// Copyright (c) 1995-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\keyboard.cpp

 // Access to Template interruptible keyboard

 // The code here implements a simple interrupt-driven keyboard driver.

 // This is an alternative to the polled driver in keyboard.cpp.

 // This example assumes that we have an intelligent keyboard controller

 // which:

 // scans the keyboard automatically

 // generates an interrupt when a key is pressed or released

 // You can use this code as a starting point and modify it to suit

 // your hardware.

 // 

 //

 #include <template_assp.h>

 #include "iolines.h"

 #include "platform.h"

 #include <kernel/kpower.h>

 #include <e32keys.h>

 //

 //

 // TO DO: (optional)

 //

 // Modify this conversion table to suit your keyboard layout

 //

 // This example assumes that the following keyboard layout:

 //

 // <----Row0-----><-----Row1-------><---Row2-----><-----Row3-------><-------Row4-----------><------Row5------><-----Row6-------><---Row7--->

 //		LAlt																																Column0

 //		'				\				TAB				Z					A						X										Column1

 //						LShift																												Column2

 //		LCtrl																																Column3

 //		Fn																																	Column4

 //		Esc				Del				Q				CapLk				S						C				3						Column5

 //		1								W									D						V				4						Column6

 //		2				T				E									F						B				5						Column7

 //		9				Y				R				K					G						N				6						Column8

 //		0				U				O				L					H						M				7						Column9

 //		-				I				P				;					J						,				8						Column10

 //		=				Enter			[				'					/						.				Prog					Column11

 //						RShift																												Column12

 //		BkSp			DnArrow			]				UpArrow				LeftArrow				Space			RightArrow				Column13

 //																																			Column14

 //																																			Column15

 // EXAMPLE ONLY

 const TUint8 convertCode[] =

 	{

 	EStdKeyNull ,   EStdKeyLeftAlt  ,  EStdKeyNull   ,   EStdKeyNull    ,      EStdKeyNull      ,   EStdKeyNull     ,    EStdKeyNull    ,EStdKeyNull,       // Column0

 	EStdKeyNull ,   EStdKeyHash     ,EStdKeyBackSlash,   EStdKeyTab     ,          'Z'          ,       'A'         ,       'X'         ,EStdKeyNull,       // Column1

 	EStdKeyNull ,    EStdKeyNull    ,EStdKeyLeftShift,   EStdKeyNull    ,      EStdKeyNull      ,   EStdKeyNull     ,    EStdKeyNull    ,EStdKeyNull,       // Column2

 	EStdKeyNull ,  EStdKeyLeftCtrl  ,  EStdKeyNull   ,   EStdKeyNull    ,      EStdKeyNull      ,   EStdKeyNull     ,    EStdKeyNull    ,EStdKeyNull,       // Column3

 	EStdKeyNull ,  EStdKeyLeftFunc  ,  EStdKeyNull   ,   EStdKeyNull    ,      EStdKeyNull      ,   EStdKeyNull     ,    EStdKeyNull    ,EStdKeyNull,       // Column4

 	EStdKeyNull ,   EStdKeyEscape   , EStdKeyDelete  ,      'Q'         ,      EStdKeyCapsLock  ,       'S'         ,        'C'        ,   '3'     ,       // Column5

 	EStdKeyNull ,       '1'         ,  EStdKeyNull   ,      'W'         ,      EStdKeyNull      ,       'D'         ,        'V'        ,   '4'     ,       // Column6

 	EStdKeyNull ,       '2'         ,     'T'        ,      'E'         ,      EStdKeyNull      ,       'F'         ,        'B'        ,   '5'     ,       // Column7

 	EStdKeyNull ,       '9'         ,     'Y'        ,      'R'         ,          'K'          ,       'G'         ,        'N'        ,   '6'     ,       // Column8

 	EStdKeyNull ,       '0'         ,     'U'        ,      'O'         ,          'L'          ,       'H'         ,        'M'        ,   '7'     ,       // Column9

 	EStdKeyNull ,    EStdKeyMinus   ,     'I'        ,      'P'         ,    EStdKeySemiColon   ,       'J'         ,    EStdKeyComma   ,   '8'     ,       // Column10

 	EStdKeyNull ,    EStdKeyEquals  ,  EStdKeyEnter  ,EStdKeySquareBracketLeft,EStdKeySingleQuote,EStdKeyForwardSlash, EStdKeyFullStop  ,EStdKeyMenu,       // Column11

 	EStdKeyNull ,    EStdKeyNull    ,EStdKeyRightShift,   EStdKeyNull   ,      EStdKeyNull      ,   EStdKeyNull     ,    EStdKeyNull    ,EStdKeyNull,       // Column12

 	EStdKeyNull ,  EStdKeyBackspace ,EStdKeyDownArrow,EStdKeySquareBracketRight,EStdKeyUpArrow  , EStdKeyLeftArrow  ,    EStdKeySpace   ,EStdKeyRightArrow, // Column13

 	EStdKeyNull ,    EStdKeyNull    ,  EStdKeyNull   ,   EStdKeyNull    ,      EStdKeyNull      ,   EStdKeyNull     ,    EStdKeyNull    ,EStdKeyNull,       // Column14

 	EStdKeyNull ,    EStdKeyNull    ,  EStdKeyNull   ,   EStdKeyNull    ,      EStdKeyNull      ,   EStdKeyNull     ,    EStdKeyNull    ,EStdKeyNull        // Column15

 	};

 // EXAMPLE ONLY

 const TInt KFlagKeyPressed = 0x80;		// As an example, we'll assume the top bit indicates pressed/released

 // EXAMPLE ONLY

 const TKeyboard	KConfigKeyboardType = EKeyboard_Full;

 const TInt KConfigKeyboardDeviceKeys = 0;

 const TInt KConfigKeyboardAppsKeys = 0;

 //

 //

 _LIT(KLitKeyboard,"Keyboard");

 class DKeyboardTemplate : public DPowerHandler

 	{

 public:

 	DKeyboardTemplate();

 	TInt Create();

 public: // from DPowerHandler

 	void PowerUp();

 	void PowerDown(TPowerState);

 	TInt HalFunction(TInt aFunction, TAny* a1, TAny* a2);

 	void KeyboardInfo(TKeyboardInfoV01& aInfo);

 	void KeyboardOn();

 	void KeyboardOff();

 	void HandleMsg(TMessageBase* aMsg);

 private:

 	static void Isr(TAny* aPtr);

 	static void EventDfcFn(TAny* aPtr);

 	void EventDfc();

 	void PowerUpDfc();

 	static void PowerUpDfcFn(TAny* aPtr);

 	void PowerDownDfc();

 	static void PowerDownDfcFn(TAny* aPtr);

 private:

 	void KeyboardPowerUp();

 	TUint GetKeyCode();

 	TBool IsKeyReady();

 public:

 	TDfcQue* iDfcQ;

 	TMessageQue iMsgQ;	

 	TDfc iPowerUpDfc;

 	TDfc iPowerDownDfc;	

 private:

 	TDfc iEventDfc;

 	TBool iKeyboardOn;

 	};

 LOCAL_C TInt halFunction(TAny* aPtr, TInt aFunction, TAny* a1, TAny* a2)

 	{

 	DKeyboardTemplate* pH=(DKeyboardTemplate*)aPtr;

 	return pH->HalFunction(aFunction,a1,a2);

 	}

 void rxMsg(TAny* aPtr)

 	{

 	DKeyboardTemplate& h=*(DKeyboardTemplate*)aPtr;

 	TMessageBase* pM=h.iMsgQ.iMessage;

 	if (pM)

 		h.HandleMsg(pM);

 	}

 //

 //	Keyboard class

 //

 DKeyboardTemplate::DKeyboardTemplate()

 	:	DPowerHandler(KLitKeyboard), 

 		iMsgQ(rxMsg,this,NULL,1),

 		iPowerUpDfc(PowerUpDfcFn,this,6),

 		iPowerDownDfc(PowerDownDfcFn,this,7),

 		iEventDfc(EventDfcFn,this,1)

 	{

 	}

 TInt DKeyboardTemplate::Create()

 //

 // Initialisation. Bind and enable the interrupt.

 //

 	{

 	iDfcQ=Kern::DfcQue0();

 	iKeyboardOn = EFalse;	

 		// install the HAL function

 	TInt r=Kern::AddHalEntry(EHalGroupKeyboard,halFunction,this);

 	if (r!=KErrNone)

 		return r;

 	iEventDfc.SetDfcQ(iDfcQ);

 	iPowerUpDfc.SetDfcQ(iDfcQ);

 	iPowerDownDfc.SetDfcQ(iDfcQ);

 	iMsgQ.SetDfcQ(iDfcQ);

 	iMsgQ.Receive();

 	// Bind the key event interrupt

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

 	if (r==KErrNone)

 		{

 		// install the power handler

 		Add();

 		KeyboardPowerUp();

 		}

 	return r;

 	}

 void DKeyboardTemplate::Isr(TAny* aPtr)

 	{

 	DKeyboardTemplate& k=*(DKeyboardTemplate*)aPtr;

 	Interrupt::Disable(KIntIdKeyboard);

 	k.iEventDfc.Add();

 	}

 void DKeyboardTemplate::EventDfcFn(TAny* aPtr)

 	{

 	((DKeyboardTemplate*)aPtr)->EventDfc();

 	}

 void DKeyboardTemplate::EventDfc()

 	{

 	__KTRACE_OPT(KHARDWARE,Kern::Printf("DKeyboardTemplate::EventDfc"));

 	TInt irq=NKern::DisableAllInterrupts();

 	while (IsKeyReady())						// while there are keys in the controller's output buffer

 		{

 		NKern::RestoreInterrupts(irq);

 		TRawEvent e;

 		TUint keyCode=GetKeyCode();				// Read keycodes from controller

 		__KTRACE_OPT(KHARDWARE,Kern::Printf("#%02x",keyCode));

 		//

 		// TO DO: (mandatory)

 		//

 		// Convert from hardware scancode to EPOC scancode and send the scancode as an event (key pressed or released)

 		// as per below EXAMPLE ONLY:

 		//

 		TUint bareCode=keyCode&~KFlagKeyPressed;

 		TUint8 stdKey=convertCode[bareCode];

 		if (keyCode&KFlagKeyPressed)

 			e.Set(TRawEvent::EKeyUp,stdKey,0);

 		else

 			e.Set(TRawEvent::EKeyDown,stdKey,0);

 		Kern::AddEvent(e);

 		NKern::Sleep(1);						// pause before reading more keycodes

 		irq=NKern::DisableAllInterrupts();

 		}

 	Interrupt::Enable(KIntIdKeyboard);

 	NKern::RestoreInterrupts(irq);

 	}

 TBool DKeyboardTemplate::IsKeyReady()

 	{

 	//

 	// TO DO: (mandatory)

 	//

 	// Return ETrue if the keyboard controller has a key event waiting to be read

 	//

 	return EFalse;	// EXAMPLE ONLY

 	}

 TUint DKeyboardTemplate::GetKeyCode()

 	{

 	//

 	// TO DO: (mandatory)

 	//

 	// Read and return the next available keycode from the keyboard controller

 	//

 	return 0;	// EXAMPLE ONLY

 	}

 void DKeyboardTemplate::PowerUpDfcFn(TAny* aPtr)

 	{

 	((DKeyboardTemplate*)aPtr)->PowerUpDfc();

 	}

 void DKeyboardTemplate::PowerDownDfcFn(TAny* aPtr)

 	{

 	((DKeyboardTemplate*)aPtr)->PowerDownDfc();

 	}

 void DKeyboardTemplate::KeyboardPowerUp()

 	{

 	__KTRACE_OPT(KPOWER,Kern::Printf("DKeyboardTemplate::KeyboardPowerUp()"));

 	iKeyboardOn = ETrue;

 	// Send key up events for EStdKeyOff (Fn+Esc) event 

 	TRawEvent e;

 	e.Set(TRawEvent::EKeyUp,EStdKeyEscape,0);

 	Kern::AddEvent(e);

 	e.Set(TRawEvent::EKeyUp,EStdKeyLeftFunc,0);

 	Kern::AddEvent(e);

 	}

 void DKeyboardTemplate::PowerUp()

 	{

 	iPowerUpDfc.Enque();	// schedules DFC to execute on this driver's thread

 	}

 void DKeyboardTemplate::PowerUpDfc()

 	{

 	__KTRACE_OPT(KPOWER, Kern::Printf("DKeyboardTemplate::PowerUpDfc()"));

 	KeyboardOn();

 	PowerUpDone();		// must be called from a different thread than PowerUp()

 	}

 void DKeyboardTemplate::KeyboardOn()

 	{

 	__KTRACE_OPT(KPOWER,Kern::Printf("DKeyboardTemplate::KeyboardOn() iKeyboardOn=%d", iKeyboardOn));

 	if (!iKeyboardOn)	// may be powered up from Power Manager or HAL

 		{

 		KeyboardPowerUp();

 		}

 	}

 void DKeyboardTemplate::PowerDown(TPowerState)

 	{

 	iPowerDownDfc.Enque();	// schedules DFC to execute on this driver's thread

 	}

 void DKeyboardTemplate::PowerDownDfc()

 	{

 	__KTRACE_OPT(KPOWER, Kern::Printf("DKeyboardTemplate::PowerDownDfc()"));

 	KeyboardOff();

 	PowerDownDone();		// must be called from a different thread than PowerDown()

 	}

 void DKeyboardTemplate::KeyboardOff()

 	{

 	__KTRACE_OPT(KPOWER,Kern::Printf("DKeyboardTemplate::KeyboardOff() iKeyboardOn=%d", iKeyboardOn));

 	if (iKeyboardOn)	// may have already been powered down by the HAL

 		{

 		iKeyboardOn = EFalse;

 		Interrupt::Disable(KIntIdKeyboard);

 		}

 	iEventDfc.Cancel();

 	}

 void DKeyboardTemplate::HandleMsg(TMessageBase* aMsg)

 	{

 	if (aMsg->iValue)

 		KeyboardOn();

 	else

 		KeyboardOff();

 	aMsg->Complete(KErrNone,ETrue);

 	}

 void DKeyboardTemplate::KeyboardInfo(TKeyboardInfoV01& aInfo)

 	{

 	__KTRACE_OPT(KEXTENSION,Kern::Printf("DKeyboardTemplate::KeyboardInfo"));

 	aInfo.iKeyboardType=KConfigKeyboardType;

 	aInfo.iDeviceKeys=KConfigKeyboardDeviceKeys;

 	aInfo.iAppsKeys=KConfigKeyboardAppsKeys;

 	}

 TInt DKeyboardTemplate::HalFunction(TInt aFunction, TAny* a1, TAny* a2)

 	{

 	TInt r=KErrNone;

 	__KTRACE_OPT(KEXTENSION,Kern::Printf("DKeyboardTemplate::HalFunction %d", aFunction));

 	switch(aFunction)

 		{

 		case EKeyboardHalKeyboardInfo:

 			{

 			TPckgBuf<TKeyboardInfoV01> kPckg;

 			KeyboardInfo(kPckg());

 			Kern::InfoCopy(*(TDes8*)a1,kPckg);

 			break;

 			}

 		case EKeyboardHalSetKeyboardState:

 			{

 			if(!Kern::CurrentThreadHasCapability(ECapabilityPowerMgmt,__PLATSEC_DIAGNOSTIC_STRING("Checked by Hal function EKeyboardHalSetKeyboardState")))

 				return KErrPermissionDenied;

 			if ((TBool)a1)

 				{

 				TThreadMessage& m=Kern::Message();

 				m.iValue = ETrue;

 				m.SendReceive(&iMsgQ);		// send a message and block Client thread until keyboard has been powered up

 				}

 			else

 				{

 				TThreadMessage& m=Kern::Message();

 				m.iValue = EFalse;

 				m.SendReceive(&iMsgQ);		// send a message and block Client thread until keyboard has been powered down

 				}

 			}

 			break;

 		case EKeyboardHalKeyboardState:

 			kumemput32(a1, &iKeyboardOn, sizeof(TBool));

 			break;

 		default:

 			r=KErrNotSupported;

 			break;

 		}

 	return r;

 	}

 DECLARE_STANDARD_EXTENSION()

 	{

 	__KTRACE_OPT(KEXTENSION,Kern::Printf("Starting keyboard driver"));

 	// create keyboard driver

 	TInt r=KErrNoMemory;

 	DKeyboardTemplate* pK=new DKeyboardTemplate;

 	if (pK)

 		r=pK->Create();

 	__KTRACE_OPT(KEXTENSION,Kern::Printf("Returns %d",r));

 	return r;

 	}