zdhci.c

ZYDAS zd1211b driver for Linux2.4

        /* Set CAM_MODE to AP Mode */
        pdot11Obj->SetReg(reg, ZD_CAM_MODE, CAM_AP);

        ConfigBcnFIFO();
        HW_EnableBeacon(pdot11Obj, mBeaconPeriod, mDtimPeriod, AP_BSS);
        HW_RadioOnOff(pdot11Obj, mRadioOn);
        return TRUE;
}

BOOLEAN zd_ProbeReq(void)
{
        Signal_t *signal;
        //FPRINT("zd_ProbeReq");

        if ((signal = allocSignal()) == NULL) {
                return FALSE;
        }
        signal->vapId=0;
        signal->id = SIG_PROBE_REQ;
        signal->block = BLOCK_SYNCH;
        sigEnque(pMgtQ, (signal));
        zd_SigProcess();

        return TRUE;
}
BOOLEAN zd_ScanReq(void)
{
        Signal_t *signal;
        if ((signal = allocSignal()) == NULL) {
                return FALSE;
        }
        signal->vapId=0x12; //This member is not used in zd1211, we can use it to carry additional information, 0x1234 indicates we don't want to start a scantimer after sending a Probe Request frame.

        signal->id = SIG_PROBE_REQ;
        signal->block = BLOCK_SYNCH;
        sigEnque(pMgtQ, (signal));
        zd_SigProcess();
        return TRUE;
}
#if 0
void zd_ScanEnd()
{
        void *reg=pdot11Obj->reg;
        if (mBssType == AP_BSS)
                pdot11Obj->SetReg(reg, ZD_Rx_Filter, AP_RX_FILTER);
        else
                pdot11Obj->SetReg(reg, ZD_Rx_Filter, STA_RX_FILTER);
        if (mAssoc) {
                //		printk("HW_SetRfChannel:%s(%d)\n",__FILE__,__LINE__);
                HW_SetRfChannel(pdot11Obj, mRfChannel, 1,mMacMode);
        }

        mBssCnt=mBssNum;
        pdot11Obj->ConfigFlag &= ((~ACTIVE_CHANNEL_SCAN_SET) & (~JUST_CHANNEL_SCAN));
}
void zd_ScanBegin(void)
{
        void *reg=pdot11Obj->reg;
        mBssNum=0;
        pdot11Obj->ConfigFlag |= (ACTIVE_CHANNEL_SCAN_SET | JUST_CHANNEL_SCAN);
        pdot11Obj->SetReg(reg, ZD_Rx_Filter, (BIT_5|BIT_8));
}
void zd_CmdScanReq(u16 channel)
{
        if(mMacMode != PURE_A_MODE) {
                //		printk("HW_SetRfChannel:%s(%d)\n",__FILE__,__LINE__);
                HW_SetRfChannel(pdot11Obj, channel, 1,mMacMode);
        } else {
                //		printk("HW_SetRfChannel:%s(%d)\n",__FILE__,__LINE__);
                HW_SetRfChannel(pdot11Obj,dot11A_Channel[channel-1],1 ,mMacMode);
        }


        zd_ScanReq();
        return;

}
#endif
BOOLEAN zd_CmdProbeReq(U8 bWithSSID)
{
        void *reg = pdot11Obj->reg;

        //FPRINT("zd_CmdProbeReq");
        if (pdot11Obj->bChScanning) {
                FPRINT("Channel is under scanning....");

                if (mRequestFlag & CHANNEL_SCAN_SET)
                        mRequestFlag &= ~CHANNEL_SCAN_SET;
                return FALSE;
        }
        pdot11Obj->bChScanning=1;

        pdot11Obj->SetReg(reg, ZD_Rx_Filter, (BIT_5|BIT_8)); //only accept beacon and ProbeRsp frame
        pdot11Obj->ConfigFlag |= ACTIVE_CHANNEL_SCAN_SET;

        mBssNum = 0;
        if(mMacMode != PURE_A_MODE) {
                //		printk("HW_SetRfChannel:%s(%d)\n",__FILE__,__LINE__);
                HW_SetRfChannel(pdot11Obj, CurrScanCH, 1,mMacMode);
        } else  {
                //		printk("HW_SetRfChannel:%s(%d)\n",__FILE__,__LINE__);
                HW_SetRfChannel(pdot11Obj, dot11A_Channel[CurrScanCH-1], 1,mMacMode);
        }

        zd_ProbeReq();

        if (mRequestFlag & CHANNEL_SCAN_SET)
                mRequestFlag &= ~CHANNEL_SCAN_SET;

        //pdot11Obj->bChScanning = 1;
        return TRUE;
}

