Remove accidental xeal60 commit

5 years ago · 3949ab322d
--- a/keyboards/handwired/xeal60/config.h
+++ b/keyboards/handwired/xeal60/config.h
@ -1,24 +0,0 @@
 /*
 Copyright 2012 Jun Wako <wakojun@gmail.com>
 Copyright 2015 Jack Humbert

 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/>.
 */

 #ifndef CONFIG_H
 #define CONFIG_H

 #include "config_common.h"

 #endif
--- a/keyboards/handwired/xeal60/info.json
+++ b/keyboards/handwired/xeal60/info.json
@ -1,12 +0,0 @@
 {
  "keyboard_name": "Let's Split",
  "url": "",
  "maintainer": "qmk",
  "width": 13,
  "height": 4,
  "layouts": {
    "LAYOUT": {
      "layout": [{"x":0, "y":0}, {"x":1, "y":0}, {"x":2, "y":0}, {"x":3, "y":0}, {"x":4, "y":0}, {"x":5, "y":0}, {"x":7, "y":0}, {"x":8, "y":0}, {"x":9, "y":0}, {"x":10, "y":0}, {"x":11, "y":0}, {"x":12, "y":0}, {"x":0, "y":1}, {"x":1, "y":1}, {"x":2, "y":1}, {"x":3, "y":1}, {"x":4, "y":1}, {"x":5, "y":1}, {"x":7, "y":1}, {"x":8, "y":1}, {"x":9, "y":1}, {"x":10, "y":1}, {"x":11, "y":1}, {"x":12, "y":1}, {"x":0, "y":2}, {"x":1, "y":2}, {"x":2, "y":2}, {"x":3, "y":2}, {"x":4, "y":2}, {"x":5, "y":2}, {"x":7, "y":2}, {"x":8, "y":2}, {"x":9, "y":2}, {"x":10, "y":2}, {"x":11, "y":2}, {"x":12, "y":2}, {"x":0, "y":3}, {"x":1, "y":3}, {"x":2, "y":3}, {"x":3, "y":3}, {"x":4, "y":3}, {"x":5, "y":3}, {"x":7, "y":3}, {"x":8, "y":3}, {"x":9, "y":3}, {"x":10, "y":3}, {"x":11, "y":3}, {"x":12, "y":3}]
    }
  }
 }
--- a/keyboards/handwired/xeal60/keymaps/default/config.h
+++ b/keyboards/handwired/xeal60/keymaps/default/config.h
@ -1,37 +0,0 @@
 /*
 This is the c configuration file for the keymap

 Copyright 2012 Jun Wako <wakojun@gmail.com>
 Copyright 2015 Jack Humbert

 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/>.
 */

 #ifndef CONFIG_USER_H
 #define CONFIG_USER_H

 #include "../../config.h"

 /* Use I2C or Serial, not both */

 #define USE_SERIAL
 // #define USE_I2C

 /* Select hand configuration */

 #define MASTER_LEFT
 // #define MASTER_RIGHT
 // #define EE_HANDS

 #endif
