1552cf2ddca1668c5230506de03e6b4a870f8961
- Author
- Ryan <fauxpark@gmail.com>
- Committer
- GitHub <noreply@github.com>
- Date
Message
Update atomic GPIO macros in keyboard custom matrix (#23796)
Diff
This diff is truncated to protect this page.
1diff --git a/keyboards/argyle/matrix.c b/keyboards/argyle/matrix.c
2index d435b368c228a2820ac73d740a368de728fe7e5a..661310ade0dc1d5651e58bd55846748781bed32c 100644
3--- a/keyboards/argyle/matrix.c
4+++ b/keyboards/argyle/matrix.c
5@@ -24,21 +24,21 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
6 static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
7 static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
8
9-static inline void setPinOutput_writeLow(pin_t pin) {
10+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
11 ATOMIC_BLOCK_FORCEON {
12 gpio_set_pin_output(pin);
13 gpio_write_pin_low(pin);
14 }
15 }
16
17-static inline void setPinOutput_writeHigh(pin_t pin) {
18+static inline void gpio_atomic_set_pin_output_high(pin_t pin) {
19 ATOMIC_BLOCK_FORCEON {
20 gpio_set_pin_output(pin);
21 gpio_write_pin_high(pin);
22 }
23 }
24
25-static inline void setPinInputHigh_atomic(pin_t pin) {
26+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
27 ATOMIC_BLOCK_FORCEON {
28 gpio_set_pin_input_high(pin);
29 }
30@@ -55,7 +55,7 @@ static inline uint8_t readMatrixPin(pin_t pin) {
31 static bool select_row(uint8_t row) {
32 pin_t pin = row_pins[row];
33 if (pin != NO_PIN) {
34- setPinOutput_writeLow(pin);
35+ gpio_atomic_set_pin_output_low(pin);
36 return true;
37 }
38 return false;
39@@ -64,7 +64,7 @@ static bool select_row(uint8_t row) {
40 static void unselect_row(uint8_t row) {
41 pin_t pin = row_pins[row];
42 if (pin != NO_PIN) {
43- setPinInputHigh_atomic(pin);
44+ gpio_atomic_set_pin_input_high(pin);
45 }
46 }
47
48@@ -84,7 +84,7 @@ static void init_pins(void) {
49
50 for (uint8_t x = 0; x < MATRIX_COLS; x++) {
51 if (col_pins[x] != NO_PIN) {
52- setPinInputHigh_atomic(col_pins[x]);
53+ gpio_atomic_set_pin_input_high(col_pins[x]);
54 }
55 }
56 }
57diff --git a/keyboards/gmmk/numpad/matrix.c b/keyboards/gmmk/numpad/matrix.c
58index 4ec41bdb7325b01068a7fa12b2a4b7928ffec759..8d6e641a77d517ecd2b4e242eca8ade6e404efef 100644
59--- a/keyboards/gmmk/numpad/matrix.c
60+++ b/keyboards/gmmk/numpad/matrix.c
61@@ -19,21 +19,21 @@ static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
62 static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
63 #define MATRIX_ROW_SHIFTER ((matrix_row_t)1)
64
65-static inline void setPinOutput_writeLow(pin_t pin) {
66+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
67 ATOMIC_BLOCK_FORCEON {
68 gpio_set_pin_output(pin);
69 gpio_write_pin_low(pin);
70 }
71 }
72
73-static inline void setPinOutput_writeHigh(pin_t pin) {
74+static inline void gpio_atomic_set_pin_output_high(pin_t pin) {
75 ATOMIC_BLOCK_FORCEON {
76 gpio_set_pin_output(pin);
77 gpio_write_pin_high(pin);
78 }
79 }
80
81-static inline void setPinInputHigh_atomic(pin_t pin) {
82+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
83 ATOMIC_BLOCK_FORCEON {
84 gpio_set_pin_input_high(pin);
85 }
86@@ -50,7 +50,7 @@ static inline uint8_t readMatrixPin(pin_t pin) {
87 static bool select_col(uint8_t col) {
88 pin_t pin = col_pins[col];
89 if (pin != NO_PIN) {
90- setPinOutput_writeLow(pin);
91+ gpio_atomic_set_pin_output_low(pin);
92 return true;
93 }
94 return false;
95@@ -60,9 +60,9 @@ static void unselect_col(uint8_t col) {
96 pin_t pin = col_pins[col];
97 if (pin != NO_PIN) {
98 # ifdef MATRIX_UNSELECT_DRIVE_HIGH
99- setPinOutput_writeHigh(pin);
100+ gpio_atomic_set_pin_output_high(pin);
101 # else
102- setPinInputHigh_atomic(pin);
103+ gpio_atomic_set_pin_input_high(pin);
104 # endif
105 }
106 }
107@@ -78,10 +78,10 @@ __attribute__((weak)) void matrix_init_custom(void) {
108 unselect_cols();
109 for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
110 if (row_pins[x] != NO_PIN) {
111- setPinInputHigh_atomic(row_pins[x]);
112+ gpio_atomic_set_pin_input_high(row_pins[x]);
113 }
114 }
115- setPinInputHigh_atomic(B8);
116+ gpio_atomic_set_pin_input_high(B8);
117 }
118
119 __attribute__((weak)) void matrix_read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col, matrix_row_t row_shifter) { // Start with a clear matrix row
120diff --git a/keyboards/halfcliff/matrix.c b/keyboards/halfcliff/matrix.c
121index ad3ad6ba09455716c5318a029e4220686a6ac832..790f8c41bb4464714eb4bcc0e2b0e282e60ed14c 100644
122--- a/keyboards/halfcliff/matrix.c
123+++ b/keyboards/halfcliff/matrix.c
124@@ -50,25 +50,25 @@ matrix_row_t matrix_get_row(uint8_t row) { return matrix[row]; }
125
126 void matrix_print(void) {}
127
128-static inline void setPinOutput_writeLow(pin_t pin) {
129+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
130 ATOMIC_BLOCK_FORCEON {
131 gpio_set_pin_output(pin);
132 gpio_write_pin_low(pin);
133 }
134 }
135
136-static inline void setPinInputHigh_atomic(pin_t pin) {
137+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
138 ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); }
139 }
140
141 // matrix code
142-static void select_row(uint8_t row) { setPinOutput_writeLow(row_pins[row]); }
143+static void select_row(uint8_t row) { gpio_atomic_set_pin_output_low(row_pins[row]); }
144
145-static void unselect_row(uint8_t row) { setPinInputHigh_atomic(row_pins[row]); }
146+static void unselect_row(uint8_t row) { gpio_atomic_set_pin_input_high(row_pins[row]); }
147
148 static void unselect_rows(void) {
149 for (uint8_t x = 0; x < ROWS_PER_HAND; x++) {
150- setPinInputHigh_atomic(row_pins[x]);
151+ gpio_atomic_set_pin_input_high(row_pins[x]);
152 }
153 }
154
155@@ -103,24 +103,24 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
156 return false;
157 }
158
159-static void select_col(uint8_t col) { setPinOutput_writeLow(col_pins[col]); }
160+static void select_col(uint8_t col) { gpio_atomic_set_pin_output_low(col_pins[col]); }
161
162-static void unselect_col(uint8_t col) { setPinInputHigh_atomic(col_pins[col]); }
163+static void unselect_col(uint8_t col) { gpio_atomic_set_pin_input_high(col_pins[col]); }
164
165 static void unselect_cols(void) {
166 for (uint8_t x = 0; x < MATRIX_COLS; x++) {
167- setPinInputHigh_atomic(col_pins[x]);
168+ gpio_atomic_set_pin_input_high(col_pins[x]);
169 }
170 }
171
172 static void init_pins(void) {
173 unselect_rows();
174 for (uint8_t x = 0; x < MATRIX_COLS; x++) {
175- setPinInputHigh_atomic(col_pins[x]);
176+ gpio_atomic_set_pin_input_high(col_pins[x]);
177 }
178 unselect_cols();
179 for (uint8_t x = 0; x < ROWS_PER_HAND; x++) {
180- setPinInputHigh_atomic(row_pins[x]);
181+ gpio_atomic_set_pin_input_high(row_pins[x]);
182 }
183 }
184
185diff --git a/keyboards/handwired/symmetric70_proto/matrix_debug/matrix.c b/keyboards/handwired/symmetric70_proto/matrix_debug/matrix.c
186index 786c1b4a73bc4b85153c2ff3eb44471ce6ff056b..fa9b6ef0fd1e0bd3c708207c956285deaac8ed31 100644
187--- a/keyboards/handwired/symmetric70_proto/matrix_debug/matrix.c
188+++ b/keyboards/handwired/symmetric70_proto/matrix_debug/matrix.c
189@@ -60,14 +60,14 @@ static const uint8_t delay_sel[] = {MATRIX_IO_DELAY_MULSEL};
190 extern matrix_row_t raw_matrix[MATRIX_ROWS]; // raw values
191 extern matrix_row_t matrix[MATRIX_ROWS]; // debounced values
192
193-static inline void setPinOutput_writeLow(pin_t pin) {
194+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
195 ATOMIC_BLOCK_FORCEON {
196 gpio_set_pin_output(pin);
197 gpio_write_pin_low(pin);
198 }
199 }
200
201-static inline void setPinInputHigh_atomic(pin_t pin) {
202+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
203 ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); }
204 }
205
206@@ -108,13 +108,13 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
207 #elif defined(DIODE_DIRECTION)
208 # if (DIODE_DIRECTION == COL2ROW)
209
210-static void select_row(uint8_t row) { setPinOutput_writeLow(row_pins[row]); }
211+static void select_row(uint8_t row) { gpio_atomic_set_pin_output_low(row_pins[row]); }
212
213-static void unselect_row(uint8_t row) { setPinInputHigh_atomic(row_pins[row]); }
214+static void unselect_row(uint8_t row) { gpio_atomic_set_pin_input_high(row_pins[row]); }
215
216 static void unselect_rows(void) {
217 for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
218- setPinInputHigh_atomic(row_pins[x]);
219+ gpio_atomic_set_pin_input_high(row_pins[x]);
220 }
221 }
222
223@@ -125,7 +125,7 @@ static void init_pins(void) {
224 # endif
225 unselect_rows();
226 for (uint8_t x = 0; x < MATRIX_COLS; x++) {
227- setPinInputHigh_atomic(col_pins[x]);
228+ gpio_atomic_set_pin_input_high(col_pins[x]);
229 }
230 }
231
232@@ -218,20 +218,20 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
233
234 # elif (DIODE_DIRECTION == ROW2COL)
235
236-static void select_col(uint8_t col) { setPinOutput_writeLow(col_pins[col]); }
237+static void select_col(uint8_t col) { gpio_atomic_set_pin_output_low(col_pins[col]); }
238
239-static void unselect_col(uint8_t col) { setPinInputHigh_atomic(col_pins[col]); }
240+static void unselect_col(uint8_t col) { gpio_atomic_set_pin_input_high(col_pins[col]); }
241
242 static void unselect_cols(void) {
243 for (uint8_t x = 0; x < MATRIX_COLS; x++) {
244- setPinInputHigh_atomic(col_pins[x]);
245+ gpio_atomic_set_pin_input_high(col_pins[x]);
246 }
247 }
248
249 static void init_pins(void) {
250 unselect_cols();
251 for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
252- setPinInputHigh_atomic(row_pins[x]);
253+ gpio_atomic_set_pin_input_high(row_pins[x]);
254 }
255 }
256
257diff --git a/keyboards/keychron/c2_pro/matrix.c b/keyboards/keychron/c2_pro/matrix.c
258index 7d5b3e4e7917cf854f56e02e83c523d1d177cb67..e05ac5e061753825f9805bfe4d52ca80e356ee7b 100644
259--- a/keyboards/keychron/c2_pro/matrix.c
260+++ b/keyboards/keychron/c2_pro/matrix.c
261@@ -41,21 +41,21 @@
262 pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
263 pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
264
265-static inline void setPinOutput_writeLow(pin_t pin) {
266+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
267 ATOMIC_BLOCK_FORCEON {
268 gpio_set_pin_output(pin);
269 gpio_write_pin_low(pin);
270 }
271 }
272
273-static inline void setPinOutput_writeHigh(pin_t pin) {
274+static inline void gpio_atomic_set_pin_output_high(pin_t pin) {
275 ATOMIC_BLOCK_FORCEON {
276 gpio_set_pin_output(pin);
277 gpio_write_pin_high(pin);
278 }
279 }
280
281-static inline void setPinInput_high(pin_t pin) {
282+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
283 ATOMIC_BLOCK_FORCEON {
284 gpio_set_pin_input_high(pin);
285 }
286@@ -106,7 +106,7 @@ static bool select_col(uint8_t col) {
287 pin_t pin = col_pins[col];
288
289 if (col < SHIFT_COL_START || col > SHIFT_COL_END) {
290- setPinOutput_writeLow(pin);
291+ gpio_atomic_set_pin_output_low(pin);
292 return true;
293 } else {
294 if (col == SHIFT_COL_START) {
295@@ -122,9 +122,9 @@ static void unselect_col(uint8_t col) {
296
297 if (col < SHIFT_COL_START || col > SHIFT_COL_END) {
298 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
299- setPinOutput_writeHigh(pin);
300+ gpio_atomic_set_pin_output_high(pin);
301 #else
302- setPinInput_high(pin);
303+ gpio_atomic_set_pin_input_high(pin);
304 #endif
305 } else {
306 HC595_output(0x01, 1);
307@@ -136,9 +136,9 @@ static void unselect_cols(void) {
308 pin_t pin = col_pins[x];
309 if (x < SHIFT_COL_START || x > SHIFT_COL_END) {
310 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
311- setPinOutput_writeHigh(pin);
312+ gpio_atomic_set_pin_output_high(pin);
313 #else
314- setPinInput_high(pin);
315+ gpio_atomic_set_pin_input_high(pin);
316 #endif
317 } else {
318 if (x == SHIFT_COL_START) HC595_output(UNSELECT_ALL_COL, 0);
319@@ -181,7 +181,7 @@ void matrix_init_custom(void) {
320
321 for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
322 if (row_pins[x] != NO_PIN) {
323- setPinInput_high(row_pins[x]);
324+ gpio_atomic_set_pin_input_high(row_pins[x]);
325 }
326 }
327
328diff --git a/keyboards/keychron/q10/matrix.c b/keyboards/keychron/q10/matrix.c
329index b772fd78899673ade114c1fecb37781fbe67ca4c..cd6e842e15daf36d146ce2b10bd55a856416ab1a 100644
330--- a/keyboards/keychron/q10/matrix.c
331+++ b/keyboards/keychron/q10/matrix.c
332@@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
333
334 #define ROWS_PER_HAND (MATRIX_ROWS)
335
336-static inline void setPinOutput_writeLow(pin_t pin) {
337+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
338 ATOMIC_BLOCK_FORCEON {
339 gpio_set_pin_output(pin);
340 gpio_write_pin_low(pin);
341 }
342 }
343
344-static inline void setPinOutput_writeHigh(pin_t pin) {
345+static inline void gpio_atomic_set_pin_output_high(pin_t pin) {
346 ATOMIC_BLOCK_FORCEON {
347 gpio_set_pin_output(pin);
348 gpio_write_pin_high(pin);
349 }
350 }
351
352-static inline void setPinInputHigh_atomic(pin_t pin) {
353+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
354 ATOMIC_BLOCK_FORCEON {
355 gpio_set_pin_input_high(pin);
356 }
357@@ -65,35 +65,35 @@ static inline uint8_t readMatrixPin(pin_t pin) {
358 static void shiftOutMultiple(uint16_t dataOut) {
359 for (uint8_t i = 0; i < 8; i++) {
360 if (dataOut & 0x1) {
361- setPinOutput_writeHigh(DATA_PIN);
362+ gpio_atomic_set_pin_output_high(DATA_PIN);
363 } else {
364- setPinOutput_writeLow(DATA_PIN);
365+ gpio_atomic_set_pin_output_low(DATA_PIN);
366 }
367 dataOut = dataOut >> 1;
368- setPinOutput_writeHigh(CLOCK_PIN);
369- setPinOutput_writeLow(CLOCK_PIN);
370+ gpio_atomic_set_pin_output_high(CLOCK_PIN);
371+ gpio_atomic_set_pin_output_low(CLOCK_PIN);
372 }
373- setPinOutput_writeHigh(LATCH_PIN);
374- setPinOutput_writeLow(LATCH_PIN);
375+ gpio_atomic_set_pin_output_high(LATCH_PIN);
376+ gpio_atomic_set_pin_output_low(LATCH_PIN);
377 }
378
379 static void shiftOut_single(uint8_t dataOut) {
380 if (dataOut & 0x1) {
381- setPinOutput_writeHigh(DATA_PIN);
382+ gpio_atomic_set_pin_output_high(DATA_PIN);
383 } else {
384- setPinOutput_writeLow(DATA_PIN);
385+ gpio_atomic_set_pin_output_low(DATA_PIN);
386 }
387- setPinOutput_writeHigh(CLOCK_PIN);
388- setPinOutput_writeLow(CLOCK_PIN);
389- setPinOutput_writeHigh(LATCH_PIN);
390- setPinOutput_writeLow(LATCH_PIN);
391+ gpio_atomic_set_pin_output_high(CLOCK_PIN);
392+ gpio_atomic_set_pin_output_low(CLOCK_PIN);
393+ gpio_atomic_set_pin_output_high(LATCH_PIN);
394+ gpio_atomic_set_pin_output_low(LATCH_PIN);
395 }
396
397 static bool select_col(uint8_t col) {
398 pin_t pin = col_pins[col];
399
400 if (pin != NO_PIN) {
401- setPinOutput_writeLow(pin);
402+ gpio_atomic_set_pin_output_low(pin);
403 return true;
404 } else {
405 if (col == (MATRIX_COLS - 8)) {
406@@ -111,16 +111,16 @@ static void unselect_col(uint8_t col) {
407
408 if (pin != NO_PIN) {
409 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
410- setPinOutput_writeHigh(pin);
411+ gpio_atomic_set_pin_output_high(pin);
412 #else
413- setPinInputHigh_atomic(pin);
414+ gpio_atomic_set_pin_input_high(pin);
415 #endif
416 } else {
417 if (col == (MATRIX_COLS - 1)) {
418- setPinOutput_writeHigh(CLOCK_PIN);
419- setPinOutput_writeLow(CLOCK_PIN);
420- setPinOutput_writeHigh(LATCH_PIN);
421- setPinOutput_writeLow(LATCH_PIN);
422+ gpio_atomic_set_pin_output_high(CLOCK_PIN);
423+ gpio_atomic_set_pin_output_low(CLOCK_PIN);
424+ gpio_atomic_set_pin_output_high(LATCH_PIN);
425+ gpio_atomic_set_pin_output_low(LATCH_PIN);
426 }
427 }
428 }
429@@ -131,9 +131,9 @@ static void unselect_cols(void) {
430 pin_t pin = col_pins[x];
431 if (pin != NO_PIN) {
432diff --git a/keyboards/keychron/q12/matrix.c b/keyboards/keychron/q12/matrix.c
433index 9d5e9c4d393d7e5647648e94d590e8b9f70da0af..bfb51703a03d9a528aa7ad6bf25dcc43cc829c21 100644
434--- a/keyboards/keychron/q12/matrix.c
435+++ b/keyboards/keychron/q12/matrix.c
436@@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
437
438 #define ROWS_PER_HAND (MATRIX_ROWS)
439
440-static inline void setPinOutput_writeLow(pin_t pin) {
441+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
442 ATOMIC_BLOCK_FORCEON {
443 gpio_set_pin_output(pin);
444 gpio_write_pin_low(pin);
445 }
446 }
447
448-static inline void setPinOutput_writeHigh(pin_t pin) {
449+static inline void gpio_atomic_set_pin_output_high(pin_t pin) {
450 ATOMIC_BLOCK_FORCEON {
451 gpio_set_pin_output(pin);
452 gpio_write_pin_high(pin);
453 }
454 }
455
456-static inline void setPinInputHigh_atomic(pin_t pin) {
457+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
458 ATOMIC_BLOCK_FORCEON {
459 gpio_set_pin_input_high(pin);
460 }
461@@ -65,36 +65,36 @@ static inline uint8_t readMatrixPin(pin_t pin) {
462 static void shiftOut(uint8_t dataOut) {
463 for (uint8_t i = 0; i < 8; i++) {
464 if (dataOut & 0x1) {
465- setPinOutput_writeHigh(DATA_PIN);
466+ gpio_atomic_set_pin_output_high(DATA_PIN);
467 } else {
468- setPinOutput_writeLow(DATA_PIN);
469+ gpio_atomic_set_pin_output_low(DATA_PIN);
470 }
471 dataOut = dataOut >> 1;
472- setPinOutput_writeHigh(CLOCK_PIN);
473- setPinOutput_writeLow(CLOCK_PIN);
474+ gpio_atomic_set_pin_output_high(CLOCK_PIN);
475+ gpio_atomic_set_pin_output_low(CLOCK_PIN);
476 }
477- setPinOutput_writeHigh(LATCH_PIN);
478- setPinOutput_writeLow(LATCH_PIN);
479+ gpio_atomic_set_pin_output_high(LATCH_PIN);
480+ gpio_atomic_set_pin_output_low(LATCH_PIN);
481 }
482
483 static void shiftout_single(uint8_t data) {
484 if (data & 0x1) {
485- setPinOutput_writeHigh(DATA_PIN);
486+ gpio_atomic_set_pin_output_high(DATA_PIN);
487 } else {
488- setPinOutput_writeLow(DATA_PIN);
489+ gpio_atomic_set_pin_output_low(DATA_PIN);
490 }
491- setPinOutput_writeHigh(CLOCK_PIN);
492- setPinOutput_writeLow(CLOCK_PIN);
493+ gpio_atomic_set_pin_output_high(CLOCK_PIN);
494+ gpio_atomic_set_pin_output_low(CLOCK_PIN);
495
496- setPinOutput_writeHigh(LATCH_PIN);
497- setPinOutput_writeLow(LATCH_PIN);
498+ gpio_atomic_set_pin_output_high(LATCH_PIN);
499+ gpio_atomic_set_pin_output_low(LATCH_PIN);
500 }
501
502 static bool select_col(uint8_t col) {
503 pin_t pin = col_pins[col];
504
505 if (pin != NO_PIN) {
506- setPinOutput_writeLow(pin);
507+ gpio_atomic_set_pin_output_low(pin);
508 return true;
509 } else {
510 if (col == 10) {
511@@ -112,16 +112,16 @@ static void unselect_col(uint8_t col) {
512
513 if (pin != NO_PIN) {
514 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
515- setPinOutput_writeHigh(pin);
516+ gpio_atomic_set_pin_output_high(pin);
517 #else
518- setPinInputHigh_atomic(pin);
519+ gpio_atomic_set_pin_input_high(pin);
520 #endif
521 } else {
522 if (col == (MATRIX_COLS - 1))
523- setPinOutput_writeHigh(CLOCK_PIN);
524- setPinOutput_writeLow(CLOCK_PIN);
525- setPinOutput_writeHigh(LATCH_PIN);
526- setPinOutput_writeLow(LATCH_PIN);
527+ gpio_atomic_set_pin_output_high(CLOCK_PIN);
528+ gpio_atomic_set_pin_output_low(CLOCK_PIN);
529+ gpio_atomic_set_pin_output_high(LATCH_PIN);
530+ gpio_atomic_set_pin_output_low(LATCH_PIN);
531 }
532 }
533
534@@ -131,9 +131,9 @@ static void unselect_cols(void) {
535 pin_t pin = col_pins[x];
536diff --git a/keyboards/keychron/q1v2/matrix.c b/keyboards/keychron/q1v2/matrix.c
537index 8e01bdb73e0c3a4a6d47c5212f62084a34d5f7ff..5fa60c1b1d0f05b0b80f80eb88157dd4d49ff125 100644
538--- a/keyboards/keychron/q1v2/matrix.c
539+++ b/keyboards/keychron/q1v2/matrix.c
540@@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
541
542 #define ROWS_PER_HAND (MATRIX_ROWS)
543
544-static inline void setPinOutput_writeLow(pin_t pin) {
545+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
546 ATOMIC_BLOCK_FORCEON {
547 gpio_set_pin_output(pin);
548 gpio_write_pin_low(pin);
549 }
550 }
551
552-static inline void setPinOutput_writeHigh(pin_t pin) {
553+static inline void gpio_atomic_set_pin_output_high(pin_t pin) {
554 ATOMIC_BLOCK_FORCEON {
555 gpio_set_pin_output(pin);
556 gpio_write_pin_high(pin);
557 }
558 }
559
560-static inline void setPinInputHigh_atomic(pin_t pin) {
561+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
562 ATOMIC_BLOCK_FORCEON {
563 gpio_set_pin_input_high(pin);
564 }
565@@ -65,37 +65,37 @@ static inline uint8_t readMatrixPin(pin_t pin) {
566 static void shiftOut(uint8_t dataOut) {
567 for (uint8_t i = 0; i < 8; i++) {
568 if (dataOut & 0x1) {
569- setPinOutput_writeHigh(DATA_PIN);
570+ gpio_atomic_set_pin_output_high(DATA_PIN);
571 } else {
572- setPinOutput_writeLow(DATA_PIN);
573+ gpio_atomic_set_pin_output_low(DATA_PIN);
574 }
575 dataOut = dataOut >> 1;
576- setPinOutput_writeHigh(CLOCK_PIN);
577- setPinOutput_writeLow(CLOCK_PIN);
578+ gpio_atomic_set_pin_output_high(CLOCK_PIN);
579+ gpio_atomic_set_pin_output_low(CLOCK_PIN);
580 }
581- setPinOutput_writeHigh(LATCH_PIN);
582- setPinOutput_writeLow(LATCH_PIN);
583+ gpio_atomic_set_pin_output_high(LATCH_PIN);
584+ gpio_atomic_set_pin_output_low(LATCH_PIN);
585 }
586
587 static void shiftout_single(uint8_t data) {
588 if (data & 0x1) {
589- setPinOutput_writeHigh(DATA_PIN);
590+ gpio_atomic_set_pin_output_high(DATA_PIN);
591 } else {
592- setPinOutput_writeLow(DATA_PIN);
593+ gpio_atomic_set_pin_output_low(DATA_PIN);
594 }
595
596- setPinOutput_writeHigh(CLOCK_PIN);
597- setPinOutput_writeLow(CLOCK_PIN);
598+ gpio_atomic_set_pin_output_high(CLOCK_PIN);
599+ gpio_atomic_set_pin_output_low(CLOCK_PIN);
600
601- setPinOutput_writeHigh(LATCH_PIN);
602- setPinOutput_writeLow(LATCH_PIN);
603+ gpio_atomic_set_pin_output_high(LATCH_PIN);
604+ gpio_atomic_set_pin_output_low(LATCH_PIN);
605 }
606
607 static bool select_col(uint8_t col) {
608 pin_t pin = col_pins[col];
609
610 if (pin != NO_PIN) {
611- setPinOutput_writeLow(pin);
612+ gpio_atomic_set_pin_output_low(pin);
613 return true;
614 } else {
615 if (col == 8) {
616@@ -113,9 +113,9 @@ static void unselect_col(uint8_t col) {
617
618 if (pin != NO_PIN) {
619 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
620- setPinOutput_writeHigh(pin);
621+ gpio_atomic_set_pin_output_high(pin);
622 #else
623- setPinInputHigh_atomic(pin);
624+ gpio_atomic_set_pin_input_high(pin);
625 #endif
626 } else {
627 if (col == (MATRIX_COLS - 1)) shiftout_single(0x01);
628@@ -129,9 +129,9 @@ static void unselect_cols(void) {
629
630 if (pin != NO_PIN) {
631 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
632- setPinOutput_writeHigh(pin);
633+ gpio_atomic_set_pin_output_high(pin);
634 #else
635- setPinInputHigh_atomic(pin);
636+ gpio_atomic_set_pin_input_high(pin);
637 #endif
638 }
639 if (x == (MATRIX_COLS - 1))
640diff --git a/keyboards/keychron/q3/matrix.c b/keyboards/keychron/q3/matrix.c
641index 25b3f6ed4ee2e90989652df24f62d8f0801fa699..5ed8d7bc4f341bc0904819c6f84f7705550a926d 100644
642--- a/keyboards/keychron/q3/matrix.c
643+++ b/keyboards/keychron/q3/matrix.c
644@@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
645
646 #define ROWS_PER_HAND (MATRIX_ROWS)
647
648-static inline void setPinOutput_writeLow(pin_t pin) {
649+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
650 ATOMIC_BLOCK_FORCEON {
651 gpio_set_pin_output(pin);
652 gpio_write_pin_low(pin);
653 }
654 }
655
656-static inline void setPinOutput_writeHigh(pin_t pin) {
657+static inline void gpio_atomic_set_pin_output_high(pin_t pin) {
658 ATOMIC_BLOCK_FORCEON {
659 gpio_set_pin_output(pin);
660 gpio_write_pin_high(pin);
661 }
662 }
663
664-static inline void setPinInputHigh_atomic(pin_t pin) {
665+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
666 ATOMIC_BLOCK_FORCEON {
667 gpio_set_pin_input_high(pin);
668 }
669@@ -65,37 +65,37 @@ static inline uint8_t readMatrixPin(pin_t pin) {
670 static void shiftOut(uint8_t dataOut) {
671 for (uint8_t i = 0; i < 8; i++) {
672 if (dataOut & 0x1) {
673- setPinOutput_writeHigh(DATA_PIN);
674+ gpio_atomic_set_pin_output_high(DATA_PIN);
675 } else {
676- setPinOutput_writeLow(DATA_PIN);
677+ gpio_atomic_set_pin_output_low(DATA_PIN);
678 }
679 dataOut = dataOut >> 1;
680- setPinOutput_writeHigh(CLOCK_PIN);
681- setPinOutput_writeLow(CLOCK_PIN);
682+ gpio_atomic_set_pin_output_high(CLOCK_PIN);
683+ gpio_atomic_set_pin_output_low(CLOCK_PIN);
684 }
685- setPinOutput_writeHigh(LATCH_PIN);
686- setPinOutput_writeLow(LATCH_PIN);
687+ gpio_atomic_set_pin_output_high(LATCH_PIN);
688+ gpio_atomic_set_pin_output_low(LATCH_PIN);
689 }
690
691 static void shiftout_single(uint8_t data) {
692 if (data & 0x1) {
693- setPinOutput_writeHigh(DATA_PIN);
694+ gpio_atomic_set_pin_output_high(DATA_PIN);
695 } else {
696- setPinOutput_writeLow(DATA_PIN);
697+ gpio_atomic_set_pin_output_low(DATA_PIN);
698 }
699
700- setPinOutput_writeHigh(CLOCK_PIN);
701- setPinOutput_writeLow(CLOCK_PIN);
702+ gpio_atomic_set_pin_output_high(CLOCK_PIN);
703+ gpio_atomic_set_pin_output_low(CLOCK_PIN);
704
705- setPinOutput_writeHigh(LATCH_PIN);
706- setPinOutput_writeLow(LATCH_PIN);
707+ gpio_atomic_set_pin_output_high(LATCH_PIN);
708+ gpio_atomic_set_pin_output_low(LATCH_PIN);
709 }
710
711 static bool select_col(uint8_t col) {
712 pin_t pin = col_pins[col];
713
714 if (pin != NO_PIN) {
715- setPinOutput_writeLow(pin);
716+ gpio_atomic_set_pin_output_low(pin);
717 return true;
718 } else {
719 if (col == 8) {
720@@ -113,9 +113,9 @@ static void unselect_col(uint8_t col) {
721
722 if (pin != NO_PIN) {
723 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
724- setPinOutput_writeHigh(pin);
725+ gpio_atomic_set_pin_output_high(pin);
726 #else
727- setPinInputHigh_atomic(pin);
728+ gpio_atomic_set_pin_input_high(pin);
729 #endif
730 } else {
731 if (col == (MATRIX_COLS - 1))
732@@ -130,9 +130,9 @@ static void unselect_cols(void) {
733
734 if (pin != NO_PIN) {
735 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
736- setPinOutput_writeHigh(pin);
737+ gpio_atomic_set_pin_output_high(pin);
738 #else
739- setPinInputHigh_atomic(pin);
740+ gpio_atomic_set_pin_input_high(pin);
741 #endif
742 }
743 if (x == (MATRIX_COLS - 1))
744diff --git a/keyboards/keychron/q5/matrix.c b/keyboards/keychron/q5/matrix.c
745index e7f69d98216c6e9899e5d8101e096a08fc73a800..e38301f00fe7e0cea22194babfa70c22d719bb51 100644
746--- a/keyboards/keychron/q5/matrix.c
747+++ b/keyboards/keychron/q5/matrix.c
748@@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
749
750 #define ROWS_PER_HAND (MATRIX_ROWS)
751
752-static inline void setPinOutput_writeLow(pin_t pin) {
753+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
754 ATOMIC_BLOCK_FORCEON {
755 gpio_set_pin_output(pin);
756 gpio_write_pin_low(pin);
757 }
758 }
759
760-static inline void setPinOutput_writeHigh(pin_t pin) {
761+static inline void gpio_atomic_set_pin_output_high(pin_t pin) {
762 ATOMIC_BLOCK_FORCEON {
763 gpio_set_pin_output(pin);
764 gpio_write_pin_high(pin);
765 }
766 }
767
768-static inline void setPinInputHigh_atomic(pin_t pin) {
769+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
770 ATOMIC_BLOCK_FORCEON {
771 gpio_set_pin_input_high(pin);
772 }
773@@ -65,36 +65,36 @@ static inline uint8_t readMatrixPin(pin_t pin) {
774 static void shiftOut(uint8_t dataOut) {
775 for (uint8_t i = 0; i < 8; i++) {
776 if (dataOut & 0x1) {
777- setPinOutput_writeHigh(DATA_PIN);
778+ gpio_atomic_set_pin_output_high(DATA_PIN);
779 } else {
780- setPinOutput_writeLow(DATA_PIN);
781+ gpio_atomic_set_pin_output_low(DATA_PIN);
782 }
783 dataOut = dataOut >> 1;
784- setPinOutput_writeHigh(CLOCK_PIN);
785- setPinOutput_writeLow(CLOCK_PIN);
786+ gpio_atomic_set_pin_output_high(CLOCK_PIN);
787+ gpio_atomic_set_pin_output_low(CLOCK_PIN);
788 }
789- setPinOutput_writeHigh(LATCH_PIN);
790- setPinOutput_writeLow(LATCH_PIN);
791+ gpio_atomic_set_pin_output_high(LATCH_PIN);
792+ gpio_atomic_set_pin_output_low(LATCH_PIN);
793 }
794
795 static void shiftout_single(uint8_t data) {
796 if (data & 0x1) {
797- setPinOutput_writeHigh(DATA_PIN);
798+ gpio_atomic_set_pin_output_high(DATA_PIN);
799 } else {
800- setPinOutput_writeLow(DATA_PIN);
801+ gpio_atomic_set_pin_output_low(DATA_PIN);
802 }
803- setPinOutput_writeHigh(CLOCK_PIN);
804- setPinOutput_writeLow(CLOCK_PIN);
805+ gpio_atomic_set_pin_output_high(CLOCK_PIN);
806+ gpio_atomic_set_pin_output_low(CLOCK_PIN);
807
808- setPinOutput_writeHigh(LATCH_PIN);
809- setPinOutput_writeLow(LATCH_PIN);
810+ gpio_atomic_set_pin_output_high(LATCH_PIN);
811+ gpio_atomic_set_pin_output_low(LATCH_PIN);
812 }
813
814 static bool select_col(uint8_t col) {
815 pin_t pin = col_pins[col];
816
817 if (pin != NO_PIN) {
818- setPinOutput_writeLow(pin);
819+ gpio_atomic_set_pin_output_low(pin);
820 return true;
821 } else {
822 if (col == 10) {
823@@ -112,16 +112,16 @@ static void unselect_col(uint8_t col) {
824
825 if (pin != NO_PIN) {
826 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
827- setPinOutput_writeHigh(pin);
828+ gpio_atomic_set_pin_output_high(pin);
829 #else
830- setPinInputHigh_atomic(pin);
831+ gpio_atomic_set_pin_input_high(pin);
832 #endif
833 } else {
834 if (col == (MATRIX_COLS - 1))
835- setPinOutput_writeHigh(CLOCK_PIN);
836- setPinOutput_writeLow(CLOCK_PIN);
837- setPinOutput_writeHigh(LATCH_PIN);
838- setPinOutput_writeLow(LATCH_PIN);
839+ gpio_atomic_set_pin_output_high(CLOCK_PIN);
840+ gpio_atomic_set_pin_output_low(CLOCK_PIN);
841+ gpio_atomic_set_pin_output_high(LATCH_PIN);
842+ gpio_atomic_set_pin_output_low(LATCH_PIN);
843 }
844 }
845
846@@ -131,9 +131,9 @@ static void unselect_cols(void) {
847 pin_t pin = col_pins[x];
848diff --git a/keyboards/keychron/q6/matrix.c b/keyboards/keychron/q6/matrix.c
849index 95e00405b44ccbec3e0b59732d7b2815f4409d4a..c61a38ad7364794af24b9824988b9d14d6f95c35 100644
850--- a/keyboards/keychron/q6/matrix.c
851+++ b/keyboards/keychron/q6/matrix.c
852@@ -46,21 +46,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
853 # define CLR_REG_VAL 0xFF
854 #endif
855
856-static inline void setPinOutput_writeLow(pin_t pin) {
857+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
858 ATOMIC_BLOCK_FORCEON {
859 gpio_set_pin_output(pin);
860 gpio_write_pin_low(pin);
861 }
862 }
863
864-static inline void setPinOutput_writeHigh(pin_t pin) {
865+static inline void gpio_atomic_set_pin_output_high(pin_t pin) {
866 ATOMIC_BLOCK_FORCEON {
867 gpio_set_pin_output(pin);
868 gpio_write_pin_high(pin);
869 }
870 }
871
872-static inline void setPinInputHigh_atomic(pin_t pin) {
873+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
874 ATOMIC_BLOCK_FORCEON {
875 gpio_set_pin_input_high(pin);
876 }
877@@ -77,36 +77,36 @@ static inline uint8_t readMatrixPin(pin_t pin) {
878 static void shiftOut(uint16_t dataOut) {
879 for (uint8_t i = 0; i < NO_PIN_NUM; i++) {
880 if (dataOut & 0x1) {
881- setPinOutput_writeHigh(DATA_PIN);
882+ gpio_atomic_set_pin_output_high(DATA_PIN);
883 } else {
884- setPinOutput_writeLow(DATA_PIN);
885+ gpio_atomic_set_pin_output_low(DATA_PIN);
886 }
887 dataOut = dataOut >> 1;
888- setPinOutput_writeHigh(CLOCK_PIN);
889- setPinOutput_writeLow(CLOCK_PIN);
890+ gpio_atomic_set_pin_output_high(CLOCK_PIN);
891+ gpio_atomic_set_pin_output_low(CLOCK_PIN);
892 }
893- setPinOutput_writeHigh(LATCH_PIN);
894- setPinOutput_writeLow(LATCH_PIN);
895+ gpio_atomic_set_pin_output_high(LATCH_PIN);
896+ gpio_atomic_set_pin_output_low(LATCH_PIN);
897 }
898
899 static void shiftout_single(uint8_t data) {
900 if (data & 0x1) {
901- setPinOutput_writeHigh(DATA_PIN);
902+ gpio_atomic_set_pin_output_high(DATA_PIN);
903 } else {
904- setPinOutput_writeLow(DATA_PIN);
905+ gpio_atomic_set_pin_output_low(DATA_PIN);
906 }
907- setPinOutput_writeHigh(CLOCK_PIN);
908- setPinOutput_writeLow(CLOCK_PIN);
909+ gpio_atomic_set_pin_output_high(CLOCK_PIN);
910+ gpio_atomic_set_pin_output_low(CLOCK_PIN);
911
912- setPinOutput_writeHigh(LATCH_PIN);
913- setPinOutput_writeLow(LATCH_PIN);
914+ gpio_atomic_set_pin_output_high(LATCH_PIN);
915+ gpio_atomic_set_pin_output_low(LATCH_PIN);
916 }
917
918 static bool select_col(uint8_t col) {
919 pin_t pin = col_pins[col];
920
921 if (pin != NO_PIN) {
922- setPinOutput_writeLow(pin);
923+ gpio_atomic_set_pin_output_low(pin);
924 return true;
925 } else {
926 if (col == NO_PIN_START) {
927@@ -124,16 +124,16 @@ static void unselect_col(uint8_t col) {
928
929 if (pin != NO_PIN) {
930 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
931- setPinOutput_writeHigh(pin);
932+ gpio_atomic_set_pin_output_high(pin);
933 #else
934- setPinInputHigh_atomic(pin);
935+ gpio_atomic_set_pin_input_high(pin);
936 #endif
937 } else {
938 if (col == (MATRIX_COLS - NO_PIN_OFFSET - 1))
939- setPinOutput_writeHigh(CLOCK_PIN);
940- setPinOutput_writeLow(CLOCK_PIN);
941- setPinOutput_writeHigh(LATCH_PIN);
942- setPinOutput_writeLow(LATCH_PIN);
943+ gpio_atomic_set_pin_output_high(CLOCK_PIN);
944+ gpio_atomic_set_pin_output_low(CLOCK_PIN);
945+ gpio_atomic_set_pin_output_high(LATCH_PIN);
946+ gpio_atomic_set_pin_output_low(LATCH_PIN);
947 }
948 }
949
950@@ -142,9 +142,9 @@ static void unselect_cols(void) {
951 pin_t pin = col_pins[x];
952diff --git a/keyboards/keychron/q65/matrix.c b/keyboards/keychron/q65/matrix.c
953index c9f9888689440c6ae9f712047cdd03dca84e40e9..4cbdd346ec353b1b6545cf502d5c51cbe087192b 100644
954--- a/keyboards/keychron/q65/matrix.c
955+++ b/keyboards/keychron/q65/matrix.c
956@@ -34,26 +34,26 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
957
958 #define ROWS_PER_HAND (MATRIX_ROWS)
959
960-static inline void writePinLow_atomic(pin_t pin) {
961+static inline void gpio_atomic_write_pin_low(pin_t pin) {
962 ATOMIC_BLOCK_FORCEON {
963 gpio_write_pin_low(pin);
964 }
965 }
966
967-static inline void writePinHigh_atomic(pin_t pin) {
968+static inline void gpio_atomic_write_pin_high(pin_t pin) {
969 ATOMIC_BLOCK_FORCEON {
970 gpio_write_pin_high(pin);
971 }
972 }
973
974-static inline void setPinOutput_writeLow(pin_t pin) {
975+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
976 ATOMIC_BLOCK_FORCEON {
977 gpio_set_pin_output(pin);
978 gpio_write_pin_low(pin);
979 }
980 }
981
982-static inline void setPinInputHigh_atomic(pin_t pin) {
983+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
984 ATOMIC_BLOCK_FORCEON {
985 gpio_set_pin_input_high(pin);
986 }
987@@ -119,9 +119,9 @@ static bool select_col(uint8_t col) {
988
989 if (pin != NO_PIN) {
990 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
991- writePinLow_atomic(pin);
992+ gpio_atomic_write_pin_low(pin);
993 #else
994- setPinOutput_writeLow(pin);
995+ gpio_atomic_set_pin_output_low(pin);
996 #endif
997 return true;
998 } else {
999@@ -138,9 +138,9 @@ static void unselect_col(uint8_t col) {
1000
1001 if (pin != NO_PIN) {
1002 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
1003- writePinHigh_atomic(pin);
1004+ gpio_atomic_write_pin_high(pin);
1005 #else
1006- setPinInputHigh_atomic(pin);
1007+ gpio_atomic_set_pin_input_high(pin);
1008 #endif
1009 } else {
1010 shiftout_single(0x01);
1011@@ -152,9 +152,9 @@ static void unselect_cols(void) {
1012 pin_t pin = col_pins[x];
1013 if (pin != NO_PIN) {
1014 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
1015- setPinOutput_writeHigh(pin);
1016+ gpio_atomic_set_pin_output_high(pin);
1017 #else
1018- setPinInputHigh_atomic(pin);
1019+ gpio_atomic_set_pin_input_high(pin);
1020 #endif
1021 } else {
1022 if (x == 0)
1023@@ -178,7 +178,7 @@ static void matrix_init_pins(void) {
1024 unselect_cols();
1025 for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
1026 if (row_pins[x] != NO_PIN) {
1027- setPinInputHigh_atomic(row_pins[x]);
1028+ gpio_atomic_set_pin_input_high(row_pins[x]);
1029 }
1030 }
1031 }
1032diff --git a/keyboards/keychron/v1/matrix.c b/keyboards/keychron/v1/matrix.c
1033index 32d9cfdbb06778956aba0e5fa24ad099580cff6d..01875ae44e7ff8fff3dedac6e48ce45163d6beab 100644
1034--- a/keyboards/keychron/v1/matrix.c
1035+++ b/keyboards/keychron/v1/matrix.c
1036@@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
1037
1038 #define ROWS_PER_HAND MATRIX_ROWS
1039
1040-static inline void setPinOutput_writeLow(pin_t pin) {
1041+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
1042 ATOMIC_BLOCK_FORCEON {
1043 gpio_set_pin_output(pin);
1044 gpio_write_pin_low(pin);
1045 }
1046 }
1047
1048-static inline void setPinOutput_writeHigh(pin_t pin) {
1049+static inline void gpio_atomic_set_pin_output_high(pin_t pin) {
1050 ATOMIC_BLOCK_FORCEON {
1051 gpio_set_pin_output(pin);
1052 gpio_write_pin_high(pin);
1053 }
1054 }
1055
1056-static inline void setPinInputHigh_atomic(pin_t pin) {
1057+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
1058 ATOMIC_BLOCK_FORCEON {
1059 gpio_set_pin_input_high(pin);
1060 }
1061@@ -113,7 +113,7 @@ static bool select_col(uint8_t col) {
1062 pin_t pin = col_pins[col];
1063
1064 if (pin != NO_PIN) {
1065- setPinOutput_writeLow(pin);
1066+ gpio_atomic_set_pin_output_low(pin);
1067 return true;
1068 } else {
1069 if (col == 8) {
1070@@ -129,9 +129,9 @@ static void unselect_col(uint8_t col) {
1071
1072 if (pin != NO_PIN) {
1073 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
1074- setPinOutput_writeHigh(pin);
1075+ gpio_atomic_set_pin_output_high(pin);
1076 #else
1077- setPinInputHigh_atomic(pin);
1078+ gpio_atomic_set_pin_input_high(pin);
1079 #endif
1080 } else {
1081 shiftOut_single(0x01);
1082@@ -143,9 +143,9 @@ static void unselect_cols(void) {
1083 pin_t pin = col_pins[x];
1084 if (pin != NO_PIN) {
1085 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
1086- setPinOutput_writeHigh(pin);
1087+ gpio_atomic_set_pin_output_high(pin);
1088 #else
1089- setPinInputHigh_atomic(pin);
1090+ gpio_atomic_set_pin_input_high(pin);
1091 #endif
1092 } else {
1093 if (x == 8)
1094@@ -169,7 +169,7 @@ static void matrix_init_pins(void) {
1095 unselect_cols();
1096 for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
1097 if (row_pins[x] != NO_PIN) {
1098- setPinInputHigh_atomic(row_pins[x]);
1099+ gpio_atomic_set_pin_input_high(row_pins[x]);
1100 }
1101 }
1102 }
1103diff --git a/keyboards/keychron/v10/matrix.c b/keyboards/keychron/v10/matrix.c
1104index bb6504fa78f3bc75e9bd5b7886ac33dc76c7f7fc..ee7d0a38c6caa76f1a8875a9ad1b6a58aff98bc2 100644
1105--- a/keyboards/keychron/v10/matrix.c
1106+++ b/keyboards/keychron/v10/matrix.c
1107@@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
1108
1109 #define ROWS_PER_HAND (MATRIX_ROWS)
1110
1111-static inline void setPinOutput_writeLow(pin_t pin) {
1112+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
1113 ATOMIC_BLOCK_FORCEON {
1114 gpio_set_pin_output(pin);
1115 gpio_write_pin_low(pin);
1116 }
1117 }
1118
1119-static inline void setPinOutput_writeHigh(pin_t pin) {
1120+static inline void gpio_atomic_set_pin_output_high(pin_t pin) {
1121 ATOMIC_BLOCK_FORCEON {
1122 gpio_set_pin_output(pin);
1123 gpio_write_pin_high(pin);
1124 }
1125 }
1126
1127-static inline void setPinInputHigh_atomic(pin_t pin) {
1128+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
1129 ATOMIC_BLOCK_FORCEON {
1130 gpio_set_pin_input_high(pin);
1131 }
1132@@ -105,7 +105,7 @@ static bool select_col(uint8_t col) {
1133 pin_t pin = col_pins[col];
1134
1135 if (pin != NO_PIN) {
1136- setPinOutput_writeLow(pin);
1137+ gpio_atomic_set_pin_output_low(pin);
1138 return true;
1139 } else {
1140 if (col == PIN_START_74HC595) {
1141@@ -121,9 +121,9 @@ static void unselect_col(uint8_t col) {
1142
1143 if (pin != NO_PIN) {
1144 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
1145- setPinOutput_writeHigh(pin);
1146+ gpio_atomic_set_pin_output_high(pin);
1147 #else
1148- setPinInputHigh_atomic(pin);
1149+ gpio_atomic_set_pin_input_high(pin);
1150 #endif
1151 } else {
1152 shiftOut_single(0x01);
1153@@ -137,9 +137,9 @@ static void unselect_cols(void) {
1154
1155 if (pin != NO_PIN) {
1156 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
1157- setPinOutput_writeHigh(pin);
1158+ gpio_atomic_set_pin_output_high(pin);
1159 #else
1160- setPinInputHigh_atomic(pin);
1161+ gpio_atomic_set_pin_input_high(pin);
1162 #endif
1163 }
1164 if (x == PIN_START_74HC595)
1165@@ -162,7 +162,7 @@ static void matrix_init_pins(void) {
1166 unselect_cols();
1167 for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
1168 if (row_pins[x] != NO_PIN) {
1169- setPinInputHigh_atomic(row_pins[x]);
1170+ gpio_atomic_set_pin_input_high(row_pins[x]);
1171 }
1172 }
1173 }
1174diff --git a/keyboards/keychron/v3/matrix.c b/keyboards/keychron/v3/matrix.c
1175index 5ee860afd2eff84f6c975ef36572f7913e4cd2e7..b12746529001d28b250c888e9571eb0991bf79f2 100644
1176--- a/keyboards/keychron/v3/matrix.c
1177+++ b/keyboards/keychron/v3/matrix.c
1178@@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
1179
1180 #define ROWS_PER_HAND (MATRIX_ROWS)
1181
1182-static inline void setPinOutput_writeLow(pin_t pin) {
1183+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
1184 ATOMIC_BLOCK_FORCEON {
1185 gpio_set_pin_output(pin);
1186 gpio_write_pin_low(pin);
1187 }
1188 }
1189
1190-static inline void setPinOutput_writeHigh(pin_t pin) {
1191+static inline void gpio_atomic_set_pin_output_high(pin_t pin) {
1192 ATOMIC_BLOCK_FORCEON {
1193 gpio_set_pin_output(pin);
1194 gpio_write_pin_high(pin);
1195 }
1196 }
1197
1198-static inline void setPinInputHigh_atomic(pin_t pin) {
1199+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
1200 ATOMIC_BLOCK_FORCEON {
1201 gpio_set_pin_input_high(pin);
1202 }
1203@@ -113,7 +113,7 @@ static bool select_col(uint8_t col) {
1204 pin_t pin = col_pins[col];
1205
1206 if (pin != NO_PIN) {
1207- setPinOutput_writeLow(pin);
1208+ gpio_atomic_set_pin_output_low(pin);
1209 return true;
1210 } else {
1211 if (col == 8) {
1212@@ -129,9 +129,9 @@ static void unselect_col(uint8_t col) {
1213
1214 if (pin != NO_PIN) {
1215 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
1216- setPinOutput_writeHigh(pin);
1217+ gpio_atomic_set_pin_output_high(pin);
1218 #else
1219- setPinInputHigh_atomic(pin);
1220+ gpio_atomic_set_pin_input_high(pin);
1221 #endif
1222 } else {
1223 shiftOut_single(0x01);
1224@@ -143,9 +143,9 @@ static void unselect_cols(void) {
1225 pin_t pin = col_pins[x];
1226 if (pin != NO_PIN) {
1227 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
1228- setPinOutput_writeHigh(pin);
1229+ gpio_atomic_set_pin_output_high(pin);
1230 #else
1231- setPinInputHigh_atomic(pin);
1232+ gpio_atomic_set_pin_input_high(pin);
1233 #endif
1234 } else {
1235 if (x == 8)
1236@@ -169,7 +169,7 @@ static void matrix_init_pins(void) {
1237 unselect_cols();
1238 for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
1239 if (row_pins[x] != NO_PIN) {
1240- setPinInputHigh_atomic(row_pins[x]);
1241+ gpio_atomic_set_pin_input_high(row_pins[x]);
1242 }
1243 }
1244 }
1245diff --git a/keyboards/keychron/v5/matrix.c b/keyboards/keychron/v5/matrix.c
1246index 255201af12a61625eec7e6421204138320fb42bb..810fdfb8e6d534d401b413498e884a66d93bf759 100644
1247--- a/keyboards/keychron/v5/matrix.c
1248+++ b/keyboards/keychron/v5/matrix.c
1249@@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
1250
1251 #define ROWS_PER_HAND (MATRIX_ROWS)
1252
1253-static inline void setPinOutput_writeLow(pin_t pin) {
1254+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
1255 ATOMIC_BLOCK_FORCEON {
1256 gpio_set_pin_output(pin);
1257 gpio_write_pin_low(pin);
1258 }
1259 }
1260
1261-static inline void setPinOutput_writeHigh(pin_t pin) {
1262+static inline void gpio_atomic_set_pin_output_high(pin_t pin) {
1263 ATOMIC_BLOCK_FORCEON {
1264 gpio_set_pin_output(pin);
1265 gpio_write_pin_high(pin);
1266 }
1267 }
1268
1269-static inline void setPinInputHigh_atomic(pin_t pin) {
1270+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
1271 ATOMIC_BLOCK_FORCEON {
1272 gpio_set_pin_input_high(pin);
1273 }
1274@@ -113,7 +113,7 @@ static bool select_col(uint8_t col) {
1275 pin_t pin = col_pins[col];
1276
1277 if (pin != NO_PIN) {
1278- setPinOutput_writeLow(pin);
1279+ gpio_atomic_set_pin_output_low(pin);
1280 return true;
1281 } else {
1282 if (col == 10) {
1283@@ -129,9 +129,9 @@ static void unselect_col(uint8_t col) {
1284
1285 if (pin != NO_PIN) {
1286 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
1287- setPinOutput_writeHigh(pin);
1288+ gpio_atomic_set_pin_output_high(pin);
1289 #else
1290- setPinInputHigh_atomic(pin);
1291+ gpio_atomic_set_pin_input_high(pin);
1292 #endif
1293 } else {
1294 shiftOut_single(0x01);
1295@@ -143,9 +143,9 @@ static void unselect_cols(void) {
1296 pin_t pin = col_pins[x];
1297 if (pin != NO_PIN) {
1298 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
1299- setPinOutput_writeHigh(pin);
1300+ gpio_atomic_set_pin_output_high(pin);
1301 #else
1302- setPinInputHigh_atomic(pin);
1303+ gpio_atomic_set_pin_input_high(pin);
1304 #endif
1305 } else {
1306 if (x == 10)
1307@@ -169,7 +169,7 @@ static void matrix_init_pins(void) {
1308 unselect_cols();
1309 for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
1310 if (row_pins[x] != NO_PIN) {
1311- setPinInputHigh_atomic(row_pins[x]);
1312+ gpio_atomic_set_pin_input_high(row_pins[x]);
1313 }
1314 }
1315 }
1316diff --git a/keyboards/keychron/v6/matrix.c b/keyboards/keychron/v6/matrix.c
1317index bb6504fa78f3bc75e9bd5b7886ac33dc76c7f7fc..ee7d0a38c6caa76f1a8875a9ad1b6a58aff98bc2 100644
1318--- a/keyboards/keychron/v6/matrix.c
1319+++ b/keyboards/keychron/v6/matrix.c
1320@@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
1321
1322 #define ROWS_PER_HAND (MATRIX_ROWS)
1323
1324-static inline void setPinOutput_writeLow(pin_t pin) {
1325+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
1326 ATOMIC_BLOCK_FORCEON {
1327 gpio_set_pin_output(pin);
1328 gpio_write_pin_low(pin);
1329 }
1330 }
1331
1332-static inline void setPinOutput_writeHigh(pin_t pin) {
1333+static inline void gpio_atomic_set_pin_output_high(pin_t pin) {
1334 ATOMIC_BLOCK_FORCEON {
1335 gpio_set_pin_output(pin);
1336 gpio_write_pin_high(pin);
1337 }
1338 }
1339
1340-static inline void setPinInputHigh_atomic(pin_t pin) {
1341+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
1342 ATOMIC_BLOCK_FORCEON {
1343 gpio_set_pin_input_high(pin);
1344 }
1345@@ -105,7 +105,7 @@ static bool select_col(uint8_t col) {
1346 pin_t pin = col_pins[col];
1347
1348 if (pin != NO_PIN) {
1349- setPinOutput_writeLow(pin);
1350+ gpio_atomic_set_pin_output_low(pin);
1351 return true;
1352 } else {
1353 if (col == PIN_START_74HC595) {
1354@@ -121,9 +121,9 @@ static void unselect_col(uint8_t col) {
1355
1356 if (pin != NO_PIN) {
1357 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
1358- setPinOutput_writeHigh(pin);
1359+ gpio_atomic_set_pin_output_high(pin);
1360 #else
1361- setPinInputHigh_atomic(pin);
1362+ gpio_atomic_set_pin_input_high(pin);
1363 #endif
1364 } else {
1365 shiftOut_single(0x01);
1366@@ -137,9 +137,9 @@ static void unselect_cols(void) {
1367
1368 if (pin != NO_PIN) {
1369 #ifdef MATRIX_UNSELECT_DRIVE_HIGH
1370- setPinOutput_writeHigh(pin);
1371+ gpio_atomic_set_pin_output_high(pin);
1372 #else
1373- setPinInputHigh_atomic(pin);
1374+ gpio_atomic_set_pin_input_high(pin);
1375 #endif
1376 }
1377 if (x == PIN_START_74HC595)
1378@@ -162,7 +162,7 @@ static void matrix_init_pins(void) {
1379 unselect_cols();
1380 for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
1381 if (row_pins[x] != NO_PIN) {
1382- setPinInputHigh_atomic(row_pins[x]);
1383+ gpio_atomic_set_pin_input_high(row_pins[x]);
1384 }
1385 }
1386 }
1387diff --git a/keyboards/rate/pistachio_pro/matrix.c b/keyboards/rate/pistachio_pro/matrix.c
1388index f235c65f56fe5ef248a9f8ab5d0bb27fcd634d7b..e40d3edd81533947a72198809f471710df445201 100644
1389--- a/keyboards/rate/pistachio_pro/matrix.c
1390+++ b/keyboards/rate/pistachio_pro/matrix.c
1391@@ -20,53 +20,53 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
1392 static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
1393 static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
1394
1395-static inline void setPinOutput_writeLow(pin_t pin) {
1396+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
1397 ATOMIC_BLOCK_FORCEON {
1398 gpio_set_pin_output(pin);
1399 gpio_write_pin_low(pin);
1400 }
1401 }
1402
1403-static inline void setPinInputHigh_atomic(pin_t pin) {
1404+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
1405 ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); }
1406 }
1407
1408 static void select_row(uint8_t row) {
1409- setPinOutput_writeLow(row_pins[row]);
1410+ gpio_atomic_set_pin_output_low(row_pins[row]);
1411 }
1412
1413 static void unselect_row(uint8_t row) {
1414- setPinInputHigh_atomic(row_pins[row]);
1415+ gpio_atomic_set_pin_input_high(row_pins[row]);
1416 }
1417
1418 static void unselect_rows(void) {
1419 for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
1420- setPinInputHigh_atomic(row_pins[x]);
1421+ gpio_atomic_set_pin_input_high(row_pins[x]);
1422 }
1423 }
1424
1425 static void select_col(uint8_t col) {
1426- setPinOutput_writeLow(col_pins[col]);
1427+ gpio_atomic_set_pin_output_low(col_pins[col]);
1428 }
1429
1430 static void unselect_col(uint8_t col) {
1431- setPinInputHigh_atomic(col_pins[col]);
1432+ gpio_atomic_set_pin_input_high(col_pins[col]);
1433 }
1434
1435 static void unselect_cols(void) {
1436 for (uint8_t x = 0; x < MATRIX_COLS; x++) {
1437- setPinInputHigh_atomic(col_pins[x]);
1438+ gpio_atomic_set_pin_input_high(col_pins[x]);
1439 }
1440 }
1441
1442 static void init_pins(void) {
1443 unselect_rows();
1444 for (uint8_t x = 0; x < MATRIX_COLS; x++) {
1445- setPinInputHigh_atomic(col_pins[x]);
1446+ gpio_atomic_set_pin_input_high(col_pins[x]);
1447 }
1448 unselect_cols();
1449 for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
1450- setPinInputHigh_atomic(row_pins[x]);
1451+ gpio_atomic_set_pin_input_high(row_pins[x]);
1452 }
1453 }
1454
1455diff --git a/keyboards/work_louder/micro/matrix.c b/keyboards/work_louder/micro/matrix.c
1456index 3cfbf17dadd0d8ce9e896a614d793b91d9355594..3944d676de0bc75df11a84c40c58e9deccf64dba 100644
1457--- a/keyboards/work_louder/micro/matrix.c
1458+++ b/keyboards/work_louder/micro/matrix.c
1459@@ -20,21 +20,21 @@ static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
1460 static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
1461 #define MATRIX_ROW_SHIFTER ((matrix_row_t)1)
1462
1463-static inline void setPinOutput_writeLow(pin_t pin) {
1464+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
1465 ATOMIC_BLOCK_FORCEON {
1466 gpio_set_pin_output(pin);
1467 gpio_write_pin_low(pin);
1468 }
1469 }
1470
1471-static inline void setPinOutput_writeHigh(pin_t pin) {
1472+static inline void gpio_atomic_set_pin_output_high(pin_t pin) {
1473 ATOMIC_BLOCK_FORCEON {
1474 gpio_set_pin_output(pin);
1475 gpio_write_pin_high(pin);
1476 }
1477 }
1478
1479-static inline void setPinInputHigh_atomic(pin_t pin) {
1480+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
1481 ATOMIC_BLOCK_FORCEON {
1482 gpio_set_pin_input_high(pin);
1483 }
1484@@ -51,7 +51,7 @@ static inline uint8_t readMatrixPin(pin_t pin) {
1485 static bool select_row(uint8_t row) {
1486 pin_t pin = row_pins[row];
1487 if (pin != NO_PIN) {
1488- setPinOutput_writeLow(pin);
1489+ gpio_atomic_set_pin_output_low(pin);
1490 return true;
1491 }
1492 return false;
1493@@ -60,7 +60,7 @@ static bool select_row(uint8_t row) {
1494 static void unselect_row(uint8_t row) {
1495 pin_t pin = row_pins[row];
1496 if (pin != NO_PIN) {
1497- setPinInputHigh_atomic(pin);
1498+ gpio_atomic_set_pin_input_high(pin);
1499 }
1500 }
1501
1502@@ -74,11 +74,11 @@ __attribute__((weak)) void matrix_init_custom(void) {
1503 unselect_rows();
1504 for (uint8_t x = 0; x < MATRIX_COLS; x++) {
1505 if (col_pins[x] != NO_PIN) {
1506- setPinInputHigh_atomic(col_pins[x]);
1507+ gpio_atomic_set_pin_input_high(col_pins[x]);
1508 }
1509 }
1510- setPinInputHigh_atomic(F7);
1511- setPinInputHigh_atomic(F0);
1512+ gpio_atomic_set_pin_input_high(F7);
1513+ gpio_atomic_set_pin_input_high(F0);
1514 }
1515
1516 void matrix_read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
1517diff --git a/quantum/matrix.c b/quantum/matrix.c
1518index d4586efac24cc0e3901944045616983587237a59..a877fb4e41d27dd4e1f3bc8b7cd0dad90cae2fbe 100644
1519--- a/quantum/matrix.c
1520+++ b/quantum/matrix.c
1521@@ -76,21 +76,21 @@ __attribute__((weak)) void matrix_init_pins(void);
1522 __attribute__((weak)) void matrix_read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row);
1523 __attribute__((weak)) void matrix_read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col, matrix_row_t row_shifter);
1524
1525-static inline void setPinOutput_writeLow(pin_t pin) {
1526+static inline void gpio_atomic_set_pin_output_low(pin_t pin) {
1527 ATOMIC_BLOCK_FORCEON {
1528 gpio_set_pin_output(pin);
1529 gpio_write_pin_low(pin);
1530 }
1531 }
1532
1533-static inline void setPinOutput_writeHigh(pin_t pin) {
1534+static inline void gpio_atomic_set_pin_output_high(pin_t pin) {
1535 ATOMIC_BLOCK_FORCEON {
1536 gpio_set_pin_output(pin);
1537 gpio_write_pin_high(pin);
1538 }
1539 }
1540
1541-static inline void setPinInputHigh_atomic(pin_t pin) {
1542+static inline void gpio_atomic_set_pin_input_high(pin_t pin) {
1543 ATOMIC_BLOCK_FORCEON {
1544 gpio_set_pin_input_high(pin);
1545 }
1546@@ -140,7 +140,7 @@ __attribute__((weak)) void matrix_read_cols_on_row(matrix_row_t current_matrix[]
1547 static bool select_row(uint8_t row) {
1548 pin_t pin = row_pins[row];
1549 if (pin != NO_PIN) {
1550- setPinOutput_writeLow(pin);
1551+ gpio_atomic_set_pin_output_low(pin);
1552 return true;
1553 }
1554 return false;
1555@@ -150,9 +150,9 @@ static void unselect_row(uint8_t row) {
1556 pin_t pin = row_pins[row];
1557 if (pin != NO_PIN) {
1558 # ifdef MATRIX_UNSELECT_DRIVE_HIGH
1559- setPinOutput_writeHigh(pin);
1560+ gpio_atomic_set_pin_output_high(pin);
1561 # else
1562- setPinInputHigh_atomic(pin);
1563+ gpio_atomic_set_pin_input_high(pin);
1564 # endif
1565 }
1566 }
1567@@ -167,7 +167,7 @@ __attribute__((weak)) void matrix_init_pins(void) {
1568 unselect_rows();
1569 for (uint8_t x = 0; x < MATRIX_COLS; x++) {
1570 if (col_pins[x] != NO_PIN) {
1571- setPinInputHigh_atomic(col_pins[x]);
1572+ gpio_atomic_set_pin_input_high(col_pins[x]);
1573 }
1574 }
1575 }
1576@@ -203,7 +203,7 @@ __attribute__((weak)) void matrix_read_cols_on_row(matrix_row_t current_matrix[]
1577 static bool select_col(uint8_t col) {
1578 pin_t pin = col_pins[col];
1579 if (pin != NO_PIN) {
1580- setPinOutput_writeLow(pin);
1581+ gpio_atomic_set_pin_output_low(pin);
1582 return true;
1583 }
1584 return false;
1585@@ -213,9 +213,9 @@ static void unselect_col(uint8_t col) {
1586 pin_t pin = col_pins[col];
1587 if (pin != NO_PIN) {
1588 # ifdef MATRIX_UNSELECT_DRIVE_HIGH
1589- setPinOutput_writeHigh(pin);
1590+ gpio_atomic_set_pin_output_high(pin);
1591 # else
1592- setPinInputHigh_atomic(pin);
1593+ gpio_atomic_set_pin_input_high(pin);
1594 # endif
1595 }
1596 }
1597@@ -230,7 +230,7 @@ __attribute__((weak)) void matrix_init_pins(void) {
1598 unselect_cols();
1599 for (uint8_t x = 0; x < ROWS_PER_HAND; x++) {
1600 if (row_pins[x] != NO_PIN) {
1601- setPinInputHigh_atomic(row_pins[x]);
1602+ gpio_atomic_set_pin_input_high(row_pins[x]);
1603 }
1604 }
1605 }