zdhci.c

ZYDAS zd1211b driver for Linux2.4

BOOLEAN zd_CmdFlushQ(void)
{
        if (pdot11Obj->QueueFlag & TX_QUEUE_SET) {
                FlushQ(pTxQ);
        } else if (pdot11Obj->QueueFlag & MGT_QUEUE_SET) {
                FlushQ(pMgtQ);
        } else if (pdot11Obj->QueueFlag & AWAKE_QUEUE_SET) {
                FlushQ(pAwakeQ);
        }

        return TRUE;
}

BOOLEAN zd_CmdProcess(U16 CmdId, void *parm1, U32 parm2)
{
        BOOLEAN status = TRUE;

        switch(CmdId) {
        case CMD_RESET_80211:
                status = zd_Reset80211((zd_80211Obj_t *)parm1);
                break;

        case CMD_ENABLE:
                if (mBssType == AP_BSS)
                        status = zd_StartAP();
                else {
                        if ((pdot11Obj->ConfigFlag & SCAN_AND_CONNECT_SET)||(mRequestFlag & CHANNEL_SCAN_SET)) {
                                //    printk("Scan and connect is underGoing\n");
                                break;
                        } else if (!mIfaceOpened) {
                                status = zd_StartSTA(1);
                                mIfaceOpened = TRUE;
                        } else {
                                pdot11Obj->ConfigFlag |= SCAN_AND_CONNECT_SET;
                                zd_ChooseAP(0);
                        }
                }

                break;

        case CMD_DISASOC: //IAPP cth
                status = zd_CmdDisasoc((MacAddr_t*)parm1, (U8)parm2);
                break;

        case CMD_DEAUTH://MAC filter cth
                status = zd_CmdDeauth((MacAddr_t*)parm1, (U8)parm2);
                break;

        case CMD_PS_POLL:
                //PSDEBUG("CMD_PS_POLL");
                status = zd_HandlePsPoll((U8 *)parm1);
                break;

        case CMD_PASSIVE_SCAN:
                status = zd_PassiveScan();
                break;

        case CMD_DISASOC_ALL:
                status = zd_DisasocAll((U8)parm2);
                break;

        case CMD_CONNECT: {
                        U8 *pBsstype=(U8*)parm1;
                        status = zd_CmdConnect((U8)parm2,*pBsstype);
                }
                break;

        case CMD_PROBE_REQ:
                //FPRINT("CMD_PROBE_REQ");
                status = zd_CmdProbeReq((U8)parm2);
                pdot11Obj->ConfigFlag |= JUST_CHANNEL_SCAN;
                break;

        case CMD_DIS_CONNECT:
                status = zd_CmdDisConnect();
                break;

        case CMD_FLUSH_QUEUE:
                status = zd_CmdFlushQ();
                break;

        case CMD_ROAMING:
                status = zd_CmdRoaming();
                break;

        default:
                status = FALSE;
                break;
        }

        return status;
}

//Event Nofify Functions
void zd_NextBcn(void)
{
        if (mBssType == AP_BSS) {
                if (mDtimCount == 0)
                        mDtimCount = mDtimPeriod;
                mDtimCount--;
        }

        ConfigBcnFIFO();

        if (pTxQ->cnt)
                pdot11Obj->QueueFlag |= TX_QUEUE_SET;
        return;
}

void zd_DtimNotify(void)
{
        SendMcPkt();
        return;
}

extern BOOLEAN Tchal_WaitChalRsp(Signal_t *signal);
void zd_SendTChalMsg(void)
{
        Tchal_WaitChalRsp(NULL);
        return;
}

extern BOOLEAN AuthTimeOut(Signal_t *signal);
void zd_SendTAuthMsg(void)
{
        AuthTimeOut(NULL);
        return;
}

extern BOOLEAN AsocTimeOut(Signal_t *signal);
void zd_SendTAsocMsg(void)
{
        AsocTimeOut(NULL);
        return;
}


