From b50ceeee79afc9098ac41f337541433d3773316c Mon Sep 17 00:00:00 2001 From: Namita Nair Date: Tue, 20 Jun 2023 15:40:49 -0700 Subject: [PATCH] qcacmn: Defer IPA SMMU mapping to OPT_DP reserve Currently, IPA SMMU map/unmap is called as part of init. This causes every nbuf to be mapped to IPA in the Rx path, causing throughputs to drop. This change resolves the problem by deferring the IPA SMMU map/unmap call to OPT_DP filter reserve/release, as nbuf needs to be mapped to IPA only in this scenario. Change-Id: If198a6c5f22af58fdaf9d9c020c74b1f76002e37 CRs-Fixed: 3496679 --- dp/inc/cdp_txrx_ipa.h | 58 ++++++++++++++++++++++++++++ dp/inc/cdp_txrx_ops.h | 12 ++++++ dp/wifi3.0/dp_ipa.c | 65 +++++++++++++++++++++++++------ dp/wifi3.0/dp_ipa.h | 28 +++++++++++++- dp/wifi3.0/dp_main.c | 3 ++ dp/wifi3.0/dp_rx.c | 10 +++-- dp/wifi3.0/dp_rx.h | 13 ++++--- dp/wifi3.0/dp_rx_defrag.c | 6 ++- dp/wifi3.0/dp_rx_desc.c | 10 +++-- dp/wifi3.0/dp_types.h | 1 + ipa/core/inc/wlan_ipa_priv.h | 4 ++ ipa/core/src/wlan_ipa_core.c | 75 ++++++++++++++++++++++++++++++------ 12 files changed, 247 insertions(+), 38 deletions(-) diff --git a/dp/inc/cdp_txrx_ipa.h b/dp/inc/cdp_txrx_ipa.h index 6f62651188..48ad93adda 100644 --- a/dp/inc/cdp_txrx_ipa.h +++ b/dp/inc/cdp_txrx_ipa.h @@ -743,6 +743,64 @@ cdp_ipa_tx_buf_smmu_unmapping(ol_txrx_soc_handle soc, uint8_t pdev_id, return QDF_STATUS_SUCCESS; } +/** + * cdp_ipa_rx_buf_smmu_pool_mapping() - Create SMMU mappings for Rx pool + * @soc: data path soc handle + * @pdev_id: pdev id + * @create: Map/unmap + * @line: line number + * @func: function name + * + * Create SMMU map/unmap for Rx buffers allocated to IPA + * + * return QDF_STATUS_SUCCESS + */ +static inline QDF_STATUS +cdp_ipa_rx_buf_smmu_pool_mapping(ol_txrx_soc_handle soc, uint8_t pdev_id, + bool create, const char *func, uint32_t line) +{ + if (!soc || !soc->ops || !soc->ops->ipa_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return QDF_STATUS_E_FAILURE; + } + + if (soc->ops->ipa_ops->ipa_rx_buf_smmu_pool_mapping) + return soc->ops->ipa_ops->ipa_rx_buf_smmu_pool_mapping(soc, + pdev_id, create, func, line); + + return QDF_STATUS_SUCCESS; +} + +static inline QDF_STATUS cdp_ipa_set_smmu_mapped(ol_txrx_soc_handle soc, + int val) +{ + if (!soc || !soc->ops || !soc->ops->ipa_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return QDF_STATUS_E_FAILURE; + } + + if (soc->ops->ipa_ops->ipa_set_smmu_mapped) + return soc->ops->ipa_ops->ipa_set_smmu_mapped(soc, val); + + return QDF_STATUS_SUCCESS; +} + +static inline int cdp_ipa_get_smmu_mapped(ol_txrx_soc_handle soc) +{ + if (!soc || !soc->ops || !soc->ops->ipa_ops) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_FATAL, + "%s invalid instance", __func__); + return QDF_STATUS_E_FAILURE; + } + + if (soc->ops->ipa_ops->ipa_get_smmu_mapped) + return soc->ops->ipa_ops->ipa_get_smmu_mapped(soc); + + return QDF_STATUS_SUCCESS; +} + #ifdef IPA_WDS_EASYMESH_FEATURE /** * cdp_ipa_ast_create() - Create/update AST entry in AST table diff --git a/dp/inc/cdp_txrx_ops.h b/dp/inc/cdp_txrx_ops.h index 5ee67b4a92..8f4a7571a1 100644 --- a/dp/inc/cdp_txrx_ops.h +++ b/dp/inc/cdp_txrx_ops.h @@ -2156,6 +2156,9 @@ struct cdp_throttle_ops { * @ipa_tx_buf_smmu_mapping: Create SMMU mappings for Tx * @ipa_tx_buf_smmu_unmapping: Release SMMU mappings for Tx * buffers to IPA + * @ipa_rx_buf_smmu_pool_mapping: Create SMMU mapping for Rx + * @ipa_set_smmu_mapped: Set IPA SMMU mapped value + * @ipa_get_smmu_mapped: Get IPA SMMU mapped value * @ipa_rx_super_rule_setup: Setup cce super rules based on filter tuple * @ipa_ast_create: Create/Update ast entry * @ipa_get_wdi_version: Get WDI version @@ -2251,6 +2254,15 @@ struct cdp_ipa_ops { uint8_t pdev_id, const char *func, uint32_t line); + QDF_STATUS (*ipa_rx_buf_smmu_pool_mapping)( + struct cdp_soc_t *soc_hdl, + uint8_t pdev_id, + bool create, + const char *func, + uint32_t line); + QDF_STATUS (*ipa_set_smmu_mapped)(struct cdp_soc_t *soc_hdl, int val); + int (*ipa_get_smmu_mapped)(struct cdp_soc_t *soc_hdl); + #ifdef IPA_OPT_WIFI_DP QDF_STATUS (*ipa_rx_super_rule_setup)(struct cdp_soc_t *soc_hdl, void *flt_params); diff --git a/dp/wifi3.0/dp_ipa.c b/dp/wifi3.0/dp_ipa.c index 839bb3c60b..d428ed56eb 100644 --- a/dp/wifi3.0/dp_ipa.c +++ b/dp/wifi3.0/dp_ipa.c @@ -378,6 +378,21 @@ static QDF_STATUS dp_ipa_handle_rx_buf_pool_smmu_mapping( } #endif /* RX_DESC_MULTI_PAGE_ALLOC */ +QDF_STATUS dp_ipa_set_smmu_mapped(struct cdp_soc_t *soc_hdl, int val) +{ + struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); + + qdf_atomic_set(&soc->ipa_mapped, val); + return QDF_STATUS_SUCCESS; +} + +int dp_ipa_get_smmu_mapped(struct cdp_soc_t *soc_hdl) +{ + struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); + + return qdf_atomic_read(&soc->ipa_mapped); +} + static QDF_STATUS dp_ipa_get_shared_mem_info(qdf_device_t osdev, qdf_shared_mem_t *shared_mem, void *cpu_addr, @@ -3448,8 +3463,12 @@ QDF_STATUS dp_ipa_enable_pipes(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, qdf_atomic_set(&soc->ipa_pipes_enabled, 1); DP_IPA_EP_SET_TX_DB_PA(soc, ipa_res); - dp_ipa_handle_rx_buf_pool_smmu_mapping(soc, pdev, true, - __func__, __LINE__); + + if (!ipa_config_is_opt_wifi_dp_enabled()) { + dp_ipa_handle_rx_buf_pool_smmu_mapping(soc, pdev, true, + __func__, __LINE__); + qdf_atomic_set(&soc->ipa_mapped, 1); + } result = qdf_ipa_wdi_enable_pipes(hdl); if (result) { @@ -3458,8 +3477,9 @@ QDF_STATUS dp_ipa_enable_pipes(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, __func__, result); qdf_atomic_set(&soc->ipa_pipes_enabled, 0); DP_IPA_RESET_TX_DB_PA(soc, ipa_res); - dp_ipa_handle_rx_buf_pool_smmu_mapping(soc, pdev, false, - __func__, __LINE__); + if (qdf_atomic_read(&soc->ipa_mapped)) + dp_ipa_handle_rx_buf_pool_smmu_mapping( + soc, pdev, false, __func__, __LINE__); return QDF_STATUS_E_FAILURE; } @@ -3505,8 +3525,10 @@ QDF_STATUS dp_ipa_disable_pipes(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, } qdf_atomic_set(&soc->ipa_pipes_enabled, 0); - dp_ipa_handle_rx_buf_pool_smmu_mapping(soc, pdev, false, - __func__, __LINE__); + + if (qdf_atomic_read(&soc->ipa_mapped)) + dp_ipa_handle_rx_buf_pool_smmu_mapping(soc, pdev, false, + __func__, __LINE__); return result ? QDF_STATUS_E_FAILURE : QDF_STATUS_SUCCESS; } @@ -3915,6 +3937,31 @@ QDF_STATUS dp_ipa_tx_buf_smmu_unmapping( struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); + if (!qdf_mem_smmu_s1_enabled(soc->osdev)) { + dp_debug("SMMU S1 disabled"); + return QDF_STATUS_SUCCESS; + } + + if (!pdev) { + dp_err("Invalid pdev instance pdev_id:%d", pdev_id); + return QDF_STATUS_E_FAILURE; + } + + if (__dp_ipa_tx_buf_smmu_mapping(soc, pdev, false, func, line) || + dp_ipa_tx_alt_buf_smmu_mapping(soc, pdev, false, func, line)) + return QDF_STATUS_E_FAILURE; + + return QDF_STATUS_SUCCESS; +} + +QDF_STATUS dp_ipa_rx_buf_pool_smmu_mapping( + struct cdp_soc_t *soc_hdl, uint8_t pdev_id, + bool create, const char *func, uint32_t line) +{ + struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl); + struct dp_pdev *pdev = + dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id); + if (!pdev) { dp_err("Invalid instance"); return QDF_STATUS_E_FAILURE; @@ -3925,13 +3972,9 @@ QDF_STATUS dp_ipa_tx_buf_smmu_unmapping( return QDF_STATUS_SUCCESS; } - if (__dp_ipa_tx_buf_smmu_mapping(soc, pdev, false, func, line) || - dp_ipa_tx_alt_buf_smmu_mapping(soc, pdev, false, func, line)) - return QDF_STATUS_E_FAILURE; - + dp_ipa_handle_rx_buf_pool_smmu_mapping(soc, pdev, create, func, line); return QDF_STATUS_SUCCESS; } - #ifdef IPA_WDS_EASYMESH_FEATURE QDF_STATUS dp_ipa_ast_create(struct cdp_soc_t *soc_hdl, qdf_ipa_ast_info_type_t *data) diff --git a/dp/wifi3.0/dp_ipa.h b/dp/wifi3.0/dp_ipa.h index 36936603b3..998620aa80 100644 --- a/dp/wifi3.0/dp_ipa.h +++ b/dp/wifi3.0/dp_ipa.h @@ -409,7 +409,6 @@ QDF_STATUS dp_ipa_handle_rx_buf_smmu_mapping(struct dp_soc *soc, bool create, const char *func, uint32_t line); - /** * dp_ipa_tx_buf_smmu_mapping() - Create SMMU mappings for IPA * allocated TX buffers @@ -437,6 +436,13 @@ QDF_STATUS dp_ipa_tx_buf_smmu_mapping(struct cdp_soc_t *soc_hdl, QDF_STATUS dp_ipa_tx_buf_smmu_unmapping(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, const char *func, uint32_t line); +QDF_STATUS dp_ipa_rx_buf_pool_smmu_mapping(struct cdp_soc_t *soc_hdl, + uint8_t pdev_id, + bool create, + const char *func, + uint32_t line); +QDF_STATUS dp_ipa_set_smmu_mapped(struct cdp_soc_t *soc, int val); +int dp_ipa_get_smmu_mapped(struct cdp_soc_t *soc); #ifndef QCA_OL_DP_SRNG_LOCK_LESS_ACCESS static inline void @@ -679,6 +685,26 @@ static inline QDF_STATUS dp_ipa_tx_buf_smmu_unmapping(struct cdp_soc_t *soc_hdl, return QDF_STATUS_SUCCESS; } +static inline QDF_STATUS dp_ipa_rx_buf_pool_smmu_mapping( + struct cdp_soc_t *soc_hdl, + uint8_t pdev_id, + bool create, + const char *func, + uint32_t line) +{ + return QDF_STATUS_SUCCESS; +} + +static inline QDF_STATUS dp_ipa_set_smmu_mapped(struct cdp_soc_t *soc, int val) +{ + return QDF_STATUS_SUCCESS; +} + +static inline int dp_ipa_get_smmu_mapped(struct cdp_soc_t *soc) +{ + return QDF_STATUS_SUCCESS; +} + #ifdef IPA_WDS_EASYMESH_FEATURE static inline QDF_STATUS dp_ipa_ast_create(struct cdp_soc_t *soc_hdl, qdf_ipa_ast_info_type_t *data) diff --git a/dp/wifi3.0/dp_main.c b/dp/wifi3.0/dp_main.c index 7d643acb6d..8284473faf 100644 --- a/dp/wifi3.0/dp_main.c +++ b/dp/wifi3.0/dp_main.c @@ -12061,6 +12061,9 @@ static struct cdp_ipa_ops dp_ops_ipa = { .ipa_rx_intrabss_fwd = dp_ipa_rx_intrabss_fwd, .ipa_tx_buf_smmu_mapping = dp_ipa_tx_buf_smmu_mapping, .ipa_tx_buf_smmu_unmapping = dp_ipa_tx_buf_smmu_unmapping, + .ipa_rx_buf_smmu_pool_mapping = dp_ipa_rx_buf_pool_smmu_mapping, + .ipa_set_smmu_mapped = dp_ipa_set_smmu_mapped, + .ipa_get_smmu_mapped = dp_ipa_get_smmu_mapped, #ifdef QCA_ENHANCED_STATS_SUPPORT .ipa_update_peer_rx_stats = dp_ipa_update_peer_rx_stats, #endif diff --git a/dp/wifi3.0/dp_rx.c b/dp/wifi3.0/dp_rx.c index bbda5dd20a..a0442892cb 100644 --- a/dp/wifi3.0/dp_rx.c +++ b/dp/wifi3.0/dp_rx.c @@ -365,6 +365,7 @@ dp_pdev_nbuf_alloc_and_map_replenish(struct dp_soc *dp_soc, nbuf_frag_info_t->paddr = qdf_nbuf_get_frag_paddr((nbuf_frag_info_t->virt_addr).nbuf, 0); + if (qdf_atomic_read(&dp_soc->ipa_mapped)) dp_ipa_handle_rx_buf_smmu_mapping(dp_soc, (qdf_nbuf_t)( (nbuf_frag_info_t->virt_addr).nbuf), rx_desc_pool->buf_size, @@ -3160,10 +3161,11 @@ dp_pdev_rx_buffers_attach(struct dp_soc *dp_soc, uint32_t mac_id, desc_list->rx_desc.cookie, rx_desc_pool->owner); - dp_ipa_handle_rx_buf_smmu_mapping( - dp_soc, nbuf, - rx_desc_pool->buf_size, true, - __func__, __LINE__); + if (qdf_atomic_read(&dp_soc->ipa_mapped)) + dp_ipa_handle_rx_buf_smmu_mapping( + dp_soc, nbuf, + rx_desc_pool->buf_size, true, + __func__, __LINE__); dp_audio_smmu_map(dp_soc->osdev, qdf_mem_paddr_from_dmaaddr(dp_soc->osdev, diff --git a/dp/wifi3.0/dp_rx.h b/dp/wifi3.0/dp_rx.h index 5077489a00..ac4ddfa797 100644 --- a/dp/wifi3.0/dp_rx.h +++ b/dp/wifi3.0/dp_rx.h @@ -2742,9 +2742,10 @@ void dp_rx_nbuf_unmap(struct dp_soc *soc, QDF_NBUF_CB_PADDR(rx_desc->nbuf), rx_desc_pool->buf_size); - dp_ipa_handle_rx_buf_smmu_mapping(soc, rx_desc->nbuf, - rx_desc_pool->buf_size, - false, __func__, __LINE__); + if (qdf_atomic_read(&soc->ipa_mapped)) + dp_ipa_handle_rx_buf_smmu_mapping(soc, rx_desc->nbuf, + rx_desc_pool->buf_size, + false, __func__, __LINE__); qdf_nbuf_unmap_nbytes_single(soc->osdev, rx_desc->nbuf, QDF_DMA_FROM_DEVICE, @@ -2760,8 +2761,10 @@ void dp_rx_nbuf_unmap_pool(struct dp_soc *soc, { dp_audio_smmu_unmap(soc->osdev, QDF_NBUF_CB_PADDR(nbuf), rx_desc_pool->buf_size); - dp_ipa_handle_rx_buf_smmu_mapping(soc, nbuf, rx_desc_pool->buf_size, - false, __func__, __LINE__); + if (qdf_atomic_read(&soc->ipa_mapped)) + dp_ipa_handle_rx_buf_smmu_mapping(soc, nbuf, + rx_desc_pool->buf_size, + false, __func__, __LINE__); qdf_nbuf_unmap_nbytes_single(soc->osdev, nbuf, QDF_DMA_FROM_DEVICE, rx_desc_pool->buf_size); } diff --git a/dp/wifi3.0/dp_rx_defrag.c b/dp/wifi3.0/dp_rx_defrag.c index f48d16885a..86a328be13 100644 --- a/dp/wifi3.0/dp_rx_defrag.c +++ b/dp/wifi3.0/dp_rx_defrag.c @@ -1307,8 +1307,10 @@ static QDF_STATUS dp_rx_defrag_reo_reinject(struct dp_txrx_peer *txrx_peer, return QDF_STATUS_E_FAILURE; } - dp_ipa_handle_rx_buf_smmu_mapping(soc, head, rx_desc_pool->buf_size, - true, __func__, __LINE__); + if (qdf_atomic_read(&soc->ipa_mapped)) + dp_ipa_handle_rx_buf_smmu_mapping(soc, head, + rx_desc_pool->buf_size, true, + __func__, __LINE__); dp_audio_smmu_map(soc->osdev, qdf_mem_paddr_from_dmaaddr(soc->osdev, diff --git a/dp/wifi3.0/dp_rx_desc.c b/dp/wifi3.0/dp_rx_desc.c index 51e4422769..7beb0e6d41 100644 --- a/dp/wifi3.0/dp_rx_desc.c +++ b/dp/wifi3.0/dp_rx_desc.c @@ -193,9 +193,13 @@ static void dp_rx_desc_nbuf_cleanup(struct dp_soc *soc, QDF_NBUF_CB_PADDR(nbuf), buf_size); - if (dp_ipa_handle_rx_buf_smmu_mapping(soc, nbuf, buf_size, - false, __func__, __LINE__)) - dp_info_rl("Unable to unmap nbuf: %pK", nbuf); + if (qdf_atomic_read(&soc->ipa_mapped)) { + if (dp_ipa_handle_rx_buf_smmu_mapping( + soc, nbuf, buf_size, + false, __func__, + __LINE__)) + dp_info_rl("Unable to unmap nbuf: %pK", nbuf); + } qdf_nbuf_unmap_nbytes_single(soc->osdev, nbuf, QDF_DMA_BIDIRECTIONAL, buf_size); dp_rx_nbuf_free(nbuf); diff --git a/dp/wifi3.0/dp_types.h b/dp/wifi3.0/dp_types.h index 630fd9d4f6..6d7a388a6e 100644 --- a/dp/wifi3.0/dp_types.h +++ b/dp/wifi3.0/dp_types.h @@ -2912,6 +2912,7 @@ struct dp_soc { struct htt_t2h_stats htt_stats; void *external_txrx_handle; /* External data path handle */ + qdf_atomic_t ipa_mapped; #ifdef IPA_OFFLOAD struct ipa_dp_tx_rsc ipa_uc_tx_rsc; #ifdef IPA_WDI3_TX_TWO_PIPES diff --git a/ipa/core/inc/wlan_ipa_priv.h b/ipa/core/inc/wlan_ipa_priv.h index ea0968e4f8..db642cb383 100644 --- a/ipa/core/inc/wlan_ipa_priv.h +++ b/ipa/core/inc/wlan_ipa_priv.h @@ -123,6 +123,8 @@ * @WLAN_IPA_UC_OPCODE_UC_READY: IPA UC ready indication * @WLAN_IPA_FILTER_RSV_NOTIFY: OPT WIFI DP filter reserve notification * @WLAN_IPA_FILTER_REL_NOTIFY: OPT WIFI DP filter release notification + * @WLAN_IPA_SMMU_MAP: IPA SMMU map call + * @WLAN_IPA_SMMU_UNMAP: IPA SMMU unmap call * @WLAN_IPA_UC_OPCODE_MAX: IPA UC max operation code */ enum wlan_ipa_uc_op_code { @@ -139,6 +141,8 @@ enum wlan_ipa_uc_op_code { WLAN_IPA_UC_OPCODE_UC_READY = 8, WLAN_IPA_FILTER_RSV_NOTIFY = 9, WLAN_IPA_FILTER_REL_NOTIFY = 10, + WLAN_IPA_SMMU_MAP = 11, + WLAN_IPA_SMMU_UNMAP = 12, /* keep this last */ WLAN_IPA_UC_OPCODE_MAX }; diff --git a/ipa/core/src/wlan_ipa_core.c b/ipa/core/src/wlan_ipa_core.c index 0009ca1e38..96727ecc93 100644 --- a/ipa/core/src/wlan_ipa_core.c +++ b/ipa/core/src/wlan_ipa_core.c @@ -4353,6 +4353,8 @@ QDF_STATUS wlan_ipa_setup(struct wlan_ipa_priv *ipa_ctx, qdf_mutex_create(&ipa_ctx->ipa_lock); qdf_atomic_init(&ipa_ctx->deinit_in_prog); + cdp_ipa_set_smmu_mapped(ipa_ctx->dp_soc, 0); + status = wlan_ipa_wdi_setup_rm(ipa_ctx); if (status != QDF_STATUS_SUCCESS) goto fail_setup_rm; @@ -4765,6 +4767,20 @@ static void wlan_ipa_uc_op_cb(struct op_msg_type *op_msg, qdf_ipa_wdi_opt_dpath_notify_flt_rlsd_per_inst(ipa_ctx->hdl, msg->rsvd); qdf_mutex_release(&ipa_ctx->ipa_lock); + } else if (msg->op_code == WLAN_IPA_SMMU_MAP) { + ipa_info("opt_dp: IPA smmu pool map"); + qdf_mutex_acquire(&ipa_ctx->ipa_lock); + cdp_ipa_rx_buf_smmu_pool_mapping(ipa_ctx->dp_soc, + ipa_ctx->dp_pdev_id, true, + __func__, __LINE__); + qdf_mutex_release(&ipa_ctx->ipa_lock); + } else if (msg->op_code == WLAN_IPA_SMMU_UNMAP) { + ipa_info("opt_dp: IPA smmu pool unmap"); + qdf_mutex_acquire(&ipa_ctx->ipa_lock); + cdp_ipa_rx_buf_smmu_pool_mapping(ipa_ctx->dp_soc, + ipa_ctx->dp_pdev_id, + false, __func__, __LINE__); + qdf_mutex_release(&ipa_ctx->ipa_lock); } else if (wlan_ipa_uc_op_metering(ipa_ctx, op_msg)) { ipa_err("Invalid message: op_code=%d, reason=%d", msg->op_code, ipa_ctx->stat_req_reason); @@ -5167,16 +5183,30 @@ void wlan_ipa_flush_pending_vdev_events(struct wlan_ipa_priv *ipa_ctx, void wlan_ipa_wdi_opt_dpath_notify_flt_rsvd(bool response) { struct wlan_ipa_priv *ipa_ctx = gp_ipa; - struct op_msg_type *msg; + struct op_msg_type *smmu_msg; + struct op_msg_type *notify_msg; struct uc_op_work_struct *uc_op_work; - msg = qdf_mem_malloc(sizeof(*msg)); - if (!msg) + smmu_msg = qdf_mem_malloc(sizeof(*smmu_msg)); + if (!smmu_msg) return; - msg->op_code = WLAN_IPA_FILTER_RSV_NOTIFY; - msg->rsvd = response; + + if (response) { + smmu_msg->op_code = WLAN_IPA_SMMU_MAP; + uc_op_work = &ipa_ctx->uc_op_work[WLAN_IPA_SMMU_MAP]; + uc_op_work->msg = smmu_msg; + qdf_sched_work(0, &uc_op_work->work); + cdp_ipa_set_smmu_mapped(ipa_ctx->dp_soc, 1); + } + + notify_msg = qdf_mem_malloc(sizeof(*notify_msg)); + if (!notify_msg) + return; + + notify_msg->op_code = WLAN_IPA_FILTER_RSV_NOTIFY; + notify_msg->rsvd = response; uc_op_work = &ipa_ctx->uc_op_work[WLAN_IPA_FILTER_RSV_NOTIFY]; - uc_op_work->msg = msg; + uc_op_work->msg = notify_msg; qdf_sched_work(0, &uc_op_work->work); } @@ -5467,10 +5497,14 @@ void wlan_ipa_wdi_opt_dpath_notify_flt_rlsd(int flt0_rslt, int flt1_rslt) { struct wifi_dp_flt_setup *dp_flt_params = NULL; struct wlan_ipa_priv *ipa_ctx = gp_ipa; - struct op_msg_type *msg; + struct wlan_objmgr_pdev *pdev; + struct op_msg_type *smmu_msg; + struct op_msg_type *notify_msg; struct uc_op_work_struct *uc_op_work; bool result = false; + bool val = false; + pdev = ipa_ctx->pdev; dp_flt_params = &(ipa_ctx->dp_cce_super_rule_flt_param); if ((dp_flt_params->flt_addr_params[0].ipa_flt_in_use == true && @@ -5484,14 +5518,31 @@ void wlan_ipa_wdi_opt_dpath_notify_flt_rlsd(int flt0_rslt, int flt1_rslt) result = true; } - msg = qdf_mem_malloc(sizeof(*msg)); - if (!msg) + smmu_msg = qdf_mem_malloc(sizeof(*smmu_msg)); + if (!smmu_msg) return; - msg->op_code = WLAN_IPA_FILTER_REL_NOTIFY; - msg->rsvd = result; + + val = cdp_ipa_get_smmu_mapped(ipa_ctx->dp_soc); + if (val) { + smmu_msg->op_code = WLAN_IPA_SMMU_UNMAP; + uc_op_work = &ipa_ctx->uc_op_work[WLAN_IPA_SMMU_UNMAP]; + uc_op_work->msg = smmu_msg; + qdf_sched_work(0, &uc_op_work->work); + cdp_ipa_set_smmu_mapped(ipa_ctx->dp_soc, 0); + } else { + ipa_err("IPA SMMU not mapped!!"); + } + + notify_msg = qdf_mem_malloc(sizeof(*notify_msg)); + if (!notify_msg) + return; + + notify_msg->op_code = WLAN_IPA_FILTER_REL_NOTIFY; + notify_msg->rsvd = result; uc_op_work = &ipa_ctx->uc_op_work[WLAN_IPA_FILTER_REL_NOTIFY]; - uc_op_work->msg = msg; + uc_op_work->msg = notify_msg; qdf_sched_work(0, &uc_op_work->work); + qdf_wake_lock_release(&ipa_ctx->opt_dp_wake_lock, WIFI_POWER_EVENT_WAKELOCK_OPT_WIFI_DP); ipa_info("opt_dp: Wakelock released");