?? zddebug.c
字號:
#ifndef _ZD_DEBUG_C_
#define _ZD_DEBUG_C_
#include "zddebug.h"
#include "zdhw.h"
#include "zdutils.h"
#ifdef HOST_IF_USB
#include "zd1211.h"
#endif
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);
extern void PHY_UWTxPower(zd_80211Obj_t *pObj, U8 TxLevel);
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)
{
#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));
#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\n", zd_readl(CAM_MODE));
#endif
#ifndef HOST_IF_USB
spin_unlock_irqrestore(&macp->q_lock, flags);
#endif
}
void zd1205_dump_cnters(struct zd1205_private *macp)
{
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 "macp.flags = %08x\n", (u32) macp->flags);
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);
}
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)
{
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(KERN_DEBUG "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);
}
/*
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)
{
u32 V1,V2,V3,V4 ;
int i;
for (i=0; i<0x30; i+=4) {
V1 = zd_readl(E2P_SUBID+4*i);
V2 = zd_readl(E2P_SUBID+4*(i+1));
V3 = zd_readl(E2P_SUBID+4*(i+2));
V4 = zd_readl(E2P_SUBID+4*(i+3));
printk(KERN_DEBUG "0x%x = %08x %08x %08x %08x \n", E2P_SUBID+4*i, V1,V2,V3,V4);
}
}
extern void zd_ShowHashInfo(u8 aid);
void zd1205_show_hash(struct zd1205_private *macp, u32 value)
{
if (value < 33)
zd_ShowHashInfo(value);
}
void zd1205_show_card_setting(struct zd1205_private *macp)
{
card_Setting_t *pSetting = &macp->cardSetting;
printk(KERN_DEBUG "RTSThreshold = %04x FragThreshold = %04x\n",
pSetting->RTSThreshold, pSetting->FragThreshold);
printk(KERN_DEBUG "DtimPeriod = %04x BeaconInterval = %04x\n",
pSetting->DtimPeriod, pSetting->BeaconInterval);
printk(KERN_DEBUG "EncryMode = %04x EncryOnOff = %04x\n",
pSetting->EncryMode, pSetting->EncryOnOff);
printk(KERN_DEBUG "EncryKeyId = %04x WepKeyLen = %04x\n",
pSetting->EncryKeyId, pSetting->WepKeyLen);
printk(KERN_DEBUG "PreambleType = %04x AuthMode = %04x\n",
pSetting->PreambleType, pSetting->AuthMode);
printk(KERN_DEBUG "Channel = %04x BssType = %04x\n",
pSetting->Channel, pSetting->BssType);
printk(KERN_DEBUG "SuggestionMode = %04x PwrState = %04x\n",
macp->SuggestionMode, macp->PwrState);
printk(KERN_DEBUG "bPSMSupported = %04x bAssoc = %04x\n",
macp->bPSMSupported, macp->bAssoc);
printk(KERN_DEBUG "bAnyActivity = %04x BSS_Members = %04x\n",
macp->bAnyActivity, macp->BSS_Members);
}
#if 0
void zd1205_dump_cam(struct zd1205_private *macp)
{
int ii;
for(ii = 0; ii < 445; ii++) {
u32 data = HW_CAM_Read(&dot11Obj, ii);
if((ii % 4) == 0)
printk(KERN_ERR "\nAddr=0x%04x ", ii);
printk(KERN_ERR "0x%08x ", data);
}
printk(KERN_ERR "\n");
}
#endif
void zd1205_dump_cam(struct zd1205_private *macp,u32 beginAddr, u32 length)
{
u8 valid_uid[40];
u8 valid_uid_cnt;
u32 data;
int ii,jj;
//u32 RollCallTblLow;
//u32 RollCallTblHigh;
u32 MACINCAM[6];
u32 tmpRollCallTblLow;
u32 tmpRollCallTblHigh;
//u32 bDisplay;
int UserIdBase;
char *EncTypeStr[]={"","WEP64","TKIP","","AES","WEP128","WEP256",""};
char *CamModeStr[]={"IBSS","AP","STA","WDS","Client","VAP","",""};
for(ii = 0; ii < length; ii++) {
data = HW_CAM_Read(&dot11Obj, beginAddr+ii);
printk(KERN_ERR "\nAddr(%03u)=0x%08x", ii+beginAddr, data);
}
printk(KERN_ERR "\n");
data = zd_readl(0x700); // Cam mode: MACREG(0x700)[2:0]
printk(KERN_ERR "CAM Mode: %s\n", CamModeStr[data&7]);
//tmpRollCallTblLow=RollCallTblLow=zd_readl(0x704);
//tmpRollCallTblHigh=RollCallTblHigh=zd_readl(0x708)&0xf;
tmpRollCallTblLow=zd_readl(0x704);
tmpRollCallTblHigh=zd_readl(0x708)&0xf;
//Scan user ID of CAM
valid_uid_cnt=0; //Reset number of user ID
for (ii=0; ii<40; ii++)
{
valid_uid[ii]=0;// Reset to invalid
if (ii<32)
{// For user 0 - 31
if (tmpRollCallTblLow & 1)
{
valid_uid[ii]=1;// set to valid
valid_uid_cnt++;
}
tmpRollCallTblLow = tmpRollCallTblLow >> 1;
}
else
{
if (tmpRollCallTblHigh & 1)
{
valid_uid[ii]=1; // set to valid
valid_uid_cnt++;
}
tmpRollCallTblHigh = tmpRollCallTblHigh >> 1;
}
}
// Dump MAC address
UserIdBase=0;
for(ii = 0; ii < 60; ii+=6)
{
//UserIdBase = UserIdBase+4;
MACINCAM[0]=HW_CAM_Read(&dot11Obj, ii);
MACINCAM[1]=HW_CAM_Read(&dot11Obj, ii+1);
MACINCAM[2]=HW_CAM_Read(&dot11Obj, ii+2);
MACINCAM[3]=HW_CAM_Read(&dot11Obj, ii+3);
MACINCAM[4]=HW_CAM_Read(&dot11Obj, ii+4);
MACINCAM[5]=HW_CAM_Read(&dot11Obj, ii+5);
for (jj=0; jj<4; jj++)
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -