/*

* Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:   Implementation of the MgmtFrameMemMngr class.

*

*/

/*

*/

#include "WlLddWlanLddConfig.h"

#include "MgmtFrameMemMngr.h"

#include "osachunk.h"

#include <kern_priv.h>

extern TAny* os_alloc( const TUint32 );

extern void os_free( const TAny* );

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

TInt MgmtFrameMemMngr::DoAllocate( DChunk*& aSharedMemoryChunk )

    {

    TraceDump( INIT_LEVEL, 

        ("WLANLDD: MgmtFrameMemMngr::DoAllocate:") );

    // determine if cached memory shall be used

    TUint cacheOption = iUseCachedMemory ? 

        EMapAttrCachedMax : 

        EMapAttrFullyBlocking;

    // Start creating the chunk

    TChunkCreateInfo info;

    info.iType         = TChunkCreateInfo::ESharedKernelMultiple;

    info.iMaxSize      = iChunkSize;

    info.iMapAttr      = EMapAttrReadUser |

                         EMapAttrWriteUser |

                         EMapAttrShared |

                         cacheOption;

    info.iOwnsMemory   = ETrue;

    info.iDestroyedDfc = NULL;

    DChunk* chunk;

    TraceDump( INIT_LEVEL, 

        (("WLANLDD: MgmtFrameMemMngr::DoAllocate: create chunk of size: %d"),

        iChunkSize) );

    TUint32 chunkMapAttrNotNeeded ( 0 );

    // Enter critical section so we can't die and leak the object we are 

    // creating, i.e. DChunk (shared memory chunk)

    NKern::ThreadEnterCS();

    TInt r = Kern::ChunkCreate( 

        info, 

        chunk, 

        iChunkKernelAddr, 

        chunkMapAttrNotNeeded );

    if( r != KErrNone)

        {

        TraceDump( WARNING_LEVEL, 

            (("WLANLDD: MgmtFrameMemMngr::DoAllocate: create chunk failed. Status: %d"),

            r ) );

        NKern::ThreadLeaveCS();

        return r;

        }

    TraceDump(MEMORY, (("WLANLDD: new DChunk: 0x%08x"), 

        reinterpret_cast<TUint32>(chunk)));

    TraceDump(INIT_LEVEL, 

        (("MgmtFrameMemMngr::DoAllocate: Platform Hw Chunk create success with cacheOption: 0x%08x"), 

        cacheOption));

    TUint32 physicalAddressNotNeeded ( 0 );

    // Map our device's memory into the chunk (at offset 0)

    r = Kern::ChunkCommitContiguous( 

            chunk, 

            0, 

            iChunkSize, 

            physicalAddressNotNeeded );

    if ( r != KErrNone)

        {

        TraceDump( WARNING_LEVEL, 

            (("WLANLDD: MgmtFrameMemMngr::DoAllocate: chunk commit failed. Status: %d"),

            r ) );

        // Commit failed so tidy-up.

        // Close chunk, which will then get deleted at some point

        Kern::ChunkClose( chunk );

        }

    else

        {

        TraceDump( INIT_LEVEL, 

            ("WLANLDD: MgmtFrameMemMngr::DoAllocate: chunk commit success") );

        // Commit succeeded so pass back the chunk pointer

        aSharedMemoryChunk = chunk;

        }

    // Can leave critical section now that we have saved pointer to created object

    NKern::ThreadLeaveCS();

    TraceDump( INIT_LEVEL, 

        (("WLANLDD: MgmtFrameMemMngr::DoAllocate: chunk map attr: %d"),

        chunkMapAttrNotNeeded ) );

    TraceDump( INIT_LEVEL, 

        (("WLANLDD: MgmtFrameMemMngr::DoAllocate: iChunkKernelAddr: 0x%08x"),

        static_cast<TUint32>(iChunkKernelAddr) ) );

    TraceDump( INIT_LEVEL, 

        (("WLANLDD: MgmtFrameMemMngr::DoAllocate: chunk physical address: 0x%08x"),

        physicalAddressNotNeeded ) );

    return r;

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

TInt MgmtFrameMemMngr::DoOpenHandle(

    DThread& aThread,

    TSharedChunkInfo& aSharedChunkInfo,

    DChunk* aSharedMemoryChunk )

    {

    TInt ret ( KErrGeneral );

    if ( aSharedMemoryChunk )

        {

        // Need to be in critical section while creating handles

        NKern::ThreadEnterCS();

        // Create handle to shared memory chunk for client thread

        TInt r = Kern::MakeHandleAndOpen( &aThread, aSharedMemoryChunk );

        // Leave critical section 

        NKern::ThreadLeaveCS();

        // positive r value is a handle, negative value is an error code

        if( r >= 0 )

            {

            // mapping success

            TraceDump( INIT_LEVEL, 

                (("WLANLDD: MgmtFrameMemMngr::OnInitialiseMemory: Handle create & open ok: handle: %d"),

                r ) );

            // store the handle & the chunk size

            aSharedChunkInfo.iChunkHandle = r;

            aSharedChunkInfo.iSize = iChunkSize;

            iClientChunkHandle = r;

            // store the kernel addresses

            TUint8* start_of_mem = reinterpret_cast<TUint8*>(iChunkKernelAddr );

            const TUint KRxDataChunkSize( 

                iChunkSize 

                - ( sizeof( TDataBuffer )

                    + KMgmtSideTxBufferLength

                    + KProtocolStackSideTxDataChunkSize

                    + sizeof( RFrameXferBlock ) 

                    + sizeof( RFrameXferBlockProtocolStack ) ) );

            TraceDump( INIT_LEVEL, 

                (("WLANLDD: MgmtFrameMemMngr::DoOpenHandle: KRxDataChunkSize: %d"),

                KRxDataChunkSize ) );

            iRxDataChunk = start_of_mem;

            TraceDump( INIT_LEVEL, 

                (("WLANLDD: MgmtFrameMemMngr::DoOpenHandle: iRxDataChunk start addr: 0x%08x"),

                reinterpret_cast<TUint32>(iRxDataChunk) ) );

            TraceDump( INIT_LEVEL, 

                (("WLANLDD: MgmtFrameMemMngr::DoOpenHandle: iRxDataChunk end addr: 0x%08x"),

                reinterpret_cast<TUint32>(iRxDataChunk + KRxDataChunkSize) ) );

            // create the Rx frame memory pool manager

            iRxFrameMemoryPool = new WlanChunk( 

                iRxDataChunk, 

                iRxDataChunk + KRxDataChunkSize,

                iRxFrameBufAllocationUnit );

            if ( iRxFrameMemoryPool && iRxFrameMemoryPool->IsValid() )

                {

                ret = KErrNone;

                TraceDump(MEMORY, (("WLANLDD: new WlanChunk: 0x%08x"), 

                    reinterpret_cast<TUint32>(iRxFrameMemoryPool)));

                iTxDataBuffer = reinterpret_cast<TDataBuffer*>(

                    start_of_mem

                    + KRxDataChunkSize );

                TraceDump( INIT_LEVEL, 

                    (("WLANLDD: MgmtFrameMemMngr::DoOpenHandle: Engine TxDataBuf start addr: 0x%08x"),

                    reinterpret_cast<TUint32>(iTxDataBuffer) ) );

                // for the single Tx buffer the actual buffer memory immediately

                // follows the Tx frame meta header

                iTxDataBuffer->KeSetBufferOffset( sizeof( TDataBuffer ) );        

                iFrameXferBlock = reinterpret_cast<RFrameXferBlock*>(

                    start_of_mem

                    + KRxDataChunkSize

                    + sizeof( TDataBuffer )

                    + KMgmtSideTxBufferLength 

                    + KProtocolStackSideTxDataChunkSize );

                TraceDump( INIT_LEVEL, 

                    (("WLANLDD: MgmtFrameMemMngr::DoOpenHandle: Engine RFrameXferBlock addr: 0x%08x"),

                    reinterpret_cast<TUint32>(iFrameXferBlock) ) );

                // initiliase xfer block

                iFrameXferBlock->Initialize( KMgmtSideTxBufferLength );

                iRxBufAlignmentPadding = RxBufAlignmentPadding();

                iParent.SetRxBufAlignmentPadding( iRxBufAlignmentPadding );

                }

            else

                {

                // create failed

                delete iRxFrameMemoryPool;

                iRxFrameMemoryPool = NULL;

                // error is returned

                }

            }

        else

            {

            // handle creation & open failed. Error is returned

            TraceDump( INIT_LEVEL | ERROR_LEVEL, 

                (("WLANLDD: MgmtFrameMemMngr::OnInitialiseMemory: Handle create & open error: %d"),

                r ) );            

            }

        }

    else

        {

        // at this point the shared memory chunk should always exist. However,

        // as it doesn't exist in this case, we return an error

        TraceDump( INIT_LEVEL | ERROR_LEVEL, 

            ("WLANLDD: MgmtFrameMemMngr::OnInitialiseMemory: Error aSharedMemoryChunk is NULL") );

        }    

    return ret;    

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

TUint8* MgmtFrameMemMngr::DoGetNextFreeRxBuffer( TUint aLengthinBytes )

    {

    TraceDump( RX_FRAME, 

        ("WLANLDD: MgmtFrameMemMngr::DoGetNextFreeRxBuffer") );

    // reserve a new Rx buffer. 

    TUint8* buffer ( NULL );

    if ( iRxFrameMemoryPool )

        {

        buffer = reinterpret_cast<TUint8*>(iRxFrameMemoryPool->Alloc( 

            aLengthinBytes

            + iRxBufAlignmentPadding,

            EFalse ) ); // no need to zero stamp the buffer content

        if ( buffer )

            {

            // allocation succeeded

            // the alignment padding is before the Rx buffer

            buffer += iRxBufAlignmentPadding;

            TraceDump(RX_FRAME, 

               (("WLANLDD: MgmtFrameMemMngr::DoGetNextFreeRxBuffer: addr of allocated Rx buf: 0x%08x"),

               reinterpret_cast<TUint32>(buffer)) );

            }

        else

            {

            TraceDump(RX_FRAME | WARNING_LEVEL, 

               ("WLANLDD: MgmtFrameMemMngr::DoGetNextFreeRxBuffer: WARNING: not enough free memory => failed"));            

            }

        }

    else

        {

         TraceDump(RX_FRAME | WARNING_LEVEL, 

            ("WLANLDD: MgmtFrameMemMngr::DoGetNextFreeRxBuffer: WARNING: no Rx mem pool mgr => failed"));       

        }

    return buffer;

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

TBool MgmtFrameMemMngr::DoEthernetFrameRxComplete( 

    TUint32 aNumOfBuffers )

    {

    TraceDump( RX_FRAME, 

        aNumOfBuffers) );

    TBool ret( EFalse );

                {

                }

            }

        }

    return ret;

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

void MgmtFrameMemMngr::DoMarkRxBufFree( TUint8* aBufferToFree )

    {

    TraceDump( RX_FRAME, 

        (("WLANLDD: MgmtFrameMemMngr::DoMarkRxBufFree: free Rx buf at addr: 0x%08x"),

        reinterpret_cast<TUint32>(aBufferToFree) ) );

        {

        iRxFrameMemoryPool->Free( 

            aBufferToFree

            // take into account the alignment padding 

            - iRxBufAlignmentPadding );

        }

    else

        {

        // the whole Rx memory pool - including aBufferToFree - has already

        // been deallocated, so nothing is done in this case

        TraceDump( RX_FRAME, 

        }    

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

TInt MgmtFrameMemMngr::RxBufAlignmentPadding() const

    {

    }

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

void MgmtFrameMemMngr::OnReleaseMemory( DThread& aThread )

    {

    TraceDump(INIT_LEVEL, ("WLANLDD: MgmtFrameMemMngr::OnReleaseMemory"));

    if ( iRxFrameMemoryPool )

        {

        TraceDump(MEMORY, (("WLANLDD: delete WlanChunk: 0x%08x"), 

            reinterpret_cast<TUint32>(iRxFrameMemoryPool)));        

        delete iRxFrameMemoryPool;

        iRxFrameMemoryPool = NULL;

        }

    if ( iParent.SharedMemoryChunk() )

        {

        TraceDump(MEMORY, (("WLANLDD: delete DChunk: 0x%08x"), 

            reinterpret_cast<TUint32>(iParent.SharedMemoryChunk())));        

        if ( iClientChunkHandle >= 0 )

            {

            TraceDump(INIT_LEVEL, 

                (("WLANLDD: MgmtFrameMemMngr::OnReleaseMemory: close shared "

                 "chunk handle: %d"), 

                iClientChunkHandle));

            // We have a valid client handle to the shared chunk, so close it