projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'master' into next
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / rt2860 / common / cmm_data_usb.c
1 /*
2 *************************************************************************
3 * Ralink Tech Inc.
4 * 5F., No.36, Taiyuan St., Jhubei City,
5 * Hsinchu County 302,
6 * Taiwan, R.O.C.
7 *
8 * (c) Copyright 2002-2007, Ralink Technology, Inc.
9 *
10 * This program is free software; you can redistribute it and/or modify *
11 * it under the terms of the GNU General Public License as published by *
12 * the Free Software Foundation; either version 2 of the License, or *
13 * (at your option) any later version. *
14 * *
15 * This program is distributed in the hope that it will be useful, *
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
18 * GNU General Public License for more details. *
19 * *
20 * You should have received a copy of the GNU General Public License *
21 * along with this program; if not, write to the *
22 * Free Software Foundation, Inc., *
23 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
24 * *
25 *************************************************************************
26 */
27
28 /*
29 All functions in this file must be USB-depended, or you should out your function
30 in other files.
31
32 */
33
34 #ifdef RTMP_MAC_USB
35
36 #include "../rt_config.h"
37
38 /*
39 We can do copy the frame into pTxContext when match following conditions.
40 =>
41 =>
42 =>
43 */
44 static inline int RtmpUSBCanDoWrite(struct rt_rtmp_adapter *pAd,
45 u8 QueIdx,
46 struct rt_ht_tx_context *pHTTXContext)
47 {
48 int canWrite = NDIS_STATUS_RESOURCES;
49
50 if (((pHTTXContext->CurWritePosition) <
51 pHTTXContext->NextBulkOutPosition)
52 && (pHTTXContext->CurWritePosition + LOCAL_TXBUF_SIZE) >
53 pHTTXContext->NextBulkOutPosition) {
54 DBGPRINT(RT_DEBUG_ERROR, ("RtmpUSBCanDoWrite c1!\n"));
55 RTUSB_SET_BULK_FLAG(pAd,
56 (fRTUSB_BULK_OUT_DATA_NORMAL << QueIdx));
57 } else if ((pHTTXContext->CurWritePosition == 8)
58 && (pHTTXContext->NextBulkOutPosition < LOCAL_TXBUF_SIZE)) {
59 DBGPRINT(RT_DEBUG_ERROR, ("RtmpUSBCanDoWrite c2!\n"));
60 RTUSB_SET_BULK_FLAG(pAd,
61 (fRTUSB_BULK_OUT_DATA_NORMAL << QueIdx));
62 } else if (pHTTXContext->bCurWriting == TRUE) {
63 DBGPRINT(RT_DEBUG_ERROR, ("RtmpUSBCanDoWrite c3!\n"));
64 } else {
65 canWrite = NDIS_STATUS_SUCCESS;
66 }
67
68 return canWrite;
69 }
70
71 u16 RtmpUSB_WriteSubTxResource(struct rt_rtmp_adapter *pAd,
72 struct rt_tx_blk *pTxBlk,
73 IN BOOLEAN bIsLast, u16 * FreeNumber)
74 {
75
76 /* Dummy function. Should be removed in the future. */
77 return 0;
78
79 }
80
81 u16 RtmpUSB_WriteFragTxResource(struct rt_rtmp_adapter *pAd,
82 struct rt_tx_blk *pTxBlk,
83 u8 fragNum, u16 * FreeNumber)
84 {
85 struct rt_ht_tx_context *pHTTXContext;
86 u16 hwHdrLen; /* The hwHdrLen consist of 802.11 header length plus the header padding length. */
87 u32 fillOffset;
88 struct rt_txinfo *pTxInfo;
89 struct rt_txwi *pTxWI;
90 u8 *pWirelessPacket = NULL;
91 u8 QueIdx;
92 int Status;
93 unsigned long IrqFlags;
94 u32 USBDMApktLen = 0, DMAHdrLen, padding;
95 BOOLEAN TxQLastRound = FALSE;
96
97 /* */
98 /* get Tx Ring Resource & Dma Buffer address */
99 /* */
100 QueIdx = pTxBlk->QueIdx;
101 pHTTXContext = &pAd->TxContext[QueIdx];
102
103 RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
104
105 pHTTXContext = &pAd->TxContext[QueIdx];
106 fillOffset = pHTTXContext->CurWritePosition;
107
108 if (fragNum == 0) {
109 /* Check if we have enough space for this bulk-out batch. */
110 Status = RtmpUSBCanDoWrite(pAd, QueIdx, pHTTXContext);
111 if (Status == NDIS_STATUS_SUCCESS) {
112 pHTTXContext->bCurWriting = TRUE;
113
114 /* Reserve space for 8 bytes padding. */
115 if ((pHTTXContext->ENextBulkOutPosition ==
116 pHTTXContext->CurWritePosition)) {
117 pHTTXContext->ENextBulkOutPosition += 8;
118 pHTTXContext->CurWritePosition += 8;
119 fillOffset += 8;
120 }
121 pTxBlk->Priv = 0;
122 pHTTXContext->CurWriteRealPos =
123 pHTTXContext->CurWritePosition;
124 } else {
125 RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx],
126 IrqFlags);
127
128 RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket,
129 NDIS_STATUS_FAILURE);
130 return (Status);
131 }
132 } else {
133 /* For sub-sequent frames of this bulk-out batch. Just copy it to our bulk-out buffer. */
134 Status =
135 ((pHTTXContext->bCurWriting ==
136 TRUE) ? NDIS_STATUS_SUCCESS : NDIS_STATUS_FAILURE);
137 if (Status == NDIS_STATUS_SUCCESS) {
138 fillOffset += pTxBlk->Priv;
139 } else {
140 RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx],
141 IrqFlags);
142
143 RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket,
144 NDIS_STATUS_FAILURE);
145 return (Status);
146 }
147 }
148
149 NdisZeroMemory((u8 *)(&pTxBlk->HeaderBuf[0]), TXINFO_SIZE);
150 pTxInfo = (struct rt_txinfo *)(&pTxBlk->HeaderBuf[0]);
151 pTxWI = (struct rt_txwi *) (&pTxBlk->HeaderBuf[TXINFO_SIZE]);
152
153 pWirelessPacket =
154 &pHTTXContext->TransferBuffer->field.WirelessPacket[fillOffset];
155
156 /* copy TXWI + WLAN Header + LLC into DMA Header Buffer */
157 /*hwHdrLen = ROUND_UP(pTxBlk->MpduHeaderLen, 4); */
158 hwHdrLen = pTxBlk->MpduHeaderLen + pTxBlk->HdrPadLen;
159
160 /* Build our URB for USBD */
161 DMAHdrLen = TXWI_SIZE + hwHdrLen;
162 USBDMApktLen = DMAHdrLen + pTxBlk->SrcBufLen;
163 padding = (4 - (USBDMApktLen % 4)) & 0x03; /* round up to 4 byte alignment */
164 USBDMApktLen += padding;
165
166 pTxBlk->Priv += (TXINFO_SIZE + USBDMApktLen);
167
168 /* For TxInfo, the length of USBDMApktLen = TXWI_SIZE + 802.11 header + payload */
169 RTMPWriteTxInfo(pAd, pTxInfo, (u16)(USBDMApktLen), FALSE, FIFO_EDCA,
170 FALSE /*NextValid */ , FALSE);
171
172 if (fragNum == pTxBlk->TotalFragNum) {
173 pTxInfo->USBDMATxburst = 0;
174 if ((pHTTXContext->CurWritePosition + pTxBlk->Priv + 3906) >
175 MAX_TXBULK_LIMIT) {
176 pTxInfo->SwUseLastRound = 1;
177 TxQLastRound = TRUE;
178 }
179 } else {
180 pTxInfo->USBDMATxburst = 1;
181 }
182
183 NdisMoveMemory(pWirelessPacket, pTxBlk->HeaderBuf,
184 TXINFO_SIZE + TXWI_SIZE + hwHdrLen);
185 pWirelessPacket += (TXINFO_SIZE + TXWI_SIZE + hwHdrLen);
186 pHTTXContext->CurWriteRealPos += (TXINFO_SIZE + TXWI_SIZE + hwHdrLen);
187
188 RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
189
190 NdisMoveMemory(pWirelessPacket, pTxBlk->pSrcBufData, pTxBlk->SrcBufLen);
191
192 /* Zero the last padding. */
193 pWirelessPacket += pTxBlk->SrcBufLen;
194 NdisZeroMemory(pWirelessPacket, padding + 8);
195
196 if (fragNum == pTxBlk->TotalFragNum) {
197 RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
198
199 /* Update the pHTTXContext->CurWritePosition. 3906 used to prevent the NextBulkOut is a A-RALINK/A-MSDU Frame. */
200 pHTTXContext->CurWritePosition += pTxBlk->Priv;
201 if (TxQLastRound == TRUE)
202 pHTTXContext->CurWritePosition = 8;
203 pHTTXContext->CurWriteRealPos = pHTTXContext->CurWritePosition;
204
205 /* Finally, set bCurWriting as FALSE */
206 pHTTXContext->bCurWriting = FALSE;
207
208 RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
209
210 /* succeed and release the skb buffer */
211 RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_SUCCESS);
212 }
213
214 return (Status);
215
216 }
217
218 u16 RtmpUSB_WriteSingleTxResource(struct rt_rtmp_adapter *pAd,
219 struct rt_tx_blk *pTxBlk,
220 IN BOOLEAN bIsLast,
221 u16 * FreeNumber)
222 {
223 struct rt_ht_tx_context *pHTTXContext;
224 u16 hwHdrLen;
225 u32 fillOffset;
226 struct rt_txinfo *pTxInfo;
227 struct rt_txwi *pTxWI;
228 u8 *pWirelessPacket;
229 u8 QueIdx;
230 unsigned long IrqFlags;
231 int Status;
232 u32 USBDMApktLen = 0, DMAHdrLen, padding;
233 BOOLEAN bTxQLastRound = FALSE;
234
235 /* For USB, didn't need PCI_MAP_SINGLE() */
236 /*SrcBufPA = PCI_MAP_SINGLE(pAd, (char *) pTxBlk->pSrcBufData, pTxBlk->SrcBufLen, PCI_DMA_TODEVICE); */
237
238 /* */
239 /* get Tx Ring Resource & Dma Buffer address */
240 /* */
241 QueIdx = pTxBlk->QueIdx;
242
243 RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
244 pHTTXContext = &pAd->TxContext[QueIdx];
245 fillOffset = pHTTXContext->CurWritePosition;
246
247 /* Check ring full. */
248 Status = RtmpUSBCanDoWrite(pAd, QueIdx, pHTTXContext);
249 if (Status == NDIS_STATUS_SUCCESS) {
250 pHTTXContext->bCurWriting = TRUE;
251
252 pTxInfo = (struct rt_txinfo *)(&pTxBlk->HeaderBuf[0]);
253 pTxWI = (struct rt_txwi *) (&pTxBlk->HeaderBuf[TXINFO_SIZE]);
254
255 /* Reserve space for 8 bytes padding. */
256 if ((pHTTXContext->ENextBulkOutPosition ==
257 pHTTXContext->CurWritePosition)) {
258 pHTTXContext->ENextBulkOutPosition += 8;
259 pHTTXContext->CurWritePosition += 8;
260 fillOffset += 8;
261 }
262 pHTTXContext->CurWriteRealPos = pHTTXContext->CurWritePosition;
263
264 pWirelessPacket =
265 &pHTTXContext->TransferBuffer->field.
266 WirelessPacket[fillOffset];
267
268 /* copy TXWI + WLAN Header + LLC into DMA Header Buffer */
269 /*hwHdrLen = ROUND_UP(pTxBlk->MpduHeaderLen, 4); */
270 hwHdrLen = pTxBlk->MpduHeaderLen + pTxBlk->HdrPadLen;
271
272 /* Build our URB for USBD */
273 DMAHdrLen = TXWI_SIZE + hwHdrLen;
274 USBDMApktLen = DMAHdrLen + pTxBlk->SrcBufLen;
275 padding = (4 - (USBDMApktLen % 4)) & 0x03; /* round up to 4 byte alignment */
276 USBDMApktLen += padding;
277
278 pTxBlk->Priv = (TXINFO_SIZE + USBDMApktLen);
279
280 /* For TxInfo, the length of USBDMApktLen = TXWI_SIZE + 802.11 header + payload */
281 RTMPWriteTxInfo(pAd, pTxInfo, (u16)(USBDMApktLen), FALSE,
282 FIFO_EDCA, FALSE /*NextValid */ , FALSE);
283
284 if ((pHTTXContext->CurWritePosition + 3906 + pTxBlk->Priv) >
285 MAX_TXBULK_LIMIT) {
286 pTxInfo->SwUseLastRound = 1;
287 bTxQLastRound = TRUE;
288 }
289 NdisMoveMemory(pWirelessPacket, pTxBlk->HeaderBuf,
290 TXINFO_SIZE + TXWI_SIZE + hwHdrLen);
291 pWirelessPacket += (TXINFO_SIZE + TXWI_SIZE + hwHdrLen);
292
293 /* We unlock it here to prevent the first 8 bytes maybe over-writed issue. */
294 /* 1. First we got CurWritePosition but the first 8 bytes still not write to the pTxcontext. */
295 /* 2. An interrupt break our routine and handle bulk-out complete. */
296 /* 3. In the bulk-out compllete, it need to do another bulk-out, */
297 /* if the ENextBulkOutPosition is just the same as CurWritePosition, it will save the first 8 bytes from CurWritePosition, */
298 /* but the payload still not copyed. the pTxContext->SavedPad[] will save as allzero. and set the bCopyPad = TRUE. */
299 /* 4. Interrupt complete. */
300 /* 5. Our interrupted routine go back and fill the first 8 bytes to pTxContext. */
301 /* 6. Next time when do bulk-out, it found the bCopyPad==TRUE and will copy the SavedPad[] to pTxContext->NextBulkOutPosition. */
302 /* and the packet will wrong. */
303 pHTTXContext->CurWriteRealPos +=
304 (TXINFO_SIZE + TXWI_SIZE + hwHdrLen);
305 RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
306
307 NdisMoveMemory(pWirelessPacket, pTxBlk->pSrcBufData,
308 pTxBlk->SrcBufLen);
309 pWirelessPacket += pTxBlk->SrcBufLen;
310 NdisZeroMemory(pWirelessPacket, padding + 8);
311
312 RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
313
314 pHTTXContext->CurWritePosition += pTxBlk->Priv;
315 if (bTxQLastRound)
316 pHTTXContext->CurWritePosition = 8;
317 pHTTXContext->CurWriteRealPos = pHTTXContext->CurWritePosition;
318
319 pHTTXContext->bCurWriting = FALSE;
320 }
321
322 RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
323
324 /* succeed and release the skb buffer */
325 RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_SUCCESS);
326
327 return (Status);
328
329 }
330
331 u16 RtmpUSB_WriteMultiTxResource(struct rt_rtmp_adapter *pAd,
332 struct rt_tx_blk *pTxBlk,
333 u8 frameNum, u16 * FreeNumber)
334 {
335 struct rt_ht_tx_context *pHTTXContext;
336 u16 hwHdrLen; /* The hwHdrLen consist of 802.11 header length plus the header padding length. */
337 u32 fillOffset;
338 struct rt_txinfo *pTxInfo;
339 struct rt_txwi *pTxWI;
340 u8 *pWirelessPacket = NULL;
341 u8 QueIdx;
342 int Status;
343 unsigned long IrqFlags;
344 /*u32 USBDMApktLen = 0, DMAHdrLen, padding; */
345
346 /* */
347 /* get Tx Ring Resource & Dma Buffer address */
348 /* */
349 QueIdx = pTxBlk->QueIdx;
350 pHTTXContext = &pAd->TxContext[QueIdx];
351
352 RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
353
354 if (frameNum == 0) {
355 /* Check if we have enough space for this bulk-out batch. */
356 Status = RtmpUSBCanDoWrite(pAd, QueIdx, pHTTXContext);
357 if (Status == NDIS_STATUS_SUCCESS) {
358 pHTTXContext->bCurWriting = TRUE;
359
360 pTxInfo = (struct rt_txinfo *)(&pTxBlk->HeaderBuf[0]);
361 pTxWI = (struct rt_txwi *) (&pTxBlk->HeaderBuf[TXINFO_SIZE]);
362
363 /* Reserve space for 8 bytes padding. */
364 if ((pHTTXContext->ENextBulkOutPosition ==
365 pHTTXContext->CurWritePosition)) {
366
367 pHTTXContext->CurWritePosition += 8;
368 pHTTXContext->ENextBulkOutPosition += 8;
369 }
370 fillOffset = pHTTXContext->CurWritePosition;
371 pHTTXContext->CurWriteRealPos =
372 pHTTXContext->CurWritePosition;
373
374 pWirelessPacket =
375 &pHTTXContext->TransferBuffer->field.
376 WirelessPacket[fillOffset];
377
378 /* */
379 /* Copy TXINFO + TXWI + WLAN Header + LLC into DMA Header Buffer */
380 /* */
381 if (pTxBlk->TxFrameType == TX_AMSDU_FRAME)
382 /*hwHdrLen = ROUND_UP(pTxBlk->MpduHeaderLen-LENGTH_AMSDU_SUBFRAMEHEAD, 4)+LENGTH_AMSDU_SUBFRAMEHEAD; */
383 hwHdrLen =
384 pTxBlk->MpduHeaderLen -
385 LENGTH_AMSDU_SUBFRAMEHEAD +
386 pTxBlk->HdrPadLen +
387 LENGTH_AMSDU_SUBFRAMEHEAD;
388 else if (pTxBlk->TxFrameType == TX_RALINK_FRAME)
389 /*hwHdrLen = ROUND_UP(pTxBlk->MpduHeaderLen-LENGTH_ARALINK_HEADER_FIELD, 4)+LENGTH_ARALINK_HEADER_FIELD; */
390 hwHdrLen =
391 pTxBlk->MpduHeaderLen -
392 LENGTH_ARALINK_HEADER_FIELD +
393 pTxBlk->HdrPadLen +
394 LENGTH_ARALINK_HEADER_FIELD;
395 else
396 /*hwHdrLen = ROUND_UP(pTxBlk->MpduHeaderLen, 4); */
397 hwHdrLen =
398 pTxBlk->MpduHeaderLen + pTxBlk->HdrPadLen;
399
400 /* Update the pTxBlk->Priv. */
401 pTxBlk->Priv = TXINFO_SIZE + TXWI_SIZE + hwHdrLen;
402
403 /* pTxInfo->USBDMApktLen now just a temp value and will to correct latter. */
404 RTMPWriteTxInfo(pAd, pTxInfo, (u16)(pTxBlk->Priv),
405 FALSE, FIFO_EDCA, FALSE /*NextValid */ ,
406 FALSE);
407
408 /* Copy it. */
409 NdisMoveMemory(pWirelessPacket, pTxBlk->HeaderBuf,
410 pTxBlk->Priv);
411 pHTTXContext->CurWriteRealPos += pTxBlk->Priv;
412 pWirelessPacket += pTxBlk->Priv;
413 }
414 } else { /* For sub-sequent frames of this bulk-out batch. Just copy it to our bulk-out buffer. */
415
416 Status =
417 ((pHTTXContext->bCurWriting ==
418 TRUE) ? NDIS_STATUS_SUCCESS : NDIS_STATUS_FAILURE);
419 if (Status == NDIS_STATUS_SUCCESS) {
420 fillOffset =
421 (pHTTXContext->CurWritePosition + pTxBlk->Priv);
422 pWirelessPacket =
423 &pHTTXContext->TransferBuffer->field.
424 WirelessPacket[fillOffset];
425
426 /*hwHdrLen = pTxBlk->MpduHeaderLen; */
427 NdisMoveMemory(pWirelessPacket, pTxBlk->HeaderBuf,
428 pTxBlk->MpduHeaderLen);
429 pWirelessPacket += (pTxBlk->MpduHeaderLen);
430 pTxBlk->Priv += pTxBlk->MpduHeaderLen;
431 } else { /* It should not happened now unless we are going to shutdown. */
432 DBGPRINT(RT_DEBUG_ERROR,
433 ("WriteMultiTxResource():bCurWriting is FALSE when handle sub-sequent frames.\n"));
434 Status = NDIS_STATUS_FAILURE;
435 }
436 }
437
438 /* We unlock it here to prevent the first 8 bytes maybe over-write issue. */
439 /* 1. First we got CurWritePosition but the first 8 bytes still not write to the pTxContext. */
440 /* 2. An interrupt break our routine and handle bulk-out complete. */
441 /* 3. In the bulk-out compllete, it need to do another bulk-out, */
442 /* if the ENextBulkOutPosition is just the same as CurWritePosition, it will save the first 8 bytes from CurWritePosition, */
443 /* but the payload still not copyed. the pTxContext->SavedPad[] will save as allzero. and set the bCopyPad = TRUE. */
444 /* 4. Interrupt complete. */
445 /* 5. Our interrupted routine go back and fill the first 8 bytes to pTxContext. */
446 /* 6. Next time when do bulk-out, it found the bCopyPad==TRUE and will copy the SavedPad[] to pTxContext->NextBulkOutPosition. */
447 /* and the packet will wrong. */
448 RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
449
450 if (Status != NDIS_STATUS_SUCCESS) {
451 DBGPRINT(RT_DEBUG_ERROR,
452 ("WriteMultiTxResource: CWPos = %ld, NBOutPos = %ld.\n",
453 pHTTXContext->CurWritePosition,
454 pHTTXContext->NextBulkOutPosition));
455 goto done;
456 }
457 /* Copy the frame content into DMA buffer and update the pTxBlk->Priv */
458 NdisMoveMemory(pWirelessPacket, pTxBlk->pSrcBufData, pTxBlk->SrcBufLen);
459 pWirelessPacket += pTxBlk->SrcBufLen;
460 pTxBlk->Priv += pTxBlk->SrcBufLen;
461
462 done:
463 /* Release the skb buffer here */
464 RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_SUCCESS);
465
466 return (Status);
467
468 }
469
470 void RtmpUSB_FinalWriteTxResource(struct rt_rtmp_adapter *pAd,
471 struct rt_tx_blk *pTxBlk,
472 u16 totalMPDUSize, u16 TxIdx)
473 {
474 u8 QueIdx;
475 struct rt_ht_tx_context *pHTTXContext;
476 u32 fillOffset;
477 struct rt_txinfo *pTxInfo;
478 struct rt_txwi *pTxWI;
479 u32 USBDMApktLen, padding;
480 unsigned long IrqFlags;
481 u8 *pWirelessPacket;
482
483 QueIdx = pTxBlk->QueIdx;
484 pHTTXContext = &pAd->TxContext[QueIdx];
485
486 RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
487
488 if (pHTTXContext->bCurWriting == TRUE) {
489 fillOffset = pHTTXContext->CurWritePosition;
490 if (((pHTTXContext->ENextBulkOutPosition ==
491 pHTTXContext->CurWritePosition)
492 || ((pHTTXContext->ENextBulkOutPosition - 8) ==
493 pHTTXContext->CurWritePosition))
494 && (pHTTXContext->bCopySavePad == TRUE))
495 pWirelessPacket = (u8 *)(&pHTTXContext->SavedPad[0]);
496 else
497 pWirelessPacket =
498 (u8 *)(&pHTTXContext->TransferBuffer->field.
499 WirelessPacket[fillOffset]);
500
501 /* */
502 /* Update TxInfo->USBDMApktLen , */
503 /* the length = TXWI_SIZE + 802.11_hdr + 802.11_hdr_pad + payload_of_all_batch_frames + Bulk-Out-padding */
504 /* */
505 pTxInfo = (struct rt_txinfo *)(pWirelessPacket);
506
507 /* Calculate the bulk-out padding */
508 USBDMApktLen = pTxBlk->Priv - TXINFO_SIZE;
509 padding = (4 - (USBDMApktLen % 4)) & 0x03; /* round up to 4 byte alignment */
510 USBDMApktLen += padding;
511
512 pTxInfo->USBDMATxPktLen = USBDMApktLen;
513
514 /* */
515 /* Update TXWI->MPDUtotalByteCount , */
516 /* the length = 802.11 header + payload_of_all_batch_frames */
517 pTxWI = (struct rt_txwi *) (pWirelessPacket + TXINFO_SIZE);
518 pTxWI->MPDUtotalByteCount = totalMPDUSize;
519
520 /* */
521 /* Update the pHTTXContext->CurWritePosition */
522 /* */
523 pHTTXContext->CurWritePosition += (TXINFO_SIZE + USBDMApktLen);
524 if ((pHTTXContext->CurWritePosition + 3906) > MAX_TXBULK_LIMIT) { /* Add 3906 for prevent the NextBulkOut packet size is a A-RALINK/A-MSDU Frame. */
525 pHTTXContext->CurWritePosition = 8;
526 pTxInfo->SwUseLastRound = 1;
527 }
528 pHTTXContext->CurWriteRealPos = pHTTXContext->CurWritePosition;
529
530 /* */
531 /* Zero the last padding. */
532 /* */
533 pWirelessPacket =
534 (&pHTTXContext->TransferBuffer->field.
535 WirelessPacket[fillOffset + pTxBlk->Priv]);
536 NdisZeroMemory(pWirelessPacket, padding + 8);
537
538 /* Finally, set bCurWriting as FALSE */
539 pHTTXContext->bCurWriting = FALSE;
540
541 } else { /* It should not happened now unless we are going to shutdown. */
542 DBGPRINT(RT_DEBUG_ERROR,
543 ("FinalWriteTxResource():bCurWriting is FALSE when handle last frames.\n"));
544 }
545
546 RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
547
548 }
549
550 void RtmpUSBDataLastTxIdx(struct rt_rtmp_adapter *pAd,
551 u8 QueIdx, u16 TxIdx)
552 {
553 /* DO nothing for USB. */
554 }
555
556 /*
557 When can do bulk-out:
558 1. TxSwFreeIdx < TX_RING_SIZE;
559 It means has at least one Ring entity is ready for bulk-out, kick it out.
560 2. If TxSwFreeIdx == TX_RING_SIZE
561 Check if the CurWriting flag is FALSE, if it's FALSE, we can do kick out.
562
563 */
564 void RtmpUSBDataKickOut(struct rt_rtmp_adapter *pAd,
565 struct rt_tx_blk *pTxBlk, u8 QueIdx)
566 {
567 RTUSB_SET_BULK_FLAG(pAd, (fRTUSB_BULK_OUT_DATA_NORMAL << QueIdx));
568 RTUSBKickBulkOut(pAd);
569
570 }
571
572 /*
573 Must be run in Interrupt context
574 This function handle RT2870 specific TxDesc and cpu index update and kick the packet out.
575 */
576 int RtmpUSBMgmtKickOut(struct rt_rtmp_adapter *pAd,
577 u8 QueIdx,
578 void *pPacket,
579 u8 *pSrcBufVA, u32 SrcBufLen)
580 {
581 struct rt_txinfo *pTxInfo;
582 unsigned long BulkOutSize;
583 u8 padLen;
584 u8 *pDest;
585 unsigned long SwIdx = pAd->MgmtRing.TxCpuIdx;
586 struct rt_tx_context *pMLMEContext =
587 (struct rt_tx_context *)pAd->MgmtRing.Cell[SwIdx].AllocVa;
588 unsigned long IrqFlags;
589
590 pTxInfo = (struct rt_txinfo *)(pSrcBufVA);
591
592 /* Build our URB for USBD */
593 BulkOutSize = SrcBufLen;
594 BulkOutSize = (BulkOutSize + 3) & (~3);
595 RTMPWriteTxInfo(pAd, pTxInfo, (u16)(BulkOutSize - TXINFO_SIZE),
596 TRUE, EpToQueue[MGMTPIPEIDX], FALSE, FALSE);
597
598 BulkOutSize += 4; /* Always add 4 extra bytes at every packet. */
599
600 /* If BulkOutSize is multiple of BulkOutMaxPacketSize, add extra 4 bytes again. */
601 if ((BulkOutSize % pAd->BulkOutMaxPacketSize) == 0)
602 BulkOutSize += 4;
603
604 padLen = BulkOutSize - SrcBufLen;
605 ASSERT((padLen <= RTMP_PKT_TAIL_PADDING));
606
607 /* Now memzero all extra padding bytes. */
608 pDest = (u8 *)(pSrcBufVA + SrcBufLen);
609 skb_put(GET_OS_PKT_TYPE(pPacket), padLen);
610 NdisZeroMemory(pDest, padLen);
611
612 RTMP_IRQ_LOCK(&pAd->MLMEBulkOutLock, IrqFlags);
613
614 pAd->MgmtRing.Cell[pAd->MgmtRing.TxCpuIdx].pNdisPacket = pPacket;
615 pMLMEContext->TransferBuffer =
616 (struct rt_tx_buffer *)(GET_OS_PKT_DATAPTR(pPacket));
617
618 /* Length in TxInfo should be 8 less than bulkout size. */
619 pMLMEContext->BulkOutSize = BulkOutSize;
620 pMLMEContext->InUse = TRUE;
621 pMLMEContext->bWaitingBulkOut = TRUE;
622
623 /*for debug */
624 /*hex_dump("RtmpUSBMgmtKickOut", &pMLMEContext->TransferBuffer->field.WirelessPacket[0], (pMLMEContext->BulkOutSize > 16 ? 16 : pMLMEContext->BulkOutSize)); */
625
626 /*pAd->RalinkCounters.KickTxCount++; */
627 /*pAd->RalinkCounters.OneSecTxDoneCount++; */
628
629 /*if (pAd->MgmtRing.TxSwFreeIdx == MGMT_RING_SIZE) */
630 /* needKickOut = TRUE; */
631
632 /* Decrease the TxSwFreeIdx and Increase the TX_CTX_IDX */
633 pAd->MgmtRing.TxSwFreeIdx--;
634 INC_RING_INDEX(pAd->MgmtRing.TxCpuIdx, MGMT_RING_SIZE);
635
636 RTMP_IRQ_UNLOCK(&pAd->MLMEBulkOutLock, IrqFlags);
637
638 RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_MLME);
639 /*if (needKickOut) */
640 RTUSBKickBulkOut(pAd);
641
642 return 0;
643 }
644
645 void RtmpUSBNullFrameKickOut(struct rt_rtmp_adapter *pAd,
646 u8 QueIdx,
647 u8 * pNullFrame, u32 frameLen)
648 {
649 if (pAd->NullContext.InUse == FALSE) {
650 struct rt_tx_context *pNullContext;
651 struct rt_txinfo *pTxInfo;
652 struct rt_txwi * pTxWI;
653 u8 *pWirelessPkt;
654
655 pNullContext = &(pAd->NullContext);
656
657 /* Set the in use bit */
658 pNullContext->InUse = TRUE;
659 pWirelessPkt =
660 (u8 *)& pNullContext->TransferBuffer->field.
661 WirelessPacket[0];
662
663 RTMPZeroMemory(&pWirelessPkt[0], 100);
664 pTxInfo = (struct rt_txinfo *)& pWirelessPkt[0];
665 RTMPWriteTxInfo(pAd, pTxInfo,
666 (u16)(sizeof(struct rt_header_802_11) + TXWI_SIZE),
667 TRUE, EpToQueue[MGMTPIPEIDX], FALSE, FALSE);
668 pTxInfo->QSEL = FIFO_EDCA;
669 pTxWI = (struct rt_txwi *) & pWirelessPkt[TXINFO_SIZE];
670 RTMPWriteTxWI(pAd, pTxWI, FALSE, FALSE, FALSE, FALSE, TRUE,
671 FALSE, 0, BSSID_WCID, (sizeof(struct rt_header_802_11)), 0,
672 0, (u8)pAd->CommonCfg.MlmeTransmit.field.MCS,
673 IFS_HTTXOP, FALSE, &pAd->CommonCfg.MlmeTransmit);
674
675 RTMPMoveMemory(&pWirelessPkt[TXWI_SIZE + TXINFO_SIZE],
676 &pAd->NullFrame, sizeof(struct rt_header_802_11));
677 pAd->NullContext.BulkOutSize =
678 TXINFO_SIZE + TXWI_SIZE + sizeof(pAd->NullFrame) + 4;
679
680 /* Fill out frame length information for global Bulk out arbitor */
681 /*pNullContext->BulkOutSize = TransferBufferLength; */
682 DBGPRINT(RT_DEBUG_TRACE,
683 ("SYNC - send NULL Frame @%d Mbps...\n",
684 RateIdToMbps[pAd->CommonCfg.TxRate]));
685 RTUSB_SET_BULK_FLAG(pAd, fRTUSB_BULK_OUT_DATA_NULL);
686
687 /* Kick bulk out */
688 RTUSBKickBulkOut(pAd);
689 }
690
691 }
692
693 /*
694 ========================================================================
695 Routine Description:
696 Get a received packet.
697
698 Arguments:
699 pAd device control block
700 pSaveRxD receive descriptor information
701 *pbReschedule need reschedule flag
702 *pRxPending pending received packet flag
703
704 Return Value:
705 the received packet
706
707 Note:
708 ========================================================================
709 */
710 void *GetPacketFromRxRing(struct rt_rtmp_adapter *pAd,
711 OUT PRT28XX_RXD_STRUC pSaveRxD,
712 OUT BOOLEAN * pbReschedule,
713 IN u32 * pRxPending)
714 {
715 struct rt_rx_context *pRxContext;
716 void *pSkb;
717 u8 *pData;
718 unsigned long ThisFrameLen;
719 unsigned long RxBufferLength;
720 struct rt_rxwi * pRxWI;
721
722 pRxContext = &pAd->RxContext[pAd->NextRxBulkInReadIndex];
723 if ((pRxContext->Readable == FALSE) || (pRxContext->InUse == TRUE))
724 return NULL;
725
726 RxBufferLength = pRxContext->BulkInOffset - pAd->ReadPosition;
727 if (RxBufferLength <
728 (RT2870_RXDMALEN_FIELD_SIZE + sizeof(struct rt_rxwi) +
729 sizeof(struct rt_rxinfo))) {
730 goto label_null;
731 }
732
733 pData = &pRxContext->TransferBuffer[pAd->ReadPosition]; /* 4KB */
734 /* The RXDMA field is 4 bytes, now just use the first 2 bytes. The Length including the (RXWI + MSDU + Padding) */
735 ThisFrameLen = *pData + (*(pData + 1) << 8);
736 if (ThisFrameLen == 0) {
737 DBGPRINT(RT_DEBUG_TRACE,
738 ("BIRIdx(%d): RXDMALen is zero.[%ld], BulkInBufLen = %ld)\n",
739 pAd->NextRxBulkInReadIndex, ThisFrameLen,
740 pRxContext->BulkInOffset));
741 goto label_null;
742 }
743 if ((ThisFrameLen & 0x3) != 0) {
744 DBGPRINT(RT_DEBUG_ERROR,
745 ("BIRIdx(%d): RXDMALen not multiple of 4.[%ld], BulkInBufLen = %ld)\n",
746 pAd->NextRxBulkInReadIndex, ThisFrameLen,
747 pRxContext->BulkInOffset));
748 goto label_null;
749 }
750
751 if ((ThisFrameLen + 8) > RxBufferLength) /* 8 for (RT2870_RXDMALEN_FIELD_SIZE + sizeof(struct rt_rxinfo)) */
752 {
753 DBGPRINT(RT_DEBUG_TRACE,
754 ("BIRIdx(%d):FrameLen(0x%lx) outranges. BulkInLen=0x%lx, remaining RxBufLen=0x%lx, ReadPos=0x%lx\n",
755 pAd->NextRxBulkInReadIndex, ThisFrameLen,
756 pRxContext->BulkInOffset, RxBufferLength,
757 pAd->ReadPosition));
758
759 /* error frame. finish this loop */
760 goto label_null;
761 }
762 /* skip USB frame length field */
763 pData += RT2870_RXDMALEN_FIELD_SIZE;
764 pRxWI = (struct rt_rxwi *) pData;
765 if (pRxWI->MPDUtotalByteCount > ThisFrameLen) {
766 DBGPRINT(RT_DEBUG_ERROR,
767 ("%s():pRxWIMPDUtotalByteCount(%d) large than RxDMALen(%ld)\n",
768 __FUNCTION__, pRxWI->MPDUtotalByteCount,
769 ThisFrameLen));
770 goto label_null;
771 }
772 /* allocate a rx packet */
773 pSkb = dev_alloc_skb(ThisFrameLen);
774 if (pSkb == NULL) {
775 DBGPRINT(RT_DEBUG_ERROR,
776 ("%s():Cannot Allocate sk buffer for this Bulk-In buffer!\n",
777 __FUNCTION__));
778 goto label_null;
779 }
780 /* copy the rx packet */
781 memcpy(skb_put(pSkb, ThisFrameLen), pData, ThisFrameLen);
782 RTPKT_TO_OSPKT(pSkb)->dev = get_netdev_from_bssid(pAd, BSS0);
783 RTMP_SET_PACKET_SOURCE(OSPKT_TO_RTPKT(pSkb), PKTSRC_NDIS);
784
785 /* copy RxD */
786 *pSaveRxD = *(struct rt_rxinfo *) (pData + ThisFrameLen);
787
788 /* update next packet read position. */
789 pAd->ReadPosition += (ThisFrameLen + RT2870_RXDMALEN_FIELD_SIZE + RXINFO_SIZE); /* 8 for (RT2870_RXDMALEN_FIELD_SIZE + sizeof(struct rt_rxinfo)) */
790
791 return pSkb;
792
793 label_null:
794
795 return NULL;
796 }
797
798 /*
799 ========================================================================
800
801 Routine Description:
802 Check Rx descriptor, return NDIS_STATUS_FAILURE if any error dound
803
804 Arguments:
805 pRxD Pointer to the Rx descriptor
806
807 Return Value:
808 NDIS_STATUS_SUCCESS No err
809 NDIS_STATUS_FAILURE Error
810
811 Note:
812
813 ========================================================================
814 */
815 int RTMPCheckRxError(struct rt_rtmp_adapter *pAd,
816 struct rt_header_802_11 * pHeader,
817 struct rt_rxwi * pRxWI, IN PRT28XX_RXD_STRUC pRxINFO)
818 {
819 struct rt_cipher_key *pWpaKey;
820 int dBm;
821
822 if (pAd->bPromiscuous == TRUE)
823 return (NDIS_STATUS_SUCCESS);
824 if (pRxINFO == NULL)
825 return (NDIS_STATUS_FAILURE);
826
827 /* Phy errors & CRC errors */
828 if (pRxINFO->Crc) {
829 /* Check RSSI for Noise Hist statistic collection. */
830 dBm = (int)(pRxWI->RSSI0) - pAd->BbpRssiToDbmDelta;
831 if (dBm <= -87)
832 pAd->StaCfg.RPIDensity[0] += 1;
833 else if (dBm <= -82)
834 pAd->StaCfg.RPIDensity[1] += 1;
835 else if (dBm <= -77)
836 pAd->StaCfg.RPIDensity[2] += 1;
837 else if (dBm <= -72)
838 pAd->StaCfg.RPIDensity[3] += 1;
839 else if (dBm <= -67)
840 pAd->StaCfg.RPIDensity[4] += 1;
841 else if (dBm <= -62)
842 pAd->StaCfg.RPIDensity[5] += 1;
843 else if (dBm <= -57)
844 pAd->StaCfg.RPIDensity[6] += 1;
845 else if (dBm > -57)
846 pAd->StaCfg.RPIDensity[7] += 1;
847
848 return (NDIS_STATUS_FAILURE);
849 }
850 /* Add Rx size to channel load counter, we should ignore error counts */
851 pAd->StaCfg.CLBusyBytes += (pRxWI->MPDUtotalByteCount + 14);
852
853 /* Drop ToDs promiscuous frame, it is opened due to CCX 2 channel load statistics */
854 if (pHeader->FC.ToDs) {
855 DBGPRINT_RAW(RT_DEBUG_ERROR, ("Err;FC.ToDs\n"));
856 return NDIS_STATUS_FAILURE;
857 }
858 /* Paul 04-03 for OFDM Rx length issue */
859 if (pRxWI->MPDUtotalByteCount > MAX_AGGREGATION_SIZE) {
860 DBGPRINT_RAW(RT_DEBUG_ERROR, ("received packet too long\n"));
861 return NDIS_STATUS_FAILURE;
862 }
863 /* Drop not U2M frames, can't drop here because we will drop beacon in this case */
864 /* I am kind of doubting the U2M bit operation */
865 /* if (pRxD->U2M == 0) */
866 /* return(NDIS_STATUS_FAILURE); */
867
868 /* drop decyption fail frame */
869 if (pRxINFO->Decrypted && pRxINFO->CipherErr) {
870
871 if (((pRxINFO->CipherErr & 1) == 1)
872 && pAd->CommonCfg.bWirelessEvent && INFRA_ON(pAd))
873 RTMPSendWirelessEvent(pAd, IW_ICV_ERROR_EVENT_FLAG,
874 pAd->MacTab.Content[BSSID_WCID].
875 Addr, BSS0, 0);
876
877 if (((pRxINFO->CipherErr & 2) == 2)
878 && pAd->CommonCfg.bWirelessEvent && INFRA_ON(pAd))
879 RTMPSendWirelessEvent(pAd, IW_MIC_ERROR_EVENT_FLAG,
880 pAd->MacTab.Content[BSSID_WCID].
881 Addr, BSS0, 0);
882 /* */
883 /* MIC Error */
884 /* */
885 if ((pRxINFO->CipherErr == 2) && pRxINFO->MyBss) {
886 pWpaKey = &pAd->SharedKey[BSS0][pRxWI->KeyIndex];
887 RTMPReportMicError(pAd, pWpaKey);
888 DBGPRINT_RAW(RT_DEBUG_ERROR, ("Rx MIC Value error\n"));
889 }
890
891 if (pRxINFO->Decrypted &&
892 (pAd->SharedKey[BSS0][pRxWI->KeyIndex].CipherAlg ==
893 CIPHER_AES)
894 && (pHeader->Sequence == pAd->FragFrame.Sequence)) {
895 /* */
896 /* Acceptable since the First FragFrame no CipherErr problem. */
897 /* */
898 return (NDIS_STATUS_SUCCESS);
899 }
900
901 return (NDIS_STATUS_FAILURE);
902 }
903
904 return (NDIS_STATUS_SUCCESS);
905 }
906
907 void RtmpUsbStaAsicForceWakeupTimeout(void *SystemSpecific1,
908 void *FunctionContext,
909 void *SystemSpecific2,
910 void *SystemSpecific3)
911 {
912 struct rt_rtmp_adapter *pAd = (struct rt_rtmp_adapter *)FunctionContext;
913
914 if (pAd && pAd->Mlme.AutoWakeupTimerRunning) {
915 AsicSendCommandToMcu(pAd, 0x31, 0xff, 0x00, 0x02);
916
917 OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_DOZE);
918 pAd->Mlme.AutoWakeupTimerRunning = FALSE;
919 }
920 }
921
922 void RT28xxUsbStaAsicForceWakeup(struct rt_rtmp_adapter *pAd, IN BOOLEAN bFromTx)
923 {
924 BOOLEAN Canceled;
925
926 if (pAd->Mlme.AutoWakeupTimerRunning)
927 RTMPCancelTimer(&pAd->Mlme.AutoWakeupTimer, &Canceled);
928
929 AsicSendCommandToMcu(pAd, 0x31, 0xff, 0x00, 0x02);
930
931 OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_DOZE);
932 }
933
934 void RT28xxUsbStaAsicSleepThenAutoWakeup(struct rt_rtmp_adapter *pAd,
935 u16 TbttNumToNextWakeUp)
936 {
937
938 /* we have decided to SLEEP, so at least do it for a BEACON period. */
939 if (TbttNumToNextWakeUp == 0)
940 TbttNumToNextWakeUp = 1;
941
942 RTMPSetTimer(&pAd->Mlme.AutoWakeupTimer, AUTO_WAKEUP_TIMEOUT);
943 pAd->Mlme.AutoWakeupTimerRunning = TRUE;
944
945 AsicSendCommandToMcu(pAd, 0x30, 0xff, 0xff, 0x02); /* send POWER-SAVE command to MCU. Timeout 40us. */
946
947 OPSTATUS_SET_FLAG(pAd, fOP_STATUS_DOZE);
948
949 }
950
951 #endif /* RTMP_MAC_USB // */
kernel source for telekom puls (alcatel/mediatek)