//
// Copyright (c) 2006 Atheros Communications Inc.
// All rights reserved.
// 
//
// 
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the 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 tool parses the recevent logs stored in the binary format 
   by the wince athsrc */
#define WAPI_ENABLE
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <a_config.h>
#include <a_osapi.h>
#include <a_types.h>
#include <athdefs.h>
#include <ieee80211.h>
#include <wmi.h>
#include <athdrv_linux.h>
#include <dbglog_api.h>
#include <dbglog_id.h>

#include "dbg_cmd_evt.h"

typedef int (*DbgCmdFormatter)(char *output, size_t len, const A_UINT8 *);
typedef int (*DbgLogFormatter)(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer);

struct dbglog_desc {
    A_INT32 oid;
    const char *desc;
    DbgLogFormatter formatter;
};

struct module_desc {
    int module;
    const char *name;
    struct dbglog_desc *descs;
    size_t len;
    int bsearch;
};

struct wmi_id_desc {
    A_INT32 oid;
    const char *desc;
    DbgCmdFormatter formatter;
    size_t cmdSize;
};

#define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
#define CASE_STR_CONST(_s, _n, _val) case _n: (_val) = #_s; break
#define CASE_STR(_x, _val) case _x: (_val) = #_x; break
#define CASE_DEF_STR(_val) default: (_val) = "Unknown"; break
#define BIT_STR(_b, _l, _r, _s, _c, _v) if (((_v) & (_c)) == (_c)) (_r) += snprintf((_b)+(_r), (_l)-(_r), _s)

#define DBG_DESC(_x) { _x, #_x, NULL }
#define DBG_DESC_FMT(_x) { _x, #_x, _x ## _fmt }

#define WM_ID_DESC(_x) { _x, #_x, NULL, 0 }
#define WM_ID_DESC_FMT(_x, s) { _x, #_x, _x ## _fmt, s }

#define MODULE_DESC(_x, _d) { DBGLOG_MODULEID_ ## _x, #_x, _d, ARRAY_SIZE(_d),0}

extern A_CHAR dbglog_id_tag[DBGLOG_MODULEID_NUM_MAX][DBGLOG_DBGID_NUM_MAX][DBGLOG_DBGID_DEFINITION_LEN_MAX];
static int check_ids;

static const char *pmmode2text(A_INT32 mode)
{
    const char *pm;
    switch (mode) {
    case 1: pm = "sleep"; break;
    case 2: pm = "awake"; break;
    case 3: pm = "fake_sleep"; break;
    default: pm = "unknown"; break;
    }
    return pm;
}

#if 0
static const char *module2text(A_INT32 moduleid)
{
    const char *msg;
    switch (moduleid) {
    CASE_STR_CONST(INF, DBGLOG_MODULEID_INF, msg);
    CASE_STR_CONST(WMI, DBGLOG_MODULEID_WMI, msg);
    CASE_STR_CONST(MISC, DBGLOG_MODULEID_MISC, msg);
    CASE_STR_CONST(PM, DBGLOG_MODULEID_PM, msg);
    CASE_STR_CONST(MGMTBUF, DBGLOG_MODULEID_TXRX_MGMTBUF, msg);
    CASE_STR_CONST(TXBUF, DBGLOG_MODULEID_TXRX_TXBUF, msg);
    CASE_STR_CONST(RXBUF, DBGLOG_MODULEID_TXRX_RXBUF, msg);
    CASE_STR_CONST(WOW, DBGLOG_MODULEID_WOW, msg);
    CASE_STR_CONST(WHAL, DBGLOG_MODULEID_WHAL, msg);
    CASE_STR_CONST(DC, DBGLOG_MODULEID_DC, msg);
    CASE_STR_CONST(CO, DBGLOG_MODULEID_CO, msg);
    CASE_STR_CONST(RO, DBGLOG_MODULEID_RO, msg);
    CASE_STR_CONST(CM, DBGLOG_MODULEID_CM, msg);
    CASE_STR_CONST(MGMT, DBGLOG_MODULEID_MGMT, msg);
    CASE_STR_CONST(TMR, DBGLOG_MODULEID_TMR, msg);
    CASE_STR_CONST(BTCOEX, DBGLOG_MODULEID_BTCOEX, msg);
    CASE_DEF_STR(msg);
    }
    return msg;
}
#endif

static const char *pmmodule2text(A_INT32 moduleid)
{
    const char *msg;
    switch (moduleid) {
    CASE_STR_CONST(CSERV, 1, msg);
    CASE_STR_CONST(MLME   , 2, msg);
    CASE_STR_CONST(TXRX   , 3, msg);
    CASE_STR_CONST(PM     , 4, msg);
    CASE_STR_CONST(BT_COEX, 5, msg);
    CASE_STR_CONST(CO     , 6, msg);
    CASE_STR_CONST(DC     , 7, msg);
    CASE_STR_CONST(RO     , 8, msg);
    CASE_STR_CONST(CM     , 9, msg);
    CASE_STR_CONST(RRM    , 10, msg);
    CASE_STR_CONST(AP     , 11, msg);
    CASE_STR_CONST(KEYMGMT, 12, msg);
    CASE_STR_CONST(CCX    , 13, msg);
    CASE_STR_CONST(MISC   , 14, msg);
    CASE_STR_CONST(DFS    , 15, msg);
    CASE_STR_CONST(TIMER  , 16, msg);
    CASE_DEF_STR(msg);
    }
    return msg;
}

static const char *status2text(A_STATUS status)
{
    const char *msg;
    switch (status) {
    CASE_STR(A_ERROR, msg);
    CASE_STR(A_OK, msg);                   /* success */
                                /* Following values start at 1 */
    CASE_STR(A_DEVICE_NOT_FOUND, msg);         /* not able to find PCI device */
    CASE_STR(A_NO_MEMORY, msg);                /* not able to allocate memory, msg); not available */
    CASE_STR(A_MEMORY_NOT_AVAIL, msg);         /* memory region is not free for mapping */
    CASE_STR(A_NO_FREE_DESC, msg);             /* no free descriptors available */
    CASE_STR(A_BAD_ADDRESS, msg);              /* address does not match descriptor */
    CASE_STR(A_WIN_DRIVER_ERROR, msg);         /* used in NT_HW version, msg); if problem at init */
    CASE_STR(A_REGS_NOT_MAPPED, msg);          /* registers not correctly mapped */
    CASE_STR(A_EPERM, msg);                    /* Not superuser */
    CASE_STR(A_EACCES, msg);                   /* Access denied */
    CASE_STR(A_ENOENT, msg);                   /* No such entry, msg); search failed, msg); etc. */
    CASE_STR(A_EEXIST, msg);                   /* The object already exists (can't create) */
    CASE_STR(A_EFAULT, msg);                   /* Bad address fault */
    CASE_STR(A_EBUSY, msg);                    /* Object is busy */
    CASE_STR(A_EINVAL, msg);                   /* Invalid parameter */
    CASE_STR(A_EMSGSIZE, msg);                 /* Inappropriate message buffer length */
    CASE_STR(A_ECANCELED, msg);                /* Operation canceled */
    CASE_STR(A_ENOTSUP, msg);                  /* Operation not supported */
    CASE_STR(A_ECOMM, msg);                    /* Communication error on send */
    CASE_STR(A_EPROTO, msg);                   /* Protocol error */
    CASE_STR(A_ENODEV, msg);                   /* No such device */
    CASE_STR(A_EDEVNOTUP, msg);                /* device is not UP */
    CASE_STR(A_NO_RESOURCE, msg);              /* No resources for requested operation */
    CASE_STR(A_HARDWARE, msg);                 /* Hardware failure */
    CASE_STR(A_PENDING, msg);                  /* Asynchronous routine; will send up results la
ter (typically in callback) */
    CASE_STR(A_EBADCHANNEL, msg);              /* The channel cannot be used */
    CASE_STR(A_DECRYPT_ERROR, msg);            /* Decryption error */
    CASE_STR(A_PHY_ERROR, msg);                /* RX PHY error */
    CASE_STR(A_CONSUMED, msg);                    /* Object was consumed */
    CASE_DEF_STR(msg);
    }
    return msg;
}

static const char *btStatus2text(A_INT32 status)
{
    const char *btState;
    switch (status) {
    CASE_STR_CONST(BT_UNDEF, 1, btState);
    CASE_STR_CONST(BT_ON, 2, btState);
    CASE_STR_CONST(BT_OFF, 3, btState); 
    CASE_STR_CONST(BT_IGNORE, 4, btState);    
    CASE_DEF_STR(btState);
    }
    return btState;
}

static int cipher2text(char *buf, size_t len, A_UINT8 cipher)
{
    int ret = 0;
    BIT_STR(buf, len, ret, "none ", NONE_CRYPT, cipher);
    BIT_STR(buf, len, ret, "wep ", WEP_CRYPT, cipher);
    BIT_STR(buf, len, ret, "tkip ", TKIP_CRYPT, cipher);
    BIT_STR(buf, len, ret, "aes ", AES_CRYPT, cipher);
    buf[(ret>0) ? --ret : ret] = 0;
    return ret;
}

static const char* enable2text(A_INT32 enable)
{
    return enable ? "ENABLE" : "DISABLE";
}

static const char* txrxstatus2text(A_INT32 status)
{
    const char *txstatus;
    switch (status) {
    CASE_STR_CONST(TXRX_ERROR, -1, txstatus);
    CASE_STR_CONST(TXRX_OK                 ,  0, txstatus);
    CASE_STR_CONST(TXRX_FAILED             ,  1, txstatus);
    CASE_STR_CONST(TXRX_Q_IS_EMPTY         ,  2, txstatus);
    CASE_STR_CONST(TXRX_Q_NOT_DRAINED      ,  3, txstatus);
    CASE_STR_CONST(TXRX_Q_DRAINED_ALL      ,  4, txstatus);
    CASE_STR_CONST(TXRX_Q_DRAIN_PENDING    ,  5, txstatus);
    CASE_STR_CONST(TXRX_IS_MGMT_PKT        ,  6, txstatus);
    CASE_STR_CONST(TXRX_IS_DATA_PKT        ,  7, txstatus);
    CASE_STR_CONST(TXRX_SAVED_AS_FRAG      ,  8, txstatus);
    CASE_STR_CONST(TXRX_Q_IS_PAUSED        ,  9, txstatus);
    CASE_STR_CONST(TXRX_RX_SEND_TO_HOST    , 10, txstatus);
    CASE_STR_CONST(TXRX_ERROR_PKT_DRAINED  , 11, txstatus);
    CASE_STR_CONST(TXRX_EOL_EXPIRED        , 12, txstatus);
    CASE_STR_CONST(TXRX_PS_FILTERED        , 13,  txstatus);
    CASE_STR_CONST(TXRX_RX_SEND_TO_TX      , 14,  txstatus);
    CASE_DEF_STR(txstatus);
    }
    return txstatus;
}

static int rxfilter2text(char *buf, size_t blen, A_INT32 rxfilter)
{
    int ret = 0;  
    BIT_STR(buf, blen, ret, "UCAST "    , 0x00000001, rxfilter);
    BIT_STR(buf, blen, ret, "MCAST "    , 0x00000002, rxfilter);
    BIT_STR(buf, blen, ret, "BCAST "   , 0x00000004, rxfilter);
    BIT_STR(buf, blen, ret, "CONTROL "  , 0x00000008, rxfilter);
    BIT_STR(buf, blen, ret, "BEACON "  , 0x00000010, rxfilter);
    BIT_STR(buf, blen, ret, "PROM "    , 0x00000020, rxfilter);
    BIT_STR(buf, blen, ret, "PROBEREQ ", 0x00000080, rxfilter);
    BIT_STR(buf, blen, ret, "MYBEACON ", 0x00000200, rxfilter);
    BIT_STR(buf, blen, ret, "COMP_BAR ", 0x00000400, rxfilter);
    BIT_STR(buf, blen, ret, "COMP_BA " , 0x00000800, rxfilter);
    BIT_STR(buf, blen, ret, "UNCOMP_BA_BAR " , 0x00001000, rxfilter);
    BIT_STR(buf, blen, ret, "PS_POLL " , 0x00004000, rxfilter);
    BIT_STR(buf, blen, ret, "MCAST_BCAST_ALL " , 0x00008000, rxfilter);
    BIT_STR(buf, blen, ret, "FROM_TO_DS "      , 0x00020000, rxfilter);
    buf[(ret>0) ? --ret : ret] = 0;
    return ret;
}

static int btState2text(char *buf, size_t blen, A_INT32 btState)
{
    int bret = 0;
    BIT_STR(buf, blen, bret, "SCO ", (1<<1), btState);
    BIT_STR(buf, blen, bret, "A2DP ", (1<<2), btState);
    BIT_STR(buf, blen, bret, "SCAN ", (1<<3), btState);
    BIT_STR(buf, blen, bret, "ESCO ", (1<<4), btState);
    buf[(bret>0) ? --bret : bret] = 0;
    return bret;
}

