/*

* Copyright (c) 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: Minimalistic keyboard driver

*

*/

//#define DEBUG

#include "syborg_keyboard.h"

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

{

  DKeyboardPs2Soc* pH=(DKeyboardPs2Soc*)aPtr;

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

}

void rxMsg(TAny* aPtr)

{

  DKeyboardPs2Soc& h=*(DKeyboardPs2Soc*)aPtr;

  TMessageBase* pM=h.iMsgQ.iMessage;

  if (pM)

	h.HandleMsg(pM);

}

TInt DKeyboardPs2Soc::FifoPop(void)

{

  TInt val = iKeyFifo[iFifoPos];

  iFifoPos++;

  iFifoCount--;

  if (iFifoPos == FIFO_SIZE)

	iFifoPos = 0;

  return val;

}

void DKeyboardPs2Soc::FifoPush(TInt val)

{

  TInt slot;

  if (iFifoCount == FIFO_SIZE)

	return;

  slot = iFifoPos + iFifoCount;

  if (slot >= FIFO_SIZE)

	slot -= FIFO_SIZE;

  iKeyFifo[slot] = val;

  iFifoCount++;

}

void DKeyboardPs2Soc::Isr(TAny* aPtr)

{

  __DEBUG_PRINT("DKeyboardPs2Soc::Isr");

  DKeyboardPs2Soc& k = *(DKeyboardPs2Soc*)aPtr;

  // Is now auto-clearing

  while(ReadReg(KHwBaseKmiKeyboard, KBD_FIFO_COUNT)!=0)

	k.FifoPush(ReadReg(KHwBaseKmiKeyboard, KBD_DATA));

  //WriteReg(KHwBaseKmiKeyboard,KBD_CLEAR_INT, 0);

  Interrupt::Clear(EIntKeyboard); 

  k.iRxDfc.Add();

}

DKeyboardPs2Soc::DKeyboardPs2Soc()

  :	DPowerHandler(KLitKeyboard),

	iRxDfc(RxDfc,this,Kern::DfcQue0(),1),

	iMsgQ(rxMsg,this,NULL,1)

{

  iKeyboardOn = ETrue;

  iFifoPos = 0;

  iFifoCount = 0;

}

TInt DKeyboardPs2Soc::Create()

{

  __DEBUG_PRINT("DKeyboardPs2Soc::Create");

  TInt r=KErrNone;

  iDfcQ=Kern::DfcQue0();

  iFifoPos = iFifoCount = 0;

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

  if (r!=KErrNone)

	return r;

  iMsgQ.SetDfcQ(iDfcQ);

  iMsgQ.Receive();

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

  if (r==KErrNone) {

	Add();

	KeyboardOn();

  }

  return r;

}

void DKeyboardPs2Soc::PowerUp()

{

  PowerUpDone();

}

void DKeyboardPs2Soc::PowerDown(TPowerState)

{

  PowerDownDone();

}

void DKeyboardPs2Soc::KeyboardOn()

{

  __DEBUG_PRINT("DKeyboardPs2Soc::KeyboardOn");

  TInt reg = ReadReg(KHwBaseKmiKeyboard,KBD_ID);

  Interrupt::Enable(EIntKeyboard);

  WriteReg(KHwBaseKmiKeyboard,KBD_INT_ENABLE,1);

}

void DKeyboardPs2Soc::KeyboardOff()

{

  __DEBUG_PRINT("DKeyboardPs2Soc::KeyboardOff");

  Interrupt::Disable(EIntKeyboard);

  WriteReg(KHwBaseKmiKeyboard,KBD_INT_ENABLE,0);

}

void DKeyboardPs2Soc::HandleMsg(TMessageBase* aMsg)

{

  __DEBUG_PRINT("DKeyboardPs2Soc::HandleMsg");

  if (aMsg->iValue)

	KeyboardOn();

  else

	KeyboardOff();

  aMsg->Complete(KErrNone,ETrue);

}

void DKeyboardPs2Soc::KeyboardInfo(TKeyboardInfoV01& aInfo)

{

  aInfo.iKeyboardType=KConfigKeyboardType;

  aInfo.iDeviceKeys=KConfigKeyboardDeviceKeys;

  aInfo.iAppsKeys=KConfigKeyboardAppsKeys;

}

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

{

  TInt r=KErrNone;

  __DEBUG_PRINT("DKeyboardPs2Soc::HalFunction");

  switch(aFunction)

	{

	case EKeyboardHalKeyboardInfo:

	  {

		TPckgBuf<TKeyboardInfoV01> kPckg;

		KeyboardInfo(kPckg());

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

		break;

	  }

	  // UIKLAF Silent running/power management

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

		  }

		else

		  {

			TThreadMessage& m=Kern::Message();

			m.iValue = EFalse;

			m.SendReceive(&iMsgQ);

		  }

	  }

	  break;

	case EKeyboardHalKeyboardState:

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

	  break;

	default:

	  r=KErrNotSupported;

	  break;

	}

  return r;

}

static void KeyOfDeath()

	{

	Kern::Fault("KeyOfDeath", 0x0f100f10);

	}

void DKeyboardPs2Soc::RxDfc(TAny* aPtr)

{

  TRawEvent e;

  DKeyboardPs2Soc& k = *(DKeyboardPs2Soc*)aPtr;

  while(k.iFifoCount>0) {

	int keycode = k.FifoPop();

	int dwn = (keycode & 0x80000000) ? 0 : 1;

	__DEBUG_PRINT("DKeyboardPs2Soc::RxDfc %d %d", keycode, dwn);

	keycode &= ~(0x80000000);	

	if (dwn) {

	  __DEBUG_PRINT("kbd EKeyDown:%d",keycode);

	  e.Set(TRawEvent::EKeyDown,KConvertCode[keycode],0);

	}

	else {

	  __DEBUG_PRINT("kbd EKeyUp:%d",keycode);

	  e.Set(TRawEvent::EKeyUp,KConvertCode[keycode],0);

	}

	if (KConvertCode[keycode] == EStdKeyF10) {

		KeyOfDeath();

	}

	Kern::AddEvent(e);

  }

}

DECLARE_STANDARD_EXTENSION()

{

  TInt r=KErrNoMemory;

  DKeyboardPs2Soc* pK=new DKeyboardPs2Soc;

  if (pK)

	r=pK->Create();

  __KTRACE_OPT(KEXTENSION,__DEBUG_PRINT("Returns %d",r));

  return r;

}