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

// Implementation of a digitiser (touch-screen) driver.

// This code assumes that an interrupt is generated on pen-down and pen-up events.

//

//

#include <assp.h>

#include <videodriver.h>

#include <drivers/xyin.h>

#include <assp/omap3530_assp/omap3530_gpio.h>

#include <assp/omap3530_assp/omap3530_scm.h>

#include "mconf.h"

#include "../common/controller.h"

// TODO replace DEBUG_PRINT(  with  __KTRACE_OPT(KHARDWARE,

#define DEBUG_PRINT(x) x

const TInt KXyinThreadPriority = 33; // might need to be updated..

_LIT(KXyinThreadName, "DigitizerThread");

//

// TO DO: (mandatory)

//

// Define the following constants that describe the digitiser position & dimensions

// This is only example code... you need to modify it for your hardware

// digitiser origin & size in pixels

const TUint	KConfigXyOffsetX	= 0;		// digitiser origin - same as display area

const TUint	KConfigXyOffsetY	= 0;

const TUint	KConfigXyWidth		= 640;		// 640 pixels per line

const TUint	KConfigXyHeight		= 480;		// 480 lines per panel

// digitiser dimensions in digitiser co-ordinates

const TInt KConfigXyBitsX   = 12;

const TInt KConfigXyBitsY   = 12;

const TInt KConfigXySpreadX = 1 << KConfigXyBitsX;  // maximum valid X spread

const TInt KConfigXySpreadY = 1 << KConfigXyBitsY;  // maximum valid Y spread

const TInt KConfigXyMinX    = 0;                    // minimum valid X value

const TInt KConfigXyMinY    = 0;                    // minimum valid Y value

const TInt KConfigXyMaxX    = KConfigXySpreadX - 1; // maximum valid X value

const TInt KConfigXyMaxY    = KConfigXySpreadY - 1; // maximum valid Y value

// Define a 2x2 matrix and two constants Tx and Ty to convert digitiser co-ordinates

// to pixels such that

//

// (X<<16 Y<<16)	=	(x y)	x	(R11 R12)	+	(Tx Ty)

//									(R21 R22)

// or :

//

// X = (x*R11 + y*R21 + TX) >> 16;

// Y = (x*R12 + y*R22 + TY) >> 16;

//

// where x,y are digitiser coordinates, Tx,Ty are constant offsets and X,Y are screen

// coordinates. Left shifting by 16 bits is used so as not to lose precision.

//

// These are default values to be used before calibration has taken place

// These are best set by observation.

// The example values given below are for a digitiser whose origin is at bottom left

// (the screen origin is at top left)

const TInt		KConfigXyR11		= (KConfigXyWidth << 16) / KConfigXySpreadX;		// 10240

const TInt		KConfigXyR12		= 0;

const TInt		KConfigXyR21		= 0;

const TInt		KConfigXyR22		= - ((KConfigXyHeight << 16) / KConfigXySpreadY);	// -7680

const TInt		KConfigXyTx			= 0;

const TInt		KConfigXyTy			= (KConfigXyHeight << 16) / KConfigXySpreadY;

//

// TO DO: (optional)

//

// Define the following constants that describe the digitiser behaviour

// This is only example code... you need to modify it for your hardware

// After taking a sample, wait for the specified number of nano-kernel ticks (normally 1 ms)

// before taking the next sample

const TInt		KInterSampleTime	= 1;

// After a group of samples has been processed by the DDigitiser::ProcessRawSample() DFC,

// wait for the specified number of nano-kernel ticks before taking the next sample

const TInt		KInterGroupTime		= 1;

// After a pen-down interrupt,

// wait for the specified number of nano-kernel ticks before taking the next sample

const TInt		KPenDownDelayTime	= 2;

// If powering up the device with the pen down,

// wait for the specified number of nano-kernel ticks before taking the next sample

const TInt		KPenUpPollTime		= 30;

// After a pen-up interrupt,

