12 years ago · 3d81d5221e
--- a/common/keyboard.c
+++ b/common/keyboard.c
 uint8_t fn_bits = 0;
 #ifdef EXTRAKEY_ENABLE
 uint16_t consumer_code = 0;
 uint16_t system_code = 0;
 #endif
 matrix_scan();
 #ifdef HOST_PJRC
 if (suspend && remote_wakeup) {
 usb_remote_wakeup();
 } else {
 host_system_send(SYSTEM_POWER_DOWN);
 }
 #else
 host_system_send(SYSTEM_POWER_DOWN);
 #endif
 host_system_send(0);
 _delay_ms(500);
 system_code = SYSTEM_POWER_DOWN;
 } else if (code == KB_SYSTEM_SLEEP) {
 host_system_send(SYSTEM_SLEEP);
 host_system_send(0);
 _delay_ms(500);
 system_code = SYSTEM_SLEEP;
 } else if (code == KB_SYSTEM_WAKE) {
 host_system_send(SYSTEM_WAKE_UP);
 host_system_send(0);
 _delay_ms(500);
 system_code = SYSTEM_WAKE_UP;
 }
 // Consumer Page
 else if (code == KB_AUDIO_MUTE) {
 host_send_keyboard_report();
 #ifdef EXTRAKEY_ENABLE
 host_consumer_send(consumer_code);
 host_system_send(system_code);
 #endif
 #ifdef DEBUG_LED
 // LED flash for debug
--- a/common/mousekey.c
+++ b/common/mousekey.c
 static void mousekey_debug(void)
 {
 if (!debug_mouse) return;
 print("mousekey[btn|x y v h]: ");
 print("mousekey [btn|x y v h]rep: [");
 phex(report.buttons); print("|");
 phex(report.x); print(" ");
 phex(report.y); print(" ");
 phex(report.v); print(" ");
 phex(report.h);
 phex(report.h); print("]");
 phex(mousekey_repeat);
 print("\n");
 }
--- a/keyboard/lufa/Makefile
+++ b/keyboard/lufa/Makefile
 SRC = $(subst $(LUFA_PATH)/LUFA/,,$(LUFA_SRC))
 SRC += keymap.c \
 matrix.c \
 led.c
 led.c \
 pjrc/bootloader_teensy.c
 CONFIG_H = config.h
 #
 MOUSEKEY_ENABLE = yes # Mouse keys
 #PS2_MOUSE_ENABLE = yes # PS/2 mouse(TrackPoint) support
 #EXTRAKEY_ENABLE = yes # Audio control and System control
 EXTRAKEY_ENABLE = yes # Audio control and System control
 #NKRO_ENABLE = yes # USB Nkey Rollover
--- a/keyboard/lufa/config.h
+++ b/keyboard/lufa/config.h
 /* USB Device descriptor */
 #define VENDOR_ID 0xFEED
 #define PRODUCT_ID 0xBEE1
 #define DEVICE_VER 0x0101
 #define PRODUCT_ID 0xBEE6
 #define DEVICE_VER 0x0202
 #define MANUFACTURER t.m.k.
 #define PRODUCT Macway mod(LUFA)
--- a/keyboard/lufa/descriptor.c
+++ b/keyboard/lufa/descriptor.c
 */
 #include "util.h"
 #include "report.h"
 #include "descriptor.h"
 HID_RI_COLLECTION(8, 0x01), /* Application */
 HID_RI_USAGE(8, 0x01), /* Pointer */
 HID_RI_COLLECTION(8, 0x00), /* Physical */
 HID_RI_USAGE_PAGE(8, 0x09), /* Button */
 HID_RI_USAGE_MINIMUM(8, 0x01),
 HID_RI_USAGE_MAXIMUM(8, 0x03),
 HID_RI_USAGE_MINIMUM(8, 0x01), /* Button 1 */
 HID_RI_USAGE_MAXIMUM(8, 0x05), /* Button 5 */
 HID_RI_LOGICAL_MINIMUM(8, 0x00),
 HID_RI_LOGICAL_MAXIMUM(8, 0x01),
 HID_RI_REPORT_COUNT(8, 0x03),
 HID_RI_REPORT_COUNT(8, 0x05),
 HID_RI_REPORT_SIZE(8, 0x01),
 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
 HID_RI_REPORT_COUNT(8, 0x01),
 HID_RI_REPORT_SIZE(8, 0x05),
 HID_RI_REPORT_SIZE(8, 0x03),
 HID_RI_INPUT(8, HID_IOF_CONSTANT),
 HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
 HID_RI_USAGE(8, 0x30), /* Usage X */
 HID_RI_USAGE(8, 0x31), /* Usage Y */
 HID_RI_LOGICAL_MINIMUM(8, -1),
 HID_RI_LOGICAL_MAXIMUM(8, 1),
 HID_RI_PHYSICAL_MINIMUM(8, -1),
 HID_RI_PHYSICAL_MAXIMUM(8, 1),
 HID_RI_LOGICAL_MINIMUM(8, -127),
 HID_RI_LOGICAL_MAXIMUM(8, 127),
 HID_RI_REPORT_COUNT(8, 0x02),
 HID_RI_REPORT_SIZE(8, 0x08),
 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),
 HID_RI_USAGE(8, 0x38), /* Wheel */
 HID_RI_LOGICAL_MINIMUM(8, -127),
 HID_RI_LOGICAL_MAXIMUM(8, 127),
 HID_RI_REPORT_COUNT(8, 0x01),
 HID_RI_REPORT_SIZE(8, 0x08),
 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),
 HID_RI_USAGE_PAGE(8, 0x0C), /* Consumer */
 HID_RI_USAGE(16, 0x0238), /* AC Pan (Horizontal wheel) */
 HID_RI_LOGICAL_MINIMUM(8, -127),
 HID_RI_LOGICAL_MAXIMUM(8, 127),
 HID_RI_REPORT_COUNT(8, 0x01),
 HID_RI_REPORT_SIZE(8, 0x08),
 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),
 HID_RI_END_COLLECTION(0),
 HID_RI_END_COLLECTION(0),
 };
 {
 HID_RI_USAGE_PAGE(16, 0xFF00), /* Vendor Page 0 */
 HID_RI_USAGE(8, 0x01), /* Vendor Usage 1 */
 HID_RI_COLLECTION(8, 0x01), /* Vendor Usage 1 */
 HID_RI_COLLECTION(8, 0x01), /* Application */
 HID_RI_USAGE(8, 0x02), /* Vendor Usage 2 */
 HID_RI_LOGICAL_MINIMUM(8, 0x00),
 HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
 HID_RI_REPORT_SIZE(8, 0x08),
 HID_RI_REPORT_COUNT(8, GENERIC_REPORT_SIZE),
 HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
 HID_RI_USAGE(8, 0x03), /* Vendor Usage 3 */
 HID_RI_LOGICAL_MINIMUM(8, 0x00),
 HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
 HID_RI_REPORT_SIZE(8, 0x08),
 HID_RI_REPORT_COUNT(8, GENERIC_REPORT_SIZE),
 HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
 HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
 HID_RI_END_COLLECTION(0),
 };
 const USB_Descriptor_HIDReport_Datatype_t PROGMEM ExtraReport[] =
 {
 HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
 HID_RI_USAGE(8, 0x80), /* System Control */
 HID_RI_COLLECTION(8, 0x01), /* Application */
 HID_RI_REPORT_ID(8, REPORT_ID_SYSTEM),
 HID_RI_LOGICAL_MINIMUM(16, 0x0081),
 HID_RI_LOGICAL_MAXIMUM(16, 0x00B7),
 HID_RI_USAGE_MINIMUM(16, 0x0081), /* System Power Down */
 HID_RI_USAGE_MAXIMUM(16, 0x00B7), /* System Display LCD Autoscale */
 HID_RI_REPORT_SIZE(8, 16),
 HID_RI_REPORT_COUNT(8, 1),
 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
 HID_RI_END_COLLECTION(0),
 HID_RI_USAGE_PAGE(8, 0x0C), /* Consumer */
 HID_RI_USAGE(8, 0x01), /* Consumer Control */
 HID_RI_COLLECTION(8, 0x01), /* Application */
 HID_RI_REPORT_ID(8, REPORT_ID_CONSUMER),
 HID_RI_LOGICAL_MINIMUM(16, 0x0010),
 HID_RI_LOGICAL_MAXIMUM(16, 0x029C),
 HID_RI_USAGE_MINIMUM(16, 0x0010), /* +10 */
 HID_RI_USAGE_MAXIMUM(16, 0x029C), /* AC Distribute Vertically */
 HID_RI_REPORT_SIZE(8, 16),
 HID_RI_REPORT_COUNT(8, 1),
 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
 HID_RI_END_COLLECTION(0),
 };
 /*******************************************************************************
 * Device Descriptors
 .Header = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},
 .TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
 .TotalInterfaces = 3,
 .TotalInterfaces = TOTAL_INTERFACES,
 .ConfigurationNumber = 1,
 .ConfigurationStrIndex = NO_DESCRIPTOR,
 .MaxPowerConsumption = USB_CONFIG_POWER_MA(100)
 },
  /*
  * Keyboard
  */
 /*
 * Keyboard
 */
 .Keyboard_Interface =
 {
 .Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
 .EndpointAddress = (ENDPOINT_DIR_IN | KEYBOARD_IN_EPNUM),
 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 .EndpointSize = HID_EPSIZE,
 .EndpointSize = KEYBOARD_EPSIZE,
 .PollingIntervalMS = 0x01
 },
 .EndpointAddress = (ENDPOINT_DIR_IN | MOUSE_IN_EPNUM),
 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 .EndpointSize = HID_EPSIZE,
 .EndpointSize = MOUSE_EPSIZE,
 .PollingIntervalMS = 0x01
 },
 {
 .Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
 .InterfaceNumber = GENERIC_INTERFACE,
 .InterfaceNumber = CONSOLE_INTERFACE,
 .AlternateSetting = 0x00,
 .TotalEndpoints = 2,
 {
 .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
 .EndpointAddress = (ENDPOINT_DIR_IN | GENERIC_IN_EPNUM),
 .EndpointAddress = (ENDPOINT_DIR_IN | CONSOLE_IN_EPNUM),
 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 .EndpointSize = GENERIC_EPSIZE,
 .EndpointSize = CONSOLE_EPSIZE,
 .PollingIntervalMS = 0x01
 },
 {
 .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
 .EndpointAddress = (ENDPOINT_DIR_OUT | GENERIC_OUT_EPNUM),
 .EndpointAddress = (ENDPOINT_DIR_OUT | CONSOLE_OUT_EPNUM),
 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 .EndpointSize = CONSOLE_EPSIZE,
 .PollingIntervalMS = 0x01
 },
 /*
 * Extra
 */
 .Extra_Interface =
 {
 .Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
 .InterfaceNumber = EXTRA_INTERFACE,
 .AlternateSetting = 0x00,
 .TotalEndpoints = 1,
 .Class = HID_CSCP_HIDClass,
 .SubClass = HID_CSCP_NonBootSubclass,
 .Protocol = HID_CSCP_NonBootProtocol,
 .InterfaceStrIndex = NO_DESCRIPTOR
 },
 .Extra_HID =
 {
 .Header = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
 .HIDSpec = VERSION_BCD(01.11),
 .CountryCode = 0x00,
 .TotalReportDescriptors = 1,
 .HIDReportType = HID_DTYPE_Report,
 .HIDReportLength = sizeof(ExtraReport)
 },
 .Extra_INEndpoint =
 {
 .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
 .EndpointAddress = (ENDPOINT_DIR_IN | EXTRA_IN_EPNUM),
 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
 .EndpointSize = GENERIC_EPSIZE,
 .EndpointSize = EXTRA_EPSIZE,
 .PollingIntervalMS = 0x01
 }
 },
 };
 Address = &ConfigurationDescriptor.Mouse_HID;
 Size = sizeof(USB_HID_Descriptor_HID_t);
 break;
 case GENERIC_INTERFACE:
 case CONSOLE_INTERFACE:
 Address = &ConfigurationDescriptor.Console_HID;
 Size = sizeof(USB_HID_Descriptor_HID_t);
 break;
 case EXTRA_INTERFACE:
 Address = &ConfigurationDescriptor.Extra_HID;
 Size = sizeof(USB_HID_Descriptor_HID_t);
 break;
 }
 break;
 case HID_DTYPE_Report:
 Address = &MouseReport;
 Size = sizeof(MouseReport);
 break;
 case GENERIC_INTERFACE:
 case CONSOLE_INTERFACE:
 Address = &ConsoleReport;
 Size = sizeof(ConsoleReport);
 break;
 case EXTRA_INTERFACE:
 Address = &ExtraReport;
 Size = sizeof(ExtraReport);
 break;
 }
 break;
 }
