[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

keyboards/system76/launch_1/config.h

@@ -0,0 +1,121 @@
+/*
+ *  Copyright (C) 2021  System76
+ *
+ *  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/>.
+ */
+
+#pragma once
+
+#include "config_common.h"
+
+// USB device descriptor parameter
+#define VENDOR_ID    0x3384
+#define PRODUCT_ID   0x0001
+#define DEVICE_VER   0x0001
+#define MANUFACTURER System76
+#define PRODUCT      Launch Configurable Keyboard (launch_1)
+
+// Key matrix size
+#define MATRIX_ROWS 6
+#define MATRIX_COLS 14
+
+/*
+ * Key matrix pins
+ * ROWS: AVR pins used for rows, top to bottom
+ * COLS: AVR pins used for columns, left to right
+ */
+#define MATRIX_ROW_PINS { F0, F1, F4, F5, F6, F7 }
+#define MATRIX_COL_PINS { D7, C7, C6, B6, B5, B4, D6, D4, E6, D5, D3, D2, B7, B0 }
+#define UNUSED_PINS
+
+/*
+ * Diode Direction
+ * COL2ROW = COL => Anode (+), ROW => Cathode (-)
+ * ROW2COL = ROW => Anode (+), COL => Cathode (-)
+ */
+#define DIODE_DIRECTION COL2ROW
+
+// Set 0 if debouncing isn't needed
+#define DEBOUNCE 5
+
+#ifdef RGB_MATRIX_ENABLE
+#    define RGB_DI_PIN E2
+#    define DRIVER_LED_TOTAL 84
+#    define RGB_MATRIX_KEYPRESSES                                      // Reacts to keypresses
+// #    define RGB_MATRIX_KEYRELEASES                                     // Reacts to keyreleases (instead of keypresses)
+// #    define RGB_MATRIX_FRAMEBUFFER_EFFECTS                             // Enables framebuffer effects
+#    define RGB_DISABLE_TIMEOUT 0                                      // Number of milliseconds to wait until RGB automatically turns off
+#    define RGB_DISABLE_AFTER_TIMEOUT 0                                // OBSOLETE: Number of ticks to wait until disabling effects
+#    define RGB_DISABLE_WHEN_USB_SUSPENDED                             // Turns off effects when suspended
+// Limit brightness to support USB-A at 0.5 A
+// TODO: Do this dynamically based on power source
+#    define RGB_MATRIX_MAXIMUM_BRIGHTNESS 176                          // Limits maximum brightness of LEDs to 176 out of 255. If not defined, maximum brightness is set to 255
+#    define RGB_MATRIX_STARTUP_MODE RGB_MATRIX_RAINBOW_MOVING_CHEVRON  // Sets the default mode, if none has been set
+#    define RGB_MATRIX_STARTUP_HUE 142                                 // Sets the default hue value, if none has been set
+#    define RGB_MATRIX_STARTUP_SAT 255                                 // Sets the default saturation value, if none has been set
+#    define RGB_MATRIX_STARTUP_VAL RGB_MATRIX_MAXIMUM_BRIGHTNESS       // Sets the default brightness value, if none has been set
+#    define RGB_MATRIX_STARTUP_SPD 127                                 // Sets the default animation speed, if none has been set
+#    define RGB_MATRIX_DISABLE_KEYCODES                                // Disables control of rgb matrix by keycodes (must use code functions to control the feature)
+
+#    define ENABLE_RGB_MATRIX_CYCLE_ALL
+#    define ENABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT
+#    define ENABLE_RGB_MATRIX_CYCLE_UP_DOWN
+#    define ENABLE_RGB_MATRIX_CYCLE_OUT_IN
+#    define ENABLE_RGB_MATRIX_CYCLE_OUT_IN_DUAL
+#    define ENABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON
+#    define ENABLE_RGB_MATRIX_CYCLE_PINWHEEL
+#    define ENABLE_RGB_MATRIX_CYCLE_SPIRAL
+#    define ENABLE_RGB_MATRIX_RAINDROPS
+#    define ENABLE_RGB_MATRIX_SPLASH
+#    define ENABLE_RGB_MATRIX_MULTISPLASH
+#endif  // RGB_MATRIX_ENABLE
+
+// Mechanical locking support; use KC_LCAP, KC_LNUM, or KC_LSCR instead in keymap
+#define LOCKING_SUPPORT_ENABLE
+
+// Locking resynchronize hack
+#define LOCKING_RESYNC_ENABLE
+
+// I2C {
+#define F_SCL 100000UL // Run I2C bus at 100 kHz
+#define I2C_START_RETRY_COUNT 20
+#define I2C_TIMEOUT 100 // milliseconds
+// } I2C
+
+// EEPROM {
+#define EEPROM_SIZE 1024
+// TODO: Refactor with new user EEPROM code (coming soon)
+#define EEPROM_MAGIC 0x76EC
+#define EEPROM_MAGIC_ADDR 64
+// Bump this every time we change what we store
+// This will automatically reset the EEPROM with defaults
+// and avoid loading invalid data from the EEPROM
+#define EEPROM_VERSION 0x02
+#define EEPROM_VERSION_ADDR (EEPROM_MAGIC_ADDR + 2)
+// } EEPROM
+
+// Dynamic keymap {
+#define DYNAMIC_KEYMAP_LAYER_COUNT 4
+#define DYNAMIC_KEYMAP_MACRO_COUNT 0
+// Dynamic keymap starts after EEPROM version
+#define DYNAMIC_KEYMAP_EEPROM_ADDR (EEPROM_VERSION_ADDR + 1)
+// Dynamic macro starts after dynamic keymaps, it is disabled
+#define DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR (DYNAMIC_KEYMAP_EEPROM_ADDR + (DYNAMIC_KEYMAP_LAYER_COUNT * MATRIX_ROWS * MATRIX_COLS * 2))
+#define DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE 0
+// } Dynamic keymap
+
+// System76 EC {
+#define SYSTEM76_EC_EEPROM_ADDR (DYNAMIC_KEYMAP_MACRO_EEPROM_ADDR + DYNAMIC_KEYMAP_MACRO_EEPROM_SIZE)
+#define SYSTEM76_EC_EEPROM_SIZE (EEPROM_SIZE - SYSTEM76_EC_EEPROM_ADDR)
+// } System76 EC

keyboards/system76/launch_1/info.json

@@ -0,0 +1,94 @@
+{
+    "keyboard_name": "System76 Launch Configurable Keyboard (launch_1)",
+    "url": "https://system76.com/accessories/launch",
+    "layouts": {
+        "LAYOUT": {
+            "layout": [
+                { "label": "Esc", "x": 0, "y": 0 },
+                { "label": "F1", "x": 1, "y": 0 },
+                { "label": "F2", "x": 2, "y": 0 },
+                { "label": "F3", "x": 3, "y": 0 },
+                { "label": "F4", "x": 4, "y": 0 },
+                { "label": "F5", "x": 5, "y": 0 },
+                { "label": "F6", "x": 6, "y": 0 },
+                { "label": "F7", "x": 7, "y": 0 },
+                { "label": "F8", "x": 8, "y": 0 },
+                { "label": "F9", "x": 9, "y": 0 },
+                { "label": "F10", "x": 10, "y": 0 },
+                { "label": "F11", "x": 11, "y": 0 },
+                { "label": "F12", "x": 12, "y": 0 },
+                { "label": "Del", "x": 13, "y": 0, "w": 1.5 },
+                { "label": "Home", "x": 14.75, "y": 0 },
+                { "label": "`", "x": 0, "y": 1 },
+                { "label": "1", "x": 1, "y": 1 },
+                { "label": "2", "x": 2, "y": 1 },
+                { "label": "3", "x": 3, "y": 1 },
+                { "label": "4", "x": 4, "y": 1 },
+                { "label": "5", "x": 5, "y": 1 },
+                { "label": "6", "x": 6, "y": 1 },
+                { "label": "7", "x": 7, "y": 1 },
+                { "label": "8", "x": 8, "y": 1 },
+                { "label": "9", "x": 9, "y": 1 },
+                { "label": "0", "x": 10, "y": 1 },
+                { "label": "-", "x": 11, "y": 1 },
+                { "label": "=", "x": 12, "y": 1 },
+                { "label": "Bksp", "x": 13, "y": 1, "w": 1.5 },
+                { "label": "PgUp", "x": 14.75, "y": 1 },
+                { "label": "Tab", "x": 0, "y": 2, "w": 1.5 },
+                { "label": "Q", "x": 1.5, "y": 2 },
+                { "label": "W", "x": 2.5, "y": 2 },
+                { "label": "E", "x": 3.5, "y": 2 },
+                { "label": "R", "x": 4.5, "y": 2 },
+                { "label": "T", "x": 5.5, "y": 2 },
+                { "label": "Y", "x": 6.5, "y": 2 },
+                { "label": "U", "x": 7.5, "y": 2 },
+                { "label": "I", "x": 8.5, "y": 2 },
+                { "label": "O", "x": 9.5, "y": 2 },
+                { "label": "P", "x": 10.5, "y": 2 },
+                { "label": "[", "x": 11.5, "y": 2 },
+                { "label": "]", "x": 12.5, "y": 2 },
+                { "label": "\\", "x": 13.5, "y": 2 },
+                { "label": "PgDn", "x": 14.75, "y": 2 },
+                { "label": "Caps", "x": 0.25, "y": 3, "w": 1.5 },
+                { "label": "A", "x": 1.75, "y": 3 },
+                { "label": "S", "x": 2.75, "y": 3 },
+                { "label": "D", "x": 3.75, "y": 3 },
+                { "label": "F", "x": 4.75, "y": 3 },
+                { "label": "G", "x": 5.75, "y": 3 },
+                { "label": "H", "x": 6.75, "y": 3 },
+                { "label": "J", "x": 7.75, "y": 3 },
+                { "label": "K", "x": 8.75, "y": 3 },
+                { "label": "L", "x": 9.75, "y": 3 },
+                { "label": ";", "x": 10.75, "y": 3 },
+                { "label": "'", "x": 11.75, "y": 3 },
+                { "label": "Enter", "x": 12.75, "y": 3, "w": 1.5 },
+                { "label": "End", "x": 14.75, "y": 3 },
+                { "label": "LShift", "x": 0.25, "y": 4, "w": 2 },
+                { "label": "Z", "x": 2.25, "y": 4 },
+                { "label": "X", "x": 3.25, "y": 4 },
+                { "label": "C", "x": 4.25, "y": 4 },
+                { "label": "V", "x": 5.25, "y": 4 },
+                { "label": "B", "x": 6.25, "y": 4 },
+                { "label": "N", "x": 7.25, "y": 4 },
+                { "label": "M", "x": 8.25, "y": 4 },
+                { "label": ",", "x": 9.25, "y": 4 },
+                { "label": ".", "x": 10.25, "y": 4 },
+                { "label": "/", "x": 11.25, "y": 4 },
+                { "label": "RShift", "x": 12.25, "y": 4, "w": 1.5 },
+                { "label": "Up", "x": 13.75, "y": 4 },
+                { "label": "LCtrl", "x": 0.25, "y": 5, "w": 1.5 },
+                { "label": "LAlt", "x": 1.75, "y": 5 },
+                { "label": "LFn", "x": 2.75, "y": 5 },
+                { "label": "Super", "x": 3.75, "y": 5 },
+                { "label": "Space", "x": 4.75, "y": 5, "w": 2 },
+                { "label": "Space", "x": 6.75, "y": 5, "w": 2 },
+                { "label": "RCtrl", "x": 8.75, "y": 5 },
+                { "label": "RAlt", "x": 9.75, "y": 5 },
+                { "label": "RFn", "x": 10.75, "y": 5, "w": 1.5 },
+                { "label": "Left", "x": 12.75, "y": 5 },
+                { "label": "Down", "x": 13.75, "y": 5 },
+                { "label": "Right", "x": 14.75, "y": 5 }
+            ]
+        }
+    }
+}

keyboards/system76/launch_1/keymaps/default/keymap.c

@@ -0,0 +1,104 @@
+/*
+ *  Copyright (C) 2021  System76
+ *
+ *  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 QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+  /* Layer 0, default layer
+ _________________________________________________________________________________________________________________________________  ________
+|        |        |        |        |        |        |        |        |        |        |        |        |        |            ||        |
+|  ESC   |   F1   |   F2   |   F3   |   F4   |   F5   |   F6   |   F7   |   F8   |   F9   |  F10   |  F11   |  F12   |  DELETE    ||  HOME  |
+|________|________|________|________|________|________|________|________|________|________|________|________|________|____________||________|
+|   ~    |   !    |   @    |   #    |   $    |   %    |   ^    |   &    |   *    |   (    |   )    |   _    |   +    |            ||        |
+|   `    |   1    |   2    |   3    |   4    |   5    |   6    |   7    |   8    |   9    |   0    |   -    |   =    | BACKSPACE  ||  PGUP  |
+|________|________|________|________|________|________|________|________|________|________|________|________|________|____________||________|
+|            |        |        |        |        |        |        |        |        |        |        |  [     |   ]    |   |    ||        |
+|     TAB    |   Q    |   W    |   E    |   R    |   T    |   Y    |   U    |   I    |   O    |   P    |  {     |   }    |   \    ||  PGDN  |
+|____________|________|________|________|________|________|________|________|________|________|________|________|________|________||________|
+  |            |        |        |        |        |        |        |        |        |        |   :    |   "    |            |   |        |
+  |    CAPS    |   A    |   S    |   D    |   F    |   G    |   H    |   J    |   K    |   L    |   ;    |   '    |   ENTER    |   |  END   |
+  |____________|________|________|________|________|________|________|________|________|________|________|________|____________|___|________|
+  |                |        |        |        |        |        |        |        |   <    |    >   |   ?    |            |        |
+  |     SHIFT      |   Z    |   X    |   C    |   V    |   B    |   N    |   M    |   ,    |    .   |   /    |   SHIFT    |   UP   |
+  |________________|________|________|________|________|________|________|________|________|________|________|____________|________|________
+  |            |        |       |        |                 |                 |        |        |             |   |        |        |        |
+  |    CTRL    |  LALT  | FN    | LGUI   |    SPACE        |      SPACE      | RCTRL  |  RALT  |     FN      |   |  LEFT  |  DOWN  | RIGHT  |
+  |____________|________|_______|________|_________________|_________________|________|________|_____________|   |________|________|________|
+   */
+
+  [0] = LAYOUT(
+    KC_ESC,  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  KC_DEL,     KC_HOME,
+    KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC,    KC_PGUP,
+    KC_TAB,    KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_BSLS,  KC_PGDN,
+      KC_CAPS,   KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_ENT,          KC_END,
+      KC_LSFT,     KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH,     KC_RSFT,   KC_UP,
+      KC_LCTL,   KC_LALT, MO(1),   KC_LGUI, KC_SPC,           KC_SPC,           KC_RCTL, KC_RALT, MO(1),           KC_LEFT, KC_DOWN, KC_RGHT
+  ),
+
+    /* Layer 1, function layer
+ _________________________________________________________________________________________________________________________________  ________
+|        |        |        |        |        |        |        |        |        |        |        |        |        |            || PLAY/  |
+| RESET  |        |        |        |        |        |        |        |        |        |        |        |        |            || PAUSE  |
+|________|________|________|________|________|________|________|________|________|________|________|________|________|____________||________|
+|        |        |        |        |        |        |        |        |        |        |  LED   |  LED   |  LED   |            || VOLUME |
+|        |        |        |        |        |        |        |        |        |        | TOGGLE |  DOWN  |  UP    |            ||   UP   |
+|________|________|________|________|________|________|________|________|________|________|________|________|________|____________||________|
+|            |        |        |        |        |        |        |        |        |        |        |        |        |        || VOLUME |
+|PRINT SCREEN|        |        |        |        |        |  HOME  |  PGDN  |  PGUP  |  END   |        |        |        |        ||  DOWN  |
+|____________|________|________|________|________|________|________|________|________|________|________|________|________|________||________|
+  |            |        |        |        |        |        |        |        |        |        |        |        |            |   |        |
+  |            |        |        |        |        |        |  LEFT  |  DOWN  |   UP   | RIGHT  |        |        |            |   |  MUTE  |
+  |____________|________|________|________|________|________|________|________|________|________|________|________|____________|___|________|
+  |                |        |        |        |        |        |        |        |        |        |        |            |        |
+  |                |        |        |        |        |        |        |        |        |        |        |            |  PGUP  |
+  |________________|________|________|________|________|________|________|________|________|________|________|____________|________|________
+  |            |        |       |        |                 |                 |        |        |             |   |        |        |        |
+  |            |        |       |        |                 |                 |        |        |             |   |  HOME  |  PGDN  |  END   |
+  |____________|________|_______|________|_________________|_________________|________|________|_____________|   |________|________|________|
+
+   * `RESET' resets the controller and puts the board into firmware flashing mode.
+   * If this key is hit accidentally, just unplug the board and plug it back in.
+   */
+
+  [1] = LAYOUT(
+    RESET,   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_MPLY,
+    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, RGB_TOG, RGB_VAD, RGB_VAI, KC_TRNS,    KC_VOLU,
+    KC_PSCR,   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_HOME, KC_PGDN, KC_PGUP, KC_END,  KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,  KC_VOLD,
+      KC_TRNS,   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT, KC_TRNS, KC_TRNS, KC_TRNS,         KC_MUTE,
+      KC_TRNS,     KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,     KC_TRNS,   KC_PGUP,
+      KC_TRNS,   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,          KC_TRNS,        KC_TRNS, KC_TRNS, KC_TRNS,           KC_HOME, KC_PGDN, KC_END
+  ),
+
+  [2] = LAYOUT(
+    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_TRNS,
+    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_TRNS,
+    KC_TRNS,   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,  KC_TRNS,
+      KC_TRNS,   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,         KC_TRNS,
+      KC_TRNS,     KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,     KC_TRNS,   KC_TRNS,
+      KC_TRNS,   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,          KC_TRNS,        KC_TRNS, KC_TRNS, KC_TRNS,           KC_TRNS, KC_TRNS, KC_TRNS
+  ),
+
+  [3] = LAYOUT(
+    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_TRNS,
+    KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,    KC_TRNS,
+    KC_TRNS,   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,  KC_TRNS,
+      KC_TRNS,   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,         KC_TRNS,
+      KC_TRNS,     KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,     KC_TRNS,   KC_TRNS,
+      KC_TRNS,   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,          KC_TRNS,        KC_TRNS, KC_TRNS, KC_TRNS,           KC_TRNS, KC_TRNS, KC_TRNS
+  ),
+};

