From 1fd0049039e920e71cf526075a9e6f279763312d Mon Sep 17 00:00:00 2001 From: Hrvoje Cavrak Date: Sat, 3 Aug 2024 19:03:38 +0200 Subject: [PATCH] DeskHop v0.62 (Minor Bugfixes) - Fixed screen lock regression bug - Cleaned up trailing spaces Due to MacOS having issues: - Moved screen lock shortcut to right control + L - Moved switch lock shortcut to right control + K --- CMakeLists.txt | 2 +- README.md | 11 +++++++--- disk/disk.img | Bin 65536 -> 65536 bytes src/defaults.c | 6 ++--- src/handlers.c | 36 +++++++++++++++--------------- src/hid_parser.c | 24 ++++++++++---------- src/hid_report.c | 40 +++++++++++++++++----------------- src/include/hid_report.h | 2 +- src/include/main.h | 6 ++--- src/include/protocol.h | 2 +- src/include/usb_descriptors.h | 2 +- src/include/user_config.h | 8 +++---- src/keyboard.c | 12 +++++----- src/led.c | 2 +- src/main.c | 6 ++--- src/mouse.c | 12 +++++----- src/protocol.c | 6 ++--- src/ramdisk.c | 31 +++++++++++++------------- src/setup.c | 40 +++++++++++++++++----------------- src/tasks.c | 26 +++++++++++----------- src/uart.c | 16 +++++++------- src/usb.c | 36 +++++++++++++++--------------- src/usb_descriptors.c | 16 +++++++------- src/utils.c | 30 ++++++++++++------------- 24 files changed, 188 insertions(+), 184 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index cca9686..ce827d2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,7 +1,7 @@ cmake_minimum_required(VERSION 3.6) set(VERSION_MAJOR 00) -set(VERSION_MINOR 139) +set(VERSION_MINOR 147) set(PICO_SDK_FETCH_FROM_GIT off) set(PICO_BOARD=pico) diff --git a/README.md b/README.md index 475c655..a77549c 100644 --- a/README.md +++ b/README.md @@ -93,9 +93,14 @@ Ever tried to move that YT video slider to a specific position but your mouse mo ### Switch Lock -If you want to lock yourself to one screen, use ```RIGHT CTRL + L```. +If you want to lock yourself to one screen, use ```RIGHT CTRL + K```. This will make sure you won't accidentally leave your current screen. To turn off, press the same key combo again. +### Lock Both Screens + +You can lock both computers at once by using ```RIGHT CTRL + L```. +To make use of this feature, first set up the OS for each output in config (since the shortcuts are different). + ### Screensaver Supposedly built in to prevent computer from entering standby, but truth be told - it is just fun to watch. **Off by default**, will make your mouse pointer bounce around the screen like a Pong ball. When enabled, it activates after a period of inactivity defined in user config header and automatically switches off as soon as you send any output towards that screen. @@ -209,8 +214,8 @@ _Config_ _Usage_ - ```Right CTRL + Right ALT``` - Toggle slower mouse mode -- ```Right CTRL + L``` - Lock/Unlock mouse desktop switching -- ```Right ALT + Right Shift + L``` - Lock both outputs at once (set output OS before, see shortcuts below) +- ```Right CTRL + K``` - Lock/Unlock mouse desktop switching +- ```Right CTRL + L``` - Lock both outputs at once (set output OS before, see shortcuts below) - ```Caps Lock``` - Switch between outputs ### Switch cursor height calibration diff --git a/disk/disk.img b/disk/disk.img index 7fef427a16d0ad94ce02f12bf0d59082f4d9cddd..3277f3cffc1b4e6273368e9a72507585d15e00ca 100644 GIT binary patch delta 54 zcmZo@U}46rZu+oVN?1B0!p%VTsx1M85g%oBxI~uL1y* Cu^4Fp diff --git a/src/defaults.c b/src/defaults.c index a99d11b..7398eda 100644 --- a/src/defaults.c +++ b/src/defaults.c @@ -21,9 +21,9 @@ const config_t default_config = { .mode = SCREENSAVER_A_MODE, .only_if_inactive = SCREENSAVER_A_ONLY_IF_INACTIVE, .idle_time_us = SCREENSAVER_A_IDLE_TIME_SEC * 1000000, - .max_time_us = SCREENSAVER_A_MAX_TIME_SEC * 1000000, + .max_time_us = SCREENSAVER_A_MAX_TIME_SEC * 1000000, } - }, + }, .output[OUTPUT_B] = { .number = OUTPUT_B, @@ -41,7 +41,7 @@ const config_t default_config = { .mode = SCREENSAVER_B_MODE, .only_if_inactive = SCREENSAVER_B_ONLY_IF_INACTIVE, .idle_time_us = SCREENSAVER_B_IDLE_TIME_SEC * 1000000, - .max_time_us = SCREENSAVER_B_MAX_TIME_SEC * 1000000, + .max_time_us = SCREENSAVER_B_MAX_TIME_SEC * 1000000, } }, .enforce_ports = ENFORCE_PORTS, diff --git a/src/handlers.c b/src/handlers.c index c89a7ab..af7d85f 100644 --- a/src/handlers.c +++ b/src/handlers.c @@ -79,14 +79,14 @@ void screenlock_hotkey_handler(device_t *state, hid_keyboard_report_t *report) { lock_report.keycode[0] = HID_KEY_L; break; case MACOS: - lock_report.modifier = KEYBOARD_MODIFIER_LEFTCTRL | KEYBOARD_MODIFIER_LEFTALT; + lock_report.modifier = KEYBOARD_MODIFIER_LEFTCTRL | KEYBOARD_MODIFIER_LEFTGUI; lock_report.keycode[0] = HID_KEY_Q; break; default: break; } - if (global_state.active_output == out) { + if (BOARD_ROLE == out) { queue_kbd_report(&lock_report, state); release_all_keys(state); } else { @@ -111,14 +111,14 @@ void mouse_zoom_hotkey_handler(device_t *state, hid_keyboard_report_t *report) { /* Put the device into a special configuration mode */ -void config_enable_hotkey_handler(device_t *state, hid_keyboard_report_t *report) { +void config_enable_hotkey_handler(device_t *state, hid_keyboard_report_t *report) { /* If config mode is already active, skip this and reboot to return to normal mode */ if (!state->config_mode_active) { watchdog_hw->scratch[5] = MAGIC_WORD_1; watchdog_hw->scratch[6] = MAGIC_WORD_2; } - release_all_keys(state); + release_all_keys(state); state->reboot_requested = true; }; @@ -226,9 +226,9 @@ void handle_api_msgs(uart_packet_t *packet, device_t *state) { /* If we don't have a valid map entry, return immediately */ if (map == NULL) - return; + return; - /* Create a pointer to the offset into the structure we need to access */ + /* Create a pointer to the offset into the structure we need to access */ uint8_t *ptr = (((uint8_t *)&global_state) + map->offset); if (packet->type == SET_VAL_MSG) { @@ -237,7 +237,7 @@ void handle_api_msgs(uart_packet_t *packet, device_t *state) { return; memcpy(ptr, &packet->data[1], map->len); - } + } else if (packet->type == GET_VAL_MSG) { uart_packet_t response = {.type=GET_VAL_MSG, .data={0}}; memcpy(response.data, ptr, map->len); @@ -252,14 +252,14 @@ void handle_api_msgs(uart_packet_t *packet, device_t *state) { /* Process request packet and create a response */ void handle_request_byte_msg(uart_packet_t *packet, device_t *state) { uint32_t address = packet->data32[0]; - + if (address > STAGING_IMAGE_SIZE) return; - /* Add requested data to bytes 4-7 in the packet and return it with a different type */ + /* Add requested data to bytes 4-7 in the packet and return it with a different type */ uint32_t data = *(uint32_t *)&ADDR_FW_RUNNING[address]; packet->data32[1] = data; - + queue_packet(packet->data, RESPONSE_BYTE_MSG, PACKET_DATA_LENGTH); } @@ -279,27 +279,27 @@ void handle_response_byte_msg(uart_packet_t *packet, device_t *state) { if((address & 0xfff) == 0x000) toggle_led(); } - + /* Update checksum as we receive each byte */ if (address < STAGING_IMAGE_SIZE - FLASH_SECTOR_SIZE) for (int i=0; i<4; i++) state->fw.checksum = crc32_iter(state->fw.checksum, packet->data[4 + i]); - memcpy(state->page_buffer + offset, &packet->data32[1], sizeof(uint32_t)); - + memcpy(state->page_buffer + offset, &packet->data32[1], sizeof(uint32_t)); + /* Neeeeeeext byte, please! */ - state->fw.address += sizeof(uint32_t); + state->fw.address += sizeof(uint32_t); state->fw.byte_done = true; } /* Process a request to read a firmware package from flash */ -void handle_heartbeat_msg(uart_packet_t *packet, device_t *state) { +void handle_heartbeat_msg(uart_packet_t *packet, device_t *state) { uint16_t other_running_version = packet->data16[0]; - + if (state->fw.upgrade_in_progress) return; - /* If the other board isn't running a newer version, we are done */ + /* If the other board isn't running a newer version, we are done */ if (other_running_version <= state->_running_fw.version) return; @@ -309,7 +309,7 @@ void handle_heartbeat_msg(uart_packet_t *packet, device_t *state) { .byte_done = true, .address = 0, .checksum = 0xffffffff, - }; + }; } diff --git a/src/hid_parser.c b/src/hid_parser.c index 78de004..3d454f9 100644 --- a/src/hid_parser.c +++ b/src/hid_parser.c @@ -46,7 +46,7 @@ void update_usage(parser_state_t *parser, int i) { *(parser->p_usage + i) = *(parser->p_usage + i - 1); } -void store_element(parser_state_t *parser, report_val_t *val, int i, uint32_t data, uint16_t size, hid_interface_t *iface) { +void store_element(parser_state_t *parser, report_val_t *val, int i, uint32_t data, uint16_t size, hid_interface_t *iface) { *val = (report_val_t){ .offset = parser->offset_in_bits, .offset_idx = parser->offset_in_bits >> 3, @@ -68,9 +68,9 @@ void store_element(parser_state_t *parser, report_val_t *val, int i, uint32_t da } void handle_global_item(parser_state_t *parser, item_t *item) { - if (item->hdr.tag == RI_GLOBAL_REPORT_ID) - parser->report_id = item->val; - + if (item->hdr.tag == RI_GLOBAL_REPORT_ID) + parser->report_id = item->val; + parser->globals[item->hdr.tag] = *item; } @@ -80,7 +80,7 @@ void handle_local_item(parser_state_t *parser, item_t *item) { parser->locals[item->hdr.tag] = *item; if (item->hdr.tag == RI_LOCAL_USAGE) { - if(IS_BLOCK_END) + if(IS_BLOCK_END) parser->global_usage = item->val; else if (parser->usage_count < HID_MAX_USAGES - 1) @@ -94,20 +94,20 @@ void handle_main_input(parser_state_t *parser, item_t *item, hid_interface_t *if report_val_t val = {0}; /* Swap count and size for 1-bit variables, it makes sense to process e.g. NKRO with - size = 1 and count = 240 in one go instead of doing 240 iterations + size = 1 and count = 240 in one go instead of doing 240 iterations Don't do this if there are usages in the queue, though. - */ + */ if (size == 1 && parser->usage_count <= 1) { size = count; - count = 1; + count = 1; } for (int i = 0; i < count; i++) { update_usage(parser, i); store_element(parser, &val, i, item->val, size, iface); - + /* Use the parsed data to populate internal device structures */ - extract_data(iface, &val); + extract_data(iface, &val); /* Iterate times and increase offset by amount, moving by x bits */ parser->offset_in_bits += size; @@ -152,7 +152,7 @@ void handle_main_item(parser_state_t *parser, item_t *item, hid_interface_t *ifa parser_state_t parser_state = {0}; // Avoid placing it on the stack, it's large void parse_report_descriptor(hid_interface_t *iface, - uint8_t const *report, + uint8_t const *report, int desc_len ) { item_t item = {0}; @@ -181,5 +181,5 @@ void parse_report_descriptor(hid_interface_t *iface, /* Move to the next position and decrement size by header length + data length */ report += SIZE_LOOKUP[item.hdr.size]; desc_len -= (SIZE_LOOKUP[item.hdr.size] + 1); - } + } } diff --git a/src/hid_report.c b/src/hid_report.c index 1c6d340..045d5e1 100644 --- a/src/hid_report.c +++ b/src/hid_report.c @@ -55,17 +55,17 @@ int32_t get_report_value(uint8_t *report, report_val_t *val) { } /* After processing the descriptor, assign the values so we can later use them to interpret reports */ -void handle_consumer_control_values(report_val_t *src, report_val_t *dst, hid_interface_t *iface) { +void handle_consumer_control_values(report_val_t *src, report_val_t *dst, hid_interface_t *iface) { if (src->offset > MAX_CC_BUTTONS) { return; } - + if (src->data_type == VARIABLE) { iface->keyboard.cc_array[src->offset] = src->usage; iface->consumer.is_variable = true; } - - iface->consumer.is_array |= (src->data_type == ARRAY); + + iface->consumer.is_array |= (src->data_type == ARRAY); } /* After processing the descriptor, assign the values so we can later use them to interpret reports */ @@ -73,13 +73,13 @@ void handle_system_control_values(report_val_t *src, report_val_t *dst, hid_inte if (src->offset > MAX_SYS_BUTTONS) { return; } - + if (src->data_type == VARIABLE) { iface->keyboard.sys_array[src->offset] = src->usage; iface->system.is_variable = true; } - - iface->system.is_array |= (src->data_type == ARRAY); + + iface->system.is_array |= (src->data_type == ARRAY); } /* After processing the descriptor, assign the values so we can later use them to interpret reports */ @@ -143,54 +143,54 @@ void extract_data(hid_interface_t *iface, report_val_t *val) { .id = &iface->mouse.report_id}, {.usage_page = HID_USAGE_PAGE_DESKTOP, - .global_usage = HID_USAGE_DESKTOP_MOUSE, + .global_usage = HID_USAGE_DESKTOP_MOUSE, .usage = HID_USAGE_DESKTOP_X, .handler = _store, .receiver = process_mouse_report, .dst = &iface->mouse.move_x, .id = &iface->mouse.report_id}, - + {.usage_page = HID_USAGE_PAGE_DESKTOP, - .global_usage = HID_USAGE_DESKTOP_MOUSE, + .global_usage = HID_USAGE_DESKTOP_MOUSE, .usage = HID_USAGE_DESKTOP_Y, .handler = _store, .receiver = process_mouse_report, .dst = &iface->mouse.move_y, .id = &iface->mouse.report_id}, - + {.usage_page = HID_USAGE_PAGE_DESKTOP, - .global_usage = HID_USAGE_DESKTOP_MOUSE, + .global_usage = HID_USAGE_DESKTOP_MOUSE, .usage = HID_USAGE_DESKTOP_WHEEL, .handler = _store, .receiver = process_mouse_report, .dst = &iface->mouse.wheel, .id = &iface->mouse.report_id}, - + {.usage_page = HID_USAGE_PAGE_KEYBOARD, - .global_usage = HID_USAGE_DESKTOP_KEYBOARD, + .global_usage = HID_USAGE_DESKTOP_KEYBOARD, .handler = handle_keyboard_descriptor_values, .receiver = process_keyboard_report, .id = &iface->keyboard.report_id}, - + {.usage_page = HID_USAGE_PAGE_CONSUMER, .global_usage = HID_USAGE_CONSUMER_CONTROL, .handler = handle_consumer_control_values, .receiver = process_consumer_report, .dst = &iface->consumer.val, .id = &iface->consumer.report_id}, - + {.usage_page = HID_USAGE_PAGE_DESKTOP, .global_usage = HID_USAGE_DESKTOP_SYSTEM_CONTROL, .handler = _store, .receiver = process_system_report, .dst = &iface->system.val, .id = &iface->system.report_id}, - }; + }; /* We extracted all we could find in the descriptor to report_values, now go through them and match them up with the values in the table above, then store those values for later reference */ - for (const usage_map_t *hay = map; hay != &map[ARRAY_SIZE(map)]; hay++) { + for (const usage_map_t *hay = map; hay != &map[ARRAY_SIZE(map)]; hay++) { /* ---> If any condition is not defined, we consider it as matched <--- */ bool global_usages_match = (val->global_usage == hay->global_usage) || (hay->global_usage == 0); bool usages_match = (val->usage == hay->usage) || (hay->usage == 0); @@ -236,7 +236,7 @@ int32_t _extract_kbd_other(uint8_t *raw_report, int len, hid_interface_t *iface, uint8_t *src = raw_report; keyboard_t *kb = &iface->keyboard; - if (iface->uses_report_id) + if (iface->uses_report_id) src++; report->modifier = src[kb->modifier.offset_idx]; @@ -286,7 +286,7 @@ int32_t extract_kbd_data( /* NKRO is a special case */ if (report_id > 0 - && report_id == iface->keyboard.nkro.report_id + && report_id == iface->keyboard.nkro.report_id && iface->keyboard.is_nkro) return _extract_kbd_nkro(raw_report, len, iface, report); diff --git a/src/include/hid_report.h b/src/include/hid_report.h index 5e9297d..1d9e1dc 100644 --- a/src/include/hid_report.h +++ b/src/include/hid_report.h @@ -31,7 +31,7 @@ typedef struct { int usage_page; int usage; uint8_t *id; - report_val_t *dst; + report_val_t *dst; value_handler_f handler; process_report_f receiver; } usage_map_t; diff --git a/src/include/main.h b/src/include/main.h index 4d553ac..9062478 100644 --- a/src/include/main.h +++ b/src/include/main.h @@ -255,7 +255,7 @@ typedef struct { uint8_t enforce_ports; uint16_t jump_treshold; - output_t output[NUM_SCREENS]; + output_t output[NUM_SCREENS]; uint32_t _reserved; // Keep checksum at the end of the struct @@ -402,7 +402,7 @@ typedef struct { bool onboard_led_state; // True when LED is ON bool relative_mouse; // True when relative mouse mode is used bool config_mode_active; // True when config mode is active - + /* Onboard LED blinky (provide feedback when e.g. mouse connected) */ int32_t blinks_left; // How many blink transitions are left int32_t last_led_change; // Timestamp of the last time led state transitioned @@ -411,7 +411,7 @@ typedef struct { typedef struct { void (*exec)(device_t *state); uint64_t frequency; - uint64_t next_run; + uint64_t next_run; bool *enabled; } task_t; diff --git a/src/include/protocol.h b/src/include/protocol.h index 85852a5..b9c63e0 100644 --- a/src/include/protocol.h +++ b/src/include/protocol.h @@ -17,7 +17,7 @@ typedef enum { typedef struct { uint32_t idx; bool readonly; - type_e type; + type_e type; uint32_t len; size_t offset; } field_map_t; diff --git a/src/include/usb_descriptors.h b/src/include/usb_descriptors.h index a295851..04b7314 100644 --- a/src/include/usb_descriptors.h +++ b/src/include/usb_descriptors.h @@ -1,4 +1,4 @@ -/* +/* * The MIT License (MIT) * * Copyright (c) 2019 Ha Thach (tinyusb.org) diff --git a/src/include/user_config.h b/src/include/user_config.h index 19bf9cd..77a98a7 100644 --- a/src/include/user_config.h +++ b/src/include/user_config.h @@ -29,7 +29,7 @@ * a key that is unlikely to ever appear on a keyboard that you will use. * HID_KEY_F24 is probably a good choice as keyboards with 24 function keys * are rare. - * + * * */ #define HOTKEY_TOGGLE HID_KEY_F24 @@ -50,7 +50,7 @@ * This is now configurable per-screen. * * ENABLE_ACCELERATION: [0-1], disables or enables mouse acceleration. - * + * * */ /* Output A values */ @@ -180,10 +180,10 @@ * ================================================== * * If enabled, fixes some device incompatibilities by - * enforcing the boot protocol (which is simpler to parse + * enforcing the boot protocol (which is simpler to parse * and with less variation) * - * ENFORCE_KEYBOARD_BOOT_PROTOCOL: [0, 1] - 1 means keyboard will forcefully use + * ENFORCE_KEYBOARD_BOOT_PROTOCOL: [0, 1] - 1 means keyboard will forcefully use * the boot protocol * - 0 means no such thing is enforced * diff --git a/src/keyboard.c b/src/keyboard.c index ac66cb4..8024356 100644 --- a/src/keyboard.c +++ b/src/keyboard.c @@ -39,13 +39,13 @@ hotkey_combo_t hotkeys[] = { /* Switch lock */ {.modifier = KEYBOARD_MODIFIER_RIGHTCTRL, - .keys = {HID_KEY_L}, + .keys = {HID_KEY_K}, .key_count = 1, .acknowledge = true, .action_handler = &switchlock_hotkey_handler}, /* Screen lock */ - {.modifier = KEYBOARD_MODIFIER_RIGHTALT | KEYBOARD_MODIFIER_RIGHTSHIFT, + {.modifier = KEYBOARD_MODIFIER_RIGHTCTRL, .keys = {HID_KEY_L}, .key_count = 1, .acknowledge = true, @@ -162,7 +162,7 @@ void process_kbd_queue_task(device_t *state) { void queue_kbd_report(hid_keyboard_report_t *report, device_t *state) { /* It wouldn't be fun to queue up a bunch of messages and then dump them all on host */ if (!state->tud_connected) - return; + return; queue_try_add(&state->kbd_queue, report); } @@ -252,7 +252,7 @@ void process_consumer_report(uint8_t *raw_report, int length, uint8_t itf, hid_i int byte_idx = i >> 3; if ((raw_report[byte_idx + 1] >> bit_idx) & 1) { - report_ptr[0] = iface->keyboard.cc_array[i]; + report_ptr[0] = iface->keyboard.cc_array[i]; } } } @@ -267,6 +267,6 @@ void process_consumer_report(uint8_t *raw_report, int length, uint8_t itf, hid_i void process_system_report(uint8_t *raw_report, int length, uint8_t itf, hid_interface_t *iface) { uint16_t new_report = raw_report[1]; uint8_t *report_ptr = (uint8_t *)&new_report; - + send_system_control(report_ptr, &global_state); -} \ No newline at end of file +} diff --git a/src/led.c b/src/led.c index af04ae3..90fb961 100644 --- a/src/led.c +++ b/src/led.c @@ -63,7 +63,7 @@ void blink_led(device_t *state) { void led_blinking_task(device_t *state) { const int blink_interval_us = 80000; /* 80 ms off, 80 ms on */ static uint8_t leds; - + /* If there is no more blinking to be done, exit immediately */ if (state->blinks_left == 0) return; diff --git a/src/main.c b/src/main.c index d8ba3c4..1ae390a 100644 --- a/src/main.c +++ b/src/main.c @@ -52,7 +52,7 @@ int main(void) { while (true) { for (int i = 0; i < NUM_TASKS; i++) task_scheduler(device, &tasks_core0[i]); - } + } } void core1_main() { @@ -64,14 +64,14 @@ void core1_main() { [4] = {.exec = &firmware_upgrade_task, .frequency = _HZ(4000)}, // | Send firmware to the other board if needed [5] = {.exec = &heartbeat_output_task, .frequency = _HZ(1)}, // | Output periodic heartbeats }; // `----- then go back and repeat forever - const int NUM_TASKS = ARRAY_SIZE(tasks_core1); + const int NUM_TASKS = ARRAY_SIZE(tasks_core1); while (true) { // Update the timestamp, so core0 can figure out if we're dead device->core1_last_loop_pass = time_us_64(); for (int i = 0; i < NUM_TASKS; i++) - task_scheduler(device, &tasks_core1[i]); + task_scheduler(device, &tasks_core1[i]); } } /* ======= End of Main Program Loops ======= */ diff --git a/src/mouse.c b/src/mouse.c index 5a4a2d6..f457fe8 100644 --- a/src/mouse.c +++ b/src/mouse.c @@ -87,7 +87,7 @@ void output_mouse_report(mouse_report_t *report, device_t *state) { state->last_activity[BOARD_ROLE] = time_us_64(); } else { queue_packet((uint8_t *)report, MOUSE_REPORT_MSG, MOUSE_REPORT_LENGTH); - } + } } /* Calculate and return Y coordinate when moving from screen out_from to screen out_to */ @@ -124,12 +124,12 @@ int16_t scale_y_coordinate(int screen_from, int screen_to, device_t *state) { void switch_screen( device_t *state, output_t *output, int new_x, int output_from, int output_to, int direction) { uint8_t *mouse_park_pos = &state->config.output[state->active_output].mouse_park_pos; - + int16_t mouse_y = (*mouse_park_pos == 0) ? MIN_SCREEN_COORD : /* Top */ (*mouse_park_pos == 1) ? MAX_SCREEN_COORD : /* Bottom */ state->pointer_y; /* Previous */ - mouse_report_t hidden_pointer = {.y = mouse_y, .x = MAX_SCREEN_COORD}; + mouse_report_t hidden_pointer = {.y = mouse_y, .x = MAX_SCREEN_COORD}; output_mouse_report(&hidden_pointer, state); switch_output(state, output_to); @@ -138,7 +138,7 @@ void switch_screen( } void switch_desktop(device_t *state, output_t *output, int new_index, int direction) { - /* Fix for MACOS: Send relative mouse movement here, one or two pixels in the + /* Fix for MACOS: Send relative mouse movement here, one or two pixels in the direction of movement, BEFORE absolute report sets X to 0 */ mouse_report_t move_relative_one = {.x = (direction == LEFT) ? SCREEN_MIDPOINT - 2 : SCREEN_MIDPOINT + 2, .mode = RELATIVE}; @@ -207,7 +207,7 @@ void check_screen_switch(const mouse_values_t *values, device_t *state) { switch_desktop(state, output, output->screen_index + 1, direction); } -void extract_report_values(uint8_t *raw_report, device_t *state, mouse_values_t *values, hid_interface_t *iface) { +void extract_report_values(uint8_t *raw_report, device_t *state, mouse_values_t *values, hid_interface_t *iface) { /* Interpret values depending on the current protocol used. */ if (iface->protocol == HID_PROTOCOL_BOOT) { hid_mouse_report_t *mouse_report = (hid_mouse_report_t *)raw_report; @@ -267,7 +267,7 @@ void process_mouse_report(uint8_t *raw_report, int len, uint8_t itf, hid_interfa output_mouse_report(&report, state); /* We use the mouse to switch outputs, the logic is in check_screen_switch() */ - check_screen_switch(&values, state); + check_screen_switch(&values, state); } /* ==================================================== * diff --git a/src/protocol.c b/src/protocol.c index d28d8f0..210ccbb 100644 --- a/src/protocol.c +++ b/src/protocol.c @@ -1,6 +1,6 @@ #include "main.h" -const field_map_t api_field_map[] = { +const field_map_t api_field_map[] = { /* Index, Rdonly, Type, Len, Offset in struct */ { 0, true, UINT8, 1, offsetof(device_t, active_output) }, { 1, true, INT16, 2, offsetof(device_t, pointer_x) }, @@ -22,7 +22,7 @@ const field_map_t api_field_map[] = { /* Until we increase the payload size from 8 bytes, clamp to avoid exceeding the field size */ { 21, false, UINT64, 7, offsetof(device_t, config.output[0].screensaver.idle_time_us) }, - { 22, false, UINT64, 7, offsetof(device_t, config.output[0].screensaver.max_time_us) }, + { 22, false, UINT64, 7, offsetof(device_t, config.output[0].screensaver.max_time_us) }, /* Output B */ { 40, false, UINT32, 4, offsetof(device_t, config.output[1].number) }, @@ -58,7 +58,7 @@ const field_map_t api_field_map[] = { { 82, true, UINT8, 1, offsetof(device_t, relative_mouse) }, }; -const field_map_t* get_field_map_entry(uint32_t index) { +const field_map_t* get_field_map_entry(uint32_t index) { for (unsigned int i = 0; i < ARRAY_SIZE(api_field_map); i++) { if (api_field_map[i].idx == index) { return &api_field_map[i]; diff --git a/src/ramdisk.c b/src/ramdisk.c index d31d2e1..14947ef 100644 --- a/src/ramdisk.c +++ b/src/ramdisk.c @@ -50,12 +50,12 @@ int32_t tud_msc_read10_cb(uint8_t lun, uint32_t lba, uint32_t offset, void *buff return -1; /* We lie about the image size - actually it's 64 kB, not 512 kB, so if we're out of bounds, return zeros */ - else if (lba >= ACTUAL_NUMBER_OF_BLOCKS) + else if (lba >= ACTUAL_NUMBER_OF_BLOCKS) memset(buffer, 0x00, bufsize); - else + else memcpy(buffer, addr, bufsize); - + return (int32_t)bufsize; } @@ -67,31 +67,31 @@ bool tud_msc_is_writable_cb(uint8_t lun) { /* Simple firmware write routine, we get 512-byte uf2 blocks with 256 byte payload */ int32_t tud_msc_write10_cb(uint8_t lun, uint32_t lba, uint32_t offset, uint8_t *buffer, uint32_t bufsize) { uf2_t *uf2 = (uf2_t *)&buffer[0]; - bool is_final_block = uf2->blockNo == (STAGING_IMAGE_SIZE / FLASH_PAGE_SIZE) - 1; - uint32_t flash_addr = (uint32_t)ADDR_FW_RUNNING + uf2->blockNo * FLASH_PAGE_SIZE - XIP_BASE; - + bool is_final_block = uf2->blockNo == (STAGING_IMAGE_SIZE / FLASH_PAGE_SIZE) - 1; + uint32_t flash_addr = (uint32_t)ADDR_FW_RUNNING + uf2->blockNo * FLASH_PAGE_SIZE - XIP_BASE; + if (lba >= NUMBER_OF_BLOCKS) return -1; /* If we're not detecting UF2 magic constants, we have nothing to do... */ if (uf2->magicStart0 != UF2_MAGIC_START0 || uf2->magicStart1 != UF2_MAGIC_START1 || uf2->magicEnd != UF2_MAGIC_END) return (int32_t)bufsize; - + if (uf2->blockNo == 0) { global_state.fw.checksum = 0xffffffff; - + /* Make sure nobody else touches the flash during this operation, otherwise we get empty pages */ global_state.fw.upgrade_in_progress = true; - } + } /* Update checksum continuously as blocks are being received */ const uint32_t last_block_with_checksum = (STAGING_IMAGE_SIZE - FLASH_SECTOR_SIZE) / FLASH_PAGE_SIZE; for (int i=0; iblockNo < last_block_with_checksum; i++) - global_state.fw.checksum = crc32_iter(global_state.fw.checksum, buffer[32 + i]); + global_state.fw.checksum = crc32_iter(global_state.fw.checksum, buffer[32 + i]); write_flash_page(flash_addr, &buffer[32]); - - if (is_final_block) { + + if (is_final_block) { global_state.fw.checksum = ~global_state.fw.checksum; /* If checksums don't match, overwrite first sector and rely on ROM bootloader for recovery */ @@ -102,18 +102,17 @@ int32_t tud_msc_write10_cb(uint8_t lun, uint32_t lba, uint32_t offset, uint8_t * else { global_state.reboot_requested = true; } - } + } /* Provide some visual indication that fw is being uploaded */ - toggle_led(); + toggle_led(); watchdog_update(); return (int32_t)bufsize; } /* This is a super-dumb, rudimentary disk, any other scsi command is simply rejected */ -int32_t tud_msc_scsi_cb(uint8_t lun, uint8_t const scsi_cmd[16], void *buffer, uint16_t bufsize) { +int32_t tud_msc_scsi_cb(uint8_t lun, uint8_t const scsi_cmd[16], void *buffer, uint16_t bufsize) { tud_msc_set_sense(lun, SCSI_SENSE_ILLEGAL_REQUEST, 0x20, 0x00); return -1; } - \ No newline at end of file diff --git a/src/setup.c b/src/setup.c index f3c8cfd..8049268 100644 --- a/src/setup.c +++ b/src/setup.c @@ -75,7 +75,7 @@ void pio_usb_host_config(device_t *state) { and it will drive it either high or low at any given time - Before uart setup, enable it as an input - Go through a probing sequence of 8 values and pull either up or down - to that value + to that value - Read out the value on the RX pin - If the entire sequence of values match, we are definitely floating so IC is not connected on BOARD_A_RX, and we're BOARD B @@ -84,22 +84,22 @@ int board_autoprobe(void) { const bool probing_sequence[] = {true, false, false, true, true, false, true, false}; const int seq_len = ARRAY_SIZE(probing_sequence); - /* Set the pin as INPUT and initialize it */ + /* Set the pin as INPUT and initialize it */ gpio_init(BOARD_A_RX); gpio_set_dir(BOARD_A_RX, GPIO_IN); - for (int i=0; iscratch[5] = 0; + watchdog_hw->scratch[5] = 0; reset_config_timer(state); @@ -131,23 +131,23 @@ bool is_config_mode_active(device_t *state) { /* ================================================== * - * Configure DMA for reliable UART transfers + * Configure DMA for reliable UART transfers * ================================================== */ -const uint8_t* uart_buffer_pointers[1] = {uart_rxbuf}; +const uint8_t* uart_buffer_pointers[1] = {uart_rxbuf}; uint8_t uart_rxbuf[DMA_RX_BUFFER_SIZE] __attribute__((aligned(DMA_RX_BUFFER_SIZE))) ; uint8_t uart_txbuf[DMA_TX_BUFFER_SIZE] __attribute__((aligned(DMA_TX_BUFFER_SIZE))) ; static void configure_tx_dma(device_t *state) { state->dma_tx_channel = dma_claim_unused_channel(true); - dma_channel_config tx_config = dma_channel_get_default_config(state->dma_tx_channel); + dma_channel_config tx_config = dma_channel_get_default_config(state->dma_tx_channel); channel_config_set_transfer_data_size(&tx_config, DMA_SIZE_8); /* Writing uart (always write the same address, but source addr changes as we read) */ channel_config_set_read_increment(&tx_config, true); channel_config_set_write_increment(&tx_config, false); - // channel_config_set_ring(&tx_config, false, 4); + // channel_config_set_ring(&tx_config, false, 4); channel_config_set_dreq(&tx_config, DREQ_UART0_TX); /* Configure, but don't start immediately. We'll do this each time the outgoing @@ -167,7 +167,7 @@ static void configure_rx_dma(device_t *state) { state->dma_rx_channel = dma_claim_unused_channel(true); state->dma_control_channel = dma_claim_unused_channel(true); - dma_channel_config config = dma_channel_get_default_config(state->dma_rx_channel); + dma_channel_config config = dma_channel_get_default_config(state->dma_rx_channel); dma_channel_config control_config = dma_channel_get_default_config(state->dma_control_channel); channel_config_set_transfer_data_size(&config, DMA_SIZE_8); @@ -185,16 +185,16 @@ static void configure_rx_dma(device_t *state) { // The UART signals when data is avaliable channel_config_set_dreq(&config, DREQ_UART0_RX); - + channel_config_set_chain_to(&config, state->dma_control_channel); - + dma_channel_configure( state->dma_rx_channel, &config, uart_rxbuf, &uart0_hw->dr, DMA_RX_BUFFER_SIZE, - false); + false); dma_channel_configure( state->dma_control_channel, @@ -204,14 +204,14 @@ static void configure_rx_dma(device_t *state) { 1, false); - dma_channel_start(state->dma_control_channel); + dma_channel_start(state->dma_control_channel); } /* ================================================== * * Perform initial board/usb setup * ================================================== */ -int board; +int board; void initial_setup(device_t *state) { /* PIO USB requires a clock multiple of 12 MHz, setting to 120 MHz */ @@ -248,12 +248,12 @@ void initial_setup(device_t *state) { multicore_launch_core1(core1_main); /* Initialize and configure TinyUSB Device */ - tud_init(BOARD_TUD_RHPORT); - + tud_init(BOARD_TUD_RHPORT); + /* Initialize and configure TinyUSB Host */ pio_usb_host_config(state); - /* Initialize and configure DMA */ + /* Initialize and configure DMA */ configure_tx_dma(state); configure_rx_dma(state); @@ -262,7 +262,7 @@ void initial_setup(device_t *state) { /* Update the core1 initial pass timestamp before enabling the watchdog */ state->core1_last_loop_pass = time_us_64(); - + /* Setup the watchdog so we reboot and recover from a crash */ watchdog_enable(WATCHDOG_TIMEOUT, WATCHDOG_PAUSE_ON_DEBUG); } diff --git a/src/tasks.c b/src/tasks.c index 5026858..b6b3aae 100644 --- a/src/tasks.c +++ b/src/tasks.c @@ -19,7 +19,7 @@ void task_scheduler(device_t *state, task_t *task) { uint64_t current_time = time_us_64(); - + if (current_time < task->next_run) return; @@ -36,7 +36,7 @@ void kick_watchdog_task(device_t *state) { so it doesn't get updated in the meantime. */ uint64_t core1_last_loop_pass = state->core1_last_loop_pass; uint64_t current_time = time_us_64(); - + /* If a reboot is requested, we'll stop updating watchdog */ if (state->reboot_requested) return; @@ -64,7 +64,7 @@ void screensaver_task(device_t *state) { const int mouse_move_delay = 5000; screensaver_t *screensaver = &state->config.output[BOARD_ROLE].screensaver; uint64_t inactivity_period = time_us_64() - state->last_activity[BOARD_ROLE]; - + static mouse_report_t report = {0}; static int last_pointer_move = 0; static int dx = 20, dy = 25, jitter = 1; @@ -119,11 +119,11 @@ void screensaver_task(device_t *state) { } /* Periodically emit heartbeat packets */ -void heartbeat_output_task(device_t *state) { +void heartbeat_output_task(device_t *state) { /* If firmware upgrade is in progress, don't touch flash_cs */ if (state->fw.upgrade_in_progress) return; - + if (state->config_mode_active) { /* Leave config mode if timeout expired and user didn't click exit */ if (time_us_64() > state->config_mode_timer) @@ -140,12 +140,12 @@ void heartbeat_output_task(device_t *state) { uart_packet_t packet = { .type = HEARTBEAT_MSG, .data16 = { - [0] = state->_running_fw.version, + [0] = state->_running_fw.version, [2] = state->active_output, }, }; - queue_try_add(&global_state.uart_tx_queue, &packet); + queue_try_add(&global_state.uart_tx_queue, &packet); } /* Process outgoing config report messages. */ @@ -194,14 +194,14 @@ void firmware_upgrade_task(device_t *state) { } } - /* If we're on the last element of the current page, page is done - write it. */ - if (TU_U32_BYTE0(state->fw.address) == 0x00) { + /* If we're on the last element of the current page, page is done - write it. */ + if (TU_U32_BYTE0(state->fw.address) == 0x00) { uint32_t page_start_addr = (state->fw.address - 1) & 0xFFFFFF00; - write_flash_page((uint32_t)ADDR_FW_RUNNING + page_start_addr - XIP_BASE, state->page_buffer); + write_flash_page((uint32_t)ADDR_FW_RUNNING + page_start_addr - XIP_BASE, state->page_buffer); } - - request_byte(state, state->fw.address); + + request_byte(state, state->fw.address); } void packet_receiver_task(device_t *state) { @@ -210,7 +210,7 @@ void packet_receiver_task(device_t *state) { uint32_t delta = get_ptr_delta(current_pointer, state); /* If we don't have enough characters for a packet, skip loop and return immediately */ - while (delta >= RAW_PACKET_LENGTH) { + while (delta >= RAW_PACKET_LENGTH) { if (is_start_of_packet(state)) { fetch_packet(state); process_packet(&state->in_packet, state); diff --git a/src/uart.c b/src/uart.c index c99b953..73a1760 100644 --- a/src/uart.c +++ b/src/uart.c @@ -22,15 +22,15 @@ * ================================================== */ /* Takes a packet as uart_packet_t struct, adds preamble, checksum and encodes it to a raw array. */ -void write_raw_packet(uint8_t *dst, uart_packet_t *packet) { +void write_raw_packet(uint8_t *dst, uart_packet_t *packet) { uint8_t pkt[RAW_PACKET_LENGTH] = {[0] = START1, [1] = START2, [2] = packet->type, /* [3-10] is data, defaults to 0 */ [11] = calc_checksum(packet->data, PACKET_DATA_LENGTH)}; - + memcpy(&pkt[START_LENGTH + TYPE_LENGTH], packet->data, PACKET_DATA_LENGTH); - memcpy(dst, &pkt, RAW_PACKET_LENGTH); + memcpy(dst, &pkt, RAW_PACKET_LENGTH); } /* Schedule packet for sending to the other box */ @@ -38,7 +38,7 @@ void queue_packet(const uint8_t *data, enum packet_type_e packet_type, int lengt uart_packet_t packet = {.type = packet_type}; memcpy(packet.data, data, length); - queue_try_add(&global_state.uart_tx_queue, &packet); + queue_try_add(&global_state.uart_tx_queue, &packet); } /* Sends just one byte of a certain packet type to the other box. */ @@ -56,7 +56,7 @@ void process_uart_tx_task(device_t *state) { if (!queue_try_remove(&state->uart_tx_queue, &packet)) return; - write_raw_packet(uart_txbuf, &packet); + write_raw_packet(uart_txbuf, &packet); dma_channel_transfer_from_buffer_now(state->dma_tx_channel, uart_txbuf, RAW_PACKET_LENGTH); } @@ -69,7 +69,7 @@ const uart_handler_t uart_handler[] = { {.type = KEYBOARD_REPORT_MSG, .handler = handle_keyboard_uart_msg}, {.type = MOUSE_REPORT_MSG, .handler = handle_mouse_abs_uart_msg}, {.type = OUTPUT_SELECT_MSG, .handler = handle_output_select_msg}, - + /* Box control */ {.type = MOUSE_ZOOM_MSG, .handler = handle_mouse_zoom_msg}, {.type = KBD_SET_REPORT_MSG, .handler = handle_set_report_msg}, @@ -77,7 +77,7 @@ const uart_handler_t uart_handler[] = { {.type = SYNC_BORDERS_MSG, .handler = handle_sync_borders_msg}, {.type = FLASH_LED_MSG, .handler = handle_flash_led_msg}, {.type = CONSUMER_CONTROL_MSG, .handler = handle_consumer_control_msg}, - + /* Config */ {.type = WIPE_CONFIG_MSG, .handler = handle_wipe_config_msg}, {.type = SAVE_CONFIG_MSG, .handler = handle_save_config_msg}, @@ -90,7 +90,7 @@ const uart_handler_t uart_handler[] = { {.type = RESPONSE_BYTE_MSG, .handler = handle_response_byte_msg}, {.type = FIRMWARE_UPGRADE_MSG, .handler = handle_fw_upgrade_msg}, - {.type = HEARTBEAT_MSG, .handler = handle_heartbeat_msg}, + {.type = HEARTBEAT_MSG, .handler = handle_heartbeat_msg}, {.type = PROXY_PACKET_MSG, .handler = handle_proxy_msg}, }; diff --git a/src/usb.c b/src/usb.c index 4dd567e..f9e409f 100644 --- a/src/usb.c +++ b/src/usb.c @@ -28,7 +28,7 @@ uint16_t tud_hid_get_report_cb(uint8_t instance, uint8_t report_id, hid_report_type_t report_type, uint8_t *buffer, - uint16_t request_len) { + uint16_t request_len) { return 0; } @@ -46,15 +46,15 @@ void tud_hid_set_report_cb(uint8_t instance, uint16_t bufsize) { /* We received a report on the config report ID */ - if (instance == ITF_NUM_HID_VENDOR && report_id == REPORT_ID_VENDOR) { + if (instance == ITF_NUM_HID_VENDOR && report_id == REPORT_ID_VENDOR) { /* Security - only if config mode is enabled are we allowed to do anything. While the report_id - isn't even advertised when not in config mode, security must always be explicit and never assume */ + isn't even advertised when not in config mode, security must always be explicit and never assume */ if (!global_state.config_mode_active) return; /* We insist on a fixed size packet. No overflows. */ if (bufsize != RAW_PACKET_LENGTH) - return; + return; uart_packet_t *packet = (uart_packet_t *) (buffer + START_LENGTH); @@ -62,8 +62,8 @@ void tud_hid_set_report_cb(uint8_t instance, if (!validate_packet(packet)) return; - process_packet(packet, &global_state); - } + process_packet(packet, &global_state); + } /* Only other set report we care about is LED state change, and that's exactly 1 byte long */ if (report_id != REPORT_ID_KEYBOARD || bufsize != 1 || report_type != HID_REPORT_TYPE_OUTPUT) @@ -125,36 +125,36 @@ void tuh_hid_umount_cb(uint8_t dev_addr, uint8_t instance) { memset(iface, 0, sizeof(hid_interface_t)); } -void tuh_hid_mount_cb(uint8_t dev_addr, uint8_t instance, uint8_t const *desc_report, uint16_t desc_len) { +void tuh_hid_mount_cb(uint8_t dev_addr, uint8_t instance, uint8_t const *desc_report, uint16_t desc_len) { uint8_t itf_protocol = tuh_hid_interface_protocol(dev_addr, instance); if (dev_addr >= MAX_DEVICES || instance > MAX_INTERFACES) return; - + /* Get interface information */ hid_interface_t *iface = &global_state.iface[dev_addr-1][instance]; iface->protocol = tuh_hid_get_protocol(dev_addr, instance); - + /* Safeguard against memory corruption in case the number of instances exceeds our maximum */ if (instance >= MAX_INTERFACES) return; /* Parse the report descriptor into our internal structure. */ - parse_report_descriptor(iface, desc_report, desc_len); + parse_report_descriptor(iface, desc_report, desc_len); switch (itf_protocol) { case HID_ITF_PROTOCOL_KEYBOARD: if (global_state.config.enforce_ports && BOARD_ROLE == OUTPUT_B) return; - + if (global_state.config.force_kbd_boot_protocol) tuh_hid_set_protocol(dev_addr, instance, HID_PROTOCOL_BOOT); - + /* Keeping this is required for setting leds from device set_report callback */ global_state.kbd_dev_addr = dev_addr; global_state.kbd_instance = instance; - global_state.keyboard_connected = true; + global_state.keyboard_connected = true; break; case HID_ITF_PROTOCOL_MOUSE: @@ -167,8 +167,8 @@ void tuh_hid_mount_cb(uint8_t dev_addr, uint8_t instance, uint8_t const *desc_re tuh_hid_set_protocol(dev_addr, instance, HID_PROTOCOL_REPORT); } break; - - case HID_ITF_PROTOCOL_NONE: + + case HID_ITF_PROTOCOL_NONE: break; } /* Flash local led to indicate a device was connected */ @@ -177,7 +177,7 @@ void tuh_hid_mount_cb(uint8_t dev_addr, uint8_t instance, uint8_t const *desc_re /* Also signal the other board to flash LED, to enable easy verification if serial works */ send_value(ENABLE, FLASH_LED_MSG); - /* Kick off the report querying */ + /* Kick off the report querying */ tuh_hid_receive_report(dev_addr, instance); } @@ -202,7 +202,7 @@ void tuh_hid_report_received_cb(uint8_t dev_addr, uint8_t instance, uint8_t cons if (receiver != NULL) receiver((uint8_t *)report, len, itf_protocol, iface); - } + } } else if (itf_protocol == HID_ITF_PROTOCOL_KEYBOARD) { process_keyboard_report((uint8_t *)report, len, itf_protocol, iface); @@ -216,7 +216,7 @@ void tuh_hid_report_received_cb(uint8_t dev_addr, uint8_t instance, uint8_t cons } /* Set protocol in a callback. This is tied to an interface, not a specific report ID */ -void tuh_hid_set_protocol_complete_cb(uint8_t dev_addr, uint8_t idx, uint8_t protocol) { +void tuh_hid_set_protocol_complete_cb(uint8_t dev_addr, uint8_t idx, uint8_t protocol) { if (dev_addr >= MAX_DEVICES || idx > MAX_INTERFACES) return; diff --git a/src/usb_descriptors.c b/src/usb_descriptors.c index 70c20f2..f154847 100644 --- a/src/usb_descriptors.c +++ b/src/usb_descriptors.c @@ -33,14 +33,14 @@ // https://github.com/raspberrypi/usb-pid tusb_desc_device_t const desc_device = DEVICE_DESCRIPTOR(0x2e8a, 0x107c); - + // https://pid.codes/1209/C000/ tusb_desc_device_t const desc_device_config = DEVICE_DESCRIPTOR(0x1209, 0xc000); // Invoked when received GET DEVICE DESCRIPTOR // Application return pointer to descriptor uint8_t const *tud_descriptor_device_cb(void) { - if (global_state.config_mode_active) + if (global_state.config_mode_active) return (uint8_t const *)&desc_device_config; else return (uint8_t const *)&desc_device; @@ -75,10 +75,10 @@ uint8_t const *tud_hid_descriptor_report_cb(uint8_t instance) { case ITF_NUM_HID: return desc_hid_report; case ITF_NUM_HID_REL_M: - return desc_hid_report_relmouse; + return desc_hid_report_relmouse; default: return desc_hid_report; - } + } } bool tud_mouse_report(uint8_t mode, uint8_t buttons, int16_t x, int16_t y, int8_t wheel) { @@ -253,14 +253,14 @@ uint8_t const desc_configuration_config[] = { // Interface number, string index, EP notification address and size, EP data address (out, in) and size. TUD_CDC_DESCRIPTOR( ITF_NUM_CDC, STRID_DEBUG, EPNUM_CDC_NOTIF, 8, EPNUM_CDC_OUT, EPNUM_CDC_IN, CFG_TUD_CDC_EP_BUFSIZE), -#endif +#endif }; uint8_t const *tud_descriptor_configuration_cb(uint8_t index) { (void)index; // for multiple configurations - - if (global_state.config_mode_active) - return desc_configuration_config; + + if (global_state.config_mode_active) + return desc_configuration_config; else return desc_configuration; } diff --git a/src/utils.c b/src/utils.c index 51e1782..8ef603a 100644 --- a/src/utils.c +++ b/src/utils.c @@ -37,7 +37,7 @@ bool verify_checksum(const uart_packet_t *packet) { } uint32_t crc32_iter(uint32_t crc, const uint8_t byte) { - return crc32_lookup_table[(byte ^ crc) & 0xff] ^ (crc >> 8); + return crc32_lookup_table[(byte ^ crc) & 0xff] ^ (crc >> 8); } /* TODO - use DMA sniffer's built-in CRC32 */ @@ -69,12 +69,12 @@ void write_flash_page(uint32_t target_addr, uint8_t *buffer) { /* Start of sector == first 256-byte page in a 4096 byte block */ bool is_sector_start = (target_addr & 0xf00) == 0; - uint32_t ints = save_and_disable_interrupts(); + uint32_t ints = save_and_disable_interrupts(); if (is_sector_start) flash_range_erase(target_addr, FLASH_SECTOR_SIZE); - flash_range_program(target_addr, buffer, FLASH_PAGE_SIZE); - restore_interrupts(ints); + flash_range_program(target_addr, buffer, FLASH_PAGE_SIZE); + restore_interrupts(ints); } void load_config(device_t *state) { @@ -82,8 +82,8 @@ void load_config(device_t *state) { config_t *running_config = &state->config; /* Load the flash config first, including the checksum */ - memcpy(running_config, config, sizeof(config_t)); - + memcpy(running_config, config, sizeof(config_t)); + /* Calculate and update checksum, size without checksum */ uint8_t checksum = calc_crc32((uint8_t *)running_config, sizeof(config_t) - sizeof(uint32_t)); @@ -110,9 +110,9 @@ void save_config(device_t *state) { /* Copy the config to buffer and pad the rest with zeros */ memcpy(state->page_buffer, raw_config, sizeof(config_t)); - memset(state->page_buffer + sizeof(config_t), 0, FLASH_PAGE_SIZE - sizeof(config_t)); + memset(state->page_buffer + sizeof(config_t), 0, FLASH_PAGE_SIZE - sizeof(config_t)); - /* Write the new config to flash */ + /* Write the new config to flash */ write_flash_page((uint32_t)ADDR_CONFIG - XIP_BASE, state->page_buffer); } @@ -120,10 +120,10 @@ void reset_config_timer(device_t *state) { /* Once this is reached, we leave the config mode */ state->config_mode_timer = time_us_64() + CONFIG_MODE_TIMEOUT; } - + void _configure_flash_cs(enum gpio_override gpo, uint pin_index) { - hw_write_masked(&ioqspi_hw->io[pin_index].ctrl, - gpo << IO_QSPI_GPIO_QSPI_SS_CTRL_OEOVER_LSB, + hw_write_masked(&ioqspi_hw->io[pin_index].ctrl, + gpo << IO_QSPI_GPIO_QSPI_SS_CTRL_OEOVER_LSB, IO_QSPI_GPIO_QSPI_SS_CTRL_OEOVER_BITS); } @@ -152,11 +152,11 @@ void request_byte(device_t *state, uint32_t address) { }; state->fw.byte_done = false; - queue_try_add(&global_state.uart_tx_queue, &packet); + queue_try_add(&global_state.uart_tx_queue, &packet); } void reboot(void) { - *((volatile uint32_t*)(PPB_BASE + 0x0ED0C)) = 0x5FA0004; + *((volatile uint32_t*)(PPB_BASE + 0x0ED0C)) = 0x5FA0004; } bool is_start_of_packet(device_t *state) { @@ -204,8 +204,8 @@ bool validate_packet(uart_packet_t *packet) { uint8_t packet_type = packet->type; /* Proxied packets are encapsulated in the data field, but same rules apply */ - if (packet->type == PROXY_PACKET_MSG) - packet_type = packet->data[0]; + if (packet->type == PROXY_PACKET_MSG) + packet_type = packet->data[0]; for (int i = 0; i < ARRAY_SIZE(ALLOWED_PACKETS); i++) { if (ALLOWED_PACKETS[i] == packet_type)