zddebug.c

ZYDAS zd1211b driver for Linux2.4

                        u32 *p;

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

        case ZD_IOCTL_TX_RATE:
                printk(KERN_DEBUG "zd1205: set tx rate = %d\n", zdreq->value);

                if (zdreq->value < 0x0c) {
                        macp->cardSetting.FixedRate = zdreq->value;
                        macp->bFixedRate = 1;
                } else
                        macp->bFixedRate = 0;
                break;

        case ZD_IOCTL_EEPROM:
                printk(KERN_DEBUG "zd1205: dump eeprom\n");
                zd1205_dump_eeprom(macp);
                break;

                /* Generate the beacon */
        case ZD_IOCTL_BCN:
                dot11Obj.dbg_cmd |= DBG_CMD_BEACON;
                printk(KERN_DEBUG "zd1205: configuration beacon\n");
                ConfigBcnFIFO();
                break;

        case ZD_IOCTL_REG_READ16:
                tmp_value = zd1211_readl(zdreq->addr, false);
                zdreq->value = tmp_value & 0xffff;
                printk(KERN_DEBUG "zd1205 read register:  reg = %4x, value = %4x\n",
                       zdreq->addr, zdreq->value);
                break;

        case ZD_IOCTL_REG_WRITE16:
                tmp_value = zdreq->value & 0xffff;
                zd1211_writel(zdreq->addr, tmp_value, false);
                printk(KERN_DEBUG "zd1205 write register: reg = %4x, value = %4x\n",
                       zdreq->addr, zdreq->value);
                break;

        case ZD_IOCTL_CAM_READ:
                printk(KERN_ERR "zd1205: cam read, addr: 0x%08x\n", zdreq->addr);
                zd1205_cam_read(macp, zdreq->addr);
                break;

        case ZD_IOCTL_CAM_WRITE:
                printk(KERN_ERR "zd1205: cam write, addr: 0x%08x value: 0x%08x\n", zdreq->addr, zdreq->value);
                zd1205_cam_write(macp, zdreq->addr, zdreq->value);
                break;

        case ZD_IOCTL_CAM_RESET:
                printk(KERN_ERR "zd1205: reset cam\n");
                zd1205_cam_rest(macp, zdreq->value);
                break;

        case ZD_IOCTL_CONT_TX:
                zd1205_cont_tx(macp, zdreq->value);
                break;
        case ZD_IOCTL_SET_MIC_CNT_ENABLE:
                dot11Obj.MIC_CNT = zdreq->value>0?1:0;
                printk("WPA MIC Counter Measure Feature : %s\n",
                       dot11Obj.MIC_CNT ? "Enable":"Disalbe");

                break;
        case ZD_IOCTL_GET_MIC_CNT_ENABLE:
                printk("WPA MIC Counter Measure Feature : %s\n",
                       dot11Obj.MIC_CNT ? "Enable":"Disalbe");

                break;
        default :
                printk(KERN_ERR "zd_dbg_ioctl: error command = %x\n", zd_cmd);
                break;
        }

        return 0;
}