--- a/keyboards/handwired/xeal60/keymaps/default/keymap.c
+++ b/keyboards/handwired/xeal60/keymaps/default/keymap.c
@ -1,129 +0,0 @@
 #include QMK_KEYBOARD_H

 extern keymap_config_t keymap_config;

 // Each layer gets a name for readability, which is then used in the keymap matrix below.
 // The underscores don't mean anything - you can have a layer called STUFF or any other name.
 // Layer names don't all need to be of the same length, obviously, and you can also skip them
 // entirely and just use numbers.
 #define _QWERTY 0
 #define _NUMPAD 1
 #define _RAISE 4

 enum custom_keycodes {
  QWERTY = SAFE_RANGE,
  NUMPAD, 
  RAISE
 };

 // Fillers to make layering more clear
 #define _______ KC_TRNS
 #define XXXXXXX KC_NO

 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /*
   * ,-----------------------------------------------------------.
   * |Esc~| 1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  -|  =|Backsp |
   * |-----------------------------------------------------------|
   * |Tab  |  Q|  W|  E|  R|  T|  Y|  U|  I|  O|  P|  [|  ]|  \  |
   * |-----------------------------------------------------------|
   * |FN     |  A|  S|  D|  F|  G|  H|  J|  K|  L|  ;|  '|Return |
   * |-----------------------------------------------------------|
   * |Shift   |  Z|  X|  C|  V|  B|  N|  M|  ,|  .|  /| Shift    |
   * |-----------------------------------------------------------|
   * |Ctrl|Gui |Alt | NUM | Space |  Space |Alt |FN  |Menu |Ctrl |
   * `-----------------------------------------------------------'
   */
  /* Layer 0: Qwerty */
  [_QWERTY] = LAYOUT_split60( \
    KC_ESC,   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_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, \
    RAISE,    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_LSFT,  KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH,                   KC_RSFT,   \
    KC_LCTL,  KC_LGUI, KC_LALT, NUMPAD,           KC_SPC,                             KC_SPC,  KC_RALT, RAISE,   KC_MENU, KC_RCTL  \
  ),

 /*
   * ,-----------------------------------------------------------.
   * |    |  |   |   |   |   |   |   |  /|  *|  -|   |   |       |
   * |-----------------------------------------------------------|
   * |     |   |   |   |   |   |   |  7|  8|  9|  +|   |   |     |
   * |-----------------------------------------------------------|
   * |      |   |   |   |   |   |   |  4|  5|  6|Bspc|   |Return |
   * |-----------------------------------------------------------|
   * |        |   |   |   |   |   |   |  1|  2|  3|  .|          |
   * |-----------------------------------------------------------|
   * |    |    |    | QWE |       |      0 | .  |     |    |     |
   * `-----------------------------------------------------------'
   */

  /* Layer 1: Numpad */
  [_NUMPAD] = LAYOUT_split60( \
    _______,  _______,  _______, _______,  _______,  _______,  _______,  _______,    KC_PSLS,  KC_PAST,    KC_MINUS,  _______, _______,  KC_BSPC, \
    _______,  _______,  _______, _______,  _______,  _______,  _______,     KC_7,    KC_8,        KC_9,    KC_PLUS,  _______, _______,   KC_BSLS, \
    _______,  _______,  _______, _______,  _______,  _______,  _______,     KC_4,    KC_5,        KC_6,    KC_BSPC, _______,          _______,  \
    _______,  _______,  _______, _______,  _______,  _______,  _______,     KC_1,    KC_2,        KC_3,    KC_DOT,                   _______,   \
    _______,  _______,  _______,  QWERTY,           KC_SPC,                 KC_0,  KC_DOT,       RAISE,    _______, _______  \
  ),

 /*
   * ,-----------------------------------------------------------.
   * |    |  |   |   |   |   |   |   |   |   |   |   |   |       |
   * |-----------------------------------------------------------|
   * |     |   | ^ |   |   |   |   |pUp| ^ |pDn|   |   |   |     |
   * |-----------------------------------------------------------|
   * |      | < | v | > |   |   |Hom| < | v | > |    |   |       |
   * |-----------------------------------------------------------|
   * |        |   |   |   |   |   |End|   |   |   |   |          |
   * |-----------------------------------------------------------|
   * |    |    |    |     |       |        |    |     |    |     |
   * `-----------------------------------------------------------'
   */

  /* Layer 2: RAISE */
  [_RAISE] = LAYOUT_split60( \
    _______,  _______,  _______, _______,  _______,  _______,  _______,  _______,    _______,  _______,    _______,  _______, _______,  _______, \
    _______,  _______,  _______, _______,  _______,  _______,  _______,  _______,    _______,  _______,    _______,  _______, _______,   _______, \
    _______,  _______,  _______, _______,  _______,  _______,  _______,  _______,    _______,  _______,    _______, _______,          _______,  \
    _______,  _______,  _______, _______,  _______,  _______,  _______,  _______,    _______,  _______,    _______,                   _______,   \
    _______,  _______,  _______, _______,           _______,             _______,    _______,  _______,    _______, _______  \
  )

 };

 #ifdef AUDIO_ENABLE
 float tone_qwerty[][2]     = SONG(QWERTY_SOUND);
 float tone_numpad[][2]     = SONG(DVORAK_SOUND);
 #endif

 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
  switch (keycode) {
    case QWERTY:
      if (record->event.pressed) {
        #ifdef AUDIO_ENABLE
          PLAY_SONG(tone_qwerty);
        #endif
        default_layer_set(1UL<<_QWERTY);
      }
      return false;
      break;
    case NUMPAD:
      if (record->event.pressed) {
        #ifdef AUDIO_ENABLE
          PLAY_SONG(tone_numpad);
        #endif
        default_layer_set(1UL<<_NUMPAD);
      }
      return false;
      break;
    case RAISE:
      if (record->event.pressed) {
        layer_on(_RAISE);
      } else {
        layer_off(_RAISE);
      }
      return false;
      break;
  }
  return true;
 }