--- a/keyboard/lufa/descriptor.h
+++ b/keyboard/lufa/descriptor.h
 USB_HID_Descriptor_HID_t Console_HID;
 USB_Descriptor_Endpoint_t Console_INEndpoint;
 USB_Descriptor_Endpoint_t Console_OUTEndpoint;
 // Extra HID Interface
 USB_Descriptor_Interface_t Extra_Interface;
 USB_HID_Descriptor_HID_t Extra_HID;
 USB_Descriptor_Endpoint_t Extra_INEndpoint;
 } USB_Descriptor_Configuration_t;
 /* nubmer of interfaces */
 #define TOTAL_INTERFACES 4
 /* index of interface */
 #define KEYBOARD_INTERFACE 0
 #define MOUSE_INTERFACE 1
 #define GENERIC_INTERFACE 2
 #define CONSOLE_INTERFACE 2
 #define EXTRA_INTERFACE 3
 // Endopoint number/size
 // Endopoint number and size
 #define KEYBOARD_IN_EPNUM 1
 #define MOUSE_IN_EPNUM 2
 #define GENERIC_IN_EPNUM 3
 #define GENERIC_OUT_EPNUM 4
 #define HID_EPSIZE 8
 #define GENERIC_EPSIZE 8
 #define GENERIC_REPORT_SIZE 8
 #define CONSOLE_IN_EPNUM 3
 #define CONSOLE_OUT_EPNUM 4
 #define EXTRA_IN_EPNUM 5
 #define KEYBOARD_EPSIZE 8
 #define MOUSE_EPSIZE 8
 #define CONSOLE_EPSIZE 8
 #define EXTRA_EPSIZE 8
 uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
