[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / vt6656 / mib.c

/*
 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * File: mib.c
 *
 * Purpose: Implement MIB Data Structure
 *
 * Author: Tevin Chen
 *
 * Date: May 21, 1996
 *
 * Functions:
 *      STAvClearAllCounter - Clear All MIB Counter
 *      STAvUpdateIstStatCounter - Update ISR statistic counter
 *      STAvUpdateRDStatCounter - Update Rx statistic counter
 *      STAvUpdateRDStatCounterEx - Update Rx statistic counter and copy rcv data
 *      STAvUpdateTDStatCounter - Update Tx statistic counter
 *      STAvUpdateTDStatCounterEx - Update Tx statistic counter and copy tx data
 *      STAvUpdate802_11Counter - Update 802.11 mib counter
 *
 * Revision History:
 *
 */

#include "upc.h"
#include "mac.h"
#include "tether.h"
#include "mib.h"
#include "wctl.h"
#include "baseband.h"

/*---------------------  Static Definitions -------------------------*/
static int          msglevel                =MSG_LEVEL_INFO;
/*---------------------  Static Classes  ----------------------------*/

/*---------------------  Static Variables  --------------------------*/

/*---------------------  Static Functions  --------------------------*/

/*---------------------  Export Variables  --------------------------*/

/*---------------------  Export Functions  --------------------------*/


/*
 * Description: Clear All Statistic Counter
 *
 * Parameters:
 *  In:
 *      pStatistic  - Pointer to Statistic Counter Data Structure
 *  Out:
 *      none
 *
 * Return Value: none
 *
 */
void STAvClearAllCounter (PSStatCounter pStatistic)
{
    // set memory to zero
	memset(pStatistic, 0, sizeof(SStatCounter));
}


/*
 * Description: Update Isr Statistic Counter
 *
 * Parameters:
 *  In:
 *      pStatistic  - Pointer to Statistic Counter Data Structure
 *      wisr        - Interrupt status
 *  Out:
 *      none
 *
 * Return Value: none
 *
 */
void STAvUpdateIsrStatCounter (PSStatCounter pStatistic, BYTE byIsr0, BYTE byIsr1)
{
    /**********************/
    /* ABNORMAL interrupt */
    /**********************/
    // not any IMR bit invoke irq
    if (byIsr0 == 0) {
        pStatistic->ISRStat.dwIsrUnknown++;
        return;
    }


    if (byIsr0 & ISR_ACTX)              // ISR, bit0
        pStatistic->ISRStat.dwIsrTx0OK++;           // TXDMA0 successful

    if (byIsr0 & ISR_BNTX)              // ISR, bit2
        pStatistic->ISRStat.dwIsrBeaconTxOK++;      // BeaconTx successful

    if (byIsr0 & ISR_RXDMA0)            // ISR, bit3
        pStatistic->ISRStat.dwIsrRx0OK++;           // Rx0 successful

    if (byIsr0 & ISR_TBTT)              // ISR, bit4
        pStatistic->ISRStat.dwIsrTBTTInt++;         // TBTT successful

    if (byIsr0 & ISR_SOFTTIMER)         // ISR, bit6
        pStatistic->ISRStat.dwIsrSTIMERInt++;

    if (byIsr0 & ISR_WATCHDOG)          // ISR, bit7
        pStatistic->ISRStat.dwIsrWatchDog++;


    if (byIsr1 & ISR_FETALERR)              // ISR, bit8
        pStatistic->ISRStat.dwIsrUnrecoverableError++;

    if (byIsr1 & ISR_SOFTINT)               // ISR, bit9
        pStatistic->ISRStat.dwIsrSoftInterrupt++;       // software interrupt

    if (byIsr1 & ISR_MIBNEARFULL)           // ISR, bit10
        pStatistic->ISRStat.dwIsrMIBNearfull++;

    if (byIsr1 & ISR_RXNOBUF)               // ISR, bit11
        pStatistic->ISRStat.dwIsrRxNoBuf++;             // Rx No Buff

}


/*
 * Description: Update Rx Statistic Counter
 *
 * Parameters:
 *  In:
 *      pStatistic      - Pointer to Statistic Counter Data Structure
 *      byRSR           - Rx Status
 *      byNewRSR        - Rx Status
 *      pbyBuffer       - Rx Buffer
 *      cbFrameLength   - Rx Length
 *  Out:
 *      none
 *
 * Return Value: none
 *
 */
void STAvUpdateRDStatCounter(PSStatCounter pStatistic,
			     BYTE byRSR, BYTE byNewRSR,
			     BYTE byRxSts, BYTE byRxRate,
			     PBYTE pbyBuffer, unsigned int cbFrameLength)
{
	/* need change */
	PS802_11Header pHeader = (PS802_11Header)pbyBuffer;

	if (byRSR & RSR_ADDROK)
		pStatistic->dwRsrADDROk++;
	if (byRSR & RSR_CRCOK) {
		pStatistic->dwRsrCRCOk++;
		pStatistic->ullRsrOK++;

		if (cbFrameLength >= ETH_ALEN) {
			/* update counters in case of successful transmission */
            if (byRSR & RSR_ADDRBROAD) {
                pStatistic->ullRxBroadcastFrames++;
		pStatistic->ullRxBroadcastBytes +=
		  (unsigned long long) cbFrameLength;
            }
            else if (byRSR & RSR_ADDRMULTI) {
                pStatistic->ullRxMulticastFrames++;
		pStatistic->ullRxMulticastBytes +=
		  (unsigned long long) cbFrameLength;
            }
            else {
                pStatistic->ullRxDirectedFrames++;
		pStatistic->ullRxDirectedBytes +=
		  (unsigned long long) cbFrameLength;
            }
        }
    }

    if(byRxRate==22) {
        pStatistic->CustomStat.ullRsr11M++;
        if(byRSR & RSR_CRCOK) {
            pStatistic->CustomStat.ullRsr11MCRCOk++;
        }
	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "11M: ALL[%d], OK[%d]:[%02x]\n",
		(signed int) pStatistic->CustomStat.ullRsr11M,
		(signed int) pStatistic->CustomStat.ullRsr11MCRCOk, byRSR);
    }
    else if(byRxRate==11) {
        pStatistic->CustomStat.ullRsr5M++;
        if(byRSR & RSR_CRCOK) {
            pStatistic->CustomStat.ullRsr5MCRCOk++;
        }
	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " 5M: ALL[%d], OK[%d]:[%02x]\n",
		(signed int) pStatistic->CustomStat.ullRsr5M,
		(signed int) pStatistic->CustomStat.ullRsr5MCRCOk, byRSR);
    }
    else if(byRxRate==4) {
        pStatistic->CustomStat.ullRsr2M++;
        if(byRSR & RSR_CRCOK) {
            pStatistic->CustomStat.ullRsr2MCRCOk++;
        }
	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " 2M: ALL[%d], OK[%d]:[%02x]\n",
		(signed int) pStatistic->CustomStat.ullRsr2M,
		(signed int) pStatistic->CustomStat.ullRsr2MCRCOk, byRSR);
    }
    else if(byRxRate==2){
        pStatistic->CustomStat.ullRsr1M++;
        if(byRSR & RSR_CRCOK) {
            pStatistic->CustomStat.ullRsr1MCRCOk++;
        }
	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " 1M: ALL[%d], OK[%d]:[%02x]\n",
		(signed int) pStatistic->CustomStat.ullRsr1M,
		(signed int) pStatistic->CustomStat.ullRsr1MCRCOk, byRSR);
    }
    else if(byRxRate==12){
        pStatistic->CustomStat.ullRsr6M++;
        if(byRSR & RSR_CRCOK) {
            pStatistic->CustomStat.ullRsr6MCRCOk++;
        }
	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " 6M: ALL[%d], OK[%d]\n",
		(signed int) pStatistic->CustomStat.ullRsr6M,
		(signed int) pStatistic->CustomStat.ullRsr6MCRCOk);
    }
    else if(byRxRate==18){
        pStatistic->CustomStat.ullRsr9M++;
        if(byRSR & RSR_CRCOK) {
            pStatistic->CustomStat.ullRsr9MCRCOk++;
        }
	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " 9M: ALL[%d], OK[%d]\n",
		(signed int) pStatistic->CustomStat.ullRsr9M,
		(signed int) pStatistic->CustomStat.ullRsr9MCRCOk);
    }
    else if(byRxRate==24){
        pStatistic->CustomStat.ullRsr12M++;
        if(byRSR & RSR_CRCOK) {
            pStatistic->CustomStat.ullRsr12MCRCOk++;
        }
	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "12M: ALL[%d], OK[%d]\n",
		(signed int) pStatistic->CustomStat.ullRsr12M,
		(signed int) pStatistic->CustomStat.ullRsr12MCRCOk);
    }
    else if(byRxRate==36){
        pStatistic->CustomStat.ullRsr18M++;
        if(byRSR & RSR_CRCOK) {
            pStatistic->CustomStat.ullRsr18MCRCOk++;
        }
	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "18M: ALL[%d], OK[%d]\n",
		(signed int) pStatistic->CustomStat.ullRsr18M,
		(signed int) pStatistic->CustomStat.ullRsr18MCRCOk);
    }
    else if(byRxRate==48){
        pStatistic->CustomStat.ullRsr24M++;
        if(byRSR & RSR_CRCOK) {
            pStatistic->CustomStat.ullRsr24MCRCOk++;
        }
	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "24M: ALL[%d], OK[%d]\n",
		(signed int) pStatistic->CustomStat.ullRsr24M,
		(signed int) pStatistic->CustomStat.ullRsr24MCRCOk);
    }
    else if(byRxRate==72){
        pStatistic->CustomStat.ullRsr36M++;
        if(byRSR & RSR_CRCOK) {
            pStatistic->CustomStat.ullRsr36MCRCOk++;
        }
	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "36M: ALL[%d], OK[%d]\n",
		(signed int) pStatistic->CustomStat.ullRsr36M,
		(signed int) pStatistic->CustomStat.ullRsr36MCRCOk);
    }
    else if(byRxRate==96){
        pStatistic->CustomStat.ullRsr48M++;
        if(byRSR & RSR_CRCOK) {
            pStatistic->CustomStat.ullRsr48MCRCOk++;
        }
	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "48M: ALL[%d], OK[%d]\n",
		(signed int) pStatistic->CustomStat.ullRsr48M,
		(signed int) pStatistic->CustomStat.ullRsr48MCRCOk);
    }
    else if(byRxRate==108){
        pStatistic->CustomStat.ullRsr54M++;
        if(byRSR & RSR_CRCOK) {
            pStatistic->CustomStat.ullRsr54MCRCOk++;
        }
	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "54M: ALL[%d], OK[%d]\n",
		(signed int) pStatistic->CustomStat.ullRsr54M,
		(signed int) pStatistic->CustomStat.ullRsr54MCRCOk);
    }
    else {
	    DBG_PRT(MSG_LEVEL_DEBUG,
		    KERN_INFO "Unknown: Total[%d], CRCOK[%d]\n",
		    (signed int) pStatistic->dwRsrRxPacket+1,
		    (signed int)pStatistic->dwRsrCRCOk);
    }

    if (byRSR & RSR_BSSIDOK)
        pStatistic->dwRsrBSSIDOk++;

    if (byRSR & RSR_BCNSSIDOK)
        pStatistic->dwRsrBCNSSIDOk++;
    if (byRSR & RSR_IVLDLEN)  //invalid len (> 2312 byte)
        pStatistic->dwRsrLENErr++;
    if (byRSR & RSR_IVLDTYP)  //invalid packet type
        pStatistic->dwRsrTYPErr++;
    if ((byRSR & (RSR_IVLDTYP | RSR_IVLDLEN)) || !(byRSR & RSR_CRCOK))
        pStatistic->dwRsrErr++;

    if (byNewRSR & NEWRSR_DECRYPTOK)
        pStatistic->dwNewRsrDECRYPTOK++;
    if (byNewRSR & NEWRSR_CFPIND)
        pStatistic->dwNewRsrCFP++;
    if (byNewRSR & NEWRSR_HWUTSF)
        pStatistic->dwNewRsrUTSF++;
    if (byNewRSR & NEWRSR_BCNHITAID)
        pStatistic->dwNewRsrHITAID++;
    if (byNewRSR & NEWRSR_BCNHITAID0)
        pStatistic->dwNewRsrHITAID0++;

    // increase rx packet count
    pStatistic->dwRsrRxPacket++;
    pStatistic->dwRsrRxOctet += cbFrameLength;


    if (IS_TYPE_DATA(pbyBuffer)) {
        pStatistic->dwRsrRxData++;
    } else if (IS_TYPE_MGMT(pbyBuffer)){
        pStatistic->dwRsrRxManage++;
    } else if (IS_TYPE_CONTROL(pbyBuffer)){
        pStatistic->dwRsrRxControl++;
    }

    if (byRSR & RSR_ADDRBROAD)
        pStatistic->dwRsrBroadcast++;
    else if (byRSR & RSR_ADDRMULTI)
        pStatistic->dwRsrMulticast++;
    else
        pStatistic->dwRsrDirected++;

    if (WLAN_GET_FC_MOREFRAG(pHeader->wFrameCtl))
        pStatistic->dwRsrRxFragment++;

    if (cbFrameLength < ETH_ZLEN + 4) {
        pStatistic->dwRsrRunt++;
    } else if (cbFrameLength == ETH_ZLEN + 4) {
        pStatistic->dwRsrRxFrmLen64++;
    }
    else if ((65 <= cbFrameLength) && (cbFrameLength <= 127)) {
        pStatistic->dwRsrRxFrmLen65_127++;
    }
    else if ((128 <= cbFrameLength) && (cbFrameLength <= 255)) {
        pStatistic->dwRsrRxFrmLen128_255++;
    }
    else if ((256 <= cbFrameLength) && (cbFrameLength <= 511)) {
        pStatistic->dwRsrRxFrmLen256_511++;
    }
    else if ((512 <= cbFrameLength) && (cbFrameLength <= 1023)) {
        pStatistic->dwRsrRxFrmLen512_1023++;
    } else if ((1024 <= cbFrameLength) &&
	       (cbFrameLength <= ETH_FRAME_LEN + 4)) {
        pStatistic->dwRsrRxFrmLen1024_1518++;
    } else if (cbFrameLength > ETH_FRAME_LEN + 4) {
        pStatistic->dwRsrLong++;
    }
}

