zdreq.c

zd1211b芯片的无线网卡的驱动,移植到s3c2410平台

                        }

/* Update the total EEPROM content */
                        //RamAddr is 2nd argument, it differs from Win
                        HW_EEPROM_ACCESS(&dot11Obj, cFIRMWARE_EEPROM_OFFSET, cEPDATA_OFFSET, (E2P_END-E2P_SUBID)/2, 1);
						//ZD1205_WriteE2P(&dot11Obj);
                        ZDPRODUCTDBG("ZDROMUpdate Write Complete\n");
                    }
                    break;
                case ZDSetMACAddress:
                    ZDPRODUCTDBG("ZDSetMACAddress\r\n");
                    {
                        ULONG j=0;
                        u8 *p = (u8 *)pZDRD->Buffer;
                        j+=p[3]; j<<=8;
                        j+=p[2]; j<<=8;
                        j+=p[1]; j<<=8;
                        j+=p[0];
                        dot11Obj.SetReg(reg,E2P_MACADDR_P1,j);
                        dot11Obj.DelayUs(10);
                        j=0;
                        j+=p[5]; j<<=8;
                        j+=p[4];

                        dot11Obj.SetReg(reg,E2P_MACADDR_P2,j);
                        dot11Obj.DelayUs(10);

                        //HW_EEPROM_ACCESS(&dot11Obj, 0, 0, EEPROM_SIZE, 1);
                        //RamAddr is 2nd argument, it differs from Win
                        HW_EEPROM_ACCESS(&dot11Obj, cFIRMWARE_EEPROM_OFFSET, cEPDATA_OFFSET, (E2P_END-E2P_SUBID)/2, 1);
						//ZD1205_WriteE2P(&dot11Obj);
                    }
                    break;
                case ZDEEPROMDataWrite:
                    ZDPRODUCTDBG("ZDEEPROMDataWrite\r\n");

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

                    //RamAddr is 2nd argument, it differs from Win
/* Update the total EEPROM content */
                    HW_EEPROM_ACCESS(&dot11Obj, cFIRMWARE_EEPROM_OFFSET, cEPDATA_OFFSET, (E2P_END-E2P_SUBID)/2, 1);
					//ZD1205_WriteE2P(&dot11Obj);
                    break;

                case ZDTxPowerGainControl:
                    ZDPRODUCTDBG("ZDTxPowerGainControl\r\n");

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

                    if(le32_to_cpu(pZDRD->Buffer[0]) == 0)
                    {
                        zd1205_DecreaseTxPower(macp, cTX_CCK);
#if fTX_GAIN_OFDM
                        zd1205_DecreaseTxPower(macp, cTX_OFDM);
#endif
                    }
                    else
                    {
                        zd1205_IncreaseTxPower(macp, cTX_CCK);
#if fTX_GAIN_OFDM
                        zd1205_IncreaseTxPower(macp, cTX_OFDM);
#endif
                    }
                    break;

                case ZDGetNICAdapterTally:
                    printk("Clear Tally Information !!!!!!!!!!!!!!!!11\n");
                    ZDPRODUCTDBG("ZDGetNICAdapterTally\r\n");

                    Reset_Tally(macp);
                    break;

                case ZDContinuousTx:
                    printk(KERN_ERR "ZDContinuousTx\n");

                    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;

					if ((macp->RF_Mode == AL7230B_RF) && (mMacMode != PURE_A_MODE)) {
						if (macp->LastZDContinuousTxRate > 3) {
							HW_Set_IF_Synthesizer(&dot11Obj, 0x00093c); 
						}
						else if (macp->LastZDContinuousTxRate <= 3) {
							HW_Set_IF_Synthesizer(&dot11Obj, 0x000abc); 
						}
					}
#ifdef ZDCONF_BANDEDGE_ADJUST
//					if((macp->RF_Mode == AL7230B_RF) && 
//						(mMacMode == PURE_A_MODE) && 
//						(macp->LastZDContinuousTxRate  == 4) && 
//						(macp->PHY_36M_Setpoint_Flag == 0)
//					)
//						macp->PHY_36M_Setpoint_Flag = 1;
//				    else if((macp->RF_Mode == AL7230B_RF) && 
//						(mMacMode == PURE_A_MODE) && 
//						(macp->LastZDContinuousTxRate != 4) && 
//						(macp->PHY_36M_Setpoint_Flag == 2)
//					)
//						macp->PHY_36M_Setpoint_Flag = 3;
    
	                if(dot11Obj.HWFeature & BIT_21) { //band edge adjust for calibration, the production test tool must do integration value /set point compensation for other channels which are not calibrated
						if( (macp->RF_Mode == AL7230B_RF) && 
							((4 <= macp->LastZDContinuousTxRate) && (macp->LastZDContinuousTxRate <= 9)) && 
							(mMacMode != PURE_A_MODE) && 
							(macp->cardSetting.Channel == 1 || macp->cardSetting.Channel == 11)
						)
						{ 
							if(macp->cardSetting.Channel == 1)   
								HW_Set_IF_Synthesizer(&dot11Obj, 0x000abc);
							LockPhyReg(&dot11Obj);
							dot11Obj.SetReg(dot11Obj.reg, ZD_CR128, 0x10);
							dot11Obj.SetReg(dot11Obj.reg, ZD_CR129, 0x10);
							UnLockPhyReg(&dot11Obj);   
						}
						else if((macp->RF_Mode == AL7230B_RF) && 
								(macp->LastZDContinuousTxRate > 3) && 
								(mMacMode != PURE_A_MODE))
						{
							if((macp->LastZDContinuousTxRate > 9) || 
								(macp->cardSetting.Channel != 1 && 
								macp->cardSetting.Channel != 11))
							{
								if(macp->cardSetting.Channel == 1)
									HW_Set_IF_Synthesizer(&dot11Obj, 0x00093c);
								LockPhyReg(&dot11Obj);
								dot11Obj.SetReg(&dot11Obj.reg, ZD_CR128, 0x14);
								dot11Obj.SetReg(&dot11Obj, ZD_CR129, 0x12);
								UnLockPhyReg(&dot11Obj);
							}
						}    
						else if((macp->RF_Mode == AL7230B_RF) && 
								(macp->LastZDContinuousTxRate <=3) && 
								(mMacMode != PURE_A_MODE))
						{
                                LockPhyReg(&dot11Obj);
                                dot11Obj.SetReg(&dot11Obj.reg, ZD_CR128, 0x14);
                                dot11Obj.SetReg(&dot11Obj, ZD_CR129, 0x12);
                                UnLockPhyReg(&dot11Obj);
						}
					}
 
