Skip to contentSkip to conversation

drivers/staging/otus/80211core/cagg.c: Fix Coding Style

PATCH New Dragoslav Zaric 1 participant 1 message Apr 26, 2009

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 drivers/staging/otus/80211core/cagg.c: Fix Coding Style

staging/otus/80211core/cagg_cs_fix.c renamed from staging/otus/80211core/cagg.c +3047 -3083
@@ -27,105 +27,98 @@
 #include "cprecomp.h"
 
 extern u8_t zcUpToAc[8];
-const u8_t pri[] = {3,3,2,3,2,1,3,2,1,0};
+const u8_t pri[] = {3, 3, 2, 3, 2, 1, 3, 2, 1, 0};
 
 
 u16_t aggr_count;
 u32_t success_mpdu;
 u32_t total_mpdu;
 
-void zfAggInit(zdev_t* dev)
+void zfAggInit(zdev_t *dev)
 {
-    u16_t i,j;
+	u16_t i, j;
 
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    zmw_declare_for_critical_section();
-    /*
-     * reset sta information
-     */
-
-    zmw_enter_critical_section(dev);
-    wd->aggInitiated = 0;
-    wd->addbaComplete = 0;
-    wd->addbaCount = 0;
-    wd->reorder = 1;
-    for (i=0; i<ZM_MAX_STA_SUPPORT; i++)
-    {
-        for (j=0; j<ZM_AC; j++)
-        {
-            //wd->aggSta[i].aggQNumber[j] = ZM_AGG_POOL_SIZE;
-            wd->aggSta[i].aggFlag[j] = wd->aggSta[i].count[j] = 0;
-            wd->aggSta[i].tid_tx[j] = NULL;
-            wd->aggSta[i].tid_tx[j+1] = NULL;
-
-        }
-    }
-
-    /*
-     * reset Tx/Rx aggregation queue information
-     */
-    wd->aggState = 0;
-    for (i=0; i<ZM_AGG_POOL_SIZE; i++)
-    {
-        /*
-         * reset tx aggregation queue
-         */
-        wd->aggQPool[i] = zfwMemAllocate(dev, sizeof(struct aggQueue));
-        if(!wd->aggQPool[i])
-        {
-            zmw_leave_critical_section(dev);
-            return;
-        }
-        wd->aggQPool[i]->aggHead = wd->aggQPool[i]->aggTail =
-        wd->aggQPool[i]->aggQEnabled = wd->aggQPool[i]->aggReady =
-        wd->aggQPool[i]->clearFlag = wd->aggQPool[i]->deleteFlag = 0;
-        //wd->aggQPool[i]->aggSize = 16;
-
-        /*
-         * reset rx aggregation queue
-         */
-        wd->tid_rx[i] = zfwMemAllocate(dev, sizeof(struct agg_tid_rx));
-        if (!wd->tid_rx[i])
-        {
-            zmw_leave_critical_section(dev);
-            return;
-        }
-        wd->tid_rx[i]->aid = ZM_MAX_STA_SUPPORT;
-        wd->tid_rx[i]->seq_start = wd->tid_rx[i]->baw_head = \
-        wd->tid_rx[i]->baw_tail = 0;
-        wd->tid_rx[i]->sq_exceed_count = wd->tid_rx[i]->sq_behind_count = 0;
-        for (j=0; j<=ZM_AGG_BAW_SIZE; j++)
-            wd->tid_rx[i]->frame[j].buf = 0;
-        /*
-         * reset ADDBA exchange status code
-         * 0: NULL
-         * 1: ADDBA Request sent/received
-         * 2: ACK for ADDBA Request sent/received
-         * 3: ADDBA Response sent/received
-         * 4: ACK for ADDBA Response sent/received
-         */
-        wd->tid_rx[i]->addBaExchangeStatusCode = 0;
-
-    }
-    zmw_leave_critical_section(dev);
-    zfAggTallyReset(dev);
-    DESTQ.init = zfAggDestInit;
-    DESTQ.init(dev);
-    wd->aggInitiated = 1;
-    aggr_count = 0;
-    success_mpdu = 0;
-    total_mpdu = 0;
+	zmw_declare_for_critical_section();
+	/*
+	* reset sta information
+	*/
+
+	zmw_enter_critical_section(dev);
+	wd->aggInitiated = 0;
+	wd->addbaComplete = 0;
+	wd->addbaCount = 0;
+	wd->reorder = 1;
+	for (i = 0; i < ZM_MAX_STA_SUPPORT; i++) {
+		for (j = 0; j < ZM_AC; j++) {
+			/* wd->aggSta[i].aggQNumber[j] = ZM_AGG_POOL_SIZE; */
+			wd->aggSta[i].aggFlag[j] = wd->aggSta[i].count[j] = 0;
+			wd->aggSta[i].tid_tx[j] = NULL;
+			wd->aggSta[i].tid_tx[j+1] = NULL;
+		}
+	}
+
+	/*
+	* reset Tx/Rx aggregation queue information
+	*/
+	wd->aggState = 0;
+	for (i = 0; i < ZM_AGG_POOL_SIZE; i++) {
+		/*
+		* reset tx aggregation queue
+		*/
+		wd->aggQPool[i] = zfwMemAllocate(dev, sizeof(struct aggQueue));
+		if (!wd->aggQPool[i]) {
+			zmw_leave_critical_section(dev);
+			return;
+		}
+		wd->aggQPool[i]->aggHead = wd->aggQPool[i]->aggTail =
+		wd->aggQPool[i]->aggQEnabled = wd->aggQPool[i]->aggReady =
+		wd->aggQPool[i]->clearFlag = wd->aggQPool[i]->deleteFlag = 0;
+		/* wd->aggQPool[i]->aggSize = 16; */
+
+		/*
+		* reset rx aggregation queue
+		*/
+		wd->tid_rx[i] = zfwMemAllocate(dev, sizeof(struct agg_tid_rx));
+		if (!wd->tid_rx[i]) {
+			zmw_leave_critical_section(dev);
+			return;
+		}
+		wd->tid_rx[i]->aid = ZM_MAX_STA_SUPPORT;
+		wd->tid_rx[i]->seq_start = wd->tid_rx[i]->baw_head = \
+		wd->tid_rx[i]->baw_tail = 0;
+		wd->tid_rx[i]->sq_exceed_count =
+					wd->tid_rx[i]->sq_behind_count = 0;
+		for (j = 0; j <= ZM_AGG_BAW_SIZE; j++)
+			wd->tid_rx[i]->frame[j].buf = 0;
+		/*
+		* reset ADDBA exchange status code
+		* 0: NULL
+		* 1: ADDBA Request sent/received
+		* 2: ACK for ADDBA Request sent/received
+		* 3: ADDBA Response sent/received
+		* 4: ACK for ADDBA Response sent/received
+		*/
+		wd->tid_rx[i]->addBaExchangeStatusCode = 0;
+	}
+
+	zmw_leave_critical_section(dev);
+	zfAggTallyReset(dev);
+	DESTQ.init = zfAggDestInit;
+	DESTQ.init(dev);
+	wd->aggInitiated = 1;
+	aggr_count = 0;
+	success_mpdu = 0;
+	total_mpdu = 0;
 #ifdef ZM_ENABLE_AGGREGATION
-#ifndef ZM_ENABLE_FW_BA_RETRANSMISSION //disable BAW
-    BAW = zfwMemAllocate(dev, sizeof(struct baw_enabler));
-    if(!BAW)
-    {
-        return;
-    }
-    BAW->init = zfBawInit;
-    BAW->init(dev);
-#endif //disable BAW
+#ifndef ZM_ENABLE_FW_BA_RETRANSMISSION /* disable BAW */
+	BAW = zfwMemAllocate(dev, sizeof(struct baw_enabler));
+	if (!BAW)
+		return;
+	BAW->init = zfBawInit;
+	BAW->init(dev);
+#endif /* disable BAW */
 #endif
 }
 
@@ -150,34 +143,32 @@ void zfAggInit(zdev_t* dev)
 
 
 
-u16_t zfAggGetSta(zdev_t* dev, zbuf_t* buf)
+u16_t zfAggGetSta(zdev_t *dev, zbuf_t *buf)
 {
-    u16_t id;
-    u16_t dst[3];
+	u16_t id;
+	u16_t dst[3];
 
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    zmw_declare_for_critical_section();
+	zmw_declare_for_critical_section();
 
-    dst[0] = zmw_rx_buf_readh(dev, buf, 0);
-    dst[1] = zmw_rx_buf_readh(dev, buf, 2);
-    dst[2] = zmw_rx_buf_readh(dev, buf, 4);
+	dst[0] = zmw_rx_buf_readh(dev, buf, 0);
+	dst[1] = zmw_rx_buf_readh(dev, buf, 2);
+	dst[2] = zmw_rx_buf_readh(dev, buf, 4);
 
-    zmw_enter_critical_section(dev);
+	zmw_enter_critical_section(dev);
 
-    if(wd->wlanMode == ZM_MODE_AP) {
-        id = zfApFindSta(dev, dst);
-    }
-    else {
-        id = 0;
-    }
-    zmw_leave_critical_section(dev);
+	if (wd->wlanMode == ZM_MODE_AP)
+		id = zfApFindSta(dev, dst);
+	else
+		id = 0;
+	zmw_leave_critical_section(dev);
 
 #if ZM_AGG_FPGA_DEBUG
-    id = 0;
+		id = 0;
 #endif
 
-    return id;
+	return id;
 }
 
 
