zd1205.c

ZYDAS zd1211b driver for Linux2.4

        u32   tmpvalue;


        tmpvalue = zd_readl(rLED_CTRL);
        tmpvalue &= ~LEDn;
        zd_writel(tmpvalue, rLED_CTRL);


#ifdef ROBIN_KAO

        zd_writel(0x0, FW_LINK_STATUS);
#endif

#endif
}


void iLED_SWITCH(struct zd1205_private *macp, u32 LEDn)
{
#if !fDISABLE_LED
        u32   tmpvalue;

        tmpvalue = zd_readl(rLED_CTRL);
        tmpvalue ^= LEDn;
        zd_writel(tmpvalue, rLED_CTRL);
#endif
}

#else
void iLED_ON(struct zd1205_private	*macp, u32 LEDn)
{
        zd_writel(0x1, LEDn);
}





void iLED_OFF(struct zd1205_private *macp, u32 LEDn)
{
        zd_writel(0x0, LEDn);
}


void iLED_SWITCH(struct zd1205_private	*macp, u32 LEDn)
{
        u32   tmpvalue;

        tmpvalue = zd_readl(LEDn);
        tmpvalue ^= 0x1;
        zd_writel(tmpvalue, LEDn);

}
#endif


void zd1205_disable_int(void)
{

        /* Disable interrupts on our PCI board by setting the mask bit */
        zd_writel(0, InterruptCtrl);
}




void zd1205_enable_int(void)
{
        struct zd1205_private *macp = g_dev->priv;

        zd_writel(macp->intrMask, InterruptCtrl);
}


void zd1205_start_download(u32 phyAddr)
{
#ifdef HOST_IF_USB
        return;
#endif

        if (!dot11Obj.bDeviceInSleep)
                zd_writel(phyAddr, ZD_PCI_TxAddr_p1);
}


void zd1205_start_upload(u32 phyAddr)
{
#ifdef HOST_IF_USB

        return;
#endif


        if (!dot11Obj.bDeviceInSleep) {
                zd_writel(phyAddr, ZD_PCI_RxAddr_p1);


                zd_writel(0, ZD_PCI_RxAddr_p2);

        }
}


int zd1205_DestPowerSave(struct zd1205_private *macp, u8 *pDestAddr)

{
        u32	tmpvalue;

        if ((macp->cardSetting.ATIMWindow != 0) && (macp->bAssoc))
        {
                // We must make sure that Device has been in IBSS mode and PwrMgt mode.
                tmpvalue = zd_readl(ZD_BCNInterval);
                if ((tmpvalue & IBSS_MODE) && (tmpvalue & POWER_MNT)) {


                        // ATIM could be sent only when BCNController is active.
                        if ((*(pDestAddr) & BIT_0) || (macp->bIBSS_Wakeup_Dest)) { // We should issue ATIM for multicast frame.
                                macp->bIBSS_Wakeup_Dest = 0;
                                return 1;
                        }
                }
        }


        return 0;
}



static void zd1205_action(unsigned long parm)
{
        zd_SigProcess();  //process management frame queue in mgtQ
}


static void zd1205_ps_action(unsigned long parm)
{
        zd_CleanupAwakeQ();
}


static void zd1205_tx_action(unsigned long parm)
{
        zd_CleanupTxQ();

}

#ifndef HOST_IF_USB
u8 zd1205_RateAdaption(u16 aid, u8 CurrentRate, u8 gear)
{

        u8	NewRate;


        RATEDEBUG("***** zd1205_RateAdaption");
        RATEDEBUG_V("aid", aid);


        RATEDEBUG_V("CurrentRate", CurrentRate);

        if (gear == FALL_RATE) {


                if (CurrentRate >= RATE_2M) {
                        NewRate = CurrentRate - 1;
                        zd_EventNotify(EVENT_UPDATE_TX_RATE, (U32)NewRate, (U32)aid, 0);
                } else {
                        NewRate = CurrentRate;
                }
                return (NewRate);
        }

        return 0;
}
#endif

void zd1205_ClearTupleCache(struct zd1205_private *macp)
{
        int i;
        tuple_Cache_t *pCache = &macp->cache;

        pCache->freeTpi = 0;
        for (i=0; i<TUPLE_CACHE_SIZE; i++)
        {
                pCache->cache[i].full = 0;
        }
}


u8 zd1205_SearchTupleCache(struct zd1205_private *macp, u8 *pAddr, u16 seq, u8 frag)
{
        int k;
        tuple_Cache_t *pCache = &macp->cache;

        for (k=0; k<TUPLE_CACHE_SIZE; k++)
        {
                if ((memcmp((char *)&pCache->cache[k].ta[0], (char *)pAddr, 6) == 0)
                                && (pCache->cache[k].sn == seq) && (pCache->cache[k].fn == frag)
                                && (pCache->cache[k].full))
                        return 1;
        }

        return 0;
}