--- a/keyboard/lufa/keymap.c
+++ b/keyboard/lufa/keymap.c
 * | |Gui |Alt | |Alt |Gui| | |Ctr|
 * `-----------------------------------------------------------'
 */ 
 KEYMAP(ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, DEL, \
 KEYMAP(PWR, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, DEL, \
 CAPS,NO, NO, NO, NO, NO, NO, NO, PSCR,SLCK,BRK, UP, NO, NO, \
 LCTL,VOLD,VOLU,MUTE,NO, NO, PAST,PSLS,HOME,PGUP,LEFT,RGHT,ENT, \
 LSFT,NO, NO, NO, NO, NO, PPLS,PMNS,END, PGDN,DOWN,RSFT,FN1, \
--- a/keyboard/lufa/lufa.c
+++ b/keyboard/lufa/lufa.c
 return;
 // TODO: impl receivechar()/recvchar()
 Endpoint_SelectEndpoint(GENERIC_OUT_EPNUM);
 Endpoint_SelectEndpoint(CONSOLE_OUT_EPNUM);
 /* Check to see if a packet has been sent from the host */
 if (Endpoint_IsOUTReceived())
 if (Endpoint_IsReadWriteAllowed())
 {
 /* Create a temporary buffer to hold the read in report from the host */
 uint8_t ConsoleData[GENERIC_REPORT_SIZE];
 uint8_t ConsoleData[CONSOLE_EPSIZE];
 /* Read Console Report Data */
 Endpoint_Read_Stream_LE(&ConsoleData, sizeof(ConsoleData), NULL);
 }
 /* IN packet */
 Endpoint_SelectEndpoint(GENERIC_IN_EPNUM);
 Endpoint_SelectEndpoint(CONSOLE_IN_EPNUM);
 // send IN packet
 if (Endpoint_IsINReady())
 Endpoint_ClearIN();
 /* Setup Keyboard HID Report Endpoints */
 ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 HID_EPSIZE, ENDPOINT_BANK_SINGLE);
 KEYBOARD_EPSIZE, ENDPOINT_BANK_SINGLE);
 /* Setup Mouse HID Report Endpoint */
 ConfigSuccess &= Endpoint_ConfigureEndpoint(MOUSE_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 HID_EPSIZE, ENDPOINT_BANK_SINGLE);
 MOUSE_EPSIZE, ENDPOINT_BANK_SINGLE);
 /* Setup Console HID Report Endpoints */
 ConfigSuccess &= Endpoint_ConfigureEndpoint(GENERIC_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 GENERIC_EPSIZE, ENDPOINT_BANK_SINGLE);
 ConfigSuccess &= Endpoint_ConfigureEndpoint(GENERIC_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
 GENERIC_EPSIZE, ENDPOINT_BANK_SINGLE);
 ConfigSuccess &= Endpoint_ConfigureEndpoint(CONSOLE_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 CONSOLE_EPSIZE, ENDPOINT_BANK_SINGLE);
 ConfigSuccess &= Endpoint_ConfigureEndpoint(CONSOLE_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
 CONSOLE_EPSIZE, ENDPOINT_BANK_SINGLE);
 /* Setup Extra HID Report Endpoint */
 ConfigSuccess &= Endpoint_ConfigureEndpoint(EXTRA_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 EXTRA_EPSIZE, ENDPOINT_BANK_SINGLE);
 }
 /*
 ReportData = (uint8_t*)&mouse_report_sent;
 ReportSize = sizeof(mouse_report_sent);
 break;
 case GENERIC_INTERFACE:
 case CONSOLE_INTERFACE:
 break;
 case EXTRA_INTERFACE:
 break;
 }
 break;
 case MOUSE_INTERFACE:
 break;
 case GENERIC_INTERFACE:
 case CONSOLE_INTERFACE:
 break;
 case EXTRA_INTERFACE:
 break;
 }
 if (Endpoint_IsReadWriteAllowed())
 {
 /* Write Mouse Report Data */
 /* Mouse report data structure
 * LUFA: { buttons, x, y }
 * tmk: { buttons, x, y, v, h }
 */
 //Endpoint_Write_Stream_LE((uint8_t *)report+1, 3, NULL);
 Endpoint_Write_Stream_LE(report, 3, NULL);
 Endpoint_Write_Stream_LE(report, sizeof(report_mouse_t), NULL);
 /* Finalize the stream transfer to send the last packet */
 Endpoint_ClearIN();
 mouse_report_sent = *report;
 }
 typedef struct {
 uint8_t report_id;
 uint16_t usage;
 } __attribute__ ((packed)) report_extra_t;
 static void send_system(uint16_t data)
 {
 Endpoint_SelectEndpoint(EXTRA_IN_EPNUM);
 if (Endpoint_IsReadWriteAllowed()) {
 report_extra_t r = {
 .report_id = REPORT_ID_SYSTEM,
 .usage = data
 };
 Endpoint_Write_Stream_LE(&r, sizeof(report_extra_t), NULL);
 Endpoint_ClearIN();
 }
 }
 static void send_consumer(uint16_t data)
 {
 Endpoint_SelectEndpoint(EXTRA_IN_EPNUM);
 if (Endpoint_IsReadWriteAllowed()) {
 report_extra_t r = {
 .report_id = REPORT_ID_CONSUMER,
 .usage = data
 };
 Endpoint_Write_Stream_LE(&r, sizeof(report_extra_t), NULL);
 Endpoint_ClearIN();
 }
 }
 if (USB_DeviceState != DEVICE_STATE_Configured)
 return -1;
 Endpoint_SelectEndpoint(GENERIC_IN_EPNUM);
 Endpoint_SelectEndpoint(CONSOLE_IN_EPNUM);
 uint8_t timeout = 10;
 uint16_t prevFN = USB_Device_GetFrameNumber();
--- a/protocol/vusb/main.c
+++ b/protocol/vusb/main.c
 debug("initForUsbConnectivity()\n");
 initForUsbConnectivity();
 int i;
 while(--i){ /* To configured */
 usbPoll();
 _delay_ms(1);
 }
 debug("main loop\n");
 while (1) {
--- a/protocol/vusb/vusb.c
+++ b/protocol/vusb/vusb.c
 }
 }
 /*
 typedef struct {
 uint8_t report_id;
 uint8_t data0;
 uint8_t data1;
 } __attribute__ ((packed)) vusb_system_report_t;
 */
 uint8_t report_id;
 uint16_t usage;
 } __attribute__ ((packed)) report_extra_t;
 static void send_system(uint16_t data)
 {
 /*
 // Not need static?
 static uint8_t report[] = { REPORT_ID_SYSTEM, 0, 0 };
 report[1] = data&0xFF;
 report[2] = (data>>8)&0xFF;
 */
 /*
 vusb_system_report_t r = {
 static uint16_t last_data = 0;
 if (data == last_data) return;
 last_data = data;
 report_extra_t report = {
 .report_id = REPORT_ID_SYSTEM,
 .data0 = data&0xFF,
 .data1 = (data>>8)&0xFF
 .usage = data
 };
 if (usbInterruptIsReady3()) {
 usbSetInterrupt3((void *)&r, sizeof(vusb_system_report_t));
 usbSetInterrupt3((void *)&report, sizeof(report));
 }
 */
 }
 static void send_consumer(uint16_t data)
 if (data == last_data) return;
 last_data = data;
 // Not need static?
 static uint8_t report[] = { REPORT_ID_CONSUMER, 0, 0 };
 report[1] = data&0xFF;
 report[2] = (data>>8)&0xFF;
 report_extra_t report = {
  .report_id = REPORT_ID_CONSUMER,
  .usage = data
 };
 if (usbInterruptIsReady3()) {
 usbSetInterrupt3((void *)&report, sizeof(report));
 }