static int btcoexFlags2text(char *buf, size_t blen, A_INT32 btCoexFlags)
{
    int bret = 0;
    BIT_STR(buf, blen, bret, "SCO_ON ", 0x0001, btCoexFlags);
    BIT_STR(buf, blen, bret, "A2DP_ON ", 0x0002, btCoexFlags);
    BIT_STR(buf, blen, bret, "ACL_ON ", 0x0004, btCoexFlags);
    BIT_STR(buf, blen, bret, "INQUIRY_ON ", 0x0008, btCoexFlags);
    BIT_STR(buf, blen, bret, "VOIP ", 0x0010, btCoexFlags);
    BIT_STR(buf, blen, bret, "RXDATA_PENDING ", 0x0020, btCoexFlags);
    BIT_STR(buf, blen, bret, "SLEEP_PENDING ", 0x0040, btCoexFlags);
    BIT_STR(buf, blen, bret, "FAKESLEEP_ON ", 0x0080, btCoexFlags);
    BIT_STR(buf, blen, bret, "ADD_BA_PENDING ", 0x0100, btCoexFlags);
    BIT_STR(buf, blen, bret, "WAKEUP_TIM_INTR ", 0x0200, btCoexFlags);
    BIT_STR(buf, blen, bret, "OPT_MODE ", 0x0400, btCoexFlags);
    BIT_STR(buf, blen, bret, "FIRST_BMISS ", 0x0800, btCoexFlags);
    BIT_STR(buf, blen, bret, "BEACON_PROTECION_ON ", 0x1000, btCoexFlags);
    BIT_STR(buf, blen, bret, "WAIT_FOR_NULL_COMP ", 0x4000, btCoexFlags);
    BIT_STR(buf, blen, bret, "PROTECT_POST_INQUIRY ", 0x8000, btCoexFlags);
    BIT_STR(buf, blen, bret, "DUAL_ANT_ACTIVE ", 0x10000, btCoexFlags);
    BIT_STR(buf, blen, bret, "DUAL_ANT_WAKEUP_TIM ", 0x20000, btCoexFlags);
    BIT_STR(buf, blen, bret, "STOMP_FOR_DTIM_RECV ", 0x40000, btCoexFlags);
    BIT_STR(buf, blen, bret, "ENABLE_COEX_ON_BCN_RECV ", 0x80000, btCoexFlags);
    buf[(bret>0) ? --bret : bret] = 0;
    return bret;
}

static int WMI_SET_MCAST_FILTER_CMDID_fmt(char *output, size_t len, const A_UINT8 *cmdbuf)
{
    WMI_SET_MCAST_FILTER_CMD *cmd = (WMI_SET_MCAST_FILTER_CMD*)cmdbuf;
    return snprintf(output, len, "%02X:%02X:%02X:%02X:%02X:%02X",
                    cmd->multicast_mac[0], cmd->multicast_mac[1], cmd->multicast_mac[2], 
                    cmd->multicast_mac[3], cmd->multicast_mac[4], cmd->multicast_mac[5]);
}

static int WMI_DEL_MCAST_FILTER_CMDID_fmt(char *output, size_t len, const A_UINT8 *cmdbuf)
{
    return WMI_SET_MCAST_FILTER_CMDID_fmt(output, len, cmdbuf);
}

static int WMI_MCAST_FILTER_CMDID_fmt(char *output, size_t len, const A_UINT8 *cmdbuf)
{
    WMI_MCAST_FILTER_CMD *cmd = (WMI_MCAST_FILTER_CMD*)cmdbuf;
    return snprintf(output, len, "%s", enable2text(cmd->enable));
}

static int WMI_START_SCAN_CMDID_fmt(char *output, size_t len, const A_UINT8 *cmdbuf)
{
    int i;
    int ret = 0;
    WMI_START_SCAN_CMD *cmd = (WMI_START_SCAN_CMD*)cmdbuf;
    const char *scanType = (cmd->scanType == WMI_SHORT_SCAN) ? "short" : "long";
    if (cmd->forceFgScan) {
        ret += snprintf(output+ret, len-ret, "forceFg ");
    }
    ret += snprintf(output+ret, len-ret, "hmdwell %u ", cmd->homeDwellTime);
    ret += snprintf(output+ret, len-ret, "fscanint %u ", cmd->forceScanInterval);
    ret += snprintf(output+ret, len-ret, "%s ", scanType);
    for (i=0; i<cmd->numChannels; ++i) {
        ret += snprintf(output+ret, len-ret, "%d ", cmd->channelList[i]);
    }
    return ret;
}

static int WMI_CONNECT_CMDID_fmt(char *output, size_t len, const A_UINT8 *cmdbuf)
{
    WMI_CONNECT_CMD *cmd = (WMI_CONNECT_CMD*)cmdbuf;
    char ssid[33];
    char pairwise[128], group[128];
    const char *dot11Auth, *authMode;
    memcpy(ssid, cmd->ssid, 32);
    ssid[cmd->ssidLength] = 0;
    cipher2text(pairwise, sizeof(pairwise), cmd->pairwiseCryptoType);
    cipher2text(group, sizeof(group), cmd->groupCryptoType);

    switch (cmd->dot11AuthMode) {
    CASE_STR(OPEN_AUTH, dot11Auth);
    CASE_STR(SHARED_AUTH, dot11Auth);
    CASE_STR(LEAP_AUTH, dot11Auth);
    CASE_DEF_STR(dot11Auth);
    }

    switch (cmd->authMode) {
    CASE_STR(WMI_NONE_AUTH, authMode);
    CASE_STR(WMI_WPA_AUTH, authMode);
    CASE_STR(WMI_WPA2_AUTH, authMode);
    CASE_STR(WMI_WPA_PSK_AUTH, authMode);
    CASE_STR(WMI_WPA2_PSK_AUTH, authMode);
    CASE_STR(WMI_WPA_AUTH_CCKM, authMode);
    CASE_STR(WMI_WPA2_AUTH_CCKM, authMode);
    CASE_DEF_STR(authMode);
    }
    return snprintf(output, len, "'%s' ch %d %s %s uni:%s grp:%s %02X:%02X:%02X:%02X:%02X:%02X ctrl 0x%x",
        ssid, cmd->channel, 
        dot11Auth, authMode, pairwise, group,
        cmd->bssid[0], cmd->bssid[1], cmd->bssid[2], 
        cmd->bssid[3], cmd->bssid[4], cmd->bssid[5], 
        cmd->ctrl_flags);
}

static int WMI_SET_BTCOEX_FE_ANT_CMDID_fmt(char *output, size_t len, const A_UINT8 *cmdbuf)
{
    WMI_SET_BTCOEX_FE_ANT_CMD *cmd = (WMI_SET_BTCOEX_FE_ANT_CMD*)cmdbuf;
    const char *fe;
    switch (cmd->btcoexFeAntType) {
    CASE_STR(WMI_BTCOEX_NOT_ENABLED, fe);
    CASE_STR(WMI_BTCOEX_FE_ANT_SINGLE, fe);
    CASE_STR(WMI_BTCOEX_FE_ANT_DUAL, fe);
    CASE_STR(WMI_BTCOEX_FE_ANT_DUAL_HIGH_ISO, fe);
    CASE_DEF_STR(fe);
    }
    return snprintf(output, len, "%s", fe);
}

static int WMI_SET_BTCOEX_SCO_CONFIG_CMDID_fmt(char *output, size_t len, const A_UINT8 *cmdbuf)
{
    WMI_SET_BTCOEX_SCO_CONFIG_CMD *cmd = (WMI_SET_BTCOEX_SCO_CONFIG_CMD*)cmdbuf;
    char scoFlags[512];
    int blen = sizeof(scoFlags);
    int bret = 0;
    BIT_STR(scoFlags, blen, bret, "OPT ", (1<<0), cmd->scoConfig.scoFlags);
    BIT_STR(scoFlags, blen, bret, "EDR ", (1<<1), cmd->scoConfig.scoFlags);   
    BIT_STR(scoFlags, blen, bret, "MASTER ", (1<<2), cmd->scoConfig.scoFlags);
    BIT_STR(scoFlags, blen, bret, "FRM ", (1<<3), cmd->scoConfig.scoFlags);
    scoFlags[(bret>0) ? --bret : bret] = 0;

    return snprintf(output, len, "%d/%d slots [%s] ps %u-%u-%u opt %u-%u-%u-%u-%u-%u scan %u/%u", 
                    cmd->scoConfig.scoSlots, cmd->scoConfig.scoIdleSlots, scoFlags,

                    cmd->scoPspollConfig.scoCyclesForceTrigger,
                    cmd->scoPspollConfig.scoDataResponseTimeout,
                    cmd->scoPspollConfig.scoPsPollLatencyFraction,

                    cmd->scoOptModeConfig.scoStompCntIn100ms,
	                cmd->scoOptModeConfig.scoContStompMax,
	                cmd->scoOptModeConfig.scoMinlowRateMbps,
	                cmd->scoOptModeConfig.scoLowRateCnt,
	                cmd->scoOptModeConfig.scoHighPktRatio,
	                cmd->scoOptModeConfig.scoMaxAggrSize,

                    cmd->scoWlanScanConfig.scanInterval,
                    cmd->scoWlanScanConfig.maxScanStompCnt);
}

static int WMI_SET_BTCOEX_A2DP_CONFIG_CMDID_fmt(char *output, size_t len, const A_UINT8 *cmdbuf)
{
    return 0;
}

static int WMI_SET_BTCOEX_ACLCOEX_CONFIG_CMDID_fmt(char *output, size_t len, const A_UINT8 *cmdbuf)
{
    return 0;
}

static int WMI_SET_BTCOEX_BTINQUIRY_PAGE_CONFIG_CMDID_fmt(char *output, size_t len, const A_UINT8 *cmdbuf)
{
    WMI_SET_BTCOEX_BTINQUIRY_PAGE_CONFIG_CMD *cmd = (WMI_SET_BTCOEX_BTINQUIRY_PAGE_CONFIG_CMD*)cmdbuf;
    return snprintf(output, len, "pspoll every %u inquiry duration %u",
                    cmd->btInquiryDataFetchFrequency,
                    cmd->protectBmissDurPostBtInquiry);
}

static int WMI_SET_BTCOEX_BT_OPERATING_STATUS_CMDID_fmt(char *output, size_t len, const A_UINT8 *cmdbuf)
{
    WMI_SET_BTCOEX_BT_OPERATING_STATUS_CMD *cmd = (WMI_SET_BTCOEX_BT_OPERATING_STATUS_CMD*)cmdbuf;
    const char *profile;
    const char *op = (cmd->btOperatingStatus==1) ? "START" : "STOP";
    switch (cmd->btProfileType) {
    CASE_STR_CONST(SCO, 1, profile);
    CASE_STR_CONST(A2DP, 2, profile);
    CASE_STR_CONST(Inquiry, 3, profile);
    CASE_STR_CONST(ACL, 4, profile);
    CASE_DEF_STR(profile);
    }
    return snprintf(output, len, "%s %s", profile, op);
}

static int WMI_SET_LISTEN_INT_CMDID_fmt(char *output, size_t len, const A_UINT8 *cmdbuf)
{
    WMI_LISTEN_INT_CMD *cmd = (WMI_LISTEN_INT_CMD*)cmdbuf;
    return snprintf(output, len, "interval %d numBeacons %d", cmd->listenInterval, cmd->numBeacons);
}

static int WMI_SET_BSS_FILTER_CMDID_fmt(char *output, size_t len, const A_UINT8 *cmdbuf)
{
    WMI_BSS_FILTER_CMD *cmd = (WMI_BSS_FILTER_CMD*)cmdbuf;
    const char *filter;
    switch (cmd->bssFilter) {
    CASE_STR(NONE_BSS_FILTER, filter);
    CASE_STR(ALL_BSS_FILTER, filter);
    CASE_STR(PROFILE_FILTER, filter);
    CASE_STR(ALL_BUT_PROFILE_FILTER, filter);
    CASE_STR(CURRENT_BSS_FILTER, filter);
    CASE_STR(ALL_BUT_BSS_FILTER, filter);
    CASE_STR(PROBED_SSID_FILTER, filter);
    CASE_STR(LAST_BSS_FILTER, filter);
    CASE_DEF_STR(filter);
    }
    return snprintf(output, len, "[%s]", filter);
}

static int CO_CHANGE_CHANNEL_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    A_INT32 freq = buffer[1];
    A_INT32 duration = buffer[2];
    return snprintf(output, len, "freq %d duration %d", freq, duration);
}

static int CO_CHANGE_STATE_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    A_INT32 stateLog = (numargs==1) ? buffer[1] : buffer[2];
    int op = stateLog & 0xff;
    const char *opstr = op ? "set" : "clr";
    int opState = (stateLog >> 8) & 0xff;
    int oldState = stateLog >> 16;
    int newState = (op) ? (oldState | opState) : (oldState & ~(opState));
    char state[256];
    size_t blen = sizeof(state);
    int ret = 0;
    BIT_STR(state, blen, ret, "DRAIN_IN_PROGRESS ", 0x01, newState);
    BIT_STR(state, blen, ret, "FAKE_SLEEP_ENABLE_IN_PROGRESS ", 0x02, newState);
    BIT_STR(state, blen, ret, "FAKE_SLEEP_ENABLED ", 0x04, newState);
    BIT_STR(state, blen, ret, "TXQ_PAUSED ", 0x08, newState);
    BIT_STR(state, blen, ret, "CHANNEL_CHANGE_IN_PROGRESS ", 0x10, newState);
    state[(ret>0) ? --ret : ret] = 0;

    ret = 0;
    if (numargs==2) {
        ret = snprintf(output+ret, len-ret, "dev %d ", buffer[1]);
    }
    ret += snprintf(output+ret, len-ret, "0x%x %s 0x%x->0x%x [%s]",
                    oldState, opstr, opState, newState, state);
    return ret;
}