keyboards/system76/launch_1/launch_1.c

@@ -0,0 +1,240 @@
+/*
+ *  Copyright (C) 2021  System76
+ *
+ *  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 "launch_1.h"
+
+#include "usb_mux.h"
+
+// clang-format off
+#ifdef RGB_MATRIX_ENABLE
+// LEDs by index
+//    0   1   2   3   4   5   6   7   8   9
+// 00 LM4 LL4 LK4 LJ4 LI4 LH4 LG4 LF4 LE4 LD4
+// 10 LC4 LB4 LA4 LA5 LB5 LC5 LD5 LE5 LG5 LH5
+// 20 LI5 LJ5 LK5 LL5 LM5 LO3 LM3 LL3 LK3 LJ3
+// 30 LI3 LH3 LG3 LF3 LE3 LD3 LC3 LB3 LA3 LA2
+// 40 LB2 LC2 LD2 LE2 LF2 LG2 LH2 LI2 LJ2 LK2
+// 50 LL2 LM2 LN2 LO2 LO1 LN1 LM1 LL1 LK1 LJ1
+// 60 LI1 LH1 LG1 LF1 LE1 LD1 LC1 LB1 LA1 LA0
+// 70 LB0 LC0 LD0 LE0 LF0 LG0 LH0 LI0 LJ0 LK0
+// 80 LL0 LM0 LN0 LO0
+led_config_t g_led_config = { LAYOUT(
+    // Key matrix to LED index
+    /*  A   B   C   D   E   F   G   H   I   J   K   L   M   N   O */
+/* 0 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
+/* 1 */ 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54,
+/* 2 */ 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
+/* 3 */ 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26,     25,
+/* 4 */ 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1,      0,
+/* 5 */ 13, 14, 15, 16, 17,     18,      19, 20, 21,    22, 23, 24
+), {
+    // LED index to physical position (see leds.sh in `launch' repo)
+/* 00 */ {209, 51}, {190, 51}, {171, 51}, {156, 51}, {140, 51}, {125, 51}, {110, 51}, {95, 51}, {80, 51}, {65, 51},
+/* 10 */ {49, 51}, {34, 51}, {11, 51}, {8, 64}, {27, 64}, {42, 64}, {57, 64}, {80, 64}, {110, 64}, {133, 64},
+/* 20 */ {148, 64}, {167, 64}, {194, 64}, {209, 64}, {224, 64}, {224, 38}, {197, 38}, {178, 38}, {163, 38}, {148, 38},
+/* 30 */ {133, 38}, {118, 38}, {103, 38}, {87, 38}, {72, 38}, {57, 38}, {42, 38}, {27, 38}, {8, 38}, {4, 26},
+/* 40 */ {23, 26}, {38, 26}, {53, 26}, {68, 26}, {84, 26}, {99, 26}, {114, 26}, {129, 26}, {144, 26}, {159, 26},
+/* 50 */ {175, 26}, {190, 26}, {205, 26}, {224, 26}, {224, 13}, {201, 13}, {182, 13}, {167, 13}, {152, 13}, {137, 13},
+/* 60 */ {121, 13}, {106, 13}, {91, 13}, {76, 13}, {61, 13}, {46, 13}, {30, 13}, {15, 13}, {0, 13}, {0, 0},
+/* 70 */ {15, 0}, {30, 0}, {46, 0}, {61, 0}, {76, 0}, {91, 0}, {106, 0}, {121, 0}, {137, 0}, {152, 0},
+/* 80 */ {167, 0}, {182, 0}, {201, 0}, {224, 0}
+}, {
+    // LED index to flags (set all to LED_FLAG_KEYLIGHT)
+    /*   0  1  2  3  4  5  6  7  8  9 */
+/* 00 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+/* 10 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+/* 20 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+/* 30 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+/* 40 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+/* 50 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+/* 60 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+/* 70 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+/* 80 */ 4, 4, 4, 4
+} };
+#endif // RGB_MATRIX_ENABLE
+
+bool eeprom_is_valid(void) { 
+    return (
+        eeprom_read_word(((void *)EEPROM_MAGIC_ADDR)) == EEPROM_MAGIC &&
+        eeprom_read_byte(((void *)EEPROM_VERSION_ADDR)) == EEPROM_VERSION
+    );
+}
+// clang-format on
+
+void eeprom_set_valid(bool valid) {
+    eeprom_update_word(((void *)EEPROM_MAGIC_ADDR), valid ? EEPROM_MAGIC : 0xFFFF);
+    eeprom_update_byte(((void *)EEPROM_VERSION_ADDR), valid ? EEPROM_VERSION : 0xFF);
+}
+
+void bootmagic_lite_reset_eeprom(void) {
+    // Set the keyboard-specific EEPROM state as invalid
+    eeprom_set_valid(false);
+    // Set the TMK/QMK EEPROM state as invalid
+    eeconfig_disable();
+}
+
+// The lite version of TMK's bootmagic based on Wilba.
+// 100% less potential for accidentally making the keyboard do stupid things.
+void bootmagic_lite(void) {
+    // Perform multiple scans because debouncing can't be turned off.
+    matrix_scan();
+#if defined(DEBOUNCE) && DEBOUNCE > 0
+    wait_ms(DEBOUNCE * 2);
+#else
+    wait_ms(30);
+#endif
+    matrix_scan();
+
+    // If the configured key (commonly Esc) is held down on power up,
+    // reset the EEPROM valid state and jump to bootloader.
+    uint8_t row = 0;  // BOOTMAGIC_LITE_ROW;
+    uint8_t col = 0;  // BOOTMAGIC_LITE_COLUMN;
+
+    if (matrix_get_row(row) & (1 << col)) {
+        bootmagic_lite_reset_eeprom();
+
+        // Jump to bootloader.
+        bootloader_jump();
+    }
+}
+
+void system76_ec_rgb_eeprom(bool write);
+void system76_ec_rgb_layer(layer_state_t layer_state);
+void system76_ec_unlock(void);
+bool system76_ec_is_unlocked(void);
+
+rgb_config_t layer_rgb[DYNAMIC_KEYMAP_LAYER_COUNT];
+
+void matrix_init_kb(void) {
+    usb_mux_init();
+
+    bootmagic_lite();
+    if (!eeprom_is_valid()) {
+        dynamic_keymap_reset();
+        dynamic_keymap_macro_reset();
+        system76_ec_rgb_eeprom(true);
+        eeprom_set_valid(true);
+    } else {
+        system76_ec_rgb_eeprom(false);
+    }
+
+    system76_ec_rgb_layer(layer_state);
+}
+
+void matrix_scan_kb(void) {
+    usb_mux_event();
+
+    matrix_scan_user();
+}
+
+#define LEVEL(value) (uint8_t)(((uint16_t)value) * ((uint16_t)RGB_MATRIX_MAXIMUM_BRIGHTNESS) / ((uint16_t)255))
+
+// clang-format off
+static const uint8_t levels[] = {
+    LEVEL(48),
+    LEVEL(72),
+    LEVEL(96),
+    LEVEL(144),
+    LEVEL(192),
+    LEVEL(255)
+};
+// clang-format on
+
+static uint8_t toggle_level = RGB_MATRIX_MAXIMUM_BRIGHTNESS;
+extern bool    input_disabled;
+
+static void set_value_all_layers(uint8_t value) {
+    if (!system76_ec_is_unlocked()) {
+        for (int8_t layer = 0; layer < DYNAMIC_KEYMAP_LAYER_COUNT; layer++) {
+            layer_rgb[layer].hsv.v = value;
+        }
+        system76_ec_rgb_layer(layer_state);
+    }
+}
+
+bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
+    if (input_disabled) {
+        return false;
+    }
+
+    if (!process_record_user(keycode, record)) {
+        return false;
+    }
+
+    switch (keycode) {
+        case RESET:
+            if (record->event.pressed) {
+                system76_ec_unlock();
+            }
+#ifdef SYSTEM76_EC
+            return false;
+#else
+            return true;
+#endif
+        case RGB_VAD:
+            if (record->event.pressed) {
+                uint8_t level = rgb_matrix_config.hsv.v;
+                for (int i = sizeof(levels) - 1; i >= 0; i--) {
+                    if (levels[i] < level) {
+                        level = levels[i];
+                        break;
+                    }
+                }
+                set_value_all_layers(level);
+            }
+            return false;
+        case RGB_VAI:
+            if (record->event.pressed) {
+                uint8_t level = rgb_matrix_config.hsv.v;
+                for (int i = 0; i < sizeof(levels); i++) {
+                    if (levels[i] > level) {
+                        level = levels[i];
+                        break;
+                    }
+                }
+                set_value_all_layers(level);
+            }
+            return false;
+        case RGB_TOG:
+            if (record->event.pressed) {
+                uint8_t level = 0;
+                if (rgb_matrix_config.hsv.v == 0) {
+                    level = toggle_level;
+                } else {
+                    toggle_level = rgb_matrix_config.hsv.v;
+                }
+                set_value_all_layers(level);
+            }
+            return false;
+    }
+
+    return true;
+}
+
+layer_state_t layer_state_set_kb(layer_state_t layer_state) {
+    system76_ec_rgb_layer(layer_state);
+
+    return layer_state_set_user(layer_state);
+}
+
+#ifdef CONSOLE_ENABLE
+void keyboard_post_init_user(void) {
+    debug_enable   = true;
+    debug_matrix   = false;
+    debug_keyboard = false;
+}
+#endif  // CONSOLE_ENABLE

