Bump firmware version to 8.2.5, update changelog, package.json, and versions.h

CHANGELOG.md

@@ -5,6 +5,21 @@ All notable changes to this project will be documented in this file.
 The format is loosely based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to the [UHK Versioning](VERSIONING.md) conventions.
 
+## [8.2.5] - 2018-05-27
+
+Device Protocol: 4.3.1 | Module Protocol: 4.0.0 | User Config: 4.0.1 | Hardware Config: 1.0.0
+
+- Now really fix the bug that made the hardware and user configuration not load from the EEPROM on some hosts right after firmware update.
+
+## [8.2.4] - 2018-05-21
+
+Device Protocol: 4.3.**1** | Module Protocol: 4.0.0 | User Config: 4.0.1 | Hardware Config: 1.0.0
+
+- Fix the bug that made the hardware and user configuration not load from the EEPROM on some hosts right after firmware update.
+- Set the signature of the hardware config to "FTY" in the RAM when the keyboard is in factory reset mode, allowing Agent to be aware of the factory reset state. `DEVICEPROTOCOL:PATCH`
+- Load the hardware and user configuration from the EEPROM even in factory reset mode.
+- Set key debounce timeout from 60ms to 80ms. This should further reduce key chattering.
+
 ## [8.2.3] - 2018-05-15
 
 Device Protocol: 4.3.0 | Module Protocol: 4.0.0 | User Config: 4.0.1 | Hardware Config: 1.0.0

right/src/config_parser/config_globals.c

@@ -11,6 +11,8 @@ config_buffer_t HardwareConfigBuffer = { hardwareConfig };
 config_buffer_t StagingUserConfigBuffer = { stagingUserConfig };
 config_buffer_t ValidatedUserConfigBuffer = { validatedUserConfig };
 
+hardware_config_t *HardwareConfig = (hardware_config_t*)hardwareConfig;
+
 bool ParserRunDry;
 
 bool IsConfigBufferIdValid(config_buffer_id_t configBufferId)

right/src/config_parser/config_globals.h

@@ -6,6 +6,10 @@
     #include "fsl_common.h"
     #include "basic_types.h"
 
+// Macros:
+
+    #define HARDWARE_CONFIG_SIGNATURE_LENGTH 3
+
 // Typedefs:
 
     typedef enum {
@@ -14,6 +18,19 @@
         ConfigBufferId_ValidatedUserConfig,
     } config_buffer_id_t;
 
+    typedef struct {
+        uint8_t signatureLength;
+        char signature[HARDWARE_CONFIG_SIGNATURE_LENGTH];
+        uint8_t majorVersion;
+        uint8_t minorVersion;
+        uint8_t patchVersion;
+        uint8_t brandId;
+        uint8_t deviceId;
+        uint32_t uniqueId;
+        bool isVendorModeOn;
+        bool isIso;
+    } hardware_config_t;
+
 // Variables:
 
     extern bool ParserRunDry;
@@ -21,8 +38,9 @@
     extern config_buffer_t HardwareConfigBuffer;
     extern config_buffer_t StagingUserConfigBuffer;
     extern config_buffer_t ValidatedUserConfigBuffer;
+    extern hardware_config_t *HardwareConfig;
 
-    // Functions:
+// Functions:
 
     bool IsConfigBufferIdValid(config_buffer_id_t configBufferId);
     config_buffer_t* ConfigBufferIdToConfigBuffer(config_buffer_id_t configBufferId);

right/src/i2c.h

@@ -35,10 +35,12 @@
     #define I2C_EEPROM_BUS_BAUD_RATE 1000000  // 1 Mhz is the maximum speed of the EEPROM.
     #define I2C_EEPROM_BUS_MUX       kPORT_MuxAlt2
 
+    #define I2C_EEPROM_BUS_SDA_GPIO  GPIOC
     #define I2C_EEPROM_BUS_SDA_PORT  PORTC
     #define I2C_EEPROM_BUS_SDA_CLOCK kCLOCK_PortC
     #define I2C_EEPROM_BUS_SDA_PIN   11
 
