zddebug.c

ZYDAS zd1211b driver for Linux2.4

        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++) {
                        if (valid_uid[UserIdBase+jj]) {
                                printk(KERN_ERR "UID:%d Mac:%02x:%02x:%02x:%02x:%02x:%02x\n",UserIdBase+jj, MACINCAM[0]&255, MACINCAM[1]&255, MACINCAM[2]&255, MACINCAM[3]&255,MACINCAM[4]&255,MACINCAM[5]&255);
                        }
                        MACINCAM[0]=MACINCAM[0]>>8;
                        MACINCAM[1]=MACINCAM[1]>>8;
                        MACINCAM[2]=MACINCAM[2]>>8;
                        MACINCAM[3]=MACINCAM[3]>>8;
                        MACINCAM[4]=MACINCAM[4]>>8;
                        MACINCAM[5]=MACINCAM[5]>>8;
                }
                UserIdBase = UserIdBase+4;
        }
        // Dump Encryption type: CAM location: 60-65
        //tmpRollCallTblLow=RollCallTblLow;
        //tmpRollCallTblHigh=RollCallTblHigh;
        for(ii=60; ii<66; ii++)
        {
                data = HW_CAM_Read(&dot11Obj, ii);
                UserIdBase=(ii-60)*8; //One location for 8 users.
                if (UserIdBase >= 40) {
                        {//location 65:For default key
                                printk(KERN_ERR "DefaultKeySet:%s\n",EncTypeStr[data&7]);
                        }
                } else {
                        for(jj=0; jj<8; jj++) {
                                if (valid_uid[UserIdBase+jj]) {
                                        printk(KERN_ERR "UID:%02d:%s\n",UserIdBase+jj,EncTypeStr[data&7]);
                                        valid_uid[UserIdBase+jj] |= ((data & 7)<<1);
                                }
                                data = data >> 4; // Next user.
                        }
                }
        }
        printk(KERN_ERR "KeyContents:\n");
        for (ii=0; ii<40; ii++)
        {
                u32 keylen;
                u32 keytype;

                if (valid_uid[ii]) {
                        keytype=valid_uid[ii]>>1;
                        switch(keytype) {
                        case 2://TKIP
                                keylen=32;
                                break;
                        case 4://AES
                                keylen=16;
                                break;
                        case 1://WEP64
                                keylen=8;
                                break;
                        case 5://WEP128
                                keylen=16;
                                break;
                        default:
                                keylen=0;
                                break;
                        }
                        keylen = keylen >> 2;
                        printk(KERN_ERR "UID:%02d\n", ii);
                        for (jj=0; jj<keylen; jj++) {
                                data = HW_CAM_Read(&dot11Obj, (66+(8*ii))+jj);
                                printk(KERN_ERR "%08x\n", data);
                        }
                }
        }
        printk(KERN_ERR "\n");
}
void zd1205_cam_read(struct zd1205_private *macp, u32 addr)
{
        u32 value = HW_CAM_Read(&dot11Obj, addr);
        printk(KERN_ERR "Addr: 0x%08x, value = 0x%08x\n", addr, value);
}

void zd1205_cam_write(struct zd1205_private *macp, u32 addr, u32 value)
{
        HW_CAM_Write(&dot11Obj, addr, value);
        printk(KERN_ERR "Write value: 0x%08x to CAM address: 0x%08x\n", value, addr);
}

void zd1205_cam_rest(struct zd1205_private *macp, int mode)
{
}