@@ -199,30 +190,31 @@ u16_t zfAggGetSta(zdev_t* dev, zbuf_t* b
 /*      Honda               ZyDAS Technology Corporation    2006.11     */
 /*                                                                      */
 /************************************************************************/
-TID_TX zfAggTxGetQueue(zdev_t* dev, u16_t aid, u16_t tid)
+TID_TX zfAggTxGetQueue(zdev_t *dev, u16_t aid, u16_t tid)
 {
-    //u16_t   i;
-    TID_TX  tid_tx;
-    zmw_get_wlan_dev(dev);
+	/* u16_t   i; */
+	TID_TX  tid_tx;
+	zmw_get_wlan_dev(dev);
 
-    //zmw_declare_for_critical_section();
+	/* zmw_declare_for_critical_section(); */
 
-    /*
-     * not a STA aid
-     */
-    if (0xffff == aid)
-        return NULL;
+	/*
+	* not a STA aid
+	*/
+	if (0xffff == aid)
+		return NULL;
 
-    //zmw_enter_critical_section(dev);
+	/* zmw_enter_critical_section(dev); */
 
-    tid_tx = wd->aggSta[aid].tid_tx[tid];
-    if (!tid_tx) return NULL;
-    if (0 == tid_tx->aggQEnabled)
-        return NULL;
+	tid_tx = wd->aggSta[aid].tid_tx[tid];
+	if (!tid_tx)
+		return NULL;
+	if (0 == tid_tx->aggQEnabled)
+		return NULL;
 
-    //zmw_leave_critical_section(dev);
+	/* zmw_leave_critical_section(dev); */
 
-    return tid_tx;
+	return tid_tx;
 }
 
 /************************************************************************/
@@ -242,54 +234,50 @@ TID_TX zfAggTxGetQueue(zdev_t* dev, u16_
 /*      Honda               ZyDAS Technology Corporation    2006.12     */
 /*                                                                      */
 /************************************************************************/
-TID_TX zfAggTxNewQueue(zdev_t* dev, u16_t aid, u16_t tid, zbuf_t* buf)
+TID_TX zfAggTxNewQueue(zdev_t *dev, u16_t aid, u16_t tid, zbuf_t *buf)
 {
-    u16_t   i;
-    TID_TX  tid_tx=NULL;
-    u16_t   ac = zcUpToAc[tid&0x7] & 0x3;
-    zmw_get_wlan_dev(dev);
-
-    zmw_declare_for_critical_section();
-
-    /*
-     * not a STA aid
-     */
-    if (0xffff == aid)
-        return NULL;
-
-    zmw_enter_critical_section(dev);
-
-    /*
-     * find one new queue for sta
-     */
-    for (i=0; i<ZM_AGG_POOL_SIZE; i++)
-    {
-        if (wd->aggQPool[i]->aggQEnabled)
-        {
-                /*
-                 * this q is enabled
-                 */
-        }
-        else
-        {
-            tid_tx = wd->aggQPool[i];
-            tid_tx->aggQEnabled = 1;
-            tid_tx->aggQSTA = aid;
-            tid_tx->ac = ac;
-            tid_tx->tid = tid;
-            tid_tx->aggHead = tid_tx->aggTail = tid_tx->size = 0;
-            tid_tx->aggReady = 0;
-            wd->aggSta[aid].tid_tx[tid] = tid_tx;
-            tid_tx->dst[0] = zmw_rx_buf_readh(dev, buf, 0);
-            tid_tx->dst[1] = zmw_rx_buf_readh(dev, buf, 2);
-            tid_tx->dst[2] = zmw_rx_buf_readh(dev, buf, 4);
-            break;
-        }
-    }
+	u16_t i;
+	TID_TX  tid_tx = NULL;
+	u16_t   ac = zcUpToAc[tid&0x7] & 0x3;
+	zmw_get_wlan_dev(dev);
+
+	zmw_declare_for_critical_section();
+
+	/*
+	* not a STA aid
+	*/
+	if (0xffff == aid)
+		return NULL;
+
+	zmw_enter_critical_section(dev);
+
+	/*
+	* find one new queue for sta
+	*/
+	for (i = 0; i < ZM_AGG_POOL_SIZE; i++) {
+		if (wd->aggQPool[i]->aggQEnabled) {
+			/*
+			* this q is enabled
+			*/
+		} else {
+			tid_tx = wd->aggQPool[i];
+			tid_tx->aggQEnabled = 1;
+			tid_tx->aggQSTA = aid;
+			tid_tx->ac = ac;
+			tid_tx->tid = tid;
+			tid_tx->aggHead = tid_tx->aggTail = tid_tx->size = 0;
+			tid_tx->aggReady = 0;
+			wd->aggSta[aid].tid_tx[tid] = tid_tx;
+			tid_tx->dst[0] = zmw_rx_buf_readh(dev, buf, 0);
+			tid_tx->dst[1] = zmw_rx_buf_readh(dev, buf, 2);
+			tid_tx->dst[2] = zmw_rx_buf_readh(dev, buf, 4);
+			break;
+		}
+	}
 
-    zmw_leave_critical_section(dev);
+	zmw_leave_critical_section(dev);
 
-    return tid_tx;
+	return tid_tx;
 }
 
 
@@ -314,543 +302,546 @@ TID_TX zfAggTxNewQueue(zdev_t* dev, u16_
 /*      Honda               Atheros Communications, INC.    2006.12     */
 /*                                                                      */
 /************************************************************************/
-u16_t zfAggTxEnqueue(zdev_t* dev, zbuf_t* buf, u16_t aid, TID_TX tid_tx)
+u16_t zfAggTxEnqueue(zdev_t *dev, zbuf_t *buf, u16_t aid, TID_TX tid_tx)
 {
-    //u16_t   qlen, frameLen;
-    u32_t   time;
+	/* u16_t   qlen, frameLen; */
+	u32_t time;
 
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    zmw_declare_for_critical_section();
+	zmw_declare_for_critical_section();
 
-    zmw_enter_critical_section(dev);
-
-    tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail);
-
-    if (tid_tx->size < (ZM_AGGQ_SIZE - 2))
-    {
-        /* Queue not full */
-
-
-        /*
-         * buffer copy
-         * in zfwBufFree will return a ndismsendcomplete
-         * to resolve the synchronize problem in aggregate
-         */
-
-        u8_t    sendComplete = 0;
-
-        tid_tx->aggvtxq[tid_tx->aggHead].buf = buf;
-        time = zm_agg_GetTime();
-        tid_tx->aggvtxq[tid_tx->aggHead].arrivalTime = time;
-        tid_tx->aggvtxq[tid_tx->aggHead].baw_retransmit = 0;
-
-        tid_tx->aggHead = ((tid_tx->aggHead + 1) & ZM_AGGQ_SIZE_MASK);
-        tid_tx->lastArrival = time;
-        tid_tx->size++;
-        tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail);
-        if (buf && (tid_tx->size < (ZM_AGGQ_SIZE - 10))) {
-            tid_tx->complete = tid_tx->aggHead;
-            sendComplete = 1;
-        }
-        zmw_leave_critical_section(dev);
-
-        if (!DESTQ.exist(dev, 0, tid_tx->ac, tid_tx, NULL)) {
-            DESTQ.insert(dev, 0, tid_tx->ac, tid_tx, NULL);
-        }
-
-        zm_msg1_agg(ZM_LV_0, "tid_tx->size=", tid_tx->size);
-        //zm_debug_msg1("tid_tx->size=", tid_tx->size);
-
-        if (buf && sendComplete && wd->zfcbSendCompleteIndication) {
-            //zmw_leave_critical_section(dev);
-            wd->zfcbSendCompleteIndication(dev, buf);
-        }
-
-        /*if (tid_tx->size >= 16 && zfHpGetFreeTxdCount(dev) > 20)
-            zfAggTxSend(dev, zfHpGetFreeTxdCount(dev), tid_tx);
-        */
-        return ZM_SUCCESS;
-    }
-    else
-    {
-        zm_msg1_agg(ZM_LV_0, "can't enqueue, tid_tx->size=", tid_tx->size);
-        /*
-         * Queue Full
-         */
-
-        /*
-         * zm_msg1_agg(ZM_LV_0, "Queue full, qnum = ", qnum);
-         * wd->commTally.txQosDropCount[ac]++;
-         * zfwBufFree(dev, buf, ZM_SUCCESS);
-         * zm_msg1_agg(ZM_LV_1, "Packet discarded, VTXQ full, ac=", ac);
-         *
-         * return ZM_ERR_EXCEED_PRIORITY_THRESHOLD;
-         */
-    }
-
-    zmw_leave_critical_section(dev);
-
-    if (!DESTQ.exist(dev, 0, tid_tx->ac, tid_tx, NULL)) {
-            DESTQ.insert(dev, 0, tid_tx->ac, tid_tx, NULL);
-    }
-
-    return ZM_ERR_EXCEED_PRIORITY_THRESHOLD;
-}
-
-u16_t    zfAggDestExist(zdev_t* dev, u16_t Qtype, u16_t ac, TID_TX tid_tx, void* vtxq) {
-    struct dest* dest;
-    u16_t   exist = 0;
-    zmw_get_wlan_dev(dev);
-
-    zmw_declare_for_critical_section();
-
-    zmw_enter_critical_section(dev);
-    if (!DESTQ.Head[ac]) {
-        exist = 0;
-    }
-    else {
-        dest = DESTQ.Head[ac];
-        if (dest->tid_tx == tid_tx) {
-            exist = 1;
-        }
-        else {
-            while (dest->next != DESTQ.Head[ac]) {
-                dest = dest->next;
-                if (dest->tid_tx == tid_tx){
-                    exist = 1;
-                    break;
-                }
-            }
-        }
-    }
-
-    zmw_leave_critical_section(dev);
-
-    return exist;
-}
-
-void    zfAggDestInsert(zdev_t* dev, u16_t Qtype, u16_t ac, TID_TX tid_tx, void* vtxq)
-{
-    struct dest* new_dest;
-    zmw_get_wlan_dev(dev);
-
-    zmw_declare_for_critical_section();
-
-    new_dest = zfwMemAllocate(dev, sizeof(struct dest));
-    if(!new_dest)
-    {
-        return;
-    }
-    new_dest->Qtype = Qtype;
-    new_dest->tid_tx = tid_tx;
-    if (0 == Qtype)
-        new_dest->tid_tx = tid_tx;
-    else
-        new_dest->vtxq = vtxq;
-    if (!DESTQ.Head[ac]) {
-
-        zmw_enter_critical_section(dev);
-        new_dest->next = new_dest;
-        DESTQ.Head[ac] = DESTQ.dest[ac] = new_dest;
-        zmw_leave_critical_section(dev);
-    }
-    else {
-
-        zmw_enter_critical_section(dev);
-        new_dest->next = DESTQ.dest[ac]->next;
-        DESTQ.dest[ac]->next = new_dest;
-        zmw_leave_critical_section(dev);
-    }
-
-
-    //DESTQ.size[ac]++;
-    return;
-}
-
-void    zfAggDestDelete(zdev_t* dev, u16_t Qtype, TID_TX tid_tx, void* vtxq)
-{
-    struct dest* dest, *temp;
-    u16_t   i;
-
-    zmw_get_wlan_dev(dev);
-
-    zmw_declare_for_critical_section();
-
-    zmw_enter_critical_section(dev);
-    if (wd->destLock) {
-        zmw_leave_critical_section(dev);
-        return;
-    }
-
-
-    //zmw_declare_for_critical_section();
-    for (i=0; i<4; i++) {
-        if (!DESTQ.Head[i]) continue;
-        dest = DESTQ.Head[i];
-        if (!dest) continue;
-
-
-        while (dest && (dest->next != DESTQ.Head[i])) {
-            if (Qtype == 0 && dest->next->tid_tx == tid_tx){
-                break;
-            }
-            if (Qtype == 1 && dest->next->vtxq == vtxq) {
-                break;
-            }
-            dest = dest->next;
-        }
-
-        if ((Qtype == 0 && dest->next->tid_tx == tid_tx) || (Qtype == 1 && dest->next->vtxq == vtxq)) {
-
-            tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail);
-            if (tid_tx->size) {
-                zmw_leave_critical_section(dev);
-                return;
-            }
-            if (!DESTQ.Head[i]) {
-                temp = NULL;
-            }
-            else {
-                temp = dest->next;
-                if (temp == dest) {
-                    DESTQ.Head[i] = DESTQ.dest[i] = NULL;
-                    //DESTQ.size[i] = 0;
-                }
-                else {
-                    dest->next = dest->next->next;
-                }
-            }
-
-            if (temp == NULL)
-                {/* do nothing */} //zfwMemFree(dev, temp, sizeof(struct dest));
-            else
-                zfwMemFree(dev, temp, sizeof(struct dest));
-
-            /*zmw_enter_critical_section(dev);
-            if (DESTQ.size[i] > 0)
-                DESTQ.size[i]--;
-            zmw_leave_critical_section(dev);
-            */
-        }
-
-    }
-    zmw_leave_critical_section(dev);
-    return;
-}
-
-void    zfAggDestInit(zdev_t* dev)
-{
-    u16_t i;
-    zmw_get_wlan_dev(dev);
-
-    //zmw_declare_for_critical_section();
-
-    for (i=0; i<4; i++) {
-        //wd->destQ.Head[i].next = wd->destQ.Head[i];
-        //wd->destQ.dest[i] = wd->destQ.Head[i];
-        //DESTQ.size[i] = 0;
-        DESTQ.Head[i] = NULL;
-    }
-    DESTQ.insert  = zfAggDestInsert;
-    DESTQ.delete  = zfAggDestDelete;
-    DESTQ.init    = zfAggDestInit;
-    DESTQ.getNext = zfAggDestGetNext;
-    DESTQ.exist   = zfAggDestExist;
-    DESTQ.ppri = 0;
-    return;
-}
-
-struct dest* zfAggDestGetNext(zdev_t* dev, u16_t ac)
-{
-    struct dest *dest = NULL;
-    zmw_get_wlan_dev(dev);
-
-    zmw_declare_for_critical_section();
-
-    zmw_enter_critical_section(dev);
-    if (DESTQ.dest[ac]) {
-        dest = DESTQ.dest[ac];
-        DESTQ.dest[ac] = DESTQ.dest[ac]->next;
-    }
-    else {
-        dest = NULL;
-    }
-    zmw_leave_critical_section(dev);
+	zmw_enter_critical_section(dev);
+
+	tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail);
+
+	if (tid_tx->size < (ZM_AGGQ_SIZE - 2)) {
+		/* Queue not full */
+
+
+		/*
+		* buffer copy
+		* in zfwBufFree will return a ndismsendcomplete
+		* to resolve the synchronize problem in aggregate
+		*/
+
+		u8_t    sendComplete = 0;
+
+		tid_tx->aggvtxq[tid_tx->aggHead].buf = buf;
+		time = zm_agg_GetTime();
+		tid_tx->aggvtxq[tid_tx->aggHead].arrivalTime = time;
+		tid_tx->aggvtxq[tid_tx->aggHead].baw_retransmit = 0;
+
+		tid_tx->aggHead = ((tid_tx->aggHead + 1) & ZM_AGGQ_SIZE_MASK);
+		tid_tx->lastArrival = time;
+		tid_tx->size++;
+		tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead,
+							tid_tx->aggTail);
+		if (buf && (tid_tx->size < (ZM_AGGQ_SIZE - 10))) {
+			tid_tx->complete = tid_tx->aggHead;
+			sendComplete = 1;
+		}
+		zmw_leave_critical_section(dev);
+
+		if (!DESTQ.exist(dev, 0, tid_tx->ac, tid_tx, NULL))
+			DESTQ.insert(dev, 0, tid_tx->ac, tid_tx, NULL);
+
+		zm_msg1_agg(ZM_LV_0, "tid_tx->size=", tid_tx->size);
+		/* zm_debug_msg1("tid_tx->size=", tid_tx->size); */
+
+		if (buf && sendComplete && wd->zfcbSendCompleteIndication) {
+			/* zmw_leave_critical_section(dev); */
+			wd->zfcbSendCompleteIndication(dev, buf);
+		}
+
+		/*if (tid_tx->size >= 16 && zfHpGetFreeTxdCount(dev) > 20)
+		* zfAggTxSend(dev, zfHpGetFreeTxdCount(dev), tid_tx);
+		*/
+		return ZM_SUCCESS;
+	} else {
+		zm_msg1_agg(ZM_LV_0, "can't enqueue, tid_tx->size=",
+								tid_tx->size);
+		/*
+		* Queue Full
+		*/
+
+		/*
+		* zm_msg1_agg(ZM_LV_0, "Queue full, qnum = ", qnum);
+		* wd->commTally.txQosDropCount[ac]++;
+		* zfwBufFree(dev, buf, ZM_SUCCESS);
+		* zm_msg1_agg(ZM_LV_1, "Packet discarded, VTXQ full, ac=", ac);
+		*
+		* return ZM_ERR_EXCEED_PRIORITY_THRESHOLD;
+		*/
+	}
+
+	zmw_leave_critical_section(dev);
+
+	if (!DESTQ.exist(dev, 0, tid_tx->ac, tid_tx, NULL))
+		DESTQ.insert(dev, 0, tid_tx->ac, tid_tx, NULL);
+
+	return ZM_ERR_EXCEED_PRIORITY_THRESHOLD;
+}
+
+u16_t zfAggDestExist(zdev_t *dev, u16_t Qtype, u16_t ac, TID_TX tid_tx,
+			void *vtxq)
+{
+	struct dest *dest;
+	u16_t   exist = 0;
+	zmw_get_wlan_dev(dev);
+
+	zmw_declare_for_critical_section();
+
+	zmw_enter_critical_section(dev);
+	if (!DESTQ.Head[ac]) {
+		exist = 0;
+	} else {
+		dest = DESTQ.Head[ac];
+		if (dest->tid_tx == tid_tx) {
+			exist = 1;
+		} else {
+			while (dest->next != DESTQ.Head[ac]) {
+				dest = dest->next;
+				if (dest->tid_tx == tid_tx) {
+					exist = 1;
+					break;
+				}
+			}
+		}
+	}
+
+	zmw_leave_critical_section(dev);
+
+	return exist;
+}
+
+void zfAggDestInsert(zdev_t *dev, u16_t Qtype, u16_t ac, TID_TX tid_tx,
+			void *vtxq)
+{
+	struct dest *new_dest;
+	zmw_get_wlan_dev(dev);
+
+	zmw_declare_for_critical_section();
+
+	new_dest = zfwMemAllocate(dev, sizeof(struct dest));
+	if (!new_dest)
+		return;
+
+	new_dest->Qtype = Qtype;
+	new_dest->tid_tx = tid_tx;
+	if (0 == Qtype)
+		new_dest->tid_tx = tid_tx;
+	else
+		new_dest->vtxq = vtxq;
+
+	if (!DESTQ.Head[ac]) {
+		zmw_enter_critical_section(dev);
+		new_dest->next = new_dest;
+		DESTQ.Head[ac] = DESTQ.dest[ac] = new_dest;
+		zmw_leave_critical_section(dev);
+	} else {
+		zmw_enter_critical_section(dev);
+		new_dest->next = DESTQ.dest[ac]->next;
+		DESTQ.dest[ac]->next = new_dest;
+		zmw_leave_critical_section(dev);
+	}
+
+
+	/* DESTQ.size[ac]++; */
+	return;
+}
+
+void zfAggDestDelete(zdev_t *dev, u16_t Qtype, TID_TX tid_tx, void *vtxq)
+{
+	struct dest *dest, *temp;
+	u16_t i;
+
+	zmw_get_wlan_dev(dev);
+
+	zmw_declare_for_critical_section();
+
+	zmw_enter_critical_section(dev);
+	if (wd->destLock) {
+		zmw_leave_critical_section(dev);
+		return;
+	}
+
+
+	/* zmw_declare_for_critical_section(); */
+	for (i = 0; i < 4; i++) {
+		if (!DESTQ.Head[i])
+			continue;
+		dest = DESTQ.Head[i];
+		if (!dest)
+			continue;
+
+		while (dest && (dest->next != DESTQ.Head[i])) {
+			if (Qtype == 0 && dest->next->tid_tx == tid_tx)
+				break;
+			if (Qtype == 1 && dest->next->vtxq == vtxq)
+				break;
+			dest = dest->next;
+		}
+
+		if ((Qtype == 0 && dest->next->tid_tx == tid_tx) ||
+			(Qtype == 1 && dest->next->vtxq == vtxq)) {
+
+			tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead,
+							tid_tx->aggTail);
+			if (tid_tx->size) {
+				zmw_leave_critical_section(dev);
+				return;
+			}
+			if (!DESTQ.Head[i]) {
+				temp = NULL;
+			} else {
+				temp = dest->next;
+				if (temp == dest) {
+					DESTQ.Head[i] = DESTQ.dest[i] = NULL;
+					/* DESTQ.size[i] = 0; */
+				} else {
+					dest->next = dest->next->next;
+				}
+			}
+
+			if (temp == NULL) {
+				/* do nothing
+				* zfwMemFree(dev, temp,
+				* sizeof(struct dest));
+				*/
+			} else
+				zfwMemFree(dev, temp, sizeof(struct dest));
+
+			/*zmw_enter_critical_section(dev);
+			* if (DESTQ.size[i] > 0)
+			* 	DESTQ.size[i]--;
+			* zmw_leave_critical_section(dev);
+			*/
+		}
+
+	}
+	zmw_leave_critical_section(dev);
+	return;
+}
+
+void zfAggDestInit(zdev_t *dev)
+{
+	u16_t i;
+	zmw_get_wlan_dev(dev);
+
+	/* zmw_declare_for_critical_section(); */
+
+	for (i = 0; i < 4; i++) {
+		/* wd->destQ.Head[i].next = wd->destQ.Head[i]; */
+		/* wd->destQ.dest[i] = wd->destQ.Head[i]; */
+		/* DESTQ.size[i] = 0; */
+		DESTQ.Head[i] = NULL;
+	}
+	DESTQ.insert  = zfAggDestInsert;
+	DESTQ.delete  = zfAggDestDelete;
+	DESTQ.init    = zfAggDestInit;
+	DESTQ.getNext = zfAggDestGetNext;
+	DESTQ.exist   = zfAggDestExist;
+	DESTQ.ppri = 0;
+	return;
+}
+
+struct dest *zfAggDestGetNext(zdev_t *dev, u16_t ac)
+{
+	struct dest *dest = NULL;
+	zmw_get_wlan_dev(dev);
+
+	zmw_declare_for_critical_section();
+
+	zmw_enter_critical_section(dev);
+	if (DESTQ.dest[ac]) {
+		dest = DESTQ.dest[ac];
+		DESTQ.dest[ac] = DESTQ.dest[ac]->next;
+	} else
+		dest = NULL;
 
-    return dest;
+	zmw_leave_critical_section(dev);
+
+	return dest;
 }
 
 #ifdef ZM_ENABLE_AGGREGATION
