qmk_firmware/keyboards/system76/system76_ec.c
jecassis 8920db2b57
[Keyboard] Add system76/launch_1 keyboard (#15395)
* WIP: virgo keyboard

* Finish layout

* Enable debugging and format

* Debug keypresses

* Add function layer

* Fix whitespace

* Fix some more whitespace

* Add Jeremy's map

* Add left split ortho 2U board

* Enabled extrakeys for volume & media control

* More work on split ortho 2U...
...but still not complete

* Finish default layout

* Fix many issues by renaming the keyboard

* Add right half as a keyboard

* Update config for right side

* WIP: Add split ortho 2U board

* WIP: Correct rules & config

* More work on split ortho

* More work on split ortho 2u

* Nearing completion on split ortho

* Remove left and right separate keyboards.
Split ortho 2U is complete and they are not needed.

* Add uglydense keyboard

* Rename directory for uglydense

* Swap right Fn and right ctrl keys

* Add jeremy's layout

* Add ian layout

* Add reset key, which is very useful for flashing.

* Add Levi's layout

* Update Levi's layout

* Fix Levi's Layout

* Fix Levi's layout again

* Add a README with some basic information

* Add keymap customization info to uglydense readme

* Make the readme make a little more sense.

* Make John a layout with left fn and left super swapped

* Update John's layout

* Add Carl's layout

* Add Sean's layout

* Add reset keys to all layouts

* Swap LALT & LGUI on default layout

* shpurk keyboard: initial commit

* Add nathaniel & shpurk layouts

* Update instructions to include necesarry dependencies

* Add Lrrr keyboard, ruler of Omicron Persei 8

* Update README for Lrrr

* Update Lrrr it uses Caterina bootloader
Also B1 wasn't working for Row 6, so I changed that to F6

* Swap RCTL & RALT

* Un-swap RCTL and RALT, making RCTL closer to right thumb

* Add printscreen to my layout

* Rename lrrr to Launch, enbiggen L-Shift to 2U

* Add layout files for Launch

* Rename launch to launch_1

* Add levi layout for ortho_split_2u

* Update carl keymap

* Add launch testboard

* Implement keyboard keycode reading using raw hid

* Enable dynamic keymap

* Add config support to launch_1

* Implement probe command, make logical key names match configurator

* Update logical key names again

* Add layout generator for keyboard configurator

* Add board name and version

* Add board name and version to test board

* Fix issues with compiling board and version commands

* Rename uglydense to launch_alpha_1 and launch_1 to launch_alpha_2

* Generate layouts for other launch prototypes

* Fix launch_alpha_1 logical names

* Add launch_beta_1

* Fix building production hex file with atmel-dfu bootloader

* Limit backlight brightness

* USB mux handling

* Allow repeat start

* Do USB MUX init before bootmagic

* Fixes for mux init

* Fix register write size for programmable function control

* Ensure bit shifts are correct

* Improve documentation

* Fix when i2c read ack condition happens

* Fix extra start in i2c_set

* Add ISP instructions

* Add fuse information

* Refactor

* Add RGB matrix support

* Fix RGB matrix

* Update Jeremy layout

* Enable audio controls

* Update Jeremy layout

* Ensure that n-key rollover is used

* Port changes to other launch boards

* Configuration values for starting HSV and speed (#7740)

* Define default HSV and speed for RGB matrix.

* Documentation for configuration values RGB_MATRIX_STARTUP_HUE, RGB_MATRIX_STARTUP_SAT and RGB_MATRIX_STARTUP_VAL.

* Document RGB_MATRIX_STARTUP_SPD.

* Preserve the ordering.

* Set default RGB mode, hue, and saturation

* Reduce AVR clock to 8MHz

* Update launch_beta_1 with new USB ID

* Update default LED mode

* Set default hue

* Disable RGB while suspended

* Add led value and color commands

* Add max value to CMD_LED_GET_VALUE

* Do not save custom mode to eeprom

* Add reset to bootloader command for Launch keyboard

* Rename launch_beta_1 to launch_1

* Enable LTO when compiling for launch_1

* Allow setting individual LED's

* Convert tabs to spaces

* Unlock on RESET keypress:
- Display unlock pattern
- Disable LED get/set functions
- Enable reset to bootloader function

* Reduce brightness of rainbow backdrop in unlock pattern

* Add hid commands for setting led matrix mode

This changes the color setting to not change the mode, and set the hue
and saturation for QMK effects.

* Fix `CMD_LED_GET_MODE`

* Add Levi's Launch layout

* Fix layer mistake in Levi's Launch layout

* Add matrix command

* Define default RGB matrix speed

* Add active_keys effect

* Move definition of RGB modes inside ifdef testing for custom RGB modes

* RGB parameters per layer

* fix: Call `system76_ec_rgb_layer` after setting mode

* Include layer 3 and 4 in default layout for launch_1

I added support for layer 3 and 4 to the Configurator, but it seems to
load bogus values.

`dynamic_keymap_reset()` has a comment saying:
```
// Reset the keymaps in EEPROM to what is in flash.
// All keyboards using dynamic keymaps should define a layout
// for the same number of layers as DYNAMIC_KEYMAP_LAYER_COUNT
```

Other keyboards seem to have default layouts that only list the first
two layers while setting `DYNAMIC_KEYMAP_LAYER_COUNT` to 4, but
whatever. This appears to make the Configurator behave as expected with
layer 3 and 4.

* Use EEPROM to store RGB parameters

* Add layer 2 and 3 to other keymaps

* Add LED_SAVE command

* Use eeprom_update_block to improve performance

* Revert "Configuration values for starting HSV and speed (#7740)"

This reverts commit de1f60fd370b4769336b8a707ee12657aee46412.

* Update launch_1 rules.mk for changes in Qmk

* WIP keycodes matching EC behavior

* Modify default layout to match design

* Apply updates to jeremy layout

* Improvements to RGB keycodes

* system76_ec: Add mode to disable layer backlight

* launch_1: Use `KC_NO` instead of `KC_TRNS` for default layout

* Revert "launch_1: Use `KC_NO` instead of `KC_TRNS` for default layout"

This reverts commit f71c5e7ac3cecbbb1a1f8934db1f329407fef041.

* Fix building bootloader

* Workaround for upstream orientation

* Custom USB IDs for USB hubs, disable USB hub feature controller

* Set USB mux orientation in a loop for one second

* Set mux orientation 100 times with 10 ms delay

* Update Jeremy's keymap

* Update Levi's Launch keymap

* Update flashing instructions and rewrite layout design instructions

* Update README.md

* Add a system76_ec command to disable input events

For testing purposes.

* Enable system76/launch_1 keyboard to work with QMK Firmware 0.15.3

 - Migrate system76/launch_1 from 0.7.103:
   - Explicitly enable used RGB matrix effects
   - Initialize flags field of `rgb_config_t` union/struct
   - Account for header and source file location changes
   - Update AVR platform makefile with Atmel DFU bootloader option
   - Update ATmega32U4 bootloader to latest from Microchip
 - Format C sources with ClangFormat
 - Format Markdown text with Prettier

* Remove System76 pre-release or test keyboards and keymaps

* Add licensing and replace guards in headers for system76/launch_1

* Remove options impact for system76/launch_1

* Revert AVR platform changes for `atmel-dfu` bootloader

* Update system76/launch_1 README

* Add system76/launch_1 information JSON file

* Replace `util/delay.h` timing abstractions in system76/launch_1

* Use I2C QMK abstractions in system76/launch_1

* Fully revert AVR platform changes for `atmel-dfu` bootloader

* Move `layouts.sh` into `keyboards/system76`

* Implement GitHub PR suggestions for system76/launch_1

* Make additional system76/launch_1 updates

* Implement minor system76/launch_1 change requests

* Add custom version of Bootmagic Lite and document fuse values for system76/launch_1

* Remove the RESET HID command from system76/launch_1

* Reorder `process_record_user` in system76/launch_1

* Add `post_rules.mk` to system76/launch_1

* Fix overlapping key in sytem76/launch_1
2022-01-10 17:39:10 -08:00

417 lines
13 KiB
C

/*
* Copyright (C) 2021 System76
* Copyright (C) 2021 Jimmy Cassis <KernelOops@outlook.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include <string.h>
#include "dynamic_keymap.h"
#include "raw_hid.h"
#include "rgb_matrix.h"
#include "version.h"
enum Command {
CMD_PROBE = 1, // Probe for System76 EC protocol
CMD_BOARD = 2, // Read board string
CMD_VERSION = 3, // Read version string
CMD_RESET = 6, // Reset to bootloader
CMD_KEYMAP_GET = 9, // Get keyboard map index
CMD_KEYMAP_SET = 10, // Set keyboard map index
CMD_LED_GET_VALUE = 11, // Get LED value by index
CMD_LED_SET_VALUE = 12, // Set LED value by index
CMD_LED_GET_COLOR = 13, // Get LED color by index
CMD_LED_SET_COLOR = 14, // Set LED color by index
CMD_LED_GET_MODE = 15, // Get LED matrix mode and speed
CMD_LED_SET_MODE = 16, // Set LED matrix mode and speed
CMD_MATRIX_GET = 17, // Get currently pressed keys
CMD_LED_SAVE = 18, // Save LED settings to ROM
CMD_SET_NO_INPUT = 19, // Enable/disable no input mode
};
bool input_disabled = false;
#define CMD_LED_INDEX_ALL 0xFF
static bool keymap_get(uint8_t layer, uint8_t output, uint8_t input, uint16_t *value) {
if (layer < dynamic_keymap_get_layer_count()) {
if (output < MATRIX_ROWS) {
if (input < MATRIX_COLS) {
*value = dynamic_keymap_get_keycode(layer, output, input);
return true;
}
}
}
return false;
}
static bool keymap_set(uint8_t layer, uint8_t output, uint8_t input, uint16_t value) {
if (layer < dynamic_keymap_get_layer_count()) {
if (output < MATRIX_ROWS) {
if (input < MATRIX_COLS) {
dynamic_keymap_set_keycode(layer, output, input, value);
return true;
}
}
}
return false;
}
static bool bootloader_reset = false;
static bool bootloader_unlocked = false;
void system76_ec_unlock(void) {
#ifdef RGB_MATRIX_CUSTOM_KB
rgb_matrix_mode_noeeprom(RGB_MATRIX_CUSTOM_unlocked);
#endif
#ifdef SYSTEM76_EC
bootloader_unlocked = true;
#endif
}
bool system76_ec_is_unlocked(void) { return bootloader_unlocked; }
#ifdef RGB_MATRIX_CUSTOM_KB
enum Mode {
MODE_SOLID_COLOR = 0,
MODE_PER_KEY,
MODE_CYCLE_ALL,
MODE_CYCLE_LEFT_RIGHT,
MODE_CYCLE_UP_DOWN,
MODE_CYCLE_OUT_IN,
MODE_CYCLE_OUT_IN_DUAL,
MODE_RAINBOW_MOVING_CHEVRON,
MODE_CYCLE_PINWHEEL,
MODE_CYCLE_SPIRAL,
MODE_RAINDROPS,
MODE_SPLASH,
MODE_MULTISPLASH,
MODE_ACTIVE_KEYS,
MODE_DISABLED,
MODE_LAST,
};
// clang-format off
static enum rgb_matrix_effects mode_map[] = {
RGB_MATRIX_SOLID_COLOR,
RGB_MATRIX_CUSTOM_raw_rgb,
RGB_MATRIX_CYCLE_ALL,
RGB_MATRIX_CYCLE_LEFT_RIGHT,
RGB_MATRIX_CYCLE_UP_DOWN,
RGB_MATRIX_CYCLE_OUT_IN,
RGB_MATRIX_CYCLE_OUT_IN_DUAL,
RGB_MATRIX_RAINBOW_MOVING_CHEVRON,
RGB_MATRIX_CYCLE_PINWHEEL,
RGB_MATRIX_CYCLE_SPIRAL,
RGB_MATRIX_RAINDROPS,
RGB_MATRIX_SPLASH,
RGB_MATRIX_MULTISPLASH,
RGB_MATRIX_CUSTOM_active_keys,
RGB_MATRIX_NONE,
};
// clang-format on
_Static_assert(sizeof(mode_map) == MODE_LAST, "mode_map_length");
RGB raw_rgb_data[DRIVER_LED_TOTAL];
// clang-format off
rgb_config_t layer_rgb[DYNAMIC_KEYMAP_LAYER_COUNT] = {
// Layer 0
{
.enable = 1,
.mode = RGB_MATRIX_STARTUP_MODE,
.hsv = {
.h = RGB_MATRIX_STARTUP_HUE,
.s = RGB_MATRIX_STARTUP_SAT,
.v = RGB_MATRIX_STARTUP_VAL,
},
.speed = RGB_MATRIX_STARTUP_SPD,
.flags = LED_FLAG_KEYLIGHT,
},
// Layer 1
{
.enable = 1,
.mode = RGB_MATRIX_CUSTOM_active_keys,
.hsv = {
.h = RGB_MATRIX_STARTUP_HUE,
.s = RGB_MATRIX_STARTUP_SAT,
.v = RGB_MATRIX_STARTUP_VAL,
},
.speed = RGB_MATRIX_STARTUP_SPD,
.flags = LED_FLAG_KEYLIGHT,
},
// Layer 2
{
.enable = 1,
.mode = RGB_MATRIX_CUSTOM_active_keys,
.hsv = {
.h = RGB_MATRIX_STARTUP_HUE,
.s = RGB_MATRIX_STARTUP_SAT,
.v = RGB_MATRIX_STARTUP_VAL,
},
.speed = RGB_MATRIX_STARTUP_SPD,
.flags = LED_FLAG_KEYLIGHT,
},
// Layer 3
{
.enable = 1,
.mode = RGB_MATRIX_CUSTOM_active_keys,
.hsv = {
.h = RGB_MATRIX_STARTUP_HUE,
.s = RGB_MATRIX_STARTUP_SAT,
.v = RGB_MATRIX_STARTUP_VAL,
},
.speed = RGB_MATRIX_STARTUP_SPD,
.flags = LED_FLAG_KEYLIGHT,
},
};
// clang-format on
// Read or write EEPROM data with checks for being inside System76 EC region.
static bool system76_ec_eeprom_op(void *buf, uint16_t size, uint16_t offset, bool write) {
uint16_t addr = SYSTEM76_EC_EEPROM_ADDR + offset;
uint16_t end = addr + size;
// Check for overflow and zero size
if ((end > addr) && (addr >= SYSTEM76_EC_EEPROM_ADDR) && (end <= (SYSTEM76_EC_EEPROM_ADDR + SYSTEM76_EC_EEPROM_SIZE))) {
if (write) {
eeprom_update_block((const void *)buf, (void *)addr, size);
} else {
eeprom_read_block((void *)buf, (const void *)addr, size);
}
return true;
} else {
return false;
}
}
// Read or write EEPROM RGB parameters.
void system76_ec_rgb_eeprom(bool write) {
uint16_t layer_rgb_size = sizeof(layer_rgb);
system76_ec_eeprom_op((void *)layer_rgb, layer_rgb_size, 0, write);
system76_ec_eeprom_op((void *)raw_rgb_data, sizeof(raw_rgb_data), layer_rgb_size, write);
}
// Update RGB parameters on layer change.
void system76_ec_rgb_layer(layer_state_t layer_state) {
if (!bootloader_unlocked) {
uint8_t layer = get_highest_layer(layer_state);
if (layer < DYNAMIC_KEYMAP_LAYER_COUNT) {
rgb_matrix_config = layer_rgb[layer];
}
}
}
#endif // RGB_MATRIX_CUSTOM_KB
void raw_hid_receive(uint8_t *data, uint8_t length) {
// Error response by default, set to success by commands
data[1] = 1;
switch (data[0]) {
case CMD_PROBE:
// Signature
data[2] = 0x76;
data[3] = 0xEC;
// Version
data[4] = 0x01;
data[1] = 0;
break;
case CMD_BOARD:
strncpy((char *)&data[2], QMK_KEYBOARD, length - 2);
data[1] = 0;
break;
case CMD_VERSION:
strncpy((char *)&data[2], QMK_VERSION, length - 2);
data[1] = 0;
break;
case CMD_RESET:
if (bootloader_unlocked) {
data[1] = 0;
bootloader_reset = true;
}
break;
case CMD_KEYMAP_GET: {
uint16_t value = 0;
if (keymap_get(data[2], data[3], data[4], &value)) {
data[5] = (uint8_t)value;
data[6] = (uint8_t)(value >> 8);
data[1] = 0;
}
} break;
case CMD_KEYMAP_SET: {
uint16_t value = ((uint16_t)data[5]) | (((uint16_t)data[6]) << 8);
if (keymap_set(data[2], data[3], data[4], value)) {
data[1] = 0;
}
} break;
#ifdef RGB_MATRIX_CUSTOM_KB
case CMD_LED_GET_VALUE:
if (!bootloader_unlocked) {
uint8_t index = data[2];
for (uint8_t layer = 0; layer < DYNAMIC_KEYMAP_LAYER_COUNT; layer++) {
if (index == (0xF0 | layer)) {
data[3] = layer_rgb[layer].hsv.v;
data[4] = RGB_MATRIX_MAXIMUM_BRIGHTNESS;
data[1] = 0;
break;
}
}
}
break;
case CMD_LED_SET_VALUE:
if (!bootloader_unlocked) {
uint8_t index = data[2];
uint8_t value = data[3];
if (value >= RGB_MATRIX_MAXIMUM_BRIGHTNESS) {
value = RGB_MATRIX_MAXIMUM_BRIGHTNESS;
}
for (uint8_t layer = 0; layer < DYNAMIC_KEYMAP_LAYER_COUNT; layer++) {
if (index == (0xF0 | layer)) {
layer_rgb[layer].hsv.v = value;
data[1] = 0;
system76_ec_rgb_layer(layer_state);
break;
}
}
}
break;
case CMD_LED_GET_COLOR:
if (!bootloader_unlocked) {
uint8_t index = data[2];
if (index < DRIVER_LED_TOTAL) {
data[3] = raw_rgb_data[index].r;
data[4] = raw_rgb_data[index].g;
data[5] = raw_rgb_data[index].b;
data[1] = 0;
} else {
for (uint8_t layer = 0; layer < DYNAMIC_KEYMAP_LAYER_COUNT; layer++) {
if (index == (0xF0 | layer)) {
data[3] = layer_rgb[layer].hsv.h;
data[4] = layer_rgb[layer].hsv.s;
data[5] = 0;
data[1] = 0;
break;
}
}
}
}
break;
case CMD_LED_SET_COLOR:
if (!bootloader_unlocked) {
uint8_t index = data[2];
RGB rgb = {
.r = data[3],
.g = data[4],
.b = data[5],
};
if (index < DRIVER_LED_TOTAL) {
raw_rgb_data[index] = rgb;
data[1] = 0;
} else {
for (uint8_t layer = 0; layer < DYNAMIC_KEYMAP_LAYER_COUNT; layer++) {
if (index == (0xF0 | layer)) {
layer_rgb[layer].hsv.h = rgb.r;
layer_rgb[layer].hsv.s = rgb.g;
// Ignore rgb.b
data[1] = 0;
system76_ec_rgb_layer(layer_state);
break;
}
}
}
}
break;
case CMD_LED_GET_MODE:
if (!bootloader_unlocked) {
uint8_t layer = data[2];
if (layer < DYNAMIC_KEYMAP_LAYER_COUNT) {
enum rgb_matrix_effects mode = layer_rgb[layer].mode;
for (uint8_t i = 0; i < MODE_LAST; i++) {
if (mode_map[i] == mode) {
data[3] = i;
data[4] = layer_rgb[layer].speed;
data[1] = 0;
break;
}
}
}
}
break;
case CMD_LED_SET_MODE:
if (!bootloader_unlocked) {
uint8_t layer = data[2];
uint8_t mode = data[3];
uint8_t speed = data[4];
if (layer < DYNAMIC_KEYMAP_LAYER_COUNT && mode < MODE_LAST) {
layer_rgb[layer].mode = mode_map[mode];
layer_rgb[layer].speed = speed;
data[1] = 0;
system76_ec_rgb_layer(layer_state);
}
}
break;
case CMD_LED_SAVE:
if (!bootloader_unlocked) {
system76_ec_rgb_eeprom(true);
data[1] = 0;
}
break;
#endif // RGB_MATRIX_CUSTOM_KB
case CMD_MATRIX_GET: {
// TODO: Improve performance?
data[2] = matrix_rows();
data[3] = matrix_cols();
uint8_t byte = 4;
uint8_t bit = 0;
for (uint8_t row = 0; row < matrix_rows(); row++) {
for (uint8_t col = 0; col < matrix_cols(); col++) {
if (byte < length) {
if (matrix_is_on(row, col)) {
data[byte] |= (1 << bit);
} else {
data[byte] &= ~(1 << bit);
}
}
bit++;
if (bit >= 8) {
byte++;
bit = 0;
}
}
}
data[1] = 0;
} break;
case CMD_SET_NO_INPUT: {
clear_keyboard();
input_disabled = data[2] != 0;
data[1] = 0;
} break;
}
raw_hid_send(data, length);
if (bootloader_reset) {
// Give host time to read response
wait_ms(100);
// Jump to the bootloader
bootloader_jump();
}
}