KeymapManager.cc

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "pedigree/kernel/machine/KeymapManager.h"
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/machine/HidInputManager.h"
#include "pedigree/kernel/machine/Keyboard.h"
#include "pedigree/kernel/machine/keymaps/KeymapEnUs.h"
#include "pedigree/kernel/utilities/utility.h"

// #define DEBUG_KEYMAP

#ifdef DEBUG_KEYMAP
#define KM_NOTICE NOTICE
#else
#define KM_NOTICE(...)
#endif

#define KEYMAP_INDEX(combinator, modifiers, scancode) \
    (((combinator & 0xFF) << 11) | ((modifiers & 0xF) << 7) | (scancode & 0x7F))
#define KEYMAP_MAX_INDEX KEYMAP_INDEX(0xFF, 0xF, 0x7F)

KeymapManager KeymapManager::m_Instance;

KeymapManager::KeymapManager()
    : m_pSparseTable(0), m_pDataTable(0), m_bLeftCtrl(false),
      m_bLeftShift(false), m_bLeftAlt(false), m_bRightCtrl(false),
      m_bRightShift(false), m_bRightAlt(false), m_bCapsLock(false),
      m_nCombinator(0), m_bHaveLoadedKeymap(false)
{
    void *sparseBuffer = ASSUME_ALIGNMENT(sparseBuff, sizeof(void *));
    void *dataBuffer = ASSUME_ALIGNMENT(dataBuff, sizeof(void *));

    m_pSparseTable = reinterpret_cast<SparseEntry *>(sparseBuffer);
    m_pDataTable = reinterpret_cast<KeymapEntry *>(dataBuffer);
}

KeymapManager::~KeymapManager()
{
}

void KeymapManager::useKeymap(uint8_t *pSparseTable, uint8_t *pDataTable)
{
    void *sparseBuffer = ASSUME_ALIGNMENT(pSparseTable, sizeof(void *));
    void *dataBuffer = ASSUME_ALIGNMENT(pDataTable, sizeof(void *));

    SparseEntry *oldSparse = m_pSparseTable;
    KeymapEntry *oldData = m_pDataTable;

    // Set the table pointers
    m_pSparseTable = reinterpret_cast<SparseEntry *>(sparseBuffer);
    m_pDataTable = reinterpret_cast<KeymapEntry *>(dataBuffer);

    // Check for a sensible keymap (40 == return key)
    if (!resolveHidKeycode(40))
    {
        ERROR("KeymapManager: new keymap check failed, restoring old keymap");
        m_pSparseTable = oldSparse;
        m_pDataTable = oldData;
    }
    else if (m_bHaveLoadedKeymap)
    {
        delete[] oldSparse;
        delete[] oldData;
    }

    // Make the HID input manager update all its keys
    HidInputManager::instance().updateKeys();

    // We've now loaded a keymap - all future loads should free the previous
    // keymap once the new one is loaded.
    m_bHaveLoadedKeymap = true;
}

bool KeymapManager::useCompiledKeymap(
    uint32_t *pCompiledKeymap, size_t keymapLength)
{
    // File format:  0    Sparse tree offset
    //               4    Data tree offset
    //               ...  Sparse tree & data tree.

    uint32_t sparseTableOffset = pCompiledKeymap[0];
    uint32_t dataTableOffset = pCompiledKeymap[1];
    uint32_t sparseTableSize = dataTableOffset - sparseTableOffset;
    uint32_t dataTableSize = keymapLength - dataTableOffset;

    // Preserve the previous keymap in case we need to restore it.
    SparseEntry *oldSparse = m_pSparseTable;
    KeymapEntry *oldData = m_pDataTable;

    // Set up our new tables.
    m_pSparseTable = new SparseEntry[sparseTableSize / sizeof(SparseEntry)];
    m_pDataTable = new KeymapEntry[dataTableSize / sizeof(KeymapEntry)];

    MemoryCopy(
        m_pSparseTable, adjust_pointer(pCompiledKeymap, sparseTableOffset),
        sparseTableSize);
    MemoryCopy(
        m_pDataTable, adjust_pointer(pCompiledKeymap, dataTableOffset),
        dataTableSize);

    // Check for sensible keymap.
    if (!resolveHidKeycode(40))
    {
        ERROR("KeymapManager: new keymap check failed, restoring old keymap");
        m_pSparseTable = oldSparse;
        m_pDataTable = oldData;

        return false;
    }
    else if (m_bHaveLoadedKeymap)
    {
        delete[] oldSparse;
        delete[] oldData;
    }

    // Make the HID input manager update all its keys
    HidInputManager::instance().updateKeys();

    // We've now loaded a keymap - all future loads should free the previous
    // keymap once the new one is loaded.
    m_bHaveLoadedKeymap = true;

    return true;
}