static int TXRX_MGMTBUF_WLAN_RESET_ON_ERROR_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    if (numargs==1) {
        char buf[512];
        A_INT32 rxfilter = buffer[1];
        rxfilter2text(buf, sizeof(buf),rxfilter);
        return snprintf(output, len, "rxfilter:[%s]", buf);
    } else if (numargs==2) {
        return snprintf(output, len, "rstCnt %d caller %p", 
                        buffer[1], (void*)buffer[2]);
    } else {
        return 0;
    }
}
static int TXRX_MGMTBUF_WAIT_FOR_TXQ_DRAIN_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    const char *mid;
    switch (buffer[2]) {
    CASE_STR_CONST(CO, 0x001, mid);
    CASE_STR_CONST(PM, 0x002, mid);
    CASE_STR_CONST(BTCOEX, 0x004, mid);
    CASE_DEF_STR(mid);
    }
    return snprintf(output, len, "wait drain %d ms %s ", buffer[1], mid);
}

static int TXRX_MGMTBUF_REAPED_BUF_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    const char *txstatus = txrxstatus2text(buffer[2]);
    return snprintf(output, len, "mgt %p %s", (void*)buffer[1], txstatus);
}

static int TXRX_MGMTBUF_DRAINQ_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    A_INT32 hwq = buffer[1];
    A_INT32 depth = buffer[2];
    return snprintf(output, len, "hwq 0x%x depth 0x%x", hwq, depth);
}

static int DC_RECEIVED_ANY_BEACON_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    if (numargs==1) {
        A_INT32 addr3 = buffer[1];
        return snprintf(output, len, "addr3 ??:??:%02X:%02X:%02X:%02X",
                 (addr3 & 0xff), ((addr3>>8)&0xff), ((addr3>>16)&0xff), ((addr3>>24)&0xff));
    } else if (numargs==2) {
        A_UINT64 tsf;
        A_UINT8 ie_tstamp[8];
        ie_tstamp[4] = buffer[1] & 0xff;
        ie_tstamp[5] = (buffer[1]>>8) & 0xff;
        ie_tstamp[6] = (buffer[1]>>16) & 0xff;
        ie_tstamp[7] = (buffer[1]>>24) & 0xff;
        ie_tstamp[0] = buffer[2] & 0xff;
        ie_tstamp[1] = (buffer[2]>>8) & 0xff;
        ie_tstamp[2] = (buffer[2]>>16) & 0xff;
        ie_tstamp[3] = (buffer[2]>>24) & 0xff;
        A_MEMCPY((A_UINT8 *)&tsf, ie_tstamp, sizeof(ie_tstamp));
        return snprintf(output, len, "ie_tsf %llu", tsf);
    }
    return 0;
}

static int DC_SET_POWER_MODE_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    const char *pm = pmmode2text(buffer[1]);
    return snprintf(output, len, "%s caller %p", pm, (void*)buffer[2]);
}

static int DC_SSID_PROBE_CB_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    const char *txstatus = txrxstatus2text(buffer[1]);
    return snprintf(output, len, "%s", txstatus);
}

static int DC_SEARCH_OPPORTUNITY_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    const char *opt;
    switch (buffer[1]) {
    CASE_STR_CONST(SCAN_IN_PROGRESS, 1, opt);
    CASE_STR_CONST(NOT_SCAN_IN_PROGRESS,  0, opt);
    CASE_DEF_STR(opt);
    }
    return snprintf(output, len, "%s", opt);
}

static int DC_SEND_NEXT_SSID_PROBE_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    const char *flags;
    switch (buffer[2]) {
    CASE_STR(DISABLE_SSID_FLAG, flags);
    CASE_STR(SPECIFIC_SSID_FLAG, flags);
    CASE_STR(ANY_SSID_FLAG, flags);
    CASE_DEF_STR(flags);
    }  
    return snprintf(output, len, "idx %d %s", buffer[1], flags);
}

static int DC_SCAN_CHAN_FINISH_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    A_UINT16 freq = buffer[1] & 0xffff;
    A_UINT16 status = (buffer[1] >> 16) & 0xffff;
    A_INT32 rxfilter = buffer[2];   
    char rxfilterMsg[1024];
    rxfilter2text(rxfilterMsg, sizeof(rxfilterMsg), rxfilter);
    return snprintf(output, len, "freq %d status %s(%d), %s", 
                    freq, status2text(status), status, rxfilterMsg);
}

static int DC_SCAN_CHAN_START_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    A_INT32 rxfilter = buffer[2];   
    char rxfilterMsg[1024];
    A_UINT16 freq;
    A_UINT16 attrib;
    const char *probed;
    rxfilter2text(rxfilterMsg, sizeof(rxfilterMsg), rxfilter);
    freq = buffer[1] & 0xffff;
    attrib = (buffer[1] >> 16) & 0xffff;
    probed = ((attrib & (0x0100|0x10))==(0x0100|0x10)) && !(attrib &  0x0800) ? "allow" : "not allow";

    return snprintf(output, len, "freq %d attrib %d probed %s %s", 
                    freq, attrib, probed, rxfilterMsg);
}

static int DC_START_SEARCH_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    if (numargs==1) {
        return snprintf(output, len, "devid %d", buffer[1]);
    } else {
        A_INT32 stype = buffer[1];
        int ret = 0;  
        char buf[1024];
        size_t blen = sizeof(buf);
        if (stype == 0) {
            BIT_STR(buf, blen, ret, "RESET "                     , 0, stype);
        }
        BIT_STR(buf, blen, ret, "ALL "                      , (0x01|0x02|0x04|0x08), stype);
        if (((0x01|0x02|0x04|0x08)& stype)!=(0x01|0x02|0x04|0x08)) {
            BIT_STR(buf, blen, ret, "POPULAR "                   , (0x02 | 0x04 | 0x08), stype);
            if (((0x02|0x04|0x08)& stype)!=(0x02|0x04|0x08)) {
                BIT_STR(buf, blen, ret, "SSIDS "                     , (0x04 | 0x08), stype);
                if (((0x04|0x08)& stype)!=(0x04|0x08)) {
                    BIT_STR(buf, blen, ret, "PROF_MASK "                 , (0x08), stype);
                }
            }
        }

        BIT_STR(buf, blen, ret, "MULTI_CHANNEL "             , 0x000100, stype);
        BIT_STR(buf, blen, ret, "DETERMINISTIC "             , 0x000200, stype);
        BIT_STR(buf, blen, ret, "PROFILE_MATCH_TERMINATED "  , 0x000400, stype);
        BIT_STR(buf, blen, ret, "HOME_CHANNEL_SKIP "         , 0x000800, stype);
        BIT_STR(buf, blen, ret, "CHANNEL_LIST_CONTINUE "     , 0x001000, stype);
        BIT_STR(buf, blen, ret, "CURRENT_SSID_SKIP "         , 0x002000, stype);
        BIT_STR(buf, blen, ret, "ACTIVE_PROBE_DISABLE "      , 0x004000, stype);
        BIT_STR(buf, blen, ret, "CHANNEL_HINT_ONLY "         , 0x008000, stype);
        BIT_STR(buf, blen, ret, "ACTIVE_CHANNELS_ONLY "      , 0x010000, stype);
        BIT_STR(buf, blen, ret, "UNUSED1 "                   , 0x020000, stype);
        BIT_STR(buf, blen, ret, "PERIODIC "                  , 0x040000, stype);
        BIT_STR(buf, blen, ret, "FIXED_DURATION "            , 0x080000, stype);
        BIT_STR(buf, blen, ret, "AP_ASSISTED "               , 0x100000, stype);
        buf[(ret>0) ? --ret : ret] = 0;
        return snprintf(output, len, "%s cb 0x%x", buf, buffer[2]);
    }
}

static int PM_CHAN_OP_REQ_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    const char *start = (buffer[1]==1) ? "start" : "stop";
    A_INT32 chanOpReq = buffer[2];
    return snprintf(output, len, "%s chan OpReq %d", start, chanOpReq);
}

static int PM_SET_ALL_BEACON_POLICY_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    const char *policyMsg;
    A_UINT16 policy = buffer[1];
    A_UINT32 cnt = buffer[2];
    switch (policy) {
    CASE_STR_CONST(disallow, 1, policyMsg);
    CASE_STR_CONST(allow, 2, policyMsg);
    CASE_DEF_STR(policyMsg);
    }
    return snprintf(output, len, "%s beacons filterCnt %d", policyMsg, cnt);
}

static int PM_SET_MY_BEACON_POLICY_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    const char *policyMsg;
    A_UINT16 policy = buffer[1] & 0xff;
    A_UINT32 bMiss = (buffer[1] >> 8);
    A_UINT32 myBeaconCnt = buffer[2];
    switch (policy) {
    CASE_STR_CONST(disallow, 1, policyMsg);
    CASE_STR_CONST(allow, 2, policyMsg);
    CASE_DEF_STR(policyMsg);
    }
    return snprintf(output, len, "bmiss %d %s during sleep filterCnt %d", bMiss, policyMsg, myBeaconCnt);
}


static int PM_SET_STATE_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    A_INT16 pmStateWakeupCount = (buffer[1] >> 16) & 0xffff;
    A_INT16 pmState = buffer[1] & 0xffff;
    A_INT16 pmAwakeCount = (buffer[2] >> 16) & 0xffff;
    A_INT8 pmSleepCount = (buffer[2] >> 8) & 0xff;
    A_INT8 pmOldState = buffer[2] & 0xff;
    return snprintf(output, len, "StateWakeupCnt %d AwakeCnt %d, SleepCnt %d, %s to %s",
                    pmStateWakeupCount, pmAwakeCount, pmSleepCount, 
                    pmmode2text(pmOldState), pmmode2text(pmState));
}

static int PM_SET_POWERMODE_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    A_UINT16 wcnt = buffer[1] >> 16;
    A_UINT16 fakeSleep = buffer[1] & 0xffff;
    A_UINT16 oldPowerMode = buffer[2] >> 16;
    A_UINT8 powerMode = (buffer[2] >> 8) & 0xff;
    A_UINT8 moduleId = buffer[2] & 0xff;
    return snprintf(output, len, "wakeCnt %d fakeSleep %d %s(%d)=>%s(%d) %s(%d)",
         wcnt, fakeSleep, pmmode2text(oldPowerMode), oldPowerMode, pmmode2text(powerMode), powerMode, pmmodule2text(moduleId), moduleId);
}

static int PM_FAKE_SLEEP_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    A_INT16 enable = (buffer[1] >> 16) & 0xffff;
    const char *state = enable2text(enable);
    A_INT8 pmFakeSleepCount = (buffer[1] >> 8) & 0xff;
    A_INT8 fakeSleepEnable = (buffer[1] & 0xff);
    A_INT16 forceAwake = (buffer[2] >> 16) & 0xffff;
    A_INT8 dontWaitForDrain = (buffer[2] >> 8) & 0xff;
    A_INT8 module = buffer[2] & 0xff;
    return snprintf(output, len, "%s cnt %d hasCnt %d forceAwake %d dontWaitDrain %d %s(%d)",
            state, pmFakeSleepCount, fakeSleepEnable, forceAwake, dontWaitForDrain, pmmodule2text(module), module);
}

static int BTCOEX_DBG_pmwakeupcnt_flags(char *output, size_t len, A_INT32 pmWakeupCnt, A_INT32 btCoexFlags)
{
    int ret = 0;
    ret += snprintf(output+ret, len-ret, "coexPmWakeupCnt %d", pmWakeupCnt);
    if (btCoexFlags!=-1) {
        char buf[512];
        btcoexFlags2text(buf, sizeof(buf), btCoexFlags);
        ret += snprintf(output+ret, len-ret, " coex [%s]", buf);
    }
    return ret;
}

static int BTCOEX_ACL_COEX_STATUS_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    A_INT32 btStatus = (buffer[1] >> 16) & 0xffff;
    A_INT32 redoAggr = buffer[1] & 0xffff;
    return snprintf(output, len, "%s redoAggr %d", btStatus2text(btStatus), redoAggr);
}

static int BTCOEX_DBG_PM_SLEEP_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    A_INT32 pmWakeupCnt = buffer[1];
    A_INT32 btCoexFlags = buffer[2];
    return BTCOEX_DBG_pmwakeupcnt_flags(output,len,pmWakeupCnt,btCoexFlags); 
}

static int BTCOEX_PSPOLL_QUEUED_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    A_INT16 isEolEnabled = (buffer[1] >> 16) & 0xffff;
    A_INT8 bSendAtLowestRate = (buffer[1] >>8) & 0xff;
    A_INT8 isPmSleep = (buffer[1]) & 0xff;
    return snprintf(output, len, "Eol:%s LowestRate:%s PmSleep:%s", 
                    enable2text(isEolEnabled), enable2text(bSendAtLowestRate),
                    enable2text(isPmSleep));
}

static int BTCOEX_PSPOLL_COMPLETE_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    return snprintf(output, len, "%s", txrxstatus2text(buffer[1]));
}

static int BTCOEX_DBG_PM_AWAKE_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    return BTCOEX_DBG_PM_SLEEP_fmt(output,len,numargs,buffer);
}