--- a/keyboards/handwired/xeal60/keymaps/default/rules.mk
+++ b/keyboards/handwired/xeal60/keymaps/default/rules.mk
@ -1,3 +0,0 @@
 ifndef QUANTUM_DIR
 	include ../../../../Makefile
 endif
--- a/keyboards/handwired/xeal60/lets_split.c
+++ b/keyboards/handwired/xeal60/lets_split.c
@ -1 +0,0 @@
 #include "lets_split.h"
--- a/keyboards/handwired/xeal60/lets_split.h
+++ b/keyboards/handwired/xeal60/lets_split.h
@ -1,28 +0,0 @@
 #ifndef LETS_SPLIT_H
 #define LETS_SPLIT_H

 #include "quantum.h"

 #ifdef KEYBOARD_lets_split_rev1
    #include "rev1.h"
 #endif


 // Used to create a keymap using only KC_ prefixed keys
 #define LAYOUT_kc( \
    L00, L01, L02, L03, L04, L05, L06, L07, R00, R01, R02, R03, R04, R05, R06, R07, \
    L10, L11, L12, L13, L14, L15, L16, L17, R10, R11, R12, R13, R14, R15, R16, R17, \
    L20, L21, L22, L23, L24, L25, L26, L27, R20, R21, R22, R23, R24, R25, R26, R27, \
    L30, L31, L32, L33, L34, L35, L36, L37, R30, R31, R32, R33, R34, R35, R36, R37, \
    L40, L41, L42, L43, L44, L45, L46, L47, R40, R41, R42, R43, R44, R45, R46, R47 \
    ) \
    LAYOUT( \
        KC_##L00, KC_##L01, KC_##L02, KC_##L03, KC_##L04, KC_##L05, KC_##L06, KC_##L07, KC_##R00, KC_##R01, KC_##R02, KC_##R03, KC_##R04, KC_##R05, KC_##R06, KC_##R07,\
        KC_##L10, KC_##L11, KC_##L12, KC_##L13, KC_##L14, KC_##L15, KC_##L16, KC_##L17, KC_##R10, KC_##R11, KC_##R12, KC_##R13, KC_##R14, KC_##R15, KC_##R16, KC_##R17,\
        KC_##L20, KC_##L21, KC_##L22, KC_##L23, KC_##L24, KC_##L25, KC_##L26, KC_##L27, KC_##R20, KC_##R21, KC_##R22, KC_##R23, KC_##R24, KC_##R25, KC_##R26, KC_##R27,\
        KC_##L30, KC_##L31, KC_##L32, KC_##L33, KC_##L34, KC_##L35, KC_##L36, KC_##L37, KC_##R30, KC_##R31, KC_##R32, KC_##R33, KC_##R34, KC_##R35, KC_##R36, KC_##R37 \
    )

 #define LAYOUT_XEAL LAYOUT_kc

 #endif
