From b6b3efc14b21117d13ae33a2eda96c5647817d5b Mon Sep 17 00:00:00 2001 From: Joel Challis Date: Tue, 9 Jan 2024 14:01:34 +0000 Subject: Remove console out endpoint (#22304) --- tmk_core/protocol/chibios/usb_main.c | 103 ++++++++++++++++++----------------- tmk_core/protocol/chibios/usb_main.h | 3 - tmk_core/protocol/lufa/lufa.c | 46 +++++----------- tmk_core/protocol/usb_descriptor.c | 20 +------ tmk_core/protocol/usb_descriptor.h | 14 ----- tmk_core/protocol/vusb/vusb.c | 17 ------ tmk_core/protocol/vusb/vusb.h | 1 - 7 files changed, 66 insertions(+), 138 deletions(-) (limited to 'tmk_core') diff --git a/tmk_core/protocol/chibios/usb_main.c b/tmk_core/protocol/chibios/usb_main.c index 66f9ad0318..7b1e641213 100644 --- a/tmk_core/protocol/chibios/usb_main.c +++ b/tmk_core/protocol/chibios/usb_main.c @@ -51,6 +51,11 @@ extern keymap_config_t keymap_config; #endif +#if defined(CONSOLE_ENABLE) +# define RBUF_SIZE 256 +# include "ring_buffer.h" +#endif + /* --------------------------------------------------------- * Global interface variables and declarations * --------------------------------------------------------- @@ -217,6 +222,24 @@ static const USBEndpointConfig digitizer_ep_config = { }; #endif +#ifdef CONSOLE_ENABLE +/* Console endpoint state structure */ +static USBInEndpointState console_ep_state; + +/* Console endpoint initialization structure (IN) - see USBEndpointConfig comment at top of file */ +static const USBEndpointConfig console_ep_config = { + USB_EP_MODE_TYPE_INTR, /* Interrupt EP */ + NULL, /* SETUP packet notification callback */ + dummy_usb_cb, /* IN notification callback */ + NULL, /* OUT notification callback */ + CONSOLE_EPSIZE, /* IN maximum packet size */ + 0, /* OUT maximum packet size */ + &console_ep_state, /* IN Endpoint state */ + NULL, /* OUT endpoint state */ + usb_lld_endpoint_fields /* USB driver specific endpoint fields */ +}; +#endif + #ifdef USB_ENDPOINTS_ARE_REORDERABLE typedef struct { size_t queue_capacity_in; @@ -347,9 +370,6 @@ typedef struct { typedef struct { union { struct { -#ifdef CONSOLE_ENABLE - usb_driver_config_t console_driver; -#endif #ifdef RAW_ENABLE usb_driver_config_t raw_driver; #endif @@ -365,13 +385,6 @@ typedef struct { } usb_driver_configs_t; static usb_driver_configs_t drivers = { -#ifdef CONSOLE_ENABLE -# define CONSOLE_IN_CAPACITY 4 -# define CONSOLE_OUT_CAPACITY 4 -# define CONSOLE_IN_MODE USB_EP_MODE_TYPE_INTR -# define CONSOLE_OUT_MODE USB_EP_MODE_TYPE_INTR - .console_driver = QMK_USB_DRIVER_CONFIG(CONSOLE, 0, true), -#endif #ifdef RAW_ENABLE # ifndef RAW_IN_CAPACITY # define RAW_IN_CAPACITY 4 @@ -509,6 +522,9 @@ static void usb_event_cb(USBDriver *usbp, usbevent_t event) { #endif #if defined(DIGITIZER_ENABLE) && !defined(DIGITIZER_SHARED_EP) usbInitEndpointI(usbp, DIGITIZER_IN_EPNUM, &digitizer_ep_config); +#endif +#ifdef CONSOLE_ENABLE + usbInitEndpointI(usbp, CONSOLE_IN_EPNUM, &console_ep_config); #endif for (int i = 0; i < NUM_USB_DRIVERS; i++) { #ifdef USB_ENDPOINTS_ARE_REORDERABLE @@ -915,50 +931,35 @@ void send_digitizer(report_digitizer_t *report) { #ifdef CONSOLE_ENABLE int8_t sendchar(uint8_t c) { - static bool timed_out = false; - /* The `timed_out` state is an approximation of the ideal `is_listener_disconnected?` state. - * - * When a 5ms timeout write has timed out, hid_listen is most likely not running, or not - * listening to this keyboard, so we go into the timed_out state. In this state we assume - * that hid_listen is most likely not gonna be connected to us any time soon, so it would - * be wasteful to write follow-up characters with a 5ms timeout, it would all add up and - * unncecessarily slow down the firmware. However instead of just dropping the characters, - * we write them with a TIME_IMMEDIATE timeout, which is a zero timeout, - * and this will succeed only if hid_listen gets connected again. When a write with - * TIME_IMMEDIATE timeout succeeds, we know that hid_listen is listening to us again, and - * we can go back to the timed_out = false state, and following writes will be executed - * with a 5ms timeout. The reason we don't just send all characters with the TIME_IMMEDIATE - * timeout is that this could cause bytes to be lost even if hid_listen is running, if there - * is a lot of data being sent over the console. - * - * This logic will work correctly as long as hid_listen is able to receive at least 200 - * bytes per second. On a heavily overloaded machine that's so overloaded that it's - * unusable, and constantly swapping, hid_listen might have trouble receiving 200 bytes per - * second, so some bytes might be lost on the console. - */ - - const sysinterval_t timeout = timed_out ? TIME_IMMEDIATE : TIME_MS2I(5); - const size_t result = chnWriteTimeout(&drivers.console_driver.driver, &c, 1, timeout); - timed_out = (result == 0); - return result; -} - -// Just a dummy function for now, this could be exposed as a weak function -// Or connected to the actual QMK console -static void console_receive(uint8_t *data, uint8_t length) { - (void)data; - (void)length; + rbuf_enqueue(c); + return 0; } void console_task(void) { - uint8_t buffer[CONSOLE_EPSIZE]; - size_t size = 0; - do { - size = chnReadTimeout(&drivers.console_driver.driver, buffer, sizeof(buffer), TIME_IMMEDIATE); - if (size > 0) { - console_receive(buffer, size); - } - } while (size > 0); + if (!rbuf_has_data()) { + return; + } + + osalSysLock(); + if (usbGetDriverStateI(&USB_DRIVER) != USB_ACTIVE) { + osalSysUnlock(); + return; + } + + if (usbGetTransmitStatusI(&USB_DRIVER, CONSOLE_IN_EPNUM)) { + osalSysUnlock(); + return; + } + + // Send in chunks - padded with zeros to 32 + char send_buf[CONSOLE_EPSIZE] = {0}; + uint8_t send_buf_count = 0; + while (rbuf_has_data() && send_buf_count < CONSOLE_EPSIZE) { + send_buf[send_buf_count++] = rbuf_dequeue(); + } + + usbStartTransmitI(&USB_DRIVER, CONSOLE_IN_EPNUM, (const uint8_t *)send_buf, CONSOLE_EPSIZE); + osalSysUnlock(); } #endif /* CONSOLE_ENABLE */ diff --git a/tmk_core/protocol/chibios/usb_main.h b/tmk_core/protocol/chibios/usb_main.h index 07186f76b8..3fd1e84fe8 100644 --- a/tmk_core/protocol/chibios/usb_main.h +++ b/tmk_core/protocol/chibios/usb_main.h @@ -57,7 +57,4 @@ void usb_event_queue_task(void); /* Putchar over the USB console */ int8_t sendchar(uint8_t c); -/* Flush output (send everything immediately) */ -void console_flush_output(void); - #endif /* CONSOLE_ENABLE */ diff --git a/tmk_core/protocol/lufa/lufa.c b/tmk_core/protocol/lufa/lufa.c index 553f69b1e4..22cc0db8ce 100644 --- a/tmk_core/protocol/lufa/lufa.c +++ b/tmk_core/protocol/lufa/lufa.c @@ -184,41 +184,16 @@ static void raw_hid_task(void) { * Console ******************************************************************************/ #ifdef CONSOLE_ENABLE -/** \brief Console Task +/** \brief Console Tasks * * FIXME: Needs doc */ -static void Console_Task(void) { +static void console_flush_task(void) { /* Device must be connected and configured for the task to run */ if (USB_DeviceState != DEVICE_STATE_Configured) return; uint8_t ep = Endpoint_GetCurrentEndpoint(); -# 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(); - } -# endif - /* IN packet */ Endpoint_SelectEndpoint(CONSOLE_IN_EPNUM); if (!Endpoint_IsEnabled() || !Endpoint_IsConfigured()) { @@ -237,6 +212,10 @@ static void Console_Task(void) { Endpoint_SelectEndpoint(ep); } + +void console_task(void) { + // do nothing +} #endif /******************************************************************************* @@ -341,7 +320,7 @@ void EVENT_USB_Device_StartOfFrame(void) { count = 0; if (!console_flush) return; - Console_Task(); + console_flush_task(); console_flush = false; } @@ -381,9 +360,6 @@ void EVENT_USB_Device_ConfigurationChanged(void) { #ifdef CONSOLE_ENABLE /* Setup console endpoint */ ConfigSuccess &= Endpoint_ConfigureEndpoint((CONSOLE_IN_EPNUM | ENDPOINT_DIR_IN), EP_TYPE_INTERRUPT, CONSOLE_EPSIZE, 1); -# if 0 - ConfigSuccess &= Endpoint_ConfigureEndpoint((CONSOLE_OUT_EPNUM | ENDPOINT_DIR_OUT), EP_TYPE_INTERRUPT, CONSOLE_EPSIZE, 1); -# endif #endif #ifdef MIDI_ENABLE @@ -627,7 +603,7 @@ int8_t sendchar(uint8_t c) { // The `timed_out` state is an approximation of the ideal `is_listener_disconnected?` state. static bool timed_out = false; - // prevents Console_Task() from running during sendchar() runs. + // prevents console_flush_task() from running during sendchar() runs. // or char will be lost. These two function is mutually exclusive. CONSOLE_FLUSH_SET(false); @@ -812,7 +788,7 @@ static void setup_usb(void) { USB_Init(); - // for Console_Task + // for console_flush_task USB_Device_EnableSOFEvents(); } @@ -876,6 +852,10 @@ void protocol_pre_task(void) { } void protocol_post_task(void) { +#ifdef CONSOLE_ENABLE + console_task(); +#endif + #ifdef MIDI_ENABLE MIDI_Device_USBTask(&USB_MIDI_Interface); #endif diff --git a/tmk_core/protocol/usb_descriptor.c b/tmk_core/protocol/usb_descriptor.c index eb214c0492..0e2e63ad8e 100644 --- a/tmk_core/protocol/usb_descriptor.c +++ b/tmk_core/protocol/usb_descriptor.c @@ -420,14 +420,6 @@ const USB_Descriptor_HIDReport_Datatype_t PROGMEM ConsoleReport[] = { HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE), HID_RI_REPORT_SIZE(8, 0x08), HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE), - - // Data from host - HID_RI_USAGE(8, 0x76), // Vendor Defined - HID_RI_LOGICAL_MINIMUM(8, 0x00), - HID_RI_LOGICAL_MAXIMUM(16, 0x00FF), - HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE), - HID_RI_REPORT_SIZE(8, 0x08), - HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE), HID_RI_END_COLLECTION(0), }; #endif @@ -677,7 +669,7 @@ const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor = { }, .InterfaceNumber = CONSOLE_INTERFACE, .AlternateSetting = 0x00, - .TotalEndpoints = 2, + .TotalEndpoints = 1, .Class = HID_CSCP_HIDClass, .SubClass = HID_CSCP_NonBootSubclass, .Protocol = HID_CSCP_NonBootProtocol, @@ -704,16 +696,6 @@ const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor = { .EndpointSize = CONSOLE_EPSIZE, .PollingIntervalMS = 0x01 }, - .Console_OUTEndpoint = { - .Header = { - .Size = sizeof(USB_Descriptor_Endpoint_t), - .Type = DTYPE_Endpoint - }, - .EndpointAddress = (ENDPOINT_DIR_OUT | CONSOLE_OUT_EPNUM), - .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA), - .EndpointSize = CONSOLE_EPSIZE, - .PollingIntervalMS = 0x01 - }, #endif #ifdef MIDI_ENABLE diff --git a/tmk_core/protocol/usb_descriptor.h b/tmk_core/protocol/usb_descriptor.h index 1268bdae73..2469990f4d 100644 --- a/tmk_core/protocol/usb_descriptor.h +++ b/tmk_core/protocol/usb_descriptor.h @@ -97,7 +97,6 @@ typedef struct { USB_Descriptor_Interface_t Console_Interface; USB_HID_Descriptor_HID_t Console_HID; USB_Descriptor_Endpoint_t Console_INEndpoint; - USB_Descriptor_Endpoint_t Console_OUTEndpoint; #endif #ifdef MIDI_ENABLE @@ -232,19 +231,6 @@ enum usb_endpoints { #ifdef CONSOLE_ENABLE CONSOLE_IN_EPNUM = NEXT_EPNUM, - -# ifdef PROTOCOL_CHIBIOS -// ChibiOS has enough memory and descriptor to actually enable the endpoint -// It could use the same endpoint numbers, as that's supported by ChibiOS -// But the QMK code currently assumes that the endpoint numbers are different -# ifdef USB_ENDPOINTS_ARE_REORDERABLE -# define CONSOLE_OUT_EPNUM CONSOLE_IN_EPNUM -# else - CONSOLE_OUT_EPNUM = NEXT_EPNUM, -# endif -# else -# define CONSOLE_OUT_EPNUM CONSOLE_IN_EPNUM -# endif #endif #ifdef MIDI_ENABLE diff --git a/tmk_core/protocol/vusb/vusb.c b/tmk_core/protocol/vusb/vusb.c index d09b2f19b7..cfeeed3712 100644 --- a/tmk_core/protocol/vusb/vusb.c +++ b/tmk_core/protocol/vusb/vusb.c @@ -717,13 +717,6 @@ const PROGMEM uchar console_hid_report[] = { 0x95, CONSOLE_BUFFER_SIZE, // Report Count 0x75, 0x08, // Report Size (8) 0x81, 0x02, // Input (Data, Variable, Absolute) - // Data from host - 0x09, 0x76, // Usage (Vendor Defined) - 0x15, 0x00, // Logical Minimum (0x00) - 0x26, 0xFF, 0x00, // Logical Maximum (0x00FF) - 0x95, CONSOLE_BUFFER_SIZE, // Report Count - 0x75, 0x08, // Report Size (8) - 0x91, 0x02, // Output (Data) 0xC0 // End Collection }; #endif @@ -991,16 +984,6 @@ const PROGMEM usbConfigurationDescriptor_t usbConfigurationDescriptor = { .wMaxPacketSize = CONSOLE_EPSIZE, .bInterval = 0x01 }, - .consoleOUTEndpoint = { - .header = { - .bLength = sizeof(usbEndpointDescriptor_t), - .bDescriptorType = USBDESCR_ENDPOINT - }, - .bEndpointAddress = (USBRQ_DIR_HOST_TO_DEVICE | USB_CFG_EP3_NUMBER), - .bmAttributes = 0x03, - .wMaxPacketSize = CONSOLE_EPSIZE, - .bInterval = 0x01 - } # endif }; diff --git a/tmk_core/protocol/vusb/vusb.h b/tmk_core/protocol/vusb/vusb.h index ae17e5e014..4750e95bf2 100644 --- a/tmk_core/protocol/vusb/vusb.h +++ b/tmk_core/protocol/vusb/vusb.h @@ -114,7 +114,6 @@ typedef struct usbConfigurationDescriptor { usbInterfaceDescriptor_t consoleInterface; usbHIDDescriptor_t consoleHID; usbEndpointDescriptor_t consoleINEndpoint; - usbEndpointDescriptor_t consoleOUTEndpoint; #endif } __attribute__((packed)) usbConfigurationDescriptor_t; -- cgit v1.2.3 From 79020519b4393c8a4f37c9b5fbd214a0f71192d4 Mon Sep 17 00:00:00 2001 From: Joel Challis Date: Thu, 1 Feb 2024 15:33:57 +0000 Subject: Align VUSB suspend protocol logic (#22688) --- tmk_core/protocol/vusb/protocol.c | 89 ++++++++++++++++++++++----------------- 1 file changed, 51 insertions(+), 38 deletions(-) (limited to 'tmk_core') diff --git a/tmk_core/protocol/vusb/protocol.c b/tmk_core/protocol/vusb/protocol.c index 1f64561274..6178d48ef2 100644 --- a/tmk_core/protocol/vusb/protocol.c +++ b/tmk_core/protocol/vusb/protocol.c @@ -22,7 +22,7 @@ #include "keyboard.h" #include "host.h" #include "timer.h" -#include "print.h" +#include "debug.h" #include "suspend.h" #include "wait.h" #include "sendchar.h" @@ -53,7 +53,7 @@ static void initForUsbConnectivity(void) { usbDeviceConnect(); } -static void vusb_send_remote_wakeup(void) { +static inline void vusb_send_remote_wakeup(void) { cli(); uint8_t ddr_orig = USBDDR; @@ -72,9 +72,7 @@ static void vusb_send_remote_wakeup(void) { bool vusb_suspended = false; -static void vusb_suspend(void) { - vusb_suspended = true; - +static inline void vusb_suspend(void) { #ifdef SLEEP_LED_ENABLE sleep_led_enable(); #endif @@ -82,16 +80,13 @@ static void vusb_suspend(void) { suspend_power_down(); } -#if USB_COUNT_SOF -static void vusb_wakeup(void) { - vusb_suspended = false; +static inline void vusb_wakeup(void) { suspend_wakeup_init(); -# ifdef SLEEP_LED_ENABLE +#ifdef SLEEP_LED_ENABLE sleep_led_disable(); -# endif -} #endif +} /** \brief Setup USB * @@ -125,49 +120,67 @@ void protocol_post_init(void) { wait_ms(50); } -void protocol_task(void) { +static inline bool should_do_suspend(void) { #if USB_COUNT_SOF if (usbSofCount != 0) { - usbSofCount = 0; - sof_timer = timer_read(); - if (vusb_suspended) { - vusb_wakeup(); - } + usbSofCount = 0; + sof_timer = timer_read(); + vusb_suspended = false; } else { // Suspend when no SOF in 3ms-10ms(7.1.7.4 Suspending of USB1.1) if (!vusb_suspended && timer_elapsed(sof_timer) > 5) { - vusb_suspend(); + vusb_suspended = true; } } #endif - if (vusb_suspended) { - vusb_suspend(); - if (suspend_wakeup_condition()) { - vusb_send_remote_wakeup(); - } - } else { - usbPoll(); + return vusb_suspended; +} - // TODO: configuration process is inconsistent. it sometime fails. - // To prevent failing to configure NOT scan keyboard during configuration - if (usbConfiguration && usbInterruptIsReady()) { - keyboard_task(); +void protocol_task(void) { +#if !defined(NO_USB_STARTUP_CHECK) + if (should_do_suspend()) { + dprintln("suspending keyboard"); + while (should_do_suspend()) { + vusb_suspend(); + if (suspend_wakeup_condition()) { + vusb_send_remote_wakeup(); + +# if USB_SUSPEND_WAKEUP_DELAY > 0 + // Some hubs, kvm switches, and monitors do + // weird things, with USB device state bouncing + // around wildly on wakeup, yielding race + // conditions that can corrupt the keyboard state. + // + // Pause for a while to let things settle... + wait_ms(USB_SUSPEND_WAKEUP_DELAY); +# endif + } } + vusb_wakeup(); + } +#endif + + usbPoll(); + + // TODO: configuration process is inconsistent. it sometime fails. + // To prevent failing to configure NOT scan keyboard during configuration + if (usbConfiguration && usbInterruptIsReady()) { + keyboard_task(); + } #ifdef RAW_ENABLE - usbPoll(); + usbPoll(); - if (usbConfiguration && usbInterruptIsReady4()) { - raw_hid_task(); - } + if (usbConfiguration && usbInterruptIsReady4()) { + raw_hid_task(); + } #endif #ifdef CONSOLE_ENABLE - usbPoll(); + usbPoll(); - if (usbConfiguration && usbInterruptIsReady3()) { - console_task(); - } -#endif + if (usbConfiguration && usbInterruptIsReady3()) { + console_task(); } +#endif } -- cgit v1.2.3 From 80f3da36e571fa702b1d3df693fd545801250eca Mon Sep 17 00:00:00 2001 From: Andre Brait Date: Fri, 16 Feb 2024 15:19:02 +0100 Subject: [Core] Add OS detection callbacks (#21777) --- docs/feature_os_detection.md | 50 +++++- quantum/keyboard.c | 7 + quantum/os_detection.c | 170 +++++++++++++++------ quantum/os_detection.h | 22 ++- quantum/os_detection/tests/os_detection.cpp | 229 ++++++++++++++++++++++++++++ quantum/os_detection/tests/rules.mk | 4 +- quantum/quantum.h | 4 + tmk_core/protocol/usb_device_state.c | 9 ++ 8 files changed, 437 insertions(+), 58 deletions(-) (limited to 'tmk_core') diff --git a/docs/feature_os_detection.md b/docs/feature_os_detection.md index 907638bcfa..a50ee7ccc2 100644 --- a/docs/feature_os_detection.md +++ b/docs/feature_os_detection.md @@ -14,7 +14,7 @@ In your `rules.mk` add: OS_DETECTION_ENABLE = yes ``` -Include `"os_detection.h"` in your `keymap.c`. +It will automatically include the required headers file. It declares `os_variant_t detected_host_os(void);` which you can call to get detected OS. It returns one of the following values: @@ -32,6 +32,54 @@ enum { ?> Note that it takes some time after firmware is booted to detect the OS. This time is quite short, probably hundreds of milliseconds, but this data may be not ready in keyboard and layout setup functions which run very early during firmware startup. +## Callbacks :id=callbacks + +If you want to perform custom actions when the OS is detected, then you can use the `process_detected_host_os_kb` function on the keyboard level source file, or `process_detected_host_os_user` function in the user `keymap.c`. + +```c +bool process_detected_host_os_kb(os_variant_t detected_os) { + if (!process_detected_host_os_user(detected_os)) { + return false; + } + switch (detected_os) { + case OS_MACOS: + case OS_IOS: + rgb_matrix_set_color_all(RGB_WHITE); + break; + case OS_WINDOWS: + rgb_matrix_set_color_all(RGB_BLUE); + break; + case OS_LINUX: + rgb_matrix_set_color_all(RGB_ORANGE); + break; + case OS_UNSURE: + rgb_matrix_set_color_all(RGB_RED); + break; + } + + return true; +} +``` + +## OS detection stability + +The OS detection is currently handled while the USB device descriptor is being assembled. +The process is done in steps, generating a number of intermediate results until it stabilizes. +We therefore resort to debouncing the result until it has been stable for a given amount of milliseconds. +This amount can be configured, in case your board is not stable within the default debouncing time of 200ms. + +## KVM and USB switches + +Some KVM and USB switches may not trigger the USB controller on the keyboard to fully reset upon switching machines. +If your keyboard does not redetect the OS in this situation, you can force the keyboard to reset when the USB initialization event is detected, forcing the USB controller to be reconfigured. + +## Configuration Options + +* `#define OS_DETECTION_DEBOUNCE 200` + * defined the debounce time for OS detection, in milliseconds +* `#define OS_DETECTION_KEYBOARD_RESET` + * enables the keyboard reset upon a USB device reinitilization, such as switching devices on some KVMs + ## Debug If OS is guessed incorrectly, you may want to collect data about USB setup packets to refine the detection logic. diff --git a/quantum/keyboard.c b/quantum/keyboard.c index ab25b02547..1d6657c230 100644 --- a/quantum/keyboard.c +++ b/quantum/keyboard.c @@ -137,6 +137,9 @@ along with this program. If not, see . #ifdef WPM_ENABLE # include "wpm.h" #endif +#ifdef OS_DETECTION_ENABLE +# include "os_detection.h" +#endif static uint32_t last_input_modification_time = 0; uint32_t last_input_activity_time(void) { @@ -741,4 +744,8 @@ void keyboard_task(void) { #endif led_task(); + +#ifdef OS_DETECTION_ENABLE + os_detection_task(); +#endif } diff --git a/quantum/os_detection.c b/quantum/os_detection.c index e606227136..b674f05b35 100644 --- a/quantum/os_detection.c +++ b/quantum/os_detection.c @@ -16,20 +16,25 @@ #include "os_detection.h" -#include +#ifdef OS_DETECTION_ENABLE -#ifdef OS_DETECTION_DEBUG_ENABLE -# include "eeconfig.h" -# include "eeprom.h" -# include "print.h" +# include +# include "timer.h" +# ifdef OS_DETECTION_KEYBOARD_RESET +# include "quantum.h" +# endif -# define STORED_USB_SETUPS 50 -# define EEPROM_USER_OFFSET (uint8_t*)EECONFIG_SIZE +# ifdef OS_DETECTION_DEBUG_ENABLE +# include "eeconfig.h" +# include "eeprom.h" +# include "print.h" -uint16_t usb_setups[STORED_USB_SETUPS]; -#endif +# define STORED_USB_SETUPS 50 +# define EEPROM_USER_OFFSET (uint8_t*)EECONFIG_SIZE + +static uint16_t usb_setups[STORED_USB_SETUPS]; +# endif -#ifdef OS_DETECTION_ENABLE struct setups_data_t { uint8_t count; uint8_t cnt_02; @@ -45,43 +50,63 @@ struct setups_data_t setups_data = { .cnt_ff = 0, }; -os_variant_t detected_os = OS_UNSURE; +# ifndef OS_DETECTION_DEBOUNCE +# define OS_DETECTION_DEBOUNCE 200 +# endif -// Some collected sequences of wLength can be found in tests. -void make_guess(void) { - if (setups_data.count < 3) { - return; - } - if (setups_data.cnt_ff >= 2 && setups_data.cnt_04 >= 1) { - detected_os = OS_WINDOWS; - return; - } - if (setups_data.count == setups_data.cnt_ff) { - // Linux has 3 packets with 0xFF. - detected_os = OS_LINUX; - return; - } - if (setups_data.count == 5 && setups_data.last_wlength == 0xFF && setups_data.cnt_ff == 1 && setups_data.cnt_02 == 2) { - detected_os = OS_MACOS; - return; - } - if (setups_data.count == 4 && setups_data.cnt_ff == 0 && setups_data.cnt_02 == 2) { - // iOS and iPadOS don't have the last 0xFF packet. - detected_os = OS_IOS; - return; - } - if (setups_data.cnt_ff == 0 && setups_data.cnt_02 == 3 && setups_data.cnt_04 == 1) { - // This is actually PS5. - detected_os = OS_LINUX; - return; +// 2s should always be more than enough (otherwise, you may have other issues) +# if OS_DETECTION_DEBOUNCE > 2000 +# undef OS_DETECTION_DEBOUNCE +# define OS_DETECTION_DEBOUNCE 2000 +# endif + +typedef uint16_t debouncing_t; + +static volatile os_variant_t detected_os = OS_UNSURE; +static os_variant_t reported_os = OS_UNSURE; + +// we need to be able to report OS_UNSURE if that is the stable result of the guesses +static bool first_report = true; + +// to react on USB state changes +static volatile enum usb_device_state current_usb_device_state = USB_DEVICE_STATE_INIT; +static enum usb_device_state reported_usb_device_state = USB_DEVICE_STATE_INIT; + +// the OS detection might be unstable for a while, "debounce" it +static volatile bool debouncing = false; +static volatile fast_timer_t last_time; + +void os_detection_task(void) { + if (current_usb_device_state == USB_DEVICE_STATE_CONFIGURED) { + // debouncing goes for both the detected OS as well as the USB state + if (debouncing && timer_elapsed_fast(last_time) >= OS_DETECTION_DEBOUNCE) { + debouncing = false; + reported_usb_device_state = current_usb_device_state; + if (detected_os != reported_os || first_report) { + first_report = false; + reported_os = detected_os; + process_detected_host_os_kb(detected_os); + } + } } - if (setups_data.cnt_ff >= 1 && setups_data.cnt_02 == 0 && setups_data.cnt_04 == 0) { - // This is actually Quest 2 or Nintendo Switch. - detected_os = OS_LINUX; - return; +# ifdef OS_DETECTION_KEYBOARD_RESET + // resetting the keyboard on the USB device state change callback results in instability, so delegate that to this task + // only take action if it's been stable at least once, to avoid issues with some KVMs + else if (current_usb_device_state == USB_DEVICE_STATE_INIT && reported_usb_device_state != USB_DEVICE_STATE_INIT) { + soft_reset_keyboard(); } +# endif } +__attribute__((weak)) bool process_detected_host_os_kb(os_variant_t detected_os) { + return process_detected_host_os_user(detected_os); +} + +__attribute__((weak)) bool process_detected_host_os_user(os_variant_t detected_os) { + return true; +} + +// Some collected sequences of wLength can be found in tests. void process_wlength(const uint16_t w_length) { # ifdef OS_DETECTION_DEBUG_ENABLE usb_setups[setups_data.count] = w_length; @@ -95,7 +120,37 @@ void process_wlength(const uint16_t w_length) { } else if (w_length == 0xFF) { setups_data.cnt_ff++; } - make_guess(); + + // now try to make a guess + os_variant_t guessed = OS_UNSURE; + if (setups_data.count >= 3) { + if (setups_data.cnt_ff >= 2 && setups_data.cnt_04 >= 1) { + guessed = OS_WINDOWS; + } else if (setups_data.count == setups_data.cnt_ff) { + // Linux has 3 packets with 0xFF. + guessed = OS_LINUX; + } else if (setups_data.count == 5 && setups_data.last_wlength == 0xFF && setups_data.cnt_ff == 1 && setups_data.cnt_02 == 2) { + guessed = OS_MACOS; + } else if (setups_data.count == 4 && setups_data.cnt_ff == 0 && setups_data.cnt_02 == 2) { + // iOS and iPadOS don't have the last 0xFF packet. + guessed = OS_IOS; + } else if (setups_data.cnt_ff == 0 && setups_data.cnt_02 == 3 && setups_data.cnt_04 == 1) { + // This is actually PS5. + guessed = OS_LINUX; + } else if (setups_data.cnt_ff >= 1 && setups_data.cnt_02 == 0 && setups_data.cnt_04 == 0) { + // This is actually Quest 2 or Nintendo Switch. + guessed = OS_LINUX; + } + } + + // only replace the guessed value if not unsure + if (guessed != OS_UNSURE) { + detected_os = guessed; + } + + // whatever the result, debounce + last_time = timer_read_fast(); + debouncing = true; } os_variant_t detected_host_os(void) { @@ -104,25 +159,38 @@ os_variant_t detected_host_os(void) { void erase_wlength_data(void) { memset(&setups_data, 0, sizeof(setups_data)); - detected_os = OS_UNSURE; + detected_os = OS_UNSURE; + reported_os = OS_UNSURE; + current_usb_device_state = USB_DEVICE_STATE_INIT; + reported_usb_device_state = USB_DEVICE_STATE_INIT; + debouncing = false; + first_report = true; +} + +void os_detection_notify_usb_device_state_change(enum usb_device_state usb_device_state) { + // treat this like any other source of instability + current_usb_device_state = usb_device_state; + last_time = timer_read_fast(); + debouncing = true; } # if defined(SPLIT_KEYBOARD) && defined(SPLIT_DETECTED_OS_ENABLE) void slave_update_detected_host_os(os_variant_t os) { detected_os = os; + last_time = timer_read_fast(); + debouncing = true; } -# endif // defined(SPLIT_KEYBOARD) && defined(SPLIT_DETECTED_OS_ENABLE) -#endif // OS_DETECTION_ENABLE +# endif -#ifdef OS_DETECTION_DEBUG_ENABLE +# ifdef OS_DETECTION_DEBUG_ENABLE void print_stored_setups(void) { -# ifdef CONSOLE_ENABLE +# ifdef CONSOLE_ENABLE uint8_t cnt = eeprom_read_byte(EEPROM_USER_OFFSET); for (uint16_t i = 0; i < cnt; ++i) { uint16_t* addr = (uint16_t*)EEPROM_USER_OFFSET + i * sizeof(uint16_t) + sizeof(uint8_t); xprintf("i: %d, wLength: 0x%02X\n", i, eeprom_read_word(addr)); } -# endif +# endif } void store_setups_in_eeprom(void) { @@ -133,4 +201,6 @@ void store_setups_in_eeprom(void) { } } -#endif // OS_DETECTION_DEBUG_ENABLE +# endif // OS_DETECTION_DEBUG_ENABLE + +#endif diff --git a/quantum/os_detection.h b/quantum/os_detection.h index 3496ea0ed2..470f30943a 100644 --- a/quantum/os_detection.h +++ b/quantum/os_detection.h @@ -16,9 +16,12 @@ #pragma once -#include - #ifdef OS_DETECTION_ENABLE + +# include +# include +# include "usb_device_state.h" + typedef enum { OS_UNSURE, OS_LINUX, @@ -30,13 +33,20 @@ typedef enum { void process_wlength(const uint16_t w_length); os_variant_t detected_host_os(void); void erase_wlength_data(void); +void os_detection_notify_usb_device_state_change(enum usb_device_state usb_device_state); + +void os_detection_task(void); + +bool process_detected_host_os_kb(os_variant_t os); +bool process_detected_host_os_user(os_variant_t os); # if defined(SPLIT_KEYBOARD) && defined(SPLIT_DETECTED_OS_ENABLE) void slave_update_detected_host_os(os_variant_t os); -# endif // defined(SPLIT_KEYBOARD) && defined(SPLIT_DETECTED_OS_ENABLE) -#endif +# endif -#ifdef OS_DETECTION_DEBUG_ENABLE +# ifdef OS_DETECTION_DEBUG_ENABLE void print_stored_setups(void); void store_setups_in_eeprom(void); -#endif +# endif + +#endif // OS_DETECTION_ENABLE diff --git a/quantum/os_detection/tests/os_detection.cpp b/quantum/os_detection/tests/os_detection.cpp index 102349852e..11e93fdea8 100644 --- a/quantum/os_detection/tests/os_detection.cpp +++ b/quantum/os_detection/tests/os_detection.cpp @@ -18,12 +18,20 @@ extern "C" { #include "os_detection.h" +#include "timer.h" + +void advance_time(uint32_t ms); } +static uint32_t reported_count; +static os_variant_t reported_os; + class OsDetectionTest : public ::testing::Test { protected: void SetUp() override { erase_wlength_data(); + reported_count = 0; + reported_os = OS_UNSURE; } }; @@ -34,6 +42,24 @@ os_variant_t check_sequence(const std::vector &w_lengths) { return detected_host_os(); } +bool process_detected_host_os_kb(os_variant_t os) { + reported_count = reported_count + 1; + reported_os = os; +} + +void assert_not_reported(void) { + // check that it does not report the result, nor any intermediate results + EXPECT_EQ(reported_count, 0); + EXPECT_EQ(reported_os, OS_UNSURE); +} + +void assert_reported(os_variant_t os) { + // check that it reports exclusively the result, not any intermediate results + EXPECT_EQ(reported_count, 1); + EXPECT_EQ(reported_os, os); + EXPECT_EQ(reported_os, detected_host_os()); +} + /* Some collected data. ChibiOS: @@ -77,88 +103,291 @@ Quest 2: [FF, FF, FF, FE, ...] */ TEST_F(OsDetectionTest, TestLinux) { EXPECT_EQ(check_sequence({0xFF, 0xFF, 0xFF}), OS_LINUX); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestChibiosMacos) { EXPECT_EQ(check_sequence({0x2, 0x24, 0x2, 0x28, 0xFF}), OS_MACOS); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestLufaMacos) { EXPECT_EQ(check_sequence({0x2, 0x10, 0x2, 0xE, 0xFF}), OS_MACOS); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestVusbMacos) { EXPECT_EQ(check_sequence({0x2, 0xE, 0x2, 0xE, 0xFF}), OS_MACOS); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestChibiosIos) { EXPECT_EQ(check_sequence({0x2, 0x24, 0x2, 0x28}), OS_IOS); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestLufaIos) { EXPECT_EQ(check_sequence({0x2, 0x10, 0x2, 0xE}), OS_IOS); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestVusbIos) { EXPECT_EQ(check_sequence({0x2, 0xE, 0x2, 0xE}), OS_IOS); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestChibiosWindows10) { EXPECT_EQ(check_sequence({0xFF, 0xFF, 0x4, 0x24, 0x4, 0x24, 0x4, 0xFF, 0x24, 0xFF, 0x4, 0xFF, 0x24, 0x4, 0x24, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A}), OS_WINDOWS); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestChibiosWindows10_2) { EXPECT_EQ(check_sequence({0xFF, 0xFF, 0x4, 0x24, 0x4, 0x24, 0x4, 0x24, 0x4, 0x24, 0x4, 0x24}), OS_WINDOWS); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestLufaWindows10) { EXPECT_EQ(check_sequence({0x12, 0xFF, 0xFF, 0x4, 0x10, 0xFF, 0xFF, 0xFF, 0x4, 0x10, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A}), OS_WINDOWS); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestLufaWindows10_2) { EXPECT_EQ(check_sequence({0xFF, 0xFF, 0x4, 0x10, 0xFF, 0x4, 0xFF, 0x10, 0xFF, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A}), OS_WINDOWS); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestLufaWindows10_3) { EXPECT_EQ(check_sequence({0xFF, 0xFF, 0x4, 0x10, 0x4, 0x10}), OS_WINDOWS); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestVusbWindows10) { EXPECT_EQ(check_sequence({0xFF, 0xFF, 0x4, 0xE, 0xFF}), OS_WINDOWS); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestVusbWindows10_2) { EXPECT_EQ(check_sequence({0xFF, 0xFF, 0x4, 0xE, 0x4}), OS_WINDOWS); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestChibiosPs5) { EXPECT_EQ(check_sequence({0x2, 0x4, 0x2, 0x28, 0x2, 0x24}), OS_LINUX); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestLufaPs5) { EXPECT_EQ(check_sequence({0x2, 0x4, 0x2, 0xE, 0x2, 0x10}), OS_LINUX); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestVusbPs5) { EXPECT_EQ(check_sequence({0x2, 0x4, 0x2, 0xE, 0x2}), OS_LINUX); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestChibiosNintendoSwitch) { EXPECT_EQ(check_sequence({0x82, 0xFF, 0x40, 0x40, 0xFF, 0x40, 0x40, 0xFF, 0x40, 0x40, 0xFF, 0x40, 0x40, 0xFF, 0x40, 0x40}), OS_LINUX); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestLufaNintendoSwitch) { EXPECT_EQ(check_sequence({0x82, 0xFF, 0x40, 0x40, 0xFF, 0x40, 0x40}), OS_LINUX); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestVusbNintendoSwitch) { EXPECT_EQ(check_sequence({0x82, 0xFF, 0x40, 0x40}), OS_LINUX); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestChibiosQuest2) { EXPECT_EQ(check_sequence({0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF}), OS_LINUX); + os_detection_task(); + assert_not_reported(); } TEST_F(OsDetectionTest, TestVusbQuest2) { EXPECT_EQ(check_sequence({0xFF, 0xFF, 0xFF, 0xFE}), OS_LINUX); + os_detection_task(); + assert_not_reported(); +} + +// Regression reported in https://github.com/qmk/qmk_firmware/pull/21777#issuecomment-1922815841 +TEST_F(OsDetectionTest, TestDetectMacM1AsIOS) { + EXPECT_EQ(check_sequence({0x02, 0x32, 0x02, 0x24, 0x101, 0xFF}), OS_IOS); + os_detection_task(); + assert_not_reported(); +} + +TEST_F(OsDetectionTest, TestDoNotReportIfUsbUnstable) { + EXPECT_EQ(check_sequence({0xFF, 0xFF, 0xFF, 0xFE}), OS_LINUX); + os_detection_task(); + assert_not_reported(); + + advance_time(OS_DETECTION_DEBOUNCE); + os_detection_task(); + assert_not_reported(); + EXPECT_EQ(detected_host_os(), OS_LINUX); +} + +TEST_F(OsDetectionTest, TestReportAfterDebounce) { + EXPECT_EQ(check_sequence({0xFF, 0xFF, 0xFF, 0xFE}), OS_LINUX); + os_detection_notify_usb_device_state_change(USB_DEVICE_STATE_CONFIGURED); + os_detection_task(); + assert_not_reported(); + + advance_time(1); + os_detection_task(); + assert_not_reported(); + EXPECT_EQ(detected_host_os(), OS_LINUX); + + advance_time(OS_DETECTION_DEBOUNCE - 3); + os_detection_task(); + assert_not_reported(); + EXPECT_EQ(detected_host_os(), OS_LINUX); + + advance_time(1); + os_detection_task(); + assert_not_reported(); + EXPECT_EQ(detected_host_os(), OS_LINUX); + + // advancing the timer alone must not cause a report + advance_time(1); + assert_not_reported(); + EXPECT_EQ(detected_host_os(), OS_LINUX); + // the task will cause a report + os_detection_task(); + assert_reported(OS_LINUX); + EXPECT_EQ(detected_host_os(), OS_LINUX); + + // check that it remains the same after a long time + advance_time(OS_DETECTION_DEBOUNCE * 15); + assert_reported(OS_LINUX); + EXPECT_EQ(detected_host_os(), OS_LINUX); +} + +TEST_F(OsDetectionTest, TestReportAfterDebounceLongWait) { + EXPECT_EQ(check_sequence({0x12, 0xFF, 0xFF, 0x4, 0x10, 0xFF, 0xFF, 0xFF, 0x4, 0x10, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A}), OS_WINDOWS); + os_detection_notify_usb_device_state_change(USB_DEVICE_STATE_CONFIGURED); + os_detection_task(); + assert_not_reported(); + + advance_time(1); + os_detection_task(); + assert_not_reported(); + EXPECT_EQ(detected_host_os(), OS_WINDOWS); + + // advancing the timer alone must not cause a report + advance_time(OS_DETECTION_DEBOUNCE * 15); + assert_not_reported(); + EXPECT_EQ(detected_host_os(), OS_WINDOWS); + // the task will cause a report + os_detection_task(); + assert_reported(OS_WINDOWS); + EXPECT_EQ(detected_host_os(), OS_WINDOWS); + + // check that it remains the same after a long time + advance_time(OS_DETECTION_DEBOUNCE * 10); + os_detection_task(); + assert_reported(OS_WINDOWS); + EXPECT_EQ(detected_host_os(), OS_WINDOWS); +} + +TEST_F(OsDetectionTest, TestReportUnsure) { + EXPECT_EQ(check_sequence({0x12, 0xFF}), OS_UNSURE); + os_detection_notify_usb_device_state_change(USB_DEVICE_STATE_CONFIGURED); + os_detection_task(); + assert_not_reported(); + + advance_time(1); + os_detection_task(); + assert_not_reported(); + EXPECT_EQ(detected_host_os(), OS_UNSURE); + + // advancing the timer alone must not cause a report + advance_time(OS_DETECTION_DEBOUNCE - 1); + assert_not_reported(); + EXPECT_EQ(detected_host_os(), OS_UNSURE); + // the task will cause a report + os_detection_task(); + assert_reported(OS_UNSURE); + EXPECT_EQ(detected_host_os(), OS_UNSURE); + + // check that it remains the same after a long time + advance_time(OS_DETECTION_DEBOUNCE * 10); + os_detection_task(); + assert_reported(OS_UNSURE); + EXPECT_EQ(detected_host_os(), OS_UNSURE); +} + +TEST_F(OsDetectionTest, TestDoNotReportIntermediateResults) { + EXPECT_EQ(check_sequence({0x12, 0xFF}), OS_UNSURE); + os_detection_notify_usb_device_state_change(USB_DEVICE_STATE_CONFIGURED); + os_detection_task(); + assert_not_reported(); + + advance_time(OS_DETECTION_DEBOUNCE - 1); + os_detection_task(); + assert_not_reported(); + EXPECT_EQ(detected_host_os(), OS_UNSURE); + + // at this stage, the final result has not been reached yet + EXPECT_EQ(check_sequence({0xFF}), OS_LINUX); + os_detection_notify_usb_device_state_change(USB_DEVICE_STATE_CONFIGURED); + advance_time(OS_DETECTION_DEBOUNCE - 1); + os_detection_task(); + assert_not_reported(); + // the intermedite but yet unstable result is exposed through detected_host_os() + EXPECT_EQ(detected_host_os(), OS_LINUX); + + // the remainder is processed + EXPECT_EQ(check_sequence({0x4, 0x10, 0xFF, 0xFF, 0xFF, 0x4, 0x10, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A}), OS_WINDOWS); + os_detection_notify_usb_device_state_change(USB_DEVICE_STATE_CONFIGURED); + advance_time(OS_DETECTION_DEBOUNCE - 1); + os_detection_task(); + assert_not_reported(); + EXPECT_EQ(detected_host_os(), OS_WINDOWS); + + // advancing the timer alone must not cause a report + advance_time(1); + assert_not_reported(); + EXPECT_EQ(detected_host_os(), OS_WINDOWS); + // the task will cause a report + os_detection_task(); + assert_reported(OS_WINDOWS); + EXPECT_EQ(detected_host_os(), OS_WINDOWS); + + // check that it remains the same after a long time + advance_time(OS_DETECTION_DEBOUNCE * 10); + os_detection_task(); + assert_reported(OS_WINDOWS); + EXPECT_EQ(detected_host_os(), OS_WINDOWS); +} + +TEST_F(OsDetectionTest, TestDoNotGoBackToUnsure) { + // 0x02 would cause it to go back to Unsure, so check that it does not + EXPECT_EQ(check_sequence({0xFF, 0xFF, 0xFF, 0xFE, 0x02}), OS_LINUX); + os_detection_task(); + assert_not_reported(); } diff --git a/quantum/os_detection/tests/rules.mk b/quantum/os_detection/tests/rules.mk index 9bfe373f46..1b69b71ba9 100644 --- a/quantum/os_detection/tests/rules.mk +++ b/quantum/os_detection/tests/rules.mk @@ -1,5 +1,7 @@ os_detection_DEFS := -DOS_DETECTION_ENABLE +os_detection_DEFS += -DOS_DETECTION_DEBOUNCE=50 os_detection_SRC := \ $(QUANTUM_PATH)/os_detection/tests/os_detection.cpp \ - $(QUANTUM_PATH)/os_detection.c + $(QUANTUM_PATH)/os_detection.c \ + $(PLATFORM_PATH)/$(PLATFORM_KEY)/timer.c diff --git a/quantum/quantum.h b/quantum/quantum.h index 98d848581d..5446ab1ad7 100644 --- a/quantum/quantum.h +++ b/quantum/quantum.h @@ -236,6 +236,10 @@ extern layer_state_t layer_state; # include "process_repeat_key.h" #endif +#ifdef OS_DETECTION_ENABLE +# include "os_detection.h" +#endif + void set_single_persistent_default_layer(uint8_t default_layer); #define IS_LAYER_ON(layer) layer_state_is(layer) diff --git a/tmk_core/protocol/usb_device_state.c b/tmk_core/protocol/usb_device_state.c index 8d56ba4d2f..4cd241528d 100644 --- a/tmk_core/protocol/usb_device_state.c +++ b/tmk_core/protocol/usb_device_state.c @@ -20,6 +20,10 @@ # include "haptic.h" #endif +#ifdef OS_DETECTION_ENABLE +# include "os_detection.h" +#endif + enum usb_device_state usb_device_state = USB_DEVICE_STATE_NO_INIT; __attribute__((weak)) void notify_usb_device_state_change_kb(enum usb_device_state usb_device_state) { @@ -32,7 +36,12 @@ static void notify_usb_device_state_change(enum usb_device_state usb_device_stat #if defined(HAPTIC_ENABLE) && HAPTIC_OFF_IN_LOW_POWER haptic_notify_usb_device_state_change(); #endif + notify_usb_device_state_change_kb(usb_device_state); + +#ifdef OS_DETECTION_ENABLE + os_detection_notify_usb_device_state_change(usb_device_state); +#endif } void usb_device_state_set_configuration(bool isConfigured, uint8_t configurationNumber) { -- cgit v1.2.3 From 2d1aed78a67b3d2b002cc739ef087963b05b76b8 Mon Sep 17 00:00:00 2001 From: Ryan Date: Sun, 18 Feb 2024 17:08:27 +1100 Subject: Update GPIO macro usages in core (#23093) --- drivers/bluetooth/bluefruit_le.cpp | 18 ++++---- drivers/eeprom/eeprom_i2c.c | 12 +++--- drivers/gpio/sn74x138.c | 24 +++++------ drivers/gpio/sn74x154.c | 18 ++++---- drivers/haptic/solenoid.c | 14 +++---- drivers/lcd/hd44780.c | 48 +++++++++++----------- drivers/lcd/st7565.c | 16 ++++---- drivers/led/apa102.c | 24 +++++------ drivers/led/aw20216s.c | 4 +- drivers/led/issi/is31fl3218-mono.c | 4 +- drivers/led/issi/is31fl3218.c | 4 +- drivers/led/issi/is31fl3731-mono.c | 4 +- drivers/led/issi/is31fl3731.c | 4 +- drivers/led/issi/is31fl3733-mono.c | 4 +- drivers/led/issi/is31fl3733.c | 4 +- drivers/led/issi/is31fl3736-mono.c | 4 +- drivers/led/issi/is31fl3736.c | 4 +- drivers/led/issi/is31fl3737-mono.c | 4 +- drivers/led/issi/is31fl3737.c | 4 +- drivers/led/issi/is31fl3741-mono.c | 4 +- drivers/led/issi/is31fl3741.c | 4 +- drivers/led/issi/is31fl3742a-mono.c | 4 +- drivers/led/issi/is31fl3742a.c | 4 +- drivers/led/issi/is31fl3743a-mono.c | 4 +- drivers/led/issi/is31fl3743a.c | 4 +- drivers/led/issi/is31fl3745-mono.c | 4 +- drivers/led/issi/is31fl3745.c | 4 +- drivers/led/issi/is31fl3746a-mono.c | 4 +- drivers/led/issi/is31fl3746a.c | 4 +- drivers/led/snled27351-mono.c | 4 +- drivers/led/snled27351.c | 4 +- drivers/oled/oled_driver.c | 20 ++++----- drivers/painter/comms/qp_comms_spi.c | 20 ++++----- drivers/sensors/adns5050.c | 32 +++++++-------- drivers/sensors/adns9800.c | 2 +- drivers/sensors/analog_joystick.c | 8 ++-- drivers/sensors/paw3204.c | 24 +++++------ drivers/sensors/pmw3320.c | 32 +++++++-------- drivers/usb2422.c | 10 ++--- .../onekey/keymaps/chibios_waiting_test/keymap.c | 12 +++--- platforms/avr/drivers/audio_pwm_hardware.c | 4 +- platforms/avr/drivers/backlight_pwm.c | 6 +-- platforms/avr/drivers/ps2/ps2_io.c | 20 ++++----- platforms/avr/drivers/serial.c | 10 ++--- platforms/avr/drivers/spi_master.c | 16 ++++---- platforms/chibios/drivers/serial.c | 12 +++--- platforms/chibios/drivers/spi_master.c | 14 +++---- platforms/chibios/drivers/ws2812_bitbang.c | 8 ++-- quantum/backlight/backlight_driver_common.c | 10 ++--- quantum/dip_switch.c | 4 +- quantum/encoder.c | 8 ++-- quantum/haptic.c | 8 ++-- quantum/haptic.h | 16 ++++---- quantum/joystick.c | 2 +- quantum/led.c | 30 +++++++------- quantum/matrix.c | 14 +++---- quantum/pointing_device/pointing_device.c | 8 ++-- quantum/split_common/split_util.c | 16 ++++---- tmk_core/protocol/arm_atsam/shift_register.c | 24 +++++------ tmk_core/protocol/arm_atsam/spi_master.c | 8 ++-- tmk_core/protocol/usb_util.c | 4 +- 61 files changed, 334 insertions(+), 334 deletions(-) (limited to 'tmk_core') diff --git a/drivers/bluetooth/bluefruit_le.cpp b/drivers/bluetooth/bluefruit_le.cpp index 39c14ddd13..218eca2195 100644 --- a/drivers/bluetooth/bluefruit_le.cpp +++ b/drivers/bluetooth/bluefruit_le.cpp @@ -188,7 +188,7 @@ static bool sdep_recv_pkt(struct sdep_msg *msg, uint16_t timeout) { bool ready = false; do { - ready = readPin(BLUEFRUIT_LE_IRQ_PIN); + ready = gpio_read_pin(BLUEFRUIT_LE_IRQ_PIN); if (ready) { break; } @@ -231,7 +231,7 @@ static void resp_buf_read_one(bool greedy) { return; } - if (readPin(BLUEFRUIT_LE_IRQ_PIN)) { + if (gpio_read_pin(BLUEFRUIT_LE_IRQ_PIN)) { struct sdep_msg msg; again: @@ -242,7 +242,7 @@ static void resp_buf_read_one(bool greedy) { dprintf("recv latency %dms\n", TIMER_DIFF_16(timer_read(), last_send)); } - if (greedy && resp_buf.peek(last_send) && readPin(BLUEFRUIT_LE_IRQ_PIN)) { + if (greedy && resp_buf.peek(last_send) && gpio_read_pin(BLUEFRUIT_LE_IRQ_PIN)) { goto again; } } @@ -293,16 +293,16 @@ void bluefruit_le_init(void) { state.configured = false; state.is_connected = false; - setPinInput(BLUEFRUIT_LE_IRQ_PIN); + gpio_set_pin_input(BLUEFRUIT_LE_IRQ_PIN); spi_init(); // Perform a hardware reset - setPinOutput(BLUEFRUIT_LE_RST_PIN); - writePinHigh(BLUEFRUIT_LE_RST_PIN); - writePinLow(BLUEFRUIT_LE_RST_PIN); + gpio_set_pin_output(BLUEFRUIT_LE_RST_PIN); + gpio_write_pin_high(BLUEFRUIT_LE_RST_PIN); + gpio_write_pin_low(BLUEFRUIT_LE_RST_PIN); wait_ms(10); - writePinHigh(BLUEFRUIT_LE_RST_PIN); + gpio_write_pin_high(BLUEFRUIT_LE_RST_PIN); wait_ms(1000); // Give it a second to initialize @@ -508,7 +508,7 @@ void bluefruit_le_task(void) { resp_buf_read_one(true); send_buf_send_one(SdepShortTimeout); - if (resp_buf.empty() && (state.event_flags & UsingEvents) && readPin(BLUEFRUIT_LE_IRQ_PIN)) { + if (resp_buf.empty() && (state.event_flags & UsingEvents) && gpio_read_pin(BLUEFRUIT_LE_IRQ_PIN)) { // Must be an event update if (at_command_P(PSTR("AT+EVENTSTATUS"), resbuf, sizeof(resbuf))) { uint32_t mask = strtoul(resbuf, NULL, 16); diff --git a/drivers/eeprom/eeprom_i2c.c b/drivers/eeprom/eeprom_i2c.c index a74a010415..0d3d5ccbe5 100644 --- a/drivers/eeprom/eeprom_i2c.c +++ b/drivers/eeprom/eeprom_i2c.c @@ -57,8 +57,8 @@ void eeprom_driver_init(void) { i2c_init(); #if defined(EXTERNAL_EEPROM_WP_PIN) /* We are setting the WP pin to high in a way that requires at least two bit-flips to change back to 0 */ - writePin(EXTERNAL_EEPROM_WP_PIN, 1); - setPinInputHigh(EXTERNAL_EEPROM_WP_PIN); + gpio_write_pin(EXTERNAL_EEPROM_WP_PIN, 1); + gpio_set_pin_input_high(EXTERNAL_EEPROM_WP_PIN); #endif } @@ -100,8 +100,8 @@ void eeprom_write_block(const void *buf, void *addr, size_t len) { uintptr_t target_addr = (uintptr_t)addr; #if defined(EXTERNAL_EEPROM_WP_PIN) - setPinOutput(EXTERNAL_EEPROM_WP_PIN); - writePin(EXTERNAL_EEPROM_WP_PIN, 0); + gpio_set_pin_output(EXTERNAL_EEPROM_WP_PIN); + gpio_write_pin(EXTERNAL_EEPROM_WP_PIN, 0); #endif while (len > 0) { @@ -134,7 +134,7 @@ void eeprom_write_block(const void *buf, void *addr, size_t len) { #if defined(EXTERNAL_EEPROM_WP_PIN) /* We are setting the WP pin to high in a way that requires at least two bit-flips to change back to 0 */ - writePin(EXTERNAL_EEPROM_WP_PIN, 1); - setPinInputHigh(EXTERNAL_EEPROM_WP_PIN); + gpio_write_pin(EXTERNAL_EEPROM_WP_PIN, 1); + gpio_set_pin_input_high(EXTERNAL_EEPROM_WP_PIN); #endif } diff --git a/drivers/gpio/sn74x138.c b/drivers/gpio/sn74x138.c index 222e5db56c..1cf8e54f56 100644 --- a/drivers/gpio/sn74x138.c +++ b/drivers/gpio/sn74x138.c @@ -27,39 +27,39 @@ static const pin_t address_pins[ADDRESS_PIN_COUNT] = SN74X138_ADDRESS_PINS; void sn74x138_init(void) { for (int i = 0; i < ADDRESS_PIN_COUNT; i++) { - setPinOutput(address_pins[i]); - writePinLow(address_pins[i]); + gpio_set_pin_output(address_pins[i]); + gpio_write_pin_low(address_pins[i]); } #if defined(SN74X138_E1_PIN) - setPinOutput(SN74X138_E1_PIN); - writePinHigh(SN74X138_E1_PIN); + gpio_set_pin_output(SN74X138_E1_PIN); + gpio_write_pin_high(SN74X138_E1_PIN); #endif #if defined(SN74X138_E2_PIN) - setPinOutput(SN74X138_E2_PIN); - writePinHigh(SN74X138_E2_PIN); + gpio_set_pin_output(SN74X138_E2_PIN); + gpio_write_pin_high(SN74X138_E2_PIN); #endif #if defined(SN74X138_E3_PIN) - setPinOutput(SN74X138_E3_PIN); - writePinLow(SN74X138_E3_PIN); + gpio_set_pin_output(SN74X138_E3_PIN); + gpio_write_pin_low(SN74X138_E3_PIN); #endif } void sn74x138_set_enabled(bool enabled) { #if defined(SN74X138_E1_PIN) - writePin(SN74X138_E1_PIN, !enabled); + gpio_write_pin(SN74X138_E1_PIN, !enabled); #endif #if defined(SN74X138_E2_PIN) - writePin(SN74X138_E2_PIN, !enabled); + gpio_write_pin(SN74X138_E2_PIN, !enabled); #endif #if defined(SN74X138_E3_PIN) - writePin(SN74X138_E3_PIN, enabled); + gpio_write_pin(SN74X138_E3_PIN, enabled); #endif } void sn74x138_set_addr(uint8_t address) { for (int i = 0; i < ADDRESS_PIN_COUNT; i++) { - writePin(address_pins[i], address & (1 << i)); + gpio_write_pin(address_pins[i], address & (1 << i)); } } diff --git a/drivers/gpio/sn74x154.c b/drivers/gpio/sn74x154.c index 5f21f12b55..6226adf27e 100644 --- a/drivers/gpio/sn74x154.c +++ b/drivers/gpio/sn74x154.c @@ -27,32 +27,32 @@ static const pin_t address_pins[ADDRESS_PIN_COUNT] = SN74X154_ADDRESS_PINS; void sn74x154_init(void) { for (int i = 0; i < ADDRESS_PIN_COUNT; i++) { - setPinOutput(address_pins[i]); - writePinLow(address_pins[i]); + gpio_set_pin_output(address_pins[i]); + gpio_write_pin_low(address_pins[i]); } #if defined(SN74X154_E0_PIN) - setPinOutput(SN74X154_E0_PIN); - writePinHigh(SN74X154_E0_PIN); + gpio_set_pin_output(SN74X154_E0_PIN); + gpio_write_pin_high(SN74X154_E0_PIN); #endif #if defined(SN74X154_E1_PIN) - setPinOutput(SN74X154_E1_PIN); - writePinHigh(SN74X154_E1_PIN); + gpio_set_pin_output(SN74X154_E1_PIN); + gpio_write_pin_high(SN74X154_E1_PIN); #endif } void sn74x154_set_enabled(bool enabled) { #if defined(SN74X154_E0_PIN) - writePin(SN74X154_E0_PIN, !enabled); + gpio_write_pin(SN74X154_E0_PIN, !enabled); #endif #if defined(SN74X154_E1_PIN) - writePin(SN74X154_E1_PIN, !enabled); + gpio_write_pin(SN74X154_E1_PIN, !enabled); #endif } void sn74x154_set_addr(uint8_t address) { for (int i = 0; i < ADDRESS_PIN_COUNT; i++) { - writePin(address_pins[i], address & (1 << i)); + gpio_write_pin(address_pins[i], address & (1 << i)); } } diff --git a/drivers/haptic/solenoid.c b/drivers/haptic/solenoid.c index da4095cda4..346b88bbc4 100644 --- a/drivers/haptic/solenoid.c +++ b/drivers/haptic/solenoid.c @@ -61,7 +61,7 @@ void solenoid_set_dwell(uint8_t dwell) { * @param index select which solenoid to check/stop */ void solenoid_stop(uint8_t index) { - writePin(solenoid_pads[index], !solenoid_active_state[index]); + gpio_write_pin(solenoid_pads[index], !solenoid_active_state[index]); solenoid_on[index] = false; solenoid_buzzing[index] = false; } @@ -78,7 +78,7 @@ void solenoid_fire(uint8_t index) { solenoid_on[index] = true; solenoid_buzzing[index] = true; solenoid_start[index] = timer_read(); - writePin(solenoid_pads[index], solenoid_active_state[index]); + gpio_write_pin(solenoid_pads[index], solenoid_active_state[index]); } /** @@ -128,12 +128,12 @@ void solenoid_check(void) { if ((elapsed[i] % (SOLENOID_BUZZ_ACTUATED + SOLENOID_BUZZ_NONACTUATED)) < SOLENOID_BUZZ_ACTUATED) { if (!solenoid_buzzing[i]) { solenoid_buzzing[i] = true; - writePin(solenoid_pads[i], solenoid_active_state[i]); + gpio_write_pin(solenoid_pads[i], solenoid_active_state[i]); } } else { if (solenoid_buzzing[i]) { solenoid_buzzing[i] = false; - writePin(solenoid_pads[i], !solenoid_active_state[i]); + gpio_write_pin(solenoid_pads[i], !solenoid_active_state[i]); } } } @@ -156,8 +156,8 @@ void solenoid_setup(void) { #else solenoid_active_state[i] = high; #endif - writePin(solenoid_pads[i], !solenoid_active_state[i]); - setPinOutput(solenoid_pads[i]); + gpio_write_pin(solenoid_pads[i], !solenoid_active_state[i]); + gpio_set_pin_output(solenoid_pads[i]); if ((!HAPTIC_OFF_IN_LOW_POWER) || (usb_device_state == USB_DEVICE_STATE_CONFIGURED)) { solenoid_fire(i); } @@ -170,6 +170,6 @@ void solenoid_setup(void) { */ void solenoid_shutdown(void) { for (uint8_t i = 0; i < NUMBER_OF_SOLENOIDS; i++) { - writePin(solenoid_pads[i], !solenoid_active_state[i]); + gpio_write_pin(solenoid_pads[i], !solenoid_active_state[i]); } } diff --git a/drivers/lcd/hd44780.c b/drivers/lcd/hd44780.c index ccc50117ab..9b4e2f0226 100644 --- a/drivers/lcd/hd44780.c +++ b/drivers/lcd/hd44780.c @@ -57,67 +57,67 @@ static const pin_t data_pins[4] = HD44780_DATA_PINS; #define HD44780_ENABLE_DELAY_US 1 static void hd44780_latch(void) { - writePinHigh(HD44780_E_PIN); + gpio_write_pin_high(HD44780_E_PIN); wait_us(HD44780_ENABLE_DELAY_US); - writePinLow(HD44780_E_PIN); + gpio_write_pin_low(HD44780_E_PIN); } void hd44780_write(uint8_t data, bool isData) { - writePin(HD44780_RS_PIN, isData); - writePinLow(HD44780_RW_PIN); + gpio_write_pin(HD44780_RS_PIN, isData); + gpio_write_pin_low(HD44780_RW_PIN); for (int i = 0; i < 4; i++) { - setPinOutput(data_pins[i]); + gpio_set_pin_output(data_pins[i]); } // Write high nibble for (int i = 0; i < 4; i++) { - writePin(data_pins[i], (data >> 4) & (1 << i)); + gpio_write_pin(data_pins[i], (data >> 4) & (1 << i)); } hd44780_latch(); // Write low nibble for (int i = 0; i < 4; i++) { - writePin(data_pins[i], data & (1 << i)); + gpio_write_pin(data_pins[i], data & (1 << i)); } hd44780_latch(); for (int i = 0; i < 4; i++) { - writePinHigh(data_pins[i]); + gpio_write_pin_high(data_pins[i]); } } uint8_t hd44780_read(bool isData) { uint8_t data = 0; - writePin(HD44780_RS_PIN, isData); - writePinHigh(HD44780_RW_PIN); + gpio_write_pin(HD44780_RS_PIN, isData); + gpio_write_pin_high(HD44780_RW_PIN); for (int i = 0; i < 4; i++) { - setPinInput(data_pins[i]); + gpio_set_pin_input(data_pins[i]); } - writePinHigh(HD44780_E_PIN); + gpio_write_pin_high(HD44780_E_PIN); wait_us(HD44780_ENABLE_DELAY_US); // Read high nibble for (int i = 0; i < 4; i++) { - data |= (readPin(data_pins[i]) << i); + data |= (gpio_read_pin(data_pins[i]) << i); } data <<= 4; - writePinLow(HD44780_E_PIN); + gpio_write_pin_low(HD44780_E_PIN); wait_us(HD44780_ENABLE_DELAY_US); - writePinHigh(HD44780_E_PIN); + gpio_write_pin_high(HD44780_E_PIN); wait_us(HD44780_ENABLE_DELAY_US); // Read low nibble for (int i = 0; i < 4; i++) { - data |= (readPin(data_pins[i]) << i); + data |= (gpio_read_pin(data_pins[i]) << i); } - writePinLow(HD44780_E_PIN); + gpio_write_pin_low(HD44780_E_PIN); return data; } @@ -171,20 +171,20 @@ void hd44780_set_ddram_address(uint8_t address) { } void hd44780_init(bool cursor, bool blink) { - setPinOutput(HD44780_RS_PIN); - setPinOutput(HD44780_RW_PIN); - setPinOutput(HD44780_E_PIN); + gpio_set_pin_output(HD44780_RS_PIN); + gpio_set_pin_output(HD44780_RW_PIN); + gpio_set_pin_output(HD44780_E_PIN); for (int i = 0; i < 4; i++) { - setPinOutput(data_pins[i]); + gpio_set_pin_output(data_pins[i]); } wait_ms(HD44780_INIT_DELAY_MS); // Manually configure for 4-bit mode - can't use hd44780_command() yet // HD44780U datasheet, Fig. 24 (p46) - writePinHigh(data_pins[0]); // Function set - writePinHigh(data_pins[1]); // DL = 1 + gpio_write_pin_high(data_pins[0]); // Function set + gpio_write_pin_high(data_pins[1]); // DL = 1 hd44780_latch(); wait_ms(5); // Send again @@ -194,7 +194,7 @@ void hd44780_init(bool cursor, bool blink) { hd44780_latch(); wait_us(64); - writePinLow(data_pins[0]); // DL = 0 + gpio_write_pin_low(data_pins[0]); // DL = 0 hd44780_latch(); wait_us(64); diff --git a/drivers/lcd/st7565.c b/drivers/lcd/st7565.c index 47ee02804b..4fce40edbe 100644 --- a/drivers/lcd/st7565.c +++ b/drivers/lcd/st7565.c @@ -92,10 +92,10 @@ static void InvertCharacter(uint8_t *cursor) { } bool st7565_init(display_rotation_t rotation) { - setPinOutput(ST7565_A0_PIN); - writePinHigh(ST7565_A0_PIN); - setPinOutput(ST7565_RST_PIN); - writePinHigh(ST7565_RST_PIN); + gpio_set_pin_output(ST7565_A0_PIN); + gpio_write_pin_high(ST7565_A0_PIN); + gpio_set_pin_output(ST7565_RST_PIN); + gpio_write_pin_high(ST7565_RST_PIN); st7565_rotation = st7565_init_user(rotation); @@ -488,18 +488,18 @@ void st7565_task(void) { __attribute__((weak)) void st7565_task_user(void) {} void st7565_reset(void) { - writePinLow(ST7565_RST_PIN); + gpio_write_pin_low(ST7565_RST_PIN); wait_ms(20); - writePinHigh(ST7565_RST_PIN); + gpio_write_pin_high(ST7565_RST_PIN); wait_ms(20); } spi_status_t st7565_send_cmd(uint8_t cmd) { - writePinLow(ST7565_A0_PIN); + gpio_write_pin_low(ST7565_A0_PIN); return spi_write(cmd); } spi_status_t st7565_send_data(uint8_t *data, uint16_t length) { - writePinHigh(ST7565_A0_PIN); + gpio_write_pin_high(ST7565_A0_PIN); return spi_transmit(data, length); } diff --git a/drivers/led/apa102.c b/drivers/led/apa102.c index 548b8f094e..d6d4327495 100644 --- a/drivers/led/apa102.c +++ b/drivers/led/apa102.c @@ -43,14 +43,14 @@ } \ } while (0) -#define APA102_SEND_BIT(byte, bit) \ - do { \ - writePin(APA102_DI_PIN, (byte >> bit) & 1); \ - io_wait; \ - writePinHigh(APA102_CI_PIN); \ - io_wait; \ - writePinLow(APA102_CI_PIN); \ - io_wait; \ +#define APA102_SEND_BIT(byte, bit) \ + do { \ + gpio_write_pin(APA102_DI_PIN, (byte >> bit) & 1); \ + io_wait; \ + gpio_write_pin_high(APA102_CI_PIN); \ + io_wait; \ + gpio_write_pin_low(APA102_CI_PIN); \ + io_wait; \ } while (0) uint8_t apa102_led_brightness = APA102_DEFAULT_BRIGHTNESS; @@ -114,11 +114,11 @@ static void apa102_send_frame(uint8_t red, uint8_t green, uint8_t blue, uint8_t } void apa102_init(void) { - setPinOutput(APA102_DI_PIN); - setPinOutput(APA102_CI_PIN); + gpio_set_pin_output(APA102_DI_PIN); + gpio_set_pin_output(APA102_CI_PIN); - writePinLow(APA102_DI_PIN); - writePinLow(APA102_CI_PIN); + gpio_write_pin_low(APA102_DI_PIN); + gpio_write_pin_low(APA102_CI_PIN); } void apa102_setleds(rgb_led_t *start_led, uint16_t num_leds) { diff --git a/drivers/led/aw20216s.c b/drivers/led/aw20216s.c index fa4454b6b1..704794f5b5 100644 --- a/drivers/led/aw20216s.c +++ b/drivers/led/aw20216s.c @@ -114,8 +114,8 @@ void aw20216s_init_drivers(void) { spi_init(); #if defined(AW20216S_EN_PIN) - setPinOutput(AW20216S_EN_PIN); - writePinHigh(AW20216S_EN_PIN); + gpio_set_pin_output(AW20216S_EN_PIN); + gpio_write_pin_high(AW20216S_EN_PIN); #endif aw20216s_init(AW20216S_CS_PIN_1); diff --git a/drivers/led/issi/is31fl3218-mono.c b/drivers/led/issi/is31fl3218-mono.c index cb5a069160..0174da7ab3 100644 --- a/drivers/led/issi/is31fl3218-mono.c +++ b/drivers/led/issi/is31fl3218-mono.c @@ -68,8 +68,8 @@ void is31fl3218_init(void) { i2c_init(); #if defined(IS31FL3218_SDB_PIN) - setPinOutput(IS31FL3218_SDB_PIN); - writePinHigh(IS31FL3218_SDB_PIN); + gpio_set_pin_output(IS31FL3218_SDB_PIN); + gpio_write_pin_high(IS31FL3218_SDB_PIN); #endif // In case we ever want to reinitialize (?) diff --git a/drivers/led/issi/is31fl3218.c b/drivers/led/issi/is31fl3218.c index c3a0946e83..dd97d236f7 100644 --- a/drivers/led/issi/is31fl3218.c +++ b/drivers/led/issi/is31fl3218.c @@ -68,8 +68,8 @@ void is31fl3218_init(void) { i2c_init(); #if defined(IS31FL3218_SDB_PIN) - setPinOutput(IS31FL3218_SDB_PIN); - writePinHigh(IS31FL3218_SDB_PIN); + gpio_set_pin_output(IS31FL3218_SDB_PIN); + gpio_write_pin_high(IS31FL3218_SDB_PIN); #endif // In case we ever want to reinitialize (?) diff --git a/drivers/led/issi/is31fl3731-mono.c b/drivers/led/issi/is31fl3731-mono.c index 5ff8f8b7c5..33a863b982 100644 --- a/drivers/led/issi/is31fl3731-mono.c +++ b/drivers/led/issi/is31fl3731-mono.c @@ -99,8 +99,8 @@ void is31fl3731_init_drivers(void) { i2c_init(); #if defined(IS31FL3731_SDB_PIN) - setPinOutput(IS31FL3731_SDB_PIN); - writePinHigh(IS31FL3731_SDB_PIN); + gpio_set_pin_output(IS31FL3731_SDB_PIN); + gpio_write_pin_high(IS31FL3731_SDB_PIN); #endif for (uint8_t i = 0; i < IS31FL3731_DRIVER_COUNT; i++) { diff --git a/drivers/led/issi/is31fl3731.c b/drivers/led/issi/is31fl3731.c index 380861d5b8..86d953ef25 100644 --- a/drivers/led/issi/is31fl3731.c +++ b/drivers/led/issi/is31fl3731.c @@ -98,8 +98,8 @@ void is31fl3731_init_drivers(void) { i2c_init(); #if defined(IS31FL3731_SDB_PIN) - setPinOutput(IS31FL3731_SDB_PIN); - writePinHigh(IS31FL3731_SDB_PIN); + gpio_set_pin_output(IS31FL3731_SDB_PIN); + gpio_write_pin_high(IS31FL3731_SDB_PIN); #endif for (uint8_t i = 0; i < IS31FL3731_DRIVER_COUNT; i++) { diff --git a/drivers/led/issi/is31fl3733-mono.c b/drivers/led/issi/is31fl3733-mono.c index 13f2d9b983..740fe06097 100644 --- a/drivers/led/issi/is31fl3733-mono.c +++ b/drivers/led/issi/is31fl3733-mono.c @@ -144,8 +144,8 @@ void is31fl3733_init_drivers(void) { i2c_init(); #if defined(IS31FL3733_SDB_PIN) - setPinOutput(IS31FL3733_SDB_PIN); - writePinHigh(IS31FL3733_SDB_PIN); + gpio_set_pin_output(IS31FL3733_SDB_PIN); + gpio_write_pin_high(IS31FL3733_SDB_PIN); #endif for (uint8_t i = 0; i < IS31FL3733_DRIVER_COUNT; i++) { diff --git a/drivers/led/issi/is31fl3733.c b/drivers/led/issi/is31fl3733.c index ac6f4b4c89..a1d6899114 100644 --- a/drivers/led/issi/is31fl3733.c +++ b/drivers/led/issi/is31fl3733.c @@ -143,8 +143,8 @@ void is31fl3733_init_drivers(void) { i2c_init(); #if defined(IS31FL3733_SDB_PIN) - setPinOutput(IS31FL3733_SDB_PIN); - writePinHigh(IS31FL3733_SDB_PIN); + gpio_set_pin_output(IS31FL3733_SDB_PIN); + gpio_write_pin_high(IS31FL3733_SDB_PIN); #endif for (uint8_t i = 0; i < IS31FL3733_DRIVER_COUNT; i++) { diff --git a/drivers/led/issi/is31fl3736-mono.c b/drivers/led/issi/is31fl3736-mono.c index 0d3b5db4e4..7a5415c725 100644 --- a/drivers/led/issi/is31fl3736-mono.c +++ b/drivers/led/issi/is31fl3736-mono.c @@ -115,8 +115,8 @@ void is31fl3736_init_drivers(void) { i2c_init(); #if defined(IS31FL3736_SDB_PIN) - setPinOutput(IS31FL3736_SDB_PIN); - writePinHigh(IS31FL3736_SDB_PIN); + gpio_set_pin_output(IS31FL3736_SDB_PIN); + gpio_write_pin_high(IS31FL3736_SDB_PIN); #endif for (uint8_t i = 0; i < IS31FL3736_DRIVER_COUNT; i++) { diff --git a/drivers/led/issi/is31fl3736.c b/drivers/led/issi/is31fl3736.c index 990e6c8905..3ab42e2f7c 100644 --- a/drivers/led/issi/is31fl3736.c +++ b/drivers/led/issi/is31fl3736.c @@ -115,8 +115,8 @@ void is31fl3736_init_drivers(void) { i2c_init(); #if defined(IS31FL3736_SDB_PIN) - setPinOutput(IS31FL3736_SDB_PIN); - writePinHigh(IS31FL3736_SDB_PIN); + gpio_set_pin_output(IS31FL3736_SDB_PIN); + gpio_write_pin_high(IS31FL3736_SDB_PIN); #endif for (uint8_t i = 0; i < IS31FL3736_DRIVER_COUNT; i++) { diff --git a/drivers/led/issi/is31fl3737-mono.c b/drivers/led/issi/is31fl3737-mono.c index 37d684cff0..7b2e5a3576 100644 --- a/drivers/led/issi/is31fl3737-mono.c +++ b/drivers/led/issi/is31fl3737-mono.c @@ -117,8 +117,8 @@ void is31fl3737_init_drivers(void) { i2c_init(); #if defined(IS31FL3737_SDB_PIN) - setPinOutput(IS31FL3737_SDB_PIN); - writePinHigh(IS31FL3737_SDB_PIN); + gpio_set_pin_output(IS31FL3737_SDB_PIN); + gpio_write_pin_high(IS31FL3737_SDB_PIN); #endif for (uint8_t i = 0; i < IS31FL3737_DRIVER_COUNT; i++) { diff --git a/drivers/led/issi/is31fl3737.c b/drivers/led/issi/is31fl3737.c index fb760cda5e..b27a4cbb0f 100644 --- a/drivers/led/issi/is31fl3737.c +++ b/drivers/led/issi/is31fl3737.c @@ -117,8 +117,8 @@ void is31fl3737_init_drivers(void) { i2c_init(); #if defined(IS31FL3737_SDB_PIN) - setPinOutput(IS31FL3737_SDB_PIN); - writePinHigh(IS31FL3737_SDB_PIN); + gpio_set_pin_output(IS31FL3737_SDB_PIN); + gpio_write_pin_high(IS31FL3737_SDB_PIN); #endif for (uint8_t i = 0; i < IS31FL3737_DRIVER_COUNT; i++) { diff --git a/drivers/led/issi/is31fl3741-mono.c b/drivers/led/issi/is31fl3741-mono.c index e4857b72d4..dbccba0fc8 100644 --- a/drivers/led/issi/is31fl3741-mono.c +++ b/drivers/led/issi/is31fl3741-mono.c @@ -143,8 +143,8 @@ void is31fl3741_init_drivers(void) { i2c_init(); #if defined(IS31FL3741_SDB_PIN) - setPinOutput(IS31FL3741_SDB_PIN); - writePinHigh(IS31FL3741_SDB_PIN); + gpio_set_pin_output(IS31FL3741_SDB_PIN); + gpio_write_pin_high(IS31FL3741_SDB_PIN); #endif for (uint8_t i = 0; i < IS31FL3741_DRIVER_COUNT; i++) { diff --git a/drivers/led/issi/is31fl3741.c b/drivers/led/issi/is31fl3741.c index a6cb661d91..3614d1c104 100644 --- a/drivers/led/issi/is31fl3741.c +++ b/drivers/led/issi/is31fl3741.c @@ -143,8 +143,8 @@ void is31fl3741_init_drivers(void) { i2c_init(); #if defined(IS31FL3741_SDB_PIN) - setPinOutput(IS31FL3741_SDB_PIN); - writePinHigh(IS31FL3741_SDB_PIN); + gpio_set_pin_output(IS31FL3741_SDB_PIN); + gpio_write_pin_high(IS31FL3741_SDB_PIN); #endif for (uint8_t i = 0; i < IS31FL3741_DRIVER_COUNT; i++) { diff --git a/drivers/led/issi/is31fl3742a-mono.c b/drivers/led/issi/is31fl3742a-mono.c index a33865260c..c63db1a7fc 100644 --- a/drivers/led/issi/is31fl3742a-mono.c +++ b/drivers/led/issi/is31fl3742a-mono.c @@ -116,8 +116,8 @@ void is31fl3742a_init_drivers(void) { i2c_init(); #if defined(IS31FL3742A_SDB_PIN) - setPinOutput(IS31FL3742A_SDB_PIN); - writePinHigh(IS31FL3742A_SDB_PIN); + gpio_set_pin_output(IS31FL3742A_SDB_PIN); + gpio_write_pin_high(IS31FL3742A_SDB_PIN); #endif for (uint8_t i = 0; i < IS31FL3742A_DRIVER_COUNT; i++) { diff --git a/drivers/led/issi/is31fl3742a.c b/drivers/led/issi/is31fl3742a.c index 8900ae666f..b8e9a58759 100644 --- a/drivers/led/issi/is31fl3742a.c +++ b/drivers/led/issi/is31fl3742a.c @@ -116,8 +116,8 @@ void is31fl3742a_init_drivers(void) { i2c_init(); #if defined(IS31FL3742A_SDB_PIN) - setPinOutput(IS31FL3742A_SDB_PIN); - writePinHigh(IS31FL3742A_SDB_PIN); + gpio_set_pin_output(IS31FL3742A_SDB_PIN); + gpio_write_pin_high(IS31FL3742A_SDB_PIN); #endif for (uint8_t i = 0; i < IS31FL3742A_DRIVER_COUNT; i++) { diff --git a/drivers/led/issi/is31fl3743a-mono.c b/drivers/led/issi/is31fl3743a-mono.c index 99b1af160e..6413dbef04 100644 --- a/drivers/led/issi/is31fl3743a-mono.c +++ b/drivers/led/issi/is31fl3743a-mono.c @@ -138,8 +138,8 @@ void is31fl3743a_init_drivers(void) { i2c_init(); #if defined(IS31FL3743A_SDB_PIN) - setPinOutput(IS31FL3743A_SDB_PIN); - writePinHigh(IS31FL3743A_SDB_PIN); + gpio_set_pin_output(IS31FL3743A_SDB_PIN); + gpio_write_pin_high(IS31FL3743A_SDB_PIN); #endif for (uint8_t i = 0; i < IS31FL3743A_DRIVER_COUNT; i++) { diff --git a/drivers/led/issi/is31fl3743a.c b/drivers/led/issi/is31fl3743a.c index 135e20710d..6f13925f27 100644 --- a/drivers/led/issi/is31fl3743a.c +++ b/drivers/led/issi/is31fl3743a.c @@ -138,8 +138,8 @@ void is31fl3743a_init_drivers(void) { i2c_init(); #if defined(IS31FL3743A_SDB_PIN) - setPinOutput(IS31FL3743A_SDB_PIN); - writePinHigh(IS31FL3743A_SDB_PIN); + gpio_set_pin_output(IS31FL3743A_SDB_PIN); + gpio_write_pin_high(IS31FL3743A_SDB_PIN); #endif for (uint8_t i = 0; i < IS31FL3743A_DRIVER_COUNT; i++) { diff --git a/drivers/led/issi/is31fl3745-mono.c b/drivers/led/issi/is31fl3745-mono.c index c5d083b272..a6ab699245 100644 --- a/drivers/led/issi/is31fl3745-mono.c +++ b/drivers/led/issi/is31fl3745-mono.c @@ -138,8 +138,8 @@ void is31fl3745_init_drivers(void) { i2c_init(); #if defined(IS31FL3745_SDB_PIN) - setPinOutput(IS31FL3745_SDB_PIN); - writePinHigh(IS31FL3745_SDB_PIN); + gpio_set_pin_output(IS31FL3745_SDB_PIN); + gpio_write_pin_high(IS31FL3745_SDB_PIN); #endif for (uint8_t i = 0; i < IS31FL3745_DRIVER_COUNT; i++) { diff --git a/drivers/led/issi/is31fl3745.c b/drivers/led/issi/is31fl3745.c index 273fddf1d4..1e3b437e02 100644 --- a/drivers/led/issi/is31fl3745.c +++ b/drivers/led/issi/is31fl3745.c @@ -138,8 +138,8 @@ void is31fl3745_init_drivers(void) { i2c_init(); #if defined(IS31FL3745_SDB_PIN) - setPinOutput(IS31FL3745_SDB_PIN); - writePinHigh(IS31FL3745_SDB_PIN); + gpio_set_pin_output(IS31FL3745_SDB_PIN); + gpio_write_pin_high(IS31FL3745_SDB_PIN); #endif for (uint8_t i = 0; i < IS31FL3745_DRIVER_COUNT; i++) { diff --git a/drivers/led/issi/is31fl3746a-mono.c b/drivers/led/issi/is31fl3746a-mono.c index 69d5079929..6bff10723f 100644 --- a/drivers/led/issi/is31fl3746a-mono.c +++ b/drivers/led/issi/is31fl3746a-mono.c @@ -116,8 +116,8 @@ void is31fl3746a_init_drivers(void) { i2c_init(); #if defined(IS31FL3746A_SDB_PIN) - setPinOutput(IS31FL3746A_SDB_PIN); - writePinHigh(IS31FL3746A_SDB_PIN); + gpio_set_pin_output(IS31FL3746A_SDB_PIN); + gpio_write_pin_high(IS31FL3746A_SDB_PIN); #endif for (uint8_t i = 0; i < IS31FL3746A_DRIVER_COUNT; i++) { diff --git a/drivers/led/issi/is31fl3746a.c b/drivers/led/issi/is31fl3746a.c index c9dfbc5c40..1ef0b2d632 100644 --- a/drivers/led/issi/is31fl3746a.c +++ b/drivers/led/issi/is31fl3746a.c @@ -116,8 +116,8 @@ void is31fl3746a_init_drivers(void) { i2c_init(); #if defined(IS31FL3746A_SDB_PIN) - setPinOutput(IS31FL3746A_SDB_PIN); - writePinHigh(IS31FL3746A_SDB_PIN); + gpio_set_pin_output(IS31FL3746A_SDB_PIN); + gpio_write_pin_high(IS31FL3746A_SDB_PIN); #endif for (uint8_t i = 0; i < IS31FL3746A_DRIVER_COUNT; i++) { diff --git a/drivers/led/snled27351-mono.c b/drivers/led/snled27351-mono.c index e13fd8a343..d87b856db6 100644 --- a/drivers/led/snled27351-mono.c +++ b/drivers/led/snled27351-mono.c @@ -105,8 +105,8 @@ void snled27351_init_drivers(void) { i2c_init(); #if defined(SNLED27351_SDB_PIN) - setPinOutput(SNLED27351_SDB_PIN); - writePinHigh(SNLED27351_SDB_PIN); + gpio_set_pin_output(SNLED27351_SDB_PIN); + gpio_write_pin_high(SNLED27351_SDB_PIN); #endif for (uint8_t i = 0; i < SNLED27351_DRIVER_COUNT; i++) { diff --git a/drivers/led/snled27351.c b/drivers/led/snled27351.c index 293685b01b..8ebf681bdb 100644 --- a/drivers/led/snled27351.c +++ b/drivers/led/snled27351.c @@ -105,8 +105,8 @@ void snled27351_init_drivers(void) { i2c_init(); #if defined(SNLED27351_SDB_PIN) - setPinOutput(SNLED27351_SDB_PIN); - writePinHigh(SNLED27351_SDB_PIN); + gpio_set_pin_output(SNLED27351_SDB_PIN); + gpio_write_pin_high(SNLED27351_SDB_PIN); #endif for (uint8_t i = 0; i < SNLED27351_DRIVER_COUNT; i++) { diff --git a/drivers/oled/oled_driver.c b/drivers/oled/oled_driver.c index 8cca41394f..1d1c2a90c4 100644 --- a/drivers/oled/oled_driver.c +++ b/drivers/oled/oled_driver.c @@ -192,7 +192,7 @@ __attribute__((weak)) bool oled_send_cmd(const uint8_t *data, uint16_t size) { return false; } // Command Mode - writePinLow(OLED_DC_PIN); + gpio_write_pin_low(OLED_DC_PIN); // Send the commands if (spi_transmit(&data[1], size - 1) != SPI_STATUS_SUCCESS) { spi_stop(); @@ -215,7 +215,7 @@ __attribute__((weak)) bool oled_send_cmd_P(const uint8_t *data, uint16_t size) { } spi_status_t status = SPI_STATUS_SUCCESS; // Command Mode - writePinLow(OLED_DC_PIN); + gpio_write_pin_low(OLED_DC_PIN); // Send the commands for (uint16_t i = 1; i < size && status >= 0; i++) { status = spi_write(pgm_read_byte((const char *)&data[i])); @@ -239,7 +239,7 @@ __attribute__((weak)) bool oled_send_data(const uint8_t *data, uint16_t size) { return false; } // Data Mode - writePinHigh(OLED_DC_PIN); + gpio_write_pin_high(OLED_DC_PIN); // Send the commands if (spi_transmit(data, size) != SPI_STATUS_SUCCESS) { spi_stop(); @@ -256,17 +256,17 @@ __attribute__((weak)) bool oled_send_data(const uint8_t *data, uint16_t size) { __attribute__((weak)) void oled_driver_init(void) { #if defined(OLED_TRANSPORT_SPI) spi_init(); - setPinOutput(OLED_CS_PIN); - writePinHigh(OLED_CS_PIN); + gpio_set_pin_output(OLED_CS_PIN); + gpio_write_pin_high(OLED_CS_PIN); - setPinOutput(OLED_DC_PIN); - writePinLow(OLED_DC_PIN); + gpio_set_pin_output(OLED_DC_PIN); + gpio_write_pin_low(OLED_DC_PIN); # ifdef OLED_RST_PIN /* Reset device */ - setPinOutput(OLED_RST_PIN); - writePinLow(OLED_RST_PIN); + gpio_set_pin_output(OLED_RST_PIN); + gpio_write_pin_low(OLED_RST_PIN); wait_ms(20); - writePinHigh(OLED_RST_PIN); + gpio_write_pin_high(OLED_RST_PIN); wait_ms(20); # endif #elif defined(OLED_TRANSPORT_I2C) diff --git a/drivers/painter/comms/qp_comms_spi.c b/drivers/painter/comms/qp_comms_spi.c index 9f52bc7d1f..4e6067394b 100644 --- a/drivers/painter/comms/qp_comms_spi.c +++ b/drivers/painter/comms/qp_comms_spi.c @@ -17,8 +17,8 @@ bool qp_comms_spi_init(painter_device_t device) { spi_init(); // Set up CS as output high - setPinOutput(comms_config->chip_select_pin); - writePinHigh(comms_config->chip_select_pin); + gpio_set_pin_output(comms_config->chip_select_pin); + gpio_write_pin_high(comms_config->chip_select_pin); return true; } @@ -49,7 +49,7 @@ void qp_comms_spi_stop(painter_device_t device) { painter_driver_t * driver = (painter_driver_t *)device; qp_comms_spi_config_t *comms_config = (qp_comms_spi_config_t *)driver->comms_config; spi_stop(); - writePinHigh(comms_config->chip_select_pin); + gpio_write_pin_high(comms_config->chip_select_pin); } const painter_comms_vtable_t spi_comms_vtable = { @@ -74,16 +74,16 @@ bool qp_comms_spi_dc_reset_init(painter_device_t device) { // Set up D/C as output low, if specified if (comms_config->dc_pin != NO_PIN) { - setPinOutput(comms_config->dc_pin); - writePinLow(comms_config->dc_pin); + gpio_set_pin_output(comms_config->dc_pin); + gpio_write_pin_low(comms_config->dc_pin); } // Set up RST as output, if specified, performing a reset in the process if (comms_config->reset_pin != NO_PIN) { - setPinOutput(comms_config->reset_pin); - writePinLow(comms_config->reset_pin); + gpio_set_pin_output(comms_config->reset_pin); + gpio_write_pin_low(comms_config->reset_pin); wait_ms(20); - writePinHigh(comms_config->reset_pin); + gpio_write_pin_high(comms_config->reset_pin); wait_ms(20); } @@ -93,14 +93,14 @@ bool qp_comms_spi_dc_reset_init(painter_device_t device) { uint32_t qp_comms_spi_dc_reset_send_data(painter_device_t device, const void *data, uint32_t byte_count) { painter_driver_t * driver = (painter_driver_t *)device; qp_comms_spi_dc_reset_config_t *comms_config = (qp_comms_spi_dc_reset_config_t *)driver->comms_config; - writePinHigh(comms_config->dc_pin); + gpio_write_pin_high(comms_config->dc_pin); return qp_comms_spi_send_data(device, data, byte_count); } void qp_comms_spi_dc_reset_send_command(painter_device_t device, uint8_t cmd) { painter_driver_t * driver = (painter_driver_t *)device; qp_comms_spi_dc_reset_config_t *comms_config = (qp_comms_spi_dc_reset_config_t *)driver->comms_config; - writePinLow(comms_config->dc_pin); + gpio_write_pin_low(comms_config->dc_pin); spi_write(cmd); } diff --git a/drivers/sensors/adns5050.c b/drivers/sensors/adns5050.c index b76268fba2..97daa8db09 100644 --- a/drivers/sensors/adns5050.c +++ b/drivers/sensors/adns5050.c @@ -47,9 +47,9 @@ void adns5050_init(void) { // Initialize the ADNS serial pins. - setPinOutput(ADNS5050_SCLK_PIN); - setPinOutput(ADNS5050_SDIO_PIN); - setPinOutput(ADNS5050_CS_PIN); + gpio_set_pin_output(ADNS5050_SCLK_PIN); + gpio_set_pin_output(ADNS5050_SDIO_PIN); + gpio_set_pin_output(ADNS5050_CS_PIN); // reboot the adns. // if the adns hasn't initialized yet, this is harmless. @@ -69,30 +69,30 @@ void adns5050_init(void) { // Just as with the serial protocol, this is used by the slave to send a // synchronization signal to the master. void adns5050_sync(void) { - writePinLow(ADNS5050_CS_PIN); + gpio_write_pin_low(ADNS5050_CS_PIN); wait_us(1); - writePinHigh(ADNS5050_CS_PIN); + gpio_write_pin_high(ADNS5050_CS_PIN); } void adns5050_cs_select(void) { - writePinLow(ADNS5050_CS_PIN); + gpio_write_pin_low(ADNS5050_CS_PIN); } void adns5050_cs_deselect(void) { - writePinHigh(ADNS5050_CS_PIN); + gpio_write_pin_high(ADNS5050_CS_PIN); } uint8_t adns5050_serial_read(void) { - setPinInput(ADNS5050_SDIO_PIN); + gpio_set_pin_input(ADNS5050_SDIO_PIN); uint8_t byte = 0; for (uint8_t i = 0; i < 8; ++i) { - writePinLow(ADNS5050_SCLK_PIN); + gpio_write_pin_low(ADNS5050_SCLK_PIN); wait_us(1); - byte = (byte << 1) | readPin(ADNS5050_SDIO_PIN); + byte = (byte << 1) | gpio_read_pin(ADNS5050_SDIO_PIN); - writePinHigh(ADNS5050_SCLK_PIN); + gpio_write_pin_high(ADNS5050_SCLK_PIN); wait_us(1); } @@ -100,19 +100,19 @@ uint8_t adns5050_serial_read(void) { } void adns5050_serial_write(uint8_t data) { - setPinOutput(ADNS5050_SDIO_PIN); + gpio_set_pin_output(ADNS5050_SDIO_PIN); for (int8_t b = 7; b >= 0; b--) { - writePinLow(ADNS5050_SCLK_PIN); + gpio_write_pin_low(ADNS5050_SCLK_PIN); if (data & (1 << b)) - writePinHigh(ADNS5050_SDIO_PIN); + gpio_write_pin_high(ADNS5050_SDIO_PIN); else - writePinLow(ADNS5050_SDIO_PIN); + gpio_write_pin_low(ADNS5050_SDIO_PIN); wait_us(2); - writePinHigh(ADNS5050_SCLK_PIN); + gpio_write_pin_high(ADNS5050_SCLK_PIN); } // tSWR. See page 15 of the ADNS spec sheet. diff --git a/drivers/sensors/adns9800.c b/drivers/sensors/adns9800.c index 083ab34d9f..f34529ee90 100644 --- a/drivers/sensors/adns9800.c +++ b/drivers/sensors/adns9800.c @@ -100,7 +100,7 @@ uint8_t adns9800_read(uint8_t reg_addr) { } void adns9800_init(void) { - setPinOutput(ADNS9800_CS_PIN); + gpio_set_pin_output(ADNS9800_CS_PIN); spi_init(); diff --git a/drivers/sensors/analog_joystick.c b/drivers/sensors/analog_joystick.c index 221625075c..15b35a45f2 100644 --- a/drivers/sensors/analog_joystick.c +++ b/drivers/sensors/analog_joystick.c @@ -122,17 +122,17 @@ report_analog_joystick_t analog_joystick_read(void) { report.y = axisToMouseComponent(ANALOG_JOYSTICK_Y_AXIS_PIN, yOrigin, maxCursorSpeed, 1); } #ifdef ANALOG_JOYSTICK_CLICK_PIN - report.button = !readPin(ANALOG_JOYSTICK_CLICK_PIN); + report.button = !gpio_read_pin(ANALOG_JOYSTICK_CLICK_PIN); #endif return report; } void analog_joystick_init(void) { - setPinInputHigh(ANALOG_JOYSTICK_X_AXIS_PIN); - setPinInputHigh(ANALOG_JOYSTICK_Y_AXIS_PIN); + gpio_set_pin_input_high(ANALOG_JOYSTICK_X_AXIS_PIN); + gpio_set_pin_input_high(ANALOG_JOYSTICK_Y_AXIS_PIN); #ifdef ANALOG_JOYSTICK_CLICK_PIN - setPinInputHigh(ANALOG_JOYSTICK_CLICK_PIN); + gpio_set_pin_input_high(ANALOG_JOYSTICK_CLICK_PIN); #endif // Account for drift xOrigin = analogReadPin(ANALOG_JOYSTICK_X_AXIS_PIN); diff --git a/drivers/sensors/paw3204.c b/drivers/sensors/paw3204.c index a13753dd6f..28c47522ed 100644 --- a/drivers/sensors/paw3204.c +++ b/drivers/sensors/paw3204.c @@ -51,8 +51,8 @@ uint8_t paw3204_read_reg(uint8_t reg_addr); void paw3204_write_reg(uint8_t reg_addr, uint8_t data); void paw3204_init(void) { - setPinOutput(PAW3204_SCLK_PIN); // setclockpin to output - setPinInputHigh(PAW3204_SDIO_PIN); // set datapin input high + gpio_set_pin_output(PAW3204_SCLK_PIN); // setclockpin to output + gpio_set_pin_input_high(PAW3204_SDIO_PIN); // set datapin input high paw3204_write_reg(REG_SETUP, 0x86); // reset sensor and set 1600cpi wait_us(5); @@ -64,16 +64,16 @@ void paw3204_init(void) { } uint8_t paw3204_serial_read(void) { - setPinInput(PAW3204_SDIO_PIN); + gpio_set_pin_input(PAW3204_SDIO_PIN); uint8_t byte = 0; for (uint8_t i = 0; i < 8; ++i) { - writePinLow(PAW3204_SCLK_PIN); + gpio_write_pin_low(PAW3204_SCLK_PIN); wait_us(1); - byte = (byte << 1) | readPin(PAW3204_SDIO_PIN); + byte = (byte << 1) | gpio_read_pin(PAW3204_SDIO_PIN); - writePinHigh(PAW3204_SCLK_PIN); + gpio_write_pin_high(PAW3204_SCLK_PIN); wait_us(1); } @@ -81,17 +81,17 @@ uint8_t paw3204_serial_read(void) { } void paw3204_serial_write(uint8_t data) { - writePinLow(PAW3204_SDIO_PIN); - setPinOutput(PAW3204_SDIO_PIN); + gpio_write_pin_low(PAW3204_SDIO_PIN); + gpio_set_pin_output(PAW3204_SDIO_PIN); for (int8_t b = 7; b >= 0; b--) { - writePinLow(PAW3204_SCLK_PIN); + gpio_write_pin_low(PAW3204_SCLK_PIN); if (data & (1 << b)) { - writePinHigh(PAW3204_SDIO_PIN); + gpio_write_pin_high(PAW3204_SDIO_PIN); } else { - writePinLow(PAW3204_SDIO_PIN); + gpio_write_pin_low(PAW3204_SDIO_PIN); } - writePinHigh(PAW3204_SCLK_PIN); + gpio_write_pin_high(PAW3204_SCLK_PIN); } wait_us(4); diff --git a/drivers/sensors/pmw3320.c b/drivers/sensors/pmw3320.c index 69a584f4e1..f19fbfd1ab 100644 --- a/drivers/sensors/pmw3320.c +++ b/drivers/sensors/pmw3320.c @@ -24,9 +24,9 @@ void pmw3320_init(void) { // Initialize sensor serial pins. - setPinOutput(PMW3320_SCLK_PIN); - setPinOutput(PMW3320_SDIO_PIN); - setPinOutput(PMW3320_CS_PIN); + gpio_set_pin_output(PMW3320_SCLK_PIN); + gpio_set_pin_output(PMW3320_SDIO_PIN); + gpio_set_pin_output(PMW3320_CS_PIN); // reboot the sensor. pmw3320_write_reg(REG_Power_Up_Reset, 0x5a); @@ -54,30 +54,30 @@ void pmw3320_init(void) { // Just as with the serial protocol, this is used by the slave to send a // synchronization signal to the master. void pmw3320_sync(void) { - writePinLow(PMW3320_CS_PIN); + gpio_write_pin_low(PMW3320_CS_PIN); wait_us(1); - writePinHigh(PMW3320_CS_PIN); + gpio_write_pin_high(PMW3320_CS_PIN); } void pmw3320_cs_select(void) { - writePinLow(PMW3320_CS_PIN); + gpio_write_pin_low(PMW3320_CS_PIN); } void pmw3320_cs_deselect(void) { - writePinHigh(PMW3320_CS_PIN); + gpio_write_pin_high(PMW3320_CS_PIN); } uint8_t pmw3320_serial_read(void) { - setPinInput(PMW3320_SDIO_PIN); + gpio_set_pin_input(PMW3320_SDIO_PIN); uint8_t byte = 0; for (uint8_t i = 0; i < 8; ++i) { - writePinLow(PMW3320_SCLK_PIN); + gpio_write_pin_low(PMW3320_SCLK_PIN); wait_us(1); - byte = (byte << 1) | readPin(PMW3320_SDIO_PIN); + byte = (byte << 1) | gpio_read_pin(PMW3320_SDIO_PIN); - writePinHigh(PMW3320_SCLK_PIN); + gpio_write_pin_high(PMW3320_SCLK_PIN); wait_us(1); } @@ -85,19 +85,19 @@ uint8_t pmw3320_serial_read(void) { } void pmw3320_serial_write(uint8_t data) { - setPinOutput(PMW3320_SDIO_PIN); + gpio_set_pin_output(PMW3320_SDIO_PIN); for (int8_t b = 7; b >= 0; b--) { - writePinLow(PMW3320_SCLK_PIN); + gpio_write_pin_low(PMW3320_SCLK_PIN); if (data & (1 << b)) - writePinHigh(PMW3320_SDIO_PIN); + gpio_write_pin_high(PMW3320_SDIO_PIN); else - writePinLow(PMW3320_SDIO_PIN); + gpio_write_pin_low(PMW3320_SDIO_PIN); wait_us(2); - writePinHigh(PMW3320_SCLK_PIN); + gpio_write_pin_high(PMW3320_SCLK_PIN); } // This was taken from ADNS5050 driver. diff --git a/drivers/usb2422.c b/drivers/usb2422.c index 1d33b5acf8..de0e399f87 100644 --- a/drivers/usb2422.c +++ b/drivers/usb2422.c @@ -346,10 +346,10 @@ static void USB2422_write_block(void) { void USB2422_init(void) { #ifdef USB2422_RESET_PIN - setPinOutput(USB2422_RESET_PIN); + gpio_set_pin_output(USB2422_RESET_PIN); #endif #ifdef USB2422_ACTIVE_PIN - setPinInput(USB2422_ACTIVE_PIN); + gpio_set_pin_input(USB2422_ACTIVE_PIN); #endif i2c_init(); // IC2 clk must be high at USB2422 reset release time to signal SMB configuration @@ -387,15 +387,15 @@ void USB2422_configure(void) { void USB2422_reset(void) { #ifdef USB2422_RESET_PIN - writePinLow(USB2422_RESET_PIN); + gpio_write_pin_low(USB2422_RESET_PIN); wait_us(2); - writePinHigh(USB2422_RESET_PIN); + gpio_write_pin_high(USB2422_RESET_PIN); #endif } bool USB2422_active(void) { #ifdef USB2422_ACTIVE_PIN - return readPin(USB2422_ACTIVE_PIN); + return gpio_read_pin(USB2422_ACTIVE_PIN); #else return 1; #endif diff --git a/keyboards/handwired/onekey/keymaps/chibios_waiting_test/keymap.c b/keyboards/handwired/onekey/keymaps/chibios_waiting_test/keymap.c index 65983c8dd8..361a08a760 100644 --- a/keyboards/handwired/onekey/keymaps/chibios_waiting_test/keymap.c +++ b/keyboards/handwired/onekey/keymaps/chibios_waiting_test/keymap.c @@ -13,20 +13,20 @@ static inline void chThdSleepMicroseconds(uint32_t us) { #endif void keyboard_post_init_user(void) { - setPinOutput(QMK_WAITING_TEST_BUSY_PIN); - setPinOutput(QMK_WAITING_TEST_YIELD_PIN); + gpio_set_pin_output(QMK_WAITING_TEST_BUSY_PIN); + gpio_set_pin_output(QMK_WAITING_TEST_YIELD_PIN); } static inline void wait_us_polling_with_strobe(uint32_t us) { - writePinHigh(QMK_WAITING_TEST_BUSY_PIN); + gpio_write_pin_high(QMK_WAITING_TEST_BUSY_PIN); wait_us(us); - writePinLow(QMK_WAITING_TEST_BUSY_PIN); + gpio_write_pin_low(QMK_WAITING_TEST_BUSY_PIN); } static inline void wait_us_yield_with_strobe(uint32_t us) { - writePinHigh(QMK_WAITING_TEST_YIELD_PIN); + gpio_write_pin_high(QMK_WAITING_TEST_YIELD_PIN); chThdSleepMicroseconds(us); - writePinLow(QMK_WAITING_TEST_YIELD_PIN); + gpio_write_pin_low(QMK_WAITING_TEST_YIELD_PIN); } static const uint32_t waiting_values[] = {0, 1, 5, 10, 25, 50, 100, 150, 200, 500, 1000}; diff --git a/platforms/avr/drivers/audio_pwm_hardware.c b/platforms/avr/drivers/audio_pwm_hardware.c index 6799cf2fdd..d484fba00f 100644 --- a/platforms/avr/drivers/audio_pwm_hardware.c +++ b/platforms/avr/drivers/audio_pwm_hardware.c @@ -216,12 +216,12 @@ void channel_2_stop(void) { void audio_driver_initialize(void) { #ifdef AUDIO1_PIN_SET channel_1_stop(); - setPinOutput(AUDIO1_PIN); + gpio_set_pin_output(AUDIO1_PIN); #endif #ifdef AUDIO2_PIN_SET channel_2_stop(); - setPinOutput(AUDIO2_PIN); + gpio_set_pin_output(AUDIO2_PIN); #endif // TCCR3A / TCCR3B: Timer/Counter #3 Control Registers TCCR3A/TCCR3B, TCCR1A/TCCR1B diff --git a/platforms/avr/drivers/backlight_pwm.c b/platforms/avr/drivers/backlight_pwm.c index 74d25753a4..f6ab9391e2 100644 --- a/platforms/avr/drivers/backlight_pwm.c +++ b/platforms/avr/drivers/backlight_pwm.c @@ -291,11 +291,11 @@ ISR(TIMERx_OVF_vect) { #endif // BACKLIGHT_BREATHING void backlight_init_ports(void) { - setPinOutput(BACKLIGHT_PIN); + gpio_set_pin_output(BACKLIGHT_PIN); #if BACKLIGHT_ON_STATE == 1 - writePinLow(BACKLIGHT_PIN); + gpio_write_pin_low(BACKLIGHT_PIN); #else - writePinHigh(BACKLIGHT_PIN); + gpio_write_pin_high(BACKLIGHT_PIN); #endif // I could write a wall of text here to explain... but TL;DW diff --git a/platforms/avr/drivers/ps2/ps2_io.c b/platforms/avr/drivers/ps2/ps2_io.c index b75a1ab0be..fb87474372 100644 --- a/platforms/avr/drivers/ps2/ps2_io.c +++ b/platforms/avr/drivers/ps2/ps2_io.c @@ -19,18 +19,18 @@ void clock_init(void) {} void clock_lo(void) { // Transition from input with pull-up to output low via Hi-Z instead of output high - writePinLow(PS2_CLOCK_PIN); - setPinOutput(PS2_CLOCK_PIN); + gpio_write_pin_low(PS2_CLOCK_PIN); + gpio_set_pin_output(PS2_CLOCK_PIN); } void clock_hi(void) { - setPinInputHigh(PS2_CLOCK_PIN); + gpio_set_pin_input_high(PS2_CLOCK_PIN); } bool clock_in(void) { - setPinInputHigh(PS2_CLOCK_PIN); + gpio_set_pin_input_high(PS2_CLOCK_PIN); wait_us(1); - return readPin(PS2_CLOCK_PIN); + return gpio_read_pin(PS2_CLOCK_PIN); } /* @@ -40,16 +40,16 @@ void data_init(void) {} void data_lo(void) { // Transition from input with pull-up to output low via Hi-Z instead of output high - writePinLow(PS2_DATA_PIN); - setPinOutput(PS2_DATA_PIN); + gpio_write_pin_low(PS2_DATA_PIN); + gpio_set_pin_output(PS2_DATA_PIN); } void data_hi(void) { - setPinInputHigh(PS2_DATA_PIN); + gpio_set_pin_input_high(PS2_DATA_PIN); } bool data_in(void) { - setPinInputHigh(PS2_DATA_PIN); + gpio_set_pin_input_high(PS2_DATA_PIN); wait_us(1); - return readPin(PS2_DATA_PIN); + return gpio_read_pin(PS2_DATA_PIN); } diff --git a/platforms/avr/drivers/serial.c b/platforms/avr/drivers/serial.c index 730d9b7a01..b529f9b45e 100644 --- a/platforms/avr/drivers/serial.c +++ b/platforms/avr/drivers/serial.c @@ -239,28 +239,28 @@ inline static void serial_delay_half2(void) { inline static void serial_output(void) ALWAYS_INLINE; inline static void serial_output(void) { - setPinOutput(SOFT_SERIAL_PIN); + gpio_set_pin_output(SOFT_SERIAL_PIN); } // make the serial pin an input with pull-up resistor inline static void serial_input_with_pullup(void) ALWAYS_INLINE; inline static void serial_input_with_pullup(void) { - setPinInputHigh(SOFT_SERIAL_PIN); + gpio_set_pin_input_high(SOFT_SERIAL_PIN); } inline static uint8_t serial_read_pin(void) ALWAYS_INLINE; inline static uint8_t serial_read_pin(void) { - return !!readPin(SOFT_SERIAL_PIN); + return !!gpio_read_pin(SOFT_SERIAL_PIN); } inline static void serial_low(void) ALWAYS_INLINE; inline static void serial_low(void) { - writePinLow(SOFT_SERIAL_PIN); + gpio_write_pin_low(SOFT_SERIAL_PIN); } inline static void serial_high(void) ALWAYS_INLINE; inline static void serial_high(void) { - writePinHigh(SOFT_SERIAL_PIN); + gpio_write_pin_high(SOFT_SERIAL_PIN); } void soft_serial_initiator_init(void) { diff --git a/platforms/avr/drivers/spi_master.c b/platforms/avr/drivers/spi_master.c index ae9df03c02..74b847c71a 100644 --- a/platforms/avr/drivers/spi_master.c +++ b/platforms/avr/drivers/spi_master.c @@ -41,10 +41,10 @@ static uint8_t currentSlaveConfig = 0; static bool currentSlave2X = false; void spi_init(void) { - writePinHigh(SPI_SS_PIN); - setPinOutput(SPI_SCK_PIN); - setPinOutput(SPI_MOSI_PIN); - setPinInput(SPI_MISO_PIN); + gpio_write_pin_high(SPI_SS_PIN); + gpio_set_pin_output(SPI_SCK_PIN); + gpio_set_pin_output(SPI_MOSI_PIN); + gpio_set_pin_input(SPI_MISO_PIN); SPCR = (_BV(SPE) | _BV(MSTR)); } @@ -105,8 +105,8 @@ bool spi_start(pin_t slavePin, bool lsbFirst, uint8_t mode, uint16_t divisor) { SPSR |= _BV(SPI2X); } currentSlavePin = slavePin; - setPinOutput(currentSlavePin); - writePinLow(currentSlavePin); + gpio_set_pin_output(currentSlavePin); + gpio_write_pin_low(currentSlavePin); return true; } @@ -169,8 +169,8 @@ spi_status_t spi_receive(uint8_t *data, uint16_t length) { void spi_stop(void) { if (currentSlavePin != NO_PIN) { - setPinOutput(currentSlavePin); - writePinHigh(currentSlavePin); + gpio_set_pin_output(currentSlavePin); + gpio_write_pin_high(currentSlavePin); currentSlavePin = NO_PIN; SPSR &= ~(_BV(SPI2X)); SPCR &= ~(currentSlaveConfig); diff --git a/platforms/chibios/drivers/serial.c b/platforms/chibios/drivers/serial.c index f199716a2b..fa8481d2dc 100644 --- a/platforms/chibios/drivers/serial.c +++ b/platforms/chibios/drivers/serial.c @@ -62,25 +62,25 @@ inline static void serial_delay_blip(void) { wait_us(1); } inline static void serial_output(void) { - setPinOutput(SOFT_SERIAL_PIN); + gpio_set_pin_output(SOFT_SERIAL_PIN); } inline static void serial_input(void) { - setPinInputHigh(SOFT_SERIAL_PIN); + gpio_set_pin_input_high(SOFT_SERIAL_PIN); } inline static bool serial_read_pin(void) { - return !!readPin(SOFT_SERIAL_PIN); + return !!gpio_read_pin(SOFT_SERIAL_PIN); } inline static void serial_low(void) { - writePinLow(SOFT_SERIAL_PIN); + gpio_write_pin_low(SOFT_SERIAL_PIN); } inline static void serial_high(void) { - writePinHigh(SOFT_SERIAL_PIN); + gpio_write_pin_high(SOFT_SERIAL_PIN); } void interrupt_handler(void *arg); // Use thread + palWaitLineTimeout instead of palSetLineCallback -// - Methods like setPinOutput and palEnableLineEvent/palDisableLineEvent +// - Methods like gpio_set_pin_output and palEnableLineEvent/palDisableLineEvent // cause the interrupt to lock up, which would limit to only receiving data... static THD_WORKING_AREA(waThread1, 128); static THD_FUNCTION(Thread1, arg) { diff --git a/platforms/chibios/drivers/spi_master.c b/platforms/chibios/drivers/spi_master.c index 481a2e422a..57fc53d49f 100644 --- a/platforms/chibios/drivers/spi_master.c +++ b/platforms/chibios/drivers/spi_master.c @@ -32,12 +32,12 @@ __attribute__((weak)) void spi_init(void) { is_initialised = true; // Try releasing special pins for a short time - setPinInput(SPI_SCK_PIN); + gpio_set_pin_input(SPI_SCK_PIN); if (SPI_MOSI_PIN != NO_PIN) { - setPinInput(SPI_MOSI_PIN); + gpio_set_pin_input(SPI_MOSI_PIN); } if (SPI_MISO_PIN != NO_PIN) { - setPinInput(SPI_MISO_PIN); + gpio_set_pin_input(SPI_MISO_PIN); } chThdSleepMilliseconds(10); @@ -271,10 +271,10 @@ bool spi_start(pin_t slavePin, bool lsbFirst, uint8_t mode, uint16_t divisor) { #if SPI_SELECT_MODE == SPI_SELECT_MODE_PAD spiConfig.ssport = PAL_PORT(slavePin); spiConfig.sspad = PAL_PAD(slavePin); - setPinOutput(slavePin); + gpio_set_pin_output(slavePin); #elif SPI_SELECT_MODE == SPI_SELECT_MODE_NONE if (slavePin != NO_PIN) { - setPinOutput(slavePin); + gpio_set_pin_output(slavePin); } #else # error "Unsupported SPI_SELECT_MODE" @@ -284,7 +284,7 @@ bool spi_start(pin_t slavePin, bool lsbFirst, uint8_t mode, uint16_t divisor) { spiSelect(&SPI_DRIVER); #if SPI_SELECT_MODE == SPI_SELECT_MODE_NONE if (slavePin != NO_PIN) { - writePinLow(slavePin); + gpio_write_pin_low(slavePin); } #endif @@ -319,7 +319,7 @@ void spi_stop(void) { if (spiStarted) { #if SPI_SELECT_MODE == SPI_SELECT_MODE_NONE if (currentSlavePin != NO_PIN) { - writePinHigh(currentSlavePin); + gpio_write_pin_high(currentSlavePin); } #endif spiUnselect(&SPI_DRIVER); diff --git a/platforms/chibios/drivers/ws2812_bitbang.c b/platforms/chibios/drivers/ws2812_bitbang.c index 883a845d88..593377068b 100644 --- a/platforms/chibios/drivers/ws2812_bitbang.c +++ b/platforms/chibios/drivers/ws2812_bitbang.c @@ -57,15 +57,15 @@ void sendByte(uint8_t byte) { // using something like wait_ns(is_one ? T1L : T0L) here throws off timings if (is_one) { // 1 - writePinHigh(WS2812_DI_PIN); + gpio_write_pin_high(WS2812_DI_PIN); wait_ns(WS2812_T1H); - writePinLow(WS2812_DI_PIN); + gpio_write_pin_low(WS2812_DI_PIN); wait_ns(WS2812_T1L); } else { // 0 - writePinHigh(WS2812_DI_PIN); + gpio_write_pin_high(WS2812_DI_PIN); wait_ns(WS2812_T0H); - writePinLow(WS2812_DI_PIN); + gpio_write_pin_low(WS2812_DI_PIN); wait_ns(WS2812_T0L); } } diff --git a/quantum/backlight/backlight_driver_common.c b/quantum/backlight/backlight_driver_common.c index 8c3fe461d7..fb2770ee3c 100644 --- a/quantum/backlight/backlight_driver_common.c +++ b/quantum/backlight/backlight_driver_common.c @@ -26,23 +26,23 @@ static const pin_t backlight_pin = BACKLIGHT_PIN; static inline void backlight_on(pin_t backlight_pin) { #if BACKLIGHT_ON_STATE == 0 - writePinLow(backlight_pin); + gpio_write_pin_low(backlight_pin); #else - writePinHigh(backlight_pin); + gpio_write_pin_high(backlight_pin); #endif } static inline void backlight_off(pin_t backlight_pin) { #if BACKLIGHT_ON_STATE == 0 - writePinHigh(backlight_pin); + gpio_write_pin_high(backlight_pin); #else - writePinLow(backlight_pin); + gpio_write_pin_low(backlight_pin); #endif } void backlight_pins_init(void) { // Setup backlight pin as output and output to off state. - FOR_EACH_LED(setPinOutput(backlight_pin); backlight_off(backlight_pin);) + FOR_EACH_LED(gpio_set_pin_output(backlight_pin); backlight_off(backlight_pin);) } void backlight_pins_on(void) { diff --git a/quantum/dip_switch.c b/quantum/dip_switch.c index e901f3e0c4..69cf665291 100644 --- a/quantum/dip_switch.c +++ b/quantum/dip_switch.c @@ -94,7 +94,7 @@ void dip_switch_init(void) { } # endif for (uint8_t i = 0; i < NUM_DIP_SWITCHES; i++) { - setPinInputHigh(dip_switch_pad[i]); + gpio_set_pin_input_high(dip_switch_pad[i]); } dip_switch_read(true); #endif @@ -123,7 +123,7 @@ void dip_switch_read(bool forced) { for (uint8_t i = 0; i < NUM_DIP_SWITCHES; i++) { #ifdef DIP_SWITCH_PINS - dip_switch_state[i] = !readPin(dip_switch_pad[i]); + dip_switch_state[i] = !gpio_read_pin(dip_switch_pad[i]); #endif #ifdef DIP_SWITCH_MATRIX_GRID dip_switch_state[i] = peek_matrix(dip_switch_pad[i].row, dip_switch_pad[i].col, read_raw); diff --git a/quantum/encoder.c b/quantum/encoder.c index 7ab194ed52..efb780c474 100644 --- a/quantum/encoder.c +++ b/quantum/encoder.c @@ -162,12 +162,12 @@ void encoder_init(void) { #endif // defined(SPLIT_KEYBOARD) && defined(ENCODER_RESOLUTIONS) for (uint8_t i = 0; i < thisCount; i++) { - setPinInputHigh(encoders_pad_a[i]); - setPinInputHigh(encoders_pad_b[i]); + gpio_set_pin_input_high(encoders_pad_a[i]); + gpio_set_pin_input_high(encoders_pad_b[i]); } encoder_wait_pullup_charge(); for (uint8_t i = 0; i < thisCount; i++) { - encoder_state[i] = (readPin(encoders_pad_a[i]) << 0) | (readPin(encoders_pad_b[i]) << 1); + encoder_state[i] = (gpio_read_pin(encoders_pad_a[i]) << 0) | (gpio_read_pin(encoders_pad_b[i]) << 1); } } @@ -247,7 +247,7 @@ static bool encoder_update(uint8_t index, uint8_t state) { bool encoder_read(void) { bool changed = false; for (uint8_t i = 0; i < thisCount; i++) { - uint8_t new_status = (readPin(encoders_pad_a[i]) << 0) | (readPin(encoders_pad_b[i]) << 1); + uint8_t new_status = (gpio_read_pin(encoders_pad_a[i]) << 0) | (gpio_read_pin(encoders_pad_b[i]) << 1); if ((encoder_state[i] & 0x3) != new_status) { encoder_state[i] <<= 2; encoder_state[i] |= new_status; diff --git a/quantum/haptic.c b/quantum/haptic.c index a1fea29625..6a466293a7 100644 --- a/quantum/haptic.c +++ b/quantum/haptic.c @@ -96,10 +96,10 @@ void haptic_init(void) { #endif eeconfig_debug_haptic(); #ifdef HAPTIC_ENABLE_PIN - setPinOutput(HAPTIC_ENABLE_PIN); + gpio_set_pin_output(HAPTIC_ENABLE_PIN); #endif #ifdef HAPTIC_ENABLE_STATUS_LED - setPinOutput(HAPTIC_ENABLE_STATUS_LED); + gpio_set_pin_output(HAPTIC_ENABLE_STATUS_LED); #endif } @@ -356,9 +356,9 @@ void haptic_shutdown(void) { void haptic_notify_usb_device_state_change(void) { update_haptic_enable_gpios(); #if defined(HAPTIC_ENABLE_PIN) - setPinOutput(HAPTIC_ENABLE_PIN); + gpio_set_pin_output(HAPTIC_ENABLE_PIN); #endif #if defined(HAPTIC_ENABLE_STATUS_LED) - setPinOutput(HAPTIC_ENABLE_STATUS_LED); + gpio_set_pin_output(HAPTIC_ENABLE_STATUS_LED); #endif } diff --git a/quantum/haptic.h b/quantum/haptic.h index 5bd1a71916..b283d5d268 100644 --- a/quantum/haptic.h +++ b/quantum/haptic.h @@ -84,22 +84,22 @@ void haptic_notify_usb_device_state_change(void); # ifndef HAPTIC_ENABLE_PIN # error HAPTIC_ENABLE_PIN not defined # endif -# define HAPTIC_ENABLE_PIN_WRITE_ACTIVE() writePinLow(HAPTIC_ENABLE_PIN) -# define HAPTIC_ENABLE_PIN_WRITE_INACTIVE() writePinHigh(HAPTIC_ENABLE_PIN) +# define HAPTIC_ENABLE_PIN_WRITE_ACTIVE() gpio_write_pin_low(HAPTIC_ENABLE_PIN) +# define HAPTIC_ENABLE_PIN_WRITE_INACTIVE() gpio_write_pin_high(HAPTIC_ENABLE_PIN) #else -# define HAPTIC_ENABLE_PIN_WRITE_ACTIVE() writePinHigh(HAPTIC_ENABLE_PIN) -# define HAPTIC_ENABLE_PIN_WRITE_INACTIVE() writePinLow(HAPTIC_ENABLE_PIN) +# define HAPTIC_ENABLE_PIN_WRITE_ACTIVE() gpio_write_pin_high(HAPTIC_ENABLE_PIN) +# define HAPTIC_ENABLE_PIN_WRITE_INACTIVE() gpio_write_pin_low(HAPTIC_ENABLE_PIN) #endif #ifdef HAPTIC_ENABLE_STATUS_LED_ACTIVE_LOW # ifndef HAPTIC_ENABLE_STATUS_LED # error HAPTIC_ENABLE_STATUS_LED not defined # endif -# define HAPTIC_ENABLE_STATUS_LED_WRITE_ACTIVE() writePinLow(HAPTIC_ENABLE_STATUS_LED) -# define HAPTIC_ENABLE_STATUS_LED_WRITE_INACTIVE() writePinHigh(HAPTIC_ENABLE_STATUS_LED) +# define HAPTIC_ENABLE_STATUS_LED_WRITE_ACTIVE() gpio_write_pin_low(HAPTIC_ENABLE_STATUS_LED) +# define HAPTIC_ENABLE_STATUS_LED_WRITE_INACTIVE() gpio_write_pin_high(HAPTIC_ENABLE_STATUS_LED) #else -# define HAPTIC_ENABLE_STATUS_LED_WRITE_ACTIVE() writePinHigh(HAPTIC_ENABLE_STATUS_LED) -# define HAPTIC_ENABLE_STATUS_LED_WRITE_INACTIVE() writePinLow(HAPTIC_ENABLE_STATUS_LED) +# define HAPTIC_ENABLE_STATUS_LED_WRITE_ACTIVE() gpio_write_pin_high(HAPTIC_ENABLE_STATUS_LED) +# define HAPTIC_ENABLE_STATUS_LED_WRITE_INACTIVE() gpio_write_pin_low(HAPTIC_ENABLE_STATUS_LED) #endif #ifndef HAPTIC_OFF_IN_LOW_POWER diff --git a/quantum/joystick.c b/quantum/joystick.c index 3e9edeb8e2..32f19b2cd9 100644 --- a/quantum/joystick.c +++ b/quantum/joystick.c @@ -43,7 +43,7 @@ __attribute__((weak)) void joystick_axis_init(uint8_t axis) { if (axis >= JOYSTICK_AXIS_COUNT) return; #if defined(JOYSTICK_ANALOG) - setPinInput(joystick_axes[axis].input_pin); + gpio_set_pin_input(joystick_axes[axis].input_pin); #endif } diff --git a/quantum/led.c b/quantum/led.c index 1e7ee9db76..e2b5985109 100644 --- a/quantum/led.c +++ b/quantum/led.c @@ -98,19 +98,19 @@ __attribute__((weak)) void led_update_ports(led_t led_state) { #endif #ifdef LED_NUM_LOCK_PIN - writePin(LED_NUM_LOCK_PIN, led_state.num_lock); + gpio_write_pin(LED_NUM_LOCK_PIN, led_state.num_lock); #endif #ifdef LED_CAPS_LOCK_PIN - writePin(LED_CAPS_LOCK_PIN, led_state.caps_lock); + gpio_write_pin(LED_CAPS_LOCK_PIN, led_state.caps_lock); #endif #ifdef LED_SCROLL_LOCK_PIN - writePin(LED_SCROLL_LOCK_PIN, led_state.scroll_lock); + gpio_write_pin(LED_SCROLL_LOCK_PIN, led_state.scroll_lock); #endif #ifdef LED_COMPOSE_PIN - writePin(LED_COMPOSE_PIN, led_state.compose); + gpio_write_pin(LED_COMPOSE_PIN, led_state.compose); #endif #ifdef LED_KANA_PIN - writePin(LED_KANA_PIN, led_state.kana); + gpio_write_pin(LED_KANA_PIN, led_state.kana); #endif } @@ -118,24 +118,24 @@ __attribute__((weak)) void led_update_ports(led_t led_state) { */ __attribute__((weak)) void led_init_ports(void) { #ifdef LED_NUM_LOCK_PIN - setPinOutput(LED_NUM_LOCK_PIN); - writePin(LED_NUM_LOCK_PIN, !LED_PIN_ON_STATE); + gpio_set_pin_output(LED_NUM_LOCK_PIN); + gpio_write_pin(LED_NUM_LOCK_PIN, !LED_PIN_ON_STATE); #endif #ifdef LED_CAPS_LOCK_PIN - setPinOutput(LED_CAPS_LOCK_PIN); - writePin(LED_CAPS_LOCK_PIN, !LED_PIN_ON_STATE); + gpio_set_pin_output(LED_CAPS_LOCK_PIN); + gpio_write_pin(LED_CAPS_LOCK_PIN, !LED_PIN_ON_STATE); #endif #ifdef LED_SCROLL_LOCK_PIN - setPinOutput(LED_SCROLL_LOCK_PIN); - writePin(LED_SCROLL_LOCK_PIN, !LED_PIN_ON_STATE); + gpio_set_pin_output(LED_SCROLL_LOCK_PIN); + gpio_write_pin(LED_SCROLL_LOCK_PIN, !LED_PIN_ON_STATE); #endif #ifdef LED_COMPOSE_PIN - setPinOutput(LED_COMPOSE_PIN); - writePin(LED_COMPOSE_PIN, !LED_PIN_ON_STATE); + gpio_set_pin_output(LED_COMPOSE_PIN); + gpio_write_pin(LED_COMPOSE_PIN, !LED_PIN_ON_STATE); #endif #ifdef LED_KANA_PIN - setPinOutput(LED_KANA_PIN); - writePin(LED_KANA_PIN, !LED_PIN_ON_STATE); + gpio_set_pin_output(LED_KANA_PIN); + gpio_write_pin(LED_KANA_PIN, !LED_PIN_ON_STATE); #endif } diff --git a/quantum/matrix.c b/quantum/matrix.c index f087a215d4..d4586efac2 100644 --- a/quantum/matrix.c +++ b/quantum/matrix.c @@ -78,27 +78,27 @@ __attribute__((weak)) void matrix_read_rows_on_col(matrix_row_t current_matrix[] static inline void setPinOutput_writeLow(pin_t pin) { ATOMIC_BLOCK_FORCEON { - setPinOutput(pin); - writePinLow(pin); + gpio_set_pin_output(pin); + gpio_write_pin_low(pin); } } static inline void setPinOutput_writeHigh(pin_t pin) { ATOMIC_BLOCK_FORCEON { - setPinOutput(pin); - writePinHigh(pin); + gpio_set_pin_output(pin); + gpio_write_pin_high(pin); } } static inline void setPinInputHigh_atomic(pin_t pin) { ATOMIC_BLOCK_FORCEON { - setPinInputHigh(pin); + gpio_set_pin_input_high(pin); } } static inline uint8_t readMatrixPin(pin_t pin) { if (pin != NO_PIN) { - return (readPin(pin) == MATRIX_INPUT_PRESSED_STATE) ? 0 : 1; + return (gpio_read_pin(pin) == MATRIX_INPUT_PRESSED_STATE) ? 0 : 1; } else { return 1; } @@ -113,7 +113,7 @@ __attribute__((weak)) void matrix_init_pins(void) { for (int col = 0; col < MATRIX_COLS; col++) { pin_t pin = direct_pins[row][col]; if (pin != NO_PIN) { - setPinInputHigh(pin); + gpio_set_pin_input_high(pin); } } } diff --git a/quantum/pointing_device/pointing_device.c b/quantum/pointing_device/pointing_device.c index 2fa49ade8e..bcced166c0 100644 --- a/quantum/pointing_device/pointing_device.c +++ b/quantum/pointing_device/pointing_device.c @@ -149,9 +149,9 @@ __attribute__((weak)) void pointing_device_init(void) { pointing_device_driver.init(); #ifdef POINTING_DEVICE_MOTION_PIN # ifdef POINTING_DEVICE_MOTION_PIN_ACTIVE_LOW - setPinInputHigh(POINTING_DEVICE_MOTION_PIN); + gpio_set_pin_input_high(POINTING_DEVICE_MOTION_PIN); # else - setPinInput(POINTING_DEVICE_MOTION_PIN); + gpio_set_pin_input(POINTING_DEVICE_MOTION_PIN); # endif #endif } @@ -247,9 +247,9 @@ __attribute__((weak)) bool pointing_device_task(void) { # error POINTING_DEVICE_MOTION_PIN not supported when sharing the pointing device report between sides. # endif # ifdef POINTING_DEVICE_MOTION_PIN_ACTIVE_LOW - if (!readPin(POINTING_DEVICE_MOTION_PIN)) + if (!gpio_read_pin(POINTING_DEVICE_MOTION_PIN)) # else - if (readPin(POINTING_DEVICE_MOTION_PIN)) + if (gpio_read_pin(POINTING_DEVICE_MOTION_PIN)) # endif { #endif diff --git a/quantum/split_common/split_util.c b/quantum/split_common/split_util.c index 2f592bd4cf..96f19bfd84 100644 --- a/quantum/split_common/split_util.c +++ b/quantum/split_common/split_util.c @@ -123,14 +123,14 @@ void split_watchdog_task(void) { void matrix_io_delay(void); static uint8_t peek_matrix_intersection(pin_t out_pin, pin_t in_pin) { - setPinInputHigh(in_pin); - setPinOutput(out_pin); - writePinLow(out_pin); + gpio_set_pin_input_high(in_pin); + gpio_set_pin_output(out_pin); + gpio_write_pin_low(out_pin); // It's almost unnecessary, but wait until it's down to low, just in case. wait_us(1); - uint8_t pin_state = readPin(in_pin); + uint8_t pin_state = gpio_read_pin(in_pin); // Set out_pin to a setting that is less susceptible to noise. - setPinInputHigh(out_pin); + gpio_set_pin_input_high(out_pin); matrix_io_delay(); // Wait for the pull-up to go HIGH. return pin_state; } @@ -138,13 +138,13 @@ static uint8_t peek_matrix_intersection(pin_t out_pin, pin_t in_pin) { __attribute__((weak)) bool is_keyboard_left_impl(void) { #if defined(SPLIT_HAND_PIN) - setPinInput(SPLIT_HAND_PIN); + gpio_set_pin_input(SPLIT_HAND_PIN); wait_us(100); // Test pin SPLIT_HAND_PIN for High/Low, if low it's right hand # ifdef SPLIT_HAND_PIN_LOW_IS_LEFT - return !readPin(SPLIT_HAND_PIN); + return !gpio_read_pin(SPLIT_HAND_PIN); # else - return readPin(SPLIT_HAND_PIN); + return gpio_read_pin(SPLIT_HAND_PIN); # endif #elif defined(SPLIT_HAND_MATRIX_GRID) # ifdef SPLIT_HAND_MATRIX_GRID_LOW_IS_LEFT diff --git a/tmk_core/protocol/arm_atsam/shift_register.c b/tmk_core/protocol/arm_atsam/shift_register.c index 3adb682aa8..e81db4a19d 100644 --- a/tmk_core/protocol/arm_atsam/shift_register.c +++ b/tmk_core/protocol/arm_atsam/shift_register.c @@ -28,27 +28,27 @@ along with this program. If not, see . # define CLOCK_DELAY 10 void shift_init_impl(void) { - setPinOutput(SR_EXP_RCLK_PIN); - setPinOutput(SPI_DATAOUT_PIN); - setPinOutput(SPI_SCLK_PIN); + gpio_set_pin_output(SR_EXP_RCLK_PIN); + gpio_set_pin_output(SPI_DATAOUT_PIN); + gpio_set_pin_output(SPI_SCLK_PIN); } void shift_out_impl(const uint8_t *data, uint16_t length) { - writePinLow(SR_EXP_RCLK_PIN); + gpio_write_pin_low(SR_EXP_RCLK_PIN); for (uint16_t i = 0; i < length; i++) { uint8_t val = data[i]; // shift out lsb first for (uint8_t bit = 0; bit < 8; bit++) { - writePin(SPI_DATAOUT_PIN, !!(val & (1 << bit))); - writePin(SPI_SCLK_PIN, true); + gpio_write_pin(SPI_DATAOUT_PIN, !!(val & (1 << bit))); + gpio_write_pin(SPI_SCLK_PIN, true); wait_us(CLOCK_DELAY); - writePin(SPI_SCLK_PIN, false); + gpio_write_pin(SPI_SCLK_PIN, false); wait_us(CLOCK_DELAY); } } - writePinHigh(SR_EXP_RCLK_PIN); + gpio_write_pin_high(SR_EXP_RCLK_PIN); return SPI_STATUS_SUCCESS; } @@ -74,13 +74,13 @@ void shift_out(const uint8_t *data, uint16_t length) { } void shift_enable(void) { - setPinOutput(SR_EXP_OE_PIN); - writePinLow(SR_EXP_OE_PIN); + gpio_set_pin_output(SR_EXP_OE_PIN); + gpio_write_pin_low(SR_EXP_OE_PIN); } void shift_disable(void) { - setPinOutput(SR_EXP_OE_PIN); - writePinHigh(SR_EXP_OE_PIN); + gpio_set_pin_output(SR_EXP_OE_PIN); + gpio_write_pin_high(SR_EXP_OE_PIN); } void shift_init(void) { diff --git a/tmk_core/protocol/arm_atsam/spi_master.c b/tmk_core/protocol/arm_atsam/spi_master.c index 3be82fac1d..fedb9654fd 100644 --- a/tmk_core/protocol/arm_atsam/spi_master.c +++ b/tmk_core/protocol/arm_atsam/spi_master.c @@ -60,8 +60,8 @@ bool spi_start(pin_t csPin, bool lsbFirst, uint8_t mode, uint16_t divisor) { } currentSelectPin = csPin; - setPinOutput(currentSelectPin); - writePinLow(currentSelectPin); + gpio_set_pin_output(currentSelectPin); + gpio_write_pin_low(currentSelectPin); SPI_SERCOM->SPI.CTRLA.bit.DORD = lsbFirst; // Data Order - LSB is transferred first SPI_SERCOM->SPI.CTRLA.bit.CPOL = 1; // Clock Polarity - SCK high when idle. Leading edge of cycle is falling. Trailing rising. @@ -94,8 +94,8 @@ spi_status_t spi_transmit(const uint8_t *data, uint16_t length) { void spi_stop(void) { if (currentSelectPin != NO_PIN) { - setPinOutput(currentSelectPin); - writePinHigh(currentSelectPin); + gpio_set_pin_output(currentSelectPin); + gpio_write_pin_high(currentSelectPin); currentSelectPin = NO_PIN; } } diff --git a/tmk_core/protocol/usb_util.c b/tmk_core/protocol/usb_util.c index 3b3be4a767..a130e8b5e3 100644 --- a/tmk_core/protocol/usb_util.c +++ b/tmk_core/protocol/usb_util.c @@ -26,9 +26,9 @@ __attribute__((weak)) bool usb_connected_state(void) { __attribute__((weak)) bool usb_vbus_state(void) { #ifdef USB_VBUS_PIN - setPinInput(USB_VBUS_PIN); + gpio_set_pin_input(USB_VBUS_PIN); wait_us(5); - return readPin(USB_VBUS_PIN); + return gpio_read_pin(USB_VBUS_PIN); #else return true; #endif -- cgit v1.2.3