ps2keybd.cpp

WinCE 3.0 BSP, 包含Inter SA1110, Intel_815E, Advantech_PCM9574 等

/*

THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.
Copyright (c) 1995-1998  Microsoft Corporation

*/

#include <windows.h>
#include <ceddk.h>
#include <nkintr.h>
//#include <oalintr.h>

#include <keybddr.h>
#include <keybdpdd.h>

#include "ps2port.hpp"
#include "ps2keybd.hpp"
#include "ps2mouse.hpp"
#include <VR4122io.h>
#include <vrc4173.h>
//#include <eagle.h>

// Scan code consts
static const UINT8 scE0Extended = 0xe0;
static const UINT8 scE1Extended = 0xe1;
static const UINT8 scKeyUpMask  = 0x80;

//  There is really only one physical keyboard supported by the system.
Ps2Keybd    *v_pp2k;
extern DWORD dwSysIntrPs2Ch1;
extern DWORD dwSysIntrKeyboard;

static KEY_STATE_FLAGS  v_KeyStateToggled;

void
WINAPI
KeybdPdd_PowerHandler(
    BOOL    bOff
    )
{
    if( !bOff )
    {

        //Set PS2 port
        v_pp2k -> m_pp2p -> EnablePS2Port();

        //Enable PS2 clock.
        v_pp2k -> m_pp2p -> EnablePS2Clock();

        if ( v_pp2k -> m_pp2p -> MouseTest() )
        {
            // PS2 mouse interrupt enable.
            v_pp2k -> m_pp2p -> InterruptEnable(MousePort);
        }

        v_pp2k -> m_pp2p -> KeyboardReset();

        v_pp2k -> m_pp2p -> KeybdChangScanToSystem();

        v_pp2k -> m_pp2p -> KeyboardLights(0);

        v_pp2k -> m_pp2p -> InterruptEnable(KeybdPort);

    }

    return;
}

BOOL
WINAPI
KeybdPdd_InitializeDriverEx(
    PFN_KEYBD_EVENT_CALLBACK_EX pfnKeybdEventCallbackEx
    )
{
    return TRUE;
}


int
WINAPI
KeybdPdd_GetEventEx(
    UINT32          VKeyBuf[16],
    UINT32          ScanCodeBuf[16],
    KEY_STATE_FLAGS KeyStateFlagsBuf[16]
    )
{
    UINT8           ui8ScanCode;
    INT             cEvents = 0;
    KEY_STATE_FLAGS KeyStateFlags;
    INT             i=0;
    static  UINT32  scInProgress;
    static  UINT32  scPrevious;


    if( v_pp2k -> m_pp2p -> KeybdPowerSwIntrCheck() ){
        VKeyBuf[i] = VK_OFF;
        KeyStateFlagsBuf[i++] = KeyStateDownFlag;
        VKeyBuf[i] = VK_OFF;
        KeyStateFlagsBuf[i++] = 0;
        return i;
    }


    v_pp2k -> m_pp2p -> DataRead(KeybdPort, &ui8ScanCode);

    if ( ui8ScanCode == scE0Extended )
        {
        scInProgress = 0xe000;
        }
    else if ( ui8ScanCode == scE1Extended )
        {
        scInProgress = 0xe10000;
        }
    else if ( scInProgress == 0xe10000 )
        {
        ui8ScanCode &= ~scKeyUpMask;
        scInProgress |= ui8ScanCode << 8;
        }
    else
        {
        scInProgress |= ui8ScanCode;
        if ( scInProgress == scPrevious )
            {
            //  mdd handles auto-repeat so ignore auto-repeats from keybd
            }
        else    // Not a repeated key.  This is the real thing.
            {
            scPrevious = scInProgress;
            
            if ( ui8ScanCode & scKeyUpMask )
                {
                KeyStateFlags = 0;
                scInProgress &= ~scKeyUpMask;
                }
            else
                {
                KeyStateFlags = KeyStateDownFlag;
                }
            cEvents = ScanCodeToVKeyEx(scInProgress, KeyStateFlags, VKeyBuf, ScanCodeBuf, KeyStateFlagsBuf);
            //RETAILMSG(1,(TEXT("IP: %08x  SC: %08x\r\n"), scInProgress, ui8ScanCode));
            }
        scInProgress = 0;
        }

    return(cEvents);

}