/*
 * Description: Update Rx Statistic Counter and copy Rx buffer
 *
 * Parameters:
 *  In:
 *      pStatistic      - Pointer to Statistic Counter Data Structure
 *      byRSR           - Rx Status
 *      byNewRSR        - Rx Status
 *      pbyBuffer       - Rx Buffer
 *      cbFrameLength   - Rx Length
 *  Out:
 *      none
 *
 * Return Value: none
 *
 */

void
STAvUpdateRDStatCounterEx (
    PSStatCounter   pStatistic,
    BYTE            byRSR,
    BYTE            byNewRSR,
    BYTE            byRxSts,
    BYTE            byRxRate,
    PBYTE           pbyBuffer,
    unsigned int            cbFrameLength
    )
{
    STAvUpdateRDStatCounter(
                    pStatistic,
                    byRSR,
                    byNewRSR,
                    byRxSts,
                    byRxRate,
                    pbyBuffer,
                    cbFrameLength
                    );

    // rx length
    pStatistic->dwCntRxFrmLength = cbFrameLength;
    // rx pattern, we just see 10 bytes for sample
    memcpy(pStatistic->abyCntRxPattern, (PBYTE)pbyBuffer, 10);
}


/*
 * Description: Update Tx Statistic Counter
 *
 * Parameters:
 *  In:
 *      pStatistic      - Pointer to Statistic Counter Data Structure
 *      byTSR0          - Tx Status
 *      byTSR1          - Tx Status
 *      pbyBuffer       - Tx Buffer
 *      cbFrameLength   - Tx Length
 *      uIdx            - Index of Tx DMA
 *  Out:
 *      none
 *
 * Return Value: none
 *
 */
