--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/navienginebsp/ne1_tb/specific/keyboard.cpp Tue Sep 28 18:00:05 2010 +0100
@@ -0,0 +1,736 @@
+/*
+* 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\keyboard.cpp
+* Access to NE1_TBVariant polled keyboard
+* The code here implements a simple polled keyboard driver.
+* This is an alternative to the interrupt-driven driver in keyboard_interrupt.cpp.
+* This example assumes that we have a non-intelligent keyboard
+* consisting of a number of i/o lines arranged in a grid.
+* You can use this code as a starting point and modify it to suit
+* your hardware.
+*
+*/
+
+
+
+#include <naviengine.h>
+#include "platform.h"
+#include <kernel/kpower.h>
+#include <e32keys.h>
+
+
+
+// The TKeyboardState class is used to encapsulate the state of
+// the keyboard. i.e which keys are currently being pressed.
+// To determine which keys are being pressed, typically a voltage
+// is applied to each row in turn (or column, depending on the hardware)
+// and the output is read resulting in a bitmask for each row.
+//
+// For example, the keys could be arranged as follows (where a '1' indicates
+// that a key is currently being pressed :
+// EXAMPLE ONLY
+//
+// Translated
+// Column# 0 1 2 3 4 5 6 7 8 9 A B C D E F KeyCode
+// Row#
+// 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 60 to 6F
+// 5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 50 to 5F
+// 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 40 to 4F
+// 3 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 30 to 3F
+// Input-> 2 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 20 to 2F
+// 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 10 to 1F
+// 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 to 0F
+//
+// output-> 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0
+//
+// TO DO: (mandadory)
+// Modify TKeyboardState (or provide an alternative) to model the
+// real keyboard state
+//
+// EXAMPLE ONLY
+class TKeyboardState
+ {
+public:
+
+ enum TDimensions
+ {
+ KRows = 7,
+ KColumns = 16
+ };
+
+public:
+ TKeyboardState();
+ void Clear();
+ TBool IsKeyReady();
+ TUint32 GetKeyCode();
+ TKeyboardState operator&(const TKeyboardState& aState);
+ TKeyboardState operator|(const TKeyboardState& aState);
+ TKeyboardState operator~();
+
+public:
+ TUint32 iKeyBitMask[KRows];
+ };
+
+/**
+Constructor
+*/
+TKeyboardState::TKeyboardState()
+ {
+ Clear();
+ }
+
+/**
+Clears the array of bitmasks
+*/
+void TKeyboardState::Clear()
+ {
+ for (TInt row=0; row<KRows; row++)
+ iKeyBitMask[row] = 0;
+ }
+
+/**
+Determines whether any keys are being pressed by examining the
+array of bitmasks to determine whether any bits are set
+
+@return ETrue if one or more keys are being pressed
+*/
+TBool TKeyboardState::IsKeyReady()
+ {
+ for (TInt row=0; row<KRows; row++)
+ {
+ if (iKeyBitMask[row] != 0)
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+
+/**
+Scans the array of bitmasks and returns a keycode representing
+the first bit that it finds that is on.
+E.g. :
+if the first bit on the first row is set, then 1 is returned,
+if the third bit on the first row is set, then 3 is returned. etc.
+
+Once a bit is found it is cleared to avoid reading it again.
+
+NB Before calling this function, IsKeyReady() should be called
+to determine whether a key code is available.
+
+@return a 32-bit keycode representing a key that is currently pressed
+*/
+
+TUint32 TKeyboardState::GetKeyCode()
+ {
+ TInt keyNum = 0;
+ for (TInt row=0; row<KRows; row++)
+ {
+ TUint32 bitMask = 1;
+ for (TInt col=0; col<KColumns; col++)
+ {
+ if (iKeyBitMask[row] & bitMask)
+ {
+ iKeyBitMask[row] &= ~bitMask;
+ return keyNum;
+ }
+ bitMask<<= 1;
+ keyNum++;
+ }
+ }
+ return 0;
+ }
+
+/**
+Perform a bitwise AND between two TKeyboardState objects
+by AND-ing together all the 32-bit integers
+
+@return a new instance of a TKeyboardState object containing the result
+*/
+TKeyboardState TKeyboardState::operator&(const TKeyboardState& aState)
+ {
+ TKeyboardState state = *this;
+
+ for (TInt row=0; row<KRows; row++)
+ state.iKeyBitMask[row]&= aState.iKeyBitMask[row];;
+
+ return state;
+ }
+
+/**
+Perform a bitwise OR between two TKeyboardState objects
+by OR-ing together all the 32-bit integers
+
+@return a new instance of a TKeyboardState object containing the result
+*/
+TKeyboardState TKeyboardState::operator|(const TKeyboardState& aState)
+ {
+ TKeyboardState state = *this;
+
+ for (TInt row=0; row<KRows; row++)
+ state.iKeyBitMask[row]|= aState.iKeyBitMask[row];;
+
+ return state;
+ }
+
+/**
+Perform a bitwise NOT (one's complement) of a KeyboardState object
+by NOT-ing all the 32-bit integers
+
+@return a new instance of a TKeyboardState object containing the result
+*/
+TKeyboardState TKeyboardState::operator~()
+ {
+ TKeyboardState state = *this;
+
+ for (TInt row=0; row<KRows; row++)
+ state.iKeyBitMask[row] = ~state.iKeyBitMask[row];
+
+ return state;
+ }
+
+//
+//
+// TO DO: (optional)
+//
+// Modify this conversion table to suit your keyboard layout
+// EXAMPLE ONLY
+//
+
+const TUint8 convertCode[] =
+ {
+//Row 0 (bottom row)
+ EStdKeyLeftAlt , EStdKeyHash , EStdKeyNull , EStdKeyLeftCtrl ,
+ EStdKeyLeftFunc , EStdKeyEscape , '1' , '2' ,
+ '9' , '0' , EStdKeyMinus , EStdKeyEquals ,
+ EStdKeyNull , EStdKeyBackspace , EStdKeyNull , EStdKeyNull ,
+//Row 1
+ EStdKeyNull , EStdKeyBackSlash , EStdKeyLeftShift , EStdKeyNull ,
+ EStdKeyNull , EStdKeyDelete , EStdKeyNull , 'T' ,
+ 'Y' , 'U' , 'I' , EStdKeyEnter ,
+ EStdKeyRightShift , EStdKeyDownArrow , EStdKeyNull , EStdKeyNull ,
+//Row 2
+ EStdKeyNull , EStdKeyTab , EStdKeyNull , EStdKeyNull ,
+ EStdKeyNull , 'Q' , 'W' , 'E' ,
+ 'R' , 'O' , 'P' , EStdKeySquareBracketLeft ,
+ EStdKeyNull , EStdKeySquareBracketRight,EStdKeyNull , EStdKeyNull ,
+//Row 3
+ EStdKeyNull , 'Z' , EStdKeyNull , EStdKeyNull ,
+ EStdKeyNull , EStdKeyCapsLock , EStdKeyNull , EStdKeyNull ,
+ 'K' , 'L' , EStdKeySemiColon , EStdKeySingleQuote ,
+ EStdKeyNull , EStdKeyUpArrow , EStdKeyNull , EStdKeyNull ,
+//Row 4
+ EStdKeyNull , EStdKeyTab , EStdKeyNull , EStdKeyNull,
+ EStdKeyNull , 'Q' , 'W' , 'E' ,
+ 'R' , 'O' , 'P' , EStdKeySquareBracketLeft ,
+ EStdKeyNull , EStdKeySquareBracketRight, EStdKeyNull , EStdKeyNull ,
+//Row 5
+ EStdKeyNull , 'X' , EStdKeyNull , EStdKeyNull ,
+ EStdKeyNull , 'C' , 'V' , 'B' ,
+ 'N' , 'M' , EStdKeyComma , EStdKeyFullStop ,
+ EStdKeyNull , EStdKeySpace , EStdKeyNull , EStdKeyNull ,
+//Row 6
+ EStdKeyNull , EStdKeyNull , EStdKeyNull , EStdKeyNull ,
+ EStdKeyNull , '3' , '4' , '5' ,
+ '6' , '7' , '8' , EStdKeyMenu ,
+ EStdKeyNull , EStdKeyRightArrow , EStdKeyNull , EStdKeyNull
+ };
+
+
+
+
+// EXAMPLE ONLY
+const TKeyboard KConfigKeyboardType = EKeyboard_Full;
+const TInt KConfigKeyboardDeviceKeys = 0;
+const TInt KConfigKeyboardAppsKeys = 0;
+
+
+//
+// TO DO: (optional)
+//
+// Set the keyboard scan rate in milliseconds
+//
+
+// EXAMPLE ONLY
+const TInt KScanRate = 50; // poll every 1/20 of a second (i.e. every 50 milliseconds)
+
+
+_LIT(KLitKeyboard,"Keyboard");
+
+
+//
+// TO DO: (optional)
+//
+// Add any private functions and data you require
+//
+NONSHARABLE_CLASS(DKeyboardNE1_TB) : public DPowerHandler
+ {
+public:
+ DKeyboardNE1_TB();
+ TInt Create();
+
+ // from DPowerHandler
+ void PowerUp();
+ void PowerDown(TPowerState);
+
+private:
+ static void HandleMessage(TAny* aPtr);
+ void HandleMsg(TMessageBase* aMsg);
+
+ static TInt HalFunction(TAny* aPtr, TInt aFunction, TAny* a1, TAny* a2);
+ TInt HalFunction(TInt aFunction, TAny* a1, TAny* a2);
+
+ static void PowerUpDfcFn(TAny* aPtr);
+ void PowerUpDfc();
+
+ static void PowerDownDfcFn(TAny* aPtr);
+ void PowerDownDfc();
+
+ static void TimerCallback(TAny* aDriver);
+ static void TimerDfcFn(TAny* aDriver);
+ void Poll();
+
+ void KeyboardInfo(TKeyboardInfoV01& aInfo);
+
+ void KeyboardOn();
+ void KeyboardOff();
+ void KeyboardPowerUp();
+
+private:
+ TDfcQue* iDfcQ;
+ TMessageQue iMsgQ;
+ TDfc iPowerUpDfc;
+ TDfc iPowerDownDfc;
+ TBool iKeyboardOn;
+ NTimer iTimer;
+ TInt iTimerTicks;
+ TDfc iTimerDfc;
+
+ // a bitmask indicating which keys were pressed down on the last timer tick
+ TKeyboardState iKeyStateLast;
+
+ // a bitmask indicating the set of keys for which we have sent an EKeyDown event
+ TKeyboardState iKeysDown;
+ };
+
+/**
+constructor
+*/
+DKeyboardNE1_TB::DKeyboardNE1_TB()
+ : DPowerHandler(KLitKeyboard),
+ iMsgQ(HandleMessage, this, NULL, 1),
+ iPowerUpDfc(PowerUpDfcFn, this, 6),
+ iPowerDownDfc(PowerDownDfcFn, this, 7),
+ iTimer(&DKeyboardNE1_TB::TimerCallback, (TAny*) this),
+ iTimerDfc(TimerDfcFn, this, 1)
+ {
+ // Convert the scan rate from milliseconds to nanokernel ticks (normally 1/64 of a second)
+ iTimerTicks = NKern::TimerTicks(KScanRate);
+ }
+
+/**
+Second-phase constructor
+Assigns queues for all the DFCs and starts the keyboard-polling timer
+
+Called by factory function at ordinal 0
+*/
+TInt DKeyboardNE1_TB::Create()
+ {
+ iDfcQ=Kern::DfcQue0();
+
+ iKeyboardOn = EFalse;
+
+ // install the HAL function
+ TInt r = Kern::AddHalEntry(EHalGroupKeyboard, DKeyboardNE1_TB::HalFunction, this);
+ if (r != KErrNone)
+ return r;
+
+ iTimerDfc.SetDfcQ(iDfcQ);
+
+ iPowerUpDfc.SetDfcQ(iDfcQ);
+ iPowerDownDfc.SetDfcQ(iDfcQ);
+ iMsgQ.SetDfcQ(iDfcQ);
+ iMsgQ.Receive();
+
+ // install the power handler
+ Add();
+
+ // Power up the device and start the timer
+ KeyboardPowerUp();
+
+ return r;
+ }
+
+/**
+Calback for the keyboard-polling timer
+Called in the context of an ISR
+
+@param aPtr A pointer to an instance of DKeyboardNE1_TB
+*/
+void DKeyboardNE1_TB::TimerCallback(TAny *aPtr)
+ {
+ // schedule a DFC
+ DKeyboardNE1_TB& k=*(DKeyboardNE1_TB*)aPtr;
+ k.iTimerDfc.Add();
+ }
+
+
+/**
+DFC scheduled by the keyboard-polling timer when it expires
+
+@param aPtr A pointer to an instance of DKeyboardNE1_TB
+*/
+void DKeyboardNE1_TB::TimerDfcFn(TAny* aPtr)
+ {
+ ((DKeyboardNE1_TB*)aPtr)->Poll();
+ }
+
+
+/**
+Reads scan codes from the keyboard until there are none left
+Called from the keyboard-polling timer's DFC
+*/
+void DKeyboardNE1_TB::Poll()
+ {
+ __KTRACE_OPT(KHARDWARE,Kern::Printf("DKeyboardNE1_TB::EventDfc"));
+
+
+ TKeyboardState keyState;
+
+ //
+ // TO DO: (mandatory)
+ // Read new key state into the array of bitmasks in keyState
+ // This typically involves applying a voltage to each row from 0 to KRows-1,
+ // reading the output state of the i/o lines at every step
+ // - this represents the keys that are pressed on each row -
+ // and storing the output of each row as a bitmask into keyState.iKeyBitMask[n],
+ // where n = the row being accessed
+ //
+
+ // To enable a simple de-bouncing algorithm,
+ // work out which keys have been pressed down for at least two timer
+ // ticks by AND-ing together the last bitmask with the current bitmask
+ TKeyboardState keysStillDown = keyState & iKeyStateLast;
+
+
+ // Similarly, work out which keys have been "un-pressed" for at least two timer
+ // ticks by AND-ing together the one's complement of the last bitmask with the
+ // one's complement of the current bitmask and
+ // then AND-ing this with the set of keys for which we have sent an EKeyDown
+ // event to give the set of keys for which we need to send an EKeyUp event
+ TKeyboardState keysStillUp = (~keyState & ~iKeyStateLast) & iKeysDown;
+
+ // save the current state for next time
+ iKeyStateLast = keyState;
+
+ // update the set of keys for which we have sent an EKeyDown event
+ iKeysDown = iKeysDown | keysStillDown;
+ iKeysDown = iKeysDown & ~keysStillUp;
+
+ // process all the key-down events
+ while (keysStillDown.IsKeyReady()) // while there are keys we haven't processed
+ {
+ TRawEvent e;
+ TUint keyCode = keysStillDown.GetKeyCode(); // Read keycodes from bitmask
+
+ __KTRACE_OPT(KHARDWARE,Kern::Printf("EKeyDown: #%02x\n",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:
+ //
+ __ASSERT_DEBUG(keyCode < (sizeof(convertCode) / sizeof(TUint8)), Kern::Fault("Keyboard", __LINE__));
+ TUint8 stdKey = convertCode[keyCode];
+
+ e.Set(TRawEvent::EKeyDown, stdKey, 0);
+ Kern::AddEvent(e);
+ }
+
+ // process all the key-up events
+ while (keysStillUp.IsKeyReady()) // while there are keys we haven't processed
+ {
+ TRawEvent e;
+ TUint keyCode = keysStillUp.GetKeyCode(); // Read keycodes from bitmask
+
+ __KTRACE_OPT(KHARDWARE,Kern::Printf("EKeyUp: #%02x\n",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:
+ //
+ __ASSERT_DEBUG(keyCode < (sizeof(convertCode) / sizeof(TUint8)), Kern::Fault("Keyboard", __LINE__));
+ TUint8 stdKey = convertCode[keyCode];
+
+ e.Set(TRawEvent::EKeyUp, stdKey, 0);
+ Kern::AddEvent(e);
+ }
+
+ // start the timer again
+ iTimer.OneShot(iTimerTicks);
+ }
+
+
+
+/**
+Notifies the peripheral of system power up.
+Called by the power manager during a transition from standby.
+Schedules a DFC to handle the power up.
+*/
+void DKeyboardNE1_TB::PowerUp()
+ {
+ iPowerUpDfc.Enque();
+ }
+
+
+/**
+static DFC to handle powering up the keyboard
+
+@param aPtr A pointer to an instance of DKeyboardNE1_TB
+*/
+void DKeyboardNE1_TB::PowerUpDfcFn(TAny* aPtr)
+ {
+ ((DKeyboardNE1_TB*)aPtr)->PowerUpDfc();
+ }
+
+
+/**
+DFC to handle powering up the keyboard
+*/
+void DKeyboardNE1_TB::PowerUpDfc()
+ {
+ __KTRACE_OPT(KPOWER, Kern::Printf("DKeyboardNE1_TB::PowerUpDfc()"));
+ KeyboardOn();
+
+ // Indicate to power handle that powered up is complete
+ PowerUpDone();
+ }
+
+/**
+Powers up the keyboard
+May be called as a result of a power transition or from the HAL
+*/
+void DKeyboardNE1_TB::KeyboardOn()
+ {
+ __KTRACE_OPT(KPOWER,Kern::Printf("DKeyboardNE1_TB::KeyboardOn() iKeyboardOn=%d", iKeyboardOn));
+
+ if (!iKeyboardOn) // make sure we don't initialize more than once
+ KeyboardPowerUp();
+ }
+
+/**
+Powers up the keyboard
+Assumes that the keyboard is currently powered off
+*/
+void DKeyboardNE1_TB::KeyboardPowerUp()
+ {
+ __KTRACE_OPT(KPOWER,Kern::Printf("DKeyboardNE1_TB::KeyboardPowerUp()"));
+
+ iKeyboardOn = ETrue;
+
+ iKeyStateLast.Clear();
+ iKeysDown.Clear();
+
+ // 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);
+
+ // Start the periodic tick for the selected rate.
+ // This will call TimerCallback() in the context of an ISR
+ iTimer.OneShot(iTimerTicks);
+ }
+
+
+/**
+Requests keyboard to power down.
+Called by the power manager during a transition to standby or power off
+Schedules a DFC to handle the power up.
+
+@param aPowerState the current power state
+*/
+void DKeyboardNE1_TB::PowerDown(TPowerState)
+ {
+ iPowerDownDfc.Enque();
+ }
+
+/**
+static DFC to handle powering down the keyboard
+
+@param aPtr A pointer to an instance of DKeyboardNE1_TB
+*/
+void DKeyboardNE1_TB::PowerDownDfcFn(TAny* aPtr)
+ {
+ ((DKeyboardNE1_TB*)aPtr)->PowerDownDfc();
+ }
+
+/**
+DFC to handle powering down the keyboard
+*/
+void DKeyboardNE1_TB::PowerDownDfc()
+ {
+ __KTRACE_OPT(KPOWER, Kern::Printf("DKeyboardNE1_TB::PowerDownDfc()"));
+ KeyboardOff();
+ PowerDownDone();
+ }
+
+/**
+Powers down the keyboard
+May be called as a result of a power transition or from the HAL
+*/
+void DKeyboardNE1_TB::KeyboardOff()
+ {
+ __KTRACE_OPT(KPOWER,Kern::Printf("DKeyboardNE1_TB::KeyboardOff() iKeyboardOn=%d", iKeyboardOn));
+
+ // cancel the keyboard-polling timer
+ iTimerDfc.Cancel();
+ iTimer.Cancel();
+
+ iKeyboardOn = EFalse;
+ }
+
+
+/**
+static message handler for processing power up/down messages
+posted internally from HalFunction()
+
+@param aPtr A pointer to an instance of DKeyboardNE1_TB
+*/
+void DKeyboardNE1_TB::HandleMessage(TAny* aPtr)
+ {
+ DKeyboardNE1_TB& h=*(DKeyboardNE1_TB*)aPtr;
+ TMessageBase* pM=h.iMsgQ.iMessage;
+ if (pM)
+ h.HandleMsg(pM);
+ }
+
+/**
+Message handler for processing power up/down messages
+posted internally from HalFunction()
+
+param aMsg A message indicating whether to power the keyboard on or off
+*/
+void DKeyboardNE1_TB::HandleMsg(TMessageBase* aMsg)
+ {
+ if (aMsg->iValue)
+ KeyboardOn();
+ else
+ KeyboardOff();
+ aMsg->Complete(KErrNone,ETrue);
+ }
+
+
+/**
+Retrieves information about the keyboard
+Called from HalFunction()
+
+@param aInfo a caller-supplied class which on return contains information about the keyboard
+*/
+void DKeyboardNE1_TB::KeyboardInfo(TKeyboardInfoV01& aInfo)
+ {
+ __KTRACE_OPT(KEXTENSION,Kern::Printf("DKeyboardNE1_TB::KeyboardInfo"));
+ aInfo.iKeyboardType=KConfigKeyboardType;
+ aInfo.iDeviceKeys=KConfigKeyboardDeviceKeys;
+ aInfo.iAppsKeys=KConfigKeyboardAppsKeys;
+ }
+
+
+/**
+HAL handler function
+
+@param aPtr a pointer to an instance of DLcdPowerHandler
+@param aFunction the function number
+@param a1 an arbitrary parameter
+@param a2 an arbitrary parameter
+*/
+TInt DKeyboardNE1_TB::HalFunction(TAny* aPtr, TInt aFunction, TAny* a1, TAny* a2)
+ {
+ DKeyboardNE1_TB* pH=(DKeyboardNE1_TB*)aPtr;
+ return pH->HalFunction(aFunction,a1,a2);
+ }
+
+
+/**
+a HAL entry handling function for HAL group attribute EHalGroupKeyboard
+
+@param a1 an arbitrary argument
+@param a2 an arbitrary argument
+@return KErrNone if successful
+*/
+TInt DKeyboardNE1_TB::HalFunction(TInt aFunction, TAny* a1, TAny* a2)
+ {
+ TInt r=KErrNone;
+
+ __KTRACE_OPT(KEXTENSION,Kern::Printf("DKeyboardNE1_TB::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;
+ DKeyboardNE1_TB* pK=new DKeyboardNE1_TB;
+ if (pK)
+ r=pK->Create();
+
+ __KTRACE_OPT(KEXTENSION,Kern::Printf("Returns %d",r));
+ return r;
+ }