Nulo/qmk_firmware
1
0
Fork 0
Code Releases Activity

Next set of split_common changes (#4974)

Browse source 
* Update split_common to use standard i2c drivers

* Eliminate RGB_DIRTY/BACKLIT_DIRTY

* Fix avr i2c_master error handling

* Fix i2c_slave addressing

* Remove unneeded timeout on i2c_stop()

* Fix RGB I2C transfers

* Remove incorrect comment
This commit is contained in:
James Churchill 2019-03-13 03:23:28 +10:00 committed by Drashna Jaelre
parent 25bb059e4e
commit 37932c293c
24 changed files with 187 additions and 614 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
common_features.mk
View file

@ -308,16 +308,16 @@ ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
OPT_DEFS += -DSPLIT_KEYBOARD OPT_DEFS += -DSPLIT_KEYBOARD
# Include files used by all split keyboards # Include files used by all split keyboards
QUANTUM_SRC += $(QUANTUM_DIR)/split_common/split_flags.c \ QUANTUM_SRC += $(QUANTUM_DIR)/split_common/split_util.c
$(QUANTUM_DIR)/split_common/split_util.c
# Determine which (if any) transport files are required # Determine which (if any) transport files are required
ifneq ($(strip $(SPLIT_TRANSPORT)), custom) ifneq ($(strip $(SPLIT_TRANSPORT)), custom)
QUANTUM_SRC += $(QUANTUM_DIR)/split_common/transport.c QUANTUM_SRC += $(QUANTUM_DIR)/split_common/transport.c
# Functions added via QUANTUM_LIB_SRC are only included in the final binary if they're called. # Functions added via QUANTUM_LIB_SRC are only included in the final binary if they're called.
# Unused functions are pruned away, which is why we can add both drivers here without bloat. # Unused functions are pruned away, which is why we can add multiple drivers here without bloat.
QUANTUM_LIB_SRC += $(QUANTUM_DIR)/split_common/i2c.c \ QUANTUM_LIB_SRC += $(QUANTUM_DIR)/split_common/serial.c \
$(QUANTUM_DIR)/split_common/serial.c i2c_master.c \
i2c_slave.c
endif endif
COMMON_VPATH += $(QUANTUM_PATH)/split_common COMMON_VPATH += $(QUANTUM_PATH)/split_common
endif endif

2
docs/i2c_driver.md
View file

@ -12,7 +12,7 @@ The I2C Master drivers used in QMK have a set of common functions to allow porta
|`uint8_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);` |Receive data over I2C. Address is the 7-bit slave address without the direction. Saves number of bytes specified by `length` in `data` array. Returns status of transaction. | |`uint8_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);` |Receive data over I2C. Address is the 7-bit slave address without the direction. Saves number of bytes specified by `length` in `data` array. Returns status of transaction. |
|`uint8_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);` |Same as the `i2c_transmit` function but `regaddr` sets where in the slave the data will be written. | |`uint8_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);` |Same as the `i2c_transmit` function but `regaddr` sets where in the slave the data will be written. |
|`uint8_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);` |Same as the `i2c_receive` function but `regaddr` sets from where in the slave the data will be read. | |`uint8_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);` |Same as the `i2c_receive` function but `regaddr` sets from where in the slave the data will be read. |
|`uint8_t i2c_stop(uint16_t timeout);` |Stops the I2C driver. | |`uint8_t i2c_stop(void);` |Ends an I2C transaction. |
### Function Return ### Function Return

3
drivers/arm/i2c_master.c
View file

@ -101,8 +101,7 @@ uint8_t i2c_readReg(uint8_t devaddr, uint8_t* regaddr, uint8_t* data, uint16_t l
return i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), regaddr, 1, data, length, MS2ST(timeout)); return i2cMasterTransmitTimeout(&I2C_DRIVER, (i2c_address >> 1), regaddr, 1, data, length, MS2ST(timeout));
} }
// This is usually not needed. It releases the driver to allow pins to become GPIO again. uint8_t i2c_stop(void)
uint8_t i2c_stop(uint16_t timeout)
{ {
i2cStop(&I2C_DRIVER); i2cStop(&I2C_DRIVER);
return 0; return 0;

2
drivers/arm/i2c_master.h
View file

@ -47,4 +47,4 @@ uint8_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t ti
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_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_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_readReg(uint8_t devaddr, uint8_t* regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
uint8_t i2c_stop(uint16_t timeout); uint8_t i2c_stop(void);

160
drivers/avr/i2c_master.c
View file

@ -7,43 +7,44 @@
#include "i2c_master.h" #include "i2c_master.h"
#include "timer.h" #include "timer.h"
#include "wait.h"
#ifndef F_SCL #ifndef F_SCL
#define F_SCL 400000UL // SCL frequency # define F_SCL 400000UL // SCL frequency
#endif #endif
#define Prescaler 1 #define Prescaler 1
#define TWBR_val ((((F_CPU / F_SCL) / Prescaler) - 16 ) / 2) #define TWBR_val ((((F_CPU / F_SCL) / Prescaler) - 16) / 2)
void i2c_init(void) void i2c_init(void) {
{ TWSR = 0; /* no prescaler */
TWSR = 0; /* no prescaler */
TWBR = (uint8_t)TWBR_val; TWBR = (uint8_t)TWBR_val;
} }
i2c_status_t i2c_start(uint8_t address, uint16_t timeout) i2c_status_t i2c_start(uint8_t address, uint16_t timeout) {
{
// reset TWI control register // reset TWI control register
TWCR = 0; TWCR = 0;
// transmit START condition // transmit START condition
TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN); TWCR = (1 << TWINT) | (1 << TWSTA) | (1 << TWEN);
uint16_t timeout_timer = timer_read(); uint16_t timeout_timer = timer_read();
while( !(TWCR & (1<<TWINT)) ) { while (!(TWCR & (1 << TWINT))) {
if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) { if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) {
return I2C_STATUS_TIMEOUT; return I2C_STATUS_TIMEOUT;
} }
} }
// check if the start condition was successfully transmitted // check if the start condition was successfully transmitted
if(((TW_STATUS & 0xF8) != TW_START) && ((TW_STATUS & 0xF8) != TW_REP_START)){ return I2C_STATUS_ERROR; } if (((TW_STATUS & 0xF8) != TW_START) && ((TW_STATUS & 0xF8) != TW_REP_START)) {
return I2C_STATUS_ERROR;
}
// load slave address into data register // load slave address into data register
TWDR = address; TWDR = address;
// start transmission of address // start transmission of address
TWCR = (1<<TWINT) | (1<<TWEN); TWCR = (1 << TWINT) | (1 << TWEN);
timeout_timer = timer_read(); timeout_timer = timer_read();
while( !(TWCR & (1<<TWINT)) ) { while (!(TWCR & (1 << TWINT))) {
if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) { if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) {
return I2C_STATUS_TIMEOUT; return I2C_STATUS_TIMEOUT;
} }
@ -51,38 +52,39 @@ i2c_status_t i2c_start(uint8_t address, uint16_t timeout)
// check if the device has acknowledged the READ / WRITE mode // check if the device has acknowledged the READ / WRITE mode
uint8_t twst = TW_STATUS & 0xF8; uint8_t twst = TW_STATUS & 0xF8;
if ( (twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK) ) return I2C_STATUS_ERROR; if ((twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK)) {
return I2C_STATUS_ERROR;
}
return I2C_STATUS_SUCCESS; return I2C_STATUS_SUCCESS;
} }
i2c_status_t i2c_write(uint8_t data, uint16_t timeout) i2c_status_t i2c_write(uint8_t data, uint16_t timeout) {
{
// load data into data register // load data into data register
TWDR = data; TWDR = data;
// start transmission of data // start transmission of data
TWCR = (1<<TWINT) | (1<<TWEN); TWCR = (1 << TWINT) | (1 << TWEN);
uint16_t timeout_timer = timer_read(); uint16_t timeout_timer = timer_read();
while( !(TWCR & (1<<TWINT)) ) { while (!(TWCR & (1 << TWINT))) {
if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) { if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) {
return I2C_STATUS_TIMEOUT; return I2C_STATUS_TIMEOUT;
} }
} }
if( (TW_STATUS & 0xF8) != TW_MT_DATA_ACK ){ return I2C_STATUS_ERROR; } if ((TW_STATUS & 0xF8) != TW_MT_DATA_ACK) {
return I2C_STATUS_ERROR;
}
return I2C_STATUS_SUCCESS; return I2C_STATUS_SUCCESS;
} }
int16_t i2c_read_ack(uint16_t timeout) int16_t i2c_read_ack(uint16_t timeout) {
{
// start TWI module and acknowledge data after reception // start TWI module and acknowledge data after reception
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWEA); TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWEA);
uint16_t timeout_timer = timer_read(); uint16_t timeout_timer = timer_read();
while( !(TWCR & (1<<TWINT)) ) { while (!(TWCR & (1 << TWINT))) {
if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) { if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) {
return I2C_STATUS_TIMEOUT; return I2C_STATUS_TIMEOUT;
} }
@ -92,14 +94,12 @@ int16_t i2c_read_ack(uint16_t timeout)
return TWDR; return TWDR;
} }
int16_t i2c_read_nack(uint16_t timeout) int16_t i2c_read_nack(uint16_t timeout) {
{
// start receiving without acknowledging reception // start receiving without acknowledging reception
TWCR = (1<<TWINT) | (1<<TWEN); TWCR = (1 << TWINT) | (1 << TWEN);
uint16_t timeout_timer = timer_read(); uint16_t timeout_timer = timer_read();
while( !(TWCR & (1<<TWINT)) ) { while (!(TWCR & (1 << TWINT))) {
if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) { if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) {
return I2C_STATUS_TIMEOUT; return I2C_STATUS_TIMEOUT;
} }
@ -109,115 +109,89 @@ int16_t i2c_read_nack(uint16_t timeout)
return TWDR; 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, uint8_t* data, uint16_t length, uint16_t timeout) {
{
i2c_status_t status = i2c_start(address | I2C_WRITE, timeout); i2c_status_t status = i2c_start(address | I2C_WRITE, timeout);
if (status) return status;
for (uint16_t i = 0; i < length; i++) { for (uint16_t i = 0; i < length && status >= 0; i++) {
status = i2c_write(data[i], timeout); status = i2c_write(data[i], timeout);
if (status) return status;
} }
status = i2c_stop(timeout); i2c_stop();
if (status) return status;
return I2C_STATUS_SUCCESS; return status;
} }
i2c_status_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_status_t status = i2c_start(address | I2C_READ, timeout); i2c_status_t status = i2c_start(address | I2C_READ, timeout);
if (status) return status;
for (uint16_t i = 0; i < (length-1); i++) { for (uint16_t i = 0; i < (length - 1) && status >= 0; i++) {
status = i2c_read_ack(timeout); status = i2c_read_ack(timeout);
if (status >= 0) { if (status >= 0) {
data[i] = status; data[i] = status;
} else {
return status;
} }
} }
status = i2c_read_nack(timeout); if (status >= 0) {
if (status >= 0 ) { status = i2c_read_nack(timeout);
data[(length-1)] = status; if (status >= 0) {
} else { data[(length - 1)] = status;
return status; }
} }
status = i2c_stop(timeout); i2c_stop();
if (status) return status;
return I2C_STATUS_SUCCESS; return status;
} }
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, uint8_t* data, uint16_t length, uint16_t timeout) {
{
i2c_status_t status = i2c_start(devaddr | 0x00, timeout); i2c_status_t status = i2c_start(devaddr | 0x00, timeout);
if (status) return status; if (status >= 0) {
status = i2c_write(regaddr, timeout);
status = i2c_write(regaddr, timeout); for (uint16_t i = 0; i < length && status >= 0; i++) {
if (status) return status; status = i2c_write(data[i], timeout);
}
for (uint16_t i = 0; i < length; i++) {
status = i2c_write(data[i], timeout);
if (status) return status;
} }
status = i2c_stop(timeout); i2c_stop();
if (status) return status;
return I2C_STATUS_SUCCESS; return status;
} }
i2c_status_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_status_t status = i2c_start(devaddr, timeout); i2c_status_t status = i2c_start(devaddr, timeout);
if (status) return status; if (status < 0) {
goto error;
}
status = i2c_write(regaddr, timeout); status = i2c_write(regaddr, timeout);
if (status) return status; if (status < 0) {
goto error;
status = i2c_stop(timeout); }
if (status) return status;
status = i2c_start(devaddr | 0x01, timeout); status = i2c_start(devaddr | 0x01, timeout);
if (status) return status;
for (uint16_t i = 0; i < (length-1); i++) { for (uint16_t i = 0; i < (length - 1) && status >= 0; i++) {
status = i2c_read_ack(timeout); status = i2c_read_ack(timeout);
if (status >= 0) { if (status >= 0) {
data[i] = status; data[i] = status;
} else {
return status;
} }
} }
status = i2c_read_nack(timeout); if (status >= 0) {
if (status >= 0 ) { status = i2c_read_nack(timeout);
data[(length-1)] = status; if (status >= 0) {
} else { data[(length - 1)] = status;
return status; }
} }
status = i2c_stop(timeout); error:
if (status) return status; i2c_stop();
return I2C_STATUS_SUCCESS; return status;
} }
i2c_status_t i2c_stop(uint16_t timeout) void i2c_stop(void) {
{
// transmit STOP condition // transmit STOP condition
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO); TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO);
uint16_t timeout_timer = timer_read();
while(TWCR & (1<<TWSTO)) {
if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) {
return I2C_STATUS_TIMEOUT;
}
}
return I2C_STATUS_SUCCESS;
} }

