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

// e32\drivers\adc\d_adc.cpp

// Generic ADC driver

// 

//

#include <adc.h>

/******************************************************

 * ADC Channel

 ******************************************************/

EXPORT_C TAdcChannel::TAdcChannel(TInt anAdc)

	:	iChannelId(-1), iCommandCount(0), iCommandList(NULL),

		iReadings(NULL)

	{

	iNext=NULL;

//	iPriority=0;

	if (anAdc>=0 && anAdc<DAdc::NumberOfAdcs)

		iAdc=DAdc::TheAdcs[anAdc];

	else

		iAdc=NULL;

	}

EXPORT_C void TAdcChannel::Read(TInt* aReadingBuffer)

//

// Initiate a reading of this channel

//

	{

	TInt irq=NKern::DisableAllInterrupts();

	if (!iNext)

		{

		iReadings=aReadingBuffer;

		iAdc->Add(this);

		}

	NKern::RestoreInterrupts(irq);

	}

EXPORT_C void TAdcChannel::Preamble()

//

// Default preamble does nothing

//

	{

	}

EXPORT_C void TAdcChannel::Postamble()

//

// Default postamble does nothing

//

	{

	}

/******************************************************

 * ADC Controller

 ******************************************************/

LOCAL_C void timerExpired(TAny* aPtr)

	{

	((DAdc*)aPtr)->TimerExpired();

	}

DAdc::DAdc()

	:	iTimer(timerExpired,this)

	{

//	iCurrentChannel=NULL;

//	iCurrentCommand=0;

//	iCommandPtr=0;

//	iCommandCount=0;

//	iMinPriority=0;

	}

DAdc::~DAdc()

	{

	}

EXPORT_C TInt DAdc::SetMinPriority(TInt anAdc, TInt aPriority)

	{

	if (anAdc<0 || anAdc>=NumberOfAdcs)

		return KErrArgument;

	if (aPriority<0 || aPriority>KNumAdcChannelPriorities)

		return KErrArgument;

	return TheAdcs[anAdc]->DoSetMinPriority(aPriority);

	}

TInt DAdc::DoSetMinPriority(TInt aPriority)

	{

	TInt irq=NKern::DisableAllInterrupts();

	if (aPriority<iMinPriority)

		{

		if (iList.iPresent[0])

			{

			TAdcChannel* pN=iList.First();

			if (pN->iPriority>=aPriority)

				{

				iList.Remove(pN);

				Execute(pN);

				}

			}

		}

	iMinPriority=aPriority;

	NKern::RestoreInterrupts(irq);

	return KErrNone;

	}

void DAdc::Add(TAdcChannel* aChannel)

//

// Queue another ADC reading request

//

	{

	if (iCurrentChannel || (aChannel->iPriority<iMinPriority))

		iList.Add(aChannel);

	else

		Execute(aChannel);

	}

void DAdc::Execute(TAdcChannel* aChannel)

//

// Begin execution of an ADC request

// This runs in an ISR or with interrupts disabled

//

	{

	aChannel->iNext=(TPriListLink*)1;	// so channel will not be queued again

	iCurrentChannel=aChannel;

	iCommandPtr=aChannel->iCommandList;

	iCommandCount=aChannel->iCommandCount;

	NextCommand();

	}

void DAdc::NextCommand()

//

// Perform the next command in the command list

// This runs in an ISR or with interrupts disabled

//

	{

	TBool wait=EFalse;

	TAdcChannel* pC=iCurrentChannel;

	if (iCommandCount)

		{

		TInt c=*iCommandPtr++;

		iCurrentCommand=c;

		iCommandCount--;

		if (c & EAdcCmdPreamble)

			pC->Preamble();

		if (c & EAdcCmdPostamble)

			pC->Postamble();

		if (c & EAdcCmdWait)

			{

			iTimer.OneShot(c & 0xffff);

			wait=ETrue;

			}

		else if (c & EAdcCmdReading)

			{

			StartConversion(pC->iChannelId);

			wait=ETrue;

			}

		}

	if (iCommandCount==0 && !wait)

		{

		iCurrentChannel=NULL;

		pC->iNext=NULL;

		if (iList.iPresent[0])

			{

			TAdcChannel* pN=iList.First();

			if (pN->iPriority>=iMinPriority)

				{

				iList.Remove(pN);

				Execute(pN);

				}

			}

		pC->Complete();

		}

	}

void DAdc::Start()

//

// Called on completion of initialisation to start processing requests

// This runs in an ISR

//

	{

	iCurrentChannel=NULL;

	if (iList.iPresent[0])

		{

		TAdcChannel* pN=iList.First();

		iList.Remove(pN);

		Execute(pN);

		}

	}

void DAdc::ConversionComplete(TInt aValue)

//

// Called when a conversion has completed

// This runs in an ISR

//

	{

	if ((iCurrentCommand & EAdcCmdDiscard)==0)

		*(iCurrentChannel->iReadings)++=aValue;

	NextCommand();

	}

void DAdc::TimerExpired()

//

// Called in ISR when timer expires

//

	{

	NextCommand();

	}