changed adjust layer to emulate mouse on rignt hand

10 files changed, 907 insertions, 907 deletions

diff --git a/keyboards/amj40/keymaps/fabian/Makefile b/keyboards/amj40/keymaps/fabian/Makefile
index 034e697bc2..a914e4c0ce 100755
--- a/keyboards/amj40/keymaps/fabian/Makefile
+++ b/keyboards/amj40/keymaps/fabian/Makefile
@@ -3,7 +3,7 @@
 #   the appropriate keymap folder that will get included automatically
 #
 BOOTMAGIC_ENABLE = no  # Virtual DIP switch configuration(+1000)
-MOUSEKEY_ENABLE  = no  # Mouse keys(+4700)
+MOUSEKEY_ENABLE  = yes  # Mouse keys(+4700)
 EXTRAKEY_ENABLE  = yes # Audio control and System control(+450)
 CONSOLE_ENABLE   = no  # Console for debug(+400)
 COMMAND_ENABLE   = yes # Commands for debug and configuration
diff --git a/keyboards/amj40/keymaps/fabian/keymap.c b/keyboards/amj40/keymaps/fabian/keymap.c
index 57b4d957b2..aef514153e 100755
--- a/keyboards/amj40/keymaps/fabian/keymap.c
+++ b/keyboards/amj40/keymaps/fabian/keymap.c
@@ -134,19 +134,19 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 /* Adjust (Lower + Raise)
  * ,-----------------------------------------------------------------------------------.
- * |      |Reset |      |Aud on|Audoff|AGnorm|AGswap|Qwerty|Colemk|Dvorak|Reset | Del  |
+ * |Reset |Colemk|Qwerty|Dvorak|      |      |      |      |  MU  |      |      |Reset |
  * |------+------+------+------+------+------|------+------+------+------+------+------|
- * |      |      |      |      |      |      |      |      |      |      |      |      |
+ * |      |AGNorm|AGSwap|      |      |      |      |  ML  |  MD  |  MR  |      |      |
  * |------+------+------+------+------+------+------+------+------+------+------+------|
- * |      |      |      |      |      |      |      |      |      |      |      |      |
+ * |      |AudOn |AudOff|      |      |      |      |MBtn1 |MBtn2 |MBtn3 |      |      |
  * |------+------+------+------+------+------+------+------+------+------+------+------|
  * |      |      |      |      |      |      |      |      |      |      |      |      |
  * `-----------------------------------------------------------------------------------'
  */
-[_ADJUST] =  KEYMAP( \
-  _______, RESET,   _______, AU_ON,   AU_OFF,  AG_NORM, AG_SWAP, QWERTY,  COLEMAK, DVORAK,  RESET,   KC_DEL, \
-  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
-  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+[_ADJUST] = KEYMAP( \
+  RESET,   COLEMAK, QWERTY,  DVORAK,  _______, _______, _______, _______, KC_MS_U, _______, _______, RESET, \
+  _______, AG_NORM, AG_SWAP, _______, _______, _______, _______, KC_MS_L, KC_MS_D, KC_MS_R, _______, _______, \
+  _______, AU_ON,   AU_OFF,  _______, _______, _______, _______, KC_BTN1, KC_BTN2, KC_BTN3, _______, _______, \
   _______, _______, _______, _______,          _______,          _______,          _______, _______, _______ \
 )
 
diff --git a/keyboards/deltasplit75/i2c.c b/keyboards/deltasplit75/i2c.c
index af806c75b6..084c890c40 100644
--- a/keyboards/deltasplit75/i2c.c
+++ b/keyboards/deltasplit75/i2c.c
@@ -1,162 +1,162 @@
-#include <util/twi.h>

-#include <avr/io.h>

-#include <stdlib.h>

-#include <avr/interrupt.h>

-#include <util/twi.h>

-#include <stdbool.h>

-#include "i2c.h"

-

-#ifdef USE_I2C

-

-// Limits the amount of we wait for any one i2c transaction.

-// Since were running SCL line 100kHz (=> 10μs/bit), and each transactions is

-// 9 bits, a single transaction will take around 90μs to complete.

-//

-// (F_CPU/SCL_CLOCK)  =>  # of μC cycles to transfer a bit

-// poll loop takes at least 8 clock cycles to execute

-#define I2C_LOOP_TIMEOUT (9+1)*(F_CPU/SCL_CLOCK)/8

-

-#define BUFFER_POS_INC() (slave_buffer_pos = (slave_buffer_pos+1)%SLAVE_BUFFER_SIZE)

-

-volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];

-

-static volatile uint8_t slave_buffer_pos;

-static volatile bool slave_has_register_set = false;

-

-// Wait for an i2c operation to finish

-inline static

-void i2c_delay(void) {

-  uint16_t lim = 0;

-  while(!(TWCR & (1<<TWINT)) && lim < I2C_LOOP_TIMEOUT)

-    lim++;

-

-  // easier way, but will wait slightly longer

-  // _delay_us(100);

-}

-

-// Setup twi to run at 100kHz

-void i2c_master_init(void) {

-  // no prescaler

-  TWSR = 0;

-  // Set TWI clock frequency to SCL_CLOCK. Need TWBR>10.

-  // Check datasheets for more info.

-  TWBR = ((F_CPU/SCL_CLOCK)-16)/2;

-}

-

-// Start a transaction with the given i2c slave address. The direction of the

-// transfer is set with I2C_READ and I2C_WRITE.

-// returns: 0 => success

-//          1 => error

-uint8_t i2c_master_start(uint8_t address) {

-  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTA);

-

-  i2c_delay();

-

-  // check that we started successfully

-  if ( (TW_STATUS != TW_START) && (TW_STATUS != TW_REP_START))

-    return 1;

-

-  TWDR = address;

-  TWCR = (1<<TWINT) | (1<<TWEN);

-

-  i2c_delay();

-

-  if ( (TW_STATUS != TW_MT_SLA_ACK) && (TW_STATUS != TW_MR_SLA_ACK) )

-    return 1; // slave did not acknowledge

-  else

-    return 0; // success

-}

-

-

-// Finish the i2c transaction.

-void i2c_master_stop(void) {

-  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);

-

-  uint16_t lim = 0;

-  while(!(TWCR & (1<<TWSTO)) && lim < I2C_LOOP_TIMEOUT)

-    lim++;

-}

-

-// Write one byte to the i2c slave.

-// returns 0 => slave ACK

-//         1 => slave NACK

-uint8_t i2c_master_write(uint8_t data) {

-  TWDR = data;

-  TWCR = (1<<TWINT) | (1<<TWEN);

-

-  i2c_delay();

-

-  // check if the slave acknowledged us

-  return (TW_STATUS == TW_MT_DATA_ACK) ? 0 : 1;

-}

-

-// Read one byte from the i2c slave. If ack=1 the slave is acknowledged,

-// if ack=0 the acknowledge bit is not set.