2
drivers/avr/i2c_master.h
View file

@ -26,6 +26,6 @@ i2c_status_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length, uint1
i2c_status_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_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, 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_status_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);
i2c_status_t i2c_stop(uint16_t timeout); void i2c_stop(void);
#endif // I2C_MASTER_H #endif // I2C_MASTER_H

2
drivers/avr/i2c_slave.c
View file

@ -16,7 +16,7 @@ static volatile bool slave_has_register_set = false;
void i2c_slave_init(uint8_t address){ void i2c_slave_init(uint8_t address){
// load address into TWI address register // load address into TWI address register
TWAR = (address << 1); TWAR = address;
// set the TWCR to enable address matching and enable TWI, clear TWINT, enable TWI interrupt // set the TWCR to enable address matching and enable TWI, clear TWINT, enable TWI interrupt
TWCR = (1 << TWIE) | (1 << TWEA) | (1 << TWINT) | (1 << TWEN); TWCR = (1 << TWIE) | (1 << TWEA) | (1 << TWINT) | (1 << TWEN);
} }

2
keyboards/cannonkeys/satisfaction75/i2c_master.c
View file

@ -109,7 +109,7 @@ uint8_t i2c_readReg(uint8_t devaddr, uint8_t* regaddr, uint8_t* data, uint16_t l
} }
// This is usually not needed. It releases the driver to allow pins to become GPIO again. // This is usually not needed. It releases the driver to allow pins to become GPIO again.
uint8_t i2c_stop(uint16_t timeout) uint8_t i2c_stop(void)
{ {
i2cStop(&I2C_DRIVER); i2cStop(&I2C_DRIVER);
return 0; return 0;

4
keyboards/dc01/left/matrix.c
View file

@ -455,10 +455,10 @@ i2c_status_t i2c_transaction(uint8_t address, uint32_t mask, uint8_t col_offset)
matrix[MATRIX_ROWS - 1] |= ((uint32_t)err << (MATRIX_COLS_SCANNED + col_offset)); //add new bits at the end matrix[MATRIX_ROWS - 1] |= ((uint32_t)err << (MATRIX_COLS_SCANNED + col_offset)); //add new bits at the end
} else { } else {
i2c_stop(10); i2c_stop();
return 1; return 1;
} }
i2c_stop(10); i2c_stop();
return 0; return 0;
} }