+    #define I2C_EEPROM_BUS_SCL_GPIO  GPIOC
     #define I2C_EEPROM_BUS_SCL_PORT  PORTC
     #define I2C_EEPROM_BUS_SCL_CLOCK kCLOCK_PortC
     #define I2C_EEPROM_BUS_SCL_PIN   10

right/src/init_peripherals.c

@@ -21,6 +21,38 @@ bool IsBusPalOn;
 volatile uint32_t I2cMainBusRequestedBaudRateBps = I2C_MAIN_BUS_NORMAL_BAUD_RATE;
 volatile uint32_t I2cMainBusActualBaudRateBps;
 
+static i2c_bus_t i2cMainBus = {
+    .baseAddr = I2C_MAIN_BUS_BASEADDR,
+    .clockSrc = I2C_MAIN_BUS_CLK_SRC,
+    .mux = I2C_MAIN_BUS_MUX,
+
+    .sdaClock = I2C_MAIN_BUS_SDA_CLOCK,
+    .sdaGpio = I2C_MAIN_BUS_SDA_GPIO,
+    .sdaPort = I2C_MAIN_BUS_SDA_PORT,
+    .sdaPin = I2C_MAIN_BUS_SDA_PIN,
+
+    .sclClock = I2C_MAIN_BUS_SCL_CLOCK,
+    .sclGpio = I2C_MAIN_BUS_SCL_GPIO,
+    .sclPort = I2C_MAIN_BUS_SCL_PORT,
+    .sclPin = I2C_MAIN_BUS_SCL_PIN,
+};
+
+static i2c_bus_t i2cEepromBus = {
+    .baseAddr = I2C_EEPROM_BUS_BASEADDR,
+    .clockSrc = I2C_EEPROM_BUS_CLK_SRC,
+    .mux = I2C_EEPROM_BUS_MUX,
+
+    .sdaClock = I2C_EEPROM_BUS_SDA_CLOCK,
+    .sdaGpio = I2C_EEPROM_BUS_SDA_GPIO,
+    .sdaPort = I2C_EEPROM_BUS_SDA_PORT,
+    .sdaPin = I2C_EEPROM_BUS_SDA_PIN,
+
+    .sclClock = I2C_EEPROM_BUS_SCL_CLOCK,
+    .sclGpio = I2C_EEPROM_BUS_SCL_GPIO,
+    .sclPort = I2C_EEPROM_BUS_SCL_PORT,
+    .sclPin = I2C_EEPROM_BUS_SCL_PIN,
+};
+
 static void initBusPalState(void) {
     IsBusPalOn = Wormhole.magicNumber == WORMHOLE_MAGIC_NUMBER && Wormhole.enumerationMode == EnumerationMode_BusPal;
     if (IsBusPalOn) {
@@ -32,12 +64,12 @@ static void initBusPalState(void) {
 static void initInterruptPriorities(void)
 {
     NVIC_SetPriority(PIT_I2C_WATCHDOG_IRQ_ID,  1);
-    NVIC_SetPriority(PIT_TIMER_IRQ_ID,         2);
-    NVIC_SetPriority(PIT_KEY_SCANNER_IRQ_ID,   3);
-    NVIC_SetPriority(PIT_KEY_DEBOUNCER_IRQ_ID, 3);
-    NVIC_SetPriority(I2C_MAIN_BUS_IRQ_ID,      3);
-    NVIC_SetPriority(I2C_EEPROM_BUS_IRQ_ID,    3);
-    NVIC_SetPriority(USB_IRQ_ID,               3);
+    NVIC_SetPriority(I2C_EEPROM_BUS_IRQ_ID,    0);
+    NVIC_SetPriority(PIT_TIMER_IRQ_ID,         3);
+    NVIC_SetPriority(PIT_KEY_SCANNER_IRQ_ID,   4);
+    NVIC_SetPriority(PIT_KEY_DEBOUNCER_IRQ_ID, 4);
+    NVIC_SetPriority(I2C_MAIN_BUS_IRQ_ID,      4);
+    NVIC_SetPriority(USB_IRQ_ID,               4);
 }
 
 static void delay(void)
@@ -45,91 +77,73 @@ static void delay(void)
     for (volatile uint32_t i=0; i<62; i++);
 }
 
-static void recoverI2c(void)
+static void recoverI2cBus(i2c_bus_t *i2cBus)
 {
-    PORT_SetPinMux(I2C_MAIN_BUS_SDA_PORT, I2C_MAIN_BUS_SDA_PIN, kPORT_MuxAsGpio);
-    PORT_SetPinMux(I2C_MAIN_BUS_SCL_PORT, I2C_MAIN_BUS_SCL_PIN, kPORT_MuxAsGpio);
-    GPIO_PinInit(I2C_MAIN_BUS_SCL_GPIO, I2C_MAIN_BUS_SCL_PIN, &(gpio_pin_config_t){kGPIO_DigitalOutput, 1});
+    PORT_SetPinMux(i2cBus->sdaPort, i2cBus->sdaPin, kPORT_MuxAsGpio);
+    PORT_SetPinMux(i2cBus->sclPort, i2cBus->sclPin, kPORT_MuxAsGpio);
+    GPIO_PinInit(i2cBus->sclGpio, i2cBus->sclPin, &(gpio_pin_config_t){kGPIO_DigitalOutput, 1});
 
     bool isOn = true;
     for (int i=0; i<20; i++) {
-        GPIO_PinInit(I2C_MAIN_BUS_SDA_GPIO, I2C_MAIN_BUS_SDA_PIN, &(gpio_pin_config_t){kGPIO_DigitalInput});
-        bool isSdaHigh = GPIO_ReadPinInput(I2C_MAIN_BUS_SDA_GPIO, I2C_MAIN_BUS_SDA_PIN);
-        GPIO_PinInit(I2C_MAIN_BUS_SDA_GPIO, I2C_MAIN_BUS_SDA_PIN, &(gpio_pin_config_t){kGPIO_DigitalOutput, 1});
+        GPIO_PinInit(i2cBus->sdaGpio, i2cBus->sdaPin, &(gpio_pin_config_t){kGPIO_DigitalInput});
+        bool isSdaHigh = GPIO_ReadPinInput(i2cBus->sdaGpio, i2cBus->sdaPin);
+        GPIO_PinInit(i2cBus->sdaGpio, i2cBus->sdaPin, &(gpio_pin_config_t){kGPIO_DigitalOutput, 1});
 
         if (isSdaHigh) {
             return;
         }
 
-        GPIO_WritePinOutput(I2C_MAIN_BUS_SCL_GPIO, I2C_MAIN_BUS_SCL_PIN, isOn);
+        GPIO_WritePinOutput(i2cBus->sclGpio, i2cBus->sclPin, isOn);
         delay();
         isOn = !isOn;
     }
 
-    GPIO_WritePinOutput(I2C_MAIN_BUS_SDA_GPIO, I2C_MAIN_BUS_SDA_PIN, 0);
+    GPIO_WritePinOutput(i2cBus->sdaGpio, i2cBus->sdaPin, 0);
     delay();
-    GPIO_WritePinOutput(I2C_MAIN_BUS_SCL_GPIO, I2C_MAIN_BUS_SCL_PIN, 1);
+    GPIO_WritePinOutput(i2cBus->sclGpio, i2cBus->sclPin, 1);
     delay();
-    GPIO_WritePinOutput(I2C_MAIN_BUS_SDA_GPIO, I2C_MAIN_BUS_SDA_PIN, 1);
+    GPIO_WritePinOutput(i2cBus->sdaGpio, i2cBus->sdaPin, 1);
     delay();
 }
 
-static void initI2cMainBus(void)
+static void initI2cBus(i2c_bus_t *i2cBus)
 {
-    CLOCK_EnableClock(I2C_MAIN_BUS_SDA_CLOCK);
-    CLOCK_EnableClock(I2C_MAIN_BUS_SCL_CLOCK);
+    CLOCK_EnableClock(i2cBus->sdaClock);
+    CLOCK_EnableClock(i2cBus->sclClock);
 
-    recoverI2c();
+    recoverI2cBus(i2cBus);
 
     port_pin_config_t pinConfig = {
         .pullSelect = kPORT_PullUp,
         .openDrainEnable = kPORT_OpenDrainEnable,
-        .mux = I2C_MAIN_BUS_MUX,
+        .mux = i2cBus->mux,
     };
 
-    PORT_SetPinConfig(I2C_MAIN_BUS_SDA_PORT, I2C_MAIN_BUS_SDA_PIN, &pinConfig);
-    PORT_SetPinConfig(I2C_MAIN_BUS_SCL_PORT, I2C_MAIN_BUS_SCL_PIN, &pinConfig);
+    PORT_SetPinConfig(i2cBus->sdaPort, i2cBus->sdaPin, &pinConfig);
+    PORT_SetPinConfig(i2cBus->sclPort, i2cBus->sclPin, &pinConfig);
 
     i2c_master_config_t masterConfig;
     I2C_MasterGetDefaultConfig(&masterConfig);
-    masterConfig.baudRate_Bps = I2cMainBusRequestedBaudRateBps;
-    uint32_t sourceClock = CLOCK_GetFreq(I2C_MAIN_BUS_CLK_SRC);
-    I2C_MasterInit(I2C_MAIN_BUS_BASEADDR, &masterConfig, sourceClock);
-    I2cMainBusActualBaudRateBps = I2C_ActualBaudRate;
+    masterConfig.baudRate_Bps = i2cBus == &i2cMainBus ? I2cMainBusRequestedBaudRateBps : I2C_EEPROM_BUS_BAUD_RATE;
+    uint32_t sourceClock = CLOCK_GetFreq(i2cBus->clockSrc);
+    I2C_MasterInit(i2cBus->baseAddr, &masterConfig, sourceClock);
+
+    if (i2cBus == &i2cMainBus) {
+        I2cMainBusActualBaudRateBps = I2C_ActualBaudRate;
+    }
 }
 
 void ReinitI2cMainBus(void)
 {
     I2C_MasterDeinit(I2C_MAIN_BUS_BASEADDR);
-    initI2cMainBus();
+    initI2cBus(&i2cMainBus);
     InitSlaveScheduler();
 }
 
-static void initI2cEepromBus(void)
-{
-    port_pin_config_t pinConfig = {
-       .pullSelect = kPORT_PullUp,
-       .openDrainEnable = kPORT_OpenDrainEnable,
-       .mux = I2C_EEPROM_BUS_MUX,
-   };
-
-   CLOCK_EnableClock(I2C_EEPROM_BUS_SDA_CLOCK);
-   CLOCK_EnableClock(I2C_EEPROM_BUS_SCL_CLOCK);
-
-   PORT_SetPinConfig(I2C_EEPROM_BUS_SDA_PORT, I2C_EEPROM_BUS_SDA_PIN, &pinConfig);
-   PORT_SetPinConfig(I2C_EEPROM_BUS_SCL_PORT, I2C_EEPROM_BUS_SCL_PIN, &pinConfig);
-
-   i2c_master_config_t masterConfig;
-   I2C_MasterGetDefaultConfig(&masterConfig);
-   masterConfig.baudRate_Bps = I2C_EEPROM_BUS_BAUD_RATE;
-   uint32_t sourceClock = CLOCK_GetFreq(I2C_EEPROM_BUS_CLK_SRC);
-   I2C_MasterInit(I2C_EEPROM_BUS_BASEADDR, &masterConfig, sourceClock);
-}
-
 static void initI2c(void)
 {
-    initI2cMainBus();
-    initI2cEepromBus();
+    initI2cBus(&i2cMainBus);
+    initI2cBus(&i2cEepromBus);
 }
 
 void InitPeripherals(void)

right/src/init_peripherals.h

@@ -1,10 +1,28 @@
 #ifndef __INIT_PERIPHERALS_H__
 #define __INIT_PERIPHERALS_H__
 
-// Includes
+// Includes:
 
     #include "fsl_common.h"
 
+// Typedefs:
+
+    typedef struct {
+        clock_name_t clockSrc;
+        I2C_Type *baseAddr;
+        uint16_t mux;
+
+        clock_ip_name_t sdaClock;
+        GPIO_Type *sdaGpio;
+        PORT_Type *sdaPort;
+        uint32_t sdaPin;
+
+        clock_ip_name_t sclClock;
+        GPIO_Type *sclGpio;
+        PORT_Type *sclPort;
+        uint32_t sclPin;
+    } i2c_bus_t;
+
 // Variables:
 
     extern bool IsBusPalOn;

right/src/key_debouncer.h

@@ -9,7 +9,7 @@
 // Macros:
 
     #define KEY_DEBOUNCER_INTERVAL_MSEC 1
-    #define KEY_DEBOUNCER_TIMEOUT_MSEC 60
+    #define KEY_DEBOUNCER_TIMEOUT_MSEC 80
 
 // Functions:
 

right/src/led_display.c

@@ -6,6 +6,7 @@
 uint8_t IconsAndLayerTextsBrightness = 0xff;
 uint8_t AlphanumericSegmentsBrightness = 0xff;
 bool ledIconStates[LedDisplayIcon_Last];
+char LedDisplay_DebugString[] = "   ";
 
 static const uint16_t capitalLetterToSegmentMap[] = {
     0b0000000011110111,
@@ -116,8 +117,12 @@ void LedDisplay_UpdateIcons(void)
 
 void LedDisplay_UpdateText(void)
 {
+#if LED_DISPLAY_DEBUG_MODE == 0
     keymap_reference_t *currentKeymap = AllKeymaps + CurrentKeymapIndex;
     LedDisplay_SetText(currentKeymap->abbreviationLen, currentKeymap->abbreviation);
+#else
+    LedDisplay_SetText(strlen(LedDisplay_DebugString), LedDisplay_DebugString);
+#endif
 }
 
 void LedDisplay_UpdateAll(void)

right/src/led_display.h

@@ -7,6 +7,10 @@
     #include <stdbool.h>
     #include "layer.h"
 
+// Macros:
+
+    #define LED_DISPLAY_DEBUG_MODE 0
+
 // Typedefs:
 
     typedef enum {
@@ -20,6 +24,7 @@
 
     extern uint8_t IconsAndLayerTextsBrightness;
     extern uint8_t AlphanumericSegmentsBrightness;
+    extern char LedDisplay_DebugString[];
 
 // Functions:
 

right/src/main.c

@@ -9,6 +9,7 @@
 #include "key_scanner.h"
 #include "usb_commands/usb_command_apply_config.h"
 #include "peripherals/reset_button.h"
+#include "config_parser/config_globals.h"
 #include "usb_report_updater.h"
 
 static bool IsEepromInitialized = false;
@@ -21,6 +22,10 @@ static void userConfigurationReadFinished(void)
 
 static void hardwareConfigurationReadFinished(void)
 {
+    if (IsFactoryResetModeEnabled) {
+        HardwareConfig->signatureLength = HARDWARE_CONFIG_SIGNATURE_LENGTH;
+        strncpy(HardwareConfig->signature, "FTY", HARDWARE_CONFIG_SIGNATURE_LENGTH);
+    }
     EEPROM_LaunchTransfer(EepromOperation_Read, ConfigBufferId_StagingUserConfig, userConfigurationReadFinished);
 }
 
@@ -29,9 +34,9 @@ int main(void)
     InitClock();
     InitPeripherals();
 
-    if (!RESET_BUTTON_IS_PRESSED) {
-        EEPROM_LaunchTransfer(EepromOperation_Read, ConfigBufferId_HardwareConfig, hardwareConfigurationReadFinished);
-    }
+    IsFactoryResetModeEnabled = RESET_BUTTON_IS_PRESSED;
+
+    EEPROM_LaunchTransfer(EepromOperation_Read, ConfigBufferId_HardwareConfig, hardwareConfigurationReadFinished);
 
     if (IsBusPalOn) {
         init_hardware();

right/src/peripherals/reset_button.c

@@ -2,6 +2,8 @@
 #include "fsl_port.h"
 #include "bootloader/wormhole.h"
 
+bool IsFactoryResetModeEnabled = false;
+
 void RESET_BUTTON_IRQ_HANDLER(void)
 {
     Wormhole.magicNumber = WORMHOLE_MAGIC_NUMBER;

right/src/peripherals/reset_button.h

@@ -16,6 +16,10 @@
 
     #define RESET_BUTTON_IS_PRESSED !GPIO_ReadPinInput(RESET_BUTTON_GPIO, RESET_BUTTON_PIN)
 
+// Variables:
+
+    extern bool IsFactoryResetModeEnabled;
+
 // Functions:
 
     void InitResetButton(void);

right/src/usb_commands/usb_command_apply_config.c

@@ -1,6 +1,7 @@
 #include "usb_commands/usb_command_apply_config.h"
 #include "config_parser/config_globals.h"
 #include "config_parser/parse_config.h"
+#include "peripherals/reset_button.h"
 #include "usb_protocol_handler.h"
 #include "keymap.h"
 
@@ -35,6 +36,10 @@ void UsbCommand_ApplyConfig(void)
     ValidatedUserConfigBuffer.buffer = StagingUserConfigBuffer.buffer;
     StagingUserConfigBuffer.buffer = temp;
 
+    if (IsFactoryResetModeEnabled) {
+        return;
+    }
+
     ParserRunDry = false;
     ValidatedUserConfigBuffer.offset = 0;
     parseConfigStatus = ParseConfig(&ValidatedUserConfigBuffer);

scripts/package.json

@@ -15,10 +15,10 @@
     "commander": "^2.11.0",
     "shelljs": "^0.7.8"
   },
-  "firmwareVersion": "8.2.3",
-  "deviceProtocolVersion": "4.3.0",
+  "firmwareVersion": "8.2.5",
+  "deviceProtocolVersion": "4.3.1",
   "moduleProtocolVersion": "4.0.0",
-  "userConfigVersion": "4.0.0",
+  "userConfigVersion": "4.0.1",
   "hardwareConfigVersion": "1.0.0",
   "devices": [
     {

shared/versions.h

@@ -20,11 +20,11 @@
 
     #define FIRMWARE_MAJOR_VERSION 8
     #define FIRMWARE_MINOR_VERSION 2
-    #define FIRMWARE_PATCH_VERSION 3
+    #define FIRMWARE_PATCH_VERSION 5
 
     #define DEVICE_PROTOCOL_MAJOR_VERSION 4
     #define DEVICE_PROTOCOL_MINOR_VERSION 3
-    #define DEVICE_PROTOCOL_PATCH_VERSION 0
+    #define DEVICE_PROTOCOL_PATCH_VERSION 1
 
     #define MODULE_PROTOCOL_MAJOR_VERSION 4
     #define MODULE_PROTOCOL_MINOR_VERSION 0
@@ -32,7 +32,7 @@
 
     #define USER_CONFIG_MAJOR_VERSION 4
     #define USER_CONFIG_MINOR_VERSION 0
-    #define USER_CONFIG_PATCH_VERSION 0
+    #define USER_CONFIG_PATCH_VERSION 1
 
     #define HARDWARE_CONFIG_MAJOR_VERSION 1
     #define HARDWARE_CONFIG_MINOR_VERSION 0