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

qcacld-3.0: Add QDF status

Browse source 
Replace CDF status with QDF status

Change-Id: I7170c8ae4c5bd97a8f0f383af637bb2ec312f082
CRs-Fixed: 981188
This commit is contained in:
Anurag Chouhan 2016-02-18 18:00:46 +05:30 • committed by Gerrit - the friendly Code Review server
commit fb54ab0eac
178 changed files with 9644 additions and 9780 deletions
Download patch file Download diff file Expand all files Collapse all files

14
core/bmi/inc/bmi.h
View file

@ -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_ */

6
core/bmi/inc/ol_fw.h
View file

@ -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;
}

106
core/bmi/src/bmi.c
View file

@ -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);
}

60
core/bmi/src/bmi_1.c
View file

@ -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;
}

102
core/bmi/src/bmi_2.c
View file

@ -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;
}

40
core/bmi/src/i_bmi.h
View file

@ -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

148
core/bmi/src/ol_fw.c
View file

@ -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;
}

39
core/cdf/inc/cdf_lock.h
View file

@ -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)

19
core/cdf/inc/cdf_mc_timer.h
View file

@ -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

6
core/cdf/inc/cdf_nbuf.h
View file

@ -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);
}

112
core/cdf/inc/cdf_status.h
View file

@ -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 */

3
core/cdf/inc/cdf_trace.h
View file

@ -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);

2
core/cdf/inc/cdf_util.h
View file

@ -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);
}

126
core/cdf/src/cdf_lock.c
View file

@ -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;
}
/**

90
core/cdf/src/cdf_mc_timer.c
View file

@ -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;
}
/**

2
core/cdf/src/cdf_memory.c
View file

@ -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);
}

26
core/cdf/src/cdf_nbuf.c
View file

@ -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;
}
/**

4
core/cdf/src/cdf_trace.c
View file

@ -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;
}
/**

5
core/cdf/src/i_cdf_atomic.h
View file

@ -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)

21
core/cdf/src/i_cdf_defer.h
View file

@ -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*/

12
core/cdf/src/i_cdf_lock.h
View file

@ -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)

26
core/cdf/src/i_cdf_nbuf.h
View file

@ -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;
}
/**

12
core/cdf/src/i_cdf_softirq_timer.h
View file

@ -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;
}
/**

31
core/cdf/src/i_cdf_util.h
View file

@ -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;

25
core/cds/inc/cds_api.h
View file

@ -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);

54
core/cds/inc/cds_concurrency.h
View file

@ -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 */

1
core/cds/inc/cds_crypto.h
View file

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

17
core/cds/inc/cds_mq.h
View file

@ -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 */

11
core/cds/inc/cds_packet.h
View file

@ -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 ) */

16
core/cds/inc/cds_reg_service.h
View file

@ -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);

24
core/cds/inc/cds_sched.h
View file

@ -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);

23
core/cds/inc/cds_utils.h
View file

@ -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 */

262
core/cds/src/cds_api.c
View file

@ -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;
}
/**

352
core/cds/src/cds_concurrency.c
View file

File diff suppressed because it is too large Load diff

16
core/cds/src/cds_mq.c
View file

@ -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;
}
}

28
core/cds/src/cds_packet.c
View file

@ -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;

82
core/cds/src/cds_reg_service.c
View file

@ -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;
}
/**

54
core/cds/src/cds_sched.c
View file

@ -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() */
/**

136
core/cds/src/cds_utils.c
View file

@ -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 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 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)

4
core/dp/htt/htt_rx.c
View file

@ -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;
}

14
core/dp/ol/inc/ol_txrx_ctrl_api.h
View file

@ -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,

16
core/dp/ol/inc/ol_txrx_osif_api.h
View file

@ -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);

4
core/dp/txrx/ol_tx.c
View file

@ -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;

86
core/dp/txrx/ol_txrx.c
View file

@ -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

8
core/dp/txrx/txrx.h
View file

@ -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);

10
core/hdd/inc/wlan_hdd_assoc.h
View file

@ -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);

20
core/hdd/inc/wlan_hdd_cfg.h
View file

@ -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);

8
core/hdd/inc/wlan_hdd_debugfs.h
View file

@ -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)

3
core/hdd/inc/wlan_hdd_ftm.h
View file

@ -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);

18
core/hdd/inc/wlan_hdd_ipa.h
View file

@ -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,

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

@ -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,

8
core/hdd/inc/wlan_hdd_power.h
View file

@ -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

28
core/hdd/inc/wlan_hdd_softap_tx_rx.h
View file

@ -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);

12
core/hdd/inc/wlan_hdd_tx_rx.h
View file

@ -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);

12
core/hdd/inc/wlan_hdd_wext.h
View file

@ -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

34
core/hdd/inc/wlan_hdd_wmm.h
View file

@ -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 */

