Add support for Meira

23 files changed, 2186 insertions, 0 deletions

diff --git a/keyboards/meira/TWIlib.c b/keyboards/meira/TWIlib.c
new file mode 100755
index 0000000000..8e0c974381
--- /dev/null
+++ b/keyboards/meira/TWIlib.c
@@ -0,0 +1,287 @@
+/*
+ * TWIlib.c
+ *
+ *  Created: 6/01/2014 10:41:33 PM
+ *  Author: Chris Herring
+ */
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include "TWIlib.h"
+#include "util/delay.h"
+#include "print.h"
+
+void TWIInit()
+{
+	TWIInfo.mode = Ready;
+	TWIInfo.errorCode = 0xFF;
+	TWIInfo.repStart = 0;
+	// Set pre-scalers (no pre-scaling)
+	TWSR = 0;
+	// Set bit rate
+	TWBR = ((F_CPU / TWI_FREQ) - 16) / 2;
+	// Enable TWI and interrupt
+	TWCR = (1 << TWIE) | (1 << TWEN);
+}
+
+uint8_t isTWIReady()
+{
+	if ( (TWIInfo.mode == Ready) | (TWIInfo.mode == RepeatedStartSent) )
+	{
+
+//        xprintf("i2c ready\n");
+		return 1;
+	}
+	else
+	{
+		if(TWIInfo.mode == Initializing){
+			switch(TWIInfo.errorCode){
+		        case TWI_SUCCESS:
+		            break;
+		        case TWI_NO_RELEVANT_INFO:
+
+		        	break;
+				case TWI_LOST_ARBIT:
+				case TWI_MT_DATA_NACK:
+					// Some kind of I2C error, reset and re-init
+		        	xprintf("I2C init error: %d\n", TWIInfo.errorCode);
+			        TWCR = (1 << TWINT)|(1 << TWSTO);
+		        	TWIInit();
+		        	break;
+		        default:
+		        	xprintf("Other i2c init error: %d\n", TWIInfo.errorCode);
+			}
+		}
+		return 0;
+	}
+}
+
+
+void TWITransmitData(void *const TXdata, uint8_t dataLen, uint8_t repStart, uint8_t blocking)
+{
+	// Wait until ready
+	while (!isTWIReady()) {_delay_us(1);}
+	// Reset the I2C stuff
+	TWCR = (1 << TWINT)|(1 << TWSTO);
+	TWIInit();
+	// Set repeated start mode
+	TWIInfo.repStart = repStart;
+	// Copy transmit info to global variables
+	TWITransmitBuffer = (uint8_t *)TXdata;
+	TXBuffLen = dataLen;
+	TXBuffIndex = 0;
+
+	// If a repeated start has been sent, then devices are already listening for an address
+	// and another start does not need to be sent.
+	if (TWIInfo.mode == RepeatedStartSent)
+	{
+		TWIInfo.mode = Initializing;
+		TWDR = TWITransmitBuffer[TXBuffIndex++]; // Load data to transmit buffer
+		TWISendTransmit(); // Send the data
+	}
+	else // Otherwise, just send the normal start signal to begin transmission.
+	{
+		TWIInfo.mode = Initializing;
+		TWISendStart();
+	}
+	if(blocking){
+		// Wait until ready
+		while (!isTWIReady()){_delay_us(1);}
+	}
+}
+
+
+// uint8_t TWITransmitData(void *const TXdata, uint8_t dataLen, uint8_t repStart)
+// {
+// 	if (dataLen <= TXMAXBUFLEN)
+// 	{
+// 		// Wait until ready
+// 		while (!isTWIReady()) {_delay_us(1);}
+// 		// Set repeated start mode
+// 		TWIInfo.repStart = repStart;
+// 		// Copy data into the transmit buffer
+// 		uint8_t *data = (uint8_t *)TXdata;
+// 		for (int i = 0; i < dataLen; i++)
+// 		{
+// 			TWITransmitBuffer[i] = data[i];
+// 		}
+// 		// Copy transmit info to global variables
+// 		TXBuffLen = dataLen;
+// 		TXBuffIndex = 0;
+
+// 		// If a repeated start has been sent, then devices are already listening for an address
+// 		// and another start does not need to be sent.
+// 		if (TWIInfo.mode == RepeatedStartSent)
+// 		{
+// 			TWIInfo.mode = Initializing;
+// 			TWDR = TWITransmitBuffer[TXBuffIndex++]; // Load data to transmit buffer
+// 			TWISendTransmit(); // Send the data
+// 		}
+// 		else // Otherwise, just send the normal start signal to begin transmission.
+// 		{
+// 			TWIInfo.mode = Initializing;
+// 			TWISendStart();
+// 		}
+
+// 	}
+// 	else
+// 	{
+// 		return 1; // return an error if data length is longer than buffer
+// 	}
+// 	return 0;
+// }
+
+uint8_t TWIReadData(uint8_t TWIaddr, uint8_t bytesToRead, uint8_t repStart)
+{
+	// Check if number of bytes to read can fit in the RXbuffer
+	if (bytesToRead < RXMAXBUFLEN)
+	{
+		// Reset buffer index and set RXBuffLen to the number of bytes to read
+		RXBuffIndex = 0;
+		RXBuffLen = bytesToRead;
+		// Create the one value array for the address to be transmitted
+		uint8_t TXdata[1];
+		// Shift the address and AND a 1 into the read write bit (set to write mode)
+		TXdata[0] = (TWIaddr << 1) | 0x01;
+		// Use the TWITransmitData function to initialize the transfer and address the slave
+		TWITransmitData(TXdata, 1, repStart, 0);
+	}
+	else
+	{
+		return 0;
+	}
+	return 1;
+}
+
+ISR (TWI_vect)
+{
+	switch (TWI_STATUS)
+	{
+		// ----\/ ---- MASTER TRANSMITTER OR WRITING ADDRESS ----\/ ----  //
+		case TWI_MT_SLAW_ACK: // SLA+W transmitted and ACK received
+		// Set mode to Master Transmitter
+		TWIInfo.mode = MasterTransmitter;
+		case TWI_START_SENT: // Start condition has been transmitted
+		case TWI_MT_DATA_ACK: // Data byte has been transmitted, ACK received
+			if (TXBuffIndex < TXBuffLen) // If there is more data to send
+			{
+				TWDR = TWITransmitBuffer[TXBuffIndex++]; // Load data to transmit buffer
+				TWIInfo.errorCode = TWI_NO_RELEVANT_INFO;
+				TWISendTransmit(); // Send the data
+			}
+			// This transmission is complete however do not release bus yet
+			else if (TWIInfo.repStart)
+			{
+				TWIInfo.errorCode = 0xFF;
+				TWISendStart();
+			}
+			// All transmissions are complete, exit
+			else
+			{
+				TWIInfo.mode = Ready;
+				TWIInfo.errorCode = 0xFF;
+				TWISendStop();
+			}
+			break;
+
+		// ----\/ ---- MASTER RECEIVER ----\/ ----  //
+
+		case TWI_MR_SLAR_ACK: // SLA+R has been transmitted, ACK has been received
+			// Switch to Master Receiver mode
+			TWIInfo.mode = MasterReceiver;
+			// If there is more than one byte to be read, receive data byte and return an ACK
+			if (RXBuffIndex < RXBuffLen-1)
+			{
+				TWIInfo.errorCode = TWI_NO_RELEVANT_INFO;
+				TWISendACK();
+			}
+			// Otherwise when a data byte (the only data byte) is received, return NACK
+			else
+			{
+				TWIInfo.errorCode = TWI_NO_RELEVANT_INFO;
+				TWISendNACK();
+			}
+			break;
+
+		case TWI_MR_DATA_ACK: // Data has been received, ACK has been transmitted.
+
+			/// -- HANDLE DATA BYTE --- ///
+			TWIReceiveBuffer[RXBuffIndex++] = TWDR;
+			// If there is more than one byte to be read, receive data byte and return an ACK
+			if (RXBuffIndex < RXBuffLen-1)
+			{
+				TWIInfo.errorCode = TWI_NO_RELEVANT_INFO;
+				TWISendACK();
+			}
+			// Otherwise when a data byte (the only data byte) is received, return NACK
+			else
+			{
+				TWIInfo.errorCode = TWI_NO_RELEVANT_INFO;
+				TWISendNACK();
+			}
+			break;
+
+		case TWI_MR_DATA_NACK: // Data byte has been received, NACK has been transmitted. End of transmission.
+
+			/// -- HANDLE DATA BYTE --- ///
+			TWIReceiveBuffer[RXBuffIndex++] = TWDR;
+			// This transmission is complete however do not release bus yet
+			if (TWIInfo.repStart)
+			{
+				TWIInfo.errorCode = 0xFF;
+				TWISendStart();
+			}
+			// All transmissions are complete, exit
+			else
+			{
+				TWIInfo.mode = Ready;
+				TWIInfo.errorCode = 0xFF;
+				TWISendStop();
+			}
+			break;
+
+		// ----\/ ---- MT and MR common ----\/ ---- //
+
+		case TWI_MR_SLAR_NACK: // SLA+R transmitted, NACK received
+		case TWI_MT_SLAW_NACK: // SLA+W transmitted, NACK received
+		case TWI_MT_DATA_NACK: // Data byte has been transmitted, NACK received
+		case TWI_LOST_ARBIT: // Arbitration has been lost
+			// Return error and send stop and set mode to ready
+			if (TWIInfo.repStart)
+			{
+				TWIInfo.errorCode = TWI_STATUS;
+				TWISendStart();
+			}
+			// All transmissions are complete, exit
+			else
+			{
+				TWIInfo.mode = Ready;
+				TWIInfo.errorCode = TWI_STATUS;
+				TWISendStop();
+			}
+			break;
+		case TWI_REP_START_SENT: // Repeated start has been transmitted
+			// Set the mode but DO NOT clear TWINT as the next data is not yet ready
+			TWIInfo.mode = RepeatedStartSent;
+			break;
+
+		// ----\/ ---- SLAVE RECEIVER ----\/ ----  //
+
+		// TODO  IMPLEMENT SLAVE RECEIVER FUNCTIONALITY
+
+		// ----\/ ---- SLAVE TRANSMITTER ----\/ ----  //
+
+		// TODO  IMPLEMENT SLAVE TRANSMITTER FUNCTIONALITY
+
+		// ----\/ ---- MISCELLANEOUS STATES ----\/ ----  //
+		case TWI_NO_RELEVANT_INFO: // It is not really possible to get into this ISR on this condition
+								   // Rather, it is there to be manually set between operations
+			break;
+		case TWI_ILLEGAL_START_STOP: // Illegal START/STOP, abort and return error
+			TWIInfo.errorCode = TWI_ILLEGAL_START_STOP;
+			TWIInfo.mode = Ready;
+			TWISendStop();
+			break;
+	}
+
+}
diff --git a/keyboards/meira/TWIlib.h b/keyboards/meira/TWIlib.h
new file mode 100755
index 0000000000..6db3cc9513
--- /dev/null
+++ b/keyboards/meira/TWIlib.h
@@ -0,0 +1,81 @@
+/*
+ * TWIlib.h
+ *
+ * Created: 6/01/2014 10:38:42 PM
+ *  Author: Chris Herring
+ */
+
+
+#ifndef TWILIB_H_
+#define TWILIB_H_
+// TWI bit rate
+#define TWI_FREQ 400000
+// Get TWI status
+#define TWI_STATUS	(TWSR & 0xF8)
+// Transmit buffer length
+#define TXMAXBUFLEN 20
+// Receive buffer length
+#define RXMAXBUFLEN 20
+// Global transmit buffer
+volatile uint8_t *TWITransmitBuffer;
+// Global receive buffer
+volatile uint8_t TWIReceiveBuffer[RXMAXBUFLEN];
+// Buffer indexes
+volatile int TXBuffIndex; // Index of the transmit buffer. Is volatile, can change at any time.
+int RXBuffIndex; // Current index in the receive buffer
+// Buffer lengths
+int TXBuffLen; // The total length of the transmit buffer
+int RXBuffLen; // The total number of bytes to read (should be less than RXMAXBUFFLEN)
+
+typedef enum {
+	Ready,
+	Initializing,
+	RepeatedStartSent,
+	MasterTransmitter,
+	MasterReceiver,
+	SlaceTransmitter,
+	SlaveReciever
+	} TWIMode;
+
+ typedef struct TWIInfoStruct{
+	TWIMode mode;
+	uint8_t errorCode;
+	uint8_t repStart;
+	}TWIInfoStruct;
+TWIInfoStruct TWIInfo;
+
+
+// TWI Status Codes
+#define TWI_START_SENT			0x08 // Start sent
+#define TWI_REP_START_SENT		0x10 // Repeated Start sent
+// Master Transmitter Mode
+#define TWI_MT_SLAW_ACK			0x18 // SLA+W sent and ACK received
+#define TWI_MT_SLAW_NACK		0x20 // SLA+W sent and NACK received
+#define TWI_MT_DATA_ACK			0x28 // DATA sent and ACK received
+#define TWI_MT_DATA_NACK		0x30 // DATA sent and NACK received
+// Master Receiver Mode
+#define TWI_MR_SLAR_ACK			0x40 // SLA+R sent, ACK received
+#define TWI_MR_SLAR_NACK		0x48 // SLA+R sent, NACK received
+#define TWI_MR_DATA_ACK			0x50 // Data received, ACK returned
+#define TWI_MR_DATA_NACK		0x58 // Data received, NACK returned
+
+// Miscellaneous States
+#define TWI_LOST_ARBIT			0x38 // Arbitration has been lost
+#define TWI_NO_RELEVANT_INFO	0xF8 // No relevant information available
+#define TWI_ILLEGAL_START_STOP	0x00 // Illegal START or STOP condition has been detected
+#define TWI_SUCCESS				0xFF // Successful transfer, this state is impossible from TWSR as bit2 is 0 and read only
+
+
+#define TWISendStart()		(TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN)|(1<<TWIE)) // Send the START signal, enable interrupts and TWI, clear TWINT flag to resume transfer.
+#define TWISendStop()		(TWCR = (1<<TWINT)|(1<<TWSTO)|(1<<TWEN)|(1<<TWIE)) // Send the STOP signal, enable interrupts and TWI, clear TWINT flag.
+#define TWISendTransmit()	(TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWIE)) // Used to resume a transfer, clear TWINT and ensure that TWI and interrupts are enabled.
+#define TWISendACK()		(TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWIE)|(1<<TWEA)) // FOR MR mode. Resume a transfer, ensure that TWI and interrupts are enabled and respond with an ACK if the device is addressed as a slave or after it receives a byte.
+#define TWISendNACK()		(TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWIE)) // FOR MR mode. Resume a transfer, ensure that TWI and interrupts are enabled but DO NOT respond with an ACK if the device is addressed as a slave or after it receives a byte.
+
+// Function declarations
+void TWITransmitData(void *const TXdata, uint8_t dataLen, uint8_t repStart, uint8_t blocking);
+void TWIInit(void);
+uint8_t TWIReadData(uint8_t TWIaddr, uint8_t bytesToRead, uint8_t repStart);
+uint8_t isTWIReady(void);
+
+#endif // TWICOMMS_H_
\ No newline at end of file
diff --git a/keyboards/meira/config.h b/keyboards/meira/config.h
new file mode 100644
index 0000000000..e335db90fc
--- /dev/null
+++ b/keyboards/meira/config.h
@@ -0,0 +1,53 @@
+/*
+Copyright 2017 Cole Markham
+
+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"
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0x6061
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    WoodKeys.click
+#define PRODUCT         Meira
+#define DESCRIPTION     Low-profile Ortholinear Compact keyboard
+
+/* key matrix size */
+#define MATRIX_ROWS 4
+#define MATRIX_COLS 12
+
+/* COL2ROW, ROW2COL, or CUSTOM_MATRIX */
+#define DIODE_DIRECTION CUSTOM_MATRIX
+
+#define BACKLIGHT_LEVELS 10
+#define BACKLIGHT_PWM_MAP {2, 4, 8, 16, 40, 55, 70, 128, 200, 255}
+#define BACKLIGHT_BREATHING
+
+#define RGB_DI_PIN D3
+#define RGBLIGHT_TIMER
+#define RGBLED_NUM 15    // Number of LEDs
+
+#ifdef SUBPROJECT_promicro
+    #include "promicro/config.h"
+#endif
+#ifdef SUBPROJECT_featherble
+    #include "featherble/config.h"
+#endif
+
+#endif
diff --git a/keyboards/meira/featherble/config.h b/keyboards/meira/featherble/config.h
new file mode 100644
index 0000000000..ade3b2d578
--- /dev/null
+++ b/keyboards/meira/featherble/config.h
@@ -0,0 +1,175 @@
+/*
+Copyright 2017 REPLACE_WITH_YOUR_NAME
+
+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 FEATHERBLECONFIG_H
+#define FEATHERBLECONFIG_H
+
+#include "config_common.h"
+
+/*
+ * Keyboard Matrix Assignments
+ *
+ * Change this to how you wired your keyboard
+ * COLS: AVR pins used for columns, left to right
+ * ROWS: AVR pins used for rows, top to bottom
+ * DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode)
+ *                  ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
+ *
+*/
+#define MATRIX_ROW_PINS { F7, F6, F5, F4 }
+// Column pins to demux in LSB order
+#define MATRIX_COL_PINS { C7, B7, B6, C6 }
+#define LED_EN_PIN D2
+#define UNUSED_PINS
+
+#define CATERINA_BOOTLOADER
+
+ 
+// #define BACKLIGHT_PIN B7
+// #define BACKLIGHT_BREATHING
+//#define BACKLIGHT_LEVELS 3
+
+
+/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
+#define DEBOUNCING_DELAY 5
+
+/* define if matrix has ghost (lacks anti-ghosting diodes) */
+//#define MATRIX_HAS_GHOST
+
+/* number of backlight levels */
+
+/* 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
+
+/*
+ * Force NKRO
+ *
+ * Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved
+ * state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the
+ * makefile for this to work.)
+ *
+ * If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N)
+ * until the next keyboard reset.
+ *
+ * NKRO may prevent your keystrokes from being detected in the BIOS, but it is
+ * fully operational during normal computer usage.
+ *
+ * For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N)
+ * or via bootmagic (hold SPACE+N while plugging in the keyboard). Once set by
+ * bootmagic, NKRO mode will always be enabled until it is toggled again during a
+ * power-up.
+ *
+ */
+//#define FORCE_NKRO
+
+/*
+ * Magic Key Options
+ *
+ * Magic keys are hotkey commands that allow control over firmware functions of
+ * the keyboard. They are best used in combination with the HID Listen program,
+ * found here: https://www.pjrc.com/teensy/hid_listen.html
+ *
+ * The options below allow the magic key functionality to be changed. This is
+ * useful if your keyboard/keypad is missing keys and you want magic key support.
+ *
+ */
+
+/* key combination for magic key command */
+#define IS_COMMAND() ( \
+    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
+)
+
+/* control how magic key switches layers */
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS  true
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS  true
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM false
+
+/* override magic key keymap */
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM
+//#define MAGIC_KEY_HELP1          H
+//#define MAGIC_KEY_HELP2          SLASH
+//#define MAGIC_KEY_DEBUG          D
+//#define MAGIC_KEY_DEBUG_MATRIX   X
+//#define MAGIC_KEY_DEBUG_KBD      K
+//#define MAGIC_KEY_DEBUG_MOUSE    M
+//#define MAGIC_KEY_VERSION        V
+//#define MAGIC_KEY_STATUS         S
+//#define MAGIC_KEY_CONSOLE        C
+//#define MAGIC_KEY_LAYER0_ALT1    ESC
+//#define MAGIC_KEY_LAYER0_ALT2    GRAVE
+//#define MAGIC_KEY_LAYER0         0
+//#define MAGIC_KEY_LAYER1         1
+//#define MAGIC_KEY_LAYER2         2
+//#define MAGIC_KEY_LAYER3         3
+//#define MAGIC_KEY_LAYER4         4
+//#define MAGIC_KEY_LAYER5         5
+//#define MAGIC_KEY_LAYER6         6
+//#define MAGIC_KEY_LAYER7         7
+//#define MAGIC_KEY_LAYER8         8
+//#define MAGIC_KEY_LAYER9         9
+//#define MAGIC_KEY_BOOTLOADER     PAUSE
+//#define MAGIC_KEY_LOCK           CAPS
+//#define MAGIC_KEY_EEPROM         E
+//#define MAGIC_KEY_NKRO           N
+//#define MAGIC_KEY_SLEEP_LED      Z
+
+/*
+ * 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
+
+/*
+ * MIDI options
+ */
+
+/* Prevent use of disabled MIDI features in the keymap */
+//#define MIDI_ENABLE_STRICT 1
+
+/* enable basic MIDI features:
+   - MIDI notes can be sent when in Music mode is on
+*/
+//#define MIDI_BASIC
+
+/* enable advanced MIDI features:
+   - MIDI notes can be added to the keymap
+   - Octave shift and transpose
+   - Virtual sustain, portamento, and modulation wheel
+   - etc.
+*/
+//#define MIDI_ADVANCED
+
+/* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
+//#define MIDI_TONE_KEYCODE_OCTAVES 1
+
+#endif
diff --git a/keyboards/meira/featherble/featherble.c b/keyboards/meira/featherble/featherble.c
new file mode 100644
index 0000000000..560f0db297
--- /dev/null
+++ b/keyboards/meira/featherble/featherble.c
@@ -0,0 +1 @@
+#include "meira.h"
diff --git a/keyboards/meira/featherble/featherble.h b/keyboards/meira/featherble/featherble.h
new file mode 100644
index 0000000000..b7599b9941
--- /dev/null
+++ b/keyboards/meira/featherble/featherble.h
@@ -0,0 +1,9 @@
+#ifndef FEATHERBLE_H
+#define FEATHERBLE_H
+
+#include "../meira.h"
+
+#include "quantum.h"
+
+
+#endif
diff --git a/keyboards/meira/featherble/rules.mk b/keyboards/meira/featherble/rules.mk
new file mode 100644
index 0000000000..47d0e5b892
--- /dev/null
+++ b/keyboards/meira/featherble/rules.mk
@@ -0,0 +1,4 @@
+BLUETOOTH_ENABLE = yes
+BACKLIGHT_ENABLE = yes
+F_CPU = 8000000
+
diff --git a/keyboards/meira/issi.c b/keyboards/meira/issi.c
new file mode 100755
index 0000000000..600a465ba3
--- /dev/null
+++ b/keyboards/meira/issi.c
@@ -0,0 +1,286 @@
+#ifdef ISSI_ENABLE
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <util/delay.h>
+#include <avr/sfr_defs.h>
+#include <avr/io.h>
+#include <util/twi.h>
+#include "issi.h"
+#include "print.h"
+#include "TWIlib.h"
+
+#define ISSI_ADDR_DEFAULT 0xE8
+
+#define ISSI_REG_CONFIG 0x00
+#define ISSI_REG_CONFIG_PICTUREMODE 0x00
+#define ISSI_REG_CONFIG_AUTOPLAYMODE 0x08
+
+#define ISSI_CONF_PICTUREMODE 0x00
+#define ISSI_CONF_AUTOFRAMEMODE 0x04
+#define ISSI_CONF_AUDIOMODE 0x08
+
+#define ISSI_REG_PICTUREFRAME 0x01
+
+#define ISSI_REG_SHUTDOWN 0x0A
+#define ISSI_REG_AUDIOSYNC 0x06
+
+#define ISSI_COMMANDREGISTER 0xFD
+#define ISSI_BANK_FUNCTIONREG 0x0B // helpfully called 'page nine'
+uint8_t control[8][9] = {
+    {0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0},
+    {0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0},
+    {0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0},
+    {0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0},
+};
+ISSIDeviceStruct *issi_devices[4] = {0, 0, 0, 0};
+
+#ifndef cbi
+#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
+#endif
+
+#ifndef sbi
+#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
+#endif
+
+#define I2C_WRITE 0
+#define F_SCL 400000UL // SCL frequency
+#define Prescaler 1
+#define TWBR_val ((((F_CPU / F_SCL) / Prescaler) - 16 ) / 2)
+
+uint8_t i2c_start(uint8_t address)
+{
+    // reset TWI control register
+    TWCR = 0;
+    // transmit START condition
+    TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);
+    // wait for end of transmission
+    while( !(TWCR & (1<<TWINT)) );
+
+    // check if the start condition was successfully transmitted
+    if((TWSR & 0xF8) != TW_START){ return 1; }
+
+    // load slave address into data register
+    TWDR = address;
+    // start transmission of address
+    TWCR = (1<<TWINT) | (1<<TWEN);
+    // wait for end of transmission
+    while( !(TWCR & (1<<TWINT)) );
+
+    // check if the device has acknowledged the READ / WRITE mode
+    uint8_t twst = TW_STATUS & 0xF8;
+    if ( (twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK) ) return 1;
+
+    return 0;
+}
+
+uint8_t i2c_write(uint8_t data)
+{
+    // load data into data register
+    TWDR = data;
+    // start transmission of data
+    TWCR = (1 << TWINT) | (1 << TWEN);
+    // wait for end of transmission
+    while (!(TWCR & (1 << TWINT)))
+        ;
+
+    if ((TWSR & 0xF8) != TW_MT_DATA_ACK) {
+        return 1;
+    }
+    return 0;
+}
+
+uint8_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length)
+{
+    TWBR = (uint8_t)TWBR_val;
+    if (i2c_start(address | I2C_WRITE))
+        return 1;
+    for (uint16_t i = 0; i < length; i++) {
+        if (i2c_write(data[i]))
+            return 1;
+    }
+    // transmit STOP condition
+    TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO);
+    return 0;
+}
+
+void setFrame(uint8_t device, uint8_t frame)
+{
+    static uint8_t current_frame = -1;
+    if(current_frame != frame){
+        uint8_t payload[] = {
+            ISSI_ADDR_DEFAULT | device << 1,
+            ISSI_COMMANDREGISTER,
+            frame
+        };
+        TWITransmitData(payload, sizeof(payload), 0, 1);
+    }
+    // static uint8_t current_frame = 0xFF;
+    // if(current_frame == frame){
+    //     // return;
+    // }
+    // uint8_t payload[2] = { ISSI_COMMANDREGISTER, frame };
+    // i2c_transmit(ISSI_ADDR_DEFAULT | device << 1, payload, 2);
+    // current_frame = frame;
+}
+
+void writeRegister8(uint8_t device, uint8_t frame, uint8_t reg, uint8_t data)
+{
+    // Set the frame
+    setFrame(device, frame);
+
+    // Write to the register
+    uint8_t payload[] = {
+        ISSI_ADDR_DEFAULT | device << 1,
+        reg,
+        data
+    };
+    TWITransmitData(payload, sizeof(payload), 0, 1);
+}
+
+// void activateLED(uint8_t matrix, uint8_t cx, uint8_t cy, uint8_t pwm)
+// {
+//     xprintf("activeLED: %02X %02X %02X %02X\n", matrix, cy, cx, pwm);
+//     uint8_t x = cx - 1;  // funciton takes 1 based counts, but we need 0...
+//     uint8_t y = cy - 1;  // creating them once for less confusion
+//     if(pwm == 0){
+//         cbi(control[matrix][y], x);
+//     }else{
+//         sbi(control[matrix][y], x);
+//     }
+//     uint8_t device = (matrix & 0x06) >> 1;
+//     uint8_t control_reg = (y << 1) | (matrix & 0x01);
+//     uint8_t pwm_reg = 0;
+//     switch(matrix & 0x01){
+//         case 0:
+//             pwm_reg = 0x24;
+//             break;
+//         case 1:
+//             pwm_reg = 0x2C;
+//             break;
+//     }
+//     pwm_reg += (y << 4) + x;
+//     xprintf("  device: %02X\n", device);
+//     xprintf("  control: %02X %02X\n", control_reg, control[matrix][y]);
+//     xprintf("  pwm:     %02X %02X\n", pwm_reg, pwm);
+//     writeRegister8(device, 0, control_reg, control[matrix][y]);
+//     writeRegister8(device, 0, control_reg + 0x12, control[matrix][y]);
+//     writeRegister8(device, 0, pwm_reg, pwm);
+// }
+
+void activateLED(uint8_t matrix, uint8_t cx, uint8_t cy, uint8_t pwm)
+{
+    uint8_t device_addr = (matrix & 0x06) >> 1;
+    ISSIDeviceStruct *device = issi_devices[device_addr];
+    if(device == 0){
+        return;
+    }
+    // xprintf("activeLED: %02X %02X %02X %02X\n", matrix, cy, cx, pwm);
+    uint8_t x = cx - 1;  // funciton takes 1 based counts, but we need 0...
+    uint8_t y = cy - 1;  // creating them once for less confusion
+    uint8_t control_reg = (y << 1) | (matrix & 0x01);
+    if(pwm == 0){
+        cbi(device->led_ctrl[control_reg], x);
+        cbi(device->led_blink_ctrl[control_reg], x);
+     }else{
+        sbi(device->led_ctrl[control_reg], x);
+        sbi(device->led_blink_ctrl[control_reg], x);
+    }
+    uint8_t pwm_reg = 0;
+    switch(matrix & 0x01){
+        case 0:
+            pwm_reg = 0x00;
+            break;
+        case 1:
+            pwm_reg = 0x08;
+            break;
+    }
+    pwm_reg += (y << 4) + x;
+    // xprintf("  device_addr: %02X\n", device_addr);
+    // xprintf("  control: %02X %02X\n", control_reg, control[matrix][y]);
+    // xprintf("  pwm:     %02X %02X\n", pwm_reg, pwm);
+    // writeRegister8(device_addr, 0, control_reg, control[matrix][y]);
+    device->led_pwm[pwm_reg] = pwm;
+    device->led_dirty = 1;
+
+    // writeRegister8(device_addr, 0, control_reg + 0x12, control[matrix][y]);
+    // writeRegister8(device_addr, 0, pwm_reg, pwm);
+}
+
+void update_issi(uint8_t device_addr, uint8_t blocking)
+{
+    // This seems to take about 6ms
+    ISSIDeviceStruct *device = issi_devices[device_addr];
+    if(device != 0){
+        if(device->fn_dirty){
+            device->fn_dirty = 0;
+            setFrame(device_addr, ISSI_BANK_FUNCTIONREG);
+            TWITransmitData(&device->fn_device_addr, sizeof(device->fn_registers) + 2, 0, 1);
+        }
+        if(device->led_dirty){
+            device->led_dirty = 0;
+            setFrame(device_addr, 0);
+            TWITransmitData(&device->led_device_addr, 0xB6, 0, blocking);
+        }
+    }
+}
+
+void issi_init(void)
+{
+    // Set LED_EN/SDB high to enable the chip
+    xprintf("Enabing SDB on pin: %d\n", LED_EN_PIN);
+    _SFR_IO8((LED_EN_PIN >> 4) + 1) &= ~_BV(LED_EN_PIN & 0xF); // IN
+    _SFR_IO8((LED_EN_PIN >> 4) + 2) |=  _BV(LED_EN_PIN & 0xF); // HI
+    TWIInit();
+    for(uint8_t device_addr = 0; device_addr < 4; device_addr++){
+        xprintf("ISSI Init device: %d\n", device_addr);
+        // If this device has been previously allocated, free it
+        if(issi_devices[device_addr] != 0){
+            free(issi_devices[device_addr]);
+        }
+        // Try to shutdown the device, if this fails skip this device
+        writeRegister8(device_addr, ISSI_BANK_FUNCTIONREG, ISSI_REG_SHUTDOWN, 0x00);
+        while (!isTWIReady()){_delay_us(1);}
+        if(TWIInfo.errorCode != 0xFF){
+            xprintf("ISSI init failed %d %02X %02X\n", device_addr, TWIInfo.mode, TWIInfo.errorCode);
+            continue;
+        }
+        // Allocate the device structure - calloc zeros it for us
+        ISSIDeviceStruct *device = (ISSIDeviceStruct *)calloc(sizeof(ISSIDeviceStruct) * 2, 1);
+        issi_devices[device_addr] = device;
+        device->fn_device_addr = ISSI_ADDR_DEFAULT | device_addr << 1;
+        device->fn_register_addr =