5 files changed, 303 insertions, 136 deletions

diff --git a/src/core/hid/emulated_devices.cpp b/src/core/hid/emulated_devices.cpp
index e97470240..0d840a003 100644
--- a/src/core/hid/emulated_devices.cpp
+++ b/src/core/hid/emulated_devices.cpp
@@ -170,13 +170,14 @@ void EmulatedDevices::SetKeyboardButton(Common::Input::CallbackStatus callback,
         return;
     }
 
+    // Index should be converted from NativeKeyboard to KeyboardKeyIndex
     UpdateKey(index, current_status.value);
 
     TriggerOnChange(DeviceTriggerType::Keyboard);
 }
 
 void EmulatedDevices::UpdateKey(std::size_t key_index, bool status) {
-    constexpr u8 KEYS_PER_BYTE = 8;
+    constexpr std::size_t KEYS_PER_BYTE = 8;
     auto& entry = device_status.keyboard_state.key[key_index / KEYS_PER_BYTE];
     const u8 mask = static_cast<u8>(1 << (key_index % KEYS_PER_BYTE));
     if (status) {
diff --git a/src/core/hid/hid_types.h b/src/core/hid/hid_types.h
index 41bc65ce2..af95f3aff 100644
--- a/src/core/hid/hid_types.h
+++ b/src/core/hid/hid_types.h
@@ -12,6 +12,195 @@
 
 namespace Core::HID {
 
+enum class DeviceIndex : u8 {
+    Left = 0,
+    Right = 1,
+    None = 2,
+    MaxDeviceIndex = 3,
+};
+
+// This is nn::hid::NpadButton
+enum class NpadButton : u64 {
+    None = 0,
+    A = 1U << 0,
+    B = 1U << 1,
+    X = 1U << 2,
+    Y = 1U << 3,
+    StickL = 1U << 4,
+    StickR = 1U << 5,
+    L = 1U << 6,
+    R = 1U << 7,
+    ZL = 1U << 8,
+    ZR = 1U << 9,
+    Plus = 1U << 10,
+    Minus = 1U << 11,
+
+    Left = 1U << 12,
+    Up = 1U << 13,
+    Right = 1U << 14,
+    Down = 1U << 15,
+
+    StickLLeft = 1U << 16,
+    StickLUp = 1U << 17,
+    StickLRight = 1U << 18,
+    StickLDown = 1U << 19,
+
+    StickRLeft = 1U << 20,
+    StickRUp = 1U << 21,
+    StickRRight = 1U << 22,
+    StickRDown = 1U << 23,
+
+    LeftSL = 1U << 24,
+    LeftSR = 1U << 25,
+
+    RightSL = 1U << 26,
+    RightSR = 1U << 27,
+
+    Palma = 1U << 28,
+    Verification = 1U << 29,
+    HandheldLeftB = 1U << 30,
+    LagonCLeft = 1U << 31,
+    LagonCUp = 1ULL << 32,
+    LagonCRight = 1ULL << 33,
+    LagonCDown = 1ULL << 34,
+};
+DECLARE_ENUM_FLAG_OPERATORS(NpadButton);
+
+enum class KeyboardKeyIndex : u32 {
+    A = 4,
+    B = 5,
+    C = 6,
+    D = 7,
+    E = 8,
+    F = 9,
+    G = 10,
+    H = 11,
+    I = 12,
+    J = 13,
+    K = 14,
+    L = 15,
+    M = 16,
+    N = 17,
+    O = 18,
+    P = 19,
+    Q = 20,
+    R = 21,
+    S = 22,
+    T = 23,
+    U = 24,
+    V = 25,
+    W = 26,
+    X = 27,
+    Y = 28,
+    Z = 29,
+    D1 = 30,
+    D2 = 31,
+    D3 = 32,
+    D4 = 33,
+    D5 = 34,
+    D6 = 35,
+    D7 = 36,
+    D8 = 37,
+    D9 = 38,
+    D0 = 39,
+    Return = 40,
+    Escape = 41,
+    Backspace = 42,
+    Tab = 43,
+    Space = 44,
+    Minus = 45,
+    Plus = 46,
+    OpenBracket = 47,
+    CloseBracket = 48,
+    Pipe = 49,
+    Tilde = 50,
+    Semicolon = 51,
+    Quote = 52,
+    Backquote = 53,
+    Comma = 54,
+    Period = 55,
+    Slash = 56,
+    CapsLock = 57,
+    F1 = 58,
+    F2 = 59,
+    F3 = 60,
+    F4 = 61,
+    F5 = 62,
+    F6 = 63,
+    F7 = 64,
+    F8 = 65,
+    F9 = 66,
+    F10 = 67,
+    F11 = 68,
+    F12 = 69,
+    PrintScreen = 70,
+    ScrollLock = 71,
+    Pause = 72,
+    Insert = 73,
+    Home = 74,
+    PageUp = 75,
+    Delete = 76,
+    End = 77,
+    PageDown = 78,
+    RightArrow = 79,
+    LeftArrow = 80,
+    DownArrow = 81,
+    UpArrow = 82,
+    NumLock = 83,
+    NumPadDivide = 84,
+    NumPadMultiply = 85,
+    NumPadSubtract = 86,
+    NumPadAdd = 87,
+    NumPadEnter = 88,
+    NumPad1 = 89,
+    NumPad2 = 90,
+    NumPad3 = 91,
+    NumPad4 = 92,
+    NumPad5 = 93,
+    NumPad6 = 94,
+    NumPad7 = 95,
+    NumPad8 = 96,
+    NumPad9 = 97,
+    NumPad0 = 98,
+    NumPadDot = 99,
+    Backslash = 100,
+    Application = 101,
+    Power = 102,
+    NumPadEquals = 103,
+    F13 = 104,
+    F14 = 105,
+    F15 = 106,
+    F16 = 107,
+    F17 = 108,
+    F18 = 109,
+    F19 = 110,
+    F20 = 111,
+    F21 = 112,
+    F22 = 113,
+    F23 = 114,
+    F24 = 115,
+    NumPadComma = 133,
+    Ro = 135,
+    KatakanaHiragana = 136,
+    Yen = 137,
+    Henkan = 138,
+    Muhenkan = 139,
+    NumPadCommaPc98 = 140,
+    HangulEnglish = 144,
+    Hanja = 145,
+    Katakana = 146,
+    Hiragana = 147,
+    ZenkakuHankaku = 148,
+    LeftControl = 224,
+    LeftShift = 225,
+    LeftAlt = 226,
+    LeftGui = 227,
+    RightControl = 228,
+    RightShift = 229,
+    RightAlt = 230,
+    RightGui = 231,
+};
+
 // This is nn::hid::NpadIdType
 enum class NpadIdType : u32 {
     Player1 = 0x0,
@@ -28,62 +217,6 @@ enum class NpadIdType : u32 {
     Invalid = 0xFFFFFFFF,
 };
 
-/// Converts a NpadIdType to an array index.
-constexpr size_t NpadIdTypeToIndex(NpadIdType npad_id_type) {
-    switch (npad_id_type) {
-    case NpadIdType::Player1:
-        return 0;
-    case NpadIdType::Player2:
-        return 1;
-    case NpadIdType::Player3:
-        return 2;
-    case NpadIdType::Player4:
-        return 3;
-    case NpadIdType::Player5:
-        return 4;
-    case NpadIdType::Player6:
-        return 5;
-    case NpadIdType::Player7:
-        return 6;
-    case NpadIdType::Player8:
-        return 7;
-    case NpadIdType::Handheld:
-        return 8;
-    case NpadIdType::Other:
-        return 9;
-    default:
-        return 0;
-    }
-}
-
-/// Converts an array index to a NpadIdType
-constexpr NpadIdType IndexToNpadIdType(size_t index) {
-    switch (index) {
-    case 0:
-        return NpadIdType::Player1;
-    case 1:
-        return NpadIdType::Player2;
-    case 2:
-        return NpadIdType::Player3;
-    case 3:
-        return NpadIdType::Player4;
-    case 4:
-        return NpadIdType::Player5;
-    case 5:
-        return NpadIdType::Player6;
-    case 6:
-        return NpadIdType::Player7;
-    case 7:
-        return NpadIdType::Player8;
-    case 8:
-        return NpadIdType::Handheld;
-    case 9:
-        return NpadIdType::Other;
-    default:
-        return NpadIdType::Invalid;
-    }
-}
-
 // This is nn::hid::NpadStyleIndex
 enum class NpadStyleIndex : u8 {
     None = 0,
@@ -124,6 +257,27 @@ enum class NpadStyleSet : u32 {
 };
 static_assert(sizeof(NpadStyleSet) == 4, "NpadStyleSet is an invalid size");
 
+// This is nn::hid::VibrationDevicePosition
+enum class VibrationDevicePosition : u32 {
+    None = 0,
+    Left = 1,
+    Right = 2,
+};
+
+// This is nn::hid::VibrationDeviceType
+enum class VibrationDeviceType : u32 {
+    Unknown = 0,
+    LinearResonantActuator = 1,
+    GcErm = 2,
+};
+
+// This is nn::hid::VibrationGcErmCommand
+enum class VibrationGcErmCommand : u64 {
+    Stop = 0,
+    Start = 1,
+    StopHard = 2,
+};
+
 // This is nn::hid::NpadStyleTag
 struct NpadStyleTag {
     union {
@@ -220,53 +374,6 @@ struct LedPattern {
     };
 };
 
-// This is nn::hid::NpadButton
-enum class NpadButton : u64 {
-    None = 0,
-    A = 1U << 0,
-    B = 1U << 1,
-    X = 1U << 2,
-    Y = 1U << 3,
-    StickL = 1U << 4,
-    StickR = 1U << 5,
-    L = 1U << 6,
-    R = 1U << 7,
-    ZL = 1U << 8,
-    ZR = 1U << 9,
-    Plus = 1U << 10,
-    Minus = 1U << 11,
-
-    Left = 1U << 12,
-    Up = 1U << 13,
-    Right = 1U << 14,
-    Down = 1U << 15,
-
-    StickLLeft = 1U << 16,
-    StickLUp = 1U << 17,
-    StickLRight = 1U << 18,
-    StickLDown = 1U << 19,
-
-    StickRLeft = 1U << 20,
-    StickRUp = 1U << 21,
-    StickRRight = 1U << 22,
-    StickRDown = 1U << 23,
-
-    LeftSL = 1U << 24,
-    LeftSR = 1U << 25,
-
-    RightSL = 1U << 26,
-    RightSR = 1U << 27,
-
-    Palma = 1U << 28,
-    Verification = 1U << 29,
-    HandheldLeftB = 1U << 30,
-    LagonCLeft = 1U << 31,
-    LagonCUp = 1ULL << 32,
-    LagonCRight = 1ULL << 33,
-    LagonCDown = 1ULL << 34,
-};
-DECLARE_ENUM_FLAG_OPERATORS(NpadButton);
-
 struct NpadButtonState {
     union {
         NpadButton raw{};
@@ -342,13 +449,6 @@ struct DebugPadButton {
 };
 static_assert(sizeof(DebugPadButton) == 0x4, "DebugPadButton is an invalid size");
 
-enum class DeviceIndex : u8 {
-    Left = 0,
-    Right = 1,
-    None = 2,
-    MaxDeviceIndex = 3,
-};
-
 // This is nn::hid::ConsoleSixAxisSensorHandle
 struct ConsoleSixAxisSensorHandle {
     u8 unknown_1;
@@ -383,20 +483,6 @@ struct VibrationDeviceHandle {
 };
 static_assert(sizeof(VibrationDeviceHandle) == 4, "SixAxisSensorHandle is an invalid size");
 
-// This is nn::hid::VibrationDeviceType
-enum class VibrationDeviceType : u32 {
-    Unknown = 0,
-    LinearResonantActuator = 1,
-    GcErm = 2,
-};
-
-// This is nn::hid::VibrationDevicePosition
-enum class VibrationDevicePosition : u32 {
-    None = 0,
-    Left = 1,
-    Right = 2,
-};
-
 // This is nn::hid::VibrationValue
 struct VibrationValue {
     f32 low_amplitude;
@@ -406,13 +492,6 @@ struct VibrationValue {
 };
 static_assert(sizeof(VibrationValue) == 0x10, "VibrationValue has incorrect size.");
 
-// This is nn::hid::VibrationGcErmCommand
-enum class VibrationGcErmCommand : u64 {
-    Stop = 0,
-    Start = 1,
-    StopHard = 2,
-};
-
 // This is nn::hid::VibrationDeviceInfo
 struct VibrationDeviceInfo {
     VibrationDeviceType type{};
@@ -482,4 +561,61 @@ struct MouseState {
     MouseAttribute attribute;
 };
 static_assert(sizeof(MouseState) == 0x28, "MouseState is an invalid size");
+
+/// Converts a NpadIdType to an array index.
+constexpr size_t NpadIdTypeToIndex(NpadIdType npad_id_type) {
+    switch (npad_id_type) {
+    case NpadIdType::Player1:
+        return 0;
+    case NpadIdType::Player2:
+        return 1;
+    case NpadIdType::Player3:
+        return 2;
+    case NpadIdType::Player4:
+        return 3;
+    case NpadIdType::Player5:
+        return 4;
+    case NpadIdType::Player6:
+        return 5;
+    case NpadIdType::Player7:
+        return 6;
+    case NpadIdType::Player8:
+        return 7;
+    case NpadIdType::Handheld:
+        return 8;
+    case NpadIdType::Other:
+        return 9;
+    default:
+        return 0;
+    }
+}
+
+/// Converts an array index to a NpadIdType
+constexpr NpadIdType IndexToNpadIdType(size_t index) {
+    switch (index) {
+    case 0:
+        return NpadIdType::Player1;
+    case 1:
+        return NpadIdType::Player2;
+    case 2:
+        return NpadIdType::Player3;
+    case 3:
+        return NpadIdType::Player4;
+    case 4:
+        return NpadIdType::Player5;
+    case 5:
+        return NpadIdType::Player6;
+    case 6:
+        return NpadIdType::Player7;
+    case 7:
+        return NpadIdType::Player8;
+    case 8:
+        return NpadIdType::Handheld;
+    case 9:
+        return NpadIdType::Other;
+    default:
+        return NpadIdType::Invalid;
+    }
+}
+
 } // namespace Core::HID
diff --git a/src/core/hle/service/hid/controllers/keyboard.cpp b/src/core/hle/service/hid/controllers/keyboard.cpp
index d6505dbc5..0ef8af0e6 100644
--- a/src/core/hle/service/hid/controllers/keyboard.cpp
+++ b/src/core/hle/service/hid/controllers/keyboard.cpp
@@ -42,6 +42,7 @@ void Controller_Keyboard::OnUpdate(const Core::Timing::CoreTiming& core_timing,
 
         next_state.key = keyboard_state;
         next_state.modifier = keyboard_modifier_state;
+        // This is always enabled on HW. Check what it actually does
         next_state.modifier.unknown.Assign(1);
     }
 
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 496b55d0e..e740b4331 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -35,8 +35,9 @@ namespace Service::HID {
 
 // Updating period for each HID device.
 // Period time is obtained by measuring the number of samples in a second on HW using a homebrew
-constexpr auto pad_update_ns = std::chrono::nanoseconds{4 * 1000 * 1000};    // (4ms, 250Hz)
-constexpr auto motion_update_ns = std::chrono::nanoseconds{5 * 1000 * 1000}; // (5ms, 200Hz)
+constexpr auto pad_update_ns = std::chrono::nanoseconds{4 * 1000 * 1000};      // (4ms, 250Hz)
+constexpr auto keyboard_update_ns = std::chrono::nanoseconds{8 * 1000 * 1000}; // (8ms, 125Hz)
+constexpr auto motion_update_ns = std::chrono::nanoseconds{5 * 1000 * 1000};   // (5ms, 200Hz)
 constexpr std::size_t SHARED_MEMORY_SIZE = 0x40000;
 
 IAppletResource::IAppletResource(Core::System& system_,
@@ -78,14 +79,21 @@ IAppletResource::IAppletResource(Core::System& system_,
             const auto guard = LockService();
             UpdateControllers(user_data, ns_late);
         });
+    keyboard_update_event = Core::Timing::CreateEvent(
+        "HID::UpdatekeyboardCallback",
+        [this](std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
+            const auto guard = LockService();
+            UpdateKeyboard(user_data, ns_late);
+        });
     motion_update_event = Core::Timing::CreateEvent(
-        "HID::MotionPadCallback",
+        "HID::UpdateMotionCallback",
         [this](std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
             const auto guard = LockService();
             UpdateMotion(user_data, ns_late);
         });
 
     system.CoreTiming().ScheduleEvent(pad_update_ns, pad_update_event);
+    system.CoreTiming().ScheduleEvent(keyboard_update_ns, keyboard_update_event);
     system.CoreTiming().ScheduleEvent(motion_update_ns, motion_update_event);
 
     system.HIDCore().ReloadInputDevices();
@@ -101,6 +109,7 @@ void IAppletResource::DeactivateController(HidController controller) {
 
 IAppletResource::~IAppletResource() {
     system.CoreTiming().UnscheduleEvent(pad_update_event, 0);
+    system.CoreTiming().UnscheduleEvent(keyboard_update_event, 0);
     system.CoreTiming().UnscheduleEvent(motion_update_event, 0);
 }
 
@@ -117,18 +126,36 @@ void IAppletResource::UpdateControllers(std::uintptr_t user_data,
     auto& core_timing = system.CoreTiming();
 
     for (const auto& controller : controllers) {
+        // Keyboard has it's own update event
+        if (controller == controllers[static_cast<size_t>(HidController::Keyboard)]) {
+            continue;
+        }
         controller->OnUpdate(core_timing, system.Kernel().GetHidSharedMem().GetPointer(),
                              SHARED_MEMORY_SIZE);
     }
 
     // If ns_late is higher than the update rate ignore the delay
-    if (ns_late > motion_update_ns) {
+    if (ns_late > pad_update_ns) {
         ns_late = {};
     }
 
     core_timing.ScheduleEvent(pad_update_ns - ns_late, pad_update_event);
 }
 
+void IAppletResource::UpdateKeyboard(std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
+    auto& core_timing = system.CoreTiming();
+
+    controllers[static_cast<size_t>(HidController::Keyboard)]->OnUpdate(
+        core_timing, system.Kernel().GetHidSharedMem().GetPointer(), SHARED_MEMORY_SIZE);
+
+    // If ns_late is higher than the update rate ignore the delay
+    if (ns_late > keyboard_update_ns) {
+        ns_late = {};
+    }
+
+    core_timing.ScheduleEvent(keyboard_update_ns - ns_late, keyboard_update_event);
+}
+
 void IAppletResource::UpdateMotion(std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
     auto& core_timing = system.CoreTiming();
 
diff --git a/src/core/hle/service/hid/hid.h b/src/core/hle/service/hid/hid.h
index 973e6a8ac..bbad165f8 100644
--- a/src/core/hle/service/hid/hid.h
+++ b/src/core/hle/service/hid/hid.h
@@ -70,11 +70,13 @@ private:
 
     void GetSharedMemoryHandle(Kernel::HLERequestContext& ctx);
     void UpdateControllers(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
+    void UpdateKeyboard(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
     void UpdateMotion(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
 
     KernelHelpers::ServiceContext& service_context;
 
     std::shared_ptr<Core::Timing::EventType> pad_update_event;
+    std::shared_ptr<Core::Timing::EventType> keyboard_update_event;
     std::shared_ptr<Core::Timing::EventType> motion_update_event;
 
     std::array<std::unique_ptr<ControllerBase>, static_cast<size_t>(HidController::MaxControllers)>