static int BTCOEX_DBG_GO_TO_SLEEP_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    return BTCOEX_DBG_pmwakeupcnt_flags(output,len,buffer[1],-1);
}

static int BTCOEX_WAKEUP_ON_DATA_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    return BTCOEX_DBG_pmwakeupcnt_flags(output,len,buffer[2], buffer[1]);
}

static int BTCOEX_TIM_NOTIFICATION_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    int ret = 0;
    A_INT32 btCoexFlags = buffer[1];
    A_INT32 btStatus = (buffer[2]>>16) & 0xffff;
    A_INT32 pmWakeupCnt = (buffer[2] & 0xffff);
    ret = BTCOEX_DBG_pmwakeupcnt_flags(output,len, pmWakeupCnt, btCoexFlags);
    ret += snprintf(output+ret, len-ret, " %s", btStatus2text(btStatus));
    return ret;
}

static int BTCOEX_DBG_ALLOW_SCAN_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    char buf[512];
    A_INT32 retStatus = buffer[2];
    A_INT32 btState = buffer[1];
    btState2text(buf, sizeof(buf), btState);
    return snprintf(output, len, "state: [%s] allow:%d", buf, retStatus);
}

static int BTCOEX_DBG_SCAN_REQUEST_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    char buf[512];
    A_INT32 scanReqEnabled = buffer[2];
    A_INT32 btState = buffer[1];
    btState2text(buf, sizeof(buf), btState);
    return snprintf(output, len, "state: [%s] scanReqEnabled:%d", buf, scanReqEnabled);
}

static int BTCOEX_DBG_SET_WLAN_STATE_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    A_INT32 btCoexFlags = buffer[2];
    char buf[512];
    const char *wlanState;
    switch (buffer[1]) {
    CASE_STR_CONST(IDLE     , 1, wlanState);
    CASE_STR_CONST(CONNECTED , 2, wlanState);
    CASE_STR_CONST(SCAN_START  , 3, wlanState);
    CASE_STR_CONST(CONNECT_START ,4, wlanState);
    CASE_STR_CONST(SCAN_END    , 5, wlanState);
    CASE_STR_CONST(APMODE_STA_CONNECTED , 6, wlanState);
    CASE_STR_CONST(APMODE_IDLE , 7, wlanState);
    CASE_STR_CONST(APMODE_SWITCH , 8, wlanState);
    CASE_STR_CONST(APMODE_TEARDOWN , 9, wlanState);
    CASE_DEF_STR(wlanState);
    }
    btcoexFlags2text(buf, sizeof(buf), btCoexFlags);
    return snprintf(output, len, "wlan %s coex [%s]", wlanState, buf);
}

static int BTCOEX_DBG_BT_INQUIRY_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    const char *btState = btStatus2text(buffer[1]);
    A_INT32 btCoexFlags = buffer[2];
    char buf[512];
    btcoexFlags2text(buf, sizeof(buf), btCoexFlags);
    return snprintf(output, len, "%s coex [%s]", btState, buf);
}

static int BTCOEX_SET_WEIGHTS_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    const char *weights;
    switch (buffer[1]) {
    CASE_STR_CONST(ALL_BT_TRAFFIC,1,weights);
    CASE_STR_CONST(ONLY_HIGH_PRI_BT_TRAFFIC,2,weights);
    CASE_STR_CONST(STOMP_ALL_BT_TRAFFIC,3,weights);
    CASE_STR_CONST(ONLY_A2DP_TRAFFIC,4,weights);
    CASE_STR_CONST(ONLY_HIGH_PRIO_AND_A2DP,5,weights);
    CASE_STR_CONST(A2DP_STOMPED,6,weights);
    CASE_STR_CONST(ALL_BT_TRAFFIC_WTX,7,weights);
    CASE_STR_CONST(ALL_BT_TRAFFIC_WTX_HIGHISO_TXRX,8,weights);
    CASE_STR_CONST(HIGH_PRI_TRAFFIC_WTX,9,weights);
    CASE_STR_CONST(HIGH_PRI_TRAFFIC_WTX_HIGHISO_TXRX,0xa,weights);
    CASE_STR_CONST(MCI_TEST,0xb,weights);
    CASE_DEF_STR(weights);
    }

    return snprintf(output, len, "%s val 0x%x", weights, buffer[2]);    
}

static int BTCOEX_PM_FAKE_SLEEP_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    const char *enable = enable2text(buffer[1]);
    A_STATUS status = buffer[2];
    return snprintf(output, len, "%s -> %s", enable, status2text(status));
}

static const struct wmi_id_desc evt_desc[] = {
    WM_ID_DESC(WMI_READY_EVENTID), 
    WM_ID_DESC(WMI_CONNECT_EVENTID),
    WM_ID_DESC(WMI_DISCONNECT_EVENTID),
    WM_ID_DESC(WMI_BSSINFO_EVENTID),
    WM_ID_DESC(WMI_CMDERROR_EVENTID),
    WM_ID_DESC(WMI_REGDOMAIN_EVENTID),
    WM_ID_DESC(WMI_PSTREAM_TIMEOUT_EVENTID),
    WM_ID_DESC(WMI_NEIGHBOR_REPORT_EVENTID),
    WM_ID_DESC(WMI_TKIP_MICERR_EVENTID),
    WM_ID_DESC(WMI_SCAN_COMPLETE_EVENTID),           /* 0x100a */
    WM_ID_DESC(WMI_REPORT_STATISTICS_EVENTID),
    WM_ID_DESC(WMI_RSSI_THRESHOLD_EVENTID),
    WM_ID_DESC(WMI_ERROR_REPORT_EVENTID),
    WM_ID_DESC(WMI_OPT_RX_FRAME_EVENTID),
    WM_ID_DESC(WMI_REPORT_ROAM_TBL_EVENTID),
    WM_ID_DESC(WMI_EXTENSION_EVENTID),
    WM_ID_DESC(WMI_CAC_EVENTID),
    WM_ID_DESC(WMI_SNR_THRESHOLD_EVENTID),
    WM_ID_DESC(WMI_LQ_THRESHOLD_EVENTID),
    WM_ID_DESC(WMI_TX_RETRY_ERR_EVENTID),            /* 0x1014 */
    WM_ID_DESC(WMI_REPORT_ROAM_DATA_EVENTID),
    WM_ID_DESC(WMI_TEST_EVENTID),
    WM_ID_DESC(WMI_APLIST_EVENTID),
    WM_ID_DESC(WMI_GET_WOW_LIST_EVENTID),
    WM_ID_DESC(WMI_GET_PMKID_LIST_EVENTID),
    WM_ID_DESC(WMI_CHANNEL_CHANGE_EVENTID),
    WM_ID_DESC(WMI_PEER_NODE_EVENTID),
    WM_ID_DESC(WMI_PSPOLL_EVENTID),
    WM_ID_DESC(WMI_DTIMEXPIRY_EVENTID),
    WM_ID_DESC(WMI_WLAN_VERSION_EVENTID),
    WM_ID_DESC(WMI_SET_PARAMS_REPLY_EVENTID),
    WM_ID_DESC(WMI_ADDBA_REQ_EVENTID),              /*0x1020 */
    WM_ID_DESC(WMI_ADDBA_RESP_EVENTID),
    WM_ID_DESC(WMI_DELBA_REQ_EVENTID),
    WM_ID_DESC(WMI_TX_COMPLETE_EVENTID),
    WM_ID_DESC(WMI_HCI_EVENT_EVENTID),
    WM_ID_DESC(WMI_ACL_DATA_EVENTID),
    WM_ID_DESC(WMI_REPORT_SLEEP_STATE_EVENTID),

    WM_ID_DESC(WMI_WAPI_REKEY_EVENTID),

    WM_ID_DESC(WMI_REPORT_BTCOEX_STATS_EVENTID),
    WM_ID_DESC(WMI_REPORT_BTCOEX_CONFIG_EVENTID),
    WM_ID_DESC(WMI_GET_PMK_EVENTID),

    /* DFS Events */
    WM_ID_DESC(WMI_DFS_HOST_ATTACH_EVENTID),
    WM_ID_DESC(WMI_DFS_HOST_INIT_EVENTID),
    WM_ID_DESC(WMI_DFS_RESET_DELAYLINES_EVENTID),
    WM_ID_DESC(WMI_DFS_RESET_RADARQ_EVENTID),
    WM_ID_DESC(WMI_DFS_RESET_AR_EVENTID),
    WM_ID_DESC(WMI_DFS_RESET_ARQ_EVENTID),          /*0x1030*/
    WM_ID_DESC(WMI_DFS_SET_DUR_MULTIPLIER_EVENTID),
    WM_ID_DESC(WMI_DFS_SET_BANGRADAR_EVENTID),
    WM_ID_DESC(WMI_DFS_SET_DEBUGLEVEL_EVENTID),
    WM_ID_DESC(WMI_DFS_PHYERR_EVENTID),
    /* CCX Evants */
    WM_ID_DESC(WMI_CCX_RM_STATUS_EVENTID),

    /* P2P Events */
    WM_ID_DESC(WMI_P2P_GO_NEG_RESULT_EVENTID),

    WM_ID_DESC(WMI_WAC_SCAN_DONE_EVENTID),
    WM_ID_DESC(WMI_WAC_REPORT_BSS_EVENTID),
    WM_ID_DESC(WMI_WAC_START_WPS_EVENTID),
    WM_ID_DESC(WMI_WAC_CTRL_REQ_REPLY_EVENTID),
        
    /*RFKILL Events*/
    WM_ID_DESC(WMI_RFKILL_STATE_CHANGE_EVENTID),
    WM_ID_DESC(WMI_RFKILL_GET_MODE_CMD_EVENTID),

    /* More P2P Events */
    WM_ID_DESC(WMI_P2P_GO_NEG_REQ_EVENTID),
    WM_ID_DESC(WMI_P2P_INVITE_REQ_EVENTID),
    WM_ID_DESC(WMI_P2P_INVITE_RCVD_RESULT_EVENTID),
    WM_ID_DESC(WMI_P2P_INVITE_SENT_RESULT_EVENTID), /*1040*/
    WM_ID_DESC(WMI_P2P_PROV_DISC_RESP_EVENTID),
    WM_ID_DESC(WMI_P2P_PROV_DISC_REQ_EVENTID),
    WM_ID_DESC(WMI_P2P_START_SDPD_EVENTID),
    WM_ID_DESC(WMI_P2P_SDPD_RX_EVENTID),

    /* Special event to notify host that cmd is processed and credit report is returned */
    WM_ID_DESC(WMI_SET_HOST_SLEEP_MODE_CMD_PROCESSED_EVENTID),
};

