blob: 5ac1dee8003f97e27661649d9b2fc17ecd5c5bd7 [file] [log] [blame]
/*
* Copyright (c) 2013-2017 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
*
*
* 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.
*/
/*
* This file was originally distributed by Qualcomm Atheros, Inc.
* under proprietary terms before Copyright ownership was assigned
* to the Linux Foundation.
*/
/* Host Debug log implementation */
#include "athdefs.h"
#include "a_types.h"
#include "dbglog_host.h"
#include "wmi.h"
#include "wmi_unified_api.h"
#include "wma.h"
#include "ol_defines.h"
#include <wlan_nlink_srv.h>
#include "vos_diag_core_event.h"
#include "qwlan_version.h"
#include <wlan_hdd_main.h>
#include <wlan_hdd_wext.h>
#include <net/sock.h>
#include <linux/netlink.h>
#ifdef CNSS_GENL
#include <net/cnss_nl.h>
#endif
#ifdef WLAN_OPEN_SOURCE
#include <linux/debugfs.h>
#endif /* WLAN_OPEN_SOURCE */
#include "wmi_unified_priv.h"
#ifdef MULTI_IF_NAME
#define CLD_DEBUGFS_DIR "cld" MULTI_IF_NAME
#else
#define CLD_DEBUGFS_DIR "cld"
#endif
#define DEBUGFS_BLOCK_NAME "dbglog_block"
#define CNSS_DIAG_FWLOG_TIMEOUT 2000
#define ATH_MODULE_NAME fwlog
#include <a_debug.h>
#define FWLOG_DEBUG ATH_DEBUG_MAKE_MODULE_MASK(0)
#define DBG_STRING(id) [id] = #id
static bool kd_nl_init = FALSE;
static int get_version = 0;
static int gprint_limiter = 0;
static bool tgt_assert_enable = 0;
#if defined(WLAN_DEBUG)
static ATH_DEBUG_MASK_DESCRIPTION g_fwlogDebugDescription[] = {
{FWLOG_DEBUG,"fwlog"},
};
ATH_DEBUG_INSTANTIATE_MODULE_VAR(fwlog,
"fwlog",
"Firmware Debug Log",
ATH_DEBUG_MASK_DEFAULTS | ATH_DEBUG_INFO | ATH_DEBUG_ERR,
ATH_DEBUG_DESCRIPTION_COUNT(g_fwlogDebugDescription),
g_fwlogDebugDescription);
#endif
module_dbg_print mod_print[WLAN_MODULE_ID_MAX];
A_UINT32 dbglog_process_type = DBGLOG_PROCESS_NET_RAW;
A_STATUS
wmi_config_debug_module_cmd(wmi_unified_t wmi_handle, A_UINT32 param, A_UINT32 val,
A_UINT32 *module_id_bitmap, A_UINT32 bitmap_len);
const char *dbglog_get_module_str(A_UINT32 module_id)
{
switch (module_id) {
case WLAN_MODULE_INF:
return "INF";
case WLAN_MODULE_WMI:
return "WMI";
case WLAN_MODULE_STA_PWRSAVE:
return "STA PS";
case WLAN_MODULE_WHAL:
return "WHAL";
case WLAN_MODULE_COEX:
return "COEX";
case WLAN_MODULE_ROAM:
return "ROAM";
case WLAN_MODULE_RESMGR_CHAN_MANAGER:
return "CHANMGR";
case WLAN_MODULE_RESMGR:
return "RESMGR";
case WLAN_MODULE_VDEV_MGR:
return "VDEV";
case WLAN_MODULE_SCAN:
return "SCAN";
case WLAN_MODULE_RATECTRL:
return "RC";
case WLAN_MODULE_AP_PWRSAVE:
return "AP PS";
case WLAN_MODULE_BLOCKACK:
return "BA";
case WLAN_MODULE_MGMT_TXRX:
return "MGMT";
case WLAN_MODULE_DATA_TXRX:
return "DATA";
case WLAN_MODULE_HTT:
return "HTT";
case WLAN_MODULE_HOST:
return "HOST";
case WLAN_MODULE_BEACON:
return "BEACON";
case WLAN_MODULE_OFFLOAD:
return "OFFLOAD";
case WLAN_MODULE_WAL:
return "WAL";
case WAL_MODULE_DE:
return "DE";
case WLAN_MODULE_PCIELP:
return "PCIELP";
case WLAN_MODULE_RTT:
return "RTT";
case WLAN_MODULE_DCS:
return "DCS";
case WLAN_MODULE_CACHEMGR:
return "CACHEMGR";
case WLAN_MODULE_ANI:
return "ANI";
case WLAN_MODULE_TEST:
return "TESTPOINT";
case WLAN_MODULE_STA_SMPS:
return "STA_SMPS";
case WLAN_MODULE_TDLS:
return "TDLS";
case WLAN_MODULE_P2P:
return "P2P";
case WLAN_MODULE_WOW:
return "WoW";
case WLAN_MODULE_IBSS_PWRSAVE:
return "IBSS PS";
case WLAN_MODULE_EXTSCAN:
return "ExtScan";
case WLAN_MODULE_UNIT_TEST:
return "UNIT_TEST";
case WLAN_MODULE_MLME:
return "MLME";
case WLAN_MODULE_SUPPL:
return "SUPPLICANT";
case WLAN_MODULE_ERE:
return "ERE";
case WLAN_MODULE_OCB:
return "OCB";
case WLAN_MODULE_RSSI_MONITOR:
return "RSSI_MONITOR";
case WLAN_MODULE_WPM:
return "WPM";
case WLAN_MODULE_CSS:
return "CSS";
case WLAN_MODULE_PPS:
return "PPS";
case WLAN_MODULE_SCAN_CH_PREDICT:
return "SCAN_CH_PREDICT";
case WLAN_MODULE_MAWC:
return "MAWC";
case WLAN_MODULE_CMC_QMIC:
return "CMC_QMIC";
case WLAN_MODULE_EGAP:
return "EGAP";
case WLAN_MODULE_NAN20:
return "NAN20";
case WLAN_MODULE_QBOOST:
return "QBOOST";
default:
return "UNKNOWN";
}
}
char * DBG_MSG_ARR[WLAN_MODULE_ID_MAX][MAX_DBG_MSGS] =
{
{
DBG_STRING(INF_DBGID_DEFINITION_START),
DBG_STRING(INF_ASSERTION_FAILED),
DBG_STRING(INF_TARGET_ID),
DBG_STRING(INF_TARGET_MEM_REMAING),
DBG_STRING(INF_TARGET_MEM_EXT_REMAING),
DBG_STRING(INF_TARGET_MEM_ALLOC_TRACK),
DBG_STRING(INF_TARGET_MEM_ALLOC_RAM),
DBG_STRING(INF_DBGID_DEFINITION_END),
},
{
DBG_STRING(WMI_DBGID_DEFINITION_START),
DBG_STRING(WMI_CMD_RX_XTND_PKT_TOO_SHORT),
DBG_STRING(WMI_EXTENDED_CMD_NOT_HANDLED),
DBG_STRING(WMI_CMD_RX_PKT_TOO_SHORT),
DBG_STRING(WMI_CALLING_WMI_EXTENSION_FN),
DBG_STRING(WMI_CMD_NOT_HANDLED),
DBG_STRING(WMI_IN_SYNC),
DBG_STRING(WMI_TARGET_WMI_SYNC_CMD),
DBG_STRING(WMI_SET_SNR_THRESHOLD_PARAMS),
DBG_STRING(WMI_SET_RSSI_THRESHOLD_PARAMS),
DBG_STRING(WMI_SET_LQ_TRESHOLD_PARAMS),
DBG_STRING(WMI_TARGET_CREATE_PSTREAM_CMD),
DBG_STRING(WMI_WI_DTM_INUSE),
DBG_STRING(WMI_TARGET_DELETE_PSTREAM_CMD),
DBG_STRING(WMI_TARGET_IMPLICIT_DELETE_PSTREAM_CMD),
DBG_STRING(WMI_TARGET_GET_BIT_RATE_CMD),
DBG_STRING(WMI_GET_RATE_MASK_CMD_FIX_RATE_MASK_IS),
DBG_STRING(WMI_TARGET_GET_AVAILABLE_CHANNELS_CMD),
DBG_STRING(WMI_TARGET_GET_TX_PWR_CMD),
DBG_STRING(WMI_FREE_EVBUF_WMIBUF),
DBG_STRING(WMI_FREE_EVBUF_DATABUF),
DBG_STRING(WMI_FREE_EVBUF_BADFLAG),
DBG_STRING(WMI_HTC_RX_ERROR_DATA_PACKET),
DBG_STRING(WMI_HTC_RX_SYNC_PAUSING_FOR_MBOX),
DBG_STRING(WMI_INCORRECT_WMI_DATA_HDR_DROPPING_PKT),
DBG_STRING(WMI_SENDING_READY_EVENT),
DBG_STRING(WMI_SETPOWER_MDOE_TO_MAXPERF),
DBG_STRING(WMI_SETPOWER_MDOE_TO_REC),
DBG_STRING(WMI_BSSINFO_EVENT_FROM),
DBG_STRING(WMI_TARGET_GET_STATS_CMD),
DBG_STRING(WMI_SENDING_SCAN_COMPLETE_EVENT),
DBG_STRING(WMI_SENDING_RSSI_INDB_THRESHOLD_EVENT),
DBG_STRING(WMI_SENDING_RSSI_INDBM_THRESHOLD_EVENT),
DBG_STRING(WMI_SENDING_LINK_QUALITY_THRESHOLD_EVENT),
DBG_STRING(WMI_SENDING_ERROR_REPORT_EVENT),
DBG_STRING(WMI_SENDING_CAC_EVENT),
DBG_STRING(WMI_TARGET_GET_ROAM_TABLE_CMD),
DBG_STRING(WMI_TARGET_GET_ROAM_DATA_CMD),
DBG_STRING(WMI_SENDING_GPIO_INTR_EVENT),
DBG_STRING(WMI_SENDING_GPIO_ACK_EVENT),
DBG_STRING(WMI_SENDING_GPIO_DATA_EVENT),
DBG_STRING(WMI_CMD_RX),
DBG_STRING(WMI_CMD_RX_XTND),
DBG_STRING(WMI_EVENT_SEND),
DBG_STRING(WMI_EVENT_SEND_XTND),
DBG_STRING(WMI_CMD_PARAMS_DUMP_START),
DBG_STRING(WMI_CMD_PARAMS_DUMP_END),
DBG_STRING(WMI_CMD_PARAMS),
DBG_STRING(WMI_EVENT_ALLOC_FAILURE),
DBG_STRING(WMI_DBGID_DCS_PARAM_CMD),
DBG_STRING(WMI_SEND_EVENT_WRONG_TLV),
DBG_STRING(WMI_SEND_EVENT_NO_TLV_DEF),
DBG_STRING(WMI_RECV_CMD_WRONG_TLV),
DBG_STRING(WMI_CHECK_TLV_PARAM_GET_NUM_TLVS_ERROR),
DBG_STRING(WMI_CHECK_TLV_PARAM_TLV_LEN_EXCEEDED_BUF_LEN),
DBG_STRING(WMI_CHECK_TLV_PARAM_NONEXISTING_TAG_ORDER),
DBG_STRING(WMI_CHECK_TLV_PARAM_WRONG_TAG_ORDER),
DBG_STRING(WMI_CHECK_TLV_PARAM_INVALID_TLV_DEF_ARRAY_SIZE),
DBG_STRING(WMI_CHECK_TLV_PARAM_INVALID_TLV_DEF_VARIED_SIZE),
DBG_STRING(WMI_CHECK_TLV_PARAM_WRONG_TLV_LENGTH),
DBG_STRING(WMI_CHECK_TLV_PARAM_UNALIGNED_TLV_LEN),
DBG_STRING(WMI_CHECK_TLV_PARAM_WRONG_INNER_TLV_LEN),
DBG_STRING(WMI_CHECK_TLV_PARAM_UNSUPPORTED_ARRAY_TAG),
DBG_STRING(WMI_CHECK_TLV_PARAM_EXCEEDED_MAX_TLVs),
DBG_STRING(WMI_CHECK_TLV_PARAM_CMD_BUF_ALLOC_FAILED),
DBG_STRING(WMI_CHECK_TLV_PARAM_TLV_INFO),
DBG_STRING(WMI_DBGID_DEFINITION_END),
},
{
DBG_STRING(PS_STA_DEFINITION_START),
DBG_STRING(PS_STA_PM_ARB_REQUEST),
DBG_STRING(PS_STA_DELIVER_EVENT),
DBG_STRING(PS_STA_PSPOLL_SEQ_DONE),
DBG_STRING(PS_STA_COEX_MODE),
DBG_STRING(PS_STA_PSPOLL_ALLOW),
DBG_STRING(PS_STA_SET_PARAM),
DBG_STRING(PS_STA_SPECPOLL_TIMER_STARTED),
DBG_STRING(PS_STA_SPECPOLL_TIMER_STOPPED),
DBG_STRING(PS_STA_AVG_CHANNEL_CONGESTION),
DBG_STRING(PS_STA_DEFINITION_END),
},
{
DBG_STRING(WHAL_DBGID_DEFINITION_START),
DBG_STRING(WHAL_ERROR_ANI_CONTROL),
DBG_STRING(WHAL_ERROR_CHIP_TEST1),
DBG_STRING(WHAL_ERROR_CHIP_TEST2),
DBG_STRING(WHAL_ERROR_EEPROM_CHECKSUM),
DBG_STRING(WHAL_ERROR_EEPROM_MACADDR),
DBG_STRING(WHAL_ERROR_INTERRUPT_HIU),
DBG_STRING(WHAL_ERROR_KEYCACHE_RESET),
DBG_STRING(WHAL_ERROR_KEYCACHE_SET),
DBG_STRING(WHAL_ERROR_KEYCACHE_TYPE),
DBG_STRING(WHAL_ERROR_KEYCACHE_TKIPENTRY),
DBG_STRING(WHAL_ERROR_KEYCACHE_WEPLENGTH),
DBG_STRING(WHAL_ERROR_PHY_INVALID_CHANNEL),
DBG_STRING(WHAL_ERROR_POWER_AWAKE),
DBG_STRING(WHAL_ERROR_POWER_SET),
DBG_STRING(WHAL_ERROR_RECV_STOPDMA),
DBG_STRING(WHAL_ERROR_RECV_STOPPCU),
DBG_STRING(WHAL_ERROR_RESET_CHANNF1),
DBG_STRING(WHAL_ERROR_RESET_CHANNF2),
DBG_STRING(WHAL_ERROR_RESET_PM),
DBG_STRING(WHAL_ERROR_RESET_OFFSETCAL),
DBG_STRING(WHAL_ERROR_RESET_RFGRANT),
DBG_STRING(WHAL_ERROR_RESET_RXFRAME),
DBG_STRING(WHAL_ERROR_RESET_STOPDMA),
DBG_STRING(WHAL_ERROR_RESET_ERRID),
DBG_STRING(WHAL_ERROR_RESET_ADCDCCAL1),
DBG_STRING(WHAL_ERROR_RESET_ADCDCCAL2),
DBG_STRING(WHAL_ERROR_RESET_TXIQCAL),
DBG_STRING(WHAL_ERROR_RESET_RXIQCAL),
DBG_STRING(WHAL_ERROR_RESET_CARRIERLEAK),
DBG_STRING(WHAL_ERROR_XMIT_COMPUTE),
DBG_STRING(WHAL_ERROR_XMIT_NOQUEUE),
DBG_STRING(WHAL_ERROR_XMIT_ACTIVEQUEUE),
DBG_STRING(WHAL_ERROR_XMIT_BADTYPE),
DBG_STRING(WHAL_ERROR_XMIT_STOPDMA),
DBG_STRING(WHAL_ERROR_INTERRUPT_BB_PANIC),
DBG_STRING(WHAL_ERROR_PAPRD_MAXGAIN_ABOVE_WINDOW),
DBG_STRING(WHAL_ERROR_QCU_HW_PAUSE_MISMATCH),
DBG_STRING(WHAL_ERROR_POWER_RFLP_CONFIG),
DBG_STRING(WHAL_ERROR_POWER_RFLP_SYNTHBYPASS_CONFIG),
DBG_STRING(WHAL_ERROR_POWER_RFLP_BIAS2X_CONFIG),
DBG_STRING(WHAL_ERROR_POWER_RFLP_PLLBYPASS_CONFIG),
DBG_STRING(WHAL_ERROR_POWER_RFLP_OFF1CHAN_CONFIG),
DBG_STRING(WHAL_ERROR_POWER_ANTENNA_LMIT),
DBG_STRING(WHAL_ERROR_POWER_REGDMN_TX_LMIT),
DBG_STRING(WHAL_ERROR_POWER_MODE_SCALED_PWR),
DBG_STRING(WHAL_ERROR_POWER_EDGE_PWR_TPSCALE),
DBG_STRING(WHAL_ERROR_POWER_CHAN_REGALLOW),
DBG_STRING(WHAL_ERROR_WAIT_REG_TIMEOUT),
DBG_STRING(WHAL_ERROR_XTAL_SET),
DBG_STRING(WHAL_DBGID_DEFINITION_END),
},
{
DBG_STRING(COEX_DEBUGID_START),
DBG_STRING(BTCOEX_DBG_MCI_1),
DBG_STRING(BTCOEX_DBG_MCI_2),
DBG_STRING(BTCOEX_DBG_MCI_3),
DBG_STRING(BTCOEX_DBG_MCI_4),
DBG_STRING(BTCOEX_DBG_MCI_5),
DBG_STRING(BTCOEX_DBG_MCI_6),
DBG_STRING(BTCOEX_DBG_MCI_7),
DBG_STRING(BTCOEX_DBG_MCI_8),
DBG_STRING(BTCOEX_DBG_MCI_9),
DBG_STRING(BTCOEX_DBG_MCI_10),
DBG_STRING(COEX_WAL_BTCOEX_INIT),
DBG_STRING(COEX_WAL_PAUSE),
DBG_STRING(COEX_WAL_RESUME),
DBG_STRING(COEX_UPDATE_AFH),
DBG_STRING(COEX_HWQ_EMPTY_CB),
DBG_STRING(COEX_MCI_TIMER_HANDLER),
DBG_STRING(COEX_MCI_RECOVER),
DBG_STRING(ERROR_COEX_MCI_ISR),
DBG_STRING(ERROR_COEX_MCI_GPM),
DBG_STRING(COEX_ProfileType),
DBG_STRING(COEX_LinkID),
DBG_STRING(COEX_LinkState),
DBG_STRING(COEX_LinkRole),
DBG_STRING(COEX_LinkRate),
DBG_STRING(COEX_VoiceType),
DBG_STRING(COEX_TInterval),
DBG_STRING(COEX_WRetrx),
DBG_STRING(COEX_Attempts),
DBG_STRING(COEX_PerformanceState),
DBG_STRING(COEX_LinkType),
DBG_STRING(COEX_RX_MCI_GPM_VERSION_QUERY),
DBG_STRING(COEX_RX_MCI_GPM_VERSION_RESPONSE),
DBG_STRING(COEX_RX_MCI_GPM_STATUS_QUERY),
DBG_STRING(COEX_STATE_WLAN_VDEV_DOWN),
DBG_STRING(COEX_STATE_WLAN_VDEV_START),
DBG_STRING(COEX_STATE_WLAN_VDEV_CONNECTED),
DBG_STRING(COEX_STATE_WLAN_VDEV_SCAN_STARTED),
DBG_STRING(COEX_STATE_WLAN_VDEV_SCAN_END),
DBG_STRING(COEX_STATE_WLAN_DEFAULT),
DBG_STRING(COEX_CHANNEL_CHANGE),
DBG_STRING(COEX_POWER_CHANGE),
DBG_STRING(COEX_CONFIG_MGR),
DBG_STRING(COEX_TX_MCI_GPM_BT_CAL_REQ),
DBG_STRING(COEX_TX_MCI_GPM_BT_CAL_GRANT),
DBG_STRING(COEX_TX_MCI_GPM_BT_CAL_DONE),
DBG_STRING(COEX_TX_MCI_GPM_WLAN_CAL_REQ),
DBG_STRING(COEX_TX_MCI_GPM_WLAN_CAL_GRANT),
DBG_STRING(COEX_TX_MCI_GPM_WLAN_CAL_DONE),
DBG_STRING(COEX_TX_MCI_GPM_BT_DEBUG),
DBG_STRING(COEX_TX_MCI_GPM_VERSION_QUERY),
DBG_STRING(COEX_TX_MCI_GPM_VERSION_RESPONSE),
DBG_STRING(COEX_TX_MCI_GPM_STATUS_QUERY),
DBG_STRING(COEX_TX_MCI_GPM_HALT_BT_GPM),
DBG_STRING(COEX_TX_MCI_GPM_WLAN_CHANNELS),
DBG_STRING(COEX_TX_MCI_GPM_BT_PROFILE_INFO),
DBG_STRING(COEX_TX_MCI_GPM_BT_STATUS_UPDATE),
DBG_STRING(COEX_TX_MCI_GPM_BT_UPDATE_FLAGS),
DBG_STRING(COEX_TX_MCI_GPM_UNKNOWN),
DBG_STRING(COEX_TX_MCI_SYS_WAKING),
DBG_STRING(COEX_TX_MCI_LNA_TAKE),
DBG_STRING(COEX_TX_MCI_LNA_TRANS),
DBG_STRING(COEX_TX_MCI_SYS_SLEEPING),
DBG_STRING(COEX_TX_MCI_REQ_WAKE),
DBG_STRING(COEX_TX_MCI_REMOTE_RESET),
DBG_STRING(COEX_TX_MCI_TYPE_UNKNOWN),
DBG_STRING(COEX_WHAL_MCI_RESET),
DBG_STRING(COEX_POLL_BT_CAL_DONE_TIMEOUT),
DBG_STRING(COEX_WHAL_PAUSE),
DBG_STRING(COEX_RX_MCI_GPM_BT_CAL_REQ),
DBG_STRING(COEX_RX_MCI_GPM_BT_CAL_DONE),
DBG_STRING(COEX_RX_MCI_GPM_BT_CAL_GRANT),
DBG_STRING(COEX_WLAN_CAL_START),
DBG_STRING(COEX_WLAN_CAL_RESULT),
DBG_STRING(COEX_BtMciState),
DBG_STRING(COEX_BtCalState),
DBG_STRING(COEX_WlanCalState),
DBG_STRING(COEX_RxReqWakeCount),
DBG_STRING(COEX_RxRemoteResetCount),
DBG_STRING(COEX_RESTART_CAL),
DBG_STRING(COEX_SENDMSG_QUEUE),
DBG_STRING(COEX_RESETSEQ_LNAINFO_TIMEOUT),
DBG_STRING(COEX_MCI_ISR_IntRaw),
DBG_STRING(COEX_MCI_ISR_Int1Raw),
DBG_STRING(COEX_MCI_ISR_RxMsgRaw),
DBG_STRING(COEX_WHAL_COEX_RESET),
DBG_STRING(COEX_WAL_COEX_INIT),
DBG_STRING(COEX_TXRX_CNT_LIMIT_ISR),
DBG_STRING(COEX_CH_BUSY),
DBG_STRING(COEX_REASSESS_WLAN_STATE),
DBG_STRING(COEX_BTCOEX_WLAN_STATE_UPDATE),
DBG_STRING(COEX_BT_NUM_OF_PROFILES),
DBG_STRING(COEX_BT_NUM_OF_HID_PROFILES),
DBG_STRING(COEX_BT_NUM_OF_ACL_PROFILES),
DBG_STRING(COEX_BT_NUM_OF_HI_ACL_PROFILES),
DBG_STRING(COEX_BT_NUM_OF_VOICE_PROFILES),
DBG_STRING(COEX_WLAN_AGGR_LIMIT),
DBG_STRING(COEX_BT_LOW_PRIO_BUDGET),
DBG_STRING(COEX_BT_HI_PRIO_BUDGET),
DBG_STRING(COEX_BT_IDLE_TIME),
DBG_STRING(COEX_SET_COEX_WEIGHT),
DBG_STRING(COEX_WLAN_WEIGHT_GROUP),
DBG_STRING(COEX_BT_WEIGHT_GROUP),
DBG_STRING(COEX_BT_INTERVAL_ALLOC),
DBG_STRING(COEX_BT_SCHEME),
DBG_STRING(COEX_BT_MGR),
DBG_STRING(COEX_BT_SM_ERROR),
DBG_STRING(COEX_SYSTEM_UPDATE),
DBG_STRING(COEX_LOW_PRIO_LIMIT),
DBG_STRING(COEX_HI_PRIO_LIMIT),
DBG_STRING(COEX_BT_INTERVAL_START),
DBG_STRING(COEX_WLAN_INTERVAL_START),
DBG_STRING(COEX_NON_LINK_BUDGET),
DBG_STRING(COEX_CONTENTION_MSG),
DBG_STRING(COEX_SET_NSS),
DBG_STRING(COEX_SELF_GEN_MASK),
DBG_STRING(COEX_PROFILE_ERROR),
DBG_STRING(COEX_WLAN_INIT),
DBG_STRING(COEX_BEACON_MISS),
DBG_STRING(COEX_BEACON_OK),
DBG_STRING(COEX_BTCOEX_SCAN_ACTIVITY),
DBG_STRING(COEX_SCAN_ACTIVITY),
DBG_STRING(COEX_FORCE_QUIETTIME),
DBG_STRING(COEX_BT_MGR_QUIETTIME),
DBG_STRING(COEX_BT_INACTIVITY_TRIGGER),
DBG_STRING(COEX_BT_INACTIVITY_REPORTED),
DBG_STRING(COEX_TX_MCI_GPM_WLAN_PRIO),
DBG_STRING(COEX_TX_MCI_GPM_BT_PAUSE_PROFILE),
DBG_STRING(COEX_TX_MCI_GPM_WLAN_SET_ACL_INACTIVITY),
DBG_STRING(COEX_RX_MCI_GPM_BT_ACL_INACTIVITY_REPORT),
DBG_STRING(COEX_GENERIC_ERROR),
DBG_STRING(COEX_RX_RATE_THRESHOLD),
DBG_STRING(COEX_RSSI),
DBG_STRING(COEX_WLAN_VDEV_NOTIF_START), // 133
DBG_STRING(COEX_WLAN_VDEV_NOTIF_UP), // 134
DBG_STRING(COEX_WLAN_VDEV_NOTIF_DOWN), // 135
DBG_STRING(COEX_WLAN_VDEV_NOTIF_STOP), // 136
DBG_STRING(COEX_WLAN_VDEV_NOTIF_ADD_PEER), // 137
DBG_STRING(COEX_WLAN_VDEV_NOTIF_DELETE_PEER), // 138
DBG_STRING(COEX_WLAN_VDEV_NOTIF_CONNECTED_PEER), // 139
DBG_STRING(COEX_WLAN_VDEV_NOTIF_PAUSE), // 140
DBG_STRING(COEX_WLAN_VDEV_NOTIF_UNPAUSED), // 141
DBG_STRING(COEX_STATE_WLAN_VDEV_PEER_ADD), // 142
DBG_STRING(COEX_STATE_WLAN_VDEV_CONNECTED_PEER), // 143
DBG_STRING(COEX_STATE_WLAN_VDEV_DELETE_PEER), // 144
DBG_STRING(COEX_STATE_WLAN_VDEV_PAUSE), // 145
DBG_STRING(COEX_STATE_WLAN_VDEV_UNPAUSED), // 146
DBG_STRING(COEX_SCAN_CALLBACK), // 147
DBG_STRING(COEX_RC_SET_CHAINMASK), // 148
DBG_STRING(COEX_TX_MCI_GPM_WLAN_SET_BT_RXSS_THRES), // 149
DBG_STRING(COEX_TX_MCI_GPM_BT_RXSS_THRES_QUERY), // 150
DBG_STRING(COEX_BT_RXSS_THRES), // 151
DBG_STRING(COEX_BT_PROFILE_ADD_RMV), // 152
DBG_STRING(COEX_BT_SCHED_INFO), // 153
DBG_STRING(COEX_TRF_MGMT), // 154
DBG_STRING(COEX_SCHED_START), // 155
DBG_STRING(COEX_SCHED_RESULT), // 156
DBG_STRING(COEX_SCHED_ERROR), // 157
DBG_STRING(COEX_SCHED_PRE_OP), // 158
DBG_STRING(COEX_SCHED_POST_OP), // 159
DBG_STRING(COEX_RX_RATE), // 160
DBG_STRING(COEX_ACK_PRIORITY), // 161
DBG_STRING(COEX_STATE_WLAN_VDEV_UP), // 162
DBG_STRING(COEX_STATE_WLAN_VDEV_PEER_UPDATE), // 163
DBG_STRING(COEX_STATE_WLAN_VDEV_STOP), // 164
DBG_STRING(COEX_WLAN_PAUSE_PEER), // 165
DBG_STRING(COEX_WLAN_UNPAUSE_PEER), // 166
DBG_STRING(COEX_WLAN_PAUSE_INTERVAL_START), // 167
DBG_STRING(COEX_WLAN_POSTPAUSE_INTERVAL_START), // 168
DBG_STRING(COEX_TRF_FREERUN), // 169
DBG_STRING(COEX_TRF_SHAPE_PM), // 170
DBG_STRING(COEX_TRF_SHAPE_PSP), // 171
DBG_STRING(COEX_TRF_SHAPE_S_CTS), // 172
DBG_STRING(COEX_CHAIN_CONFIG), // 173
DBG_STRING(COEX_SYSTEM_MONITOR), // 174
DBG_STRING(COEX_SINGLECHAIN_INIT), // 175
DBG_STRING(COEX_MULTICHAIN_INIT), // 176
DBG_STRING(COEX_SINGLECHAIN_DBG_1), // 177
DBG_STRING(COEX_SINGLECHAIN_DBG_2), // 178
DBG_STRING(COEX_SINGLECHAIN_DBG_3), // 179
DBG_STRING(COEX_MULTICHAIN_DBG_1), // 180
DBG_STRING(COEX_MULTICHAIN_DBG_2), // 181
DBG_STRING(COEX_MULTICHAIN_DBG_3), // 182
DBG_STRING(COEX_PSP_TX_CB), // 183
DBG_STRING(COEX_PSP_RX_CB), // 184
DBG_STRING(COEX_PSP_STAT_1), // 185
DBG_STRING(COEX_PSP_SPEC_POLL), // 186
DBG_STRING(COEX_PSP_READY_STATE), // 187
DBG_STRING(COEX_PSP_TX_STATUS_STATE), // 188
DBG_STRING(COEX_PSP_RX_STATUS_STATE_1), // 189
DBG_STRING(COEX_PSP_NOT_READY_STATE), // 190
DBG_STRING(COEX_PSP_DISABLED_STATE), // 191
DBG_STRING(COEX_PSP_ENABLED_STATE), // 192
DBG_STRING(COEX_PSP_SEND_PSPOLL), // 193
DBG_STRING(COEX_PSP_MGR_ENTER), // 194
DBG_STRING(COEX_PSP_MGR_RESULT), // 195
DBG_STRING(COEX_PSP_NONWLAN_INTERVAL), // 196
DBG_STRING(COEX_PSP_STAT_2), // 197
DBG_STRING(COEX_PSP_RX_STATUS_STATE_2), // 198
DBG_STRING(COEX_PSP_ERROR), // 199
DBG_STRING(COEX_T2BT), // 200
DBG_STRING(COEX_BT_DURATION), // 201
DBG_STRING(COEX_TX_MCI_GPM_WLAN_SCHED_INFO_TRIG), // 202
DBG_STRING(COEX_TX_MCI_GPM_WLAN_SCHED_INFO_TRIG_RSP), // 203
DBG_STRING(COEX_TX_MCI_GPM_SCAN_OP), // 204
DBG_STRING(COEX_TX_MCI_GPM_BT_PAUSE_GPM_TX), // 205
DBG_STRING(COEX_CTS2S_SEND), // 206
DBG_STRING(COEX_CTS2S_RESULT), // 207
DBG_STRING(COEX_ENTER_OCS), // 208
DBG_STRING(COEX_EXIT_OCS), // 209
DBG_STRING(COEX_UPDATE_OCS), // 210
DBG_STRING(COEX_STATUS_OCS), // 211
DBG_STRING(COEX_STATS_BT), // 212
DBG_STRING(COEX_MWS_WLAN_INIT),
DBG_STRING(COEX_MWS_WBTMR_SYNC),
DBG_STRING(COEX_MWS_TYPE2_RX),
DBG_STRING(COEX_MWS_TYPE2_TX),
DBG_STRING(COEX_MWS_WLAN_CHAVD),
DBG_STRING(COEX_MWS_WLAN_CHAVD_INSERT),
DBG_STRING(COEX_MWS_WLAN_CHAVD_MERGE),
DBG_STRING(COEX_MWS_WLAN_CHAVD_RPT),
DBG_STRING(COEX_MWS_CP_MSG_SEND),
DBG_STRING(COEX_MWS_CP_ESCAPE),
DBG_STRING(COEX_MWS_CP_UNFRAME),
DBG_STRING(COEX_MWS_CP_SYNC_UPDATE),
DBG_STRING(COEX_MWS_CP_SYNC),
DBG_STRING(COEX_MWS_CP_WLAN_STATE_IND),
DBG_STRING(COEX_MWS_CP_SYNCRESP_TIMEOUT),
DBG_STRING(COEX_MWS_SCHEME_UPDATE),
DBG_STRING(COEX_MWS_WLAN_EVENT),
DBG_STRING(COEX_MWS_UART_UNESCAPE),
DBG_STRING(COEX_MWS_UART_ENCODE_SEND),
DBG_STRING(COEX_MWS_UART_RECV_DECODE),
DBG_STRING(COEX_MWS_UL_HDL),
DBG_STRING(COEX_MWS_REMOTE_EVENT),
DBG_STRING(COEX_MWS_OTHER),
DBG_STRING(COEX_MWS_ERROR),
DBG_STRING(COEX_MWS_ANT_DIVERSITY), //237
DBG_STRING(COEX_P2P_GO),
DBG_STRING(COEX_P2P_CLIENT),
DBG_STRING(COEX_SCC_1),
DBG_STRING(COEX_SCC_2),
DBG_STRING(COEX_MCC_1),
DBG_STRING(COEX_MCC_2),
DBG_STRING(COEX_TRF_SHAPE_NOA),
DBG_STRING(COEX_NOA_ONESHOT),
DBG_STRING(COEX_NOA_PERIODIC),
DBG_STRING(COEX_LE_1),
DBG_STRING(COEX_LE_2),
DBG_STRING(COEX_ANT_1),
DBG_STRING(COEX_ANT_2),
DBG_STRING(COEX_ENTER_NOA),
DBG_STRING(COEX_EXIT_NOA),
DBG_STRING(COEX_BT_SCAN_PROTECT), // 253
DBG_STRING(COEX_DEBUG_ID_END) // 254
},
{
DBG_STRING(ROAM_DBGID_DEFINITION_START),
DBG_STRING(ROAM_MODULE_INIT),
DBG_STRING(ROAM_DEV_START),
DBG_STRING(ROAM_CONFIG_RSSI_THRESH),
DBG_STRING(ROAM_CONFIG_SCAN_PERIOD),
DBG_STRING(ROAM_CONFIG_AP_PROFILE),
DBG_STRING(ROAM_CONFIG_CHAN_LIST),
DBG_STRING(ROAM_CONFIG_SCAN_PARAMS),
DBG_STRING(ROAM_CONFIG_RSSI_CHANGE),
DBG_STRING(ROAM_SCAN_TIMER_START),
DBG_STRING(ROAM_SCAN_TIMER_EXPIRE),
DBG_STRING(ROAM_SCAN_TIMER_STOP),
DBG_STRING(ROAM_SCAN_STARTED),
DBG_STRING(ROAM_SCAN_COMPLETE),
DBG_STRING(ROAM_SCAN_CANCELLED),
DBG_STRING(ROAM_CANDIDATE_FOUND),
DBG_STRING(ROAM_RSSI_ACTIVE_SCAN),
DBG_STRING(ROAM_RSSI_ACTIVE_ROAM),
DBG_STRING(ROAM_RSSI_GOOD),
DBG_STRING(ROAM_BMISS_FIRST_RECV),
DBG_STRING(ROAM_DEV_STOP),
DBG_STRING(ROAM_FW_OFFLOAD_ENABLE),
DBG_STRING(ROAM_CANDIDATE_SSID_MATCH),
DBG_STRING(ROAM_CANDIDATE_SECURITY_MATCH),
DBG_STRING(ROAM_LOW_RSSI_INTERRUPT),
DBG_STRING(ROAM_HIGH_RSSI_INTERRUPT),
DBG_STRING(ROAM_SCAN_REQUESTED),
DBG_STRING(ROAM_BETTER_CANDIDATE_FOUND),
DBG_STRING(ROAM_BETTER_AP_EVENT),
DBG_STRING(ROAM_CANCEL_LOW_PRIO_SCAN),
DBG_STRING(ROAM_FINAL_BMISS_RECVD),
DBG_STRING(ROAM_CONFIG_SCAN_MODE),
DBG_STRING(ROAM_BMISS_FINAL_SCAN_ENABLE),
DBG_STRING(ROAM_SUITABLE_AP_EVENT),
DBG_STRING(ROAM_RSN_IE_PARSE_ERROR),
DBG_STRING(ROAM_WPA_IE_PARSE_ERROR),
DBG_STRING(ROAM_SCAN_CMD_FROM_HOST),
DBG_STRING(ROAM_HO_SORT_CANDIDATE),
DBG_STRING(ROAM_HO_SAVE_CANDIDATE),
DBG_STRING(ROAM_HO_GET_CANDIDATE),
DBG_STRING(ROAM_HO_OFFLOAD_SET_PARAM),
DBG_STRING(ROAM_HO_SM),
DBG_STRING(ROAM_HO_HTT_SAVED),
DBG_STRING(ROAM_HO_SYNC_START),
DBG_STRING(ROAM_HO_START),
DBG_STRING(ROAM_HO_SYNC_COMPLETE),
DBG_STRING(ROAM_HO_STOP),
DBG_STRING(ROAM_HO_HTT_FORWARD),
DBG_STRING(ROAM_CONFIG_SCAN_PARAMS_1),
DBG_STRING(ROAM_SCAN_COMPLETE_1),
DBG_STRING(ROAM_SWBMISS_BCN_RECV_VAL),
DBG_STRING(ROAM_SWBMISS_BCN_RECV_THRE2),
DBG_STRING(ROAM_SCAN_REQUESTED_1),
DBG_STRING(ROAM_HO_SORT_CANDIDATE_CUR),
DBG_STRING(ROAM_HO_SAVE_CANDIDATE_DUP),
DBG_STRING(ROAM_HO_SM_EVENT),
DBG_STRING(ROAM_HO_ENTER_CH),
DBG_STRING(ROAM_HO_MGMT_RX),
DBG_STRING(ROAM_HO_CANDIDATE_INFO),
DBG_STRING(ROAM_HO_OFFLD_DATA_STORE),
DBG_STRING(ROAM_HO_HTT_DATA_STORE),
DBG_STRING(ROAM_HO_UPDATE_STATUS),
DBG_STRING(ROAM_HO_OCS_CH_CB),
DBG_STRING(ROAM_RSSI_INTERRUPT_STATE),
DBG_STRING(ROAM_INVOKE_PARAM_CHECK),
DBG_STRING(ROAM_INVOKE_PARAM_CHAN),
DBG_STRING(ROAM_INVOKE_PARAM_BSSID),
DBG_STRING(ROAM_INVOKE_STATE_CHECK),
DBG_STRING(ROAM_INVOKE_START_SUCCESS),
DBG_STRING(ROAM_INVOKE_START_FAILURE),
DBG_STRING(ROAM_INVOKE_BSSID_CHECK),
DBG_STRING(ROAM_CANDIDATE_INFO),
DBG_STRING(ROAM_CANDIDATE_FILTER_MATCH),
DBG_STRING(ROAM_CANDIDATE_RSSI_ADJUST),
DBG_STRING(ROAM_CONFIG_ROAM_FILTER),
DBG_STRING(ROAM_EXTENDED_RSSI_TRESHOLD_1),
DBG_STRING(ROAM_EXTENDED_RSSI_TRESHOLD_2),
DBG_STRING(ROAM_BLACKLIST_BSSID),
DBG_STRING(ROAM_WHITELIST_SSID),
DBG_STRING(ROAM_WHITELIST_SSID_2),
DBG_STRING(ROAM_PREFERRED_BSSID),
DBG_STRING(ROAM_PREFERRED_FACTOR),
DBG_STRING(ROAM_SCAN_HIRSSI_THRESHOLD),
DBG_STRING(ROAM_SCAN_HIRSSI_CHECK),
DBG_STRING(ROAM_SCAN_HIRSSI_TIMER_EXPIRED),
DBG_STRING(ROAM_SCAN_EXTSCAN_CHECK),
DBG_STRING(ROAM_DBGID_DEFINITION_END)
},
{
DBG_STRING(RESMGR_CHMGR_DEFINITION_START),
DBG_STRING(RESMGR_CHMGR_PAUSE_COMPLETE),
DBG_STRING(RESMGR_CHMGR_CHANNEL_CHANGE),
DBG_STRING(RESMGR_CHMGR_RESUME_COMPLETE),
DBG_STRING(RESMGR_CHMGR_VDEV_PAUSE),
DBG_STRING(RESMGR_CHMGR_VDEV_UNPAUSE),
DBG_STRING(RESMGR_CHMGR_CTS2S_TX_COMP),
DBG_STRING(RESMGR_CHMGR_CFEND_TX_COMP),
DBG_STRING(RESMGR_CHMGR_DEFINITION_END)
},
{
DBG_STRING(RESMGR_DEFINITION_START),
DBG_STRING(RESMGR_OCS_ALLOCRAM_SIZE),
DBG_STRING(RESMGR_OCS_RESOURCES),
DBG_STRING(RESMGR_LINK_CREATE),
DBG_STRING(RESMGR_LINK_DELETE),
DBG_STRING(RESMGR_OCS_CHREQ_CREATE),
DBG_STRING(RESMGR_OCS_CHREQ_DELETE),
DBG_STRING(RESMGR_OCS_CHREQ_START),
DBG_STRING(RESMGR_OCS_CHREQ_STOP),
DBG_STRING(RESMGR_OCS_SCHEDULER_INVOKED),
DBG_STRING(RESMGR_OCS_CHREQ_GRANT),
DBG_STRING(RESMGR_OCS_CHREQ_COMPLETE),
DBG_STRING(RESMGR_OCS_NEXT_TSFTIME),
DBG_STRING(RESMGR_OCS_TSF_TIMEOUT_US),
DBG_STRING(RESMGR_OCS_CURR_CAT_WINDOW),
DBG_STRING(RESMGR_OCS_CURR_CAT_WINDOW_REQ),
DBG_STRING(RESMGR_OCS_CURR_CAT_WINDOW_TIMESLOT),
DBG_STRING(RESMGR_OCS_CHREQ_RESTART),
DBG_STRING(RESMGR_OCS_CLEANUP_CH_ALLOCATORS),
DBG_STRING(RESMGR_OCS_PURGE_CHREQ),
DBG_STRING(RESMGR_OCS_CH_ALLOCATOR_FREE),
DBG_STRING(RESMGR_OCS_RECOMPUTE_SCHEDULE),
DBG_STRING(RESMGR_OCS_NEW_CAT_WINDOW_REQ),
DBG_STRING(RESMGR_OCS_NEW_CAT_WINDOW_TIMESLOT),
DBG_STRING(RESMGR_OCS_CUR_CH_ALLOC),
DBG_STRING(RESMGR_OCS_WIN_CH_ALLOC),
DBG_STRING(RESMGR_OCS_SCHED_CH_CHANGE),
DBG_STRING(RESMGR_OCS_CONSTRUCT_CAT_WIN),
DBG_STRING(RESMGR_OCS_CHREQ_PREEMPTED),
DBG_STRING(RESMGR_OCS_CH_SWITCH_REQ),
DBG_STRING(RESMGR_OCS_CHANNEL_SWITCHED),
DBG_STRING(RESMGR_OCS_CLEANUP_STALE_REQS),
DBG_STRING(RESMGR_OCS_CHREQ_UPDATE),
DBG_STRING(RESMGR_OCS_REG_NOA_NOTIF),
DBG_STRING(RESMGR_OCS_DEREG_NOA_NOTIF),
DBG_STRING(RESMGR_OCS_GEN_PERIODIC_NOA),
DBG_STRING(RESMGR_OCS_RECAL_QUOTAS),
DBG_STRING(RESMGR_OCS_GRANTED_QUOTA_STATS),
DBG_STRING(RESMGR_OCS_ALLOCATED_QUOTA_STATS),
DBG_STRING(RESMGR_OCS_REQ_QUOTA_STATS),
DBG_STRING(RESMGR_OCS_TRACKING_TIME_FIRED),
DBG_STRING(RESMGR_VC_ARBITRATE_ATTRIBUTES),
DBG_STRING(RESMGR_OCS_LATENCY_STRICT_TIME_SLOT),
DBG_STRING(RESMGR_OCS_CURR_TSF),
DBG_STRING(RESMGR_OCS_QUOTA_REM),
DBG_STRING(RESMGR_OCS_LATENCY_CASE_NO),
DBG_STRING(RESMGR_OCS_WIN_CAT_DUR),
DBG_STRING(RESMGR_VC_UPDATE_CUR_VC),
DBG_STRING(RESMGR_VC_REG_UNREG_LINK),
DBG_STRING(RESMGR_VC_PRINT_LINK),
DBG_STRING(RESMGR_OCS_MISS_TOLERANCE),
DBG_STRING(RESMGR_DYN_SCH_ALLOCRAM_SIZE),
DBG_STRING(RESMGR_DYN_SCH_ENABLE),
DBG_STRING(RESMGR_DYN_SCH_ACTIVE),
DBG_STRING(RESMGR_DYN_SCH_CH_STATS_START),
DBG_STRING(RESMGR_DYN_SCH_CH_SX_STATS),
DBG_STRING(RESMGR_DYN_SCH_TOT_UTIL_PER),
DBG_STRING(RESMGR_DYN_SCH_HOME_CH_QUOTA),
DBG_STRING(RESMGR_OCS_REG_RECAL_QUOTA_NOTIF),
DBG_STRING(RESMGR_OCS_DEREG_RECAL_QUOTA_NOTIF),
DBG_STRING(RESMGR_DYN_SCH_CH_STATS_END),
DBG_STRING(RESMGR_DEFINITION_END)
},
{
DBG_STRING(VDEV_MGR_DEFINITION_START), /* vdev Mgr */
DBG_STRING(VDEV_MGR_FIRST_BMISS_DETECTED),
DBG_STRING(VDEV_MGR_FINAL_BMISS_DETECTED),
DBG_STRING(VDEV_MGR_BCN_IN_SYNC),
DBG_STRING(VDEV_MGR_AP_KEEPALIVE_IDLE),
DBG_STRING(VDEV_MGR_AP_KEEPALIVE_INACTIVE),
DBG_STRING(VDEV_MGR_AP_KEEPALIVE_UNRESPONSIVE),
DBG_STRING(VDEV_MGR_AP_TBTT_CONFIG),
DBG_STRING(VDEV_MGR_FIRST_BCN_RECEIVED),
DBG_STRING(VDEV_MGR_VDEV_START),
DBG_STRING(VDEV_MGR_VDEV_UP),
DBG_STRING(VDEV_MGR_PEER_AUTHORIZED),
DBG_STRING(VDEV_MGR_OCS_HP_LP_REQ_POSTED),
DBG_STRING(VDEV_MGR_VDEV_START_OCS_HP_REQ_COMPLETE),
DBG_STRING(VDEV_MGR_VDEV_START_OCS_HP_REQ_STOP),
DBG_STRING(VDEV_MGR_HP_START_TIME),
DBG_STRING(VDEV_MGR_VDEV_PAUSE_DELAY_UPDATE),
DBG_STRING(VDEV_MGR_VDEV_PAUSE_FAIL),
DBG_STRING(VDEV_MGR_GEN_PERIODIC_NOA),
DBG_STRING(VDEV_MGR_OFF_CHAN_GO_CH_REQ_SETUP),
DBG_STRING(VDEV_MGR_DEFINITION_END),
},
{
DBG_STRING(SCAN_START_COMMAND_FAILED), /* scan */
DBG_STRING(SCAN_STOP_COMMAND_FAILED),
DBG_STRING(SCAN_EVENT_SEND_FAILED),
DBG_STRING(SCAN_ENGINE_START),
DBG_STRING(SCAN_ENGINE_CANCEL_COMMAND),
DBG_STRING(SCAN_ENGINE_STOP_DUE_TO_TIMEOUT),
DBG_STRING(SCAN_EVENT_SEND_TO_HOST),
DBG_STRING(SCAN_FWLOG_EVENT_ADD),
DBG_STRING(SCAN_FWLOG_EVENT_REM),
DBG_STRING(SCAN_FWLOG_EVENT_PREEMPTED),
DBG_STRING(SCAN_FWLOG_EVENT_RESTARTED),
DBG_STRING(SCAN_FWLOG_EVENT_COMPLETED),
DBG_STRING(SCAN_SM_REQ_NEXT_CH),
DBG_STRING(SCAN_ENG_START),
DBG_STRING(SCAN_ENG_CANCEL),
DBG_STRING(SCAN_ENG_SPOOFED_MAC_ADDR),
DBG_STRING(SCAN_ENG_PARAM_1),
DBG_STRING(SCAN_ENG_PARAM_2),
DBG_STRING(SCAN_ENG_MAX_SCAN_TIMEOUT),
DBG_STRING(SCAN_ENG_START_IN_PROGRESS),
DBG_STRING(SCAN_SM_START_COMMAND_FAILED),
DBG_STRING(SCAN_SCH_START),
DBG_STRING(SCAN_SCH_START_INFO),
DBG_STRING(SCAN_SCH_START_NEW_REQ_FAILED),
DBG_STRING(SCAN_SCH_START_ALLOC_FAIL),
DBG_STRING(SCAN_SCH_ENGINE_STOP_DUE_TO_TIMEOUT),
DBG_STRING(SCAN_SCH_POLICY_EVENT),
DBG_STRING(SCAN_SCH_CANCEL),
DBG_STRING(SCAN_SCH_STOP_COMMAND_FAILED),
DBG_STRING(SCAN_SCH_NEXT_SCAN_FAILED),
DBG_STRING(SCAN_WMI_SET_CHAN_LIST),
DBG_STRING(SCAN_EVENT_STARTED),
DBG_STRING(SCAN_EVENT_BSS_CHANNEL),
DBG_STRING(SCAN_EVENT_FOREIGN_CHANNEL),
DBG_STRING(SCAN_EVENT_DEQUEUED),
DBG_STRING(SCAN_EVENT_START_FAILED),
DBG_STRING(SCAN_EVENT_FOREIGN_CHANNEL_EXIT),
DBG_STRING(SCAN_SM_DISPATCH),
DBG_STRING(SCAN_SM_TRANSITIONS),
DBG_STRING(SCAN_SM_REQ_NEXT_CHAN),
DBG_STRING(SCAN_SEND_PROBE_REQ_RET_VDEV),
DBG_STRING(SCAN_SEND_PROBE_REQ_RET_PLM),
DBG_STRING(SCAN_SEND_PROBE_REQ_RET_PASSIVE),
DBG_STRING(SCAN_SEND_PROBE_REQ_RET_RADAR),
DBG_STRING(SCAN_SEND_PROBE_REQ_RET_DFS),
DBG_STRING(SCAN_SEND_PROBE_REQ_INFO),
DBG_STRING(SCAN_SM_CANCEL),
DBG_STRING(SCAN_SM_PROBE_REQ_FRAME_SEND_FAILED),
DBG_STRING(SCAN_SCH_BANNED_MODULE),
DBG_STRING(SCAN_SM_STATS_INFO),
DBG_STRING(SCAN_DBGID_DEFINITION_END),
},
{
DBG_STRING(RATECTRL_DBGID_DEFINITION_START), /* Rate ctrl*/
DBG_STRING(RATECTRL_DBGID_ASSOC),
DBG_STRING(RATECTRL_DBGID_NSS_CHANGE),
DBG_STRING(RATECTRL_DBGID_CHAINMASK_ERR),
DBG_STRING(RATECTRL_DBGID_UNEXPECTED_FRAME),
DBG_STRING(RATECTRL_DBGID_WAL_RCQUERY),
DBG_STRING(RATECTRL_DBGID_WAL_RCUPDATE),
DBG_STRING(RATECTRL_DBGID_GTX_UPDATE),
DBG_STRING(RATECTRL_DBGID_DEFINITION_END)
},
{
DBG_STRING(AP_PS_DBGID_DEFINITION_START),
DBG_STRING(AP_PS_DBGID_UPDATE_TIM),
DBG_STRING(AP_PS_DBGID_PEER_STATE_CHANGE),
DBG_STRING(AP_PS_DBGID_PSPOLL),
DBG_STRING(AP_PS_DBGID_PEER_CREATE),
DBG_STRING(AP_PS_DBGID_PEER_DELETE),
DBG_STRING(AP_PS_DBGID_VDEV_CREATE),
DBG_STRING(AP_PS_DBGID_VDEV_DELETE),
DBG_STRING(AP_PS_DBGID_SYNC_TIM),
DBG_STRING(AP_PS_DBGID_NEXT_RESPONSE),
DBG_STRING(AP_PS_DBGID_START_SP),
DBG_STRING(AP_PS_DBGID_COMPLETED_EOSP),
DBG_STRING(AP_PS_DBGID_TRIGGER),
DBG_STRING(AP_PS_DBGID_DUPLICATE_TRIGGER),
DBG_STRING(AP_PS_DBGID_UAPSD_RESPONSE),
DBG_STRING(AP_PS_DBGID_SEND_COMPLETE),
DBG_STRING(AP_PS_DBGID_SEND_N_COMPLETE),
DBG_STRING(AP_PS_DBGID_DETECT_OUT_OF_SYNC_STA),
DBG_STRING(AP_PS_DBGID_DELIVER_CAB),
DBG_STRING(AP_PS_DBGID_NO_CLIENT),
DBG_STRING(AP_PS_DBGID_CLIENT_IN_PS_ACTIVE),
DBG_STRING(AP_PS_DBGID_CLIENT_IN_PS_NON_ACTIVE),
DBG_STRING(AP_PS_DBGID_CLIENT_IN_AWAKE),
DBG_STRING(AP_PS_DBGID_EGAP_SET_PARAM),
DBG_STRING(AP_PS_DBGID_EGAP_VDEV_START),
DBG_STRING(AP_PS_DBGID_EGAP_VDEV_STOP),
DBG_STRING(AP_PS_DBGID_EGAP_CONN_PEER),
DBG_STRING(AP_PS_DBGID_EGAP_DELETE_PEER),
DBG_STRING(AP_PS_DBGID_EGAP_WAL_PEER_EVENT),
DBG_STRING(AP_PS_DBGID_EGAP_WAL_PDEV_EVENT),
DBG_STRING(AP_PS_DBGID_EGAP_NOTIF_STA_SLEEPING),
DBG_STRING(AP_PS_DBGID_EGAP_PROC_STA_SLEEPING),
DBG_STRING(AP_PS_DBGID_EGAP_PROC_STA_INACTIVITY),
DBG_STRING(AP_PS_DBGID_EGAP_CHANGE_CHAINMASK),
DBG_STRING(AP_PS_DBGID_EGAP_CHANGE_SM_STATE),
},
{
"" /* Block Ack */
},
/* Mgmt TxRx */
{
DBG_STRING(MGMT_TXRX_DBGID_DEFINITION_START),
DBG_STRING(MGMT_TXRX_FORWARD_TO_HOST),
DBG_STRING(MGMT_TXRX_MGMT_FRAME_BUFFER_FULL),
DBG_STRING(MGMT_TXRX_VDEV_USED_TO_SEND_FRAME_IS_FREE),
DBG_STRING(MGMT_TXRX_LOCAL_FRAME_SEND_FAILED),
DBG_STRING(MGMT_TXRX_DBGID_DEFINITION_END),
},
{ /* Data TxRx */
DBG_STRING(DATA_TXRX_DBGID_DEFINITION_START),
DBG_STRING(DATA_TXRX_DBGID_RX_DATA_SEQ_LEN_INFO),
DBG_STRING(DATA_TXRX_DBGID_REPLAY_CHECK),
DBG_STRING(DATA_TXRX_DBGID_DUP_CHECK),
DBG_STRING(DATA_TXRX_INVALID_PEER_AST_STA),
DBG_STRING(DATA_TXRX_INVALID_PEER_AST_P2P),
DBG_STRING(DATA_TXRX_INVALID_ADDR1_STA),
DBG_STRING(DATA_TXRX_INVALID_ADDR1_P2P),
DBG_STRING(DATA_TXRX_MULTICAST_BROADCAST_FRAME),
DBG_STRING(DATA_TXRX_INVALID_FRAME_CTRL_OR_ADDR),
DBG_STRING(DATA_TXRX_DBGID_DEFINITION_END),
},
{ /* HTT */
DBG_STRING(HTT_DBGID_DEFINITION_START),
DBG_STRING(HTT_DBGID_INVALID_VDEVID_OR_GROUP),
DBG_STRING(HTT_DBGID_DISCARD_INTERNAL_PKTS),
DBG_STRING(HTT_DBGID_DISCARD_TX_PKTS),
DBG_STRING(HTT_DBGID_GROUP_CHANGE),
DBG_STRING(HTT_DBGID_GROUP_CREDIT_STATS),
DBG_STRING(HTT_DBGID_DISCARD_INTERNAL_PKTS_NUM),
DBG_STRING(HTT_DBGID_DEFINITION_END),
},
{ /* HOST */
},
{ /* BEACON */
DBG_STRING(BEACON_EVENT_SWBA_SEND_FAILED),
DBG_STRING(BEACON_EVENT_EARLY_RX_BMISS_STATUS),
DBG_STRING(BEACON_EVENT_EARLY_RX_SLEEP_SLOP),
DBG_STRING(BEACON_EVENT_EARLY_RX_CONT_BMISS_TIMEOUT),
DBG_STRING(BEACON_EVENT_EARLY_RX_PAUSE_SKIP_BCN_NUM),
DBG_STRING(BEACON_EVENT_EARLY_RX_CLK_DRIFT),
DBG_STRING(BEACON_EVENT_EARLY_RX_AP_DRIFT),
DBG_STRING(BEACON_EVENT_EARLY_RX_BCN_TYPE),
},
{ /* Offload Mgr */
DBG_STRING(OFFLOAD_MGR_DBGID_DEFINITION_START),
DBG_STRING(OFFLOADMGR_REGISTER_OFFLOAD),
DBG_STRING(OFFLOADMGR_DEREGISTER_OFFLOAD),
DBG_STRING(OFFLOADMGR_NO_REG_DATA_HANDLERS),
DBG_STRING(OFFLOADMGR_NO_REG_EVENT_HANDLERS),
DBG_STRING(OFFLOADMGR_REG_OFFLOAD_FAILED),
DBG_STRING(OFFLOADMGR_DEREG_OFFLOAD_FAILED),
DBG_STRING(OFFLOADMGR_ENTER_FAILED),
DBG_STRING(OFFLOADMGR_EXIT_FAILED),
DBG_STRING(OFFLOADMGR_GTK_FAILED),
DBG_STRING(OFFLOADMGR_GTK_REKEY_FAILED),
DBG_STRING(OFFLOADMGR_DBGID_DEFINITION_END),
},
{
DBG_STRING(WAL_DBGID_DEFINITION_START),
DBG_STRING(WAL_DBGID_FAST_WAKE_REQUEST),
DBG_STRING(WAL_DBGID_FAST_WAKE_RELEASE),
DBG_STRING(WAL_DBGID_SET_POWER_STATE),
DBG_STRING(WAL_DBGID_CHANNEL_CHANGE_FORCE_RESET),
DBG_STRING(WAL_DBGID_CHANNEL_CHANGE),
DBG_STRING(WAL_DBGID_VDEV_START),
DBG_STRING(WAL_DBGID_VDEV_STOP),
DBG_STRING(WAL_DBGID_VDEV_UP),
DBG_STRING(WAL_DBGID_VDEV_DOWN),
DBG_STRING(WAL_DBGID_SW_WDOG_RESET),
DBG_STRING(WAL_DBGID_TX_SCH_REGISTER_TIDQ),
DBG_STRING(WAL_DBGID_TX_SCH_UNREGISTER_TIDQ),
DBG_STRING(WAL_DBGID_TX_SCH_TICKLE_TIDQ),
DBG_STRING(WAL_DBGID_XCESS_FAILURES),
DBG_STRING(WAL_DBGID_AST_ADD_WDS_ENTRY),
DBG_STRING(WAL_DBGID_AST_DEL_WDS_ENTRY),
DBG_STRING(WAL_DBGID_AST_WDS_ENTRY_PEER_CHG),
DBG_STRING(WAL_DBGID_AST_WDS_SRC_LEARN_FAIL),
DBG_STRING(WAL_DBGID_STA_KICKOUT),
DBG_STRING(WAL_DBGID_BAR_TX_FAIL),
DBG_STRING(WAL_DBGID_BAR_ALLOC_FAIL),
DBG_STRING(WAL_DBGID_LOCAL_DATA_TX_FAIL),
DBG_STRING(WAL_DBGID_SECURITY_PM4_QUEUED),
DBG_STRING(WAL_DBGID_SECURITY_GM1_QUEUED),
DBG_STRING(WAL_DBGID_SECURITY_PM4_SENT),
DBG_STRING(WAL_DBGID_SECURITY_ALLOW_DATA),
DBG_STRING(WAL_DBGID_SECURITY_UCAST_KEY_SET),
DBG_STRING(WAL_DBGID_SECURITY_MCAST_KEY_SET),
DBG_STRING(WAL_DBGID_SECURITY_ENCR_EN),
DBG_STRING(WAL_DBGID_BB_WDOG_TRIGGERED),
DBG_STRING(WAL_DBGID_RX_LOCAL_BUFS_LWM),
DBG_STRING(WAL_DBGID_RX_LOCAL_DROP_LARGE_MGMT),
DBG_STRING(WAL_DBGID_VHT_ILLEGAL_RATE_PHY_ERR_DETECTED),
DBG_STRING(WAL_DBGID_DEV_RESET),
DBG_STRING(WAL_DBGID_TX_BA_SETUP),
DBG_STRING(WAL_DBGID_RX_BA_SETUP),
DBG_STRING(WAL_DBGID_DEV_TX_TIMEOUT),
DBG_STRING(WAL_DBGID_DEV_RX_TIMEOUT),
DBG_STRING(WAL_DBGID_STA_VDEV_XRETRY),
DBG_STRING(WAL_DBGID_DCS),
DBG_STRING(WAL_DBGID_MGMT_TX_FAIL),
DBG_STRING(WAL_DBGID_SET_M4_SENT_MANUALLY),
DBG_STRING(WAL_DBGID_PROCESS_4_WAY_HANDSHAKE),
DBG_STRING(WAL_DBGID_WAL_CHANNEL_CHANGE_START),
DBG_STRING(WAL_DBGID_WAL_CHANNEL_CHANGE_COMPLETE),
DBG_STRING(WAL_DBGID_WHAL_CHANNEL_CHANGE_START),
DBG_STRING(WAL_DBGID_WHAL_CHANNEL_CHANGE_COMPLETE),
DBG_STRING(WAL_DBGID_TX_MGMT_DESCID_SEQ_TYPE_LEN),
DBG_STRING(WAL_DBGID_TX_DATA_MSDUID_SEQ_TYPE_LEN),
DBG_STRING(WAL_DBGID_TX_DISCARD),
DBG_STRING(WAL_DBGID_TX_MGMT_COMP_DESCID_STATUS),
DBG_STRING(WAL_DBGID_TX_DATA_COMP_MSDUID_STATUS),
DBG_STRING(WAL_DBGID_RESET_PCU_CYCLE_CNT),
DBG_STRING(WAL_DBGID_SETUP_RSSI_INTERRUPTS),
DBG_STRING(WAL_DBGID_BRSSI_CONFIG),
DBG_STRING(WAL_DBGID_CURRENT_BRSSI_AVE),
DBG_STRING(WAL_DBGID_BCN_TX_COMP),
DBG_STRING(WAL_DBGID_SET_HW_CHAINMASK),
DBG_STRING(WAL_DBGID_SET_HW_CHAINMASK_TXRX_STOP_FAIL),
DBG_STRING(WAL_DBGID_GET_HW_CHAINMASK),
DBG_STRING(WAL_DBGID_SMPS_DISABLE),
DBG_STRING(WAL_DBGID_SMPS_ENABLE_HW_CNTRL),
DBG_STRING(WAL_DBGID_SMPS_SWSEL_CHAINMASK),
DBG_STRING(WAL_DBGID_SUSPEND),
DBG_STRING(WAL_DBGID_RESUME),
DBG_STRING(WAL_DBGID_PEER_TX_FAIL_CNT_THRES_EXCEEDED),
DBG_STRING(WAL_DBGID_RX_FULL_REORDER_SUPPORT),
DBG_STRING(WAL_DBGID_HCM_BIN),
DBG_STRING(WAL_DBGID_HCM_BIN_PENALIZE),
DBG_STRING(WAL_DBGID_HCM_BIN_DEPENALIZE),
DBG_STRING(WAL_DBGID_AST_UPDATE_WDS_ENTRY),
DBG_STRING(WAL_DBGID_PEER_EXT_STATS),
DBG_STRING(WAL_DBGID_TX_AC_BUFFER_SET),
DBG_STRING(WAL_DBGID_AST_ENTRY_EXIST),
DBG_STRING(WAL_DBGID_AST_ENTRY_FULL),
DBG_STRING(WAL_DBGID_WMMAC_TXQ_STATUS),
DBG_STRING(WAL_DBGID_PROLONGED_TX_PPDU_TOTAL_US),
DBG_STRING(WAL_DBGID_UPDATE_USED_TIME),
DBG_STRING(WAL_DBGID_PAST_WB_ACK_TIMESTAMP),
DBG_STRING(WAL_DBGID_WMMAC_ADD_DEL_TSPEC),
DBG_STRING(WAL_DBGID_WMMAC_TIMER_EXPIRY),
DBG_STRING(WAL_DBGID_WMMAC_PARAMS),
DBG_STRING(WAL_DBGID_TX_MGMT_WAL_PEER_DOES_NOT_EXIST),
DBG_STRING(WAL_DBGID_TX_MGMT_WAL_PEER_DELETE_IN_PROGRESS),
DBG_STRING(WAL_DBGID_TX_MGMT_FRAME_DESC_ALLOC_FAILED),
DBG_STRING(WAL_DBGID_TX_MGMT_TID_STRUCT_NOT_FOUND),
DBG_STRING(WAL_DBGID_TX_MGMT_ENQUEUE_FAILED),
DBG_STRING(WAL_DBGID_TX_ARP),
DBG_STRING(WAL_DBGID_TX_DHCP),
DBG_STRING(WAL_DBGID_DEFINITION_END),
},
{
"" /* DE */
},
{
"" /* pcie lp */
},
{
/* RTT */
DBG_STRING(RTT_CALL_FLOW),
DBG_STRING(RTT_REQ_SUB_TYPE),
DBG_STRING(RTT_MEAS_REQ_HEAD),
DBG_STRING(RTT_MEAS_REQ_BODY),
DBG_STRING(RTT_INIT_GLOBAL_STATE),
DBG_STRING(RTT_REPORT),
DBG_STRING(RTT_ERROR_REPORT),
DBG_STRING(RTT_TIMER_STOP),
DBG_STRING(RTT_SEND_TM_FRAME),
DBG_STRING(RTT_V3_RESP_CNT),
DBG_STRING(RTT_V3_RESP_FINISH),
DBG_STRING(RTT_CHANNEL_SWITCH_REQ),
DBG_STRING(RTT_CHANNEL_SWITCH_GRANT),
DBG_STRING(RTT_CHANNEL_SWITCH_COMPLETE),
DBG_STRING(RTT_CHANNEL_SWITCH_PREEMPT),
DBG_STRING(RTT_CHANNEL_SWITCH_STOP),
DBG_STRING(RTT_TIMER_START),
DBG_STRING(RTT_FTM_PARAM_INFO),
DBG_STRING(RTT_RX_TM_FRAME),
DBG_STRING(RTT_INITR_TSTAMP),
DBG_STRING(RTT_RSPDR_TSTAMP),
DBG_STRING(RTT_TX_COMP_STATUS),
DBG_STRING(RTT_ERROR_WMI_EVENT),
DBG_STRING(RTT_MEASUREMENT_VALUES),
},
{ /* RESOURCE */
DBG_STRING(RESOURCE_DBGID_DEFINITION_START),
DBG_STRING(RESOURCE_PEER_ALLOC),
DBG_STRING(RESOURCE_PEER_FREE),
DBG_STRING(RESOURCE_PEER_ALLOC_WAL_PEER),
DBG_STRING(RESOURCE_PEER_NBRHOOD_MGMT_ALLOC),
DBG_STRING(RESOURCE_PEER_NBRHOOD_MGMT_INFO),
DBG_STRING(RESOURCE_SMALL_MGMT_BUF_FULL),
DBG_STRING(RESOURCE_MGMT_AVAIL_BUF_CNT_NOT_ENOUGH),
DBG_STRING(RESOURCE_MGMT_BUF_FULL),
DBG_STRING(RESOURCE_MGMT_BUF_INC),
DBG_STRING(RESOURCE_MGMT_BUF_DEC),
DBG_STRING(RESOURCE_DBGID_DEFINITION_END),
},
{ /* DCS */
DBG_STRING(WLAN_DCS_DBGID_INIT),
DBG_STRING(WLAN_DCS_DBGID_WMI_CWINT),
DBG_STRING(WLAN_DCS_DBGID_TIMER),
DBG_STRING(WLAN_DCS_DBGID_CMDG),
DBG_STRING(WLAN_DCS_DBGID_CMDS),
DBG_STRING(WLAN_DCS_DBGID_DINIT)
},
{ /* CACHEMGR */
""
},
{ /* ANI */
DBG_STRING(ANI_DBGID_POLL),
DBG_STRING(ANI_DBGID_CONTROL),
DBG_STRING(ANI_DBGID_OFDM_PARAMS),
DBG_STRING(ANI_DBGID_CCK_PARAMS),
DBG_STRING(ANI_DBGID_RESET),
DBG_STRING(ANI_DBGID_RESTART),
DBG_STRING(ANI_DBGID_OFDM_LEVEL),
DBG_STRING(ANI_DBGID_CCK_LEVEL),
DBG_STRING(ANI_DBGID_FIRSTEP),
DBG_STRING(ANI_DBGID_CYCPWR),
DBG_STRING(ANI_DBGID_MRC_CCK),
DBG_STRING(ANI_DBGID_SELF_CORR_LOW),
DBG_STRING(ANI_DBGID_ENABLE),
DBG_STRING(ANI_DBGID_CURRENT_LEVEL),
DBG_STRING(ANI_DBGID_POLL_PERIOD),
DBG_STRING(ANI_DBGID_LISTEN_PERIOD),
DBG_STRING(ANI_DBGID_OFDM_LEVEL_CFG),
DBG_STRING(ANI_DBGID_CCK_LEVEL_CFG)
},
{
DBG_STRING(P2P_DBGID_DEFINITION_START),
DBG_STRING(P2P_DEV_REGISTER),
DBG_STRING(P2P_HANDLE_NOA),
DBG_STRING(P2P_UPDATE_SCHEDULE_OPPS),
DBG_STRING(P2P_UPDATE_SCHEDULE),
DBG_STRING(P2P_UPDATE_START_TIME),
DBG_STRING(P2P_UPDATE_START_TIME_DIFF_TSF32),
DBG_STRING(P2P_UPDATE_START_TIME_FINAL),
DBG_STRING(P2P_SETUP_SCHEDULE_TIMER),
DBG_STRING(P2P_PROCESS_SCHEDULE_AFTER_CALC),
DBG_STRING(P2P_PROCESS_SCHEDULE_STARTED_TIMER),
DBG_STRING(P2P_CALC_SCHEDULES_FIRST_CALL_ALL_NEXT_EVENT),
DBG_STRING(P2P_CALC_SCHEDULES_FIRST_VALUE),
DBG_STRING(P2P_CALC_SCHEDULES_EARLIEST_NEXT_EVENT),
DBG_STRING(P2P_CALC_SCHEDULES_SANITY_COUNT),
DBG_STRING(P2P_CALC_SCHEDULES_CALL_ALL_NEXT_EVENT_FROM_WHILE_LOOP),
DBG_STRING(P2P_CALC_SCHEDULES_TIMEOUT_1),
DBG_STRING(P2P_CALC_SCHEDULES_TIMEOUT_2),
DBG_STRING(P2P_FIND_ALL_NEXT_EVENTS_REQ_EXPIRED),
DBG_STRING(P2P_FIND_ALL_NEXT_EVENTS_REQ_ACTIVE),
DBG_STRING(P2P_FIND_NEXT_EVENT_REQ_NOT_STARTED),
DBG_STRING(P2P_FIND_NEXT_EVENT_REQ_COMPLETE_NON_PERIODIC),
DBG_STRING(P2P_FIND_NEXT_EVENT_IN_MID_OF_NOA),
DBG_STRING(P2P_FIND_NEXT_EVENT_REQ_COMPLETE),
DBG_STRING(P2P_SCHEDULE_TIMEOUT),
DBG_STRING(P2P_CALC_SCHEDULES_ENTER),
DBG_STRING(P2P_PROCESS_SCHEDULE_ENTER),
DBG_STRING(P2P_FIND_ALL_NEXT_EVENTS_INDIVIDUAL_REQ_AFTER_CHANGE),
DBG_STRING(P2P_FIND_ALL_NEXT_EVENTS_INDIVIDUAL_REQ_BEFORE_CHANGE),
DBG_STRING(P2P_FIND_ALL_NEXT_EVENTS_ENTER),
DBG_STRING(P2P_FIND_NEXT_EVENT_ENTER),
DBG_STRING(P2P_NOA_GO_PRESENT),
DBG_STRING(P2P_NOA_GO_ABSENT),
DBG_STRING(P2P_GO_NOA_NOTIF),
DBG_STRING(P2P_GO_TBTT_OFFSET),
DBG_STRING(P2P_GO_GET_NOA_INFO),
DBG_STRING(P2P_GO_ADD_ONE_SHOT_NOA),
DBG_STRING(P2P_GO_GET_NOA_IE),
DBG_STRING(P2P_GO_BCN_TX_COMP),
DBG_STRING(P2P_DBGID_DEFINITION_END),
},
{
DBG_STRING(CSA_DBGID_DEFINITION_START),
DBG_STRING(CSA_OFFLOAD_POOL_INIT),
DBG_STRING(CSA_OFFLOAD_REGISTER_VDEV),
DBG_STRING(CSA_OFFLOAD_DEREGISTER_VDEV),
DBG_STRING(CSA_DEREGISTER_VDEV_ERROR),
DBG_STRING(CSA_OFFLOAD_BEACON_RECEIVED),
DBG_STRING(CSA_OFFLOAD_BEACON_CSA_RECV),
DBG_STRING(CSA_OFFLOAD_CSA_RECV_ERROR_IE),
DBG_STRING(CSA_OFFLOAD_CSA_TIMER_ERROR),
DBG_STRING(CSA_OFFLOAD_CSA_TIMER_EXP),
DBG_STRING(CSA_OFFLOAD_WMI_EVENT_ERROR),
DBG_STRING(CSA_OFFLOAD_WMI_EVENT_SENT),
DBG_STRING(CSA_OFFLOAD_WMI_CHANSWITCH_RECV),
DBG_STRING(CSA_DBGID_DEFINITION_END),
},
{ /* NLO offload */
DBG_STRING(NLO_DBGID_SSID_TO_BE_SCANNED_LIST),
DBG_STRING(NLO_DBGID_SSID_TO_BE_SKIPPED_LIST),
},
{
DBG_STRING(WLAN_CHATTER_DBGID_DEFINITION_START),
DBG_STRING(WLAN_CHATTER_ENTER),
DBG_STRING(WLAN_CHATTER_EXIT),
DBG_STRING(WLAN_CHATTER_FILTER_HIT),
DBG_STRING(WLAN_CHATTER_FILTER_MISS),
DBG_STRING(WLAN_CHATTER_FILTER_FULL),
DBG_STRING(WLAN_CHATTER_FILTER_TM_ADJ),
DBG_STRING(WLAN_CHATTER_BUFFER_FULL),
DBG_STRING(WLAN_CHATTER_TIMEOUT),
DBG_STRING(WLAN_CHATTER_MC_FILTER_ADD),
DBG_STRING(WLAN_CHATTER_MC_FILTER_DEL),
DBG_STRING(WLAN_CHATTER_MC_FILTER_ALLOW),
DBG_STRING(WLAN_CHATTER_MC_FILTER_DROP),
DBG_STRING(WLAN_CHATTER_COALESCING_FILTER_ADD),
DBG_STRING(WLAN_CHATTER_COALESCING_FILTER_DEL),
DBG_STRING(WLAN_CHATTER_DBGID_DEFINITION_END),
},
{
DBG_STRING(WOW_DBGID_DEFINITION_START),
DBG_STRING(WOW_ENABLE_CMDID),
DBG_STRING(WOW_RECV_DATA_PKT),
DBG_STRING(WOW_WAKE_HOST_DATA),
DBG_STRING(WOW_RECV_MGMT),
DBG_STRING(WOW_WAKE_HOST_MGMT),
DBG_STRING(WOW_RECV_EVENT),
DBG_STRING(WOW_WAKE_HOST_EVENT),
DBG_STRING(WOW_INIT),
DBG_STRING(WOW_RECV_MAGIC_PKT),
DBG_STRING(WOW_RECV_BITMAP_PATTERN),
DBG_STRING(WOW_AP_VDEV_DISALLOW),
DBG_STRING(WOW_STA_VDEV_DISALLOW),
DBG_STRING(WOW_P2PGO_VDEV_DISALLOW),
DBG_STRING(WOW_NS_OFLD_ENABLE),
DBG_STRING(WOW_ARP_OFLD_ENABLE),
DBG_STRING(WOW_NS_ARP_OFLD_DISABLE),
DBG_STRING(WOW_NS_RECEIVED),
DBG_STRING(WOW_NS_REPLIED),
DBG_STRING(WOW_ARP_RECEIVED),
DBG_STRING(WOW_ARP_REPLIED),
DBG_STRING(WOW_BEACON_OFFLOAD_TX),
DBG_STRING(WOW_BEACON_OFFLOAD_CFG),
DBG_STRING(WOW_IBSS_VDEV_ALLOW),
DBG_STRING(WOW_DBGID_DEFINITION_END),
},
{ /* WAL VDEV */
""
},
{ /* WAL PDEV */
""
},
{ /* TEST */
""
},
{ /* STA SMPS */
DBG_STRING(STA_SMPS_DBGID_DEFINITION_START),
DBG_STRING(STA_SMPS_DBGID_CREATE_PDEV_INSTANCE),
DBG_STRING(STA_SMPS_DBGID_CREATE_VIRTUAL_CHAN_INSTANCE),
DBG_STRING(STA_SMPS_DBGID_DELETE_VIRTUAL_CHAN_INSTANCE),
DBG_STRING(STA_SMPS_DBGID_CREATE_STA_INSTANCE),
DBG_STRING(STA_SMPS_DBGID_DELETE_STA_INSTANCE),
DBG_STRING(STA_SMPS_DBGID_VIRTUAL_CHAN_SMPS_START),
DBG_STRING(STA_SMPS_DBGID_VIRTUAL_CHAN_SMPS_STOP),
DBG_STRING(STA_SMPS_DBGID_SEND_SMPS_ACTION_FRAME),
DBG_STRING(STA_SMPS_DBGID_HOST_FORCED_MODE),
DBG_STRING(STA_SMPS_DBGID_FW_FORCED_MODE),
DBG_STRING(STA_SMPS_DBGID_RSSI_THRESHOLD_CROSSED),
DBG_STRING(STA_SMPS_DBGID_SMPS_ACTION_FRAME_COMPLETION),
DBG_STRING(STA_SMPS_DBGID_DTIM_EBT_EVENT_CHMASK_UPDATE),
DBG_STRING(STA_SMPS_DBGID_DTIM_CHMASK_UPDATE),
DBG_STRING(STA_SMPS_DBGID_DTIM_BEACON_EVENT_CHMASK_UPDATE),
DBG_STRING(STA_SMPS_DBGID_DTIM_POWER_STATE_CHANGE),
DBG_STRING(STA_SMPS_DBGID_DTIM_CHMASK_UPDATE_SLEEP),
DBG_STRING(STA_SMPS_DBGID_DTIM_CHMASK_UPDATE_AWAKE),
},
{ /* SWBMISS */
DBG_STRING(SWBMISS_DBGID_DEFINITION_START),
DBG_STRING(SWBMISS_ENABLED),
DBG_STRING(SWBMISS_DISABLED),
DBG_STRING(SWBMISS_UPDATE_BEACON_RSSI),
DBG_STRING(SWBMISS_CHECK_RSSI_OUTLIER),
DBG_STRING(SWBMISS_TIMER_SET),
DBG_STRING(SWBMISS_DBGID_DEFINITION_END),
},
{ /* WMMAC */
""
},
{ /* TDLS */
DBG_STRING(TDLS_DBGID_DEFINITION_START),
DBG_STRING(TDLS_DBGID_VDEV_CREATE),
DBG_STRING(TDLS_DBGID_VDEV_DELETE),
DBG_STRING(TDLS_DBGID_ENABLED_PASSIVE),
DBG_STRING(TDLS_DBGID_ENABLED_ACTIVE),
DBG_STRING(TDLS_DBGID_DISABLED),
DBG_STRING(TDLS_DBGID_CONNTRACK_TIMER),
DBG_STRING(TDLS_DBGID_WAL_SET),
DBG_STRING(TDLS_DBGID_WAL_GET),
DBG_STRING(TDLS_DBGID_WAL_PEER_UPDATE_SET),
DBG_STRING(TDLS_DBGID_WAL_PEER_UPDATE_EVT),
DBG_STRING(TDLS_DBGID_WAL_VDEV_CREATE),
DBG_STRING(TDLS_DBGID_WAL_VDEV_DELETE),
DBG_STRING(TDLS_DBGID_WLAN_EVENT),
DBG_STRING(TDLS_DBGID_WLAN_PEER_UPDATE_SET),
DBG_STRING(TDLS_DBGID_PEER_EVT_DRP_THRESH),
DBG_STRING(TDLS_DBGID_PEER_EVT_DRP_RATE),
DBG_STRING(TDLS_DBGID_PEER_EVT_DRP_RSSI),
DBG_STRING(TDLS_DBGID_PEER_EVT_DISCOVER),
DBG_STRING(TDLS_DBGID_PEER_EVT_DELETE),
DBG_STRING(TDLS_DBGID_PEER_CAP_UPDATE),
DBG_STRING(TDLS_DBGID_UAPSD_SEND_PTI_FRAME),
DBG_STRING(TDLS_DBGID_UAPSD_SEND_PTI_FRAME2PEER),
DBG_STRING(TDLS_DBGID_UAPSD_START_PTR_TIMER),
DBG_STRING(TDLS_DBGID_UAPSD_CANCEL_PTR_TIMER),
DBG_STRING(TDLS_DBGID_UAPSD_PTR_TIMER_TIMEOUT),
DBG_STRING(TDLS_DBGID_UAPSD_STA_PS_EVENT_HANDLER),
DBG_STRING(TDLS_DBGID_UAPSD_PEER_EVENT_HANDLER),
DBG_STRING(TDLS_DBGID_UAPSD_PS_DEFAULT_SETTINGS),
DBG_STRING(TDLS_DBGID_UAPSD_GENERIC),
},
{ /* HB */
DBG_STRING(WLAN_HB_DBGID_DEFINITION_START),
DBG_STRING(WLAN_HB_DBGID_INIT),
DBG_STRING(WLAN_HB_DBGID_TCP_GET_TXBUF_FAIL),
DBG_STRING(WLAN_HB_DBGID_TCP_SEND_FAIL),
DBG_STRING(WLAN_HB_DBGID_BSS_PEER_NULL),
DBG_STRING(WLAN_HB_DBGID_UDP_GET_TXBUF_FAIL),
DBG_STRING(WLAN_HB_DBGID_UDP_SEND_FAIL),
DBG_STRING(WLAN_HB_DBGID_WMI_CMD_INVALID_PARAM),
DBG_STRING(WLAN_HB_DBGID_WMI_CMD_INVALID_OP),
DBG_STRING(WLAN_HB_DBGID_WOW_NOT_ENTERED),
DBG_STRING(WLAN_HB_DBGID_ALLOC_SESS_FAIL),
DBG_STRING(WLAN_HB_DBGID_CTX_NULL),
DBG_STRING(WLAN_HB_DBGID_CHKSUM_ERR),
DBG_STRING(WLAN_HB_DBGID_UDP_TX),
DBG_STRING(WLAN_HB_DBGID_TCP_TX),
DBG_STRING(WLAN_HB_DBGID_DEFINITION_END),
},
{ /* TXBF */
DBG_STRING(TXBFEE_DBGID_START),
DBG_STRING(TXBFEE_DBGID_NDPA_RECEIVED),
DBG_STRING(TXBFEE_DBGID_HOST_CONFIG_TXBFEE_TYPE),
DBG_STRING(TXBFER_DBGID_SEND_NDPA),
DBG_STRING(TXBFER_DBGID_GET_NDPA_BUF_FAIL),
DBG_STRING(TXBFER_DBGID_SEND_NDPA_FAIL),
DBG_STRING(TXBFER_DBGID_GET_NDP_BUF_FAIL),
DBG_STRING(TXBFER_DBGID_SEND_NDP_FAIL),
DBG_STRING(TXBFER_DBGID_GET_BRPOLL_BUF_FAIL),
DBG_STRING(TXBFER_DBGID_SEND_BRPOLL_FAIL),
DBG_STRING(TXBFER_DBGID_HOST_CONFIG_CMDID),
DBG_STRING(TXBFEE_DBGID_HOST_CONFIG_CMDID),
DBG_STRING(TXBFEE_DBGID_ENABLE_UPLOAD_H),
DBG_STRING(TXBFEE_DBGID_UPLOADH_CV_TAG),
DBG_STRING(TXBFEE_DBGID_UPLOADH_H_TAG),
DBG_STRING(TXBFEE_DBGID_CAPTUREH_RECEIVED),
DBG_STRING(TXBFEE_DBGID_PACKET_IS_STEERED),
DBG_STRING(TXBFEE_UPLOADH_EVENT_ALLOC_MEM_FAIL),
DBG_STRING(TXBFEE_DBGID_SW_WAR_AID_ZERO),
DBG_STRING(TXBFEE_DBGID_BRPOLL_RECEIVED),
DBG_STRING(TXBFEE_DBGID_GID_RECEIVED),
DBG_STRING(TXBFEE_DBGID_END),
},
{ /*BATCH SCAN*/
},
{ /*THERMAL MGR*/
DBG_STRING(THERMAL_MGR_DBGID_DEFINITION_START),
DBG_STRING(THERMAL_MGR_NEW_THRESH),
DBG_STRING(THERMAL_MGR_THRESH_CROSSED),
DBG_STRING(THERMAL_MGR_DBGID_DEFINITION_END),
},
{ /* WLAN_MODULE_PHYERR_DFS */
DBG_STRING(WLAN_PHYERR_DFS_DBGID_DEFINITION_START),
DBG_STRING(WLAN_PHYERR_DFS_PHYERR_INFO_CHAN_BUFLEN),
DBG_STRING(WLAN_PHYERR_DFS_PHYERR_INFO_PPDU),
DBG_STRING(WLAN_PHYERR_DFS_DBDID_RADAR_SUMMARY),
DBG_STRING(WLAN_PHYERR_DFS_DBDID_SEARCH_FFT),
DBG_STRING(WLAN_PHTERR_DFS_DBDID_FILTER_STATUS),
DBG_STRING(WLAN_PHYERR_DFS_DBGID_DEFINITION_END),
},
{
/* WLAN_MODULE_RMC */
DBG_STRING(RMC_DBGID_DEFINITION_START),
DBG_STRING(RMC_SM_INIT_ERR),
DBG_STRING(RMC_VDEV_ALLOC_ERR),
DBG_STRING(RMC_CREATE_INSTANCE),
DBG_STRING(RMC_DELETE_INSTANCE),
DBG_STRING(RMC_NEW_PRI_LEADER),
DBG_STRING(RMC_NEW_SEC_LEADER),
DBG_STRING(RMC_NO_LDR_CHANGE),
DBG_STRING(RMC_LDR_INFORM_SENT),
DBG_STRING(RMC_PEER_ADD),
DBG_STRING(RMC_PEER_DELETE),
DBG_STRING(RMC_PEER_UNKNOWN),
DBG_STRING(RMC_PRI_LDR_RSSI_UPDATE),
DBG_STRING(RMC_SEC_LDR_RSSI_UPDATE),
DBG_STRING(RMC_SET_MODE),
DBG_STRING(RMC_SET_ACTION_PERIOD),
DBG_STRING(RMC_DBGID_DEFINITION_END),
},
{
/* WLAN_MODULE_STATS */
DBG_STRING(WLAN_STATS_DBGID_DEFINITION_START),
DBG_STRING(WLAN_STATS_DBGID_EST_LINKSPEED_VDEV_EN_DIS),
DBG_STRING(WLAN_STATS_DBGID_EST_LINKSPEED_CHAN_TIME_START),
DBG_STRING(WLAN_STATS_DBGID_EST_LINKSPEED_CHAN_TIME_END),
DBG_STRING(WLAN_STATS_DBGID_EST_LINKSPEED_CALC),
DBG_STRING(WLAN_STATS_DBGID_EST_LINKSPEED_UPDATE_HOME_CHAN),
DBG_STRING(WLAN_STATS_DBGID_RSSI),
DBG_STRING(WLAN_STATS_DBGID_CNE_RSSI),
DBG_STRING(WLAN_STATS_DBGID_DEFINITION_END),
},
{
/* WLAN_MODULE_NAN */
DBG_STRING(NAN_DBGID_START),
DBG_STRING(NAN_DBGID_FUNC_BEGIN),
DBG_STRING(NAN_DBGID_FUNC_END),
DBG_STRING(NAN_DBGID_MAIN_DEBUG),
DBG_STRING(NAN_DBGID_MAC_DEBUG),
DBG_STRING(NAN_DBGID_BLOOM_FILTER_DEBUG),
DBG_STRING(NAN_DBGID_MAC_ADDR),
DBG_STRING(NAN_DBGID_PARAM_UPDATED),
DBG_STRING(NAN_DBGID_NULL_PTR),
DBG_STRING(NAN_DBGID_INVALID_FUNC_ARG),
DBG_STRING(NAN_DBGID_INVALID_MSG_PARAM),
DBG_STRING(NAN_DBGID_MISSING_MSG_PARAM),
DBG_STRING(NAN_DBGID_DEPRECATED_MSG_PARAM),
DBG_STRING(NAN_DBGID_UNSUPPORTED_MSG_PARAM),
DBG_STRING(NAN_DBGID_INVALID_PKT_DATA),
DBG_STRING(NAN_DBGID_LOG_PKT_DATA),
DBG_STRING(NAN_DBGID_INVALID_VALUE),
DBG_STRING(NAN_DBGID_INVALID_OPERATION),
DBG_STRING(NAN_DBGID_INVALID_STATE),
DBG_STRING(NAN_DBGID_FUNCTION_ENABLED),
DBG_STRING(NAN_DBGID_FUNCTION_DISABLED),
DBG_STRING(NAN_DBGID_INVALID_FUNCTION_STATE),
DBG_STRING(NAN_DBGID_READ_ERROR),
DBG_STRING(NAN_DBGID_WRITE_ERROR),
DBG_STRING(NAN_DBGID_RECEIVE_ERROR),
DBG_STRING(NAN_DBGID_TRANSMIT_ERROR),
DBG_STRING(NAN_DBGID_PARSE_ERROR),
DBG_STRING(NAN_DBGID_RES_ALLOC_ERROR),
DBG_STRING(NAN_DBGID_DBG_LOG_LAST),
},
{
/* WLAN_MODULE_IBSS_PWRSAVE */
DBG_STRING(IBSS_PS_DBGID_DEFINITION_START),
DBG_STRING(IBSS_PS_DBGID_PEER_CREATE),
DBG_STRING(IBSS_PS_DBGID_PEER_DELETE),
DBG_STRING(IBSS_PS_DBGID_VDEV_CREATE),
DBG_STRING(IBSS_PS_DBGID_VDEV_DELETE),
DBG_STRING(IBSS_PS_DBGID_VDEV_EVENT),
DBG_STRING(IBSS_PS_DBGID_PEER_EVENT),
DBG_STRING(IBSS_PS_DBGID_DELIVER_CAB),
DBG_STRING(IBSS_PS_DBGID_DELIVER_UC_DATA),
DBG_STRING(IBSS_PS_DBGID_DELIVER_UC_DATA_ERROR),
DBG_STRING(IBSS_PS_DBGID_UC_INACTIVITY_TMR_RESTART),
DBG_STRING(IBSS_PS_DBGID_MC_INACTIVITY_TMR_RESTART),
DBG_STRING(IBSS_PS_DBGID_NULL_TX_COMPLETION),
DBG_STRING(IBSS_PS_DBGID_ATIM_TIMER_START),
DBG_STRING(IBSS_PS_DBGID_UC_ATIM_SEND),
DBG_STRING(IBSS_PS_DBGID_BC_ATIM_SEND),
DBG_STRING(IBSS_PS_DBGID_UC_TIMEOUT),
DBG_STRING(IBSS_PS_DBGID_PWR_COLLAPSE_ALLOWED),
DBG_STRING(IBSS_PS_DBGID_PWR_COLLAPSE_NOT_ALLOWED),
DBG_STRING(IBSS_PS_DBGID_SET_PARAM),
DBG_STRING(IBSS_PS_DBGID_HOST_TX_PAUSE),
DBG_STRING(IBSS_PS_DBGID_HOST_TX_UNPAUSE),
DBG_STRING(IBSS_PS_DBGID_PS_DESC_BIN_HWM),
DBG_STRING(IBSS_PS_DBGID_PS_DESC_BIN_LWM),
DBG_STRING(IBSS_PS_DBGID_PS_KICKOUT_PEER),
DBG_STRING(IBSS_PS_DBGID_SET_PEER_PARAM),
DBG_STRING(IBSS_PS_DBGID_BCN_ATIM_WIN_MISMATCH),
DBG_STRING(IBSS_PS_DBGID_RX_CHAINMASK_CHANGE),
},
{
/* HIF UART Interface DBGIDs */
DBG_STRING(HIF_UART_DBGID_START),
DBG_STRING(HIF_UART_DBGID_POWER_STATE),
DBG_STRING(HIF_UART_DBGID_TXRX_FLOW),
DBG_STRING(HIF_UART_DBGID_TXRX_CTRL_CHAR),
DBG_STRING(HIF_UART_DBGID_TXRX_BUF_DUMP),
},
{
/* LPI */
""
},
{
/* EXTSCAN DBGIDs */
DBG_STRING(EXTSCAN_START),
DBG_STRING(EXTSCAN_STOP),
DBG_STRING(EXTSCAN_CLEAR_ENTRY_CONTENT),
DBG_STRING(EXTSCAN_GET_FREE_ENTRY_SUCCESS),
DBG_STRING(EXTSCAN_GET_FREE_ENTRY_INCONSISTENT),
DBG_STRING(EXTSCAN_GET_FREE_ENTRY_NO_MORE_ENTRIES),
DBG_STRING(EXTSCAN_CREATE_ENTRY_SUCCESS),
DBG_STRING(EXTSCAN_CREATE_ENTRY_ERROR),
DBG_STRING(EXTSCAN_SEARCH_SCAN_ENTRY_QUEUE),
DBG_STRING(EXTSCAN_SEARCH_SCAN_ENTRY_KEY_FOUND),
DBG_STRING(EXTSCAN_SEARCH_SCAN_ENTRY_KEY_NOT_FOUND),
DBG_STRING(EXTSCAN_ADD_ENTRY),
DBG_STRING(EXTSCAN_BUCKET_SEND_OPERATION_EVENT),
DBG_STRING(EXTSCAN_BUCKET_SEND_OPERATION_EVENT_FAILED),
DBG_STRING(EXTSCAN_BUCKET_START_SCAN_CYCLE),
DBG_STRING(EXTSCAN_BUCKET_PERIODIC_TIMER),
DBG_STRING(EXTSCAN_SEND_START_STOP_EVENT),
DBG_STRING(EXTSCAN_NOTIFY_WLAN_CHANGE),
DBG_STRING(EXTSCAN_NOTIFY_WLAN_HOTLIST_MATCH),
DBG_STRING(EXTSCAN_MAIN_RECEIVED_FRAME),
DBG_STRING(EXTSCAN_MAIN_NO_SSID_IE),
DBG_STRING(EXTSCAN_MAIN_MALFORMED_FRAME),
DBG_STRING(EXTSCAN_FIND_BSSID_BY_REFERENCE),
DBG_STRING(EXTSCAN_FIND_BSSID_BY_REFERENCE_ERROR),
DBG_STRING(EXTSCAN_NOTIFY_TABLE_USAGE),
DBG_STRING(EXTSCAN_FOUND_RSSI_ENTRY),
DBG_STRING(EXTSCAN_BSSID_FOUND_RSSI_SAMPLE),
DBG_STRING(EXTSCAN_BSSID_ADDED_RSSI_SAMPLE),
DBG_STRING(EXTSCAN_BSSID_REPLACED_RSSI_SAMPLE),
DBG_STRING(EXTSCAN_BSSID_TRANSFER_CURRENT_SAMPLES),
DBG_STRING(EXTSCAN_BUCKET_PROCESS_SCAN_EVENT),
DBG_STRING(EXTSCAN_BUCKET_CANNOT_FIND_BUCKET),
DBG_STRING(EXTSCAN_START_SCAN_REQUEST_FAILED),
DBG_STRING(EXTSCAN_BUCKET_STOP_CURRENT_SCANS),
DBG_STRING(EXTSCAN_BUCKET_SCAN_STOP_REQUEST),
DBG_STRING(EXTSCAN_BUCKET_PERIODIC_TIMER_ERROR),
DBG_STRING(EXTSCAN_BUCKET_START_OPERATION),
DBG_STRING(EXTSCAN_START_INTERNAL_ERROR),
DBG_STRING(EXTSCAN_NOTIFY_HOTLIST_MATCH),
DBG_STRING(EXTSCAN_CONFIG_HOTLIST_TABLE),
DBG_STRING(EXTSCAN_CONFIG_WLAN_CHANGE_TABLE),
DBG_STRING(EXTSCAN_EVENT_SEND_FAILED),
},
{ /* UNIT_TEST */
DBG_STRING(UNIT_TEST_GEN),
},
{ /* MLME */
DBG_STRING(MLME_DEBUG_CMN),
DBG_STRING(MLME_DEBUG_IF),
DBG_STRING(MLME_DEBUG_AUTH),
DBG_STRING(MLME_DEBUG_REASSOC),
DBG_STRING(MLME_DEBUG_DEAUTH),
DBG_STRING(MLME_DEBUG_DISASSOC),
DBG_STRING(MLME_DEBUG_ROAM),
DBG_STRING(MLME_DEBUG_RETRY),
DBG_STRING(MLME_DEBUG_TIMER),
DBG_STRING(MLME_DEBUG_FRAMEPARSE),
},
{ /*SUPPLICANT */
DBG_STRING(SUPPL_DBGID_INIT),
DBG_STRING(SUPPL_DBGID_RECV_EAPOL),
DBG_STRING(SUPPL_DBGID_RECV_EAPOL_TIMEOUT),
DBG_STRING(SUPPL_DBGID_SEND_EAPOL),
DBG_STRING(SUPPL_DBGID_MIC_MISMATCH),
DBG_STRING(SUPPL_DBGID_FINISH),
DBG_STRING(SUPPL_DBGID_GET_FRM_INFO),
DBG_STRING(SUPPL_DBGID_DUMP_TYPE),
DBG_STRING(SUPPL_DBGID_DUMP_HEX),
DBG_STRING(SUPPL_DBGID_NODE_NOT_FOUND),
DBG_STRING(SUPPL_DBGID_GET_EAPOL_BUF),
DBG_STRING(SUPPL_DBGID_GET_BUF_FAIL),
DBG_STRING(SUPPL_DBGID_RECV_EAPOL_ERROR),
},
{
/* ERE */
""
},
{
DBG_STRING(OCB_DBGID_VDEV_CREATE),
DBG_STRING(OCB_DBGID_VDEV_DELETE),
DBG_STRING(OCB_DBGID_CHAN_PAUSE),
DBG_STRING(OCB_DBGID_CHAN_UNPAUSE),
DBG_STRING(OCB_DBGID_PEER_CREATE),
DBG_STRING(OCB_DBGID_PEER_DELETE),
DBG_STRING(OCB_DBGID_DCC_START),
DBG_STRING(OCB_DBGID_DCC_STOP),
DBG_STRING(OCB_DBGID_SET_CONFIG_CMD),
DBG_STRING(OCB_DBGID_SET_UTC_TIME_CMD),
DBG_STRING(OCB_DBGID_START_TIMING_ADVERT_CMD),
DBG_STRING(OCB_DBGID_STOP_TIMING_ADVERT_CMD),
DBG_STRING(OCB_DBGID_GET_TSF_TIMER_CMD),
DBG_STRING(OCB_DBGID_GET_DCC_STATS_CMD),
DBG_STRING(OCB_DBGID_UPDATE_DCC_NDL_CMD),
DBG_STRING(OCB_DBGID_SET_CONFIG_RESP_EVENT),
DBG_STRING(OCB_DBGID_GET_TSF_TIMER_RESP_EVENT),
DBG_STRING(OCB_DBGID_GET_DCC_STATS_RESP_EVENT),
DBG_STRING(OCB_DBGID_DCC_STATS_EVENT),
DBG_STRING(OCB_UPDATE_DCC_NDL_RESP_EVENT),
DBG_STRING(OCB_DBGID_GENERIC),
DBG_STRING(OCB_DBGID_VDEV_START),
DBG_STRING(OCB_DBGID_CHANNEL_SCHED_EVENT),
DBG_STRING(OCB_DBGID_GPS_EVENT_START),
DBG_STRING(OCB_DBGID_GPS_EVENT_END),
DBG_STRING(OCB_DBGID_TX_TA_FRAME),
DBG_STRING(OCB_DBGID_RX_TA_FRAME),
},
{
DBG_STRING(RSSI_MONITOR_DBGID_DEFINITION_START),
DBG_STRING(RSSI_MONITOR_VDEV_INIT),
DBG_STRING(RSSI_MONITOR_VDEV_FREE),
DBG_STRING(RSSI_MONITOR_VDEV_EVENT),
DBG_STRING(RSSI_MONITOR_HW_EVENT),
DBG_STRING(RSSI_MONITOR_ENABLE_THRESHOLDS_CLIENT_REQ),
DBG_STRING(RSSI_MONITOR_ENABLE_THRESHOLDS_CLIENT_REQ_ERR),
DBG_STRING(RSSI_MONITOR_DISABLE_THRESHOLDS_CLIENT_REQ),
DBG_STRING(RSSI_MONITOR_DISABLE_THRESHOLDS_CLIENT_REQ_ERR),
DBG_STRING(RSSI_MONITOR_ARBITER),
DBG_STRING(RSSI_MONITOR_ARBITER_CONFIG_HW),
DBG_STRING(RSSI_MONITOR_CHECK_AND_DELIVER_EVENT),
DBG_STRING(RSSI_MONITOR_DELIVER_EVENT),
DBG_STRING(RSSI_MONITOR_UPDATE_BEACON_RSSI),
DBG_STRING(RSSI_MONITOR_DBGID_DEFINITION_END),
},
{
/* WPM */
""
},
{
/* CSS */
""
},
{
/* PPS */
""
},
{
/* SCAN_CH_PREDICT */
""
},
{
/* MAWCE */
""
},
{
/* CMC_QMIC */
""
},
{
/* EGAP */
""
},
{
/* NAN20 */
""
},
{
DBG_STRING(WLAN_MODULE_QBOOST_DEFINITION_START),
DBG_STRING(WLAN_MODULE_QBOOST_DBGID_WLAN_PEER_NOT_FOUND),
DBG_STRING(WLAN_MODULE_QBOOST_DEFINITION_END),
},
};
int dbglog_module_log_enable(wmi_unified_t wmi_handle, A_UINT32 mod_id,
bool isenable)
{
A_UINT32 val = 0;
if (mod_id > WLAN_MODULE_ID_MAX) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("dbglog_module_log_enable: Invalid module id %d\n",
mod_id));
return -EINVAL;
}
WMI_DBGLOG_SET_MODULE_ID(val,mod_id);
if (isenable) {
/* set it to global module level */
WMI_DBGLOG_SET_LOG_LEVEL(val,DBGLOG_INFO);
} else {
/* set it to ERROR level */
WMI_DBGLOG_SET_LOG_LEVEL(val,DBGLOG_ERR);
}
wmi_config_debug_module_cmd(wmi_handle, WMI_DEBUG_LOG_PARAM_LOG_LEVEL, val, NULL,0);
return 0;
}
int dbglog_vap_log_enable(wmi_unified_t wmi_handle, A_UINT16 vap_id,
bool isenable)
{
if (vap_id > DBGLOG_MAX_VDEVID) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("dbglog_vap_log_enable:Invalid vap_id %d\n",
vap_id));
return -EINVAL;
}
wmi_config_debug_module_cmd(wmi_handle,
isenable ? WMI_DEBUG_LOG_PARAM_VDEV_ENABLE:WMI_DEBUG_LOG_PARAM_VDEV_DISABLE, vap_id, NULL,0 );
return 0;
}
int dbglog_set_log_lvl(wmi_unified_t wmi_handle, DBGLOG_LOG_LVL log_lvl)
{
A_UINT32 val = 0;
if (log_lvl > DBGLOG_LVL_MAX) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("dbglog_set_log_lvl:Invalid log level %d\n",
log_lvl));
return -EINVAL;
}
WMI_DBGLOG_SET_MODULE_ID(val,WMI_DEBUG_LOG_MODULE_ALL);
WMI_DBGLOG_SET_LOG_LEVEL(val,log_lvl);
wmi_config_debug_module_cmd(wmi_handle, WMI_DEBUG_LOG_PARAM_LOG_LEVEL, val, NULL,0);
return 0;
}
int dbglog_set_mod_log_lvl(wmi_unified_t wmi_handle, A_UINT32 mod_log_lvl)
{
A_UINT32 val = 0;
/* set the global module level to log_lvl */
WMI_DBGLOG_SET_MODULE_ID(val,(mod_log_lvl/10));
WMI_DBGLOG_SET_LOG_LEVEL(val,(mod_log_lvl%10));
wmi_config_debug_module_cmd(wmi_handle, WMI_DEBUG_LOG_PARAM_LOG_LEVEL, val, NULL,0);
return 0;
}
A_STATUS
wmi_config_debug_module_cmd(wmi_unified_t wmi_handle, A_UINT32 param, A_UINT32 val,
A_UINT32 *module_id_bitmap, A_UINT32 bitmap_len)
{
wmi_buf_t buf;
wmi_debug_log_config_cmd_fixed_param *configmsg;
A_STATUS status = A_OK;
int i;
int len;
int8_t *buf_ptr;
int32_t *module_id_bitmap_array; /* Used to fomr the second tlv*/
ASSERT(bitmap_len < MAX_MODULE_ID_BITMAP_WORDS);
/* Allocate size for 2 tlvs - including tlv hdr space for second tlv*/
len = sizeof(wmi_debug_log_config_cmd_fixed_param) + WMI_TLV_HDR_SIZE +
(sizeof(int32_t) * MAX_MODULE_ID_BITMAP_WORDS);
buf = wmi_buf_alloc(wmi_handle, len);
if (buf == NULL)
return A_NO_MEMORY;
configmsg = (wmi_debug_log_config_cmd_fixed_param *)(wmi_buf_data(buf));
buf_ptr = (int8_t *)configmsg;
WMITLV_SET_HDR(&configmsg->tlv_header,
WMITLV_TAG_STRUC_wmi_debug_log_config_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(wmi_debug_log_config_cmd_fixed_param));
configmsg->dbg_log_param = param;
configmsg->value = val;
/* Filling in the data part of second tlv -- should follow first tlv _ WMI_TLV_HDR_SIZE*/
module_id_bitmap_array = (A_UINT32*)(buf_ptr +
sizeof(wmi_debug_log_config_cmd_fixed_param) +
WMI_TLV_HDR_SIZE);
WMITLV_SET_HDR(buf_ptr + sizeof(wmi_debug_log_config_cmd_fixed_param),
WMITLV_TAG_ARRAY_UINT32,
sizeof(A_UINT32) * MAX_MODULE_ID_BITMAP_WORDS);
if (module_id_bitmap) {
for(i=0;i<bitmap_len;++i) {
module_id_bitmap_array[i] = module_id_bitmap[i];
}
}
AR_DEBUG_PRINTF(ATH_DEBUG_RSVD1,
("wmi_dbg_cfg_send: param 0x%x val 0x%x \n",
param, val));
status = wmi_unified_cmd_send(wmi_handle, buf,
len, WMI_DBGLOG_CFG_CMDID);
if (status != A_OK)
adf_nbuf_free(buf);
return status;
}
void
dbglog_set_vap_enable_bitmap(wmi_unified_t wmi_handle, A_UINT32 vap_enable_bitmap)
{
wmi_config_debug_module_cmd(wmi_handle,
WMI_DEBUG_LOG_PARAM_VDEV_ENABLE_BITMAP,
vap_enable_bitmap, NULL,0 );
}
void
dbglog_set_mod_enable_bitmap(wmi_unified_t wmi_handle,A_UINT32 log_level, A_UINT32 *mod_enable_bitmap, A_UINT32 bitmap_len )
{
wmi_config_debug_module_cmd(wmi_handle,
WMI_DEBUG_LOG_PARAM_MOD_ENABLE_BITMAP,
log_level,
mod_enable_bitmap,bitmap_len);
}
int dbglog_report_enable(wmi_unified_t wmi_handle, bool isenable)
{
int bitmap[2] = {0};
if(isenable){
/* set the vap enable bitmap */
dbglog_set_vap_enable_bitmap(wmi_handle, 0xFFFF);
bitmap[0] = 0xFFFFFFFF;
bitmap[1] = 0x1F;
/* set the module level bitmap */
dbglog_set_mod_enable_bitmap(wmi_handle, 0x0, bitmap, 2);
} else {
dbglog_set_vap_enable_bitmap(wmi_handle, bitmap[0]);
dbglog_set_mod_enable_bitmap(wmi_handle, DBGLOG_LVL_MAX, bitmap, 2);
}
return 0;
}
static char *
dbglog_get_msg(A_UINT32 moduleid, A_UINT32 debugid)
{
static char unknown_str[64];
if (moduleid < WLAN_MODULE_ID_MAX && debugid < MAX_DBG_MSGS) {
char *str = DBG_MSG_ARR[moduleid][debugid];
if (str && str[0] != '\0') {
return str;
}
}
snprintf(unknown_str, sizeof(unknown_str),
"UNKNOWN %u:%u",
moduleid, debugid);
return unknown_str;
}
void
dbglog_printf(
A_UINT32 timestamp,
A_UINT16 vap_id,
const char *fmt, ...)
{
char buf[128];
va_list ap;
if (vap_id < DBGLOG_MAX_VDEVID) {
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (DBGLOG_PRINT_PREFIX "[%u] vap-%u ", timestamp, vap_id));
} else {
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (DBGLOG_PRINT_PREFIX "[%u] ", timestamp));
}
va_start(ap, fmt);
vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("%s\n", buf));
}
void
dbglog_printf_no_line_break(
A_UINT32 timestamp,
A_UINT16 vap_id,
const char *fmt, ...)
{
char buf[128];
va_list ap;
if (vap_id < DBGLOG_MAX_VDEVID) {
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (DBGLOG_PRINT_PREFIX "[%u] vap-%u ", timestamp, vap_id));
} else {
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (DBGLOG_PRINT_PREFIX "[%u] ", timestamp));
}
va_start(ap, fmt);
vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("%s", buf));
}
#define USE_NUMERIC 0
A_BOOL
dbglog_default_print_handler(A_UINT32 mod_id, A_UINT16 vap_id, A_UINT32 dbg_id,
A_UINT32 timestamp, A_UINT16 numargs, A_UINT32 *args)
{
int i;
if (vap_id < DBGLOG_MAX_VDEVID) {
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (DBGLOG_PRINT_PREFIX "[%u] vap-%u %s ( ", timestamp, vap_id, dbglog_get_msg(mod_id, dbg_id)));
} else {
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (DBGLOG_PRINT_PREFIX "[%u] %s ( ", timestamp, dbglog_get_msg(mod_id, dbg_id)));
}
for (i = 0; i < numargs; i++) {
#if USE_NUMERIC
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("%u", args[i]));
#else
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("%#x", args[i]));
#endif
if ((i + 1) < numargs) {
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (", "));
}
}
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (" )\n"));
return TRUE;
}
#define DBGLOG_PARSE_ARGS_STRING_LENGTH (DBGLOG_NUM_ARGS_MAX * 11 + 10)
static int
dbglog_print_raw_data(A_UINT32 *buffer, A_UINT32 length)
{
A_UINT32 timestamp;
A_UINT32 debugid;
A_UINT32 moduleid;
A_UINT16 numargs, curArgs;
A_UINT32 count = 0, totalWriteLen, writeLen;
char parseArgsString[DBGLOG_PARSE_ARGS_STRING_LENGTH];
char *dbgidString;
while (count < length) {
debugid = DBGLOG_GET_DBGID(buffer[count + 1]);
moduleid = DBGLOG_GET_MODULEID(buffer[count + 1]);
numargs = DBGLOG_GET_NUMARGS(buffer[count + 1]);
timestamp = DBGLOG_GET_TIME_STAMP(buffer[count]);
if (moduleid < WLAN_MODULE_ID_MAX && debugid < MAX_DBG_MSGS && numargs <= DBGLOG_NUM_ARGS_MAX) {
OS_MEMZERO(parseArgsString, sizeof(parseArgsString));
totalWriteLen = 0;
for (curArgs = 0; curArgs < numargs; curArgs++){
// Using sprintf_s instead of sprintf, to avoid length overflow
writeLen = snprintf(parseArgsString + totalWriteLen, DBGLOG_PARSE_ARGS_STRING_LENGTH - totalWriteLen, "%x ", buffer[count + 2 + curArgs]);
totalWriteLen += writeLen;
}
if (debugid < MAX_DBG_MSGS){
dbgidString = DBG_MSG_ARR[moduleid][debugid];
if (dbgidString != NULL) {
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("fw:%s(%x %x):%s\n",
dbgidString,
timestamp, buffer[count+1],
parseArgsString));
} else {
/* host need sync with FW id */
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("fw:%s:m:%x,id:%x(%x %x):%s\n",
"UNKNOWN", moduleid, debugid,
timestamp, buffer[count+1],
parseArgsString));
}
} else if (debugid == DBGLOG_DBGID_SM_FRAMEWORK_PROXY_DBGLOG_MSG) {
/* specific debugid */
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("fw:%s:m:%x,id:%x(%x %x):%s\n",
"DBGLOG_SM_MSG", moduleid, debugid,
timestamp, buffer[count+1],
parseArgsString));
} else {
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("fw:%s:m:%x,id:%x(%x %x):%s\n",
"UNKNOWN", moduleid, debugid,
timestamp, buffer[count+1],
parseArgsString));
}
}
count += numargs + 2; /* 32 bit Time stamp + 32 bit Dbg header*/
}
return 0;
}
#ifdef WLAN_OPEN_SOURCE
static int
dbglog_debugfs_raw_data(wmi_unified_t wmi_handle, const u_int8_t *buf, A_UINT32 length, A_UINT32 dropped)
{
struct fwdebug *fwlog = (struct fwdebug *)&wmi_handle->dbglog;
struct dbglog_slot *slot;
struct sk_buff *skb;
size_t slot_len;
if (WARN_ON(length > ATH6KL_FWLOG_PAYLOAD_SIZE))
return -ENODEV;
slot_len = sizeof(*slot) + ATH6KL_FWLOG_PAYLOAD_SIZE;
skb = alloc_skb(slot_len, GFP_KERNEL);
if (!skb)
return -ENOMEM;
slot = (struct dbglog_slot *) skb_put(skb, slot_len);
slot->diag_type = (A_UINT32)DIAG_TYPE_FW_DEBUG_MSG;
slot->timestamp = cpu_to_le32(jiffies);
slot->length = cpu_to_le32(length);
slot->dropped = cpu_to_le32(dropped);
memcpy(slot->payload, buf, length);
/* Need to pad each record to fixed length ATH6KL_FWLOG_PAYLOAD_SIZE */
memset(slot->payload + length, 0, ATH6KL_FWLOG_PAYLOAD_SIZE - length);
spin_lock(&fwlog->fwlog_queue.lock);
__skb_queue_tail(&fwlog->fwlog_queue, skb);
complete(&fwlog->fwlog_completion);
/* drop oldest entries */
while (skb_queue_len(&fwlog->fwlog_queue) >
ATH6KL_FWLOG_MAX_ENTRIES) {
skb = __skb_dequeue(&fwlog->fwlog_queue);
kfree_skb(skb);
}
spin_unlock(&fwlog->fwlog_queue.lock);
return TRUE;
}
#endif /* WLAN_OPEN_SOURCE */
/**
* nl_srv_bcast_fw_logs() - Wrapper func to send bcast msgs to FW logs mcast grp
* @skb: sk buffer pointer
*
* Sends the bcast message to FW logs multicast group with generic nl socket
* if CNSS_GENL is enabled. Else, use the legacy netlink socket to send.
*
* Return: zero on success, error code otherwise
*/
static int nl_srv_bcast_fw_logs(struct sk_buff *skb)
{
#ifdef CNSS_GENL
return nl_srv_bcast(skb, CLD80211_MCGRP_FW_LOGS, WLAN_NL_MSG_CNSS_DIAG);
#else
return nl_srv_bcast(skb);
#endif
}
/*
* Package the data from the fw diag WMI event handler.
* Pass this data to cnss-diag service
*/
static int
send_fw_diag_nl_data(const u_int8_t *buffer,
A_UINT32 len, A_UINT32 event_type)
{
struct sk_buff *skb_out;
struct nlmsghdr *nlh;
int res = 0;
tAniNlHdr *wnl;
int radio;
int msg_len;
if (WARN_ON(len > ATH6KL_FWLOG_PAYLOAD_SIZE))
return -ENODEV;
if (nl_srv_is_initialized() != 0)
return -EIO;
radio = vos_get_radio_index();
if (radio == -EINVAL)
return -EIO;
if (vos_is_multicast_logging())
{
msg_len = len + sizeof(radio);
skb_out = nlmsg_new(msg_len, GFP_KERNEL);
if (!skb_out)
{
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Failed to allocate new skb\n"));
return -1;
}
nlh = nlmsg_put(skb_out, 0, 0, WLAN_NL_MSG_CNSS_DIAG, msg_len, 0);
if (nlh == NULL) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
("%s: nlmsg_put failed\n", __func__));
nlmsg_free(skb_out);
return -ENOMEM;
}
wnl = (tAniNlHdr *)nlh;
wnl->radio = radio;
/* data buffer should offset after the nlmsg_hdr + sizeof(int) radio */
memcpy(nlmsg_data(nlh) + sizeof(radio), buffer, len);
res = nl_srv_bcast_fw_logs(skb_out);
if ((res < 0) && (res != -ESRCH))
{
AR_DEBUG_PRINTF(ATH_DEBUG_RSVD1,
("%s: nl_srv_bcast_fw_logs failed 0x%x \n", __func__, res));
return res;
}
}
return res;
}
static int
send_diag_netlink_data(const u_int8_t *buffer, A_UINT32 len, A_UINT32 cmd)
{
struct sk_buff *skb_out;
struct nlmsghdr *nlh;
int res = 0;
struct dbglog_slot *slot;
size_t slot_len;
tAniNlHdr *wnl;
int radio;
if (WARN_ON(len > ATH6KL_FWLOG_PAYLOAD_SIZE))
return -ENODEV;
if (nl_srv_is_initialized() != 0)
return -EIO;
radio = vos_get_radio_index();
if (radio == -EINVAL)
return -EIO;
if (vos_is_multicast_logging()) {
slot_len = sizeof(*slot) + ATH6KL_FWLOG_PAYLOAD_SIZE + sizeof(radio);
skb_out = nlmsg_new(slot_len, GFP_KERNEL);
if (!skb_out) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
("Failed to allocate new skb\n"));
return -1;
}
nlh = nlmsg_put(skb_out, 0, 0, WLAN_NL_MSG_CNSS_DIAG, slot_len, 0);
if (nlh == NULL) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
("%s: nlmsg_put failed\n", __func__));
nlmsg_free(skb_out);
return -ENOMEM;
}
wnl = (tAniNlHdr *)nlh;
wnl->radio = radio;
/* data buffer should offset after the nlmsg_hdr + sizeof(int) radio */
slot = (struct dbglog_slot *) (nlmsg_data(nlh) + sizeof(radio));
slot->diag_type = cmd;
slot->timestamp = cpu_to_le32(jiffies);
slot->length = cpu_to_le32(len);
/* Version mapped to get_version here */
slot->dropped = get_version;
memcpy(slot->payload, buffer, len);
res = nl_srv_bcast_fw_logs(skb_out);
if ((res < 0) && (res != -ESRCH)) {
AR_DEBUG_PRINTF(ATH_DEBUG_RSVD1,
("%s: nl_srv_bcast_fw_logs failed 0x%x \n", __func__, res));
return res;
}
}
return res;
}
int
dbglog_process_netlink_data(wmi_unified_t wmi_handle, const u_int8_t *buffer,
A_UINT32 len, A_UINT32 dropped)
{
struct sk_buff *skb_out;
struct nlmsghdr *nlh;
int res = 0;
struct dbglog_slot *slot;
size_t slot_len;
tAniNlHdr *wnl;
int radio;
if (WARN_ON(len > ATH6KL_FWLOG_PAYLOAD_SIZE))
return -ENODEV;
if (nl_srv_is_initialized() != 0)
return -EIO;
radio = vos_get_radio_index();
if (radio == -EINVAL)
return -EIO;
if (vos_is_multicast_logging())
{
slot_len = sizeof(*slot) + ATH6KL_FWLOG_PAYLOAD_SIZE + sizeof(radio);
skb_out = nlmsg_new(slot_len, GFP_KERNEL);
if (!skb_out)
{
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Failed to allocate new skb\n"));
return -1;
}
nlh = nlmsg_put(skb_out, 0, 0, WLAN_NL_MSG_CNSS_DIAG, slot_len, 0);
if (nlh == NULL) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
("%s: nlmsg_put failed\n", __func__));
nlmsg_free(skb_out);
return -ENOMEM;
}
wnl = (tAniNlHdr *)nlh;
wnl->radio = radio;
/* data buffer should offset after the nlmsg_hdr + sizeof(int) radio */
slot = (struct dbglog_slot *) (nlmsg_data(nlh) + sizeof(radio));
slot->diag_type = (A_UINT32)DIAG_TYPE_FW_DEBUG_MSG;
slot->timestamp = cpu_to_le32(jiffies);
slot->length = cpu_to_le32(len);
slot->dropped = cpu_to_le32(dropped);
memcpy(slot->payload, buffer, len);
res = nl_srv_bcast_fw_logs(skb_out);
if ((res < 0) && (res != -ESRCH))
{
AR_DEBUG_PRINTF(ATH_DEBUG_RSVD1,
("%s: nl_srv_bcast_fw_logs failed 0x%x \n", __func__, res));
return res;
}
}
return res;
}
/*
* WMI diag data event handler, this function invoked as a CB
* when there DIAG_EVENT, DIAG_MSG, DIAG_DBG to be
* forwarded from the FW. This is the new implementation for
* replacement of fw_dbg and dbg messages
*/
static int
diag_fw_handler(ol_scn_t scn, u_int8_t *data, u_int32_t datalen)
{
tp_wma_handle wma = (tp_wma_handle)scn;
WMI_DIAG_EVENTID_param_tlvs *param_buf;
u_int8_t *datap;
u_int32_t len = 0;
u_int32_t *buffer;
if (!wma) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("NULL Pointer assigned\n"));
return -1;
}
/* when fw asser occurs,host can't use TLV format. */
if (wma->is_fw_assert) {
datap = data;
len = datalen;
wma->is_fw_assert = 0;
} else {
param_buf = (WMI_DIAG_EVENTID_param_tlvs *) data;
if (!param_buf) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
("Get NULL point message from FW\n"));
return -1;
}
param_buf = (WMI_DIAG_EVENTID_param_tlvs *) data;
datap = param_buf->bufp;
len = param_buf->num_bufp;
if (!get_version) {
if (len < 2*(sizeof(uint32_t))) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
("len is less than expected\n"));
return A_ERROR;
}
buffer = (u_int32_t *)datap ;
buffer++; /* skip offset */
if (WLAN_DIAG_TYPE_CONFIG == DIAG_GET_TYPE(*buffer)) {
if (len < 3*(sizeof(uint32_t))) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
("len is less than expected\n"));
return A_ERROR;
}
buffer++; /* skip */
if (DIAG_VERSION_INFO == DIAG_GET_ID(*buffer)) {
if (len < 4*(sizeof(uint32_t))) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
("len is less than expected\n"));
return A_ERROR;
}
buffer++; /* skip */
/* get payload */
get_version = *buffer;
}
}
}
}
if (dbglog_process_type == DBGLOG_PROCESS_PRINT_RAW) {
if (!gprint_limiter) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("NOT Supported"
" only supports net link socket\n"));
gprint_limiter = TRUE;
}
return 0;
}
if ( dbglog_process_type == DBGLOG_PROCESS_NET_RAW) {
return send_diag_netlink_data((A_UINT8 *)datap,
len, DIAG_TYPE_FW_MSG);
}
#ifdef WLAN_OPEN_SOURCE
if (dbglog_process_type == DBGLOG_PROCESS_POOL_RAW) {
if (!gprint_limiter) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("NOT Supported"
" only supports net link socket\n"));
gprint_limiter = TRUE;
}
return 0;
}
#endif /* WLAN_OPEN_SOURCE */
if (!gprint_limiter) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("NOT Supported"
" only supports net link socket\n"));
gprint_limiter = TRUE;
}
/* Always returns zero */
return (0);
}
/**
* process_fw_diag_event_data - process diag events and fw messages
* @datap: data to be processed
* num_data: number of data chunks
*
* return: success
*/
static int
process_fw_diag_event_data(uint8_t *datap, uint32_t num_data)
{
uint32_t diag_type;
uint32_t nl_data_len; /* diag hdr + payload */
uint32_t diag_data_len; /* each fw diag payload */
struct wlan_diag_data *diag_data;
while (num_data > 0) {
diag_data = (struct wlan_diag_data *)datap;
diag_type = WLAN_DIAG_0_TYPE_GET(diag_data->word0);
diag_data_len = WLAN_DIAG_0_LEN_GET(diag_data->word0);
/* Length of diag struct and len of payload */
nl_data_len = sizeof(struct wlan_diag_data) + diag_data_len;
if (nl_data_len > num_data) {
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,
("processed all the messages\n"));
return 0;
}
switch (diag_type) {
case DIAG_TYPE_FW_EVENT:
return send_fw_diag_nl_data(datap, nl_data_len,
diag_type);
break;
case DIAG_TYPE_FW_LOG:
return send_fw_diag_nl_data(datap, nl_data_len,
diag_type);
break;
}
/* Move to the next event and send to cnss-diag */
datap += nl_data_len;
num_data -= nl_data_len;
}
return 0;
}
/*
* WMI diag data event handler, this function invoked as a CB
* when there DIAG_DATA to be forwarded from the FW.
*/
static int
fw_diag_data_event_handler(ol_scn_t scn, u_int8_t *data, u_int32_t datalen)
{
WMI_DIAG_DATA_CONTAINER_EVENTID_param_tlvs *param_buf;
u_int8_t *datap;
u_int32_t num_data; /* Total events */
param_buf = (WMI_DIAG_DATA_CONTAINER_EVENTID_param_tlvs *) data;
if (!param_buf) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Got NULL point message from FW\n"));
return -1;
}
num_data = param_buf->num_bufp;
datap = (u_int8_t *)param_buf->bufp;
return process_fw_diag_event_data(datap, num_data);
}
int
dbglog_parse_debug_logs(ol_scn_t scn, u_int8_t *data, u_int32_t datalen)
{
tp_wma_handle wma = (tp_wma_handle)scn;
A_UINT32 count;
A_UINT32 *buffer;
A_UINT32 timestamp;
A_UINT32 debugid;
A_UINT32 moduleid;
A_UINT16 vapid;
A_UINT16 numargs;
adf_os_size_t length;
A_UINT32 dropped;
WMI_DEBUG_MESG_EVENTID_param_tlvs *param_buf;
u_int8_t *datap;
u_int32_t len;
if (!wma) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("NULL Pointer assigned\n"));
return -1;
}
/*when fw asser occurs,host can't use TLV format.*/
if (wma->is_fw_assert) {
datap = data;
len = datalen;
wma->is_fw_assert = 0;
} else {
param_buf = (WMI_DEBUG_MESG_EVENTID_param_tlvs *) data;
if (!param_buf) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Get NULL point message from FW\n"));
return -1;
}
datap = param_buf->bufp;
len = param_buf->num_bufp;
}
dropped = *((A_UINT32 *)datap);
if (dropped > 0) {
AR_DEBUG_PRINTF(ATH_DEBUG_TRC , ("%d log buffers are dropped \n", dropped));
}
datap += sizeof(dropped);
len -= sizeof(dropped);
count = 0;
buffer = (A_UINT32 *)datap;
length = (len >> 2);
if ( dbglog_process_type == DBGLOG_PROCESS_PRINT_RAW) {
return dbglog_print_raw_data(buffer, length);
}
if (dbglog_process_type == DBGLOG_PROCESS_NET_RAW) {
return dbglog_process_netlink_data((wmi_unified_t)wma->wmi_handle,
(A_UINT8 *)buffer,
len, dropped);
}
#ifdef WLAN_OPEN_SOURCE
if (dbglog_process_type == DBGLOG_PROCESS_POOL_RAW) {
return dbglog_debugfs_raw_data((wmi_unified_t)wma->wmi_handle,
(A_UINT8 *)buffer, len, dropped);
}
#endif /* WLAN_OPEN_SOURCE */
while ((count + 2) < length) {
timestamp = DBGLOG_GET_TIME_STAMP(buffer[count]);
debugid = DBGLOG_GET_DBGID(buffer[count + 1]);
moduleid = DBGLOG_GET_MODULEID(buffer[count + 1]);
vapid = DBGLOG_GET_VDEVID(buffer[count + 1]);
numargs = DBGLOG_GET_NUMARGS(buffer[count + 1]);
if ((count + 2 + numargs) > length)
return 0;
if (moduleid >= WLAN_MODULE_ID_MAX)
return 0;
if (mod_print[moduleid] == NULL) {
/* No module specific log registered use the default handler*/
dbglog_default_print_handler(moduleid, vapid, debugid, timestamp,
numargs,
(((A_UINT32 *)buffer) + 2 + count));
} else {
if(!(mod_print[moduleid](moduleid, vapid, debugid, timestamp,
numargs,
(((A_UINT32 *)buffer) + 2 + count)))) {
/* The message is not handled by the module specific handler*/
dbglog_default_print_handler(moduleid, vapid, debugid, timestamp,
numargs,
(((A_UINT32 *)buffer) + 2 + count));
}
}
count += numargs + 2; /* 32 bit Time stamp + 32 bit Dbg header*/
}
/* Always returns zero */
return (0);
}
void
dbglog_reg_modprint(A_UINT32 mod_id, module_dbg_print printfn)
{
if (!mod_print[mod_id]) {
mod_print[mod_id] = printfn;
} else {
AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("module print is already registered for this module %d\n",
mod_id));
}
}
void
dbglog_sm_print(
A_UINT32 timestamp,
A_UINT16 vap_id,
A_UINT16 numargs,
A_UINT32 *args,
const char *module_prefix,
const char *states[], A_UINT32 num_states,
const char *events[], A_UINT32 num_events)
{
A_UINT8 type, arg1, arg2, arg3;
A_UINT32 extra, extra2, extra3;
if (numargs != 4) {
return;
}
type = (args[0] >> 24) & 0xff;
arg1 = (args[0] >> 16) & 0xff;
arg2 = (args[0] >> 8) & 0xff;
arg3 = (args[0] >> 0) & 0xff;
extra = args[1];
extra2 = args[2];
extra3 = args[3];
switch (type) {
case 0: /* state transition */
if (arg1 < num_states && arg2 < num_states) {
dbglog_printf(timestamp, vap_id, "%s: %s => %s (%#x, %#x, %#x)",
module_prefix, states[arg1], states[arg2], extra, extra2, extra3);
} else {
dbglog_printf(timestamp, vap_id, "%s: %u => %u (%#x, %#x, %#x)",
module_prefix, arg1, arg2, extra, extra2, extra3);
}
break;
case 1: /* dispatch event */
if (arg1 < num_states && arg2 < num_events) {
dbglog_printf(timestamp, vap_id, "%s: %s < %s (%#x, %#x, %#x)",
module_prefix, states[arg1], events[arg2], extra, extra2, extra3);
} else {
dbglog_printf(timestamp, vap_id, "%s: %u < %u (%#x, %#x, %#x)",
module_prefix, arg1, arg2, extra, extra2, extra3);
}
break;
case 2: /* warning */
switch (arg1) {
case 0: /* unhandled event */
if (arg2 < num_states && arg3 < num_events) {
dbglog_printf(timestamp, vap_id, "%s: unhandled event %s in state %s (%#x, %#x, %#x)",
module_prefix, events[arg3], states[arg2], extra, extra2, extra3);
} else {
dbglog_printf(timestamp, vap_id, "%s: unhandled event %u in state %u (%#x, %#x, %#x)",
module_prefix, arg3, arg2, extra, extra2, extra3);
}
break;
default:
break;
}
break;
}
}
A_BOOL
dbglog_sta_powersave_print_handler(
A_UINT32 mod_id,
A_UINT16 vap_id,
A_UINT32 dbg_id,
A_UINT32 timestamp,
A_UINT16 numargs,
A_UINT32 *args)
{
static const char *states[] = {
"IDLE",
"ACTIVE",
"SLEEP_TXQ_FLUSH",
"SLEEP_TX_SENT",
"PAUSE",
"SLEEP_DOZE",
"SLEEP_AWAKE",
"ACTIVE_TXQ_FLUSH",
"ACTIVE_TX_SENT",
"PAUSE_TXQ_FLUSH",
"PAUSE_TX_SENT",
"IDLE_TXQ_FLUSH",
"IDLE_TX_SENT",
};
static const char *events[] = {
"START",
"STOP",
"PAUSE",
"UNPAUSE",
"TIM",
"DTIM",
"SEND_COMPLETE",
"PRE_SEND",
"RX",
"HWQ_EMPTY",
"PAUSE_TIMEOUT",
"TXRX_INACTIVITY_TIMEOUT",
"PSPOLL_TIMEOUT",
"UAPSD_TIMEOUT",
"DELAYED_SLEEP_TIMEOUT",
"SEND_N_COMPLETE",
"TIDQ_PAUSE_COMPLETE",
"SEND_PSPOLL",
"SEND_SPEC_PSPOLL",
};
switch (dbg_id) {
case DBGLOG_DBGID_SM_FRAMEWORK_PROXY_DBGLOG_MSG:
dbglog_sm_print(timestamp, vap_id, numargs, args, "STA PS",
states, ARRAY_LENGTH(states), events, ARRAY_LENGTH(events));
break;
case PS_STA_PM_ARB_REQUEST:
if (numargs == 4) {
dbglog_printf(timestamp, vap_id, "PM ARB request flags=%x, last_time=%x %s: %s",
args[1], args[2], dbglog_get_module_str(args[0]), args[3] ? "SLEEP" : "WAKE");
}
break;
case PS_STA_DELIVER_EVENT:
if (numargs == 2) {
dbglog_printf(timestamp, vap_id, "STA PS: %s %s",
(args[0] == 0 ? "PAUSE_COMPLETE" :
(args[0] == 1 ? "UNPAUSE_COMPLETE" :
(args[0] == 2 ? "SLEEP" :
(args[0] == 3 ? "AWAKE" : "UNKNOWN")))),
(args[1] == 0 ? "SUCCESS" :
(args[1] == 1 ? "TXQ_FLUSH_TIMEOUT" :
(args[1] == 2 ? "NO_ACK" :
(args[1] == 3 ? "RX_LEAK_TIMEOUT" :
(args[1] == 4 ? "PSPOLL_UAPSD_BUSY_TIMEOUT" : "UNKNOWN"))))));
}
break;
case PS_STA_PSPOLL_SEQ_DONE:
if (numargs == 5) {
dbglog_printf(timestamp, vap_id, "STA PS poll: queue=%u comp=%u rsp=%u rsp_dur=%u fc=%x qos=%x %s",
args[0], args[1], args[2], args[3],
(args[4] >> 16) & 0xffff,
(args[4] >> 8) & 0xff,
(args[4] & 0xff) == 0 ? "SUCCESS" :
(args[4] & 0xff) == 1 ? "NO_ACK" :
(args[4] & 0xff) == 2 ? "DROPPED" :
(args[4] & 0xff) == 3 ? "FILTERED" :
(args[4] & 0xff) == 4 ? "RSP_TIMEOUT" : "UNKNOWN");
}
break;
case PS_STA_COEX_MODE:
if (numargs == 1) {
dbglog_printf(timestamp, vap_id, "STA PS COEX MODE %s",
args[0] ? "ENABLED" : "DISABLED");
}
break;
case PS_STA_PSPOLL_ALLOW:
if (numargs == 3) {
dbglog_printf(timestamp, vap_id, "STA PS-Poll %s flags=%x time=%u",
args[0] ? "ALLOW" : "DISALLOW", args[1], args[2]);
}
break;
case PS_STA_SET_PARAM:
if (numargs == 2) {
struct {
char *name;
int is_time_param;
} params[] = {
{ "MAX_SLEEP_ATTEMPTS", 0 },
{ "DELAYED_SLEEP", 1 },
{ "TXRX_INACTIVITY", 1 },
{ "MAX_TX_BEFORE_WAKE", 0 },
{ "UAPSD_TIMEOUT", 1 },
{ "UAPSD_CONFIG", 0 },
{ "PSPOLL_RESPONSE_TIMEOUT", 1 },
{ "MAX_PSPOLL_BEFORE_WAKE", 0 },
{ "RX_WAKE_POLICY", 0 },
{ "DELAYED_PAUSE_RX_LEAK", 1 },
{ "TXRX_INACTIVITY_BLOCKED_RETRY", 1 },
{ "SPEC_WAKE_INTERVAL", 1 },
{ "MAX_SPEC_NODATA_PSPOLL", 0 },
{ "ESTIMATED_PSPOLL_RESP_TIME", 1 },
{ "QPOWER_MAX_PSPOLL_BEFORE_WAKE", 0 },
{ "QPOWER_ENABLE", 0 },
};
A_UINT32 param = args[0];
A_UINT32 value = args[1];
if (param < ARRAY_LENGTH(params)) {
if (params[param].is_time_param) {
dbglog_printf(timestamp, vap_id, "STA PS SET_PARAM %s => %u (us)",
params[param].name, value);
} else {
dbglog_printf(timestamp, vap_id, "STA PS SET_PARAM %s => %#x",
params[param].name, value);
}
} else {
dbglog_printf(timestamp, vap_id, "STA PS SET_PARAM %x => %#x",
param, value);
}
}
break;
case PS_STA_SPECPOLL_TIMER_STARTED:
dbglog_printf(timestamp, vap_id, "SPEC Poll Timer Started: Beacon time Remaining:%d wakeup interval:%d", args[0], args[1]);
break;
case PS_STA_SPECPOLL_TIMER_STOPPED:
dbglog_printf(timestamp, vap_id,
"SPEC Poll Timer Stopped");
break;
default:
return FALSE;
}
return TRUE;
}
/* IBSS PS sub modules */
enum wlan_ibss_ps_sub_module {
WLAN_IBSS_PS_SUB_MODULE_IBSS_NW_SM = 0,
WLAN_IBSS_PS_SUB_MODULE_IBSS_SELF_PS = 1,
WLAN_IBSS_PS_SUB_MODULE_IBSS_PEER_PS = 2,
WLAN_IBSS_PS_SUB_MODULE_MAX = 3,
};
#define WLAN_IBSS_PS_SUB_MODULE_OFFSET 0x1E
A_BOOL
dbglog_ibss_powersave_print_handler(
A_UINT32 mod_id,
A_UINT16 vap_id,
A_UINT32 dbg_id,
A_UINT32 timestamp,
A_UINT16 numargs,
A_UINT32 *args)
{
static const char *nw_states[] = {
"WAIT_FOR_TBTT",
"ATIM_WINDOW_PRE_BCN",
"ATIM_WINDOW_POST_BCN",
"OUT_OF_ATIM_WINDOW",
"PAUSE_PENDING",
"PAUSED",
};
static const char *ps_states[] = {
"ACTIVE",
"SLEEP_TX_SEND",
"SLEEP_DOZE_PAUSE_PENDING",
"SLEEP_DOZE",
"SLEEP_AWAKE",
"ACTIVE_TX_SEND",
"PAUSE_TX_SEND",
"PAUSED",
};
static const char *peer_ps_states[] = {
"ACTIVE",
"SLEEP_AWAKE",
"SLEEP_DOZE",
"PS_UNKNOWN",
};
static const char *events[] = {
"START",
"STOP",
"SWBA",
"TBTT",
"TX_BCN_CMP",
"SEND_COMPLETE",
"SEND_N_COMPLETE",
"PRE_SEND",
"RX",
"UC_INACTIVITY_TIMEOUT",
"BC_INACTIVITY_TIMEOUT",
"ATIM_WINDOW_BEGIN",
"ATIM_WINDOW_END",
"HWQ_EMPTY",
"UC_ATIM_RCVD",
"TRAFFIC_EXCHANGE_DONE",
"POWER_SAVE_STATE_CHANGE",
"NEW_PEER_JOIN",
"IBSS_VDEV_PAUSE_REQUEST",
"IBSS_VDEV_PAUSE_RESPONSE",
"IBSS_VDEV_PAUSE_TIMEOUT",
"IBSS_VDEV_UNPAUSE_REQUEST",
"PS_STATE_CHANGE",
};
enum wlan_ibss_ps_sub_module sub_module;
switch (dbg_id) {
case DBGLOG_DBGID_SM_FRAMEWORK_PROXY_DBGLOG_MSG:
sub_module = (args[1] >> WLAN_IBSS_PS_SUB_MODULE_OFFSET) & 0x3;
switch(sub_module)
{
case WLAN_IBSS_PS_SUB_MODULE_IBSS_NW_SM:
dbglog_sm_print(timestamp, vap_id, numargs, args, "IBSS PS NW",
nw_states, ARRAY_LENGTH(nw_states), events,
ARRAY_LENGTH(events));
break;
case WLAN_IBSS_PS_SUB_MODULE_IBSS_SELF_PS:
dbglog_sm_print(timestamp, vap_id, numargs, args,
"IBSS PS Self", ps_states, ARRAY_LENGTH(ps_states),
events, ARRAY_LENGTH(events));
break;
case WLAN_IBSS_PS_SUB_MODULE_IBSS_PEER_PS:
dbglog_sm_print(timestamp, vap_id, numargs, args,
"IBSS PS Peer", peer_ps_states,
ARRAY_LENGTH(peer_ps_states), events,
ARRAY_LENGTH(events));
break;
default:
break;
}
break;
case IBSS_PS_DBGID_PEER_CREATE:
if (numargs == 2) {