#elif !defined(ZDCONF_BANDEDGE_ADJUST)
	#error "Undefined ZDCONF_BANDEDGE_ADJUST"
#endif
// Roger 2004-11-10 , Set for Dr.Wang request , set 0x0001c4 when CCK mode with AL2230
#ifdef ZDCONF_RF_AL2230_SUPPORT
                    if (dot11Obj.rfMode == AL2230_RF || dot11Obj.rfMode == AL2230S_RF)
                    {
//if (macp->cardSetting.LastSentTxRate > 3) {
                        if (macp->LastZDContinuousTxRate > 3)
                        {
                            HW_Set_IF_Synthesizer(&dot11Obj, 0x0005a4);
                        }
//else if (macp->cardSetting.LastSentTxRate <= 3) {
                        else if (macp->LastZDContinuousTxRate <= 3)
                        {
                            HW_Set_IF_Synthesizer(&dot11Obj, 0x0001c4);
                        }
                    }
#endif

                    ZDPRODUCTDBG("ZDContinuousTx TxMode=%d TxStart=%d TxRate=0x%x\r\n",
                        macp->bContinueTxMode,
                        macp->bContinueTx,
                        macp->LastZDContinuousTxRate);

// Start
                    if(le32_to_cpu(pZDRD->Buffer[1]) == ContTx_Start)
                    {
                        UCHAR   tmpChr = 0;
                        UINT    RateTmp= 0;
                        ULONG tmpvalue;
                        ULONG   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 = 20;
                        while(nLoop--)
                        {
                            dot11Obj.DelayUs(10*1000);// sleep 10ms
                            tmpvalue = dot11Obj.GetReg(reg, ZD1205_CR60);

                            if(tmpvalue == 0x04)
                                break;
                        }

                        UnLockPhyReg(&dot11Obj);
                        switch(le32_to_cpu(pZDRD->Buffer[0]))
                        {
                            case ContTx_Normal:   // Normal continous transmit

                                ZDPRODUCTDBG("Start ContTx_Normal\n");

                                macp->bContinueTx = 1;
                                LockPhyReg(&dot11Obj);
                                macp->PHYTestTimer = 0;
//ZD1205_WRITE_REGISTER(Adapter,CR122, 0xFF);  2004/10/22 mark
                                UnLockPhyReg(&dot11Obj);

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

                                switch (macp->LastZDContinuousTxRate)
                                {
                                    case 4:       //6M
                                        RateTmp = 0xB;
                                        break;
                                    case 5:       //9M
                                        RateTmp = 0xF;
                                        break;
                                    case 6:       //12M
                                        RateTmp = 0xA;
                                        break;
                                    case 7:       //18M
                                        RateTmp = 0xE;
                                        break;
                                    case 8:       //24M
                                        RateTmp = 0x9;
                                        break;
                                    case 9:       //36M
                                        RateTmp = 0xD;
                                        break;

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

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

                                    default:
                                        RateTmp = 0;
                                        break;
                                }

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

                                if (RateTmp)
                                {
                                    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);

                                    UnLockPhyReg(&dot11Obj);

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

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

                                    break;
                                }

                                tmpChr = macp->LastZDContinuousTxRate;
                                ZDPRODUCTDBG("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

                                dot11Obj.SetReg(reg, ZD1205_CR5, tmpChr);
                                UnLockPhyReg(&dot11Obj);

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

                            case ContTx_CW:       // CW transmit
                                ZDPRODUCTDBG("Start CW transmit\n");
                                macp->bContinueTx = 1;

                                LockPhyReg(&dot11Obj);
                                tmpvalue = dot11Obj.GetReg(reg, ZD1205_CR9);
                                tmpvalue |= 0x18;
                                dot11Obj.SetReg(reg, ZD1205_CR9, tmpvalue);
                                UnLockPhyReg(&dot11Obj);

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

// Carrier suppression
                            case ContTx_CarrierSuppression:
                                ZDPRODUCTDBG("Start Carrier suppression transmit\n");
                                macp->bContinueTx = 1;

                                LockPhyReg(&dot11Obj);
                                tmpvalue = dot11Obj.GetReg(reg, ZD1205_CR9);
                                tmpvalue &= ~0x10;
                                tmpvalue |= 0x8;