278
core/hdd/src/wlan_hdd_assoc.c
View file

@ -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;

344
core/hdd/src/wlan_hdd_cfg.c
View file

File diff suppressed because it is too large Load diff

213
core/hdd/src/wlan_hdd_cfg80211.c
View file

@ -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;
}

8
core/hdd/src/wlan_hdd_cfg80211.h
View file

@ -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,

12
core/hdd/src/wlan_hdd_conc_ut.c
View file

@ -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;
}

24
core/hdd/src/wlan_hdd_debugfs.c
View file

@ -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;
}
/**

17
core/hdd/src/wlan_hdd_driver_ops.c
View file

@ -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)
{

62
core/hdd/src/wlan_hdd_ext_scan.c
View file

@ -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;

125
core/hdd/src/wlan_hdd_ftm.c
View file

@ -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 */

22
core/hdd/src/wlan_hdd_green_ap.c
View file

@ -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");
}

387
core/hdd/src/wlan_hdd_hostapd.c
View file

File diff suppressed because it is too large Load diff

14
core/hdd/src/wlan_hdd_hostapd.h
View file

@ -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) */

186
core/hdd/src/wlan_hdd_ioctl.c
View file

@ -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;
}

38
core/hdd/src/wlan_hdd_ipa.c
View file

@ -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 */

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

File diff suppressed because it is too large Load diff

22
core/hdd/src/wlan_hdd_memdump.c
View file

@ -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"));
}

4
core/hdd/src/wlan_hdd_nan.c
View file

@ -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;

2
core/hdd/src/wlan_hdd_napi.c
View file

@ -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");

30
core/hdd/src/wlan_hdd_ocb.c
View file

@ -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;
}

28
core/hdd/src/wlan_hdd_oemdata.c
View file

@ -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);

46
core/hdd/src/wlan_hdd_p2p.c
View file

@ -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",

146
core/hdd/src/wlan_hdd_power.c
View file

@ -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;
}

42
core/hdd/src/wlan_hdd_scan.c
View file

@ -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;
}

154
core/hdd/src/wlan_hdd_softap_tx_rx.c
View file

@ -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;
}

10
core/hdd/src/wlan_hdd_stats.c
View file

@ -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;

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

@ -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;
}

62
core/hdd/src/wlan_hdd_tdls.c
View file

@ -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;

50
core/hdd/src/wlan_hdd_tx_rx.c
View file

@ -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

239
core/hdd/src/wlan_hdd_wext.c
View file

@ -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;

136
core/hdd/src/wlan_hdd_wmm.c
View file

@ -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;
}
/**

30
core/hdd/src/wlan_hdd_wowl.c
View file

@ -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);

4
core/mac/inc/ani_global.h
View file

@ -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;

6
core/mac/inc/mac_trace.h
View file

@ -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);

4
core/mac/inc/sir_api.h
View file

@ -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
*/

4
core/mac/src/pe/include/lim_api.h
View file

@ -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);

8
core/mac/src/pe/include/lim_ft.h
View file

@ -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__ */

2
core/mac/src/pe/include/lim_global.h
View file

@ -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 */

4
core/mac/src/pe/lim/lim_admit_control.c
View file

@ -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 "));

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

@ -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;

14
core/mac/src/pe/lim/lim_assoc_utils.c
View file

@ -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;

33
core/mac/src/pe/lim/lim_ft.c
View file

@ -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:

8
core/mac/src/pe/lim/lim_ibss_peer_mgmt.c
View file

@ -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);

76
core/mac/src/pe/lim/lim_p2p.c
View file

@ -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;
}

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

@ -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)) {

Some files were not shown because too many files have changed in this diff Show more