samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacld-3.0: Fix compilation issues after rebase

Browse Source 
Remove the compilation issues for references to cdf after rebase

Change-Id: Ia39c5c72fe5c95f9a91d5f6967ea60904b46f756
CRs-Fixed: 981188
This commit is contained in:
Anurag Chouhan
2016-02-29 14:15:27 +05:30
committed by Gerrit - the friendly Code Review server
parent b2dc16fefe
commit df2b26883d
28 changed files with 156 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
core/bmi/inc/bmi.h
View File

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

32
core/bmi/src/bmi.c
View File

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

16
core/bmi/src/bmi_1.c
View File

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

26
core/bmi/src/bmi_2.c
View File

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

4
core/bmi/src/i_bmi.h
View File

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

8
core/bmi/src/ol_fw.c
View File

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

8
core/cdf/inc/cdf_nbuf.h
View File

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

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

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

10
core/cdf/src/cdf_nbuf.c
View File

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

4
core/cdf/src/i_cdf_nbuf.h
View File

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

2
core/cds/inc/cds_api.h
View File

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

4
core/cds/inc/cds_sched.h
View File

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

10
core/cds/src/cds_api.c
View File

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

12
core/dp/htt/htt_tx.c
View File

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

14
core/dp/ol/inc/ol_htt_tx_api.h
View File

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

12
core/dp/txrx/ol_tx.c
View File

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

6
core/dp/txrx/ol_tx_desc.c
View File

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

8
core/dp/txrx/ol_txrx.c
View File

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

4
core/dp/txrx/ol_txrx_types.h
View File

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

10
core/hdd/src/wlan_hdd_driver_ops.c
View File

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

6
core/hdd/src/wlan_hdd_ftm.c
View File

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

18
core/hdd/src/wlan_hdd_ipa.c
View File

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

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

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

34
core/hdd/src/wlan_hdd_memdump.c
View File

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

8
core/utils/epping/src/epping_main.c
View File

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

2
core/wma/inc/wma.h
View File

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

4
core/wma/src/wma_data.c
View File

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

45
core/wma/src/wma_main.c
View File

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