-// returns: byte read from i2c device

-uint8_t i2c_master_read(int ack) {

-  TWCR = (1<<TWINT) | (1<<TWEN) | (ack<<TWEA);

-

-  i2c_delay();

-  return TWDR;

-}

-

-void i2c_reset_state(void) {

-  TWCR = 0;

-}

-

-void i2c_slave_init(uint8_t address) {

-  TWAR = address << 0; // slave i2c address

-  // TWEN  - twi enable

-  // TWEA  - enable address acknowledgement

-  // TWINT - twi interrupt flag

-  // TWIE  - enable the twi interrupt

-  TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN);

-}

-

-ISR(TWI_vect);

-

-ISR(TWI_vect) {

-  uint8_t ack = 1;

-  switch(TW_STATUS) {

-    case TW_SR_SLA_ACK:

-      // this device has been addressed as a slave receiver

-      slave_has_register_set = false;

-      break;

-

-    case TW_SR_DATA_ACK:

-      // this device has received data as a slave receiver

-      // The first byte that we receive in this transaction sets the location

-      // of the read/write location of the slaves memory that it exposes over

-      // i2c.  After that, bytes will be written at slave_buffer_pos, incrementing

-      // slave_buffer_pos after each write.

-      if(!slave_has_register_set) {

-        slave_buffer_pos = TWDR;

-        // don't acknowledge the master if this memory loctaion is out of bounds

-        if ( slave_buffer_pos >= SLAVE_BUFFER_SIZE ) {

-          ack = 0;

-          slave_buffer_pos = 0;

-        }

-        slave_has_register_set = true;

-      } else {

-        i2c_slave_buffer[slave_buffer_pos] = TWDR;

-        BUFFER_POS_INC();

-      }

-      break;

-

-    case TW_ST_SLA_ACK:

-    case TW_ST_DATA_ACK:

-      // master has addressed this device as a slave transmitter and is

-      // requesting data.

-      TWDR = i2c_slave_buffer[slave_buffer_pos];

-      BUFFER_POS_INC();

-      break;

-

-    case TW_BUS_ERROR: // something went wrong, reset twi state

-      TWCR = 0;

-    default:

-      break;

-  }

-  // Reset everything, so we are ready for the next TWI interrupt

-  TWCR |= (1<<TWIE) | (1<<TWINT) | (ack<<TWEA) | (1<<TWEN);

-}

-#endif

+#include <util/twi.h>
+#include <avr/io.h>
+#include <stdlib.h>
+#include <avr/interrupt.h>
+#include <util/twi.h>
+#include <stdbool.h>
+#include "i2c.h"
+
+#ifdef USE_I2C
+
+// Limits the amount of we wait for any one i2c transaction.
+// Since were running SCL line 100kHz (=> 10μs/bit), and each transactions is
+// 9 bits, a single transaction will take around 90μs to complete.
+//
+// (F_CPU/SCL_CLOCK)  =>  # of μC cycles to transfer a bit
+// poll loop takes at least 8 clock cycles to execute
+#define I2C_LOOP_TIMEOUT (9+1)*(F_CPU/SCL_CLOCK)/8
+
+#define BUFFER_POS_INC() (slave_buffer_pos = (slave_buffer_pos+1)%SLAVE_BUFFER_SIZE)
+
+volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];
+
+static volatile uint8_t slave_buffer_pos;
+static volatile bool slave_has_register_set = false;
+
+// Wait for an i2c operation to finish
+inline static
+void i2c_delay(void) {
+  uint16_t lim = 0;
+  while(!(TWCR & (1<<TWINT)) && lim < I2C_LOOP_TIMEOUT)
+    lim++;
+
+  // easier way, but will wait slightly longer
+  // _delay_us(100);
+}
+
+// Setup twi to run at 100kHz
+void i2c_master_init(void) {
+  // no prescaler
+  TWSR = 0;
+  // Set TWI clock frequency to SCL_CLOCK. Need TWBR>10.
+  // Check datasheets for more info.
+  TWBR = ((F_CPU/SCL_CLOCK)-16)/2;
+}
+
+// Start a transaction with the given i2c slave address. The direction of the
+// transfer is set with I2C_READ and I2C_WRITE.
+// returns: 0 => success
+//          1 => error
+uint8_t i2c_master_start(uint8_t address) {
+  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTA);
+
+  i2c_delay();
+
+  // check that we started successfully
+  if ( (TW_STATUS != TW_START) && (TW_STATUS != TW_REP_START))
+    return 1;
+
+  TWDR = address;
+  TWCR = (1<<TWINT) | (1<<TWEN);
+
+  i2c_delay();
+
+  if ( (TW_STATUS != TW_MT_SLA_ACK) && (TW_STATUS != TW_MR_SLA_ACK) )
+    return 1; // slave did not acknowledge
+  else
+    return 0; // success
+}
+
+
+// Finish the i2c transaction.
+void i2c_master_stop(void) {
+  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
+
+  uint16_t lim = 0;
+  while(!(TWCR & (1<<TWSTO)) && lim < I2C_LOOP_TIMEOUT)
+    lim++;
+}
+
+// Write one byte to the i2c slave.
+// returns 0 => slave ACK
+//         1 => slave NACK
+uint8_t i2c_master_write(uint8_t data) {
+  TWDR = data;
+  TWCR = (1<<TWINT) | (1<<TWEN);
+
+  i2c_delay();
+
+  // check if the slave acknowledged us
+  return (TW_STATUS == TW_MT_DATA_ACK) ? 0 : 1;
+}
+
+// Read one byte from the i2c slave. If ack=1 the slave is acknowledged,
+// if ack=0 the acknowledge bit is not set.
+// returns: byte read from i2c device
+uint8_t i2c_master_read(int ack) {
+  TWCR = (1<<TWINT) | (1<<TWEN) | (ack<<TWEA);
+
+  i2c_delay();
+  return TWDR;
+}
+
+void i2c_reset_state(void) {
+  TWCR = 0;
+}
+
+void i2c_slave_init(uint8_t address) {
+  TWAR = address << 0; // slave i2c address
+  // TWEN  - twi enable
+  // TWEA  - enable address acknowledgement
+  // TWINT - twi interrupt flag
+  // TWIE  - enable the twi interrupt
+  TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN);
+}
+
+ISR(TWI_vect);
+
+ISR(TWI_vect) {
+  uint8_t ack = 1;
+  switch(TW_STATUS) {
+    case TW_SR_SLA_ACK:
+      // this device has been addressed as a slave receiver
+      slave_has_register_set = false;
+      break;
+
+    case TW_SR_DATA_ACK:
+      // this device has received data as a slave receiver
+      // The first byte that we receive in this transaction sets the location
+      // of the read/write location of the slaves memory that it exposes over
+      // i2c.  After that, bytes will be written at slave_buffer_pos, incrementing
+      // slave_buffer_pos after each write.
+      if(!slave_has_register_set) {
+        slave_buffer_pos = TWDR;
+        // don't acknowledge the master if this memory loctaion is out of bounds
+        if ( slave_buffer_pos >= SLAVE_BUFFER_SIZE ) {
+          ack = 0;
+          slave_buffer_pos = 0;
+        }
+        slave_has_register_set = true;
+      } else {
+        i2c_slave_buffer[slave_buffer_pos] = TWDR;
+        BUFFER_POS_INC();
+      }
+      break;
+
+    case TW_ST_SLA_ACK:
+    case TW_ST_DATA_ACK:
+      // master has addressed this device as a slave transmitter and is
+      // requesting data.
+      TWDR = i2c_slave_buffer[slave_buffer_pos];
+      BUFFER_POS_INC();
+      break;
+
+    case TW_BUS_ERROR: // something went wrong, reset twi state
+      TWCR = 0;
+    default:
+      break;
+  }
+  // Reset everything, so we are ready for the next TWI interrupt
+  TWCR |= (1<<TWIE) | (1<<TWINT) | (ack<<TWEA) | (1<<TWEN);
+}
+#endif
diff --git a/keyboards/deltasplit75/i2c.h b/keyboards/deltasplit75/i2c.h
index cc3910806c..08ce4b0093 100644
--- a/keyboards/deltasplit75/i2c.h
+++ b/keyboards/deltasplit75/i2c.h
@@ -1,31 +1,31 @@
-#ifndef I2C_H

