zd1211.c

ZYDAS zd1211b driver for Linux2.4

                        ((PUSB_WRITE_REG)pRegBuffer)->WritePackage[i].Address = cpu_to_le16(Address[i]);
                        ((PUSB_WRITE_REG)pRegBuffer)->WritePackage[i].WriteData_low = cpu_to_le16(Value[i]);
                }
        }

        bufSize = sizeof(u16) * (1+RegCount*2);

        if (macp->ep4isIntOut)
                usb_fill_int_urb(macp->reg_urb, macp->usb,
                                 usb_sndintpipe(macp->usb, EP_REG_OUT),
                                 pRegBuffer, bufSize,
                                 zd1211_reg_cb, macp, 1);
        else
                usb_fill_bulk_urb(macp->reg_urb, macp->usb,
                                  usb_sndbulkpipe(macp->usb, EP_REG_OUT),
                                  pRegBuffer, bufSize,
                                  zd1211_reg_cb, macp);
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14))

        macp->reg_urb->transfer_flags |= URB_ASYNC_UNLINK;
#endif

        if ((ret = SUBMIT_URB(macp->reg_urb, GFP_ATOMIC))) {
                printk(KERN_ERR "zd1211: failed reg_urb\n");
                zd1211_DumpErrorCode(macp, ret);
                goto out;
        }

        macp->regWaitWCompCnt++;
        wait_event(macp->regSet_wait, test_bit(ZD1211_CMD_FINISH, &macp->flags));

        macp->regRWCompCnt++;
        clear_bit(ZD1211_CMD_FINISH, &macp->flags);

out:
        kfree(pRegBuffer);
        up(&macp->reg_sem);
        return ret;
}

int zd1211_WriteMultiRegister(u16 *Address, u16 *Value, u16 RegCount, u8 bAddUSBCSRAddress) {
        int ret = 1;
        int count = 0;

        while (ret != 0) {
                ret = zd1211_USB_PACKAGE_WRITE_REGISTER(Address, Value, RegCount, bAddUSBCSRAddress);

                count++;
                if (count > 5) {
                        FPRINT("zd1211_WriteMultiRegister failed");
                        break;
                }
        }

        return ret;
}


//return 0: success
int zd1211_writel(u32 Address, u32 Value, u8 bAddUSBCSRAddress) {
        struct zd1205_private *macp = g_dev->priv;
#ifdef fQuickPhySet

        u8	bIsPhyReg = 0;
#endif


        u16  WriteAddr[6];
        u16  WriteData[6];
        int ret = 1;
        int count = 0;

#ifdef fQuickPhySet

        if (bAddUSBCSRAddress && (Address <= ZD1205_PHY_END))

                bIsPhyReg = 1;
#endif


#ifdef fQuickPhySet

        if (bIsPhyReg) {
                u32	tmpvalue;

                tmpvalue = zd_readl(CtlReg1);
                tmpvalue &= ~0x80;
                {
                        if (((macp->USBCSRAddress+CtlReg1) & BASE_ADDR_MASK_HOST) == USB_BASE_ADDR_HOST)
                                WriteAddr[0] = (u16) (macp->USBCSRAddress+CtlReg1) + 1;
                        else

                                // must write High word first
                                WriteAddr[0] = (u16) (macp->USBCSRAddress+CtlReg1) + 2;
                }
                WriteData[0] = (u16) (tmpvalue >> 16);

                WriteAddr[1] = (u16) (macp->USBCSRAddress+CtlReg1);

                WriteData[1] = (u16) (tmpvalue & 0xFFFF);

                if (bAddUSBCSRAddress) {
                        Address += (u16) (macp->USBCSRAddress);
                        if ((Address & BASE_ADDR_MASK_HOST) == USB_BASE_ADDR_HOST)
                                WriteAddr[2] = (u16) Address + 1;
                        else
                                // must write High word first
                                WriteAddr[2] = (u16) Address + 2;
                } else
                        WriteAddr[2] = (u16) Address + 1;

                WriteData[2] = (u16) (Value >> 16);
                WriteAddr[3] = (u16) Address;

                WriteData[3] = (u16) (Value & 0xFFFF);


                tmpvalue |= 0x80;
                {

                        if (((macp->USBCSRAddress+CtlReg1) & BASE_ADDR_MASK_HOST) == USB_BASE_ADDR_HOST)

                                WriteAddr[4] = (u16) (macp->USBCSRAddress+CtlReg1) + 1;
                        else
                                // must write High word first
                                WriteAddr[4] = (u16) (macp->USBCSRAddress+CtlReg1) + 2;
                }
                WriteData[4] = (u16) (tmpvalue >> 16);
                WriteAddr[5] = (u16) (macp->USBCSRAddress+CtlReg1);
                WriteData[5] = (u16) (tmpvalue & 0xFFFF);

                return zd1211_USB_PACKAGE_WRITE_REGISTER(WriteAddr, WriteData, 6, false);
        } else {
#endif
                if (bAddUSBCSRAddress) {
                        Address += macp->USBCSRAddress;
                        if ((Address & BASE_ADDR_MASK_HOST) == USB_BASE_ADDR_HOST)
                                WriteAddr[0] = (u16) Address + 1;
                        else
                                // must write High word first
                                WriteAddr[0] = (u16) Address + 2;
                } else
                        WriteAddr[0] = (u16) Address + 1;

                WriteAddr[1] = (u16) Address;
                WriteData[0] = (u16) (Value >> 16);
                WriteData[1] = (u16) (Value & 0xFFFF);


                while (ret != 0) {
                        ret = zd1211_USB_PACKAGE_WRITE_REGISTER(WriteAddr, WriteData, 2, false);
                        count++;
                        if (count > 5) {

                                printk(KERN_ERR "zd1211_writel failed for 5 attempts\n");
                                break;
                        }
                }

#ifdef fQuickPhySet

        }
#endif

        return ret;
}