void zd1205_cont_tx(struct zd1205_private *macp, u8 rate)
{

        void *reg = dot11Obj.reg;
        static u8 LastCont_TX_Rate=0;
        printk(KERN_ERR "ZDContinuousTx,Rate=%d\n",rate);

        //if (le32_to_cpu(pZDRD->ZDRdLength) < sizeof(ZD_RD_STRUCT))
        //{
        //   pZDRD->ZDRdLength = cpu_to_le32(sizeof(ZD_RD_STRUCT));
        //    *BytesNeeded = sizeof(ZD_RD_STRUCT);
        //    *BytesRead = 0;
        //    Status = NDIS_STATUS_BUFFER_TOO_SHORT;
        //    break;
        //}

        //macp->bContinueTxMode = le32_to_cpu(pZDRD->Buffer[0]);
        //macp->bContinueTx = le32_to_cpu(pZDRD->Buffer[1]);

        /* Use the Fixed Rate instead of LastSentTxRate */
        //macp->LastZDContinuousTxRate = macp->cardSetting.LastSentTxRate;
        //macp->LastZDContinuousTxRate = macp->cardSetting.FixedRate;

        // Roger 2004-11-10 , Set for Dr.Wang request , set 0x0001c4 when CCK mode with AL2230
        if (dot11Obj.rfMode == AL2230_RF)
        {
                //if (macp->cardSetting.LastSentTxRate > 3) {
                if (LastCont_TX_Rate > 3) {
                        HW_Set_IF_Synthesizer(&dot11Obj, 0x0005a4);
                }
                //else if (macp->cardSetting.LastSentTxRate <= 3) {
                else if (LastCont_TX_Rate <= 3) {
                        HW_Set_IF_Synthesizer(&dot11Obj, 0x0001c4);
                }
        }
        LastCont_TX_Rate = rate;

        if(rate <= RATE_54M)
        {  // Start
                u8	tmpChr = 0;
                u32	RateTmp= 0;
                u32	tmpvalue;
                u32	nLoop;
                LockPhyReg(&dot11Obj);
                dot11Obj.SetReg(reg, ZD1205_CR2, 0x3F);
                dot11Obj.SetReg(reg, ZD1205_CR138, 0x28);
                dot11Obj.SetReg(reg, ZD1205_CR33, 0x20);
                // Query CR60 until change to 0x04
                nLoop = 200;
                while(nLoop--) {
                        dot11Obj.DelayUs(10*1000); // sleep 10ms
                        tmpvalue = dot11Obj.GetReg(reg, ZD1205_CR60);

                        if(tmpvalue == 0x04)
                                break;
                }

                UnLockPhyReg(&dot11Obj);

                printk(KERN_DEBUG "Start ContTx_Normal\n");

                dot11Obj.bContinueTx = 1;
                LockPhyReg(&dot11Obj);
                /* In order to avoid the uninitial length problem,
                   force to set length to 0x20.
                 */
                dot11Obj.SetReg(reg, ZD1205_CR134, 0x20);
                UnLockPhyReg(&dot11Obj);

                switch (rate) {
                case RATE_6M: //6M
                        RateTmp = 0xB;
                        break;
                case RATE_9M: //9M
                        RateTmp = 0xF;
                        break;
                case RATE_12M: //12M
                        RateTmp = 0xA;
                        break;
                case RATE_18M: //18M
                        RateTmp = 0xE;
                        break;
                case RATE_24M: //24M
                        RateTmp = 0x9;
                        break;
                case RATE_36M: //36M
                        RateTmp = 0xD;
                        break;

                case RATE_48M:   //48M
                        RateTmp = 0x8;
                        break;

                case RATE_54M:   //54M
                        RateTmp = 0xC;
                        break;

                default:
                        RateTmp = 0;
                        break;
                }

                printk(KERN_DEBUG "RateTmp=0x%08x\n", RateTmp);

                if (RateTmp) {
                        LockPhyReg(&dot11Obj);
                        dot11Obj.SetReg(reg, ZD1205_CR132, RateTmp);

                        //AcquireCtrOfPhyReg(Adapter);
                        tmpvalue = dot11Obj.GetReg(reg, ZD1205_CR159);
                        tmpvalue &= ~(BIT_0 + BIT_1 );
                        tmpvalue |= BIT_2;
                        dot11Obj.SetReg(reg, ZD1205_CR159, tmpvalue);


                        dot11Obj.SetReg(reg, 0x644, 7);

                        tmpvalue = dot11Obj.GetReg(reg, 0x648);
                        tmpvalue &= ~BIT_0;
                        dot11Obj.SetReg(reg, 0x648, tmpvalue);
                        UnLockPhyReg(&dot11Obj);

                }

                tmpChr = LastCont_TX_Rate;
                printk(KERN_DEBUG "tmpChr=0x%x\n", tmpChr);

#if 0

                if (macp->preambleMode == 1)
                        macp->cardSetting.PreambleType = 0x00;
                else if (macp->preambleMode == 2)
                        macp->cardSetting.PreambleType = 0x20;
#endif

                if (macp->cardSetting.PreambleType == SHORT_PREAMBLE) {
                        // short premable
                        tmpChr |= BIT_5;
                } else {
                        // long premable
                        tmpChr &= ~BIT_5;
                }

                if (macp->RegionCode == 0x10)
                        tmpChr &= ~BIT_6;   //USA
                if (macp->RegionCode == 0x40)
                        tmpChr |= BIT_6;    //japan

                LockPhyReg(&dot11Obj);
                dot11Obj.SetReg(reg, ZD1205_CR5, tmpChr);
                dot11Obj.SetReg(reg, 0x644, 3);
                UnLockPhyReg(&dot11Obj);
        } else
        {
                u32	tmpvalue;

                // Roger 2004-11-10 , Set for Dr.Wang request , set 0x0001c4 when CCK mode with AL2230
                if (dot11Obj.rfMode == AL2230_RF) {
                        HW_Set_IF_Synthesizer(&dot11Obj, 0x0005a4);
                }

                LockPhyReg(&dot11Obj);
                dot11Obj.SetReg(reg, ZD1205_CR2, 0x26);
                dot11Obj.SetReg(reg, ZD1205_CR138, 0xA8);
                dot11Obj.SetReg(reg, ZD1205_CR33, 0x08);
                UnLockPhyReg(&dot11Obj);
                printk(KERN_DEBUG "Stop Normal Continuous Transmit\n");

                dot11Obj.bContinueTx = 0;
                LockPhyReg(&dot11Obj);
                macp->PHYTestTimer = 30;
                //                      ZD1205_WRITE_REGISTER(Adapter,CR122, 0x0);
                UnLockPhyReg(&dot11Obj);

                if (LastCont_TX_Rate >= 4) {
                        LockPhyReg(&dot11Obj);
                        tmpvalue = dot11Obj.GetReg(reg, ZD1205_CR159);
                        tmpvalue &= ~(BIT_0 + BIT_1 + BIT_2 );
                        dot11Obj.SetReg(reg, ZD1205_CR159, tmpvalue);

                        dot11Obj.SetReg(reg, 0x644, 0);

                        tmpvalue = dot11Obj.GetReg(reg, 0x648);
                        tmpvalue |= BIT_0;
                        dot11Obj.SetReg(reg, 0x648, tmpvalue);
                        UnLockPhyReg(&dot11Obj);

                } else {
                        LockPhyReg(&dot11Obj);
                        dot11Obj.SetReg(reg, 0x644, 0);

                        tmpvalue = dot11Obj.GetReg(reg, 0x648);
                        tmpvalue |= BIT_0;
                        dot11Obj.SetReg(reg, 0x648, tmpvalue);
                        UnLockPhyReg(&dot11Obj);
                }

                //dot11Obj.SetReg(reg, ZD_PS_Ctrl, 0x1);
                //Roger 2004-11-16 SoftwareReset here to solve RX fail after TxContinue problem
                {
                        //zd1205_device_reset(macp);
                        //Card resetting , copying from driver of ZyNOS
                        //It's a little different from ours
                        u32  tmp_value;
                        /* Update the value of Beacon Interval and Pre TBTT */
                        update_beacon_interval(macp, 0x2);
                        zd_writel(0x01, Pre_TBTT);

                        LockPhyReg(&dot11Obj);
                        dot11Obj.SetReg(dot11Obj.reg, ZD1205_PHY_END, 0x8);
                        tmp_value = zd_readl(PS_Ctrl);
                        zd_writel(tmp_value | BIT_5, PS_Ctrl);
                        dot11Obj.SetReg(dot11Obj.reg, ZD1205_PHY_END, 0x0);
                        UnLockPhyReg(&dot11Obj);

                        dot11Obj.bDeviceInSleep = 1;
                        dot11Obj.DelayUs(5000);
                }
        }

        return 0;
}

#endif