keyboards/ai03/orbit/transport.c

   1
   2 #include "transport.h"
   3
   4 #include "config.h"
   5 #include "matrix.h"
   6 #include "quantum.h"
   7
   8 #include "orbit.h"
   9
  10 #define ROWS_PER_HAND (MATRIX_ROWS/2)
  11
  12 #ifdef RGBLIGHT_ENABLE
  13 #   include "rgblight.h"
  14 #endif
  15
  16 #ifdef BACKLIGHT_ENABLE
  17 # include "backlight.h"
  18   extern backlight_config_t backlight_config;
  19 #endif
  20
  21 #if defined(USE_I2C) || defined(EH)
  22
  23 #include "i2c.h"
  24
  25 #ifndef SLAVE_I2C_ADDRESS
  26 #  define SLAVE_I2C_ADDRESS           0x32
  27 #endif
  28
  29 #if (MATRIX_COLS > 8)
  30 #  error "Currently only supports 8 COLS"
  31 #endif
  32
  33 // Get rows from other half over i2c
  34 bool transport_master(matrix_row_t matrix[]) {
  35   int err = 0;
  36
  37   // write backlight info
  38 #ifdef BACKLIGHT_ENABLE
  39   if (BACKLIT_DIRTY) {
  40     err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
  41     if (err) { goto i2c_error; }
  42
  43     // Backlight location
  44     err = i2c_master_write(I2C_BACKLIT_START);
  45     if (err) { goto i2c_error; }
  46
  47     // Write backlight
  48     i2c_master_write(get_backlight_level());
  49
  50     BACKLIT_DIRTY = false;
  51   }
  52 #endif
  53
  54   err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
  55   if (err) { goto i2c_error; }
  56
  57   // start of matrix stored at I2C_KEYMAP_START
  58   err = i2c_master_write(I2C_KEYMAP_START);
  59   if (err) { goto i2c_error; }
  60
  61   // Start read
  62   err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ);
  63   if (err) { goto i2c_error; }
  64
  65   if (!err) {
  66     int i;
  67     for (i = 0; i < ROWS_PER_HAND-1; ++i) {
  68       matrix[i] = i2c_master_read(I2C_ACK);
  69     }
  70     matrix[i] = i2c_master_read(I2C_NACK);
  71     i2c_master_stop();
  72   } else {
  73 i2c_error: // the cable is disconnceted, or something else went wrong
  74     i2c_reset_state();
  75     return false;
  76   }
  77
  78 #ifdef RGBLIGHT_ENABLE
  79   if (RGB_DIRTY) {
  80     err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
  81     if (err) { goto i2c_error; }
  82
  83     // RGB Location
  84     err = i2c_master_write(I2C_RGB_START);
  85     if (err) { goto i2c_error; }
  86
  87     uint32_t dword = eeconfig_read_rgblight();
  88
  89     // Write RGB
  90     err = i2c_master_write_data(&dword, 4);
  91     if (err) { goto i2c_error; }
  92
  93     RGB_DIRTY = false;
  94     i2c_master_stop();
  95   }
  96 #endif
  97
  98   return true;
  99 }
 100
 101 void transport_slave(matrix_row_t matrix[]) {
 102
 103   for (int i = 0; i < ROWS_PER_HAND; ++i)
 104   {
 105     i2c_slave_buffer[I2C_KEYMAP_START + i] = matrix[i];
 106   }
 107   // Read Backlight Info
 108   #ifdef BACKLIGHT_ENABLE
 109   if (BACKLIT_DIRTY)
 110   {
 111     backlight_set(i2c_slave_buffer[I2C_BACKLIT_START]);
 112     BACKLIT_DIRTY = false;
 113   }
 114   #endif
 115   #ifdef RGBLIGHT_ENABLE
 116   if (RGB_DIRTY)
 117   {
 118     // Disable interupts (RGB data is big)
 119     cli();
 120     // Create new DWORD for RGB data
 121     uint32_t dword;
 122
 123     // Fill the new DWORD with the data that was sent over
 124     uint8_t * dword_dat = (uint8_t *)(&dword);
 125     for (int i = 0; i < 4; i++)
 126     {
 127       dword_dat[i] = i2c_slave_buffer[I2C_RGB_START + i];
 128     }
 129
 130     // Update the RGB now with the new data and set RGB_DIRTY to false
 131     rgblight_update_dword(dword);
 132     RGB_DIRTY = false;
 133     // Re-enable interupts now that RGB is set
 134     sei();
 135   }
 136   #endif
 137 }
 138
 139 void transport_master_init(void) {
 140   i2c_master_init();
 141 }
 142
 143 void transport_slave_init(void) {
 144   i2c_slave_init(SLAVE_I2C_ADDRESS);
 145 }
 146
 147 #else // USE_SERIAL
 148
 149 #include "serial.h"
 150
 151
 152
 153 volatile Serial_s2m_buffer_t serial_s2m_buffer = {};
 154 volatile Serial_m2s_buffer_t serial_m2s_buffer = {};
 155 uint8_t volatile status0 = 0;
 156
 157 SSTD_t transactions[] = {
 158   { (uint8_t *)&status0,
 159     sizeof(serial_m2s_buffer), (uint8_t *)&serial_m2s_buffer,
 160     sizeof(serial_s2m_buffer), (uint8_t *)&serial_s2m_buffer
 161   }
 162 };
 163
 164 uint8_t slave_layer_cache;
 165 uint8_t slave_nlock_cache;
 166 uint8_t slave_clock_cache;
 167 uint8_t slave_slock_cache;
 168
 169 void transport_master_init(void)
 170 { soft_serial_initiator_init(transactions, TID_LIMIT(transactions)); }
 171
 172 void transport_slave_init(void)
 173 {
 174         soft_serial_target_init(transactions, TID_LIMIT(transactions));
 175         slave_layer_cache = 255;
 176         slave_nlock_cache = 255;
 177         slave_clock_cache = 255;
 178         slave_slock_cache = 255;
 179 }
 180
 181 bool transport_master(matrix_row_t matrix[]) {
 182
 183   if (soft_serial_transaction()) {
 184     return false;
 185   }
 186
 187   // TODO:  if MATRIX_COLS > 8 change to unpack()
 188   for (int i = 0; i < ROWS_PER_HAND; ++i) {
 189     matrix[i] = serial_s2m_buffer.smatrix[i];
 190   }
 191
 192   #if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
 193     // Code to send RGB over serial goes here (not implemented yet)
 194   #endif
 195
 196   #ifdef BACKLIGHT_ENABLE
 197     // Write backlight level for slave to read
 198     serial_m2s_buffer.backlight_level = backlight_config.enable ? backlight_config.level : 0;
 199   #endif
 200
 201   return true;
 202 }
 203
 204 void transport_slave(matrix_row_t matrix[]) {
 205
 206   // TODO: if MATRIX_COLS > 8 change to pack()
 207   for (int i = 0; i < ROWS_PER_HAND; ++i)
 208   {
 209     serial_s2m_buffer.smatrix[i] = matrix[i];
 210   }
 211   #ifdef BACKLIGHT_ENABLE
 212     backlight_set(serial_m2s_buffer.backlight_level);
 213   #endif
 214   #if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
 215   // Add serial implementation for RGB here
 216   #endif
 217
 218   if (slave_layer_cache != serial_m2s_buffer.current_layer) {
 219         slave_layer_cache = serial_m2s_buffer.current_layer;
 220         set_layer_indicators(slave_layer_cache);
 221   }
 222
 223   if (slave_nlock_cache != serial_m2s_buffer.nlock_led) {
 224         slave_nlock_cache = serial_m2s_buffer.nlock_led;
 225         led_toggle(3, slave_nlock_cache);
 226   }
 227   if (slave_clock_cache != serial_m2s_buffer.clock_led) {
 228         slave_clock_cache = serial_m2s_buffer.clock_led;
 229         led_toggle(4, slave_clock_cache);
 230   }
 231   if (slave_slock_cache != serial_m2s_buffer.slock_led) {
 232         slave_slock_cache = serial_m2s_buffer.slock_led;
 233         led_toggle(5, slave_slock_cache);
 234   }
 235
 236 }
 237
 238 #endif