BOOLEAN zd_StartSTA(BOOLEAN bEnable)
{
        void *reg = pdot11Obj->reg;
        //FPRINT("zd_StartSTA");
        HW_SetSupportedRate(pdot11Obj, (U8 *)&mBrates);
        HW_RadioOnOff(pdot11Obj, mRadioOn);


        if (mBssType == INFRASTRUCTURE_BSS)
                pdot11Obj->SetReg(reg, ZD_CAM_MODE, CAM_STA);
        else
                pdot11Obj->SetReg(reg, ZD_CAM_MODE, CAM_IBSS);
        if (mBssType == PSEUDO_IBSS) {
                zd_PseudoIbssConnect();
        } else {
                //if (!bEnable)
                {
                        pdot11Obj->ConfigFlag |= SCAN_AND_CONNECT_SET;
                        mRequestFlag |= CHANNEL_SCAN_SET;
                }
        }

        return TRUE;
}

BOOLEAN zd_CmdDisasoc(MacAddr_t *sta, U8 rCode)
{
        Signal_t *signal;
        //FPRINT("zd_CmdDisasoc");

        //if (isGroup(sta))
        //	return FALSE;

        if ((signal = allocSignal()) == NULL)
                return FALSE;

        signal->id = SIG_DIASSOC_REQ;
        signal->block = BLOCK_ASOC;
        if (mBssType == INFRASTRUCTURE_BSS) {
                memcpy(&signal->frmInfo.Sta, (U8 *)&mBssId, 6);
        } else {
                memcpy(&signal->frmInfo.Sta, sta, 6);
        }
        signal->frmInfo.rCode = (ReasonCode)rCode;
        sigEnque(pMgtQ, (signal));

        return TRUE;
}

BOOLEAN zd_CmdDeauth(MacAddr_t *sta, U8 rCode)
{
        Signal_t *signal;

        if ((signal = allocSignal()) == NULL)
                return FALSE;

        signal->id = SIG_DEAUTH_REQ;
        signal->block = BLOCK_AUTH_REQ;
        memcpy(&signal->frmInfo.Sta, sta, 6);
        signal->frmInfo.rCode = (ReasonCode)rCode;
        sigEnque(pMgtQ, (signal));

        return TRUE;
}

BOOLEAN zd_PassiveScan(void)
{
        void *reg = pdot11Obj->reg;

        //FPRINT("zd_PassiveScan");

        if (pdot11Obj->ConfigFlag & PASSIVE_CHANNEL_SCAN_SET)
                return FALSE;

        pdot11Obj->ConfigFlag |= PASSIVE_CHANNEL_SCAN_SET;
        pdot11Obj->SetReg(reg, ZD_Rx_Filter, 0x100); //only accept beacon frame
        if(mMacMode != PURE_A_MODE) {
                //		printk("HW_SetRfChannel:%s(%d)\n",__FILE__,__LINE__);
                HW_SetRfChannel(pdot11Obj, CurrScanCH, 1,mMacMode);
        } else {
                //		printk("HW_SetRfChannel:%s(%d)\n",__FILE__,__LINE__);
                HW_SetRfChannel(pdot11Obj,dot11A_Channel[CurrScanCH-1],1 ,mMacMode);
        }

        pdot11Obj->StartTimer(SCAN_TIMEOUT, DO_SCAN);

        return TRUE;
}

BOOLEAN zd_DisasocAll(U8 rCode)
{
        int i;
        MacAddr_t *sta;
        if (mBssType == AP_BSS) {
                for (i=1; i<(MAX_AID+1); i++) {
                        if (sstByAid[i]->asoc == STATION_STATE_ASOC) {
                                sta = (MacAddr_t *)&sstByAid[i]->mac[0];
                                zd_CmdDisasoc(sta, rCode);
                        }
                }

                FlushQ(pTxQ);
        } else if (mBssType == INFRASTRUCTURE_BSS) {
                if (mAssoc)
                        zd_CmdDisasoc(&mBssId, rCode);
        }
        return TRUE;

}

BOOLEAN zd_ChooseAP(BOOLEAN bUseBssid)
{
        U8 i;
        U16 cap;
        U16 quality = 10000;
        BOOLEAN found = FALSE;

        mBssIndex = 0xff;
        for (i=0; i<mBssCnt; i++) {
                if (bUseBssid) {
                        if (memcmp(&dot11DesiredBssid, &mBssInfo[i].bssid.mac[0], ETH_ALEN) == 0 && memcmp(&dot11DesiredBssid, zeroMacAddress, ETH_ALEN)!=0) {
                                //ZD1211DEBUG(0, "zd_ChooseAP: Bssid" MACSTR "matched to index:%d\n",MAC2STR(dot11DesiredBssid), i);
                                mBssIndex = i;
                                break;
                        }
                }

                cap = mBssInfo[i].cap;
                if ((memcmp(&dot11DesiredSsid, &mBssInfo[i].ssid, dot11DesiredSsid.buf[1]+2) == 0)
                                || (!mProbeWithSsid) ) {

                        if(1)
                                ;
                        else if ((mMacMode == PURE_B_MODE) && (mBssInfo[i].apMode == PURE_G_AP))
                                continue;
                        else if ((mMacMode == PURE_B_MODE) && (mBssInfo[i].apMode == PURE_A_AP))
                                continue;
                        else if ((mMacMode == PURE_G_MODE) && (mBssInfo[i].apMode == PURE_B_AP))
                                continue;
                        else if ((mMacMode == PURE_G_MODE) && (mBssInfo[i].apMode == PURE_A_AP))
                                continue;

                        else if ((mMacMode == PURE_A_MODE) && (mBssInfo[i].apMode != PURE_A_AP))
                                continue;

                        else if ((mMacMode == MIXED_MODE) && (mBssInfo[i].apMode == PURE_A_AP))
                                continue;

                        //check capability ...
                        if (cap & CAP_PRIVACY) {
                                if (!mPrivacyInvoked)
                                        continue;
                        } else {
                                if (mPrivacyInvoked)
                                        continue;
                        }
                        if (!pdot11Obj->IsUSB2_0) { //host is usb 1.1
                                if (mBssInfo[i].apMode == PURE_G_AP)
                                        continue;
                        }

                        if (cap & CAP_ESS) {
                                if (mBssInfo[i].signalQuality < quality ) {
                                        quality = mBssInfo[i].signalQuality;
                                        mBssIndex = i;
                                        //FPRINT_V("cap", cap);
                                }
                        }

                        //break;
                }
        }
        if (mBssIndex< mBssCnt) {
                found = TRUE;
                //FPRINT_V("Desired AP Found, Bss Index", mBssIndex);
                if (pdot11Obj->ConfigFlag & SCAN_AND_CONNECT_SET) {
                        //printk("zd_ChooseAP: set mRequestFlag.BSS_CONNECT_SET\n");
                        mRequestFlag |= BSS_CONNECT_SET;
                        pdot11Obj->ConfigFlag &= ~SCAN_AND_CONNECT_SET;
                }
        } else {
                //printk(" \n");
                //printk(KERN_ERR "****** Can't find desiredSSID:");
                //for (i=0; i<dot11DesiredSsid.buf[1]; i++) {
                //	printk("%c", dot11DesiredSsid.buf[2+i]);
                //}
                //printk(" \n");
        }
        //	int j;
        //	if(0xff != mBssIndex) {
        //		for(j=0;j<mBssInfo[mBssIndex].ssid.buf[1];j++)
        //			printk("%c",mBssInfo[mBssIndex].ssid.buf[2+j]);
        //		printk("  ChooseAP(Mac=%d,Ch:%d)\n",mBssInfo[mBssIndex].apMode,mBssInfo[mBssIndex].Phpm.buf[2]);
        //	}

        return found;
}
BOOLEAN zd_InfraConnect(U8 index)
{
        Signal_t *signal;
        struct zd1205_private *macp = (struct zd1205_private *)g_dev->priv;

        MacAddr_t *pBssid;
        Element *pSsid = NULL;
        U32 tmpvalue;
        BOOLEAN	bChooseAPResult;
        void *reg = pdot11Obj->reg;
        //FPRINT("zd_InfraConnect");
        if (mBssNum == 0)
                return FALSE;

        if ((signal = allocSignal()) == NULL)
                return FALSE;
        if(mCounterMeasureState) {
                mRequestFlag &= ~BSS_CONNECT_SET;
                return FALSE;
        }
        // look up global scan result table according to desired ssid,
        // because mBssInfo order may be different from macp->BSSInfo[].
        /*if (mBssCnt)
        {
            U8	ssidLength;
            for(i=0; i<mBssCnt; i++)
            {
                ssidLength=dot11DesiredSsid.buf[1]+2;
        	if (mBssInfo[i].cap & CAP_ESS)
        	{
        	    if (memcmp((U8*)&dot11DesiredSsid,(U8*)&mBssInfo[i].ssid,ssidLength)==0)
        	    {
        		break;
        	    }
        	}
            }		
        } */
        // Use zd_ChooseAP instead of above code