diff options
author | Seth Barberee <seth.barberee@gmail.com> | 2018-07-22 08:56:14 -0500 |
---|---|---|
committer | Drashna Jaelre <drashna@live.com> | 2018-07-22 06:56:14 -0700 |
commit | ed99581161b35b383ee9e1f5c070574524e9ea36 (patch) | |
tree | f0a8cb293512fac2e64b4ab413a47d3ae031da60 | |
parent | 83d33caf63fc2270de576c2163f39ace400bc328 (diff) | |
download | qmk_firmware-ed99581161b35b383ee9e1f5c070574524e9ea36.tar.gz qmk_firmware-ed99581161b35b383ee9e1f5c070574524e9ea36.zip |
Convert Iris to use SPLIT_KEYBOARD (#3458)
* convert iris to split-common
* Fix build error
-rw-r--r-- | keyboards/iris/i2c.c | 162 | ||||
-rw-r--r-- | keyboards/iris/i2c.h | 49 | ||||
-rw-r--r-- | keyboards/iris/matrix.c | 484 | ||||
-rw-r--r-- | keyboards/iris/rules.mk | 7 | ||||
-rw-r--r-- | keyboards/iris/serial.c | 228 | ||||
-rw-r--r-- | keyboards/iris/serial.h | 26 | ||||
-rw-r--r-- | keyboards/iris/split_rgb.c | 41 | ||||
-rw-r--r-- | keyboards/iris/split_rgb.h | 6 | ||||
-rw-r--r-- | keyboards/iris/split_util.c | 86 | ||||
-rw-r--r-- | keyboards/iris/split_util.h | 20 | ||||
-rw-r--r-- | quantum/split_common/matrix.c | 1 |
11 files changed, 2 insertions, 1108 deletions
diff --git a/keyboards/iris/i2c.c b/keyboards/iris/i2c.c deleted file mode 100644 index 084c890c4..000000000 --- a/keyboards/iris/i2c.c +++ /dev/null | |||
@@ -1,162 +0,0 @@ | |||
1 | #include <util/twi.h> | ||
2 | #include <avr/io.h> | ||
3 | #include <stdlib.h> | ||
4 | #include <avr/interrupt.h> | ||
5 | #include <util/twi.h> | ||
6 | #include <stdbool.h> | ||
7 | #include "i2c.h" | ||
8 | |||
9 | #ifdef USE_I2C | ||
10 | |||
11 | // Limits the amount of we wait for any one i2c transaction. | ||
12 | // Since were running SCL line 100kHz (=> 10μs/bit), and each transactions is | ||
13 | // 9 bits, a single transaction will take around 90μs to complete. | ||
14 | // | ||
15 | // (F_CPU/SCL_CLOCK) => # of μC cycles to transfer a bit | ||
16 | // poll loop takes at least 8 clock cycles to execute | ||
17 | #define I2C_LOOP_TIMEOUT (9+1)*(F_CPU/SCL_CLOCK)/8 | ||
18 | |||
19 | #define BUFFER_POS_INC() (slave_buffer_pos = (slave_buffer_pos+1)%SLAVE_BUFFER_SIZE) | ||
20 | |||
21 | volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE]; | ||
22 | |||
23 | static volatile uint8_t slave_buffer_pos; | ||
24 | static volatile bool slave_has_register_set = false; | ||
25 | |||
26 | // Wait for an i2c operation to finish | ||
27 | inline static | ||
28 | void i2c_delay(void) { | ||
29 | uint16_t lim = 0; | ||
30 | while(!(TWCR & (1<<TWINT)) && lim < I2C_LOOP_TIMEOUT) | ||
31 | lim++; | ||
32 | |||
33 | // easier way, but will wait slightly longer | ||
34 | // _delay_us(100); | ||
35 | } | ||
36 | |||
37 | // Setup twi to run at 100kHz | ||
38 | void i2c_master_init(void) { | ||
39 | // no prescaler | ||
40 | TWSR = 0; | ||
41 | // Set TWI clock frequency to SCL_CLOCK. Need TWBR>10. | ||
42 | // Check datasheets for more info. | ||
43 | TWBR = ((F_CPU/SCL_CLOCK)-16)/2; | ||
44 | } | ||
45 | |||
46 | // Start a transaction with the given i2c slave address. The direction of the | ||
47 | // transfer is set with I2C_READ and I2C_WRITE. | ||
48 | // returns: 0 => success | ||
49 | // 1 => error | ||
50 | uint8_t i2c_master_start(uint8_t address) { | ||
51 | TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTA); | ||
52 | |||
53 | i2c_delay(); | ||
54 | |||
55 | // check that we started successfully | ||
56 | if ( (TW_STATUS != TW_START) && (TW_STATUS != TW_REP_START)) | ||
57 | return 1; | ||
58 | |||
59 | TWDR = address; | ||
60 | TWCR = (1<<TWINT) | (1<<TWEN); | ||
61 | |||
62 | i2c_delay(); | ||
63 | |||
64 | if ( (TW_STATUS != TW_MT_SLA_ACK) && (TW_STATUS != TW_MR_SLA_ACK) ) | ||
65 | return 1; // slave did not acknowledge | ||
66 | else | ||
67 | return 0; // success | ||
68 | } | ||
69 | |||
70 | |||
71 | // Finish the i2c transaction. | ||
72 | void i2c_master_stop(void) { | ||
73 | TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO); | ||
74 | |||
75 | uint16_t lim = 0; | ||
76 | while(!(TWCR & (1<<TWSTO)) && lim < I2C_LOOP_TIMEOUT) | ||
77 | lim++; | ||
78 | } | ||
79 | |||
80 | // Write one byte to the i2c slave. | ||
81 | // returns 0 => slave ACK | ||
82 | // 1 => slave NACK | ||
83 | uint8_t i2c_master_write(uint8_t data) { | ||
84 | TWDR = data; | ||
85 | TWCR = (1<<TWINT) | (1<<TWEN); | ||
86 | |||
87 | i2c_delay(); | ||
88 | |||
89 | // check if the slave acknowledged us | ||
90 | return (TW_STATUS == TW_MT_DATA_ACK) ? 0 : 1; | ||
91 | } | ||
92 | |||
93 | // Read one byte from the i2c slave. If ack=1 the slave is acknowledged, | ||
94 | // if ack=0 the acknowledge bit is not set. | ||
95 | // returns: byte read from i2c device | ||
96 | uint8_t i2c_master_read(int ack) { | ||
97 | TWCR = (1<<TWINT) | (1<<TWEN) | (ack<<TWEA); | ||
98 | |||
99 | i2c_delay(); | ||
100 | return TWDR; | ||
101 | } | ||
102 | |||
103 | void i2c_reset_state(void) { | ||
104 | TWCR = 0; | ||
105 | } | ||
106 | |||
107 | void i2c_slave_init(uint8_t address) { | ||
108 | TWAR = address << 0; // slave i2c address | ||
109 | // TWEN - twi enable | ||
110 | // TWEA - enable address acknowledgement | ||
111 | // TWINT - twi interrupt flag | ||
112 | // TWIE - enable the twi interrupt | ||
113 | TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN); | ||
114 | } | ||
115 | |||
116 | ISR(TWI_vect); | ||
117 | |||
118 | ISR(TWI_vect) { | ||
119 | uint8_t ack = 1; | ||
120 | switch(TW_STATUS) { | ||
121 | case TW_SR_SLA_ACK: | ||
122 | // this device has been addressed as a slave receiver | ||
123 | slave_has_register_set = false; | ||
124 | break; | ||
125 | |||
126 | case TW_SR_DATA_ACK: | ||
127 | // this device has received data as a slave receiver | ||
128 | // The first byte that we receive in this transaction sets the location | ||
129 | // of the read/write location of the slaves memory that it exposes over | ||
130 | // i2c. After that, bytes will be written at slave_buffer_pos, incrementing | ||
131 | // slave_buffer_pos after each write. | ||
132 | if(!slave_has_register_set) { | ||
133 | slave_buffer_pos = TWDR; | ||
134 | // don't acknowledge the master if this memory loctaion is out of bounds | ||
135 | if ( slave_buffer_pos >= SLAVE_BUFFER_SIZE ) { | ||
136 | ack = 0; | ||
137 | slave_buffer_pos = 0; | ||
138 | } | ||
139 | slave_has_register_set = true; | ||
140 | } else { | ||
141 | i2c_slave_buffer[slave_buffer_pos] = TWDR; | ||
142 | BUFFER_POS_INC(); | ||
143 | } | ||
144 | break; | ||
145 | |||
146 | case TW_ST_SLA_ACK: | ||
147 | case TW_ST_DATA_ACK: | ||
148 | // master has addressed this device as a slave transmitter and is | ||
149 | // requesting data. | ||
150 | TWDR = i2c_slave_buffer[slave_buffer_pos]; | ||
151 | BUFFER_POS_INC(); | ||
152 | break; | ||
153 | |||
154 | case TW_BUS_ERROR: // something went wrong, reset twi state | ||
155 | TWCR = 0; | ||
156 | default: | ||
157 | break; | ||
158 | } | ||
159 | // Reset everything, so we are ready for the next TWI interrupt | ||
160 | TWCR |= (1<<TWIE) | (1<<TWINT) | (ack<<TWEA) | (1<<TWEN); | ||
161 | } | ||
162 | #endif | ||
diff --git a/keyboards/iris/i2c.h b/keyboards/iris/i2c.h deleted file mode 100644 index 43e596988..000000000 --- a/keyboards/iris/i2c.h +++ /dev/null | |||
@@ -1,49 +0,0 @@ | |||
1 | #ifndef I2C_H | ||
2 | #define I2C_H | ||
3 | |||
4 | #include <stdint.h> | ||
5 | |||
6 | #ifndef F_CPU | ||
7 | #define F_CPU 16000000UL | ||
8 | #endif | ||
9 | |||
10 | #define I2C_READ 1 | ||
11 | #define I2C_WRITE 0 | ||
12 | |||
13 | #define I2C_ACK 1 | ||
14 | #define I2C_NACK 0 | ||
15 | |||
16 | #define SLAVE_BUFFER_SIZE 0x10 | ||
17 | |||
18 | // i2c SCL clock frequency | ||
19 | #define SCL_CLOCK 100000L | ||
20 | |||
21 | extern volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE]; | ||
22 | |||
23 | void i2c_master_init(void); | ||
24 | uint8_t i2c_master_start(uint8_t address); | ||
25 | void i2c_master_stop(void); | ||
26 | uint8_t i2c_master_write(uint8_t data); | ||
27 | uint8_t i2c_master_read(int); | ||
28 | void i2c_reset_state(void); | ||
29 | void i2c_slave_init(uint8_t address); | ||
30 | |||
31 | |||
32 | static inline unsigned char i2c_start_read(unsigned char addr) { | ||
33 | return i2c_master_start((addr << 1) | I2C_READ); | ||
34 | } | ||
35 | |||
36 | static inline unsigned char i2c_start_write(unsigned char addr) { | ||
37 | return i2c_master_start((addr << 1) | I2C_WRITE); | ||
38 | } | ||
39 | |||
40 | // from SSD1306 scrips | ||
41 | extern unsigned char i2c_rep_start(unsigned char addr); | ||
42 | extern void i2c_start_wait(unsigned char addr); | ||
43 | extern unsigned char i2c_readAck(void); | ||
44 | extern unsigned char i2c_readNak(void); | ||
45 | extern unsigned char i2c_read(unsigned char ack); | ||
46 | |||
47 | #define i2c_read(ack) (ack) ? i2c_readAck() : i2c_readNak(); | ||
48 | |||
49 | #endif | ||
diff --git a/keyboards/iris/matrix.c b/keyboards/iris/matrix.c deleted file mode 100644 index 217264f26..000000000 --- a/keyboards/iris/matrix.c +++ /dev/null | |||
@@ -1,484 +0,0 @@ | |||
1 | /* | ||
2 | Copyright 2017 Danny Nguyen <danny@keeb.io> | ||
3 | |||
4 | This program is free software: you can redistribute it and/or modify | ||
5 | it under the terms of the GNU General Public License as published by | ||
6 | the Free Software Foundation, either version 2 of the License, or | ||
7 | (at your option) any later version. | ||
8 | |||
9 | This program is distributed in the hope that it will be useful, | ||
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
12 | GNU General Public License for more details. | ||
13 | |||
14 | You should have received a copy of the GNU General Public License | ||
15 | along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
16 | */ | ||
17 | |||
18 | /* | ||
19 | * scan matrix | ||
20 | */ | ||
21 | #include <stdint.h> | ||
22 | #include <stdbool.h> | ||
23 | #include <avr/io.h> | ||
24 | #include "wait.h" | ||
25 | #include "print.h" | ||
26 | #include "debug.h" | ||
27 | #include "util.h" | ||
28 | #include "matrix.h" | ||
29 | #include "split_util.h" | ||
30 | #include "pro_micro.h" | ||
31 | #include "config.h" | ||
32 | #include "timer.h" | ||
33 | |||
34 | #ifdef BACKLIGHT_ENABLE | ||
35 | #include "backlight.h" | ||
36 | extern backlight_config_t backlight_config; | ||
37 | #endif | ||
38 | |||
39 | #ifdef USE_I2C | ||
40 | # include "i2c.h" | ||
41 | #else // USE_SERIAL | ||
42 | # include "serial.h" | ||
43 | #endif | ||
44 | |||
45 | #ifndef DEBOUNCING_DELAY | ||
46 | # define DEBOUNCING_DELAY 5 | ||
47 | #endif | ||
48 | |||
49 | #if (DEBOUNCING_DELAY > 0) | ||
50 | static uint16_t debouncing_time; | ||
51 | static bool debouncing = false; | ||
52 | #endif | ||
53 | |||
54 | #if (MATRIX_COLS <= 8) | ||
55 | # define print_matrix_header() print("\nr/c 01234567\n") | ||
56 | # define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row)) | ||
57 | # define matrix_bitpop(i) bitpop(matrix[i]) | ||
58 | # define ROW_SHIFTER ((uint8_t)1) | ||
59 | #else | ||
60 | # error "Currently only supports 8 COLS" | ||
61 | #endif | ||
62 | static matrix_row_t matrix_debouncing[MATRIX_ROWS]; | ||
63 | |||
64 | #define ERROR_DISCONNECT_COUNT 5 | ||
65 | |||
66 | #define SERIAL_LED_ADDR 0x00 | ||
67 | |||
68 | #define ROWS_PER_HAND (MATRIX_ROWS/2) | ||
69 | |||
70 | static uint8_t error_count = 0; | ||
71 | |||
72 | static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; | ||
73 | static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; | ||
74 | |||
75 | /* matrix state(1:on, 0:off) */ | ||
76 | static matrix_row_t matrix[MATRIX_ROWS]; | ||
77 | static matrix_row_t matrix_debouncing[MATRIX_ROWS]; | ||
78 | |||
79 | #if (DIODE_DIRECTION == COL2ROW) | ||
80 | static void init_cols(void); | ||
81 | static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row); | ||
82 | static void unselect_rows(void); | ||
83 | static void select_row(uint8_t row); | ||
84 | static void unselect_row(uint8_t row); | ||
85 | #elif (DIODE_DIRECTION == ROW2COL) | ||
86 | static void init_rows(void); | ||
87 | static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col); | ||
88 | static void unselect_cols(void); | ||
89 | static void unselect_col(uint8_t col); | ||
90 | static void select_col(uint8_t col); | ||
91 | #endif | ||
92 | |||
93 | __attribute__ ((weak)) | ||
94 | void matrix_init_kb(void) { | ||
95 | matrix_init_user(); | ||
96 | } | ||
97 | |||
98 | __attribute__ ((weak)) | ||
99 | void matrix_scan_kb(void) { | ||
100 | matrix_scan_user(); | ||
101 | } | ||
102 | |||
103 | __attribute__ ((weak)) | ||
104 | void matrix_init_user(void) { | ||
105 | } | ||
106 | |||
107 | __attribute__ ((weak)) | ||
108 | void matrix_scan_user(void) { | ||
109 | } | ||
110 | |||
111 | inline | ||
112 | uint8_t matrix_rows(void) | ||
113 | { | ||
114 | return MATRIX_ROWS; | ||
115 | } | ||
116 | |||
117 | inline | ||
118 | uint8_t matrix_cols(void) | ||
119 | { | ||
120 | return MATRIX_COLS; | ||
121 | } | ||
122 | |||
123 | void matrix_init(void) | ||
124 | { | ||
125 | debug_enable = true; | ||
126 | debug_matrix = true; | ||
127 | debug_mouse = true; | ||
128 | // initialize row and col | ||
129 | unselect_rows(); | ||
130 | init_cols(); | ||
131 | |||
132 | TX_RX_LED_INIT; | ||
133 | |||
134 | // initialize matrix state: all keys off | ||
135 | for (uint8_t i=0; i < MATRIX_ROWS; i++) { | ||
136 | matrix[i] = 0; | ||
137 | matrix_debouncing[i] = 0; | ||
138 | } | ||
139 | |||
140 | matrix_init_quantum(); | ||
141 | |||
142 | } | ||
143 | |||
144 | uint8_t _matrix_scan(void) | ||
145 | { | ||
146 | int offset = isLeftHand ? 0 : (ROWS_PER_HAND); | ||
147 | #if (DIODE_DIRECTION == COL2ROW) | ||
148 | // Set row, read cols | ||
149 | for (uint8_t current_row = 0; current_row < ROWS_PER_HAND; current_row++) { | ||
150 | # if (DEBOUNCING_DELAY > 0) | ||
151 | bool matrix_changed = read_cols_on_row(matrix_debouncing+offset, current_row); | ||
152 | |||
153 | if (matrix_changed) { | ||
154 | debouncing = true; | ||
155 | debouncing_time = timer_read(); | ||
156 | } | ||
157 | |||
158 | # else | ||
159 | read_cols_on_row(matrix+offset, current_row); | ||
160 | # endif | ||
161 | |||
162 | } | ||
163 | |||
164 | #elif (DIODE_DIRECTION == ROW2COL) | ||
165 | // Set col, read rows | ||
166 | for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) { | ||
167 | # if (DEBOUNCING_DELAY > 0) | ||
168 | bool matrix_changed = read_rows_on_col(matrix_debouncing+offset, current_col); | ||
169 | if (matrix_changed) { | ||
170 | debouncing = true; | ||
171 | debouncing_time = timer_read(); | ||
172 | } | ||
173 | # else | ||
174 | read_rows_on_col(matrix+offset, current_col); | ||
175 | # endif | ||
176 | |||
177 | } | ||
178 | #endif | ||
179 | |||
180 | # if (DEBOUNCING_DELAY > 0) | ||
181 | if (debouncing && (timer_elapsed(debouncing_time) > DEBOUNCING_DELAY)) { | ||
182 | for (uint8_t i = 0; i < ROWS_PER_HAND; i++) { | ||
183 | matrix[i+offset] = matrix_debouncing[i+offset]; | ||
184 | } | ||
185 | debouncing = false; | ||
186 | } | ||
187 | # endif | ||
188 | |||
189 | return 1; | ||
190 | } | ||
191 | |||
192 | #ifdef USE_I2C | ||
193 | |||
194 | // Get rows from other half over i2c | ||
195 | int i2c_transaction(void) { | ||
196 | int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; | ||
197 | |||
198 | int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE); | ||
199 | if (err) goto i2c_error; | ||
200 | |||
201 | // start of matrix stored at 0x00 | ||
202 | err = i2c_master_write(0x00); | ||
203 | if (err) goto i2c_error; | ||
204 | |||
205 | #ifdef BACKLIGHT_ENABLE | ||
206 | // Write backlight level for slave to read | ||
207 | err = i2c_master_write(backlight_config.enable ? backlight_config.level : 0); | ||
208 | #else | ||
209 | // Write zero, so our byte index is the same | ||
210 | err = i2c_master_write(0x00); | ||
211 | #endif | ||
212 | if (err) goto i2c_error; | ||
213 | |||
214 | // Start read | ||
215 | err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ); | ||
216 | if (err) goto i2c_error; | ||
217 | |||
218 | if (!err) { | ||
219 | int i; | ||
220 | for (i = 0; i < ROWS_PER_HAND-1; ++i) { | ||
221 | matrix[slaveOffset+i] = i2c_master_read(I2C_ACK); | ||
222 | } | ||
223 | matrix[slaveOffset+i] = i2c_master_read(I2C_NACK); | ||
224 | i2c_master_stop(); | ||
225 | } else { | ||
226 | i2c_error: // the cable is disconnceted, or something else went wrong | ||
227 | i2c_reset_state(); | ||
228 | return err; | ||
229 | } | ||
230 | |||
231 | return 0; | ||
232 | } | ||
233 | |||
234 | #else // USE_SERIAL | ||
235 | |||
236 | int serial_transaction(void) { | ||
237 | int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; | ||
238 | |||
239 | if (serial_update_buffers()) { | ||
240 | return 1; | ||
241 | } | ||
242 | |||
243 | for (int i = 0; i < ROWS_PER_HAND; ++i) { | ||
244 | matrix[slaveOffset+i] = serial_slave_buffer[i]; | ||
245 | } | ||
246 | |||
247 | #ifdef BACKLIGHT_ENABLE | ||
248 | // Write backlight level for slave to read | ||
249 | serial_master_buffer[SERIAL_LED_ADDR] = backlight_config.enable ? backlight_config.level : 0; | ||
250 | #endif | ||
251 | return 0; | ||
252 | } | ||
253 | #endif | ||
254 | |||
255 | uint8_t matrix_scan(void) | ||
256 | { | ||
257 | uint8_t ret = _matrix_scan(); | ||
258 | |||
259 | #ifdef USE_I2C | ||
260 | if( i2c_transaction() ) { | ||
261 | #else // USE_SERIAL | ||
262 | if( serial_transaction() ) { | ||
263 | #endif | ||
264 | // turn on the indicator led when halves are disconnected | ||
265 | TXLED1; | ||
266 | |||
267 | error_count++; | ||
268 | |||
269 | if (error_count > ERROR_DISCONNECT_COUNT) { | ||
270 | // reset other half if disconnected | ||
271 | int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; | ||
272 | for (int i = 0; i < ROWS_PER_HAND; ++i) { | ||
273 | matrix[slaveOffset+i] = 0; | ||
274 | } | ||
275 | } | ||
276 | } else { | ||
277 | // turn off the indicator led on no error | ||
278 | TXLED0; | ||
279 | error_count = 0; | ||
280 | } | ||
281 | matrix_scan_quantum(); | ||
282 | return ret; | ||
283 | } | ||
284 | |||
285 | void matrix_slave_scan(void) { | ||
286 | _matrix_scan(); | ||
287 | |||
288 | int offset = (isLeftHand) ? 0 : ROWS_PER_HAND; | ||
289 | |||
290 | #ifdef USE_I2C | ||
291 | #ifdef BACKLIGHT_ENABLE | ||
292 | // Read backlight level sent from master and update level on slave | ||
293 | backlight_set(i2c_slave_buffer[0]); | ||
294 | #endif | ||
295 | for (int i = 0; i < ROWS_PER_HAND; ++i) { | ||
296 | i2c_slave_buffer[i+1] = matrix[offset+i]; | ||
297 | } | ||
298 | #else // USE_SERIAL | ||
299 | for (int i = 0; i < ROWS_PER_HAND; ++i) { | ||
300 | serial_slave_buffer[i] = matrix[offset+i]; | ||
301 | } | ||
302 | |||
303 | #ifdef BACKLIGHT_ENABLE | ||
304 | // Read backlight level sent from master and update level on slave | ||
305 | backlight_set(serial_master_buffer[SERIAL_LED_ADDR]); | ||
306 | #endif | ||
307 | #endif | ||
308 | } | ||
309 | |||
310 | bool matrix_is_modified(void) | ||
311 | { | ||
312 | if (debouncing) return false; | ||
313 | return true; | ||
314 | } | ||
315 | |||
316 | inline | ||
317 | bool matrix_is_on(uint8_t row, uint8_t col) | ||
318 | { | ||
319 | return (matrix[row] & ((matrix_row_t)1<<col)); | ||
320 | } | ||
321 | |||
322 | inline | ||
323 | matrix_row_t matrix_get_row(uint8_t row) | ||
324 | { | ||
325 | return matrix[row]; | ||
326 | } | ||
327 | |||
328 | void matrix_print(void) | ||
329 | { | ||
330 | print("\nr/c 0123456789ABCDEF\n"); | ||
331 | for (uint8_t row = 0; row < MATRIX_ROWS; row++) { | ||
332 | phex(row); print(": "); | ||
333 | pbin_reverse16(matrix_get_row(row)); | ||
334 | print("\n"); | ||
335 | } | ||
336 | } | ||
337 | |||
338 | uint8_t matrix_key_count(void) | ||
339 | { | ||
340 | uint8_t count = 0; | ||
341 | for (uint8_t i = 0; i < MATRIX_ROWS; i++) { | ||
342 | count += bitpop16(matrix[i]); | ||
343 | } | ||
344 | return count; | ||
345 | } | ||
346 | |||
347 | #if (DIODE_DIRECTION == COL2ROW) | ||
348 | |||
349 | static void init_cols(void) | ||
350 | { | ||
351 | for(uint8_t x = 0; x < MATRIX_COLS; x++) { | ||
352 | uint8_t pin = col_pins[x]; | ||
353 | _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN | ||
354 | _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI | ||
355 | } | ||
356 | } | ||
357 | |||
358 | static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) | ||
359 | { | ||
360 | // Store last value of row prior to reading | ||
361 | matrix_row_t last_row_value = current_matrix[current_row]; | ||
362 | |||
363 | // Clear data in matrix row | ||
364 | current_matrix[current_row] = 0; | ||
365 | |||
366 | // Select row and wait for row selecton to stabilize | ||
367 | select_row(current_row); | ||
368 | wait_us(30); | ||
369 | |||
370 | // For each col... | ||
371 | for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) { | ||
372 | |||
373 | // Select the col pin to read (active low) | ||
374 | uint8_t pin = col_pins[col_index]; | ||
375 | uint8_t pin_state = (_SFR_IO8(pin >> 4) & _BV(pin & 0xF)); | ||
376 | |||
377 | // Populate the matrix row with the state of the col pin | ||
378 | current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index); | ||
379 | } | ||
380 | |||
381 | // Unselect row | ||
382 | unselect_row(current_row); | ||
383 | |||
384 | return (last_row_value != current_matrix[current_row]); | ||
385 | } | ||
386 | |||
387 | static void select_row(uint8_t row) | ||
388 | { | ||
389 | uint8_t pin = row_pins[row]; | ||
390 | _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT | ||
391 | _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW | ||
392 | } | ||
393 | |||
394 | static void unselect_row(uint8_t row) | ||
395 | { | ||
396 | uint8_t pin = row_pins[row]; | ||
397 | _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN | ||
398 | _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI | ||
399 | } | ||
400 | |||
401 | static void unselect_rows(void) | ||
402 | { | ||
403 | for(uint8_t x = 0; x < ROWS_PER_HAND; x++) { | ||
404 | uint8_t pin = row_pins[x]; | ||
405 | _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN | ||
406 | _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI | ||
407 | } | ||
408 | } | ||
409 | |||
410 | #elif (DIODE_DIRECTION == ROW2COL) | ||
411 | |||
412 | static void init_rows(void) | ||
413 | { | ||
414 | for(uint8_t x = 0; x < ROWS_PER_HAND; x++) { | ||
415 | uint8_t pin = row_pins[x]; | ||
416 | _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN | ||
417 | _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI | ||
418 | } | ||
419 | } | ||
420 | |||
421 | static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) | ||
422 | { | ||
423 | bool matrix_changed = false; | ||
424 | |||
425 | // Select col and wait for col selecton to stabilize | ||
426 | select_col(current_col); | ||
427 | wait_us(30); | ||
428 | |||
429 | // For each row... | ||
430 | for(uint8_t row_index = 0; row_index < ROWS_PER_HAND; row_index++) | ||
431 | { | ||
432 | |||
433 | // Store last value of row prior to reading | ||
434 | matrix_row_t last_row_value = current_matrix[row_index]; | ||
435 | |||
436 | // Check row pin state | ||
437 | if ((_SFR_IO8(row_pins[row_index] >> 4) & _BV(row_pins[row_index] & 0xF)) == 0) | ||
438 | { | ||
439 | // Pin LO, set col bit | ||
440 | current_matrix[row_index] |= (ROW_SHIFTER << current_col); | ||
441 | } | ||
442 | else | ||
443 | { | ||
444 | // Pin HI, clear col bit | ||
445 | current_matrix[row_index] &= ~(ROW_SHIFTER << current_col); | ||
446 | } | ||
447 | |||
448 | // Determine if the matrix changed state | ||
449 | if ((last_row_value != current_matrix[row_index]) && !(matrix_changed)) | ||
450 | { | ||
451 | matrix_changed = true; | ||
452 | } | ||
453 | } | ||
454 | |||
455 | // Unselect col | ||
456 | unselect_col(current_col); | ||
457 | |||
458 | return matrix_changed; | ||
459 | } | ||
460 | |||
461 | static void select_col(uint8_t col) | ||
462 | { | ||
463 | uint8_t pin = col_pins[col]; | ||
464 | _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT | ||
465 | _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW | ||
466 | } | ||
467 | |||
468 | static void unselect_col(uint8_t col) | ||
469 | { | ||
470 | uint8_t pin = col_pins[col]; | ||
471 | _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN | ||
472 | _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI | ||
473 | } | ||
474 | |||
475 | static void unselect_cols(void) | ||
476 | { | ||
477 | for(uint8_t x = 0; x < MATRIX_COLS; x++) { | ||
478 | uint8_t pin = col_pins[x]; | ||
479 | _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN | ||
480 | _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI | ||
481 | } | ||
482 | } | ||
483 | |||
484 | #endif | ||
diff --git a/keyboards/iris/rules.mk b/keyboards/iris/rules.mk index db4bf3a1e..07d78059e 100644 --- a/keyboards/iris/rules.mk +++ b/keyboards/iris/rules.mk | |||
@@ -1,8 +1,3 @@ | |||
1 | SRC += matrix.c \ | ||
2 | i2c.c \ | ||
3 | split_util.c \ | ||
4 | serial.c | ||
5 | |||
6 | # MCU name | 1 | # MCU name |
7 | #MCU = at90usb1287 | 2 | #MCU = at90usb1287 |
8 | MCU = atmega32u4 | 3 | MCU = atmega32u4 |
@@ -69,6 +64,6 @@ USE_I2C = yes | |||
69 | # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE | 64 | # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE |
70 | SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend | 65 | SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend |
71 | 66 | ||
72 | CUSTOM_MATRIX = yes | 67 | SPLIT_KEYBOARD = yes |
73 | 68 | ||
74 | DEFAULT_FOLDER = iris/rev2 | 69 | DEFAULT_FOLDER = iris/rev2 |
diff --git a/keyboards/iris/serial.c b/keyboards/iris/serial.c deleted file mode 100644 index 74bcbb6bf..000000000 --- a/keyboards/iris/serial.c +++ /dev/null | |||
@@ -1,228 +0,0 @@ | |||
1 | /* | ||
2 | * WARNING: be careful changing this code, it is very timing dependent | ||
3 | */ | ||
4 | |||
5 | #ifndef F_CPU | ||
6 | #define F_CPU 16000000 | ||
7 | #endif | ||
8 | |||
9 | #include <avr/io.h> | ||
10 | #include <avr/interrupt.h> | ||
11 | #include <util/delay.h> | ||
12 | #include <stdbool.h> | ||
13 | #include "serial.h" | ||
14 | |||
15 | #ifndef USE_I2C | ||
16 | |||
17 | // Serial pulse period in microseconds. Its probably a bad idea to lower this | ||
18 | // value. | ||
19 | #define SERIAL_DELAY 24 | ||
20 | |||
21 | uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0}; | ||
22 | uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0}; | ||
23 | |||
24 | #define SLAVE_DATA_CORRUPT (1<<0) | ||
25 | volatile uint8_t status = 0; | ||
26 | |||
27 | inline static | ||
28 | void serial_delay(void) { | ||
29 | _delay_us(SERIAL_DELAY); | ||
30 | } | ||
31 | |||
32 | inline static | ||
33 | void serial_output(void) { | ||
34 | SERIAL_PIN_DDR |= SERIAL_PIN_MASK; | ||
35 | } | ||
36 | |||
37 | // make the serial pin an input with pull-up resistor | ||
38 | inline static | ||
39 | void serial_input(void) { | ||
40 | SERIAL_PIN_DDR &= ~SERIAL_PIN_MASK; | ||
41 | SERIAL_PIN_PORT |= SERIAL_PIN_MASK; | ||
42 | } | ||
43 | |||
44 | inline static | ||
45 | uint8_t serial_read_pin(void) { | ||
46 | return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK); | ||
47 | } | ||
48 | |||
49 | inline static | ||
50 | void serial_low(void) { | ||
51 | SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK; | ||
52 | } | ||
53 | |||
54 | inline static | ||
55 | void serial_high(void) { | ||
56 | SERIAL_PIN_PORT |= SERIAL_PIN_MASK; | ||
57 | } | ||
58 | |||
59 | void serial_master_init(void) { | ||
60 | serial_output(); | ||
61 | serial_high(); | ||
62 | } | ||
63 | |||
64 | void serial_slave_init(void) { | ||
65 | serial_input(); | ||
66 | |||
67 | // Enable INT0 | ||
68 | EIMSK |= _BV(INT0); | ||
69 | // Trigger on falling edge of INT0 | ||
70 | EICRA &= ~(_BV(ISC00) | _BV(ISC01)); | ||
71 | } | ||
72 | |||
73 | // Used by the master to synchronize timing with the slave. | ||
74 | static | ||
75 | void sync_recv(void) { | ||
76 | serial_input(); | ||
77 | // This shouldn't hang if the slave disconnects because the | ||
78 | // serial line will float to high if the slave does disconnect. | ||
79 | while (!serial_read_pin()); | ||
80 | serial_delay(); | ||
81 | } | ||
82 | |||
83 | // Used by the slave to send a synchronization signal to the master. | ||
84 | static | ||
85 | void sync_send(void) { | ||
86 | serial_output(); | ||
87 | |||
88 | serial_low(); | ||
89 | serial_delay(); | ||
90 | |||
91 | serial_high(); | ||
92 | } | ||
93 | |||
94 | // Reads a byte from the serial line | ||
95 | static | ||
96 | uint8_t serial_read_byte(void) { | ||
97 | uint8_t byte = 0; | ||
98 | serial_input(); | ||
99 | for ( uint8_t i = 0; i < 8; ++i) { | ||
100 | byte = (byte << 1) | serial_read_pin(); | ||
101 | serial_delay(); | ||
102 | _delay_us(1); | ||
103 | } | ||
104 | |||
105 | return byte; | ||
106 | } | ||
107 | |||
108 | // Sends a byte with MSB ordering | ||
109 | static | ||
110 | void serial_write_byte(uint8_t data) { | ||
111 | uint8_t b = 8; | ||
112 | serial_output(); | ||
113 | while( b-- ) { | ||
114 | if(data & (1 << b)) { | ||
115 | serial_high(); | ||
116 | } else { | ||
117 | serial_low(); | ||
118 | } | ||
119 | serial_delay(); | ||
120 | } | ||
121 | } | ||
122 | |||
123 | // interrupt handle to be used by the slave device | ||
124 | ISR(SERIAL_PIN_INTERRUPT) { | ||
125 | sync_send(); | ||
126 | |||
127 | uint8_t checksum = 0; | ||
128 | for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) { | ||
129 | serial_write_byte(serial_slave_buffer[i]); | ||
130 | sync_send(); | ||
131 | checksum += serial_slave_buffer[i]; | ||
132 | } | ||
133 | serial_write_byte(checksum); | ||
134 | sync_send(); | ||
135 | |||
136 | // wait for the sync to finish sending | ||
137 | serial_delay(); | ||
138 | |||
139 | // read the middle of pulses | ||
140 | _delay_us(SERIAL_DELAY/2); | ||
141 | |||
142 | uint8_t checksum_computed = 0; | ||
143 | for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) { | ||
144 | serial_master_buffer[i] = serial_read_byte(); | ||
145 | sync_send(); | ||
146 | checksum_computed += serial_master_buffer[i]; | ||
147 | } | ||
148 | uint8_t checksum_received = serial_read_byte(); | ||
149 | sync_send(); | ||
150 | |||
151 | serial_input(); // end transaction | ||
152 | |||
153 | if ( checksum_computed != checksum_received ) { | ||
154 | status |= SLAVE_DATA_CORRUPT; | ||
155 | } else { | ||
156 | status &= ~SLAVE_DATA_CORRUPT; | ||
157 | } | ||
158 | } | ||
159 | |||
160 | inline | ||
161 | bool serial_slave_DATA_CORRUPT(void) { | ||
162 | return status & SLAVE_DATA_CORRUPT; | ||
163 | } | ||
164 | |||
165 | // Copies the serial_slave_buffer to the master and sends the | ||
166 | // serial_master_buffer to the slave. | ||
167 | // | ||
168 | // Returns: | ||
169 | // 0 => no error | ||
170 | // 1 => slave did not respond | ||
171 | int serial_update_buffers(void) { | ||
172 | // this code is very time dependent, so we need to disable interrupts | ||
173 | cli(); | ||
174 | |||
175 | // signal to the slave that we want to start a transaction | ||
176 | serial_output(); | ||
177 | serial_low(); | ||
178 | _delay_us(1); | ||
179 | |||
180 | // wait for the slaves response | ||
181 | serial_input(); | ||
182 | serial_high(); | ||
183 | _delay_us(SERIAL_DELAY); | ||
184 | |||
185 | // check if the slave is present | ||
186 | if (serial_read_pin()) { | ||
187 | // slave failed to pull the line low, assume not present | ||
188 | sei(); | ||
189 | return 1; | ||
190 | } | ||
191 | |||
192 | // if the slave is present syncronize with it | ||
193 | sync_recv(); | ||
194 | |||
195 | uint8_t checksum_computed = 0; | ||
196 | // receive data from the slave | ||
197 | for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) { | ||
198 | serial_slave_buffer[i] = serial_read_byte(); | ||
199 | sync_recv(); | ||
200 | checksum_computed += serial_slave_buffer[i]; | ||
201 | } | ||
202 | uint8_t checksum_received = serial_read_byte(); | ||
203 | sync_recv(); | ||
204 | |||
205 | if (checksum_computed != checksum_received) { | ||
206 | sei(); | ||
207 | return 1; | ||
208 | } | ||
209 | |||
210 | uint8_t checksum = 0; | ||
211 | // send data to the slave | ||
212 | for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) { | ||
213 | serial_write_byte(serial_master_buffer[i]); | ||
214 | sync_recv(); | ||
215 | checksum += serial_master_buffer[i]; | ||
216 | } | ||
217 | serial_write_byte(checksum); | ||
218 | sync_recv(); | ||
219 | |||
220 | // always, release the line when not in use | ||
221 | serial_output(); | ||
222 | serial_high(); | ||
223 | |||
224 | sei(); | ||
225 | return 0; | ||
226 | } | ||
227 | |||
228 | #endif | ||
diff --git a/keyboards/iris/serial.h b/keyboards/iris/serial.h deleted file mode 100644 index 15fe4db7b..000000000 --- a/keyboards/iris/serial.h +++ /dev/null | |||
@@ -1,26 +0,0 @@ | |||
1 | #ifndef MY_SERIAL_H | ||
2 | #define MY_SERIAL_H | ||
3 | |||
4 | #include "config.h" | ||
5 | #include <stdbool.h> | ||
6 | |||
7 | /* TODO: some defines for interrupt setup */ | ||
8 | #define SERIAL_PIN_DDR DDRD | ||
9 | #define SERIAL_PIN_PORT PORTD | ||
10 | #define SERIAL_PIN_INPUT PIND | ||
11 | #define SERIAL_PIN_MASK _BV(PD0) | ||
12 | #define SERIAL_PIN_INTERRUPT INT0_vect | ||
13 | |||
14 | #define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2 | ||
15 | #define SERIAL_MASTER_BUFFER_LENGTH 1 | ||
16 | |||
17 | // Buffers for master - slave communication | ||
18 | extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH]; | ||
19 | extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH]; | ||
20 | |||
21 | void serial_master_init(void); | ||
22 | void serial_slave_init(void); | ||
23 | int serial_update_buffers(void); | ||
24 | bool serial_slave_data_corrupt(void); | ||
25 | |||
26 | #endif | ||
diff --git a/keyboards/iris/split_rgb.c b/keyboards/iris/split_rgb.c deleted file mode 100644 index 6d7cb44cf..000000000 --- a/keyboards/iris/split_rgb.c +++ /dev/null | |||
@@ -1,41 +0,0 @@ | |||
1 | #include <stdint.h> | ||
2 | #include <stdbool.h> | ||
3 | #include "split_util.h" | ||
4 | #include "progmem.h" | ||
5 | #include "print.h" | ||
6 | #include "rgblight.h" | ||
7 | |||
8 | #ifdef USE_I2C | ||
9 | # include "i2c.h" | ||
10 | #else // USE_SERIAL | ||
11 | # include "serial.h" | ||
12 | #endif | ||
13 | |||
14 | |||
15 | rgblight_config_t rgblight_config; | ||
16 | |||
17 | void rgblight_slave_update(void) { | ||
18 | //rgblight_effect_christmas(); | ||
19 | } | ||
20 | |||
21 | |||
22 | void rgblight_set(void) { | ||
23 | if (rgblight_config.enable) { | ||
24 | #ifdef RGBW | ||
25 | ws2812_setleds_rgbw(led, RGBLED_NUM); | ||
26 | #else | ||
27 | ws2812_setleds(led, RGBLED_NUM); | ||
28 | #endif | ||
29 | } else { | ||
30 | for (uint8_t i = 0; i < RGBLED_NUM; i++) { | ||
31 | led[i].r = 0; | ||
32 | led[i].g = 0; | ||
33 | led[i].b = 0; | ||
34 | } | ||
35 | #ifdef RGBW | ||
36 | ws2812_setleds_rgbw(led, RGBLED_NUM); | ||
37 | #else | ||
38 | ws2812_setleds(led, RGBLED_NUM); | ||
39 | #endif | ||
40 | } | ||
41 | } | ||
diff --git a/keyboards/iris/split_rgb.h b/keyboards/iris/split_rgb.h deleted file mode 100644 index 5f552890a..000000000 --- a/keyboards/iris/split_rgb.h +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | #ifndef SPLIT_RGB_H | ||
2 | #define SPLIT_RGB_H | ||
3 | |||
4 | void rgblight_slave_update(void); | ||
5 | |||
6 | #endif | ||
diff --git a/keyboards/iris/split_util.c b/keyboards/iris/split_util.c deleted file mode 100644 index 346cbc908..000000000 --- a/keyboards/iris/split_util.c +++ /dev/null | |||
@@ -1,86 +0,0 @@ | |||
1 | #include <avr/io.h> | ||
2 | #include <avr/wdt.h> | ||
3 | #include <avr/power.h> | ||
4 | #include <avr/interrupt.h> | ||
5 | #include <util/delay.h> | ||
6 | #include <avr/eeprom.h> | ||
7 | #include "split_util.h" | ||
8 | #include "matrix.h" | ||
9 | #include "keyboard.h" | ||
10 | #include "config.h" | ||
11 | #include "timer.h" | ||
12 | |||
13 | #ifdef USE_I2C | ||
14 | # include "i2c.h" | ||
15 | #else | ||
16 | # include "serial.h" | ||
17 | #endif | ||
18 | |||
19 | volatile bool isLeftHand = true; | ||
20 | |||
21 | static void setup_handedness(void) { | ||
22 | #ifdef EE_HANDS | ||
23 | isLeftHand = eeprom_read_byte(EECONFIG_HANDEDNESS); | ||
24 | #else | ||
25 | // I2C_MASTER_RIGHT is deprecated, use MASTER_RIGHT instead, since this works for both serial and i2c | ||
26 | #if defined(I2C_MASTER_RIGHT) || defined(MASTER_RIGHT) | ||
27 | isLeftHand = !has_usb(); | ||
28 | #else | ||
29 | isLeftHand = has_usb(); | ||
30 | #endif | ||
31 | #endif | ||
32 | } | ||
33 | |||
34 | static void keyboard_master_setup(void) { | ||
35 | #ifdef USE_I2C | ||
36 | i2c_master_init(); | ||
37 | #ifdef SSD1306OLED | ||
38 | matrix_master_OLED_init (); | ||
39 | #endif | ||
40 | #else | ||
41 | serial_master_init(); | ||
42 | #endif | ||
43 | } | ||
44 | |||
45 | static void keyboard_slave_setup(void) { | ||
46 | timer_init(); | ||
47 | #ifdef USE_I2C | ||
48 | i2c_slave_init(SLAVE_I2C_ADDRESS); | ||
49 | #else | ||
50 | serial_slave_init(); | ||
51 | #endif | ||
52 | } | ||
53 | |||
54 | bool has_usb(void) { | ||
55 | USBCON |= (1 << OTGPADE); //enables VBUS pad | ||
56 | _delay_us(5); | ||
57 | return (USBSTA & (1<<VBUS)); //checks state of VBUS | ||
58 | } | ||
59 | |||
60 | void split_keyboard_setup(void) { | ||
61 | setup_handedness(); | ||
62 | |||
63 | if (has_usb()) { | ||
64 | keyboard_master_setup(); | ||
65 | } else { | ||
66 | keyboard_slave_setup(); | ||
67 | } | ||
68 | sei(); | ||
69 | } | ||
70 | |||
71 | void keyboard_slave_loop(void) { | ||
72 | matrix_init(); | ||
73 | |||
74 | while (1) { | ||
75 | matrix_slave_scan(); | ||
76 | } | ||
77 | } | ||
78 | |||
79 | // this code runs before the usb and keyboard is initialized | ||
80 | void matrix_setup(void) { | ||
81 | split_keyboard_setup(); | ||
82 | |||
83 | if (!has_usb()) { | ||
84 | keyboard_slave_loop(); | ||
85 | } | ||
86 | } | ||
diff --git a/keyboards/iris/split_util.h b/keyboards/iris/split_util.h deleted file mode 100644 index 595a0659e..000000000 --- a/keyboards/iris/split_util.h +++ /dev/null | |||
@@ -1,20 +0,0 @@ | |||
1 | #ifndef SPLIT_KEYBOARD_UTIL_H | ||
2 | #define SPLIT_KEYBOARD_UTIL_H | ||
3 | |||
4 | #include <stdbool.h> | ||
5 | #include "eeconfig.h" | ||
6 | |||
7 | #define SLAVE_I2C_ADDRESS 0x32 | ||
8 | |||
9 | extern volatile bool isLeftHand; | ||
10 | |||
11 | // slave version of matix scan, defined in matrix.c | ||
12 | void matrix_slave_scan(void); | ||
13 | |||
14 | void split_keyboard_setup(void); | ||
15 | bool has_usb(void); | ||
16 | void keyboard_slave_loop(void); | ||
17 | |||
18 | void matrix_master_OLED_init (void); | ||
19 | |||
20 | #endif | ||
diff --git a/quantum/split_common/matrix.c b/quantum/split_common/matrix.c index 5e5475f44..0a79e4256 100644 --- a/quantum/split_common/matrix.c +++ b/quantum/split_common/matrix.c | |||
@@ -37,6 +37,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
37 | #endif | 37 | #endif |
38 | #ifdef BACKLIGHT_ENABLE | 38 | #ifdef BACKLIGHT_ENABLE |
39 | # include "backlight.h" | 39 | # include "backlight.h" |
40 | extern backlight_config_t backlight_config; | ||
40 | #endif | 41 | #endif |
41 | 42 | ||
42 | #if defined(USE_I2C) || defined(EH) | 43 | #if defined(USE_I2C) || defined(EH) |