-#define I2C_H

-

-#include <stdint.h>

-

-#ifndef F_CPU

-#define F_CPU 16000000UL

-#endif

-

-#define I2C_READ 1

-#define I2C_WRITE 0

-

-#define I2C_ACK 1

-#define I2C_NACK 0

-

-#define SLAVE_BUFFER_SIZE 0x10

-

-// i2c SCL clock frequency

-#define SCL_CLOCK  100000L

-

-extern volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];

-

-void i2c_master_init(void);

-uint8_t i2c_master_start(uint8_t address);

-void i2c_master_stop(void);

-uint8_t i2c_master_write(uint8_t data);

-uint8_t i2c_master_read(int);

-void i2c_reset_state(void);

-void i2c_slave_init(uint8_t address);

-

-#endif

+#ifndef I2C_H
+#define I2C_H
+
+#include <stdint.h>
+
+#ifndef F_CPU
+#define F_CPU 16000000UL
+#endif
+
+#define I2C_READ 1
+#define I2C_WRITE 0
+
+#define I2C_ACK 1
+#define I2C_NACK 0
+
+#define SLAVE_BUFFER_SIZE 0x10
+
+// i2c SCL clock frequency
+#define SCL_CLOCK  100000L
+
+extern volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];
+
+void i2c_master_init(void);
+uint8_t i2c_master_start(uint8_t address);
+void i2c_master_stop(void);
+uint8_t i2c_master_write(uint8_t data);
+uint8_t i2c_master_read(int);
+void i2c_reset_state(void);
+void i2c_slave_init(uint8_t address);
+
+#endif
diff --git a/keyboards/deltasplit75/keymaps/default/config.h b/keyboards/deltasplit75/keymaps/default/config.h
index c72c00e681..4fb2554e0d 100644
--- a/keyboards/deltasplit75/keymaps/default/config.h
+++ b/keyboards/deltasplit75/keymaps/default/config.h
@@ -1,31 +1,31 @@
-/*

-Copyright 2012 Jun Wako <wakojun@gmail.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/>.

-*/

-

-

-#define USE_SERIAL

-

-#define MASTER_LEFT

-// #define _MASTER_RIGHT

-// #define EE_HANDS

-

-

-#ifdef SUBPROJECT_v2

-    #include "../../v2/config.h"

-#endif

-#ifdef SUBPROJECT_protosplit

-    #include "../../protosplit/config.h"

-#endif

+/*
+Copyright 2012 Jun Wako <wakojun@gmail.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/>.
+*/
+
+
+#define USE_SERIAL
+
+#define MASTER_LEFT
+// #define _MASTER_RIGHT
+// #define EE_HANDS
+
+
+#ifdef SUBPROJECT_v2
+    #include "../../v2/config.h"
+#endif
+#ifdef SUBPROJECT_protosplit
+    #include "../../protosplit/config.h"
+#endif
diff --git a/keyboards/deltasplit75/matrix.c b/keyboards/deltasplit75/matrix.c
index c3bb0b058c..1389690042 100644
--- a/keyboards/deltasplit75/matrix.c
+++ b/keyboards/deltasplit75/matrix.c
@@ -1,318 +1,318 @@
-/*

-Copyright 2012 Jun Wako <wakojun@gmail.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/>.

-*/

-

-/*

- * scan matrix

- */

-#include <stdint.h>

-#include <stdbool.h>

-#include <avr/io.h>

-#include <avr/wdt.h>

-#include <avr/interrupt.h>

-#include <util/delay.h>

-#include "print.h"

-#include "debug.h"

-#include "util.h"

-#include "matrix.h"

-#include "split_util.h"

-#include "pro_micro.h"

-#include "config.h"

-

-#ifdef USE_I2C

-#  include "i2c.h"

-#else // USE_SERIAL

-#  include "serial.h"

-#endif

-

-#ifndef DEBOUNCE

-#  define DEBOUNCE	5

-#endif

-

-#define ERROR_DISCONNECT_COUNT 5

-

-static uint8_t debouncing = DEBOUNCE;

-static const int ROWS_PER_HAND = MATRIX_ROWS/2;

-static uint8_t error_count = 0;

-

-static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;

-static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;

-

-/* matrix state(1:on, 0:off) */

-static matrix_row_t matrix[MATRIX_ROWS];

-static matrix_row_t matrix_debouncing[MATRIX_ROWS];

-

-static matrix_row_t read_cols(void);

-static void init_cols(void);

-static void unselect_rows(void);

-static void select_row(uint8_t row);

-

-__attribute__ ((weak))

-void matrix_init_quantum(void) {

-    matrix_init_kb();

-}

-

-__attribute__ ((weak))

-void matrix_scan_quantum(void) {

-    matrix_scan_kb();

-}

-

-__attribute__ ((weak))

-void matrix_init_kb(void) {

-    matrix_init_user();

-}

-

-__attribute__ ((weak))

-void matrix_scan_kb(void) {

-    matrix_scan_user();

-}

-

-__attribute__ ((weak))

-void matrix_init_user(void) {

-}

-

-__attribute__ ((weak))

-void matrix_scan_user(void) {

-}

-

-inline

-uint8_t matrix_rows(void)

-{

-    return MATRIX_ROWS;

-}

-

-inline

-uint8_t matrix_cols(void)

-{

-    return MATRIX_COLS;

-}

-

-void matrix_init(void)