void
STAvUpdateTDStatCounter (
    PSStatCounter   pStatistic,
    BYTE            byPktNum,
    BYTE            byRate,
    BYTE            byTSR
    )
{
    BYTE    byRetyCnt;
    // increase tx packet count
    pStatistic->dwTsrTxPacket++;

    byRetyCnt = (byTSR & 0xF0) >> 4;
    if (byRetyCnt != 0) {
        pStatistic->dwTsrRetry++;
        pStatistic->dwTsrTotalRetry += byRetyCnt;
        pStatistic->dwTxFail[byRate]+= byRetyCnt;
        pStatistic->dwTxFail[MAX_RATE] += byRetyCnt;

        if ( byRetyCnt == 0x1)
            pStatistic->dwTsrOnceRetry++;
        else
            pStatistic->dwTsrMoreThanOnceRetry++;

        if (byRetyCnt <= 8)
            pStatistic->dwTxRetryCount[byRetyCnt-1]++;

    }
    if ( !(byTSR & (TSR_TMO | TSR_RETRYTMO))) {

   if (byRetyCnt < 2)
        pStatistic->TxNoRetryOkCount ++;
   else
        pStatistic->TxRetryOkCount ++;

        pStatistic->ullTsrOK++;
        pStatistic->CustomStat.ullTsrAllOK++;
        // update counters in case that successful transmit
        pStatistic->dwTxOk[byRate]++;
        pStatistic->dwTxOk[MAX_RATE]++;

        if ( pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni == TX_PKT_BROAD )  {
            pStatistic->ullTxBroadcastFrames++;
            pStatistic->ullTxBroadcastBytes += pStatistic->abyTxPktInfo[byPktNum].wLength;
        } else if ( pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni == TX_PKT_MULTI ) {
            pStatistic->ullTxMulticastFrames++;
            pStatistic->ullTxMulticastBytes += pStatistic->abyTxPktInfo[byPktNum].wLength;
        } else if ( pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni == TX_PKT_UNI ) {
            pStatistic->ullTxDirectedFrames++;
            pStatistic->ullTxDirectedBytes += pStatistic->abyTxPktInfo[byPktNum].wLength;
        }
    }
    else {

        pStatistic->TxFailCount ++;

        pStatistic->dwTsrErr++;
        if (byTSR & TSR_RETRYTMO)
            pStatistic->dwTsrRetryTimeout++;
        if (byTSR & TSR_TMO)
            pStatistic->dwTsrTransmitTimeout++;
    }

    if ( pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni == TX_PKT_BROAD )  {
        pStatistic->dwTsrBroadcast++;
    } else if ( pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni == TX_PKT_MULTI ) {
        pStatistic->dwTsrMulticast++;
    } else if ( pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni == TX_PKT_UNI ) {
        pStatistic->dwTsrDirected++;
    }
}


