From 761329bbf2c31a239ee8c3f60a1a327c1529f813 Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Tue, 19 Sep 2017 10:30:11 -0700 Subject: [PATCH 01/14] qcacmn: Do not start unmap timer if send cmd to FW fails Do not start unmap timer if peer delete couldn't be sent to firmware. Change-Id: Ie746bde046b76d8e136ebb4fd0b60088bf516d42 CRs-Fixed: 2116223 --- dp/inc/cdp_txrx_cmn.h | 4 ++-- dp/inc/cdp_txrx_ops.h | 8 +++++++- dp/wifi3.0/dp_main.c | 5 +++-- 3 files changed, 12 insertions(+), 5 deletions(-) diff --git a/dp/inc/cdp_txrx_cmn.h b/dp/inc/cdp_txrx_cmn.h index ee23b5855f21..c98c57da8f87 100644 --- a/dp/inc/cdp_txrx_cmn.h +++ b/dp/inc/cdp_txrx_cmn.h @@ -157,10 +157,10 @@ static inline void cdp_peer_teardown } static inline void -cdp_peer_delete(ol_txrx_soc_handle soc, void *peer) +cdp_peer_delete(ol_txrx_soc_handle soc, void *peer, uint32_t bitmap) { if (soc->ops->cmn_drv_ops->txrx_peer_delete) - return soc->ops->cmn_drv_ops->txrx_peer_delete(peer); + return soc->ops->cmn_drv_ops->txrx_peer_delete(peer, bitmap); return; } diff --git a/dp/inc/cdp_txrx_ops.h b/dp/inc/cdp_txrx_ops.h index ad9b5eacac35..eb0e5bcd1d1f 100644 --- a/dp/inc/cdp_txrx_ops.h +++ b/dp/inc/cdp_txrx_ops.h @@ -36,6 +36,12 @@ #include #endif +/** + * bitmap values to indicate special handling of peer_delete + */ +#define CDP_PEER_DELETE_NO_SPECIAL 0 +#define CDP_PEER_DO_NOT_START_UNMAP_TIMER 1 + /****************************************************************************** * * Control Interface (A Interface) @@ -75,7 +81,7 @@ struct cdp_cmn_ops { void (*txrx_peer_teardown) (struct cdp_vdev *vdev_hdl, void *peer_hdl); - void (*txrx_peer_delete)(void *peer); + void (*txrx_peer_delete)(void *peer, uint32_t bitmap); int (*txrx_set_monitor_mode)(struct cdp_vdev *vdev, uint8_t smart_monitor); diff --git a/dp/wifi3.0/dp_main.c b/dp/wifi3.0/dp_main.c index cd72a196fa17..a52c9172f612 100644 --- a/dp/wifi3.0/dp_main.c +++ b/dp/wifi3.0/dp_main.c @@ -3217,10 +3217,11 @@ void dp_peer_unref_delete(void *peer_handle) /* * dp_peer_detach_wifi3() – Detach txrx peer - * @peer_handle: Datapath peer handle + * @peer_handle: Datapath peer handle + * @bitmap: bitmap indicating special handling of request. * */ -static void dp_peer_delete_wifi3(void *peer_handle) +static void dp_peer_delete_wifi3(void *peer_handle, uint32_t bitmap) { struct dp_peer *peer = (struct dp_peer *)peer_handle; From be998d8c2de87b40d3fdb32f0a67fa0d17b91f9a Mon Sep 17 00:00:00 2001 From: bings Date: Tue, 24 Oct 2017 17:46:32 +0800 Subject: [PATCH 02/14] qcacmn: Free sdio hif device when hif_device_inserted fails hif_device_inserted may be failed when installing sdio wlan module, which causes memory leak. To fix this memory leak, free the hif_sdio_dev and its related DMA buffers when sdio driver fails in hif_device_inserted. Change-Id: I6ee53cd2a55fbb1492c66caa260ba8b3681526e6 CRs-Fixed: 2131539 --- hif/src/sdio/native_sdio/src/hif.c | 29 ++++++++++++++++++++++------- 1 file changed, 22 insertions(+), 7 deletions(-) diff --git a/hif/src/sdio/native_sdio/src/hif.c b/hif/src/sdio/native_sdio/src/hif.c index 96d85e7d1445..cc68bd95bb6e 100644 --- a/hif/src/sdio/native_sdio/src/hif.c +++ b/hif/src/sdio/native_sdio/src/hif.c @@ -1719,7 +1719,7 @@ static int hif_device_inserted(struct sdio_func *func, AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("%s: CMD52 to set bus width failed: %d\n", __func__, ret)); - return ret; + goto del_hif_dev;; } device->host->ios.bus_width = MMC_BUS_WIDTH_1; @@ -1740,7 +1740,7 @@ static int hif_device_inserted(struct sdio_func *func, ("%s: CMD52 to bus width failed: %d\n", __func__, ret)); - return ret; + goto del_hif_dev; } device->host->ios.bus_width = MMC_BUS_WIDTH_4; @@ -1761,7 +1761,7 @@ static int hif_device_inserted(struct sdio_func *func, ("%s: CMD52 to bus width failed: %d\n", __func__, ret)); - return ret; + goto del_hif_dev; } device->host->ios.bus_width = MMC_BUS_WIDTH_8; @@ -1773,7 +1773,8 @@ static int hif_device_inserted(struct sdio_func *func, ("%s: MMC bus width %d is not supported.\n", __func__, mmcbuswidth)); - return ret = QDF_STATUS_E_FAILURE; + ret = QDF_STATUS_E_FAILURE; + goto del_hif_dev; } AR_DEBUG_PRINTF(ATH_DEBUG_ANY, ("%s: Set MMC bus width to %dBit.\n", @@ -1808,9 +1809,23 @@ static int hif_device_inserted(struct sdio_func *func, sema_init(&device->sem_async, 0); ret = hif_enable_func(device, func); - - return (ret == QDF_STATUS_SUCCESS || ret == QDF_STATUS_E_PENDING) - ? 0 : QDF_STATUS_E_FAILURE; + if ((ret == QDF_STATUS_SUCCESS || ret == QDF_STATUS_E_PENDING)) + return 0; + ret = QDF_STATUS_E_FAILURE; +del_hif_dev: + del_hif_device(device); + for (i = 0; i < MAX_HIF_DEVICES; ++i) { + if (hif_devices[i] == device) { + hif_devices[i] = NULL; + break; + } + } + if (i == MAX_HIF_DEVICES) { + AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, + ("%s: No hif_devices[] slot for %pK", + __func__, device)); + } + return ret; } /** From 3379c749690a507bd05f3c44623f48eb73e601a8 Mon Sep 17 00:00:00 2001 From: "Pamidipati, Vijay" Date: Wed, 1 Nov 2017 18:50:43 +0530 Subject: [PATCH 03/14] qcacmn: Fix descriptor leak issue in DP In the DMA descriptor reap code, the check for NAPI quota is after Tail pointer is updated. This is causing a descriptor leak in high load conditions when loop is exited without processing the reaped descriptor. This change moves the quota check to end of while loop. Change-Id: I2f3432bf257947f85abc2216a0f2dfc44813c44c CRs-Fixed: 2137017 --- dp/wifi3.0/dp_rx.c | 5 ++--- dp/wifi3.0/dp_rx_err.c | 16 ++++++++-------- 2 files changed, 10 insertions(+), 11 deletions(-) diff --git a/dp/wifi3.0/dp_rx.c b/dp/wifi3.0/dp_rx.c index d70494fb8fef..7b139ad31117 100644 --- a/dp/wifi3.0/dp_rx.c +++ b/dp/wifi3.0/dp_rx.c @@ -957,9 +957,8 @@ dp_rx_process(struct dp_intr *int_ctx, void *hal_ring, uint32_t quota) * them in per vdev queue. * Process the received pkts in a different per vdev loop. */ - while (qdf_likely((ring_desc = - hal_srng_dst_get_next(hal_soc, hal_ring)) - && quota)) { + while (qdf_likely(quota && (ring_desc = + hal_srng_dst_get_next(hal_soc, hal_ring)))) { error = HAL_RX_ERROR_STATUS_GET(ring_desc); ring_id = hal_srng_ring_id_get(hal_ring); diff --git a/dp/wifi3.0/dp_rx_err.c b/dp/wifi3.0/dp_rx_err.c index 8f24f3d85b6a..a77ef50c1182 100644 --- a/dp/wifi3.0/dp_rx_err.c +++ b/dp/wifi3.0/dp_rx_err.c @@ -774,9 +774,9 @@ dp_rx_err_process(struct dp_soc *soc, void *hal_ring, uint32_t quota) goto done; } - while (qdf_likely((ring_desc = - hal_srng_dst_get_next(hal_soc, hal_ring)) - && quota--)) { + while (qdf_likely(quota-- && (ring_desc = + hal_srng_dst_get_next(hal_soc, hal_ring)))) { + DP_STATS_INC(soc, rx.err_ring_pkts, 1); error = HAL_RX_ERROR_STATUS_GET(ring_desc); @@ -843,6 +843,7 @@ dp_rx_err_process(struct dp_soc *soc, void *hal_ring, uint32_t quota) /* Return link descriptor through WBM ring (SW2WBM)*/ dp_rx_link_desc_return(soc, ring_desc, HAL_BM_ACTION_PUT_IN_IDLE_LIST); + } done: @@ -913,9 +914,8 @@ dp_rx_wbm_err_process(struct dp_soc *soc, void *hal_ring, uint32_t quota) goto done; } - while (qdf_likely((ring_desc = - hal_srng_dst_get_next(hal_soc, hal_ring)) - && quota--)) { + while (qdf_likely(quota-- && (ring_desc = + hal_srng_dst_get_next(hal_soc, hal_ring)))) { /* XXX */ wbm_err_src = HAL_RX_WBM_ERR_SRC_GET(ring_desc); @@ -1248,8 +1248,8 @@ dp_rxdma_err_process(struct dp_soc *soc, uint32_t mac_id, uint32_t quota) return 0; } - while (qdf_likely((rxdma_dst_ring_desc = - hal_srng_dst_get_next(hal_soc, err_dst_srng)) && quota--)) { + while (qdf_likely(quota-- && (rxdma_dst_ring_desc = + hal_srng_dst_get_next(hal_soc, err_dst_srng)))) { rx_bufs_used += dp_rx_err_mpdu_pop(soc, mac_id, rxdma_dst_ring_desc, From 231f9296864d33c8caee5580b6540e6b87a47447 Mon Sep 17 00:00:00 2001 From: Dustin Brown Date: Fri, 20 Oct 2017 17:37:33 -0700 Subject: [PATCH 04/14] qcacmn: Add QDF cpu hotplug APIs Currently, there are two consumers of the Linux kernel CPU hotplug APIs. Besides being problematic for not being operating system agnostic, different versions of the Linux kernel export different CPU hotplug APIs. In order to consolidate the various abstractions for different operating systems and API versions, create a CPU hotplug abstraction in QDF. Change-Id: Ib17c6e3ed3a87a90a82d909a6c493360cab27855 CRs-Fixed: 2132632 --- qdf/inc/qdf_cpuhp.h | 106 ++++++++++++++++++++++++ qdf/linux/src/i_qdf_cpuhp.h | 34 ++++++++ qdf/linux/src/qdf_cpuhp.c | 119 +++++++++++++++++++++++++++ qdf/src/qdf_cpuhp.c | 157 ++++++++++++++++++++++++++++++++++++ 4 files changed, 416 insertions(+) create mode 100644 qdf/inc/qdf_cpuhp.h create mode 100644 qdf/linux/src/i_qdf_cpuhp.h create mode 100644 qdf/linux/src/qdf_cpuhp.c create mode 100644 qdf/src/qdf_cpuhp.c diff --git a/qdf/inc/qdf_cpuhp.h b/qdf/inc/qdf_cpuhp.h new file mode 100644 index 000000000000..c3e99bad9094 --- /dev/null +++ b/qdf/inc/qdf_cpuhp.h @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2017 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. + */ + +/** + * DOC: qdf_cpuhp (CPU hotplug) + * QCA driver framework (QDF) CPU hotplug APIs + */ + +#ifndef __QDF_CPUHP_H +#define __QDF_CPUHP_H + +#include "qdf_status.h" +#include "qdf_types.h" + +/** + * struct qdf_cpuhp_handler - an opaque hotplug event registration handle + */ +struct qdf_cpuhp_handler; + +typedef void (*qdf_cpuhp_callback)(void *context, uint32_t cpu); + +#ifdef QCA_CONFIG_SMP +/** + * qdf_cpuhp_init() - Initialize the CPU hotplug event infrastructure + * + * To be called once, globally. + * + * Return: None + */ +QDF_STATUS qdf_cpuhp_init(void); + +/** + * qdf_cpuhp_deinit() - De-initialize the CPU hotplug event infrastructure + * + * To be called once, globally. + * + * Return: None + */ +QDF_STATUS qdf_cpuhp_deinit(void); + +/** + * qdf_cpuhp_register() - Register for CPU up/down event notifications + * @handler: a double pointer to the event registration handle to allocate + * @context: an opaque context to pass back to event listeners + * @up_callback: the function pointer to invoke for CPU up events + * @down_callback: the function pointer to invoke for CPU down events + * + * "Up" happens just after the CPU is up. Inversely, "down" happens just before + * the CPU goes down. + * + * @handler will point to a valid memory address on success, or NULL on failure. + * + * Return: QDF_STATUS + */ +QDF_STATUS qdf_cpuhp_register(struct qdf_cpuhp_handler **handler, + void *context, + qdf_cpuhp_callback up_callback, + qdf_cpuhp_callback down_callback); + +/** + * qdf_cpuhp_unregister() - Un-register for CPU up/down event notifications + * @handler: a double pointer to the event registration handle to de-allocate + * + * @handler point to NULL upon completion + * + * Return: None + */ +void qdf_cpuhp_unregister(struct qdf_cpuhp_handler **handler); +#else +QDF_STATUS qdf_cpuhp_init(void) +{ + return QDF_STATUS_SUCCESS; +} + +QDF_STATUS qdf_cpuhp_deinit(void) +{ + return QDF_STATUS_SUCCESS; +} + +QDF_STATUS qdf_cpuhp_register(struct qdf_cpuhp_handler **handler, + void *context, + qdf_cpuhp_callback up_callback, + qdf_cpuhp_callback down_callback) +{ + return QDF_STATUS_SUCCESS; +} + +void qdf_cpuhp_unregister(struct qdf_cpuhp_handler **handler) {} +#endif /* QCA_CONFIG_SMP */ + +#endif /* __QDF_CPUHP_H */ diff --git a/qdf/linux/src/i_qdf_cpuhp.h b/qdf/linux/src/i_qdf_cpuhp.h new file mode 100644 index 000000000000..7cee453c6502 --- /dev/null +++ b/qdf/linux/src/i_qdf_cpuhp.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2017 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. + */ + +/** + * DOC: i_qdf_cpuhp.h (CPU hotplug) + * Linux-specific definitions for QDF CPU hotplug API's + */ + +#ifndef __I_QDF_CPUHP_H +#define __I_QDF_CPUHP_H + +#include "linux/types.h" + +typedef void (*__qdf_cpuhp_emit)(uint32_t cpu); + +void __qdf_cpuhp_os_init(__qdf_cpuhp_emit on_up, __qdf_cpuhp_emit on_down); +void __qdf_cpuhp_os_deinit(void); + +#endif /* __I_QDF_CPUHP_H */ diff --git a/qdf/linux/src/qdf_cpuhp.c b/qdf/linux/src/qdf_cpuhp.c new file mode 100644 index 000000000000..e192055a2e7f --- /dev/null +++ b/qdf/linux/src/qdf_cpuhp.c @@ -0,0 +1,119 @@ +/* + * Copyright (c) 2017 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. + */ + +/** + * DOC: qdf_cpuhp + * This file provides OS dependent QDF CPU hotplug APIs + */ + +#include "i_qdf_cpuhp.h" +#include "qdf_trace.h" +#include "linux/cpu.h" +#include "linux/notifier.h" +#include "linux/version.h" + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 6, 0) +#include "linux/cpuhotplug.h" +#endif + +static __qdf_cpuhp_emit __qdf_cpuhp_on_up; +static __qdf_cpuhp_emit __qdf_cpuhp_on_down; + +#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 6, 0) +static int qdf_cpuhp_legacy_handler(struct notifier_block *block, + unsigned long state, + void *hcpu) +{ + unsigned long cpu = (unsigned long)hcpu; + + switch (state) { + case CPU_ONLINE: + __qdf_cpuhp_on_up(cpu); + break; + + case CPU_DOWN_PREPARE: + case CPU_DOWN_PREPARE_FROZEN: + __qdf_cpuhp_on_down(cpu); + break; + + default: + break; + } + + return NOTIFY_OK; +} + +static struct notifier_block qdf_cpuhp_notifier_block = { + .notifier_call = qdf_cpuhp_legacy_handler, +}; + +static inline void qdf_cpuhp_register_callbacks(void) +{ + register_hotcpu_notifier(&qdf_cpuhp_notifier_block); +} + +static inline void qdf_cpuhp_unregister_callbacks(void) +{ + unregister_hotcpu_notifier(&qdf_cpuhp_notifier_block); +} +#else +static enum cpuhp_state registered_hotplug_state; + +static int qdf_cpuhp_up_handler(unsigned int cpu) +{ + __qdf_cpuhp_on_up(cpu); + + return 0; +} + +static int qdf_cpuhp_down_handler(unsigned int cpu) +{ + __qdf_cpuhp_on_down(cpu); + + return 0; +} + +static inline void qdf_cpuhp_register_callbacks(void) +{ + registered_hotplug_state = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, + "wlan/qca-qdf:online", + qdf_cpuhp_up_handler, + qdf_cpuhp_down_handler); +} + +static inline void qdf_cpuhp_unregister_callbacks(void) +{ + QDF_BUG(registered_hotplug_state); + if (registered_hotplug_state) + cpuhp_remove_state(registered_hotplug_state); +} +#endif /* KERNEL_VERSION(4, 6, 0) */ + +void __qdf_cpuhp_os_init(__qdf_cpuhp_emit on_up, __qdf_cpuhp_emit on_down) +{ + __qdf_cpuhp_on_up = on_up; + __qdf_cpuhp_on_down = on_down; + + qdf_cpuhp_register_callbacks(); +} + +void __qdf_cpuhp_os_deinit(void) +{ + qdf_cpuhp_unregister_callbacks(); +} + diff --git a/qdf/src/qdf_cpuhp.c b/qdf/src/qdf_cpuhp.c new file mode 100644 index 000000000000..ccccafd8f718 --- /dev/null +++ b/qdf/src/qdf_cpuhp.c @@ -0,0 +1,157 @@ +/* + * Copyright (c) 2017 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. + */ + +/** + * DOC: qdf_cpuhp (CPU hotplug) + * QCA driver framework (QDF) CPU hotplug APIs + */ + +#include "qdf_cpuhp.h" +#include "i_qdf_cpuhp.h" +#include "qdf_list.h" +#include "qdf_lock.h" + +static qdf_mutex_t qdf_cpuhp_lock; +static qdf_list_t qdf_cpuhp_handlers; + +struct qdf_cpuhp_handler { + qdf_list_node_t node; + void *context; + qdf_cpuhp_callback up_callback; + qdf_cpuhp_callback down_callback; +}; + +static void qdf_cpuhp_on_up(uint32_t cpu) +{ + QDF_STATUS status; + qdf_list_node_t *node; + + qdf_mutex_acquire(&qdf_cpuhp_lock); + + status = qdf_list_peek_front(&qdf_cpuhp_handlers, &node); + while (QDF_IS_STATUS_SUCCESS(status)) { + struct qdf_cpuhp_handler *handler = + qdf_container_of(node, struct qdf_cpuhp_handler, node); + if (handler->up_callback) + handler->up_callback(handler->context, cpu); + + status = qdf_list_peek_next(&qdf_cpuhp_handlers, node, &node); + } + + qdf_mutex_release(&qdf_cpuhp_lock); +} + +static void qdf_cpuhp_on_down(uint32_t cpu) +{ + QDF_STATUS status; + qdf_list_node_t *node; + + qdf_mutex_acquire(&qdf_cpuhp_lock); + + status = qdf_list_peek_front(&qdf_cpuhp_handlers, &node); + while (QDF_IS_STATUS_SUCCESS(status)) { + struct qdf_cpuhp_handler *handler = + qdf_container_of(node, struct qdf_cpuhp_handler, node); + if (handler->down_callback) + handler->down_callback(handler->context, cpu); + + status = qdf_list_peek_next(&qdf_cpuhp_handlers, node, &node); + } + + qdf_mutex_release(&qdf_cpuhp_lock); +} + +QDF_STATUS qdf_cpuhp_init(void) +{ + QDF_STATUS status; + + status = qdf_mutex_create(&qdf_cpuhp_lock); + if (QDF_IS_STATUS_ERROR(status)) + return status; + + qdf_list_create(&qdf_cpuhp_handlers, 0); + + __qdf_cpuhp_os_init(qdf_cpuhp_on_up, qdf_cpuhp_on_down); + + return QDF_STATUS_SUCCESS; +} + +QDF_STATUS qdf_cpuhp_deinit(void) +{ + __qdf_cpuhp_os_deinit(); + qdf_list_destroy(&qdf_cpuhp_handlers); + return qdf_mutex_destroy(&qdf_cpuhp_lock); +} + +QDF_STATUS qdf_cpuhp_register(struct qdf_cpuhp_handler **out_handler, + void *context, + qdf_cpuhp_callback up_callback, + qdf_cpuhp_callback down_callback) +{ + QDF_STATUS status; + struct qdf_cpuhp_handler *handler; + + *out_handler = NULL; + + handler = qdf_mem_malloc(sizeof(*handler)); + if (!handler) + return QDF_STATUS_E_NOMEM; + + handler->context = context; + handler->up_callback = up_callback; + handler->down_callback = down_callback; + + status = qdf_mutex_acquire(&qdf_cpuhp_lock); + if (QDF_IS_STATUS_ERROR(status)) + goto free_handler; + + status = qdf_list_insert_back(&qdf_cpuhp_handlers, &handler->node); + if (QDF_IS_STATUS_ERROR(status)) + goto release_lock; + + /* this can fail, but there isn't a good way to recover... */ + qdf_mutex_release(&qdf_cpuhp_lock); + + *out_handler = handler; + + return QDF_STATUS_SUCCESS; + +release_lock: + qdf_mutex_release(&qdf_cpuhp_lock); + +free_handler: + qdf_mem_free(handler); + + return status; +} + +void qdf_cpuhp_unregister(struct qdf_cpuhp_handler **out_handler) +{ + struct qdf_cpuhp_handler *handler = *out_handler; + + QDF_BUG(handler); + if (!handler) + return; + + qdf_mutex_acquire(&qdf_cpuhp_lock); + qdf_list_remove_node(&qdf_cpuhp_handlers, &handler->node); + qdf_mutex_release(&qdf_cpuhp_lock); + + *out_handler = NULL; +} + From 88e0b955649a986d53f5f115b0cf5625d06ca1cb Mon Sep 17 00:00:00 2001 From: Yun Park Date: Wed, 11 Oct 2017 23:08:34 -0700 Subject: [PATCH 05/14] qcacmn: Remove local queue from send_packet_completion Static analys complains about the htc_pkt having a pointer to the local queue when the function returned. Remove the local queue so that it is not an issue. Requires epping to support individual single completions. Change-Id: I8f96420f5f6305c43051a21073607cdd6c603855 CRs-Fixed: 2125394 --- htc/htc_send.c | 79 ++++++++++++-------------------------------------- 1 file changed, 19 insertions(+), 60 deletions(-) diff --git a/htc/htc_send.c b/htc/htc_send.c index b404291895e6..91aeec425f16 100644 --- a/htc/htc_send.c +++ b/htc/htc_send.c @@ -188,61 +188,25 @@ static inline void restore_tx_packet(HTC_TARGET *target, HTC_PACKET *pPacket) } -static void do_send_completion(HTC_ENDPOINT *pEndpoint, - HTC_PACKET_QUEUE *pQueueToIndicate) -{ - do { - - if (HTC_QUEUE_EMPTY(pQueueToIndicate)) { - /* nothing to indicate */ - break; - } - - if (pEndpoint->EpCallBacks.EpTxCompleteMultiple != NULL) { - AR_DEBUG_PRINTF(ATH_DEBUG_SEND, - ("HTC calling ep %d, send complete multiple callback (%d pkts)\n", - pEndpoint->Id, - HTC_PACKET_QUEUE_DEPTH - (pQueueToIndicate))); - /* a multiple send complete handler is being used, pass - * the queue to the handler - */ - pEndpoint->EpCallBacks.EpTxCompleteMultiple( - pEndpoint->EpCallBacks.pContext, - pQueueToIndicate); - /* all packets are now owned by the callback, reset - * queue to be safe - */ - INIT_HTC_PACKET_QUEUE(pQueueToIndicate); - } else { - HTC_PACKET *pPacket; - /* using legacy EpTxComplete */ - do { - pPacket = htc_packet_dequeue(pQueueToIndicate); - AR_DEBUG_PRINTF(ATH_DEBUG_SEND, - ("HTC calling ep %d send complete callback on packet %pK\n", - pEndpoint->Id, pPacket)); - pEndpoint->EpCallBacks.EpTxComplete(pEndpoint-> - EpCallBacks. - pContext, - pPacket); - } while (!HTC_QUEUE_EMPTY(pQueueToIndicate)); - } - - } while (false); - -} - static void send_packet_completion(HTC_TARGET *target, HTC_PACKET *pPacket) { HTC_ENDPOINT *pEndpoint = &target->endpoint[pPacket->Endpoint]; - HTC_PACKET_QUEUE container; + HTC_EP_SEND_PKT_COMPLETE EpTxComplete; restore_tx_packet(target, pPacket); - INIT_HTC_PACKET_QUEUE_AND_ADD(&container, pPacket); /* do completion */ - do_send_completion(pEndpoint, &container); + AR_DEBUG_PRINTF(ATH_DEBUG_SEND, + ("HTC calling ep %d send complete callback on packet %pK\n", + pEndpoint->Id, pPacket)); + + EpTxComplete = pEndpoint->EpCallBacks.EpTxComplete; + if (EpTxComplete != NULL) + EpTxComplete(pEndpoint->EpCallBacks.pContext, pPacket); + else + qdf_nbuf_free(pPacket->pPktContext); + + } void htc_send_complete_check_cleanup(void *context) @@ -1535,20 +1499,15 @@ QDF_STATUS htc_send_pkts_multiple(HTC_HANDLE HTCHandle, #endif /* do completion on any packets that couldn't get in */ - if (!HTC_QUEUE_EMPTY(pPktQueue)) { + while (!HTC_QUEUE_EMPTY(pPktQueue)) { + pPacket = htc_packet_dequeue(pPktQueue); - HTC_PACKET_QUEUE_ITERATE_ALLOW_REMOVE(pPktQueue, pPacket) { - /* remove the headroom reserved for HTC_FRAME_HDR */ - restore_tx_packet(target, pPacket); + if (HTC_STOPPING(target)) + pPacket->Status = QDF_STATUS_E_CANCELED; + else + pPacket->Status = QDF_STATUS_E_RESOURCES; - if (HTC_STOPPING(target)) - pPacket->Status = QDF_STATUS_E_CANCELED; - else - pPacket->Status = QDF_STATUS_E_RESOURCES; - } - HTC_PACKET_QUEUE_ITERATE_END; - - do_send_completion(pEndpoint, pPktQueue); + send_packet_completion(target, pPacket); } AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("-htc_send_pkts_multiple\n")); From 0087818a2518e7c7f35375262a7bba6cebf38f06 Mon Sep 17 00:00:00 2001 From: Krunal Soni Date: Tue, 24 Oct 2017 23:33:05 -0700 Subject: [PATCH 06/14] qcacmn: Fix to propagate key-receiver-sequence-counter to WMI SME module propagates KeyRSC to MAC/PE module but MAC/PE doesn't pass this counter to WMA and due to which WMA is not able pass to WMI module. Add a fix to propagate KeyRSC field from MAC to WMA module and WMA to WMI module. CRs-Fixed: 2130765 Change-Id: I0de6907bf8aa159eccb1d8310e7027f8fdf19fff --- wmi/src/wmi_unified_tlv.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/wmi/src/wmi_unified_tlv.c b/wmi/src/wmi_unified_tlv.c index e59ea9c1f208..74065f281bd7 100644 --- a/wmi/src/wmi_unified_tlv.c +++ b/wmi/src/wmi_unified_tlv.c @@ -4940,6 +4940,9 @@ static QDF_STATUS send_setup_install_key_cmd_tlv(wmi_unified_t wmi_handle, key_data = (A_UINT8 *) (buf_ptr + WMI_TLV_HDR_SIZE); qdf_mem_copy((void *)key_data, (const void *)key_params->key_data, key_params->key_len); + if (key_params->key_rsc_counter) + qdf_mem_copy(&cmd->key_rsc_counter, key_params->key_rsc_counter, + sizeof(wmi_key_seq_counter)); cmd->key_len = key_params->key_len; status = wmi_unified_cmd_send(wmi_handle, buf, len, From 101b8b4cde24b65ca3f50ff098413134ce21de3c Mon Sep 17 00:00:00 2001 From: Anirban Sirkhell Date: Wed, 1 Mar 2017 10:32:33 +0800 Subject: [PATCH 07/14] qcacmn: Add vdev param to enable/disable buffering of mcast frames Add WMI vdev param to indicate firmware not to buffer mcast frames even when clients are in power-save. CRs-Fixed: 2133095 Change-Id: I4fe936e6a490ec8007f909e1ba079bec2f2713cd --- wmi/inc/wmi_unified_param.h | 1 + wmi/src/wmi_unified_non_tlv.c | 2 ++ 2 files changed, 3 insertions(+) diff --git a/wmi/inc/wmi_unified_param.h b/wmi/inc/wmi_unified_param.h index 45acbeaf67c4..896c5cb8d13b 100644 --- a/wmi/inc/wmi_unified_param.h +++ b/wmi/inc/wmi_unified_param.h @@ -5664,6 +5664,7 @@ typedef enum { wmi_vdev_param_set_hemu_mode, wmi_vdev_param_set_he_ltf, wmi_vdev_param_set_heop, + wmi_vdev_param_disable_cabq, wmi_vdev_param_max, } wmi_conv_vdev_param_id; diff --git a/wmi/src/wmi_unified_non_tlv.c b/wmi/src/wmi_unified_non_tlv.c index ab150c7acd37..c662b64637ef 100644 --- a/wmi/src/wmi_unified_non_tlv.c +++ b/wmi/src/wmi_unified_non_tlv.c @@ -8987,6 +8987,8 @@ static void populate_vdev_param_non_tlv(uint32_t *vdev_param) WMI_VDEV_PARAM_DISABLE_DYN_BW_RTS; vdev_param[wmi_vdev_param_ampdu_subframe_size_per_ac] = WMI_VDEV_PARAM_AMPDU_SUBFRAME_SIZE_PER_AC; + vdev_param[wmi_vdev_param_disable_cabq] = + WMI_VDEV_PARAM_DISABLE_CABQ; } #endif From d6eb35e9f2b384d507c00967c99c1cf5381e1308 Mon Sep 17 00:00:00 2001 From: Om Prakash Tripathi Date: Tue, 7 Nov 2017 14:37:22 +0530 Subject: [PATCH 08/14] qcacmn: Get WMI_SERVICE_THERM_THROT capability from FW Host enables thermal throttle depending on FW capability. Add support to read this capability from ext service ready. Change-Id: Ifafc24deac0bac228c98750f54e95fdfa3377a6a CRs-Fixed: 2128049 --- wmi/src/wmi_unified_tlv.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/wmi/src/wmi_unified_tlv.c b/wmi/src/wmi_unified_tlv.c index 74065f281bd7..15931a4c656a 100644 --- a/wmi/src/wmi_unified_tlv.c +++ b/wmi/src/wmi_unified_tlv.c @@ -16304,6 +16304,10 @@ QDF_STATUS save_ext_service_bitmap_tlv(wmi_unified_t wmi_handle, void *evt_buf, ev->wmi_service_segment_bitmap, (WMI_SERVICE_SEGMENT_BM_SIZE32 * sizeof(uint32_t))); + WMI_LOGD("wmi_ext_service_bitmap 0:0x%x, 1:0x%x, 2:0x%x, 3:0x%x\n", + soc->wmi_ext_service_bitmap[0], soc->wmi_ext_service_bitmap[1], + soc->wmi_ext_service_bitmap[2], soc->wmi_ext_service_bitmap[3]); + if (bitmap_buf) qdf_mem_copy(bitmap_buf, soc->wmi_ext_service_bitmap, @@ -20359,7 +20363,7 @@ static void populate_tlv_service(uint32_t *wmi_service) wmi_service[wmi_service_smart_antenna_hw_support] = WMI_SERVICE_UNAVAILABLE; wmi_service[wmi_service_enhanced_proxy_sta] = WMI_SERVICE_UNAVAILABLE; - wmi_service[wmi_service_tt] = WMI_SERVICE_UNAVAILABLE; + wmi_service[wmi_service_tt] = WMI_SERVICE_THERM_THROT; wmi_service[wmi_service_atf] = WMI_SERVICE_ATF; wmi_service[wmi_service_peer_caching] = WMI_SERVICE_UNAVAILABLE; wmi_service[wmi_service_coex_gpio] = WMI_SERVICE_UNAVAILABLE; From 1f88428baf79d95bd9afbcb68ff5e604e1781dfe Mon Sep 17 00:00:00 2001 From: Arif Hussain Date: Fri, 3 Nov 2017 14:22:49 -0700 Subject: [PATCH 09/14] qcacmn: Replace instances of unadorned pointer reference in DFS Replace all instances of %p with %pK in DFS component, so that kernel pointers are hidden from unprivileged users. Change-Id: Ia10971516bf962287af9ff8dce873888500a01a1 CRs-fixed: 2133321 --- umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c b/umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c index 047907e5a861..1d9fe71c3221 100644 --- a/umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c +++ b/umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c @@ -360,7 +360,7 @@ QDF_STATUS tgt_dfs_process_emulate_bang_radar_cmd(struct wlan_objmgr_pdev *pdev, dfs_unit_test); else dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS, - "dfs_tx_ops=%p", dfs_tx_ops); + "dfs_tx_ops=%pK", dfs_tx_ops); return QDF_STATUS_E_FAILURE; } From 87f0c5d850bd0fe926a6797c7c8d8bc66fa70a16 Mon Sep 17 00:00:00 2001 From: Karunakar Dasineni Date: Sun, 29 Oct 2017 21:54:21 -0700 Subject: [PATCH 10/14] qcacmn: Replenish Rx buffers on low threshold intr Replenish buffers in RXDMA refill ring based on low threshold interrupts in addition to regular Rx processing. Also increased RXDMA refill ring size to 4096. Change-Id: If1f4592c815fe2404c4952a96b721cb6d4fdfcd0 --- dp/inc/cdp_txrx_cmn_struct.h | 2 + dp/wifi3.0/dp_main.c | 85 +++++++++++++++++++++++++++++++++--- dp/wifi3.0/dp_rx.c | 42 +++++++++++------- dp/wifi3.0/dp_rx_desc.c | 3 +- dp/wifi3.0/dp_rx_err.c | 6 +-- dp/wifi3.0/dp_types.h | 2 + wlan_cfg/wlan_cfg.c | 27 +++++++++++- wlan_cfg/wlan_cfg.h | 22 ++++++++++ 8 files changed, 164 insertions(+), 25 deletions(-) diff --git a/dp/inc/cdp_txrx_cmn_struct.h b/dp/inc/cdp_txrx_cmn_struct.h index 3deded7e2370..197ece62d030 100644 --- a/dp/inc/cdp_txrx_cmn_struct.h +++ b/dp/inc/cdp_txrx_cmn_struct.h @@ -991,6 +991,8 @@ struct cdp_pdev_stats { uint32_t map_err; /* x86 failures */ uint32_t x86_fail; + /* low threshold interrupts */ + uint32_t low_thresh_intrs; } replenish; /* Rx Raw Packets */ diff --git a/dp/wifi3.0/dp_main.c b/dp/wifi3.0/dp_main.c index a52c9172f612..480727188b3b 100644 --- a/dp/wifi3.0/dp_main.c +++ b/dp/wifi3.0/dp_main.c @@ -339,8 +339,11 @@ static int dp_srng_calculate_msi_group(struct dp_soc *soc, grp_mask = &soc->wlan_cfg_ctx->int_rxdma2host_ring_mask[0]; break; - case RXDMA_MONITOR_BUF: case RXDMA_BUF: + grp_mask = &soc->wlan_cfg_ctx->int_host2rxdma_ring_mask[0]; + break; + + case RXDMA_MONITOR_BUF: /* TODO: support low_thresh interrupt */ return -QDF_STATUS_E_NOENT; break; @@ -490,6 +493,7 @@ static int dp_srng_setup(struct dp_soc *soc, struct dp_srng *srng, num_entries = (num_entries > max_entries) ? max_entries : num_entries; srng->hal_srng = NULL; srng->alloc_size = (num_entries * entry_size) + ring_base_align - 1; + srng->num_entries = num_entries; srng->base_vaddr_unaligned = qdf_mem_alloc_consistent( soc->osdev, soc->osdev->dev, srng->alloc_size, &(srng->base_paddr_unaligned)); @@ -608,6 +612,7 @@ static uint32_t dp_service_srngs(void *dp_ctx, uint32_t dp_budget) uint8_t rx_wbm_rel_mask = int_ctx->rx_wbm_rel_ring_mask; uint8_t reo_status_mask = int_ctx->reo_status_ring_mask; uint32_t remaining_quota = dp_budget; + struct dp_pdev *pdev = NULL; /* Process Tx completion interrupts first to return back buffers */ while (tx_mask) { @@ -689,11 +694,14 @@ static uint32_t dp_service_srngs(void *dp_ctx, uint32_t dp_budget) /* Process LMAC interrupts */ for (ring = 0 ; ring < MAX_PDEV_CNT; ring++) { - if (soc->pdev_list[ring] == NULL) + pdev = soc->pdev_list[ring]; + if (pdev == NULL) continue; if (int_ctx->rx_mon_ring_mask & (1 << ring)) { work_done = dp_mon_process(soc, ring, remaining_quota); budget -= work_done; + if (budget <= 0) + goto budget_done; remaining_quota = budget; } @@ -701,6 +709,22 @@ static uint32_t dp_service_srngs(void *dp_ctx, uint32_t dp_budget) work_done = dp_rxdma_err_process(soc, ring, remaining_quota); budget -= work_done; + if (budget <= 0) + goto budget_done; + remaining_quota = budget; + } + + if (int_ctx->host2rxdma_ring_mask & (1 << ring)) { + union dp_rx_desc_list_elem_t *desc_list = NULL; + union dp_rx_desc_list_elem_t *tail = NULL; + struct dp_srng *rx_refill_buf_ring = + &pdev->rx_refill_buf_ring; + + DP_STATS_INC(pdev, replenish.low_thresh_intrs, 1); + dp_rx_buffers_replenish(soc, ring, + rx_refill_buf_ring, + &soc->rx_desc_buf[ring], 0, + &desc_list, &tail, HAL_RX_BUF_RBM_SW3_BM); } } @@ -758,6 +782,7 @@ static QDF_STATUS dp_soc_interrupt_attach_poll(void *txrx_soc) soc->intr_ctx[i].rx_wbm_rel_ring_mask = 0x1; soc->intr_ctx[i].reo_status_ring_mask = 0x1; soc->intr_ctx[i].rxdma2host_ring_mask = 0x1; + soc->intr_ctx[i].host2rxdma_ring_mask = 0x1; soc->intr_ctx[i].soc = soc; soc->intr_ctx[i].lro_ctx = qdf_lro_init(); } @@ -825,6 +850,8 @@ static void dp_soc_interrupt_map_calculate_integrated(struct dp_soc *soc, soc->wlan_cfg_ctx, intr_ctx_num); int rxdma2host_ring_mask = wlan_cfg_get_rxdma2host_ring_mask( soc->wlan_cfg_ctx, intr_ctx_num); + int host2rxdma_ring_mask = wlan_cfg_get_host2rxdma_ring_mask( + soc->wlan_cfg_ctx, intr_ctx_num); for (j = 0; j < HIF_MAX_GRP_IRQ; j++) { @@ -844,6 +871,12 @@ static void dp_soc_interrupt_map_calculate_integrated(struct dp_soc *soc, wlan_cfg_get_hw_mac_idx(soc->wlan_cfg_ctx, j); } + if (host2rxdma_ring_mask & (1 << j)) { + irq_id_map[num_irq++] = + host2rxdma_host_buf_ring_mac1 - + wlan_cfg_get_hw_mac_idx(soc->wlan_cfg_ctx, j); + } + if (rx_mon_mask & (1 << j)) { irq_id_map[num_irq++] = ppdu_end_interrupts_mac1 - @@ -953,6 +986,9 @@ static QDF_STATUS dp_soc_interrupt_attach(void *txrx_soc) wlan_cfg_get_reo_status_ring_mask(soc->wlan_cfg_ctx, i); int rxdma2host_ring_mask = wlan_cfg_get_rxdma2host_ring_mask(soc->wlan_cfg_ctx, i); + int host2rxdma_ring_mask = + wlan_cfg_get_host2rxdma_ring_mask(soc->wlan_cfg_ctx, i); + soc->intr_ctx[i].dp_intr_id = i; soc->intr_ctx[i].tx_ring_mask = tx_mask; @@ -960,6 +996,7 @@ static QDF_STATUS dp_soc_interrupt_attach(void *txrx_soc) soc->intr_ctx[i].rx_mon_ring_mask = rx_mon_mask; soc->intr_ctx[i].rx_err_ring_mask = rx_err_ring_mask; soc->intr_ctx[i].rxdma2host_ring_mask = rxdma2host_ring_mask; + soc->intr_ctx[i].host2rxdma_ring_mask = host2rxdma_ring_mask; soc->intr_ctx[i].rx_wbm_rel_ring_mask = rx_wbm_rel_ring_mask; soc->intr_ctx[i].reo_status_ring_mask = reo_status_ring_mask; @@ -1015,6 +1052,7 @@ static void dp_soc_interrupt_detach(void *txrx_soc) soc->intr_ctx[i].rx_wbm_rel_ring_mask = 0; soc->intr_ctx[i].reo_status_ring_mask = 0; soc->intr_ctx[i].rxdma2host_ring_mask = 0; + soc->intr_ctx[i].host2rxdma_ring_mask = 0; qdf_lro_deinit(soc->intr_ctx[i].lro_ctx); } @@ -1344,7 +1382,7 @@ static void dp_hw_link_desc_pool_cleanup(struct dp_soc *soc) #define REO_CMD_RING_SIZE 32 #define REO_STATUS_RING_SIZE 32 #define RXDMA_BUF_RING_SIZE 1024 -#define RXDMA_REFILL_RING_SIZE 2048 +#define RXDMA_REFILL_RING_SIZE 4096 #define RXDMA_MONITOR_BUF_RING_SIZE 4096 #define RXDMA_MONITOR_DST_RING_SIZE 2048 #define RXDMA_MONITOR_STATUS_RING_SIZE 1024 @@ -1489,6 +1527,7 @@ static uint8_t dp_soc_ring_if_nss_offloaded(struct dp_soc *soc, enum hal_ring_ty switch (ring_type) { case WBM2SW_RELEASE: case REO_DST: + case RXDMA_BUF: status = ((nss_config) & (1 << ring_num)); break; default: @@ -1530,7 +1569,7 @@ static void dp_soc_reset_intr_mask(struct dp_soc *soc) group_number = dp_srng_find_ring_in_mask(j, grp_mask); if (group_number < 0) { QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, - FL("ring not part of an group; ring_type: %d,ring_num %d"), + FL("ring not part of any group; ring_type: %d,ring_num %d"), WBM2SW_RELEASE, j); return; } @@ -1565,7 +1604,7 @@ static void dp_soc_reset_intr_mask(struct dp_soc *soc) group_number = dp_srng_find_ring_in_mask(j, grp_mask); if (group_number < 0) { QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, - FL("ring not part of an group; ring_type: %d,ring_num %d"), + FL("ring not part of any group; ring_type: %d,ring_num %d"), REO_DST, j); return; } @@ -1579,6 +1618,40 @@ static void dp_soc_reset_intr_mask(struct dp_soc *soc) */ wlan_cfg_set_rx_ring_mask(soc->wlan_cfg_ctx, group_number, mask); } + + /* + * group mask for Rx buffer refill ring + */ + grp_mask = &soc->wlan_cfg_ctx->int_host2rxdma_ring_mask[0]; + + /* loop and reset the mask for only offloaded ring */ + for (j = 0; j < MAX_PDEV_CNT; j++) { + if (!dp_soc_ring_if_nss_offloaded(soc, RXDMA_BUF, j)) { + continue; + } + + /* + * Group number corresponding to rx offloaded ring. + */ + group_number = dp_srng_find_ring_in_mask(j, grp_mask); + if (group_number < 0) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, + FL("ring not part of any group; ring_type: %d,ring_num %d"), + REO_DST, j); + return; + } + + /* set the interrupt mask for offloaded ring */ + mask = wlan_cfg_get_host2rxdma_ring_mask(soc->wlan_cfg_ctx, + group_number); + mask &= (~(1 << j)); + + /* + * set the interrupt mask to zero for rx offloaded radio. + */ + wlan_cfg_set_host2rxdma_ring_mask(soc->wlan_cfg_ctx, + group_number, mask); + } } #ifdef IPA_OFFLOAD @@ -3857,6 +3930,8 @@ dp_print_pdev_rx_stats(struct dp_pdev *pdev) pdev->stats.replenish.pkts.bytes); DP_PRINT_STATS(" Buffers Added To Freelist = %d", pdev->stats.buf_freelist); + DP_PRINT_STATS(" Low threshold intr = %d", + pdev->stats.replenish.low_thresh_intrs); DP_PRINT_STATS("Dropped:"); DP_PRINT_STATS(" msdu_not_done = %d", pdev->stats.dropped.msdu_not_done); diff --git a/dp/wifi3.0/dp_rx.c b/dp/wifi3.0/dp_rx.c index 7b139ad31117..d088a965eca3 100644 --- a/dp/wifi3.0/dp_rx.c +++ b/dp/wifi3.0/dp_rx.c @@ -107,6 +107,29 @@ QDF_STATUS dp_rx_buffers_replenish(struct dp_soc *dp_soc, uint32_t mac_id, QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, "requested %d buffers for replenish", num_req_buffers); + hal_srng_access_start(dp_soc->hal_soc, rxdma_srng); + num_entries_avail = hal_srng_src_num_avail(dp_soc->hal_soc, + rxdma_srng, + sync_hw_ptr); + + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, + "no of availble entries in rxdma ring: %d", + num_entries_avail); + + if (!(*desc_list) && (num_entries_avail > + ((dp_rxdma_srng->num_entries * 3) / 4))) { + num_req_buffers = num_entries_avail; + } else if (num_entries_avail < num_req_buffers) { + num_desc_to_free = num_req_buffers - num_entries_avail; + num_req_buffers = num_entries_avail; + } + + if (qdf_unlikely(!num_req_buffers)) { + num_desc_to_free = num_req_buffers; + hal_srng_access_end(dp_soc->hal_soc, rxdma_srng); + goto free_descs; + } + /* * if desc_list is NULL, allocate the descs from freelist */ @@ -122,6 +145,7 @@ QDF_STATUS dp_rx_buffers_replenish(struct dp_soc *dp_soc, uint32_t mac_id, "no free rx_descs in freelist"); DP_STATS_INC(dp_pdev, err.desc_alloc_fail, num_req_buffers); + hal_srng_access_end(dp_soc->hal_soc, rxdma_srng); return QDF_STATUS_E_NOMEM; } @@ -130,19 +154,6 @@ QDF_STATUS dp_rx_buffers_replenish(struct dp_soc *dp_soc, uint32_t mac_id, num_req_buffers = num_alloc_desc; } - hal_srng_access_start(dp_soc->hal_soc, rxdma_srng); - num_entries_avail = hal_srng_src_num_avail(dp_soc->hal_soc, - rxdma_srng, - sync_hw_ptr); - - QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, - "no of availble entries in rxdma ring: %d", - num_entries_avail); - - if (num_entries_avail < num_req_buffers) { - num_desc_to_free = num_req_buffers - num_entries_avail; - num_req_buffers = num_entries_avail; - } count = 0; @@ -208,10 +219,11 @@ QDF_STATUS dp_rx_buffers_replenish(struct dp_soc *dp_soc, uint32_t mac_id, QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, "%d rx desc added back to free list", num_desc_to_free); - DP_STATS_INC(dp_pdev, buf_freelist, num_desc_to_free); DP_STATS_INC_PKT(dp_pdev, replenish.pkts, num_req_buffers, (RX_BUFFER_SIZE * num_req_buffers)); +free_descs: + DP_STATS_INC(dp_pdev, buf_freelist, num_desc_to_free); /* * add any available free desc back to the free list */ @@ -1449,7 +1461,7 @@ dp_rx_pdev_attach(struct dp_pdev *pdev) /* For Rx buffers, WBM release ring is SW RING 3,for all pdev's */ dp_rxdma_srng = &pdev->rx_refill_buf_ring; dp_rx_buffers_replenish(soc, pdev_id, dp_rxdma_srng, rx_desc_pool, - rxdma_entries, &desc_list, &tail, HAL_RX_BUF_RBM_SW3_BM); + 0, &desc_list, &tail, HAL_RX_BUF_RBM_SW3_BM); return QDF_STATUS_SUCCESS; } diff --git a/dp/wifi3.0/dp_rx_desc.c b/dp/wifi3.0/dp_rx_desc.c index 621c0f78c771..b91dbae4a0fd 100644 --- a/dp/wifi3.0/dp_rx_desc.c +++ b/dp/wifi3.0/dp_rx_desc.c @@ -126,6 +126,7 @@ uint16_t dp_rx_get_free_desc_list(struct dp_soc *soc, uint32_t pool_id, return count; } } + (*tail)->next = NULL; qdf_spin_unlock_bh(&soc->rx_desc_mutex[pool_id]); return count; } @@ -152,7 +153,7 @@ void dp_rx_add_desc_list_to_free_list(struct dp_soc *soc, temp_list = rx_desc_pool->freelist; - qdf_print( + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG, "temp_list: %pK, *local_desc_list: %pK, *tail: %pK (*tail)->next: %pK\n", temp_list, *local_desc_list, *tail, (*tail)->next); rx_desc_pool->freelist = *local_desc_list; diff --git a/dp/wifi3.0/dp_rx_err.c b/dp/wifi3.0/dp_rx_err.c index a77ef50c1182..0045eb601936 100644 --- a/dp/wifi3.0/dp_rx_err.c +++ b/dp/wifi3.0/dp_rx_err.c @@ -992,7 +992,7 @@ dp_rx_wbm_err_process(struct dp_soc *soc, void *hal_ring, uint32_t quota) default: QDF_TRACE(QDF_MODULE_ID_DP, - QDF_TRACE_LEVEL_ERROR, + QDF_TRACE_LEVEL_DEBUG, "REO error %d detected", reo_error_code); } @@ -1029,13 +1029,13 @@ dp_rx_wbm_err_process(struct dp_soc *soc, void *hal_ring, uint32_t quota) case HAL_RXDMA_ERR_DECRYPT: QDF_TRACE(QDF_MODULE_ID_DP, - QDF_TRACE_LEVEL_ERROR, + QDF_TRACE_LEVEL_DEBUG, "Packet received with Decrypt error"); break; default: QDF_TRACE(QDF_MODULE_ID_DP, - QDF_TRACE_LEVEL_ERROR, + QDF_TRACE_LEVEL_DEBUG, "RXDMA error %d", rxdma_error_code); } diff --git a/dp/wifi3.0/dp_types.h b/dp/wifi3.0/dp_types.h index 2a56d63fd7f5..1eeb42280deb 100644 --- a/dp/wifi3.0/dp_types.h +++ b/dp/wifi3.0/dp_types.h @@ -358,6 +358,7 @@ struct dp_srng { qdf_dma_addr_t base_paddr_unaligned; uint32_t alloc_size; int irq; + uint32_t num_entries; }; struct dp_rx_reorder_array_elem { @@ -427,6 +428,7 @@ struct dp_intr { uint8_t rx_wbm_rel_ring_mask; /* WBM2SW Rx Release Ring */ uint8_t reo_status_ring_mask; /* REO command response ring */ uint8_t rxdma2host_ring_mask; /* RXDMA to host destination ring */ + uint8_t host2rxdma_ring_mask; /* Host to RXDMA buffer ring */ struct dp_soc *soc; /* Reference to SoC structure , to get DMA ring handles */ qdf_lro_ctx_t lro_ctx; diff --git a/wlan_cfg/wlan_cfg.c b/wlan_cfg/wlan_cfg.c index 511945c604b3..ae124c27a849 100644 --- a/wlan_cfg/wlan_cfg.c +++ b/wlan_cfg/wlan_cfg.c @@ -77,7 +77,7 @@ /* Interrupt Mitigation - Timer threshold in us */ #define WLAN_CFG_INT_TIMER_THRESHOLD_TX 1000 #define WLAN_CFG_INT_TIMER_THRESHOLD_RX 500 -#define WLAN_CFG_INT_TIMER_THRESHOLD_OTHER 8 +#define WLAN_CFG_INT_TIMER_THRESHOLD_OTHER 1000 #define WLAN_CFG_TX_RING_SIZE 512 @@ -159,6 +159,11 @@ #define WLAN_CFG_RXDMA2HOST_RING_MASK_2 0x4 #define WLAN_CFG_RXDMA2HOST_RING_MASK_3 0x0 +#define WLAN_CFG_HOST2RXDMA_RING_MASK_0 0x1 +#define WLAN_CFG_HOST2RXDMA_RING_MASK_1 0x2 +#define WLAN_CFG_HOST2RXDMA_RING_MASK_2 0x4 +#define WLAN_CFG_HOST2RXDMA_RING_MASK_3 0x0 + #define WLAN_CFG_DP_TX_NUM_POOLS 3 /* Change this to a lower value to enforce scattered idle list mode */ #define WLAN_CFG_MAX_ALLOC_SIZE (2 << 20) @@ -254,6 +259,12 @@ static const int rxdma2host_ring_mask[WLAN_CFG_INT_NUM_CONTEXTS] = { WLAN_CFG_RXDMA2HOST_RING_MASK_2, WLAN_CFG_RXDMA2HOST_RING_MASK_3}; +static const int host2rxdma_ring_mask[WLAN_CFG_INT_NUM_CONTEXTS] = { + WLAN_CFG_HOST2RXDMA_RING_MASK_0, + WLAN_CFG_HOST2RXDMA_RING_MASK_1, + WLAN_CFG_HOST2RXDMA_RING_MASK_2, + WLAN_CFG_HOST2RXDMA_RING_MASK_3}; + /** * struct wlan_cfg_dp_pdev_ctxt - Configuration parameters for pdev (radio) * @rx_dma_buf_ring_size - Size of RxDMA buffer ring @@ -322,6 +333,8 @@ struct wlan_cfg_dp_soc_ctxt *wlan_cfg_soc_attach() reo_status_ring_mask[i]; wlan_cfg_ctx->int_rxdma2host_ring_mask[i] = rxdma2host_ring_mask[i]; + wlan_cfg_ctx->int_host2rxdma_ring_mask[i] = + host2rxdma_ring_mask[i]; } /* This is default mapping and can be overridden by HW config @@ -404,6 +417,18 @@ int wlan_cfg_get_rxdma2host_ring_mask(struct wlan_cfg_dp_soc_ctxt *cfg, return cfg->int_rxdma2host_ring_mask[context]; } +void wlan_cfg_set_host2rxdma_ring_mask(struct wlan_cfg_dp_soc_ctxt *cfg, + int context, int mask) +{ + cfg->int_host2rxdma_ring_mask[context] = mask; +} + +int wlan_cfg_get_host2rxdma_ring_mask(struct wlan_cfg_dp_soc_ctxt *cfg, + int context) +{ + return cfg->int_host2rxdma_ring_mask[context]; +} + void wlan_cfg_set_hw_macid(struct wlan_cfg_dp_soc_ctxt *cfg, int pdev_idx, int hw_macid) { diff --git a/wlan_cfg/wlan_cfg.h b/wlan_cfg/wlan_cfg.h index d28c301ff4b5..01bb228c8758 100644 --- a/wlan_cfg/wlan_cfg.h +++ b/wlan_cfg/wlan_cfg.h @@ -128,6 +128,7 @@ struct wlan_cfg_dp_soc_ctxt { int int_rx_wbm_rel_ring_mask[WLAN_CFG_INT_NUM_CONTEXTS]; int int_reo_status_ring_mask[WLAN_CFG_INT_NUM_CONTEXTS]; int int_rxdma2host_ring_mask[WLAN_CFG_INT_NUM_CONTEXTS]; + int int_host2rxdma_ring_mask[WLAN_CFG_INT_NUM_CONTEXTS]; int hw_macid[MAX_PDEV_CNT]; int base_hw_macid; bool lro_enabled; @@ -268,6 +269,27 @@ void wlan_cfg_set_rxdma2host_ring_mask(struct wlan_cfg_dp_soc_ctxt *cfg, int wlan_cfg_get_rxdma2host_ring_mask(struct wlan_cfg_dp_soc_ctxt *cfg, int context); +/** + * wlan_cfg_set_host2rxdma_ring_mask() - Set host2rxdma ring interrupt mask + * for the given interrupt context + * @wlan_cfg_ctx - Configuration Handle + * @context - Numerical ID identifying the Interrupt/NAPI context + * + */ +void wlan_cfg_set_host2rxdma_ring_mask(struct wlan_cfg_dp_soc_ctxt *cfg, + int context, int mask); + +/** + * wlan_cfg_get_host2rxdma_ring_mask() - Return host2rxdma ring interrupt mask + * mapped to an interrupt context + * @wlan_cfg_ctx - Configuration Handle + * @context - Numerical ID identifying the Interrupt/NAPI context + * + * Return: int_host2rxdma_ring_mask[context] + */ +int wlan_cfg_get_host2rxdma_ring_mask(struct wlan_cfg_dp_soc_ctxt *cfg, + int context); + /** * wlan_cfg_set_hw_macid() - Set HW MAC Id for the given PDEV index * From a7ee2c65f7707fc9e482462b4bfa8b23b3aed1a9 Mon Sep 17 00:00:00 2001 From: Karunakar Dasineni Date: Tue, 31 Oct 2017 09:05:44 -0700 Subject: [PATCH 11/14] qcacmn: WAR for wrong MSDU count in Rx descriptor Due to a HW issue, msdu count received in REO entrance descriptor could be wrong in case of some error packets received on RXDMA2SW ring. Instead we should rely on Rx MSDU link descriptor entries being non-null to pop MSDUs. Change-Id: I1f4344752bdca13e9502aab79ee648b9b075d2e9 --- dp/wifi3.0/dp_rx_err.c | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/dp/wifi3.0/dp_rx_err.c b/dp/wifi3.0/dp_rx_err.c index 0045eb601936..1801065cbdcb 100644 --- a/dp/wifi3.0/dp_rx_err.c +++ b/dp/wifi3.0/dp_rx_err.c @@ -1133,11 +1133,7 @@ dp_rx_err_mpdu_pop(struct dp_soc *soc, uint32_t mac_id, qdf_assert(rx_msdu_link_desc); - num_msdus = (msdu_cnt > HAL_RX_NUM_MSDU_DESC)? - HAL_RX_NUM_MSDU_DESC:msdu_cnt; - hal_rx_msdu_list_get(rx_msdu_link_desc, &msdu_list, &num_msdus); - msdu_cnt -= num_msdus; if (msdu_list.sw_cookie[0] != HAL_RX_COOKIE_SPECIAL) { /* if the msdus belongs to NSS offloaded radio && @@ -1184,7 +1180,7 @@ dp_rx_err_mpdu_pop(struct dp_soc *soc, uint32_t mac_id, dp_rx_link_desc_return(soc, p_last_buf_addr_info, bm_action); p_last_buf_addr_info = p_buf_addr_info; - } while (buf_info.paddr && msdu_cnt); + } while (buf_info.paddr); DP_STATS_INC(soc, rx.err.rxdma_error[rxdma_error_code], 1); From 4711ade7bbff6abad6e9364092c426d57c3f65a9 Mon Sep 17 00:00:00 2001 From: Yun Park Date: Mon, 28 Aug 2017 21:49:31 -0700 Subject: [PATCH 12/14] qcacmn: Fix memmory leak from dp_tx_ipa_uc_detach IPA Tx buffers are allocated using qdf_mem_alloc_consistent, so free using qdf_mem_free_consistent. Change-Id: I0125189e1eec2a45f06bc7c2662d65c8745b3d3e CRs-Fixed: 2135803 --- dp/wifi3.0/dp_ipa.c | 152 +++++++++++++++++++++++++++--------------- dp/wifi3.0/dp_types.h | 3 +- 2 files changed, 102 insertions(+), 53 deletions(-) diff --git a/dp/wifi3.0/dp_ipa.c b/dp/wifi3.0/dp_ipa.c index 604a46bbc26d..ca1e3f4c2f98 100644 --- a/dp/wifi3.0/dp_ipa.c +++ b/dp/wifi3.0/dp_ipa.c @@ -29,6 +29,9 @@ #include "dp_tx.h" #include "dp_ipa.h" +/* Hard coded config parameters until dp_ops_cfg.cfg_attach implemented */ +#define CFG_IPA_UC_TX_BUF_SIZE_DEFAULT (2048) + /** * dp_tx_ipa_uc_detach - Free autonomy TX resources * @soc: data path instance @@ -41,16 +44,37 @@ static void dp_tx_ipa_uc_detach(struct dp_soc *soc, struct dp_pdev *pdev) { int idx; + uint32_t ring_base_align = 8; + /* + * Uncomment when dp_ops_cfg.cfg_attach is implemented + * unsigned int uc_tx_buf_sz = + * dp_cfg_ipa_uc_tx_buf_size(pdev->osif_pdev); + */ + unsigned int uc_tx_buf_sz = CFG_IPA_UC_TX_BUF_SIZE_DEFAULT; + unsigned int alloc_size = uc_tx_buf_sz + ring_base_align - 1; for (idx = 0; idx < soc->ipa_uc_tx_rsc.alloc_tx_buf_cnt; idx++) { - if (soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr[idx]) { - qdf_mem_free(soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr[idx]); - soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr[idx] = NULL; + if (soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr_unaligned[idx]) { + qdf_mem_free_consistent( + soc->osdev, soc->osdev->dev, + alloc_size, + soc->ipa_uc_tx_rsc. + tx_buf_pool_vaddr_unaligned[idx], + soc->ipa_uc_tx_rsc. + tx_buf_pool_paddr_unaligned[idx], + 0); + + soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr_unaligned[idx] = + (void *)NULL; + soc->ipa_uc_tx_rsc.tx_buf_pool_paddr_unaligned[idx] = + (qdf_dma_addr_t)NULL; } } - qdf_mem_free(soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr); - soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr = NULL; + qdf_mem_free(soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr_unaligned); + soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr_unaligned = NULL; + qdf_mem_free(soc->ipa_uc_tx_rsc.tx_buf_pool_paddr_unaligned); + soc->ipa_uc_tx_rsc.tx_buf_pool_paddr_unaligned = NULL; } /** @@ -78,9 +102,6 @@ int dp_ipa_uc_detach(struct dp_soc *soc, struct dp_pdev *pdev) return QDF_STATUS_SUCCESS; /* success */ } -/* Hard coded config parameters until dp_ops_cfg.cfg_attach implemented */ -#define CFG_IPA_UC_TX_BUF_SIZE_DEFAULT (2048) - /** * dp_tx_ipa_uc_attach - Allocate autonomy TX resources * @soc: data path instance @@ -118,15 +139,28 @@ static int dp_tx_ipa_uc_attach(struct dp_soc *soc, struct dp_pdev *pdev) hal_get_srng_params(soc->hal_soc, (void *)wbm_srng, &srng_params); num_entries = srng_params.num_entries; - QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, - "requested %d buffers to be posted to wbm ring", - num_entries); + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO, + "%s: requested %d buffers to be posted to wbm ring", + __func__, num_entries); - soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr = qdf_mem_malloc(num_entries * - sizeof(*soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr)); - if (!soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr) { + soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr_unaligned = + qdf_mem_malloc(num_entries * + sizeof(*soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr_unaligned)); + if (!soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr_unaligned) { QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, - "%s: IPA WBM Ring mem_info alloc fail", __func__); + "%s: IPA WBM Ring Tx buf pool vaddr alloc fail", + __func__); + return -ENOMEM; + } + + soc->ipa_uc_tx_rsc.tx_buf_pool_paddr_unaligned = + qdf_mem_malloc(num_entries * + sizeof(*soc->ipa_uc_tx_rsc.tx_buf_pool_paddr_unaligned)); + if (!soc->ipa_uc_tx_rsc.tx_buf_pool_paddr_unaligned) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, + "%s: IPA WBM Ring Tx buf pool paddr alloc fail", + __func__); + qdf_mem_free(soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr_unaligned); return -ENOMEM; } @@ -148,12 +182,13 @@ static int dp_tx_ipa_uc_attach(struct dp_soc *soc, struct dp_pdev *pdev) ring_entry = hal_srng_dst_get_next_hp(soc->hal_soc, (void *)wbm_srng); if (!ring_entry) { - QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, - "Failed to get WBM ring entry\n"); + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO, + "%s: Failed to get WBM ring entry\n", + __func__); qdf_mem_free_consistent(soc->osdev, soc->osdev->dev, alloc_size, buffer_vaddr_unaligned, buffer_paddr_unaligned, 0); - goto fail; + break; } buffer_vaddr = (void *)qdf_align((unsigned long) @@ -167,24 +202,32 @@ static int dp_tx_ipa_uc_attach(struct dp_soc *soc, struct dp_pdev *pdev) HAL_WBM_PADDR_LO_SET(ring_entry, paddr_lo); HAL_WBM_PADDR_HI_SET(ring_entry, paddr_hi); - soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr[tx_buffer_count] = - buffer_vaddr; + soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr_unaligned[tx_buffer_count] + = buffer_vaddr_unaligned; + soc->ipa_uc_tx_rsc.tx_buf_pool_paddr_unaligned[tx_buffer_count] + = buffer_paddr_unaligned; } hal_srng_access_end(soc->hal_soc, wbm_srng); soc->ipa_uc_tx_rsc.alloc_tx_buf_cnt = tx_buffer_count; - QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, - "IPA WDI TX buffer: %d allocated\n", - tx_buffer_count); + if (tx_buffer_count) { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO, + "%s: IPA WDI TX buffer: %d allocated\n", + __func__, tx_buffer_count); + } else { + QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, + "%s: No IPA WDI TX buffer allocated\n", + __func__); + qdf_mem_free(soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr_unaligned); + soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr_unaligned = NULL; + qdf_mem_free(soc->ipa_uc_tx_rsc.tx_buf_pool_paddr_unaligned); + soc->ipa_uc_tx_rsc.tx_buf_pool_paddr_unaligned = NULL; + retval = -ENOMEM; + } return retval; - -fail: - hal_srng_access_end(soc->hal_soc, wbm_srng); - qdf_mem_free(soc->ipa_uc_tx_rsc.tx_buf_pool_vaddr); - return retval; } /** @@ -211,7 +254,8 @@ int dp_ipa_uc_attach(struct dp_soc *soc, struct dp_pdev *pdev) error = dp_tx_ipa_uc_attach(soc, pdev); if (error) { QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, - "DP IPA UC TX attach fail code %d\n", error); + "%s: DP IPA UC TX attach fail code %d\n", + __func__, error); return error; } @@ -219,7 +263,8 @@ int dp_ipa_uc_attach(struct dp_soc *soc, struct dp_pdev *pdev) error = dp_rx_ipa_uc_attach(soc, pdev); if (error) { QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR, - "DP IPA UC RX attach fail code %d\n", error); + "%s: DP IPA UC RX attach fail code %d\n", + __func__, error); dp_tx_ipa_uc_detach(soc, pdev); return error; } @@ -471,7 +516,7 @@ qdf_nbuf_t dp_tx_send_ipa_data_frame(struct cdp_vdev *vdev, qdf_nbuf_t skb) ret = dp_tx_send((struct dp_vdev_t *)vdev, skb); if (ret) { QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, - "Failed to tx"); + "%s: Failed to tx", __func__); return ret; } @@ -643,23 +688,25 @@ QDF_STATUS dp_ipa_setup(struct cdp_pdev *ppdev, void *ipa_i2w_cb, ret = ipa_wdi3_conn_pipes(&pipe_in, &pipe_out); if (ret) { QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, - "ipa_wdi3_conn_pipes: IPA pipe setup failed: ret=%d", - ret); + "%s: ipa_wdi3_conn_pipes: IPA pipe setup failed: ret=%d", + __func__, ret); return QDF_STATUS_E_FAILURE; } /* IPA uC Doorbell registers */ QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG, - "Tx DB PA=0x%x, Rx DB PA=0x%x", - (unsigned int)pipe_out.tx_uc_db_pa, - (unsigned int)pipe_out.rx_uc_db_pa); + "%s: Tx DB PA=0x%x, Rx DB PA=0x%x", + __func__, + (unsigned int)pipe_out.tx_uc_db_pa, + (unsigned int)pipe_out.rx_uc_db_pa); ipa_res->tx_comp_doorbell_paddr = pipe_out.tx_uc_db_pa; ipa_res->tx_comp_doorbell_vaddr = pipe_out.tx_uc_db_va; ipa_res->rx_ready_doorbell_paddr = pipe_out.rx_uc_db_pa; QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG, - "Tx: %s=%pK, %s=%d, %s=%pK, %s=%pK, %s=%d, %s=%pK, %s=%d, %s=%pK", + "%s: Tx: %s=%pK, %s=%d, %s=%pK, %s=%pK, %s=%d, %s=%pK, %s=%d, %s=%pK", + __func__, "transfer_ring_base_pa", (void *)pipe_in.tx.transfer_ring_base_pa, "transfer_ring_size", @@ -678,7 +725,8 @@ QDF_STATUS dp_ipa_setup(struct cdp_pdev *ppdev, void *ipa_i2w_cb, (void *)ipa_res->tx_comp_doorbell_paddr); QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG, - "Rx: %s=%pK, %s=%d, %s=%pK, %s=%pK, %s=%d, %s=%pK, %s=%d, %s=%pK", + "%s: Rx: %s=%pK, %s=%d, %s=%pK, %s=%pK, %s=%d, %s=%pK, %s=%d, %s=%pK", + __func__, "transfer_ring_base_pa", (void *)pipe_in.rx.transfer_ring_base_pa, "transfer_ring_size", @@ -713,8 +761,8 @@ QDF_STATUS dp_ipa_cleanup(uint32_t tx_pipe_handle, uint32_t rx_pipe_handle) ret = ipa_wdi3_disconn_pipes(); if (ret) { QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, - "ipa_wdi3_disconn_pipes: IPA pipe cleanup failed: ret=%d", - ret); + "%s: ipa_wdi3_disconn_pipes: IPA pipe cleanup failed: ret=%d", + __func__, ret); return QDF_STATUS_E_FAILURE; } @@ -743,8 +791,8 @@ QDF_STATUS dp_ipa_setup_iface(char *ifname, uint8_t *mac_addr, int ret = -EINVAL; QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG, - "Add Partial hdr: %s, %pM", - ifname, mac_addr); + "%s: Add Partial hdr: %s, %pM", + __func__, ifname, mac_addr); qdf_mem_zero(&hdr_info, sizeof(struct ipa_wdi3_hdr_info)); qdf_ether_addr_copy(uc_tx_hdr.eth.h_source, mac_addr); @@ -773,8 +821,8 @@ QDF_STATUS dp_ipa_setup_iface(char *ifname, uint8_t *mac_addr, ret = ipa_wdi3_reg_intf(&in); if (ret) { QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, - "ipa_wdi3_reg_intf: register IPA interface falied: ret=%d", - ret); + "%s: ipa_wdi3_reg_intf: register IPA interface falied: ret=%d", + __func__, ret); return QDF_STATUS_E_FAILURE; } @@ -795,8 +843,8 @@ QDF_STATUS dp_ipa_cleanup_iface(char *ifname, bool is_ipv6_enabled) ret = ipa_wdi3_dereg_intf(ifname); if (ret) { QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, - "ipa_wdi3_dereg_intf: IPA pipe deregistration failed: ret=%d", - ret); + "%s: ipa_wdi3_dereg_intf: IPA pipe deregistration failed: ret=%d", + __func__, ret); return QDF_STATUS_E_FAILURE; } @@ -816,8 +864,8 @@ QDF_STATUS dp_ipa_enable_pipes(struct cdp_pdev *ppdev) result = ipa_wdi3_enable_pipes(); if (result) { QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, - "%s: Enable WDI PIPE fail, code %d", - __func__, result); + "%s: Enable WDI PIPE fail, code %d", + __func__, result); return QDF_STATUS_E_FAILURE; } @@ -837,8 +885,8 @@ QDF_STATUS dp_ipa_disable_pipes(struct cdp_pdev *ppdev) result = ipa_wdi3_disable_pipes(); if (result) { QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, - "%s: Disable WDI PIPE fail, code %d", - __func__, result); + "%s: Disable WDI PIPE fail, code %d", + __func__, result); return QDF_STATUS_E_FAILURE; } @@ -863,8 +911,8 @@ QDF_STATUS dp_ipa_set_perf_level(int client, uint32_t max_supported_bw_mbps) result = ipa_wdi3_set_perf_profile(&profile); if (result) { QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, - "%s: ipa_wdi3_set_perf_profile fail, code %d", - __func__, result); + "%s: ipa_wdi3_set_perf_profile fail, code %d", + __func__, result); return QDF_STATUS_E_FAILURE; } diff --git a/dp/wifi3.0/dp_types.h b/dp/wifi3.0/dp_types.h index 1eeb42280deb..511cb601099a 100644 --- a/dp/wifi3.0/dp_types.h +++ b/dp/wifi3.0/dp_types.h @@ -799,7 +799,8 @@ struct dp_soc { qdf_dma_addr_t ipa_wbm_tp_paddr; /* TX buffers populated into the WBM ring */ - void **tx_buf_pool_vaddr; + void **tx_buf_pool_vaddr_unaligned; + qdf_dma_addr_t *tx_buf_pool_paddr_unaligned; } ipa_uc_tx_rsc; /* IPA uC datapath offload Wlan Rx resources */ From 8aaf6f265395e5ba27f296f7365b2deb466297ae Mon Sep 17 00:00:00 2001 From: Naveen Rawat Date: Thu, 2 Nov 2017 17:04:46 -0700 Subject: [PATCH 13/14] qcacmn: Add WLAN_PEER_NDP peer type Add WLAN_PEER_NDP peer type in enum wlan_peer_type Change-Id: Ibb8a606ccfdcdefb5395e0da89c0b10dc8345320 CRs-Fixed: 2137430 --- umac/cmn_services/inc/wlan_cmn.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/umac/cmn_services/inc/wlan_cmn.h b/umac/cmn_services/inc/wlan_cmn.h index 726fc7504903..c1eaa3bc6f35 100644 --- a/umac/cmn_services/inc/wlan_cmn.h +++ b/umac/cmn_services/inc/wlan_cmn.h @@ -230,6 +230,7 @@ enum wifi_traffic_ac { * @WLAN_PEER_NAWDS: NAWDS Peer * @WLAN_PEER_STA_TEMP: STA Peer Temp (its host only node) * @WLAN_PEER_IBSS: IBSS Peer + * @WLAN_PEER_NDP: NDP Peer */ enum wlan_peer_type { WLAN_PEER_SELF = 1, @@ -241,6 +242,7 @@ enum wlan_peer_type { WLAN_PEER_NAWDS = 7, WLAN_PEER_STA_TEMP = 8, WLAN_PEER_IBSS = 9, + WLAN_PEER_NDP = 10, }; /** From dc5672f7606ffe79043fff73ad2ec44e4a53eb83 Mon Sep 17 00:00:00 2001 From: Mukul Sharma Date: Thu, 2 Nov 2017 17:42:36 +0530 Subject: [PATCH 14/14] qcacmn: Perform cleanup of send_init_cmd Currently, WMI is exposing two command ops (send_init_cmd and init_send_cmd) for init command purpose which is leading to data/code redundeancy. Perform clenaup for send_init_cmd. Change-Id: I8f31ab45392cf2afb3cc34c633ba83ea42a3a835 CRs-Fixed: 2138507 --- wmi/inc/wmi_unified_api.h | 9 --- wmi/inc/wmi_unified_param.h | 8 +- wmi/inc/wmi_unified_priv.h | 10 --- wmi/src/wmi_unified_api.c | 45 ------------ wmi/src/wmi_unified_tlv.c | 141 +++--------------------------------- 5 files changed, 17 insertions(+), 196 deletions(-) diff --git a/wmi/inc/wmi_unified_api.h b/wmi/inc/wmi_unified_api.h index 3101b3210126..43931867ebd8 100644 --- a/wmi/inc/wmi_unified_api.h +++ b/wmi/inc/wmi_unified_api.h @@ -841,15 +841,6 @@ 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); - QDF_STATUS wmi_unified_set_base_macaddr_indicate_cmd(void *wmi_hdl, uint8_t *custom_addr); diff --git a/wmi/inc/wmi_unified_param.h b/wmi/inc/wmi_unified_param.h index 896c5cb8d13b..0488edfffb7f 100644 --- a/wmi/inc/wmi_unified_param.h +++ b/wmi/inc/wmi_unified_param.h @@ -5901,6 +5901,8 @@ struct wmi_host_fw_abi_ver { * @rx_batchmode: RX batch mode * @tt_support: Thermal throttling support * @atf_config: ATF config + * @mgmt_comp_evt_bundle_support: bundle support required for mgmt complete evt + * @tx_msdu_new_partition_id_support: new partiition id support for tx msdu * @iphdr_pad_config: ipheader pad config * @qwrap_config: Qwrap configuration * @alloc_frag_desc_for_data_pkt: Frag desc for data @@ -5922,6 +5924,7 @@ struct wmi_host_fw_abi_ver { * @bpf_instruction_size: * @max_bssid_rx_filters: * @use_pdev_id: + * @max_num_dbs_scan_duty_cycle: max dbs can duty cycle value */ typedef struct { uint32_t num_vdevs; @@ -5963,7 +5966,9 @@ typedef struct { uint32_t VO_Minfree; uint32_t rx_batchmode; uint32_t tt_support; - uint32_t atf_config; + uint32_t atf_config:1, + mgmt_comp_evt_bundle_support:1, + tx_msdu_new_partition_id_support:1; uint32_t iphdr_pad_config; uint32_t qwrap_config:16, @@ -5987,6 +5992,7 @@ typedef struct { uint32_t bpf_instruction_size; uint32_t max_bssid_rx_filters; uint32_t use_pdev_id; + uint32_t max_num_dbs_scan_duty_cycle; } target_resource_config; /** diff --git a/wmi/inc/wmi_unified_priv.h b/wmi/inc/wmi_unified_priv.h index d4007e80d078..201e1cef021b 100644 --- a/wmi/inc/wmi_unified_priv.h +++ b/wmi/inc/wmi_unified_priv.h @@ -680,19 +680,10 @@ 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); QDF_STATUS (*check_and_update_fw_version_cmd)(wmi_unified_t wmi_hdl, void *ev); -QDF_STATUS (*send_saved_init_cmd)(wmi_unified_t wmi_handle); - QDF_STATUS (*send_set_base_macaddr_indicate_cmd)(wmi_unified_t wmi_handle, uint8_t *custom_addr); @@ -1444,7 +1435,6 @@ struct wmi_unified { int wmi_stop_in_progress; struct wmi_host_abi_version fw_abi_version; struct wmi_host_abi_version final_abi_vers; - struct wmi_cmd_init saved_wmi_init_cmd; uint32_t num_of_diag_events_logs; uint32_t *events_logs_list; #ifdef WLAN_OPEN_SOURCE diff --git a/wmi/src/wmi_unified_api.c b/wmi/src/wmi_unified_api.c index 0490e9208e00..3ec510807d6d 100644 --- a/wmi/src/wmi_unified_api.c +++ b/wmi/src/wmi_unified_api.c @@ -2755,51 +2755,6 @@ 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 - * @res_cfg: resource config - * @num_mem_chunks: no of mem chunck - * @mem_chunk: pointer to mem chunck structure - * - * This function sends IE information to firmware - * - * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure - * - */ -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) -{ - wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; - - if (wmi_handle->ops->send_init_cmd) - return wmi_handle->ops->send_init_cmd(wmi_handle, - res_cfg, num_mem_chunks, mem_chunk, action); - - return QDF_STATUS_E_FAILURE; -} -#endif -/** - * wmi_unified_send_saved_init_cmd() - wmi init command - * @wmi_handle: pointer to wmi handle - * - * This function sends IE information to firmware - * - * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure - * - */ -QDF_STATUS wmi_unified_send_saved_init_cmd(void *wmi_hdl) -{ - wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; - - if (wmi_handle->ops->send_saved_init_cmd) - return wmi_handle->ops->send_saved_init_cmd(wmi_handle); - - return QDF_STATUS_E_FAILURE; -} /** * wmi_unified_save_fw_version_cmd() - save fw version diff --git a/wmi/src/wmi_unified_tlv.c b/wmi/src/wmi_unified_tlv.c index 15931a4c656a..8d8c1fbad20d 100644 --- a/wmi/src/wmi_unified_tlv.c +++ b/wmi/src/wmi_unified_tlv.c @@ -12459,9 +12459,17 @@ void wmi_copy_resource_config(wmi_resource_config *resource_cfg, resource_cfg->bpf_instruction_size = tgt_res_cfg->bpf_instruction_size; resource_cfg->max_bssid_rx_filters = tgt_res_cfg->max_bssid_rx_filters; resource_cfg->use_pdev_id = tgt_res_cfg->use_pdev_id; + resource_cfg->max_num_dbs_scan_duty_cycle = + tgt_res_cfg->max_num_dbs_scan_duty_cycle; - WMI_RSRC_CFG_FLAG_ATF_CONFIG_ENABLE_SET(resource_cfg->flag1, - tgt_res_cfg->atf_config); + if (tgt_res_cfg->atf_config) + WMI_RSRC_CFG_FLAG_ATF_CONFIG_ENABLE_SET(resource_cfg->flag1, 1); + if (tgt_res_cfg->mgmt_comp_evt_bundle_support) + WMI_RSRC_CFG_FLAG_MGMT_COMP_EVT_BUNDLE_SUPPORT_SET( + resource_cfg->flag1, 1); + if (tgt_res_cfg->tx_msdu_new_partition_id_support) + WMI_RSRC_CFG_FLAG_TX_MSDU_ID_NEW_PARTITION_SUPPORT_SET( + resource_cfg->flag1, 1); } /* copy_hw_mode_id_in_init_cmd() - Helper routine to copy hw_mode in init cmd @@ -12560,131 +12568,6 @@ static inline void copy_fw_abi_version_tlv(wmi_unified_t wmi_handle, sizeof(wmi_abi_version)); } -#ifdef CONFIG_MCL -/** - * send_init_cmd_tlv() - wmi init command - * @wmi_handle: pointer to wmi handle - * @res_cfg: resource config - * @num_mem_chunks: no of mem chunck - * @mem_chunk: pointer to mem chunck structure - * - * This function sends IE information to firmware - * - * Return: QDF_STATUS_SUCCESS for success otherwise failure - * - */ -static QDF_STATUS send_init_cmd_tlv(wmi_unified_t wmi_handle, - wmi_resource_config *tgt_res_cfg, - uint8_t num_mem_chunks, struct wmi_host_mem_chunk *mem_chunks, - bool action) -{ - wmi_buf_t buf; - wmi_init_cmd_fixed_param *cmd; - uint8_t *buf_ptr; - wmi_resource_config *resource_cfg; - wlan_host_memory_chunk *host_mem_chunks; - uint32_t mem_chunk_len = 0; - uint16_t idx; - int len; - int ret; - - len = sizeof(*cmd) + sizeof(wmi_resource_config) + WMI_TLV_HDR_SIZE; - mem_chunk_len = (sizeof(wlan_host_memory_chunk) * MAX_MEM_CHUNKS); - buf = wmi_buf_alloc(wmi_handle, len + mem_chunk_len); - if (!buf) { - WMI_LOGD("%s: wmi_buf_alloc failed\n", __func__); - return QDF_STATUS_E_FAILURE; - } - - buf_ptr = (uint8_t *) wmi_buf_data(buf); - cmd = (wmi_init_cmd_fixed_param *) buf_ptr; - resource_cfg = (wmi_resource_config *) (buf_ptr + sizeof(*cmd)); - - host_mem_chunks = (wlan_host_memory_chunk *) - (buf_ptr + sizeof(*cmd) + sizeof(wmi_resource_config) - + WMI_TLV_HDR_SIZE); - - WMITLV_SET_HDR(&cmd->tlv_header, - WMITLV_TAG_STRUC_wmi_init_cmd_fixed_param, - WMITLV_GET_STRUCT_TLVLEN(wmi_init_cmd_fixed_param)); - - qdf_mem_copy(resource_cfg, tgt_res_cfg, sizeof(wmi_resource_config)); - WMITLV_SET_HDR(&resource_cfg->tlv_header, - WMITLV_TAG_STRUC_wmi_resource_config, - WMITLV_GET_STRUCT_TLVLEN(wmi_resource_config)); - - for (idx = 0; idx < num_mem_chunks; ++idx) { - WMITLV_SET_HDR(&(host_mem_chunks[idx].tlv_header), - WMITLV_TAG_STRUC_wlan_host_memory_chunk, - WMITLV_GET_STRUCT_TLVLEN - (wlan_host_memory_chunk)); - host_mem_chunks[idx].ptr = mem_chunks[idx].paddr; - host_mem_chunks[idx].size = mem_chunks[idx].len; - host_mem_chunks[idx].req_id = mem_chunks[idx].req_id; - WMI_LOGD("chunk %d len %d requested ,ptr 0x%x ", - idx, host_mem_chunks[idx].size, - host_mem_chunks[idx].ptr); - } - cmd->num_host_mem_chunks = num_mem_chunks; - len += (num_mem_chunks * sizeof(wlan_host_memory_chunk)); - WMITLV_SET_HDR((buf_ptr + sizeof(*cmd) + sizeof(wmi_resource_config)), - WMITLV_TAG_ARRAY_STRUC, - (sizeof(wlan_host_memory_chunk) * - num_mem_chunks)); - - /* Fill fw_abi_vers */ - copy_fw_abi_version_tlv(wmi_handle, cmd); - - if (action) { - ret = wmi_unified_cmd_send(wmi_handle, buf, len, - WMI_INIT_CMDID); - if (ret) { - WMI_LOGE(FL("Failed to send set WMI INIT command ret = %d"), ret); - wmi_buf_free(buf); - return QDF_STATUS_E_FAILURE; - } - } else { - wmi_handle->saved_wmi_init_cmd.buf = buf; - wmi_handle->saved_wmi_init_cmd.buf_len = len; - } - - return QDF_STATUS_SUCCESS; - -} -#endif -/** - * send_saved_init_cmd_tlv() - wmi init command - * @wmi_handle: pointer to wmi handle - * - * This function sends IE information to firmware - * - * Return: QDF_STATUS_SUCCESS for success otherwise failure - * - */ -static QDF_STATUS send_saved_init_cmd_tlv(wmi_unified_t wmi_handle) -{ - int status; - - if (!wmi_handle->saved_wmi_init_cmd.buf || - !wmi_handle->saved_wmi_init_cmd.buf_len) { - WMI_LOGP("Service ready ext event w/o WMI_SERVICE_EXT_MSG!"); - return QDF_STATUS_E_FAILURE; - } - status = wmi_unified_cmd_send(wmi_handle, - wmi_handle->saved_wmi_init_cmd.buf, - wmi_handle->saved_wmi_init_cmd.buf_len, - WMI_INIT_CMDID); - if (status) { - WMI_LOGE(FL("Failed to send set WMI INIT command ret = %d"), status); - wmi_buf_free(wmi_handle->saved_wmi_init_cmd.buf); - return QDF_STATUS_E_FAILURE; - } - wmi_handle->saved_wmi_init_cmd.buf = NULL; - wmi_handle->saved_wmi_init_cmd.buf_len = 0; - - return QDF_STATUS_SUCCESS; -} - static QDF_STATUS save_fw_version_cmd_tlv(wmi_unified_t wmi_handle, void *evt_buf) { WMI_SERVICE_READY_EVENTID_param_tlvs *param_buf; @@ -19809,13 +19692,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, - .send_saved_init_cmd = send_saved_init_cmd_tlv, .send_set_base_macaddr_indicate_cmd = send_set_base_macaddr_indicate_cmd_tlv, .send_log_supported_evt_cmd = send_log_supported_evt_cmd_tlv,