zdasocsvc.c

ZYDAS zd1211b driver for Linux2.4

                                                mCurrConnUser++;
                                                if (bErpSta == FALSE) {
                                                        printk(KERN_DEBUG "Increment mNumBOnlySta\n");
                                                        mNumBOnlySta++;
                                                }
                                        }
                                }

                                asStatus = SC_SUCCESSFUL;
                                if (signal->id == SIG_REASSOC)
                                        notifyStatus1 = STA_REASSOCIATED;
                                pdot11Obj->StatusNotify(notifyStatus1, (U8 *)&Sta);

                                if (mMacMode != PURE_B_MODE && mMacMode != PURE_A_MODE) {
                                        if (pdot11Obj->ConfigFlag & NON_ERP_PRESENT_SET) {
                                                U32 tmpValue;
                                                void *reg = pdot11Obj->reg;

                                                // force enabled protection mode for debug
                                                mErp.buf[2] |= (NON_ERP_PRESENT | USE_PROTECTION);
                                                tmpValue = pdot11Obj->GetReg(reg, ZD_RTS_CTS_Rate);
                                                tmpValue &= ~CTS_MOD_TYPE_OFDM;
                                                tmpValue |= CTS_RATE_11M;
                                                pdot11Obj->SetReg(reg, ZD_RTS_CTS_Rate, tmpValue);

                                                if (Preamble == 0) { //long preamble
                                                        mErp.buf[2] |= BARKER_PREAMBLE;
                                                        tmpValue = pdot11Obj->GetReg(reg, ZD_RTS_CTS_Rate);
                                                        tmpValue &= ~NON_BARKER_PMB_SET;
                                                        tmpValue |= CTS_RATE_11M;
                                                        pdot11Obj->SetReg(reg, ZD_RTS_CTS_Rate, tmpValue);
                                                        //FPRINT("Enable Barker Preamble");
                                                }
                                                pdot11Obj->ConfigFlag |= ENABLE_PROTECTION_SET;
                                                //FPRINT("Enable Protection Mode");
                                        }
                                }

                        }
                } else {
                        //wpa_check_failed:
                        asStatus = SC_UNSPEC_FAILURE;
                }
wpa_check_failed:

                aid |= 0xC000;
                if (aid != 0xC000) {
                        FPRINT_V("Aid", aid);
                        FPRINT_V("MaxRate", MaxRate);
                }

check_failed:
                if (signal->id == SIG_REASSOC)
                        type = ST_REASOC_RSP;
                mkRe_AsocRspFrm(pfrmDesc, type, &Sta, mCap, asStatus, aid, &mBrates, pExtRate, vapId);
                sendMgtFrame(signal, pfrmDesc);

                return FALSE;
        } else {
                freeFdesc(pfrmDesc);
                return TRUE;
        }
}

BOOLEAN Re_AsocReq(Signal_t *signal)
{
        FrmDesc_t *pfrmDesc;
        U8 vapId = 0;
        TypeSubtype subType = ST_ASOC_REQ;
        Element *pExtRate = NULL;

        FPRINT("Re_AsocReq");
        if (memcmp(zeroMacAddress, (u8*)&mBssId, 6)==0) {
                sigEnque(pMgtQ, (signal));
                return FALSE;
        }

        pfrmDesc = allocFdesc();
        if(!pfrmDesc) {
                sigEnque(pMgtQ, (signal));
                return FALSE;
        }


        if (signal->id == SIG_REASSOC_REQ) {
                subType = ST_REASOC_REQ;
        }

        pExtRate = &mExtRates;

        memcpy((U8 *)&AsSta, (U8 *)&mBssId, 6);

        mkRe_AsocReqFrm(pfrmDesc, subType, &mBssId, mCap, mListenInterval,
                        &mOldAP, &mSsid, &mBrates, pExtRate, &mWPAIe, vapId);

        pdot11Obj->StartTimer(ASOC_TIMEOUT, DO_ASOC);
        AsocState = STE_WAIT_ASOC_RSP;
        return sendMgtFrame(signal, pfrmDesc);
}