/*
 * Description: Update 802.11 mib counter
 *
 * Parameters:
 *  In:
 *      p802_11Counter  - Pointer to 802.11 mib counter
 *      pStatistic      - Pointer to Statistic Counter Data Structure
 *      dwCounter       - hardware counter for 802.11 mib
 *  Out:
 *      none
 *
 * Return Value: none
 *
 */
void
STAvUpdate802_11Counter(
    PSDot11Counters         p802_11Counter,
    PSStatCounter           pStatistic,
    BYTE                    byRTSSuccess,
    BYTE                    byRTSFail,
    BYTE                    byACKFail,
    BYTE                    byFCSErr
    )
{
    //p802_11Counter->TransmittedFragmentCount
    p802_11Counter->MulticastTransmittedFrameCount =
      (unsigned long long) (pStatistic->dwTsrBroadcast +
			    pStatistic->dwTsrMulticast);
    p802_11Counter->FailedCount = (unsigned long long) (pStatistic->dwTsrErr);
    p802_11Counter->RetryCount = (unsigned long long) (pStatistic->dwTsrRetry);
    p802_11Counter->MultipleRetryCount =
      (unsigned long long) (pStatistic->dwTsrMoreThanOnceRetry);
    //p802_11Counter->FrameDuplicateCount
    p802_11Counter->RTSSuccessCount += (unsigned long long) byRTSSuccess;
    p802_11Counter->RTSFailureCount += (unsigned long long) byRTSFail;
    p802_11Counter->ACKFailureCount += (unsigned long long) byACKFail;
    p802_11Counter->FCSErrorCount +=   (unsigned long long) byFCSErr;
    //p802_11Counter->ReceivedFragmentCount
    p802_11Counter->MulticastReceivedFrameCount =
      (unsigned long long) (pStatistic->dwRsrBroadcast +
			    pStatistic->dwRsrMulticast);
}

/*
 * Description: Clear 802.11 mib counter
 *
 * Parameters:
 *  In:
 *      p802_11Counter  - Pointer to 802.11 mib counter
 *  Out:
 *      none
 *
 * Return Value: none
 *
 */
void
STAvClear802_11Counter(PSDot11Counters p802_11Counter)
{
    // set memory to zero
	memset(p802_11Counter, 0, sizeof(SDot11Counters));
}

/*
 * Description: Clear 802.11 mib counter
 *
 * Parameters:
 *  In:
 *      pUsbCounter  - Pointer to USB mib counter
 *      ntStatus - URB status
 *  Out:
 *      none
 *
 * Return Value: none
 *
 */

void STAvUpdateUSBCounter(PSUSBCounter pUsbCounter, int ntStatus)
{

//    if ( ntStatus == USBD_STATUS_CRC ) {
        pUsbCounter->dwCrc++;
//    }

}
Commit	Line	Data
92b96797 FB	1	/*
	2	* Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
	3	* All rights reserved.
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License along
	16	* with this program; if not, write to the Free Software Foundation, Inc.,
	17	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	18	*
	19	* File: mib.c
	20	*
	21	* Purpose: Implement MIB Data Structure
	22	*
	23	* Author: Tevin Chen
	24	*
	25	* Date: May 21, 1996
	26	*
	27	* Functions:
	28	* STAvClearAllCounter - Clear All MIB Counter
	29	* STAvUpdateIstStatCounter - Update ISR statistic counter
	30	* STAvUpdateRDStatCounter - Update Rx statistic counter
	31	* STAvUpdateRDStatCounterEx - Update Rx statistic counter and copy rcv data
	32	* STAvUpdateTDStatCounter - Update Tx statistic counter
	33	* STAvUpdateTDStatCounterEx - Update Tx statistic counter and copy tx data
	34	* STAvUpdate802_11Counter - Update 802.11 mib counter
	35	*
	36	* Revision History:
	37	*
	38	*/
	39
