OLED Driver Feature

7 files changed, 996 insertions, 25 deletions

diff --git a/drivers/arm/i2c_master.c b/drivers/arm/i2c_master.c
index 0e5edcc38..7369398cc 100644
--- a/drivers/arm/i2c_master.c
+++ b/drivers/arm/i2c_master.c
@@ -42,6 +42,18 @@ static const I2CConfig i2cconfig = {
   0
 };
 
+static i2c_status_t chibios_to_qmk(const msg_t* status) {
+  switch (*status) {
+    case I2C_NO_ERROR:
+      return I2C_STATUS_SUCCESS;
+    case I2C_TIMEOUT:
+      return I2C_STATUS_TIMEOUT;
+    // I2C_BUS_ERROR, I2C_ARBITRATION_LOST, I2C_ACK_FAILURE, I2C_OVERRUN, I2C_PEC_ERROR, I2C_SMB_ALERT
+    default:
+      return I2C_STATUS_ERROR;
+  }
+}
+
 __attribute__ ((weak))
 void i2c_init(void)
 {
@@ -57,29 +69,30 @@ void i2c_init(void)
   //i2cInit(); //This is invoked by halInit() so no need to redo it.
 }
 
-// This is usually not needed
-uint8_t i2c_start(uint8_t address)
+i2c_status_t i2c_start(uint8_t address)
 {
   i2c_address = address;
   i2cStart(&I2C_DRIVER, &i2cconfig);
-  return 0;
+  return I2C_STATUS_SUCCESS;
 }
 
-uint8_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout)
+i2c_status_t i2c_transmit(uint8_t address, const uint8_t* data, uint16_t length, uint16_t timeout)
 {
   i2c_address = address;
   i2cStart(&I2C_DRIVER, &i2cconfig);
-  return i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), data, length, 0, 0, MS2ST(timeout));
+  msg_t status = i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), data, length, 0, 0, MS2ST(timeout));
+  return chibios_to_qmk(&status);
 }
 
-uint8_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout)
+i2c_status_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout)
 {
   i2c_address = address;
   i2cStart(&I2C_DRIVER, &i2cconfig);
-  return i2cMasterReceiveTimeout(&I2C_DRIVER, (i2c_address >> 1), data, length, MS2ST(timeout));
+  msg_t status = i2cMasterReceiveTimeout(&I2C_DRIVER, (i2c_address >> 1), data, length, MS2ST(timeout));
+  return chibios_to_qmk(&status);
 }
 
-uint8_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout)
+i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, const uint8_t* data, uint16_t length, uint16_t timeout)
 {
   i2c_address = devaddr;
   i2cStart(&I2C_DRIVER, &i2cconfig);
@@ -91,18 +104,19 @@ uint8_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t l
   }
   complete_packet[0] = regaddr;
 
-  return i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), complete_packet, length + 1, 0, 0, MS2ST(timeout));
+  msg_t status = i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), complete_packet, length + 1, 0, 0, MS2ST(timeout));
+  return chibios_to_qmk(&status);
 }
 
-uint8_t i2c_readReg(uint8_t devaddr, uint8_t* regaddr, uint8_t* data, uint16_t length, uint16_t timeout)
+i2c_status_t i2c_readReg(uint8_t devaddr, uint8_t* regaddr, uint8_t* data, uint16_t length, uint16_t timeout)
 {
   i2c_address = devaddr;
   i2cStart(&I2C_DRIVER, &i2cconfig);
-  return i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), regaddr, 1, data, length, MS2ST(timeout));
+  msg_t status = i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), regaddr, 1, data, length, MS2ST(timeout));
+  return chibios_to_qmk(&status);
 }
 
-uint8_t i2c_stop(void)
+void i2c_stop(void)
 {
   i2cStop(&I2C_DRIVER);
-  return 0;
 }
diff --git a/drivers/arm/i2c_master.h b/drivers/arm/i2c_master.h
index 4ab2301f8..a15f1702d 100644
--- a/drivers/arm/i2c_master.h
+++ b/drivers/arm/i2c_master.h
@@ -40,11 +40,17 @@
   #define I2C_DRIVER I2CD1
 #endif
 
+typedef int16_t i2c_status_t;
+
+#define I2C_STATUS_SUCCESS (0)
+#define I2C_STATUS_ERROR   (-1)
+#define I2C_STATUS_TIMEOUT (-2)
+
 void i2c_init(void);
-uint8_t i2c_start(uint8_t address);
-uint8_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);
-uint8_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);
-uint8_t i2c_transmit_receive(uint8_t address, uint8_t * tx_body, uint16_t tx_length, uint8_t * rx_body, uint16_t rx_length);
-uint8_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
-uint8_t i2c_readReg(uint8_t devaddr, uint8_t* regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
-uint8_t i2c_stop(void);
+i2c_status_t i2c_start(uint8_t address);
+i2c_status_t i2c_transmit(uint8_t address, const uint8_t* data, uint16_t length, uint16_t timeout);
+i2c_status_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);
+i2c_status_t i2c_transmit_receive(uint8_t address, uint8_t * tx_body, uint16_t tx_length, uint8_t * rx_body, uint16_t rx_length);
+i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, const uint8_t* data, uint16_t length, uint16_t timeout);
+i2c_status_t i2c_readReg(uint8_t devaddr, uint8_t* regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
+void i2c_stop(void);
diff --git a/drivers/avr/i2c_master.c b/drivers/avr/i2c_master.c
index ba6d0d158..a7364bae0 100755
--- a/drivers/avr/i2c_master.c
+++ b/drivers/avr/i2c_master.c
@@ -121,7 +121,7 @@ int16_t i2c_read_nack(uint16_t timeout) {
   return TWDR;
 }
 
-i2c_status_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout) {
+i2c_status_t i2c_transmit(uint8_t address, const uint8_t* data, uint16_t length, uint16_t timeout) {
   i2c_status_t status = i2c_start(address | I2C_WRITE, timeout);
 
   for (uint16_t i = 0; i < length && status >= 0; i++) {
@@ -155,7 +155,7 @@ i2c_status_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16
   return (status < 0) ? status : I2C_STATUS_SUCCESS;
 }
 
-i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout) {
+i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, const uint8_t* data, uint16_t length, uint16_t timeout) {
   i2c_status_t status = i2c_start(devaddr | 0x00, timeout);
   if (status >= 0) {
     status = i2c_write(regaddr, timeout);
diff --git a/drivers/avr/i2c_master.h b/drivers/avr/i2c_master.h
index 81a7fb5e3..b4613115d 100755
--- a/drivers/avr/i2c_master.h
+++ b/drivers/avr/i2c_master.h
@@ -22,10 +22,10 @@ i2c_status_t i2c_start(uint8_t address, uint16_t timeout);
 i2c_status_t i2c_write(uint8_t data, uint16_t timeout);
 int16_t i2c_read_ack(uint16_t timeout);
 int16_t i2c_read_nack(uint16_t timeout);
-i2c_status_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);
+i2c_status_t i2c_transmit(uint8_t address, const uint8_t* data, uint16_t length, uint16_t timeout);
 i2c_status_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);
-i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
+i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, const uint8_t* data, uint16_t length, uint16_t timeout);
 i2c_status_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
 void i2c_stop(void);
 