bool KeymapManager::handleHidModifier(uint8_t keyCode, bool bDown)
{
    // If the key isn't a modifier, return false right away
    if (!((keyCode >= HidLeftCtrl && keyCode <= HidRightGui) ||
          keyCode == HidCapsLock))
        return false;
    // Handle modifier keys, enabled on keyDown, disabled on keyUp
    if (keyCode == HidLeftCtrl)
        m_bLeftCtrl = bDown;
    if (keyCode == HidRightCtrl)
        m_bRightCtrl = bDown;
    if (keyCode == HidLeftShift)
        m_bLeftShift = bDown;
    if (keyCode == HidRightShift)
        m_bRightShift = bDown;
    if (keyCode == HidLeftAlt)
        m_bLeftAlt = bDown;
    if (keyCode == HidRightAlt)
        m_bRightAlt = bDown;
    // Handle CapsLock key, changes on keyUp
    if (keyCode == HidCapsLock && !bDown)
        m_bCapsLock = !m_bCapsLock;
    return true;
}

uint64_t KeymapManager::resolveHidKeycode(uint8_t keyCode)
{
    KM_NOTICE("resolveHidKeycode(" << keyCode << ")");

    // Get the modifiers
    bool bCtrl = m_bLeftCtrl || m_bRightCtrl;
    bool bShift = m_bLeftShift || m_bRightShift;
    bool bAlt = m_bLeftAlt, bAltGr = m_bRightAlt;

    bool bUseUpper = false;  // Use the upper case keymap

    if (m_bCapsLock ^ bShift)
        bUseUpper = true;

    // Try and grab a keymap entry for the scancode with all modifiers enabled.
    KeymapEntry *pKeymapEntry =
        getKeymapEntry(bCtrl, bShift, bAlt, bAltGr, m_nCombinator, keyCode);
    // Fallback and try without combinator
    if (!pKeymapEntry || (!pKeymapEntry->value && !pKeymapEntry->flags))
    {
        KM_NOTICE("keymap: falling back: -combinator");
        pKeymapEntry = getKeymapEntry(bCtrl, bShift, bAlt, bAltGr, 0, keyCode);
    }
    // Fallback and try without combinator and Ctrl
    if (!pKeymapEntry || (!pKeymapEntry->value && !pKeymapEntry->flags))
    {
        KM_NOTICE("keymap: falling back: -combinator, -ctrl");
        pKeymapEntry = getKeymapEntry(false, bShift, bAlt, bAltGr, 0, keyCode);
    }
    // Fallback and try with only Shift
    if (!pKeymapEntry || (!pKeymapEntry->value && !pKeymapEntry->flags))
    {
        KM_NOTICE("keymap: falling back: -combinator, -ctrl, -alt");
        pKeymapEntry = getKeymapEntry(false, bShift, false, false, 0, keyCode);
    }
    // Fallback and try with no modifier enabled
    if (!pKeymapEntry || (!pKeymapEntry->value && !pKeymapEntry->flags))
    {
        KM_NOTICE("keymap: falling back: -combinator, -ctrl, -alt, -shift");
        pKeymapEntry = getKeymapEntry(false, false, false, false, 0, keyCode);
    }
    // This key has no entry at all in the keymap
    if (!pKeymapEntry || (!pKeymapEntry->value && !pKeymapEntry->flags))
    {
        KM_NOTICE("keymap: no fallback possible, key not in keymap");
        return 0;
    }

    KM_NOTICE("keymap: successfully got a keymap entry");

    // Does this key set any combinator?
    uint32_t nCombinator = pKeymapEntry->flags & 0xFF;
    if (nCombinator)
    {
        // If the key sets the same combinator that we're currently using,
        // the "dead" key becomes live and shows the default key.
        if (nCombinator == m_nCombinator)
        {
            // Unset combinator and fall through to display default glyph
            m_nCombinator = 0;
        }
        else
        {
            // Change combinator
            m_nCombinator = nCombinator;
            return 0;
        }
    }
    else
    {
        // Dead keys should be reset here
        m_nCombinator = 0;
    }

    uint64_t key = pKeymapEntry->value;

    if (pKeymapEntry->flags & KeymapEntry::Special)
        key |= Keyboard::Special;
    else if (bUseUpper && key >= 'a' && key <= 'z')
        key -= ('a' - 'A');
    else if (!bUseUpper && key >= 'A' && key <= 'Z')
        key += ('a' - 'A');

    if (bCtrl)
        key |= Keyboard::Ctrl;
    if (bShift)
        key |= Keyboard::Shift;
    if (bAlt)
        key |= Keyboard::Alt;
    if (bAltGr)
        key |= Keyboard::AltGr;

    return key;
}