-#ifndef ZM_ENABLE_FW_BA_RETRANSMISSION //disable BAW
-u16_t   zfAggTidTxInsertHead(zdev_t* dev, struct bufInfo *buf_info,TID_TX tid_tx)
+#ifndef ZM_ENABLE_FW_BA_RETRANSMISSION /* disable BAW */
+u16_t zfAggTidTxInsertHead(zdev_t *dev, struct bufInfo *buf_info, TID_TX tid_tx)
+{
+	zbuf_t *buf;
+	u32_t time;
+	struct baw_header *baw_header;
+
+	zmw_get_wlan_dev(dev);
+
+	zmw_declare_for_critical_section();
+
+	buf = buf_info->buf;
+
+	zmw_enter_critical_section(dev);
+	tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail);
+	zmw_leave_critical_section(dev);
+
+	if (tid_tx->size >= (ZM_AGGQ_SIZE - 2)) {
+		zfwBufFree(dev, buf, ZM_SUCCESS);
+		return 0;
+	}
+
+	zmw_enter_critical_section(dev);
+	tid_tx->aggTail = (tid_tx->aggTail == 0) ? ZM_AGGQ_SIZE_MASK :
+							tid_tx->aggTail - 1;
+	tid_tx->aggvtxq[tid_tx->aggTail].buf = buf;
+	/* time = zm_agg_GetTime(); */
+	tid_tx->aggvtxq[tid_tx->aggTail].arrivalTime = buf_info->timestamp;
+	tid_tx->aggvtxq[tid_tx->aggTail].baw_retransmit =
+						buf_info->baw_retransmit;
+
+	baw_header = &tid_tx->aggvtxq[tid_tx->aggTail].baw_header;
+	baw_header->headerLen   = buf_info->baw_header->headerLen;
+	baw_header->micLen      = buf_info->baw_header->micLen;
+	baw_header->snapLen     = buf_info->baw_header->snapLen;
+	baw_header->removeLen   = buf_info->baw_header->removeLen;
+	baw_header->keyIdx      = buf_info->baw_header->keyIdx;
+	zfwMemoryCopy((u8_t *)baw_header->header,
+				(u8_t *)buf_info->baw_header->header, 58);
+	zfwMemoryCopy((u8_t *)baw_header->mic,
+				(u8_t *)buf_info->baw_header->mic   , 8);
+	zfwMemoryCopy((u8_t *)baw_header->snap,
+				(u8_t *)buf_info->baw_header->snap  , 8);
+
+	tid_tx->size++;
+	tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail);
+	zmw_leave_critical_section(dev);
+
+	/* tid_tx->lastArrival = time; */
+	if (1 == tid_tx->size)
+		DESTQ.insert(dev, 0, tid_tx->ac, tid_tx, NULL);
+
+	zm_msg1_agg(ZM_LV_0, "0xC2:insertHead, tid_tx->size=", tid_tx->size);
+
+	return TRUE;
+}
+#endif /* disable BAW */
+#endif
+
+void zfiTxComplete(zdev_t *dev)
 {
-    zbuf_t* buf;
-    u32_t time;
-    struct baw_header *baw_header;
-
-    zmw_get_wlan_dev(dev);
-
-    zmw_declare_for_critical_section();
-
-
-    buf = buf_info->buf;
-
-    zmw_enter_critical_section(dev);
-    tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail);
-    zmw_leave_critical_section(dev);
-
-    if (tid_tx->size >= (ZM_AGGQ_SIZE - 2)) {
-        zfwBufFree(dev, buf, ZM_SUCCESS);
-        return 0;
-    }
-
-    zmw_enter_critical_section(dev);
-    tid_tx->aggTail = (tid_tx->aggTail == 0)? ZM_AGGQ_SIZE_MASK: tid_tx->aggTail - 1;
-    tid_tx->aggvtxq[tid_tx->aggTail].buf = buf;
-    //time = zm_agg_GetTime();
-    tid_tx->aggvtxq[tid_tx->aggTail].arrivalTime = buf_info->timestamp;
-    tid_tx->aggvtxq[tid_tx->aggTail].baw_retransmit = buf_info->baw_retransmit;
-
-    baw_header = &tid_tx->aggvtxq[tid_tx->aggTail].baw_header;
-    baw_header->headerLen   = buf_info->baw_header->headerLen;
-    baw_header->micLen      = buf_info->baw_header->micLen;
-    baw_header->snapLen     = buf_info->baw_header->snapLen;
-    baw_header->removeLen   = buf_info->baw_header->removeLen;
-    baw_header->keyIdx      = buf_info->baw_header->keyIdx;
-    zfwMemoryCopy((u8_t *)baw_header->header, (u8_t *)buf_info->baw_header->header, 58);
-    zfwMemoryCopy((u8_t *)baw_header->mic   , (u8_t *)buf_info->baw_header->mic   , 8);
-    zfwMemoryCopy((u8_t *)baw_header->snap  , (u8_t *)buf_info->baw_header->snap  , 8);
-
-    tid_tx->size++;
-    tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail);
-    zmw_leave_critical_section(dev);
-
-    //tid_tx->lastArrival = time;
-    if (1 == tid_tx->size) {
-        DESTQ.insert(dev, 0, tid_tx->ac, tid_tx, NULL);
-    }
-
-
-    zm_msg1_agg(ZM_LV_0, "0xC2:insertHead, tid_tx->size=", tid_tx->size);
-
-    return TRUE;
-}
-#endif //disable BAW
-#endif
-
-void    zfiTxComplete(zdev_t* dev)
-{
-
-    zmw_get_wlan_dev(dev);
-
-    //zmw_declare_for_critical_section();
-
-    if( (wd->wlanMode == ZM_MODE_AP) ||
-        (wd->wlanMode == ZM_MODE_INFRASTRUCTURE && wd->sta.EnableHT) ||
-        (wd->wlanMode == ZM_MODE_PSEUDO) ) {
-        zfAggTxScheduler(dev, 0);
-    }
-
-    return;
-}
-
-TID_TX  zfAggTxReady(zdev_t* dev) {
-    //struct dest* dest;
-    u16_t   i;
-    TID_TX  tid_tx = NULL;
-    zmw_get_wlan_dev(dev);
-
-    zmw_declare_for_critical_section();
-
-    zmw_enter_critical_section(dev);
-    for (i=0; i<ZM_AGG_POOL_SIZE; i++)
-    {
-        if (wd->aggQPool[i]->aggQEnabled)
-        {
-            if (wd->aggQPool[i]->size >= 16) {
-                tid_tx = wd->aggQPool[i];
-                break;
-            }
-        }
-        else {
-        }
-    }
-    zmw_leave_critical_section(dev);
-    return tid_tx;
-}
-
-u16_t   zfAggValidTidTx(zdev_t* dev, TID_TX tid_tx) {
-    u16_t   i, valid = 0;
-    zmw_get_wlan_dev(dev);
-
-    zmw_declare_for_critical_section();
-
-    zmw_enter_critical_section(dev);
-    for (i=0; i<ZM_AGG_POOL_SIZE; i++)
-    {
-        if (wd->aggQPool[i] == tid_tx)
-        {
-            valid = 1;
-            break;
-        }
-        else {
-        }
-    }
-    zmw_leave_critical_section(dev);
-
-    return valid;
-}
-
-void    zfAggTxScheduler(zdev_t* dev, u8_t ScanAndClear)
-{
-    TID_TX  tid_tx = NULL;
-    void*   vtxq;
-    struct dest* dest;
-    zbuf_t*  buf;
-    u32_t txql, min_txql;
-    //u16_t aggr_size = 1;
-    u16_t txq_threshold;
-    zmw_get_wlan_dev(dev);
-
-    zmw_declare_for_critical_section();
-
-    if (!wd->aggInitiated)
-    {
-        return;
-    }
-
-    /* debug */
-    txql = TXQL;
-    min_txql = AGG_MIN_TXQL;
-
-    if(wd->txq_threshold)
-        txq_threshold = wd->txq_threshold;
-    else
-        txq_threshold = AGG_MIN_TXQL;
-
-    tid_tx = zfAggTxReady(dev);
-    if (tid_tx) ScanAndClear = 0;
-    while (zfHpGetFreeTxdCount(dev) > 20 && (TXQL < txq_threshold || tid_tx)) {
-    //while (zfHpGetFreeTxdCount(dev) > 20 && (ScanAndClear || tid_tx)) {
-    //while (TXQL < txq_threshold) {
-        u16_t i;
-        u8_t ac;
-        s8_t destQ_count = 0;
-    //while ((zfHpGetFreeTxdCount(dev)) > 32) {
-
-        //DbgPrint("zfAggTxScheduler: in while loop");
-        for (i=0; i<4; i++) {
-            if (DESTQ.Head[i]) destQ_count++;
-        }
-        if (0 >= destQ_count) break;
-
-        zmw_enter_critical_section(dev);
-        ac = pri[DESTQ.ppri]; DESTQ.ppri = (DESTQ.ppri + 1) % 10;
-        zmw_leave_critical_section(dev);
-
-        for (i=0; i<10; i++){
-            if(DESTQ.Head[ac]) break;
-
-            zmw_enter_critical_section(dev);
-            ac = pri[DESTQ.ppri]; DESTQ.ppri = (DESTQ.ppri + 1) % 10;
-            zmw_leave_critical_section(dev);
-        }
-        if (i == 10) break;
-        //DbgPrint("zfAggTxScheduler: have dest Q");
-        zmw_enter_critical_section(dev);
-        wd->destLock = 1;
-        zmw_leave_critical_section(dev);
-
-        dest = DESTQ.getNext(dev, ac);
-        if (!dest) {
-            zmw_enter_critical_section(dev);
-            wd->destLock = 0;
-            zmw_leave_critical_section(dev);
-
-            DbgPrint("bug report! DESTQ.getNext got nothing!");
-            break;
-        }
-        if (dest->Qtype == 0) {
-            tid_tx = dest->tid_tx;
-
-            //DbgPrint("zfAggTxScheduler: have tid_tx Q");
-
-            if(tid_tx && zfAggValidTidTx(dev, tid_tx))
-                tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail);
-            else {
-                zmw_enter_critical_section(dev);
-                wd->destLock = 0;
-                zmw_leave_critical_section(dev);
-
-                tid_tx = zfAggTxReady(dev);
-                continue;
-            }
-
-            zmw_enter_critical_section(dev);
-            wd->destLock = 0;
-            zmw_leave_critical_section(dev);
-            //zmw_enter_critical_section(dev);
-            if (tid_tx && !tid_tx->size) {
-
-                //zmw_leave_critical_section(dev);
-                //DESTQ.delete(dev, 0, tid_tx, NULL);
-            }
-            else if(wd->aggState == 0){
-                //wd->aggState = 1;
-                //zmw_leave_critical_section(dev);
-                zfAggTxSend(dev, zfHpGetFreeTxdCount(dev), tid_tx);
-                //wd->aggState = 0;
-            }
-            else {
-                //zmw_leave_critical_section(dev);
-                break;
-            }
-        }
-        else {
-            vtxq = dest->vtxq;
-            buf = zfGetVtxq(dev, ac);
-            zm_assert( buf != 0 );
-
-            zfTxSendEth(dev, buf, 0, ZM_EXTERNAL_ALLOC_BUF, 0);
-
-        }
-        /*flush all but < 16 frames in tid_tx to TXQ*/
-        tid_tx = zfAggTxReady(dev);
-    }
-
-    /*while ((zfHpGetFreeTxdCount(dev)) > 32) {
-    //while ((zfHpGetFreeTxdCount(dev)) > 32) {
-
-        destQ_count = 0;
-        for (i=0; i<4; i++) destQ_count += wd->destQ.size[i];
-        if (0 >= destQ_count) break;
-
-        ac = pri[wd->destQ.ppri]; wd->destQ.ppri = (wd->destQ.ppri + 1) % 10;
-        for (i=0; i<10; i++){
-            if(wd->destQ.size[ac]!=0) break;
-            ac = pri[wd->destQ.ppri]; wd->destQ.ppri = (wd->destQ.ppri + 1) % 10;
-        }
-        if (i == 10) break;
-        dest = wd->destQ.getNext(dev, ac);
-        if (dest->Qtype == 0) {
-            tid_tx = dest->tid_tx;
-            tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail);
-            if (!tid_tx->size) {
-                wd->destQ.delete(dev, 0, tid_tx, NULL);
-                break;
-            }
-            else if((wd->aggState == 0) && (tid_tx->size >= 16)){
-                zfAggTxSend(dev, zfHpGetFreeTxdCount(dev), tid_tx);
-            }
-            else {
-                break;
-            }
-        }
-
-    }
-    */
-    return;
+	zmw_get_wlan_dev(dev);
+
+	/* zmw_declare_for_critical_section(); */
+
+	if ((wd->wlanMode == ZM_MODE_AP) ||
+		(wd->wlanMode == ZM_MODE_INFRASTRUCTURE && wd->sta.EnableHT) ||
+		(wd->wlanMode == ZM_MODE_PSEUDO))
+		zfAggTxScheduler(dev, 0);
+
+	return;
+}
+
+TID_TX zfAggTxReady(zdev_t *dev)
+{
+	/* struct dest* dest; */
+	u16_t   i;
+	TID_TX  tid_tx = NULL;
+	zmw_get_wlan_dev(dev);
+
+	zmw_declare_for_critical_section();
+
+	zmw_enter_critical_section(dev);
+	for (i = 0; i < ZM_AGG_POOL_SIZE; i++) {
+		if (wd->aggQPool[i]->aggQEnabled) {
+			if (wd->aggQPool[i]->size >= 16) {
+				tid_tx = wd->aggQPool[i];
+				break;
+			}
+		} else {
+		}
+	}
+
+	zmw_leave_critical_section(dev);
+	return tid_tx;
+}
+
+u16_t zfAggValidTidTx(zdev_t *dev, TID_TX tid_tx)
+{
+	u16_t i, valid = 0;
+	zmw_get_wlan_dev(dev);
+
+	zmw_declare_for_critical_section();
+
+	zmw_enter_critical_section(dev);
+
+	for (i = 0; i < ZM_AGG_POOL_SIZE; i++) {
+		if (wd->aggQPool[i] == tid_tx) {
+			valid = 1;
+			break;
+		} else {
+		}
+	}
+
+	zmw_leave_critical_section(dev);
+
+	return valid;
+}
+
+void zfAggTxScheduler(zdev_t *dev, u8_t ScanAndClear)
+{
+	TID_TX  tid_tx = NULL;
+	void *vtxq;
+	struct dest *dest;
+	zbuf_t *buf;
+	u32_t txql, min_txql;
+	/* u16_t aggr_size = 1; */
+	u16_t txq_threshold;
+	zmw_get_wlan_dev(dev);
+
+	zmw_declare_for_critical_section();
+
+	if (!wd->aggInitiated)
+		return;
+
+	/* debug */
+	txql = TXQL;
+	min_txql = AGG_MIN_TXQL;
+
+	if (wd->txq_threshold)
+		txq_threshold = wd->txq_threshold;
+	else
+		txq_threshold = AGG_MIN_TXQL;
+
+	tid_tx = zfAggTxReady(dev);
+	if (tid_tx)
+		ScanAndClear = 0;
+	while (zfHpGetFreeTxdCount(dev) > 20 &&
+					(TXQL < txq_threshold || tid_tx)) {
+		/* while (zfHpGetFreeTxdCount(dev) > 20
+		*		&& (ScanAndClear || tid_tx)) {
+		* while (TXQL < txq_threshold) {
+		*/
+		u16_t i;
+		u8_t ac;
+		s8_t destQ_count = 0;
+		/* while ((zfHpGetFreeTxdCount(dev)) > 32) { */
+
+		/* DbgPrint("zfAggTxScheduler: in while loop"); */
+		for (i = 0; i < 4; i++) {
+			if (DESTQ.Head[i])
+				destQ_count++;
+		}
+		if (0 >= destQ_count)
+			break;
+
+		zmw_enter_critical_section(dev);
+		ac = pri[DESTQ.ppri];
+		DESTQ.ppri = (DESTQ.ppri + 1) % 10;
+		zmw_leave_critical_section(dev);
+
+		for (i = 0; i < 10; i++) {
+			if (DESTQ.Head[ac])
+				break;
+
+			zmw_enter_critical_section(dev);
+			ac = pri[DESTQ.ppri];
+			DESTQ.ppri = (DESTQ.ppri + 1) % 10;
+			zmw_leave_critical_section(dev);
+		}
+		if (i == 10)
+			break;
+		/* DbgPrint("zfAggTxScheduler: have dest Q"); */
+		zmw_enter_critical_section(dev);
+		wd->destLock = 1;
+		zmw_leave_critical_section(dev);
+
+		dest = DESTQ.getNext(dev, ac);
+		if (!dest) {
+			zmw_enter_critical_section(dev);
+			wd->destLock = 0;
+			zmw_leave_critical_section(dev);
+
+			DbgPrint("bug report! DESTQ.getNext got nothing!");
+			break;
+		}
+		if (dest->Qtype == 0) {
+			tid_tx = dest->tid_tx;
+
+			/* DbgPrint("zfAggTxScheduler: have tid_tx Q"); */
+
+			if (tid_tx && zfAggValidTidTx(dev, tid_tx))
+				tid_tx->size = zm_agg_qlen(dev,
+					tid_tx->aggHead, tid_tx->aggTail);
+			else {
+				zmw_enter_critical_section(dev);
+				wd->destLock = 0;
+				zmw_leave_critical_section(dev);
+
+				tid_tx = zfAggTxReady(dev);
+				continue;
+			}
+
+			zmw_enter_critical_section(dev);
+			wd->destLock = 0;
+			zmw_leave_critical_section(dev);
+			/* zmw_enter_critical_section(dev); */
+			if (tid_tx && !tid_tx->size) {
+				/* zmw_leave_critical_section(dev); */
+				/* DESTQ.delete(dev, 0, tid_tx, NULL); */
+			} else if (wd->aggState == 0) {
+				/* wd->aggState = 1; */
+				/* zmw_leave_critical_section(dev); */
+				zfAggTxSend(dev,
+				zfHpGetFreeTxdCount(dev), tid_tx);
+				/* wd->aggState = 0; */
+			} else {
+				/* zmw_leave_critical_section(dev); */
+				break;
+			}
+		} else {
+			vtxq = dest->vtxq;
+			buf = zfGetVtxq(dev, ac);
+			zm_assert(buf != 0);
+
+			zfTxSendEth(dev, buf, 0, ZM_EXTERNAL_ALLOC_BUF, 0);
+
+		}
+		/* flush all but < 16 frames in tid_tx to TXQ */
+		tid_tx = zfAggTxReady(dev);
+	}
+
+	/* while ((zfHpGetFreeTxdCount(dev)) > 32) {
+	while ((zfHpGetFreeTxdCount(dev)) > 32) {
+
+	destQ_count = 0;
+	for (i=0; i<4; i++) destQ_count += wd->destQ.size[i];
+	if (0 >= destQ_count) break;
+
+	ac = pri[wd->destQ.ppri]; wd->destQ.ppri = (wd->destQ.ppri + 1) % 10;
+	for (i=0; i<10; i++){
+		if(wd->destQ.size[ac]!=0) break;
+		ac = pri[wd->destQ.ppri]; wd->destQ.ppri = (wd->destQ.ppri + 1)
+									% 10;
+	}
+	if (i == 10) break;
+	dest = wd->destQ.getNext(dev, ac);
+	if (dest->Qtype == 0) {
+		tid_tx = dest->tid_tx;
+		tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead,
+							tid_tx->aggTail);
+		if (!tid_tx->size) {
+			wd->destQ.delete(dev, 0, tid_tx, NULL);
+			break;
+		}
+		else if((wd->aggState == 0) && (tid_tx->size >= 16)){
+		zfAggTxSend(dev, zfHpGetFreeTxdCount(dev), tid_tx);
+		}
+		else {
+		break;
+		}
+	}
+
+	}
+	*/
+	return;
 }
 
 /************************************************************************/