void zd_SwitchNextCH(void)
{
        void *reg = pdot11Obj->reg;
        static u8 LastScanMacMode;
        static u8 ScanAround = 0;
        //static u8 ScanWait = 0;
        static u8 initMAC_Mode = 0xff;

        if(initMAC_Mode == 0xff)
                initMAC_Mode = mMacMode;
        //FPRINT("zd_SwitchNextCH");

        if ((PURE_A_MODE != mMacMode && CurrScanCH > MAX_CHANNEL_ALLOW) ||
                        (PURE_A_MODE == mMacMode && CurrScanCH > dot11A_Channel_Amount - 1)
                        //In 11a, channel array index 0 is also meaningful.
           ) { //Scan Finish...
#ifdef HMAC_DEBUG
                U8 i, j;
                U16 cap;
#endif

                if (mBssType == AP_BSS)
                        pdot11Obj->SetReg(reg, ZD_Rx_Filter, AP_RX_FILTER);
                else
                        pdot11Obj->SetReg(reg, ZD_Rx_Filter, STA_RX_FILTER);

                if (pdot11Obj->ConfigFlag & PASSIVE_CHANNEL_SCAN_SET)
                        pdot11Obj->ConfigFlag &= ~PASSIVE_CHANNEL_SCAN_SET;

                if (pdot11Obj->ConfigFlag & IBSS_CHANNEL_SCAN_SET) {
                        pdot11Obj->ConfigFlag &= ~IBSS_CHANNEL_SCAN_SET;
                        //mRequestFlag |= IBSS_CONNECT_SET;
                }

                CurrScanCH = 1;
                pdot11Obj->bChScanning = 0;
                ScanAround=0;

                if (pdot11Obj->ConfigFlag & ACTIVE_CHANNEL_SCAN_SET) {
#ifdef HMAC_DEBUG
                        printk("\nSSID          BSSID            CH  Signal  Mode     Basic-Rates  Ext-Rates    b/g AP");
                        printk("\n------------------------------------------------------------------------------------");
                        for (i=0; i<mBssNum; i++) {
                                printk("\n");
                                for (j=0; j<mBssInfo[i].ssid.buf[1]; j++) {
                                        printk("%c", mBssInfo[i].ssid.buf[2+j]);
                                }

                                for (j=mBssInfo[i].ssid.buf[1]; j<12; j++) {
                                        printk(" ");
                                }

                                printk("%02x:%02x:%02x:%02x:%02x:%02x",
                                       mBssInfo[i].bssid.mac[0], mBssInfo[i].bssid.mac[1], mBssInfo[i].bssid.mac[2],
                                       mBssInfo[i].bssid.mac[3], mBssInfo[i].bssid.mac[4], mBssInfo[i].bssid.mac[5]);

                                printk("  %2d", mBssInfo[i].Phpm.buf[2]);
                                printk("   %2d", mBssInfo[i].signalStrength);

                                cap = mBssInfo[i].cap;
                                cap &= (CAP_PRIVACY | CAP_IBSS | CAP_ESS);

                                switch(cap) {
                                case 0x01:
                                        printk("   Infra   ");
                                        break;
                                case 0x02:
                                        printk("   Ad_Hoc  ");
                                        break;
                                case 0x11:
                                        printk("   Infra, W");
                                        break;
                                case 0x12:
                                        printk("   Ad_Hoc,W");
                                        break;
                                default :
                                        break;
                                }

                                printk("  ");

                                for (j=0; j<mBssInfo[i].supRates.buf[1]; j++) {
                                        printk(" %x", mBssInfo[i].supRates.buf[2+j]);
                                }

                                printk("  ");
                                for (j=0; j<mBssInfo[i].extRates.buf[1]; j++) {
                                        printk(" %x", mBssInfo[i].extRates.buf[2+j]);
                                }

                                if (mBssInfo[i].apMode == PURE_B_AP)
                                        printk("   B-AP");
                                else if (mBssInfo[i].apMode == PURE_G_AP)
                                        printk("   G-AP");
                                else if  (mBssInfo[i].apMode == MIXED_AP)
                                        printk("   M-AP");
                        }
                        else if (mBssInfo[i].apMode == PURE_A_AP)
                                printk("   A_AP");
                        else
                                VerAssert();


                        printk("\n");

                        FPRINT("****** Scan Finished ******");
#endif

                        pdot11Obj->ConfigFlag &= ~ACTIVE_CHANNEL_SCAN_SET;
                        mBssCnt = mBssNum;
                }//End of ACTIVE_CHANNEL_SCAN_SET

                if (pdot11Obj->ConfigFlag & JUST_CHANNEL_SCAN) {
                        pdot11Obj->ConfigFlag &= ~JUST_CHANNEL_SCAN;

                        if (mAssoc)
                                HW_SetRfChannel(pdot11Obj, mRfChannel, 1, initMAC_Mode);
                } else {
                        if (mBssType == INFRASTRUCTURE_BSS)
                                zd_ChooseAP(0);
                        else if (mBssType == INDEPENDENT_BSS)
                                zd_IbssConnect();
                }

                if (pdot11Obj->ConfigFlag & SCAN_AND_CONNECT_SET) {
                        pdot11Obj->ConfigFlag &= ~SCAN_AND_CONNECT_SET;
                }
                initMAC_Mode = 0xff;
                return;
        }//End of (CurrentScannedChannel > MAX_CHANNEL_ALLOW)

        CurrScanCH++;
        if(mMacMode != PURE_A_MODE && CurrScanCH <= MAX_CHANNEL_ALLOW + 1) {
                //printk("HW_SetRfChannel:%s(%d)\n",__FILE__,__LINE__);
                HW_SetRfChannel(pdot11Obj, CurrScanCH, 1,mMacMode);
                LastScanMacMode = mMacMode;
        } else if(mMacMode == PURE_A_MODE && CurrScanCH<=dot11A_Channel_Amount) {
                //printk("HW_SetRfChannel:%s(%d)\n",__FILE__,__LINE__);
                HW_SetRfChannel(pdot11Obj, dot11A_Channel[CurrScanCH-1],1, mMacMode);
                LastScanMacMode = mMacMode;
        }
        if(PURE_A_MODE != LastScanMacMode && CurrScanCH > MAX_CHANNEL_ALLOW && ScanAround <1) {
                if(pdot11Obj->rfMode == AL7230B_RF) {
                        mMacMode = PURE_A_MODE;
                        CurrScanCH = 1;
                        ChangeMacMode(PURE_A_MODE,dot11A_Channel[CurrScanCH-1]);
                        pdot11Obj->DelayUs(1000);
                        HW_SetRfChannel(pdot11Obj, dot11A_Channel[CurrScanCH-1],0,mMacMode);
                        ScanAround ++;
                }


        } else if(ScanAround < 1 &&PURE_A_MODE == LastScanMacMode && CurrScanCH > dot11A_Channel_Amount - 1) {
                ScanAround ++;
                CurrScanCH = 1;
                mMacMode = MIXED_MODE;
                ChangeMacMode(MIXED_MODE, CurrScanCH);
                pdot11Obj->DelayUs(1000);
                HW_SetRfChannel(pdot11Obj, CurrScanCH, 0,mMacMode);
        }


        //for debug
        //pdot11Obj->SetReg(reg, ZD_USB_DEBUG_PORT, 0x22222222);

        if  (pdot11Obj->ConfigFlag & PASSIVE_CHANNEL_SCAN_SET)
                pdot11Obj->StartTimer(SCAN_TIMEOUT, DO_SCAN);

        if (pdot11Obj->ConfigFlag & ACTIVE_CHANNEL_SCAN_SET)
                zd_ProbeReq();

        return;
}

void zd_UpdateCurrTxRate(U8 rate, U16 aid)
{
        Hash_t *pHash;
        if (mBssType == INFRASTRUCTURE_BSS) {
                pHash = sstByAid[0];
                pHash->CurrTxRate = rate;
        } else {
                if (aid) {
                        pHash = sstByAid[aid];
#if !defined(OFDM)

                        pHash->CurrTxRate = rate;
#else

                        if (rate < pHash->CurrTxRate) { //Retry Failed happened
                                pHash->FailedFrames++;
                                //FPRINT_V("FailedFrames", pHash->FailedFrames);
                        }
#endif

                }
        }
}

void zd_EnableProtection(U8 protect)
{
        U32 tmpValue;
        void *reg = pdot11Obj->reg;

        if (protect) {
                //FPRINT("zd_EnableProtection");
                pdot11Obj->ConfigFlag |= ENABLE_PROTECTION_SET;
                mErp.buf[2] |= USE_PROTECTION;
                tmpValue = pdot11Obj->GetReg(reg, ZD_RTS_CTS_Rate);
                tmpValue &= ~CTS_MOD_TY