/*
* Copyright (c) 2006-2009 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:   WlanPlatformHwChunk implementation
*
*/

/*
* %version: 8 %
*/

#include "osa_includeme.h"

#include <wlanosa.h>
#include <platform.h>

#include "osaplatformhwchunk.h"
#include "osachunk.h"

struct WlanPlatformHwChunkImpl : public DBase, public WlanObject
    {

    /**
     * Ctor
     *
     * @since S60 v3.2
     * @param aStartOfBuf begin of the memory buffer
     * @param aEndOfBuf 1 past end of the memory buffer
     * @param aPlatChunkHw platform chunk object
     * @param aPhysRamAddr physical ram address
     * @param aPhysRamSize size of the physical ram
     * @param aAllocationUnit size of the allocation unit in bytes
     */
    WlanPlatformHwChunkImpl( 
        TUint8* aStartOfBuf, 
        TUint8* aEndOfBuf, 
        DPlatChunkHw** aPlatChunkHw, 
        TPhysAddr aPhysRamAddr, 
        TInt aPhysRamSize,
        TInt aAllocationUnit );

    /**
     * Dtor
     *
     * @since S60 v3.2
     */
    virtual ~WlanPlatformHwChunkImpl();

    /**
     * Deallocate acquired resources (if any) 
     *
     * @since S60 v3.2
     */
    inline void Dispose();

    /**
     * the one and only chunk
     * Own.
     */
    WlanChunk*      iChunk;

    /**
     * the one and only platform chunk
     * Own.
     */
    DPlatChunkHw*   iPlatChunk;

    /**
     * physical ram address
     */
    TPhysAddr       iPhysRamAddr;

    /**
     * physical ram size
     */
    TInt            iPhysRamSize;
    
private:
        
    // Prohibit copy constructor.
    WlanPlatformHwChunkImpl( const WlanPlatformHwChunkImpl& );
    // Prohibit assigment operator.
    WlanPlatformHwChunkImpl& operator= ( 
        const WlanPlatformHwChunkImpl& );        
    };

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TInt WlanPlatformHwChunk::RoundToPageSize(  TInt aSizeInBytes  )
    {
    TraceDump(INFO_LEVEL, ("[WLAN] WlanPlatformHwChunk::RoundToPageSize +"));

    // extract MMU page size in bytes
	aSizeInBytes = Kern::RoundToPageSize( aSizeInBytes );

    TraceDump(INFO_LEVEL, ("[WLAN] WlanPlatformHwChunk::RoundToPageSize -"));

    return aSizeInBytes;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline TBool WlanPlatformHwChunk::AllocatePhysicalRam( TInt aSizeInBytes, 
                                                       TPhysAddr& aPhysAddr )
    {
    TBool ret( ETrue );
    TraceDump(INFO_LEVEL, 
        ("[WLAN] WlanPlatformHwChunk::AllocatePhysicalRam +"));

    const TInt ret_code( Epoc::AllocPhysicalRam( aSizeInBytes, aPhysAddr ) );
    if ( ret_code != KErrNone )
    {
    // this can happen if we have  no memory
    ret = EFalse;
    TraceDump(ERROR_LEVEL, (("[WLAN] error: allocation: %d"), ret_code));
    Trace( ERROR_LEVEL, 
        reinterpret_cast<const TInt8*>(WLAN_FILE), __LINE__ );
    }

    TraceDump(INFO_LEVEL, 
        ("[WLAN] WlanPlatformHwChunk::AllocatePhysicalRam -"));

    return ret;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline void WlanPlatformHwChunk::FreePhysicalRam( TPhysAddr aPhysRamAddr, 
                                                  TInt aPhysRamSize )
    {
    TraceDump(INFO_LEVEL, ("[WLAN] WlanPlatformHwChunk::FreePhysicalRam +"));

    const TInt ret = Epoc::FreePhysicalRam( aPhysRamAddr, aPhysRamSize );
    if ( ret != KErrNone )
        {
        // no valid use case exists for this code path to be taken
        TraceDump(CRIT_LEVEL, (("[WLAN] critical: value: %d"), ret));
        MWlanOsa::Assert( 
            reinterpret_cast<const TInt8*>(WLAN_FILE), __LINE__ );
        }
    else
        {
        // left intentionally empty
        }

    TraceDump(INFO_LEVEL, ("[WLAN] WlanPlatformHwChunk::FreePhysicalRam -"));
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
WlanPlatformHwChunkImpl::WlanPlatformHwChunkImpl( 
    TUint8* aStartOfBuf, 
    TUint8* aEndOfBuf,
    DPlatChunkHw** aPlatChunkHw,
    TPhysAddr aPhysRamAddr, 
    TInt aPhysRamSize,
    TInt aAllocationUnit )
    : iChunk( NULL ), iPlatChunk( *aPlatChunkHw ), 
    iPhysRamAddr( aPhysRamAddr ), iPhysRamSize( aPhysRamSize )
    {
    TraceDump(INFO_LEVEL, 
        (("[WLAN] WlanPlatformHwChunkImpl ctor +: 0x%08x"), this));

    iChunk = new WlanChunk( aStartOfBuf, aEndOfBuf, aAllocationUnit );
    if ( iChunk )
        {
        if ( iChunk->IsValid() )
            {
            Validate();     // mark as valid
            }
        else
            {
            TraceDump(ERROR_LEVEL, ("[WLAN] error: allocation"));
            Trace( ERROR_LEVEL, 
                reinterpret_cast<const TInt8*>(WLAN_FILE), __LINE__ );

            InValidate();   // mark as invalid

            // chunk deallocated in dtor so we don't have to do it here
            }
        }
    else
        {
        // allocation failure
        TraceDump(ERROR_LEVEL, ("[WLAN] error: allocation"));
        Trace( ERROR_LEVEL, 
            reinterpret_cast<const TInt8*>(WLAN_FILE), __LINE__ );

        InValidate();   // mark as invalid
        }

    TraceDump(INFO_LEVEL, 
        (("[WLAN] WlanPlatformHwChunkImpl ctor -: 0x%08x"), this));
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
WlanPlatformHwChunkImpl::~WlanPlatformHwChunkImpl()
    {
    TraceDump(INFO_LEVEL, 
        (("[WLAN] WlanPlatformHwChunkImpl dtor +: 0x%08x"), this));

    Dispose();

    TraceDump(INFO_LEVEL, 
        (("[WLAN] WlanPlatformHwChunkImpl dtor +: 0x%08x"), this));
    }

// ---------------------------------------------------------------------------
// only 1 call point. That's the reason for inlining
// ---------------------------------------------------------------------------
//
inline void WlanPlatformHwChunkImpl::Dispose()
    {
    TraceDump(INFO_LEVEL, 
        (("[WLAN] WlanPlatformHwChunkImpl::Dispose +: 0x%08x"), this));

    // NOTE: always dellocate the chunk prior freeing the memory associated to
    // it
    delete iChunk;
    iChunk = NULL;

    if ( iPlatChunk )
        {
        // close the chunk. This also automatically deletes the object 
        // as its reference count goes to 0
        iPlatChunk->Close( NULL );
        // free the physical ram which was associated with the chunk
        WlanPlatformHwChunk::FreePhysicalRam( iPhysRamAddr, iPhysRamSize );
        }
    else
        {
        // left intentionally empty
        }

    TraceDump(INFO_LEVEL, 
        (("[WLAN] WlanPlatformHwChunkImpl::Dispose -: 0x%08x"), this));
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline WlanPlatformHwChunkImpl& WlanPlatformHwChunk::Pimpl()
    {
    return *iPimpl;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
inline const WlanPlatformHwChunkImpl& WlanPlatformHwChunk::Pimpl() const
    {
    return *iPimpl;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
WlanPlatformHwChunk::WlanPlatformHwChunk( 
    TInt aSizeInBytes, 
    TBool aUseCachedMemory,
    TInt aAllocationUnit ) 
    : iPimpl( NULL ), iUseCachedMemory ( aUseCachedMemory )
    {
    TraceDump(INFO_LEVEL, 
        (("[WLAN] WlanPlatformHwChunk ctor +: 0x%08x"), this));

    TBool ret( EFalse );
    TPhysAddr phys_ram_addr( 0 );   // physical ram address

    TraceDump(PLAT_HW_CHUNK, 
        (("[WLAN] WlanPlatformHwChunk requested memory size: %d"), 
        aSizeInBytes));

    // round up request to MMU page size boundary
    const TInt phys_ram_size( RoundToPageSize( aSizeInBytes ) );

    TraceDump(PLAT_HW_CHUNK, 
        (("[WLAN] WlanPlatformHwChunk memory size to be aquired: %d"), 
        phys_ram_size));

    // allocate the physical ram
    ret = AllocatePhysicalRam( phys_ram_size, phys_ram_addr );
    
    if ( ret )
        {
        // physical ram allocation success
        // allocate hw chunk for the physical ram
        ret = AllocateHardwareChunk( 
                phys_ram_addr, 
                phys_ram_size, 
                aAllocationUnit );
        if ( ret )
            {
            // chunk creation success
            Validate();     // mark as valid
            }
        else
            {
            // chunk creation failure
            // free the physical ram 
            FreePhysicalRam( phys_ram_addr, phys_ram_size );
            InValidate();   // mark as invalid
            }
        }
    else
        {
        // physical ram allocation failure
        InValidate();   // mark as invalid
        }

    TraceDump(INFO_LEVEL, 
        (("[WLAN] WlanPlatformHwChunk ctor -: 0x%08x"), this));
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
WlanPlatformHwChunk::~WlanPlatformHwChunk()
    {
    TraceDump(INFO_LEVEL, 
        (("[WLAN] WlanPlatformHwChunk dtor +: 0x%08x"), this));

    delete iPimpl;

    TraceDump(INFO_LEVEL, 
        (("[WLAN] WlanPlatformHwChunk dtor -: 0x%08x"), this));
    }

// ---------------------------------------------------------------------------
// only 1 call point thats the reason for inlining
// ---------------------------------------------------------------------------
//
inline TBool WlanPlatformHwChunk::AllocateHardwareChunk( 
    TPhysAddr aPhysRamAddr, 
    TInt aPhysRamSize,
    TInt aAllocationUnit )
    {
    TraceDump(INFO_LEVEL, 
        (("[WLAN] WlanPlatformHwChunk::AllocateHardwareChunk +: 0x%08x"), 
        this));

    TBool ret( EFalse );

    // determine if cached memory shall be used
    TUint cacheOption = iUseCachedMemory ? 
        EMapAttrCachedMax : 
        EMapAttrFullyBlocking;

    // lets create a hw chunk for our physical ram
    DPlatChunkHw* chunk = NULL;
    TInt code = DPlatChunkHw::New( 
        chunk, aPhysRamAddr, aPhysRamSize, 
        EMapAttrSupRw | cacheOption );

    if ( KErrNone != code )
        {
        // creation error -> bail out
        TraceDump(ERROR_LEVEL, (("[WLAN] error: allocation %d"), code));
        Trace( ERROR_LEVEL, 
            reinterpret_cast<const TInt8*>(WLAN_FILE), __LINE__ );

        TraceDump(INFO_LEVEL, 
            (("[WLAN] WlanPlatformHwChunk::AllocateHardwareChunk -: 0x%08x"), 
            this));

        return ret;
        }
    else
        {
        TraceDump(PLAT_HW_CHUNK, 
            (("[WLAN] Platform Hw Chunk create success with cacheOption: 0x%08x"), 
            cacheOption));
        }

    // hw chunk creation success proceed
    iPimpl = new WlanPlatformHwChunkImpl( 
        reinterpret_cast<TUint8*>(chunk->LinearAddress()), 
        (reinterpret_cast<TUint8*>(chunk->LinearAddress())) + aPhysRamSize,
        &chunk,
        aPhysRamAddr,
        aPhysRamSize,
        aAllocationUnit );

    if ( iPimpl )
        {
        // success -> validate implementation
        if ( Pimpl().IsValid() )
            {
            Validate();     // we are valid to go
            ret = ETrue;
            }
        else
            {
            TraceDump(ERROR_LEVEL, ("[WLAN] error: allocation"));
            Trace( ERROR_LEVEL, 
                reinterpret_cast<const TInt8*>(WLAN_FILE), __LINE__ );

            InValidate();   // we are invalid to go

            // allways dealloc in dtor
            }       
        }
    else
        {
        // allocation failed -> trace
        TraceDump(ERROR_LEVEL, ("[WLAN] error: allocation"));
        Trace( ERROR_LEVEL, 
            reinterpret_cast<const TInt8*>(WLAN_FILE), __LINE__ );

        // we must now deallocate allocated resources
        // allways close the chunk
        // this also automatically deletes the object 
        // as its reference count goes to 0
        chunk->Close( NULL );
        }

    TraceDump(INFO_LEVEL, 
        (("[WLAN] WlanPlatformHwChunk::AllocateHardwareChunk -: 0x%08x"), 
        this));

    return ret;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
MWlanOsaChunkBase& WlanPlatformHwChunk::Chunk()
    {
    return *(Pimpl().iChunk);
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
const MWlanOsaChunkBase& WlanPlatformHwChunk::Chunk() const
    {
    return *(Pimpl().iChunk);
    }