--- a/keyboards/handwired/xeal60/matrix.c
+++ b/keyboards/handwired/xeal60/matrix.c
@ -1,470 +0,0 @@
 /*
 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 "wait.h"
 #include "print.h"
 #include "debug.h"
 #include "util.h"
 #include "matrix.h"
 #include "split_util.h"
 #include "pro_micro.h"
 #include "config.h"
 #include "timer.h"

 #ifdef USE_I2C
 #  include "i2c.h"
 #else // USE_SERIAL
 #  include "serial.h"
 #endif

 #ifndef DEBOUNCING_DELAY
 #   define DEBOUNCING_DELAY 5
 #endif

 #if (DEBOUNCING_DELAY > 0)
    static uint16_t debouncing_time;
    static bool debouncing = false;
 #endif

 #if (MATRIX_COLS <= 8)
 #    define print_matrix_header()  print("\nr/c 01234567\n")
 #    define print_matrix_row(row)  print_bin_reverse8(matrix_get_row(row))
 #    define matrix_bitpop(i)       bitpop(matrix[i])
 #    define ROW_SHIFTER ((uint8_t)1)
 #else
 #    error "Currently only supports 8 COLS"
 #endif
 static matrix_row_t matrix_debouncing[MATRIX_ROWS];

 #define ERROR_DISCONNECT_COUNT 5

 #define 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];

 #if (DIODE_DIRECTION == COL2ROW)
    static void init_cols(void);
    static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row);
    static void unselect_rows(void);
    static void select_row(uint8_t row);
    static void unselect_row(uint8_t row);
 #elif (DIODE_DIRECTION == ROW2COL)
    static void init_rows(void);
    static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col);
    static void unselect_cols(void);
    static void unselect_col(uint8_t col);
    static void select_col(uint8_t col);
 #endif

 __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) {
 }

 __attribute__ ((weak))
 void matrix_slave_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)
 {
 #ifdef DISABLE_JTAG
  // JTAG disable for PORT F. write JTD bit twice within four cycles.
  MCUCR |= (1<<JTD);
  MCUCR |= (1<<JTD);
 #endif

    debug_enable = true;
    debug_matrix = true;
    debug_mouse = true;
    // initialize row and col
 #if (DIODE_DIRECTION == COL2ROW)
    unselect_rows();
    init_cols();
 #elif (DIODE_DIRECTION == ROW2COL)
    unselect_cols();
    init_rows();
 #endif

    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)
 {
    int offset = isLeftHand ? 0 : (ROWS_PER_HAND);
 #if (DIODE_DIRECTION == COL2ROW)
    // Set row, read cols
    for (uint8_t current_row = 0; current_row < ROWS_PER_HAND; current_row++) {
 #       if (DEBOUNCING_DELAY > 0)
            bool matrix_changed = read_cols_on_row(matrix_debouncing+offset, current_row);

            if (matrix_changed) {
                debouncing = true;
                debouncing_time = timer_read();
            }

 #       else
            read_cols_on_row(matrix+offset, current_row);
 #       endif

    }

 #elif (DIODE_DIRECTION == ROW2COL)
    // Set col, read rows
    for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
 #       if (DEBOUNCING_DELAY > 0)
            bool matrix_changed = read_rows_on_col(matrix_debouncing+offset, current_col);
            if (matrix_changed) {
                debouncing = true;
                debouncing_time = timer_read();
            }
 #       else
             read_rows_on_col(matrix+offset, current_col);
 #       endif

    }
 #endif

 #   if (DEBOUNCING_DELAY > 0)
        if (debouncing && (timer_elapsed(debouncing_time) > DEBOUNCING_DELAY)) {
            for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
                matrix[i+offset] = matrix_debouncing[i+offset];
            }
            debouncing = false;
        }
 #   endif

    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)
 {
    uint8_t 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 : ROWS_PER_HAND;

 #ifdef USE_I2C
    for (int i = 0; i < ROWS_PER_HAND; ++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
    matrix_slave_scan_user();
 }

 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;
 }

 #if (DIODE_DIRECTION == COL2ROW)

 static void init_cols(void)
 {
    for(uint8_t x = 0; x < MATRIX_COLS; x++) {
        uint8_t pin = col_pins[x];
        _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
        _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
    }
 }

 static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
 {
    // Store last value of row prior to reading
    matrix_row_t last_row_value = current_matrix[current_row];

    // Clear data in matrix row
    current_matrix[current_row] = 0;

    // Select row and wait for row selecton to stabilize
    select_row(current_row);
    wait_us(30);

    // For each col...
    for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {

        // Select the col pin to read (active low)
        uint8_t pin = col_pins[col_index];
        uint8_t pin_state = (_SFR_IO8(pin >> 4) & _BV(pin & 0xF));

        // Populate the matrix row with the state of the col pin
        current_matrix[current_row] |=  pin_state ? 0 : (ROW_SHIFTER << col_index);
    }

    // Unselect row
    unselect_row(current_row);

    return (last_row_value != current_matrix[current_row]);
 }

 static void select_row(uint8_t row)
 {
    uint8_t pin = row_pins[row];
    _SFR_IO8((pin >> 4) + 1) |=  _BV(pin & 0xF); // OUT
    _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
 }

 static void unselect_row(uint8_t row)
 {
    uint8_t pin = row_pins[row];
    _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
    _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
 }

 static void unselect_rows(void)
 {
    for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
        uint8_t pin = row_pins[x];
        _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
        _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
    }
 }

 #elif (DIODE_DIRECTION == ROW2COL)

 static void init_rows(void)
 {
    for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
        uint8_t pin = row_pins[x];
        _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
        _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
    }
 }

 static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
 {
    bool matrix_changed = false;

    // Select col and wait for col selecton to stabilize
    select_col(current_col);
    wait_us(30);

    // For each row...
    for(uint8_t row_index = 0; row_index < ROWS_PER_HAND; row_index++)
    {

        // Store last value of row prior to reading
        matrix_row_t last_row_value = current_matrix[row_index];

        // Check row pin state
        if ((_SFR_IO8(row_pins[row_index] >> 4) & _BV(row_pins[row_index] & 0xF)) == 0)
        {
            // Pin LO, set col bit
            current_matrix[row_index] |= (ROW_SHIFTER << current_col);
        }
        else
        {
            // Pin HI, clear col bit
            current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
        }

        // Determine if the matrix changed state
        if ((last_row_value != current_matrix[row_index]) && !(matrix_changed))
        {
            matrix_changed = true;
        }
    }

    // Unselect col
    unselect_col(current_col);

    return matrix_changed;
 }

 static void select_col(uint8_t col)
 {
    uint8_t pin = col_pins[col];
    _SFR_IO8((pin >> 4) + 1) |=  _BV(pin & 0xF); // OUT
    _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
 }

 static void unselect_col(uint8_t col)
 {
    uint8_t pin = col_pins[col];
    _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
    _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
 }

 static void unselect_cols(void)
 {
    for(uint8_t x = 0; x < MATRIX_COLS; x++) {
        uint8_t pin = col_pins[x];
        _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
        _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
    }
 }

 #endif
--- a/keyboards/handwired/xeal60/readme.md
+++ b/keyboards/handwired/xeal60/readme.md
@ -1,187 +0,0 @@
 Let's Split
 ======

 This readme and most of the code are from https://github.com/ahtn/tmk_keyboard/

 Split keyboard firmware for Arduino Pro Micro or other ATmega32u4
 based boards.

 **Hardware files for the Let's Split are now stored at http://qmk.fm/lets_split/**
 **Hardware files for the sockets version can be found at https://github.com/dumle29/let-s-Split-v2/tree/socket-reverseable**

 ## Build Guide

 A build guide for putting together the Let's Split v2 can be found here: [An Overly Verbose Guide to Building a Let's Split Keyboard](https://github.com/nicinabox/lets-split-guide)

 There is additional information there about flashing and adding RGB underglow.

 A build guide for putting together the sockets version can be found here: *Guide will be made and linked here when the PCBs have been received and tested*

 ## First Time Setup

 Download or clone the `qmk_firmware` repo and navigate to its top level directory. Once your build environment is setup, you'll be able to generate the default .hex using:

 ```
 $ make lets_split/rev2:default
 ```

 You will see a lot of output and if everything worked correctly you will see the built hex file:

 ```
 lets_split_rev2_default.hex
 ```

 If you would like to use one of the alternative keymaps, or create your own, copy one of the existing [keymaps](keymaps/) and run make like so:


 ```
 $ make lets_split/rev2:YOUR_KEYMAP_NAME
 ```

 If everything worked correctly you will see a file:

 ```
 lets_split_rev2_YOUR_KEYMAP_NAME.hex
 ```

 For more information on customizing keymaps, take a look at the primary documentation for [Customizing Your Keymap](/docs/faq_keymap.md) in the main readme.md.

 ### Let's split 1.0
 If you have a first generation Let's Split you will need to use the revision 1 code. To do so, use `rev1` in all your commands instead.

 Features
 --------

 For the full Quantum Mechanical Keyboard feature list, see [the parent readme.md](/readme.md).

 Some features supported by the firmware:

 * Either half can connect to the computer via USB, or both halves can be used
  independently.
 * You only need 3 wires to connect the two halves. Two for VCC and GND and one
  for serial communication.
 * Optional support for I2C connection between the two halves if for some
  reason you require a faster connection between the two halves. Note this
  requires an extra wire between halves and pull-up resistors on the data lines.

 Required Hardware
 -----------------

 Apart from diodes and key switches for the keyboard matrix in each half, you
 will need:

 * 2 Arduino Pro Micros. You can find these on AliExpress for ≈3.50USD each.
 * 2 TRRS sockets and 1 TRRS cable, or 2 TRS sockets and 1 TRS cable

 Alternatively, you can use any sort of cable and socket that has at least 3
 wires. If you want to use I2C to communicate between halves, you will need a
 cable with at least 4 wires and 2x 4.7kΩ pull-up resistors

 Optional Hardware
 -----------------

 A speaker can be hooked-up to either side to the `5` (`C6`) pin and `GND`, and turned on via `AUDIO_ENABLE`.

 Wiring
 ------

 The 3 wires of the TRS/TRRS cable need to connect GND, VCC, and digital pin 3 (i.e.
 PD0 on the ATmega32u4) between the two Pro Micros.

 Next, wire your key matrix to any of the remaining 17 IO pins of the pro micro
 and modify the `matrix.c` accordingly.

 The wiring for serial:

 ![serial wiring](https://i.imgur.com/C3D1GAQ.png)

 The wiring for i2c:

 ![i2c wiring](https://i.imgur.com/Hbzhc6E.png)

 The pull-up resistors may be placed on either half. It is also possible
 to use 4 resistors and have the pull-ups in both halves, but this is
 unnecessary in simple use cases.

 You can change your configuration between serial and i2c by modifying your `config.h` file.

 Notes on Software Configuration
 -------------------------------

 Configuring the firmware is similar to any other QMK project. One thing
 to note is that `MATRIX_ROWS` in `config.h` is the total number of rows between
 the two halves, i.e. if your split keyboard has 4 rows in each half, then use
 `MATRIX_ROWS=8`.

 Also, the current implementation assumes a maximum of 8 columns, but it would
 not be very difficult to adapt it to support more if required.

 Flashing
 -------
 From the top level `qmk_firmware` directory run `make KEYBOARD:KEYMAP:avrdude` for automatic serial port resolution and flashing.
 Example: `make lets_split/rev2:default:avrdude`


 Choosing which board to plug the USB cable into (choosing Master)
 --------
 Because the two boards are identical, the firmware has logic to differentiate the left and right board.

 It uses two strategies to figure things out: looking at the EEPROM (memory on the chip) or looking if the current board has the usb cable.

 The EEPROM approach requires additional setup (flashing the eeprom) but allows you to swap the usb cable to either side.

 The USB cable approach is easier to setup and if you just want the usb cable on the left board, you do not need to do anything extra.

 ### Setting the left hand as master
 If you always plug the usb cable into the left board, nothing extra is needed as this is the default. Comment out `EE_HANDS` and comment out `I2C_MASTER_RIGHT` or `MASTER_RIGHT` if for some reason it was set.

 ### Setting the right hand as master
 If you always plug the usb cable into the right board, add an extra flag to your `config.h`
 ```
 #define MASTER_RIGHT
 ```

 ### Setting EE_hands to use either hands as master
 If you define `EE_HANDS` in your `config.h`, you will need to set the
 EEPROM for the left and right halves.

 The EEPROM is used to store whether the
 half is left handed or right handed. This makes it so that the same firmware
 file will run on both hands instead of having to flash left and right handed
 versions of the firmware to each half. To flash the EEPROM file for the left
 half run:
 ```
 avrdude -p atmega32u4 -P $(COM_PORT) -c avr109 -U eeprom:w:eeprom-lefthand.eep
 // or the equivalent in dfu-programmer

 ```
 and similarly for right half
 ```
 avrdude -p atmega32u4 -P $(COM_PORT) -c avr109 -U eeprom:w:eeprom-righhand.eep
 // or the equivalent in dfu-programmer
 ```

 NOTE: replace `$(COM_PORT)` with the port of your device (e.g. `/dev/ttyACM0`)

 After you have flashed the EEPROM, you then need to set `EE_HANDS` in your config.h, rebuild the hex files and reflash.

 Note that you need to program both halves, but you have the option of using
 different keymaps for each half. You could program the left half with a QWERTY
 layout and the right half with a Colemak layout using bootmagic's default layout option.
 Then if you connect the left half to a computer by USB the keyboard will use QWERTY and Colemak when the
 right half is connected.


 Notes on Using Pro Micro 3.3V
 -----------------------------

 Do update the `F_CPU` parameter in `rules.mk` to `8000000` which reflects
 the frequency on the 3.3V board.

 Also, if the slave board is producing weird characters in certain columns,
 update the following line in `matrix.c` to the following:

 ```
 // _delay_us(30);  // without this wait read unstable value.
 _delay_us(300);  // without this wait read unstable value.
 ```
--- a/keyboards/handwired/xeal60/rev1/config.h
+++ b/keyboards/handwired/xeal60/rev1/config.h
@ -1,93 +0,0 @@
 /*
 Copyright 2012 Jun Wako <wakojun@gmail.com>
 Copyright 2015 Jack Humbert

 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/>.
 */

 #ifndef REV1_CONFIG_H
 #define REV1_CONFIG_H

 #include "config_common.h"

 /* USB Device descriptor parameter */
 #define VENDOR_ID       0x4131
 #define PRODUCT_ID      0x5141
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    XeaLouS
 #define PRODUCT         XeaL60
 #define DESCRIPTION     A split keyboard 

 /* key matrix size */
 // Rows are doubled-up
 #define MATRIX_ROWS 10
 #define MATRIX_COLS 8

 // wiring of each half
 //ascii art of pro micro
 //        PORT          
 //PD3 TX0        RAW    
 //PD2 RX1        GND
 //    GND        RESET
 //    GND        VCC
 //PD1 2          A3  PF4
 //PD0 3          A2  PF5
 //PD4 4          A1  PF6
 //PC6 5          A0  PF7
 //PD7 6          15  PB1
 //PE6 7          14  PB3
 //PB4 8          13  PB2
 //PB5 9          10  PB6

 #define MATRIX_ROW_PINS { B5, B4, E6, D7, C6 }
 #define MATRIX_COL_PINS { B6, B2, B3, B1, F7, F6, F5 }

 /* define if matrix has ghost */
 //#define MATRIX_HAS_GHOST

 /* number of backlight levels */
 // #define BACKLIGHT_LEVELS 3

 /* Set 0 if debouncing isn't needed */
 #define DEBOUNCING_DELAY 5

 /* 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

 /* key combination for command */
 #define IS_COMMAND() ( \
    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
 )

 /*
 * Feature disable options
 *  These options are also useful to firmware size reduction.
 */

 /* disable debug print */
 // #define NO_DEBUG

 /* disable print */
 // #define NO_PRINT

 /* disable action features */
 //#define NO_ACTION_LAYER
 //#define NO_ACTION_TAPPING
 //#define NO_ACTION_ONESHOT
 //#define NO_ACTION_MACRO
 //#define NO_ACTION_FUNCTION

 #endif
