273 TUint8* MgmtFrameMemMngr::DoGetNextFreeRxBuffer( TUint aLengthinBytes ) |
275 TUint8* MgmtFrameMemMngr::DoGetNextFreeRxBuffer( TUint aLengthinBytes ) |
274 { |
276 { |
275 TraceDump( RX_FRAME, |
277 TraceDump( RX_FRAME, |
276 ("WLANLDD: MgmtFrameMemMngr::DoGetNextFreeRxBuffer") ); |
278 ("WLANLDD: MgmtFrameMemMngr::DoGetNextFreeRxBuffer") ); |
277 |
279 |
278 // if there are any Rx buffers which have been handled and |
|
279 // can already be re-used, free them first |
|
280 |
|
281 const TUint32* rxHandledBuffersArray ( NULL ); |
|
282 TUint32 numOfHandled ( 0 ); |
|
283 |
|
284 iFrameXferBlock->KeGetHandledRxBuffers( |
|
285 rxHandledBuffersArray, |
|
286 numOfHandled ); |
|
287 |
|
288 if ( numOfHandled ) |
|
289 { |
|
290 // there are buffers which can be freed, so free them |
|
291 for ( TUint i = 0; i < numOfHandled; ++i ) |
|
292 { |
|
293 // first free the actual Rx frame buffer |
|
294 |
|
295 TraceDump( RX_FRAME, |
|
296 (("WLANLDD: MgmtFrameMemMngr::DoGetNextFreeRxBuffer: free Rx buf at addr: 0x%08x"), |
|
297 reinterpret_cast<TUint32>(reinterpret_cast<TDataBuffer*>( |
|
298 iRxDataChunk |
|
299 + rxHandledBuffersArray[i])->KeGetBufferStart()) ) ); |
|
300 |
|
301 iRxFrameMemoryPool->Free( |
|
302 reinterpret_cast<TDataBuffer*>( |
|
303 iRxDataChunk + rxHandledBuffersArray[i])->KeGetBufferStart() |
|
304 // take into account the alignment padding |
|
305 - iRxBufAlignmentPadding ); |
|
306 |
|
307 // then free the Rx frame meta header |
|
308 |
|
309 TraceDump( RX_FRAME, |
|
310 (("WLANLDD: MgmtFrameMemMngr::DoGetNextFreeRxBuffer: free Rx meta header at addr: 0x%08x"), |
|
311 reinterpret_cast<TUint32>( iRxDataChunk + rxHandledBuffersArray[i])) ); |
|
312 |
|
313 iRxFrameMemoryPool->Free( iRxDataChunk + rxHandledBuffersArray[i] ); |
|
314 } |
|
315 |
|
316 // remove the buffers we freed above from the completed buffers of this |
|
317 // object so that they are not tried to be freed again once the Mgmt |
|
318 // Client issues the next Rx request |
|
319 |
|
320 iCountCompleted -= numOfHandled; |
|
321 assign( |
|
322 iCompletedBuffers + numOfHandled, |
|
323 iCompletedBuffers, |
|
324 iCountCompleted ); |
|
325 } |
|
326 |
|
327 // reserve a new Rx buffer. |
280 // reserve a new Rx buffer. |
328 |
281 |
329 TUint8* buffer ( NULL ); |
282 TUint8* buffer ( NULL ); |
330 |
283 |
331 if ( iRxFrameMemoryPool ) |
284 if ( iRxFrameMemoryPool ) |
364 // --------------------------------------------------------------------------- |
317 // --------------------------------------------------------------------------- |
365 // |
318 // |
366 // --------------------------------------------------------------------------- |
319 // --------------------------------------------------------------------------- |
367 // |
320 // |
368 TBool MgmtFrameMemMngr::DoEthernetFrameRxComplete( |
321 TBool MgmtFrameMemMngr::DoEthernetFrameRxComplete( |
369 const TDataBuffer*& aBufferStart, |
322 TDataBuffer*& aBufferStart, |
370 TUint32 aNumOfBuffers ) |
323 TUint32 aNumOfBuffers ) |
371 { |
324 { |
372 TraceDump( RX_FRAME, |
325 TraceDump( RX_FRAME, |
373 (("WLANLDD: MgmtFrameMemMngr::DoEthernetFrameRxComplete: aNumOfBuffers: %d"), |
326 (("WLANLDD: MgmtFrameMemMngr::DoEthernetFrameRxComplete: " |
|
327 "aNumOfBuffers: %d"), |
374 aNumOfBuffers) ); |
328 aNumOfBuffers) ); |
375 |
329 |
376 if ( aNumOfBuffers + iCountTobeCompleted > KMaxToBeCompletedRxBufs ) |
|
377 { |
|
378 // too little space reserved for Rx buffer handles |
|
379 os_assert( (TUint8*)("WLANLDD: panic"), (TUint8*)(WLAN_FILE), __LINE__ ); |
|
380 } |
|
381 |
|
382 TBool ret( EFalse ); |
330 TBool ret( EFalse ); |
383 |
331 TDataBuffer** metaHdrPtrArray(&aBufferStart); |
384 if ( iReadStatus == EPending ) |
332 |
385 { |
333 if ( iFrameXferBlock ) |
386 // read pending |
334 { |
387 if ( !iCountTobeCompleted ) |
335 for ( TUint i = 0; i < aNumOfBuffers; ++i ) |
388 { |
336 { |
389 // no existing Rx buffers to complete in queue |
337 if ( metaHdrPtrArray[i] ) |
390 // we may complete these ones on the fly |
|
391 |
|
392 // note the completed Rx buffers first so that we can change |
|
393 // their addresses to offsets |
|
394 assign( |
|
395 reinterpret_cast<TUint32*>(&aBufferStart), |
|
396 iCompletedBuffers, |
|
397 aNumOfBuffers ); |
|
398 |
|
399 // update the new Rx buffer start addresses added above to be |
|
400 // offsets from the Rx memory pool beginning |
|
401 for( TUint i = 0; i < aNumOfBuffers; ++i ) |
|
402 { |
338 { |
403 TraceDump( RX_FRAME, |
339 iFrameXferBlock->AddRxFrame( metaHdrPtrArray[i] ); |
404 (("WLANLDD: MgmtFrameMemMngr::DoEthernetFrameRxComplete: supplied Rx buf addr: 0x%08x"), |
|
405 iCompletedBuffers[i]) ); |
|
406 |
|
407 iCompletedBuffers[i] |
|
408 -= reinterpret_cast<TUint32>(iRxDataChunk); |
|
409 |
|
410 TraceDump( RX_FRAME, |
|
411 (("WLANLDD: MgmtFrameMemMngr::DoEthernetFrameRxComplete: Rx buf offset addr: 0x%08x"), |
|
412 iCompletedBuffers[i]) ); |
|
413 } |
340 } |
414 |
341 } |
415 iCountCompleted = aNumOfBuffers; |
342 |
416 |
343 if ( iReadStatus == EPending ) |
417 iFrameXferBlock->KeRxComplete( iCompletedBuffers, iCountCompleted); |
344 { |
418 } |
345 ret = ETrue; |
419 else |
346 } |
420 { |
347 } |
421 // existing rx buffers to complete in queue. |
|
422 // We must append these at the rear and after that |
|
423 // complete the existing read request |
|
424 assign( |
|
425 reinterpret_cast<TUint32*>(&aBufferStart), |
|
426 iTobeCompletedBuffers + iCountTobeCompleted, |
|
427 aNumOfBuffers ); |
|
428 |
|
429 // update the new Rx buffer start addresses added above to be |
|
430 // offsets from the Rx memory pool beginning |
|
431 for( TUint i = 0; i < aNumOfBuffers; ++i ) |
|
432 { |
|
433 TraceDump( RX_FRAME, |
|
434 (("WLANLDD: MgmtFrameMemMngr::DoEthernetFrameRxComplete: supplied Rx buf addr: 0x%08x"), |
|
435 iTobeCompletedBuffers[iCountTobeCompleted + i]) ); |
|
436 |
|
437 iTobeCompletedBuffers[iCountTobeCompleted + i] |
|
438 -= reinterpret_cast<TUint32>(iRxDataChunk); |
|
439 |
|
440 TraceDump( RX_FRAME, |
|
441 (("WLANLDD: MgmtFrameMemMngr::DoEthernetFrameRxComplete: Rx buf offset addr: 0x%08x"), |
|
442 iTobeCompletedBuffers[iCountTobeCompleted + i]) ); |
|
443 } |
|
444 |
|
445 iCountCompleted = iCountTobeCompleted + aNumOfBuffers; |
|
446 |
|
447 iFrameXferBlock->KeRxComplete( |
|
448 iTobeCompletedBuffers, |
|
449 iCountCompleted ); |
|
450 |
|
451 // note the completed Rx buffers |
|
452 assign( iTobeCompletedBuffers, iCompletedBuffers, iCountCompleted ); |
|
453 iCountTobeCompleted = 0; |
|
454 } |
|
455 |
|
456 ret = ETrue; |
|
457 } |
|
458 else |
|
459 { |
|
460 // no read pending |
|
461 // append at the rear |
|
462 assign( |
|
463 reinterpret_cast<TUint32*>(&aBufferStart), |
|
464 iTobeCompletedBuffers + iCountTobeCompleted, |
|
465 aNumOfBuffers ); |
|
466 |
|
467 // update the new Rx buffer start addresses added above to be |
|
468 // offsets from the Rx memory pool beginning |
|
469 for( TUint i = 0; i < aNumOfBuffers; ++i ) |
|
470 { |
|
471 TraceDump( RX_FRAME, |
|
472 (("WLANLDD: MgmtFrameMemMngr::DoEthernetFrameRxComplete: supplied Rx buf addr: 0x%08x"), |
|
473 iTobeCompletedBuffers[iCountTobeCompleted + i]) ); |
|
474 |
|
475 iTobeCompletedBuffers[iCountTobeCompleted + i] |
|
476 -= reinterpret_cast<TUint32>(iRxDataChunk); |
|
477 |
|
478 TraceDump( RX_FRAME, |
|
479 (("WLANLDD: MgmtFrameMemMngr::DoEthernetFrameRxComplete: Rx buf offset addr: 0x%08x"), |
|
480 iTobeCompletedBuffers[iCountTobeCompleted + i]) ); |
|
481 } |
|
482 |
|
483 iCountTobeCompleted += aNumOfBuffers; |
|
484 } |
|
485 |
|
486 TraceDump( RX_FRAME, |
|
487 (("WLANLDD: MgmtFrameMemMngr::DoEthernetFrameRxComplete: end: iCountCompleted: %d"), |
|
488 iCountCompleted) ); |
|
489 |
|
490 TraceDump( RX_FRAME, |
|
491 (("WLANLDD: MgmtFrameMemMngr::DoEthernetFrameRxComplete: end: iCountTobeCompleted: %d"), |
|
492 iCountTobeCompleted) ); |
|
493 |
348 |
494 return ret; |
349 return ret; |
495 } |
|
496 |
|
497 // --------------------------------------------------------------------------- |
|
498 // |
|
499 // --------------------------------------------------------------------------- |
|
500 // |
|
501 TUint32* MgmtFrameMemMngr::DoGetTobeCompletedBuffersStart() |
|
502 { |
|
503 return iTobeCompletedBuffers; |
|
504 } |
|
505 |
|
506 // --------------------------------------------------------------------------- |
|
507 // |
|
508 // --------------------------------------------------------------------------- |
|
509 // |
|
510 TUint32* MgmtFrameMemMngr::DoGetCompletedBuffersStart() |
|
511 { |
|
512 return iCompletedBuffers; |
|
513 } |
|
514 |
|
515 // --------------------------------------------------------------------------- |
|
516 // |
|
517 // --------------------------------------------------------------------------- |
|
518 // |
|
519 void MgmtFrameMemMngr::DoFreeRxBuffers() |
|
520 { |
|
521 if ( IsMemInUse() ) |
|
522 { |
|
523 for ( TUint i = 0; i < iCountCompleted; ++i ) |
|
524 { |
|
525 TDataBuffer* metaHdr ( reinterpret_cast<TDataBuffer*>( |
|
526 iRxDataChunk + iCompletedBuffers[i]) ); |
|
527 |
|
528 // first free the actual Rx frame buffer |
|
529 TraceDump( RX_FRAME, |
|
530 (("WLANLDD: MgmtFrameMemMngr::DoFreeRxBuffers: free Rx buf at addr: 0x%08x"), |
|
531 reinterpret_cast<TUint32>(metaHdr->KeGetBufferStart()) ) ); |
|
532 |
|
533 iRxFrameMemoryPool->Free( |
|
534 metaHdr->KeGetBufferStart() |
|
535 // take into account the alignment padding |
|
536 - iRxBufAlignmentPadding ); |
|
537 |
|
538 // free the Rx frame meta header |
|
539 |
|
540 TraceDump( RX_FRAME, |
|
541 (("WLANLDD: MgmtFrameMemMngr::DoFreeRxBuffers: free Rx meta header at addr: 0x%08x"), |
|
542 reinterpret_cast<TUint32>(metaHdr)) ); |
|
543 |
|
544 iRxFrameMemoryPool->Free( metaHdr ); |
|
545 } |
|
546 } |
|
547 else |
|
548 { |
|
549 // the whole Rx memory pool has already been deallocated, so nothing |
|
550 // is done in this case |
|
551 TraceDump( RX_FRAME, |
|
552 ("WLANLDD: MgmtFrameMemMngr::DoFreeRxBuffers: Rx memory pool already deallocated; no action needed") ); |
|
553 } |
|
554 } |
350 } |
555 |
351 |
556 // --------------------------------------------------------------------------- |
352 // --------------------------------------------------------------------------- |
557 // |
353 // |
558 // --------------------------------------------------------------------------- |
354 // --------------------------------------------------------------------------- |
573 else |
369 else |
574 { |
370 { |
575 // the whole Rx memory pool - including aBufferToFree - has already |
371 // the whole Rx memory pool - including aBufferToFree - has already |
576 // been deallocated, so nothing is done in this case |
372 // been deallocated, so nothing is done in this case |
577 TraceDump( RX_FRAME, |
373 TraceDump( RX_FRAME, |
578 ("WLANLDD: MgmtFrameMemMngr::DoMarkRxBufFree: Rx memory pool already deallocated; no action needed") ); |
374 ("WLANLDD: MgmtFrameMemMngr::DoMarkRxBufFree: Rx memory pool already " |
|
375 "deallocated; no action needed") ); |
579 } |
376 } |
580 } |
377 } |
581 |
378 |
582 // --------------------------------------------------------------------------- |
379 // --------------------------------------------------------------------------- |
|
380 // |
|
381 // --------------------------------------------------------------------------- |
|
382 // |
|
383 TBool MgmtFrameMemMngr::OnReadRequest() |
|
384 { |
|
385 TBool ret( EFalse ); |
|
386 |
|
387 if ( IsMemInUse() && iFrameXferBlock ) |
|
388 { |
|
389 if ( iFrameXferBlock->RxFrameAvailable() ) |
|
390 { |
|
391 // there are Rx frames ready for the user mode client retrieval |
|
392 ret = ETrue; |
|
393 |
|
394 // the frame Rx request won't be left pending as the callee will |
|
395 // complete it |
|
396 iReadStatus = ENotPending; |
|
397 } |
|
398 else |
|
399 { |
|
400 // there are no Rx frames ready for the user mode client retrieval |
|
401 // the Rx request is left pending |
|
402 iReadStatus = EPending; |
|
403 } |
|
404 } |
|
405 #ifndef NDEBUG |
|
406 else |
|
407 { |
|
408 os_assert( (TUint8*)("WLANLDD: panic"), (TUint8*)(WLAN_FILE), __LINE__ ); |
|
409 } |
|
410 #endif |
|
411 |
|
412 TraceDump( RX_FRAME, |
|
413 (("WLANLDD: MgmtFrameMemMngr::OnReadRequest: ret (bool): %d"), |
|
414 ret) ); |
|
415 |
|
416 return ret; |
|
417 } |
|
418 |
|
419 // --------------------------------------------------------------------------- |
|
420 // Note! This method is executed in the context of the user mode client |
|
421 // thread, but in supervisor mode |
|
422 // --------------------------------------------------------------------------- |
|
423 // |
|
424 TDataBuffer* MgmtFrameMemMngr::GetRxFrame( |
|
425 TDataBuffer* aFrameToFreeInUserSpace ) |
|
426 { |
|
427 TDataBuffer* rxFrame( NULL ); |
|
428 |
|
429 if ( IsMemInUse() && iFrameXferBlock ) |
|
430 { |
|
431 if ( aFrameToFreeInUserSpace ) |
|
432 { |
|
433 FreeRxPacket( aFrameToFreeInUserSpace ); |
|
434 } |
|
435 |
|
436 rxFrame = iFrameXferBlock->GetRxFrame(); |
|
437 } |
|
438 |
|
439 return rxFrame; |
|
440 } |
|
441 |
|
442 // --------------------------------------------------------------------------- |
|
443 // |
|
444 // --------------------------------------------------------------------------- |
|
445 // |
|
446 TDataBuffer* MgmtFrameMemMngr::OnWriteEthernetFrame() const |
|
447 { |
|
448 if ( iTxDataBuffer && |
|
449 ( iTxDataBuffer->GetLength() >= sizeof( SEthernetHeader ) ) ) |
|
450 { |
|
451 return iTxDataBuffer; |
|
452 } |
|
453 else |
|
454 { |
|
455 #ifndef NDEBUG |
|
456 os_assert( (TUint8*)("WLANLDD: panic"), (TUint8*)(WLAN_FILE), __LINE__ ); |
|
457 #endif |
|
458 return NULL; |
|
459 } |
|
460 } |
|
461 |
|
462 // --------------------------------------------------------------------------- |
583 // |
463 // |
584 // --------------------------------------------------------------------------- |
464 // --------------------------------------------------------------------------- |
585 // |
465 // |
586 TInt MgmtFrameMemMngr::RxBufAlignmentPadding() const |
466 TInt MgmtFrameMemMngr::RxBufAlignmentPadding() const |
587 { |
467 { |
588 const TInt KMemMgrHdrLen = iRxFrameMemoryPool->HeaderSize(); |
468 if ( iRxFrameMemoryPool ) |
589 const TInt KRemainder ( KMemMgrHdrLen % iRxFrameBufAllocationUnit ); |
469 { |
590 TInt padding = KRemainder ? |
470 const TInt KMemMgrHdrLen = iRxFrameMemoryPool->HeaderSize(); |
591 ( iRxFrameBufAllocationUnit - KRemainder ) : KRemainder; |
471 const TInt KRemainder ( KMemMgrHdrLen % iRxFrameBufAllocationUnit ); |
592 |
472 TInt padding = KRemainder ? |
593 TraceDump(INIT_LEVEL, (("WLANLDD: MgmtFrameMemMngr::RxBufAlignmentPadding: %d"), |
473 ( iRxFrameBufAllocationUnit - KRemainder ) : KRemainder; |
594 padding)); |
474 |
595 |
475 TraceDump(INIT_LEVEL, (("WLANLDD: MgmtFrameMemMngr::RxBufAlignmentPadding: %d"), |
596 return padding; |
476 padding)); |
|
477 |
|
478 return padding; |
|
479 } |
|
480 else |
|
481 { |
|
482 os_assert( (TUint8*)("WLANLDD: panic"), (TUint8*)(WLAN_FILE), __LINE__ ); |
|
483 return 0; |
|
484 } |
597 } |
485 } |
598 |
486 |
599 // --------------------------------------------------------------------------- |
487 // --------------------------------------------------------------------------- |
600 // |
488 // |
601 // --------------------------------------------------------------------------- |
489 // --------------------------------------------------------------------------- |