static const struct wmi_id_desc cmds_desc[] = {
    WM_ID_DESC_FMT(WMI_CONNECT_CMDID, sizeof(WMI_CONNECT_CMD)),
    WM_ID_DESC(WMI_RECONNECT_CMDID),
    WM_ID_DESC(WMI_DISCONNECT_CMDID),
    WM_ID_DESC(WMI_SYNCHRONIZE_CMDID),
    WM_ID_DESC(WMI_CREATE_PSTREAM_CMDID),
    WM_ID_DESC(WMI_DELETE_PSTREAM_CMDID),
    WM_ID_DESC_FMT(WMI_START_SCAN_CMDID, sizeof(WMI_START_SCAN_CMD)),
    WM_ID_DESC(WMI_SET_SCAN_PARAMS_CMDID),
    WM_ID_DESC_FMT(WMI_SET_BSS_FILTER_CMDID, sizeof(WMI_BSS_FILTER_CMD)),
    WM_ID_DESC(WMI_SET_PROBED_SSID_CMDID),               /* 10 */
    WM_ID_DESC_FMT(WMI_SET_LISTEN_INT_CMDID, sizeof(WMI_LISTEN_INT_CMD)),
    WM_ID_DESC(WMI_SET_BMISS_TIME_CMDID),
    WM_ID_DESC(WMI_SET_DISC_TIMEOUT_CMDID),
    WM_ID_DESC(WMI_GET_CHANNEL_LIST_CMDID),
    WM_ID_DESC(WMI_SET_BEACON_INT_CMDID),
    WM_ID_DESC(WMI_GET_STATISTICS_CMDID),
    WM_ID_DESC(WMI_SET_CHANNEL_PARAMS_CMDID),
    WM_ID_DESC(WMI_SET_POWER_MODE_CMDID),
    WM_ID_DESC(WMI_SET_IBSS_PM_CAPS_CMDID),
    WM_ID_DESC(WMI_SET_POWER_PARAMS_CMDID),              /* 20 */
    WM_ID_DESC(WMI_SET_POWERSAVE_TIMERS_POLICY_CMDID),
    WM_ID_DESC(WMI_ADD_CIPHER_KEY_CMDID),
    WM_ID_DESC(WMI_DELETE_CIPHER_KEY_CMDID),
    WM_ID_DESC(WMI_ADD_KRK_CMDID),
    WM_ID_DESC(WMI_DELETE_KRK_CMDID),
    WM_ID_DESC(WMI_SET_PMKID_CMDID),
    WM_ID_DESC(WMI_SET_TX_PWR_CMDID),
    WM_ID_DESC(WMI_GET_TX_PWR_CMDID),
    WM_ID_DESC(WMI_SET_ASSOC_INFO_CMDID),
    WM_ID_DESC(WMI_ADD_BAD_AP_CMDID),                    /* 30 */
    WM_ID_DESC(WMI_DELETE_BAD_AP_CMDID),
    WM_ID_DESC(WMI_SET_TKIP_COUNTERMEASURES_CMDID),
    WM_ID_DESC(WMI_RSSI_THRESHOLD_PARAMS_CMDID),
    WM_ID_DESC(WMI_TARGET_ERROR_REPORT_BITMASK_CMDID),
    WM_ID_DESC(WMI_SET_ACCESS_PARAMS_CMDID),
    WM_ID_DESC(WMI_SET_RETRY_LIMITS_CMDID),
    WM_ID_DESC(WMI_RESERVED1),
    WM_ID_DESC(WMI_RESERVED2),
    WM_ID_DESC(WMI_SET_VOICE_PKT_SIZE_CMDID),
    WM_ID_DESC(WMI_SET_MAX_SP_LEN_CMDID),                /* 40 */
    WM_ID_DESC(WMI_SET_ROAM_CTRL_CMDID),
    WM_ID_DESC(WMI_GET_ROAM_TBL_CMDID),
    WM_ID_DESC(WMI_GET_ROAM_DATA_CMDID),
    WM_ID_DESC(WMI_ENABLE_RM_CMDID),
    WM_ID_DESC(WMI_SET_MAX_OFFHOME_DURATION_CMDID),
    WM_ID_DESC(WMI_EXTENSION_CMDID),                        /* Non-wireless extensions */
    WM_ID_DESC(WMI_SNR_THRESHOLD_PARAMS_CMDID),
    WM_ID_DESC(WMI_LQ_THRESHOLD_PARAMS_CMDID),
    WM_ID_DESC(WMI_SET_LPREAMBLE_CMDID),
    WM_ID_DESC(WMI_SET_RTS_CMDID),                       /* 50 */
    WM_ID_DESC(WMI_CLR_RSSI_SNR_CMDID),
    WM_ID_DESC(WMI_SET_FIXRATES_CMDID),
    WM_ID_DESC(WMI_GET_FIXRATES_CMDID),
    WM_ID_DESC(WMI_SET_AUTH_MODE_CMDID),
    WM_ID_DESC(WMI_SET_REASSOC_MODE_CMDID),
    WM_ID_DESC(WMI_SET_WMM_CMDID),
    WM_ID_DESC(WMI_SET_WMM_TXOP_CMDID),
    WM_ID_DESC(WMI_TEST_CMDID),
    /* COEX AR6002 only*/
    WM_ID_DESC(WMI_SET_BT_STATUS_CMDID),                
    WM_ID_DESC(WMI_SET_BT_PARAMS_CMDID),                /* 60 */

    WM_ID_DESC(WMI_SET_KEEPALIVE_CMDID),
    WM_ID_DESC(WMI_GET_KEEPALIVE_CMDID),
    WM_ID_DESC(WMI_SET_APPIE_CMDID),
    WM_ID_DESC(WMI_GET_APPIE_CMDID),
    WM_ID_DESC(WMI_SET_WSC_STATUS_CMDID),

    /* Wake on Wireless */
    WM_ID_DESC(WMI_SET_HOST_SLEEP_MODE_CMDID),
    WM_ID_DESC(WMI_SET_WOW_MODE_CMDID),
    WM_ID_DESC(WMI_GET_WOW_LIST_CMDID),
    WM_ID_DESC(WMI_ADD_WOW_PATTERN_CMDID),
    WM_ID_DESC(WMI_DEL_WOW_PATTERN_CMDID),               /* 70 */

    WM_ID_DESC(WMI_SET_FRAMERATES_CMDID),
    WM_ID_DESC(WMI_SET_AP_PS_CMDID),
    WM_ID_DESC(WMI_SET_QOS_SUPP_CMDID),
};

static const struct wmi_id_desc cmdxs_desc[] = {
    WM_ID_DESC(WMI_SET_BITRATE_CMDID),
    WM_ID_DESC(WMI_GET_BITRATE_CMDID),
    WM_ID_DESC(WMI_SET_WHALPARAM_CMDID),


    /*Should add the new command to the tail for compatible with
     * etna.
     */
    WM_ID_DESC(WMI_SET_MAC_ADDRESS_CMDID),
    WM_ID_DESC(WMI_SET_AKMP_PARAMS_CMDID),
    WM_ID_DESC(WMI_SET_PMKID_LIST_CMDID),
    WM_ID_DESC(WMI_GET_PMKID_LIST_CMDID),
    WM_ID_DESC(WMI_ABORT_SCAN_CMDID),
    WM_ID_DESC(WMI_SET_TARGET_EVENT_REPORT_CMDID),

    /* Unused */
    WM_ID_DESC(WMI_UNUSED1),
    WM_ID_DESC(WMI_UNUSED2),

    /*
     * AP mode commands
     */
    WM_ID_DESC(WMI_AP_HIDDEN_SSID_CMDID),
    WM_ID_DESC(WMI_AP_SET_NUM_STA_CMDID),
    WM_ID_DESC(WMI_AP_ACL_POLICY_CMDID),
    WM_ID_DESC(WMI_AP_ACL_MAC_LIST_CMDID),
    WM_ID_DESC(WMI_AP_CONFIG_COMMIT_CMDID),
    WM_ID_DESC(WMI_AP_SET_MLME_CMDID),
    WM_ID_DESC(WMI_AP_SET_PVB_CMDID),
    WM_ID_DESC(WMI_AP_CONN_INACT_CMDID),
    WM_ID_DESC(WMI_AP_PROT_SCAN_TIME_CMDID),
    WM_ID_DESC(WMI_AP_SET_COUNTRY_CMDID),
    WM_ID_DESC(WMI_AP_SET_DTIM_CMDID),
    WM_ID_DESC(WMI_AP_MODE_STAT_CMDID),

    WM_ID_DESC(WMI_SET_IP_CMDID),
    WM_ID_DESC(WMI_SET_PARAMS_CMDID),
    WM_ID_DESC_FMT(WMI_SET_MCAST_FILTER_CMDID, sizeof(WMI_SET_MCAST_FILTER_CMD)),
    WM_ID_DESC_FMT(WMI_DEL_MCAST_FILTER_CMDID, sizeof(WMI_SET_MCAST_FILTER_CMD)),

    WM_ID_DESC(WMI_ALLOW_AGGR_CMDID),
    WM_ID_DESC(WMI_ADDBA_REQ_CMDID),
    WM_ID_DESC(WMI_DELBA_REQ_CMDID),
    WM_ID_DESC(WMI_SET_HT_CAP_CMDID),
    WM_ID_DESC(WMI_SET_HT_OP_CMDID),
    WM_ID_DESC(WMI_SET_TX_SELECT_RATES_CMDID),
    WM_ID_DESC(WMI_SET_TX_SGI_PARAM_CMDID),
    WM_ID_DESC(WMI_SET_RATE_POLICY_CMDID),

    WM_ID_DESC(WMI_HCI_CMD_CMDID),
    WM_ID_DESC(WMI_RX_FRAME_FORMAT_CMDID),
    WM_ID_DESC(WMI_SET_THIN_MODE_CMDID),
    WM_ID_DESC(WMI_SET_BT_WLAN_CONN_PRECEDENCE_CMDID),

    WM_ID_DESC(WMI_AP_SET_11BG_RATESET_CMDID),
    WM_ID_DESC(WMI_SET_PMK_CMDID),
    WM_ID_DESC_FMT(WMI_MCAST_FILTER_CMDID, sizeof(WMI_MCAST_FILTER_CMD)),
	/* COEX CMDID AR6003*/
	WM_ID_DESC_FMT(WMI_SET_BTCOEX_FE_ANT_CMDID, sizeof(WMI_SET_BTCOEX_FE_ANT_CMD)),
	WM_ID_DESC(WMI_SET_BTCOEX_COLOCATED_BT_DEV_CMDID),
	WM_ID_DESC_FMT(WMI_SET_BTCOEX_SCO_CONFIG_CMDID, sizeof(WMI_SET_BTCOEX_SCO_CONFIG_CMD)),
	WM_ID_DESC_FMT(WMI_SET_BTCOEX_A2DP_CONFIG_CMDID, sizeof(WMI_SET_BTCOEX_A2DP_CONFIG_CMD)),
	WM_ID_DESC_FMT(WMI_SET_BTCOEX_ACLCOEX_CONFIG_CMDID, sizeof(WMI_SET_BTCOEX_ACLCOEX_CONFIG_CMD)),
	WM_ID_DESC_FMT(WMI_SET_BTCOEX_BTINQUIRY_PAGE_CONFIG_CMDID, sizeof(WMI_SET_BTCOEX_BTINQUIRY_PAGE_CONFIG_CMD)),
	WM_ID_DESC(WMI_SET_BTCOEX_DEBUG_CMDID),
	WM_ID_DESC_FMT(WMI_SET_BTCOEX_BT_OPERATING_STATUS_CMDID, sizeof(WMI_SET_BTCOEX_BT_OPERATING_STATUS_CMD)),
	WM_ID_DESC(WMI_GET_BTCOEX_STATS_CMDID),
	WM_ID_DESC(WMI_GET_BTCOEX_CONFIG_CMDID),

    WM_ID_DESC(WMI_SET_DFS_ENABLE_CMDID),   /* F034 */
    WM_ID_DESC(WMI_SET_DFS_MINRSSITHRESH_CMDID),
    WM_ID_DESC(WMI_SET_DFS_MAXPULSEDUR_CMDID),
    WM_ID_DESC(WMI_DFS_RADAR_DETECTED_CMDID),

    /* P2P CMDS */
    WM_ID_DESC(WMI_P2P_SET_CONFIG_CMDID),    /* F038 */
    WM_ID_DESC(WMI_WPS_SET_CONFIG_CMDID),
    WM_ID_DESC(WMI_SET_REQ_DEV_ATTR_CMDID),
    WM_ID_DESC(WMI_P2P_FIND_CMDID),
    WM_ID_DESC(WMI_P2P_STOP_FIND_CMDID),
    WM_ID_DESC(WMI_P2P_GO_NEG_START_CMDID),
    WM_ID_DESC(WMI_P2P_LISTEN_CMDID),

    WM_ID_DESC(WMI_CONFIG_TX_MAC_RULES_CMDID),
    WM_ID_DESC(WMI_SET_PROMISCUOUS_MODE_CMDID),/* F040 */
    WM_ID_DESC(WMI_RX_FRAME_FILTER_CMDID),
    WM_ID_DESC(WMI_SET_CHANNEL_CMDID),

    /* WAC commands */
    WM_ID_DESC(WMI_ENABLE_WAC_CMDID),
    WM_ID_DESC(WMI_WAC_SCAN_REPLY_CMDID),
    WM_ID_DESC(WMI_WAC_CTRL_REQ_CMDID),
    WM_ID_DESC(WMI_SET_DIV_PARAMS_CMDID),

    WM_ID_DESC(WMI_GET_PMK_CMDID),
    WM_ID_DESC(WMI_SET_PASSPHRASE_CMDID),
    WM_ID_DESC(WMI_SEND_ASSOC_RES_CMDID),
    WM_ID_DESC(WMI_SET_ASSOC_REQ_RELAY_CMDID),
    WM_ID_DESC(WMI_GET_RFKILL_MODE_CMDID),
    WM_ID_DESC(WMI_SET_RFKILL_MODE_CMDID),

    /* ACS command, consists of sub-commands */
    WM_ID_DESC(WMI_ACS_CTRL_CMDID),
    
    /* Ultra low power store / recall commands */
    WM_ID_DESC(WMI_STORERECALL_CONFIGURE_CMDID),
    WM_ID_DESC(WMI_STORERECALL_RECALL_CMDID),
    WM_ID_DESC(WMI_STORERECALL_HOST_READY_CMDID),
    WM_ID_DESC(WMI_FORCE_TARGET_ASSERT_CMDID),
    WM_ID_DESC(WMI_SET_EXCESS_TX_RETRY_THRES_CMDID),

    WM_ID_DESC(WMI_P2P_GO_NEG_REQ_RSP_CMDID),  /* F053 */
    WM_ID_DESC(WMI_P2P_GRP_INIT_CMDID),
    WM_ID_DESC(WMI_P2P_GRP_FORMATION_DONE_CMDID),
    WM_ID_DESC(WMI_P2P_INVITE_CMDID),
    WM_ID_DESC(WMI_P2P_INVITE_REQ_RSP_CMDID),
    WM_ID_DESC(WMI_P2P_PROV_DISC_REQ_CMDID),
    WM_ID_DESC(WMI_P2P_SET_CMDID),

    WM_ID_DESC(WMI_AP_SET_APSD_CMDID),         /* F05A */
    WM_ID_DESC(WMI_AP_APSD_BUFFERED_TRAFFIC_CMDID),

    WM_ID_DESC(WMI_P2P_SDPD_TX_CMDID), /* F05C */
    WM_ID_DESC(WMI_P2P_STOP_SDPD_CMDID),
    WM_ID_DESC(WMI_P2P_CANCEL_CMDID),
};

static int dbg_wmi_cmd_params_pos, dbg_wmi_cmd_params_cmdid;
static A_UINT8 *dbg_wmi_cmd_params_buf;

