Root/drivers/staging/winbond/mds.c

1#include "mds_f.h"
2#include "mto.h"
3#include "wbhal.h"
4#include "wb35tx_f.h"
5
6unsigned char
7Mds_initial(struct wbsoft_priv *adapter)
8{
9    struct wb35_mds *pMds = &adapter->Mds;
10
11    pMds->TxPause = false;
12    pMds->TxRTSThreshold = DEFAULT_RTSThreshold;
13    pMds->TxFragmentThreshold = DEFAULT_FRAGMENT_THRESHOLD;
14
15    return hal_get_tx_buffer(&adapter->sHwData, &pMds->pTxBuffer);
16}
17
18static void Mds_DurationSet(struct wbsoft_priv *adapter, struct wb35_descriptor *pDes, u8 *buffer)
19{
20    struct T00_descriptor *pT00;
21    struct T01_descriptor *pT01;
22    u16 Duration, NextBodyLen, OffsetSize;
23    u8 Rate, i;
24    unsigned char CTS_on = false, RTS_on = false;
25    struct T00_descriptor *pNextT00;
26    u16 BodyLen = 0;
27    unsigned char boGroupAddr = false;
28
29    OffsetSize = pDes->FragmentThreshold + 32 + 3;
30    OffsetSize &= ~0x03;
31    Rate = pDes->TxRate >> 1;
32    if (!Rate)
33        Rate = 1;
34
35    pT00 = (struct T00_descriptor *)buffer;
36    pT01 = (struct T01_descriptor *)(buffer+4);
37    pNextT00 = (struct T00_descriptor *)(buffer+OffsetSize);
38
39    if (buffer[DOT_11_DA_OFFSET+8] & 0x1) /* +8 for USB hdr */
40        boGroupAddr = true;
41
42    /******************************************
43     * Set RTS/CTS mechanism
44     ******************************************/
45    if (!boGroupAddr) {
46        /* NOTE : If the protection mode is enabled and the MSDU will be fragmented,
47         * the tx rates of MPDUs will all be DSSS rates. So it will not use
48         * CTS-to-self in this case. CTS-To-self will only be used when without
49         * fragmentation. -- 20050112 */
50        BodyLen = (u16)pT00->T00_frame_length; /* include 802.11 header */
51        BodyLen += 4; /* CRC */
52
53        if (BodyLen >= CURRENT_RTS_THRESHOLD)
54            RTS_on = true; /* Using RTS */
55        else {
56            if (pT01->T01_modulation_type) { /* Is using OFDM */
57                if (CURRENT_PROTECT_MECHANISM) /* Is using protect */
58                    CTS_on = true; /* Using CTS */
59            }
60        }
61    }
62
63    if (RTS_on || CTS_on) {
64        if (pT01->T01_modulation_type) { /* Is using OFDM */
65            /* CTS duration
66             * 2 SIFS + DATA transmit time + 1 ACK
67             * ACK Rate : 24 Mega bps
68             * ACK frame length = 14 bytes */
69            Duration = 2*DEFAULT_SIFSTIME +
70                       2*PREAMBLE_PLUS_SIGNAL_PLUS_SIGNALEXTENSION +
71                       ((BodyLen*8 + 22 + Rate*4 - 1)/(Rate*4))*Tsym +
72                       ((112 + 22 + 95)/96)*Tsym;
73        } else { /* DSSS */
74            /* CTS duration
75             * 2 SIFS + DATA transmit time + 1 ACK
76             * Rate : ?? Mega bps
77             * ACK frame length = 14 bytes */
78            if (pT01->T01_plcp_header_length) /* long preamble */
79                Duration = LONG_PREAMBLE_PLUS_PLCPHEADER_TIME*2;
80            else
81                Duration = SHORT_PREAMBLE_PLUS_PLCPHEADER_TIME*2;
82
83            Duration += (((BodyLen + 14)*8 + Rate-1) / Rate +
84                        DEFAULT_SIFSTIME*2);
85        }
86
87        if (RTS_on) {
88            if (pT01->T01_modulation_type) { /* Is using OFDM */
89                /* CTS + 1 SIFS + CTS duration
90                 * CTS Rate : 24 Mega bps
91                 * CTS frame length = 14 bytes */
92                Duration += (DEFAULT_SIFSTIME +
93                                PREAMBLE_PLUS_SIGNAL_PLUS_SIGNALEXTENSION +
94                                ((112 + 22 + 95)/96)*Tsym);
95            } else {
96                /* CTS + 1 SIFS + CTS duration
97                 * CTS Rate : ?? Mega bps
98                 * CTS frame length = 14 bytes */
99                if (pT01->T01_plcp_header_length) /* long preamble */
100                    Duration += LONG_PREAMBLE_PLUS_PLCPHEADER_TIME;
101                else
102                    Duration += SHORT_PREAMBLE_PLUS_PLCPHEADER_TIME;
103
104                Duration += (((112 + Rate-1) / Rate) + DEFAULT_SIFSTIME);
105            }
106        }
107
108        /* Set the value into USB descriptor */
109        pT01->T01_add_rts = RTS_on ? 1 : 0;
110        pT01->T01_add_cts = CTS_on ? 1 : 0;
111        pT01->T01_rts_cts_duration = Duration;
112    }
113
114    /******************************************
115     * Fill the more fragment descriptor
116     ******************************************/
117    if (boGroupAddr)
118        Duration = 0;
119    else {
120        for (i = pDes->FragmentCount-1; i > 0; i--) {
121            NextBodyLen = (u16)pNextT00->T00_frame_length;
122            NextBodyLen += 4; /* CRC */
123
124            if (pT01->T01_modulation_type) {
125                /* OFDM
126                 * data transmit time + 3 SIFS + 2 ACK
127                 * Rate : ??Mega bps
128                 * ACK frame length = 14 bytes, tx rate = 24M */
129                Duration = PREAMBLE_PLUS_SIGNAL_PLUS_SIGNALEXTENSION * 3;
130                Duration += (((NextBodyLen*8 + 22 + Rate*4 - 1)/(Rate*4)) * Tsym +
131                            (((2*14)*8 + 22 + 95)/96)*Tsym +
132                            DEFAULT_SIFSTIME*3);
133            } else {
134                /* DSSS
135                 * data transmit time + 2 ACK + 3 SIFS
136                 * Rate : ??Mega bps
137                 * ACK frame length = 14 bytes
138                 * TODO : */
139                if (pT01->T01_plcp_header_length) /* long preamble */
140                    Duration = LONG_PREAMBLE_PLUS_PLCPHEADER_TIME*3;
141                else
142                    Duration = SHORT_PREAMBLE_PLUS_PLCPHEADER_TIME*3;
143
144                Duration += (((NextBodyLen + (2*14))*8 + Rate-1) / Rate +
145                            DEFAULT_SIFSTIME*3);
146            }
147
148            ((u16 *)buffer)[5] = cpu_to_le16(Duration); /* 4 USHOR for skip 8B USB, 2USHORT=FC + Duration */
149
150            /* ----20061009 add by anson's endian */
151            pNextT00->value = cpu_to_le32(pNextT00->value);
152            pT01->value = cpu_to_le32(pT01->value);
153            /* ----end 20061009 add by anson's endian */
154
155            buffer += OffsetSize;
156            pT01 = (struct T01_descriptor *)(buffer+4);
157            if (i != 1) /* The last fragment will not have the next fragment */
158                pNextT00 = (struct T00_descriptor *)(buffer+OffsetSize);
159        }
160
161        /*******************************************
162         * Fill the last fragment descriptor
163         *******************************************/
164        if (pT01->T01_modulation_type) {
165            /* OFDM
166             * 1 SIFS + 1 ACK
167             * Rate : 24 Mega bps
168             * ACK frame length = 14 bytes */
169            Duration = PREAMBLE_PLUS_SIGNAL_PLUS_SIGNALEXTENSION;
170            /* The Tx rate of ACK use 24M */
171            Duration += (((112 + 22 + 95)/96)*Tsym + DEFAULT_SIFSTIME);
172        } else {
173            /* DSSS
174             * 1 ACK + 1 SIFS
175             * Rate : ?? Mega bps
176             * ACK frame length = 14 bytes(112 bits) */
177            if (pT01->T01_plcp_header_length) /* long preamble */
178                Duration = LONG_PREAMBLE_PLUS_PLCPHEADER_TIME;
179            else
180                Duration = SHORT_PREAMBLE_PLUS_PLCPHEADER_TIME;
181
182            Duration += ((112 + Rate-1)/Rate + DEFAULT_SIFSTIME);
183        }
184    }
185
186    ((u16 *)buffer)[5] = cpu_to_le16(Duration); /* 4 USHOR for skip 8B USB, 2USHORT=FC + Duration */
187    pT00->value = cpu_to_le32(pT00->value);
188    pT01->value = cpu_to_le32(pT01->value);
189    /* --end 20061009 add */
190
191}
192
193/* The function return the 4n size of usb pk */
194static u16 Mds_BodyCopy(struct wbsoft_priv *adapter, struct wb35_descriptor *pDes, u8 *TargetBuffer)
195{
196    struct T00_descriptor *pT00;
197    struct wb35_mds *pMds = &adapter->Mds;
198    u8 *buffer;
199    u8 *src_buffer;
200    u8 *pctmp;
201    u16 Size = 0;
202    u16 SizeLeft, CopySize, CopyLeft, stmp;
203    u8 buf_index, FragmentCount = 0;
204
205
206    /* Copy fragment body */
207    buffer = TargetBuffer; /* shift 8B usb + 24B 802.11 */
208    SizeLeft = pDes->buffer_total_size;
209    buf_index = pDes->buffer_start_index;
210
211    pT00 = (struct T00_descriptor *)buffer;
212    while (SizeLeft) {
213        pT00 = (struct T00_descriptor *)buffer;
214        CopySize = SizeLeft;
215        if (SizeLeft > pDes->FragmentThreshold) {
216            CopySize = pDes->FragmentThreshold;
217            pT00->T00_frame_length = 24 + CopySize; /* Set USB length */
218        } else
219            pT00->T00_frame_length = 24 + SizeLeft; /* Set USB length */
220
221        SizeLeft -= CopySize;
222
223        /* 1 Byte operation */
224        pctmp = (u8 *)(buffer + 8 + DOT_11_SEQUENCE_OFFSET);
225        *pctmp &= 0xf0;
226        *pctmp |= FragmentCount; /* 931130.5.m */
227        if (!FragmentCount)
228            pT00->T00_first_mpdu = 1;
229
230        buffer += 32; /* 8B usb + 24B 802.11 header */
231        Size += 32;
232
233        /* Copy into buffer */
234        stmp = CopySize + 3;
235        stmp &= ~0x03; /* 4n Alignment */
236        Size += stmp; /* Current 4n offset of mpdu */
237
238        while (CopySize) {
239            /* Copy body */
240            src_buffer = pDes->buffer_address[buf_index];
241            CopyLeft = CopySize;
242            if (CopySize >= pDes->buffer_size[buf_index]) {
243                CopyLeft = pDes->buffer_size[buf_index];
244
245                /* Get the next buffer of descriptor */
246                buf_index++;
247                buf_index %= MAX_DESCRIPTOR_BUFFER_INDEX;
248            } else {
249                u8 *pctmp = pDes->buffer_address[buf_index];
250                pctmp += CopySize;
251                pDes->buffer_address[buf_index] = pctmp;
252                pDes->buffer_size[buf_index] -= CopySize;
253            }
254
255            memcpy(buffer, src_buffer, CopyLeft);
256            buffer += CopyLeft;
257            CopySize -= CopyLeft;
258        }
259
260        /* 931130.5.n */
261        if (pMds->MicAdd) {
262            if (!SizeLeft) {
263                pMds->MicWriteAddress[pMds->MicWriteIndex] = buffer - pMds->MicAdd;
264                pMds->MicWriteSize[pMds->MicWriteIndex] = pMds->MicAdd;
265                pMds->MicAdd = 0;
266            } else if (SizeLeft < 8) { /* 931130.5.p */
267                pMds->MicAdd = SizeLeft;
268                pMds->MicWriteAddress[pMds->MicWriteIndex] = buffer - (8 - SizeLeft);
269                pMds->MicWriteSize[pMds->MicWriteIndex] = 8 - SizeLeft;
270                pMds->MicWriteIndex++;
271            }
272        }
273
274        /* Does it need to generate the new header for next mpdu? */
275        if (SizeLeft) {
276            buffer = TargetBuffer + Size; /* Get the next 4n start address */
277            memcpy(buffer, TargetBuffer, 32); /* Copy 8B USB +24B 802.11 */
278            pT00 = (struct T00_descriptor *)buffer;
279            pT00->T00_first_mpdu = 0;
280        }
281
282        FragmentCount++;
283    }
284
285    pT00->T00_last_mpdu = 1;
286    pT00->T00_IsLastMpdu = 1;
287    buffer = (u8 *)pT00 + 8; /* +8 for USB hdr */
288    buffer[1] &= ~0x04; /* Clear more frag bit of 802.11 frame control */
289    pDes->FragmentCount = FragmentCount; /* Update the correct fragment number */
290    return Size;
291}
292
293static void Mds_HeaderCopy(struct wbsoft_priv *adapter, struct wb35_descriptor *pDes, u8 *TargetBuffer)
294{
295    struct wb35_mds *pMds = &adapter->Mds;
296    u8 *src_buffer = pDes->buffer_address[0]; /* 931130.5.g */
297    struct T00_descriptor *pT00;
298    struct T01_descriptor *pT01;
299    u16 stmp;
300    u8 i, ctmp1, ctmp2, ctmpf;
301    u16 FragmentThreshold = CURRENT_FRAGMENT_THRESHOLD;
302
303
304    stmp = pDes->buffer_total_size;
305    /*
306     * Set USB header 8 byte
307     */
308    pT00 = (struct T00_descriptor *)TargetBuffer;
309    TargetBuffer += 4;
310    pT01 = (struct T01_descriptor *)TargetBuffer;
311    TargetBuffer += 4;
312
313    pT00->value = 0; /* Clear */
314    pT01->value = 0; /* Clear */
315
316    pT00->T00_tx_packet_id = pDes->Descriptor_ID; /* Set packet ID */
317    pT00->T00_header_length = 24; /* Set header length */
318    pT01->T01_retry_abort_ebable = 1; /* 921013 931130.5.h */
319
320    /* Key ID setup */
321    pT01->T01_wep_id = 0;
322
323    FragmentThreshold = DEFAULT_FRAGMENT_THRESHOLD; /* Do not fragment */
324    /* Copy full data, the 1'st buffer contain all the data 931130.5.j */
325    memcpy(TargetBuffer, src_buffer, DOT_11_MAC_HEADER_SIZE); /* Copy header */
326    pDes->buffer_address[0] = src_buffer + DOT_11_MAC_HEADER_SIZE;
327    pDes->buffer_total_size -= DOT_11_MAC_HEADER_SIZE;
328    pDes->buffer_size[0] = pDes->buffer_total_size;
329
330    /* Set fragment threshold */
331    FragmentThreshold -= (DOT_11_MAC_HEADER_SIZE + 4);
332    pDes->FragmentThreshold = FragmentThreshold;
333
334    /* Set more frag bit */
335    TargetBuffer[1] |= 0x04; /* Set more frag bit */
336
337    /*
338     * Set tx rate
339     */
340    stmp = *(u16 *)(TargetBuffer+30); /* 2n alignment address */
341
342    /* Use basic rate */
343    ctmp1 = ctmpf = CURRENT_TX_RATE_FOR_MNG;
344
345    pDes->TxRate = ctmp1;
346    pr_debug("Tx rate =%x\n", ctmp1);
347
348    pT01->T01_modulation_type = (ctmp1%3) ? 0 : 1;
349
350    for (i = 0; i < 2; i++) {
351        if (i == 1)
352            ctmp1 = ctmpf;
353
354        pMds->TxRate[pDes->Descriptor_ID][i] = ctmp1; /* backup the ta rate and fall back rate */
355
356        if (ctmp1 == 108)
357            ctmp2 = 7;
358        else if (ctmp1 == 96)
359            ctmp2 = 6; /* Rate convert for USB */
360        else if (ctmp1 == 72)
361            ctmp2 = 5;
362        else if (ctmp1 == 48)
363            ctmp2 = 4;
364        else if (ctmp1 == 36)
365            ctmp2 = 3;
366        else if (ctmp1 == 24)
367            ctmp2 = 2;
368        else if (ctmp1 == 18)
369            ctmp2 = 1;
370        else if (ctmp1 == 12)
371            ctmp2 = 0;
372        else if (ctmp1 == 22)
373            ctmp2 = 3;
374        else if (ctmp1 == 11)
375            ctmp2 = 2;
376        else if (ctmp1 == 4)
377            ctmp2 = 1;
378        else
379            ctmp2 = 0; /* if( ctmp1 == 2 ) or default */
380
381        if (i == 0)
382            pT01->T01_transmit_rate = ctmp2;
383        else
384            pT01->T01_fall_back_rate = ctmp2;
385    }
386
387    /*
388     * Set preamble type
389     */
390    if ((pT01->T01_modulation_type == 0) && (pT01->T01_transmit_rate == 0)) /* RATE_1M */
391        pDes->PreambleMode = WLAN_PREAMBLE_TYPE_LONG;
392    else
393        pDes->PreambleMode = CURRENT_PREAMBLE_MODE;
394    pT01->T01_plcp_header_length = pDes->PreambleMode; /* Set preamble */
395
396}
397
398static void MLME_GetNextPacket(struct wbsoft_priv *adapter, struct wb35_descriptor *desc)
399{
400    desc->InternalUsed = desc->buffer_start_index + desc->buffer_number;
401    desc->InternalUsed %= MAX_DESCRIPTOR_BUFFER_INDEX;
402    desc->buffer_address[desc->InternalUsed] = adapter->sMlmeFrame.pMMPDU;
403    desc->buffer_size[desc->InternalUsed] = adapter->sMlmeFrame.len;
404    desc->buffer_total_size += adapter->sMlmeFrame.len;
405    desc->buffer_number++;
406    desc->Type = adapter->sMlmeFrame.DataType;
407}
408
409static void MLMEfreeMMPDUBuffer(struct wbsoft_priv *adapter, s8 *pData)
410{
411    int i;
412
413    /* Reclaim the data buffer */
414    for (i = 0; i < MAX_NUM_TX_MMPDU; i++) {
415        if (pData == (s8 *)&(adapter->sMlmeFrame.TxMMPDU[i]))
416            break;
417    }
418    if (adapter->sMlmeFrame.TxMMPDUInUse[i])
419        adapter->sMlmeFrame.TxMMPDUInUse[i] = false;
420    else {
421        /* Something wrong
422         PD43 Add debug code here??? */
423    }
424}
425
426static void MLME_SendComplete(struct wbsoft_priv *adapter, u8 PacketID, unsigned char SendOK)
427{
428    /* Reclaim the data buffer */
429    adapter->sMlmeFrame.len = 0;
430    MLMEfreeMMPDUBuffer(adapter, adapter->sMlmeFrame.pMMPDU);
431
432    /* Return resource */
433    adapter->sMlmeFrame.IsInUsed = PACKET_FREE_TO_USE;
434}
435
436void
437Mds_Tx(struct wbsoft_priv *adapter)
438{
439    struct hw_data *pHwData = &adapter->sHwData;
440    struct wb35_mds *pMds = &adapter->Mds;
441    struct wb35_descriptor TxDes;
442    struct wb35_descriptor *pTxDes = &TxDes;
443    u8 *XmitBufAddress;
444    u16 XmitBufSize, PacketSize, stmp, CurrentSize, FragmentThreshold;
445    u8 FillIndex, TxDesIndex, FragmentCount, FillCount;
446    unsigned char BufferFilled = false;
447
448
449    if (pMds->TxPause)
450        return;
451    if (!hal_driver_init_OK(pHwData))
452        return;
453
454    /* Only one thread can be run here */
455    if (atomic_inc_return(&pMds->TxThreadCount) != 1)
456        goto cleanup;
457
458    /* Start to fill the data */
459    do {
460        FillIndex = pMds->TxFillIndex;
461        if (pMds->TxOwner[FillIndex]) { /* Is owned by software 0:Yes 1:No */
462            pr_debug("[Mds_Tx] Tx Owner is H/W.\n");
463            break;
464        }
465
466        XmitBufAddress = pMds->pTxBuffer + (MAX_USB_TX_BUFFER * FillIndex); /* Get buffer */
467        XmitBufSize = 0;
468        FillCount = 0;
469        do {
470            PacketSize = adapter->sMlmeFrame.len;
471            if (!PacketSize)
472                break;
473
474            /* For Check the buffer resource */
475            FragmentThreshold = CURRENT_FRAGMENT_THRESHOLD;
476            /* 931130.5.b */
477            FragmentCount = PacketSize/FragmentThreshold + 1;
478            stmp = PacketSize + FragmentCount*32 + 8; /* 931130.5.c 8:MIC */
479            if ((XmitBufSize + stmp) >= MAX_USB_TX_BUFFER) {
480                printk("[Mds_Tx] Excess max tx buffer.\n");
481                break; /* buffer is not enough */
482            }
483
484
485            /*
486             * Start transmitting
487             */
488            BufferFilled = true;
489
490            /* Leaves first u8 intact */
491            memset((u8 *)pTxDes + 1, 0, sizeof(struct wb35_descriptor) - 1);
492
493            TxDesIndex = pMds->TxDesIndex; /* Get the current ID */
494            pTxDes->Descriptor_ID = TxDesIndex;
495            pMds->TxDesFrom[TxDesIndex] = 2; /* Storing the information of source coming from */
496            pMds->TxDesIndex++;
497            pMds->TxDesIndex %= MAX_USB_TX_DESCRIPTOR;
498
499            MLME_GetNextPacket(adapter, pTxDes);
500
501            /* Copy header. 8byte USB + 24byte 802.11Hdr. Set TxRate, Preamble type */
502            Mds_HeaderCopy(adapter, pTxDes, XmitBufAddress);
503
504            /* For speed up Key setting */
505            if (pTxDes->EapFix) {
506                pr_debug("35: EPA 4th frame detected. Size = %d\n", PacketSize);
507                pHwData->IsKeyPreSet = 1;
508            }
509
510            /* Copy (fragment) frame body, and set USB, 802.11 hdr flag */
511            CurrentSize = Mds_BodyCopy(adapter, pTxDes, XmitBufAddress);
512
513            /* Set RTS/CTS and Normal duration field into buffer */
514            Mds_DurationSet(adapter, pTxDes, XmitBufAddress);
515
516            /* Shift to the next address */
517            XmitBufSize += CurrentSize;
518            XmitBufAddress += CurrentSize;
519
520            /* Get packet to transmit completed, 1:TESTSTA 2:MLME 3: Ndis data */
521            MLME_SendComplete(adapter, 0, true);
522
523            /* Software TSC count 20060214 */
524            pMds->TxTsc++;
525            if (pMds->TxTsc == 0)
526                pMds->TxTsc_2++;
527
528            FillCount++; /* 20060928 */
529        } while (HAL_USB_MODE_BURST(pHwData)); /* End of multiple MSDU copy loop. false = single true = multiple sending */
530
531        /* Move to the next one, if necessary */
532        if (BufferFilled) {
533            /* size setting */
534            pMds->TxBufferSize[FillIndex] = XmitBufSize;
535
536            /* 20060928 set Tx count */
537            pMds->TxCountInBuffer[FillIndex] = FillCount;
538
539            /* Set owner flag */
540            pMds->TxOwner[FillIndex] = 1;
541
542            pMds->TxFillIndex++;
543            pMds->TxFillIndex %= MAX_USB_TX_BUFFER_NUMBER;
544            BufferFilled = false;
545        } else
546            break;
547
548        if (!PacketSize) /* No more pk for transmitting */
549            break;
550
551    } while (true);
552
553    /*
554     * Start to send by lower module
555     */
556    if (!pHwData->IsKeyPreSet)
557        Wb35Tx_start(adapter);
558
559cleanup:
560        atomic_dec(&pMds->TxThreadCount);
561}
562
563void
564Mds_SendComplete(struct wbsoft_priv *adapter, struct T02_descriptor *pT02)
565{
566    struct wb35_mds *pMds = &adapter->Mds;
567    struct hw_data *pHwData = &adapter->sHwData;
568    u8 PacketId = (u8)pT02->T02_Tx_PktID;
569    unsigned char SendOK = true;
570    u8 RetryCount, TxRate;
571
572    if (pT02->T02_IgnoreResult) /* Don't care the result */
573        return;
574    if (pT02->T02_IsLastMpdu) {
575        /* TODO: DTO -- get the retry count and fragment count */
576        /* Tx rate */
577        TxRate = pMds->TxRate[PacketId][0];
578        RetryCount = (u8)pT02->T02_MPDU_Cnt;
579        if (pT02->value & FLAG_ERROR_TX_MASK) {
580            SendOK = false;
581
582            if (pT02->T02_transmit_abort || pT02->T02_out_of_MaxTxMSDULiftTime) {
583                /* retry error */
584                pHwData->dto_tx_retry_count += (RetryCount+1);
585                /* [for tx debug] */
586                if (RetryCount < 7)
587                    pHwData->tx_retry_count[RetryCount] += RetryCount;
588                else
589                    pHwData->tx_retry_count[7] += RetryCount;
590                pr_debug("dto_tx_retry_count =%d\n", pHwData->dto_tx_retry_count);
591                MTO_SetTxCount(adapter, TxRate, RetryCount);
592            }
593            pHwData->dto_tx_frag_count += (RetryCount+1);
594
595            /* [for tx debug] */
596            if (pT02->T02_transmit_abort_due_to_TBTT)
597                pHwData->tx_TBTT_start_count++;
598            if (pT02->T02_transmit_without_encryption_due_to_wep_on_false)
599                pHwData->tx_WepOn_false_count++;
600            if (pT02->T02_discard_due_to_null_wep_key)
601                pHwData->tx_Null_key_count++;
602        } else {
603            if (pT02->T02_effective_transmission_rate)
604                pHwData->tx_ETR_count++;
605            MTO_SetTxCount(adapter, TxRate, RetryCount);
606        }
607
608        /* Clear send result buffer */
609        pMds->TxResult[PacketId] = 0;
610    } else
611        pMds->TxResult[PacketId] |= ((u16)(pT02->value & 0x0ffff));
612}
613

Archive Download this file



interactive