@@ -875,137 +866,127 @@ void    zfAggTxScheduler(zdev_t* dev, u8
 /*      Honda               Atheros Communications, INC.    2006.12     */
 /*                                                                      */
 /************************************************************************/
-u16_t zfAggTx(zdev_t* dev, zbuf_t* buf, u16_t tid)
+u16_t zfAggTx(zdev_t *dev, zbuf_t *buf, u16_t tid)
 {
-    u16_t aid;
-    //u16_t qnum;
-    //u16_t aggflag = 0;
-    //u16_t arrivalrate = 0;
-    TID_TX tid_tx;
+	u16_t aid;
+	/* u16_t qnum; */
+	/* u16_t aggflag = 0; */
+	/* u16_t arrivalrate = 0; */
+	TID_TX tid_tx;
 
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    zmw_declare_for_critical_section();
+	zmw_declare_for_critical_section();
 
-    if(!wd->aggInitiated)
-    {
-        return ZM_ERR_TX_BUFFER_UNAVAILABLE;
-    }
+	if (!wd->aggInitiated)
+		return ZM_ERR_TX_BUFFER_UNAVAILABLE;
 
-    aid = zfAggGetSta(dev, buf);
+	aid = zfAggGetSta(dev, buf);
 
-    //arrivalrate = zfAggTxArrivalRate(dev, aid, tid);
+	/* arrivalrate = zfAggTxArrivalRate(dev, aid, tid); */
 
-    if (0xffff == aid)
-    {
-        /*
-         * STA not associated, this is a BC/MC or STA->AP packet
-         */
+	if (0xffff == aid) {
+		/*
+		* STA not associated, this is a BC/MC or STA->AP packet
+		*/
 
-        return ZM_ERR_TX_BUFFER_UNAVAILABLE;
-    }
+		return ZM_ERR_TX_BUFFER_UNAVAILABLE;
+	}
 
-    /*
-     * STA associated, a unicast packet
-     */
+	/*
+	* STA associated, a unicast packet
+	*/
 
-    tid_tx = zfAggTxGetQueue(dev, aid, tid);
+	tid_tx = zfAggTxGetQueue(dev, aid, tid);
 
-    /*tid_q.tid_tx = tid_tx;
-    wd->destQ.insert = zfAggDestInsert;
-    wd->destQ.insert(dev, 0, tid_q);
-    */
-    if (tid_tx != NULL)
-    {
-        /*
-         * this (aid, ac) is aggregated
-         */
+	/*tid_q.tid_tx = tid_tx;
+	wd->destQ.insert = zfAggDestInsert;
+	wd->destQ.insert(dev, 0, tid_q);
+	*/
+	if (tid_tx != NULL) {
+		/*
+		* this (aid, ac) is aggregated
+		*/
 
-        //if (arrivalrate < ZM_AGG_LOW_THRESHOLD)
-        if (0)
-        {
-            /*
-             * arrival rate too low
-             * delete this aggregate queue
-             */
+		/* if (arrivalrate < ZM_AGG_LOW_THRESHOLD) */
+		if (0) {
+			/*
+			* arrival rate too low
+			* delete this aggregate queue
+			*/
 
-            zmw_enter_critical_section(dev);
+			zmw_enter_critical_section(dev);
 
-            //wd->aggQPool[qnum]->clearFlag = wd->aggQPool[qnum]->deleteFlag =1;
+			/* wd->aggQPool[qnum]->clearFlag =
+			*  wd->aggQPool[qnum]->deleteFlag =1;
+			*/
+			zmw_leave_critical_section(dev);
 
-            zmw_leave_critical_section(dev);
+		}
 
-        }
+		return zfAggTxEnqueue(dev, buf, aid, tid_tx);
 
-        return zfAggTxEnqueue(dev, buf, aid, tid_tx);
+	} else {
+		/*
+		* this (aid, ac) not yet aggregated
+		* queue not found
+		*/
 
-    }
-    else
-    {
-        /*
-         * this (aid, ac) not yet aggregated
-         * queue not found
-         */
+		/* if (arrivalrate > ZM_AGG_HIGH_THRESHOLD) */
+		if (1) {
+			/*
+			* arrivalrate high enough to get a new agg queue
+			*/
 
-        //if (arrivalrate > ZM_AGG_HIGH_THRESHOLD)
-        if (1)
-        {
-            /*
-             * arrivalrate high enough to get a new agg queue
-             */
+			tid_tx = zfAggTxNewQueue(dev, aid, tid, buf);
 
-            tid_tx = zfAggTxNewQueue(dev, aid, tid, buf);
+			/* zm_msg1_agg(ZM_LV_0, "get new AggQueue qnum = ",
+			*  tid_tx->);
+			*/
 
-            //zm_msg1_agg(ZM_LV_0, "get new AggQueue qnum = ", tid_tx->);
+			if (tid_tx) {
+				/*
+				 * got a new aggregate queue
+				 */
 
-            if (tid_tx)
-            {
-                /*
-                 * got a new aggregate queue
-                 */
+				/* zmw_enter_critical_section(dev);
 
-                //zmw_enter_critical_section(dev);
+				wd->aggSta[aid].aggFlag[ac] = 1;
 
-                //wd->aggSta[aid].aggFlag[ac] = 1;
+				zmw_leave_critical_section(dev);
 
-                //zmw_leave_critical_section(dev);
 
-                /*
-                 * add ADDBA functions here
-                 * return ZM_ERR_TX_BUFFER_UNAVAILABLE;
-                 */
+				//add ADDBA functions here
+				return ZM_ERR_TX_BUFFER_UNAVAILABLE;
 
 
-                //zfAggSendAddbaRequest(dev, tid_tx->dst, tid_tx->ac, tid_tx->tid);
-                //zmw_enter_critical_section(dev);
 
-                //wd->aggSta[aid].aggFlag[ac] = 0;
+				zfAggSendAddbaRequest(dev, tid_tx->dst,
+						tid_tx->ac, tid_tx->tid);
+				zmw_enter_critical_section(dev);
 
-                //zmw_leave_critical_section(dev);
+				wd->aggSta[aid].aggFlag[ac] = 0;
 
-                return zfAggTxEnqueue(dev, buf, aid, tid_tx);
+				zmw_leave_critical_section(dev);
+				*/
+				return zfAggTxEnqueue(dev, buf, aid, tid_tx);
 
-            }
-            else
-            {
-                /*
-                 * just can't get a new aggregate queue
-                 */
-
-                return ZM_ERR_TX_BUFFER_UNAVAILABLE;
-            }
-        }
-        else
-        {
-            /*
-             * arrival rate is not high enough to get a new agg queue
-             */
-
-            return ZM_ERR_TX_BUFFER_UNAVAILABLE;
-        }
-    }
+			} else {
+				/*
+				 * just can't get a new aggregate queue
+				 */
 
+				return ZM_ERR_TX_BUFFER_UNAVAILABLE;
+			}
+		} else {
+			/*
+			* arrival rate is not high enough to get
+			* a new agg queue
+			*/
 
+			return ZM_ERR_TX_BUFFER_UNAVAILABLE;
+		}
+	}
 
 }
 
@@ -1028,27 +1009,27 @@ u16_t zfAggTx(zdev_t* dev, zbuf_t* buf, 
 /*      Honda               Atheros Communications, INC.    2006.12     */
 /*                                                                      */
 /************************************************************************/
-u16_t zfAggTxReadyCount(zdev_t* dev, u16_t ac)
+u16_t zfAggTxReadyCount(zdev_t *dev, u16_t ac)
 {
-    u16_t i;
-    u16_t readycount = 0;
+	u16_t i;
+	u16_t readycount = 0;
 
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    zmw_declare_for_critical_section();
+	zmw_declare_for_critical_section();
 
-    zmw_enter_critical_section(dev);
+	zmw_enter_critical_section(dev);
 
-    for (i=0 ; i<ZM_AGG_POOL_SIZE; i++)
-    {
-        if (wd->aggQPool[i]->aggQEnabled && (wd->aggQPool[i]->aggReady || \
-                wd->aggQPool[i]->clearFlag) && ac == wd->aggQPool[i]->ac)
-            readycount++;
-    }
+	for (i = 0 ; i < ZM_AGG_POOL_SIZE; i++) {
+		if (wd->aggQPool[i]->aggQEnabled &&
+			(wd->aggQPool[i]->aggReady || \
+		wd->aggQPool[i]->clearFlag) && ac == wd->aggQPool[i]->ac)
+			readycount++;
+	}
 
-    zmw_leave_critical_section(dev);
+	zmw_leave_critical_section(dev);
 
-    return readycount;
+	return readycount;
 }
 
 /************************************************************************/
@@ -1071,35 +1052,32 @@ u16_t zfAggTxReadyCount(zdev_t* dev, u16
 /*      Honda               Atheros Communications, INC.    2006.12     */
 /*                                                                      */
 /************************************************************************/
-u16_t zfAggTxPartial(zdev_t* dev, u16_t ac, u16_t readycount)
+u16_t zfAggTxPartial(zdev_t *dev, u16_t ac, u16_t readycount)
 {
-    u16_t qlen;
-    u16_t partial;
+	u16_t qlen;
+	u16_t partial;
 
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    zmw_declare_for_critical_section();
+	zmw_declare_for_critical_section();
 
-    zmw_enter_critical_section(dev);
+	zmw_enter_critical_section(dev);
 
-    qlen = zm_agg_qlen(dev, wd->vtxqHead[ac], wd->vtxqTail[ac]);
+	qlen = zm_agg_qlen(dev, wd->vtxqHead[ac], wd->vtxqTail[ac]);
 
-    if ((qlen + readycount) > 0)
-    {
-        partial = (u16_t)( zm_agg_weight(ac) * ((u16_t)qlen/(qlen + \
-                        readycount)) );
-    }
-    else
-    {
-        partial = 0;
-    }
+	if ((qlen + readycount) > 0) {
+		partial = (u16_t)(zm_agg_weight(ac) *
+					((u16_t)qlen/(qlen + readycount)));
+	} else {
+		partial = 0;
+	}
 
-    zmw_leave_critical_section(dev);
+	zmw_leave_critical_section(dev);
 
-    if (partial > qlen)
-        partial = qlen;
+	if (partial > qlen)
+		partial = qlen;
 
-    return partial;
+	return partial;
 }
 
 
@@ -1122,144 +1100,140 @@ u16_t zfAggTxPartial(zdev_t* dev, u16_t 
 /*      Honda               Atheros Communications, INC.    2006.12     */
 /*                                                                      */
 /************************************************************************/
-u16_t zfAggTxSend(zdev_t* dev, u32_t freeTxd, TID_TX tid_tx)
+u16_t zfAggTxSend(zdev_t *dev, u32_t freeTxd, TID_TX tid_tx)
 {
-    //u16_t   qnum;
-    //u16_t   qlen;
-    u16_t   j;
-    //u16_t   sentcount = 0;
-    zbuf_t* buf;
-    struct  aggControl aggControl;
-    u16_t   aggLen;
-    //zbuf_t*  newBuf;
-    //u16_t   bufLen;
-    //TID_BAW tid_baw = NULL;
-    //struct bufInfo *buf_info;
-
-    zmw_get_wlan_dev(dev);
-
-    zmw_declare_for_critical_section();
-
-    //while (tid_tx->size > 0)
-
-    zmw_enter_critical_section(dev);
-    tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail);
-    aggLen = zm_agg_min(16, zm_agg_min(tid_tx->size, (u16_t)(freeTxd - 2)));
-    zmw_leave_critical_section(dev);
-
-            /*
-             * why there have to be 2 free Txd?
-             */
-    if (aggLen <=0 )
-        return 0;
-
-
-    if (aggLen == 1) {
-        buf = zfAggTxGetVtxq(dev, tid_tx);
-        if (buf)
-            zfTxSendEth(dev, buf, 0, ZM_EXTERNAL_ALLOC_BUF, 0);
-        if (tid_tx->size == 0) {
-            //DESTQ.delete(dev, 0, tid_tx, NULL);
-        }
-
-        return 1;
-    }
-                /*
-                 * Free Txd queue is big enough to put aggregation
-                 */
-    zmw_enter_critical_section(dev);
-    if (wd->aggState == 1) {
-        zmw_leave_critical_section(dev);
-        return 0;
-    }
-    wd->aggState = 1;
-    zmw_leave_critical_section(dev);
-
-
-    zm_msg1_agg(ZM_LV_0, "aggLen=", aggLen);
-    tid_tx->aggFrameSize = 0;
-    for (j=0; j < aggLen; j++) {
-        buf = zfAggTxGetVtxq(dev, tid_tx);
-
-        zmw_enter_critical_section(dev);
-        tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail);
-        zmw_leave_critical_section(dev);
-
-        if ( buf ) {
-            //struct aggTally *agg_tal;
-            u16_t completeIndex;
-
-            if (0 == j) {
-                aggControl.ampduIndication = ZM_AGG_FIRST_MPDU;
-
-            }
-            else if ((j == (aggLen - 1)) || tid_tx->size == 0)
-            {
-                aggControl.ampduIndication = ZM_AGG_LAST_MPDU;
-                //wd->aggState = 0;
-
-            }
-            else
-            {
-                aggControl.ampduIndication = ZM_AGG_MIDDLE_MPDU;
-                /* the packet is delayed more than 500 ms, drop it */
-
-            }
-            tid_tx->aggFrameSize += zfwBufGetSize(dev, buf);
-            aggControl.addbaIndication = 0;
-            aggControl.aggEnabled = 1;
+	/* u16_t   qnum; */
+	/* u16_t   qlen; */
+	u16_t   j;
+	/* u16_t   sentcount = 0; */
+	zbuf_t *buf;
+	struct  aggControl aggControl;
+	u16_t   aggLen;
+	/* zbuf_t*  newBuf; */
+	/* u16_t   bufLen; */
+	/* TID_BAW tid_baw = NULL; */
+	/* struct bufInfo *buf_info; */
+
+	zmw_get_wlan_dev(dev);
+
+	zmw_declare_for_critical_section();
+
+	/* while (tid_tx->size > 0) */
+
+	zmw_enter_critical_section(dev);
+	tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail);
+	aggLen = zm_agg_min(16, zm_agg_min(tid_tx->size, (u16_t)(freeTxd - 2)));
+	zmw_leave_critical_section(dev);
+
+	/*
+	* why there have to be 2 free Txd?
+	*/
+	if (aggLen <= 0)
+		return 0;
+
+
+	if (aggLen == 1) {
+		buf = zfAggTxGetVtxq(dev, tid_tx);
+		if (buf)
+			zfTxSendEth(dev, buf, 0, ZM_EXTERNAL_ALLOC_BUF, 0);
+		if (tid_tx->size == 0)
+			/* DESTQ.delete(dev, 0, tid_tx, NULL); */
+
+		return 1;
+	}
+	/*
+	* Free Txd queue is big enough to put aggregation
+	*/
+	zmw_enter_critical_section(dev);
+	if (wd->aggState == 1) {
+		zmw_leave_critical_section(dev);
+		return 0;
+	}
+	wd->aggState = 1;
+	zmw_leave_critical_section(dev);
+
+
+	zm_msg1_agg(ZM_LV_0, "aggLen=", aggLen);
+	tid_tx->aggFrameSize = 0;
+	for (j = 0; j < aggLen; j++) {
+		buf = zfAggTxGetVtxq(dev, tid_tx);
+
+		zmw_enter_critical_section(dev);
+		tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead,
+							tid_tx->aggTail);
+		zmw_leave_critical_section(dev);
+
+		if (buf) {
+			/* struct aggTally *agg_tal; */
+			u16_t completeIndex;
+
+			if (0 == j) {
+				aggControl.ampduIndication = ZM_AGG_FIRST_MPDU;
+
+			} else if ((j == (aggLen - 1)) || tid_tx->size == 0) {
+				aggControl.ampduIndication = ZM_AGG_LAST_MPDU;
+				/* wd->aggState = 0; */
+			} else {
+				aggControl.ampduIndication = ZM_AGG_MIDDLE_MPDU;
+				/* the packet is delayed more than
+				*  500 ms, drop it */
+			}
+			tid_tx->aggFrameSize += zfwBufGetSize(dev, buf);
+			aggControl.addbaIndication = 0;
+			aggControl.aggEnabled = 1;
 
 #ifdef ZM_AGG_TALLY
-            agg_tal = &wd->agg_tal;
-            agg_tal->sent_packets_sum++;
+			agg_tal = &wd->agg_tal;
+			agg_tal->sent_packets_sum++;
 
 #endif
 
-            zfAggTxSendEth(dev, buf, 0, ZM_EXTERNAL_ALLOC_BUF, 0, &aggControl, tid_tx);
-
-            zmw_enter_critical_section(dev);
-            completeIndex = tid_tx->complete;
-            if(zm_agg_inQ(tid_tx, tid_tx->complete))
-                zm_agg_plus(tid_tx->complete);
-            zmw_leave_critical_section(dev);
-
-            if(zm_agg_inQ(tid_tx, completeIndex) && wd->zfcbSendCompleteIndication
-                    && tid_tx->aggvtxq[completeIndex].buf) {
-                wd->zfcbSendCompleteIndication(dev, tid_tx->aggvtxq[completeIndex].buf);
-                zm_debug_msg0("in queue complete worked!");
-            }
-
-        }
-        else {
-            /*
-             * this aggregation queue is empty
-             */
-            zm_msg1_agg(ZM_LV_0, "aggLen not reached, but no more frame, j=", j);
-
-            break;
-        }
-    }
-    zmw_enter_critical_section(dev);
-    wd->aggState = 0;
-    zmw_leave_critical_section(dev);
-
-    //zm_acquire_agg_spin_lock(Adapter);
-    tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail);
-    //zm_release_agg_spin_lock(Adapter);
-
-    if (tid_tx->size == 0) {
-        //DESTQ.delete(dev, 0, tid_tx, NULL);
-    }
+			zfAggTxSendEth(dev, buf, 0, ZM_EXTERNAL_ALLOC_BUF, 0,
+							&aggControl, tid_tx);
 
-
-
-    //zfAggInvokeBar(dev, tid_tx);
-    if(j>0) {
-        aggr_count++;
-        zm_msg1_agg(ZM_LV_0, "0xC2:sent 1 aggr, aggr_count=", aggr_count);
-        zm_msg1_agg(ZM_LV_0, "0xC2:sent 1 aggr, aggr_size=", j);
-    }
-    return j;
+			zmw_enter_critical_section(dev);
+			completeIndex = tid_tx->complete;
+			if (zm_agg_inQ(tid_tx, tid_tx->complete))
+				zm_agg_plus(tid_tx->complete);
+			zmw_leave_critical_section(dev);
+
+			if (zm_agg_inQ(tid_tx, completeIndex) &&
+				wd->zfcbSendCompleteIndication
+				&& tid_tx->aggvtxq[completeIndex].buf) {
+				wd->zfcbSendCompleteIndication(dev,
+					tid_tx->aggvtxq[completeIndex].buf);
+				zm_debug_msg0("in queue complete worked!");
+			}
+
+		} else {
+			/*
+			* this aggregation queue is empty
+			*/
+			zm_msg1_agg(ZM_LV_0, "aggLen not reached, but no more "
+						"frame, j=", j);
+
+			break;
+		}
+	}
+	zmw_enter_critical_section(dev);
+	wd->aggState = 0;
+	zmw_leave_critical_section(dev);
+
+	/* zm_acquire_agg_spin_lock(Adapter); */
+	tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail);
+	/* zm_release_agg_spin_lock(Adapter); */
+
+	if (tid_tx->size == 0)
+		/* DESTQ.delete(dev, 0, tid_tx, NULL); */
+
+	/* zfAggInvokeBar(dev, tid_tx); */
+	if (j > 0) {
+		aggr_count++;
+		zm_msg1_agg(ZM_LV_0, "0xC2:sent 1 aggr, aggr_count=",
+								aggr_count);
+		zm_msg1_agg(ZM_LV_0, "0xC2:sent 1 aggr, aggr_size=", j);
+	}
+	return j;
 }
 
 
