// 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:

// template\template_variant\specific\uart.cpp

// pdd for serial ports

// assume Modem Control Signals change cause an interrupt

// 

//

#include <drivers/comm.h>

#include <template_assp.h>

#include "iolines.h"

#include <e32hal.h>

_LIT(KPddName,"Comm.Template");

// needs ldd version..

const TInt KMinimumLddMajorVersion=1;

const TInt KMinimumLddMinorVersion=1;

const TInt KMinimumLddBuild=122;

//

// TO DO: (mandatory)

//

// Define here the UART enumeration data for the serial ports.

// It is a good idea to define each enumerated value as a bit mask that can be written to (or OR-ed or AND-ed to)

// a hardware register to provide the configuration option desired (the following are EXAMPLES ONLY):

//

// EXAMPLE ONLY

enum TUartBaudRate

	{

	EUartBaudRate115200/* =bitmask for 115200 Baud */,

	EUartBaudRate76800/* =bitmask for 76800 Baud */,

	EUartBaudRate57600/* =bitmask for 57600 Baud */,

	EUartBaudRate38400/* =bitmask for 38400 Baud */,

	EUartBaudRate19200/* =bitmask for 19200 Baud */,

	EUartBaudRate14400/* =bitmask for 14400 Baud */,

	EUartBaudRate9600/* =bitmask for 9600 Baud */,

	EUartBaudRate4800/* =bitmask for 4800 Baud */,

	EUartBaudRate2400/* =bitmask for 2400 Baud */,

	EUartBaudRate1200/* =bitmask for 1200 Baud */,

	EUartBaudRate600/* =bitmask for 600 Baud */,

	EUartBaudRate300/* =bitmask for 300 Baud */,

	EUartBaudRate150/* =bitmask for 150 Baud */,

	EUartBaudRate110/* =bitmask for 110 Baud */

	};

// EXAMPLE ONLY

enum TUartBreak

	{

	EUartBreakOff/* =bitmask for turning Break Off */,

	EUartBreakOn/* =bitmask for turning Break On */

	};

// EXAMPLE ONLY

enum TUartParity

	{

	EUartParityNone/* =bitmask for no Parity */,

	EUartParityOdd/* =bitmask for odd Parity */,

	EUartParityEven/* =bitmask for even Parity */

	};

// EXAMPLE ONLY

enum TUartStopBit

	{

	EUartStopBitOne/* =bitmask for one stop bit */,

	EUartStopBitTwo/* =bitmask for two stop bits */

	};

enum TUartDataLength

	{

	EUartDataLength5/* =bitmask for five data bits */,

	EUartDataLength6/* =bitmask for six data bits */,

	EUartDataLength7/* =bitmask for seven data bits */,

	EUartDataLength8/* =bitmask for eight data bits */

	};

//

// TO DO: (mandatory)

//

// Lookup table to convert EPOC baud rates into hardware-specific baud rate values

// Unsupported baud rates select the nearest lower rate.

//

// EXAMPLE ONLY

static const TUartBaudRate BaudRate[19] =

	{

	EUartBaudRate110,EUartBaudRate110,EUartBaudRate110,

	EUartBaudRate110,EUartBaudRate150,EUartBaudRate300,

	EUartBaudRate600,EUartBaudRate1200,EUartBaudRate110,

	EUartBaudRate110,EUartBaudRate2400,EUartBaudRate110,

	EUartBaudRate4800,EUartBaudRate110,EUartBaudRate9600,

	EUartBaudRate19200,EUartBaudRate38400,EUartBaudRate57600,

	EUartBaudRate115200

	};

//

// TO DO: (mandatory)

//

// Lookup table to convert EPOC parity settings into hardware-specific values

//

// EXAMPLE ONLY

static const TUartParity Parity[3] =

	{

	EUartParityNone,EUartParityEven,EUartParityOdd

	};

//

// TO DO: (mandatory)

//

// Lookup table to convert EPOC stop bit values into hardware-specific values

//