static int WMI_EVENT_SEND_XTND_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    const char *txt;
    A_INT32 evt = buffer[1];
    switch (evt) {
    CASE_STR(WMIX_DSETOPENREQ_EVENTID, txt);
    CASE_STR(WMIX_DSETCLOSE_EVENTID, txt);
    CASE_STR(WMIX_DSETDATAREQ_EVENTID, txt);
    CASE_STR(WMIX_GPIO_INTR_EVENTID, txt);
    CASE_STR(WMIX_GPIO_DATA_EVENTID, txt);
    CASE_STR(WMIX_GPIO_ACK_EVENTID, txt);
    CASE_STR(WMIX_HB_CHALLENGE_RESP_EVENTID, txt);
    CASE_STR(WMIX_DBGLOG_EVENTID, txt);
    CASE_STR(WMIX_PROF_COUNT_EVENTID, txt);
    CASE_DEF_STR(txt);
    }
    return snprintf(output, len, "%s", txt);
}

static int WMI_EVENT_SEND_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    A_INT32 idx = buffer[1];
    A_INT32 sidx;
    if (idx>=(A_INT32)WMI_READY_EVENTID && 
            idx<(A_INT32)(WMI_READY_EVENTID+ARRAY_SIZE(evt_desc))) {
        sidx = idx - WMI_READY_EVENTID;
        return snprintf(output, len, "%s", evt_desc[sidx].desc);
    } else if (idx>=(A_INT32)WMI_SET_BITRATE_CMDID && 
            idx<(A_INT32)(WMI_SET_BITRATE_CMDID+ARRAY_SIZE(cmdxs_desc))) {
        sidx = idx - WMI_SET_BITRATE_CMDID;
        return snprintf(output, len, "%s", cmdxs_desc[sidx].desc);
    }
    return 0;
}


static int WMI_CMD_RX_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    A_INT32 idx = buffer[1];
    A_INT32 length = buffer[2];
    A_INT32 sidx;
    if (idx>=(A_INT32)WMI_CONNECT_CMDID && 
            idx<(A_INT32)(WMI_CONNECT_CMDID+ARRAY_SIZE(cmds_desc))) {
        sidx = idx-WMI_CONNECT_CMDID;
        return snprintf(output, len, "%s, len %d", 
                       cmds_desc[sidx].desc, length);
    } else if (idx>=(A_INT32)WMI_SET_BITRATE_CMDID && 
            idx<(A_INT32)(WMI_SET_BITRATE_CMDID+ARRAY_SIZE(cmdxs_desc))) {
        sidx = idx - WMI_SET_BITRATE_CMDID;
        return snprintf(output, len, "%s, len %d", 
                       cmdxs_desc[sidx].desc, length);
    }
    return 0;
}

static int WMI_CMD_PARAMS_DUMP_START_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    A_INT32 paramslen = buffer[2];
    paramslen += (sizeof(A_INT32) * 2); /* adding pad */
    dbg_wmi_cmd_params_pos = 0;
    dbg_wmi_cmd_params_cmdid = buffer[1];
    dbg_wmi_cmd_params_buf = (paramslen>0) ? malloc(paramslen) : NULL;
    return 0;
}

static int WMI_CMD_PARAMS_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    if (dbg_wmi_cmd_params_buf == NULL) {
        /* partial debug log where there is no START. Skip it*/
        return 0;
    }   
    memcpy(&dbg_wmi_cmd_params_buf[dbg_wmi_cmd_params_pos], &buffer[1], sizeof(A_INT32));
    memcpy(&dbg_wmi_cmd_params_buf[dbg_wmi_cmd_params_pos+4], &buffer[2], sizeof(A_INT32));
    dbg_wmi_cmd_params_pos += (sizeof(A_INT32) * 2);
    return 0;
}

static int WMI_CMD_PARAMS_DUMP_END_fmt(char *output, size_t len, A_UINT32 numargs, A_INT32 *buffer)
{
    int ret = 0;
    A_INT32 idx = dbg_wmi_cmd_params_cmdid;
    DbgCmdFormatter cmdFormatter = NULL;
    size_t cmdSize;
    if (dbg_wmi_cmd_params_buf == NULL) {
        /* partial debug log where there is no START. Skip it*/
        return 0;
    }   
    if (idx>=(A_INT32)WMI_CONNECT_CMDID && 
            idx<(A_INT32)(WMI_CONNECT_CMDID+ARRAY_SIZE(cmds_desc)) ) {
        cmdFormatter = cmds_desc[idx-WMI_CONNECT_CMDID].formatter;
        cmdSize = cmds_desc[idx-WMI_CONNECT_CMDID].cmdSize;
    } else if (idx>=(A_INT32)WMI_SET_BITRATE_CMDID && 
            idx<(A_INT32)(WMI_SET_BITRATE_CMDID+ARRAY_SIZE(cmdxs_desc))) {
        cmdFormatter = cmdxs_desc[idx-WMI_SET_BITRATE_CMDID].formatter;
        cmdSize = cmdxs_desc[idx-WMI_SET_BITRATE_CMDID].cmdSize;
    }
    if (cmdFormatter) {
        ret += snprintf(output+ret, len-ret, " ");
        if (dbg_wmi_cmd_params_pos>=cmdSize) {
            ret += cmdFormatter(output+ret, len-ret, dbg_wmi_cmd_params_buf);
        } else {
            ret += snprintf(output+ret, len-ret, "malformed cmd. size too small %d < %d",
                    dbg_wmi_cmd_params_pos, cmdSize);
        }
    }
    dbg_wmi_cmd_params_pos = 0;
    dbg_wmi_cmd_params_cmdid = 0;
    free(dbg_wmi_cmd_params_buf);
    dbg_wmi_cmd_params_buf = NULL;
    return ret;
}

static struct dbglog_desc wmi_desc[] = {
    DBG_DESC(0),
    DBG_DESC(WMI_CMD_RX_XTND_PKT_TOO_SHORT),
    DBG_DESC(WMI_EXTENDED_CMD_NOT_HANDLED),
    DBG_DESC(WMI_CMD_RX_PKT_TOO_SHORT),
    DBG_DESC(WMI_CALLING_WMI_EXTENSION_FN),
    DBG_DESC(WMI_CMD_NOT_HANDLED),
    DBG_DESC(WMI_IN_SYNC),
    DBG_DESC(WMI_TARGET_WMI_SYNC_CMD),
    DBG_DESC(WMI_SET_SNR_THRESHOLD_PARAMS),
    DBG_DESC(WMI_SET_RSSI_THRESHOLD_PARAMS),
    DBG_DESC(WMI_SET_LQ_TRESHOLD_PARAMS),
    DBG_DESC(WMI_TARGET_CREATE_PSTREAM_CMD),
    DBG_DESC(WMI_WI_DTM_INUSE),
    DBG_DESC(WMI_TARGET_DELETE_PSTREAM_CMD),
    DBG_DESC(WMI_TARGET_IMPLICIT_DELETE_PSTREAM_CMD),
    DBG_DESC(WMI_TARGET_GET_BIT_RATE_CMD),
    DBG_DESC(WMI_GET_RATE_MASK_CMD_FIX_RATE_MASK_IS),
    DBG_DESC(WMI_TARGET_GET_AVAILABLE_CHANNELS_CMD),
    DBG_DESC(WMI_TARGET_GET_TX_PWR_CMD),
    DBG_DESC(WMI_FREE_EVBUF_WMIBUF),
    DBG_DESC(WMI_FREE_EVBUF_DATABUF),
    DBG_DESC(WMI_FREE_EVBUF_BADFLAG),
    DBG_DESC(WMI_HTC_RX_ERROR_DATA_PACKET),
    DBG_DESC(WMI_HTC_RX_SYNC_PAUSING_FOR_MBOX),
    DBG_DESC(WMI_INCORRECT_WMI_DATA_HDR_DROPPING_PKT),
    DBG_DESC(WMI_SENDING_READY_EVENT),
    DBG_DESC(WMI_SETPOWER_MDOE_TO_MAXPERF),
    DBG_DESC(WMI_SETPOWER_MDOE_TO_REC),
    DBG_DESC(WMI_BSSINFO_EVENT_FROM),
    DBG_DESC(WMI_TARGET_GET_STATS_CMD),
    DBG_DESC(WMI_SENDING_SCAN_COMPLETE_EVENT),
    DBG_DESC(WMI_SENDING_RSSI_INDB_THRESHOLD_EVENT),
    DBG_DESC(WMI_SENDING_RSSI_INDBM_THRESHOLD_EVENT),
    DBG_DESC(WMI_SENDING_LINK_QUALITY_THRESHOLD_EVENT),
    DBG_DESC(WMI_SENDING_ERROR_REPORT_EVENT),
    DBG_DESC(WMI_SENDING_CAC_EVENT),
    DBG_DESC(WMI_TARGET_GET_ROAM_TABLE_CMD),
    DBG_DESC(WMI_TARGET_GET_ROAM_DATA_CMD),
    DBG_DESC(WMI_SENDING_GPIO_INTR_EVENT),
    DBG_DESC(WMI_SENDING_GPIO_ACK_EVENT),
    DBG_DESC(WMI_SENDING_GPIO_DATA_EVENT),
    DBG_DESC_FMT(WMI_CMD_RX),
    DBG_DESC(WMI_CMD_RX_XTND),
    DBG_DESC_FMT(WMI_EVENT_SEND),
    DBG_DESC_FMT(WMI_EVENT_SEND_XTND),
    DBG_DESC_FMT(WMI_CMD_PARAMS_DUMP_START),
    DBG_DESC_FMT(WMI_CMD_PARAMS_DUMP_END),
    DBG_DESC_FMT(WMI_CMD_PARAMS),
};

static struct dbglog_desc co_desc[] = {
    DBG_DESC(0),
    DBG_DESC(CO_INIT),
    DBG_DESC(CO_ACQUIRE_LOCK),
    DBG_DESC(CO_START_OP1),
    DBG_DESC(CO_START_OP2),
    DBG_DESC(CO_DRAIN_TX_COMPLETE_CB),
    DBG_DESC(CO_CHANGE_CHANNEL_CB),
    DBG_DESC(CO_RETURN_TO_HOME_CHANNEL),
    DBG_DESC(CO_FINISH_OP_TIMEOUT),
    DBG_DESC(CO_OP_END),
    DBG_DESC(CO_CANCEL_OP),
    DBG_DESC_FMT(CO_CHANGE_CHANNEL),
    DBG_DESC(CO_RELEASE_LOCK),
    DBG_DESC_FMT(CO_CHANGE_STATE),
};

static struct dbglog_desc mgmtbuf_desc[] = {
    DBG_DESC(0),
    DBG_DESC(TXRX_MGMTBUF_ALLOCATE_BUF),
    DBG_DESC(TXRX_MGMTBUF_ALLOCATE_SM_BUF),
    DBG_DESC(TXRX_MGMTBUF_ALLOCATE_RMBUF),
    DBG_DESC(TXRX_MGMTBUF_GET_BUF),
    DBG_DESC(TXRX_MGMTBUF_GET_SM_BUF),
    DBG_DESC(TXRX_MGMTBUF_QUEUE_BUF_TO_TXQ),
    DBG_DESC_FMT(TXRX_MGMTBUF_REAPED_BUF),
    DBG_DESC(TXRX_MGMTBUF_REAPED_SM_BUF),
    DBG_DESC_FMT(TXRX_MGMTBUF_WAIT_FOR_TXQ_DRAIN),
    DBG_DESC(TXRX_MGMTBUF_WAIT_FOR_TXQ_SFQ_DRAIN),
    DBG_DESC(TXRX_MGMTBUF_ENQUEUE_INTO_DATA_SFQ),
    DBG_DESC(TXRX_MGMTBUF_DEQUEUE_FROM_DATA_SFQ),
    DBG_DESC(TXRX_MGMTBUF_PAUSE_DATA_TXQ),
    DBG_DESC(TXRX_MGMTBUF_RESUME_DATA_TXQ),
    DBG_DESC(TXRX_MGMTBUF_WAIT_FORTXQ_DRAIN_TIMEOUT),
    DBG_DESC_FMT(TXRX_MGMTBUF_DRAINQ),
    DBG_DESC(TXRX_MGMTBUF_INDICATE_Q_DRAINED),
    DBG_DESC(TXRX_MGMTBUF_ENQUEUE_INTO_HW_SFQ),
    DBG_DESC(TXRX_MGMTBUF_DEQUEUE_FROM_HW_SFQ),
    DBG_DESC(TXRX_MGMTBUF_PAUSE_HW_TXQ),
    DBG_DESC(TXRX_MGMTBUF_RESUME_HW_TXQ),
    DBG_DESC(TXRX_MGMTBUF_TEAR_DOWN_BA),
    DBG_DESC(TXRX_MGMTBUF_PROCESS_ADDBA_REQ),
    DBG_DESC(TXRX_MGMTBUF_PROCESS_DELBA),
    DBG_DESC(TXRX_MGMTBUF_PERFORM_BA),
    DBG_DESC_FMT(TXRX_MGMTBUF_WLAN_RESET_ON_ERROR),
};