-{

-    debug_enable = true;

-    debug_matrix = true;

-    debug_mouse = true;

-    // initialize row and col

-    unselect_rows();

-    init_cols();

-

-    TX_RX_LED_INIT;

-

-    // initialize matrix state: all keys off

-    for (uint8_t i=0; i < MATRIX_ROWS; i++) {

-        matrix[i] = 0;

-        matrix_debouncing[i] = 0;

-    }

-

-    matrix_init_quantum();

-}

-

-uint8_t _matrix_scan(void)

-{

-    // Right hand is stored after the left in the matirx so, we need to offset it

-    int offset = isLeftHand ? 0 : (ROWS_PER_HAND);

-

-    for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {

-        select_row(i);

-        _delay_us(30);  // without this wait read unstable value.

-        matrix_row_t cols = read_cols();

-        if (matrix_debouncing[i+offset] != cols) {

-            matrix_debouncing[i+offset] = cols;

-            debouncing = DEBOUNCE;

-        }

-        unselect_rows();

-    }

-

-    if (debouncing) {

-        if (--debouncing) {

-            _delay_ms(1);

-        } else {

-            for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {

-                matrix[i+offset] = matrix_debouncing[i+offset];

-            }

-        }

-    }

-

-    return 1;

-}

-

-#ifdef USE_I2C

-

-// Get rows from other half over i2c

-int i2c_transaction(void) {

-    int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;

-

-    int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);

-    if (err) goto i2c_error;

-

-    // start of matrix stored at 0x00

-    err = i2c_master_write(0x00);

-    if (err) goto i2c_error;

-

-    // Start read

-    err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ);

-    if (err) goto i2c_error;

-

-    if (!err) {

-        int i;

-        for (i = 0; i < ROWS_PER_HAND-1; ++i) {

-            matrix[slaveOffset+i] = i2c_master_read(I2C_ACK);

-        }

-        matrix[slaveOffset+i] = i2c_master_read(I2C_NACK);

-        i2c_master_stop();

-    } else {

-i2c_error: // the cable is disconnceted, or something else went wrong

-        i2c_reset_state();

-        return err;

-    }

-

-    return 0;

-}

-

-#else // USE_SERIAL

-

-int serial_transaction(void) {

-    int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;

-

-    if (serial_update_buffers()) {

-        return 1;

-    }

-

-    for (int i = 0; i < ROWS_PER_HAND; ++i) {

-        matrix[slaveOffset+i] = serial_slave_buffer[i];

-    }

-    return 0;

-}

-#endif

-

-uint8_t matrix_scan(void)

