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

// \omap3530\omap3530_assp\shared\tps65950\tps65950.cpp

// Access driver for TPS65950

// This file is part of the Beagle Base port

//

#include <e32cmn.h>

#include <kernel.h>

#include <nk_priv.h>

//#include <e32atomics.h>

#include <omap3530_i2c.h>

#include <omap3530_i2creg.h>

#include "tps65950.h"

GLREF_C TInt InitInterrupts();

const TUint KGroupCount = 5;

// One handle per group on TPS65950

static I2c::THandle	I2cHandle[ KGroupCount ];

// One DCB per group

static I2c::TConfigPb TheDcb[ KGroupCount ];

// I2C transfer object

enum TPhase

	{

	EAddressPb,

	EDataPb

	};

static I2c::TTransferPb TheTransferPb[2];

// Group index to Group number

static const TUint8 KGroupIndexToGroupNumber[ KGroupCount ] =

	{ 0x12, 0x48, 0x49, 0x4a, 0x4b };

// Queue of requests

static SDblQue TheQueue;

// Current state

enum TState

	{

	EIdle,

	EPending,

	EReading,

	EWriting,

	EUnprotectPhase0

	};

static TState CurrentState;

TPS65950::TReq* CurrentPhaseReq;

TPS65950::TReq* PreviousPhaseReq;

LOCAL_D TUint8 IsInitialized;	// auto-cleared to EFalse

const TUint8	KUnprotectPhase0Data	= 0xCE;

const TUint8	KUnprotectPhase1Data	= 0xEC;

static const TUint8 KUnprotectData[4] =

	{

	TPS65950::Register::PROTECT_KEY bitand TPS65950::Register::KRegisterMask, KUnprotectPhase0Data,

	TPS65950::Register::PROTECT_KEY bitand TPS65950::Register::KRegisterMask, KUnprotectPhase1Data,

	};

static const TUint8 KProtectData[2] =

	{

	TPS65950::Register::PROTECT_KEY bitand TPS65950::Register::KRegisterMask, 0

	};

static TUint8 TempWriteBuf[2];

// Spinlock to protect queue when adding or removing items

//static TSpinLock QueueLock(TSpinLock::EOrderGenericIrqLow1+1);

GLDEF_D TDfcQue*	TheDfcQue;

const TInt KDfcQuePriority	= 27;

_LIT( KDriverNameDes, "tps65950" );

TInt TheProtectionUsageCount = 0;

LOCAL_C void InternalPanic( TInt aLine )

	{

	Kern::Fault( "tps65950", aLine );

	}

LOCAL_C void PanicClient( TPS65950::TPanic aPanic )

	{

	Kern::PanicCurrentThread( KDriverNameDes, aPanic );

	}

namespace TPS65950

{

void CompletionDfcFunction( TAny* aParam );

void SyncDfcFunction( TAny* aParam );

void DummyDfcFunction( TAny* aParam );

static TDfc CompletionDfc( CompletionDfcFunction, NULL, 1 );

static TDfc DummyDfc( CompletionDfcFunction, NULL, 1 );

FORCE_INLINE TReq& ReqFromLink( SDblQueLink* aLink )

	{

	return *_LOFF( aLink, TReq, iLink );

	}

inline TBool AtomicSetPendingWasIdle()

	{

	// atomic if (CurrentState == idleState) {CurrentState=EPending, returns TRUE} else {idleState=CurrentState, CurrentState unchanged, return FALSE}

	TState idleState = EIdle;	// required for atomic comparison

	//TBool wasIdle = __e32_atomic_cas_ord32( (TUint32*)&CurrentState, (TUint32*)&idleState, EPending );

	//return wasIdle;

	if (CurrentState == idleState)

		{

		CurrentState = EPending;

		return ETrue;

		}

	else

		{

		idleState = CurrentState;

		return EFalse;

		}

	}

void StartRead( TReq& aReq )