@@ -1282,36 +1256,35 @@ u16_t zfAggTxSend(zdev_t* dev, u32_t fre
 /*      Honda               Atheros Communications, INC.    2006.12     */
 /*                                                                      */
 /************************************************************************/
-TID_TX zfAggTxGetReadyQueue(zdev_t* dev, u16_t ac)
+TID_TX zfAggTxGetReadyQueue(zdev_t *dev, u16_t ac)
 {
-    //u16_t       qnum = ZM_AGG_POOL_SIZE;
-    u16_t       i;
-    u32_t       time = 0;
-    TID_TX      tid_tx = NULL;
-
-    zmw_get_wlan_dev(dev);
-
-    zmw_declare_for_critical_section();
-
-    zmw_enter_critical_section(dev);
-
-    for (i=0 ;i<ZM_AGG_POOL_SIZE; i++)
-    {
-        if (1 == wd->aggQPool[i]->aggQEnabled && ac == wd->aggQPool[i]->ac &&
-                (wd->aggQPool[i]->size > 0))
-        {
-            if (0 == time || time > wd->aggQPool[i]->aggvtxq[ \
-                            wd->aggQPool[i]->aggHead ].arrivalTime)
-            {
-                tid_tx = wd->aggQPool[i];
-                time = tid_tx->aggvtxq[ tid_tx->aggHead ].arrivalTime;
-            }
-        }
-    }
+	/* u16_t       qnum = ZM_AGG_POOL_SIZE; */
+	u16_t i;
+	u32_t time = 0;
+	TID_TX tid_tx = NULL;
+
+	zmw_get_wlan_dev(dev);
+
+	zmw_declare_for_critical_section();
+
+	zmw_enter_critical_section(dev);
+
+	for (i = 0; i < ZM_AGG_POOL_SIZE; i++) {
+		if (1 == wd->aggQPool[i]->aggQEnabled &&
+			ac == wd->aggQPool[i]->ac &&
+			(wd->aggQPool[i]->size > 0)) {
+			if (0 == time || time > wd->aggQPool[i]->aggvtxq[\
+				wd->aggQPool[i]->aggHead].arrivalTime) {
+				tid_tx = wd->aggQPool[i];
+				time =
+				tid_tx->aggvtxq[tid_tx->aggHead].arrivalTime;
+			}
+		}
+	}
 
-    zmw_leave_critical_section(dev);
+	zmw_leave_critical_section(dev);
 
-    return tid_tx;
+	return tid_tx;
 }
 
 
@@ -1333,40 +1306,43 @@ TID_TX zfAggTxGetReadyQueue(zdev_t* dev,
 /*      Honda               Atheros Communications, INC.    2006.12     */
 /*                                                                      */
 /************************************************************************/
-zbuf_t* zfAggTxGetVtxq(zdev_t* dev, TID_TX tid_tx)
+zbuf_t *zfAggTxGetVtxq(zdev_t *dev, TID_TX tid_tx)
 {
-    zbuf_t* buf = NULL;
+	zbuf_t *buf = NULL;
+
+	zmw_declare_for_critical_section();
 
-    zmw_declare_for_critical_section();
+	if (tid_tx->aggHead != tid_tx->aggTail) {
+		buf = tid_tx->aggvtxq[tid_tx->aggTail].buf;
 
-    if (tid_tx->aggHead != tid_tx->aggTail)
-    {
-        buf = tid_tx->aggvtxq[ tid_tx->aggTail ].buf;
-
-        tid_tx->aggvtxq[tid_tx->aggTail].buf = NULL;
-
-        zmw_enter_critical_section(dev);
-        tid_tx->aggTail = ((tid_tx->aggTail + 1) & ZM_AGGQ_SIZE_MASK);
-        if(tid_tx->size > 0) tid_tx->size--;
-        tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail);
-        if (NULL == buf) {
-            //tid_tx->aggTail = tid_tx->aggHead = tid_tx->size = 0;
-            //zm_msg1_agg(ZM_LV_0, "GetVtxq buf == NULL, tid_tx->size=", tid_tx->size);
-        }
-        zmw_leave_critical_section(dev);
-    }
-    else
-    {
-        /*
-         * queue is empty
-         */
-        zm_msg1_agg(ZM_LV_0, "tid_tx->aggHead == tid_tx->aggTail, tid_tx->size=", tid_tx->size);
-
-    }
-
-    if (zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail) != tid_tx->size)
-        zm_msg1_agg(ZM_LV_0, "qlen!=tid_tx->size! tid_tx->size=", tid_tx->size);
-    return buf;
+		tid_tx->aggvtxq[tid_tx->aggTail].buf = NULL;
+
+		zmw_enter_critical_section(dev);
+		tid_tx->aggTail = ((tid_tx->aggTail + 1) & ZM_AGGQ_SIZE_MASK);
+		if (tid_tx->size > 0)
+			tid_tx->size--;
+		tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead,
+							tid_tx->aggTail);
+		if (NULL == buf) {
+			/*tid_tx->aggTail = tid_tx->aggHead = tid_tx->size = 0;
+			* zm_msg1_agg(ZM_LV_0, "GetVtxq buf == NULL,
+			* tid_tx->size=", tid_tx->size);
+			*/
+		}
+		zmw_leave_critical_section(dev);
+	} else {
+		/*
+		* queue is empty
+		*/
+		zm_msg1_agg(ZM_LV_0, "tid_tx->aggHead == tid_tx->aggTail, "
+						"tid_tx->size=", tid_tx->size);
+
+	}
+
+	if (zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail) != tid_tx->size)
+		zm_msg1_agg(ZM_LV_0, "qlen!=tid_tx->size! tid_tx->size=",
+								tid_tx->size);
+	return buf;
 }
 
 
