From db7818216695d449855be591f067cdeb2999e35a Mon Sep 17 00:00:00 2001 From: Jingxiang Ge Date: Wed, 10 Nov 2021 16:44:32 +0800 Subject: [PATCH] qcacmn: Always enable ce debug history for ce2/ce3 Current there is no ce debug history when testing perf build, so it is hard to debug some issue. Here it only enable ce2/ce3 on perf build, which keep only necessary log here. Change-Id: I29b998939cfa25f0547a9871721c6daeb0fdd961 CRs-Fixed: 3058740 --- hif/inc/hif.h | 31 +++++++++++++ hif/src/ce/ce_main.c | 107 +++++++++++++++++++++++++++++++++++++++---- hif/src/hif_main.h | 3 +- 3 files changed, 131 insertions(+), 10 deletions(-) diff --git a/hif/inc/hif.h b/hif/inc/hif.h index 9786f4aa6d4e..e338ed73800c 100644 --- a/hif/inc/hif.h +++ b/hif/inc/hif.h @@ -1,5 +1,6 @@ /* * Copyright (c) 2013-2021 The Linux Foundation. All rights reserved. + * Copyright (c) 2022 Qualcomm Innovation Center, Inc. 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 @@ -1656,6 +1657,36 @@ ssize_t hif_ce_en_desc_hist(struct hif_softc *scn, const char *buf, size_t size); ssize_t hif_disp_ce_enable_desc_data_hist(struct hif_softc *scn, char *buf); ssize_t hif_dump_desc_event(struct hif_softc *scn, char *buf); +/** + * hif_ce_debug_history_prealloc_init() - alloc ce debug history memory + * + * alloc ce debug history memory with driver init, so such memory can + * be existed even after stop module. + * on ini value. + * + * Return: QDF_STATUS_SUCCESS for success, other for fail. + */ +QDF_STATUS hif_ce_debug_history_prealloc_init(void); +/** + * hif_ce_debug_history_prealloc_deinit() - free ce debug history memory + * + * free ce debug history memory when driver deinit. + * + * Return: QDF_STATUS_SUCCESS for success, other for fail. + */ +QDF_STATUS hif_ce_debug_history_prealloc_deinit(void); +#else +static inline +QDF_STATUS hif_ce_debug_history_prealloc_init(void) +{ + return QDF_STATUS_SUCCESS; +} + +static inline +QDF_STATUS hif_ce_debug_history_prealloc_deinit(void) +{ + return QDF_STATUS_SUCCESS; +} #endif/*#if defined(HIF_CONFIG_SLUB_DEBUG_ON)||defined(HIF_CE_DEBUG_DATA_BUF)*/ /** diff --git a/hif/src/ce/ce_main.c b/hif/src/ce/ce_main.c index 9a0dd3f17d0e..1fc8bb03c7fe 100644 --- a/hif/src/ce/ce_main.c +++ b/hif/src/ce/ce_main.c @@ -1,5 +1,6 @@ /* * Copyright (c) 2013-2020 The Linux Foundation. All rights reserved. + * Copyright (c) 2022 Qualcomm Innovation Center, Inc. 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 @@ -1412,6 +1413,7 @@ QDF_STATUS alloc_mem_ce_debug_hist_data(struct hif_softc *scn, uint32_t ce_id) (uint8_t *)qdf_mem_malloc(CE_DEBUG_MAX_DATA_BUF_SIZE); if (!event->data) { hif_err_rl("ce debug data alloc failed"); + scn->hif_ce_desc_hist.data_enable[ce_id] = false; return QDF_STATUS_E_NOMEM; } } @@ -1451,7 +1453,72 @@ void free_mem_ce_debug_hist_data(struct hif_softc *scn, uint32_t ce_id) #ifndef HIF_CE_DEBUG_DATA_DYNAMIC_BUF #if defined(HIF_CONFIG_SLUB_DEBUG_ON) || defined(HIF_CE_DEBUG_DATA_BUF) -struct hif_ce_desc_event hif_ce_desc_history[CE_COUNT_MAX][HIF_CE_HISTORY_MAX]; +struct hif_ce_desc_event *hif_ce_desc_history[CE_COUNT_MAX]; + +/* define this variable for crashscope parse */ +uint32_t hif_ce_history_max = HIF_CE_HISTORY_MAX; + +/** + * hif_ce_debug_only_enable_ce2_ce3() - if only enable ce2/ce3 debug + * This is different config for perf/debug buid version. + * for debug build, it will enable ce history for all ce, but for + * perf build(if CONFIG_SLUB_DEBUG_ON is N), it only enable for + * ce2(wmi event) & ce3(wmi cmd) history. + * + * Return: true if only enable ce2/ce3 debug, otherwise false. + */ +#if defined(CONFIG_SLUB_DEBUG_ON) +static inline bool hif_ce_debug_only_enable_ce2_ce3(void) +{ + return false; +} +#else +static inline bool hif_ce_debug_only_enable_ce2_ce3(void) +{ + return true; +} +#endif + +QDF_STATUS hif_ce_debug_history_prealloc_deinit(void) +{ + int ce_id; + + for (ce_id = 0; ce_id < CE_COUNT_MAX; ce_id++) { + if (hif_ce_desc_history[ce_id]) { + qdf_mem_free(hif_ce_desc_history[ce_id]); + hif_ce_desc_history[ce_id] = NULL; + } + } + hif_debug("ce debug memory freed"); + + return QDF_STATUS_SUCCESS; +} + +QDF_STATUS hif_ce_debug_history_prealloc_init(void) +{ + int ce_id; + + hif_debug("alloc ce debug memory, only_ce2/ce3 %d", + hif_ce_debug_only_enable_ce2_ce3()); + for (ce_id = 0; ce_id < CE_COUNT_MAX; ce_id++) { + if (hif_ce_debug_only_enable_ce2_ce3() && + ce_id != CE_ID_2 && + ce_id != CE_ID_3) { + hif_ce_desc_history[ce_id] = NULL; + continue; + } + + hif_ce_desc_history[ce_id] = + qdf_mem_malloc(HIF_CE_HISTORY_MAX * + sizeof(struct hif_ce_desc_event)); + if (!hif_ce_desc_history[ce_id]) { + hif_ce_debug_history_prealloc_deinit(); + return QDF_STATUS_E_NOMEM; + } + } + + return QDF_STATUS_SUCCESS; +} /** * alloc_mem_ce_debug_history() - Allocate CE descriptor history @@ -1465,14 +1532,33 @@ alloc_mem_ce_debug_history(struct hif_softc *scn, unsigned int ce_id, uint32_t src_nentries) { struct ce_desc_hist *ce_hist = &scn->hif_ce_desc_hist; + QDF_STATUS status = QDF_STATUS_SUCCESS; - ce_hist->hist_ev[ce_id] = hif_ce_desc_history[ce_id]; - ce_hist->enable[ce_id] = 1; - - if (src_nentries) - alloc_mem_ce_debug_hist_data(scn, ce_id); - else + if (hif_ce_debug_only_enable_ce2_ce3() && + ce_id != CE_ID_2 && + ce_id != CE_ID_3) { + ce_hist->enable[ce_id] = false; ce_hist->data_enable[ce_id] = false; + return QDF_STATUS_SUCCESS; + } + + if (!hif_ce_desc_history[ce_id]) { + hif_err("prealloc memory failed"); + return QDF_STATUS_E_NOMEM; + } + ce_hist->hist_ev[ce_id] = hif_ce_desc_history[ce_id]; + ce_hist->enable[ce_id] = true; + + if (src_nentries) { + status = alloc_mem_ce_debug_hist_data(scn, ce_id); + if (status != QDF_STATUS_SUCCESS) { + ce_hist->enable[ce_id] = false; + ce_hist->hist_ev[ce_id] = NULL; + return status; + } + } else { + ce_hist->data_enable[ce_id] = false; + } return QDF_STATUS_SUCCESS; } @@ -1488,7 +1574,10 @@ static void free_mem_ce_debug_history(struct hif_softc *scn, unsigned int ce_id) { struct ce_desc_hist *ce_hist = &scn->hif_ce_desc_hist; - ce_hist->enable[ce_id] = 0; + if (!ce_hist->enable[ce_id]) + return; + + ce_hist->enable[ce_id] = false; if (ce_hist->data_enable[ce_id]) { ce_hist->data_enable[ce_id] = false; free_mem_ce_debug_hist_data(scn, ce_id); @@ -1538,7 +1627,7 @@ static void free_mem_ce_debug_history(struct hif_softc *scn, unsigned int CE_id) free_mem_ce_debug_hist_data(scn, CE_id); } - ce_hist->enable[CE_id] = 0; + ce_hist->enable[CE_id] = false; qdf_mem_free(ce_hist->hist_ev[CE_id]); ce_hist->hist_ev[CE_id] = NULL; } diff --git a/hif/src/hif_main.h b/hif/src/hif_main.h index e6bcaaba16d7..5dbea7f4ab4a 100644 --- a/hif/src/hif_main.h +++ b/hif/src/hif_main.h @@ -1,5 +1,6 @@ /* * Copyright (c) 2013-2021 The Linux Foundation. All rights reserved. + * Copyright (c) 2022 Qualcomm Innovation Center, Inc. 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 @@ -166,7 +167,7 @@ struct hif_latency_detect { #if defined(HIF_CONFIG_SLUB_DEBUG_ON) || defined(HIF_CE_DEBUG_DATA_BUF) struct ce_desc_hist { qdf_atomic_t history_index[CE_COUNT_MAX]; - uint32_t enable[CE_COUNT_MAX]; + bool enable[CE_COUNT_MAX]; bool data_enable[CE_COUNT_MAX]; qdf_mutex_t ce_dbg_datamem_lock[CE_COUNT_MAX]; uint32_t hist_index;