-{

-    int ret = _matrix_scan();

-

-

-

-#ifdef USE_I2C

-    if( i2c_transaction() ) {

-#else // USE_SERIAL

-    if( serial_transaction() ) {

-#endif

-        // turn on the indicator led when halves are disconnected

-        TXLED1;

-

-        error_count++;

-

-        if (error_count > ERROR_DISCONNECT_COUNT) {

-            // reset other half if disconnected

-            int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;

-            for (int i = 0; i < ROWS_PER_HAND; ++i) {

-                matrix[slaveOffset+i] = 0;

-            }

-        }

-    } else {

-        // turn off the indicator led on no error

-        TXLED0;

-        error_count = 0;

-    }

-

-    matrix_scan_quantum();

-

-    return ret;

-}

-

-void matrix_slave_scan(void) {

-    _matrix_scan();

-

-    int offset = (isLeftHand) ? 0 : (MATRIX_ROWS / 2);

-

-#ifdef USE_I2C

-    for (int i = 0; i < ROWS_PER_HAND; ++i) {

-        /* i2c_slave_buffer[i] = matrix[offset+i]; */

-        i2c_slave_buffer[i] = matrix[offset+i];

-    }

-#else // USE_SERIAL

-    for (int i = 0; i < ROWS_PER_HAND; ++i) {

-        serial_slave_buffer[i] = matrix[offset+i];

-    }

-#endif

-}

-

-bool matrix_is_modified(void)

-{

-    if (debouncing) return false;

-    return true;

-}

-

-inline

-bool matrix_is_on(uint8_t row, uint8_t col)

-{

-    return (matrix[row] & ((matrix_row_t)1<<col));

-}

-

-inline

-matrix_row_t matrix_get_row(uint8_t row)

-{

-    return matrix[row];

-}

-

-void matrix_print(void)

-{

-    print("\nr/c 0123456789ABCDEF\n");

-    for (uint8_t row = 0; row < MATRIX_ROWS; row++) {

-        phex(row); print(": ");

-        pbin_reverse16(matrix_get_row(row));

-        print("\n");

-    }

-}

-

-uint8_t matrix_key_count(void)

-{

-    uint8_t count = 0;

-    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {

-        count += bitpop16(matrix[i]);

-    }

-    return count;

-}

-

-static void  init_cols(void)

-{

-    for(int x = 0; x < MATRIX_COLS; x++) {

-        _SFR_IO8((col_pins[x] >> 4) + 1) &=  ~_BV(col_pins[x] & 0xF);

-        _SFR_IO8((col_pins[x] >> 4) + 2) |= _BV(col_pins[x] & 0xF);

-    }

-}

-

-static matrix_row_t read_cols(void)

-{

-    matrix_row_t result = 0;

-    for(int x = 0; x < MATRIX_COLS; x++) {

-        result |= (_SFR_IO8(col_pins[x] >> 4) & _BV(col_pins[x] & 0xF)) ? 0 : (1 << x);

-    }

-    return result;

-}

-

-static void unselect_rows(void)

-{

-    for(int x = 0; x < ROWS_PER_HAND; x++) {

-        _SFR_IO8((row_pins[x] >> 4) + 1) &=  ~_BV(row_pins[x] & 0xF);

-        _SFR_IO8((row_pins[x] >> 4) + 2) |= _BV(row_pins[x] & 0xF);

-    }

-}

-

-static void select_row(uint8_t row)

-{

-    _SFR_IO8((row_pins[row] >> 4) + 1) |=  _BV(row_pins[row] & 0xF);

-    _SFR_IO8((row_pins[row] >> 4) + 2) &= ~_BV(row_pins[row] & 0xF);

-}

+/*
+Copyright 2012 Jun Wako <wakojun@gmail.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/>.
+*/
+
+/*
+ * scan matrix
+ */
+#include <stdint.h>
+#include <stdbool.h>
+#include <avr/io.h>
+#include <avr/wdt.h>
+#include <avr/interrupt.h>
+#include <util/delay.h>
+#include "print.h"
+#include "debug.h"
+#include "util.h"
+#include "matrix.h"
+#include "split_util.h"
+#include "pro_micro.h"
+#include "config.h"
+
+#ifdef USE_I2C
+#  include "i2c.h"
+#else // USE_SERIAL
+#  include "serial.h"
+#endif
+
+#ifndef DEBOUNCE
+#  define DEBOUNCE	5
+#endif
+
+#define ERROR_DISCONNECT_COUNT 5
+
+static uint8_t debouncing = DEBOUNCE;
+static const int ROWS_PER_HAND = MATRIX_ROWS/2;
+static uint8_t error_count = 0;
+
+static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
+static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
+
+/* matrix state(1:on, 0:off) */
+static matrix_row_t matrix[MATRIX_ROWS];
+static matrix_row_t matrix_debouncing[MATRIX_ROWS];
+
+static matrix_row_t read_cols(void);
+static void init_cols(void);
+static void unselect_rows(void);
+static void select_row(uint8_t row);
+
+__attribute__ ((weak))
+void matrix_init_quantum(void) {
+    matrix_init_kb();
+}
+
+__attribute__ ((weak))
+void matrix_scan_quantum(void) {
+    matrix_scan_kb();
+}
+
+__attribute__ ((weak))
+void matrix_init_kb(void) {
+    matrix_init_user();
+}
+
+__attribute__ ((weak))
+void matrix_scan_kb(void) {
+    matrix_scan_user();
+}
+
+__attribute__ ((weak))
+void matrix_init_user(void) {
+}
+
+__attribute__ ((weak))
+void matrix_scan_user(void) {
+}
+
+inline
+uint8_t matrix_rows(void)
+{
+    return MATRIX_ROWS;
+}
+
+inline
+uint8_t matrix_cols(void)
+{
+    return MATRIX_COLS;
+}
+
+void matrix_init(void)
+{
+    debug_enable = true;
+    debug_matrix = true;
+    debug_mouse = true;
+    // initialize row and col
+    unselect_rows();
+    init_cols();
+
+    TX_RX_LED_INIT;
+
+    // initialize matrix state: all keys off
+    for (uint8_t i=0; i < MATRIX_ROWS; i++) {
+        matrix[i] = 0;
+        matrix_debouncing[i] = 0;
+    }
+
+    matrix_init_quantum();
+}
+
+uint8_t _matrix_scan(void)
+{
+    // Right hand is stored after the left in the matirx so, we need to offset it
+    int offset = isLeftHand ? 0 : (ROWS_PER_HAND);
+
+    for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
+        select_row(i);
+        _delay_us(30);  // without this wait read unstable value.
+        matrix_row_t cols = read_cols();
+        if (matrix_debouncing[i+offset] != cols) {
+            matrix_debouncing[i+offset] = cols;
+            debouncing = DEBOUNCE;
+        }
+        unselect_rows();
+    }
+
+    if (debouncing) {
+        if (--debouncing) {
+            _delay_ms(1);
+        } else {
+            for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
+                matrix[i+offset] = matrix_debouncing[i+offset];
+            }
+        }
+    }
+
+    return 1;
+}
+
+#ifdef USE_I2C
+
+// Get rows from other half over i2c
+int i2c_transaction(void) {
+    int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
+
+    int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
+    if (err) goto i2c_error;
+
+    // start of matrix stored at 0x00
+    err = i2c_master_write(0x00);
+    if (err) goto i2c_error;
+
+    // Start read
+    err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ);
+    if (err) goto i2c_error;
+
+    if (!err) {
+        int i;
+        for (i = 0; i < ROWS_PER_HAND-1; ++i) {
+            matrix[slaveOffset+i] = i2c_master_read(I2C_ACK);
+        }
+        matrix[slaveOffset+i] = i2c_master_read(I2C_NACK);
+        i2c_master_stop();
+    } else {
+i2c_error: // the cable is disconnceted, or something else went wrong
+        i2c_reset_state();
+        return err;
+    }
+
+    return 0;
+}
+
+#else // USE_SERIAL
+
+int serial_transaction(void) {
+    int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
+
+    if (serial_update_buffers()) {
+        return 1;
+    }
+
+    for (int i = 0; i < ROWS_PER_HAND; ++i) {
+        matrix[slaveOffset+i] = serial_slave_buffer[i];
+    }
+    return 0;
+}
+#endif
+
+uint8_t matrix_scan(void)
+{
+    int ret = _matrix_scan();
+
+
+
+#ifdef USE_I2C
+    if( i2c_transaction() ) {
+#else // USE_SERIAL
+    if( serial_transaction() ) {
+#endif
+        // turn on the indicator led when halves are disconnected
+        TXLED1;
+
+        error_count++;
+
+        if (error_count > ERROR_DISCONNECT_COUNT) {
+            // reset other half if disconnected
+            int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
+            for (int i = 0; i < ROWS_PER_HAND; ++i) {
+                matrix[slaveOffset+i] = 0;
+            }
+        }
+    } else {
+        // turn off the indicator led on no error
+        TXLED0;
+        error_count = 0;
+    }
+
+    matrix_scan_quantum();
+
+    return ret;
+}
+
+void matrix_slave_scan(void) {
+    _matrix_scan();
+
+    int offset = (isLeftHand) ? 0 : (MATRIX_ROWS / 2);
+
+#ifdef USE_I2C
+    for (int i = 0; i < ROWS_PER_HAND; ++i) {
+        /* i2c_slave_buffer[i] = matrix[offset+i]; */
+        i2c_slave_buffer[i] = matrix[offset+i];
+    }
+#else // USE_SERIAL
+    for (int i = 0; i < ROWS_PER_HAND; ++i) {
+        serial_slave_buffer[i] = matrix[offset+i];
+    }
+#endif
+}
+
+bool matrix_is_modified(void)
+{
+    if (debouncing) return false;
+    return true;
+}
+
+inline
+bool matrix_is_on(uint8_t row, uint8_t col)
+{
+    return (matrix[row] & ((matrix_row_t)1<<col));
+}
+
+inline
+matrix_row_t matrix_get_row(uint8_t row)
+{
+    return matrix[row];
+}
+
+void matrix_print(void)
+{
+    print("\nr/c 0123456789ABCDEF\n");
+    for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
+        phex(row); print(": ");
+        pbin_reverse16(matrix_get_row(row));
+        print("\n");
+    }
+}
+
+uint8_t matrix_key_count(void)
+{
+    uint8_t count = 0;
+    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+        count += bitpop16(matrix[i]);
+    }
+    return count;
+}
+
+static void  init_cols(void)
+{
+    for(int x = 0; x < MATRIX_COLS; x++) {
+        _SFR_IO8((col_pins[x] >> 4) + 1) &=  ~_BV(col_pins[x] & 0xF);
+        _SFR_IO8((col_pins[x] >> 4) + 2) |= _BV(col_pins[x] & 0xF);
+    }
+}
+
+static matrix_row_t read_cols(void)
+{
+    matrix_row_t result = 0;
+    for(int x = 0; x < MATRIX_COLS; x++) {
+        result |= (_SFR_IO8(col_pins[x] >> 4) & _BV(col_pins[x] & 0xF)) ? 0 : (1 << x);
+    }
+    return result;
+}
+
+static void unselect_rows(void)
+{
+    for(int x = 0; x < ROWS_PER_HAND; x++) {
+        _SFR_IO8((row_pins[x] >> 4) + 1) &=  ~_BV(row_pins[x] & 0xF);
+        _SFR_IO8((row_pins[x] >> 4) + 2) |= _BV(row_pins[x] & 0xF);
+    }
+}
+
+static void select_row(uint8_t row)
+{
+    _SFR_IO8((row_pins[row] >> 4) + 1) |=  _BV(row_pins[row] & 0xF);
+    _SFR_IO8((row_pins[row] >> 4) + 2) &= ~_BV(row_pins[row] & 0xF);
+}
diff --git a/keyboards/deltasplit75/serial.c b/keyboards/deltasplit75/serial.c
index 898ef7d426..6faed09ce0 100644
--- a/keyboards/deltasplit75/serial.c
+++ b/keyboards/deltasplit75/serial.c
@@ -1,228 +1,228 @@
-/*

- * WARNING: be careful changing this code, it is very timing dependent

- */