// wait for the specified number of nano-kernel ticks before calling PenUp()

const TInt		KPenUpDebounceTime	= 10;

// number of samples to discard on pen-down

const TInt		KConfigXyPenDownDiscard	= 1;

// number of samples to discard on pen-up

const TInt		KConfigXyPenUpDiscard	= 1;

// offset in pixels to cause movement in X direction

const TInt		KConfigXyAccThresholdX	= 12;

// offset in pixels to cause movement in Y direction

const TInt		KConfigXyAccThresholdY	= 12;

// number of samples to average - MUST be <= KMaxXYSamples

const TInt		KConfigXyNumXYSamples	= 2;

// disregard extremal values in each 4-sample group

const TBool		KConfigXyDisregardMinMax= EFalse;

// obsolete constants :

const TInt		KConfigXyDriveXRise		= 0;

const TInt		KConfigXyDriveYRise		= 0;

const TInt		KConfigXyMaxJumpX		= 0;

const TInt		KConfigXyMaxJumpY		= 0;

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

 * Main Digitiser Class

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

//

// TO DO: (optional)

//

// Add any private functions and data you require

//

NONSHARABLE_CLASS(DTemplateDigitiser) : public DDigitiser

	{

public:

	enum TState

		{

		E_HW_PowerUp,

		E_HW_PenUpDebounce,

		E_HW_CollectSample

		};

public:

	// from DDigitiser - initialisation

	DTemplateDigitiser();

	virtual TInt DoCreate();

	void SetDefaultConfig();

	// from DDigitiser - signals to hardware-dependent code

	virtual void WaitForPenDown();

	virtual void WaitForPenUp();

	virtual void WaitForPenUpDebounce();

	virtual void DigitiserOn();

	virtual void DigitiserOff();

	virtual void FilterPenMove(const TPoint& aPoint);

	virtual void ResetPenMoveFilter();

	// from DDigitiser - machine-configuration related things

	virtual TInt DigitiserToScreen(const TPoint& aDigitiserPoint, TPoint& aScreenPoint);

	virtual void ScreenToDigitiser(TInt& aX, TInt& aY);

	virtual TInt SetXYInputCalibration(const TDigitizerCalibration& aCalibration);

	virtual TInt CalibrationPoints(TDigitizerCalibration& aCalibration);

	virtual TInt SaveXYInputCalibration();

	virtual TInt RestoreXYInputCalibration(TDigitizerCalibrationType aType);

	virtual void DigitiserInfo(TDigitiserInfoV01& aInfo);

	// from DPowerHandler

	virtual void PowerDown(TPowerState);

	virtual void PowerUp();

public:

	// implementation

	void TakeSample();

	void PenInterrupt();

	void DigitiserPowerUp();

	void DoPowerUp();

private:

	static void TimerCallback(TAny* aPtr);

	static void TimerIntCallback(TAny* aPtr);

	static void TakeReadingDfc(TAny* aPtr);

	static void PowerUpDfc(TAny* aPtr);

	static void PowerDownDfc(TAny* aPtr);

	static void PenIsr(TAny* aPtr);

	TouchController iController;

	NTimer iTimer;

	NTimer iTimerInt;

	TDfc iTakeReadingDfc;

	TDfc iPowerDownDfc;

	TDfc iPowerUpDfc;

	TInt iSamplesCount;

	TState iState;

	TUint8 iPoweringDown;

	TSize iScreenSize;

	TActualMachineConfig& iMachineConfig;

	};

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

 * Digitiser main code

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

/**

Creates a new instance of DDigitiser.

Called by extension entry point (PIL) to create a DDigitiser-derived object.

@return	a pointer to a DTemplateDigitiser object

*/

DDigitiser* DDigitiser::New()

	{

	return new DTemplateDigitiser;

	}

DTemplateDigitiser::DTemplateDigitiser() :

		iTimer(TimerCallback,this),

		iTimerInt(TimerIntCallback,this),

		iTakeReadingDfc(TakeReadingDfc,this,5),

		iPowerDownDfc(PowerDownDfc,this,5),

		iPowerUpDfc(PowerUpDfc,this,5),

		iMachineConfig(TheActualMachineConfig())

	{

	}

TInt DTemplateDigitiser::DoCreate()

	{

	__KTRACE_OPT(KEXTENSION,Kern::Printf("DTemplateDigitiser::DoCreate"));

	DEBUG_PRINT(Kern::Printf("DTemplateDigitiser::DoCreate"));

	if (Kern::ColdStart())

		{

		__KTRACE_OPT(KEXTENSION,Kern::Printf("Resetting digitiser calibration"));

		// Emergency digitiser calibration values

		iMachineConfig.iCalibration.iR11 = KConfigXyR11;

		iMachineConfig.iCalibration.iR12 = KConfigXyR12;

		iMachineConfig.iCalibration.iR21 = KConfigXyR21;

		iMachineConfig.iCalibration.iR22 = KConfigXyR22;

		iMachineConfig.iCalibration.iTx = KConfigXyTx;

		iMachineConfig.iCalibration.iTy = KConfigXyTy;

		}

	// create a DFCQ for this driver

	TInt r = Kern::DfcQCreate(iDfcQ, KXyinThreadPriority, &KXyinThreadName);

	if(r != KErrNone)

		{

		__KTRACE_OPT(KIIC, Kern::Printf("Digitizer: DFC Queue creation failed, ch: %d, r = %d\n", r));

		return r;

		}

	iTakeReadingDfc.SetDfcQ(iDfcQ);

	iPowerDownDfc.SetDfcQ(iDfcQ);

	iPowerUpDfc.SetDfcQ(iDfcQ);

#ifdef USE_SYMBIAN_PRM

	// register power handler

	Add();

#endif

	// setup the DAV (data ready/available) pin by binding to the GPIO pin..

	r = GPIO::BindInterrupt(KDataReadyPin, PenIsr, this);

	if(r != KErrNone)

		{

		Kern::Printf("GPIO::BindInterrupt() failed for pin %d, r=%d", KDataReadyPin, r);

		return r;

		}

	r = GPIO::SetPinDirection(KDataReadyPin, GPIO::EInput);

	if(r == KErrNone)

		{

		r = GPIO::SetInterruptTrigger(KDataReadyPin, GPIO::EEdgeRising);

		if(r == KErrNone)

			{

			GPIO::SetDebounceTime(KDataReadyPin, 100);

			SCM::SetPadConfig(CONTROL_PADCONF_MMC2_DAT0, SCM::EMsw, SCM::EMode4 | SCM::EInputEnable); // 133 (mmc2dat1)

			r = GPIO::SetPinMode(KDataReadyPin, GPIO::EEnabled);

			}

		}

	if (r == KErrNone)

		{

		// set up the default configuration

		SetDefaultConfig();

		// some of the pre-configuration of the touch controller could be done here..

		iController.HardReset();

		iController.Configure(TouchController::EModeSingle);

		DigitiserPowerUp();

		}

	return r;

	}

/**

Initialise the DDigitiser::iCfg structure

*/