static struct dbglog_desc dc_desc[] = {
    DBG_DESC(0),
    DBG_DESC_FMT(DC_SCAN_CHAN_START),
    DBG_DESC_FMT(DC_SCAN_CHAN_FINISH),
    DBG_DESC(DC_BEACON_RECEIVE7),
    DBG_DESC_FMT(DC_SSID_PROBE_CB),
    DBG_DESC_FMT(DC_SEND_NEXT_SSID_PROBE),
    DBG_DESC_FMT(DC_START_SEARCH),
    DBG_DESC(DC_CANCEL_SEARCH_CB),
    DBG_DESC(DC_STOP_SEARCH),
    DBG_DESC(DC_END_SEARCH),
    DBG_DESC(DC_MIN_CHDWELL_TIMEOUT),
    DBG_DESC(DC_START_SEARCH_CANCELED),
    DBG_DESC_FMT(DC_SET_POWER_MODE),
    DBG_DESC(DC_INIT),
    DBG_DESC_FMT(DC_SEARCH_OPPORTUNITY),
    DBG_DESC_FMT(DC_RECEIVED_ANY_BEACON),
    DBG_DESC(DC_RECEIVED_MY_BEACON),
    DBG_DESC(DC_PROFILE_IS_ADHOC_BUT_BSS_IS_INFRA),
    DBG_DESC(DC_PS_ENABLED_BUT_ATHEROS_IE_ABSENT),
    DBG_DESC(DC_BSS_ADHOC_CHANNEL_NOT_ALLOWED),
    DBG_DESC(DC_SET_BEACON_UPDATE),
    DBG_DESC(DC_BEACON_UPDATE_COMPLETE),
    DBG_DESC(DC_END_SEARCH_BEACON_UPDATE_COMP_CB),
    DBG_DESC(DC_BSSINFO_EVENT_DROPPED),
    DBG_DESC(DC_IEEEPS_ENABLED_BUT_ATIM_ABSENT),
};

static struct dbglog_desc btcoex_desc[] = {
    DBG_DESC(0),
    DBG_DESC(BTCOEX_STATUS_CMD),
    DBG_DESC(BTCOEX_PARAMS_CMD),
    DBG_DESC(BTCOEX_ANT_CONFIG),
    DBG_DESC(BTCOEX_COLOCATED_BT_DEVICE),
    DBG_DESC(BTCOEX_CLOSE_RANGE_SCO_ON),
    DBG_DESC(BTCOEX_CLOSE_RANGE_SCO_OFF),
    DBG_DESC(BTCOEX_CLOSE_RANGE_A2DP_ON),
    DBG_DESC(BTCOEX_CLOSE_RANGE_A2DP_OFF),
    DBG_DESC(BTCOEX_A2DP_PROTECT_ON),
    DBG_DESC(BTCOEX_A2DP_PROTECT_OFF),
    DBG_DESC(BTCOEX_SCO_PROTECT_ON),
    DBG_DESC(BTCOEX_SCO_PROTECT_OFF),
    DBG_DESC(BTCOEX_CLOSE_RANGE_DETECTOR_START),
    DBG_DESC(BTCOEX_CLOSE_RANGE_DETECTOR_STOP),
    DBG_DESC(BTCOEX_CLOSE_RANGE_TOGGLE),
    DBG_DESC(BTCOEX_CLOSE_RANGE_TOGGLE_RSSI_LRCNT),
    DBG_DESC(BTCOEX_CLOSE_RANGE_RSSI_THRESH),
    DBG_DESC(BTCOEX_CLOSE_RANGE_LOW_RATE_THRESH),
    DBG_DESC(BTCOEX_PTA_PRI_INTR_HANDLER),
    DBG_DESC_FMT(BTCOEX_PSPOLL_QUEUED),
    DBG_DESC_FMT(BTCOEX_PSPOLL_COMPLETE),
    DBG_DESC_FMT(BTCOEX_DBG_PM_AWAKE),
    DBG_DESC_FMT(BTCOEX_DBG_PM_SLEEP),
    DBG_DESC(BTCOEX_DBG_SCO_COEX_ON),
    DBG_DESC(BTCOEX_SCO_DATARECEIVE),
    DBG_DESC(BTCOEX_INTR_INIT),
    DBG_DESC(BTCOEX_PTA_PRI_DIFF),
    DBG_DESC_FMT(BTCOEX_TIM_NOTIFICATION),
    DBG_DESC(BTCOEX_SCO_WAKEUP_ON_DATA),
    DBG_DESC(BTCOEX_SCO_SLEEP),
    DBG_DESC_FMT(BTCOEX_SET_WEIGHTS),
    DBG_DESC(BTCOEX_SCO_DATARECEIVE_LATENCY_VAL),
    DBG_DESC(BTCOEX_SCO_MEASURE_TIME_DIFF),
    DBG_DESC(BTCOEX_SET_EOL_VAL),
    DBG_DESC(BTCOEX_OPT_DETECT_HANDLER),
    DBG_DESC(BTCOEX_SCO_TOGGLE_STATE),
    DBG_DESC(BTCOEX_SCO_STOMP),
    DBG_DESC(BTCOEX_NULL_COMP_CALLBACK),
    DBG_DESC(BTCOEX_RX_INCOMING),
    DBG_DESC(BTCOEX_RX_INCOMING_CTL),
    DBG_DESC(BTCOEX_RX_INCOMING_MGMT),
    DBG_DESC(BTCOEX_RX_INCOMING_DATA),
    DBG_DESC(BTCOEX_RTS_RECEPTION),
    DBG_DESC(BTCOEX_FRAME_PRI_LOW_RATE_THRES),
    DBG_DESC_FMT(BTCOEX_PM_FAKE_SLEEP),
    DBG_DESC_FMT(BTCOEX_ACL_COEX_STATUS),
    DBG_DESC(BTCOEX_ACL_COEX_DETECTION),
    DBG_DESC(BTCOEX_A2DP_COEX_STATUS),
    DBG_DESC(BTCOEX_SCO_STATUS),
    DBG_DESC_FMT(BTCOEX_WAKEUP_ON_DATA),
    DBG_DESC(BTCOEX_DATARECEIVE),
    DBG_DESC(0),
    DBG_DESC(BTCOEX_GET_MAX_AGGR_SIZE),
    DBG_DESC(BTCOEX_MAX_AGGR_AVAIL_TIME),
    DBG_DESC(BTCOEX_DBG_WBTIMER_INTR),
    DBG_DESC(0),
    DBG_DESC(BTCOEX_DBG_SCO_SYNC),
    DBG_DESC(0),
    DBG_DESC(BTCOEX_UPLINK_QUEUED_RATE),
    DBG_DESC(BTCOEX_DBG_UPLINK_ENABLE_EOL),
    DBG_DESC(BTCOEX_UPLINK_FRAME_DURATION),
    DBG_DESC(BTCOEX_UPLINK_SET_EOL),
    DBG_DESC(BTCOEX_DBG_EOL_EXPIRED),
    DBG_DESC(BTCOEX_DBG_DATA_COMPLETE),
    DBG_DESC(BTCOEX_UPLINK_QUEUED_TIMESTAMP),
    DBG_DESC(BTCOEX_DBG_DATA_COMPLETE_TIME),
    DBG_DESC(BTCOEX_DBG_A2DP_ROLE_IS_SLAVE),
    DBG_DESC(BTCOEX_DBG_A2DP_ROLE_IS_MASTER),
    DBG_DESC(BTCOEX_DBG_UPLINK_SEQ_NUM),
    DBG_DESC(BTCOEX_UPLINK_AGGR_SEQ),
    DBG_DESC(BTCOEX_DBG_TX_COMP_SEQ_NO),
    DBG_DESC(BTCOEX_DBG_MAX_AGGR_PAUSE_STATE),
    DBG_DESC(BTCOEX_DBG_ACL_TRAFFIC),
    DBG_DESC(BTCOEX_CURR_AGGR_PROP),
    DBG_DESC(BTCOEX_DBG_SCO_GET_PER_TIME_DIFF),
    DBG_DESC(BTCOEX_PSPOLL_PROCESS),
    DBG_DESC(BTCOEX_RETURN_FROM_MAC),
    DBG_DESC(BTCOEX_FREED_REQUEUED_CNT),
    DBG_DESC(BTCOEX_DBG_TOGGLE_LOW_RATES),
    DBG_DESC(BTCOEX_MAC_GOES_TO_SLEEP),
    DBG_DESC(BTCOEX_DBG_A2DP_NO_SYNC),
    DBG_DESC(BTCOEX_RETURN_FROM_MAC_HOLD_Q_INFO),
    DBG_DESC(BTCOEX_RETURN_FROM_MAC_AC),
    DBG_DESC(BTCOEX_DBG_DTIM_RECV),
    DBG_DESC(0),
    DBG_DESC(BTCOEX_IS_PRE_UPDATE),
    DBG_DESC(BTCOEX_ENQUEUED_BIT_MAP),
    DBG_DESC(BTCOEX_TX_COMPLETE_FIRST_DESC_STATS),
    DBG_DESC(BTCOEX_UPLINK_DESC),
    DBG_DESC(BTCOEX_SCO_GET_PER_FIRST_FRM_TIMESTAMP),
    DBG_DESC(0), DBG_DESC(0), DBG_DESC(0),
    DBG_DESC(BTCOEX_DBG_RECV_ACK),
    DBG_DESC(BTCOEX_DBG_ADDBA_INDICATION),
    DBG_DESC(BTCOEX_TX_COMPLETE_EOL_FAILED),
    DBG_DESC(BTCOEX_DBG_A2DP_USAGE_COMPLETE),
    DBG_DESC(BTCOEX_DBG_A2DP_STOMP_FOR_BCN_HANDLER),
    DBG_DESC(BTCOEX_DBG_A2DP_SYNC_INTR),
    DBG_DESC(BTCOEX_DBG_A2DP_STOMP_FOR_BCN_RECEPTION),
    DBG_DESC(BTCOEX_FORM_AGGR_CURR_AGGR),
    DBG_DESC(BTCOEX_DBG_TOGGLE_A2DP_BURST_CNT),
    DBG_DESC(BTCOEX_DBG_BT_TRAFFIC),
    DBG_DESC(BTCOEX_DBG_STOMP_BT_TRAFFIC),
    DBG_DESC(BTCOEX_RECV_NULL),
    DBG_DESC(BTCOEX_DBG_A2DP_MASTER_BT_END),
    DBG_DESC(BTCOEX_DBG_A2DP_BT_START),
    DBG_DESC(BTCOEX_DBG_A2DP_SLAVE_BT_END),
    DBG_DESC(BTCOEX_DBG_A2DP_STOMP_BT),
    DBG_DESC_FMT(BTCOEX_DBG_GO_TO_SLEEP),
    DBG_DESC(BTCOEX_DBG_A2DP_PKT),
    DBG_DESC(BTCOEX_DBG_A2DP_PSPOLL_DATA_RECV),
    DBG_DESC(BTCOEX_DBG_A2DP_NULL),
    DBG_DESC(BTCOEX_DBG_UPLINK_DATA),
    DBG_DESC(BTCOEX_DBG_A2DP_STOMP_LOW_PRIO_NULL),
    DBG_DESC(BTCOEX_DBG_ADD_BA_RESP_TIMEOUT),
    DBG_DESC(BTCOEX_DBG_TXQ_STATE),
    DBG_DESC_FMT(BTCOEX_DBG_ALLOW_SCAN),
    DBG_DESC_FMT(BTCOEX_DBG_SCAN_REQUEST),
    DBG_DESC(0), DBG_DESC(0), DBG_DESC(0), DBG_DESC(0), DBG_DESC(0), DBG_DESC(0), DBG_DESC(0),
    DBG_DESC(BTCOEX_A2DP_SLEEP),
    DBG_DESC(BTCOEX_DBG_DATA_ACTIV_TIMEOUT),
    DBG_DESC(BTCOEX_DBG_SWITCH_TO_PSPOLL_ON_MODE),
    DBG_DESC(BTCOEX_DBG_SWITCH_TO_PSPOLL_OFF_MODE),
    DBG_DESC(BTCOEX_DATARECEIVE_AGGR),
    DBG_DESC(BTCOEX_DBG_DATA_RECV_SLEEPING_PENDING),
    DBG_DESC(BTCOEX_DBG_DATARESP_TIMEOUT),
    DBG_DESC(BTCOEX_BDG_BMISS),
    DBG_DESC(BTCOEX_DBG_DATA_RECV_WAKEUP_TIM),
    DBG_DESC(BTCOEX_DBG_SECOND_BMISS),
    DBG_DESC(0), 
    DBG_DESC_FMT(BTCOEX_DBG_SET_WLAN_STATE),
    DBG_DESC(BTCOEX_BDG_FIRST_BMISS),
    DBG_DESC(BTCOEX_DBG_A2DP_CHAN_OP),
    DBG_DESC(BTCOEX_DBG_A2DP_INTR),
    DBG_DESC_FMT(BTCOEX_DBG_BT_INQUIRY),
    DBG_DESC(BTCOEX_DBG_BT_INQUIRY_DATA_FETCH),
    DBG_DESC(BTCOEX_DBG_POST_INQUIRY_FINISH),
    DBG_DESC(BTCOEX_DBG_SCO_OPT_MODE_TIMER_HANDLER),
    DBG_DESC(BTCOEX_DBG_NULL_FRAME_SLEEP),
    DBG_DESC(BTCOEX_DBG_NULL_FRAME_AWAKE),
    DBG_DESC(0), DBG_DESC(0), DBG_DESC(0), DBG_DESC(0), 
    DBG_DESC(BTCOEX_DBG_SET_AGGR_SIZE),
    DBG_DESC(BTCOEX_DBG_TEAR_BA_TIMEOUT),
    DBG_DESC(BTCOEX_DBG_MGMT_FRAME_SEQ_NO),
    DBG_DESC(BTCOEX_DBG_SCO_STOMP_HIGH_PRI),
    DBG_DESC(BTCOEX_DBG_COLOCATED_BT_DEV),
    DBG_DESC(BTCOEX_DBG_FE_ANT_TYPE),
    DBG_DESC(BTCOEX_DBG_BT_INQUIRY_CMD),
    DBG_DESC(BTCOEX_DBG_SCO_CONFIG),
    DBG_DESC(BTCOEX_DBG_SCO_PSPOLL_CONFIG),
    DBG_DESC(BTCOEX_DBG_SCO_OPTMODE_CONFIG),
    DBG_DESC(BTCOEX_DBG_A2DP_CONFIG),
    DBG_DESC(BTCOEX_DBG_A2DP_PSPOLL_CONFIG),
    DBG_DESC(BTCOEX_DBG_A2DP_OPTMODE_CONFIG),
    DBG_DESC(BTCOEX_DBG_ACLCOEX_CONFIG),
    DBG_DESC(BTCOEX_DBG_ACLCOEX_PSPOLL_CONFIG),
    DBG_DESC(BTCOEX_DBG_ACLCOEX_OPTMODE_CONFIG),
    DBG_DESC(BTCOEX_DBG_DEBUG_CMD),
    DBG_DESC(BTCOEX_DBG_SET_BT_OPERATING_STATUS),
    DBG_DESC(BTCOEX_DBG_GET_CONFIG),
    DBG_DESC(BTCOEX_DBG_GET_STATS),
    DBG_DESC(BTCOEX_DBG_BT_OPERATING_STATUS),
    DBG_DESC(BTCOEX_DBG_PERFORM_RECONNECT),
    DBG_DESC(0), 
    DBG_DESC(BTCOEX_DBG_ACL_WLAN_MED),
    DBG_DESC(BTCOEX_DBG_ACL_BT_MED),
    DBG_DESC(BTCOEX_DBG_WLAN_CONNECT),
    DBG_DESC(BTCOEX_DBG_A2DP_DUAL_START),
    DBG_DESC(BTCOEX_DBG_PMAWAKE_NOTIFY),
    DBG_DESC(BTCOEX_DBG_BEACON_SCAN_ENABLE),
    DBG_DESC(BTCOEX_DBG_BEACON_SCAN_DISABLE),
    DBG_DESC(BTCOEX_DBG_RX_NOTIFY),
    DBG_DESC(BTCOEX_SCO_GET_PER_SECOND_FRM_TIMESTAMP),
    DBG_DESC(BTCOEX_DBG_TXQ_DETAILS),
    DBG_DESC(BTCOEX_DBG_SCO_STOMP_LOW_PRI),
    DBG_DESC(BTCOEX_DBG_A2DP_FORCE_SCAN),
    DBG_DESC(BTCOEX_DBG_DTIM_STOMP_COMP),
    DBG_DESC(BTCOEX_ACL_PRESENCE_TIMER),
    DBG_DESC(BTCOEX_DBG_QUEUE_SELF_CTS),
    DBG_DESC(BTCOEX_DBG_SELF_CTS_COMP),
    DBG_DESC(BTCOEX_DBG_APMODE_WAIT_FOR_CTS_COMP_FAILED),
    DBG_DESC(BTCOEX_DBG_APMODE_A2DP_MED_TO_BT),
    DBG_DESC(BTCOEX_DBG_APMODE_SET_BTSTATE),
    DBG_DESC(BTCOEX_DBG_APMODE_A2DP_STATUS),
    DBG_DESC(BTCOEX_DBG_APMODE_SCO_CTS_HANDLER),
    DBG_DESC(BTCOEX_DBG_APMODE_SCO_STATUS),
    DBG_DESC(BTCOEX_DBG_APMODE_TXQ_DRAINED),
    DBG_DESC(BTCOEX_DBG_APMODE_SCO_ARM_TIMER),
    DBG_DESC(BTCOEX_DBG_APMODE_SWITCH_MED_TO_WLAN),
    DBG_DESC(BTCOEX_APMODE_BCN_TX_HANDLER),
    DBG_DESC(BTCOEX_APMODE_BCN_TX),
    DBG_DESC(BTCOEX_APMODE_SCO_RTS_HANDLER),
};