-#endif // I2C_MASTER_H
\ No newline at end of file
+#endif // I2C_MASTER_H
diff --git a/drivers/oled/glcdfont.c b/drivers/oled/glcdfont.c
new file mode 100644
index 000000000..150be9e94
--- /dev/null
+++ b/drivers/oled/glcdfont.c
@@ -0,0 +1,240 @@
+#pragma once
+
+#ifdef __AVR__
+ #include <avr/io.h>
+ #include <avr/pgmspace.h>
+#elif defined(ESP8266)
+ #include <pgmspace.h>
+#else
+ #define PROGMEM
+#endif
+
+// Helidox 8x6 font with QMK Firmware Logo
+// Online editor: http://teripom.x0.com/
+
+static const unsigned char font[] PROGMEM = {
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x3E, 0x5B, 0x4F, 0x5B, 0x3E, 0x00,
+  0x3E, 0x6B, 0x4F, 0x6B, 0x3E, 0x00,
+  0x1C, 0x3E, 0x7C, 0x3E, 0x1C, 0x00,
+  0x18, 0x3C, 0x7E, 0x3C, 0x18, 0x00,
+  0x1C, 0x57, 0x7D, 0x57, 0x1C, 0x00,
+  0x1C, 0x5E, 0x7F, 0x5E, 0x1C, 0x00,
+  0x00, 0x18, 0x3C, 0x18, 0x00, 0x00,
+  0xFF, 0xE7, 0xC3, 0xE7, 0xFF, 0x00,
+  0x00, 0x18, 0x24, 0x18, 0x00, 0x00,
+  0xFF, 0xE7, 0xDB, 0xE7, 0xFF, 0x00,
+  0x30, 0x48, 0x3A, 0x06, 0x0E, 0x00,
+  0x26, 0x29, 0x79, 0x29, 0x26, 0x00,
+  0x40, 0x7F, 0x05, 0x05, 0x07, 0x00,
+  0x40, 0x7F, 0x05, 0x25, 0x3F, 0x00,
+  0x5A, 0x3C, 0xE7, 0x3C, 0x5A, 0x00,
+  0x7F, 0x3E, 0x1C, 0x1C, 0x08, 0x00,
+  0x08, 0x1C, 0x1C, 0x3E, 0x7F, 0x00,
+  0x14, 0x22, 0x7F, 0x22, 0x14, 0x00,
+  0x5F, 0x5F, 0x00, 0x5F, 0x5F, 0x00,
+  0x06, 0x09, 0x7F, 0x01, 0x7F, 0x00,
+  0x00, 0x66, 0x89, 0x95, 0x6A, 0x00,
+  0x60, 0x60, 0x60, 0x60, 0x60, 0x00,
+  0x94, 0xA2, 0xFF, 0xA2, 0x94, 0x00,
+  0x08, 0x04, 0x7E, 0x04, 0x08, 0x00,
+  0x10, 0x20, 0x7E, 0x20, 0x10, 0x00,
+  0x08, 0x08, 0x2A, 0x1C, 0x08, 0x00,
+  0x08, 0x1C, 0x2A, 0x08, 0x08, 0x00,
+  0x1E, 0x10, 0x10, 0x10, 0x10, 0x00,
+  0x0C, 0x1E, 0x0C, 0x1E, 0x0C, 0x00,
+  0x30, 0x38, 0x3E, 0x38, 0x30, 0x00,
+  0x06, 0x0E, 0x3E, 0x0E, 0x06, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x5F, 0x00, 0x00, 0x00,
+  0x00, 0x07, 0x00, 0x07, 0x00, 0x00,
+  0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00,
+  0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x00,
+  0x23, 0x13, 0x08, 0x64, 0x62, 0x00,
+  0x36, 0x49, 0x56, 0x20, 0x50, 0x00,
+  0x00, 0x08, 0x07, 0x03, 0x00, 0x00,
+  0x00, 0x1C, 0x22, 0x41, 0x00, 0x00,
+  0x00, 0x41, 0x22, 0x1C, 0x00, 0x00,
+  0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 0x00,
+  0x08, 0x08, 0x3E, 0x08, 0x08, 0x00,
+  0x00, 0x80, 0x70, 0x30, 0x00, 0x00,
+  0x08, 0x08, 0x08, 0x08, 0x08, 0x00,
+  0x00, 0x00, 0x60, 0x60, 0x00, 0x00,
+  0x20, 0x10, 0x08, 0x04, 0x02, 0x00,
+  0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00,
+  0x00, 0x42, 0x7F, 0x40, 0x00, 0x00,
+  0x72, 0x49, 0x49, 0x49, 0x46, 0x00,
+  0x21, 0x41, 0x49, 0x4D, 0x33, 0x00,
+  0x18, 0x14, 0x12, 0x7F, 0x10, 0x00,
+  0x27, 0x45, 0x45, 0x45, 0x39, 0x00,
+  0x3C, 0x4A, 0x49, 0x49, 0x31, 0x00,
+  0x41, 0x21, 0x11, 0x09, 0x07, 0x00,
+  0x36, 0x49, 0x49, 0x49, 0x36, 0x00,
+  0x46, 0x49, 0x49, 0x29, 0x1E, 0x00,
+  0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+  0x00, 0x40, 0x34, 0x00, 0x00, 0x00,
+  0x00, 0x08, 0x14, 0x22, 0x41, 0x00,
+  0x14, 0x14, 0x14, 0x14, 0x14, 0x00,
+  0x00, 0x41, 0x22, 0x14, 0x08, 0x00,
+  0x02, 0x01, 0x59, 0x09, 0x06, 0x00,
+  0x3E, 0x41, 0x5D, 0x59, 0x4E, 0x00,
+  0x7C, 0x12, 0x11, 0x12, 0x7C, 0x00,
+  0x7F, 0x49, 0x49, 0x49, 0x36, 0x00,
+  0x3E, 0x41, 0x41, 0x41, 0x22, 0x00,
+  0x7F, 0x41, 0x41, 0x41, 0x3E, 0x00,
+  0x7F, 0x49, 0x49, 0x49, 0x41, 0x00,
+  0x7F, 0x09, 0x09, 0x09, 0x01, 0x00,
+  0x3E, 0x41, 0x41, 0x51, 0x73, 0x00,
+  0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00,
+  0x00, 0x41, 0x7F, 0x41, 0x00, 0x00,
+  0x20, 0x40, 0x41, 0x3F, 0x01, 0x00,
+  0x7F, 0x08, 0x14, 0x22, 0x41, 0x00,
+  0x7F, 0x40, 0x40, 0x40, 0x40, 0x00,
+  0x7F, 0x02, 0x1C, 0x02, 0x7F, 0x00,
+  0x7F, 0x04, 0x08, 0x10, 0x7F, 0x00,
+  0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00,
+  0x7F, 0x09, 0x09, 0x09, 0x06, 0x00,
+  0x3E, 0x41, 0x51, 0x21, 0x5E, 0x00,
+  0x7F, 0x09, 0x19, 0x29, 0x46, 0x00,
+  0x26, 0x49, 0x49, 0x49, 0x32, 0x00,
+  0x03, 0x01, 0x7F, 0x01, 0x03, 0x00,
+  0x3F, 0x40, 0x40, 0x40, 0x3F, 0x00,
+  0x1F, 0x20, 0x40, 0x20, 0x1F, 0x00,
+  0x3F, 0x40, 0x38, 0x40, 0x3F, 0x00,
+  0x63, 0x14, 0x08, 0x14, 0x63, 0x00,
+  0x03, 0x04, 0x78, 0x04, 0x03, 0x00,
+  0x61, 0x59, 0x49, 0x4D, 0x43, 0x00,
+  0x00, 0x7F, 0x41, 0x41, 0x41, 0x00,
+  0x02, 0x04, 0x08, 0x10, 0x20, 0x00,
+  0x00, 0x41, 0x41, 0x41, 0x7F, 0x00,
+  0x04, 0x02, 0x01, 0x02, 0x04, 0x00,
+  0x40, 0x40, 0x40, 0x40, 0x40, 0x00,
+  0x00, 0x03, 0x07, 0x08, 0x00, 0x00,
+  0x20, 0x54, 0x54, 0x78, 0x40, 0x00,
+  0x7F, 0x28, 0x44, 0x44, 0x38, 0x00,
+  0x38, 0x44, 0x44, 0x44, 0x28, 0x00,
+  0x38, 0x44, 0x44, 0x28, 0x7F, 0x00,
+  0x38, 0x54, 0x54, 0x54, 0x18, 0x00,
+  0x00, 0x08, 0x7E, 0x09, 0x02, 0x00,
+  0x18, 0xA4, 0xA4, 0x9C, 0x78, 0x00,
+  0x7F, 0x08, 0x04, 0x04, 0x78, 0x00,
+  0x00, 0x44, 0x7D, 0x40, 0x00, 0x00,
+  0x20, 0x40, 0x40, 0x3D, 0x00, 0x00,
+  0x7F, 0x10, 0x28, 0x44, 0x00, 0x00,
+  0x00, 0x41, 0x7F, 0x40, 0x00, 0x00,
+  0x7C, 0x04, 0x78, 0x04, 0x78, 0x00,
+  0x7C, 0x08, 0x04, 0x04, 0x78, 0x00,
+  0x38, 0x44, 0x44, 0x44, 0x38, 0x00,
+  0xFC, 0x18, 0x24, 0x24, 0x18, 0x00,
+  0x18, 0x24, 0x24, 0x18, 0xFC, 0x00,
+  0x7C, 0x08, 0x04, 0x04, 0x08, 0x00,
+  0x48, 0x54, 0x54, 0x54, 0x24, 0x00,
+  0x04, 0x04, 0x3F, 0x44, 0x24, 0x00,
+  0x3C, 0x40, 0x40, 0x20, 0x7C, 0x00,
+  0x1C, 0x20, 0x40, 0x20, 0x1C, 0x00,
+  0x3C, 0x40, 0x30, 0x40, 0x3C, 0x00,
+  0x44, 0x28, 0x10, 0x28, 0x44, 0x00,
+  0x4C, 0x90, 0x90, 0x90, 0x7C, 0x00,
+  0x44, 0x64, 0x54, 0x4C, 0x44, 0x00,
+  0x00, 0x08, 0x36, 0x41, 0x00, 0x00,
+  0x00, 0x00, 0x77, 0x00, 0x00, 0x00,
+  0x00, 0x41, 0x36, 0x08, 0x00, 0x00,
+  0x02, 0x01, 0x02, 0x04, 0x02, 0x00,
+  0x3C, 0x26, 0x23, 0x26, 0x3C, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x40, 0x40, 0x40, 0xF0, 0xF8, 0xF8,
+  0xFF, 0x38, 0xFF, 0xF8, 0xF8, 0x3F,
+  0xF8, 0xF8, 0xFF, 0x38, 0xFF, 0xF8,
+  0xF8, 0xF0, 0x40, 0x40, 0x40, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+  0xC0, 0xC0, 0xC0, 0x80, 0x00, 0x00,
+  0xC0, 0xC0, 0x80, 0x00, 0x00, 0x00,
+  0x80, 0xC0, 0xC0, 0x00, 0xC0, 0xC0,
+  0x00, 0x00, 0x80, 0xC0, 0xC0, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0,
+  0xC0, 0xC0, 0xC0, 0x00, 0xC0, 0xC0,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xE0, 0xF0, 0xF0, 0xF0, 0xE0, 0xEC,
+  0xEE, 0xF7, 0xF3, 0x70, 0x20, 0x00,
+  0x7C, 0x7C, 0x7C, 0x7E, 0x00, 0x7E,
+  0x7E, 0x7E, 0x7F, 0x7F, 0x7F, 0x00,
+  0x00, 0x80, 0xC0, 0xE0, 0x7E, 0x5B,
+  0x4F, 0x5B, 0xFE, 0xC0, 0x00, 0x00,
+  0xC0, 0x00, 0xDC, 0xD7, 0xDE, 0xDE,
+  0xDE, 0xD7, 0xDC, 0x00, 0xC0, 0x00,
+  0x00, 0x00, 0x00, 0xE0, 0xEC, 0xDF,
+  0xFC, 0xE0, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x49, 0x49, 0x49, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xE0, 0xDF, 0xBF, 0xBF, 0x00,
+  0xBF, 0xBF, 0xDF, 0xE0, 0xFF, 0xFF,
+  0xFF, 0xFF, 0x49, 0x49, 0x49, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x1F, 0x3F,
+  0x60, 0x60, 0xE0, 0xBF, 0x1F, 0x00,
+  0x7F, 0x7F, 0x07, 0x1E, 0x38, 0x1E,
+  0x07, 0x7F, 0x7F, 0x00, 0x7F, 0x7F,
+  0x0E, 0x1F, 0x3B, 0x71, 0x60, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x7F, 0x7F,
+  0x0C, 0x0C, 0x0C, 0x00, 0x7E, 0x7E,
+  0x00, 0x7F, 0x7E, 0x03, 0x03, 0x00,
+  0x7F, 0x7E, 0x03, 0x03, 0x7E, 0x7E,
+  0x03, 0x03, 0x7F, 0x7E, 0x00, 0x0F,
+  0x3E, 0x70, 0x3C, 0x06, 0x3C, 0x70,
+  0x3E, 0x0F, 0x00, 0x32, 0x7B, 0x49,
+  0x49, 0x3F, 0x7E, 0x00, 0x7F, 0x7E,
+  0x03, 0x03, 0x00, 0x1E, 0x3F, 0x69,
+  0x69, 0x6F, 0x26, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0F, 0x1F, 0x3F, 0x7F, 0x7F, 0x7F,
+  0x7F, 0x7F, 0x3F, 0x1E, 0x0C, 0x00,
+  0x1F, 0x1F, 0x1F, 0x3F, 0x00, 0x3F,
+  0x3F, 0x3F, 0x7F, 0x7F, 0x7F, 0x00,
+  0x30, 0x7B, 0x7F, 0x78, 0x30, 0x20,
+  0x20, 0x30, 0x78, 0x7F, 0x3B, 0x00,
+  0x03, 0x00, 0x0F, 0x7F, 0x0F, 0x0F,
+  0x0F, 0x7F, 0x0F, 0x00, 0x03, 0x00,
+  0x40, 0x7C, 0x3F, 0x3F, 0x23, 0x01,
+  0x23, 0x3F, 0x37, 0x6C, 0x40, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x01, 0x01, 0x07, 0x0F, 0x0F,
+  0x7F, 0x0F, 0x7F, 0x0F, 0x0F, 0x7E,
+  0x0F, 0x0F, 0x7F, 0x0F, 0x7F, 0x0F,
+  0x0F, 0x07, 0x01, 0x01, 0x01, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x01, 0x01, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
diff --git a/drivers/oled/oled_driver.c b/drivers/oled/oled_driver.c
new file mode 100644
index 000000000..aa025d7a4
--- /dev/null
+++ b/drivers/oled/oled_driver.c
@@ -0,0 +1,528 @@
+/*
+Copyright 2019 Ryan Caltabiano <https://github.com/XScorpion2>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "i2c_master.h"
+#include "oled_driver.h"
+#include OLED_FONT_H
+#include "timer.h"
+#include "print.h"
+
+#include <string.h>
+
+#if defined(__AVR__)
+  #include <avr/io.h>
+  #include <avr/pgmspace.h>
+#elif defined(ESP8266)
+  #include <pgmspace.h>
+#else // defined(ESP8266)
+  #define PROGMEM
+  #define memcpy_P(des, src, len) memcpy(des, src, len)
+#endif // defined(__AVR__)
+
+// Used commands from spec sheet: https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf
+// Fundamental Commands
+#define CONTRAST                0x81
+#define DISPLAY_ALL_ON          0xA5
+#define DISPLAY_ALL_ON_RESUME   0xA4
+#define NORMAL_DISPLAY          0xA6
+#define DISPLAY_ON              0xAF
+#define DISPLAY_OFF             0xAE
+
+// Scrolling Commands
+#define ACTIVATE_SCROLL         0x2F
+#define DEACTIVATE_SCROLL       0x2E
+#define SCROLL_RIGHT            0x26
+#define SCROLL_LEFT             0x27
+#define SCROLL_RIGHT_UP         0x29
+#define SCROLL_LEFT_UP          0x2A
+
+// Addressing Setting Commands
+#define MEMORY_MODE             0x20
+#define COLUMN_ADDR             0x21
+#define PAGE_ADDR               0x22
+
+// Hardware Configuration Commands
+#define DISPLAY_START_LINE      0x40
+#define SEGMENT_REMAP           0xA0
+#define SEGMENT_REMAP_INV       0xA1
+#define MULTIPLEX_RATIO         0xA8
+#define COM_SCAN_INC            0xC0
+#define COM_SCAN_DEC            0xC8
+#define DISPLAY_OFFSET          0xD3
+#define COM_PINS                0xDA
+
+// Timing & Driving Commands
+#define DISPLAY_CLOCK           0xD5
+#define PRE_CHARGE_PERIOD       0xD9
+#define VCOM_DETECT             0xDB
+
+// Charge Pump Commands
+#define CHARGE_PUMP             0x8D
+
+// Misc defines
+#define OLED_TIMEOUT 60000
+#define OLED_BLOCK_COUNT (sizeof(OLED_BLOCK_TYPE) * 8)
+#define OLED_BLOCK_SIZE (OLED_MATRIX_SIZE / OLED_BLOCK_COUNT)
+
+// i2c defines
+#define I2C_CMD 0x00
+#define I2C_DATA 0x40
+#if defined(__AVR__)
+  // already defined on ARM
+  #define I2C_TIMEOUT 100
+  #define I2C_TRANSMIT_P(data) i2c_transmit_P((OLED_DISPLAY_ADDRESS << 1), &data[0], sizeof(data), I2C_TIMEOUT)
+#else // defined(__AVR__)
+  #define I2C_TRANSMIT_P(data) i2c_transmit((OLED_DISPLAY_ADDRESS << 1), &data[0], sizeof(data), I2C_TIMEOUT)
+#endif // defined(__AVR__)
+#define I2C_TRANSMIT(data) i2c_transmit((OLED_DISPLAY_ADDRESS << 1), &data[0], sizeof(data), I2C_TIMEOUT)
+#define I2C_WRITE_REG(mode, data, size) i2c_writeReg((OLED_DISPLAY_ADDRESS << 1), mode, data, size, I2C_TIMEOUT)
+
+#define HAS_FLAGS(bits, flags) ((bits & flags) == flags)
+
+// Display buffer's is the same as the OLED memory layout
+// this is so we don't end up with rounding errors with
+// parts of the display unusable or don't get cleared correctly
+// and also allows for drawing & inverting
+uint8_t          oled_buffer[OLED_MATRIX_SIZE];
+uint8_t*         oled_cursor;
+OLED_BLOCK_TYPE  oled_dirty = 0;
+bool             oled_initialized = false;
+bool             oled_active = false;
+bool             oled_scrolling = false;
+uint8_t          oled_rotation = 0;
+uint8_t          oled_rotation_width = 0;
+#if !defined(OLED_DISABLE_TIMEOUT)
+  uint16_t         oled_last_activity;
+#endif
+
+// Internal variables to reduce math instructions
+
+#if defined(__AVR__)
+// identical to i2c_transmit, but for PROGMEM since all initialization is in PROGMEM arrays currently
+// probably should move this into i2c_master...
+static i2c_status_t i2c_transmit_P(uint8_t address, const uint8_t* data, uint16_t length, uint16_t timeout) {
+  i2c_status_t status = i2c_start(address | I2C_WRITE, timeout);
+
+  for (uint16_t i = 0; i < length && status >= 0; i++) {
+    status = i2c_write(pgm_read_byte((const char*)data++), timeout);
+    if (status) break;
+  }
+
+  i2c_stop();
+
+  return status;
+}
+#endif
+
+// Flips the rendering bits for a character at the current cursor position
+static void InvertCharacter(uint8_t *cursor)
+{
+  const uint8_t *end = cursor + OLED_FONT_WIDTH;
+  while (cursor < end) {
+    *cursor = ~(*cursor);
+    cursor++;
+  }
+}
+
+bool oled_init(uint8_t rotation) {
+  oled_rotation = oled_init_user(rotation);
+  if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_90)) {
+    oled_rotation_width = OLED_DISPLAY_WIDTH;
+  } else {
+    oled_rotation_width = OLED_DISPLAY_HEIGHT;
+  }
+  i2c_init();
+
+  static const uint8_t PROGMEM display_setup1[] = {
+    I2C_CMD,
+    DISPLAY_OFF,
+    DISPLAY_CLOCK, 0x80,
+    MULTIPLEX_RATIO, OLED_DISPLAY_HEIGHT - 1,
+    DISPLAY_OFFSET, 0x00,
+    DISPLAY_START_LINE | 0x00,
+    CHARGE_PUMP, 0x14,
+    MEMORY_MODE, 0x00, }; // Horizontal addressing mode
+  if (I2C_TRANSMIT_P(display_setup1) != I2C_STATUS_SUCCESS) {
+    print("oled_init cmd set 1 failed\n");
+    return false;
+  }
+
+  if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_180)) {
+    static const uint8_t PROGMEM display_normal[] = {
+      I2C_CMD,
+      SEGMENT_REMAP_INV,
+      COM_SCAN_DEC };
+    if (I2C_TRANSMIT_P(display_normal) != I2C_STATUS_SUCCESS) {
+      print("oled_init cmd normal rotation failed\n");
+      return false;
+    }
+  } else {
+    static const uint8_t PROGMEM display_flipped[] = {
+      I2C_CMD,
+      SEGMENT_REMAP,
+      COM_SCAN_INC };
+    if (I2C_TRANSMIT_P(display_flipped) != I2C_STATUS_SUCCESS) {
+      print("display_flipped failed\n");
+      return false;
+    }
+  }
+
+  static const uint8_t PROGMEM display_setup2[] = {
+    I2C_CMD,
+    COM_PINS, 0x02,
+    CONTRAST, 0x8F,
+    PRE_CHARGE_PERIOD, 0xF1,
+    VCOM_DETECT, 0x40,
+    DISPLAY_ALL_ON_RESUME,
+    NORMAL_DISPLAY,
+    DEACTIVATE_SCROLL,
+    DISPLAY_ON };
+  if (I2C_TRANSMIT_P(display_setup2) != I2C_STATUS_SUCCESS) {
+    print("display_setup2 failed\n");
+    return false;
+  }
+
+  oled_clear();
+  oled_initialized = true;
+  oled_active = true;
+  oled_scrolling = false;
+  return true;
+}
+
+__attribute__((weak))
+uint8_t oled_init_user(uint8_t rotation) {
+  return rotation;
+}
+
+void oled_clear(void) {
+  memset(oled_buffer, 0, sizeof(oled_buffer));
+  oled_cursor = &oled_buffer[0];
+  oled_dirty = -1; // -1 will be max value as long as display_dirty is unsigned type
+}
+
+static void calc_bounds(uint8_t update_start, uint8_t* cmd_array)
+{
+  cmd_array[1] = OLED_BLOCK_SIZE * update_start % OLED_DISPLAY_WIDTH;
+  cmd_array[4] = OLED_BLOCK_SIZE * update_start / OLED_DISPLAY_WIDTH;
+  cmd_array[2] = (OLED_BLOCK_SIZE + OLED_DISPLAY_WIDTH - 1) % OLED_DISPLAY_WIDTH + cmd_array[1];
+  cmd_array[5] = (OLED_BLOCK_SIZE + OLED_DISPLAY_WIDTH - 1) / OLED_DISPLAY_WIDTH - 1;
+}
+
+static void calc_bounds_90(uint8_t update_start, uint8_t* cmd_array)
+{
+  cmd_array[1] = OLED_BLOCK_SIZE * update_start / OLED_DISPLAY_HEIGHT * 8;
+  cmd_array[4] = OLED_BLOCK_SIZE * update_start % OLED_DISPLAY_HEIGHT;
+  cmd_array[2] = (OLED_BLOCK_SIZE + OLED_DISPLAY_HEIGHT - 1) / OLED_DISPLAY_HEIGHT * 8 - 1 + cmd_array[1];;
+  cmd_array[5] = (OLED_BLOCK_SIZE + OLED_DISPLAY_HEIGHT - 1) % OLED_DISPLAY_HEIGHT / 8;
+}
+
+uint8_t crot(uint8_t a, int8_t n)
+{
+  const uint8_t mask = 0x7;
+  n &= mask;
+  return a << n | a >> (-n & mask);
+}
+
+static void rotate_90(const uint8_t* src, uint8_t* dest)
+{
+  for (uint8_t i = 0, shift = 7; i < 8; ++i, --shift) {
+    uint8_t selector = (1 << i);
+    for (uint8_t j = 0; j < 8; ++j) {
+      dest[i] |= crot(src[j] & selector, shift - (int8_t)j);
+    }
+  }
+}
+
+void oled_render(void) {
+  // Do we have work to do?
+  if (!oled_dirty || oled_scrolling) {
+    return;
+  }
+
+  // Find first dirty block
+  uint8_t update_start = 0;
+  while (!(oled_dirty & (1 << update_start))) { ++update_start; }
+
+  // Set column & page position
+  static uint8_t display_start[] = {
+    I2C_CMD,
+    COLUMN_ADDR, 0, OLED_DISPLAY_WIDTH - 1,
+    PAGE_ADDR, 0, OLED_DISPLAY_HEIGHT / 8 - 1 };
+  if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_90)) {
+    calc_bounds(update_start, &display_start[1]); // Offset from I2C_CMD byte at the start
+  } else {
+    calc_bounds_90(update_start, &display_start[1]); // Offset from I2C_CMD byte at the start
+  }
+
+  // Send column & page position
+  if (I2C_TRANSMIT(display_start) != I2C_STATUS_SUCCESS) {
+    print("oled_render offset command failed\n");
+    return;
+  }
+
+  if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_90)) {
+    // Send render data chunk as is
+    if (I2C_WRITE_REG(I2C_DATA, &oled_buffer[OLED_BLOCK_SIZE * update_start], OLED_BLOCK_SIZE) != I2C_STATUS_SUCCESS) {
+      print("oled_render data failed\n");
+      return;
+    }
+  } else {
+    // Rotate the render chunks
+    const static uint8_t source_map[] = OLED_SOURCE_MAP;
+    const static uint8_t target_map[] = OLED_TARGET_MAP;
+
+    static uint8_t temp_buffer[OLED_BLOCK_SIZE];
+    memset(temp_buffer, 0, sizeof(temp_buffer));
+    for(uint8_t i = 0; i < sizeof(source_map); ++i) {
+      rotate_90(&oled_buffer[OLED_BLOCK_SIZE * update_start + source_map[i]], &temp_buffer[target_map[i]]);
+    }
+
+    // Send render data chunk after rotating
+    if (I2C_WRITE_REG(I2C_DATA, &temp_buffer[0], OLED_BLOCK_SIZE) != I2C_STATUS_SUCCESS) {
+      print("oled_render data failed\n");
+      return;
+    }
+  }
+
+  // Turn on display if it is off
+  oled_on();
+
+  // Clear dirty flag
+  oled_dirty &= ~(1 << update_start);
+}
+
+void oled_set_cursor(uint8_t col, uint8_t line) {
+  uint16_t index = line * oled_rotation_width + col * OLED_FONT_WIDTH;
+
+  // Out of bounds?
+  if (index >= OLED_MATRIX_SIZE) {
+    index = 0;
+  }
+
+  oled_cursor = &oled_buffer[index];
+}
+
+void oled_advance_page(bool clearPageRemainder) {
+  uint16_t index = oled_cursor - &oled_buffer[0];
+  uint8_t remaining = oled_rotation_width - (index % oled_rotation_width);
+
+  if (clearPageRemainder) {
+    // Remaining Char count
+    remaining = remaining / OLED_FONT_WIDTH;
+
+    // Write empty character until next line
+    while (remaining--)
+      oled_write_char(' ', false);
+  } else {
+    // Next page index out of bounds?
+    if (index + remaining >= OLED_MATRIX_SIZE) {
+      index = 0;
+      remaining = 0;
+    }
+
+    oled_cursor = &oled_buffer[index + remaining];
+  }
+}
+
+void oled_advance_char(void) {
+  uint16_t nextIndex = oled_cursor - &oled_buffer[0] + OLED_FONT_WIDTH;
+  uint8_t remainingSpace = oled_rotation_width - (nextIndex % oled_rotation_width);
+
+  // Do we have enough space on the current line for the next character
+  if (remainingSpace < OLED_FONT_WIDTH) {
+    nextIndex += remainingSpace;
+  }
+
+  // Did we go out of bounds
+  if (nextIndex >= OLED_MATRIX_SIZE) {
+    nextIndex = 0;
+  }
+
+  // Update cursor position
+  oled_cursor = &oled_buffer[nextIndex];
+}
+
+// Main handler that writes character data to the display buffer
+void oled_write_char(const char data, bool invert) {
+  // Advance to the next line if newline
+  if (data == '\n') {
+    // Old source wrote ' ' until end of line...
+    oled_advance_page(true);
+    return;
+  }
+
+  // copy the current render buffer to check for dirty after
+  static uint8_t oled_temp_buffer[OLED_FONT_WIDTH];
+  memcpy(&oled_temp_buffer, oled_cursor, OLED_FONT_WIDTH);
+
+  // set the reder buffer data
+  uint8_t cast_data = (uint8_t)data; // font based on unsigned type for index
+  if (cast_data < OLED_FONT_START || cast_data > OLED_FONT_END) {
+    memset(oled_cursor, 0x00, OLED_FONT_WIDTH);
+  } else {
+    const uint8_t *glyph = &font[(cast_data - OLED_FONT_START) * OLED_FONT_WIDTH];
+    memcpy_P(oled_cursor, glyph, OLED_FONT_WIDTH);
+  }
+
+  // Invert if needed
+  if (invert) {
+    InvertCharacter(oled_cursor);
+  }
+
+  // Dirty check
+  if (memcmp(&oled_temp_buffer, oled_cursor, OLED_FONT_WIDTH)) {
+    oled_dirty |= (1 << ((oled_cursor - &oled_buffer[0]) / OLED_BLOCK_SIZE));
+  }
+
+  // Finally move to the next char
+  oled_advance_char();
+}
+
+void oled_write(const char *data, bool invert) {
+  const char *end = data + strlen(data);
+  while (data < end) {
+    oled_write_char(*data, invert);
+    data++;
+  }
+}
+
+void oled_write_ln(const char *data, bool invert) {
+  oled_write(data, invert);
+  oled_advance_page(true);
+}
+
+#if defined(__AVR__)
+void oled_write_P(const char *data, bool invert) {
+  uint8_t c = pgm_read_byte(data);
+  while (c != 0) {
+    oled_write_char(c, invert);
+    c = pgm_read_byte(++data);
+  }
+}
+
+void oled_write_ln_P(const char *data, bool invert) {
+  oled_write_P(data, invert);
+  oled_advance_page(true);
+}
+#endif // defined(__AVR__)
+
+bool oled_on(void) {
+#if !defined(OLED_DISABLE_TIMEOUT)
+  oled_last_activity = timer_read();
+#endif
+
+  static const uint8_t PROGMEM display_on[] = { I2C_CMD, DISPLAY_ON };
+  if (!oled_active) {
+    if (I2C_TRANSMIT_P(display_on) != I2C_STATUS_SUCCESS) {
+      print("oled_on cmd failed\n");
+      return oled_active;
+    }
+    oled_active = true;
+  }
+  return oled_active;
+}
+
+bool oled_off(void) {
+  static const uint8_t PROGMEM display_off[] = { I2C_CMD, DISPLAY_OFF };
+  if (oled_active) {
+    if (I2C_TRANSMIT_P(display_off) != I2C_STATUS_SUCCESS) {
+      print("oled_off cmd failed\n");
+      return oled_active;
+    }
+    oled_active = false;
+  }
+  return !oled_active;
+}
+
+bool oled_scroll_right(void) {
+  // Dont enable scrolling if we need to update the display
+  // This prevents scrolling of bad data from starting the scroll too early after init
+  if (!oled_dirty && !oled_scrolling) {
+    static const uint8_t PROGMEM display_scroll_right[] = {
+      I2C_CMD, SCROLL_RIGHT, 0x00, 0x00, 0x00, 0x0F, 0x00, 0xFF, ACTIVATE_SCROLL };
+    if (I2C_TRANSMIT_P(display_scroll_right) != I2C_STATUS_SUCCESS) {
+      print("oled_scroll_right cmd failed\n");
+      return oled_scrolling;
+    }
+    oled_scrolling = true;
+  }
+  return oled_scrolling;
+}
+
+bool oled_scroll_left(void) {
+  // Dont enable scrolling if we need to update the display
+  // This prevents scrolling of bad data from starting the scroll too early after init
+  if (!oled_dirty && !oled_scrolling) {
+    static const uint8_t PROGMEM display_scroll_left[] = {
+      I2C_CMD, SCROLL_LEFT, 0x00, 0x00, 0x00, 0x0F, 0x00, 0xFF, ACTIVATE_SCROLL };
+    if (I2C_TRANSMIT_P(display_scroll_left) != I2C_STATUS_SUCCESS) {
+      print("oled_scroll_left cmd failed\n");
+      return oled_scrolling;
+    }
+    oled_scrolling = true;
+  }
+  return oled_scrolling;
+}
+
+bool oled_scroll_off(void) {
+  if (oled_scrolling) {
+    static const uint8_t PROGMEM display_scroll_off[] = { I2C_CMD, DEACTIVATE_SCROLL };
+    if (I2C_TRANSMIT_P(display_scroll_off) != I2C_STATUS_SUCCESS) {
+      print("oled_scroll_off cmd failed\n");
+      return oled_scrolling;
+    }
+    oled_scrolling = false;
+  }
+  return !oled_scrolling;
+}
+
+uint8_t oled_max_chars(void) {
+  if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_90)) {
+    return OLED_DISPLAY_WIDTH / OLED_FONT_WIDTH;
+  }
+  return OLED_DISPLAY_HEIGHT / OLED_FONT_WIDTH;
+}
+
+uint8_t oled_max_lines(void) {
+  if (!HAS_FLAGS(oled_rotation, OLED_ROTATION_90)) {
+    return OLED_DISPLAY_HEIGHT / OLED_FONT_HEIGHT;
+  }
+  return OLED_DISPLAY_WIDTH / OLED_FONT_HEIGHT;
+}
+
+void oled_task(void) {
+  if (!oled_initialized) {
+    return;
+  }
+
+  oled_set_cursor(0, 0);
+
+  oled_task_user();
+
+  // Smart render system, no need to check for dirty
+  oled_render();
+
+  // Display timeout check
+#if !defined(OLED_DISABLE_TIMEOUT)
+  if (oled_active && timer_elapsed(oled_last_activity) > OLED_TIMEOUT) {
+    oled_off();
+  }
+#endif
+}
+
+__attribute__((weak))
+void oled_task_user(void) {
+}
diff --git a/drivers/oled/oled_driver.h b/drivers/oled/oled_driver.h
new file mode 100644
index 000000000..1ca31df11
--- /dev/null
+++ b/drivers/oled/oled_driver.h
@@ -0,0 +1,183 @@
+/*
+Copyright 2019 Ryan Caltabiano <https://github.com/XScorpion2>
+
+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/>.
+*/
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+
+
+#if defined(OLED_DISPLAY_CUSTOM)
+  // Expected user to implement the necessary defines
+#elif defined(OLED_DISPLAY_128X64)
+  // Double height 128x64
+  #define OLED_DISPLAY_WIDTH 128
+  #define OLED_DISPLAY_HEIGHT 64
+  #define OLED_MATRIX_SIZE (OLED_DISPLAY_HEIGHT / 8 * OLED_DISPLAY_WIDTH) // 1024 (compile time mathed)
+  #define OLED_BLOCK_TYPE uint16_t
+  #define OLED_BLOCK_COUNT (sizeof(OLED_BLOCK_TYPE) * 8) // 16 (compile time mathed)
+  #define OLED_BLOCK_SIZE (OLED_MATRIX_SIZE / OLED_BLOCK_COUNT) // 64 (compile time mathed)
+
+  // For 90 degree rotation, we map our internal matrix to oled matrix using fixed arrays
+  // The OLED writes to it's memory horizontally, starting top left, but our memory starts bottom left in this mode
+  #define OLED_SOURCE_MAP { 0, 8, 16, 24, 32, 40, 48, 56 }
+  #define OLED_TARGET_MAP { 56, 48, 40, 32, 24, 16, 8, 0 }
+  // If OLED_BLOCK_TYPE is uint8_t, these tables would look like:
+  // #define OLED_SOURCE_MAP { 0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120 }
+  // #define OLED_TARGET_MAP { 56, 120, 48, 112, 40, 104, 32, 96, 24, 88, 16, 80, 8, 72, 0, 64 }
+#else // defined(OLED_DISPLAY_128X64)
+  // Default 128x32
+  #define OLED_DISPLAY_WIDTH 128
+  #define OLED_DISPLAY_HEIGHT 32
+  #define OLED_MATRIX_SIZE (OLED_DISPLAY_HEIGHT / 8 * OLED_DISPLAY_WIDTH) // 512 (compile time mathed)
+  #define OLED_BLOCK_TYPE uint8_t // Type to use for segmenting the oled display for smart rendering, use unsigned types only
+  #define OLED_BLOCK_COUNT (sizeof(OLED_BLOCK_TYPE) * 8) // 8 (compile time mathed)
+  #define OLED_BLOCK_SIZE (OLED_MATRIX_SIZE / OLED_BLOCK_COUNT) // 128 (compile time mathed)
+
+  // For 90 degree rotation, we map our internal matrix to oled matrix using fixed arrays
+  // The OLED writes to it's memory horizontally, starting top left, but our memory starts bottom left in this mode
+  #define OLED_SOURCE_MAP { 0, 8, 16, 24, 32, 40, 48, 56 }
+  #define OLED_TARGET_MAP { 48, 32, 16, 0, 56, 40, 24, 8 }
+#endif // defined(OLED_DISPLAY_CUSTOM)
+
+// Address to use for tthe i2d oled communication
+#if !defined(OLED_DISPLAY_ADDRESS)
+  #define OLED_DISPLAY_ADDRESS 0x3C
+#endif
+
+// Custom font file to use
+#if !defined(OLED_FONT_H)
+  #define OLED_FONT_H "glcdfont.c"
+#endif
+// unsigned char value of the first character in the font file
+#if !defined(OLED_FONT_START)
+  #define OLED_FONT_START 0
+#endif
+// unsigned char value of the last character in the font file
+#if !defined(OLED_FONT_END)
+  #define OLED_FONT_END 224
+#endif
+// Font render width
+#if !defined(OLED_FONT_WIDTH)
+  #define OLED_FONT_WIDTH 6
+#endif
+// Font render height
+#if !defined(OLED_FONT_HEIGHT)
+  #define OLED_FONT_HEIGHT 8
+#endif
+
+#define OLED_ROTATION_0 0x00
+#define OLED_ROTATION_90 0x01
+#define OLED_ROTATION_180 0x02
+#define OLED_ROTATION_270 0x03
+
+// Initialize the oled display, rotating the rendered output based on the define passed in.
+// Returns true if the OLED was initialized successfully
+bool oled_init(uint8_t rotation);
+
+// Called at the start of oled_init, weak function overridable by the user
+// rotation - the value passed into oled_init
+// Return new uint8_t if you want to override default rotation
+uint8_t oled_init_user(uint8_t rotation);
+
+// Clears the display buffer, resets cursor position to 0, and sets the buffer to dirty for rendering
+void oled_clear(void);
+
+// Renders the dirty chunks of the buffer to oled display
+void oled_render(void);
+
+// Moves cursor to character position indicated by column and line, wraps if out of bounds
+// Max column denoted by 'oled_max_chars()' and max lines by 'oled_max_lines()' functions
+void oled_set_cursor(uint8_t col, uint8_t line);
+
+// Advances the cursor to the next page, writing ' ' if true
+// Wraps to the begining when out of bounds
+void oled_advance_page(bool clearPageRemainder);
+
+// Moves the cursor forward 1 character length
+// Advance page if there is not enough room for the next character
+// Wraps to the begining when out of bounds
+void oled_advance_char(void);
+
+// Writes a single character to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+// Main handler that writes character data to the display buffer
+void oled_write_char(const char data, bool invert);
+
+// Writes a string to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+void oled_write(const char *data, bool invert);
+
+// Writes a string to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+// Advances the cursor to the next page, wiring ' ' to the remainder of the current page
+void oled_write_ln(const char *data, bool invert);
+
+#if defined(__AVR__)
+// Writes a PROGMEM string to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+// Remapped to call 'void oled_write(const char *data, bool invert);' on ARM
+void oled_write_P(const char *data, bool invert);
+
+// Writes a PROGMEM string to the buffer at current cursor position
+// Advances the cursor while writing, inverts the pixels if true
+// Advances the cursor to the next page, wiring ' ' to the remainder of the current page
+// Remapped to call 'void oled_write_ln(const char *data, bool invert);' on ARM
+void oled_write_ln_P(const char *data, bool invert);
+#else
+  // Writes a string to the buffer at current cursor position
+  // Advances the cursor while writing, inverts the pixels if true
+  #define oled_write_P(data, invert) oled_write(data, invert)
+
+  // Writes a string to the buffer at current cursor position
+  // Advances the cursor while writing, inverts the pixels if true
+  // Advances the cursor to the next page, wiring ' ' to the remainder of the current page
+  #define oled_write_ln_P(data, invert) oled_write(data, invert)
+#endif // defined(__AVR__)
+
+// Can be used to manually turn on the screen if it is off
+// Returns true if the screen was on or turns on
+bool oled_on(void);
+
+// Can be used to manually turn off the screen if it is on
+// Returns true if the screen was off or turns off
+bool oled_off(void);
+
+// Basically it's oled_render, but with timeout management and oled_task_user calling!
+void oled_task(void);
+
+// Called at the start of oled_task, weak function overridable by the user
+void oled_task_user(void);
+
+// Scrolls the entire display right
+// Returns true if the screen was scrolling or starts scrolling
+// NOTE: display contents cannot be changed while scrolling
+bool oled_scroll_right(void);
+
+// Scrolls the entire display left
+// Returns true if the screen was scrolling or starts scrolling
+// NOTE: display contents cannot be changed while scrolling
+bool oled_scroll_left(void);
+
+// Turns off display scrolling
+// Returns true if the screen was not scrolling or stops scrolling
+bool oled_scroll_off(void);
+
+// Returns the maximum number of characters that will fit on a line
+uint8_t oled_max_chars(void);
+
+// Returns the maximum number of lines that will fit on the oled
+uint8_t oled_max_lines(void);