	{

	__KTRACE_OPT( KTPS65950, Kern::Printf( "+TPS65950:StartRead(@%x) [%x:%x]",

												&aReq,

												KGroupIndexToGroupNumber[ aReq.iRegister >> Register::KGroupShift ],

												aReq.iRegister bitand Register::KRegisterMask ) );

	//__e32_atomic_store_ord32( &CurrentState, EReading );

	CurrentState = EReading;

	TheTransferPb[ EAddressPb ].iData = (TUint8*)&aReq.iRegister;	// low byte is register address

	TheTransferPb[ EDataPb ].iType = I2c::TTransferPb::ERead;

	TheTransferPb[ EDataPb ].iData = &aReq.iReadValue;

	__DEBUG_ONLY( aReq.iReadValue = 0xEE );

	TheTransferPb[ EDataPb ].iLength = 1;

	TheTransferPb[ EAddressPb ].iResult = KErrNone;

	TheTransferPb[ EDataPb ].iResult = KErrNone;

	TUint groupIndex = aReq.iRegister >> Register::KGroupShift;

	I2c::TransferA( I2cHandle[ groupIndex ], TheTransferPb[ EAddressPb ] );

	__KTRACE_OPT( KTPS65950, Kern::Printf( "-TPS65950:StartRead(@%x)", &aReq ) );

	}

void StartWrite( TReq& aReq )

	{

	__KTRACE_OPT( KTPS65950, Kern::Printf( "+TPS65950:StartWrite(@%x) [%x:%x]<-%x",

												&aReq,

												KGroupIndexToGroupNumber[ aReq.iRegister >> Register::KGroupShift ],

												aReq.iRegister bitand Register::KRegisterMask,

												aReq.iWriteValue ) );

	//__e32_atomic_store_ord32( &CurrentState, EWriting );

	CurrentState = EWriting;

	TempWriteBuf[0] = aReq.iRegister bitand Register::KRegisterMask;

	TempWriteBuf[1] = aReq.iWriteValue;

	TheTransferPb[ EDataPb ].iType = I2c::TTransferPb::EWrite;

	TheTransferPb[ EDataPb ].iData = &TempWriteBuf[0];

	TheTransferPb[ EDataPb ].iLength = 2;

	TheTransferPb[ EDataPb ].iResult = KErrNone;

	TUint groupIndex = aReq.iRegister >> Register::KGroupShift;

	I2c::TransferA( I2cHandle[ groupIndex ], TheTransferPb[ EDataPb ] );

	__KTRACE_OPT( KTPS65950, Kern::Printf( "-TPS65950:StartWrite(@%x)", &aReq ) );

	}

void StartUnprotectPhase0( TReq& aReq )

	{

	__KTRACE_OPT( KTPS65950, Kern::Printf( "+TPS65950:StartUnprotectPhase0(@%x)", &aReq ) );

	//__e32_atomic_store_ord32( &CurrentState, EUnprotectPhase0 );

	CurrentState = EUnprotectPhase0;

	TheTransferPb[ EDataPb ].iType = I2c::TTransferPb::EWrite;

	TheTransferPb[ EDataPb ].iData = &KUnprotectData[0];

	TheTransferPb[ EDataPb ].iLength = 2;

	TheTransferPb[ EDataPb ].iResult = KErrNone;

	const TUint groupIndex = Register::PROTECT_KEY >> Register::KGroupShift;

	I2c::TransferA( I2cHandle[ groupIndex ], TheTransferPb[ EDataPb ] );

	__KTRACE_OPT( KTPS65950, Kern::Printf( "-TPS65950:StartUnprotectPhase0(@%x)", &aReq ) );

	}

void StartUnprotectPhase1( TReq& aReq )