-

-#ifndef F_CPU

-#define F_CPU 16000000

-#endif

-

-#include <avr/io.h>

-#include <avr/interrupt.h>

-#include <util/delay.h>

-#include <stdbool.h>

-#include "serial.h"

-

-#ifdef USE_SERIAL

-

-// Serial pulse period in microseconds. Its probably a bad idea to lower this

-// value.

-#define SERIAL_DELAY 24

-

-uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0};

-uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0};

-

-#define SLAVE_DATA_CORRUPT (1<<0)

-volatile uint8_t status = 0;

-

-inline static

-void serial_delay(void) {

-  _delay_us(SERIAL_DELAY);

-}

-

-inline static

-void serial_output(void) {

-  SERIAL_PIN_DDR |= SERIAL_PIN_MASK;

-}

-

-// make the serial pin an input with pull-up resistor

-inline static

-void serial_input(void) {

-  SERIAL_PIN_DDR  &= ~SERIAL_PIN_MASK;

-  SERIAL_PIN_PORT |= SERIAL_PIN_MASK;

-}

-

-inline static

-uint8_t serial_read_pin(void) {

-  return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK);

-}

-

-inline static

-void serial_low(void) {

-  SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK;

-}

-

-inline static

-void serial_high(void) {

-  SERIAL_PIN_PORT |= SERIAL_PIN_MASK;

-}

-

-void serial_master_init(void) {

-  serial_output();

-  serial_high();

-}

-

-void serial_slave_init(void) {

-  serial_input();

-

-  // Enable INT0

-  EIMSK |= _BV(INT0);

-  // Trigger on falling edge of INT0

-  EICRA &= ~(_BV(ISC00) | _BV(ISC01));

-}

-

-// Used by the master to synchronize timing with the slave.

-static

-void sync_recv(void) {

-  serial_input();

-  // This shouldn't hang if the slave disconnects because the

-  // serial line will float to high if the slave does disconnect.

-  while (!serial_read_pin());

-  serial_delay();

-}

-

-// Used by the slave to send a synchronization signal to the master.

-static

-void sync_send(void) {

-  serial_output();

-

-  serial_low();

-  serial_delay();

-

-  serial_high();

-}

-

-// Reads a byte from the serial line

-static

-uint8_t serial_read_byte(void) {

-  uint8_t byte = 0;

-  serial_input();

-  for ( uint8_t i = 0; i < 8; ++i) {

-    byte = (byte << 1) | serial_read_pin();

-    serial_delay();

-    _delay_us(1);

-  }

-

-  return byte;

-}

-

-// Sends a byte with MSB ordering

-static

-void serial_write_byte(uint8_t data) {

-  uint8_t b = 8;

-  serial_output();

-  while( b-- ) {

-    if(data & (1 << b)) {

-      serial_high();

-    } else {

-      serial_low();

-    }

-    serial_delay();

-  }

-}

-

-// interrupt handle to be used by the slave device

-ISR(SERIAL_PIN_INTERRUPT) {

-  sync_send();

-

-  uint8_t checksum = 0;

-  for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {

-    serial_write_byte(serial_slave_buffer[i]);

-    sync_send();

-    checksum += serial_slave_buffer[i];

-  }

-  serial_write_byte(checksum);

-  sync_send();

-

-  // wait for the sync to finish sending

-  serial_delay();

-

-  // read the middle of pulses

-  _delay_us(SERIAL_DELAY/2);

-

-  uint8_t checksum_computed = 0;

-  for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {

-    serial_master_buffer[i] = serial_read_byte();

-    sync_send();

-    checksum_computed += serial_master_buffer[i];

-  }

-  uint8_t checksum_received = serial_read_byte();

-  sync_send();

-

-  serial_input(); // end transaction

-

-  if ( checksum_computed != checksum_received ) {

-    status |= SLAVE_DATA_CORRUPT;

-  } else {

-    status &= ~SLAVE_DATA_CORRUPT;

-  }

-}

-

-inline

-bool serial_slave_DATA_CORRUPT(void) {

-  return status & SLAVE_DATA_CORRUPT;

-}

-

-// Copies the serial_slave_buffer to the master and sends the

-// serial_master_buffer to the slave.

-//

-// Returns:

-// 0 => no error

-// 1 => slave did not respond

-int serial_update_buffers(void) {

-  // this code is very time dependent, so we need to disable interrupts

-  cli();

-

-  // signal to the slave that we want to start a transaction

-  serial_output();

-  serial_low();

-  _delay_us(1);

-

-  // wait for the slaves response

-  serial_input();

-  serial_high();

-  _delay_us(SERIAL_DELAY);

-

-  // check if the slave is present

-  if (serial_read_pin()) {

-    // slave failed to pull the line low, assume not present

-    sei();

-    return 1;

-  }

-

-  // if the slave is present syncronize with it

-  sync_recv();

-

-  uint8_t checksum_computed = 0;

-  // receive data from the slave

-  for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {

-    serial_slave_buffer[i] = serial_read_byte();

-    sync_recv();

-    checksum_computed += serial_slave_buffer[i];

-  }

-  uint8_t checksum_received = serial_read_byte();

-  sync_recv();

-

-  if (checksum_computed != checksum_received) {

-    sei();

-    return 1;

-  }

-

-  uint8_t checksum = 0;

-  // send data to the slave

-  for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {

-    serial_write_byte(serial_master_buffer[i]);

-    sync_recv();

-    checksum += serial_master_buffer[i];

-  }

-  serial_write_byte(checksum);

-  sync_recv();

-

-  // always, release the line when not in use

-  serial_output();

-  serial_high();

-

-  sei();

-  return 0;

-}

-

-#endif