KeymapManager::KeymapEntry *KeymapManager::getKeymapEntry(
    bool bCtrl, bool bShift, bool bAlt, bool bAltGr, uint8_t nCombinator,
    uint8_t keyCode)
{
    KM_NOTICE(
        "getKeymapEntry(ctrl=" << bCtrl << ", shift=" << bShift
                               << ", alt=" << bAlt << ", altgr=" << bAltGr
                               << ", comb=" << nCombinator
                               << ", code=" << keyCode << ")");

    // Grab the keymap table index for this key
    size_t modifiers = 0;
    if (bCtrl)
        modifiers |= IndexCtrl;
    if (bShift)
        modifiers |= IndexShift;
    if (bAlt)
        modifiers |= IndexAlt;
    if (bAltGr)
        modifiers |= IndexAltGr;
    size_t nIndex = KEYMAP_INDEX(nCombinator, modifiers, keyCode);

    KM_NOTICE(
        "idx=" << nIndex << ", mods=" << modifiers << ", code=" << keyCode);

    // Now walk the sparse tree
    size_t bisect = (KEYMAP_MAX_INDEX + 1) / 2;
    size_t size = (KEYMAP_MAX_INDEX + 1) / 2;
    SparseEntry *pSparse = m_pSparseTable;
    size_t nDataIndex = 0;
    while (true)
    {
        if (nIndex < bisect)
        {
            if (!pSparse->left)
                return 0;
            if (pSparse->left & SparseEntry::DataFlag)
            {
                size_t nOffset = nIndex - (bisect - size);
                nDataIndex = (pSparse->left & ~SparseEntry::DataFlag) +
                             nOffset * sizeof(KeymapEntry);
                break;
            }
            size /= 2;
            bisect = bisect - size;
            pSparse = &m_pSparseTable[pSparse->left / sizeof(SparseEntry)];
        }
        else
        {
            if (!pSparse->right)
                return 0;
            if (pSparse->right & SparseEntry::DataFlag)
            {
                size_t nOffset = nIndex - bisect;
                nDataIndex = (pSparse->right & ~SparseEntry::DataFlag) +
                             nOffset * sizeof(KeymapEntry);
                break;
            }
            size /= 2;
            bisect = bisect + size;
            pSparse = &m_pSparseTable[pSparse->right / sizeof(SparseEntry)];
        }
    }

    // Return the found keymap entry
    return &m_pDataTable[nDataIndex / sizeof(KeymapEntry)];
}

// These tables originated from qemu
// Copyright (c) 2007 OpenMoko, Inc.  (andrew@openedhand.com)
static const uint8_t pc102ToHidTableNormal[] = {
    0x00, 0x29, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
    0x2d, 0x2e, 0x2a, 0x2b, 0x14, 0x1a, 0x08, 0x15, 0x17, 0x1c, 0x18, 0x0c,
    0x12, 0x13, 0x2f, 0x30, 0x28, 0xe0, 0x04, 0x16, 0x07, 0x09, 0x0a, 0x0b,
    0x0d, 0x0e, 0x0f, 0x33, 0x34, 0x35, 0xe1, 0x31, 0x1d, 0x1b, 0x06, 0x19,
    0x05, 0x11, 0x10, 0x36, 0x37, 0x38, 0xe5, 0x55, 0xe2, 0x2c, 0x39, 0x3a,
    0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x53, 0x47, 0x5f,
    0x60, 0x61, 0x56, 0x5c, 0x5d, 0x5e, 0x57, 0x59, 0x5a, 0x5b, 0x62, 0x63,
    0x00, 0x00, 0x64, 0x44, 0x45, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e,
    0x00, 0x00, 0x71, 0x72, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x85,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0xe3, 0xe7, 0x65};

static const uint8_t pc102ToHidTableEscape[] = {
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x58, 0xe4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x00, 0x46, 0xe6, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x4a,
    0x52, 0x4b, 0x00, 0x50, 0x00, 0x4f, 0x00, 0x4d, 0x51, 0x4e, 0x49, 0x4c,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

uint8_t KeymapManager::convertPc102ScancodeToHidKeycode(
    uint8_t scancode, EscapeState &escape)
{
    // Handle escape scancode 0xE0
    if (scancode == 0xE0)
    {
        escape = EscapeE0;
        return 0;
    }

    // Handle escape scancode 0xE1
    if (scancode == 0xE1)
    {
        escape = EscapeE1;
        return 0;
    }

    // Treat 0xE1 0x1D as 0xE0 (escape scancode)
    if (scancode == 0x1D && escape == EscapeE1)
    {
        escape = EscapeE0;
        return 0;
    }

    if (escape)
    {
        escape = EscapeNone;
        KM_NOTICE(
            "keymap: using escape table to convert PC102 scancode "
            << scancode);
        return pc102ToHidTableEscape[scancode & 0x7F];
    }
    else
    {
        KM_NOTICE(
            "keymap: using normal table to convert PC102 scancode "
            << scancode);
        return pc102ToHidTableNormal[scancode & 0x7F];
    }
}