pl050keybd.cpp

来自「WinCE 3.0 BSP, 包含Inter SA1110, Intel_815」· C++ 代码 · 共 256 行

/* -*-C-*-
 *
 * $Revision: 1.4 $
 *   $Author: kwelton $
 *     $Date: 2000/08/08 19:41:55 $
 *
 * 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
 * Copyright (c) 2000 ARM Limited
 * All Rights Reserved
 */

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

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

#include "pl050port.hpp"
#include "pl050mouse.hpp"
#include "pl050keybd.hpp"

extern PFN_KEYBD_EVENT_CALLBACK_EX v_pfnKeybdEventCallbackEx;

extern "C" unsigned int KbdISRUpcall(bool timedout, unsigned int scancode);

static pl050Keybd *kbdport;

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

static KEY_STATE_FLAGS v_KeyStateToggled;

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

/*
 * GetISTPriority
 *
 * Read the thread priority to use for the keyboard IST or return the default
 */
static DWORD GetISTPriority(void)
{
    HKEY hKey;
    DWORD dwVal;
    DWORD dwLen;
    DWORD dwType;
    DWORD dwRet;

    dwVal = THREAD_PRIORITY_HIGHEST;

    dwRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE, KEYBOARD_DRIVER_KEY,
                         0, 0, &hKey);

    if (dwRet == ERROR_SUCCESS)
    {
        dwLen = sizeof(DWORD);
        RegQueryValueEx(hKey, TEXT("Priority"), NULL, &dwType,
                        (PUCHAR)&dwVal, &dwLen);
        RegCloseKey(hKey);
    }

    return dwVal;
}

static void pl050KeybdIsrThread(pl050Keybd *pp2k)
{
    SetThreadPriority(GetCurrentThread(), GetISTPriority());

    pp2k->m_pp2p->ISRLoop(INFINITE);

    ERRORMSG(1, (TEXT("pl050kbd: ISR thread proc has returned!\r\n")));

    return;
}

/*
 * @func KeybdDriverInitializeEx
 *
 *    Do one time only keyboard driver initialization.
 *
 * @parm
 *
 *    pfnKeybdEventCallbackEx    The callback into the input system.
 *
 * @rdesc
 *
 *    If the function succeeds the return value is TRUE, otherwise, it is
 *    FALSE.  Extended error information is available via the GetLastError
 *    function.
 *
 * @comm
 *
 *    Calls KeybdPdd_InitializeDriver() then starts driver interrupt
 *    service thread.
 */
extern "C" void KeybdDriverInitializeEx(PFN_KEYBD_EVENT_CALLBACK_EX pfnKeybdEventCallbackEx)
{
    v_pfnKeybdEventCallbackEx = pfnKeybdEventCallbackEx;

    KeybdPdd_InitializeDriverEx(pfnKeybdEventCallbackEx);

    (*pfnKeybdEventCallbackEx)(KEYBD_DEVICE_CONNECT, 0, 0);

    /*
     * if there's a callback function registered, then we register
     * our upcall with the generic ISR, otherwise we clear the upcall
     */
    if (pfnKeybdEventCallbackEx != NULL)
        kbdport->m_pp2p->SetISRUpcall(KbdISRUpcall);
    else
        kbdport->m_pp2p->SetISRUpcall(NULL);

    return;
}

#ifdef DEBUG
PFN_KEYBD_DRIVER_INITIALIZE_EX v_pfnDriverInitializeTestEx = KeybdDriverInitializeEx;
#endif

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

void WINAPI KeybdPdd_PowerHandler(BOOL bOff)
{
    return;
}

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

int WINAPI pl050KeybdPdd_GetEventEx(UINT32 VKeyBuf[16],
                                    UINT32 ScanCodeBuf[16],
                                    KEY_STATE_FLAGS KeyStateFlagsBuf[16],
                                    UINT8 ui8ScanCode)
{
    INT cEvents = 0;
    KEY_STATE_FLAGS KeyStateFlags;

    static UINT32 scInProgress;
    static UINT32 scPrevious;

#if 0
    DEBUGMSG(1,(TEXT("GetEventEx: scInProgress = %08x, Scan %08x\r\n"),
                scInProgress, ui8ScanCode));
#endif /* 0/1 */

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

    kbdport->m_pp2p->KeyboardLights(fLights);

    return;
}

KEY_STATE_FLAGS WINAPI KeybdPdd_KeyStateToggled(void)
{
    return v_KeyStateToggled;
}

bool pl050Keybd::IsrThreadStart(void)
{
    HANDLE  hthrd;

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

    if (hthrd == NULL)
    {
        ERRORMSG(1, (TEXT("Failed to create kbd ISR thread\r\n")));
        return false;
    }
    else
    {
        // Since we don't need the handle, close it now.
        CloseHandle(hthrd);

        return true;
    }
}

bool pl050Keybd::Initialise(pl050Port *port)
{
    m_pp2p = port;

    kbdport = this;
    DEBUGMSG(1, (TEXT("pl050Keybd::Init: kbdport = %x\r\n"), kbdport));

    port->OpenPort();

    port->KeyboardMode(1);
    port->KeyboardLights(5);

    return true;
}

/* EOF pl050keybd.cpp */