Reworked USB to have individual max packet sizes per endpoint or per type

itzandroidtab · itzandroidtab · commit 1321723ce449 · 2025-07-05T17:33:30.000+02:00
diff --git a/klib/usb/device/keyboard.hpp b/klib/usb/device/keyboard.hpp
@@ -966,7 +966,7 @@ namespace klib::usb::device {
                     break;
                 case hid::class_request::set_report:
                     // check if the packet length is not above the max endpoint size
-                    if (packet.wLength > Usb::max_endpoint_size) {
+                    if (packet.wLength > Usb::max_endpoint_size.size(usb::control_endpoint, klib::usb::descriptor::transfer_type::control)) {
                         // invalid length
                         return usb::handshake::stall;
                     }
diff --git a/klib/usb/device/mouse.hpp b/klib/usb/device/mouse.hpp
@@ -565,7 +565,7 @@ namespace klib::usb::device {
                     break;
                 case hid::class_request::set_report:
                     // check if the packet length is not above the max endpoint size
-                    if (packet.wLength > Usb::max_endpoint_size) {
+                    if (packet.wLength > Usb::max_endpoint_size.size(usb::control_endpoint, klib::usb::descriptor::transfer_type::control)) {
                         // invalid length
                         return usb::handshake::stall;
                     }
diff --git a/klib/usb/usb/size.hpp b/klib/usb/usb/size.hpp
@@ -0,0 +1,81 @@
+#ifndef KLIB_USB_SIZE_HPP
+#define KLIB_USB_SIZE_HPP
+
+#include <array>
+
+#include "descriptor.hpp"
+
+namespace klib::usb {
+    /**
+     * @brief Helper class to get the size of a specific endpoint by transfer type
+     * 
+     * @note Gives the same interface as the other classes in this file
+     * 
+     * @tparam Control 
+     * @tparam Isochronous 
+     * @tparam BulkSize 
+     * @tparam Interrupt 
+     */
+    template <
+        uint16_t Control,
+        uint16_t Isochronous,
+        uint16_t BulkSize,
+        uint16_t Interrupt
+    >
+    class endpoint_size_type {
+    protected:
+        // storage for all the sizes of every endpoint type
+        const std::array<uint16_t, 4> s = {
+            Control, Isochronous, BulkSize, Interrupt
+        };
+
+    public:
+        /**
+         * @brief Get the size of a endpoint
+         * 
+         * @param endpoint 
+         * @param type 
+         * @return constexpr auto 
+         */
+        constexpr auto size(const uint8_t endpoint, const descriptor::transfer_type& type) const {
+            return s[static_cast<uint8_t>(type)];
+        }
+    };
+
+    /**
+     * @brief Helper class to get the size of a specific endpoint by the endpoint number
+     * 
+     * @note Gives the same interface as the other classes in this file
+     * 
+     * @tparam EndpointCount 
+     * @tparam Values 
+     */
+    template <
+        uint8_t EndpointCount, 
+        uint16_t... Values
+    >
+    class endpoint_size_endpoint {
+    protected:
+        static_assert(sizeof...(Values) == EndpointCount, "Invalid endpoint sizes received");
+
+        // storage for all the endpoint sizes
+        const std::array<uint16_t, EndpointCount> s = {
+            Values...
+        };
+
+    public:
+        /**
+         * @brief Get the size of a endpoint
+         * 
+         * @param endpoint 
+         * @param type 
+         * @return constexpr auto 
+         */
+        constexpr auto size(const uint8_t endpoint, const descriptor::transfer_type& type) const {
+            return s[endpoint];
+        }
+    };
+}
+
+#endif
+
diff --git a/targets/chip/max32625/io/usb.hpp b/targets/chip/max32625/io/usb.hpp
@@ -96,8 +96,8 @@ namespace klib::max32625::io {
         // amount of endpoints supported by the max32625
         constexpr static uint8_t endpoint_count = 8;
 
-        // max size in a single endpoint
-        constexpr static uint8_t max_endpoint_size = 64;
+        // maximum endpoint sizes
+        constexpr static klib::usb::endpoint_size_type<64, 64, 64, 64> max_endpoint_size = {};
 
         // type to use in device functions
         using usb_type = usb<Usb, Device>;
@@ -697,7 +697,9 @@ namespace klib::max32625::io {
                 // set the endpoint to a known state
                 state[i] = {
                     .is_busy = false,
-                    .max_size = static_cast<uint8_t>((i == 0) ? max_endpoint_size : 0),
+                    .max_size = static_cast<uint8_t>(
+                        (i == 0) ? max_endpoint_size.size(0, klib::usb::descriptor::transfer_type::control) : 0
+                    ),
                     .requested_size = 0,
                     .transferred_size = 0,
                     .callback = nullptr
@@ -781,7 +783,7 @@ namespace klib::max32625::io {
             );
 
             // set the new endpoint size
-            state[endpoint].max_size = klib::min(max_endpoint_size, size);
+            state[endpoint].max_size = klib::min(size, max_endpoint_size.size(endpoint, type));
 
             // store the ctrl data in the endpoint
             (*ep) = ctrl;
diff --git a/targets/core/atmel/atsam4s/usb.hpp b/targets/core/atmel/atsam4s/usb.hpp
@@ -51,8 +51,10 @@ namespace klib::core::atsam4s::io {
         // amount of endpoints supported by the atsam4s
         constexpr static uint8_t endpoint_count = 8;
 
-        // max size in a single endpoint
-        constexpr static uint8_t max_endpoint_size = 64;
+        // maximum endpoint sizes
+        constexpr static klib::usb::endpoint_size_endpoint<endpoint_count, 
+            64, 64, 64, 64, 512, 512, 64, 64
+        > max_endpoint_size = {};
 
         // type to use in device functions
         using usb_type = usb<Usb, Device>;
@@ -564,7 +566,9 @@ namespace klib::core::atsam4s::io {
             for (uint32_t i = 0; i < endpoint_count; i++) {
                 // set the endpoint to a known state
                 state[i].is_busy = false;
-                state[i].max_size = static_cast<uint8_t>((i == 0) ? max_endpoint_size : 0);
+                state[i].max_size = static_cast<uint8_t>(
+                    (i == 0) ? max_endpoint_size.size(0, klib::usb::descriptor::transfer_type::control) : 0
+                );
                 state[i].data = nullptr;
                 state[i].requested_size = 0;
                 state[i].transferred_size = 0;
@@ -649,7 +653,7 @@ namespace klib::core::atsam4s::io {
             const klib::usb::descriptor::transfer_type type, const uint32_t size)
         {
             // set the new endpoint size
-            state[endpoint].max_size = size;
+            state[endpoint].max_size = klib::min(size, max_endpoint_size.size(endpoint, type));
 
             // reset the endpoint
             reset(endpoint, mode);
diff --git a/targets/core/cypress/mb9bf560l/usb.hpp b/targets/core/cypress/mb9bf560l/usb.hpp
@@ -4,10 +4,11 @@
 #include <span>
 
 #include <klib/klib.hpp>
-#include <klib/usb/usb/usb.hpp>
 #include <klib/math.hpp>
 #include <klib/irq_helper.hpp>
 #include <klib/usb/usb/setup.hpp>
+#include <klib/usb/usb/size.hpp>
+#include <klib/usb/usb/usb.hpp>
 
 #include <io/port.hpp>
 
@@ -51,8 +52,10 @@ namespace klib::core::mb9bf560l::io {
         // amount of endpoints supported by the lpc1756
         constexpr static uint8_t endpoint_count = 6;
 
-        // max size in a single endpoint
-        constexpr static uint8_t max_endpoint_size = 64;
+        // maximum endpoint sizes
+        constexpr static klib::usb::endpoint_size_endpoint<endpoint_count, 
+            64, 256, 64, 64, 64, 64
+        > max_endpoint_size = {};
 
         // type to use in device functions
         using usb_type = usb<Usb, Device>;
@@ -171,7 +174,7 @@ namespace klib::core::mb9bf560l::io {
             Usb::port->UDCC |= 0x1;
 
             // configure enpoint 0 endpoint size.
-            Usb::port->EP0C = max_endpoint_size;
+            Usb::port->EP0C = max_endpoint_size.size(0, klib::usb::descriptor::transfer_type::control);
 
             // clear the reset flag
             Usb::port->UDCC &= ~(0x1 << 7);
@@ -661,7 +664,9 @@ namespace klib::core::mb9bf560l::io {
             for (uint32_t i = 0; i < endpoint_count; i++) {
                 // set the endpoint to a known state
                 state[i].is_busy = false;
-                state[i].max_size = static_cast<uint8_t>((i == 0) ? max_endpoint_size : 0);
+                state[i].max_size = static_cast<uint8_t>(
+                    (i == 0) ? max_endpoint_size.size(0, klib::usb::descriptor::transfer_type::control) : 0
+                );
                 state[i].data = nullptr;
                 state[i].requested_size = 0;
                 state[i].transferred_size = 0;
@@ -765,7 +770,7 @@ namespace klib::core::mb9bf560l::io {
             const uint16_t s = size & (endpoint == 1 ? 0x1ff : 0x7f);
 
             // set the new endpoint size
-            state[endpoint].max_size = s;
+            state[endpoint].max_size = klib::min(s, max_endpoint_size.size(endpoint, type));
 
             // set the endpoint configuration
             (*ep_control) = (
diff --git a/targets/core/nxp/lpc17xx/usb.hpp b/targets/core/nxp/lpc17xx/usb.hpp
@@ -5,6 +5,7 @@
 
 #include <klib/klib.hpp>
 #include <klib/usb/usb/usb.hpp>
+#include <klib/usb/usb/size.hpp>
 #include <klib/math.hpp>
 
 #include <io/power.hpp>
@@ -51,8 +52,8 @@ namespace klib::core::lpc17xx::io {
         // amount of endpoints supported by the lpc1756
         constexpr static uint8_t endpoint_count = 16;
 
-        // max size in a control endpoint
-        constexpr static uint8_t max_control_endpoint_size = 64;
+        // maximum endpoint sizes
+        constexpr static klib::usb::endpoint_size_type<64, 1023, 64, 64> max_endpoint_size = {};
 
         // type to use in device functions
         using usb_type = usb<Usb, Device>;
@@ -178,9 +179,9 @@ namespace klib::core::lpc17xx::io {
 
         static void reset() {
             Usb::port->EPIND = 0;
-            Usb::port->MAXPSIZE = max_control_endpoint_size;
+            Usb::port->MAXPSIZE = max_endpoint_size.size(0, klib::usb::descriptor::transfer_type::control);
             Usb::port->EPIND = 1;
-            Usb::port->MAXPSIZE = max_control_endpoint_size;
+            Usb::port->MAXPSIZE = max_endpoint_size.size(0, klib::usb::descriptor::transfer_type::control);
 
             while ((Usb::port->DEVINTST & 0x100) == 0) {
                 // do nothing
@@ -733,7 +734,9 @@ namespace klib::core::lpc17xx::io {
             for (uint32_t i = 0; i < endpoint_count; i++) {
                 // set the endpoint to a known state
                 state[i].is_busy = false;
-                state[i].max_size = static_cast<uint8_t>((i == 0) ? max_control_endpoint_size : 0);
+                state[i].max_size = static_cast<uint8_t>(
+                    (i == 0) ? max_endpoint_size.size(0, klib::usb::descriptor::transfer_type::control) : 0
+                );
                 state[i].data = nullptr;
                 state[i].requested_size = 0;
                 state[i].transferred_size = 0;
@@ -853,7 +856,7 @@ namespace klib::core::lpc17xx::io {
             Usb::port->MAXPSIZE = size;
 
             // set the new endpoint size
-            state[endpoint].max_size = size;
+            state[endpoint].max_size = klib::min(size, max_endpoint_size.size(ep, type));
 
             // wait until the flag is updated
             while ((Usb::port->DEVINTST & 0x100) == 0) {

Original file line number	Diff line number	Diff line change
`@@ -966,7 +966,7 @@ namespace klib::usb::device {`
`966`	`966`	`break;`
`967`	`967`	`case hid::class_request::set_report:`
`968`	`968`	`// check if the packet length is not above the max endpoint size`
`969`		`- if (packet.wLength > Usb::max_endpoint_size) {`
	`969`	`+ if (packet.wLength > Usb::max_endpoint_size.size(usb::control_endpoint, klib::usb::descriptor::transfer_type::control)) {`
`970`	`970`	`// invalid length`
`971`	`971`	`return usb::handshake::stall;`
`972`	`972`	`}`
Original file line number	Diff line number	Diff line change
`@@ -565,7 +565,7 @@ namespace klib::usb::device {`
`565`	`565`	`break;`
`566`	`566`	`case hid::class_request::set_report:`
`567`	`567`	`// check if the packet length is not above the max endpoint size`
`568`		`- if (packet.wLength > Usb::max_endpoint_size) {`
	`568`	`+ if (packet.wLength > Usb::max_endpoint_size.size(usb::control_endpoint, klib::usb::descriptor::transfer_type::control)) {`
`569`	`569`	`// invalid length`
`570`	`570`	`return usb::handshake::stall;`
`571`	`571`	`}`