static struct dbglog_desc pm_desc[] = {
    DBG_DESC(0),
    DBG_DESC(PM_INIT), 
    DBG_DESC(PM_ENABLE),
    DBG_DESC_FMT(PM_SET_STATE),
    DBG_DESC_FMT(PM_SET_POWERMODE),
    DBG_DESC(PM_CONN_NOTIFY),
    DBG_DESC(PM_REF_COUNT_NEGATIVE),
    DBG_DESC(PM_INFRA_STA_APSD_ENABLE),
    DBG_DESC(PM_INFRA_STA_UPDATE_APSD_STATE),
    DBG_DESC_FMT(PM_CHAN_OP_REQ),
    DBG_DESC_FMT(PM_SET_MY_BEACON_POLICY),
    DBG_DESC_FMT(PM_SET_ALL_BEACON_POLICY),
    DBG_DESC(PM_INFRA_STA_SET_PM_PARAMS1),
    DBG_DESC(PM_INFRA_STA_SET_PM_PARAMS2),
    DBG_DESC(PM_ADHOC_SET_PM_CAPS_FAIL),
    DBG_DESC(PM_ADHOC_UNKNOWN_IBSS_ATTRIB_ID),
    DBG_DESC(PM_ADHOC_SET_PM_PARAMS),
    DBG_DESC(0),
    DBG_DESC(PM_ADHOC_STATE1),
    DBG_DESC(PM_ADHOC_STATE2),
    DBG_DESC(PM_ADHOC_CONN_MAP),
    DBG_DESC_FMT(PM_FAKE_SLEEP),
    DBG_DESC(PM_AP_STATE1),
    DBG_DESC(PM_AP_SET_PM_PARAMS),
    DBG_DESC(PM_P2P_STATE1),
};

static struct dbglog_desc dummy_desc[] = {
    DBG_DESC(0),
};

static struct module_desc modules[] = {
    MODULE_DESC(INF, dummy_desc),
    MODULE_DESC(WMI, wmi_desc),
    MODULE_DESC(MISC, dummy_desc),
    MODULE_DESC(PM, pm_desc),
    MODULE_DESC(TXRX_MGMTBUF, mgmtbuf_desc),
    MODULE_DESC(TXRX_TXBUF, dummy_desc),
    MODULE_DESC(TXRX_RXBUF, dummy_desc),
    MODULE_DESC(WOW, dummy_desc),
    MODULE_DESC(WHAL, dummy_desc),
    MODULE_DESC(DC, dc_desc),
    MODULE_DESC(CO, co_desc),
    MODULE_DESC(RO, dummy_desc),
    MODULE_DESC(CM, dummy_desc),
    MODULE_DESC(MGMT, dummy_desc),
    MODULE_DESC(TMR, dummy_desc),
    MODULE_DESC(BTCOEX, btcoex_desc),
};

static int compOid(const void *a, const void *b)
{
    return *(A_INT32*)a  - *(A_INT32*)b;
}

static void do_check_ids(void)
{
    size_t m, d, td;
    for (m = 0; m < DBGLOG_MODULEID_NUM_MAX; ++m) {
        size_t mlen;
        struct dbglog_desc *dlog;
        if (m >= ARRAY_SIZE(modules)) {
            printf("module id %d does not matched\n", m);
            break;
        }
        dlog = modules[m].descs;
        mlen = modules[m].len;
        d=td=1;
        while (dlog && (d<mlen||dbglog_id_tag[m][td][0]!='\0')) {       
            if (d>=mlen) {
                if (dlog != dummy_desc) {
                    printf("m %s dbgid %s(%d) is larger than max internal table %d host/firmware mismatch?\n", 
                            modules[m].name, dbglog_id_tag[m][td], td, mlen);
                }                
                break;
            }

            if (dbglog_id_tag[m][td][0]=='\0' && dlog[d].oid!=0) {
                for (;td < DBGLOG_DBGID_NUM_MAX && dbglog_id_tag[m][td][0]=='\0'; ++td);
            }
            if (strcmp(dbglog_id_tag[m][td], dlog[d].desc)!=0 && dlog[d].oid!=0) {
                printf("debug id does not matched '%s' <> '%s'\n", dbglog_id_tag[m][td], dlog[d].desc);
                break;
            } else {
                if (td!=d && !modules[m].bsearch) {                    
                    printf("Module %s debugid %s(%d) mismatched. using binary search for debugid",
                           modules[m].name, dbglog_id_tag[m][td], td); 
                    modules[m].bsearch = 1;
                }
            }
            ++d; ++td;
        }
        if (modules[m].bsearch && dlog) {
            qsort(dlog, mlen, sizeof(dlog[0]), compOid);
        }
    }
    check_ids = 1;
}

static DbgLogFormatter getFormatter(A_INT32 moduleid, A_INT32 debugid)
{
    if (!check_ids) {
        do_check_ids();
    }

    if ( moduleid < ARRAY_SIZE(modules)) {
        const struct module_desc *m = &modules[moduleid];
        if (m->descs ) {
            if (m->bsearch){
                struct dbglog_desc *d;
                d = (struct dbglog_desc*)bsearch(&debugid, m->descs, m->len, sizeof(m->descs[0]), compOid);
                return d ? d->formatter : NULL;
            } else if (debugid>0 && debugid<m->len) {
                return m->descs[debugid].formatter;   
            }
        }
    }
    return NULL;
}

int dbg_formater(int lv, char *output, size_t len, A_UINT32 ts, A_INT32 *logbuf)
{
    int ret = 0;
	A_UINT32 idx, last_idx;
    A_UINT32 debugid = DBGLOG_GET_DBGID(logbuf[0]);
    A_UINT32 moduleid = DBGLOG_GET_MODULEID(logbuf[0]);
    A_UINT32 numargs = DBGLOG_GET_NUMARGS(logbuf[0]);
    A_UINT32 timestamp = DBGLOG_GET_TIMESTAMP(logbuf[0]);
    DbgLogFormatter dbgFormatter = NULL;

    if (numargs>2) {
        return ret;
    }

    if (lv > 0) {
        dbgFormatter = getFormatter(moduleid, debugid);
    }

    if (ts>0) {
        if (lv == 0) {
            ret += snprintf(output+ret, len-ret, "%8d: ", ts);
        } else {
            ret += strftime(output+ret, len-ret, "%m-%d %H:%M:%S ", gmtime((time_t*)&ts));
        }
    }
    ret += snprintf(output+ret, len-ret, "(%05d) %s", timestamp, dbglog_id_tag[moduleid][debugid]);
    if (lv>1 || lv == 0 || !dbgFormatter) {

        if(numargs == 1 && !strcmp(dbglog_id_tag[moduleid][debugid], "WMI_EVENT_SEND"))
        {
            idx = 0;
            last_idx = ARRAY_SIZE(dbg_wmi_event_str);
            for(idx = 0 ; idx < last_idx ; idx++) {
                if(dbg_wmi_event_str[idx].id == logbuf[1]) {
                    break;
                }
            }
            if(idx < last_idx) {
                ret += snprintf(output+ret, len-ret, ": 0x%04x\t\t--- %s",
                                logbuf[1], dbg_wmi_event_str[idx].str );
            } else {
            	ret += snprintf(output+ret, len-ret, ": 0x%04x", logbuf[1]);
            }
        } else if(numargs == 2 && !strcmp(dbglog_id_tag[moduleid][debugid], "WMI_CMD_RX")) {
            idx = 0;
            last_idx = ARRAY_SIZE(dbg_wmi_cmd_str);
            for(idx = 0 ; idx < last_idx ; idx++) {
                if(dbg_wmi_cmd_str[idx].id == logbuf[1])
                    break;
            }
            if(idx < last_idx) {
                ret += snprintf(output+ret, len-ret, ": 0x%02x, 0x%02x\t\t+++ %s",
                                logbuf[1], logbuf[2], dbg_wmi_cmd_str[idx].str );
            } else {
            	ret += snprintf(output+ret, len-ret, ": 0x%02x, 0x%02x", 
            	                logbuf[1], logbuf[2]);
            }
        } else {
	        if (numargs>0) {
	            ret += snprintf(output+ret, len-ret, ": 0x%x", logbuf[1]);
	        }
	        if (numargs>1) {
	            ret += snprintf(output+ret, len-ret, ", 0x%x", logbuf[2]);
	        }
	        if (dbgFormatter && numargs>0 && lv > 0) {
	            ret += snprintf(output+ret, len-ret, ", ");
	        }
        }
    } else {
        ret += snprintf(output+ret, len-ret, ": ");
    }

    if (dbgFormatter && lv > 0) {
        int pos = ret;
        int addlen;
        addlen = dbgFormatter(output+ret, len-ret, numargs, logbuf);
        if (addlen>0) {
            ret += addlen;
        } else if (lv<=1) {
            /* skip this message */
            (void)pos;
            return 0;
        }
    }
    ret += snprintf(output+ret, len-ret, "\n");
    return ret;
}