qcacld-3.0: Add QDF status

Replace CDF status with QDF status

Change-Id: I7170c8ae4c5bd97a8f0f383af637bb2ec312f082
CRs-Fixed: 981188

core/bmi/inc/bmi.h

@@ -38,7 +38,7 @@
 #include "hif.h"
 
 struct ol_context;
-CDF_STATUS ol_cds_init(cdf_device_t cdf_dev, void *hif_ctx);
+QDF_STATUS ol_cds_init(cdf_device_t cdf_dev, void *hif_ctx);
 void ol_cds_free(void);
 
 /**
@@ -64,22 +64,22 @@ void ol_init_ini_config(struct ol_context *ol_ctx,
 			struct ol_config_info *cfg);
 #ifdef HIF_PCI
 void bmi_cleanup(struct ol_context *scn);
-CDF_STATUS bmi_done(struct ol_context *ol_ctx);
-CDF_STATUS bmi_download_firmware(struct ol_context *ol_ctx);
+QDF_STATUS bmi_done(struct ol_context *ol_ctx);
+QDF_STATUS bmi_download_firmware(struct ol_context *ol_ctx);
 #else
 static inline void bmi_cleanup(struct ol_context *scn)
 {
 	return;
 }
 
-static inline CDF_STATUS bmi_done(struct ol_context *ol_ctx)
+static inline QDF_STATUS bmi_done(struct ol_context *ol_ctx)
 {
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-static inline CDF_STATUS bmi_download_firmware(struct ol_context *ol_ctx)
+static inline QDF_STATUS bmi_download_firmware(struct ol_context *ol_ctx)
 {
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 #endif
 #endif /* _BMI_H_ */

core/bmi/inc/ol_fw.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2016 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -48,9 +48,9 @@
 #define AR6320_DEV_VERSION           0x1000000
 
 #ifdef HIF_PCI
-void ol_target_failure(void *instance, CDF_STATUS status);
+void ol_target_failure(void *instance, QDF_STATUS status);
 #else
-static inline void ol_target_failure(void *instance, CDF_STATUS status)
+static inline void ol_target_failure(void *instance, QDF_STATUS status)
 {
 	return;
 }

core/bmi/src/bmi.c

@@ -37,7 +37,7 @@
 /* Enable BMI_TEST COMMANDs; The Value 0x09 is randomly choosen */
 #define BMI_TEST_ENABLE (0x09)
 
-static CDF_STATUS
+static QDF_STATUS
 bmi_command_test(uint32_t command, uint32_t address, uint8_t *data,
 				uint32_t length, struct ol_context *ol_ctx)
 {
@@ -53,10 +53,10 @@ bmi_command_test(uint32_t command, uint32_t address, uint8_t *data,
 	default:
 		break;
 	}
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-CDF_STATUS bmi_init(struct ol_context *ol_ctx)
+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;
@@ -65,12 +65,12 @@ CDF_STATUS bmi_init(struct ol_context *ol_ctx)
 	if (!scn) {
 		BMI_ERR("Invalid scn Context");
 		bmi_assert(0);
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 
 	if (!cdf_dev->dev) {
 		BMI_ERR("%s: Invalid Device Pointer", __func__);
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 
 	info->bmi_done = false;
@@ -81,7 +81,7 @@ CDF_STATUS bmi_init(struct ol_context *ol_ctx)
 							&info->bmi_cmd_da, 0);
 		if (!info->bmi_cmd_buff) {
 			BMI_ERR("No Memory for BMI Command");
-			return CDF_STATUS_E_NOMEM;
+			return QDF_STATUS_E_NOMEM;
 		}
 	}
 
@@ -94,12 +94,12 @@ CDF_STATUS bmi_init(struct ol_context *ol_ctx)
 			goto end;
 		}
 	}
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 end:
 	cdf_os_mem_free_consistent(cdf_dev, MAX_BMI_CMDBUF_SZ,
 				 info->bmi_cmd_buff, info->bmi_cmd_da, 0);
 	info->bmi_cmd_buff = NULL;
-	return CDF_STATUS_E_NOMEM;
+	return QDF_STATUS_E_NOMEM;
 }
 
 void bmi_cleanup(struct ol_context *ol_ctx)
@@ -128,22 +128,22 @@ void bmi_cleanup(struct ol_context *ol_ctx)
 }
 
 
-CDF_STATUS bmi_done(struct ol_context *ol_ctx)
+QDF_STATUS bmi_done(struct ol_context *ol_ctx)
 {
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	if (NO_BMI)
 		return status;
 
 	status = bmi_done_local(ol_ctx);
 
-	if (status != CDF_STATUS_SUCCESS)
+	if (status != QDF_STATUS_SUCCESS)
 		BMI_ERR("BMI_DONE Failed status:%d", status);
 
 	return status;
 }
 
-CDF_STATUS
+QDF_STATUS
 bmi_get_target_info(struct bmi_target_info *targ_info,
 						struct ol_context *ol_ctx)
 {
@@ -158,12 +158,12 @@ bmi_get_target_info(struct bmi_target_info *targ_info,
 
 	if (info->bmi_done) {
 		BMI_ERR("BMI Phase is Already Done");
-		return CDF_STATUS_E_PERM;
+		return QDF_STATUS_E_PERM;
 	}
 
 	if (!bmi_cmd_buff || !bmi_rsp_buff) {
 		BMI_ERR("%s:BMI CMD/RSP Buffer is NULL", __func__);
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 	cid = BMI_GET_TARGET_INFO;
 
@@ -175,11 +175,11 @@ bmi_get_target_info(struct bmi_target_info *targ_info,
 					BMI_EXCHANGE_TIMEOUT_MS);
 	if (status) {
 		BMI_ERR("Failed to target info: status:%d", status);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	cdf_mem_copy(targ_info, bmi_rsp_buff, length);
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 #ifdef FEATURE_BMI_2
@@ -194,7 +194,7 @@ static inline uint32_t bmi_get_test_addr(void)
 }
 #endif
 
-CDF_STATUS bmi_download_firmware(struct ol_context *ol_ctx)
+QDF_STATUS bmi_download_firmware(struct ol_context *ol_ctx)
 {
 	uint8_t data[10], out[10];
 	uint32_t address;
@@ -202,12 +202,12 @@ CDF_STATUS bmi_download_firmware(struct ol_context *ol_ctx)
 	struct hif_opaque_softc *scn = ol_ctx->scn;
 
 	if (NO_BMI)
-		return CDF_STATUS_SUCCESS; /* no BMI for Q6 bring up */
+		return QDF_STATUS_SUCCESS; /* no BMI for Q6 bring up */
 
 	if (!scn) {
 		BMI_ERR("Invalid scn context");
 		bmi_assert(0);
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 #ifdef CONFIG_CNSS
 	if (BMI_TEST_ENABLE == cnss_get_bmi_setup()) {
@@ -215,7 +215,7 @@ CDF_STATUS bmi_download_firmware(struct ol_context *ol_ctx)
 		BMI_DBG("ret:%d writing data:%s\n", ret, data);
 		address = bmi_get_test_addr();
 
-		if (bmi_init(ol_ctx) != CDF_STATUS_SUCCESS) {
+		if (bmi_init(ol_ctx) != QDF_STATUS_SUCCESS) {
 			BMI_WARN("BMI_INIT Failed; No Memory!");
 			goto end;
 		}
@@ -229,7 +229,7 @@ end:
 	return bmi_firmware_download(ol_ctx);
 }
 
-CDF_STATUS bmi_read_soc_register(uint32_t address, uint32_t *param,
+QDF_STATUS bmi_read_soc_register(uint32_t address, uint32_t *param,
 						struct ol_context *ol_ctx)
 {
 	struct hif_opaque_softc *scn = ol_ctx->scn;
@@ -248,7 +248,7 @@ CDF_STATUS bmi_read_soc_register(uint32_t address, uint32_t *param,
 
 	if (info->bmi_done) {
 		BMI_DBG("Command disallowed");
-		return CDF_STATUS_E_PERM;
+		return QDF_STATUS_E_PERM;
 	}
 
 	BMI_DBG("BMI Read SOC Register:device: 0x%p, address: 0x%x",
@@ -266,15 +266,15 @@ CDF_STATUS bmi_read_soc_register(uint32_t address, uint32_t *param,
 			bmi_rsp_buff, &param_len, BMI_EXCHANGE_TIMEOUT_MS);
 	if (status) {
 		BMI_DBG("Unable to read from the device; status:%d", status);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 	cdf_mem_copy(param, bmi_rsp_buff, sizeof(*param));
 
 	BMI_DBG("BMI Read SOC Register: Exit value: %d", *param);
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-CDF_STATUS bmi_write_soc_register(uint32_t address, uint32_t param,
+QDF_STATUS bmi_write_soc_register(uint32_t address, uint32_t param,
 					struct ol_context *ol_ctx)
 {
 	struct hif_opaque_softc *scn = ol_ctx->scn;
@@ -292,7 +292,7 @@ CDF_STATUS bmi_write_soc_register(uint32_t address, uint32_t param,
 
 	if (info->bmi_done) {
 		BMI_DBG("Command disallowed");
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	BMI_DBG("SOC Register Write:device:0x%p, addr:0x%x, param:%d",
@@ -311,14 +311,14 @@ CDF_STATUS bmi_write_soc_register(uint32_t address, uint32_t param,
 						NULL, NULL, 0);
 	if (status) {
 		BMI_ERR("Unable to write to the device: status:%d", status);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	BMI_DBG("BMI Read SOC Register: Exit");
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-CDF_STATUS
+QDF_STATUS
 bmilz_data(uint8_t *buffer, uint32_t length, struct ol_context *ol_ctx)
 {
 	uint32_t cid;
@@ -337,7 +337,7 @@ bmilz_data(uint8_t *buffer, uint32_t length, struct ol_context *ol_ctx)
 
 	if (info->bmi_done) {
 		BMI_ERR("Command disallowed");
-		return CDF_STATUS_E_PERM;
+		return QDF_STATUS_E_PERM;
 	}
 
 	BMI_DBG("BMI Send LZ Data: device: 0x%p, length: %d",
@@ -363,17 +363,17 @@ bmilz_data(uint8_t *buffer, uint32_t length, struct ol_context *ol_ctx)
 		if (status) {
 			BMI_ERR("Failed to write to the device: status:%d",
 								status);
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 		remaining -= txlen;
 	}
 
 	BMI_DBG("BMI LZ Data: Exit");
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-CDF_STATUS bmi_sign_stream_start(uint32_t address, uint8_t *buffer,
+QDF_STATUS bmi_sign_stream_start(uint32_t address, uint8_t *buffer,
 				 uint32_t length, struct ol_context *ol_ctx)
 {
 	uint32_t cid;
@@ -394,7 +394,7 @@ CDF_STATUS bmi_sign_stream_start(uint32_t address, uint8_t *buffer,
 
 	if (info->bmi_done) {
 		BMI_ERR("Command disallowed");
-		return CDF_STATUS_E_PERM;
+		return QDF_STATUS_E_PERM;
 	}
 
 	BMI_ERR("Sign Stream start:device:0x%p, addr:0x%x, length:%d",
@@ -431,16 +431,16 @@ CDF_STATUS bmi_sign_stream_start(uint32_t address, uint8_t *buffer,
 		if (status) {
 			BMI_ERR("Unable to write to the device: status:%d",
 								status);
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 		remaining -= txlen;
 	}
 	BMI_DBG("BMI SIGN Stream Start: Exit");
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-CDF_STATUS
+QDF_STATUS
 bmilz_stream_start(uint32_t address, struct ol_context *ol_ctx)
 {
 	uint32_t cid;
@@ -457,7 +457,7 @@ bmilz_stream_start(uint32_t address, struct ol_context *ol_ctx)
 
 	if (info->bmi_done) {
 		BMI_DBG("Command disallowed");
-		return CDF_STATUS_E_PERM;
+		return QDF_STATUS_E_PERM;
 	}
 	BMI_DBG("BMI LZ Stream Start: (device: 0x%p, address: 0x%x)",
 						scn, address);
@@ -473,23 +473,23 @@ bmilz_stream_start(uint32_t address, struct ol_context *ol_ctx)
 	if (status) {
 		BMI_ERR("Unable to Start LZ Stream to the device status:%d",
 								status);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 	BMI_DBG("BMI LZ Stream: Exit");
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-CDF_STATUS
+QDF_STATUS
 bmi_fast_download(uint32_t address, uint8_t *buffer,
 		  uint32_t length, struct ol_context *ol_ctx)
 {
-	CDF_STATUS status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
 	uint32_t last_word = 0;
 	uint32_t last_word_offset = length & ~0x3;
 	uint32_t unaligned_bytes = length & 0x3;
 
 	status = bmilz_stream_start(address, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS)
+	if (status != QDF_STATUS_SUCCESS)
 		goto end;
 
 	/* copy the last word into a zero padded buffer */
@@ -499,13 +499,13 @@ bmi_fast_download(uint32_t address, uint8_t *buffer,
 
 	status = bmilz_data(buffer, last_word_offset, ol_ctx);
 
-	if (status != CDF_STATUS_SUCCESS)
+	if (status != QDF_STATUS_SUCCESS)
 		goto end;
 
 	if (unaligned_bytes)
 		status = bmilz_data((uint8_t *) &last_word, 4, ol_ctx);
 
-	if (status != CDF_STATUS_SUCCESS)
+	if (status != QDF_STATUS_SUCCESS)
 		/*
 		 * Close compressed stream and open a new (fake) one.
 		 * This serves mainly to flush Target caches.
@@ -517,23 +517,23 @@ end:
 
 /**
  * ol_cds_init() - API to initialize global CDS OL Context
- * @cdf_dev: CDF Device
+ * @cdf_dev: QDF Device
  * @hif_ctx: HIF Context
  *
  * Return: Success/Failure
  */
-CDF_STATUS ol_cds_init(cdf_device_t cdf_dev, void *hif_ctx)
+QDF_STATUS ol_cds_init(cdf_device_t cdf_dev, void *hif_ctx)
 {
 	struct ol_context *ol_info;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	if (NO_BMI)
-		return CDF_STATUS_SUCCESS; /* no BMI for Q6 bring up */
+		return QDF_STATUS_SUCCESS; /* no BMI for Q6 bring up */
 
-	status = cds_alloc_context(cds_get_global_context(), CDF_MODULE_ID_BMI,
+	status = cds_alloc_context(cds_get_global_context(), QDF_MODULE_ID_BMI,
 					(void **)&ol_info, sizeof(*ol_info));
 
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("%s: CDS Allocation failed for ol_bmi context",
 								__func__);
 		return status;
@@ -555,10 +555,10 @@ CDF_STATUS ol_cds_init(cdf_device_t cdf_dev, void *hif_ctx)
  */
 void ol_cds_free(void)
 {
-	struct ol_context *ol_info = cds_get_context(CDF_MODULE_ID_BMI);
+	struct ol_context *ol_info = cds_get_context(QDF_MODULE_ID_BMI);
 
 	if (NO_BMI)
 		return;
 
-	cds_free_context(cds_get_global_context(), CDF_MODULE_ID_BMI, ol_info);
+	cds_free_context(cds_get_global_context(), QDF_MODULE_ID_BMI, ol_info);
 }

core/bmi/src/bmi_1.c

@@ -30,7 +30,7 @@
 
 /* APIs visible to the driver */
 
-CDF_STATUS
+QDF_STATUS
 bmi_read_memory(uint32_t address,
 		uint8_t *buffer, uint32_t length, struct ol_context *ol_ctx)
 {
@@ -48,12 +48,12 @@ bmi_read_memory(uint32_t address,
 
 	if (info->bmi_done) {
 		BMI_DBG("command disallowed");
-		return CDF_STATUS_E_PERM;
+		return QDF_STATUS_E_PERM;
 	}
 
 	if (!info->bmi_cmd_buff || !info->bmi_rsp_buff) {
 		BMI_ERR("BMI Initialization hasn't done");
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 
 	bmi_assert(BMI_COMMAND_FITS(BMI_DATASZ_MAX + sizeof(cid) +
@@ -88,7 +88,7 @@ bmi_read_memory(uint32_t address,
 						BMI_EXCHANGE_TIMEOUT_MS);
 		if (status) {
 			BMI_ERR("Unable to read from the device");
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 		if (remaining == rxlen) {
 			cdf_mem_copy(&buffer[length - remaining + align],
@@ -103,10 +103,10 @@ bmi_read_memory(uint32_t address,
 	}
 
 	BMI_DBG("BMI Read Memory: Exit");
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-CDF_STATUS bmi_write_memory(uint32_t address, uint8_t *buffer, uint32_t length,
+QDF_STATUS bmi_write_memory(uint32_t address, uint8_t *buffer, uint32_t length,
 						struct ol_context *ol_ctx)
 {
 	struct hif_opaque_softc *scn = ol_ctx->scn;
@@ -124,12 +124,12 @@ CDF_STATUS bmi_write_memory(uint32_t address, uint8_t *buffer, uint32_t length,
 
 	if (info->bmi_done) {
 		BMI_ERR("Command disallowed");
-		return CDF_STATUS_E_PERM;
+		return QDF_STATUS_E_PERM;
 	}
 
 	if (!bmi_cmd_buff) {
 		BMI_ERR("BMI initialization hasn't done");
-		return CDF_STATUS_E_PERM;
+		return QDF_STATUS_E_PERM;
 	}
 
 	bmi_assert(BMI_COMMAND_FITS(BMI_DATASZ_MAX + header));
@@ -170,7 +170,7 @@ CDF_STATUS bmi_write_memory(uint32_t address, uint8_t *buffer, uint32_t length,
 		if (status) {
 			BMI_ERR("Unable to write to the device; status:%d",
 								status);
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 		remaining -= txlen;
 		address += txlen;
@@ -178,10 +178,10 @@ CDF_STATUS bmi_write_memory(uint32_t address, uint8_t *buffer, uint32_t length,
 
 	BMI_DBG("BMI Write Memory: Exit");
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-CDF_STATUS
+QDF_STATUS
 bmi_execute(uint32_t address, A_UINT32 *param, struct ol_context *ol_ctx)
 {
 	struct hif_opaque_softc *scn = ol_ctx->scn;
@@ -198,12 +198,12 @@ bmi_execute(uint32_t address, A_UINT32 *param, struct ol_context *ol_ctx)
 
 	if (info->bmi_done) {
 		BMI_ERR("Command disallowed");
-		return CDF_STATUS_E_PERM;
+		return QDF_STATUS_E_PERM;
 	}
 
 	if (!bmi_cmd_buff || !bmi_rsp_buff) {
 		BMI_ERR("%s:BMI CMD/RSP Buffer is NULL", __func__);
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 
 	bmi_assert(BMI_COMMAND_FITS(size));
@@ -228,40 +228,40 @@ bmi_execute(uint32_t address, A_UINT32 *param, struct ol_context *ol_ctx)
 					bmi_rsp_buff, &param_len, 0);
 	if (status) {
 		BMI_ERR("Unable to read from the device status:%d", status);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	cdf_mem_copy(param, bmi_rsp_buff, sizeof(*param));
 
 	BMI_DBG("BMI Execute: Exit (param: %d)", *param);
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-inline CDF_STATUS
+inline QDF_STATUS
 bmi_no_command(struct ol_context *ol_ctx)
 {
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-CDF_STATUS
+QDF_STATUS
 bmi_firmware_download(struct ol_context *ol_ctx)
 {
 	struct hif_opaque_softc *scn = ol_ctx->scn;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	struct bmi_target_info targ_info;
 	struct hif_target_info *tgt_info = hif_get_target_info_handle(scn);
 
 	cdf_mem_zero(&targ_info, sizeof(targ_info));
 	/* Initialize BMI */
 	status = bmi_init(ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("BMI Initialization Failed err:%d", status);
 		return status;
 	}
 
 	/* Get target information */
 	status = bmi_get_target_info(&targ_info, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("BMI Target Info get failed: status:%d", status);
 		return status;
 	}
@@ -271,19 +271,19 @@ bmi_firmware_download(struct ol_context *ol_ctx)
 
 	/* Configure target */
 	status = ol_configure_target(ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("BMI Configure Target Failed status:%d", status);
 		return status;
 	}
 
 	status = ol_download_firmware(ol_ctx);
-	if (status != CDF_STATUS_SUCCESS)
+	if (status != QDF_STATUS_SUCCESS)
 		BMI_ERR("BMI Download Firmware Failed Status:%d", status);
 
 	return status;
 }
 
-CDF_STATUS bmi_done_local(struct ol_context *ol_ctx)
+QDF_STATUS bmi_done_local(struct ol_context *ol_ctx)
 {
 	struct hif_opaque_softc *scn = ol_ctx->scn;
 	int status;
@@ -295,18 +295,18 @@ CDF_STATUS bmi_done_local(struct ol_context *ol_ctx)
 	if (!scn) {
 		BMI_ERR("Invalid scn context");
 		bmi_assert(0);
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 
 	if (!cdf_dev->dev) {
 		BMI_ERR("%s: Invalid device pointer", __func__);
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 
 	info = GET_BMI_CONTEXT(ol_ctx);
 	if (info->bmi_done) {
 		BMI_DBG("bmi_done_local skipped");
-		return CDF_STATUS_E_PERM;
+		return QDF_STATUS_E_PERM;
 	}
 
 	cmd = info->bmi_cmd_da;
@@ -320,7 +320,7 @@ CDF_STATUS bmi_done_local(struct ol_context *ol_ctx)
 	if (!info->bmi_cmd_buff) {
 		BMI_ERR("Invalid scn BMICmdBuff");
 		bmi_assert(0);
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 
 	cdf_mem_copy(info->bmi_cmd_buff, &cid, sizeof(cid));
@@ -329,7 +329,7 @@ CDF_STATUS bmi_done_local(struct ol_context *ol_ctx)
 				sizeof(cid), NULL, NULL, 0);
 	if (status) {
 		BMI_ERR("Failed to write to the device; status:%d", status);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	if (info->bmi_cmd_buff) {
@@ -346,5 +346,5 @@ CDF_STATUS bmi_done_local(struct ol_context *ol_ctx)
 		info->bmi_rsp_da = 0;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }

core/bmi/src/bmi_2.c

@@ -33,7 +33,7 @@
  */
 #define BMI_LOAD_IMAGE              18
 
-CDF_STATUS
+QDF_STATUS
 bmi_no_command(struct ol_context *ol_ctx)
 {
 	struct hif_opaque_softc *scn = ol_ctx->scn;
@@ -49,12 +49,12 @@ bmi_no_command(struct ol_context *ol_ctx)
 
 	if (info->bmi_done) {
 		BMI_ERR("Command disallowed: BMI DONE ALREADY");
-		return CDF_STATUS_E_PERM;
+		return QDF_STATUS_E_PERM;
 	}
 
 	if (!bmi_cmd_buff || !bmi_rsp_buff) {
 		BMI_ERR("No Memory Allocated for BMI CMD/RSP Buffer");
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 	cid = BMI_NO_COMMAND;
 
@@ -66,18 +66,18 @@ bmi_no_command(struct ol_context *ol_ctx)
 
 	if (status) {
 		BMI_ERR("Failed to write bmi no command status:%d", status);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	cdf_mem_copy(&ret, bmi_rsp_buff, length);
 	if (ret != 0) {
 		BMI_ERR("bmi no command response error ret 0x%x", ret);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-CDF_STATUS
+QDF_STATUS
 bmi_done_local(struct ol_context *ol_ctx)
 {
 	struct hif_opaque_softc *scn = ol_ctx->scn;
@@ -94,17 +94,17 @@ bmi_done_local(struct ol_context *ol_ctx)
 
 	if (info->bmi_done) {
 		BMI_ERR("Command disallowed");
-		return CDF_STATUS_E_PERM;
+		return QDF_STATUS_E_PERM;
 	}
 
 	if (!bmi_cmd_buff || !bmi_rsp_buff) {
 		BMI_ERR("No Memory Allocated for BMI CMD/RSP Buffer");
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 
 	if (!cdf_dev->dev) {
 		BMI_ERR("%s Invalid Device pointer", __func__);
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 
 	cid = BMI_DONE;
@@ -117,13 +117,13 @@ bmi_done_local(struct ol_context *ol_ctx)
 
 	if (status) {
 		BMI_ERR("Failed to close BMI on target status:%d", status);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 	cdf_mem_copy(&ret, bmi_rsp_buff, length);
 
 	if (ret != 0) {
 		BMI_ERR("BMI DONE response failed:%d", ret);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	if (info->bmi_cmd_buff) {
@@ -140,10 +140,10 @@ bmi_done_local(struct ol_context *ol_ctx)
 		info->bmi_rsp_da = 0;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-CDF_STATUS bmi_write_memory(uint32_t address, uint8_t *buffer, uint32_t length,
+QDF_STATUS bmi_write_memory(uint32_t address, uint8_t *buffer, uint32_t length,
 			    struct ol_context *ol_ctx)
 {
 	uint32_t cid;
@@ -164,12 +164,12 @@ CDF_STATUS bmi_write_memory(uint32_t address, uint8_t *buffer, uint32_t length,
 
 	if (info->bmi_done) {
 		BMI_ERR("Command disallowed");
-		return CDF_STATUS_E_PERM;
+		return QDF_STATUS_E_PERM;
 	}
 
 	if (!bmi_cmd_buff || !bmi_rsp_buff) {
 		BMI_ERR("BMI Initialization is not happened");
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 
 	bmi_assert(BMI_COMMAND_FITS(BMI_DATASZ_MAX + header));
@@ -207,20 +207,20 @@ CDF_STATUS bmi_write_memory(uint32_t address, uint8_t *buffer, uint32_t length,
 						BMI_EXCHANGE_TIMEOUT_MS);
 		if (status) {
 			BMI_ERR("BMI Write Memory Failed status:%d", status);
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 		cdf_mem_copy(&ret, bmi_rsp_buff, rsp_len);
 		if (ret != 0) {
 			BMI_ERR("BMI Write memory response fail: %x", ret);
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 		remaining -= txlen; address += txlen;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-CDF_STATUS
+QDF_STATUS
 bmi_read_memory(uint32_t address, uint8_t *buffer,
 		uint32_t length, struct ol_context *ol_ctx)
 {
@@ -240,11 +240,11 @@ bmi_read_memory(uint32_t address, uint8_t *buffer,
 
 	if (info->bmi_done) {
 		BMI_ERR("Command disallowed");
-		return CDF_STATUS_E_PERM;
+		return QDF_STATUS_E_PERM;
 	}
 	if (!bmi_cmd_buff || !bmi_rsp_buff) {
 		BMI_ERR("BMI Initialization is not done");
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 
 	bmi_assert(BMI_COMMAND_FITS(BMI_DATASZ_MAX + size));
@@ -278,14 +278,14 @@ bmi_read_memory(uint32_t address, uint8_t *buffer,
 
 		if (status) {
 			BMI_ERR("BMI Read memory failed status:%d", status);
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 
 		cdf_mem_copy(&ret, bmi_rsp_buff, rsp_len);
 
 		if (ret != 0) {
 			BMI_ERR("bmi read memory response fail %x", ret);
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 
 		cdf_mem_copy(&buffer[length - remaining],
@@ -293,10 +293,10 @@ bmi_read_memory(uint32_t address, uint8_t *buffer,
 		remaining -= rxlen; address += rxlen;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-CDF_STATUS
+QDF_STATUS
 bmi_execute(uint32_t address, uint32_t *param, struct ol_context *ol_ctx)
 {
 	struct hif_opaque_softc *scn = ol_ctx->scn;
@@ -312,12 +312,12 @@ bmi_execute(uint32_t address, uint32_t *param, struct ol_context *ol_ctx)
 
 	if (info->bmi_done) {
 		BMI_ERR("Command disallowed");
-		return CDF_STATUS_E_PERM;
+		return QDF_STATUS_E_PERM;
 	}
 
 	if (!bmi_cmd_buff || !bmi_rsp_buff) {
 		BMI_ERR("No Memory Allocated for bmi buffers");
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 
 	cid = BMI_EXECUTE;
@@ -330,24 +330,24 @@ bmi_execute(uint32_t address, uint32_t *param, struct ol_context *ol_ctx)
 
 	if (status) {
 		BMI_ERR("Failed to do BMI_EXECUTE status:%d", status);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	cdf_mem_copy(&ret, bmi_rsp_buff, length);
 
 	if (ret != 0) {
 		BMI_ERR("%s: ret 0x%x", __func__, ret);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-static CDF_STATUS
+static QDF_STATUS
 bmi_load_image(dma_addr_t address,
 		uint32_t size, struct ol_context *ol_ctx)
 {
 	uint32_t cid;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	uint32_t offset;
 	uint32_t length;
 	uint8_t ret = 0;
@@ -362,12 +362,12 @@ bmi_load_image(dma_addr_t address,
 
 	if (info->bmi_done) {
 		BMI_ERR("Command disallowed");
-		return CDF_STATUS_E_PERM;
+		return QDF_STATUS_E_PERM;
 	}
 
 	if (!bmi_cmd_buff || !bmi_rsp_buff) {
 		BMI_ERR("No Memory Allocated for BMI CMD/RSP Buffer");
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 
 	bmi_assert(BMI_COMMAND_FITS(sizeof(cid) + sizeof(address)));
@@ -396,41 +396,41 @@ bmi_load_image(dma_addr_t address,
 
 	if (status) {
 		BMI_ERR("BMI Load Image Failed; status:%d", status);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	cdf_mem_copy(&ret, bmi_rsp_buff, length);
 	if (ret != 0) {
 		BMI_ERR("%s: ret 0x%x", __func__, ret);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-static CDF_STATUS bmi_enable(struct ol_context *ol_ctx)
+static QDF_STATUS bmi_enable(struct ol_context *ol_ctx)
 {
 	struct hif_opaque_softc *scn = ol_ctx->scn;
 	struct bmi_target_info targ_info;
 	struct image_desc_info image_desc_info;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	struct hif_target_info *tgt_info;
 	struct bmi_info *info = GET_BMI_CONTEXT(ol_ctx);
 
 	if (!scn) {
 		BMI_ERR("Invalid scn context");
 		bmi_assert(0);
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 
 	tgt_info = hif_get_target_info_handle(scn);
 
 	if (info->bmi_cmd_buff == NULL || info->bmi_rsp_buff == NULL) {
 		BMI_ERR("bmi_open failed!");
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 
 	status = bmi_get_target_info(&targ_info, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS)
+	if (status != QDF_STATUS_SUCCESS)
 			return status;
 
 	BMI_DBG("%s: target type 0x%x, target ver 0x%x", __func__,
@@ -441,13 +441,13 @@ static CDF_STATUS bmi_enable(struct ol_context *ol_ctx)
 
 	if (cnss_get_fw_image(&image_desc_info) != 0) {
 		BMI_ERR("Failed to get fw image");
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	status = bmi_load_image(image_desc_info.bdata_addr,
 				image_desc_info.bdata_size,
 				ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Load board data failed! status:%d", status);
 		return status;
 	}
@@ -455,27 +455,27 @@ static CDF_STATUS bmi_enable(struct ol_context *ol_ctx)
 	status = bmi_load_image(image_desc_info.fw_addr,
 				image_desc_info.fw_size,
 				ol_ctx);
-	if (status != CDF_STATUS_SUCCESS)
+	if (status != QDF_STATUS_SUCCESS)
 		BMI_ERR("Load fw image failed! status:%d", status);
 
 	return status;
 }
 
-CDF_STATUS bmi_firmware_download(struct ol_context *ol_ctx)
+QDF_STATUS bmi_firmware_download(struct ol_context *ol_ctx)
 {
-	CDF_STATUS status;
+	QDF_STATUS status;
 
 	if (NO_BMI)
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 
 	status = bmi_init(ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("BMI_INIT Failed status:%d", status);
 		goto end;
 	}
 
 	status = bmi_enable(ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("BMI_ENABLE failed status:%d\n", status);
 		goto err_bmi_enable;
 	}

core/bmi/src/i_bmi.h

@@ -75,16 +75,16 @@
 
 /* BMI LOGGING WRAPPERS */
 
-#define BMI_LOG(level, args...) CDF_TRACE(CDF_MODULE_ID_BMI, \
+#define BMI_LOG(level, args...) QDF_TRACE(QDF_MODULE_ID_BMI, \
 					level, ##args)
-#define BMI_ERR(args ...)	BMI_LOG(CDF_TRACE_LEVEL_ERROR, args)
-#define BMI_DBG(args ...)	BMI_LOG(CDF_TRACE_LEVEL_DEBUG, args)
-#define BMI_WARN(args ...)	BMI_LOG(CDF_TRACE_LEVEL_WARN, args)
-#define BMI_INFO(args ...)	BMI_LOG(CDF_TRACE_LEVEL_INFO, args)
+#define BMI_ERR(args ...)	BMI_LOG(QDF_TRACE_LEVEL_ERROR, args)
+#define BMI_DBG(args ...)	BMI_LOG(QDF_TRACE_LEVEL_DEBUG, args)
+#define BMI_WARN(args ...)	BMI_LOG(QDF_TRACE_LEVEL_WARN, args)
+#define BMI_INFO(args ...)	BMI_LOG(QDF_TRACE_LEVEL_INFO, args)
 /* End of BMI Logging Wrappers */
 
 /* BMI Assert Wrappers */
-#define bmi_assert CDF_BUG
+#define bmi_assert QDF_BUG
 /*
  * Although we had envisioned BMI to run on top of HTC, this is not how the
  * final implementation ended up. On the Target side, BMI is a part of the BSP
@@ -146,7 +146,7 @@ struct bmi_info {
  * struct ol_context - Structure to hold OL context
  * @bmi: BMI info
  * @cal_in_flash: For Firmware Flash Download
- * @cdf_dev: CDF Device
+ * @cdf_dev: QDF Device
  * @scn: HIF Context
  * @ramdump_work: WorkQueue for Ramdump collection
  * @tgt_def: Target Defnition pointer
@@ -167,26 +167,26 @@ struct ol_context {
 
 #define GET_BMI_CONTEXT(ol_ctx) ((struct bmi_info *)ol_ctx)
 
-CDF_STATUS bmi_execute(uint32_t address, uint32_t *param,
+QDF_STATUS bmi_execute(uint32_t address, uint32_t *param,
 				struct ol_context *ol_ctx);
-CDF_STATUS bmi_init(struct ol_context *ol_ctx);
-CDF_STATUS bmi_no_command(struct ol_context *ol_ctx);
-CDF_STATUS bmi_read_memory(uint32_t address, uint8_t *buffer, uint32_t length,
+QDF_STATUS bmi_init(struct ol_context *ol_ctx);
+QDF_STATUS bmi_no_command(struct ol_context *ol_ctx);
+QDF_STATUS bmi_read_memory(uint32_t address, uint8_t *buffer, uint32_t length,
 					struct ol_context *ol_ctx);
-CDF_STATUS bmi_write_memory(uint32_t address, uint8_t *buffer, uint32_t length,
+QDF_STATUS bmi_write_memory(uint32_t address, uint8_t *buffer, uint32_t length,
 					struct ol_context *ol_ctx);
-CDF_STATUS bmi_fast_download(uint32_t address, uint8_t *buffer, uint32_t length,
+QDF_STATUS bmi_fast_download(uint32_t address, uint8_t *buffer, uint32_t length,
 					struct ol_context *ol_ctx);
-CDF_STATUS bmi_read_soc_register(uint32_t address,
+QDF_STATUS bmi_read_soc_register(uint32_t address,
 				uint32_t *param, struct ol_context *ol_ctx);
-CDF_STATUS bmi_write_soc_register(uint32_t address, uint32_t param,
+QDF_STATUS bmi_write_soc_register(uint32_t address, uint32_t param,
 					struct ol_context *ol_ctx);
-CDF_STATUS bmi_get_target_info(struct bmi_target_info *targ_info,
+QDF_STATUS bmi_get_target_info(struct bmi_target_info *targ_info,
 			       struct ol_context *ol_ctx);
-CDF_STATUS bmi_firmware_download(struct ol_context *ol_ctx);
-CDF_STATUS bmi_done_local(struct ol_context *ol_ctx);
-CDF_STATUS ol_download_firmware(struct ol_context *ol_ctx);
-CDF_STATUS ol_configure_target(struct ol_context *ol_ctx);
+QDF_STATUS bmi_firmware_download(struct ol_context *ol_ctx);
+QDF_STATUS bmi_done_local(struct ol_context *ol_ctx);
+QDF_STATUS ol_download_firmware(struct ol_context *ol_ctx);
+QDF_STATUS ol_configure_target(struct ol_context *ol_ctx);
 void ramdump_work_handler(void *arg);
 struct ol_config_info *ol_get_ini_handle(struct ol_context *ol_ctx);
 #endif

core/bmi/src/ol_fw.c

@@ -124,7 +124,7 @@ static int ol_check_fw_hash(const u8 *data, u32 fw_size, ATH_BIN_FILE file)
 				   digest, SHA256_DIGEST_SIZE);
 		cdf_trace_hex_dump(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_FATAL,
 				   hash, SHA256_DIGEST_SIZE);
-		ret = CDF_STATUS_E_FAILURE;
+		ret = QDF_STATUS_E_FAILURE;
 	}
 #endif
 end:
@@ -280,7 +280,7 @@ __ol_transfer_bin_file(struct ol_context *ol_ctx, ATH_BIN_FILE file,
 
 	if (!fw_entry || !fw_entry->data) {
 		BMI_ERR("Invalid fw_entries");
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	fw_entry_size = fw_entry->size;
@@ -290,7 +290,7 @@ __ol_transfer_bin_file(struct ol_context *ol_ctx, ATH_BIN_FILE file,
 
 	if (ol_check_fw_hash(fw_entry->data, fw_entry_size, file)) {
 		BMI_ERR("Hash Check failed for file:%s", filename);
-		status = CDF_STATUS_E_FAILURE;
+		status = QDF_STATUS_E_FAILURE;
 		goto end;
 	}
 #endif
@@ -303,7 +303,7 @@ __ol_transfer_bin_file(struct ol_context *ol_ctx, ATH_BIN_FILE file,
 		if (!temp_eeprom) {
 			BMI_ERR("%s: Memory allocation failed", __func__);
 			release_firmware(fw_entry);
-			return CDF_STATUS_E_NOMEM;
+			return QDF_STATUS_E_NOMEM;
 		}
 
 		cdf_mem_copy(temp_eeprom, (uint8_t *) fw_entry->data,
@@ -363,7 +363,7 @@ __ol_transfer_bin_file(struct ol_context *ol_ctx, ATH_BIN_FILE file,
 
 		if (fw_entry_size < sizeof(SIGN_HEADER_T)) {
 			BMI_ERR("Invalid binary size %d", fw_entry_size);
-			status = CDF_STATUS_E_FAILURE;
+			status = QDF_STATUS_E_FAILURE;
 			goto end;
 		}
 
@@ -379,7 +379,7 @@ __ol_transfer_bin_file(struct ol_context *ol_ctx, ATH_BIN_FILE file,
 						sizeof(SIGN_HEADER_T), ol_ctx);
 			if (status != EOK) {
 				BMI_ERR("unable to start sign stream");
-				status = CDF_STATUS_E_FAILURE;
+				status = QDF_STATUS_E_FAILURE;
 				goto end;
 			}
 
@@ -449,7 +449,7 @@ end:
 	if (status != EOK) {
 		BMI_ERR("%s, BMI operation failed: %d", __func__, __LINE__);
 		release_firmware(fw_entry);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	release_firmware(fw_entry);
@@ -558,7 +558,7 @@ void ramdump_work_handler(void *data)
 			hif_hia_item_address(target_type,
 			offsetof(struct host_interest_s, hi_failure_state)),
 			(uint8_t *)&host_interest_address,
-			sizeof(uint32_t)) != CDF_STATUS_SUCCESS) {
+			sizeof(uint32_t)) != QDF_STATUS_SUCCESS) {
 		BMI_ERR("HifDiagReadiMem FW Dump Area Pointer failed!");
 		ol_copy_ramdump(ramdump_scn);
 		cnss_device_crashed();
@@ -569,7 +569,7 @@ void ramdump_work_handler(void *data)
 
 	if (hif_diag_read_mem(ramdump_scn, host_interest_address,
 			      (uint8_t *) &dram_dump_values[0],
-			      4 * sizeof(uint32_t)) != CDF_STATUS_SUCCESS) {
+			      4 * sizeof(uint32_t)) != QDF_STATUS_SUCCESS) {
 		BMI_ERR("HifDiagReadiMem FW Dump Area failed!");
 		goto out_fail;
 	}
@@ -607,7 +607,7 @@ void ol_schedule_fw_indication_work(struct hif_opaque_softc *scn)
 }
 #endif
 
-void ol_target_failure(void *instance, CDF_STATUS status)
+void ol_target_failure(void *instance, QDF_STATUS status)
 {
 	struct ol_context *ol_ctx = instance;
 	struct hif_opaque_softc *scn = ol_ctx->scn;
@@ -663,7 +663,7 @@ void ol_target_failure(void *instance, CDF_STATUS status)
 	return;
 }
 
-CDF_STATUS ol_configure_target(struct ol_context *ol_ctx)
+QDF_STATUS ol_configure_target(struct ol_context *ol_ctx)
 {
 	uint32_t param;
 #ifdef CONFIG_CNSS
@@ -680,18 +680,18 @@ CDF_STATUS ol_configure_target(struct ol_context *ol_ctx)
 	if (bmi_write_memory(
 		hif_hia_item_address(target_type,
 		offsetof(struct host_interest_s, hi_app_host_interest)),
-		(uint8_t *) &param, 4, ol_ctx) != CDF_STATUS_SUCCESS) {
+		(uint8_t *) &param, 4, ol_ctx) != QDF_STATUS_SUCCESS) {
 		BMI_ERR("bmi_write_memory for htc version failed");
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	/* set the firmware mode to STA/IBSS/AP */
 	{
 		if (bmi_read_memory(hif_hia_item_address(target_type,
 			offsetof(struct host_interest_s, hi_option_flag)),
-			(uint8_t *)&param, 4, ol_ctx) != CDF_STATUS_SUCCESS) {
+			(uint8_t *)&param, 4, ol_ctx) != QDF_STATUS_SUCCESS) {
 			BMI_ERR("bmi_read_memory for setting fwmode failed");
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 
 		/* TODO following parameters need to be re-visited. */
@@ -711,9 +711,9 @@ CDF_STATUS ol_configure_target(struct ol_context *ol_ctx)
 		if (bmi_write_memory(
 			hif_hia_item_address(target_type,
 			offsetof(struct host_interest_s, hi_option_flag)),
-			(uint8_t *)&param, 4, ol_ctx) != CDF_STATUS_SUCCESS) {
+			(uint8_t *)&param, 4, ol_ctx) != QDF_STATUS_SUCCESS) {
 			BMI_ERR("BMI WRITE for setting fwmode failed");
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 	}
 
@@ -722,18 +722,18 @@ CDF_STATUS ol_configure_target(struct ol_context *ol_ctx)
 		/* set the firmware to disable CDC max perf WAR */
 		if (bmi_read_memory(hif_hia_item_address(target_type,
 			offsetof(struct host_interest_s, hi_option_flag2)),
-			(uint8_t *) &param, 4, ol_ctx) != CDF_STATUS_SUCCESS) {
+			(uint8_t *) &param, 4, ol_ctx) != QDF_STATUS_SUCCESS) {
 			BMI_ERR("BMI READ for setting cdc max perf failed");
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 
 		param |= HI_OPTION_DISABLE_CDC_MAX_PERF_WAR;
 		if (bmi_write_memory(
 			hif_hia_item_address(target_type,
 			offsetof(struct host_interest_s, hi_option_flag2)),
-			(uint8_t *)&param, 4, ol_ctx) != CDF_STATUS_SUCCESS) {
+			(uint8_t *)&param, 4, ol_ctx) != QDF_STATUS_SUCCESS) {
 			BMI_ERR("setting cdc max perf failed");
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 	}
 #endif /* CONFIG_CDC_MAX_PERF_WAR */
@@ -747,19 +747,19 @@ CDF_STATUS ol_configure_target(struct ol_context *ol_ctx)
 	if (!ret && cap.cap_flag & CNSS_HAS_EXTERNAL_SWREG) {
 		if (bmi_read_memory(hif_hia_item_address(target_type,
 			offsetof(struct host_interest_s, hi_option_flag2)),
-			(uint8_t *)&param, 4, ol_ctx) != CDF_STATUS_SUCCESS) {
+			(uint8_t *)&param, 4, ol_ctx) != QDF_STATUS_SUCCESS) {
 			BMI_ERR("bmi_read_memory for setting"
 				"external SWREG failed");
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 
 		param |= HI_OPTION_USE_EXT_LDO;
 		if (bmi_write_memory(
 			hif_hia_item_address(target_type,
 			offsetof(struct host_interest_s, hi_option_flag2)),
-			(uint8_t *)&param, 4, ol_ctx) != CDF_STATUS_SUCCESS) {
+			(uint8_t *)&param, 4, ol_ctx) != QDF_STATUS_SUCCESS) {
 			BMI_ERR("BMI WRITE for setting external SWREG fail");
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 	}
 #endif
@@ -768,18 +768,18 @@ CDF_STATUS ol_configure_target(struct ol_context *ol_ctx)
 	if (ini_cfg->enable_lpass_support) {
 		if (bmi_read_memory(hif_hia_item_address(target_type,
 			offsetof(struct host_interest_s, hi_option_flag2)),
-			(uint8_t *) &param, 4, ol_ctx) != CDF_STATUS_SUCCESS) {
+			(uint8_t *) &param, 4, ol_ctx) != QDF_STATUS_SUCCESS) {
 			BMI_ERR("BMI READ:Setting LPASS Support failed");
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 
 		param |= HI_OPTION_DBUART_SUPPORT;
 		if (bmi_write_memory(
 			hif_hia_item_address(target_type,
 			offsetof(struct host_interest_s, hi_option_flag2)),
-			(uint8_t *)&param, 4, ol_ctx) != CDF_STATUS_SUCCESS) {
+			(uint8_t *)&param, 4, ol_ctx) != QDF_STATUS_SUCCESS) {
 			BMI_ERR("BMI_READ for setting LPASS Support fail");
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 	}
 #endif
@@ -794,9 +794,9 @@ CDF_STATUS ol_configure_target(struct ol_context *ol_ctx)
 		if (bmi_write_memory(
 			hif_hia_item_address(target_type,
 			offsetof(struct host_interest_s, hi_be)),
-			(uint8_t *) &param, 4, ol_ctx) != CDF_STATUS_SUCCESS) {
+			(uint8_t *) &param, 4, ol_ctx) != QDF_STATUS_SUCCESS) {
 			BMI_ERR("setting host CPU BE mode failed");
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 	}
 
@@ -805,12 +805,12 @@ CDF_STATUS ol_configure_target(struct ol_context *ol_ctx)
 	if (bmi_write_memory(
 		hif_hia_item_address(target_type,
 		offsetof(struct host_interest_s, hi_fw_swap)),
-		(uint8_t *) &param, 4, ol_ctx) != CDF_STATUS_SUCCESS) {
+		(uint8_t *) &param, 4, ol_ctx) != QDF_STATUS_SUCCESS) {
 		BMI_ERR("BMI WRITE failed setting FW data/desc swap flags");
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 static int
@@ -821,11 +821,11 @@ ol_check_dataset_patch(struct hif_opaque_softc *scn, uint32_t *address)
 }
 
 
-CDF_STATUS ol_fw_populate_clk_settings(A_refclk_speed_t refclk,
+QDF_STATUS ol_fw_populate_clk_settings(A_refclk_speed_t refclk,
 				     struct cmnos_clock_s *clock_s)
 {
 	if (!clock_s)
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
 	switch (refclk) {
 	case SOC_REFCLK_48_MHZ:
@@ -876,20 +876,20 @@ CDF_STATUS ol_fw_populate_clk_settings(A_refclk_speed_t refclk,
 		clock_s->pll_settling_time = 1024;
 		clock_s->refclk_hz = 0;
 	default:
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	clock_s->refclk_hz = refclk_speed_to_hz[refclk];
 	clock_s->wlan_pll.refdiv = 0;
 	clock_s->wlan_pll.outdiv = 1;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
+QDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 {
 	struct hif_opaque_softc *hif = ol_ctx->scn;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	uint32_t addr = 0;
 	uint32_t reg_val = 0;
 	uint32_t mem_val = 0;
@@ -927,14 +927,14 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 
 	addr = (RTC_SOC_BASE_ADDRESS | EFUSE_OFFSET);
 	status = bmi_read_soc_register(addr, &reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to read EFUSE Addr");
 		goto end;
 	}
 
 	status = ol_fw_populate_clk_settings(EFUSE_XTAL_SEL_GET(reg_val),
 					     &clock_s);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to set clock settings");
 		goto end;
 	}
@@ -944,7 +944,7 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 	reg_val = 0;
 	addr = (RTC_SOC_BASE_ADDRESS | BB_PLL_CONFIG_OFFSET);
 	status = bmi_read_soc_register(addr, &reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to read PLL_CONFIG Addr");
 		goto end;
 	}
@@ -954,14 +954,14 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 	reg_val |= (BB_PLL_CONFIG_FRAC_SET(clock_s.wlan_pll.rnfrac) |
 		    BB_PLL_CONFIG_OUTDIV_SET(clock_s.wlan_pll.outdiv));
 	status = bmi_write_soc_register(addr, reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to write PLL_CONFIG Addr");
 		goto end;
 	}
 
 	reg_val = 0;
 	status = bmi_read_soc_register(addr, &reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to read back PLL_CONFIG Addr");
 		goto end;
 	}
@@ -971,7 +971,7 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 	reg_val = 0;
 	addr = (RTC_WMAC_BASE_ADDRESS | WLAN_PLL_SETTLE_OFFSET);
 	status = bmi_read_soc_register(addr, &reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to read PLL_SETTLE Addr");
 		goto end;
 	}
@@ -980,14 +980,14 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 	reg_val &= ~WLAN_PLL_SETTLE_TIME_MASK;
 	reg_val |= WLAN_PLL_SETTLE_TIME_SET(clock_s.pll_settling_time);
 	status = bmi_write_soc_register(addr, reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to write PLL_SETTLE Addr");
 		goto end;
 	}
 
 	reg_val = 0;
 	status = bmi_read_soc_register(addr, &reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to read back PLL_SETTLE Addr");
 		goto end;
 	}
@@ -997,7 +997,7 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 	reg_val = 0;
 	addr = (RTC_SOC_BASE_ADDRESS | SOC_CORE_CLK_CTRL_OFFSET);
 	status = bmi_read_soc_register(addr, &reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to read CLK_CTRL Addr");
 		goto end;
 	}
@@ -1006,14 +1006,14 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 	reg_val &= ~SOC_CORE_CLK_CTRL_DIV_MASK;
 	reg_val |= SOC_CORE_CLK_CTRL_DIV_SET(1);
 	status = bmi_write_soc_register(addr, reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to write CLK_CTRL Addr");
 		goto end;
 	}
 
 	reg_val = 0;
 	status = bmi_read_soc_register(addr, &reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to read back CLK_CTRL Addr");
 		goto end;
 	}
@@ -1023,7 +1023,7 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 	mem_val = 1;
 	status = bmi_write_memory(cmnos_core_clk_div_addr,
 				  (uint8_t *) &mem_val, 4, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to write CLK_DIV Addr");
 		goto end;
 	}
@@ -1032,7 +1032,7 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 	reg_val = 0;
 	addr = (RTC_WMAC_BASE_ADDRESS | WLAN_PLL_CONTROL_OFFSET);
 	status = bmi_read_soc_register(addr, &reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to read PLL_CTRL Addr");
 		goto end;
 	}
@@ -1044,14 +1044,14 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 		    WLAN_PLL_CONTROL_DIV_SET(clock_s.wlan_pll.div) |
 		    WLAN_PLL_CONTROL_NOPWD_SET(1));
 	status = bmi_write_soc_register(addr, reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to write PLL_CTRL Addr");
 		goto end;
 	}
 
 	reg_val = 0;
 	status = bmi_read_soc_register(addr, &reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to read back PLL_CTRL Addr");
 		goto end;
 	}
@@ -1063,7 +1063,7 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 		reg_val = 0;
 		status = bmi_read_soc_register((RTC_WMAC_BASE_ADDRESS |
 				RTC_SYNC_STATUS_OFFSET), &reg_val, ol_ctx);
-		if (status != CDF_STATUS_SUCCESS) {
+		if (status != QDF_STATUS_SUCCESS) {
 			BMI_ERR("Failed to read RTC_SYNC_STATUS Addr");
 			goto end;
 		}
@@ -1073,7 +1073,7 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 	reg_val = 0;
 	addr = (RTC_WMAC_BASE_ADDRESS | WLAN_PLL_CONTROL_OFFSET);
 	status = bmi_read_soc_register(addr, &reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to read PLL_CTRL Addr for CTRL_BYPASS");
 		goto end;
 	}
@@ -1082,14 +1082,14 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 	reg_val &= ~WLAN_PLL_CONTROL_BYPASS_MASK;
 	reg_val |= WLAN_PLL_CONTROL_BYPASS_SET(0);
 	status = bmi_write_soc_register(addr, reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to write PLL_CTRL Addr for CTRL_BYPASS");
 		goto end;
 	}
 
 	reg_val = 0;
 	status = bmi_read_soc_register(addr, &reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to read back PLL_CTRL Addr for CTRL_BYPASS");
 		goto end;
 	}
@@ -1100,7 +1100,7 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 		reg_val = 0;
 		status = bmi_read_soc_register((RTC_WMAC_BASE_ADDRESS |
 				RTC_SYNC_STATUS_OFFSET), &reg_val, ol_ctx);
-		if (status != CDF_STATUS_SUCCESS) {
+		if (status != QDF_STATUS_SUCCESS) {
 			BMI_ERR("Failed to read SYNC_STATUS Addr");
 			goto end;
 		}
@@ -1110,7 +1110,7 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 	reg_val = 0;
 	addr = (RTC_SOC_BASE_ADDRESS | SOC_CPU_CLOCK_OFFSET);
 	status = bmi_read_soc_register(addr, &reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to read CPU_CLK Addr");
 		goto end;
 	}
@@ -1119,14 +1119,14 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 	reg_val &= ~SOC_CPU_CLOCK_STANDARD_MASK;
 	reg_val |= SOC_CPU_CLOCK_STANDARD_SET(1);
 	status = bmi_write_soc_register(addr, reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to write CPU_CLK Addr");
 		goto end;
 	}
 
 	reg_val = 0;
 	status = bmi_read_soc_register(addr, &reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to read back CPU_CLK Addr");
 		goto end;
 	}
@@ -1136,7 +1136,7 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 	reg_val = 0;
 	addr = (RTC_WMAC_BASE_ADDRESS | WLAN_PLL_CONTROL_OFFSET);
 	status = bmi_read_soc_register(addr, &reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to read PLL_CTRL Addr for NOPWD");
 		goto end;
 	}
@@ -1144,13 +1144,13 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 
 	reg_val &= ~WLAN_PLL_CONTROL_NOPWD_MASK;
 	status = bmi_write_soc_register(addr, reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to write PLL_CTRL Addr for NOPWD");
 		goto end;
 	}
 	reg_val = 0;
 	status = bmi_read_soc_register(addr, &reg_val, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to read back PLL_CTRL Addr for NOPWD");
 		goto end;
 	}
@@ -1160,7 +1160,7 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 	mem_val = 1;
 	status = bmi_write_memory(cmnos_cpu_pll_init_done_addr,
 				  (uint8_t *) &mem_val, 4, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to write PLL_INIT Addr");
 		goto end;
 	}
@@ -1168,7 +1168,7 @@ CDF_STATUS ol_patch_pll_switch(struct ol_context *ol_ctx)
 	mem_val = TARGET_CPU_FREQ;
 	status = bmi_write_memory(cmnos_cpu_speed_addr,
 				  (uint8_t *) &mem_val, 4, ol_ctx);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to write CPU_SPEED Addr");
 		goto end;
 	}
@@ -1184,7 +1184,7 @@ end:
 void ol_transfer_codeswap_struct(struct ol_context *ol_ctx)
 {
 	struct codeswap_codeseg_info wlan_codeswap;
-	CDF_STATUS rv;
+	QDF_STATUS rv;
 
 	if (cnss_get_codeswap_struct(&wlan_codeswap)) {
 		BMI_ERR("%s: failed to get codeswap structure", __func__);
@@ -1195,7 +1195,7 @@ void ol_transfer_codeswap_struct(struct ol_context *ol_ctx)
 			      (uint8_t *) &wlan_codeswap, sizeof(wlan_codeswap),
 			      ol_ctx);
 
-	if (rv != CDF_STATUS_SUCCESS) {
+	if (rv != QDF_STATUS_SUCCESS) {
 		BMI_ERR("Failed to Write 0xa0000 to Target");
 		return;
 	}
@@ -1203,12 +1203,12 @@ void ol_transfer_codeswap_struct(struct ol_context *ol_ctx)
 }
 #endif
 
-CDF_STATUS ol_download_firmware(struct ol_context *ol_ctx)
+QDF_STATUS ol_download_firmware(struct ol_context *ol_ctx)
 {
 	struct hif_opaque_softc *scn = ol_ctx->scn;
 	uint32_t param, address = 0;
 	int status = !EOK;
-	CDF_STATUS ret;
+	QDF_STATUS ret;
 	struct hif_target_info *tgt_info = hif_get_target_info_handle(scn);
 	struct ol_config_info *ini_cfg = ol_get_ini_handle(ol_ctx);
 	uint32_t target_type = tgt_info->target_type;
@@ -1220,7 +1220,7 @@ CDF_STATUS ol_download_firmware(struct ol_context *ol_ctx)
 					      target_type,
 					      target_version)) {
 		BMI_ERR("%s: No FW files from CNSS driver", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 #endif
 	/* Transfer Board Data from Target EEPROM to Target RAM */
@@ -1237,7 +1237,7 @@ CDF_STATUS ol_download_firmware(struct ol_context *ol_ctx)
 
 	ret = ol_patch_pll_switch(ol_ctx);
 
-	if (ret != CDF_STATUS_SUCCESS) {
+	if (ret != QDF_STATUS_SUCCESS) {
 		BMI_ERR("pll switch failed. status %d", ret);
 		return ret;
 	}

core/cdf/inc/cdf_lock.h

@@ -39,7 +39,6 @@
  */
 
 /* Include Files */
-#include "cdf_status.h"
 #include "qdf_status.h"
 #include "i_cdf_lock.h"
 
@@ -107,10 +106,10 @@ cdf_semaphore_release(cdf_device_t osdev, cdf_semaphore_t *m)
  * a failure.
  *
  * Return:
- *	CDF_STATUS_SUCCESS:	lock was successfully initialized
+ *	QDF_STATUS_SUCCESS:	lock was successfully initialized
  *	CDF failure reason codes: lock is not initialized and can't be used
  */
-CDF_STATUS cdf_mutex_init(cdf_mutex_t *lock);
+QDF_STATUS cdf_mutex_init(cdf_mutex_t *lock);
 
 /**
  * cdf_mutex_acquire () - acquire a CDF lock
@@ -122,10 +121,10 @@ CDF_STATUS cdf_mutex_init(cdf_mutex_t *lock);
  * lock in the locked state with the calling thread as its owner.
  *
  * Return:
- *	CDF_STATUS_SUCCESS:	lock was successfully initialized
+ *	QDF_STATUS_SUCCESS:	lock was successfully initialized
  *	CDF failure reason codes: lock is not initialized and can't be used
  */
-CDF_STATUS cdf_mutex_acquire(cdf_mutex_t *lock);
+QDF_STATUS cdf_mutex_acquire(cdf_mutex_t *lock);
 
 /**
  * cdf_mutex_release() - release a CDF lock
@@ -138,10 +137,10 @@ CDF_STATUS cdf_mutex_acquire(cdf_mutex_t *lock);
  * initialized, an error is returned.
  *
  * Return:
- *	CDF_STATUS_SUCCESS:	lock was successfully initialized
+ *	QDF_STATUS_SUCCESS:	lock was successfully initialized
  *	CDF failure reason codes: lock is not initialized and can't be used
  */
-CDF_STATUS cdf_mutex_release(cdf_mutex_t *lock);
+QDF_STATUS cdf_mutex_release(cdf_mutex_t *lock);
 
 /**
  * cdf_mutex_destroy() - destroy a CDF lock
@@ -159,10 +158,10 @@ CDF_STATUS cdf_mutex_release(cdf_mutex_t *lock);
  * been re-initialized.
  *
  * Return:
- *	CDF_STATUS_SUCCESS:	lock was successfully initialized
+ *	QDF_STATUS_SUCCESS:	lock was successfully initialized
  *	CDF failure reason codes: lock is not initialized and can't be used
  */
-CDF_STATUS cdf_mutex_destroy(cdf_mutex_t *lock);
+QDF_STATUS cdf_mutex_destroy(cdf_mutex_t *lock);
 
 /**
  * cdf_spinlock_init() - initialize a spinlock
@@ -217,7 +216,7 @@ static inline void cdf_spin_unlock_bh(cdf_spinlock_t *lock)
  *    CDF status success : if wake lock is initialized
  *    CDF status fialure : if wake lock was not initialized
  */
-CDF_STATUS cdf_wake_lock_init(cdf_wake_lock_t *lock, const char *name);
+QDF_STATUS cdf_wake_lock_init(cdf_wake_lock_t *lock, const char *name);
 
 /**
  * cdf_wake_lock_acquire() - acquires a wake lock
@@ -228,7 +227,7 @@ CDF_STATUS cdf_wake_lock_init(cdf_wake_lock_t *lock, const char *name);
  *    CDF status success : if wake lock is acquired
  *    CDF status fialure : if wake lock was not acquired
  */
-CDF_STATUS cdf_wake_lock_acquire(cdf_wake_lock_t *pLock, uint32_t reason);
+QDF_STATUS cdf_wake_lock_acquire(cdf_wake_lock_t *pLock, uint32_t reason);
 
 /**
  * cdf_wake_lock_timeout_acquire() - acquires a wake lock with a timeout
@@ -239,7 +238,7 @@ CDF_STATUS cdf_wake_lock_acquire(cdf_wake_lock_t *pLock, uint32_t reason);
  *   CDF status success : if wake lock is acquired
  *   CDF status fialure : if wake lock was not acquired
  */
-CDF_STATUS cdf_wake_lock_timeout_acquire(cdf_wake_lock_t *pLock,
+QDF_STATUS cdf_wake_lock_timeout_acquire(cdf_wake_lock_t *pLock,
 					 uint32_t msec, uint32_t reason);
 
 /**
@@ -251,7 +250,7 @@ CDF_STATUS cdf_wake_lock_timeout_acquire(cdf_wake_lock_t *pLock,
  *    CDF status success : if wake lock is acquired
  *    CDF status fialure : if wake lock was not acquired
  */
-CDF_STATUS cdf_wake_lock_release(cdf_wake_lock_t *pLock, uint32_t reason);
+QDF_STATUS cdf_wake_lock_release(cdf_wake_lock_t *pLock, uint32_t reason);
 
 /**
  * cdf_wake_lock_destroy() - destroys a wake lock
@@ -261,15 +260,15 @@ CDF_STATUS cdf_wake_lock_release(cdf_wake_lock_t *pLock, uint32_t reason);
  * CDF status success :	if wake lock is acquired
  * CDF status fialure :	if wake lock was not acquired
  */
-CDF_STATUS cdf_wake_lock_destroy(cdf_wake_lock_t *pLock);
+QDF_STATUS cdf_wake_lock_destroy(cdf_wake_lock_t *pLock);
 
 struct hif_pm_runtime_lock;
 typedef struct hif_pm_runtime_lock *cdf_runtime_lock_t;
 
-CDF_STATUS cdf_runtime_pm_get(void);
-CDF_STATUS cdf_runtime_pm_put(void);
-CDF_STATUS cdf_runtime_pm_prevent_suspend(cdf_runtime_lock_t lock);
-CDF_STATUS cdf_runtime_pm_allow_suspend(cdf_runtime_lock_t lock);
+QDF_STATUS cdf_runtime_pm_get(void);
+QDF_STATUS cdf_runtime_pm_put(void);
+QDF_STATUS cdf_runtime_pm_prevent_suspend(cdf_runtime_lock_t lock);
+QDF_STATUS cdf_runtime_pm_allow_suspend(cdf_runtime_lock_t lock);
 cdf_runtime_lock_t cdf_runtime_lock_init(const char *name);
 void cdf_runtime_lock_deinit(cdf_runtime_lock_t lock);
 
@@ -281,7 +280,7 @@ void cdf_runtime_lock_deinit(cdf_runtime_lock_t lock);
  *    CDF status success : if wake lock is acquired
  *    CDF status fialure : if wake lock was not acquired
  */
-CDF_STATUS cdf_spinlock_acquire(cdf_spinlock_t *pLock);
+QDF_STATUS cdf_spinlock_acquire(cdf_spinlock_t *pLock);
 
 /**
  * cdf_spinlock_release() - release a spin lock
@@ -291,7 +290,7 @@ CDF_STATUS cdf_spinlock_acquire(cdf_spinlock_t *pLock);
  * CDF status success :	if wake lock is acquired
  * CDF status fialure :	if wake lock was not acquired
  */
-CDF_STATUS cdf_spinlock_release(cdf_spinlock_t *pLock);
+QDF_STATUS cdf_spinlock_release(cdf_spinlock_t *pLock);
 
 #define cdf_spin_lock(_lock) __cdf_spin_lock(_lock)
 #define cdf_spin_unlock(_lock) __cdf_spin_unlock(_lock)

core/cdf/inc/cdf_mc_timer.h

@@ -36,7 +36,6 @@
 
 /* Include Files */
 #include <cdf_types.h>
-#include <cdf_status.h>
 #include <qdf_status.h>
 #include <cdf_lock.h>
 #include <i_cdf_mc_timer.h>
@@ -150,7 +149,7 @@ CDF_TIMER_STATE cdf_mc_timer_get_current_state(cdf_mc_timer_t *pTimer);
  *  within the tx thread flow.
  *
  * Return:
- *	CDF_STATUS_SUCCESS - Timer is initialized successfully
+ *	QDF_STATUS_SUCCESS - Timer is initialized successfully
  *	CDF failure status - Timer initialization failed
  */
 #ifdef TIMER_MANAGER
@@ -158,13 +157,13 @@ CDF_TIMER_STATE cdf_mc_timer_get_current_state(cdf_mc_timer_t *pTimer);
 	cdf_mc_timer_init_debug(timer, timerType, callback, userdata, \
 		__FILE__, __LINE__)
 
-CDF_STATUS cdf_mc_timer_init_debug(cdf_mc_timer_t *timer,
+QDF_STATUS cdf_mc_timer_init_debug(cdf_mc_timer_t *timer,
 				   CDF_TIMER_TYPE timerType,
 				   cdf_mc_timer_callback_t callback,
 				   void *userData, char *fileName,
 				   uint32_t lineNum);
 #else
-CDF_STATUS cdf_mc_timer_init(cdf_mc_timer_t *timer, CDF_TIMER_TYPE timerType,
+QDF_STATUS cdf_mc_timer_init(cdf_mc_timer_t *timer, CDF_TIMER_TYPE timerType,
 			     cdf_mc_timer_callback_t callback,
 			     void *userData);
 #endif
@@ -187,10 +186,10 @@ CDF_STATUS cdf_mc_timer_init(cdf_mc_timer_t *timer, CDF_TIMER_TYPE timerType,
  * been re-initialized.
  *
  * Return:
- *	CDF_STATUS_SUCCESS - Timer is initialized successfully
+ *	QDF_STATUS_SUCCESS - Timer is initialized successfully
  *	CDF failure status - Timer initialization failed
  */
-CDF_STATUS cdf_mc_timer_destroy(cdf_mc_timer_t *timer);
+QDF_STATUS cdf_mc_timer_destroy(cdf_mc_timer_t *timer);
 
 /**
  * cdf_mc_timer_start() - start a CDF Timer object
@@ -206,10 +205,10 @@ CDF_STATUS cdf_mc_timer_destroy(cdf_mc_timer_t *timer);
  * or has been cancelled.
  *
  * Return:
- *	CDF_STATUS_SUCCESS - Timer is initialized successfully
+ *	QDF_STATUS_SUCCESS - Timer is initialized successfully
  *	CDF failure status - Timer initialization failed
  */
-CDF_STATUS cdf_mc_timer_start(cdf_mc_timer_t *timer, uint32_t expirationTime);
+QDF_STATUS cdf_mc_timer_start(cdf_mc_timer_t *timer, uint32_t expirationTime);
 
 /**
  * cdf_mc_timer_stop() - stop a CDF Timer
@@ -221,10 +220,10 @@ CDF_STATUS cdf_mc_timer_start(cdf_mc_timer_t *timer, uint32_t expirationTime);
  * was created and can be started again via a call to cdf_mc_timer_start().
  *
  * Return:
- *	CDF_STATUS_SUCCESS - Timer is initialized successfully
+ *	QDF_STATUS_SUCCESS - Timer is initialized successfully
  *	CDF failure status - Timer initialization failed
  */
-CDF_STATUS cdf_mc_timer_stop(cdf_mc_timer_t *timer);
+QDF_STATUS cdf_mc_timer_stop(cdf_mc_timer_t *timer);
 
 /**
  * cdf_mc_timer_get_system_ticks() - get the system time in 10ms ticks

core/cdf/inc/cdf_nbuf.h

@@ -95,7 +95,7 @@ typedef __cdf_nbuf_queue_t cdf_nbuf_queue_t;
  *
  * Return: Status of the operation
  */
-static inline CDF_STATUS
+static inline QDF_STATUS
 cdf_nbuf_map(cdf_device_t osdev, cdf_nbuf_t buf, cdf_dma_dir_t dir)
 {
 	return __cdf_nbuf_map(osdev, buf, dir);
@@ -123,7 +123,7 @@ cdf_nbuf_unmap(cdf_device_t osdev, cdf_nbuf_t buf, cdf_dma_dir_t dir)
  *
  * Return: Status of the operation
  */
-static inline CDF_STATUS
+static inline QDF_STATUS
 cdf_nbuf_map_single(cdf_device_t osdev, cdf_nbuf_t buf, cdf_dma_dir_t dir)
 {
 	return __cdf_nbuf_map_single(osdev, buf, dir);
@@ -448,7 +448,7 @@ static inline cdf_nbuf_t cdf_nbuf_copy(cdf_nbuf_t buf)
  *
  * Return: Status of the call - 0 successful
  */
-static inline CDF_STATUS cdf_nbuf_cat(cdf_nbuf_t dst, cdf_nbuf_t src)
+static inline QDF_STATUS cdf_nbuf_cat(cdf_nbuf_t dst, cdf_nbuf_t src)
 {
 	return __cdf_nbuf_cat(dst, src);
 }

core/cdf/inc/cdf_status.h

@@ -1,112 +0,0 @@
-/*
- * Copyright (c) 2014-2015 The Linux Foundation. All rights reserved.
- *
- * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
- *
- *
- * Permission to use, copy, modify, and/or distribute this software for
- * any purpose with or without fee is hereby granted, provided that the
- * above copyright notice and this permission notice appear in all
- * copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
- * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
- * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
- * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
- * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
-
-/*
- * This file was originally distributed by Qualcomm Atheros, Inc.
- * under proprietary terms before Copyright ownership was assigned
- * to the Linux Foundation.
- */
-
-#if !defined(__CDF_STATUS_H)
-#define __CDF_STATUS_H
-
-#include <qdf_status.h>
-/**
- * DOC:  cdf_status
- *
- * Connectivity driver framework (CDF) status codes
- *
- * Basic status codes/definitions used by CDF
- */
-
-/**
- * typedef CDF_STATUS - CDF error codes
- * @CDF_STATUS_SUCCESS: success
- * @CDF_STATUS_E_RESOURCES: system resource(other than memory) not available
- * @CDF_STATUS_E_NOMEM: not enough memory
- * @CDF_STATUS_E_AGAIN: try again
- * @CDF_STATUS_E_INVAL: invalid request
- * @CDF_STATUS_E_FAULT: system fault
- * @CDF_STATUS_E_ALREADY: another request already in progress
- * @CDF_STATUS_E_BADMSG: bad message
- * @CDF_STATUS_E_BUSY: device or resource busy
- * @CDF_STATUS_E_CANCELED: request cancelled
- * @CDF_STATUS_E_ABORTED: request aborted
- * @CDF_STATUS_E_NOSUPPORT: request not supported
- * @CDF_STATUS_E_PERM: operation not permitted
- * @CDF_STATUS_E_EMPTY: empty condition
- * @CDF_STATUS_E_EXISTS: existence failure
- * @CDF_STATUS_E_TIMEOUT: operation timeout
- * @CDF_STATUS_E_FAILURE: unknown reason do not use unless nothign else applies
- * @CDF_STATUS_NOT_INITIALIZED: resource not initialized
- * @CDF_STATUS_E_NULL_VALUE: request is null
- * @CDF_STATUS_PMC_PENDING: request pendign in pmc
- * @CDF_STATUS_PMC_DISABLED: pmc is disabled
- * @CDF_STATUS_PMC_NOT_NOW: pmc not ready now
- * @CDF_STATUS_PMC_AC_POWER: pmc ac power
- * @CDF_STATUS_PMC_SYS_ERROR: pmc system error
- * @CDF_STATUS_HEARTBEAT_TMOUT: hearbeat timeout error
- * @CDF_STATUS_NTH_BEACON_DELIVERY: Nth beacon delivery
- * @CDF_STATUS_CSR_WRONG_STATE: csr in wrong state
- * @CDF_STATUS_FT_PREAUTH_KEY_SUCCESS: ft preauth key success
- * @CDF_STATUS_FT_PREAUTH_KEY_FAILED: ft preauth key failed
- * @CDF_STATUS_CMD_NOT_QUEUED: command not queued
- * @CDF_STATUS_FW_MSG_TIMEDOUT: target message timeout
- * @CDF_STATUS_MAX: not a realy value just a place holder for max
- */
-typedef enum {
-	CDF_STATUS_SUCCESS,
-	CDF_STATUS_E_RESOURCES,
-	CDF_STATUS_E_NOMEM,
-	CDF_STATUS_E_AGAIN,
-	CDF_STATUS_E_INVAL,
-	CDF_STATUS_E_FAULT,
-	CDF_STATUS_E_ALREADY,
-	CDF_STATUS_E_BADMSG,
-	CDF_STATUS_E_BUSY,
-	CDF_STATUS_E_CANCELED,
-	CDF_STATUS_E_ABORTED,
-	CDF_STATUS_E_NOSUPPORT,
-	CDF_STATUS_E_PERM,
-	CDF_STATUS_E_EMPTY,
-	CDF_STATUS_E_EXISTS,
-	CDF_STATUS_E_TIMEOUT,
-	CDF_STATUS_E_FAILURE,
-	CDF_STATUS_NOT_INITIALIZED,
-	CDF_STATUS_E_NULL_VALUE,
-	CDF_STATUS_PMC_PENDING,
-	CDF_STATUS_PMC_DISABLED,
-	CDF_STATUS_PMC_NOT_NOW,
-	CDF_STATUS_PMC_AC_POWER,
-	CDF_STATUS_PMC_SYS_ERROR,
-	CDF_STATUS_HEARTBEAT_TMOUT,
-	CDF_STATUS_NTH_BEACON_DELIVERY,
-	CDF_STATUS_CSR_WRONG_STATE,
-	CDF_STATUS_FT_PREAUTH_KEY_SUCCESS,
-	CDF_STATUS_FT_PREAUTH_KEY_FAILED,
-	CDF_STATUS_CMD_NOT_QUEUED,
-	CDF_STATUS_FW_MSG_TIMEDOUT,
-	CDF_STATUS_MAX
-} CDF_STATUS;
-
-#define CDF_IS_STATUS_SUCCESS(status) (CDF_STATUS_SUCCESS == (status))
-
-#endif /* if !defined __CDF_STATUS_H */

core/cdf/inc/cdf_trace.h

@@ -40,7 +40,6 @@
 /* Include Files */
 #include  <cdf_types.h>         /* For CDF_MODULE_ID... */
 #include  <stdarg.h>            /* For va_list... */
-#include  <cdf_status.h>
 #include  <qdf_status.h>
 #include  <cdf_nbuf.h>
 #include  <cds_packet.h>
@@ -265,7 +264,7 @@ bool cdf_trace_get_level(CDF_MODULE_ID module, CDF_TRACE_LEVEL level);
 typedef void (*tp_cdf_trace_cb)(void *pMac, tp_cdf_trace_record, uint16_t);
 void cdf_trace(uint8_t module, uint8_t code, uint16_t session, uint32_t data);
 void cdf_trace_register(CDF_MODULE_ID, tp_cdf_trace_cb);
-CDF_STATUS cdf_trace_spin_lock_init(void);
+QDF_STATUS cdf_trace_spin_lock_init(void);
 void cdf_trace_init(void);
 void cdf_trace_enable(uint32_t, uint8_t enable);
 void cdf_trace_dump_all(void *, uint8_t, uint8_t, uint32_t, uint32_t);

core/cdf/inc/cdf_util.h

@@ -48,7 +48,7 @@
  */
 #define cdf_likely(_expr)       __cdf_likely(_expr)
 
-CDF_INLINE_FN int cdf_status_to_os_return(CDF_STATUS status)
+CDF_INLINE_FN int cdf_status_to_os_return(QDF_STATUS status)
 {
 	return __cdf_status_to_os_return(status);
 }

core/cdf/src/cdf_lock.c

@@ -82,29 +82,29 @@ enum {
  * a failure.
  *
  * Return:
- *      CDF_STATUS_SUCCESS:     lock was successfully initialized
+ *      QDF_STATUS_SUCCESS:     lock was successfully initialized
  *      CDF failure reason codes: lock is not initialized and can't be used
  */
-CDF_STATUS cdf_mutex_init(cdf_mutex_t *lock)
+QDF_STATUS cdf_mutex_init(cdf_mutex_t *lock)
 {
 	/* check for invalid pointer */
 	if (lock == NULL) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: NULL pointer passed in", __func__);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 	/* check for 'already initialized' lock */
 	if (LINUX_LOCK_COOKIE == lock->cookie) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: already initialized lock", __func__);
-		return CDF_STATUS_E_BUSY;
+		return QDF_STATUS_E_BUSY;
 	}
 
 	if (in_interrupt()) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s cannot be called from interrupt context!!!",
 			  __func__);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	/* initialize new lock */
@@ -114,7 +114,7 @@ CDF_STATUS cdf_mutex_init(cdf_mutex_t *lock)
 	lock->processID = 0;
 	lock->refcount = 0;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -127,10 +127,10 @@ CDF_STATUS cdf_mutex_init(cdf_mutex_t *lock)
  * lock in the locked state with the calling thread as its owner.
  *
  * Return:
- *      CDF_STATUS_SUCCESS:     lock was successfully initialized
+ *      QDF_STATUS_SUCCESS:     lock was successfully initialized
  *      CDF failure reason codes: lock is not initialized and can't be used
  */
-CDF_STATUS cdf_mutex_acquire(cdf_mutex_t *lock)
+QDF_STATUS cdf_mutex_acquire(cdf_mutex_t *lock)
 {
 	int rc;
 	/* check for invalid pointer */
@@ -138,14 +138,14 @@ CDF_STATUS cdf_mutex_acquire(cdf_mutex_t *lock)
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: NULL pointer passed in", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 	/* check if lock refers to an initialized object */
 	if (LINUX_LOCK_COOKIE != lock->cookie) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: uninitialized lock", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	if (in_interrupt()) {
@@ -153,7 +153,7 @@ CDF_STATUS cdf_mutex_acquire(cdf_mutex_t *lock)
 			  "%s cannot be called from interrupt context!!!",
 			  __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 	if ((lock->processID == current->pid) &&
 		(lock->state == LOCK_ACQUIRED)) {
@@ -163,7 +163,7 @@ CDF_STATUS cdf_mutex_acquire(cdf_mutex_t *lock)
 			  "%s: %x %d %d", __func__, lock, current->pid,
 			  lock->refcount);
 #endif
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 	/* acquire a Lock */
 	mutex_lock(&lock->m_lock);
@@ -172,7 +172,7 @@ CDF_STATUS cdf_mutex_acquire(cdf_mutex_t *lock)
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: unable to lock mutex (rc = %d)", __func__, rc);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 #ifdef CDF_NESTED_LOCK_DEBUG
 	CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_INFO,
@@ -182,14 +182,14 @@ CDF_STATUS cdf_mutex_acquire(cdf_mutex_t *lock)
 		lock->processID = current->pid;
 		lock->refcount++;
 		lock->state = LOCK_ACQUIRED;
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	} else {
 		/* lock is already destroyed */
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Lock is already destroyed", __func__);
 		mutex_unlock(&lock->m_lock);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 }
 
@@ -204,17 +204,17 @@ CDF_STATUS cdf_mutex_acquire(cdf_mutex_t *lock)
  * initialized, an error is returned.
  *
  * Return:
- *      CDF_STATUS_SUCCESS:     lock was successfully initialized
+ *      QDF_STATUS_SUCCESS:     lock was successfully initialized
  *      CDF failure reason codes: lock is not initialized and can't be used
  */
-CDF_STATUS cdf_mutex_release(cdf_mutex_t *lock)
+QDF_STATUS cdf_mutex_release(cdf_mutex_t *lock)
 {
 	/* check for invalid pointer */
 	if (lock == NULL) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: NULL pointer passed in", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	/* check if lock refers to an uninitialized object */
@@ -222,7 +222,7 @@ CDF_STATUS cdf_mutex_release(cdf_mutex_t *lock)
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: uninitialized lock", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	if (in_interrupt()) {
@@ -230,7 +230,7 @@ CDF_STATUS cdf_mutex_release(cdf_mutex_t *lock)
 			  "%s cannot be called from interrupt context!!!",
 			  __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	/* CurrentThread = GetCurrentThreadId();
@@ -247,7 +247,7 @@ CDF_STATUS cdf_mutex_release(cdf_mutex_t *lock)
 			  __func__, lock->processID, current->pid);
 #endif
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_PERM;
+		return QDF_STATUS_E_PERM;
 	}
 	if ((lock->processID == current->pid) &&
 		(lock->state == LOCK_ACQUIRED)) {
@@ -260,7 +260,7 @@ CDF_STATUS cdf_mutex_release(cdf_mutex_t *lock)
 		  lock->refcount);
 #endif
 	if (lock->refcount)
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 
 	lock->processID = 0;
 	lock->refcount = 0;
@@ -272,7 +272,7 @@ CDF_STATUS cdf_mutex_release(cdf_mutex_t *lock)
 		  "%s: Freeing lock %x %d %d", lock, lock->processID,
 		  lock->refcount);
 #endif
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -291,36 +291,36 @@ CDF_STATUS cdf_mutex_release(cdf_mutex_t *lock)
  * been re-initialized.
  *
  * Return:
- *      CDF_STATUS_SUCCESS:     lock was successfully initialized
+ *      QDF_STATUS_SUCCESS:     lock was successfully initialized
  *      CDF failure reason codes: lock is not initialized and can't be used
  */
-CDF_STATUS cdf_mutex_destroy(cdf_mutex_t *lock)
+QDF_STATUS cdf_mutex_destroy(cdf_mutex_t *lock)
 {
 	/* check for invalid pointer */
 	if (NULL == lock) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: NULL pointer passed in", __func__);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	if (LINUX_LOCK_COOKIE != lock->cookie) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: uninitialized lock", __func__);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	if (in_interrupt()) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s cannot be called from interrupt context!!!",
 			  __func__);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	/* check if lock is released */
 	if (!mutex_trylock(&lock->m_lock)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: lock is not released", __func__);
-		return CDF_STATUS_E_BUSY;
+		return QDF_STATUS_E_BUSY;
 	}
 	lock->cookie = 0;
 	lock->state = LOCK_DESTROYED;
@@ -329,7 +329,7 @@ CDF_STATUS cdf_mutex_destroy(cdf_mutex_t *lock)
 
 	mutex_unlock(&lock->m_lock);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -340,10 +340,10 @@ CDF_STATUS cdf_mutex_destroy(cdf_mutex_t *lock)
  *    CDF status success : if wake lock is acquired
  *    CDF status failure : if wake lock was not acquired
  */
-CDF_STATUS cdf_spinlock_acquire(cdf_spinlock_t *pLock)
+QDF_STATUS cdf_spinlock_acquire(cdf_spinlock_t *pLock)
 {
 	spin_lock(&pLock->spinlock);
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -354,10 +354,10 @@ CDF_STATUS cdf_spinlock_acquire(cdf_spinlock_t *pLock)
  * CDF status success : if wake lock is acquired
  * CDF status failure : if wake lock was not acquired
  */
-CDF_STATUS cdf_spinlock_release(cdf_spinlock_t *pLock)
+QDF_STATUS cdf_spinlock_release(cdf_spinlock_t *pLock)
 {
 	spin_unlock(&pLock->spinlock);
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -390,14 +390,14 @@ static const char *cdf_wake_lock_name(cdf_wake_lock_t *pLock)
  *    CDF status success : if wake lock is initialized
  *    CDF status failure : if wake lock was not initialized
  */
-CDF_STATUS cdf_wake_lock_init(cdf_wake_lock_t *pLock, const char *name)
+QDF_STATUS cdf_wake_lock_init(cdf_wake_lock_t *pLock, const char *name)
 {
 #if defined CONFIG_CNSS
 	cnss_pm_wake_lock_init(pLock, name);
 #elif defined(WLAN_OPEN_SOURCE) && defined(CONFIG_HAS_WAKELOCK)
 	wake_lock_init(pLock, WAKE_LOCK_SUSPEND, name);
 #endif
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -409,7 +409,7 @@ CDF_STATUS cdf_wake_lock_init(cdf_wake_lock_t *pLock, const char *name)
  *    CDF status success : if wake lock is acquired
  *    CDF status failure : if wake lock was not acquired
  */
-CDF_STATUS cdf_wake_lock_acquire(cdf_wake_lock_t *pLock, uint32_t reason)
+QDF_STATUS cdf_wake_lock_acquire(cdf_wake_lock_t *pLock, uint32_t reason)
 {
 	host_diag_log_wlock(reason, cdf_wake_lock_name(pLock),
 			WIFI_POWER_EVENT_DEFAULT_WAKELOCK_TIMEOUT,
@@ -419,7 +419,7 @@ CDF_STATUS cdf_wake_lock_acquire(cdf_wake_lock_t *pLock, uint32_t reason)
 #elif defined(WLAN_OPEN_SOURCE) && defined(CONFIG_HAS_WAKELOCK)
 	wake_lock(pLock);
 #endif
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -431,7 +431,7 @@ CDF_STATUS cdf_wake_lock_acquire(cdf_wake_lock_t *pLock, uint32_t reason)
  *   CDF status success : if wake lock is acquired
  *   CDF status failure : if wake lock was not acquired
  */
-CDF_STATUS cdf_wake_lock_timeout_acquire(cdf_wake_lock_t *pLock, uint32_t msec,
+QDF_STATUS cdf_wake_lock_timeout_acquire(cdf_wake_lock_t *pLock, uint32_t msec,
 					 uint32_t reason)
 {
 	/* Wakelock for Rx is frequent.
@@ -448,7 +448,7 @@ CDF_STATUS cdf_wake_lock_timeout_acquire(cdf_wake_lock_t *pLock, uint32_t msec,
 #elif defined(WLAN_OPEN_SOURCE) && defined(CONFIG_HAS_WAKELOCK)
 	wake_lock_timeout(pLock, msecs_to_jiffies(msec));
 #endif
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -460,7 +460,7 @@ CDF_STATUS cdf_wake_lock_timeout_acquire(cdf_wake_lock_t *pLock, uint32_t msec,
  *    CDF status success : if wake lock is acquired
  *    CDF status failure : if wake lock was not acquired
  */
-CDF_STATUS cdf_wake_lock_release(cdf_wake_lock_t *pLock, uint32_t reason)
+QDF_STATUS cdf_wake_lock_release(cdf_wake_lock_t *pLock, uint32_t reason)
 {
 	host_diag_log_wlock(reason, cdf_wake_lock_name(pLock),
 			WIFI_POWER_EVENT_DEFAULT_WAKELOCK_TIMEOUT,
@@ -470,7 +470,7 @@ CDF_STATUS cdf_wake_lock_release(cdf_wake_lock_t *pLock, uint32_t reason)
 #elif defined(WLAN_OPEN_SOURCE) && defined(CONFIG_HAS_WAKELOCK)
 	wake_unlock(pLock);
 #endif
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -481,14 +481,14 @@ CDF_STATUS cdf_wake_lock_release(cdf_wake_lock_t *pLock, uint32_t reason)
  * CDF status success : if wake lock is acquired
  * CDF status failure : if wake lock was not acquired
  */
-CDF_STATUS cdf_wake_lock_destroy(cdf_wake_lock_t *pLock)
+QDF_STATUS cdf_wake_lock_destroy(cdf_wake_lock_t *pLock)
 {
 #if defined CONFIG_CNSS
 	cnss_pm_wake_lock_destroy(pLock);
 #elif defined(WLAN_OPEN_SOURCE) && defined(CONFIG_HAS_WAKELOCK)
 	wake_lock_destroy(pLock);
 #endif
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -504,7 +504,7 @@ CDF_STATUS cdf_wake_lock_destroy(cdf_wake_lock_t *pLock)
  * return: success if the bus is up and a get has been issued
  *   otherwise an error code.
  */
-CDF_STATUS cdf_runtime_pm_get(void)
+QDF_STATUS cdf_runtime_pm_get(void)
 {
 	void *ol_sc;
 	int ret;
@@ -515,15 +515,15 @@ CDF_STATUS cdf_runtime_pm_get(void)
 		CDF_ASSERT(0);
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 				"%s: HIF context is null!", __func__);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	ret = hif_pm_runtime_get(ol_sc);
 
 	if (ret)
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -534,9 +534,9 @@ CDF_STATUS cdf_runtime_pm_get(void)
  *
  * This api will return a failure if the hif module hasn't been initialized
  *
- * return: CDF_STATUS_SUCCESS if the put is performed
+ * return: QDF_STATUS_SUCCESS if the put is performed
  */
-CDF_STATUS cdf_runtime_pm_put(void)
+QDF_STATUS cdf_runtime_pm_put(void)
 {
 	void *ol_sc;
 	int ret;
@@ -547,15 +547,15 @@ CDF_STATUS cdf_runtime_pm_put(void)
 		CDF_ASSERT(0);
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 				"%s: HIF context is null!", __func__);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	ret = hif_pm_runtime_put(ol_sc);
 
 	if (ret)
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -564,9 +564,9 @@ CDF_STATUS cdf_runtime_pm_put(void)
  *
  * The lock can only be acquired once per lock context and is tracked.
  *
- * return: CDF_STATUS_SUCCESS or failure code.
+ * return: QDF_STATUS_SUCCESS or failure code.
  */
-CDF_STATUS cdf_runtime_pm_prevent_suspend(cdf_runtime_lock_t lock)
+QDF_STATUS cdf_runtime_pm_prevent_suspend(cdf_runtime_lock_t lock)
 {
 	void *ol_sc;
 	int ret;
@@ -577,15 +577,15 @@ CDF_STATUS cdf_runtime_pm_prevent_suspend(cdf_runtime_lock_t lock)
 		CDF_ASSERT(0);
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 				"%s: HIF context is null!", __func__);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	ret = hif_pm_runtime_prevent_suspend(ol_sc, lock);
 
 	if (ret)
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -594,9 +594,9 @@ CDF_STATUS cdf_runtime_pm_prevent_suspend(cdf_runtime_lock_t lock)
  *
  * The lock can only be acquired once per lock context and is tracked.
  *
- * return: CDF_STATUS_SUCCESS or failure code.
+ * return: QDF_STATUS_SUCCESS or failure code.
  */
-CDF_STATUS cdf_runtime_pm_allow_suspend(cdf_runtime_lock_t lock)
+QDF_STATUS cdf_runtime_pm_allow_suspend(cdf_runtime_lock_t lock)
 {
 	void *ol_sc;
 	int ret;
@@ -607,15 +607,15 @@ CDF_STATUS cdf_runtime_pm_allow_suspend(cdf_runtime_lock_t lock)
 		CDF_ASSERT(0);
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 				"%s: HIF context is null!", __func__);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	ret = hif_pm_runtime_allow_suspend(ol_sc, lock);
 
 	if (ret)
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**

core/cdf/src/cdf_mc_timer.c

@@ -96,7 +96,7 @@ static void cdf_linux_timer_callback(unsigned long data)
 {
 	cdf_mc_timer_t *timer = (cdf_mc_timer_t *) data;
 	cds_msg_t msg;
-	CDF_STATUS vStatus;
+	QDF_STATUS vStatus;
 	unsigned long flags;
 
 	cdf_mc_timer_callback_t callback = NULL;
@@ -122,15 +122,15 @@ static void cdf_linux_timer_callback(unsigned long data)
 		 * not been updated this is a rare race condition!
 		 */
 		timer->state = CDF_TIMER_STATE_STOPPED;
-		vStatus = CDF_STATUS_E_ALREADY;
+		vStatus = QDF_STATUS_E_ALREADY;
 		break;
 
 	case CDF_TIMER_STATE_STOPPED:
-		vStatus = CDF_STATUS_E_ALREADY;
+		vStatus = QDF_STATUS_E_ALREADY;
 		break;
 
 	case CDF_TIMER_STATE_UNUSED:
-		vStatus = CDF_STATUS_E_EXISTS;
+		vStatus = QDF_STATUS_E_EXISTS;
 		break;
 
 	case CDF_TIMER_STATE_RUNNING:
@@ -146,18 +146,18 @@ static void cdf_linux_timer_callback(unsigned long data)
 		userData = timer->userData;
 		threadId = timer->platformInfo.threadID;
 		type = timer->type;
-		vStatus = CDF_STATUS_SUCCESS;
+		vStatus = QDF_STATUS_SUCCESS;
 		break;
 
 	default:
 		CDF_ASSERT(0);
-		vStatus = CDF_STATUS_E_FAULT;
+		vStatus = QDF_STATUS_E_FAULT;
 		break;
 	}
 
 	spin_unlock_irqrestore(&timer->platformInfo.spinlock, flags);
 
-	if (CDF_STATUS_SUCCESS != vStatus) {
+	if (QDF_STATUS_SUCCESS != vStatus) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "TIMER callback called in a wrong state=%d",
 			  timer->state);
@@ -182,7 +182,7 @@ static void cdf_linux_timer_callback(unsigned long data)
 	msg.bodyptr = userData;
 	msg.bodyval = 0;
 
-	if (cds_mq_post_message(CDS_MQ_ID_SYS, &msg) == CDF_STATUS_SUCCESS)
+	if (cds_mq_post_message(CDS_MQ_ID_SYS, &msg) == QDF_STATUS_SUCCESS)
 		return;
 
 	CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
@@ -335,11 +335,11 @@ void cdf_mc_timer_exit(void)
  *  within the tx thread flow.
  *
  * Return:
- *	CDF_STATUS_SUCCESS - Timer is initialized successfully
+ *	QDF_STATUS_SUCCESS - Timer is initialized successfully
  *	CDF failure status - Timer initialization failed
  */
 #ifdef TIMER_MANAGER
-CDF_STATUS cdf_mc_timer_init_debug(cdf_mc_timer_t *timer,
+QDF_STATUS cdf_mc_timer_init_debug(cdf_mc_timer_t *timer,
 				   CDF_TIMER_TYPE timerType,
 				   cdf_mc_timer_callback_t callback,
 				   void *userData, char *fileName,
@@ -352,7 +352,7 @@ CDF_STATUS cdf_mc_timer_init_debug(cdf_mc_timer_t *timer,
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Null params being passed", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	timer->ptimerNode = cdf_mem_malloc(sizeof(cdf_mc_timer_node_t));
@@ -362,7 +362,7 @@ CDF_STATUS cdf_mc_timer_init_debug(cdf_mc_timer_t *timer,
 			  "%s: Not able to allocate memory for timeNode",
 			  __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_NOMEM;
+		return QDF_STATUS_E_NOMEM;
 	}
 
 	cdf_mem_set(timer->ptimerNode, sizeof(cdf_mc_timer_node_t), 0);
@@ -377,7 +377,7 @@ CDF_STATUS cdf_mc_timer_init_debug(cdf_mc_timer_t *timer,
 	cdf_spin_unlock_irqrestore(&cdf_timer_list_lock);
 	if (QDF_STATUS_SUCCESS != qdf_status) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
-			  "%s: Unable to insert node into List cdf_status %d",
+			  "%s: Unable to insert node into List qdf_status %d",
 			  __func__, qdf_status);
 	}
 
@@ -398,10 +398,10 @@ CDF_STATUS cdf_mc_timer_init_debug(cdf_mc_timer_t *timer,
 	timer->platformInfo.threadID = 0;
 	timer->state = CDF_TIMER_STATE_STOPPED;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 #else
-CDF_STATUS cdf_mc_timer_init(cdf_mc_timer_t *timer, CDF_TIMER_TYPE timerType,
+QDF_STATUS cdf_mc_timer_init(cdf_mc_timer_t *timer, CDF_TIMER_TYPE timerType,
 			     cdf_mc_timer_callback_t callback,
 			     void *userData)
 {
@@ -410,7 +410,7 @@ CDF_STATUS cdf_mc_timer_init(cdf_mc_timer_t *timer, CDF_TIMER_TYPE timerType,
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Null params being passed", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	/* set the various members of the timer structure
@@ -430,7 +430,7 @@ CDF_STATUS cdf_mc_timer_init(cdf_mc_timer_t *timer, CDF_TIMER_TYPE timerType,
 	timer->platformInfo.threadID = 0;
 	timer->state = CDF_TIMER_STATE_STOPPED;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 #endif
 
@@ -452,11 +452,11 @@ CDF_STATUS cdf_mc_timer_init(cdf_mc_timer_t *timer, CDF_TIMER_TYPE timerType,
  * been re-initialized.
  *
  * Return:
- *	CDF_STATUS_SUCCESS - Timer is initialized successfully
+ *	QDF_STATUS_SUCCESS - Timer is initialized successfully
  *	CDF failure status - Timer initialization failed
  */
 #ifdef TIMER_MANAGER
-CDF_STATUS cdf_mc_timer_destroy(cdf_mc_timer_t *timer)
+QDF_STATUS cdf_mc_timer_destroy(cdf_mc_timer_t *timer)
 {
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	unsigned long flags;
@@ -466,7 +466,7 @@ CDF_STATUS cdf_mc_timer_destroy(cdf_mc_timer_t *timer)
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Null timer pointer being passed", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	/* Check if timer refers to an uninitialized object */
@@ -474,7 +474,7 @@ CDF_STATUS cdf_mc_timer_destroy(cdf_mc_timer_t *timer)
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Cannot destroy uninitialized timer", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	cdf_spin_lock_irqsave(&cdf_timer_list_lock);
@@ -550,12 +550,12 @@ CDF_STATUS cdf_mc_timer_destroy(cdf_mc_timer_t *timer)
  * been re-initialized.
  *
  * Return:
- *      CDF_STATUS_SUCCESS - Timer is initialized successfully
+ *      QDF_STATUS_SUCCESS - Timer is initialized successfully
  *      CDF failure status - Timer initialization failed
  */
-CDF_STATUS cdf_mc_timer_destroy(cdf_mc_timer_t *timer)
+QDF_STATUS cdf_mc_timer_destroy(cdf_mc_timer_t *timer)
 {
-	CDF_STATUS vStatus = CDF_STATUS_SUCCESS;
+	QDF_STATUS vStatus = QDF_STATUS_SUCCESS;
 	unsigned long flags;
 
 	/* check for invalid pointer */
@@ -563,7 +563,7 @@ CDF_STATUS cdf_mc_timer_destroy(cdf_mc_timer_t *timer)
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Null timer pointer being passed", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	/* check if timer refers to an uninitialized object */
@@ -571,36 +571,36 @@ CDF_STATUS cdf_mc_timer_destroy(cdf_mc_timer_t *timer)
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Cannot destroy uninitialized timer", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 	spin_lock_irqsave(&timer->platformInfo.spinlock, flags);
 
 	switch (timer->state) {
 
 	case CDF_TIMER_STATE_STARTING:
-		vStatus = CDF_STATUS_E_BUSY;
+		vStatus = QDF_STATUS_E_BUSY;
 		break;
 
 	case CDF_TIMER_STATE_RUNNING:
 		/* Stop the timer first */
 		del_timer(&(timer->platformInfo.Timer));
-		vStatus = CDF_STATUS_SUCCESS;
+		vStatus = QDF_STATUS_SUCCESS;
 		break;
 
 	case CDF_TIMER_STATE_STOPPED:
-		vStatus = CDF_STATUS_SUCCESS;
+		vStatus = QDF_STATUS_SUCCESS;
 		break;
 
 	case CDF_TIMER_STATE_UNUSED:
-		vStatus = CDF_STATUS_E_ALREADY;
+		vStatus = QDF_STATUS_E_ALREADY;
 		break;
 
 	default:
-		vStatus = CDF_STATUS_E_FAULT;
+		vStatus = QDF_STATUS_E_FAULT;
 		break;
 	}
 
-	if (CDF_STATUS_SUCCESS == vStatus) {
+	if (QDF_STATUS_SUCCESS == vStatus) {
 		timer->platformInfo.cookie = LINUX_INVALID_TIMER_COOKIE;
 		timer->state = CDF_TIMER_STATE_UNUSED;
 		spin_unlock_irqrestore(&timer->platformInfo.spinlock, flags);
@@ -632,10 +632,10 @@ CDF_STATUS cdf_mc_timer_destroy(cdf_mc_timer_t *timer)
  * or has been cancelled.
  *
  * Return:
- *	CDF_STATUS_SUCCESS - Timer is initialized successfully
+ *	QDF_STATUS_SUCCESS - Timer is initialized successfully
  *	CDF failure status - Timer initialization failed
  */
-CDF_STATUS cdf_mc_timer_start(cdf_mc_timer_t *timer, uint32_t expirationTime)
+QDF_STATUS cdf_mc_timer_start(cdf_mc_timer_t *timer, uint32_t expirationTime)
 {
 	unsigned long flags;
 
@@ -647,7 +647,7 @@ CDF_STATUS cdf_mc_timer_start(cdf_mc_timer_t *timer, uint32_t expirationTime)
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s Null timer pointer being passed", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	/* check if timer refers to an uninitialized object */
@@ -656,7 +656,7 @@ CDF_STATUS cdf_mc_timer_start(cdf_mc_timer_t *timer, uint32_t expirationTime)
 			  "%s: Cannot start uninitialized timer", __func__);
 		CDF_ASSERT(0);
 
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	/* check if timer has expiration time less than 10 ms */
@@ -665,7 +665,7 @@ CDF_STATUS cdf_mc_timer_start(cdf_mc_timer_t *timer, uint32_t expirationTime)
 			  "%s: Cannot start a timer with expiration less than 10 ms",
 			  __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	/* make sure the remainer of the logic isn't interrupted */
@@ -677,7 +677,7 @@ CDF_STATUS cdf_mc_timer_start(cdf_mc_timer_t *timer, uint32_t expirationTime)
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_INFO_HIGH,
 			  "%s: Cannot start timer in state = %d ", __func__,
 			  timer->state);
-		return CDF_STATUS_E_ALREADY;
+		return QDF_STATUS_E_ALREADY;
 	}
 
 	/* start the timer */
@@ -701,7 +701,7 @@ CDF_STATUS cdf_mc_timer_start(cdf_mc_timer_t *timer, uint32_t expirationTime)
 
 	spin_unlock_irqrestore(&timer->platformInfo.spinlock, flags);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -714,10 +714,10 @@ CDF_STATUS cdf_mc_timer_start(cdf_mc_timer_t *timer, uint32_t expirationTime)
  * was created and can be started again via a call to cdf_mc_timer_start().
  *
  * Return:
- *	CDF_STATUS_SUCCESS - Timer is initialized successfully
+ *	QDF_STATUS_SUCCESS - Timer is initialized successfully
  *	CDF failure status - Timer initialization failed
  */
-CDF_STATUS cdf_mc_timer_stop(cdf_mc_timer_t *timer)
+QDF_STATUS cdf_mc_timer_stop(cdf_mc_timer_t *timer)
 {
 	unsigned long flags;
 
@@ -729,7 +729,7 @@ CDF_STATUS cdf_mc_timer_stop(cdf_mc_timer_t *timer)
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s Null timer pointer being passed", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	/* check if timer refers to an uninitialized object */
@@ -738,7 +738,7 @@ CDF_STATUS cdf_mc_timer_stop(cdf_mc_timer_t *timer)
 			  "%s: Cannot stop uninitialized timer", __func__);
 		CDF_ASSERT(0);
 
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	/* ensure the timer state is correct */
@@ -749,7 +749,7 @@ CDF_STATUS cdf_mc_timer_stop(cdf_mc_timer_t *timer)
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_INFO_HIGH,
 			  "%s: Cannot stop timer in state = %d",
 			  __func__, timer->state);
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 
 	timer->state = CDF_TIMER_STATE_STOPPED;
@@ -760,7 +760,7 @@ CDF_STATUS cdf_mc_timer_stop(cdf_mc_timer_t *timer)
 
 	try_allowing_sleep(timer->type);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**

core/cdf/src/cdf_memory.c

@@ -307,7 +307,7 @@ void *cdf_mem_malloc_debug(size_t size, char *fileName, uint32_t lineNum)
 		cdf_spin_unlock_irqrestore(&cdf_mem_list_lock);
 		if (QDF_STATUS_SUCCESS != qdf_status) {
 			CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
-				  "%s: Unable to insert node into List cdf_status %d",
+				  "%s: Unable to insert node into List qdf_status %d",
 				  __func__, qdf_status);
 		}
 

core/cdf/src/cdf_nbuf.c

@@ -44,7 +44,7 @@
 #include <cdf_nbuf.h>
 #include <cdf_memory.h>
 #include <cdf_trace.h>
-#include <cdf_status.h>
+#include <qdf_status.h>
 #include <cdf_lock.h>
 
 /* Packet Counter */
@@ -230,9 +230,9 @@ void __cdf_nbuf_free(struct sk_buff *skb)
  * @skb: Pointer to network buffer
  * @dir: Direction
  *
- * Return: CDF_STATUS
+ * Return: QDF_STATUS
  */
-CDF_STATUS
+QDF_STATUS
 __cdf_nbuf_map(cdf_device_t osdev, struct sk_buff *skb, cdf_dma_dir_t dir)
 {
 #ifdef CDF_OS_DEBUG
@@ -252,7 +252,7 @@ __cdf_nbuf_map(cdf_device_t osdev, struct sk_buff *skb, cdf_dma_dir_t dir)
 
 	return __cdf_nbuf_map_single(osdev, skb, dir);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -284,9 +284,9 @@ __cdf_nbuf_unmap(cdf_device_t osdev, struct sk_buff *skb, cdf_dma_dir_t dir)
  * @skb: Pointer to network buffer
  * @dir: Direction
  *
- * Return: CDF_STATUS
+ * Return: QDF_STATUS
  */
-CDF_STATUS
+QDF_STATUS
 __cdf_nbuf_map_single(cdf_device_t osdev, cdf_nbuf_t buf, cdf_dma_dir_t dir)
 {
 	cdf_dma_addr_t paddr;
@@ -294,15 +294,15 @@ __cdf_nbuf_map_single(cdf_device_t osdev, cdf_nbuf_t buf, cdf_dma_dir_t dir)
 /* tempory hack for simulation */
 #ifdef A_SIMOS_DEVHOST
 	NBUF_CB_PADDR(buf) = paddr = buf->data;
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 #else
 	/* assume that the OS only provides a single fragment */
 	NBUF_CB_PADDR(buf) = paddr =
 		dma_map_single(osdev->dev, buf->data,
 			       skb_end_pointer(buf) - buf->data, dir);
 	return dma_mapping_error(osdev->dev, paddr)
-		? CDF_STATUS_E_FAILURE
-		: CDF_STATUS_SUCCESS;
+		? QDF_STATUS_E_FAILURE
+		: QDF_STATUS_SUCCESS;
 #endif /* #ifdef A_SIMOS_DEVHOST */
 }
 
@@ -328,9 +328,9 @@ __cdf_nbuf_unmap_single(cdf_device_t osdev, cdf_nbuf_t buf, cdf_dma_dir_t dir)
  * @skb: Pointer to network buffer
  * @cksum: Pointer to checksum value
  *
- * Return: CDF_STATUS
+ * Return: QDF_STATUS
  */
-CDF_STATUS
+QDF_STATUS
 __cdf_nbuf_set_rx_cksum(struct sk_buff *skb, cdf_nbuf_rx_cksum_t *cksum)
 {
 	switch (cksum->l4_result) {
@@ -347,9 +347,9 @@ __cdf_nbuf_set_rx_cksum(struct sk_buff *skb, cdf_nbuf_rx_cksum_t *cksum)
 	default:
 		pr_err("ADF_NET:Unknown checksum type\n");
 		cdf_assert(0);
-		return CDF_STATUS_E_NOSUPPORT;
+		return QDF_STATUS_E_NOSUPPORT;
 	}
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**

core/cdf/src/cdf_trace.c

@@ -554,11 +554,11 @@ void cdf_trace(uint8_t module, uint8_t code, uint16_t session, uint32_t data)
  *
  * Return : nothing
  */
-CDF_STATUS cdf_trace_spin_lock_init(void)
+QDF_STATUS cdf_trace_spin_lock_init(void)
 {
 	spin_lock_init(&ltrace_lock);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**

core/cdf/src/i_cdf_atomic.h

@@ -27,18 +27,17 @@
 #ifndef I_CDF_ATOMIC_H
 #define I_CDF_ATOMIC_H
 
-#include <cdf_status.h>         /* CDF_STATUS */
 #include <qdf_status.h>         /* QDF_STATUS */
 
 #include <linux/atomic.h>
 
 typedef atomic_t __cdf_atomic_t;
 
-static inline CDF_STATUS __cdf_atomic_init(__cdf_atomic_t *v)
+static inline QDF_STATUS __cdf_atomic_init(__cdf_atomic_t *v)
 {
 	atomic_set(v, 0);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 static inline int32_t __cdf_atomic_read(__cdf_atomic_t *v)

core/cdf/src/i_cdf_defer.h

@@ -35,7 +35,6 @@
 #include <net/cnss.h>
 #endif
 #include <cdf_types.h>
-#include <cdf_status.h>
 #include <qdf_status.h>
 #include <cdf_trace.h>
 
@@ -52,7 +51,7 @@ typedef struct {
 
 extern void __cdf_defer_func(struct work_struct *work);
 
-static inline CDF_STATUS
+static inline QDF_STATUS
 __cdf_init_work(__cdf_work_t *work, cdf_defer_fn_t func, void *arg)
 {
 	/*Initilize func and argument in work struct */
@@ -63,38 +62,38 @@ __cdf_init_work(__cdf_work_t *work, cdf_defer_fn_t func, void *arg)
 #else
 	INIT_WORK(&work->work, __cdf_defer_func);
 #endif
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-static inline CDF_STATUS __cdf_schedule_work(__cdf_work_t *work)
+static inline QDF_STATUS __cdf_schedule_work(__cdf_work_t *work)
 {
 	schedule_work(&work->work);
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-static inline CDF_STATUS __cdf_init_bh(cdf_handle_t hdl,
+static inline QDF_STATUS __cdf_init_bh(cdf_handle_t hdl,
 				       struct tasklet_struct *bh,
 				       cdf_defer_fn_t func, void *arg)
 {
 	tasklet_init(bh, (__cdf_bh_fn_t) func, (unsigned long)arg);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-static inline CDF_STATUS
+static inline QDF_STATUS
 __cdf_sched_bh(cdf_handle_t hdl, struct tasklet_struct *bh)
 {
 	tasklet_schedule(bh);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-static inline CDF_STATUS
+static inline QDF_STATUS
 __cdf_disable_bh(cdf_handle_t hdl, struct tasklet_struct *bh)
 {
 	tasklet_kill(bh);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 #endif /*_I_CDF_DEFER_H*/

core/cdf/src/i_cdf_lock.h

@@ -101,12 +101,12 @@ typedef int cdf_wake_lock_t;
  * __cdf_semaphore_init() - initialize the semaphore
  * @m: Semaphore object
  *
- * Return: CDF_STATUS_SUCCESS
+ * Return: QDF_STATUS_SUCCESS
  */
-static inline CDF_STATUS __cdf_semaphore_init(struct semaphore *m)
+static inline QDF_STATUS __cdf_semaphore_init(struct semaphore *m)
 {
 	sema_init(m, 1);
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -138,14 +138,14 @@ __cdf_semaphore_release(cdf_device_t osdev, struct semaphore *m)
  * __cdf_spinlock_init() - initialize spin lock
  * @lock: Spin lock object
  *
- * Return: CDF_STATUS_SUCCESS
+ * Return: QDF_STATUS_SUCCESS
  */
-static inline CDF_STATUS __cdf_spinlock_init(__cdf_spinlock_t *lock)
+static inline QDF_STATUS __cdf_spinlock_init(__cdf_spinlock_t *lock)
 {
 	spin_lock_init(&lock->spinlock);
 	lock->flags = 0;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 #define __cdf_spinlock_destroy(lock)

core/cdf/src/i_cdf_nbuf.h

@@ -38,7 +38,7 @@
 #include <linux/etherdevice.h>
 #include <linux/dma-mapping.h>
 #include <cdf_types.h>
-#include <cdf_status.h>
+#include <qdf_status.h>
 
 /*
  * Use socket buffer as the underlying implentation as skbuf .
@@ -334,11 +334,11 @@ typedef void (*cdf_nbuf_trace_update_t)(char *);
 __cdf_nbuf_t __cdf_nbuf_alloc(__cdf_device_t osdev, size_t size, int reserve,
 			      int align, int prio);
 void __cdf_nbuf_free(struct sk_buff *skb);
-CDF_STATUS __cdf_nbuf_map(__cdf_device_t osdev,
+QDF_STATUS __cdf_nbuf_map(__cdf_device_t osdev,
 			  struct sk_buff *skb, cdf_dma_dir_t dir);
 void __cdf_nbuf_unmap(__cdf_device_t osdev,
 		      struct sk_buff *skb, cdf_dma_dir_t dir);
-CDF_STATUS __cdf_nbuf_map_single(__cdf_device_t osdev,
+QDF_STATUS __cdf_nbuf_map_single(__cdf_device_t osdev,
 				 struct sk_buff *skb, cdf_dma_dir_t dir);
 void __cdf_nbuf_unmap_single(__cdf_device_t osdev,
 			     struct sk_buff *skb, cdf_dma_dir_t dir);
@@ -356,16 +356,16 @@ void __cdf_nbuf_trace_update(struct sk_buff *buf, char *event_string);
  *
  * Return: CDF status
  */
-static inline CDF_STATUS __cdf_os_to_status(signed int error)
+static inline QDF_STATUS __cdf_os_to_status(signed int error)
 {
 	switch (error) {
 	case 0:
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	case ENOMEM:
 	case -ENOMEM:
-		return CDF_STATUS_E_NOMEM;
+		return QDF_STATUS_E_NOMEM;
 	default:
-		return CDF_STATUS_E_NOSUPPORT;
+		return QDF_STATUS_E_NOSUPPORT;
 	}
 }
 
@@ -397,13 +397,13 @@ static inline size_t __cdf_nbuf_len(struct sk_buff *skb)
  * Link tow nbufs the new buf is piggybacked into the older one. The older
  * (src) skb is released.
  *
- * Return: CDF_STATUS (status of the call) if failed the src skb
+ * Return: QDF_STATUS (status of the call) if failed the src skb
  *	   is released
  */
-static inline CDF_STATUS
+static inline QDF_STATUS
 __cdf_nbuf_cat(struct sk_buff *dst, struct sk_buff *src)
 {
-	CDF_STATUS error = 0;
+	QDF_STATUS error = 0;
 
 	cdf_assert(dst && src);
 
@@ -520,7 +520,7 @@ static inline void __cdf_nbuf_trim_tail(struct sk_buff *skb, size_t size)
  * prototypes. Implemented in cdf_nbuf.c
  */
 cdf_nbuf_tx_cksum_t __cdf_nbuf_get_tx_cksum(struct sk_buff *skb);
-CDF_STATUS __cdf_nbuf_set_rx_cksum(struct sk_buff *skb,
+QDF_STATUS __cdf_nbuf_set_rx_cksum(struct sk_buff *skb,
 				   cdf_nbuf_rx_cksum_t *cksum);
 uint8_t __cdf_nbuf_get_tid(struct sk_buff *skb);
 void __cdf_nbuf_set_tid(struct sk_buff *skb, uint8_t tid);
@@ -927,10 +927,10 @@ typedef struct __cdf_nbuf_qhead {
  *
  * Return: CDF status
  */
-static inline CDF_STATUS __cdf_nbuf_queue_init(__cdf_nbuf_queue_t *qhead)
+static inline QDF_STATUS __cdf_nbuf_queue_init(__cdf_nbuf_queue_t *qhead)
 {
 	memset(qhead, 0, sizeof(struct __cdf_nbuf_qhead));
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**

core/cdf/src/i_cdf_softirq_timer.h

@@ -56,7 +56,7 @@ typedef void (*cdf_dummy_timer_func_t)(unsigned long arg);
  *
  * Return: none
  */
-static inline CDF_STATUS
+static inline QDF_STATUS
 __cdf_softirq_timer_init(cdf_handle_t hdl,
 			 struct timer_list *timer,
 			 cdf_softirq_timer_func_t func, void *arg,
@@ -69,7 +69,7 @@ __cdf_softirq_timer_init(cdf_handle_t hdl,
 	timer->function = (cdf_dummy_timer_func_t) func;
 	timer->data = (unsigned long)arg;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -79,13 +79,13 @@ __cdf_softirq_timer_init(cdf_handle_t hdl,
  *
  * Return: none
  */
-static inline CDF_STATUS
+static inline QDF_STATUS
 __cdf_softirq_timer_start(struct timer_list *timer, uint32_t delay)
 {
 	timer->expires = jiffies + msecs_to_jiffies(delay);
 	add_timer(timer);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -95,12 +95,12 @@ __cdf_softirq_timer_start(struct timer_list *timer, uint32_t delay)
  *
  * Return: none
  */
-static inline CDF_STATUS
+static inline QDF_STATUS
 __cdf_softirq_timer_mod(struct timer_list *timer, uint32_t delay)
 {
 	mod_timer(timer, jiffies + msecs_to_jiffies(delay));
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**

core/cdf/src/i_cdf_util.h

@@ -36,7 +36,6 @@
 #include <linux/random.h>
 
 #include <cdf_types.h>
-#include <cdf_status.h>
 #include <qdf_status.h>
 #include <asm/byteorder.h>
 /*
@@ -47,36 +46,36 @@
 #define __cdf_likely(_expr)     likely(_expr)
 
 /**
- * cdf_status_to_os_return(): translates cdf_status types to linux return types
+ * cdf_status_to_os_return(): translates qdf_status types to linux return types
  * @status: status to translate
  *
  * Translates error types that linux may want to handle specially.
  *
- * return: 0 or the linux error code that most closely matches the CDF_STATUS.
+ * return: 0 or the linux error code that most closely matches the QDF_STATUS.
  *	defaults to -1 (EPERM)
  */
-static inline int __cdf_status_to_os_return(CDF_STATUS status)
+static inline int __cdf_status_to_os_return(QDF_STATUS status)
 {
 	switch (status) {
-	case CDF_STATUS_SUCCESS:
+	case QDF_STATUS_SUCCESS:
 		return 0;
-	case CDF_STATUS_E_NULL_VALUE:
-	case CDF_STATUS_E_FAULT:
+	case QDF_STATUS_E_NULL_VALUE:
+	case QDF_STATUS_E_FAULT:
 		return -EFAULT;
-	case CDF_STATUS_E_TIMEOUT:
-	case CDF_STATUS_E_BUSY:
+	case QDF_STATUS_E_TIMEOUT:
+	case QDF_STATUS_E_BUSY:
 		return -EBUSY;
-	case CDF_STATUS_NOT_INITIALIZED:
-	case CDF_STATUS_E_AGAIN:
+	case QDF_STATUS_NOT_INITIALIZED:
+	case QDF_STATUS_E_AGAIN:
 		return -EAGAIN;
-	case CDF_STATUS_E_NOSUPPORT:
+	case QDF_STATUS_E_NOSUPPORT:
 		return -ENOSYS;
-	case CDF_STATUS_E_ALREADY:
+	case QDF_STATUS_E_ALREADY:
 		return -EALREADY;
-	case CDF_STATUS_E_NOMEM:
+	case QDF_STATUS_E_NOMEM:
 		return -ENOMEM;
-	case CDF_STATUS_E_FAILURE:
-	case CDF_STATUS_E_INVAL:
+	case QDF_STATUS_E_FAILURE:
+	case QDF_STATUS_E_INVAL:
 		return -EINVAL;
 	default:
 		return -EPERM;

core/cds/inc/cds_api.h

@@ -35,7 +35,6 @@
  */
 
 #include <cdf_types.h>
-#include <cdf_status.h>
 #include <qdf_status.h>
 #include <cdf_memory.h>
 #include <qdf_list.h>
@@ -186,17 +185,17 @@ static inline void cds_set_unload_in_progress(uint8_t value)
 v_CONTEXT_t cds_init(void);
 void cds_deinit(void);
 
-CDF_STATUS cds_pre_enable(v_CONTEXT_t cds_context);
+QDF_STATUS cds_pre_enable(v_CONTEXT_t cds_context);
 
-CDF_STATUS cds_open(void);
+QDF_STATUS cds_open(void);
 
-CDF_STATUS cds_enable(v_CONTEXT_t cds_context);
+QDF_STATUS cds_enable(v_CONTEXT_t cds_context);
 
-CDF_STATUS cds_disable(v_CONTEXT_t cds_context);
+QDF_STATUS cds_disable(v_CONTEXT_t cds_context);
 
-CDF_STATUS cds_close(v_CONTEXT_t cds_context);
+QDF_STATUS cds_close(v_CONTEXT_t cds_context);
 
-CDF_STATUS cds_shutdown(v_CONTEXT_t cds_context);
+QDF_STATUS cds_shutdown(v_CONTEXT_t cds_context);
 
 void cds_core_return_msg(void *pVContext, p_cds_msg_wrapper pMsgWrapper);
 
@@ -204,15 +203,15 @@ void *cds_get_context(CDF_MODULE_ID moduleId);
 
 v_CONTEXT_t cds_get_global_context(void);
 
-CDF_STATUS cds_alloc_context(void *p_cds_context, CDF_MODULE_ID moduleID,
+QDF_STATUS cds_alloc_context(void *p_cds_context, CDF_MODULE_ID moduleID,
 			     void **ppModuleContext, uint32_t size);
 
-CDF_STATUS cds_free_context(void *p_cds_context, CDF_MODULE_ID moduleID,
+QDF_STATUS cds_free_context(void *p_cds_context, CDF_MODULE_ID moduleID,
 			    void *pModuleContext);
 
-CDF_STATUS cds_set_context(CDF_MODULE_ID moduleID, void *context);
+QDF_STATUS cds_set_context(CDF_MODULE_ID moduleID, void *context);
 
-CDF_STATUS cds_get_vdev_types(enum tCDF_ADAPTER_MODE mode, uint32_t *type,
+QDF_STATUS cds_get_vdev_types(enum tCDF_ADAPTER_MODE mode, uint32_t *type,
 			      uint32_t *subType);
 
 void cds_flush_work(void *work);
@@ -230,7 +229,7 @@ void cds_set_ring_log_level(uint32_t ring_id, uint32_t log_level);
 enum wifi_driver_log_level cds_get_ring_log_level(uint32_t ring_id);
 void cds_set_multicast_logging(uint8_t value);
 uint8_t cds_is_multicast_logging(void);
-CDF_STATUS cds_set_log_completion(uint32_t is_fatal,
+QDF_STATUS cds_set_log_completion(uint32_t is_fatal,
 		uint32_t type,
 		uint32_t sub_type);
 void cds_get_log_completion(uint32_t *is_fatal,
@@ -239,7 +238,7 @@ void cds_get_log_completion(uint32_t *is_fatal,
 bool cds_is_log_report_in_progress(void);
 void cds_init_log_completion(void);
 void cds_deinit_log_completion(void);
-CDF_STATUS cds_flush_logs(uint32_t is_fatal,
+QDF_STATUS cds_flush_logs(uint32_t is_fatal,
 		uint32_t indicator,
 		uint32_t reason_code);
 void cds_logging_set_fw_flush_complete(void);

core/cds/inc/cds_concurrency.h

@@ -477,7 +477,7 @@ int cds_cfg80211_get_concurrency_matrix(struct wiphy *wiphy,
 			const void *data,
 			int data_len);
 uint32_t cds_get_concurrency_mode(void);
-CDF_STATUS cds_check_and_restart_sap(eCsrRoamResult roam_result,
+QDF_STATUS cds_check_and_restart_sap(eCsrRoamResult roam_result,
 		hdd_station_ctx_t *hdd_sta_ctx);
 void cds_handle_conc_rule1(hdd_adapter_t *adapter,
 		tCsrRoamProfile *roam_profile);
@@ -494,9 +494,9 @@ static inline bool cds_handle_conc_rule2(hdd_adapter_t *adapter,
 }
 #endif /* FEATURE_WLAN_CH_AVOID */
 uint8_t cds_search_and_check_for_session_conc(uint8_t session_id,
-		tCsrRoamProfile * roam_profile);
+		tCsrRoamProfile *roam_profile);
 bool cds_check_for_session_conc(uint8_t session_id, uint8_t channel);
-CDF_STATUS cds_handle_conc_multiport(uint8_t session_id, uint8_t channel);
+QDF_STATUS cds_handle_conc_multiport(uint8_t session_id, uint8_t channel);
 
 #ifdef FEATURE_WLAN_FORCE_SAP_SCC
 void cds_force_sap_on_scc(eCsrRoamResult roam_result,
@@ -525,7 +525,7 @@ uint8_t cds_is_mcc_in_24G(void);
 int32_t cds_set_mas(hdd_adapter_t *adapter, uint8_t mas_value);
 int cds_set_mcc_p2p_quota(hdd_adapter_t *hostapd_adapter,
 		uint32_t set_value);
-CDF_STATUS cds_change_mcc_go_beacon_interval(hdd_adapter_t *pHostapdAdapter);
+QDF_STATUS cds_change_mcc_go_beacon_interval(hdd_adapter_t *pHostapdAdapter);
 int cds_go_set_mcc_p2p_quota(hdd_adapter_t *hostapd_adapter,
 		uint32_t set_value);
 void cds_set_mcc_latency(hdd_adapter_t *adapter, int set_value);
@@ -555,32 +555,32 @@ void cds_decr_active_session(enum tCDF_ADAPTER_MODE mode,
 				uint8_t sessionId);
 void cds_decr_session_set_pcl(enum tCDF_ADAPTER_MODE mode,
 		uint8_t session_id);
-CDF_STATUS cds_init_policy_mgr(void);
-CDF_STATUS cds_deinit_policy_mgr(void);
-CDF_STATUS cds_get_pcl(enum cds_con_mode mode,
+QDF_STATUS cds_init_policy_mgr(void);
+QDF_STATUS cds_deinit_policy_mgr(void);
+QDF_STATUS cds_get_pcl(enum cds_con_mode mode,
 				uint8_t *pcl_Channels, uint32_t *len);
 bool cds_allow_concurrency(enum cds_con_mode mode,
 				uint8_t channel, enum hw_mode_bandwidth bw);
 enum cds_conc_priority_mode cds_get_first_connection_pcl_table_index(void);
 enum cds_one_connection_mode cds_get_second_connection_pcl_table_index(void);
 enum cds_two_connection_mode cds_get_third_connection_pcl_table_index(void);
-CDF_STATUS cds_incr_connection_count(uint32_t vdev_id);
-CDF_STATUS cds_update_connection_info(uint32_t vdev_id);
-CDF_STATUS cds_decr_connection_count(uint32_t vdev_id);
-CDF_STATUS cds_current_connections_update(uint32_t session_id,
+QDF_STATUS cds_incr_connection_count(uint32_t vdev_id);
+QDF_STATUS cds_update_connection_info(uint32_t vdev_id);
+QDF_STATUS cds_decr_connection_count(uint32_t vdev_id);
+QDF_STATUS cds_current_connections_update(uint32_t session_id,
 				uint8_t channel,
 				enum cds_conn_update_reason);
 bool cds_is_ibss_conn_exist(uint8_t *ibss_channel);
 #ifdef MPC_UT_FRAMEWORK
-CDF_STATUS cds_incr_connection_count_utfw(
+QDF_STATUS cds_incr_connection_count_utfw(
 		uint32_t vdev_id, uint32_t tx_streams, uint32_t rx_streams,
 		uint32_t chain_mask, uint32_t type, uint32_t sub_type,
 		uint32_t channelid, uint32_t mac_id);
-CDF_STATUS cds_update_connection_info_utfw(
+QDF_STATUS cds_update_connection_info_utfw(
 		uint32_t vdev_id, uint32_t tx_streams, uint32_t rx_streams,
 		uint32_t chain_mask, uint32_t type, uint32_t sub_type,
 		uint32_t channelid, uint32_t mac_id);
-CDF_STATUS cds_decr_connection_count_utfw(
+QDF_STATUS cds_decr_connection_count_utfw(
 		uint32_t del_all, uint32_t vdev_id);
 struct cds_conc_connection_info *cds_get_conn_info(uint32_t *len);
 enum cds_pcl_type get_pcl_from_first_conn_table(enum cds_con_mode type,
@@ -592,24 +592,24 @@ enum cds_pcl_type get_pcl_from_third_conn_table(
 	enum cds_two_connection_mode idx, enum cds_con_mode type,
 	enum cds_conc_priority_mode sys_pref, uint8_t dbs_capable);
 #else
-static inline CDF_STATUS cds_incr_connection_count_utfw(uint32_t vdev_id,
+static inline QDF_STATUS cds_incr_connection_count_utfw(uint32_t vdev_id,
 		uint32_t tx_streams, uint32_t rx_streams,
 		uint32_t chain_mask, uint32_t type, uint32_t sub_type,
 		uint32_t channelid, uint32_t mac_id)
 {
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
-static inline CDF_STATUS cds_update_connection_info_utfw(uint32_t vdev_id,
+static inline QDF_STATUS cds_update_connection_info_utfw(uint32_t vdev_id,
 		uint32_t tx_streams, uint32_t rx_streams,
 		uint32_t chain_mask, uint32_t type, uint32_t sub_type,
 		uint32_t channelid, uint32_t mac_id)
 {
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
-static inline CDF_STATUS cds_decr_connection_count_utfw(uint32_t del_all,
+static inline QDF_STATUS cds_decr_connection_count_utfw(uint32_t del_all,
 		uint32_t vdev_id)
 {
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 static inline struct cds_conc_connection_info *cds_get_conn_info(uint32_t *len)
 {
@@ -618,7 +618,7 @@ static inline struct cds_conc_connection_info *cds_get_conn_info(uint32_t *len)
 #endif
 enum cds_con_mode cds_convert_device_mode_to_hdd_type(
 				device_mode_t device_mode);
-CDF_STATUS cds_soc_set_hw_mode(uint32_t session_id,
+QDF_STATUS cds_soc_set_hw_mode(uint32_t session_id,
 		enum hw_mode_ss_config mac0_ss,
 		enum hw_mode_bandwidth mac0_bw,
 		enum hw_mode_ss_config mac1_ss,
@@ -627,7 +627,7 @@ CDF_STATUS cds_soc_set_hw_mode(uint32_t session_id,
 		enum hw_mode_agile_dfs_capab dfs,
 		enum cds_conn_update_reason reason);
 enum cds_conc_next_action cds_need_opportunistic_upgrade(void);
-CDF_STATUS cds_next_actions(uint32_t session_id,
+QDF_STATUS cds_next_actions(uint32_t session_id,
 		enum cds_conc_next_action action,
 		enum cds_conn_update_reason reason);
 void cds_set_dual_mac_scan_config(uint8_t dbs_val,
@@ -640,7 +640,7 @@ void cds_soc_set_dual_mac_cfg_cb(enum set_hw_mode_status status,
 		uint32_t fw_mode_config);
 bool cds_map_concurrency_mode(enum tCDF_ADAPTER_MODE *old_mode,
 		enum cds_con_mode *new_mode);
-CDF_STATUS cds_get_channel_from_scan_result(hdd_adapter_t *adapter,
+QDF_STATUS cds_get_channel_from_scan_result(hdd_adapter_t *adapter,
 		tCsrRoamProfile *roam_profile, uint8_t *channel);
 
 enum tCDF_GLOBAL_CON_MODE cds_get_conparam(void);
@@ -650,8 +650,8 @@ void cds_clear_concurrent_session_count(void);
 bool cds_is_multiple_active_sta_sessions(void);
 bool cds_is_sta_active_connection_exists(void);
 bool cds_concurrent_beaconing_sessions_running(void);
-CDF_STATUS cdf_wait_for_connection_update(void);
-CDF_STATUS cdf_reset_connection_update(void);
-CDF_STATUS cdf_set_connection_update(void);
-CDF_STATUS cdf_init_connection_update(void);
+QDF_STATUS cdf_wait_for_connection_update(void);
+QDF_STATUS cdf_reset_connection_update(void);
+QDF_STATUS cdf_set_connection_update(void);
+QDF_STATUS cdf_init_connection_update(void);
 #endif /* __CDS_CONCURRENCY_H */

core/cds/inc/cds_crypto.h

@@ -35,7 +35,6 @@
  */
 
 #include <cdf_types.h>
-#include <cdf_status.h>
 #include <qdf_status.h>
 #include <cdf_memory.h>
 #include <qdf_list.h>

core/cds/inc/cds_mq.h

@@ -42,7 +42,6 @@
    Include Files
    ------------------------------------------------------------------------*/
 #include <cdf_types.h>
-#include <cdf_status.h>
 #include <qdf_status.h>
 
 /*--------------------------------------------------------------------------
@@ -129,21 +128,21 @@ typedef enum {
    message needs anything in this message, it needs to copy the contents
    before returning from the message queue handler.
 
-   \return CDF_STATUS_SUCCESS - the message has been successfully posted
+   \return QDF_STATUS_SUCCESS - the message has been successfully posted
    to the message queue.
 
-   CDF_STATUS_E_INVAL - The value specified by msgQueueId does not
+   QDF_STATUS_E_INVAL - The value specified by msgQueueId does not
    refer to a valid Message Queue Id.
 
-   CDF_STATUS_E_FAULT  - message is an invalid pointer.
+   QDF_STATUS_E_FAULT  - message is an invalid pointer.
 
-   CDF_STATUS_E_FAILURE - the message queue handler has reported
+   QDF_STATUS_E_FAILURE - the message queue handler has reported
    an unknown failure.
 
    \sa
 
    --------------------------------------------------------------------------*/
-CDF_STATUS cds_mq_post_message(CDS_MQ_ID msgQueueId, cds_msg_t *message);
+QDF_STATUS cds_mq_post_message(CDS_MQ_ID msgQueueId, cds_msg_t *message);
 
 /**---------------------------------------------------------------------------
 
@@ -152,15 +151,15 @@ CDF_STATUS cds_mq_post_message(CDS_MQ_ID msgQueueId, cds_msg_t *message);
    \param pBuf is a buffer allocated by caller. The actual structure varies
    base on message type
 
-   \return CDF_STATUS_SUCCESS - the message has been successfully posted
+   \return QDF_STATUS_SUCCESS - the message has been successfully posted
    to the message queue.
 
-   CDF_STATUS_E_FAILURE - the message queue handler has reported
+   QDF_STATUS_E_FAILURE - the message queue handler has reported
    an unknown failure.
 
    \sa
    --------------------------------------------------------------------------*/
 
-CDF_STATUS cds_send_mb_message_to_mac(void *pBuf);
+QDF_STATUS cds_send_mb_message_to_mac(void *pBuf);
 
 #endif /* if !defined __CDS_MQ_H */

core/cds/inc/cds_packet.h

@@ -42,7 +42,6 @@
    Include Files
    ------------------------------------------------------------------------*/
 #include <cdf_types.h>
-#include <cdf_status.h>
 #include <qdf_status.h>
 
 /*--------------------------------------------------------------------------
@@ -119,13 +118,13 @@ static inline void cds_pkt_proto_trace_close(void) {}
  * cds_pkt_return_packet  Free the cds Packet
  * @ cds Packet
  */
-CDF_STATUS cds_pkt_return_packet(cds_pkt_t *packet);
+QDF_STATUS cds_pkt_return_packet(cds_pkt_t *packet);
 
 /**
  * cds_pkt_get_packet_length  Returns the packet length
  * @ cds Packet
  */
-CDF_STATUS cds_pkt_get_packet_length(cds_pkt_t *pPacket,
+QDF_STATUS cds_pkt_get_packet_length(cds_pkt_t *pPacket,
 				     uint16_t *pPacketSize);
 
 /*
@@ -175,15 +174,15 @@ typedef enum {
 #define cds_packet_alloc(s, d, p)	\
 	cds_packet_alloc_debug(s, d, p, __FILE__, __LINE__)
 
-CDF_STATUS cds_packet_alloc_debug(uint16_t size, void **data, void **ppPacket,
+QDF_STATUS cds_packet_alloc_debug(uint16_t size, void **data, void **ppPacket,
 				  uint8_t *file_name, uint32_t line_num);
 #else
-CDF_STATUS cds_packet_alloc(uint16_t size, void **data, void **ppPacket);
+QDF_STATUS cds_packet_alloc(uint16_t size, void **data, void **ppPacket);
 #endif
 
 void cds_packet_free(void *pPacket);
 
-typedef CDF_STATUS (*cds_pkt_get_packet_callback)(cds_pkt_t *pPacket,
+typedef QDF_STATUS (*cds_pkt_get_packet_callback)(cds_pkt_t *pPacket,
 						  void *userData);
 
 #endif /* !defined( __CDS_PKT_H ) */

core/cds/inc/cds_reg_service.h

@@ -36,7 +36,7 @@
 
    ========================================================================*/
 
-#include "cdf_status.h"
+#include "qdf_status.h"
 
 #define CDS_COUNTRY_CODE_LEN  2
 #define CDS_MAC_ADDRESS_LEN 6
@@ -318,26 +318,26 @@ enum channel_width {
 extern struct regulatory_channel reg_channels[NUM_RF_CHANNELS];
 extern const struct chan_map chan_mapping[NUM_RF_CHANNELS];
 
-CDF_STATUS cds_get_reg_domain_from_country_code(v_REGDOMAIN_t *pRegDomain,
+QDF_STATUS cds_get_reg_domain_from_country_code(v_REGDOMAIN_t *pRegDomain,
 						const uint8_t *country_alpha2,
 						enum country_src source);
 
-CDF_STATUS cds_read_default_country(uint8_t *default_country);
+QDF_STATUS cds_read_default_country(uint8_t *default_country);
 
-CDF_STATUS cds_get_channel_list_with_power(struct channel_power
+QDF_STATUS cds_get_channel_list_with_power(struct channel_power
 					   *base_channels,
 					   uint8_t *num_base_channels,
 					   struct channel_power
 					   *channel_40mhz,
 					   uint8_t *num_channels_40mhz);
 
-CDF_STATUS cds_set_reg_domain(void *client_ctxt, v_REGDOMAIN_t reg_domain);
+QDF_STATUS cds_set_reg_domain(void *client_ctxt, v_REGDOMAIN_t reg_domain);
 
 enum channel_state cds_get_channel_state(uint32_t chan_num);
 
-CDF_STATUS cds_regulatory_init(void);
-CDF_STATUS cds_get_dfs_region(uint8_t *dfs_region);
-CDF_STATUS cds_set_dfs_region(uint8_t dfs_region);
+QDF_STATUS cds_regulatory_init(void);
+QDF_STATUS cds_get_dfs_region(uint8_t *dfs_region);
+QDF_STATUS cds_set_dfs_region(uint8_t dfs_region);
 bool cds_is_dsrc_channel(uint16_t);
 enum channel_state cds_get_bonded_channel_state(uint32_t chan_num,
 					   enum channel_width chan_width);

core/cds/inc/cds_sched.h

@@ -374,24 +374,24 @@ void cds_free_ol_rx_pkt_freeq(p_cds_sched_context pSchedContext);
    \param  p_cds_sched_context - pointer to a previously allocated buffer big
    enough to hold a scheduler context.
 
-   \return CDF_STATUS_SUCCESS - Scheduler was successfully initialized and
+   \return QDF_STATUS_SUCCESS - Scheduler was successfully initialized and
    is ready to be used.
 
-   CDF_STATUS_E_RESOURCES - System resources (other than memory)
+   QDF_STATUS_E_RESOURCES - System resources (other than memory)
    are unavailable to initilize the scheduler
 
-   CDF_STATUS_E_NOMEM - insufficient memory exists to initialize
+   QDF_STATUS_E_NOMEM - insufficient memory exists to initialize
    the scheduler
 
-   CDF_STATUS_E_INVAL - Invalid parameter passed to the scheduler Open
+   QDF_STATUS_E_INVAL - Invalid parameter passed to the scheduler Open
    function
 
-   CDF_STATUS_E_FAILURE - Failure to initialize the scheduler/
+   QDF_STATUS_E_FAILURE - Failure to initialize the scheduler/
 
    \sa cds_sched_open()
 
    -------------------------------------------------------------------------*/
-CDF_STATUS cds_sched_open(void *p_cds_context,
+QDF_STATUS cds_sched_open(void *p_cds_context,
 			  p_cds_sched_context pSchedCxt, uint32_t SchedCtxSize);
 
 /*---------------------------------------------------------------------------
@@ -409,27 +409,27 @@ CDF_STATUS cds_sched_open(void *p_cds_context,
 
    \param  p_cds_context - pointer to the global CDF Context
 
-   \return CDF_STATUS_SUCCESS - Scheduler was successfully initialized and
+   \return QDF_STATUS_SUCCESS - Scheduler was successfully initialized and
    is ready to be used.
 
-   CDF_STATUS_E_INVAL - Invalid parameter passed to the scheduler Open
+   QDF_STATUS_E_INVAL - Invalid parameter passed to the scheduler Open
    function
 
-   CDF_STATUS_E_FAILURE - Failure to initialize the scheduler/
+   QDF_STATUS_E_FAILURE - Failure to initialize the scheduler/
 
    \sa cds_sched_close()
 
    ---------------------------------------------------------------------------*/
-CDF_STATUS cds_sched_close(void *p_cds_context);
+QDF_STATUS cds_sched_close(void *p_cds_context);
 
 /* Helper routines provided to other CDS API's */
-CDF_STATUS cds_mq_init(p_cds_mq_type pMq);
+QDF_STATUS cds_mq_init(p_cds_mq_type pMq);
 void cds_mq_deinit(p_cds_mq_type pMq);
 void cds_mq_put(p_cds_mq_type pMq, p_cds_msg_wrapper pMsgWrapper);
 p_cds_msg_wrapper cds_mq_get(p_cds_mq_type pMq);
 bool cds_is_mq_empty(p_cds_mq_type pMq);
 p_cds_sched_context get_cds_sched_ctxt(void);
-CDF_STATUS cds_sched_init_mqs(p_cds_sched_context pSchedContext);
+QDF_STATUS cds_sched_init_mqs(p_cds_sched_context pSchedContext);
 void cds_sched_deinit_mqs(p_cds_sched_context pSchedContext);
 void cds_sched_flush_mc_mqs(p_cds_sched_context pSchedContext);
 

core/cds/inc/cds_utils.h

@@ -42,7 +42,6 @@
    Include Files
    ------------------------------------------------------------------------*/
 #include <cdf_types.h>
-#include <cdf_status.h>
 #include <qdf_status.h>
 #include <qdf_event.h>
 #include "ani_global.h"
@@ -90,9 +89,9 @@
    Function declarations and documenation
    ------------------------------------------------------------------------*/
 
-CDF_STATUS cds_crypto_init(uint32_t *phCryptProv);
+QDF_STATUS cds_crypto_init(uint32_t *phCryptProv);
 
-CDF_STATUS cds_crypto_deinit(uint32_t hCryptProv);
+QDF_STATUS cds_crypto_deinit(uint32_t hCryptProv);
 
 /**
  * cds_rand_get_bytes
@@ -105,9 +104,9 @@ CDF_STATUS cds_crypto_deinit(uint32_t hCryptProv);
  * @param numBytes the number of bytes that should be generated and
  * copied
  *
- * @return CDF_STATUS_SUCCSS if the operation succeeds
+ * @return QDF_STATUS_SUCCSS if the operation succeeds
  */
-CDF_STATUS cds_rand_get_bytes(uint32_t handle, uint8_t *pbBuf,
+QDF_STATUS cds_rand_get_bytes(uint32_t handle, uint8_t *pbBuf,
 			      uint32_t numBytes);
 
 /**
@@ -129,10 +128,10 @@ CDF_STATUS cds_rand_get_bytes(uint32_t handle, uint8_t *pbBuf,
  * @param keyLen length of key
  * @param digest holds resultant SHA1 HMAC (20B)
  *
- * @return CDF_STATUS_SUCCSS if the operation succeeds
+ * @return QDF_STATUS_SUCCSS if the operation succeeds
  *
  */
-CDF_STATUS cds_sha1_hmac_str(uint32_t cryptHandle,      /* Handle */
+QDF_STATUS cds_sha1_hmac_str(uint32_t cryptHandle,      /* Handle */
 			     uint8_t *text,    /* pointer to data stream */
 			     uint32_t textLen,  /* length of data stream */
 			     uint8_t *key,     /* pointer to authentication key */
@@ -158,21 +157,21 @@ CDF_STATUS cds_sha1_hmac_str(uint32_t cryptHandle,      /* Handle */
  * @param keyLen length of key
  * @param digest holds resultant MD5 HMAC (16B)
  *
- * @return CDF_STATUS_SUCCSS if the operation succeeds
+ * @return QDF_STATUS_SUCCSS if the operation succeeds
  *
  */
-CDF_STATUS cds_md5_hmac_str(uint32_t cryptHandle,       /* Handle */
+QDF_STATUS cds_md5_hmac_str(uint32_t cryptHandle,       /* Handle */
 			    uint8_t *text,     /* pointer to data stream */
 			    uint32_t textLen,   /* length of data stream */
 			    uint8_t *key,      /* pointer to authentication key */
 			    uint32_t keyLen,    /* length of authentication key */
 			    uint8_t digest[CDS_DIGEST_MD5_SIZE]);       /* caller digest to be filled in */
 
-CDF_STATUS cds_encrypt_aes(uint32_t cryptHandle,        /* Handle */
+QDF_STATUS cds_encrypt_aes(uint32_t cryptHandle,        /* Handle */
 			   uint8_t *pText,      /* pointer to data stream */
 			   uint8_t *Encrypted, uint8_t *pKey);          /* pointer to authentication key */
 
-CDF_STATUS cds_decrypt_aes(uint32_t cryptHandle,        /* Handle */
+QDF_STATUS cds_decrypt_aes(uint32_t cryptHandle,        /* Handle */
 			   uint8_t *pText,      /* pointer to data stream */
 			   uint8_t *pDecrypted, uint8_t *pKey);         /* pointer to authentication key */
 
@@ -186,5 +185,5 @@ bool cds_attach_mmie(uint8_t *igtk, uint8_t *ipn, uint16_t key_id,
 		     uint8_t *frm, uint8_t *efrm, uint16_t frmLen);
 uint8_t cds_get_mmie_size(void);
 #endif /* WLAN_FEATURE_11W */
-CDF_STATUS sme_send_flush_logs_cmd_to_fw(tpAniSirGlobal pMac);
+QDF_STATUS sme_send_flush_logs_cmd_to_fw(tpAniSirGlobal pMac);
 #endif /* #if !defined __CDS_UTILS_H */

core/cds/src/cds_api.c

@@ -164,9 +164,9 @@ static void cds_set_nan_enable(tMacOpenParameters *param,
  *
  * Return: CDF status
  */
-CDF_STATUS cds_open(void)
+QDF_STATUS cds_open(void)
 {
-	CDF_STATUS cdf_status = CDF_STATUS_SUCCESS;
+	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
 	int iter = 0;
 	tSirRetStatus sirStatus = eSIR_SUCCESS;
 	tMacOpenParameters mac_openParms;
@@ -184,7 +184,7 @@ CDF_STATUS cds_open(void)
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_FATAL,
 			  "%s: Trying to open CDS without a PreOpen", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	/* Initialize the timer module */
@@ -198,7 +198,7 @@ CDF_STATUS cds_open(void)
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_FATAL,
 			  "%s: Unable to init probeEvent", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 	if (qdf_event_create(&(gp_cds_context->wmaCompleteEvent)) !=
 	    QDF_STATUS_SUCCESS) {
@@ -209,8 +209,8 @@ CDF_STATUS cds_open(void)
 	}
 
 	/* Initialize the free message queue */
-	cdf_status = cds_mq_init(&gp_cds_context->freeVosMq);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = cds_mq_init(&gp_cds_context->freeVosMq);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		/* Critical Error ...  Cannot proceed further */
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_FATAL,
 			  "%s: Failed to initialize CDS free message queue",
@@ -228,10 +228,10 @@ CDF_STATUS cds_open(void)
 	}
 
 	/* Now Open the CDS Scheduler */
-	cdf_status = cds_sched_open(gp_cds_context, &gp_cds_context->cdf_sched,
+	qdf_status = cds_sched_open(gp_cds_context, &gp_cds_context->cdf_sched,
 				    sizeof(cds_sched_context));
 
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		/* Critical Error ...  Cannot proceed further */
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_FATAL,
 			  "%s: Failed to open CDS Scheduler", __func__);
@@ -259,10 +259,10 @@ CDF_STATUS cds_open(void)
 
 	ol_ctx = cds_get_context(CDF_MODULE_ID_BMI);
 	/* Initialize BMI and Download firmware */
-	cdf_status = bmi_download_firmware(ol_ctx);
-	if (cdf_status != CDF_STATUS_SUCCESS) {
+	qdf_status = bmi_download_firmware(ol_ctx);
+	if (qdf_status != QDF_STATUS_SUCCESS) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_FATAL,
-			  "BMI FIALED status:%d", cdf_status);
+			  "BMI FIALED status:%d", qdf_status);
 		goto err_bmi_close;
 	}
 
@@ -367,11 +367,11 @@ CDF_STATUS cds_open(void)
 	mac_openParms.self_gen_frm_pwr = pHddCtx->config->self_gen_frm_pwr;
 	mac_openParms.maxStation = pHddCtx->config->maxNumberOfPeers;
 
-	cdf_status = wma_open(gp_cds_context,
+	qdf_status = wma_open(gp_cds_context,
 			      hdd_update_tgt_cfg,
 			      hdd_dfs_indicate_radar, &mac_openParms);
 
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		/* Critical Error ...  Cannot proceed further */
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_FATAL,
 			  "%s: Failed to open WMA module", __func__);
@@ -417,8 +417,8 @@ CDF_STATUS cds_open(void)
 	}
 
 	/* Now proceed to open the SME */
-	cdf_status = sme_open(gp_cds_context->pMACContext);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = sme_open(gp_cds_context->pMACContext);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		/* Critical Error ...  Cannot proceed further */
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_FATAL,
 			  "%s: Failed to open SME", __func__);
@@ -441,7 +441,7 @@ CDF_STATUS cds_open(void)
 	CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_INFO_HIGH,
 		  "%s: CDS successfully Opened", __func__);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 
 err_sme_close:
 	sme_close(gp_cds_context->pMACContext);
@@ -475,7 +475,7 @@ err_wma_complete_event:
 err_probe_event:
 	qdf_event_destroy(&gp_cds_context->ProbeEvent);
 
-	return CDF_STATUS_E_FAILURE;
+	return QDF_STATUS_E_FAILURE;
 } /* cds_open() */
 
 /**
@@ -484,9 +484,9 @@ err_probe_event:
  *
  * Return: CDF status
  */
-CDF_STATUS cds_pre_enable(v_CONTEXT_t cds_context)
+QDF_STATUS cds_pre_enable(v_CONTEXT_t cds_context)
 {
-	CDF_STATUS cdf_status = CDF_STATUS_SUCCESS;
+	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;
@@ -496,40 +496,40 @@ CDF_STATUS cds_pre_enable(v_CONTEXT_t cds_context)
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Context mismatch", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	if (p_cds_context->pMACContext == NULL) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: MAC NULL context", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	if (p_cds_context->pWMAContext == NULL) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: WMA NULL context", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	scn = cds_get_context(CDF_MODULE_ID_HIF);
 	if (!scn) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_FATAL,
 			  "%s: scn is null!", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	/* Reset wma wait event */
 	qdf_event_reset(&gp_cds_context->wmaCompleteEvent);
 
 	/*call WMA pre start */
-	cdf_status = wma_pre_start(gp_cds_context);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = wma_pre_start(gp_cds_context);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_SYS, CDF_TRACE_LEVEL_FATAL,
 			  "Failed to WMA prestart");
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	/* Need to update time out of complete */
@@ -551,24 +551,24 @@ CDF_STATUS cds_pre_enable(v_CONTEXT_t cds_context)
 		wlan_sys_probe();
 
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
-	cdf_status = htc_start(gp_cds_context->htc_ctx);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = htc_start(gp_cds_context->htc_ctx);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_SYS, CDF_TRACE_LEVEL_FATAL,
 			  "Failed to Start HTC");
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
-	cdf_status = wma_wait_for_ready_event(gp_cds_context->pWMAContext);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = wma_wait_for_ready_event(gp_cds_context->pWMAContext);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_FATAL,
 			  "Failed to get ready event from target firmware");
 		htc_set_target_to_sleep(scn);
 		htc_stop(gp_cds_context->htc_ctx);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	if (ol_txrx_pdev_attach(gp_cds_context->pdev_txrx_ctx)) {
@@ -577,12 +577,12 @@ CDF_STATUS cds_pre_enable(v_CONTEXT_t cds_context)
 		htc_set_target_to_sleep(scn);
 		htc_stop(gp_cds_context->htc_ctx);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	htc_set_target_to_sleep(scn);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -591,9 +591,9 @@ CDF_STATUS cds_pre_enable(v_CONTEXT_t cds_context)
  *
  * Return: CDF status
  */
-CDF_STATUS cds_enable(v_CONTEXT_t cds_context)
+QDF_STATUS cds_enable(v_CONTEXT_t cds_context)
 {
-	CDF_STATUS cdf_status = CDF_STATUS_SUCCESS;
+	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;
@@ -606,7 +606,7 @@ CDF_STATUS cds_enable(v_CONTEXT_t cds_context)
 	if (gp_cds_context != p_cds_context) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: mismatch in context", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	if ((p_cds_context->pWMAContext == NULL) ||
@@ -618,15 +618,15 @@ CDF_STATUS cds_enable(v_CONTEXT_t cds_context)
 			CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 				  "%s: MAC NULL context", __func__);
 
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	/* Start the wma */
-	cdf_status = wma_start(p_cds_context);
-	if (cdf_status != CDF_STATUS_SUCCESS) {
+	qdf_status = wma_start(p_cds_context);
+	if (qdf_status != QDF_STATUS_SUCCESS) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to start wma", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 	CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_INFO,
 		  "%s: wma correctly started", __func__);
@@ -649,9 +649,9 @@ CDF_STATUS cds_enable(v_CONTEXT_t cds_context)
 		  "%s: MAC correctly started", __func__);
 
 	/* START SME */
-	cdf_status = sme_start(p_cds_context->pMACContext);
+	qdf_status = sme_start(p_cds_context->pMACContext);
 
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_FATAL,
 			  "%s: Failed to start SME", __func__);
 		goto err_mac_stop;
@@ -672,7 +672,7 @@ CDF_STATUS cds_enable(v_CONTEXT_t cds_context)
 	CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_INFO,
 		  "%s: CDS Start is successful!!", __func__);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 
 err_sme_stop:
 	sme_stop(p_cds_context->pMACContext, HAL_STOP_TYPE_SYS_RESET);
@@ -682,11 +682,11 @@ err_mac_stop:
 
 err_wma_stop:
 	qdf_event_reset(&(gp_cds_context->wmaCompleteEvent));
-	cdf_status = wma_stop(p_cds_context, HAL_STOP_TYPE_RF_KILL);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = wma_stop(p_cds_context, HAL_STOP_TYPE_RF_KILL);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to stop wma", __func__);
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(cdf_status));
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 		wma_setneedshutdown(cds_context);
 	} else {
 		qdf_status =
@@ -709,7 +709,7 @@ err_wma_stop:
 		}
 	}
 
-	return CDF_STATUS_E_FAILURE;
+	return QDF_STATUS_E_FAILURE;
 } /* cds_enable() */
 
 /**
@@ -718,9 +718,9 @@ err_wma_stop:
  *
  * Return: CDF status
  */
-CDF_STATUS cds_disable(v_CONTEXT_t cds_context)
+QDF_STATUS cds_disable(v_CONTEXT_t cds_context)
 {
-	CDF_STATUS cdf_status;
+	QDF_STATUS qdf_status;
 
 	/* wma_stop is called before the SYS so that the processing of target
 	 * pending responses will not be handled during uninitialization of
@@ -728,12 +728,12 @@ CDF_STATUS cds_disable(v_CONTEXT_t cds_context)
 	 */
 	qdf_event_reset(&(gp_cds_context->wmaCompleteEvent));
 
-	cdf_status = wma_stop(cds_context, HAL_STOP_TYPE_RF_KILL);
+	qdf_status = wma_stop(cds_context, HAL_STOP_TYPE_RF_KILL);
 
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to stop wma", __func__);
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(cdf_status));
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 		wma_setneedshutdown(cds_context);
 	}
 
@@ -741,14 +741,14 @@ CDF_STATUS cds_disable(v_CONTEXT_t cds_context)
 	hif_reset_soc(((cds_context_type *) cds_context)->pHIFContext);
 
 	/* SYS STOP will stop SME and MAC */
-	cdf_status = sys_stop(cds_context);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = sys_stop(cds_context);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to stop SYS", __func__);
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(cdf_status));
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -757,13 +757,13 @@ CDF_STATUS cds_disable(v_CONTEXT_t cds_context)
  *
  * Return: CDF status
  */
-CDF_STATUS cds_close(v_CONTEXT_t cds_context)
+QDF_STATUS cds_close(v_CONTEXT_t cds_context)
 {
-	CDF_STATUS cdf_status;
+	QDF_STATUS qdf_status;
 	QDF_STATUS qdf_status;
 
-	cdf_status = wma_wmi_work_close(cds_context);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = wma_wmi_work_close(cds_context);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 		 "%s: Failed to close wma_wmi_work", __func__);
 		CDF_ASSERT(0);
@@ -779,18 +779,18 @@ CDF_STATUS cds_close(v_CONTEXT_t cds_context)
 	cds_free_context(cds_context, CDF_MODULE_ID_TXRX,
 			 gp_cds_context->pdev_txrx_ctx);
 
-	cdf_status = sme_close(((p_cds_contextType) cds_context)->pMACContext);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = sme_close(((p_cds_contextType) cds_context)->pMACContext);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to close SME", __func__);
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(cdf_status));
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 	}
 
-	cdf_status = mac_close(((p_cds_contextType) cds_context)->pMACContext);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = mac_close(((p_cds_contextType) cds_context)->pMACContext);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to close MAC", __func__);
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(cdf_status));
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 	}
 
 	((p_cds_contextType) cds_context)->pMACContext = NULL;
@@ -799,19 +799,19 @@ CDF_STATUS cds_close(v_CONTEXT_t cds_context)
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 				  "%s: Failed to shutdown wma", __func__);
 	} else {
-		cdf_status = wma_close(cds_context);
-		if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+		qdf_status = wma_close(cds_context);
+		if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 			CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 				  "%s: Failed to close wma", __func__);
-			CDF_ASSERT(CDF_IS_STATUS_SUCCESS(cdf_status));
+			CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 		}
 	}
 
-	cdf_status = wma_wmi_service_close(cds_context);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = wma_wmi_service_close(cds_context);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to close wma_wmi_service", __func__);
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(cdf_status));
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 	}
 
 	cds_mq_deinit(&((p_cds_contextType) cds_context)->freeVosMq);
@@ -834,7 +834,7 @@ CDF_STATUS cds_close(v_CONTEXT_t cds_context)
 
 	gp_cds_context->pHDDContext = NULL;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -1033,7 +1033,7 @@ void cds_clear_driver_state(enum cds_driver_state state)
  * @moduleId: module ID who's context area is being allocated.
  * @ppModuleContext: pointer to location where the pointer to the
  *	allocated context is returned. Note this output pointer
- *	is valid only if the API returns CDF_STATUS_SUCCESS
+ *	is valid only if the API returns QDF_STATUS_SUCCESS
  * @param size: size of the context area to be allocated.
  *
  * This API allows any user to allocate a user context area within the
@@ -1041,7 +1041,7 @@ void cds_clear_driver_state(enum cds_driver_state state)
  *
  * Return: CDF status
  */
-CDF_STATUS cds_alloc_context(void *p_cds_context, CDF_MODULE_ID moduleID,
+QDF_STATUS cds_alloc_context(void *p_cds_context, CDF_MODULE_ID moduleID,
 			     void **ppModuleContext, uint32_t size)
 {
 	void **pGpModContext = NULL;
@@ -1049,14 +1049,14 @@ CDF_STATUS cds_alloc_context(void *p_cds_context, CDF_MODULE_ID moduleID,
 	if (p_cds_context == NULL) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: cds context is null", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	if ((gp_cds_context != p_cds_context) || (ppModuleContext == NULL)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: context mismatch or null param passed",
 			  __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	switch (moduleID) {
@@ -1090,7 +1090,7 @@ CDF_STATUS cds_alloc_context(void *p_cds_context, CDF_MODULE_ID moduleID,
 			  "does not have its context allocated by CDS",
 			  __func__, moduleID);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 	}
 
@@ -1101,7 +1101,7 @@ CDF_STATUS cds_alloc_context(void *p_cds_context, CDF_MODULE_ID moduleID,
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Module ID %i context has already been allocated",
 			  __func__, moduleID);
-		return CDF_STATUS_E_EXISTS;
+		return QDF_STATUS_E_EXISTS;
 	}
 
 	/* Dynamically allocate the context for module */
@@ -1113,7 +1113,7 @@ CDF_STATUS cds_alloc_context(void *p_cds_context, CDF_MODULE_ID moduleID,
 			  "%s: Failed to " "allocate Context for module ID %i",
 			  __func__, moduleID);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_NOMEM;
+		return QDF_STATUS_E_NOMEM;
 	}
 
 	if (moduleID == CDF_MODULE_ID_TLSHIM)
@@ -1121,7 +1121,7 @@ CDF_STATUS cds_alloc_context(void *p_cds_context, CDF_MODULE_ID moduleID,
 
 	*pGpModContext = *ppModuleContext;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 } /* cds_alloc_context() */
 
 /**
@@ -1131,16 +1131,16 @@ CDF_STATUS cds_alloc_context(void *p_cds_context, CDF_MODULE_ID moduleID,
  *
  * API to set a MODULE Context in gloabl CDS Context
  *
- * Return: CDF_STATUS
+ * Return: QDF_STATUS
  */
-CDF_STATUS cds_set_context(CDF_MODULE_ID module_id, void *context)
+QDF_STATUS cds_set_context(CDF_MODULE_ID module_id, void *context)
 {
 	p_cds_contextType p_cds_context = cds_get_global_context();
 
 	if (!p_cds_context) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "cds context is Invald");
-		return CDF_STATUS_NOT_INITIALIZED;
+		return QDF_STATUS_NOT_INITIALIZED;
 	}
 
 	switch (module_id) {
@@ -1152,10 +1152,10 @@ CDF_STATUS cds_set_context(CDF_MODULE_ID module_id, void *context)
 			  "%s: Module ID %i does not have its context "
 			  "allocated by CDS", __func__, module_id);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -1170,7 +1170,7 @@ CDF_STATUS cds_set_context(CDF_MODULE_ID module_id, void *context)
  *
  * Return: CDF status
  */
-CDF_STATUS cds_free_context(void *p_cds_context, CDF_MODULE_ID moduleID,
+QDF_STATUS cds_free_context(void *p_cds_context, CDF_MODULE_ID moduleID,
 			    void *pModuleContext)
 {
 	void **pGpModContext = NULL;
@@ -1179,7 +1179,7 @@ CDF_STATUS cds_free_context(void *p_cds_context, CDF_MODULE_ID moduleID,
 	    (pModuleContext == NULL)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Null params or context mismatch", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	switch (moduleID) {
@@ -1219,7 +1219,7 @@ CDF_STATUS cds_free_context(void *p_cds_context, CDF_MODULE_ID moduleID,
 			  "does not have its context allocated by CDS",
 			  __func__, moduleID);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 	}
 
@@ -1229,13 +1229,13 @@ CDF_STATUS cds_free_context(void *p_cds_context, CDF_MODULE_ID moduleID,
 			  "%s: Module ID %i "
 			  "context has not been allocated or freed already",
 			  __func__, moduleID);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	if (*pGpModContext != pModuleContext) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: pGpModContext != pModuleContext", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	if (pModuleContext != NULL)
@@ -1243,7 +1243,7 @@ CDF_STATUS cds_free_context(void *p_cds_context, CDF_MODULE_ID moduleID,
 
 	*pGpModContext = NULL;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 } /* cds_free_context() */
 
 /**
@@ -1258,7 +1258,7 @@ CDF_STATUS cds_free_context(void *p_cds_context, CDF_MODULE_ID moduleID,
  *
  * Return: CDF status
  */
-CDF_STATUS cds_mq_post_message(CDS_MQ_ID msgQueueId, cds_msg_t *pMsg)
+QDF_STATUS cds_mq_post_message(CDS_MQ_ID msgQueueId, cds_msg_t *pMsg)
 {
 	p_cds_mq_type pTargetMq = NULL;
 	p_cds_msg_wrapper pMsgWrapper = NULL;
@@ -1269,7 +1269,7 @@ CDF_STATUS cds_mq_post_message(CDS_MQ_ID msgQueueId, cds_msg_t *pMsg)
 			  "%s: Null params or global cds context is null",
 			  __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	switch (msgQueueId) {
@@ -1306,14 +1306,14 @@ CDF_STATUS cds_mq_post_message(CDS_MQ_ID msgQueueId, cds_msg_t *pMsg)
 			  ("%s: Trying to queue msg into unknown MC Msg queue ID %d"),
 			  __func__, msgQueueId);
 
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	CDF_ASSERT(NULL != pTargetMq);
 	if (pTargetMq == NULL) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: pTargetMq == NULL", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	/* Try and get a free Msg wrapper */
@@ -1329,7 +1329,7 @@ CDF_STATUS cds_mq_post_message(CDS_MQ_ID msgQueueId, cds_msg_t *pMsg)
 		if (CDS_WRAPPER_MAX_FAIL_COUNT == debug_count)
 			CDF_BUG(0);
 
-		return CDF_STATUS_E_RESOURCES;
+		return QDF_STATUS_E_RESOURCES;
 	}
 
 	atomic_set(&cds_wrapper_empty_count, 0);
@@ -1343,7 +1343,7 @@ CDF_STATUS cds_mq_post_message(CDS_MQ_ID msgQueueId, cds_msg_t *pMsg)
 	set_bit(MC_POST_EVENT_MASK, &gp_cds_context->cdf_sched.mcEventFlag);
 	wake_up_interruptible(&gp_cds_context->cdf_sched.mcWaitQueue);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 } /* cds_mq_post_message() */
 
 /**
@@ -1430,9 +1430,9 @@ void cds_core_return_msg(void *pVContext, p_cds_msg_wrapper pMsgWrapper)
  *
  * Return: CDF status
  */
-CDF_STATUS cds_shutdown(v_CONTEXT_t cds_context)
+QDF_STATUS cds_shutdown(v_CONTEXT_t cds_context)
 {
-	CDF_STATUS cdf_status;
+	QDF_STATUS qdf_status;
 	QDF_STATUS qdf_status;
 	tpAniSirGlobal pmac = (((p_cds_contextType)cds_context)->pMACContext);
 
@@ -1440,11 +1440,11 @@ CDF_STATUS cds_shutdown(v_CONTEXT_t cds_context)
 	cds_free_context(cds_context, CDF_MODULE_ID_TXRX,
 			 gp_cds_context->pdev_txrx_ctx);
 
-	cdf_status = sme_close(((p_cds_contextType) cds_context)->pMACContext);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = sme_close(((p_cds_contextType) cds_context)->pMACContext);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to close SME", __func__);
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(cdf_status));
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 	}
 	/*
 	 * CAC timer will be initiated and started only when SAP starts on
@@ -1458,27 +1458,27 @@ CDF_STATUS cds_shutdown(v_CONTEXT_t cds_context)
 		cdf_mc_timer_destroy(&pmac->sap.SapDfsInfo.sap_dfs_cac_timer);
 	}
 
-	cdf_status = mac_close(((p_cds_contextType) cds_context)->pMACContext);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = mac_close(((p_cds_contextType) cds_context)->pMACContext);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to close MAC", __func__);
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(cdf_status));
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 	}
 
 	((p_cds_contextType) cds_context)->pMACContext = NULL;
 
 	if (false == wma_needshutdown(cds_context)) {
 
-		cdf_status = wma_close(cds_context);
-		if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+		qdf_status = wma_close(cds_context);
+		if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 			CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 				  "%s: Failed to close wma!", __func__);
-			CDF_ASSERT(CDF_IS_STATUS_SUCCESS(cdf_status));
+			CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 		}
 	}
 
-	cdf_status = wma_wmi_work_close(cds_context);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = wma_wmi_work_close(cds_context);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 		"%s: Failed to close wma_wmi_work!", __func__);
 		CDF_ASSERT(0);
@@ -1490,11 +1490,11 @@ CDF_STATUS cds_shutdown(v_CONTEXT_t cds_context)
 		gp_cds_context->htc_ctx = NULL;
 	}
 
-	cdf_status = wma_wmi_service_close(cds_context);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = wma_wmi_service_close(cds_context);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to close wma_wmi_service!", __func__);
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(cdf_status));
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 	}
 
 	cds_mq_deinit(&((p_cds_contextType) cds_context)->freeVosMq);
@@ -1513,7 +1513,7 @@ CDF_STATUS cds_shutdown(v_CONTEXT_t cds_context)
 		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -1524,10 +1524,10 @@ CDF_STATUS cds_shutdown(v_CONTEXT_t cds_context)
  *
  * Return: WMI vdev type
  */
-CDF_STATUS cds_get_vdev_types(enum tCDF_ADAPTER_MODE mode, uint32_t *type,
+QDF_STATUS cds_get_vdev_types(enum tCDF_ADAPTER_MODE mode, uint32_t *type,
 			      uint32_t *sub_type)
 {
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	*type = 0;
 	*sub_type = 0;
 
@@ -1556,7 +1556,7 @@ CDF_STATUS cds_get_vdev_types(enum tCDF_ADAPTER_MODE mode, uint32_t *type,
 	default:
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "Invalid device mode %d", mode);
-		status = CDF_STATUS_E_INVAL;
+		status = QDF_STATUS_E_INVAL;
 		break;
 	}
 	return status;
@@ -1891,7 +1891,7 @@ void cds_deinit_log_completion(void)
  *
  * Return: 0 if setting of params is successful
  */
-CDF_STATUS cds_set_log_completion(uint32_t is_fatal,
+QDF_STATUS cds_set_log_completion(uint32_t is_fatal,
 		uint32_t indicator,
 		uint32_t reason_code)
 {
@@ -1901,7 +1901,7 @@ CDF_STATUS cds_set_log_completion(uint32_t is_fatal,
 	if (!p_cds_context) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 				"%s: cds context is Invalid", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	cdf_spinlock_acquire(&p_cds_context->bug_report_lock);
@@ -1910,7 +1910,7 @@ CDF_STATUS cds_set_log_completion(uint32_t is_fatal,
 	p_cds_context->log_complete.reason_code = reason_code;
 	p_cds_context->log_complete.is_report_in_progress = true;
 	cdf_spinlock_release(&p_cds_context->bug_report_lock);
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -1976,12 +1976,12 @@ bool cds_is_log_report_in_progress(void)
  *
  * Return: 0 on success
  */
-CDF_STATUS cds_flush_logs(uint32_t is_fatal,
+QDF_STATUS cds_flush_logs(uint32_t is_fatal,
 		uint32_t indicator,
 		uint32_t reason_code)
 {
 	uint32_t ret;
-	CDF_STATUS status;
+	QDF_STATUS status;
 
 	p_cds_contextType p_cds_context;
 
@@ -1989,21 +1989,21 @@ CDF_STATUS cds_flush_logs(uint32_t is_fatal,
 	if (!p_cds_context) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 				"%s: cds context is Invalid", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	if (cds_is_log_report_in_progress() == true) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 				"%s: Bug report already in progress - dropping! type:%d, indicator=%d reason_code=%d",
 				__func__, is_fatal, indicator, reason_code);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	status = cds_set_log_completion(is_fatal, indicator, reason_code);
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			"%s: Failed to set log trigger params", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_INFO,
@@ -2015,10 +2015,10 @@ CDF_STATUS cds_flush_logs(uint32_t is_fatal,
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 				"%s: Failed to send flush FW log", __func__);
 		cds_init_log_completion();
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**

core/cds/src/cds_mq.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014-2015 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -55,13 +55,13 @@ tSirRetStatus u_mac_post_ctrl_msg(void *pSirGlobal, void *pMb);
  *
  * Return: cdf status
  */
-inline CDF_STATUS cds_mq_init(p_cds_mq_type pMq)
+inline QDF_STATUS cds_mq_init(p_cds_mq_type pMq)
 {
 
 	if (pMq == NULL) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: NULL pointer passed", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	/* Now initialize the lock */
@@ -70,7 +70,7 @@ inline CDF_STATUS cds_mq_init(p_cds_mq_type pMq)
 	/* Now initialize the List data structure */
 	INIT_LIST_HEAD(&pMq->mqList);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 } /* cds_mq_init() */
 
 /**
@@ -170,7 +170,7 @@ inline bool cds_is_mq_empty(p_cds_mq_type pMq)
 	if (pMq == NULL) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: NULL pointer passed", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	spin_lock_irqsave(&pMq->mqLock, flags);
@@ -186,9 +186,9 @@ inline bool cds_is_mq_empty(p_cds_mq_type pMq)
  *
  * Return: cdf status
  */
-CDF_STATUS cds_send_mb_message_to_mac(void *pBuf)
+QDF_STATUS cds_send_mb_message_to_mac(void *pBuf)
 {
-	CDF_STATUS cdf_ret_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS cdf_ret_status = QDF_STATUS_E_FAILURE;
 	tSirRetStatus sirStatus;
 	v_CONTEXT_t cds_context;
 	void *hHal;
@@ -205,7 +205,7 @@ CDF_STATUS cds_send_mb_message_to_mac(void *pBuf)
 		} else {
 			sirStatus = u_mac_post_ctrl_msg(hHal, pBuf);
 			if (eSIR_SUCCESS == sirStatus)
-				cdf_ret_status = CDF_STATUS_SUCCESS;
+				cdf_ret_status = QDF_STATUS_SUCCESS;
 		}
 	}
 

core/cds/src/cds_packet.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014-2015 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -76,11 +76,11 @@ cdf_spinlock_t trace_buffer_lock;
  * cds_pkt_return_packet  Free the cds Packet
  * @ cds Packet
  */
-CDF_STATUS cds_pkt_return_packet(cds_pkt_t *packet)
+QDF_STATUS cds_pkt_return_packet(cds_pkt_t *packet)
 {
 	/* Validate the input parameter pointer */
 	if (unlikely(packet == NULL)) {
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	/* Free up the Adf nbuf */
@@ -91,7 +91,7 @@ CDF_STATUS cds_pkt_return_packet(cds_pkt_t *packet)
 	/* Free up the Rx packet */
 	cdf_mem_free(packet);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**--------------------------------------------------------------------------
@@ -103,13 +103,13 @@ CDF_STATUS cds_pkt_return_packet(cds_pkt_t *packet)
    \param pPacket - the cds Packet to get the packet length from.
 
    \param pPacketSize - location to return the total size of the data contained
-                       in the cds Packet.
+   in the cds Packet.
    \return
 
    \sa
 
    ---------------------------------------------------------------------------*/
-CDF_STATUS
+QDF_STATUS
 cds_pkt_get_packet_length(cds_pkt_t *pPacket, uint16_t *pPacketSize)
 {
 	/* Validate the parameter pointers */
@@ -117,11 +117,11 @@ cds_pkt_get_packet_length(cds_pkt_t *pPacket, uint16_t *pPacketSize)
 	    (pPacket->pkt_buf == NULL)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_FATAL,
 			  "VPKT [%d]: NULL pointer", __LINE__);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 	/* return the requested information */
 	*pPacketSize = cdf_nbuf_len(pPacket->pkt_buf);
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /*---------------------------------------------------------------------------
@@ -289,10 +289,10 @@ void cds_pkt_proto_trace_close(void)
 * @brief cds_packet_alloc_debug() -
       Allocate a network buffer for TX
    ---------------------------------------------------------------------------*/
-CDF_STATUS cds_packet_alloc_debug(uint16_t size, void **data, void **ppPacket,
+QDF_STATUS cds_packet_alloc_debug(uint16_t size, void **data, void **ppPacket,
 				  uint8_t *file_name, uint32_t line_num)
 {
-	CDF_STATUS cdf_ret_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS cdf_ret_status = QDF_STATUS_E_FAILURE;
 	cdf_nbuf_t nbuf;
 
 	nbuf =
@@ -305,7 +305,7 @@ CDF_STATUS cds_packet_alloc_debug(uint16_t size, void **data, void **ppPacket,
 		cdf_nbuf_set_protocol(nbuf, ETH_P_CONTROL);
 		*ppPacket = nbuf;
 		*data = cdf_nbuf_data(nbuf);
-		cdf_ret_status = CDF_STATUS_SUCCESS;
+		cdf_ret_status = QDF_STATUS_SUCCESS;
 	}
 
 	return cdf_ret_status;
@@ -315,9 +315,9 @@ CDF_STATUS cds_packet_alloc_debug(uint16_t size, void **data, void **ppPacket,
 * @brief cds_packet_alloc() -
       Allocate a network buffer for TX
    ---------------------------------------------------------------------------*/
-CDF_STATUS cds_packet_alloc(uint16_t size, void **data, void **ppPacket)
+QDF_STATUS cds_packet_alloc(uint16_t size, void **data, void **ppPacket)
 {
-	CDF_STATUS cdf_ret_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS cdf_ret_status = QDF_STATUS_E_FAILURE;
 	cdf_nbuf_t nbuf;
 
 	nbuf = cdf_nbuf_alloc(NULL, roundup(size + TX_PKT_MIN_HEADROOM, 4),
@@ -328,7 +328,7 @@ CDF_STATUS cds_packet_alloc(uint16_t size, void **data, void **ppPacket)
 		cdf_nbuf_set_protocol(nbuf, ETH_P_CONTROL);
 		*ppPacket = nbuf;
 		*data = cdf_nbuf_data(nbuf);
-		cdf_ret_status = CDF_STATUS_SUCCESS;
+		cdf_ret_status = QDF_STATUS_SUCCESS;
 	}
 
 	return cdf_ret_status;

core/cds/src/cds_reg_service.c

@@ -333,7 +333,7 @@ static int cds_regulatory_wiphy_init(hdd_context_t *hdd_ctx,
  * cds_update_regulatory_info() - update regulatory info
  * @hdd_ctx: hdd context
  *
- * Return: CDF_STATUS
+ * Return: QDF_STATUS
  */
 static void cds_update_regulatory_info(hdd_context_t *hdd_ctx)
 {
@@ -357,16 +357,16 @@ static void cds_update_regulatory_info(hdd_context_t *hdd_ctx)
  * @channels_40mhz: 40 MHz channels
  * @num_40mhz_channels: number of 40 Mhz channels
  *
- * Return: CDF_STATUS_SUCCESS
+ * Return: QDF_STATUS_SUCCESS
  */
-CDF_STATUS cds_get_channel_list_with_power(struct channel_power
+QDF_STATUS cds_get_channel_list_with_power(struct channel_power
 					   *base_channels,
 					   uint8_t *num_base_channels,
 					   struct channel_power
 					   *channels_40mhz,
 					   uint8_t *num_40mhz_channels)
 {
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	int i, count;
 
 	if (base_channels && num_base_channels) {
@@ -420,9 +420,9 @@ CDF_STATUS cds_get_channel_list_with_power(struct channel_power
  * cds_read_default_country() - set the default country
  * @default_country: default country
  *
- * Return: CDF_STATUS
+ * Return: QDF_STATUS
  */
-CDF_STATUS cds_read_default_country(uint8_t *default_country)
+QDF_STATUS cds_read_default_country(uint8_t *default_country)
 {
 	hdd_context_t *hdd_ctx;
 
@@ -430,7 +430,7 @@ CDF_STATUS cds_read_default_country(uint8_t *default_country)
 	if (!hdd_ctx) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "invalid hdd_ctx pointer");
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	memcpy(default_country,
@@ -442,7 +442,7 @@ CDF_STATUS cds_read_default_country(uint8_t *default_country)
 		  default_country[0],
 		  default_country[1]);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -580,9 +580,7 @@ static int cds_bw20_ch_index_to_bw40_ch_index(int k)
 		m = k - RF_CHAN_36 + RF_CHAN_BOND_38;
 		if (m > RF_CHAN_BOND_62)
 			m = RF_CHAN_BOND_62;
-	}
-	else if (k >= RF_CHAN_100 && k <= RF_CHAN_144)
-	{
+	} else if (k >= RF_CHAN_100 && k <= RF_CHAN_144) {
 		m = k - RF_CHAN_100 + RF_CHAN_BOND_102;
 		if (m > RF_CHAN_BOND_142)
 			m = RF_CHAN_BOND_142;
@@ -598,17 +596,17 @@ static int cds_bw20_ch_index_to_bw40_ch_index(int k)
  * cds_set_dfs_region() - set the dfs_region
  * @dfs_region: the dfs_region to set
  *
- * Return: CDF_STATUS_SUCCESS if dfs_region set correctly
- *         CDF_STATUS_E_EXISTS if hdd context not found
+ * Return: QDF_STATUS_SUCCESS if dfs_region set correctly
+ *         QDF_STATUS_E_EXISTS if hdd context not found
  */
-CDF_STATUS cds_set_dfs_region(uint8_t dfs_region)
+QDF_STATUS cds_set_dfs_region(uint8_t dfs_region)
 {
 	hdd_context_t *hdd_ctx;
 
 	hdd_ctx = cds_get_context(CDF_MODULE_ID_HDD);
 
 	if (NULL == hdd_ctx)
-		return CDF_STATUS_E_EXISTS;
+		return QDF_STATUS_E_EXISTS;
 
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) || defined(WITH_BACKPORTS)
 	hdd_ctx->reg.dfs_region = dfs_region;
@@ -631,39 +629,39 @@ CDF_STATUS cds_set_dfs_region(uint8_t dfs_region)
 		break;
 	}
 #endif
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
  * cds_get_dfs_region() - get the dfs_region
  * @dfs_region: the dfs_region to return
  *
- * Return: CDF_STATUS_SUCCESS if dfs_region set correctly
- *         CDF_STATUS_E_EXISTS if hdd context not found
+ * Return: QDF_STATUS_SUCCESS if dfs_region set correctly
+ *         QDF_STATUS_E_EXISTS if hdd context not found
  */
-CDF_STATUS cds_get_dfs_region(uint8_t *dfs_region)
+QDF_STATUS cds_get_dfs_region(uint8_t *dfs_region)
 {
 	hdd_context_t *hdd_ctx;
 
 	hdd_ctx = cds_get_context(CDF_MODULE_ID_HDD);
 
 	if (NULL == hdd_ctx)
-		return CDF_STATUS_E_EXISTS;
+		return QDF_STATUS_E_EXISTS;
 
 	*dfs_region = hdd_ctx->reg.dfs_region;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
  * cds_get_reg_domain_from_country_code() - get the regulatory domain
  * @reg_domain_ptr: ptr to store regulatory domain
  *
- * Return: CDF_STATUS_SUCCESS on success
- *         CDF_STATUS_E_FAULT on error
- *         CDF_STATUS_E_EMPTY country table empty
+ * Return: QDF_STATUS_SUCCESS on success
+ *         QDF_STATUS_E_FAULT on error
+ *         QDF_STATUS_E_EMPTY country table empty
  */
-CDF_STATUS cds_get_reg_domain_from_country_code(v_REGDOMAIN_t *reg_domain_ptr,
+QDF_STATUS cds_get_reg_domain_from_country_code(v_REGDOMAIN_t *reg_domain_ptr,
 						const uint8_t *country_alpha2,
 						enum country_src source)
 {
@@ -673,24 +671,24 @@ CDF_STATUS cds_get_reg_domain_from_country_code(v_REGDOMAIN_t *reg_domain_ptr,
 	if (NULL == reg_domain_ptr) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  ("Invalid reg domain pointer"));
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	*reg_domain_ptr = 0;
 
 	if (SOURCE_QUERY == source)
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 
 	if (NULL == country_alpha2) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  ("Country code array is NULL"));
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	if (cds_is_driver_recovering()) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "SSR in progress, return");
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 
 	hdd_ctx = cds_get_context(CDF_MODULE_ID_HDD);
@@ -698,7 +696,7 @@ CDF_STATUS cds_get_reg_domain_from_country_code(v_REGDOMAIN_t *reg_domain_ptr,
 	if (NULL == hdd_ctx) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  ("Invalid pHddCtx pointer"));
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	wiphy = hdd_ctx->wiphy;
@@ -716,7 +714,7 @@ CDF_STATUS cds_get_reg_domain_from_country_code(v_REGDOMAIN_t *reg_domain_ptr,
 				     NL80211_USER_REG_HINT_USER);
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /*
@@ -757,7 +755,7 @@ static int cds_process_regulatory_data(struct wiphy *wiphy,
 	if (NULL == hdd_ctx) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "invalid hdd_ctx pointer");
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	hdd_ctx->isVHT80Allowed = 0;
@@ -928,7 +926,7 @@ static int cds_process_regulatory_data(struct wiphy *wiphy,
 	if (k == 0)
 		return -1;
 
-	return 0;
+	return QDF_STATUS_SUCCESS;
 }
 
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 14, 0)) && !defined(WITH_BACKPORTS)
@@ -1098,9 +1096,9 @@ void hdd_reg_notifier(struct wiphy *wiphy,
 
 /**
  * cds_regulatory_init() - regulatory_init
- * Return: CDF_STATUS
+ * Return: QDF_STATUS
  */
-CDF_STATUS cds_regulatory_init(void)
+QDF_STATUS cds_regulatory_init(void)
 {
 	hdd_context_t *hdd_ctx = NULL;
 	struct wiphy *wiphy = NULL;
@@ -1111,7 +1109,7 @@ CDF_STATUS cds_regulatory_init(void)
 	if (!hdd_ctx) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "invalid hdd_ctx pointer");
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	wiphy = hdd_ctx->wiphy;
@@ -1125,7 +1123,7 @@ CDF_STATUS cds_regulatory_init(void)
 					nBandCapability, true) != 0) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  ("Error while creating regulatory entry"));
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	reg_info->cc_src = SOURCE_DRIVER;
@@ -1143,7 +1141,7 @@ CDF_STATUS cds_regulatory_init(void)
 
 	cds_fill_and_send_ctl_to_fw(reg_info);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -1151,18 +1149,18 @@ CDF_STATUS cds_regulatory_init(void)
  * @client_ctxt: client context
  * @reg_domain: regulatory domain
  *
- * Return: CDF_STATUS
+ * Return: QDF_STATUS
  */
-CDF_STATUS cds_set_reg_domain(void *client_ctxt, v_REGDOMAIN_t reg_domain)
+QDF_STATUS cds_set_reg_domain(void *client_ctxt, v_REGDOMAIN_t reg_domain)
 {
 	if (reg_domain >= REGDOMAIN_COUNT) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "CDS set reg domain, invalid REG domain ID %d",
 			  reg_domain);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**

core/cds/src/cds_sched.c

@@ -82,7 +82,7 @@ static int cds_mc_thread(void *Arg);
 #ifdef QCA_CONFIG_SMP
 static int cds_ol_rx_thread(void *arg);
 static unsigned long affine_cpu;
-static CDF_STATUS cds_alloc_ol_rx_pkt_freeq(p_cds_sched_context pSchedContext);
+static QDF_STATUS cds_alloc_ol_rx_pkt_freeq(p_cds_sched_context pSchedContext);
 #endif
 
 #ifdef QCA_CONFIG_SMP
@@ -186,29 +186,29 @@ static struct notifier_block cds_cpu_hotplug_notifier = {
  *
  * Return: CDF status
  */
-CDF_STATUS cds_sched_open(void *p_cds_context,
+QDF_STATUS cds_sched_open(void *p_cds_context,
 		p_cds_sched_context pSchedContext,
 		uint32_t SchedCtxSize)
 {
-	CDF_STATUS vStatus = CDF_STATUS_SUCCESS;
+	QDF_STATUS vStatus = QDF_STATUS_SUCCESS;
 	CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_INFO_HIGH,
 		  "%s: Opening the CDS Scheduler", __func__);
 	/* Sanity checks */
 	if ((p_cds_context == NULL) || (pSchedContext == NULL)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Null params being passed", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 	if (sizeof(cds_sched_context) != SchedCtxSize) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_INFO_HIGH,
 			  "%s: Incorrect CDS Sched Context size passed",
 			  __func__);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 	cdf_mem_zero(pSchedContext, sizeof(cds_sched_context));
 	pSchedContext->pVContext = p_cds_context;
 	vStatus = cds_sched_init_mqs(pSchedContext);
-	if (!CDF_IS_STATUS_SUCCESS(vStatus)) {
+	if (!QDF_IS_STATUS_SUCCESS(vStatus)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to initialize CDS Scheduler MQs",
 			  __func__);
@@ -240,8 +240,8 @@ CDF_STATUS cds_sched_open(void *p_cds_context,
 	spin_lock_bh(&pSchedContext->cds_ol_rx_pkt_freeq_lock);
 	INIT_LIST_HEAD(&pSchedContext->cds_ol_rx_pkt_freeq);
 	spin_unlock_bh(&pSchedContext->cds_ol_rx_pkt_freeq_lock);
-	if (cds_alloc_ol_rx_pkt_freeq(pSchedContext) != CDF_STATUS_SUCCESS) {
-		return CDF_STATUS_E_FAILURE;
+	if (cds_alloc_ol_rx_pkt_freeq(pSchedContext) != QDF_STATUS_SUCCESS) {
+		return QDF_STATUS_E_FAILURE;
 	}
 	register_hotcpu_notifier(&cds_cpu_hotplug_notifier);
 	pSchedContext->cpu_hot_plug_notifier = &cds_cpu_hotplug_notifier;
@@ -292,7 +292,7 @@ CDF_STATUS cds_sched_open(void *p_cds_context,
 	/* We're good now: Let's get the ball rolling!!! */
 	CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_INFO_HIGH,
 		  "%s: CDS Scheduler successfully Opened", __func__);
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 
 #ifdef QCA_CONFIG_SMP
 OL_RX_THREAD_START_FAILURE:
@@ -313,7 +313,7 @@ MC_THREAD_START_FAILURE:
 	cds_free_ol_rx_pkt_freeq(gp_cds_sched_context);
 #endif
 
-	return CDF_STATUS_E_RESOURCES;
+	return QDF_STATUS_E_RESOURCES;
 
 } /* cds_sched_open() */
 
@@ -329,7 +329,7 @@ static int cds_mc_thread(void *Arg)
 	p_cds_msg_wrapper pMsgWrapper = NULL;
 	tpAniSirGlobal pMacContext = NULL;
 	tSirRetStatus macStatus = eSIR_SUCCESS;
-	CDF_STATUS vStatus = CDF_STATUS_SUCCESS;
+	QDF_STATUS vStatus = QDF_STATUS_SUCCESS;
 	int retWaitStatus = 0;
 	bool shutdown = false;
 	hdd_context_t *pHddCtx = NULL;
@@ -424,7 +424,7 @@ static int cds_mc_thread(void *Arg)
 				vStatus =
 					sys_mc_process_msg(pSchedContext->pVContext,
 							   pMsgWrapper->pVosMsg);
-				if (!CDF_IS_STATUS_SUCCESS(vStatus)) {
+				if (!QDF_IS_STATUS_SUCCESS(vStatus)) {
 					CDF_TRACE(CDF_MODULE_ID_CDF,
 						  CDF_TRACE_LEVEL_ERROR,
 						  "%s: Issue Processing SYS message",
@@ -455,7 +455,7 @@ static int cds_mc_thread(void *Arg)
 				vStatus =
 					wma_mc_process_msg(pSchedContext->pVContext,
 							 pMsgWrapper->pVosMsg);
-				if (!CDF_IS_STATUS_SUCCESS(vStatus)) {
+				if (!QDF_IS_STATUS_SUCCESS(vStatus)) {
 					CDF_TRACE(CDF_MODULE_ID_CDF,
 						  CDF_TRACE_LEVEL_ERROR,
 						  "%s: Issue Processing WMA message",
@@ -546,7 +546,7 @@ static int cds_mc_thread(void *Arg)
 				vStatus =
 					sme_process_msg((tHalHandle) pMacContext,
 							pMsgWrapper->pVosMsg);
-				if (!CDF_IS_STATUS_SUCCESS(vStatus)) {
+				if (!QDF_IS_STATUS_SUCCESS(vStatus)) {
 					CDF_TRACE(CDF_MODULE_ID_CDF,
 						  CDF_TRACE_LEVEL_ERROR,
 						  "%s: Issue Processing SME message",
@@ -619,7 +619,7 @@ void cds_free_ol_rx_pkt_freeq(p_cds_sched_context pSchedContext)
  *
  * Return: status of memory allocation
  */
-static CDF_STATUS cds_alloc_ol_rx_pkt_freeq(p_cds_sched_context pSchedContext)
+static QDF_STATUS cds_alloc_ol_rx_pkt_freeq(p_cds_sched_context pSchedContext)
 {
 	struct cds_ol_rx_pkt *pkt, *tmp;
 	int i;
@@ -638,7 +638,7 @@ static CDF_STATUS cds_alloc_ol_rx_pkt_freeq(p_cds_sched_context pSchedContext)
 		spin_unlock_bh(&pSchedContext->cds_ol_rx_pkt_freeq_lock);
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 
 free:
 	spin_lock_bh(&pSchedContext->cds_ol_rx_pkt_freeq_lock);
@@ -650,7 +650,7 @@ free:
 		spin_lock_bh(&pSchedContext->cds_ol_rx_pkt_freeq_lock);
 	}
 	spin_unlock_bh(&pSchedContext->cds_ol_rx_pkt_freeq_lock);
-	return CDF_STATUS_E_NOMEM;
+	return QDF_STATUS_E_NOMEM;
 }
 
 /**
@@ -895,14 +895,14 @@ static int cds_ol_rx_thread(void *arg)
  *
  * Return: cdf status
  */
-CDF_STATUS cds_sched_close(void *p_cds_context)
+QDF_STATUS cds_sched_close(void *p_cds_context)
 {
 	CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_INFO_HIGH,
 		  "%s: invoked", __func__);
 	if (gp_cds_sched_context == NULL) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: gp_cds_sched_context == NULL", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 	/* shut down MC Thread */
 	set_bit(MC_SHUTDOWN_EVENT_MASK, &gp_cds_sched_context->mcEventFlag);
@@ -929,7 +929,7 @@ CDF_STATUS cds_sched_close(void *p_cds_context)
 	cds_free_ol_rx_pkt_freeq(gp_cds_sched_context);
 	unregister_hotcpu_notifier(&cds_cpu_hotplug_notifier);
 #endif
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 } /* cds_sched_close() */
 
 /**
@@ -940,14 +940,14 @@ CDF_STATUS cds_sched_close(void *p_cds_context)
  *
  * Return: CDF status
  */
-CDF_STATUS cds_sched_init_mqs(p_cds_sched_context pSchedContext)
+QDF_STATUS cds_sched_init_mqs(p_cds_sched_context pSchedContext)
 {
-	CDF_STATUS vStatus = CDF_STATUS_SUCCESS;
+	QDF_STATUS vStatus = QDF_STATUS_SUCCESS;
 	/* Now intialize all the message queues */
 	CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_INFO_HIGH,
 		  "%s: Initializing the WMA MC Message queue", __func__);
 	vStatus = cds_mq_init(&pSchedContext->wmaMcMq);
-	if (!CDF_IS_STATUS_SUCCESS(vStatus)) {
+	if (!QDF_IS_STATUS_SUCCESS(vStatus)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to init WMA MC Message queue", __func__);
 		CDF_ASSERT(0);
@@ -956,7 +956,7 @@ CDF_STATUS cds_sched_init_mqs(p_cds_sched_context pSchedContext)
 	CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_INFO_HIGH,
 		  "%s: Initializing the PE MC Message queue", __func__);
 	vStatus = cds_mq_init(&pSchedContext->peMcMq);
-	if (!CDF_IS_STATUS_SUCCESS(vStatus)) {
+	if (!QDF_IS_STATUS_SUCCESS(vStatus)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to init PE MC Message queue", __func__);
 		CDF_ASSERT(0);
@@ -965,7 +965,7 @@ CDF_STATUS cds_sched_init_mqs(p_cds_sched_context pSchedContext)
 	CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_INFO_HIGH,
 		  "%s: Initializing the SME MC Message queue", __func__);
 	vStatus = cds_mq_init(&pSchedContext->smeMcMq);
-	if (!CDF_IS_STATUS_SUCCESS(vStatus)) {
+	if (!QDF_IS_STATUS_SUCCESS(vStatus)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to init SME MC Message queue", __func__);
 		CDF_ASSERT(0);
@@ -974,14 +974,14 @@ CDF_STATUS cds_sched_init_mqs(p_cds_sched_context pSchedContext)
 	CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_INFO_HIGH,
 		  "%s: Initializing the SYS MC Message queue", __func__);
 	vStatus = cds_mq_init(&pSchedContext->sysMcMq);
-	if (!CDF_IS_STATUS_SUCCESS(vStatus)) {
+	if (!QDF_IS_STATUS_SUCCESS(vStatus)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to init SYS MC Message queue", __func__);
 		CDF_ASSERT(0);
 		return vStatus;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 } /* cds_sched_init_mqs() */
 
 /**

core/cds/src/cds_utils.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014-2015 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -29,18 +29,18 @@
    FILE:         cds_utils.c
 
    OVERVIEW:     This source file contains definitions for CDS crypto APIs
-                The four APIs mentioned in this file are used for
-                initializing, and de-initializing a crypto context, and
-                obtaining truly random data (for keys), as well as
-                SHA1 HMAC, and AES encrypt and decrypt routines.
-
-                The routines include:
-                cds_crypto_init() - Initializes Crypto module
-                cds_crypto_deinit() - De-initializes Crypto module
-                cds_rand_get_bytes() - Generates random byte
-                cds_sha1_hmac_str() - Generate the HMAC-SHA1 of a string given a key
-                cds_encrypt_aes() - Generate AES Encrypted byte stream
-                cds_decrypt_aes() - Decrypts an AES Encrypted byte stream
+   The four APIs mentioned in this file are used for
+   initializing, and de-initializing a crypto context, and
+   obtaining truly random data (for keys), as well as
+   SHA1 HMAC, and AES encrypt and decrypt routines.
+
+   The routines include:
+   cds_crypto_init() - Initializes Crypto module
+   cds_crypto_deinit() - De-initializes Crypto module
+   cds_rand_get_bytes() - Generates random byte
+   cds_sha1_hmac_str() - Generate the HMAC-SHA1 of a string given a key
+   cds_encrypt_aes() - Generate AES Encrypted byte stream
+   cds_decrypt_aes() - Decrypts an AES Encrypted byte stream
 
    DEPENDENCIES:
    ============================================================================*/
@@ -201,37 +201,37 @@ static void cds_cmac_calc_mic(struct crypto_cipher *tfm,
 
    \param phCryptProv - pointer to the Crypt handle
 
-   \return CDF_STATUS_SUCCESS - Successfully generated random memory.
+   \return QDF_STATUS_SUCCESS - Successfully generated random memory.
 
-          CDF_STATUS_E_FAULT  - pbBuf is an invalid pointer.
+   QDF_STATUS_E_FAULT  - pbBuf is an invalid pointer.
 
-          CDF_STATUS_E_FAILURE - default return value if it fails due to
-          unknown reasons
+   QDF_STATUS_E_FAILURE - default return value if it fails due to
+   unknown reasons
 
-  ***CDF_STATUS_E_RESOURCES - System resources (other than memory)
-          are unavailable
+   ***QDF_STATUS_E_RESOURCES - System resources (other than memory)
+   are unavailable
    \sa
 
     ( *** return value not considered yet )
    --------------------------------------------------------------------------*/
-CDF_STATUS cds_crypto_init(uint32_t *phCryptProv)
+QDF_STATUS cds_crypto_init(uint32_t *phCryptProv)
 {
-	CDF_STATUS uResult = CDF_STATUS_E_FAILURE;
+	QDF_STATUS uResult = QDF_STATUS_E_FAILURE;
 
 	/* This implementation doesn't require a crypto context */
 	*phCryptProv = 0;
-	uResult = CDF_STATUS_SUCCESS;
-	return (uResult);
+	uResult = QDF_STATUS_SUCCESS;
+	return uResult;
 }
 
-CDF_STATUS cds_crypto_deinit(uint32_t hCryptProv)
+QDF_STATUS cds_crypto_deinit(uint32_t hCryptProv)
 {
-	CDF_STATUS uResult = CDF_STATUS_E_FAILURE;
+	QDF_STATUS uResult = QDF_STATUS_E_FAILURE;
 
 	/* CryptReleaseContext succeeded */
-	uResult = CDF_STATUS_SUCCESS;
+	uResult = QDF_STATUS_SUCCESS;
 
-	return (uResult);
+	return uResult;
 }
 
 /*--------------------------------------------------------------------------
@@ -247,38 +247,38 @@ CDF_STATUS cds_crypto_deinit(uint32_t hCryptProv)
 
    \param lock - pointer to the opaque lock object to initialize
 
-   \return CDF_STATUS_SUCCESS - Successfully generated random memory.
+   \return QDF_STATUS_SUCCESS - Successfully generated random memory.
 
-          CDF_STATUS_E_FAULT  - pbBuf is an invalid pointer.
+   QDF_STATUS_E_FAULT  - pbBuf is an invalid pointer.
 
-          CDF_STATUS_E_FAILURE - default return value if it fails due to
-          unknown reasons
+   QDF_STATUS_E_FAILURE - default return value if it fails due to
+   unknown reasons
 
-  ***CDF_STATUS_E_RESOURCES - System resources (other than memory)
-          are unavailable
+  ***QDF_STATUS_E_RESOURCES - System resources (other than memory)
+  are unavailable
    \sa
 
     ( *** return value not considered yet )
    --------------------------------------------------------------------------*/
-CDF_STATUS
+QDF_STATUS
 cds_rand_get_bytes(uint32_t cryptHandle, uint8_t *pbBuf, uint32_t numBytes)
 {
-	CDF_STATUS uResult = CDF_STATUS_E_FAILURE;
+	QDF_STATUS uResult = QDF_STATUS_E_FAILURE;
 
 	/* check for invalid pointer */
 	if (NULL == pbBuf) {
-		uResult = CDF_STATUS_E_FAULT;
-		return (uResult);
+		uResult = QDF_STATUS_E_FAULT;
+		return uResult;
 	}
 
 	get_random_bytes(pbBuf, numBytes);
 	/* "Random sequence generated." */
-	uResult = CDF_STATUS_SUCCESS;
-	return (uResult);
+	uResult = QDF_STATUS_SUCCESS;
+	return uResult;
 }
 
 #ifdef WLAN_FEATURE_11W
-uint8_t cds_get_mmie_size()
+uint8_t cds_get_mmie_size(void)
 {
 	return sizeof(struct ieee80211_mmie);
 }
@@ -310,7 +310,7 @@ static void cds_increase_seq(uint8_t *ipn)
    of Broadcast/Multicast robust management frames.
 
    \param igtk - pointer  group key which will be used to calculate
-                the 8 byte MIC.
+   the 8 byte MIC.
    \param ipn - pointer ipn, it is also known as sequence number
    \param key_id - key identication number
    \param frm - pointer to the start of the frame.
@@ -318,7 +318,7 @@ static void cds_increase_seq(uint8_t *ipn)
    \param frmLen - size of the entire frame.
 
    \return - this function will return true on success and false on
-            failure.
+   failure.
 
    --------------------------------------------------------------------------*/
 
@@ -420,7 +420,7 @@ cds_attach_mmie(uint8_t *igtk, uint8_t *ipn, uint16_t key_id,
 	if (NULL == input) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Memory allocation failed", __func__);
-		ret = CDF_STATUS_E_NOMEM;
+		ret = QDF_STATUS_E_NOMEM;
 		goto err_tfm;
 	}
 
@@ -530,7 +530,7 @@ cds_is_mmie_valid(uint8_t *igtk, uint8_t *ipn, uint8_t *frm, uint8_t *efrm)
 	if (NULL == input) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "Memory allocation failed");
-		ret = CDF_STATUS_E_NOMEM;
+		ret = QDF_STATUS_E_NOMEM;
 		goto err_tfm;
 	}
 
@@ -708,7 +708,7 @@ err_tfm:
 	return ret;
 }
 
-CDF_STATUS cds_sha1_hmac_str(uint32_t cryptHandle,      /* Handle */
+QDF_STATUS cds_sha1_hmac_str(uint32_t cryptHandle,      /* Handle */
 			     uint8_t *pText,    /* pointer to data stream */
 			     uint32_t textLen,  /* length of data stream */
 			     uint8_t *pKey,     /* pointer to authentication key */
@@ -728,10 +728,10 @@ CDF_STATUS cds_sha1_hmac_str(uint32_t cryptHandle,      /* Handle */
 	if (ret != 0) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "hmac_sha1() call failed");
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -868,7 +868,7 @@ err_tfm:
 	return ret;
 }
 
-CDF_STATUS cds_md5_hmac_str(uint32_t cryptHandle,       /* Handle */
+QDF_STATUS cds_md5_hmac_str(uint32_t cryptHandle,       /* Handle */
 			    uint8_t *pText,     /* pointer to data stream */
 			    uint32_t textLen,   /* length of data stream */
 			    uint8_t *pKey,      /* pointer to authentication key */
@@ -888,10 +888,10 @@ CDF_STATUS cds_md5_hmac_str(uint32_t cryptHandle,       /* Handle */
 	if (ret != 0) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "hmac_md5() call failed");
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 struct ecb_aes_result {
@@ -921,21 +921,21 @@ static void ecb_aes_complete(struct crypto_async_request *req, int err)
 
    \param lock - pointer to the opaque lock object to initialize
 
-   \return CDF_STATUS_SUCCESS - Successfully generated random memory.
+   \return QDF_STATUS_SUCCESS - Successfully generated random memory.
 
-          CDF_STATUS_E_FAULT  - pbBuf is an invalid pointer.
+   QDF_STATUS_E_FAULT  - pbBuf is an invalid pointer.
 
-          CDF_STATUS_E_FAILURE - default return value if it fails due to
-          unknown reasons
+   QDF_STATUS_E_FAILURE - default return value if it fails due to
+   unknown reasons
 
-  ***CDF_STATUS_E_RESOURCES - System resources (other than memory)
-          are unavailable
+  ***QDF_STATUS_E_RESOURCES - System resources (other than memory)
+  are unavailable
    \sa
 
     ( *** return value not considered yet )
    --------------------------------------------------------------------------*/
 
-CDF_STATUS cds_encrypt_aes(uint32_t cryptHandle,        /* Handle */
+QDF_STATUS cds_encrypt_aes(uint32_t cryptHandle,        /* Handle */
 			   uint8_t *pPlainText,         /* pointer to data stream */
 			   uint8_t *pCiphertext, uint8_t *pKey)
 {                               /* pointer to authentication key */
@@ -997,10 +997,10 @@ err_tfm:
 	if (ret != 0) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s() call failed", __func__);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /*--------------------------------------------------------------------------
@@ -1016,25 +1016,25 @@ err_tfm:
 
    \param lock - pointer to the opaque lock object to initialize
 
-   \return CDF_STATUS_SUCCESS - Successfully generated random memory.
+   \return QDF_STATUS_SUCCESS - Successfully generated random memory.
 
-          CDF_STATUS_E_FAULT  - pbBuf is an invalid pointer.
+   QDF_STATUS_E_FAULT  - pbBuf is an invalid pointer.
 
-          CDF_STATUS_E_FAILURE - default return value if it fails due to
-          unknown reasons
+   QDF_STATUS_E_FAILURE - default return value if it fails due to
+   unknown reasons
 
-  ***CDF_STATUS_E_RESOURCES - System resources (other than memory)
-          are unavailable
+  ***QDF_STATUS_E_RESOURCES - System resources (other than memory)
+  are unavailable
    \sa
 
     ( *** return value not considered yet )
    --------------------------------------------------------------------------*/
 
-CDF_STATUS cds_decrypt_aes(uint32_t cryptHandle,        /* Handle */
+QDF_STATUS cds_decrypt_aes(uint32_t cryptHandle,        /* Handle */
 			   uint8_t *pText,      /* pointer to data stream */
 			   uint8_t *pDecrypted, uint8_t *pKey)
 {                               /* pointer to authentication key */
-/*    CDF_STATUS uResult = CDF_STATUS_E_FAILURE; */
+/*    QDF_STATUS uResult = QDF_STATUS_E_FAILURE; */
 	struct ecb_aes_result result;
 	struct ablkcipher_request *req;
 	struct crypto_ablkcipher *tfm;
@@ -1093,10 +1093,10 @@ err_tfm:
 	if (ret != 0) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s() call failed", __func__);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 uint32_t cds_chan_to_freq(uint8_t chan)

core/dp/htt/htt_rx.c

@@ -224,7 +224,7 @@ static void htt_rx_ring_refill_retry(void *arg)
 void htt_rx_ring_fill_n(struct htt_pdev_t *pdev, int num)
 {
 	int idx;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	struct htt_host_rx_desc_base *rx_desc;
 
 	idx = *(pdev->rx_ring.alloc_idx.vaddr);
@@ -284,7 +284,7 @@ void htt_rx_ring_fill_n(struct htt_pdev_t *pdev, int num)
 			cdf_nbuf_map(pdev->osdev, rx_netbuf,
 						CDF_DMA_FROM_DEVICE);
 #endif
-		if (status != CDF_STATUS_SUCCESS) {
+		if (status != QDF_STATUS_SUCCESS) {
 			cdf_nbuf_free(rx_netbuf);
 			goto fail;
 		}

core/dp/ol/inc/ol_txrx_ctrl_api.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011-2015 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2011-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -674,9 +674,9 @@ ol_txrx_set_monitor_mode_vap(ol_txrx_pdev_handle pdev,
  */
 void ol_txrx_set_curchan(ol_txrx_pdev_handle pdev, uint32_t chan_mhz);
 
-CDF_STATUS ol_txrx_bus_suspend(void);
-CDF_STATUS ol_txrx_bus_resume(void);
-CDF_STATUS ol_txrx_wait_for_pending_tx(int timeout);
+QDF_STATUS ol_txrx_bus_suspend(void);
+QDF_STATUS ol_txrx_bus_resume(void);
+QDF_STATUS ol_txrx_wait_for_pending_tx(int timeout);
 
 /**
  * @brief Get the number of pending transmit frames that are awaiting completion.
@@ -764,7 +764,7 @@ enum ol_txrx_peer_state {
  *
  * Return: CDF Status
  */
-CDF_STATUS
+QDF_STATUS
 ol_txrx_peer_state_update(ol_txrx_pdev_handle pdev, uint8_t *peer_addr,
 			  enum ol_txrx_peer_state state);
 
@@ -900,7 +900,7 @@ struct txrx_pdev_cfg_param_t {
 ol_pdev_handle ol_pdev_cfg_attach(cdf_device_t osdev,
 				  struct txrx_pdev_cfg_param_t cfg_param);
 
-CDF_STATUS ol_txrx_get_vdevid(struct ol_txrx_peer_t *peer, uint8_t *vdev_id);
+QDF_STATUS ol_txrx_get_vdevid(struct ol_txrx_peer_t *peer, uint8_t *vdev_id);
 void *ol_txrx_get_vdev_by_sta_id(uint8_t sta_id);
 
 
@@ -1252,7 +1252,7 @@ void ol_txrx_display_stats(uint16_t bitmap);
 void ol_txrx_clear_stats(uint16_t bitmap);
 int ol_txrx_stats(uint8_t vdev_id, char *buffer, unsigned buf_len);
 
-CDF_STATUS ol_txrx_register_ocb_peer(void *cds_ctx, uint8_t *mac_addr,
+QDF_STATUS ol_txrx_register_ocb_peer(void *cds_ctx, uint8_t *mac_addr,
 				     uint8_t *peer_id);
 
 void ol_txrx_set_ocb_peer(struct ol_txrx_pdev_t *pdev,

core/dp/ol/inc/ol_txrx_osif_api.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2014-2015 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2012, 2014-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -110,7 +110,7 @@ struct ol_txrx_desc_type {
 };
 
 
-typedef CDF_STATUS (*ol_rx_callback_fp)(void *p_cds_gctx,
+typedef QDF_STATUS (*ol_rx_callback_fp)(void *p_cds_gctx,
 					 cdf_nbuf_t pDataBuff,
 					 uint8_t ucSTAId);
 
@@ -119,12 +119,12 @@ typedef void (*ol_tx_pause_callback_fp)(uint8_t vdev_id,
 					enum netif_reason_type reason);
 
 #ifdef QCA_LL_TX_FLOW_CONTROL_V2
-CDF_STATUS ol_txrx_register_pause_cb(ol_tx_pause_callback_fp pause_cb);
+QDF_STATUS ol_txrx_register_pause_cb(ol_tx_pause_callback_fp pause_cb);
 #else
 static inline
-CDF_STATUS ol_txrx_register_pause_cb(ol_tx_pause_callback_fp pause_cb)
+QDF_STATUS ol_txrx_register_pause_cb(ol_tx_pause_callback_fp pause_cb)
 {
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 
 }
 #endif
@@ -262,12 +262,12 @@ cdf_nbuf_t ol_tx_send_ipa_data_frame(void *vdev,
 			cdf_nbuf_t skb);
 #endif
 
-CDF_STATUS ol_txrx_register_peer(ol_rx_callback_fp rxcb,
+QDF_STATUS ol_txrx_register_peer(ol_rx_callback_fp rxcb,
 				 struct ol_txrx_desc_type *sta_desc);
 
-CDF_STATUS ol_txrx_clear_peer(uint8_t sta_id);
+QDF_STATUS ol_txrx_clear_peer(uint8_t sta_id);
 
-CDF_STATUS ol_txrx_change_peer_state(uint8_t sta_id,
+QDF_STATUS ol_txrx_change_peer_state(uint8_t sta_id,
 				     enum ol_txrx_peer_state sta_state,
 				     bool roam_synch_in_progress);
 

core/dp/txrx/ol_tx.c

@@ -149,7 +149,7 @@ cdf_nbuf_t ol_tx_send_data_frame(uint8_t sta_id, cdf_nbuf_t skb,
 	struct ol_txrx_pdev_t *pdev = cds_get_context(CDF_MODULE_ID_TXRX);
 	struct ol_txrx_peer_t *peer;
 	cdf_nbuf_t ret;
-	CDF_STATUS status;
+	QDF_STATUS status;
 
 	if (cdf_unlikely(!pdev)) {
 		CDF_TRACE(CDF_MODULE_ID_TXRX, CDF_TRACE_LEVEL_WARN,
@@ -182,7 +182,7 @@ cdf_nbuf_t ol_tx_send_data_frame(uint8_t sta_id, cdf_nbuf_t skb,
 	}
 
 	status = cdf_nbuf_map_single(cdf_ctx, skb, CDF_DMA_TO_DEVICE);
-	if (cdf_unlikely(status != CDF_STATUS_SUCCESS)) {
+	if (cdf_unlikely(status != QDF_STATUS_SUCCESS)) {
 		CDF_TRACE(CDF_MODULE_ID_TXRX, CDF_TRACE_LEVEL_WARN,
 			"%s: nbuf map failed", __func__);
 		return skb;

core/dp/txrx/ol_txrx.c

@@ -130,16 +130,16 @@ ol_txrx_find_peer_by_addr_and_vdev(ol_txrx_pdev_handle pdev,
 	return peer;
 }
 
-CDF_STATUS ol_txrx_get_vdevid(struct ol_txrx_peer_t *peer, uint8_t *vdev_id)
+QDF_STATUS ol_txrx_get_vdevid(struct ol_txrx_peer_t *peer, uint8_t *vdev_id)
 {
 	if (!peer) {
 		CDF_TRACE(CDF_MODULE_ID_TXRX, CDF_TRACE_LEVEL_ERROR,
 				  "peer argument is null!!");
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	*vdev_id = peer->vdev->vdev_id;
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 void *ol_txrx_get_vdev_by_sta_id(uint8_t sta_id)
@@ -1263,7 +1263,7 @@ void ol_txrx_flush_rx_frames(struct ol_txrx_peer_t *peer,
 				    bool drop)
 {
 	struct ol_rx_cached_buf *cache_buf;
-	CDF_STATUS ret;
+	QDF_STATUS ret;
 	ol_rx_callback_fp data_rx = NULL;
 	void *cds_ctx = cds_get_global_context();
 
@@ -1291,7 +1291,7 @@ void ol_txrx_flush_rx_frames(struct ol_txrx_peer_t *peer,
 		} else {
 			/* Flush the cached frames to HDD */
 			ret = data_rx(cds_ctx, cache_buf->buf, peer->local_id);
-			if (ret != CDF_STATUS_SUCCESS)
+			if (ret != QDF_STATUS_SUCCESS)
 				cdf_nbuf_free(cache_buf->buf);
 		}
 		cdf_mem_free(cache_buf);
@@ -1466,7 +1466,7 @@ static A_STATUS ol_tx_filter_pass_thru(struct ol_txrx_msdu_info_t *tx_msdu_info)
 	return A_OK;
 }
 
-CDF_STATUS
+QDF_STATUS
 ol_txrx_peer_state_update(struct ol_txrx_pdev_t *pdev, uint8_t *peer_mac,
 			  enum ol_txrx_peer_state state)
 {
@@ -1475,7 +1475,7 @@ ol_txrx_peer_state_update(struct ol_txrx_pdev_t *pdev, uint8_t *peer_mac,
 	if (cdf_unlikely(!pdev)) {
 		TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "Pdev is NULL");
 		cdf_assert(0);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	peer =  ol_txrx_peer_find_hash_find(pdev, peer_mac, 0, 1);
@@ -1484,7 +1484,7 @@ ol_txrx_peer_state_update(struct ol_txrx_pdev_t *pdev, uint8_t *peer_mac,
 			" 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n", __FUNCTION__,
 			peer_mac[0], peer_mac[1], peer_mac[2], peer_mac[3],
 			peer_mac[4], peer_mac[5]);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	/* TODO: Should we send WMI command of the connection state? */
@@ -1496,7 +1496,7 @@ ol_txrx_peer_state_update(struct ol_txrx_pdev_t *pdev, uint8_t *peer_mac,
 			   __func__);
 #endif
 		cdf_atomic_dec(&peer->ref_cnt);
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 
 	TXRX_PRINT(TXRX_PRINT_LEVEL_INFO2, "%s: change from %d to %d\n",
@@ -1530,7 +1530,7 @@ ol_txrx_peer_state_update(struct ol_txrx_pdev_t *pdev, uint8_t *peer_mac,
 	/* Set the state after the Pause to avoid the race condiction
 	   with ADDBA check in tx path */
 	peer->state = state;
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 void
@@ -1886,18 +1886,18 @@ static void ol_txrx_dump_tx_desc(ol_txrx_pdev_handle pdev_handle)
  * queue doesn't empty before timeout occurs.
  *
  * Return:
- *    CDF_STATUS_SUCCESS if the queue empties,
- *    CDF_STATUS_E_TIMEOUT in case of timeout,
- *    CDF_STATUS_E_FAULT in case of missing handle
+ *    QDF_STATUS_SUCCESS if the queue empties,
+ *    QDF_STATUS_E_TIMEOUT in case of timeout,
+ *    QDF_STATUS_E_FAULT in case of missing handle
  */
-CDF_STATUS ol_txrx_wait_for_pending_tx(int timeout)
+QDF_STATUS ol_txrx_wait_for_pending_tx(int timeout)
 {
 	ol_txrx_pdev_handle txrx_pdev = cds_get_context(CDF_MODULE_ID_TXRX);
 
 	if (txrx_pdev == NULL) {
 		TXRX_PRINT(TXRX_PRINT_LEVEL_ERR,
 			   "%s: txrx context is null", __func__);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	while (ol_txrx_get_tx_pending(txrx_pdev)) {
@@ -1906,11 +1906,11 @@ CDF_STATUS ol_txrx_wait_for_pending_tx(int timeout)
 			TXRX_PRINT(TXRX_PRINT_LEVEL_ERR,
 				"%s: tx frames are pending", __func__);
 			ol_txrx_dump_tx_desc(txrx_pdev);
-			return CDF_STATUS_E_TIMEOUT;
+			return QDF_STATUS_E_TIMEOUT;
 		}
 		timeout = timeout - OL_ATH_TX_DRAIN_WAIT_DELAY;
 	}
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 #ifndef QCA_WIFI_3_0_EMU
@@ -1924,9 +1924,9 @@ CDF_STATUS ol_txrx_wait_for_pending_tx(int timeout)
  *
  * Ensure that ol_txrx is ready for bus suspend
  *
- * Return: CDF_STATUS
+ * Return: QDF_STATUS
  */
-CDF_STATUS ol_txrx_bus_suspend(void)
+QDF_STATUS ol_txrx_bus_suspend(void)
 {
 	return ol_txrx_wait_for_pending_tx(SUSPEND_DRAIN_WAIT);
 }
@@ -1936,11 +1936,11 @@ CDF_STATUS ol_txrx_bus_suspend(void)
  *
  * Dummy function for symetry
  *
- * Return: CDF_STATUS_SUCCESS
+ * Return: QDF_STATUS_SUCCESS
  */
-CDF_STATUS ol_txrx_bus_resume(void)
+QDF_STATUS ol_txrx_bus_resume(void)
 {
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 int ol_txrx_get_tx_pending(ol_txrx_pdev_handle pdev_handle)
@@ -2990,7 +2990,7 @@ static void ol_rx_data_cb(struct ol_txrx_peer_t *peer,
 {
 	void *cds_ctx = cds_get_global_context();
 	cdf_nbuf_t buf, next_buf;
-	CDF_STATUS ret;
+	QDF_STATUS ret;
 	ol_rx_callback_fp data_rx = NULL;
 
 	if (cdf_unlikely(!cds_ctx))
@@ -3017,7 +3017,7 @@ static void ol_rx_data_cb(struct ol_txrx_peer_t *peer,
 		next_buf = cdf_nbuf_queue_next(buf);
 		cdf_nbuf_set_next(buf, NULL);   /* Add NULL terminator */
 		ret = data_rx(cds_ctx, buf, peer->local_id);
-		if (ret != CDF_STATUS_SUCCESS) {
+		if (ret != QDF_STATUS_SUCCESS) {
 			TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "Frame Rx to HDD failed");
 			cdf_nbuf_free(buf);
 		}
@@ -3141,7 +3141,7 @@ drop_rx_buf:
  *
  * Return: CDF Status
  */
-CDF_STATUS ol_txrx_register_peer(ol_rx_callback_fp rxcb,
+QDF_STATUS ol_txrx_register_peer(ol_rx_callback_fp rxcb,
 				 struct ol_txrx_desc_type *sta_desc)
 {
 	struct ol_txrx_peer_t *peer;
@@ -3151,18 +3151,18 @@ CDF_STATUS ol_txrx_register_peer(ol_rx_callback_fp rxcb,
 
 	if (!pdev) {
 		TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "Pdev is NULL");
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	if (sta_desc->sta_id >= WLAN_MAX_STA_COUNT) {
 		TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "Invalid sta id :%d",
 			 sta_desc->sta_id);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	peer = ol_txrx_peer_find_by_local_id(pdev, sta_desc->sta_id);
 	if (!peer)
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 
 	cdf_spin_lock_bh(&peer->peer_info_lock);
 	peer->osif_rx = rxcb;
@@ -3182,7 +3182,7 @@ CDF_STATUS ol_txrx_register_peer(ol_rx_callback_fp rxcb,
 	}
 
 	ol_txrx_flush_rx_frames(peer, 0);
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -3191,7 +3191,7 @@ CDF_STATUS ol_txrx_register_peer(ol_rx_callback_fp rxcb,
  *
  * Return: CDF Status
  */
-CDF_STATUS ol_txrx_clear_peer(uint8_t sta_id)
+QDF_STATUS ol_txrx_clear_peer(uint8_t sta_id)
 {
 	struct ol_txrx_peer_t *peer;
 	struct ol_txrx_pdev_t *pdev = cds_get_context(CDF_MODULE_ID_TXRX);
@@ -3199,12 +3199,12 @@ CDF_STATUS ol_txrx_clear_peer(uint8_t sta_id)
 	if (!pdev) {
 		TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "%s: Unable to find pdev!",
 			   __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	if (sta_id >= WLAN_MAX_STA_COUNT) {
 		TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "Invalid sta id %d", sta_id);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 #ifdef QCA_CONFIG_SMP
@@ -3218,7 +3218,7 @@ CDF_STATUS ol_txrx_clear_peer(uint8_t sta_id)
 
 	peer = ol_txrx_peer_find_by_local_id(pdev, sta_id);
 	if (!peer)
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 
 	/* Purge the cached rx frame queue */
 	ol_txrx_flush_rx_frames(peer, 1);
@@ -3228,7 +3228,7 @@ CDF_STATUS ol_txrx_clear_peer(uint8_t sta_id)
 	peer->state = ol_txrx_peer_state_disc;
 	cdf_spin_unlock_bh(&peer->peer_info_lock);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -3237,9 +3237,9 @@ CDF_STATUS ol_txrx_clear_peer(uint8_t sta_id)
  * @mac_addr: MAC address of the self peer
  * @peer_id: Pointer to the peer ID
  *
- * Return: CDF_STATUS_SUCCESS on success, CDF_STATUS_E_FAILURE on failure
+ * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_FAILURE on failure
  */
-CDF_STATUS ol_txrx_register_ocb_peer(void *cds_ctx, uint8_t *mac_addr,
+QDF_STATUS ol_txrx_register_ocb_peer(void *cds_ctx, uint8_t *mac_addr,
 				     uint8_t *peer_id)
 {
 	ol_txrx_pdev_handle pdev;
@@ -3248,21 +3248,21 @@ CDF_STATUS ol_txrx_register_ocb_peer(void *cds_ctx, uint8_t *mac_addr,
 	if (!cds_ctx) {
 		TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "%s: Invalid context",
 			   __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	pdev = cds_get_context(CDF_MODULE_ID_TXRX);
 	if (!pdev) {
 		TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "%s: Unable to find pdev!",
 			   __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	peer = ol_txrx_find_peer_by_addr(pdev, mac_addr, peer_id);
 	if (!peer) {
 		TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "%s: Unable to find OCB peer!",
 			   __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	ol_txrx_set_ocb_peer(pdev, peer);
@@ -3271,7 +3271,7 @@ CDF_STATUS ol_txrx_register_ocb_peer(void *cds_ctx, uint8_t *mac_addr,
 	ol_txrx_peer_state_update(pdev, peer->mac_addr.raw,
 				  ol_txrx_peer_state_auth);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -3324,15 +3324,15 @@ exit:
  *
  * Return: CDF status
  */
-CDF_STATUS ol_txrx_register_pause_cb(ol_tx_pause_callback_fp pause_cb)
+QDF_STATUS ol_txrx_register_pause_cb(ol_tx_pause_callback_fp pause_cb)
 {
 	struct ol_txrx_pdev_t *pdev = cds_get_context(CDF_MODULE_ID_TXRX);
 	if (!pdev || !pause_cb) {
 		TXRX_PRINT(TXRX_PRINT_LEVEL_ERR, "pdev or pause_cb is NULL");
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 	pdev->pause_cb = pause_cb;
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 #endif
 

core/dp/txrx/txrx.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2014 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -107,8 +107,8 @@ struct wlan_txrx_stats {
 
 struct ol_txrx_vdev_t;
 
-CDF_STATUS wlan_register_mgmt_client(void *pdev_txrx,
-				     CDF_STATUS (*rx_mgmt)(void *g_cdsctx,
+QDF_STATUS wlan_register_mgmt_client(void *pdev_txrx,
+				     QDF_STATUS (*rx_mgmt)(void *g_cdsctx,
 							   void *buf));
 
 typedef void (*ol_txrx_vdev_delete_cb)(void *context);
@@ -124,7 +124,7 @@ typedef void
 (*ol_txrx_mgmt_tx_cb)(void *ctxt, cdf_nbuf_t tx_mgmt_frm, int had_error);
 
 /* If RSSI realm is changed, send notification to Clients, SME, HDD */
-typedef CDF_STATUS (*wlan_txrx_rssi_cross_thresh)(void *adapter, u8 rssi,
+typedef QDF_STATUS (*wlan_txrx_rssi_cross_thresh)(void *adapter, u8 rssi,
 						  void *usr_ctx,
 						  int8_t avg_rssi);
 

core/hdd/inc/wlan_hdd_assoc.h

@@ -168,9 +168,9 @@ eCsrBand hdd_conn_get_connected_band(hdd_station_ctx_t *pHddStaCtx);
  * @roamStatus: roam status
  * @roamResult: roam result
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_sme_roam_callback(void *pContext, tCsrRoamInfo *pRoamInfo,
+QDF_STATUS hdd_sme_roam_callback(void *pContext, tCsrRoamInfo *pRoamInfo,
 				 uint32_t roamId,
 				 eRoamCmdStatus roamStatus,
 				 eCsrRoamResult roamResult);
@@ -214,9 +214,9 @@ int hdd_set_csr_auth_type(hdd_adapter_t *pAdapter, eCsrAuthType RSNAuthType);
  * Construct the staDesc and register with TL the new STA.
  * This is called as part of ADD_STA in the TDLS setup.
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_roam_register_tdlssta(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_roam_register_tdlssta(hdd_adapter_t *pAdapter,
 				     const uint8_t *peerMac, uint16_t staId,
 				     uint8_t ucastSig);
 
@@ -248,7 +248,7 @@ hdd_indicate_ese_bcn_report_no_results(const hdd_adapter_t *pAdapter,
 					    const uint8_t numBss);
 #endif /* FEATURE_WLAN_ESE && FEATURE_WLAN_ESE_UPLOAD */
 
-CDF_STATUS hdd_change_peer_state(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_change_peer_state(hdd_adapter_t *pAdapter,
 				 uint8_t sta_id,
 				 enum ol_txrx_peer_state sta_state,
 				 bool roam_synch_in_progress);

core/hdd/inc/wlan_hdd_cfg.h

@@ -3569,32 +3569,32 @@ static __inline unsigned long util_min(unsigned long a, unsigned long b)
 }
 
 /* Function declarations and documenation */
-CDF_STATUS hdd_parse_config_ini(hdd_context_t *pHddCtx);
-CDF_STATUS hdd_update_mac_config(hdd_context_t *pHddCtx);
-CDF_STATUS hdd_set_sme_config(hdd_context_t *pHddCtx);
-CDF_STATUS hdd_set_sme_chan_list(hdd_context_t *hdd_ctx);
+QDF_STATUS hdd_parse_config_ini(hdd_context_t *pHddCtx);
+QDF_STATUS hdd_update_mac_config(hdd_context_t *pHddCtx);
+QDF_STATUS hdd_set_sme_config(hdd_context_t *pHddCtx);
+QDF_STATUS hdd_set_sme_chan_list(hdd_context_t *hdd_ctx);
 bool hdd_update_config_dat(hdd_context_t *pHddCtx);
-CDF_STATUS hdd_cfg_get_global_config(hdd_context_t *pHddCtx, char *pBuf,
+QDF_STATUS hdd_cfg_get_global_config(hdd_context_t *pHddCtx, char *pBuf,
 				     int buflen);
 
 eCsrPhyMode hdd_cfg_xlate_to_csr_phy_mode(eHddDot11Mode dot11Mode);
-CDF_STATUS hdd_execute_global_config_command(hdd_context_t *pHddCtx,
+QDF_STATUS hdd_execute_global_config_command(hdd_context_t *pHddCtx,
 					     char *command);
 
 bool hdd_is_okc_mode_enabled(hdd_context_t *pHddCtx);
-CDF_STATUS hdd_set_idle_ps_config(hdd_context_t *pHddCtx, uint32_t val);
+QDF_STATUS hdd_set_idle_ps_config(hdd_context_t *pHddCtx, uint32_t val);
 
 void hdd_update_tgt_cfg(void *context, void *param);
 bool hdd_dfs_indicate_radar(void *context, void *param);
 
-CDF_STATUS hdd_string_to_u8_array(char *str, uint8_t *intArray, uint8_t *len,
+QDF_STATUS hdd_string_to_u8_array(char *str, uint8_t *intArray, uint8_t *len,
 				  uint8_t intArrayMaxLen);
-CDF_STATUS hdd_hex_string_to_u16_array(char *str, uint16_t *int_array,
+QDF_STATUS hdd_hex_string_to_u16_array(char *str, uint16_t *int_array,
 				uint8_t *len, uint8_t int_array_max_len);
 
 void hdd_cfg_print(hdd_context_t *pHddCtx);
 
-CDF_STATUS hdd_update_nss(hdd_context_t *hdd_ctx, uint8_t nss);
+QDF_STATUS hdd_update_nss(hdd_context_t *hdd_ctx, uint8_t nss);
 #ifdef FEATURE_WLAN_SCAN_PNO
 void hdd_set_pno_channel_prediction_config(
 	tpSmeConfigParams sme_config, hdd_context_t *hdd_ctx);

core/hdd/inc/wlan_hdd_debugfs.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2014 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -29,12 +29,12 @@
 #define _WLAN_HDD_DEBUGFS_H
 
 #ifdef WLAN_OPEN_SOURCE
-CDF_STATUS hdd_debugfs_init(hdd_adapter_t *pAdapter);
+QDF_STATUS hdd_debugfs_init(hdd_adapter_t *pAdapter);
 void hdd_debugfs_exit(hdd_context_t *pHddCtx);
 #else
-inline CDF_STATUS hdd_debugfs_init(hdd_adapter_t *pAdapter)
+inline QDF_STATUS hdd_debugfs_init(hdd_adapter_t *pAdapter)
 {
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 inline void hdd_debugfs_exit(hdd_context_t *pHddCtx)

core/hdd/inc/wlan_hdd_ftm.h

@@ -34,7 +34,6 @@
  * WLAN Host Device Driver Factory Test Mode header file
  */
 
-#include "cdf_status.h"
 #include "qdf_status.h"
 #include "cds_mq.h"
 #include "cds_api.h"
@@ -60,7 +59,7 @@ int wlan_hdd_ftm_open(hdd_context_t *hdd_ctx);
 int wlan_hdd_ftm_close(hdd_context_t *hdd_ctx);
 
 #if  defined(QCA_WIFI_FTM)
-CDF_STATUS wlan_hdd_ftm_testmode_cmd(void *data, int len);
+QDF_STATUS wlan_hdd_ftm_testmode_cmd(void *data, int len);
 int wlan_hdd_qcmbr_unified_ioctl(hdd_adapter_t *adapter, struct ifreq *ifr);
 int hdd_ftm_start(hdd_context_t *hdd_ctx);
 int hdd_ftm_stop(hdd_context_t *hdd_ctx);

core/hdd/inc/wlan_hdd_ipa.h

@@ -52,9 +52,9 @@ static inline hdd_ipa_nbuf_cb_fn wlan_hdd_stub_ipa_fn(void)
 	return hdd_ipa_nbuf_cb;
 };
 
-CDF_STATUS hdd_ipa_init(hdd_context_t *hdd_ctx);
-CDF_STATUS hdd_ipa_cleanup(hdd_context_t *hdd_ctx);
-CDF_STATUS hdd_ipa_process_rxt(void *cds_context, cdf_nbuf_t rxBuf,
+QDF_STATUS hdd_ipa_init(hdd_context_t *hdd_ctx);
+QDF_STATUS hdd_ipa_cleanup(hdd_context_t *hdd_ctx);
+QDF_STATUS hdd_ipa_process_rxt(void *cds_context, cdf_nbuf_t rxBuf,
 	uint8_t sta_id);
 int hdd_ipa_wlan_evt(hdd_adapter_t *adapter, uint8_t sta_id,
 	enum ipa_wlan_event type, uint8_t *mac_addr);
@@ -75,20 +75,20 @@ void hdd_ipa_uc_force_pipe_shutdown(hdd_context_t *hdd_ctx);
 struct sk_buff *hdd_ipa_tx_packet_ipa(hdd_context_t *hdd_ctx,
 	struct sk_buff *skb, uint8_t session_id);
 #else
-static inline CDF_STATUS hdd_ipa_init(hdd_context_t *hdd_ctx)
+static inline QDF_STATUS hdd_ipa_init(hdd_context_t *hdd_ctx)
 {
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-static inline CDF_STATUS hdd_ipa_cleanup(hdd_context_t *hdd_ctx)
+static inline QDF_STATUS hdd_ipa_cleanup(hdd_context_t *hdd_ctx)
 {
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
-static inline CDF_STATUS hdd_ipa_process_rxt(void *cds_context,
+static inline QDF_STATUS hdd_ipa_process_rxt(void *cds_context,
 	cdf_nbuf_t rxBuf, uint8_t sta_id)
 {
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 static inline int hdd_ipa_wlan_evt(hdd_adapter_t *adapter, uint8_t sta_id,

core/hdd/inc/wlan_hdd_main.h

@@ -674,7 +674,7 @@ typedef struct hdd_hostapd_state_s {
 	int bssState;
 	qdf_event_t cdf_event;
 	qdf_event_t cdf_stop_bss_event;
-	CDF_STATUS cdf_status;
+	QDF_STATUS qdf_status;
 	bool bCommit;
 
 } hdd_hostapd_state_t;
@@ -899,7 +899,7 @@ struct hdd_adapter_s {
 	struct completion tdls_del_station_comp;
 	struct completion tdls_mgmt_comp;
 	struct completion tdls_link_establish_req_comp;
-	CDF_STATUS tdlsAddStaStatus;
+	QDF_STATUS tdlsAddStaStatus;
 #endif
 
 	/* Track whether the linkup handling is needed  */
@@ -1343,43 +1343,43 @@ void wlan_hdd_check_sta_ap_concurrent_ch_intf(void *sta_pAdapter);
 
 const char *hdd_device_mode_to_string(uint8_t device_mode);
 
-CDF_STATUS hdd_get_front_adapter(hdd_context_t *pHddCtx,
+QDF_STATUS hdd_get_front_adapter(hdd_context_t *pHddCtx,
 				 hdd_adapter_list_node_t **ppAdapterNode);
 
-CDF_STATUS hdd_get_next_adapter(hdd_context_t *pHddCtx,
+QDF_STATUS hdd_get_next_adapter(hdd_context_t *pHddCtx,
 				hdd_adapter_list_node_t *pAdapterNode,
 				hdd_adapter_list_node_t **pNextAdapterNode);
 
-CDF_STATUS hdd_remove_adapter(hdd_context_t *pHddCtx,
+QDF_STATUS hdd_remove_adapter(hdd_context_t *pHddCtx,
 			      hdd_adapter_list_node_t *pAdapterNode);
 
-CDF_STATUS hdd_remove_front_adapter(hdd_context_t *pHddCtx,
+QDF_STATUS hdd_remove_front_adapter(hdd_context_t *pHddCtx,
 				    hdd_adapter_list_node_t **ppAdapterNode);
 
-CDF_STATUS hdd_add_adapter_back(hdd_context_t *pHddCtx,
+QDF_STATUS hdd_add_adapter_back(hdd_context_t *pHddCtx,
 				hdd_adapter_list_node_t *pAdapterNode);
 
-CDF_STATUS hdd_add_adapter_front(hdd_context_t *pHddCtx,
+QDF_STATUS hdd_add_adapter_front(hdd_context_t *pHddCtx,
 				 hdd_adapter_list_node_t *pAdapterNode);
 
 hdd_adapter_t *hdd_open_adapter(hdd_context_t *pHddCtx, uint8_t session_type,
 				const char *name, tSirMacAddr macAddr,
 				bool rtnl_held);
-CDF_STATUS hdd_close_adapter(hdd_context_t *pHddCtx, hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_close_adapter(hdd_context_t *pHddCtx, hdd_adapter_t *pAdapter,
 			     bool rtnl_held);
-CDF_STATUS hdd_close_all_adapters(hdd_context_t *pHddCtx, bool rtnl_held);
-CDF_STATUS hdd_stop_all_adapters(hdd_context_t *pHddCtx);
-CDF_STATUS hdd_reset_all_adapters(hdd_context_t *pHddCtx);
-CDF_STATUS hdd_start_all_adapters(hdd_context_t *pHddCtx);
+QDF_STATUS hdd_close_all_adapters(hdd_context_t *pHddCtx, bool rtnl_held);
+QDF_STATUS hdd_stop_all_adapters(hdd_context_t *pHddCtx);
+QDF_STATUS hdd_reset_all_adapters(hdd_context_t *pHddCtx);
+QDF_STATUS hdd_start_all_adapters(hdd_context_t *pHddCtx);
 hdd_adapter_t *hdd_get_adapter_by_vdev(hdd_context_t *pHddCtx,
 				       uint32_t vdev_id);
 hdd_adapter_t *hdd_get_adapter_by_macaddr(hdd_context_t *pHddCtx,
 					  tSirMacAddr macAddr);
-CDF_STATUS hdd_init_station_mode(hdd_adapter_t *pAdapter);
+QDF_STATUS hdd_init_station_mode(hdd_adapter_t *pAdapter);
 hdd_adapter_t *hdd_get_adapter(hdd_context_t *pHddCtx, device_mode_t mode);
 void hdd_deinit_adapter(hdd_context_t *pHddCtx, hdd_adapter_t *pAdapter,
 			bool rtnl_held);
-CDF_STATUS hdd_stop_adapter(hdd_context_t *pHddCtx, hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_stop_adapter(hdd_context_t *pHddCtx, hdd_adapter_t *pAdapter,
 			    const bool bCloseSession);
 void hdd_set_station_ops(struct net_device *pWlanDev);
 uint8_t *wlan_hdd_get_intf_addr(hdd_context_t *pHddCtx);
@@ -1400,12 +1400,12 @@ void hdd_allow_suspend(uint32_t reason);
 void hdd_prevent_suspend_timeout(uint32_t timeout, uint32_t reason);
 
 void wlan_hdd_cfg80211_update_wiphy_caps(struct wiphy *wiphy);
-CDF_STATUS hdd_set_ibss_power_save_params(hdd_adapter_t *pAdapter);
-CDF_STATUS wlan_hdd_restart_driver(hdd_context_t *pHddCtx);
+QDF_STATUS hdd_set_ibss_power_save_params(hdd_adapter_t *pAdapter);
+QDF_STATUS wlan_hdd_restart_driver(hdd_context_t *pHddCtx);
 void hdd_exchange_version_and_caps(hdd_context_t *pHddCtx);
 int wlan_hdd_validate_context(hdd_context_t *pHddCtx);
 bool hdd_is_valid_mac_address(const uint8_t *pMacAddr);
-CDF_STATUS hdd_issta_p2p_clientconnected(hdd_context_t *pHddCtx);
+QDF_STATUS hdd_issta_p2p_clientconnected(hdd_context_t *pHddCtx);
 
 void hdd_checkandupdate_phymode(hdd_context_t *pHddCtx);
 
@@ -1484,11 +1484,11 @@ void hdd_update_macaddr(struct hdd_config *config,
 void wlan_hdd_disable_roaming(hdd_adapter_t *pAdapter);
 void wlan_hdd_enable_roaming(hdd_adapter_t *pAdapter);
 
-CDF_STATUS hdd_post_cds_enable_config(hdd_context_t *pHddCtx);
+QDF_STATUS hdd_post_cds_enable_config(hdd_context_t *pHddCtx);
 
-CDF_STATUS hdd_abort_mac_scan_all_adapters(hdd_context_t *hdd_ctx);
+QDF_STATUS hdd_abort_mac_scan_all_adapters(hdd_context_t *hdd_ctx);
 
-CDF_STATUS wlan_hdd_check_custom_con_channel_rules(hdd_adapter_t *sta_adapter,
+QDF_STATUS wlan_hdd_check_custom_con_channel_rules(hdd_adapter_t *sta_adapter,
 						  hdd_adapter_t *ap_adapter,
 						  tCsrRoamProfile *roam_profile,
 						  tScanResultHandle *scan_cache,

core/hdd/inc/wlan_hdd_power.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2014-2015 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2012, 2014-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -128,11 +128,11 @@ struct pkt_filter_cfg {
 
 
 /* SSR shutdown & re-init functions */
-CDF_STATUS hdd_wlan_shutdown(void);
-CDF_STATUS hdd_wlan_re_init(void *hif_sc);
+QDF_STATUS hdd_wlan_shutdown(void);
+QDF_STATUS hdd_wlan_re_init(void *hif_sc);
 
 void hdd_conf_mcastbcast_filter(hdd_context_t *pHddCtx, bool setfilter);
-CDF_STATUS hdd_conf_arp_offload(hdd_adapter_t *pAdapter, bool fenable);
+QDF_STATUS hdd_conf_arp_offload(hdd_adapter_t *pAdapter, bool fenable);
 void hdd_conf_hostoffload(hdd_adapter_t *pAdapter, bool fenable);
 
 #ifdef WLAN_FEATURE_PACKET_FILTERING

core/hdd/inc/wlan_hdd_softap_tx_rx.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014-2015 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -39,24 +39,24 @@
 int hdd_softap_hard_start_xmit(struct sk_buff *skb,
 			       struct net_device *dev);
 void hdd_softap_tx_timeout(struct net_device *dev);
-CDF_STATUS hdd_softap_init_tx_rx(hdd_adapter_t *pAdapter);
-CDF_STATUS hdd_softap_deinit_tx_rx(hdd_adapter_t *pAdapter);
-CDF_STATUS hdd_softap_init_tx_rx_sta(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_softap_init_tx_rx(hdd_adapter_t *pAdapter);
+QDF_STATUS hdd_softap_deinit_tx_rx(hdd_adapter_t *pAdapter);
+QDF_STATUS hdd_softap_init_tx_rx_sta(hdd_adapter_t *pAdapter,
 				     uint8_t STAId,
 				     struct cdf_mac_addr *pmacAddrSTA);
-CDF_STATUS hdd_softap_deinit_tx_rx_sta(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_softap_deinit_tx_rx_sta(hdd_adapter_t *pAdapter,
 				       uint8_t STAId);
-CDF_STATUS hdd_softap_rx_packet_cbk(void *cds_context,
+QDF_STATUS hdd_softap_rx_packet_cbk(void *cds_context,
 				    cdf_nbuf_t rxBufChain,
 				    uint8_t staId);
 #ifdef IPA_OFFLOAD
-CDF_STATUS hdd_softap_rx_mul_packet_cbk(void *cds_context,
+QDF_STATUS hdd_softap_rx_mul_packet_cbk(void *cds_context,
 					cdf_nbuf_t rx_buf_list, uint8_t staId);
 #endif /* IPA_OFFLOAD */
 
-CDF_STATUS hdd_softap_deregister_sta(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_softap_deregister_sta(hdd_adapter_t *pAdapter,
 				     uint8_t staId);
-CDF_STATUS hdd_softap_register_sta(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_softap_register_sta(hdd_adapter_t *pAdapter,
 				   bool fAuthRequired,
 				   bool fPrivacyBit,
 				   uint8_t staId,
@@ -64,14 +64,14 @@ CDF_STATUS hdd_softap_register_sta(hdd_adapter_t *pAdapter,
 				   uint8_t bcastSig,
 				   struct cdf_mac_addr *pPeerMacAddress,
 				   bool fWmmEnabled);
-CDF_STATUS hdd_softap_register_bc_sta(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_softap_register_bc_sta(hdd_adapter_t *pAdapter,
 				      bool fPrivacyBit);
-CDF_STATUS hdd_softap_deregister_bc_sta(hdd_adapter_t *pAdapter);
-CDF_STATUS hdd_softap_stop_bss(hdd_adapter_t *pHostapdAdapter);
-CDF_STATUS hdd_softap_change_sta_state(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_softap_deregister_bc_sta(hdd_adapter_t *pAdapter);
+QDF_STATUS hdd_softap_stop_bss(hdd_adapter_t *pHostapdAdapter);
+QDF_STATUS hdd_softap_change_sta_state(hdd_adapter_t *pAdapter,
 				       struct cdf_mac_addr *pDestMacAddress,
 				       enum ol_txrx_peer_state state);
-CDF_STATUS hdd_softap_get_sta_id(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_softap_get_sta_id(hdd_adapter_t *pAdapter,
 				 struct cdf_mac_addr *pMacAddress,
 				 uint8_t *staId);
 

core/hdd/inc/wlan_hdd_tx_rx.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2015 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -55,17 +55,17 @@
 
 int hdd_hard_start_xmit(struct sk_buff *skb, struct net_device *dev);
 void hdd_tx_timeout(struct net_device *dev);
-CDF_STATUS hdd_init_tx_rx(hdd_adapter_t *pAdapter);
-CDF_STATUS hdd_deinit_tx_rx(hdd_adapter_t *pAdapter);
-CDF_STATUS hdd_rx_packet_cbk(void *cds_context, cdf_nbuf_t rxBufChain,
+QDF_STATUS hdd_init_tx_rx(hdd_adapter_t *pAdapter);
+QDF_STATUS hdd_deinit_tx_rx(hdd_adapter_t *pAdapter);
+QDF_STATUS hdd_rx_packet_cbk(void *cds_context, cdf_nbuf_t rxBufChain,
 			     uint8_t staId);
 
 #ifdef IPA_OFFLOAD
-CDF_STATUS hdd_rx_mul_packet_cbk(void *cds_context,
+QDF_STATUS hdd_rx_mul_packet_cbk(void *cds_context,
 				 cdf_nbuf_t rx_buf_list, uint8_t staId);
 #endif /* IPA_OFFLOAD */
 
-CDF_STATUS hdd_ibss_get_sta_id(hdd_station_ctx_t *pHddStaCtx,
+QDF_STATUS hdd_ibss_get_sta_id(hdd_station_ctx_t *pHddStaCtx,
 			       struct cdf_mac_addr *pMacAddress,
 			       uint8_t *staId);
 

core/hdd/inc/wlan_hdd_wext.h

@@ -338,23 +338,23 @@ extern int hdd_priv_get_data(struct iw_point *p_priv_data,
 
 extern void *mem_alloc_copy_from_user_helper(const void *wrqu_data, size_t len);
 
-extern CDF_STATUS wlan_hdd_get_linkspeed_for_peermac(hdd_adapter_t *pAdapter,
+extern QDF_STATUS wlan_hdd_get_linkspeed_for_peermac(hdd_adapter_t *pAdapter,
 					     struct cdf_mac_addr mac_address);
 void hdd_clear_roam_profile_ie(hdd_adapter_t *pAdapter);
 
 uint8_t *wlan_hdd_get_vendor_oui_ie_ptr(uint8_t *oui, uint8_t oui_size,
 					uint8_t *ie, int ie_len);
 
-CDF_STATUS wlan_hdd_get_class_astats(hdd_adapter_t *pAdapter);
+QDF_STATUS wlan_hdd_get_class_astats(hdd_adapter_t *pAdapter);
 
-CDF_STATUS wlan_hdd_get_station_stats(hdd_adapter_t *pAdapter);
+QDF_STATUS wlan_hdd_get_station_stats(hdd_adapter_t *pAdapter);
 
-CDF_STATUS wlan_hdd_get_rssi(hdd_adapter_t *pAdapter, int8_t *rssi_value);
+QDF_STATUS wlan_hdd_get_rssi(hdd_adapter_t *pAdapter, int8_t *rssi_value);
 
-CDF_STATUS wlan_hdd_get_snr(hdd_adapter_t *pAdapter, int8_t *snr);
+QDF_STATUS wlan_hdd_get_snr(hdd_adapter_t *pAdapter, int8_t *snr);
 
 #ifdef FEATURE_WLAN_TDLS
-CDF_STATUS iw_set_tdls_params(struct net_device *dev,
+QDF_STATUS iw_set_tdls_params(struct net_device *dev,
 			      struct iw_request_info *info,
 			      union iwreq_data *wrqu, char *extra, int nOffset);
 #endif

core/hdd/inc/wlan_hdd_wmm.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011-2012,2014 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2011-2012,2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -223,9 +223,9 @@ int hdd_wmmps_helper(hdd_adapter_t *pAdapter, uint8_t *ptr);
  * adapter to an initial state.  The configuration can later be
  * overwritten via application APIs or via QoS Map sent OTA.
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_wmm_init(hdd_adapter_t *pAdapter);
+QDF_STATUS hdd_wmm_init(hdd_adapter_t *pAdapter);
 
 /**
  * hdd_wmm_adapter_init() - initialize the WMM configuration of an adapter
@@ -235,9 +235,9 @@ CDF_STATUS hdd_wmm_init(hdd_adapter_t *pAdapter);
  * adapter to an initial state.  The configuration can later be
  * overwritten via application APIs
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_wmm_adapter_init(hdd_adapter_t *pAdapter);
+QDF_STATUS hdd_wmm_adapter_init(hdd_adapter_t *pAdapter);
 
 /**
  * hdd_wmm_close() - WMM close function
@@ -246,9 +246,9 @@ CDF_STATUS hdd_wmm_adapter_init(hdd_adapter_t *pAdapter);
  * Function which will perform any necessary work to to clean up the
  * WMM functionality prior to the kernel module unload.
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_wmm_adapter_close(hdd_adapter_t *pAdapter);
+QDF_STATUS hdd_wmm_adapter_close(hdd_adapter_t *pAdapter);
 
 /**
  * hdd_wmm_select_queue() - Function which will classify the packet
@@ -301,9 +301,9 @@ void hdd_wmm_acquire_access_required(hdd_adapter_t *pAdapter,
  * @pGranted: [out] pointer to bool flag when indicates if access
  *	      has been granted or not
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_wmm_acquire_access(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_wmm_acquire_access(hdd_adapter_t *pAdapter,
 				  sme_ac_enum_type acType, bool *pGranted);
 
 /**
@@ -314,9 +314,9 @@ CDF_STATUS hdd_wmm_acquire_access(hdd_adapter_t *pAdapter,
  * @pRoamInfo: [in]  pointer to roam information
  * @eBssType: [in]  type of BSS
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_wmm_assoc(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_wmm_assoc(hdd_adapter_t *pAdapter,
 			 tCsrRoamInfo *pRoamInfo, eCsrRoamBssType eBssType);
 
 /**
@@ -327,9 +327,9 @@ CDF_STATUS hdd_wmm_assoc(hdd_adapter_t *pAdapter,
  * @pRoamInfo: [in]  pointer to roam information
  * @eBssType : [in]  type of BSS
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_wmm_connect(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_wmm_connect(hdd_adapter_t *pAdapter,
 			   tCsrRoamInfo *pRoamInfo, eCsrRoamBssType eBssType);
 
 /**
@@ -339,9 +339,9 @@ CDF_STATUS hdd_wmm_connect(hdd_adapter_t *pAdapter,
  * @pAdapter  : [in]  pointer to adapter context
  * @pUapsdMask: [out] pointer to where the UAPSD Mask is to be stored
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_wmm_get_uapsd_mask(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_wmm_get_uapsd_mask(hdd_adapter_t *pAdapter,
 				  uint8_t *pUapsdMask);
 
 /**
@@ -396,9 +396,9 @@ hdd_wlan_wmm_status_e hdd_wmm_checkts(hdd_adapter_t *pAdapter,
  *
  * @pAdapter: [in]  pointer to Adapter context
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_wmm_adapter_clear(hdd_adapter_t *pAdapter);
+QDF_STATUS hdd_wmm_adapter_clear(hdd_adapter_t *pAdapter);
 
 void wlan_hdd_process_peer_unauthorised_pause(hdd_adapter_t *adapter);
 #endif /* #ifndef _WLAN_HDD_WMM_H */

core/hdd/src/wlan_hdd_assoc.c

@@ -917,12 +917,12 @@ static void hdd_conn_remove_connect_info(hdd_station_ctx_t *pHddStaCtx)
  * @pAdapter: pointer to adapter
  * @staId: station identifier
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-static CDF_STATUS
+static QDF_STATUS
 hdd_roam_deregister_sta(hdd_adapter_t *pAdapter, uint8_t staId)
 {
-	CDF_STATUS cdf_status;
+	QDF_STATUS qdf_status;
 	hdd_station_ctx_t *pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
 
 	if (eConnectionState_IbssDisconnected ==
@@ -933,13 +933,13 @@ hdd_roam_deregister_sta(hdd_adapter_t *pAdapter, uint8_t staId)
 		 */
 	}
 
-	cdf_status = ol_txrx_clear_peer(staId);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = ol_txrx_clear_peer(staId);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		hddLog(LOGE,
 			FL("ol_txrx_clear_peer() failed for staID %d. Status(%d) [0x%08X]"),
-			staId, cdf_status, cdf_status);
+			staId, qdf_status, qdf_status);
 	}
-	return cdf_status;
+	return qdf_status;
 }
 
 /**
@@ -955,16 +955,16 @@ hdd_roam_deregister_sta(hdd_adapter_t *pAdapter, uint8_t staId)
  * 2. Clean up internal connection states and data structures;
  * 3. Send disconnect indication to supplicant.
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-static CDF_STATUS hdd_dis_connect_handler(hdd_adapter_t *pAdapter,
+static QDF_STATUS hdd_dis_connect_handler(hdd_adapter_t *pAdapter,
 					  tCsrRoamInfo *pRoamInfo,
 					  uint32_t roamId,
 					  eRoamCmdStatus roamStatus,
 					  eCsrRoamResult roamResult)
 {
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
-	CDF_STATUS vstatus;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	QDF_STATUS vstatus;
 	struct net_device *dev = pAdapter->dev;
 	hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
 	hdd_station_ctx_t *pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
@@ -973,7 +973,7 @@ static CDF_STATUS hdd_dis_connect_handler(hdd_adapter_t *pAdapter,
 
 	if (dev == NULL) {
 		hddLog(LOGE, FL("net_dev is released return"));
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 	/* notify apps that we can't pass traffic anymore */
 	hddLog(LOG1, FL("Disabling queues"));
@@ -1083,10 +1083,10 @@ static CDF_STATUS hdd_dis_connect_handler(hdd_adapter_t *pAdapter,
 		uint8_t i;
 		sta_id = pHddStaCtx->broadcast_ibss_staid;
 		vstatus = hdd_roam_deregister_sta(pAdapter, sta_id);
-		if (!CDF_IS_STATUS_SUCCESS(vstatus)) {
+		if (!QDF_IS_STATUS_SUCCESS(vstatus)) {
 			hdd_err("hdd_roam_deregister_sta() failed for staID %d Status=%d [0x%x]",
 					sta_id, status, status);
-			status = CDF_STATUS_E_FAILURE;
+			status = QDF_STATUS_E_FAILURE;
 		}
 		pHddCtx->sta_to_adapter[sta_id] = NULL;
 		/* Clear all the peer sta register with TL. */
@@ -1096,11 +1096,11 @@ static CDF_STATUS hdd_dis_connect_handler(hdd_adapter_t *pAdapter,
 			sta_id = pHddStaCtx->conn_info.staId[i];
 			hddLog(LOG1, FL("Deregister StaID %d"), sta_id);
 			vstatus = hdd_roam_deregister_sta(pAdapter, sta_id);
-			if (!CDF_IS_STATUS_SUCCESS(vstatus)) {
+			if (!QDF_IS_STATUS_SUCCESS(vstatus)) {
 				hddLog(LOGE,
 					FL("hdd_roamDeregisterSTA() failed to for staID %d. Status= %d [0x%x]"),
 					sta_id, status, status);
-				status = CDF_STATUS_E_FAILURE;
+				status = QDF_STATUS_E_FAILURE;
 			}
 			/* set the staid and peer mac as 0, all other
 			 * reset are done in hdd_connRemoveConnectInfo.
@@ -1117,11 +1117,11 @@ static CDF_STATUS hdd_dis_connect_handler(hdd_adapter_t *pAdapter,
 		 * for now, only one.
 		 */
 		vstatus = hdd_roam_deregister_sta(pAdapter, sta_id);
-		if (!CDF_IS_STATUS_SUCCESS(vstatus)) {
+		if (!QDF_IS_STATUS_SUCCESS(vstatus)) {
 			hddLog(LOGE,
 				FL("hdd_roam_deregister_sta() failed to for staID %d. Status= %d [0x%x]"),
 				sta_id, status, status);
-			status = CDF_STATUS_E_FAILURE;
+			status = QDF_STATUS_E_FAILURE;
 		}
 		pHddCtx->sta_to_adapter[sta_id] = NULL;
 	}
@@ -1181,38 +1181,38 @@ void hdd_set_peer_authorized_event(uint32_t vdev_id)
  *
  * Return: CDF status
  */
-CDF_STATUS hdd_change_peer_state(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_change_peer_state(hdd_adapter_t *pAdapter,
 				 uint8_t sta_id,
 				 enum ol_txrx_peer_state sta_state,
 				 bool roam_synch_in_progress)
 {
 	struct ol_txrx_peer_t *peer;
-	CDF_STATUS err;
+	QDF_STATUS err;
 	struct ol_txrx_pdev_t *pdev = cds_get_context(CDF_MODULE_ID_TXRX);
 
 	if (!pdev) {
 		hdd_err("Failed to get txrx context");
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	if (sta_id >= WLAN_MAX_STA_COUNT) {
 		hddLog(LOGE, "Invalid sta id :%d", sta_id);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	peer = ol_txrx_peer_find_by_local_id(pdev, sta_id);
 	if (!peer)
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 
 	err = ol_txrx_peer_state_update(pdev,
 			(u_int8_t *) peer->mac_addr.raw, sta_state);
-	if (err != CDF_STATUS_SUCCESS) {
+	if (err != QDF_STATUS_SUCCESS) {
 		hddLog(LOGE, "peer state update failed");
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
 	if (roam_synch_in_progress)
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 #endif
 
 	if (sta_state == ol_txrx_peer_state_auth) {
@@ -1224,9 +1224,9 @@ CDF_STATUS hdd_change_peer_state(hdd_adapter_t *pAdapter,
 		err = sme_set_peer_authorized(peer->mac_addr.raw,
 				hdd_set_peer_authorized_event,
 				pAdapter->sessionId);
-		if (err != CDF_STATUS_SUCCESS) {
+		if (err != QDF_STATUS_SUCCESS) {
 			hddLog(LOGE, "Failed to set the peer state to authorized");
-			return CDF_STATUS_E_FAULT;
+			return QDF_STATUS_E_FAULT;
 		}
 
 		if (pAdapter->device_mode == WLAN_HDD_INFRA_STATION ||
@@ -1247,7 +1247,7 @@ CDF_STATUS hdd_change_peer_state(hdd_adapter_t *pAdapter,
 #endif
 		}
 	}
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -1258,20 +1258,20 @@ CDF_STATUS hdd_change_peer_state(hdd_adapter_t *pAdapter,
  * @pPeerMacAddress: peer MAC address
  * @pBssDesc: pointer to BSS description
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-static CDF_STATUS hdd_roam_register_sta(hdd_adapter_t *pAdapter,
+static QDF_STATUS hdd_roam_register_sta(hdd_adapter_t *pAdapter,
 					tCsrRoamInfo *pRoamInfo,
 					uint8_t staId,
 					struct cdf_mac_addr *pPeerMacAddress,
 					tSirBssDescription *pBssDesc)
 {
-	CDF_STATUS cdf_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS qdf_status = QDF_STATUS_E_FAILURE;
 	struct ol_txrx_desc_type staDesc = { 0 };
 	hdd_station_ctx_t *pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
 
 	if (NULL == pBssDesc)
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
 	/* Get the Station ID from the one saved during the association */
 	staDesc.sta_id = staId;
@@ -1291,13 +1291,13 @@ static CDF_STATUS hdd_roam_register_sta(hdd_adapter_t *pAdapter,
 		staDesc.is_wapi_supported = 0;
 #endif /* FEATURE_WLAN_WAPI */
 
-	cdf_status = ol_txrx_register_peer(hdd_rx_packet_cbk,
+	qdf_status = ol_txrx_register_peer(hdd_rx_packet_cbk,
 						&staDesc);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		hddLog(LOGW,
 			"ol_txrx_register_peer() failed to register. Status=%d [0x%08X]",
-			cdf_status, cdf_status);
-		return cdf_status;
+			qdf_status, qdf_status);
+		return qdf_status;
 	}
 
 	if (!pRoamInfo->fAuthRequired) {
@@ -1305,7 +1305,7 @@ static CDF_STATUS hdd_roam_register_sta(hdd_adapter_t *pAdapter,
 		 * Connections that do not need Upper layer auth, transition
 		 * TLSHIM directly to 'Authenticated' state
 		 */
-		cdf_status =
+		qdf_status =
 			hdd_change_peer_state(pAdapter, staDesc.sta_id,
 						ol_txrx_peer_state_auth,
 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
@@ -1320,7 +1320,7 @@ static CDF_STATUS hdd_roam_register_sta(hdd_adapter_t *pAdapter,
 		hddLog(LOG3,
 			"ULA auth StaId= %d. Changing TL state to CONNECTED at Join time",
 			 pHddStaCtx->conn_info.staId[0]);
-		cdf_status =
+		qdf_status =
 			hdd_change_peer_state(pAdapter, staDesc.sta_id,
 						ol_txrx_peer_state_conn,
 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
@@ -1331,7 +1331,7 @@ static CDF_STATUS hdd_roam_register_sta(hdd_adapter_t *pAdapter,
 						);
 		hdd_conn_set_authenticated(pAdapter, false);
 	}
-	return cdf_status;
+	return qdf_status;
 }
 
 /**
@@ -1541,9 +1541,9 @@ static int hdd_change_sta_state_authenticated(hdd_adapter_t *adapter,
  * @roamStatus: roam status
  * @roamResult: roam result
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-static CDF_STATUS hdd_roam_set_key_complete_handler(hdd_adapter_t *pAdapter,
+static QDF_STATUS hdd_roam_set_key_complete_handler(hdd_adapter_t *pAdapter,
 						    tCsrRoamInfo *pRoamInfo,
 						    uint32_t roamId,
 						    eRoamCmdStatus roamStatus,
@@ -1551,13 +1551,13 @@ static CDF_STATUS hdd_roam_set_key_complete_handler(hdd_adapter_t *pAdapter,
 {
 	eCsrEncryptionType connectedCipherAlgo;
 	bool fConnected = false;
-	CDF_STATUS cdf_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS qdf_status = QDF_STATUS_E_FAILURE;
 	hdd_station_ctx_t *pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
 	ENTER();
 
 	if (NULL == pRoamInfo) {
 		hddLog(LOG2, FL("pRoamInfo is NULL"));
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 	/*
 	 * if (WPA), tell TL to go to 'authenticated' after the keys are set.
@@ -1579,11 +1579,11 @@ static CDF_STATUS hdd_roam_set_key_complete_handler(hdd_adapter_t *pAdapter,
 				pHddStaCtx->roam_info.roamingState =
 					HDD_ROAM_STATE_NONE;
 			} else {
-				cdf_status = hdd_ibss_get_sta_id(
+				qdf_status = hdd_ibss_get_sta_id(
 							pHddStaCtx,
 							&pRoamInfo->peerMac,
 							&staId);
-				if (CDF_STATUS_SUCCESS == cdf_status) {
+				if (QDF_STATUS_SUCCESS == qdf_status) {
 					hddLog(LOG2,
 						"WLAN TL STA Ptk Installed for STAID=%d",
 						staId);
@@ -1623,11 +1623,11 @@ static CDF_STATUS hdd_roam_set_key_complete_handler(hdd_adapter_t *pAdapter,
 			  eCSR_ENCRYPT_TYPE_WEP104_STATICKEY)) {
 				if (pHddStaCtx->conn_info.gtk_installed &&
 					pHddStaCtx->conn_info.ptk_installed)
-					cdf_status =
+					qdf_status =
 					    hdd_change_sta_state_authenticated(pAdapter,
 						pRoamInfo);
 			} else if (pHddStaCtx->conn_info.ptk_installed) {
-				cdf_status =
+				qdf_status =
 				    hdd_change_sta_state_authenticated(pAdapter,
 					pRoamInfo);
 			}
@@ -1650,7 +1650,7 @@ static CDF_STATUS hdd_roam_set_key_complete_handler(hdd_adapter_t *pAdapter,
 	}
 
 	EXIT();
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -1661,7 +1661,7 @@ static CDF_STATUS hdd_roam_set_key_complete_handler(hdd_adapter_t *pAdapter,
  */
 void hdd_perform_roam_set_key_complete(hdd_adapter_t *pAdapter)
 {
-	CDF_STATUS cdf_ret_status = CDF_STATUS_SUCCESS;
+	QDF_STATUS cdf_ret_status = QDF_STATUS_SUCCESS;
 	hdd_station_ctx_t *pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
 	tCsrRoamInfo roamInfo;
 	roamInfo.fAuthRequired = false;
@@ -1676,7 +1676,7 @@ void hdd_perform_roam_set_key_complete(hdd_adapter_t *pAdapter)
 					   pHddStaCtx->roam_info.roamId,
 					   pHddStaCtx->roam_info.roamStatus,
 					   eCSR_ROAM_RESULT_AUTHENTICATED);
-	if (cdf_ret_status != CDF_STATUS_SUCCESS)
+	if (cdf_ret_status != QDF_STATUS_SUCCESS)
 		hddLog(LOGE, FL("Set Key complete failure"));
 
 	pHddStaCtx->roam_info.deferKeyComplete = false;
@@ -1690,9 +1690,9 @@ void hdd_perform_roam_set_key_complete(hdd_adapter_t *pAdapter)
  * @roamStatus: roam status
  * @roamResult: roam result
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-static CDF_STATUS hdd_association_completion_handler(hdd_adapter_t *pAdapter,
+static QDF_STATUS hdd_association_completion_handler(hdd_adapter_t *pAdapter,
 						     tCsrRoamInfo *pRoamInfo,
 						     uint32_t roamId,
 						     eRoamCmdStatus roamStatus,
@@ -1701,7 +1701,7 @@ static CDF_STATUS hdd_association_completion_handler(hdd_adapter_t *pAdapter,
 	struct net_device *dev = pAdapter->dev;
 	hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
 	hdd_station_ctx_t *pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
-	CDF_STATUS cdf_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS qdf_status = QDF_STATUS_E_FAILURE;
 	uint8_t reqRsnIe[DOT11F_IE_RSN_MAX_LEN];
 	uint32_t reqRsnLength = DOT11F_IE_RSN_MAX_LEN;
 	int ft_carrier_on = false;
@@ -1710,7 +1710,7 @@ static CDF_STATUS hdd_association_completion_handler(hdd_adapter_t *pAdapter,
 
 	if (!pHddCtx) {
 		hdd_err("HDD context is NULL");
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	/* HDD has initiated disconnect, do not send connect result indication
@@ -1726,7 +1726,7 @@ static CDF_STATUS hdd_association_completion_handler(hdd_adapter_t *pAdapter,
 	if (eCSR_ROAM_RESULT_ASSOCIATED == roamResult) {
 		if (NULL == pRoamInfo) {
 			hddLog(LOGE, FL("pRoamInfo is NULL"));
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 		if (!hddDisconInProgress) {
 			hddLog(LOG1, FL("Set HDD connState to eConnectionState_Associated"));
@@ -1853,7 +1853,7 @@ static CDF_STATUS hdd_association_completion_handler(hdd_adapter_t *pAdapter,
 				wlan_hdd_netif_queue_control(pAdapter,
 					WLAN_NETIF_CARRIER_OFF,
 					WLAN_CONTROL_PATH);
-				return CDF_STATUS_E_FAILURE;
+				return QDF_STATUS_E_FAILURE;
 			}
 			if (pRoamInfo->u.pConnectedProfile->AuthType ==
 			    eCSR_AUTH_TYPE_FT_RSN
@@ -2083,7 +2083,7 @@ static CDF_STATUS hdd_association_completion_handler(hdd_adapter_t *pAdapter,
 				/*
 				 * Register the Station with TL after associated
 				 */
-				cdf_status = hdd_roam_register_sta(pAdapter,
+				qdf_status = hdd_roam_register_sta(pAdapter,
 								   pRoamInfo,
 								   pHddStaCtx->
 								   conn_info.
@@ -2107,7 +2107,7 @@ static CDF_STATUS hdd_association_completion_handler(hdd_adapter_t *pAdapter,
 						reqRsnIe, reqRsnLength);
 			/* Reassoc successfully */
 			if (pRoamInfo->fAuthRequired) {
-				cdf_status =
+				qdf_status =
 					hdd_change_peer_state(pAdapter,
 						pHddStaCtx->conn_info.staId[0],
 						ol_txrx_peer_state_conn,
@@ -2122,7 +2122,7 @@ static CDF_STATUS hdd_association_completion_handler(hdd_adapter_t *pAdapter,
 				hddLog(LOG2,
 					FL("staId: %d Changing TL state to AUTHENTICATED"),
 					  pHddStaCtx->conn_info.staId[0]);
-				cdf_status =
+				qdf_status =
 					hdd_change_peer_state(pAdapter,
 						pHddStaCtx->conn_info.staId[0],
 						ol_txrx_peer_state_auth,
@@ -2135,7 +2135,7 @@ static CDF_STATUS hdd_association_completion_handler(hdd_adapter_t *pAdapter,
 				hdd_conn_set_authenticated(pAdapter, true);
 			}
 
-			if (CDF_IS_STATUS_SUCCESS(cdf_status)) {
+			if (QDF_IS_STATUS_SUCCESS(qdf_status)) {
 				/*
 				 * Perform any WMM-related association
 				 * processing
@@ -2155,10 +2155,10 @@ static CDF_STATUS hdd_association_completion_handler(hdd_adapter_t *pAdapter,
 						   WLAN_CONTROL_PATH);
 		}
 
-		if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+		if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 			hddLog(LOGE,
 				"STA register with TL failed. status(=%d) [%08X]",
-				cdf_status, cdf_status);
+				qdf_status, qdf_status);
 		}
 #ifdef WLAN_FEATURE_11W
 		cdf_mem_zero(&pAdapter->hdd_stats.hddPmfStats,
@@ -2293,19 +2293,19 @@ static CDF_STATUS hdd_association_completion_handler(hdd_adapter_t *pAdapter,
 					   WLAN_CONTROL_PATH);
 	}
 
-	if (CDF_STATUS_SUCCESS != cds_check_and_restart_sap(
+	if (QDF_STATUS_SUCCESS != cds_check_and_restart_sap(
 					roamResult, pHddStaCtx))
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
 	if (NULL != pRoamInfo && NULL != pRoamInfo->pBssDesc) {
 		cds_force_sap_on_scc(roamResult,
 				pRoamInfo->pBssDesc->channelId);
 	} else {
 		hdd_err("pRoamInfo profile is not set properly");
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -2561,9 +2561,9 @@ static bool roam_remove_ibss_station(hdd_adapter_t *pAdapter, uint8_t staId)
  *
  * We update the status of the IBSS to connected in this function.
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-static CDF_STATUS roam_ibss_connect_handler(hdd_adapter_t *pAdapter,
+static QDF_STATUS roam_ibss_connect_handler(hdd_adapter_t *pAdapter,
 					    tCsrRoamInfo *pRoamInfo)
 {
 	struct cfg80211_bss *bss;
@@ -2585,13 +2585,13 @@ static CDF_STATUS roam_ibss_connect_handler(hdd_adapter_t *pAdapter,
 		hddLog(LOGE,
 		       FL("%s: unable to create IBSS entry"),
 		       pAdapter->dev->name);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 	cfg80211_put_bss(
 		WLAN_HDD_GET_CTX(pAdapter)->wiphy,
 		bss);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -2604,9 +2604,9 @@ static CDF_STATUS roam_ibss_connect_handler(hdd_adapter_t *pAdapter,
  *
  * This function indicates the Mic failure to the supplicant
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-static CDF_STATUS
+static QDF_STATUS
 hdd_roam_mic_error_indication_handler(hdd_adapter_t *pAdapter,
 				      tCsrRoamInfo *pRoamInfo,
 				      uint32_t roamId,
@@ -2652,7 +2652,7 @@ hdd_roam_mic_error_indication_handler(hdd_adapter_t *pAdapter,
 
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -2665,16 +2665,16 @@ hdd_roam_mic_error_indication_handler(hdd_adapter_t *pAdapter,
  *
  * The Ibss connection status is updated regularly here in this function.
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-static CDF_STATUS
+static QDF_STATUS
 roam_roam_connect_status_update_handler(hdd_adapter_t *pAdapter,
 					tCsrRoamInfo *pRoamInfo,
 					uint32_t roamId,
 					eRoamCmdStatus roamStatus,
 					eCsrRoamResult roamResult)
 {
-	CDF_STATUS cdf_status;
+	QDF_STATUS qdf_status;
 
 	hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
 	switch (roamResult) {
@@ -2702,15 +2702,15 @@ roam_roam_connect_status_update_handler(hdd_adapter_t *pAdapter,
 		pHddCtx->sta_to_adapter[pRoamInfo->staId] = pAdapter;
 
 		/* Register the Station with TL for the new peer. */
-		cdf_status = hdd_roam_register_sta(pAdapter,
+		qdf_status = hdd_roam_register_sta(pAdapter,
 						   pRoamInfo,
 						   pRoamInfo->staId,
 						   &pRoamInfo->peerMac,
 						   pRoamInfo->pBssDesc);
-		if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+		if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 			hddLog(LOGE,
-				"Cannot register STA with TL for IBSS. Failed with cdf_status = %d [%08X]",
-				cdf_status, cdf_status);
+				"Cannot register STA with TL for IBSS. Failed with qdf_status = %d [%08X]",
+				qdf_status, qdf_status);
 		}
 		pHddStaCtx->ibss_sta_generation++;
 		memset(&staInfo, 0, sizeof(staInfo));
@@ -2737,18 +2737,18 @@ roam_roam_connect_status_update_handler(hdd_adapter_t *pAdapter,
 			hddLog(LOG2, "New peer joined set PTK encType=%d",
 				  pHddStaCtx->ibss_enc_key.encType);
 
-			cdf_status =
+			qdf_status =
 				sme_roam_set_key(WLAN_HDD_GET_HAL_CTX
 							 (pAdapter),
 						 pAdapter->sessionId,
 						 &pHddStaCtx->ibss_enc_key,
 						 &roamId);
 
-			if (CDF_STATUS_SUCCESS != cdf_status) {
+			if (QDF_STATUS_SUCCESS != qdf_status) {
 				hddLog(LOGE,
 				       FL("sme_roam_set_key failed, status=%d"),
-				       cdf_status);
-				return CDF_STATUS_E_FAILURE;
+				       qdf_status);
+				return QDF_STATUS_E_FAILURE;
 			}
 		}
 		hddLog(LOG1, FL("Enabling queues"));
@@ -2814,7 +2814,7 @@ roam_roam_connect_status_update_handler(hdd_adapter_t *pAdapter,
 
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 #ifdef FEATURE_WLAN_TDLS
@@ -2828,13 +2828,13 @@ roam_roam_connect_status_update_handler(hdd_adapter_t *pAdapter,
  * Construct the staDesc and register with TL the new STA.
  * This is called as part of ADD_STA in the TDLS setup.
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_roam_register_tdlssta(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_roam_register_tdlssta(hdd_adapter_t *pAdapter,
 				     const uint8_t *peerMac, uint16_t staId,
 				     uint8_t ucastSig)
 {
-	CDF_STATUS cdf_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS qdf_status = QDF_STATUS_E_FAILURE;
 	struct ol_txrx_desc_type staDesc = { 0 };
 
 	/*
@@ -2849,15 +2849,15 @@ CDF_STATUS hdd_roam_register_tdlssta(hdd_adapter_t *pAdapter,
 
 
 	/* Register the Station with TL...  */
-	cdf_status = ol_txrx_register_peer(hdd_rx_packet_cbk,
+	qdf_status = ol_txrx_register_peer(hdd_rx_packet_cbk,
 						&staDesc);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		hddLog(LOGE, FL("ol_txrx_register_peer() failed to register. Status=%d [0x%08X]"),
-			cdf_status, cdf_status);
-		return cdf_status;
+			qdf_status, qdf_status);
+		return qdf_status;
 	}
 
-	return cdf_status;
+	return qdf_status;
 }
 
 /**
@@ -2865,18 +2865,18 @@ CDF_STATUS hdd_roam_register_tdlssta(hdd_adapter_t *pAdapter,
  * @pAdapter: pointer to adapter
  * @staId: station identifier
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-static CDF_STATUS hdd_roam_deregister_tdlssta(hdd_adapter_t *pAdapter,
+static QDF_STATUS hdd_roam_deregister_tdlssta(hdd_adapter_t *pAdapter,
 					      uint8_t staId)
 {
-	CDF_STATUS cdf_status;
-	cdf_status = ol_txrx_clear_peer(staId);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	QDF_STATUS qdf_status;
+	qdf_status = ol_txrx_clear_peer(staId);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		hddLog(LOGW, FL("ol_txrx_clear_peer() failed for staID %d. Status=%d [0x%08X]"),
-			staId, cdf_status, cdf_status);
+			staId, qdf_status, qdf_status);
 	}
-	return cdf_status;
+	return qdf_status;
 }
 
 /**
@@ -2891,9 +2891,9 @@ static CDF_STATUS hdd_roam_deregister_tdlssta(hdd_adapter_t *pAdapter,
  * TL in case of new TDLS client is added and deregistration at the time
  * TDLS client is deleted.
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-static CDF_STATUS
+static QDF_STATUS
 hdd_roam_tdls_status_update_handler(hdd_adapter_t *pAdapter,
 				    tCsrRoamInfo *pRoamInfo,
 				    uint32_t roamId,
@@ -2903,7 +2903,7 @@ hdd_roam_tdls_status_update_handler(hdd_adapter_t *pAdapter,
 	hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
 	tdlsCtx_t *pHddTdlsCtx = WLAN_HDD_GET_TDLS_CTX_PTR(pAdapter);
 	tSmeTdlsPeerStateParams smeTdlsPeerStateParams;
-	CDF_STATUS status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
 	uint8_t staIdx;
 	hddTdlsPeer_t *curr_peer;
 	uint32_t reason;
@@ -2978,7 +2978,7 @@ hdd_roam_tdls_status_update_handler(hdd_adapter_t *pAdapter,
 							 peerMac,
 							 &pRoamInfo->
 							 peerMac);
-					status = CDF_STATUS_SUCCESS;
+					status = QDF_STATUS_SUCCESS;
 					break;
 				}
 			}
@@ -2991,7 +2991,7 @@ hdd_roam_tdls_status_update_handler(hdd_adapter_t *pAdapter,
 							     staId)) {
 					hddLog(LOGE,
 						"wlan_hdd_tdls_set_sta_id() failed");
-					return CDF_STATUS_E_FAILURE;
+					return QDF_STATUS_E_FAILURE;
 				}
 
 				(WLAN_HDD_GET_CTX(pAdapter))->
@@ -3008,7 +3008,7 @@ hdd_roam_tdls_status_update_handler(hdd_adapter_t *pAdapter,
 							    pRoamInfo->
 							    ucastSig);
 			} else {
-				status = CDF_STATUS_E_FAILURE;
+				status = QDF_STATUS_E_FAILURE;
 				hddLog(LOGE,
 					FL("no available slot in conn_info. staId %d cannot be stored"),
 					pRoamInfo->staId);
@@ -3078,7 +3078,7 @@ hdd_roam_tdls_status_update_handler(hdd_adapter_t *pAdapter,
 					     tdlsConnInfo[staIdx].
 					     peerMac,
 					     CDF_MAC_ADDR_SIZE);
-				status = CDF_STATUS_SUCCESS;
+				status = QDF_STATUS_SUCCESS;
 				break;
 			}
 		}
@@ -3096,7 +3096,7 @@ hdd_roam_tdls_status_update_handler(hdd_adapter_t *pAdapter,
 						pRoamInfo->peerMac.bytes, true);
 		wlan_hdd_tdls_indicate_teardown(pAdapter, curr_peer,
 						pRoamInfo->reasonCode);
-		status = CDF_STATUS_SUCCESS;
+		status = QDF_STATUS_SUCCESS;
 		break;
 	}
 	case eCSR_ROAM_RESULT_DELETE_ALL_TDLS_PEER_IND:
@@ -3156,7 +3156,7 @@ hdd_roam_tdls_status_update_handler(hdd_adapter_t *pAdapter,
 					sme_update_tdls_peer_state(
 						pHddCtx->hHal,
 						&smeTdlsPeerStateParams);
-				if (CDF_STATUS_SUCCESS != status) {
+				if (QDF_STATUS_SUCCESS != status) {
 					hddLog(LOGE,
 						  FL("sme_update_tdls_peer_state failed for "
 						  MAC_ADDRESS_STR),
@@ -3176,7 +3176,7 @@ hdd_roam_tdls_status_update_handler(hdd_adapter_t *pAdapter,
 				pHddCtx->tdlsConnInfo[staIdx].
 				sessionId = 255;
 
-				status = CDF_STATUS_SUCCESS;
+				status = QDF_STATUS_SUCCESS;
 			}
 		}
 		break;
@@ -3190,7 +3190,7 @@ hdd_roam_tdls_status_update_handler(hdd_adapter_t *pAdapter,
 				FL("concurrency detected. ignore SHOULD_DISCOVER concurrency_mode: 0x%x, active_sessions: %d"),
 				 pHddCtx->concurrency_mode,
 				 pHddCtx->no_of_active_sessions[CDF_STA_MODE]);
-			status = CDF_STATUS_E_FAILURE;
+			status = QDF_STATUS_E_FAILURE;
 			break;
 		}
 
@@ -3199,7 +3199,7 @@ hdd_roam_tdls_status_update_handler(hdd_adapter_t *pAdapter,
 					       pRoamInfo->peerMac.bytes);
 		if (!curr_peer) {
 			hddLog(LOGE, FL("curr_peer is null"));
-			status = CDF_STATUS_E_FAILURE;
+			status = QDF_STATUS_E_FAILURE;
 		} else {
 			if (eTDLS_LINK_CONNECTED ==
 			    curr_peer->link_status) {
@@ -3218,7 +3218,7 @@ hdd_roam_tdls_status_update_handler(hdd_adapter_t *pAdapter,
 					hddLog(LOG2,
 						FL
 						("TDLS ExternalControl enabled but curr_peer is not forced, ignore SHOULD_DISCOVER"));
-					status = CDF_STATUS_SUCCESS;
+					status = QDF_STATUS_SUCCESS;
 					break;
 				} else {
 					hddLog(LOG2,
@@ -3232,7 +3232,7 @@ hdd_roam_tdls_status_update_handler(hdd_adapter_t *pAdapter,
 				wlan_hdd_tdls_pre_setup_init_work
 					(pHddTdlsCtx, curr_peer);
 			}
-			status = CDF_STATUS_SUCCESS;
+			status = QDF_STATUS_SUCCESS;
 		}
 		break;
 	}
@@ -3244,7 +3244,7 @@ hdd_roam_tdls_status_update_handler(hdd_adapter_t *pAdapter,
 						pRoamInfo->peerMac.bytes, true);
 		if (!curr_peer) {
 			hddLog(LOGE, FL("curr_peer is null"));
-			status = CDF_STATUS_E_FAILURE;
+			status = QDF_STATUS_E_FAILURE;
 		} else {
 			if (eTDLS_LINK_CONNECTED ==
 			    curr_peer->link_status) {
@@ -3281,7 +3281,7 @@ hdd_roam_tdls_status_update_handler(hdd_adapter_t *pAdapter,
 					  ("TDLS link is not connected, ignore SHOULD_TEARDOWN, reason: %d"),
 					  pRoamInfo->reasonCode);
 			}
-			status = CDF_STATUS_SUCCESS;
+			status = QDF_STATUS_SUCCESS;
 		}
 		break;
 	}
@@ -3293,7 +3293,7 @@ hdd_roam_tdls_status_update_handler(hdd_adapter_t *pAdapter,
 						pRoamInfo->peerMac.bytes, true);
 		if (!curr_peer) {
 			hddLog(LOGE, FL("curr_peer is null"));
-			status = CDF_STATUS_E_FAILURE;
+			status = QDF_STATUS_E_FAILURE;
 		} else {
 			if (eTDLS_LINK_CONNECTED ==
 			    curr_peer->link_status) {
@@ -3329,7 +3329,7 @@ hdd_roam_tdls_status_update_handler(hdd_adapter_t *pAdapter,
 					  ("TDLS link is not connected, ignore SHOULD_PEER_DISCONNECTED, reason: %d"),
 					  pRoamInfo->reasonCode);
 			}
-			status = CDF_STATUS_SUCCESS;
+			status = QDF_STATUS_SUCCESS;
 		}
 		break;
 	}
@@ -3835,17 +3835,17 @@ static inline bool hdd_is_8021x_sha256_auth_type(hdd_station_ctx_t *pHddStaCtx)
  * @roamStatus: roam status
  * @roamResult: roam result
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS
+QDF_STATUS
 hdd_sme_roam_callback(void *pContext, tCsrRoamInfo *pRoamInfo, uint32_t roamId,
 		      eRoamCmdStatus roamStatus, eCsrRoamResult roamResult)
 {
-	CDF_STATUS cdf_ret_status = CDF_STATUS_SUCCESS;
+	QDF_STATUS cdf_ret_status = QDF_STATUS_SUCCESS;
 	hdd_adapter_t *pAdapter = (hdd_adapter_t *) pContext;
 	hdd_wext_state_t *pWextState = NULL;
 	hdd_station_ctx_t *pHddStaCtx = NULL;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	hdd_context_t *pHddCtx = NULL;
 
 	hddLog(LOG2,
@@ -3855,7 +3855,7 @@ hdd_sme_roam_callback(void *pContext, tCsrRoamInfo *pRoamInfo, uint32_t roamId,
 	/* Sanity check */
 	if ((NULL == pAdapter) || (WLAN_HDD_ADAPTER_MAGIC != pAdapter->magic)) {
 		hddLog(LOGP, "invalid adapter or adapter has invalid magic");
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	pWextState = WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter);
@@ -3916,8 +3916,8 @@ hdd_sme_roam_callback(void *pContext, tCsrRoamInfo *pRoamInfo, uint32_t roamId,
 				WLAN_CONTROL_PATH);
 		status = hdd_roam_deregister_sta(pAdapter,
 					pHddStaCtx->conn_info.staId[0]);
-		if (!CDF_IS_STATUS_SUCCESS(status))
-			cdf_ret_status = CDF_STATUS_E_FAILURE;
+		if (!QDF_IS_STATUS_SUCCESS(status))
+			cdf_ret_status = QDF_STATUS_E_FAILURE;
 		pHddStaCtx->ft_carrier_on = true;
 		pHddStaCtx->hdd_ReassocScenario = true;
 		hddLog(LOG1,
@@ -4075,39 +4075,39 @@ hdd_sme_roam_callback(void *pContext, tCsrRoamInfo *pRoamInfo, uint32_t roamId,
 #ifdef FEATURE_WLAN_LFR_METRICS
 	case eCSR_ROAM_PREAUTH_INIT_NOTIFY:
 		/* This event is to notify pre-auth initiation */
-		if (CDF_STATUS_SUCCESS !=
+		if (QDF_STATUS_SUCCESS !=
 		    wlan_hdd_cfg80211_roam_metrics_preauth(pAdapter,
 							   pRoamInfo)) {
-			cdf_ret_status = CDF_STATUS_E_FAILURE;
+			cdf_ret_status = QDF_STATUS_E_FAILURE;
 		}
 		break;
 	case eCSR_ROAM_PREAUTH_STATUS_SUCCESS:
 		/*
 		 * This event will notify pre-auth completion in case of success
 		 */
-		if (CDF_STATUS_SUCCESS !=
+		if (QDF_STATUS_SUCCESS !=
 		    wlan_hdd_cfg80211_roam_metrics_preauth_status(pAdapter,
 							 pRoamInfo, 1)) {
-			cdf_ret_status = CDF_STATUS_E_FAILURE;
+			cdf_ret_status = QDF_STATUS_E_FAILURE;
 		}
 		break;
 	case eCSR_ROAM_PREAUTH_STATUS_FAILURE:
 		/*
 		 * This event will notify pre-auth completion incase of failure.
 		 */
-		if (CDF_STATUS_SUCCESS !=
+		if (QDF_STATUS_SUCCESS !=
 		    wlan_hdd_cfg80211_roam_metrics_preauth_status(pAdapter,
 								pRoamInfo, 0)) {
-			cdf_ret_status = CDF_STATUS_E_FAILURE;
+			cdf_ret_status = QDF_STATUS_E_FAILURE;
 		}
 		break;
 	case eCSR_ROAM_HANDOVER_SUCCESS:
 		/* This event is to notify handover success.
 		   It will be only invoked on success */
-		if (CDF_STATUS_SUCCESS !=
+		if (QDF_STATUS_SUCCESS !=
 		    wlan_hdd_cfg80211_roam_metrics_handover(pAdapter,
 							    pRoamInfo)) {
-			cdf_ret_status = CDF_STATUS_E_FAILURE;
+			cdf_ret_status = QDF_STATUS_E_FAILURE;
 		}
 		break;
 #endif
@@ -4321,7 +4321,7 @@ static int32_t hdd_process_genie(hdd_adapter_t *pAdapter,
 				 uint16_t gen_ie_len, uint8_t *gen_ie)
 {
 	tHalHandle halHandle = WLAN_HDD_GET_HAL_CTX(pAdapter);
-	CDF_STATUS result;
+	QDF_STATUS result;
 	tDot11fIERSN dot11RSNIE;
 	tDot11fIEWPA dot11WPAIE;
 	uint32_t i;
@@ -4723,14 +4723,14 @@ static int __iw_set_essid(struct net_device *dev,
 	if (hdd_conn_get_connected_bss_type(pHddStaCtx, &connectedBssType) ||
 	    (eMib_dot11DesiredBssType_independent ==
 	     pHddStaCtx->conn_info.connDot11DesiredBssType)) {
-		CDF_STATUS cdf_status;
+		QDF_STATUS qdf_status;
 
 		/* Need to issue a disconnect to CSR. */
 		INIT_COMPLETION(pAdapter->disconnect_comp_var);
-		cdf_status = sme_roam_disconnect(hHal, pAdapter->sessionId,
+		qdf_status = sme_roam_disconnect(hHal, pAdapter->sessionId,
 					 eCSR_DISCONNECT_REASON_UNSPECIFIED);
 
-		if (CDF_STATUS_SUCCESS == cdf_status) {
+		if (QDF_STATUS_SUCCESS == qdf_status) {
 			rc = wait_for_completion_timeout(&pAdapter->
 						 disconnect_comp_var,
 						 msecs_to_jiffies
@@ -4751,7 +4751,7 @@ static int __iw_set_essid(struct net_device *dev,
 
 	status = hdd_wmm_get_uapsd_mask(pAdapter,
 					&pWextState->roamProfile.uapsd_mask);
-	if (CDF_STATUS_SUCCESS != status)
+	if (QDF_STATUS_SUCCESS != status)
 		pWextState->roamProfile.uapsd_mask = 0;
 
 	pWextState->roamProfile.SSIDs.numOfSSIDs = 1;

core/hdd/src/wlan_hdd_cfg80211.c

@@ -1529,7 +1529,7 @@ static int __wlan_hdd_cfg80211_do_acs(struct wiphy *wiphy,
 	status = cds_get_pcl(CDS_SAP_MODE,
 					sap_config->acs_cfg.pcl_channels,
 					&sap_config->acs_cfg.pcl_ch_count);
-	if (CDF_STATUS_SUCCESS != status)
+	if (QDF_STATUS_SUCCESS != status)
 		hddLog(LOGE, FL("Get PCL failed"));
 
 	wlan_hdd_set_acs_ch_range(sap_config, ht_enabled, vht_enabled);
@@ -1938,7 +1938,7 @@ __wlan_hdd_cfg80211_set_scanning_mac_oui(struct wiphy *wiphy,
 	tpSirScanMacOui pReqMsg = NULL;
 	hdd_context_t *pHddCtx = wiphy_priv(wiphy);
 	struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_SET_SCANNING_MAC_OUI_MAX + 1];
-	CDF_STATUS status;
+	QDF_STATUS status;
 	int ret;
 
 	ENTER();
@@ -1977,7 +1977,7 @@ __wlan_hdd_cfg80211_set_scanning_mac_oui(struct wiphy *wiphy,
 	hddLog(LOG1, FL("Oui (%02x:%02x:%02x)"), pReqMsg->oui[0],
 	       pReqMsg->oui[1], pReqMsg->oui[2]);
 	status = sme_set_scanning_mac_oui(pHddCtx->hHal, pReqMsg);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hddLog(CDF_TRACE_LEVEL_ERROR,
 		       FL("sme_set_scanning_mac_oui failed(err=%d)"), status);
 		goto fail;
@@ -2058,7 +2058,7 @@ __wlan_hdd_cfg80211_get_features(struct wiphy *wiphy,
 	struct sk_buff *skb = NULL;
 	uint32_t dbs_capability = 0;
 	bool one_by_one_dbs, two_by_two_dbs;
-	CDF_STATUS ret = CDF_STATUS_E_FAILURE;
+	QDF_STATUS ret = QDF_STATUS_E_FAILURE;
 	int ret_val;
 
 	uint8_t feature_flags[(NUM_QCA_WLAN_VENDOR_FEATURES + 7) / 8] = {0};
@@ -2097,7 +2097,7 @@ __wlan_hdd_cfg80211_get_features(struct wiphy *wiphy,
 		goto nla_put_failure;
 
 	ret = wma_get_dbs_hw_modes(&one_by_one_dbs, &two_by_two_dbs);
-	if (CDF_STATUS_SUCCESS == ret) {
+	if (QDF_STATUS_SUCCESS == ret) {
 		if (one_by_one_dbs)
 			dbs_capability = DRV_DBS_CAPABILITY_1X1;
 
@@ -2483,13 +2483,13 @@ static bool wlan_hdd_check_dfs_channel_for_adapter(hdd_context_t *hdd_ctx,
 	hdd_adapter_list_node_t *adapter_node = NULL, *next = NULL;
 	hdd_ap_ctx_t *ap_ctx;
 	hdd_station_ctx_t *sta_ctx;
-	CDF_STATUS cdf_status;
+	QDF_STATUS qdf_status;
 
-	cdf_status = hdd_get_front_adapter(hdd_ctx,
+	qdf_status = hdd_get_front_adapter(hdd_ctx,
 					   &adapter_node);
 
 	while ((NULL != adapter_node) &&
-	       (CDF_STATUS_SUCCESS == cdf_status)) {
+	       (QDF_STATUS_SUCCESS == qdf_status)) {
 		adapter = adapter_node->pAdapter;
 
 		if ((device_mode == adapter->device_mode) &&
@@ -2532,7 +2532,7 @@ static bool wlan_hdd_check_dfs_channel_for_adapter(hdd_context_t *hdd_ctx,
 			}
 		}
 
-		cdf_status = hdd_get_next_adapter(hdd_ctx,
+		qdf_status = hdd_get_next_adapter(hdd_ctx,
 						  adapter_node,
 						  &next);
 		adapter_node = next;
@@ -2559,7 +2559,7 @@ int wlan_hdd_disable_dfs_chan_scan(hdd_context_t *hdd_ctx,
 				   uint32_t no_dfs_flag)
 {
 	tHalHandle h_hal = WLAN_HDD_GET_HAL_CTX(adapter);
-	CDF_STATUS status;
+	QDF_STATUS status;
 	int ret_val = -EPERM;
 
 	if (no_dfs_flag == hdd_ctx->config->enableDFSChnlScan) {
@@ -2588,7 +2588,7 @@ int wlan_hdd_disable_dfs_chan_scan(hdd_context_t *hdd_ctx,
 		status = sme_handle_dfs_chan_scan(
 			h_hal, hdd_ctx->config->enableDFSChnlScan);
 
-		if (CDF_STATUS_SUCCESS == status) {
+		if (QDF_STATUS_SUCCESS == status) {
 			ret_val = 0;
 
 			/*
@@ -2598,7 +2598,7 @@ int wlan_hdd_disable_dfs_chan_scan(hdd_context_t *hdd_ctx,
 			 * all sessions
 			 */
 			status = sme_scan_flush_result(h_hal);
-			if (CDF_STATUS_SUCCESS != status)
+			if (QDF_STATUS_SUCCESS != status)
 				ret_val = -EPERM;
 		}
 
@@ -3135,7 +3135,7 @@ __wlan_hdd_cfg80211_wifi_configuration_set(struct wiphy *wiphy,
 	u32 modulated_dtim;
 	u16 stats_avg_factor;
 	u32 guard_time;
-	CDF_STATUS status;
+	QDF_STATUS status;
 
 	if (CDF_GLOBAL_FTM_MODE == hdd_get_conparam()) {
 		hdd_err("Command not allowed in FTM mode");
@@ -3163,7 +3163,7 @@ __wlan_hdd_cfg80211_wifi_configuration_set(struct wiphy *wiphy,
 						      adapter->sessionId,
 						      modulated_dtim);
 
-		if (CDF_STATUS_SUCCESS != status)
+		if (QDF_STATUS_SUCCESS != status)
 			ret_val = -EPERM;
 	}
 
@@ -3174,7 +3174,7 @@ __wlan_hdd_cfg80211_wifi_configuration_set(struct wiphy *wiphy,
 							adapter->sessionId,
 							stats_avg_factor);
 
-		if (CDF_STATUS_SUCCESS != status)
+		if (QDF_STATUS_SUCCESS != status)
 			ret_val = -EPERM;
 	}
 
@@ -3186,7 +3186,7 @@ __wlan_hdd_cfg80211_wifi_configuration_set(struct wiphy *wiphy,
 						  adapter->sessionId,
 						  guard_time);
 
-		if (CDF_STATUS_SUCCESS != status)
+		if (QDF_STATUS_SUCCESS != status)
 			ret_val = -EPERM;
 	}
 
@@ -3251,7 +3251,7 @@ static int __wlan_hdd_cfg80211_wifi_logger_start(struct wiphy *wiphy,
 		const void *data,
 		int data_len)
 {
-	CDF_STATUS status;
+	QDF_STATUS status;
 	hdd_context_t *hdd_ctx = wiphy_priv(wiphy);
 	struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_WIFI_LOGGER_START_MAX + 1];
 	struct sir_wifi_start_log start_log;
@@ -3313,7 +3313,7 @@ static int __wlan_hdd_cfg80211_wifi_logger_start(struct wiphy *wiphy,
 	}
 
 	status = sme_wifi_start_logger(hdd_ctx->hHal, start_log);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hddLog(LOGE, FL("sme_wifi_start_logger failed(err=%d)"),
 				status);
 		return -EINVAL;
@@ -3374,7 +3374,7 @@ static int __wlan_hdd_cfg80211_wifi_logger_get_ring_data(struct wiphy *wiphy,
 		const void *data,
 		int data_len)
 {
-	CDF_STATUS status;
+	QDF_STATUS status;
 	uint32_t ring_id;
 	hdd_context_t *hdd_ctx = wiphy_priv(wiphy);
 	struct nlattr *tb
@@ -3417,7 +3417,7 @@ static int __wlan_hdd_cfg80211_wifi_logger_get_ring_data(struct wiphy *wiphy,
 	status = cds_flush_logs(WLAN_LOG_TYPE_NON_FATAL,
 			WLAN_LOG_INDICATOR_FRAMEWORK,
 			WLAN_LOG_REASON_CODE_UNUSED);
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		hddLog(LOGE, FL("Failed to trigger bug report"));
 		return -EINVAL;
 	}
@@ -3553,7 +3553,7 @@ wlan_hdd_add_tx_ptrn(hdd_adapter_t *adapter, hdd_context_t *hdd_ctx,
 			struct nlattr **tb)
 {
 	struct sSirAddPeriodicTxPtrn *add_req;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	uint32_t request_id, ret, len;
 	uint8_t pattern_id = 0;
 	struct cdf_mac_addr dst_addr;
@@ -3661,7 +3661,7 @@ wlan_hdd_add_tx_ptrn(hdd_adapter_t *adapter, hdd_context_t *hdd_ctx,
 	hddLog(LOG1, FL("pattern id: %d"), add_req->ucPtrnId);
 
 	status = sme_add_periodic_tx_ptrn(hdd_ctx->hHal, add_req);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hddLog(LOGE,
 			FL("sme_add_periodic_tx_ptrn failed (err=%d)"), status);
 		goto fail;
@@ -3691,7 +3691,7 @@ wlan_hdd_del_tx_ptrn(hdd_adapter_t *adapter, hdd_context_t *hdd_ctx,
 			struct nlattr **tb)
 {
 	struct sSirDelPeriodicTxPtrn *del_req;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	uint32_t request_id, ret;
 	uint8_t pattern_id = 0;
 
@@ -3725,7 +3725,7 @@ wlan_hdd_del_tx_ptrn(hdd_adapter_t *adapter, hdd_context_t *hdd_ctx,
 			 request_id, del_req->ucPtrnId);
 
 	status = sme_del_periodic_tx_ptrn(hdd_ctx->hHal, del_req);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hddLog(LOGE,
 			FL("sme_del_periodic_tx_ptrn failed (err=%d)"), status);
 		goto fail;
@@ -3878,7 +3878,7 @@ __wlan_hdd_cfg80211_monitor_rssi(struct wiphy *wiphy,
 	hdd_context_t *hdd_ctx = wiphy_priv(wiphy);
 	struct nlattr *tb[PARAM_MAX + 1];
 	struct rssi_monitor_req req;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	int ret;
 	uint32_t control;
 	static const struct nla_policy policy[PARAM_MAX + 1] = {
@@ -3951,7 +3951,7 @@ __wlan_hdd_cfg80211_monitor_rssi(struct wiphy *wiphy,
 			req.request_id, req.session_id, req.control);
 
 	status = sme_set_rssi_monitoring(hdd_ctx->hHal, &req);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hddLog(LOGE,
 			FL("sme_set_rssi_monitoring failed(err=%d)"), status);
 		return -EINVAL;
@@ -4069,7 +4069,7 @@ static int __wlan_hdd_cfg80211_get_preferred_freq_list(struct wiphy *wiphy,
 {
 	hdd_context_t *hdd_ctx = wiphy_priv(wiphy);
 	int i, ret = 0;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	uint8_t pcl[MAX_NUM_CHAN];
 	uint32_t pcl_len = 0;
 	uint32_t freq_list[MAX_NUM_CHAN];
@@ -4103,7 +4103,7 @@ static int __wlan_hdd_cfg80211_get_preferred_freq_list(struct wiphy *wiphy,
 	hdd_debug("Userspace requested pref freq list");
 
 	status = cds_get_pcl(intf_mode, pcl, &pcl_len);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		hdd_err("Get pcl failed");
 		return -EINVAL;
 	}
@@ -4234,19 +4234,19 @@ static int __wlan_hdd_cfg80211_set_probable_oper_channel(struct wiphy *wiphy,
 
 	if (hdd_ctx->config->policy_manager_enabled) {
 		ret = cdf_reset_connection_update();
-		if (!CDF_IS_STATUS_SUCCESS(ret))
+		if (!QDF_IS_STATUS_SUCCESS(ret))
 			hdd_err("clearing event failed");
 
 		ret = cds_current_connections_update(adapter->sessionId,
 					channel_hint,
 					CDS_UPDATE_REASON_SET_OPER_CHAN);
-		if (CDF_STATUS_E_FAILURE == ret) {
+		if (QDF_STATUS_E_FAILURE == ret) {
 			/* return in the failure case */
 			hdd_err("ERROR: connections update failed!!");
 			return -EINVAL;
 		}
 
-		if (CDF_STATUS_SUCCESS == ret) {
+		if (QDF_STATUS_SUCCESS == ret) {
 			/*
 			 * Success is the only case for which we expect hw mode
 			 * change to take place, hence we need to wait.
@@ -4254,7 +4254,7 @@ static int __wlan_hdd_cfg80211_set_probable_oper_channel(struct wiphy *wiphy,
 			 * through
 			 */
 			ret = cdf_wait_for_connection_update();
-			if (!CDF_IS_STATUS_SUCCESS(ret)) {
+			if (!QDF_IS_STATUS_SUCCESS(ret)) {
 				hdd_err("ERROR: cdf wait for event failed!!");
 				return -EINVAL;
 			}
@@ -4507,7 +4507,7 @@ static int __wlan_hdd_cfg80211_set_ota_test(struct wiphy *wiphy,
 	hdd_context_t *hdd_ctx  = wiphy_priv(wiphy);
 	struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_OTA_TEST_MAX + 1];
 	uint8_t ota_enable = 0;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	uint32_t current_roam_state;
 
 	if (CDF_GLOBAL_FTM_MODE == hdd_get_conparam()) {
@@ -4543,14 +4543,14 @@ static int __wlan_hdd_cfg80211_set_ota_test(struct wiphy *wiphy,
 			sme_get_current_roam_state(hal, adapter->sessionId);
 	status = sme_stop_roaming(hal, adapter->sessionId,
 					eCsrHddIssued);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		hdd_err("Enable/Disable roaming failed");
 		return -EINVAL;
 	}
 
 	status = sme_ps_enable_disable(hal, adapter->sessionId,
 					SME_PS_DISABLE);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		hdd_err("Enable/Disable power save failed");
 		/* restore previous roaming setting */
 		if (current_roam_state == eCSR_ROAMING_STATE_JOINING ||
@@ -4562,7 +4562,7 @@ static int __wlan_hdd_cfg80211_set_ota_test(struct wiphy *wiphy,
 			status = sme_stop_roaming(hal, adapter->sessionId,
 						eCsrHddIssued);
 
-		if (status != CDF_STATUS_SUCCESS)
+		if (status != QDF_STATUS_SUCCESS)
 			hdd_err("Restoring roaming state failed");
 
 		return -EINVAL;
@@ -5743,7 +5743,7 @@ uint8_t *wlan_hdd_cfg80211_get_ie_ptr(const uint8_t *ies_ptr, int length,
  * This function validates whether given channel is part of valid
  * channel list.
  */
-CDF_STATUS wlan_hdd_validate_operation_channel(hdd_adapter_t *pAdapter,
+QDF_STATUS wlan_hdd_validate_operation_channel(hdd_adapter_t *pAdapter,
 					       int channel)
 {
 
@@ -5767,7 +5767,7 @@ CDF_STATUS wlan_hdd_validate_operation_channel(hdd_adapter_t *pAdapter,
 		if (fValidChannel != true) {
 			hddLog(CDF_TRACE_LEVEL_ERROR,
 			       "%s: Invalid Channel [%d]", __func__, channel);
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 	} else {
 		if (0 != sme_cfg_get_str(hHal, WNI_CFG_VALID_CHANNEL_LIST,
@@ -5775,7 +5775,7 @@ CDF_STATUS wlan_hdd_validate_operation_channel(hdd_adapter_t *pAdapter,
 			hddLog(CDF_TRACE_LEVEL_ERROR,
 			       "%s: failed to get valid channel list",
 			       __func__);
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 		for (indx = 0; indx < num_ch; indx++) {
 			if (channel == valid_ch[indx]) {
@@ -5786,10 +5786,10 @@ CDF_STATUS wlan_hdd_validate_operation_channel(hdd_adapter_t *pAdapter,
 		if (indx >= num_ch) {
 			hddLog(CDF_TRACE_LEVEL_ERROR,
 			       "%s: Invalid Channel [%d]", __func__, channel);
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 	}
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 
 }
 
@@ -5836,7 +5836,7 @@ static void wlan_hdd_set_dhcp_server_offload(hdd_adapter_t *pHostapdAdapter)
 		temp = srv_ip[num];
 		pDhcpSrvInfo->dhcpSrvIP |= (temp << (8 * num));
 	}
-	if (CDF_STATUS_SUCCESS !=
+	if (QDF_STATUS_SUCCESS !=
 	    sme_set_dhcp_srv_offload(pHddCtx->hHal, pDhcpSrvInfo)) {
 		hddLog(CDF_TRACE_LEVEL_ERROR,
 		       "%s: sme_setDHCPSrvOffload fail!", __func__);
@@ -5857,7 +5857,7 @@ static int __wlan_hdd_cfg80211_change_bss(struct wiphy *wiphy,
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
 	int ret = 0;
-	CDF_STATUS cdf_ret_status;
+	QDF_STATUS cdf_ret_status;
 
 	ENTER();
 
@@ -5894,7 +5894,7 @@ static int __wlan_hdd_cfg80211_change_bss(struct wiphy *wiphy,
 							      pAdapter->sessionCtx.
 							      ap.
 							      apDisableIntraBssFwd);
-		if (!CDF_IS_STATUS_SUCCESS(cdf_ret_status)) {
+		if (!QDF_IS_STATUS_SUCCESS(cdf_ret_status)) {
 			ret = -EINVAL;
 		}
 	}
@@ -5929,7 +5929,7 @@ static int wlan_hdd_change_iface_to_sta_mode(struct net_device *ndev,
 	hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
 	hdd_wext_state_t *wext;
 	struct wireless_dev *wdev;
-	CDF_STATUS status;
+	QDF_STATUS status;
 
 	ENTER();
 
@@ -6011,7 +6011,7 @@ static int __wlan_hdd_cfg80211_change_iface(struct wiphy *wiphy,
 	struct hdd_config *pConfig = NULL;
 	eMib_dot11DesiredBssType connectedBssType;
 	unsigned long rc;
-	CDF_STATUS vstatus;
+	QDF_STATUS vstatus;
 	int status;
 
 	ENTER();
@@ -6063,7 +6063,7 @@ static int __wlan_hdd_cfg80211_change_iface(struct wiphy *wiphy,
 		case NL80211_IFTYPE_STATION:
 		case NL80211_IFTYPE_P2P_CLIENT:
 			vstatus = wlan_hdd_change_iface_to_sta_mode(ndev, type);
-			if (vstatus != CDF_STATUS_SUCCESS)
+			if (vstatus != QDF_STATUS_SUCCESS)
 				return -EINVAL;
 
 			hdd_register_tx_flow_control(pAdapter,
@@ -6129,7 +6129,7 @@ static int __wlan_hdd_cfg80211_change_iface(struct wiphy *wiphy,
 			hdd_set_ap_ops(pAdapter->dev);
 
 			vstatus = hdd_init_ap_mode(pAdapter);
-			if (vstatus != CDF_STATUS_SUCCESS) {
+			if (vstatus != QDF_STATUS_SUCCESS) {
 				hddLog(LOGP,
 				       FL
 					       ("Error initializing the ap mode"));
@@ -6163,7 +6163,7 @@ static int __wlan_hdd_cfg80211_change_iface(struct wiphy *wiphy,
 		case NL80211_IFTYPE_P2P_CLIENT:
 		case NL80211_IFTYPE_ADHOC:
 			status = wlan_hdd_change_iface_to_sta_mode(ndev, type);
-			if (status != CDF_STATUS_SUCCESS)
+			if (status != QDF_STATUS_SUCCESS)
 				return status;
 
 			if ((NL80211_IFTYPE_P2P_CLIENT == type) ||
@@ -6208,7 +6208,7 @@ static int __wlan_hdd_cfg80211_change_iface(struct wiphy *wiphy,
 		    || (eCSR_BSS_TYPE_START_IBSS == LastBSSType)) {
 			/* Need to issue a disconnect to CSR. */
 			INIT_COMPLETION(pAdapter->disconnect_comp_var);
-			if (CDF_STATUS_SUCCESS ==
+			if (QDF_STATUS_SUCCESS ==
 			    sme_roam_disconnect(WLAN_HDD_GET_HAL_CTX(pAdapter),
 						pAdapter->sessionId,
 						eCSR_DISCONNECT_REASON_UNSPECIFIED)) {
@@ -6297,7 +6297,7 @@ static int __wlan_hdd_change_station(struct wiphy *wiphy,
 				   struct station_parameters *params)
 #endif
 {
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	hdd_context_t *pHddCtx;
 	hdd_station_ctx_t *pHddStaCtx;
@@ -6337,7 +6337,7 @@ static int __wlan_hdd_change_station(struct wiphy *wiphy,
 							    &STAMacAddress,
 							    ol_txrx_peer_state_auth);
 
-			if (status != CDF_STATUS_SUCCESS) {
+			if (status != QDF_STATUS_SUCCESS) {
 				hddLog(CDF_TRACE_LEVEL_INFO,
 				       FL
 					       ("Not able to change TL state to AUTHENTICATED"));
@@ -6514,7 +6514,7 @@ static int __wlan_hdd_change_station(struct wiphy *wiphy,
 							     &StaParams,
 							     isBufSta,
 							     isOffChannelSupported);
-			if (CDF_STATUS_SUCCESS != status) {
+			if (QDF_STATUS_SUCCESS != status) {
 				hddLog(CDF_TRACE_LEVEL_ERROR,
 				       FL
 					       ("wlan_hdd_tdls_set_peer_caps failed!"));
@@ -6524,7 +6524,7 @@ static int __wlan_hdd_change_station(struct wiphy *wiphy,
 			status =
 				wlan_hdd_tdls_add_station(wiphy, dev, mac, 1,
 							  &StaParams);
-			if (CDF_STATUS_SUCCESS != status) {
+			if (QDF_STATUS_SUCCESS != status) {
 				hddLog(CDF_TRACE_LEVEL_ERROR,
 				       FL("wlan_hdd_tdls_add_station failed!"));
 				return -EINVAL;
@@ -6588,7 +6588,7 @@ static int __wlan_hdd_cfg80211_add_key(struct wiphy *wiphy,
 	v_CONTEXT_t p_cds_context = (WLAN_HDD_GET_CTX(pAdapter))->pcds_context;
 #endif
 	hdd_hostapd_state_t *pHostapdState;
-	CDF_STATUS cdf_ret_status;
+	QDF_STATUS cdf_ret_status;
 	hdd_context_t *pHddCtx;
 	hdd_ap_ctx_t *ap_ctx = WLAN_HDD_GET_AP_CTX_PTR(pAdapter);
 
@@ -6771,7 +6771,7 @@ static int __wlan_hdd_cfg80211_add_key(struct wiphy *wiphy,
 #else
 			status = wlansap_set_key_sta(p_cds_context, &setKey);
 #endif
-			if (status != CDF_STATUS_SUCCESS) {
+			if (status != QDF_STATUS_SUCCESS) {
 				CDF_TRACE(CDF_MODULE_ID_HDD,
 					  CDF_TRACE_LEVEL_ERROR,
 					  "[%4d] wlansap_set_key_sta returned ERROR status= %d",
@@ -6828,11 +6828,11 @@ static int __wlan_hdd_cfg80211_add_key(struct wiphy *wiphy,
 		   request */
 		cdf_ret_status = sme_ft_update_key(WLAN_HDD_GET_HAL_CTX(pAdapter),
 						   pAdapter->sessionId, &setKey);
-		if (cdf_ret_status == CDF_STATUS_FT_PREAUTH_KEY_SUCCESS) {
+		if (cdf_ret_status == QDF_STATUS_FT_PREAUTH_KEY_SUCCESS) {
 			hddLog(CDF_TRACE_LEVEL_INFO_MED,
 			       "%s: Update PreAuth Key success", __func__);
 			return 0;
-		} else if (cdf_ret_status == CDF_STATUS_FT_PREAUTH_KEY_FAILED) {
+		} else if (cdf_ret_status == QDF_STATUS_FT_PREAUTH_KEY_FAILED) {
 			hddLog(CDF_TRACE_LEVEL_ERROR,
 			       "%s: Update PreAuth Key failed", __func__);
 			return -EINVAL;
@@ -7486,7 +7486,7 @@ int wlan_hdd_cfg80211_update_bss(struct wiphy *wiphy,
 {
 	tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(pAdapter);
 	tCsrScanResultInfo *pScanResult;
-	CDF_STATUS status = 0;
+	QDF_STATUS status = 0;
 	tScanResultHandle pResult;
 	struct cfg80211_bss *bss_status = NULL;
 	hdd_context_t *pHddCtx;
@@ -7615,7 +7615,7 @@ int wlan_hdd_cfg80211_pmksa_candidate_notify(hdd_adapter_t *pAdapter,
  * Return: CDF status
  */
 #define MAX_LFR_METRICS_EVENT_LENGTH 100
-CDF_STATUS wlan_hdd_cfg80211_roam_metrics_preauth(hdd_adapter_t *pAdapter,
+QDF_STATUS wlan_hdd_cfg80211_roam_metrics_preauth(hdd_adapter_t *pAdapter,
 						  tCsrRoamInfo *pRoamInfo)
 {
 	unsigned char metrics_notification[MAX_LFR_METRICS_EVENT_LENGTH + 1];
@@ -7625,7 +7625,7 @@ CDF_STATUS wlan_hdd_cfg80211_roam_metrics_preauth(hdd_adapter_t *pAdapter,
 
 	if (NULL == pAdapter) {
 		hddLog(LOGE, FL("pAdapter is NULL!"));
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	/* create the event */
@@ -7643,7 +7643,7 @@ CDF_STATUS wlan_hdd_cfg80211_roam_metrics_preauth(hdd_adapter_t *pAdapter,
 
 	EXIT();
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -7656,7 +7656,7 @@ CDF_STATUS wlan_hdd_cfg80211_roam_metrics_preauth(hdd_adapter_t *pAdapter,
  *
  * Return: CDF status
  */
-CDF_STATUS
+QDF_STATUS
 wlan_hdd_cfg80211_roam_metrics_preauth_status(hdd_adapter_t *pAdapter,
 					      tCsrRoamInfo *pRoamInfo,
 					      bool preauth_status)
@@ -7668,7 +7668,7 @@ wlan_hdd_cfg80211_roam_metrics_preauth_status(hdd_adapter_t *pAdapter,
 
 	if (NULL == pAdapter) {
 		hddLog(LOGE, FL("pAdapter is NULL!"));
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	/* create the event */
@@ -7694,7 +7694,7 @@ wlan_hdd_cfg80211_roam_metrics_preauth_status(hdd_adapter_t *pAdapter,
 
 	EXIT();
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -7706,7 +7706,7 @@ wlan_hdd_cfg80211_roam_metrics_preauth_status(hdd_adapter_t *pAdapter,
  *
  * Return: CDF status
  */
-CDF_STATUS wlan_hdd_cfg80211_roam_metrics_handover(hdd_adapter_t *pAdapter,
+QDF_STATUS wlan_hdd_cfg80211_roam_metrics_handover(hdd_adapter_t *pAdapter,
 						   tCsrRoamInfo *pRoamInfo)
 {
 	unsigned char metrics_notification[MAX_LFR_METRICS_EVENT_LENGTH + 1];
@@ -7716,7 +7716,7 @@ CDF_STATUS wlan_hdd_cfg80211_roam_metrics_handover(hdd_adapter_t *pAdapter,
 
 	if (NULL == pAdapter) {
 		hddLog(LOGE, FL("pAdapter is NULL!"));
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	/* create the event */
@@ -7735,7 +7735,7 @@ CDF_STATUS wlan_hdd_cfg80211_roam_metrics_handover(hdd_adapter_t *pAdapter,
 
 	EXIT();
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 #endif
 
@@ -7957,7 +7957,7 @@ int wlan_hdd_cfg80211_connect_start(hdd_adapter_t *pAdapter,
 			 */
 			status = hdd_set_ibss_power_save_params(pAdapter);
 
-			if (CDF_STATUS_SUCCESS != status) {
+			if (QDF_STATUS_SUCCESS != status) {
 				hddLog(LOGE,
 				       FL("Set IBSS Power Save Params Failed"));
 				return -EINVAL;
@@ -8034,7 +8034,7 @@ int wlan_hdd_cfg80211_connect_start(hdd_adapter_t *pAdapter,
 					  pAdapter->sessionId, pRoamProfile,
 					  &roamId);
 
-		if ((CDF_STATUS_SUCCESS != status) &&
+		if ((QDF_STATUS_SUCCESS != status) &&
 		    (WLAN_HDD_INFRA_STATION == pAdapter->device_mode ||
 		     WLAN_HDD_P2P_CLIENT == pAdapter->device_mode)) {
 			hddLog(LOGE,
@@ -8757,7 +8757,7 @@ static int wlan_hdd_try_disconnect(hdd_adapter_t *pAdapter)
 		 * ssid and the previous connect command in CSR. Else we might
 		 * hit some race conditions leading to SME and HDD out of sync.
 		 */
-		if (CDF_STATUS_CMD_NOT_QUEUED == status) {
+		if (QDF_STATUS_CMD_NOT_QUEUED == status) {
 			hdd_info("Already disconnected or connect was in sme/roam pending list and removed by disconnect");
 		} else if (0 != status) {
 			hdd_err("csrRoamDisconnect failure, returned %d",
@@ -8770,7 +8770,7 @@ static int wlan_hdd_try_disconnect(hdd_adapter_t *pAdapter)
 		rc = wait_for_completion_timeout(
 			&pAdapter->disconnect_comp_var,
 			msecs_to_jiffies(WLAN_WAIT_TIME_DISCONNECT));
-		if (!rc && (CDF_STATUS_CMD_NOT_QUEUED != status)) {
+		if (!rc && (QDF_STATUS_CMD_NOT_QUEUED != status)) {
 			hdd_err("Sme disconnect event timed out session Id %d staDebugState %d",
 				pAdapter->sessionId, pHddStaCtx->staDebugState);
 			result = -ETIMEDOUT;
@@ -8958,7 +8958,7 @@ int wlan_hdd_disconnect(hdd_adapter_t *pAdapter, u16 reason)
 	 * the previous connect command in CSR. Else we might hit some
 	 * race conditions leading to SME and HDD out of sync.
 	 */
-	if (CDF_STATUS_CMD_NOT_QUEUED == status) {
+	if (QDF_STATUS_CMD_NOT_QUEUED == status) {
 		hdd_info("Already disconnected or connect was in sme/roam pending list and removed by disconnect");
 	} else if (0 != status) {
 		hddLog(LOGE,
@@ -8972,7 +8972,7 @@ int wlan_hdd_disconnect(hdd_adapter_t *pAdapter, u16 reason)
 					 msecs_to_jiffies
 						 (WLAN_WAIT_TIME_DISCONNECT));
 
-	if (!rc && (CDF_STATUS_CMD_NOT_QUEUED != status)) {
+	if (!rc && (QDF_STATUS_CMD_NOT_QUEUED != status)) {
 		hddLog(LOGE,
 			FL("Failed to disconnect, timed out"));
 		result = -ETIMEDOUT;
@@ -9370,20 +9370,20 @@ static int __wlan_hdd_cfg80211_join_ibss(struct wiphy *wiphy,
 	}
 	if (pHddCtx->config->policy_manager_enabled) {
 		status = cdf_reset_connection_update();
-		if (!CDF_IS_STATUS_SUCCESS(status))
+		if (!QDF_IS_STATUS_SUCCESS(status))
 			hdd_err("ERR: clear event failed");
 
 		status = cds_current_connections_update(pAdapter->sessionId,
 						channelNum,
 						CDS_UPDATE_REASON_JOIN_IBSS);
-		if (CDF_STATUS_E_FAILURE == status) {
+		if (QDF_STATUS_E_FAILURE == status) {
 			hdd_err("ERROR: connections update failed!!");
 			return -EINVAL;
 		}
 
-		if (CDF_STATUS_SUCCESS == status) {
+		if (QDF_STATUS_SUCCESS == status) {
 			status = cdf_wait_for_connection_update();
-			if (!CDF_IS_STATUS_SUCCESS(status)) {
+			if (!QDF_IS_STATUS_SUCCESS(status)) {
 				hdd_err("ERROR: cdf wait for event failed!!");
 				return -EINVAL;
 			}
@@ -9409,7 +9409,7 @@ static int __wlan_hdd_cfg80211_join_ibss(struct wiphy *wiphy,
 	/* enable selected protection checks in IBSS mode */
 	pRoamProfile->cfg_protection = IBSS_CFG_PROTECTION_ENABLE_MASK;
 
-	if (CDF_STATUS_E_FAILURE == sme_cfg_set_int(pHddCtx->hHal,
+	if (QDF_STATUS_E_FAILURE == sme_cfg_set_int(pHddCtx->hHal,
 						    WNI_CFG_IBSS_ATIM_WIN_SIZE,
 						    pHddCtx->config->
 						    ibssATIMWinSize)) {
@@ -9420,7 +9420,7 @@ static int __wlan_hdd_cfg80211_join_ibss(struct wiphy *wiphy,
 	/* BSSID is provided by upper layers hence no need to AUTO generate */
 	if (NULL != params->bssid) {
 		if (sme_cfg_set_int(pHddCtx->hHal, WNI_CFG_IBSS_AUTO_BSSID, 0)
-				== CDF_STATUS_E_FAILURE) {
+				== QDF_STATUS_E_FAILURE) {
 			hddLog(LOGE,
 				FL("ccmCfgStInt failed for WNI_CFG_IBSS_AUTO_BSSID"));
 			return -EIO;
@@ -9428,7 +9428,7 @@ static int __wlan_hdd_cfg80211_join_ibss(struct wiphy *wiphy,
 		cdf_mem_copy(bssid.bytes, params->bssid, CDF_MAC_ADDR_SIZE);
 	} else if (pHddCtx->config->isCoalesingInIBSSAllowed == 0) {
 		if (sme_cfg_set_int(pHddCtx->hHal, WNI_CFG_IBSS_AUTO_BSSID, 0)
-				== CDF_STATUS_E_FAILURE) {
+				== QDF_STATUS_E_FAILURE) {
 			hddLog(LOGE,
 				FL("ccmCfgStInt failed for WNI_CFG_IBSS_AUTO_BSSID"));
 			return -EIO;
@@ -9519,7 +9519,7 @@ static int __wlan_hdd_cfg80211_leave_ibss(struct wiphy *wiphy,
 	tCsrRoamProfile *pRoamProfile;
 	hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
 	int status;
-	CDF_STATUS hal_status;
+	QDF_STATUS hal_status;
 	unsigned long rc;
 
 	ENTER();
@@ -9559,7 +9559,7 @@ static int __wlan_hdd_cfg80211_leave_ibss(struct wiphy *wiphy,
 	hal_status = sme_roam_disconnect(WLAN_HDD_GET_HAL_CTX(pAdapter),
 					 pAdapter->sessionId,
 					 eCSR_DISCONNECT_REASON_IBSS_LEAVE);
-	if (!CDF_IS_STATUS_SUCCESS(hal_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(hal_status)) {
 		hddLog(LOGE,
 		       FL("sme_roam_disconnect failed hal_status(%d)"),
 		       hal_status);
@@ -9829,7 +9829,6 @@ int __wlan_hdd_cfg80211_del_station(struct wiphy *wiphy,
 {
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	hdd_context_t *pHddCtx;
-	CDF_STATUS cdf_status = CDF_STATUS_E_FAILURE;
 	QDF_STATUS qdf_status = QDF_STATUS_E_FAILURE;
 	hdd_hostapd_state_t *hapd_state;
 	int status;
@@ -9895,10 +9894,10 @@ int __wlan_hdd_cfg80211_del_station(struct wiphy *wiphy,
 					qdf_event_reset(&hapd_state->cdf_event);
 					hdd_softap_sta_disassoc(pAdapter,
 								mac);
-					cdf_status =
+					qdf_status =
 						hdd_softap_sta_deauth(pAdapter,
 							pDelStaParams);
-					if (CDF_IS_STATUS_SUCCESS(cdf_status)) {
+					if (QDF_IS_STATUS_SUCCESS(qdf_status)) {
 						pAdapter->aStaInfo[i].
 						isDeauthInProgress = true;
 						qdf_status =
@@ -9914,11 +9913,11 @@ int __wlan_hdd_cfg80211_del_station(struct wiphy *wiphy,
 				}
 			}
 		} else {
-			cdf_status =
+			qdf_status =
 				hdd_softap_get_sta_id(pAdapter,
 					      (struct cdf_mac_addr *) mac,
 					      &staId);
-			if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+			if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 				hddLog(LOG1,
 				       FL("Skip DEL STA as this is not used::"
 					  MAC_ADDRESS_STR),
@@ -9958,9 +9957,9 @@ int __wlan_hdd_cfg80211_del_station(struct wiphy *wiphy,
 
 			qdf_event_reset(&hapd_state->cdf_event);
 			hdd_softap_sta_disassoc(pAdapter, mac);
-			cdf_status = hdd_softap_sta_deauth(pAdapter,
+			qdf_status = hdd_softap_sta_deauth(pAdapter,
 							   pDelStaParams);
-			if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+			if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 				pAdapter->aStaInfo[staId].isDeauthInProgress =
 					false;
 				hddLog(LOG1,
@@ -10131,7 +10130,7 @@ static int __wlan_hdd_cfg80211_set_pmksa(struct wiphy *wiphy,
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
 	tHalHandle halHandle;
-	CDF_STATUS result = CDF_STATUS_SUCCESS;
+	QDF_STATUS result = QDF_STATUS_SUCCESS;
 	int status;
 	tPmkidCacheInfo pmk_id;
 
@@ -10175,7 +10174,7 @@ static int __wlan_hdd_cfg80211_set_pmksa(struct wiphy *wiphy,
 			 pAdapter->sessionId, result));
 
 	EXIT();
-	return CDF_IS_STATUS_SUCCESS(result) ? 0 : -EINVAL;
+	return QDF_IS_STATUS_SUCCESS(result) ? 0 : -EINVAL;
 }
 
 /**
@@ -10247,7 +10246,7 @@ static int __wlan_hdd_cfg80211_del_pmksa(struct wiphy *wiphy,
 			 TRACE_CODE_HDD_CFG80211_DEL_PMKSA,
 			 pAdapter->sessionId, 0));
 	/* Delete the PMKID CSR cache */
-	if (CDF_STATUS_SUCCESS !=
+	if (QDF_STATUS_SUCCESS !=
 	    sme_roam_del_pmkid_from_cache(halHandle,
 					  pAdapter->sessionId, pmksa->bssid,
 					  false)) {
@@ -10315,7 +10314,7 @@ static int __wlan_hdd_cfg80211_flush_pmksa(struct wiphy *wiphy,
 	halHandle = WLAN_HDD_GET_HAL_CTX(pAdapter);
 
 	/* Flush the PMKID cache in CSR */
-	if (CDF_STATUS_SUCCESS !=
+	if (QDF_STATUS_SUCCESS !=
 	    sme_roam_del_pmkid_from_cache(halHandle, pAdapter->sessionId, NULL,
 					  true)) {
 		hddLog(LOGE, FL("Cannot flush PMKIDCache"));
@@ -10447,7 +10446,7 @@ void wlan_hdd_cfg80211_update_replay_counter_callback(void *callbackContext,
 		return;
 	}
 
-	if (CDF_STATUS_SUCCESS != pGtkOffloadGetInfoRsp->ulStatus) {
+	if (QDF_STATUS_SUCCESS != pGtkOffloadGetInfoRsp->ulStatus) {
 		hddLog(LOGE, FL("wlan Failed to get replay counter value"));
 		return;
 	}
@@ -10496,7 +10495,7 @@ int __wlan_hdd_cfg80211_set_rekey_data(struct wiphy *wiphy,
 	tHalHandle hHal;
 	int result;
 	tSirGtkOffloadParams hddGtkOffloadReqParams;
-	CDF_STATUS status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
 
 	ENTER();
 
@@ -10551,7 +10550,7 @@ int __wlan_hdd_cfg80211_set_rekey_data(struct wiphy *wiphy,
 			sme_set_gtk_offload(hHal, &hddGtkOffloadReqParams,
 					    pAdapter->sessionId);
 
-		if (CDF_STATUS_SUCCESS != status) {
+		if (QDF_STATUS_SUCCESS != status) {
 			hddLog(LOGE, FL("sme_set_gtk_offload failed, status(%d)"),
 			       status);
 			return -EINVAL;
@@ -10608,7 +10607,7 @@ static int __wlan_hdd_cfg80211_set_mac_acl(struct wiphy *wiphy,
 	v_CONTEXT_t p_cds_context = NULL;
 	hdd_context_t *pHddCtx;
 	int status;
-	CDF_STATUS cdf_status = CDF_STATUS_SUCCESS;
+	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
 
 	ENTER();
 
@@ -10695,13 +10694,13 @@ static int __wlan_hdd_cfg80211_set_mac_acl(struct wiphy *wiphy,
 			}
 		}
 #ifdef WLAN_FEATURE_MBSSID
-		cdf_status =
+		qdf_status =
 			wlansap_set_mac_acl(WLAN_HDD_GET_SAP_CTX_PTR(pAdapter),
 					    pConfig);
 #else
-		cdf_status = wlansap_set_mac_acl(p_cds_context, pConfig);
+		qdf_status = wlansap_set_mac_acl(p_cds_context, pConfig);
 #endif
-		if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+		if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 			hddLog(LOGE, FL("SAP Set Mac Acl fail"));
 			return -EINVAL;
 		}
@@ -10837,7 +10836,7 @@ static int __wlan_hdd_cfg80211_testmode(struct wiphy *wiphy,
 		void *buf;
 		tSirLPHBReq *hb_params = NULL;
 		tSirLPHBReq *hb_params_temp = NULL;
-		CDF_STATUS smeStatus;
+		QDF_STATUS smeStatus;
 
 		if (!tb[WLAN_HDD_TM_ATTR_DATA]) {
 			hddLog(LOGE, FL("Testmode INV DATA"));
@@ -10865,7 +10864,7 @@ static int __wlan_hdd_cfg80211_testmode(struct wiphy *wiphy,
 			sme_lphb_config_req((tHalHandle) (pHddCtx->hHal),
 					    hb_params,
 					    wlan_hdd_cfg80211_lphb_ind_handler);
-		if (CDF_STATUS_SUCCESS != smeStatus) {
+		if (QDF_STATUS_SUCCESS != smeStatus) {
 			hddLog(LOGE, "LPHB Config Fail, disable");
 			cdf_mem_free(hb_params);
 		}
@@ -10878,7 +10877,7 @@ static int __wlan_hdd_cfg80211_testmode(struct wiphy *wiphy,
 	{
 		int buf_len;
 		void *buf;
-		CDF_STATUS status;
+		QDF_STATUS status;
 		if (!tb[WLAN_HDD_TM_ATTR_DATA]) {
 			hddLog(LOGE,
 			       FL
@@ -10893,7 +10892,7 @@ static int __wlan_hdd_cfg80211_testmode(struct wiphy *wiphy,
 
 		status = wlan_hdd_ftm_testmode_cmd(buf, buf_len);
 
-		if (status != CDF_STATUS_SUCCESS)
+		if (status != QDF_STATUS_SUCCESS)
 			err = -EBUSY;
 		break;
 	}
@@ -11000,7 +10999,7 @@ __wlan_hdd_cfg80211_set_ap_channel_width(struct wiphy *wiphy,
 {
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	hdd_context_t *pHddCtx;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	tSmeConfigParams sme_config;
 	bool cbModeChange;
 
@@ -11062,7 +11061,7 @@ __wlan_hdd_cfg80211_set_ap_channel_width(struct wiphy *wiphy,
 	/* Change SAP ht2040 mode */
 	status = hdd_set_sap_ht2040_mode(pAdapter,
 					 cfg80211_get_chandef_type(chandef));
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		hddLog(LOGE, FL("Error!!! Cannot set SAP HT20/40 mode!"));
 		return -EINVAL;
 	}

core/hdd/src/wlan_hdd_cfg80211.h

@@ -2266,16 +2266,16 @@ int wlan_hdd_cfg80211_pmksa_candidate_notify(hdd_adapter_t *pAdapter,
 					int index, bool preauth);
 
 #ifdef FEATURE_WLAN_LFR_METRICS
-CDF_STATUS wlan_hdd_cfg80211_roam_metrics_preauth(hdd_adapter_t *pAdapter,
+QDF_STATUS wlan_hdd_cfg80211_roam_metrics_preauth(hdd_adapter_t *pAdapter,
 						tCsrRoamInfo *pRoamInfo);
 
-CDF_STATUS wlan_hdd_cfg80211_roam_metrics_preauth_status(hdd_adapter_t *
+QDF_STATUS wlan_hdd_cfg80211_roam_metrics_preauth_status(hdd_adapter_t *
 							 pAdapter,
 							 tCsrRoamInfo *
 							 pRoamInfo,
 							 bool preauth_status);
 
-CDF_STATUS wlan_hdd_cfg80211_roam_metrics_handover(hdd_adapter_t *pAdapter,
+QDF_STATUS wlan_hdd_cfg80211_roam_metrics_handover(hdd_adapter_t *pAdapter,
 						   tCsrRoamInfo *pRoamInfo);
 #endif
 
@@ -2304,7 +2304,7 @@ void hdd_reg_notifier(struct wiphy *wiphy,
 
 extern void hdd_conn_set_connection_state(hdd_adapter_t *pAdapter,
 					  eConnectionState connState);
-CDF_STATUS wlan_hdd_validate_operation_channel(hdd_adapter_t *pAdapter,
+QDF_STATUS wlan_hdd_validate_operation_channel(hdd_adapter_t *pAdapter,
 					       int channel);
 #ifdef FEATURE_WLAN_TDLS
 int wlan_hdd_cfg80211_send_tdls_discover_req(struct wiphy *wiphy,

core/hdd/src/wlan_hdd_conc_ut.c

@@ -630,11 +630,11 @@ void wlan_hdd_one_connection_scenario(hdd_context_t *hdd_ctx)
 	bool status = false;
 	enum cds_pcl_type pcl_type;
 	char reason[20] = {0};
-	CDF_STATUS ret;
+	QDF_STATUS ret;
 
 	/* flush the entire table first */
 	ret = cds_init_policy_mgr();
-	if (!CDF_IS_STATUS_SUCCESS(ret)) {
+	if (!QDF_IS_STATUS_SUCCESS(ret)) {
 		hdd_err("Policy manager initialization failed");
 		return;
 	}
@@ -681,7 +681,7 @@ void wlan_hdd_two_connections_scenario(hdd_context_t *hdd_ctx,
 	enum cds_one_connection_mode second_index;
 	char reason[20] = {0};
 	bool status = false;
-	CDF_STATUS ret;
+	QDF_STATUS ret;
 
 	for (sub_type = CDS_STA_MODE;
 		sub_type < CDS_MAX_NUM_OF_MODE; sub_type++) {
@@ -689,7 +689,7 @@ void wlan_hdd_two_connections_scenario(hdd_context_t *hdd_ctx,
 
 		/* flush the entire table first */
 		ret = cds_init_policy_mgr();
-		if (!CDF_IS_STATUS_SUCCESS(ret)) {
+		if (!QDF_IS_STATUS_SUCCESS(ret)) {
 			hdd_err("Policy manager initialization failed");
 			return;
 		}
@@ -761,7 +761,7 @@ void wlan_hdd_three_connections_scenario(hdd_context_t *hdd_ctx,
 	enum cds_two_connection_mode third_index;
 	char reason[20] = {0};
 	bool status = false;
-	CDF_STATUS ret;
+	QDF_STATUS ret;
 
 	/* let's set the chain_mask, mac_ids*/
 	if (chain_mask == CDS_TWO_TWO) {
@@ -787,7 +787,7 @@ void wlan_hdd_three_connections_scenario(hdd_context_t *hdd_ctx,
 		type_1 = wlan_hdd_valid_type_of_persona(sub_type_1);
 		/* flush the entire table first */
 		ret = cds_init_policy_mgr();
-		if (!CDF_IS_STATUS_SUCCESS(ret)) {
+		if (!QDF_IS_STATUS_SUCCESS(ret)) {
 			hdd_err("Policy manager initialization failed");
 			return;
 		}

core/hdd/src/wlan_hdd_debugfs.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2015 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -321,7 +321,7 @@ static ssize_t __wcnss_patterngen_write(struct file *file,
 	char *pattern_buf;
 	uint16_t pattern_len = 0;
 	uint16_t i = 0;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	int ret;
 
 	ENTER();
@@ -411,7 +411,7 @@ static ssize_t __wcnss_patterngen_write(struct file *file,
 		/* Delete pattern */
 		status = sme_del_periodic_tx_ptrn(pHddCtx->hHal,
 						  delPeriodicTxPtrnParams);
-		if (CDF_STATUS_SUCCESS != status) {
+		if (QDF_STATUS_SUCCESS != status) {
 			CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 				  "%s: sme_del_periodic_tx_ptrn() failed!",
 				  __func__);
@@ -489,7 +489,7 @@ static ssize_t __wcnss_patterngen_write(struct file *file,
 	/* Add pattern */
 	status = sme_add_periodic_tx_ptrn(pHddCtx->hHal,
 					  addPeriodicTxPtrnParams);
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  "%s: sme_add_periodic_tx_ptrn() failed!", __func__);
 
@@ -610,33 +610,33 @@ static const struct file_operations fops_patterngen = {
  * NB: The current implementation only supports debugfs operations
  * on the primary interface, i.e. wlan0
  *
- * Return: CDF_STATUS_SUCCESS if all files registered,
- *	   CDF_STATUS_E_FAILURE on failure
+ * Return: QDF_STATUS_SUCCESS if all files registered,
+ *	   QDF_STATUS_E_FAILURE on failure
  */
-CDF_STATUS hdd_debugfs_init(hdd_adapter_t *pAdapter)
+QDF_STATUS hdd_debugfs_init(hdd_adapter_t *pAdapter)
 {
 	hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
 	pHddCtx->debugfs_phy = debugfs_create_dir("wlan_wcnss", 0);
 
 	if (NULL == pHddCtx->debugfs_phy)
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
 	if (NULL == debugfs_create_file("wow_enable", S_IRUSR | S_IWUSR,
 					pHddCtx->debugfs_phy, pAdapter,
 					&fops_wowenable))
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
 	if (NULL == debugfs_create_file("wow_pattern", S_IRUSR | S_IWUSR,
 					pHddCtx->debugfs_phy, pAdapter,
 					&fops_wowpattern))
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
 	if (NULL == debugfs_create_file("pattern_gen", S_IRUSR | S_IWUSR,
 					pHddCtx->debugfs_phy, pAdapter,
 					&fops_patterngen))
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**

core/hdd/src/wlan_hdd_driver_ops.c

@@ -38,7 +38,6 @@
 #include <soc/qcom/icnss.h>
 #endif /* HIF_PCI */
 #include "cds_api.h"
-#include "cdf_status.h"
 #include "qdf_status.h"
 #include "cdf_lock.h"
 #include "cds_sched.h"
@@ -182,7 +181,7 @@ static void hdd_hif_init_cds_callbacks(void *data, struct hif_callbacks *cbk)
  */
 static int hdd_init_cds_hif_context(void *hif)
 {
-	CDF_STATUS status;
+	QDF_STATUS status;
 
 	status = cds_set_context(CDF_MODULE_ID_HIF, hif);
 
@@ -199,7 +198,7 @@ static int hdd_init_cds_hif_context(void *hif)
  */
 static void hdd_deinit_cds_hif_context(void)
 {
-	CDF_STATUS status;
+	QDF_STATUS status;
 
 	status = cds_set_context(CDF_MODULE_ID_HIF, NULL);
 
@@ -224,7 +223,7 @@ static void hdd_deinit_cds_hif_context(void)
 static int hdd_hif_open(struct device *dev, void *bdev, const hif_bus_id *bid,
 			enum ath_hal_bus_type bus_type, bool reinit)
 {
-	CDF_STATUS status;
+	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);
@@ -259,7 +258,7 @@ static int hdd_hif_open(struct device *dev, void *bdev, const hif_bus_id *bid,
 	status = hif_enable(hif_ctx, dev, bdev, bid, bus_type,
 			    (reinit == true) ?  HIF_ENABLE_TYPE_REINIT :
 			    HIF_ENABLE_TYPE_PROBE);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hdd_err("hif_enable error = %d, reinit = %d",
 			status, reinit);
 		ret = cdf_status_to_os_return(status);
@@ -328,7 +327,7 @@ static int wlan_hdd_probe(struct device *dev, void *bdev, const hif_bus_id *bid,
 	enum ath_hal_bus_type bus_type, bool reinit)
 {
 	void *hif_ctx;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	int ret = 0;
 	cdf_device_t cdf_dev;
 	uint32_t mode = cds_get_conparam();
@@ -358,7 +357,7 @@ static int wlan_hdd_probe(struct device *dev, void *bdev, const hif_bus_id *bid,
 
 	if (WLAN_IS_EPPING_ENABLED(mode)) {
 		status = epping_open();
-		if (status != CDF_STATUS_SUCCESS)
+		if (status != QDF_STATUS_SUCCESS)
 			goto err_hdd_deinit;
 	}
 
@@ -374,7 +373,7 @@ static int wlan_hdd_probe(struct device *dev, void *bdev, const hif_bus_id *bid,
 
 	status = ol_cds_init(cdf_dev, hif_ctx);
 
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		pr_err("%s No Memory to Create BMI Context\n", __func__);
 		goto err_hif_close;
 	}
@@ -599,7 +598,7 @@ done:
  *
  * @state: state
  *
- * Return: CDF_STATUS
+ * Return: QDF_STATUS
  */
 int wlan_hdd_bus_suspend(pm_message_t state)
 {

core/hdd/src/wlan_hdd_ext_scan.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2015 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2012-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -1714,7 +1714,7 @@ static int __wlan_hdd_cfg80211_extscan_get_capabilities(struct wiphy *wiphy,
 	hdd_context_t *pHddCtx = wiphy_priv(wiphy);
 	struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX +
 			  1];
-	CDF_STATUS status;
+	QDF_STATUS status;
 
 	ENTER();
 
@@ -1759,7 +1759,7 @@ static int __wlan_hdd_cfg80211_extscan_get_capabilities(struct wiphy *wiphy,
 	spin_unlock(&context->context_lock);
 
 	status = sme_ext_scan_get_capabilities(pHddCtx->hHal, pReqMsg);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hddLog(LOGE, FL("sme_ext_scan_get_capabilities failed(err=%d)"),
 			status);
 		goto fail;
@@ -1846,7 +1846,7 @@ static int __wlan_hdd_cfg80211_extscan_get_cached_results(struct wiphy *wiphy,
 	struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX +
 			  1];
 	struct hdd_ext_scan_context *context;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	int retval = 0;
 	unsigned long rc;
 
@@ -1900,7 +1900,7 @@ static int __wlan_hdd_cfg80211_extscan_get_cached_results(struct wiphy *wiphy,
 	spin_unlock(&context->context_lock);
 
 	status = sme_get_cached_results(pHddCtx->hHal, pReqMsg);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hddLog(LOGE,
 		       FL("sme_get_cached_results failed(err=%d)"), status);
 		goto fail;
@@ -1993,7 +1993,7 @@ __wlan_hdd_cfg80211_extscan_set_bssid_hotlist(struct wiphy *wiphy,
 	struct nlattr *apTh;
 	struct hdd_ext_scan_context *context;
 	uint32_t request_id;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	uint8_t i;
 	int rem, retval;
 	unsigned long rc;
@@ -2111,7 +2111,7 @@ __wlan_hdd_cfg80211_extscan_set_bssid_hotlist(struct wiphy *wiphy,
 	spin_unlock(&context->context_lock);
 
 	status = sme_set_bss_hotlist(pHddCtx->hHal, pReqMsg);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hddLog(LOGE, FL("sme_set_bss_hotlist failed(err=%d)"), status);
 		goto fail;
 	}
@@ -2190,7 +2190,7 @@ __wlan_hdd_cfg80211_extscan_set_significant_change(struct wiphy *wiphy,
 	struct nlattr *apTh;
 	struct hdd_ext_scan_context *context;
 	uint32_t request_id;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	uint8_t i;
 	int rem, retval;
 	unsigned long rc;
@@ -2330,7 +2330,7 @@ __wlan_hdd_cfg80211_extscan_set_significant_change(struct wiphy *wiphy,
 	spin_unlock(&context->context_lock);
 
 	status = sme_set_significant_change(pHddCtx->hHal, pReqMsg);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hddLog(LOGE,
 		       FL("sme_set_significant_change failed(err=%d)"), status);
 		cdf_mem_free(pReqMsg);
@@ -2472,7 +2472,7 @@ __wlan_hdd_cfg80211_extscan_get_valid_channels(struct wiphy *wiphy,
 			  1];
 	uint32_t requestId, maxChannels;
 	tWifiBand wifiBand;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	struct sk_buff *reply_skb;
 	uint8_t i;
 	int ret;
@@ -2527,7 +2527,7 @@ __wlan_hdd_cfg80211_extscan_get_valid_channels(struct wiphy *wiphy,
 	status = sme_get_valid_channels_by_band((tHalHandle) (pHddCtx->hHal),
 						wifiBand, chan_list,
 						&num_channels);
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		hddLog(LOGE,
 		       FL("sme_get_valid_channels_by_band failed (err=%d)"),
 		       status);
@@ -2693,7 +2693,7 @@ static int hdd_extscan_start_fill_bucket_channel_spec(
 	struct nlattr *buckets;
 	struct nlattr *channels;
 	int rem1, rem2;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	uint8_t bkt_index, j, num_channels, total_channels = 0;
 	uint32_t chan_list[WNI_CFG_VALID_CHANNEL_LIST_LEN] = {0};
 
@@ -2821,7 +2821,7 @@ static int hdd_extscan_start_fill_bucket_channel_spec(
 			status = sme_get_valid_channels_by_band(hdd_ctx->hHal,
 						req_msg->buckets[bkt_index].band,
 						chan_list, &num_channels);
-			if (!CDF_IS_STATUS_SUCCESS(status)) {
+			if (!QDF_IS_STATUS_SUCCESS(status)) {
 				hddLog(LOGE,
 				       FL("sme_GetValidChannelsByBand failed (err=%d)"),
 				       status);
@@ -3138,7 +3138,7 @@ __wlan_hdd_cfg80211_extscan_start(struct wiphy *wiphy,
 	struct nlattr *tb[PARAM_MAX + 1];
 	struct hdd_ext_scan_context *context;
 	uint32_t request_id, num_buckets;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	int retval;
 	unsigned long rc;
 
@@ -3250,7 +3250,7 @@ __wlan_hdd_cfg80211_extscan_start(struct wiphy *wiphy,
 	spin_unlock(&context->context_lock);
 
 	status = sme_ext_scan_start(pHddCtx->hHal, pReqMsg);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hddLog(LOGE,
 			FL("sme_ext_scan_start failed(err=%d)"), status);
 		goto fail;
@@ -3347,7 +3347,7 @@ __wlan_hdd_cfg80211_extscan_stop(struct wiphy *wiphy,
 	hdd_context_t *pHddCtx = wiphy_priv(wiphy);
 	struct nlattr *tb[PARAM_MAX + 1];
 	struct hdd_ext_scan_context *context;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	uint32_t request_id;
 	int retval;
 	unsigned long rc;
@@ -3393,7 +3393,7 @@ __wlan_hdd_cfg80211_extscan_stop(struct wiphy *wiphy,
 	spin_unlock(&context->context_lock);
 
 	status = sme_ext_scan_stop(pHddCtx->hHal, pReqMsg);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hddLog(LOGE,
 		       FL("sme_ext_scan_stop failed(err=%d)"), status);
 		goto fail;
@@ -3475,7 +3475,7 @@ __wlan_hdd_cfg80211_extscan_reset_bssid_hotlist(struct wiphy *wiphy,
 			  1];
 	struct hdd_ext_scan_context *context;
 	uint32_t request_id;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	int retval;
 	unsigned long rc;
 
@@ -3522,7 +3522,7 @@ __wlan_hdd_cfg80211_extscan_reset_bssid_hotlist(struct wiphy *wiphy,
 	spin_unlock(&context->context_lock);
 
 	status = sme_reset_bss_hotlist(pHddCtx->hHal, pReqMsg);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hddLog(LOGE,
 		       FL("sme_reset_bss_hotlist failed(err=%d)"), status);
 		goto fail;
@@ -3600,7 +3600,7 @@ __wlan_hdd_cfg80211_extscan_reset_significant_change(struct wiphy
 			  1];
 	struct hdd_ext_scan_context *context;
 	uint32_t request_id;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	int retval;
 	unsigned long rc;
 
@@ -3647,7 +3647,7 @@ __wlan_hdd_cfg80211_extscan_reset_significant_change(struct wiphy
 	spin_unlock(&context->context_lock);
 
 	status = sme_reset_significant_change(pHddCtx->hHal, pReqMsg);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hddLog(LOGE, FL("sme_reset_significant_change failed(err=%d)"),
 			status);
 		cdf_mem_free(pReqMsg);
@@ -3812,7 +3812,7 @@ static int __wlan_hdd_cfg80211_set_epno_list(struct wiphy *wiphy,
 	hdd_context_t *hdd_ctx           = wiphy_priv(wiphy);
 	struct nlattr *tb[
 		QCA_WLAN_VENDOR_ATTR_PNO_MAX + 1];
-	CDF_STATUS status;
+	QDF_STATUS status;
 	uint32_t num_networks, len;
 	int ret_val;
 
@@ -3869,7 +3869,7 @@ static int __wlan_hdd_cfg80211_set_epno_list(struct wiphy *wiphy,
 		goto fail;
 
 	status = sme_set_epno_list(hdd_ctx->hHal, req_msg);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hddLog(LOGE, FL("sme_set_epno_list failed(err=%d)"), status);
 		goto fail;
 	}
@@ -4018,7 +4018,7 @@ static int __wlan_hdd_cfg80211_set_passpoint_list(struct wiphy *wiphy,
 	hdd_adapter_t *adapter             = WLAN_HDD_GET_PRIV_PTR(dev);
 	hdd_context_t *hdd_ctx             = wiphy_priv(wiphy);
 	struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_PNO_MAX + 1];
-	CDF_STATUS status;
+	QDF_STATUS status;
 	uint32_t num_networks = 0;
 	int ret;
 
@@ -4072,7 +4072,7 @@ static int __wlan_hdd_cfg80211_set_passpoint_list(struct wiphy *wiphy,
 		goto fail;
 
 	status = sme_set_passpoint_list(hdd_ctx->hHal, req_msg);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hddLog(LOGE,
 			FL("sme_set_passpoint_list failed(err=%d)"), status);
 		goto fail;
@@ -4135,7 +4135,7 @@ static int __wlan_hdd_cfg80211_reset_passpoint_list(struct wiphy *wiphy,
 	hdd_adapter_t *adapter             = WLAN_HDD_GET_PRIV_PTR(dev);
 	hdd_context_t *hdd_ctx             = wiphy_priv(wiphy);
 	struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_PNO_MAX + 1];
-	CDF_STATUS status;
+	QDF_STATUS status;
 	int ret;
 
 	ENTER();
@@ -4174,7 +4174,7 @@ static int __wlan_hdd_cfg80211_reset_passpoint_list(struct wiphy *wiphy,
 			req_msg->request_id, req_msg->session_id);
 
 	status = sme_reset_passpoint_list(hdd_ctx->hHal, req_msg);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hddLog(LOGE,
 			FL("sme_reset_passpoint_list failed(err=%d)"), status);
 		goto fail;
@@ -4264,7 +4264,7 @@ __wlan_hdd_cfg80211_extscan_set_ssid_hotlist(struct wiphy *wiphy,
 	uint32_t request_id;
 	char ssid_string[SIR_MAC_MAX_SSID_LENGTH + 1];
 	int ssid_len, i, rem;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	int retval;
 	unsigned long rc;
 
@@ -4384,7 +4384,7 @@ __wlan_hdd_cfg80211_extscan_set_ssid_hotlist(struct wiphy *wiphy,
 	spin_unlock(&context->context_lock);
 
 	status = sme_set_ssid_hotlist(hdd_ctx->hHal, request);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hddLog(LOGE,
 		       FL("sme_set_ssid_hotlist failed(err=%d)"), status);
 		goto fail;
@@ -4484,7 +4484,7 @@ __wlan_hdd_cfg80211_extscan_reset_ssid_hotlist(struct wiphy *wiphy,
 	struct nlattr *tb[PARAM_MAX + 1];
 	struct hdd_ext_scan_context *context;
 	uint32_t request_id;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	int retval;
 	unsigned long rc;
 
@@ -4534,7 +4534,7 @@ __wlan_hdd_cfg80211_extscan_reset_ssid_hotlist(struct wiphy *wiphy,
 	spin_unlock(&context->context_lock);
 
 	status = sme_set_ssid_hotlist(hdd_ctx->hHal, request);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hddLog(LOGE,
 		       FL("sme_reset_ssid_hotlist failed(err=%d)"), status);
 		goto fail;

core/hdd/src/wlan_hdd_ftm.c

@@ -99,16 +99,16 @@ static uint32_t wlan_ftm_postmsg(uint8_t *cmd_ptr, uint16_t cmd_len)
 	ftmMsg.bodyptr = (uint8_t *) cmd_ptr;
 	ftmMsg.bodyval = 0;
 
-	if (CDF_STATUS_SUCCESS != cds_mq_post_message(CDF_MODULE_ID_WMA,
+	if (QDF_STATUS_SUCCESS != cds_mq_post_message(CDF_MODULE_ID_WMA,
 						      &ftmMsg)) {
 		hddLog(CDF_TRACE_LEVEL_ERROR, "%s: : Failed to post Msg to HAL",
 		       __func__);
 
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	EXIT();
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -161,16 +161,16 @@ static inline void hdd_is_lpass_supported(tMacOpenParameters *mac_openParms,
  * - All the WLAN SW components should have been opened. This includes MAC.
  *
  * Returns:
- *	CDF_STATUS_SUCCESS - Scheduler was successfully initialized and
+ *	QDF_STATUS_SUCCESS - Scheduler was successfully initialized and
  *	is ready to be used.
- *	CDF_STATUS_E_RESOURCES - System resources (other than memory)
+ *	QDF_STATUS_E_RESOURCES - System resources (other than memory)
  *	are unavailable to initialize the scheduler
- *	CDF_STATUS_E_FAILURE - Failure to initialize the scheduler
+ *	QDF_STATUS_E_FAILURE - Failure to initialize the scheduler
  */
-static CDF_STATUS wlan_ftm_cds_open(v_CONTEXT_t p_cds_context,
+static QDF_STATUS wlan_ftm_cds_open(v_CONTEXT_t p_cds_context,
 				    uint32_t hddContextSize)
 {
-	CDF_STATUS vStatus = CDF_STATUS_SUCCESS;
+	QDF_STATUS vStatus = QDF_STATUS_SUCCESS;
 	int iter = 0;
 	tSirRetStatus sirStatus = eSIR_SUCCESS;
 	tMacOpenParameters mac_openParms;
@@ -191,7 +191,7 @@ static CDF_STATUS wlan_ftm_cds_open(v_CONTEXT_t p_cds_context,
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Trying to open CDS without a PreOpen", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	/* Initialize the probe event */
@@ -199,7 +199,7 @@ static CDF_STATUS wlan_ftm_cds_open(v_CONTEXT_t p_cds_context,
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Unable to init probeEvent", __func__);
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	if (qdf_event_create(&(gp_cds_context->wmaCompleteEvent)) !=
@@ -213,7 +213,7 @@ static CDF_STATUS wlan_ftm_cds_open(v_CONTEXT_t p_cds_context,
 
 	/* Initialize the free message queue */
 	vStatus = cds_mq_init(&gp_cds_context->freeVosMq);
-	if (!CDF_IS_STATUS_SUCCESS(vStatus)) {
+	if (!QDF_IS_STATUS_SUCCESS(vStatus)) {
 
 		/* Critical Error ...  Cannot proceed further */
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
@@ -235,7 +235,7 @@ static CDF_STATUS wlan_ftm_cds_open(v_CONTEXT_t p_cds_context,
 	vStatus = cds_sched_open(gp_cds_context, &gp_cds_context->cdf_sched,
 				 sizeof(cds_sched_context));
 
-	if (!CDF_IS_STATUS_SUCCESS(vStatus)) {
+	if (!QDF_IS_STATUS_SUCCESS(vStatus)) {
 		/* Critical Error ...  Cannot proceed further */
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to open CDS Scheduler %d", __func__,
@@ -300,7 +300,7 @@ static CDF_STATUS wlan_ftm_cds_open(v_CONTEXT_t p_cds_context,
 
 	vStatus = wma_open(gp_cds_context,
 			   wlan_hdd_ftm_update_tgt_cfg, NULL, &mac_openParms);
-	if (!CDF_IS_STATUS_SUCCESS(vStatus)) {
+	if (!QDF_IS_STATUS_SUCCESS(vStatus)) {
 		/* Critical Error ...  Cannot proceed further */
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to open WMA module %d", __func__,
@@ -346,7 +346,7 @@ static CDF_STATUS wlan_ftm_cds_open(v_CONTEXT_t p_cds_context,
 #ifndef QCA_WIFI_FTM
 	/* Now proceed to open the SME */
 	vStatus = sme_open(gp_cds_context->pMACContext);
-	if (!CDF_IS_STATUS_SUCCESS(vStatus)) {
+	if (!QDF_IS_STATUS_SUCCESS(vStatus)) {
 		/* Critical Error ...  Cannot proceed further */
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to open SME %d", __func__, vStatus);
@@ -355,16 +355,16 @@ static CDF_STATUS wlan_ftm_cds_open(v_CONTEXT_t p_cds_context,
 
 	vStatus = sme_init_chan_list(gp_cds_context->pMACContext,
 				     hdd_ctx->reg.alpha2, hdd_ctx->reg.cc_src);
-	if (!CDF_IS_STATUS_SUCCESS(vStatus)) {
+	if (!QDF_IS_STATUS_SUCCESS(vStatus)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to init sme channel list", __func__);
 	} else {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_INFO_HIGH,
 			  "%s: CDS successfully Opened", __func__);
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 #else
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 #endif
 
 #ifndef QCA_WIFI_FTM
@@ -397,7 +397,7 @@ err_wma_complete_event:
 err_probe_event:
 	qdf_event_destroy(&gp_cds_context->ProbeEvent);
 
-	return CDF_STATUS_E_FAILURE;
+	return QDF_STATUS_E_FAILURE;
 
 } /* wlan_ftm_cds_open() */
 
@@ -407,38 +407,37 @@ err_probe_event:
  *
  * The wlan_ftm_cds_close() function closes the CDF Module
  *
- * Return: CDF_STATUS_SUCCESS - successfully closed
+ * Return: QDF_STATUS_SUCCESS - successfully closed
  */
-static CDF_STATUS wlan_ftm_cds_close(v_CONTEXT_t cds_context)
+static QDF_STATUS wlan_ftm_cds_close(v_CONTEXT_t cds_context)
 {
-	CDF_STATUS cdf_status;
 	QDF_STATUS qdf_status;
 	p_cds_contextType gp_cds_context = (p_cds_contextType) cds_context;
 
 #ifndef QCA_WIFI_FTM
-	cdf_status = sme_close(((p_cds_contextType) cds_context)->pMACContext);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = sme_close(((p_cds_contextType) cds_context)->pMACContext);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
-			  "%s: Failed to close SME %d", __func__, cdf_status);
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(cdf_status));
+			  "%s: Failed to close SME %d", __func__, qdf_status);
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 	}
 #endif
 
-	cdf_status = mac_close(((p_cds_contextType) cds_context)->pMACContext);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = mac_close(((p_cds_contextType) cds_context)->pMACContext);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
-			  "%s: Failed to close MAC %d", __func__, cdf_status);
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(cdf_status));
+			  "%s: Failed to close MAC %d", __func__, qdf_status);
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 	}
 
 	((p_cds_contextType) cds_context)->pMACContext = NULL;
 
 
-	cdf_status = wma_close(cds_context);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = wma_close(cds_context);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
-			  "%s: Failed to close WMA %d", __func__, cdf_status);
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(cdf_status));
+			  "%s: Failed to close WMA %d", __func__, qdf_status);
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 	}
 #if  defined(QCA_WIFI_FTM)
 	if (gp_cds_context->htc_ctx) {
@@ -446,11 +445,11 @@ static CDF_STATUS wlan_ftm_cds_close(v_CONTEXT_t cds_context)
 		htc_destroy(gp_cds_context->htc_ctx);
 		gp_cds_context->htc_ctx = NULL;
 	}
-	cdf_status = wma_wmi_service_close(cds_context);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = wma_wmi_service_close(cds_context);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to close wma_wmi_service", __func__);
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(cdf_status));
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 	}
 
 	hif_disable_isr(gp_cds_context->pHIFContext);
@@ -474,7 +473,7 @@ static CDF_STATUS wlan_ftm_cds_close(v_CONTEXT_t cds_context)
 		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -484,12 +483,12 @@ static CDF_STATUS wlan_ftm_cds_close(v_CONTEXT_t cds_context)
  * The cds_ftm_pre_start() function performs all pre-start activities
  * in FTM mode.
  *
- * Return: CDF_STATUS_SUCCESS if pre-start was successful, an
+ * Return: QDF_STATUS_SUCCESS if pre-start was successful, an
  *	   appropriate CDF_STATUS_E_* error code otherwise
  */
-static CDF_STATUS cds_ftm_pre_start(v_CONTEXT_t cds_context)
+static QDF_STATUS cds_ftm_pre_start(v_CONTEXT_t cds_context)
 {
-	CDF_STATUS vStatus = CDF_STATUS_SUCCESS;
+	QDF_STATUS vStatus = QDF_STATUS_SUCCESS;
 	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
 	p_cds_contextType p_cds_context = (p_cds_contextType) cds_context;
 #if  defined(QCA_WIFI_FTM)
@@ -502,7 +501,7 @@ static CDF_STATUS cds_ftm_pre_start(v_CONTEXT_t cds_context)
 		CDF_ASSERT(0);
 		CDF_TRACE(CDF_MODULE_ID_SYS, CDF_TRACE_LEVEL_ERROR,
 			  "%s: WMA NULL context", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	/* Reset WMA wait event */
@@ -510,11 +509,11 @@ static CDF_STATUS cds_ftm_pre_start(v_CONTEXT_t cds_context)
 
 	/*call WMA pre start */
 	vStatus = wma_pre_start(p_cds_context);
-	if (!CDF_IS_STATUS_SUCCESS(vStatus)) {
+	if (!QDF_IS_STATUS_SUCCESS(vStatus)) {
 		CDF_TRACE(CDF_MODULE_ID_SYS, CDF_TRACE_LEVEL_ERROR,
 			  "Failed to WMA prestart ");
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	/* Need to update time out of complete */
@@ -531,20 +530,20 @@ static CDF_STATUS cds_ftm_pre_start(v_CONTEXT_t cds_context)
 				  __func__);
 		}
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 #if  defined(QCA_WIFI_FTM)
 	vStatus = htc_start(gp_cds_context->htc_ctx);
-	if (!CDF_IS_STATUS_SUCCESS(vStatus)) {
+	if (!QDF_IS_STATUS_SUCCESS(vStatus)) {
 		CDF_TRACE(CDF_MODULE_ID_SYS, CDF_TRACE_LEVEL_FATAL,
 			  "Failed to Start HTC");
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 	wma_wait_for_ready_event(gp_cds_context->pWMAContext);
 #endif /* QCA_WIFI_FTM */
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -558,7 +557,7 @@ static CDF_STATUS cds_ftm_pre_start(v_CONTEXT_t cds_context)
  */
 int wlan_hdd_ftm_open(hdd_context_t *hdd_ctx)
 {
-	CDF_STATUS vStatus = CDF_STATUS_SUCCESS;
+	QDF_STATUS vStatus = QDF_STATUS_SUCCESS;
 	p_cds_contextType p_cds_context = NULL;
 
 	CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_INFO_HIGH,
@@ -575,7 +574,7 @@ int wlan_hdd_ftm_open(hdd_context_t *hdd_ctx)
 
 	vStatus = wlan_ftm_cds_open(p_cds_context, 0);
 
-	if (!CDF_IS_STATUS_SUCCESS(vStatus)) {
+	if (!QDF_IS_STATUS_SUCCESS(vStatus)) {
 		hddLog(CDF_TRACE_LEVEL_FATAL, "%s: cds_open failed", __func__);
 		goto err_cdf_status_failure;
 	}
@@ -656,7 +655,7 @@ static int wlan_ftm_stop(hdd_context_t *hdd_ctx)
  */
 int wlan_hdd_ftm_close(hdd_context_t *hdd_ctx)
 {
-	CDF_STATUS cdf_status;
+	QDF_STATUS qdf_status;
 	v_CONTEXT_t cds_context = hdd_ctx->pcds_context;
 
 	hdd_adapter_t *adapter = hdd_get_adapter(hdd_ctx, WLAN_HDD_FTM);
@@ -675,11 +674,11 @@ int wlan_hdd_ftm_close(hdd_context_t *hdd_ctx)
 
 	hdd_close_all_adapters(hdd_ctx, false);
 
-	cdf_status = cds_sched_close(cds_context);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = cds_sched_close(cds_context);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to close CDS Scheduler", __func__);
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(cdf_status));
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 	}
 	/* Close CDS */
 	wlan_ftm_cds_close(cds_context);
@@ -746,7 +745,7 @@ static void hdd_ftm_mc_process_msg(void *message)
  */
 static int wlan_hdd_ftm_start(hdd_context_t *hdd_ctx)
 {
-	CDF_STATUS vStatus = CDF_STATUS_SUCCESS;
+	QDF_STATUS vStatus = QDF_STATUS_SUCCESS;
 	p_cds_contextType p_cds_context =
 		(p_cds_contextType) (hdd_ctx->pcds_context);
 
@@ -771,7 +770,7 @@ static int wlan_hdd_ftm_start(hdd_context_t *hdd_ctx)
 	}
 
 	/* Vos preStart is calling */
-	if (!CDF_IS_STATUS_SUCCESS(cds_ftm_pre_start(hdd_ctx->pcds_context))) {
+	if (!QDF_IS_STATUS_SUCCESS(cds_ftm_pre_start(hdd_ctx->pcds_context))) {
 		hddLog(CDF_TRACE_LEVEL_FATAL, "%s: cds_pre_enable failed",
 		       __func__);
 		goto err_status_failure;
@@ -780,7 +779,7 @@ static int wlan_hdd_ftm_start(hdd_context_t *hdd_ctx)
 	sme_register_ftm_msg_processor(hdd_ctx->hHal, hdd_ftm_mc_process_msg);
 
 	vStatus = wma_start(p_cds_context);
-	if (vStatus != CDF_STATUS_SUCCESS) {
+	if (vStatus != QDF_STATUS_SUCCESS) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to start WMA", __func__);
 		goto err_status_failure;
@@ -856,7 +855,7 @@ static int wlan_hdd_qcmbr_command(hdd_adapter_t *adapter,
 			if (wlan_hdd_ftm_testmode_cmd(pqcmbr_data->buf,
 						      pqcmbr_data->
 						      length)
-			    != CDF_STATUS_SUCCESS) {
+			    != QDF_STATUS_SUCCESS) {
 				ret = -EBUSY;
 			} else {
 				ret = 0;
@@ -1013,9 +1012,9 @@ static void wlanqcmbr_mc_process_msg(void *message)
  * @data: FTM testmode command
  * @len: length of @data
  *
- * Return: CDF_STATUS_SUCCESS on success, CDF_STATUS_E_* on error
+ * Return: QDF_STATUS_SUCCESS on success, CDF_STATUS_E_* on error
  */
-CDF_STATUS wlan_hdd_ftm_testmode_cmd(void *data, int len)
+QDF_STATUS wlan_hdd_ftm_testmode_cmd(void *data, int len)
 {
 	struct ar6k_testmode_cmd_data *cmd_data;
 
@@ -1025,7 +1024,7 @@ CDF_STATUS wlan_hdd_ftm_testmode_cmd(void *data, int len)
 	if (!cmd_data) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  ("Failed to allocate FTM command data"));
-		return CDF_STATUS_E_NOMEM;
+		return QDF_STATUS_E_NOMEM;
 	}
 
 	cmd_data->data = cdf_mem_malloc(len);
@@ -1034,7 +1033,7 @@ CDF_STATUS wlan_hdd_ftm_testmode_cmd(void *data, int len)
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  ("Failed to allocate FTM command data buffer"));
 		cdf_mem_free(cmd_data);
-		return CDF_STATUS_E_NOMEM;
+		return QDF_STATUS_E_NOMEM;
 	}
 
 	cmd_data->len = len;
@@ -1043,9 +1042,9 @@ CDF_STATUS wlan_hdd_ftm_testmode_cmd(void *data, int len)
 	if (wlan_ftm_postmsg((uint8_t *) cmd_data, sizeof(*cmd_data))) {
 		cdf_mem_free(cmd_data->data);
 		cdf_mem_free(cmd_data);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 #endif /*QCA_WIFI_FTM */

core/hdd/src/wlan_hdd_green_ap.c

@@ -302,19 +302,19 @@ static void hdd_wlan_green_ap_timer_fn(void *ctx)
  * hdd_wlan_green_ap_attach() - Attach Green AP context to HDD context
  * @hdd_ctx: Global HDD contect
  *
- * Return: CDF_STATUS_SUCCESS on success, otherwise CDF_STATUS_E_* error
+ * Return: QDF_STATUS_SUCCESS on success, otherwise CDF_STATUS_E_* error
  */
-static CDF_STATUS hdd_wlan_green_ap_attach(struct hdd_context_s *hdd_ctx)
+static QDF_STATUS hdd_wlan_green_ap_attach(struct hdd_context_s *hdd_ctx)
 {
 	struct hdd_green_ap_ctx *green_ap;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	ENTER();
 
 	green_ap = cdf_mem_malloc(sizeof(*green_ap));
 	if (!green_ap) {
 		hdd_alert("Memory allocation for Green-AP failed!");
-		status = CDF_STATUS_E_NOMEM;
+		status = QDF_STATUS_E_NOMEM;
 		goto error;
 	}
 
@@ -340,18 +340,18 @@ error:
  * hdd_wlan_green_ap_deattach() - Detach Green AP context from HDD context
  * @hdd_ctx: Global HDD contect
  *
- * Return: CDF_STATUS_SUCCESS on success, otherwise CDF_STATUS_E_* error
+ * Return: QDF_STATUS_SUCCESS on success, otherwise CDF_STATUS_E_* error
  */
-static CDF_STATUS hdd_wlan_green_ap_deattach(struct hdd_context_s *hdd_ctx)
+static QDF_STATUS hdd_wlan_green_ap_deattach(struct hdd_context_s *hdd_ctx)
 {
 	struct hdd_green_ap_ctx *green_ap = hdd_ctx->green_ap_ctx;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	ENTER();
 
 	if (green_ap == NULL) {
 		hdd_notice("Green-AP is not enabled");
-		status = CDF_STATUS_E_NOSUPPORT;
+		status = QDF_STATUS_E_NOSUPPORT;
 		goto done;
 	}
 
@@ -361,7 +361,7 @@ static CDF_STATUS hdd_wlan_green_ap_deattach(struct hdd_context_s *hdd_ctx)
 		cdf_mc_timer_stop(&green_ap->ps_timer);
 
 	/* Destroy the Green AP timer */
-	if (!CDF_IS_STATUS_SUCCESS(cdf_mc_timer_destroy(&green_ap->ps_timer)))
+	if (!QDF_IS_STATUS_SUCCESS(cdf_mc_timer_destroy(&green_ap->ps_timer)))
 		hdd_notice("Cannot deallocate Green-AP's timer");
 
 	/* release memory */
@@ -383,7 +383,7 @@ done:
  */
 void hdd_wlan_green_ap_init(struct hdd_context_s *hdd_ctx)
 {
-	if (!CDF_IS_STATUS_SUCCESS(hdd_wlan_green_ap_attach(hdd_ctx)))
+	if (!QDF_IS_STATUS_SUCCESS(hdd_wlan_green_ap_attach(hdd_ctx)))
 		hdd_err("Failed to allocate Green-AP resource");
 }
 
@@ -395,7 +395,7 @@ void hdd_wlan_green_ap_init(struct hdd_context_s *hdd_ctx)
  */
 void hdd_wlan_green_ap_deinit(struct hdd_context_s *hdd_ctx)
 {
-	if (!CDF_IS_STATUS_SUCCESS(hdd_wlan_green_ap_deattach(hdd_ctx)))
+	if (!QDF_IS_STATUS_SUCCESS(hdd_wlan_green_ap_deattach(hdd_ctx)))
 		hdd_err("Cannot deallocate Green-AP resource");
 }
 

core/hdd/src/wlan_hdd_hostapd.h

@@ -50,9 +50,9 @@
 hdd_adapter_t *hdd_wlan_create_ap_dev(hdd_context_t *pHddCtx,
 				      tSirMacAddr macAddr, uint8_t *name);
 
-CDF_STATUS hdd_register_hostapd(hdd_adapter_t *pAdapter, uint8_t rtnl_held);
+QDF_STATUS hdd_register_hostapd(hdd_adapter_t *pAdapter, uint8_t rtnl_held);
 
-CDF_STATUS hdd_unregister_hostapd(hdd_adapter_t *pAdapter, bool rtnl_held);
+QDF_STATUS hdd_unregister_hostapd(hdd_adapter_t *pAdapter, bool rtnl_held);
 
 eCsrAuthType
 hdd_translate_rsn_to_csr_auth_type(uint8_t auth_suite[4]);
@@ -73,7 +73,7 @@ hdd_translate_wpa_to_csr_auth_type(uint8_t auth_suite[4]);
 eCsrEncryptionType
 hdd_translate_wpa_to_csr_encryption_type(uint8_t cipher_suite[4]);
 
-CDF_STATUS hdd_softap_sta_deauth(hdd_adapter_t *,
+QDF_STATUS hdd_softap_sta_deauth(hdd_adapter_t *,
 		struct tagCsrDelStaParams *);
 void hdd_softap_sta_disassoc(hdd_adapter_t *, uint8_t *);
 void hdd_softap_tkip_mic_fail_counter_measure(hdd_adapter_t *, bool);
@@ -85,9 +85,9 @@ int hdd_softap_unpack_ie(tHalHandle halHandle,
 			 bool *pMFPRequired,
 			 uint16_t gen_ie_len, uint8_t *gen_ie);
 
-CDF_STATUS hdd_hostapd_sap_event_cb(tpSap_Event pSapEvent,
+QDF_STATUS hdd_hostapd_sap_event_cb(tpSap_Event pSapEvent,
 				    void *usrDataForCallback);
-CDF_STATUS hdd_init_ap_mode(hdd_adapter_t *pAdapter);
+QDF_STATUS hdd_init_ap_mode(hdd_adapter_t *pAdapter);
 void hdd_set_ap_ops(struct net_device *pWlanHostapdDev);
 int hdd_hostapd_stop(struct net_device *dev);
 void hdd_hostapd_channel_wakelock_init(hdd_context_t *pHddCtx);
@@ -96,7 +96,7 @@ void hdd_hostapd_channel_wakelock_deinit(hdd_context_t *pHddCtx);
 void hdd_restart_softap(hdd_context_t *pHddCtx, hdd_adapter_t *pAdapter);
 #endif /* FEATURE_WLAN_FORCE_SAP_SCC */
 #ifdef QCA_HT_2040_COEX
-CDF_STATUS hdd_set_sap_ht2040_mode(hdd_adapter_t *pHostapdAdapter,
+QDF_STATUS hdd_set_sap_ht2040_mode(hdd_adapter_t *pHostapdAdapter,
 				   uint8_t channel_type);
 #endif
 
@@ -112,5 +112,5 @@ int wlan_hdd_cfg80211_change_beacon(struct wiphy *wiphy,
 				    struct net_device *dev,
 				    struct cfg80211_beacon_data *params);
 
-CDF_STATUS wlan_hdd_config_acs(hdd_context_t *hdd_ctx, hdd_adapter_t *adapter);
+QDF_STATUS wlan_hdd_config_acs(hdd_context_t *hdd_ctx, hdd_adapter_t *adapter);
 #endif /* end #if !defined(WLAN_HDD_HOSTAPD_H) */

core/hdd/src/wlan_hdd_ioctl.c

@@ -180,13 +180,13 @@ static void hdd_get_tsm_stats_cb(tAniTrafStrmMetrics tsm_metrics,
 }
 
 static
-CDF_STATUS hdd_get_tsm_stats(hdd_adapter_t *adapter,
+QDF_STATUS hdd_get_tsm_stats(hdd_adapter_t *adapter,
 			     const uint8_t tid,
 			     tAniTrafStrmMetrics *tsm_metrics)
 {
 	hdd_station_ctx_t *hdd_sta_ctx = NULL;
-	CDF_STATUS hstatus;
-	CDF_STATUS vstatus = CDF_STATUS_SUCCESS;
+	QDF_STATUS hstatus;
+	QDF_STATUS vstatus = QDF_STATUS_SUCCESS;
 	unsigned long rc;
 	struct statsContext context;
 	hdd_context_t *hdd_ctx = NULL;
@@ -194,7 +194,7 @@ CDF_STATUS hdd_get_tsm_stats(hdd_adapter_t *adapter,
 	if (NULL == adapter) {
 		hddLog(CDF_TRACE_LEVEL_ERROR,
 		       "%s: adapter is NULL", __func__);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	hdd_ctx = WLAN_HDD_GET_CTX(adapter);
@@ -210,10 +210,10 @@ CDF_STATUS hdd_get_tsm_stats(hdd_adapter_t *adapter,
 				    hdd_sta_ctx->conn_info.staId[0],
 				    hdd_sta_ctx->conn_info.bssId,
 				    &context, hdd_ctx->pcds_context, tid);
-	if (CDF_STATUS_SUCCESS != hstatus) {
+	if (QDF_STATUS_SUCCESS != hstatus) {
 		hddLog(CDF_TRACE_LEVEL_ERROR,
 		       "%s: Unable to retrieve statistics", __func__);
-		vstatus = CDF_STATUS_E_FAULT;
+		vstatus = QDF_STATUS_E_FAULT;
 	} else {
 		/* request was sent -- wait for the response */
 		rc = wait_for_completion_timeout(&context.completion,
@@ -222,7 +222,7 @@ CDF_STATUS hdd_get_tsm_stats(hdd_adapter_t *adapter,
 			hddLog(CDF_TRACE_LEVEL_ERROR,
 			       "%s: SME timed out while retrieving statistics",
 			       __func__);
-			vstatus = CDF_STATUS_E_TIMEOUT;
+			vstatus = QDF_STATUS_E_TIMEOUT;
 		}
 	}
 
@@ -243,7 +243,7 @@ CDF_STATUS hdd_get_tsm_stats(hdd_adapter_t *adapter,
 	context.magic = 0;
 	spin_unlock(&hdd_context_lock);
 
-	if (CDF_STATUS_SUCCESS == vstatus) {
+	if (QDF_STATUS_SUCCESS == vstatus) {
 		tsm_metrics->UplinkPktQueueDly =
 			adapter->tsmStats.UplinkPktQueueDly;
 		cdf_mem_copy(tsm_metrics->UplinkPktQueueDlyHist,
@@ -566,7 +566,7 @@ hdd_reassoc(hdd_adapter_t *adapter, const uint8_t *bssid,
 	}
 
 	/* Check channel number is a valid channel number */
-	if (CDF_STATUS_SUCCESS !=
+	if (QDF_STATUS_SUCCESS !=
 	    wlan_hdd_validate_operation_channel(adapter, channel)) {
 		hddLog(CDF_TRACE_LEVEL_ERROR, "%s: Invalid Channel %d",
 		       __func__, channel);
@@ -1107,7 +1107,7 @@ hdd_parse_set_roam_scan_channels_v1(hdd_adapter_t *adapter,
 {
 	uint8_t channel_list[WNI_CFG_VALID_CHANNEL_LIST_LEN] = { 0 };
 	uint8_t num_chan = 0;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	hdd_context_t *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
 	int ret;
 
@@ -1135,7 +1135,7 @@ hdd_parse_set_roam_scan_channels_v1(hdd_adapter_t *adapter,
 		sme_change_roam_scan_channel_list(hdd_ctx->hHal,
 						  adapter->sessionId,
 						  channel_list, num_chan);
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to update channel list information",
 			  __func__);
@@ -1174,7 +1174,7 @@ hdd_parse_set_roam_scan_channels_v2(hdd_adapter_t *adapter,
 	uint8_t num_chan;
 	int i;
 	hdd_context_t *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
-	CDF_STATUS status;
+	QDF_STATUS status;
 	int ret = 0;
 
 	/* array of values begins after "SETROAMSCANCHANNELS " */
@@ -1208,7 +1208,7 @@ hdd_parse_set_roam_scan_channels_v2(hdd_adapter_t *adapter,
 		sme_change_roam_scan_channel_list(hdd_ctx->hHal,
 						  adapter->sessionId,
 						  channel_list, num_chan);
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to update channel list information",
 			  __func__);
@@ -1278,7 +1278,7 @@ hdd_parse_set_roam_scan_channels(hdd_adapter_t *adapter, const char *command)
  *
  * Return: 0 for success non-zero for failure
  */
-CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
+QDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 {
 	uint8_t *cmdPtr = NULL;
 	int count, content = 0, ret = 0;
@@ -1287,11 +1287,11 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 	/* move to argument list */
 	cmdPtr = strnchr(pValue, strlen(pValue), SPACE_ASCII_VALUE);
 	if (NULL == cmdPtr)
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
 	/* no space after the command */
 	if (SPACE_ASCII_VALUE != *cmdPtr)
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
 	/* remove empty spaces */
 	while ((SPACE_ASCII_VALUE == *cmdPtr) && ('\0' != *cmdPtr))
@@ -1300,17 +1300,17 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 	/* START/STOP PLM req */
 	ret = sscanf(cmdPtr, "%31s ", buf);
 	if (1 != ret)
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
 	ret = kstrtos32(buf, 10, &content);
 	if (ret < 0)
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
 	pPlmRequest->enable = content;
 	cmdPtr = strpbrk(cmdPtr, " ");
 
 	if (NULL == cmdPtr)
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
 	/* remove empty spaces */
 	while ((SPACE_ASCII_VALUE == *cmdPtr) && ('\0' != *cmdPtr))
@@ -1319,11 +1319,11 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 	/* Dialog token of radio meas req containing meas reqIE */
 	ret = sscanf(cmdPtr, "%31s ", buf);
 	if (1 != ret)
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
 	ret = kstrtos32(buf, 10, &content);
 	if (ret < 0)
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
 	pPlmRequest->diag_token = content;
 	hddLog(CDF_TRACE_LEVEL_DEBUG, "diag token %d",
@@ -1331,7 +1331,7 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 	cmdPtr = strpbrk(cmdPtr, " ");
 
 	if (NULL == cmdPtr)
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
 	/* remove empty spaces */
 	while ((SPACE_ASCII_VALUE == *cmdPtr) && ('\0' != *cmdPtr))
@@ -1340,11 +1340,11 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 	/* measurement token of meas req IE */
 	ret = sscanf(cmdPtr, "%31s ", buf);
 	if (1 != ret)
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
 	ret = kstrtos32(buf, 10, &content);
 	if (ret < 0)
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
 	pPlmRequest->meas_token = content;
 	hddLog(CDF_TRACE_LEVEL_DEBUG, "meas token %d",
@@ -1357,7 +1357,7 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 		cmdPtr = strpbrk(cmdPtr, " ");
 
 		if (NULL == cmdPtr)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		/* remove empty spaces */
 		while ((SPACE_ASCII_VALUE == *cmdPtr) && ('\0' != *cmdPtr))
@@ -1366,14 +1366,14 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 		/* total number of bursts after which STA stops sending */
 		ret = sscanf(cmdPtr, "%31s ", buf);
 		if (1 != ret)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		ret = kstrtos32(buf, 10, &content);
 		if (ret < 0)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		if (content < 0)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		pPlmRequest->numBursts = content;
 		hddLog(CDF_TRACE_LEVEL_DEBUG, "num burst %d",
@@ -1381,7 +1381,7 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 		cmdPtr = strpbrk(cmdPtr, " ");
 
 		if (NULL == cmdPtr)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		/* remove empty spaces */
 		while ((SPACE_ASCII_VALUE == *cmdPtr) && ('\0' != *cmdPtr))
@@ -1390,14 +1390,14 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 		/* burst interval in seconds */
 		ret = sscanf(cmdPtr, "%31s ", buf);
 		if (1 != ret)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		ret = kstrtos32(buf, 10, &content);
 		if (ret < 0)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		if (content <= 0)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		pPlmRequest->burstInt = content;
 		hddLog(CDF_TRACE_LEVEL_DEBUG, "burst Int %d",
@@ -1405,7 +1405,7 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 		cmdPtr = strpbrk(cmdPtr, " ");
 
 		if (NULL == cmdPtr)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		/* remove empty spaces */
 		while ((SPACE_ASCII_VALUE == *cmdPtr) && ('\0' != *cmdPtr))
@@ -1414,14 +1414,14 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 		/* Meas dur in TU's,STA goes off-ch and transmit PLM bursts */
 		ret = sscanf(cmdPtr, "%31s ", buf);
 		if (1 != ret)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		ret = kstrtos32(buf, 10, &content);
 		if (ret < 0)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		if (content <= 0)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		pPlmRequest->measDuration = content;
 		hddLog(CDF_TRACE_LEVEL_DEBUG, "measDur %d",
@@ -1429,7 +1429,7 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 		cmdPtr = strpbrk(cmdPtr, " ");
 
 		if (NULL == cmdPtr)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		/* remove empty spaces */
 		while ((SPACE_ASCII_VALUE == *cmdPtr) && ('\0' != *cmdPtr))
@@ -1438,14 +1438,14 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 		/* burst length of PLM bursts */
 		ret = sscanf(cmdPtr, "%31s ", buf);
 		if (1 != ret)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		ret = kstrtos32(buf, 10, &content);
 		if (ret < 0)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		if (content <= 0)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		pPlmRequest->burstLen = content;
 		hddLog(CDF_TRACE_LEVEL_DEBUG, "burstLen %d",
@@ -1453,7 +1453,7 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 		cmdPtr = strpbrk(cmdPtr, " ");
 
 		if (NULL == cmdPtr)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		/* remove empty spaces */
 		while ((SPACE_ASCII_VALUE == *cmdPtr) && ('\0' != *cmdPtr))
@@ -1462,14 +1462,14 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 		/* desired tx power for transmission of PLM bursts */
 		ret = sscanf(cmdPtr, "%31s ", buf);
 		if (1 != ret)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		ret = kstrtos32(buf, 10, &content);
 		if (ret < 0)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		if (content <= 0)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		pPlmRequest->desiredTxPwr = content;
 		hddLog(CDF_TRACE_LEVEL_DEBUG,
@@ -1479,7 +1479,7 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 			cmdPtr = strpbrk(cmdPtr, " ");
 
 			if (NULL == cmdPtr)
-				return CDF_STATUS_E_FAILURE;
+				return QDF_STATUS_E_FAILURE;
 
 			/* remove empty spaces */
 			while ((SPACE_ASCII_VALUE == *cmdPtr)
@@ -1488,11 +1488,11 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 
 			ret = sscanf(cmdPtr, "%31s ", buf);
 			if (1 != ret)
-				return CDF_STATUS_E_FAILURE;
+				return QDF_STATUS_E_FAILURE;
 
 			ret = kstrtos32(buf, 16, &content);
 			if (ret < 0)
-				return CDF_STATUS_E_FAILURE;
+				return QDF_STATUS_E_FAILURE;
 
 			pPlmRequest->mac_addr.bytes[count] = content;
 		}
@@ -1503,7 +1503,7 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 		cmdPtr = strpbrk(cmdPtr, " ");
 
 		if (NULL == cmdPtr)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		/* remove empty spaces */
 		while ((SPACE_ASCII_VALUE == *cmdPtr) && ('\0' != *cmdPtr))
@@ -1512,14 +1512,14 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 		/* number of channels */
 		ret = sscanf(cmdPtr, "%31s ", buf);
 		if (1 != ret)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		ret = kstrtos32(buf, 10, &content);
 		if (ret < 0)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		if (content < 0)
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 
 		pPlmRequest->plmNumCh = content;
 		hddLog(CDF_TRACE_LEVEL_DEBUG, "numch %d",
@@ -1530,7 +1530,7 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 			cmdPtr = strpbrk(cmdPtr, " ");
 
 			if (NULL == cmdPtr)
-				return CDF_STATUS_E_FAILURE;
+				return QDF_STATUS_E_FAILURE;
 
 			/* remove empty spaces */
 			while ((SPACE_ASCII_VALUE == *cmdPtr)
@@ -1539,14 +1539,14 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 
 			ret = sscanf(cmdPtr, "%31s ", buf);
 			if (1 != ret)
-				return CDF_STATUS_E_FAILURE;
+				return QDF_STATUS_E_FAILURE;
 
 			ret = kstrtos32(buf, 10, &content);
 			if (ret < 0)
-				return CDF_STATUS_E_FAILURE;
+				return QDF_STATUS_E_FAILURE;
 
 			if (content <= 0)
-				return CDF_STATUS_E_FAILURE;
+				return QDF_STATUS_E_FAILURE;
 
 			pPlmRequest->plmChList[count] = content;
 			hddLog(CDF_TRACE_LEVEL_DEBUG, " ch- %d",
@@ -1554,7 +1554,7 @@ CDF_STATUS hdd_parse_plm_cmd(uint8_t *pValue, tSirPlmReq *pPlmRequest)
 		}
 	}
 	/* If PLM START */
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 #endif
 
@@ -1577,7 +1577,7 @@ static int hdd_enable_ext_wow(hdd_adapter_t *adapter,
 			      tpSirExtWoWParams arg_params)
 {
 	tSirExtWoWParams params;
-	CDF_STATUS cdf_ret_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS cdf_ret_status = QDF_STATUS_E_FAILURE;
 	hdd_context_t *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
 	tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(adapter);
 	int rc;
@@ -1589,7 +1589,7 @@ static int hdd_enable_ext_wow(hdd_adapter_t *adapter,
 	cdf_ret_status = sme_configure_ext_wow(hHal, &params,
 						&wlan_hdd_ready_to_extwow,
 						hdd_ctx);
-	if (CDF_STATUS_SUCCESS != cdf_ret_status) {
+	if (QDF_STATUS_SUCCESS != cdf_ret_status) {
 		hddLog(CDF_TRACE_LEVEL_ERROR,
 		       FL("sme_configure_ext_wow returned failure %d"),
 		       cdf_ret_status);
@@ -1621,7 +1621,7 @@ static int hdd_enable_ext_wow(hdd_adapter_t *adapter,
 				return rc;
 			}
 			cdf_ret_status = wlan_hdd_bus_suspend(state);
-			if (cdf_ret_status != CDF_STATUS_SUCCESS) {
+			if (cdf_ret_status != QDF_STATUS_SUCCESS) {
 				CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 					"%s: wlan_hdd_suspend failed, status = %d",
 					__func__, cdf_ret_status);
@@ -1685,12 +1685,12 @@ static int hdd_set_app_type1_params(tHalHandle hHal,
 				    tpSirAppType1Params arg_params)
 {
 	tSirAppType1Params params;
-	CDF_STATUS cdf_ret_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS cdf_ret_status = QDF_STATUS_E_FAILURE;
 
 	cdf_mem_copy(&params, arg_params, sizeof(params));
 
 	cdf_ret_status = sme_configure_app_type1_params(hHal, &params);
-	if (CDF_STATUS_SUCCESS != cdf_ret_status) {
+	if (QDF_STATUS_SUCCESS != cdf_ret_status) {
 		hddLog(CDF_TRACE_LEVEL_ERROR,
 		       FL("sme_configure_app_type1_params returned failure %d"),
 		       cdf_ret_status);
@@ -1743,12 +1743,12 @@ static int hdd_set_app_type2_params(tHalHandle hHal,
 				    tpSirAppType2Params arg_params)
 {
 	tSirAppType2Params params;
-	CDF_STATUS cdf_ret_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS cdf_ret_status = QDF_STATUS_E_FAILURE;
 
 	cdf_mem_copy(&params, arg_params, sizeof(params));
 
 	cdf_ret_status = sme_configure_app_type2_params(hHal, &params);
-	if (CDF_STATUS_SUCCESS != cdf_ret_status) {
+	if (QDF_STATUS_SUCCESS != cdf_ret_status) {
 		hddLog(CDF_TRACE_LEVEL_ERROR,
 		       FL("sme_configure_app_type2_params returned failure %d"),
 		       cdf_ret_status);
@@ -2105,7 +2105,7 @@ static int wlan_hdd_get_link_status(hdd_adapter_t *adapter)
 	hdd_station_ctx_t *pHddStaCtx =
 				WLAN_HDD_GET_STATION_CTX_PTR(adapter);
 	struct statsContext context;
-	CDF_STATUS hstatus;
+	QDF_STATUS hstatus;
 	unsigned long rc;
 
 	if (cds_is_driver_recovering()) {
@@ -2137,7 +2137,7 @@ static int wlan_hdd_get_link_status(hdd_adapter_t *adapter)
 	hstatus = sme_get_link_status(WLAN_HDD_GET_HAL_CTX(adapter),
 				      hdd_get_link_status_cb,
 				      &context, adapter->sessionId);
-	if (CDF_STATUS_SUCCESS != hstatus) {
+	if (QDF_STATUS_SUCCESS != hstatus) {
 		hddLog(CDF_TRACE_LEVEL_ERROR,
 		       "%s: Unable to retrieve link status", __func__);
 		/* return a cached value */
@@ -2399,7 +2399,7 @@ static int hdd_parse_get_cckm_ie(uint8_t *pValue, uint8_t **pCckmIe,
 int wlan_hdd_set_mc_rate(hdd_adapter_t *pAdapter, int targetRate)
 {
 	tSirRateUpdateInd rateUpdate = {0};
-	CDF_STATUS status;
+	QDF_STATUS status;
 	hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
 	struct hdd_config *pConfig = NULL;
 
@@ -2433,7 +2433,7 @@ int wlan_hdd_set_mc_rate(hdd_adapter_t *pAdapter, int targetRate)
 		hdd_device_mode_to_string(pAdapter->device_mode),
 		pAdapter->device_mode);
 	status = sme_send_rate_update_ind(pHddCtx->hHal, &rateUpdate);
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		hddLog(CDF_TRACE_LEVEL_ERROR, "%s: SETMCRATE failed",
 		       __func__);
 		return -EFAULT;
@@ -2557,7 +2557,7 @@ static int drv_cmd_country(hdd_adapter_t *adapter,
 			   hdd_priv_data_t *priv_data)
 {
 	int ret = 0;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	unsigned long rc;
 	char *country_code;
 
@@ -2572,7 +2572,7 @@ static int drv_cmd_country(hdd_adapter_t *adapter,
 			hdd_ctx->pcds_context,
 			eSIR_TRUE,
 			eSIR_TRUE);
-	if (status == CDF_STATUS_SUCCESS) {
+	if (status == QDF_STATUS_SUCCESS) {
 		rc = wait_for_completion_timeout(
 			&adapter->change_country_code,
 			 msecs_to_jiffies(WLAN_WAIT_TIME_COUNTRY));
@@ -2600,7 +2600,7 @@ static int drv_cmd_set_roam_trigger(hdd_adapter_t *adapter,
 	uint8_t *value = command;
 	int8_t rssi = 0;
 	uint8_t lookUpThreshold = CFG_NEIGHBOR_LOOKUP_RSSI_THRESHOLD_DEFAULT;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	/* Move pointer to ahead of SETROAMTRIGGER<delimiter> */
 	value = value + command_len + 1;
@@ -2648,7 +2648,7 @@ static int drv_cmd_set_roam_trigger(hdd_adapter_t *adapter,
 	status = sme_set_neighbor_lookup_rssi_threshold(hdd_ctx->hHal,
 							adapter->sessionId,
 							lookUpThreshold);
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		CDF_TRACE(CDF_MODULE_ID_HDD,
 			  CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to set roam trigger, try again",
@@ -3131,7 +3131,7 @@ static int drv_cmd_get_roam_scan_channels(hdd_adapter_t *adapter,
 	char extra[128] = { 0 };
 	int len;
 
-	if (CDF_STATUS_SUCCESS !=
+	if (QDF_STATUS_SUCCESS !=
 		sme_get_roam_scan_channel_list(hdd_ctx->hHal,
 					       ChannelList,
 					       &numChannels,
@@ -4160,7 +4160,7 @@ static void hdd_wma_send_fastreassoc_cmd(int sessionId, tSirMacAddr bssid,
 	msg.type = SIR_HAL_ROAM_INVOKE;
 	msg.reserved = 0;
 	msg.bodyptr = fastreassoc;
-	if (CDF_STATUS_SUCCESS != cds_mq_post_message(CDF_MODULE_ID_WMA,
+	if (QDF_STATUS_SUCCESS != cds_mq_post_message(CDF_MODULE_ID_WMA,
 								&msg)) {
 		cdf_mem_free(fastreassoc);
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
@@ -4237,7 +4237,7 @@ static int drv_cmd_fast_reassoc(hdd_adapter_t *adapter,
 	}
 
 	/* Check channel number is a valid channel number */
-	if (CDF_STATUS_SUCCESS !=
+	if (QDF_STATUS_SUCCESS !=
 		wlan_hdd_validate_operation_channel(adapter, channel)) {
 		hddLog(LOGE, FL("Invalid Channel [%d]"), channel);
 		return -EINVAL;
@@ -4272,7 +4272,7 @@ static int drv_cmd_ccx_plm_req(hdd_adapter_t *adapter,
 {
 	int ret = 0;
 	uint8_t *value = command;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	tpSirPlmReq pPlmRequest = NULL;
 
 	pPlmRequest = cdf_mem_malloc(sizeof(tSirPlmReq));
@@ -4282,7 +4282,7 @@ static int drv_cmd_ccx_plm_req(hdd_adapter_t *adapter,
 	}
 
 	status = hdd_parse_plm_cmd(value, pPlmRequest);
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		cdf_mem_free(pPlmRequest);
 		pPlmRequest = NULL;
 		ret = -EINVAL;
@@ -4291,7 +4291,7 @@ static int drv_cmd_ccx_plm_req(hdd_adapter_t *adapter,
 	pPlmRequest->sessionId = adapter->sessionId;
 
 	status = sme_set_plm_request(hdd_ctx->hHal, pPlmRequest);
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		cdf_mem_free(pPlmRequest);
 		pPlmRequest = NULL;
 		ret = -EINVAL;
@@ -4600,7 +4600,7 @@ static int drv_cmd_miracast(hdd_adapter_t *adapter,
 			    uint8_t command_len,
 			    hdd_priv_data_t *priv_data)
 {
-	CDF_STATUS ret_status;
+	QDF_STATUS ret_status;
 	int ret = 0;
 	tHalHandle hHal;
 	uint8_t filterType = 0;
@@ -4646,7 +4646,7 @@ static int drv_cmd_miracast(hdd_adapter_t *adapter,
 	pHddCtx->miracast_value = filterType;
 
 	ret_status = sme_set_miracast(hHal, filterType);
-	if (CDF_STATUS_SUCCESS != ret_status) {
+	if (QDF_STATUS_SUCCESS != ret_status) {
 		hddLog(LOGE, "Failed to set miracast");
 		return -EBUSY;
 	}
@@ -4669,7 +4669,7 @@ static int drv_cmd_set_ccx_roam_scan_channels(hdd_adapter_t *adapter,
 	uint8_t *value = command;
 	uint8_t ChannelList[WNI_CFG_VALID_CHANNEL_LIST_LEN] = { 0 };
 	uint8_t numChannels = 0;
-	CDF_STATUS status;
+	QDF_STATUS status;
 
 	ret = hdd_parse_channellist(value, ChannelList, &numChannels);
 	if (ret) {
@@ -4693,7 +4693,7 @@ static int drv_cmd_set_ccx_roam_scan_channels(hdd_adapter_t *adapter,
 						    adapter->sessionId,
 						    ChannelList,
 						    numChannels);
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		CDF_TRACE(CDF_MODULE_ID_HDD,
 			  CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to update channel list information",
@@ -4769,7 +4769,7 @@ static int drv_cmd_get_tsm_stats(hdd_adapter_t *adapter,
 		  CDF_TRACE_LEVEL_INFO,
 		  "%s: Received Command to get tsm stats tid = %d",
 		  __func__, tid);
-	if (CDF_STATUS_SUCCESS !=
+	if (QDF_STATUS_SUCCESS !=
 	    hdd_get_tsm_stats(adapter, tid, &tsm_metrics)) {
 		CDF_TRACE(CDF_MODULE_ID_HDD,
 			  CDF_TRACE_LEVEL_ERROR,
@@ -4878,7 +4878,7 @@ static int drv_cmd_ccx_beacon_req(hdd_adapter_t *adapter,
 	int ret;
 	uint8_t *value = command;
 	tCsrEseBeaconReq eseBcnReq;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	if (WLAN_HDD_INFRA_STATION != adapter->device_mode) {
 		hdd_warn("Unsupported in mode %s(%d)",
@@ -4909,13 +4909,13 @@ static int drv_cmd_ccx_beacon_req(hdd_adapter_t *adapter,
 					    adapter->sessionId,
 					    &eseBcnReq);
 
-	if (CDF_STATUS_E_RESOURCES == status) {
+	if (QDF_STATUS_E_RESOURCES == status) {
 		hddLog(CDF_TRACE_LEVEL_INFO,
 		       FL("sme_set_ese_beacon_request failed (%d), a request already in progress"),
 		       status);
 		ret = -EBUSY;
 		goto exit;
-	} else if (CDF_STATUS_SUCCESS != status) {
+	} else if (QDF_STATUS_SUCCESS != status) {
 		CDF_TRACE(CDF_MODULE_ID_HDD,
 			  CDF_TRACE_LEVEL_ERROR,
 			  "%s: sme_set_ese_beacon_request failed (%d)",
@@ -4960,8 +4960,8 @@ static int drv_cmd_max_tx_power(hdd_adapter_t *adapter,
 	int ret = 0;
 	int status;
 	int txPower;
-	CDF_STATUS cdf_status;
-	CDF_STATUS smeStatus;
+	QDF_STATUS qdf_status;
+	QDF_STATUS smeStatus;
 	uint8_t *value = command;
 	struct cdf_mac_addr bssid = CDF_MAC_ADDR_BROADCAST_INITIALIZER;
 	struct cdf_mac_addr selfMac = CDF_MAC_ADDR_BROADCAST_INITIALIZER;
@@ -4977,9 +4977,9 @@ static int drv_cmd_max_tx_power(hdd_adapter_t *adapter,
 		goto exit;
 	}
 
-	cdf_status = hdd_get_front_adapter(hdd_ctx, &pAdapterNode);
+	qdf_status = hdd_get_front_adapter(hdd_ctx, &pAdapterNode);
 	while (NULL != pAdapterNode
-	       && CDF_STATUS_SUCCESS == cdf_status) {
+	       && QDF_STATUS_SUCCESS == qdf_status) {
 		adapter = pAdapterNode->pAdapter;
 		/* Assign correct self MAC address */
 		cdf_copy_macaddr(&bssid,
@@ -4995,7 +4995,7 @@ static int drv_cmd_max_tx_power(hdd_adapter_t *adapter,
 
 		smeStatus = sme_set_max_tx_power(hdd_ctx->hHal,
 						 bssid, selfMac, txPower);
-		if (CDF_STATUS_SUCCESS != status) {
+		if (QDF_STATUS_SUCCESS != status) {
 			hddLog(CDF_TRACE_LEVEL_ERROR,
 			       "%s:Set max tx power failed",
 			       __func__);
@@ -5005,7 +5005,7 @@ static int drv_cmd_max_tx_power(hdd_adapter_t *adapter,
 		hddLog(CDF_TRACE_LEVEL_INFO,
 		       "%s: Set max tx power success",
 		       __func__);
-		cdf_status = hdd_get_next_adapter(hdd_ctx, pAdapterNode,
+		qdf_status = hdd_get_next_adapter(hdd_ctx, pAdapterNode,
 						  &pNext);
 		pAdapterNode = pNext;
 	}
@@ -5910,7 +5910,7 @@ static int drv_cmd_set_fcc_channel(hdd_adapter_t *adapter,
 {
 	uint8_t *value;
 	uint8_t fcc_constraint;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	int ret = 0;
 
 	/*
@@ -5936,7 +5936,7 @@ static int drv_cmd_set_fcc_channel(hdd_adapter_t *adapter,
 	}
 
 	status = sme_disable_non_fcc_channel(hdd_ctx->hHal, !fcc_constraint);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		hdd_err("sme disable fn. returned err");
 		ret = -EPERM;
 	}

core/hdd/src/wlan_hdd_ipa.c

@@ -1234,7 +1234,7 @@ static void
 hdd_ipa_uc_rm_notify_handler(void *context, enum ipa_rm_event event)
 {
 	struct hdd_ipa_priv *hdd_ipa = context;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	/*
 	 * When SSR is going on or driver is unloading, just return.
@@ -1354,7 +1354,7 @@ static void hdd_ipa_uc_op_cb(struct op_msg_type *op_msg, void *usr_ctxt)
 	struct IpaHwStatsWDIInfoData_t ipa_stat;
 	struct hdd_ipa_priv *hdd_ipa;
 	hdd_context_t *hdd_ctx;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	if (!op_msg || !usr_ctxt) {
 		HDD_IPA_LOG(CDF_TRACE_LEVEL_ERROR, "%s, INVALID ARG", __func__);
@@ -1664,7 +1664,7 @@ static void hdd_ipa_uc_offload_enable_disable(hdd_adapter_t *adapter,
 		ipa_offload_enable_disable.vdev_id,
 		ipa_offload_enable_disable.enable);
 
-	if (CDF_STATUS_SUCCESS !=
+	if (QDF_STATUS_SUCCESS !=
 		sme_ipa_offload_enable_disable(WLAN_HDD_GET_HAL_CTX(adapter),
 			adapter->sessionId, &ipa_offload_enable_disable)) {
 		HDD_IPA_LOG(CDF_TRACE_LEVEL_ERROR,
@@ -1716,7 +1716,7 @@ static void hdd_ipa_uc_op_event_handler(uint8_t *op_msg, void *hdd_ctx)
 	struct hdd_ipa_priv *hdd_ipa;
 	struct op_msg_type *msg;
 	struct uc_op_work_struct *uc_op_work;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	status = wlan_hdd_validate_context(hdd_ctx);
 	if (0 != status) {
@@ -1775,9 +1775,9 @@ static void hdd_ipa_init_uc_op_work(struct work_struct *work,
  * hdd_ipa_uc_ol_init() - Initialize IPA uC offload
  * @hdd_ctx: Global HDD context
  *
- * Return: CDF_STATUS
+ * Return: QDF_STATUS
  */
-static CDF_STATUS hdd_ipa_uc_ol_init(hdd_context_t *hdd_ctx)
+static QDF_STATUS hdd_ipa_uc_ol_init(hdd_context_t *hdd_ctx)
 {
 	struct ipa_wdi_in_params pipe_in;
 	struct ipa_wdi_out_params pipe_out;
@@ -1879,7 +1879,7 @@ static CDF_STATUS hdd_ipa_uc_ol_init(hdd_context_t *hdd_ctx)
 		ipa_ctxt->uc_op_work[i].msg = NULL;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -2827,7 +2827,7 @@ static void hdd_ipa_i2w_cb(void *priv, enum ipa_dp_evt_type evt,
 	struct hdd_ipa_iface_context *iface_context;
 	cdf_nbuf_t skb;
 	struct hdd_ipa_pm_tx_cb *pm_tx_cb = NULL;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	iface_context = (struct hdd_ipa_iface_context *)priv;
 	if (evt != IPA_RECEIVE) {
@@ -3511,7 +3511,7 @@ static void hdd_ipa_msg_free_fn(void *buff, uint32_t len, uint32_t type)
 int hdd_ipa_send_mcc_scc_msg(hdd_context_t *pHddCtx, bool mcc_mode)
 {
 	hdd_adapter_list_node_t *adapter_node = NULL, *next = NULL;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	hdd_adapter_t *pAdapter;
 	struct ipa_msg_meta meta;
 	struct ipa_wlan_msg *msg;
@@ -3523,7 +3523,7 @@ int hdd_ipa_send_mcc_scc_msg(hdd_context_t *pHddCtx, bool mcc_mode)
 	if (!pHddCtx->mcc_mode) {
 		/* Flush TxRx queue for each adapter before switch to SCC */
 		status =  hdd_get_front_adapter(pHddCtx, &adapter_node);
-		while (NULL != adapter_node && CDF_STATUS_SUCCESS == status) {
+		while (NULL != adapter_node && QDF_STATUS_SUCCESS == status) {
 			pAdapter = adapter_node->pAdapter;
 			if (pAdapter->device_mode == WLAN_HDD_INFRA_STATION ||
 				pAdapter->device_mode == WLAN_HDD_SOFTAP) {
@@ -4002,16 +4002,16 @@ static inline char *hdd_ipa_rm_state_to_str(enum hdd_ipa_rm_state state)
  * Allocate hdd_ipa resources, ipa pipe resource and register
  * wlan interface with IPA module.
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_ipa_init(hdd_context_t *hdd_ctx)
+QDF_STATUS hdd_ipa_init(hdd_context_t *hdd_ctx)
 {
 	struct hdd_ipa_priv *hdd_ipa = NULL;
 	int ret, i;
 	struct hdd_ipa_iface_context *iface_context = NULL;
 
 	if (!hdd_ipa_is_enabled(hdd_ctx))
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 
 	hdd_ipa = cdf_mem_malloc(sizeof(*hdd_ipa));
 	if (!hdd_ipa) {
@@ -4097,7 +4097,7 @@ CDF_STATUS hdd_ipa_init(hdd_context_t *hdd_ctx)
 			goto fail_create_sys_pipe;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 
 fail_create_sys_pipe:
 	hdd_ipa_destroy_rm_resource(hdd_ipa);
@@ -4108,7 +4108,7 @@ fail_get_resource:
 	hdd_ctx->hdd_ipa = NULL;
 	ghdd_ipa = NULL;
 fail_return:
-	return CDF_STATUS_E_FAILURE;
+	return QDF_STATUS_E_FAILURE;
 }
 
 /**
@@ -4133,9 +4133,9 @@ void hdd_ipa_cleanup_pending_event(struct hdd_ipa_priv *hdd_ipa)
  * hdd_ipa_cleanup - IPA cleanup function
  * @hdd_ctx: HDD global context
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_ipa_cleanup(hdd_context_t *hdd_ctx)
+QDF_STATUS hdd_ipa_cleanup(hdd_context_t *hdd_ctx)
 {
 	struct hdd_ipa_priv *hdd_ipa = hdd_ctx->hdd_ipa;
 	int i;
@@ -4144,7 +4144,7 @@ CDF_STATUS hdd_ipa_cleanup(hdd_context_t *hdd_ctx)
 	struct hdd_ipa_pm_tx_cb *pm_tx_cb = NULL;
 
 	if (!hdd_ipa_is_enabled(hdd_ctx))
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 
 	if (!hdd_ipa_uc_is_enabled(hdd_ctx)) {
 		unregister_inetaddr_notifier(&hdd_ipa->ipv4_notifier);
@@ -4222,6 +4222,6 @@ CDF_STATUS hdd_ipa_cleanup(hdd_context_t *hdd_ctx)
 	cdf_mem_free(hdd_ipa);
 	hdd_ctx->hdd_ipa = NULL;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 #endif /* IPA_OFFLOAD */

core/hdd/src/wlan_hdd_memdump.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -197,7 +197,7 @@ static int __wlan_hdd_cfg80211_get_fw_mem_dump(struct wiphy *wiphy,
 					       const void *data, int data_len)
 {
 	int status;
-	CDF_STATUS sme_status;
+	QDF_STATUS sme_status;
 	hdd_context_t *hdd_ctx = wiphy_priv(wiphy);
 	struct fw_dump_req fw_mem_dump_req;
 	struct fw_dump_seg_req *seg_req;
@@ -296,7 +296,7 @@ static int __wlan_hdd_cfg80211_get_fw_mem_dump(struct wiphy *wiphy,
 	spin_unlock(&hdd_context_lock);
 
 	sme_status = sme_fw_mem_dump(hdd_ctx->hHal, &fw_mem_dump_req);
-	if (CDF_STATUS_SUCCESS != sme_status) {
+	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,
@@ -539,8 +539,8 @@ int memdump_init(void)
 {
 	hdd_context_t *hdd_ctx;
 	int status = 0;
-	CDF_STATUS cb_status;
-	CDF_STATUS cdf_status;
+	QDF_STATUS cb_status;
+	QDF_STATUS qdf_status;
 
 	hdd_ctx = cds_get_context(CDF_MODULE_ID_HDD);
 	if (!hdd_ctx) {
@@ -555,7 +555,7 @@ int memdump_init(void)
 
 	cb_status = sme_fw_mem_dump_register_cb(hdd_ctx->hHal,
 				wlan_hdd_cfg80211_fw_mem_dump_cb);
-	if (CDF_STATUS_SUCCESS != cb_status) {
+	if (QDF_STATUS_SUCCESS != cb_status) {
 		hddLog(LOGE , FL("Failed to register the callback"));
 		return -EINVAL;
 	}
@@ -568,10 +568,10 @@ int memdump_init(void)
 
 	init_completion(&fw_dump_context.response_event);
 
-	cdf_status = cdf_mc_timer_init(&hdd_ctx->memdump_cleanup_timer,
+	qdf_status = cdf_mc_timer_init(&hdd_ctx->memdump_cleanup_timer,
 				    CDF_TIMER_TYPE_SW, memdump_cleanup_timer_cb,
 				    (void *)hdd_ctx);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		hddLog(LOGE, FL("Failed to init memdump cleanup timer"));
 		return -EINVAL;
 	}
@@ -594,7 +594,7 @@ void memdump_deinit(void)
 	cdf_dma_addr_t paddr;
 	cdf_dma_addr_t dma_ctx = 0;
 	cdf_device_t cdf_ctx;
-	CDF_STATUS cdf_status;
+	QDF_STATUS qdf_status;
 
 	hdd_ctx = cds_get_context(CDF_MODULE_ID_HDD);
 	if (!hdd_ctx) {
@@ -631,7 +631,7 @@ void memdump_deinit(void)
 		cdf_mc_timer_stop(&hdd_ctx->memdump_cleanup_timer);
 	}
 
-	cdf_status = cdf_mc_timer_destroy(&hdd_ctx->memdump_cleanup_timer);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status))
+	qdf_status = cdf_mc_timer_destroy(&hdd_ctx->memdump_cleanup_timer);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status))
 		hddLog(LOGE, FL("Failed to deallocate timer"));
 }

core/hdd/src/wlan_hdd_nan.c

@@ -58,7 +58,7 @@ static int __wlan_hdd_cfg80211_nan_request(struct wiphy *wiphy,
 					   int data_len)
 {
 	tNanRequestReq nan_req;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	int ret_val;
 	hdd_context_t *hdd_ctx = wiphy_priv(wiphy);
 
@@ -82,7 +82,7 @@ static int __wlan_hdd_cfg80211_nan_request(struct wiphy *wiphy,
 	nan_req.request_data = data;
 
 	status = sme_nan_request(&nan_req);
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		ret_val = -EINVAL;
 	}
 	return ret_val;

core/hdd/src/wlan_hdd_napi.c

@@ -121,7 +121,7 @@ int hdd_napi_create(void)
 		 * services/calls.
 		 * For Rome, there is only one service, hence a single call
 		 */
-		if (CDF_STATUS_SUCCESS !=
+		if (QDF_STATUS_SUCCESS !=
 		    hif_map_service_to_pipe(hif_ctx, HTT_DATA_MSG_SVC,
 					    &ul, &dl, &ul_polled, &dl_polled)) {
 			hdd_err("cannot map service to pipe");

core/hdd/src/wlan_hdd_ocb.c

@@ -241,16 +241,16 @@ static int hdd_ocb_validate_config(hdd_adapter_t *adapter,
  */
 static int hdd_ocb_register_sta(hdd_adapter_t *adapter)
 {
-	CDF_STATUS cdf_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS qdf_status = QDF_STATUS_E_FAILURE;
 	struct ol_txrx_desc_type sta_desc = {0};
 	hdd_context_t *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
 	hdd_station_ctx_t *pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(adapter);
 	uint8_t peer_id;
 
-	cdf_status = ol_txrx_register_ocb_peer(hdd_ctx->pcds_context,
+	qdf_status = ol_txrx_register_ocb_peer(hdd_ctx->pcds_context,
 					       adapter->macAddressCurrent.bytes,
 					       &peer_id);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		hddLog(LOGE, FL("Error registering OCB Self Peer!"));
 		return -EINVAL;
 	}
@@ -260,11 +260,11 @@ static int hdd_ocb_register_sta(hdd_adapter_t *adapter)
 	sta_desc.sta_id = peer_id;
 	sta_desc.is_qos_enabled = 1;
 
-	cdf_status = ol_txrx_register_peer(hdd_rx_packet_cbk,
+	qdf_status = ol_txrx_register_peer(hdd_rx_packet_cbk,
 						&sta_desc);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		hddLog(LOGE, FL("Failed to register. Status= %d [0x%08X]"),
-		       cdf_status, cdf_status);
+		       qdf_status, qdf_status);
 		return -EINVAL;
 	}
 
@@ -400,7 +400,7 @@ static int hdd_ocb_set_config_req(hdd_adapter_t *adapter,
 				  struct sir_ocb_config *config)
 {
 	int rc;
-	CDF_STATUS cdf_status;
+	QDF_STATUS qdf_status;
 	struct hdd_ocb_ctxt context = {0};
 
 	if (hdd_ocb_validate_config(adapter, config)) {
@@ -417,10 +417,10 @@ static int hdd_ocb_set_config_req(hdd_adapter_t *adapter,
 	netif_carrier_off(adapter->dev);
 
 	/* Call the SME API to set the config */
-	cdf_status = sme_ocb_set_config(
+	qdf_status = sme_ocb_set_config(
 		((hdd_context_t *)adapter->pHddCtx)->hHal, &context,
 		hdd_ocb_set_config_callback, config);
-	if (cdf_status != CDF_STATUS_SUCCESS) {
+	if (qdf_status != QDF_STATUS_SUCCESS) {
 		hddLog(LOGE, FL("Error calling SME function."));
 		/* Convert from ecdf_status to errno */
 		return -EINVAL;
@@ -1036,7 +1036,7 @@ static int __wlan_hdd_cfg80211_ocb_set_utc_time(struct wiphy *wiphy,
 	cdf_mem_copy(utc->time_error, nla_data(time_error_attr),
 		SIZE_UTC_TIME_ERROR);
 
-	if (sme_ocb_set_utc_time(hdd_ctx->hHal, utc) != CDF_STATUS_SUCCESS) {
+	if (sme_ocb_set_utc_time(hdd_ctx->hHal, utc) != QDF_STATUS_SUCCESS) {
 		hddLog(LOGE, FL("Error while setting UTC time"));
 		rc = -EINVAL;
 	} else {
@@ -1152,7 +1152,7 @@ __wlan_hdd_cfg80211_ocb_start_timing_advert(struct wiphy *wiphy,
 	}
 
 	if (sme_ocb_start_timing_advert(hdd_ctx->hHal, timing_advert) !=
-			CDF_STATUS_SUCCESS) {
+			QDF_STATUS_SUCCESS) {
 		hddLog(LOGE, FL("Error while starting timing advert"));
 		rc = -EINVAL;
 	} else {
@@ -1254,7 +1254,7 @@ __wlan_hdd_cfg80211_ocb_stop_timing_advert(struct wiphy *wiphy,
 		tb[QCA_WLAN_VENDOR_ATTR_OCB_STOP_TIMING_ADVERT_CHANNEL_FREQ]);
 
 	if (sme_ocb_stop_timing_advert(hdd_ctx->hHal, timing_advert) !=
-			CDF_STATUS_SUCCESS) {
+			QDF_STATUS_SUCCESS) {
 		hddLog(LOGE, FL("Error while stopping timing advert"));
 		rc = -EINVAL;
 	} else {
@@ -1586,7 +1586,7 @@ static int __wlan_hdd_cfg80211_dcc_get_stats(struct wiphy *wiphy,
 			       &request);
 	if (rc) {
 		hddLog(LOGE, FL("Error calling SME function"));
-		/* Need to convert from cdf_status to errno. */
+		/* Need to convert from qdf_status to errno. */
 		return -EINVAL;
 	}
 
@@ -1733,7 +1733,7 @@ static int __wlan_hdd_cfg80211_dcc_clear_stats(struct wiphy *wiphy,
 	if (sme_dcc_clear_stats(hdd_ctx->hHal, adapter->sessionId,
 		nla_get_u32(
 			tb[QCA_WLAN_VENDOR_ATTR_DCC_CLEAR_STATS_BITMAP])) !=
-			CDF_STATUS_SUCCESS) {
+			QDF_STATUS_SUCCESS) {
 		hddLog(LOGE, FL("Error calling SME function."));
 		return -EINVAL;
 	}
@@ -1882,7 +1882,7 @@ static int __wlan_hdd_cfg80211_dcc_update_ndl(struct wiphy *wiphy,
 				&request);
 	if (rc) {
 		hddLog(LOGE, FL("Error calling SME function."));
-		/* Convert from cdf_status to errno */
+		/* Convert from qdf_status to errno */
 		return -EINVAL;
 	}
 

core/hdd/src/wlan_hdd_oemdata.c

@@ -58,7 +58,7 @@ static struct hdd_context_s *p_hdd_ctx;
 static int populate_oem_data_cap(hdd_adapter_t *adapter,
 				 t_iw_oem_data_cap *data_cap)
 {
-	CDF_STATUS status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
 	struct hdd_config *config;
 	uint32_t num_chan;
 	uint8_t *chan_list;
@@ -97,7 +97,7 @@ static int populate_oem_data_cap(hdd_adapter_t *adapter,
 	num_chan = WNI_CFG_VALID_CHANNEL_LIST_LEN;
 	status = sme_get_cfg_valid_channels(hdd_ctx->hHal,
 					    &chan_list[0], &num_chan);
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		hdd_err("failed to get valid channel list, status: %d", status);
 		cdf_mem_free(chan_list);
 		return -EINVAL;
@@ -179,7 +179,7 @@ static void send_oem_reg_rsp_nlink_msg(void)
 	hdd_adapter_list_node_t *pAdapterNode = NULL;
 	hdd_adapter_list_node_t *pNext = NULL;
 	hdd_adapter_t *pAdapter = NULL;
-	CDF_STATUS status = 0;
+	QDF_STATUS status = 0;
 
 	/* OEM message is always to a specific process and cannot be a broadcast */
 	if (p_hdd_ctx->oem_pid == 0) {
@@ -215,7 +215,7 @@ static void send_oem_reg_rsp_nlink_msg(void)
 
 	/* Iterate through each of the adapters and fill device mode and vdev id */
 	status = hdd_get_front_adapter(p_hdd_ctx, &pAdapterNode);
-	while ((CDF_STATUS_SUCCESS == status) && pAdapterNode) {
+	while ((QDF_STATUS_SUCCESS == status) && pAdapterNode) {
 		pAdapter = pAdapterNode->pAdapter;
 		if (pAdapter) {
 			deviceMode = buf++;
@@ -364,27 +364,27 @@ void hdd_send_oem_data_rsp_msg(int length, uint8_t *oemDataRsp)
  *
  * This function sends oem message to SME
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-static CDF_STATUS oem_process_data_req_msg(int oemDataLen, char *oemData)
+static QDF_STATUS oem_process_data_req_msg(int oemDataLen, char *oemData)
 {
 	hdd_adapter_t *pAdapter = NULL;
 	tOemDataReqConfig oemDataReqConfig;
 	uint32_t oemDataReqID = 0;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	/* for now, STA interface only */
 	pAdapter = hdd_get_adapter(p_hdd_ctx, WLAN_HDD_INFRA_STATION);
 	if (!pAdapter) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  "%s: No adapter for STA mode", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	if (!oemData) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  "%s: oemData is null", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	cdf_mem_zero(&oemDataReqConfig, sizeof(tOemDataReqConfig));
@@ -392,7 +392,7 @@ static CDF_STATUS oem_process_data_req_msg(int oemDataLen, char *oemData)
 	oemDataReqConfig.data = cdf_mem_malloc(oemDataLen);
 	if (!oemDataReqConfig.data) {
 		hddLog(LOGE, FL("malloc failed for data req buffer"));
-		return CDF_STATUS_E_NOMEM;
+		return QDF_STATUS_E_NOMEM;
 	}
 
 	oemDataReqConfig.data_len = oemDataLen;
@@ -431,7 +431,7 @@ static int oem_process_channel_info_req_msg(int numOfChannels, char *chanList)
 	uint8_t chanId;
 	uint32_t reg_info_1;
 	uint32_t reg_info_2;
-	CDF_STATUS status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
 	int i;
 	uint8_t *buf;
 
@@ -479,7 +479,7 @@ static int oem_process_channel_info_req_msg(int numOfChannels, char *chanList)
 		chanId = chanList[i];
 		status = sme_get_reg_info(p_hdd_ctx->hHal, chanId,
 					  &reg_info_1, &reg_info_2);
-		if (CDF_STATUS_SUCCESS == status) {
+		if (QDF_STATUS_SUCCESS == status) {
 			/* copy into hdd chan info struct */
 			hddChanInfo.chan_id = chanId;
 			hddChanInfo.reserved0 = 0;
@@ -538,7 +538,7 @@ static int oem_process_channel_info_req_msg(int numOfChannels, char *chanList)
 static int oem_process_set_cap_req_msg(int oem_cap_len,
 				       char *oem_cap, int32_t app_pid)
 {
-	CDF_STATUS status;
+	QDF_STATUS status;
 	int error_code;
 	struct sk_buff *skb;
 	struct nlmsghdr *nlh;
@@ -552,7 +552,7 @@ static int oem_process_set_cap_req_msg(int oem_cap_len,
 
 	status = sme_oem_update_capability(p_hdd_ctx->hHal,
 					(struct sme_oem_capability *)oem_cap);
-	if (!CDF_IS_STATUS_SUCCESS(status))
+	if (!QDF_IS_STATUS_SUCCESS(status))
 		hdd_err("error updating rm capability, status: %d", status);
 	error_code = cdf_status_to_os_return(status);
 

core/hdd/src/wlan_hdd_p2p.c

@@ -160,8 +160,8 @@ static bool hdd_p2p_is_action_type_rsp(const u8 *buf)
 }
 
 static
-CDF_STATUS wlan_hdd_remain_on_channel_callback(tHalHandle hHal, void *pCtx,
-			CDF_STATUS status, uint32_t scan_id)
+QDF_STATUS wlan_hdd_remain_on_channel_callback(tHalHandle hHal, void *pCtx,
+			QDF_STATUS status, uint32_t scan_id)
 {
 	hdd_adapter_t *pAdapter = (hdd_adapter_t *) pCtx;
 	hdd_cfg80211_state_t *cfgState = WLAN_HDD_GET_CFG_STATE_PTR(pAdapter);
@@ -170,7 +170,7 @@ CDF_STATUS wlan_hdd_remain_on_channel_callback(tHalHandle hHal, void *pCtx,
 
 	if (!hdd_ctx) {
 		hdd_err("Invalid HDD context");
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	mutex_lock(&cfgState->remain_on_chan_ctx_lock);
@@ -181,7 +181,7 @@ CDF_STATUS wlan_hdd_remain_on_channel_callback(tHalHandle hHal, void *pCtx,
 		hddLog(LOGW,
 		       "%s: No Rem on channel pending for which Rsp is received",
 		       __func__);
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 
 	hddLog(LOG1, "Received remain on channel rsp");
@@ -266,9 +266,9 @@ CDF_STATUS wlan_hdd_remain_on_channel_callback(tHalHandle hHal, void *pCtx,
 	}
 	cdf_mem_free(pRemainChanCtx);
 	complete(&pAdapter->cancel_rem_on_chan_var);
-	if (CDF_STATUS_SUCCESS != status)
+	if (QDF_STATUS_SUCCESS != status)
 		complete(&pAdapter->rem_on_chan_ready_event);
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 void wlan_hdd_cancel_existing_remain_on_channel(hdd_adapter_t *pAdapter)
@@ -542,11 +542,11 @@ static int wlan_hdd_execute_remain_on_channel(hdd_adapter_t *pAdapter,
 		      hdd_remain_on_chan_ctx_t *pRemainChanCtx)
 {
 	hdd_cfg80211_state_t *cfgState = WLAN_HDD_GET_CFG_STATE_PTR(pAdapter);
-	CDF_STATUS cdf_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS qdf_status = QDF_STATUS_E_FAILURE;
 	hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
 	hdd_adapter_list_node_t *pAdapterNode = NULL, *pNext = NULL;
 	hdd_adapter_t *pAdapter_temp;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	bool isGoPresent = false;
 	unsigned int duration;
 
@@ -565,11 +565,11 @@ static int wlan_hdd_execute_remain_on_channel(hdd_adapter_t *pAdapter,
 	mutex_unlock(&cfgState->remain_on_chan_ctx_lock);
 
 	/* Initialize Remain on chan timer */
-	cdf_status =
+	qdf_status =
 		cdf_mc_timer_init(&pRemainChanCtx->hdd_remain_on_chan_timer,
 				  CDF_TIMER_TYPE_SW,
 				  wlan_hdd_remain_on_chan_timeout, pAdapter);
-	if (cdf_status != CDF_STATUS_SUCCESS) {
+	if (qdf_status != QDF_STATUS_SUCCESS) {
 		hddLog(CDF_TRACE_LEVEL_ERROR,
 		       FL("Not able to initialize remain_on_chan timer"));
 		mutex_lock(&cfgState->remain_on_chan_ctx_lock);
@@ -581,7 +581,7 @@ static int wlan_hdd_execute_remain_on_channel(hdd_adapter_t *pAdapter,
 	}
 
 	status = hdd_get_front_adapter(pHddCtx, &pAdapterNode);
-	while (NULL != pAdapterNode && CDF_STATUS_SUCCESS == status) {
+	while (NULL != pAdapterNode && QDF_STATUS_SUCCESS == status) {
 		pAdapter_temp = pAdapterNode->pAdapter;
 		if (pAdapter_temp->device_mode == WLAN_HDD_P2P_GO) {
 			isGoPresent = true;
@@ -608,7 +608,7 @@ static int wlan_hdd_execute_remain_on_channel(hdd_adapter_t *pAdapter,
 		uint8_t sessionId = pAdapter->sessionId;
 		/* call sme API to start remain on channel. */
 
-		if (CDF_STATUS_SUCCESS != sme_remain_on_channel(
+		if (QDF_STATUS_SUCCESS != sme_remain_on_channel(
 				WLAN_HDD_GET_HAL_CTX(pAdapter),
 				sessionId,
 				pRemainChanCtx->chan.hw_value, duration,
@@ -631,7 +631,7 @@ static int wlan_hdd_execute_remain_on_channel(hdd_adapter_t *pAdapter,
 
 		if (REMAIN_ON_CHANNEL_REQUEST ==
 		    pRemainChanCtx->rem_on_chan_request) {
-			if (CDF_STATUS_SUCCESS != sme_register_mgmt_frame(
+			if (QDF_STATUS_SUCCESS != sme_register_mgmt_frame(
 						WLAN_HDD_GET_HAL_CTX(pAdapter),
 						sessionId,
 						(SIR_MAC_MGMT_FRAME << 2) |
@@ -644,7 +644,7 @@ static int wlan_hdd_execute_remain_on_channel(hdd_adapter_t *pAdapter,
 	} else if ((WLAN_HDD_SOFTAP == pAdapter->device_mode) ||
 		   (WLAN_HDD_P2P_GO == pAdapter->device_mode)) {
 		/* call sme API to start remain on channel. */
-		if (CDF_STATUS_SUCCESS != wlansap_remain_on_channel(
+		if (QDF_STATUS_SUCCESS != wlansap_remain_on_channel(
 #ifdef WLAN_FEATURE_MBSSID
 			    WLAN_HDD_GET_SAP_CTX_PTR(pAdapter),
 #else
@@ -665,7 +665,7 @@ static int wlan_hdd_execute_remain_on_channel(hdd_adapter_t *pAdapter,
 			return -EINVAL;
 		}
 
-		if (CDF_STATUS_SUCCESS != wlansap_register_mgmt_frame(
+		if (QDF_STATUS_SUCCESS != wlansap_register_mgmt_frame(
 #ifdef WLAN_FEATURE_MBSSID
 			    WLAN_HDD_GET_SAP_CTX_PTR(pAdapter),
 #else
@@ -987,7 +987,7 @@ void hdd_remain_chan_ready_handler(hdd_adapter_t *pAdapter,
 {
 	hdd_cfg80211_state_t *cfgState = NULL;
 	hdd_remain_on_chan_ctx_t *pRemainChanCtx = NULL;
-	CDF_STATUS status;
+	QDF_STATUS status;
 
 	if (NULL == pAdapter) {
 		hddLog(LOGE, FL("pAdapter is NULL"));
@@ -1017,7 +1017,7 @@ void hdd_remain_chan_ready_handler(hdd_adapter_t *pAdapter,
 					   hdd_remain_on_chan_timer,
 					   (pRemainChanCtx->duration +
 					    COMPLETE_EVENT_PROPOGATE_TIME));
-		if (status != CDF_STATUS_SUCCESS) {
+		if (status != QDF_STATUS_SUCCESS) {
 			hddLog(LOGE, "%s: Remain on Channel timer start failed",
 			       __func__);
 		}
@@ -1430,7 +1430,7 @@ int __wlan_hdd_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
 							   remain_on_chan_ctx->
 							   hdd_remain_on_chan_timer,
 							   wait);
-				if (status != CDF_STATUS_SUCCESS) {
+				if (status != QDF_STATUS_SUCCESS) {
 					hddLog(LOGE,
 					       "%s: Remain on Channel timer start failed",
 					       __func__);
@@ -1572,7 +1572,7 @@ send_frame:
 			}
 		}
 
-		if (CDF_STATUS_SUCCESS !=
+		if (QDF_STATUS_SUCCESS !=
 		    sme_send_action(WLAN_HDD_GET_HAL_CTX(pAdapter),
 				    sessionId, buf, len, extendedWait, noack,
 				    current_freq)) {
@@ -1582,7 +1582,7 @@ send_frame:
 		}
 	} else if (WLAN_HDD_SOFTAP == pAdapter->device_mode ||
 		   WLAN_HDD_P2P_GO == pAdapter->device_mode) {
-		if (CDF_STATUS_SUCCESS !=
+		if (QDF_STATUS_SUCCESS !=
 #ifdef WLAN_FEATURE_MBSSID
 		    wlansap_send_action(WLAN_HDD_GET_SAP_CTX_PTR(pAdapter),
 #else
@@ -1896,7 +1896,7 @@ int hdd_set_p2p_ps(struct net_device *dev, void *msgData)
 {
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(pAdapter);
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	tP2pPsConfig NoA;
 	p2p_app_setP2pPs_t *pappNoA = (p2p_app_setP2pPs_t *) msgData;
 
@@ -2096,7 +2096,7 @@ void __hdd_indicate_mgmt_frame(hdd_adapter_t *pAdapter,
 	uint8_t subType = 0;
 	tActionFrmType actionFrmType;
 	hdd_cfg80211_state_t *cfgState = NULL;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	hdd_remain_on_chan_ctx_t *pRemainChanCtx = NULL;
 	hdd_context_t *pHddCtx;
 
@@ -2270,7 +2270,7 @@ void __hdd_indicate_mgmt_frame(hdd_adapter_t *pAdapter,
 										hdd_remain_on_chan_timer,
 										extend_time);
 								if (status !=
-								    CDF_STATUS_SUCCESS) {
+								    QDF_STATUS_SUCCESS) {
 									hddLog
 										(LOGE,
 										"%s: Remain on Channel timer start failed",

core/hdd/src/wlan_hdd_power.c

@@ -103,7 +103,7 @@ static bool ssr_timer_started;
 #ifdef WLAN_FEATURE_GTK_OFFLOAD
 static void hdd_conf_gtk_offload(hdd_adapter_t *pAdapter, bool fenable)
 {
-	CDF_STATUS ret;
+	QDF_STATUS ret;
 	tSirGtkOffloadParams hddGtkOffloadReqParams;
 	hdd_station_ctx_t *pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
 
@@ -119,7 +119,7 @@ static void hdd_conf_gtk_offload(hdd_adapter_t *pAdapter, bool fenable)
 			ret = sme_set_gtk_offload(WLAN_HDD_GET_HAL_CTX(pAdapter),
 						  &hddGtkOffloadReqParams,
 						  pAdapter->sessionId);
-			if (CDF_STATUS_SUCCESS != ret) {
+			if (QDF_STATUS_SUCCESS != ret) {
 				CDF_TRACE(CDF_MODULE_ID_HDD,
 					  CDF_TRACE_LEVEL_ERROR,
 					  "%s: sme_set_gtk_offload failed, returned %d",
@@ -145,7 +145,7 @@ static void hdd_conf_gtk_offload(hdd_adapter_t *pAdapter, bool fenable)
 				(WLAN_HDD_GET_HAL_CTX(pAdapter),
 				 wlan_hdd_cfg80211_update_replay_counter_callback,
 				 pAdapter, pAdapter->sessionId);
-			if (CDF_STATUS_SUCCESS != ret) {
+			if (QDF_STATUS_SUCCESS != ret) {
 				CDF_TRACE(CDF_MODULE_ID_HDD,
 					  CDF_TRACE_LEVEL_ERROR,
 					  "%s: sme_get_gtk_offload failed, returned %d",
@@ -168,7 +168,7 @@ static void hdd_conf_gtk_offload(hdd_adapter_t *pAdapter, bool fenable)
 								    (pAdapter),
 							    &hddGtkOffloadReqParams,
 							    pAdapter->sessionId);
-				if (CDF_STATUS_SUCCESS != ret) {
+				if (QDF_STATUS_SUCCESS != ret) {
 					CDF_TRACE(CDF_MODULE_ID_HDD,
 						  CDF_TRACE_LEVEL_ERROR,
 						  "%s: failed to dissable GTK offload, returned %d",
@@ -280,7 +280,7 @@ static void hdd_conf_ns_offload(hdd_adapter_t *pAdapter, bool fenable)
 	hdd_context_t *pHddCtx;
 
 	int i = 0;
-	CDF_STATUS returnStatus;
+	QDF_STATUS returnStatus;
 	uint32_t count = 0, scope;
 
 	ENTER();
@@ -394,7 +394,7 @@ static void hdd_conf_ns_offload(hdd_adapter_t *pAdapter, bool fenable)
 			/* Configure the Firmware with this */
 			returnStatus = sme_set_host_offload(WLAN_HDD_GET_HAL_CTX(pAdapter),
 				pAdapter->sessionId, &offLoadRequest);
-			if (CDF_STATUS_SUCCESS != returnStatus) {
+			if (QDF_STATUS_SUCCESS != returnStatus) {
 				hdd_err("Failed to enable HostOffload feature with status: %d",
 					returnStatus);
 			}
@@ -408,7 +408,7 @@ static void hdd_conf_ns_offload(hdd_adapter_t *pAdapter, bool fenable)
 		offLoadRequest.enableOrDisable = SIR_OFFLOAD_DISABLE;
 		offLoadRequest.offloadType =  SIR_IPV6_NS_OFFLOAD;
 
-		if (CDF_STATUS_SUCCESS !=
+		if (QDF_STATUS_SUCCESS !=
 			sme_set_host_offload(WLAN_HDD_GET_HAL_CTX(pAdapter),
 				pAdapter->sessionId, &offLoadRequest))
 				hdd_err("Failed to disable NS Offload");
@@ -679,10 +679,10 @@ int wlan_hdd_ipv4_changed(struct notifier_block *nb,
  * @fenable: true : enable ARP offload false : disable arp offload
  *
  * Return:
- *	CDF_STATUS_SUCCESS - on successful operation,
- *	CDF_STATUS_E_FAILURE - on failure of operation
+ *	QDF_STATUS_SUCCESS - on successful operation,
+ *	QDF_STATUS_E_FAILURE - on failure of operation
  */
-CDF_STATUS hdd_conf_arp_offload(hdd_adapter_t *pAdapter, bool fenable)
+QDF_STATUS hdd_conf_arp_offload(hdd_adapter_t *pAdapter, bool fenable)
 {
 	struct in_ifaddr **ifap = NULL;
 	struct in_ifaddr *ifa = NULL;
@@ -701,7 +701,7 @@ CDF_STATUS hdd_conf_arp_offload(hdd_adapter_t *pAdapter, bool fenable)
 		!pHddCtx->ap_arpns_support) {
 		hddLog(LOG1,
 			FL("ARP Offload is not supported in SAP/P2PGO mode"));
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 
 	if (fenable) {
@@ -749,36 +749,36 @@ CDF_STATUS hdd_conf_arp_offload(hdd_adapter_t *pAdapter, bool fenable)
 			       offLoadRequest.params.hostIpv4Addr[2],
 			       offLoadRequest.params.hostIpv4Addr[3]);
 
-			if (CDF_STATUS_SUCCESS !=
+			if (QDF_STATUS_SUCCESS !=
 			    sme_set_host_offload(WLAN_HDD_GET_HAL_CTX(pAdapter),
 						 pAdapter->sessionId,
 						 &offLoadRequest)) {
 				hddLog(CDF_TRACE_LEVEL_ERROR,
 				       "%s: Failed to enable HostOffload feature",
 				       __func__);
-				return CDF_STATUS_E_FAILURE;
+				return QDF_STATUS_E_FAILURE;
 			}
 		} else {
 			hddLog(CDF_TRACE_LEVEL_INFO,
 			       FL("IP Address is not assigned"));
 		}
 
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	} else {
 		cdf_mem_zero((void *)&offLoadRequest,
 			     sizeof(tSirHostOffloadReq));
 		offLoadRequest.enableOrDisable = SIR_OFFLOAD_DISABLE;
 		offLoadRequest.offloadType = SIR_IPV4_ARP_REPLY_OFFLOAD;
 
-		if (CDF_STATUS_SUCCESS !=
+		if (QDF_STATUS_SUCCESS !=
 		    sme_set_host_offload(WLAN_HDD_GET_HAL_CTX(pAdapter),
 					 pAdapter->sessionId, &offLoadRequest)) {
 			hddLog(CDF_TRACE_LEVEL_ERROR,
 			       "%s: Failure to disable host " "offload feature",
 			       __func__);
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 }
 
@@ -832,7 +832,7 @@ static void hdd_mcbc_filter_modification(hdd_context_t *pHddCtx,
  */
 void hdd_conf_mcastbcast_filter(hdd_context_t *pHddCtx, bool setfilter)
 {
-	CDF_STATUS cdf_ret_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS cdf_ret_status = QDF_STATUS_E_FAILURE;
 	tpSirWlanSetRxpFilters wlanRxpFilterParam =
 		cdf_mem_malloc(sizeof(tSirWlanSetRxpFilters));
 	if (NULL == wlanRxpFilterParam) {
@@ -857,17 +857,17 @@ void hdd_conf_mcastbcast_filter(hdd_context_t *pHddCtx, bool setfilter)
 	cdf_ret_status =
 		sme_configure_rxp_filter(pHddCtx->hHal, wlanRxpFilterParam);
 
-	if (setfilter && (CDF_STATUS_SUCCESS == cdf_ret_status))
+	if (setfilter && (QDF_STATUS_SUCCESS == cdf_ret_status))
 		pHddCtx->hdd_mcastbcast_filter_set = true;
 
 	hddLog(LOG1,
 		FL("%s to post set/reset filter to lower mac with status %d configuredMcstBcstFilterSetting = %d setMcstBcstFilter = %d"),
-		(CDF_STATUS_SUCCESS != cdf_ret_status) ? "Failed" : "Success",
+		(QDF_STATUS_SUCCESS != cdf_ret_status) ? "Failed" : "Success",
 		cdf_ret_status,
 		wlanRxpFilterParam->configuredMcstBcstFilterSetting,
 		wlanRxpFilterParam->setMcstBcstFilter);
 
-	if (CDF_STATUS_SUCCESS != cdf_ret_status)
+	if (QDF_STATUS_SUCCESS != cdf_ret_status)
 		cdf_mem_free(wlanRxpFilterParam);
 }
 
@@ -1001,7 +1001,7 @@ static void hdd_send_suspend_ind(hdd_context_t *pHddCtx,
 						  bool suspended),
 				 void *callbackContext)
 {
-	CDF_STATUS cdf_ret_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS cdf_ret_status = QDF_STATUS_E_FAILURE;
 
 	hdd_info("%s: send wlan suspend indication", __func__);
 
@@ -1009,7 +1009,7 @@ static void hdd_send_suspend_ind(hdd_context_t *pHddCtx,
 		sme_configure_suspend_ind(pHddCtx->hHal, conn_state_mask,
 					  callback, callbackContext);
 
-	if (CDF_STATUS_SUCCESS == cdf_ret_status) {
+	if (QDF_STATUS_SUCCESS == cdf_ret_status) {
 		pHddCtx->hdd_mcastbcast_filter_set = true;
 	} else {
 		hddLog(CDF_TRACE_LEVEL_ERROR,
@@ -1027,11 +1027,11 @@ static void hdd_send_suspend_ind(hdd_context_t *pHddCtx,
 static void hdd_conf_resume_ind(hdd_adapter_t *pAdapter)
 {
 	hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
-	CDF_STATUS cdf_ret_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS cdf_ret_status = QDF_STATUS_E_FAILURE;
 
 	cdf_ret_status = sme_configure_resume_req(pHddCtx->hHal, NULL);
 
-	if (CDF_STATUS_SUCCESS != cdf_ret_status) {
+	if (QDF_STATUS_SUCCESS != cdf_ret_status) {
 		hddLog(CDF_TRACE_LEVEL_ERROR,
 		       "%s: sme_configure_resume_req return failure %d",
 		       __func__, cdf_ret_status);
@@ -1090,7 +1090,7 @@ hdd_suspend_wlan(void (*callback)(void *callbackContext, bool suspended),
 {
 	hdd_context_t *pHddCtx;
 
-	CDF_STATUS status;
+	QDF_STATUS status;
 	hdd_adapter_t *pAdapter = NULL;
 	hdd_adapter_list_node_t *pAdapterNode = NULL, *pNext = NULL;
 	uint32_t conn_state_mask = 0;
@@ -1113,7 +1113,7 @@ hdd_suspend_wlan(void (*callback)(void *callbackContext, bool suspended),
 	hdd_update_mcastbcast_filter(pHddCtx);
 
 	status = hdd_get_front_adapter(pHddCtx, &pAdapterNode);
-	while (NULL != pAdapterNode && CDF_STATUS_SUCCESS == status) {
+	while (NULL != pAdapterNode && QDF_STATUS_SUCCESS == status) {
 		pAdapter = pAdapterNode->pAdapter;
 
 		/* stop all TX queues before suspend */
@@ -1149,7 +1149,7 @@ static void hdd_resume_wlan(void)
 	hdd_context_t *pHddCtx;
 	hdd_adapter_t *pAdapter = NULL;
 	hdd_adapter_list_node_t *pAdapterNode = NULL, *pNext = NULL;
-	CDF_STATUS status;
+	QDF_STATUS status;
 
 	hddLog(CDF_TRACE_LEVEL_INFO, "%s: WLAN being resumed by OS",
 	       __func__);
@@ -1172,7 +1172,7 @@ static void hdd_resume_wlan(void)
 	/*loop through all adapters. Concurrency */
 	status = hdd_get_front_adapter(pHddCtx, &pAdapterNode);
 
-	while (NULL != pAdapterNode && CDF_STATUS_SUCCESS == status) {
+	while (NULL != pAdapterNode && QDF_STATUS_SUCCESS == status) {
 		pAdapter = pAdapterNode->pAdapter;
 
 		/* wake the tx queues */
@@ -1258,12 +1258,12 @@ static void hdd_ssr_timer_start(int msec)
  *
  * This function is called by the HIF to shutdown the driver during SSR.
  *
- * Return: CDF_STATUS_SUCCESS if the driver was shut down,
+ * Return: QDF_STATUS_SUCCESS if the driver was shut down,
  *	or an error status otherwise
  */
-CDF_STATUS hdd_wlan_shutdown(void)
+QDF_STATUS hdd_wlan_shutdown(void)
 {
-	CDF_STATUS cdf_status;
+	QDF_STATUS qdf_status;
 	v_CONTEXT_t p_cds_context = NULL;
 	hdd_context_t *pHddCtx;
 	p_cds_sched_context cds_sched_context = NULL;
@@ -1284,7 +1284,7 @@ CDF_STATUS hdd_wlan_shutdown(void)
 	if (!p_cds_context) {
 		hddLog(CDF_TRACE_LEVEL_FATAL, "%s: Global CDS context is Null",
 		       __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	/* Get the HDD context. */
@@ -1292,7 +1292,7 @@ CDF_STATUS hdd_wlan_shutdown(void)
 	if (!pHddCtx) {
 		hddLog(CDF_TRACE_LEVEL_FATAL, "%s: HDD context is Null",
 		       __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	cds_set_recovery_in_progress(true);
@@ -1343,12 +1343,12 @@ CDF_STATUS hdd_wlan_shutdown(void)
 #endif
 
 	hddLog(CDF_TRACE_LEVEL_FATAL, "%s: Doing WMA STOP", __func__);
-	cdf_status = wma_stop(p_cds_context, HAL_STOP_TYPE_RF_KILL);
+	qdf_status = wma_stop(p_cds_context, HAL_STOP_TYPE_RF_KILL);
 
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to stop WMA", __func__);
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(cdf_status));
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 		wma_setneedshutdown(p_cds_context);
 	}
 
@@ -1356,19 +1356,19 @@ CDF_STATUS hdd_wlan_shutdown(void)
 	/* Stop SME - Cannot invoke cds_disable as cds_disable relies
 	 * on threads being running to process the SYS Stop
 	 */
-	cdf_status = sme_stop(pHddCtx->hHal, HAL_STOP_TYPE_SYS_RESET);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = sme_stop(pHddCtx->hHal, HAL_STOP_TYPE_SYS_RESET);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
-			  "%s: Failed to stop sme %d", __func__, cdf_status);
+			  "%s: Failed to stop sme %d", __func__, qdf_status);
 		CDF_ASSERT(0);
 	}
 
 	hddLog(CDF_TRACE_LEVEL_FATAL, "%s: Doing MAC STOP", __func__);
 	/* Stop MAC (PE and HAL) */
-	cdf_status = mac_stop(pHddCtx->hHal, HAL_STOP_TYPE_SYS_RESET);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = mac_stop(pHddCtx->hHal, HAL_STOP_TYPE_SYS_RESET);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,
-			  "%s: Failed to stop mac %d", __func__, cdf_status);
+			  "%s: Failed to stop mac %d", __func__, qdf_status);
 		CDF_ASSERT(0);
 	}
 
@@ -1389,7 +1389,7 @@ CDF_STATUS hdd_wlan_shutdown(void)
 
 	hddLog(CDF_TRACE_LEVEL_FATAL, "%s: WLAN driver shutdown complete",
 	       __func__);
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -1397,15 +1397,15 @@ CDF_STATUS hdd_wlan_shutdown(void)
  *
  * This function is called by the HIF to re-initialize the driver after SSR.
  *
- * Return: CDF_STATUS_SUCCESS if the driver was re-initialized,
+ * Return: QDF_STATUS_SUCCESS if the driver was re-initialized,
  *	or an error status otherwise
  */
-CDF_STATUS hdd_wlan_re_init(void *hif_sc)
+QDF_STATUS hdd_wlan_re_init(void *hif_sc)
 {
-	CDF_STATUS cdf_status;
+	QDF_STATUS qdf_status;
 	v_CONTEXT_t p_cds_context = NULL;
 	hdd_context_t *pHddCtx = NULL;
-	CDF_STATUS cdf_ret_status;
+	QDF_STATUS cdf_ret_status;
 	hdd_adapter_t *pAdapter;
 	int i;
 
@@ -1438,8 +1438,8 @@ CDF_STATUS hdd_wlan_re_init(void *hif_sc)
 	hdd_set_conparam(0);
 
 	/* Re-open CDS, it is a re-open b'se control transport was never closed. */
-	cdf_status = cds_open();
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = cds_open();
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		hddLog(CDF_TRACE_LEVEL_FATAL, "%s: cds_open failed", __func__);
 		goto err_re_init;
 	}
@@ -1452,8 +1452,8 @@ CDF_STATUS hdd_wlan_re_init(void *hif_sc)
 		goto err_cds_close;
 	}
 
-	cdf_status = cds_pre_enable(pHddCtx->pcds_context);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = cds_pre_enable(pHddCtx->pcds_context);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		hdd_alert("cds_pre_enable failed");
 		goto err_cds_close;
 	}
@@ -1464,16 +1464,16 @@ CDF_STATUS hdd_wlan_re_init(void *hif_sc)
 	 * since the SME config operation must access the cfg database.
 	 * Set the SME configuration parameters.
 	 */
-	cdf_status = hdd_set_sme_config(pHddCtx);
-	if (CDF_STATUS_SUCCESS != cdf_status) {
+	qdf_status = hdd_set_sme_config(pHddCtx);
+	if (QDF_STATUS_SUCCESS != qdf_status) {
 		hdd_alert("Failed hdd_set_sme_config");
 		goto err_cds_close;
 	}
 
 	ol_txrx_register_pause_cb(wlan_hdd_txrx_pause_cb);
 
-	cdf_status = hdd_set_sme_chan_list(pHddCtx);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = hdd_set_sme_chan_list(pHddCtx);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		hddLog(CDF_TRACE_LEVEL_FATAL,
 		       "%s: Failed to init channel list", __func__);
 		goto err_cds_close;
@@ -1492,7 +1492,7 @@ CDF_STATUS hdd_wlan_re_init(void *hif_sc)
 				     (uint8_t *) &pHddCtx->config->
 				     intfMacAddr[0],
 				     sizeof(pHddCtx->config->intfMacAddr[0]));
-	if (!CDF_IS_STATUS_SUCCESS(cdf_ret_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(cdf_ret_status)) {
 		hddLog(CDF_TRACE_LEVEL_ERROR, "%s: Failed to set MAC Address. "
 		       "HALStatus is %08d [x%08x]", __func__, cdf_ret_status,
 		       cdf_ret_status);
@@ -1501,14 +1501,14 @@ CDF_STATUS hdd_wlan_re_init(void *hif_sc)
 
 	/* Start CDS which starts up the SME/MAC/HAL modules and everything else
 	   Note: Firmware image will be read and downloaded inside cds_enable API */
-	cdf_status = cds_enable(p_cds_context);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = cds_enable(p_cds_context);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		hddLog(CDF_TRACE_LEVEL_FATAL, "%s: cds_enable failed", __func__);
 		goto err_cds_close;
 	}
 
-	cdf_status = hdd_post_cds_enable_config(pHddCtx);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = hdd_post_cds_enable_config(pHddCtx);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		hddLog(CDF_TRACE_LEVEL_FATAL,
 		       "%s: hdd_post_cds_enable_config failed", __func__);
 		goto err_cds_disable;
@@ -1628,7 +1628,7 @@ err_cds_close:
 		wiphy_unregister(pHddCtx->wiphy);
 		wiphy_free(pHddCtx->wiphy);
 
-		if (!CDF_IS_STATUS_SUCCESS(cds_deinit_policy_mgr())) {
+		if (!QDF_IS_STATUS_SUCCESS(cds_deinit_policy_mgr())) {
 			hdd_err("Failed to deinit policy manager");
 			/* Proceed and complete the clean up */
 		}
@@ -1641,7 +1641,7 @@ err_re_init:
 	return -EPERM;
 
 success:
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -1720,7 +1720,7 @@ static int __wlan_hdd_cfg80211_resume_wlan(struct wiphy *wiphy)
 	hdd_context_t *pHddCtx = wiphy_priv(wiphy);
 	hdd_adapter_t *pAdapter;
 	hdd_adapter_list_node_t *pAdapterNode, *pNext;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	int result;
 	p_cds_sched_context cds_sched_context = get_cds_sched_ctxt();
 
@@ -1768,7 +1768,7 @@ static int __wlan_hdd_cfg80211_resume_wlan(struct wiphy *wiphy)
 
 	status = hdd_get_front_adapter(pHddCtx, &pAdapterNode);
 
-	while (NULL != pAdapterNode && CDF_STATUS_SUCCESS == status) {
+	while (NULL != pAdapterNode && QDF_STATUS_SUCCESS == status) {
 		pAdapter = pAdapterNode->pAdapter;
 		if ((NULL != pAdapter) &&
 		    (WLAN_HDD_INFRA_STATION == pAdapter->device_mode)) {
@@ -1857,7 +1857,7 @@ static int __wlan_hdd_cfg80211_suspend_wlan(struct wiphy *wiphy,
 	hdd_adapter_list_node_t *pAdapterNode = NULL, *pNext = NULL;
 	hdd_adapter_t *pAdapter;
 	hdd_scaninfo_t *pScanInfo;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	int rc;
 
 	ENTER();
@@ -1876,7 +1876,7 @@ static int __wlan_hdd_cfg80211_suspend_wlan(struct wiphy *wiphy,
 	 * until CAC is done for a SoftAP which is in started state.
 	 */
 	status = hdd_get_front_adapter(pHddCtx, &pAdapterNode);
-	while (NULL != pAdapterNode && CDF_STATUS_SUCCESS == status) {
+	while (NULL != pAdapterNode && QDF_STATUS_SUCCESS == status) {
 		pAdapter = pAdapterNode->pAdapter;
 		if (WLAN_HDD_SOFTAP == pAdapter->device_mode) {
 			if (BSS_START ==
@@ -1911,7 +1911,7 @@ static int __wlan_hdd_cfg80211_suspend_wlan(struct wiphy *wiphy,
 
 	/* Stop ongoing scan on each interface */
 	status = hdd_get_front_adapter(pHddCtx, &pAdapterNode);
-	while (NULL != pAdapterNode && CDF_STATUS_SUCCESS == status) {
+	while (NULL != pAdapterNode && QDF_STATUS_SUCCESS == status) {
 		pAdapter = pAdapterNode->pAdapter;
 		pScanInfo = &pAdapter->scan_info;
 
@@ -2077,7 +2077,7 @@ static int __wlan_hdd_cfg80211_set_power_mgmt(struct wiphy *wiphy,
 {
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	hdd_context_t *pHddCtx;
-	CDF_STATUS cdf_status;
+	QDF_STATUS qdf_status;
 	int status;
 
 	ENTER();
@@ -2105,11 +2105,11 @@ static int __wlan_hdd_cfg80211_set_power_mgmt(struct wiphy *wiphy,
 
 		hddLog(LOG1,
 			FL("offload: in cfg80211_set_power_mgmt, calling arp offload"));
-		cdf_status = hdd_conf_arp_offload(pAdapter, true);
-		if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+		qdf_status = hdd_conf_arp_offload(pAdapter, true);
+		if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 			hddLog(LOG1,
 				FL("Failed to enable ARPOFFLOAD Feature %d"),
-				cdf_status);
+				qdf_status);
 		}
 	}
 
@@ -2204,7 +2204,7 @@ static int __wlan_hdd_cfg80211_set_txpower(struct wiphy *wiphy,
 	/* Fall through */
 	case NL80211_TX_POWER_LIMITED:  /* Limit TX power by the mBm parameter */
 		if (sme_set_max_tx_power(hHal, bssid, selfMac, dbm) !=
-		    CDF_STATUS_SUCCESS) {
+		    QDF_STATUS_SUCCESS) {
 			hddLog(LOGE, FL("Setting maximum tx power failed"));
 			return -EIO;
 		}

core/hdd/src/wlan_hdd_scan.c

@@ -560,9 +560,9 @@ static int wlan_hdd_scan_request_enqueue(hdd_adapter_t *adapter,
  * @source : returns source of the scan request
  * @timestamp: scan request timestamp
  *
- * Return: CDF_STATUS
+ * Return: QDF_STATUS
  */
-CDF_STATUS wlan_hdd_scan_request_dequeue(hdd_context_t *hdd_ctx,
+QDF_STATUS wlan_hdd_scan_request_dequeue(hdd_context_t *hdd_ctx,
 	uint32_t scan_id, struct cfg80211_scan_request **req, uint8_t *source,
 	uint32_t *timestamp)
 {
@@ -633,7 +633,7 @@ CDF_STATUS wlan_hdd_scan_request_dequeue(hdd_context_t *hdd_ctx,
  * Return: 0 for success, non zero for failure
  */
 
-static CDF_STATUS
+static QDF_STATUS
 hdd_scan_request_callback(tHalHandle halHandle, void *pContext,
 			  uint8_t sessionId, uint32_t scanId,
 			  eCsrScanStatus status)
@@ -663,7 +663,7 @@ hdd_scan_request_callback(tHalHandle halHandle, void *pContext,
 	if (pAdapter->dev != dev) {
 		hddLog(LOGW, "%s: device mismatch %p vs %p",
 		       __func__, pAdapter->dev, dev);
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 
 	wlan_hdd_scan_request_dequeue(hddctx, scanId, &req, &source,
@@ -687,7 +687,7 @@ hdd_scan_request_callback(tHalHandle halHandle, void *pContext,
 	wireless_send_event(dev, we_event, &wrqu, msg);
 
 	EXIT();
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -710,7 +710,7 @@ static int __iw_set_scan(struct net_device *dev, struct iw_request_info *info,
 	hdd_context_t *hdd_ctx = WLAN_HDD_GET_CTX(pAdapter);
 	hdd_wext_state_t *pwextBuf = WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter);
 	tCsrScanRequest scanRequest;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	struct iw_scan_req *scanReq = (struct iw_scan_req *)extra;
 	hdd_adapter_t *con_sap_adapter;
 	uint16_t con_dfs_ch;
@@ -832,7 +832,7 @@ static int __iw_set_scan(struct net_device *dev, struct iw_request_info *info,
 	status = sme_scan_request((WLAN_HDD_GET_CTX(pAdapter))->hHal,
 				  pAdapter->sessionId, &scanRequest,
 				  &hdd_scan_request_callback, dev);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_FATAL,
 			  "%s:sme_scan_request  fail %d!!!", __func__, status);
 		goto error;
@@ -891,7 +891,7 @@ static int __iw_get_scan(struct net_device *dev,
 	hdd_context_t *hdd_ctx;
 	tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(pAdapter);
 	tCsrScanResultInfo *pScanResult;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	hdd_scan_info_t scanInfo;
 	tScanResultHandle pResult;
 	int i = 0;
@@ -1089,7 +1089,7 @@ nla_put_failure:
  *
  * Return: CDF status
  */
-static CDF_STATUS hdd_cfg80211_scan_done_callback(tHalHandle halHandle,
+static QDF_STATUS hdd_cfg80211_scan_done_callback(tHalHandle halHandle,
 					   void *pContext,
 					   uint8_t sessionId,
 					   uint32_t scanId,
@@ -1108,7 +1108,7 @@ static CDF_STATUS hdd_cfg80211_scan_done_callback(tHalHandle halHandle,
 
 	ret = wlan_hdd_validate_context(hddctx);
 	if (0 != ret)
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 
 	hddLog(CDF_TRACE_LEVEL_INFO,
 		"%s called with hal = %p, pContext = %p, ID = %d, status = %d",
@@ -1121,7 +1121,7 @@ static CDF_STATUS hdd_cfg80211_scan_done_callback(tHalHandle halHandle,
 		goto allow_suspend;
 	}
 
-	if (CDF_STATUS_SUCCESS !=
+	if (QDF_STATUS_SUCCESS !=
 		wlan_hdd_scan_request_dequeue(hddctx, scanId, &req, &source,
 			&scan_time)) {
 		hdd_err("Dequeue of scan request failed ID: %d", scanId);
@@ -1554,9 +1554,9 @@ static int __wlan_hdd_cfg80211_scan(struct wiphy *wiphy,
 				pAdapter->sessionId, &scan_req,
 				&hdd_cfg80211_scan_done_callback, dev);
 
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		hddLog(LOGE, FL("sme_scan_request returned error %d"), status);
-		if (CDF_STATUS_E_RESOURCES == status) {
+		if (QDF_STATUS_E_RESOURCES == status) {
 			hddLog(LOGE,
 			       FL("HO is in progress.So defer the scan by informing busy"));
 			status = -EBUSY;
@@ -1985,7 +1985,7 @@ hdd_sched_scan_callback(void *callbackContext,
  *
  * Return: Success if PNO is allowed, Failure otherwise.
  */
-static CDF_STATUS wlan_hdd_is_pno_allowed(hdd_adapter_t *adapter)
+static QDF_STATUS wlan_hdd_is_pno_allowed(hdd_adapter_t *adapter)
 {
 	hddLog(LOG1,
 		FL("dev_mode=%d, conn_state=%d, session ID=%d"),
@@ -1995,9 +1995,9 @@ static CDF_STATUS wlan_hdd_is_pno_allowed(hdd_adapter_t *adapter)
 	if ((adapter->device_mode == WLAN_HDD_INFRA_STATION) &&
 		(eConnectionState_NotConnected ==
 		 adapter->sessionCtx.station.conn_info.connState))
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	else
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 
 }
 
@@ -2023,7 +2023,7 @@ static int __wlan_hdd_cfg80211_sched_scan_start(struct wiphy *wiphy,
 	u8 valid_ch[WNI_CFG_VALID_CHANNEL_LIST_LEN] = { 0 };
 	u8 channels_allowed[WNI_CFG_VALID_CHANNEL_LIST_LEN] = { 0 };
 	uint32_t num_channels_allowed = WNI_CFG_VALID_CHANNEL_LIST_LEN;
-	CDF_STATUS status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
 	int ret = 0;
 	hdd_scaninfo_t *pScanInfo = &pAdapter->scan_info;
 	struct hdd_config *config = NULL;
@@ -2079,7 +2079,7 @@ static int __wlan_hdd_cfg80211_sched_scan_start(struct wiphy *wiphy,
 		}
 	}
 
-	if (CDF_STATUS_E_FAILURE == wlan_hdd_is_pno_allowed(pAdapter)) {
+	if (QDF_STATUS_E_FAILURE == wlan_hdd_is_pno_allowed(pAdapter)) {
 		hddLog(LOGE, FL("pno is not allowed"));
 		return -ENOTSUPP;
 	}
@@ -2251,7 +2251,7 @@ static int __wlan_hdd_cfg80211_sched_scan_start(struct wiphy *wiphy,
 						pAdapter->sessionId,
 						hdd_sched_scan_callback,
 						pAdapter);
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		hddLog(LOGE, FL("Failed to enable PNO"));
 		ret = -EINVAL;
 		goto error;
@@ -2297,7 +2297,7 @@ int wlan_hdd_cfg80211_sched_scan_start(struct wiphy *wiphy,
 static int __wlan_hdd_cfg80211_sched_scan_stop(struct wiphy *wiphy,
 					       struct net_device *dev)
 {
-	CDF_STATUS status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	hdd_context_t *pHddCtx;
 	tHalHandle hHal;
@@ -2361,7 +2361,7 @@ static int __wlan_hdd_cfg80211_sched_scan_stop(struct wiphy *wiphy,
 	status = sme_set_preferred_network_list(hHal, pPnoRequest,
 						pAdapter->sessionId,
 						NULL, pAdapter);
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		hddLog(LOGE, FL("Failed to disabled PNO"));
 		ret = -EINVAL;
 	}

core/hdd/src/wlan_hdd_softap_tx_rx.c

@@ -208,7 +208,7 @@ int hdd_softap_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 		 */
 		STAId = pHddApCtx->uBCStaId;
 	} else {
-		if (CDF_STATUS_SUCCESS !=
+		if (QDF_STATUS_SUCCESS !=
 			 hdd_softap_get_sta_id(pAdapter,
 				 pDestMacAddress, &STAId)) {
 			CDF_TRACE(CDF_MODULE_ID_HDD_SAP_DATA,
@@ -391,12 +391,12 @@ void hdd_softap_tx_timeout(struct net_device *dev)
  * @hdd_softap_init_tx_rx() - Initialize Tx/RX module
  * @pAdapter: pointer to adapter context
  *
- * Return: CDF_STATUS_E_FAILURE if any errors encountered,
- *	   CDF_STATUS_SUCCESS otherwise
+ * Return: QDF_STATUS_E_FAILURE if any errors encountered,
+ *	   QDF_STATUS_SUCCESS otherwise
  */
-CDF_STATUS hdd_softap_init_tx_rx(hdd_adapter_t *pAdapter)
+QDF_STATUS hdd_softap_init_tx_rx(hdd_adapter_t *pAdapter)
 {
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	uint8_t STAId = 0;
 
@@ -416,12 +416,12 @@ CDF_STATUS hdd_softap_init_tx_rx(hdd_adapter_t *pAdapter)
  * @hdd_softap_deinit_tx_rx() - Deinitialize Tx/RX module
  * @pAdapter: pointer to adapter context
  *
- * Return: CDF_STATUS_E_FAILURE if any errors encountered,
- *	   CDF_STATUS_SUCCESS otherwise
+ * Return: QDF_STATUS_E_FAILURE if any errors encountered,
+ *	   QDF_STATUS_SUCCESS otherwise
  */
-CDF_STATUS hdd_softap_deinit_tx_rx(hdd_adapter_t *pAdapter)
+QDF_STATUS hdd_softap_deinit_tx_rx(hdd_adapter_t *pAdapter)
 {
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	return status;
 }
@@ -432,10 +432,10 @@ CDF_STATUS hdd_softap_deinit_tx_rx(hdd_adapter_t *pAdapter)
  * @STAId: Station ID to initialize
  * @pmacAddrSTA: pointer to the MAC address of the station
  *
- * Return: CDF_STATUS_E_FAILURE if any errors encountered,
- *	   CDF_STATUS_SUCCESS otherwise
+ * Return: QDF_STATUS_E_FAILURE if any errors encountered,
+ *	   QDF_STATUS_SUCCESS otherwise
  */
-CDF_STATUS hdd_softap_init_tx_rx_sta(hdd_adapter_t *pAdapter, uint8_t STAId,
+QDF_STATUS hdd_softap_init_tx_rx_sta(hdd_adapter_t *pAdapter, uint8_t STAId,
 				     struct cdf_mac_addr *pmacAddrSTA)
 {
 	spin_lock_bh(&pAdapter->staInfo_lock);
@@ -443,7 +443,7 @@ CDF_STATUS hdd_softap_init_tx_rx_sta(hdd_adapter_t *pAdapter, uint8_t STAId,
 		CDF_TRACE(CDF_MODULE_ID_HDD_SAP_DATA, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Reinit station %d", __func__, STAId);
 		spin_unlock_bh(&pAdapter->staInfo_lock);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	cdf_mem_zero(&pAdapter->aStaInfo[STAId], sizeof(hdd_station_info_t));
@@ -453,7 +453,7 @@ CDF_STATUS hdd_softap_init_tx_rx_sta(hdd_adapter_t *pAdapter, uint8_t STAId,
 	cdf_copy_macaddr(&pAdapter->aStaInfo[STAId].macAddrSTA, pmacAddrSTA);
 
 	spin_unlock_bh(&pAdapter->staInfo_lock);
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -461,12 +461,12 @@ CDF_STATUS hdd_softap_init_tx_rx_sta(hdd_adapter_t *pAdapter, uint8_t STAId,
  * @pAdapter: pointer to adapter context
  * @STAId: Station ID to deinitialize
  *
- * Return: CDF_STATUS_E_FAILURE if any errors encountered,
- *	   CDF_STATUS_SUCCESS otherwise
+ * Return: QDF_STATUS_E_FAILURE if any errors encountered,
+ *	   QDF_STATUS_SUCCESS otherwise
  */
-CDF_STATUS hdd_softap_deinit_tx_rx_sta(hdd_adapter_t *pAdapter, uint8_t STAId)
+QDF_STATUS hdd_softap_deinit_tx_rx_sta(hdd_adapter_t *pAdapter, uint8_t STAId)
 {
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	hdd_hostapd_state_t *pHostapdState;
 
 	pHostapdState = WLAN_HDD_GET_HOSTAP_STATE_PTR(pAdapter);
@@ -477,7 +477,7 @@ CDF_STATUS hdd_softap_deinit_tx_rx_sta(hdd_adapter_t *pAdapter, uint8_t STAId)
 		spin_unlock_bh(&pAdapter->staInfo_lock);
 		CDF_TRACE(CDF_MODULE_ID_HDD_SAP_DATA, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Deinit station not inited %d", __func__, STAId);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	pAdapter->aStaInfo[STAId].isUsed = false;
@@ -497,10 +497,10 @@ CDF_STATUS hdd_softap_deinit_tx_rx_sta(hdd_adapter_t *pAdapter, uint8_t STAId)
  * the HDD when one or more packets were received for a registered
  * STA.
  *
- * Return: CDF_STATUS_E_FAILURE if any errors encountered,
- *	   CDF_STATUS_SUCCESS otherwise
+ * Return: QDF_STATUS_E_FAILURE if any errors encountered,
+ *	   QDF_STATUS_SUCCESS otherwise
  */
-CDF_STATUS hdd_softap_rx_packet_cbk(void *cds_context,
+QDF_STATUS hdd_softap_rx_packet_cbk(void *cds_context,
 				    cdf_nbuf_t rxBuf, uint8_t staId)
 {
 	hdd_adapter_t *pAdapter = NULL;
@@ -516,14 +516,14 @@ CDF_STATUS hdd_softap_rx_packet_cbk(void *cds_context,
 	if ((NULL == cds_context) || (NULL == rxBuf)) {
 		CDF_TRACE(CDF_MODULE_ID_HDD_SAP_DATA, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Null params being passed", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	pHddCtx = cds_get_context(CDF_MODULE_ID_HDD);
 	if (NULL == pHddCtx) {
 		CDF_TRACE(CDF_MODULE_ID_HDD_SAP_DATA, CDF_TRACE_LEVEL_ERROR,
 			  "%s: HDD context is Null", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	pAdapter = pHddCtx->sta_to_adapter[staId];
@@ -531,7 +531,7 @@ CDF_STATUS hdd_softap_rx_packet_cbk(void *cds_context,
 		hddLog(LOGE,
 			FL("invalid adapter %p or adapter has invalid magic"),
 			pAdapter);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	/* walk the chain until all are processed */
@@ -545,7 +545,7 @@ CDF_STATUS hdd_softap_rx_packet_cbk(void *cds_context,
 
 		CDF_TRACE(CDF_MODULE_ID_HDD_SAP_DATA, CDF_TRACE_LEVEL_ERROR,
 			  "%s: ERROR!!Invalid netdevice", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 	cpu_index = wlan_hdd_get_cpu();
 	++pAdapter->hdd_stats.hddTxRxStats.rxPackets[cpu_index];
@@ -592,7 +592,7 @@ CDF_STATUS hdd_softap_rx_packet_cbk(void *cds_context,
 
 	pAdapter->dev->last_rx = jiffies;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -600,23 +600,23 @@ CDF_STATUS hdd_softap_rx_packet_cbk(void *cds_context,
  * @pAdapter: pointer to adapter context
  * @staId: Station ID to deregister
  *
- * Return: CDF_STATUS_SUCCESS on success, CDF_STATUS_E_* on error
+ * Return: QDF_STATUS_SUCCESS on success, CDF_STATUS_E_* on error
  */
-CDF_STATUS hdd_softap_deregister_sta(hdd_adapter_t *pAdapter, uint8_t staId)
+QDF_STATUS hdd_softap_deregister_sta(hdd_adapter_t *pAdapter, uint8_t staId)
 {
-	CDF_STATUS cdf_status = CDF_STATUS_SUCCESS;
+	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
 	hdd_context_t *pHddCtx;
 
 	if (NULL == pAdapter) {
 		CDF_TRACE(CDF_MODULE_ID_HDD_SAP_DATA, CDF_TRACE_LEVEL_ERROR,
 			  "%s: pAdapter is NULL", __func__);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	if (WLAN_HDD_ADAPTER_MAGIC != pAdapter->magic) {
 		CDF_TRACE(CDF_MODULE_ID_HDD_SAP_DATA, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Invalid pAdapter magic", __func__);
-		return CDF_STATUS_E_INVAL;
+		return QDF_STATUS_E_INVAL;
 	}
 
 	pHddCtx = (hdd_context_t *) (pAdapter->pHddCtx);
@@ -624,11 +624,11 @@ CDF_STATUS hdd_softap_deregister_sta(hdd_adapter_t *pAdapter, uint8_t staId)
 	 * structures. This helps to block RX frames from other
 	 * station to this station.
 	 */
-	cdf_status = ol_txrx_clear_peer(staId);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	qdf_status = ol_txrx_clear_peer(staId);
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_HDD_SAP_DATA, CDF_TRACE_LEVEL_ERROR,
 			  "ol_txrx_clear_peer() failed to for staID %d.  "
-			  "Status= %d [0x%08X]", staId, cdf_status, cdf_status);
+			  "Status= %d [0x%08X]", staId, qdf_status, qdf_status);
 	}
 
 	if (pAdapter->aStaInfo[staId].isUsed) {
@@ -639,7 +639,7 @@ CDF_STATUS hdd_softap_deregister_sta(hdd_adapter_t *pAdapter, uint8_t staId)
 	}
 	pHddCtx->sta_to_adapter[staId] = NULL;
 
-	return cdf_status;
+	return qdf_status;
 }
 
 /**
@@ -653,9 +653,9 @@ CDF_STATUS hdd_softap_deregister_sta(hdd_adapter_t *pAdapter, uint8_t staId)
  * @pPeerMacAddress: station MAC address
  * @fWmmEnabled: is WMM enabled for this STA?
  *
- * Return: CDF_STATUS_SUCCESS on success, CDF_STATUS_E_* on error
+ * Return: QDF_STATUS_SUCCESS on success, CDF_STATUS_E_* on error
  */
-CDF_STATUS hdd_softap_register_sta(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_softap_register_sta(hdd_adapter_t *pAdapter,
 				   bool fAuthRequired,
 				   bool fPrivacyBit,
 				   uint8_t staId,
@@ -664,7 +664,7 @@ CDF_STATUS hdd_softap_register_sta(hdd_adapter_t *pAdapter,
 				   struct cdf_mac_addr *pPeerMacAddress,
 				   bool fWmmEnabled)
 {
-	CDF_STATUS cdf_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS qdf_status = QDF_STATUS_E_FAILURE;
 	struct ol_txrx_desc_type staDesc = { 0 };
 	hdd_context_t *pHddCtx = pAdapter->pHddCtx;
 
@@ -683,7 +683,7 @@ CDF_STATUS hdd_softap_register_sta(hdd_adapter_t *pAdapter,
 	/*Save the pAdapter Pointer for this staId */
 	pHddCtx->sta_to_adapter[staId] = pAdapter;
 
-	cdf_status =
+	qdf_status =
 		hdd_softap_init_tx_rx_sta(pAdapter, staId,
 					  pPeerMacAddress);
 
@@ -693,14 +693,14 @@ CDF_STATUS hdd_softap_register_sta(hdd_adapter_t *pAdapter,
 		  staDesc.is_qos_enabled);
 
 
-	cdf_status =
+	qdf_status =
 		ol_txrx_register_peer(hdd_softap_rx_packet_cbk,
 					   &staDesc);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_HDD_SAP_DATA, CDF_TRACE_LEVEL_ERROR,
 			  "SOFTAP ol_txrx_register_peer() failed to register.  Status= %d [0x%08X]",
-			  cdf_status, cdf_status);
-		return cdf_status;
+			  qdf_status, qdf_status);
+		return qdf_status;
 	}
 
 	/* if ( WPA ), tell TL to go to 'connected' and after keys come to the
@@ -720,7 +720,7 @@ CDF_STATUS hdd_softap_register_sta(hdd_adapter_t *pAdapter,
 		/* Connections that do not need Upper layer auth,
 		 * transition TL directly to 'Authenticated' state.
 		 */
-		cdf_status = hdd_change_peer_state(pAdapter, staDesc.sta_id,
+		qdf_status = hdd_change_peer_state(pAdapter, staDesc.sta_id,
 						ol_txrx_peer_state_auth, false);
 
 		pAdapter->aStaInfo[staId].tlSTAState = ol_txrx_peer_state_auth;
@@ -731,7 +731,7 @@ CDF_STATUS hdd_softap_register_sta(hdd_adapter_t *pAdapter,
 			  "ULA auth StaId= %d.  Changing TL state to CONNECTED at Join time",
 			  pAdapter->aStaInfo[staId].ucSTAId);
 
-		cdf_status = hdd_change_peer_state(pAdapter, staDesc.sta_id,
+		qdf_status = hdd_change_peer_state(pAdapter, staDesc.sta_id,
 						ol_txrx_peer_state_conn, false);
 		pAdapter->aStaInfo[staId].tlSTAState = ol_txrx_peer_state_conn;
 
@@ -745,7 +745,7 @@ CDF_STATUS hdd_softap_register_sta(hdd_adapter_t *pAdapter,
 				   WLAN_START_ALL_NETIF_QUEUE_N_CARRIER,
 				   WLAN_CONTROL_PATH);
 
-	return cdf_status;
+	return qdf_status;
 }
 
 /**
@@ -753,12 +753,12 @@ CDF_STATUS hdd_softap_register_sta(hdd_adapter_t *pAdapter,
  * @pAdapter: pointer to adapter context
  * @fPrivacyBit: should 802.11 privacy bit be set?
  *
- * Return: CDF_STATUS_SUCCESS on success, CDF_STATUS_E_* on error
+ * Return: QDF_STATUS_SUCCESS on success, CDF_STATUS_E_* on error
  */
-CDF_STATUS hdd_softap_register_bc_sta(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_softap_register_bc_sta(hdd_adapter_t *pAdapter,
 				      bool fPrivacyBit)
 {
-	CDF_STATUS cdf_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS qdf_status = QDF_STATUS_E_FAILURE;
 	hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
 	struct cdf_mac_addr broadcastMacAddr =
 					CDF_MAC_ADDR_BROADCAST_INITIALIZER;
@@ -772,21 +772,21 @@ CDF_STATUS hdd_softap_register_bc_sta(hdd_adapter_t *pAdapter,
 #else
 	pHddCtx->sta_to_adapter[WLAN_RX_SAP_SELF_STA_ID] = pAdapter;
 #endif
-	cdf_status =
+	qdf_status =
 		hdd_softap_register_sta(pAdapter, false, fPrivacyBit,
 					(WLAN_HDD_GET_AP_CTX_PTR(pAdapter))->
 					uBCStaId, 0, 1, &broadcastMacAddr, 0);
 
-	return cdf_status;
+	return qdf_status;
 }
 
 /**
  * hdd_softap_deregister_bc_sta() - Deregister the SoftAP broadcast STA
  * @pAdapter: pointer to adapter context
  *
- * Return: CDF_STATUS_SUCCESS on success, CDF_STATUS_E_* on error
+ * Return: QDF_STATUS_SUCCESS on success, CDF_STATUS_E_* on error
  */
-CDF_STATUS hdd_softap_deregister_bc_sta(hdd_adapter_t *pAdapter)
+QDF_STATUS hdd_softap_deregister_bc_sta(hdd_adapter_t *pAdapter)
 {
 	return hdd_softap_deregister_sta(pAdapter,
 					 (WLAN_HDD_GET_AP_CTX_PTR(pAdapter))->
@@ -797,11 +797,11 @@ CDF_STATUS hdd_softap_deregister_bc_sta(hdd_adapter_t *pAdapter)
  * hdd_softap_stop_bss() - Stop the BSS
  * @pAdapter: pointer to adapter context
  *
- * Return: CDF_STATUS_SUCCESS on success, CDF_STATUS_E_* on error
+ * Return: QDF_STATUS_SUCCESS on success, CDF_STATUS_E_* on error
  */
-CDF_STATUS hdd_softap_stop_bss(hdd_adapter_t *pAdapter)
+QDF_STATUS hdd_softap_stop_bss(hdd_adapter_t *pAdapter)
 {
-	CDF_STATUS cdf_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS qdf_status = QDF_STATUS_E_FAILURE;
 	uint8_t staId = 0;
 	hdd_context_t *pHddCtx;
 	pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
@@ -813,12 +813,12 @@ CDF_STATUS hdd_softap_stop_bss(hdd_adapter_t *pAdapter)
 		CDF_TRACE(CDF_MODULE_ID_HDD_SAP_DATA, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Loading_unloading in Progress, state: 0x%x. Ignore!!!",
 			  __func__, cds_get_driver_state());
-		return CDF_STATUS_E_PERM;
+		return QDF_STATUS_E_PERM;
 	}
 
-	cdf_status = hdd_softap_deregister_bc_sta(pAdapter);
+	qdf_status = hdd_softap_deregister_bc_sta(pAdapter);
 
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_HDD_SAP_DATA, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to deregister BC sta Id %d", __func__,
 			  (WLAN_HDD_GET_AP_CTX_PTR(pAdapter))->uBCStaId);
@@ -827,8 +827,8 @@ CDF_STATUS hdd_softap_stop_bss(hdd_adapter_t *pAdapter)
 	for (staId = 0; staId < WLAN_MAX_STA_COUNT; staId++) {
 		/* This excludes BC sta as it is already deregistered */
 		if (pAdapter->aStaInfo[staId].isUsed) {
-			cdf_status = hdd_softap_deregister_sta(pAdapter, staId);
-			if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+			qdf_status = hdd_softap_deregister_sta(pAdapter, staId);
+			if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 				CDF_TRACE(CDF_MODULE_ID_HDD_SAP_DATA,
 					  CDF_TRACE_LEVEL_ERROR,
 					  "%s: Failed to deregister sta Id %d",
@@ -836,7 +836,7 @@ CDF_STATUS hdd_softap_stop_bss(hdd_adapter_t *pAdapter)
 			}
 		}
 	}
-	return cdf_status;
+	return qdf_status;
 }
 
 /**
@@ -845,24 +845,24 @@ CDF_STATUS hdd_softap_stop_bss(hdd_adapter_t *pAdapter)
  * @pDestMacAddress: MAC address of the station
  * @state: new state of the station
  *
- * Return: CDF_STATUS_SUCCESS on success, CDF_STATUS_E_* on error
+ * Return: QDF_STATUS_SUCCESS on success, CDF_STATUS_E_* on error
  */
-CDF_STATUS hdd_softap_change_sta_state(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_softap_change_sta_state(hdd_adapter_t *pAdapter,
 				       struct cdf_mac_addr *pDestMacAddress,
 				       enum ol_txrx_peer_state state)
 {
 	uint8_t ucSTAId = WLAN_MAX_STA_COUNT;
-	CDF_STATUS cdf_status = CDF_STATUS_SUCCESS;
+	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
 
 	CDF_TRACE(CDF_MODULE_ID_HDD_SAP_DATA, CDF_TRACE_LEVEL_INFO,
 		  "%s: enter", __func__);
 
-	if (CDF_STATUS_SUCCESS !=
+	if (QDF_STATUS_SUCCESS !=
 		 hdd_softap_get_sta_id(pAdapter,
 			 pDestMacAddress, &ucSTAId)) {
 		CDF_TRACE(CDF_MODULE_ID_HDD_SAP_DATA, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Failed to find right station", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	if (false ==
@@ -871,15 +871,15 @@ CDF_STATUS hdd_softap_change_sta_state(hdd_adapter_t *pAdapter,
 		CDF_TRACE(CDF_MODULE_ID_HDD_SAP_DATA, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Station MAC address does not matching",
 			  __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
-	cdf_status =
+	qdf_status =
 		hdd_change_peer_state(pAdapter, ucSTAId, state, false);
 	CDF_TRACE(CDF_MODULE_ID_HDD_SAP_DATA, CDF_TRACE_LEVEL_INFO,
 		  "%s: change station to state %d succeed", __func__, state);
 
-	if (CDF_STATUS_SUCCESS == cdf_status) {
+	if (QDF_STATUS_SUCCESS == qdf_status) {
 		pAdapter->aStaInfo[ucSTAId].tlSTAState =
 			ol_txrx_peer_state_auth;
 	}
@@ -887,7 +887,7 @@ CDF_STATUS hdd_softap_change_sta_state(hdd_adapter_t *pAdapter,
 	CDF_TRACE(CDF_MODULE_ID_HDD_SAP_DATA, CDF_TRACE_LEVEL_INFO,
 		  "%s exit", __func__);
 
-	return cdf_status;
+	return qdf_status;
 }
 
 /*
@@ -896,11 +896,11 @@ CDF_STATUS hdd_softap_change_sta_state(hdd_adapter_t *pAdapter,
  * @pDestMacAddress: MAC address of the destination
  * @staId: Station ID associated with the MAC address
  *
- * Return: CDF_STATUS_SUCCESS if a match was found, in which case
- *	   staId is populated, CDF_STATUS_E_FAILURE if a match is
+ * Return: QDF_STATUS_SUCCESS if a match was found, in which case
+ *	   staId is populated, QDF_STATUS_E_FAILURE if a match is
  *	   not found
  */
-CDF_STATUS hdd_softap_get_sta_id(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_softap_get_sta_id(hdd_adapter_t *pAdapter,
 				 struct cdf_mac_addr *pMacAddress,
 				 uint8_t *staId)
 {
@@ -911,9 +911,9 @@ CDF_STATUS hdd_softap_get_sta_id(hdd_adapter_t *pAdapter,
 			(&pAdapter->aStaInfo[i].macAddrSTA, pMacAddress,
 			CDF_MAC_ADDR_SIZE) && pAdapter->aStaInfo[i].isUsed) {
 			*staId = i;
-			return CDF_STATUS_SUCCESS;
+			return QDF_STATUS_SUCCESS;
 		}
 	}
 
-	return CDF_STATUS_E_FAILURE;
+	return QDF_STATUS_E_FAILURE;
 }

core/hdd/src/wlan_hdd_stats.c

@@ -1193,7 +1193,7 @@ __wlan_hdd_cfg80211_ll_stats_set(struct wiphy *wiphy,
 		LinkLayerStatsSetReq.mpduSizeThreshold,
 		LinkLayerStatsSetReq.aggressiveStatisticsGathering);
 
-	if (CDF_STATUS_SUCCESS != sme_ll_stats_set_req(pHddCtx->hHal,
+	if (QDF_STATUS_SUCCESS != sme_ll_stats_set_req(pHddCtx->hHal,
 						       &LinkLayerStatsSetReq)) {
 		hddLog(CDF_TRACE_LEVEL_ERROR, "%s:"
 		       "sme_ll_stats_set_req Failed", __func__);
@@ -1323,7 +1323,7 @@ __wlan_hdd_cfg80211_ll_stats_get(struct wiphy *wiphy,
 	INIT_COMPLETION(context->response_event);
 	spin_unlock(&context->context_lock);
 
-	if (CDF_STATUS_SUCCESS != sme_ll_stats_get_req(pHddCtx->hHal,
+	if (QDF_STATUS_SUCCESS != sme_ll_stats_get_req(pHddCtx->hHal,
 						       &LinkLayerStatsGetReq)) {
 		hddLog(CDF_TRACE_LEVEL_ERROR, "%s:"
 		       "sme_ll_stats_get_req Failed", __func__);
@@ -1454,7 +1454,7 @@ __wlan_hdd_cfg80211_ll_stats_clear(struct wiphy *wiphy,
 		LinkLayerStatsClearReq.statsClearReqMask,
 		LinkLayerStatsClearReq.stopReq);
 
-	if (CDF_STATUS_SUCCESS == sme_ll_stats_clear_req(pHddCtx->hHal,
+	if (QDF_STATUS_SUCCESS == sme_ll_stats_clear_req(pHddCtx->hHal,
 					&LinkLayerStatsClearReq)) {
 		temp_skbuff = cfg80211_vendor_cmd_alloc_reply_skb(wiphy,
 								  2 *
@@ -1537,7 +1537,7 @@ static int __wlan_hdd_cfg80211_stats_ext_request(struct wiphy *wiphy,
 	struct net_device *dev = wdev->netdev;
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	int ret_val;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	hdd_context_t *hdd_ctx = wiphy_priv(wiphy);
 
 	ENTER();
@@ -1556,7 +1556,7 @@ static int __wlan_hdd_cfg80211_stats_ext_request(struct wiphy *wiphy,
 
 	status = sme_stats_ext_request(pAdapter->sessionId, &stats_ext_req);
 
-	if (CDF_STATUS_SUCCESS != status)
+	if (QDF_STATUS_SUCCESS != status)
 		ret_val = -EINVAL;
 
 	return ret_val;

core/hdd/src/wlan_hdd_subnet_detect.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2015-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -78,7 +78,7 @@ static int __wlan_hdd_cfg80211_set_gateway_params(struct wiphy *wiphy,
 	struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_GW_PARAM_CONFIG_MAX + 1];
 	struct gateway_param_update_req req = { 0 };
 	int ret;
-	CDF_STATUS status;
+	QDF_STATUS status;
 
 	ENTER();
 
@@ -156,7 +156,7 @@ static int __wlan_hdd_cfg80211_set_gateway_params(struct wiphy *wiphy,
 	hdd_info("ipv6 addr: %pI6c", req.ipv6_addr);
 
 	status = sme_gateway_param_update(hdd_ctx->hHal, &req);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hdd_err("sme_gateway_param_update failed(err=%d)", status);
 		ret = -EINVAL;
 	}

core/hdd/src/wlan_hdd_tdls.c

@@ -234,11 +234,11 @@ static uint32_t wlan_hdd_tdls_discovery_sent_cnt(hdd_context_t *pHddCtx)
 	hdd_adapter_list_node_t *pAdapterNode = NULL, *pNext = NULL;
 	hdd_adapter_t *pAdapter = NULL;
 	tdlsCtx_t *pHddTdlsCtx = NULL;
-	CDF_STATUS status = 0;
+	QDF_STATUS status = 0;
 	uint32_t count = 0;
 
 	status = hdd_get_front_adapter(pHddCtx, &pAdapterNode);
-	while (NULL != pAdapterNode && CDF_STATUS_SUCCESS == status) {
+	while (NULL != pAdapterNode && QDF_STATUS_SUCCESS == status) {
 		pAdapter = pAdapterNode->pAdapter;
 
 		pHddTdlsCtx = WLAN_HDD_GET_TDLS_CTX_PTR(pAdapter);
@@ -535,7 +535,7 @@ int wlan_hdd_tdls_init(hdd_adapter_t *pAdapter)
 	int i;
 	uint8_t staIdx;
 	tdlsInfo_t *tInfo;
-	CDF_STATUS cdf_ret_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS cdf_ret_status = QDF_STATUS_E_FAILURE;
 
 	if (NULL == pHddCtx)
 		return -EINVAL;
@@ -723,7 +723,7 @@ int wlan_hdd_tdls_init(hdd_adapter_t *pAdapter)
 	dump_tdls_state_param_setting(tInfo);
 
 	cdf_ret_status = sme_update_fw_tdls_state(pHddCtx->hHal, tInfo, true);
-	if (CDF_STATUS_SUCCESS != cdf_ret_status) {
+	if (QDF_STATUS_SUCCESS != cdf_ret_status) {
 		cdf_mem_free(tInfo);
 		cdf_mc_timer_destroy(&pHddTdlsCtx->peerDiscoveryTimeoutTimer);
 		cdf_mem_free(pHddTdlsCtx);
@@ -744,7 +744,7 @@ void wlan_hdd_tdls_exit(hdd_adapter_t *pAdapter)
 	tdlsCtx_t *pHddTdlsCtx;
 	hdd_context_t *pHddCtx;
 	tdlsInfo_t *tInfo;
-	CDF_STATUS cdf_ret_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS cdf_ret_status = QDF_STATUS_E_FAILURE;
 
 	pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
 	if (!pHddCtx) {
@@ -826,7 +826,7 @@ void wlan_hdd_tdls_exit(hdd_adapter_t *pAdapter)
 
 			cdf_ret_status =
 				sme_update_fw_tdls_state(pHddCtx->hHal, tInfo, false);
-			if (CDF_STATUS_SUCCESS != cdf_ret_status) {
+			if (QDF_STATUS_SUCCESS != cdf_ret_status) {
 				cdf_mem_free(tInfo);
 			}
 		} else {
@@ -1530,7 +1530,7 @@ void wlan_hdd_tdls_set_mode(hdd_context_t *pHddCtx,
 			    eTDLSSupportMode tdls_mode, bool bUpdateLast)
 {
 	hdd_adapter_list_node_t *pAdapterNode = NULL, *pNext = NULL;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	hdd_adapter_t *pAdapter;
 	tdlsCtx_t *pHddTdlsCtx;
 
@@ -1551,7 +1551,7 @@ void wlan_hdd_tdls_set_mode(hdd_context_t *pHddCtx,
 
 	status = hdd_get_front_adapter(pHddCtx, &pAdapterNode);
 
-	while (NULL != pAdapterNode && CDF_STATUS_SUCCESS == status) {
+	while (NULL != pAdapterNode && QDF_STATUS_SUCCESS == status) {
 		pAdapter = pAdapterNode->pAdapter;
 		pHddTdlsCtx = WLAN_HDD_GET_TDLS_CTX_PTR(pAdapter);
 		if (NULL != pHddTdlsCtx) {
@@ -1591,7 +1591,7 @@ int wlan_hdd_tdls_set_params(struct net_device *dev,
 	tdlsCtx_t *pHddTdlsCtx = WLAN_HDD_GET_TDLS_CTX_PTR(pAdapter);
 	eTDLSSupportMode req_tdls_mode;
 	tdlsInfo_t *tdlsParams;
-	CDF_STATUS cdf_ret_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS cdf_ret_status = QDF_STATUS_E_FAILURE;
 
 	if (NULL == pHddTdlsCtx) {
 		hddLog(LOGE, FL("TDLS not enabled!"));
@@ -1666,7 +1666,7 @@ int wlan_hdd_tdls_set_params(struct net_device *dev,
 	dump_tdls_state_param_setting(tdlsParams);
 
 	cdf_ret_status = sme_update_fw_tdls_state(pHddCtx->hHal, tdlsParams, true);
-	if (CDF_STATUS_SUCCESS != cdf_ret_status) {
+	if (QDF_STATUS_SUCCESS != cdf_ret_status) {
 		cdf_mem_free(tdlsParams);
 		return -EINVAL;
 	}
@@ -1697,7 +1697,7 @@ void wlan_hdd_update_tdls_info(hdd_adapter_t *adapter, bool tdls_prohibited,
 	hdd_context_t *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
 	tdlsCtx_t *hdd_tdls_ctx = WLAN_HDD_GET_TDLS_CTX_PTR(adapter);
 	tdlsInfo_t *tdls_param;
-	CDF_STATUS cdf_ret_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS cdf_ret_status = QDF_STATUS_E_FAILURE;
 
 	if (!hdd_tdls_ctx) {
 		/* may be TDLS is not applicable for this adapter */
@@ -1777,7 +1777,7 @@ void wlan_hdd_update_tdls_info(hdd_adapter_t *adapter, bool tdls_prohibited,
 	cdf_ret_status = sme_update_fw_tdls_state(hdd_ctx->hHal,
 					       tdls_param,
 					       true);
-	if (CDF_STATUS_SUCCESS != cdf_ret_status) {
+	if (QDF_STATUS_SUCCESS != cdf_ret_status) {
 		cdf_mem_free(tdls_param);
 		return;
 	}
@@ -1855,7 +1855,7 @@ int wlan_hdd_tdls_update_peer_mac(hdd_adapter_t *adapter, const uint8_t *mac,
 				  uint32_t peer_state)
 {
 	tSmeTdlsPeerStateParams sme_tdls_peer_state_params = {0};
-	CDF_STATUS status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
 	hdd_context_t *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
 
 	sme_tdls_peer_state_params.vdevId = adapter->sessionId;
@@ -1864,7 +1864,7 @@ int wlan_hdd_tdls_update_peer_mac(hdd_adapter_t *adapter, const uint8_t *mac,
 	sme_tdls_peer_state_params.peerState = peer_state;
 	status = sme_update_tdls_peer_state(hdd_ctx->hHal,
 					    &sme_tdls_peer_state_params);
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		hddLog(LOGE, FL("sme_UpdateTdlsPeerState failed for "MAC_ADDRESS_STR),
 				MAC_ADDR_ARRAY(mac));
 		return -EPERM;
@@ -1971,12 +1971,12 @@ hddTdlsPeer_t *wlan_hdd_tdls_find_all_peer(hdd_context_t *pHddCtx,
 	hdd_adapter_t *pAdapter = NULL;
 	tdlsCtx_t *pHddTdlsCtx = NULL;
 	hddTdlsPeer_t *curr_peer = NULL;
-	CDF_STATUS status = 0;
+	QDF_STATUS status = 0;
 
 	mutex_lock(&pHddCtx->tdls_lock);
 
 	status = hdd_get_front_adapter(pHddCtx, &pAdapterNode);
-	while (NULL != pAdapterNode && CDF_STATUS_SUCCESS == status) {
+	while (NULL != pAdapterNode && QDF_STATUS_SUCCESS == status) {
 		pAdapter = pAdapterNode->pAdapter;
 
 		pHddTdlsCtx = WLAN_HDD_GET_TDLS_CTX_PTR(pAdapter);
@@ -2366,12 +2366,12 @@ hddTdlsPeer_t *wlan_hdd_tdls_is_progress(hdd_context_t *pHddCtx,
 	hdd_adapter_t *pAdapter = NULL;
 	tdlsCtx_t *pHddTdlsCtx = NULL;
 	hddTdlsPeer_t *curr_peer = NULL;
-	CDF_STATUS status = 0;
+	QDF_STATUS status = 0;
 
 	mutex_lock(&pHddCtx->tdls_lock);
 
 	status = hdd_get_front_adapter(pHddCtx, &pAdapterNode);
-	while (NULL != pAdapterNode && CDF_STATUS_SUCCESS == status) {
+	while (NULL != pAdapterNode && QDF_STATUS_SUCCESS == status) {
 		pAdapter = pAdapterNode->pAdapter;
 
 		pHddTdlsCtx = WLAN_HDD_GET_TDLS_CTX_PTR(pAdapter);
@@ -3055,7 +3055,7 @@ __wlan_hdd_cfg80211_exttdls_get_status(struct wiphy *wiphy,
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	hdd_context_t *pHddCtx = wiphy_priv(wiphy);
 	struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_TDLS_GET_STATUS_MAX + 1];
-	CDF_STATUS ret;
+	QDF_STATUS ret;
 	uint32_t state;
 	int32_t reason;
 	uint32_t global_operating_class = 0;
@@ -3237,7 +3237,7 @@ __wlan_hdd_cfg80211_exttdls_enable(struct wiphy *wiphy,
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	hdd_context_t *pHddCtx = wiphy_priv(wiphy);
 	struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_TDLS_ENABLE_MAX + 1];
-	CDF_STATUS status;
+	QDF_STATUS status;
 	tdls_req_params_t pReqMsg = { 0 };
 	int ret;
 
@@ -3360,7 +3360,7 @@ static int __wlan_hdd_cfg80211_exttdls_disable(struct wiphy *wiphy,
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	hdd_context_t *pHddCtx = wiphy_priv(wiphy);
 	struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_TDLS_DISABLE_MAX + 1];
-	CDF_STATUS status;
+	QDF_STATUS status;
 
 	if (CDF_GLOBAL_FTM_MODE == hdd_get_conparam()) {
 		hdd_err("Command not allowed in FTM mode");
@@ -3429,7 +3429,7 @@ int wlan_hdd_tdls_add_station(struct wiphy *wiphy,
 {
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	hdd_context_t *pHddCtx = wiphy_priv(wiphy);
-	CDF_STATUS status;
+	QDF_STATUS status;
 	hddTdlsPeer_t *pTdlsPeer;
 	uint16_t numCurrTdlsPeers;
 	unsigned long rc;
@@ -3588,7 +3588,7 @@ int wlan_hdd_tdls_add_station(struct wiphy *wiphy,
 		return -EPERM;
 	}
 
-	if (CDF_STATUS_SUCCESS != pAdapter->tdlsAddStaStatus) {
+	if (QDF_STATUS_SUCCESS != pAdapter->tdlsAddStaStatus) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Add Station is unsuccessful", __func__);
 		return -EPERM;
@@ -3671,7 +3671,7 @@ static int __wlan_hdd_cfg80211_tdls_mgmt(struct wiphy *wiphy,
 	hdd_context_t *pHddCtx = wiphy_priv(wiphy);
 	hdd_station_ctx_t *hdd_sta_ctx;
 	u8 peerMac[CDF_MAC_ADDR_SIZE];
-	CDF_STATUS status;
+	QDF_STATUS status;
 	int max_sta_failed = 0;
 	int responder;
 	unsigned long rc;
@@ -3859,7 +3859,7 @@ static int __wlan_hdd_cfg80211_tdls_mgmt(struct wiphy *wiphy,
 					  peer_capability, (uint8_t *) buf, len,
 					  !responder);
 
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  "%s: sme_send_tdls_mgmt_frame failed!", __func__);
 		pAdapter->mgmtTxCompletionStatus = false;
@@ -4157,7 +4157,7 @@ static int __wlan_hdd_cfg80211_tdls_oper(struct wiphy *wiphy,
 	hdd_context_t *pHddCtx = wiphy_priv(wiphy);
 	int status;
 	tSmeTdlsPeerStateParams smeTdlsPeerStateParams;
-	CDF_STATUS cdf_ret_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS cdf_ret_status = QDF_STATUS_E_FAILURE;
 	hddTdlsPeer_t *pTdlsPeer;
 
 	ENTER();
@@ -4194,7 +4194,7 @@ static int __wlan_hdd_cfg80211_tdls_oper(struct wiphy *wiphy,
 	switch (oper) {
 	case NL80211_TDLS_ENABLE_LINK:
 	{
-		CDF_STATUS status;
+		QDF_STATUS status;
 		unsigned long rc;
 		tCsrTdlsLinkEstablishParams tdlsLinkEstablishParams;
 
@@ -4269,7 +4269,7 @@ static int __wlan_hdd_cfg80211_tdls_oper(struct wiphy *wiphy,
 							  pTdlsPeer->staId,
 							  pTdlsPeer->
 							  signature);
-			if (CDF_STATUS_SUCCESS == status) {
+			if (QDF_STATUS_SUCCESS == status) {
 				uint8_t i;
 
 				cdf_mem_zero(&smeTdlsPeerStateParams,
@@ -4388,7 +4388,7 @@ static int __wlan_hdd_cfg80211_tdls_oper(struct wiphy *wiphy,
 					sme_update_tdls_peer_state(pHddCtx->
 								   hHal,
 								   &smeTdlsPeerStateParams);
-				if (CDF_STATUS_SUCCESS !=
+				if (QDF_STATUS_SUCCESS !=
 				    cdf_ret_status) {
 					CDF_TRACE(CDF_MODULE_ID_HDD,
 						  CDF_TRACE_LEVEL_ERROR,
@@ -4741,7 +4741,7 @@ int hdd_set_tdls_offchannelmode(hdd_adapter_t *adapter, int offchanmode)
 	hdd_station_ctx_t *hdd_sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(adapter);
 	hdd_context_t *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
 	sme_tdls_chan_switch_params chan_switch_params;
-	CDF_STATUS status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
 
 	if (offchanmode < ENABLE_CHANSWITCH ||
 			offchanmode > DISABLE_CHANSWITCH) {
@@ -4834,7 +4834,7 @@ int hdd_set_tdls_offchannelmode(hdd_adapter_t *adapter, int offchanmode)
 	status = sme_send_tdls_chan_switch_req(WLAN_HDD_GET_HAL_CTX(adapter),
 			&chan_switch_params);
 
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		hdd_log(LOG1,
 			FL("Failed to send channel switch request to sme"));
 		return -EINVAL;

core/hdd/src/wlan_hdd_tx_rx.c

@@ -292,7 +292,7 @@ static bool wlan_hdd_is_eapol_or_wai(struct sk_buff *skb)
  */
 int hdd_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
-	CDF_STATUS status;
+	QDF_STATUS status;
 	sme_ac_enum_type ac;
 	sme_QosWmmUpType up;
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
@@ -325,7 +325,7 @@ int hdd_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 		struct cdf_mac_addr *pDestMacAddress =
 					(struct cdf_mac_addr *) skb->data;
 
-		if (CDF_STATUS_SUCCESS !=
+		if (QDF_STATUS_SUCCESS !=
 				hdd_ibss_get_sta_id(&pAdapter->sessionCtx.station,
 					pDestMacAddress, &STAId))
 			STAId = HDD_WLAN_INVALID_STA_ID;
@@ -522,10 +522,10 @@ drop_pkt:
  * @pMacAddress: pointer to Peer Mac address
  * @staID: pointer to returned Station Index
  *
- * Return: CDF_STATUS_SUCCESS/CDF_STATUS_E_FAILURE
+ * Return: QDF_STATUS_SUCCESS/QDF_STATUS_E_FAILURE
  */
 
-CDF_STATUS hdd_ibss_get_sta_id(hdd_station_ctx_t *pHddStaCtx,
+QDF_STATUS hdd_ibss_get_sta_id(hdd_station_ctx_t *pHddStaCtx,
 			       struct cdf_mac_addr *pMacAddress, uint8_t *staId)
 {
 	uint8_t idx;
@@ -534,11 +534,11 @@ CDF_STATUS hdd_ibss_get_sta_id(hdd_station_ctx_t *pHddStaCtx,
 		if (cdf_mem_compare(&pHddStaCtx->conn_info.peerMacAddress[idx],
 				    pMacAddress, CDF_MAC_ADDR_SIZE)) {
 			*staId = pHddStaCtx->conn_info.staId[idx];
-			return CDF_STATUS_SUCCESS;
+			return QDF_STATUS_SUCCESS;
 		}
 	}
 
-	return CDF_STATUS_E_FAILURE;
+	return QDF_STATUS_E_FAILURE;
 }
 
 /**
@@ -601,18 +601,18 @@ void hdd_tx_timeout(struct net_device *dev)
  * @hdd_init_tx_rx() - Initialize Tx/RX module
  * @pAdapter: pointer to adapter context
  *
- * Return: CDF_STATUS_E_FAILURE if any errors encountered,
- *	   CDF_STATUS_SUCCESS otherwise
+ * Return: QDF_STATUS_E_FAILURE if any errors encountered,
+ *	   QDF_STATUS_SUCCESS otherwise
  */
-CDF_STATUS hdd_init_tx_rx(hdd_adapter_t *pAdapter)
+QDF_STATUS hdd_init_tx_rx(hdd_adapter_t *pAdapter)
 {
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	if (NULL == pAdapter) {
 		CDF_TRACE(CDF_MODULE_ID_HDD_DATA, CDF_TRACE_LEVEL_ERROR,
 			  FL("pAdapter is NULL"));
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	return status;
@@ -622,18 +622,18 @@ CDF_STATUS hdd_init_tx_rx(hdd_adapter_t *pAdapter)
  * @hdd_deinit_tx_rx() - Deinitialize Tx/RX module
  * @pAdapter: pointer to adapter context
  *
- * Return: CDF_STATUS_E_FAILURE if any errors encountered,
- *	   CDF_STATUS_SUCCESS otherwise
+ * Return: QDF_STATUS_E_FAILURE if any errors encountered,
+ *	   QDF_STATUS_SUCCESS otherwise
  */
-CDF_STATUS hdd_deinit_tx_rx(hdd_adapter_t *pAdapter)
+QDF_STATUS hdd_deinit_tx_rx(hdd_adapter_t *pAdapter)
 {
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	if (NULL == pAdapter) {
 		CDF_TRACE(CDF_MODULE_ID_HDD_DATA, CDF_TRACE_LEVEL_ERROR,
 			  FL("pAdapter is NULL"));
 		CDF_ASSERT(0);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	return status;
@@ -649,10 +649,10 @@ CDF_STATUS hdd_deinit_tx_rx(hdd_adapter_t *pAdapter)
  * the HDD when one or more packets were received for a registered
  * STA.
  *
- * Return: CDF_STATUS_E_FAILURE if any errors encountered,
- *	   CDF_STATUS_SUCCESS otherwise
+ * Return: QDF_STATUS_E_FAILURE if any errors encountered,
+ *	   QDF_STATUS_SUCCESS otherwise
  */
-CDF_STATUS hdd_rx_packet_cbk(void *cds_context, cdf_nbuf_t rxBuf, uint8_t staId)
+QDF_STATUS hdd_rx_packet_cbk(void *cds_context, cdf_nbuf_t rxBuf, uint8_t staId)
 {
 	hdd_adapter_t *pAdapter = NULL;
 	hdd_context_t *pHddCtx = NULL;
@@ -668,14 +668,14 @@ CDF_STATUS hdd_rx_packet_cbk(void *cds_context, cdf_nbuf_t rxBuf, uint8_t staId)
 	if ((NULL == cds_context) || (NULL == rxBuf)) {
 		CDF_TRACE(CDF_MODULE_ID_HDD_DATA, CDF_TRACE_LEVEL_ERROR,
 			  "%s: Null params being passed", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	pHddCtx = cds_get_context(CDF_MODULE_ID_HDD);
 	if (NULL == pHddCtx) {
 		CDF_TRACE(CDF_MODULE_ID_HDD_DATA, CDF_TRACE_LEVEL_ERROR,
 			  "%s: HDD context is Null", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	pAdapter = pHddCtx->sta_to_adapter[staId];
@@ -683,7 +683,7 @@ CDF_STATUS hdd_rx_packet_cbk(void *cds_context, cdf_nbuf_t rxBuf, uint8_t staId)
 		hddLog(LOGE,
 			FL("invalid adapter %p or adapter has invalid magic"),
 			pAdapter);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 	cpu_index = wlan_hdd_get_cpu();
 
@@ -693,7 +693,7 @@ CDF_STATUS hdd_rx_packet_cbk(void *cds_context, cdf_nbuf_t rxBuf, uint8_t staId)
 		CDF_TRACE(CDF_MODULE_ID_HDD_DATA, CDF_TRACE_LEVEL_FATAL,
 			  "Magic cookie(%x) for adapter sanity verification is invalid",
 			  pAdapter->magic);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
@@ -707,7 +707,7 @@ CDF_STATUS hdd_rx_packet_cbk(void *cds_context, cdf_nbuf_t rxBuf, uint8_t staId)
 		 * it to stack
 		 */
 		cdf_nbuf_free(skb);
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 
 	wlan_hdd_log_eapol(skb, WIFI_EVENT_DRIVER_EAPOL_FRAME_RECEIVED);
@@ -764,7 +764,7 @@ CDF_STATUS hdd_rx_packet_cbk(void *cds_context, cdf_nbuf_t rxBuf, uint8_t staId)
 
 	pAdapter->dev->last_rx = jiffies;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 #ifdef FEATURE_WLAN_DIAG_SUPPORT

core/hdd/src/wlan_hdd_wext.c

@@ -799,7 +799,7 @@ int hdd_wlan_get_rts_threshold(hdd_adapter_t *pAdapter, union iwreq_data *wrqu)
 	if (0 != ret)
 		return ret;
 
-	if (CDF_STATUS_SUCCESS !=
+	if (QDF_STATUS_SUCCESS !=
 	    sme_cfg_get_int(hHal, WNI_CFG_RTS_THRESHOLD, &threshold)) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_WARN,
 			  FL
@@ -847,7 +847,7 @@ int hdd_wlan_get_frag_threshold(hdd_adapter_t *pAdapter,
 		return status;
 
 	if (sme_cfg_get_int(hHal, WNI_CFG_FRAGMENTATION_THRESHOLD, &threshold)
-	    != CDF_STATUS_SUCCESS) {
+	    != QDF_STATUS_SUCCESS) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_WARN,
 			  FL
 				  ("failed to get ini parameter, WNI_CFG_FRAGMENTATION_THRESHOLD"));
@@ -1088,27 +1088,27 @@ static void hdd_get_snr_cb(int8_t snr, uint32_t staId, void *pContext)
  * @pAdapter: adapter upon which the measurement is requested
  * @rssi_value: pointer to where the RSSI should be returned
  *
- * Return: CDF_STATUS_SUCCESS on success, CDF_STATUS_E_* on error
+ * Return: QDF_STATUS_SUCCESS on success, CDF_STATUS_E_* on error
  */
-CDF_STATUS wlan_hdd_get_rssi(hdd_adapter_t *pAdapter, int8_t *rssi_value)
+QDF_STATUS wlan_hdd_get_rssi(hdd_adapter_t *pAdapter, int8_t *rssi_value)
 {
 	struct statsContext context;
 	hdd_context_t *pHddCtx;
 	hdd_station_ctx_t *pHddStaCtx;
-	CDF_STATUS hstatus;
+	QDF_STATUS hstatus;
 	unsigned long rc;
 
 	if (NULL == pAdapter) {
 		hddLog(CDF_TRACE_LEVEL_WARN,
 		       "%s: Invalid context, pAdapter", __func__);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 	if (cds_is_driver_recovering()) {
 		hdd_err("Recovery in Progress. State: 0x%x Ignore!!!",
 			cds_get_driver_state());
 		/* return a cached value */
 		*rssi_value = pAdapter->rssi;
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 
 	pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
@@ -1117,13 +1117,13 @@ CDF_STATUS wlan_hdd_get_rssi(hdd_adapter_t *pAdapter, int8_t *rssi_value)
 	if (eConnectionState_Associated != pHddStaCtx->conn_info.connState) {
 		hdd_err("Not associated!, return last connected AP rssi!");
 		*rssi_value = pAdapter->rssi;
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 
 	if (pHddStaCtx->hdd_ReassocScenario) {
 		hdd_info("Roaming in progress, return cached RSSI");
 		*rssi_value = pAdapter->rssi;
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 
 	init_completion(&context.completion);
@@ -1134,7 +1134,7 @@ CDF_STATUS wlan_hdd_get_rssi(hdd_adapter_t *pAdapter, int8_t *rssi_value)
 			       pHddStaCtx->conn_info.staId[0],
 			       pHddStaCtx->conn_info.bssId, pAdapter->rssi,
 			       &context, pHddCtx->pcds_context);
-	if (CDF_STATUS_SUCCESS != hstatus) {
+	if (QDF_STATUS_SUCCESS != hstatus) {
 		hddLog(CDF_TRACE_LEVEL_ERROR, "%s: Unable to retrieve RSSI",
 		       __func__);
 		/* we'll returned a cached value below */
@@ -1169,7 +1169,7 @@ CDF_STATUS wlan_hdd_get_rssi(hdd_adapter_t *pAdapter, int8_t *rssi_value)
 
 	*rssi_value = pAdapter->rssi;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -1177,14 +1177,14 @@ CDF_STATUS wlan_hdd_get_rssi(hdd_adapter_t *pAdapter, int8_t *rssi_value)
  * @pAdapter: adapter upon which the measurement is requested
  * @snr: pointer to where the SNR should be returned
  *
- * Return: CDF_STATUS_SUCCESS on success, CDF_STATUS_E_* on error
+ * Return: QDF_STATUS_SUCCESS on success, CDF_STATUS_E_* on error
  */
-CDF_STATUS wlan_hdd_get_snr(hdd_adapter_t *pAdapter, int8_t *snr)
+QDF_STATUS wlan_hdd_get_snr(hdd_adapter_t *pAdapter, int8_t *snr)
 {
 	struct statsContext context;
 	hdd_context_t *pHddCtx;
 	hdd_station_ctx_t *pHddStaCtx;
-	CDF_STATUS hstatus;
+	QDF_STATUS hstatus;
 	unsigned long rc;
 	int valid;
 
@@ -1193,14 +1193,14 @@ CDF_STATUS wlan_hdd_get_snr(hdd_adapter_t *pAdapter, int8_t *snr)
 	if (NULL == pAdapter) {
 		hddLog(CDF_TRACE_LEVEL_ERROR,
 		       "%s: Invalid context, pAdapter", __func__);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 
 	pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
 
 	valid = wlan_hdd_validate_context(pHddCtx);
 	if (0 != valid)
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 
 	pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
 
@@ -1211,7 +1211,7 @@ CDF_STATUS wlan_hdd_get_snr(hdd_adapter_t *pAdapter, int8_t *snr)
 	hstatus = sme_get_snr(pHddCtx->hHal, hdd_get_snr_cb,
 			      pHddStaCtx->conn_info.staId[0],
 			      pHddStaCtx->conn_info.bssId, &context);
-	if (CDF_STATUS_SUCCESS != hstatus) {
+	if (QDF_STATUS_SUCCESS != hstatus) {
 		hddLog(CDF_TRACE_LEVEL_ERROR, "%s: Unable to retrieve RSSI",
 		       __func__);
 		/* we'll returned a cached value below */
@@ -1246,7 +1246,7 @@ CDF_STATUS wlan_hdd_get_snr(hdd_adapter_t *pAdapter, int8_t *snr)
 
 	*snr = pAdapter->snr;
 	EXIT();
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -1326,25 +1326,25 @@ hdd_get_link_speed_cb(tSirLinkSpeedInfo *pLinkSpeed, void *pContext)
  * This function will send a query to SME for the linkspeed of the
  * given peer, and then wait for the callback to be invoked.
  *
- * Return: CDF_STATUS_SUCCESS if linkspeed data is available,
+ * Return: QDF_STATUS_SUCCESS if linkspeed data is available,
  * otherwise a CDF_STATUS_E_* error.
  */
-CDF_STATUS wlan_hdd_get_linkspeed_for_peermac(hdd_adapter_t *pAdapter,
+QDF_STATUS wlan_hdd_get_linkspeed_for_peermac(hdd_adapter_t *pAdapter,
 					      struct cdf_mac_addr macAddress) {
-	CDF_STATUS status;
+	QDF_STATUS status;
 	unsigned long rc;
 	struct linkspeedContext context;
 	tSirLinkSpeedInfo *linkspeed_req;
 
 	if (NULL == pAdapter) {
 		hddLog(CDF_TRACE_LEVEL_ERROR, "%s: pAdapter is NULL", __func__);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 	linkspeed_req = cdf_mem_malloc(sizeof(*linkspeed_req));
 	if (NULL == linkspeed_req) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  "%s Request Buffer Alloc Fail", __func__);
-		return CDF_STATUS_E_NOMEM;
+		return QDF_STATUS_E_NOMEM;
 	}
 	init_completion(&context.completion);
 	context.pAdapter = pAdapter;
@@ -1354,7 +1354,7 @@ CDF_STATUS wlan_hdd_get_linkspeed_for_peermac(hdd_adapter_t *pAdapter,
 	status = sme_get_link_speed(WLAN_HDD_GET_HAL_CTX(pAdapter),
 				    linkspeed_req,
 				    &context, hdd_get_link_speed_cb);
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		hddLog(CDF_TRACE_LEVEL_ERROR,
 		       "%s: Unable to retrieve statistics for link speed",
 		       __func__);
@@ -1386,7 +1386,7 @@ CDF_STATUS wlan_hdd_get_linkspeed_for_peermac(hdd_adapter_t *pAdapter,
 	spin_lock(&hdd_context_lock);
 	context.magic = 0;
 	spin_unlock(&hdd_context_lock);
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -1418,13 +1418,13 @@ int wlan_hdd_get_link_speed(hdd_adapter_t *sta_adapter, uint32_t *link_speed)
 		/* we are not connected so we don't have a classAstats */
 		*link_speed = 0;
 	} else {
-		CDF_STATUS status;
+		QDF_STATUS status;
 		struct cdf_mac_addr bssid;
 
 		cdf_copy_macaddr(&bssid, &hdd_stactx->conn_info.bssId);
 
 		status = wlan_hdd_get_linkspeed_for_peermac(sta_adapter, bssid);
-		if (!CDF_IS_STATUS_SUCCESS(status)) {
+		if (!QDF_IS_STATUS_SUCCESS(status)) {
 			hddLog(LOGE, FL("Unable to retrieve SME linkspeed"));
 			return -EINVAL;
 		}
@@ -1772,14 +1772,14 @@ static int __iw_set_mode(struct net_device *dev,
 		if (hdd_conn_get_connected_bss_type
 			    (WLAN_HDD_GET_STATION_CTX_PTR(pAdapter), &connectedBssType)
 		    || (eCSR_BSS_TYPE_START_IBSS == LastBSSType)) {
-			CDF_STATUS cdf_status;
+			QDF_STATUS qdf_status;
 			/* need to issue a disconnect to CSR. */
 			INIT_COMPLETION(pAdapter->disconnect_comp_var);
-			cdf_status =
+			qdf_status =
 				sme_roam_disconnect(WLAN_HDD_GET_HAL_CTX(pAdapter),
 						    pAdapter->sessionId,
 						    eCSR_DISCONNECT_REASON_IBSS_LEAVE);
-			if (CDF_STATUS_SUCCESS == cdf_status) {
+			if (QDF_STATUS_SUCCESS == qdf_status) {
 				unsigned long rc;
 				rc = wait_for_completion_timeout(&pAdapter->
 								 disconnect_comp_var,
@@ -1961,7 +1961,7 @@ static int __iw_set_freq(struct net_device *dev, struct iw_request_info *info,
 
 		if (sme_cfg_get_str(hHal, WNI_CFG_VALID_CHANNEL_LIST,
 				    validChan, &numChans) !=
-				CDF_STATUS_SUCCESS) {
+				QDF_STATUS_SUCCESS) {
 			CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_WARN, FL
 				  ("failed to get ini parameter, WNI_CFG_VALID_CHANNEL_LIST"));
 			return -EIO;
@@ -2050,7 +2050,7 @@ static int __iw_get_freq(struct net_device *dev, struct iw_request_info *info,
 
 	if (pHddStaCtx->conn_info.connState == eConnectionState_Associated) {
 		if (sme_get_operation_channel(hHal, &channel, pAdapter->sessionId)
-		    != CDF_STATUS_SUCCESS) {
+		    != QDF_STATUS_SUCCESS) {
 			CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 				  FL("failed to get operating channel %u"),
 				  pAdapter->sessionId);
@@ -2181,7 +2181,7 @@ static int __iw_set_tx_power(struct net_device *dev,
 		return ret;
 
 	if (sme_cfg_set_int(hHal, WNI_CFG_CURRENT_TX_POWER_LEVEL,
-				wrqu->txpower.value) != CDF_STATUS_SUCCESS) {
+				wrqu->txpower.value) != QDF_STATUS_SUCCESS) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR, FL
 				("failed to set ini parameter, WNI_CFG_CURRENT_TX_POWER_LEVEL"));
 		return -EIO;
@@ -2227,9 +2227,8 @@ static int __iw_get_bitrate(struct net_device *dev,
 			    struct iw_request_info *info,
 			    union iwreq_data *wrqu, char *extra)
 {
-	CDF_STATUS cdf_status = CDF_STATUS_SUCCESS;
 	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	hdd_wext_state_t *pWextState;
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	hdd_station_ctx_t *pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
@@ -2266,7 +2265,7 @@ static int __iw_get_bitrate(struct net_device *dev,
 					   pHddStaCtx->conn_info.staId[0],
 					   pAdapter, pAdapter->sessionId);
 
-		if (CDF_STATUS_SUCCESS != status) {
+		if (QDF_STATUS_SUCCESS != status) {
 			hddLog(CDF_TRACE_LEVEL_ERROR,
 			       "%s: Unable to retrieve statistics", __func__);
 			return status;
@@ -2282,7 +2281,7 @@ static int __iw_get_bitrate(struct net_device *dev,
 			hddLog(CDF_TRACE_LEVEL_ERROR,
 			       "%s: SME timeout while retrieving statistics",
 			       __func__);
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 
 		wrqu->bitrate.value =
@@ -2291,7 +2290,7 @@ static int __iw_get_bitrate(struct net_device *dev,
 
 	EXIT();
 
-	return cdf_status;
+	return qdf_status;
 }
 
 /**
@@ -2360,17 +2359,17 @@ static int __iw_set_bitrate(struct net_device *dev,
 		valid_rate = true;
 	} else if (sme_cfg_get_int(WLAN_HDD_GET_HAL_CTX(pAdapter),
 				   WNI_CFG_DOT11_MODE,
-				   &active_phy_mode) == CDF_STATUS_SUCCESS) {
+				   &active_phy_mode) == QDF_STATUS_SUCCESS) {
 		if (active_phy_mode == WNI_CFG_DOT11_MODE_11A
 		    || active_phy_mode == WNI_CFG_DOT11_MODE_11G
 		    || active_phy_mode == WNI_CFG_DOT11_MODE_11B) {
 			if ((sme_cfg_get_str(WLAN_HDD_GET_HAL_CTX(pAdapter),
 				     WNI_CFG_SUPPORTED_RATES_11A, supp_rates,
-				     &a_len) == CDF_STATUS_SUCCESS)
+				     &a_len) == QDF_STATUS_SUCCESS)
 			    &&
 			    (sme_cfg_get_str(WLAN_HDD_GET_HAL_CTX(pAdapter),
 				     WNI_CFG_SUPPORTED_RATES_11B, supp_rates,
-				     &b_len) == CDF_STATUS_SUCCESS)) {
+				     &b_len) == QDF_STATUS_SUCCESS)) {
 				for (i = 0; i < (b_len + a_len); ++i) {
 					/* supported rates returned is double
 					 * the actual rate so we divide it by 2
@@ -2390,7 +2389,7 @@ static int __iw_set_bitrate(struct net_device *dev,
 		return -EINVAL;
 	}
 	if (sme_cfg_set_int(WLAN_HDD_GET_HAL_CTX(pAdapter),
-			    WNI_CFG_FIXED_RATE, rate) != CDF_STATUS_SUCCESS) {
+			    WNI_CFG_FIXED_RATE, rate) != QDF_STATUS_SUCCESS) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR, FL
 				("failed to set ini parameter, WNI_CFG_FIXED_RATE"));
 		return -EIO;
@@ -2606,7 +2605,7 @@ static int __iw_get_genie(struct net_device *dev,
 	hdd_wext_state_t *pWextState;
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	hdd_station_ctx_t *pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
-	CDF_STATUS status;
+	QDF_STATUS status;
 	uint32_t length = DOT11F_IE_RSN_MAX_LEN;
 	uint8_t genIeBytes[DOT11F_IE_RSN_MAX_LEN];
 	hdd_context_t *hdd_ctx;
@@ -2825,7 +2824,7 @@ static int __iw_set_rts_threshold(struct net_device *dev,
 	}
 
 	if (sme_cfg_set_int(hHal, WNI_CFG_RTS_THRESHOLD, wrqu->rts.value) !=
-			CDF_STATUS_SUCCESS) {
+			QDF_STATUS_SUCCESS) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR, FL
 				("failed to set ini parameter, WNI_CFG_RTS_THRESHOLD"));
 		return -EIO;
@@ -2955,7 +2954,7 @@ static int __iw_set_frag_threshold(struct net_device *dev,
 
 	if (sme_cfg_set_int
 		    (hHal, WNI_CFG_FRAGMENTATION_THRESHOLD, wrqu->frag.value)
-		    != CDF_STATUS_SUCCESS) {
+		    != QDF_STATUS_SUCCESS) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR, FL
 				("failed to set ini parameter, WNI_CFG_FRAGMENTATION_THRESHOLD"));
 		return -EIO;
@@ -3129,7 +3128,7 @@ static int __iw_get_range(struct net_device *dev, struct iw_request_info *info,
 	/*Get the phy mode */
 	if (sme_cfg_get_int(hHal,
 			    WNI_CFG_DOT11_MODE,
-			    &active_phy_mode) == CDF_STATUS_SUCCESS) {
+			    &active_phy_mode) == QDF_STATUS_SUCCESS) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_INFO,
 			  "active_phy_mode = %d", active_phy_mode);
 
@@ -3140,7 +3139,7 @@ static int __iw_get_range(struct net_device *dev, struct iw_request_info *info,
 			if (sme_cfg_get_str(hHal,
 					    WNI_CFG_SUPPORTED_RATES_11A,
 					    supp_rates,
-					    &a_len) == CDF_STATUS_SUCCESS) {
+					    &a_len) == QDF_STATUS_SUCCESS) {
 				if (a_len > WNI_CFG_SUPPORTED_RATES_11A_LEN) {
 					a_len = WNI_CFG_SUPPORTED_RATES_11A_LEN;
 				}
@@ -3159,7 +3158,7 @@ static int __iw_get_range(struct net_device *dev, struct iw_request_info *info,
 			if (sme_cfg_get_str(hHal,
 					    WNI_CFG_SUPPORTED_RATES_11B,
 					    supp_rates,
-					    &b_len) == CDF_STATUS_SUCCESS) {
+					    &b_len) == QDF_STATUS_SUCCESS) {
 				if (b_len > WNI_CFG_SUPPORTED_RATES_11B_LEN) {
 					b_len = WNI_CFG_SUPPORTED_RATES_11B_LEN;
 				}
@@ -3191,7 +3190,7 @@ static int __iw_get_range(struct net_device *dev, struct iw_request_info *info,
 	/*Supported Channels and Frequencies */
 	if (sme_cfg_get_str
 		    ((hHal), WNI_CFG_VALID_CHANNEL_LIST, channels,
-		    &num_channels) != CDF_STATUS_SUCCESS) {
+		    &num_channels) != QDF_STATUS_SUCCESS) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_WARN,
 			  FL
 				  ("failed to get ini parameter, WNI_CFG_VALID_CHANNEL_LIST"));
@@ -3334,23 +3333,23 @@ static void hdd_get_class_a_statistics_cb(void *pStats, void *pContext)
  * wlan_hdd_get_class_astats() - Get Class A statistics
  * @pAdapter: adapter for which statistics are desired
  *
- * Return: CDF_STATUS_SUCCESS if adapter's Class A statistics were updated
+ * Return: QDF_STATUS_SUCCESS if adapter's Class A statistics were updated
  */
-CDF_STATUS wlan_hdd_get_class_astats(hdd_adapter_t *pAdapter)
+QDF_STATUS wlan_hdd_get_class_astats(hdd_adapter_t *pAdapter)
 {
 	hdd_station_ctx_t *pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
-	CDF_STATUS hstatus;
+	QDF_STATUS hstatus;
 	unsigned long rc;
 	struct statsContext context;
 
 	if (NULL == pAdapter) {
 		hddLog(CDF_TRACE_LEVEL_ERROR, "%s: pAdapter is NULL", __func__);
-		return CDF_STATUS_E_FAULT;
+		return QDF_STATUS_E_FAULT;
 	}
 	if (cds_is_driver_recovering()) {
 		hdd_err("Recovery in Progress. State: 0x%x Ignore!!!",
 			 cds_get_driver_state());
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 
 	/* we are connected so prepare our callback context */
@@ -3365,7 +3364,7 @@ CDF_STATUS wlan_hdd_get_class_astats(hdd_adapter_t *pAdapter)
 				     false, /* non-cached results */
 				     pHddStaCtx->conn_info.staId[0],
 				     &context, pAdapter->sessionId);
-	if (CDF_STATUS_SUCCESS != hstatus) {
+	if (QDF_STATUS_SUCCESS != hstatus) {
 		hddLog(CDF_TRACE_LEVEL_ERROR,
 		       "%s: Unable to retrieve Class A statistics", __func__);
 		/* we'll returned a cached value below */
@@ -3398,7 +3397,7 @@ CDF_STATUS wlan_hdd_get_class_astats(hdd_adapter_t *pAdapter)
 	spin_unlock(&hdd_context_lock);
 
 	/* either callback updated pAdapter stats or it has cached data */
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -3474,18 +3473,18 @@ static void hdd_get_station_statistics_cb(void *pStats, void *pContext)
  * wlan_hdd_get_station_stats() - Get station statistics
  * @pAdapter: adapter for which statistics are desired
  *
- * Return: CDF_STATUS_SUCCESS if adapter's statistics were updated
+ * Return: QDF_STATUS_SUCCESS if adapter's statistics were updated
  */
-CDF_STATUS wlan_hdd_get_station_stats(hdd_adapter_t *pAdapter)
+QDF_STATUS wlan_hdd_get_station_stats(hdd_adapter_t *pAdapter)
 {
 	hdd_station_ctx_t *pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
-	CDF_STATUS hstatus;
+	QDF_STATUS hstatus;
 	unsigned long rc;
 	struct statsContext context;
 
 	if (NULL == pAdapter) {
 		hddLog(CDF_TRACE_LEVEL_ERROR, "%s: pAdapter is NULL", __func__);
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 
 	/* we are connected so prepare our callback context */
@@ -3503,7 +3502,7 @@ CDF_STATUS wlan_hdd_get_station_stats(hdd_adapter_t *pAdapter)
 				     false, /* non-cached results */
 				     pHddStaCtx->conn_info.staId[0],
 				     &context, pAdapter->sessionId);
-	if (CDF_STATUS_SUCCESS != hstatus) {
+	if (QDF_STATUS_SUCCESS != hstatus) {
 		hddLog(CDF_TRACE_LEVEL_ERROR,
 		       "%s: Unable to retrieve statistics", __func__);
 		/* we'll return with cached values */
@@ -3537,7 +3536,7 @@ CDF_STATUS wlan_hdd_get_station_stats(hdd_adapter_t *pAdapter)
 	spin_unlock(&hdd_context_lock);
 
 	/* either callback updated pAdapter stats or it has cached data */
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -3748,7 +3747,7 @@ static int __iw_set_encode(struct net_device *dev, struct iw_request_info *info,
 	eCsrEncryptionType encryptionType = eCSR_ENCRYPT_TYPE_NONE;
 	bool fKeyPresent = 0;
 	int i;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	int ret;
 
 	ENTER();
@@ -3800,7 +3799,7 @@ static int __iw_set_encode(struct net_device *dev, struct iw_request_info *info,
 				sme_roam_disconnect(WLAN_HDD_GET_HAL_CTX(pAdapter),
 						    pAdapter->sessionId,
 						    eCSR_DISCONNECT_REASON_UNSPECIFIED);
-			if (CDF_STATUS_SUCCESS == status) {
+			if (QDF_STATUS_SUCCESS == status) {
 				unsigned long rc;
 				rc = wait_for_completion_timeout(&pAdapter->
 								 disconnect_comp_var,
@@ -4037,7 +4036,7 @@ static int __iw_set_encodeext(struct net_device *dev,
 	hdd_station_ctx_t *pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
 	hdd_wext_state_t *pWextState = WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter);
 	hdd_context_t *hdd_ctx;
-	CDF_STATUS cdf_ret_status = CDF_STATUS_SUCCESS;
+	QDF_STATUS cdf_ret_status = QDF_STATUS_SUCCESS;
 	tCsrRoamProfile *pRoamProfile = &pWextState->roamProfile;
 	int ret;
 	struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
@@ -4190,11 +4189,11 @@ static int __iw_set_encodeext(struct net_device *dev,
 	 */
 	cdf_ret_status = sme_ft_update_key(WLAN_HDD_GET_HAL_CTX(pAdapter),
 					   pAdapter->sessionId, &setKey);
-	if (cdf_ret_status == CDF_STATUS_FT_PREAUTH_KEY_SUCCESS) {
+	if (cdf_ret_status == QDF_STATUS_FT_PREAUTH_KEY_SUCCESS) {
 		hddLog(CDF_TRACE_LEVEL_INFO_MED,
 		       "%s: Update PreAuth Key success", __func__);
 		return 0;
-	} else if (cdf_ret_status == CDF_STATUS_FT_PREAUTH_KEY_FAILED) {
+	} else if (cdf_ret_status == QDF_STATUS_FT_PREAUTH_KEY_FAILED) {
 		hddLog(CDF_TRACE_LEVEL_ERROR,
 		       "%s: Update PreAuth Key failed", __func__);
 		return -EINVAL;
@@ -4206,7 +4205,7 @@ static int __iw_set_encodeext(struct net_device *dev,
 					  pAdapter->sessionId,
 					  &setKey, &roamId);
 
-	if (cdf_ret_status != CDF_STATUS_SUCCESS) {
+	if (cdf_ret_status != QDF_STATUS_SUCCESS) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  "[%4d] sme_roam_set_key returned ERROR status= %d",
 			  __LINE__, cdf_ret_status);
@@ -4277,7 +4276,7 @@ static int __iw_set_retry(struct net_device *dev, struct iw_request_info *info,
 		if ((wrqu->retry.flags & IW_RETRY_LONG)) {
 			if (sme_cfg_set_int (hHal, WNI_CFG_LONG_RETRY_LIMIT,
 						wrqu->retry.value) !=
-					CDF_STATUS_SUCCESS) {
+					QDF_STATUS_SUCCESS) {
 				CDF_TRACE(CDF_MODULE_ID_HDD,
 					  CDF_TRACE_LEVEL_ERROR, FL
 					  ("failed to set ini parameter, WNI_CFG_LONG_RETRY_LIMIT"));
@@ -4286,7 +4285,7 @@ static int __iw_set_retry(struct net_device *dev, struct iw_request_info *info,
 		} else if ((wrqu->retry.flags & IW_RETRY_SHORT)) {
 			if (sme_cfg_set_int (hHal, WNI_CFG_SHORT_RETRY_LIMIT,
 						wrqu->retry.value) !=
-					CDF_STATUS_SUCCESS) {
+					QDF_STATUS_SUCCESS) {
 				CDF_TRACE(CDF_MODULE_ID_HDD,
 					CDF_TRACE_LEVEL_ERROR, FL
 					("failed to set ini parameter, WNI_CFG_LONG_RETRY_LIMIT"));
@@ -4356,7 +4355,7 @@ static int __iw_get_retry(struct net_device *dev, struct iw_request_info *info,
 		wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
 
 		if (sme_cfg_get_int(hHal, WNI_CFG_LONG_RETRY_LIMIT, &retry) !=
-		    CDF_STATUS_SUCCESS) {
+		    QDF_STATUS_SUCCESS) {
 			CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_WARN,
 				  FL
 					  ("failed to get ini parameter, WNI_CFG_LONG_RETRY_LIMIT"));
@@ -4368,7 +4367,7 @@ static int __iw_get_retry(struct net_device *dev, struct iw_request_info *info,
 		wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_SHORT;
 
 		if (sme_cfg_get_int(hHal, WNI_CFG_SHORT_RETRY_LIMIT, &retry) !=
-		    CDF_STATUS_SUCCESS) {
+		    QDF_STATUS_SUCCESS) {
 			CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_WARN,
 				  FL
 					  ("failed to get ini parameter, WNI_CFG_LONG_RETRY_LIMIT"));
@@ -4425,7 +4424,7 @@ static int __iw_set_mlme(struct net_device *dev,
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	hdd_station_ctx_t *pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
 	struct iw_mlme *mlme = (struct iw_mlme *)extra;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	hdd_context_t *hdd_ctx;
 	int ret;
 
@@ -4456,7 +4455,7 @@ static int __iw_set_mlme(struct net_device *dev,
 				sme_roam_disconnect(WLAN_HDD_GET_HAL_CTX(pAdapter),
 						    pAdapter->sessionId, reason);
 
-			if (CDF_STATUS_SUCCESS == status) {
+			if (QDF_STATUS_SUCCESS == status) {
 				unsigned long rc;
 				rc = wait_for_completion_timeout(&pAdapter->
 								 disconnect_comp_var,
@@ -4540,7 +4539,7 @@ int wlan_hdd_update_phymode(struct net_device *net, tHalHandle hal,
 {
 #ifdef QCA_HT_2040_COEX
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(net);
-	CDF_STATUS halStatus = CDF_STATUS_E_FAILURE;
+	QDF_STATUS halStatus = QDF_STATUS_E_FAILURE;
 #endif
 	bool band_24 = false, band_5g = false;
 	bool ch_bond24 = false, ch_bond5g = false;
@@ -4765,7 +4764,7 @@ int wlan_hdd_update_phymode(struct net_device *net, tHalHandle hal,
 			halStatus = sme_set_ht2040_mode(hal,
 							pAdapter->sessionId,
 							eHT_CHAN_HT20, false);
-			if (halStatus == CDF_STATUS_E_FAILURE) {
+			if (halStatus == QDF_STATUS_E_FAILURE) {
 				hddLog(LOGE, FL("Failed to disable OBSS"));
 				return -EIO;
 			}
@@ -4775,7 +4774,7 @@ int wlan_hdd_update_phymode(struct net_device *net, tHalHandle hal,
 			halStatus = sme_set_ht2040_mode(hal,
 							pAdapter->sessionId,
 							eHT_CHAN_HT20, true);
-			if (halStatus == CDF_STATUS_E_FAILURE) {
+			if (halStatus == QDF_STATUS_E_FAILURE) {
 				hddLog(LOGE, FL("Failed to enable OBSS"));
 				return -EIO;
 			}
@@ -4877,7 +4876,7 @@ static void hdd_get_temperature_cb(int temperature, void *pContext)
  */
 int wlan_hdd_get_temperature(hdd_adapter_t *pAdapter, int *temperature)
 {
-	CDF_STATUS status;
+	QDF_STATUS status;
 	struct statsContext tempContext;
 	unsigned long rc;
 
@@ -4891,7 +4890,7 @@ int wlan_hdd_get_temperature(hdd_adapter_t *pAdapter, int *temperature)
 	tempContext.magic = TEMP_CONTEXT_MAGIC;
 	status = sme_get_temperature(WLAN_HDD_GET_HAL_CTX(pAdapter),
 				     &tempContext, hdd_get_temperature_cb);
-	if (CDF_STATUS_SUCCESS != status) {
+	if (QDF_STATUS_SUCCESS != status) {
 		hddLog(CDF_TRACE_LEVEL_ERROR,
 		       FL("Unable to retrieve temperature"));
 	} else {
@@ -4936,7 +4935,7 @@ static int __iw_setint_getnone(struct net_device *dev,
 	int set_value = value[1];
 	int ret;
 	int enable_pbm, enable_mp;
-	CDF_STATUS status;
+	QDF_STATUS status;
 
 	ENTER();
 
@@ -5033,7 +5032,7 @@ static int __iw_setint_getnone(struct net_device *dev,
 			ret = -EINVAL;
 		} else if (sme_cfg_set_int(hHal, WNI_CFG_ASSOC_STA_LIMIT,
 					set_value)
-			   != CDF_STATUS_SUCCESS) {
+			   != QDF_STATUS_SUCCESS) {
 			CDF_TRACE(CDF_MODULE_ID_HDD,
 				  CDF_TRACE_LEVEL_ERROR, FL
 				  ("failed to set ini parameter, WNI_CFG_ASSOC_STA_LIMIT"));
@@ -5056,7 +5055,7 @@ static int __iw_setint_getnone(struct net_device *dev,
 		    (set_value > CFG_DATA_INACTIVITY_TIMEOUT_MAX) ||
 		    (sme_cfg_set_int((WLAN_HDD_GET_CTX(pAdapter))->hHal,
 				     WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT,
-				     set_value) == CDF_STATUS_E_FAILURE)) {
+				     set_value) == QDF_STATUS_E_FAILURE)) {
 			hddLog(LOGE, "Failure: Could not pass on "
 			       "WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT configuration info "
 			       "to CCM");
@@ -5077,7 +5076,7 @@ static int __iw_setint_getnone(struct net_device *dev,
 		if (sme_set_tx_power
 			    (hHal, pAdapter->sessionId, bssid,
 			    pAdapter->device_mode,
-			    set_value) != CDF_STATUS_SUCCESS) {
+			    set_value) != QDF_STATUS_SUCCESS) {
 			hddLog(CDF_TRACE_LEVEL_ERROR,
 			       "%s: Setting tx power failed", __func__);
 			return -EIO;
@@ -5096,7 +5095,7 @@ static int __iw_setint_getnone(struct net_device *dev,
 		cdf_copy_macaddr(&selfMac, &pHddStaCtx->conn_info.bssId);
 
 		if (sme_set_max_tx_power(hHal, bssid, selfMac, set_value)
-		    != CDF_STATUS_SUCCESS) {
+		    != QDF_STATUS_SUCCESS) {
 			hddLog(CDF_TRACE_LEVEL_ERROR,
 			       "%s: Setting maximum tx power failed",
 			       __func__);
@@ -5111,7 +5110,7 @@ static int __iw_setint_getnone(struct net_device *dev,
 		       "%s: Setting maximum tx power %d dBm for 2.4 GHz band",
 		       __func__, set_value);
 		if (sme_set_max_tx_power_per_band(eCSR_BAND_24, set_value) !=
-		    CDF_STATUS_SUCCESS) {
+		    QDF_STATUS_SUCCESS) {
 			hddLog(CDF_TRACE_LEVEL_ERROR,
 			       "%s: Setting maximum tx power failed for 2.4 GHz band",
 			       __func__);
@@ -5126,7 +5125,7 @@ static int __iw_setint_getnone(struct net_device *dev,
 		       "%s: Setting maximum tx power %d dBm for 5.0 GHz band",
 		       __func__, set_value);
 		if (sme_set_max_tx_power_per_band(eCSR_BAND_5G, set_value) !=
-		    CDF_STATUS_SUCCESS) {
+		    QDF_STATUS_SUCCESS) {
 			hddLog(CDF_TRACE_LEVEL_ERROR,
 			       "%s: Setting maximum tx power failed for 5.0 GHz band",
 			       __func__);
@@ -5180,7 +5179,7 @@ static int __iw_setint_getnone(struct net_device *dev,
 			hddLog(LOGE, "NSS greater than 2 not supported");
 			ret = -EINVAL;
 		} else {
-			if (CDF_STATUS_SUCCESS !=
+			if (QDF_STATUS_SUCCESS !=
 				hdd_update_nss(WLAN_HDD_GET_CTX(pAdapter),
 				set_value))
 				ret = -EINVAL;
@@ -5273,7 +5272,7 @@ static int __iw_setint_getnone(struct net_device *dev,
 		hddLog(LOG1, "LDPC val %d", set_value);
 		/* get the HT capability info */
 		ret = sme_cfg_get_int(hHal, WNI_CFG_HT_CAP_INFO, &value);
-		if (CDF_STATUS_SUCCESS != ret) {
+		if (QDF_STATUS_SUCCESS != ret) {
 			CDF_TRACE(CDF_MODULE_ID_HDD,
 				  CDF_TRACE_LEVEL_ERROR,
 				  "%s: could not get HT capability info",
@@ -5311,7 +5310,7 @@ static int __iw_setint_getnone(struct net_device *dev,
 		hddLog(LOG1, "TX_STBC val %d", set_value);
 		/* get the HT capability info */
 		ret = sme_cfg_get_int(hHal, WNI_CFG_HT_CAP_INFO, &value);
-		if (CDF_STATUS_SUCCESS != ret) {
+		if (QDF_STATUS_SUCCESS != ret) {
 			CDF_TRACE(CDF_MODULE_ID_HDD,
 				  CDF_TRACE_LEVEL_ERROR,
 				  "%s: could not get HT capability info",
@@ -5349,7 +5348,7 @@ static int __iw_setint_getnone(struct net_device *dev,
 		       set_value);
 		/* get the HT capability info */
 		ret = sme_cfg_get_int(hHal, WNI_CFG_HT_CAP_INFO, &value);
-		if (CDF_STATUS_SUCCESS != ret) {
+		if (QDF_STATUS_SUCCESS != ret) {
 			CDF_TRACE(CDF_MODULE_ID_CDF,
 				  CDF_TRACE_LEVEL_ERROR,
 				  "%s: could not get HT capability info",
@@ -5414,7 +5413,7 @@ static int __iw_setint_getnone(struct net_device *dev,
 		if (!ret) {
 			if (sme_cfg_set_int
 				    (hHal, WNI_CFG_RTS_THRESHOLD, value) !=
-				    CDF_STATUS_SUCCESS) {
+				    QDF_STATUS_SUCCESS) {
 				hddLog(LOGE, "FAILED TO SET RTSCTS");
 				return -EIO;
 			}
@@ -6120,7 +6119,7 @@ static int __iw_setint_getnone(struct net_device *dev,
 
 			status = sme_ext_change_channel(hHal,
 				   set_value, pAdapter->sessionId);
-			if (status != CDF_STATUS_SUCCESS) {
+			if (status != QDF_STATUS_SUCCESS) {
 				hddLog(LOGE,
 				  FL("Error in change channel status %d"),
 				  status);
@@ -6174,7 +6173,7 @@ static int __iw_setchar_getnone(struct net_device *dev,
 				struct iw_request_info *info,
 				union iwreq_data *wrqu, char *extra)
 {
-	CDF_STATUS vstatus;
+	QDF_STATUS vstatus;
 	int sub_cmd;
 	int ret;
 	char *pBuffer = NULL;
@@ -6277,7 +6276,7 @@ static int __iw_setchar_getnone(struct net_device *dev,
 		break;
 	case WE_SET_CONFIG:
 		vstatus = hdd_execute_global_config_command(hdd_ctx, pBuffer);
-		if (CDF_STATUS_SUCCESS != vstatus) {
+		if (QDF_STATUS_SUCCESS != vstatus) {
 			ret = -EINVAL;
 		}
 		break;
@@ -6362,7 +6361,7 @@ static int __iw_setnone_getint(struct net_device *dev,
 	{
 		if (sme_cfg_get_int
 			    (hHal, WNI_CFG_ASSOC_STA_LIMIT,
-			    (uint32_t *) value) != CDF_STATUS_SUCCESS) {
+			    (uint32_t *) value) != QDF_STATUS_SUCCESS) {
 			CDF_TRACE(CDF_MODULE_ID_HDD,
 				  CDF_TRACE_LEVEL_WARN, FL
 					  ("failed to get ini parameter, WNI_CFG_ASSOC_STA_LIMIT"));
@@ -6638,7 +6637,7 @@ static int __iw_setnone_getint(struct net_device *dev,
 		*value = wma_cli_get_command(pAdapter->sessionId,
 					     WMI_PDEV_PARAM_TXPOWER_LIMIT2G,
 					     PDEV_CMD);
-		if (CDF_STATUS_SUCCESS !=
+		if (QDF_STATUS_SUCCESS !=
 		    sme_cfg_get_int(hHal, WNI_CFG_CURRENT_TX_POWER_LEVEL,
 				    &txpow2g)) {
 			return -EIO;
@@ -6655,7 +6654,7 @@ static int __iw_setnone_getint(struct net_device *dev,
 		*value = wma_cli_get_command(pAdapter->sessionId,
 					     WMI_PDEV_PARAM_TXPOWER_LIMIT5G,
 					     PDEV_CMD);
-		if (CDF_STATUS_SUCCESS !=
+		if (QDF_STATUS_SUCCESS !=
 		    sme_cfg_get_int(hHal, WNI_CFG_CURRENT_TX_POWER_LEVEL,
 				    &txpow5g)) {
 			return -EIO;
@@ -6852,9 +6851,9 @@ static int __iw_set_three_ints_getnone(struct net_device *dev,
 	 */
 	case WE_SET_SAP_CHANNELS:
 		if (wlan_hdd_validate_operation_channel(pAdapter, value[1]) !=
-			CDF_STATUS_SUCCESS ||
+			QDF_STATUS_SUCCESS ||
 			wlan_hdd_validate_operation_channel(pAdapter,
-					value[2]) != CDF_STATUS_SUCCESS) {
+					value[2]) != QDF_STATUS_SUCCESS) {
 			ret = -EINVAL;
 		} else {
 			hdd_ctx->config->force_sap_acs_st_ch = value[1];
@@ -7189,7 +7188,7 @@ static int __iw_get_char_setnone(struct net_device *dev,
 	}
 	case WE_GET_CHANNEL_LIST:
 	{
-		CDF_STATUS status;
+		QDF_STATUS status;
 		uint8_t i, len;
 		char *buf;
 		uint8_t ubuf[WNI_CFG_COUNTRY_CODE_LEN];
@@ -7202,7 +7201,7 @@ static int __iw_get_char_setnone(struct net_device *dev,
 		status =
 			iw_softap_get_channel_list(dev, info, wrqu,
 						   (char *)&channel_list);
-		if (!CDF_IS_STATUS_SUCCESS(status)) {
+		if (!QDF_IS_STATUS_SUCCESS(status)) {
 			hddLog(LOGE, FL("GetChannelList Failed!!!"));
 			return -EINVAL;
 		}
@@ -7221,7 +7220,7 @@ static int __iw_get_char_setnone(struct net_device *dev,
 		}
 		len = scnprintf(buf, WE_MAX_STR_LEN, "%u ",
 				channel_list.num_channels);
-		if (CDF_STATUS_SUCCESS == sme_get_country_code(hdd_ctx->hHal,
+		if (QDF_STATUS_SUCCESS == sme_get_country_code(hdd_ctx->hHal,
 						ubuf, &ubuf_len)) {
 			/* Printing Country code in getChannelList */
 			for (i = 0; i < (ubuf_len - 1); i++)
@@ -7292,7 +7291,7 @@ static int __iw_get_char_setnone(struct net_device *dev,
 			ch_bond5g = true;
 
 		phymode = sme_get_phy_mode(hal);
-		if ((CDF_STATUS_SUCCESS !=
+		if ((QDF_STATUS_SUCCESS !=
 		     sme_get_freq_band(hal, &currBand))) {
 			CDF_TRACE(CDF_MODULE_ID_HDD,
 				  CDF_TRACE_LEVEL_INFO,
@@ -7919,7 +7918,7 @@ static int __iw_set_var_ints_getnone(struct net_device *dev,
 		msg.type = SIR_HAL_UNIT_TEST_CMD;
 		msg.reserved = 0;
 		msg.bodyptr = unitTestArgs;
-		if (CDF_STATUS_SUCCESS !=
+		if (QDF_STATUS_SUCCESS !=
 		    cds_mq_post_message(CDF_MODULE_ID_WMA, &msg)) {
 			cdf_mem_free(unitTestArgs);
 			CDF_TRACE(CDF_MODULE_ID_HDD,
@@ -8491,7 +8490,7 @@ static int __iw_set_host_offload(struct net_device *dev,
 	 * copied individually.
 	 */
 	memcpy(&offloadRequest, pRequest, wrqu->data.length);
-	if (CDF_STATUS_SUCCESS !=
+	if (QDF_STATUS_SUCCESS !=
 	    sme_set_host_offload(WLAN_HDD_GET_HAL_CTX(pAdapter),
 				 pAdapter->sessionId, &offloadRequest)) {
 		hddLog(CDF_TRACE_LEVEL_ERROR,
@@ -8579,7 +8578,7 @@ static int __iw_set_keepalive_params(struct net_device *dev,
 
 	hdd_info("Keep alive period  %d", request->timePeriod);
 
-	if (CDF_STATUS_SUCCESS !=
+	if (QDF_STATUS_SUCCESS !=
 	    sme_set_keep_alive(WLAN_HDD_GET_HAL_CTX(pAdapter),
 		pAdapter->sessionId, request)) {
 		hdd_err("Failure to execute Keep Alive");
@@ -8694,7 +8693,7 @@ static int wlan_hdd_set_filter(hdd_context_t *hdd_ctx,
 				request->params_data[i].data_mask[5]);
 		}
 
-		if (CDF_STATUS_SUCCESS !=
+		if (QDF_STATUS_SUCCESS !=
 			sme_receive_filter_set_filter(hdd_ctx->hHal,
 				&packetFilterSetReq,
 				sessionId)) {
@@ -8709,7 +8708,7 @@ static int wlan_hdd_set_filter(hdd_context_t *hdd_ctx,
 		hdd_info("Clear Packet Filter Request for Id: %d",
 			request->filter_id);
 		packetFilterClrReq.filterId = request->filter_id;
-		if (CDF_STATUS_SUCCESS !=
+		if (QDF_STATUS_SUCCESS !=
 		    sme_receive_filter_clear_filter(hdd_ctx->hHal,
 						    &packetFilterClrReq,
 						    sessionId)) {
@@ -8814,7 +8813,7 @@ static int __iw_get_statistics(struct net_device *dev,
 {
 
 	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
-	CDF_STATUS status = CDF_STATUS_SUCCESS;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	hdd_wext_state_t *pWextState;
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	hdd_context_t *hdd_ctx = WLAN_HDD_GET_CTX(pAdapter);
@@ -8848,7 +8847,7 @@ static int __iw_get_statistics(struct net_device *dev,
 						     (pAdapter))->conn_info.staId[0],
 					    pAdapter, pAdapter->sessionId);
 
-		if (CDF_STATUS_SUCCESS != status) {
+		if (QDF_STATUS_SUCCESS != status) {
 			hddLog(CDF_TRACE_LEVEL_ERROR,
 			       "%s: Unable to retrieve SME statistics",
 			       __func__);
@@ -9259,7 +9258,7 @@ int hdd_set_band(struct net_device *dev, u8 ui_band)
 	tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(pAdapter);
 	eCsrBand band;
 
-	CDF_STATUS status;
+	QDF_STATUS status;
 	hdd_context_t *pHddCtx;
 	hdd_adapter_list_node_t *pAdapterNode, *pNext;
 	eCsrBand currBand = eCSR_BAND_MAX;
@@ -9308,7 +9307,7 @@ int hdd_set_band(struct net_device *dev, u8 ui_band)
 		band = pHddCtx->config->nBandCapability;
 	}
 
-	if (CDF_STATUS_SUCCESS != sme_get_freq_band(hHal, &currBand)) {
+	if (QDF_STATUS_SUCCESS != sme_get_freq_band(hHal, &currBand)) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_INFO,
 			  "%s: Failed to get current band config", __func__);
 		return -EIO;
@@ -9324,7 +9323,7 @@ int hdd_set_band(struct net_device *dev, u8 ui_band)
 			  __func__, currBand, band);
 
 		status = hdd_get_front_adapter(pHddCtx, &pAdapterNode);
-		while (NULL != pAdapterNode && CDF_STATUS_SUCCESS == status) {
+		while (NULL != pAdapterNode && QDF_STATUS_SUCCESS == status) {
 			pAdapter = pAdapterNode->pAdapter;
 			hHal = WLAN_HDD_GET_HAL_CTX(pAdapter);
 			hdd_abort_mac_scan(pHddCtx, pAdapter->sessionId,
@@ -9341,7 +9340,7 @@ int hdd_set_band(struct net_device *dev, u8 ui_band)
 			    (hdd_conn_is_connected
 				     (WLAN_HDD_GET_STATION_CTX_PTR(pAdapter)))
 			    && (connectedBand != band)) {
-				CDF_STATUS status = CDF_STATUS_SUCCESS;
+				QDF_STATUS status = QDF_STATUS_SUCCESS;
 				long lrc;
 
 				/* STA already connected on current band, So issue disconnect
@@ -9359,7 +9358,7 @@ int hdd_set_band(struct net_device *dev, u8 ui_band)
 							    pAdapter->sessionId,
 							    eCSR_DISCONNECT_REASON_UNSPECIFIED);
 
-				if (CDF_STATUS_SUCCESS != status) {
+				if (QDF_STATUS_SUCCESS != status) {
 					hddLog(CDF_TRACE_LEVEL_ERROR,
 					       "%s csr_roam_disconnect failure, returned %d",
 					       __func__, (int)status);
@@ -9387,7 +9386,7 @@ int hdd_set_band(struct net_device *dev, u8 ui_band)
 			pAdapterNode = pNext;
 		}
 
-		if (CDF_STATUS_SUCCESS !=
+		if (QDF_STATUS_SUCCESS !=
 		    sme_set_freq_band(hHal, pAdapter->sessionId, band)) {
 			CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_FATAL,
 				  FL("Failed to set the band value to %u"),
@@ -10744,7 +10743,7 @@ int hdd_set_wext(hdd_adapter_t *pAdapter)
 
 	hdd_clear_roam_profile_ie(pAdapter);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 
 }
 
@@ -10768,19 +10767,19 @@ int hdd_register_wext(struct net_device *dev)
 
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  ("ERROR: hdd_set_wext failed!!"));
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	if (!QDF_IS_STATUS_SUCCESS(qdf_event_create(&pwextBuf->hdd_cdf_event))) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  ("ERROR: HDD cdf event init failed!!"));
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	if (!QDF_IS_STATUS_SUCCESS(qdf_event_create(&pwextBuf->scanevent))) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  ("ERROR: HDD scan event init failed!!"));
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 	/* Register as a wireless device */
 	dev->wireless_handlers = (struct iw_handler_def *)&we_handler_def;

core/hdd/src/wlan_hdd_wmm.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2015 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -158,7 +158,7 @@ static void hdd_wmm_enable_tl_uapsd(hdd_wmm_qos_context_t *pQosContext)
 	sme_ac_enum_type acType = pQosContext->acType;
 	hdd_wmm_ac_status_t *pAc = &pAdapter->hddWmmStatus.wmmAcStatus[acType];
 	hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
-	CDF_STATUS status;
+	QDF_STATUS status;
 	uint32_t service_interval;
 	uint32_t suspension_interval;
 	sme_QosWmmDirType direction;
@@ -209,7 +209,7 @@ static void hdd_wmm_enable_tl_uapsd(hdd_wmm_qos_context_t *pQosContext)
 					   direction, psb, pAdapter->sessionId,
 					   pHddCtx->config->DelayedTriggerFrmInt);
 
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, WMM_TRACE_LEVEL_ERROR,
 			  "%s: Failed to enable U-APSD for AC=%d",
 			  __func__, acType);
@@ -243,7 +243,7 @@ static void hdd_wmm_disable_tl_uapsd(hdd_wmm_qos_context_t *pQosContext)
 	hdd_adapter_t *pAdapter = pQosContext->pAdapter;
 	sme_ac_enum_type acType = pQosContext->acType;
 	hdd_wmm_ac_status_t *pAc = &pAdapter->hddWmmStatus.wmmAcStatus[acType];
-	CDF_STATUS status;
+	QDF_STATUS status;
 
 	/* have we previously enabled UAPSD? */
 	if (pAc->wmmAcUapsdInfoValid == true) {
@@ -254,7 +254,7 @@ static void hdd_wmm_disable_tl_uapsd(hdd_wmm_qos_context_t *pQosContext)
 							     (pAdapter))->conn_info.staId[0],
 						    acType, pAdapter->sessionId);
 
-		if (!CDF_IS_STATUS_SUCCESS(status)) {
+		if (!QDF_IS_STATUS_SUCCESS(status)) {
 			CDF_TRACE(CDF_MODULE_ID_HDD, WMM_TRACE_LEVEL_ERROR,
 				  "%s: Failed to disable U-APSD for AC=%d",
 				  __func__, acType);
@@ -376,7 +376,7 @@ static void hdd_wmm_inactivity_timer_cb(void *user_data)
 	hdd_adapter_t *pAdapter;
 	hdd_wmm_ac_status_t *pAc;
 	hdd_wlan_wmm_status_e status;
-	CDF_STATUS cdf_status;
+	QDF_STATUS qdf_status;
 	uint32_t currentTrafficCnt = 0;
 	sme_ac_enum_type acType = pQosContext->acType;
 
@@ -405,10 +405,10 @@ static void hdd_wmm_inactivity_timer_cb(void *user_data)
 		pAc->wmmPrevTrafficCnt = currentTrafficCnt;
 		if (pAc->wmmInactivityTimer.state == CDF_TIMER_STATE_STOPPED) {
 			/* Restart the timer */
-			cdf_status =
+			qdf_status =
 				cdf_mc_timer_start(&pAc->wmmInactivityTimer,
 						   pAc->wmmInactivityTime);
-			if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+			if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 				CDF_TRACE(CDF_MODULE_ID_HDD,
 					  CDF_TRACE_LEVEL_ERROR,
 					  FL(
@@ -437,13 +437,13 @@ static void hdd_wmm_inactivity_timer_cb(void *user_data)
  * time specified in the AddTS parameters is non-zero, this function
  * is invoked to start a traffic inactivity timer for the given AC.
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-static CDF_STATUS
+static QDF_STATUS
 hdd_wmm_enable_inactivity_timer(hdd_wmm_qos_context_t *pQosContext,
 				uint32_t inactivityTime)
 {
-	CDF_STATUS cdf_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS qdf_status = QDF_STATUS_E_FAILURE;
 	hdd_adapter_t *pAdapter = pQosContext->pAdapter;
 	sme_ac_enum_type acType = pQosContext->acType;
 	hdd_wmm_ac_status_t *pAc;
@@ -451,28 +451,28 @@ hdd_wmm_enable_inactivity_timer(hdd_wmm_qos_context_t *pQosContext,
 	pAdapter = pQosContext->pAdapter;
 	pAc = &pAdapter->hddWmmStatus.wmmAcStatus[acType];
 
-	cdf_status = cdf_mc_timer_init(&pAc->wmmInactivityTimer,
+	qdf_status = cdf_mc_timer_init(&pAc->wmmInactivityTimer,
 				       CDF_TIMER_TYPE_SW,
 				       hdd_wmm_inactivity_timer_cb,
 				       pQosContext);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  FL("Initializing inactivity timer failed on AC %d"),
 			  acType);
-		return cdf_status;
+		return qdf_status;
 	}
 	/* Start the inactivity timer */
-	cdf_status = cdf_mc_timer_start(&pAc->wmmInactivityTimer,
+	qdf_status = cdf_mc_timer_start(&pAc->wmmInactivityTimer,
 					inactivityTime);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  FL("Starting inactivity timer failed on AC %d"),
 			  acType);
-		cdf_status = cdf_mc_timer_destroy(&pAc->wmmInactivityTimer);
-		if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+		qdf_status = cdf_mc_timer_destroy(&pAc->wmmInactivityTimer);
+		if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 			hdd_err("Failed to destroy inactivity timer");
 		}
-		return cdf_status;
+		return qdf_status;
 	}
 	pAc->wmmInactivityTime = inactivityTime;
 	/* Initialize the current tx traffic count on this AC */
@@ -480,7 +480,7 @@ hdd_wmm_enable_inactivity_timer(hdd_wmm_qos_context_t *pQosContext,
 		pAdapter->hdd_stats.hddTxRxStats.txXmitClassifiedAC[pQosContext->
 								    acType];
 	pQosContext->is_inactivity_timer_running = true;
-	return cdf_status;
+	return qdf_status;
 }
 
 /**
@@ -492,15 +492,15 @@ hdd_wmm_enable_inactivity_timer(hdd_wmm_qos_context_t *pQosContext,
  * This function is invoked to disable the traffic inactivity timer
  * for the given AC.  This is normally done when the TS is deleted.
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-static CDF_STATUS
+static QDF_STATUS
 hdd_wmm_disable_inactivity_timer(hdd_wmm_qos_context_t *pQosContext)
 {
 	hdd_adapter_t *pAdapter = pQosContext->pAdapter;
 	sme_ac_enum_type acType = pQosContext->acType;
 	hdd_wmm_ac_status_t *pAc = &pAdapter->hddWmmStatus.wmmAcStatus[acType];
-	CDF_STATUS cdf_status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS qdf_status = QDF_STATUS_E_FAILURE;
 
 	/* Clear the timer and the counter */
 	pAc->wmmInactivityTime = 0;
@@ -508,17 +508,17 @@ hdd_wmm_disable_inactivity_timer(hdd_wmm_qos_context_t *pQosContext)
 
 	if (pQosContext->is_inactivity_timer_running == true) {
 		pQosContext->is_inactivity_timer_running = false;
-		cdf_status = cdf_mc_timer_stop(&pAc->wmmInactivityTimer);
-		if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+		qdf_status = cdf_mc_timer_stop(&pAc->wmmInactivityTimer);
+		if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 			hdd_err("Failed to stop inactivity timer");
-			return cdf_status;
+			return qdf_status;
 		}
-		cdf_status = cdf_mc_timer_destroy(&pAc->wmmInactivityTimer);
-		if (!CDF_IS_STATUS_SUCCESS(cdf_status))
+		qdf_status = cdf_mc_timer_destroy(&pAc->wmmInactivityTimer);
+		if (!QDF_IS_STATUS_SUCCESS(qdf_status))
 			hdd_err("Failed to destroy inactivity timer:Timer started");
 	}
 
-	return cdf_status;
+	return qdf_status;
 }
 #endif /* FEATURE_WLAN_ESE */
 
@@ -536,9 +536,9 @@ hdd_wmm_disable_inactivity_timer(hdd_wmm_qos_context_t *pQosContext)
  * gets called externally through some function pointer magic (so
  * there is a need for rigorous parameter checking).
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-static CDF_STATUS hdd_wmm_sme_callback(tHalHandle hHal,
+static QDF_STATUS hdd_wmm_sme_callback(tHalHandle hHal,
 				       void *hddCtx,
 				       sme_QosWmmTspecInfo *pCurrentQosInfo,
 				       sme_QosStatusType smeStatus,
@@ -556,7 +556,7 @@ static CDF_STATUS hdd_wmm_sme_callback(tHalHandle hHal,
 		     (HDD_WMM_CTX_MAGIC != pQosContext->magic))) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, WMM_TRACE_LEVEL_ERROR,
 			  "%s: Invalid QoS Context", __func__);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	pAdapter = pQosContext->pAdapter;
@@ -1059,7 +1059,7 @@ static CDF_STATUS hdd_wmm_sme_callback(tHalHandle hHal,
 		  "%s: complete, access for TL AC %d is%sallowed",
 		  __func__, acType, pAc->wmmAcAccessAllowed ? " " : " not ");
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 #endif
 
@@ -1371,9 +1371,9 @@ static void hdd_wmm_do_implicit_qos(struct work_struct *work)
  * adapter to an initial state.  The configuration can later be
  * overwritten via application APIs or via QoS Map sent OTA.
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_wmm_init(hdd_adapter_t *pAdapter)
+QDF_STATUS hdd_wmm_init(hdd_adapter_t *pAdapter)
 {
 	sme_QosWmmUpType *hddWmmDscpToUpMap = pAdapter->hddWmmDscpToUpMap;
 	uint8_t dscp;
@@ -1391,7 +1391,7 @@ CDF_STATUS hdd_wmm_init(hdd_adapter_t *pAdapter)
 	/* Special case for Expedited Forwarding (DSCP 46) */
 	hddWmmDscpToUpMap[46] = SME_QOS_WMM_UP_VO;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -1402,9 +1402,9 @@ CDF_STATUS hdd_wmm_init(hdd_adapter_t *pAdapter)
  * adapter to an initial state.  The configuration can later be
  * overwritten via application APIs
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_wmm_adapter_init(hdd_adapter_t *pAdapter)
+QDF_STATUS hdd_wmm_adapter_init(hdd_adapter_t *pAdapter)
 {
 	hdd_wmm_ac_status_t *pAcStatus;
 	sme_ac_enum_type acType;
@@ -1432,7 +1432,7 @@ CDF_STATUS hdd_wmm_adapter_init(hdd_adapter_t *pAdapter)
 	 */
 	pAdapter->configuredPsb = HDD_PSB_CFG_INVALID;
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -1441,9 +1441,9 @@ CDF_STATUS hdd_wmm_adapter_init(hdd_adapter_t *pAdapter)
  *
  * @pAdapter: [in]  pointer to Adapter context
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_wmm_adapter_clear(hdd_adapter_t *pAdapter)
+QDF_STATUS hdd_wmm_adapter_clear(hdd_adapter_t *pAdapter)
 {
 	hdd_wmm_ac_status_t *pAcStatus;
 	sme_ac_enum_type acType;
@@ -1460,7 +1460,7 @@ CDF_STATUS hdd_wmm_adapter_clear(hdd_adapter_t *pAdapter)
 		pAcStatus->wmmAcTspecValid = false;
 		pAcStatus->wmmAcUapsdInfoValid = false;
 	}
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -1470,9 +1470,9 @@ CDF_STATUS hdd_wmm_adapter_clear(hdd_adapter_t *pAdapter)
  * Function which will perform any necessary work to to clean up the
  * WMM functionality prior to the kernel module unload.
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_wmm_adapter_close(hdd_adapter_t *pAdapter)
+QDF_STATUS hdd_wmm_adapter_close(hdd_adapter_t *pAdapter)
 {
 	hdd_wmm_qos_context_t *pQosContext;
 
@@ -1494,7 +1494,7 @@ CDF_STATUS hdd_wmm_adapter_close(hdd_adapter_t *pAdapter)
 		hdd_wmm_free_context(pQosContext);
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -1792,9 +1792,9 @@ void hdd_wmm_acquire_access_required(hdd_adapter_t *pAdapter,
  * @pGranted: [out] pointer to bool flag when indicates if access
  *	      has been granted or not
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_wmm_acquire_access(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_wmm_acquire_access(hdd_adapter_t *pAdapter,
 				  sme_ac_enum_type acType, bool *pGranted)
 {
 	hdd_wmm_qos_context_t *pQosContext;
@@ -1815,7 +1815,7 @@ CDF_STATUS hdd_wmm_acquire_access(hdd_adapter_t *pAdapter,
 			pAdapter->hddWmmStatus.wmmAcStatus[acType].
 			wmmAcAccessAllowed;
 
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 	/* do we already have an implicit QoS request pending for this AC? */
 	if ((pAdapter->hddWmmStatus.wmmAcStatus[acType].wmmAcAccessNeeded) ||
@@ -1828,7 +1828,7 @@ CDF_STATUS hdd_wmm_acquire_access(hdd_adapter_t *pAdapter,
 			  __func__, acType);
 
 		*pGranted = false;
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 	/* did we already fail to establish implicit QoS for this AC?
 	 * (if so, access should have been granted when the failure
@@ -1853,7 +1853,7 @@ CDF_STATUS hdd_wmm_acquire_access(hdd_adapter_t *pAdapter,
 			*pGranted = false;
 		}
 
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 	/* we need to establish implicit QoS */
 	CDF_TRACE(CDF_MODULE_ID_HDD, WMM_TRACE_LEVEL_INFO,
@@ -1872,7 +1872,7 @@ CDF_STATUS hdd_wmm_acquire_access(hdd_adapter_t *pAdapter,
 		pAdapter->hddWmmStatus.wmmAcStatus[acType].wmmAcAccessAllowed =
 			true;
 		*pGranted = true;
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 
 	pQosContext->acType = acType;
@@ -1899,7 +1899,7 @@ CDF_STATUS hdd_wmm_acquire_access(hdd_adapter_t *pAdapter,
 	 * TSPEC negotiation completes
 	 */
 	*pGranted = false;
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -1910,13 +1910,13 @@ CDF_STATUS hdd_wmm_acquire_access(hdd_adapter_t *pAdapter,
  * @pRoamInfo: [in]  pointer to roam information
  * @eBssType: [in]  type of BSS
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_wmm_assoc(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_wmm_assoc(hdd_adapter_t *pAdapter,
 			 tCsrRoamInfo *pRoamInfo, eCsrRoamBssType eBssType)
 {
 	uint8_t uapsdMask;
-	CDF_STATUS status;
+	QDF_STATUS status;
 	hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
 
 	/* when we associate we need to notify TL if it needs to
@@ -1939,7 +1939,7 @@ CDF_STATUS hdd_wmm_assoc(hdd_adapter_t *pAdapter,
 		CDF_TRACE(CDF_MODULE_ID_HDD, WMM_TRACE_LEVEL_INFO_LOW,
 			  "%s: Reassoc so no work, Exiting", __func__);
 
-		return CDF_STATUS_SUCCESS;
+		return QDF_STATUS_SUCCESS;
 	}
 	/* get the negotiated UAPSD Mask */
 	uapsdMask =
@@ -1961,7 +1961,7 @@ CDF_STATUS hdd_wmm_assoc(hdd_adapter_t *pAdapter,
 						   pAdapter->sessionId,
 						   pHddCtx->config->DelayedTriggerFrmInt);
 
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(status));
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(status));
 	}
 
 	if (uapsdMask & HDD_AC_VI) {
@@ -1977,7 +1977,7 @@ CDF_STATUS hdd_wmm_assoc(hdd_adapter_t *pAdapter,
 						   pAdapter->sessionId,
 						   pHddCtx->config->DelayedTriggerFrmInt);
 
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(status));
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(status));
 	}
 
 	if (uapsdMask & HDD_AC_BK) {
@@ -1993,7 +1993,7 @@ CDF_STATUS hdd_wmm_assoc(hdd_adapter_t *pAdapter,
 						   pAdapter->sessionId,
 						   pHddCtx->config->DelayedTriggerFrmInt);
 
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(status));
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(status));
 	}
 
 	if (uapsdMask & HDD_AC_BE) {
@@ -2009,21 +2009,21 @@ CDF_STATUS hdd_wmm_assoc(hdd_adapter_t *pAdapter,
 						   pAdapter->sessionId,
 						   pHddCtx->config->DelayedTriggerFrmInt);
 
-		CDF_ASSERT(CDF_IS_STATUS_SUCCESS(status));
+		CDF_ASSERT(QDF_IS_STATUS_SUCCESS(status));
 	}
 
 	status = sme_update_dsc_pto_up_mapping(pHddCtx->hHal,
 					       pAdapter->hddWmmDscpToUpMap,
 					       pAdapter->sessionId);
 
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hdd_wmm_init(pAdapter);
 	}
 
 	CDF_TRACE(CDF_MODULE_ID_HDD, WMM_TRACE_LEVEL_INFO_LOW,
 		  "%s: Exiting", __func__);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 static const uint8_t acm_mask_bit[WLAN_MAX_AC] = {
@@ -2041,9 +2041,9 @@ static const uint8_t acm_mask_bit[WLAN_MAX_AC] = {
  * @pRoamInfo: [in]  pointer to roam information
  * @eBssType : [in]  type of BSS
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_wmm_connect(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_wmm_connect(hdd_adapter_t *pAdapter,
 			   tCsrRoamInfo *pRoamInfo, eCsrRoamBssType eBssType)
 {
 	int ac;
@@ -2108,7 +2108,7 @@ CDF_STATUS hdd_wmm_connect(hdd_adapter_t *pAdapter,
 	CDF_TRACE(CDF_MODULE_ID_HDD, WMM_TRACE_LEVEL_INFO_LOW,
 		  "%s: Exiting", __func__);
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -2118,9 +2118,9 @@ CDF_STATUS hdd_wmm_connect(hdd_adapter_t *pAdapter,
  * @pAdapter  : [in]  pointer to adapter context
  * @pUapsdMask: [out] pointer to where the UAPSD Mask is to be stored
  *
- * Return: CDF_STATUS enumeration
+ * Return: QDF_STATUS enumeration
  */
-CDF_STATUS hdd_wmm_get_uapsd_mask(hdd_adapter_t *pAdapter,
+QDF_STATUS hdd_wmm_get_uapsd_mask(hdd_adapter_t *pAdapter,
 				  uint8_t *pUapsdMask)
 {
 	uint8_t uapsdMask;
@@ -2157,7 +2157,7 @@ CDF_STATUS hdd_wmm_get_uapsd_mask(hdd_adapter_t *pAdapter,
 
 	/* return calculated mask */
 	*pUapsdMask = uapsdMask;
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**

core/hdd/src/wlan_hdd_wowl.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2015 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -57,7 +57,7 @@ static inline int find_ptrn_len(const char *ptrn)
 	return len;
 }
 
-static void hdd_wowl_callback(void *pContext, CDF_STATUS cdf_ret_status)
+static void hdd_wowl_callback(void *pContext, QDF_STATUS cdf_ret_status)
 {
 	CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_INFO,
 		  "%s: Return code = (%d)", __func__, cdf_ret_status);
@@ -117,7 +117,7 @@ bool hdd_add_wowl_ptrn(hdd_adapter_t *pAdapter, const char *ptrn)
 {
 	struct wow_add_pattern localPattern;
 	int i, first_empty_slot, len, offset;
-	CDF_STATUS cdf_ret_status;
+	QDF_STATUS cdf_ret_status;
 	const char *temp;
 	tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(pAdapter);
 	uint8_t sessionId = pAdapter->sessionId;
@@ -256,7 +256,7 @@ bool hdd_add_wowl_ptrn(hdd_adapter_t *pAdapter, const char *ptrn)
 		cdf_ret_status =
 			sme_wow_add_pattern(hHal, &localPattern,
 						   sessionId);
-		if (!CDF_IS_STATUS_SUCCESS(cdf_ret_status)) {
+		if (!QDF_IS_STATUS_SUCCESS(cdf_ret_status)) {
 			/* Add failed, so invalidate the local storage */
 			CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 				  "sme_wowl_add_bcast_pattern failed with error code (%d)",
@@ -293,7 +293,7 @@ bool hdd_del_wowl_ptrn(hdd_adapter_t *pAdapter, const char *ptrn)
 	unsigned char id;
 	tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(pAdapter);
 	bool patternFound = false;
-	CDF_STATUS cdf_ret_status;
+	QDF_STATUS cdf_ret_status;
 	uint8_t sessionId = pAdapter->sessionId;
 	hdd_context_t *pHddCtx = pAdapter->pHddCtx;
 
@@ -314,7 +314,7 @@ bool hdd_del_wowl_ptrn(hdd_adapter_t *pAdapter, const char *ptrn)
 		cdf_ret_status =
 			sme_wow_delete_pattern(hHal, &delPattern,
 						   sessionId);
-		if (CDF_IS_STATUS_SUCCESS(cdf_ret_status)) {
+		if (QDF_IS_STATUS_SUCCESS(cdf_ret_status)) {
 			/* Remove from local storage as well */
 			CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 				  "Deleted pattern with id %d [%s]", id,
@@ -344,7 +344,7 @@ bool hdd_add_wowl_ptrn_debugfs(hdd_adapter_t *pAdapter, uint8_t pattern_idx,
 			       char *pattern_mask)
 {
 	struct wow_add_pattern localPattern;
-	CDF_STATUS cdf_ret_status;
+	QDF_STATUS cdf_ret_status;
 	tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(pAdapter);
 	uint8_t session_id = pAdapter->sessionId;
 	uint16_t pattern_len, mask_len, i;
@@ -432,7 +432,7 @@ bool hdd_add_wowl_ptrn_debugfs(hdd_adapter_t *pAdapter, uint8_t pattern_idx,
 	cdf_ret_status =
 		sme_wow_add_pattern(hHal, &localPattern, session_id);
 
-	if (!CDF_IS_STATUS_SUCCESS(cdf_ret_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(cdf_ret_status)) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  "%s: sme_wowl_add_bcast_pattern failed with error code (%d).",
 			  __func__, cdf_ret_status);
@@ -463,7 +463,7 @@ bool hdd_del_wowl_ptrn_debugfs(hdd_adapter_t *pAdapter, uint8_t pattern_idx)
 {
 	struct wow_delete_pattern delPattern;
 	tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(pAdapter);
-	CDF_STATUS cdf_ret_status;
+	QDF_STATUS cdf_ret_status;
 	uint8_t sessionId = pAdapter->sessionId;
 
 	if (pattern_idx > (WOWL_MAX_PTRNS_ALLOWED - 1)) {
@@ -487,7 +487,7 @@ bool hdd_del_wowl_ptrn_debugfs(hdd_adapter_t *pAdapter, uint8_t pattern_idx)
 	cdf_ret_status = sme_wow_delete_pattern(hHal, &delPattern,
 						    sessionId);
 
-	if (!CDF_IS_STATUS_SUCCESS(cdf_ret_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(cdf_ret_status)) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  "%s: sme_wowl_del_bcast_pattern failed with error code (%d).",
 			  __func__, cdf_ret_status);
@@ -513,7 +513,7 @@ bool hdd_del_wowl_ptrn_debugfs(hdd_adapter_t *pAdapter, uint8_t pattern_idx)
 bool hdd_enter_wowl(hdd_adapter_t *pAdapter, bool enable_mp, bool enable_pbm)
 {
 	tSirSmeWowlEnterParams wowParams;
-	CDF_STATUS cdf_ret_status;
+	QDF_STATUS cdf_ret_status;
 	tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(pAdapter);
 
 	cdf_mem_zero(&wowParams, sizeof(tSirSmeWowlEnterParams));
@@ -541,8 +541,8 @@ bool hdd_enter_wowl(hdd_adapter_t *pAdapter, bool enable_mp, bool enable_pbm)
 #endif /* WLAN_WAKEUP_EVENTS */
 					&wowParams, pAdapter->sessionId);
 
-	if (!CDF_IS_STATUS_SUCCESS(cdf_ret_status)) {
-		if (CDF_STATUS_PMC_PENDING != cdf_ret_status) {
+	if (!QDF_IS_STATUS_SUCCESS(cdf_ret_status)) {
+		if (QDF_STATUS_PMC_PENDING != cdf_ret_status) {
 			/* We failed to enter WoWL */
 			CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 				  "sme_enter_wowl failed with error code (%d)",
@@ -563,12 +563,12 @@ bool hdd_exit_wowl(hdd_adapter_t *pAdapter)
 {
 	tSirSmeWowlExitParams wowParams;
 	tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(pAdapter);
-	CDF_STATUS cdf_ret_status;
+	QDF_STATUS cdf_ret_status;
 
 	wowParams.sessionId = pAdapter->sessionId;
 
 	cdf_ret_status = sme_exit_wowl(hHal, &wowParams);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_ret_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(cdf_ret_status)) {
 		CDF_TRACE(CDF_MODULE_ID_HDD, CDF_TRACE_LEVEL_ERROR,
 			  "sme_exit_wowl failed with error code (%d)",
 			  cdf_ret_status);

core/mac/inc/ani_global.h

@@ -247,7 +247,7 @@ enum wifi_logging_ring_id {
 
 /* ------------------------------------------------------------------- */
 /* Change channel generic scheme */
-typedef void (*CHANGE_CHANNEL_CALLBACK)(tpAniSirGlobal pMac, CDF_STATUS status,
+typedef void (*CHANGE_CHANNEL_CALLBACK)(tpAniSirGlobal pMac, QDF_STATUS status,
 					uint32_t *data,
 					tpPESession psessionEntry);
 
@@ -842,7 +842,7 @@ typedef struct sAniSirLim {
 	uint8_t gLimDfsTargetChanNum;
 	uint8_t probeCounter;
 	uint8_t maxProbe;
-	CDF_STATUS(*add_bssdescr_callback)
+	QDF_STATUS(*add_bssdescr_callback)
 		(tpAniSirGlobal pMac, tpSirBssDescription buf,
 		uint32_t scan_id, uint32_t flags);
 	uint8_t retry_packet_cnt;

core/mac/inc/mac_trace.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2015 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -57,8 +57,8 @@ uint8_t *mac_trace_get_lim_msg_string(uint16_t limMsg);
 uint8_t *mac_trace_get_wma_msg_string(uint16_t wmaMsg);
 uint8_t *mac_trace_get_sme_msg_string(uint16_t smeMsg);
 uint8_t *mac_trace_get_info_log_string(uint16_t infoLog);
-CDF_STATUS pe_acquire_global_lock(tAniSirLim *psPe);
-CDF_STATUS pe_release_global_lock(tAniSirLim *psPe);
+QDF_STATUS pe_acquire_global_lock(tAniSirLim *psPe);
+QDF_STATUS pe_release_global_lock(tAniSirLim *psPe);
 
 uint8_t *mac_trace_get_neighbour_roam_state(uint16_t neighbourRoamState);
 uint8_t *mac_trace_getcsr_roam_state(uint16_t csr_roamState);

core/mac/inc/sir_api.h

@@ -2322,7 +2322,7 @@ typedef struct sSirHalWowlEnterParams {
 	/* Status code to be filled by HAL when it sends
 	 * SIR_HAL_WOWL_ENTER_RSP to PE.
 	 */
-	CDF_STATUS status;
+	QDF_STATUS status;
 
 	/*BSSID to find the current session
 	 */
@@ -2342,7 +2342,7 @@ typedef struct sSirHalWowlExitParams {
 	/* Status code to be filled by HAL when it sends
 	 * SIR_HAL_WOWL_EXIT_RSP to PE.
 	 */
-	CDF_STATUS status;
+	QDF_STATUS status;
 
 	/*BSSIDX to find the current session
 	 */

core/mac/src/pe/include/lim_api.h

@@ -167,7 +167,7 @@ bool lim_is_deauth_diassoc_for_drop(tpAniSirGlobal mac, uint8_t *rx_pkt_info);
 bool lim_is_assoc_req_for_drop(tpAniSirGlobal mac, uint8_t *rx_pkt_info);
 #endif
 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
-CDF_STATUS pe_roam_synch_callback(tpAniSirGlobal mac_ctx,
+QDF_STATUS pe_roam_synch_callback(tpAniSirGlobal mac_ctx,
 	struct sSirSmeRoamOffloadSynchInd *roam_sync_ind_ptr,
 	tpSirBssDescription  bss_desc_ptr);
 #endif
@@ -229,7 +229,7 @@ void pe_free_msg(tpAniSirGlobal pMac, tSirMsgQ *pMsg);
    \return  void
 
    --------------------------------------------------------------------------*/
-void lim_remain_on_chn_rsp(tpAniSirGlobal pMac, CDF_STATUS status, uint32_t *data);
+void lim_remain_on_chn_rsp(tpAniSirGlobal pMac, QDF_STATUS status, uint32_t *data);
 
 void lim_process_abort_scan_ind(tpAniSirGlobal pMac, uint8_t sessionId,
 	uint32_t scan_id, uint32_t scan_requestor_id);

core/mac/src/pe/include/lim_ft.h

@@ -48,11 +48,11 @@ void lim_ft_open(tpAniSirGlobal pMac, tpPESession psessionEntry);
 void lim_ft_cleanup(tpAniSirGlobal pMac, tpPESession psessionEntry);
 void lim_ft_cleanup_pre_auth_info(tpAniSirGlobal pMac, tpPESession psessionEntry);
 int lim_process_ft_pre_auth_req(tpAniSirGlobal pMac, tpSirMsgQ pMsg);
-void lim_perform_ft_pre_auth(tpAniSirGlobal pMac, CDF_STATUS status,
+void lim_perform_ft_pre_auth(tpAniSirGlobal pMac, QDF_STATUS status,
 			     uint32_t *data, tpPESession psessionEntry);
-void limPerformPostFTPreAuth(tpAniSirGlobal pMac, CDF_STATUS status,
+void limPerformPostFTPreAuth(tpAniSirGlobal pMac, QDF_STATUS status,
 			     uint32_t *data, tpPESession psessionEntry);
-void limFTResumeLinkCb(tpAniSirGlobal pMac, CDF_STATUS status, uint32_t *data);
+void limFTResumeLinkCb(tpAniSirGlobal pMac, QDF_STATUS status, uint32_t *data);
 void lim_post_ft_pre_auth_rsp(tpAniSirGlobal pMac, tSirRetStatus status,
 			      uint8_t *auth_rsp, uint16_t auth_rsp_length,
 			      tpPESession psessionEntry);
@@ -81,7 +81,7 @@ tSirRetStatus lim_ft_prepare_add_bss_req(tpAniSirGlobal pMac,
 		uint8_t updateEntry,
 		tpPESession pftSessionEntry,
 		tpSirBssDescription bssDescription);
-CDF_STATUS lim_send_preauth_scan_offload(tpAniSirGlobal mac_ctx,
+QDF_STATUS lim_send_preauth_scan_offload(tpAniSirGlobal mac_ctx,
 		uint8_t session_id, tSirFTPreAuthReq *ft_preauth_req);
 #endif /* __LIMFT_H__ */
 

core/mac/src/pe/include/lim_global.h

@@ -209,7 +209,7 @@ typedef enum eLimDot11hChanSwStates {
 
 /* WLAN_SUSPEND_LINK Related */
 typedef void (*SUSPEND_RESUME_LINK_CALLBACK)(tpAniSirGlobal pMac,
-					     CDF_STATUS status,
+					     QDF_STATUS status,
 					     uint32_t *data);
 
 /* LIM to HAL SCAN Management Message Interface states */

core/mac/src/pe/lim/lim_admit_control.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011-2015 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2011-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -1087,7 +1087,7 @@ void lim_process_hal_add_ts_rsp(tpAniSirGlobal pMac, tpSirMsgQ limMsg)
 		goto end;
 	}
 
-	if (pAddTsRspMsg->status == CDF_STATUS_SUCCESS) {
+	if (pAddTsRspMsg->status == QDF_STATUS_SUCCESS) {
 		PELOG1(lim_log
 			       (pMac, LOG1,
 			       FL("Received successful ADDTS response from HAL "));

core/mac/src/pe/lim/lim_api.c

@@ -766,7 +766,7 @@ tSirRetStatus pe_open(tpAniSirGlobal pMac, tMacOpenParameters *pMacOpenParam)
 	pMac->lim.mgmtFrameSessionId = 0xff;
 	pMac->lim.deferredMsgCnt = 0;
 
-	if (!CDF_IS_STATUS_SUCCESS(cdf_mutex_init(&pMac->lim.lkPeGlobalLock))) {
+	if (!QDF_IS_STATUS_SUCCESS(cdf_mutex_init(&pMac->lim.lkPeGlobalLock))) {
 		PELOGE(lim_log(pMac, LOGE, FL("pe lock init failed!"));)
 		status = eSIR_FAILURE;
 		goto pe_open_lock_fail;
@@ -829,7 +829,7 @@ tSirRetStatus pe_close(tpAniSirGlobal pMac)
 
 	cdf_mem_free(pMac->lim.gpSession);
 	pMac->lim.gpSession = NULL;
-	if (!CDF_IS_STATUS_SUCCESS
+	if (!QDF_IS_STATUS_SUCCESS
 		    (cdf_mutex_destroy(&pMac->lim.lkPeGlobalLock))) {
 		return eSIR_FAILURE;
 	}
@@ -987,18 +987,18 @@ tSirRetStatus pe_process_messages(tpAniSirGlobal pMac, tSirMsgQ *pMsg)
  * @return None
  */
 
-CDF_STATUS pe_handle_mgmt_frame(void *p_cds_gctx, void *cds_buff)
+QDF_STATUS pe_handle_mgmt_frame(void *p_cds_gctx, void *cds_buff)
 {
 	tpAniSirGlobal pMac;
 	tpSirMacMgmtHdr mHdr;
 	tSirMsgQ msg;
 	cds_pkt_t *pVosPkt;
-	CDF_STATUS cdf_status;
+	QDF_STATUS qdf_status;
 	uint8_t *pRxPacketInfo;
 
 	pVosPkt = (cds_pkt_t *) cds_buff;
 	if (NULL == pVosPkt) {
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	pMac = cds_get_context(CDF_MODULE_ID_PE);
@@ -1006,16 +1006,16 @@ CDF_STATUS pe_handle_mgmt_frame(void *p_cds_gctx, void *cds_buff)
 		/* cannot log a failure without a valid pMac */
 		cds_pkt_return_packet(pVosPkt);
 		pVosPkt = NULL;
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
-	cdf_status =
+	qdf_status =
 		wma_ds_peek_rx_packet_info(pVosPkt, (void *)&pRxPacketInfo, false);
 
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		cds_pkt_return_packet(pVosPkt);
 		pVosPkt = NULL;
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	/*
@@ -1065,10 +1065,10 @@ CDF_STATUS pe_handle_mgmt_frame(void *p_cds_gctx, void *cds_buff)
 		lim_log(pMac, LOGW,
 			FL
 				("sys_bbt_process_message_core failed to process SIR_BB_XPORT_MGMT_MSG"));
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -1081,20 +1081,20 @@ CDF_STATUS pe_handle_mgmt_frame(void *p_cds_gctx, void *cds_buff)
 void pe_register_wma_handle(tpAniSirGlobal pMac, tSirSmeReadyReq *ready_req)
 {
 	void *p_cds_gctx;
-	CDF_STATUS retStatus;
+	QDF_STATUS retStatus;
 
 	p_cds_gctx = cds_get_global_context();
 
 	retStatus = wma_register_mgmt_frm_client(p_cds_gctx,
 				 pe_handle_mgmt_frame);
-	if (retStatus != CDF_STATUS_SUCCESS)
+	if (retStatus != QDF_STATUS_SUCCESS)
 		lim_log(pMac, LOGP,
 			FL("Registering the PE Handle with WMA has failed"));
 
 	retStatus = wma_register_roaming_callbacks(p_cds_gctx,
 			ready_req->csr_roam_synch_cb,
 			ready_req->pe_roam_synch_cb);
-	if (retStatus != CDF_STATUS_SUCCESS)
+	if (retStatus != QDF_STATUS_SUCCESS)
 		lim_log(pMac, LOGP,
 			FL("Registering roaming callbacks with WMA failed"));
 }
@@ -1836,7 +1836,7 @@ void lim_fill_join_rsp_ht_caps(tpPESession session, tpSirSmeJoinRsp join_rsp)
 #endif
 
 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
-CDF_STATUS lim_roam_fill_bss_descr(tpAniSirGlobal pMac,
+QDF_STATUS lim_roam_fill_bss_descr(tpAniSirGlobal pMac,
 		roam_offload_synch_ind *roam_offload_synch_ind_ptr,
 		tpSirBssDescription  bss_desc_ptr)
 {
@@ -1852,7 +1852,7 @@ CDF_STATUS lim_roam_fill_bss_descr(tpAniSirGlobal pMac,
 	(tpSirProbeRespBeacon) cdf_mem_malloc(sizeof(tSirProbeRespBeacon));
 	if (NULL == parsed_frm_ptr) {
 		lim_log(pMac, LOGE, "fail to allocate memory for frame");
-		return CDF_STATUS_E_NOMEM;
+		return QDF_STATUS_E_NOMEM;
 	}
 
 	if (roam_offload_synch_ind_ptr->beaconProbeRespLength <=
@@ -1861,7 +1861,7 @@ CDF_STATUS lim_roam_fill_bss_descr(tpAniSirGlobal pMac,
 		"few bytes in synchInd beacon / probe resp frame! length=%d",
 		__func__, roam_offload_synch_ind_ptr->beaconProbeRespLength);
 		cdf_mem_free(parsed_frm_ptr);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
 	CDF_TRACE(CDF_MODULE_ID_PE, CDF_TRACE_LEVEL_INFO,
@@ -1879,7 +1879,7 @@ CDF_STATUS lim_roam_fill_bss_descr(tpAniSirGlobal pMac,
 			"Parse error Beacon, length=%d",
 			roam_offload_synch_ind_ptr->beaconProbeRespLength);
 			cdf_mem_free(parsed_frm_ptr);
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 	} else {
 		if (sir_convert_probe_frame2_struct(pMac,
@@ -1891,7 +1891,7 @@ CDF_STATUS lim_roam_fill_bss_descr(tpAniSirGlobal pMac,
 			"Parse error ProbeResponse, length=%d",
 			roam_offload_synch_ind_ptr->beaconProbeRespLength);
 			cdf_mem_free(parsed_frm_ptr);
-			return CDF_STATUS_E_FAILURE;
+			return QDF_STATUS_E_FAILURE;
 		}
 	}
 	/* 24 byte MAC header and 12 byte to ssid IE */
@@ -1983,7 +1983,7 @@ CDF_STATUS lim_roam_fill_bss_descr(tpAniSirGlobal pMac,
 			ie_len);
 	}
 	cdf_mem_free(parsed_frm_ptr);
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 /**
  * pe_roam_synch_callback() - PE level callback for roam synch propagation
@@ -1997,7 +1997,7 @@ CDF_STATUS lim_roam_fill_bss_descr(tpAniSirGlobal pMac,
  *
  * Return: Success or Failure status
  */
-CDF_STATUS pe_roam_synch_callback(tpAniSirGlobal mac_ctx,
+QDF_STATUS pe_roam_synch_callback(tpAniSirGlobal mac_ctx,
 	roam_offload_synch_ind *roam_sync_ind_ptr,
 	tpSirBssDescription  bss_desc)
 {
@@ -2008,7 +2008,7 @@ CDF_STATUS pe_roam_synch_callback(tpAniSirGlobal mac_ctx,
 	uint16_t aid;
 	tpAddBssParams add_bss_params;
 	uint8_t local_nss;
-	CDF_STATUS status = CDF_STATUS_E_FAILURE;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
 
 	if (!roam_sync_ind_ptr) {
 		lim_log(mac_ctx, LOGE, FL("LFR3:roam_sync_ind_ptr is NULL"));
@@ -2030,11 +2030,11 @@ CDF_STATUS pe_roam_synch_callback(tpAniSirGlobal mac_ctx,
 		return status;
 	}
 	status = lim_roam_fill_bss_descr(mac_ctx, roam_sync_ind_ptr, bss_desc);
-	if (!CDF_IS_STATUS_SUCCESS(status)) {
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		lim_log(mac_ctx, LOGE, FL("LFR3:Failed to fill Bss Descr"));
 		return status;
 	}
-	status = CDF_STATUS_E_FAILURE;
+	status = QDF_STATUS_E_FAILURE;
 	ft_session_ptr = pe_create_session(mac_ctx, bss_desc->bssId,
 			&session_id, mac_ctx->lim.maxStation,
 			eSIR_INFRASTRUCTURE_MODE);
@@ -2096,7 +2096,7 @@ CDF_STATUS pe_roam_synch_callback(tpAniSirGlobal mac_ctx,
 	if (NULL == mac_ctx->roam.pReassocResp) {
 		lim_log(mac_ctx, LOGE, FL("LFR3:assoc resp mem alloc failed"));
 		ft_session_ptr->bRoamSynchInProgress = false;
-		return CDF_STATUS_E_NOMEM;
+		return QDF_STATUS_E_NOMEM;
 	}
 	cdf_mem_copy(mac_ctx->roam.pReassocResp,
 			(uint8_t *)roam_sync_ind_ptr +
@@ -2137,7 +2137,7 @@ CDF_STATUS pe_roam_synch_callback(tpAniSirGlobal mac_ctx,
 	if (mac_ctx->roam.pReassocResp)
 		cdf_mem_free(mac_ctx->roam.pReassocResp);
 	mac_ctx->roam.pReassocResp = NULL;
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 #endif
 
@@ -2259,26 +2259,26 @@ tMgmtFrmDropReason lim_is_pkt_candidate_for_drop(tpAniSirGlobal pMac,
 	return eMGMT_DROP_NO_DROP;
 }
 
-CDF_STATUS pe_acquire_global_lock(tAniSirLim *psPe)
+QDF_STATUS pe_acquire_global_lock(tAniSirLim *psPe)
 {
-	CDF_STATUS status = CDF_STATUS_E_INVAL;
+	QDF_STATUS status = QDF_STATUS_E_INVAL;
 
 	if (psPe) {
-		if (CDF_IS_STATUS_SUCCESS
+		if (QDF_IS_STATUS_SUCCESS
 			    (cdf_mutex_acquire(&psPe->lkPeGlobalLock))) {
-			status = CDF_STATUS_SUCCESS;
+			status = QDF_STATUS_SUCCESS;
 		}
 	}
 	return status;
 }
 
-CDF_STATUS pe_release_global_lock(tAniSirLim *psPe)
+QDF_STATUS pe_release_global_lock(tAniSirLim *psPe)
 {
-	CDF_STATUS status = CDF_STATUS_E_INVAL;
+	QDF_STATUS status = QDF_STATUS_E_INVAL;
 	if (psPe) {
-		if (CDF_IS_STATUS_SUCCESS
+		if (QDF_IS_STATUS_SUCCESS
 			    (cdf_mutex_release(&psPe->lkPeGlobalLock))) {
-			status = CDF_STATUS_SUCCESS;
+			status = QDF_STATUS_SUCCESS;
 		}
 	}
 	return status;

core/mac/src/pe/lim/lim_assoc_utils.c

@@ -1980,7 +1980,7 @@ tSirRetStatus
 lim_populate_matching_rate_set(tpAniSirGlobal mac_ctx, tpDphHashNode sta_ds,
 	tSirMacRateSet *oper_rate_set, tSirMacRateSet *ext_rate_set,
 	uint8_t *supported_mcs_set, tpPESession session_entry,
-	tDot11fIEVHTCaps * vht_caps)
+	tDot11fIEVHTCaps *vht_caps)
 #else
 tSirRetStatus
 lim_populate_matching_rate_set(tpAniSirGlobal mac_ctx, tpDphHashNode sta_ds,
@@ -2348,7 +2348,7 @@ lim_add_sta(tpAniSirGlobal mac_ctx,
 
 	add_sta_params->updateSta = update_entry;
 
-	add_sta_params->status = CDF_STATUS_SUCCESS;
+	add_sta_params->status = QDF_STATUS_SUCCESS;
 	add_sta_params->respReqd = 1;
 	/* Update HT Capability */
 
@@ -2757,7 +2757,7 @@ lim_del_sta(tpAniSirGlobal pMac,
 	cdf_mem_copy((uint8_t *) pDelStaParams->staMac,
 		     (uint8_t *) pStaDs->staAddr, sizeof(tSirMacAddr));
 
-	pDelStaParams->status = CDF_STATUS_SUCCESS;
+	pDelStaParams->status = QDF_STATUS_SUCCESS;
 	msgQ.type = WMA_DELETE_STA_REQ;
 	msgQ.reserved = 0;
 	msgQ.bodyptr = pDelStaParams;
@@ -2908,7 +2908,7 @@ lim_add_sta_self(tpAniSirGlobal pMac, uint16_t staIdx, uint8_t updateSta,
 
 	pAddStaParams->assocId = psessionEntry->limAID;
 	pAddStaParams->staType = STA_ENTRY_SELF;
-	pAddStaParams->status = CDF_STATUS_SUCCESS;
+	pAddStaParams->status = QDF_STATUS_SUCCESS;
 	pAddStaParams->respReqd = 1;
 
 	/* Update  PE session ID */
@@ -3586,7 +3586,7 @@ lim_del_bss(tpAniSirGlobal pMac, tpDphHashNode pStaDs, uint16_t bssIdx,
 		lim_deactivate_and_change_timer(pMac, eLIM_JOIN_FAIL_TIMER);
 	}
 
-	pDelBssParams->status = CDF_STATUS_SUCCESS;
+	pDelBssParams->status = QDF_STATUS_SUCCESS;
 	pDelBssParams->respReqd = 1;
 	cdf_mem_copy(pDelBssParams->bssid, psessionEntry->bssId,
 		     sizeof(tSirMacAddr));
@@ -4213,7 +4213,7 @@ tSirRetStatus lim_sta_send_add_bss(tpAniSirGlobal pMac, tpSirAssocRsp pAssocRsp,
 	lim_log(pMac, LOG2, FL("maxTxPower: %d"), pAddBssParams->maxTxPower);
 #endif
 	/* FIXME_GEN4 - Any other value that can be used for initialization? */
-	pAddBssParams->status = CDF_STATUS_SUCCESS;
+	pAddBssParams->status = QDF_STATUS_SUCCESS;
 	pAddBssParams->respReqd = true;
 	/* update persona */
 	pAddBssParams->halPersona = (uint8_t) psessionEntry->pePersona;
@@ -4744,7 +4744,7 @@ tSirRetStatus lim_sta_send_add_bss_pre_assoc(tpAniSirGlobal pMac, uint8_t update
 	lim_log(pMac, LOG2, FL("maxTxPower: %d"), pAddBssParams->maxTxPower);
 #endif
 
-	pAddBssParams->status = CDF_STATUS_SUCCESS;
+	pAddBssParams->status = QDF_STATUS_SUCCESS;
 	pAddBssParams->respReqd = true;
 
 	pAddBssParams->staContext.smesessionId = psessionEntry->smeSessionId;

core/mac/src/pe/lim/lim_ft.c

@@ -50,7 +50,7 @@
 #include "wma.h"
 
 extern void lim_send_set_sta_key_req(tpAniSirGlobal pMac,
-				     tLimMlmSetKeysReq *pMlmSetKeysReq,
+				     tLimMlmSetKeysReq * pMlmSetKeysReq,
 				     uint16_t staIdx,
 				     uint8_t defWEPIdx,
 				     tpPESession sessionEntry, bool sendRsp);
@@ -283,7 +283,7 @@ int lim_process_ft_pre_auth_req(tpAniSirGlobal mac_ctx, tpSirMsgQ msg)
 			FL("Performing pre-auth on same channel (session %p)"),
 			session);
 		/* We are in the same channel. Perform pre-auth */
-		lim_perform_ft_pre_auth(mac_ctx, CDF_STATUS_SUCCESS, NULL,
+		lim_perform_ft_pre_auth(mac_ctx, QDF_STATUS_SUCCESS, NULL,
 					session);
 	}
 
@@ -294,7 +294,7 @@ int lim_process_ft_pre_auth_req(tpAniSirGlobal mac_ctx, tpSirMsgQ msg)
  * Send the Auth1
  * Receive back Auth2
  *------------------------------------------------------------------*/
-void lim_perform_ft_pre_auth(tpAniSirGlobal pMac, CDF_STATUS status,
+void lim_perform_ft_pre_auth(tpAniSirGlobal pMac, QDF_STATUS status,
 			     uint32_t *data, tpPESession psessionEntry)
 {
 	tSirMacAuthFrameBody authFrame;
@@ -314,7 +314,7 @@ void lim_perform_ft_pre_auth(tpAniSirGlobal pMac, CDF_STATUS status,
 		}
 	}
 
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		lim_log(pMac, LOGE,
 			FL(" Change channel not successful for FT pre-auth"));
 		goto preauth_fail;
@@ -404,7 +404,7 @@ tSirRetStatus lim_ft_prepare_add_bss_req(tpAniSirGlobal pMac,
 		cdf_mem_free(pBeaconStruct);
 		lim_log(pMac, LOGP,
 			FL("Unable to allocate memory for creating ADD_BSS"));
-		return (eSIR_MEM_ALLOC_FAILED);
+		return eSIR_MEM_ALLOC_FAILED;
 	}
 
 	cdf_mem_set((uint8_t *) pAddBssParams, sizeof(tAddBssParams), 0);
@@ -726,7 +726,7 @@ tSirRetStatus lim_ft_prepare_add_bss_req(tpAniSirGlobal pMac,
 	}
 #endif
 
-	pAddBssParams->status = CDF_STATUS_SUCCESS;
+	pAddBssParams->status = QDF_STATUS_SUCCESS;
 	pAddBssParams->respReqd = true;
 
 	pAddBssParams->staContext.sessionId = pftSessionEntry->peSessionId;
@@ -1012,7 +1012,7 @@ tSirRetStatus lim_ft_setup_auth_session(tpAniSirGlobal pMac,
 /*------------------------------------------------------------------
  * Resume Link Call Back
  *------------------------------------------------------------------*/
-void lim_ft_process_pre_auth_result(tpAniSirGlobal pMac, CDF_STATUS status,
+void lim_ft_process_pre_auth_result(tpAniSirGlobal pMac, QDF_STATUS status,
 				    tpPESession psessionEntry)
 {
 	if (NULL == psessionEntry ||
@@ -1172,10 +1172,11 @@ void lim_handle_ft_pre_auth_rsp(tpAniSirGlobal pMac, tSirRetStatus status,
 		pbssDescription =
 			psessionEntry->ftPEContext.pFTPreAuthReq->pbssDescription;
 		lim_print_mac_addr(pMac, pbssDescription->bssId, LOG1);
-		if ((pftSessionEntry =
+		pftSessionEntry =
 			     pe_create_session(pMac, pbssDescription->bssId,
 					       &sessionId, pMac->lim.maxStation,
-					       psessionEntry->bssType)) == NULL) {
+					       psessionEntry->bssType);
+		if (pftSessionEntry == NULL) {
 			lim_log(pMac, LOGE, FL(
 				"Session not created for pre-auth 11R AP"));
 			status = eSIR_FAILURE;
@@ -1655,7 +1656,7 @@ void lim_process_ft_aggr_qo_s_rsp(tpAniSirGlobal pMac, tpSirMsgQ limMsg)
 	}
 	for (i = 0; i < HAL_QOS_NUM_AC_MAX; i++) {
 		if ((((1 << i) & pAggrQosRspMsg->tspecIdx)) &&
-		    (pAggrQosRspMsg->status[i] != CDF_STATUS_SUCCESS)) {
+		    (pAggrQosRspMsg->status[i] != QDF_STATUS_SUCCESS)) {
 			sir_copy_mac_addr(peerMacAddr, psessionEntry->bssId);
 			addTsParam.staIdx = pAggrQosRspMsg->staIdx;
 			addTsParam.sessionId = pAggrQosRspMsg->sessionId;
@@ -1878,7 +1879,7 @@ tSirRetStatus lim_process_ft_aggr_qos_req(tpAniSirGlobal pMac, uint32_t *pMsgBuf
  *
  * Return: Status of sending message to WMA.
  */
-CDF_STATUS lim_send_preauth_scan_offload(tpAniSirGlobal mac_ctx,
+QDF_STATUS lim_send_preauth_scan_offload(tpAniSirGlobal mac_ctx,
 			uint8_t session_id,
 			tSirFTPreAuthReq *ft_preauth_req)
 {
@@ -1890,7 +1891,7 @@ CDF_STATUS lim_send_preauth_scan_offload(tpAniSirGlobal mac_ctx,
 	if (NULL == scan_offload_req) {
 		lim_log(mac_ctx, LOGE,
 			FL("Memory allocation failed for pScanOffloadReq"));
-		return CDF_STATUS_E_NOMEM;
+		return QDF_STATUS_E_NOMEM;
 	}
 
 	cdf_mem_zero(scan_offload_req, sizeof(tSirScanOffloadReq));
@@ -1932,10 +1933,10 @@ CDF_STATUS lim_send_preauth_scan_offload(tpAniSirGlobal mac_ctx,
 	if (rc != eSIR_SUCCESS) {
 		lim_log(mac_ctx, LOGE, FL("START_SCAN_OFFLOAD failed %u"), rc);
 		cdf_mem_free(scan_offload_req);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 
@@ -1982,13 +1983,13 @@ void lim_preauth_scan_event_handler(tpAniSirGlobal mac_ctx,
 		 * after successful auth, or timed out. Either way, STA
 		 * is back to home channel. Data traffic can continue.
 		 */
-		lim_ft_process_pre_auth_result(mac_ctx, CDF_STATUS_SUCCESS,
+		lim_ft_process_pre_auth_result(mac_ctx, QDF_STATUS_SUCCESS,
 			session_entry);
 		break;
 
 	case SCAN_EVENT_FOREIGN_CHANNEL:
 		/* Sta is on candidate channel. Send auth */
-		lim_perform_ft_pre_auth(mac_ctx, CDF_STATUS_SUCCESS, NULL,
+		lim_perform_ft_pre_auth(mac_ctx, QDF_STATUS_SUCCESS, NULL,
 					session_entry);
 		break;
 	default:

core/mac/src/pe/lim/lim_ibss_peer_mgmt.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2015 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2012-2016 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -1088,7 +1088,7 @@ lim_ibss_add_sta_rsp(tpAniSirGlobal pMac, void *msg, tpPESession psessionEntry)
 		return eSIR_FAILURE;
 	}
 
-	if (pAddStaParams->status != CDF_STATUS_SUCCESS) {
+	if (pAddStaParams->status != QDF_STATUS_SUCCESS) {
 		PELOGE(lim_log
 			       (pMac, LOGE, FL("IBSS: ADD_STA_RSP error (%x) "),
 			       pAddStaParams->status);
@@ -1137,7 +1137,7 @@ void lim_ibss_del_bss_rsp_when_coalescing(tpAniSirGlobal pMac, void *msg,
 		goto end;
 	}
 
-	if (pDelBss->status != CDF_STATUS_SUCCESS) {
+	if (pDelBss->status != QDF_STATUS_SUCCESS) {
 		lim_log(pMac, LOGE,
 			FL("IBSS: DEL_BSS_RSP(coalesce) error (%x) Bss %d "),
 			pDelBss->status, pDelBss->bssIdx);
@@ -1234,7 +1234,7 @@ void lim_ibss_del_bss_rsp(tpAniSirGlobal pMac, void *msg, tpPESession psessionEn
 		return;
 	}
 
-	if (pDelBss->status != CDF_STATUS_SUCCESS) {
+	if (pDelBss->status != QDF_STATUS_SUCCESS) {
 		PELOGE(lim_log
 			       (pMac, LOGE, FL("IBSS: DEL_BSS_RSP error (%x) Bss %d "),
 			       pDelBss->status, pDelBss->bssIdx);

core/mac/src/pe/lim/lim_p2p.c

@@ -26,7 +26,7 @@
  */
 
 /*===========================================================================
-                        L I M _ P 2 P . C
+			L I M _ P 2 P . C
 
    OVERVIEW:
 
@@ -36,7 +36,7 @@
 
 /*===========================================================================
 
-                      EDIT HISTORY FOR FILE
+			EDIT HISTORY FOR FILE
 
    This section contains comments describing changes made to the module.
    Notice that changes are listed in reverse chronological order.
@@ -46,7 +46,7 @@
    when        who     what, where, why
    ----------    ---    --------------------------------------------------------
    2011-05-02    djindal Corrected file indentation and changed remain on channel
-                      handling for concurrency.
+			handling for concurrency.
    ===========================================================================*/
 
 #include "lim_utils.h"
@@ -63,21 +63,21 @@
    received Beacon/Prpbe Resp. */
 #define   MAX_TIME_TO_BE_ACTIVE_CHANNEL 9000
 
-void lim_exit_remain_on_channel(tpAniSirGlobal pMac, CDF_STATUS status,
+void lim_exit_remain_on_channel(tpAniSirGlobal pMac, QDF_STATUS status,
 				uint32_t *data, tpPESession psessionEntry);
 extern tSirRetStatus lim_set_link_state(tpAniSirGlobal pMac, tSirLinkState state,
 					tSirMacAddr bssId, tSirMacAddr selfMacAddr,
 					tpSetLinkStateCallback callback,
 					void *callbackArg);
 
-CDF_STATUS lim_p2p_action_cnf(tpAniSirGlobal pMac, uint32_t txCompleteSuccess);
+QDF_STATUS lim_p2p_action_cnf(tpAniSirGlobal pMac, uint32_t txCompleteSuccess);
 
 /*------------------------------------------------------------------
  *
  * Below function is called if hdd requests a remain on channel.
  *
  *------------------------------------------------------------------*/
-static CDF_STATUS lim_send_hal_req_remain_on_chan_offload(tpAniSirGlobal pMac,
+static QDF_STATUS lim_send_hal_req_remain_on_chan_offload(tpAniSirGlobal pMac,
 							  tSirRemainOnChnReq *
 							  pRemOnChnReq)
 {
@@ -89,7 +89,7 @@ static CDF_STATUS lim_send_hal_req_remain_on_chan_offload(tpAniSirGlobal pMac,
 	if (NULL == pScanOffloadReq) {
 		lim_log(pMac, LOGE,
 			FL("Memory allocation failed for pScanOffloadReq"));
-		return CDF_STATUS_E_NOMEM;
+		return QDF_STATUS_E_NOMEM;
 	}
 
 	cdf_mem_zero(pScanOffloadReq, sizeof(tSirScanOffloadReq));
@@ -122,10 +122,10 @@ static CDF_STATUS lim_send_hal_req_remain_on_chan_offload(tpAniSirGlobal pMac,
 		lim_log(pMac, LOGE, FL("wma_post_ctrl_msg() return failure %u"),
 			rc);
 		cdf_mem_free(pScanOffloadReq);
-		return CDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /*------------------------------------------------------------------
@@ -137,11 +137,11 @@ static CDF_STATUS lim_send_hal_req_remain_on_chan_offload(tpAniSirGlobal pMac,
 int lim_process_remain_on_chnl_req(tpAniSirGlobal pMac, uint32_t *pMsg)
 {
 	tSirRemainOnChnReq *msgbuff = (tSirRemainOnChnReq *) pMsg;
-	CDF_STATUS status;
+	QDF_STATUS status;
 
 	pMac->lim.gpLimRemainOnChanReq = msgbuff;
 	status = lim_send_hal_req_remain_on_chan_offload(pMac, msgbuff);
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		/* Post the meessage to Sme */
 		lim_send_sme_rsp(pMac, eWNI_SME_REMAIN_ON_CHN_RSP,
 				 status, msgbuff->sessionId, msgbuff->scan_id);
@@ -250,14 +250,13 @@ void lim_process_remain_on_chn_timeout(tpAniSirGlobal mac_ctx)
 
 	/* get the previous valid LINK state */
 	if (lim_set_link_state(mac_ctx, eSIR_LINK_IDLE_STATE, null_bssid,
-		mac_ctx->lim.gSelfMacAddr, NULL, NULL) != eSIR_SUCCESS)
-	{
+		mac_ctx->lim.gSelfMacAddr, NULL, NULL) != eSIR_SUCCESS) {
 		lim_log(mac_ctx, LOGE, FL("Unable to change link state"));
 		return;
 	}
 
 	if (mac_ctx->lim.gLimMlmState != eLIM_MLM_P2P_LISTEN_STATE) {
-		lim_remain_on_chn_rsp(mac_ctx, CDF_STATUS_SUCCESS, NULL);
+		lim_remain_on_chn_rsp(mac_ctx, QDF_STATUS_SUCCESS, NULL);
 	} else {
 		session = pe_find_session_by_session_id(mac_ctx,
 			roc_timer->sessionId);
@@ -269,11 +268,11 @@ void lim_process_remain_on_chn_timeout(tpAniSirGlobal mac_ctx)
 			goto error;
 		}
 
-		lim_exit_remain_on_channel(mac_ctx, CDF_STATUS_SUCCESS, NULL,
+		lim_exit_remain_on_channel(mac_ctx, QDF_STATUS_SUCCESS, NULL,
 			session);
 		return;
 error:
-		lim_remain_on_chn_rsp(mac_ctx, CDF_STATUS_E_FAILURE, NULL);
+		lim_remain_on_chn_rsp(mac_ctx, QDF_STATUS_E_FAILURE, NULL);
 	}
 	return;
 }
@@ -285,21 +284,21 @@ error:
  *
  *------------------------------------------------------------------*/
 
-void lim_exit_remain_on_channel(tpAniSirGlobal pMac, CDF_STATUS status,
+void lim_exit_remain_on_channel(tpAniSirGlobal pMac, QDF_STATUS status,
 				uint32_t *data, tpPESession psessionEntry)
 {
 
-	if (status != CDF_STATUS_SUCCESS) {
+	if (status != QDF_STATUS_SUCCESS) {
 		PELOGE(lim_log(pMac, LOGE, "Remain on Channel Failed");)
 		goto error;
 	}
 	/* Set the resume channel to Any valid channel (invalid). */
 	/* This will instruct HAL to set it to any previous valid channel. */
 	pe_set_resume_channel(pMac, 0, 0);
-	lim_remain_on_chn_rsp(pMac, CDF_STATUS_SUCCESS, NULL);
+	lim_remain_on_chn_rsp(pMac, QDF_STATUS_SUCCESS, NULL);
 	return;
 error:
-	lim_remain_on_chn_rsp(pMac, CDF_STATUS_E_FAILURE, NULL);
+	lim_remain_on_chn_rsp(pMac, QDF_STATUS_E_FAILURE, NULL);
 	return;
 }
 
@@ -308,7 +307,7 @@ error:
  * Send remain on channel respone: Success/ Failure
  *
  *------------------------------------------------------------------*/
-void lim_remain_on_chn_rsp(tpAniSirGlobal pMac, CDF_STATUS status, uint32_t *data)
+void lim_remain_on_chn_rsp(tpAniSirGlobal pMac, QDF_STATUS status, uint32_t *data)
 {
 	tpPESession psessionEntry;
 	uint8_t sessionId;
@@ -324,7 +323,7 @@ void lim_remain_on_chn_rsp(tpAniSirGlobal pMac, CDF_STATUS status, uint32_t *dat
 	}
 	/* Incase of the Remain on Channel Failure Case */
 	/* Cleanup Everything */
-	if (CDF_STATUS_E_FAILURE == status) {
+	if (QDF_STATUS_E_FAILURE == status) {
 		/* Deactivate Remain on Channel Timer */
 		lim_deactivate_and_change_timer(pMac, eLIM_REMAIN_CHN_TIMER);
 
@@ -342,10 +341,11 @@ void lim_remain_on_chn_rsp(tpAniSirGlobal pMac, CDF_STATUS status, uint32_t *dat
 	}
 
 	/* delete the session */
-	if ((psessionEntry = pe_find_session_by_bssid(pMac,
+	psessionEntry = pe_find_session_by_bssid(pMac,
 						      MsgRemainonChannel->
 						      selfMacAddr.bytes,
-						      &sessionId)) != NULL) {
+						      &sessionId);
+	if (psessionEntry != NULL) {
 		if (LIM_IS_P2P_DEVICE_ROLE(psessionEntry)) {
 			pe_delete_session(pMac, psessionEntry);
 		}
@@ -412,7 +412,7 @@ void lim_send_sme_mgmt_frame_ind(tpAniSirGlobal pMac, uint8_t frameType,
 	return;
 }
 
-CDF_STATUS lim_p2p_action_cnf(tpAniSirGlobal pMac, uint32_t txCompleteSuccess)
+QDF_STATUS lim_p2p_action_cnf(tpAniSirGlobal pMac, uint32_t txCompleteSuccess)
 {
 	if (pMac->lim.mgmtFrameSessionId != 0xff) {
 		/* The session entry might be invalid(0xff) action confirmation received after
@@ -424,7 +424,7 @@ CDF_STATUS lim_p2p_action_cnf(tpAniSirGlobal pMac, uint32_t txCompleteSuccess)
 		pMac->lim.mgmtFrameSessionId = 0xff;
 	}
 
-	return CDF_STATUS_SUCCESS;
+	return QDF_STATUS_SUCCESS;
 }
 
 /**
@@ -445,7 +445,7 @@ static void lim_tx_action_frame(tpAniSirGlobal mac_ctx,
 {
 	uint8_t tx_flag = 0;
 	tpSirMacFrameCtl fc = (tpSirMacFrameCtl) mb_msg->data;
-	CDF_STATUS cdf_status;
+	QDF_STATUS qdf_status;
 	uint8_t sme_session_id = 0;
 	uint16_t channel_freq;
 
@@ -459,7 +459,7 @@ static void lim_tx_action_frame(tpAniSirGlobal mac_ctx,
 
 	if ((SIR_MAC_MGMT_PROBE_RSP == fc->subType) ||
 		(mb_msg->noack)) {
-		cdf_status = wma_tx_frame(mac_ctx, packet, (uint16_t) msg_len,
+		qdf_status = wma_tx_frame(mac_ctx, packet, (uint16_t) msg_len,
 			TXRX_FRM_802_11_MGMT,
 			ANI_TXDIR_TODS, 7, lim_tx_complete,
 			frame, tx_flag, sme_session_id,
@@ -468,11 +468,11 @@ static void lim_tx_action_frame(tpAniSirGlobal mac_ctx,
 		if (!mb_msg->noack)
 			lim_send_sme_rsp(mac_ctx,
 				eWNI_SME_ACTION_FRAME_SEND_CNF,
-				cdf_status, mb_msg->sessionId, 0);
+				qdf_status, mb_msg->sessionId, 0);
 		mac_ctx->lim.mgmtFrameSessionId = 0xff;
 	} else {
 		mac_ctx->lim.mgmtFrameSessionId = mb_msg->sessionId;
-		cdf_status =
+		qdf_status =
 			wma_tx_frameWithTxComplete(mac_ctx, packet,
 				(uint16_t) msg_len,
 				TXRX_FRM_802_11_MGMT,
@@ -481,12 +481,12 @@ static void lim_tx_action_frame(tpAniSirGlobal mac_ctx,
 				sme_session_id, false,
 				channel_freq);
 
-		if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+		if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 			lim_log(mac_ctx, LOGE,
 				FL("couldn't send action frame"));
 			lim_send_sme_rsp(mac_ctx,
 				eWNI_SME_ACTION_FRAME_SEND_CNF,
-				cdf_status, mb_msg->sessionId, 0);
+				qdf_status, mb_msg->sessionId, 0);
 			mac_ctx->lim.mgmtFrameSessionId = 0xff;
 		} else {
 			mac_ctx->lim.mgmtFrameSessionId = mb_msg->sessionId;
@@ -516,7 +516,7 @@ void lim_send_p2p_action_frame(tpAniSirGlobal mac_ctx,
 	uint32_t msg_len;
 	uint8_t *frame;
 	void *packet;
-	CDF_STATUS cdf_status;
+	QDF_STATUS qdf_status;
 	tpSirMacFrameCtl fc = (tpSirMacFrameCtl) mb_msg->data;
 	uint8_t noa_len = 0;
 	uint8_t noa_stream[SIR_MAX_NOA_ATTR_LEN + (2 * SIR_P2P_IE_HEADER_LEN)];
@@ -541,7 +541,7 @@ void lim_send_p2p_action_frame(tpAniSirGlobal mac_ctx,
 		lim_log(mac_ctx, LOGE,
 			FL("RemainOnChannel is not running\n"));
 		lim_send_sme_rsp(mac_ctx, eWNI_SME_ACTION_FRAME_SEND_CNF,
-			CDF_STATUS_E_FAILURE, mb_msg->sessionId, 0);
+			QDF_STATUS_E_FAILURE, mb_msg->sessionId, 0);
 		return;
 	}
 	sme_session_id = mb_msg->sessionId;
@@ -654,9 +654,9 @@ void lim_send_p2p_action_frame(tpAniSirGlobal mac_ctx,
 			msg_len - PROBE_RSP_IE_OFFSET);
 
 	/* Ok-- try to allocate some memory: */
-	cdf_status = cds_packet_alloc((uint16_t) msg_len, (void **)&frame,
+	qdf_status = cds_packet_alloc((uint16_t) msg_len, (void **)&frame,
 		(void **)&packet);
-	if (!CDF_IS_STATUS_SUCCESS(cdf_status)) {
+	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		lim_log(mac_ctx, LOGE,
 			FL("Failed to allocate %d bytes for a Probe Request."),
 			msg_len);
@@ -720,7 +720,7 @@ void lim_send_p2p_action_frame(tpAniSirGlobal mac_ctx,
 				FL("Dropping SA Query - PE Session not found"));
 			lim_send_sme_rsp(mac_ctx,
 				eWNI_SME_ACTION_FRAME_SEND_CNF,
-				CDF_STATUS_E_FAILURE, mb_msg->sessionId, 0);
+				QDF_STATUS_E_FAILURE, mb_msg->sessionId, 0);
 			cds_packet_free((void *)packet);
 			return;
 		}
@@ -734,7 +734,7 @@ void lim_send_p2p_action_frame(tpAniSirGlobal mac_ctx,
 				FL("Dropping SA Query due to non PMF conne."));
 			lim_send_sme_rsp(mac_ctx,
 				eWNI_SME_ACTION_FRAME_SEND_CNF,
-				CDF_STATUS_E_FAILURE, mb_msg->sessionId, 0);
+				QDF_STATUS_E_FAILURE, mb_msg->sessionId, 0);
 			cds_packet_free((void *)packet);
 			return;
 		}

core/mac/src/pe/lim/lim_process_assoc_rsp_frame.c

@@ -811,8 +811,7 @@ lim_process_assoc_rsp_frame(tpAniSirGlobal mac_ctx,
 	/* Stop Association failure timer */
 	if (subtype == LIM_ASSOC)
 		lim_deactivate_and_change_timer(mac_ctx, eLIM_ASSOC_FAIL_TIMER);
-	else
-	{
+	else {
 		/* Stop Reassociation failure timer */
 		mac_ctx->lim.reAssocRetryAttempt = 0;
 		if ((NULL != mac_ctx->lim.pSessionEntry)
@@ -893,7 +892,7 @@ lim_process_assoc_rsp_frame(tpAniSirGlobal mac_ctx,
 				FL("ASSOC res with eSIR_MAC_TRY_AGAIN_LATER "
 				" recvd.Starting timer to wait timeout=%d."),
 				timeout_value);
-			if (CDF_STATUS_SUCCESS !=
+			if (QDF_STATUS_SUCCESS !=
 				cdf_mc_timer_start(
 					&session_entry->pmfComebackTimer,
 					timeout_value)) {