BOOLEAN Re_AsocRsp(Signal_t *signal)
{
        Hash_t	*pHash;
        FrmDesc_t *pfrmDesc;
        Frame_t *rdu;
        U8 vapId = 0;
        MacAddr_t Sta;
        U16 status;

        //ZDEBUG("Re_AsocRsp");
        FPRINT("Re_AsocRsp");

        pfrmDesc = signal->frmInfo.frmDesc;
        rdu = pfrmDesc->mpdu;

        memcpy((U8 *)&Sta, (U8 *)addr2(rdu), 6);
        if (memcmp(&AsSta, &Sta, 6) != 0) {
                //FPRINT("Not for my Assoc AP");
                goto asoc_release;
        }

        pdot11Obj->StopTimer(DO_ASOC);
        AsocState = STE_ASOC_IDLE;


        status = status(rdu);
        if (status == SC_SUCCESSFUL) {
                U8	Len;
                U8	tmpMaxRate = 0x02;
                U8	ZydasMode = 0;
                U8	Preamble = 0;
                U8	MaxRate;
                BOOLEAN bErpSta = FALSE;
                int i;
                U8	HigestBasicRate = 0;

                UpdateStaStatus(&Sta, STATION_STATE_ASOC, vapId);
                pHash = HashSearch(&Sta);
                if (pHash != NULL) {
                        if (!pHash->AlreadyIn) {
                                pHash->AlreadyIn=1;
                                mCurrConnUser++;
                        }
                }

                mAPCap = cap(rdu);

                //check capability
                if (mAPCap & CAP_SHORT_PREAMBLE) {
                        Preamble = 1;
                } else {
                        Preamble = 0;
                }

                mAid = (aid(rdu) & 0x3FFF);
                getElem(rdu, EID_SUPRATES, &mAPBrates);
                //zd1205_dump_data("mAPBrates", &mAPBrates.buf[2], mAPBrates.buf[1]);

                if (getElem(rdu, EID_EXT_RATES, &mAPErates)) {
                        //zd1205_dump_data("mAPErates", &mAPErates.buf[2], mAPErates.buf[1]);
                }

                memcpy((U8 *)&mBssId, (U8 *)addr2(rdu), 6);
                mAssoc = TRUE;

                //update supported rates
                HW_SetSupportedRate(pdot11Obj, (U8 *)&mAPBrates);
                HW_SetSupportedRate(pdot11Obj, (U8 *)&mAPErates);

                Len = eLen(&mAPBrates);
                for (i=0; i<Len; i++) {
                        if ((mAPBrates.buf[2+i] & 0x7f) > tmpMaxRate ) {
                                tmpMaxRate = (mAPBrates.buf[2+i] & 0x7f);
                                if (mAPBrates.buf[2+i] & 0x80)
                                        HigestBasicRate = mAPBrates.buf[2+i];
                        }

                        if (((mAPBrates.buf[2+i] & 0x7f) == 0x21) && (!(mAPCap & CAP_PBCC_ENABLE))) { //Zydas 16.5M
                                ZydasMode = 1;
                        }
                }


                Len = eLen(&mAPErates);
                for (i=0; i<Len; i++) {
                        if ((mAPErates.buf[2+i] & 0x7f) > tmpMaxRate ) {
                                tmpMaxRate = (mAPErates.buf[2+i] & 0x7f);
                                if (mAPErates.buf[2+i] & 0x80)
                                        HigestBasicRate = mAPErates.buf[2+i];
                        }
                }

                //FPRINT_V("tmpMaxRate", tmpMaxRate);
                //FPRINT_V("mMaxTxRate", mMaxTxRate);
                MaxRate = RateConvert((tmpMaxRate & 0x7f));
                //FPRINT_V("MaxRate", MaxRate);
                if (MaxRate > mMaxTxRate)
                        MaxRate = mMaxTxRate;
                memset(mAPBrates.buf, 0, sizeof(Element));
                memset(mAPErates.buf, 0, sizeof(Element));
                AssocInfoUpdate(&mBssId, MaxRate, mAid, ZydasMode, Preamble, bErpSta, vapId);

                pdot11Obj->StatusNotify(STA_ASSOCIATED, (U8 *)&mBssId);
                pdot11Obj->Aid = mAid;
                mConnRetryCnt = 0;

                FPRINT_V("Aid", mAid);
                FPRINT_V("MaxRate", MaxRate);
        } else {
                FPRINT("Asoc Failed!!!");
                FPRINT_V("Status Code", status);
        }

asoc_release:
        freeFdesc(pfrmDesc);
        return TRUE;
}


BOOLEAN AsocTimeOut(Signal_t *signal)
{
        U8 vapId = 0;
        FPRINT("AsocTimeOut");

        if (AsocState == STE_WAIT_ASOC_RSP) {
                AsocState = STE_ASOC_IDLE;
                UpdateStaStatus(&mBssId, STATION_STATE_DIS_ASOC, vapId);
        }

        mRequestFlag |= CONNECT_TOUT_SET;
        return FALSE;
}


BOOLEAN AsocEntry(Signal_t *signal)
{
        FrmDesc_t *pfrmDesc;

        if (AsocState == STE_ASOC_IDLE) {
                switch(signal->id) {
                case SIG_DIASSOC_REQ:
                        return DisasocReq(signal);

                case SIG_DISASSOC:
                        return Disasoc(signal);

                case SIG_ASSOC:
                case SIG_REASSOC:
                        return Re_Asociate(signal);

                case SIG_ASSOC_REQ:
                case SIG_REASSOC_REQ:
                        return Re_AsocReq(signal);

                default:
                        goto asoc_discard;
                }
        } else if (AsocState == STE_WAIT_ASOC_RSP) {
                switch(signal->id) {
                case SIG_DIASSOC_REQ:
                        return DisasocReq(signal);

                case SIG_DISASSOC:
                        return Disasoc(signal);

                case SIG_ASSOC:
                case SIG_REASSOC:
                        return Re_Asociate(signal);

                case SIG_ASSOC_REQ:
                case SIG_REASSOC_REQ:
                        return Re_AsocReq(signal);

                case SIG_ASSOC_RSP:
                case SIG_REASSOC_RSP:
                        return Re_AsocRsp(signal);

                case SIG_TO_ASOC:

                        return AsocTimeOut(signal);

                default:
                        goto asoc_discard;
                }
        } else
                goto asoc_discard;

asoc_discard:
        pfrmDesc = signal->frmInfo.frmDesc;
        freeFdesc(pfrmDesc);
        return TRUE;
}

#endif