mach_pc/Keyboard.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 "Keyboard.h"
#include "pedigree/kernel/LockGuard.h"
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/machine/HidInputManager.h"
#include "pedigree/kernel/machine/InputManager.h"
#include "pedigree/kernel/machine/KeymapManager.h"
#include "pedigree/kernel/process/Thread.h"
#include "pedigree/kernel/processor/Processor.h"
#include "pedigree/kernel/processor/ProcessorInformation.h"
#include "pedigree/kernel/utilities/new"
 
#include "Ps2Controller.h"
 
#if DEBUGGER
#if TRACK_PAGE_ALLOCATIONS
#include "pedigree/kernel/debugger/commands/AllocationCommand.h"
#endif
 
#include "pedigree/kernel/core/SlamAllocator.h"
#include "pedigree/kernel/debugger/commands/SlamCommand.h"
#endif
 
class Process;
 
#if MEMORY_TRACING
extern void toggleTracingAllocations();
#endif
 
X86Keyboard::X86Keyboard(Ps2Controller* controller)
    : m_pPs2Controller(controller),
      m_Escape(KeymapManager::EscapeNone),
      m_IrqId(0),
      m_LedState(0),
      m_LedCommandState(LedIdle),
      m_LedSent(0),
      m_LedRetries(0),
      m_LedLock(),
      m_ReaderThread() {}
 
X86Keyboard::~X86Keyboard() {
  stopReaderThread();
}
 
void X86Keyboard::initialise() {
 
  // enable data stream
  uint8_t result = 0;
  m_pPs2Controller->writeFirstPort(0xF4);
  m_pPs2Controller->readFirstPort(result);
  NOTICE("X86Keyboard: 'enable stream' response: " << Hex << result);
}
 
char X86Keyboard::getChar() {
  if (m_pPs2Controller->getDebugState()) {
    // Convert the scancode into ASCII and return it
    uint8_t scancode = m_pPs2Controller->readByte();
    return scancodeToAscii(scancode);
  } else {
    ERROR("Keyboard::getChar() should not be called outside debug mode");
    return 0;
  }
}
 
char X86Keyboard::getCharNonBlock() {
  if (m_pPs2Controller->getDebugState()) {
    uint8_t scancode = m_pPs2Controller->readByteNonBlock();
    if (!scancode) {
      return 0;
    }
 
    // Convert the scancode into ASCII and return it
    return scancodeToAscii(scancode);
  } else {
    ERROR(
        "Keyboard::getCharNonBlock should not be called outside debug "
        "mode");
    return 0;
  }
}
 
void X86Keyboard::setDebugState(bool enableDebugState) {
  m_pPs2Controller->setDebugState(enableDebugState);
}
 
bool X86Keyboard::getDebugState() {
  return m_pPs2Controller->getDebugState();
}
 
char X86Keyboard::scancodeToAscii(uint8_t scancode) {
  // Get the HID keycode corresponding to the scancode
  uint8_t keyCode = KeymapManager::instance().convertPc102ScancodeToHidKeycode(scancode, m_Escape);
  if (!keyCode)
    return 0;
 
  uint64_t key = 0;
  // Let KeymapManager handle the modifiers
  if (!KeymapManager::instance().handleHidModifier(keyCode, !(scancode & 0x80)) &&
      !(scancode & 0x80))
    key = KeymapManager::instance().resolveHidKeycode(keyCode);  // Get the actual key
 
  // Check for special keys
  if (key & Keyboard::Special) {
    char a = key & 0xFF, b = (key >> 8) & 0xFF, c = (key >> 16) & 0xFF, d = (key >> 24) & 0xFF;
    // Up
    if (a == 'u' && b == 'p')
      return 'j';
    // Down
    if (a == 'd' && b == 'o' && c == 'w' && d == 'n')
      return 'k';
    // PageUp
    if (a == 'p' && b == 'g' && c == 'u' && d == 'p')
      return '\b';
    // PageDown
    if (a == 'p' && b == 'g' && c == 'd' && d == 'n')
      return ' ';
  }
  // Discard non-ASCII keys
  if ((key & Keyboard::Special) || ((key & 0xFFFFFFFF) > 0x7f))
    return 0;
  return static_cast<char>(key & 0x7f);
}
 
char X86Keyboard::getLedState() {
  LockGuard<Mutex> guard(m_LedLock);
  return m_LedState;
}
 
void X86Keyboard::setLedState(char state) {
  updateLedState(state, false);
}
 
void X86Keyboard::updateLedState(char state, bool toggle) {
  LockGuard<Mutex> guard(m_LedLock);
  m_LedState = (toggle ? m_LedState ^ state : state) & 7;
  if (m_LedCommandState == LedIdle) {
    m_LedCommandState = LedCommandAck;
    m_LedRetries = 0;
    m_pPs2Controller->writeFirstPort(0xED);
  }
}
 