keyboards/system76/launch_1/launch_1.h

@@ -0,0 +1,38 @@
+/*
+ *  Copyright (C) 2021  System76
+ *
+ *  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/>.
+ */
+
+#pragma once
+
+#include "quantum.h"
+
+// clang-format off
+#define LAYOUT( \
+  K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D,   K0E, \
+  K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D,   K1E, \
+  K20,  K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D,  K2E, \
+   K30,  K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C,      K3D, \
+   K40,   K41, K42, K43, K44, K45, K46, K47, K48, K49, K4A,    K4B,  K4C,      \
+   K50,  K51, K52, K53, K54,      K55,      K56, K57, K58,      K59, K5A, K5B  \
+) { \
+    { K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D }, \
+    { K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D }, \
+    { K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D }, \
+    { K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, K0E }, \
+    { K40, K41, K42, K43, K44, K45, K46, K47, K48, K49, K4A, K4B, K4C, K1E }, \
+    { K50, K51, K52, K53, K54, K3D, K55, K56, K57, K58, K59, K5A, K5B, K2E }, \
+}
+// clang-format on

keyboards/system76/launch_1/post_rules.mk

@@ -0,0 +1,12 @@
+# System76 EC
+#   remove the RESET HID command
+VALID_SYSTEM76_EC_TYPES := yes
+SYSTEM76_EC_ENABLE ?= no
+ifneq ($(strip $(SYSTEM76_EC_ENABLE)),no)
+    ifeq ($(filter $(SYSTEM76_EC_ENABLE),$(VALID_SYSTEM76_EC_TYPES)),)
+        $(error SYSTEM76_EC_EN="$(strip $(SYSTEM76_EC_ENABLE))" is not a valid type for the System76 EC option)
+    endif
+    ifneq ($(strip $(SYSTEM76_EC_ENABLE)),no)
+        OPT_DEFS += -DSYSTEM76_EC
+    endif
+endif

