// Copyright (c) 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:

// /os/kernelhwsrv/kernel/eka/drivers/rpmb/rpmbdevice.cpp

// Kernel extension entry point for RPMB driver.

// 

//

/**

 @file

 @internalTechnology

*/

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "../../include/drivers/locmedia_ost.h"

#ifdef __VC32__

#pragma warning(disable: 4127) // disabling warning "conditional expression is constant"

#endif

#include "rpmbdeviceTraces.h"

#endif

#include <kernel/kernel.h>

#include <drivers/rpmbdevice.h>

#include <drivers/sdcard.h>

#include <drivers/sdio/sdio.h>

#include <drivers/mmc.h>

DRpmbDevice * DRpmbDevice::DRpmbDevicePtrs[KMaxPBusSockets*4] = {

	NULL, NULL, NULL, NULL,

	NULL, NULL, NULL, NULL,

	NULL, NULL, NULL, NULL,

	NULL, NULL, NULL, NULL};

EXPORT_C DRpmbDevice::DRpmbDevice():

	iSessionEndCallBack(DRpmbDevice::SessionEndCallBack, this),

	iDeviceIndex(KIndexNotAssigned)

    {

	}

EXPORT_C DRpmbDevice::~DRpmbDevice()

    {

    Close();

	}

void DRpmbDevice::SessionEndCallBack(TAny* aSelf)

    {

    DRpmbDevice& self = *static_cast<DRpmbDevice*>(aSelf);

    self.DoSessionEndCallBack();

    }

void DRpmbDevice::DoSessionEndCallBack()

    {   

    iSocket->EndInCritical();

    Kern::SemaphoreSignal(*iRequestSemaphore);

    }

void DRpmbDevice::BusCallBack(TAny* aPtr, TInt aReason, TAny* a1, TAny* a2)

{

    DRpmbDevice* device = (DRpmbDevice*)aPtr;

    TPBusState busState = (TPBusState) (TInt) a1;

	TInt busError = (TInt) a2;

    if(aReason == TPBusCallBack::EPBusStateChange 

		&& busState == EPBusOn && busError == KErrNone)

		{

		Kern::SemaphoreSignal(*(device->iPowerUpSemaphore));

        }

}

TInt DRpmbDevice::PowerUpStack()

    {

    //

    // Power up the socket - This ensures that the socket is powered up 

    // and the functions are re-enumerated.

    //  

    iBusCallBack.iFunction = BusCallBack;

    iBusCallBack.iPtr=this;

    iBusCallBack.SetSocket(iSocket->iSocketNumber);

    iBusCallBack.Add();

	NKern::ThreadEnterCS();

    TInt r = Kern::SemaphoreCreate(iPowerUpSemaphore,_L("RPMBPowerUpSem"), 0);

    if(r == KErrNone)

        {

		TInt r = iSocket->PowerUp();

        if(r==KErrNone)

            {

            Kern::SemaphoreWait(*iPowerUpSemaphore);

            }

        }

	NKern::ThreadLeaveCS();

    return r;

    }

void DRpmbDevice::SetSynchronisationParms(TUint8 aDeviceIndex)

	{

	// Mark this instance as being associated with the requested index 

	iDeviceIndex = aDeviceIndex;

	// Mark the requested index as being associated with this instance

	// Atomic operation ensures store is flushed from cache and committed 

	// to global memory

	__e32_atomic_store_ord_ptr(&(DRpmbDevicePtrs[iDeviceIndex]),this);

	}

void DRpmbDevice::ClearSynchronisationParms()

	{

	// Serialise access to global pointer array and it's local index

	NKern::FMWait(&iSynchronisationParmsMutex);

	if (iDeviceIndex < KMaxPBusSockets*4)

		{

		// Atomic operation for load from global memory and not from cache

		DRpmbDevice * ptrTableEntry = 

			(DRpmbDevice *)__e32_atomic_load_acq_ptr(&(DRpmbDevicePtrs[iDeviceIndex]));

		// This instance of DRpmbDevice is associated with an index

		// The associated index MUST be associated with this instance

		__ASSERT_ALWAYS((ptrTableEntry == this), Kern::Fault(__FILE__, __LINE__));

		// Disassociate index and instance

		// Atomic operation ensures store is flushed from cache and committed 

		// to global memory

		__e32_atomic_store_ord_ptr(&(DRpmbDevicePtrs[iDeviceIndex]),NULL);

		iDeviceIndex = KIndexNotAssigned;

		}

	// Serialise access to global pointer array and it's local index

	NKern::FMSignal(&iSynchronisationParmsMutex);

	}

EXPORT_C TInt DRpmbDevice::Open(TUint aDeviceIndex)

    {

    //

    //eMMC4.4+ devices have RPMB partitions and each MMC device may be configured as having an RPMB 

	//partition in the baseport

	//This function creates an MMC stack session for device aDeviceIndex

	//This is used to access the RPMB partition on that device

	//Extensions that use this interface during system startup should be located AFTER the RPMB and MMC

	//extesnions in the system ROM and should not call this interface synchronously from a system

	//startup initialisation routine

	//aDeviceIndex the index of the device supporting the RPMB partition

	//Returns KerrNone if successful

	//Returns KErrNotReady if the baseport configuration hasn't been read yet

    //Returns KErrNotSupported if the baseport configuration does not have a valid RPMB partition 

	//or RPMB is not supported by the media device

	//Otherwise retruns a systemwide error code

    //

    OstTrace0(TRACE_FLOW, DRPMBDEVICE_OPEN_1, "RPMB: >DrpmbDevice::Open");

    __KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: >DrpmbDevice::Open"));

	TRpmbDeviceParms params;

	params.iCardNumber = 0;

	params.iSocketPtr = NULL;	

    MRpmbInfo* rpmbInterface = NULL;

	TInt r = MMCGetExtInterface(KInterfaceRpmb, (MMCMExtInterface*&) rpmbInterface);

	// MMCGetExtInterface currently returns KErrNotReady with rpmbInterface == NULL if the RPMB parameters 

	// haven't yet been populated

	// proveided any calling extension is located AFTER the RPMB and MMC extesnions in the system ROM and 

	// does not call this interface synchronously from a system initialisation routine the following 

	// shouldn't be asserted 

	OstTrace1(TRACE_FLOW, DRPMBDEVICE_OPEN_2, "RPMB: DrpmbDevice Get Interface err = %d", r);

	__KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: DrpmbDevice Get Interface err = %d", r));

	__ASSERT_ALWAYS(r == KErrNone, Kern::Fault(__FILE__, __LINE__));

	if (rpmbInterface == NULL)

		{

		// unexpected error since MMCGetExtInterface didn't return an error

	    OstTrace0(TRACE_FLOW, DRPMBDEVICE_OPEN_3, "RPMB: DrpmbDevice Null rpmbInterface");

	    __KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: DrpmbDevice Null rpmbInterface"));

		return KErrGeneral;

		}

	// Interface currently supports a single device, device index = 0   

	r = rpmbInterface->RpmbInfo(aDeviceIndex, params);

    if(r != KErrNone)

        {

		// requested index non zero or baseport not configured with RPMB capable MMC device

        OstTrace1(TRACE_FLOW, DRPMBDEVICE_OPEN_4, "RPMB: DrpmbDevice requested index non zero or baseport not configured, err = %d", r);

        __KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: DrpmbDevice requested index non zero or baseport not configured, err = %d", r));

		return r;

		}

    iSocket = params.iSocketPtr;

	// iSocket cannot be NULL 

	// TMMCardControllerInterface::RegisterMediaDevices ensures that the assigned value is not NULL

	__ASSERT_ALWAYS((iSocket!=NULL), Kern::Fault(__FILE__, __LINE__));

	// Serialise access to global pointer array and it's local index

	NKern::FMWait(&iSynchronisationParmsMutex);

	if (iDeviceIndex != KIndexNotAssigned)

		{

		// This instance of DRpmbDevice is already open

		if (iDeviceIndex == aDeviceIndex)

			{

			// Serialise access to global pointer array and it's local index

			NKern::FMSignal(&iSynchronisationParmsMutex);

			// Already open with requested index

		    OstTrace0(TRACE_FLOW, DRPMBDEVICE_OPEN_5, "RPMB: DrpmbDevice already open with requested index");

		    __KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: DrpmbDevice already open with requested index"));

			return KErrNone;

			}

		else

			{

			// Serialise access to global pointer array and it's local index

			NKern::FMSignal(&iSynchronisationParmsMutex);

			// Already open with other index

	        OstTrace0(TRACE_FLOW, DRPMBDEVICE_OPEN_6, "RPMB: DrpmbDevice already open with other index");

	        __KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: DrpmbDevice already open with other index"));

			return KErrInUse;

			}

		}

	else

		{

		// This instance of DRpmbDevice is not open

		// Atomic operation for load from global memory and not from cache

		DRpmbDevice * ptrTableEntry = 

			(DRpmbDevice *)__e32_atomic_load_acq_ptr(&(DRpmbDevicePtrs[aDeviceIndex]));

		if (ptrTableEntry == NULL)

			{

			SetSynchronisationParms((TUint8)(aDeviceIndex));

			}

		else

			{

			// Requested index cannot be associated with this instance of DRpmbdevice  

			__ASSERT_ALWAYS(ptrTableEntry != this, Kern::Fault(__FILE__, __LINE__));

			// Serialise access to global pointer array and it's local index

			NKern::FMSignal(&iSynchronisationParmsMutex);

			// Requested index already associated with a different instance of DRpmbDevice

	        OstTrace0(TRACE_FLOW, DRPMBDEVICE_OPEN_7, "RPMB: DrpmbDevice requested index already associated with a different instance of DrpmbDevice");

	        __KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: DrpmbDevice requested index already associated with a different instance of DrpmbDevice"));

			return KErrInUse;

			}

		}

	NKern::FMSignal(&iSynchronisationParmsMutex);

	r = PowerUpStack();

    if (r != KErrNone && r != KErrCompletion)

        {

        // Stack wasn't already powered up and failed to power up

		ClearSynchronisationParms();

	    OstTrace1(TRACE_FLOW, DRPMBDEVICE_OPEN_8, "RPMB: DrpmbDevice wasn't already powered up and failed with err = %d", r);

	    __KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: DrpmbDevice wasn't already powered up and failed with err = %d", r));

		return r;

        }

    DMMCStack* stack = iSocket->Stack(KBusNumber);

    if(stack == NULL)

        {

		// KBusNumber = 0 so iSocket->Stack() returns iSocket->iStack 

		// Expect this to have been pre-assigned

		// Expect a socket to be bound to a stack

        ClearSynchronisationParms();

        OstTrace0(TRACE_FLOW, DRPMBDEVICE_OPEN_9, "RPMB: stack is NULL");

        __KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: stack is NULL"));

        return KErrNoMemory;

        }

    iCard = stack->CardP(params.iCardNumber);

    if(iCard == NULL) 

        {

		// stack->CardP() returns stack->iCardArray->CardP(params.iCardNumber)

		// Expect this to have been pre-assigned

		// Expect card array to point to a card

        ClearSynchronisationParms();

        OstTrace0(TRACE_FLOW, DRPMBDEVICE_OPEN_10, "RPMB: card pointer is NULL");

        __KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: card pointer is NULL"));

        return KErrNoMemory;

        }

	NKern::ThreadEnterCS(); 

    iSession = stack->AllocSession(iSessionEndCallBack);

	NKern::ThreadLeaveCS(); 

    if (iSession == NULL)

        {

		// DMMCStack::AllocSession() failed to create a new instance off DMMCSession

        OstTrace0(TRACE_FLOW, DRPMBDEVICE_OPEN_11, "RPMB: failed to create a new instance of DMMCSession");

        __KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: failed to create a new instance of DMMCSession"));

        return KErrNoMemory; 

        }

    iSession->SetStack(stack);

    iSession->SetCard(iCard);

    TInt bufLen, minorBufLen;

    stack->BufferInfo(iIntBuf, bufLen, minorBufLen);

	// mmc media driver reserved the first KRpmbOneFramePacketLength bytes of the 

	// PSL buffer to be used for RPMB requests / responses

	iIntBuf += minorBufLen;

    if(iCard->ExtendedCSD().ExtendedCSDRev() < 5 || iCard->ExtendedCSD().RpmbSize() == 0)

        {

		// RPMB is not supported on selected hardware

        ClearSynchronisationParms();

        OstTrace0(TRACE_FLOW, DRPMBDEVICE_OPEN_12, "RPMB: feature is not supported on selected hardware");

        __KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: feature is not supported on selected hardware"));

        return KErrNotSupported;

        }

    OstTrace0(TRACE_FLOW, DRPMBDEVICE_OPEN_13, "RPMB: <DrpmbDevice::Open");

    __KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: <DrpmbDevice::Open"));

    return KErrNone;

    }