void X86Keyboard::handleLedResponse(uint8_t response) {
  // Command replies share the scancode FIFO. Only the reader consumes it,
  // so queued key releases cannot be mistaken for a synchronous LED reply.
  LockGuard<Mutex> guard(m_LedLock);
  if (m_LedCommandState == LedIdle) {
    return;
  }
 
  if (response == 0xFE) {
    if (m_LedRetries++ == 3) {
      m_LedCommandState = LedIdle;
      ERROR("X86Keyboard: LED command retry limit reached");
      return;
    }
    m_pPs2Controller->writeFirstPort(m_LedCommandState == LedCommandAck ? 0xED : m_LedSent);
    return;
  }
 
  m_LedRetries = 0;
  if (m_LedCommandState == LedCommandAck) {
    m_LedSent = m_LedState;
    m_LedCommandState = LedDataAck;
    m_pPs2Controller->writeFirstPort(m_LedSent);
  } else if (m_LedSent != m_LedState) {
    m_LedCommandState = LedCommandAck;
    m_pPs2Controller->writeFirstPort(0xED);
  } else {
    m_LedCommandState = LedIdle;
  }
}
 
void X86Keyboard::startReaderThread() {
  if (m_ReaderThread) {
    FATAL("X86Keyboard reader started more than once.");
  }
 
  Process* pProcess = Processor::information().getCurrentThread()->getParent();
  Thread* pThread = new Thread(pProcess, readerThreadTrampoline, this);
  pThread->setName("X86 keyboard reader");
  m_ReaderThread.adopt(pThread);
 
  // Now that we're listening - enable IRQs from the keyboard
  m_pPs2Controller->setIrqEnable(true, false);
}
 
void X86Keyboard::stopReaderThread() {
  m_ReaderThread.stop();
}
 
int X86Keyboard::readerThreadTrampoline(void* param) {
  X86Keyboard* instance = reinterpret_cast<X86Keyboard*>(param);
  instance->readerThread();
  return 0;
}
 
void X86Keyboard::readerThread() {
  while (true) {
    uint8_t scancode;
    if (!m_pPs2Controller->readFirstPort(scancode)) {
      Thread* thread = Processor::information().getCurrentThread();
      if (thread && thread->getUnwindState() != Thread::Continue) {
        return;
      }
      continue;
    }
    if (scancode == 0xFA || scancode == 0xFE) {
      handleLedResponse(scancode);
      continue;
    }
 
    // Check for keys with special functions
#if DEBUGGER
#if CRIPPLINGLY_VIGILANT
    if (scancode == 0x43)  // F9
      SlamAllocator::instance().setVigilance(true);
    if (scancode == 0x44)  // F10
      SlamAllocator::instance().setVigilance(false);
#endif
    if (scancode == 0x57)  // F11
    {
#if MEMORY_TRACING
      WARNING("F11: Toggling allocation tracing.");
      toggleTracingAllocations();
#else
#if TRACK_PAGE_ALLOCATIONS
      NOTICE("F11: Triggering allocation checkpoint.");
      g_AllocationCommand.checkpoint();
#endif
      NOTICE("F11: Cleaning SLAM.");
      g_SlamCommand.clean();
#endif
 
      continue;
    }
    if (scancode == 0x58)  // F12
    {
      FATAL("User-induced breakpoint.");
    }
#endif
 
    // Check for LED manipulation
    if (scancode & 0x80) {
      uint8_t code = scancode & ~0x80;
      if (code == 0x3A) {
        DEBUG_LOG("X86Keyboard: Caps Lock toggled");
        updateLedState(Keyboard::CapsLock, true);
      } else if (code == 0x45) {
        DEBUG_LOG("X86Keyboard: Num Lock toggled");
        updateLedState(Keyboard::NumLock, true);
      } else if (code == 0x46) {
        DEBUG_LOG("X86Keyboard: Scroll Lock toggled");
        updateLedState(Keyboard::ScrollLock, true);
      }
    }
 
    InputManager::instance().machineKeyUpdate(scancode & 0x7F, scancode & 0x80);
 
    // Get the HID keycode corresponding to the scancode
    uint8_t keyCode =
        KeymapManager::instance().convertPc102ScancodeToHidKeycode(scancode, m_Escape);
    if (!keyCode) {
      ERROR("X86Keyboard: failed to translate scancode " << Hex << scancode);
      continue;
    }
 
    // Send the keycode to the HID input manager
    if (scancode & 0x80)
      HidInputManager::instance().keyUp(keyCode);
    else
      HidInputManager::instance().keyDown(keyCode);
  }
}