	{

	__KTRACE_OPT( KTPS65950, Kern::Printf( "+TPS65950:StartUnprotectPhase1(@%x)", &aReq ) );

	// Set state to writing so that it will complete as a normal write

	//__e32_atomic_store_ord32( &CurrentState, EWriting );

	CurrentState = EWriting;

	TheTransferPb[ EDataPb ].iData = &KUnprotectData[2];

	TheTransferPb[ EDataPb ].iResult = KErrNone;

	const TUint groupIndex = Register::PROTECT_KEY >> Register::KGroupShift;

	I2c::TransferA( I2cHandle[ groupIndex ], TheTransferPb[ EDataPb ] );

	__KTRACE_OPT( KTPS65950, Kern::Printf( "-TPS65950:StartUnprotectPhase1(@%x)", &aReq ) );

	}

void StartProtect( TReq& aReq )

	{

	__KTRACE_OPT( KTPS65950, Kern::Printf( "+TPS65950:StartProtect(@%x)", &aReq ) );

	//__e32_atomic_store_ord32( &CurrentState, EWriting );

	CurrentState = EWriting;

	TheTransferPb[ EDataPb ].iType = I2c::TTransferPb::EWrite;

	TheTransferPb[ EDataPb ].iData = &KProtectData[0];

	TheTransferPb[ EDataPb ].iLength = 2;

	TheTransferPb[ EDataPb ].iResult = KErrNone;

	const TUint groupIndex = Register::PROTECT_KEY >> Register::KGroupShift;

	I2c::TransferA( I2cHandle[ groupIndex ], TheTransferPb[ EDataPb ] );

	__KTRACE_OPT( KTPS65950, Kern::Printf( "-TPS65950:StartWrite(@%x)", &aReq ) );

	}

void StartRequest()

	{

	__KTRACE_OPT( KTPS65950, Kern::Printf( "+TPS65950:StartRequest(%d)", CurrentState ) );

	__ASSERT_DEBUG( EPending == CurrentState, InternalPanic( __LINE__ ) );

	// We don't need to take lock here because we're currently idle so it's not possible

	// for there to be a change in which item is queue head. The link pointers of the

	// head item could change if another thread is queueing a new request, but that doesn't

	// affect any of the fields we care about here

	__ASSERT_DEBUG( !TheQueue.IsEmpty(), InternalPanic( __LINE__ ) );

	if( !CurrentPhaseReq )

		{

		PreviousPhaseReq = NULL;

		CurrentPhaseReq = &ReqFromLink( TheQueue.First() );

		}

	FOREVER

		{

		if( !CurrentPhaseReq )

			{

			__ASSERT_DEBUG( PreviousPhaseReq, InternalPanic( __LINE__ ) );

			// we didn't find any phases to execute, so complete request

			// by faking a write completion on the previous phase

			CurrentPhaseReq = PreviousPhaseReq;

			//__e32_atomic_store_ord32( &CurrentState, EWriting );

			CurrentState = EWriting;

			// Queue DFC instead of calling directly to avoid recursion if multiple items on queue

			// complete without any action

			CompletionDfc.Enque();

			break;

			}

		else

			{

			TReq::TAction action = CurrentPhaseReq->iAction;

			__KTRACE_OPT( KTPS65950, Kern::Printf( "=TPS65950:StartRequest:req@%x:a=%x", CurrentPhaseReq, action ) );

			if( (TReq::ERead == action) || (TReq::EClearSet == action) )

				{

				StartRead( *CurrentPhaseReq );

				break;

				}

			else if( TReq::EWrite == action )

				{

				StartWrite( *CurrentPhaseReq );

				break;

				}

			else if( TReq::EDisableProtect == action )

				{

				if( ++TheProtectionUsageCount == 1 )

					{

					// Currently protected, start an unprotect sequence

					StartUnprotectPhase0( *CurrentPhaseReq );

					break;

					}

				else 

					{

					goto move_to_next_phase;

					}

				}

			else if( TReq::ERestoreProtect == action )

				{

				if( --TheProtectionUsageCount == 0 )

					{

					StartProtect( *CurrentPhaseReq );

					break;

					}

				else 

					{

	move_to_next_phase:

					// already unprotected, skip to next phase

					CurrentPhaseReq->iResult = KErrNone;

					PreviousPhaseReq = CurrentPhaseReq;

					CurrentPhaseReq = CurrentPhaseReq->iNextPhase;

					}

				}

			else

				{

				InternalPanic( __LINE__ );

				}

			}

		}

	__KTRACE_OPT( KTPS65950, Kern::Printf( "-TPS65950:StartRequest(%d)", CurrentState ) );

	}

void DummyDfcFunction( TAny* /*aParam*/ )