void
WINAPI
KeybdPdd_ToggleKeyNotification(
    KEY_STATE_FLAGS KeyStateFlags
    )
{
    unsigned int    fLights;

    v_KeyStateToggled = KeyStateFlags;

    fLights = 0;

    if ( KeyStateFlags & KeyShiftCapitalFlag )
    {
        fLights |= 0x04;
    }

    if ( KeyStateFlags & KeyShiftNumLockFlag )
    {
        fLights |= 0x2;
    }

    v_pp2k -> m_pp2p -> KeyboardLights(fLights);

    return;
}


KEY_STATE_FLAGS
WINAPI
KeybdPdd_KeyStateToggled(
    void
    )
{
    return v_KeyStateToggled;
}



BOOL
KeybdIstLoop(
    HANDLE  hevIntrKeybd
    );

BOOL
KeybdIstSuspendLoop(
    HANDLE  hevSuspend
    );


BOOL
Ps2Keybd::
IsrThreadProc(
    void
    )
{

    // Key scan interrupt.
    m_hevInterrupt = CreateEvent(NULL, FALSE, FALSE, NULL);
    if ( m_hevInterrupt == NULL)
    {
        goto leave;
    }

    if ( !InterruptInitialize(dwSysIntrPs2Ch1, m_hevInterrupt, NULL, 0) )
    {
        goto leave;
    }

    m_pp2p -> InterruptEnable(KeybdPort);

    KeybdIstLoop(m_hevInterrupt);

leave:
    return 0;
}


BOOL
Ps2Keybd::
SuspendThreadProc(
    void
    )
{

    // Power switch interrupt.
    m_hevSuspend = CreateEvent(NULL, FALSE, FALSE, NULL);
    if ( m_hevSuspend == NULL)
    {
        RETAILMSG(1, (TEXT("CreateEvent error!!\r\n")));
        goto leave;
    }

    if ( !InterruptInitialize(dwSysIntrKeyboard, m_hevSuspend, NULL, 0) )
    {
        RETAILMSG(1, (TEXT("InterruptInitialize error!!\r\n")));
        goto leave;
    }

    KeybdIstSuspendLoop(m_hevSuspend);

leave:
    return 0;
}


DWORD
Ps2KeybdIsrThread(
    Ps2Keybd    *pp2k
    )
{

    pp2k -> IsrThreadProc();

    return 0;
}


DWORD
SuspendIsrThread(
    Ps2Keybd    *pp2k
    )
{

    pp2k -> SuspendThreadProc();

    return 0;
}


BOOL
Ps2Keybd::
IsrThreadStart(
    void
    )
{
    HANDLE  hthrd;
    HANDLE  hSuspendthrd;

    hthrd = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Ps2KeybdIsrThread, this, 0, NULL);

    //  Since we don't need the handle, close it now.
    CloseHandle(hthrd);


    hSuspendthrd = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)SuspendIsrThread, this, 0, NULL);

    //  Since we don't need the handle, close it now.
    CloseHandle(hSuspendthrd);

    return TRUE;
}


BOOL
Ps2Keybd::
Initialize(
    Ps2Port *pp2p
    )
{
    BOOL    bRet = FALSE;

    m_pp2p = pp2p;

    if( !v_pp2k -> m_pp2p -> KeyboardReset() )
    {
        RETAILMSG(1,(TEXT("PS2 keyboard probably not present!.\r\n")));
        //goto leave; // To avoid the error, return TRUE anytime.
    }
    v_pp2k -> m_pp2p -> KeybdChangScanToSystem();

    v_pp2k -> m_pp2p -> KeyboardLights(0);

    return bRet = TRUE;

//leave:
    return bRet;
}