📄 zddebug.c
字号:
#ifndef _ZD_DEBUG_C_
#define _ZD_DEBUG_C_
#include "zddebug.h"
#include "zdhw.h"
#include "zdutils.h"
#include "zdpsmon.h"
#ifdef HOST_IF_USB
#include "zd1211.h"
#endif
#include "zdglobal.h"
extern zd_80211Obj_t dot11Obj;
//for debug message show
extern u32 freeSignalCount;
extern u32 freeFdescCount;
extern void zd_ShowQInfo(void);
extern void zd_ShowState(void);
extern BOOLEAN mPrivacyInvoked;
extern U16 mCap;
extern U8 mWpaBcKeyLen;
extern U8 mGkInstalled;
extern U8 mDynKeyMode;
extern U8 mKeyFormat;
int zd1205_cont_tx(struct zd1205_private *macp, u8 rate);
extern int zd_SetKeyContext(U8 *addr, U8 encryMode, U8 keyLength, U8 KeyId, U8 *pKeyContent);
extern void ConfigBcnFIFO(void);
extern BOOLEAN zd_CmdDeauth(MacAddr_t *sta, U8 rCode);
extern BOOLEAN zd_CmdDisasoc(MacAddr_t *sta, U8 rCode);
extern void update_beacon_interval(struct zd1205_private *macp, int val);
#if ZDCONF_RF_UW2453_SUPPORT == 1 || ZDCONF_RF_AR2124_SUPPORT == 1
extern void PHY_UWTxPower(zd_80211Obj_t *pObj, U8 TxLevel);
#endif
extern U8 mMacMode;
#if ZDCONF_APC == 1
extern U8 APC_NT[256][6];
#endif
void zd1205_list_STAs(struct zd1205_private *macp)
{
#if ZDCONF_AP_SUPPORT == 1
#define NUM_VAP 0 // For compatible with ZD1212
int i,j, vapId;
Hash_t *p;
U8 RateTbl [] = {1,2,5,11,6,9,12,18,24,36,48,54 };
printk("\nAssociated Station List:\n");
for(vapId = 0;vapId <=NUM_VAP;vapId++)
{
printk("Station List of VAP:%d\n", vapId);
printk("*********************\n");
for (i=1; i<(MAX_AID+1); i++)
{
p = sstByAid[i];
if(p->vapId != vapId) continue;
if (p->bValid)
{
printk("STA %02d :\n",i);
printk(" MAC : ");
for(j=0;j<ETH_ALEN;j++)
printk("%02x ", p->mac[j]);
printk("\n");
printk(" Encryption : ");
switch(p->encryMode)
{
case NO_WEP:
printk("OFF (%d)\n", p->encryMode);
break;
case WEP64:
printk("WEP64 (%d)\n", p->encryMode);
break;
case WEP128:
printk("WEP128 (%d)\n", p->encryMode);
break;
case AES:
printk("AES (%d)\n", p->encryMode);
break;
case TKIP:
printk("TKIP (%d)\n", p->encryMode);
break;
default:
printk("Unknown (%d)\n",p->encryMode);
break;
}
/*
#if ZDCONF_80211E_SUPPORT == 1
printk(" QoS Support : %s\n",p->qos?"Yes":"NO");
#endif
#if ZDCONF_LP_SUPPORT == 1
printk(" BurstMode : %02d\n", p->Turbo_Burst);
printk(" A-MSDU Mode : %s(Max:%d)\n", p->Turbo_AMSDU?"On":"Off",p->Turbo_AMSDU_LEN?1792:3839);
#endif
*/
if(p->RxRate > 0 && p->RxRate < 0xC)
{
printk(" RxRate : %02d Mbps\n",RateTbl[p->RxRate]);
printk(" TxRate : %02d Mbps\n",RateTbl[p->CurrTxRate]);
}
printk(" Power Saving : %s\n", p->psm?"ON":"OFF");
printk(" Erp Sta : %s\n",p->bErpSta?"Yes":"No");
printk(" Last Activity : %05ds Ago\n",(HW_GetNow(&dot11Obj)-p->ttl)/HZ);
}
}
}
#undef NUM_VAP
#endif
}
void zd1205_set_sniffer_mode(struct zd1205_private *macp)
{
struct net_device *dev = macp->device;
dev->type = ARPHRD_IEEE80211;
dev->hard_header_len = ETH_HLEN;
dev->addr_len = ETH_ALEN;
if (netif_running(dev))
netif_stop_queue(dev);
zd_writel(0x01, SnifferOn);
zd_writel(0xffffff, Rx_Filter);
zd_writel(0x08, EncryptionType);
macp->intrMask = RX_COMPLETE_EN;
}
void zd1205_dump_regs(struct zd1205_private *macp)
{
#if ZDCONF_DBGMSG_NORMAL == 1
#ifndef HOST_IF_USB
spin_lock_irqsave(&macp->q_lock, flags);
#endif
printk(KERN_DEBUG "*******************************************************\n");
printk(KERN_DEBUG "MACAddr_P1 = %08x MACAddr_P2 = %08x\n",
zd_readl(MACAddr_P1), zd_readl(MACAddr_P2));
printk(KERN_DEBUG "BCNInterval = %08x. BCNPLCPCfg = %08x\n",
zd_readl(BCNInterval), zd_readl(BCNPLCPCfg));
printk(KERN_DEBUG "TSF_LowPart = %08x, TSF_HighPart = %08x\n",
zd_readl(TSF_LowPart), zd_readl(TSF_HighPart));
printk(KERN_DEBUG "DeviceState = %08x, NAV_CCA = %08x\n",
zd_readl(DeviceState), zd_readl(NAV_CCA));
printk(KERN_DEBUG "CRC32Cnt = %08x, CRC16Cnt = %08x\n",
zd_readl(CRC32Cnt), zd_readl(CRC16Cnt));
printk(KERN_DEBUG "TotalRxFrm = %08x, TotalTxFrm = %08x\n",
zd_readl(TotalRxFrm), zd_readl(TotalTxFrm));
printk(KERN_DEBUG "RxFIFOOverrun = %08x, UnderrunCnt = %08x\n",
zd_readl(RxFIFOOverrun), zd_readl(UnderrunCnt));
printk(KERN_DEBUG "BSSID_P1 = %08x, BSSID_P2 = %08x\n",
zd_readl(BSSID_P1), zd_readl(BSSID_P2));
printk(KERN_DEBUG "Pre_TBTT = %08x, ATIMWndPeriod = %08x\n",
zd_readl(Pre_TBTT), zd_readl(ATIMWndPeriod));
printk(KERN_DEBUG "RetryCnt = %08x, IFS_Value = %08x\n",
zd_readl(RetryCnt), zd_readl(IFS_Value));
printk(KERN_DEBUG "NAV_CNT = %08x, CWmin_CWmax = %08x\n",
zd_readl(NAV_CNT), zd_readl(CWmin_CWmax));
//printk(KERN_DEBUG "GroupHash_P1 = %08x, GroupHash_P2 = %08x\n",
// zd_readl(GroupHash_P1), zd_readl(GroupHash_P2));
printk(KERN_DEBUG "DecrypErr_UNI = %08x, DecrypErr_Mul = %08x\n",
zd_readl(DecrypErr_UNI), zd_readl(DecrypErr_Mul));
printk(KERN_DEBUG "intrMask = %08x\n", macp->intrMask);
#ifndef HOST_IF_USB
printk(KERN_DEBUG "InterruptCtrl = %08x, Rx_Filter = %08x\n",
zd_readl(InterruptCtrl), zd_readl(Rx_Filter));
printk(KERN_DEBUG "ReadTcbAddress = %08x, ReadRfdAddress= %08x\n",
zd_readl(ReadTcbAddress), zd_readl(ReadRfdAddress));
printk(KERN_DEBUG "BCN_FIFO_Semaphore = %08x, CtlReg1 = %08x\n",
zd_readl(BCN_FIFO_Semaphore), zd_readl(CtlReg1));
printk(KERN_DEBUG "RX_OFFSET_BYTE = %08x, RX_TIME_OUT = %08x\n",
zd_readl(RX_OFFSET_BYTE), zd_readl(RX_TIME_OUT));
printk(KERN_DEBUG "CAM_DEBUG = %08x, CAM_STATUS = %08x\n",
zd_readl(CAM_DEBUG), zd_readl(CAM_STATUS));
printk(KERN_DEBUG "CAM_ROLL_TB_LOW = %08x, CAM_ROLL_TB_HIGH = %08x\n",
zd_readl(CAM_ROLL_TB_LOW), zd_readl(CAM_ROLL_TB_HIGH));
printk(KERN_DEBUG "CAM_MODE = %08x, intrMask = %08x\n", zd_readl(CAM_MODE), macp->intrMask);
#endif
#ifndef HOST_IF_USB
spin_unlock_irqrestore(&macp->q_lock, flags);
#endif
#endif
}
void zd1205_dump_cnters(struct zd1205_private *macp)
{
#if ZDCONF_DBGMSG_NORMAL == 1
zd1205_lock(macp);
printk(KERN_DEBUG "*************************************************\n");
printk(KERN_DEBUG "freeTxQ = %08d, activeTxQ = %08d\n", macp->freeTxQ->count, macp->activeTxQ->count);
printk(KERN_DEBUG "freeSignalCount = %08d, freeFdescCount = %08d\n", freeSignalCount, freeFdescCount);
//printk(KERN_DEBUG "hwTotalRxFrm = %08d, hwTotalTxFrm = %08d\n", macp->hwTotalRxFrm, macp->hwTotalTxFrm);
//printk(KERN_DEBUG "hwRxFIFOOverrun = %08d, hwUnderrunCnt = %08d\n", macp->hwRxFIFOOverrun, macp->hwUnderrunCnt);
//printk(KERN_DEBUG "hwCRC32Cnt = %08d, hwCRC16Cnt = %08d\n", macp->hwCRC32Cnt, macp->hwCRC16Cnt);
//printk(KERN_DEBUG "ErrLongFrmCnt = %08d, ErrShortFrmCnt = %08d\n", macp->ErrLongFrmCnt, macp->ErrShortFrmCnt);
//printk(KERN_DEBUG "ErrToHostFrmCnt = %08d, ErrZeroLenFrmCnt= %08d\n", macp->ErrToHostFrmCnt, macp->ErrZeroLenFrmCnt);
printk(KERN_DEBUG "rxOFDMDataFrame = %08d, rx11bDataFrame = %08d\n", macp->rxOFDMDataFrame, macp->rx11bDataFrame);
printk(KERN_DEBUG "rxSignalQuality = %08d, rxSignalStrength= %08d\n", macp->rxSignalQuality, macp->rxSignalStrength);
printk(KERN_DEBUG "rxRate = %08d, txRate = %08dx\n", macp->rxInfo.rate, macp->cardSetting.CurrTxRate);
//printk(KERN_DEBUG "rxNeedFragCnt = %08d, rxCompFragCnt = %08d\n", macp->rxNeedFragCnt, macp->rxCompFragCnt);
//printk(KERN_DEBUG "ArFreeFailCnt = %08d, ArAgedCnt = %08d\n", macp->ArFreeFailCnt, macp->ArAgedCnt);
//printk(KERN_DEBUG "ArSearchFailCnt = %08d, DropFirstFragCnt= %08d\n", macp->ArSearchFailCnt, macp->DropFirstFragCnt);
//printk(KERN_DEBUG "skb_req = %08d, AllocSkbFailCnt= %08d\n", macp->skb_req, macp->AllocSkbFailCnt);
printk(KERN_DEBUG "txQueToUpCnt = %08d, txQueSetCnt = %08d\n", macp->txQueToUpCnt, macp->txQueSetCnt);
printk(KERN_DEBUG "sleepCnt = %08d, wakeupCnt = %08d\n", macp->sleepCnt, macp->wakeupCnt);
printk(KERN_DEBUG "WaitLenInfoCnt = %08d, CompLenInfoCnt = %08d\n", macp->WaitLenInfoCnt, macp->CompLenInfoCnt);
printk(KERN_DEBUG "Continue2Rx = %08d, NoMergedRxCnt = %08d\n", macp->Continue2Rx, macp->NoMergedRxCnt);
printk(KERN_DEBUG "bcnCnt = %08d, dtimCnt = %08d\n", macp->bcnCnt, macp->dtimCnt);
printk(KERN_DEBUG "txCnt = %08d, txCmpCnt = %08d\n", macp->txCnt, macp->txCmpCnt);
printk(KERN_DEBUG "retryFailCnt = %08d, rxCnt = %08d\n", macp->retryFailCnt, macp->rxCnt);
printk(KERN_DEBUG "usbTxCnt = %08d, usbTxCompCnt = %08d\n", macp->usbTxCnt, macp->usbTxCompCnt);
printk(KERN_DEBUG "regWaitRCompCnt = %08d, regWaitWCompCnt= %08d\n", macp->regWaitRCompCnt, macp->regWaitWCompCnt);
printk(KERN_DEBUG "regRWCompCnt = %08d, regUnCompCnt = %08d\n", macp->regRWCompCnt, macp->regUnCompCnt);
printk(KERN_DEBUG "regWaitRspCnt = %08d, regRspCompCnt = %08d\n", macp->regWaitRspCnt, macp->regRspCompCnt);
printk(KERN_DEBUG "regRdSleepCnt = %08d, regRspCompCnt = %08d\n", macp->regRdSleepCnt, macp->regRspCompCnt);
printk(KERN_DEBUG "lastRxComp = %08d\n", macp->lastRxComp);
printk(KERN_DEBUG "macp.flags = %08x ", (u32) macp->flags);
if(macp->bHandleNonRxTxRunning)
{
printk("NonRxTxRunning ");
}
if(test_bit(ZD1211_TX_BUSY,&macp->flags)) //B4
printk("TX_BUSY ");
if(test_bit(ZD1211_REQ_COMP,&macp->flags)) //B2
printk("REQ_COMP ");
if(test_bit(ZD1211_RUNNING,&macp->flags)) //B3
printk("RUNNING ");
if(test_bit(ZD1211_CMD_FINISH,&macp->flags)) //B5
printk("CMD_FINISH ");
printk("\n");
printk("bDeviceInSleep:%d\n", dot11Obj.bDeviceInSleep);
zd_ShowQInfo();
zd_ShowState();
macp->bcnCnt = 0;
macp->dtimCnt = 0;
macp->rxCnt = 0;
macp->txCmpCnt = 0;
macp->txCnt = 0;
macp->retryFailCnt = 0;
macp->txIdleCnt = 0;
macp->rxIdleCnt = 0;
macp->hwTotalRxFrm = 0;
macp->hwTotalTxFrm = 0;
macp->hwRxFIFOOverrun = 0;
macp->hwUnderrunCnt = 0;
macp->hwCRC32Cnt =0;
macp->hwCRC16Cnt =0;
macp->ErrLongFrmCnt = 0;
macp->ErrShortFrmCnt = 0;
macp->ErrToHostFrmCnt = 0;
macp->ErrZeroLenFrmCnt = 0;
macp->rxOFDMDataFrame = 0;
macp->rx11bDataFrame = 0;
macp->ArFreeFailCnt = 0;
macp->ArAgedCnt = 0;
macp->ArSearchFailCnt = 0;
macp->DropFirstFragCnt = 0;
macp->rxNeedFragCnt = 0;
macp->rxCompFragCnt = 0;
macp->txQueToUpCnt = 0;
macp->txQueSetCnt = 0;
//macp->sleepCnt = 0;
//macp->wakeupCnt = 0;
macp->Continue2Rx = 0;
macp->NoMergedRxCnt = 0;
#ifdef WPA_DEBUG
printk("cardSet.WPAIeLen=%d\n",macp->cardSetting.WPAIeLen);
printk("mDynKeyMode:%d,mKeyFormat:%d,mPrivacyInvoked:%d,mCap:0x%X,mWpaBcKenLen:%d\n",mDynKeyMode,mKeyFormat,mPrivacyInvoked,mCap,mWpaBcKeyLen);
#endif
zd1205_unlock(macp);
#endif
}
void zd1205_update_brate(struct zd1205_private *macp, u32 value)
{
u8 ii;
u8 nRate;
u8 *pRate;
card_Setting_t *pSetting = &macp->cardSetting;
u8 rate_list[4] = { 0x02, 0x04, 0x0B, 0x16 };
/* Get the number of rates we support */
nRate = pSetting->Info_SupportedRates[1];
pRate = &(pSetting->Info_SupportedRates[2]);
for(ii = 0; ii < nRate; ii++)
{
/* If the Rate is less than the basic Rate, mask 0x80 with the value. */
if((*pRate & 0x7f) <= rate_list[value])
*pRate |= 0x80;
else
*pRate &= 0x7f;
pRate++;
}
}
/*
void acquire_ctrl_of_phy_req(void *regp)
{
u32 tmpValue;
tmpValue = zd_readl(CtlReg1);
tmpValue &= ~0x80;
zd_writel(tmpValue, CtlReg1);
}
void release_ctrl_of_phy_req(void *regp)
{
u32 tmpValue;
tmpValue = zd_readl(CtlReg1);
tmpValue |= 0x80;
zd_writel(tmpValue, CtlReg1);
}
*/
void zd1205_dump_phy(struct zd1205_private *macp)
{
#if ZDCONF_DBGMSG_NORMAL == 1
void *regp = macp->regp;
u32 regValue[4];
int i;
LockPhyReg(&dot11Obj);
for (i=0; i<256; i+=4) {
//acquire_ctrl_of_phy_req(regp);
if (i==4)//The offset of CR4 to CR8 are not multiplied by 4 directly.
{
regValue[0]=zd_readl(ZD_CR4);
regValue[1]=zd_readl(ZD_CR5);
regValue[2]=zd_readl(ZD_CR6);
regValue[3]=zd_readl(ZD_CR7);
}
else if (i==8)
{
regValue[0]=zd_readl(ZD_CR8);
regValue[1]=zd_readl(ZD_CR9);
regValue[2]=zd_readl(ZD_CR10);
regValue[3]=zd_readl(ZD_CR11);
}
else
{
regValue[0] = zd_readl(4*i);
regValue[1] = zd_readl(4*(i+1));
regValue[2] = zd_readl(4*(i+2));
regValue[3] = zd_readl(4*(i+3));
}
printk("CR%03d = %02x CR%03d = %02x CR%03d = %02x CR%03d = %02x\n",
i, (u8)regValue[0], i+1, (u8)regValue[1], i+2, (u8)regValue[2], i+3, (u8)regValue[3]);
//release_ctrl_of_phy_req(regp);
}
UnLockPhyReg(&dot11Obj);
#endif
}
/*
void zd1205_dump_eeprom(struct zd1205_private *macp)
{
u32 e2pValue, e2pValue1;
int i;
for (i=0; i<20; i+=2) {
e2pValue = zd_readl(E2P_SUBID+4*i);
e2pValue1 = zd_readl(E2P_SUBID+4*(i+1));
printk(KERN_DEBUG "0x%x = %08x, 0x%x = %08x\n", E2P_SUBID+4*i, e2pValue, E2P_SUBID+4*(i+1), e2pValue1);
}
}
*/
void zd1205_dump_eeprom(struct zd1205_private *macp)
{
#if ZDCONF_DBGMSG_NORMAL == 1
u32 V1,V2,V3,V4 ;
int i;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -