/*

* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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: 

* ne1_tb\Specific\xyin.cpp

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

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

* This file is part of the NE1_TBVariant Base port

* We use this driver to exemplify the usage of Resource Management for shared resources, Peripheral "Sleep"

* and detection and notification of Wakeup events

*

*/

#include <assp.h>

#include <naviengine.h>

#include <videodriver.h>

#include "mconf.h"

#include <xyin.h>

#include "lcdgce.h"

#ifdef USE_PEN_INTERRUPTS

#include <gpio.h>

const TUint KLcdInterruptPin = 22;

#else

const TUint KPenEventsPollTime = 30;

#endif

// digitiser origin & size in pixels

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

const TUint	KConfigXyOffsetY	= 0;

// digitiser dimensions in digitiser co-ordinates

const TInt      KConfigXySpreadX = 3600; // maximum valid X spread

const TInt      KConfigXySpreadY = 3600; // maximum valid Y spread

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

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

const TUint		KXYShift         = 4100;

const TInt KDigitiserThreadPriority = 26;

_LIT(KDigitiserDriverThreadName,"DigitizerThread");

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

// 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	= 4;

// disregard extremal values in each 4-sample group

const TBool		KConfigXyDisregardMinMax= ETrue;  //EFalse;

// Registers..

const TUint KHwPenInterruptRegister = KHwFPGABase + 0x0408; // LCD penInterrupt register

const TUint KHwTSPStart             = KHwFPGABase + 0x0608; // TSP Control Register..

const TUint KHwTSPXData             = KHwFPGABase + 0x0610; // TSP X Data Register..

const TUint KHwTSPYData             = KHwFPGABase + 0x0618; // TSP Y Data Register..

// obsolete constants :

const TInt KConfigXyDriveXRise = 0;

const TInt KConfigXyDriveYRise = 0;

const TInt KConfigXyMaxJumpX   = 0;

const TInt KConfigXyMaxJumpY   = 0;

struct SConfig

	{

	TUint iConfigXyWidth;

	TUint iConfigXyHeight;

	TBool iLandscape;

	// Calibration Values

	TInt iConfigXyR11;

	TInt iConfigXyR12;

	TInt iConfigXyR21;

	TInt iConfigXyR22;

	TInt iConfigXyTx;

	TInt iConfigXyTy;

	};

enum TTouchScreenMode

	{

	TOUCHSCREEN_MODE_NEC_WVGA     = 0,

	TOUCHSCREEN_MODE_HITACHI_VGA,

	TOUCHSCREEN_MODE_HITACHI_QVGA,

	TOUCHSCREEN_MODE_NONE = 255,

	};

static const SConfig Mode_Config[]=

	{

	// NEC WVGA - default mode

		{

		800,

		480,

		ETrue,

		// Calibration values; these are set manually using the TechView calibration app

		17722,      // R11

		1239,       // R12

		399,        // R21

		12352,      // R22

		-11623449,  // Tx

		-10468471,  // Ty

		},

	// LCD, Portrait VGA

		{

		480,

		640,

		EFalse,

		// Calibration values; these are set manually using the TechView calibration app

		11346,      // R11

		538,        // R12

		-682,       // R21

		14703,      // R22

		-5683258,   // Tx

		-9913475,   // Ty

		},

	// LCD, Portrait QVGA

		{

		240,

		320,

		EFalse,

		// Calibration values; these are set manually using the TechView calibration app

		5873,		//iConfigXyR11;

		651,		//iConfigXyR12;

		-250,		//iConfigXyR21;

		7366,		//iConfigXyR22;

		-3591097,	//iConfigXyTx;

		-5181791,	//iConfigXyTy;

		},

	};

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

 * Main Digitiser Class

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

NONSHARABLE_CLASS(DNE1_TBDigitiser) : public DDigitiser

	{

public:

	enum TState

		{

		E_HW_PowerUp,

		E_HW_PenUpDebounce,

		E_HW_CollectSample

		};

public:

	// from DDigitiser - initialisation

	DNE1_TBDigitiser();

	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();

	// implementation

	void TakeSample();

	void PenInterrupt();

	void DigitiserPowerUp();

	void PowerUpDfc();

	// callbacks

	static void TimerExpired(TAny* aPtr);

	static void TimerIntExpired(TAny* aPtr);

	static void PenIsr(TAny* aPtr);

	static void TakeReading(TAny* aPtr);

	static void PowerDown(TAny* aPtr);

	static void PowerUp(TAny* aPtr);

private:

	NTimer iTimer;

	NTimer iTimerInt;

	TDfc   iTakeReadingDfc;

	TDfc   iPowerDownDfc;

	TDfc   iPowerUpDfc;

	TInt   iSamplesCount;

	TState iState;

	TUint8 iPoweringDown;

	TSize  iScreenSize;

#ifndef USE_PEN_INTERRUPTS

	NTimer iPollingTimer;

#endif

	TActualMachineConfig& iMachineConfig;

	TTouchScreenMode      iCurrentMode;

	TInt                  iInterruptId;

	};

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

 * Digitiser main code

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

/**

Sample timer callback

Schedules a DFC to take a sample

@param aPtr	a pointer to DNE1_TBDigitiser

*/

void DNE1_TBDigitiser::TimerExpired(TAny* aPtr)

	{

	DNE1_TBDigitiser* pD=(DNE1_TBDigitiser*)aPtr;

	__KTRACE_OPT(KHARDWARE, Kern::Printf("TimerExpired"));

	pD->iTakeReadingDfc.Add();

	}

/**

Debounce timer callback

schedules a DFC to process a pen-down interrupt

@param aPtr	a pointer to DNE1_TBDigitiser

*/

void DNE1_TBDigitiser::TimerIntExpired(TAny* aPtr)

	{

	DNE1_TBDigitiser* pD=(DNE1_TBDigitiser*)aPtr;

	__KTRACE_OPT(KHARDWARE, Kern::Printf("TIntExpired"));

	pD->iTakeReadingDfc.Add();

	}

/**

Pen-up/down interrupt handler

@param aPtr	a pointer to DNE1_TBDigitiser

*/

void DNE1_TBDigitiser::PenIsr(TAny* aPtr)

	{

	DNE1_TBDigitiser* pD=(DNE1_TBDigitiser*)aPtr;

	//check the status of the interrupt:

	TUint16 status = AsspRegister::Read16(KHwPenInterruptRegister);

	if (!(status & 0x100)) // Pen is down..

		{

#ifdef USE_PEN_INTERRUPTS

		GPIO::DisableInterrupt(pD->iInterruptId);

#endif

		pD->PenInterrupt();

		}

#ifndef USE_PEN_INTERRUPTS

		// kick-off the timer again..

		pD->iPollingTimer.Again(KPenEventsPollTime);

#endif

	}

/**

DFC for taking a sample

@param aPtr	a pointer to DNE1_TBDigitiser

*/

void DNE1_TBDigitiser::TakeReading(TAny* aPtr)

	{

	DNE1_TBDigitiser* pD=(DNE1_TBDigitiser*)aPtr;

	pD->TakeSample();

	}

/**

DFC for powering down the device

@param aPtr	a pointer to DNE1_TBDigitiser

*/

void DNE1_TBDigitiser::PowerDown(TAny* aPtr)

	{

	DNE1_TBDigitiser* pD=(DNE1_TBDigitiser*)aPtr;

	pD->DigitiserOff();

	}

/**

DFC for powering up the device

@param aPtr	a pointer to DNE1_TBDigitiser

*/

void DNE1_TBDigitiser::PowerUp(TAny* aPtr)

	{

	DNE1_TBDigitiser* pD=(DNE1_TBDigitiser*)aPtr;

	pD->PowerUpDfc();

	}

/**

Creates a new instance of DDigitiser.

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

@return	a pointer to a DNE1_TBDigitiser object

*/

DDigitiser* DDigitiser::New()

	{

	return new DNE1_TBDigitiser;

	}

/**

Default constructor

*/

DNE1_TBDigitiser::DNE1_TBDigitiser() :

		iTimer(TimerExpired,this),

		iTimerInt(TimerIntExpired,this),

		iTakeReadingDfc(TakeReading,this,5),

		iPowerDownDfc(PowerDown,this,5),

		iPowerUpDfc(PowerUp,this,5),

#ifndef USE_PEN_INTERRUPTS

		iPollingTimer(PenIsr, this),

#endif

		iMachineConfig(TheActualMachineConfig())

	{

	}

/**

Perform hardware-dependent initialisation

Called by platform independent layer

*/

TInt DNE1_TBDigitiser::DoCreate()

	{

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

	if (Kern::ColdStart())

		{

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

		// Emergency digitiser calibration values

		TInt mode = ReadDipSwitchDisplayMode();

		switch (mode)

			{

			case DISPLAY_MODE_HITACHI_VGA: // Hitachi display in VGA

				iCurrentMode = TOUCHSCREEN_MODE_HITACHI_VGA;

				break;

			case DISPLAY_MODE_HITACHI_QVGA: // Hitachi display in QVGA

				iCurrentMode = TOUCHSCREEN_MODE_HITACHI_QVGA;

				break;

			case DISPLAY_MODE_NEC_WVGA:	// NEC display in WVGA

				iCurrentMode = TOUCHSCREEN_MODE_NEC_WVGA;

				break;

			// In all ANALOG modes - don't use the digitiser

			case DISPLAY_MODE_ANALOG_VGA:

			case DISPLAY_MODE_ANALOG_QVGA_LANDSCAPE_OLD:

			case DISPLAY_MODE_ANALOG_QVGA_PORTRAIT:

			case DISPLAY_MODE_ANALOG_QVGA_LANDSCAPE:

				iCurrentMode = TOUCHSCREEN_MODE_NONE;

				break;

			default:    // In all other modes, use the NEC WVGA settings

				iCurrentMode = TOUCHSCREEN_MODE_NEC_WVGA;

				break;

			}

		iMachineConfig.iCalibration.iR11 = Mode_Config[iCurrentMode].iConfigXyR11;

		iMachineConfig.iCalibration.iR12 = Mode_Config[iCurrentMode].iConfigXyR12;

		iMachineConfig.iCalibration.iR21 = Mode_Config[iCurrentMode].iConfigXyR21;

		iMachineConfig.iCalibration.iR22 = Mode_Config[iCurrentMode].iConfigXyR22;

		iMachineConfig.iCalibration.iTx  = Mode_Config[iCurrentMode].iConfigXyTx;

		iMachineConfig.iCalibration.iTy  = Mode_Config[iCurrentMode].iConfigXyTy;

		}

	TDynamicDfcQue* dfcq;

	// Create a dedicated DFC queue for this driver

	TInt r = Kern::DynamicDfcQCreate(dfcq, KDigitiserThreadPriority, KDigitiserDriverThreadName);

	if (r != KErrNone)

		{

		__KTRACE_OPT(KEXTENSION,Kern::Printf("Could not create a DFCQue, r %d", r));

		return r;

		}

#ifdef CPU_AFFINITY_ANY

	NKern::ThreadSetCpuAffinity((NThread*)(iDfcQ->iThread), KCpuAffinityAny);

#endif

	// and DFCs to use it..

	iDfcQ = dfcq;

	iTakeReadingDfc.SetDfcQ(iDfcQ);

	iPowerDownDfc.SetDfcQ(iDfcQ);

	iPowerUpDfc.SetDfcQ(iDfcQ);

	// stop at this point, if the LCD panel is not present

	if (iCurrentMode == TOUCHSCREEN_MODE_NONE)

		{

		__KTRACE_OPT(KEXTENSION,Kern::Printf("xyin.cpp: LCD panel not switched on...\nwill not start the driver"));

		return KErrNone;

		}

	// register power handler

	Add();

	DigitiserPowerUp();

#ifdef USE_PEN_INTERRUPTS

   // set up interrupts

	iInterruptId = KLcdInterruptPin;

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

	if (r != KErrNone)

		{

		__KTRACE_OPT(KEXTENSION,Kern::Printf("Error binding the interrupt: r %d", r));

		return r;

		}

#endif

	// set up the default configuration

	SetDefaultConfig();

	return KErrNone;

	}

/**

Initialise the DDigitiser::iCfg structure

*/

void DNE1_TBDigitiser::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            = KConfigXySpreadX - 1;     // maximum valid X value

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

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

	iCfg.iMaxY            = KConfigXySpreadY - 1;     // 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 DNE1_TBDigitiser::TakeSample()

	{

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

												// out if it needs propagation

	TBool penDown = EFalse;

    //check the touch panel interrupt state

    TUint16 status = AsspRegister::Read16(KHwPenInterruptRegister);

    if(!(status & 0x100))  //Panel touched

        penDown = ETrue;

	__KTRACE_OPT(KHARDWARE,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

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

			{

			iState=E_HW_CollectSample;

			iSamplesCount=0;     // reset sample buffer

#ifdef USE_PEN_INTERRUPTS

			// clear and enable pen-down interrupt

			GPIO::EnableInterrupt(iInterruptId);

#endif