diff --git a/VERSION.txt b/VERSION.txt index c759ce1ae864..9b705309a2c4 100644 --- a/VERSION.txt +++ b/VERSION.txt @@ -1,2 +1,2 @@ -Current Component wlan-cmn.driver.lnx.1.0 version 5.1.0.22K +Current Component wlan-cmn.driver.lnx.1.0 version 5.1.0.22S Matches Component wlan-cld3.driver.lnx.1.1 version 5.1.0.22C diff --git a/hif/inc/hif.h b/hif/inc/hif.h index d30de2d75ec4..5b24ef8a64e6 100644 --- a/hif/inc/hif.h +++ b/hif/inc/hif.h @@ -40,7 +40,9 @@ extern "C" { #ifdef HIF_PCI #include #endif /* HIF_PCI */ - +#ifdef HIF_USB +#include +#endif /* HIF_USB */ #define ENABLE_MBOX_DUMMY_SPACE_FEATURE 1 typedef struct htc_callbacks HTC_CALLBACKS; @@ -363,7 +365,7 @@ typedef void (*fastpath_msg_handler)(void *, qdf_nbuf_t *, uint32_t); #ifdef WLAN_FEATURE_FASTPATH void hif_enable_fastpath(struct hif_opaque_softc *hif_ctx); bool hif_is_fastpath_mode_enabled(struct hif_opaque_softc *hif_ctx); -void *hif_get_ce_handle(struct hif_opaque_softc *hif_ctx, int); +void *hif_get_ce_handle(struct hif_opaque_softc *hif_ctx, int ret); int hif_ce_fastpath_cb_register(struct hif_opaque_softc *hif_ctx, fastpath_msg_handler handler, void *context); #else @@ -373,6 +375,11 @@ static inline int hif_ce_fastpath_cb_register(struct hif_opaque_softc *hif_ctx, { return QDF_STATUS_E_FAILURE; } +static inline void *hif_get_ce_handle(struct hif_opaque_softc *hif_ctx, int ret) +{ + return NULL; +} + #endif /* @@ -613,7 +620,11 @@ struct hif_pipe_addl_info *hif_get_addl_pipe_info(struct hif_opaque_softc *osc, uint32_t hif_set_nss_wifiol_mode(struct hif_opaque_softc *osc, uint32_t pipe_num); int32_t hif_get_nss_wifiol_bypass_nw_process(struct hif_opaque_softc *osc); -#endif +#endif /* QCA_NSS_WIFI_OFFLOAD_SUPPORT */ + +void hif_set_bundle_mode(struct hif_opaque_softc *scn, bool enabled, + int rx_bundle_cnt); +int hif_bus_reset_resume(struct hif_opaque_softc *scn); #ifdef WLAN_SUSPEND_RESUME_TEST typedef void (*hdd_fake_resume_callback)(uint32_t val); @@ -623,4 +634,5 @@ void hif_fake_apps_suspend(hdd_fake_resume_callback callback); #ifdef __cplusplus } #endif + #endif /* _HIF_H_ */ diff --git a/hif/inc/regtable.h b/hif/inc/regtable.h index 1453b5fcd7ed..fe460499022f 100644 --- a/hif/inc/regtable.h +++ b/hif/inc/regtable.h @@ -31,8 +31,14 @@ #ifdef HIF_SDIO #include "regtable_sdio.h" #endif + #if defined(HIF_PCI) || defined(HIF_SNOC) || defined(HIF_AHB) #include "reg_struct.h" #include "regtable_pcie.h" #endif + +#if defined(HIF_USB) +#include "regtable_usb.h" +#endif + #endif diff --git a/hif/src/ar6320def.h b/hif/src/ar6320def.h index 22413872205c..f03a07caa097 100644 --- a/hif/src/ar6320def.h +++ b/hif/src/ar6320def.h @@ -460,8 +460,10 @@ struct targetdef_s ar6320_targetdef = { .d_DRAM_BASE_ADDRESS = AR6320_DRAM_BASE_ADDRESS, .d_SOC_CORE_BASE_ADDRESS = AR6320_SOC_CORE_BASE_ADDRESS, .d_CORE_CTRL_ADDRESS = AR6320_CORE_CTRL_ADDRESS, +#if defined(HIF_PCI) || defined(HIF_SNOC) || defined(HIF_AHB) .d_MSI_NUM_REQUEST = MSI_NUM_REQUEST, .d_MSI_ASSIGN_FW = MSI_ASSIGN_FW, +#endif .d_CORE_CTRL_CPU_INTR_MASK = AR6320_CORE_CTRL_CPU_INTR_MASK, .d_SR_WR_INDEX_ADDRESS = AR6320_SR_WR_INDEX_ADDRESS, .d_DST_WATERMARK_ADDRESS = AR6320_DST_WATERMARK_ADDRESS, diff --git a/hif/src/ar6320v2def.h b/hif/src/ar6320v2def.h index 0058d447553c..7a27909cf68e 100644 --- a/hif/src/ar6320v2def.h +++ b/hif/src/ar6320v2def.h @@ -464,8 +464,10 @@ struct targetdef_s ar6320v2_targetdef = { .d_DRAM_BASE_ADDRESS = AR6320V2_DRAM_BASE_ADDRESS, .d_SOC_CORE_BASE_ADDRESS = AR6320V2_SOC_CORE_BASE_ADDRESS, .d_CORE_CTRL_ADDRESS = AR6320V2_CORE_CTRL_ADDRESS, +#if defined(HIF_PCI) || defined(HIF_SNOC) || defined(HIF_AHB) .d_MSI_NUM_REQUEST = MSI_NUM_REQUEST, .d_MSI_ASSIGN_FW = MSI_ASSIGN_FW, +#endif .d_CORE_CTRL_CPU_INTR_MASK = AR6320V2_CORE_CTRL_CPU_INTR_MASK, .d_SR_WR_INDEX_ADDRESS = AR6320V2_SR_WR_INDEX_ADDRESS, .d_DST_WATERMARK_ADDRESS = AR6320V2_DST_WATERMARK_ADDRESS, diff --git a/hif/src/ar9888def.h b/hif/src/ar9888def.h index 5a7fc331d9a8..9e291cc407c3 100644 --- a/hif/src/ar9888def.h +++ b/hif/src/ar9888def.h @@ -367,8 +367,10 @@ struct targetdef_s ar9888_targetdef = { .d_DRAM_BASE_ADDRESS = AR9888_DRAM_BASE_ADDRESS, .d_SOC_CORE_BASE_ADDRESS = AR9888_SOC_CORE_BASE_ADDRESS, .d_CORE_CTRL_ADDRESS = AR9888_CORE_CTRL_ADDRESS, +#if defined(HIF_PCI) || defined(HIF_SNOC) || defined(HIF_AHB) .d_MSI_NUM_REQUEST = MSI_NUM_REQUEST, .d_MSI_ASSIGN_FW = MSI_ASSIGN_FW, +#endif .d_CORE_CTRL_CPU_INTR_MASK = AR9888_CORE_CTRL_CPU_INTR_MASK, .d_SR_WR_INDEX_ADDRESS = AR9888_SR_WR_INDEX_ADDRESS, .d_DST_WATERMARK_ADDRESS = AR9888_DST_WATERMARK_ADDRESS, diff --git a/hif/src/ce/ce_bmi.c b/hif/src/ce/ce_bmi.c index 8f773da31909..4f3bcc6d790f 100644 --- a/hif/src/ce/ce_bmi.c +++ b/hif/src/ce/ce_bmi.c @@ -39,9 +39,6 @@ #include "hif_main.h" #include "ce_api.h" #include "qdf_trace.h" -#ifdef CONFIG_CNSS -#include -#endif #include "hif_debug.h" /* Track a BMI transaction that is in progress */ diff --git a/hif/src/ce/ce_diag.c b/hif/src/ce/ce_diag.c index 2fe339c13183..c96d0a316e79 100644 --- a/hif/src/ce/ce_diag.c +++ b/hif/src/ce/ce_diag.c @@ -38,9 +38,6 @@ #include "hif_main.h" #include "ce_api.h" #include "qdf_trace.h" -#ifdef CONFIG_CNSS -#include -#endif #include "hif_debug.h" void diff --git a/hif/src/ce/ce_main.c b/hif/src/ce/ce_main.c index 7fd2b1c0d63a..1a7d3a5a5123 100644 --- a/hif/src/ce/ce_main.c +++ b/hif/src/ce/ce_main.c @@ -38,15 +38,12 @@ #include "hif_main.h" #include "ce_api.h" #include "qdf_trace.h" -#ifdef CONFIG_CNSS -#include -#endif +#include "pld_common.h" #include "hif_debug.h" #include "ce_internal.h" #include "ce_reg.h" #include "ce_assignment.h" #include "ce_tasklet.h" -#include "platform_icnss.h" #ifndef CONFIG_WIN #include "qwlan_version.h" #endif @@ -1942,8 +1939,8 @@ void hif_get_target_ce_config(struct CE_pipe_config **target_ce_config_ret, */ int hif_wlan_enable(struct hif_softc *scn) { - struct icnss_wlan_enable_cfg cfg; - enum icnss_driver_mode mode; + struct pld_wlan_enable_cfg cfg; + enum pld_driver_mode mode; uint32_t con_mode = hif_get_conparam(scn); hif_get_target_ce_config((struct CE_pipe_config **)&cfg.ce_tgt_cfg, @@ -1959,16 +1956,17 @@ int hif_wlan_enable(struct hif_softc *scn) cfg.num_shadow_reg_cfg /= sizeof(struct shadow_reg_cfg); if (QDF_GLOBAL_FTM_MODE == con_mode) - mode = ICNSS_FTM; + mode = PLD_FTM; else if (QDF_IS_EPPING_ENABLED(con_mode)) - mode = ICNSS_EPPING; + mode = PLD_EPPING; else - mode = ICNSS_MISSION; + mode = PLD_MISSION; if (BYPASS_QMI) return 0; else - return icnss_wlan_enable(&cfg, mode, QWLAN_VERSIONSTR); + return pld_wlan_enable(scn->qdf_dev->dev, &cfg, + mode, QWLAN_VERSIONSTR); } #define CE_EPPING_USES_IRQ true @@ -2916,15 +2914,15 @@ irqreturn_t hif_fw_interrupt_handler(int irq, void *arg) */ void hif_wlan_disable(struct hif_softc *scn) { - enum icnss_driver_mode mode; + enum pld_driver_mode mode; uint32_t con_mode = hif_get_conparam(scn); if (QDF_GLOBAL_FTM_MODE == con_mode) - mode = ICNSS_FTM; + mode = PLD_FTM; else if (QDF_IS_EPPING_ENABLED(con_mode)) - mode = ICNSS_EPPING; + mode = PLD_EPPING; else - mode = ICNSS_MISSION; + mode = PLD_MISSION; - icnss_wlan_disable(mode); + pld_wlan_disable(scn->qdf_dev->dev, mode); } diff --git a/hif/src/ce/ce_tasklet.c b/hif/src/ce/ce_tasklet.c index 27bfba18b3ab..2f6809fa4935 100644 --- a/hif/src/ce/ce_tasklet.c +++ b/hif/src/ce/ce_tasklet.c @@ -40,10 +40,7 @@ #include "ce_reg.h" #include "ce_internal.h" #include "ce_tasklet.h" -#ifdef CONFIG_CNSS -#include -#endif -#include "platform_icnss.h" +#include "pld_common.h" #include "hif_debug.h" #include "hif_napi.h" @@ -243,6 +240,35 @@ void ce_tasklet_kill(struct hif_softc *scn) qdf_atomic_set(&scn->active_tasklet_cnt, 0); } +#define HIF_CE_DRAIN_WAIT_CNT 20 +/** + * hif_drain_tasklets(): wait untill no tasklet is pending + * @scn: hif context + * + * Let running tasklets clear pending trafic. + * + * Return: 0 if no bottom half is in progress when it returns. + * -EFAULT if it times out. + */ +int hif_drain_tasklets(struct hif_softc *scn) +{ + uint32_t ce_drain_wait_cnt = 0; + + while (qdf_atomic_read(&scn->active_tasklet_cnt)) { + if (++ce_drain_wait_cnt > HIF_CE_DRAIN_WAIT_CNT) { + HIF_ERROR("%s: CE still not done with access", + __func__); + + return -EFAULT; + } + HIF_INFO("%s: Waiting for CE to finish access", __func__); + msleep(10); + } + return 0; +} + + + #ifdef WLAN_SUSPEND_RESUME_TEST static bool g_hif_apps_fake_suspended; static hdd_fake_resume_callback hdd_fake_aps_resume; @@ -308,7 +334,10 @@ static bool hif_fake_aps_resume(void) static irqreturn_t hif_snoc_interrupt_handler(int irq, void *context) { struct ce_tasklet_entry *tasklet_entry = context; - return ce_dispatch_interrupt(icnss_get_ce_id(irq), tasklet_entry); + struct hif_softc *scn = HIF_GET_SOFTC(tasklet_entry->hif_ce_state); + + return ce_dispatch_interrupt(pld_get_ce_id(scn->qdf_dev->dev, irq), + tasklet_entry); } /** @@ -416,7 +445,7 @@ irqreturn_t ce_dispatch_interrupt(int ce_id, * * @ce_name: ce_name */ -const char *ce_name[ICNSS_MAX_IRQ_REGISTRATIONS] = { +const char *ce_name[] = { "WLAN_CE_0", "WLAN_CE_1", "WLAN_CE_2", @@ -445,20 +474,23 @@ QDF_STATUS ce_unregister_irq(struct HIF_CE_state *hif_ce_state, uint32_t mask) int id; int ce_count; int ret; + struct hif_softc *scn; if (hif_ce_state == NULL) { HIF_WARN("%s: hif_ce_state = NULL", __func__); return QDF_STATUS_SUCCESS; } - ce_count = HIF_GET_SOFTC(hif_ce_state)->ce_count; + scn = HIF_GET_SOFTC(hif_ce_state); + ce_count = scn->ce_count; + for (id = 0; id < ce_count; id++) { if ((mask & (1 << id)) && hif_ce_state->tasklets[id].inited) { - ret = icnss_ce_free_irq(id, + ret = pld_ce_free_irq(scn->qdf_dev->dev, id, &hif_ce_state->tasklets[id]); if (ret < 0) HIF_ERROR( - "%s: icnss_unregister_irq error - ce_id = %d, ret = %d", + "%s: pld_unregister_irq error - ce_id = %d, ret = %d", __func__, id, ret); } } @@ -477,14 +509,17 @@ QDF_STATUS ce_unregister_irq(struct HIF_CE_state *hif_ce_state, uint32_t mask) QDF_STATUS ce_register_irq(struct HIF_CE_state *hif_ce_state, uint32_t mask) { int id; - int ce_count = HIF_GET_SOFTC(hif_ce_state)->ce_count; + int ce_count; int ret; unsigned long irqflags = IRQF_TRIGGER_RISING; uint32_t done_mask = 0; + struct hif_softc *scn = HIF_GET_SOFTC(hif_ce_state); + + ce_count = scn->ce_count; for (id = 0; id < ce_count; id++) { if ((mask & (1 << id)) && hif_ce_state->tasklets[id].inited) { - ret = icnss_ce_request_irq(id, + ret = pld_ce_request_irq(scn->qdf_dev->dev, id, hif_snoc_interrupt_handler, irqflags, ce_name[id], &hif_ce_state->tasklets[id]); diff --git a/hif/src/ce/ce_tasklet.h b/hif/src/ce/ce_tasklet.h index 1b158aedfde7..a6fbdfd84856 100644 --- a/hif/src/ce/ce_tasklet.h +++ b/hif/src/ce/ce_tasklet.h @@ -31,6 +31,7 @@ void init_tasklet_workers(struct hif_opaque_softc *scn); void ce_tasklet_init(struct HIF_CE_state *hif_ce_state, uint32_t mask); void ce_tasklet_kill(struct hif_softc *scn); +int hif_drain_tasklets(struct hif_softc *scn); QDF_STATUS ce_register_irq(struct HIF_CE_state *hif_ce_state, uint32_t mask); QDF_STATUS ce_unregister_irq(struct HIF_CE_state *hif_ce_state, uint32_t mask); irqreturn_t ce_dispatch_interrupt(int irq, diff --git a/hif/src/dispatcher/dummy.c b/hif/src/dispatcher/dummy.c index db5ff06aee6e..e9362f96d5ef 100644 --- a/hif/src/dispatcher/dummy.c +++ b/hif/src/dispatcher/dummy.c @@ -284,3 +284,27 @@ void hif_dummy_display_stats(struct hif_softc *hif_ctx) */ void hif_dummy_clear_stats(struct hif_softc *hif_ctx) {} +/** + * hif_dummy_set_bundle_mode() - dummy call + * @hif_sc: hif context + * @enabled: flag to enable/disable bundling + * @rx_bundle_cnt: bundle count to be used for RX + * + * Return: none + */ +void hif_dummy_set_bundle_mode(struct hif_softc *hif_ctx, + bool enabled, int rx_bundle_cnt) +{ + return; +} + +/** + * hif_dummy_bus_reset_resume() - dummy call + * @hif_sc: hif context + * + * Return: int 0 for success, non zero for failure + */ +int hif_dummy_bus_reset_resume(struct hif_softc *hif_ctx) +{ + return 0; +} diff --git a/hif/src/dispatcher/dummy.h b/hif/src/dispatcher/dummy.h index a44db047039c..049fa1a5333c 100644 --- a/hif/src/dispatcher/dummy.h +++ b/hif/src/dispatcher/dummy.h @@ -55,3 +55,7 @@ void hif_dummy_ipa_get_ce_resource(struct hif_softc *hif_sc, void hif_dummy_mask_interrupt_call(struct hif_softc *hif_sc); void hif_dummy_display_stats(struct hif_softc *hif_ctx); void hif_dummy_clear_stats(struct hif_softc *hif_ctx); +void hif_dummy_set_bundle_mode(struct hif_softc *hif_ctx, + bool enabled, int rx_bundle_cnt); +int hif_dummy_bus_reset_resume(struct hif_softc *hif_ctx); + diff --git a/hif/src/dispatcher/multibus.c b/hif/src/dispatcher/multibus.c index 215c8299e1aa..416d997a5b4d 100644 --- a/hif/src/dispatcher/multibus.c +++ b/hif/src/dispatcher/multibus.c @@ -31,6 +31,7 @@ #include "hif.h" #include "hif_main.h" #include "multibus.h" +#include "dummy.h" #if defined(HIF_PCI) || defined(HIF_SNOC) || defined(HIF_AHB) #include "ce_main.h" #endif @@ -49,12 +50,13 @@ static void hif_intialize_default_ops(struct hif_softc *hif_sc) /* must be filled in by hif_bus_open */ bus_ops->hif_bus_close = NULL; - /* dummy implementations */ bus_ops->hif_display_stats = &hif_dummy_display_stats; bus_ops->hif_clear_stats = &hif_dummy_clear_stats; + bus_ops->hif_set_bundle_mode = hif_dummy_set_bundle_mode; + bus_ops->hif_bus_reset_resume = hif_dummy_bus_reset_resume; } #define NUM_OPS (sizeof(struct hif_bus_ops) / sizeof(void *)) @@ -100,6 +102,8 @@ int hif_bus_get_context_size(enum qdf_bus_type bus_type) return hif_snoc_get_context_size(); case QDF_BUS_TYPE_SDIO: return hif_sdio_get_context_size(); + case QDF_BUS_TYPE_USB: + return hif_usb_get_context_size(); default: return 0; } @@ -131,6 +135,8 @@ QDF_STATUS hif_bus_open(struct hif_softc *hif_sc, break; case QDF_BUS_TYPE_SDIO: status = hif_initialize_sdio_ops(hif_sc); + case QDF_BUS_TYPE_USB: + status = hif_initialize_usb_ops(&hif_sc->bus_ops); break; default: status = QDF_STATUS_E_NOSUPPORT; @@ -347,3 +353,34 @@ void hif_disable_power_management(struct hif_opaque_softc *hif_hdl) hif_sc->bus_ops.hif_disable_power_management(hif_sc); } +/** + * hif_set_bundle_mode() - enable bundling and set default rx bundle cnt + * @scn: pointer to hif_opaque_softc structure + * @enabled: flag to enable/disable bundling + * @rx_bundle_cnt: bundle count to be used for RX + * + * Return: none + */ +void hif_set_bundle_mode(struct hif_opaque_softc *scn, bool enabled, + int rx_bundle_cnt) +{ + struct hif_softc *hif_sc = HIF_GET_SOFTC(scn); + hif_sc->bus_ops.hif_set_bundle_mode(hif_sc, enabled, rx_bundle_cnt); +} + +/** + * hif_bus_reset_resume() - resume the bus after reset + * @scn: struct hif_opaque_softc + * + * This function is called to tell the driver that USB device has been resumed + * and it has also been reset. The driver should redo any necessary + * initialization. This function resets WLAN SOC. + * + * Return: int 0 for success, non zero for failure + */ +int hif_bus_reset_resume(struct hif_opaque_softc *scn) + +{ + struct hif_softc *hif_sc = HIF_GET_SOFTC(scn); + return hif_sc->bus_ops.hif_bus_reset_resume(hif_sc); +} diff --git a/hif/src/dispatcher/multibus.h b/hif/src/dispatcher/multibus.h index 5dd845f0c638..71b7a3c76bd7 100644 --- a/hif/src/dispatcher/multibus.h +++ b/hif/src/dispatcher/multibus.h @@ -74,6 +74,9 @@ struct hif_bus_ops { void (*hif_disable_power_management)(struct hif_softc *hif_ctx); void (*hif_display_stats)(struct hif_softc *hif_ctx); void (*hif_clear_stats)(struct hif_softc *hif_ctx); + void (*hif_set_bundle_mode) (struct hif_softc *hif_ctx, bool enabled, + int rx_bundle_cnt); + int (*hif_bus_reset_resume)(struct hif_softc *hif_ctx); }; #ifdef HIF_SNOC @@ -169,4 +172,23 @@ static inline int hif_sdio_get_context_size(void) } #endif /* HIF_SDIO */ +#ifdef HIF_USB +QDF_STATUS hif_initialize_usb_ops(struct hif_bus_ops *bus_ops); +int hif_usb_get_context_size(void); +#else +static inline QDF_STATUS hif_initialize_usb_ops(struct hif_bus_ops *bus_ops) +{ + HIF_ERROR("%s: not supported", __func__); + return QDF_STATUS_E_NOSUPPORT; +} +/** + * hif_usb_get_context_size() - dummy when usb isn't supported + * + * Return: 0 as an invalid size to indicate no support + */ +static inline int hif_usb_get_context_size(void) +{ + return 0; +} +#endif /* HIF_USB */ #endif /* _MULTIBUS_H_ */ diff --git a/hif/src/dispatcher/multibus_snoc.c b/hif/src/dispatcher/multibus_snoc.c index d2de51262d3a..ae292709fecd 100644 --- a/hif/src/dispatcher/multibus_snoc.c +++ b/hif/src/dispatcher/multibus_snoc.c @@ -45,8 +45,8 @@ QDF_STATUS hif_initialize_snoc_ops(struct hif_bus_ops *bus_ops) bus_ops->hif_bus_close = &hif_snoc_close; bus_ops->hif_bus_prevent_linkdown = &hif_dummy_bus_prevent_linkdown; bus_ops->hif_reset_soc = &hif_dummy_reset_soc; - bus_ops->hif_bus_suspend = &hif_dummy_bus_suspend; - bus_ops->hif_bus_resume = &hif_dummy_bus_resume; + bus_ops->hif_bus_suspend = &hif_snoc_bus_suspend; + bus_ops->hif_bus_resume = &hif_snoc_bus_resume; bus_ops->hif_target_sleep_state_adjust = &hif_dummy_target_sleep_state_adjust; diff --git a/hif/src/dispatcher/multibus_usb.c b/hif/src/dispatcher/multibus_usb.c new file mode 100644 index 000000000000..0f3af6007cb8 --- /dev/null +++ b/hif/src/dispatcher/multibus_usb.c @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2016 The Linux Foundation. All rights reserved. + * + * 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. + */ + +#include "hif.h" +#include "hif_main.h" +#include "multibus.h" +#include "usb_api.h" +#include "hif_io32.h" +#include "dummy.h" +#include "if_usb.h" + +/** + * hif_initialize_usb_ops() - initialize the usb ops + * @bus_ops: hif_bus_ops table pointer to initialize + * + * Return: QDF_STATUS_SUCCESS + */ +QDF_STATUS hif_initialize_usb_ops(struct hif_bus_ops *bus_ops) +{ + bus_ops->hif_bus_open = &hif_usb_open; + bus_ops->hif_bus_close = &hif_usb_close; + bus_ops->hif_bus_prevent_linkdown = &hif_dummy_bus_prevent_linkdown; + bus_ops->hif_reset_soc = &hif_dummy_reset_soc; + bus_ops->hif_bus_suspend = &hif_usb_bus_suspend; + bus_ops->hif_bus_resume = &hif_usb_bus_resume; + bus_ops->hif_target_sleep_state_adjust = + &hif_dummy_target_sleep_state_adjust; + bus_ops->hif_disable_isr = &hif_usb_disable_isr; + bus_ops->hif_nointrs = &hif_usb_nointrs; + bus_ops->hif_enable_bus = &hif_usb_enable_bus; + bus_ops->hif_disable_bus = &hif_usb_disable_bus; + bus_ops->hif_bus_configure = &hif_usb_bus_configure; + bus_ops->hif_get_config_item = &hif_dummy_get_config_item; + bus_ops->hif_set_mailbox_swap = &hif_dummy_set_mailbox_swap; + bus_ops->hif_claim_device = &hif_dummy_claim_device; + bus_ops->hif_shutdown_device = &hif_usb_shutdown_bus_device; + bus_ops->hif_stop = &hif_usb_stop_device; + bus_ops->hif_bus_pkt_dl_len_set = &hif_dummy_bus_pkt_dl_len_set; + bus_ops->hif_cancel_deferred_target_sleep = + &hif_dummy_cancel_deferred_target_sleep; + bus_ops->hif_irq_disable = &hif_usb_irq_disable; + bus_ops->hif_irq_enable = &hif_usb_irq_enable; + bus_ops->hif_dump_registers = &hif_dummy_dump_registers; + bus_ops->hif_dump_target_memory = &hif_dummy_dump_target_memory; + bus_ops->hif_ipa_get_ce_resource = &hif_dummy_ipa_get_ce_resource; + bus_ops->hif_enable_power_management = + &hif_dummy_enable_power_management; + bus_ops->hif_disable_power_management = + &hif_dummy_disable_power_management; + bus_ops->hif_set_bundle_mode = hif_usb_set_bundle_mode; + bus_ops->hif_bus_reset_resume = hif_usb_bus_reset_resume; + + return QDF_STATUS_SUCCESS; +} + +/** + * hif_usb_get_context_size() - return the size of the usb context + * + * Return the size of the context. (0 for invalid bus) + */ +int hif_usb_get_context_size(void) +{ + return sizeof(struct hif_usb_softc); +} diff --git a/hif/src/dispatcher/pci_api.h b/hif/src/dispatcher/pci_api.h index d895a0013511..6395cf484c12 100644 --- a/hif/src/dispatcher/pci_api.h +++ b/hif/src/dispatcher/pci_api.h @@ -24,7 +24,8 @@ * under proprietary terms before Copyright ownership was assigned * to the Linux Foundation. */ - +#ifndef _PCI_API_H_ +#define _PCI_API_H_ QDF_STATUS hif_pci_open(struct hif_softc *hif_ctx, enum qdf_bus_type bus_type); void hif_pci_close(struct hif_softc *hif_ctx); @@ -51,3 +52,4 @@ void hif_pci_enable_power_management(struct hif_softc *hif_ctx, void hif_pci_disable_power_management(struct hif_softc *hif_ctx); void hif_pci_display_stats(struct hif_softc *hif_ctx); void hif_pci_clear_stats(struct hif_softc *hif_ctx); +#endif /* _PCI_API_H_ */ diff --git a/hif/src/dispatcher/snoc_api.h b/hif/src/dispatcher/snoc_api.h index ec7902fa02da..813171f119dd 100644 --- a/hif/src/dispatcher/snoc_api.h +++ b/hif/src/dispatcher/snoc_api.h @@ -25,11 +25,13 @@ * to the Linux Foundation. */ +#ifndef _SNOC_API_H_ +#define _SNOC_API_H_ QDF_STATUS hif_snoc_open(struct hif_softc *hif_ctx, enum qdf_bus_type bus_type); void hif_snoc_close(struct hif_softc *hif_ctx); - - +int hif_snoc_bus_suspend(struct hif_softc *hif_ctx); +int hif_snoc_bus_resume(struct hif_softc *hif_ctx); void hif_snoc_disable_isr(struct hif_softc *hif_ctx); void hif_snoc_nointrs(struct hif_softc *scn); QDF_STATUS hif_snoc_enable_bus(struct hif_softc *ol_sc, @@ -43,3 +45,4 @@ void hif_snoc_irq_enable(struct hif_softc *scn, int ce_id); int hif_snoc_dump_registers(struct hif_softc *scn); void hif_snoc_display_stats(struct hif_softc *hif_ctx); void hif_snoc_clear_stats(struct hif_softc *hif_ctx); +#endif /* _SNOC_API_H_ */ diff --git a/hif/src/dispatcher/usb_api.h b/hif/src/dispatcher/usb_api.h new file mode 100644 index 000000000000..db8f2fdc841a --- /dev/null +++ b/hif/src/dispatcher/usb_api.h @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2016 The Linux Foundation. All rights reserved. + * + * 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. + */ +#ifndef _USB_API_H_ +#define _USB_API_H_ + +QDF_STATUS hif_usb_open(struct hif_softc *hif_ctx, + enum qdf_bus_type bus_type); +void hif_usb_close(struct hif_softc *hif_ctx); + + +void hif_usb_disable_isr(struct hif_softc *hif_ctx); +void hif_usb_nointrs(struct hif_softc *scn); +QDF_STATUS hif_usb_enable_bus(struct hif_softc *ol_sc, + struct device *dev, void *bdev, + const hif_bus_id *bid, + enum hif_enable_type type); +void hif_usb_disable_bus(struct hif_softc *scn); +int hif_usb_bus_configure(struct hif_softc *scn); +void hif_usb_irq_disable(struct hif_softc *scn, int ce_id); +void hif_usb_irq_enable(struct hif_softc *scn, int ce_id); +int hif_usb_dump_registers(struct hif_softc *scn); +int hif_usb_bus_suspend(struct hif_softc *hif_ctx); +int hif_usb_bus_resume(struct hif_softc *hif_ctx); +void hif_usb_stop_device(struct hif_softc *hif_sc); +void hif_usb_shutdown_bus_device(struct hif_softc *scn); +int hif_usb_bus_reset_resume(struct hif_softc *hif_ctx); +void hif_usb_set_bundle_mode(struct hif_opaque_softc *scn, + bool enabled, int rx_bundle_cnt); +#endif /*_USB_API_H_*/ diff --git a/hif/src/hif_debug.h b/hif/src/hif_debug.h index ff5f6c793f61..a51437bebf31 100644 --- a/hif/src/hif_debug.h +++ b/hif/src/hif_debug.h @@ -36,7 +36,7 @@ #define HIF_INFO_LO(args ...) \ QDF_TRACE(QDF_MODULE_ID_HIF, QDF_TRACE_LEVEL_INFO_LOW, ## args) #define HIF_TRACE(args ...) \ - QDF_TRACE(QDF_MODULE_ID_HIF, QDF_TRACE_LEVEL_ERROR, ## args) + QDF_TRACE(QDF_MODULE_ID_HIF, QDF_TRACE_LEVEL_INFO, ## args) #define HIF_DBG(args ...) \ QDF_TRACE(QDF_MODULE_ID_HIF, QDF_TRACE_LEVEL_DEBUG, ## args) diff --git a/hif/src/hif_main.c b/hif/src/hif_main.c index 624874a5d710..abdb15864568 100644 --- a/hif/src/hif_main.c +++ b/hif/src/hif_main.c @@ -39,17 +39,13 @@ #include "hif_main.h" #include "hif_hw_version.h" #if defined(HIF_PCI) || defined(HIF_SNOC) || defined(HIF_AHB) -#include "ce_api.h" #include "ce_tasklet.h" -#include "platform_icnss.h" #endif #include "qdf_trace.h" #include "qdf_status.h" -#ifdef CONFIG_CNSS -#include -#endif #include "hif_debug.h" #include "mp_dev.h" +#include "ce_api.h" void hif_dump(struct hif_opaque_softc *hif_ctx, uint8_t cmd_id, bool start) { @@ -328,6 +324,11 @@ void hif_get_hw_info(struct hif_opaque_softc *scn, u32 *version, u32 *revision, const char **target_name) { struct hif_target_info *info = hif_get_target_info_handle(scn); + struct hif_softc *sc = HIF_GET_SOFTC(scn); + + if (sc->bus_type == QDF_BUS_TYPE_USB) + hif_usb_get_hw_info(sc); + *version = info->target_version; *revision = info->target_revision; *target_name = hif_get_hw_name(info); @@ -459,7 +460,7 @@ QDF_STATUS hif_enable(struct hif_opaque_softc *hif_ctx, struct device *dev, scn->hif_init_done = true; - HIF_TRACE("%s: X OK", __func__); + HIF_TRACE("%s: OK", __func__); return QDF_STATUS_SUCCESS; } @@ -892,7 +893,7 @@ bool hif_is_recovery_in_progress(struct hif_softc *scn) return false; } - +#if defined(HIF_PCI) || defined(SNOC) || defined(HIF_AHB) /** * hif_batch_send() - API to access hif specific function * ce_batch_send. @@ -962,6 +963,7 @@ int hif_send_fast(struct hif_opaque_softc *osc, qdf_nbuf_t nbuf, return ce_send_fast((struct CE_handle *)ce_tx_hdl, nbuf, transfer_id, download_len); } +#endif /** * hif_reg_write() - API to access hif specific function @@ -994,3 +996,19 @@ uint32_t hif_reg_read(struct hif_opaque_softc *hif_ctx, uint32_t offset) struct hif_softc *scn = HIF_GET_SOFTC(hif_ctx); return hif_read32_mb(scn->mem + offset); } + +#if defined(HIF_USB) +/** + * hif_ramdump_handler(): generic ramdump handler + * @scn: struct hif_opaque_softc + * + * Return: None + */ + +void hif_ramdump_handler(struct hif_opaque_softc *scn) + +{ + if (hif_get_bus_type == QDF_BUS_TYPE_USB) + hif_usb_ramdump_handler(); +} +#endif diff --git a/hif/src/hif_main.h b/hif/src/hif_main.h index 371f99fd02bb..8a44e95ee2e2 100644 --- a/hif/src/hif_main.h +++ b/hif/src/hif_main.h @@ -95,6 +95,8 @@ #define HIF_GET_PCI_SOFTC(scn) ((struct hif_pci_softc *)scn) #define HIF_GET_CE_STATE(scn) ((struct HIF_CE_state *)scn) #define HIF_GET_SDIO_SOFTC(scn) ((struct hif_sdio_softc *)scn) +#define HIF_GET_USB_SOFTC(scn) ((struct hif_usb_softc *)scn) +#define HIF_GET_USB_DEVICE(scn) ((HIF_DEVICE_USB *)scn) #define HIF_GET_SOFTC(scn) ((struct hif_softc *)scn) #define GET_HIF_OPAQUE_HDL(scn) ((struct hif_opaque_softc *)scn) @@ -203,4 +205,12 @@ void hif_wlan_disable(struct hif_softc *scn); int hif_target_sleep_state_adjust(struct hif_softc *scn, bool sleep_ok, bool wait_for_it); +#ifdef HIF_USB +void hif_usb_get_hw_info(struct hif_softc *scn); +void hif_ramdump_handler(struct hif_opaque_softc *scn); + +#else +static inline void hif_usb_get_hw_info(struct hif_softc *scn) {} +static inline void hif_ramdump_handler(struct hif_opaque_softc *scn) {} +#endif #endif /* __HIF_MAIN_H__ */ diff --git a/hif/src/pcie/if_pci.c b/hif/src/pcie/if_pci.c index e28dab98b400..a37d5f3c66a7 100644 --- a/hif/src/pcie/if_pci.c +++ b/hif/src/pcie/if_pci.c @@ -47,16 +47,11 @@ #include #include "qdf_status.h" #include "qdf_atomic.h" -#ifdef CONFIG_CNSS -#include -#else -#include "cnss_stub.h" -#endif +#include "pld_common.h" #include "mp_dev.h" #include "hif_debug.h" #include "if_pci_internal.h" -#include "icnss_stub.h" #include "ce_tasklet.h" #include "targaddrs.h" @@ -88,19 +83,6 @@ struct ce_irq_reg_table { uint32_t irq_status; }; -#if !defined(QCA_WIFI_3_0_ADRASTEA) -static inline void cnss_intr_notify_q6(void) -{ -} -#endif - -#if !defined(QCA_WIFI_3_0_ADRASTEA) -static inline void *cnss_get_target_smem(void) -{ - return NULL; -} -#endif - #ifndef QCA_WIFI_3_0_ADRASTEA static inline void hif_pci_route_adrastea_interrupt(struct hif_pci_softc *sc) { @@ -124,7 +106,7 @@ void hif_pci_route_adrastea_interrupt(struct hif_pci_softc *sc) hif_write32_mb(sc->mem + Q6_ENABLE_REGISTER_1, 0); if (scn->notice_send) - cnss_intr_notify_q6(); + pld_intr_notify_q6(sc->dev); } } #endif @@ -1130,7 +1112,7 @@ static void hif_pm_runtime_start(struct hif_pci_softc *sc) HIF_INFO("%s: Enabling RUNTIME PM, Delay: %d ms", __func__, ol_sc->hif_config.runtime_pm_delay); - cnss_runtime_init(sc->dev, ol_sc->hif_config.runtime_pm_delay); + pld_runtime_init(sc->dev, ol_sc->hif_config.runtime_pm_delay); qdf_atomic_set(&sc->pm_state, HIF_PM_RUNTIME_STATE_ON); hif_runtime_pm_debugfs_create(sc); } @@ -1153,7 +1135,7 @@ static void hif_pm_runtime_stop(struct hif_pci_softc *sc) if (mode == QDF_GLOBAL_FTM_MODE || QDF_IS_EPPING_ENABLED(mode)) return; - cnss_runtime_exit(sc->dev); + pld_runtime_exit(sc->dev); hif_pm_runtime_resume(sc->dev); qdf_atomic_set(&sc->pm_state, HIF_PM_RUNTIME_STATE_NONE); @@ -2496,7 +2478,7 @@ static void hif_runtime_prevent_linkdown(struct hif_softc *scn, bool flag) } #endif -#if defined(CONFIG_CNSS) && defined(CONFIG_PCI_MSM) +#if defined(CONFIG_PCI_MSM) /** * hif_bus_prevent_linkdown(): allow or permit linkdown * @flag: true prevents linkdown, false allows @@ -2511,7 +2493,7 @@ void hif_pci_prevent_linkdown(struct hif_softc *scn, bool flag) HIF_ERROR("wlan: %s pcie power collapse", (flag ? "disable" : "enable")); hif_runtime_prevent_linkdown(scn, flag); - cnss_wlan_pm_control(flag); + pld_wlan_pm_control(scn->qdf_dev->dev, flag); } #else void hif_pci_prevent_linkdown(struct hif_softc *scn, bool flag) @@ -2522,32 +2504,6 @@ void hif_pci_prevent_linkdown(struct hif_softc *scn, bool flag) } #endif -/** - * hif_drain_tasklets(): wait untill no tasklet is pending - * @scn: hif context - * - * Let running tasklets clear pending trafic. - * - * Return: 0 if no bottom half is in progress when it returns. - * -EFAULT if it times out. - */ -static inline int hif_drain_tasklets(struct hif_softc *scn) -{ - uint32_t ce_drain_wait_cnt = 0; - - while (qdf_atomic_read(&scn->active_tasklet_cnt)) { - if (++ce_drain_wait_cnt > HIF_CE_DRAIN_WAIT_CNT) { - HIF_ERROR("%s: CE still not done with access", - __func__); - - return -EFAULT; - } - HIF_INFO("%s: Waiting for CE to finish access", __func__); - msleep(10); - } - return 0; -} - /** * hif_bus_suspend_link_up() - suspend the bus * @@ -3064,7 +3020,7 @@ static int hif_log_soc_wakeup_timeout(struct hif_pci_softc *sc) if (cbk->set_recovery_in_progress) cbk->set_recovery_in_progress(cbk->context, true); - cnss_wlan_pci_link_down(); + pld_is_pci_link_down(sc->dev); return -EACCES; } diff --git a/hif/src/pcie/if_pci.h b/hif/src/pcie/if_pci.h index 332002875443..ab89f7d6d6ca 100644 --- a/hif/src/pcie/if_pci.h +++ b/hif/src/pcie/if_pci.h @@ -185,13 +185,9 @@ irqreturn_t hif_pci_interrupt_handler(int irq, void *arg); #define OL_ATH_TX_DRAIN_WAIT_CNT 60 #endif -#define HIF_CE_DRAIN_WAIT_CNT 20 - - #ifdef FEATURE_RUNTIME_PM #include -#ifdef WLAN_OPEN_SOURCE static inline int hif_pm_request_resume(struct device *dev) { return pm_request_resume(dev); @@ -215,7 +211,6 @@ static inline int hif_pm_runtime_resume(struct device *dev) { return pm_runtime_resume(dev); } -#endif #else static inline void hif_pm_runtime_mark_last_busy(struct device *dev) { } #endif /* FEATURE_RUNTIME_PM */ diff --git a/hif/src/sdio/hif_sdio.c b/hif/src/sdio/hif_sdio.c index 83ef92248bd8..77b699336efa 100644 --- a/hif/src/sdio/hif_sdio.c +++ b/hif/src/sdio/hif_sdio.c @@ -226,16 +226,3 @@ void hif_send_complete_check(struct hif_opaque_softc *hif_ctx, uint8_t pipe, } -/** - * hif_set_bundle_mode() - set bundling mode. - * @hif_ctx: HIF context - * @enabled: enable/disable bundling - * @rx_bundle_cnt: bundling count - * - * Return: none - */ -void hif_set_bundle_mode(struct hif_opaque_softc *hif_ctx, bool enabled, - uint64_t rx_bundle_cnt) -{ - -} diff --git a/hif/src/snoc/hif_io32_snoc.h b/hif/src/snoc/hif_io32_snoc.h index 70fc14d6b4ed..1fe76f13042b 100644 --- a/hif/src/snoc/hif_io32_snoc.h +++ b/hif/src/snoc/hif_io32_snoc.h @@ -38,7 +38,6 @@ #include "regtable.h" #include "ce_reg.h" #include "qdf_atomic.h" -#include #include "hif_main.h" #include "hif_debug.h" diff --git a/hif/src/snoc/if_snoc.c b/hif/src/snoc/if_snoc.c index df7937f62f5c..ab0bda16b323 100644 --- a/hif/src/snoc/if_snoc.c +++ b/hif/src/snoc/if_snoc.c @@ -38,6 +38,9 @@ #include "ce_main.h" #include "ce_tasklet.h" #include "snoc_api.h" +#include +#include "pld_common.h" +#include "qdf_util.h" /** * hif_disable_isr(): disable isr @@ -130,13 +133,13 @@ QDF_STATUS hif_snoc_open(struct hif_softc *hif_ctx, enum qdf_bus_type bus_type) static QDF_STATUS hif_snoc_get_soc_info(struct hif_softc *scn) { int ret; - struct icnss_soc_info soc_info; + struct pld_soc_info soc_info; qdf_mem_zero(&soc_info, sizeof(soc_info)); - ret = icnss_get_soc_info(&soc_info); + ret = pld_get_soc_info(scn->qdf_dev->dev, &soc_info); if (ret < 0) { - HIF_ERROR("%s: icnss_get_soc_info error = %d", __func__, ret); + HIF_ERROR("%s: pld_get_soc_info error = %d", __func__, ret); return QDF_STATUS_E_FAILURE; } @@ -192,7 +195,7 @@ static inline int hif_snoc_get_target_type(struct hif_softc *ol_sc, struct device *dev, void *bdev, const hif_bus_id *bid, uint32_t *hif_type, uint32_t *target_type) { - /* TODO: need to use CNSS's HW version. Hard code for now */ + /* TODO: need to use HW version. Hard code for now */ #ifdef QCA_WIFI_3_0_ADRASTEA *hif_type = HIF_TYPE_ADRASTEA; *target_type = TARGET_TYPE_ADRASTEA; @@ -231,6 +234,16 @@ QDF_STATUS hif_snoc_enable_bus(struct hif_softc *ol_sc, return ret; } + ret = qdf_device_init_wakeup(ol_sc->qdf_dev, true); + if (ret == -EEXIST) + HIF_WARN("%s: device_init_wakeup already done", + __func__); + else if (ret) { + HIF_ERROR("%s: device_init_wakeup: err= %d", + __func__, ret); + return ret; + } + if (!ol_sc) { HIF_ERROR("%s: hif_ctx is NULL", __func__); return QDF_STATUS_E_NOMEM; @@ -265,6 +278,10 @@ QDF_STATUS hif_snoc_enable_bus(struct hif_softc *ol_sc, */ void hif_snoc_disable_bus(struct hif_softc *scn) { + int ret = qdf_device_init_wakeup(scn->qdf_dev, false); + + if (ret) + HIF_ERROR("%s: device_init_wakeup: err %d", __func__, ret); } /** @@ -309,3 +326,175 @@ void hif_snoc_irq_disable(struct hif_softc *scn, int ce_id) { ce_disable_irq_in_individual_register(scn, ce_id); } + +/* + * hif_snoc_setup_wakeup_sources() - enable/disable irq wake on correct irqs + * @hif_softc: hif context + * + * Firmware will send a wakeup request to the HTC_CTRL_RSVD_SVC when waking up + * the host driver. Ensure that the copy complete interrupt from this copy + * engine can wake up the apps processor. + * + * Return: 0 for success + */ +QDF_STATUS hif_snoc_setup_wakeup_sources(struct hif_softc *scn, bool enable) +{ + struct hif_opaque_softc *hif_hdl = GET_HIF_OPAQUE_HDL(scn); + uint8_t ul_pipe, dl_pipe; + int ul_is_polled, dl_is_polled; + int irq_to_wake_on; + + QDF_STATUS status; + int ret; + + status = hif_map_service_to_pipe(hif_hdl, HTC_CTRL_RSVD_SVC, + &ul_pipe, &dl_pipe, + &ul_is_polled, &dl_is_polled); + if (status) { + HIF_ERROR("%s: pipe_mapping failure", __func__); + return status; + } + + irq_to_wake_on = icnss_get_irq(dl_pipe); + if (irq_to_wake_on < 0) { + HIF_ERROR("%s: failed to map ce to irq", __func__); + return QDF_STATUS_E_RESOURCES; + } + + if (enable) + ret = enable_irq_wake(irq_to_wake_on); + else + ret = disable_irq_wake(irq_to_wake_on); + + if (ret) { + HIF_ERROR("%s: Fail to setup wake IRQ!", __func__); + return QDF_STATUS_E_RESOURCES; + } + + HIF_ERROR("%s: expecting wake from ce %d, irq %d", + __func__, dl_pipe, irq_to_wake_on); + return QDF_STATUS_SUCCESS; +} + +/** + * __hif_snoc_irq_state_vote() - enable/disable all the ce interrupts + * @scn: hif context pointer + * @enble: true to enable the interrupts false to disable + * + * takes care of unwinding partial successes. + * + * Return: QDF_STATUS_SUCCESS on success + */ + +static QDF_STATUS __hif_snoc_irq_state_vote(struct hif_softc *scn, bool enable) +{ + int num_ce = scn->ce_count; + int ce_id = 0; + int irq; + + while (ce_id < num_ce) { + irq = icnss_get_irq(ce_id); + if (irq < 0) + goto error; + + if (enable) + enable_irq(irq); + else + disable_irq(irq); + + ce_id++; + } + + return QDF_STATUS_SUCCESS; + +error: + HIF_ERROR("%s: failed to map ce to irq", __func__); + + while (--ce_id >= 0) { + irq = icnss_get_irq(ce_id); + if (irq < 0) + continue; + + if (enable) + disable_irq(irq); + else + enable_irq(irq); + } + return QDF_STATUS_E_FAULT; +} + +/** + * hif_snoc_enable_irqs() - enable the ce irqs + * @scn: hif context + * + * Return: QDF_STATUS_SUCCESS on success + */ +static QDF_STATUS hif_snoc_enable_irqs(struct hif_softc *scn) +{ + return __hif_snoc_irq_state_vote(scn, true); +} + +/** + * hif_snoc_enable_irqs() - enable the ce irqs + * @scn: hif context + * + * Return: QDF_STATUS_SUCCESS on success + */ +static QDF_STATUS hif_snoc_disable_irqs(struct hif_softc *scn) +{ + return __hif_snoc_irq_state_vote(scn, false); +} + +/** + * hif_snoc_bus_suspend() - prepare to suspend the bus + * @scn: hif context + * + * Setup wakeup interrupt configuration. + * Disable CE interrupts (wakeup interrupt will still wake apps) + * Drain tasklets. - make sure that we don't suspend while processing + * the wakeup message. + * + * Return: 0 on success. + */ +int hif_snoc_bus_suspend(struct hif_softc *scn) +{ + if (hif_snoc_setup_wakeup_sources(scn, true) != QDF_STATUS_SUCCESS) + goto error; + + if (hif_snoc_disable_irqs(scn) != QDF_STATUS_SUCCESS) + goto wakeup_sources; + + if (hif_drain_tasklets(scn) != 0) + goto enable_irqs; + return 0; + +enable_irqs: + if (hif_snoc_enable_irqs(scn) != QDF_STATUS_SUCCESS) + QDF_BUG(0); +wakeup_sources: + if (hif_snoc_setup_wakeup_sources(scn, false) != QDF_STATUS_SUCCESS) + QDF_BUG(0); +error: + return -EFAULT; + +} + +/** + * hif_snoc_bus_resume() - snoc bus resume function + * @scn: hif context + * + * Clear wakeup interrupt configuration. + * Reenable ce interrupts + * + * Return: 0 on success + */ +int hif_snoc_bus_resume(struct hif_softc *scn) +{ + if (hif_snoc_setup_wakeup_sources(scn, false) != QDF_STATUS_SUCCESS) + QDF_BUG(0); + + if (hif_snoc_enable_irqs(scn) != QDF_STATUS_SUCCESS) + QDF_BUG(0); + + return 0; +} diff --git a/hif/src/usb/hif_usb.c b/hif/src/usb/hif_usb.c index e0682f6fd209..8c1a3e4628ef 100644 --- a/hif/src/usb/hif_usb.c +++ b/hif/src/usb/hif_usb.c @@ -893,14 +893,14 @@ void hif_suspend_wow(struct hif_opaque_softc *scn) } /** - * hif_set_bundle_mode() - enable bundling and set default rx bundle cnt + * hif_usb_set_bundle_mode() - enable bundling and set default rx bundle cnt * @scn: pointer to hif_opaque_softc structure * @enabled: flag to enable/disable bundling * @rx_bundle_cnt: bundle count to be used for RX * * Return: none */ -void hif_set_bundle_mode(struct hif_opaque_softc *scn, +void hif_usb_set_bundle_mode(struct hif_softc *scn, bool enabled, int rx_bundle_cnt) { HIF_DEVICE_USB *device = HIF_GET_USB_DEVICE(scn); diff --git a/hif/src/usb/if_usb.c b/hif/src/usb/if_usb.c index ff056eaeb1ac..7b6cc54d9b26 100644 --- a/hif/src/usb/if_usb.c +++ b/hif/src/usb/if_usb.c @@ -361,7 +361,7 @@ int hif_usb_bus_resume(struct hif_softc *hif_ctx) } /** - * hif_bus_reset_resume() - resume the bus after reset + * hif_usb_bus_reset_resume() - resume the bus after reset * @scn: struct hif_opaque_softc * * This function is called to tell the driver that USB device has been resumed @@ -370,10 +370,9 @@ int hif_usb_bus_resume(struct hif_softc *hif_ctx) * * Return: int 0 for success, non zero for failure */ -int hif_bus_reset_resume(struct hif_opaque_softc *scn) +int hif_usb_bus_reset_resume(struct hif_softc *hif_ctx) { int ret = 0; - struct hif_softc *hif_ctx = HIF_GET_SOFTC(scn); HIF_ENTER(); if (hif_usb_diag_write_cold_reset(hif_ctx) != QDF_STATUS_SUCCESS) ret = 1; @@ -621,7 +620,7 @@ void hif_fw_assert_ramdump_pattern(struct hif_usb_softc *sc) } /** - * hif_ramdump_handler(): dump bus debug registers + * hif_usb_ramdump_handler(): dump bus debug registers * @scn: struct hif_opaque_softc * * This function is to receive information of firmware crash dump, and @@ -641,7 +640,7 @@ void hif_fw_assert_ramdump_pattern(struct hif_usb_softc *sc) * Return: 0 for success or error code */ -void hif_ramdump_handler(struct hif_opaque_softc *scn) +void hif_usb_ramdump_handler(struct hif_opaque_softc *scn) { uint32_t *reg, pattern, i, start_addr = 0; uint32_t len; diff --git a/htc/htc.c b/htc/htc.c index 76d41caad8c7..5fd24fb9d8b3 100644 --- a/htc/htc.c +++ b/htc/htc.c @@ -611,6 +611,12 @@ static void reset_endpoint_states(HTC_TARGET *target) } } +/** + * htc_start() - Main HTC function to trigger HTC start + * @HTCHandle: pointer to HTC handle + * + * Return: A_OK for success or an appropriate A_STATUS error + */ A_STATUS htc_start(HTC_HANDLE HTCHandle) { qdf_nbuf_t netbuf; @@ -656,13 +662,14 @@ A_STATUS htc_start(HTC_HANDLE HTCHandle) ("HTC using TX credit flow control\n")); } -#ifdef HIF_SDIO -#if ENABLE_BUNDLE_RX - if (HTC_ENABLE_BUNDLE(target)) + if ((hif_get_bus_type(target->hif_dev) == QDF_BUS_TYPE_SDIO) || + (hif_get_bus_type(target->hif_dev) == QDF_BUS_TYPE_USB)) { + if (HTC_RX_BUNDLE_ENABLED(target)) pSetupComp->SetupFlags |= HTC_SETUP_COMPLETE_FLAGS_ENABLE_BUNDLE_RECV; -#endif /* ENABLE_BUNDLE_RX */ -#endif /* HIF_SDIO */ + hif_set_bundle_mode(target->hif_dev, true, + HTC_MAX_MSG_PER_BUNDLE_RX); + } SET_HTC_PACKET_INFO_TX(pSendPacket, NULL, diff --git a/htc/htc_internal.h b/htc/htc_internal.h index d1738b10c5f0..ccabdb699027 100644 --- a/htc/htc_internal.h +++ b/htc/htc_internal.h @@ -89,6 +89,7 @@ typedef enum { HTC_PROCESS_CREDIT_REPORT, HTC_SUSPEND_ACK, HTC_SUSPEND_NACK, + HTC_INITIAL_WAKE_UP, } htc_credit_exchange_type; typedef struct { @@ -193,7 +194,7 @@ typedef struct _HTC_TARGET { #ifdef HIF_SDIO A_UINT16 AltDataCreditSize; #endif - + A_UINT32 avail_tx_credits; #if defined(DEBUG_HL_LOGGING) && defined(CONFIG_HL_SUPPORT) A_UINT32 rx_bundle_stats[HTC_MAX_MSG_PER_BUNDLE_RX]; A_UINT32 tx_bundle_stats[HTC_MAX_MSG_PER_BUNDLE_TX]; @@ -202,7 +203,20 @@ typedef struct _HTC_TARGET { uint32_t con_mode; } HTC_TARGET; +#if defined ENABLE_BUNDLE_TX +#define HTC_TX_BUNDLE_ENABLED(target) (target->MaxMsgsPerHTCBundle > 1) +#else +#define HTC_TX_BUNDLE_ENABLED(target) 0 +#endif + +#if defined ENABLE_BUNDLE_RX +#define HTC_RX_BUNDLE_ENABLED(target) (target->MaxMsgsPerHTCBundle > 1) +#else +#define HTC_RX_BUNDLE_ENABLED(target) 0 +#endif + #define HTC_ENABLE_BUNDLE(target) (target->MaxMsgsPerHTCBundle > 1) + #ifdef RX_SG_SUPPORT #define RESET_RX_SG_CONFIG(_target) \ _target->ExpRxSgTotalLen = 0; \ @@ -327,7 +341,7 @@ htc_send_complete_check(HTC_ENDPOINT *pEndpoint, int force) { #define DEBUG_BUNDLE 0 #endif -#ifdef HIF_SDIO +#if defined(HIF_SDIO) || defined(HIF_USB) #ifndef ENABLE_BUNDLE_TX #define ENABLE_BUNDLE_TX 1 #endif @@ -335,5 +349,5 @@ htc_send_complete_check(HTC_ENDPOINT *pEndpoint, int force) { #ifndef ENABLE_BUNDLE_RX #define ENABLE_BUNDLE_RX 1 #endif -#endif /* HIF_SDIO */ +#endif /*defined(HIF_SDIO) || defined(HIF_USB)*/ #endif /* !_HTC_HOST_INTERNAL_H_ */ diff --git a/htc/htc_recv.c b/htc/htc_recv.c index e3b5383baff4..49e2fddebba0 100644 --- a/htc/htc_recv.c +++ b/htc/htc_recv.c @@ -440,6 +440,18 @@ QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf, qdf_event_set(&target->ctrl_response_valid); break; +#ifdef CONFIG_MCL + case HTC_MSG_WAKEUP_FROM_SUSPEND_ID: + AR_DEBUG_PRINTF(ATH_DEBUG_ANY, + ("Received initial wake up\n")); + LOCK_HTC_CREDIT(target); + htc_credit_record(HTC_INITIAL_WAKE_UP, + pEndpoint->TxCredits, + HTC_PACKET_QUEUE_DEPTH( + &pEndpoint->TxQueue)); + UNLOCK_HTC_CREDIT(target); + break; +#endif case HTC_MSG_SEND_SUSPEND_COMPLETE: wow_nack = false; LOCK_HTC_CREDIT(target); diff --git a/htc/htc_send.c b/htc/htc_send.c index 4d538223fc12..d6b87946e4ee 100644 --- a/htc/htc_send.c +++ b/htc/htc_send.c @@ -383,6 +383,14 @@ static A_STATUS htc_send_bundled_netbuf(HTC_TARGET *target, return status; } +/** + * htc_issue_packets_bundle() - HTC function to send bundle packets from a queue + * @target: HTC target on which packets need to be sent + * @pEndpoint: logical endpoint on which packets needs to be sent + * @pPktQueue: HTC packet queue containing the list of packets to be sent + * + * Return: void + */ static void htc_issue_packets_bundle(HTC_TARGET *target, HTC_ENDPOINT *pEndpoint, HTC_PACKET_QUEUE *pPktQueue) @@ -392,6 +400,7 @@ static void htc_issue_packets_bundle(HTC_TARGET *target, unsigned char *pBundleBuffer = NULL; HTC_PACKET *pPacket = NULL, *pPacketTx = NULL; HTC_FRAME_HDR *pHtcHdr; + int last_credit_pad = 0; int creditPad, creditRemainder, transferLength, bundlesSpaceRemaining = 0; HTC_PACKET_QUEUE *pQueueSave = NULL; @@ -429,7 +438,8 @@ static void htc_issue_packets_bundle(HTC_TARGET *target, if (bundlesSpaceRemaining < transferLength) { /* send out previous buffer */ - htc_send_bundled_netbuf(target, pEndpoint, pBundleBuffer, + htc_send_bundled_netbuf(target, pEndpoint, + pBundleBuffer - last_credit_pad, pPacketTx); if (HTC_PACKET_QUEUE_DEPTH(pPktQueue) < HTC_MIN_MSG_PER_BUNDLE) { @@ -453,20 +463,25 @@ static void htc_issue_packets_bundle(HTC_TARGET *target, bundlesSpaceRemaining -= transferLength; netbuf = GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket); - pHtcHdr = (HTC_FRAME_HDR *) qdf_nbuf_get_frag_vaddr(netbuf, 0); - HTC_WRITE32(pHtcHdr, - SM(pPacket->ActualLength, - HTC_FRAME_HDR_PAYLOADLEN) | SM(pPacket->PktInfo. - AsTx. - SendFlags | - HTC_FLAGS_SEND_BUNDLE, - HTC_FRAME_HDR_FLAGS) - | SM(pPacket->Endpoint, HTC_FRAME_HDR_ENDPOINTID)); - HTC_WRITE32((uint32_t *) pHtcHdr + 1, - SM(pPacket->PktInfo.AsTx.SeqNo, - HTC_FRAME_HDR_CONTROLBYTES1) | SM(creditPad, - HTC_FRAME_HDR_RESERVED)); - pHtcHdr->reserved = creditPad; + + if (hif_get_bus_type(target->hif_dev) != QDF_BUS_TYPE_USB) { + pHtcHdr = + (HTC_FRAME_HDR *) + qdf_nbuf_get_frag_vaddr(netbuf, 0); + HTC_WRITE32(pHtcHdr, + SM(pPacket->ActualLength, + HTC_FRAME_HDR_PAYLOADLEN) | + SM(pPacket->PktInfo.AsTx.SendFlags | + HTC_FLAGS_SEND_BUNDLE, + HTC_FRAME_HDR_FLAGS) | + SM(pPacket->Endpoint, + HTC_FRAME_HDR_ENDPOINTID)); + HTC_WRITE32((uint32_t *) pHtcHdr + 1, + SM(pPacket->PktInfo.AsTx.SeqNo, + HTC_FRAME_HDR_CONTROLBYTES1) | SM(creditPad, + HTC_FRAME_HDR_RESERVED)); + pHtcHdr->reserved = creditPad; + } frag_count = qdf_nbuf_get_num_frags(netbuf); nbytes = pPacket->ActualLength + HTC_HDR_LENGTH; for (i = 0; i < frag_count && nbytes > 0; i++) { @@ -482,18 +497,39 @@ static void htc_issue_packets_bundle(HTC_TARGET *target, } HTC_PACKET_ENQUEUE(pQueueSave, pPacket); pBundleBuffer += creditPad; + + if (hif_get_bus_type(target->hif_dev) == QDF_BUS_TYPE_USB) { + /* last one can't be packed. */ + last_credit_pad = creditPad; + } + } if (pBundleBuffer != qdf_nbuf_data(bundleBuf)) { /* send out remaining buffer */ - htc_send_bundled_netbuf(target, pEndpoint, pBundleBuffer, + htc_send_bundled_netbuf(target, pEndpoint, + pBundleBuffer - last_credit_pad, pPacketTx); } else { free_htc_bundle_packet(target, pPacketTx); } } #endif /* ENABLE_BUNDLE_TX */ +#else +static void htc_issue_packets_bundle(HTC_TARGET *target, + HTC_ENDPOINT *pEndpoint, + HTC_PACKET_QUEUE *pPktQueue) +{ +} #endif +/** + * htc_issue_packets() - HTC function to send packets from a queue + * @target: HTC target on which packets need to be sent + * @pEndpoint: logical endpoint on which packets needs to be sent + * @pPktQueue: HTC packet queue containing the list of packets to be sent + * + * Return: QDF_STATUS_SUCCESS on success and error QDF status on failure + */ static A_STATUS htc_issue_packets(HTC_TARGET *target, HTC_ENDPOINT *pEndpoint, HTC_PACKET_QUEUE *pPktQueue) @@ -504,21 +540,30 @@ static A_STATUS htc_issue_packets(HTC_TARGET *target, uint16_t payloadLen; HTC_FRAME_HDR *pHtcHdr; uint32_t data_attr = 0; + enum qdf_bus_type bus_type; + + bus_type = hif_get_bus_type(target->hif_dev); AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("+htc_issue_packets: Queue: %p, Pkts %d \n", pPktQueue, HTC_PACKET_QUEUE_DEPTH(pPktQueue))); while (true) { -#if defined(HIF_USB) || defined(HIF_SDIO) -#ifdef ENABLE_BUNDLE_TX - if (IS_TX_CREDIT_FLOW_ENABLED(pEndpoint) && - HTC_ENABLE_BUNDLE(target) && + if (HTC_TX_BUNDLE_ENABLED(target) && HTC_PACKET_QUEUE_DEPTH(pPktQueue) >= HTC_MIN_MSG_PER_BUNDLE) { - htc_issue_packets_bundle(target, pEndpoint, pPktQueue); + switch (bus_type) { + case QDF_BUS_TYPE_SDIO: + if (!IS_TX_CREDIT_FLOW_ENABLED(pEndpoint)) + break; + case QDF_BUS_TYPE_USB: + htc_issue_packets_bundle(target, + pEndpoint, + pPktQueue); + break; + default: + break; + } } -#endif -#endif /* if not bundling or there was a packet that could not be placed in a bundle, * and send it by normal way */ @@ -605,18 +650,8 @@ static A_STATUS htc_issue_packets(HTC_TARGET *target, pEndpoint->ul_outstanding_cnt--; HTC_PACKET_REMOVE(&pEndpoint->TxLookupQueue, pPacket); /* reclaim credits */ -#if defined(HIF_USB) - if (pEndpoint->Id >= ENDPOINT_2 - && pEndpoint->Id <= ENDPOINT_5) - target->avail_tx_credits += - pPacket->PktInfo.AsTx.CreditsUsed; - else pEndpoint->TxCredits += pPacket->PktInfo.AsTx.CreditsUsed; -#else - pEndpoint->TxCredits += - pPacket->PktInfo.AsTx.CreditsUsed; -#endif /* put it back into the callers queue */ HTC_PACKET_ENQUEUE_TO_HEAD(pPktQueue, pPacket); UNLOCK_HTC_TX(target); @@ -632,14 +667,6 @@ static A_STATUS htc_issue_packets(HTC_TARGET *target, hif_pm_runtime_put(target->hif_dev); } if (qdf_unlikely(A_FAILED(status))) { -#if defined(HIF_USB) - if (pEndpoint->Id >= ENDPOINT_2 && pEndpoint->Id <= ENDPOINT_5) - target->avail_tx_credits += - pPacket->PktInfo.AsTx.CreditsUsed; - else - pEndpoint->TxCredits += - pPacket->PktInfo.AsTx.CreditsUsed; -#endif AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("htc_issue_packets, failed pkt:0x%p status:%d", pPacket, status)); @@ -703,8 +730,17 @@ static void queue_htc_pm_packets(HTC_ENDPOINT *endpoint, {} #endif - -/* get HTC send packets from the TX queue on an endpoint, based on available credits */ +/** + * get_htc_send_packets_credit_based() - get packets based on available credits + * @target: HTC target on which packets need to be sent + * @pEndpoint: logical endpoint on which packets needs to be sent + * @pQueue: HTC packet queue containing the list of packets to be sent + * + * Get HTC send packets from TX queue on an endpoint based on available credits. + * The function moves the packets from TX queue of the endpoint to pQueue. + * + * Return: None + */ void get_htc_send_packets_credit_based(HTC_TARGET *target, HTC_ENDPOINT *pEndpoint, HTC_PACKET_QUEUE *pQueue) @@ -772,26 +808,11 @@ void get_htc_send_packets_credit_based(HTC_TARGET *target, creditsRequired, pEndpoint->TxCredits)); if (pEndpoint->Id == ENDPOINT_0) { - /* endpoint 0 is special, it always has a credit and does not require credit based - * flow control */ + /* + * endpoint 0 is special, it always has a credit and + * does not require credit based flow control + */ creditsRequired = 0; -#if defined(HIF_USB) - } else if (pEndpoint->Id >= ENDPOINT_2 - && pEndpoint->Id <= ENDPOINT_5) { - if (target->avail_tx_credits < creditsRequired) - break; - - target->avail_tx_credits -= creditsRequired; - - if (target->avail_tx_credits < 9) { - /* tell the target we need credits ASAP! */ - sendFlags |= HTC_FLAGS_NEED_CREDIT_UPDATE; - INC_HTC_EP_STAT(pEndpoint, - TxCreditLowIndications, 1); - AR_DEBUG_PRINTF(ATH_DEBUG_SEND, - (" Host Needs Credits \n")); - } -#endif } else { if (pEndpoint->TxCredits < creditsRequired) { @@ -937,6 +958,15 @@ void get_htc_send_packets(HTC_TARGET *target, } +/** + * htc_try_send() - Send packets in a queue on an endpoint + * @target: HTC target on which packets need to be sent + * @pEndpoint: logical endpoint on which packets needs to be sent + * @pCallersSendQueue: packet queue containing the list of packets to be sent + * + * Return: HTC_SEND_QUEUE_RESULT indicates whether the packet was queued to be + * sent or the packet should be dropped by the upper layer + */ static HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target, HTC_ENDPOINT *pEndpoint, HTC_PACKET_QUEUE *pCallersSendQueue) @@ -1066,7 +1096,8 @@ static HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target, } while (false); if (result != HTC_SEND_QUEUE_OK) { - AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("-htc_try_send: \n")); + AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("-htc_try_send: %d\n", + result)); return result; } @@ -1129,6 +1160,17 @@ static HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target, } #endif } else { + + /* + * Header and payload belongs to the different fragments and + * consume 2 resource for one HTC package but USB combine into + * one transfer. + */ + if (HTC_TX_BUNDLE_ENABLED(target) && tx_resources && + hif_get_bus_type(target->hif_dev) == + QDF_BUS_TYPE_USB) + tx_resources = (HTC_MAX_MSG_PER_BUNDLE_TX * 2); + /* get all the packets for this endpoint that we can for this pass */ get_htc_send_packets(target, pEndpoint, &sendQueue, tx_resources); @@ -1394,7 +1436,14 @@ A_STATUS htc_send_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket) } #ifdef ATH_11AC_TXCOMPACT - +/** + * htc_send_data_pkt() - send single data packet on an endpoint + * @HTCHandle: pointer to HTC handle + * @netbuf: network buffer containing the data to be sent + * @ActualLength: length of data that needs to be transmitted + * + * Return: A_OK for success or an appropriate A_STATUS error + */ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, qdf_nbuf_t netbuf, int Epid, int ActualLength) { @@ -1468,6 +1517,14 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, qdf_nbuf_t netbuf, int Epid, } #else /*ATH_11AC_TXCOMPACT */ +/** + * htc_send_data_pkt() - htc_send_data_pkt + * @HTCHandle: pointer to HTC handle + * @pPacket: pointer to HTC_PACKET + * @more_data: indicates whether more data is to follow + * + * Return: A_OK for success or an appropriate A_STATUS error + */ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket, uint8_t more_data) { @@ -1526,12 +1583,10 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket, /* append new packet to pEndpoint->TxQueue */ HTC_PACKET_ENQUEUE(&pEndpoint->TxQueue, pPacket); -#ifdef ENABLE_BUNDLE_TX - if (HTC_ENABLE_BUNDLE(target) && (more_data)) { + if (HTC_TX_BUNDLE_ENABLED(target) && (more_data)) { UNLOCK_HTC_TX(target); return A_OK; } -#endif } else { LOCK_HTC_TX(target); pEndpoint = &target->endpoint[1]; @@ -1571,14 +1626,27 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket, #endif UNLOCK_HTC_TX(target); } -#ifdef ENABLE_BUNDLE_TX - else if (HTC_ENABLE_BUNDLE(target)) { + + else if (HTC_TX_BUNDLE_ENABLED(target)) { + + if ((hif_get_bus_type(target->hif_dev) == QDF_BUS_TYPE_USB) && + hif_get_free_queue_number(target->hif_dev, + pEndpoint->UL_PipeID)) { + /* + * Header and payload belongs to the different fragments + * and consume 2 resource for one HTC package but USB + * combine into one transfer. + */ + get_htc_send_packets(target, pEndpoint, &sendQueue, + (HTC_MAX_MSG_PER_BUNDLE_TX * 2)); + } else { /* Dequeue max packets from endpoint tx queue */ get_htc_send_packets(target, pEndpoint, &sendQueue, HTC_MAX_TX_BUNDLE_SEND_LIMIT); + } + UNLOCK_HTC_TX(target); } -#endif else { /* * Now drain the endpoint TX queue for transmission as long as we have @@ -1597,15 +1665,13 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket, /* send what we can */ while (true) { -#if defined(HIF_USB) || defined(HIF_SDIO) -#ifdef ENABLE_BUNDLE_TX - if (HTC_ENABLE_BUNDLE(target) && - HTC_PACKET_QUEUE_DEPTH(&sendQueue) >= - HTC_MIN_MSG_PER_BUNDLE) { + if (HTC_TX_BUNDLE_ENABLED(target) && + (HTC_PACKET_QUEUE_DEPTH(&sendQueue) >= + HTC_MIN_MSG_PER_BUNDLE) && + (hif_get_bus_type(target->hif_dev) == QDF_BUS_TYPE_SDIO || + hif_get_bus_type(target->hif_dev) == QDF_BUS_TYPE_USB)) { htc_issue_packets_bundle(target, pEndpoint, &sendQueue); } -#endif -#endif pPacket = htc_packet_dequeue(&sendQueue); if (pPacket == NULL) { break; @@ -1746,6 +1812,15 @@ static HTC_PACKET *htc_lookup_tx_packet(HTC_TARGET *target, return pFoundPacket; } +/** + * htc_tx_completion_handler() - htc tx completion handler + * @Context: pointer to HTC_TARGET structure + * @netbuf: pointer to netbuf for which completion handler is being called + * @EpID: end point Id on which the packet was sent + * @toeplitz_hash_result: toeplitz hash result + * + * Return: QDF_STATUS_SUCCESS for success or an appropriate QDF_STATUS error + */ QDF_STATUS htc_tx_completion_handler(void *Context, qdf_nbuf_t netbuf, unsigned int EpID, uint32_t toeplitz_hash_result) @@ -1788,6 +1863,12 @@ QDF_STATUS htc_tx_completion_handler(void *Context, } HTC_PACKET_QUEUE_ITERATE_END; free_htc_bundle_packet(target, pPacket); + + if (hif_get_bus_type(target->hif_dev) == QDF_BUS_TYPE_USB) { + if (!IS_TX_CREDIT_FLOW_ENABLED(pEndpoint)) + htc_try_send(target, pEndpoint, NULL); + } + return QDF_STATUS_SUCCESS; } /* will be giving this buffer back to upper layers */ @@ -1934,7 +2015,15 @@ bool htc_is_endpoint_active(HTC_HANDLE HTCHandle, HTC_ENDPOINT_ID Endpoint) return true; } -/* process credit reports and call distribution function */ +/** + * htc_process_credit_rpt() - process credit report, call distribution function + * @target: pointer to HTC_TARGET + * @pRpt: pointer to HTC_CREDIT_REPORT + * @NumEntries: number of entries in credit report + * @FromEndpoint: endpoint for which credit report is received + * + * Return: A_OK for success or an appropriate A_STATUS error + */ void htc_process_credit_rpt(HTC_TARGET *target, HTC_CREDIT_REPORT *pRpt, int NumEntries, HTC_ENDPOINT_ID FromEndpoint) { @@ -1996,35 +2085,7 @@ void htc_process_credit_rpt(HTC_TARGET *target, HTC_CREDIT_REPORT *pRpt, } #endif -#if defined(HIF_USB) - if (pEndpoint->Id >= ENDPOINT_2 && pEndpoint->Id <= ENDPOINT_5) { - HTC_ENDPOINT_ID eid[DATA_EP_SIZE] = { ENDPOINT_5, - ENDPOINT_4, ENDPOINT_2, ENDPOINT_3 }; - int epid_idx; - target->avail_tx_credits += rpt_credits; - - for (epid_idx = 0; epid_idx < DATA_EP_SIZE; epid_idx++) { - pEndpoint = &target->endpoint[eid[epid_idx]]; - if (HTC_PACKET_QUEUE_DEPTH(&pEndpoint->TxQueue)) { - break; - } - - } - UNLOCK_HTC_TX(target); - htc_try_send(target, pEndpoint, NULL); - LOCK_HTC_TX(target); - } else { - pEndpoint->TxCredits += rpt_credits; - - if (pEndpoint->TxCredits - && HTC_PACKET_QUEUE_DEPTH(&pEndpoint->TxQueue)) { - UNLOCK_HTC_TX(target); - htc_try_send(target, pEndpoint, NULL); - LOCK_HTC_TX(target); - } - } -#else pEndpoint->TxCredits += rpt_credits; if (pEndpoint->service_id == WMI_CONTROL_SVC) { @@ -2050,7 +2111,6 @@ void htc_process_credit_rpt(HTC_TARGET *target, HTC_CREDIT_REPORT *pRpt, #endif LOCK_HTC_TX(target); } -#endif totalCredits += rpt_credits; } diff --git a/pld_stub/inc/pld_common.h b/pld_stub/inc/pld_common.h index f7ac8ad6e6d2..7689c9d6d4ae 100644 --- a/pld_stub/inc/pld_common.h +++ b/pld_stub/inc/pld_common.h @@ -106,18 +106,30 @@ enum pld_driver_mode { PLD_OFF }; +#define PLD_MAX_TIMESTAMP_LEN 32 + /** * struct pld_soc_info - SOC information * @v_addr: virtual address of preallocated memory * @p_addr: physical address of preallcoated memory - * @version: version number + * @chip_id: chip ID + * @chip_family: chip family + * @board_id: board ID + * @soc_id: SOC ID + * @fw_version: FW version + * @fw_build_timestamp: FW build timestamp * * pld_soc_info is used to store WLAN SOC information. */ struct pld_soc_info { void __iomem *v_addr; phys_addr_t p_addr; - u32 version; + u32 chip_id; + u32 chip_family; + u32 board_id; + u32 soc_id; + u32 fw_version; + char fw_build_timestamp[PLD_MAX_TIMESTAMP_LEN + 1]; }; /** diff --git a/qdf/inc/qdf_nbuf.h b/qdf/inc/qdf_nbuf.h index a99607d30c5f..ab752c499aa8 100644 --- a/qdf/inc/qdf_nbuf.h +++ b/qdf/inc/qdf_nbuf.h @@ -55,13 +55,29 @@ #define QDF_NBUF_TRAC_DHCP_CLI_PORT 68 #define QDF_NBUF_TRAC_ETH_TYPE_OFFSET 12 #define QDF_NBUF_TRAC_EAPOL_ETH_TYPE 0x888E +#define QDF_NBUF_TRAC_WAPI_ETH_TYPE 0x88b4 #define QDF_NBUF_TRAC_ARP_ETH_TYPE 0x0806 +#define QDF_NBUF_TRAC_IPV4_ETH_TYPE 0x0800 +#define QDF_NBUF_TRAC_IPV6_ETH_TYPE 0x86dd #define QDF_NBUF_DEST_MAC_OFFSET 0 #define QDF_NBUF_SRC_MAC_OFFSET 6 +#define QDF_NBUF_TRAC_IPV4_PROTO_TYPE_OFFSET 23 +#define QDF_NBUF_TRAC_IPV4_DEST_ADDR_OFFSET 30 +#define QDF_NBUF_TRAC_IPV6_PROTO_TYPE_OFFSET 20 +#define QDF_NBUF_TRAC_IPV4_ADDR_MCAST_MASK 0xE0000000 +#define QDF_NBUF_TRAC_IPV4_ADDR_BCAST_MASK 0xF0000000 +#define QDF_NBUF_TRAC_IPV6_DEST_ADDR_OFFSET 38 +#define QDF_NBUF_TRAC_IPV6_DEST_ADDR 0xFF00 +#define QDF_NBUF_TRAC_ICMP_TYPE 1 +#define QDF_NBUF_TRAC_TCP_TYPE 6 +#define QDF_NBUF_TRAC_UDP_TYPE 17 +#define QDF_NBUF_TRAC_ICMPV6_TYPE 0x3a /* EAPOL Related MASK */ #define EAPOL_PACKET_TYPE_OFFSET 15 #define EAPOL_KEY_INFO_OFFSET 19 +#define EAPOL_PKT_LEN_OFFSET 16 +#define EAPOL_KEY_LEN_OFFSET 21 #define EAPOL_MASK 0x8013 #define EAPOL_M1_BIT_MASK 0x8000 #define EAPOL_M2_BIT_MASK 0x0001 @@ -134,6 +150,8 @@ struct mon_rx_status { #define QDF_DHCP_OPTION53_OFFSET (0x11A) #define QDF_DHCP_OPTION53_LENGTH_OFFSET (0x11B) #define QDF_DHCP_OPTION53_STATUS_OFFSET (0x11C) +#define DHCP_PKT_LEN_OFFSET 16 +#define DHCP_TRANSACTION_ID_OFFSET 46 #define QDF_DHCP_DISCOVER (1) #define QDF_DHCP_OFFER (2) #define QDF_DHCP_REQUEST (3) @@ -143,12 +161,112 @@ struct mon_rx_status { #define QDF_DHCP_RELEASE (7) #define QDF_DHCP_INFORM (8) +/* ARP Related Mask */ #define ARP_SUB_TYPE_OFFSET 20 #define ARP_REQUEST (1) #define ARP_RESPONSE (2) +/* IPV4 Related Mask */ +#define IPV4_PKT_LEN_OFFSET 16 +#define IPV4_TCP_SEQ_NUM_OFFSET 38 +#define IPV4_SRC_PORT_OFFSET 34 +#define IPV4_DST_PORT_OFFSET 36 + +/* IPV4 ICMP Related Mask */ +#define ICMP_SEQ_NUM_OFFSET 40 +#define ICMP_SUBTYPE_OFFSET 34 +#define ICMP_REQUEST 0x08 +#define ICMP_RESPONSE 0x00 + +/* IPV6 Related Mask */ +#define IPV6_PKT_LEN_OFFSET 18 +#define IPV6_TCP_SEQ_NUM_OFFSET 58 +#define IPV6_SRC_PORT_OFFSET 54 +#define IPV6_DST_PORT_OFFSET 56 + +/* IPV6 ICMPV6 Related Mask */ +#define ICMPV6_SEQ_NUM_OFFSET 60 +#define ICMPV6_SUBTYPE_OFFSET 54 +#define ICMPV6_REQUEST 0x80 +#define ICMPV6_RESPONSE 0x81 + #define QDF_NBUF_IPA_CHECK_MASK 0x80000000 +/** + * qdf_proto_type - protocol type + * @QDF_PROTO_TYPE_DHCP - DHCP + * @QDF_PROTO_TYPE_EAPOL - EAPOL + * @QDF_PROTO_TYPE_ARP - ARP + * @QDF_PROTO_TYPE_MGMT - MGMT + */ +enum qdf_proto_type { + QDF_PROTO_TYPE_DHCP, + QDF_PROTO_TYPE_EAPOL, + QDF_PROTO_TYPE_ARP, + QDF_PROTO_TYPE_MGMT, + QDF_PROTO_TYPE_MAX +}; + +/** + * qdf_proto_subtype - subtype of packet + * @QDF_PROTO_EAPOL_M1 - EAPOL 1/4 + * @QDF_PROTO_EAPOL_M2 - EAPOL 2/4 + * @QDF_PROTO_EAPOL_M3 - EAPOL 3/4 + * @QDF_PROTO_EAPOL_M4 - EAPOL 4/4 + * @QDF_PROTO_DHCP_DISCOVER - discover + * @QDF_PROTO_DHCP_REQUEST - request + * @QDF_PROTO_DHCP_OFFER - offer + * @QDF_PROTO_DHCP_ACK - ACK + * @QDF_PROTO_DHCP_NACK - NACK + * @QDF_PROTO_DHCP_RELEASE - release + * @QDF_PROTO_DHCP_INFORM - inform + * @QDF_PROTO_DHCP_DECLINE - decline + * @QDF_PROTO_ARP_REQ - arp request + * @QDF_PROTO_ARP_RES - arp response + * @QDF_PROTO_ICMP_REQ - icmp request + * @QDF_PROTO_ICMP_RES - icmp response + * @QDF_PROTO_ICMPV6_REQ - icmpv6 request + * @QDF_PROTO_ICMPV6_RES - icmpv6 response + * @QDF_PROTO_IPV4_UDP - ipv4 udp + * @QDF_PROTO_IPV4_TCP - ipv4 tcp + * @QDF_PROTO_IPV6_UDP - ipv6 udp + * @QDF_PROTO_IPV6_TCP - ipv6 tcp + * @QDF_PROTO_MGMT_ASSOC -assoc + * @QDF_PROTO_MGMT_DISASSOC - disassoc + * @QDF_PROTO_MGMT_AUTH - auth + * @QDF_PROTO_MGMT_DEAUTH - deauth + */ +enum qdf_proto_subtype { + QDF_PROTO_INVALID, + QDF_PROTO_EAPOL_M1, + QDF_PROTO_EAPOL_M2, + QDF_PROTO_EAPOL_M3, + QDF_PROTO_EAPOL_M4, + QDF_PROTO_DHCP_DISCOVER, + QDF_PROTO_DHCP_REQUEST, + QDF_PROTO_DHCP_OFFER, + QDF_PROTO_DHCP_ACK, + QDF_PROTO_DHCP_NACK, + QDF_PROTO_DHCP_RELEASE, + QDF_PROTO_DHCP_INFORM, + QDF_PROTO_DHCP_DECLINE, + QDF_PROTO_ARP_REQ, + QDF_PROTO_ARP_RES, + QDF_PROTO_ICMP_REQ, + QDF_PROTO_ICMP_RES, + QDF_PROTO_ICMPV6_REQ, + QDF_PROTO_ICMPV6_RES, + QDF_PROTO_IPV4_UDP, + QDF_PROTO_IPV4_TCP, + QDF_PROTO_IPV6_UDP, + QDF_PROTO_IPV6_TCP, + QDF_PROTO_MGMT_ASSOC, + QDF_PROTO_MGMT_DISASSOC, + QDF_PROTO_MGMT_AUTH, + QDF_PROTO_MGMT_DEAUTH, + QDF_PROTO_SUBTYPE_MAX +}; + /** * @qdf_nbuf_t - Platform indepedent packet abstraction */ @@ -1084,6 +1202,186 @@ static inline uint8_t qdf_nbuf_get_tx_parallel_dnload_frm(qdf_nbuf_t buf) return __qdf_nbuf_get_tx_htt2_frm(buf); } +/** + * qdf_nbuf_get_dhcp_subtype() - get the subtype + * of DHCP packet. + * @buf: Pointer to DHCP packet buffer + * + * This func. returns the subtype of DHCP packet. + * + * Return: subtype of the DHCP packet. + */ +static inline enum qdf_proto_subtype +qdf_nbuf_get_dhcp_subtype(qdf_nbuf_t buf) +{ + return __qdf_nbuf_data_get_dhcp_subtype(qdf_nbuf_data(buf)); +} + +/** + * qdf_nbuf_data_get_dhcp_subtype() - get the subtype + * of DHCP packet. + * @buf: Pointer to DHCP packet data buffer + * + * This func. returns the subtype of DHCP packet. + * + * Return: subtype of the DHCP packet. + */ +static inline enum qdf_proto_subtype +qdf_nbuf_data_get_dhcp_subtype(uint8_t *data) +{ + return __qdf_nbuf_data_get_dhcp_subtype(data); +} + +/** + * qdf_nbuf_get_eapol_subtype() - get the subtype + * of EAPOL packet. + * @buf: Pointer to EAPOL packet buffer + * + * This func. returns the subtype of EAPOL packet. + * + * Return: subtype of the EAPOL packet. + */ +static inline enum qdf_proto_subtype +qdf_nbuf_get_eapol_subtype(qdf_nbuf_t buf) +{ + return __qdf_nbuf_data_get_eapol_subtype(qdf_nbuf_data(buf)); +} + +/** + * qdf_nbuf_data_get_eapol_subtype() - get the subtype + * of EAPOL packet. + * @data: Pointer to EAPOL packet data buffer + * + * This func. returns the subtype of EAPOL packet. + * + * Return: subtype of the EAPOL packet. + */ +static inline enum qdf_proto_subtype +qdf_nbuf_data_get_eapol_subtype(uint8_t *data) +{ + return __qdf_nbuf_data_get_eapol_subtype(data); +} + +/** + * qdf_nbuf_get_arp_subtype() - get the subtype + * of ARP packet. + * @buf: Pointer to ARP packet buffer + * + * This func. returns the subtype of ARP packet. + * + * Return: subtype of the ARP packet. + */ +static inline enum qdf_proto_subtype +qdf_nbuf_get_arp_subtype(qdf_nbuf_t buf) +{ + return __qdf_nbuf_data_get_arp_subtype(qdf_nbuf_data(buf)); +} + +/** + * qdf_nbuf_data_get_arp_subtype() - get the subtype + * of ARP packet. + * @data: Pointer to ARP packet data buffer + * + * This func. returns the subtype of ARP packet. + * + * Return: subtype of the ARP packet. + */ +static inline enum qdf_proto_subtype +qdf_nbuf_data_get_arp_subtype(uint8_t *data) +{ + return __qdf_nbuf_data_get_arp_subtype(data); +} + +/** + * qdf_nbuf_get_icmp_subtype() - get the subtype + * of IPV4 ICMP packet. + * @buf: Pointer to IPV4 ICMP packet buffer + * + * This func. returns the subtype of ICMP packet. + * + * Return: subtype of the ICMP packet. + */ +static inline enum qdf_proto_subtype +qdf_nbuf_get_icmp_subtype(qdf_nbuf_t buf) +{ + return __qdf_nbuf_data_get_icmp_subtype(qdf_nbuf_data(buf)); +} + +/** + * qdf_nbuf_data_get_icmp_subtype() - get the subtype + * of IPV4 ICMP packet. + * @data: Pointer to IPV4 ICMP packet data buffer + * + * This func. returns the subtype of ICMP packet. + * + * Return: subtype of the ICMP packet. + */ +static inline enum qdf_proto_subtype +qdf_nbuf_data_get_icmp_subtype(uint8_t *data) +{ + return __qdf_nbuf_data_get_icmp_subtype(data); +} + +/** + * qdf_nbuf_get_icmpv6_subtype() - get the subtype + * of IPV6 ICMPV6 packet. + * @buf: Pointer to IPV6 ICMPV6 packet buffer + * + * This func. returns the subtype of ICMPV6 packet. + * + * Return: subtype of the ICMPV6 packet. + */ +static inline enum qdf_proto_subtype +qdf_nbuf_get_icmpv6_subtype(qdf_nbuf_t buf) +{ + return __qdf_nbuf_data_get_icmpv6_subtype(qdf_nbuf_data(buf)); +} + +/** + * qdf_nbuf_data_get_icmpv6_subtype() - get the subtype + * of IPV6 ICMPV6 packet. + * @data: Pointer to IPV6 ICMPV6 packet data buffer + * + * This func. returns the subtype of ICMPV6 packet. + * + * Return: subtype of the ICMPV6 packet. + */ +static inline enum qdf_proto_subtype +qdf_nbuf_data_get_icmpv6_subtype(uint8_t *data) +{ + return __qdf_nbuf_data_get_icmpv6_subtype(data); +} + +/** + * qdf_nbuf_data_get_ipv4_proto() - get the proto type + * of IPV4 packet. + * @data: Pointer to IPV4 packet data buffer + * + * This func. returns the proto type of IPV4 packet. + * + * Return: proto type of IPV4 packet. + */ +static inline uint8_t +qdf_nbuf_data_get_ipv4_proto(uint8_t *data) +{ + return __qdf_nbuf_data_get_ipv4_proto(data); +} + +/** + * qdf_nbuf_data_get_ipv6_proto() - get the proto type + * of IPV6 packet. + * @data: Pointer to IPV6 packet data buffer + * + * This func. returns the proto type of IPV6 packet. + * + * Return: proto type of IPV6 packet. + */ +static inline uint8_t +qdf_nbuf_data_get_ipv6_proto(uint8_t *data) +{ + return __qdf_nbuf_data_get_ipv6_proto(data); +} + /** * qdf_nbuf_is_ipv4_pkt() - check if packet is a ipv4 packet or not * @buf: buffer @@ -1095,7 +1393,21 @@ static inline uint8_t qdf_nbuf_get_tx_parallel_dnload_frm(qdf_nbuf_t buf) static inline bool qdf_nbuf_is_ipv4_pkt(qdf_nbuf_t buf) { - return __qdf_nbuf_is_ipv4_pkt(buf); + return __qdf_nbuf_data_is_ipv4_pkt(qdf_nbuf_data(buf)); +} + +/** + * qdf_nbuf_data_is_ipv4_pkt() - check if packet is a ipv4 packet or not + * @data: data + * + * This api is for Tx packets. + * + * Return: true if packet is ipv4 packet + */ +static inline +bool qdf_nbuf_data_is_ipv4_pkt(uint8_t *data) +{ + return __qdf_nbuf_data_is_ipv4_pkt(data); } /** @@ -1109,7 +1421,22 @@ bool qdf_nbuf_is_ipv4_pkt(qdf_nbuf_t buf) static inline bool qdf_nbuf_is_ipv4_dhcp_pkt(qdf_nbuf_t buf) { - return __qdf_nbuf_is_ipv4_dhcp_pkt(buf); + return __qdf_nbuf_data_is_ipv4_dhcp_pkt(qdf_nbuf_data(buf)); +} + +/** + * qdf_nbuf_data_is_ipv4_dhcp_pkt() - check if it is DHCP packet. + * @data: Pointer to DHCP packet data buffer + * + * This func. checks whether it is a DHCP packet or not. + * + * Return: true if it is a DHCP packet + * false if not + */ +static inline +bool qdf_nbuf_data_is_ipv4_dhcp_pkt(uint8_t *data) +{ + return __qdf_nbuf_data_is_ipv4_dhcp_pkt(data); } /** @@ -1123,7 +1450,36 @@ bool qdf_nbuf_is_ipv4_dhcp_pkt(qdf_nbuf_t buf) static inline bool qdf_nbuf_is_ipv4_eapol_pkt(qdf_nbuf_t buf) { - return __qdf_nbuf_is_ipv4_eapol_pkt(buf); + return __qdf_nbuf_data_is_ipv4_eapol_pkt(qdf_nbuf_data(buf)); +} + +/** + * qdf_nbuf_data_is_ipv4_eapol_pkt() - check if it is EAPOL packet. + * @data: Pointer to EAPOL packet data buffer + * + * This func. checks whether it is a EAPOL packet or not. + * + * Return: true if it is a EAPOL packet + * false if not + */ +static inline +bool qdf_nbuf_data_is_ipv4_eapol_pkt(uint8_t *data) +{ + return __qdf_nbuf_data_is_ipv4_eapol_pkt(data); +} + +/** + * qdf_nbuf_is_ipv4_wapi_pkt() - check if packet is a wapi packet or not + * @buf: buffer + * + * This api is for ipv4 packet. + * + * Return: true if packet is WAPI packet + */ +static inline +bool qdf_nbuf_is_ipv4_wapi_pkt(qdf_nbuf_t buf) +{ + return __qdf_nbuf_is_ipv4_wapi_pkt(buf); } /** @@ -1137,33 +1493,278 @@ bool qdf_nbuf_is_ipv4_eapol_pkt(qdf_nbuf_t buf) static inline bool qdf_nbuf_is_ipv4_arp_pkt(qdf_nbuf_t buf) { - return __qdf_nbuf_is_ipv4_arp_pkt(buf); + return __qdf_nbuf_data_is_ipv4_arp_pkt(qdf_nbuf_data(buf)); } /** - * qdf_invalidate_range() - invalidate the virtual address range specified by - * start and end addresses. - * Note: This does not write back the cache entries. + * qdf_nbuf_data_is_ipv4_arp_pkt() - check if it is ARP packet. + * @data: Pointer to ARP packet data buffer + * + * This func. checks whether it is a ARP packet or not. + * + * Return: TRUE if it is a ARP packet + * FALSE if not + */ +static inline +bool qdf_nbuf_data_is_ipv4_arp_pkt(uint8_t *data) +{ + return __qdf_nbuf_data_is_ipv4_arp_pkt(data); +} + +/** + * qdf_nbuf_is_ipv6_pkt() - check if it is IPV6 packet. + * @buf: Pointer to IPV6 packet buffer + * + * This func. checks whether it is a IPV6 packet or not. + * + * Return: TRUE if it is a IPV6 packet + * FALSE if not + */ +static inline +bool qdf_nbuf_is_ipv6_pkt(qdf_nbuf_t buf) +{ + return __qdf_nbuf_data_is_ipv6_pkt(qdf_nbuf_data(buf)); +} + +/** + * qdf_nbuf_data_is_ipv6_pkt() - check if it is IPV6 packet. + * @data: Pointer to IPV6 packet data buffer + * + * This func. checks whether it is a IPV6 packet or not. + * + * Return: TRUE if it is a IPV6 packet + * FALSE if not + */ +static inline +bool qdf_nbuf_data_is_ipv6_pkt(uint8_t *data) +{ + return __qdf_nbuf_data_is_ipv6_pkt(data); +} + +/** + * qdf_nbuf_data_is_ipv4_mcast_pkt() - check if it is IPV4 multicast packet. + * @data: Pointer to IPV4 packet data buffer + * + * This func. checks whether it is a IPV4 multicast packet or not. + * + * Return: TRUE if it is a IPV4 multicast packet + * FALSE if not + */ +static inline +bool qdf_nbuf_data_is_ipv4_mcast_pkt(uint8_t *data) +{ + return __qdf_nbuf_data_is_ipv4_mcast_pkt(data); +} + +/** + * qdf_nbuf_data_is_ipv6_mcast_pkt() - check if it is IPV6 multicast packet. + * @data: Pointer to IPV6 packet data buffer + * + * This func. checks whether it is a IPV6 multicast packet or not. + * + * Return: TRUE if it is a IPV6 multicast packet + * FALSE if not + */ +static inline +bool qdf_nbuf_data_is_ipv6_mcast_pkt(uint8_t *data) +{ + return __qdf_nbuf_data_is_ipv6_mcast_pkt(data); +} + +/** + * qdf_nbuf_is_icmp_pkt() - check if it is IPV4 ICMP packet. + * @buf: Pointer to IPV4 ICMP packet buffer + * + * This func. checks whether it is a ICMP packet or not. + * + * Return: TRUE if it is a ICMP packet + * FALSE if not + */ +static inline +bool qdf_nbuf_is_icmp_pkt(qdf_nbuf_t buf) +{ + return __qdf_nbuf_data_is_icmp_pkt(qdf_nbuf_data(buf)); +} + +/** + * qdf_nbuf_data_is_icmp_pkt() - check if it is IPV4 ICMP packet. + * @data: Pointer to IPV4 ICMP packet data buffer + * + * This func. checks whether it is a ICMP packet or not. + * + * Return: TRUE if it is a ICMP packet + * FALSE if not + */ +static inline +bool qdf_nbuf_data_is_icmp_pkt(uint8_t *data) +{ + return __qdf_nbuf_data_is_icmp_pkt(data); +} + +/** + * qdf_nbuf_is_icmpv6_pkt() - check if it is IPV6 ICMPV6 packet. + * @buf: Pointer to IPV6 ICMPV6 packet buffer + * + * This func. checks whether it is a ICMPV6 packet or not. + * + * Return: TRUE if it is a ICMPV6 packet + * FALSE if not + */ +static inline +bool qdf_nbuf_is_icmpv6_pkt(qdf_nbuf_t buf) +{ + return __qdf_nbuf_data_is_icmpv6_pkt(qdf_nbuf_data(buf)); +} + +/** + * qdf_nbuf_data_is_icmpv6_pkt() - check if it is IPV6 ICMPV6 packet. + * @data: Pointer to IPV6 ICMPV6 packet data buffer + * + * This func. checks whether it is a ICMPV6 packet or not. + * + * Return: TRUE if it is a ICMPV6 packet + * FALSE if not + */ +static inline +bool qdf_nbuf_data_is_icmpv6_pkt(uint8_t *data) +{ + return __qdf_nbuf_data_is_icmpv6_pkt(data); +} + +/** + * qdf_nbuf_is_ipv4_udp_pkt() - check if it is IPV4 UDP packet. + * @buf: Pointer to IPV4 UDP packet buffer + * + * This func. checks whether it is a IPV4 UDP packet or not. + * + * Return: TRUE if it is a IPV4 UDP packet + * FALSE if not + */ +static inline +bool qdf_nbuf_is_ipv4_udp_pkt(qdf_nbuf_t buf) +{ + return __qdf_nbuf_data_is_ipv4_udp_pkt(qdf_nbuf_data(buf)); +} + +/** + * qdf_nbuf_data_is_ipv4_udp_pkt() - check if it is IPV4 UDP packet. + * @data: Pointer to IPV4 UDP packet data buffer + * + * This func. checks whether it is a IPV4 UDP packet or not. + * + * Return: TRUE if it is a IPV4 UDP packet + * FALSE if not + */ +static inline +bool qdf_nbuf_data_is_ipv4_udp_pkt(uint8_t *data) +{ + return __qdf_nbuf_data_is_ipv4_udp_pkt(data); +} + +/** + * qdf_nbuf_is_ipv4_tcp_pkt() - check if it is IPV4 TCP packet. + * @buf: Pointer to IPV4 TCP packet buffer + * + * This func. checks whether it is a IPV4 TCP packet or not. + * + * Return: TRUE if it is a IPV4 TCP packet + * FALSE if not + */ +static inline +bool qdf_nbuf_is_ipv4_tcp_pkt(qdf_nbuf_t buf) +{ + return __qdf_nbuf_data_is_ipv4_tcp_pkt(qdf_nbuf_data(buf)); +} + +/** + * qdf_nbuf_data_is_ipv4_tcp_pkt() - check if it is IPV4 TCP packet. + * @data: Pointer to IPV4 TCP packet data buffer + * + * This func. checks whether it is a IPV4 TCP packet or not. + * + * Return: TRUE if it is a IPV4 TCP packet + * FALSE if not + */ +static inline +bool qdf_nbuf_data_is_ipv4_tcp_pkt(uint8_t *data) +{ + return __qdf_nbuf_data_is_ipv4_tcp_pkt(data); +} + +/** + * qdf_nbuf_is_ipv6_udp_pkt() - check if it is IPV6 UDP packet. + * @buf: Pointer to IPV6 UDP packet buffer + * + * This func. checks whether it is a IPV6 UDP packet or not. + * + * Return: TRUE if it is a IPV6 UDP packet + * FALSE if not + */ +static inline +bool qdf_nbuf_is_ipv6_udp_pkt(qdf_nbuf_t buf) +{ + return __qdf_nbuf_data_is_ipv6_udp_pkt(qdf_nbuf_data(buf)); +} + +/** + * qdf_nbuf_data_is_ipv6_udp_pkt() - check if it is IPV6 UDP packet. + * @data: Pointer to IPV6 UDP packet data buffer + * + * This func. checks whether it is a IPV6 UDP packet or not. + * + * Return: TRUE if it is a IPV6 UDP packet + * FALSE if not + */ +static inline +bool qdf_nbuf_data_is_ipv6_udp_pkt(uint8_t *data) +{ + return __qdf_nbuf_data_is_ipv6_udp_pkt(data); +} + +/** + * qdf_nbuf_is_ipv6_tcp_pkt() - check if it is IPV6 TCP packet. + * @buf: Pointer to IPV6 TCP packet buffer + * + * This func. checks whether it is a IPV6 TCP packet or not. + * + * Return: TRUE if it is a IPV6 TCP packet + * FALSE if not + */ +static inline +bool qdf_nbuf_is_ipv6_tcp_pkt(qdf_nbuf_t buf) +{ + return __qdf_nbuf_data_is_ipv6_tcp_pkt(qdf_nbuf_data(buf)); +} + +/** + * qdf_nbuf_data_is_ipv6_tcp_pkt() - check if it is IPV6 TCP packet. + * @data: Pointer to IPV6 TCP packet data buffer + * + * This func. checks whether it is a IPV6 TCP packet or not. + * + * Return: TRUE if it is a IPV6 TCP packet + * FALSE if not + */ +static inline +bool qdf_nbuf_data_is_ipv6_tcp_pkt(uint8_t *data) +{ + return __qdf_nbuf_data_is_ipv6_tcp_pkt(data); +} + +/** + * qdf_invalidate_range() - invalidate virtual address range + * @start: start address of the address range + * @end: end address of the address range + * + * Note that this function does not write back the cache entries. * * Return: none */ -#ifdef MSM_PLATFORM static inline void qdf_invalidate_range(void *start, void *end) { - dmac_inv_range(start, end); + __qdf_invalidate_range(start, end); } -#else -static inline void qdf_invalidate_range(void *start, void *end) -{ - /* TODO figure out how to invalidate cache on x86 and other - non-MSM platform */ - QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_FATAL, - "Cache invalidate not yet implemneted for non-MSM platform"); - return; -} -#endif - /** * qdf_nbuf_reset_num_frags() - decrement the number of fragments * @buf: Network buffer diff --git a/qdf/inc/qdf_status.h b/qdf/inc/qdf_status.h index 2344c89afff7..0a58c4eb4843 100644 --- a/qdf/inc/qdf_status.h +++ b/qdf/inc/qdf_status.h @@ -78,6 +78,7 @@ * @QDF_STATUS_FT_PREAUTH_KEY_FAILED: ft preauth key failed * @QDF_STATUS_CMD_NOT_QUEUED: command not queued * @QDF_STATUS_FW_MSG_TIMEDOUT: target message timeout + * @QDF_STATUS_E_USB_ERROR: USB transaction error * @QDF_STATUS_MAX: not a realy value just a place holder for max */ typedef enum { @@ -123,6 +124,7 @@ typedef enum { QDF_STATUS_FT_PREAUTH_KEY_FAILED, QDF_STATUS_CMD_NOT_QUEUED, QDF_STATUS_FW_MSG_TIMEDOUT, + QDF_STATUS_E_USB_ERROR, QDF_STATUS_MAX } QDF_STATUS; diff --git a/qdf/inc/qdf_trace.h b/qdf/inc/qdf_trace.h index 992a1e1c55d6..b80cfa9b4d8f 100644 --- a/qdf/inc/qdf_trace.h +++ b/qdf/inc/qdf_trace.h @@ -233,65 +233,6 @@ enum QDF_DP_TRACE_ID { QDF_DP_TRACE_MAX }; -/** - * qdf_proto_type - protocol type - * @QDF_PROTO_TYPE_DHCP - DHCP - * @QDF_PROTO_TYPE_EAPOL - EAPOL - * @QDF_PROTO_TYPE_ARP - ARP - * @QDF_PROTO_TYPE_MGMT - MGMT - */ -enum qdf_proto_type { - QDF_PROTO_TYPE_DHCP, - QDF_PROTO_TYPE_EAPOL, - QDF_PROTO_TYPE_ARP, - QDF_PROTO_TYPE_MGMT, - QDF_PROTO_TYPE_MAX -}; - -/** - * qdf_proto_subtype - subtype of packet - * @QDF_PROTO_EAPOL_M1 - EAPOL 1/4 - * @QDF_PROTO_EAPOL_M2 - EAPOL 2/4 - * @QDF_PROTO_EAPOL_M3 - EAPOL 3/4 - * @QDF_PROTO_EAPOL_M4 - EAPOL 4/4 - * @QDF_PROTO_DHCP_DISCOVER - discover - * @QDF_PROTO_DHCP_REQUEST - request - * @QDF_PROTO_DHCP_OFFER - offer - * @QDF_PROTO_DHCP_ACK - ACK - * @QDF_PROTO_DHCP_NACK - NACK - * @QDF_PROTO_DHCP_RELEASE - release - * @QDF_PROTO_DHCP_INFORM - inform - * @QDF_PROTO_DHCP_DECLINE - decline - * @QDF_PROTO_ARP_REQ - arp request - * @QDF_PROTO_ARP_RES - arp response - * @QDF_PROTO_MGMT_ASSOC -assoc - * @QDF_PROTO_MGMT_DISASSOC - disassoc - * @QDF_PROTO_MGMT_AUTH - auth - * @QDF_PROTO_MGMT_DEAUTH - deauth - */ -enum qdf_proto_subtype { - QDF_PROTO_INVALID, - QDF_PROTO_EAPOL_M1, - QDF_PROTO_EAPOL_M2, - QDF_PROTO_EAPOL_M3, - QDF_PROTO_EAPOL_M4, - QDF_PROTO_DHCP_DISCOVER, - QDF_PROTO_DHCP_REQUEST, - QDF_PROTO_DHCP_OFFER, - QDF_PROTO_DHCP_ACK, - QDF_PROTO_DHCP_NACK, - QDF_PROTO_DHCP_RELEASE, - QDF_PROTO_DHCP_INFORM, - QDF_PROTO_DHCP_DECLINE, - QDF_PROTO_ARP_REQ, - QDF_PROTO_ARP_RES, - QDF_PROTO_MGMT_ASSOC, - QDF_PROTO_MGMT_DISASSOC, - QDF_PROTO_MGMT_AUTH, - QDF_PROTO_MGMT_DEAUTH, - QDF_PROTO_SUBTYPE_MAX -}; - /** * qdf_proto_dir - direction * @QDF_TX: TX direction diff --git a/qdf/inc/qdf_util.h b/qdf/inc/qdf_util.h index 588e55544fe9..44d0450264a4 100644 --- a/qdf/inc/qdf_util.h +++ b/qdf/inc/qdf_util.h @@ -421,4 +421,17 @@ int qdf_get_cpu(void) return __qdf_get_cpu(); } +/** + * qdf_device_init_wakeup() - allow a device to wake up the aps system + * @qdf_dev: the qdf device context + * @enable: enable/disable the device as a wakup source + * + * Return: 0 or errno + */ +static inline int qdf_device_init_wakeup(qdf_device_t qdf_dev, bool enable) +{ + return __qdf_device_init_wakeup(qdf_dev, enable); +} + + #endif /*_QDF_UTIL_H*/ diff --git a/qdf/linux/src/i_qdf_list.h b/qdf/linux/src/i_qdf_list.h index eacdc61ab5d2..23cef762313f 100644 --- a/qdf/linux/src/i_qdf_list.h +++ b/qdf/linux/src/i_qdf_list.h @@ -59,4 +59,5 @@ static inline void __qdf_list_create(__qdf_list_t *list, uint32_t max_size) list->max_size = max_size; } +bool qdf_list_has_node(__qdf_list_t *list, __qdf_list_node_t *node); #endif diff --git a/qdf/linux/src/i_qdf_nbuf.h b/qdf/linux/src/i_qdf_nbuf.h index 6fafff7a1b75..f1eaeef2483d 100644 --- a/qdf/linux/src/i_qdf_nbuf.h +++ b/qdf/linux/src/i_qdf_nbuf.h @@ -45,6 +45,7 @@ #include #include #include +#include /* * Use socket buffer as the underlying implentation as skbuf . @@ -60,6 +61,10 @@ typedef struct sk_buff *__qdf_nbuf_t; * The driver will always add one tx fragment (the tx descriptor) */ #define QDF_NBUF_CB_TX_MAX_EXTRA_FRAGS 2 +#define QDF_NBUF_CB_PACKET_TYPE_EAPOL 1 +#define QDF_NBUF_CB_PACKET_TYPE_ARP 2 +#define QDF_NBUF_CB_PACKET_TYPE_WAPI 3 +#define QDF_NBUF_CB_PACKET_TYPE_DHCP 4 /* * Make sure that qdf_dma_addr_t in the cb block is always 64 bit aligned @@ -171,24 +176,18 @@ struct qdf_nbuf_cb { } win; /* 21 bytes*/ struct { uint32_t data_attr; /* 4 bytes */ - union { - struct { - uint8_t packet_state; - uint8_t packet_track:4, - proto_type:4; - uint8_t dp_trace:1, - htt2_frm:1, - rsrvd:6; - uint8_t vdev_id; - } hl; - struct { - uint8_t packet_state; - uint8_t packet_track:4, - proto_type:4; - uint8_t dp_trace:1, - rsrvd:7; - uint8_t vdev_id; - } ll; /* low latency */ + struct{ + uint8_t packet_state; + uint8_t packet_track:4, + proto_type:4; + uint8_t dp_trace:1, + is_bcast:1, + is_mcast:1, + packet_type:3, + /* used only for hl*/ + htt2_frm:1, + reserved:1; + uint8_t vdev_id; } trace; /* 4 bytes */ struct { uint32_t owned:1, @@ -266,23 +265,29 @@ struct qdf_nbuf_cb { (((struct qdf_nbuf_cb *)((skb)->cb))->u.tx.dev.mcl.data_attr) #define QDF_NBUF_CB_TX_PACKET_STATE(skb) \ (((struct qdf_nbuf_cb *) \ - ((skb)->cb))->u.tx.dev.mcl.trace.ll.packet_state) + ((skb)->cb))->u.tx.dev.mcl.trace.packet_state) #define QDF_NBUF_CB_TX_PACKET_TRACK(skb) \ (((struct qdf_nbuf_cb *) \ - ((skb)->cb))->u.tx.dev.mcl.trace.ll.packet_track) + ((skb)->cb))->u.tx.dev.mcl.trace.packet_track) #define QDF_NBUF_CB_TX_PROTO_TYPE(skb) \ (((struct qdf_nbuf_cb *) \ - ((skb)->cb))->u.tx.dev.mcl.trace.ll.proto_type) + ((skb)->cb))->u.tx.dev.mcl.trace.proto_type) #define QDF_NBUF_UPDATE_TX_PKT_COUNT(skb, PACKET_STATE) \ qdf_nbuf_set_state(skb, PACKET_STATE) #define QDF_NBUF_GET_PACKET_TRACK(skb) \ - (((struct qdf_nbuf_cb *)((skb)->cb))->u.tx.dev.mcl.trace.ll.packet_track) + (((struct qdf_nbuf_cb *)((skb)->cb))->u.tx.dev.mcl.trace.packet_track) #define QDF_NBUF_CB_TX_DP_TRACE(skb) \ - (((struct qdf_nbuf_cb *)((skb)->cb))->u.tx.dev.mcl.trace.ll.dp_trace) + (((struct qdf_nbuf_cb *)((skb)->cb))->u.tx.dev.mcl.trace.dp_trace) #define QDF_NBUF_CB_TX_HL_HTT2_FRM(skb) \ - (((struct qdf_nbuf_cb *)((skb)->cb))->u.tx.dev.mcl.trace.hl.htt2_frm) + (((struct qdf_nbuf_cb *)((skb)->cb))->u.tx.dev.mcl.trace.htt2_frm) #define QDF_NBUF_CB_TX_VDEV_ID(skb) \ - (((struct qdf_nbuf_cb *)((skb)->cb))->u.tx.dev.mcl.trace.ll.vdev_id) + (((struct qdf_nbuf_cb *)((skb)->cb))->u.tx.dev.mcl.trace.vdev_id) +#define QDF_NBUF_CB_GET_IS_BCAST(skb) \ + (((struct qdf_nbuf_cb *)((skb)->cb))->u.tx.dev.mcl.trace.is_bcast) +#define QDF_NBUF_CB_GET_IS_MCAST(skb) \ + (((struct qdf_nbuf_cb *)((skb)->cb))->u.tx.dev.mcl.trace.is_mcast) +#define QDF_NBUF_CB_GET_PACKET_TYPE(skb) \ + (((struct qdf_nbuf_cb *)((skb)->cb))->u.tx.dev.mcl.trace.packet_type) #define QDF_NBUF_CB_TX_IPA_OWNED(skb) \ (((struct qdf_nbuf_cb *)((skb)->cb))->u.tx.dev.mcl.ipa.owned) #define QDF_NBUF_CB_TX_IPA_PRIV(skb) \ @@ -486,10 +491,27 @@ QDF_STATUS __qdf_nbuf_frag_map( qdf_device_t osdev, __qdf_nbuf_t nbuf, int offset, qdf_dma_dir_t dir, int cur_frag); -bool __qdf_nbuf_is_ipv4_pkt(struct sk_buff *skb); -bool __qdf_nbuf_is_ipv4_dhcp_pkt(struct sk_buff *skb); -bool __qdf_nbuf_is_ipv4_eapol_pkt(struct sk_buff *skb); -bool __qdf_nbuf_is_ipv4_arp_pkt(struct sk_buff *skb); +bool __qdf_nbuf_is_ipv4_wapi_pkt(struct sk_buff *skb); +bool __qdf_nbuf_data_is_ipv4_pkt(uint8_t *data); +bool __qdf_nbuf_data_is_ipv6_pkt(uint8_t *data); +bool __qdf_nbuf_data_is_ipv4_mcast_pkt(uint8_t *data); +bool __qdf_nbuf_data_is_ipv6_mcast_pkt(uint8_t *data); +bool __qdf_nbuf_data_is_icmp_pkt(uint8_t *data); +bool __qdf_nbuf_data_is_icmpv6_pkt(uint8_t *data); +bool __qdf_nbuf_data_is_ipv4_udp_pkt(uint8_t *data); +bool __qdf_nbuf_data_is_ipv4_tcp_pkt(uint8_t *data); +bool __qdf_nbuf_data_is_ipv6_udp_pkt(uint8_t *data); +bool __qdf_nbuf_data_is_ipv6_tcp_pkt(uint8_t *data); +bool __qdf_nbuf_data_is_ipv4_dhcp_pkt(uint8_t *data); +bool __qdf_nbuf_data_is_ipv4_eapol_pkt(uint8_t *data); +bool __qdf_nbuf_data_is_ipv4_arp_pkt(uint8_t *data); +enum qdf_proto_subtype __qdf_nbuf_data_get_dhcp_subtype(uint8_t *data); +enum qdf_proto_subtype __qdf_nbuf_data_get_eapol_subtype(uint8_t *data); +enum qdf_proto_subtype __qdf_nbuf_data_get_arp_subtype(uint8_t *data); +enum qdf_proto_subtype __qdf_nbuf_data_get_icmp_subtype(uint8_t *data); +enum qdf_proto_subtype __qdf_nbuf_data_get_icmpv6_subtype(uint8_t *data); +uint8_t __qdf_nbuf_data_get_ipv4_proto(uint8_t *data); +uint8_t __qdf_nbuf_data_get_ipv6_proto(uint8_t *data); /** * __qdf_to_status() - OS to QDF status conversion @@ -1608,4 +1630,30 @@ __qdf_nbuf_get_priv_ptr(struct sk_buff *skb) return &skb->cb[8]; } +/** + * __qdf_invalidate_range() - invalidate virtual address range + * @start: start address of the address range + * @end: end address of the address range + * + * Note that this function does not write back the cache entries. + * + * Return: none + */ +#ifdef MSM_PLATFORM +static inline void __qdf_invalidate_range(void *start, void *end) +{ + dmac_inv_range(start, end); +} + +#else +static inline void __qdf_invalidate_range(void *start, void *end) +{ + /* TODO figure out how to invalidate cache on x86 and other + non-MSM platform */ + pr_err("Cache invalidate not yet implemneted for non-MSM platforms\n"); + return; +} +#endif + + #endif /*_I_QDF_NET_BUF_H */ diff --git a/qdf/linux/src/i_qdf_time.h b/qdf/linux/src/i_qdf_time.h index 3d66c4d4c69d..7862e250a354 100644 --- a/qdf/linux/src/i_qdf_time.h +++ b/qdf/linux/src/i_qdf_time.h @@ -35,7 +35,11 @@ #include #include +#ifdef MSM_PLATFORM #include +#else +#include +#endif #ifdef CONFIG_CNSS #include #endif diff --git a/qdf/linux/src/i_qdf_types.h b/qdf/linux/src/i_qdf_types.h index 74325b7b64f5..f915d0a9bcf2 100644 --- a/qdf/linux/src/i_qdf_types.h +++ b/qdf/linux/src/i_qdf_types.h @@ -154,6 +154,7 @@ struct __qdf_mempool_ctxt; * @QDF_BUS_TYPE_AHB: AHB Bus * @QDF_BUS_TYPE_SNOC: SNOC Bus * @QDF_BUS_TYPE_SIM: Simulator + * @QDF_BUS_TYPE_USB: USB Bus */ enum qdf_bus_type { QDF_BUS_TYPE_NONE = -1, @@ -161,7 +162,8 @@ enum qdf_bus_type { QDF_BUS_TYPE_AHB, QDF_BUS_TYPE_SNOC, QDF_BUS_TYPE_SIM, - QDF_BUS_TYPE_SDIO + QDF_BUS_TYPE_SDIO, + QDF_BUS_TYPE_USB }; /** diff --git a/qdf/linux/src/i_qdf_util.h b/qdf/linux/src/i_qdf_util.h index f11f7c6740d7..1cfb71614232 100644 --- a/qdf/linux/src/i_qdf_util.h +++ b/qdf/linux/src/i_qdf_util.h @@ -271,4 +271,9 @@ int __qdf_get_cpu(void) } #endif +static inline int __qdf_device_init_wakeup(__qdf_device_t qdf_dev, bool enable) +{ + return device_init_wakeup(qdf_dev->dev, enable); +} + #endif /*_I_QDF_UTIL_H*/ diff --git a/qdf/linux/src/qdf_list.c b/qdf/linux/src/qdf_list.c index 9412a1ac977b..ee1f462a4c18 100644 --- a/qdf/linux/src/qdf_list.c +++ b/qdf/linux/src/qdf_list.c @@ -133,30 +133,46 @@ QDF_STATUS qdf_list_remove_back(qdf_list_t *list, qdf_list_node_t **node2) } EXPORT_SYMBOL(qdf_list_remove_back); +/** + * qdf_list_has_node() - check if a node is in a list + * @list: pointer to the list being searched + * @node: pointer to the node to search for + * + * It is expected that the list being checked is locked + * when this function is being called. + * + * Return: true if the node is in the list + */ +bool qdf_list_has_node(qdf_list_t *list, qdf_list_node_t *node) +{ + qdf_list_node_t *tmp; + + list_for_each(tmp, &list->anchor) { + if (tmp == node) + return true; + } + return false; +} + /** * qdf_list_remove_node() - remove input node from list * @list: Pointer to list * @node_to_remove: Pointer to node which needs to be removed * + * verifies that the node is in the list before removing it. + * It is expected that the list being removed from is locked + * when this function is being called. + * * Return: QDF status */ QDF_STATUS qdf_list_remove_node(qdf_list_t *list, qdf_list_node_t *node_to_remove) { - qdf_list_node_t *tmp; - int found = 0; - if (list_empty(&list->anchor)) return QDF_STATUS_E_EMPTY; /* verify that node_to_remove is indeed part of list list */ - list_for_each(tmp, &list->anchor) { - if (tmp == node_to_remove) { - found = 1; - break; - } - } - if (found == 0) + if (!qdf_list_has_node(list, node_to_remove)) return QDF_STATUS_E_INVAL; list_del(node_to_remove); diff --git a/qdf/linux/src/qdf_mem.c b/qdf/linux/src/qdf_mem.c index 101d221e93cb..d29f13307abd 100644 --- a/qdf/linux/src/qdf_mem.c +++ b/qdf/linux/src/qdf_mem.c @@ -503,6 +503,42 @@ void *qdf_mem_malloc_debug(size_t size, } EXPORT_SYMBOL(qdf_mem_malloc_debug); +/** + * qdf_mem_validate_node_for_free() - validate that the node is in a list + * @qdf_node: node to check for being in a list + * + * qdf_node should be a non null value. + * + * Return: true if the node validly linked in an anchored doubly linked list + */ +static bool qdf_mem_validate_node_for_free(qdf_list_node_t *qdf_node) +{ + struct list_head *node = qdf_node; + + /* + * if the node is an empty list, it is not tied to an anchor node + * and must have been removed with list_del_init + */ + if (list_empty(node)) + return false; + + if (node->prev == NULL) + return false; + + if (node->next == NULL) + return false; + + if (node->prev->next != node) + return false; + + if (node->next->prev != node) + return false; + + return true; +} + + + /** * qdf_mem_free() - QDF memory free API * @ptr: Pointer to the starting address of the memory to be free'd. @@ -514,50 +550,99 @@ EXPORT_SYMBOL(qdf_mem_malloc_debug); */ void qdf_mem_free(void *ptr) { - if (ptr != NULL) { - QDF_STATUS qdf_status; - struct s_qdf_mem_struct *mem_struct = - ((struct s_qdf_mem_struct *)ptr) - 1; + struct s_qdf_mem_struct *mem_struct; + + /* freeing a null pointer is valid */ + if (qdf_unlikely(ptr == NULL)) + return; + + mem_struct = ((struct s_qdf_mem_struct *)ptr) - 1; + + if (qdf_unlikely(mem_struct == NULL)) { + QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_FATAL, + "%s: null mem_struct", __func__); + QDF_BUG(0); + } #if defined(CONFIG_CNSS) && defined(CONFIG_WCNSS_MEM_PRE_ALLOC) - if (wcnss_prealloc_put(ptr)) - return; + if (wcnss_prealloc_put(ptr)) + return; #endif - qdf_spin_lock_irqsave(&qdf_mem_list_lock); - qdf_status = - qdf_list_remove_node(&qdf_mem_list, &mem_struct->node); - qdf_spin_unlock_irqrestore(&qdf_mem_list_lock); + qdf_spin_lock_irqsave(&qdf_mem_list_lock); - if (QDF_STATUS_SUCCESS == qdf_status) { - if (qdf_mem_cmp(mem_struct->header, - &WLAN_MEM_HEADER[0], - sizeof(WLAN_MEM_HEADER))) { - QDF_TRACE(QDF_MODULE_ID_QDF, - QDF_TRACE_LEVEL_FATAL, - "Memory Header is corrupted. mem_info: Filename %s, line_num %d", - mem_struct->file_name, - (int)mem_struct->line_num); - QDF_BUG(0); - } - if (qdf_mem_cmp((uint8_t *) ptr + mem_struct->size, - &WLAN_MEM_TAIL[0], - sizeof(WLAN_MEM_TAIL))) { - QDF_TRACE(QDF_MODULE_ID_QDF, - QDF_TRACE_LEVEL_FATAL, - "Memory Trailer is corrupted. mem_info: Filename %s, line_num %d", - mem_struct->file_name, - (int)mem_struct->line_num); - QDF_BUG(0); - } - kfree((void *)mem_struct); - } else { - QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_FATAL, - "%s: Unallocated memory (double free?)", - __func__); - QDF_BUG(0); - } + /* + * invalid memory access when checking the header/tailer + * would be a use after free and would indicate a double free + * or invalid pointer passed. + */ + if (qdf_mem_cmp(mem_struct->header, &WLAN_MEM_HEADER[0], + sizeof(WLAN_MEM_HEADER))) + goto error; + + /* + * invalid memory access while checking validate node + * would indicate corruption in the nodes pointed to + */ + if (!qdf_mem_validate_node_for_free(&mem_struct->node)) + goto error; + + /* + * invalid memory access here is unlikely and would imply + * that the size value was corrupted/incorrect. + * It is unlikely that the above checks would pass in a + * double free case. + */ + if (qdf_mem_cmp((uint8_t *) ptr + mem_struct->size, + &WLAN_MEM_TAIL[0], sizeof(WLAN_MEM_TAIL))) + goto error; + + /* + * make the node an empty list before doing the spin unlock + * The empty list check will guarantee that we avoid a race condition. + */ + list_del_init(&mem_struct->node); + qdf_spin_unlock_irqrestore(&qdf_mem_list_lock); + kfree(mem_struct); + return; + +error: + if (!qdf_list_has_node(&qdf_mem_list, &mem_struct->node)) { + QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_FATAL, + "%s: Unallocated memory (double free?)", + __func__); + qdf_spin_unlock_irqrestore(&qdf_mem_list_lock); + QDF_BUG(0); } + + if (qdf_mem_cmp(mem_struct->header, &WLAN_MEM_HEADER[0], + sizeof(WLAN_MEM_HEADER))) { + QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_FATAL, + "Memory Header is corrupted."); + qdf_spin_unlock_irqrestore(&qdf_mem_list_lock); + QDF_BUG(0); + } + + if (!qdf_mem_validate_node_for_free(&mem_struct->node)) { + QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_FATAL, + "Memory_struct is corrupted."); + qdf_spin_unlock_irqrestore(&qdf_mem_list_lock); + QDF_BUG(0); + } + + if (qdf_mem_cmp((uint8_t *) ptr + mem_struct->size, + &WLAN_MEM_TAIL[0], sizeof(WLAN_MEM_TAIL))) { + QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_FATAL, + "Memory Trailer is corrupted. mem_info: Filename %s, line_num %d", + mem_struct->file_name, (int)mem_struct->line_num); + qdf_spin_unlock_irqrestore(&qdf_mem_list_lock); + QDF_BUG(0); + } + + QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_FATAL, + "%s unexpected error", __func__); + qdf_spin_unlock_irqrestore(&qdf_mem_list_lock); + QDF_BUG(0); } EXPORT_SYMBOL(qdf_mem_free); #else @@ -860,7 +945,7 @@ void qdf_mem_move(void *dst_addr, const void *src_addr, uint32_t num_bytes) } EXPORT_SYMBOL(qdf_mem_move); -#if defined(A_SIMOS_DEVHOST) || defined(HIF_SDIO) +#if defined(A_SIMOS_DEVHOST) || defined(HIF_SDIO) || defined(HIF_USB) /** * qdf_mem_alloc_consistent() - allocates consistent qdf memory * @osdev: OS device handle @@ -876,7 +961,11 @@ void *qdf_mem_alloc_consistent(qdf_device_t osdev, void *dev, qdf_size_t size, void *vaddr; vaddr = qdf_mem_malloc(size); - *phy_addr = ((qdf_dma_addr_t) vaddr); + *phy_addr = ((uintptr_t) vaddr); + /* using this type conversion to suppress "cast from pointer to integer + * of different size" warning on some platforms + */ + BUILD_BUG_ON(sizeof(*phy_addr) < sizeof(vaddr)); return vaddr; } @@ -900,7 +989,7 @@ void *qdf_mem_alloc_consistent(qdf_device_t osdev, void *dev, qdf_size_t size, #endif EXPORT_SYMBOL(qdf_mem_alloc_consistent); -#if defined(A_SIMOS_DEVHOST) || defined(HIF_SDIO) +#if defined(A_SIMOS_DEVHOST) || defined(HIF_SDIO) || defined(HIF_USB) /** * qdf_mem_free_consistent() - free consistent qdf memory * @osdev: OS device handle diff --git a/qdf/linux/src/qdf_nbuf.c b/qdf/linux/src/qdf_nbuf.c index aa6e2dcbdf02..28457f6af6f6 100644 --- a/qdf/linux/src/qdf_nbuf.c +++ b/qdf/linux/src/qdf_nbuf.c @@ -311,13 +311,15 @@ EXPORT_SYMBOL(__qdf_nbuf_unmap); * * Return: QDF_STATUS */ -#ifdef A_SIMOS_DEVHOST +#if defined(A_SIMOS_DEVHOST) || defined (HIF_USB) QDF_STATUS __qdf_nbuf_map_single(qdf_device_t osdev, qdf_nbuf_t buf, qdf_dma_dir_t dir) { qdf_dma_addr_t paddr; - QDF_NBUF_CB_PADDR(buf) = paddr = buf->data; + QDF_NBUF_CB_PADDR(buf) = paddr = (uintptr_t)buf->data; + BUILD_BUG_ON(sizeof(paddr) < sizeof(buf->data)); + BUILD_BUG_ON(sizeof(QDF_NBUF_CB_PADDR(buf)) < sizeof(buf->data)); return QDF_STATUS_SUCCESS; } EXPORT_SYMBOL(__qdf_nbuf_map_single); @@ -345,7 +347,7 @@ EXPORT_SYMBOL(__qdf_nbuf_map_single); * * Return: none */ -#if defined(A_SIMOS_DEVHOST) +#if defined(A_SIMOS_DEVHOST) || defined (HIF_USB) void __qdf_nbuf_unmap_single(qdf_device_t osdev, qdf_nbuf_t buf, qdf_dma_dir_t dir) { @@ -464,39 +466,269 @@ void __qdf_nbuf_reg_trace_cb(qdf_nbuf_trace_update_t cb_func_ptr) EXPORT_SYMBOL(__qdf_nbuf_reg_trace_cb); /** - * __qdf_nbuf_is_ipv4_pkt() - check if packet is a ipv4 packet - * @skb: Pointer to network buffer + * __qdf_nbuf_data_get_dhcp_subtype() - get the subtype + * of DHCP packet. + * @data: Pointer to DHCP packet data buffer + * + * This func. returns the subtype of DHCP packet. + * + * Return: subtype of the DHCP packet. + */ +enum qdf_proto_subtype +__qdf_nbuf_data_get_dhcp_subtype(uint8_t *data) +{ + enum qdf_proto_subtype subtype = QDF_PROTO_INVALID; + + if ((data[QDF_DHCP_OPTION53_OFFSET] == QDF_DHCP_OPTION53) && + (data[QDF_DHCP_OPTION53_LENGTH_OFFSET] == + QDF_DHCP_OPTION53_LENGTH)) { + + switch (data[QDF_DHCP_OPTION53_STATUS_OFFSET]) { + case QDF_DHCP_DISCOVER: + subtype = QDF_PROTO_DHCP_DISCOVER; + break; + case QDF_DHCP_REQUEST: + subtype = QDF_PROTO_DHCP_REQUEST; + break; + case QDF_DHCP_OFFER: + subtype = QDF_PROTO_DHCP_OFFER; + break; + case QDF_DHCP_ACK: + subtype = QDF_PROTO_DHCP_ACK; + break; + case QDF_DHCP_NAK: + subtype = QDF_PROTO_DHCP_NACK; + break; + case QDF_DHCP_RELEASE: + subtype = QDF_PROTO_DHCP_RELEASE; + break; + case QDF_DHCP_INFORM: + subtype = QDF_PROTO_DHCP_INFORM; + break; + case QDF_DHCP_DECLINE: + subtype = QDF_PROTO_DHCP_DECLINE; + break; + default: + break; + } + } + + return subtype; +} + +/** + * __qdf_nbuf_data_get_eapol_subtype() - get the subtype + * of EAPOL packet. + * @data: Pointer to EAPOL packet data buffer + * + * This func. returns the subtype of EAPOL packet. + * + * Return: subtype of the EAPOL packet. + */ +enum qdf_proto_subtype +__qdf_nbuf_data_get_eapol_subtype(uint8_t *data) +{ + uint16_t eapol_key_info; + enum qdf_proto_subtype subtype = QDF_PROTO_INVALID; + uint16_t mask; + + eapol_key_info = (uint16_t)(*(uint16_t *) + (data + EAPOL_KEY_INFO_OFFSET)); + + mask = eapol_key_info & EAPOL_MASK; + switch (mask) { + case EAPOL_M1_BIT_MASK: + subtype = QDF_PROTO_EAPOL_M1; + break; + case EAPOL_M2_BIT_MASK: + subtype = QDF_PROTO_EAPOL_M2; + break; + case EAPOL_M3_BIT_MASK: + subtype = QDF_PROTO_EAPOL_M3; + break; + case EAPOL_M4_BIT_MASK: + subtype = QDF_PROTO_EAPOL_M4; + break; + default: + break; + } + + return subtype; +} + +/** + * __qdf_nbuf_data_get_arp_subtype() - get the subtype + * of ARP packet. + * @data: Pointer to ARP packet data buffer + * + * This func. returns the subtype of ARP packet. + * + * Return: subtype of the ARP packet. + */ +enum qdf_proto_subtype +__qdf_nbuf_data_get_arp_subtype(uint8_t *data) +{ + uint16_t subtype; + enum qdf_proto_subtype proto_subtype = QDF_PROTO_INVALID; + + subtype = (uint16_t)(*(uint16_t *) + (data + ARP_SUB_TYPE_OFFSET)); + + switch (QDF_SWAP_U16(subtype)) { + case ARP_REQUEST: + proto_subtype = QDF_PROTO_ARP_REQ; + break; + case ARP_RESPONSE: + proto_subtype = QDF_PROTO_ARP_RES; + break; + default: + break; + } + + return proto_subtype; +} + +/** + * __qdf_nbuf_data_get_icmp_subtype() - get the subtype + * of IPV4 ICMP packet. + * @data: Pointer to IPV4 ICMP packet data buffer + * + * This func. returns the subtype of ICMP packet. + * + * Return: subtype of the ICMP packet. + */ +enum qdf_proto_subtype +__qdf_nbuf_data_get_icmp_subtype(uint8_t *data) +{ + uint8_t subtype; + enum qdf_proto_subtype proto_subtype = QDF_PROTO_INVALID; + + subtype = (uint8_t)(*(uint8_t *) + (data + ICMP_SUBTYPE_OFFSET)); + + switch (subtype) { + case ICMP_REQUEST: + proto_subtype = QDF_PROTO_ICMP_REQ; + break; + case ICMP_RESPONSE: + proto_subtype = QDF_PROTO_ICMP_RES; + break; + default: + break; + } + + return proto_subtype; +} + +/** + * __qdf_nbuf_data_get_icmpv6_subtype() - get the subtype + * of IPV6 ICMPV6 packet. + * @data: Pointer to IPV6 ICMPV6 packet data buffer + * + * This func. returns the subtype of ICMPV6 packet. + * + * Return: subtype of the ICMPV6 packet. + */ +enum qdf_proto_subtype +__qdf_nbuf_data_get_icmpv6_subtype(uint8_t *data) +{ + uint8_t subtype; + enum qdf_proto_subtype proto_subtype = QDF_PROTO_INVALID; + + subtype = (uint8_t)(*(uint8_t *) + (data + ICMPV6_SUBTYPE_OFFSET)); + + switch (subtype) { + case ICMPV6_REQUEST: + proto_subtype = QDF_PROTO_ICMPV6_REQ; + break; + case ICMPV6_RESPONSE: + proto_subtype = QDF_PROTO_ICMPV6_RES; + break; + default: + break; + } + + return proto_subtype; +} + +/** + * __qdf_nbuf_data_get_ipv4_proto() - get the proto type + * of IPV4 packet. + * @data: Pointer to IPV4 packet data buffer + * + * This func. returns the proto type of IPV4 packet. + * + * Return: proto type of IPV4 packet. + */ +uint8_t +__qdf_nbuf_data_get_ipv4_proto(uint8_t *data) +{ + uint8_t proto_type; + + proto_type = (uint8_t)(*(uint8_t *)(data + + QDF_NBUF_TRAC_IPV4_PROTO_TYPE_OFFSET)); + return proto_type; +} + +/** + * __qdf_nbuf_data_get_ipv6_proto() - get the proto type + * of IPV6 packet. + * @data: Pointer to IPV6 packet data buffer + * + * This func. returns the proto type of IPV6 packet. + * + * Return: proto type of IPV6 packet. + */ +uint8_t +__qdf_nbuf_data_get_ipv6_proto(uint8_t *data) +{ + uint8_t proto_type; + + proto_type = (uint8_t)(*(uint8_t *)(data + + QDF_NBUF_TRAC_IPV6_PROTO_TYPE_OFFSET)); + return proto_type; +} + +/** + * __qdf_nbuf_data_is_ipv4_pkt() - check if packet is a ipv4 packet + * @data: Pointer to network data * * This api is for Tx packets. * * Return: true if packet is ipv4 packet * false otherwise */ -bool __qdf_nbuf_is_ipv4_pkt(struct sk_buff *skb) +bool __qdf_nbuf_data_is_ipv4_pkt(uint8_t *data) { - if (qdf_nbuf_get_protocol(skb) == htons(ETH_P_IP)) + uint16_t ether_type; + + ether_type = (uint16_t)(*(uint16_t *)(data + + QDF_NBUF_TRAC_ETH_TYPE_OFFSET)); + + if (ether_type == QDF_SWAP_U16(QDF_NBUF_TRAC_IPV4_ETH_TYPE)) return true; else return false; } /** - * __qdf_nbuf_is_ipv4_dhcp_pkt() - check if skb data is a dhcp packet - * @skb: Pointer to network buffer + * __qdf_nbuf_data_is_ipv4_dhcp_pkt() - check if skb data is a dhcp packet + * @data: Pointer to network data buffer * * This api is for ipv4 packet. * * Return: true if packet is DHCP packet * false otherwise */ -bool __qdf_nbuf_is_ipv4_dhcp_pkt(struct sk_buff *skb) +bool __qdf_nbuf_data_is_ipv4_dhcp_pkt(uint8_t *data) { uint16_t sport; uint16_t dport; - sport = (uint16_t)(*(uint16_t *)(skb->data + QDF_NBUF_TRAC_IPV4_OFFSET + + sport = (uint16_t)(*(uint16_t *)(data + QDF_NBUF_TRAC_IPV4_OFFSET + QDF_NBUF_TRAC_IPV4_HEADER_SIZE)); - dport = (uint16_t)(*(uint16_t *)(skb->data + QDF_NBUF_TRAC_IPV4_OFFSET + + dport = (uint16_t)(*(uint16_t *)(data + QDF_NBUF_TRAC_IPV4_OFFSET + QDF_NBUF_TRAC_IPV4_HEADER_SIZE + sizeof(uint16_t))); @@ -510,19 +742,19 @@ bool __qdf_nbuf_is_ipv4_dhcp_pkt(struct sk_buff *skb) } /** - * __qdf_nbuf_is_ipv4_eapol_pkt() - check if skb data is a eapol packet - * @skb: Pointer to network buffer + * __qdf_nbuf_data_is_ipv4_eapol_pkt() - check if skb data is a eapol packet + * @data: Pointer to network data buffer * * This api is for ipv4 packet. * * Return: true if packet is EAPOL packet * false otherwise. */ -bool __qdf_nbuf_is_ipv4_eapol_pkt(struct sk_buff *skb) +bool __qdf_nbuf_data_is_ipv4_eapol_pkt(uint8_t *data) { uint16_t ether_type; - ether_type = (uint16_t)(*(uint16_t *)(skb->data + + ether_type = (uint16_t)(*(uint16_t *)(data + QDF_NBUF_TRAC_ETH_TYPE_OFFSET)); if (ether_type == QDF_SWAP_U16(QDF_NBUF_TRAC_EAPOL_ETH_TYPE)) @@ -532,27 +764,279 @@ bool __qdf_nbuf_is_ipv4_eapol_pkt(struct sk_buff *skb) } /** - * __qdf_nbuf_is_ipv4_arp_pkt() - check if skb data is a eapol packet + * __qdf_nbuf_is_ipv4_wapi_pkt() - check if skb data is a wapi packet * @skb: Pointer to network buffer * * This api is for ipv4 packet. * - * Return: true if packet is ARP packet + * Return: true if packet is WAPI packet * false otherwise. */ -bool __qdf_nbuf_is_ipv4_arp_pkt(struct sk_buff *skb) +bool __qdf_nbuf_is_ipv4_wapi_pkt(struct sk_buff *skb) { uint16_t ether_type; ether_type = (uint16_t)(*(uint16_t *)(skb->data + QDF_NBUF_TRAC_ETH_TYPE_OFFSET)); + if (ether_type == QDF_SWAP_U16(QDF_NBUF_TRAC_WAPI_ETH_TYPE)) + return true; + else + return false; +} + +/** + * __qdf_nbuf_data_is_ipv4_arp_pkt() - check if skb data is a arp packet + * @data: Pointer to network data buffer + * + * This api is for ipv4 packet. + * + * Return: true if packet is ARP packet + * false otherwise. + */ +bool __qdf_nbuf_data_is_ipv4_arp_pkt(uint8_t *data) +{ + uint16_t ether_type; + + ether_type = (uint16_t)(*(uint16_t *)(data + + QDF_NBUF_TRAC_ETH_TYPE_OFFSET)); + if (ether_type == QDF_SWAP_U16(QDF_NBUF_TRAC_ARP_ETH_TYPE)) return true; else return false; } +/** + * __qdf_nbuf_data_is_ipv6_pkt() - check if it is IPV6 packet. + * @data: Pointer to IPV6 packet data buffer + * + * This func. checks whether it is a IPV6 packet or not. + * + * Return: TRUE if it is a IPV6 packet + * FALSE if not + */ +bool __qdf_nbuf_data_is_ipv6_pkt(uint8_t *data) +{ + uint16_t ether_type; + + ether_type = (uint16_t)(*(uint16_t *)(data + + QDF_NBUF_TRAC_ETH_TYPE_OFFSET)); + + if (ether_type == QDF_SWAP_U16(QDF_NBUF_TRAC_IPV6_ETH_TYPE)) + return true; + else + return false; +} + +/** + * __qdf_nbuf_data_is_ipv4_mcast_pkt() - check if it is IPV4 multicast packet. + * @data: Pointer to IPV4 packet data buffer + * + * This func. checks whether it is a IPV4 multicast packet or not. + * + * Return: TRUE if it is a IPV4 multicast packet + * FALSE if not + */ +bool __qdf_nbuf_data_is_ipv4_mcast_pkt(uint8_t *data) +{ + if (__qdf_nbuf_data_is_ipv4_pkt(data)) { + uint32_t *dst_addr = + (uint32_t *)(data + QDF_NBUF_TRAC_IPV4_DEST_ADDR_OFFSET); + + /* + * Check first word of the IPV4 address and if it is + * equal to 0xE then it represents multicast IP. + */ + if ((*dst_addr & QDF_NBUF_TRAC_IPV4_ADDR_BCAST_MASK) == + QDF_NBUF_TRAC_IPV4_ADDR_MCAST_MASK) + return true; + else + return false; + } else + return false; +} + +/** + * __qdf_nbuf_data_is_ipv6_mcast_pkt() - check if it is IPV6 multicast packet. + * @data: Pointer to IPV6 packet data buffer + * + * This func. checks whether it is a IPV6 multicast packet or not. + * + * Return: TRUE if it is a IPV6 multicast packet + * FALSE if not + */ +bool __qdf_nbuf_data_is_ipv6_mcast_pkt(uint8_t *data) +{ + if (__qdf_nbuf_data_is_ipv6_pkt(data)) { + uint16_t *dst_addr; + + dst_addr = (uint16_t *) + (data + QDF_NBUF_TRAC_IPV6_DEST_ADDR_OFFSET); + + /* + * Check first byte of the IP address and if it + * 0xFF00 then it is a IPV6 mcast packet. + */ + if (*dst_addr == + QDF_SWAP_U16(QDF_NBUF_TRAC_IPV6_DEST_ADDR)) + return true; + else + return false; + } else + return false; +} + +/** + * __qdf_nbuf_data_is_icmp_pkt() - check if it is IPV4 ICMP packet. + * @data: Pointer to IPV4 ICMP packet data buffer + * + * This func. checks whether it is a ICMP packet or not. + * + * Return: TRUE if it is a ICMP packet + * FALSE if not + */ +bool __qdf_nbuf_data_is_icmp_pkt(uint8_t *data) +{ + if (__qdf_nbuf_data_is_ipv4_pkt(data)) { + uint8_t pkt_type; + + pkt_type = (uint8_t)(*(uint8_t *)(data + + QDF_NBUF_TRAC_IPV4_PROTO_TYPE_OFFSET)); + + if (pkt_type == QDF_NBUF_TRAC_ICMP_TYPE) + return true; + else + return false; + } else + return false; +} + +/** + * __qdf_nbuf_data_is_icmpv6_pkt() - check if it is IPV6 ICMPV6 packet. + * @data: Pointer to IPV6 ICMPV6 packet data buffer + * + * This func. checks whether it is a ICMPV6 packet or not. + * + * Return: TRUE if it is a ICMPV6 packet + * FALSE if not + */ +bool __qdf_nbuf_data_is_icmpv6_pkt(uint8_t *data) +{ + if (__qdf_nbuf_data_is_ipv6_pkt(data)) { + uint8_t pkt_type; + + pkt_type = (uint8_t)(*(uint8_t *)(data + + QDF_NBUF_TRAC_IPV6_PROTO_TYPE_OFFSET)); + + if (pkt_type == QDF_NBUF_TRAC_ICMPV6_TYPE) + return true; + else + return false; + } else + return false; +} + +/** + * __qdf_nbuf_data_is_ipv4_udp_pkt() - check if it is IPV4 UDP packet. + * @data: Pointer to IPV4 UDP packet data buffer + * + * This func. checks whether it is a IPV4 UDP packet or not. + * + * Return: TRUE if it is a IPV4 UDP packet + * FALSE if not + */ +bool __qdf_nbuf_data_is_ipv4_udp_pkt(uint8_t *data) +{ + if (__qdf_nbuf_data_is_ipv4_pkt(data)) { + uint8_t pkt_type; + + pkt_type = (uint8_t)(*(uint8_t *)(data + + QDF_NBUF_TRAC_IPV4_PROTO_TYPE_OFFSET)); + + if (pkt_type == QDF_NBUF_TRAC_UDP_TYPE) + return true; + else + return false; + } else + return false; +} + +/** + * __qdf_nbuf_data_is_ipv4_tcp_pkt() - check if it is IPV4 TCP packet. + * @data: Pointer to IPV4 TCP packet data buffer + * + * This func. checks whether it is a IPV4 TCP packet or not. + * + * Return: TRUE if it is a IPV4 TCP packet + * FALSE if not + */ +bool __qdf_nbuf_data_is_ipv4_tcp_pkt(uint8_t *data) +{ + if (__qdf_nbuf_data_is_ipv4_pkt(data)) { + uint8_t pkt_type; + + pkt_type = (uint8_t)(*(uint8_t *)(data + + QDF_NBUF_TRAC_IPV4_PROTO_TYPE_OFFSET)); + + if (pkt_type == QDF_NBUF_TRAC_TCP_TYPE) + return true; + else + return false; + } else + return false; +} + +/** + * __qdf_nbuf_data_is_ipv6_udp_pkt() - check if it is IPV6 UDP packet. + * @data: Pointer to IPV6 UDP packet data buffer + * + * This func. checks whether it is a IPV6 UDP packet or not. + * + * Return: TRUE if it is a IPV6 UDP packet + * FALSE if not + */ +bool __qdf_nbuf_data_is_ipv6_udp_pkt(uint8_t *data) +{ + if (__qdf_nbuf_data_is_ipv6_pkt(data)) { + uint8_t pkt_type; + + pkt_type = (uint8_t)(*(uint8_t *)(data + + QDF_NBUF_TRAC_IPV6_PROTO_TYPE_OFFSET)); + + if (pkt_type == QDF_NBUF_TRAC_UDP_TYPE) + return true; + else + return false; + } else + return false; +} + +/** + * __qdf_nbuf_data_is_ipv6_tcp_pkt() - check if it is IPV6 TCP packet. + * @data: Pointer to IPV6 TCP packet data buffer + * + * This func. checks whether it is a IPV6 TCP packet or not. + * + * Return: TRUE if it is a IPV6 TCP packet + * FALSE if not + */ +bool __qdf_nbuf_data_is_ipv6_tcp_pkt(uint8_t *data) +{ + if (__qdf_nbuf_data_is_ipv6_pkt(data)) { + uint8_t pkt_type; + + pkt_type = (uint8_t)(*(uint8_t *)(data + + QDF_NBUF_TRAC_IPV6_PROTO_TYPE_OFFSET)); + + if (pkt_type == QDF_NBUF_TRAC_TCP_TYPE) + return true; + else + return false; + } else + return false; +} + #ifdef MEMORY_DEBUG #define QDF_NET_BUF_TRACK_MAX_SIZE (1024) diff --git a/qdf/linux/src/qdf_trace.c b/qdf/linux/src/qdf_trace.c index 08628620d45e..d713f5356077 100644 --- a/qdf/linux/src/qdf_trace.c +++ b/qdf/linux/src/qdf_trace.c @@ -1114,43 +1114,6 @@ void qdf_dp_add_record(enum QDF_DP_TRACE_ID code, } EXPORT_SYMBOL(qdf_dp_add_record); -/** - * qdf_event_eapol_log() - send event to wlan diag - * @skb: skb ptr - * @dir: direction - * @eapol_key_info: eapol key info - * - * Return: None - */ -#ifdef FEATURE_WLAN_DIAG_SUPPORT -static void qdf_event_eapol_log(struct sk_buff *skb, enum qdf_proto_dir dir, - int16_t eapol_key_info) -{ - WLAN_HOST_DIAG_EVENT_DEF(wlan_diag_event, struct host_event_wlan_eapol); - - wlan_diag_event.event_sub_type = - (dir == QDF_TX ? - WIFI_EVENT_DRIVER_EAPOL_FRAME_TRANSMIT_REQUESTED : - WIFI_EVENT_DRIVER_EAPOL_FRAME_RECEIVED); - wlan_diag_event.eapol_packet_type = (uint8_t)(*(uint8_t *) - (skb->data + EAPOL_PACKET_TYPE_OFFSET)); - wlan_diag_event.eapol_key_info = eapol_key_info; - wlan_diag_event.eapol_rate = 0; - qdf_mem_copy(wlan_diag_event.dest_addr, - (skb->data + QDF_NBUF_DEST_MAC_OFFSET), - sizeof(wlan_diag_event.dest_addr)); - qdf_mem_copy(wlan_diag_event.src_addr, - (skb->data + QDF_NBUF_SRC_MAC_OFFSET), - sizeof(wlan_diag_event.src_addr)); - - WLAN_HOST_DIAG_EVENT_REPORT(&wlan_diag_event, EVENT_WLAN_EAPOL); -} -#else -static void qdf_event_eapol_log(struct sk_buff *skb, enum qdf_proto_dir dir, - int16_t eapol_key_info) -{ -} -#endif /** * qdf_log_eapol_pkt() - log EAPOL packet @@ -1163,38 +1126,18 @@ static void qdf_event_eapol_log(struct sk_buff *skb, enum qdf_proto_dir dir, bool qdf_log_eapol_pkt(uint8_t session_id, struct sk_buff *skb, enum qdf_proto_dir dir) { - uint16_t mask; - uint16_t eapol_key_info; enum qdf_proto_subtype subtype; if ((qdf_dp_get_proto_bitmap() & QDF_NBUF_PKT_TRAC_TYPE_EAPOL) && - qdf_nbuf_is_ipv4_eapol_pkt(skb) == true) { + ((dir == QDF_TX && QDF_NBUF_CB_PACKET_TYPE_EAPOL == + QDF_NBUF_CB_GET_PACKET_TYPE(skb)) || + (dir == QDF_RX && qdf_nbuf_is_ipv4_eapol_pkt(skb) == true))) { - eapol_key_info = (uint16_t)(*(uint16_t *) - (skb->data + EAPOL_KEY_INFO_OFFSET)); - - mask = eapol_key_info & EAPOL_MASK; - switch (mask) { - case EAPOL_M1_BIT_MASK: - subtype = QDF_PROTO_EAPOL_M1; - break; - case EAPOL_M2_BIT_MASK: - subtype = QDF_PROTO_EAPOL_M2; - break; - case EAPOL_M3_BIT_MASK: - subtype = QDF_PROTO_EAPOL_M3; - break; - case EAPOL_M4_BIT_MASK: - subtype = QDF_PROTO_EAPOL_M4; - break; - default: - subtype = QDF_PROTO_INVALID; - } + subtype = qdf_nbuf_get_eapol_subtype(skb); DPTRACE(qdf_dp_trace_proto_pkt(QDF_DP_TRACE_EAPOL_PACKET_RECORD, session_id, (skb->data + QDF_NBUF_SRC_MAC_OFFSET), (skb->data + QDF_NBUF_DEST_MAC_OFFSET), QDF_PROTO_TYPE_EAPOL, subtype, dir)); - qdf_event_eapol_log(skb, dir, eapol_key_info); if (QDF_TX == dir) QDF_NBUF_CB_TX_DP_TRACE(skb) = 1; else if (QDF_RX == dir) @@ -1219,41 +1162,11 @@ bool qdf_log_dhcp_pkt(uint8_t session_id, struct sk_buff *skb, enum qdf_proto_subtype subtype = QDF_PROTO_INVALID; if ((qdf_dp_get_proto_bitmap() & QDF_NBUF_PKT_TRAC_TYPE_DHCP) && - qdf_nbuf_is_ipv4_dhcp_pkt(skb) == true) { + ((dir == QDF_TX && QDF_NBUF_CB_PACKET_TYPE_DHCP == + QDF_NBUF_CB_GET_PACKET_TYPE(skb)) || + (dir == QDF_RX && qdf_nbuf_is_ipv4_dhcp_pkt(skb) == true))) { - if ((skb->data[QDF_DHCP_OPTION53_OFFSET] == QDF_DHCP_OPTION53) && - (skb->data[QDF_DHCP_OPTION53_LENGTH_OFFSET] == - QDF_DHCP_OPTION53_LENGTH)) { - - switch (skb->data[QDF_DHCP_OPTION53_STATUS_OFFSET]) { - case QDF_DHCP_DISCOVER: - subtype = QDF_PROTO_DHCP_DISCOVER; - break; - case QDF_DHCP_REQUEST: - subtype = QDF_PROTO_DHCP_REQUEST; - break; - case QDF_DHCP_OFFER: - subtype = QDF_PROTO_DHCP_OFFER; - break; - case QDF_DHCP_ACK: - subtype = QDF_PROTO_DHCP_ACK; - break; - case QDF_DHCP_NAK: - subtype = QDF_PROTO_DHCP_NACK; - break; - case QDF_DHCP_RELEASE: - subtype = QDF_PROTO_DHCP_RELEASE; - break; - case QDF_DHCP_INFORM: - subtype = QDF_PROTO_DHCP_INFORM; - break; - case QDF_DHCP_DECLINE: - subtype = QDF_PROTO_DHCP_DECLINE; - break; - default: - subtype = QDF_PROTO_INVALID; - } - } + subtype = qdf_nbuf_get_dhcp_subtype(skb); DPTRACE(qdf_dp_trace_proto_pkt(QDF_DP_TRACE_DHCP_PACKET_RECORD, session_id, (skb->data + QDF_NBUF_SRC_MAC_OFFSET), (skb->data + QDF_NBUF_DEST_MAC_OFFSET), @@ -1279,25 +1192,14 @@ EXPORT_SYMBOL(qdf_log_dhcp_pkt); bool qdf_log_arp_pkt(uint8_t session_id, struct sk_buff *skb, enum qdf_proto_dir dir) { - uint16_t subtype; enum qdf_proto_subtype proto_subtype; if ((qdf_dp_get_proto_bitmap() & QDF_NBUF_PKT_TRAC_TYPE_ARP) && - qdf_nbuf_is_ipv4_arp_pkt(skb) == true) { - - subtype = (uint16_t)(*(uint16_t *) - (skb->data + ARP_SUB_TYPE_OFFSET)); - switch (QDF_SWAP_U16(subtype)) { - case ARP_REQUEST: - proto_subtype = QDF_PROTO_ARP_REQ; - break; - case ARP_RESPONSE: - proto_subtype = QDF_PROTO_ARP_RES; - break; - default: - proto_subtype = QDF_PROTO_INVALID; - } + ((dir == QDF_TX && QDF_NBUF_CB_PACKET_TYPE_ARP == + QDF_NBUF_CB_GET_PACKET_TYPE(skb)) || + (dir == QDF_RX && qdf_nbuf_is_ipv4_arp_pkt(skb) == true))) { + proto_subtype = qdf_nbuf_get_arp_subtype(skb); DPTRACE(qdf_dp_trace_proto_pkt(QDF_DP_TRACE_ARP_PACKET_RECORD, session_id, (skb->data + QDF_NBUF_SRC_MAC_OFFSET), (skb->data + QDF_NBUF_DEST_MAC_OFFSET), diff --git a/wmi/inc/wmi_unified_api.h b/wmi/inc/wmi_unified_api.h index 8086231c5834..7108b298876c 100644 --- a/wmi/inc/wmi_unified_api.h +++ b/wmi/inc/wmi_unified_api.h @@ -36,7 +36,9 @@ #include #include "a_types.h" #include "ol_defines.h" +#ifdef CONFIG_MCL #include "wmi.h" +#endif #include "htc_api.h" #include "wmi_unified_param.h" @@ -123,7 +125,7 @@ void *wmi_unified_attach(void *scn_handle, * * Return: none */ -void wmi_mgmt_cmd_record(wmi_unified_t wmi_handle, WMI_CMD_ID cmd, +void wmi_mgmt_cmd_record(wmi_unified_t wmi_handle, uint32_t cmd, void *header, uint32_t vdev_id, uint32_t chanfreq); /** @@ -171,7 +173,7 @@ void wmi_buf_free(wmi_buf_t net_buf); */ int wmi_unified_cmd_send(wmi_unified_t wmi_handle, wmi_buf_t buf, uint32_t buflen, - WMI_CMD_ID cmd_id); + uint32_t cmd_id); /** * wmi_unified_register_event_handler() - WMI event handler @@ -648,7 +650,8 @@ QDF_STATUS wmi_unified_dfs_phyerr_filter_offload_en_cmd(void *wmi_hdl, #ifndef WMI_NON_TLV_SUPPORT QDF_STATUS wmi_unified_pktlog_wmi_send_cmd(void *wmi_hdl, WMI_PKTLOG_EVENT pktlog_event, - WMI_CMD_ID cmd_id); + uint32_t cmd_id, + uint8_t user_triggered); #endif QDF_STATUS wmi_unified_add_wow_wakeup_event_cmd(void *wmi_hdl, @@ -762,10 +765,12 @@ QDF_STATUS wmi_unified_dcc_update_ndl(void *wmi_hdl, QDF_STATUS wmi_unified_save_fw_version_cmd(void *wmi_hdl, void *evt_buf); +#ifdef CONFIG_MCL QDF_STATUS wmi_unified_send_init_cmd(void *wmi_hdl, wmi_resource_config *res_cfg, uint8_t num_mem_chunks, struct wmi_host_mem_chunk *mem_chunk, bool action); +#endif QDF_STATUS wmi_unified_send_saved_init_cmd(void *wmi_hdl); diff --git a/wmi/inc/wmi_unified_non_tlv.h b/wmi/inc/wmi_unified_non_tlv.h index 18dc04724057..d475a6706460 100644 --- a/wmi/inc/wmi_unified_non_tlv.h +++ b/wmi/inc/wmi_unified_non_tlv.h @@ -28,7 +28,8 @@ #include #include "a_types.h" #include "wmi_unified_param.h" - +#include "legacy/wmi.h" +#include "legacy/wmi_unified.h" #include "ol_defines.h" /* Fix Me: wmi_unified_t structure definition */ QDF_STATUS send_vdev_create_cmd_non_tlv(wmi_unified_t wmi_handle, diff --git a/wmi/inc/wmi_unified_param.h b/wmi/inc/wmi_unified_param.h index 9bb8deeefdcd..39111a43eeb7 100644 --- a/wmi/inc/wmi_unified_param.h +++ b/wmi/inc/wmi_unified_param.h @@ -32,7 +32,6 @@ #ifndef _WMI_UNIFIED_PARAM_H_ #define _WMI_UNIFIED_PARAM_H_ -#include "wmi_unified.h" #define IEEE80211_ADDR_LEN 6 /* size of 802.11 address */ #define WMI_MAC_MAX_SSID_LENGTH 32 #define WMI_SCAN_MAX_NUM_SSID 0x0A @@ -70,9 +69,9 @@ #endif #define WMI_NOISE_FLOOR_DBM_DEFAULT (-96) #define WMI_MAC_IPV6_ADDR_LEN 16 -#ifdef WLAN_NS_OFFLOAD #define WMI_OFFLOAD_DISABLE 0 #define WMI_OFFLOAD_ENABLE 1 +#ifdef WLAN_NS_OFFLOAD /* support only one IPv6 offload */ #define WMI_MAC_NS_OFFLOAD_SIZE 1 /* Number of target IP V6 addresses for NS offload */ @@ -281,15 +280,15 @@ enum wmi_dwelltime_adaptive_mode { #define MAX_NUM_CHAN 128 /* WME stream classes */ -#define WMI_AC_BE 0 /* best effort */ -#define WMI_AC_BK 1 /* background */ -#define WMI_AC_VI 2 /* video */ -#define WMI_AC_VO 3 /* voice */ +#define WMI_HOST_AC_BE 0 /* best effort */ +#define WMI_HOST_AC_BK 1 /* background */ +#define WMI_HOST_AC_VI 2 /* video */ +#define WMI_HOST_AC_VO 3 /* voice */ #define WMI_TID_TO_AC(_tid) (\ - (((_tid) == 0) || ((_tid) == 3)) ? WMI_AC_BE : \ - (((_tid) == 1) || ((_tid) == 2)) ? WMI_AC_BK : \ - (((_tid) == 4) || ((_tid) == 5)) ? WMI_AC_VI : \ - WMI_AC_VO) + (((_tid) == 0) || ((_tid) == 3)) ? WMI_HOST_AC_BE : \ + (((_tid) == 1) || ((_tid) == 2)) ? WMI_HOST_AC_BK : \ + (((_tid) == 4) || ((_tid) == 5)) ? WMI_HOST_AC_VI : \ + WMI_HOST_AC_VO) /** * struct vdev_create_params - vdev create cmd parameter @@ -737,7 +736,7 @@ struct beacon_tmpl_params { uint8_t *frm; }; -#ifndef WMI_NON_TLV_SUPPORT +#ifdef CONFIG_MCL /** * struct beacon_params - beacon cmd parameter * @vdev_id: vdev id @@ -804,6 +803,16 @@ typedef struct { uint32_t rates[(WMI_MAX_SUPPORTED_RATES / 4) + 1]; } target_rate_set; +/** + * struct wmi_host_mac_addr - host mac addr 2 word representation of MAC addr + * @mac_addr31to0: upper 4 bytes of MAC address + * @mac_addr47to32: lower 2 bytes of MAC address + */ +typedef struct { + uint32_t mac_addr31to0; + uint32_t mac_addr47to32; +} wmi_host_mac_addr; + /** * struct peer_assoc_params - peer assoc cmd parameter * @peer_macaddr: peer mac address @@ -852,7 +861,7 @@ typedef struct { * @peer_mac: Peer mac address */ struct peer_assoc_params { - wmi_mac_addr peer_macaddr; + wmi_host_mac_addr peer_macaddr; uint32_t vdev_id; uint32_t peer_new_assoc; uint32_t peer_associd; @@ -867,13 +876,8 @@ struct peer_assoc_params { uint32_t peer_vht_caps; uint32_t peer_phymode; uint32_t peer_ht_info[2]; -#ifndef WMI_NON_TLV_SUPPORT - wmi_rate_set peer_legacy_rates; - wmi_rate_set peer_ht_rates; -#else target_rate_set peer_legacy_rates; target_rate_set peer_ht_rates; -#endif uint32_t rx_max_rate; uint32_t rx_mcs_set; uint32_t tx_max_rate; @@ -1051,10 +1055,28 @@ struct scan_stop_params { * @num_scan_chans: no of scan channels * @chan_info: pointer to wmi channel info */ -#ifndef WMI_NON_TLV_SUPPORT +#ifdef CONFIG_MCL +/* TODO: This needs clean-up based on how its processed. */ +typedef struct { + /* TLV tag and len; tag equals WMITLV_TAG_STRUC_wmi_channel */ + uint32_t tlv_header; + /** primary 20 MHz channel frequency in mhz */ + uint32_t mhz; + /** Center frequency 1 in MHz*/ + uint32_t band_center_freq1; + /** Center frequency 2 in MHz - valid only for 11acvht 80plus80 mode*/ + uint32_t band_center_freq2; + /** channel info described below */ + uint32_t info; + /** contains min power, max power, reg power and reg class id. */ + uint32_t reg_info_1; + /** contains antennamax */ + uint32_t reg_info_2; +} wmi_channel_param; + struct scan_chan_list_params { uint8_t num_scan_chans; - wmi_channel *chan_info; + wmi_channel_param *chan_info; }; #else /** @@ -1362,8 +1384,8 @@ enum wmi_peer_rate_report_cond_phy_type { * @delta_min: rate min delta */ struct report_rate_delta { - A_UINT32 percent; /* in unit of 12.5% */ - A_UINT32 delta_min; /* in unit of Mbps */ + uint32_t percent; /* in unit of 12.5% */ + uint32_t delta_min; /* in unit of Mbps */ }; /** @@ -1379,14 +1401,14 @@ struct report_rate_per_phy { * Any of these two conditions or both of * them can be set. */ - A_UINT32 cond_flags; + uint32_t cond_flags; struct report_rate_delta delta; /* * In unit of Mbps. There are at most 4 thresholds * If the threshold count is less than 4, set zero to * the one following the last threshold */ - A_UINT32 report_rate_threshold[WMI_MAX_NUM_OF_RATE_THRESH]; + uint32_t report_rate_threshold[WMI_MAX_NUM_OF_RATE_THRESH]; }; /** @@ -1397,9 +1419,9 @@ struct report_rate_per_phy { * @report_per_phy: report per phy type */ struct wmi_peer_rate_report_params { - A_UINT32 rate_report_enable; - A_UINT32 backoff_time; /* in unit of msecond */ - A_UINT32 timer_period; /* in unit of msecond */ + uint32_t rate_report_enable; + uint32_t backoff_time; /* in unit of msecond */ + uint32_t timer_period; /* in unit of msecond */ /* *In the following field, the array index means the phy type, * please see enum wmi_peer_rate_report_cond_phy_type for detail @@ -1615,6 +1637,33 @@ struct mobility_domain_info { uint16_t mobility_domain; }; +#define WMI_HOST_ROAM_OFFLOAD_NUM_MCS_SET (16) + +/* This TLV will be filled only in case roam offload + * for wpa2-psk/okc/ese/11r is enabled */ +typedef struct { + /* + * TLV tag and len; tag equals + * WMITLV_TAG_STRUC_wmi_roam_offload_fixed_param + */ + uint32_t tlv_header; + uint32_t rssi_cat_gap; /* gap for every category bucket */ + uint32_t prefer_5g; /* prefer select 5G candidate */ + uint32_t select_5g_margin; + uint32_t reassoc_failure_timeout; /* reassoc failure timeout */ + uint32_t capability; + uint32_t ht_caps_info; + uint32_t ampdu_param; + uint32_t ht_ext_cap; + uint32_t ht_txbf; + uint32_t asel_cap; + uint32_t qos_enabled; + uint32_t qos_caps; + uint32_t wmm_caps; + /* since this is 4 byte aligned, we don't declare it as tlv array */ + uint32_t mcsset[WMI_HOST_ROAM_OFFLOAD_NUM_MCS_SET >> 2]; +} roam_offload_param; + /* struct roam_offload_scan_params - structure * containing roaming offload scan parameters * @is_roam_req_valid: flag to tell whether roam req @@ -1663,7 +1712,7 @@ struct roam_offload_scan_params { /* THis is not available in non tlv target. * please remove this and replace with a host based * structure */ - wmi_roam_offload_tlv_param roam_offload_params; + roam_offload_param roam_offload_params; #endif }; @@ -1871,7 +1920,6 @@ struct extscan_cached_result_params { bool flush; }; -#ifdef FEATURE_WLAN_SCAN_PNO /* Set PNO */ #define WMI_PNO_MAX_NETW_CHANNELS 26 #define WMI_PNO_MAX_NETW_CHANNELS_EX 60 @@ -1968,7 +2016,6 @@ struct pno_scan_req_params { #endif }; -#endif /* FEATURE_WLAN_SCAN_PNO */ #define WMI_WLAN_EXTSCAN_MAX_CHANNELS 36 #define WMI_WLAN_EXTSCAN_MAX_BUCKETS 16 @@ -4134,16 +4181,6 @@ typedef struct { uint32_t num_chan_stats; } wmi_host_stats_event; -/** - * struct wmi_host_mac_addr - host mac addr 2 word representation of MAC addr - * @mac_addr31to0: upper 4 bytes of MAC address - * @mac_addr47to32: lower 2 bytes of MAC address - */ -typedef struct { - uint32_t mac_addr31to0; - uint32_t mac_addr47to32; -} wmi_host_mac_addr; - /** * struct wmi_host_peer_extd_stats - peer extd stats event structure * @peer_macaddr: Peer mac address @@ -4909,6 +4946,7 @@ typedef enum { wmi_vdev_param_rtscts_rate, wmi_vdev_param_mcc_rtscts_protection_enable, wmi_vdev_param_mcc_broadcast_probe_enable, + wmi_vdev_param_capabilities, wmi_vdev_param_max, } wmi_conv_vdev_param_id; diff --git a/wmi/inc/wmi_unified_priv.h b/wmi/inc/wmi_unified_priv.h index bae209b3a7a3..f54202822980 100644 --- a/wmi/inc/wmi_unified_priv.h +++ b/wmi/inc/wmi_unified_priv.h @@ -33,8 +33,6 @@ #define _WMI_UNIFIED_PRIV_H_ #include #include "a_types.h" -#include "wmi.h" -#include "wmi_unified.h" #include "wmi_unified_param.h" #include "qdf_atomic.h" @@ -250,7 +248,7 @@ QDF_STATUS (*send_stats_request_cmd)(wmi_unified_t wmi_handle, uint8_t macaddr[IEEE80211_ADDR_LEN], struct stats_request_params *param); -#ifdef WMI_NON_TLV_SUPPORT +#ifdef CONFIG_WIN QDF_STATUS (*send_packet_log_enable_cmd)(wmi_unified_t wmi_handle, WMI_HOST_PKTLOG_EVENT PKTLOG_EVENT); #else @@ -363,12 +361,6 @@ QDF_STATUS (*send_probe_rsp_tmpl_send_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_setup_install_key_cmd)(wmi_unified_t wmi_handle, struct set_key_params *key_params); -#ifndef WMI_NON_TLV_SUPPORT -QDF_STATUS (*send_process_update_edca_param_cmd)(wmi_unified_t wmi_handle, - uint8_t vdev_id, - wmi_wmm_vparams gwmm_param[WMI_MAX_NUM_AC]); -#endif - QDF_STATUS (*send_vdev_set_gtx_cfg_cmd)(wmi_unified_t wmi_handle, uint32_t if_id, struct wmi_gtx_config *gtx_info); @@ -379,10 +371,6 @@ QDF_STATUS (*send_set_sta_keep_alive_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_set_sta_sa_query_param_cmd)(wmi_unified_t wmi_handle, uint8_t vdev_id, uint32_t max_retries, uint32_t retry_interval); -#ifndef WMI_NON_TLV_SUPPORT -QDF_STATUS (*send_bcn_buf_ll_cmd)(wmi_unified_t wmi_handle, - wmi_bcn_send_from_host_cmd_fixed_param *param); -#endif QDF_STATUS (*send_set_gateway_params_cmd)(wmi_unified_t wmi_handle, struct gateway_update_req_param *req); @@ -395,11 +383,6 @@ QDF_STATUS (*send_scan_probe_setoui_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_reset_passpoint_network_list_cmd)(wmi_unified_t wmi_handle, struct wifi_passpoint_req_param *req); -#ifndef WMI_NON_TLV_SUPPORT -QDF_STATUS (*send_roam_scan_offload_mode_cmd)(wmi_unified_t wmi_handle, - wmi_start_scan_cmd_fixed_param *scan_cmd_fp, - struct roam_offload_scan_params *roam_req); -#endif QDF_STATUS (*send_roam_scan_offload_rssi_thresh_cmd)(wmi_unified_t wmi_handle, struct roam_offload_scan_rssi_params *roam_req); @@ -482,7 +465,7 @@ QDF_STATUS (*send_snr_cmd)(wmi_unified_t wmi_handle, uint8_t vdev_id); QDF_STATUS (*send_link_status_req_cmd)(wmi_unified_t wmi_handle, struct link_status_params *link_status); -#ifndef WMI_NON_TLV_SUPPORT +#ifdef CONFIG_MCL QDF_STATUS (*send_lphb_config_hbenable_cmd)(wmi_unified_t wmi_handle, wmi_hb_set_enable_cmd_fixed_param *params); @@ -506,6 +489,25 @@ QDF_STATUS (*send_get_link_speed_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_egap_conf_params_cmd)(wmi_unified_t wmi_handle, wmi_ap_ps_egap_param_cmd_fixed_param *egap_params); + +QDF_STATUS (*send_process_update_edca_param_cmd)(wmi_unified_t wmi_handle, + uint8_t vdev_id, + wmi_wmm_vparams gwmm_param[WMI_MAX_NUM_AC]); + +QDF_STATUS (*send_bcn_buf_ll_cmd)(wmi_unified_t wmi_handle, + wmi_bcn_send_from_host_cmd_fixed_param * param); + +QDF_STATUS (*send_roam_scan_offload_mode_cmd)(wmi_unified_t wmi_handle, + wmi_start_scan_cmd_fixed_param * scan_cmd_fp, + struct roam_offload_scan_params *roam_req); + +QDF_STATUS (*send_roam_scan_offload_ap_profile_cmd)(wmi_unified_t wmi_handle, + wmi_ap_profile * ap_profile_p, + uint32_t vdev_id); + +QDF_STATUS (*send_pktlog_wmi_send_cmd)(wmi_unified_t wmi_handle, + WMI_PKTLOG_EVENT pktlog_event, + WMI_CMD_ID cmd_id, uint8_t user_triggered); #endif QDF_STATUS (*send_fw_profiling_cmd)(wmi_unified_t wmi_handle, @@ -524,11 +526,6 @@ QDF_STATUS (*send_start_oem_data_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_dfs_phyerr_filter_offload_en_cmd)(wmi_unified_t wmi_handle, bool dfs_phyerr_filter_offload); -#ifndef WMI_NON_TLV_SUPPORT -QDF_STATUS (*send_pktlog_wmi_send_cmd)(wmi_unified_t wmi_handle, - WMI_PKTLOG_EVENT pktlog_event, - WMI_CMD_ID cmd_id); -#endif QDF_STATUS (*send_add_wow_wakeup_event_cmd)(wmi_unified_t wmi_handle, uint32_t vdev_id, @@ -628,10 +625,12 @@ QDF_STATUS (*send_process_fw_mem_dump_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_process_set_ie_info_cmd)(wmi_unified_t wmi_handle, struct vdev_ie_info_param *ie_info); +#ifdef CONFIG_MCL QDF_STATUS (*send_init_cmd)(wmi_unified_t wmi_handle, wmi_resource_config *res_cfg, uint8_t num_mem_chunks, struct wmi_host_mem_chunk *mem_chunk, bool action); +#endif QDF_STATUS (*save_fw_version_cmd)(wmi_unified_t wmi_handle, void *evt_buf); @@ -685,11 +684,6 @@ QDF_STATUS (*send_roam_invoke_cmd)(wmi_unified_t wmi_handle, QDF_STATUS (*send_roam_scan_offload_cmd)(wmi_unified_t wmi_handle, uint32_t command, uint32_t vdev_id); -#ifndef WMI_NON_TLV_SUPPORT -QDF_STATUS (*send_roam_scan_offload_ap_profile_cmd)(wmi_unified_t wmi_handle, - wmi_ap_profile *ap_profile_p, - uint32_t vdev_id); -#endif QDF_STATUS (*send_roam_scan_offload_scan_period_cmd)(wmi_unified_t wmi_handle, uint32_t scan_period, @@ -1160,7 +1154,7 @@ struct wmi_unified { qdf_atomic_t pending_cmds; HTC_ENDPOINT_ID wmi_endpoint_id; uint16_t max_msg_len; - WMI_EVT_ID event_id[WMI_UNIFIED_MAX_EVENT]; + uint32_t event_id[WMI_UNIFIED_MAX_EVENT]; wmi_unified_event_handler event_handler[WMI_UNIFIED_MAX_EVENT]; enum wmi_rx_exec_ctx ctx[WMI_UNIFIED_MAX_EVENT]; uint32_t max_event_idx; @@ -1208,6 +1202,8 @@ struct wmi_unified { #endif }; #ifdef WMI_NON_TLV_SUPPORT +/* ONLY_NON_TLV_TARGET:TLV attach dummy function defintion for case when + * driver supports only NON-TLV target (WIN mainline) */ #define wmi_tlv_attach(x) qdf_print("TLV Unavailable\n") #else void wmi_tlv_attach(wmi_unified_t wmi_handle); diff --git a/wmi/inc/wmi_unified_tlv.h b/wmi/inc/wmi_unified_tlv.h index 5de7bae37952..b21b40a59cc5 100644 --- a/wmi/inc/wmi_unified_tlv.h +++ b/wmi/inc/wmi_unified_tlv.h @@ -29,6 +29,8 @@ #include #include "a_types.h" #include "wmi_unified_param.h" +#include "wmi.h" +#include "wmi_unified.h" #include "ol_defines.h" /* Fix Me: wmi_unified_t structure definition */ QDF_STATUS send_vdev_create_cmd_tlv(wmi_unified_t wmi_handle, @@ -115,10 +117,14 @@ QDF_STATUS send_stats_request_cmd_tlv(wmi_unified_t wmi_handle, uint8_t macaddr[IEEE80211_ADDR_LEN], struct stats_request_params *param); +#ifdef CONFIG_WIN +QDF_STATUS send_packet_log_enable_cmd_tlv(wmi_unified_t wmi_handle, + WMI_HOST_PKTLOG_EVENT PKTLOG_EVENT); +#else QDF_STATUS send_packet_log_enable_cmd_tlv(wmi_unified_t wmi_handle, uint8_t macaddr[IEEE80211_ADDR_LEN], struct packet_enable_params *param); - +#endif QDF_STATUS send_beacon_send_cmd_tlv(wmi_unified_t wmi_handle, struct beacon_params *param); @@ -373,7 +379,7 @@ send_dfs_phyerr_filter_offload_en_cmd_tlv(wmi_unified_t wmi_handle, QDF_STATUS send_pktlog_wmi_send_cmd_tlv(wmi_unified_t wmi_handle, WMI_PKTLOG_EVENT pktlog_event, - WMI_CMD_ID cmd_id); + WMI_CMD_ID cmd_id, uint8_t user_triggered); QDF_STATUS send_add_wow_wakeup_event_cmd_tlv(wmi_unified_t wmi_handle, uint32_t vdev_id, diff --git a/wmi/src/wmi_tlv_platform.c b/wmi/src/wmi_tlv_platform.c index 22e0befccffe..d7858aed6d4f 100644 --- a/wmi/src/wmi_tlv_platform.c +++ b/wmi/src/wmi_tlv_platform.c @@ -47,7 +47,7 @@ #ifndef NO_DYNAMIC_MEM_ALLOC #define wmi_tlv_os_mem_alloc(scn, ptr, numBytes) \ { \ - (ptr) = os_malloc(NULL, (numBytes), GFP_ATOMIC); \ + (ptr) = qdf_mem_malloc(numBytes); \ } #define wmi_tlv_os_mem_free qdf_mem_free #endif diff --git a/wmi/src/wmi_unified.c b/wmi/src/wmi_unified.c index fa51a843e4e6..4b4fa5fae023 100644 --- a/wmi/src/wmi_unified.c +++ b/wmi/src/wmi_unified.c @@ -37,12 +37,62 @@ #include "htc_api.h" #include "htc_api.h" #include "dbglog_host.h" -#include "wmi.h" #include "wmi_unified_priv.h" #include "wmi_unified_param.h" #include +/* This check for CONFIG_WIN temporary added due to redeclaration compilation +error in MCL. Error is caused due to inclusion of wmi.h in wmi_unified_api.h +which gets included here through ol_if_athvar.h. Eventually it is expected that +wmi.h will be removed from wmi_unified_api.h after cleanup, which will need +WMI_CMD_HDR to be defined here. */ +#ifdef CONFIG_WIN +/* Copied from wmi.h */ +#undef MS +#define MS(_v, _f) (((_v) & _f##_MASK) >> _f##_LSB) +#undef SM +#define SM(_v, _f) (((_v) << _f##_LSB) & _f##_MASK) +#undef WO +#define WO(_f) ((_f##_OFFSET) >> 2) + +#undef GET_FIELD +#define GET_FIELD(_addr, _f) MS(*((A_UINT32 *)(_addr) + WO(_f)), _f) +#undef SET_FIELD +#define SET_FIELD(_addr, _f, _val) \ + (*((A_UINT32 *)(_addr) + WO(_f)) = \ + (*((A_UINT32 *)(_addr) + WO(_f)) & ~_f##_MASK) | SM(_val, _f)) + +#define WMI_GET_FIELD(_msg_buf, _msg_type, _f) \ + GET_FIELD(_msg_buf, _msg_type ## _ ## _f) + +#define WMI_SET_FIELD(_msg_buf, _msg_type, _f, _val) \ + SET_FIELD(_msg_buf, _msg_type ## _ ## _f, _val) + +#define WMI_EP_APASS 0x0 +#define WMI_EP_LPASS 0x1 +#define WMI_EP_SENSOR 0x2 + +/* + * * Control Path + * */ +typedef PREPACK struct { + A_UINT32 commandId:24, + reserved:2, /* used for WMI endpoint ID */ + plt_priv:6; /* platform private */ +} POSTPACK WMI_CMD_HDR; /* used for commands and events */ + +#define WMI_CMD_HDR_COMMANDID_LSB 0 +#define WMI_CMD_HDR_COMMANDID_MASK 0x00ffffff +#define WMI_CMD_HDR_COMMANDID_OFFSET 0x00000000 +#define WMI_CMD_HDR_WMI_ENDPOINTID_MASK 0x03000000 +#define WMI_CMD_HDR_WMI_ENDPOINTID_OFFSET 24 +#define WMI_CMD_HDR_PLT_PRIV_LSB 24 +#define WMI_CMD_HDR_PLT_PRIV_MASK 0xff000000 +#define WMI_CMD_HDR_PLT_PRIV_OFFSET 0x00000000 +/* end of copy wmi.h */ +#endif /* CONFIG_WIN */ + #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 3, 0)) /* TODO Cleanup this backported function */ int qcacld_bp_seq_printf(struct seq_file *m, const char *f, ...) @@ -241,7 +291,7 @@ uint32_t wmi_mgmt_log_max_entry = WMI_MGMT_EVENT_DEBUG_MAX_ENTRY; uint32_t wmi_record_max_length = WMI_EVENT_DEBUG_ENTRY_MAX_LENGTH; uint32_t wmi_display_size = 100; -static uint8_t *wmi_id_to_name(WMI_CMD_ID wmi_command); +static uint8_t *wmi_id_to_name(uint32_t wmi_command); /** * wmi_log_init() - Initialize WMI event logging @@ -898,7 +948,7 @@ static QDF_STATUS wmi_debugfs_init(wmi_unified_t wmi_handle) * * Return: none */ -void wmi_mgmt_cmd_record(wmi_unified_t wmi_handle, WMI_CMD_ID cmd, +void wmi_mgmt_cmd_record(wmi_unified_t wmi_handle, uint32_t cmd, void *header, uint32_t vdev_id, uint32_t chanfreq) { qdf_spin_lock_bh(&wmi_handle->log_info.wmi_record_lock); @@ -920,7 +970,7 @@ void wmi_mgmt_cmd_record(wmi_unified_t wmi_handle, WMI_CMD_ID cmd, * Return: none */ static void wmi_debugfs_remove(wmi_unified_t wmi_handle) { } -void wmi_mgmt_cmd_record(wmi_unified_t wmi_handle, WMI_CMD_ID cmd, +void wmi_mgmt_cmd_record(wmi_unified_t wmi_handle, uint32_t cmd, void *header, uint32_t vdev_id, uint32_t chanfreq) { } #endif /*WMI_INTERFACE_EVENT_LOGGING */ @@ -1007,7 +1057,7 @@ uint16_t wmi_get_max_msg_len(wmi_unified_t wmi_handle) } #ifndef WMI_NON_TLV_SUPPORT -static uint8_t *wmi_id_to_name(WMI_CMD_ID wmi_command) +static uint8_t *wmi_id_to_name(uint32_t wmi_command) { switch (wmi_command) { /* initialize the wlan sub system */ @@ -1583,18 +1633,20 @@ static uint8_t *wmi_id_to_name(WMI_CMD_ID wmi_command) CASE_RETURN_STRING(WMI_PDEV_SET_WAKEUP_CONFIG_CMDID); CASE_RETURN_STRING(WMI_PDEV_GET_ANTDIV_STATUS_CMDID); CASE_RETURN_STRING(WMI_PEER_ANTDIV_INFO_REQ_CMDID); + CASE_RETURN_STRING(WMI_MNT_FILTER_CMDID); + CASE_RETURN_STRING(WMI_PDEV_GET_CHIP_POWER_STATS_CMDID); } return "Invalid WMI cmd"; } -static inline void wma_log_cmd_id(WMI_CMD_ID cmd_id) +static inline void wma_log_cmd_id(uint32_t cmd_id) { WMI_LOGD("Send WMI command:%s command_id:%d", wmi_id_to_name(cmd_id), cmd_id); } #else -static uint8_t *wmi_id_to_name(WMI_CMD_ID wmi_command) +static uint8_t *wmi_id_to_name(uint32_t wmi_command) { return "Invalid WMI cmd"; } @@ -1608,7 +1660,7 @@ static uint8_t *wmi_id_to_name(WMI_CMD_ID wmi_command) * Return: true if the command is part of the suspend resume sequence. */ #ifndef WMI_NON_TLV_SUPPORT -static bool wmi_is_runtime_pm_cmd(WMI_CMD_ID cmd_id) +static bool wmi_is_runtime_pm_cmd(uint32_t cmd_id) { switch (cmd_id) { case WMI_WOW_ENABLE_CMDID: @@ -1632,7 +1684,7 @@ static bool wmi_is_runtime_pm_cmd(WMI_CMD_ID cmd_id) * * Return: true if the command is part of the resume sequence. */ -static bool wmi_is_pm_resume_cmd(WMI_CMD_ID cmd_id) +static bool wmi_is_pm_resume_cmd(uint32_t cmd_id) { switch (cmd_id) { case WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID: @@ -1644,11 +1696,11 @@ static bool wmi_is_pm_resume_cmd(WMI_CMD_ID cmd_id) } } #else -static bool wmi_is_runtime_pm_cmd(WMI_CMD_ID cmd_id) +static bool wmi_is_runtime_pm_cmd(uint32_t cmd_id) { return false; } -static bool wmi_is_pm_resume_cmd(WMI_CMD_ID cmd_id) +static bool wmi_is_pm_resume_cmd(uint32_t cmd_id) { return false; } @@ -1664,7 +1716,7 @@ static bool wmi_is_pm_resume_cmd(WMI_CMD_ID cmd_id) * Return: 0 on success */ int wmi_unified_cmd_send(wmi_unified_t wmi_handle, wmi_buf_t buf, uint32_t len, - WMI_CMD_ID cmd_id) + uint32_t cmd_id) { HTC_PACKET *pkt; A_STATUS status; diff --git a/wmi/src/wmi_unified_api.c b/wmi/src/wmi_unified_api.c index f9b5884d97d9..86a79f31f94f 100644 --- a/wmi/src/wmi_unified_api.c +++ b/wmi/src/wmi_unified_api.c @@ -30,7 +30,6 @@ #include "a_debug.h" #include "ol_if_athvar.h" #include "ol_defines.h" -#include "wmi.h" #include "wmi_unified_priv.h" #include "wmi_unified_param.h" @@ -2313,13 +2312,14 @@ wmi_unified_dfs_phyerr_filter_offload_en_cmd(void *wmi_hdl, #ifndef WMI_NON_TLV_SUPPORT QDF_STATUS wmi_unified_pktlog_wmi_send_cmd(void *wmi_hdl, WMI_PKTLOG_EVENT pktlog_event, - WMI_CMD_ID cmd_id) + uint32_t cmd_id, + uint8_t user_triggered) { wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; if (wmi_handle->ops->send_pktlog_wmi_send_cmd) return wmi_handle->ops->send_pktlog_wmi_send_cmd(wmi_handle, - pktlog_event, cmd_id); + pktlog_event, cmd_id, user_triggered); return QDF_STATUS_E_FAILURE; } @@ -2902,7 +2902,7 @@ QDF_STATUS wmi_unified_process_set_ie_info_cmd(void *wmi_hdl, return QDF_STATUS_E_FAILURE; } - +#ifdef CONFIG_MCL /** * wmi_unified_send_init_cmd() - wmi init command * @wmi_handle: pointer to wmi handle @@ -2928,7 +2928,7 @@ QDF_STATUS wmi_unified_send_init_cmd(void *wmi_hdl, return QDF_STATUS_E_FAILURE; } - +#endif /** * wmi_unified_send_saved_init_cmd() - wmi init command * @wmi_handle: pointer to wmi handle diff --git a/wmi/src/wmi_unified_non_tlv.c b/wmi/src/wmi_unified_non_tlv.c index 71913b9d75bd..ae886ad25a82 100644 --- a/wmi/src/wmi_unified_non_tlv.c +++ b/wmi/src/wmi_unified_non_tlv.c @@ -31,11 +31,12 @@ #include "a_debug.h" #include "ol_if_athvar.h" #include "ol_defines.h" -#include "wmi.h" #include "wmi_unified_api.h" #include "wmi_unified_priv.h" #ifdef WMI_NON_TLV_SUPPORT +#include "legacy/wmi.h" +#include "legacy/wmi_unified.h" /** * send_vdev_create_cmd_non_tlv() - send VDEV create command to fw * @wmi_handle: wmi handle diff --git a/wmi/src/wmi_unified_tlv.c b/wmi/src/wmi_unified_tlv.c index c9f0b0da7ca8..44a2738efb0e 100644 --- a/wmi/src/wmi_unified_tlv.c +++ b/wmi/src/wmi_unified_tlv.c @@ -1157,6 +1157,21 @@ QDF_STATUS send_stats_request_cmd_tlv(wmi_unified_t wmi_handle, return ret; } +#ifdef CONFIG_WIN +/** + * send_packet_log_enable_cmd_tlv() - WMI request stats function + * @param wmi_handle : handle to WMI. + * @param macaddr : MAC address + * @param param : pointer to hold stats request parameter + * + * Return: 0 on success and -ve on failure. + */ +QDF_STATUS send_packet_log_enable_cmd_tlv(wmi_unified_t wmi_handle, + WMI_HOST_PKTLOG_EVENT PKTLOG_EVENT) +{ + return 0; +} +#else /** * send_packet_log_enable_cmd_tlv() - WMI request stats function * @param wmi_handle : handle to WMI. @@ -1171,7 +1186,9 @@ QDF_STATUS send_packet_log_enable_cmd_tlv(wmi_unified_t wmi_handle, { return 0; } +#endif +#ifdef CONFIG_MCL /** * send_beacon_send_cmd_tlv() - WMI beacon send function * @param wmi_handle : handle to WMI. @@ -1227,6 +1244,69 @@ QDF_STATUS send_beacon_send_cmd_tlv(wmi_unified_t wmi_handle, } return 0; } +#else +QDF_STATUS send_beacon_send_cmd_tlv(wmi_unified_t wmi_handle, + struct beacon_params *param) +{ + return 0; +} + +/** + * send_beacon_send_tmpl_cmd_tlv() - WMI beacon send function + * @param wmi_handle : handle to WMI. + * @param param : pointer to hold beacon send cmd parameter + * + * Return: 0 on success and -ve on failure. + */ +QDF_STATUS send_beacon_tmpl_send_cmd_tlv(wmi_unified_t wmi_handle, + struct beacon_tmpl_params *param) +{ + int32_t ret; + wmi_bcn_tmpl_cmd_fixed_param *cmd; + wmi_bcn_prb_info *bcn_prb_info; + wmi_buf_t wmi_buf; + uint8_t *buf_ptr; + uint32_t wmi_buf_len; + + wmi_buf_len = sizeof(wmi_bcn_tmpl_cmd_fixed_param) + + sizeof(wmi_bcn_prb_info) + WMI_TLV_HDR_SIZE + + param->tmpl_len_aligned; + wmi_buf = wmi_buf_alloc(wmi_handle, wmi_buf_len); + if (!wmi_buf) { + WMI_LOGE("%s : wmi_buf_alloc failed", __func__); + return QDF_STATUS_E_NOMEM; + } + buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf); + cmd = (wmi_bcn_tmpl_cmd_fixed_param *) buf_ptr; + WMITLV_SET_HDR(&cmd->tlv_header, + WMITLV_TAG_STRUC_wmi_bcn_tmpl_cmd_fixed_param, + WMITLV_GET_STRUCT_TLVLEN(wmi_bcn_tmpl_cmd_fixed_param)); + cmd->vdev_id = param->vdev_id; + cmd->tim_ie_offset = param->tim_ie_offset; + cmd->buf_len = param->tmpl_len; + buf_ptr += sizeof(wmi_bcn_tmpl_cmd_fixed_param); + + bcn_prb_info = (wmi_bcn_prb_info *) buf_ptr; + WMITLV_SET_HDR(&bcn_prb_info->tlv_header, + WMITLV_TAG_STRUC_wmi_bcn_prb_info, + WMITLV_GET_STRUCT_TLVLEN(wmi_bcn_prb_info)); + bcn_prb_info->caps = 0; + bcn_prb_info->erp = 0; + buf_ptr += sizeof(wmi_bcn_prb_info); + + WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, param->tmpl_len_aligned); + buf_ptr += WMI_TLV_HDR_SIZE; + qdf_mem_copy(buf_ptr, param->frm, param->tmpl_len); + + ret = wmi_unified_cmd_send(wmi_handle, + wmi_buf, wmi_buf_len, WMI_BCN_TMPL_CMDID); + if (ret) { + WMI_LOGE("%s: Failed to send bcn tmpl: %d", __func__, ret); + wmi_buf_free(wmi_buf); + } + return 0; +} +#endif /** * send_peer_assoc_cmd_tlv() - WMI peer assoc function @@ -1512,6 +1592,7 @@ error: return ret; } +#ifdef CONFIG_MCL /** * send_scan_chan_list_cmd_tlv() - WMI scan channel list function * @param wmi_handle : handle to WMI. @@ -1527,7 +1608,7 @@ QDF_STATUS send_scan_chan_list_cmd_tlv(wmi_unified_t wmi_handle, wmi_scan_chan_list_cmd_fixed_param *cmd; int i; uint8_t *buf_ptr; - wmi_channel *chan_info, *tchan_info; + wmi_channel_param *chan_info, *tchan_info; uint16_t len = sizeof(*cmd) + WMI_TLV_HDR_SIZE; len += sizeof(wmi_channel) * chan_list->num_scan_chans; @@ -1551,7 +1632,8 @@ QDF_STATUS send_scan_chan_list_cmd_tlv(wmi_unified_t wmi_handle, WMITLV_SET_HDR((buf_ptr + sizeof(wmi_scan_chan_list_cmd_fixed_param)), WMITLV_TAG_ARRAY_STRUC, sizeof(wmi_channel) * chan_list->num_scan_chans); - chan_info = (wmi_channel *) (buf_ptr + sizeof(*cmd) + WMI_TLV_HDR_SIZE); + chan_info = (wmi_channel_param *) + (buf_ptr + sizeof(*cmd) + WMI_TLV_HDR_SIZE); tchan_info = chan_list->chan_info; for (i = 0; i < chan_list->num_scan_chans; ++i) { @@ -1586,7 +1668,74 @@ QDF_STATUS send_scan_chan_list_cmd_tlv(wmi_unified_t wmi_handle, end: return qdf_status; } +#else +QDF_STATUS send_scan_chan_list_cmd_tlv(wmi_unified_t wmi_handle, + struct scan_chan_list_params *chan_list) +{ + wmi_buf_t buf; + QDF_STATUS qdf_status; + wmi_scan_chan_list_cmd_fixed_param *cmd; + int i; + uint8_t *buf_ptr; + wmi_channel *chan_info; + struct channel_param *tchan_info; + uint16_t len = sizeof(*cmd) + WMI_TLV_HDR_SIZE; + len += sizeof(wmi_channel) * chan_list->num_chan; + buf = wmi_buf_alloc(wmi_handle, len); + if (!buf) { + WMI_LOGE("Failed to allocate memory"); + qdf_status = QDF_STATUS_E_NOMEM; + goto end; + } + + buf_ptr = (uint8_t *) wmi_buf_data(buf); + cmd = (wmi_scan_chan_list_cmd_fixed_param *) buf_ptr; + WMITLV_SET_HDR(&cmd->tlv_header, + WMITLV_TAG_STRUC_wmi_scan_chan_list_cmd_fixed_param, + WMITLV_GET_STRUCT_TLVLEN + (wmi_scan_chan_list_cmd_fixed_param)); + + WMI_LOGD("no of channels = %d, len = %d", chan_list->num_chan, len); + + cmd->num_scan_chans = chan_list->num_chan; + WMITLV_SET_HDR((buf_ptr + sizeof(wmi_scan_chan_list_cmd_fixed_param)), + WMITLV_TAG_ARRAY_STRUC, + sizeof(wmi_channel) * chan_list->num_chan); + chan_info = (wmi_channel *) (buf_ptr + sizeof(*cmd) + WMI_TLV_HDR_SIZE); + tchan_info = &(chan_list->ch_param[0]); + + for (i = 0; i < chan_list->num_chan; ++i) { + WMITLV_SET_HDR(&chan_info->tlv_header, + WMITLV_TAG_STRUC_wmi_channel, + WMITLV_GET_STRUCT_TLVLEN(wmi_channel)); + chan_info->mhz = tchan_info->mhz; + chan_info->band_center_freq1 = + tchan_info->cfreq1; + chan_info->band_center_freq2 = + tchan_info->cfreq2; + + WMI_LOGD("chan[%d] = %u", i, chan_info->mhz); + + /*TODO: Set WMI_SET_CHANNEL_MIN_POWER */ + /*TODO: Set WMI_SET_CHANNEL_ANTENNA_MAX */ + /*TODO: WMI_SET_CHANNEL_REG_CLASSID */ + tchan_info++; + chan_info++; + } + + qdf_status = wmi_unified_cmd_send(wmi_handle, buf, len, + WMI_SCAN_CHAN_LIST_CMDID); + + if (QDF_IS_STATUS_ERROR(qdf_status)) { + WMI_LOGE("Failed to send WMI_SCAN_CHAN_LIST_CMDID"); + wmi_buf_free(buf); + } + +end: + return qdf_status; +} +#endif /** * send_mgmt_cmd_tlv() - WMI scan start function * @wmi_handle : handle to WMI. @@ -3534,12 +3683,12 @@ QDF_STATUS send_setup_install_key_cmd_tlv(wmi_unified_t wmi_handle, cmd->key_txmic_len = key_params->key_txmic_len; cmd->key_rxmic_len = key_params->key_rxmic_len; } - +#ifdef FEATURE_WLAN_WAPI wmi_update_wpi_key_counter(cmd->wpi_key_tsc_counter, key_params->tx_iv, cmd->wpi_key_rsc_counter, key_params->rx_iv); - +#endif buf_ptr += sizeof(wmi_vdev_install_key_cmd_fixed_param); WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, roundup(key_params->key_len, sizeof(uint32_t))); @@ -5094,9 +5243,12 @@ QDF_STATUS wmi_get_buf_extscan_start_cmd(wmi_unified_t wmi_handle, cmd->configuration_flags |= WMI_EXTSCAN_EXTENDED_BATCHING_EN; WMI_LOGI("%s: configuration_flags: 0x%x", __func__, cmd->configuration_flags); - +#ifdef FEATURE_WLAN_EXTSCAN cmd->min_rest_time = WMI_EXTSCAN_REST_TIME; cmd->max_rest_time = WMI_EXTSCAN_REST_TIME; + cmd->max_scan_time = WMI_EXTSCAN_MAX_SCAN_TIME; + cmd->burst_duration = WMI_EXTSCAN_BURST_DURATION; +#endif cmd->max_bssids_per_scan_cycle = pstart->maxAPperScan; /* The max dwell time is retrieved from the first channel @@ -5112,11 +5264,9 @@ QDF_STATUS wmi_get_buf_extscan_start_cmd(wmi_unified_t wmi_handle, cmd->repeat_probe_time = cmd->max_dwell_time_active / WMI_SCAN_NPROBES_DEFAULT; - cmd->max_scan_time = WMI_EXTSCAN_MAX_SCAN_TIME; cmd->probe_delay = 0; cmd->probe_spacing_time = 0; cmd->idle_time = 0; - cmd->burst_duration = WMI_EXTSCAN_BURST_DURATION; cmd->scan_ctrl_flags = WMI_SCAN_ADD_BCAST_PROBE_REQ | WMI_SCAN_ADD_CCK_RATES | WMI_SCAN_ADD_OFDM_RATES | @@ -5506,11 +5656,13 @@ static void wmi_set_pno_channel_prediction(uint8_t *buf_ptr, WMITLV_SET_HDR(&channel_prediction_cfg->tlv_header, WMITLV_TAG_ARRAY_BYTE, WMITLV_GET_STRUCT_TLVLEN(nlo_channel_prediction_cfg)); +#ifdef FEATURE_WLAN_SCAN_PNO channel_prediction_cfg->enable = pno->pno_channel_prediction; channel_prediction_cfg->top_k_num = pno->top_k_num_of_channels; channel_prediction_cfg->stationary_threshold = pno->stationary_thresh; channel_prediction_cfg->full_scan_period_ms = pno->channel_prediction_full_scan; +#endif buf_ptr += sizeof(nlo_channel_prediction_cfg); WMI_LOGD("enable: %d, top_k_num: %d, stat_thresh: %d, full_scan: %d", channel_prediction_cfg->enable, @@ -5570,8 +5722,10 @@ QDF_STATUS send_pno_start_cmd_tlv(wmi_unified_t wmi_handle, cmd->vdev_id = pno->sessionId; cmd->flags = WMI_NLO_CONFIG_START | WMI_NLO_CONFIG_SSID_HIDE_EN; +#ifdef FEATURE_WLAN_SCAN_PNO WMI_SCAN_SET_DWELL_MODE(cmd->flags, pno->pnoscan_adaptive_dwell_mode); +#endif /* Current FW does not support min-max range for dwell time */ cmd->active_dwell_time = pno->active_max_time; cmd->passive_dwell_time = pno->passive_max_time; @@ -5679,7 +5833,7 @@ QDF_STATUS send_set_ric_req_cmd_tlv(wmi_unified_t wmi_handle, wmi_ric_tspec *tspec_param; wmi_buf_t buf; uint8_t *buf_ptr; - struct mac_tspec_ie *ptspecIE; + struct mac_tspec_ie *ptspecIE = NULL; int32_t len = sizeof(wmi_ric_request_fixed_param) + WMI_TLV_HDR_SIZE + sizeof(wmi_ric_tspec); @@ -5713,34 +5867,36 @@ QDF_STATUS send_set_ric_req_cmd_tlv(wmi_unified_t wmi_handle, if (is_add_ts) ptspecIE = &(((struct add_ts_param *) msg)->tspec); +#ifdef WLAN_FEATURE_ROAM_OFFLOAD else ptspecIE = &(((struct del_ts_params *) msg)->delTsInfo.tspec); - - /* Fill the tsinfo in the format expected by firmware */ +#endif + if (ptspecIE) { + /* Fill the tsinfo in the format expected by firmware */ #ifndef ANI_LITTLE_BIT_ENDIAN - qdf_mem_copy(((uint8_t *) &tspec_param->ts_info) + 1, - ((uint8_t *) &ptspecIE->tsinfo) + 1, 2); + qdf_mem_copy(((uint8_t *) &tspec_param->ts_info) + 1, + ((uint8_t *) &ptspecIE->tsinfo) + 1, 2); #else - qdf_mem_copy(((uint8_t *) &tspec_param->ts_info), - ((uint8_t *) &ptspecIE->tsinfo) + 1, 2); + qdf_mem_copy(((uint8_t *) &tspec_param->ts_info), + ((uint8_t *) &ptspecIE->tsinfo) + 1, 2); #endif /* ANI_LITTLE_BIT_ENDIAN */ - tspec_param->nominal_msdu_size = ptspecIE->nomMsduSz; - tspec_param->maximum_msdu_size = ptspecIE->maxMsduSz; - tspec_param->min_service_interval = ptspecIE->minSvcInterval; - tspec_param->max_service_interval = ptspecIE->maxSvcInterval; - tspec_param->inactivity_interval = ptspecIE->inactInterval; - tspec_param->suspension_interval = ptspecIE->suspendInterval; - tspec_param->svc_start_time = ptspecIE->svcStartTime; - tspec_param->min_data_rate = ptspecIE->minDataRate; - tspec_param->mean_data_rate = ptspecIE->meanDataRate; - tspec_param->peak_data_rate = ptspecIE->peakDataRate; - tspec_param->max_burst_size = ptspecIE->maxBurstSz; - tspec_param->delay_bound = ptspecIE->delayBound; - tspec_param->min_phy_rate = ptspecIE->minPhyRate; - tspec_param->surplus_bw_allowance = ptspecIE->surplusBw; - tspec_param->medium_time = 0; - + tspec_param->nominal_msdu_size = ptspecIE->nomMsduSz; + tspec_param->maximum_msdu_size = ptspecIE->maxMsduSz; + tspec_param->min_service_interval = ptspecIE->minSvcInterval; + tspec_param->max_service_interval = ptspecIE->maxSvcInterval; + tspec_param->inactivity_interval = ptspecIE->inactInterval; + tspec_param->suspension_interval = ptspecIE->suspendInterval; + tspec_param->svc_start_time = ptspecIE->svcStartTime; + tspec_param->min_data_rate = ptspecIE->minDataRate; + tspec_param->mean_data_rate = ptspecIE->meanDataRate; + tspec_param->peak_data_rate = ptspecIE->peakDataRate; + tspec_param->max_burst_size = ptspecIE->maxBurstSz; + tspec_param->delay_bound = ptspecIE->delayBound; + tspec_param->min_phy_rate = ptspecIE->minPhyRate; + tspec_param->surplus_bw_allowance = ptspecIE->surplusBw; + tspec_param->medium_time = 0; + } WMI_LOGI("%s: Set RIC Req is_add_ts:%d", __func__, is_add_ts); if (wmi_unified_cmd_send(wmi_handle, buf, len, @@ -6916,7 +7072,7 @@ send_dfs_phyerr_filter_offload_en_cmd_tlv(wmi_unified_t wmi_handle, */ QDF_STATUS send_pktlog_wmi_send_cmd_tlv(wmi_unified_t wmi_handle, WMI_PKTLOG_EVENT pktlog_event, - WMI_CMD_ID cmd_id) + WMI_CMD_ID cmd_id, uint8_t user_triggered) { WMI_PKTLOG_EVENT PKTLOG_EVENT; WMI_CMD_ID CMD_ID; @@ -6943,6 +7099,8 @@ QDF_STATUS send_pktlog_wmi_send_cmd_tlv(wmi_unified_t wmi_handle, WMITLV_GET_STRUCT_TLVLEN (wmi_pdev_pktlog_enable_cmd_fixed_param)); cmd->evlist = PKTLOG_EVENT; + cmd->enable = user_triggered ? WMI_PKTLOG_ENABLE_FORCE + : WMI_PKTLOG_ENABLE_AUTO; cmd->pdev_id = WMI_PDEV_ID_SOC; if (wmi_unified_cmd_send(wmi_handle, buf, len, WMI_PDEV_PKTLOG_ENABLE_CMDID)) { @@ -7119,7 +7277,7 @@ QDF_STATUS send_wow_patterns_to_fw_cmd_tlv(wmi_unified_t wmi_handle, WMI_LOGI("vdev id : %d, ptrn id: %d, ptrn len: %d, ptrn offset: %d user %d", cmd->vdev_id, cmd->pattern_id, bitmap_pattern->pattern_len, bitmap_pattern->pattern_offset, user); - +#ifdef CONFIG_MCL WMI_LOGI("Pattern : "); QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_INFO, &bitmap_pattern->patternbuf[0], bitmap_pattern->pattern_len); @@ -7127,6 +7285,7 @@ QDF_STATUS send_wow_patterns_to_fw_cmd_tlv(wmi_unified_t wmi_handle, WMI_LOGI("Mask : "); QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_INFO, &bitmap_pattern->bitmaskbuf[0], bitmap_pattern->pattern_len); +#endif buf_ptr += sizeof(WOW_BITMAP_PATTERN_T); @@ -8868,7 +9027,7 @@ void wmi_copy_resource_config(wmi_resource_config *resource_cfg, tgt_res_cfg->num_ocb_schedules; } - +#ifdef CONFIG_MCL /** * send_init_cmd_tlv() - wmi init command * @wmi_handle: pointer to wmi handle @@ -8950,12 +9109,14 @@ QDF_STATUS send_init_cmd_tlv(wmi_unified_t wmi_handle, my_vers.abi_version_ns_1 = WMI_ABI_VERSION_NS_1; my_vers.abi_version_ns_2 = WMI_ABI_VERSION_NS_2; my_vers.abi_version_ns_3 = WMI_ABI_VERSION_NS_3; - +#ifdef CONFIG_MCL + /* This needs to be enabled for WIN Lithium after removing dependency + * on wmi_unified.h from priv.h for using wmi_abi_version type */ wmi_cmp_and_set_abi_version(num_whitelist, version_whitelist, &my_vers, &wmi_handle->fw_abi_version, &cmd->host_abi_vers); - +#endif WMI_LOGD("%s: INIT_CMD version: %d, %d, 0x%x, 0x%x, 0x%x, 0x%x", __func__, WMI_VER_GET_MAJOR(cmd->host_abi_vers.abi_version_0), WMI_VER_GET_MINOR(cmd->host_abi_vers.abi_version_0), @@ -8963,13 +9124,13 @@ QDF_STATUS send_init_cmd_tlv(wmi_unified_t wmi_handle, cmd->host_abi_vers.abi_version_ns_1, cmd->host_abi_vers.abi_version_ns_2, cmd->host_abi_vers.abi_version_ns_3); - +#ifdef CONFIG_MCL /* Save version sent from host - * Will be used to check ready event */ qdf_mem_copy(&wmi_handle->final_abi_vers, &cmd->host_abi_vers, sizeof(wmi_abi_version)); - +#endif if (action) { ret = wmi_unified_cmd_send(wmi_handle, buf, len, WMI_INIT_CMDID); @@ -8986,7 +9147,7 @@ QDF_STATUS send_init_cmd_tlv(wmi_unified_t wmi_handle, return QDF_STATUS_SUCCESS; } - +#endif /** * send_saved_init_cmd_tlv() - wmi init command * @wmi_handle: pointer to wmi handle @@ -9032,11 +9193,14 @@ QDF_STATUS save_fw_version_cmd_tlv(wmi_unified_t wmi_handle, void *evt_buf) if (!ev) return QDF_STATUS_E_FAILURE; +#ifdef CONFIG_MCL + /* TODO:This needs to be enabled for WIN Lithium after removing dependen + * on wmi_unified.h from priv.h for using wmi_abi_version type */ /*Save fw version from service ready message */ /*This will be used while sending INIT message */ qdf_mem_copy(&wmi_handle->fw_abi_version, &ev->fw_abi_vers, sizeof(wmi_handle->fw_abi_version)); - +#endif return QDF_STATUS_SUCCESS; } @@ -9060,7 +9224,9 @@ QDF_STATUS check_and_update_fw_version_cmd_tlv(wmi_unified_t wmi_handle, param_buf = (WMI_READY_EVENTID_param_tlvs *) evt_buf; ev = param_buf->fixed_param; - +#ifdef CONFIG_MCL + /* TODO:This needs to be enabled for WIN Lithium after removing dependen + * on wmi_unified.h from priv.h for using wmi_abi_version type */ if (!wmi_versions_are_compatible(&wmi_handle->final_abi_vers, &ev->fw_abi_vers)) { /* @@ -9091,7 +9257,7 @@ QDF_STATUS check_and_update_fw_version_cmd_tlv(wmi_unified_t wmi_handle, sizeof(wmi_abi_version)); qdf_mem_copy(&wmi_handle->fw_abi_version, &ev->fw_abi_vers, sizeof(wmi_abi_version)); - +#endif return QDF_STATUS_SUCCESS; } @@ -10607,11 +10773,12 @@ static QDF_STATUS init_cmd_send_tlv(wmi_unified_t wmi_handle, my_vers.abi_version_ns_2 = WMI_ABI_VERSION_NS_2; my_vers.abi_version_ns_3 = WMI_ABI_VERSION_NS_3; +#ifdef CONFIG_MCL wmi_cmp_and_set_abi_version(num_whitelist, version_whitelist, &my_vers, (struct _wmi_abi_version *)&wmi_handle->fw_abi_version, &cmd->host_abi_vers); - +#endif qdf_print("%s: INIT_CMD version: %d, %d, 0x%x, 0x%x, 0x%x, 0x%x", __func__, WMI_VER_GET_MAJOR(cmd->host_abi_vers.abi_version_0), @@ -10624,9 +10791,10 @@ static QDF_STATUS init_cmd_send_tlv(wmi_unified_t wmi_handle, /* Save version sent from host - * Will be used to check ready event */ +#ifdef CONFIG_MCL qdf_mem_copy(&wmi_handle->final_abi_vers, &cmd->host_abi_vers, sizeof(wmi_abi_version)); - +#endif return wmi_unified_cmd_send(wmi_handle, buf, len, WMI_INIT_CMDID); } @@ -10793,11 +10961,12 @@ save_fw_version_in_service_ready_tlv(wmi_unified_t wmi_handle, void *evt_buf) return QDF_STATUS_E_FAILURE; } +#ifdef CONFIG_MCL /*Save fw version from service ready message */ /*This will be used while sending INIT message */ qdf_mem_copy(&wmi_handle->fw_abi_version, &ev->fw_abi_vers, sizeof(wmi_handle->fw_abi_version)); - +#endif return QDF_STATUS_SUCCESS; } @@ -11653,6 +11822,9 @@ struct wmi_ops tlv_ops = { .send_stats_request_cmd = send_stats_request_cmd_tlv, .send_packet_log_enable_cmd = send_packet_log_enable_cmd_tlv, .send_beacon_send_cmd = send_beacon_send_cmd_tlv, +#ifndef CONFIG_MCL + .send_beacon_tmpl_send_cmd = send_beacon_tmpl_send_cmd_tlv, +#endif .send_peer_assoc_cmd = send_peer_assoc_cmd_tlv, .send_scan_start_cmd = send_scan_start_cmd_tlv, .send_scan_stop_cmd = send_scan_stop_cmd_tlv, @@ -11685,12 +11857,9 @@ struct wmi_ops tlv_ops = { .send_set_thermal_mgmt_cmd = send_set_thermal_mgmt_cmd_tlv, .send_lro_config_cmd = send_lro_config_cmd_tlv, .send_peer_rate_report_cmd = send_peer_rate_report_cmd_tlv, - .send_bcn_buf_ll_cmd = send_bcn_buf_ll_cmd_tlv, .send_set_sta_sa_query_param_cmd = send_set_sta_sa_query_param_cmd_tlv, .send_set_sta_keep_alive_cmd = send_set_sta_keep_alive_cmd_tlv, .send_vdev_set_gtx_cfg_cmd = send_vdev_set_gtx_cfg_cmd_tlv, - .send_process_update_edca_param_cmd = - send_process_update_edca_param_cmd_tlv, .send_probe_rsp_tmpl_send_cmd = send_probe_rsp_tmpl_send_cmd_tlv, .send_p2p_go_set_beacon_ie_cmd = @@ -11707,8 +11876,6 @@ struct wmi_ops tlv_ops = { send_reset_passpoint_network_list_cmd_tlv, .send_set_passpoint_network_list_cmd = send_set_passpoint_network_list_cmd_tlv, - .send_roam_scan_offload_mode_cmd = - send_roam_scan_offload_mode_cmd_tlv, .send_roam_scan_offload_rssi_thresh_cmd = send_roam_scan_offload_rssi_thresh_cmd_tlv, .send_roam_scan_filter_cmd = @@ -11732,7 +11899,9 @@ struct wmi_ops tlv_ops = { .send_plm_stop_cmd = send_plm_stop_cmd_tlv, .send_plm_start_cmd = send_plm_start_cmd_tlv, .send_pno_stop_cmd = send_pno_stop_cmd_tlv, +#ifdef FEATURE_WLAN_SCAN_PNO .send_pno_start_cmd = send_pno_start_cmd_tlv, +#endif .send_set_ric_req_cmd = send_set_ric_req_cmd_tlv, .send_process_ll_stats_clear_cmd = send_process_ll_stats_clear_cmd_tlv, .send_process_ll_stats_set_cmd = send_process_ll_stats_set_cmd_tlv, @@ -11741,6 +11910,7 @@ struct wmi_ops tlv_ops = { .send_snr_request_cmd = send_snr_request_cmd_tlv, .send_snr_cmd = send_snr_cmd_tlv, .send_link_status_req_cmd = send_link_status_req_cmd_tlv, +#ifdef CONFIG_MCL .send_lphb_config_hbenable_cmd = send_lphb_config_hbenable_cmd_tlv, .send_lphb_config_tcp_params_cmd = send_lphb_config_tcp_params_cmd_tlv, .send_lphb_config_udp_params_cmd = send_lphb_config_udp_params_cmd_tlv, @@ -11749,14 +11919,24 @@ struct wmi_ops tlv_ops = { .send_process_dhcp_ind_cmd = send_process_dhcp_ind_cmd_tlv, .send_get_link_speed_cmd = send_get_link_speed_cmd_tlv, .send_egap_conf_params_cmd = send_egap_conf_params_cmd_tlv, + .send_bcn_buf_ll_cmd = send_bcn_buf_ll_cmd_tlv, + .send_process_update_edca_param_cmd = + send_process_update_edca_param_cmd_tlv, + .send_roam_scan_offload_mode_cmd = + send_roam_scan_offload_mode_cmd_tlv, + .send_pktlog_wmi_send_cmd = send_pktlog_wmi_send_cmd_tlv, + .send_roam_scan_offload_ap_profile_cmd = + send_roam_scan_offload_ap_profile_cmd_tlv, +#endif .send_fw_profiling_cmd = send_fw_profiling_cmd_tlv, .send_csa_offload_enable_cmd = send_csa_offload_enable_cmd_tlv, +#ifdef FEATURE_WLAN_RA_FILTERING .send_wow_sta_ra_filter_cmd = send_wow_sta_ra_filter_cmd_tlv, +#endif .send_nat_keepalive_en_cmd = send_nat_keepalive_en_cmd_tlv, .send_start_oem_data_cmd = send_start_oem_data_cmd_tlv, .send_dfs_phyerr_filter_offload_en_cmd = send_dfs_phyerr_filter_offload_en_cmd_tlv, - .send_pktlog_wmi_send_cmd = send_pktlog_wmi_send_cmd_tlv, .send_add_wow_wakeup_event_cmd = send_add_wow_wakeup_event_cmd_tlv, .send_wow_patterns_to_fw_cmd = send_wow_patterns_to_fw_cmd_tlv, .send_wow_delete_pattern_cmd = send_wow_delete_pattern_cmd_tlv, @@ -11793,7 +11973,9 @@ struct wmi_ops tlv_ops = { .send_update_tdls_peer_state_cmd = send_update_tdls_peer_state_cmd_tlv, .send_process_fw_mem_dump_cmd = send_process_fw_mem_dump_cmd_tlv, .send_process_set_ie_info_cmd = send_process_set_ie_info_cmd_tlv, +#ifdef CONFIG_MCL .send_init_cmd = send_init_cmd_tlv, +#endif .save_fw_version_cmd = save_fw_version_cmd_tlv, .check_and_update_fw_version = check_and_update_fw_version_cmd_tlv, @@ -11818,8 +12000,6 @@ struct wmi_ops tlv_ops = { .send_unit_test_cmd = send_unit_test_cmd_tlv, .send_roam_invoke_cmd = send_roam_invoke_cmd_tlv, .send_roam_scan_offload_cmd = send_roam_scan_offload_cmd_tlv, - .send_roam_scan_offload_ap_profile_cmd = - send_roam_scan_offload_ap_profile_cmd_tlv, .send_roam_scan_offload_scan_period_cmd = send_roam_scan_offload_scan_period_cmd_tlv, .send_roam_scan_offload_chan_list_cmd =