92b96797	40	#include "upc.h"
92b96797	41	#include "mac.h"
92b96797	42	#include "tether.h"
92b96797	43	#include "mib.h"
92b96797	44	#include "wctl.h"
92b96797	45	#include "baseband.h"
92b96797 FB	46
	47	/--------------------- Static Definitions -------------------------/
	48	static int msglevel =MSG_LEVEL_INFO;
	49	/--------------------- Static Classes ----------------------------/
	50
	51	/--------------------- Static Variables --------------------------/
	52
	53	/--------------------- Static Functions --------------------------/
	54
	55	/--------------------- Export Variables --------------------------/
	56
	57	/--------------------- Export Functions --------------------------/
	58
	59
	60
	61	/*
	62	* Description: Clear All Statistic Counter
	63	*
	64	* Parameters:
	65	* In:
	66	* pStatistic - Pointer to Statistic Counter Data Structure
	67	* Out:
	68	* none
	69	*
	70	* Return Value: none
	71	*
	72	*/
	73	void STAvClearAllCounter (PSStatCounter pStatistic)
	74	{
	75	// set memory to zero
3e362598	76	memset(pStatistic, 0, sizeof(SStatCounter));
92b96797 FB	77	}
	78
	79
	80	/*
	81	* Description: Update Isr Statistic Counter
	82	*
	83	* Parameters:
	84	* In:
	85	* pStatistic - Pointer to Statistic Counter Data Structure
	86	* wisr - Interrupt status
	87	* Out:
	88	* none
	89	*
	90	* Return Value: none
	91	*
	92	*/
	93	void STAvUpdateIsrStatCounter (PSStatCounter pStatistic, BYTE byIsr0, BYTE byIsr1)
	94	{
	95	/**********************/
	96	/* ABNORMAL interrupt */
	97	/**********************/
	98	// not any IMR bit invoke irq
	99	if (byIsr0 == 0) {
	100	pStatistic->ISRStat.dwIsrUnknown++;
	101	return;
	102	}
	103
	104
8a3d91b0	105	if (byIsr0 & ISR_ACTX) // ISR, bit0
92b96797 FB	106	pStatistic->ISRStat.dwIsrTx0OK++; // TXDMA0 successful
92b96797 FB	107
8a3d91b0	108	if (byIsr0 & ISR_BNTX) // ISR, bit2
92b96797 FB	109	pStatistic->ISRStat.dwIsrBeaconTxOK++; // BeaconTx successful
92b96797 FB	110
8a3d91b0	111	if (byIsr0 & ISR_RXDMA0) // ISR, bit3
92b96797 FB	112	pStatistic->ISRStat.dwIsrRx0OK++; // Rx0 successful
92b96797 FB	113
8a3d91b0	114	if (byIsr0 & ISR_TBTT) // ISR, bit4
92b96797 FB	115	pStatistic->ISRStat.dwIsrTBTTInt++; // TBTT successful
92b96797 FB	116
8a3d91b0	117	if (byIsr0 & ISR_SOFTTIMER) // ISR, bit6
92b96797 FB	118	pStatistic->ISRStat.dwIsrSTIMERInt++;
92b96797 FB	119
8a3d91b0	120	if (byIsr0 & ISR_WATCHDOG) // ISR, bit7
92b96797 FB	121	pStatistic->ISRStat.dwIsrWatchDog++;
	122
	123
8a3d91b0	124	if (byIsr1 & ISR_FETALERR) // ISR, bit8
92b96797 FB	125	pStatistic->ISRStat.dwIsrUnrecoverableError++;
92b96797 FB	126
8a3d91b0	127	if (byIsr1 & ISR_SOFTINT) // ISR, bit9
92b96797 FB	128	pStatistic->ISRStat.dwIsrSoftInterrupt++; // software interrupt
92b96797 FB	129
8a3d91b0	130	if (byIsr1 & ISR_MIBNEARFULL) // ISR, bit10
92b96797 FB	131	pStatistic->ISRStat.dwIsrMIBNearfull++;
92b96797 FB	132
8a3d91b0	133	if (byIsr1 & ISR_RXNOBUF) // ISR, bit11
92b96797 FB	134	pStatistic->ISRStat.dwIsrRxNoBuf++; // Rx No Buff
	135
	136	}
	137
	138
	139	/*
	140	* Description: Update Rx Statistic Counter
	141	*
	142	* Parameters:
	143	* In:
	144	* pStatistic - Pointer to Statistic Counter Data Structure
	145	* byRSR - Rx Status
	146	* byNewRSR - Rx Status
	147	* pbyBuffer - Rx Buffer
	148	* cbFrameLength - Rx Length
	149	* Out:
	150	* none
	151	*
	152	* Return Value: none
	153	*
	154	*/
cc856e61 AM	155	void STAvUpdateRDStatCounter(PSStatCounter pStatistic,
	156	BYTE byRSR, BYTE byNewRSR,
	157	BYTE byRxSts, BYTE byRxRate,
	158	PBYTE pbyBuffer, unsigned int cbFrameLength)
92b96797	159	{
9a0e756c AM	160	/* need change */
9a0e756c AM	161	PS802_11Header pHeader = (PS802_11Header)pbyBuffer;
92b96797	162
9a0e756c AM	163	if (byRSR & RSR_ADDROK)
	164	pStatistic->dwRsrADDROk++;
	165	if (byRSR & RSR_CRCOK) {
	166	pStatistic->dwRsrCRCOk++;
	167	pStatistic->ullRsrOK++;
92b96797	168
9a0e756c AM	169	if (cbFrameLength >= ETH_ALEN) {
9a0e756c AM	170	/* update counters in case of successful transmission */
8a3d91b0	171	if (byRSR & RSR_ADDRBROAD) {
92b96797	172	pStatistic->ullRxBroadcastFrames++;
cc856e61 AM	173	pStatistic->ullRxBroadcastBytes +=
cc856e61 AM	174	(unsigned long long) cbFrameLength;
92b96797	175	}
8a3d91b0	176	else if (byRSR & RSR_ADDRMULTI) {
92b96797	177	pStatistic->ullRxMulticastFrames++;
cc856e61 AM	178	pStatistic->ullRxMulticastBytes +=
cc856e61 AM	179	(unsigned long long) cbFrameLength;
92b96797 FB	180	}
	181	else {
	182	pStatistic->ullRxDirectedFrames++;
cc856e61 AM	183	pStatistic->ullRxDirectedBytes +=
cc856e61 AM	184	(unsigned long long) cbFrameLength;
92b96797 FB	185	}
	186	}
	187	}
	188
	189	if(byRxRate==22) {
	190	pStatistic->CustomStat.ullRsr11M++;
8a3d91b0	191	if(byRSR & RSR_CRCOK) {
92b96797 FB	192	pStatistic->CustomStat.ullRsr11MCRCOk++;
92b96797 FB	193	}
213d2e93 AM	194	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "11M: ALL[%d], OK[%d]:[%02x]\n",
	195	(signed int) pStatistic->CustomStat.ullRsr11M,
	196	(signed int) pStatistic->CustomStat.ullRsr11MCRCOk, byRSR);
92b96797 FB	197	}
	198	else if(byRxRate==11) {
	199	pStatistic->CustomStat.ullRsr5M++;
8a3d91b0	200	if(byRSR & RSR_CRCOK) {
92b96797 FB	201	pStatistic->CustomStat.ullRsr5MCRCOk++;
92b96797 FB	202	}
213d2e93 AM	203	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " 5M: ALL[%d], OK[%d]:[%02x]\n",
	204	(signed int) pStatistic->CustomStat.ullRsr5M,
	205	(signed int) pStatistic->CustomStat.ullRsr5MCRCOk, byRSR);
92b96797 FB	206	}
	207	else if(byRxRate==4) {
	208	pStatistic->CustomStat.ullRsr2M++;
8a3d91b0	209	if(byRSR & RSR_CRCOK) {
92b96797 FB	210	pStatistic->CustomStat.ullRsr2MCRCOk++;
92b96797 FB	211	}
213d2e93 AM	212	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " 2M: ALL[%d], OK[%d]:[%02x]\n",
	213	(signed int) pStatistic->CustomStat.ullRsr2M,
	214	(signed int) pStatistic->CustomStat.ullRsr2MCRCOk, byRSR);
92b96797 FB	215	}
	216	else if(byRxRate==2){
	217	pStatistic->CustomStat.ullRsr1M++;
8a3d91b0	218	if(byRSR & RSR_CRCOK) {
92b96797 FB	219	pStatistic->CustomStat.ullRsr1MCRCOk++;
92b96797 FB	220	}
213d2e93 AM	221	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " 1M: ALL[%d], OK[%d]:[%02x]\n",
	222	(signed int) pStatistic->CustomStat.ullRsr1M,
	223	(signed int) pStatistic->CustomStat.ullRsr1MCRCOk, byRSR);
92b96797 FB	224	}
	225	else if(byRxRate==12){
	226	pStatistic->CustomStat.ullRsr6M++;
8a3d91b0	227	if(byRSR & RSR_CRCOK) {
92b96797 FB	228	pStatistic->CustomStat.ullRsr6MCRCOk++;
92b96797 FB	229	}
213d2e93 AM	230	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " 6M: ALL[%d], OK[%d]\n",
	231	(signed int) pStatistic->CustomStat.ullRsr6M,
	232	(signed int) pStatistic->CustomStat.ullRsr6MCRCOk);
92b96797 FB	233	}
	234	else if(byRxRate==18){
	235	pStatistic->CustomStat.ullRsr9M++;
8a3d91b0	236	if(byRSR & RSR_CRCOK) {
92b96797 FB	237	pStatistic->CustomStat.ullRsr9MCRCOk++;
92b96797 FB	238	}
213d2e93 AM	239	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " 9M: ALL[%d], OK[%d]\n",
	240	(signed int) pStatistic->CustomStat.ullRsr9M,
	241	(signed int) pStatistic->CustomStat.ullRsr9MCRCOk);
92b96797 FB	242	}
	243	else if(byRxRate==24){
	244	pStatistic->CustomStat.ullRsr12M++;
8a3d91b0	245	if(byRSR & RSR_CRCOK) {
92b96797 FB	246	pStatistic->CustomStat.ullRsr12MCRCOk++;
92b96797 FB	247	}
213d2e93 AM	248	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "12M: ALL[%d], OK[%d]\n",
	249	(signed int) pStatistic->CustomStat.ullRsr12M,
	250	(signed int) pStatistic->CustomStat.ullRsr12MCRCOk);
92b96797 FB	251	}
	252	else if(byRxRate==36){
	253	pStatistic->CustomStat.ullRsr18M++;
8a3d91b0	254	if(byRSR & RSR_CRCOK) {
92b96797 FB	255	pStatistic->CustomStat.ullRsr18MCRCOk++;
92b96797 FB	256	}
213d2e93 AM	257	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "18M: ALL[%d], OK[%d]\n",
	258	(signed int) pStatistic->CustomStat.ullRsr18M,
	259	(signed int) pStatistic->CustomStat.ullRsr18MCRCOk);
92b96797 FB	260	}
	261	else if(byRxRate==48){
	262	pStatistic->CustomStat.ullRsr24M++;
8a3d91b0	263	if(byRSR & RSR_CRCOK) {
92b96797 FB	264	pStatistic->CustomStat.ullRsr24MCRCOk++;
92b96797 FB	265	}
213d2e93 AM	266	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "24M: ALL[%d], OK[%d]\n",
	267	(signed int) pStatistic->CustomStat.ullRsr24M,
	268	(signed int) pStatistic->CustomStat.ullRsr24MCRCOk);
92b96797 FB	269	}
	270	else if(byRxRate==72){
	271	pStatistic->CustomStat.ullRsr36M++;
8a3d91b0	272	if(byRSR & RSR_CRCOK) {
92b96797 FB	273	pStatistic->CustomStat.ullRsr36MCRCOk++;
92b96797 FB	274	}
213d2e93 AM	275	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "36M: ALL[%d], OK[%d]\n",
	276	(signed int) pStatistic->CustomStat.ullRsr36M,
	277	(signed int) pStatistic->CustomStat.ullRsr36MCRCOk);
92b96797 FB	278	}
	279	else if(byRxRate==96){
	280	pStatistic->CustomStat.ullRsr48M++;
8a3d91b0	281	if(byRSR & RSR_CRCOK) {
92b96797 FB	282	pStatistic->CustomStat.ullRsr48MCRCOk++;
92b96797 FB	283	}
213d2e93 AM	284	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "48M: ALL[%d], OK[%d]\n",
	285	(signed int) pStatistic->CustomStat.ullRsr48M,
	286	(signed int) pStatistic->CustomStat.ullRsr48MCRCOk);
92b96797 FB	287	}
	288	else if(byRxRate==108){
	289	pStatistic->CustomStat.ullRsr54M++;
8a3d91b0	290	if(byRSR & RSR_CRCOK) {
92b96797 FB	291	pStatistic->CustomStat.ullRsr54MCRCOk++;
92b96797 FB	292	}
213d2e93 AM	293	DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "54M: ALL[%d], OK[%d]\n",
	294	(signed int) pStatistic->CustomStat.ullRsr54M,
	295	(signed int) pStatistic->CustomStat.ullRsr54MCRCOk);
92b96797 FB	296	}
92b96797 FB	297	else {
213d2e93 AM	298	DBG_PRT(MSG_LEVEL_DEBUG,
	299	KERN_INFO "Unknown: Total[%d], CRCOK[%d]\n",
	300	(signed int) pStatistic->dwRsrRxPacket+1,
	301	(signed int)pStatistic->dwRsrCRCOk);
92b96797 FB	302	}
92b96797 FB	303
8a3d91b0	304	if (byRSR & RSR_BSSIDOK)
92b96797 FB	305	pStatistic->dwRsrBSSIDOk++;
92b96797 FB	306
8a3d91b0	307	if (byRSR & RSR_BCNSSIDOK)
92b96797	308	pStatistic->dwRsrBCNSSIDOk++;
8a3d91b0	309	if (byRSR & RSR_IVLDLEN) //invalid len (> 2312 byte)
92b96797	310	pStatistic->dwRsrLENErr++;
8a3d91b0	311	if (byRSR & RSR_IVLDTYP) //invalid packet type
92b96797	312	pStatistic->dwRsrTYPErr++;
8a3d91b0	313	if ((byRSR & (RSR_IVLDTYP \| RSR_IVLDLEN)) \|\| !(byRSR & RSR_CRCOK))
92b96797 FB	314	pStatistic->dwRsrErr++;
92b96797 FB	315
8a3d91b0	316	if (byNewRSR & NEWRSR_DECRYPTOK)
92b96797	317	pStatistic->dwNewRsrDECRYPTOK++;
8a3d91b0	318	if (byNewRSR & NEWRSR_CFPIND)
92b96797	319	pStatistic->dwNewRsrCFP++;
8a3d91b0	320	if (byNewRSR & NEWRSR_HWUTSF)
92b96797	321	pStatistic->dwNewRsrUTSF++;
8a3d91b0	322	if (byNewRSR & NEWRSR_BCNHITAID)
92b96797	323	pStatistic->dwNewRsrHITAID++;
8a3d91b0	324	if (byNewRSR & NEWRSR_BCNHITAID0)
92b96797 FB	325	pStatistic->dwNewRsrHITAID0++;
	326
	327	// increase rx packet count
	328	pStatistic->dwRsrRxPacket++;
	329	pStatistic->dwRsrRxOctet += cbFrameLength;
	330
	331
	332	if (IS_TYPE_DATA(pbyBuffer)) {
	333	pStatistic->dwRsrRxData++;
	334	} else if (IS_TYPE_MGMT(pbyBuffer)){
	335	pStatistic->dwRsrRxManage++;
	336	} else if (IS_TYPE_CONTROL(pbyBuffer)){
	337	pStatistic->dwRsrRxControl++;
	338	}
	339
8a3d91b0	340	if (byRSR & RSR_ADDRBROAD)
92b96797	341	pStatistic->dwRsrBroadcast++;
8a3d91b0	342	else if (byRSR & RSR_ADDRMULTI)
92b96797 FB	343	pStatistic->dwRsrMulticast++;
	344	else
	345	pStatistic->dwRsrDirected++;
	346
	347	if (WLAN_GET_FC_MOREFRAG(pHeader->wFrameCtl))
	348	pStatistic->dwRsrRxFragment++;
	349