+/*
+ * WARNING: be careful changing this code, it is very timing dependent
+ */
+
+#ifndef F_CPU
+#define F_CPU 16000000
+#endif
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <util/delay.h>
+#include <stdbool.h>
+#include "serial.h"
+
+#ifdef USE_SERIAL
+
+// Serial pulse period in microseconds. Its probably a bad idea to lower this
+// value.
+#define SERIAL_DELAY 24
+
+uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0};
+uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0};
+
+#define SLAVE_DATA_CORRUPT (1<<0)
+volatile uint8_t status = 0;
+
+inline static
+void serial_delay(void) {
+  _delay_us(SERIAL_DELAY);
+}
+
+inline static
+void serial_output(void) {
+  SERIAL_PIN_DDR |= SERIAL_PIN_MASK;
+}
+
+// make the serial pin an input with pull-up resistor
+inline static
+void serial_input(void) {
+  SERIAL_PIN_DDR  &= ~SERIAL_PIN_MASK;
+  SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
+}
+
+inline static
+uint8_t serial_read_pin(void) {
+  return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK);
+}
+
+inline static
+void serial_low(void) {
+  SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK;
+}
+
+inline static
+void serial_high(void) {
+  SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
+}
+
+void serial_master_init(void) {
+  serial_output();
+  serial_high();
+}
+
+void serial_slave_init(void) {
+  serial_input();
+
+  // Enable INT0
+  EIMSK |= _BV(INT0);
+  // Trigger on falling edge of INT0
+  EICRA &= ~(_BV(ISC00) | _BV(ISC01));
+}
+
+// Used by the master to synchronize timing with the slave.
+static
+void sync_recv(void) {
+  serial_input();
+  // This shouldn't hang if the slave disconnects because the
+  // serial line will float to high if the slave does disconnect.
+  while (!serial_read_pin());
+  serial_delay();
+}
+
+// Used by the slave to send a synchronization signal to the master.
+static
+void sync_send(void) {
+  serial_output();
+
+  serial_low();
+  serial_delay();
+
+  serial_high();
+}
+
+// Reads a byte from the serial line
+static
+uint8_t serial_read_byte(void) {
+  uint8_t byte = 0;
+  serial_input();
+  for ( uint8_t i = 0; i < 8; ++i) {
+    byte = (byte << 1) | serial_read_pin();
+    serial_delay();
+    _delay_us(1);
+  }
+
+  return byte;
+}
+
+// Sends a byte with MSB ordering
+static
+void serial_write_byte(uint8_t data) {
+  uint8_t b = 8;
+  serial_output();
+  while( b-- ) {
+    if(data & (1 << b)) {
+      serial_high();
+    } else {
+      serial_low();
+    }
+    serial_delay();
+  }
+}
+
+// interrupt handle to be used by the slave device
+ISR(SERIAL_PIN_INTERRUPT) {
+  sync_send();
+
+  uint8_t checksum = 0;
+  for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
+    serial_write_byte(serial_slave_buffer[i]);
+    sync_send();
+    checksum += serial_slave_buffer[i];
+  }
+  serial_write_byte(checksum);
+  sync_send();
+
+  // wait for the sync to finish sending
+  serial_delay();
+
+  // read the middle of pulses
+  _delay_us(SERIAL_DELAY/2);
+
+  uint8_t checksum_computed = 0;
+  for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
+    serial_master_buffer[i] = serial_read_byte();
+    sync_send();
+    checksum_computed += serial_master_buffer[i];
+  }
+  uint8_t checksum_received = serial_read_byte();
+  sync_send();
+
+  serial_input(); // end transaction
+
+  if ( checksum_computed != checksum_received ) {
+    status |= SLAVE_DATA_CORRUPT;
+  } else {
+    status &= ~SLAVE_DATA_CORRUPT;
+  }
+}
+
+inline
+bool serial_slave_DATA_CORRUPT(void) {
+  return status & SLAVE_DATA_CORRUPT;
+}
+
+// Copies the serial_slave_buffer to the master and sends the
+// serial_master_buffer to the slave.
+//
+// Returns:
+// 0 => no error
+// 1 => slave did not respond
+int serial_update_buffers(void) {
+  // this code is very time dependent, so we need to disable interrupts
+  cli();
+
+  // signal to the slave that we want to start a transaction
+  serial_output();
+  serial_low();
+  _delay_us(1);
+
+  // wait for the slaves response
+  serial_input();
+  serial_high();
+  _delay_us(SERIAL_DELAY);
+
+  // check if the slave is present
+  if (serial_read_pin()) {
+    // slave failed to pull the line low, assume not present
+    sei();
+    return 1;
+  }
+
+  // if the slave is present syncronize with it
+  sync_recv();
+
+  uint8_t checksum_computed = 0;
+  // receive data from the slave
+  for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
+    serial_slave_buffer[i] = serial_read_byte();
+    sync_recv();
+    checksum_computed += serial_slave_buffer[i];
+  }
+  uint8_t checksum_received = serial_read_byte();
+  sync_recv();
+
+  if (checksum_computed != checksum_received) {
+    sei();
+    return 1;
+  }
+
+  uint8_t checksum = 0;
+  // send data to the slave
+  for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
+    serial_write_byte(serial_master_buffer[i]);
+    sync_recv();
+    checksum += serial_master_buffer[i];
+  }
+  serial_write_byte(checksum);
+  sync_recv();
+
+  // always, release the line when not in use
+  serial_output();
+  serial_high();
+
+  sei();
+  return 0;
+}
+
+#endif
diff --git a/keyboards/deltasplit75/serial.h b/keyboards/deltasplit75/serial.h
index ab2ea0a096..6ef52019a8 100644
--- a/keyboards/deltasplit75/serial.h
+++ b/keyboards/deltasplit75/serial.h
@@ -1,26 +1,26 @@
-#ifndef MY_SERIAL_H

-#define MY_SERIAL_H

-

-#include "config.h"

-#include <stdbool.h>

-

-/* TODO:  some defines for interrupt setup */

-#define SERIAL_PIN_DDR DDRD

-#define SERIAL_PIN_PORT PORTD

-#define SERIAL_PIN_INPUT PIND

-#define SERIAL_PIN_MASK _BV(PD0)

-#define SERIAL_PIN_INTERRUPT INT0_vect

-

-#define SERIAL_SLAVE_BUFFER_LENGTH ((MATRIX_COLS+7)/8 *MATRIX_ROWS/2)

-#define SERIAL_MASTER_BUFFER_LENGTH 1

-

-// Buffers for master - slave communication

-extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH];

-extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH];

-

-void serial_master_init(void);

-void serial_slave_init(void);

-int serial_update_buffers(void);

-bool serial_slave_data_corrupt(void);

-

-#endif