--- a/keyboards/handwired/xeal60/rev1/rev1.c
+++ b/keyboards/handwired/xeal60/rev1/rev1.c
@ -1,15 +0,0 @@
 #include "lets_split.h"

 void matrix_init_kb(void) {

    // // green led on
    // DDRD |= (1<<5);
    // PORTD &= ~(1<<5);

    // // orange led on
    // DDRB |= (1<<0);
    // PORTB &= ~(1<<0);

 	matrix_init_user();
 };

--- a/keyboards/handwired/xeal60/rev1/rev1.h
+++ b/keyboards/handwired/xeal60/rev1/rev1.h
@ -1,33 +0,0 @@
 #ifndef REV1_H
 #define REV1_H

 #include "lets_split.h"

 //void promicro_bootloader_jmp(bool program);
 #include "quantum.h"

 //void promicro_bootloader_jmp(bool program);

 #define LAYOUT( \
 	L00, L01, L02, L03, L04, L05, L06,      R00, R01, R02, R03, R04, R05, R06, \
 	L10, L11, L12, L13, L14, L15, L16, L17,      R11, R12, R13, R14, R15, R16, \
 	L20, L21, L22, L23, L24, L25, L26,           R21, R22, R23, R24, R25, R26, \
 	L30, L31, L32, L33, L34, L35,                R31, R32, R33, R34, R35, R36, \
  L40, L41, L42, L43, L44,                          R42, R43, R44, R45, R46 \
 	) \
 	{ \
  	{ L00, L01, L02, L03, L04, L05, L06 }, \
 	  { L10, L11, L12, L13, L14, L15, L16, L17 }, \
 	  { L20, L21, L22, L23, L24, L25, L26 }, \
 	  { L30, L31, L32, L33, L34, L35 }, \
    { L40, L41, L42, L43, L44 }, \
    { R00, R01, R02, R03, R04, R05, R06}, \
    { R11, R12, R13, R14, R15, R16 }, \
    { R21, R22, R23, R24, R25, R26 }, \
    { R31, R32, R33, R34, R35, R36 }, \
    { R42, R43, R44, R45, R46 } \
 	}

 #define LAYOUT_split60 LAYOUT

 #endif
