| /* |
| * Copyright (c) 2013-2016 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 "host_diag_core_event.h" |
| #include "qwlan_version.h" |
| #include <net/sock.h> |
| #include <linux/netlink.h> |
| #include <linux/vmalloc.h> |
| |
| #ifdef WLAN_OPEN_SOURCE |
| #include <linux/debugfs.h> |
| #endif /* WLAN_OPEN_SOURCE */ |
| #include "wmi_unified_priv.h" |
| |
| #define CLD_DEBUGFS_DIR "cld" |
| #define DEBUGFS_BLOCK_NAME "dbglog_block" |
| |
| #define ATH_MODULE_NAME fwlog |
| #include <a_debug.h> |
| #define FWLOG_DEBUG ATH_DEBUG_MAKE_MODULE_MASK(0) |
| |
| #if defined(DEBUG) |
| |
| static bool appstarted; |
| static bool senddriverstatus; |
| static int cnss_diag_pid = INVALID_PID; |
| static int get_version; |
| static int gprint_limiter; |
| |
| static ATH_DEBUG_MASK_DESCRIPTION g_fwlog_debug_description[] = { |
| {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_fwlog_debug_description), |
| g_fwlog_debug_description); |
| #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"; |
| default: |
| return "UNKNOWN"; |
| } |
| } |
| |
| char *DBG_MSG_ARR[WLAN_MODULE_ID_MAX][MAX_DBG_MSGS] = { |
| { |
| "INF_MSG_START", |
| "INF_ASSERTION_FAILED", |
| "INF_TARGET_ID", |
| "INF_MSG_END" |
| }, |
| { |
| "WMI_DBGID_DEFINITION_START", |
| "WMI_CMD_RX_XTND_PKT_TOO_SHORT", |
| "WMI_EXTENDED_CMD_NOT_HANDLED", |
| "WMI_CMD_RX_PKT_TOO_SHORT", |
| "WMI_CALLING_WMI_EXTENSION_FN", |
| "WMI_CMD_NOT_HANDLED", |
| "WMI_IN_SYNC", |
| "WMI_TARGET_WMI_SYNC_CMD", |
| "WMI_SET_SNR_THRESHOLD_PARAMS", |
| "WMI_SET_RSSI_THRESHOLD_PARAMS", |
| "WMI_SET_LQ_TRESHOLD_PARAMS", |
| "WMI_TARGET_CREATE_PSTREAM_CMD", |
| "WMI_WI_DTM_INUSE", |
| "WMI_TARGET_DELETE_PSTREAM_CMD", |
| "WMI_TARGET_IMPLICIT_DELETE_PSTREAM_CMD", |
| "WMI_TARGET_GET_BIT_RATE_CMD", |
| "WMI_GET_RATE_MASK_CMD_FIX_RATE_MASK_IS", |
| "WMI_TARGET_GET_AVAILABLE_CHANNELS_CMD", |
| "WMI_TARGET_GET_TX_PWR_CMD", |
| "WMI_FREE_EVBUF_WMIBUF", |
| "WMI_FREE_EVBUF_DATABUF", |
| "WMI_FREE_EVBUF_BADFLAG", |
| "WMI_HTC_RX_ERROR_DATA_PACKET", |
| "WMI_HTC_RX_SYNC_PAUSING_FOR_MBOX", |
| "WMI_INCORRECT_WMI_DATA_HDR_DROPPING_PKT", |
| "WMI_SENDING_READY_EVENT", |
| "WMI_SETPOWER_MDOE_TO_MAXPERF", |
| "WMI_SETPOWER_MDOE_TO_REC", |
| "WMI_BSSINFO_EVENT_FROM", |
| "WMI_TARGET_GET_STATS_CMD", |
| "WMI_SENDING_SCAN_COMPLETE_EVENT", |
| "WMI_SENDING_RSSI_INDB_THRESHOLD_EVENT ", |
| "WMI_SENDING_RSSI_INDBM_THRESHOLD_EVENT", |
| "WMI_SENDING_LINK_QUALITY_THRESHOLD_EVENT", |
| "WMI_SENDING_ERROR_REPORT_EVENT", |
| "WMI_SENDING_CAC_EVENT", |
| "WMI_TARGET_GET_ROAM_TABLE_CMD", |
| "WMI_TARGET_GET_ROAM_DATA_CMD", |
| "WMI_SENDING_GPIO_INTR_EVENT", |
| "WMI_SENDING_GPIO_ACK_EVENT", |
| "WMI_SENDING_GPIO_DATA_EVENT", |
| "WMI_CMD_RX", |
| "WMI_CMD_RX_XTND", |
| "WMI_EVENT_SEND", |
| "WMI_EVENT_SEND_XTND", |
| "WMI_CMD_PARAMS_DUMP_START", |
| "WMI_CMD_PARAMS_DUMP_END", |
| "WMI_CMD_PARAMS", |
| "WMI_EVENT_ALLOC_FAILURE", |
| "WMI_DBGID_DCS_PARAM_CMD", |
| "WMI_SEND_EVENT_WRONG_TLV", |
| "WMI_SEND_EVENT_NO_TLV_DEF", |
| "WMI_DBGID_DEFNITION_END", |
| }, |
| { |
| "PS_STA_DEFINITION_START", |
| "PS_STA_PM_ARB_REQUEST", |
| "PS_STA_DELIVER_EVENT", |
| "PS_STA_PSPOLL_SEQ_DONE", |
| "PS_STA_COEX_MODE", |
| "PS_STA_PSPOLL_ALLOW", |
| "PS_STA_SET_PARAM", |
| "PS_STA_SPECPOLL_TIMER_STARTED", |
| "PS_STA_SPECPOLL_TIMER_STOPPED", |
| }, |
| { |
| "WHAL_DBGID_DEFINITION_START", |
| "WHAL_ERROR_ANI_CONTROL", |
| "WHAL_ERROR_CHIP_TEST1", |
| "WHAL_ERROR_CHIP_TEST2", |
| "WHAL_ERROR_EEPROM_CHECKSUM", |
| "WHAL_ERROR_EEPROM_MACADDR", |
| "WHAL_ERROR_INTERRUPT_HIU", |
| "WHAL_ERROR_KEYCACHE_RESET", |
| "WHAL_ERROR_KEYCACHE_SET", |
| "WHAL_ERROR_KEYCACHE_TYPE", |
| "WHAL_ERROR_KEYCACHE_TKIPENTRY", |
| "WHAL_ERROR_KEYCACHE_WEPLENGTH", |
| "WHAL_ERROR_PHY_INVALID_CHANNEL", |
| "WHAL_ERROR_POWER_AWAKE", |
| "WHAL_ERROR_POWER_SET", |
| "WHAL_ERROR_RECV_STOPDMA", |
| "WHAL_ERROR_RECV_STOPPCU", |
| "WHAL_ERROR_RESET_CHANNF1", |
| "WHAL_ERROR_RESET_CHANNF2", |
| "WHAL_ERROR_RESET_PM", |
| "WHAL_ERROR_RESET_OFFSETCAL", |
| "WHAL_ERROR_RESET_RFGRANT", |
| "WHAL_ERROR_RESET_RXFRAME", |
| "WHAL_ERROR_RESET_STOPDMA", |
| "WHAL_ERROR_RESET_ERRID", |
| "WHAL_ERROR_RESET_ADCDCCAL1", |
| "WHAL_ERROR_RESET_ADCDCCAL2", |
| "WHAL_ERROR_RESET_TXIQCAL", |
| "WHAL_ERROR_RESET_RXIQCAL", |
| "WHAL_ERROR_RESET_CARRIERLEAK", |
| "WHAL_ERROR_XMIT_COMPUTE", |
| "WHAL_ERROR_XMIT_NOQUEUE", |
| "WHAL_ERROR_XMIT_ACTIVEQUEUE", |
| "WHAL_ERROR_XMIT_BADTYPE", |
| "WHAL_ERROR_XMIT_STOPDMA", |
| "WHAL_ERROR_INTERRUPT_BB_PANIC", |
| "WHAL_ERROR_PAPRD_MAXGAIN_ABOVE_WINDOW", |
| "WHAL_ERROR_QCU_HW_PAUSE_MISMATCH", |
| "WHAL_DBGID_DEFINITION_END", |
| }, |
| { |
| "COEX_DEBUGID_START", |
| "BTCOEX_DBG_MCI_1", |
| "BTCOEX_DBG_MCI_2", |
| "BTCOEX_DBG_MCI_3", |
| "BTCOEX_DBG_MCI_4", |
| "BTCOEX_DBG_MCI_5", |
| "BTCOEX_DBG_MCI_6", |
| "BTCOEX_DBG_MCI_7", |
| "BTCOEX_DBG_MCI_8", |
| "BTCOEX_DBG_MCI_9", |
| "BTCOEX_DBG_MCI_10", |
| "COEX_WAL_BTCOEX_INIT", |
| "COEX_WAL_PAUSE", |
| "COEX_WAL_RESUME", |
| "COEX_UPDATE_AFH", |
| "COEX_HWQ_EMPTY_CB", |
| "COEX_MCI_TIMER_HANDLER", |
| "COEX_MCI_RECOVER", |
| "ERROR_COEX_MCI_ISR", |
| "ERROR_COEX_MCI_GPM", |
| "COEX_ProfileType", |
| "COEX_LinkID", |
| "COEX_LinkState", |
| "COEX_LinkRole", |
| "COEX_LinkRate", |
| "COEX_VoiceType", |
| "COEX_TInterval", |
| "COEX_WRetrx", |
| "COEX_Attempts", |
| "COEX_PerformanceState", |
| "COEX_LinkType", |
| "COEX_RX_MCI_GPM_VERSION_QUERY", |
| "COEX_RX_MCI_GPM_VERSION_RESPONSE", |
| "COEX_RX_MCI_GPM_STATUS_QUERY", |
| "COEX_STATE_WLAN_VDEV_DOWN", |
| "COEX_STATE_WLAN_VDEV_START", |
| "COEX_STATE_WLAN_VDEV_CONNECTED", |
| "COEX_STATE_WLAN_VDEV_SCAN_STARTED", |
| "COEX_STATE_WLAN_VDEV_SCAN_END", |
| "COEX_STATE_WLAN_DEFAULT", |
| "COEX_CHANNEL_CHANGE", |
| "COEX_POWER_CHANGE", |
| "COEX_CONFIG_MGR", |
| "COEX_TX_MCI_GPM_BT_CAL_REQ", |
| "COEX_TX_MCI_GPM_BT_CAL_GRANT", |
| "COEX_TX_MCI_GPM_BT_CAL_DONE", |
| "COEX_TX_MCI_GPM_WLAN_CAL_REQ", |
| "COEX_TX_MCI_GPM_WLAN_CAL_GRANT", |
| "COEX_TX_MCI_GPM_WLAN_CAL_DONE", |
| "COEX_TX_MCI_GPM_BT_DEBUG", |
| "COEX_TX_MCI_GPM_VERSION_QUERY", |
| "COEX_TX_MCI_GPM_VERSION_RESPONSE", |
| "COEX_TX_MCI_GPM_STATUS_QUERY", |
| "COEX_TX_MCI_GPM_HALT_BT_GPM", |
| "COEX_TX_MCI_GPM_WLAN_CHANNELS", |
| "COEX_TX_MCI_GPM_BT_PROFILE_INFO", |
| "COEX_TX_MCI_GPM_BT_STATUS_UPDATE", |
| "COEX_TX_MCI_GPM_BT_UPDATE_FLAGS", |
| "COEX_TX_MCI_GPM_UNKNOWN", |
| "COEX_TX_MCI_SYS_WAKING", |
| "COEX_TX_MCI_LNA_TAKE", |
| "COEX_TX_MCI_LNA_TRANS", |
| "COEX_TX_MCI_SYS_SLEEPING", |
| "COEX_TX_MCI_REQ_WAKE", |
| "COEX_TX_MCI_REMOTE_RESET", |
| "COEX_TX_MCI_TYPE_UNKNOWN", |
| "COEX_WHAL_MCI_RESET", |
| "COEX_POLL_BT_CAL_DONE_TIMEOUT", |
| "COEX_WHAL_PAUSE", |
| "COEX_RX_MCI_GPM_BT_CAL_REQ", |
| "COEX_RX_MCI_GPM_BT_CAL_DONE", |
| "COEX_RX_MCI_GPM_BT_CAL_GRANT", |
| "COEX_WLAN_CAL_START", |
| "COEX_WLAN_CAL_RESULT", |
| "COEX_BtMciState", |
| "COEX_BtCalState", |
| "COEX_WlanCalState", |
| "COEX_RxReqWakeCount", |
| "COEX_RxRemoteResetCount", |
| "COEX_RESTART_CAL", |
| "COEX_SENDMSG_QUEUE", |
| "COEX_RESETSEQ_LNAINFO_TIMEOUT", |
| "COEX_MCI_ISR_IntRaw", |
| "COEX_MCI_ISR_Int1Raw", |
| "COEX_MCI_ISR_RxMsgRaw", |
| "COEX_WHAL_COEX_RESET", |
| "COEX_WAL_COEX_INIT", |
| "COEX_TXRX_CNT_LIMIT_ISR", |
| "COEX_CH_BUSY", |
| "COEX_REASSESS_WLAN_STATE", |
| "COEX_BTCOEX_WLAN_STATE_UPDATE", |
| "COEX_BT_NUM_OF_PROFILES", |
| "COEX_BT_NUM_OF_HID_PROFILES", |
| "COEX_BT_NUM_OF_ACL_PROFILES", |
| "COEX_BT_NUM_OF_HI_ACL_PROFILES", |
| "COEX_BT_NUM_OF_VOICE_PROFILES", |
| "COEX_WLAN_AGGR_LIMIT", |
| "COEX_BT_LOW_PRIO_BUDGET", |
| "COEX_BT_HI_PRIO_BUDGET", |
| "COEX_BT_IDLE_TIME", |
| "COEX_SET_COEX_WEIGHT", |
| "COEX_WLAN_WEIGHT_GROUP", |
| "COEX_BT_WEIGHT_GROUP", |
| "COEX_BT_INTERVAL_ALLOC", |
| "COEX_BT_SCHEME", |
| "COEX_BT_MGR", |
| "COEX_BT_SM_ERROR", |
| "COEX_SYSTEM_UPDATE", |
| "COEX_LOW_PRIO_LIMIT", |
| "COEX_HI_PRIO_LIMIT", |
| "COEX_BT_INTERVAL_START", |
| "COEX_WLAN_INTERVAL_START", |
| "COEX_NON_LINK_BUDGET", |
| "COEX_CONTENTION_MSG", |
| "COEX_SET_NSS", |
| "COEX_SELF_GEN_MASK", |
| "COEX_PROFILE_ERROR", |
| "COEX_WLAN_INIT", |
| "COEX_BEACON_MISS", |
| "COEX_BEACON_OK", |
| "COEX_BTCOEX_SCAN_ACTIVITY", |
| "COEX_SCAN_ACTIVITY", |
| "COEX_FORCE_QUIETTIME", |
| "COEX_BT_MGR_QUIETTIME", |
| "COEX_BT_INACTIVITY_TRIGGER", |
| "COEX_BT_INACTIVITY_REPORTED", |
| "COEX_TX_MCI_GPM_WLAN_PRIO", |
| "COEX_TX_MCI_GPM_BT_PAUSE_PROFILE", |
| "COEX_TX_MCI_GPM_WLAN_SET_ACL_INACTIVITY", |
| "COEX_RX_MCI_GPM_BT_ACL_INACTIVITY_REPORT", |
| "COEX_GENERIC_ERROR", |
| "COEX_RX_RATE_THRESHOLD", |
| "COEX_RSSI", |
| "COEX_WLAN_VDEV_NOTIF_START", /* 133 */ |
| "COEX_WLAN_VDEV_NOTIF_UP", /* 134 */ |
| "COEX_WLAN_VDEV_NOTIF_DOWN", /* 135 */ |
| "COEX_WLAN_VDEV_NOTIF_STOP", /* 136 */ |
| "COEX_WLAN_VDEV_NOTIF_ADD_PEER", /* 137 */ |
| "COEX_WLAN_VDEV_NOTIF_DELETE_PEER", /* 138 */ |
| "COEX_WLAN_VDEV_NOTIF_CONNECTED_PEER", /* 139 */ |
| "COEX_WLAN_VDEV_NOTIF_PAUSE", /* 140 */ |
| "COEX_WLAN_VDEV_NOTIF_UNPAUSED", /* 141 */ |
| "COEX_STATE_WLAN_VDEV_PEER_ADD", /* 142 */ |
| "COEX_STATE_WLAN_VDEV_CONNECTED_PEER", /* 143 */ |
| "COEX_STATE_WLAN_VDEV_DELETE_PEER", /* 144 */ |
| "COEX_STATE_WLAN_VDEV_PAUSE", /* 145 */ |
| "COEX_STATE_WLAN_VDEV_UNPAUSED", /* 146 */ |
| "COEX_SCAN_CALLBACK", /* 147 */ |
| "COEX_RC_SET_CHAINMASK", /* 148 */ |
| "COEX_TX_MCI_GPM_WLAN_SET_BT_RXSS_THRES", /* 149 */ |
| "COEX_TX_MCI_GPM_BT_RXSS_THRES_QUERY", /* 150 */ |
| "COEX_BT_RXSS_THRES", /* 151 */ |
| "COEX_BT_PROFILE_ADD_RMV", /* 152 */ |
| "COEX_BT_SCHED_INFO", /* 153 */ |
| "COEX_TRF_MGMT", /* 154 */ |
| "COEX_SCHED_START", /* 155 */ |
| "COEX_SCHED_RESULT", /* 156 */ |
| "COEX_SCHED_ERROR", /* 157 */ |
| "COEX_SCHED_PRE_OP", /* 158 */ |
| "COEX_SCHED_POST_OP", /* 159 */ |
| "COEX_RX_RATE", /* 160 */ |
| "COEX_ACK_PRIORITY", /* 161 */ |
| "COEX_STATE_WLAN_VDEV_UP", /* 162 */ |
| "COEX_STATE_WLAN_VDEV_PEER_UPDATE", /* 163 */ |
| "COEX_STATE_WLAN_VDEV_STOP", /* 164 */ |
| "COEX_WLAN_PAUSE_PEER", /* 165 */ |
| "COEX_WLAN_UNPAUSE_PEER", /* 166 */ |
| "COEX_WLAN_PAUSE_INTERVAL_START", /* 167 */ |
| "COEX_WLAN_POSTPAUSE_INTERVAL_START", /* 168 */ |
| "COEX_TRF_FREERUN", /* 169 */ |
| "COEX_TRF_SHAPE_PM", /* 170 */ |
| "COEX_TRF_SHAPE_PSP", /* 171 */ |
| "COEX_TRF_SHAPE_S_CTS", /* 172 */ |
| "COEX_CHAIN_CONFIG", /* 173 */ |
| "COEX_SYSTEM_MONITOR", /* 174 */ |
| "COEX_SINGLECHAIN_INIT", /* 175 */ |
| "COEX_MULTICHAIN_INIT", /* 176 */ |
| "COEX_SINGLECHAIN_DBG_1", /* 177 */ |
| "COEX_SINGLECHAIN_DBG_2", /* 178 */ |
| "COEX_SINGLECHAIN_DBG_3", /* 179 */ |
| "COEX_MULTICHAIN_DBG_1", /* 180 */ |
| "COEX_MULTICHAIN_DBG_2", /* 181 */ |
| "COEX_MULTICHAIN_DBG_3", /* 182 */ |
| "COEX_PSP_TX_CB", /* 183 */ |
| "COEX_PSP_RX_CB", /* 184 */ |
| "COEX_PSP_STAT_1", /* 185 */ |
| "COEX_PSP_SPEC_POLL", /* 186 */ |
| "COEX_PSP_READY_STATE", /* 187 */ |
| "COEX_PSP_TX_STATUS_STATE", /* 188 */ |
| "COEX_PSP_RX_STATUS_STATE_1", /* 189 */ |
| "COEX_PSP_NOT_READY_STATE", /* 190 */ |
| "COEX_PSP_DISABLED_STATE", /* 191 */ |
| "COEX_PSP_ENABLED_STATE", /* 192 */ |
| "COEX_PSP_SEND_PSPOLL", /* 193 */ |
| "COEX_PSP_MGR_ENTER", /* 194 */ |
| "COEX_PSP_MGR_RESULT", /* 195 */ |
| "COEX_PSP_NONWLAN_INTERVAL", /* 196 */ |
| "COEX_PSP_STAT_2", /* 197 */ |
| "COEX_PSP_RX_STATUS_STATE_2", /* 198 */ |
| "COEX_PSP_ERROR", /* 199 */ |
| "COEX_T2BT", /* 200 */ |
| "COEX_BT_DURATION", /* 201 */ |
| "COEX_TX_MCI_GPM_WLAN_SCHED_INFO_TRIG", /* 202 */ |
| "COEX_TX_MCI_GPM_WLAN_SCHED_INFO_TRIG_RSP", /* 203 */ |
| "COEX_TX_MCI_GPM_SCAN_OP", /* 204 */ |
| "COEX_TX_MCI_GPM_BT_PAUSE_GPM_TX", /* 205 */ |
| "COEX_CTS2S_SEND", /* 206 */ |
| "COEX_CTS2S_RESULT", /* 207 */ |
| "COEX_ENTER_OCS", /* 208 */ |
| "COEX_EXIT_OCS", /* 209 */ |
| "COEX_UPDATE_OCS", /* 210 */ |
| "COEX_STATUS_OCS", /* 211 */ |
| "COEX_STATS_BT", /* 212 */ |
| "COEX_MWS_WLAN_INIT", |
| "COEX_MWS_WBTMR_SYNC", |
| "COEX_MWS_TYPE2_RX", |
| "COEX_MWS_TYPE2_TX", |
| "COEX_MWS_WLAN_CHAVD", |
| "COEX_MWS_WLAN_CHAVD_INSERT", |
| "COEX_MWS_WLAN_CHAVD_MERGE", |
| "COEX_MWS_WLAN_CHAVD_RPT", |
| "COEX_MWS_CP_MSG_SEND", |
| "COEX_MWS_CP_ESCAPE", |
| "COEX_MWS_CP_UNFRAME", |
| "COEX_MWS_CP_SYNC_UPDATE", |
| "COEX_MWS_CP_SYNC", |
| "COEX_MWS_CP_WLAN_STATE_IND", |
| "COEX_MWS_CP_SYNCRESP_TIMEOUT", |
| "COEX_MWS_SCHEME_UPDATE", |
| "COEX_MWS_WLAN_EVENT", |
| "COEX_MWS_UART_UNESCAPE", |
| "COEX_MWS_UART_ENCODE_SEND", |
| "COEX_MWS_UART_RECV_DECODE", |
| "COEX_MWS_UL_HDL", |
| "COEX_MWS_REMOTE_EVENT", |
| "COEX_MWS_OTHER", |
| "COEX_MWS_ERROR", |
| "COEX_MWS_ANT_DIVERSITY", /* 237 */ |
| "COEX_P2P_GO", |
| "COEX_P2P_CLIENT", |
| "COEX_SCC_1", |
| "COEX_SCC_2", |
| "COEX_MCC_1", |
| "COEX_MCC_2", |
| "COEX_TRF_SHAPE_NOA", |
| "COEX_NOA_ONESHOT", |
| "COEX_NOA_PERIODIC", |
| "COEX_LE_1", |
| "COEX_LE_2", |
| "COEX_ANT_1", |
| "COEX_ANT_2", |
| "COEX_ENTER_NOA", |
| "COEX_EXIT_NOA", |
| "COEX_BT_SCAN_PROTECT", /* 253 */ |
| "COEX_DEBUG_ID_END" /* 254 */ |
| }, |
| { |
| "ROAM_DBGID_DEFINITION_START", |
| "ROAM_MODULE_INIT", |
| "ROAM_DEV_START", |
| "ROAM_CONFIG_RSSI_THRESH", |
| "ROAM_CONFIG_SCAN_PERIOD", |
| "ROAM_CONFIG_AP_PROFILE", |
| "ROAM_CONFIG_CHAN_LIST", |
| "ROAM_CONFIG_SCAN_PARAMS", |
| "ROAM_CONFIG_RSSI_CHANGE", |
| "ROAM_SCAN_TIMER_START", |
| "ROAM_SCAN_TIMER_EXPIRE", |
| "ROAM_SCAN_TIMER_STOP", |
| "ROAM_SCAN_STARTED", |
| "ROAM_SCAN_COMPLETE", |
| "ROAM_SCAN_CANCELLED", |
| "ROAM_CANDIDATE_FOUND", |
| "ROAM_RSSI_ACTIVE_SCAN", |
| "ROAM_RSSI_ACTIVE_ROAM", |
| "ROAM_RSSI_GOOD", |
| "ROAM_BMISS_FIRST_RECV", |
| "ROAM_DEV_STOP", |
| "ROAM_FW_OFFLOAD_ENABLE", |
| "ROAM_CANDIDATE_SSID_MATCH", |
| "ROAM_CANDIDATE_SECURITY_MATCH", |
| "ROAM_LOW_RSSI_INTERRUPT", |
| "ROAM_HIGH_RSSI_INTERRUPT", |
| "ROAM_SCAN_REQUESTED", |
| "ROAM_BETTER_CANDIDATE_FOUND", |
| "ROAM_BETTER_AP_EVENT", |
| "ROAM_CANCEL_LOW_PRIO_SCAN", |
| "ROAM_FINAL_BMISS_RECVD", |
| "ROAM_CONFIG_SCAN_MODE", |
| "ROAM_BMISS_FINAL_SCAN_ENABLE", |
| "ROAM_SUITABLE_AP_EVENT", |
| "ROAM_RSN_IE_PARSE_ERROR", |
| "ROAM_WPA_IE_PARSE_ERROR", |
| "ROAM_SCAN_CMD_FROM_HOST", |
| "ROAM_HO_SORT_CANDIDATE", |
| "ROAM_HO_SAVE_CANDIDATE", |
| "ROAM_HO_GET_CANDIDATE", |
| "ROAM_HO_OFFLOAD_SET_PARAM", |
| "ROAM_HO_SM", |
| "ROAM_HO_HTT_SAVED", |
| "ROAM_HO_SYNC_START", |
| "ROAM_HO_START", |
| "ROAM_HO_COMPLETE", |
| "ROAM_HO_STOP", |
| "ROAM_HO_HTT_FORWARD", |
| "ROAM_DBGID_DEFINITION_END" |
| }, |
| { |
| "RESMGR_CHMGR_DEFINITION_START", |
| "RESMGR_CHMGR_PAUSE_COMPLETE", |
| "RESMGR_CHMGR_CHANNEL_CHANGE", |
| "RESMGR_CHMGR_RESUME_COMPLETE", |
| "RESMGR_CHMGR_VDEV_PAUSE", |
| "RESMGR_CHMGR_VDEV_UNPAUSE", |
| "RESMGR_CHMGR_CTS2S_TX_COMP", |
| "RESMGR_CHMGR_CFEND_TX_COMP", |
| "RESMGR_CHMGR_DEFINITION_END" |
| }, |
| { |
| "RESMGR_DEFINITION_START", |
| "RESMGR_OCS_ALLOCRAM_SIZE", |
| "RESMGR_OCS_RESOURCES", |
| "RESMGR_LINK_CREATE", |
| "RESMGR_LINK_DELETE", |
| "RESMGR_OCS_CHREQ_CREATE", |
| "RESMGR_OCS_CHREQ_DELETE", |
| "RESMGR_OCS_CHREQ_START", |
| "RESMGR_OCS_CHREQ_STOP", |
| "RESMGR_OCS_SCHEDULER_INVOKED", |
| "RESMGR_OCS_CHREQ_GRANT", |
| "RESMGR_OCS_CHREQ_COMPLETE", |
| "RESMGR_OCS_NEXT_TSFTIME", |
| "RESMGR_OCS_TSF_TIMEOUT_US", |
| "RESMGR_OCS_CURR_CAT_WINDOW", |
| "RESMGR_OCS_CURR_CAT_WINDOW_REQ", |
| "RESMGR_OCS_CURR_CAT_WINDOW_TIMESLOT", |
| "RESMGR_OCS_CHREQ_RESTART", |
| "RESMGR_OCS_CLEANUP_CH_ALLOCATORS", |
| "RESMGR_OCS_PURGE_CHREQ", |
| "RESMGR_OCS_CH_ALLOCATOR_FREE", |
| "RESMGR_OCS_RECOMPUTE_SCHEDULE", |
| "RESMGR_OCS_NEW_CAT_WINDOW_REQ", |
| "RESMGR_OCS_NEW_CAT_WINDOW_TIMESLOT", |
| "RESMGR_OCS_CUR_CH_ALLOC", |
| "RESMGR_OCS_WIN_CH_ALLOC", |
| "RESMGR_OCS_SCHED_CH_CHANGE", |
| "RESMGR_OCS_CONSTRUCT_CAT_WIN", |
| "RESMGR_OCS_CHREQ_PREEMPTED", |
| "RESMGR_OCS_CH_SWITCH_REQ", |
| "RESMGR_OCS_CHANNEL_SWITCHED", |
| "RESMGR_OCS_CLEANUP_STALE_REQS", |
| "RESMGR_OCS_CHREQ_UPDATE", |
| "RESMGR_OCS_REG_NOA_NOTIF", |
| "RESMGR_OCS_DEREG_NOA_NOTIF", |
| "RESMGR_OCS_GEN_PERIODIC_NOA", |
| "RESMGR_OCS_RECAL_QUOTAS", |
| "RESMGR_OCS_GRANTED_QUOTA_STATS", |
| "RESMGR_OCS_ALLOCATED_QUOTA_STATS", |
| "RESMGR_OCS_REQ_QUOTA_STATS", |
| "RESMGR_OCS_TRACKING_TIME_FIRED", |
| "RESMGR_VC_ARBITRATE_ATTRIBUTES", |
| "RESMGR_OCS_LATENCY_STRICT_TIME_SLOT", |
| "RESMGR_OCS_CURR_TSF", |
| "RESMGR_OCS_QUOTA_REM", |
| "RESMGR_OCS_LATENCY_CASE_NO", |
| "RESMGR_OCS_WIN_CAT_DUR", |
| "RESMGR_VC_UPDATE_CUR_VC", |
| "RESMGR_VC_REG_UNREG_LINK", |
| "RESMGR_VC_PRINT_LINK", |
| "RESMGR_OCS_MISS_TOLERANCE", |
| "RESMGR_DYN_SCH_ALLOCRAM_SIZE", |
| "RESMGR_DYN_SCH_ENABLE", |
| "RESMGR_DYN_SCH_ACTIVE", |
| "RESMGR_DYN_SCH_CH_STATS_START", |
| "RESMGR_DYN_SCH_CH_SX_STATS", |
| "RESMGR_DYN_SCH_TOT_UTIL_PER", |
| "RESMGR_DYN_SCH_HOME_CH_QUOTA", |
| "RESMGR_OCS_REG_RECAL_QUOTA_NOTIF", |
| "RESMGR_OCS_DEREG_RECAL_QUOTA_NOTIF", |
| "RESMGR_DEFINITION_END" |
| }, |
| { |
| "VDEV_MGR_DEBID_DEFINITION_START", /* vdev Mgr */ |
| "VDEV_MGR_FIRST_BEACON_MISS_DETECTED", |
| "VDEV_MGR_FINAL_BEACON_MISS_DETECTED", |
| "VDEV_MGR_BEACON_IN_SYNC", |
| "VDEV_MGR_AP_KEEPALIVE_IDLE", |
| "VDEV_MGR_AP_KEEPALIVE_INACTIVE", |
| "VDEV_MGR_AP_KEEPALIVE_UNRESPONSIVE", |
| "VDEV_MGR_AP_TBTT_CONFIG", |
| "VDEV_MGR_FIRST_BCN_RECEIVED", |
| "VDEV_MGR_VDEV_START", |
| "VDEV_MGR_VDEV_UP", |
| "VDEV_MGR_PEER_AUTHORIZED", |
| "VDEV_MGR_OCS_HP_LP_REQ_POSTED", |
| "VDEV_MGR_VDEV_START_OCS_HP_REQ_COMPLETE", |
| "VDEV_MGR_VDEV_START_OCS_HP_REQ_STOP", |
| "VDEV_MGR_HP_START_TIME", |
| "VDEV_MGR_VDEV_PAUSE_DELAY_UPDATE", |
| "VDEV_MGR_VDEV_PAUSE_FAIL", |
| "VDEV_MGR_GEN_PERIODIC_NOA", |
| "VDEV_MGR_OFF_CHAN_GO_CH_REQ_SETUP", |
| "VDEV_MGR_DEFINITION_END", |
| }, |
| { |
| "SCAN_START_COMMAND_FAILED", /* scan */ |
| "SCAN_STOP_COMMAND_FAILED", |
| "SCAN_EVENT_SEND_FAILED", |
| "SCAN_ENGINE_START", |
| "SCAN_ENGINE_CANCEL_COMMAND", |
| "SCAN_ENGINE_STOP_DUE_TO_TIMEOUT", |
| "SCAN_EVENT_SEND_TO_HOST", |
| "SCAN_FWLOG_EVENT_ADD", |
| "SCAN_FWLOG_EVENT_REM", |
| "SCAN_FWLOG_EVENT_PREEMPTED", |
| "SCAN_FWLOG_EVENT_RESTARTED", |
| "SCAN_FWLOG_EVENT_COMPLETED", |
| }, |
| { |
| "RATECTRL_DBGID_DEFINITION_START", /* Rate ctrl */ |
| "RATECTRL_DBGID_ASSOC", |
| "RATECTRL_DBGID_NSS_CHANGE", |
| "RATECTRL_DBGID_CHAINMASK_ERR", |
| "RATECTRL_DBGID_UNEXPECTED_FRAME", |
| "RATECTRL_DBGID_WAL_RCQUERY", |
| "RATECTRL_DBGID_WAL_RCUPDATE", |
| "RATECTRL_DBGID_GTX_UPDATE", |
| "RATECTRL_DBGID_DEFINITION_END" |
| }, |
| { |
| "AP_PS_DBGID_DEFINITION_START", |
| "AP_PS_DBGID_UPDATE_TIM", |
| "AP_PS_DBGID_PEER_STATE_CHANGE", |
| "AP_PS_DBGID_PSPOLL", |
| "AP_PS_DBGID_PEER_CREATE", |
| "AP_PS_DBGID_PEER_DELETE", |
| "AP_PS_DBGID_VDEV_CREATE", |
| "AP_PS_DBGID_VDEV_DELETE", |
| "AP_PS_DBGID_SYNC_TIM", |
| "AP_PS_DBGID_NEXT_RESPONSE", |
| "AP_PS_DBGID_START_SP", |
| "AP_PS_DBGID_COMPLETED_EOSP", |
| "AP_PS_DBGID_TRIGGER", |
| "AP_PS_DBGID_DUPLICATE_TRIGGER", |
| "AP_PS_DBGID_UAPSD_RESPONSE", |
| "AP_PS_DBGID_SEND_COMPLETE", |
| "AP_PS_DBGID_SEND_N_COMPLETE", |
| "AP_PS_DBGID_DETECT_OUT_OF_SYNC_STA", |
| "AP_PS_DBGID_DELIVER_CAB", |
| }, |
| { |
| "" /* Block Ack */ |
| }, |
| /* Mgmt TxRx */ |
| { |
| "MGMT_TXRX_DBGID_DEFINITION_START", |
| "MGMT_TXRX_FORWARD_TO_HOST", |
| "MGMT_TXRX_DBGID_DEFINITION_END", |
| }, |
| { /* Data TxRx */ |
| "DATA_TXRX_DBGID_DEFINITION_START", |
| "DATA_TXRX_DBGID_RX_DATA_SEQ_LEN_INFO", |
| "DATA_TXRX_DBGID_DEFINITION_END", |
| }, |
| {"" /* HTT */ |
| }, |
| {"" /* HOST */ |
| }, |
| {"" /* BEACON */ |
| "BEACON_EVENT_SWBA_SEND_FAILED", |
| "BEACON_EVENT_EARLY_RX_BMISS_STATUS", |
| "BEACON_EVENT_EARLY_RX_SLEEP_SLOP", |
| "BEACON_EVENT_EARLY_RX_CONT_BMISS_TIMEOUT", |
| "BEACON_EVENT_EARLY_RX_PAUSE_SKIP_BCN_NUM", |
| "BEACON_EVENT_EARLY_RX_CLK_DRIFT", |
| "BEACON_EVENT_EARLY_RX_AP_DRIFT", |
| "BEACON_EVENT_EARLY_RX_BCN_TYPE",}, |
| { /* Offload Mgr */ |
| "OFFLOAD_MGR_DBGID_DEFINITION_START", |
| "OFFLOADMGR_REGISTER_OFFLOAD", |
| "OFFLOADMGR_DEREGISTER_OFFLOAD", |
| "OFFLOADMGR_NO_REG_DATA_HANDLERS", |
| "OFFLOADMGR_NO_REG_EVENT_HANDLERS", |
| "OFFLOADMGR_REG_OFFLOAD_FAILED", |
| "OFFLOADMGR_DBGID_DEFINITION_END", |
| }, |
| { |
| "WAL_DBGID_DEFINITION_START", |
| "WAL_DBGID_FAST_WAKE_REQUEST", |
| "WAL_DBGID_FAST_WAKE_RELEASE", |
| "WAL_DBGID_SET_POWER_STATE", |
| "WAL_DBGID_MISSING", |
| "WAL_DBGID_CHANNEL_CHANGE_FORCE_RESET", |
| "WAL_DBGID_CHANNEL_CHANGE", |
| "WAL_DBGID_VDEV_START", |
| "WAL_DBGID_VDEV_STOP", |
| "WAL_DBGID_VDEV_UP", |
| "WAL_DBGID_VDEV_DOWN", |
| "WAL_DBGID_SW_WDOG_RESET", |
| "WAL_DBGID_TX_SCH_REGISTER_TIDQ", |
| "WAL_DBGID_TX_SCH_UNREGISTER_TIDQ", |
| "WAL_DBGID_TX_SCH_TICKLE_TIDQ", |
| "WAL_DBGID_XCESS_FAILURES", |
| "WAL_DBGID_AST_ADD_WDS_ENTRY", |
| "WAL_DBGID_AST_DEL_WDS_ENTRY", |
| "WAL_DBGID_AST_WDS_ENTRY_PEER_CHG", |
| "WAL_DBGID_AST_WDS_SRC_LEARN_FAIL", |
| "WAL_DBGID_STA_KICKOUT", |
| "WAL_DBGID_BAR_TX_FAIL", |
| "WAL_DBGID_BAR_ALLOC_FAIL", |
| "WAL_DBGID_LOCAL_DATA_TX_FAIL", |
| "WAL_DBGID_SECURITY_PM4_QUEUED", |
| "WAL_DBGID_SECURITY_GM1_QUEUED", |
| "WAL_DBGID_SECURITY_PM4_SENT", |
| "WAL_DBGID_SECURITY_ALLOW_DATA", |
| "WAL_DBGID_SECURITY_UCAST_KEY_SET", |
| "WAL_DBGID_SECURITY_MCAST_KEY_SET", |
| "WAL_DBGID_SECURITY_ENCR_EN", |
| "WAL_DBGID_BB_WDOG_TRIGGERED", |
| "WAL_DBGID_RX_LOCAL_BUFS_LWM", |
| "WAL_DBGID_RX_LOCAL_DROP_LARGE_MGMT", |
| "WAL_DBGID_VHT_ILLEGAL_RATE_PHY_ERR_DETECTED", |
| "WAL_DBGID_DEV_RESET", |
| "WAL_DBGID_TX_BA_SETUP", |
| "WAL_DBGID_RX_BA_SETUP", |
| "WAL_DBGID_DEV_TX_TIMEOUT", |
| "WAL_DBGID_DEV_RX_TIMEOUT", |
| "WAL_DBGID_STA_VDEV_XRETRY", |
| "WAL_DBGID_DCS", |
| "WAL_DBGID_MGMT_TX_FAIL", |
| "WAL_DBGID_SET_M4_SENT_MANUALLY", |
| "WAL_DBGID_PROCESS_4_WAY_HANDSHAKE", |
| "WAL_DBGID_WAL_CHANNEL_CHANGE_START", |
| "WAL_DBGID_WAL_CHANNEL_CHANGE_COMPLETE", |
| "WAL_DBGID_WHAL_CHANNEL_CHANGE_START", |
| "WAL_DBGID_WHAL_CHANNEL_CHANGE_COMPLETE", |
| "WAL_DBGID_TX_MGMT_DESCID_SEQ_TYPE_LEN", |
| "WAL_DBGID_TX_DATA_MSDUID_SEQ_TYPE_LEN", |
| "WAL_DBGID_TX_DISCARD", |
| "WAL_DBGID_TX_MGMT_COMP_DESCID_STATUS", |
| "WAL_DBGID_TX_DATA_COMP_MSDUID_STATUS", |
| "WAL_DBGID_RESET_PCU_CYCLE_CNT", |
| "WAL_DBGID_SETUP_RSSI_INTERRUPTS", |
| "WAL_DBGID_BRSSI_CONFIG", |
| "WAL_DBGID_CURRENT_BRSSI_AVE", |
| "WAL_DBGID_BCN_TX_COMP", |
| "WAL_DBGID_SET_HW_CHAINMASK", |
| "WAL_DBGID_SET_HW_CHAINMASK_TXRX_STOP_FAIL", |
| "WAL_DBGID_GET_HW_CHAINMASK", |
| "WAL_DBGID_SMPS_DISABLE", |
| "WAL_DBGID_SMPS_ENABLE_HW_CNTRL", |
| "WAL_DBGID_SMPS_SWSEL_CHAINMASK", |
| "WAL_DBGID_DEFINITION_END", |
| }, |
| { |
| "" /* DE */ |
| }, |
| { |
| "" /* pcie lp */ |
| }, |
| { |
| /* RTT */ |
| "RTT_CALL_FLOW", |
| "RTT_REQ_SUB_TYPE", |
| "RTT_MEAS_REQ_HEAD", |
| "RTT_MEAS_REQ_BODY", |
| "", |
| "", |
| "RTT_INIT_GLOBAL_STATE", |
| "", |
| "RTT_REPORT", |
| "", |
| "RTT_ERROR_REPORT", |
| "RTT_TIMER_STOP", |
| "RTT_SEND_TM_FRAME", |
| "RTT_V3_RESP_CNT", |
| "RTT_V3_RESP_FINISH", |
| "RTT_CHANNEL_SWITCH_REQ", |
| "RTT_CHANNEL_SWITCH_GRANT", |
| "RTT_CHANNEL_SWITCH_COMPLETE", |
| "RTT_CHANNEL_SWITCH_PREEMPT", |
| "RTT_CHANNEL_SWITCH_STOP", |
| "RTT_TIMER_START", |
| }, |
| { /* RESOURCE */ |
| "RESOURCE_DBGID_DEFINITION_START", |
| "RESOURCE_PEER_ALLOC", |
| "RESOURCE_PEER_FREE", |
| "RESOURCE_PEER_ALLOC_WAL_PEER", |
| "RESOURCE_PEER_NBRHOOD_MGMT_ALLOC", |
| "RESOURCE_PEER_NBRHOOD_MGMT_INFO," "RESOURCE_DBGID_DEFINITION_END", |
| }, |
| { /* DCS */ |
| "WLAN_DCS_DBGID_INIT", |
| "WLAN_DCS_DBGID_WMI_CWINT", |
| "WLAN_DCS_DBGID_TIMER", |
| "WLAN_DCS_DBGID_CMDG", |
| "WLAN_DCS_DBGID_CMDS", |
| "WLAN_DCS_DBGID_DINIT" |
| }, |
| { /* CACHEMGR */ |
| "" |
| }, |
| { /* ANI */ |
| "ANI_DBGID_POLL", |
| "ANI_DBGID_CONTROL", |
| "ANI_DBGID_OFDM_PARAMS", |
| "ANI_DBGID_CCK_PARAMS", |
| "ANI_DBGID_RESET", |
| "ANI_DBGID_RESTART", |
| "ANI_DBGID_OFDM_LEVEL", |
| "ANI_DBGID_CCK_LEVEL", |
| "ANI_DBGID_FIRSTEP", |
| "ANI_DBGID_CYCPWR", |
| "ANI_DBGID_MRC_CCK", |
| "ANI_DBGID_SELF_CORR_LOW", |
| "ANI_DBGID_ENABLE", |
| "ANI_DBGID_CURRENT_LEVEL", |
| "ANI_DBGID_POLL_PERIOD", |
| "ANI_DBGID_LISTEN_PERIOD", |
| "ANI_DBGID_OFDM_LEVEL_CFG", |
| "ANI_DBGID_CCK_LEVEL_CFG" |
| }, |
| { |
| "P2P_DBGID_DEFINITION_START", |
| "P2P_DEV_REGISTER", |
| "P2P_HANDLE_NOA", |
| "P2P_UPDATE_SCHEDULE_OPPS", |
| "P2P_UPDATE_SCHEDULE", |
| "P2P_UPDATE_START_TIME", |
| "P2P_UPDATE_START_TIME_DIFF_TSF32", |
| "P2P_UPDATE_START_TIME_FINAL", |
| "P2P_SETUP_SCHEDULE_TIMER", |
| "P2P_PROCESS_SCHEDULE_AFTER_CALC", |
| "P2P_PROCESS_SCHEDULE_STARTED_TIMER", |
| "P2P_CALC_SCHEDULES_FIRST_CALL_ALL_NEXT_EVENT", |
| "P2P_CALC_SCHEDULES_FIRST_VALUE", |
| "P2P_CALC_SCHEDULES_EARLIEST_NEXT_EVENT", |
| "P2P_CALC_SCHEDULES_SANITY_COUNT", |
| "P2P_CALC_SCHEDULES_CALL_ALL_NEXT_EVENT_FROM_WHILE_LOOP", |
| "P2P_CALC_SCHEDULES_TIMEOUT_1", |
| "P2P_CALC_SCHEDULES_TIMEOUT_2", |
| "P2P_FIND_ALL_NEXT_EVENTS_REQ_EXPIRED", |
| "P2P_FIND_ALL_NEXT_EVENTS_REQ_ACTIVE", |
| "P2P_FIND_NEXT_EVENT_REQ_NOT_STARTED", |
| "P2P_FIND_NEXT_EVENT_REQ_COMPLETE_NON_PERIODIC", |
| "P2P_FIND_NEXT_EVENT_IN_MID_OF_NOA", |
| "P2P_FIND_NEXT_EVENT_REQ_COMPLETE", |
| "P2P_SCHEDULE_TIMEOUT", |
| "P2P_CALC_SCHEDULES_ENTER", |
| "P2P_PROCESS_SCHEDULE_ENTER", |
| "P2P_FIND_ALL_NEXT_EVENTS_INDIVIDUAL_REQ_AFTER_CHANGE", |
| "P2P_FIND_ALL_NEXT_EVENTS_INDIVIDUAL_REQ_BEFORE_CHANGE", |
| "P2P_FIND_ALL_NEXT_EVENTS_ENTER", |
| "P2P_FIND_NEXT_EVENT_ENTER", |
| "P2P_NOA_GO_PRESENT", |
| "P2P_NOA_GO_ABSENT", |
| "P2P_GO_NOA_NOTIF", |
| "P2P_GO_TBTT_OFFSET", |
| "P2P_GO_GET_NOA_INFO", |
| "P2P_GO_ADD_ONE_SHOT_NOA", |
| "P2P_GO_GET_NOA_IE", |
| "P2P_GO_BCN_TX_COMP", |
| "P2P_DBGID_DEFINITION_END", |
| }, |
| { |
| "CSA_DBGID_DEFINITION_START", |
| "CSA_OFFLOAD_POOL_INIT", |
| "CSA_OFFLOAD_REGISTER_VDEV", |
| "CSA_OFFLOAD_DEREGISTER_VDEV", |
| "CSA_DEREGISTER_VDEV_ERROR", |
| "CSA_OFFLOAD_BEACON_RECEIVED", |
| "CSA_OFFLOAD_BEACON_CSA_RECV", |
| "CSA_OFFLOAD_CSA_RECV_ERROR_IE", |
| "CSA_OFFLOAD_CSA_TIMER_ERROR", |
| "CSA_OFFLOAD_CSA_TIMER_EXP", |
| "CSA_OFFLOAD_WMI_EVENT_ERROR", |
| "CSA_OFFLOAD_WMI_EVENT_SENT", |
| "CSA_OFFLOAD_WMI_CHANSWITCH_RECV", |
| "CSA_DBGID_DEFINITION_END", |
| }, |
| { /* NLO offload */ |
| "" |
| }, |
| { |
| "WLAN_CHATTER_DBGID_DEFINITION_START", |
| "WLAN_CHATTER_ENTER", |
| "WLAN_CHATTER_EXIT", |
| "WLAN_CHATTER_FILTER_HIT", |
| "WLAN_CHATTER_FILTER_MISS", |
| "WLAN_CHATTER_FILTER_FULL", |
| "WLAN_CHATTER_FILTER_TM_ADJ", |
| "WLAN_CHATTER_BUFFER_FULL", |
| "WLAN_CHATTER_TIMEOUT", |
| "WLAN_CHATTER_DBGID_DEFINITION_END", |
| }, |
| { |
| "WOW_DBGID_DEFINITION_START", |
| "WOW_ENABLE_CMDID", |
| "WOW_RECV_DATA_PKT", |
| "WOW_WAKE_HOST_DATA", |
| "WOW_RECV_MGMT", |
| "WOW_WAKE_HOST_MGMT", |
| "WOW_RECV_EVENT", |
| "WOW_WAKE_HOST_EVENT", |
| "WOW_INIT", |
| "WOW_RECV_MAGIC_PKT", |
| "WOW_RECV_BITMAP_PATTERN", |
| "WOW_AP_VDEV_DISALLOW", |
| "WOW_STA_VDEV_DISALLOW", |
| "WOW_P2PGO_VDEV_DISALLOW", |
| "WOW_NS_OFLD_ENABLE", |
| "WOW_ARP_OFLD_ENABLE", |
| "WOW_NS_ARP_OFLD_DISABLE", |
| "WOW_NS_RECEIVED", |
| "WOW_NS_REPLIED", |
| "WOW_ARP_RECEIVED", |
| "WOW_ARP_REPLIED", |
| "WOW_DBGID_DEFINITION_END", |
| }, |
| { /* WAL VDEV */ |
| "" |
| }, |
| { /* WAL PDEV */ |
| "" |
| }, |
| { /* TEST */ |
| "TP_CHANGE_CHANNEL", |
| "TP_LOCAL_SEND", |
| }, |
| { /* STA SMPS */ |
| "STA_SMPS_DBGID_DEFINITION_START", |
| "STA_SMPS_DBGID_CREATE_PDEV_INSTANCE", |
| "STA_SMPS_DBGID_CREATE_VIRTUAL_CHAN_INSTANCE", |
| "STA_SMPS_DBGID_DELETE_VIRTUAL_CHAN_INSTANCE", |
| "STA_SMPS_DBGID_CREATE_STA_INSTANCE", |
| "STA_SMPS_DBGID_DELETE_STA_INSTANCE", |
| "STA_SMPS_DBGID_VIRTUAL_CHAN_SMPS_START", |
| "STA_SMPS_DBGID_VIRTUAL_CHAN_SMPS_STOP", |
| "STA_SMPS_DBGID_SEND_SMPS_ACTION_FRAME", |
| "STA_SMPS_DBGID_HOST_FORCED_MODE", |
| "STA_SMPS_DBGID_FW_FORCED_MODE", |
| "STA_SMPS_DBGID_RSSI_THRESHOLD_CROSSED", |
| "STA_SMPS_DBGID_SMPS_ACTION_FRAME_COMPLETION", |
| "STA_SMPS_DBGID_DTIM_EBT_EVENT_CHMASK_UPDATE", |
| "STA_SMPS_DBGID_DTIM_CHMASK_UPDATE", |
| "STA_SMPS_DBGID_DTIM_BEACON_EVENT_CHMASK_UPDATE", |
| "STA_SMPS_DBGID_DTIM_POWER_STATE_CHANGE", |
| "STA_SMPS_DBGID_DTIM_CHMASK_UPDATE_SLEEP", |
| "STA_SMPS_DBGID_DTIM_CHMASK_UPDATE_AWAKE", |
| "SMPS_DBGID_DEFINITION_END", |
| }, |
| { /* SWBMISS */ |
| "SWBMISS_DBGID_DEFINITION_START", |
| "SWBMISS_ENABLED", |
| "SWBMISS_DISABLED", |
| "SWBMISS_DBGID_DEFINITION_END", |
| }, |
| { /* WMMAC */ |
| "" |
| }, |
| { /* TDLS */ |
| "TDLS_DBGID_DEFINITION_START", |
| "TDLS_DBGID_VDEV_CREATE", |
| "TDLS_DBGID_VDEV_DELETE", |
| "TDLS_DBGID_ENABLED_PASSIVE", |
| "TDLS_DBGID_ENABLED_ACTIVE", |
| "TDLS_DBGID_DISABLED", |
| "TDLS_DBGID_CONNTRACK_TIMER", |
| "TDLS_DBGID_WAL_SET", |
| "TDLS_DBGID_WAL_GET", |
| "TDLS_DBGID_WAL_PEER_UPDATE_SET", |
| "TDLS_DBGID_WAL_PEER_UPDATE_EVT", |
| "TDLS_DBGID_WAL_VDEV_CREATE", |
| "TDLS_DBGID_WAL_VDEV_DELETE", |
| "TDLS_DBGID_WLAN_EVENT", |
| "TDLS_DBGID_WLAN_PEER_UPDATE_SET", |
| "TDLS_DBGID_PEER_EVT_DRP_THRESH", |
| "TDLS_DBGID_PEER_EVT_DRP_RATE", |
| "TDLS_DBGID_PEER_EVT_DRP_RSSI", |
| "TDLS_DBGID_PEER_EVT_DISCOVER", |
| "TDLS_DBGID_PEER_EVT_DELETE", |
| "TDLS_DBGID_PEER_CAP_UPDATE", |
| "TDLS_DBGID_UAPSD_SEND_PTI_FRAME", |
| "TDLS_DBGID_UAPSD_SEND_PTI_FRAME2PEER", |
| "TDLS_DBGID_UAPSD_START_PTR_TIMER", |
| "TDLS_DBGID_UAPSD_CANCEL_PTR_TIMER", |
| "TDLS_DBGID_UAPSD_PTR_TIMER_TIMEOUT", |
| "TDLS_DBGID_UAPSD_STA_PS_EVENT_HANDLER", |
| "TDLS_DBGID_UAPSD_PEER_EVENT_HANDLER", |
| "TDLS_DBGID_UAPSD_PS_DEFAULT_SETTINGS", |
| "TDLS_DBGID_UAPSD_GENERIC", |
| }, |
| { /* HB */ |
| "WLAN_HB_DBGID_DEFINITION_START", |
| "WLAN_HB_DBGID_INIT", |
| "WLAN_HB_DBGID_TCP_GET_TXBUF_FAIL", |
| "WLAN_HB_DBGID_TCP_SEND_FAIL", |
| "WLAN_HB_DBGID_BSS_PEER_NULL", |
| "WLAN_HB_DBGID_UDP_GET_TXBUF_FAIL", |
| "WLAN_HB_DBGID_UDP_SEND_FAIL", |
| "WLAN_HB_DBGID_WMI_CMD_INVALID_PARAM", |
| "WLAN_HB_DBGID_WMI_CMD_INVALID_OP", |
| "WLAN_HB_DBGID_WOW_NOT_ENTERED", |
| "WLAN_HB_DBGID_ALLOC_SESS_FAIL", |
| "WLAN_HB_DBGID_CTX_NULL", |
| "WLAN_HB_DBGID_CHKSUM_ERR", |
| "WLAN_HB_DBGID_UDP_TX", |
| "WLAN_HB_DBGID_TCP_TX", |
| "WLAN_HB_DBGID_DEFINITION_END", |
| }, |
| { /* TXBF */ |
| "TXBFEE_DBGID_START", |
| "TXBFEE_DBGID_NDPA_RECEIVED", |
| "TXBFEE_DBGID_HOST_CONFIG_TXBFEE_TYPE", |
| "TXBFER_DBGID_SEND_NDPA", |
| "TXBFER_DBGID_GET_NDPA_BUF_FAIL", |
| "TXBFER_DBGID_SEND_NDPA_FAIL", |
| "TXBFER_DBGID_GET_NDP_BUF_FAIL", |
| "TXBFER_DBGID_SEND_NDP_FAIL", |
| "TXBFER_DBGID_GET_BRPOLL_BUF_FAIL", |
| "TXBFER_DBGID_SEND_BRPOLL_FAIL", |
| "TXBFER_DBGID_HOST_CONFIG_CMDID", |
| "TXBFEE_DBGID_HOST_CONFIG_CMDID", |
| "TXBFEE_DBGID_ENABLED_ENABLED_UPLOAD_H", |
| "TXBFEE_DBGID_UPLOADH_CV_TAG", |
| "TXBFEE_DBGID_UPLOADH_H_TAG", |
| "TXBFEE_DBGID_CAPTUREH_RECEIVED", |
| "TXBFEE_DBGID_PACKET_IS_STEERED", |
| "TXBFEE_UPLOADH_EVENT_ALLOC_MEM_FAIL", |
| "TXBFEE_DBGID_END", |
| }, |
| { /*BATCH SCAN */ |
| }, |
| { /*THERMAL MGR */ |
| "THERMAL_MGR_DBGID_DEFINITION_START", |
| "THERMAL_MGR_NEW_THRESH", |
| "THERMAL_MGR_THRESH_CROSSED", |
| "THERMAL_MGR_DBGID_DEFINITION END", |
| }, |
| { /* WLAN_MODULE_PHYERR_DFS */ |
| "" |
| }, |
| { |
| /* WLAN_MODULE_RMC */ |
| "RMC_DBGID_DEFINITION_START", |
| "RMC_CREATE_INSTANCE", |
| "RMC_DELETE_INSTANCE", |
| "RMC_LDR_SEL", |
| "RMC_NO_LDR", |
| "RMC_LDR_NOT_SEL", |
| "RMC_LDR_INF_SENT", |
| "RMC_PEER_ADD", |
| "RMC_PEER_DELETE", |
| "RMC_PEER_UNKNOWN", |
| "RMC_SET_MODE", |
| "RMC_SET_ACTION_PERIOD", |
| "RMC_ACRION_FRAME_RX", |
| "RMC_DBGID_DEFINITION_END", |
| }, |
| { |
| /* WLAN_MODULE_STATS */ |
| "WLAN_STATS_DBGID_DEFINITION_START", |
| "WLAN_STATS_DBGID_EST_LINKSPEED_VDEV_EN_DIS", |
| "WLAN_STATS_DBGID_EST_LINKSPEED_CHAN_TIME_START", |
| "WLAN_STATS_DBGID_EST_LINKSPEED_CHAN_TIME_END", |
| "WLAN_STATS_DBGID_EST_LINKSPEED_CALC", |
| "WLAN_STATS_DBGID_EST_LINKSPEED_UPDATE_HOME_CHAN", |
| "WLAN_STATS_DBGID_DEFINITION_END", |
| }, |
| { |
| /* WLAN_MODULE_NAN */ |
| }, |
| { |
| /* WLAN_MODULE_IBSS_PWRSAVE */ |
| "IBSS_PS_DBGID_DEFINITION_START", |
| "IBSS_PS_DBGID_PEER_CREATE", |
| "IBSS_PS_DBGID_PEER_DELETE", |
| "IBSS_PS_DBGID_VDEV_CREATE", |
| "IBSS_PS_DBGID_VDEV_DELETE", |
| "IBSS_PS_DBGID_VDEV_EVENT", |
| "IBSS_PS_DBGID_PEER_EVENT", |
| "IBSS_PS_DBGID_DELIVER_CAB", |
| "IBSS_PS_DBGID_DELIVER_UC_DATA", |
| "IBSS_PS_DBGID_DELIVER_UC_DATA_ERROR", |
| "IBSS_PS_DBGID_UC_INACTIVITY_TMR_RESTART", |
| "IBSS_PS_DBGID_MC_INACTIVITY_TMR_RESTART", |
| "IBSS_PS_DBGID_NULL_TX_COMPLETION", |
| "IBSS_PS_DBGID_ATIM_TIMER_START", |
| "IBSS_PS_DBGID_UC_ATIM_SEND", |
| "IBSS_PS_DBGID_BC_ATIM_SEND", |
| "IBSS_PS_DBGID_UC_TIMEOUT", |
| "IBSS_PS_DBGID_PWR_COLLAPSE_ALLOWED", |
| "IBSS_PS_DBGID_PWR_COLLAPSE_NOT_ALLOWED", |
| "IBSS_PS_DBGID_SET_PARAM", |
| "IBSS_PS_DBGID_HOST_TX_PAUSE", |
| "IBSS_PS_DBGID_HOST_TX_UNPAUSE", |
| "IBSS_PS_DBGID_PS_DESC_BIN_HWM", |
| "IBSS_PS_DBGID_PS_DESC_BIN_LWM", |
| "IBSS_PS_DBGID_PS_KICKOUT_PEER", |
| "IBSS_PS_DBGID_SET_PEER_PARAM", |
| "IBSS_PS_DBGID_BCN_ATIM_WIN_MISMATCH", |
| "IBSS_PS_DBGID_RX_CHAINMASK_CHANGE", |
| }, |
| { |
| /* HIF UART Interface DBGIDs */ |
| "HIF_UART_DBGID_START", |
| "HIF_UART_DBGID_POWER_STATE", |
| "HIF_UART_DBGID_TXRX_FLOW", |
| "HIF_UART_DBGID_TXRX_CTRL_CHAR", |
| "HIF_UART_DBGID_TXRX_BUF_DUMP", |
| }, |
| { |
| /* LPI */ |
| "" |
| }, |
| { |
| /* EXTSCAN DBGIDs */ |
| "EXTSCAN_START", |
| "EXTSCAN_STOP", |
| "EXTSCAN_CLEAR_ENTRY_CONTENT", |
| "EXTSCAN_GET_FREE_ENTRY_SUCCESS", |
| "EXTSCAN_GET_FREE_ENTRY_INCONSISTENT", |
| "EXTSCAN_GET_FREE_ENTRY_NO_MORE_ENTRIES", |
| "EXTSCAN_CREATE_ENTRY_SUCCESS", |
| "EXTSCAN_CREATE_ENTRY_ERROR", |
| "EXTSCAN_SEARCH_SCAN_ENTRY_QUEUE", |
| "EXTSCAN_SEARCH_SCAN_ENTRY_KEY_FOUND", |
| "EXTSCAN_SEARCH_SCAN_ENTRY_KEY_NOT_FOUND", |
| "EXTSCAN_ADD_ENTRY", |
| "EXTSCAN_BUCKET_SEND_OPERATION_EVENT", |
| "EXTSCAN_BUCKET_SEND_OPERATION_EVENT_FAILED", |
| "EXTSCAN_BUCKET_START_SCAN_CYCLE", |
| "EXTSCAN_BUCKET_PERIODIC_TIMER", |
| "EXTSCAN_SEND_START_STOP_EVENT", |
| "EXTSCAN_NOTIFY_WLAN_CHANGE", |
| "EXTSCAN_NOTIFY_WLAN_HOTLIST_MATCH", |
| "EXTSCAN_MAIN_RECEIVED_FRAME", |
| "EXTSCAN_MAIN_NO_SSID_IE", |
| "EXTSCAN_MAIN_MALFORMED_FRAME", |
| "EXTSCAN_FIND_BSSID_BY_REFERENCE", |
| "EXTSCAN_FIND_BSSID_BY_REFERENCE_ERROR", |
| "EXTSCAN_NOTIFY_TABLE_USAGE", |
| "EXTSCAN_FOUND_RSSI_ENTRY", |
| "EXTSCAN_BSSID_FOUND_RSSI_SAMPLE", |
| "EXTSCAN_BSSID_ADDED_RSSI_SAMPLE", |
| "EXTSCAN_BSSID_REPLACED_RSSI_SAMPLE", |
| "EXTSCAN_BSSID_TRANSFER_CURRENT_SAMPLES", |
| "EXTSCAN_BUCKET_PROCESS_SCAN_EVENT", |
| "EXTSCAN_BUCKET_CANNOT_FIND_BUCKET", |
| "EXTSCAN_START_SCAN_REQUEST_FAILED", |
| "EXTSCAN_BUCKET_STOP_CURRENT_SCANS", |
| "EXTSCAN_BUCKET_SCAN_STOP_REQUEST", |
| "EXTSCAN_BUCKET_PERIODIC_TIMER_ERROR", |
| "EXTSCAN_BUCKET_START_OPERATION", |
| "EXTSCAN_START_INTERNAL_ERROR", |
| "EXTSCAN_NOTIFY_HOTLIST_MATCH", |
| "EXTSCAN_CONFIG_HOTLIST_TABLE", |
| "EXTSCAN_CONFIG_WLAN_CHANGE_TABLE", |
| }, |
| { /* UNIT_TEST */ |
| "UNIT_TEST_GEN", |
| }, |
| { /* MLME */ |
| "MLME_DEBUG_CMN", |
| "MLME_IF", |
| "MLME_AUTH", |
| "MLME_REASSOC", |
| "MLME_DEAUTH", |
| "MLME_DISASSOC", |
| "MLME_ROAM", |
| "MLME_RETRY", |
| "MLME_TIMER", |
| "MLME_FRMPARSE", |
| }, |
| { /*SUPPLICANT */ |
| "SUPPL_INIT", |
| "SUPPL_RECV_EAPOL", |
| "SUPPL_RECV_EAPOL_TIMEOUT", |
| "SUPPL_SEND_EAPOL", |
| "SUPPL_MIC_MISMATCH", |
| "SUPPL_FINISH", |
| }, |
| }; |
| |
| 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_ERR, |
| ("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) |
| cdf_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 > true) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, |
| ("dbglog_report_enable:Invalid value %d\n", |
| isenable)); |
| return -EINVAL; |
| } |
| |
| 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 uint8_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 */ |
| |
| /* |
| * Package the data from the fw diag WMI event handler. |
| * Pass this data to cnss-diag service |
| */ |
| int |
| send_fw_diag_nl_data(wmi_unified_t wmi_handle, const uint8_t *buffer, |
| A_UINT32 len, A_UINT32 event_type) |
| { |
| struct sk_buff *skb_out; |
| struct nlmsghdr *nlh; |
| int res = 0; |
| |
| if (WARN_ON(len > ATH6KL_FWLOG_PAYLOAD_SIZE)) |
| return -ENODEV; |
| |
| if (nl_srv_is_initialized() != 0) |
| return -EIO; |
| |
| if (cds_is_multicast_logging()) { |
| skb_out = nlmsg_new(len, 0); |
| 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, len, 0); |
| memcpy(nlmsg_data(nlh), buffer, len); |
| |
| res = nl_srv_bcast(skb_out); |
| if (res < 0) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_RSVD1, |
| ("%s: nl_srv_bcast failed 0x%x\n", |
| __func__, res)); |
| return res; |
| } |
| } |
| return res; |
| } |
| |
| static int |
| send_diag_netlink_data(const uint8_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; |
| |
| if (WARN_ON(len > ATH6KL_FWLOG_PAYLOAD_SIZE)) |
| return -ENODEV; |
| |
| if (nl_srv_is_initialized() != 0) |
| return -EIO; |
| |
| if (cds_is_multicast_logging()) { |
| slot_len = sizeof(*slot) + ATH6KL_FWLOG_PAYLOAD_SIZE; |
| |
| skb_out = nlmsg_new(slot_len, 0); |
| 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); |
| slot = (struct dbglog_slot *)nlmsg_data(nlh); |
| 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(skb_out); |
| if (res < 0) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_RSVD1, |
| ("%s: nl_srv_bcast failed 0x%x\n", |
| __func__, res)); |
| return res; |
| } |
| } |
| return res; |
| } |
| |
| int |
| dbglog_process_netlink_data(wmi_unified_t wmi_handle, const uint8_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; |
| |
| if (WARN_ON(len > ATH6KL_FWLOG_PAYLOAD_SIZE)) |
| return -ENODEV; |
| |
| if (nl_srv_is_initialized() != 0) |
| return -EIO; |
| |
| if (cds_is_multicast_logging()) { |
| slot_len = sizeof(*slot) + ATH6KL_FWLOG_PAYLOAD_SIZE; |
| |
| skb_out = nlmsg_new(slot_len, 0); |
| 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); |
| slot = (struct dbglog_slot *)nlmsg_data(nlh); |
| 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(skb_out); |
| if (res < 0) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_RSVD1, |
| ("%s: nl_srv_ucast 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, uint8_t *data, uint32_t datalen) |
| { |
| |
| tp_wma_handle wma = (tp_wma_handle) scn; |
| wmitlv_cmd_param_info *param_buf; |
| uint8_t *datap; |
| uint32_t len = 0; |
| uint32_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 = (wmitlv_cmd_param_info *) data; |
| if (!param_buf) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, |
| ("Get NULL point message from FW\n")); |
| return -1; |
| } |
| |
| param_buf = (wmitlv_cmd_param_info *) data; |
| datap = param_buf->tlv_ptr; |
| len = param_buf->num_elements; |
| if (!get_version) { |
| buffer = (uint32_t *) datap; |
| buffer++; /* skip offset */ |
| if (WLAN_DIAG_TYPE_CONFIG == DIAG_GET_TYPE(*buffer)) { |
| buffer++; /* skip */ |
| if (DIAG_VERSION_INFO == DIAG_GET_ID(*buffer)) { |
| 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; |
| } |
| |
| /* |
| * WMI diag data event handler, this function invoked as a CB |
| * when there DIAG_DATA to be forwarded from the FW. |
| */ |
| |
| int fw_diag_data_event_handler(ol_scn_t scn, uint8_t *data, uint32_t datalen) |
| { |
| |
| tp_wma_handle wma = (tp_wma_handle) scn; |
| struct wlan_diag_data *diag_data; |
| WMI_DIAG_DATA_CONTAINER_EVENTID_param_tlvs *param_buf; |
| wmi_diag_data_container_event_fixed_param *fixed_param; |
| uint8_t *datap; |
| uint32_t num_data = 0; /* Total events */ |
| uint32_t diag_data_len = 0; /* each fw diag payload */ |
| uint32_t diag_type = 0; |
| uint32_t i = 0; |
| uint32_t nl_data_len = 0; /* diag hdr + payload */ |
| |
| 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; |
| } |
| |
| if (!wma) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("NULL Pointer assigned\n")); |
| return -1; |
| } |
| |
| fixed_param = param_buf->fixed_param; |
| num_data = param_buf->num_bufp; |
| |
| datap = (uint8_t *) param_buf->bufp; |
| |
| /* If cnss-diag service started triggered during the init of services */ |
| if (appstarted) { |
| for (i = 0; i < num_data; i++) { |
| 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 0 |
| print_hex_dump_bytes("payload: ", DUMP_PREFIX_ADDRESS, |
| diag_data->payload, diag_data_len); |
| #endif |
| switch (diag_type) { |
| case DIAG_TYPE_FW_EVENT: |
| return send_fw_diag_nl_data((wmi_unified_t) |
| wma->wmi_handle, |
| datap, nl_data_len, |
| diag_type); |
| break; |
| case DIAG_TYPE_FW_LOG: |
| return send_fw_diag_nl_data((wmi_unified_t) |
| wma->wmi_handle, |
| datap, nl_data_len, |
| diag_type); |
| break; |
| } |
| /* Move to the next event and send to cnss-diag */ |
| datap += nl_data_len; |
| } |
| } |
| return 0; |
| } |
| |
| int dbglog_parse_debug_logs(ol_scn_t scn, uint8_t *data, uint32_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; |
| qdf_size_t length; |
| A_UINT32 dropped; |
| WMI_DEBUG_MESG_EVENTID_param_tlvs *param_buf; |
| uint8_t *datap; |
| uint32_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_INFO, |
| ("%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) { |
| if (appstarted) { |
| return dbglog_process_netlink_data((wmi_unified_t) wma-> |
| wmi_handle, |
| (A_UINT8 *) buffer, |
| len, dropped); |
| } else { |
| return 0; |
| } |
| |
| } |
| #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, QDF_ARRAY_SIZE(states), events, |
| QDF_ARRAY_SIZE(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 < QDF_ARRAY_SIZE(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, |
| QDF_ARRAY_SIZE(nw_states), events, |
| QDF_ARRAY_SIZE(events)); |
| break; |
| case WLAN_IBSS_PS_SUB_MODULE_IBSS_SELF_PS: |
| dbglog_sm_print(timestamp, vap_id, numargs, args, |
| "IBSS PS Self", ps_states, |
| QDF_ARRAY_SIZE(ps_states), events, |
| QDF_ARRAY_SIZE(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, |
| QDF_ARRAY_SIZE(peer_ps_states), events, |
| QDF_ARRAY_SIZE(events)); |
| break; |
| default: |
| break; |
| } |
| break; |
| case IBSS_PS_DBGID_PEER_CREATE: |
| if (numargs == 2) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: peer alloc failed for peer ID:%u", |
| args[0]); |
| } else if (numargs == 1) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: create peer ID=%u", args[0]); |
| } |
| break; |
| case IBSS_PS_DBGID_PEER_DELETE: |
| if (numargs == 4) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: delete peer ID=%u num_peers:%d num_sleeping_peers:%d ps_enabled_for_this_peer:%d", |
| args[0], args[1], args[2], args[3]); |
| } |
| break; |
| case IBSS_PS_DBGID_VDEV_CREATE: |
| if (numargs == 1) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: vdev alloc failed", args[0]); |
| } else if (numargs == 0) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: vdev created"); |
| } |
| break; |
| case IBSS_PS_DBGID_VDEV_DELETE: |
| dbglog_printf(timestamp, vap_id, "IBSS PS: vdev deleted"); |
| break; |
| |
| case IBSS_PS_DBGID_VDEV_EVENT: |
| if (numargs == 1) { |
| if (args[0] == 5) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: vdev event for peer add"); |
| } else if (args[0] == 7) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: vdev event for peer delete"); |
| } else { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: vdev event %u", |
| args[0]); |
| } |
| } |
| break; |
| |
| case IBSS_PS_DBGID_PEER_EVENT: |
| if (numargs == 4) { |
| if (args[0] == 0xFFFF) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: pre_send for peer:%u peer_type:%u sm_event_mask:%0x", |
| args[1], args[3], args[2]); |
| } else if (args[0] == 0x20000) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: send_complete for peer:%u peer_type:%u sm_event_mask:%0x", |
| args[1], args[3], args[2]); |
| } else if (args[0] == 0x10) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: send_n_complete for peer:%u peer_type:%u sm_event_mask:%0x", |
| args[1], args[3], args[2]); |
| } else if (args[0] == 0x40) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: rx event for peer:%u peer_type:%u sm_event_mask:%0x", |
| args[1], args[3], args[2]); |
| } else if (args[0] == 0x4) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: hw_q_empty for peer:%u peer_type:%u sm_event_mask:%0x", |
| args[1], args[3], args[2]); |
| } |
| } |
| break; |
| |
| case IBSS_PS_DBGID_DELIVER_CAB: |
| if (numargs == 4) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: Deliver CAB n_mpdu:%d send_flags:%0x tid_cur:%d q_depth_for_other_tid:%d", |
| args[0], args[1], args[2], args[3]); |
| } |
| break; |
| |
| case IBSS_PS_DBGID_DELIVER_UC_DATA: |
| if (numargs == 4) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: Deliver UC data peer:%d tid:%d n_mpdu:%d send_flags:%0x", |
| args[0], args[1], args[2], args[3]); |
| } |
| break; |
| |
| case IBSS_PS_DBGID_DELIVER_UC_DATA_ERROR: |
| if (numargs == 4) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: Deliver UC data error peer:%d tid:%d allowed_tidmask:%0x, pending_tidmap:%0x", |
| args[0], args[1], args[2], args[3]); |
| } |
| break; |
| |
| case IBSS_PS_DBGID_UC_INACTIVITY_TMR_RESTART: |
| if (numargs == 2) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: UC timer restart peer:%d timer_val:%0x", |
| args[0], args[1]); |
| } |
| break; |
| |
| case IBSS_PS_DBGID_MC_INACTIVITY_TMR_RESTART: |
| if (numargs == 1) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: MC timer restart timer_val:%0x", |
| args[0]); |
| } |
| break; |
| |
| case IBSS_PS_DBGID_NULL_TX_COMPLETION: |
| if (numargs == 3) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: null tx completion peer:%d tx_completion_status:%d flags:%0x", |
| args[0], args[1], args[2]); |
| } |
| break; |
| |
| case IBSS_PS_DBGID_ATIM_TIMER_START: |
| if (numargs == 4) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: ATIM timer start tsf:%0x %0x tbtt:%0x %0x", |
| args[0], args[1], args[2], args[3]); |
| } |
| break; |
| |
| case IBSS_PS_DBGID_UC_ATIM_SEND: |
| if (numargs == 2) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: Send ATIM to peer:%d", args[1]); |
| } else if (numargs == 1) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: no peers to send UC ATIM", |
| args[1]); |
| } |
| break; |
| |
| case IBSS_PS_DBGID_BC_ATIM_SEND: |
| if (numargs == 2) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: MC Data, num_of_peers:%d bc_atim_sent:%d", |
| args[1], args[0]); |
| } |
| break; |
| |
| case IBSS_PS_DBGID_UC_TIMEOUT: |
| if (numargs == 2) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: UC timeout for peer:%d send_null:%d", |
| args[0], args[1]); |
| } |
| break; |
| |
| case IBSS_PS_DBGID_PWR_COLLAPSE_ALLOWED: |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: allow power collapse"); |
| break; |
| |
| case IBSS_PS_DBGID_PWR_COLLAPSE_NOT_ALLOWED: |
| if (numargs == 0) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: power collapse not allowed by INI"); |
| } else if (numargs == 1) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: power collapse not allowed since peer id:%d is not PS capable", |
| args[0]); |
| } else if (numargs == 2) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: power collapse not allowed - no peers in NW"); |
| } else if (numargs == 3) { |
| if (args[0] == 2) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: power collapse not allowed, non-zero qdepth %d %d", |
| args[1], args[2]); |
| } else if (args[0] == 3) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: power collapse not allowed by peer:%d peer_flags:%0x", |
| args[1], args[2]); |
| } |
| } else if (numargs == 5) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: power collapse not allowed by state m/c nw_cur_state:%d nw_next_state:%d ps_cur_state:%d flags:%0x", |
| args[1], args[2], args[3], args[4]); |
| } |
| break; |
| |
| case IBSS_PS_DBGID_SET_PARAM: |
| if (numargs == 2) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: Set Param ID:%0x Value:%0x", |
| args[0], args[1]); |
| } |
| break; |
| |
| case IBSS_PS_DBGID_HOST_TX_PAUSE: |
| if (numargs == 1) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: Pausing host, vdev_map:%0x", |
| args[0]); |
| } |
| break; |
| |
| case IBSS_PS_DBGID_HOST_TX_UNPAUSE: |
| if (numargs == 1) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: Unpausing host, vdev_map:%0x", |
| args[0]); |
| } |
| break; |
| case IBSS_PS_DBGID_PS_DESC_BIN_LWM: |
| if (numargs == 1) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: LWM, vdev_map:%0x", args[0]); |
| } |
| break; |
| |
| case IBSS_PS_DBGID_PS_DESC_BIN_HWM: |
| if (numargs == 1) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: HWM, vdev_map:%0x", args[0]); |
| } |
| break; |
| |
| case IBSS_PS_DBGID_PS_KICKOUT_PEER: |
| if (numargs == 3) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: Kickout peer id:%d atim_fail_cnt:%d status:%d", |
| args[0], args[1], args[2]); |
| } |
| break; |
| |
| case IBSS_PS_DBGID_SET_PEER_PARAM: |
| if (numargs == 3) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: Set Peer Id:%d Param ID:%0x Value:%0x", |
| args[0], args[1], args[2]); |
| } |
| break; |
| |
| case IBSS_PS_DBGID_BCN_ATIM_WIN_MISMATCH: |
| if (numargs == 4) { |
| if (args[0] == 0xDEAD) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: ATIM window length mismatch, our's:%d, peer id:%d, peer's:%d", |
| args[1], args[2], args[3]); |
| } else if (args[0] == 0xBEEF) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: Peer ATIM window length changed, peer id:%d, peer recorded atim window:%d new atim window:%d", |
| args[1], args[2], args[3]); |
| } |
| } |
| break; |
| |
| case IBSS_PS_DBGID_RX_CHAINMASK_CHANGE: |
| if (numargs == 2) { |
| if (args[1] == 0x1) { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: Voting for low power chainmask from :%d", |
| args[0]); |
| } else { |
| dbglog_printf(timestamp, vap_id, |
| "IBSS PS: Voting for high power chainmask from :%d", |
| args[0]); |
| } |
| } |
| break; |
| |
| default: |
| return false; |
| } |
| |
| return true; |
| } |
| |
| A_BOOL dbglog_ratectrl_print_handler(A_UINT32 mod_id, |
| A_UINT16 vap_id, |
| A_UINT32 dbg_id, |
| A_UINT32 timestamp, |
| A_UINT16 numargs, A_UINT32 *args) |
| { |
| switch (dbg_id) { |
| case RATECTRL_DBGID_ASSOC: |
| dbglog_printf(timestamp, vap_id, |
| "RATE: ChainMask %d, phymode %d, ni_flags 0x%08x, vht_mcs_set 0x%04x, ht_mcs_set 0x%04x", |
| args[0], args[1], args[2], args[3], args[4]); |
| break; |
| case RATECTRL_DBGID_NSS_CHANGE: |
| dbglog_printf(timestamp, vap_id, "RATE: NEW NSS %d\n", args[0]); |
| break; |
| case RATECTRL_DBGID_CHAINMASK_ERR: |
| dbglog_printf(timestamp, vap_id, |
| "RATE: Chainmask ERR %d %d %d\n", args[0], |
| args[1], args[2]); |
| break; |
| case RATECTRL_DBGID_UNEXPECTED_FRAME: |
| dbglog_printf(timestamp, vap_id, |
| "RATE: WARN1: rate %d flags 0x%08x\n", args[0], |
| args[1]); |
| break; |
| case RATECTRL_DBGID_WAL_RCQUERY: |
| dbglog_printf(timestamp, vap_id, |
| "ratectrl_dbgid_wal_rcquery [rix1 %d rix2 %d rix3 %d proberix %d ppduflag 0x%x] ", |
| args[0], args[1], args[2], args[3], args[4]); |
| break; |
| case RATECTRL_DBGID_WAL_RCUPDATE: |
| dbglog_printf(timestamp, vap_id, |
| "ratectrl_dbgid_wal_rcupdate [numelems %d ppduflag 0x%x] ", |
| args[0], args[1]); |
| break; |
| case RATECTRL_DBGID_GTX_UPDATE: |
| { |
| switch (args[0]) { |
| case 255: |
| dbglog_printf(timestamp, vap_id, |
| "GtxInitPwrCfg [bw[last %d|cur %d] rtcode 0x%x tpc %d tpc_init_pwr_cfg %d] ", |
| args[1] >> 8, args[1] & 0xff, |
| args[2], args[3], args[4]); |
| break; |
| case 254: |
| dbglog_printf(timestamp, vap_id, |
| "gtx_cfg_addr [RTMask0@0x%x PERThreshold@0x%x gtxTPCMin@0x%x userGtxMask@0x%x] ", |
| args[1], args[2], args[3], |
| args[4]); |
| break; |
| default: |
| dbglog_printf(timestamp, vap_id, |
| "gtx_update [act %d bw %d rix 0x%x tpc %d per %d lastrssi %d] ", |
| args[0], args[1], args[2], |
| args[3], args[4], args[5]); |
| } |
| } |
| break; |
| } |
| return true; |
| } |
| |
| A_BOOL dbglog_ani_print_handler(A_UINT32 mod_id, |
| A_UINT16 vap_id, |
| A_UINT32 dbg_id, |
| A_UINT32 timestamp, |
| A_UINT16 numargs, A_UINT32 *args) |
| { |
| switch (dbg_id) { |
| case ANI_DBGID_ENABLE: |
| dbglog_printf(timestamp, vap_id, "ANI Enable: %d", args[0]); |
| break; |
| case ANI_DBGID_POLL: |
| dbglog_printf(timestamp, vap_id, |
| "ANI POLLING: AccumListenTime %d ListenTime %d ofdmphyerr %d cckphyerr %d", |
| args[0], args[1], args[2], args[3]); |
| break; |
| case ANI_DBGID_RESTART: |
| dbglog_printf(timestamp, vap_id, "ANI Restart"); |
| break; |
| case ANI_DBGID_CURRENT_LEVEL: |
| dbglog_printf(timestamp, vap_id, |
| "ANI CURRENT LEVEL ofdm level %d cck level %d", |
| args[0], args[1]); |
| break; |
| case ANI_DBGID_OFDM_LEVEL: |
| dbglog_printf(timestamp, vap_id, |
| "ANI UPDATE ofdm level %d firstep %d firstep_low %d cycpwr_thr %d self_corr_low %d", |
| args[0], args[1], args[2], args[3], args[4]); |
| break; |
| case ANI_DBGID_CCK_LEVEL: |
| dbglog_printf(timestamp, vap_id, |
| "ANI UPDATE cck level %d firstep %d firstep_low %d mrc_cck %d", |
| args[0], args[1], args[2], args[3]); |
| break; |
| case ANI_DBGID_CONTROL: |
| dbglog_printf(timestamp, vap_id, |
| "ANI CONTROL ofdmlevel %d ccklevel %d\n", |
| args[0]); |
| |
| break; |
| case ANI_DBGID_OFDM_PARAMS: |
| dbglog_printf(timestamp, vap_id, |
| "ANI ofdm_control firstep %d cycpwr %d\n", |
| args[0], args[1]); |
| break; |
| case ANI_DBGID_CCK_PARAMS: |
| dbglog_printf(timestamp, vap_id, |
| "ANI cck_control mrc_cck %d barker_threshold %d\n", |
| args[0], args[1]); |
| break; |
| case ANI_DBGID_RESET: |
| dbglog_printf(timestamp, vap_id, |
| "ANI resetting resetflag %d resetCause %8x channel index %d", |
| args[0], args[1], args[2]); |
| break; |
| case ANI_DBGID_SELF_CORR_LOW: |
| dbglog_printf(timestamp, vap_id, "ANI self_corr_low %d", |
| args[0]); |
| break; |
| case ANI_DBGID_FIRSTEP: |
| dbglog_printf(timestamp, vap_id, |
| "ANI firstep %d firstep_low %d", args[0], |
| args[1]); |
| break; |
| case ANI_DBGID_MRC_CCK: |
| dbglog_printf(timestamp, vap_id, "ANI mrc_cck %d", args[0]); |
| break; |
| case ANI_DBGID_CYCPWR: |
| dbglog_printf(timestamp, vap_id, "ANI cypwr_thresh %d", |
| args[0]); |
| break; |
| case ANI_DBGID_POLL_PERIOD: |
| dbglog_printf(timestamp, vap_id, |
| "ANI Configure poll period to %d", args[0]); |
| break; |
| case ANI_DBGID_LISTEN_PERIOD: |
| dbglog_printf(timestamp, vap_id, |
| "ANI Configure listen period to %d", args[0]); |
| break; |
| case ANI_DBGID_OFDM_LEVEL_CFG: |
| dbglog_printf(timestamp, vap_id, |
| "ANI Configure ofdm level to %d", args[0]); |
| break; |
| case ANI_DBGID_CCK_LEVEL_CFG: |
| dbglog_printf(timestamp, vap_id, |
| "ANI Configure cck level to %d", args[0]); |
| break; |
| default: |
| dbglog_printf(timestamp, vap_id, "ANI arg1 %d arg2 %d arg3 %d", |
| args[0], args[1], args[2]); |
| break; |
| } |
| return true; |
| } |
| |
| A_BOOL |
| dbglog_ap_powersave_print_handler(A_UINT32 mod_id, |
| A_UINT16 vap_id, |
| A_UINT32 dbg_id, |
| A_UINT32 timestamp, |
| A_UINT16 numargs, A_UINT32 *args) |
| { |
| switch (dbg_id) { |
| case AP_PS_DBGID_UPDATE_TIM: |
| if (numargs == 2) { |
| dbglog_printf(timestamp, vap_id, |
| "AP PS: TIM update AID=%u %s", |
| args[0], args[1] ? "set" : "clear"); |
| } |
| break; |
| case AP_PS_DBGID_PEER_STATE_CHANGE: |
| if (numargs == 2) { |
| dbglog_printf(timestamp, vap_id, |
| "AP PS: AID=%u power save %s", |
| args[0], |
| args[1] ? "enabled" : "disabled"); |
| } |
| break; |
| case AP_PS_DBGID_PSPOLL: |
| if (numargs == 3) { |
| dbglog_printf(timestamp, vap_id, |
| "AP PS: AID=%u pspoll response tid=%u flags=%x", |
| args[0], args[1], args[2]); |
| } |
| break; |
| case AP_PS_DBGID_PEER_CREATE: |
| if (numargs == 1) { |
| dbglog_printf(timestamp, vap_id, |
| "AP PS: create peer AID=%u", args[0]); |
| } |
| break; |
| case AP_PS_DBGID_PEER_DELETE: |
| if (numargs == 1) { |
| dbglog_printf(timestamp, vap_id, |
| "AP PS: delete peer AID=%u", args[0]); |
| } |
| break; |
| case AP_PS_DBGID_VDEV_CREATE: |
| dbglog_printf(timestamp, vap_id, "AP PS: vdev create"); |
| break; |
| case AP_PS_DBGID_VDEV_DELETE: |
| dbglog_printf(timestamp, vap_id, "AP PS: vdev delete"); |
| break; |
| case AP_PS_DBGID_SYNC_TIM: |
| if (numargs == 3) { |
| dbglog_printf(timestamp, vap_id, |
| "AP PS: AID=%u advertised=%#x buffered=%#x", |
| args[0], args[1], args[2]); |
| } |
| break; |
| case AP_PS_DBGID_NEXT_RESPONSE: |
| if (numargs == 4) { |
| dbglog_printf(timestamp, vap_id, |
| "AP PS: AID=%u select next response %s%s%s", |
| args[0], args[1] ? "(usp active) " : "", |
| args[2] ? "(pending usp) " : "", |
| args[3] ? "(pending poll response)" : ""); |
| } |
| break; |
| case AP_PS_DBGID_START_SP: |
| if (numargs == 3) { |
| dbglog_printf(timestamp, vap_id, |
| "AP PS: AID=%u START SP tsf=%#x (%u)", |
| args[0], args[1], args[2]); |
| } |
| break; |
| case AP_PS_DBGID_COMPLETED_EOSP: |
| if (numargs == 3) { |
| dbglog_printf(timestamp, vap_id, |
| "AP PS: AID=%u EOSP eosp_tsf=%#x trigger_tsf=%#x", |
| args[0], args[1], args[2]); |
| } |
| break; |
| case AP_PS_DBGID_TRIGGER: |
| if (numargs == 4) { |
| dbglog_printf(timestamp, vap_id, |
| "AP PS: AID=%u TRIGGER tsf=%#x %s%s", |
| args[0], args[1], |
| args[2] ? "(usp active) " : "", |
| args[3] ? "(send_n in progress)" : ""); |
| } |
| break; |
| case AP_PS_DBGID_DUPLICATE_TRIGGER: |
| if (numargs == 4) { |
| dbglog_printf(timestamp, vap_id, |
| "AP PS: AID=%u DUP TRIGGER tsf=%#x seq=%u ac=%u", |
| args[0], args[1], args[2], args[3]); |
| } |
| break; |
| case AP_PS_DBGID_UAPSD_RESPONSE: |
| if (numargs == 5) { |
| dbglog_printf(timestamp, vap_id, |
| "AP PS: AID=%u UAPSD response tid=%u, n_mpdu=%u flags=%#x max_sp=%u current_sp=%u", |
| args[0], args[1], args[2], args[3], |
| (args[4] >> 16) & 0xffff, |
| args[4] & 0xffff); |
| } |
| break; |
| case AP_PS_DBGID_SEND_COMPLETE: |
| if (numargs == 5) { |
| dbglog_printf(timestamp, vap_id, |
| "AP PS: AID=%u SEND_COMPLETE fc=%#x qos=%#x %s%s", |
| args[0], args[1], args[2], |
| args[3] ? "(usp active) " : "", |
| args[4] ? "(pending poll response)" : ""); |
| } |
| break; |
| case AP_PS_DBGID_SEND_N_COMPLETE: |
| if (numargs == 3) { |
| dbglog_printf(timestamp, vap_id, |
| "AP PS: AID=%u SEND_N_COMPLETE %s%s", |
| args[0], |
| args[1] ? "(usp active) " : "", |
| args[2] ? "(pending poll response)" : ""); |
| } |
| break; |
| case AP_PS_DBGID_DETECT_OUT_OF_SYNC_STA: |
| if (numargs == 4) { |
| dbglog_printf(timestamp, vap_id, |
| "AP PS: AID=%u detected out-of-sync now=%u tx_waiting=%u txq_depth=%u", |
| args[0], args[1], args[2], args[3]); |
| } |
| break; |
| case AP_PS_DBGID_DELIVER_CAB: |
| if (numargs == 4) { |
| dbglog_printf(timestamp, vap_id, |
| "AP PS: CAB %s n_mpdus=%u, flags=%x, extra=%u", |
| (args[0] == 17) ? "MGMT" : "DATA", |
| args[1], args[2], args[3]); |
| } |
| break; |
| default: |
| return false; |
| } |
| |
| return true; |
| } |
| |
| A_BOOL |
| dbglog_wal_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[] = { |
| "ACTIVE", |
| "WAIT", |
| "WAIT_FILTER", |
| "PAUSE", |
| "PAUSE_SEND_N", |
| "BLOCK", |
| }; |
| |
| static const char *events[] = { |
| "PAUSE", |
| "PAUSE_FILTER", |
| "UNPAUSE", |
| |
| "BLOCK", |
| "BLOCK_FILTER", |
| "UNBLOCK", |
| |
| "HWQ_EMPTY", |
| "ALLOW_N", |
| }; |
| |
| #define WAL_VDEV_TYPE(type) \ |
| (type == 0 ? "AP" : \ |
| (type == 1 ? "STA" : \ |
| (type == 2 ? "IBSS" : \ |
| (type == 2 ? "MONITOR" : \ |
| "UNKNOWN")))) |
| |
| #define WAL_SLEEP_STATE(state) \ |
| (state == 1 ? "NETWORK SLEEP" : \ |
| (state == 2 ? "AWAKE" : \ |
| (state == 3 ? "SYSTEM SLEEP" : \ |
| "UNKNOWN"))) |
| |
| switch (dbg_id) { |
| case DBGLOG_DBGID_SM_FRAMEWORK_PROXY_DBGLOG_MSG: |
| dbglog_sm_print(timestamp, vap_id, numargs, args, "TID PAUSE", |
| states, QDF_ARRAY_SIZE(states), events, |
| QDF_ARRAY_SIZE(events)); |
| break; |
| case WAL_DBGID_SET_POWER_STATE: |
| if (numargs == 3) { |
| dbglog_printf(timestamp, vap_id, |
| "WAL %s => %s, req_count=%u", |
| WAL_SLEEP_STATE(args[0]), |
| WAL_SLEEP_STATE(args[1]), args[2]); |
| } |
| break; |
| case WAL_DBGID_CHANNEL_CHANGE_FORCE_RESET: |
| if (numargs == 4) { |
| dbglog_printf(timestamp, vap_id, |
| "WAL channel change (force reset) freq=%u, flags=%u mode=%u rx_ok=%u tx_ok=%u", |
| args[0] & 0x0000ffff, |
| (args[0] & 0xffff0000) >> 16, args[1], |
| args[2], args[3]); |
| } |
| break; |
| case WAL_DBGID_CHANNEL_CHANGE: |
| if (numargs == 2) { |
| dbglog_printf(timestamp, vap_id, |
| "WAL channel change freq=%u, mode=%u flags=%u rx_ok=1 tx_ok=1", |
| args[0] & 0x0000ffff, |
| (args[0] & 0xffff0000) >> 16, args[1]); |
| } |
| break; |
| case WAL_DBGID_VDEV_START: |
| if (numargs == 1) { |
| dbglog_printf(timestamp, vap_id, "WAL %s vdev started", |
| WAL_VDEV_TYPE(args[0])); |
| } |
| break; |
| case WAL_DBGID_VDEV_STOP: |
| dbglog_printf(timestamp, vap_id, "WAL %s vdev stopped", |
| WAL_VDEV_TYPE(args[0])); |
| break; |
| case WAL_DBGID_VDEV_UP: |
| dbglog_printf(timestamp, vap_id, "WAL %s vdev up, count=%u", |
| WAL_VDEV_TYPE(args[0]), args[1]); |
| break; |
| case WAL_DBGID_VDEV_DOWN: |
| dbglog_printf(timestamp, vap_id, "WAL %s vdev down, count=%u", |
| WAL_VDEV_TYPE(args[0]), args[1]); |
| break; |
| case WAL_DBGID_TX_MGMT_DESCID_SEQ_TYPE_LEN: |
| dbglog_printf(timestamp, vap_id, |
| "WAL Tx Mgmt frame desc_id=0x%x, seq=0x%x, type=0x%x, len=0x%x islocal=0x%x", |
| args[0], args[1], args[2], |
| (args[3] & 0xffff0000) >> 16, |
| args[3] & 0x0000ffff); |
| break; |
| case WAL_DBGID_TX_MGMT_COMP_DESCID_STATUS: |
| dbglog_printf(timestamp, vap_id, |
| "WAL Tx Mgmt frame completion desc_id=0x%x, status=0x%x, islocal=0x%x", |
| args[0], args[1], args[2]); |
| break; |
| case WAL_DBGID_TX_DATA_MSDUID_SEQ_TYPE_LEN: |
| dbglog_printf(timestamp, vap_id, |
| "WAL Tx Data frame msdu_id=0x%x, seq=0x%x, type=0x%x, len=0x%x", |
| args[0], args[1], args[2], args[3]); |
| break; |
| case WAL_DBGID_TX_DATA_COMP_MSDUID_STATUS: |
| dbglog_printf(timestamp, vap_id, |
| "WAL Tx Data frame completion desc_id=0x%x, status=0x%x, seq=0x%x", |
| args[0], args[1], args[2]); |
| break; |
| case WAL_DBGID_RESET_PCU_CYCLE_CNT: |
| dbglog_printf(timestamp, vap_id, |
| "WAL PCU cycle counter value at reset:%x", |
| args[0]); |
| break; |
| case WAL_DBGID_TX_DISCARD: |
| dbglog_printf(timestamp, vap_id, |
| "WAL Tx enqueue discard msdu_id=0x%x", args[0]); |
| break; |
| case WAL_DBGID_SET_HW_CHAINMASK: |
| dbglog_printf(timestamp, vap_id, "WAL_DBGID_SET_HW_CHAINMASK " |
| "pdev=%d, txchain=0x%x, rxchain=0x%x", |
| args[0], args[1], args[2]); |
| break; |
| case WAL_DBGID_SET_HW_CHAINMASK_TXRX_STOP_FAIL: |
| dbglog_printf(timestamp, vap_id, |
| "WAL_DBGID_SET_HW_CHAINMASK_TXRX_STOP_FAIL rxstop=%d, txstop=%d", |
| args[0], args[1]); |
| break; |
| case WAL_DBGID_GET_HW_CHAINMASK: |
| dbglog_printf(timestamp, vap_id, "WAL_DBGID_GET_HW_CHAINMASK " |
| "txchain=0x%x, rxchain=0x%x", args[0], args[1]); |
| break; |
| case WAL_DBGID_SMPS_DISABLE: |
| dbglog_printf(timestamp, vap_id, "WAL_DBGID_SMPS_DISABLE"); |
| break; |
| case WAL_DBGID_SMPS_ENABLE_HW_CNTRL: |
| dbglog_printf(timestamp, vap_id, |
| "WAL_DBGID_SMPS_ENABLE_HW_CNTRL low_pwr_mask=0x%x, high_pwr_mask=0x%x", |
| args[0], args[1]); |
| break; |
| case WAL_DBGID_SMPS_SWSEL_CHAINMASK: |
| dbglog_printf(timestamp, vap_id, |
| "WAL_DBGID_SMPS_SWSEL_CHAINMASK low_pwr=0x%x, chain_mask=0x%x", |
| args[0], args[1]); |
| break; |
| default: |
| return false; |
| } |
| |
| return true; |
| } |
| |
| A_BOOL |
| dbglog_scan_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", |
| "BSSCHAN", |
| "WAIT_FOREIGN_CHAN", |
| "FOREIGN_CHANNEL", |
| "TERMINATING" |
| }; |
| |
| static const char *events[] = { |
| "REQ", |
| "STOP", |
| "BSSCHAN", |
| "FOREIGN_CHAN", |
| "CHECK_ACTIVITY", |
| "REST_TIME_EXPIRE", |
| "DWELL_TIME_EXPIRE", |
| "PROBE_TIME_EXPIRE", |
| }; |
| |
| switch (dbg_id) { |
| case DBGLOG_DBGID_SM_FRAMEWORK_PROXY_DBGLOG_MSG: |
| dbglog_sm_print(timestamp, vap_id, numargs, args, "SCAN", |
| states, QDF_ARRAY_SIZE(states), events, |
| QDF_ARRAY_SIZE(events)); |
| break; |
| default: |
| return false; |
| } |
| |
| return true; |
| } |
| |
| A_BOOL dbglog_coex_print_handler(A_UINT32 mod_id, |
| A_UINT16 vap_id, |
| A_UINT32 dbg_id, |
| A_UINT32 timestamp, |
| A_UINT16 numargs, A_UINT32 *args) |
| { |
| A_UINT8 i; |
| char *dbg_id_str; |
| |
| static const char *wlan_rx_xput_status[] = { |
| "WLAN_XPUT_NORMAL", |
| "WLAN_XPUT_UNDER_THRESH", |
| "WLAN_XPUT_CRITICAL", |
| "WLAN_XPUT_RECOVERY_TIMEOUT", |
| }; |
| |
| static const char *coex_sched_req[] = { |
| "SCHED_REQ_NEXT", |
| "SCHED_REQ_BT", |
| "SCHED_REQ_WLAN", |
| "SCHED_REQ_POSTPAUSE", |
| "SCHED_REQ_UNPAUSE", |
| }; |
| |
| static const char *coex_sched_type[] = { |
| "SCHED_NONE", |
| "SCHED_WLAN", |
| "SCHED_BT", |
| "SCHED_WLAN_PAUSE", |
| "SCHED_WLAN_POSTPAUSE", |
| "SCHED_WLAN_UNPAUSE", |
| "COEX_SCHED_MWS", |
| }; |
| |
| static const char *coex_trf_mgmt_type[] = { |
| "TRF_MGMT_FREERUN", |
| "TRF_MGMT_SHAPE_PM", |
| "TRF_MGMT_SHAPE_PSP", |
| "TRF_MGMT_SHAPE_S_CTS", |
| "TRF_MGMT_SHAPE_OCS", |
| "TRF_MGMT_SHAPE_FIXED_TIME", |
| "TRF_MGMT_SHAPE_NOA", |
| "TRF_MGMT_SHAPE_OCS_CRITICAL", |
| "TRF_MGMT_NONE", |
| }; |
| |
| static const char *coex_system_status[] = { |
| "ALL_OFF", |
| "BTCOEX_NOT_REQD", |
| "WLAN_IS_IDLE", |
| "EXECUTE_SCHEME", |
| "BT_FULL_CONCURRENCY", |
| "WLAN_SLEEPING", |
| "WLAN_IS_PAUSED", |
| "WAIT_FOR_NEXT_ACTION", |
| "SOC_WAKE", |
| }; |
| |
| static const char *wlan_rssi_type[] = { |
| "LOW_RSSI", |
| "MID_RSSI", |
| "HI_RSSI", |
| "INVALID_RSSI", |
| }; |
| |
| static const char *coex_bt_scheme[] = { |
| "IDLE_CTRL", |
| "ACTIVE_ASYNC_CTRL", |
| "PASSIVE_SYNC_CTRL", |
| "ACTIVE_SYNC_CTRL", |
| "DEFAULT_CTRL", |
| "CONCURRENCY_CTRL", |
| }; |
| |
| static const char *wal_peer_rx_rate_stats_event_sent[] = { |
| "PR_RX_EVT_SENT_NONE", |
| "PR_RX_EVT_SENT_LOWER", |
| "PR_RX_EVT_SENT_UPPER", |
| }; |
| |
| static const char *wlan_psp_stimulus[] = { |
| "ENTRY", |
| "EXIT", |
| "PS_READY", |
| "PS_NOT_READY", |
| "RX_MORE_DATA_RCVD", |
| "RX_NO_MORE_DATA_RCVD", |
| "TX_DATA_COMPLT", |
| "TX_COMPLT", |
| "TIM_SET", |
| "REQ", |
| "DONE_SUCCESS", |
| "DONE_NO_PS_POLL_ACK", |
| "DONE_RESPONSE_TMO", |
| "DONE_DROPPED", |
| "DONE_FILTERED", |
| "WLAN_START", |
| "NONWLAN_START", |
| "NONWLAN_INTVL_UPDATE", |
| "NULL_TX", |
| "NULL_TX_COMPLT", |
| "BMISS_FIRST", |
| "NULL_TX_FAIL", |
| "RX_NO_MORE_DATA_DATAFRM", |
| }; |
| |
| static const char *coex_pspoll_state[] = { |
| "STATE_DISABLED", |
| "STATE_NOT_READY", |
| "STATE_ENABLED", |
| "STATE_READY", |
| "STATE_TX_STATUS", |
| "STATE_RX_STATUS", |
| }; |
| |
| static const char *coex_scheduler_interval[] = { |
| "COEX_SCHED_NONWLAN_INT", |
| "COEX_SCHED_WLAN_INT", |
| }; |
| |
| static const char *wlan_weight[] = { |
| "BT_COEX_BASE", |
| "BT_COEX_LOW", |
| "BT_COEX_MID", |
| "BT_COEX_MID_NONSYNC", |
| "BT_COEX_HI_NONVOICE", |
| "BT_COEX_HI", |
| "BT_COEX_CRITICAL", |
| }; |
| |
| static const char *wlan_power_state[] = { |
| "SLEEP", |
| "AWAKE", |
| "FULL_SLEEP", |
| }; |
| |
| static const char *coex_psp_error_type[] = { |
| "DISABLED_STATE", |
| "VDEV_NULL", |
| "COEX_PSP_ENTRY", |
| "ZERO_INTERVAL", |
| "COEX_PSP_EXIT", |
| "READY_DISABLED", |
| "READY_NOT_DISABLED", |
| "POLL_PKT_DROPPED", |
| "SET_TIMER_PARAM", |
| }; |
| |
| static const char *wlan_phymode[] = { |
| "A", |
| "G", |
| "B", |
| "G_ONLY", |
| "NA_HT20", |
| "NG_HT20", |
| "NA_HT40", |
| "NG_HT40", |
| "AC_VHT20", |
| "AC_VHT40", |
| "AC_VHT80", |
| "AC_VHT20_2G", |
| "AC_VHT40_2G", |
| "AC_VHT80_2G", |
| "UNKNOWN", |
| }; |
| |
| static const char *wlan_curr_band[] = { |
| "2G", |
| "5G", |
| }; |
| |
| dbg_id_str = dbglog_get_msg(mod_id, dbg_id); |
| |
| switch (dbg_id) { |
| case COEX_SYSTEM_UPDATE: |
| if (numargs == 1 && args[0] < 9) { |
| dbglog_printf(timestamp, vap_id, "%s: %s", dbg_id_str, |
| coex_system_status[args[0]]); |
| } else if (numargs >= 5 && args[0] < 9 && args[2] < 9) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: %s, WlanSysState(0x%x), %s, NumChains(%u), AggrLimit(%u)", |
| dbg_id_str, coex_system_status[args[0]], |
| args[1], coex_trf_mgmt_type[args[2]], |
| args[3], args[4]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_SCHED_START: |
| if (numargs >= 5 && args[0] < 5 && args[2] < 9 && args[3] < 4 |
| && args[4] < 4) { |
| if (args[1] == 0xffffffff) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: %s, DETERMINE_DURATION, %s, %s, %s", |
| dbg_id_str, |
| coex_sched_req[args[0]], |
| coex_trf_mgmt_type[args[2]], |
| wlan_rx_xput_status[args[3]], |
| wlan_rssi_type[args[4]]); |
| } else { |
| dbglog_printf(timestamp, vap_id, |
| "%s: %s, IntvlDur(%u), %s, %s, %s", |
| dbg_id_str, |
| coex_sched_req[args[0]], args[1], |
| coex_trf_mgmt_type[args[2]], |
| wlan_rx_xput_status[args[3]], |
| wlan_rssi_type[args[4]]); |
| } |
| } else { |
| return false; |
| } |
| break; |
| case COEX_SCHED_RESULT: |
| if (numargs >= 5 && args[0] < 5 && args[1] < 9 && args[2] < 9) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: %s, %s, %s, CoexMgrPolicy(%u), IdleOverride(%u)", |
| dbg_id_str, coex_sched_req[args[0]], |
| coex_trf_mgmt_type[args[1]], |
| coex_trf_mgmt_type[args[2]], args[3], |
| args[4]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_BT_SCHEME: |
| if (numargs >= 1 && args[0] < 6) { |
| dbglog_printf(timestamp, vap_id, "%s: %s", dbg_id_str, |
| coex_bt_scheme[args[0]]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_TRF_FREERUN: |
| if (numargs >= 5 && args[0] < 7) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: %s, AllocatedBtIntvls(%u), BtIntvlCnt(%u), AllocatedWlanIntvls(%u), WlanIntvlCnt(%u)", |
| dbg_id_str, coex_sched_type[args[0]], |
| args[1], args[2], args[3], args[4]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_TRF_SHAPE_PM: /* used by ocs now */ |
| if (numargs >= 3) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: IntvlLength(%u), BtDuration(%u), WlanDuration(%u)", |
| dbg_id_str, args[0], args[1], args[2]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_SYSTEM_MONITOR: |
| if (numargs >= 5 && args[1] < 4 && args[4] < 4) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: WlanRxCritical(%u), %s, MinDirectRxRate(%u), MonitorActiveNum(%u), %s", |
| dbg_id_str, args[0], |
| wlan_rx_xput_status[args[1]], args[2], |
| args[3], wlan_rssi_type[args[4]]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_RX_RATE: |
| if (numargs >= 5 && args[4] < 3) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: NumUnderThreshPeers(%u), MinDirectRate(%u), LastRateSample(%u), DeltaT(%u), %s", |
| dbg_id_str, args[0], args[1], args[2], |
| args[3], |
| wal_peer_rx_rate_stats_event_sent[args |
| [4]]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_WLAN_INTERVAL_START: |
| if (numargs >= 5) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: WlanIntvlCnt(%u), Duration(%u), Weight(%u), BaseIdleOverride(%u), WeightMat[0](0x%x)", |
| dbg_id_str, args[0], args[1], args[2], |
| args[3], args[4]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_WLAN_POSTPAUSE_INTERVAL_START: |
| if (numargs >= 4) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: WlanPostPauseIntvlCnt(%u), XputMonitorActiveNum(%u), Duration(%u), Weight(%u)", |
| dbg_id_str, args[0], args[1], args[2], |
| args[3]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_BT_INTERVAL_START: |
| if (numargs >= 5) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: BtIntvlCnt(%u), Duration(%u), Weight(%u), BaseIdleOverride(%u), WeightMat[0](0x%x), ", |
| dbg_id_str, args[0], args[1], args[2], |
| args[3], args[4]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_POWER_CHANGE: |
| if (numargs >= 3 && args[1] < 3 && args[2] < 3) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: Event(0x%x) %s->%s", dbg_id_str, |
| args[0], wlan_power_state[args[1]], |
| wlan_power_state[args[2]]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_CHANNEL_CHANGE: |
| if (numargs >= 5 && args[3] < 2 && args[4] < 15) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: %uMhz->%uMhz, WlanSysState(0x%x), CurrBand(%s), PhyMode(%s)", |
| dbg_id_str, args[0], args[1], args[2], |
| wlan_curr_band[args[3]], |
| wlan_phymode[args[4]]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_PSP_MGR_ENTER: |
| if (numargs >= 5 && args[0] < 23 && args[1] < 6 && args[3] < 2) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: %s, %s, PsPollAvg(%u), %s, CurrT(%u)", |
| dbg_id_str, wlan_psp_stimulus[args[0]], |
| coex_pspoll_state[args[1]], args[2], |
| coex_scheduler_interval[args[3]], |
| args[4]); |
| } else { |
| return false; |
| } |
| break; |
| /* Translate following into decimal */ |
| case COEX_SINGLECHAIN_DBG_1: |
| case COEX_SINGLECHAIN_DBG_2: |
| case COEX_SINGLECHAIN_DBG_3: |
| case COEX_MULTICHAIN_DBG_1: |
| case COEX_MULTICHAIN_DBG_2: |
| case COEX_MULTICHAIN_DBG_3: |
| case BTCOEX_DBG_MCI_1: |
| case BTCOEX_DBG_MCI_2: |
| case BTCOEX_DBG_MCI_3: |
| case BTCOEX_DBG_MCI_4: |
| case BTCOEX_DBG_MCI_5: |
| case BTCOEX_DBG_MCI_6: |
| case BTCOEX_DBG_MCI_7: |
| case BTCOEX_DBG_MCI_8: |
| case BTCOEX_DBG_MCI_9: |
| case BTCOEX_DBG_MCI_10: |
| |
| if (numargs > 0) { |
| dbglog_printf_no_line_break(timestamp, vap_id, "%s: %u", |
| dbg_id_str, args[0]); |
| for (i = 1; i < numargs; i++) { |
| printk(", %u", args[i]); |
| } |
| printk("\n"); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_LinkID: |
| if (numargs >= 4) { |
| if (args[0]) { /* Add profile */ |
| dbglog_printf(timestamp, vap_id, |
| "%s Alloc: LocalID(%u), RemoteID(%u), MinFreeLocalID(%u)", |
| dbg_id_str, args[1], args[2], |
| args[3]); |
| } else { /* Remove profile */ |
| dbglog_printf(timestamp, vap_id, |
| "%s Dealloc: LocalID(%u), RemoteID(%u), MinFreeLocalID(%u)", |
| dbg_id_str, args[1], args[2], |
| args[3]); |
| } |
| } else { |
| return false; |
| } |
| break; |
| case COEX_PSP_MGR_RESULT: |
| if (numargs >= 5 && args[0] < 6) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: %s, PsPollAvg(%u), EstimationOverrun(%u), EstimationUnderun(%u), NotReadyErr(%u)", |
| dbg_id_str, coex_pspoll_state[args[0]], |
| args[1], args[2], args[3], args[4]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_TRF_SHAPE_PSP: |
| if (numargs >= 5 && args[0] < 7 && args[1] < 7) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: %s, %s, Dur(%u), BtTriggerRecvd(%u), PspWlanCritical(%u)", |
| dbg_id_str, coex_sched_type[args[0]], |
| wlan_weight[args[1]], args[2], args[3], |
| args[4]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_PSP_SPEC_POLL: |
| if (numargs >= 5) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: PsPollSpecEna(%u), Count(%u), NextTS(%u), AllowSpecPsPollTx(%u), Intvl(%u)", |
| dbg_id_str, args[0], args[1], args[2], |
| args[3], args[4]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_PSP_READY_STATE: |
| if (numargs >= 5) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: T2NonWlan(%u), CoexSchedulerEndTS(%u), MoreData(%u), PSPRespExpectedTS(%u), NonWlanIdleT(%u)", |
| dbg_id_str, args[0], args[1], args[2], |
| args[3], args[4]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_PSP_NONWLAN_INTERVAL: |
| if (numargs >= 4) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: NonWlanBaseIntvl(%u), NonWlanIdleT(%u), PSPSpecIntvl(%u), ApRespTimeout(%u)", |
| dbg_id_str, args[0], args[1], args[2], |
| args[3]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_PSP_ERROR: |
| if (numargs >= 1 && args[0] < 9) { |
| dbglog_printf_no_line_break(timestamp, vap_id, "%s: %s", |
| dbg_id_str, |
| coex_psp_error_type[args |
| [0]]); |
| for (i = 1; i < numargs; i++) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_INFO, |
| (", %u", args[i])); |
| } |
| AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("\n")); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_PSP_STAT_1: |
| if (numargs >= 5) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: ApResp0(%u), ApResp1(%u), ApResp2(%u), ApResp3(%u), ApResp4(%u)", |
| dbg_id_str, args[0], args[1], args[2], |
| args[3], args[4]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_PSP_STAT_2: |
| if (numargs >= 5) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: DataPt(%u), Max(%u), NextApRespIndex(%u), NumOfValidDataPts(%u), PsPollAvg(%u)", |
| dbg_id_str, args[0], args[1], args[2], |
| args[3], args[4]); |
| } else { |
| return false; |
| } |
| break; |
| case COEX_PSP_RX_STATUS_STATE_1: |
| if (numargs >= 5) { |
| if (args[2]) { |
| dbglog_printf(timestamp, vap_id, |
| "%s: RsExpectedTS(%u), RespActualTS(%u), Overrun, RsOverrunT(%u), RsRxDur(%u)", |
| dbg_id_str, args[0], args[1], |
| args[3], args[4]); |
| } else { |
| dbglog_printf(timestamp, vap_id, |
| "%s: RsExpectedTS(%u), RespActualTS(%u), Underrun, RsUnderrunT(%u), RsRxDur(%u)", |
| dbg_id_str, args[0], args[1], |
| args[3], args[4]); |
| } |
| } else { |
| return false; |
| } |
| break; |
| default: |
| return false; |
| } |
| |
| return true; |
| } |
| |
| A_BOOL |
| dbglog_beacon_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[] = { |
| "INIT", |
| "ADJUST_START", |
| "ADJUSTING", |
| "ADJUST_HOLD", |
| }; |
| |
| static const char *events[] = { |
| "ADJUST_START", |
| "ADJUST_RESTART", |
| "ADJUST_STOP", |
| "ADJUST_PAUSE", |
| "ADJUST_UNPAUSE", |
| "ADJUST_INC_SLOP_STEP", |
| "ADJUST_HOLD", |
| "ADJUST_HOLD_TIME_OUT", |
| }; |
| |
| switch (dbg_id) { |
| case DBGLOG_DBGID_SM_FRAMEWORK_PROXY_DBGLOG_MSG: |
| dbglog_sm_print(timestamp, vap_id, numargs, args, "EARLY_RX", |
| states, QDF_ARRAY_SIZE(states), events, |
| QDF_ARRAY_SIZE(events)); |
| break; |
| case BEACON_EVENT_EARLY_RX_BMISS_STATUS: |
| if (numargs == 3) { |
| dbglog_printf(timestamp, vap_id, |
| "early_rx bmiss status:rcv=%d total=%d miss=%d", |
| args[0], args[1], args[2]); |
| } |
| break; |
| case BEACON_EVENT_EARLY_RX_SLEEP_SLOP: |
| if (numargs == 1) { |
| dbglog_printf(timestamp, vap_id, |
| "early_rx update sleep_slop:%d", args[0]); |
| } |
| break; |
| case BEACON_EVENT_EARLY_RX_CONT_BMISS_TIMEOUT: |
| if (numargs == 1) { |
| dbglog_printf(timestamp, vap_id, |
| "early_rx cont bmiss timeout,update sleep_slop:%d", |
| args[0]); |
| } |
| break; |
| case BEACON_EVENT_EARLY_RX_PAUSE_SKIP_BCN_NUM: |
| if (numargs == 1) { |
| dbglog_printf(timestamp, vap_id, |
| "early_rx skip bcn num:%d", args[0]); |
| } |
| break; |
| case BEACON_EVENT_EARLY_RX_CLK_DRIFT: |
| if (numargs == 1) { |
| dbglog_printf(timestamp, vap_id, |
| "early_rx clk drift:%d", args[0]); |
| } |
| break; |
| case BEACON_EVENT_EARLY_RX_AP_DRIFT: |
| if (numargs == 1) { |
| dbglog_printf(timestamp, vap_id, |
| "early_rx ap drift:%d", args[0]); |
| } |
| break; |
| case BEACON_EVENT_EARLY_RX_BCN_TYPE: |
| if (numargs == 1) { |
| dbglog_printf(timestamp, vap_id, |
| "early_rx bcn type:%d", args[0]); |
| } |
| break; |
| default: |
| return false; |
| } |
| |
| return true; |
| } |
| |
| A_BOOL |
| dbglog_data_txrx_print_handler(A_UINT32 mod_id, |
| A_UINT16 vap_id, |
| A_UINT32 dbg_id, |
| A_UINT32 timestamp, |
| A_UINT16 numargs, A_UINT32 *args) |
| { |
| switch (dbg_id) { |
| case DATA_TXRX_DBGID_RX_DATA_SEQ_LEN_INFO: |
| dbglog_printf(timestamp, vap_id, |
| "DATA RX seq=0x%x, len=0x%x, stored=0x%x, duperr=0x%x", |
| args[0], args[1], (args[2] & 0xffff0000) >> 16, |
| args[2] & 0x0000ffff); |
| break; |
| default: |
| return false; |
| } |
| |
| return true; |
| } |
| |
| A_BOOL dbglog_smps_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[] = { |
| "S_INACTIVE", |
| "S_STATIC", |
| "S_DYNAMIC", |
| "S_STALLED", |
| "S_INACTIVE_WAIT", |
| "S_STATIC_WAIT", |
| "S_DYNAMIC_WAIT", |
| }; |
| |
| static const char *events[] = { |
| "E_STOP", |
| "E_STOP_COMPL", |
| "E_START", |
| "E_STATIC", |
| "E_STATIC_COMPL", |
| "E_DYNAMIC", |
| "E_DYNAMIC_COMPL", |
| "E_STALL", |
| "E_RSSI_ABOVE_THRESH", |
| "E_RSSI_BELOW_THRESH", |
| "E_FORCED_NONE", |
| }; |
| switch (dbg_id) { |
| case DBGLOG_DBGID_SM_FRAMEWORK_PROXY_DBGLOG_MSG: |
| dbglog_sm_print(timestamp, vap_id, numargs, args, "STA_SMPS SM", |
| states, QDF_ARRAY_SIZE(states), events, |
| QDF_ARRAY_SIZE(events)); |
| break; |
| case STA_SMPS_DBGID_CREATE_PDEV_INSTANCE: |
| dbglog_printf(timestamp, vap_id, "STA_SMPS Create PDEV ctx %#x", |
| args[0]); |
| break; |
| case STA_SMPS_DBGID_CREATE_VIRTUAL_CHAN_INSTANCE: |
| dbglog_printf(timestamp, vap_id, |
| "STA_SMPS Create Virtual Chan ctx %#x", args[0]); |
| break; |
| case STA_SMPS_DBGID_DELETE_VIRTUAL_CHAN_INSTANCE: |
| dbglog_printf(timestamp, vap_id, |
| "STA_SMPS Delete Virtual Chan ctx %#x", args[0]); |
| break; |
| case STA_SMPS_DBGID_CREATE_STA_INSTANCE: |
| dbglog_printf(timestamp, vap_id, "STA_SMPS Create STA ctx %#x", |
| args[0]); |
| break; |
| case STA_SMPS_DBGID_DELETE_STA_INSTANCE: |
| dbglog_printf(timestamp, vap_id, "STA_SMPS Delete STA ctx %#x", |
| args[0]); |
| break; |
| case STA_SMPS_DBGID_VIRTUAL_CHAN_SMPS_START: |
| break; |
| case STA_SMPS_DBGID_VIRTUAL_CHAN_SMPS_STOP: |
| break; |
| case STA_SMPS_DBGID_SEND_SMPS_ACTION_FRAME: |
| dbglog_printf(timestamp, vap_id, |
| "STA_SMPS STA %#x Signal SMPS mode as %s; cb_flags %#x", |
| args[0], |
| (args[1] == |
| 0 ? "DISABLED" : (args[1] == |
| 0x1 ? "STATIC" : (args[1] == |
| 0x3 ? |
| "DYNAMIC" : |
| "UNKNOWN"))), |
| args[2]); |
| break; |
| case STA_SMPS_DBGID_DTIM_EBT_EVENT_CHMASK_UPDATE: |
| dbglog_printf(timestamp, vap_id, |
| "STA_SMPS_DBGID_DTIM_EBT_EVENT_CHMASK_UPDATE"); |
| break; |
| case STA_SMPS_DBGID_DTIM_CHMASK_UPDATE: |
| dbglog_printf(timestamp, vap_id, |
| "STA_SMPS_DBGID_DTIM_CHMASK_UPDATE " |
| "tx_mask %#x rx_mask %#x arb_dtim_mask %#x", |
| args[0], args[1], args[2]); |
| break; |
| case STA_SMPS_DBGID_DTIM_BEACON_EVENT_CHMASK_UPDATE: |
| dbglog_printf(timestamp, vap_id, |
| "STA_SMPS_DBGID_DTIM_BEACON_EVENT_CHMASK_UPDATE"); |
| break; |
| case STA_SMPS_DBGID_DTIM_POWER_STATE_CHANGE: |
| dbglog_printf(timestamp, vap_id, |
| "STA_SMPS_DBGID_DTIM_POWER_STATE_CHANGE cur_pwr_state %s new_pwr_state %s", |
| (args[0] == |
| 0x1 ? "SLEEP" : (args[0] == |
| 0x2 ? "AWAKE" : (args[0] == |
| 0x3 ? |
| "FULL_SLEEP" : |
| "UNKNOWN"))), |
| (args[1] == |
| 0x1 ? "SLEEP" : (args[1] == |
| 0x2 ? "AWAKE" : (args[1] == |
| 0x3 ? |
| "FULL_SLEEP" : |
| "UNKNOWN")))); |
| break; |
| case STA_SMPS_DBGID_DTIM_CHMASK_UPDATE_SLEEP: |
| dbglog_printf(timestamp, vap_id, |
| "STA_SMPS_DBGID_DTIM_CHMASK_UPDATE_SLEEP " |
| "tx_mask %#x rx_mask %#x orig_rx %#x dtim_rx %#x", |
| args[0], args[1], args[2], args[3]); |
| break; |
| case STA_SMPS_DBGID_DTIM_CHMASK_UPDATE_AWAKE: |
| dbglog_printf(timestamp, vap_id, |
| "STA_SMPS_DBGID_DTIM_CHMASK_UPDATE_AWAKE " |
| "tx_mask %#x rx_mask %#x orig_rx %#x", args[0], |
| args[1], args[2]); |
| break; |
| default: |
| dbglog_printf(timestamp, vap_id, "STA_SMPS: UNKNOWN DBGID!"); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| A_BOOL |
| dbglog_p2p_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[] = { |
| "ACTIVE", |
| "DOZE", |
| "TX_BCN", |
| "CTWIN", |
| "OPPPS", |
| }; |
| |
| static const char *events[] = { |
| "ONESHOT_NOA", |
| "CTWINDOW", |
| "PERIODIC_NOA", |
| "IDLE", |
| "NOA_CHANGED", |
| "TBTT", |
| "TX_BCN_CMP", |
| "OPPPS_OK", |
| "OPPPS_CHANGED", |
| }; |
| |
| switch (dbg_id) { |
| case DBGLOG_DBGID_SM_FRAMEWORK_PROXY_DBGLOG_MSG: |
| dbglog_sm_print(timestamp, vap_id, numargs, args, "P2P GO PS", |
| states, QDF_ARRAY_SIZE(states), events, |
| QDF_ARRAY_SIZE(events)); |
| break; |
| default: |
| return false; |
| } |
| |
| return true; |
| } |
| |
| A_BOOL |
| dbglog_pcielp_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[] = { |
| "STOP", |
| "TX", |
| "RX", |
| "SLEEP", |
| "SUSPEND", |
| }; |
| |
| static const char *events[] = { |
| "VDEV_UP", |
| "ALL_VDEV_DOWN", |
| "AWAKE", |
| "SLEEP", |
| "TX_ACTIVITY", |
| "TX_INACTIVITY", |
| "TX_AC_CHANGE", |
| "SUSPEND", |
| "RESUME", |
| }; |
| |
| switch (dbg_id) { |
| case DBGLOG_DBGID_SM_FRAMEWORK_PROXY_DBGLOG_MSG: |
| dbglog_sm_print(timestamp, vap_id, numargs, args, "PCIELP", |
| states, QDF_ARRAY_SIZE(states), events, |
| QDF_ARRAY_SIZE(events)); |
| break; |
| default: |
| return false; |
| } |
| |
| return true; |
| } |
| |
| #ifdef WLAN_OPEN_SOURCE |
| static int dbglog_block_open(struct inode *inode, struct file *file) |
| { |
| struct fwdebug *fwlog = inode->i_private; |
| |
| if (fwlog->fwlog_open) |
| return -EBUSY; |
| |
| fwlog->fwlog_open = true; |
| |
| file->private_data = inode->i_private; |
| return 0; |
| } |
| |
| static int dbglog_block_release(struct inode *inode, struct file *file) |
| { |
| struct fwdebug *fwlog = inode->i_private; |
| |
| fwlog->fwlog_open = false; |
| |
| return 0; |
| } |
| |
| static ssize_t dbglog_block_read(struct file *file, |
| char __user *user_buf, |
| size_t count, loff_t *ppos) |
| { |
| struct fwdebug *fwlog = file->private_data; |
| struct sk_buff *skb; |
| ssize_t ret_cnt; |
| size_t len = 0, not_copied; |
| char *buf; |
| int ret; |
| |
| buf = vmalloc(count); |
| if (!buf) |
| return -ENOMEM; |
| |
| spin_lock_bh(&fwlog->fwlog_queue.lock); |
| |
| if (skb_queue_len(&fwlog->fwlog_queue) == 0) { |
| /* we must init under queue lock */ |
| init_completion(&fwlog->fwlog_completion); |
| |
| spin_unlock_bh(&fwlog->fwlog_queue.lock); |
| |
| ret = |
| wait_for_completion_interruptible(&fwlog->fwlog_completion); |
| if (ret == -ERESTARTSYS) { |
| vfree(buf); |
| return ret; |
| } |
| |
| spin_lock_bh(&fwlog->fwlog_queue.lock); |
| } |
| |
| while ((skb = __skb_dequeue(&fwlog->fwlog_queue))) { |
| if (skb->len > count - len) { |
| /* not enough space, put skb back and leave */ |
| __skb_queue_head(&fwlog->fwlog_queue, skb); |
| break; |
| } |
| |
| memcpy(buf + len, skb->data, skb->len); |
| len += skb->len; |
| |
| kfree_skb(skb); |
| } |
| |
| spin_unlock_bh(&fwlog->fwlog_queue.lock); |
| |
| /* FIXME: what to do if len == 0? */ |
| not_copied = copy_to_user(user_buf, buf, len); |
| if (not_copied != 0) { |
| ret_cnt = -EFAULT; |
| goto out; |
| } |
| |
| *ppos = *ppos + len; |
| |
| ret_cnt = len; |
| |
| out: |
| vfree(buf); |
| |
| return ret_cnt; |
| } |
| |
| static const struct file_operations fops_dbglog_block = { |
| .open = dbglog_block_open, |
| .release = dbglog_block_release, |
| .read = dbglog_block_read, |
| .owner = THIS_MODULE, |
| .llseek = default_llseek, |
| }; |
| |
| int dbglog_debugfs_init(wmi_unified_t wmi_handle) |
| { |
| |
| wmi_handle->debugfs_phy = debugfs_create_dir(CLD_DEBUGFS_DIR, NULL); |
| if (!wmi_handle->debugfs_phy) |
| return -ENOMEM; |
| |
| debugfs_create_file(DEBUGFS_BLOCK_NAME, S_IRUSR, |
| wmi_handle->debugfs_phy, &wmi_handle->dbglog, |
| &fops_dbglog_block); |
| |
| return true; |
| } |
| |
| int dbglog_debugfs_remove(wmi_unified_t wmi_handle) |
| { |
| debugfs_remove_recursive(wmi_handle->debugfs_phy); |
| return true; |
| } |
| #endif /* WLAN_OPEN_SOURCE */ |
| |
| static void |
| cnss_diag_event_report(A_UINT16 event_Id, A_UINT16 length, void *pPayload) |
| { |
| A_UINT8 *pBuf, *pBuf1; |
| event_report_t *pEvent_report; |
| A_UINT16 total_len; |
| total_len = sizeof(event_report_t) + length; |
| pBuf = qdf_mem_malloc(total_len); |
| if (!pBuf) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, |
| ("%s: qdf_mem_malloc failed \n", __func__)); |
| return; |
| } |
| pBuf1 = pBuf; |
| pEvent_report = (event_report_t *) pBuf; |
| pEvent_report->diag_type = DIAG_TYPE_EVENTS; |
| pEvent_report->event_id = event_Id; |
| pEvent_report->length = length; |
| pBuf += sizeof(event_report_t); |
| memcpy(pBuf, pPayload, length); |
| send_diag_netlink_data((A_UINT8 *) pBuf1, total_len, |
| DIAG_TYPE_HOST_MSG); |
| qdf_mem_free((void *)pBuf1); |
| return; |
| |
| } |
| |
| static void cnss_diag_send_driver_loaded(void) |
| { |
| if (appstarted) { |
| host_event_wlan_bringup_status_payload_type wlan_bringup_status; |
| /* Send Driver up command */ |
| strlcpy(&wlan_bringup_status.driverVersion[0], QWLAN_VERSIONSTR, |
| sizeof(wlan_bringup_status.driverVersion)); |
| wlan_bringup_status.wlanStatus = DIAG_WLAN_DRIVER_LOADED; |
| cnss_diag_event_report(EVENT_WLAN_BRINGUP_STATUS, |
| sizeof(wlan_bringup_status), |
| &wlan_bringup_status); |
| senddriverstatus = false; |
| } else |
| senddriverstatus = true; |
| } |
| |
| static void cnss_diag_send_driver_unloaded(void) |
| { |
| host_event_wlan_bringup_status_payload_type wlan_bringup_status; |
| /* Send Driver down command */ |
| memset(&wlan_bringup_status, 0, |
| sizeof(host_event_wlan_bringup_status_payload_type)); |
| wlan_bringup_status.wlanStatus = DIAG_WLAN_DRIVER_UNLOADED; |
| cnss_diag_event_report(EVENT_WLAN_BRINGUP_STATUS, |
| sizeof(wlan_bringup_status), |
| &wlan_bringup_status); |
| } |
| |
| /**--------------------------------------------------------------------------- |
| \brief cnss_diag_msg_callback() - Call back invoked by netlink service |
| |
| This function gets invoked by netlink service when a message is recevied |
| from the cnss-diag application in user-space. |
| |
| \param - |
| - skb - skb with netlink message |
| |
| \return - 0 for success, non zero for failure |
| --------------------------------------------------------------------------*/ |
| int cnss_diag_msg_callback(struct sk_buff *skb) |
| { |
| struct nlmsghdr *nlh; |
| struct dbglog_slot *slot; |
| A_UINT8 *msg; |
| |
| nlh = (struct nlmsghdr *)skb->data; |
| if (!nlh) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, |
| ("%s: Netlink header null \n", __func__)); |
| return -1; |
| } |
| |
| msg = NLMSG_DATA(nlh); |
| |
| /* This check added for backward compatability */ |
| if (!memcmp(msg, "Hello", 5)) { |
| appstarted = true; |
| cnss_diag_pid = nlh->nlmsg_pid; |
| AR_DEBUG_PRINTF(ATH_DEBUG_INFO, |
| ("%s: registered pid %d \n", __func__, |
| cnss_diag_pid)); |
| if (senddriverstatus) |
| cnss_diag_send_driver_loaded(); |
| return 0; |
| } else |
| slot = (struct dbglog_slot *)msg; |
| switch (slot->diag_type) { |
| case DIAG_TYPE_CRASH_INJECT: |
| if (slot->length == 2) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_INFO, |
| ("%s : DIAG_TYPE_CRASH_INJECT: %d %d\n", |
| __func__, slot->payload[0], slot->payload[1])); |
| wma_cli_set2_command(0, GEN_PARAM_CRASH_INJECT, |
| slot->payload[0], slot->payload[1], |
| GEN_CMD); |
| } else { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, |
| ("crash_inject cmd error\n")); |
| } |
| break; |
| default: |
| break; |
| } |
| return 0; |
| |
| } |
| |
| /**--------------------------------------------------------------------------- |
| \brief cnss_diag_notify_wlan_close() - notify APP driver closed |
| |
| This function notifies the user cnss-diag app that wlan driver is closed. |
| |
| \param - |
| - None |
| |
| \return - 0 for success, non zero for failure |
| --------------------------------------------------------------------------*/ |
| int cnss_diag_notify_wlan_close(void) |
| { |
| /* Send nl msg about the wlan close */ |
| if (INVALID_PID != cnss_diag_pid) { |
| cnss_diag_send_driver_unloaded(); |
| cnss_diag_pid = INVALID_PID; |
| } |
| return 0; |
| |
| } |
| |
| /**--------------------------------------------------------------------------- |
| \brief cnss_diag_activate_service() - Activate cnss_diag message handler |
| |
| This function registers a handler to receive netlink message from |
| an cnss-diag application process. |
| |
| \param - |
| - None |
| |
| \return - 0 for success, non zero for failure |
| --------------------------------------------------------------------------*/ |
| int cnss_diag_activate_service(void) |
| { |
| int ret = 0; |
| |
| /* Register the msg handler for msgs addressed to WLAN_NL_MSG_OEM */ |
| ret = nl_srv_register(WLAN_NL_MSG_CNSS_DIAG, cnss_diag_msg_callback); |
| if (ret) { |
| AR_DEBUG_PRINTF(ATH_DEBUG_ERR, |
| ("CNSS-DIAG Registration failed")); |
| return ret; |
| } |
| return 0; |
| } |
| |
| A_BOOL |
| dbglog_wow_print_handler(A_UINT32 mod_id, |
| A_UINT16 vap_id, |
| A_UINT32 dbg_id, |
| A_UINT32 timestamp, A_UINT16 numargs, A_UINT32 *args) |
| { |
| |
| switch (dbg_id) { |
| case WOW_NS_OFLD_ENABLE: |
| if (4 == numargs) { |
| dbglog_printf(timestamp, vap_id, |
| "Enable NS offload, for sender %02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x\ |
| :%02x%02x:%02x%02x:%02x%02x", *(A_UINT8 *) &args[0], *((A_UINT8 *) &args[0] + 1), |
| *((A_UINT8 *) &args[0] + 2), *((A_UINT8 *) &args[0] + 3), *(A_UINT8 *) &args[1], *((A_UINT8 *) &args[1] + 1), *((A_UINT8 *) &args[1] + 2), *((A_UINT8 *) &args[1] + 3), |
| *(A_UINT8 *) &args[2], *((A_UINT8 *) &args[2] + 1), *((A_UINT8 *) &args[2] + 2), *((A_UINT8 *) &args[2] + 3), *(A_UINT8 *) &args[3], *((A_UINT8 *) &args[3] + 1), |
| *((A_UINT8 *) &args[3] + 2), *((A_UINT8 *) &args[3] + 3)); |
| } else { |
| return false; |
| } |
| break; |
| case WOW_ARP_OFLD_ENABLE: |
| if (1 == numargs) { |
| dbglog_printf(timestamp, vap_id, |
| "Enable ARP offload, for sender %d.%d.%d.%d", |
| *(A_UINT8 *) args, |
| *((A_UINT8 *) args + 1), |
| *((A_UINT8 *) args + 2), |
| *((A_UINT8 *) args + 3)); |
| } else { |
| return false; |
| } |
| break; |
| case WOW_NS_ARP_OFLD_DISABLE: |
| if (0 == numargs) { |
| dbglog_printf(timestamp, vap_id, |
| "disable NS/ARP offload"); |
| } else { |
| return false; |
| } |
| break; |
| case WOW_NS_RECEIVED: |
| if (4 == numargs) { |
| dbglog_printf(timestamp, vap_id, |
| "NS requested from %02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x\ |
| :%02x%02x:%02x%02x:%02x%02x", *(A_UINT8 *) &args[0], *((A_UINT8 *) &args[0] + 1), |
| *((A_UINT8 *) &args[0] + 2), *((A_UINT8 *) &args[0] + 3), *(A_UINT8 *) &args[1], *((A_UINT8 *) &args[1] + 1), *((A_UINT8 *) &args[1] + 2), |
| *((A_UINT8 *) &args[1] + 3), *(A_UINT8 *) &args[2], *((A_UINT8 *) &args[2] + 1), *((A_UINT8 *) &args[2] + 2), *((A_UINT8 *) &args[2] + 3), |
| *(A_UINT8 *) &args[3], *((A_UINT8 *) &args[3] + 1), *((A_UINT8 *) &args[3] + 2), *((A_UINT8 *) &args[3] + 3)); |
| } else { |
| return false; |
| } |
| break; |
| case WOW_NS_REPLIED: |
| if (4 == numargs) { |
| dbglog_printf(timestamp, vap_id, |
| "NS replied to %02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x\ |
| :%02x%02x:%02x%02x:%02x%02x", *(A_UINT8 *) &args[0], *((A_UINT8 *) &args[0] + 1), |
| *((A_UINT8 *) &args[0] + 2), *((A_UINT8 *) &args[0] + 3), *(A_UINT8 *) &args[1], *((A_UINT8 *) &args[1] + 1), *((A_UINT8 *) &args[1] + 2), |
| *((A_UINT8 *) &args[1] + 3), *(A_UINT8 *) &args[2], *((A_UINT8 *) &args[2] + 1), *((A_UINT8 *) &args[2] + 2), *((A_UINT8 *) &args[2] + 3), |
| *(A_UINT8 *) &args[3], *((A_UINT8 *) &args[3] + 1), *((A_UINT8 *) &args[3] + 2), *((A_UINT8 *) &args[3] + 3)); |
| } else { |
| return false; |
| } |
| break; |
| case WOW_ARP_RECEIVED: |
| if (1 == numargs) { |
| dbglog_printf(timestamp, vap_id, |
| "ARP requested from %d.%d.%d.%d", |
| *(A_UINT8 *) args, |
| *((A_UINT8 *) args + 1), |
| *((A_UINT8 *) args + 2), |
| *((A_UINT8 *) args + 3)); |
| } else { |
| return false; |
| } |
| break; |
| break; |
| case WOW_ARP_REPLIED: |
| if (1 == numargs) { |
| dbglog_printf(timestamp, vap_id, |
| "ARP replied to %d.%d.%d.%d", |
| *(A_UINT8 *) args, |
| *((A_UINT8 *) args + 1), |
| *((A_UINT8 *) args + 2), |
| *((A_UINT8 *) args + 3)); |
| } else { |
| return false; |
| } |
| break; |
| default: |
| return false; |
| } |
| |
| return true; |
| } |
| |
| int dbglog_parser_type_init(wmi_unified_t wmi_handle, int type) |
| { |
| if (type >= DBGLOG_PROCESS_MAX) { |
| return A_ERROR; |
| } |
| |
| dbglog_process_type = type; |
| gprint_limiter = false; |
| |
| return A_OK; |
| } |
| |
| int dbglog_init(wmi_unified_t wmi_handle) |
| { |
| int res = 0; |
| OS_MEMSET(mod_print, 0, sizeof(mod_print)); |
| |
| dbglog_reg_modprint(WLAN_MODULE_STA_PWRSAVE, |
| dbglog_sta_powersave_print_handler); |
| dbglog_reg_modprint(WLAN_MODULE_AP_PWRSAVE, |
| dbglog_ap_powersave_print_handler); |
| dbglog_reg_modprint(WLAN_MODULE_WAL, dbglog_wal_print_handler); |
| dbglog_reg_modprint(WLAN_MODULE_SCAN, dbglog_scan_print_handler); |
| dbglog_reg_modprint(WLAN_MODULE_RATECTRL, |
| dbglog_ratectrl_print_handler); |
| dbglog_reg_modprint(WLAN_MODULE_ANI, dbglog_ani_print_handler); |
| dbglog_reg_modprint(WLAN_MODULE_COEX, dbglog_coex_print_handler); |
| dbglog_reg_modprint(WLAN_MODULE_BEACON, dbglog_beacon_print_handler); |
| dbglog_reg_modprint(WLAN_MODULE_WOW, dbglog_wow_print_handler); |
| dbglog_reg_modprint(WLAN_MODULE_DATA_TXRX, |
| dbglog_data_txrx_print_handler); |
| dbglog_reg_modprint(WLAN_MODULE_STA_SMPS, dbglog_smps_print_handler); |
| dbglog_reg_modprint(WLAN_MODULE_P2P, dbglog_p2p_print_handler); |
| dbglog_reg_modprint(WLAN_MODULE_PCIELP, dbglog_pcielp_print_handler); |
| dbglog_reg_modprint(WLAN_MODULE_IBSS_PWRSAVE, |
| dbglog_ibss_powersave_print_handler); |
| |
| /* Register handler for F3 or debug messages */ |
| res = |
| wmi_unified_register_event_handler(wmi_handle, |
| WMI_DEBUG_MESG_EVENTID, |
| dbglog_parse_debug_logs); |
| if (res != 0) |
| return res; |
| |
| /* Register handler for FW diag events */ |
| res = wmi_unified_register_event_handler(wmi_handle, |
| WMI_DIAG_DATA_CONTAINER_EVENTID, |
| fw_diag_data_event_handler); |
| if (res != 0) |
| return res; |
| |
| /* Register handler for new FW diag Event, LOG, MSG combined */ |
| res = wmi_unified_register_event_handler(wmi_handle, WMI_DIAG_EVENTID, |
| diag_fw_handler); |
| if (res != 0) |
| return res; |
| |
| cnss_diag_send_driver_loaded(); |
| #ifdef WLAN_OPEN_SOURCE |
| /* Initialize the fw debug log queue */ |
| skb_queue_head_init(&wmi_handle->dbglog.fwlog_queue); |
| init_completion(&wmi_handle->dbglog.fwlog_completion); |
| |
| /* Initialize debugfs */ |
| dbglog_debugfs_init(wmi_handle); |
| #endif /* WLAN_OPEN_SOURCE */ |
| |
| return res; |
| } |
| |
| int dbglog_deinit(wmi_unified_t wmi_handle) |
| { |
| int res = 0; |
| |
| #ifdef WLAN_OPEN_SOURCE |
| /* DeInitialize the fw debug log queue */ |
| skb_queue_purge(&wmi_handle->dbglog.fwlog_queue); |
| complete(&wmi_handle->dbglog.fwlog_completion); |
| |
| /* Deinitialize the debugfs */ |
| dbglog_debugfs_remove(wmi_handle); |
| #endif /* WLAN_OPEN_SOURCE */ |
| |
| res = |
| wmi_unified_unregister_event_handler(wmi_handle, |
| WMI_DEBUG_MESG_EVENTID); |
| if (res != 0) |
| return res; |
| |
| return res; |
| } |