void zd1211_StrongSignalDect(struct zd1205_private *macp) {
        u32 tmpvalue;

        if ( (macp->PHYTestTimerCount >= macp->PHYTestTimer)&&
                        (macp->PHYTestTimer) && (macp->PHYLowPower & BIT_0)	&&
                        (!dot11Obj.bContinueTx) &&

                        (macp->bAssoc))
        {
                macp->PHYTestTimerCount = 0;
                if (macp->RF_Mode == RFMD_RF) {
                        if ( (macp->PHYTestRssi >= macp->PHYTestRssiBound) &&

                                        ((!dot11Obj.CR122Flag) || (dot11Obj.CR122Flag == 2))) {
                                LockPhyReg(&dot11Obj);
                                zd_writel(0xff, ZD1205_CR122);

                                if ( (macp->PHYLowPower & BIT_1)&&
                                                ((!dot11Obj.CR31Flag) || (dot11Obj.CR31Flag == 2)) ) {


                                        macp->bTraceSetPoint = 0;

                                        tmpvalue = dot11Obj.IntValue[dot11Obj.Channel-1] - cPWR_STRONG_SIG_DROP;

                                        zd_writel(tmpvalue, ZD1205_CR31);

                                        dot11Obj.CR31Flag = 1;
                                }


                                UnLockPhyReg(&dot11Obj);

                                dot11Obj.CR122Flag = 1;

                        } else if ( (macp->PHYTestRssi < macp->PHYTestRssiBound) &&
                                        ((dot11Obj.CR122Flag) || (dot11Obj.CR122Flag == 2)) ) {
                                LockPhyReg(&dot11Obj);
                                zd_writel(0x00, ZD1205_CR122);
                                UnLockPhyReg(&dot11Obj);

                                if ( (macp->PHYLowPower & BIT_1) &&

                                                ((dot11Obj.CR31Flag) || (dot11Obj.CR31Flag == 2)) ) {
                                        macp->bTraceSetPoint = 1;

                                        HW_UpdateIntegrationValue(&dot11Obj, dot11Obj.Channel, macp->cardSetting.MacMode);

                                        dot11Obj.CR31Flag = 0;

                                }


                                dot11Obj.CR122Flag = 0;
                        }

                } else if((macp->RF_Mode == AL2230_RF) || (macp->RF_Mode == AL2230S_RF)) {
                        if ( (macp->PHYTestRssi >= macp->PHYTestRssiBound)&&
                                        ((!dot11Obj.CR203Flag) || (dot11Obj.CR203Flag == 2)) ) {

                                LockPhyReg(&dot11Obj);

                                zd_writel(0x0a, ZD1205_CR203);
                                if ( (macp->PHYLowPower & BIT_1)&&
                                                ((!dot11Obj.CR31Flag) || (dot11Obj.CR31Flag == 2)) ) {



                                        macp->bTraceSetPoint = 0;

                                        tmpvalue = dot11Obj.IntValue[dot11Obj.Channel-1] - cPWR_STRONG_SIG_DROP;
                                        zd_writel(tmpvalue, ZD1205_CR31);
                                        dot11Obj.CR31Flag = 1;
                                }

                                UnLockPhyReg(&dot11Obj);
                                dot11Obj.CR203Flag = 1;
                        } else if ( (macp->PHYTestRssi < macp->PHYTestRssiBound)&&
                                        ((dot11Obj.CR203Flag) || (dot11Obj.CR203Flag == 2)) ) {
                                LockPhyReg(&dot11Obj);
                                zd_writel(0x06, ZD1205_CR203);
                                UnLockPhyReg(&dot11Obj);




                                if ( (macp->PHYLowPower & BIT_1)&&
                                                ((dot11Obj.CR31Flag) || (dot11Obj.CR31Flag == 2)) ) {

                                        macp->bTraceSetPoint = 1;


                                        HW_UpdateIntegrationValue(&dot11Obj, dot11Obj.Channel, macp->cardSetting.MacMode);
                                        dot11Obj.CR31Flag = 0;
                                }


                                dot11Obj.CR203Flag = 0;
                        }
                }
        } else
        {
                macp->PHYTestTimerCount++;

        }
}


