qmk-dactyl-manuform-a/tmk_core/protocol/lufa/lufa.c

1015 lines
29 KiB
C
Raw Normal View History

/*
* Copyright 2012 Jun Wako <wakojun@gmail.com>
* This file is based on:
* LUFA-120219/Demos/Device/Lowlevel/KeyboardMouse
* LUFA-120219/Demos/Device/Lowlevel/GenericHID
*/
/*
LUFA Library
Copyright (C) Dean Camera, 2012.
dean [at] fourwalledcubicle [dot] com
www.lufa-lib.org
*/
/*
Copyright 2012 Dean Camera (dean [at] fourwalledcubicle [dot] com)
Copyright 2010 Denver Gingerich (denver [at] ossguy [dot] com)
Permission to use, copy, modify, distribute, and sell this
software and its documentation for any purpose is hereby granted
without fee, provided that the above copyright notice appear in
all copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
The author disclaim all warranties with regard to this
software, including all implied warranties of merchantability
and fitness. In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/
#include "report.h"
#include "host.h"
#include "host_driver.h"
#include "keyboard.h"
#include "action.h"
#include "led.h"
#include "sendchar.h"
#include "debug.h"
#ifdef SLEEP_LED_ENABLE
2019-08-30 20:19:03 +02:00
# include "sleep_led.h"
#endif
2013-03-26 08:55:45 +01:00
#include "suspend.h"
Merge ChibiOS and LUFA descriptor support (#2362) * Move lufa descriptor to protocol/usb_descriptor * Try to compile usb_descriptor on ChibiOS * Add lufa_utils for ChibiOS Lufa USB descriptors for ChibiOS * More lufa_util compatibility fixes * First compiling version of shared USB descriptor * Send the usb descriptors * Fix the CONSOLE output on ChibiOS * Add errors for unsupported interfaces * Enable support for vitual serial port USB descriptors * Implement virtual serial port for ChibiOS * Cleanup the lufa_utils Use the default lufa header files * Add raw hid support for ChibiOS This is completely untested * Enable midi compilation on ChibiOS * Move midi functionality out of lufa.c * Don't register sysex callback when not needed * ChibiOS compilation fixes * Update ChibiOS submodule * Fix the Midi USB descriptor It didn't work properly when both Midi and Virtual serial port was enabled. * Add MIDI support for ChibiOS * Fix USB descriptor strings on ChibiOS * Use serial usb driver for raw hid * Generalize the ChibiOS stream like drivers This makes the initialization much more simple and eliminates a lot of the code duplication. * Convert console output to chibios stream driver * Fixes for ChibiOS update * Update the ChibiOS contrib submodule To include the usb data toggle synchronization fixes * Fix duplicate reset enumeration on ChibiOS * Add missing include * Add number of endpoints check for ChibiOS * Enable serial USB driver on all keyboards * Add missing includes when API is enabled withot midi * Add another missing inlcude
2018-02-08 21:07:46 +01:00
#include "usb_descriptor.h"
#include "lufa.h"
2016-11-17 23:42:14 +01:00
#include "quantum.h"
#include <util/atomic.h>
#include "outputselect.h"
2015-10-24 02:12:04 +02:00
#ifdef NKRO_ENABLE
2019-08-30 20:19:03 +02:00
# include "keycode_config.h"
2019-08-30 20:19:03 +02:00
extern keymap_config_t keymap_config;
#endif
2016-01-20 06:06:52 +01:00
#ifdef AUDIO_ENABLE
2019-08-30 20:19:03 +02:00
# include <audio.h>
2015-10-24 02:12:04 +02:00
#endif
#ifdef BLUETOOTH_ENABLE
2019-08-30 20:19:03 +02:00
# ifdef MODULE_ADAFRUIT_BLE
# include "adafruit_ble.h"
# else
# include "bluetooth.h"
# endif
#endif
2016-08-01 07:02:52 +02:00
#ifdef VIRTSER_ENABLE
2019-08-30 20:19:03 +02:00
# include "virtser.h"
2016-08-01 07:02:52 +02:00
#endif
2016-11-23 06:30:06 +01:00
#ifdef MIDI_ENABLE
2019-08-30 20:19:03 +02:00
# include "qmk_midi.h"
2016-11-23 06:30:06 +01:00
#endif
2016-11-28 08:31:16 +01:00
#ifdef RAW_ENABLE
2019-08-30 20:19:03 +02:00
# include "raw_hid.h"
2016-11-28 08:31:16 +01:00
#endif
uint8_t keyboard_idle = 0;
/* 0: Boot Protocol, 1: Report Protocol(default) */
2019-08-30 20:19:03 +02:00
uint8_t keyboard_protocol = 1;
static uint8_t keyboard_led_stats = 0;
static report_keyboard_t keyboard_report_sent;
2012-06-29 09:48:36 +02:00
/* Host driver */
static uint8_t keyboard_leds(void);
2019-08-30 20:19:03 +02:00
static void send_keyboard(report_keyboard_t *report);
static void send_mouse(report_mouse_t *report);
static void send_system(uint16_t data);
static void send_consumer(uint16_t data);
host_driver_t lufa_driver = {
keyboard_leds, send_keyboard, send_mouse, send_system, send_consumer,
};
2016-08-01 07:02:52 +02:00
#ifdef VIRTSER_ENABLE
2019-08-30 20:19:03 +02:00
USB_ClassInfo_CDC_Device_t cdc_device = {
.Config =
{
.ControlInterfaceNumber = CCI_INTERFACE,
.DataINEndpoint =
{
.Address = CDC_IN_EPADDR,
.Size = CDC_EPSIZE,
.Banks = 1,
},
.DataOUTEndpoint =
{
.Address = CDC_OUT_EPADDR,
.Size = CDC_EPSIZE,
.Banks = 1,
},
.NotificationEndpoint =
{
.Address = CDC_NOTIFICATION_EPADDR,
.Size = CDC_NOTIFICATION_EPSIZE,
.Banks = 1,
},
},
2016-08-01 07:02:52 +02:00
};
#endif
2016-11-28 08:31:16 +01:00
#ifdef RAW_ENABLE
/** \brief Raw HID Send
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
void raw_hid_send(uint8_t *data, uint8_t length) {
// TODO: implement variable size packet
if (length != RAW_EPSIZE) {
return;
}
if (USB_DeviceState != DEVICE_STATE_Configured) {
return;
}
// TODO: decide if we allow calls to raw_hid_send() in the middle
// of other endpoint usage.
uint8_t ep = Endpoint_GetCurrentEndpoint();
Endpoint_SelectEndpoint(RAW_IN_EPNUM);
// Check to see if the host is ready to accept another packet
if (Endpoint_IsINReady()) {
// Write data
Endpoint_Write_Stream_LE(data, RAW_EPSIZE, NULL);
// Finalize the stream transfer to send the last packet
Endpoint_ClearIN();
}
Endpoint_SelectEndpoint(ep);
2016-11-28 08:31:16 +01:00
}
/** \brief Raw HID Receive
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
__attribute__((weak)) void raw_hid_receive(uint8_t *data, uint8_t length) {
// Users should #include "raw_hid.h" in their own code
// and implement this function there. Leave this as weak linkage
// so users can opt to not handle data coming in.
2016-11-28 08:31:16 +01:00
}
/** \brief Raw HID Task
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
static void raw_hid_task(void) {
// Create a temporary buffer to hold the read in data from the host
uint8_t data[RAW_EPSIZE];
bool data_read = false;
// Device must be connected and configured for the task to run
if (USB_DeviceState != DEVICE_STATE_Configured) return;
Endpoint_SelectEndpoint(RAW_OUT_EPNUM);
// Check to see if a packet has been sent from the host
if (Endpoint_IsOUTReceived()) {
// Check to see if the packet contains data
if (Endpoint_IsReadWriteAllowed()) {
/* Read data */
Endpoint_Read_Stream_LE(data, sizeof(data), NULL);
data_read = true;
}
// Finalize the stream transfer to receive the last packet
Endpoint_ClearOUT();
if (data_read) {
raw_hid_receive(data, sizeof(data));
}
}
2016-11-28 08:31:16 +01:00
}
#endif
2015-08-21 16:46:53 +02:00
/*******************************************************************************
* Console
******************************************************************************/
#ifdef CONSOLE_ENABLE
/** \brief Console Task
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
static void Console_Task(void) {
/* Device must be connected and configured for the task to run */
2019-08-30 20:19:03 +02:00
if (USB_DeviceState != DEVICE_STATE_Configured) return;
uint8_t ep = Endpoint_GetCurrentEndpoint();
2019-08-30 20:19:03 +02:00
# if 0
// TODO: impl receivechar()/recvchar()
Endpoint_SelectEndpoint(CONSOLE_OUT_EPNUM);
/* Check to see if a packet has been sent from the host */
if (Endpoint_IsOUTReceived())
{
/* Check to see if the packet contains data */
if (Endpoint_IsReadWriteAllowed())
{
/* Create a temporary buffer to hold the read in report from the host */
uint8_t ConsoleData[CONSOLE_EPSIZE];
/* Read Console Report Data */
Endpoint_Read_Stream_LE(&ConsoleData, sizeof(ConsoleData), NULL);
/* Process Console Report Data */
//ProcessConsoleHIDReport(ConsoleData);
}
/* Finalize the stream transfer to send the last packet */
Endpoint_ClearOUT();
}
2019-08-30 20:19:03 +02:00
# endif
/* IN packet */
Endpoint_SelectEndpoint(CONSOLE_IN_EPNUM);
if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) {
Endpoint_SelectEndpoint(ep);
return;
}
// fill empty bank
2019-08-30 20:19:03 +02:00
while (Endpoint_IsReadWriteAllowed()) Endpoint_Write_8(0);
// flash senchar packet
if (Endpoint_IsINReady()) {
Endpoint_ClearIN();
}
Endpoint_SelectEndpoint(ep);
}
#endif
/*******************************************************************************
* USB Events
******************************************************************************/
/*
* Event Order of Plug in:
* 0) EVENT_USB_Device_Connect
* 1) EVENT_USB_Device_Suspend
* 2) EVENT_USB_Device_Reset
* 3) EVENT_USB_Device_Wake
2019-08-30 20:19:03 +02:00
*/
/** \brief Event USB Device Connect
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
void EVENT_USB_Device_Connect(void) {
print("[C]");
/* For battery powered device */
if (!USB_IsInitialized) {
USB_Disable();
USB_Init();
USB_Device_EnableSOFEvents();
}
}
/** \brief Event USB Device Connect
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
void EVENT_USB_Device_Disconnect(void) {
print("[D]");
/* For battery powered device */
USB_IsInitialized = false;
2019-08-30 20:19:03 +02:00
/* TODO: This doesn't work. After several plug in/outs can not be enumerated.
if (USB_IsInitialized) {
USB_Disable(); // Disable all interrupts
USB_Controller_Enable();
USB_INT_Enable(USB_INT_VBUSTI);
}
*/
}
/** \brief Event USB Device Connect
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
void EVENT_USB_Device_Reset(void) { print("[R]"); }
2013-03-13 08:01:53 +01:00
/** \brief Event USB Device Connect
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
void EVENT_USB_Device_Suspend() {
print("[S]");
#ifdef SLEEP_LED_ENABLE
sleep_led_enable();
#endif
2013-03-13 08:01:53 +01:00
}
/** \brief Event USB Device Connect
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
void EVENT_USB_Device_WakeUp() {
print("[W]");
2013-03-26 08:55:45 +01:00
suspend_wakeup_init();
#ifdef SLEEP_LED_ENABLE
sleep_led_disable();
// NOTE: converters may not accept this
led_set(host_keyboard_leds());
#endif
2013-03-13 08:01:53 +01:00
}
#ifdef CONSOLE_ENABLE
static bool console_flush = false;
2019-08-30 20:19:03 +02:00
# define CONSOLE_FLUSH_SET(b) \
do { \
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { console_flush = b; } \
} while (0)
/** \brief Event USB Device Start Of Frame
*
* FIXME: Needs doc
* called every 1ms
*/
2019-08-30 20:19:03 +02:00
void EVENT_USB_Device_StartOfFrame(void) {
static uint8_t count;
if (++count % 50) return;
count = 0;
if (!console_flush) return;
Console_Task();
console_flush = false;
}
2016-11-28 08:31:16 +01:00
#endif
/** \brief Event handler for the USB_ConfigurationChanged event.
*
* This is fired when the host sets the current configuration of the USB device after enumeration.
*
* ATMega32u2 supports dual bank(ping-pong mode) only on endpoint 3 and 4,
* it is safe to use single bank for all endpoints.
*/
2019-08-30 20:19:03 +02:00
void EVENT_USB_Device_ConfigurationChanged(void) {
bool ConfigSuccess = true;
/* Setup Keyboard HID Report Endpoints */
Use a single endpoint for HID reports (#3951) * Unify multiple HID interfaces into one This reduces the number of USB endpoints required, which frees them up for other things. NKRO and EXTRAKEY always use the shared endpoint. By default, MOUSEKEY also uses it. This means it won't work as a Boot Procotol mouse in some BIOSes, etc. If you really think your keyboard needs to work as a mouse in your BIOS, set MOUSE_SHARED_EP = no in your rules.mk. By default, the core keyboard does not use the shared endpoint, as not all BIOSes are standards compliant and that's one place you don't want to find out your keyboard doesn't work.. If you are really confident, you can set KEYBOARD_SHARED_EP = yes to use the shared endpoint here too. * unify endpoints: ChibiOS protocol implementation * fixup: missing #ifdef EXTRAKEY_ENABLEs broke build on AVR with EXTRAKEY disabled * endpoints: restore error when too many endpoints required * lufa: wait up to 10ms to send keyboard input This avoids packets being dropped when two reports are sent in quick succession (eg. releasing a dual role key). * endpoints: fix compile on ARM_ATSAM * endpoint: ARM_ATSAM fixes No longer use wrong or unexpected endpoint IDs * endpoints: accommodate VUSB protocol V-USB has its own, understandably simple ideas about the report formats. It already blasts the mouse and extrakeys through one endpoint with report IDs. We just stay out of its way. * endpoints: document new endpoint configuration options * endpoints: respect keyboard_report->mods in NKRO The caller(s) of host_keyboard_send expect to be able to just drop modifiers in the mods field and not worry about whether NKRO is in use. This is a good thing. So we just shift it over if needs be. * endpoints: report.c: update for new keyboard_report format
2018-11-16 07:22:05 +01:00
#ifndef KEYBOARD_SHARED_EP
2019-08-30 20:19:03 +02:00
ConfigSuccess &= ENDPOINT_CONFIG(KEYBOARD_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN, KEYBOARD_EPSIZE, ENDPOINT_BANK_SINGLE);
Use a single endpoint for HID reports (#3951) * Unify multiple HID interfaces into one This reduces the number of USB endpoints required, which frees them up for other things. NKRO and EXTRAKEY always use the shared endpoint. By default, MOUSEKEY also uses it. This means it won't work as a Boot Procotol mouse in some BIOSes, etc. If you really think your keyboard needs to work as a mouse in your BIOS, set MOUSE_SHARED_EP = no in your rules.mk. By default, the core keyboard does not use the shared endpoint, as not all BIOSes are standards compliant and that's one place you don't want to find out your keyboard doesn't work.. If you are really confident, you can set KEYBOARD_SHARED_EP = yes to use the shared endpoint here too. * unify endpoints: ChibiOS protocol implementation * fixup: missing #ifdef EXTRAKEY_ENABLEs broke build on AVR with EXTRAKEY disabled * endpoints: restore error when too many endpoints required * lufa: wait up to 10ms to send keyboard input This avoids packets being dropped when two reports are sent in quick succession (eg. releasing a dual role key). * endpoints: fix compile on ARM_ATSAM * endpoint: ARM_ATSAM fixes No longer use wrong or unexpected endpoint IDs * endpoints: accommodate VUSB protocol V-USB has its own, understandably simple ideas about the report formats. It already blasts the mouse and extrakeys through one endpoint with report IDs. We just stay out of its way. * endpoints: document new endpoint configuration options * endpoints: respect keyboard_report->mods in NKRO The caller(s) of host_keyboard_send expect to be able to just drop modifiers in the mods field and not worry about whether NKRO is in use. This is a good thing. So we just shift it over if needs be. * endpoints: report.c: update for new keyboard_report format
2018-11-16 07:22:05 +01:00
#endif
Use a single endpoint for HID reports (#3951) * Unify multiple HID interfaces into one This reduces the number of USB endpoints required, which frees them up for other things. NKRO and EXTRAKEY always use the shared endpoint. By default, MOUSEKEY also uses it. This means it won't work as a Boot Procotol mouse in some BIOSes, etc. If you really think your keyboard needs to work as a mouse in your BIOS, set MOUSE_SHARED_EP = no in your rules.mk. By default, the core keyboard does not use the shared endpoint, as not all BIOSes are standards compliant and that's one place you don't want to find out your keyboard doesn't work.. If you are really confident, you can set KEYBOARD_SHARED_EP = yes to use the shared endpoint here too. * unify endpoints: ChibiOS protocol implementation * fixup: missing #ifdef EXTRAKEY_ENABLEs broke build on AVR with EXTRAKEY disabled * endpoints: restore error when too many endpoints required * lufa: wait up to 10ms to send keyboard input This avoids packets being dropped when two reports are sent in quick succession (eg. releasing a dual role key). * endpoints: fix compile on ARM_ATSAM * endpoint: ARM_ATSAM fixes No longer use wrong or unexpected endpoint IDs * endpoints: accommodate VUSB protocol V-USB has its own, understandably simple ideas about the report formats. It already blasts the mouse and extrakeys through one endpoint with report IDs. We just stay out of its way. * endpoints: document new endpoint configuration options * endpoints: respect keyboard_report->mods in NKRO The caller(s) of host_keyboard_send expect to be able to just drop modifiers in the mods field and not worry about whether NKRO is in use. This is a good thing. So we just shift it over if needs be. * endpoints: report.c: update for new keyboard_report format
2018-11-16 07:22:05 +01:00
#if defined(MOUSE_ENABLE) && !defined(MOUSE_SHARED_EP)
/* Setup Mouse HID Report Endpoint */
2019-08-30 20:19:03 +02:00
ConfigSuccess &= ENDPOINT_CONFIG(MOUSE_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN, MOUSE_EPSIZE, ENDPOINT_BANK_SINGLE);
#endif
Use a single endpoint for HID reports (#3951) * Unify multiple HID interfaces into one This reduces the number of USB endpoints required, which frees them up for other things. NKRO and EXTRAKEY always use the shared endpoint. By default, MOUSEKEY also uses it. This means it won't work as a Boot Procotol mouse in some BIOSes, etc. If you really think your keyboard needs to work as a mouse in your BIOS, set MOUSE_SHARED_EP = no in your rules.mk. By default, the core keyboard does not use the shared endpoint, as not all BIOSes are standards compliant and that's one place you don't want to find out your keyboard doesn't work.. If you are really confident, you can set KEYBOARD_SHARED_EP = yes to use the shared endpoint here too. * unify endpoints: ChibiOS protocol implementation * fixup: missing #ifdef EXTRAKEY_ENABLEs broke build on AVR with EXTRAKEY disabled * endpoints: restore error when too many endpoints required * lufa: wait up to 10ms to send keyboard input This avoids packets being dropped when two reports are sent in quick succession (eg. releasing a dual role key). * endpoints: fix compile on ARM_ATSAM * endpoint: ARM_ATSAM fixes No longer use wrong or unexpected endpoint IDs * endpoints: accommodate VUSB protocol V-USB has its own, understandably simple ideas about the report formats. It already blasts the mouse and extrakeys through one endpoint with report IDs. We just stay out of its way. * endpoints: document new endpoint configuration options * endpoints: respect keyboard_report->mods in NKRO The caller(s) of host_keyboard_send expect to be able to just drop modifiers in the mods field and not worry about whether NKRO is in use. This is a good thing. So we just shift it over if needs be. * endpoints: report.c: update for new keyboard_report format
2018-11-16 07:22:05 +01:00
#ifdef SHARED_EP_ENABLE
/* Setup Shared HID Report Endpoint */
2019-08-30 20:19:03 +02:00
ConfigSuccess &= ENDPOINT_CONFIG(SHARED_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN, SHARED_EPSIZE, ENDPOINT_BANK_SINGLE);
#endif
2016-11-28 08:31:16 +01:00
#ifdef RAW_ENABLE
/* Setup Raw HID Report Endpoints */
2019-08-30 20:19:03 +02:00
ConfigSuccess &= ENDPOINT_CONFIG(RAW_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN, RAW_EPSIZE, ENDPOINT_BANK_SINGLE);
ConfigSuccess &= ENDPOINT_CONFIG(RAW_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT, RAW_EPSIZE, ENDPOINT_BANK_SINGLE);
2016-11-28 08:31:16 +01:00
#endif
#ifdef CONSOLE_ENABLE
/* Setup Console HID Report Endpoints */
2019-08-30 20:19:03 +02:00
ConfigSuccess &= ENDPOINT_CONFIG(CONSOLE_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN, CONSOLE_EPSIZE, ENDPOINT_BANK_SINGLE);
# if 0
2013-02-11 14:56:30 +01:00
ConfigSuccess &= ENDPOINT_CONFIG(CONSOLE_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
CONSOLE_EPSIZE, ENDPOINT_BANK_SINGLE);
2019-08-30 20:19:03 +02:00
# endif
#endif
2013-07-28 10:34:41 +02:00
2015-08-21 16:46:53 +02:00
#ifdef MIDI_ENABLE
2015-08-25 01:31:12 +02:00
ConfigSuccess &= Endpoint_ConfigureEndpoint(MIDI_STREAM_IN_EPADDR, EP_TYPE_BULK, MIDI_STREAM_EPSIZE, ENDPOINT_BANK_SINGLE);
ConfigSuccess &= Endpoint_ConfigureEndpoint(MIDI_STREAM_OUT_EPADDR, EP_TYPE_BULK, MIDI_STREAM_EPSIZE, ENDPOINT_BANK_SINGLE);
2015-08-21 16:46:53 +02:00
#endif
2016-08-01 07:02:52 +02:00
#ifdef VIRTSER_ENABLE
ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_NOTIFICATION_EPADDR, EP_TYPE_INTERRUPT, CDC_NOTIFICATION_EPSIZE, ENDPOINT_BANK_SINGLE);
ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_OUT_EPADDR, EP_TYPE_BULK, CDC_EPSIZE, ENDPOINT_BANK_SINGLE);
ConfigSuccess &= Endpoint_ConfigureEndpoint(CDC_IN_EPADDR, EP_TYPE_BULK, CDC_EPSIZE, ENDPOINT_BANK_SINGLE);
#endif
}
/* FIXME: Expose this table in the docs somehow
Appendix G: HID Request Support Requirements
The following table enumerates the requests that need to be supported by various types of HID class devices.
Device type GetReport SetReport GetIdle SetIdle GetProtocol SetProtocol
------------------------------------------------------------------------------------------
Boot Mouse Required Optional Optional Optional Required Required
Non-Boot Mouse Required Optional Optional Optional Optional Optional
Boot Keyboard Required Optional Required Required Required Required
Non-Boot Keybrd Required Optional Required Required Optional Optional
Other Device Required Optional Optional Optional Optional Optional
*/
/** \brief Event handler for the USB_ControlRequest event.
*
* This is fired before passing along unhandled control requests to the library for processing internally.
*/
2019-08-30 20:19:03 +02:00
void EVENT_USB_Device_ControlRequest(void) {
uint8_t *ReportData = NULL;
uint8_t ReportSize = 0;
/* Handle HID Class specific requests */
2019-08-30 20:19:03 +02:00
switch (USB_ControlRequest.bRequest) {
case HID_REQ_GetReport:
2019-08-30 20:19:03 +02:00
if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE)) {
Endpoint_ClearSETUP();
// Interface
switch (USB_ControlRequest.wIndex) {
2019-08-30 20:19:03 +02:00
case KEYBOARD_INTERFACE:
// TODO: test/check
ReportData = (uint8_t *)&keyboard_report_sent;
ReportSize = sizeof(keyboard_report_sent);
break;
}
/* Write the report data to the control endpoint */
Endpoint_Write_Control_Stream_LE(ReportData, ReportSize);
Endpoint_ClearOUT();
}
break;
case HID_REQ_SetReport:
2019-08-30 20:19:03 +02:00
if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE)) {
// Interface
switch (USB_ControlRequest.wIndex) {
2019-08-30 20:19:03 +02:00
case KEYBOARD_INTERFACE:
Use a single endpoint for HID reports (#3951) * Unify multiple HID interfaces into one This reduces the number of USB endpoints required, which frees them up for other things. NKRO and EXTRAKEY always use the shared endpoint. By default, MOUSEKEY also uses it. This means it won't work as a Boot Procotol mouse in some BIOSes, etc. If you really think your keyboard needs to work as a mouse in your BIOS, set MOUSE_SHARED_EP = no in your rules.mk. By default, the core keyboard does not use the shared endpoint, as not all BIOSes are standards compliant and that's one place you don't want to find out your keyboard doesn't work.. If you are really confident, you can set KEYBOARD_SHARED_EP = yes to use the shared endpoint here too. * unify endpoints: ChibiOS protocol implementation * fixup: missing #ifdef EXTRAKEY_ENABLEs broke build on AVR with EXTRAKEY disabled * endpoints: restore error when too many endpoints required * lufa: wait up to 10ms to send keyboard input This avoids packets being dropped when two reports are sent in quick succession (eg. releasing a dual role key). * endpoints: fix compile on ARM_ATSAM * endpoint: ARM_ATSAM fixes No longer use wrong or unexpected endpoint IDs * endpoints: accommodate VUSB protocol V-USB has its own, understandably simple ideas about the report formats. It already blasts the mouse and extrakeys through one endpoint with report IDs. We just stay out of its way. * endpoints: document new endpoint configuration options * endpoints: respect keyboard_report->mods in NKRO The caller(s) of host_keyboard_send expect to be able to just drop modifiers in the mods field and not worry about whether NKRO is in use. This is a good thing. So we just shift it over if needs be. * endpoints: report.c: update for new keyboard_report format
2018-11-16 07:22:05 +01:00
#if defined(SHARED_EP_ENABLE) && !defined(KEYBOARD_SHARED_EP)
2019-08-30 20:19:03 +02:00
case SHARED_INTERFACE:
2014-07-19 17:25:06 +02:00
#endif
2019-08-30 20:19:03 +02:00
Endpoint_ClearSETUP();
2012-06-29 09:48:36 +02:00
2019-08-30 20:19:03 +02:00
while (!(Endpoint_IsOUTReceived())) {
if (USB_DeviceState == DEVICE_STATE_Unattached) return;
}
2019-08-30 20:19:03 +02:00
if (Endpoint_BytesInEndpoint() == 2) {
uint8_t report_id = Endpoint_Read_8();
2019-08-30 20:19:03 +02:00
if (report_id == REPORT_ID_KEYBOARD || report_id == REPORT_ID_NKRO) {
keyboard_led_stats = Endpoint_Read_8();
}
} else {
keyboard_led_stats = Endpoint_Read_8();
}
2012-06-29 09:48:36 +02:00
2019-08-30 20:19:03 +02:00
Endpoint_ClearOUT();
Endpoint_ClearStatusStage();
break;
}
2012-06-29 09:48:36 +02:00
}
break;
case HID_REQ_GetProtocol:
2019-08-30 20:19:03 +02:00
if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE)) {
if (USB_ControlRequest.wIndex == KEYBOARD_INTERFACE) {
Endpoint_ClearSETUP();
2019-08-30 20:19:03 +02:00
while (!(Endpoint_IsINReady()))
;
Endpoint_Write_8(keyboard_protocol);
Endpoint_ClearIN();
Endpoint_ClearStatusStage();
}
2012-06-29 09:48:36 +02:00
}
break;
case HID_REQ_SetProtocol:
2019-08-30 20:19:03 +02:00
if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE)) {
if (USB_ControlRequest.wIndex == KEYBOARD_INTERFACE) {
Endpoint_ClearSETUP();
Endpoint_ClearStatusStage();
2012-06-29 09:48:36 +02:00
keyboard_protocol = (USB_ControlRequest.wValue & 0xFF);
clear_keyboard();
}
2012-06-29 09:48:36 +02:00
}
break;
case HID_REQ_SetIdle:
2019-08-30 20:19:03 +02:00
if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE)) {
2012-06-29 09:48:36 +02:00
Endpoint_ClearSETUP();
Endpoint_ClearStatusStage();
keyboard_idle = ((USB_ControlRequest.wValue & 0xFF00) >> 8);
2012-06-29 09:48:36 +02:00
}
break;
case HID_REQ_GetIdle:
2019-08-30 20:19:03 +02:00
if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE)) {
2012-06-29 09:48:36 +02:00
Endpoint_ClearSETUP();
2019-08-30 20:19:03 +02:00
while (!(Endpoint_IsINReady()))
;
Endpoint_Write_8(keyboard_idle);
2012-06-29 09:48:36 +02:00
Endpoint_ClearIN();
Endpoint_ClearStatusStage();
}
break;
}
2016-08-01 07:02:52 +02:00
#ifdef VIRTSER_ENABLE
CDC_Device_ProcessControlRequest(&cdc_device);
#endif
}
/*******************************************************************************
* Host driver
******************************************************************************/
/** \brief Keyboard LEDs
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
static uint8_t keyboard_leds(void) { return keyboard_led_stats; }
/** \brief Send Keyboard
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
static void send_keyboard(report_keyboard_t *report) {
uint8_t timeout = 255;
2019-08-30 20:19:03 +02:00
uint8_t where = where_to_send();
2015-10-26 02:40:56 +01:00
#ifdef BLUETOOTH_ENABLE
2019-08-30 20:19:03 +02:00
if (where == OUTPUT_BLUETOOTH || where == OUTPUT_USB_AND_BT) {
# ifdef MODULE_ADAFRUIT_BLE
adafruit_ble_send_keys(report->mods, report->keys, sizeof(report->keys));
# elif MODULE_RN42
bluefruit_serial_send(0xFD);
bluefruit_serial_send(0x09);
bluefruit_serial_send(0x01);
bluefruit_serial_send(report->mods);
bluefruit_serial_send(report->reserved);
for (uint8_t i = 0; i < KEYBOARD_REPORT_KEYS; i++) {
bluefruit_serial_send(report->keys[i]);
}
# else
bluefruit_serial_send(0xFD);
bluefruit_serial_send(report->mods);
bluefruit_serial_send(report->reserved);
for (uint8_t i = 0; i < KEYBOARD_REPORT_KEYS; i++) {
bluefruit_serial_send(report->keys[i]);
}
# endif
}
#endif
if (where != OUTPUT_USB && where != OUTPUT_USB_AND_BT) {
2019-08-30 20:19:03 +02:00
return;
}
/* Select the Keyboard Report Endpoint */
2019-08-30 20:19:03 +02:00
uint8_t ep = KEYBOARD_IN_EPNUM;
Use a single endpoint for HID reports (#3951) * Unify multiple HID interfaces into one This reduces the number of USB endpoints required, which frees them up for other things. NKRO and EXTRAKEY always use the shared endpoint. By default, MOUSEKEY also uses it. This means it won't work as a Boot Procotol mouse in some BIOSes, etc. If you really think your keyboard needs to work as a mouse in your BIOS, set MOUSE_SHARED_EP = no in your rules.mk. By default, the core keyboard does not use the shared endpoint, as not all BIOSes are standards compliant and that's one place you don't want to find out your keyboard doesn't work.. If you are really confident, you can set KEYBOARD_SHARED_EP = yes to use the shared endpoint here too. * unify endpoints: ChibiOS protocol implementation * fixup: missing #ifdef EXTRAKEY_ENABLEs broke build on AVR with EXTRAKEY disabled * endpoints: restore error when too many endpoints required * lufa: wait up to 10ms to send keyboard input This avoids packets being dropped when two reports are sent in quick succession (eg. releasing a dual role key). * endpoints: fix compile on ARM_ATSAM * endpoint: ARM_ATSAM fixes No longer use wrong or unexpected endpoint IDs * endpoints: accommodate VUSB protocol V-USB has its own, understandably simple ideas about the report formats. It already blasts the mouse and extrakeys through one endpoint with report IDs. We just stay out of its way. * endpoints: document new endpoint configuration options * endpoints: respect keyboard_report->mods in NKRO The caller(s) of host_keyboard_send expect to be able to just drop modifiers in the mods field and not worry about whether NKRO is in use. This is a good thing. So we just shift it over if needs be. * endpoints: report.c: update for new keyboard_report format
2018-11-16 07:22:05 +01:00
uint8_t size = KEYBOARD_REPORT_SIZE;
2013-07-28 10:34:41 +02:00
#ifdef NKRO_ENABLE
if (keyboard_protocol && keymap_config.nkro) {
2019-08-30 20:19:03 +02:00
ep = SHARED_IN_EPNUM;
Use a single endpoint for HID reports (#3951) * Unify multiple HID interfaces into one This reduces the number of USB endpoints required, which frees them up for other things. NKRO and EXTRAKEY always use the shared endpoint. By default, MOUSEKEY also uses it. This means it won't work as a Boot Procotol mouse in some BIOSes, etc. If you really think your keyboard needs to work as a mouse in your BIOS, set MOUSE_SHARED_EP = no in your rules.mk. By default, the core keyboard does not use the shared endpoint, as not all BIOSes are standards compliant and that's one place you don't want to find out your keyboard doesn't work.. If you are really confident, you can set KEYBOARD_SHARED_EP = yes to use the shared endpoint here too. * unify endpoints: ChibiOS protocol implementation * fixup: missing #ifdef EXTRAKEY_ENABLEs broke build on AVR with EXTRAKEY disabled * endpoints: restore error when too many endpoints required * lufa: wait up to 10ms to send keyboard input This avoids packets being dropped when two reports are sent in quick succession (eg. releasing a dual role key). * endpoints: fix compile on ARM_ATSAM * endpoint: ARM_ATSAM fixes No longer use wrong or unexpected endpoint IDs * endpoints: accommodate VUSB protocol V-USB has its own, understandably simple ideas about the report formats. It already blasts the mouse and extrakeys through one endpoint with report IDs. We just stay out of its way. * endpoints: document new endpoint configuration options * endpoints: respect keyboard_report->mods in NKRO The caller(s) of host_keyboard_send expect to be able to just drop modifiers in the mods field and not worry about whether NKRO is in use. This is a good thing. So we just shift it over if needs be. * endpoints: report.c: update for new keyboard_report format
2018-11-16 07:22:05 +01:00
size = sizeof(struct nkro_report);
2013-07-28 10:34:41 +02:00
}
#endif
Use a single endpoint for HID reports (#3951) * Unify multiple HID interfaces into one This reduces the number of USB endpoints required, which frees them up for other things. NKRO and EXTRAKEY always use the shared endpoint. By default, MOUSEKEY also uses it. This means it won't work as a Boot Procotol mouse in some BIOSes, etc. If you really think your keyboard needs to work as a mouse in your BIOS, set MOUSE_SHARED_EP = no in your rules.mk. By default, the core keyboard does not use the shared endpoint, as not all BIOSes are standards compliant and that's one place you don't want to find out your keyboard doesn't work.. If you are really confident, you can set KEYBOARD_SHARED_EP = yes to use the shared endpoint here too. * unify endpoints: ChibiOS protocol implementation * fixup: missing #ifdef EXTRAKEY_ENABLEs broke build on AVR with EXTRAKEY disabled * endpoints: restore error when too many endpoints required * lufa: wait up to 10ms to send keyboard input This avoids packets being dropped when two reports are sent in quick succession (eg. releasing a dual role key). * endpoints: fix compile on ARM_ATSAM * endpoint: ARM_ATSAM fixes No longer use wrong or unexpected endpoint IDs * endpoints: accommodate VUSB protocol V-USB has its own, understandably simple ideas about the report formats. It already blasts the mouse and extrakeys through one endpoint with report IDs. We just stay out of its way. * endpoints: document new endpoint configuration options * endpoints: respect keyboard_report->mods in NKRO The caller(s) of host_keyboard_send expect to be able to just drop modifiers in the mods field and not worry about whether NKRO is in use. This is a good thing. So we just shift it over if needs be. * endpoints: report.c: update for new keyboard_report format
2018-11-16 07:22:05 +01:00
Endpoint_SelectEndpoint(ep);
/* Check if write ready for a polling interval around 10ms */
while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
if (!Endpoint_IsReadWriteAllowed()) return;
Use a single endpoint for HID reports (#3951) * Unify multiple HID interfaces into one This reduces the number of USB endpoints required, which frees them up for other things. NKRO and EXTRAKEY always use the shared endpoint. By default, MOUSEKEY also uses it. This means it won't work as a Boot Procotol mouse in some BIOSes, etc. If you really think your keyboard needs to work as a mouse in your BIOS, set MOUSE_SHARED_EP = no in your rules.mk. By default, the core keyboard does not use the shared endpoint, as not all BIOSes are standards compliant and that's one place you don't want to find out your keyboard doesn't work.. If you are really confident, you can set KEYBOARD_SHARED_EP = yes to use the shared endpoint here too. * unify endpoints: ChibiOS protocol implementation * fixup: missing #ifdef EXTRAKEY_ENABLEs broke build on AVR with EXTRAKEY disabled * endpoints: restore error when too many endpoints required * lufa: wait up to 10ms to send keyboard input This avoids packets being dropped when two reports are sent in quick succession (eg. releasing a dual role key). * endpoints: fix compile on ARM_ATSAM * endpoint: ARM_ATSAM fixes No longer use wrong or unexpected endpoint IDs * endpoints: accommodate VUSB protocol V-USB has its own, understandably simple ideas about the report formats. It already blasts the mouse and extrakeys through one endpoint with report IDs. We just stay out of its way. * endpoints: document new endpoint configuration options * endpoints: respect keyboard_report->mods in NKRO The caller(s) of host_keyboard_send expect to be able to just drop modifiers in the mods field and not worry about whether NKRO is in use. This is a good thing. So we just shift it over if needs be. * endpoints: report.c: update for new keyboard_report format
2018-11-16 07:22:05 +01:00
/* If we're in Boot Protocol, don't send any report ID or other funky fields */
if (!keyboard_protocol) {
Endpoint_Write_Stream_LE(&report->mods, 8, NULL);
} else {
Endpoint_Write_Stream_LE(report, size, NULL);
2013-07-28 10:34:41 +02:00
}
/* Finalize the stream transfer to send the last packet */
Endpoint_ClearIN();
keyboard_report_sent = *report;
}
2019-08-30 20:19:03 +02:00
/** \brief Send Mouse
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
static void send_mouse(report_mouse_t *report) {
#ifdef MOUSE_ENABLE
uint8_t timeout = 255;
2019-08-30 20:19:03 +02:00
uint8_t where = where_to_send();
2015-10-26 02:40:56 +01:00
2019-08-30 20:19:03 +02:00
# ifdef BLUETOOTH_ENABLE
if (where == OUTPUT_BLUETOOTH || where == OUTPUT_USB_AND_BT) {
# ifdef MODULE_ADAFRUIT_BLE
// FIXME: mouse buttons
adafruit_ble_send_mouse_move(report->x, report->y, report->v, report->h, report->buttons);
# else
bluefruit_serial_send(0xFD);
bluefruit_serial_send(0x00);
bluefruit_serial_send(0x03);
bluefruit_serial_send(report->buttons);
bluefruit_serial_send(report->x);
bluefruit_serial_send(report->y);
bluefruit_serial_send(report->v); // should try sending the wheel v here
bluefruit_serial_send(report->h); // should try sending the wheel h here
bluefruit_serial_send(0x00);
# endif
}
# endif
if (where != OUTPUT_USB && where != OUTPUT_USB_AND_BT) {
2019-08-30 20:19:03 +02:00
return;
}
/* Select the Mouse Report Endpoint */
Endpoint_SelectEndpoint(MOUSE_IN_EPNUM);
/* Check if write ready for a polling interval around 10ms */
while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
if (!Endpoint_IsReadWriteAllowed()) return;
/* Write Mouse Report Data */
Endpoint_Write_Stream_LE(report, sizeof(report_mouse_t), NULL);
/* Finalize the stream transfer to send the last packet */
Endpoint_ClearIN();
#endif
}
/** \brief Send Extra
*
* FIXME: Needs doc
*/
Use a single endpoint for HID reports (#3951) * Unify multiple HID interfaces into one This reduces the number of USB endpoints required, which frees them up for other things. NKRO and EXTRAKEY always use the shared endpoint. By default, MOUSEKEY also uses it. This means it won't work as a Boot Procotol mouse in some BIOSes, etc. If you really think your keyboard needs to work as a mouse in your BIOS, set MOUSE_SHARED_EP = no in your rules.mk. By default, the core keyboard does not use the shared endpoint, as not all BIOSes are standards compliant and that's one place you don't want to find out your keyboard doesn't work.. If you are really confident, you can set KEYBOARD_SHARED_EP = yes to use the shared endpoint here too. * unify endpoints: ChibiOS protocol implementation * fixup: missing #ifdef EXTRAKEY_ENABLEs broke build on AVR with EXTRAKEY disabled * endpoints: restore error when too many endpoints required * lufa: wait up to 10ms to send keyboard input This avoids packets being dropped when two reports are sent in quick succession (eg. releasing a dual role key). * endpoints: fix compile on ARM_ATSAM * endpoint: ARM_ATSAM fixes No longer use wrong or unexpected endpoint IDs * endpoints: accommodate VUSB protocol V-USB has its own, understandably simple ideas about the report formats. It already blasts the mouse and extrakeys through one endpoint with report IDs. We just stay out of its way. * endpoints: document new endpoint configuration options * endpoints: respect keyboard_report->mods in NKRO The caller(s) of host_keyboard_send expect to be able to just drop modifiers in the mods field and not worry about whether NKRO is in use. This is a good thing. So we just shift it over if needs be. * endpoints: report.c: update for new keyboard_report format
2018-11-16 07:22:05 +01:00
#ifdef EXTRAKEY_ENABLE
static void send_extra(uint8_t report_id, uint16_t data) {
uint8_t timeout = 255;
2019-08-30 20:19:03 +02:00
if (USB_DeviceState != DEVICE_STATE_Configured) return;
report_extra_t r = {.report_id = report_id, .usage = data};
Use a single endpoint for HID reports (#3951) * Unify multiple HID interfaces into one This reduces the number of USB endpoints required, which frees them up for other things. NKRO and EXTRAKEY always use the shared endpoint. By default, MOUSEKEY also uses it. This means it won't work as a Boot Procotol mouse in some BIOSes, etc. If you really think your keyboard needs to work as a mouse in your BIOS, set MOUSE_SHARED_EP = no in your rules.mk. By default, the core keyboard does not use the shared endpoint, as not all BIOSes are standards compliant and that's one place you don't want to find out your keyboard doesn't work.. If you are really confident, you can set KEYBOARD_SHARED_EP = yes to use the shared endpoint here too. * unify endpoints: ChibiOS protocol implementation * fixup: missing #ifdef EXTRAKEY_ENABLEs broke build on AVR with EXTRAKEY disabled * endpoints: restore error when too many endpoints required * lufa: wait up to 10ms to send keyboard input This avoids packets being dropped when two reports are sent in quick succession (eg. releasing a dual role key). * endpoints: fix compile on ARM_ATSAM * endpoint: ARM_ATSAM fixes No longer use wrong or unexpected endpoint IDs * endpoints: accommodate VUSB protocol V-USB has its own, understandably simple ideas about the report formats. It already blasts the mouse and extrakeys through one endpoint with report IDs. We just stay out of its way. * endpoints: document new endpoint configuration options * endpoints: respect keyboard_report->mods in NKRO The caller(s) of host_keyboard_send expect to be able to just drop modifiers in the mods field and not worry about whether NKRO is in use. This is a good thing. So we just shift it over if needs be. * endpoints: report.c: update for new keyboard_report format
2018-11-16 07:22:05 +01:00
Endpoint_SelectEndpoint(SHARED_IN_EPNUM);
/* Check if write ready for a polling interval around 10ms */
while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
if (!Endpoint_IsReadWriteAllowed()) return;
Endpoint_Write_Stream_LE(&r, sizeof(report_extra_t), NULL);
Endpoint_ClearIN();
}
#endif
/** \brief Send System
*
* FIXME: Needs doc
*/
static void send_system(uint16_t data) {
#ifdef EXTRAKEY_ENABLE
send_extra(REPORT_ID_SYSTEM, data);
Use a single endpoint for HID reports (#3951) * Unify multiple HID interfaces into one This reduces the number of USB endpoints required, which frees them up for other things. NKRO and EXTRAKEY always use the shared endpoint. By default, MOUSEKEY also uses it. This means it won't work as a Boot Procotol mouse in some BIOSes, etc. If you really think your keyboard needs to work as a mouse in your BIOS, set MOUSE_SHARED_EP = no in your rules.mk. By default, the core keyboard does not use the shared endpoint, as not all BIOSes are standards compliant and that's one place you don't want to find out your keyboard doesn't work.. If you are really confident, you can set KEYBOARD_SHARED_EP = yes to use the shared endpoint here too. * unify endpoints: ChibiOS protocol implementation * fixup: missing #ifdef EXTRAKEY_ENABLEs broke build on AVR with EXTRAKEY disabled * endpoints: restore error when too many endpoints required * lufa: wait up to 10ms to send keyboard input This avoids packets being dropped when two reports are sent in quick succession (eg. releasing a dual role key). * endpoints: fix compile on ARM_ATSAM * endpoint: ARM_ATSAM fixes No longer use wrong or unexpected endpoint IDs * endpoints: accommodate VUSB protocol V-USB has its own, understandably simple ideas about the report formats. It already blasts the mouse and extrakeys through one endpoint with report IDs. We just stay out of its way. * endpoints: document new endpoint configuration options * endpoints: respect keyboard_report->mods in NKRO The caller(s) of host_keyboard_send expect to be able to just drop modifiers in the mods field and not worry about whether NKRO is in use. This is a good thing. So we just shift it over if needs be. * endpoints: report.c: update for new keyboard_report format
2018-11-16 07:22:05 +01:00
#endif
}
/** \brief Send Consumer
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
static void send_consumer(uint16_t data) {
Use a single endpoint for HID reports (#3951) * Unify multiple HID interfaces into one This reduces the number of USB endpoints required, which frees them up for other things. NKRO and EXTRAKEY always use the shared endpoint. By default, MOUSEKEY also uses it. This means it won't work as a Boot Procotol mouse in some BIOSes, etc. If you really think your keyboard needs to work as a mouse in your BIOS, set MOUSE_SHARED_EP = no in your rules.mk. By default, the core keyboard does not use the shared endpoint, as not all BIOSes are standards compliant and that's one place you don't want to find out your keyboard doesn't work.. If you are really confident, you can set KEYBOARD_SHARED_EP = yes to use the shared endpoint here too. * unify endpoints: ChibiOS protocol implementation * fixup: missing #ifdef EXTRAKEY_ENABLEs broke build on AVR with EXTRAKEY disabled * endpoints: restore error when too many endpoints required * lufa: wait up to 10ms to send keyboard input This avoids packets being dropped when two reports are sent in quick succession (eg. releasing a dual role key). * endpoints: fix compile on ARM_ATSAM * endpoint: ARM_ATSAM fixes No longer use wrong or unexpected endpoint IDs * endpoints: accommodate VUSB protocol V-USB has its own, understandably simple ideas about the report formats. It already blasts the mouse and extrakeys through one endpoint with report IDs. We just stay out of its way. * endpoints: document new endpoint configuration options * endpoints: respect keyboard_report->mods in NKRO The caller(s) of host_keyboard_send expect to be able to just drop modifiers in the mods field and not worry about whether NKRO is in use. This is a good thing. So we just shift it over if needs be. * endpoints: report.c: update for new keyboard_report format
2018-11-16 07:22:05 +01:00
#ifdef EXTRAKEY_ENABLE
uint8_t where = where_to_send();
2015-10-26 02:40:56 +01:00
2019-08-30 20:19:03 +02:00
# ifdef BLUETOOTH_ENABLE
if (where == OUTPUT_BLUETOOTH || where == OUTPUT_USB_AND_BT) {
2019-08-30 20:19:03 +02:00
# ifdef MODULE_ADAFRUIT_BLE
adafruit_ble_send_consumer_key(data, 0);
2019-08-30 20:19:03 +02:00
# elif MODULE_RN42
static uint16_t last_data = 0;
if (data == last_data) return;
2019-08-30 20:19:03 +02:00
last_data = data;
uint16_t bitmap = CONSUMER2RN42(data);
bluefruit_serial_send(0xFD);
bluefruit_serial_send(0x03);
bluefruit_serial_send(0x03);
2019-08-30 20:19:03 +02:00
bluefruit_serial_send(bitmap & 0xFF);
bluefruit_serial_send((bitmap >> 8) & 0xFF);
# else
static uint16_t last_data = 0;
if (data == last_data) return;
2019-08-30 20:19:03 +02:00
last_data = data;
uint16_t bitmap = CONSUMER2BLUEFRUIT(data);
bluefruit_serial_send(0xFD);
bluefruit_serial_send(0x00);
bluefruit_serial_send(0x02);
2019-08-30 20:19:03 +02:00
bluefruit_serial_send((bitmap >> 8) & 0xFF);
bluefruit_serial_send(bitmap & 0xFF);
bluefruit_serial_send(0x00);
bluefruit_serial_send(0x00);
bluefruit_serial_send(0x00);
bluefruit_serial_send(0x00);
2019-08-30 20:19:03 +02:00
# endif
}
2019-08-30 20:19:03 +02:00
# endif
if (where != OUTPUT_USB && where != OUTPUT_USB_AND_BT) {
2019-08-30 20:19:03 +02:00
return;
}
send_extra(REPORT_ID_CONSUMER, data);
Use a single endpoint for HID reports (#3951) * Unify multiple HID interfaces into one This reduces the number of USB endpoints required, which frees them up for other things. NKRO and EXTRAKEY always use the shared endpoint. By default, MOUSEKEY also uses it. This means it won't work as a Boot Procotol mouse in some BIOSes, etc. If you really think your keyboard needs to work as a mouse in your BIOS, set MOUSE_SHARED_EP = no in your rules.mk. By default, the core keyboard does not use the shared endpoint, as not all BIOSes are standards compliant and that's one place you don't want to find out your keyboard doesn't work.. If you are really confident, you can set KEYBOARD_SHARED_EP = yes to use the shared endpoint here too. * unify endpoints: ChibiOS protocol implementation * fixup: missing #ifdef EXTRAKEY_ENABLEs broke build on AVR with EXTRAKEY disabled * endpoints: restore error when too many endpoints required * lufa: wait up to 10ms to send keyboard input This avoids packets being dropped when two reports are sent in quick succession (eg. releasing a dual role key). * endpoints: fix compile on ARM_ATSAM * endpoint: ARM_ATSAM fixes No longer use wrong or unexpected endpoint IDs * endpoints: accommodate VUSB protocol V-USB has its own, understandably simple ideas about the report formats. It already blasts the mouse and extrakeys through one endpoint with report IDs. We just stay out of its way. * endpoints: document new endpoint configuration options * endpoints: respect keyboard_report->mods in NKRO The caller(s) of host_keyboard_send expect to be able to just drop modifiers in the mods field and not worry about whether NKRO is in use. This is a good thing. So we just shift it over if needs be. * endpoints: report.c: update for new keyboard_report format
2018-11-16 07:22:05 +01:00
#endif
}
/*******************************************************************************
* sendchar
******************************************************************************/
#ifdef CONSOLE_ENABLE
2019-08-30 20:19:03 +02:00
# define SEND_TIMEOUT 5
/** \brief Send Char
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
int8_t sendchar(uint8_t c) {
// Not wait once timeouted.
// Because sendchar() is called so many times, waiting each call causes big lag.
static bool timeouted = false;
// prevents Console_Task() from running during sendchar() runs.
// or char will be lost. These two function is mutually exclusive.
CONSOLE_FLUSH_SET(false);
2019-08-30 20:19:03 +02:00
if (USB_DeviceState != DEVICE_STATE_Configured) return -1;
uint8_t ep = Endpoint_GetCurrentEndpoint();
Endpoint_SelectEndpoint(CONSOLE_IN_EPNUM);
if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) {
goto ERROR_EXIT;
}
if (timeouted && !Endpoint_IsReadWriteAllowed()) {
goto ERROR_EXIT;
}
timeouted = false;
uint8_t timeout = SEND_TIMEOUT;
while (!Endpoint_IsReadWriteAllowed()) {
if (USB_DeviceState != DEVICE_STATE_Configured) {
goto ERROR_EXIT;
}
if (Endpoint_IsStalled()) {
goto ERROR_EXIT;
}
if (!(timeout--)) {
timeouted = true;
goto ERROR_EXIT;
}
_delay_ms(1);
}
Endpoint_Write_8(c);
// send when bank is full
if (!Endpoint_IsReadWriteAllowed()) {
2019-08-30 20:19:03 +02:00
while (!(Endpoint_IsINReady()))
;
Endpoint_ClearIN();
} else {
CONSOLE_FLUSH_SET(true);
}
Endpoint_SelectEndpoint(ep);
return 0;
ERROR_EXIT:
Endpoint_SelectEndpoint(ep);
return -1;
}
#endif
2015-10-27 17:42:30 +01:00
/*******************************************************************************
* MIDI
******************************************************************************/
2015-08-20 06:42:08 +02:00
2015-08-21 16:46:53 +02:00
#ifdef MIDI_ENABLE
2019-08-30 20:19:03 +02:00
USB_ClassInfo_MIDI_Device_t USB_MIDI_Interface = {
.Config =
{
.StreamingInterfaceNumber = AS_INTERFACE,
.DataINEndpoint =
{
.Address = MIDI_STREAM_IN_EPADDR,
.Size = MIDI_STREAM_EPSIZE,
.Banks = 1,
},
.DataOUTEndpoint =
{
.Address = MIDI_STREAM_OUT_EPADDR,
.Size = MIDI_STREAM_EPSIZE,
.Banks = 1,
},
},
Merge ChibiOS and LUFA descriptor support (#2362) * Move lufa descriptor to protocol/usb_descriptor * Try to compile usb_descriptor on ChibiOS * Add lufa_utils for ChibiOS Lufa USB descriptors for ChibiOS * More lufa_util compatibility fixes * First compiling version of shared USB descriptor * Send the usb descriptors * Fix the CONSOLE output on ChibiOS * Add errors for unsupported interfaces * Enable support for vitual serial port USB descriptors * Implement virtual serial port for ChibiOS * Cleanup the lufa_utils Use the default lufa header files * Add raw hid support for ChibiOS This is completely untested * Enable midi compilation on ChibiOS * Move midi functionality out of lufa.c * Don't register sysex callback when not needed * ChibiOS compilation fixes * Update ChibiOS submodule * Fix the Midi USB descriptor It didn't work properly when both Midi and Virtual serial port was enabled. * Add MIDI support for ChibiOS * Fix USB descriptor strings on ChibiOS * Use serial usb driver for raw hid * Generalize the ChibiOS stream like drivers This makes the initialization much more simple and eliminates a lot of the code duplication. * Convert console output to chibios stream driver * Fixes for ChibiOS update * Update the ChibiOS contrib submodule To include the usb data toggle synchronization fixes * Fix duplicate reset enumeration on ChibiOS * Add missing include * Add number of endpoints check for ChibiOS * Enable serial USB driver on all keyboards * Add missing includes when API is enabled withot midi * Add another missing inlcude
2018-02-08 21:07:46 +01:00
};
2015-08-25 01:31:12 +02:00
2019-08-30 20:19:03 +02:00
void send_midi_packet(MIDI_EventPacket_t *event) { MIDI_Device_SendEventPacket(&USB_MIDI_Interface, event); }
2015-08-25 01:31:12 +02:00
2019-08-30 20:19:03 +02:00
bool recv_midi_packet(MIDI_EventPacket_t *const event) { return MIDI_Device_ReceiveEventPacket(&USB_MIDI_Interface, event); }
2015-08-25 01:31:12 +02:00
2015-08-21 16:46:53 +02:00
#endif
2015-08-20 06:42:08 +02:00
2016-08-01 07:02:52 +02:00
/*******************************************************************************
* VIRTUAL SERIAL
******************************************************************************/
#ifdef VIRTSER_ENABLE
/** \brief Virtual Serial Init
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
void virtser_init(void) {
cdc_device.State.ControlLineStates.DeviceToHost = CDC_CONTROL_LINE_IN_DSR;
CDC_Device_SendControlLineStateChange(&cdc_device);
2016-08-01 07:02:52 +02:00
}
/** \brief Virtual Serial Receive
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
void virtser_recv(uint8_t c) __attribute__((weak));
void virtser_recv(uint8_t c) {
// Ignore by default
2016-08-01 07:02:52 +02:00
}
/** \brief Virtual Serial Task
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
void virtser_task(void) {
uint16_t count = CDC_Device_BytesReceived(&cdc_device);
uint8_t ch;
2020-01-31 01:30:41 +01:00
for (; count; --count) {
2019-08-30 20:19:03 +02:00
ch = CDC_Device_ReceiveByte(&cdc_device);
virtser_recv(ch);
}
2016-08-01 07:02:52 +02:00
}
/** \brief Virtual Serial Send
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
void virtser_send(const uint8_t byte) {
uint8_t timeout = 255;
uint8_t ep = Endpoint_GetCurrentEndpoint();
2016-08-01 07:02:52 +02:00
2019-08-30 20:19:03 +02:00
if (cdc_device.State.ControlLineStates.HostToDevice & CDC_CONTROL_LINE_OUT_DTR) {
/* IN packet */
Endpoint_SelectEndpoint(cdc_device.Config.DataINEndpoint.Address);
2016-08-01 07:02:52 +02:00
2019-08-30 20:19:03 +02:00
if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) {
Endpoint_SelectEndpoint(ep);
return;
}
2016-08-01 07:02:52 +02:00
2019-08-30 20:19:03 +02:00
while (timeout-- && !Endpoint_IsReadWriteAllowed()) _delay_us(40);
2016-08-01 07:02:52 +02:00
2019-08-30 20:19:03 +02:00
Endpoint_Write_8(byte);
CDC_Device_Flush(&cdc_device);
2016-08-01 07:02:52 +02:00
2019-08-30 20:19:03 +02:00
if (Endpoint_IsINReady()) {
Endpoint_ClearIN();
}
2016-08-01 07:02:52 +02:00
2019-08-30 20:19:03 +02:00
Endpoint_SelectEndpoint(ep);
}
2016-08-01 07:02:52 +02:00
}
#endif
2015-08-20 06:42:08 +02:00
/*******************************************************************************
* main
******************************************************************************/
/** \brief Setup MCU
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
static void setup_mcu(void) {
/* Disable watchdog if enabled by bootloader/fuses */
MCUSR &= ~_BV(WDRF);
wdt_disable();
/* Disable clock division */
clock_prescale_set(clock_div_1);
}
/** \brief Setup USB
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
static void setup_usb(void) {
// Leonardo needs. Without this USB device is not recognized.
USB_Disable();
USB_Init();
// for Console_Task
USB_Device_EnableSOFEvents();
print_set_sendchar(sendchar);
}
/** \brief Main
*
* FIXME: Needs doc
*/
2019-08-30 20:19:03 +02:00
int main(void) __attribute__((weak));
int main(void) {
2015-08-21 16:46:53 +02:00
#ifdef MIDI_ENABLE
setup_midi();
2015-08-21 16:46:53 +02:00
#endif
2015-08-20 06:42:08 +02:00
setup_mcu();
keyboard_setup();
setup_usb();
sei();
#if defined(MODULE_ADAFRUIT_EZKEY) || defined(MODULE_RN42)
serial_init();
#endif
/* wait for USB startup & debug output */
2015-10-27 17:42:30 +01:00
#ifdef WAIT_FOR_USB
while (USB_DeviceState != DEVICE_STATE_Configured) {
2019-08-30 20:19:03 +02:00
# if defined(INTERRUPT_CONTROL_ENDPOINT)
;
# else
USB_USBTask();
# endif
}
print("USB configured.\n");
2015-10-27 17:42:30 +01:00
#else
USB_USBTask();
#endif
/* init modules */
2012-10-26 20:07:37 +02:00
keyboard_init();
host_set_driver(&lufa_driver);
#ifdef SLEEP_LED_ENABLE
sleep_led_init();
#endif
2016-08-01 07:02:52 +02:00
#ifdef VIRTSER_ENABLE
virtser_init();
#endif
print("Keyboard start.\n");
while (1) {
2019-08-30 20:19:03 +02:00
#if !defined(NO_USB_STARTUP_CHECK)
2015-10-26 19:49:46 +01:00
while (USB_DeviceState == DEVICE_STATE_Suspended) {
print("[s]");
suspend_power_down();
if (USB_Device_RemoteWakeupEnabled && suspend_wakeup_condition()) {
2019-08-30 20:19:03 +02:00
USB_Device_SendRemoteWakeup();
2015-10-26 19:49:46 +01:00
}
}
2019-08-30 20:19:03 +02:00
#endif
2013-03-13 08:01:53 +01:00
2016-11-15 19:18:10 +01:00
keyboard_task();
2015-08-21 16:46:53 +02:00
#ifdef MIDI_ENABLE
Merge ChibiOS and LUFA descriptor support (#2362) * Move lufa descriptor to protocol/usb_descriptor * Try to compile usb_descriptor on ChibiOS * Add lufa_utils for ChibiOS Lufa USB descriptors for ChibiOS * More lufa_util compatibility fixes * First compiling version of shared USB descriptor * Send the usb descriptors * Fix the CONSOLE output on ChibiOS * Add errors for unsupported interfaces * Enable support for vitual serial port USB descriptors * Implement virtual serial port for ChibiOS * Cleanup the lufa_utils Use the default lufa header files * Add raw hid support for ChibiOS This is completely untested * Enable midi compilation on ChibiOS * Move midi functionality out of lufa.c * Don't register sysex callback when not needed * ChibiOS compilation fixes * Update ChibiOS submodule * Fix the Midi USB descriptor It didn't work properly when both Midi and Virtual serial port was enabled. * Add MIDI support for ChibiOS * Fix USB descriptor strings on ChibiOS * Use serial usb driver for raw hid * Generalize the ChibiOS stream like drivers This makes the initialization much more simple and eliminates a lot of the code duplication. * Convert console output to chibios stream driver * Fixes for ChibiOS update * Update the ChibiOS contrib submodule To include the usb data toggle synchronization fixes * Fix duplicate reset enumeration on ChibiOS * Add missing include * Add number of endpoints check for ChibiOS * Enable serial USB driver on all keyboards * Add missing includes when API is enabled withot midi * Add another missing inlcude
2018-02-08 21:07:46 +01:00
MIDI_Device_USBTask(&USB_MIDI_Interface);
2015-08-21 16:46:53 +02:00
#endif
#ifdef MODULE_ADAFRUIT_BLE
adafruit_ble_task();
#endif
2016-08-01 07:02:52 +02:00
#ifdef VIRTSER_ENABLE
virtser_task();
CDC_Device_USBTask(&cdc_device);
#endif
2016-11-28 08:31:16 +01:00
#ifdef RAW_ENABLE
raw_hid_task();
#endif
#if !defined(INTERRUPT_CONTROL_ENDPOINT)
USB_USBTask();
#endif
}
}
2015-08-20 06:42:08 +02:00
2019-08-30 20:19:03 +02:00
uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue, const uint16_t wIndex, const void **const DescriptorAddress) { return get_usb_descriptor(wValue, wIndex, DescriptorAddress); }