Merge remote-tracking branch 'adafruit/main' into busio-uart-rp

8 files changed, 359 insertions, 40 deletions

diff --git a/shared-module/_pixelbuf/PixelBuf.c b/shared-module/_pixelbuf/PixelBuf.c
index f3e679631..4cbf6dc21 100644
--- a/shared-module/_pixelbuf/PixelBuf.c
+++ b/shared-module/_pixelbuf/PixelBuf.c
@@ -31,6 +31,7 @@
 #include "py/runtime.h"
 #include "shared-bindings/_pixelbuf/PixelBuf.h"
 #include <string.h>
+#include <math.h>
 
 // Helper to ensure we have the native super class instead of a subclass.
 static pixelbuf_pixelbuf_obj_t* native_pixelbuf(mp_obj_t pixelbuf_obj) {
@@ -69,6 +70,7 @@ void common_hal__pixelbuf_pixelbuf_construct(pixelbuf_pixelbuf_obj_t *self, size
     }
     // Call set_brightness so that it can allocate a second buffer if needed.
     self->brightness = 1.0;
+    self->scaled_brightness = 0x100;
     common_hal__pixelbuf_pixelbuf_set_brightness(MP_OBJ_FROM_PTR(self), brightness);
 
     // Turn on auto_write. We don't want to do it with the above brightness call.
@@ -109,26 +111,32 @@ void common_hal__pixelbuf_pixelbuf_set_brightness(mp_obj_t self_in, mp_float_t b
     pixelbuf_pixelbuf_obj_t* self = native_pixelbuf(self_in);
     // Skip out if the brightness is already set. The default of self->brightness is 1.0. So, this
     // also prevents the pre_brightness_buffer allocation when brightness is set to 1.0 again.
-    mp_float_t change = brightness - self->brightness;
-    if (-0.001 < change && change < 0.001) {
+    self->brightness = brightness;
+    // Use 256 steps of brightness so that we can do integer math below.
+    uint16_t new_scaled_brightness = (uint16_t)(brightness * 256);
+    if (new_scaled_brightness == self->scaled_brightness) {
         return;
     }
-    self->brightness = brightness;
+    self->scaled_brightness = new_scaled_brightness;
     size_t pixel_len = self->pixel_count * self->bytes_per_pixel;
-    if (self->pre_brightness_buffer == NULL) {
-        self->pre_brightness_buffer = m_malloc(pixel_len, false);
-        memcpy(self->pre_brightness_buffer, self->post_brightness_buffer, pixel_len);
-    }
-    for (size_t i = 0; i < pixel_len; i++) {
-        // Don't adjust per-pixel luminance bytes in dotstar mode
-        if (self->byteorder.is_dotstar && i % 4 == 0) {
-            continue;
+    if (self->scaled_brightness == 0x100 && !self->pre_brightness_buffer) {
+        return;
+    } else {
+        if (self->pre_brightness_buffer == NULL) {
+            self->pre_brightness_buffer = m_malloc(pixel_len, false);
+            memcpy(self->pre_brightness_buffer, self->post_brightness_buffer, pixel_len);
+        }
+        for (size_t i = 0; i < pixel_len; i++) {
+            // Don't adjust per-pixel luminance bytes in dotstar mode
+            if (self->byteorder.is_dotstar && i % 4 == 0) {
+                continue;
+            }
+            self->post_brightness_buffer[i] = (self->pre_brightness_buffer[i] * self->scaled_brightness) / 256;
         }
-        self->post_brightness_buffer[i] = self->pre_brightness_buffer[i] * self->brightness;
-    }
 
-    if (self->auto_write) {
-        common_hal__pixelbuf_pixelbuf_show(self_in);
+        if (self->auto_write) {
+            common_hal__pixelbuf_pixelbuf_show(self_in);
+        }
     }
 }
 
@@ -197,28 +205,34 @@ void _pixelbuf_set_pixel_color(pixelbuf_pixelbuf_obj_t* self, size_t index, uint
     }
     pixelbuf_rgbw_t *rgbw_order = &self->byteorder.byteorder;
     size_t offset = index * self->bytes_per_pixel;
-    if (self->pre_brightness_buffer != NULL) {
-        uint8_t* pre_brightness_buffer = self->pre_brightness_buffer + offset;
-        if (self->bytes_per_pixel == 4) {
-            pre_brightness_buffer[rgbw_order->w] = w;
-        }
-
-        pre_brightness_buffer[rgbw_order->r] = r;
-        pre_brightness_buffer[rgbw_order->g] = g;
-        pre_brightness_buffer[rgbw_order->b] = b;
+    uint8_t *scaled_buffer, *unscaled_buffer;
+    if (self->pre_brightness_buffer) {
+        scaled_buffer = self->post_brightness_buffer + offset;
+        unscaled_buffer = self->pre_brightness_buffer + offset;
+    } else {
+        scaled_buffer = NULL;
+        unscaled_buffer = self->post_brightness_buffer + offset;
     }
 
-    uint8_t* post_brightness_buffer = self->post_brightness_buffer + offset;
     if (self->bytes_per_pixel == 4) {
-        // Only apply brightness if w is actually white (aka not DotStar.)
-        if (!self->byteorder.is_dotstar) {
-            w *= self->brightness;
+        unscaled_buffer[rgbw_order->w] = w;
+    }
+
+    unscaled_buffer[rgbw_order->r] = r;
+    unscaled_buffer[rgbw_order->g] = g;
+    unscaled_buffer[rgbw_order->b] = b;
+
+    if (scaled_buffer) {
+        if (self->bytes_per_pixel == 4) {
+            if (!self->byteorder.is_dotstar) {
+                w = (w * self->scaled_brightness) / 256;
+            }
+            scaled_buffer[rgbw_order->w] = w;
         }
-        post_brightness_buffer[rgbw_order->w] = w;
+        scaled_buffer[rgbw_order->r] = (r * self->scaled_brightness) / 256;
+        scaled_buffer[rgbw_order->g] = (g * self->scaled_brightness) / 256;
+        scaled_buffer[rgbw_order->b] = (b * self->scaled_brightness) / 256;
     }
-    post_brightness_buffer[rgbw_order->r] = r * self->brightness;
-    post_brightness_buffer[rgbw_order->g] = g * self->brightness;
-    post_brightness_buffer[rgbw_order->b] = b * self->brightness;
 }
 
 void _pixelbuf_set_pixel(pixelbuf_pixelbuf_obj_t* self, size_t index, mp_obj_t value) {
diff --git a/shared-module/_pixelbuf/PixelBuf.h b/shared-module/_pixelbuf/PixelBuf.h
index a9fbed366..f0c80bcad 100644
--- a/shared-module/_pixelbuf/PixelBuf.h
+++ b/shared-module/_pixelbuf/PixelBuf.h
@@ -49,7 +49,8 @@ typedef struct {
 typedef struct {
     mp_obj_base_t base;
     size_t pixel_count;
-    size_t bytes_per_pixel;
+    uint16_t bytes_per_pixel;
+    uint16_t scaled_brightness;
     pixelbuf_byteorder_details_t byteorder;
     mp_float_t brightness;
     mp_obj_t transmit_buffer_obj;
diff --git a/shared-module/displayio/Bitmap.c b/shared-module/displayio/Bitmap.c
index d1942efc7..cf34f2d35 100644
--- a/shared-module/displayio/Bitmap.c
+++ b/shared-module/displayio/Bitmap.c
@@ -116,14 +116,33 @@ void common_hal_displayio_bitmap_blit(displayio_bitmap_t *self, int16_t x, int16
         mp_raise_RuntimeError(translate("Read-only object"));
     }
 
+    bool x_reverse = false;
+    bool y_reverse = false;
+
+    // Add reverse direction option to protect blitting of self bitmap back into self bitmap
+    if (x > x1) {
+        x_reverse = true;
+    }
+    if (y > y1) {
+        y_reverse = true;
+    }
+
     // simplest version - use internal functions for get/set pixels
-    for (int16_t i=0; i < (x2-x1) ; i++) {
-        if ( (x+i >= 0) && (x+i < self->width) ) {
+    for (int16_t i=0; i < (x2-x1); i++) {
+
+        const int xs_index = x_reverse ? ( (x2 - 1) - i ) : x1+i; // x-index into the source bitmap
+        const int xd_index = x_reverse ? ((x + (x2-x1)) - i ) : x+i; // x-index into the destination bitmap
+
+        if ( (xd_index >= 0) && (xd_index < self->width) ) {
             for (int16_t j=0; j < (y2-y1) ; j++){
-                if ((y+j >= 0) && (y+j < self->height) ) {
-                    uint32_t value = common_hal_displayio_bitmap_get_pixel(source, x1+i, y1+j);
+
+                const int ys_index = y_reverse ? ( (y2 - 1) - j ) : y1+j ; // y-index into the source bitmap
+                const int yd_index = y_reverse ? ((y + (y2-y1)) - j ) : y+j ; // y-index into the destination bitmap
+
+                if ((yd_index >= 0) && (yd_index < self->height) ) {
+                    uint32_t value = common_hal_displayio_bitmap_get_pixel(source, xs_index, ys_index);
                     if ( (skip_index_none) || (value != skip_index) ) { // write if skip_value_none is True
-                            common_hal_displayio_bitmap_set_pixel(self, x+i, y+j, value);
+                            common_hal_displayio_bitmap_set_pixel(self, xd_index, yd_index, value);
                     }
                 }
             }
diff --git a/shared-module/usb_cdc/Serial.c b/shared-module/usb_cdc/Serial.c
new file mode 100644
index 000000000..b4d8667ca
--- /dev/null
+++ b/shared-module/usb_cdc/Serial.c
@@ -0,0 +1,149 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 Dan Halbert for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "lib/utils/interrupt_char.h"
+#include "shared-module/usb_cdc/Serial.h"
+#include "supervisor/shared/tick.h"
+
+#include "tusb.h"
+
+size_t common_hal_usb_cdc_serial_read(usb_cdc_serial_obj_t *self, uint8_t *data, size_t len, int *errcode) {
+
+    const bool wait_forever = self->timeout < 0.0f;
+    const bool wait_for_timeout = self->timeout > 0.0f;
+
+    // Read up to len bytes immediately.
+    // The number of bytes read will not be larger than what is already in the TinyUSB FIFO.
+    uint32_t total_num_read = tud_cdc_n_read(self->idx, data, len);
+
+    if (wait_forever || wait_for_timeout) {
+        // Read more if we have time.
+        // Use special routine to avoid pulling in uint64-float-compatible math routines.
+        uint64_t timeout_ms = float_to_uint64(self->timeout * 1000);  // Junk value if timeout < 0.
+        uint64_t start_ticks = supervisor_ticks_ms64();
+
+        uint32_t num_read = 0;
+        while (total_num_read < len &&
+               (wait_forever || supervisor_ticks_ms64() - start_ticks <= timeout_ms)) {
+
+            // Wait for a bit, and check for ctrl-C.
+            RUN_BACKGROUND_TASKS;
+            if (mp_hal_is_interrupted()) {
+                return 0;
+            }
+
+            // Advance buffer pointer and reduce number of bytes that need to be read.
+            len -= num_read;
+            data += num_read;
+
+            // Try to read another batch of bytes.
+            num_read = tud_cdc_n_read(self->idx, data, len);
+            total_num_read += num_read;
+        }
+    }
+
+    return total_num_read;
+}
+
+size_t common_hal_usb_cdc_serial_write(usb_cdc_serial_obj_t *self, const uint8_t *data, size_t len, int *errcode) {
+    const bool wait_forever = self->write_timeout < 0.0f;
+    const bool wait_for_timeout = self->write_timeout > 0.0f;
+
+    // Write as many bytes as possible immediately.
+    // The number of bytes written at once will not be larger than what can fit in the TinyUSB FIFO.
+    uint32_t total_num_written = tud_cdc_n_write(self->idx, data, len);
+    tud_cdc_n_write_flush(self->idx);
+
+    if (wait_forever || wait_for_timeout) {
+        // Write more if we have time.
+        // Use special routine to avoid pulling in uint64-float-compatible math routines.
+        uint64_t timeout_ms = float_to_uint64(self->write_timeout * 1000);  // Junk value if write_timeout < 0.
+        uint64_t start_ticks = supervisor_ticks_ms64();
+
+        uint32_t num_written = 0;
+        while (total_num_written < len &&
+               (wait_forever || supervisor_ticks_ms64() - start_ticks <= timeout_ms)) {
+
+            // Wait for a bit, and check for ctrl-C.
+            RUN_BACKGROUND_TASKS;
+            if (mp_hal_is_interrupted()) {
+                return 0;
+            }
+
+            // Advance buffer pointer and reduce number of bytes that need to be written.
+            len -= num_written;
+            data += num_written;
+
+            // Try to write another batch of bytes.
+            num_written = tud_cdc_n_write(self->idx, data, len);
+            tud_cdc_n_write_flush(self->idx);
+            total_num_written += num_written;
+        }
+    }
+
+    return total_num_written;
+}
+
+uint32_t common_hal_usb_cdc_serial_get_in_waiting(usb_cdc_serial_obj_t *self) {
+    return tud_cdc_n_available(self->idx);
+}
+
+uint32_t common_hal_usb_cdc_serial_get_out_waiting(usb_cdc_serial_obj_t *self) {
+    // Return number of FIFO bytes currently occupied.
+    return CFG_TUD_CDC_TX_BUFSIZE - tud_cdc_n_write_available(self->idx);
+}
+
+void common_hal_usb_cdc_serial_reset_input_buffer(usb_cdc_serial_obj_t *self) {
+    tud_cdc_n_read_flush(self->idx);
+}
+
+uint32_t common_hal_usb_cdc_serial_reset_output_buffer(usb_cdc_serial_obj_t *self) {
+    return tud_cdc_n_write_clear(self->idx);
+}
+
+uint32_t common_hal_usb_cdc_serial_flush(usb_cdc_serial_obj_t *self) {
+    return tud_cdc_n_write_flush(self->idx);
+}
+
+bool common_hal_usb_cdc_serial_get_connected(usb_cdc_serial_obj_t *self) {
+    return tud_cdc_n_connected(self->idx);
+}
+
+mp_float_t common_hal_usb_cdc_serial_get_timeout(usb_cdc_serial_obj_t *self) {
+    return self->timeout;
+}
+
+void common_hal_usb_cdc_serial_set_timeout(usb_cdc_serial_obj_t *self, mp_float_t timeout) {
+    self->timeout = timeout;
+}
+
+mp_float_t common_hal_usb_cdc_serial_get_write_timeout(usb_cdc_serial_obj_t *self) {
+    return self->write_timeout;
+}
+
+void common_hal_usb_cdc_serial_set_write_timeout(usb_cdc_serial_obj_t *self, mp_float_t write_timeout) {
+    self->write_timeout = write_timeout;
+}
diff --git a/shared-module/usb_cdc/Serial.h b/shared-module/usb_cdc/Serial.h
new file mode 100644
index 000000000..ddf78eefa
--- /dev/null
+++ b/shared-module/usb_cdc/Serial.h
@@ -0,0 +1,39 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 Dan Halbert for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef SHARED_MODULE_USB_CDC_SERIAL_H
+#define SHARED_MODULE_USB_CDC_SERIAL_H
+
+#include "py/obj.h"
+
+typedef struct {
+    mp_obj_base_t base;
+    mp_float_t timeout;       // if negative, wait forever.
+    mp_float_t write_timeout; // if negative, wait forever.
+    uint8_t idx;              // which CDC device?
+} usb_cdc_serial_obj_t;
+
+#endif // SHARED_MODULE_USB_CDC_SERIAL_H
diff --git a/shared-module/usb_cdc/__init__.c b/shared-module/usb_cdc/__init__.c
new file mode 100644
index 000000000..fe05cb107
--- /dev/null
+++ b/shared-module/usb_cdc/__init__.c
@@ -0,0 +1,61 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 Dan Halbert for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "genhdr/autogen_usb_descriptor.h"
+#include "py/gc.h"
+#include "py/obj.h"
+#include "py/mphal.h"
+#include "py/runtime.h"
+#include "py/objtuple.h"
+#include "shared-bindings/usb_cdc/__init__.h"
+#include "shared-bindings/usb_cdc/Serial.h"
+#include "tusb.h"
+
+#if CFG_TUD_CDC != 2
+#error CFG_TUD_CDC must be exactly 2
+#endif
+
+static usb_cdc_serial_obj_t serial_objs[CFG_TUD_CDC] = {
+    {   .base.type = &usb_cdc_serial_type,
+        .timeout = -1.0f,
+        .write_timeout = -1.0f,
+        .idx = 0,
+    }, {
+        .base.type = &usb_cdc_serial_type,
+        .timeout = -1.0f,
+        .write_timeout = -1.0f,
+        .idx = 1,
+    }
+};
+
+const mp_rom_obj_tuple_t usb_cdc_serials_tuple = {
+    .base.type = &mp_type_tuple,
+    .len = CFG_TUD_CDC,
+    .items = {
+        &serial_objs[0],
+        &serial_objs[1],
+    },
+};
diff --git a/shared-module/usb_cdc/__init__.h b/shared-module/usb_cdc/__init__.h
new file mode 100644
index 000000000..9de3eb2fa
--- /dev/null
+++ b/shared-module/usb_cdc/__init__.h
@@ -0,0 +1,34 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2021 Dan Halbert for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef SHARED_MODULE_USB_CDC___INIT___H
+#define SHARED_MODULE_USB_CDC___INIT___H
+
+#include "py/objtuple.h"
+
+extern const mp_rom_obj_tuple_t usb_cdc_serials_tuple;
+
+#endif /* SHARED_MODULE_USB_CDC___INIT___H */
diff --git a/shared-module/usb_hid/Device.c b/shared-module/usb_hid/Device.c
index 943c9bfed..2b560c328 100644
--- a/shared-module/usb_hid/Device.c
+++ b/shared-module/usb_hid/Device.c
@@ -73,7 +73,8 @@ static usb_hid_device_obj_t* get_hid_device(uint8_t report_id) {
 }
 
 // Callbacks invoked when receive Get_Report request through control endpoint
-uint16_t tud_hid_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen) {
+uint16_t tud_hid_get_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen) {
+    (void) itf;
     // only support Input Report
     if ( report_type != HID_REPORT_TYPE_INPUT ) return 0;
 
@@ -83,7 +84,8 @@ uint16_t tud_hid_get_report_cb(uint8_t report_id, hid_report_type_t report_type,
 }
 
 // Callbacks invoked when receive Set_Report request through control endpoint
-void tud_hid_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize) {
+void tud_hid_set_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize) {
+    (void) itf;
     if (report_type == HID_REPORT_TYPE_INVALID) {
         report_id = buffer[0];
         buffer++;