int zd1205_zd_dbg_ioctl(struct zd1205_private *macp, struct zdap_ioctl *zdreq)
{
        void *regp = macp->regp;
        u16 zd_cmd;
        u32 tmp_value;
        u32 tmp_addr;
        u32 CRn;

        zd_cmd = zdreq->cmd;

        switch(zd_cmd)
        {
        case ZD_IOCTL_DEBUG_FLAG:
                macp->debugflag = zdreq->addr;
                mDebugFlag = zdreq->value;
                break;
        case ZD_IOCTL_REG_READ:
                acquire_ctrl_of_phy_req(regp);
                tmp_value = zd_readl(zdreq->addr);
                release_ctrl_of_phy_req(regp);
                zdreq->value = tmp_value;

                printk(KERN_DEBUG "zd1211 read register:  reg = 0x%04x, value = 0x%08x\n",
                       zdreq->addr, zdreq->value);
                //if (copy_to_user(ifr->ifr_data, &zdreq, sizeof (zdreq)))
                //return -EFAULT;
                break;

        case ZD_IOCTL_REG_WRITE:
                acquire_ctrl_of_phy_req(regp);
                zd_writel(zdreq->value, zdreq->addr);
                release_ctrl_of_phy_req(regp);

                if (zdreq->addr == RX_OFFSET_BYTE)
                        macp->rxOffset = zdreq->value;
                break;

        case ZD_IOCTL_MEM_DUMP:
                zd1205_dump_data("mem", (u8 *)zdreq->addr, zdreq->value);
                //memcpy(&zdreq->data[0], (u8 *)zdreq->addr, zdreq->value);
                //if (copy_to_user(ifr->ifr_data, &zdreq, sizeof (zdreq)))
                //return -EFAULT;
                break;

        case ZD_IOCTL_RATE:
                /* Check for the validation of vale */
                if(zdreq->value > 3 || zdreq->value < 0) {
                        printk(KERN_DEBUG "zd1205: Basic Rate %x doesn't support\n", zdreq->value);
                        break;
                }

                printk(KERN_DEBUG "zd1205: Basic Rate = %x\n", zdreq->value);
                zd1205_update_brate(macp, zdreq->value);
                break;

        case ZD_IOCTL_SNIFFER:
                macp->sniffer_on = zdreq->value;
                printk(KERN_DEBUG "zd1205: sniffer_on = %x\n", macp->sniffer_on);
                zd1205_set_sniffer_mode(macp);
                break;

        case ZD_IOCTL_CAM_DUMP://Arg1: Location, Arg2: Length
                {
                        u32 startAddr, length;
                        startAddr=((zdreq->addr & 0xF00)>>8)*100+
                                  ((zdreq->addr & 0xF0)>>4)*10+
                                  (zdreq->addr & 0xF);
                        length=((zdreq->value & 0xF00)>>8)*100+
                               ((zdreq->value & 0xF0)>>4)*10+
                               (zdreq->value & 0xF);
                        printk(KERN_DEBUG "zd1205: dump cam\n");
                        zd1205_dump_cam(macp,startAddr,length);
                        break;
                }
        case ZD_IOCTL_DUMP_PHY:
                printk(KERN_DEBUG "zd1205: dump phy\n");
                zd1205_dump_phy(macp);
                break;
        case ZD_IOCTL_READ_PHY:
        case ZD_IOCTL_WRITE_PHY:
                acquire_ctrl_of_phy_req(regp);
                tmp_addr = zdreq->addr;
                CRn=    ((tmp_addr & 0xF00)>>8)*100+
                        ((tmp_addr & 0xF0)>>4)*10+
                        (tmp_addr & 0xF);
                if (CRn >= 4 && CRn <= 8)//Special handling for CR4 to CR8
                {
                        u8 cnvtbl1[]={0x20, 0x10, 0x14, 0x18, 0x1c};
                        tmp_addr = cnvtbl1[CRn-4];
                } else {
                        tmp_addr = CRn*4;
                }
                if (zd_cmd == ZD_IOCTL_READ_PHY) {
                        zdreq->value = zd_readl(tmp_addr);
                        printk(KERN_DEBUG "CR%d=0x%x\n",CRn, zdreq->value);
                } else {// ZD_IOCTL_WRITE_PHY
                        zd_writel(zdreq->value, tmp_addr);
                        printk(KERN_DEBUG "set CR%d=0x%x\n",CRn, zdreq->value);
                }
                release_ctrl_of_phy_req(regp);
                break;

        case ZD_IOCTL_CARD_SETTING:
                printk(KERN_DEBUG "zd1205: card setting\n");
                zd1205_show_card_setting(macp);
                break;

        case ZD_IOCTL_HASH_DUMP:
                printk(KERN_DEBUG "zd1205: aid = %x\n", zdreq->value);
                zd1205_show_hash(macp, zdreq->value);
                break;

        case ZD_IOCTL_RFD_DUMP:
                printk(KERN_DEBUG "===== zd1205 rfd dump =====\n");
                zd1205_dump_rfds(macp);
                break;

        case ZD_IOCTL_MEM_READ: {
                        u32 *p;

                        p = (u32 *) bus_to_virt(zdreq->addr);
                        printk(KERN_DEBUG "zd1205: read memory addr: 0x%08x value: 0x%08x\n", zdreq->addr, *p);
                        break;
                }

        case ZD_IOCTL_MEM_WRITE: {