define boot protocol compatible report layouts explicitly

Author: benedekkupper

hid-rp/hid/app/keyboard.hpp

@@ -40,7 +40,7 @@ template <uint8_t REPORT_ID = 0, std::size_t ROLLOVER_LIMIT = 6>
 }
 
 template <std::uint8_t REPORT_ID = 0, std::size_t ROLLOVER_LIMIT = 6>
-struct keys_input_report : public hid::report::base<hid::report::type::INPUT, REPORT_ID>
+struct keys_input_report : hid::report::base<hid::report::type::INPUT, REPORT_ID>
 {
     hid::report_bitset<page::keyboard_keypad, page::keyboard_keypad::KEYBOARD_LEFT_CONTROL,
                        page::keyboard_keypad::KEYBOARD_RIGHT_GUI>
@@ -74,6 +74,18 @@ struct keys_input_report : public hid::report::base<hid::report::type::INPUT, RE
         }
         return false;
     }
+
+    static constexpr boot::mode boot_mode()
+        requires((REPORT_ID == 0) and (ROLLOVER_LIMIT == 6))
+    {
+        return boot::mode::KEYBOARD;
+    }
+};
+
+// Boot protocol has predefined report layout
+struct boot_input_report final : keys_input_report<0, 6>
+{
+    using keys_input_report::keys_input_report;
 };
 
 template <uint8_t REPORT_ID>
@@ -97,9 +109,21 @@ template <uint8_t REPORT_ID>
 }
 
 template <uint8_t REPORT_ID = 0>
-struct output_report : public hid::report::base<hid::report::type::OUTPUT, REPORT_ID>
+struct output_report : hid::report::base<hid::report::type::OUTPUT, REPORT_ID>
 {
     hid::report_bitset<page::leds, page::leds::NUM_LOCK, page::leds::KANA> leds;
+
+    static constexpr boot::mode boot_mode()
+        requires(REPORT_ID == 0)
+    {
+        return boot::mode::KEYBOARD;
+    }
+};
+
+// Boot protocol has predefined report layout
+struct boot_output_report final : output_report<0>
+{
+    using output_report::output_report;
 };
 
 template <uint8_t REPORT_ID = 0>

hid-rp/hid/app/mouse.hpp

@@ -22,6 +22,18 @@ struct report : public hid::report::base<hid::report::type::INPUT, REPORT_ID>
         x = 0;
         y = 0;
     }
+
+    static constexpr boot::mode boot_mode()
+        requires((REPORT_ID == 0) and (BUTTONS_COUNT == 3))
+    {
+        return boot::mode::MOUSE;
+    }
+};
+
+// Boot protocol has predefined report layout
+struct boot_report final : report<0, 3>
+{
+    using report::report;
 };
 
 template <uint8_t REPORT_ID = 0, std::size_t BUTTONS_COUNT = 3>

hid-rp/hid/report.hpp

@@ -147,5 +147,18 @@ static_assert(base<type::OUTPUT, 0x42>::selector() == selector(0x242));
 
 template <class T, report::type TYPE = T::type(), id::type REPORT_ID = T::ID>
 concept Data = std::is_base_of_v<base<TYPE, REPORT_ID>, T>;
+
+template <class T>
+concept BootCompatibleData =
+    Data<T> and std::convertible_to<decltype(T::selector()), report::selector> and
+    std::convertible_to<decltype(T::boot_mode()), boot::mode> and
+    (((sizeof(T) == 8) and (T::boot_mode() == boot::mode::KEYBOARD) and
+      (T::selector().type() == type::INPUT)) or
+     ((sizeof(T) == 1) and (T::boot_mode() == boot::mode::KEYBOARD) and
+      (T::selector().type() == type::OUTPUT)) or
+     ((sizeof(T) == 3) and (T::boot_mode() == boot::mode::MOUSE) and
+      (T::selector().type() == type::INPUT)));
+
 } // namespace report
+
 } // namespace hid

hid-rp/hid/report_array.hpp

@@ -22,7 +22,7 @@ class report_array
     bool set(T usage, bool value = true)
     {
         auto num = static_cast<numeric_type>(usage);
-        auto it = std::find(arr_.begin(), arr_.end(), value ? static_cast<numeric_type>(0) : num);
+        auto* it = std::find(arr_.begin(), arr_.end(), value ? static_cast<numeric_type>(0) : num);
         if (it != arr_.end())
         {
             *it = value ? num : static_cast<numeric_type>(0);

test/keyboard.cpp

@@ -4,6 +4,7 @@
 #include "test_framework.hpp"
 
 using namespace hid::app::keyboard;
+using namespace hid::page;
 
 SUITE(keyboard_)
 {
@@ -54,4 +55,31 @@ SUITE(keyboard_)
         CHECK(hid::rdf::get_application_usage_id(hid::rdf::descriptor_view(desc5)) ==
               hid::page::generic_desktop::KEYBOARD);
     };
+
+    TEST_CASE("report structures")
+    {
+        static_assert(keys_input_report<0>::type() == hid::report::type::INPUT);
+        static_assert(keys_input_report<0>::ID == 0);
+        static_assert(keys_input_report<0>::has_id() == false);
+        static_assert(keys_input_report<0>::selector() ==
+                      hid::report::selector(hid::report::type::INPUT, 0));
+        static_assert(hid::report::BootCompatibleData<boot_input_report>);
+        static_assert(not hid::report::BootCompatibleData<keys_input_report<5>>);
+
+        keys_input_report<0> report0;
+        report0.set_key_state(keyboard_keypad::KEYBOARD_LEFT_CONTROL, true);
+        report0.set_key_state(keyboard_keypad::KEYBOARD_RIGHT_GUI, true);
+        report0.set_key_state(keyboard_keypad::KEYPAD_HEXADECIMAL, true);
+        CHECK(report0.modifiers.test(keyboard_keypad::KEYBOARD_LEFT_CONTROL));
+        CHECK(report0.modifiers.test(keyboard_keypad::KEYBOARD_RIGHT_GUI));
+        CHECK(report0.scancodes.test(keyboard_keypad::KEYPAD_HEXADECIMAL));
+
+        static_assert(output_report<5>::type() == hid::report::type::OUTPUT);
+        static_assert(output_report<5>::ID == 5);
+        static_assert(output_report<5>::has_id() == true);
+        static_assert(output_report<5>::selector() ==
+                      hid::report::selector(hid::report::type::OUTPUT, 5));
+        static_assert(hid::report::BootCompatibleData<boot_output_report>);
+        static_assert(not hid::report::BootCompatibleData<output_report<5>>);
+    };
 };