	{

	__KTRACE_OPT( KTPS65950, Kern::Printf( "TPS65950:DummyDFC(%d)", CurrentState ) );

	}

void CompletionDfcFunction( TAny* /*aParam*/ )

	{

	__KTRACE_OPT( KTPS65950, Kern::Printf( "+TPS65950:DFC(%d)", CurrentState ) );

	__ASSERT_DEBUG( EIdle != CurrentState, InternalPanic( __LINE__ ) );

	__ASSERT_DEBUG( CurrentPhaseReq, InternalPanic( __LINE__ ) );

	TInt result = TheTransferPb[ EDataPb ].iResult;

	if( KErrNone != TheTransferPb[ EAddressPb ].iResult )

		{

		result = TheTransferPb[ EAddressPb ].iResult;

		}

	TReq& req = *CurrentPhaseReq;

	TBool completed = ETrue;

	if( KErrNone == result)

		{

		if( EReading == CurrentState )

			{

			__KTRACE_OPT( KTPS65950, Kern::Printf( "=TPS65950:DFC:Read [%x:%x]=%x",

													KGroupIndexToGroupNumber[ req.iRegister >> Register::KGroupShift ],

													req.iRegister bitand Register::KRegisterMask,

													req.iReadValue ) );

			if( TReq::EClearSet == req.iAction)

				{

				// Start write phase of a ClearSet

				req.iWriteValue = (req.iReadValue bitand ~req.iClearMask) bitor req.iSetMask;

				StartWrite( req );

				completed = EFalse;

				}

			}

		else if( EUnprotectPhase0 == CurrentState )

			{

			StartUnprotectPhase1( req );

			completed = EFalse;

			}

		}

	if( completed || (KErrNone != result) )

		{

		// Read or write, protect has completed, or final write stage of a ClearSet or unprotect, or error

		PreviousPhaseReq = CurrentPhaseReq;

		CurrentPhaseReq = req.iNextPhase;

		if( CurrentPhaseReq )

			{

			// start next phase

			//__e32_atomic_store_ord32( &CurrentState, EPending );

			CurrentState = EPending;

			StartRequest();

			}

		else

			{

			//__e32_atomic_store_ord32( &CurrentState, EIdle );

			CurrentState = EIdle;

			// From now a concurrent ExecAsync() can start a new request if it adds an item to the queue

			// remove item from queue and complete

			TUint irq = __SPIN_LOCK_IRQSAVE( QueueLock );

			ReqFromLink( TheQueue.First() ).iLink.Deque();

			TBool queueEmpty = TheQueue.IsEmpty();

			__SPIN_UNLOCK_IRQRESTORE( QueueLock, irq );

			// If queue was empty inside spinlock but an ExecAsync() adds an item before the if statement below,

			// the ExecAsync() will start the new request

			if( !queueEmpty )

				{

				if( AtomicSetPendingWasIdle() )

					{

					// ExecAsync didn't start a request

					StartRequest();

					}

				}

			// Notify client of completion

			req.iResult = result;

			if( req.iCompletionDfc )

				{

				req.iCompletionDfc->Enque();

				}

			}

		}

	__KTRACE_OPT( KTPS65950, Kern::Printf( "-TPS65950:DFC(%d)", CurrentState ) );

	}

// Used to complete synchronous operations

void SyncDfcFunction( TAny* aParam )