// EXAMPLE ONLY

static const TUartStopBit StopBit[2] =

	{

	EUartStopBitOne,EUartStopBitTwo

	};

//

// TO DO: (mandatory)

//

// Lookup table to convert EPOC data bit settings into hardware-specific values

//

// EXAMPLE ONLY

static const TUartDataLength DataLength[4] =

	{

	EUartDataLength5,EUartDataLength6,	

	EUartDataLength7,EUartDataLength8

	};

class DDriverComm : public DPhysicalDevice

	{

public:

	DDriverComm();

	virtual TInt Install();

	virtual void GetCaps(TDes8 &aDes) const;

	virtual TInt Create(DBase*& aChannel, TInt aUnit, const TDesC8* anInfo, const TVersion &aVer);

	virtual TInt Validate(TInt aUnit, const TDesC8* anInfo, const TVersion &aVer);

	};

class DCommTemplate : public DComm

	{

public:

	DCommTemplate();

	~DCommTemplate();

	TInt DoCreate(TInt aUnit, const TDesC8* anInfo);

public:

	virtual TInt Start();

	virtual void Stop(TStopMode aMode);

	virtual void Break(TBool aState);

	virtual void EnableTransmit();

	virtual TUint Signals() const;

	virtual void SetSignals(TUint aSetMask,TUint aClearMask);

	virtual TInt ValidateConfig(const TCommConfigV01 &aConfig) const;

	virtual void Configure(TCommConfigV01 &aConfig);

	virtual void Caps(TDes8 &aCaps) const;

	virtual TInt DisableIrqs();

	virtual void RestoreIrqs(TInt aIrq);

	virtual TDfcQue* DfcQ(TInt aUnit);

	virtual void CheckConfig(TCommConfigV01& aConfig);

public:

	static void Isr(TAny* aPtr);

public:

	TInt iInterruptId;

	TInt iUnit;

	TLinAddr iPortAddr;

	TInt iInInterrupt;

	TUint iSignals;

	TDynamicDfcQue*	iDfcQ;

	};

DDriverComm::DDriverComm()

//

// Constructor

//

	{

	//

	// TO DO: (mandatory)

	//

	// Set up iUnitMask with the number of Units (Serial Ports) supported by this PDD,

	// 1 bit set per Unit supported e.g.:

	// iUnitsMask=0x7;	->  supports units 0, 1, 2

	//

	iVersion=TVersion(KCommsMajorVersionNumber,KCommsMinorVersionNumber,KCommsBuildVersionNumber);

	}

TInt DDriverComm::Install()

//

// Install the driver

//

	{

	return SetName(&KPddName);

	}

void GetTemplateCommsCaps(TDes8 &aCaps, TInt aUnit)

	{

	TCommCaps2 capsBuf;

	//

	// TO DO: (mandatory)

	//

	// Fill in the Caps structure with the relevant information for this Unit, e.g

	//  TCommCapsV02 &c=capsBuf();

	//	c.iRate=(OR in as many KCapsBpsXXX as bit rates supported);

	//	c.iDataBits=(OR in as many KCapsDataXXX as data length configuration supported);

	//	c.iStopBits=(OR in as many KCapsStopXXX as the number of stop bits configurations supported);

	//	c.iParity=(OR in as many KCapsParityXXX as parity configuration supported);

	//	c.iHandshake=(OR in all KCapsObeyXXXSupported, KCapsSendXXXSupported, KCapsFailXXXSupported, KCapsFreeXXXSupported

	//				  as required for this Unit's configuration);.

	//	c.iSignals=(OR in as many KCapsSignalXXXSupported as Modem control signals controllable by this Unit);

	//	c.iSIR=(0 or OR in as many KCapsSIRXXX as IR bit rates supported);

	//	c.iNotificationCaps=(OR in as many KNotifyXXXSupported as notifications supported by this Unit);

	//	c.iFifo=(0 or KCapsHasFifo);

	//	c.iRoleCaps=(0 or KCapsRoleSwitchSupported);

	//	c.iFlowControlCaps=(0 or KCapsFlowControlStatusSupported);

	/** @see TCommCapsV02 */

	//

	aCaps.FillZ(aCaps.MaxLength());

	aCaps=capsBuf.Left(Min(capsBuf.Length(),aCaps.MaxLength()));

	}

void DDriverComm::GetCaps(TDes8 &aDes) const

//

// Return the drivers capabilities

//

	{

	GetTemplateCommsCaps(aDes, 0);

	}

TInt DDriverComm::Create(DBase*& aChannel, TInt aUnit, const TDesC8* anInfo, const TVersion& aVer)

//

// Create a driver

//

	{

	DCommTemplate* pD=new DCommTemplate;

	aChannel=pD;

	TInt r=KErrNoMemory;

	if (pD)

		r=pD->DoCreate(aUnit,anInfo);

	return r;

	}

TInt DDriverComm::Validate(TInt aUnit, const TDesC8* /*anInfo*/, const TVersion& aVer)

//

//	Validate the requested configuration (Version and Unit)

//

	{

	if ((!Kern::QueryVersionSupported(iVersion,aVer)) || (!Kern::QueryVersionSupported(aVer,TVersion(KMinimumLddMajorVersion,KMinimumLddMinorVersion,KMinimumLddBuild))))

		return KErrNotSupported;

	//

	// TO DO: (mandatory)

	//

	// Return KErrNotSupported if aUnit is not in the supported range for this driver, KErrNone if it is

	//

	return KErrNone;

	}

DCommTemplate::DCommTemplate()

//

// Constructor

//

	{

	iInterruptId=-1;		// -1 means not bound

	}

DCommTemplate::~DCommTemplate()

//

// Destructor

//

	{

	if (iInterruptId>=0)

		Interrupt::Unbind(iInterruptId);

	if (iDfcQ)

		{

		iDfcQ->Destroy();

		}

	}

const TInt KDCommTemplDfcThreadPriority = 24;

_LIT(KDCommTemplDfcThread,"DCommTemplDfcThread");

TInt DCommTemplate::DoCreate(TInt aUnit, const TDesC8* /*anInfo*/)

//

// Sets up the PDD

//

	{

	iUnit=aUnit;

	TInt irq=-1;

	//

	// TO DO: (mandatory)

	//

	//  Create own DFC queue

	TInt r = Kern::DynamicDfcQCreate(iDfcQ, KDCommTemplDfcThreadPriority, KDCommTemplDfcThread);

	if (r != KErrNone)

		return r; 	

	// Set iPortAddr and irq with the Linear Base address of the UART and the Interrupt ID coresponding to aUnit

	//

	// bind to UART interrupt

	r=Interrupt::Bind(irq,Isr,this);

	if (r==KErrNone)

		iInterruptId=irq;

	//

	// TO DO: (optional)

	//

	// Any other setting up of UART hardware registers, required for:

	//  - Disabling the UART operation

	//  - disabling all UART Interrupts

	//  - clearing all Rx errors

	//  - clearing all UART interrupts

	//  - de-activating output Modem Control signals

	//

	Variant::MarkDebugPortOff();

	return r;

	}

TDfcQue* DCommTemplate::DfcQ(TInt aUnit)

//

// Return the DFC queue to be used for this device

// For UARTs just use the standard low priority DFC queue

// For Serial PC cards, use the PC card controller thread for the socket in question.

//

	{

	return aUnit==iUnit ? iDfcQ : NULL;

	}

TInt DCommTemplate::Start()

//

// Start receiving characters

//

	{

	iTransmitting=EFalse;			// if EnableTransmit() called before Start()

	//

	// TO DO: (mandatory)

	//

	// Set up hardware registers to enable the UART and switch receive mode on

	//

	// if (iUnit!=IR Port)											TO DO: (mandatory): Implement

		{

		iSignals=Signals();

		iLdd->UpdateSignals(iSignals);

		}

	//

	// TO DO: (optional)

	//

	// If Unit is IR Port may need to start the IR port

	//

	Interrupt::Enable(iInterruptId);

	return KErrNone;

	}