keyboards/system76/launch_1/readme.md

@@ -0,0 +1,62 @@
+# System76 Launch Configurable Keyboard (launch_1)
+
+![System76 Launch Configurable Keyboard](https://images.prismic.io/system76/b71307ac-dae6-4863-b7ca-804cd61c7ef8_launch_overhead.png?auto=compress,format&w=750)
+
+The Launch Configurable Keyboard is engineered to be comfortable, fully customizable, and make your workflow more efficient.
+
+- High-speed USB Hub
+- Works on Linux, Windows and macOS
+- 100% Open Source
+- Made in Colorado
+
+Additional Launch Keyboard resources:
+
+- Keyboard Maintainer: [System76](https://github.com/system76)
+- Hardware Supported: [System76 Launch GitHub Repository](https://github.com/system76/launch)
+- Hardware Availability: [Shop System76](https://system76.com/accessories/launch)
+
+## Building Firmware
+
+To build the firmware using `make` (after setting up the build environment), e.g.:
+
+```bash
+make -r system76/launch_1:default
+```
+
+Equivalently, using the QMK CLI:
+
+```bash
+qmk compile -kb system76/launch_1 -km default
+```
+
+## Flashing Firmware (DFU)
+
+To build and flash the firmware on the keyboard, e.g.:
+
+```bash
+make -r system76/launch_1:default:flash
+```
+
+Equivalently, using the QMK CLI:
+
+```bash
+qmk flash -kb system76/launch_1 -km default
+```
+
+## Flashing Firmware (ISP)
+
+To flash the firmware (and/or bootloader) using ISP refer to the [_ISP Flashing Guide_](https://docs.qmk.fm/#/isp_flashing_guide).
+
+> **Factory fuse values** => Low: `0x5E`, High: `0x99`, Extended: `0xF3`, Lock Bits: `0xFF`
+
+## Environment Setup
+
+See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. If new to QMK, start with the [_Complete Newbs Guide_](https://docs.qmk.fm/#/newbs).
+
+## Bootloader
+
+Enter the bootloader in 3 ways:
+
+- **Bootmagic reset**: Hold down the key at (0,0) in the matrix (Escape) and plug in the keyboard.
+- **Keycode in layout**: Press the key mapped to `RESET` in the second layer (Escape).
+- **Electrical reset**: Briefly short AVR ISP's GND (6) and RST (5) pads on the back of the PCB.

keyboards/system76/launch_1/rgb_matrix_kb.inc

@@ -0,0 +1,157 @@
+/*
+ *  Copyright (C) 2021  System76
+ *
+ *  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/>.
+ */
+
+RGB_MATRIX_EFFECT(active_keys)
+RGB_MATRIX_EFFECT(raw_rgb)
+RGB_MATRIX_EFFECT(unlocked)
+
+#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS
+
+#include "dynamic_keymap.h"
+
+static bool active_keys_initialized = false;
+static uint8_t active_keys_table[DRIVER_LED_TOTAL] = {0};
+
+static void active_keys_initialize(void) {
+    for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
+        for (uint8_t col = 0; col < MATRIX_COLS; col++) {
+            uint8_t led = g_led_config.matrix_co[row][col];
+            if (led < DRIVER_LED_TOTAL && row < 16 && col < 16) {
+                active_keys_table[led] = (row << 4) | col;
+            }
+        }
+    }
+    active_keys_initialized = true;
+}
+
+static bool active_keys(effect_params_t* params) {
+    if (!active_keys_initialized) {
+        active_keys_initialize();
+    }
+
+    RGB_MATRIX_USE_LIMITS(led_min, led_max);
+    uint8_t layer = get_highest_layer(layer_state);
+    RGB rgb = hsv_to_rgb(rgb_matrix_config.hsv);
+
+    for (uint8_t i = led_min; i < led_max; i++) {
+        RGB_MATRIX_TEST_LED_FLAGS();
+
+        uint8_t rowcol = active_keys_table[i];
+        uint8_t row = rowcol >> 4;
+        uint8_t col = rowcol & 0xF;
+        uint16_t keycode = dynamic_keymap_get_keycode(layer, row, col);
+        switch (keycode) {
+            case KC_NO:
+            case KC_TRNS:
+                rgb_matrix_set_color(i, 0, 0, 0);
+                break;
+            default:
+                rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
+                break;
+        }
+    }
+
+    return led_max < DRIVER_LED_TOTAL;
+}
+
+RGB raw_rgb_data[DRIVER_LED_TOTAL] = {0};
+
+static uint8_t normalize_component(uint8_t component) {
+    uint16_t x = (uint16_t)component;
+    x *= rgb_matrix_config.hsv.v;  // Multiply by current brightness
+    x /= 255;                      // Divide by maximum brightness
+    return (uint8_t)x;
+}
+
+static RGB normalize_index(uint8_t i) {
+    RGB raw = raw_rgb_data[i];
+    RGB rgb = {
+        .r = normalize_component(raw.r),
+        .g = normalize_component(raw.g),
+        .b = normalize_component(raw.b),
+    };
+    return rgb;
+}
+
+static bool raw_rgb(effect_params_t* params) {
+    RGB_MATRIX_USE_LIMITS(led_min, led_max);
+    for (uint8_t i = led_min; i < led_max; i++) {
+        RGB_MATRIX_TEST_LED_FLAGS();
+        RGB rgb = normalize_index(i);
+        rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
+    }
+    return led_max < DRIVER_LED_TOTAL;
+}
+
+static uint8_t unlocked_keys[8][2] = {
+    {2, 7},  // U
+    {4, 6},  // N
+    {3, 9},  // L
+    {2, 9},  // O
+    {4, 3},  // C
+    {3, 8},  // K
+    {2, 3},  // E
+    {3, 3},  // D
+};
+
+static uint8_t unlocked_ticks      = 0;
+static uint8_t unlocked_i          = 0;
+static uint8_t unlocked_leds_count = 0;
+static uint8_t unlocked_leds[2]    = {0, 0};
+
+static bool unlocked(effect_params_t* params) {
+    RGB_MATRIX_USE_LIMITS(led_min, led_max);
+
+    unlocked_ticks++;
+
+    if (params->init) {
+        unlocked_ticks = 0;
+        unlocked_i = 0;
+    }
+
+    if (unlocked_ticks == 0) {
+        if (unlocked_i == 8) {
+            unlocked_leds_count = 0;
+            unlocked_i = 0;
+        } else {
+            unlocked_leds_count = rgb_matrix_map_row_column_to_led(unlocked_keys[unlocked_i][0], unlocked_keys[unlocked_i][1], unlocked_leds);
+            unlocked_i++;
+        }
+    }
+
+    for (uint8_t i = led_min; i < led_max; i++) {
+        RGB_MATRIX_TEST_LED_FLAGS();
+
+        HSV hsv = {
+            .h = i + unlocked_ticks,
+            .s = 0xFF,
+            .v = 0x70,
+        };
+        for (uint8_t j = 0; j < unlocked_leds_count; j++) {
+            if (i == unlocked_leds[j]) {
+                hsv.s = 0;
+                hsv.v = 0xFF;
+            }
+        }
+
+        RGB rgb = hsv_to_rgb(hsv);
+        rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
+    }
+    return led_max < DRIVER_LED_TOTAL;
+}
+
+#endif  // RGB_MATRIX_CUSTOM_EFFECT_IMPLS

keyboards/system76/launch_1/rules.mk

@@ -0,0 +1,33 @@
+# MCU name
+MCU = atmega32u4
+
+# CPU frequency divided by two since AVR is at 3.3 V
+F_CPU = 8000000
+
+# External oscillator is 16 MHz
+F_USB = 16000000
+
+# Bootloader selection
+BOOTLOADER = atmel-dfu
+
+# Build options
+#   change yes to no to disable
+BOOTMAGIC_ENABLE = no       # Bootmagic Lite
+MOUSEKEY_ENABLE = no        # Mouse keys
+EXTRAKEY_ENABLE = yes       # Audio control and system control
+CONSOLE_ENABLE = no         # Console for debug
+COMMAND_ENABLE = no         # Commands for debug and configuration
+DYNAMIC_KEYMAP_ENABLE = yes # Reconfigurable keyboard without flashing firmware
+NKRO_ENABLE = yes           # USB N-key rollover
+RAW_ENABLE = yes            # Raw HID commands (used by Keyboard Configurator)
+BACKLIGHT_ENABLE = no       # RGB backlight (conflicts with RGB matrix)
+RGBLIGHT_ENABLE = no        # Enable keyboard RGB underglow
+RGB_MATRIX_ENABLE = yes     # RGB matrix
+RGB_MATRIX_DRIVER = WS2812
+RGB_MATRIX_CUSTOM_KB = yes  # Custom keyboard effects
+AUDIO_ENABLE = no           # Audio output
+LTO_ENABLE = yes            # Link-time optimization for smaller binary
+
+# Add System76 EC command interface as well as I2C and USB mux drivers
+SRC += system76_ec.c usb_mux.c
+QUANTUM_LIB_SRC += i2c_master.c

keyboards/system76/launch_1/usb_mux.c

@@ -0,0 +1,478 @@
+/*
+ *  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 "usb_mux.h"
+
+#include <stdbool.h>
+
+#include "i2c_master.h"
+#include "wait.h"
+
+#define REG_PF1_CTL 0xBF800C04
+#define REG_PIO64_OEN 0xBF800908
+#define REG_PIO64_OUT 0xBF800928
+#define REG_VID 0xBF803000
+#define REG_PRT_SWAP 0xBF8030FA
+#define REG_USB3_HUB_VID 0xBFD2E548
+#define REG_RUNTIME_FLAGS2 0xBFD23408
+#define REG_I2S_FEAT_SEL 0xBFD23412
+
+struct USB7206 {
+    uint8_t addr;
+};
+
+struct USB7206 usb_hub = {.addr = 0x2D};
+
+// Perform USB7206 register access.
+// Returns zero on success or a negative number on error.
+i2c_status_t usb7206_register_access(struct USB7206* self) {
+    uint8_t register_access[3] = {
+        0x99,
+        0x37,
+        0x00,
+    };
+
+    return i2c_transmit(self->addr << 1, register_access, sizeof(register_access), I2C_TIMEOUT);
+}
+
+// Read data from USB7206 register region.
+// Returns number of bytes read on success or a negative number on error.
+i2c_status_t usb7206_read_reg(struct USB7206* self, uint32_t addr, uint8_t* data, int length) {
+    i2c_status_t status;
+
+    uint8_t register_read[9] = {
+        0x00,                   // Buffer address MSB: always 0
+        0x00,                   // Buffer address LSB: always 0
+        0x06,                   // Number of bytes to write to command block buffer area
+        0x01,                   // Direction: 0 = write, 1 = read
+        (uint8_t)length,        // Number of bytes to read from register
+        (uint8_t)(addr >> 24),  // Register address byte 3
+        (uint8_t)(addr >> 16),  // Register address byte 2
+        (uint8_t)(addr >> 8),   // Register address byte 1
+        (uint8_t)(addr >> 0),   // Register address byte 0
+    };
+
+    status = i2c_transmit(self->addr << 1, register_read, sizeof(register_read), I2C_TIMEOUT);
+    if (status < 0) {
+        return status;
+    }
+
+    status = usb7206_register_access(self);
+    if (status < 0) {
+        return status;
+    }
+
+    uint8_t read[2] = {
+        0x00,  // Buffer address MSB: always 0
+        0x06,  // Buffer address LSB: 6 to skip header
+    };
+
+    status = i2c_start((self->addr << 1) | I2C_WRITE, I2C_TIMEOUT);
+    if (status >= 0) {
+        for (uint16_t i = 0; i < sizeof(read); i++) {
+            status = i2c_write(read[i], I2C_TIMEOUT);
+            if (status < 0) {
+                goto error;
+            }
+        }
+    } else {
+        goto error;
+    }
+
+    status = i2c_start((self->addr << 1) | I2C_READ, I2C_TIMEOUT);
+    if (status < 0) {
+        goto error;
+    }
+
+    // Read and ignore buffer length
+    status = i2c_read_ack(I2C_TIMEOUT);
+    if (status < 0) {
+        goto error;
+    }
+
+    for (uint16_t i = 0; i < (length - 1) && status >= 0; i++) {
+        status = i2c_read_ack(I2C_TIMEOUT);
+        if (status >= 0) {
+            data[i] = (uint8_t)status;
+        }
+    }
+
+    if (status >= 0) {
+        status = i2c_read_nack(I2C_TIMEOUT);
+        if (status >= 0) {
+            data[(length - 1)] = (uint8_t)status;
+        }
+    }
+
+error:
+    i2c_stop();
+
+    return (status < 0) ? status : length;
+}
+
+// Read 32-bit value from USB7206 register region.
+// Returns number of bytes read on success or a negative number on error.
+i2c_status_t usb7206_read_reg_32(struct USB7206* self, uint32_t addr, uint32_t* data) {
+    i2c_status_t status;
+
+    // First byte is available length
+    uint8_t bytes[4] = {0, 0, 0, 0};
+
+    status = usb7206_read_reg(self, addr, bytes, sizeof(bytes));
+    if (status < 0) {
+        return status;
+    }
+
+    // Convert from little endian
+    *data = (((uint32_t)bytes[0]) << 0) | (((uint32_t)bytes[1]) << 8) | (((uint32_t)bytes[2]) << 16) | (((uint32_t)bytes[3]) << 24);
+
+    return status;
+}
+
+// Write data to USB7206 register region.
+// Returns number of bytes written on success or a negative number on error.
+i2c_status_t usb7206_write_reg(struct USB7206* self, uint32_t addr, uint8_t* data, int length) {
+    i2c_status_t status;
+
+    uint8_t register_write[9] = {
+        0x00,                   // Buffer address MSB: always 0
+        0x00,                   // Buffer address LSB: always 0
+        ((uint8_t)length) + 6,  // Number of bytes to write to command block buffer area
+        0x00,                   // Direction: 0 = write, 1 = read
+        (uint8_t)length,        // Number of bytes to write to register
+        (uint8_t)(addr >> 24),  // Register address byte 3
+        (uint8_t)(addr >> 16),  // Register address byte 2
+        (uint8_t)(addr >> 8),   // Register address byte 1
+        (uint8_t)(addr >> 0),   // Register address byte 0
+    };
+
+    status = i2c_start((self->addr << 1) | I2C_WRITE, I2C_TIMEOUT);
+    if (status >= 0) {
+        for (uint16_t i = 0; i < sizeof(register_write); i++) {
+            status = i2c_write(register_write[i], I2C_TIMEOUT);
+            if (status < 0) {
+                goto error;
+            }
+        }
+
+        for (uint16_t i = 0; i < length; i++) {
+            status = i2c_write(data[i], I2C_TIMEOUT);
+            if (status < 0) {
+                goto error;
+            }
+        }
+    } else {
+        goto error;
+    }
+
+    i2c_stop();
+
+    status = usb7206_register_access(self);
+    if (status < 0) {
+        goto error;
+    }
+
+error:
+    i2c_stop();
+
+    return (status < 0) ? status : length;
+}
+
+// Write 8-bit value to USB7206 register region.
+// Returns number of bytes written on success or a negative number on error.
+i2c_status_t usb7206_write_reg_8(struct USB7206* self, uint32_t addr, uint8_t data) { return usb7206_write_reg(self, addr, &data, sizeof(data)); }
+
+// Write 32-bit value to USB7206 register region.
+// Returns number of bytes written on success or a negative number on error.
+i2c_status_t usb7206_write_reg_32(struct USB7206* self, uint32_t addr, uint32_t data) {
+    // Convert to little endian
+    uint8_t bytes[4] = {
+        (uint8_t)(data >> 0),
+        (uint8_t)(data >> 8),
+        (uint8_t)(data >> 16),
+        (uint8_t)(data >> 24),
+    };
+
+    return usb7206_write_reg(self, addr, bytes, sizeof(bytes));
+}
+
+// Initialize USB7206.
+// Returns zero on success or a negative number on error.
+int usb7206_init(struct USB7206* self) {
+    i2c_status_t status;
+    uint32_t     data;
+
+    // DM and DP are swapped on ports 2 and 3
+    status = usb7206_write_reg_8(self, REG_PRT_SWAP, 0x0C);
+    if (status < 0) {
+        return status;
+    }
+
+    // Disable audio
+    status = usb7206_write_reg_8(self, REG_I2S_FEAT_SEL, 0);
+    if (status < 0) {
+        return status;
+    }
+
+    // Set HFC_DISABLE
+    data   = 0;
+    status = usb7206_read_reg_32(self, REG_RUNTIME_FLAGS2, &data);
+    if (status < 0) {
+        return status;
+    }
+    data |= 1;
+    status = usb7206_write_reg_32(self, REG_RUNTIME_FLAGS2, data);
+    if (status < 0) {
+        return status;
+    }
+
+    // Set Vendor ID and Product ID of USB 2 hub
+    status = usb7206_write_reg_32(self, REG_VID, 0x00033384);
+    if (status < 0) {
+        return status;
+    }
+
+    // Set Vendor ID and Product ID of USB 3 hub
+    status = usb7206_write_reg_32(self, REG_USB3_HUB_VID, 0x00043384);
+    if (status < 0) {
+        return status;
+    }
+
+    return 0;
+}
+
+// Attach USB7206.
+// Returns bytes written on success or a negative number on error.
+i2c_status_t usb7206_attach(struct USB7206* self) {
+    uint8_t data[3] = {
+        0xAA,
+        0x56,
+        0x00,
+    };
+
+    return i2c_transmit(self->addr << 1, data, sizeof(data), I2C_TIMEOUT);
+}
+
+struct USB7206_GPIO {
+    struct USB7206* usb7206;
+    uint32_t        pf;
+};
+
+struct USB7206_GPIO usb_gpio_sink         = {.usb7206 = &usb_hub, .pf = 29};  // UP_SEL = PF29 = GPIO93
+struct USB7206_GPIO usb_gpio_source_left  = {.usb7206 = &usb_hub, .pf = 10};  // CL_SEL = PF10 = GPIO74
+struct USB7206_GPIO usb_gpio_source_right = {.usb7206 = &usb_hub, .pf = 25};  // CR_SEL = PF25 = GPIO88
+
+// Set USB7206 GPIO to specified value.
+// Returns zero on success or negative number on error.
+i2c_status_t usb7206_gpio_set(struct USB7206_GPIO* self, bool value) {
+    i2c_status_t status;
+    uint32_t     data;
+
+    data   = 0;
+    status = usb7206_read_reg_32(self->usb7206, REG_PIO64_OUT, &data);
+    if (status < 0) {
+        return status;
+    }
+
+    if (value) {
+        data |= (((uint32_t)1) << self->pf);
+    } else {
+        data &= ~(((uint32_t)1) << self->pf);
+    }
+    status = usb7206_write_reg_32(self->usb7206, REG_PIO64_OUT, data);
+    if (status < 0) {
+        return status;
+    }
+
+    return 0;
+}
+
+// Initialize USB7206 GPIO.
+// Returns zero on success or a negative number on error.
+i2c_status_t usb7206_gpio_init(struct USB7206_GPIO* self) {
+    i2c_status_t status;
+    uint32_t     data;
+
+    // Set programmable function to GPIO
+    status = usb7206_write_reg_8(self->usb7206, REG_PF1_CTL + (self->pf - 1), 0);
+    if (status < 0) {
+        return status;
+    }
+
+    // Set GPIO to false by default
+    usb7206_gpio_set(self, false);
+
+    // Set GPIO to output
+    data   = 0;
+    status = usb7206_read_reg_32(self->usb7206, REG_PIO64_OEN, &data);
+    if (status < 0) {
+        return status;
+    }
+
+    data |= (((uint32_t)1) << self->pf);
+    status = usb7206_write_reg_32(self->usb7206, REG_PIO64_OEN, data);
+    if (status < 0) {
+        return status;
+    }
+
+    return 0;
+}
+
+struct PTN5110 {
+    uint8_t              addr;
+    uint8_t              cc;
+    struct USB7206_GPIO* gpio;
+};
+
+struct PTN5110 usb_sink         = {.addr = 0x51, .gpio = &usb_gpio_sink};
+struct PTN5110 usb_source_left  = {.addr = 0x52, .gpio = &usb_gpio_source_left};
+struct PTN5110 usb_source_right = {.addr = 0x50, .gpio = &usb_gpio_source_right};
+
+// Initialize PTN5110.
+// Returns zero on success or a negative number on error.
+i2c_status_t ptn5110_init(struct PTN5110* self) {
+    // Set last cc to invalid value, to force update
+    self->cc = 0xFF;
+    // Initialize GPIO
+    return usb7206_gpio_init(self->gpio);
+}
+
+// Read PTN5110 CC_STATUS.
+// Returns zero on success or a negative number on error.
+i2c_status_t ptn5110_get_cc_status(struct PTN5110* self, uint8_t* cc) { return i2c_readReg(self->addr << 1, 0x1D, cc, 1, I2C_TIMEOUT); }
+
+// Set PTN5110 SSMUX orientation.
+// Returns zero on success or a negative number on error.
+i2c_status_t ptn5110_set_ssmux(struct PTN5110* self, bool orientation) { return usb7206_gpio_set(self->gpio, orientation); }
+
+// Write PTN5110 COMMAND.
+// Returns zero on success or negative number on error.
+i2c_status_t ptn5110_command(struct PTN5110* self, uint8_t command) { return i2c_writeReg(self->addr << 1, 0x23, &command, 1, I2C_TIMEOUT); }
+
+// Set orientation of PTN5110 operating as a sink, call this once.
+// Returns zero on success or a negative number on error.
+i2c_status_t ptn5110_sink_set_orientation(struct PTN5110* self) {
+    i2c_status_t status;
+    uint8_t      cc;
+
+    status = ptn5110_get_cc_status(self, &cc);
+    if (status < 0) {
+        return status;
+    }
+
+    if ((cc & 0x03) == 0) {
+        status = ptn5110_set_ssmux(self, false);
+        if (status < 0) {
+            return status;
+        }
+    } else {
+        status = ptn5110_set_ssmux(self, true);
+        if (status < 0) {
+            return status;
+        }
+    }
+
+    return 0;
+}
+
+// Update PTN5110 operating as a source, call this repeatedly.
+// Returns zero on success or a negative number on error.
+i2c_status_t ptn5110_source_update(struct PTN5110* self) {
+    i2c_status_t status;
+    uint8_t      cc;
+
+    status = ptn5110_get_cc_status(self, &cc);
+    if (status < 0) {
+        return status;
+    }
+
+    if (cc != self->cc) {
+        // WARNING: Setting this here will disable retries
+        self->cc = cc;
+
+        bool connected   = false;
+        bool orientation = false;
+        if ((cc & 0x03) == 2) {
+            connected   = true;
+            orientation = true;
+        } else if (((cc >> 2) & 0x03) == 2) {
+            connected   = true;
+            orientation = false;
+        }
+
+        if (connected) {
+            // Set SS mux orientation
+            status = ptn5110_set_ssmux(self, orientation);
+            if (status < 0) {
+                return status;
+            }
+
+            // Enable source Vbus command
+            status = ptn5110_command(self, 0b01110111);
+            if (status < 0) {
+                return status;
+            }
+        } else {
+            // Disable source Vbus command
+            status = ptn5110_command(self, 0b01100110);
+            if (status < 0) {
+                return status;
+            }
+        }
+    }
+
+    return 0;
+}
+
+void usb_mux_event(void) {
+    // Run this on every 1000th matrix scan
+    static int cycle = 0;
+    if (cycle >= 1000) {
+        cycle = 0;
+        ptn5110_source_update(&usb_source_left);
+        ptn5110_source_update(&usb_source_right);
+    } else {
+        cycle += 1;
+    }
+}
+
+void usb_mux_init(void) {
+    // Run I2C bus at 100 kHz
+    i2c_init();
+
+    // Set up hub
+    usb7206_init(&usb_hub);
+
+    // Set up sink
+    ptn5110_init(&usb_sink);
+    ptn5110_sink_set_orientation(&usb_sink);
+
+    // Set up sources
+    ptn5110_init(&usb_source_left);
+    ptn5110_init(&usb_source_right);
+
+    // Attach hub
+    usb7206_attach(&usb_hub);
+
+    // Ensure orientation is correct after attaching hub
+    // TODO: Find reason why GPIO for sink orientation is reset
+    for (int i = 0; i < 100; i++) {
+        ptn5110_sink_set_orientation(&usb_sink);
+        wait_ms(10);
+    }
+}

keyboards/system76/launch_1/usb_mux.h

@@ -0,0 +1,21 @@
+/*
+ *  Copyright (C) 2021  System76
+ *
+ *  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/>.
+ */
+
+#pragma once
+
+void usb_mux_init(void);
+void usb_mux_event(void);

keyboards/system76/layouts.sh

@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+#
+# This script produces layout data for the System76 Keyboard Configurator.
+#
+# Copyright (C) 2021  System76
+#
+# 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, version 3.
+#
+# 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/>.
+
+set -eEuo pipefail
+
+R=$(git rev-parse --show-toplevel)
+cd "${R}"
+rm -rf .build/layouts
+mkdir -p .build/layouts
+D="$(realpath .build/layouts)"
+
+binary="${D}/keymap"
+source="${binary}.c"
+header="quantum/keycode.h"
+printf "#include <stdio.h>\n" >"$source"
+printf "#include \"%s\"\n\n" "${header}" >>"$source"
+echo "int main(int argc, char **argv) {" >>"$source"
+grep '^    KC_' "$header" |
+  cut -d ' ' -f5 |
+  cut -d ',' -f1 |
+  while read -r keycode; do
+    name=$(echo "${keycode}" | cut -d '_' -f2-)
+    printf "    printf(\"%s,0x%%04X\\\n\", $keycode);\n" "${name}" >>"$source"
+  done
+printf "\n    return 0;\n}\n" >>"$source"
+gcc -I. "$source" -o "$binary"
+"${binary}" | tee "${D}/keymap.csv"
+
+cd keyboards
+for board in system76/launch_*; do
+  file="$board/$(basename "$board").h"
+  if [ ! -e "$file" ]; then
+    continue
+  fi
+  echo "# ${board}"
+  mkdir -p "${D}/${board}"
+  cp "${D}/keymap.csv" "${D}/${board}"
+  row=0
+  rg \
+    --multiline \
+    --multiline-dotall \
+    --regexp '#define LAYOUT\(.*\) \{.*\}' \
+    "$file" |
+    grep --only-matching '\{.*\}' |
+    sed 's/^{ //' |
+    sed 's/ }$//' |
+    sed 's/, / /g' |
+    while read -r line; do
+      col=0
+      for word in $line; do
+        if [[ "${word}" != "___" ]]; then
+          echo "${word},${row},${col}"
+        fi
+        col=$((col + 1))
+      done
+      row=$((row + 1))
+    done |
+    sort -n |
+    tee "${D}/${board}/layout.csv"
+done

keyboards/system76/readme.md

@@ -0,0 +1,5 @@
+# System76 Keyboards
+
+Keyboards by [System76](https://system76.com/):
+
+- [launch_1](https://system76.com/accessories/launch)

keyboards/system76/system76_ec.c

@@ -0,0 +1,416 @@
+/*
+ *  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();
+    }
+}