//================================================================
// Housekeeping Every 0.5 s
//================================================================


void zd1211_TxCalibration(struct zd1205_private *macp) {
        static u32 loop = 0;

        static u16 TrackingLoop = 0;
        static u32 accumulate  = 0;
        u8 setpoint;
        u16 channel;
        u32	average = 0;
        u32	tmpvalue;
        static u16 TrackingCnt = 0;
        static u32 accumulate_OFDM = 0;
        static u16 TrackingCnt_OFDM = 0;
        u8  PreTxOFDMType = cTX_CCK;

        loop++;


#if fTX_PWR_CTRL

        if ((loop % 64) == 0)
        {
                if (macp->bTraceSetPoint) {


                        LockPhyReg(&dot11Obj);
                        if (TrackingLoop == TRACKING_NUM) {
                                TrackingLoop = 0;


                                if (TrackingCnt && PURE_A_MODE != macp->cardSetting.MacMode ) {
                                        average = (u32) (accumulate / TrackingCnt);
                                        channel = dot11Obj.Channel;
                                        setpoint = macp->EepSetPoint[channel-1];
                                        if (macp->EnableTxPwrCtrl) {
                                                if (average < (u32) (setpoint - cPWR_CTRL_GUARD))
                                                        zd1205_IncreaseTxPower(macp, cTX_CCK);
                                                else if (average > setpoint)

                                                        zd1205_DecreaseTxPower(macp, cTX_CCK);
                                        }
                                        accumulate = 0;
                                        TrackingCnt = 0;
                                }

                                if (TrackingCnt_OFDM) {
                                        average = (u32) (accumulate_OFDM / TrackingCnt_OFDM);
                                        channel = dot11Obj.Channel;
                                        if(PURE_A_MODE != macp->cardSetting.MacMode) {
                                                setpoint = macp->SetPointOFDM[macp->TxOFDMType - cTX_OFDM][channel - 1];
                                        } else if (PURE_A_MODE == macp->cardSetting.MacMode) {
                                                u8 UselessInt;//Only for store return Integration value that we don't need
                                                int ret;
                                                ret = a_OSC_get_cal_int(
                                                              channel,
                                                              macp->cardSetting.LastSentTxRate ,
                                                              &UselessInt, &setpoint);
                                                if(0 != ret)
                                                        printk("a_OSC_get_cal_int can't found the channel\n");
                                        }
                                        //printk("Enter TrackingCnt_OFDM(CH:%d)(SET:%d)(avg:%d)\n",channel,setpoint,average);
                                        if (macp->EnableTxPwrCtrl) {
                                                if (average < (u32) (setpoint - cPWR_CTRL_GUARD))
                                                        zd1205_IncreaseTxPower(macp, cTX_OFDM);
                                                else if (average > setpoint)
                                                        zd1205_DecreaseTxPower(macp, cTX_OFDM);
                                        }
                                        accumulate_OFDM = 0;
                                        TrackingCnt_OFDM = 0;
                                }
                        } else {

                                TrackingLoop ++;