void DTemplateDigitiser::SetDefaultConfig()

	{

	iCfg.iPenDownDiscard = KConfigXyPenDownDiscard;		// number of samples to discard on pen-down

	iCfg.iPenUpDiscard = KConfigXyPenUpDiscard;			// number of samples to discard on pen-up

	iCfg.iDriveXRise = KConfigXyDriveXRise;				// number of milliseconds to wait when driving horizontal edges

	iCfg.iDriveYRise = KConfigXyDriveYRise;				// number of milliseconds to wait when driving vertical edges

	iCfg.iMinX = KConfigXyMinX;							// minimum valid X value

	iCfg.iMaxX = KConfigXyMaxX;							// maximum valid X value

	iCfg.iSpreadX = KConfigXySpreadX;					// maximum valid X spread

	iCfg.iMinY = KConfigXyMinY;							// minimum valid Y value

	iCfg.iMaxY = KConfigXyMaxY;							// maximum valid Y value

	iCfg.iSpreadY = KConfigXySpreadY;					// maximum valid Y spread

	iCfg.iMaxJumpX = KConfigXyMaxJumpX;					// maximum X movement per sample (pixels)

	iCfg.iMaxJumpY = KConfigXyMaxJumpY;					// maximum Y movement per sample (pixels)

	iCfg.iAccThresholdX = KConfigXyAccThresholdX;		// offset in pixels to cause movement in X direction

	iCfg.iAccThresholdY = KConfigXyAccThresholdY;		// offset in pixels to cause movement in Y direction

	iCfg.iNumXYSamples = KConfigXyNumXYSamples;			// number of samples to average

	iCfg.iDisregardMinMax = KConfigXyDisregardMinMax;	// disregard extremal values in each 4-sample group

	}

/**

Takes a sample from the digitiser.

Called in the context of a DFC thread.

*/

void DTemplateDigitiser::TakeSample()

	{

#ifdef USE_SYMBIAN_PRM

	TTemplatePowerController::WakeupEvent();	// notify of pendown (wakeup event) and let the power controller sort

							 					// out if it needs propagation

#endif

	// TO DO: (mandatory)

	// Read from appropriate hardware register to determine whether digitiser panel is being touched

	// Set penDown to ETrue if touched or EFalse if not touched.

	//

	TPoint points[4];

	TInt num_points = 0;

	TInt r = iController.GetMeasurements(points, num_points);

	Kern::Printf("Num touches: %d", num_points);

	Kern::Printf("Measurments: (r: %d)", r);

	for(TInt i = 0; i < num_points; i++)

		{

		Kern::Printf("%d: iX: %d, iY: %d",i, points[i].iX, points[i].iY);

		}

	TInt penDown = num_points;

	//	DEBUG_PRINT(Kern::Printf("TS: S%d PD%d Sp%d", (TInt)iState, penDown?1:0, iSamplesCount));

	if (iState==E_HW_PowerUp)

		{

		// waiting for pen to go up after switch on due to pen down or through the HAL

		// coverity[dead_error_condition]

		// The next line should be reachable when this template file is edited for use

		if (!penDown)							// pen has gone up -> transition to new state

			{

			iState=E_HW_CollectSample;

			iSamplesCount=0;						// reset sample buffer

			// TO DO: (mandatory)

			// Write to the appropriate hardware register to clear the digitiser interrupt

			//

			// TO DO: (mandatory)

			// Write to the appropriate hardware register(s) to allow the hardware

			// to detect when the digitizer panel is touched

			//

//			Interrupt::Enable(KIntIdDigitiser);		// enable pen-down interrupt

 			// TO DO: (mandatory)

			// Write to the appropriate hardware register to enable the digitiser interrupt

			//

			}

		else									// pen is still down, wait a bit longer in this state

			{

			iTimer.OneShot(KPenUpPollTime);

			}

		return;

		}

	if (!penDown)

		{

		if (iState==E_HW_PenUpDebounce)

			{

			iState=E_HW_CollectSample;	// back to initial state, no samples collected

			iSamplesCount=0;			// reset sample buffer

			// Need to lock the kernel to simulate ISR context and thus defer preemption,

			// since PenUp() expects an ISR context and calls TDfc::Add().

			NKern::Lock();

			PenUp();					// adds DFC

			NKern::Unlock();

			}

		else							// iState=E_HW_CollectSample

			{

			iState=E_HW_PenUpDebounce;

			iTimer.OneShot(KPenUpDebounceTime);		// wait a bit to make sure pen still up

			}

		return;

		}

	else if (iState==E_HW_PenUpDebounce)	// pen down

		{

		// false alarm - pen is down again

		iState=E_HW_CollectSample;		// take a new set of samples

		iSamplesCount=0;				// reset sample buffer

		}

	// default: pen down and iState=E_HW_CollectSample

	// TO DO: (mandatory)

	// Read from appropriate hardware register to get the current digitiser coordinates

	// of the point that is being touched. Set aResults accordingly.

	// This is only example code... you need to modify it for your hardware

	//

	TPoint aResults;

	// X axis

	iX[iSamplesCount] = aResults.iX;

	// Y axis

	iY[iSamplesCount] = aResults.iY;

	DEBUG_PRINT(Kern::Printf("Raw: X=%d Y=%d",iX[iSamplesCount],iY[iSamplesCount]));

	// Put the hardware back into pen-detect mode

	// TO DO: (mandatory)

	// Write to the appropriate hardware register(s) to allow the hardware

	// to detect when the digitizer panel is touched

	//

	// count samples collected - if it's less than minimum,

	// schedule the reading of another sample

	if (++iSamplesCount < iCfg.iNumXYSamples)	// iX[] and iY[] are 4 levels deep in xyin.h...

		{

		if(KInterSampleTime > 0)				// need to check this config param as it might be zero!

			iTimer.OneShot(KInterSampleTime);	// haven't got a complete group yet, so queue timer to sample again

		else

			iTakeReadingDfc.Enque();

		return;

		}

	// Have a complete group of samples so pass up to processing layer (PIL)

	// Need to lock the kernel to simulate ISR context and thus defer preemption,

	// since RawSampleValid() expects an ISR context and calls TDfc::Add().

	NKern::Lock();

	RawSampleValid();		// adds DFC

	NKern::Unlock();

	}

/**

Request for an interrupt to be generated when the pen is next down

Called by PIL at startup or when pen leaves digitiser after pen-up event issued

*/

void DTemplateDigitiser::WaitForPenDown()

	{

	// Called at startup or when pen leaves digitiser after pen-up event issued

	DEBUG_PRINT(Kern::Printf("WD: PowerDownMask %x",iPoweringDown));

	if (iPoweringDown)

		{

		// powering down

		// TO DO: (mandatory)

		// Write to the appropriate hardware register(s) to allow the hardware

		// to detect when the digitizer panel is touched and wakes up the system if in standby

		//

		//

		// TO DO: (optional)

		//

		// Relinquish request on power resources

		// This will place the peripheral hardware in a low power "Sleep" mode which is Interrupt detection capable

		// EXAMPLE ONLY

#ifdef USE_SYMBIAN_PRM

		TemplateResourceManager* aManager = TTemplatePowerController::ResourceManager();

		aManager -> ModifyToLevel(TemplateResourceManager::AsynchMlResourceUsedByXOnly, 50 /* a percentage */);

		aManager -> SharedBResource1() -> Release();

#endif

		iPoweringDown = EFalse;

		PowerDownDone();

		}

	else

		{

		// TO DO: (mandatory)

		// Write to the appropriate hardware register to clear the digitiser interrupt

		//

		// TO DO: (mandatory)

		// Write to the appropriate hardware register(s) to allow the hardware

		// to detect when the digitizer panel is touched

		//

		if ((iTimer.iState == NTimer::EIdle) && (iTimerInt.iState == NTimer::EIdle))

			{

			GPIO::EnableInterrupt(KDataReadyPin); // enable pen-down interrupt

			}

		}

	}

/**

Called by PIL after it has processed a group of raw samples while pen is down.

Used to indicate that the iX, iY buffers may be re-used

*/

void DTemplateDigitiser::WaitForPenUp()

	{

	DEBUG_PRINT(Kern::Printf("WU"));

	iState = E_HW_CollectSample;

	iSamplesCount = 0;					// reset sample buffer

	if(KInterGroupTime > 0)				// need to check this config param as it might be zero!

		{

		iTimer.OneShot(KInterGroupTime);

		}

	else

		{

		iTakeReadingDfc.Enque();

		}

	}