@@ -1388,267 +1364,287 @@ zbuf_t* zfAggTxGetVtxq(zdev_t* dev, TID_
 /*      Honda               Atheros Communications, INC.    2006.12     */
 /*                                                                      */
 /************************************************************************/
-u16_t zfAggTxDeleteQueue(zdev_t* dev, u16_t qnum)
+u16_t zfAggTxDeleteQueue(zdev_t *dev, u16_t qnum)
 {
-    u16_t ac, tid;
-    struct aggQueue *tx_tid;
-    struct aggSta   *agg_sta;
+	u16_t ac, tid;
+	struct aggQueue *tx_tid;
+	struct aggSta *agg_sta;
 
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    zmw_declare_for_critical_section();
+	zmw_declare_for_critical_section();
 
-    tx_tid = wd->aggQPool[qnum];
-    agg_sta = &wd->aggSta[tx_tid->aggQSTA];
-    ac = tx_tid->ac;
-    tid = tx_tid->tid;
+	tx_tid = wd->aggQPool[qnum];
+	agg_sta = &wd->aggSta[tx_tid->aggQSTA];
+	ac = tx_tid->ac;
+	tid = tx_tid->tid;
 
-    zmw_enter_critical_section(dev);
+	zmw_enter_critical_section(dev);
 
-    tx_tid->aggQEnabled = 0;
-    tx_tid->aggHead = tx_tid->aggTail = 0;
-    tx_tid->aggReady = 0;
-    tx_tid->clearFlag = tx_tid->deleteFlag = 0;
-    tx_tid->size = 0;
-    agg_sta->count[ac] = 0;
+	tx_tid->aggQEnabled = 0;
+	tx_tid->aggHead = tx_tid->aggTail = 0;
+	tx_tid->aggReady = 0;
+	tx_tid->clearFlag = tx_tid->deleteFlag = 0;
+	tx_tid->size = 0;
+	agg_sta->count[ac] = 0;
 
-    agg_sta->tid_tx[tid] = NULL;
-    agg_sta->aggFlag[ac] = 0;
+	agg_sta->tid_tx[tid] = NULL;
+	agg_sta->aggFlag[ac] = 0;
 
-    zmw_leave_critical_section(dev);
+	zmw_leave_critical_section(dev);
 
-    zm_msg1_agg(ZM_LV_0, "queue deleted! qnum=", qnum);
+	zm_msg1_agg(ZM_LV_0, "queue deleted! qnum=", qnum);
 
-    return ZM_SUCCESS;
+	return ZM_SUCCESS;
 }
 
 #ifdef ZM_ENABLE_AGGREGATION
-#ifndef ZM_ENABLE_FW_BA_RETRANSMISSION //disable BAW
-void zfBawCore(zdev_t* dev, u16_t baw_seq, u32_t bitmap, u16_t aggLen) {
-    TID_BAW tid_baw;
-    s16_t i;
-    zbuf_t* buf;
-    struct bufInfo *buf_info;
-
-    zmw_get_wlan_dev(dev);
-    //zmw_declare_for_critical_section();
-    tid_baw = BAW->getQ(dev, baw_seq);
-    //tid_baw = NULL;
-    if (NULL == tid_baw)
-        return;
-
-    total_mpdu += aggLen;
-    for (i = aggLen - 1; i>=0; i--) {
-        if (((bitmap >> i) & 0x1) == 0) {
-            buf_info = BAW->pop(dev, i, tid_baw);
-            buf = buf_info->buf;
-            if (buf) {
-                //wd->zfcbSetBawQ(dev, buf, 0);
-                zfAggTidTxInsertHead(dev, buf_info, tid_baw->tid_tx);
-            }
-        }
-        else {
-            success_mpdu++;
-        }
-    }
-    BAW->disable(dev, tid_baw);
-    zfAggTxScheduler(dev);
-    zm_debug_msg1("success_mpdu = ", success_mpdu);
-    zm_debug_msg1("  total_mpdu = ", total_mpdu);
-}
-
-void    zfBawInit(zdev_t* dev) {
-    TID_BAW tid_baw;
-    u16_t i,j;
-    zmw_get_wlan_dev(dev);
-    //zmw_declare_for_critical_section();
-
-    for (i=0; i<ZM_BAW_POOL_SIZE; i++){
-        tid_baw = &BAW->tid_baw[i];
-        for (j=0; j<ZM_VTXQ_SIZE; j++) {
-            tid_baw->frame[j].buf = NULL;
-        }
-        tid_baw->enabled = tid_baw->head = tid_baw->tail = tid_baw->size = 0;
-        tid_baw->start_seq = 0;
-    }
-    BAW->delPoint = 0;
-    BAW->core = zfBawCore;
-    BAW->getNewQ = zfBawGetNewQ;
-    BAW->insert = zfBawInsert;
-    BAW->pop = zfBawPop;
-    BAW->enable = zfBawEnable;
-    BAW->disable = zfBawDisable;
-    BAW->getQ = zfBawGetQ;
-}
-
-
-
-TID_BAW zfBawGetNewQ(zdev_t* dev, u16_t start_seq, TID_TX tid_tx) {
-    TID_BAW tid_baw=NULL;
-    TID_BAW next_baw=NULL;
-    u16_t i;
-    zmw_get_wlan_dev(dev);
-    //zmw_declare_for_critical_section();
-
-    /*
-    for (i=0; i<ZM_BAW_POOL_SIZE; i++){
-        tid_baw = &BAW->tid_baw[i];
-        if (FALSE == tid_baw->enabled)
-            break;
-    }
-    */
-
-    tid_baw = &BAW->tid_baw[BAW->delPoint];
-    i = BAW->delPoint;
-    //if (ZM_BAW_POOL_SIZE == i) {
-        //return NULL;
-    //    u8_t temp = BAW->delPoint;
-    //    tid_baw = &BAW->tid_baw[BAW->delPoint];
-    //    BAW->disable(dev, tid_baw);
-    //    BAW->delPoint = (BAW->delPoint < (ZM_BAW_POOL_SIZE - 1))? (BAW->delPoint + 1): 0;
-    //    temp = BAW->delPoint;
-    //}
-
-    zm_msg1_agg(ZM_LV_0, "get new tid_baw, index=", i);
-    BAW->delPoint = (i < (ZM_BAW_POOL_SIZE -1))? (i + 1): 0;
-    next_baw = &BAW->tid_baw[BAW->delPoint];
-    if (1 == next_baw->enabled) BAW->disable(dev, next_baw);
-
-    BAW->enable(dev, tid_baw, start_seq);
-    tid_baw->tid_tx = tid_tx;
-
-    return tid_baw;
-}
-
-u16_t   zfBawInsert(zdev_t* dev, zbuf_t* buf, u16_t baw_seq, TID_BAW tid_baw, u8_t baw_retransmit, struct baw_header_r *header_r) {
-    //TID_BAW tid_baw;
-    //u16_t   bufLen;
-
-    //zmw_get_wlan_dev(dev);
-    //zmw_declare_for_critical_section();
-
-    if(tid_baw->size < (ZM_VTXQ_SIZE - 1)) {
-        struct baw_header *baw_header = &tid_baw->frame[tid_baw->head].baw_header;
-
-        baw_header->headerLen   = header_r->headerLen;
-        baw_header->micLen      = header_r->micLen;
-        baw_header->snapLen     = header_r->snapLen;
-        baw_header->removeLen   = header_r->removeLen;
-        baw_header->keyIdx      = header_r->keyIdx;
-        zfwMemoryCopy((u8_t *)baw_header->header, (u8_t *)header_r->header, 58);
-        zfwMemoryCopy((u8_t *)baw_header->mic   , (u8_t *)header_r->mic   , 8);
-        zfwMemoryCopy((u8_t *)baw_header->snap  , (u8_t *)header_r->snap  , 8);
-        //wd->zfcbSetBawQ(dev, buf, 1);
-        tid_baw->frame[tid_baw->head].buf = buf;
-        tid_baw->frame[tid_baw->head].baw_seq = baw_seq;
-        tid_baw->frame[tid_baw->head].baw_retransmit = baw_retransmit + 1;
-
-        //tid_baw->frame[tid_baw->head].data = pBuf->data;
-        tid_baw->head++;
-        tid_baw->size++;
-    }
-    else {
-        //wd->zfcbSetBawQ(dev, buf, 0);
-        zfwBufFree(dev, buf, ZM_SUCCESS);
-        return FALSE;
-    }
-    return TRUE;
-}
-
-struct bufInfo* zfBawPop(zdev_t* dev, u16_t index, TID_BAW tid_baw) {
-    //TID_BAW tid_baw;
-    //zbuf_t* buf;
-    struct bufInfo *buf_info;
-    zmw_get_wlan_dev(dev);
-
-    buf_info = &wd->buf_info;
-    buf_info->baw_header = NULL;
-
-    if (NULL == (buf_info->buf = tid_baw->frame[index].buf))
-        return buf_info;
-
-    buf_info->baw_retransmit = tid_baw->frame[index].baw_retransmit;
-    buf_info->baw_header = &tid_baw->frame[index].baw_header;
-    buf_info->timestamp = tid_baw->frame[index].timestamp;
-    //pBuf->data = pBuf->buffer;
-    //wd->zfcbRestoreBufData(dev, buf);
-    tid_baw->frame[index].buf = NULL;
-
-    return buf_info;
-}
-
-void    zfBawEnable(zdev_t* dev, TID_BAW tid_baw, u16_t start_seq) {
-    //TID_BAW tid_baw;
-
-    //zmw_get_wlan_dev(dev);
-    //zmw_declare_for_critical_section();
-
-    tid_baw->enabled = TRUE;
-    tid_baw->head = tid_baw->tail = tid_baw->size = 0;
-    tid_baw->start_seq = start_seq;
-}
-
-void    zfBawDisable(zdev_t* dev, TID_BAW tid_baw) {
-    //TID_BAW tid_baw;
-    u16_t i;
-
-    //zmw_get_wlan_dev(dev);
-    //zmw_declare_for_critical_section();
-    for (i=0; i<ZM_VTXQ_SIZE; i++) {
-        if (tid_baw->frame[i].buf) {
-
-            //wd->zfcbSetBawQ(dev, tid_baw->frame[i].buf, 0);
-            zfwBufFree(dev, tid_baw->frame[i].buf, ZM_SUCCESS);
-            tid_baw->frame[i].buf = NULL;
-        }
-    }
-
-    tid_baw->enabled = FALSE;
-}
-
-TID_BAW zfBawGetQ(zdev_t* dev, u16_t baw_seq) {
-    TID_BAW tid_baw=NULL;
-    u16_t i;
-
-    zmw_get_wlan_dev(dev);
-    //zmw_declare_for_critical_section();
-    for (i=0; i<ZM_BAW_POOL_SIZE; i++){
-        tid_baw = &BAW->tid_baw[i];
-        if (TRUE == tid_baw->enabled)
-        {
-            zm_msg1_agg(ZM_LV_0, "get an old tid_baw, baw_seq=", baw_seq);
-            zm_msg1_agg(ZM_LV_0, "check a  tid_baw->start_seq=", tid_baw->start_seq);
-            if(baw_seq == tid_baw->start_seq)
-                break;
-        }
-
-    }
-    if (ZM_BAW_POOL_SIZE == i)
-        return NULL;
-    return tid_baw;
-}
-#endif //disable BAW
-#endif
-
-u16_t zfAggTallyReset(zdev_t* dev)
-{
-    struct aggTally* agg_tal;
-
-    zmw_get_wlan_dev(dev);
-
-    //zmw_declare_for_critical_section();
-
-    agg_tal = &wd->agg_tal;
-    agg_tal->got_packets_sum = 0;
-    agg_tal->got_bytes_sum = 0;
-    agg_tal->sent_bytes_sum = 0;
-    agg_tal->sent_packets_sum = 0;
-    agg_tal->avg_got_packets = 0;
-    agg_tal->avg_got_bytes = 0;
-    agg_tal->avg_sent_packets = 0;
-    agg_tal->avg_sent_bytes = 0;
-    agg_tal->time = 0;
-    return 0;
+#ifndef ZM_ENABLE_FW_BA_RETRANSMISSION /* disable BAW */
+void zfBawCore(zdev_t *dev, u16_t baw_seq, u32_t bitmap, u16_t aggLen)
+{
+	TID_BAW tid_baw;
+	s16_t i;
+	zbuf_t *buf;
+	struct bufInfo *buf_info;
+
+	zmw_get_wlan_dev(dev);
+	/* zmw_declare_for_critical_section(); */
+	tid_baw = BAW->getQ(dev, baw_seq);
+	/* tid_baw = NULL; */
+	if (NULL == tid_baw)
+		return;
+
+	total_mpdu += aggLen;
+	for (i = aggLen - 1; i >= 0; i--) {
+		if (((bitmap >> i) & 0x1) == 0) {
+			buf_info = BAW->pop(dev, i, tid_baw);
+			buf = buf_info->buf;
+			if (buf) {
+				/* wd->zfcbSetBawQ(dev, buf, 0); */
+				zfAggTidTxInsertHead(dev, buf_info,
+							tid_baw->tid_tx);
+			}
+		} else {
+			success_mpdu++;
+		}
+	}
+
+	BAW->disable(dev, tid_baw);
+	zfAggTxScheduler(dev);
+	zm_debug_msg1("success_mpdu = ", success_mpdu);
+	zm_debug_msg1("  total_mpdu = ", total_mpdu);
+}
+
+void zfBawInit(zdev_t *dev)
+{
+	TID_BAW tid_baw;
+	u16_t i, j;
+	zmw_get_wlan_dev(dev);
+	/* zmw_declare_for_critical_section(); */
+
+	for (i = 0; i < ZM_BAW_POOL_SIZE; i++) {
+		tid_baw = &BAW->tid_baw[i];
+		for (j = 0; j < ZM_VTXQ_SIZE; j++)
+			tid_baw->frame[j].buf = NULL;
+		tid_baw->enabled = tid_baw->head = tid_baw->tail =
+							tid_baw->size = 0;
+		tid_baw->start_seq = 0;
+	}
+
+	BAW->delPoint = 0;
+	BAW->core = zfBawCore;
+	BAW->getNewQ = zfBawGetNewQ;
+	BAW->insert = zfBawInsert;
+	BAW->pop = zfBawPop;
+	BAW->enable = zfBawEnable;
+	BAW->disable = zfBawDisable;
+	BAW->getQ = zfBawGetQ;
+}
+
+TID_BAW zfBawGetNewQ(zdev_t *dev, u16_t start_seq, TID_TX tid_tx)
+{
+	TID_BAW tid_baw = NULL;
+	TID_BAW next_baw = NULL;
+	u16_t i;
+	zmw_get_wlan_dev(dev);
+	/* zmw_declare_for_critical_section(); */
+
+	/*
+	for (i=0; i<ZM_BAW_POOL_SIZE; i++){
+	tid_baw = &BAW->tid_baw[i];
+	if (FALSE == tid_baw->enabled)
+		break;
+	}
+	*/
+
+	tid_baw = &BAW->tid_baw[BAW->delPoint];
+	i = BAW->delPoint;
+	/* if (ZM_BAW_POOL_SIZE == i) {
+		return NULL;
+	u8_t temp = BAW->delPoint;
+	tid_baw = &BAW->tid_baw[BAW->delPoint];
+	BAW->disable(dev, tid_baw);
+	BAW->delPoint = (BAW->delPoint < (ZM_BAW_POOL_SIZE - 1))?
+							(BAW->delPoint + 1): 0;
+	temp = BAW->delPoint;
+	}
+	*/
+
+	zm_msg1_agg(ZM_LV_0, "get new tid_baw, index=", i);
+	BAW->delPoint = (i < (ZM_BAW_POOL_SIZE - 1)) ? (i + 1) : 0;
+	next_baw = &BAW->tid_baw[BAW->delPoint];
+	if (1 == next_baw->enabled)
+		BAW->disable(dev, next_baw);
+
+	BAW->enable(dev, tid_baw, start_seq);
+	tid_baw->tid_tx = tid_tx;
+
+	return tid_baw;
+}
+
+u16_t zfBawInsert(zdev_t *dev, zbuf_t *buf, u16_t baw_seq, TID_BAW tid_baw,
+			u8_t baw_retransmit, struct baw_header_r *header_r)
+{
+	/* TID_BAW tid_baw; */
+	/* u16_t   bufLen; */
+
+	/* zmw_get_wlan_dev(dev); */
+	/* zmw_declare_for_critical_section(); */
+
+	if (tid_baw->size < (ZM_VTXQ_SIZE - 1)) {
+		struct baw_header *baw_header =
+				&tid_baw->frame[tid_baw->head].baw_header;
+
+		baw_header->headerLen   = header_r->headerLen;
+		baw_header->micLen      = header_r->micLen;
+		baw_header->snapLen     = header_r->snapLen;
+		baw_header->removeLen   = header_r->removeLen;
+		baw_header->keyIdx      = header_r->keyIdx;
+		zfwMemoryCopy((u8_t *)baw_header->header,
+						(u8_t *)header_r->header, 58);
+		zfwMemoryCopy((u8_t *)baw_header->mic   ,
+						(u8_t *)header_r->mic   , 8);
+		zfwMemoryCopy((u8_t *)baw_header->snap  ,
+						(u8_t *)header_r->snap  , 8);
+		/* wd->zfcbSetBawQ(dev, buf, 1); */
+		tid_baw->frame[tid_baw->head].buf = buf;
+		tid_baw->frame[tid_baw->head].baw_seq = baw_seq;
+		tid_baw->frame[tid_baw->head].baw_retransmit =
+							baw_retransmit + 1;
+
+		/* tid_baw->frame[tid_baw->head].data = pBuf->data; */
+		tid_baw->head++;
+		tid_baw->size++;
+	} else {
+		/* wd->zfcbSetBawQ(dev, buf, 0); */
+		zfwBufFree(dev, buf, ZM_SUCCESS);
+		return FALSE;
+	}
+	return TRUE;
+}
+
+struct bufInfo *zfBawPop(zdev_t *dev, u16_t index, TID_BAW tid_baw)
+{
+	/* TID_BAW tid_baw; */
+	/* zbuf_t* buf; */
+	struct bufInfo *buf_info;
+	zmw_get_wlan_dev(dev);
+
+	buf_info = &wd->buf_info;
+	buf_info->baw_header = NULL;
+
+	buf_info->buf = tid_baw->frame[index].buf;
+	if (NULL == buf_info->buf)
+		return buf_info;
+
+	buf_info->baw_retransmit = tid_baw->frame[index].baw_retransmit;
+	buf_info->baw_header = &tid_baw->frame[index].baw_header;
+	buf_info->timestamp = tid_baw->frame[index].timestamp;
+	/* pBuf->data = pBuf->buffer; */
+	/* wd->zfcbRestoreBufData(dev, buf); */
+	tid_baw->frame[index].buf = NULL;
+
+	return buf_info;
+}
+
+void zfBawEnable(zdev_t *dev, TID_BAW tid_baw, u16_t start_seq)
+{
+	/* TID_BAW tid_baw; */
+
+	/* zmw_get_wlan_dev(dev); */
+	/* zmw_declare_for_critical_section(); */
+
+	tid_baw->enabled = TRUE;
+	tid_baw->head = tid_baw->tail = tid_baw->size = 0;
+	tid_baw->start_seq = start_seq;
+}
+
+void zfBawDisable(zdev_t *dev, TID_BAW tid_baw)
+{
+	/* TID_BAW tid_baw; */
+	u16_t i;
+
+	/* zmw_get_wlan_dev(dev); */
+	/* zmw_declare_for_critical_section(); */
+	for (i = 0; i < ZM_VTXQ_SIZE; i++) {
+		if (tid_baw->frame[i].buf) {
+
+			/* wd->zfcbSetBawQ(dev, tid_baw->frame[i].buf, 0); */
+			zfwBufFree(dev, tid_baw->frame[i].buf, ZM_SUCCESS);
+			tid_baw->frame[i].buf = NULL;
+		}
+	}
+
+	tid_baw->enabled = FALSE;
+}
+
+TID_BAW zfBawGetQ(zdev_t *dev, u16_t baw_seq)
+{
+	TID_BAW tid_baw = NULL;
+	u16_t i;
+
+	zmw_get_wlan_dev(dev);
+	/* zmw_declare_for_critical_section(); */
+	for (i = 0; i < ZM_BAW_POOL_SIZE; i++) {
+		tid_baw = &BAW->tid_baw[i];
+		if (TRUE == tid_baw->enabled) {
+			zm_msg1_agg(ZM_LV_0, "get an old tid_baw, baw_seq=",
+								 baw_seq);
+			zm_msg1_agg(ZM_LV_0, "check a  tid_baw->start_seq=",
+							tid_baw->start_seq);
+			if (baw_seq == tid_baw->start_seq)
+				break;
+		}
+
+	}
+	if (ZM_BAW_POOL_SIZE == i)
+		return NULL;
+
+	return tid_baw;
+}
+#endif /* disable BAW */
+#endif
+
+u16_t zfAggTallyReset(zdev_t *dev)
+{
+	struct aggTally *agg_tal;
+
+	zmw_get_wlan_dev(dev);
+
+	/* zmw_declare_for_critical_section(); */
+
+	agg_tal = &wd->agg_tal;
+	agg_tal->got_packets_sum = 0;
+	agg_tal->got_bytes_sum = 0;
+	agg_tal->sent_bytes_sum = 0;
+	agg_tal->sent_packets_sum = 0;
+	agg_tal->avg_got_packets = 0;
+	agg_tal->avg_got_bytes = 0;
+	agg_tal->avg_sent_packets = 0;
+	agg_tal->avg_sent_bytes = 0;
+	agg_tal->time = 0;
+
+	return 0;
 }
 
 
@@ -1669,642 +1665,651 @@ u16_t zfAggTallyReset(zdev_t* dev)
 /*      Honda               Atheros Communications, INC.    2006.12     */
 /*                                                                      */
 /************************************************************************/
-u16_t   zfAggScanAndClear(zdev_t* dev, u32_t time)
+u16_t zfAggScanAndClear(zdev_t *dev, u32_t time)
 {
-    u16_t i;
-    u16_t head;
-    u16_t tail;
-    u32_t tick;
-    u32_t arrivalTime;
-    //u16_t aid, ac;
-    TID_TX tid_tx;
-
-    zmw_get_wlan_dev(dev);
-
-    zmw_declare_for_critical_section();
-
-    if(!(wd->state == ZM_WLAN_STATE_ENABLED)) return 0;
-    zfAggTxScheduler(dev, 1);
-    tick = zm_agg_GetTime();
-    for (i=0; i<ZM_AGG_POOL_SIZE; i++)
-    {
-        if (!wd->aggQPool[i]) return 0;
-        if (1 == wd->aggQPool[i]->aggQEnabled)
-        {
-            tid_tx = wd->aggQPool[i];
-            zmw_enter_critical_section(dev);
-
-            head = tid_tx->aggHead;
-            tail = tid_tx->aggTail;
-
-            arrivalTime = (u32_t)tid_tx->aggvtxq[tid_tx->aggTail].arrivalTime;
-
-
-            if((tick - arrivalTime) <= ZM_AGG_CLEAR_TIME)
-            {
-
-            }
-            else if((tid_tx->size = zm_agg_qlen(dev, tid_tx->aggHead, tid_tx->aggTail)) > 0)
-            {
-
-                tid_tx->clearFlag = 1;
-
-                //zm_msg1_agg(ZM_LV_0, "clear queue    tick =", tick);
-                //zm_msg1_agg(ZM_LV_0, "clear queue arrival =", arrivalTime);
-
+	u16_t i;
+	u16_t head;
+	u16_t tail;
+	u32_t tick;
+	u32_t arrivalTime;
+	/* u16_t aid, ac; */
+	TID_TX tid_tx;
+
+	zmw_get_wlan_dev(dev);
+
+	zmw_declare_for_critical_section();
+
+	if (!(wd->state == ZM_WLAN_STATE_ENABLED))
+		return 0;
+
+	zfAggTxScheduler(dev, 1);
+	tick = zm_agg_GetTime();
+
+	for (i = 0; i < ZM_AGG_POOL_SIZE; i++) {
+		if (!wd->aggQPool[i])
+			return 0;
+		if (1 == wd->aggQPool[i]->aggQEnabled) {
+			tid_tx = wd->aggQPool[i];
+			zmw_enter_critical_section(dev);
+
+			head = tid_tx->aggHead;
+			tail = tid_tx->aggTail;
+
+			arrivalTime =
+			(u32_t)tid_tx->aggvtxq[tid_tx->aggTail].arrivalTime;
+
+			tid_tx->size = zm_agg_qlen(dev,
+					tid_tx->aggHead, tid_tx->aggTail);
+
+			if ((tick - arrivalTime) <= ZM_AGG_CLEAR_TIME) {
+				/* do nothing */
+			} else if (tid_tx->size > 0) {
+
+					tid_tx->clearFlag = 1;
+
+					/*zm_msg1_agg(ZM_LV_0, "clear queue
+						tick =", tick);
+					zm_msg1_agg(ZM_LV_0, "clear queue
+						arrival =", arrivalTime);
+
+					zmw_leave_critical_section(dev);
+					zfAggTxScheduler(dev);
+					zmw_enter_critical_section(dev);
+					*/
+
+				}
+
+			if (tid_tx->size == 0) {
+				/*
+				* queue empty
+				*/
+				if (tick - tid_tx->lastArrival >
+							ZM_AGG_DELETE_TIME) {
+					zm_msg1_agg(ZM_LV_0, "delete queue, "
+						"idle for n sec. n = ", \
+						ZM_AGG_DELETE_TIME/10);
+
+					zmw_leave_critical_section(dev);
+					zfAggTxDeleteQueue(dev, i);
+					zmw_enter_critical_section(dev);
+				}
+			}
+
+			zmw_leave_critical_section(dev);
+		}
+	}
 
-                //zmw_leave_critical_section(dev);
-                //zfAggTxScheduler(dev);
-                //zmw_enter_critical_section(dev);
+	zfAggRxClear(dev, time);
 
-            }
-
-            if (tid_tx->size == 0)
-            {
-                /*
-                 * queue empty
-                 */
-                if (tick - tid_tx->lastArrival > ZM_AGG_DELETE_TIME)
-                {
-                    zm_msg1_agg(ZM_LV_0, "delete queue, idle for n sec. n = ", \
-                            ZM_AGG_DELETE_TIME/10);
+#ifdef ZM_AGG_TALLY
+	if ((wd->tick % 100) == 0)
+		zfAggPrintTally(dev);
+#endif
 
-                    zmw_leave_critical_section(dev);
-                    zfAggTxDeleteQueue(dev, i);
-                    zmw_enter_critical_section(dev);
-                }
-            }
+	return ZM_SUCCESS;
+}
 
-            zmw_leave_critical_section(dev);
-        }
-    }
+u16_t zfAggPrintTally(zdev_t *dev)
+{
+	struct aggTally *agg_tal;
 
-        zfAggRxClear(dev, time);
+	zmw_get_wlan_dev(dev);
 
-#ifdef ZM_AGG_TALLY
-    if((wd->tick % 100) == 0) {
-        zfAggPrintTally(dev);
-    }
-#endif
-
-    return ZM_SUCCESS;
-}
-
-u16_t   zfAggPrintTally(zdev_t* dev)
-{
-    struct aggTally* agg_tal;
-
-    zmw_get_wlan_dev(dev);
-
-    //zmw_declare_for_critical_section();
-
-    agg_tal = &wd->agg_tal;
-
-    if(agg_tal->got_packets_sum < 10)
-    {
-        zfAggTallyReset(dev);
-        return 0;
-    }
-
-    agg_tal->time++;
-    agg_tal->avg_got_packets = (agg_tal->avg_got_packets * (agg_tal->time - 1) +
-            agg_tal->got_packets_sum) / agg_tal->time;
-    agg_tal->avg_got_bytes = (agg_tal->avg_got_bytes * (agg_tal->time - 1) +
-            agg_tal->got_bytes_sum) / agg_tal->time;
-    agg_tal->avg_sent_packets = (agg_tal->avg_sent_packets * (agg_tal->time - 1)
-            + agg_tal->sent_packets_sum) / agg_tal->time;
-    agg_tal->avg_sent_bytes = (agg_tal->avg_sent_bytes * (agg_tal->time - 1) +
-            agg_tal->sent_bytes_sum) / agg_tal->time;
-    zm_msg1_agg(ZM_LV_0, "got_packets_sum =", agg_tal->got_packets_sum);
-    zm_msg1_agg(ZM_LV_0, "  got_bytes_sum =", agg_tal->got_bytes_sum);
-    zm_msg1_agg(ZM_LV_0, "sent_packets_sum=", agg_tal->sent_packets_sum);
-    zm_msg1_agg(ZM_LV_0, " sent_bytes_sum =", agg_tal->sent_bytes_sum);
-    agg_tal->got_packets_sum = agg_tal->got_bytes_sum =agg_tal->sent_packets_sum
-                = agg_tal->sent_bytes_sum = 0;
-    zm_msg1_agg(ZM_LV_0, "avg_got_packets =", agg_tal->avg_got_packets);
-    zm_msg1_agg(ZM_LV_0, "  avg_got_bytes =", agg_tal->avg_got_bytes);
-    zm_msg1_agg(ZM_LV_0, "avg_sent_packets=", agg_tal->avg_sent_packets);
-    zm_msg1_agg(ZM_LV_0, " avg_sent_bytes =", agg_tal->avg_sent_bytes);
-    if ((wd->commTally.BA_Fail == 0) || (wd->commTally.Hw_Tx_MPDU == 0))
-    {
-        zm_msg1_agg(ZM_LV_0, "Hardware Tx MPDU=", wd->commTally.Hw_Tx_MPDU);
-        zm_msg1_agg(ZM_LV_0, "  BA Fail number=", wd->commTally.BA_Fail);
-    }
-    else
-        zm_msg1_agg(ZM_LV_0, "1/(BA fail rate)=", wd->commTally.Hw_Tx_MPDU/wd->commTally.BA_Fail);
-
-    return 0;
-}
-
-u16_t zfAggRxClear(zdev_t* dev, u32_t time)
-{
-    u16_t   i;
-    struct agg_tid_rx *tid_rx;
-
-    zmw_get_wlan_dev(dev);
-
-    zmw_declare_for_critical_section();
-
-    for (i=0; i<ZM_AGG_POOL_SIZE; i++)
-    {
-        zmw_enter_critical_section(dev);
-        tid_rx = wd->tid_rx[i];
-        if (tid_rx->baw_head != tid_rx->baw_tail)
-        {
-            u16_t j = tid_rx->baw_tail;
-            while ((j != tid_rx->baw_head) && !tid_rx->frame[j].buf) {
-            	j = (j + 1) & ZM_AGG_BAW_MASK;
-            }
-            if ((j != tid_rx->baw_head) && (time - tid_rx->frame[j].arrivalTime) >
-                    (ZM_AGG_CLEAR_TIME - 5))
-            {
-                zmw_leave_critical_section(dev);
-                zm_msg0_agg(ZM_LV_1, "queue RxFlush by RxClear");
-                zfAggRxFlush(dev, 0, tid_rx);
-                zmw_enter_critical_section(dev);
-            }
-        }
-        zmw_leave_critical_section(dev);
-    }
-
-    return ZM_SUCCESS;
-}
-
-struct agg_tid_rx* zfAggRxEnabled(zdev_t* dev, zbuf_t* buf)
-{
-    u16_t   dst0, src[3], ac, aid, fragOff;
-    u8_t    up;
-    u16_t   offset = 0;
-    u16_t   seq_no;
-    u16_t frameType;
-    u16_t frameCtrl;
-    u16_t frameSubtype;
-    u32_t tcp_seq;
-    //struct aggSta *agg_sta;
+	/* zmw_declare_for_critical_section(); */
+
+	agg_tal = &wd->agg_tal;
+
+	if (agg_tal->got_packets_sum < 10) {
+		zfAggTallyReset(dev);
+		return 0;
+	}
+
+	agg_tal->time++;
+	agg_tal->avg_got_packets = (agg_tal->avg_got_packets *
+		(agg_tal->time - 1) + agg_tal->got_packets_sum) / agg_tal->time;
+	agg_tal->avg_got_bytes = (agg_tal->avg_got_bytes * (agg_tal->time - 1) +
+		agg_tal->got_bytes_sum) / agg_tal->time;
+	agg_tal->avg_sent_packets = (agg_tal->avg_sent_packets *
+		(agg_tal->time - 1)
+		+ agg_tal->sent_packets_sum) / agg_tal->time;
+	agg_tal->avg_sent_bytes = (agg_tal->avg_sent_bytes *
+				(agg_tal->time - 1) +
+				agg_tal->sent_bytes_sum) / agg_tal->time;
+	zm_msg1_agg(ZM_LV_0, "got_packets_sum =", agg_tal->got_packets_sum);
+	zm_msg1_agg(ZM_LV_0, "  got_bytes_sum =", agg_tal->got_bytes_sum);
+	zm_msg1_agg(ZM_LV_0, "sent_packets_sum=", agg_tal->sent_packets_sum);
+	zm_msg1_agg(ZM_LV_0, " sent_bytes_sum =", agg_tal->sent_bytes_sum);
+	agg_tal->got_packets_sum = agg_tal->got_bytes_sum =
+		agg_tal->sent_packets_sum = agg_tal->sent_bytes_sum = 0;
+	zm_msg1_agg(ZM_LV_0, "avg_got_packets =", agg_tal->avg_got_packets);
+	zm_msg1_agg(ZM_LV_0, "  avg_got_bytes =", agg_tal->avg_got_bytes);
+	zm_msg1_agg(ZM_LV_0, "avg_sent_packets=", agg_tal->avg_sent_packets);
[… more lines in the raw message]

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Part of the diff is not shown here. View the raw message.