	{

	NKern::FSSignal( reinterpret_cast<NFastSemaphore*>( aParam ) );

	}

EXPORT_C void ExecAsync( TReq& aRequest )

	{

	__KTRACE_OPT( KTPS65950, Kern::Printf( "+TPS65950:ExecAsync(@%x)", &aRequest ) );

	__ASSERT_DEBUG( (TUint)aRequest.iAction <= TReq::ERestoreProtect, PanicClient( EBadAction ) );

	__ASSERT_DEBUG( (TReq::EDisableProtect == aRequest.iAction) 

					|| (TReq::ERestoreProtect == aRequest.iAction)

					|| (((TUint)aRequest.iRegister >> Register::KGroupShift) < KGroupCount), PanicClient( EBadGroup ) );

	TUint irq = __SPIN_LOCK_IRQSAVE( QueueLock );

	TheQueue.Add( &aRequest.iLink );

	__SPIN_UNLOCK_IRQRESTORE( QueueLock, irq );

	if( AtomicSetPendingWasIdle() )

		{

		StartRequest();

		}

	__KTRACE_OPT( KTPS65950, Kern::Printf( "-TPS65950:ExecAsync" ) );

	}

EXPORT_C TInt WriteSync( TUint16 aRegister, TUint8 aValue )

	{

	__ASSERT_NO_FAST_MUTEX;

	NFastSemaphore sem;

	TDfc dfc( SyncDfcFunction, &sem, TheDfcQue, 2 );

	TReq req;

	req.iRegister = aRegister;

	req.iAction = TReq::EWrite;

	req.iCompletionDfc = &dfc;

	req.iWriteValue = aValue;

	req.iNextPhase = NULL;

	NKern::FSSetOwner( &sem, NULL );

	ExecAsync( req );

	NKern::FSWait( &sem );

	return req.iResult;

	}

EXPORT_C TInt ReadSync( TUint16 aRegister, TUint8& aValue )

	{

	__ASSERT_NO_FAST_MUTEX;

	NFastSemaphore sem;

	TDfc dfc( SyncDfcFunction, &sem, TheDfcQue, 2 );

	TReq req;

	req.iRegister = aRegister;

	req.iAction = TReq::ERead;

	req.iCompletionDfc = &dfc;

	req.iNextPhase = NULL;

	NKern::FSSetOwner( &sem, NULL );

	ExecAsync( req );

	NKern::FSWait( &sem );

	aValue = req.iReadValue;

	return req.iResult;

	}

EXPORT_C TInt ClearSetSync( TUint16 aRegister, TUint8 aClearMask, TUint8 aSetMask )

	{

	__ASSERT_NO_FAST_MUTEX;

	NFastSemaphore sem;

	TDfc dfc( SyncDfcFunction, &sem, TheDfcQue, 2 );

	TReq req;

	req.iRegister = aRegister;

	req.iAction = TReq::EClearSet;

	req.iCompletionDfc = &dfc;

	req.iClearMask = aClearMask;

	req.iSetMask = aSetMask;

	req.iNextPhase = NULL;

	NKern::FSSetOwner( &sem, NULL );

	ExecAsync( req );

	NKern::FSWait( &sem );

	return req.iResult;

	}

EXPORT_C TInt DisableProtect()

	{

	__ASSERT_NO_FAST_MUTEX;

	NFastSemaphore sem;

	TDfc dfc( SyncDfcFunction, &sem, TheDfcQue, 2 );

	TReq req;

	req.iAction = TReq::EDisableProtect;

	req.iCompletionDfc = &dfc;

	req.iNextPhase = NULL;

	NKern::FSSetOwner( &sem, NULL );

	ExecAsync( req );

	NKern::FSWait( &sem );