--- a/keyboards/handwired/xeal60/rev1/rules.mk
+++ b/keyboards/handwired/xeal60/rev1/rules.mk
@ -1 +0,0 @@
 BACKLIGHT_ENABLE = no
--- a/keyboards/handwired/xeal60/rules.mk
+++ b/keyboards/handwired/xeal60/rules.mk
@ -1,77 +0,0 @@
 SRC += matrix.c \
 	   split_util.c \
 	   serial.c \
 	   ssd1306.c

 # MCU name
 #MCU = at90usb1287
 MCU = atmega32u4

 # Processor frequency.
 #     This will define a symbol, F_CPU, in all source code files equal to the
 #     processor frequency in Hz. You can then use this symbol in your source code to
 #     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
 #     automatically to create a 32-bit value in your source code.
 #
 #     This will be an integer division of F_USB below, as it is sourced by
 #     F_USB after it has run through any CPU prescalers. Note that this value
 #     does not *change* the processor frequency - it should merely be updated to
 #     reflect the processor speed set externally so that the code can use accurate
 #     software delays.
 F_CPU = 16000000

 #
 # LUFA specific
 #
 # Target architecture (see library "Board Types" documentation).
 ARCH = AVR8

 # Input clock frequency.
 #     This will define a symbol, F_USB, in all source code files equal to the
 #     input clock frequency (before any prescaling is performed) in Hz. This value may
 #     differ from F_CPU if prescaling is used on the latter, and is required as the
 #     raw input clock is fed directly to the PLL sections of the AVR for high speed
 #     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
 #     at the end, this will be done automatically to create a 32-bit value in your
 #     source code.
 #
 #     If no clock division is performed on the input clock inside the AVR (via the
 #     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
 F_USB = $(F_CPU)

 # Bootloader
 #     This definition is optional, and if your keyboard supports multiple bootloaders of
 #     different sizes, comment this out, and the correct address will be loaded 
 #     automatically (+60). See bootloader.mk for all options.
 BOOTLOADER = caterina

 # Interrupt driven control endpoint task(+60)
 OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT

 # Build Options
 #   change to "no" to disable the options, or define them in the Makefile in
 #   the appropriate keymap folder that will get included automatically
 #
 BOOTMAGIC_ENABLE = yes      # Virtual DIP switch configuration(+1000)
 MOUSEKEY_ENABLE = no        # 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
 NKRO_ENABLE = yes           # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
 BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality
 MIDI_ENABLE = no            # MIDI controls
 AUDIO_ENABLE = no           # Audio output on port C6
 UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 RGBLIGHT_ENABLE = no        # Enable WS2812 RGB underlight.  Do not enable this with audio at the same time.
 SUBPROJECT_rev1 = yes
 USE_I2C = no

 # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
 SLEEP_LED_ENABLE = no    # Breathing sleep LED during USB suspend

 CUSTOM_MATRIX = yes

 LAYOUTS = ortho_4x12

 DEFAULT_FOLDER = lets_split/rev2
--- a/keyboards/handwired/xeal60/serial.c
+++ b/keyboards/handwired/xeal60/serial.c
@ -1,228 +0,0 @@
 /*
 * 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"

 #ifndef USE_I2C

 // 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
--- a/keyboards/handwired/xeal60/serial.h
+++ b/keyboards/handwired/xeal60/serial.h
@ -1,26 +0,0 @@
 #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_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
--- a/keyboards/handwired/xeal60/split_util.c
+++ b/keyboards/handwired/xeal60/split_util.c
@ -1,86 +0,0 @@
 #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"
 #include "timer.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();
 #ifdef SSD1306OLED
    matrix_master_OLED_init ();
 #endif
 #else
    serial_master_init();
 #endif
 }

 static void keyboard_slave_setup(void) {
  timer_init();
 #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();
    }
 }
--- a/keyboards/handwired/xeal60/split_util.h
+++ b/keyboards/handwired/xeal60/split_util.h
@ -1,20 +0,0 @@
 #ifndef SPLIT_KEYBOARD_UTIL_H
 #define SPLIT_KEYBOARD_UTIL_H

 #include <stdbool.h>
 #include "eeconfig.h"

 #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);

 void matrix_master_OLED_init (void);

 #endif