5e03f73f	350	if (cbFrameLength < ETH_ZLEN + 4) {
92b96797	351	pStatistic->dwRsrRunt++;
5e03f73f	352	} else if (cbFrameLength == ETH_ZLEN + 4) {
92b96797 FB	353	pStatistic->dwRsrRxFrmLen64++;
	354	}
	355	else if ((65 <= cbFrameLength) && (cbFrameLength <= 127)) {
	356	pStatistic->dwRsrRxFrmLen65_127++;
	357	}
	358	else if ((128 <= cbFrameLength) && (cbFrameLength <= 255)) {
	359	pStatistic->dwRsrRxFrmLen128_255++;
	360	}
	361	else if ((256 <= cbFrameLength) && (cbFrameLength <= 511)) {
	362	pStatistic->dwRsrRxFrmLen256_511++;
	363	}
	364	else if ((512 <= cbFrameLength) && (cbFrameLength <= 1023)) {
	365	pStatistic->dwRsrRxFrmLen512_1023++;
6d4e807c AM	366	} else if ((1024 <= cbFrameLength) &&
6d4e807c AM	367	(cbFrameLength <= ETH_FRAME_LEN + 4)) {
92b96797	368	pStatistic->dwRsrRxFrmLen1024_1518++;
6d4e807c	369	} else if (cbFrameLength > ETH_FRAME_LEN + 4) {
92b96797 FB	370	pStatistic->dwRsrLong++;
92b96797 FB	371	}
92b96797 FB	372	}
92b96797 FB	373
92b96797 FB	374	/*
	375	* Description: Update Rx Statistic Counter and copy Rx buffer
	376	*
	377	* Parameters:
	378	* In:
	379	* pStatistic - Pointer to Statistic Counter Data Structure
	380	* byRSR - Rx Status
	381	* byNewRSR - Rx Status
	382	* pbyBuffer - Rx Buffer
	383	* cbFrameLength - Rx Length
	384	* Out:
	385	* none
	386	*
	387	* Return Value: none
	388	*
	389	*/
	390
	391	void
	392	STAvUpdateRDStatCounterEx (
	393	PSStatCounter pStatistic,
	394	BYTE byRSR,
	395	BYTE byNewRSR,
	396	BYTE byRxSts,
	397	BYTE byRxRate,
	398	PBYTE pbyBuffer,
cc856e61	399	unsigned int cbFrameLength
92b96797 FB	400	)
	401	{
	402	STAvUpdateRDStatCounter(
	403	pStatistic,
	404	byRSR,
	405	byNewRSR,
	406	byRxSts,
	407	byRxRate,
	408	pbyBuffer,
	409	cbFrameLength
	410	);
	411
	412	// rx length
	413	pStatistic->dwCntRxFrmLength = cbFrameLength;
	414	// rx pattern, we just see 10 bytes for sample
3e362598	415	memcpy(pStatistic->abyCntRxPattern, (PBYTE)pbyBuffer, 10);
92b96797 FB	416	}
	417
	418
	419	/*
	420	* Description: Update Tx Statistic Counter
	421	*
	422	* Parameters:
	423	* In:
	424	* pStatistic - Pointer to Statistic Counter Data Structure
	425	* byTSR0 - Tx Status
	426	* byTSR1 - Tx Status
	427	* pbyBuffer - Tx Buffer
	428	* cbFrameLength - Tx Length
	429	* uIdx - Index of Tx DMA
	430	* Out:
	431	* none
	432	*
	433	* Return Value: none
	434	*
	435	*/
	436	void
	437	STAvUpdateTDStatCounter (
	438	PSStatCounter pStatistic,
	439	BYTE byPktNum,
	440	BYTE byRate,
	441	BYTE byTSR
	442	)
	443	{
	444	BYTE byRetyCnt;
	445	// increase tx packet count
	446	pStatistic->dwTsrTxPacket++;
	447
	448	byRetyCnt = (byTSR & 0xF0) >> 4;
	449	if (byRetyCnt != 0) {
	450	pStatistic->dwTsrRetry++;
	451	pStatistic->dwTsrTotalRetry += byRetyCnt;
	452	pStatistic->dwTxFail[byRate]+= byRetyCnt;
	453	pStatistic->dwTxFail[MAX_RATE] += byRetyCnt;
	454
	455	if ( byRetyCnt == 0x1)
	456	pStatistic->dwTsrOnceRetry++;
	457	else
	458	pStatistic->dwTsrMoreThanOnceRetry++;
	459
	460	if (byRetyCnt <= 8)
	461	pStatistic->dwTxRetryCount[byRetyCnt-1]++;
	462
	463	}
8a3d91b0	464	if ( !(byTSR & (TSR_TMO \| TSR_RETRYTMO))) {
92b96797	465
92b96797 FB	466	if (byRetyCnt < 2)
	467	pStatistic->TxNoRetryOkCount ++;
	468	else
	469	pStatistic->TxRetryOkCount ++;
92b96797 FB	470
	471	pStatistic->ullTsrOK++;
	472	pStatistic->CustomStat.ullTsrAllOK++;
	473	// update counters in case that successful transmit
	474	pStatistic->dwTxOk[byRate]++;
	475	pStatistic->dwTxOk[MAX_RATE]++;
	476
	477	if ( pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni == TX_PKT_BROAD ) {
	478	pStatistic->ullTxBroadcastFrames++;
	479	pStatistic->ullTxBroadcastBytes += pStatistic->abyTxPktInfo[byPktNum].wLength;
	480	} else if ( pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni == TX_PKT_MULTI ) {
	481	pStatistic->ullTxMulticastFrames++;
	482	pStatistic->ullTxMulticastBytes += pStatistic->abyTxPktInfo[byPktNum].wLength;
	483	} else if ( pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni == TX_PKT_UNI ) {
	484	pStatistic->ullTxDirectedFrames++;
	485	pStatistic->ullTxDirectedBytes += pStatistic->abyTxPktInfo[byPktNum].wLength;
	486	}
	487	}
	488	else {
	489
92b96797	490	pStatistic->TxFailCount ++;
92b96797 FB	491
92b96797 FB	492	pStatistic->dwTsrErr++;
8a3d91b0	493	if (byTSR & TSR_RETRYTMO)
92b96797	494	pStatistic->dwTsrRetryTimeout++;
8a3d91b0	495	if (byTSR & TSR_TMO)
92b96797 FB	496	pStatistic->dwTsrTransmitTimeout++;
	497	}
	498
	499	if ( pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni == TX_PKT_BROAD ) {
	500	pStatistic->dwTsrBroadcast++;
	501	} else if ( pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni == TX_PKT_MULTI ) {
	502	pStatistic->dwTsrMulticast++;
	503	} else if ( pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni == TX_PKT_UNI ) {
	504	pStatistic->dwTsrDirected++;
	505	}
	506	}
	507
	508
	509
	510	/*
	511	* Description: Update 802.11 mib counter
	512	*
	513	* Parameters:
	514	* In:
	515	* p802_11Counter - Pointer to 802.11 mib counter
	516	* pStatistic - Pointer to Statistic Counter Data Structure
	517	* dwCounter - hardware counter for 802.11 mib
	518	* Out:
	519	* none
	520	*
	521	* Return Value: none
	522	*
	523	*/
	524	void
	525	STAvUpdate802_11Counter(
	526	PSDot11Counters p802_11Counter,
	527	PSStatCounter pStatistic,
	528	BYTE byRTSSuccess,
	529	BYTE byRTSFail,
	530	BYTE byACKFail,
	531	BYTE byFCSErr
	532	)
	533	{
	534	//p802_11Counter->TransmittedFragmentCount
cc856e61 AM	535	p802_11Counter->MulticastTransmittedFrameCount =
	536	(unsigned long long) (pStatistic->dwTsrBroadcast +
	537	pStatistic->dwTsrMulticast);
	538	p802_11Counter->FailedCount = (unsigned long long) (pStatistic->dwTsrErr);
	539	p802_11Counter->RetryCount = (unsigned long long) (pStatistic->dwTsrRetry);
	540	p802_11Counter->MultipleRetryCount =
	541	(unsigned long long) (pStatistic->dwTsrMoreThanOnceRetry);
92b96797	542	//p802_11Counter->FrameDuplicateCount
cc856e61 AM	543	p802_11Counter->RTSSuccessCount += (unsigned long long) byRTSSuccess;
	544	p802_11Counter->RTSFailureCount += (unsigned long long) byRTSFail;
	545	p802_11Counter->ACKFailureCount += (unsigned long long) byACKFail;
	546	p802_11Counter->FCSErrorCount += (unsigned long long) byFCSErr;
92b96797	547	//p802_11Counter->ReceivedFragmentCount
cc856e61 AM	548	p802_11Counter->MulticastReceivedFrameCount =
	549	(unsigned long long) (pStatistic->dwRsrBroadcast +
	550	pStatistic->dwRsrMulticast);
92b96797 FB	551	}
	552
	553	/*
	554	* Description: Clear 802.11 mib counter
	555	*
	556	* Parameters:
	557	* In:
	558	* p802_11Counter - Pointer to 802.11 mib counter
	559	* Out:
	560	* none
	561	*
	562	* Return Value: none
	563	*
	564	*/
	565	void
	566	STAvClear802_11Counter(PSDot11Counters p802_11Counter)
	567	{
	568	// set memory to zero
3e362598	569	memset(p802_11Counter, 0, sizeof(SDot11Counters));
92b96797 FB	570	}
	571
	572	/*
	573	* Description: Clear 802.11 mib counter
	574	*
	575	* Parameters:
	576	* In:
	577	* pUsbCounter - Pointer to USB mib counter
	578	* ntStatus - URB status
	579	* Out:
	580	* none
	581	*
	582	* Return Value: none
	583	*
	584	*/
	585
6487c49e	586	void STAvUpdateUSBCounter(PSUSBCounter pUsbCounter, int ntStatus)
92b96797 FB	587	{
	588
	589	// if ( ntStatus == USBD_STATUS_CRC ) {
	590	pUsbCounter->dwCrc++;
	591	// }
	592
	593	}