+#ifndef MY_SERIAL_H
+#define MY_SERIAL_H
+
+#include "config.h"
+#include <stdbool.h>
+
+/* TODO:  some defines for interrupt setup */
+#define SERIAL_PIN_DDR DDRD
+#define SERIAL_PIN_PORT PORTD
+#define SERIAL_PIN_INPUT PIND
+#define SERIAL_PIN_MASK _BV(PD0)
+#define SERIAL_PIN_INTERRUPT INT0_vect
+
+#define SERIAL_SLAVE_BUFFER_LENGTH ((MATRIX_COLS+7)/8 *MATRIX_ROWS/2)
+#define SERIAL_MASTER_BUFFER_LENGTH 1
+
+// Buffers for master - slave communication
+extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH];
+extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH];
+
+void serial_master_init(void);
+void serial_slave_init(void);
+int serial_update_buffers(void);
+bool serial_slave_data_corrupt(void);
+
+#endif
diff --git a/keyboards/deltasplit75/split_util.c b/keyboards/deltasplit75/split_util.c
index a636f60dbf..226dc18816 100644
--- a/keyboards/deltasplit75/split_util.c
+++ b/keyboards/deltasplit75/split_util.c
@@ -1,81 +1,81 @@
-#include <avr/io.h>

-#include <avr/wdt.h>

-#include <avr/power.h>

-#include <avr/interrupt.h>

-#include <util/delay.h>

-#include <avr/eeprom.h>

-#include "split_util.h"

-#include "matrix.h"

-#include "keyboard.h"

-#include "config.h"

-

-#ifdef USE_I2C

-#  include "i2c.h"

-#else

-#  include "serial.h"

-#endif

-

-volatile bool isLeftHand = true;

-

-static void setup_handedness(void) {

-  #ifdef EE_HANDS

-    isLeftHand = eeprom_read_byte(EECONFIG_HANDEDNESS);

-  #else

-    // I2C_MASTER_RIGHT is deprecated use MASTER_RIGHT instead since this works for both serial and i2c

-    #if defined(I2C_MASTER_RIGHT) || defined(MASTER_RIGHT)

-      isLeftHand = !has_usb();

-    #else

-      isLeftHand = has_usb();

-    #endif

-  #endif

-}

-

-static void keyboard_master_setup(void) {

-#ifdef USE_I2C

-    i2c_master_init();

-#else

-    serial_master_init();

-#endif

-}

-

-static void keyboard_slave_setup(void) {

-#ifdef USE_I2C

-    i2c_slave_init(SLAVE_I2C_ADDRESS);

-#else

-    serial_slave_init();

-#endif

-}

-

-bool has_usb(void) {

-   USBCON |= (1 << OTGPADE); //enables VBUS pad

-   _delay_us(5);

-   return (USBSTA & (1<<VBUS));  //checks state of VBUS

-}

-

-void split_keyboard_setup(void) {

-   setup_handedness();

-

-   if (has_usb()) {

-      keyboard_master_setup();

-   } else {

-      keyboard_slave_setup();

-   }

-   sei();

-}

-

-void keyboard_slave_loop(void) {

-   matrix_init();

-

-   while (1) {

-      matrix_slave_scan();

-   }

-}

-

-// this code runs before the usb and keyboard is initialized

-void matrix_setup(void) {

-    split_keyboard_setup();

-

-    if (!has_usb()) {

-        keyboard_slave_loop();

-    }

-}

+#include <avr/io.h>
+#include <avr/wdt.h>
+#include <avr/power.h>
+#include <avr/interrupt.h>
+#include <util/delay.h>
+#include <avr/eeprom.h>
+#include "split_util.h"
+#include "matrix.h"
+#include "keyboard.h"
+#include "config.h"
+
+#ifdef USE_I2C
+#  include "i2c.h"
+#else
+#  include "serial.h"
+#endif
+
+volatile bool isLeftHand = true;
+
+static void setup_handedness(void) {
+  #ifdef EE_HANDS
+    isLeftHand = eeprom_read_byte(EECONFIG_HANDEDNESS);
+  #else
+    // I2C_MASTER_RIGHT is deprecated use MASTER_RIGHT instead since this works for both serial and i2c
+    #if defined(I2C_MASTER_RIGHT) || defined(MASTER_RIGHT)
+      isLeftHand = !has_usb();
+    #else
+      isLeftHand = has_usb();
+    #endif
+  #endif
+}
+
+static void keyboard_master_setup(void) {
+#ifdef USE_I2C
+    i2c_master_init();
+#else
+    serial_master_init();
+#endif
+}
+
+static void keyboard_slave_setup(void) {
+#ifdef USE_I2C
+    i2c_slave_init(SLAVE_I2C_ADDRESS);
+#else
+    serial_slave_init();
+#endif
+}
+
+bool has_usb(void) {
+   USBCON |= (1 << OTGPADE); //enables VBUS pad
+   _delay_us(5);
+   return (USBSTA & (1<<VBUS));  //checks state of VBUS
+}
+
+void split_keyboard_setup(void) {
+   setup_handedness();
+
+   if (has_usb()) {
+      keyboard_master_setup();
+   } else {
+      keyboard_slave_setup();
+   }
+   sei();
+}
+
+void keyboard_slave_loop(void) {
+   matrix_init();
+
+   while (1) {
+      matrix_slave_scan();
+   }
+}
+
+// this code runs before the usb and keyboard is initialized
+void matrix_setup(void) {
+    split_keyboard_setup();
+
+    if (!has_usb()) {
+        keyboard_slave_loop();
+    }
+}
diff --git a/keyboards/deltasplit75/split_util.h b/keyboards/deltasplit75/split_util.h
index a1b0447bbd..6b896679ca 100644
--- a/keyboards/deltasplit75/split_util.h
+++ b/keyboards/deltasplit75/split_util.h
@@ -1,22 +1,22 @@
-#ifndef SPLIT_KEYBOARD_UTIL_H

-#define SPLIT_KEYBOARD_UTIL_H

-

-#include <stdbool.h>

-

-#ifdef EE_HANDS

-	#define EECONFIG_BOOTMAGIC_END      (uint8_t *)10

-	#define EECONFIG_HANDEDNESS         EECONFIG_BOOTMAGIC_END

-#endif

-

-#define SLAVE_I2C_ADDRESS           0x32

-

-extern volatile bool isLeftHand;

-

-// slave version of matix scan, defined in matrix.c

-void matrix_slave_scan(void);

-

-void split_keyboard_setup(void);

-bool has_usb(void);

-void keyboard_slave_loop(void);

-

-#endif

+#ifndef SPLIT_KEYBOARD_UTIL_H
+#define SPLIT_KEYBOARD_UTIL_H
+
+#include <stdbool.h>
+
+#ifdef EE_HANDS
+	#define EECONFIG_BOOTMAGIC_END      (uint8_t *)10
+	#define EECONFIG_HANDEDNESS         EECONFIG_BOOTMAGIC_END
+#endif
+
+#define SLAVE_I2C_ADDRESS           0x32
+
+extern volatile bool isLeftHand;
+
+// slave version of matix scan, defined in matrix.c
+void matrix_slave_scan(void);
+
+void split_keyboard_setup(void);
+bool has_usb(void);
+void keyboard_slave_loop(void);
+
+#endif