6
keyboards/ergodox_ez/ergodox_ez.c
View file

@ -128,7 +128,7 @@ uint8_t init_mcp23018(void) {
mcp23018_status = i2c_write(IODIRA, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out; mcp23018_status = i2c_write(IODIRA, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out;
mcp23018_status = i2c_write(0b00000000, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out; mcp23018_status = i2c_write(0b00000000, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out;
mcp23018_status = i2c_write(0b00111111, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out; mcp23018_status = i2c_write(0b00111111, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out;
i2c_stop(ERGODOX_EZ_I2C_TIMEOUT); i2c_stop();
// set pull-up // set pull-up
// - unused : on : 1 // - unused : on : 1
@ -140,7 +140,7 @@ uint8_t init_mcp23018(void) {
mcp23018_status = i2c_write(0b00111111, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out; mcp23018_status = i2c_write(0b00111111, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out;
out: out:
i2c_stop(ERGODOX_EZ_I2C_TIMEOUT); i2c_stop();
#ifdef LEFT_LEDS #ifdef LEFT_LEDS
if (!mcp23018_status) mcp23018_status = ergodox_left_leds_update(); if (!mcp23018_status) mcp23018_status = ergodox_left_leds_update();
@ -179,7 +179,7 @@ uint8_t ergodox_left_leds_update(void) {
if (mcp23018_status) goto out; if (mcp23018_status) goto out;
out: out:
i2c_stop(ERGODOX_EZ_I2C_TIMEOUT); i2c_stop();
return mcp23018_status; return mcp23018_status;
} }
#endif #endif

4
keyboards/ergodox_ez/matrix.c
View file

@ -309,7 +309,7 @@ static matrix_row_t read_cols(uint8_t row)
data = ~((uint8_t)mcp23018_status); data = ~((uint8_t)mcp23018_status);
mcp23018_status = I2C_STATUS_SUCCESS; mcp23018_status = I2C_STATUS_SUCCESS;
out: out:
i2c_stop(ERGODOX_EZ_I2C_TIMEOUT); i2c_stop();
return data; return data;
} }
} else { } else {
@ -362,7 +362,7 @@ static void select_row(uint8_t row)
mcp23018_status = i2c_write(GPIOA, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out; mcp23018_status = i2c_write(GPIOA, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out;
mcp23018_status = i2c_write(0xFF & ~(1<<row), ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out; mcp23018_status = i2c_write(0xFF & ~(1<<row), ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out;
out: out:
i2c_stop(ERGODOX_EZ_I2C_TIMEOUT); i2c_stop();
} }
} else { } else {
// select on teensy // select on teensy

4
keyboards/gergo/gergo.c
View file

@ -47,7 +47,7 @@ uint8_t init_mcp23018(void) {
mcp23018_status = i2c_write(IODIRA, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out; mcp23018_status = i2c_write(IODIRA, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out;
mcp23018_status = i2c_write(0b10000000, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out; mcp23018_status = i2c_write(0b10000000, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out;
mcp23018_status = i2c_write(0b11111111, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out; mcp23018_status = i2c_write(0b11111111, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out;
i2c_stop(ERGODOX_EZ_I2C_TIMEOUT); i2c_stop();
// set pull-up // set pull-up
// - unused : on : 1 // - unused : on : 1
@ -59,7 +59,7 @@ uint8_t init_mcp23018(void) {
mcp23018_status = i2c_write(0b11111111, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out; mcp23018_status = i2c_write(0b11111111, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out;
out: out:
i2c_stop(ERGODOX_EZ_I2C_TIMEOUT); i2c_stop();
// SREG=sreg_prev; // SREG=sreg_prev;
//uprintf("Init %x\n", mcp23018_status); //uprintf("Init %x\n", mcp23018_status);
return mcp23018_status; return mcp23018_status;

4
keyboards/gergo/matrix.c
View file

@ -394,7 +394,7 @@ static matrix_row_t read_cols(uint8_t row)
data = ~((uint8_t)mcp23018_status); data = ~((uint8_t)mcp23018_status);
mcp23018_status = I2C_STATUS_SUCCESS; mcp23018_status = I2C_STATUS_SUCCESS;
out: out:
i2c_stop(ERGODOX_EZ_I2C_TIMEOUT); i2c_stop();
#ifdef DEBUG_MATRIX #ifdef DEBUG_MATRIX
if (data != 0x00) xprintf("I2C: %d\n", data); if (data != 0x00) xprintf("I2C: %d\n", data);
@ -444,7 +444,7 @@ static void select_row(uint8_t row)
mcp23018_status = i2c_write(GPIOA, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out; mcp23018_status = i2c_write(GPIOA, ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out;
mcp23018_status = i2c_write(0xFF & ~(1<<row), ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out; mcp23018_status = i2c_write(0xFF & ~(1<<row), ERGODOX_EZ_I2C_TIMEOUT); if (mcp23018_status) goto out;
out: out:
i2c_stop(ERGODOX_EZ_I2C_TIMEOUT); i2c_stop();
} }
} else { } else {
// Output low(DDR:1, PORT:0) to select // Output low(DDR:1, PORT:0) to select

22
quantum/keymap_common.c
View file

@ -29,10 +29,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "backlight.h" #include "backlight.h"
#include "quantum.h" #include "quantum.h"
#ifdef SPLIT_KEYBOARD
#include "split_flags.h"
#endif
#ifdef MIDI_ENABLE #ifdef MIDI_ENABLE
#include "process_midi.h" #include "process_midi.h"
#endif #endif
@ -138,39 +134,21 @@ action_t action_for_key(uint8_t layer, keypos_t key)
#ifdef BACKLIGHT_ENABLE #ifdef BACKLIGHT_ENABLE
case BL_ON: case BL_ON:
action.code = ACTION_BACKLIGHT_ON(); action.code = ACTION_BACKLIGHT_ON();
#ifdef SPLIT_KEYBOARD
BACKLIT_DIRTY = true;
#endif
break; break;
case BL_OFF: case BL_OFF:
action.code = ACTION_BACKLIGHT_OFF(); action.code = ACTION_BACKLIGHT_OFF();
#ifdef SPLIT_KEYBOARD
BACKLIT_DIRTY = true;
#endif
break; break;
case BL_DEC: case BL_DEC:
action.code = ACTION_BACKLIGHT_DECREASE(); action.code = ACTION_BACKLIGHT_DECREASE();
#ifdef SPLIT_KEYBOARD
BACKLIT_DIRTY = true;
#endif
break; break;
case BL_INC: case BL_INC:
action.code = ACTION_BACKLIGHT_INCREASE(); action.code = ACTION_BACKLIGHT_INCREASE();
#ifdef SPLIT_KEYBOARD
BACKLIT_DIRTY = true;
#endif
break; break;
case BL_TOGG: case BL_TOGG:
action.code = ACTION_BACKLIGHT_TOGGLE(); action.code = ACTION_BACKLIGHT_TOGGLE();
#ifdef SPLIT_KEYBOARD
BACKLIT_DIRTY = true;
#endif
break; break;
case BL_STEP: case BL_STEP:
action.code = ACTION_BACKLIGHT_STEP(); action.code = ACTION_BACKLIGHT_STEP();
#ifdef SPLIT_KEYBOARD
BACKLIT_DIRTY = true;
#endif
break; break;
#endif #endif
#ifdef SWAP_HANDS_ENABLE #ifdef SWAP_HANDS_ENABLE

30
quantum/quantum.c
View file

@ -360,9 +360,6 @@ bool process_record_quantum(keyrecord_t *record) {
if (!record->event.pressed) { if (!record->event.pressed) {
#endif #endif
rgblight_toggle(); rgblight_toggle();
#ifdef SPLIT_KEYBOARD
RGB_DIRTY = true;
#endif
} }
return false; return false;
case RGB_MODE_FORWARD: case RGB_MODE_FORWARD:
@ -374,9 +371,6 @@ bool process_record_quantum(keyrecord_t *record) {
else { else {
rgblight_step(); rgblight_step();
} }
#ifdef SPLIT_KEYBOARD
RGB_DIRTY = true;
#endif
} }
return false; return false;
case RGB_MODE_REVERSE: case RGB_MODE_REVERSE:
@ -388,9 +382,6 @@ bool process_record_quantum(keyrecord_t *record) {
else { else {
rgblight_step_reverse(); rgblight_step_reverse();
} }
#ifdef SPLIT_KEYBOARD
RGB_DIRTY = true;
#endif
} }
return false; return false;
case RGB_HUI: case RGB_HUI:
@ -401,9 +392,6 @@ bool process_record_quantum(keyrecord_t *record) {
if (!record->event.pressed) { if (!record->event.pressed) {
#endif #endif
rgblight_increase_hue(); rgblight_increase_hue();
#ifdef SPLIT_KEYBOARD
RGB_DIRTY = true;
#endif
} }
return false; return false;
case RGB_HUD: case RGB_HUD:
@ -414,9 +402,6 @@ bool process_record_quantum(keyrecord_t *record) {
if (!record->event.pressed) { if (!record->event.pressed) {
#endif #endif
rgblight_decrease_hue(); rgblight_decrease_hue();
#ifdef SPLIT_KEYBOARD
RGB_DIRTY = true;
#endif
} }
return false; return false;
case RGB_SAI: case RGB_SAI:
@ -427,9 +412,6 @@ bool process_record_quantum(keyrecord_t *record) {
if (!record->event.pressed) { if (!record->event.pressed) {
#endif #endif
rgblight_increase_sat(); rgblight_increase_sat();
#ifdef SPLIT_KEYBOARD
RGB_DIRTY = true;
#endif
} }
return false; return false;
case RGB_SAD: case RGB_SAD:
@ -440,9 +422,6 @@ bool process_record_quantum(keyrecord_t *record) {
if (!record->event.pressed) { if (!record->event.pressed) {
#endif #endif
rgblight_decrease_sat(); rgblight_decrease_sat();
#ifdef SPLIT_KEYBOARD
RGB_DIRTY = true;
#endif
} }
return false; return false;
case RGB_VAI: case RGB_VAI:
@ -453,9 +432,6 @@ bool process_record_quantum(keyrecord_t *record) {
if (!record->event.pressed) { if (!record->event.pressed) {
#endif #endif
rgblight_increase_val(); rgblight_increase_val();
#ifdef SPLIT_KEYBOARD
RGB_DIRTY = true;
#endif
} }
return false; return false;
case RGB_VAD: case RGB_VAD:
@ -466,9 +442,6 @@ bool process_record_quantum(keyrecord_t *record) {
if (!record->event.pressed) { if (!record->event.pressed) {
#endif #endif
rgblight_decrease_val(); rgblight_decrease_val();
#ifdef SPLIT_KEYBOARD
RGB_DIRTY = true;
#endif
} }
return false; return false;
case RGB_SPI: case RGB_SPI:
@ -484,9 +457,6 @@ bool process_record_quantum(keyrecord_t *record) {
case RGB_MODE_PLAIN: case RGB_MODE_PLAIN:
if (record->event.pressed) { if (record->event.pressed) {
rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT); rgblight_mode(RGBLIGHT_MODE_STATIC_LIGHT);
#ifdef SPLIT_KEYBOARD
RGB_DIRTY = true;
#endif
} }
return false; return false;
case RGB_MODE_BREATHE: case RGB_MODE_BREATHE:

4
quantum/quantum.h
View file

@ -44,10 +44,6 @@
#endif #endif
#endif #endif
#ifdef SPLIT_KEYBOARD
#include "split_flags.h"
#endif
#ifdef RGB_MATRIX_ENABLE #ifdef RGB_MATRIX_ENABLE
#include "rgb_matrix.h" #include "rgb_matrix.h"
#endif #endif

184
quantum/split_common/i2c.c
View file

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

59
quantum/split_common/i2c.h
View file

@ -1,59 +0,0 @@
#pragma once
#include <stdint.h>
#ifndef F_CPU
#define F_CPU 16000000UL
#endif
#define I2C_READ 1
#define I2C_WRITE 0
#define I2C_ACK 1
#define I2C_NACK 0
// Address location defines (Keymap should be last, as it's size is dynamic)
#define I2C_BACKLIT_START 0x00
// Need 4 bytes for RGB (32 bit)
#define I2C_RGB_START 0x01
#define I2C_KEYMAP_START 0x06
// Slave buffer (8bit per)
// Rows per hand + backlit space + rgb space
// TODO : Make this dynamically sized
#define SLAVE_BUFFER_SIZE 0x20
// i2c SCL clock frequency
#ifndef SCL_CLOCK
#define SCL_CLOCK 100000L
#endif
// Support 8bits right now (8 cols) will need to edit to take higher (code exists in delta split?)
extern volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];
void i2c_master_init(void);
uint8_t i2c_master_start(uint8_t address);
void i2c_master_stop(void);
uint8_t i2c_master_write(uint8_t data);
uint8_t i2c_master_write_data(void *const TXdata, uint8_t dataLen);
uint8_t i2c_master_read(int);
void i2c_reset_state(void);
void i2c_slave_init(uint8_t address);
static inline unsigned char i2c_start_read(unsigned char addr) {
return i2c_master_start((addr << 1) | I2C_READ);
}
static inline unsigned char i2c_start_write(unsigned char addr) {
return i2c_master_start((addr << 1) | I2C_WRITE);
}
// from SSD1306 scrips
extern unsigned char i2c_rep_start(unsigned char addr);
extern void i2c_start_wait(unsigned char addr);
extern unsigned char i2c_readAck(void);
extern unsigned char i2c_readNak(void);
extern unsigned char i2c_read(unsigned char ack);
#define i2c_read(ack) (ack) ? i2c_readAck() : i2c_readNak();

1
quantum/split_common/matrix.c
View file

@ -25,7 +25,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "matrix.h" #include "matrix.h"
#include "split_util.h" #include "split_util.h"
#include "config.h" #include "config.h"
#include "split_flags.h"
#include "quantum.h" #include "quantum.h"
#include "debounce.h" #include "debounce.h"
#include "transport.h" #include "transport.h"

5
quantum/split_common/split_flags.c
View file

@ -1,5 +0,0 @@
#include "split_flags.h"
volatile bool RGB_DIRTY = false;
volatile bool BACKLIT_DIRTY = false;

15
quantum/split_common/split_flags.h
View file

@ -1,15 +0,0 @@
#pragma once
#include <stdbool.h>
#include <stdint.h>
/**
* Global Flags
**/
//RGB Stuff
extern volatile bool RGB_DIRTY;
//Backlight Stuff
extern volatile bool BACKLIT_DIRTY;

5
quantum/split_common/split_util.c
View file

@ -3,7 +3,6 @@
#include "keyboard.h" #include "keyboard.h"
#include "config.h" #include "config.h"
#include "timer.h" #include "timer.h"
#include "split_flags.h"
#include "transport.h" #include "transport.h"
#include "quantum.h" #include "quantum.h"
@ -60,10 +59,6 @@ static void keyboard_master_setup(void) {
#endif #endif
#endif #endif
transport_master_init(); transport_master_init();
// For master the Backlight info needs to be sent on startup
// Otherwise the salve won't start with the proper info until an update
BACKLIT_DIRTY = true;
} }
static void keyboard_slave_setup(void) static void keyboard_slave_setup(void)

230
quantum/split_common/transport.c
View file

@ -3,146 +3,83 @@
#include "matrix.h" #include "matrix.h"
#include "quantum.h" #include "quantum.h"
#define ROWS_PER_HAND (MATRIX_ROWS/2) #define ROWS_PER_HAND (MATRIX_ROWS / 2)
#ifdef RGBLIGHT_ENABLE #ifdef RGBLIGHT_ENABLE
# include "rgblight.h" # include "rgblight.h"
#endif #endif
#ifdef BACKLIGHT_ENABLE #ifdef BACKLIGHT_ENABLE
# include "backlight.h" # include "backlight.h"
extern backlight_config_t backlight_config; extern backlight_config_t backlight_config;
#endif #endif
#if defined(USE_I2C) || defined(EH) #if defined(USE_I2C) || defined(EH)
#include "i2c.h" # include "i2c_master.h"
# include "i2c_slave.h"
#ifndef SLAVE_I2C_ADDRESS # define I2C_BACKLIT_START 0x00
# define SLAVE_I2C_ADDRESS 0x32 // Need 4 bytes for RGB (32 bit)
#endif # define I2C_RGB_START 0x01
# define I2C_KEYMAP_START 0x05
#if (MATRIX_COLS > 8) # define TIMEOUT 100
# error "Currently only supports 8 COLS"
#endif # ifndef SLAVE_I2C_ADDRESS
# define SLAVE_I2C_ADDRESS 0x32
# endif
// Get rows from other half over i2c // Get rows from other half over i2c
bool transport_master(matrix_row_t matrix[]) { bool transport_master(matrix_row_t matrix[]) {
int err = 0; i2c_readReg(SLAVE_I2C_ADDRESS, I2C_KEYMAP_START, (void *)matrix, ROWS_PER_HAND * sizeof(matrix_row_t), TIMEOUT);
// write backlight info // write backlight info
#ifdef BACKLIGHT_ENABLE # ifdef BACKLIGHT_ENABLE
if (BACKLIT_DIRTY) { static uint8_t prev_level = ~0;
err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE); uint8_t level = get_backlight_level();
if (err) { goto i2c_error; } if (level != prev_level) {
i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_BACKLIT_START, (void *)&level, sizeof(level), TIMEOUT);
// Backlight location prev_level = level;
err = i2c_master_write(I2C_BACKLIT_START);
if (err) { goto i2c_error; }
// Write backlight
i2c_master_write(get_backlight_level());
BACKLIT_DIRTY = false;
} }
#endif # endif
err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE); # ifdef RGBLIGHT_ENABLE
if (err) { goto i2c_error; } static uint32_t prev_rgb = ~0;
uint32_t rgb = eeconfig_read_rgblight();
// start of matrix stored at I2C_KEYMAP_START if (rgb != prev_rgb) {
err = i2c_master_write(I2C_KEYMAP_START); i2c_writeReg(SLAVE_I2C_ADDRESS, I2C_RGB_START, (void *)&rgb, sizeof(rgb), TIMEOUT);
if (err) { goto i2c_error; } prev_rgb = rgb;
// 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[i] = i2c_master_read(I2C_ACK);
}
matrix[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 false;
} }
# endif
#ifdef RGBLIGHT_ENABLE
if (RGB_DIRTY) {
err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
if (err) { goto i2c_error; }
// RGB Location
err = i2c_master_write(I2C_RGB_START);
if (err) { goto i2c_error; }
uint32_t dword = eeconfig_read_rgblight();
// Write RGB
err = i2c_master_write_data(&dword, 4);
if (err) { goto i2c_error; }
RGB_DIRTY = false;
i2c_master_stop();
}
#endif
return true; return true;
} }
void transport_slave(matrix_row_t matrix[]) { void transport_slave(matrix_row_t matrix[]) {
for (int i = 0; i < ROWS_PER_HAND * sizeof(matrix_row_t); ++i) {
for (int i = 0; i < ROWS_PER_HAND; ++i) i2c_slave_reg[I2C_KEYMAP_START + i] = matrix[i];
{
i2c_slave_buffer[I2C_KEYMAP_START + i] = matrix[i];
} }
// Read Backlight Info
#ifdef BACKLIGHT_ENABLE
if (BACKLIT_DIRTY)
{
backlight_set(i2c_slave_buffer[I2C_BACKLIT_START]);
BACKLIT_DIRTY = false;
}
#endif
#ifdef RGBLIGHT_ENABLE
if (RGB_DIRTY)
{
// Disable interupts (RGB data is big)
cli();
// Create new DWORD for RGB data
uint32_t dword;
// Fill the new DWORD with the data that was sent over // Read Backlight Info
uint8_t * dword_dat = (uint8_t *)(&dword); # ifdef BACKLIGHT_ENABLE
for (int i = 0; i < 4; i++) backlight_set(i2c_slave_reg[I2C_BACKLIT_START]);
{ # endif
dword_dat[i] = i2c_slave_buffer[I2C_RGB_START + i];
}
// Update the RGB now with the new data and set RGB_DIRTY to false # ifdef RGBLIGHT_ENABLE
rgblight_update_dword(dword); uint32_t rgb = *(uint32_t *)(i2c_slave_reg + I2C_RGB_START);
RGB_DIRTY = false; // Update the RGB with the new data
// Re-enable interupts now that RGB is set rgblight_update_dword(rgb);
sei(); # endif
}
#endif
} }
void transport_master_init(void) { void transport_master_init(void) { i2c_init(); }
i2c_master_init();
}
void transport_slave_init(void) { void transport_slave_init(void) { i2c_slave_init(SLAVE_I2C_ADDRESS); }
i2c_slave_init(SLAVE_I2C_ADDRESS);
}
#else // USE_SERIAL #else // USE_SERIAL
#include "serial.h" # include "serial.h"
typedef struct _Serial_s2m_buffer_t { typedef struct _Serial_s2m_buffer_t {
// TODO: if MATRIX_COLS > 8 change to uint8_t packed_matrix[] for pack/unpack // TODO: if MATRIX_COLS > 8 change to uint8_t packed_matrix[] for pack/unpack
@ -150,40 +87,40 @@ typedef struct _Serial_s2m_buffer_t {
} Serial_s2m_buffer_t; } Serial_s2m_buffer_t;
typedef struct _Serial_m2s_buffer_t { typedef struct _Serial_m2s_buffer_t {
#ifdef BACKLIGHT_ENABLE # ifdef BACKLIGHT_ENABLE
uint8_t backlight_level; uint8_t backlight_level;
#endif # endif
#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT) # if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
rgblight_config_t rgblight_config; //not yet use rgblight_config_t rgblight_config; // not yet use
// //
// When MCUs on both sides drive their respective RGB LED chains, // When MCUs on both sides drive their respective RGB LED chains,
// it is necessary to synchronize, so it is necessary to communicate RGB information. // it is necessary to synchronize, so it is necessary to communicate RGB
// In that case, define the RGBLIGHT_SPLIT macro. // information. In that case, define the RGBLIGHT_SPLIT macro.
// //
// Otherwise, if the master side MCU drives both sides RGB LED chains, // Otherwise, if the master side MCU drives both sides RGB LED chains,
// there is no need to communicate. // there is no need to communicate.
#endif # endif
} Serial_m2s_buffer_t; } Serial_m2s_buffer_t;
volatile Serial_s2m_buffer_t serial_s2m_buffer = {}; volatile Serial_s2m_buffer_t serial_s2m_buffer = {};
volatile Serial_m2s_buffer_t serial_m2s_buffer = {}; volatile Serial_m2s_buffer_t serial_m2s_buffer = {};
uint8_t volatile status0 = 0; uint8_t volatile status0 = 0;
SSTD_t transactions[] = { SSTD_t transactions[] = {
{ (uint8_t *)&status0, {
sizeof(serial_m2s_buffer), (uint8_t *)&serial_m2s_buffer, (uint8_t *)&status0,
sizeof(serial_s2m_buffer), (uint8_t *)&serial_s2m_buffer sizeof(serial_m2s_buffer),
} (uint8_t *)&serial_m2s_buffer,
sizeof(serial_s2m_buffer),
(uint8_t *)&serial_s2m_buffer,
},
}; };
void transport_master_init(void) void transport_master_init(void) { soft_serial_initiator_init(transactions, TID_LIMIT(transactions)); }
{ soft_serial_initiator_init(transactions, TID_LIMIT(transactions)); }
void transport_slave_init(void) void transport_slave_init(void) { soft_serial_target_init(transactions, TID_LIMIT(transactions)); }
{ soft_serial_target_init(transactions, TID_LIMIT(transactions)); }
bool transport_master(matrix_row_t matrix[]) { bool transport_master(matrix_row_t matrix[]) {
if (soft_serial_transaction()) { if (soft_serial_transaction()) {
return false; return false;
} }
@ -193,32 +130,29 @@ bool transport_master(matrix_row_t matrix[]) {
matrix[i] = serial_s2m_buffer.smatrix[i]; matrix[i] = serial_s2m_buffer.smatrix[i];
} }
#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT) # if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
// Code to send RGB over serial goes here (not implemented yet) // Code to send RGB over serial goes here (not implemented yet)
#endif # endif
#ifdef BACKLIGHT_ENABLE # ifdef BACKLIGHT_ENABLE
// Write backlight level for slave to read // Write backlight level for slave to read
serial_m2s_buffer.backlight_level = backlight_config.enable ? backlight_config.level : 0; serial_m2s_buffer.backlight_level = backlight_config.enable ? backlight_config.level : 0;
#endif # endif
return true; return true;
} }
void transport_slave(matrix_row_t matrix[]) { void transport_slave(matrix_row_t matrix[]) {
// TODO: if MATRIX_COLS > 8 change to pack() // TODO: if MATRIX_COLS > 8 change to pack()
for (int i = 0; i < ROWS_PER_HAND; ++i) for (int i = 0; i < ROWS_PER_HAND; ++i) {
{
serial_s2m_buffer.smatrix[i] = matrix[i]; serial_s2m_buffer.smatrix[i] = matrix[i];
} }
#ifdef BACKLIGHT_ENABLE # ifdef BACKLIGHT_ENABLE
backlight_set(serial_m2s_buffer.backlight_level); backlight_set(serial_m2s_buffer.backlight_level);
#endif # endif
#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT) # if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
// Add serial implementation for RGB here // Add serial implementation for RGB here
#endif # endif
} }
#endif #endif

9
tmk_core/common/avr/suspend.c
View file

@ -11,9 +11,6 @@
#include "led.h" #include "led.h"
#include "host.h" #include "host.h"
#include "rgblight_reconfig.h" #include "rgblight_reconfig.h"
#ifdef SPLIT_KEYBOARD
#include "split_flags.h"
#endif
#ifdef PROTOCOL_LUFA #ifdef PROTOCOL_LUFA
#include "lufa.h" #include "lufa.h"
@ -135,9 +132,6 @@ static void power_down(uint8_t wdto) {
is_suspended = true; is_suspended = true;
rgblight_enabled = rgblight_config.enable; rgblight_enabled = rgblight_config.enable;
rgblight_disable_noeeprom(); rgblight_disable_noeeprom();
#ifdef SPLIT_KEYBOARD
RGB_DIRTY = true;
#endif
} }
#endif #endif
suspend_power_down_kb(); suspend_power_down_kb();
@ -216,9 +210,6 @@ void suspend_wakeup_init(void) {
wait_ms(10); wait_ms(10);
#endif #endif
rgblight_enable_noeeprom(); rgblight_enable_noeeprom();
#ifdef SPLIT_KEYBOARD
RGB_DIRTY = true;
#endif
} }
#ifdef RGBLIGHT_ANIMATIONS #ifdef RGBLIGHT_ANIMATIONS
rgblight_timer_enable(); rgblight_timer_enable();