EXPORT_C void DRpmbDevice::Close()

    {

	//

    //Closes an interaction with an RPMB configured device 

    //

    OstTrace0(TRACE_FLOW, DRPMBDEVICE_CLOSE_1, "RPMB: >DrpmbDevice::Close");

    __KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: >DrpmbDevice::Close"));

	ClearSynchronisationParms();

	iBusCallBack.Remove();

	NKern::ThreadEnterCS();

    if(iPowerUpSemaphore)

		{

        iPowerUpSemaphore->Close(NULL);

		iPowerUpSemaphore = NULL;

		}

	if (iSession)

		{

		delete iSession;

		iSession = NULL;

		}

	if(iRequestSemaphore)

		{

        iRequestSemaphore->Close(NULL);

		iRequestSemaphore = NULL;

		}

	NKern::ThreadLeaveCS();

	OstTrace0(TRACE_FLOW, DRPMBDEVICE_CLOSE_2, "RPMB: <DrpmbDevice::Close");

	__KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: <DrpmbDevice::Close"));

    }

EXPORT_C TInt DRpmbDevice::SendAccessRequest(TDes8& aRpmbRequest, TDes8& aRpmbResponse)

    {

    //

    //sends a request to be handled by the RPMB partition

    //aRpmbRequest - the physically contiguous region of memory containg the request to be handled

    //aRpmbResponse - the physically contiguous region memory to where the response from the hardware will be written

	//returns KErrNone if successful

	//returns system wide epoc error code if set on call back from stack

	//returns KErrArgument for invalid descriptor argument length

	//returns KErrNotReady if not opened

	//retruns KErrNotready if MMC stack is processing a posponed power down or a postponed media change event

	//otherwise returns system wide error code 

	//

    OstTrace0(TRACE_FLOW, DRPMBDEVICE_SENDACCESSREQUEST_1, "RPMB: >DrpmbDevice::SendAccessRequest");

    __KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: >DrpmbDevice::SendAccessRequest"));

	if ((aRpmbRequest.Length() != KRpmbOneFramePacketLength) || (aRpmbResponse.Length() != KRpmbOneFramePacketLength))

		{

		// insist on single frame access as mutiple read and multiple write (reliable write) notb yet supported

		return KErrArgument;

		}

	if (iSession == NULL)

        {

		// DRpmbDevice::Open not called at all

		// or not called after DRpmbDevice::Close

	    OstTrace0(TRACE_FLOW, DRPMBDEVICE_SENDACCESSREQUEST_2, "RPMB: DMMCSession is NULL");

	    __KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: DMMCSession is NULL"));

        return KErrNotReady;

        }

	if (iRequestSemaphore == NULL)

		{

		// iRequestSemaphore zero filled prior to contruction

		// create semaphore for waiting on stack

		NKern::ThreadEnterCS();

		TInt r = Kern::SemaphoreCreate(iRequestSemaphore,_L("RPMBRequestSemaphore"), 0);

		NKern::ThreadLeaveCS();

		if (r != KErrNone)

			{

			// failed to create semaphore 

		    OstTrace1(TRACE_FLOW, DRPMBDEVICE_SENDACCESSREQUEST_3, "RPMB: failed to create semaphore err = %d", r);

		    __KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: failed to create semaphore err = %d", r));

			return r;

			}

		}

    memcpy(iIntBuf, aRpmbRequest.Ptr(), KRpmbOneFramePacketLength);

    TInt r = iSocket->InCritical();

	// may be KErrNotready if MMC stack is processing a posponed power down event or a postponed media change event

	if (r == KErrNone)

       {

    iSession->SetPartition(TExtendedCSD::ESelectRPMB);            //Set RPMB Partition

    iSession->ResetCommandStack();

    iSession->FillCommandArgs(KDeviceAddress, KRpmbOneFramePacketLength, iIntBuf, KRpmbOneFramePacketLength);

    iSession->iSessionID = ECIMRpmbAccess;

        r = iSession->Engage();

        if(r == KErrNone)

            {

			Kern::SemaphoreWait(*iRequestSemaphore);

			memcpy((TUint8 *)aRpmbResponse.Ptr(), iIntBuf, KRpmbOneFramePacketLength);

		    OstTrace1(TRACE_FLOW, DRPMBDEVICE_SENDACCESSREQUEST_4, "RPMB: request complete with %d", iSession->EpocErrorCode());

		    __KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: request complete with %d", iSession->EpocErrorCode()));

			return iSession->EpocErrorCode();  

            }

        }

    iSocket->EndInCritical();

    OstTrace1(TRACE_FLOW, DRPMBDEVICE_SENDACCESSREQUEST_5, "RPMB: <DrpmbDevice::SendAccessRequest complete %d", r);

    __KTRACE_OPT(KPBUS1, Kern::Printf("RPMB: <DrpmbDevice::SendAccessRequest complete %d", r));

    return r;

    }

DECLARE_STANDARD_EXTENSION()

    {

    __KTRACE_OPT(KBOOT,Kern::Printf("RPMBEXT.DLL DECLARE_STANDARD_EXTENSION entry point"));      

	return KErrNone;

    }