diff options
Diffstat (limited to 'users/drashna/drashna_transport.c')
| -rw-r--r-- | users/drashna/drashna_transport.c | 508 |
1 files changed, 508 insertions, 0 deletions
diff --git a/users/drashna/drashna_transport.c b/users/drashna/drashna_transport.c new file mode 100644 index 0000000000..f0908b4900 --- /dev/null +++ b/users/drashna/drashna_transport.c @@ -0,0 +1,508 @@ +/* Copyright 2020 Christopher Courtney, aka Drashna Jael're (@drashna) <drashna@live.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 2 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 <http://www.gnu.org/licenses/>. + */ + +#include <string.h> +#include <stddef.h> + +#include "matrix.h" +#include QMK_KEYBOARD_H + +#define ROWS_PER_HAND (MATRIX_ROWS / 2) + +#ifdef RGBLIGHT_ENABLE +# include "rgblight.h" +#endif + +#ifdef BACKLIGHT_ENABLE +# include "backlight.h" +#endif + +#ifdef ENCODER_ENABLE +# include "encoder.h" +static pin_t encoders_pad[] = ENCODERS_PAD_A; +# define NUMBER_OF_ENCODERS (sizeof(encoders_pad) / sizeof(pin_t)) +#endif + +#ifdef POINTING_DEVICE_ENABLE +static int8_t split_mouse_x = 0, split_mouse_y = 0; +#endif + +#ifdef OLED_DRIVER_ENABLE +# include "oled_driver.h" +#endif + +#if defined(USE_I2C) + +# include "i2c_master.h" +# include "i2c_slave.h" + +typedef struct _I2C_slave_buffer_t { + matrix_row_t smatrix[ROWS_PER_HAND]; +# ifdef SPLIT_MODS_ENABLE + uint8_t real_mods; + uint8_t weak_mods; +# ifndef NO_ACTION_ONESHOT + uint8_t oneshot_mods; +# endif +# endif +# ifdef BACKLIGHT_ENABLE + uint8_t backlight_level; +# endif +# if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT) + rgblight_syncinfo_t rgblight_sync; +# endif +# ifdef ENCODER_ENABLE + uint8_t encoder_state[NUMBER_OF_ENCODERS]; +# endif +# ifdef WPM_ENABLE + uint8_t current_wpm; +# endif + int8_t mouse_x; + int8_t mouse_y; + bool oled_on; + layer_state_t t_layer_state; + layer_state_t t_default_layer_state; + bool is_rgb_matrix_suspended; +} __attribute__((packed)) I2C_slave_buffer_t; + +static I2C_slave_buffer_t *const i2c_buffer = (I2C_slave_buffer_t *)i2c_slave_reg; + +# define I2C_BACKLIGHT_START offsetof(I2C_slave_buffer_t, backlight_level) +# define I2C_RGB_START offsetof(I2C_slave_buffer_t, rgblight_sync) +# define I2C_KEYMAP_START offsetof(I2C_slave_buffer_t, smatrix) +# define I2C_REAL_MODS_START offsetof(I2C_slave_buffer_t, real_mods) +# define I2C_WEAK_MODS_START offsetof(I2C_slave_buffer_t, weak_mods) +# define I2C_ONESHOT_MODS_START offsetof(I2C_slave_buffer_t, oneshot_mods) +# define I2C_ENCODER_START offsetof(I2C_slave_buffer_t, encoder_state) +# define I2C_WPM_START offsetof(I2C_slave_buffer_t, current_wpm) +# define I2C_MOUSE_X_START offsetof(I2C_slave_buffer_t, mouse_x) +# define I2C_MOUSE_Y_START offsetof(I2C_slave_buffer_t, mouse_y) +# define I2C_OLED_ON_START offsetof(I2C_slave_buffer_t, oled_on) +# define I2C_LAYER_STATE_START offsetof(I2C_slave_buffer_t, t_layer_state) +# define I2C_DEFAULT_LAYER_STATE_START offsetof(I2C_slave_buffer_t, t_default_layer_state) +# define I2C_RGB_MATRIX_SUSPEND_START offsetof(I2C_slave_buffer_t, is_rgb_matrix_suspended) + +# define TIMEOUT 100 + +# ifndef SLAVE_I2C_ADDRESS +# define SLAVE_I2C_ADDRESS 0x32 +# endif + +// Get rows from other half over i2c +bool transport_master(matrix_row_t matrix[]) { + i2c_readReg(SLAVE_I2C_ADDRESS, I2C_KEYMAP_START, (void *)matrix, sizeof(i2c_buffer->smatrix), TIMEOUT); + + // write backlight info +# ifdef BACKLIGHT_ENABLE + uint8_t level = is_backlight_enabled() ? get_backlight_level() : 0; + if (level != i2c_buffer->backlight_level) { + if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_BACKLIGHT_START, (void *)&level, sizeof(level), TIMEOUT) >= 0) { + i2c_buffer->backlight_level = level; + } + } +# endif + +# if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT) + if (rgblight_get_change_flags()) { + rgblight_syncinfo_t rgblight_sync; + rgblight_get_syncinfo(&rgblight_sync); + if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_RGB_START, (void *)&rgblight_sync, sizeof(rgblight_sync), TIMEOUT) >= 0) { + rgblight_clear_change_flags(); + } + } +# endif + +# ifdef ENCODER_ENABLE + i2c_readReg(SLAVE_I2C_ADDRESS, I2C_ENCODER_START, (void *)i2c_buffer->encoder_state, sizeof(i2c_buffer->encoder_state), TIMEOUT); + encoder_update_raw(i2c_buffer->encoder_state); +# endif + +# ifdef WPM_ENABLE + uint8_t current_wpm = get_current_wpm(); + if (current_wpm != i2c_buffer->current_wpm) { + if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_WPM_START, (void *)¤t_wpm, sizeof(current_wpm), TIMEOUT) >= 0) { + i2c_buffer->current_wpm = current_wpm; + } + } +# endif + +# ifdef POINTING_DEVICE_ENABLE + if (is_keyboard_left()) { + report_mouse_t temp_report = pointing_device_get_report(); + i2c_readReg(SLAVE_I2C_ADDRESS, I2C_MOUSE_X_START, (void *)&i2c_buffer->mouse_x, sizeof(i2c_buffer->mouse_x), TIMEOUT); + temp_report.x = i2c_buffer->mouse_x; + i2c_readReg(SLAVE_I2C_ADDRESS, I2C_MOUSE_Y_START, (void *)&i2c_buffer->mouse_y, sizeof(i2c_buffer->mouse_y), TIMEOUT); + temp_report.y = i2c_buffer->mouse_y; + pointing_device_set_report(temp_report); + } +# endif + +# ifdef SPLIT_MODS_ENABLE + uint8_t real_mods = get_mods(); + if (real_mods != i2c_buffer->real_mods) { + if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_REAL_MODS_START, (void *)&real_mods, sizeof(real_mods), TIMEOUT) >= 0) { + i2c_buffer->real_mods = real_mods; + } + } + + uint8_t weak_mods = get_weak_mods(); + if (weak_mods != i2c_buffer->weak_mods) { + if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_WEAK_MODS_START, (void *)&weak_mods, sizeof(weak_mods), TIMEOUT) >= 0) { + i2c_buffer->weak_mods = weak_mods; + } + } + +# ifndef NO_ACTION_ONESHOT + uint8_t oneshot_mods = get_oneshot_mods(); + if (oneshot_mods != i2c_buffer->oneshot_mods) { + if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_ONESHOT_MODS_START, (void *)&oneshot_mods, sizeof(oneshot_mods), TIMEOUT) >= 0) { + i2c_buffer->oneshot_mods = oneshot_mods; + } + } +# endif +# endif + + if (layer_state != i2c_buffer->t_layer_state) { + if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_LAYER_STATE_START, (void *)&layer_state, sizeof(layer_state), TIMEOUT) >= 0) { + i2c_buffer->t_layer_state = layer_state; + } + } + + if (default_layer_state != i2c_buffer->t_default_layer_state) { + if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_DEFAULT_LAYER_STATE_START, (void *)&default_layer_state, sizeof(default_layer_state), TIMEOUT) >= 0) { + i2c_buffer->t_default_layer_state = default_layer_state; + } + } + +# ifdef OLED_DRIVER_ENABLE + bool is_oled = is_oled_on(); + if (is_oled != i2c_buffer->oled_on) { + if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_LAYER_STATE_START, (void *)&is_oled, sizeof(is_oled), TIMEOUT) >= 0) { + i2c_buffer->oled_on = is_oled; + } + } +# endif + +# ifdef RGB_MATRIX_ENABLE + bool sus_state = rgb_matrix_get_suspend_state(); + if (sus_state != i2c_buffer->is_rgb_matrix_suspended) { + if (i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_RGB_MATRIX_SUSPEND_START, (void *)&sus_state, sizeof(sus_state), TIMEOUT) >= 0) { + i2c_buffer->is_rgb_matrix_suspended = sus_state; + } + } +# endif + + return true; +} + +void transport_slave(matrix_row_t matrix[]) { + // Copy matrix to I2C buffer + memcpy((void *)i2c_buffer->smatrix, (void *)matrix, sizeof(i2c_buffer->smatrix)); + +// Read Backlight Info +# ifdef BACKLIGHT_ENABLE + backlight_set(i2c_buffer->backlight_level); +# endif + +# if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT) + // Update the RGB with the new data + if (i2c_buffer->rgblight_sync.status.change_flags != 0) { + rgblight_update_sync(&i2c_buffer->rgblight_sync, false); + i2c_buffer->rgblight_sync.status.change_flags = 0; + } +# endif + +# ifdef ENCODER_ENABLE + encoder_state_raw(i2c_buffer->encoder_state); +# endif + +# ifdef WPM_ENABLE + set_current_wpm(i2c_buffer->current_wpm); +# endif + +# ifdef POINTING_DEVICE_ENABLE + if (!is_keyboard_left()) { + i2c_buffer->mouse_x = split_mouse_x; + i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_MOUSE_X_START, (void *)&i2c_buffer->mouse_x, sizeof(i2c_buffer->mouse_x), TIMEOUT); + i2c_buffer->mouse_y = split_mouse_y; + i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_MOUSE_Y_START, (void *)&i2c_buffer->mouse_y, sizeof(i2c_buffer->mouse_y), TIMEOUT); + } + +# endif + +# ifdef SPLIT_MODS_ENABLE + set_mods(i2c_buffer->real_mods); + set_weak_mods(i2c_buffer->weak_mods); +# ifndef NO_ACTION_ONESHOT + set_oneshot_mods(i2c_buffer->oneshot_mods); +# endif +# endif + + if (layer_state != i2c_buffer->t_layer_state) { + layer_state = i2c_buffer->t_layer_state; + } + if (default_layer_state != i2c_buffer->t_default_layer_state) { + default_layer_state = i2c_buffer->t_default_layer_state; + } + +# ifdef OLED_DRIVER_ENABLE + if (i2c_buffer->oled_on) { + oled_on(); + } else { + oled_off(); + } +# endif + +# ifdef RGB_MATRIX_ENABLE + rgb_matrix_set_suspend_state(i2c_buffer->is_rgb_matrix_suspended); +# endif +} + +void transport_master_init(void) { i2c_init(); } + +void transport_slave_init(void) { i2c_slave_init(SLAVE_I2C_ADDRESS); } + +#else // USE_SERIAL + +# include "serial.h" + +typedef struct _Serial_s2m_buffer_t { + // TODO: if MATRIX_COLS > 8 change to uint8_t packed_matrix[] for pack/unpack + matrix_row_t smatrix[ROWS_PER_HAND]; +# ifdef ENCODER_ENABLE + uint8_t encoder_state[NUMBER_OF_ENCODERS]; +# endif + int8_t mouse_x; + int8_t mouse_y; +} __attribute__((packed)) Serial_s2m_buffer_t; + +typedef struct _Serial_m2s_buffer_t { +# ifdef SPLIT_MODS_ENABLE + uint8_t real_mods; + uint8_t weak_mods; +# ifndef NO_ACTION_ONESHOT + uint8_t oneshot_mods; +# endif +# endif +# ifdef BACKLIGHT_ENABLE + uint8_t backlight_level; +# endif +# ifdef WPM_ENABLE + uint8_t current_wpm; +# endif + bool oled_on; + layer_state_t t_layer_state; + layer_state_t t_default_layer_state; + bool is_rgb_matrix_suspended; +} __attribute__((packed)) Serial_m2s_buffer_t; + +# if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT) +// When MCUs on both sides drive their respective RGB LED chains, +// it is necessary to synchronize, so it is necessary to communicate RGB +// information. In that case, define RGBLIGHT_SPLIT with info on the number +// of LEDs on each half. +// +// Otherwise, if the master side MCU drives both sides RGB LED chains, +// there is no need to communicate. + +typedef struct _Serial_rgblight_t { + rgblight_syncinfo_t rgblight_sync; +} Serial_rgblight_t; + +volatile Serial_rgblight_t serial_rgblight = {}; +uint8_t volatile status_rgblight = 0; +# endif + +volatile Serial_s2m_buffer_t serial_s2m_buffer = {}; +volatile Serial_m2s_buffer_t serial_m2s_buffer = {}; +uint8_t volatile status0 = 0; + +enum serial_transaction_id { + GET_SLAVE_MATRIX = 0, +# if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT) + PUT_RGBLIGHT, +# endif +}; + +SSTD_t transactions[] = { + [GET_SLAVE_MATRIX] = + { + (uint8_t *)&status0, + sizeof(serial_m2s_buffer), + (uint8_t *)&serial_m2s_buffer, + sizeof(serial_s2m_buffer), + (uint8_t *)&serial_s2m_buffer, + }, +# if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT) + [PUT_RGBLIGHT] = + { + (uint8_t *)&status_rgblight, sizeof(serial_rgblight), (uint8_t *)&serial_rgblight, 0, NULL // no slave to master transfer + }, +# endif +}; + +void transport_master_init(void) { soft_serial_initiator_init(transactions, TID_LIMIT(transactions)); } + +void transport_slave_init(void) { soft_serial_target_init(transactions, TID_LIMIT(transactions)); } + +# if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT) + +// rgblight synchronization information communication. + +void transport_rgblight_master(void) { + if (rgblight_get_change_flags()) { + rgblight_get_syncinfo((rgblight_syncinfo_t *)&serial_rgblight.rgblight_sync); + if (soft_serial_transaction(PUT_RGBLIGHT) == TRANSACTION_END) { + rgblight_clear_change_flags(); + } + } +} + +void transport_rgblight_slave(void) { + if (status_rgblight == TRANSACTION_ACCEPTED) { + rgblight_update_sync((rgblight_syncinfo_t *)&serial_rgblight.rgblight_sync, false); + status_rgblight = TRANSACTION_END; + } +} + +# else +# define transport_rgblight_master() +# define transport_rgblight_slave() +# endif + +bool transport_master(matrix_row_t matrix[]) { +# ifndef SERIAL_USE_MULTI_TRANSACTION + if (soft_serial_transaction() != TRANSACTION_END) { + return false; + } +# else + transport_rgblight_master(); + if (soft_serial_transaction(GET_SLAVE_MATRIX) != TRANSACTION_END) { + return false; + } +# endif + + // TODO: if MATRIX_COLS > 8 change to unpack() + for (int i = 0; i < ROWS_PER_HAND; ++i) { + matrix[i] = serial_s2m_buffer.smatrix[i]; + } + +# ifdef BACKLIGHT_ENABLE + // Write backlight level for slave to read + serial_m2s_buffer.backlight_level = is_backlight_enabled() ? get_backlight_level() : 0; +# endif + +# ifdef ENCODER_ENABLE + encoder_update_raw((uint8_t *)serial_s2m_buffer.encoder_state); +# endif + +# ifdef WPM_ENABLE + // Write wpm to slave + serial_m2s_buffer.current_wpm = get_current_wpm(); +# endif + +# ifdef SPLIT_MODS_ENABLE + serial_m2s_buffer.real_mods = get_mods(); + serial_m2s_buffer.weak_mods = get_weak_mods(); +# ifndef NO_ACTION_ONESHOT + serial_m2s_buffer.oneshot_mods = get_oneshot_mods(); +# endif +# endif + +# ifdef POINTING_DEVICE_ENABLE + if (is_keyboard_left()) { + report_mouse_t temp_report = pointing_device_get_report(); + temp_report.x = serial_s2m_buffer.mouse_x; + temp_report.y = serial_s2m_buffer.mouse_y; + pointing_device_set_report(temp_report); + } +# endif + + serial_m2s_buffer.t_layer_state = layer_state; + serial_m2s_buffer.t_default_layer_state = default_layer_state; +# ifdef OLED_DRIVER_ENABLE + serial_m2s_buffer.oled_on = is_oled_on(); +# endif + +# ifdef RGB_MATRIX_ENABLE + serial_m2s_buffer.is_rgb_matrix_suspended = rgb_matrix_get_suspend_state(); +# endif + + return true; +} + +void transport_slave(matrix_row_t matrix[]) { + transport_rgblight_slave(); + + // TODO: if MATRIX_COLS > 8 change to pack() + for (int i = 0; i < ROWS_PER_HAND; ++i) { + serial_s2m_buffer.smatrix[i] = matrix[i]; + } + +# ifdef BACKLIGHT_ENABLE + backlight_set(serial_m2s_buffer.backlight_level); +# endif + +# ifdef ENCODER_ENABLE + encoder_state_raw((uint8_t *)serial_s2m_buffer.encoder_state); +# endif + +# ifdef WPM_ENABLE + set_current_wpm(serial_m2s_buffer.current_wpm); +# endif + +# ifdef SPLIT_MODS_ENABLE + set_mods(serial_m2s_buffer.real_mods); + set_weak_mods(serial_m2s_buffer.weak_mods); +# ifndef NO_ACTION_ONESHOT + set_oneshot_mods(serial_m2s_buffer.oneshot_mods); +# endif +# endif + +# ifdef POINTING_DEVICE_ENABLE + if (!is_keyboard_left()) { + serial_s2m_buffer.mouse_x = split_mouse_x; + serial_s2m_buffer.mouse_y = split_mouse_y; + } +# endif + + if (layer_state != serial_m2s_buffer.t_layer_state) { + layer_state = serial_m2s_buffer.t_layer_state; + } + if (default_layer_state != serial_m2s_buffer.t_default_layer_state) { + default_layer_state = serial_m2s_buffer.t_default_layer_state; + } +# ifdef OLED_DRIVER_ENABLE + if (serial_m2s_buffer.oled_on) { + oled_on(); + } else { + oled_off(); + } +# endif + +# ifdef RGB_MATRIX_ENABLE + rgb_matrix_set_suspend_state(serial_m2s_buffer.is_rgb_matrix_suspended); +# endif +} + +#endif + +#ifdef POINTING_DEVICE_ENABLE +void master_mouse_send(int8_t x, int8_t y) { + split_mouse_x = x; + split_mouse_y = y; +} +#endif |