void zd1205_UpdateTupleCache(struct zd1205_private *macp, u8 *pAddr, u16 seq ,u8 frag)
{
        int k;
        tuple_Cache_t *pCache = &macp->cache;

        for (k=0; k<TUPLE_CACHE_SIZE; k++)
        {
                if (pCache->cache[k].full) {
                        if ((memcmp((char *)&pCache->cache[k].ta[0], (char *)pAddr, 6) == 0)
                                        && (pCache->cache[k].sn == seq) ) {
                                pCache->cache[k].fn = frag;

                                return;
                        }
                }
        }

        pCache->freeTpi &= (TUPLE_CACHE_SIZE-1);
        memcpy(&pCache->cache[pCache->freeTpi].ta[0], (char *)pAddr, 6);
        pCache->cache[pCache->freeTpi].sn = seq;
        pCache->cache[pCache->freeTpi].fn = frag;
        pCache->cache[pCache->freeTpi].full = 1;

        pCache->freeTpi++;

}


void zd1205_ArReset(struct zd1205_private *macp)
{
        u8 i;
        defrag_Array_t *pArray = &macp->defragArray;

        for (i=0; i<MAX_DEFRAG_NUM; i++)
                pArray->mpdu[i].inUse = 0;
}


void zd1205_ArAge(struct zd1205_private *macp, u32 age)
{
        u8 i;
        defrag_Array_t *pArray = &macp->defragArray;

        for (i=0; i<MAX_DEFRAG_NUM; i++)
        {
                if (pArray->mpdu[i].inUse) {
                        if ((age - pArray->mpdu[i].eol) > MAX_RX_TIMEOUT) {
                                DFDEBUG("***** zd1205_ArAged");
                                macp->ArAgedCnt++;




                                dot11Obj.ReleaseBuffer(pArray->mpdu[i].buf);
                                pArray->mpdu[i].inUse = 0;
                        }
                }
        }
}




int	zd1205_ArFree(struct zd1205_private *macp)
{
        u8 i;
        defrag_Array_t *pArray = &macp->defragArray;

        for (i=0; i<MAX_DEFRAG_NUM; i++)
        {
                if (!pArray->mpdu[i].inUse)

                        return i;
        }

        macp->ArFreeFailCnt++;
        return -1;
}


int	zd1205_ArSearch(struct zd1205_private *macp, u8 *pAddr, u16 seq, u8 frag)
{
        u8 i;
        defrag_Array_t *pArray = &macp->defragArray;
        defrag_Mpdu_t *pDeMpdu;


        for (i=0; i<MAX_DEFRAG_NUM; i++)
        {
                pDeMpdu = &pArray->mpdu[i];
                if (pDeMpdu->inUse) {
                        if ((memcmp((char *)&pDeMpdu->ta[0], pAddr, 6) == 0)
                                        && (pDeMpdu->sn == seq)) {
                                if (pDeMpdu->fn == (frag-1)) {
                                        return i;
                                } else {
                                        dot11Obj.ReleaseBuffer(pDeMpdu->buf);
                                        pDeMpdu->inUse = 0;
                                        return -1;
                                }
                        }
                }
        }

        return -1;
}



void zd1205_ArUpdate(struct zd1205_private *macp, u8 *pAddr, u16 seq, u8 frag, int i)
{

        defrag_Array_t *pArray = &macp->defragArray;


        pArray->mpdu[i].inUse = 1;
        memcpy(&pArray->mpdu[i].ta[0], (char*)pAddr, 6);
        pArray->mpdu[i].sn = seq;
        pArray->mpdu[i].fn = frag;
        pArray->mpdu[i].eol = nowT();
}


void zd1205_IncreaseTxPower(struct zd1205_private *macp, u8 TxPwrType)
{
        u8   *pTxGain;

#if fTX_GAIN_OFDM

        if (TxPwrType != cTX_OFDM)
                pTxGain = &(dot11Obj.TxGainSetting);

        else
                pTxGain = &(dot11Obj.TxGainSetting2);
#else

        pTxGain = &(dot11Obj.TxGainSetting);
#endif

        switch(macp->RF_Mode)
        {
        case MAXIM_NEW_RF:
                if (*pTxGain < MAXIM2_MAX_TX_PWR_SET)

                        (*pTxGain)++;
                break;

        case RFMD_RF:
                if (*pTxGain < RFMD_MAX_TX_PWR_SET)
                        (*pTxGain) ++;
                break;

        case AL2230_RF:
        case AL2230S_RF:
        case AL7230B_RF:
                if (*pTxGain < AL2230_MAX_TX_PWR_SET)
                        (*pTxGain) += 2;
                break;

        default:
                break;
        }

        HW_Write_TxGain2(&dot11Obj, TxPwrType);
}


void zd1205_DecreaseTxPower(struct zd1205_private *macp, u8 TxPwrType)
{
        u8   *pTxGain;

#if fTX_GAIN_OFDM

        if (TxPwrType != cTX_OFDM)
                pTxGain = &(dot11Obj.TxGainSetting);
        else
                pTxGain = &(dot11Obj.TxGainSetting2);
#else

        pTxGain = &(dot11Obj.TxGainSetting);

#endif


        switch(macp->RF_Mode)
        {
        case MAXIM_NEW_RF:
                if (*pTxGain > MAXIM2_MIN_TX_PWR_SET)

                        (*pTxGain)--;
                break;

        case RFMD_RF:
                if (*pTxGain > RFMD_MIN_TX_PWR_SET)