TBool FinishedTransmitting(TAny* aPtr)

	{

	//

	// TO DO: (mandatory)

	//

	// Return ETrue if UART is still transmitting, EFalse Otherwise

	//

	return EFalse;		// EXAMPLE ONLY

	}

void DCommTemplate::Stop(TStopMode aMode)

//

// Stop receiving characters

//

	{

	switch (aMode)

		{

		case EStopNormal:

		case EStopPwrDown:

			Interrupt::Disable(iInterruptId);

			iTransmitting=EFalse;

			// wait for uart to stop tranmitting

			Kern::PollingWait(FinishedTransmitting,this,3,100);

			//

			// TO DO: (optional)

			//

			// Any other setting up of UART hardware registers, required for:

			//  - Disabling the UART operation

			//  - disabling all UART Interrupts

			//  - disabling Transmit and Receive pathes

			//  - clearing all UART interrupts

			//

			break;

		case  EStopEmergency:

			Interrupt::Disable(iInterruptId);

			iTransmitting=EFalse;

			break;

		}

	//

	// TO DO: (optional)

	//

	// If Unit is IR Port may need to stop the IR port

	//

	Variant::MarkDebugPortOff();

	}

void DCommTemplate::Break(TBool aState)

//

// Start or stop the uart breaking

//

	{

	if (aState)

		{

		//

		// TO DO: (mandatory)

		//

		// Enable sending a Break (space) condition

		//

		}

	else

		{

		//

		// TO DO: (mandatory)

		//

		// Stop sending a Break (space) condition

		//

		}

	}

void DCommTemplate::EnableTransmit()

//

// Start sending characters.

//

	{

	TBool tx = (TBool)__e32_atomic_swp_ord32(&iTransmitting, 1);

	if (tx)

		return;

		TInt r = 0;

	while (/* (Transmit FIFO Not full) && */ Kern::PowerGood())				// TO DO: (mandatory): Implement

		{

		TInt r=TransmitIsr();

		if(r<0)

			{

			//no more to send

			iTransmitting=EFalse;

			break;

			}

		//

		// TO DO: (mandatory)

		//

		// Write transmit character into transmit FIFO or output register

		//

		}

	TInt irq=0;

	if (!iInInterrupt)					// CheckTxBuffer adds a Dfc: can only run from ISR or with NKernel locked

		{

		NKern::Lock();

		irq=NKern::DisableAllInterrupts();

		}

	CheckTxBuffer();

	if (!iInInterrupt)

		{

		NKern::RestoreInterrupts(irq);

		NKern::Unlock();

		}

	//

	// TO DO: (mandatory)

	//

	// Enable transmission of data

	//

	if (r>=0)											// only enable interrupt if there's more data to send

		{

		//

		// TO DO: (mandatory)

		//

		// Enable transmit interrupt in the Hardware (Interrupt::Enable() has already been called in Start())

		//

		}

	}

TUint DCommTemplate::Signals() const

//

// Read and translate the modem lines

//

	{

	TUint signals=0;

	//

	// TO DO: (mandatory)

	//

	// If the UART corresponding to iUnit supports Modem Control Signals, read them and return a bitmask with one or 

	// more of the following OR-ed in:

	// - KSignalDTR,

	// - KSignalRTS,

	// - KSignalDSR,

	// - KSignalCTS,

	// - KSignalDCD.

	// 

	return signals;

	}

void DCommTemplate::SetSignals(TUint aSetMask, TUint aClearMask)

//

// Set signals.

//

	{

	//

	// TO DO: (mandatory)

	//

	// If the UART corresponding to iUnit supports Modem Control Signals, converts the flags in aSetMask and aClearMask 

	// into hardware-specific bitmasks to write to the UART modem/handshake output register(s). 

	// aSetMask, aClearMask will have one or more of the following OR-ed in: