M keyboards/3w6/rev1/matrix.c => keyboards/3w6/rev1/matrix.c +7 -7
@@ 165,8 165,8 @@ static void init_cols(void) {
pin_t matrix_col_pins_mcu[MATRIX_COLS_PER_SIDE] = MATRIX_COL_PINS_L;
for (int pin_index = 0; pin_index < MATRIX_COLS_PER_SIDE; pin_index++) {
pin_t pin = matrix_col_pins_mcu[pin_index];
- setPinInput(pin);
- writePinHigh(pin);
+ gpio_set_pin_input(pin);
+ gpio_write_pin_high(pin);
}
}
@@ 177,7 177,7 @@ static matrix_row_t read_cols(uint8_t row) {
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS_PER_SIDE; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(matrix_col_pins_mcu[col_index]);
+ uint8_t pin_state = gpio_read_pin(matrix_col_pins_mcu[col_index]);
// Populate the matrix row with the state of the col pin
current_row_value |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
@@ 223,8 223,8 @@ static void unselect_rows(void) {
pin_t matrix_row_pins_mcu[MATRIX_ROWS_PER_SIDE] = MATRIX_ROW_PINS_L;
for (int pin_index = 0; pin_index < MATRIX_ROWS_PER_SIDE; pin_index++) {
pin_t pin = matrix_row_pins_mcu[pin_index];
- setPinInput(pin);
- writePinLow(pin);
+ gpio_set_pin_input(pin);
+ gpio_write_pin_low(pin);
}
}
@@ 236,8 236,8 @@ static void select_row(uint8_t row) {
// select on atmega32u4
pin_t matrix_row_pins_mcu[MATRIX_ROWS_PER_SIDE] = MATRIX_ROW_PINS_L;
pin_t pin = matrix_row_pins_mcu[row];
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
} else {
// select on tca9555
if (tca9555_status) { // if there was an error
M keyboards/3w6/rev2/matrix.c => keyboards/3w6/rev2/matrix.c +7 -7
@@ 165,8 165,8 @@ static void init_cols(void) {
pin_t matrix_col_pins_mcu[MATRIX_COLS_PER_SIDE] = MATRIX_COL_PINS_L;
for (int pin_index = 0; pin_index < MATRIX_COLS_PER_SIDE; pin_index++) {
pin_t pin = matrix_col_pins_mcu[pin_index];
- setPinInput(pin);
- writePinHigh(pin);
+ gpio_set_pin_input(pin);
+ gpio_write_pin_high(pin);
}
}
@@ 177,7 177,7 @@ static matrix_row_t read_cols(uint8_t row) {
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS_PER_SIDE; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(matrix_col_pins_mcu[col_index]);
+ uint8_t pin_state = gpio_read_pin(matrix_col_pins_mcu[col_index]);
// Populate the matrix row with the state of the col pin
current_row_value |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
@@ 221,8 221,8 @@ static void unselect_rows(void) {
pin_t matrix_row_pins_mcu[MATRIX_ROWS_PER_SIDE] = MATRIX_ROW_PINS_L;
for (int pin_index = 0; pin_index < MATRIX_ROWS_PER_SIDE; pin_index++) {
pin_t pin = matrix_row_pins_mcu[pin_index];
- setPinInput(pin);
- writePinLow(pin);
+ gpio_set_pin_input(pin);
+ gpio_write_pin_low(pin);
}
}
@@ 233,8 233,8 @@ static void select_row(uint8_t row) {
// select on atmega32u4
pin_t matrix_row_pins_mcu[MATRIX_ROWS_PER_SIDE] = MATRIX_ROW_PINS_L;
pin_t pin = matrix_row_pins_mcu[row];
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
} else {
// select on tca9555
if (tca9555_status) { // if there was an error
M keyboards/40percentclub/4pack/4pack.c => keyboards/40percentclub/4pack/4pack.c +2 -2
@@ 23,8 23,8 @@ void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
- setPinOutput(F4); // cathodes
- setPinOutput(F5); // cathodes
+ gpio_set_pin_output(F4); // cathodes
+ gpio_set_pin_output(F5); // cathodes
// Do the rest
matrix_init_user();
M keyboards/40percentclub/sixpack/sixpack.c => keyboards/40percentclub/sixpack/sixpack.c +3 -3
@@ 16,9 16,9 @@
#include "quantum.h"
void matrix_init_kb(void) {
- setPinOutput(B6); // Backlight cathodes Col.3
- setPinOutput(F6); // Backlight cathodes Col.2
- setPinOutput(F7); // Backlight cathodes Col.1
+ gpio_set_pin_output(B6); // Backlight cathodes Col.3
+ gpio_set_pin_output(F6); // Backlight cathodes Col.2
+ gpio_set_pin_output(F7); // Backlight cathodes Col.1
matrix_init_user();
}
M keyboards/4pplet/eagle_viper_rep/rev_a/rev_a.c => keyboards/4pplet/eagle_viper_rep/rev_a/rev_a.c +47 -47
@@ 17,9 17,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "rev_a.h"
void board_init(void) {
- setPinInputHigh(CAPS_PIN);
- setPinInputHigh(SCROLL_PIN);
- setPinInputHigh(NUM_PIN);
+ gpio_set_pin_input_high(CAPS_PIN);
+ gpio_set_pin_input_high(SCROLL_PIN);
+ gpio_set_pin_input_high(NUM_PIN);
}
/* Set indicator leds to indicate lock states */
@@ 27,23 27,23 @@ bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res && LOCK_LIGHTS) {
if(led_state.caps_lock){
- setPinOutput(CAPS_PIN);
- writePin(CAPS_PIN, 0);
+ gpio_set_pin_output(CAPS_PIN);
+ gpio_write_pin(CAPS_PIN, 0);
}
else
- setPinInputHigh(CAPS_PIN);
+ gpio_set_pin_input_high(CAPS_PIN);
if(led_state.scroll_lock){
- setPinOutput(SCROLL_PIN);
- writePin(SCROLL_PIN, 0);
+ gpio_set_pin_output(SCROLL_PIN);
+ gpio_write_pin(SCROLL_PIN, 0);
}
else
- setPinInputHigh(SCROLL_PIN);
+ gpio_set_pin_input_high(SCROLL_PIN);
if(led_state.num_lock){
- setPinOutput(NUM_PIN);
- writePin(NUM_PIN, 0);
+ gpio_set_pin_output(NUM_PIN);
+ gpio_write_pin(NUM_PIN, 0);
}
else
- setPinInputHigh(NUM_PIN);
+ gpio_set_pin_input_high(NUM_PIN);
}
return res;
}
@@ 59,50 59,50 @@ layer_state_t layer_state_set_kb(layer_state_t state) {
void setLayerLed(layer_state_t state){
switch(get_highest_layer(state)){
case 0 :
- setPinOutput(LAYER_1);
- writePin(LAYER_1, 0);
- setPinInputHigh(LAYER_2);
- setPinInputHigh(LAYER_3);
- setPinInputHigh(LAYER_4);
- setPinInputHigh(LAYER_5);
+ gpio_set_pin_output(LAYER_1);
+ gpio_write_pin(LAYER_1, 0);
+ gpio_set_pin_input_high(LAYER_2);
+ gpio_set_pin_input_high(LAYER_3);
+ gpio_set_pin_input_high(LAYER_4);
+ gpio_set_pin_input_high(LAYER_5);
break;
case 1 :
- setPinOutput(LAYER_2);
- writePin(LAYER_2, 0);
- setPinInputHigh(LAYER_1);
- setPinInputHigh(LAYER_3);
- setPinInputHigh(LAYER_4);
- setPinInputHigh(LAYER_5);
+ gpio_set_pin_output(LAYER_2);
+ gpio_write_pin(LAYER_2, 0);
+ gpio_set_pin_input_high(LAYER_1);
+ gpio_set_pin_input_high(LAYER_3);
+ gpio_set_pin_input_high(LAYER_4);
+ gpio_set_pin_input_high(LAYER_5);
break;
case 2 :
- setPinOutput(LAYER_3);
- writePin(LAYER_3, 0);
- setPinInputHigh(LAYER_1);
- setPinInputHigh(LAYER_2);
- setPinInputHigh(LAYER_4);
- setPinInputHigh(LAYER_5);
+ gpio_set_pin_output(LAYER_3);
+ gpio_write_pin(LAYER_3, 0);
+ gpio_set_pin_input_high(LAYER_1);
+ gpio_set_pin_input_high(LAYER_2);
+ gpio_set_pin_input_high(LAYER_4);
+ gpio_set_pin_input_high(LAYER_5);
break;
case 3 :
- writePin(LAYER_4, 0);
- setPinInputHigh(LAYER_5);
- setPinInputHigh(LAYER_1);
- setPinInputHigh(LAYER_2);
- setPinInputHigh(LAYER_3);
- setPinOutput(LAYER_4);
+ gpio_write_pin(LAYER_4, 0);
+ gpio_set_pin_input_high(LAYER_5);
+ gpio_set_pin_input_high(LAYER_1);
+ gpio_set_pin_input_high(LAYER_2);
+ gpio_set_pin_input_high(LAYER_3);
+ gpio_set_pin_output(LAYER_4);
break;
case 4 :
- setPinOutput(LAYER_5);
- writePin(LAYER_5, 0);
- setPinInputHigh(LAYER_1);
- setPinInputHigh(LAYER_2);
- setPinInputHigh(LAYER_3);
- setPinInputHigh(LAYER_4);
+ gpio_set_pin_output(LAYER_5);
+ gpio_write_pin(LAYER_5, 0);
+ gpio_set_pin_input_high(LAYER_1);
+ gpio_set_pin_input_high(LAYER_2);
+ gpio_set_pin_input_high(LAYER_3);
+ gpio_set_pin_input_high(LAYER_4);
break;
default :
- setPinInputHigh(LAYER_1);
- setPinInputHigh(LAYER_2);
- setPinInputHigh(LAYER_3);
- setPinInputHigh(LAYER_4);
- setPinInputHigh(LAYER_5);
+ gpio_set_pin_input_high(LAYER_1);
+ gpio_set_pin_input_high(LAYER_2);
+ gpio_set_pin_input_high(LAYER_3);
+ gpio_set_pin_input_high(LAYER_4);
+ gpio_set_pin_input_high(LAYER_5);
}
}
M keyboards/4pplet/eagle_viper_rep/rev_b/rev_b.c => keyboards/4pplet/eagle_viper_rep/rev_b/rev_b.c +15 -15
@@ 17,11 17,11 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "rev_b.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(LAYER_1);
- setPinOutput(LAYER_2);
- setPinOutput(LAYER_3);
- setPinOutput(LAYER_4);
- setPinOutput(LAYER_5);
+ gpio_set_pin_output(LAYER_1);
+ gpio_set_pin_output(LAYER_2);
+ gpio_set_pin_output(LAYER_3);
+ gpio_set_pin_output(LAYER_4);
+ gpio_set_pin_output(LAYER_5);
keyboard_pre_init_user();
}
@@ 32,26 32,26 @@ layer_state_t layer_state_set_kb(layer_state_t state) {
}
/* Set indicator leds to indicate which layer is active */
void setLayerLed(layer_state_t state){
- writePinLow(LAYER_1);
- writePinLow(LAYER_2);
- writePinLow(LAYER_3);
- writePinLow(LAYER_4);
- writePinLow(LAYER_5);
+ gpio_write_pin_low(LAYER_1);
+ gpio_write_pin_low(LAYER_2);
+ gpio_write_pin_low(LAYER_3);
+ gpio_write_pin_low(LAYER_4);
+ gpio_write_pin_low(LAYER_5);
switch (get_highest_layer(state)) {
case 0:
- writePinHigh(LAYER_1);
+ gpio_write_pin_high(LAYER_1);
break;
case 1:
- writePinHigh(LAYER_2);
+ gpio_write_pin_high(LAYER_2);
break;
case 2:
- writePinHigh(LAYER_3);
+ gpio_write_pin_high(LAYER_3);
break;
case 3:
- writePinHigh(LAYER_4);
+ gpio_write_pin_high(LAYER_4);
break;
case 4:
- writePinHigh(LAYER_5);
+ gpio_write_pin_high(LAYER_5);
break;
}
}
M keyboards/acheron/apollo/87h/delta/delta.c => keyboards/acheron/apollo/87h/delta/delta.c +2 -2
@@ 18,8 18,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "quantum.h"
void board_init(void) {
- setPinInput(B9);
- setPinInput(B10);
+ gpio_set_pin_input(B9);
+ gpio_set_pin_input(B10);
}
led_config_t g_led_config = { {
M keyboards/acheron/apollo/87htsc/87htsc.c => keyboards/acheron/apollo/87htsc/87htsc.c +2 -2
@@ 18,8 18,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "quantum.h"
void board_init(void) {
- setPinInput(B9);
- setPinInput(B10);
+ gpio_set_pin_input(B9);
+ gpio_set_pin_input(B10);
}
led_config_t g_led_config = { {
M keyboards/acheron/athena/alpha/alpha.c => keyboards/acheron/athena/alpha/alpha.c +4 -4
@@ 17,8 17,8 @@
#include "quantum.h"
void board_init(void) {
- setPinInput(B6);
- setPinInput(B7);
+ gpio_set_pin_input(B6);
+ gpio_set_pin_input(B7);
}
void keyboard_post_init_kb(void){
@@ 34,10 34,10 @@ bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
#ifdef CAPSLOCK_INDICATOR
if(res) {
- writePin(LED_CAPS_LOCK_PIN, !led_state.caps_lock);
+ gpio_write_pin(LED_CAPS_LOCK_PIN, !led_state.caps_lock);
}
#else
- writePin(LED_CAPS_LOCK_PIN, 0);
+ gpio_write_pin(LED_CAPS_LOCK_PIN, 0);
#endif
return res;
}
M keyboards/acheron/athena/beta/beta.c => keyboards/acheron/athena/beta/beta.c +4 -4
@@ 17,18 17,18 @@
#include "quantum.h"
void board_init(void) {
- setPinInput(B6);
- setPinInput(B7);
+ gpio_set_pin_input(B6);
+ gpio_set_pin_input(B7);
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
#ifdef CAPSLOCK_INDICATOR
if(res) {
- writePin(LED_CAPS_LOCK_PIN, led_state.caps_lock);
+ gpio_write_pin(LED_CAPS_LOCK_PIN, led_state.caps_lock);
}
#else
- writePin(LED_CAPS_LOCK_PIN, 0);
+ gpio_write_pin(LED_CAPS_LOCK_PIN, 0);
#endif
return res;
}
M keyboards/acheron/austin/austin.c => keyboards/acheron/austin/austin.c +6 -6
@@ 1,18 1,18 @@
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(A0);
- setPinOutput(A1);
- setPinOutput(A2);
+ gpio_set_pin_output(A0);
+ gpio_set_pin_output(A1);
+ gpio_set_pin_output(A2);
keyboard_pre_init_user();
}
bool led_update_kb(led_t led_state) {
if (led_update_user(led_state)) {
- writePin(A2, led_state.num_lock);
- writePin(A0, led_state.caps_lock);
- writePin(A1, led_state.scroll_lock);
+ gpio_write_pin(A2, led_state.num_lock);
+ gpio_write_pin(A0, led_state.caps_lock);
+ gpio_write_pin(A1, led_state.scroll_lock);
}
return true;
}
M keyboards/acheron/elongate/delta/delta.c => keyboards/acheron/elongate/delta/delta.c +16 -16
@@ 30,18 30,18 @@ void led_init_ports(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(LED1_PIN, !led_state.num_lock);
- writePin(LED2_PIN, !led_state.caps_lock);
- writePin(LED3_PIN, !led_state.scroll_lock);
+ gpio_write_pin(LED1_PIN, !led_state.num_lock);
+ gpio_write_pin(LED2_PIN, !led_state.caps_lock);
+ gpio_write_pin(LED3_PIN, !led_state.scroll_lock);
}
return res;
}
// Turns off all bottom LEDs
void turn_off_bottom_leds(void){
- writePin(LED4_PIN, 1);
- writePin(LED5_PIN, 1);
- writePin(LED6_PIN, 1);
+ gpio_write_pin(LED4_PIN, 1);
+ gpio_write_pin(LED5_PIN, 1);
+ gpio_write_pin(LED6_PIN, 1);
}
/*
@@ 53,19 53,19 @@ layer_state_t layer_state_set_kb(layer_state_t state) {
switch (get_highest_layer(state)) {
// The base layer, or layer zero, will be handled by the default case.
case 1:
- writePin(LED4_PIN, 1);
- writePin(LED5_PIN, 0);
- writePin(LED6_PIN, 1);
+ gpio_write_pin(LED4_PIN, 1);
+ gpio_write_pin(LED5_PIN, 0);
+ gpio_write_pin(LED6_PIN, 1);
break;
case 2:
- writePin(LED4_PIN, 1);
- writePin(LED5_PIN, 1);
- writePin(LED6_PIN, 0);
+ gpio_write_pin(LED4_PIN, 1);
+ gpio_write_pin(LED5_PIN, 1);
+ gpio_write_pin(LED6_PIN, 0);
break;
default:
- writePin(LED4_PIN, 0);
- writePin(LED5_PIN, 1);
- writePin(LED6_PIN, 1);
+ gpio_write_pin(LED4_PIN, 0);
+ gpio_write_pin(LED5_PIN, 1);
+ gpio_write_pin(LED6_PIN, 1);
break;
}
return state;
@@ 73,5 73,5 @@ layer_state_t layer_state_set_kb(layer_state_t state) {
// Since the keyboard starts at layer 0, the init function starts LED4 as lit up.
void keyboard_post_init_kb(void){
- writePin(LED4_PIN, 0);
+ gpio_write_pin(LED4_PIN, 0);
}
M keyboards/acheron/shark/beta/beta.c => keyboards/acheron/shark/beta/beta.c +2 -2
@@ 17,6 17,6 @@
#include "quantum.h"
void board_init(void) {
- setPinInput(B6);
- setPinInput(B7);
+ gpio_set_pin_input(B6);
+ gpio_set_pin_input(B7);
}
M keyboards/aeboards/ext65/rev1/rev1.c => keyboards/aeboards/ext65/rev1/rev1.c +9 -9
@@ 19,18 19,18 @@
void keyboard_pre_init_user(void) {
// Call the keyboard pre init code.
// Set our LED pins as output
- setPinOutput(D5);
- setPinOutput(D3);
- setPinOutput(D2);
- setPinOutput(D1);
+ gpio_set_pin_output(D5);
+ gpio_set_pin_output(D3);
+ gpio_set_pin_output(D2);
+ gpio_set_pin_output(D1);
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(D5, led_state.num_lock);
- writePin(D3, led_state.caps_lock);
- writePin(D2, led_state.scroll_lock);
+ gpio_write_pin(D5, led_state.num_lock);
+ gpio_write_pin(D3, led_state.caps_lock);
+ gpio_write_pin(D2, led_state.scroll_lock);
}
return res;
}
@@ 38,10 38,10 @@ bool led_update_kb(led_t led_state) {
layer_state_t layer_state_set_kb(layer_state_t state) {
switch (get_highest_layer(state)) {
case 1:
- writePinHigh(D1);
+ gpio_write_pin_high(D1);
break;
default: // for any other layers, or the default layer
- writePinLow(D1);
+ gpio_write_pin_low(D1);
break;
}
return layer_state_set_user(state);
M keyboards/aeboards/ext65/rev2/rev2.c => keyboards/aeboards/ext65/rev2/rev2.c +9 -9
@@ 71,10 71,10 @@ bool oled_task_kb(void) {
void keyboard_pre_init_kb(void) {
// Call the keyboard pre init code.
// Set our LED pins as output
- setPinOutput(B4);
- setPinOutput(B3);
- setPinOutput(A15);
- setPinOutput(A14);
+ gpio_set_pin_output(B4);
+ gpio_set_pin_output(B3);
+ gpio_set_pin_output(A15);
+ gpio_set_pin_output(A14);
keyboard_pre_init_user();
}
@@ 82,9 82,9 @@ void keyboard_pre_init_kb(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if (res) {
- writePin(B4, led_state.num_lock);
- writePin(B3, led_state.caps_lock);
- writePin(A15, led_state.scroll_lock);
+ gpio_write_pin(B4, led_state.num_lock);
+ gpio_write_pin(B3, led_state.caps_lock);
+ gpio_write_pin(A15, led_state.scroll_lock);
}
return res;
}
@@ 92,10 92,10 @@ bool led_update_kb(led_t led_state) {
layer_state_t layer_state_set_kb(layer_state_t state) {
switch (get_highest_layer(state)) {
case 1:
- writePinHigh(A14);
+ gpio_write_pin_high(A14);
break;
default: // for any other layers, or the default layer
- writePinLow(A14);
+ gpio_write_pin_low(A14);
break;
}
return layer_state_set_user(state);
M keyboards/aeboards/ext65/rev3/rev3.c => keyboards/aeboards/ext65/rev3/rev3.c +3 -3
@@ 22,16 22,16 @@ void matrix_io_delay(void) { __asm__ volatile("nop\nnop\nnop\n"); }
void keyboard_pre_init_user(void) {
// Call the keyboard pre init code.
// Set our LED pins as output
- setPinOutput(LED_LAYERS_PIN);
+ gpio_set_pin_output(LED_LAYERS_PIN);
}
layer_state_t layer_state_set_kb(layer_state_t state) {
switch (get_highest_layer(state)) {
case 1:
- writePinHigh(LED_LAYERS_PIN);
+ gpio_write_pin_high(LED_LAYERS_PIN);
break;
default: // for any other layers, or the default layer
- writePinLow(LED_LAYERS_PIN);
+ gpio_write_pin_low(LED_LAYERS_PIN);
break;
}
return layer_state_set_user(state);
M keyboards/ai03/orbit/orbit.c => keyboards/ai03/orbit/orbit.c +12 -12
@@ 19,13 19,13 @@
void led_init_ports(void) {
// Initialize indicator LEDs to output
if (isLeftHand) {
- setPinOutput(C6);
- setPinOutput(B6);
- setPinOutput(B5);
+ gpio_set_pin_output(C6);
+ gpio_set_pin_output(B6);
+ gpio_set_pin_output(B5);
} else {
- setPinOutput(F6);
- setPinOutput(F7);
- setPinOutput(C7);
+ gpio_set_pin_output(F6);
+ gpio_set_pin_output(F7);
+ gpio_set_pin_output(C7);
}
set_layer_indicators(0);
@@ 40,15 40,15 @@ void led_toggle(uint8_t id, bool on) {
switch (id) {
case 0:
// Left hand C6
- writePin(C6, on);
+ gpio_write_pin(C6, on);
break;
case 1:
// Left hand B6
- writePin(B6, on);
+ gpio_write_pin(B6, on);
break;
case 2:
// Left hand B5
- writePin(B5, on);
+ gpio_write_pin(B5, on);
break;
default:
break;
@@ 57,15 57,15 @@ void led_toggle(uint8_t id, bool on) {
switch (id) {
case 3:
// Right hand F6
- writePin(F6, on);
+ gpio_write_pin(F6, on);
break;
case 4:
// Right hand F7
- writePin(F7, on);
+ gpio_write_pin(F7, on);
break;
case 5:
// Right hand C7
- writePin(C7, on);
+ gpio_write_pin(C7, on);
break;
default:
break;
M keyboards/ai03/vega/vega.c => keyboards/ai03/vega/vega.c +4 -4
@@ 19,8 19,8 @@
void matrix_init_kb(void) {
// Initialize indicator LEDs to output
- setPinOutput(B7); // Caps
- setPinOutput(A5); // Slck
+ gpio_set_pin_output(B7); // Caps
+ gpio_set_pin_output(A5); // Slck
matrix_init_user();
}
@@ 30,8 30,8 @@ bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(B7, !led_state.caps_lock);
- writePin(A5, !led_state.scroll_lock);
+ gpio_write_pin(B7, !led_state.caps_lock);
+ gpio_write_pin(A5, !led_state.scroll_lock);
}
return res;
}=
\ No newline at end of file
M keyboards/akko/5087/5087.c => keyboards/akko/5087/5087.c +6 -6
@@ 137,17 137,17 @@ enum __layers {
// clang-format on
void matrix_init_kb(void) {
- setPinOutput(LED_MAC_OS_PIN); // LDE2 MAC\WIN
- writePinLow(LED_MAC_OS_PIN);
- setPinOutput(LED_WIN_LOCK_PIN); // LED3 Win Lock
- writePinLow(LED_WIN_LOCK_PIN);
+ gpio_set_pin_output(LED_MAC_OS_PIN); // LDE2 MAC\WIN
+ gpio_write_pin_low(LED_MAC_OS_PIN);
+ gpio_set_pin_output(LED_WIN_LOCK_PIN); // LED3 Win Lock
+ gpio_write_pin_low(LED_WIN_LOCK_PIN);
matrix_init_user();
}
void housekeeping_task_kb(void){
- writePin(LED_MAC_OS_PIN, (get_highest_layer(default_layer_state) == 3));
- writePin(LED_WIN_LOCK_PIN, keymap_config.no_gui);
+ gpio_write_pin(LED_MAC_OS_PIN, (get_highest_layer(default_layer_state) == 3));
+ gpio_write_pin(LED_WIN_LOCK_PIN, keymap_config.no_gui);
}
bool process_record_kb(uint16_t keycode, keyrecord_t* record) {
M keyboards/akko/5108/5108.c => keyboards/akko/5108/5108.c +3 -3
@@ 148,15 148,15 @@ const snled27351_led_t PROGMEM g_snled27351_leds[SNLED27351_LED_COUNT] = {
#endif
void keyboard_pre_init_kb(void) {
- setPinOutput(LED_WIN_LOCK_PIN); // LED3 Win Lock
- writePinLow(LED_WIN_LOCK_PIN);
+ gpio_set_pin_output(LED_WIN_LOCK_PIN); // LED3 Win Lock
+ gpio_write_pin_low(LED_WIN_LOCK_PIN);
keyboard_pre_init_user();
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if (res) {
- writePin(LED_WIN_LOCK_PIN, keymap_config.no_gui);
+ gpio_write_pin(LED_WIN_LOCK_PIN, keymap_config.no_gui);
}
return res;
}
M keyboards/al1/matrix.c => keyboards/al1/matrix.c +2 -2
@@ 48,7 48,7 @@ static void select_col(uint8_t col) {
static void init_pins(void) {
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
@@ 65,7 65,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0) {
+ if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_matrix[row_index] |= (MATRIX_ROW_SHIFTER << current_col);
} else {
M keyboards/anavi/knob1/knob1.c => keyboards/anavi/knob1/knob1.c +2 -2
@@ 6,8 6,8 @@
void keyboard_post_init_kb(void) {
// Enable RGB LED
- setPinOutput(GP11);
- writePinHigh(GP11);
+ gpio_set_pin_output(GP11);
+ gpio_write_pin_high(GP11);
rgblight_enable();
// Offload to the user func
M keyboards/anavi/knobs3/knobs3.c => keyboards/anavi/knobs3/knobs3.c +2 -2
@@ 6,8 6,8 @@
void keyboard_post_init_kb(void) {
// Enable RGB LED
- setPinOutput(GP11);
- writePinHigh(GP11);
+ gpio_set_pin_output(GP11);
+ gpio_write_pin_high(GP11);
rgblight_enable();
// Offload to the user func
M keyboards/argyle/matrix.c => keyboards/argyle/matrix.c +6 -6
@@ 26,27 26,27 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinOutput_writeHigh(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinHigh(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_high(pin);
}
}
static inline void setPinInputHigh_atomic(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
static inline uint8_t readMatrixPin(pin_t pin) {
if (pin != NO_PIN) {
- return (readPin(pin) == 0) ? 0 : 1;
+ return (gpio_read_pin(pin) == 0) ? 0 : 1;
} else {
return 1;
}
M keyboards/artifact/lvl/rev_hs01/rev_hs01.c => keyboards/artifact/lvl/rev_hs01/rev_hs01.c +1 -1
@@ 17,5 17,5 @@
void led_init_ports(void) {
// Set our LED pins as open drain outputs
- setPinOutputOpenDrain(LED_CAPS_LOCK_PIN);
+ gpio_set_pin_output_open_drain(LED_CAPS_LOCK_PIN);
}
M keyboards/atlantis/ps17/ps17.c => keyboards/atlantis/ps17/ps17.c +9 -9
@@ 5,26 5,26 @@
layer_state_t layer_state_set_kb(layer_state_t state) {
/* Display current layer using indicator LEDs */
- writePin(LED_INDICATOR_0_PIN, !IS_LAYER_ON_STATE(state, 1));
- writePin(LED_INDICATOR_1_PIN, !IS_LAYER_ON_STATE(state, 2));
- writePin(LED_INDICATOR_2_PIN, !IS_LAYER_ON_STATE(state, 3));
+ gpio_write_pin(LED_INDICATOR_0_PIN, !IS_LAYER_ON_STATE(state, 1));
+ gpio_write_pin(LED_INDICATOR_1_PIN, !IS_LAYER_ON_STATE(state, 2));
+ gpio_write_pin(LED_INDICATOR_2_PIN, !IS_LAYER_ON_STATE(state, 3));
return layer_state_set_user(state);
}
void keyboard_pre_init_kb(void) {
/* Set indicator LEDs as outputs */
- setPinOutput(LED_INDICATOR_0_PIN);
- setPinOutput(LED_INDICATOR_1_PIN);
- setPinOutput(LED_INDICATOR_2_PIN);
+ gpio_set_pin_output(LED_INDICATOR_0_PIN);
+ gpio_set_pin_output(LED_INDICATOR_1_PIN);
+ gpio_set_pin_output(LED_INDICATOR_2_PIN);
keyboard_pre_init_user();
}
#ifdef RGB_MATRIX_ENABLE
void suspend_power_down_kb(void) {
/* Disable indicator LEDs when going to sleep */
- writePin(LED_INDICATOR_0_PIN, 1);
- writePin(LED_INDICATOR_1_PIN, 1);
- writePin(LED_INDICATOR_2_PIN, 1);
+ gpio_write_pin(LED_INDICATOR_0_PIN, 1);
+ gpio_write_pin(LED_INDICATOR_1_PIN, 1);
+ gpio_write_pin(LED_INDICATOR_2_PIN, 1);
suspend_power_down_user();
}
M keyboards/atomic/atomic.c => keyboards/atomic/atomic.c +2 -2
@@ 21,8 21,8 @@ void matrix_init_kb(void) {
// runs once when the firmware starts up
// Turn status LED on
- setPinOutput(E6);
- writePinHigh(E6);
+ gpio_set_pin_output(E6);
+ gpio_write_pin_high(E6);
matrix_init_user();
}
M keyboards/bajjak/bajjak.h => keyboards/bajjak/bajjak.h +11 -11
@@ 53,17 53,17 @@ uint8_t bajjak_left_leds_update(void);
#endif
-inline void bajjak_board_led_on(void) { setPinOutput(D6); writePinHigh(D6); }
-inline void bajjak_right_led_1_on(void) { setPinOutput(B5); writePinHigh(B5); }
-inline void bajjak_right_led_2_on(void) { setPinOutput(B6); writePinHigh(B6); }
-inline void bajjak_right_led_3_on(void) { setPinOutput(B7); writePinHigh(B7); }
-inline void bajjak_right_led_on(uint8_t led) { setPinOutput(led+4); writePinHigh(led+4); }
-
-inline void bajjak_board_led_off(void) { setPinInput(D6); writePinLow(D6); }
-inline void bajjak_right_led_1_off(void) { setPinInput(B5); writePinLow(B5); }
-inline void bajjak_right_led_2_off(void) { setPinInput(B6); writePinLow(B6); }
-inline void bajjak_right_led_3_off(void) { setPinInput(B7); writePinLow(B7); }
-inline void bajjak_right_led_off(uint8_t led) { setPinInput(led+4); writePinLow(led+4); }
+inline void bajjak_board_led_on(void) { gpio_set_pin_output(D6); gpio_write_pin_high(D6); }
+inline void bajjak_right_led_1_on(void) { gpio_set_pin_output(B5); gpio_write_pin_high(B5); }
+inline void bajjak_right_led_2_on(void) { gpio_set_pin_output(B6); gpio_write_pin_high(B6); }
+inline void bajjak_right_led_3_on(void) { gpio_set_pin_output(B7); gpio_write_pin_high(B7); }
+inline void bajjak_right_led_on(uint8_t led) { gpio_set_pin_output(led+4); gpio_write_pin_high(led+4); }
+
+inline void bajjak_board_led_off(void) { gpio_set_pin_input(D6); gpio_write_pin_low(D6); }
+inline void bajjak_right_led_1_off(void) { gpio_set_pin_input(B5); gpio_write_pin_low(B5); }
+inline void bajjak_right_led_2_off(void) { gpio_set_pin_input(B6); gpio_write_pin_low(B6); }
+inline void bajjak_right_led_3_off(void) { gpio_set_pin_input(B7); gpio_write_pin_low(B7); }
+inline void bajjak_right_led_off(uint8_t led) { gpio_set_pin_input(led+4); gpio_write_pin_low(led+4); }
#ifdef LEFT_LEDS
bool bajjak_left_led_1;
M keyboards/bajjak/matrix.c => keyboards/bajjak/matrix.c +28 -28
@@ 128,13 128,13 @@ static void init_cols(void) {
// not needed, already done as part of init_mcp23018()
// init on teensy
- setPinInputHigh(F0);
- setPinInputHigh(F1);
- setPinInputHigh(F4);
- setPinInputHigh(F5);
- setPinInputHigh(F6);
- setPinInputHigh(F7);
- setPinInputHigh(D7);
+ gpio_set_pin_input_high(F0);
+ gpio_set_pin_input_high(F1);
+ gpio_set_pin_input_high(F4);
+ gpio_set_pin_input_high(F5);
+ gpio_set_pin_input_high(F6);
+ gpio_set_pin_input_high(F7);
+ gpio_set_pin_input_high(D7);
}
static matrix_row_t read_cols(uint8_t row) {
@@ 175,13 175,13 @@ static void unselect_rows(void) {
// direction
// unselect on teensy
- setPinInput(B0);
- setPinInput(B1);
- setPinInput(B2);
- setPinInput(B3);
- setPinInput(D2);
- setPinInput(D3);
- setPinInput(C6);
+ gpio_set_pin_input(B0);
+ gpio_set_pin_input(B1);
+ gpio_set_pin_input(B2);
+ gpio_set_pin_input(B3);
+ gpio_set_pin_input(D2);
+ gpio_set_pin_input(D3);
+ gpio_set_pin_input(C6);
}
static void select_row(uint8_t row) {
@@ 200,32 200,32 @@ static void select_row(uint8_t row) {
// Output low(DDR:1, PORT:0) to select
switch (row) {
case 7:
- setPinOutput(B0);
- writePinLow(B0);
+ gpio_set_pin_output(B0);
+ gpio_write_pin_low(B0);
break;
case 8:
- setPinOutput(B1);
- writePinLow(B1);
+ gpio_set_pin_output(B1);
+ gpio_write_pin_low(B1);
break;
case 9:
- setPinOutput(B2);
- writePinLow(B2);
+ gpio_set_pin_output(B2);
+ gpio_write_pin_low(B2);
break;
case 10:
- setPinOutput(B3);
- writePinLow(B3);
+ gpio_set_pin_output(B3);
+ gpio_write_pin_low(B3);
break;
case 11:
- setPinOutput(D2);
- writePinLow(D2);
+ gpio_set_pin_output(D2);
+ gpio_write_pin_low(D2);
break;
case 12:
- setPinOutput(D3);
- writePinLow(D3);
+ gpio_set_pin_output(D3);
+ gpio_write_pin_low(D3);
break;
case 13:
- setPinOutput(C6);
- writePinLow(C6);
+ gpio_set_pin_output(C6);
+ gpio_write_pin_low(C6);
break;
}
}
M keyboards/bandominedoni/bandominedoni.c => keyboards/bandominedoni/bandominedoni.c +7 -7
@@ 70,14 70,14 @@ led_config_t g_led_config = {
#if defined(SPLIT_HAND_MATRIX_GRID)
static uint8_t peek_matrix_intersection(pin_t out_pin, pin_t in_pin) {
- setPinInputHigh(in_pin);
- setPinOutput(out_pin);
- writePinLow(out_pin);
+ gpio_set_pin_input_high(in_pin);
+ gpio_set_pin_output(out_pin);
+ gpio_write_pin_low(out_pin);
// It's almost unnecessary, but wait until it's down to low, just in case.
wait_us(1);
- uint8_t pin_state = readPin(in_pin);
+ uint8_t pin_state = gpio_read_pin(in_pin);
// Set out_pin to a setting that is less susceptible to noise.
- setPinInputHigh(out_pin);
+ gpio_set_pin_input_high(out_pin);
matrix_io_delay(); // Wait for the pull-up to go HIGH.
return pin_state;
}
@@ 93,8 93,8 @@ static enum { UNKNOWN, LEFT, RIGHT } hand_side = UNKNOWN;
if (hand_side == UNKNOWN) {
#if defined(SPLIT_HAND_PIN)
// Test pin SPLIT_HAND_PIN for High/Low, if low it's right hand
- setPinInput(SPLIT_HAND_PIN);
- hand_side = readPin(SPLIT_HAND_PIN) ? LEFT : RIGHT;
+ gpio_set_pin_input(SPLIT_HAND_PIN);
+ hand_side = gpio_read_pin(SPLIT_HAND_PIN) ? LEFT : RIGHT;
return (hand_side == LEFT);
#elif defined(SPLIT_HAND_MATRIX_GRID)
# ifdef SPLIT_HAND_MATRIX_GRID_LOW_IS_LEFT
M keyboards/barleycorn_smd/matrix.c => keyboards/barleycorn_smd/matrix.c +6 -6
@@ 23,17 23,17 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static void unselect_rows(void) {
for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void select_row(uint8_t row) {
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row) {
- setPinInputHigh(row_pins[row]);
+ gpio_set_pin_input_high(row_pins[row]);
}
static void init_pins(void) {
@@ 46,7 46,7 @@ static void init_pins(void) {
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
if ( x < 8 ) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
}
@@ 111,7 111,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
pin_state = port_expander_col_buffer[1] & (1 << 1);
break;
default :
- pin_state = readPin(col_pins[col_index]);
+ pin_state = gpio_read_pin(col_pins[col_index]);
}
// Populate the matrix row with the state of the col pin
M keyboards/bastardkb/charybdis/charybdis.c => keyboards/bastardkb/charybdis/charybdis.c +2 -2
@@ 371,12 371,12 @@ void housekeeping_task_kb(void) {
#if defined(KEYBOARD_bastardkb_charybdis_3x5_blackpill) || defined(KEYBOARD_bastardkb_charybdis_4x6_blackpill)
void keyboard_pre_init_kb(void) {
- setPinInputHigh(A0);
+ gpio_set_pin_input_high(A0);
keyboard_pre_init_user();
}
void matrix_scan_kb(void) {
- if (!readPin(A0)) {
+ if (!gpio_read_pin(A0)) {
reset_keyboard();
}
matrix_scan_user();
M keyboards/bear_face/v1/v1.c => keyboards/bear_face/v1/v1.c +2 -2
@@ 19,7 19,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
void keyboard_pre_init_kb(void) {
//Sets LED pin as output
- setPinOutput(F7);
+ gpio_set_pin_output(F7);
keyboard_pre_init_user();
}
@@ 28,7 28,7 @@ bool led_update_kb(led_t led_state) {
// Caps Lock LED indicator toggling code here
bool res = led_update_user(led_state);
if(res) {
- writePin(F7, led_state.caps_lock);
+ gpio_write_pin(F7, led_state.caps_lock);
}
return res;
}
M keyboards/bear_face/v2/v2.c => keyboards/bear_face/v2/v2.c +2 -2
@@ 19,7 19,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
void keyboard_pre_init_kb(void) {
//Sets LED pin as output
- setPinOutput(F7);
+ gpio_set_pin_output(F7);
keyboard_pre_init_user();
}
@@ 28,7 28,7 @@ bool led_update_kb(led_t led_state) {
// Caps Lock LED indicator toggling code here
bool res = led_update_user(led_state);
if(res) {
- writePin(F7, led_state.caps_lock);
+ gpio_write_pin(F7, led_state.caps_lock);
}
return res;
}
M keyboards/bioi/g60/g60.c => keyboards/bioi/g60/g60.c +3 -3
@@ 15,14 15,14 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(F0);
- writePinHigh(F0);
+ gpio_set_pin_output(F0);
+ gpio_write_pin_high(F0);
keyboard_pre_init_user();
}
bool led_update_kb(led_t led_state) {
if (led_update_user(led_state)) {
- writePin(F0, !led_state.caps_lock);
+ gpio_write_pin(F0, !led_state.caps_lock);
}
return true;
}
M keyboards/bioi/morgan65/morgan65.c => keyboards/bioi/morgan65/morgan65.c +3 -3
@@ 15,14 15,14 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(F0);
- writePinHigh(F0);
+ gpio_set_pin_output(F0);
+ gpio_write_pin_high(F0);
keyboard_pre_init_user();
}
bool led_update_kb(led_t led_state) {
if (led_update_user(led_state)) {
- writePin(F0, !led_state.caps_lock);
+ gpio_write_pin(F0, !led_state.caps_lock);
}
return true;
}
M keyboards/bioi/s65/s65.c => keyboards/bioi/s65/s65.c +3 -3
@@ 14,14 14,14 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(F0);
- writePinHigh(F0);
+ gpio_set_pin_output(F0);
+ gpio_write_pin_high(F0);
keyboard_pre_init_user();
}
bool led_update_kb(led_t led_state) {
if (led_update_user(led_state)) {
- writePin(F0, !led_state.caps_lock);
+ gpio_write_pin(F0, !led_state.caps_lock);
}
return true;
}
M keyboards/blu/vimclutch/vimclutch.c => keyboards/blu/vimclutch/vimclutch.c +2 -2
@@ 18,8 18,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
void keyboard_pre_init_kb(void)
{
- setPinOutput(F4);
- setPinOutput(F5);
+ gpio_set_pin_output(F4);
+ gpio_set_pin_output(F5);
keyboard_pre_init_user();
};
M keyboards/bobpad/bobpad.c => keyboards/bobpad/bobpad.c +1 -1
@@ 19,7 19,7 @@
bool led_update_kb(led_t led_state) {
if (!led_update_user(led_state)) { return false; }
- writePin(LED_CAPS_LOCK_PIN, led_state.caps_lock);
+ gpio_write_pin(LED_CAPS_LOCK_PIN, led_state.caps_lock);
return true;
};
M keyboards/bpiphany/ghost_squid/ghost_squid.c => keyboards/bpiphany/ghost_squid/ghost_squid.c +2 -2
@@ 18,8 18,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "ghost_squid.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(D0);
- writePinLow(D0);
+ gpio_set_pin_output(D0);
+ gpio_write_pin_low(D0);
fn_led_off();
keyboard_pre_init_user();
M keyboards/bpiphany/ghost_squid/ghost_squid.h => keyboards/bpiphany/ghost_squid/ghost_squid.h +2 -2
@@ 19,5 19,5 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "quantum.h"
-#define fn_led_on() writePinLow(D0)
-#define fn_led_off() writePinHigh(D0)
+#define fn_led_on() gpio_write_pin_low(D0)
+#define fn_led_off() gpio_write_pin_high(D0)
M keyboards/bpiphany/ghost_squid/matrix.c => keyboards/bpiphany/ghost_squid/matrix.c +14 -14
@@ 55,22 55,22 @@ void select_col(uint8_t col) {
void matrix_init_custom(void) {
/* Column output pins */
- setPinOutput(D1);
- setPinOutput(D2);
- setPinOutput(D3);
- setPinOutput(D4);
- setPinOutput(D5);
- setPinOutput(D6);
+ gpio_set_pin_output(D1);
+ gpio_set_pin_output(D2);
+ gpio_set_pin_output(D3);
+ gpio_set_pin_output(D4);
+ gpio_set_pin_output(D5);
+ gpio_set_pin_output(D6);
/* Row input pins */
- writePinHigh(B0);
- writePinHigh(B1);
- writePinHigh(B2);
- writePinHigh(B3);
- writePinHigh(B4);
- writePinHigh(B5);
- writePinHigh(B6);
- writePinHigh(C2);
+ gpio_write_pin_high(B0);
+ gpio_write_pin_high(B1);
+ gpio_write_pin_high(B2);
+ gpio_write_pin_high(B3);
+ gpio_write_pin_high(B4);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B6);
+ gpio_write_pin_high(C2);
}
bool matrix_scan_custom(matrix_row_t current_matrix[]) {
M keyboards/capsunlocked/cu75/cu75.c => keyboards/capsunlocked/cu75/cu75.c +4 -4
@@ 20,12 20,12 @@ void matrix_init_kb(void)
audio_init();
PLAY_SONG(test_sound);
// Fix port B5
- setPinInput(B5);
- writePinHigh(B5);
+ gpio_set_pin_input(B5);
+ gpio_write_pin_high(B5);
#else
// If we're not using the audio pin, drive it low
- setPinOutput(C6);
- writePinLow(C6);
+ gpio_set_pin_output(C6);
+ gpio_write_pin_low(C6);
#endif
}
M keyboards/capsunlocked/cu80/v2/v2.c => keyboards/capsunlocked/cu80/v2/v2.c +1 -1
@@ 3,7 3,7 @@
#include "quantum.h"
void matrix_init_kb(void) {
- setPinOutput(E6);
+ gpio_set_pin_output(E6);
matrix_init_user();
}
M keyboards/centromere/centromere.c => keyboards/centromere/centromere.c +12 -12
@@ 2,23 2,23 @@
void led_init(void) {
#if MCU == atmega32u2
- setPinOutput(C4); // Set red LED pin as output
- setPinOutput(C5); // Set blue LED pin as output
- setPinOutput(D1); // Set green LED pin as output
+ gpio_set_pin_output(C4); // Set red LED pin as output
+ gpio_set_pin_output(C5); // Set blue LED pin as output
+ gpio_set_pin_output(D1); // Set green LED pin as output
- writePinHigh(C4); // Turn off red LED pin
- writePinHigh(C5); // Turn off blue LED pin
- writePinHigh(D1); // Turn off green LED pin
+ gpio_write_pin_high(C4); // Turn off red LED pin
+ gpio_write_pin_high(C5); // Turn off blue LED pin
+ gpio_write_pin_high(D1); // Turn off green LED pin
#else
- setPinOutput(F4); // Set red LED pin as output
- setPinOutput(F5); // Set blue LED pin as output
- setPinOutput(D1); // Set green LED pin as output
+ gpio_set_pin_output(F4); // Set red LED pin as output
+ gpio_set_pin_output(F5); // Set blue LED pin as output
+ gpio_set_pin_output(D1); // Set green LED pin as output
- writePinHigh(F4); // Turn off red LED pin
- writePinHigh(F5); // Turn off blue LED pin
- writePinHigh(D1); // Turn off green LED pin
+ gpio_write_pin_high(F4); // Turn off red LED pin
+ gpio_write_pin_high(F5); // Turn off blue LED pin
+ gpio_write_pin_high(D1); // Turn off green LED pin
#endif
M keyboards/centromere/centromere.h => keyboards/centromere/centromere.h +10 -10
@@ 3,21 3,21 @@
#include "quantum.h"
#if MCU == atmega32u2
-#define red_led_off writePinHigh(C5)
-#define red_led_on writePinLow(C5)
-#define blu_led_off writePinHigh(C4)
-#define blu_led_on writePinLow(C4)
+#define red_led_off gpio_write_pin_high(C5)
+#define red_led_on gpio_write_pin_low(C5)
+#define blu_led_off gpio_write_pin_high(C4)
+#define blu_led_on gpio_write_pin_low(C4)
#else
-#define red_led_off writePinHigh(F5)
-#define red_led_on writePinLow(F5)
-#define blu_led_off writePinHigh(F4)
-#define blu_led_on writePinLow(F4)
+#define red_led_off gpio_write_pin_high(F5)
+#define red_led_on gpio_write_pin_low(F5)
+#define blu_led_off gpio_write_pin_high(F4)
+#define blu_led_on gpio_write_pin_low(F4)
#endif
-#define grn_led_off writePinHigh(D1)
-#define grn_led_on writePinLow(D1)
+#define grn_led_off gpio_write_pin_high(D1)
+#define grn_led_on gpio_write_pin_low(D1)
#define set_led_off red_led_off; blu_led_off
#define set_led_red red_led_on; grn_led_off; blu_led_off
M keyboards/cheshire/curiosity/curiosity.c => keyboards/cheshire/curiosity/curiosity.c +6 -6
@@ 1,17 1,17 @@
#include "quantum.h"
void matrix_init_board(void){
- setPinOutput(A8);
- setPinOutput(A9);
- setPinOutput(A10);
+ gpio_set_pin_output(A8);
+ gpio_set_pin_output(A9);
+ gpio_set_pin_output(A10);
}
bool led_update_kb(led_t led_state) {
bool runDefault = led_update_user(led_state);
if (runDefault) {
- writePin(A8, !led_state.num_lock);
- writePin(A9, !led_state.caps_lock);
- writePin(A10, !led_state.scroll_lock);
+ gpio_write_pin(A8, !led_state.num_lock);
+ gpio_write_pin(A9, !led_state.caps_lock);
+ gpio_write_pin(A10, !led_state.scroll_lock);
}
return runDefault;
}
M keyboards/cipulot/common/ec_switch_matrix.c => keyboards/cipulot/common/ec_switch_matrix.c +19 -19
@@ 54,19 54,19 @@ static adc_mux adcMux;
void init_row(void) {
// Set all row pins as output and low
for (uint8_t idx = 0; idx < MATRIX_ROWS; idx++) {
- setPinOutput(row_pins[idx]);
- writePinLow(row_pins[idx]);
+ gpio_set_pin_output(row_pins[idx]);
+ gpio_write_pin_low(row_pins[idx]);
}
}
// Initialize the multiplexers
void init_amux(void) {
for (uint8_t idx = 0; idx < AMUX_COUNT; idx++) {
- setPinOutput(amux_en_pins[idx]);
- writePinLow(amux_en_pins[idx]);
+ gpio_set_pin_output(amux_en_pins[idx]);
+ gpio_write_pin_low(amux_en_pins[idx]);
}
for (uint8_t idx = 0; idx < AMUX_SEL_PINS_COUNT; idx++) {
- setPinOutput(amux_sel_pins[idx]);
+ gpio_set_pin_output(amux_sel_pins[idx]);
}
}
@@ 75,13 75,13 @@ void select_amux_channel(uint8_t channel, uint8_t col) {
// Get the channel for the specified multiplexer
uint8_t ch = amux_n_col_channels[channel][col];
// momentarily disable specified multiplexer
- writePinHigh(amux_en_pins[channel]);
+ gpio_write_pin_high(amux_en_pins[channel]);
// Select the multiplexer channel
for (uint8_t i = 0; i < AMUX_SEL_PINS_COUNT; i++) {
- writePin(amux_sel_pins[i], ch & (1 << i));
+ gpio_write_pin(amux_sel_pins[i], ch & (1 << i));
}
// re enable specified multiplexer
- writePinLow(amux_en_pins[channel]);
+ gpio_write_pin_low(amux_en_pins[channel]);
}
// Disable all the unused multiplexers
@@ 89,28 89,28 @@ void disable_unused_amux(uint8_t channel) {
// disable all the other multiplexers apart from the current selected one
for (uint8_t idx = 0; idx < AMUX_COUNT; idx++) {
if (idx != channel) {
- writePinHigh(amux_en_pins[idx]);
+ gpio_write_pin_high(amux_en_pins[idx]);
}
}
}
// Discharge the peak hold capacitor
void discharge_capacitor(void) {
#ifdef OPEN_DRAIN_SUPPORT
- writePinLow(DISCHARGE_PIN);
+ gpio_write_pin_low(DISCHARGE_PIN);
#else
- writePinLow(DISCHARGE_PIN);
- setPinOutput(DISCHARGE_PIN);
+ gpio_write_pin_low(DISCHARGE_PIN);
+ gpio_set_pin_output(DISCHARGE_PIN);
#endif
}
// Charge the peak hold capacitor
void charge_capacitor(uint8_t row) {
#ifdef OPEN_DRAIN_SUPPORT
- writePinHigh(DISCHARGE_PIN);
+ gpio_write_pin_high(DISCHARGE_PIN);
#else
- setPinInput(DISCHARGE_PIN);
+ gpio_set_pin_input(DISCHARGE_PIN);
#endif
- writePinHigh(row_pins[row]);
+ gpio_write_pin_high(row_pins[row]);
}
// Initialize the peripherals pins
@@ 123,11 123,11 @@ int ec_init(void) {
adc_read(adcMux);
// Initialize discharge pin as discharge mode
- writePinLow(DISCHARGE_PIN);
+ gpio_write_pin_low(DISCHARGE_PIN);
#ifdef OPEN_DRAIN_SUPPORT
- setPinOutputOpenDrain(DISCHARGE_PIN);
+ gpio_set_pin_output_open_drain(DISCHARGE_PIN);
#else
- setPinOutput(DISCHARGE_PIN);
+ gpio_set_pin_output(DISCHARGE_PIN);
#endif
// Initialize drive lines
@@ 212,7 212,7 @@ uint16_t ec_readkey_raw(uint8_t channel, uint8_t row, uint8_t col) {
select_amux_channel(channel, col);
// Set the row pin to low state to avoid ghosting
- writePinLow(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
ATOMIC_BLOCK_FORCEON {
// Set the row pin to high state and have capacitor charge
M keyboards/clueboard/2x1800/2019/2019.c => keyboards/clueboard/2x1800/2019/2019.c +12 -12
@@ 17,14 17,14 @@
void matrix_init_kb(void) {
// Set our LED pins as output
- setPinOutput(D6);
- setPinOutput(B4);
- setPinOutput(B5);
- setPinOutput(B6);
+ gpio_set_pin_output(D6);
+ gpio_set_pin_output(B4);
+ gpio_set_pin_output(B5);
+ gpio_set_pin_output(B6);
// Set our Tilt Sensor pins as input
- setPinInputHigh(SHAKE_PIN_A);
- setPinInputHigh(SHAKE_PIN_B);
+ gpio_set_pin_input_high(SHAKE_PIN_A);
+ gpio_set_pin_input_high(SHAKE_PIN_B);
// Run the keymap level init
matrix_init_user();
@@ 43,12 43,12 @@ void check_encoder_buttons(void) {
if (drawing_mode) {
dprintf("Turning drawing mode off.\n");
drawing_mode = false;
- writePinLow(D6);
+ gpio_write_pin_low(D6);
unregister_code(KC_BTN1);
} else {
dprintf("Turning drawing mode on.\n");
drawing_mode = true;
- writePinHigh(D6);
+ gpio_write_pin_high(D6);
register_code(KC_BTN1);
}
}
@@ 65,7 65,7 @@ void matrix_scan_kb(void) {
#ifdef SHAKE_ENABLE
// Read the current state of the tilt sensor. It is physically
// impossible for both pins to register a low state at the same time.
- uint8_t tilt_read = (readPin(SHAKE_PIN_A) << 4) | readPin(SHAKE_PIN_B);
+ uint8_t tilt_read = (gpio_read_pin(SHAKE_PIN_A) << 4) | gpio_read_pin(SHAKE_PIN_B);
// Check to see if the tilt sensor has changed state since our last read
if (tilt_state != tilt_read) {
@@ 136,9 136,9 @@ bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(B4, !led_state.num_lock);
- writePin(B5, !led_state.caps_lock);
- writePin(B6, !led_state.scroll_lock);
+ gpio_write_pin(B4, !led_state.num_lock);
+ gpio_write_pin(B5, !led_state.caps_lock);
+ gpio_write_pin(B6, !led_state.scroll_lock);
}
return res;
M keyboards/clueboard/2x1800/2021/max7219.c => keyboards/clueboard/2x1800/2021/max7219.c +2 -2
@@ 206,8 206,8 @@ void max7219_init(void) {
wait_ms(1500);
dprintf("max7219_init()\n");
- setPinOutput(MAX7219_LOAD);
- writePinHigh(MAX7219_LOAD);
+ gpio_set_pin_output(MAX7219_LOAD);
+ gpio_write_pin_high(MAX7219_LOAD);
spi_init();
for (int i=0; i<MAX7219_CONTROLLERS; i++) {
M keyboards/clueboard/66/rev4/rev4.c => keyboards/clueboard/66/rev4/rev4.c +12 -12
@@ 2,23 2,23 @@
void led_init_ports(void) {
// Set our LED pins as output
- setPinOutput(B13); // LED1
- writePinLow(B13);
- setPinOutput(B14); // LED2
- writePinLow(B14);
- setPinOutput(A8); // LED3
- writePinLow(A8);
- setPinOutput(A0); // Capslock LED
- writePinLow(A0);
+ gpio_set_pin_output(B13); // LED1
+ gpio_write_pin_low(B13);
+ gpio_set_pin_output(B14); // LED2
+ gpio_write_pin_low(B14);
+ gpio_set_pin_output(A8); // LED3
+ gpio_write_pin_low(A8);
+ gpio_set_pin_output(A0); // Capslock LED
+ gpio_write_pin_low(A0);
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(B13, led_state.num_lock);
- writePin(A0, led_state.caps_lock);
- writePin(B14, led_state.caps_lock);
- writePin(A8, led_state.scroll_lock);
+ gpio_write_pin(B13, led_state.num_lock);
+ gpio_write_pin(A0, led_state.caps_lock);
+ gpio_write_pin(B14, led_state.caps_lock);
+ gpio_write_pin(A8, led_state.scroll_lock);
}
return res;
}
M keyboards/converter/palm_usb/matrix.c => keyboards/converter/palm_usb/matrix.c +18 -18
@@ 95,27 95,27 @@ void pins_init(void) {
// set pins for pullups, Rts , power &etc.
//print ("pins setup\n");
- setPinOutput(VCC_PIN);
- writePinLow(VCC_PIN);
+ gpio_set_pin_output(VCC_PIN);
+ gpio_write_pin_low(VCC_PIN);
#if ( HANDSPRING == 0)
#ifdef CY835
- setPinOutput(GND_PIN);
- writePinLow(GND_PIN);
+ gpio_set_pin_output(GND_PIN);
+ gpio_write_pin_low(GND_PIN);
- setPinOutput(PULLDOWN_PIN);
- writePinLow(PULLDOWN_PIN);
+ gpio_set_pin_output(PULLDOWN_PIN);
+ gpio_write_pin_low(PULLDOWN_PIN);
#endif
- setPinInput(DCD_PIN);
- setPinInput(RTS_PIN);
+ gpio_set_pin_input(DCD_PIN);
+ gpio_set_pin_input(RTS_PIN);
#endif
/* check that the other side isn't powered up.
- test=readPin(DCD_PIN);
+ test=gpio_read_pin(DCD_PIN);
xprintf("b%02X:", test);
- test=readPin(RTS_PIN);
+ test=gpio_read_pin(RTS_PIN);
xprintf("%02X\n", test);
*/
@@ 128,16 128,16 @@ uint8_t rts_reset(void) {
// On boot, we keep rts as input, then switch roles here
// on leaving sleep, we toggle the same way
- firstread=readPin(RTS_PIN);
+ firstread=gpio_read_pin(RTS_PIN);
// printf("r%02X:", firstread);
- setPinOutput(RTS_PIN);
+ gpio_set_pin_output(RTS_PIN);
if (firstread) {
- writePinLow(RTS_PIN);
+ gpio_write_pin_low(RTS_PIN);
}
wait_ms(10);
- writePinHigh(RTS_PIN);
+ gpio_write_pin_high(RTS_PIN);
/* the future is Arm
@@ 223,9 223,9 @@ uint8_t handspring_handshake(void) {
}
uint8_t handspring_reset(void) {
- writePinLow(VCC_PIN);
+ gpio_write_pin_low(VCC_PIN);
wait_ms(5);
- writePinHigh(VCC_PIN);
+ gpio_write_pin_high(VCC_PIN);
if ( handspring_handshake() ) {
last_activity = timer_read();
@@ 249,7 249,7 @@ void matrix_init(void)
#endif
print("power up\n");
- writePinHigh(VCC_PIN);
+ gpio_write_pin_high(VCC_PIN);
// wait for DCD strobe from keyboard - it will do this
// up to 3 times, then the board needs the RTS toggled to try again
@@ 264,7 264,7 @@ void matrix_init(void)
}
#else /// Palm / HP device with DCD
- while( !readPin(DCD_PIN) ) {;}
+ while( !gpio_read_pin(DCD_PIN) ) {;}
print("dcd\n");
rts_reset(); // at this point the keyboard should think all is well.
M keyboards/converter/siemens_tastatur/matrix.c => keyboards/converter/siemens_tastatur/matrix.c +24 -24
@@ 79,29 79,29 @@ static void pal_cb(void* unused) {
void matrix_init(void) {
//Set I/O as pull-up inputs to read states
- setPinInputHigh(A0);
- setPinInputHigh(A1);
- setPinInputHigh(A2);
- setPinInputHigh(A3);
- setPinInputHigh(A4);
- setPinInputHigh(A5);
- setPinInputHigh(A6);
- setPinInputHigh(A7);
- setPinInputHigh(A8);
- setPinInputHigh(A9);
- setPinInputHigh(A10);
- setPinInputHigh(B3);
- setPinInputHigh(B4);
- setPinInputHigh(B5);
- setPinInputHigh(B6);
- setPinInputHigh(B7);
- setPinInputHigh(B8);
- setPinInputHigh(B9);
- setPinInputHigh(B11);
- setPinInputHigh(B12);
- setPinInputHigh(B13);
- setPinInputHigh(B14);
- setPinInputHigh(B15);
+ gpio_set_pin_input_high(A0);
+ gpio_set_pin_input_high(A1);
+ gpio_set_pin_input_high(A2);
+ gpio_set_pin_input_high(A3);
+ gpio_set_pin_input_high(A4);
+ gpio_set_pin_input_high(A5);
+ gpio_set_pin_input_high(A6);
+ gpio_set_pin_input_high(A7);
+ gpio_set_pin_input_high(A8);
+ gpio_set_pin_input_high(A9);
+ gpio_set_pin_input_high(A10);
+ gpio_set_pin_input_high(B3);
+ gpio_set_pin_input_high(B4);
+ gpio_set_pin_input_high(B5);
+ gpio_set_pin_input_high(B6);
+ gpio_set_pin_input_high(B7);
+ gpio_set_pin_input_high(B8);
+ gpio_set_pin_input_high(B9);
+ gpio_set_pin_input_high(B11);
+ gpio_set_pin_input_high(B12);
+ gpio_set_pin_input_high(B13);
+ gpio_set_pin_input_high(B14);
+ gpio_set_pin_input_high(B15);
memset(matrix, 0, MATRIX_ROWS * sizeof(matrix_row_t));
memset(matrix_debouncing, 0, MATRIX_ROWS * sizeof(matrix_row_t));
@@ 207,7 207,7 @@ uint8_t matrix_scan(void) {
matrix[3] = 0x00;
}
//Special case for Shift
- if (readPin(B11) == 0) { matrix[3] |= 0x01; }
+ if (gpio_read_pin(B11) == 0) { matrix[3] |= 0x01; }
porta_buffer = 65535;
portb_buffer = 65535;
M keyboards/converter/xt_usb/config.h => keyboards/converter/xt_usb/config.h +3 -3
@@ 34,10 34,10 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* hard reset: low pulse for 500ms and after that HiZ for safety */
#define XT_RESET() do { \
- writePinLow(XT_RST_PIN); \
- setPinOutput(XT_RST_PIN); \
+ gpio_write_pin_low(XT_RST_PIN); \
+ gpio_set_pin_output(XT_RST_PIN); \
wait_ms(500); \
- setPinInput(XT_RST_PIN); \
+ gpio_set_pin_input(XT_RST_PIN); \
} while (0)
/* INT1 for falling edge of clock line */
M keyboards/converter/xt_usb/xt.h => keyboards/converter/xt_usb/xt.h +10 -10
@@ 43,30 43,30 @@ POSSIBILITY OF SUCH DAMAGE.
#define XT_DATA_IN() \
do { \
- setPinInput(XT_DATA_PIN); \
- writePinHigh(XT_DATA_PIN); \
+ gpio_set_pin_input(XT_DATA_PIN); \
+ gpio_write_pin_high(XT_DATA_PIN); \
} while (0)
-#define XT_DATA_READ() readPin(XT_DATA_PIN)
+#define XT_DATA_READ() gpio_read_pin(XT_DATA_PIN)
#define XT_DATA_LO() \
do { \
- writePinLow(XT_DATA_PIN); \
- setPinOutput(XT_DATA_PIN); \
+ gpio_write_pin_low(XT_DATA_PIN); \
+ gpio_set_pin_output(XT_DATA_PIN); \
} while (0)
#define XT_CLOCK_IN() \
do { \
- setPinInput(XT_CLOCK_PIN); \
- writePinHigh(XT_CLOCK_PIN); \
+ gpio_set_pin_input(XT_CLOCK_PIN); \
+ gpio_write_pin_high(XT_CLOCK_PIN); \
} while (0)
-#define XT_CLOCK_READ() readPin(XT_CLOCK_PIN)
+#define XT_CLOCK_READ() gpio_read_pin(XT_CLOCK_PIN)
#define XT_CLOCK_LO() \
do { \
- writePinLow(XT_CLOCK_PIN); \
- setPinOutput(XT_CLOCK_PIN); \
+ gpio_write_pin_low(XT_CLOCK_PIN); \
+ gpio_set_pin_output(XT_CLOCK_PIN); \
} while (0)
void xt_host_init(void);
M keyboards/custommk/evo70_r2/matrix.c => keyboards/custommk/evo70_r2/matrix.c +10 -10
@@ 10,7 10,7 @@ void matrix_wait_for_pin(pin_t pin, uint8_t target_state) {
rtcnt_t start = chSysGetRealtimeCounterX();
rtcnt_t end = start + 5000;
while (chSysIsCounterWithinX(chSysGetRealtimeCounterX(), start, end)) {
- if (readPin(pin) == target_state) {
+ if (gpio_read_pin(pin) == target_state) {
break;
}
}
@@ 27,22 27,22 @@ void matrix_wait_for_port(stm32_gpio_t *port, uint32_t target_bitmask) {
}
void shift_pulse_clock(void) {
- writePinHigh(COL_SHIFT_CLK_PIN);
+ gpio_write_pin_high(COL_SHIFT_CLK_PIN);
matrix_wait_for_pin(COL_SHIFT_CLK_PIN, 1);
- writePinLow(COL_SHIFT_CLK_PIN);
+ gpio_write_pin_low(COL_SHIFT_CLK_PIN);
}
void matrix_init_custom(void) {
//set all row pins as input with pullups
for (int i = 0; i < MATRIX_ROWS; ++i) {
- writePinHigh(row_pins[i]);
- setPinInputHigh(row_pins[i]);
+ gpio_write_pin_high(row_pins[i]);
+ gpio_set_pin_input_high(row_pins[i]);
}
//set all column pins high in ROW2COL matrix
- setPinOutput(COL_SHIFT_IN_PIN);
- setPinOutput(COL_SHIFT_CLK_PIN);
- writePinHigh(COL_SHIFT_IN_PIN);
+ gpio_set_pin_output(COL_SHIFT_IN_PIN);
+ gpio_set_pin_output(COL_SHIFT_CLK_PIN);
+ gpio_write_pin_high(COL_SHIFT_IN_PIN);
matrix_wait_for_pin(COL_SHIFT_IN_PIN, 1);
for (int i = 0; i < MATRIX_COLS; ++i) {
@@ 54,13 54,13 @@ void matrix_init_custom(void) {
bool matrix_scan_custom(matrix_row_t current_matrix[]) {
static matrix_row_t temp_matrix[MATRIX_ROWS] = {0};
- writePinLow(COL_SHIFT_IN_PIN);
+ gpio_write_pin_low(COL_SHIFT_IN_PIN);
matrix_wait_for_pin(COL_SHIFT_IN_PIN, 0);
// Setup the output column pin
shift_pulse_clock();
- writePinHigh(COL_SHIFT_IN_PIN);
+ gpio_write_pin_high(COL_SHIFT_IN_PIN);
for (int current_col = 0; current_col < MATRIX_COLS; ++current_col) {
// Read the column ports
M keyboards/cutie_club/wraith/wraith.c => keyboards/cutie_club/wraith/wraith.c +1 -1
@@ 16,7 16,7 @@
#include "quantum.h"
void matrix_init_kb(void) {
- setPinOutput(B0);
+ gpio_set_pin_output(B0);
matrix_init_user();
}
M keyboards/dark/magnum_ergo_1/magnum_ergo_1.c => keyboards/dark/magnum_ergo_1/magnum_ergo_1.c +22 -22
@@ 17,34 17,34 @@
#include "quantum.h"
void keyoard_post_init_kb(void) {
- setPinOutput(LED_CAPS_LOCK_PIN);
- setPinOutput(LED_INDICATOR_1);
- setPinOutput(LED_INDICATOR_2);
- setPinOutput(LED_INDICATOR_3);
- setPinOutput(LED_INDICATOR_4);
- setPinOutput(LED_INDICATOR_5);
+ gpio_set_pin_output(LED_CAPS_LOCK_PIN);
+ gpio_set_pin_output(LED_INDICATOR_1);
+ gpio_set_pin_output(LED_INDICATOR_2);
+ gpio_set_pin_output(LED_INDICATOR_3);
+ gpio_set_pin_output(LED_INDICATOR_4);
+ gpio_set_pin_output(LED_INDICATOR_5);
#ifndef LED_CAPS_LOCK_PIN
- writePin(LED_CAPS_LOCK_PIN, 0);
+ gpio_write_pin(LED_CAPS_LOCK_PIN, 0);
#endif
#ifndef LED_INDICATOR_1
- writePin(LED_INDICATOR_1, 0);
+ gpio_write_pin(LED_INDICATOR_1, 0);
#endif
#ifndef LED_INDICATOR_2
- writePin(LED_INDICATOR_2, 0);
+ gpio_write_pin(LED_INDICATOR_2, 0);
#endif
#ifndef LED_INDICATOR_3
- writePin(LED_INDICATOR_3, 0);
+ gpio_write_pin(LED_INDICATOR_3, 0);
#endif
#ifndef LED_INDICATOR_4
- writePin(LED_INDICATOR_4, 0);
+ gpio_write_pin(LED_INDICATOR_4, 0);
#endif
#ifndef LED_INDICATOR_5
- writePin(LED_INDICATOR_5, 0);
+ gpio_write_pin(LED_INDICATOR_5, 0);
#endif
keyboard_post_init_user();
}
@@ 53,39 53,39 @@ layer_state_t layer_state_set_kb(layer_state_t state) {
switch (get_highest_layer(state)) {
case 1:
#ifdef LED_INDICATOR_4
- writePin(LED_INDICATOR_4, 1);
+ gpio_write_pin(LED_INDICATOR_4, 1);
#endif
#ifdef LED_INDICATOR_5
- writePin(LED_INDICATOR_5, 1);
+ gpio_write_pin(LED_INDICATOR_5, 1);
#endif
break;
case 2:
#ifdef LED_INDICATOR_1
- writePin(LED_INDICATOR_1, 1);
+ gpio_write_pin(LED_INDICATOR_1, 1);
#endif
#ifdef LED_INDICATOR_2
- writePin(LED_INDICATOR_2, 1);
+ gpio_write_pin(LED_INDICATOR_2, 1);
#endif
#ifdef LED_INDICATOR_3
- writePin(LED_INDICATOR_3, 1);
+ gpio_write_pin(LED_INDICATOR_3, 1);
#endif
break;
default:
#ifdef LED_INDICATOR_1
- writePin(LED_INDICATOR_1, 0);
+ gpio_write_pin(LED_INDICATOR_1, 0);
#endif
#ifdef LED_INDICATOR_2
- writePin(LED_INDICATOR_2, 0);
+ gpio_write_pin(LED_INDICATOR_2, 0);
#endif
#ifdef LED_INDICATOR_3
- writePin(LED_INDICATOR_3, 0);
+ gpio_write_pin(LED_INDICATOR_3, 0);
#endif
#ifdef LED_INDICATOR_4
- writePin(LED_INDICATOR_4, 0);
+ gpio_write_pin(LED_INDICATOR_4, 0);
#endif
#ifdef LED_INDICATOR_5
- writePin(LED_INDICATOR_5, 0);
+ gpio_write_pin(LED_INDICATOR_5, 0);
#endif
break;
}
M keyboards/darkproject/kd83a_bfg_edition/kd83a_bfg_edition.c => keyboards/darkproject/kd83a_bfg_edition/kd83a_bfg_edition.c +6 -6
@@ 132,9 132,9 @@ void spi_init(void) {
is_initialised = true;
// Try releasing special pins for a short time
- setPinInput(SPI_SCK_PIN);
- setPinInput(SPI_MOSI_PIN);
- setPinInput(SPI_MISO_PIN);
+ gpio_set_pin_input(SPI_SCK_PIN);
+ gpio_set_pin_input(SPI_MOSI_PIN);
+ gpio_set_pin_input(SPI_MISO_PIN);
chThdSleepMilliseconds(10);
@@ 147,12 147,12 @@ void spi_init(void) {
#endif
void keyboard_pre_init_kb(void) {
- setPinOutput(C0);
- setPinOutput(C15);
+ gpio_set_pin_output(C0);
+ gpio_set_pin_output(C15);
keyboard_pre_init_user();
};
void housekeeping_task_kb(void) {
- writePin(C15, keymap_config.no_gui);
+ gpio_write_pin(C15, keymap_config.no_gui);
};
bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
M keyboards/darkproject/kd87a_bfg_edition/kd87a_bfg_edition.c => keyboards/darkproject/kd87a_bfg_edition/kd87a_bfg_edition.c +6 -6
@@ 133,9 133,9 @@ void spi_init(void) {
is_initialised = true;
// Try releasing special pins for a short time
- setPinInput(SPI_SCK_PIN);
- setPinInput(SPI_MOSI_PIN);
- setPinInput(SPI_MISO_PIN);
+ gpio_set_pin_input(SPI_SCK_PIN);
+ gpio_set_pin_input(SPI_MOSI_PIN);
+ gpio_set_pin_input(SPI_MISO_PIN);
chThdSleepMilliseconds(10);
@@ 148,12 148,12 @@ void spi_init(void) {
#endif
void keyboard_pre_init_kb(void) {
- setPinOutput(C0);
- setPinOutput(C15);
+ gpio_set_pin_output(C0);
+ gpio_set_pin_output(C15);
keyboard_pre_init_user();
};
void housekeeping_task_kb(void) {
- writePin(C15, keymap_config.no_gui);
+ gpio_write_pin(C15, keymap_config.no_gui);
};
bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
M keyboards/dekunukem/duckypad/duckypad.c => keyboards/dekunukem/duckypad/duckypad.c +4 -4
@@ 21,11 21,11 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(A0);
- writePinHigh(A0);
- writePinLow(A0);
+ gpio_set_pin_output(A0);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_low(A0);
wait_ms(10);
- writePinHigh(A0);
+ gpio_write_pin_high(A0);
keyboard_pre_init_user();
}
M keyboards/dichotomy/dichotomy.c => keyboards/dichotomy/dichotomy.c +6 -6
@@ 60,13 60,13 @@ bool pointing_device_task(void){
}
void led_init(void) {
- setPinOutput(D1);
- setPinOutput(F5);
- setPinOutput(F6);
+ gpio_set_pin_output(D1);
+ gpio_set_pin_output(F5);
+ gpio_set_pin_output(F6);
- writePinHigh(D1);
- writePinHigh(F5);
- writePinHigh(F6);
+ gpio_write_pin_high(D1);
+ gpio_write_pin_high(F5);
+ gpio_write_pin_high(F6);
}
M keyboards/dichotomy/dichotomy.h => keyboards/dichotomy/dichotomy.h +6 -6
@@ 4,12 4,12 @@
#include "pointing_device.h"
#include "quantum.h"
-#define red_led_off() writePinHigh(F6)
-#define red_led_on() writePinLow(F6)
-#define blu_led_off() writePinHigh(F5)
-#define blu_led_on() writePinLow(F5)
-#define grn_led_off() writePinHigh(D1)
-#define grn_led_on() writePinLow(D1)
+#define red_led_off() gpio_write_pin_high(F6)
+#define red_led_on() gpio_write_pin_low(F6)
+#define blu_led_off() gpio_write_pin_high(F5)
+#define blu_led_on() gpio_write_pin_low(F5)
+#define grn_led_off() gpio_write_pin_high(D1)
+#define grn_led_on() gpio_write_pin_low(D1)
#define red_led(flag) if (flag) red_led_on(); else red_led_off()
#define blu_led(flag) if (flag) blu_led_on(); else blu_led_off()
M keyboards/dinofizz/fnrow/v1/v1.c => keyboards/dinofizz/fnrow/v1/v1.c +5 -5
@@ 17,8 17,8 @@
void keyboard_pre_init_kb(void) {
// Immediately set the LED pin as an output and set it ON
- setPinOutput(A15);
- writePinHigh(A15);
+ gpio_set_pin_output(A15);
+ gpio_write_pin_high(A15);
keyboard_pre_init_user();
}
@@ 26,11 26,11 @@ void keyboard_pre_init_kb(void) {
void keyboard_post_init_kb(void) {
// Blink the LED so we know everything is running OK
// Finish with LED OFF
- writePinLow(A15);
+ gpio_write_pin_low(A15);
wait_ms(100);
- writePinHigh(A15);
+ gpio_write_pin_high(A15);
wait_ms(100);
- writePinLow(A15);
+ gpio_write_pin_low(A15);
keyboard_post_init_user();
}
M keyboards/dk60/dk60.c => keyboards/dk60/dk60.c +2 -2
@@ 40,8 40,8 @@ void matrix_init_kb(void) {
}
void led_init_ports(void) {
- setPinOutput(E6);
- setPinOutput(F0);
+ gpio_set_pin_output(E6);
+ gpio_set_pin_output(F0);
}
void led_update_ports(led_t led_state) {
M keyboards/dk60/dk60.h => keyboards/dk60/dk60.h +4 -4
@@ 19,11 19,11 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "quantum.h"
-inline void dk60_caps_led_on(void) { writePinHigh(E6); }
-inline void dk60_esc_led_on(void) { writePinHigh(F0); }
+inline void dk60_caps_led_on(void) { gpio_write_pin_high(E6); }
+inline void dk60_esc_led_on(void) { gpio_write_pin_high(F0); }
-inline void dk60_caps_led_off(void) { writePinLow(E6); }
-inline void dk60_esc_led_off(void) { writePinLow(F0); }
+inline void dk60_caps_led_off(void) { gpio_write_pin_low(E6); }
+inline void dk60_esc_led_off(void) { gpio_write_pin_low(F0); }
inline void dk60_led_all_on(void) {
dk60_caps_led_on();
M keyboards/dm9records/lain/lain.c => keyboards/dm9records/lain/lain.c +3 -3
@@ 12,7 12,7 @@ void lain_eeconfig_update_kb(void) { eeconfig_update_kb(lain_config.raw); }
void lain_set_led(uint8_t no, bool flag) {
led_states[no] = flag;
- writePin(leds[no], lain_config.led_enabled ? flag : false);
+ gpio_write_pin(leds[no], lain_config.led_enabled ? flag : false);
}
void lain_enable_leds(bool flag) {
@@ 20,7 20,7 @@ void lain_enable_leds(bool flag) {
lain_eeconfig_update_kb();
for (int i = 0; i < LED_NUM; i++) {
- writePin(leds[i], lain_config.led_enabled ? led_states[i] : false);
+ gpio_write_pin(leds[i], lain_config.led_enabled ? led_states[i] : false);
}
}
@@ 28,7 28,7 @@ void lain_enable_leds_toggle(void) { lain_enable_leds(!lain_config.led_enabled);
void led_init_ports(void) {
for (uint8_t i = 0; i < LED_NUM; i++) {
- setPinOutput(leds[i]);
+ gpio_set_pin_output(leds[i]);
lain_set_led(leds[i], 0);
}
}
M keyboards/doppelganger/doppelganger.c => keyboards/doppelganger/doppelganger.c +7 -7
@@ 16,30 16,30 @@
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(C6);
- setPinOutput(B0);
+ gpio_set_pin_output(C6);
+ gpio_set_pin_output(B0);
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if (res) {
- // writePin sets the pin high for 1 and low for 0.
+ // gpio_write_pin sets the pin high for 1 and low for 0.
// In this example the pins are inverted, setting
// it low/0 turns it on, and high/1 turns the LED off.
// This behavior depends on whether the LED is between the pin
// and VCC or the pin and GND.
- writePin(C6, !led_state.caps_lock);
+ gpio_write_pin(C6, !led_state.caps_lock);
}
return res;
}
__attribute__((weak)) layer_state_t layer_state_set_user(layer_state_t state) {
- writePin(B0, !(state & (1UL << 1)));
+ gpio_write_pin(B0, !(state & (1UL << 1)));
return state;
}
// Override core logic as we reuse SPLIT_HAND_PIN within matrix pins
bool is_keyboard_left(void) {
- setPinInput(SPLIT_HAND_PIN);
- return readPin(SPLIT_HAND_PIN);
+ gpio_set_pin_input(SPLIT_HAND_PIN);
+ return gpio_read_pin(SPLIT_HAND_PIN);
}
M keyboards/dp60/matrix.c => keyboards/dp60/matrix.c +72 -72
@@ 54,10 54,10 @@ void matrix_scan_user(void) {}
void matrix_init(void)
{
- //setPinOutput(F0);
- //writePinHigh(F0);
- setPinOutput(B4);
- writePinLow(B4);
+ //gpio_set_pin_output(F0);
+ //gpio_write_pin_high(F0);
+ gpio_set_pin_output(B4);
+ gpio_write_pin_low(B4);
init_cols();
init_rows();
@@ 123,20 123,20 @@ void matrix_print(void)
*/
static void init_rows(void)
{
- setPinInputHigh(E6);
- setPinInputHigh(F6);
- setPinInputHigh(F7);
- setPinInputHigh(B7);
- setPinInputHigh(D4);
+ gpio_set_pin_input_high(E6);
+ gpio_set_pin_input_high(F6);
+ gpio_set_pin_input_high(F7);
+ gpio_set_pin_input_high(B7);
+ gpio_set_pin_input_high(D4);
}
static uint8_t read_rows(void)
{
- return ((readPin(E6) ? 0 : (1 << 0)) |
- (readPin(F6) ? 0 : (1 << 1)) |
- (readPin(F7) ? 0 : (1 << 2)) |
- (readPin(B7) ? 0 : (1 << 3)) |
- (readPin(D4) ? 0 : (1 << 4)));
+ return ((gpio_read_pin(E6) ? 0 : (1 << 0)) |
+ (gpio_read_pin(F6) ? 0 : (1 << 1)) |
+ (gpio_read_pin(F7) ? 0 : (1 << 2)) |
+ (gpio_read_pin(B7) ? 0 : (1 << 3)) |
+ (gpio_read_pin(D4) ? 0 : (1 << 4)));
}
/*
@@ 164,104 164,104 @@ static uint8_t read_rows(void)
*/
static void init_cols(void)
{
- setPinOutput(F0);
- setPinOutput(F1);
- setPinOutput(F4);
- setPinOutput(F5);
+ gpio_set_pin_output(F0);
+ gpio_set_pin_output(F1);
+ gpio_set_pin_output(F4);
+ gpio_set_pin_output(F5);
- setPinOutput(D2);
- setPinOutput(D3);
- setPinOutput(D5);
- setPinOutput(D6);
+ gpio_set_pin_output(D2);
+ gpio_set_pin_output(D3);
+ gpio_set_pin_output(D5);
+ gpio_set_pin_output(D6);
unselect_cols();
}
static void unselect_cols(void)
{
- writePinHigh(F0);
- writePinHigh(F1);
- writePinHigh(F4);
- writePinHigh(F5);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_high(F5);
- writePinHigh(D2);
- writePinHigh(D3);
- writePinHigh(D5);
- writePinHigh(D6);
+ gpio_write_pin_high(D2);
+ gpio_write_pin_high(D3);
+ gpio_write_pin_high(D5);
+ gpio_write_pin_high(D6);
}
static void select_col(uint8_t col) {
switch (col) {
case 0:
- writePinLow(F0);
- writePinLow(F1);
- writePinLow(F4);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_low(F4);
break;
case 1:
- writePinHigh(F0);
- writePinLow(F1);
- writePinLow(F4);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_low(F4);
break;
case 2:
- writePinLow(F0);
- writePinHigh(F1);
- writePinLow(F4);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_low(F4);
break;
case 3:
- writePinHigh(F0);
- writePinHigh(F1);
- writePinLow(F4);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_low(F4);
break;
case 4:
- writePinLow(F0);
- writePinLow(F1);
- writePinHigh(F4);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_high(F4);
break;
case 5:
- writePinHigh(F0);
- writePinLow(F1);
- writePinHigh(F4);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_high(F4);
break;
case 6:
- writePinLow(F0);
- writePinHigh(F1);
- writePinHigh(F4);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_high(F4);
break;
case 7:
- writePinLow(D2);
- writePinLow(D3);
- writePinLow(D5);
+ gpio_write_pin_low(D2);
+ gpio_write_pin_low(D3);
+ gpio_write_pin_low(D5);
break;
case 8:
- writePinHigh(D2);
- writePinLow(D3);
- writePinLow(D5);
+ gpio_write_pin_high(D2);
+ gpio_write_pin_low(D3);
+ gpio_write_pin_low(D5);
break;
case 9:
- writePinLow(D2);
- writePinHigh(D3);
- writePinLow(D5);
+ gpio_write_pin_low(D2);
+ gpio_write_pin_high(D3);
+ gpio_write_pin_low(D5);
break;
case 10:
- writePinHigh(D2);
- writePinHigh(D3);
- writePinLow(D5);
+ gpio_write_pin_high(D2);
+ gpio_write_pin_high(D3);
+ gpio_write_pin_low(D5);
break;
case 11:
- writePinLow(D2);
- writePinLow(D3);
- writePinHigh(D5);
+ gpio_write_pin_low(D2);
+ gpio_write_pin_low(D3);
+ gpio_write_pin_high(D5);
break;
case 12:
- writePinHigh(D2);
- writePinLow(D3);
- writePinHigh(D5);
+ gpio_write_pin_high(D2);
+ gpio_write_pin_low(D3);
+ gpio_write_pin_high(D5);
break;
case 13:
- writePinLow(D2);
- writePinHigh(D3);
- writePinHigh(D5);
+ gpio_write_pin_low(D2);
+ gpio_write_pin_high(D3);
+ gpio_write_pin_high(D5);
break;
}
}
M keyboards/drop/lib/mux.c => keyboards/drop/lib/mux.c +6 -6
@@ 22,8 22,8 @@
#define C2_B5_SENSE B0
static inline void digital_write(pin_t pin, uint8_t level) {
- setPinOutput(pin);
- writePin(pin, level);
+ gpio_set_pin_output(pin);
+ gpio_write_pin(pin, level);
}
uint16_t v_con_1 = 0;
@@ 42,10 42,10 @@ void keyboard_USB_enable(void) {
digital_write(SRC_1, 1);
digital_write(SRC_2, 1);
- setPinInput(C1_A5_SENSE);
- setPinInput(C1_B5_SENSE);
- setPinInput(C2_A5_SENSE);
- setPinInput(C2_B5_SENSE);
+ gpio_set_pin_input(C1_A5_SENSE);
+ gpio_set_pin_input(C1_B5_SENSE);
+ gpio_set_pin_input(C2_A5_SENSE);
+ gpio_set_pin_input(C2_B5_SENSE);
// reset hub
digital_write(HUB_RESET_N, 0);
M keyboards/duck/orion/v3/matrix.c => keyboards/duck/orion/v3/matrix.c +3 -3
@@ 56,13 56,13 @@ void matrix_scan_user(void) {
void indicator_init_ports(void) {
// Num LED
- setPinOutput(B4);
+ gpio_set_pin_output(B4);
// Caps Lock
- setPinOutput(B0);
+ gpio_set_pin_output(B0);
// Scroll Lock
- setPinOutput(D7);
+ gpio_set_pin_output(D7);
}
void matrix_init(void) {
M keyboards/duck/orion/v3/v3.c => keyboards/duck/orion/v3/v3.c +3 -3
@@ 31,9 31,9 @@
// of the Escape key.
bool led_update_kb(led_t led_state) {
if(led_update_user(led_state)) {
- writePin(B0, !led_state.caps_lock);
- writePin(B4, !led_state.num_lock);
- writePin(D7, !led_state.scroll_lock);
+ gpio_write_pin(B0, !led_state.caps_lock);
+ gpio_write_pin(B4, !led_state.num_lock);
+ gpio_write_pin(D7, !led_state.scroll_lock);
}
return true;
}
M keyboards/dumbpad/v0x/v0x.c => keyboards/dumbpad/v0x/v0x.c +10 -10
@@ 17,8 17,8 @@
void keyboard_pre_init_kb(void) {
// Set LED IO as outputs
- setPinOutput(LED_00);
- setPinOutput(LED_01);
+ gpio_set_pin_output(LED_00);
+ gpio_set_pin_output(LED_01);
keyboard_pre_init_user();
}
@@ 27,16 27,16 @@ bool shutdown_kb(bool jump_to_bootloader) {
return false;
}
// Shutdown LEDs
- writePinLow(LED_00);
- writePinLow(LED_01);
+ gpio_write_pin_low(LED_00);
+ gpio_write_pin_low(LED_01);
return true;
}
layer_state_t layer_state_set_kb(layer_state_t state) {
// Layer LEDs act as binary indication of current layer
uint8_t layer = get_highest_layer(state);
- writePin(LED_00, layer & 0b1);
- writePin(LED_01, (layer >> 1) & 0b1);
+ gpio_write_pin(LED_00, layer & 0b1);
+ gpio_write_pin(LED_01, (layer >> 1) & 0b1);
return layer_state_set_user(state);
}
@@ 49,11 49,11 @@ void matrix_init_kb(void) {
// runs once when the firmware starts up
uint8_t led_delay_ms = 80;
for (int i = 0; i < 2; i++) {
- writePinHigh(LED_00);
- writePinHigh(LED_01);
+ gpio_write_pin_high(LED_00);
+ gpio_write_pin_high(LED_01);
wait_ms(led_delay_ms);
- writePinLow(LED_00);
- writePinLow(LED_01);
+ gpio_write_pin_low(LED_00);
+ gpio_write_pin_low(LED_01);
if (i < 1) {
wait_ms(led_delay_ms);
}
M keyboards/dumbpad/v0x_dualencoder/v0x_dualencoder.c => keyboards/dumbpad/v0x_dualencoder/v0x_dualencoder.c +10 -10
@@ 17,8 17,8 @@
void keyboard_pre_init_kb(void) {
// Set LED IO as outputs
- setPinOutput(LED_00);
- setPinOutput(LED_01);
+ gpio_set_pin_output(LED_00);
+ gpio_set_pin_output(LED_01);
keyboard_pre_init_user();
}
@@ 27,16 27,16 @@ bool shutdown_kb(bool jump_to_bootloader) {
return false;
}
// Shutdown LEDs
- writePinLow(LED_00);
- writePinLow(LED_01);
+ gpio_write_pin_low(LED_00);
+ gpio_write_pin_low(LED_01);
return true;
}
layer_state_t layer_state_set_kb(layer_state_t state) {
// Layer LEDs act as binary indication of current layer
uint8_t layer = get_highest_layer(state);
- writePin(LED_00, layer & 0b1);
- writePin(LED_01, (layer >> 1) & 0b1);
+ gpio_write_pin(LED_00, layer & 0b1);
+ gpio_write_pin(LED_01, (layer >> 1) & 0b1);
return layer_state_set_user(state);
}
@@ 49,11 49,11 @@ void matrix_init_kb(void) {
// runs once when the firmware starts up
uint8_t led_delay_ms = 80;
for (int i = 0; i < 2; i++) {
- writePinHigh(LED_00);
- writePinHigh(LED_01);
+ gpio_write_pin_high(LED_00);
+ gpio_write_pin_high(LED_01);
wait_ms(led_delay_ms);
- writePinLow(LED_00);
- writePinLow(LED_01);
+ gpio_write_pin_low(LED_00);
+ gpio_write_pin_low(LED_01);
if (i < 1) {
wait_ms(led_delay_ms);
}
M keyboards/dumbpad/v0x_right/v0x_right.c => keyboards/dumbpad/v0x_right/v0x_right.c +10 -10
@@ 17,8 17,8 @@
void keyboard_pre_init_kb(void) {
// Set LED IO as outputs
- setPinOutput(LED_00);
- setPinOutput(LED_01);
+ gpio_set_pin_output(LED_00);
+ gpio_set_pin_output(LED_01);
keyboard_pre_init_user();
}
@@ 27,16 27,16 @@ bool shutdown_kb(bool jump_to_bootloader) {
return false;
}
// Shutdown LEDs
- writePinLow(LED_00);
- writePinLow(LED_01);
+ gpio_write_pin_low(LED_00);
+ gpio_write_pin_low(LED_01);
return true;
}
layer_state_t layer_state_set_kb(layer_state_t state) {
// Layer LEDs act as binary indication of current layer
uint8_t layer = get_highest_layer(state);
- writePin(LED_00, layer & 0b1);
- writePin(LED_01, (layer >> 1) & 0b1);
+ gpio_write_pin(LED_00, layer & 0b1);
+ gpio_write_pin(LED_01, (layer >> 1) & 0b1);
return layer_state_set_user(state);
}
@@ 49,11 49,11 @@ void matrix_init_kb(void) {
// runs once when the firmware starts up
uint8_t led_delay_ms = 80;
for (int i = 0; i < 2; i++) {
- writePinHigh(LED_00);
- writePinHigh(LED_01);
+ gpio_write_pin_high(LED_00);
+ gpio_write_pin_high(LED_01);
wait_ms(led_delay_ms);
- writePinLow(LED_00);
- writePinLow(LED_01);
+ gpio_write_pin_low(LED_00);
+ gpio_write_pin_low(LED_01);
if (i < 1) {
wait_ms(led_delay_ms);
}
M keyboards/dumbpad/v1x/v1x.c => keyboards/dumbpad/v1x/v1x.c +15 -15
@@ 17,9 17,9 @@
void keyboard_pre_init_kb(void) {
// Set LED IO as outputs
- setPinOutput(LED_00);
- setPinOutput(LED_01);
- setPinOutput(LED_02);
+ gpio_set_pin_output(LED_00);
+ gpio_set_pin_output(LED_01);
+ gpio_set_pin_output(LED_02);
keyboard_pre_init_user();
}
@@ 28,17 28,17 @@ bool shutdown_kb(bool jump_to_bootloader) {
return false;
}
// Shutdown LEDs
- writePinLow(LED_00);
- writePinLow(LED_01);
- writePinLow(LED_02);
+ gpio_write_pin_low(LED_00);
+ gpio_write_pin_low(LED_01);
+ gpio_write_pin_low(LED_02);
return true;
}
layer_state_t layer_state_set_kb(layer_state_t state) {
// Layer LEDs act as binary indication of current layer
uint8_t layer = get_highest_layer(state);
- writePin(LED_00, layer & 0b1);
- writePin(LED_01, (layer >> 1) & 0b1);
+ gpio_write_pin(LED_00, layer & 0b1);
+ gpio_write_pin(LED_01, (layer >> 1) & 0b1);
return layer_state_set_user(state);
}
@@ 51,13 51,13 @@ void matrix_init_kb(void) {
// runs once when the firmware starts up
uint8_t led_delay_ms = 80;
for (int i = 0; i < 2; i++) {
- writePinHigh(LED_00);
- writePinHigh(LED_01);
- writePinHigh(LED_02);
+ gpio_write_pin_high(LED_00);
+ gpio_write_pin_high(LED_01);
+ gpio_write_pin_high(LED_02);
wait_ms(led_delay_ms);
- writePinLow(LED_00);
- writePinLow(LED_01);
- writePinLow(LED_02);
+ gpio_write_pin_low(LED_00);
+ gpio_write_pin_low(LED_01);
+ gpio_write_pin_low(LED_02);
if (i < 1) {
wait_ms(led_delay_ms);
}
@@ 69,7 69,7 @@ void matrix_init_kb(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(LED_02, !led_state.num_lock);
+ gpio_write_pin(LED_02, !led_state.num_lock);
}
return res;
}
M keyboards/dumbpad/v1x_dualencoder/v1x_dualencoder.c => keyboards/dumbpad/v1x_dualencoder/v1x_dualencoder.c +15 -15
@@ 17,9 17,9 @@
void keyboard_pre_init_kb(void) {
// Set LED IO as outputs
- setPinOutput(LED_00);
- setPinOutput(LED_01);
- setPinOutput(LED_02);
+ gpio_set_pin_output(LED_00);
+ gpio_set_pin_output(LED_01);
+ gpio_set_pin_output(LED_02);
keyboard_pre_init_user();
}
@@ 28,17 28,17 @@ bool shutdown_kb(bool jump_to_bootloader) {
return false;
}
// Shutdown LEDs
- writePinLow(LED_00);
- writePinLow(LED_01);
- writePinLow(LED_02);
+ gpio_write_pin_low(LED_00);
+ gpio_write_pin_low(LED_01);
+ gpio_write_pin_low(LED_02);
return true;
}
layer_state_t layer_state_set_kb(layer_state_t state) {
// Layer LEDs act as binary indication of current layer
uint8_t layer = get_highest_layer(state);
- writePin(LED_00, layer & 0b1);
- writePin(LED_01, (layer >> 1) & 0b1);
+ gpio_write_pin(LED_00, layer & 0b1);
+ gpio_write_pin(LED_01, (layer >> 1) & 0b1);
return layer_state_set_user(state);
}
@@ 51,13 51,13 @@ void matrix_init_kb(void) {
// runs once when the firmware starts up
uint8_t led_delay_ms = 80;
for (int i = 0; i < 2; i++) {
- writePinHigh(LED_00);
- writePinHigh(LED_01);
- writePinHigh(LED_02);
+ gpio_write_pin_high(LED_00);
+ gpio_write_pin_high(LED_01);
+ gpio_write_pin_high(LED_02);
wait_ms(led_delay_ms);
- writePinLow(LED_00);
- writePinLow(LED_01);
- writePinLow(LED_02);
+ gpio_write_pin_low(LED_00);
+ gpio_write_pin_low(LED_01);
+ gpio_write_pin_low(LED_02);
if (i < 1) {
wait_ms(led_delay_ms);
}
@@ 69,7 69,7 @@ void matrix_init_kb(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(LED_02, !led_state.num_lock);
+ gpio_write_pin(LED_02, !led_state.num_lock);
}
return res;
}
M keyboards/dumbpad/v1x_right/v1x_right.c => keyboards/dumbpad/v1x_right/v1x_right.c +15 -15
@@ 17,9 17,9 @@
void keyboard_pre_init_kb(void) {
// Set LED IO as outputs
- setPinOutput(LED_00);
- setPinOutput(LED_01);
- setPinOutput(LED_02);
+ gpio_set_pin_output(LED_00);
+ gpio_set_pin_output(LED_01);
+ gpio_set_pin_output(LED_02);
keyboard_pre_init_user();
}
@@ 28,17 28,17 @@ bool shutdown_kb(bool jump_to_bootloader) {
return false;
}
// Shutdown LEDs
- writePinLow(LED_00);
- writePinLow(LED_01);
- writePinLow(LED_02);
+ gpio_write_pin_low(LED_00);
+ gpio_write_pin_low(LED_01);
+ gpio_write_pin_low(LED_02);
return true;
}
layer_state_t layer_state_set_kb(layer_state_t state) {
// Layer LEDs act as binary indication of current layer
uint8_t layer = get_highest_layer(state);
- writePin(LED_00, layer & 0b1);
- writePin(LED_01, (layer >> 1) & 0b1);
+ gpio_write_pin(LED_00, layer & 0b1);
+ gpio_write_pin(LED_01, (layer >> 1) & 0b1);
return layer_state_set_user(state);
}
@@ 51,13 51,13 @@ void matrix_init_kb(void) {
// runs once when the firmware starts up
uint8_t led_delay_ms = 80;
for (int i = 0; i < 2; i++) {
- writePinHigh(LED_00);
- writePinHigh(LED_01);
- writePinHigh(LED_02);
+ gpio_write_pin_high(LED_00);
+ gpio_write_pin_high(LED_01);
+ gpio_write_pin_high(LED_02);
wait_ms(led_delay_ms);
- writePinLow(LED_00);
- writePinLow(LED_01);
- writePinLow(LED_02);
+ gpio_write_pin_low(LED_00);
+ gpio_write_pin_low(LED_01);
+ gpio_write_pin_low(LED_02);
if (i < 1) {
wait_ms(led_delay_ms);
}
@@ 69,7 69,7 @@ void matrix_init_kb(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(LED_02, !led_state.num_lock);
+ gpio_write_pin(LED_02, !led_state.num_lock);
}
return res;
}
M keyboards/dumbpad/v3x/v3x.c => keyboards/dumbpad/v3x/v3x.c +15 -15
@@ 48,9 48,9 @@ led_config_t g_led_config = {{// Key Matrix to LED Index
void keyboard_pre_init_kb(void) {
// Set LED IO as outputs
- setPinOutput(LED_00);
- setPinOutput(LED_01);
- setPinOutput(LED_02);
+ gpio_set_pin_output(LED_00);
+ gpio_set_pin_output(LED_01);
+ gpio_set_pin_output(LED_02);
keyboard_pre_init_user();
}
@@ 59,17 59,17 @@ bool shutdown_kb(bool jump_to_bootloader) {
return false;
}
// Shutdown LEDs
- writePinLow(LED_00);
- writePinLow(LED_01);
- writePinLow(LED_02);
+ gpio_write_pin_low(LED_00);
+ gpio_write_pin_low(LED_01);
+ gpio_write_pin_low(LED_02);
return true;
}
layer_state_t layer_state_set_kb(layer_state_t state) {
// Layer LEDs act as binary indication of current layer
uint8_t layer = get_highest_layer(state);
- writePin(LED_00, layer & 0b1);
- writePin(LED_01, (layer >> 1) & 0b1);
+ gpio_write_pin(LED_00, layer & 0b1);
+ gpio_write_pin(LED_01, (layer >> 1) & 0b1);
uprintf("%d string", layer);
return layer_state_set_user(state);
}
@@ 83,13 83,13 @@ void matrix_init_kb(void) {
// runs once when the firmware starts up
uint8_t led_delay_ms = 80;
for (int i = 0; i < 2; i++) {
- writePinHigh(LED_00);
- writePinHigh(LED_01);
- writePinHigh(LED_02);
+ gpio_write_pin_high(LED_00);
+ gpio_write_pin_high(LED_01);
+ gpio_write_pin_high(LED_02);
wait_ms(led_delay_ms);
- writePinLow(LED_00);
- writePinLow(LED_01);
- writePinLow(LED_02);
+ gpio_write_pin_low(LED_00);
+ gpio_write_pin_low(LED_01);
+ gpio_write_pin_low(LED_02);
if (i < 1) {
wait_ms(led_delay_ms);
}
@@ 101,6 101,6 @@ void matrix_init_kb(void) {
bool led_update_kb(led_t led_state) {
if (!led_update_user(led_state)) return false;
// put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
- writePin(LED_02, !led_state.num_lock);
+ gpio_write_pin(LED_02, !led_state.num_lock);
return true;
}
M keyboards/durgod/dgk6x/dgk6x.c => keyboards/durgod/dgk6x/dgk6x.c +10 -10
@@ 18,22 18,22 @@
/* Private Functions */
void off_all_leds(void) {
- writePinHigh(LED_CAPS_LOCK_PIN);
- writePinHigh(LED_WIN_LOCK_PIN);
- writePinHigh(LED_MR_LOCK_PIN);
+ gpio_write_pin_high(LED_CAPS_LOCK_PIN);
+ gpio_write_pin_high(LED_WIN_LOCK_PIN);
+ gpio_write_pin_high(LED_MR_LOCK_PIN);
}
void on_all_leds(void) {
- writePinLow(LED_CAPS_LOCK_PIN);
- writePinLow(LED_WIN_LOCK_PIN);
- writePinLow(LED_MR_LOCK_PIN);
+ gpio_write_pin_low(LED_CAPS_LOCK_PIN);
+ gpio_write_pin_low(LED_WIN_LOCK_PIN);
+ gpio_write_pin_low(LED_MR_LOCK_PIN);
}
/* WinLock and MR LEDs are non-standard. Need to override led init */
void led_init_ports(void) {
- setPinOutput(LED_CAPS_LOCK_PIN);
- setPinOutput(LED_WIN_LOCK_PIN);
- setPinOutput(LED_MR_LOCK_PIN);
+ gpio_set_pin_output(LED_CAPS_LOCK_PIN);
+ gpio_set_pin_output(LED_WIN_LOCK_PIN);
+ gpio_set_pin_output(LED_MR_LOCK_PIN);
off_all_leds();
}
@@ 44,7 44,7 @@ bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
case GU_TOGG:
if (record->event.pressed) {
// Toggle LED on key press
- togglePin(LED_WIN_LOCK_PIN);
+ gpio_toggle_pin(LED_WIN_LOCK_PIN);
}
break;
}
M keyboards/durgod/k310/k310.c => keyboards/durgod/k310/k310.c +18 -18
@@ 22,33 22,33 @@
/* Private Functions */
void off_all_leds(void) {
#ifdef LED_NUM_LOCK_PIN
- writePinHigh(LED_NUM_LOCK_PIN);
+ gpio_write_pin_high(LED_NUM_LOCK_PIN);
#endif
- writePinHigh(LED_CAPS_LOCK_PIN);
- writePinHigh(LED_SCROLL_LOCK_PIN);
- writePinHigh(LED_WIN_LOCK_PIN);
- writePinHigh(LED_MR_LOCK_PIN);
+ gpio_write_pin_high(LED_CAPS_LOCK_PIN);
+ gpio_write_pin_high(LED_SCROLL_LOCK_PIN);
+ gpio_write_pin_high(LED_WIN_LOCK_PIN);
+ gpio_write_pin_high(LED_MR_LOCK_PIN);
}
void on_all_leds(void) {
#ifdef LED_NUM_LOCK_PIN
- writePinLow(LED_NUM_LOCK_PIN);
+ gpio_write_pin_low(LED_NUM_LOCK_PIN);
#endif
- writePinLow(LED_CAPS_LOCK_PIN);
- writePinLow(LED_SCROLL_LOCK_PIN);
- writePinLow(LED_WIN_LOCK_PIN);
- writePinLow(LED_MR_LOCK_PIN);
+ gpio_write_pin_low(LED_CAPS_LOCK_PIN);
+ gpio_write_pin_low(LED_SCROLL_LOCK_PIN);
+ gpio_write_pin_low(LED_WIN_LOCK_PIN);
+ gpio_write_pin_low(LED_MR_LOCK_PIN);
}
/* WinLock and MR LEDs are non-standard. Need to override led init */
void led_init_ports(void) {
#ifdef LED_NUM_LOCK_PIN
- setPinOutput(LED_NUM_LOCK_PIN);
+ gpio_set_pin_output(LED_NUM_LOCK_PIN);
#endif
- setPinOutput(LED_CAPS_LOCK_PIN);
- setPinOutput(LED_SCROLL_LOCK_PIN);
- setPinOutput(LED_WIN_LOCK_PIN);
- setPinOutput(LED_MR_LOCK_PIN);
+ gpio_set_pin_output(LED_CAPS_LOCK_PIN);
+ gpio_set_pin_output(LED_SCROLL_LOCK_PIN);
+ gpio_set_pin_output(LED_WIN_LOCK_PIN);
+ gpio_set_pin_output(LED_MR_LOCK_PIN);
off_all_leds();
}
@@ 58,7 58,7 @@ bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
case GU_TOGG:
if (record->event.pressed) {
// Toggle LED on key press
- togglePin(LED_WIN_LOCK_PIN);
+ gpio_toggle_pin(LED_WIN_LOCK_PIN);
}
break;
}
@@ 75,7 75,7 @@ static void hardware_reset_cb(void *arg) {
#endif
void keyboard_pre_init_kb(void) {
- setPinInputHigh(HARDWARE_RESET_PIN);
+ gpio_set_pin_input_high(HARDWARE_RESET_PIN);
#ifndef HW_RESET_PIN_DISABLED
/* Jump to bootloader when the hardware reset button is pressed */
@@ 83,7 83,7 @@ void keyboard_pre_init_kb(void) {
palSetPadCallback(PAL_PORT(HARDWARE_RESET_PIN), PAL_PAD(HARDWARE_RESET_PIN), hardware_reset_cb, NULL);
/* The interrupt is edge-triggered so check that it's not already pressed */
- if (!readPin(HARDWARE_RESET_PIN)) {
+ if (!gpio_read_pin(HARDWARE_RESET_PIN)) {
bootloader_jump();
}
#endif
M keyboards/durgod/k320/k320.c => keyboards/durgod/k320/k320.c +18 -18
@@ 22,33 22,33 @@
/* Private Functions */
void off_all_leds(void) {
#ifdef LED_NUM_LOCK_PIN
- writePinHigh(LED_NUM_LOCK_PIN);
+ gpio_write_pin_high(LED_NUM_LOCK_PIN);
#endif
- writePinHigh(LED_CAPS_LOCK_PIN);
- writePinHigh(LED_SCROLL_LOCK_PIN);
- writePinHigh(LED_WIN_LOCK_PIN);
- writePinHigh(LED_MR_LOCK_PIN);
+ gpio_write_pin_high(LED_CAPS_LOCK_PIN);
+ gpio_write_pin_high(LED_SCROLL_LOCK_PIN);
+ gpio_write_pin_high(LED_WIN_LOCK_PIN);
+ gpio_write_pin_high(LED_MR_LOCK_PIN);
}
void on_all_leds(void) {
#ifdef LED_NUM_LOCK_PIN
- writePinLow(LED_NUM_LOCK_PIN);
+ gpio_write_pin_low(LED_NUM_LOCK_PIN);
#endif
- writePinLow(LED_CAPS_LOCK_PIN);
- writePinLow(LED_SCROLL_LOCK_PIN);
- writePinLow(LED_WIN_LOCK_PIN);
- writePinLow(LED_MR_LOCK_PIN);
+ gpio_write_pin_low(LED_CAPS_LOCK_PIN);
+ gpio_write_pin_low(LED_SCROLL_LOCK_PIN);
+ gpio_write_pin_low(LED_WIN_LOCK_PIN);
+ gpio_write_pin_low(LED_MR_LOCK_PIN);
}
/* WinLock and MR LEDs are non-standard. Need to override led init */
void led_init_ports(void) {
#ifdef LED_NUM_LOCK_PIN
- setPinOutput(LED_NUM_LOCK_PIN);
+ gpio_set_pin_output(LED_NUM_LOCK_PIN);
#endif
- setPinOutput(LED_CAPS_LOCK_PIN);
- setPinOutput(LED_SCROLL_LOCK_PIN);
- setPinOutput(LED_WIN_LOCK_PIN);
- setPinOutput(LED_MR_LOCK_PIN);
+ gpio_set_pin_output(LED_CAPS_LOCK_PIN);
+ gpio_set_pin_output(LED_SCROLL_LOCK_PIN);
+ gpio_set_pin_output(LED_WIN_LOCK_PIN);
+ gpio_set_pin_output(LED_MR_LOCK_PIN);
off_all_leds();
}
@@ 58,7 58,7 @@ bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
case GU_TOGG:
if (record->event.pressed) {
// Toggle LED on key press
- togglePin(LED_WIN_LOCK_PIN);
+ gpio_toggle_pin(LED_WIN_LOCK_PIN);
}
break;
}
@@ 75,7 75,7 @@ static void hardware_reset_cb(void *arg) {
#endif
void keyboard_pre_init_kb(void) {
- setPinInputHigh(HARDWARE_RESET_PIN);
+ gpio_set_pin_input_high(HARDWARE_RESET_PIN);
#ifndef HW_RESET_PIN_DISABLED
/* Jump to bootloader when the hardware reset button is pressed */
@@ 83,7 83,7 @@ void keyboard_pre_init_kb(void) {
palSetPadCallback(PAL_PORT(HARDWARE_RESET_PIN), PAL_PAD(HARDWARE_RESET_PIN), hardware_reset_cb, NULL);
/* The interrupt is edge-triggered so check that it's not already pressed */
- if (!readPin(HARDWARE_RESET_PIN)) {
+ if (!gpio_read_pin(HARDWARE_RESET_PIN)) {
bootloader_jump();
}
#endif
M keyboards/dztech/bocc/bocc.c => keyboards/dztech/bocc/bocc.c +2 -2
@@ 16,14 16,14 @@
#include "quantum.h"
void matrix_init_kb(void) {
- setPinOutput(E6);
+ gpio_set_pin_output(E6);
matrix_init_user();
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(E6, !led_state.caps_lock);
+ gpio_write_pin(E6, !led_state.caps_lock);
}
return res;
}
M keyboards/ealdin/quadrant/quadrant.c => keyboards/ealdin/quadrant/quadrant.c +2 -2
@@ 54,14 54,14 @@ bool encoder_update_kb(uint8_t index, bool clockwise) {
}
void keyboard_pre_init_kb(void) {
- setPinOutput(F0);
+ gpio_set_pin_output(F0);
keyboard_pre_init_user();
}
bool led_update_kb(led_t led_state) {
if (led_update_user(led_state)) {
- writePin(F0, led_state.caps_lock);
+ gpio_write_pin(F0, led_state.caps_lock);
}
return true;
}
M keyboards/edda/edda.c => keyboards/edda/edda.c +15 -15
@@ 18,32 18,32 @@ void keyboard_pre_init_kb(void) {
keyboard_pre_init_user();
// Set our LED pins as output
- setPinOutput(B2);
- setPinOutput(B1);
- setPinOutput(B0);
+ gpio_set_pin_output(B2);
+ gpio_set_pin_output(B1);
+ gpio_set_pin_output(B0);
}
__attribute__((weak)) layer_state_t layer_state_set_user(layer_state_t state) {
switch (get_highest_layer(state)) {
case 1:
- writePin(B2, 1);
- writePin(B1, 0);
- writePin(B0, 0);
+ gpio_write_pin(B2, 1);
+ gpio_write_pin(B1, 0);
+ gpio_write_pin(B0, 0);
break;
case 2:
- writePin(B2, 1);
- writePin(B1, 1);
- writePin(B0, 0);
+ gpio_write_pin(B2, 1);
+ gpio_write_pin(B1, 1);
+ gpio_write_pin(B0, 0);
break;
case 3:
- writePin(B2, 1);
- writePin(B1, 1);
- writePin(B0, 1);
+ gpio_write_pin(B2, 1);
+ gpio_write_pin(B1, 1);
+ gpio_write_pin(B0, 1);
break;
default: // for any other layers, or the default layer
- writePin(B2, 0);
- writePin(B1, 0);
- writePin(B0, 0);
+ gpio_write_pin(B2, 0);
+ gpio_write_pin(B1, 0);
+ gpio_write_pin(B0, 0);
break;
}
return state;
M keyboards/enviousdesign/commissions/mini1800/mini1800.c => keyboards/enviousdesign/commissions/mini1800/mini1800.c +5 -5
@@ 3,15 3,15 @@
#include "quantum.h"
void matrix_init_user(void) {
- setPinOutput(GP9); //init gpio
- writePinLow(GP9);
- setPinOutput(GP11); //init and turn off inverted power led
- writePinHigh(GP11);
+ gpio_set_pin_output(GP9); //init gpio
+ gpio_write_pin_low(GP9);
+ gpio_set_pin_output(GP11); //init and turn off inverted power led
+ gpio_write_pin_high(GP11);
}
//layer, capslock and numlock
layer_state_t layer_state_set_user(layer_state_t state) {
- writePin(GP9, layer_state_cmp(state, 1));
+ gpio_write_pin(GP9, layer_state_cmp(state, 1));
return state;
}
M keyboards/ergodox_ez/matrix.c => keyboards/ergodox_ez/matrix.c +27 -27
@@ 130,12 130,12 @@ static void init_cols(void) {
// not needed, already done as part of init_mcp23018()
// init on teensy
- setPinInputHigh(F0);
- setPinInputHigh(F1);
- setPinInputHigh(F4);
- setPinInputHigh(F5);
- setPinInputHigh(F6);
- setPinInputHigh(F7);
+ gpio_set_pin_input_high(F0);
+ gpio_set_pin_input_high(F1);
+ gpio_set_pin_input_high(F4);
+ gpio_set_pin_input_high(F5);
+ gpio_set_pin_input_high(F6);
+ gpio_set_pin_input_high(F7);
}
static matrix_row_t read_cols(uint8_t row) {
@@ 176,13 176,13 @@ static void unselect_rows(void) {
// direction
// unselect on teensy
- setPinInput(B0);
- setPinInput(B1);
- setPinInput(B2);
- setPinInput(B3);
- setPinInput(D2);
- setPinInput(D3);
- setPinInput(C6);
+ gpio_set_pin_input(B0);
+ gpio_set_pin_input(B1);
+ gpio_set_pin_input(B2);
+ gpio_set_pin_input(B3);
+ gpio_set_pin_input(D2);
+ gpio_set_pin_input(D3);
+ gpio_set_pin_input(C6);
}
static void select_row(uint8_t row) {
@@ 200,32 200,32 @@ static void select_row(uint8_t row) {
// Output low(DDR:1, PORT:0) to select
switch (row) {
case 7:
- setPinOutput(B0);
- writePinLow(B0);
+ gpio_set_pin_output(B0);
+ gpio_write_pin_low(B0);
break;
case 8:
- setPinOutput(B1);
- writePinLow(B1);
+ gpio_set_pin_output(B1);
+ gpio_write_pin_low(B1);
break;
case 9:
- setPinOutput(B2);
- writePinLow(B2);
+ gpio_set_pin_output(B2);
+ gpio_write_pin_low(B2);
break;
case 10:
- setPinOutput(B3);
- writePinLow(B3);
+ gpio_set_pin_output(B3);
+ gpio_write_pin_low(B3);
break;
case 11:
- setPinOutput(D2);
- writePinLow(D2);
+ gpio_set_pin_output(D2);
+ gpio_write_pin_low(D2);
break;
case 12:
- setPinOutput(D3);
- writePinLow(D3);
+ gpio_set_pin_output(D3);
+ gpio_write_pin_low(D3);
break;
case 13:
- setPinOutput(C6);
- writePinLow(C6);
+ gpio_set_pin_output(C6);
+ gpio_write_pin_low(C6);
break;
}
}
M keyboards/evyd13/gh80_3700/gh80_3700.c => keyboards/evyd13/gh80_3700/gh80_3700.c +11 -11
@@ 16,22 16,22 @@
#include "quantum.h"
void led_init_ports(void) {
- setPinOutput(E6);
- setPinOutput(B1);
- setPinOutput(D0);
- setPinOutput(D1);
- setPinOutput(F0);
+ gpio_set_pin_output(E6);
+ gpio_set_pin_output(B1);
+ gpio_set_pin_output(D0);
+ gpio_set_pin_output(D1);
+ gpio_set_pin_output(F0);
- writePinHigh(E6);
- writePinHigh(B1);
- writePinHigh(D0);
- writePinHigh(D1);
- writePinHigh(F0);
+ gpio_write_pin_high(E6);
+ gpio_write_pin_high(B1);
+ gpio_write_pin_high(D0);
+ gpio_write_pin_high(D1);
+ gpio_write_pin_high(F0);
}
bool led_update_kb(led_t led_state) {
if(led_update_user(led_state)) {
- writePin(E6, !led_state.num_lock);
+ gpio_write_pin(E6, !led_state.num_lock);
}
return true;
M keyboards/evyd13/gud70/gud70.c => keyboards/evyd13/gud70/gud70.c +2 -2
@@ 17,6 17,6 @@
void keyboard_pre_init_kb(void) {
// Enable top LED
- setPinOutput(B3);
- writePinLow(B3);
+ gpio_set_pin_output(B3);
+ gpio_write_pin_low(B3);
}
M keyboards/evyd13/pockettype/pockettype.c => keyboards/evyd13/pockettype/pockettype.c +7 -7
@@ 17,20 17,20 @@
void led_init_ports(void) {
// * Enable LED anodes (Vbus pin is replaced by B0 on some boards)
- setPinOutput(B0);
- writePinHigh(B0);
+ gpio_set_pin_output(B0);
+ gpio_write_pin_high(B0);
// * Set our LED pins as output and high
- setPinOutput(F5);
- writePinHigh(F5);
+ gpio_set_pin_output(F5);
+ gpio_write_pin_high(F5);
- setPinOutput(F4);
- writePinLow(F4);
+ gpio_set_pin_output(F4);
+ gpio_write_pin_low(F4);
}
bool led_update_kb(led_t led_state) {
if(led_update_user(led_state)) {
- writePin(F5, !led_state.caps_lock);
+ gpio_write_pin(F5, !led_state.caps_lock);
}
return true;
M keyboards/evyd13/wasdat/matrix.c => keyboards/evyd13/wasdat/matrix.c +7 -7
@@ 46,7 46,7 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
*/
static void select_col(uint8_t col) {
if (col_pins[col] != NO_PIN) {
- writePinLow(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
} else {
sn74x138_set_addr(13 - col);
}
@@ 54,8 54,8 @@ static void select_col(uint8_t col) {
static void unselect_col(uint8_t col) {
if (col_pins[col] != NO_PIN) {
- setPinOutput(col_pins[col]);
- writePinHigh(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_high(col_pins[col]);
} else {
sn74x138_set_addr(0);
}
@@ 65,8 65,8 @@ static void unselect_cols(void) {
// Native
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
if (col_pins[x] != NO_PIN) {
- setPinOutput(col_pins[x]);
- writePinHigh(col_pins[x]);
+ gpio_set_pin_output(col_pins[x]);
+ gpio_write_pin_high(col_pins[x]);
}
}
@@ 77,7 77,7 @@ static void unselect_cols(void) {
static void init_pins(void) {
unselect_cols();
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
@@ 94,7 94,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0) {
+ if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_matrix[row_index] |= (MATRIX_ROW_SHIFTER << current_col);
} else {
M keyboards/evyd13/wasdat_code/matrix.c => keyboards/evyd13/wasdat_code/matrix.c +7 -7
@@ 48,7 48,7 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
*/
static void select_col(uint8_t col) {
if (col_pins[col] != NO_PIN) {
- writePinLow(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
} else {
sn74x138_set_addr((col == 6) ? 7 : 15 - col);
sn74x138_set_enabled(true);
@@ 57,8 57,8 @@ static void select_col(uint8_t col) {
static void unselect_col(uint8_t col) {
if (col_pins[col] != NO_PIN) {
- setPinOutput(col_pins[col]);
- writePinHigh(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_high(col_pins[col]);
} else {
sn74x138_set_enabled(false);
}
@@ 68,8 68,8 @@ static void unselect_cols(void) {
// Native
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
if (col_pins[x] != NO_PIN) {
- setPinOutput(col_pins[x]);
- writePinHigh(col_pins[x]);
+ gpio_set_pin_output(col_pins[x]);
+ gpio_write_pin_high(col_pins[x]);
}
}
@@ 80,7 80,7 @@ static void unselect_cols(void) {
static void init_pins(void) {
unselect_cols();
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
@@ 97,7 97,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0) {
+ if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_matrix[row_index] |= (MATRIX_ROW_SHIFTER << current_col);
} else {
M keyboards/exclusive/e6v2/oe/oe.c => keyboards/exclusive/e6v2/oe/oe.c +4 -4
@@ 1,15 1,15 @@
#include "quantum.h"
void led_init_ports(void) {
- setPinOutput(B2);
- setPinOutput(B6);
+ gpio_set_pin_output(B2);
+ gpio_set_pin_output(B6);
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(B2, !led_state.caps_lock);
- writePin(B6, led_state.raw == 0);
+ gpio_write_pin(B2, !led_state.caps_lock);
+ gpio_write_pin(B6, led_state.raw == 0);
}
return res;
}
M keyboards/exclusive/e85/hotswap/hotswap.c => keyboards/exclusive/e85/hotswap/hotswap.c +4 -4
@@ 17,16 17,16 @@
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(C7);
- setPinOutput(B5);
+ gpio_set_pin_output(C7);
+ gpio_set_pin_output(B5);
keyboard_pre_init_user();
}
bool led_update_kb(led_t led_state) {
if (led_update_user(led_state)) {
- writePin(C7, led_state.caps_lock);
- writePin(B5, led_state.scroll_lock);
+ gpio_write_pin(C7, led_state.caps_lock);
+ gpio_write_pin(B5, led_state.scroll_lock);
}
return true;
}
M keyboards/exclusive/e85/soldered/soldered.c => keyboards/exclusive/e85/soldered/soldered.c +4 -4
@@ 17,16 17,16 @@
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(C7);
- setPinOutput(B5);
+ gpio_set_pin_output(C7);
+ gpio_set_pin_output(B5);
keyboard_pre_init_user();
}
bool led_update_kb(led_t led_state) {
if (led_update_user(led_state)) {
- writePin(C7, led_state.caps_lock);
- writePin(B5, led_state.scroll_lock);
+ gpio_write_pin(C7, led_state.caps_lock);
+ gpio_write_pin(B5, led_state.scroll_lock);
}
return true;
}
M keyboards/ferris/0_1/matrix.c => keyboards/ferris/0_1/matrix.c +7 -7
@@ 182,8 182,8 @@ static void init_cols(void) {
pin_t matrix_col_pins_mcu[MATRIX_COLS_PER_SIDE] = MATRIX_COL_PINS_MCU;
for (int pin_index = 0; pin_index < MATRIX_COLS_PER_SIDE; pin_index++) {
pin_t pin = matrix_col_pins_mcu[pin_index];
- setPinInput(pin);
- writePinHigh(pin);
+ gpio_set_pin_input(pin);
+ gpio_write_pin_high(pin);
}
}
@@ 194,7 194,7 @@ static matrix_row_t read_cols(uint8_t row) {
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS_PER_SIDE; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(matrix_col_pins_mcu[col_index]);
+ uint8_t pin_state = gpio_read_pin(matrix_col_pins_mcu[col_index]);
// Populate the matrix row with the state of the col pin
current_row_value |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
@@ 229,8 229,8 @@ static void unselect_rows(void) {
pin_t matrix_row_pins_mcu[MATRIX_ROWS_PER_SIDE] = MATRIX_ROW_PINS_MCU;
for (int pin_index = 0; pin_index < MATRIX_ROWS_PER_SIDE; pin_index++) {
pin_t pin = matrix_row_pins_mcu[pin_index];
- setPinInput(pin);
- writePinLow(pin);
+ gpio_set_pin_input(pin);
+ gpio_write_pin_low(pin);
}
}
@@ 239,8 239,8 @@ static void select_row(uint8_t row) {
// select on atmega32u4
pin_t matrix_row_pins_mcu[MATRIX_ROWS_PER_SIDE] = MATRIX_ROW_PINS_MCU;
pin_t pin = matrix_row_pins_mcu[row];
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
} else {
// select on mcp23017
if (mcp23017_status) { // if there was an error
M keyboards/ferris/0_2/matrix.c => keyboards/ferris/0_2/matrix.c +6 -6
@@ 173,7 173,7 @@ static matrix_row_t read_cols(uint8_t row) {
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS_PER_SIDE; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(matrix_col_pins_mcu[col_index]);
+ uint8_t pin_state = gpio_read_pin(matrix_col_pins_mcu[col_index]);
// Populate the matrix row with the state of the col pin
current_row_value |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
@@ 199,7 199,7 @@ static matrix_row_t read_cols(uint8_t row) {
static void unselect_row(uint8_t row) {
pin_t matrix_row_pins_mcu[MATRIX_ROWS_PER_SIDE] = MATRIX_ROW_PINS_MCU;
- setPinInputHigh(matrix_row_pins_mcu[row]);
+ gpio_set_pin_input_high(matrix_row_pins_mcu[row]);
}
static void unselect_rows(void) {
@@ 211,14 211,14 @@ static void unselect_rows(void) {
pin_t matrix_row_pins_mcu[MATRIX_ROWS_PER_SIDE] = MATRIX_ROW_PINS_MCU;
for (int pin_index = 0; pin_index < MATRIX_ROWS_PER_SIDE; pin_index++) {
pin_t pin = matrix_row_pins_mcu[pin_index];
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
static void unselect_cols(void) {
pin_t matrix_col_pins_mcu[MATRIX_COLS_PER_SIDE] = MATRIX_COL_PINS_MCU;
for (int pin_index = 0; pin_index < MATRIX_COLS_PER_SIDE; pin_index++) {
pin_t pin = matrix_col_pins_mcu[pin_index];
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
@@ 227,8 227,8 @@ static void select_row(uint8_t row) {
// select on MCU
pin_t matrix_row_pins_mcu[MATRIX_ROWS_PER_SIDE] = MATRIX_ROW_PINS_MCU;
pin_t pin = matrix_row_pins_mcu[row];
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
} else {
// select on mcp23017
if (mcp23017_status) { // if there was an error
M keyboards/fjlabs/bolsa65/bolsa65.c => keyboards/fjlabs/bolsa65/bolsa65.c +2 -2
@@ 15,14 15,14 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
void matrix_init_kb(void) {
// Initialize indicator LEDs to output
- setPinOutput(F7); // Caps
+ gpio_set_pin_output(F7); // Caps
matrix_init_user();
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(F7, led_state.caps_lock);
+ gpio_write_pin(F7, led_state.caps_lock);
}
return res;
}
M keyboards/flx/virgo/virgo.c => keyboards/flx/virgo/virgo.c +4 -4
@@ 20,15 20,15 @@ void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
- setPinOutput(E6);
- setPinOutput(B2);
+ gpio_set_pin_output(E6);
+ gpio_set_pin_output(B2);
matrix_init_user();
}
bool led_update_kb(led_t led_state) {
if(led_update_user(led_state)) {
- writePin(E6, !led_state.caps_lock);
- writePin(B2, !led_state.scroll_lock);
+ gpio_write_pin(E6, !led_state.caps_lock);
+ gpio_write_pin(B2, !led_state.scroll_lock);
}
return true;
}
M keyboards/gboards/gergoplex/matrix.c => keyboards/gboards/gergoplex/matrix.c +5 -5
@@ 168,7 168,7 @@ void matrix_print(void) {
// Remember this means ROWS
static void init_cols(void) {
for (uint8_t col = 0; col < MATRIX_COLS; col++) {
- setPinInputHigh(col_pins[col]);
+ gpio_set_pin_input_high(col_pins[col]);
}
}
@@ 195,8 195,8 @@ static void unselect_rows(void) {
// the other row bits high, and it's not changing to a different direction
for (uint8_t row = 0; row < MATRIX_ROWS_PER_SIDE; row++) {
- setPinInput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_input(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
}
@@ 211,7 211,7 @@ static void select_row(uint8_t row) {
}
} else {
- setPinOutput(row_pins[row - MATRIX_ROWS_PER_SIDE]);
- writePinLow(row_pins[row - MATRIX_ROWS_PER_SIDE]);
+ gpio_set_pin_output(row_pins[row - MATRIX_ROWS_PER_SIDE]);
+ gpio_write_pin_low(row_pins[row - MATRIX_ROWS_PER_SIDE]);
}
}
M keyboards/geistmaschine/macropod/matrix.c => keyboards/geistmaschine/macropod/matrix.c +2 -2
@@ 38,7 38,7 @@ void pca9555_setup(void) {
void matrix_init_custom(void) {
// Encoder pushbutton on the MCU is connected to PD2
- setPinInputHigh(D2);
+ gpio_set_pin_input_high(D2);
pca9555_setup();
}
@@ 79,7 79,7 @@ bool matrix_scan_custom(matrix_row_t current_matrix[]) {
}
// Shift pin states by 1 to make room for the switch connected to the MCU, then OR them together and invert (as QMK uses inverted logic compared to the electrical levels)
- matrix_row_t data = ~(pin_states << 1 | readPin(D2));
+ matrix_row_t data = ~(pin_states << 1 | gpio_read_pin(D2));
bool changed = current_matrix[0] != data;
current_matrix[0] = data;
M keyboards/geonworks/ee_at/ee_at.c => keyboards/geonworks/ee_at/ee_at.c +6 -6
@@ 17,14 17,14 @@
void led_init_ports(void) {
// Set our LED pins as open drain outputs
- setPinOutputOpenDrain(LED_CAPS_LOCK_PIN);
- setPinOutputOpenDrain(LED_NUM_LOCK_PIN);
- setPinOutputOpenDrain(LED_SCROLL_LOCK_PIN);
- setPinOutputOpenDrain(LED_KANA_PIN);
- setPinOutputOpenDrain(A14);
+ gpio_set_pin_output_open_drain(LED_CAPS_LOCK_PIN);
+ gpio_set_pin_output_open_drain(LED_NUM_LOCK_PIN);
+ gpio_set_pin_output_open_drain(LED_SCROLL_LOCK_PIN);
+ gpio_set_pin_output_open_drain(LED_KANA_PIN);
+ gpio_set_pin_output_open_drain(A14);
}
layer_state_t layer_state_set_kb(layer_state_t state) {
- writePin(A14, !layer_state_cmp(state, 1));
+ gpio_write_pin(A14, !layer_state_cmp(state, 1));
return layer_state_set_user(state);
}
M keyboards/geonworks/w1_at/w1_at.c => keyboards/geonworks/w1_at/w1_at.c +6 -6
@@ 17,14 17,14 @@
void led_init_ports(void) {
// Set our LED pins as open drain outputs
- setPinOutputOpenDrain(LED_CAPS_LOCK_PIN);
- setPinOutputOpenDrain(LED_NUM_LOCK_PIN);
- setPinOutputOpenDrain(LED_SCROLL_LOCK_PIN);
- setPinOutputOpenDrain(LED_KANA_PIN);
- setPinOutputOpenDrain(A14);
+ gpio_set_pin_output_open_drain(LED_CAPS_LOCK_PIN);
+ gpio_set_pin_output_open_drain(LED_NUM_LOCK_PIN);
+ gpio_set_pin_output_open_drain(LED_SCROLL_LOCK_PIN);
+ gpio_set_pin_output_open_drain(LED_KANA_PIN);
+ gpio_set_pin_output_open_drain(A14);
}
layer_state_t layer_state_set_kb(layer_state_t state) {
- writePin(A14, !layer_state_cmp(state, 1));
+ gpio_write_pin(A14, !layer_state_cmp(state, 1));
return layer_state_set_user(state);
}
M keyboards/gh60/revc/revc.h => keyboards/gh60/revc/revc.h +10 -10
@@ 12,14 12,14 @@
* B2 Capslock LED
* B0 not connected
*/
-static inline void gh60_caps_led_on(void) { setPinOutput(B2); writePinLow(B2); }
-static inline void gh60_poker_leds_on(void) { setPinOutput(F4); writePinLow(F4); }
-static inline void gh60_fn_led_on(void) { setPinOutput(F5); writePinLow(F5); }
-static inline void gh60_esc_led_on(void) { setPinOutput(F6); writePinLow(F6); }
-static inline void gh60_wasd_leds_on(void) { setPinOutput(F7); writePinLow(F7); }
+static inline void gh60_caps_led_on(void) { gpio_set_pin_output(B2); gpio_write_pin_low(B2); }
+static inline void gh60_poker_leds_on(void) { gpio_set_pin_output(F4); gpio_write_pin_low(F4); }
+static inline void gh60_fn_led_on(void) { gpio_set_pin_output(F5); gpio_write_pin_low(F5); }
+static inline void gh60_esc_led_on(void) { gpio_set_pin_output(F6); gpio_write_pin_low(F6); }
+static inline void gh60_wasd_leds_on(void) { gpio_set_pin_output(F7); gpio_write_pin_low(F7); }
-static inline void gh60_caps_led_off(void) { setPinInput(B2); }
-static inline void gh60_poker_leds_off(void) { setPinInput(F4); }
-static inline void gh60_fn_led_off(void) { setPinInput(F5); }
-static inline void gh60_esc_led_off(void) { setPinInput(F6); }
-static inline void gh60_wasd_leds_off(void) { setPinInput(F7); }
+static inline void gh60_caps_led_off(void) { gpio_set_pin_input(B2); }
+static inline void gh60_poker_leds_off(void) { gpio_set_pin_input(F4); }
+static inline void gh60_fn_led_off(void) { gpio_set_pin_input(F5); }
+static inline void gh60_esc_led_off(void) { gpio_set_pin_input(F6); }
+static inline void gh60_wasd_leds_off(void) { gpio_set_pin_input(F7); }
M keyboards/ghs/rar/rar.c => keyboards/ghs/rar/rar.c +4 -4
@@ 18,8 18,8 @@
void keyboard_pre_init_kb(void) {
// Set our LED pins as output.
- setPinOutput(B1);
- setPinOutput(B3);
+ gpio_set_pin_output(B1);
+ gpio_set_pin_output(B3);
keyboard_pre_init_user();
}
@@ 28,8 28,8 @@ bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if (res) {
- writePin(B1, led_state.caps_lock);
- writePin(B3, led_state.scroll_lock);
+ gpio_write_pin(B1, led_state.caps_lock);
+ gpio_write_pin(B3, led_state.scroll_lock);
}
return res;
M keyboards/gl516/a52gl/matrix.c => keyboards/gl516/a52gl/matrix.c +12 -12
@@ 21,37 21,37 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static void select_row(uint8_t row)
{
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row)
{
- setPinInputHigh(row_pins[row]);
+ gpio_set_pin_input_high(row_pins[row]);
}
static void unselect_rows(void)
{
for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void select_col(uint8_t col)
{
- setPinOutput(col_pins[col]);
- writePinLow(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
- setPinInputHigh(col_pins[col]);
+ gpio_set_pin_input_high(col_pins[col]);
}
static void unselect_cols(void)
{
for(uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 59,10 59,10 @@ static void init_pins(void) {
unselect_rows();
unselect_cols();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
@@ 82,7 82,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
@@ 110,7 110,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[tmp];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0)
+ if (gpio_read_pin(row_pins[row_index]) == 0)
{
// Pin LO, set col bit
current_matrix[tmp] |= (MATRIX_ROW_SHIFTER << current_col);
M keyboards/gl516/j73gl/matrix.c => keyboards/gl516/j73gl/matrix.c +12 -12
@@ 21,37 21,37 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static void select_row(uint8_t row)
{
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row)
{
- setPinInputHigh(row_pins[row]);
+ gpio_set_pin_input_high(row_pins[row]);
}
static void unselect_rows(void)
{
for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void select_col(uint8_t col)
{
- setPinOutput(col_pins[col]);
- writePinLow(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
- setPinInputHigh(col_pins[col]);
+ gpio_set_pin_input_high(col_pins[col]);
}
static void unselect_cols(void)
{
for(uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 59,10 59,10 @@ static void init_pins(void) {
unselect_rows();
unselect_cols();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
@@ 82,7 82,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
@@ 110,7 110,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[tmp];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0)
+ if (gpio_read_pin(row_pins[row_index]) == 0)
{
// Pin LO, set col bit
current_matrix[tmp] |= (MATRIX_ROW_SHIFTER << current_col);
M keyboards/gl516/n51gl/matrix.c => keyboards/gl516/n51gl/matrix.c +12 -12
@@ 21,37 21,37 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static void select_row(uint8_t row)
{
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row)
{
- setPinInputHigh(row_pins[row]);
+ gpio_set_pin_input_high(row_pins[row]);
}
static void unselect_rows(void)
{
for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void select_col(uint8_t col)
{
- setPinOutput(col_pins[col]);
- writePinLow(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
- setPinInputHigh(col_pins[col]);
+ gpio_set_pin_input_high(col_pins[col]);
}
static void unselect_cols(void)
{
for(uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 59,10 59,10 @@ static void init_pins(void) {
unselect_rows();
unselect_cols();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
@@ 82,7 82,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
@@ 110,7 110,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[tmp];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0)
+ if (gpio_read_pin(row_pins[row_index]) == 0)
{
// Pin LO, set col bit
current_matrix[tmp] |= (MATRIX_ROW_SHIFTER << current_col);
M keyboards/glenpickle/chimera_ortho_plus/chimera_ortho_plus.c => keyboards/glenpickle/chimera_ortho_plus/chimera_ortho_plus.c +0 -1
@@ 9,7 9,6 @@ void led_init(void) {
gpio_write_pin_high(CHIMERA_ORTHO_PLUS_RED_LED_PIN);
}
-
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
M keyboards/gmmk/gmmk2/p96/ansi/ansi.c => keyboards/gmmk/gmmk2/p96/ansi/ansi.c +3 -3
@@ 317,9 317,9 @@ void spi_init(void) {
is_initialised = true;
// Try releasing special pins for a short time
- setPinInput(SPI_SCK_PIN);
- setPinInput(SPI_MOSI_PIN);
- setPinInput(SPI_MISO_PIN);
+ gpio_set_pin_input(SPI_SCK_PIN);
+ gpio_set_pin_input(SPI_MOSI_PIN);
+ gpio_set_pin_input(SPI_MISO_PIN);
chThdSleepMilliseconds(10);
M keyboards/gmmk/gmmk2/p96/iso/iso.c => keyboards/gmmk/gmmk2/p96/iso/iso.c +3 -3
@@ 313,9 313,9 @@ void spi_init(void) {
is_initialised = true;
// Try releasing special pins for a short time
- setPinInput(SPI_SCK_PIN);
- setPinInput(SPI_MOSI_PIN);
- setPinInput(SPI_MISO_PIN);
+ gpio_set_pin_input(SPI_SCK_PIN);
+ gpio_set_pin_input(SPI_MOSI_PIN);
+ gpio_set_pin_input(SPI_MISO_PIN);
chThdSleepMilliseconds(10);
M keyboards/gmmk/numpad/matrix.c => keyboards/gmmk/numpad/matrix.c +6 -6
@@ 21,27 21,27 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinOutput_writeHigh(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinHigh(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_high(pin);
}
}
static inline void setPinInputHigh_atomic(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
static inline uint8_t readMatrixPin(pin_t pin) {
if (pin != NO_PIN) {
- return readPin(pin);
+ return gpio_read_pin(pin);
} else {
return 1;
}
M keyboards/gmmk/numpad/numpad.c => keyboards/gmmk/numpad/numpad.c +2 -2
@@ 111,8 111,8 @@ led_config_t g_led_config = {{
void keyboard_pre_init_user(void) {
wait_ms(2000);
- setPinOutput(AW20216S_PW_EN_PIN);
- writePinHigh(AW20216S_PW_EN_PIN);
+ gpio_set_pin_output(AW20216S_PW_EN_PIN);
+ gpio_write_pin_high(AW20216S_PW_EN_PIN);
}
# endif
M keyboards/gray_studio/think65/solder/solder.c => keyboards/gray_studio/think65/solder/solder.c +2 -2
@@ 24,13 24,13 @@ void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
- setPinOutput(C7);
+ gpio_set_pin_output(C7);
matrix_init_user();
}
bool led_update_kb(led_t led_state) {
if(led_update_user(led_state)) {
- writePin(C7, !led_state.caps_lock);
+ gpio_write_pin(C7, !led_state.caps_lock);
}
return true;
}
M keyboards/halfcliff/matrix.c => keyboards/halfcliff/matrix.c +5 -5
@@ 52,13 52,13 @@ void matrix_print(void) {}
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinInputHigh_atomic(pin_t pin) {
- ATOMIC_BLOCK_FORCEON { setPinInputHigh(pin); }
+ ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); }
}
// matrix code
@@ 83,7 83,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_row_value |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
@@ 138,7 138,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t current_row_value = last_row_value;
// Check row pin state
- if (readPin(row_pins[row_index]) == 0) {
+ if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_row_value |= (MATRIX_ROW_SHIFTER << current_col);
} else {
M keyboards/handwired/2x5keypad/2x5keypad.c => keyboards/handwired/2x5keypad/2x5keypad.c +7 -7
@@ 5,21 5,21 @@ void matrix_init_kb(void)
{
matrix_init_user();
- setPinOutput(RED_LED);
- setPinOutput(BLUE_LED);
- setPinOutput(GREEN_LED);
+ gpio_set_pin_output(RED_LED);
+ gpio_set_pin_output(BLUE_LED);
+ gpio_set_pin_output(GREEN_LED);
}
void turn_off_leds(void)
{
- writePinLow(RED_LED);
- writePinLow(BLUE_LED);
- writePinLow(GREEN_LED);
+ gpio_write_pin_low(RED_LED);
+ gpio_write_pin_low(BLUE_LED);
+ gpio_write_pin_low(GREEN_LED);
}
void turn_on_led(pin_t pin)
{
- writePinHigh(pin);
+ gpio_write_pin_high(pin);
}
M keyboards/handwired/aek64/aek64.c => keyboards/handwired/aek64/aek64.c +3 -3
@@ 24,13 24,13 @@ void keyboard_pre_init_user(void) {
// Call the keyboard pre init code.
// Set our LED pins as output
- setPinOutput(C3);
+ gpio_set_pin_output(C3);
}
void matrix_init_kb(void) {
// Flash the led 1 sec on startup.
- writePinHigh(C3);
+ gpio_write_pin_high(C3);
wait_ms(1000);
- writePinLow(C3);
+ gpio_write_pin_low(C3);
}
M keyboards/handwired/battleship_gamepad/battleship_gamepad.c => keyboards/handwired/battleship_gamepad/battleship_gamepad.c +1 -1
@@ 24,5 24,5 @@ joystick_config_t joystick_axes[JOYSTICK_AXIS_COUNT] = {
/* joystick button code (thumbstick pressed) */
void keyboard_pre_init_kb(void) {
- setPinInputHigh(F6);
+ gpio_set_pin_input_high(F6);
}
M keyboards/handwired/colorlice/colorlice.c => keyboards/handwired/colorlice/colorlice.c +4 -4
@@ 55,14 55,14 @@ void suspend_wakeup_init_kb(void)
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- // writePin sets the pin high for 1 and low for 0.
+ // gpio_write_pin sets the pin high for 1 and low for 0.
// In this example the pins are inverted, setting
// it low/0 turns it on, and high/1 turns the LED off.
// This behavior depends on whether the LED is between the pin
// and VCC or the pin and GND.
- writePin(B2, !led_state.num_lock);
- writePin(C6, !led_state.caps_lock);
- writePin(B7, !led_state.scroll_lock);
+ gpio_write_pin(B2, !led_state.num_lock);
+ gpio_write_pin(C6, !led_state.caps_lock);
+ gpio_write_pin(B7, !led_state.scroll_lock);
}
return res;
}
M keyboards/handwired/dqz11n1g/matrix.c => keyboards/handwired/dqz11n1g/matrix.c +6 -6
@@ 25,7 25,7 @@ static void unselect_rows(void);
void matrix_init_custom(void) {
/* initialize row pins */
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
- setPinOutput(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
}
unselect_rows();
@@ 47,20 47,20 @@ void matrix_init_custom(void) {
spi_start(slavePin, lsbFirst, mode, divisor);
/* Initialize pin controlling the shift register's SH/~LD pin */
- setPinOutput(ROW_SHIFT_PIN);
+ gpio_set_pin_output(ROW_SHIFT_PIN);
}
static void select_row(uint8_t row) {
pin_t pin = row_pins[row];
if (pin != NO_PIN) {
- writePinHigh(pin);
+ gpio_write_pin_high(pin);
}
}
static void unselect_row(uint8_t row) {
pin_t pin = row_pins[row];
if (pin != NO_PIN) {
- writePinLow(pin);
+ gpio_write_pin_low(pin);
}
}
@@ 75,12 75,12 @@ bool matrix_read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
matrix_row_t current_row_value = 0;
/* Set shift register SH/~LD pin to "load" mode */
- writePinLow(ROW_SHIFT_PIN);
+ gpio_write_pin_low(ROW_SHIFT_PIN);
select_row(current_row);
matrix_output_select_delay();
/* Set shift register SH/~LD pin to "shift" mode */
- writePinHigh(ROW_SHIFT_PIN);
+ gpio_write_pin_high(ROW_SHIFT_PIN);
/* For each octet of columns... */
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index += 8) {
M keyboards/handwired/evk/v1_3/v1_3.c => keyboards/handwired/evk/v1_3/v1_3.c +4 -4
@@ 23,22 23,22 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// runs once when the firmware starts up
void matrix_init_kb(void) {
// Set the LEDs pins
- setPinOutput(D5); // Layer 1 Status LED
+ gpio_set_pin_output(D5); // Layer 1 Status LED
matrix_init_user();
}
// Set LED based on layer
__attribute__((weak)) layer_state_t layer_state_set_user(layer_state_t state) {
- writePin(D5, layer_state_cmp(state, 1));
+ gpio_write_pin(D5, layer_state_cmp(state, 1));
return state;
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if (res) {
- // writePin sets the pin high for 1 and low for 0.
- writePin(D4, led_state.caps_lock);
+ // gpio_write_pin sets the pin high for 1 and low for 0.
+ gpio_write_pin(D4, led_state.caps_lock);
}
return res;
}
M keyboards/handwired/jopr/jopr.c => keyboards/handwired/jopr/jopr.c +3 -3
@@ 1,7 1,7 @@
#include "quantum.h"
void led_init_ports(void) {
- setPinOutput(F0);
- setPinOutput(F1);
- setPinOutput(F4);
+ gpio_set_pin_output(F0);
+ gpio_set_pin_output(F1);
+ gpio_set_pin_output(F4);
}=
\ No newline at end of file
M keyboards/handwired/jotanck/jotanck.c => keyboards/handwired/jotanck/jotanck.c +2 -2
@@ 17,8 17,8 @@
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(JOTANCK_LED1);
- setPinOutput(JOTANCK_LED2);
+ gpio_set_pin_output(JOTANCK_LED1);
+ gpio_set_pin_output(JOTANCK_LED2);
keyboard_pre_init_user();
}
M keyboards/handwired/jotpad16/jotpad16.c => keyboards/handwired/jotpad16/jotpad16.c +2 -2
@@ 1,8 1,8 @@
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(JOTPAD16_LED1);
- setPinOutput(JOTPAD16_LED2);
+ gpio_set_pin_output(JOTPAD16_LED1);
+ gpio_set_pin_output(JOTPAD16_LED2);
keyboard_pre_init_user();
}
M keyboards/handwired/jtallbean/split_65/split_65.c => keyboards/handwired/jtallbean/split_65/split_65.c +4 -4
@@ 25,8 25,8 @@ void matrix_init_kb(void) {
// runs once when the firmware starts up
// Set our LED pins as output
- setPinOutput(B0);
- writePinLow(B0);
+ gpio_set_pin_output(B0);
+ gpio_write_pin_low(B0);
matrix_init_user();
}
@@ 36,8 36,8 @@ bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- // writePin sets the pin high for 1 and low for 0.
- writePin(B0, led_state.caps_lock);
+ // gpio_write_pin sets the pin high for 1 and low for 0.
+ gpio_write_pin(B0, led_state.caps_lock);
}
return res;
}
M keyboards/handwired/lagrange/lagrange.c => keyboards/handwired/lagrange/lagrange.c +2 -2
@@ 35,7 35,7 @@ bool is_keyboard_master(void) {
static int8_t is_master = -1;
if (is_master < 0) {
- while (readPin(SPI_SS_PIN)) {
+ while (gpio_read_pin(SPI_SS_PIN)) {
if (USB_Device_IsAddressSet()) {
is_master = 1;
return is_master;
@@ 53,7 53,7 @@ bool is_keyboard_master(void) {
}
void keyboard_pre_init_kb(void) {
- setPinInputHigh(SPI_SS_PIN);
+ gpio_set_pin_input_high(SPI_SS_PIN);
keyboard_pre_init_user();
}
M keyboards/handwired/lagrange/transport.c => keyboards/handwired/lagrange/transport.c +8 -8
@@ 53,7 53,7 @@ bool shake_hands(bool master) {
* alignment. */
if (master) {
- writePinLow(SPI_SS_PIN);
+ gpio_write_pin_low(SPI_SS_PIN);
}
for (i = 0 ; i < 8 ; i += 1) {
@@ 64,7 64,7 @@ bool shake_hands(bool master) {
}
if (master) {
- writePinHigh(SPI_SS_PIN);
+ gpio_write_pin_high(SPI_SS_PIN);
}
} while (i < 8);
@@ 176,8 176,8 @@ void transport_master_init(void) {
* above depends on it and the SPI master driver won't do it
* before we call spi_start(). */
- writePinHigh(SPI_SS_PIN);
- setPinOutput(SPI_SS_PIN);
+ gpio_write_pin_high(SPI_SS_PIN);
+ gpio_set_pin_output(SPI_SS_PIN);
spi_init();
@@ 195,10 195,10 @@ void transport_slave_init(void) {
* they're asserted making the MISO pin an output on both ends and
* leading to potential shorts. */
- setPinInputHigh(SPI_SS_PIN);
- setPinInput(SPI_SCK_PIN);
- setPinInput(SPI_MOSI_PIN);
- setPinOutput(SPI_MISO_PIN);
+ gpio_set_pin_input_high(SPI_SS_PIN);
+ gpio_set_pin_input(SPI_SCK_PIN);
+ gpio_set_pin_input(SPI_MOSI_PIN);
+ gpio_set_pin_output(SPI_MISO_PIN);
SPCR = _BV(SPE);
M keyboards/handwired/owlet60/matrix.c => keyboards/handwired/owlet60/matrix.c +18 -18
@@ 129,19 129,19 @@ void matrix_print(void)
// uses standard row code
static void select_row(uint8_t row)
{
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row)
{
- setPinInputHigh(row_pins[row]);
+ gpio_set_pin_input_high(row_pins[row]);
}
static void unselect_rows(void)
{
for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
@@ 149,10 149,10 @@ static void init_pins(void) { // still need some fixing, this might not work
unselect_rows(); // with the loop
/*
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
*/
- setPinInputHigh(dat_pin);
+ gpio_set_pin_input_high(dat_pin);
}
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
@@ 173,7 173,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
// Select the col pin to read (active low)
select_col_analog(col_index);
wait_us(30);
- uint8_t pin_state = readPin(dat_pin);
+ uint8_t pin_state = gpio_read_pin(dat_pin);
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index);
@@ 201,8 201,8 @@ void matrix_init(void) {
matrix_init_kb();
- setPinInput(D5);
- setPinInput(B0);
+ gpio_set_pin_input(D5);
+ gpio_set_pin_input(B0);
}
// modified for per col read matrix scan
@@ 273,27 273,27 @@ static void select_col_analog(uint8_t col) {
static void mux_pin_control(const uint8_t binary[]) {
// set pin0
- setPinOutput(col_select_pins[0]);
+ gpio_set_pin_output(col_select_pins[0]);
if(binary[2] == 0) {
- writePinLow(col_select_pins[0]);
+ gpio_write_pin_low(col_select_pins[0]);
}
else {
- writePinHigh(col_select_pins[0]);
+ gpio_write_pin_high(col_select_pins[0]);
}
// set pin1
- setPinOutput(col_select_pins[1]);
+ gpio_set_pin_output(col_select_pins[1]);
if(binary[1] == 0) {
- writePinLow(col_select_pins[1]);
+ gpio_write_pin_low(col_select_pins[1]);
}
else {
- writePinHigh(col_select_pins[1]);
+ gpio_write_pin_high(col_select_pins[1]);
}
// set pin2
- setPinOutput(col_select_pins[2]);
+ gpio_set_pin_output(col_select_pins[2]);
if(binary[0] == 0) {
- writePinLow(col_select_pins[2]);
+ gpio_write_pin_low(col_select_pins[2]);
}
else {
- writePinHigh(col_select_pins[2]);
+ gpio_write_pin_high(col_select_pins[2]);
}
}
M keyboards/handwired/prime_exl_plus/prime_exl_plus.c => keyboards/handwired/prime_exl_plus/prime_exl_plus.c +11 -11
@@ 17,22 17,22 @@
void matrix_init_kb(void) {
// set CapsLock LED to output and low
- setPinOutput(B0);
- writePinLow(B0);
+ gpio_set_pin_output(B0);
+ gpio_write_pin_low(B0);
// set NumLock LED to output and low
- setPinOutput(B1);
- writePinLow(B1);
+ gpio_set_pin_output(B1);
+ gpio_write_pin_low(B1);
// set ScrollLock LED to output and low
- setPinOutput(B2);
- writePinLow(B2);
+ gpio_set_pin_output(B2);
+ gpio_write_pin_low(B2);
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(B1, led_state.num_lock);
- writePin(B0, led_state.caps_lock);
- //writePin(B2, led_state.scroll_lock);
+ gpio_write_pin(B1, led_state.num_lock);
+ gpio_write_pin(B0, led_state.caps_lock);
+ //gpio_write_pin(B2, led_state.scroll_lock);
}
return res;
}
@@ 41,9 41,9 @@ bool led_update_kb(led_t led_state) {
layer_state_t layer_state_set_kb(layer_state_t state)
{
if (get_highest_layer(state) == 1) {
- writePinHigh(B2);
+ gpio_write_pin_high(B2);
} else {
- writePinLow(B2);
+ gpio_write_pin_low(B2);
}
return layer_state_set_user(state);
}
M keyboards/handwired/retro_refit/retro_refit.c => keyboards/handwired/retro_refit/retro_refit.c +3 -3
@@ 15,9 15,9 @@ void matrix_init_kb(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(D0, !led_state.caps_lock);
- writePin(D1, !led_state.num_lock);
- writePin(C6, !led_state.scroll_lock);
+ gpio_write_pin(D0, !led_state.caps_lock);
+ gpio_write_pin(D1, !led_state.num_lock);
+ gpio_write_pin(C6, !led_state.scroll_lock);
}
return res;
M keyboards/handwired/selene/selene.c => keyboards/handwired/selene/selene.c +6 -6
@@ 18,9 18,9 @@
#include "selene.h"
void matrix_init_kb(void){
- setPinOutput(NUM_LOCK_PIN);
- setPinOutput(CAPS_LOCK_PIN);
- setPinOutput(SCROLL_LOCK_PIN);
+ gpio_set_pin_output(NUM_LOCK_PIN);
+ gpio_set_pin_output(CAPS_LOCK_PIN);
+ gpio_set_pin_output(SCROLL_LOCK_PIN);
}
void keyboard_post_init_user(void) {
@@ 30,9 30,9 @@ void keyboard_post_init_user(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(NUM_LOCK_PIN, led_state.num_lock);
- writePin(CAPS_LOCK_PIN, led_state.caps_lock);
- writePin(SCROLL_LOCK_PIN, led_state.scroll_lock);
+ gpio_write_pin(NUM_LOCK_PIN, led_state.num_lock);
+ gpio_write_pin(CAPS_LOCK_PIN, led_state.caps_lock);
+ gpio_write_pin(SCROLL_LOCK_PIN, led_state.scroll_lock);
}
return res;
}
M keyboards/handwired/sono1/sono1.c => keyboards/handwired/sono1/sono1.c +13 -13
@@ 18,17 18,17 @@
void matrix_init_kb(void) {
/* LED pins setup */
- setPinOutput(LED_KANA_PIN);
- setPinOutput(LED_CAPS_LOCK_PIN);
- setPinOutput(LED_CTRL_XFER_PIN);
- setPinOutput(LED_NUM_LOCK_PIN);
- setPinOutput(LED_KB_LOCK_PIN);
+ gpio_set_pin_output(LED_KANA_PIN);
+ gpio_set_pin_output(LED_CAPS_LOCK_PIN);
+ gpio_set_pin_output(LED_CTRL_XFER_PIN);
+ gpio_set_pin_output(LED_NUM_LOCK_PIN);
+ gpio_set_pin_output(LED_KB_LOCK_PIN);
- writePinHigh(LED_KANA_PIN);
- writePinHigh(LED_CAPS_LOCK_PIN);
- writePinHigh(LED_CTRL_XFER_PIN);
- writePinHigh(LED_NUM_LOCK_PIN);
- writePinHigh(LED_KB_LOCK_PIN);
+ gpio_write_pin_high(LED_KANA_PIN);
+ gpio_write_pin_high(LED_CAPS_LOCK_PIN);
+ gpio_write_pin_high(LED_CTRL_XFER_PIN);
+ gpio_write_pin_high(LED_NUM_LOCK_PIN);
+ gpio_write_pin_high(LED_KB_LOCK_PIN);
matrix_init_user();
}
@@ 36,9 36,9 @@ void matrix_init_kb(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(LED_NUM_LOCK_PIN, !led_state.num_lock);
- writePin(LED_CAPS_LOCK_PIN, !led_state.caps_lock);
- writePin(LED_CTRL_XFER_PIN, !led_state.scroll_lock);
+ gpio_write_pin(LED_NUM_LOCK_PIN, !led_state.num_lock);
+ gpio_write_pin(LED_CAPS_LOCK_PIN, !led_state.caps_lock);
+ gpio_write_pin(LED_CTRL_XFER_PIN, !led_state.scroll_lock);
}
return res;
}
M keyboards/handwired/symmetric70_proto/debug_config.h => keyboards/handwired/symmetric70_proto/debug_config.h +6 -6
@@ 8,23 8,23 @@
#include <gpio.h>
static inline void setDebugPinOutput_Low(void) {
- setPinOutput(MATRIX_DEBUG_PIN);
- writePinLow(MATRIX_DEBUG_PIN);
+ gpio_set_pin_output(MATRIX_DEBUG_PIN);
+ gpio_write_pin_low(MATRIX_DEBUG_PIN);
}
#define MATRIX_DEBUG_PIN_INIT() setDebugPinOutput_Low()
#ifdef MATRIX_DEBUG_SCAN
-# define MATRIX_DEBUG_SCAN_START() writePinHigh(MATRIX_DEBUG_PIN)
-# define MATRIX_DEBUG_SCAN_END() writePinLow(MATRIX_DEBUG_PIN)
+# define MATRIX_DEBUG_SCAN_START() gpio_write_pin_high(MATRIX_DEBUG_PIN)
+# define MATRIX_DEBUG_SCAN_END() gpio_write_pin_low(MATRIX_DEBUG_PIN)
#else
# define MATRIX_DEBUG_SCAN_START()
# define MATRIX_DEBUG_SCAN_END()
#endif
#ifdef MATRIX_DEBUG_DELAY
-# define MATRIX_DEBUG_DELAY_START() writePinHigh(MATRIX_DEBUG_PIN)
-# define MATRIX_DEBUG_DELAY_END() writePinLow(MATRIX_DEBUG_PIN)
+# define MATRIX_DEBUG_DELAY_START() gpio_write_pin_high(MATRIX_DEBUG_PIN)
+# define MATRIX_DEBUG_DELAY_END() gpio_write_pin_low(MATRIX_DEBUG_PIN)
#else
# define MATRIX_DEBUG_DELAY_START()
# define MATRIX_DEBUG_DELAY_END()
M keyboards/handwired/symmetric70_proto/matrix_debug/matrix.c => keyboards/handwired/symmetric70_proto/matrix_debug/matrix.c +15 -15
@@ 62,13 62,13 @@ extern matrix_row_t matrix[MATRIX_ROWS]; // debounced values
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinInputHigh_atomic(pin_t pin) {
- ATOMIC_BLOCK_FORCEON { setPinInputHigh(pin); }
+ ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); }
}
// matrix code
@@ 80,7 80,7 @@ static void init_pins(void) {
for (int col = 0; col < MATRIX_COLS; col++) {
pin_t pin = direct_pins[row][col];
if (pin != NO_PIN) {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
}
@@ 93,7 93,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
pin_t pin = direct_pins[current_row][col_index];
if (pin != NO_PIN) {
- current_row_value |= readPin(pin) ? 0 : (MATRIX_ROW_SHIFTER << col_index);
+ current_row_value |= gpio_read_pin(pin) ? 0 : (MATRIX_ROW_SHIFTER << col_index);
}
}
@@ 120,8 120,8 @@ static void unselect_rows(void) {
static void init_pins(void) {
# ifdef MATRIX_MUL_SELECT
- setPinOutput(MATRIX_MUL_SELECT);
- writePinLow(MATRIX_MUL_SELECT);
+ gpio_set_pin_output(MATRIX_MUL_SELECT);
+ gpio_write_pin_low(MATRIX_MUL_SELECT);
# endif
unselect_rows();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
@@ 141,10 141,10 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
# ifdef MATRIX_MUL_SELECT
- writePin(MATRIX_MUL_SELECT, col_sel[col_index]);
+ gpio_write_pin(MATRIX_MUL_SELECT, col_sel[col_index]);
waitInputPinDelay();
# endif
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_row_value |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
@@ 160,7 160,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
is_pressed = false;
for (uint8_t i = 0; i < ARRAY_SIZE(delay_ports); i++) {
# ifdef MATRIX_IO_DELAY_MULSEL
- writePin(MATRIX_MUL_SELECT, delay_sel[i]);
+ gpio_write_pin(MATRIX_MUL_SELECT, delay_sel[i]);
waitInputPinDelay();
# endif
is_pressed |= ((readPort(delay_ports[i]) & delay_masks[i]) != delay_masks[i]);
@@ 174,10 174,10 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
MATRIX_DEBUG_DELAY_START();
# ifdef MATRIX_MUL_SELECT
- writePin(MATRIX_MUL_SELECT, col_sel[col_index]);
+ gpio_write_pin(MATRIX_MUL_SELECT, col_sel[col_index]);
waitInputPinDelay();
# endif
- while (readPin(col_pins[col_index]) == 0) {
+ while (gpio_read_pin(col_pins[col_index]) == 0) {
}
MATRIX_DEBUG_DELAY_END();
}
@@ 193,10 193,10 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
MATRIX_DEBUG_DELAY_END();
MATRIX_DEBUG_DELAY_START();
# ifdef MATRIX_MUL_SELECT
- writePin(MATRIX_MUL_SELECT, col_sel[col_index]);
+ gpio_write_pin(MATRIX_MUL_SELECT, col_sel[col_index]);
waitInputPinDelay();
# endif
- state |= (readPin(col_pins[col_index]) == 0);
+ state |= (gpio_read_pin(col_pins[col_index]) == 0);
}
MATRIX_DEBUG_DELAY_END();
} while (state);
@@ 250,7 250,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t current_row_value = last_row_value;
// Check row pin state
- if (readPin(row_pins[row_index]) == 0) {
+ if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_row_value |= (MATRIX_ROW_SHIFTER << current_col);
key_pressed = true;
M keyboards/handwired/symmetric70_proto/matrix_fast/matrix_extension_74hc15x.c => keyboards/handwired/symmetric70_proto/matrix_fast/matrix_extension_74hc15x.c +3 -3
@@ 51,9 51,9 @@ static const pin_t sel_pins[] = { MATRIX_EXT_74HC15x };
LOCAL_FUNC ALWAYS_INLINE void select74HC15x(uint8_t devid);
LOCAL_FUNC
void select74HC15x(uint8_t devid) {
- writePin(sel_pins[0], devid&1);
+ gpio_write_pin(sel_pins[0], devid&1);
#if defined(MATRIX_EXTENSION_74HC153)
- writePin(sel_pins[1], devid&2);
+ gpio_write_pin(sel_pins[1], devid&2);
#endif
}
@@ 67,7 67,7 @@ LOCAL_FUNC port_width_t readPortMultiplexer(uint8_t devid, pin_t port) {
#define readMatrixPort(dev, port) \
((dev) == MCU_GPIO)? readPort(port): (IS_74HC15x(dev))? readPortMultiplexer((dev)-MCU_GPIOa, port):0
-#define INIT_74HC15X(x) setPinOutput(x); writePinLow(x);
+#define INIT_74HC15X(x) gpio_set_pin_output(x); gpio_write_pin_low(x);
LOCAL_FUNC
void init_74hc15x(void) {
MAP(INIT_74HC15X, MATRIX_EXT_74HC15x)
M keyboards/handwired/tractyl_manuform/5x6_right/f411/f411.c => keyboards/handwired/tractyl_manuform/5x6_right/f411/f411.c +5 -5
@@ 16,10 16,10 @@
#include "tractyl_manuform.h"
-void keyboard_pre_init_sub(void) { setPinInputHigh(A0); }
+void keyboard_pre_init_sub(void) { gpio_set_pin_input_high(A0); }
void matrix_scan_sub_kb(void) {
- if (!readPin(A0)) {
+ if (!gpio_read_pin(A0)) {
reset_keyboard();
}
}
@@ 44,7 44,7 @@ __attribute__((weak)) void bootmagic_scan(void) {
}
#endif
- if (matrix_get_row(row) & (1 << col) || !readPin(A0)) {
+ if (matrix_get_row(row) & (1 << col) || !gpio_read_pin(A0)) {
eeconfig_disable();
bootloader_jump();
}
@@ 53,9 53,9 @@ __attribute__((weak)) void bootmagic_scan(void) {
#ifdef USB_VBUS_PIN
bool usb_vbus_state(void) {
- setPinInputLow(USB_VBUS_PIN);
+ gpio_set_pin_input_low(USB_VBUS_PIN);
wait_us(5);
- return readPin(USB_VBUS_PIN);
+ return gpio_read_pin(USB_VBUS_PIN);
}
#endif
M keyboards/handwired/traveller/traveller.c => keyboards/handwired/traveller/traveller.c +2 -2
@@ 11,8 11,8 @@ void matrix_init_kb(void) {
#endif
// Turn status LED on
- setPinOutput(C7);
- writePinHigh(C7);
+ gpio_set_pin_output(C7);
+ gpio_write_pin_high(C7);
matrix_init_user();
}
M keyboards/handwired/woodpad/woodpad.c => keyboards/handwired/woodpad/woodpad.c +3 -3
@@ 17,14 17,14 @@
#include "woodpad.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(F7);
+ gpio_set_pin_output(F7);
keyboard_pre_init_user();
}
inline void numlock_led_on(void) {
- writePinHigh(F7);
+ gpio_write_pin_high(F7);
}
inline void numlock_led_off(void) {
- writePinLow(F7);
+ gpio_write_pin_low(F7);
}
M keyboards/handwired/z150/z150.c => keyboards/handwired/z150/z150.c +9 -9
@@ 17,13 17,13 @@
#include "quantum.h"
void matrix_init_kb(void) {
- setPinOutput(NUM_LOCK_LED_PIN);
- setPinOutput(CAPS_LOCK_LED_PIN);
- setPinOutput(SCROLL_LOCK_LED_PIN);
+ gpio_set_pin_output(NUM_LOCK_LED_PIN);
+ gpio_set_pin_output(CAPS_LOCK_LED_PIN);
+ gpio_set_pin_output(SCROLL_LOCK_LED_PIN);
- writePinLow(NUM_LOCK_LED_PIN);
- writePinLow(CAPS_LOCK_LED_PIN);
- writePinLow(SCROLL_LOCK_LED_PIN);
+ gpio_write_pin_low(NUM_LOCK_LED_PIN);
+ gpio_write_pin_low(CAPS_LOCK_LED_PIN);
+ gpio_write_pin_low(SCROLL_LOCK_LED_PIN);
matrix_init_user();
}
@@ 31,9 31,9 @@ void matrix_init_kb(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(NUM_LOCK_LED_PIN, !led_state.num_lock);
- writePin(CAPS_LOCK_LED_PIN, !led_state.caps_lock);
- writePin(SCROLL_LOCK_LED_PIN, !led_state.scroll_lock);
+ gpio_write_pin(NUM_LOCK_LED_PIN, !led_state.num_lock);
+ gpio_write_pin(CAPS_LOCK_LED_PIN, !led_state.caps_lock);
+ gpio_write_pin(SCROLL_LOCK_LED_PIN, !led_state.scroll_lock);
}
return res;
}
M keyboards/hardwareabstraction/handwire/handwire.c => keyboards/hardwareabstraction/handwire/handwire.c +5 -5
@@ 28,7 28,7 @@ enum custom_keycodes{
// Documentation: custom_quantum_functions.md
void keyboard_post_init_kb(void){
- setPinOutput(BUZZER_PIN);
+ gpio_set_pin_output(BUZZER_PIN);
keyboard_post_init_user();
}
@@ 36,7 36,7 @@ void housekeeping_task_kb(void){
if(buzzer_on){
if(buzzer_active && timer_elapsed(buzzer_timer) > buzzer_dwell){
buzzer_active = false;
- writePinLow(BUZZER_PIN);
+ gpio_write_pin_low(BUZZER_PIN);
}
}
housekeeping_task_user();
@@ 50,7 50,7 @@ bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
if(!buzzer_active){
buzzer_active = true;
buzzer_timer = timer_read();
- writePinHigh(BUZZER_PIN);
+ gpio_write_pin_high(BUZZER_PIN);
}
}
@@ 94,10 94,10 @@ bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
if(buzzer_on == true){
buzzer_active = true;
buzzer_timer = timer_read();
- writePinHigh(BUZZER_PIN);
+ gpio_write_pin_high(BUZZER_PIN);
}
else{
- writePinLow(BUZZER_PIN);
+ gpio_write_pin_low(BUZZER_PIN);
}
break;
M keyboards/hazel/bad_wings/matrix.c => keyboards/hazel/bad_wings/matrix.c +6 -6
@@ 48,11 48,11 @@ bool sr_74hc595_spi_start(void) {
bool sr_74hc595_spi_send_byte(uint8_t data) {
sr_74hc595_spi_start();
- writePinLow(SHIFTREG_MATRIX_COL_CS);
+ gpio_write_pin_low(SHIFTREG_MATRIX_COL_CS);
matrix_io_delay();
spi_write(data);
matrix_io_delay();
- writePinHigh(SHIFTREG_MATRIX_COL_CS);
+ gpio_write_pin_high(SHIFTREG_MATRIX_COL_CS);
sr_74hc595_spi_stop();
return true;
}
@@ 82,12 82,12 @@ void matrix_init_custom(void) {
// Set up the initial states for all the row pins
for (int r = 0; r < SHIFTREG_ROWS; r++) {
// Note: This needs to use the internal pull down resistors, and atmegas do *not* support that
- setPinInputLow(rowPinsSR[r]);
+ gpio_set_pin_input_low(rowPinsSR[r]);
}
// Set the CS to low by default, and specify as an output pin
- writePinHigh(SHIFTREG_MATRIX_COL_CS); // should be high when using SPI?
- setPinOutput(SHIFTREG_MATRIX_COL_CS);
+ gpio_write_pin_high(SHIFTREG_MATRIX_COL_CS); // should be high when using SPI?
+ gpio_set_pin_output(SHIFTREG_MATRIX_COL_CS);
// Since it's the init, deactivate all the columns. We'll activate once we get to the matrix scan
clearColumns();
@@ 116,7 116,7 @@ bool matrix_scan_custom(matrix_row_t current_matrix[]) {
matrix_io_delay();
for (int r = 0; r < SHIFTREG_ROWS; r++) {
- current_matrix[r] |= ((readPin(rowPinsSR[r]) ? 1 : 0) << c);
+ current_matrix[r] |= ((gpio_read_pin(rowPinsSR[r]) ? 1 : 0) << c);
}
}
M keyboards/heliar/wm1_hotswap/wm1_hotswap.c => keyboards/heliar/wm1_hotswap/wm1_hotswap.c +9 -9
@@ 19,20 19,20 @@
void keyboard_pre_init_kb(void)
{
- setPinOutput(D7);
- writePinHigh(D7);
- setPinOutput(D6);
- writePinHigh(D6);
- setPinOutput(D4);
- writePinHigh(D4);
+ gpio_set_pin_output(D7);
+ gpio_write_pin_high(D7);
+ gpio_set_pin_output(D6);
+ gpio_write_pin_high(D6);
+ gpio_set_pin_output(D4);
+ gpio_write_pin_high(D4);
}
bool led_update_kb(led_t led_state) {
if (led_update_user(led_state)){
- writePin(D7, !led_state.num_lock);
- writePin(D6, !led_state.caps_lock);
- writePin(D4, !led_state.scroll_lock);
+ gpio_write_pin(D7, !led_state.num_lock);
+ gpio_write_pin(D6, !led_state.caps_lock);
+ gpio_write_pin(D4, !led_state.scroll_lock);
}
return true;
M keyboards/hhkb/yang/matrix.c => keyboards/hhkb/yang/matrix.c +10 -10
@@ 34,12 34,12 @@ uint8_t power_save_level;
static uint32_t matrix_last_modified = 0;
-static inline void key_strobe_high(void) { writePinLow(B6); }
-static inline void key_strobe_low(void) { writePinHigh(B6); }
-static inline bool key_state(void) { return readPin(D7); }
-static inline void key_prev_on(void) { writePinHigh(B7); }
-static inline void key_prev_off(void) { writePinLow(B7); }
-static inline bool key_power_state(void) { return !readPin(D6); }
+static inline void key_strobe_high(void) { gpio_write_pin_low(B6); }
+static inline void key_strobe_low(void) { gpio_write_pin_high(B6); }
+static inline bool key_state(void) { return gpio_read_pin(D7); }
+static inline void key_prev_on(void) { gpio_write_pin_high(B7); }
+static inline void key_prev_off(void) { gpio_write_pin_low(B7); }
+static inline bool key_power_state(void) { return !gpio_read_pin(D6); }
static inline void suspend_power_down_longer(void) {
uint8_t times = 60;
@@ 52,8 52,8 @@ void matrix_power_up(void) {
DDRB = 0xFF;
PORTB = 0x40;
// switch MOS FET on
- setPinOutput(D6);
- writePinLow(D6);
+ gpio_set_pin_output(D6);
+ gpio_write_pin_low(D6);
}
void matrix_power_down(void) {
@@ 62,8 62,8 @@ void matrix_power_down(void) {
DDRB = 0x00;
PORTB = 0xFF;
// switch MOS FET off
- setPinOutput(D6);
- writePinHigh(D6);
+ gpio_set_pin_output(D6);
+ gpio_write_pin_high(D6);
}
static inline void key_select_row(uint8_t row) { PORTB = (PORTB & 0b11111000) | ((row)&0b111); }
M keyboards/hhkb/yang/yang.c => keyboards/hhkb/yang/yang.c +31 -31
@@ 21,13 21,13 @@ extern uint8_t power_save_level;
void hhkb_led_on(uint8_t led) {
switch (led) {
case 1:
- writePinHigh(F4);
+ gpio_write_pin_high(F4);
break;
case 2:
- writePinHigh(F2);
+ gpio_write_pin_high(F2);
break;
case 3:
- writePinHigh(F0);
+ gpio_write_pin_high(F0);
break;
}
}
@@ 35,55 35,55 @@ void hhkb_led_on(uint8_t led) {
void hhkb_led_off(uint8_t led) {
switch (led) {
case 1:
- writePinLow(F4);
+ gpio_write_pin_low(F4);
break;
case 2:
- writePinLow(F2);
+ gpio_write_pin_low(F2);
break;
case 3:
- writePinLow(F0);
+ gpio_write_pin_low(F0);
break;
}
}
void keyboard_pre_init_kb(void) {
// BT power up
- setPinOutput(D5);
- writePinLow(D5);
+ gpio_set_pin_output(D5);
+ gpio_write_pin_low(D5);
// Row selectors
- setPinOutput(B0);
- setPinOutput(B1);
- setPinOutput(B2);
+ gpio_set_pin_output(B0);
+ gpio_set_pin_output(B1);
+ gpio_set_pin_output(B2);
// Col selectors
- setPinOutput(B3);
- setPinOutput(B4);
- setPinOutput(B5);
+ gpio_set_pin_output(B3);
+ gpio_set_pin_output(B4);
+ gpio_set_pin_output(B5);
// Key strobe
- setPinOutput(B6);
- writePinHigh(B6);
+ gpio_set_pin_output(B6);
+ gpio_write_pin_high(B6);
// Key: input with pull-up
- setPinInputHigh(D7);
+ gpio_set_pin_input_high(D7);
// Unused pins on Pro2 ANSI
// Input with pull up to save power
- setPinInputHigh(C6);
- setPinInputHigh(C7);
+ gpio_set_pin_input_high(C6);
+ gpio_set_pin_input_high(C7);
// LED pin configuration
- setPinOutput(F0);
- setPinOutput(F1);
- setPinOutput(F4);
- writePinLow(F0);
- writePinLow(F1);
- writePinLow(F4);
+ gpio_set_pin_output(F0);
+ gpio_set_pin_output(F1);
+ gpio_set_pin_output(F4);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_low(F4);
// Turn on switch PCB
- setPinOutput(D6);
- writePinLow(D6);
+ gpio_set_pin_output(D6);
+ gpio_write_pin_low(D6);
keyboard_pre_init_user();
}
@@ 93,7 93,7 @@ void suspend_power_down_kb(void) {
// Disable UART TX to avoid current leakage
UCSR1B &= ~_BV(TXEN1);
// Power down BLE module
- writePinHigh(D5);
+ gpio_write_pin_high(D5);
}
suspend_power_down_user();
@@ 101,7 101,7 @@ void suspend_power_down_kb(void) {
void suspend_wakeup_init_kb(void) {
// Power up BLE module
- writePinLow(D5);
+ gpio_write_pin_low(D5);
// Enable UART TX
UCSR1B |= _BV(TXEN1);
@@ 111,8 111,8 @@ void suspend_wakeup_init_kb(void) {
layer_state_t layer_state_set_kb(layer_state_t state) {
state = layer_state_set_user(state);
- writePin(F1, IS_LAYER_ON_STATE(state, 1));
- writePin(F0, IS_LAYER_ON_STATE(state, 2));
+ gpio_write_pin(F1, IS_LAYER_ON_STATE(state, 1));
+ gpio_write_pin(F0, IS_LAYER_ON_STATE(state, 2));
return state;
}
M keyboards/hineybush/h10/h10.c => keyboards/hineybush/h10/h10.c +2 -2
@@ 23,12 23,12 @@
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
- setPinOutput(F7);
+ gpio_set_pin_output(F7);
}
bool led_update_kb(led_t led_state) {
if(led_update_user(led_state)) {
- writePin(F7, !led_state.num_lock);
+ gpio_write_pin(F7, !led_state.num_lock);
}
return true;
}
M keyboards/hineybush/h60/h60.c => keyboards/hineybush/h60/h60.c +2 -2
@@ 19,12 19,12 @@
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
- setPinOutput(C6);
+ gpio_set_pin_output(C6);
}
bool led_update_kb(led_t led_state) {
if(led_update_user(led_state)) {
- writePin(C6, !led_state.caps_lock);
+ gpio_write_pin(C6, !led_state.caps_lock);
}
return true;
}
M keyboards/hineybush/h87a/h87a.c => keyboards/hineybush/h87a/h87a.c +4 -4
@@ 18,15 18,15 @@
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
- setPinOutput(D5);
- setPinOutput(E6);
+ gpio_set_pin_output(D5);
+ gpio_set_pin_output(E6);
matrix_init_user();
}
bool led_update_kb(led_t led_state) {
if(led_update_user(led_state)) {
- writePin(D5, !led_state.caps_lock);
- writePin(E6, !led_state.scroll_lock);
+ gpio_write_pin(D5, !led_state.caps_lock);
+ gpio_write_pin(E6, !led_state.scroll_lock);
}
return true;
}
M keyboards/hineybush/h88/h88.c => keyboards/hineybush/h88/h88.c +4 -4
@@ 18,15 18,15 @@
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
- setPinOutput(D5);
- setPinOutput(E6);
+ gpio_set_pin_output(D5);
+ gpio_set_pin_output(E6);
matrix_init_user();
}
bool led_update_kb(led_t led_state) {
if(led_update_user(led_state)) {
- writePin(D5, !led_state.caps_lock);
- writePin(E6, !led_state.scroll_lock);
+ gpio_write_pin(D5, !led_state.caps_lock);
+ gpio_write_pin(E6, !led_state.scroll_lock);
}
return true;
}
M keyboards/hineybush/hbcp/matrix.c => keyboards/hineybush/hbcp/matrix.c +10 -10
@@ 27,11 27,11 @@ static matrix_row_t last_matrix[MATRIX_ROWS]; // raw values of last scan
// matrix code
void select_row(uint8_t row) {
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
- void unselect_row(uint8_t row) { setPinInputHigh(row_pins[row]); }
+ void unselect_row(uint8_t row) { gpio_set_pin_input_high(row_pins[row]); }
bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
// Store last value of row prior to reading
@@ 47,7 47,7 @@ static matrix_row_t last_matrix[MATRIX_ROWS]; // raw values of last scan
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
@@ 60,11 60,11 @@ static matrix_row_t last_matrix[MATRIX_ROWS]; // raw values of last scan
}
void select_col(uint8_t col) {
- setPinOutput(col_pins[col]);
- writePinLow(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
- void unselect_col(uint8_t col) { setPinInputHigh(col_pins[col]); }
+ void unselect_col(uint8_t col) { gpio_set_pin_input_high(col_pins[col]); }
bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
bool matrix_changed = false;
@@ 79,7 79,7 @@ static matrix_row_t last_matrix[MATRIX_ROWS]; // raw values of last scan
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0) {
+ if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_matrix[row_index] |= (MATRIX_ROW_SHIFTER << current_col);
}
@@ 98,13 98,13 @@ static matrix_row_t last_matrix[MATRIX_ROWS]; // raw values of last scan
void unselect_rows(void) {
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
void unselect_cols(void) {
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
M keyboards/hineybush/physix/physix.c => keyboards/hineybush/physix/physix.c +5 -5
@@ 24,8 24,8 @@
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
- setPinOutput(D3);
- setPinOutput(D5);
+ gpio_set_pin_output(D3);
+ gpio_set_pin_output(D5);
matrix_init_user();
}
@@ 33,13 33,13 @@ bool led_update_kb(led_t led_state) {
// put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
bool res = led_update_user(led_state);
if(res) {
- // writePin sets the pin high for 1 and low for 0.
+ // gpio_write_pin sets the pin high for 1 and low for 0.
// In this example the pins are inverted, setting
// it low/0 turns it on, and high/1 turns the LED off.
// This behavior depends on whether the LED is between the pin
// and VCC or the pin and GND.
- writePin(D3, led_state.caps_lock);
- writePin(D5, led_state.scroll_lock);
+ gpio_write_pin(D3, led_state.caps_lock);
+ gpio_write_pin(D5, led_state.scroll_lock);
}
return res;
return led_update_user(led_state);
M keyboards/ibm/model_m/ashpil_usbc/ashpil_usbc.c => keyboards/ibm/model_m/ashpil_usbc/ashpil_usbc.c +9 -9
@@ 18,19 18,19 @@
void keyboard_pre_init_kb(void) {
/* Setting status LEDs pins to output and +5V (off) */
- setPinOutput(D5);
- setPinOutput(D6);
- setPinOutput(D7);
- writePinHigh(D5);
- writePinHigh(D6);
- writePinHigh(D7);
+ gpio_set_pin_output(D5);
+ gpio_set_pin_output(D6);
+ gpio_set_pin_output(D7);
+ gpio_write_pin_high(D5);
+ gpio_write_pin_high(D6);
+ gpio_write_pin_high(D7);
}
bool led_update_kb(led_t led_state) {
if(led_update_user(led_state)) {
- writePin(D5, !led_state.num_lock);
- writePin(D6, !led_state.caps_lock);
- writePin(D7, !led_state.scroll_lock);
+ gpio_write_pin(D5, !led_state.num_lock);
+ gpio_write_pin(D6, !led_state.caps_lock);
+ gpio_write_pin(D7, !led_state.scroll_lock);
}
return true;
}
M keyboards/ibm/model_m/modelh/modelh.c => keyboards/ibm/model_m/modelh/modelh.c +2 -2
@@ 18,8 18,8 @@
void keyboard_pre_init_kb(void) {
- setPinOutput(MODELH_STATUS_LED);
- writePin(MODELH_STATUS_LED, 0);
+ gpio_set_pin_output(MODELH_STATUS_LED);
+ gpio_write_pin(MODELH_STATUS_LED, 0);
keyboard_pre_init_user();
}
M keyboards/ibm/model_m/mschwingen/matrix.c => keyboards/ibm/model_m/mschwingen/matrix.c +6 -6
@@ 31,15 31,15 @@ static uint16_t row_bits[MATRIX_ROWS] = {
static const pin_t col_pins[MATRIX_COLS] = {D1, D4, D7, B4, F7, F6, F5, F4};
static void select_col(uint8_t col) {
- setPinOutput(col_pins[col]);
- writePinLow(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
-static void unselect_col(uint8_t col) { setPinInputHigh(col_pins[col]); }
+static void unselect_col(uint8_t col) { gpio_set_pin_input_high(col_pins[col]); }
static void unselect_cols(void) {
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 51,8 51,8 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
select_col(current_col);
matrix_io_delay();
- writePinLow(SR_LOAD_PIN);
- writePinHigh(SR_LOAD_PIN);
+ gpio_write_pin_low(SR_LOAD_PIN);
+ gpio_write_pin_high(SR_LOAD_PIN);
row_data = spi_read() << 8;
row_data |= spi_read();
M keyboards/ibm/model_m/mschwingen/mschwingen.c => keyboards/ibm/model_m/mschwingen/mschwingen.c +18 -18
@@ 74,12 74,12 @@ void sleep_led_toggle(void) {}
void sleep_led_disable(void) {
suspend_active = false;
- writePinHigh(MODELM_STATUS_LED);
+ gpio_write_pin_high(MODELM_STATUS_LED);
}
void sleep_led_enable(void) {
suspend_active = true;
- writePinLow(MODELM_STATUS_LED);
+ gpio_write_pin_low(MODELM_STATUS_LED);
#ifdef KEYBOARD_ibm_model_m_mschwingen_led_ws2812
led[0] = black;
led[1] = black;
@@ 94,15 94,15 @@ void keyboard_pre_init_kb(void) {
ws2812_setleds(led, RGBLIGHT_LED_COUNT);
#else
/* Set status LEDs pins to output and Low (on) */
- setPinOutput(MODELM_LED_CAPSLOCK);
- setPinOutput(MODELM_LED_SCROLLOCK);
- setPinOutput(MODELM_LED_NUMLOCK);
- writePinLow(MODELM_LED_CAPSLOCK);
- writePinLow(MODELM_LED_SCROLLOCK);
- writePinLow(MODELM_LED_NUMLOCK);
+ gpio_set_pin_output(MODELM_LED_CAPSLOCK);
+ gpio_set_pin_output(MODELM_LED_SCROLLOCK);
+ gpio_set_pin_output(MODELM_LED_NUMLOCK);
+ gpio_write_pin_low(MODELM_LED_CAPSLOCK);
+ gpio_write_pin_low(MODELM_LED_SCROLLOCK);
+ gpio_write_pin_low(MODELM_LED_NUMLOCK);
#endif
- setPinOutput(MODELM_STATUS_LED);
- writePinHigh(MODELM_STATUS_LED);
+ gpio_set_pin_output(MODELM_STATUS_LED);
+ gpio_write_pin_high(MODELM_STATUS_LED);
_delay_ms(50);
#ifdef UART_DEBUG
uart_init(115200);
@@ 110,10 110,10 @@ void keyboard_pre_init_kb(void) {
uprintf("\r\nHello world!\r\n");
#endif
- setPinOutput(SR_LOAD_PIN);
- setPinOutput(SR_CLK_PIN);
- setPinOutput(SR_DOUT_PIN); // MOSI - unused
- writePinLow(SR_CLK_PIN);
+ gpio_set_pin_output(SR_LOAD_PIN);
+ gpio_set_pin_output(SR_CLK_PIN);
+ gpio_set_pin_output(SR_DOUT_PIN); // MOSI - unused
+ gpio_write_pin_low(SR_CLK_PIN);
}
#ifdef KEYBOARD_ibm_model_m_mschwingen_led_ws2812
@@ 187,9 187,9 @@ bool led_update_kb(led_t led_state) {
dprintf("LED Update: %d %d %d", led_state.num_lock, led_state.caps_lock, led_state.scroll_lock);
if (led_update_user(led_state)) {
- if (!isRecording) writePin(MODELM_LED_NUMLOCK, !led_state.num_lock);
- writePin(MODELM_LED_CAPSLOCK, !led_state.caps_lock);
- writePin(MODELM_LED_SCROLLOCK, !led_state.scroll_lock);
+ if (!isRecording) gpio_write_pin(MODELM_LED_NUMLOCK, !led_state.num_lock);
+ gpio_write_pin(MODELM_LED_CAPSLOCK, !led_state.caps_lock);
+ gpio_write_pin(MODELM_LED_SCROLLOCK, !led_state.scroll_lock);
}
return true;
}
@@ 198,7 198,7 @@ void update_layer_leds(void) {
if (isRecording && timer_elapsed(blink_cycle_timer) > 150) {
blink_state = !blink_state;
blink_cycle_timer = timer_read();
- writePin(MODELM_LED_NUMLOCK, blink_state);
+ gpio_write_pin(MODELM_LED_NUMLOCK, blink_state);
}
}
M keyboards/ibm/model_m/teensypp/teensypp.c => keyboards/ibm/model_m/teensypp/teensypp.c +9 -9
@@ 17,20 17,20 @@
void led_init_ports(void) {
/* Setting status LEDs pins to output and +5V (off) */
- setPinOutput(B4);
- setPinOutput(B5);
- setPinOutput(B6);
- writePinHigh(B4);
- writePinHigh(B5);
- writePinHigh(B6);
+ gpio_set_pin_output(B4);
+ gpio_set_pin_output(B5);
+ gpio_set_pin_output(B6);
+ gpio_write_pin_high(B4);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B6);
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(B4, !led_state.num_lock);
- writePin(B6, !led_state.caps_lock);
- writePin(B5, !led_state.scroll_lock);
+ gpio_write_pin(B4, !led_state.num_lock);
+ gpio_write_pin(B6, !led_state.caps_lock);
+ gpio_write_pin(B5, !led_state.scroll_lock);
}
return res;
}
M keyboards/ibm/model_m/yugo_m/yugo_m.c => keyboards/ibm/model_m/yugo_m/yugo_m.c +6 -6
@@ 17,9 17,9 @@
void keyboard_pre_init_kb(void) {
// Set our LED pins as output
- setPinOutput(A2);
- setPinOutput(A1);
- setPinOutput(A0);
+ gpio_set_pin_output(A2);
+ gpio_set_pin_output(A1);
+ gpio_set_pin_output(A0);
keyboard_pre_init_user();
}
@@ 27,9 27,9 @@ void keyboard_pre_init_kb(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(A2, !led_state.num_lock);
- writePin(A1, !led_state.caps_lock);
- writePin(A0, !led_state.scroll_lock);
+ gpio_write_pin(A2, !led_state.num_lock);
+ gpio_write_pin(A1, !led_state.caps_lock);
+ gpio_write_pin(A0, !led_state.scroll_lock);
}
return res;
}
M keyboards/idb/idb_60/idb_60.c => keyboards/idb/idb_60/idb_60.c +6 -6
@@ 1,24 1,24 @@
#include "idb_60.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(C4);
- setPinOutput(C5);
+ gpio_set_pin_output(C4);
+ gpio_set_pin_output(C5);
}
inline void _idb_60_caps_led_on(void) {
- writePinLow(C5);
+ gpio_write_pin_low(C5);
}
inline void _idb_60_fn_led_on(void) {
- writePinLow(C4);
+ gpio_write_pin_low(C4);
}
inline void _idb_60_caps_led_off(void) {
- writePinHigh(C5);
+ gpio_write_pin_high(C5);
}
inline void _idb_60_fn_led_off(void) {
- writePinHigh(C4);
+ gpio_write_pin_high(C4);
}
// Capslock LED indicator
M keyboards/ilumkb/volcano660/volcano660.c => keyboards/ilumkb/volcano660/volcano660.c +6 -6
@@ 16,18 16,18 @@
#include "quantum.h"
void matrix_init_kb(void) {
- setPinOutput(D0);
- setPinOutput(D1);
- setPinOutput(D2);
+ gpio_set_pin_output(D0);
+ gpio_set_pin_output(D1);
+ gpio_set_pin_output(D2);
matrix_init_user();
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(D0, !led_state.num_lock);
- writePin(D2, !led_state.caps_lock);
- writePin(D1, !led_state.scroll_lock);
+ gpio_write_pin(D0, !led_state.num_lock);
+ gpio_write_pin(D2, !led_state.caps_lock);
+ gpio_write_pin(D1, !led_state.scroll_lock);
}
return res;
M keyboards/ingrained/matrix.c => keyboards/ingrained/matrix.c +7 -7
@@ 180,8 180,8 @@ static void init_cols(void) {
pin_t matrix_col_pins_mcu[MATRIX_COLS_PER_SIDE] = MATRIX_COL_PINS_MCU;
for (int pin_index = 0; pin_index < MATRIX_COLS_PER_SIDE; pin_index++) {
pin_t pin = matrix_col_pins_mcu[pin_index];
- setPinInput(pin);
- writePinHigh(pin);
+ gpio_set_pin_input(pin);
+ gpio_write_pin_high(pin);
}
}
@@ 192,7 192,7 @@ static matrix_row_t read_cols(uint8_t row) {
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS_PER_SIDE; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(matrix_col_pins_mcu[col_index]);
+ uint8_t pin_state = gpio_read_pin(matrix_col_pins_mcu[col_index]);
// Populate the matrix row with the state of the col pin
current_row_value |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
@@ 227,8 227,8 @@ static void unselect_rows(void) {
pin_t matrix_row_pins_mcu[MATRIX_ROWS_PER_SIDE] = MATRIX_ROW_PINS_MCU;
for (int pin_index = 0; pin_index < MATRIX_ROWS_PER_SIDE; pin_index++) {
pin_t pin = matrix_row_pins_mcu[pin_index];
- setPinInput(pin);
- writePinLow(pin);
+ gpio_set_pin_input(pin);
+ gpio_write_pin_low(pin);
}
}
@@ 237,8 237,8 @@ static void select_row(uint8_t row) {
// select on atmega32u4
pin_t matrix_row_pins_mcu[MATRIX_ROWS_PER_SIDE] = MATRIX_ROW_PINS_MCU;
pin_t pin = matrix_row_pins_mcu[row];
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
} else {
// select on mcp23017
if (mcp23017_status) { // if there was an error
M keyboards/input_club/k_type/is31fl3733-dual.c => keyboards/input_club/k_type/is31fl3733-dual.c +2 -2
@@ 128,8 128,8 @@ void is31fl3733_write_pwm_buffer(uint8_t bus, uint8_t index) {
void is31fl3733_init_drivers(void) {
#if defined(IS31FL3733_SDB_PIN)
- setPinOutput(IS31FL3733_SDB_PIN);
- writePinHigh(IS31FL3733_SDB_PIN);
+ gpio_set_pin_output(IS31FL3733_SDB_PIN);
+ gpio_write_pin_high(IS31FL3733_SDB_PIN);
#endif
i2c_init(&I2CD1, I2C1_SCL_PIN, I2C1_SDA_PIN);
M keyboards/jae/j01/j01.c => keyboards/jae/j01/j01.c +2 -2
@@ 26,12 26,12 @@ void matrix_init_kb(void) {
// runs once when the firmware starts up
matrix_init_user();
- setPinOutput(E6);
+ gpio_set_pin_output(E6);
}
bool led_update_kb(led_t led_state) {
if(led_update_user(led_state)) {
- writePin(E6, !led_state.caps_lock);
+ gpio_write_pin(E6, !led_state.caps_lock);
}
return true;
M keyboards/jels/jels88/jels88.c => keyboards/jels/jels88/jels88.c +4 -4
@@ 23,16 23,16 @@
#define SCROLL_LED D4
void keyboard_pre_init_kb(void) {
- setPinOutput(CAPS_LED);
- setPinOutput(SCROLL_LED);
+ gpio_set_pin_output(CAPS_LED);
+ gpio_set_pin_output(SCROLL_LED);
keyboard_pre_init_user();
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if (res) {
- writePin(CAPS_LED, led_state.caps_lock);
- writePin(SCROLL_LED, led_state.scroll_lock);
+ gpio_write_pin(CAPS_LED, led_state.caps_lock);
+ gpio_write_pin(SCROLL_LED, led_state.scroll_lock);
}
return res;
}
M keyboards/jian/nsrev2/config.h => keyboards/jian/nsrev2/config.h +14 -14
@@ 57,33 57,33 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// (Doesn't work on mac. There is no num lock, so it will be always off and lit)
#ifdef NUM_NMOSFET
-#define RESET_NUM_LOCK_LED() writePinLow(NUM_LOCK_LED_PIN)
+#define RESET_NUM_LOCK_LED() gpio_write_pin_low(NUM_LOCK_LED_PIN)
#ifdef NUM_INVERT
-#define UPDATE_NUM_LOCK_LED() writePin(NUM_LOCK_LED_PIN, !led_state.num_lock)
+#define UPDATE_NUM_LOCK_LED() gpio_write_pin(NUM_LOCK_LED_PIN, !led_state.num_lock)
#else
-#define UPDATE_NUM_LOCK_LED() writePin(NUM_LOCK_LED_PIN, led_state.num_lock)
+#define UPDATE_NUM_LOCK_LED() gpio_write_pin(NUM_LOCK_LED_PIN, led_state.num_lock)
#endif // NUM_INVERT
#else
-#define RESET_NUM_LOCK_LED() writePinHigh(NUM_LOCK_LED_PIN)
+#define RESET_NUM_LOCK_LED() gpio_write_pin_high(NUM_LOCK_LED_PIN)
#ifdef NUM_INVERT
-#define UPDATE_NUM_LOCK_LED() writePin(NUM_LOCK_LED_PIN, led_state.num_lock)
+#define UPDATE_NUM_LOCK_LED() gpio_write_pin(NUM_LOCK_LED_PIN, led_state.num_lock)
#else
-#define UPDATE_NUM_LOCK_LED() writePin(NUM_LOCK_LED_PIN, !led_state.num_lock)
+#define UPDATE_NUM_LOCK_LED() gpio_write_pin(NUM_LOCK_LED_PIN, !led_state.num_lock)
#endif // NUM_INVERT
#endif // NUM_NMOSFET
#ifdef CAPS_NMOSFET
-#define RESET_CAPS_LOCK_LED() writePinLow(CAPS_LOCK_LED_PIN)
-#define UPDATE_CAPS_LOCK_LED() writePin(CAPS_LOCK_LED_PIN, led_state.caps_lock)
+#define RESET_CAPS_LOCK_LED() gpio_write_pin_low(CAPS_LOCK_LED_PIN)
+#define UPDATE_CAPS_LOCK_LED() gpio_write_pin(CAPS_LOCK_LED_PIN, led_state.caps_lock)
#else
-#define RESET_CAPS_LOCK_LED() writePinHigh(CAPS_LOCK_LED_PIN)
-#define UPDATE_CAPS_LOCK_LED() writePin(CAPS_LOCK_LED_PIN, !led_state.caps_lock)
+#define RESET_CAPS_LOCK_LED() gpio_write_pin_high(CAPS_LOCK_LED_PIN)
+#define UPDATE_CAPS_LOCK_LED() gpio_write_pin(CAPS_LOCK_LED_PIN, !led_state.caps_lock)
#endif // CAPS_NMOSFET
#ifdef SCROLL_NMOSFET
-#define RESET_SCROLL_LOCK_LED() writePinLow(SCROLL_LOCK_LED_PIN)
-#define UPDATE_SCROLL_LOCK_LED() writePin(SCROLL_LOCK_LED_PIN, led_state.scroll_lock)
+#define RESET_SCROLL_LOCK_LED() gpio_write_pin_low(SCROLL_LOCK_LED_PIN)
+#define UPDATE_SCROLL_LOCK_LED() gpio_write_pin(SCROLL_LOCK_LED_PIN, led_state.scroll_lock)
#else
-#define RESET_SCROLL_LOCK_LED() writePinHigh(SCROLL_LOCK_LED_PIN)
-#define UPDATE_SCROLL_LOCK_LED() writePin(SCROLL_LOCK_LED_PIN, !led_state.scroll_lock)
+#define RESET_SCROLL_LOCK_LED() gpio_write_pin_high(SCROLL_LOCK_LED_PIN)
+#define UPDATE_SCROLL_LOCK_LED() gpio_write_pin(SCROLL_LOCK_LED_PIN, !led_state.scroll_lock)
#endif // SCROLL_NMOSFET
M keyboards/jian/nsrev2/nsrev2.c => keyboards/jian/nsrev2/nsrev2.c +3 -3
@@ 36,15 36,15 @@ void suspend_wakeup_init_kb(void) {
void led_init_kb(void)
{
#ifdef NUM_LOCK_LED_PIN
- setPinOutput(NUM_LOCK_LED_PIN);
+ gpio_set_pin_output(NUM_LOCK_LED_PIN);
RESET_NUM_LOCK_LED();
#endif // NUM_LOCK_LED_PIN
#ifdef CAPS_LOCK_LED_PIN
- setPinOutput(CAPS_LOCK_LED_PIN);
+ gpio_set_pin_output(CAPS_LOCK_LED_PIN);
RESET_CAPS_LOCK_LED();
#endif // CAPS_LOCK_LED_PIN
#ifdef SCROLL_LOCK_LED_PIN
- setPinOutput(SCROLL_LOCK_LED_PIN);
+ gpio_set_pin_output(SCROLL_LOCK_LED_PIN);
RESET_SCROLL_LOCK_LED();
#endif // SCROLL_LOCK_LED_PIN
}
M keyboards/jian/rev1/config.h => keyboards/jian/rev1/config.h +14 -14
@@ 39,35 39,35 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// (Doesn't work on mac. There is no num lock, so it will be always off and lit)
#ifdef NUM_NMOSFET
-#define RESET_NUM_LOCK_LED() writePinLow(NUM_LOCK_LED_PIN)
+#define RESET_NUM_LOCK_LED() gpio_write_pin_low(NUM_LOCK_LED_PIN)
#ifdef NUM_INVERT
-#define UPDATE_NUM_LOCK_LED() writePin(NUM_LOCK_LED_PIN, !led_state.num_lock)
+#define UPDATE_NUM_LOCK_LED() gpio_write_pin(NUM_LOCK_LED_PIN, !led_state.num_lock)
#else
-#define UPDATE_NUM_LOCK_LED() writePin(NUM_LOCK_LED_PIN, led_state.num_lock)
+#define UPDATE_NUM_LOCK_LED() gpio_write_pin(NUM_LOCK_LED_PIN, led_state.num_lock)
#endif // NUM_INVERT
#else
-#define RESET_NUM_LOCK_LED() writePinHigh(NUM_LOCK_LED_PIN)
+#define RESET_NUM_LOCK_LED() gpio_write_pin_high(NUM_LOCK_LED_PIN)
#ifdef NUM_INVERT
-#define UPDATE_NUM_LOCK_LED() writePin(NUM_LOCK_LED_PIN, led_state.num_lock)
+#define UPDATE_NUM_LOCK_LED() gpio_write_pin(NUM_LOCK_LED_PIN, led_state.num_lock)
#else
-#define UPDATE_NUM_LOCK_LED() writePin(NUM_LOCK_LED_PIN, !led_state.num_lock)
+#define UPDATE_NUM_LOCK_LED() gpio_write_pin(NUM_LOCK_LED_PIN, !led_state.num_lock)
#endif // NUM_INVERT
#endif // NUM_NMOSFET
#ifdef CAPS_NMOSFET
-#define RESET_CAPS_LOCK_LED() writePinLow(CAPS_LOCK_LED_PIN)
-#define UPDATE_CAPS_LOCK_LED() writePin(CAPS_LOCK_LED_PIN, led_state.caps_lock)
+#define RESET_CAPS_LOCK_LED() gpio_write_pin_low(CAPS_LOCK_LED_PIN)
+#define UPDATE_CAPS_LOCK_LED() gpio_write_pin(CAPS_LOCK_LED_PIN, led_state.caps_lock)
#else
-#define RESET_CAPS_LOCK_LED() writePinHigh(CAPS_LOCK_LED_PIN)
-#define UPDATE_CAPS_LOCK_LED() writePin(CAPS_LOCK_LED_PIN, !led_state.caps_lock)
+#define RESET_CAPS_LOCK_LED() gpio_write_pin_high(CAPS_LOCK_LED_PIN)
+#define UPDATE_CAPS_LOCK_LED() gpio_write_pin(CAPS_LOCK_LED_PIN, !led_state.caps_lock)
#endif // CAPS_NMOSFET
#ifdef SCROLL_NMOSFET
-#define RESET_SCROLL_LOCK_LED() writePinLow(SCROLL_LOCK_LED_PIN)
-#define UPDATE_SCROLL_LOCK_LED() writePin(SCROLL_LOCK_LED_PIN, led_state.scroll_lock)
+#define RESET_SCROLL_LOCK_LED() gpio_write_pin_low(SCROLL_LOCK_LED_PIN)
+#define UPDATE_SCROLL_LOCK_LED() gpio_write_pin(SCROLL_LOCK_LED_PIN, led_state.scroll_lock)
#else
-#define RESET_SCROLL_LOCK_LED() writePinHigh(SCROLL_LOCK_LED_PIN)
-#define UPDATE_SCROLL_LOCK_LED() writePin(SCROLL_LOCK_LED_PIN, !led_state.scroll_lock)
+#define RESET_SCROLL_LOCK_LED() gpio_write_pin_high(SCROLL_LOCK_LED_PIN)
+#define UPDATE_SCROLL_LOCK_LED() gpio_write_pin(SCROLL_LOCK_LED_PIN, !led_state.scroll_lock)
#endif // SCROLL_NMOSFET
#define RGBLIGHT_TIMER
M keyboards/jian/rev1/rev1.c => keyboards/jian/rev1/rev1.c +3 -3
@@ 36,15 36,15 @@ void suspend_wakeup_init_kb(void) {
void led_init_kb(void)
{
#ifdef NUM_LOCK_LED_PIN
- setPinOutput(NUM_LOCK_LED_PIN);
+ gpio_set_pin_output(NUM_LOCK_LED_PIN);
RESET_NUM_LOCK_LED();
#endif // NUM_LOCK_LED_PIN
#ifdef CAPS_LOCK_LED_PIN
- setPinOutput(CAPS_LOCK_LED_PIN);
+ gpio_set_pin_output(CAPS_LOCK_LED_PIN);
RESET_CAPS_LOCK_LED();
#endif // CAPS_LOCK_LED_PIN
#ifdef SCROLL_LOCK_LED_PIN
- setPinOutput(SCROLL_LOCK_LED_PIN);
+ gpio_set_pin_output(SCROLL_LOCK_LED_PIN);
RESET_SCROLL_LOCK_LED();
#endif // SCROLL_LOCK_LED_PIN
}
M keyboards/jian/rev2/config.h => keyboards/jian/rev2/config.h +14 -14
@@ 45,33 45,33 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// (Doesn't work on mac. There is no num lock, so it will be always off and lit)
#ifdef NUM_NMOSFET
-#define RESET_NUM_LOCK_LED() writePinLow(NUM_LOCK_LED_PIN)
+#define RESET_NUM_LOCK_LED() gpio_write_pin_low(NUM_LOCK_LED_PIN)
#ifdef NUM_INVERT
-#define UPDATE_NUM_LOCK_LED() writePin(NUM_LOCK_LED_PIN, !led_state.num_lock)
+#define UPDATE_NUM_LOCK_LED() gpio_write_pin(NUM_LOCK_LED_PIN, !led_state.num_lock)
#else
-#define UPDATE_NUM_LOCK_LED() writePin(NUM_LOCK_LED_PIN, led_state.num_lock)
+#define UPDATE_NUM_LOCK_LED() gpio_write_pin(NUM_LOCK_LED_PIN, led_state.num_lock)
#endif // NUM_INVERT
#else
-#define RESET_NUM_LOCK_LED() writePinHigh(NUM_LOCK_LED_PIN)
+#define RESET_NUM_LOCK_LED() gpio_write_pin_high(NUM_LOCK_LED_PIN)
#ifdef NUM_INVERT
-#define UPDATE_NUM_LOCK_LED() writePin(NUM_LOCK_LED_PIN, led_state.num_lock)
+#define UPDATE_NUM_LOCK_LED() gpio_write_pin(NUM_LOCK_LED_PIN, led_state.num_lock)
#else
-#define UPDATE_NUM_LOCK_LED() writePin(NUM_LOCK_LED_PIN, !led_state.num_lock)
+#define UPDATE_NUM_LOCK_LED() gpio_write_pin(NUM_LOCK_LED_PIN, !led_state.num_lock)
#endif // NUM_INVERT
#endif // NUM_NMOSFET
#ifdef CAPS_NMOSFET
-#define RESET_CAPS_LOCK_LED() writePinLow(CAPS_LOCK_LED_PIN)
-#define UPDATE_CAPS_LOCK_LED() writePin(CAPS_LOCK_LED_PIN, led_state.caps_lock)
+#define RESET_CAPS_LOCK_LED() gpio_write_pin_low(CAPS_LOCK_LED_PIN)
+#define UPDATE_CAPS_LOCK_LED() gpio_write_pin(CAPS_LOCK_LED_PIN, led_state.caps_lock)
#else
-#define RESET_CAPS_LOCK_LED() writePinHigh(CAPS_LOCK_LED_PIN)
-#define UPDATE_CAPS_LOCK_LED() writePin(CAPS_LOCK_LED_PIN, !led_state.caps_lock)
+#define RESET_CAPS_LOCK_LED() gpio_write_pin_high(CAPS_LOCK_LED_PIN)
+#define UPDATE_CAPS_LOCK_LED() gpio_write_pin(CAPS_LOCK_LED_PIN, !led_state.caps_lock)
#endif // CAPS_NMOSFET
#ifdef SCROLL_NMOSFET
-#define RESET_SCROLL_LOCK_LED() writePinLow(SCROLL_LOCK_LED_PIN)
-#define UPDATE_SCROLL_LOCK_LED() writePin(SCROLL_LOCK_LED_PIN, led_state.scroll_lock)
+#define RESET_SCROLL_LOCK_LED() gpio_write_pin_low(SCROLL_LOCK_LED_PIN)
+#define UPDATE_SCROLL_LOCK_LED() gpio_write_pin(SCROLL_LOCK_LED_PIN, led_state.scroll_lock)
#else
-#define RESET_SCROLL_LOCK_LED() writePinHigh(SCROLL_LOCK_LED_PIN)
-#define UPDATE_SCROLL_LOCK_LED() writePin(SCROLL_LOCK_LED_PIN, !led_state.scroll_lock)
+#define RESET_SCROLL_LOCK_LED() gpio_write_pin_high(SCROLL_LOCK_LED_PIN)
+#define UPDATE_SCROLL_LOCK_LED() gpio_write_pin(SCROLL_LOCK_LED_PIN, !led_state.scroll_lock)
#endif // SCROLL_NMOSFET
M keyboards/jian/rev2/rev2.c => keyboards/jian/rev2/rev2.c +3 -3
@@ 36,15 36,15 @@ void suspend_wakeup_init_kb(void) {
void led_init_kb(void)
{
#ifdef NUM_LOCK_LED_PIN
- setPinOutput(NUM_LOCK_LED_PIN);
+ gpio_set_pin_output(NUM_LOCK_LED_PIN);
RESET_NUM_LOCK_LED();
#endif // NUM_LOCK_LED_PIN
#ifdef CAPS_LOCK_LED_PIN
- setPinOutput(CAPS_LOCK_LED_PIN);
+ gpio_set_pin_output(CAPS_LOCK_LED_PIN);
RESET_CAPS_LOCK_LED();
#endif // CAPS_LOCK_LED_PIN
#ifdef SCROLL_LOCK_LED_PIN
- setPinOutput(SCROLL_LOCK_LED_PIN);
+ gpio_set_pin_output(SCROLL_LOCK_LED_PIN);
RESET_SCROLL_LOCK_LED();
#endif // SCROLL_LOCK_LED_PIN
}
M keyboards/jones/v03/matrix.c => keyboards/jones/v03/matrix.c +6 -6
@@ 22,24 22,24 @@ static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static void select_row(uint8_t row) {
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row) {
- setPinInputHigh(row_pins[row]);
+ gpio_set_pin_input_high(row_pins[row]);
}
static void unselect_rows(void) {
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void init_pins(void) {
unselect_rows();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 60,7 60,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
// skip reading when index equals (= pin itself)
if (col_index != current_row) {
// Check col pin pin_state
- if (readPin(col_pins[col_index]) == 0) {
+ if (gpio_read_pin(col_pins[col_index]) == 0) {
// Pin LO, set col bit
current_matrix[current_row] |= (ROW_SHIFTER << col_index);
} else {
M keyboards/jones/v03_1/matrix.c => keyboards/jones/v03_1/matrix.c +6 -6
@@ 22,24 22,24 @@ static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static void select_row(uint8_t row) {
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row) {
- setPinInputHigh(row_pins[row]);
+ gpio_set_pin_input_high(row_pins[row]);
}
static void unselect_rows(void) {
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void init_pins(void) {
unselect_rows();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 60,7 60,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
// skip reading when index equals (= pin itself)
if (col_index != current_row) {
// Check col pin pin_state
- if (readPin(col_pins[col_index]) == 0) {
+ if (gpio_read_pin(col_pins[col_index]) == 0) {
// Pin LO, set col bit
current_matrix[current_row] |= (ROW_SHIFTER << col_index);
} else {
M keyboards/joshajohnson/hub16/matrix.c => keyboards/joshajohnson/hub16/matrix.c +10 -10
@@ 31,22 31,22 @@ extern matrix_row_t raw_matrix[MATRIX_ROWS]; // raw values
extern matrix_row_t matrix[MATRIX_ROWS]; // debounced values
static void select_row(uint8_t row) {
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
-static void unselect_row(uint8_t row) { setPinInputHigh(row_pins[row]); }
+static void unselect_row(uint8_t row) { gpio_set_pin_input_high(row_pins[row]); }
static void unselect_rows(void) {
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void init_pins(void) {
unselect_rows();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 64,7 64,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
@@ 79,8 79,8 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
void matrix_init_custom(void) {
// initialize key pins
- setPinInput(SWITCH_1);
- setPinInput(SWITCH_2);
+ gpio_set_pin_input(SWITCH_1);
+ gpio_set_pin_input(SWITCH_2);
init_pins();
}
@@ 112,8 112,8 @@ static bool read_encoder_switches(matrix_row_t current_matrix[], uint8_t current
bool btn_2_rise = 0;
btn_1_array <<= 1;
btn_2_array <<= 1;
- btn_1_array |= readPin(SWITCH_1);
- btn_2_array |= readPin(SWITCH_2);
+ btn_1_array |= gpio_read_pin(SWITCH_1);
+ btn_2_array |= gpio_read_pin(SWITCH_2);
(btn_1_array == 0b01111111) ? (btn_1_rise = 1) : (btn_1_rise = 0);
(btn_2_array == 0b01111111) ? (btn_2_rise = 1) : (btn_2_rise = 0);
M keyboards/jukaie/jk01/jk01.c => keyboards/jukaie/jk01/jk01.c +6 -6
@@ 132,9 132,9 @@ void spi_init(void) {
is_initialised = true;
// Try releasing special pins for a short time
- setPinInput(SPI_SCK_PIN);
- setPinInput(SPI_MOSI_PIN);
- setPinInput(SPI_MISO_PIN);
+ gpio_set_pin_input(SPI_SCK_PIN);
+ gpio_set_pin_input(SPI_MOSI_PIN);
+ gpio_set_pin_input(SPI_MISO_PIN);
chThdSleepMilliseconds(10);
@@ 147,12 147,12 @@ void spi_init(void) {
#endif
void keyboard_pre_init_kb(void) {
- setPinOutput(C0);
- setPinOutput(C15);
+ gpio_set_pin_output(C0);
+ gpio_set_pin_output(C15);
keyboard_pre_init_user();
};
void housekeeping_task_kb(void) {
- writePin(C15, keymap_config.no_gui);
+ gpio_write_pin(C15, keymap_config.no_gui);
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
M keyboards/kabedon/kabedon980/kabedon980.c => keyboards/kabedon/kabedon980/kabedon980.c +1 -1
@@ 2,7 2,7 @@
bool led_update_kb(led_t led_state) {
if (led_update_user(led_state)) {
- writePin(E6, !led_state.caps_lock);
+ gpio_write_pin(E6, !led_state.caps_lock);
}
return true;
}
M keyboards/kagizaraya/chidori/board.c => keyboards/kagizaraya/chidori/board.c +8 -8
@@ 60,8 60,8 @@ static board_interface_t* get_interface(board_info_t* board) {
static void board_set_master_led(board_info_t* board, uint8_t led_index, bool status) {
pin_t pin = board->led_pins[led_index];
board->led_status[led_index] = status;
- setPinOutput(pin);
- status ? writePinHigh(pin) : writePinLow(pin);
+ gpio_set_pin_output(pin);
+ status ? gpio_write_pin_high(pin) : gpio_write_pin_low(pin);
}
static void board_set_slave_led(board_info_t* board, uint8_t led_index, bool status) {
@@ 254,18 254,18 @@ static bool board_read_cols_on_slave_row(board_info_t* board, matrix_row_t curre
// Functions for master board
//
static void board_select_master_row(board_info_t* board, uint8_t board_row) {
- setPinOutput(board->row_pins[board_row]);
- writePinLow(board->row_pins[board_row]);
+ gpio_set_pin_output(board->row_pins[board_row]);
+ gpio_write_pin_low(board->row_pins[board_row]);
}
-static void board_unselect_master_row(board_info_t* board, uint8_t board_row) { setPinInputHigh(board->row_pins[board_row]); }
+static void board_unselect_master_row(board_info_t* board, uint8_t board_row) { gpio_set_pin_input_high(board->row_pins[board_row]); }
static void board_unselect_master_rows(board_info_t* board) {
if (!board) {
return;
}
for (uint8_t x = 0; x < NUM_ROWS; x++) {
- setPinInput(board->row_pins[x]);
+ gpio_set_pin_input(board->row_pins[x]);
}
}
@@ 281,7 281,7 @@ static bool board_read_cols_on_master_row(board_info_t* board, matrix_row_t curr
wait_us(30);
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
- uint8_t pin_state = readPin(board->col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(board->col_pins[col_index]);
current_matrix[row] |= pin_state ? 0 : (1 << col_index);
}
board_unselect_master_row(board, board_row);
@@ 295,7 295,7 @@ static void board_master_init(void) {
return;
}
for (uint8_t x = 0; x < NUM_COLS; x++) {
- setPinInputHigh(board->col_pins[x]);
+ gpio_set_pin_input_high(board->col_pins[x]);
}
board->initialized = true;
}
M keyboards/kakunpc/angel64/alpha/matrix.c => keyboards/kakunpc/angel64/alpha/matrix.c +12 -12
@@ 105,37 105,37 @@ void matrix_print(void)
static void select_row(uint8_t row)
{
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row)
{
- setPinInputHigh(row_pins[row]);
+ gpio_set_pin_input_high(row_pins[row]);
}
static void unselect_rows(void)
{
for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void select_col(uint8_t col)
{
- setPinOutput(col_pins[col]);
- writePinLow(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
- setPinInputHigh(col_pins[col]);
+ gpio_set_pin_input_high(col_pins[col]);
}
static void unselect_cols(void)
{
for(uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 143,10 143,10 @@ static void init_pins(void) {
unselect_rows();
unselect_cols();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
@@ 166,7 166,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index);
@@ 194,7 194,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[tmp];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0)
+ if (gpio_read_pin(row_pins[row_index]) == 0)
{
// Pin LO, set col bit
current_matrix[tmp] |= (ROW_SHIFTER << current_col);
M keyboards/kakunpc/angel64/rev1/matrix.c => keyboards/kakunpc/angel64/rev1/matrix.c +12 -12
@@ 105,37 105,37 @@ void matrix_print(void)
static void select_row(uint8_t row)
{
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row)
{
- setPinInputHigh(row_pins[row]);
+ gpio_set_pin_input_high(row_pins[row]);
}
static void unselect_rows(void)
{
for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void select_col(uint8_t col)
{
- setPinOutput(col_pins[col]);
- writePinLow(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
- setPinInputHigh(col_pins[col]);
+ gpio_set_pin_input_high(col_pins[col]);
}
static void unselect_cols(void)
{
for(uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 143,10 143,10 @@ static void init_pins(void) {
unselect_rows();
unselect_cols();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
@@ 166,7 166,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index);
@@ 194,7 194,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[tmp];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0)
+ if (gpio_read_pin(row_pins[row_index]) == 0)
{
// Pin LO, set col bit
current_matrix[tmp] |= (ROW_SHIFTER << current_col);
M keyboards/kakunpc/choc_taro/matrix.c => keyboards/kakunpc/choc_taro/matrix.c +12 -12
@@ 28,32 28,32 @@ static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static void select_row(uint8_t row) {
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row) {
- setPinInputHigh(row_pins[row]);
+ gpio_set_pin_input_high(row_pins[row]);
}
static void unselect_rows(void) {
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void select_col(uint8_t col) {
- setPinOutput(col_pins[col]);
- writePinLow(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
static void unselect_col(uint8_t col) {
- setPinInputHigh(col_pins[col]);
+ gpio_set_pin_input_high(col_pins[col]);
}
static void unselect_cols(void) {
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 62,11 62,11 @@ static void init_pins(void) {
unselect_cols();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
@@ 85,7 85,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index);
@@ 111,7 111,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[tmp];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0) {
+ if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_matrix[tmp] |= (ROW_SHIFTER << current_col);
} else {
M keyboards/kakunpc/thedogkeyboard/matrix.c => keyboards/kakunpc/thedogkeyboard/matrix.c +12 -12
@@ 105,37 105,37 @@ void matrix_print(void)
static void select_row(uint8_t row)
{
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row)
{
- setPinInputHigh(row_pins[row]);
+ gpio_set_pin_input_high(row_pins[row]);
}
static void unselect_rows(void)
{
for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void select_col(uint8_t col)
{
- setPinOutput(col_pins[col]);
- writePinLow(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
- setPinInputHigh(col_pins[col]);
+ gpio_set_pin_input_high(col_pins[col]);
}
static void unselect_cols(void)
{
for(uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 143,10 143,10 @@ static void init_pins(void) {
unselect_rows();
unselect_cols();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
@@ 166,7 166,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index);
@@ 194,7 194,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[tmp];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0)
+ if (gpio_read_pin(row_pins[row_index]) == 0)
{
// Pin LO, set col bit
current_matrix[tmp] |= (ROW_SHIFTER << current_col);
M keyboards/kbdfans/bella/soldered/soldered.c => keyboards/kbdfans/bella/soldered/soldered.c +2 -2
@@ 15,14 15,14 @@
*/
#include "quantum.h"
void matrix_init_kb(void) {
- setPinOutput(E6);
+ gpio_set_pin_output(E6);
matrix_init_user();
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(E6, !led_state.caps_lock);
+ gpio_write_pin(E6, !led_state.caps_lock);
}
return res;
}
M keyboards/kbdfans/kbd19x/kbd19x.h => keyboards/kbdfans/kbd19x/kbd19x.h +6 -6
@@ 20,11 20,11 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "quantum.h"
#include "led.h"
-inline void kbd19x_caps_led_on(void) { writePinHigh(LED_CAPS_LOCK_PIN); }
-inline void kbd19x_caps_led_off(void) { writePinLow(LED_CAPS_LOCK_PIN); }
+inline void kbd19x_caps_led_on(void) { gpio_write_pin_high(LED_CAPS_LOCK_PIN); }
+inline void kbd19x_caps_led_off(void) { gpio_write_pin_low(LED_CAPS_LOCK_PIN); }
-inline void kbd19x_sclk_led_on(void) { writePinHigh(LED_SCROLL_LOCK_PIN); }
-inline void kbd19x_sclk_led_off(void) { writePinLow(LED_SCROLL_LOCK_PIN); }
+inline void kbd19x_sclk_led_on(void) { gpio_write_pin_high(LED_SCROLL_LOCK_PIN); }
+inline void kbd19x_sclk_led_off(void) { gpio_write_pin_low(LED_SCROLL_LOCK_PIN); }
-inline void kbd19x_nmlk_led_on(void) { writePinHigh(LED_NUM_LOCK_PIN); }
-inline void kbd19x_nmlk_led_off(void) { writePinLow(LED_NUM_LOCK_PIN); }
+inline void kbd19x_nmlk_led_on(void) { gpio_write_pin_high(LED_NUM_LOCK_PIN); }
+inline void kbd19x_nmlk_led_off(void) { gpio_write_pin_low(LED_NUM_LOCK_PIN); }
M keyboards/kbdfans/kbd8x/kbd8x.h => keyboards/kbdfans/kbd8x/kbd8x.h +6 -6
@@ 19,11 19,11 @@
#include "led.h"
// Functions for setting LEDs on toggle keys
-inline void caps_led_on(void) { writePinHigh(LED_CAPS_LOCK_PIN); }
-inline void caps_led_off(void) { writePinLow(LED_CAPS_LOCK_PIN); }
+inline void caps_led_on(void) { gpio_write_pin_high(LED_CAPS_LOCK_PIN); }
+inline void caps_led_off(void) { gpio_write_pin_low(LED_CAPS_LOCK_PIN); }
-inline void num_led_on(void) { writePinHigh(LED_NUM_LOCK_PIN); }
-inline void num_led_off(void) { writePinLow(LED_NUM_LOCK_PIN); }
+inline void num_led_on(void) { gpio_write_pin_high(LED_NUM_LOCK_PIN); }
+inline void num_led_off(void) { gpio_write_pin_low(LED_NUM_LOCK_PIN); }
-inline void scroll_led_on(void) { writePinHigh(LED_SCROLL_LOCK_PIN); }
-inline void scroll_led_off(void) { writePinLow(LED_SCROLL_LOCK_PIN); }
+inline void scroll_led_on(void) { gpio_write_pin_high(LED_SCROLL_LOCK_PIN); }
+inline void scroll_led_off(void) { gpio_write_pin_low(LED_SCROLL_LOCK_PIN); }
M keyboards/kbdfans/maja_soldered/maja_soldered.c => keyboards/kbdfans/maja_soldered/maja_soldered.c +2 -2
@@ 16,14 16,14 @@
#include "quantum.h"
void matrix_init_kb(void) {
- setPinOutput(D4);
+ gpio_set_pin_output(D4);
matrix_init_user();
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(D4, !led_state.caps_lock);
+ gpio_write_pin(D4, !led_state.caps_lock);
}
return res;
}
M keyboards/kbdfans/niu_mini/niu_mini.c => keyboards/kbdfans/niu_mini/niu_mini.c +2 -2
@@ 12,8 12,8 @@ const keypos_t PROGMEM hand_swap_config[MATRIX_ROWS][MATRIX_COLS] = {
void matrix_init_kb(void) {
// Turn status LED on
- setPinOutput(E6);
- writePinHigh(E6);
+ gpio_set_pin_output(E6);
+ gpio_write_pin_high(E6);
matrix_init_user();
}
M keyboards/kbdfans/phaseone/phaseone.c => keyboards/kbdfans/phaseone/phaseone.c +1 -1
@@ 17,5 17,5 @@
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(D4);
+ gpio_set_pin_output(D4);
}
M keyboards/kbdmania/kmac/kmac.c => keyboards/kbdmania/kmac/kmac.c +15 -15
@@ 19,11 19,11 @@
#define WASD_MASK 0b10
void backlight_init_ports(void) {
- setPinOutput(B1);
- setPinOutput(B2);
- setPinOutput(B3);
- setPinOutput(B4);
- setPinOutput(D7);
+ gpio_set_pin_output(B1);
+ gpio_set_pin_output(B2);
+ gpio_set_pin_output(B3);
+ gpio_set_pin_output(B4);
+ gpio_set_pin_output(D7);
}
/* Backlight pin configuration
@@ 36,21 36,21 @@ void backlight_init_ports(void) {
void backlight_set(uint8_t level) {
// F-row
if (level & F_ROW_MASK) {
- writePinHigh(B1);
+ gpio_write_pin_high(B1);
} else {
- writePinLow(B1);
+ gpio_write_pin_low(B1);
}
// WASD
if (level & WASD_MASK) {
- writePinLow(B2);
- writePinLow(B3);
- writePinLow(B4);
- writePinLow(D7);
+ gpio_write_pin_low(B2);
+ gpio_write_pin_low(B3);
+ gpio_write_pin_low(B4);
+ gpio_write_pin_low(D7);
} else {
- writePinHigh(B2);
- writePinHigh(B3);
- writePinHigh(B4);
- writePinHigh(D7);
+ gpio_write_pin_high(B2);
+ gpio_write_pin_high(B3);
+ gpio_write_pin_high(B4);
+ gpio_write_pin_high(D7);
}
}
M keyboards/kbdmania/kmac/matrix.c => keyboards/kbdmania/kmac/matrix.c +12 -12
@@ 94,8 94,8 @@ void matrix_print(void) {
*/
static void unselect_cols(void) {
for (uint8_t x = 0; x < 6; x++) {
- setPinOutput(col_pins[x]);
- writePinLow(col_pins[x]);
+ gpio_set_pin_output(col_pins[x]);
+ gpio_write_pin_low(col_pins[x]);
}
}
@@ 103,13 103,13 @@ static void select_col(uint8_t col) {
if (col < 16) {
uint8_t c = col + 8;
- writePin(B6, c & 0b10000);
- writePin(C6, c & 0b01000);
- writePin(C7, c & 0b00100);
- writePin(F1, c & 0b00010);
- writePin(F0, c & 0b00001);
+ gpio_write_pin(B6, c & 0b10000);
+ gpio_write_pin(C6, c & 0b01000);
+ gpio_write_pin(C7, c & 0b00100);
+ gpio_write_pin(F1, c & 0b00010);
+ gpio_write_pin(F0, c & 0b00001);
} else {
- writePinHigh(B5);
+ gpio_write_pin_high(B5);
}
}
@@ 122,10 122,10 @@ static void select_col(uint8_t col) {
static void init_pins(void) {
unselect_cols();
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
- setPinInputHigh(E2);
+ gpio_set_pin_input_high(E2);
}
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
@@ 143,7 143,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
// Check row pin state
// Use the otherwise unused row: 3, col: 0 for caps lock
if (row_index == 3 && current_col == 0) {
- if (readPin(E2) == 0) {
+ if (gpio_read_pin(E2) == 0) {
// Pin LO, set col bit
current_matrix[row_index] |= (ROW_SHIFTER << current_col);
} else {
@@ 151,7 151,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
}
} else {
- if (readPin(row_pins[row_index]) == 0) {
+ if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin HI, clear col bit
current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
} else {
M keyboards/kbdmania/kmac_pad/kmac_pad.c => keyboards/kbdmania/kmac_pad/kmac_pad.c +2 -2
@@ 23,7 23,7 @@ void keyboard_pre_init_kb(void) {
* FN Pin PB3
* PAD Pin PB1
*/
- setPinOutput(B3);
- setPinOutput(B1);
+ gpio_set_pin_output(B3);
+ gpio_set_pin_output(B1);
keyboard_pre_init_user();
}
M keyboards/kbdmania/kmac_pad/matrix.c => keyboards/kbdmania/kmac_pad/matrix.c +6 -6
@@ 30,13 30,13 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
*/
static void unselect_cols(void) {
for (uint8_t col = 0; col < MATRIX_COLS; col++) {
- setPinOutput(col_pins[col]);
- writePinLow(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
}
static void select_col(uint8_t col) {
- writePinHigh(col_pins[col]);
+ gpio_write_pin_high(col_pins[col]);
}
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
@@ 50,7 50,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
if (current_col == 0) {
matrix_row_t last_row_value = current_matrix[0];
- if (readPin(row_pins[0]) == 0) {
+ if (gpio_read_pin(row_pins[0]) == 0) {
// Pin LO, set col bit
current_matrix[0] |= (1 << current_col);
} else {
@@ 68,7 68,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
for (uint8_t row_index = 1; row_index < MATRIX_ROWS; row_index++) {
matrix_row_t last_row_value = current_matrix[row_index];
- if (readPin(row_pins[row_index]) == 0) {
+ if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin HI, clear col bit
current_matrix[row_index] &= ~(1 << current_col);
} else {
@@ 95,7 95,7 @@ void matrix_init_custom(void) {
// initialize key pins
for (uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++) {
- setPinInputHigh(row_pins[row_index]);
+ gpio_set_pin_input_high(row_pins[row_index]);
}
}
M keyboards/kc60/kc60.c => keyboards/kc60/kc60.c +2 -2
@@ 2,8 2,8 @@
void led_update_ports(led_t led_state) {
if (led_state.caps_lock) {
- setPinOutput(B2);
+ gpio_set_pin_output(B2);
} else {
- setPinInput(B2);
+ gpio_set_pin_input(B2);
}
}
M keyboards/kc60se/kc60se.c => keyboards/kc60se/kc60se.c +2 -2
@@ 17,13 17,13 @@
#include "quantum.h"
void matrix_init_kb(void){
- setPinOutput(B2);
+ gpio_set_pin_output(B2);
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(B2, !led_state.caps_lock);
+ gpio_write_pin(B2, !led_state.caps_lock);
}
return res;
}
M keyboards/keebio/kbo5000/rev1/rev1.c => keyboards/keebio/kbo5000/rev1/rev1.c +2 -2
@@ 2,14 2,14 @@
#include "split_util.h"
void matrix_init_kb(void) {
- setPinOutput(CAPS_LOCK_LED_PIN);
+ gpio_set_pin_output(CAPS_LOCK_LED_PIN);
matrix_init_user();
}
bool led_update_kb(led_t led_state) {
// Only update if left half
if (isLeftHand && led_update_user(led_state)) {
- writePin(CAPS_LOCK_LED_PIN, !led_state.caps_lock);
+ gpio_write_pin(CAPS_LOCK_LED_PIN, !led_state.caps_lock);
}
return true;
}
M keyboards/keebio/quefrency/rev2/rev2.c => keyboards/keebio/quefrency/rev2/rev2.c +2 -2
@@ 2,14 2,14 @@
#include "split_util.h"
void matrix_init_kb(void) {
- setPinOutput(CAPS_LOCK_LED_PIN);
+ gpio_set_pin_output(CAPS_LOCK_LED_PIN);
matrix_init_user();
}
bool led_update_kb(led_t led_state) {
// Only update if left half
if (isLeftHand && led_update_user(led_state)) {
- writePin(CAPS_LOCK_LED_PIN, !led_state.caps_lock);
+ gpio_write_pin(CAPS_LOCK_LED_PIN, !led_state.caps_lock);
}
return true;
}
M keyboards/keebio/quefrency/rev3/rev3.c => keyboards/keebio/quefrency/rev3/rev3.c +2 -2
@@ 18,14 18,14 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "split_util.h"
void matrix_init_kb(void) {
- setPinOutput(CAPS_LOCK_LED_PIN);
+ gpio_set_pin_output(CAPS_LOCK_LED_PIN);
matrix_init_user();
}
bool led_update_kb(led_t led_state) {
// Only update if left half
if (led_update_user(led_state) && isLeftHand) {
- writePin(CAPS_LOCK_LED_PIN, !led_state.caps_lock);
+ gpio_write_pin(CAPS_LOCK_LED_PIN, !led_state.caps_lock);
}
return true;
}
M keyboards/keebio/sinc/sinc.c => keyboards/keebio/sinc/sinc.c +1 -1
@@ 22,7 22,7 @@ bool led_update_kb(led_t led_state) {
if (!led_update_user(led_state)) { return false; }
// Only update if left half
if (isLeftHand && led_update_user(led_state)) {
- writePin(LED_CAPS_LOCK_PIN, !led_state.caps_lock);
+ gpio_write_pin(LED_CAPS_LOCK_PIN, !led_state.caps_lock);
}
return true;
}
M keyboards/keychron/c2_pro/matrix.c => keyboards/keychron/c2_pro/matrix.c +15 -15
@@ 43,27 43,27 @@ pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinOutput_writeHigh(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinHigh(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_high(pin);
}
}
static inline void setPinInput_high(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
static inline uint8_t readMatrixPin(pin_t pin) {
if (pin != NO_PIN) {
- return readPin(pin);
+ return gpio_read_pin(pin);
} else {
return 1;
}
@@ 81,13 81,13 @@ static void HC595_output(SIZE_T data, uint8_t bit) {
ATOMIC_BLOCK_FORCEON {
for (uint8_t i = 0; i < (SHIFT_COL_END - SHIFT_COL_START + 1); i++) {
if (data & 0x1) {
- writePinHigh(HC595_DS);
+ gpio_write_pin_high(HC595_DS);
} else {
- writePinLow(HC595_DS);
+ gpio_write_pin_low(HC595_DS);
}
- writePinHigh(HC595_SHCP);
+ gpio_write_pin_high(HC595_SHCP);
HC595_delay(n);
- writePinLow(HC595_SHCP);
+ gpio_write_pin_low(HC595_SHCP);
HC595_delay(n);
if (bit) {
break;
@@ 95,9 95,9 @@ static void HC595_output(SIZE_T data, uint8_t bit) {
data = data >> 1;
}
}
- writePinHigh(HC595_STCP);
+ gpio_write_pin_high(HC595_STCP);
HC595_delay(n);
- writePinLow(HC595_STCP);
+ gpio_write_pin_low(HC595_STCP);
HC595_delay(n);
}
}
@@ 175,9 175,9 @@ static void matrix_read_rows_on_col(matrix_row_t current_matrix[], uint8_t curre
}
void matrix_init_custom(void) {
- setPinOutput(HC595_DS);
- setPinOutput(HC595_STCP);
- setPinOutput(HC595_SHCP);
+ gpio_set_pin_output(HC595_DS);
+ gpio_set_pin_output(HC595_STCP);
+ gpio_set_pin_output(HC595_SHCP);
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
if (row_pins[x] != NO_PIN) {
M keyboards/keychron/q10/matrix.c => keyboards/keychron/q10/matrix.c +6 -6
@@ 36,27 36,27 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinOutput_writeHigh(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinHigh(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_high(pin);
}
}
static inline void setPinInputHigh_atomic(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
static inline uint8_t readMatrixPin(pin_t pin) {
if (pin != NO_PIN) {
- return readPin(pin);
+ return gpio_read_pin(pin);
} else {
return 1;
}
M keyboards/keychron/q11/q11.c => keyboards/keychron/q11/q11.c +4 -4
@@ 130,12 130,12 @@ void keyboard_post_init_kb(void) {
// and disable USB connectivity when the ADC value exceeds 1000,
// to avoid affecting the serial usart communication between the left hand and the right hand.
if (is_keyboard_left()) {
- setPinOutput(A0);
- writePinHigh(A0);
+ gpio_set_pin_output(A0);
+ gpio_write_pin_high(A0);
} else {
if ((analogReadPin_my(B0) > 1000) || (analogReadPin_my(B1) > 1000)) {
- setPinInput(A11);
- setPinInput(A12);
+ gpio_set_pin_input(A11);
+ gpio_set_pin_input(A12);
}
}
M keyboards/keychron/q12/matrix.c => keyboards/keychron/q12/matrix.c +6 -6
@@ 36,27 36,27 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinOutput_writeHigh(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinHigh(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_high(pin);
}
}
static inline void setPinInputHigh_atomic(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
static inline uint8_t readMatrixPin(pin_t pin) {
if (pin != NO_PIN) {
- return readPin(pin);
+ return gpio_read_pin(pin);
} else {
return 1;
}
M keyboards/keychron/q1v2/matrix.c => keyboards/keychron/q1v2/matrix.c +6 -6
@@ 36,27 36,27 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinOutput_writeHigh(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinHigh(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_high(pin);
}
}
static inline void setPinInputHigh_atomic(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
static inline uint8_t readMatrixPin(pin_t pin) {
if (pin != NO_PIN) {
- return readPin(pin);
+ return gpio_read_pin(pin);
} else {
return 1;
}
M keyboards/keychron/q3/matrix.c => keyboards/keychron/q3/matrix.c +6 -6
@@ 36,27 36,27 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinOutput_writeHigh(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinHigh(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_high(pin);
}
}
static inline void setPinInputHigh_atomic(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
static inline uint8_t readMatrixPin(pin_t pin) {
if (pin != NO_PIN) {
- return readPin(pin);
+ return gpio_read_pin(pin);
} else {
return 1;
}
M keyboards/keychron/q5/matrix.c => keyboards/keychron/q5/matrix.c +6 -6
@@ 36,27 36,27 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinOutput_writeHigh(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinHigh(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_high(pin);
}
}
static inline void setPinInputHigh_atomic(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
static inline uint8_t readMatrixPin(pin_t pin) {
if (pin != NO_PIN) {
- return readPin(pin);
+ return gpio_read_pin(pin);
} else {
return 1;
}
M keyboards/keychron/q6/matrix.c => keyboards/keychron/q6/matrix.c +6 -6
@@ 48,27 48,27 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinOutput_writeHigh(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinHigh(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_high(pin);
}
}
static inline void setPinInputHigh_atomic(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
static inline uint8_t readMatrixPin(pin_t pin) {
if (pin != NO_PIN) {
- return readPin(pin);
+ return gpio_read_pin(pin);
} else {
return 1;
}
M keyboards/keychron/q65/matrix.c => keyboards/keychron/q65/matrix.c +22 -22
@@ 36,32 36,32 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static inline void writePinLow_atomic(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- writePinLow(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void writePinHigh_atomic(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- writePinHigh(pin);
+ gpio_write_pin_high(pin);
}
}
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinInputHigh_atomic(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
static inline uint8_t readMatrixPin(pin_t pin) {
if (pin != NO_PIN) {
- return readPin(pin);
+ return gpio_read_pin(pin);
} else {
return 1;
}
@@ 76,20 76,20 @@ static void shiftOut(uint8_t dataOut) {
for (uint8_t i = 0; i < 8; i++) {
compiler_barrier();
if (dataOut & 0x1) {
- writePinHigh(DATA_PIN);
+ gpio_write_pin_high(DATA_PIN);
} else {
- writePinLow(DATA_PIN);
+ gpio_write_pin_low(DATA_PIN);
}
dataOut = dataOut >> 1;
compiler_barrier();
- writePinHigh(CLOCK_PIN);
+ gpio_write_pin_high(CLOCK_PIN);
small_delay();
- writePinLow(CLOCK_PIN);
+ gpio_write_pin_low(CLOCK_PIN);
}
compiler_barrier();
- writePinHigh(LATCH_PIN);
+ gpio_write_pin_high(LATCH_PIN);
small_delay();
- writePinLow(LATCH_PIN);
+ gpio_write_pin_low(LATCH_PIN);
compiler_barrier();
}
}
@@ 98,18 98,18 @@ static void shiftout_single(uint8_t data) {
ATOMIC_BLOCK_FORCEON {
compiler_barrier();
if (data & 0x1) {
- writePinHigh(DATA_PIN);
+ gpio_write_pin_high(DATA_PIN);
} else {
- writePinLow(DATA_PIN);
+ gpio_write_pin_low(DATA_PIN);
}
compiler_barrier();
- writePinHigh(CLOCK_PIN);
+ gpio_write_pin_high(CLOCK_PIN);
small_delay();
- writePinLow(CLOCK_PIN);
+ gpio_write_pin_low(CLOCK_PIN);
compiler_barrier();
- writePinHigh(LATCH_PIN);
+ gpio_write_pin_high(LATCH_PIN);
small_delay();
- writePinLow(LATCH_PIN);
+ gpio_write_pin_low(LATCH_PIN);
compiler_barrier();
}
}
@@ 165,13 165,13 @@ static void unselect_cols(void) {
}
static void matrix_init_pins(void) {
- setPinOutput(DATA_PIN);
- setPinOutput(CLOCK_PIN);
- setPinOutput(LATCH_PIN);
+ gpio_set_pin_output(DATA_PIN);
+ gpio_set_pin_output(CLOCK_PIN);
+ gpio_set_pin_output(LATCH_PIN);
#ifdef MATRIX_UNSELECT_DRIVE_HIGH
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
if (col_pins[x] != NO_PIN) {
- setPinOutput(col_pins[x]);
+ gpio_set_pin_output(col_pins[x]);
}
}
#endif
M keyboards/keychron/v1/matrix.c => keyboards/keychron/v1/matrix.c +22 -22
@@ 36,27 36,27 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinOutput_writeHigh(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinHigh(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_high(pin);
}
}
static inline void setPinInputHigh_atomic(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
static inline uint8_t readMatrixPin(pin_t pin) {
if (pin != NO_PIN) {
- return readPin(pin);
+ return gpio_read_pin(pin);
} else {
return 1;
}
@@ 71,20 71,20 @@ static void shiftOut(uint8_t dataOut) {
for (uint8_t i = 0; i < 8; i++) {
compiler_barrier();
if (dataOut & 0x1) {
- writePinHigh(DATA_PIN);
+ gpio_write_pin_high(DATA_PIN);
} else {
- writePinLow(DATA_PIN);
+ gpio_write_pin_low(DATA_PIN);
}
dataOut = dataOut >> 1;
compiler_barrier();
- writePinHigh(CLOCK_PIN);
+ gpio_write_pin_high(CLOCK_PIN);
small_delay();
- writePinLow(CLOCK_PIN);
+ gpio_write_pin_low(CLOCK_PIN);
}
compiler_barrier();
- writePinHigh(LATCH_PIN);
+ gpio_write_pin_high(LATCH_PIN);
small_delay();
- writePinLow(LATCH_PIN);
+ gpio_write_pin_low(LATCH_PIN);
compiler_barrier();
}
}
@@ 93,18 93,18 @@ static void shiftOut_single(uint8_t data) {
ATOMIC_BLOCK_FORCEON {
compiler_barrier();
if (data & 0x1) {
- writePinHigh(DATA_PIN);
+ gpio_write_pin_high(DATA_PIN);
} else {
- writePinLow(DATA_PIN);
+ gpio_write_pin_low(DATA_PIN);
}
compiler_barrier();
- writePinHigh(CLOCK_PIN);
+ gpio_write_pin_high(CLOCK_PIN);
small_delay();
- writePinLow(CLOCK_PIN);
+ gpio_write_pin_low(CLOCK_PIN);
compiler_barrier();
- writePinHigh(LATCH_PIN);
+ gpio_write_pin_high(LATCH_PIN);
small_delay();
- writePinLow(LATCH_PIN);
+ gpio_write_pin_low(LATCH_PIN);
compiler_barrier();
}
}
@@ 156,13 156,13 @@ static void unselect_cols(void) {
}
static void matrix_init_pins(void) {
- setPinOutput(DATA_PIN);
- setPinOutput(CLOCK_PIN);
- setPinOutput(LATCH_PIN);
+ gpio_set_pin_output(DATA_PIN);
+ gpio_set_pin_output(CLOCK_PIN);
+ gpio_set_pin_output(LATCH_PIN);
#ifdef MATRIX_UNSELECT_DRIVE_HIGH
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
if (col_pins[x] != NO_PIN) {
- setPinOutput(col_pins[x]);
+ gpio_set_pin_output(col_pins[x]);
}
}
#endif
M keyboards/keychron/v10/matrix.c => keyboards/keychron/v10/matrix.c +22 -22
@@ 36,27 36,27 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinOutput_writeHigh(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinHigh(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_high(pin);
}
}
static inline void setPinInputHigh_atomic(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
static inline uint8_t readMatrixPin(pin_t pin) {
if (pin != NO_PIN) {
- return readPin(pin);
+ return gpio_read_pin(pin);
} else {
return 1;
}
@@ 70,34 70,34 @@ static void shiftOut(uint16_t dataOut) {
ATOMIC_BLOCK_FORCEON {
for (uint8_t i = 0; i < PIN_USED_74HC595; i++) {
if (dataOut & 0x1) {
- writePinHigh(DATA_PIN_74HC595);
+ gpio_write_pin_high(DATA_PIN_74HC595);
} else {
- writePinLow(DATA_PIN_74HC595);
+ gpio_write_pin_low(DATA_PIN_74HC595);
}
dataOut = dataOut >> 1;
- writePinHigh(CLOCK_PIN_74HC595);
+ gpio_write_pin_high(CLOCK_PIN_74HC595);
small_delay(2);
- writePinLow(CLOCK_PIN_74HC595);
+ gpio_write_pin_low(CLOCK_PIN_74HC595);
}
- writePinHigh(LATCH_PIN_74HC595);
+ gpio_write_pin_high(LATCH_PIN_74HC595);
small_delay(2);
- writePinLow(LATCH_PIN_74HC595);
+ gpio_write_pin_low(LATCH_PIN_74HC595);
}
}
static void shiftOut_single(uint8_t data) {
ATOMIC_BLOCK_FORCEON {
if (data & 0x1) {
- writePinHigh(DATA_PIN_74HC595);
+ gpio_write_pin_high(DATA_PIN_74HC595);
} else {
- writePinLow(DATA_PIN_74HC595);
+ gpio_write_pin_low(DATA_PIN_74HC595);
}
- writePinHigh(CLOCK_PIN_74HC595);
+ gpio_write_pin_high(CLOCK_PIN_74HC595);
small_delay(2);
- writePinLow(CLOCK_PIN_74HC595);
- writePinHigh(LATCH_PIN_74HC595);
+ gpio_write_pin_low(CLOCK_PIN_74HC595);
+ gpio_write_pin_high(LATCH_PIN_74HC595);
small_delay(2);
- writePinLow(LATCH_PIN_74HC595);
+ gpio_write_pin_low(LATCH_PIN_74HC595);
}
}
@@ 149,13 149,13 @@ static void unselect_cols(void) {
}
static void matrix_init_pins(void) {
- setPinOutput(DATA_PIN_74HC595);
- setPinOutput(CLOCK_PIN_74HC595);
- setPinOutput(LATCH_PIN_74HC595);
+ gpio_set_pin_output(DATA_PIN_74HC595);
+ gpio_set_pin_output(CLOCK_PIN_74HC595);
+ gpio_set_pin_output(LATCH_PIN_74HC595);
#ifdef MATRIX_UNSELECT_DRIVE_HIGH
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
if (col_pins[x] != NO_PIN) {
- setPinOutput(col_pins[x]);
+ gpio_set_pin_output(col_pins[x]);
}
}
#endif
M keyboards/keychron/v3/matrix.c => keyboards/keychron/v3/matrix.c +22 -22
@@ 36,27 36,27 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinOutput_writeHigh(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinHigh(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_high(pin);
}
}
static inline void setPinInputHigh_atomic(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
static inline uint8_t readMatrixPin(pin_t pin) {
if (pin != NO_PIN) {
- return readPin(pin);
+ return gpio_read_pin(pin);
} else {
return 1;
}
@@ 71,20 71,20 @@ static void shiftOut(uint8_t dataOut) {
for (uint8_t i = 0; i < 8; i++) {
compiler_barrier();
if (dataOut & 0x1) {
- writePinHigh(DATA_PIN);
+ gpio_write_pin_high(DATA_PIN);
} else {
- writePinLow(DATA_PIN);
+ gpio_write_pin_low(DATA_PIN);
}
dataOut = dataOut >> 1;
compiler_barrier();
- writePinHigh(CLOCK_PIN);
+ gpio_write_pin_high(CLOCK_PIN);
small_delay();
- writePinLow(CLOCK_PIN);
+ gpio_write_pin_low(CLOCK_PIN);
}
compiler_barrier();
- writePinHigh(LATCH_PIN);
+ gpio_write_pin_high(LATCH_PIN);
small_delay();
- writePinLow(LATCH_PIN);
+ gpio_write_pin_low(LATCH_PIN);
compiler_barrier();
}
}
@@ 93,18 93,18 @@ static void shiftOut_single(uint8_t data) {
ATOMIC_BLOCK_FORCEON {
compiler_barrier();
if (data & 0x1) {
- writePinHigh(DATA_PIN);
+ gpio_write_pin_high(DATA_PIN);
} else {
- writePinLow(DATA_PIN);
+ gpio_write_pin_low(DATA_PIN);
}
compiler_barrier();
- writePinHigh(CLOCK_PIN);
+ gpio_write_pin_high(CLOCK_PIN);
small_delay();
- writePinLow(CLOCK_PIN);
+ gpio_write_pin_low(CLOCK_PIN);
compiler_barrier();
- writePinHigh(LATCH_PIN);
+ gpio_write_pin_high(LATCH_PIN);
small_delay();
- writePinLow(LATCH_PIN);
+ gpio_write_pin_low(LATCH_PIN);
compiler_barrier();
}
}
@@ 156,13 156,13 @@ static void unselect_cols(void) {
}
static void matrix_init_pins(void) {
- setPinOutput(DATA_PIN);
- setPinOutput(CLOCK_PIN);
- setPinOutput(LATCH_PIN);
+ gpio_set_pin_output(DATA_PIN);
+ gpio_set_pin_output(CLOCK_PIN);
+ gpio_set_pin_output(LATCH_PIN);
#ifdef MATRIX_UNSELECT_DRIVE_HIGH
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
if (col_pins[x] != NO_PIN) {
- setPinOutput(col_pins[x]);
+ gpio_set_pin_output(col_pins[x]);
}
}
#endif
M keyboards/keychron/v5/matrix.c => keyboards/keychron/v5/matrix.c +22 -22
@@ 36,27 36,27 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinOutput_writeHigh(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinHigh(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_high(pin);
}
}
static inline void setPinInputHigh_atomic(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
static inline uint8_t readMatrixPin(pin_t pin) {
if (pin != NO_PIN) {
- return readPin(pin);
+ return gpio_read_pin(pin);
} else {
return 1;
}
@@ 71,20 71,20 @@ static void shiftOut(uint8_t dataOut) {
for (uint8_t i = 0; i < 8; i++) {
compiler_barrier();
if (dataOut & 0x1) {
- writePinHigh(DATA_PIN);
+ gpio_write_pin_high(DATA_PIN);
} else {
- writePinLow(DATA_PIN);
+ gpio_write_pin_low(DATA_PIN);
}
dataOut = dataOut >> 1;
compiler_barrier();
- writePinHigh(CLOCK_PIN);
+ gpio_write_pin_high(CLOCK_PIN);
small_delay();
- writePinLow(CLOCK_PIN);
+ gpio_write_pin_low(CLOCK_PIN);
}
compiler_barrier();
- writePinHigh(LATCH_PIN);
+ gpio_write_pin_high(LATCH_PIN);
small_delay();
- writePinLow(LATCH_PIN);
+ gpio_write_pin_low(LATCH_PIN);
compiler_barrier();
}
}
@@ 93,18 93,18 @@ static void shiftOut_single(uint8_t data) {
ATOMIC_BLOCK_FORCEON {
compiler_barrier();
if (data & 0x1) {
- writePinHigh(DATA_PIN);
+ gpio_write_pin_high(DATA_PIN);
} else {
- writePinLow(DATA_PIN);
+ gpio_write_pin_low(DATA_PIN);
}
compiler_barrier();
- writePinHigh(CLOCK_PIN);
+ gpio_write_pin_high(CLOCK_PIN);
small_delay();
- writePinLow(CLOCK_PIN);
+ gpio_write_pin_low(CLOCK_PIN);
compiler_barrier();
- writePinHigh(LATCH_PIN);
+ gpio_write_pin_high(LATCH_PIN);
small_delay();
- writePinLow(LATCH_PIN);
+ gpio_write_pin_low(LATCH_PIN);
compiler_barrier();
}
}
@@ 156,13 156,13 @@ static void unselect_cols(void) {
}
static void matrix_init_pins(void) {
- setPinOutput(DATA_PIN);
- setPinOutput(CLOCK_PIN);
- setPinOutput(LATCH_PIN);
+ gpio_set_pin_output(DATA_PIN);
+ gpio_set_pin_output(CLOCK_PIN);
+ gpio_set_pin_output(LATCH_PIN);
#ifdef MATRIX_UNSELECT_DRIVE_HIGH
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
if (col_pins[x] != NO_PIN) {
- setPinOutput(col_pins[x]);
+ gpio_set_pin_output(col_pins[x]);
}
}
#endif
M keyboards/keychron/v6/matrix.c => keyboards/keychron/v6/matrix.c +22 -22
@@ 36,27 36,27 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinOutput_writeHigh(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinHigh(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_high(pin);
}
}
static inline void setPinInputHigh_atomic(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
static inline uint8_t readMatrixPin(pin_t pin) {
if (pin != NO_PIN) {
- return readPin(pin);
+ return gpio_read_pin(pin);
} else {
return 1;
}
@@ 70,34 70,34 @@ static void shiftOut(uint16_t dataOut) {
ATOMIC_BLOCK_FORCEON {
for (uint8_t i = 0; i < PIN_USED_74HC595; i++) {
if (dataOut & 0x1) {
- writePinHigh(DATA_PIN_74HC595);
+ gpio_write_pin_high(DATA_PIN_74HC595);
} else {
- writePinLow(DATA_PIN_74HC595);
+ gpio_write_pin_low(DATA_PIN_74HC595);
}
dataOut = dataOut >> 1;
- writePinHigh(CLOCK_PIN_74HC595);
+ gpio_write_pin_high(CLOCK_PIN_74HC595);
small_delay(2);
- writePinLow(CLOCK_PIN_74HC595);
+ gpio_write_pin_low(CLOCK_PIN_74HC595);
}
- writePinHigh(LATCH_PIN_74HC595);
+ gpio_write_pin_high(LATCH_PIN_74HC595);
small_delay(2);
- writePinLow(LATCH_PIN_74HC595);
+ gpio_write_pin_low(LATCH_PIN_74HC595);
}
}
static void shiftOut_single(uint8_t data) {
ATOMIC_BLOCK_FORCEON {
if (data & 0x1) {
- writePinHigh(DATA_PIN_74HC595);
+ gpio_write_pin_high(DATA_PIN_74HC595);
} else {
- writePinLow(DATA_PIN_74HC595);
+ gpio_write_pin_low(DATA_PIN_74HC595);
}
- writePinHigh(CLOCK_PIN_74HC595);
+ gpio_write_pin_high(CLOCK_PIN_74HC595);
small_delay(2);
- writePinLow(CLOCK_PIN_74HC595);
- writePinHigh(LATCH_PIN_74HC595);
+ gpio_write_pin_low(CLOCK_PIN_74HC595);
+ gpio_write_pin_high(LATCH_PIN_74HC595);
small_delay(2);
- writePinLow(LATCH_PIN_74HC595);
+ gpio_write_pin_low(LATCH_PIN_74HC595);
}
}
@@ 149,13 149,13 @@ static void unselect_cols(void) {
}
static void matrix_init_pins(void) {
- setPinOutput(DATA_PIN_74HC595);
- setPinOutput(CLOCK_PIN_74HC595);
- setPinOutput(LATCH_PIN_74HC595);
+ gpio_set_pin_output(DATA_PIN_74HC595);
+ gpio_set_pin_output(CLOCK_PIN_74HC595);
+ gpio_set_pin_output(LATCH_PIN_74HC595);
#ifdef MATRIX_UNSELECT_DRIVE_HIGH
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
if (col_pins[x] != NO_PIN) {
- setPinOutput(col_pins[x]);
+ gpio_set_pin_output(col_pins[x]);
}
}
#endif
M keyboards/keyhive/honeycomb/honeycomb.c => keyboards/keyhive/honeycomb/honeycomb.c +6 -6
@@ 60,12 60,12 @@ bool pointing_device_task(void){
}
void led_init(void) {
- setPinOutput(D1);
- writePinHigh(D1);
- setPinOutput(F4);
- writePinHigh(F4);
- setPinOutput(F5);
- writePinHigh(F5);
+ gpio_set_pin_output(D1);
+ gpio_write_pin_high(D1);
+ gpio_set_pin_output(F4);
+ gpio_write_pin_high(F4);
+ gpio_set_pin_output(F5);
+ gpio_write_pin_high(F5);
}
void matrix_init_kb(void) {
M keyboards/keyhive/honeycomb/honeycomb.h => keyboards/keyhive/honeycomb/honeycomb.h +6 -6
@@ 2,12 2,12 @@
#include "quantum.h"
-#define RED_LED_OFF() writePinHigh(F6)
-#define RED_LED_ON() writePinLow(F6)
-#define BLU_LED_OFF() writePinHigh(F5)
-#define BLU_LED_ON() writePinLow(F5)
-#define GRN_LED_OFF() writePinHigh(D1)
-#define GRN_LED_ON() writePinLow(D1)
+#define RED_LED_OFF() gpio_write_pin_high(F6)
+#define RED_LED_ON() gpio_write_pin_low(F6)
+#define BLU_LED_OFF() gpio_write_pin_high(F5)
+#define BLU_LED_ON() gpio_write_pin_low(F5)
+#define GRN_LED_OFF() gpio_write_pin_high(D1)
+#define GRN_LED_ON() gpio_write_pin_low(D1)
#define SET_LED_OFF (RED_LED_OFF(); GRN_LED_OFF(); BLU_LED_OFF(); )
#define SET_LED_RED (RED_LED_ON(); GRN_LED_OFF(); BLU_LED_OFF(); )
M keyboards/keyhive/lattice60/lattice60.c => keyboards/keyhive/lattice60/lattice60.c +3 -3
@@ 21,8 21,8 @@
void keyboard_pre_init_kb(void){
//init the LED pins as outputs
- setPinOutput(LED1_PIN);
- setPinOutput(LED2_PIN);
+ gpio_set_pin_output(LED1_PIN);
+ gpio_set_pin_output(LED2_PIN);
//call any user initialization code
keyboard_pre_init_user();
}
@@ 31,7 31,7 @@ bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res){
//write the CAPS LOCK state on LED1
- writePin(LED1_PIN, led_state.caps_lock);
+ gpio_write_pin(LED1_PIN, led_state.caps_lock);
}
return res;
}
M keyboards/keyhive/navi10/rev0/rev0.c => keyboards/keyhive/navi10/rev0/rev0.c +2 -2
@@ 20,9 20,9 @@ void matrix_init_kb(void) {
// runs once when the firmware starts up
//set the indicator LED pin to Output
- setPinOutput(B5);
+ gpio_set_pin_output(B5);
//set HIGH for off.
- writePinHigh(B5);
+ gpio_write_pin_high(B5);
//call any user functions
matrix_init_user();
M keyboards/keyhive/navi10/rev2/rev2.c => keyboards/keyhive/navi10/rev2/rev2.c +2 -2
@@ 20,9 20,9 @@ void matrix_init_kb(void) {
// runs once when the firmware starts up
//set the indicator LED pin to Output
- setPinOutput(B5);
+ gpio_set_pin_output(B5);
//set HIGH for off.
- writePinHigh(B5);
+ gpio_write_pin_high(B5);
//call any user functions
matrix_init_user();
M keyboards/keyhive/navi10/rev3/rev3.c => keyboards/keyhive/navi10/rev3/rev3.c +2 -2
@@ 20,9 20,9 @@ void matrix_init_kb(void) {
// runs once when the firmware starts up
//set the indicator LED pin to Output
- setPinOutput(B5);
+ gpio_set_pin_output(B5);
//set HIGH for off.
- writePinHigh(B5);
+ gpio_write_pin_high(B5);
//call any user functions
matrix_init_user();
M keyboards/kin80/blackpill103/blackpill103.c => keyboards/kin80/blackpill103/blackpill103.c +2 -2
@@ 18,8 18,8 @@
void matrix_init_kb(void) {
/* LED pins setup */
- setPinOutput(LED4_PIN);
- writePinLow(LED4_PIN);
+ gpio_set_pin_output(LED4_PIN);
+ gpio_write_pin_low(LED4_PIN);
matrix_init_user();
}
M keyboards/kin80/blackpill401/blackpill401.c => keyboards/kin80/blackpill401/blackpill401.c +2 -2
@@ 18,8 18,8 @@
void matrix_init_kb(void) {
/* LED pins setup */
- setPinOutput(LED4_PIN);
- writePinLow(LED4_PIN);
+ gpio_set_pin_output(LED4_PIN);
+ gpio_write_pin_low(LED4_PIN);
matrix_init_user();
}
M keyboards/kin80/blackpill411/blackpill411.c => keyboards/kin80/blackpill411/blackpill411.c +2 -2
@@ 18,8 18,8 @@
void matrix_init_kb(void) {
/* LED pins setup */
- setPinOutput(LED4_PIN);
- writePinLow(LED4_PIN);
+ gpio_set_pin_output(LED4_PIN);
+ gpio_write_pin_low(LED4_PIN);
matrix_init_user();
}
M keyboards/kin80/micro/micro.c => keyboards/kin80/micro/micro.c +2 -2
@@ 18,8 18,8 @@
void matrix_init_kb(void) {
/* LED pins setup */
- setPinOutput(LED4_PIN);
- writePinLow(LED4_PIN);
+ gpio_set_pin_output(LED4_PIN);
+ gpio_write_pin_low(LED4_PIN);
matrix_init_user();
}
M keyboards/kinesis/kint36/kint36.c => keyboards/kinesis/kint36/kint36.c +2 -2
@@ 22,6 22,6 @@ void matrix_init_kb(void) {
matrix_init_user();
// Turn on the Teensy 3.6 Power LED:
- setPinOutput(LED_POWER);
- writePinHigh(LED_POWER);
+ gpio_set_pin_output(LED_POWER);
+ gpio_write_pin_high(LED_POWER);
}
M keyboards/kinesis/kint41/kint41.c => keyboards/kinesis/kint41/kint41.c +2 -2
@@ 22,8 22,8 @@ void matrix_init_kb(void) {
matrix_init_user();
// Turn on the Teensy 4.x Power LED:
- setPinOutput(LED_POWER);
- writePinHigh(LED_POWER);
+ gpio_set_pin_output(LED_POWER);
+ gpio_write_pin_high(LED_POWER);
}
// delay_inline sleeps for |cycles| (e.g. sleeping for F_CPU will sleep 1s).
M keyboards/kinesis/kintlc/kintlc.c => keyboards/kinesis/kintlc/kintlc.c +2 -2
@@ 22,6 22,6 @@ void matrix_init_kb(void) {
matrix_init_user();
// Turn on the Teensy LC Power LED:
- setPinOutput(LED_POWER);
- writePinHigh(LED_POWER);
+ gpio_set_pin_output(LED_POWER);
+ gpio_write_pin_high(LED_POWER);
}
M keyboards/kinesis/kintwin/kintwin.c => keyboards/kinesis/kintwin/kintwin.c +9 -9
@@ 8,22 8,22 @@ void matrix_init_kb(void) {
uint8_t led_delay_ms = 80;
/* LED pins setup */
- setPinOutput(LED_CAPS_LOCK_PIN);
- writePinLow(LED_CAPS_LOCK_PIN);
+ gpio_set_pin_output(LED_CAPS_LOCK_PIN);
+ gpio_write_pin_low(LED_CAPS_LOCK_PIN);
wait_ms(led_delay_ms);
- setPinOutput(LED_NUM_LOCK_PIN);
- writePinLow(LED_NUM_LOCK_PIN);
+ gpio_set_pin_output(LED_NUM_LOCK_PIN);
+ gpio_write_pin_low(LED_NUM_LOCK_PIN);
wait_ms(led_delay_ms);
- setPinOutput(LED_SCROLL_LOCK_PIN);
- writePinLow(LED_SCROLL_LOCK_PIN);
+ gpio_set_pin_output(LED_SCROLL_LOCK_PIN);
+ gpio_write_pin_low(LED_SCROLL_LOCK_PIN);
wait_ms(led_delay_ms);
- setPinOutput(LED_COMPOSE_PIN);
- writePinLow(LED_COMPOSE_PIN);
+ gpio_set_pin_output(LED_COMPOSE_PIN);
+ gpio_write_pin_low(LED_COMPOSE_PIN);
wait_ms(led_delay_ms);
- writePinHigh(LED_COMPOSE_PIN);
+ gpio_write_pin_high(LED_COMPOSE_PIN);
matrix_init_user();
}=
\ No newline at end of file
M keyboards/kinesis/nguyenvietyen/matrix.c => keyboards/kinesis/nguyenvietyen/matrix.c +16 -16
@@ 8,10 8,10 @@ static matrix_row_t read_row(uint8_t row) {
// keypad and program buttons
if (row == 12) {
- return ~(readPin(B4) | (readPin(B5) << 1) | 0b11111100);
+ return ~(gpio_read_pin(B4) | (gpio_read_pin(B5) << 1) | 0b11111100);
}
- return ~(readPin(B6) | readPin(B2) << 1 | readPin(B3) << 2 | readPin(B1) << 3 | readPin(F7) << 4 | readPin(F6) << 5 | readPin(F5) << 6 | readPin(F4) << 7);
+ return ~(gpio_read_pin(B6) | gpio_read_pin(B2) << 1 | gpio_read_pin(B3) << 2 | gpio_read_pin(B1) << 3 | gpio_read_pin(F7) << 4 | gpio_read_pin(F6) << 5 | gpio_read_pin(F5) << 6 | gpio_read_pin(F4) << 7);
}
static void unselect_rows(void) {
@@ 26,24 26,24 @@ static void select_rows(uint8_t row) {
void matrix_init_custom(void) {
// output low (multiplexers)
- setPinOutput(D0);
- setPinOutput(D1);
- setPinOutput(D2);
- setPinOutput(D3);
+ gpio_set_pin_output(D0);
+ gpio_set_pin_output(D1);
+ gpio_set_pin_output(D2);
+ gpio_set_pin_output(D3);
// input with pullup (matrix)
- setPinInputHigh(B6);
- setPinInputHigh(B2);
- setPinInputHigh(B3);
- setPinInputHigh(B1);
- setPinInputHigh(F7);
- setPinInputHigh(F6);
- setPinInputHigh(F5);
- setPinInputHigh(F4);
+ gpio_set_pin_input_high(B6);
+ gpio_set_pin_input_high(B2);
+ gpio_set_pin_input_high(B3);
+ gpio_set_pin_input_high(B1);
+ gpio_set_pin_input_high(F7);
+ gpio_set_pin_input_high(F6);
+ gpio_set_pin_input_high(F5);
+ gpio_set_pin_input_high(F4);
// input with pullup (program and keypad buttons)
- setPinInputHigh(B4);
- setPinInputHigh(B5);
+ gpio_set_pin_input_high(B4);
+ gpio_set_pin_input_high(B5);
// initialize row and col
unselect_rows();
M keyboards/kkatano/wallaby/wallaby.c => keyboards/kkatano/wallaby/wallaby.c +2 -2
@@ 18,8 18,8 @@
bool led_update_kb(led_t led_state) {
if (led_update_user(led_state)) {
- writePin(B6, led_state.caps_lock);
- writePin(B7, led_state.scroll_lock);
+ gpio_write_pin(B6, led_state.caps_lock);
+ gpio_write_pin(B7, led_state.scroll_lock);
}
return true;
}
M keyboards/kkatano/yurei/yurei.c => keyboards/kkatano/yurei/yurei.c +2 -2
@@ 18,8 18,8 @@
bool led_update_kb(led_t led_state) {
if (led_update_user(led_state)) {
- writePin(B6, led_state.caps_lock);
- writePin(B7, led_state.scroll_lock);
+ gpio_write_pin(B6, led_state.caps_lock);
+ gpio_write_pin(B7, led_state.scroll_lock);
}
return true;
}
M keyboards/kopibeng/mnk88/mnk88.c => keyboards/kopibeng/mnk88/mnk88.c +4 -4
@@ 18,8 18,8 @@
void matrix_init_kb(void) {
- setPinOutput(LED_CAPS_LOCK_PIN);
- setPinOutput(LED_SCROLL_LOCK_PIN);
+ gpio_set_pin_output(LED_CAPS_LOCK_PIN);
+ gpio_set_pin_output(LED_SCROLL_LOCK_PIN);
matrix_init_user();
}
@@ 29,8 29,8 @@ bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(LED_CAPS_LOCK_PIN, led_state.caps_lock);
- writePin(LED_SCROLL_LOCK_PIN, led_state.scroll_lock);
+ gpio_write_pin(LED_CAPS_LOCK_PIN, led_state.caps_lock);
+ gpio_write_pin(LED_SCROLL_LOCK_PIN, led_state.scroll_lock);
}
return res;
}
M keyboards/kopibeng/typ65/typ65.c => keyboards/kopibeng/typ65/typ65.c +21 -21
@@ 17,9 17,9 @@
#include "quantum.h"
void keyboard_pre_init_kb (void) {
- setPinOutput(INDICATOR_0);
- setPinOutput(INDICATOR_1);
- setPinOutput(INDICATOR_2);
+ gpio_set_pin_output(INDICATOR_0);
+ gpio_set_pin_output(INDICATOR_1);
+ gpio_set_pin_output(INDICATOR_2);
keyboard_pre_init_user();
}
@@ 27,41 27,41 @@ void keyboard_pre_init_kb (void) {
__attribute__((weak)) layer_state_t layer_state_set_user(layer_state_t state) {
switch (get_highest_layer(state)) {
case 1:
- writePinHigh(INDICATOR_0);
- writePinLow(INDICATOR_1);
- writePinLow(INDICATOR_2);
+ gpio_write_pin_high(INDICATOR_0);
+ gpio_write_pin_low(INDICATOR_1);
+ gpio_write_pin_low(INDICATOR_2);
break;
case 2:
- writePinLow(INDICATOR_0);
- writePinHigh(INDICATOR_1);
- writePinLow(INDICATOR_2);
+ gpio_write_pin_low(INDICATOR_0);
+ gpio_write_pin_high(INDICATOR_1);
+ gpio_write_pin_low(INDICATOR_2);
break;
case 3:
- writePinLow(INDICATOR_0);
- writePinLow(INDICATOR_1);
- writePinHigh(INDICATOR_2);
+ gpio_write_pin_low(INDICATOR_0);
+ gpio_write_pin_low(INDICATOR_1);
+ gpio_write_pin_high(INDICATOR_2);
break;
default:
- writePinHigh(INDICATOR_0);
- writePinHigh(INDICATOR_1);
- writePinHigh(INDICATOR_2);
+ gpio_write_pin_high(INDICATOR_0);
+ gpio_write_pin_high(INDICATOR_1);
+ gpio_write_pin_high(INDICATOR_2);
break;
}
return state;
}
void suspend_power_down_kb(void) {
- writePinLow(INDICATOR_0);
- writePinLow(INDICATOR_1);
- writePinLow(INDICATOR_2);
+ gpio_write_pin_low(INDICATOR_0);
+ gpio_write_pin_low(INDICATOR_1);
+ gpio_write_pin_low(INDICATOR_2);
suspend_power_down_user();
}
void suspend_wakeup_init_kb(void) {
- writePinHigh(INDICATOR_0);
- writePinHigh(INDICATOR_1);
- writePinHigh(INDICATOR_2);
+ gpio_write_pin_high(INDICATOR_0);
+ gpio_write_pin_high(INDICATOR_1);
+ gpio_write_pin_high(INDICATOR_2);
suspend_wakeup_init_user();
}=
\ No newline at end of file
M keyboards/kopibeng/xt8x/xt8x.c => keyboards/kopibeng/xt8x/xt8x.c +6 -6
@@ 19,9 19,9 @@
void matrix_init_kb(void) {
// Initialize indicator LEDs to output
- setPinOutput(LED_CAPS_LOCK_PIN); // Caps
- setPinOutput(LED_SCROLL_LOCK_PIN); // Scroll lock
- setPinOutput(INDICATOR_PIN_0); // Layer indicator on F13
+ gpio_set_pin_output(LED_CAPS_LOCK_PIN); // Caps
+ gpio_set_pin_output(LED_SCROLL_LOCK_PIN); // Scroll lock
+ gpio_set_pin_output(INDICATOR_PIN_0); // Layer indicator on F13
matrix_init_user();
}
@@ 31,13 31,13 @@ bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(LED_CAPS_LOCK_PIN, led_state.caps_lock);
- writePin(LED_SCROLL_LOCK_PIN, led_state.scroll_lock);
+ gpio_write_pin(LED_CAPS_LOCK_PIN, led_state.caps_lock);
+ gpio_write_pin(LED_SCROLL_LOCK_PIN, led_state.scroll_lock);
}
return res;
}
__attribute__((weak)) layer_state_t layer_state_set_user(layer_state_t state) {
- writePin(INDICATOR_PIN_0, layer_state_cmp(state, 1));
+ gpio_write_pin(INDICATOR_PIN_0, layer_state_cmp(state, 1));
return state;
}
M keyboards/ktec/ergodone/ergodox_compat.h => keyboards/ktec/ergodone/ergodox_compat.h +8 -8
@@ 15,12 15,12 @@
#endif
#define LED_BRIGHTNESS_LO 15
#define LED_BRIGHTNESS_HI 255
-static inline void ergodox_right_led_1_off(void) { setPinOutput(LED_NUM_LOCK_PIN); writePin(LED_NUM_LOCK_PIN, 0); }
-static inline void ergodox_right_led_1_on(void) { setPinOutput(LED_NUM_LOCK_PIN); writePin(LED_NUM_LOCK_PIN, 1); }
-static inline void ergodox_right_led_2_off(void) { setPinOutput(LED_CAPS_LOCK_PIN); writePin(LED_CAPS_LOCK_PIN, 0); }
-static inline void ergodox_right_led_2_on(void) { setPinOutput(LED_CAPS_LOCK_PIN); writePin(LED_CAPS_LOCK_PIN, 1); }
-static inline void ergodox_right_led_3_off(void) { setPinOutput(LED_SCROLL_LOCK_PIN); writePin(LED_SCROLL_LOCK_PIN, 0); }
-static inline void ergodox_right_led_3_on(void) { setPinOutput(LED_SCROLL_LOCK_PIN); writePin(LED_SCROLL_LOCK_PIN, 1); }
+static inline void ergodox_right_led_1_off(void) { gpio_set_pin_output(LED_NUM_LOCK_PIN); gpio_write_pin(LED_NUM_LOCK_PIN, 0); }
+static inline void ergodox_right_led_1_on(void) { gpio_set_pin_output(LED_NUM_LOCK_PIN); gpio_write_pin(LED_NUM_LOCK_PIN, 1); }
+static inline void ergodox_right_led_2_off(void) { gpio_set_pin_output(LED_CAPS_LOCK_PIN); gpio_write_pin(LED_CAPS_LOCK_PIN, 0); }
+static inline void ergodox_right_led_2_on(void) { gpio_set_pin_output(LED_CAPS_LOCK_PIN); gpio_write_pin(LED_CAPS_LOCK_PIN, 1); }
+static inline void ergodox_right_led_3_off(void) { gpio_set_pin_output(LED_SCROLL_LOCK_PIN); gpio_write_pin(LED_SCROLL_LOCK_PIN, 0); }
+static inline void ergodox_right_led_3_on(void) { gpio_set_pin_output(LED_SCROLL_LOCK_PIN); gpio_write_pin(LED_SCROLL_LOCK_PIN, 1); }
static inline void ergodox_right_led_on(uint8_t l) {
switch (l) {
case 1:
@@ 51,8 51,8 @@ static inline void ergodox_right_led_off(uint8_t l) {
break;
}
}
-static inline void ergodox_board_led_off(void) { setPinOutput(D5); writePin(D5, !ERGODOX_BOARD_LED_ON_STATE); }
-static inline void ergodox_board_led_on(void) { setPinOutput(D5); writePin(D5, ERGODOX_BOARD_LED_ON_STATE); }
+static inline void ergodox_board_led_off(void) { gpio_set_pin_output(D5); gpio_write_pin(D5, !ERGODOX_BOARD_LED_ON_STATE); }
+static inline void ergodox_board_led_on(void) { gpio_set_pin_output(D5); gpio_write_pin(D5, ERGODOX_BOARD_LED_ON_STATE); }
static inline void ergodox_led_all_on(void) {
ergodox_right_led_1_on();
ergodox_right_led_2_on();
M keyboards/ktec/ergodone/matrix.c => keyboards/ktec/ergodone/matrix.c +50 -50
@@ 82,13 82,13 @@ static void expander_scan(void) {
*/
static void init_cols(void) {
// Pro Micro
- setPinInputHigh(E6);
- setPinInputHigh(D2);
- setPinInputHigh(D3);
- setPinInputHigh(D4);
- setPinInputHigh(D7);
- setPinInputHigh(C6);
- setPinInputHigh(B4);
+ gpio_set_pin_input_high(E6);
+ gpio_set_pin_input_high(D2);
+ gpio_set_pin_input_high(D3);
+ gpio_set_pin_input_high(D4);
+ gpio_set_pin_input_high(D7);
+ gpio_set_pin_input_high(C6);
+ gpio_set_pin_input_high(B4);
// Expander
expander_init_cols();
@@ 97,13 97,13 @@ static void init_cols(void) {
static matrix_row_t read_cols(void) {
// clang-format off
return expander_read_row() |
- (readPin(D3) ? 0 : (1<<6)) |
- (readPin(D2) ? 0 : (1<<5)) |
- (readPin(D4) ? 0 : (1<<4)) |
- (readPin(C6) ? 0 : (1<<3)) |
- (readPin(D7) ? 0 : (1<<2)) |
- (readPin(E6) ? 0 : (1<<1)) |
- (readPin(B4) ? 0 : (1<<0)) ;
+ (gpio_read_pin(D3) ? 0 : (1<<6)) |
+ (gpio_read_pin(D2) ? 0 : (1<<5)) |
+ (gpio_read_pin(D4) ? 0 : (1<<4)) |
+ (gpio_read_pin(C6) ? 0 : (1<<3)) |
+ (gpio_read_pin(D7) ? 0 : (1<<2)) |
+ (gpio_read_pin(E6) ? 0 : (1<<1)) |
+ (gpio_read_pin(B4) ? 0 : (1<<0)) ;
// clang-format on
}
@@ 116,18 116,18 @@ static matrix_row_t read_cols(void) {
*/
static void unselect_rows(void) {
// Pro Micro
- setPinInput(B1);
- setPinInput(B2);
- setPinInput(F4);
- setPinInput(F5);
- setPinInput(F6);
- setPinInput(F7);
- writePinLow(B1);
- writePinLow(B2);
- writePinLow(F4);
- writePinLow(F5);
- writePinLow(F6);
- writePinLow(F7);
+ gpio_set_pin_input(B1);
+ gpio_set_pin_input(B2);
+ gpio_set_pin_input(F4);
+ gpio_set_pin_input(F5);
+ gpio_set_pin_input(F6);
+ gpio_set_pin_input(F7);
+ gpio_write_pin_low(B1);
+ gpio_write_pin_low(B2);
+ gpio_write_pin_low(F4);
+ gpio_write_pin_low(F5);
+ gpio_write_pin_low(F6);
+ gpio_write_pin_low(F7);
// Expander
expander_unselect_rows();
@@ 137,28 137,28 @@ static void unselect_row(uint8_t row) {
// Pro Micro
switch (row) {
case 0:
- setPinInput(F4);
- writePinLow(F4);
+ gpio_set_pin_input(F4);
+ gpio_write_pin_low(F4);
break;
case 1:
- setPinInput(F5);
- writePinLow(F5);
+ gpio_set_pin_input(F5);
+ gpio_write_pin_low(F5);
break;
case 2:
- setPinInput(F6);
- writePinLow(F6);
+ gpio_set_pin_input(F6);
+ gpio_write_pin_low(F6);
break;
case 3:
- setPinInput(F7);
- writePinLow(F7);
+ gpio_set_pin_input(F7);
+ gpio_write_pin_low(F7);
break;
case 4:
- setPinInput(B1);
- writePinLow(B1);
+ gpio_set_pin_input(B1);
+ gpio_write_pin_low(B1);
break;
case 5:
- setPinInput(B2);
- writePinLow(B2);
+ gpio_set_pin_input(B2);
+ gpio_write_pin_low(B2);
break;
}
@@ 170,28 170,28 @@ static void select_row(uint8_t row) {
// Pro Micro
switch (row) {
case 0:
- setPinOutput(F4);
- writePinLow(F4);
+ gpio_set_pin_output(F4);
+ gpio_write_pin_low(F4);
break;
case 1:
- setPinOutput(F5);
- writePinLow(F5);
+ gpio_set_pin_output(F5);
+ gpio_write_pin_low(F5);
break;
case 2:
- setPinOutput(F6);
- writePinLow(F6);
+ gpio_set_pin_output(F6);
+ gpio_write_pin_low(F6);
break;
case 3:
- setPinOutput(F7);
- writePinLow(F7);
+ gpio_set_pin_output(F7);
+ gpio_write_pin_low(F7);
break;
case 4:
- setPinOutput(B1);
- writePinLow(B1);
+ gpio_set_pin_output(B1);
+ gpio_write_pin_low(B1);
break;
case 5:
- setPinOutput(B2);
- writePinLow(B2);
+ gpio_set_pin_output(B2);
+ gpio_write_pin_low(B2);
break;
}
M keyboards/ktec/staryu/backlight_staryu.h => keyboards/ktec/staryu/backlight_staryu.h +2 -2
@@ 20,9 20,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
static inline void backlight_set_value(uint8_t index, uint8_t level) {
static const uint8_t backlight_pins[] = BACKLIGHT_PINS;
if (level) {
- setPinOutput(backlight_pins[index]);
+ gpio_set_pin_output(backlight_pins[index]);
} else {
- setPinInput(backlight_pins[index]);
+ gpio_set_pin_input(backlight_pins[index]);
}
}
M keyboards/kv/revt/revt.c => keyboards/kv/revt/revt.c +2 -2
@@ 18,8 18,8 @@
void matrix_init_kb(void) {
// Turn status LED on
- setPinOutput(C14);
- writePinHigh(C14);
+ gpio_set_pin_output(C14);
+ gpio_write_pin_high(C14);
matrix_init_user();
}
M keyboards/lazydesigners/dimple/staggered/staggered.c => keyboards/lazydesigners/dimple/staggered/staggered.c +2 -2
@@ 15,9 15,9 @@
*/
#include "staggered.h"
void dimple_led_on(void) {
- writePinLow(E6);
+ gpio_write_pin_low(E6);
}
void dimple_led_off(void) {
- writePinHigh(E6);
+ gpio_write_pin_high(E6);
}
M keyboards/lfkeyboards/lfk78/lfk78.c => keyboards/lfkeyboards/lfk78/lfk78.c +2 -2
@@ 10,8 10,8 @@ void matrix_init_kb(void) {
#ifndef AUDIO_ENABLE
// If we're not using the audio pin, drive it low
- setPinOutput(C6);
- writePinLow(C6);
+ gpio_set_pin_output(C6);
+ gpio_write_pin_low(C6);
#endif
#ifdef WATCHDOG_ENABLE
M keyboards/lfkeyboards/lfk87/lfk87.c => keyboards/lfkeyboards/lfk87/lfk87.c +2 -2
@@ 12,8 12,8 @@ void matrix_init_kb(void)
matrix_init_user();
#ifndef AUDIO_ENABLE
// If we're not using the audio pin, drive it low
- setPinOutput(C6);
- writePinLow(C6);
+ gpio_set_pin_output(C6);
+ gpio_write_pin_low(C6);
#endif
#ifdef WATCHDOG_ENABLE
// This is done after turning the layer LED red, if we're caught in a loop
M keyboards/lfkeyboards/mini1800/mini1800.c => keyboards/lfkeyboards/mini1800/mini1800.c +2 -2
@@ 13,8 13,8 @@ void matrix_init_kb(void)
matrix_init_user();
#ifndef AUDIO_ENABLE
// If we're not using the audio pin, drive it low
- setPinOutput(C6);
- writePinLow(C6);
+ gpio_set_pin_output(C6);
+ gpio_write_pin_low(C6);
#endif
_delay_ms(500);
#ifdef WATCHDOG_ENABLE
M keyboards/lfkeyboards/smk65/revb/revb.c => keyboards/lfkeyboards/smk65/revb/revb.c +4 -4
@@ 27,12 27,12 @@ void matrix_init_kb(void)
#ifdef AUDIO_ENABLE
// audio_init() sets PB5 to output and drives it low, which breaks our matrix
// so reset PB5 to input
- setPinInput(B5);
- writePinHigh(B5);
+ gpio_set_pin_input(B5);
+ gpio_write_pin_high(B5);
#else
// If we're not using the audio pin, drive it low
- setPinOutput(C6);
- writePinLow(C6);
+ gpio_set_pin_output(C6);
+ gpio_write_pin_low(C6);
#endif
}
M keyboards/lz/erghost/matrix.c => keyboards/lz/erghost/matrix.c +144 -144
@@ 63,103 63,103 @@ static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static void select_col(uint8_t col) {
switch (col) {
case 0:
- writePinLow(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinHigh(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(B0);
break;
case 1:
- writePinLow(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinHigh(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(B0);
break;
case 2:
- writePinLow(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinHigh(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(B0);
break;
case 3:
- writePinLow(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinHigh(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(B0);
break;
case 4:
- writePinHigh(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinHigh(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(B0);
break;
case 5:
- writePinHigh(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinHigh(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(B0);
break;
case 6:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinHigh(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(B0);
break;
case 7:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinHigh(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(B0);
break;
case 8:
- writePinLow(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinHigh(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F1);
break;
case 9:
- writePinLow(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinHigh(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
break;
case 10:
- writePinLow(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinHigh(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F1);
break;
case 11:
- writePinLow(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinHigh(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
break;
case 12:
- writePinHigh(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinHigh(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F1);
break;
case 13:
- writePinHigh(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinHigh(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
break;
case 14:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinHigh(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
break;
case 15:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinHigh(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F1);
break;
case 16:
- writePinLow(E6);
+ gpio_write_pin_low(E6);
break;
}
}
@@ 167,130 167,130 @@ static void select_col(uint8_t col) {
static void unselect_col(uint8_t col) {
switch (col) {
case 0:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinLow(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(B0);
break;
case 1:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinLow(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(B0);
break;
case 2:
- writePinHigh(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinLow(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(B0);
break;
case 3:
- writePinHigh(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinLow(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(B0);
break;
case 4:
- writePinLow(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinLow(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(B0);
break;
case 5:
- writePinLow(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinLow(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(B0);
break;
case 6:
- writePinLow(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinLow(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(B0);
break;
case 7:
- writePinLow(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinLow(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(B0);
break;
case 8:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinLow(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F1);
break;
case 9:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinLow(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
break;
case 10:
- writePinHigh(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinLow(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F1);
break;
case 11:
- writePinHigh(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinLow(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
break;
case 12:
- writePinLow(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinLow(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F1);
break;
case 13:
- writePinLow(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinLow(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
break;
case 14:
- writePinLow(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinLow(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
break;
case 15:
- writePinLow(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinLow(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F1);
break;
case 16:
- writePinHigh(E6);
+ gpio_write_pin_high(E6);
break;
}
}
static void unselect_cols(void) {
//Native
- writePinHigh(E6);
+ gpio_write_pin_high(E6);
//Demultiplexer
- writePinLow(B0);
- writePinLow(F1);
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
+ gpio_write_pin_low(B0);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
}
static void init_pins(void) {
unselect_cols();
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
- setPinOutput(B5);
- setPinOutput(B7);
- setPinOutput(F0);
- setPinOutput(B0);
- setPinOutput(F1);
- setPinOutput(E6);
+ gpio_set_pin_output(B5);
+ gpio_set_pin_output(B7);
+ gpio_set_pin_output(F0);
+ gpio_set_pin_output(B0);
+ gpio_set_pin_output(F1);
+ gpio_set_pin_output(E6);
}
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
@@ 306,7 306,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0) {
+ if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_matrix[row_index] |= (MATRIX_ROW_SHIFTER << current_col);
} else {
M keyboards/machkeyboards/mach3/mach3.c => keyboards/machkeyboards/mach3/mach3.c +2 -2
@@ 35,8 35,8 @@ led_config_t g_led_config = { {
#endif
void keyboard_pre_init_kb(void) {
- setPinOutput(F5);
- writePinHigh(F5);
+ gpio_set_pin_output(F5);
+ gpio_write_pin_high(F5);
keyboard_pre_init_user();
}
M keyboards/macrocat/macrocat.c => keyboards/macrocat/macrocat.c +2 -2
@@ 129,11 129,11 @@ void encoder_triple_click(void) {
void matrix_init_kb(void) {
matrix_init_user();
- setPinInputHigh(ENCODER_SWITCH);
+ gpio_set_pin_input_high(ENCODER_SWITCH);
}
void matrix_scan_kb(void) {
matrix_scan_user();
- if (readPin(ENCODER_SWITCH)) {
+ if (gpio_read_pin(ENCODER_SWITCH)) {
if (encoder_pressed) { // release switch
encoder_pressed = 0;
encoder_press_combo += 1;
M keyboards/makeymakey/makeymakey.c => keyboards/makeymakey/makeymakey.c +39 -39
@@ 26,7 26,7 @@ void keyboard_post_init_kb(void) {
{
for(uint8_t col = 0; col < MATRIX_COLS; col++)
{
- writePinLow(pins[row][col]); //Disable internal pull-up resistors
+ gpio_write_pin_low(pins[row][col]); //Disable internal pull-up resistors
}
}
@@ 35,8 35,8 @@ void keyboard_post_init_kb(void) {
void cycle_leds(void) {
for(uint8_t i = 0; i < 3; i++) {
- setPinInput(led_pins[i]);
- writePinLow(led_pins[i]);
+ gpio_set_pin_input(led_pins[i]);
+ gpio_write_pin_low(led_pins[i]);
}
led_cycle_counter++;
@@ 45,62 45,62 @@ void cycle_leds(void) {
switch (led_cycle_counter) {
case 0:
if (led_state[0]) { // Up Arrow
- setPinInput(led_pins[0]);
- writePinLow(led_pins[0]);
- setPinOutput(led_pins[1]);
- writePinHigh(led_pins[1]);
- setPinOutput(led_pins[2]);
- writePinLow(led_pins[2]);
+ gpio_set_pin_input(led_pins[0]);
+ gpio_write_pin_low(led_pins[0]);
+ gpio_set_pin_output(led_pins[1]);
+ gpio_write_pin_high(led_pins[1]);
+ gpio_set_pin_output(led_pins[2]);
+ gpio_write_pin_low(led_pins[2]);
}
break;
case 1:
if (led_state[1]) { // Down Arrow
- setPinOutput(led_pins[0]);
- writePinHigh(led_pins[0]);
- setPinOutput(led_pins[1]);
- writePinLow(led_pins[1]);
- setPinInput(led_pins[2]);
- writePinLow(led_pins[2]);
+ gpio_set_pin_output(led_pins[0]);
+ gpio_write_pin_high(led_pins[0]);
+ gpio_set_pin_output(led_pins[1]);
+ gpio_write_pin_low(led_pins[1]);
+ gpio_set_pin_input(led_pins[2]);
+ gpio_write_pin_low(led_pins[2]);
}
break;
case 2:
if (led_state[2]) { // Left Arrow
- setPinOutput(led_pins[0]);
- writePinLow(led_pins[0]);
- setPinOutput(led_pins[1]);
- writePinHigh(led_pins[1]);
- setPinInput(led_pins[2]);
- writePinLow(led_pins[2]);
+ gpio_set_pin_output(led_pins[0]);
+ gpio_write_pin_low(led_pins[0]);
+ gpio_set_pin_output(led_pins[1]);
+ gpio_write_pin_high(led_pins[1]);
+ gpio_set_pin_input(led_pins[2]);
+ gpio_write_pin_low(led_pins[2]);
}
break;
case 3:
if (led_state[3]) { // Right Arrow
- setPinInput(led_pins[0]);
- writePinLow(led_pins[0]);
- setPinOutput(led_pins[1]);
- writePinLow(led_pins[1]);
- setPinOutput(led_pins[2]);
- writePinHigh(led_pins[2]);
+ gpio_set_pin_input(led_pins[0]);
+ gpio_write_pin_low(led_pins[0]);
+ gpio_set_pin_output(led_pins[1]);
+ gpio_write_pin_low(led_pins[1]);
+ gpio_set_pin_output(led_pins[2]);
+ gpio_write_pin_high(led_pins[2]);
}
break;
case 4:
if (led_state[4]) { // Space
- setPinOutput(led_pins[0]);
- writePinLow(led_pins[0]);
- setPinInput(led_pins[1]);
- writePinLow(led_pins[1]);
- setPinOutput(led_pins[2]);
- writePinHigh(led_pins[2]);
+ gpio_set_pin_output(led_pins[0]);
+ gpio_write_pin_low(led_pins[0]);
+ gpio_set_pin_input(led_pins[1]);
+ gpio_write_pin_low(led_pins[1]);
+ gpio_set_pin_output(led_pins[2]);
+ gpio_write_pin_high(led_pins[2]);
}
break;
case 5:
if (led_state[5]) { // Right Click
- setPinOutput(led_pins[0]);
- writePinHigh(led_pins[0]);
- setPinInput(led_pins[1]);
- writePinLow(led_pins[1]);
- setPinOutput(led_pins[2]);
- writePinLow(led_pins[2]);
+ gpio_set_pin_output(led_pins[0]);
+ gpio_write_pin_high(led_pins[0]);
+ gpio_set_pin_input(led_pins[1]);
+ gpio_write_pin_low(led_pins[1]);
+ gpio_set_pin_output(led_pins[2]);
+ gpio_write_pin_low(led_pins[2]);
}
break;
default:
M keyboards/mariorion_v25/mariorion_v25.c => keyboards/mariorion_v25/mariorion_v25.c +21 -21
@@ 23,50 23,50 @@ void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
- setPinOutput(INDICATOR_0);
- setPinOutput(INDICATOR_1);
- setPinOutput(INDICATOR_2);
+ gpio_set_pin_output(INDICATOR_0);
+ gpio_set_pin_output(INDICATOR_1);
+ gpio_set_pin_output(INDICATOR_2);
matrix_init_user();
}
layer_state_t layer_state_set_kb(layer_state_t state) {
switch (get_highest_layer(state)) {
case 1:
- writePinHigh(INDICATOR_0);
- writePinLow(INDICATOR_1);
- writePinLow(INDICATOR_2);
+ gpio_write_pin_high(INDICATOR_0);
+ gpio_write_pin_low(INDICATOR_1);
+ gpio_write_pin_low(INDICATOR_2);
break;
case 2:
- writePinLow(INDICATOR_0);
- writePinHigh(INDICATOR_1);
- writePinLow(INDICATOR_2);
+ gpio_write_pin_low(INDICATOR_0);
+ gpio_write_pin_high(INDICATOR_1);
+ gpio_write_pin_low(INDICATOR_2);
break;
case 3:
- writePinLow(INDICATOR_0);
- writePinLow(INDICATOR_1);
- writePinHigh(INDICATOR_2);
+ gpio_write_pin_low(INDICATOR_0);
+ gpio_write_pin_low(INDICATOR_1);
+ gpio_write_pin_high(INDICATOR_2);
break;
default:
- writePinHigh(INDICATOR_0);
- writePinHigh(INDICATOR_1);
- writePinHigh(INDICATOR_2);
+ gpio_write_pin_high(INDICATOR_0);
+ gpio_write_pin_high(INDICATOR_1);
+ gpio_write_pin_high(INDICATOR_2);
break;
}
return layer_state_set_user(state);
}
void suspend_power_down_kb(void) {
- writePinLow(INDICATOR_0);
- writePinLow(INDICATOR_1);
- writePinLow(INDICATOR_2);
+ gpio_write_pin_low(INDICATOR_0);
+ gpio_write_pin_low(INDICATOR_1);
+ gpio_write_pin_low(INDICATOR_2);
suspend_power_down_user();
}
void suspend_wakeup_init_kb(void) {
- writePinHigh(INDICATOR_0);
- writePinHigh(INDICATOR_1);
- writePinHigh(INDICATOR_2);
+ gpio_write_pin_high(INDICATOR_0);
+ gpio_write_pin_high(INDICATOR_1);
+ gpio_write_pin_high(INDICATOR_2);
suspend_wakeup_init_user();
}
M keyboards/marksard/leftover30/leftover30.c => keyboards/marksard/leftover30/leftover30.c +4 -4
@@ 22,16 22,16 @@
void keyboard_pre_init_user(void) {
/* Set CAPSLOCK indicator pin as output */
- setPinOutput(D1);
+ gpio_set_pin_output(D1);
/* Set NUMLOCK indicator pin as output */
- setPinOutput(D2);
+ gpio_set_pin_output(D2);
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(D2, led_state.num_lock);
- writePin(D1, led_state.caps_lock);
+ gpio_write_pin(D2, led_state.num_lock);
+ gpio_write_pin(D1, led_state.caps_lock);
}
return res;
}
M keyboards/masterworks/classy_tkl/rev_a/rev_a.c => keyboards/masterworks/classy_tkl/rev_a/rev_a.c +4 -4
@@ 26,8 26,8 @@ void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
- setPinOutput(CAPS_PIN);
- setPinOutput(SCROLL_PIN);
+ gpio_set_pin_output(CAPS_PIN);
+ gpio_set_pin_output(SCROLL_PIN);
matrix_init_user();
}
@@ 35,8 35,8 @@ void matrix_init_kb(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(CAPS_PIN, led_state.caps_lock);
- writePin(SCROLL_PIN, led_state.scroll_lock);
+ gpio_write_pin(CAPS_PIN, led_state.caps_lock);
+ gpio_write_pin(SCROLL_PIN, led_state.scroll_lock);
}
return res;
}
M keyboards/matrix/cain_re/cain_re.c => keyboards/matrix/cain_re/cain_re.c +6 -6
@@ 21,9 21,9 @@
void matrix_init_kb(void)
{
- setPinOutput(NUM_PIN);
- setPinOutput(CAPS_PIN);
- setPinOutput(SCROLL_PIN);
+ gpio_set_pin_output(NUM_PIN);
+ gpio_set_pin_output(CAPS_PIN);
+ gpio_set_pin_output(SCROLL_PIN);
matrix_init_user();
}
@@ 32,9 32,9 @@ bool led_update_kb(led_t led_state)
{
bool res = led_update_user(led_state);
if (res) {
- writePin(NUM_PIN, led_state.num_lock);
- writePin(CAPS_PIN, led_state.caps_lock);
- writePin(SCROLL_PIN, led_state.scroll_lock);
+ gpio_write_pin(NUM_PIN, led_state.num_lock);
+ gpio_write_pin(CAPS_PIN, led_state.caps_lock);
+ gpio_write_pin(SCROLL_PIN, led_state.scroll_lock);
}
return res;
}
M keyboards/matrix/falcon/falcon.c => keyboards/matrix/falcon/falcon.c +4 -4
@@ 18,11 18,11 @@
void matrix_init_kb(void)
{
// enable charge
- setPinOutput(CHG_EN_PIN);
- writePinHigh(CHG_EN_PIN);
+ gpio_set_pin_output(CHG_EN_PIN);
+ gpio_write_pin_high(CHG_EN_PIN);
// enable led power
- setPinOutput(LED_POWER_PIN);
- writePinHigh(LED_POWER_PIN);
+ gpio_set_pin_output(LED_POWER_PIN);
+ gpio_write_pin_high(LED_POWER_PIN);
}
M keyboards/matrix/m12og/rev1/matrix.c => keyboards/matrix/m12og/rev1/matrix.c +6 -6
@@ 22,22 22,22 @@ static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static void select_col(uint8_t col) {
- setPinOutput(col_pins[col]);
- writePinHigh(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_high(col_pins[col]);
}
-static void unselect_col(uint8_t col) { setPinInputLow(col_pins[col]); }
+static void unselect_col(uint8_t col) { gpio_set_pin_input_low(col_pins[col]); }
static void unselect_cols(void) {
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputLow(col_pins[x]);
+ gpio_set_pin_input_low(col_pins[x]);
}
}
static void init_pins(void) {
unselect_cols();
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputLow(row_pins[x]);
+ gpio_set_pin_input_low(row_pins[x]);
}
}
@@ 55,7 55,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t current_row_value = last_row_value;
// Check row pin state
- if (readPin(row_pins[row_index]) != 0) {
+ if (gpio_read_pin(row_pins[row_index]) != 0) {
// Pin LO, set col bit
current_row_value |= (MATRIX_ROW_SHIFTER << current_col);
} else {
M keyboards/matrix/m12og/rev1/rev1.c => keyboards/matrix/m12og/rev1/rev1.c +1 -1
@@ 17,7 17,7 @@
#include "quantum.h"
void board_init(void) {
- writePinLow(A8);
+ gpio_write_pin_low(A8);
}
void bootloader_jump(void) {
M keyboards/matrix/m12og/rev2/rev2.c => keyboards/matrix/m12og/rev2/rev2.c +9 -9
@@ 4,20 4,20 @@
#include "quantum.h"
-void matrix_init_kb(void) {
- setPinOutput(C6);
- setPinOutput(B2);
- setPinOutput(B1);
-
- matrix_init_user();
+void matrix_init_user(void) {
+ gpio_set_pin_output(C6);
+ gpio_set_pin_output(B2);
+ gpio_set_pin_output(B1);
+
+ matrix_init_user();
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if (res) {
- writePin(B1, !led_state.num_lock);
- writePin(C6, !led_state.caps_lock);
- writePin(B2, !led_state.scroll_lock);
+ gpio_write_pin(B1, !led_state.num_lock);
+ gpio_write_pin(C6, !led_state.caps_lock);
+ gpio_write_pin(B2, !led_state.scroll_lock);
}
return res;
}
M keyboards/mc_76k/mc_76k.c => keyboards/mc_76k/mc_76k.c +3 -3
@@ 17,18 17,18 @@
#include "quantum.h"
void keyboard_pre_init_kb (void) {
- setPinOutput(D2);
+ gpio_set_pin_output(D2);
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- // writePin sets the pin high for 1 and low for 0.
+ // gpio_write_pin sets the pin high for 1 and low for 0.
// In this example the pins are inverted, setting
// it low/0 turns it on, and high/1 turns the LED off.
// This behavior depends on whether the LED is between the pin
// and VCC or the pin and GND.
- writePin(D2, !led_state.caps_lock);
+ gpio_write_pin(D2, !led_state.caps_lock);
}
return res;
}
M keyboards/mechlovin/adelais/standard_led/avr/rev1/matrix.c => keyboards/mechlovin/adelais/standard_led/avr/rev1/matrix.c +134 -134
@@ 37,7 37,7 @@ static void init_pins(void) {
for (int col = 0; col < MATRIX_COLS; col++) {
pin_t pin = direct_pins[row][col];
if (pin != NO_PIN) {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
}
@@ 50,7 50,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
pin_t pin = direct_pins[current_row][col_index];
if (pin != NO_PIN) {
- current_matrix[current_row] |= readPin(pin) ? 0 : (MATRIX_ROW_SHIFTER << col_index);
+ current_matrix[current_row] |= gpio_read_pin(pin) ? 0 : (MATRIX_ROW_SHIFTER << col_index);
}
}
@@ 97,94 97,94 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
static void select_col(uint8_t col) {
switch (col) {
case 0:
- writePinLow(F4);
- writePinLow(F1);
- writePinHigh(F0);
- writePinHigh(F5);
+ gpio_write_pin_low(F4);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F5);
break;
case 1:
- writePinLow(F4);
- writePinHigh(F1);
- writePinLow(F0);
- writePinHigh(F5);
+ gpio_write_pin_low(F4);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F5);
break;
case 2:
- writePinLow(F4);
- writePinHigh(F1);
- writePinHigh(F0);
- writePinHigh(F5);
+ gpio_write_pin_low(F4);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F5);
break;
case 3:
- writePinHigh(F4);
- writePinLow(F1);
- writePinLow(F0);
- writePinHigh(F5);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F5);
break;
case 4:
- writePinHigh(F4);
- writePinLow(F1);
- writePinHigh(F0);
- writePinHigh(F5);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F5);
break;
case 5:
- writePinHigh(F4);
- writePinHigh(F1);
- writePinHigh(F0);
- writePinHigh(F5);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F5);
break;
case 6:
- writePinHigh(F4);
- writePinHigh(F1);
- writePinHigh(F0);
- writePinHigh(F6);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F6);
break;
case 7:
- writePinLow(F4);
- writePinLow(F1);
- writePinLow(F0);
- writePinHigh(F6);
+ gpio_write_pin_low(F4);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F6);
break;
case 8:
- writePinLow(F4);
- writePinLow(F1);
- writePinHigh(F0);
- writePinHigh(F6);
+ gpio_write_pin_low(F4);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F6);
break;
case 9:
- writePinLow(F4);
- writePinHigh(F1);
- writePinLow(F0);
- writePinHigh(F6);
+ gpio_write_pin_low(F4);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F6);
break;
case 10:
- writePinLow(F4);
- writePinHigh(F1);
- writePinHigh(F0);
- writePinHigh(F6);
+ gpio_write_pin_low(F4);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F6);
break;
case 11:
- writePinHigh(F4);
- writePinLow(F1);
- writePinLow(F0);
- writePinHigh(F6);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F6);
break;
case 12:
- writePinHigh(F4);
- writePinLow(F1);
- writePinHigh(F0);
- writePinHigh(F6);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F6);
break;
case 13:
- writePinHigh(F4);
- writePinHigh(F1);
- writePinLow(F0);
- writePinHigh(F6);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F6);
break;
case 14:
- writePinLow(F4);
- writePinLow(F1);
- writePinLow(F0);
- writePinHigh(F5);
+ gpio_write_pin_low(F4);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F5);
break;
}
}
@@ 192,94 192,94 @@ static void select_col(uint8_t col) {
static void unselect_col(uint8_t col) {
switch (col) {
case 0:
- writePinHigh(F4);
- writePinHigh(F1);
- writePinLow(F0);
- writePinLow(F5);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F5);
break;
case 1:
- writePinHigh(F4);
- writePinLow(F1);
- writePinHigh(F0);
- writePinLow(F5);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F5);
break;
case 2:
- writePinHigh(F4);
- writePinLow(F1);
- writePinLow(F0);
- writePinLow(F5);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F5);
break;
case 3:
- writePinLow(F4);
- writePinHigh(F1);
- writePinHigh(F0);
- writePinLow(F5);
+ gpio_write_pin_low(F4);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F5);
break;
case 4:
- writePinLow(F4);
- writePinHigh(F1);
- writePinLow(F0);
- writePinLow(F5);
+ gpio_write_pin_low(F4);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F5);
break;
case 5:
- writePinLow(F4);
- writePinLow(F1);
- writePinLow(F0);
- writePinLow(F5);
+ gpio_write_pin_low(F4);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F5);
break;
case 6:
- writePinLow(F4);
- writePinLow(F1);
- writePinLow(F0);
- writePinLow(F6);
+ gpio_write_pin_low(F4);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F6);
break;
case 7:
- writePinHigh(F4);
- writePinHigh(F1);
- writePinHigh(F0);
- writePinLow(F6);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F6);
break;
case 8:
- writePinHigh(F4);
- writePinHigh(F1);
- writePinLow(F0);
- writePinLow(F6);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F6);
break;
case 9:
- writePinHigh(F4);
- writePinLow(F1);
- writePinHigh(F0);
- writePinLow(F6);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F6);
break;
case 10:
- writePinHigh(F4);
- writePinLow(F1);
- writePinLow(F0);
- writePinLow(F6);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F6);
break;
case 11:
- writePinLow(F4);
- writePinHigh(F1);
- writePinHigh(F0);
- writePinLow(F6);
+ gpio_write_pin_low(F4);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F6);
break;
case 12:
- writePinLow(F4);
- writePinHigh(F1);
- writePinLow(F0);
- writePinLow(F6);
+ gpio_write_pin_low(F4);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F6);
break;
case 13:
- writePinLow(F4);
- writePinLow(F1);
- writePinHigh(F0);
- writePinLow(F6);
+ gpio_write_pin_low(F4);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F6);
break;
case 14:
- writePinHigh(F4);
- writePinHigh(F1);
- writePinHigh(F0);
- writePinLow(F5);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F5);
break;
}
}
@@ 287,23 287,23 @@ static void unselect_col(uint8_t col) {
static void unselect_cols(void) {
//Demultiplexer
- writePinHigh(F0);
- writePinHigh(F1);
- writePinHigh(F4);
- writePinLow(F5);
- writePinLow(F6);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_low(F5);
+ gpio_write_pin_low(F6);
}
static void init_pins(void) {
unselect_cols();
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
- setPinOutput(F0);
- setPinOutput(F1);
- setPinOutput(F4);
- setPinOutput(F5);
- setPinOutput(F6);
+ gpio_set_pin_output(F0);
+ gpio_set_pin_output(F1);
+ gpio_set_pin_output(F4);
+ gpio_set_pin_output(F5);
+ gpio_set_pin_output(F6);
}
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
@@ 319,7 319,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0) {
+ if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_matrix[row_index] |= (MATRIX_ROW_SHIFTER << current_col);
} else {
M keyboards/mechlovin/hannah910/hannah910.c => keyboards/mechlovin/hannah910/hannah910.c +11 -11
@@ 16,17 16,17 @@
#include "quantum.h"
void led_init_ports(void) {
- setPinOutput(B2);
- setPinOutput(D0);
- setPinOutput(D1);
- setPinOutput(D2);
+ gpio_set_pin_output(B2);
+ gpio_set_pin_output(D0);
+ gpio_set_pin_output(D1);
+ gpio_set_pin_output(D2);
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(B2, led_state.caps_lock);
+ gpio_write_pin(B2, led_state.caps_lock);
}
return res;
}
@@ 35,22 35,22 @@ layer_state_t layer_state_set_user(layer_state_t state)
{
// if on layer 1, turn on D2 LED, otherwise off.
if (get_highest_layer(state) == 1) {
- writePinHigh(D2);
+ gpio_write_pin_high(D2);
} else {
- writePinLow(D2);
+ gpio_write_pin_low(D2);
}
// if on layer 2, turn on D1 LED, otherwise off.
if (get_highest_layer(state) == 2) {
- writePinHigh(D1);
+ gpio_write_pin_high(D1);
} else {
- writePinLow(D1);
+ gpio_write_pin_low(D1);
}
// if on layer 3, turn on D0 LED, otherwise off.
if (get_highest_layer(state) == 3) {
- writePinHigh(D0);
+ gpio_write_pin_high(D0);
} else {
- writePinLow(D0);
+ gpio_write_pin_low(D0);
}
return state;
M keyboards/mechlovin/infinity87/rev2/matrix.c => keyboards/mechlovin/infinity87/rev2/matrix.c +146 -146
@@ 37,7 37,7 @@ static void init_pins(void) {
for (int col = 0; col < MATRIX_COLS; col++) {
pin_t pin = direct_pins[row][col];
if (pin != NO_PIN) {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
}
@@ 50,7 50,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
pin_t pin = direct_pins[current_row][col_index];
if (pin != NO_PIN) {
- current_matrix[current_row] |= readPin(pin) ? 0 : (MATRIX_ROW_SHIFTER << col_index);
+ current_matrix[current_row] |= gpio_read_pin(pin) ? 0 : (MATRIX_ROW_SHIFTER << col_index);
}
}
@@ 101,103 101,103 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
static void select_col(uint8_t col) {
switch (col) {
case 0:
- writePinLow(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinHigh(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(B0);
break;
case 1:
- writePinLow(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinHigh(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(B0);
break;
case 2:
- writePinLow(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinHigh(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(B0);
break;
case 3:
- writePinLow(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinHigh(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(B0);
break;
case 4:
- writePinHigh(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinHigh(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(B0);
break;
case 5:
- writePinHigh(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinHigh(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(B0);
break;
case 6:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinHigh(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(B0);
break;
case 7:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinHigh(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(B0);
break;
case 8:
- writePinLow(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinHigh(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F1);
break;
case 9:
- writePinLow(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinHigh(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
break;
case 10:
- writePinLow(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinHigh(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F1);
break;
case 11:
- writePinLow(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinHigh(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
break;
case 12:
- writePinHigh(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinHigh(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F1);
break;
case 13:
- writePinHigh(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinHigh(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
break;
case 14:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinHigh(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
break;
case 15:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinHigh(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F1);
break;
case 16:
- writePinLow(E6);
+ gpio_write_pin_low(E6);
break;
}
}
@@ 205,130 205,130 @@ static void select_col(uint8_t col) {
static void unselect_col(uint8_t col) {
switch (col) {
case 0:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinLow(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(B0);
break;
case 1:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinLow(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(B0);
break;
case 2:
- writePinHigh(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinLow(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(B0);
break;
case 3:
- writePinHigh(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinLow(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(B0);
break;
case 4:
- writePinLow(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinLow(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(B0);
break;
case 5:
- writePinLow(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinLow(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(B0);
break;
case 6:
- writePinLow(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinLow(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(B0);
break;
case 7:
- writePinLow(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinLow(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(B0);
break;
case 8:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinLow(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F1);
break;
case 9:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinLow(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
break;
case 10:
- writePinHigh(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinLow(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F1);
break;
case 11:
- writePinHigh(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinLow(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
break;
case 12:
- writePinLow(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinLow(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F1);
break;
case 13:
- writePinLow(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinLow(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
break;
case 14:
- writePinLow(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinLow(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
break;
case 15:
- writePinLow(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinLow(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F1);
break;
case 16:
- writePinHigh(E6);
+ gpio_write_pin_high(E6);
break;
}
}
static void unselect_cols(void) {
//Native
- writePinHigh(E6);
+ gpio_write_pin_high(E6);
//Demultiplexer
- writePinLow(B0);
- writePinLow(F1);
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
+ gpio_write_pin_low(B0);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
}
static void init_pins(void) {
unselect_cols();
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
- setPinOutput(B5);
- setPinOutput(B7);
- setPinOutput(F0);
- setPinOutput(B0);
- setPinOutput(F1);
- setPinOutput(E6);
+ gpio_set_pin_output(B5);
+ gpio_set_pin_output(B7);
+ gpio_set_pin_output(F0);
+ gpio_set_pin_output(B0);
+ gpio_set_pin_output(F1);
+ gpio_set_pin_output(E6);
}
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
@@ 344,7 344,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0) {
+ if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_matrix[row_index] |= (MATRIX_ROW_SHIFTER << current_col);
} else {
M keyboards/mechlovin/infinity875/matrix.c => keyboards/mechlovin/infinity875/matrix.c +146 -146
@@ 37,7 37,7 @@ static void init_pins(void) {
for (int col = 0; col < MATRIX_COLS; col++) {
pin_t pin = direct_pins[row][col];
if (pin != NO_PIN) {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
}
@@ 50,7 50,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
pin_t pin = direct_pins[current_row][col_index];
if (pin != NO_PIN) {
- current_matrix[current_row] |= readPin(pin) ? 0 : (MATRIX_ROW_SHIFTER << col_index);
+ current_matrix[current_row] |= gpio_read_pin(pin) ? 0 : (MATRIX_ROW_SHIFTER << col_index);
}
}
@@ 101,103 101,103 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
static void select_col(uint8_t col) {
switch (col) {
case 0:
- writePinLow(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinHigh(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(B0);
break;
case 1:
- writePinLow(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinHigh(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(B0);
break;
case 2:
- writePinLow(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinHigh(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(B0);
break;
case 3:
- writePinLow(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinHigh(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(B0);
break;
case 4:
- writePinHigh(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinHigh(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(B0);
break;
case 5:
- writePinHigh(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinHigh(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(B0);
break;
case 6:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinHigh(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(B0);
break;
case 7:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinHigh(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(B0);
break;
case 8:
- writePinLow(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinHigh(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F1);
break;
case 9:
- writePinLow(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinHigh(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
break;
case 10:
- writePinLow(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinHigh(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F1);
break;
case 11:
- writePinLow(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinHigh(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
break;
case 12:
- writePinHigh(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinHigh(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F1);
break;
case 13:
- writePinHigh(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinHigh(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
break;
case 14:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinHigh(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
break;
case 15:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinHigh(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F1);
break;
case 16:
- writePinLow(E6);
+ gpio_write_pin_low(E6);
break;
}
}
@@ 205,130 205,130 @@ static void select_col(uint8_t col) {
static void unselect_col(uint8_t col) {
switch (col) {
case 0:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinLow(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(B0);
break;
case 1:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinLow(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(B0);
break;
case 2:
- writePinHigh(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinLow(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(B0);
break;
case 3:
- writePinHigh(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinLow(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(B0);
break;
case 4:
- writePinLow(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinLow(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(B0);
break;
case 5:
- writePinLow(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinLow(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(B0);
break;
case 6:
- writePinLow(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinLow(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(B0);
break;
case 7:
- writePinLow(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinLow(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(B0);
break;
case 8:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinLow(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F1);
break;
case 9:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinLow(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
break;
case 10:
- writePinHigh(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinLow(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F1);
break;
case 11:
- writePinHigh(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinLow(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
break;
case 12:
- writePinLow(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinLow(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F1);
break;
case 13:
- writePinLow(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinLow(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
break;
case 14:
- writePinLow(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinLow(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
break;
case 15:
- writePinLow(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinLow(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F1);
break;
case 16:
- writePinHigh(E6);
+ gpio_write_pin_high(E6);
break;
}
}
static void unselect_cols(void) {
//Native
- writePinHigh(E6);
+ gpio_write_pin_high(E6);
//Demultiplexer
- writePinLow(B0);
- writePinLow(F1);
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
+ gpio_write_pin_low(B0);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
}
static void init_pins(void) {
unselect_cols();
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
- setPinOutput(B5);
- setPinOutput(B7);
- setPinOutput(F0);
- setPinOutput(B0);
- setPinOutput(F1);
- setPinOutput(E6);
+ gpio_set_pin_output(B5);
+ gpio_set_pin_output(B7);
+ gpio_set_pin_output(F0);
+ gpio_set_pin_output(B0);
+ gpio_set_pin_output(F1);
+ gpio_set_pin_output(E6);
}
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
@@ 344,7 344,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0) {
+ if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_matrix[row_index] |= (MATRIX_ROW_SHIFTER << current_col);
} else {
M keyboards/mechlovin/infinityce/infinityce.c => keyboards/mechlovin/infinityce/infinityce.c +2 -2
@@ 18,12 18,12 @@
void led_init_ports(void) {
// * Set our LED pins as output
- setPinOutput(B3);
+ gpio_set_pin_output(B3);
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(B3, led_state.caps_lock);
+ gpio_write_pin(B3, led_state.caps_lock);
rgblight_set_effect_range(1, 30);
if (led_state.scroll_lock) {
rgblight_setrgb_at(255, 255, 255, 0);
M keyboards/mechlovin/kanu/kanu.c => keyboards/mechlovin/kanu/kanu.c +8 -8
@@ 17,15 17,15 @@
#include "quantum.h"
void led_init_ports(void) {
- setPinOutput(B2);
- setPinOutput(D0);
- setPinOutput(D1);
- setPinOutput(D2);
+ gpio_set_pin_output(B2);
+ gpio_set_pin_output(D0);
+ gpio_set_pin_output(D1);
+ gpio_set_pin_output(D2);
}
bool led_update_kb(led_t led_state) {
if(led_update_user(led_state)) {
- writePin(B2, led_state.caps_lock);
+ gpio_write_pin(B2, led_state.caps_lock);
}
return true;
@@ 34,10 34,10 @@ bool led_update_kb(led_t led_state) {
__attribute__((weak))
layer_state_t layer_state_set_user(layer_state_t state) {
// if on layer 1, turn on D2 LED, otherwise off.
- writePin(D2, get_highest_layer(state) == 1);
+ gpio_write_pin(D2, get_highest_layer(state) == 1);
// if on layer 2, turn on D1 LED, otherwise off.
- writePin(D1, get_highest_layer(state) == 2);
+ gpio_write_pin(D1, get_highest_layer(state) == 2);
// if on layer 3, turn on D0 LED, otherwise off.
- writePin(D0, get_highest_layer(state) == 3);
+ gpio_write_pin(D0, get_highest_layer(state) == 3);
return state;
}
M keyboards/mechlovin/kay65/kay65.c => keyboards/mechlovin/kay65/kay65.c +1 -1
@@ 21,5 21,5 @@ void keyboard_pre_init_user(void) {
// Call the keyboard pre init code.
// Set our LED pins as output
- setPinOutput(D7);
+ gpio_set_pin_output(D7);
}
M keyboards/mechlovin/olly/bb/bb.c => keyboards/mechlovin/olly/bb/bb.c +10 -10
@@ 17,19 17,19 @@
#include "quantum.h"
void led_init_ports(void) {
- setPinOutput(C0);
- setPinOutput(D0);
- setPinOutput(D1);
- setPinOutput(C1);
- setPinOutput(C6);
+ gpio_set_pin_output(C0);
+ gpio_set_pin_output(D0);
+ gpio_set_pin_output(D1);
+ gpio_set_pin_output(C1);
+ gpio_set_pin_output(C6);
}
__attribute__((weak)) layer_state_t layer_state_set_user(layer_state_t state) {
- writePin(D1, layer_state_cmp(state, 1));
- writePin(D0, layer_state_cmp(state, 2));
- writePin(C1, layer_state_cmp(state, 3));
- writePin(C0, layer_state_cmp(state, 4));
- writePin(C6, layer_state_cmp(state, 5));
+ gpio_write_pin(D1, layer_state_cmp(state, 1));
+ gpio_write_pin(D0, layer_state_cmp(state, 2));
+ gpio_write_pin(C1, layer_state_cmp(state, 3));
+ gpio_write_pin(C0, layer_state_cmp(state, 4));
+ gpio_write_pin(C6, layer_state_cmp(state, 5));
return state;
}
M keyboards/mechlovin/olly/bb/matrix.c => keyboards/mechlovin/olly/bb/matrix.c +152 -152
@@ 67,109 67,109 @@ static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static void select_col(uint8_t col) {
switch (col) {
case 0:
- writePinLow(A0);
- writePinLow(A1);
- writePinLow(A2);
- writePinHigh(B4);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_high(B4);
break;
case 1:
- writePinLow(A0);
- writePinLow(A1);
- writePinHigh(A2);
- writePinHigh(B4);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_high(B4);
break;
case 2:
- writePinLow(A0);
- writePinHigh(A1);
- writePinLow(A2);
- writePinHigh(B4);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_high(B4);
break;
case 3:
- writePinLow(A0);
- writePinHigh(A1);
- writePinHigh(A2);
- writePinHigh(B4);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_high(B4);
break;
case 4:
- writePinHigh(A0);
- writePinLow(A1);
- writePinLow(A2);
- writePinHigh(B4);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_high(B4);
break;
case 5:
- writePinHigh(A0);
- writePinLow(A1);
- writePinHigh(A2);
- writePinHigh(B4);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_high(B4);
break;
case 6:
- writePinHigh(A0);
- writePinHigh(A1);
- writePinLow(A2);
- writePinHigh(B4);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_high(B4);
break;
case 7:
- writePinHigh(A0);
- writePinHigh(A1);
- writePinHigh(A2);
- writePinHigh(B4);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_high(B4);
break;
case 8:
- writePinHigh(A0);
- writePinHigh(A1);
- writePinHigh(A2);
- writePinHigh(C7);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_high(C7);
break;
case 9:
- writePinLow(A0);
- writePinLow(A1);
- writePinLow(A2);
- writePinHigh(C7);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_high(C7);
break;
case 10:
- writePinLow(A0);
- writePinLow(A1);
- writePinHigh(A2);
- writePinHigh(C7);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_high(C7);
break;
case 11:
- writePinLow(A0);
- writePinHigh(A1);
- writePinLow(A2);
- writePinHigh(C7);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_high(C7);
break;
case 12:
- writePinLow(A0);
- writePinHigh(A1);
- writePinHigh(A2);
- writePinHigh(C7);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_high(C7);
break;
case 13:
- writePinHigh(A0);
- writePinLow(A1);
- writePinLow(A2);
- writePinHigh(C7);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_high(C7);
break;
case 14:
- writePinHigh(A0);
- writePinLow(A1);
- writePinHigh(A2);
- writePinHigh(C7);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_high(C7);
break;
case 15:
- writePinHigh(A0);
- writePinHigh(A1);
- writePinLow(A2);
- writePinHigh(C7);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_high(C7);
break;
case 16:
- writePinLow(C2);
+ gpio_write_pin_low(C2);
break;
case 17:
- writePinLow(C3);
+ gpio_write_pin_low(C3);
break;
case 18:
- writePinLow(C5);
+ gpio_write_pin_low(C5);
break;
}
}
@@ 177,140 177,140 @@ static void select_col(uint8_t col) {
static void unselect_col(uint8_t col) {
switch (col) {
case 0:
- writePinHigh(A0);
- writePinHigh(A1);
- writePinHigh(A2);
- writePinLow(B4);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_low(B4);
break;
case 1:
- writePinHigh(A0);
- writePinHigh(A1);
- writePinLow(A2);
- writePinLow(B4);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_low(B4);
break;
case 2:
- writePinHigh(A0);
- writePinLow(A1);
- writePinHigh(A2);
- writePinLow(B4);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_low(B4);
break;
case 3:
- writePinHigh(A0);
- writePinLow(A1);
- writePinLow(A2);
- writePinLow(B4);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_low(B4);
break;
case 4:
- writePinLow(A0);
- writePinHigh(A1);
- writePinHigh(A2);
- writePinLow(B4);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_low(B4);
break;
case 5:
- writePinLow(A0);
- writePinHigh(A1);
- writePinLow(A2);
- writePinLow(B4);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_low(B4);
break;
case 6:
- writePinLow(A0);
- writePinLow(A1);
- writePinHigh(A2);
- writePinLow(B4);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_low(B4);
break;
case 7:
- writePinLow(A0);
- writePinLow(A1);
- writePinLow(A2);
- writePinLow(B4);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_low(B4);
break;
case 8:
- writePinLow(A0);
- writePinLow(A1);
- writePinLow(A2);
- writePinLow(C7);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_low(C7);
break;
case 9:
- writePinHigh(A0);
- writePinHigh(A1);
- writePinHigh(A2);
- writePinLow(C7);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_low(C7);
break;
case 10:
- writePinHigh(A0);
- writePinHigh(A1);
- writePinLow(A2);
- writePinLow(C7);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_low(C7);
break;
case 11:
- writePinHigh(A0);
- writePinLow(A1);
- writePinHigh(A2);
- writePinLow(C7);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_low(C7);
break;
case 12:
- writePinHigh(A0);
- writePinLow(A1);
- writePinLow(A2);
- writePinLow(C7);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_low(C7);
break;
case 13:
- writePinLow(A0);
- writePinHigh(A1);
- writePinHigh(A2);
- writePinLow(C7);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_low(C7);
break;
case 14:
- writePinLow(A0);
- writePinHigh(A1);
- writePinLow(A2);
- writePinLow(C7);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_low(C7);
break;
case 15:
- writePinLow(A0);
- writePinLow(A1);
- writePinHigh(A2);
- writePinLow(C7);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_low(C7);
break;
case 16:
- writePinHigh(C2);
+ gpio_write_pin_high(C2);
break;
case 17:
- writePinHigh(C3);
+ gpio_write_pin_high(C3);
break;
case 18:
- writePinHigh(C5);
+ gpio_write_pin_high(C5);
break;
}
}
static void unselect_cols(void) {
//Native
- writePinHigh(C2);
- writePinHigh(C3);
- writePinHigh(C5);
+ gpio_write_pin_high(C2);
+ gpio_write_pin_high(C3);
+ gpio_write_pin_high(C5);
//Demultiplexer
- writePinLow(B4);
- writePinLow(C7);
- writePinHigh(A0);
- writePinHigh(A1);
- writePinHigh(A2);
+ gpio_write_pin_low(B4);
+ gpio_write_pin_low(C7);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_high(A2);
}
static void init_pins(void) {
unselect_cols();
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
- setPinOutput(A0);
- setPinOutput(A1);
- setPinOutput(A2);
- setPinOutput(B4);
- setPinOutput(C7);
- setPinOutput(C2);
- setPinOutput(C3);
- setPinOutput(C5);
+ gpio_set_pin_output(A0);
+ gpio_set_pin_output(A1);
+ gpio_set_pin_output(A2);
+ gpio_set_pin_output(B4);
+ gpio_set_pin_output(C7);
+ gpio_set_pin_output(C2);
+ gpio_set_pin_output(C3);
+ gpio_set_pin_output(C5);
}
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
@@ 326,7 326,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0) {
+ if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_matrix[row_index] |= (MATRIX_ROW_SHIFTER << current_col);
} else {
M keyboards/mechlovin/olly/jf/rev1/matrix.c => keyboards/mechlovin/olly/jf/rev1/matrix.c +160 -160
@@ 37,7 37,7 @@ static void init_pins(void) {
for (int col = 0; col < MATRIX_COLS; col++) {
pin_t pin = direct_pins[row][col];
if (pin != NO_PIN) {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
}
@@ 50,7 50,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
pin_t pin = direct_pins[current_row][col_index];
if (pin != NO_PIN) {
- current_matrix[current_row] |= readPin(pin) ? 0 : (MATRIX_ROW_SHIFTER << col_index);
+ current_matrix[current_row] |= gpio_read_pin(pin) ? 0 : (MATRIX_ROW_SHIFTER << col_index);
}
}
@@ 60,22 60,22 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
#elif (DIODE_DIRECTION == COL2ROW)
static void select_row(uint8_t row) {
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
-static void unselect_row(uint8_t row) { setPinInputHigh(row_pins[row]); }
+static void unselect_row(uint8_t row) { gpio_set_pin_input_high(row_pins[row]); }
static void unselect_rows(void) {
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void init_pins(void) {
unselect_rows();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 94,7 94,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
@@ 154,109 154,109 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
static void select_col(uint8_t col) {
switch (col) {
case 0:
- writePinLow(A0);
- writePinLow(A1);
- writePinLow(A2);
- writePinHigh(B4);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_high(B4);
break;
case 1:
- writePinLow(A0);
- writePinLow(A1);
- writePinHigh(A2);
- writePinHigh(B4);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_high(B4);
break;
case 2:
- writePinLow(A0);
- writePinHigh(A1);
- writePinLow(A2);
- writePinHigh(B4);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_high(B4);
break;
case 3:
- writePinLow(A0);
- writePinHigh(A1);
- writePinHigh(A2);
- writePinHigh(B4);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_high(B4);
break;
case 4:
- writePinHigh(A0);
- writePinLow(A1);
- writePinLow(A2);
- writePinHigh(B4);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_high(B4);
break;
case 5:
- writePinHigh(A0);
- writePinLow(A1);
- writePinHigh(A2);
- writePinHigh(B4);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_high(B4);
break;
case 6:
- writePinHigh(A0);
- writePinHigh(A1);
- writePinLow(A2);
- writePinHigh(B4);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_high(B4);
break;
case 7:
- writePinHigh(A0);
- writePinHigh(A1);
- writePinHigh(A2);
- writePinHigh(B4);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_high(B4);
break;
case 8:
- writePinHigh(A0);
- writePinHigh(A1);
- writePinHigh(A2);
- writePinHigh(C7);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_high(C7);
break;
case 9:
- writePinLow(A0);
- writePinLow(A1);
- writePinLow(A2);
- writePinHigh(C7);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_high(C7);
break;
case 10:
- writePinLow(A0);
- writePinLow(A1);
- writePinHigh(A2);
- writePinHigh(C7);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_high(C7);
break;
case 11:
- writePinLow(A0);
- writePinHigh(A1);
- writePinLow(A2);
- writePinHigh(C7);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_high(C7);
break;
case 12:
- writePinLow(A0);
- writePinHigh(A1);
- writePinHigh(A2);
- writePinHigh(C7);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_high(C7);
break;
case 13:
- writePinHigh(A0);
- writePinLow(A1);
- writePinLow(A2);
- writePinHigh(C7);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_high(C7);
break;
case 14:
- writePinHigh(A0);
- writePinLow(A1);
- writePinHigh(A2);
- writePinHigh(C7);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_high(C7);
break;
case 15:
- writePinHigh(A0);
- writePinHigh(A1);
- writePinLow(A2);
- writePinHigh(C7);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_high(C7);
break;
case 16:
- writePinLow(C2);
+ gpio_write_pin_low(C2);
break;
case 17:
- writePinLow(C3);
+ gpio_write_pin_low(C3);
break;
case 18:
- writePinLow(C5);
+ gpio_write_pin_low(C5);
break;
}
}
@@ 264,140 264,140 @@ static void select_col(uint8_t col) {
static void unselect_col(uint8_t col) {
switch (col) {
case 0:
- writePinHigh(A0);
- writePinHigh(A1);
- writePinHigh(A2);
- writePinLow(B4);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_low(B4);
break;
case 1:
- writePinHigh(A0);
- writePinHigh(A1);
- writePinLow(A2);
- writePinLow(B4);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_low(B4);
break;
case 2:
- writePinHigh(A0);
- writePinLow(A1);
- writePinHigh(A2);
- writePinLow(B4);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_low(B4);
break;
case 3:
- writePinHigh(A0);
- writePinLow(A1);
- writePinLow(A2);
- writePinLow(B4);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_low(B4);
break;
case 4:
- writePinLow(A0);
- writePinHigh(A1);
- writePinHigh(A2);
- writePinLow(B4);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_low(B4);
break;
case 5:
- writePinLow(A0);
- writePinHigh(A1);
- writePinLow(A2);
- writePinLow(B4);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_low(B4);
break;
case 6:
- writePinLow(A0);
- writePinLow(A1);
- writePinHigh(A2);
- writePinLow(B4);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_low(B4);
break;
case 7:
- writePinLow(A0);
- writePinLow(A1);
- writePinLow(A2);
- writePinLow(B4);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_low(B4);
break;
case 8:
- writePinLow(A0);
- writePinLow(A1);
- writePinLow(A2);
- writePinLow(C7);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_low(C7);
break;
case 9:
- writePinHigh(A0);
- writePinHigh(A1);
- writePinHigh(A2);
- writePinLow(C7);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_low(C7);
break;
case 10:
- writePinHigh(A0);
- writePinHigh(A1);
- writePinLow(A2);
- writePinLow(C7);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_low(C7);
break;
case 11:
- writePinHigh(A0);
- writePinLow(A1);
- writePinHigh(A2);
- writePinLow(C7);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_low(C7);
break;
case 12:
- writePinHigh(A0);
- writePinLow(A1);
- writePinLow(A2);
- writePinLow(C7);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_low(C7);
break;
case 13:
- writePinLow(A0);
- writePinHigh(A1);
- writePinHigh(A2);
- writePinLow(C7);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_low(C7);
break;
case 14:
- writePinLow(A0);
- writePinHigh(A1);
- writePinLow(A2);
- writePinLow(C7);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_low(A2);
+ gpio_write_pin_low(C7);
break;
case 15:
- writePinLow(A0);
- writePinLow(A1);
- writePinHigh(A2);
- writePinLow(C7);
+ gpio_write_pin_low(A0);
+ gpio_write_pin_low(A1);
+ gpio_write_pin_high(A2);
+ gpio_write_pin_low(C7);
break;
case 16:
- writePinHigh(C2);
+ gpio_write_pin_high(C2);
break;
case 17:
- writePinHigh(C3);
+ gpio_write_pin_high(C3);
break;
case 18:
- writePinHigh(C5);
+ gpio_write_pin_high(C5);
break;
}
}
static void unselect_cols(void) {
//Native
- writePinHigh(C2);
- writePinHigh(C3);
- writePinHigh(C5);
+ gpio_write_pin_high(C2);
+ gpio_write_pin_high(C3);
+ gpio_write_pin_high(C5);
//Demultiplexer
- writePinLow(B4);
- writePinLow(C7);
- writePinHigh(A0);
- writePinHigh(A1);
- writePinHigh(A2);
+ gpio_write_pin_low(B4);
+ gpio_write_pin_low(C7);
+ gpio_write_pin_high(A0);
+ gpio_write_pin_high(A1);
+ gpio_write_pin_high(A2);
}
static void init_pins(void) {
unselect_cols();
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
- setPinOutput(A0);
- setPinOutput(A1);
- setPinOutput(A2);
- setPinOutput(B4);
- setPinOutput(C7);
- setPinOutput(C2);
- setPinOutput(C3);
- setPinOutput(C5);
+ gpio_set_pin_output(A0);
+ gpio_set_pin_output(A1);
+ gpio_set_pin_output(A2);
+ gpio_set_pin_output(B4);
+ gpio_set_pin_output(C7);
+ gpio_set_pin_output(C2);
+ gpio_set_pin_output(C3);
+ gpio_set_pin_output(C5);
}
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
@@ 413,7 413,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0) {
+ if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_matrix[row_index] |= (MATRIX_ROW_SHIFTER << current_col);
} else {
M keyboards/mechlovin/olly/jf/rev1/rev1.c => keyboards/mechlovin/olly/jf/rev1/rev1.c +13 -13
@@ 18,22 18,22 @@
void led_init_ports(void) {
- setPinOutput(C0);
- setPinOutput(D0);
- setPinOutput(D1);
- setPinOutput(C1);
- setPinOutput(C6);
- setPinOutput(B0);
- setPinOutput(B1);
- setPinOutput(B2);
+ gpio_set_pin_output(C0);
+ gpio_set_pin_output(D0);
+ gpio_set_pin_output(D1);
+ gpio_set_pin_output(C1);
+ gpio_set_pin_output(C6);
+ gpio_set_pin_output(B0);
+ gpio_set_pin_output(B1);
+ gpio_set_pin_output(B2);
}
layer_state_t layer_state_set_user(layer_state_t state) {
- writePin(D1, layer_state_cmp(state, 1));
- writePin(D0, layer_state_cmp(state, 2));
- writePin(C1, layer_state_cmp(state, 3));
- writePin(C0, layer_state_cmp(state, 4));
- writePin(C6, layer_state_cmp(state, 5));
+ gpio_write_pin(D1, layer_state_cmp(state, 1));
+ gpio_write_pin(D0, layer_state_cmp(state, 2));
+ gpio_write_pin(C1, layer_state_cmp(state, 3));
+ gpio_write_pin(C0, layer_state_cmp(state, 4));
+ gpio_write_pin(C6, layer_state_cmp(state, 5));
return state;
}
M keyboards/mechlovin/olly/orion/orion.c => keyboards/mechlovin/olly/orion/orion.c +10 -10
@@ 22,20 22,20 @@ void board_init(void) {
}
void keyboard_pre_init_kb(void) {
- setPinOutput(B5);
- setPinOutput(B6);
- setPinOutput(B7);
- setPinOutput(B8);
- setPinOutput(B9);
+ gpio_set_pin_output(B5);
+ gpio_set_pin_output(B6);
+ gpio_set_pin_output(B7);
+ gpio_set_pin_output(B8);
+ gpio_set_pin_output(B9);
keyboard_pre_init_user();
}
layer_state_t layer_state_set_kb(layer_state_t state) {
state = layer_state_set_user(state);
- writePin(B7, layer_state_cmp(state, 0));
- writePin(B6, layer_state_cmp(state, 1));
- writePin(B5, layer_state_cmp(state, 2));
- writePin(B8, layer_state_cmp(state, 3));
- writePin(B9, layer_state_cmp(state, 4));
+ gpio_write_pin(B7, layer_state_cmp(state, 0));
+ gpio_write_pin(B6, layer_state_cmp(state, 1));
+ gpio_write_pin(B5, layer_state_cmp(state, 2));
+ gpio_write_pin(B8, layer_state_cmp(state, 3));
+ gpio_write_pin(B9, layer_state_cmp(state, 4));
return state;
}
M keyboards/mechlovin/serratus/matrix.c => keyboards/mechlovin/serratus/matrix.c +146 -146
@@ 37,7 37,7 @@ static void init_pins(void) {
for (int col = 0; col < MATRIX_COLS; col++) {
pin_t pin = direct_pins[row][col];
if (pin != NO_PIN) {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
}
@@ 50,7 50,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
pin_t pin = direct_pins[current_row][col_index];
if (pin != NO_PIN) {
- current_matrix[current_row] |= readPin(pin) ? 0 : (MATRIX_ROW_SHIFTER << col_index);
+ current_matrix[current_row] |= gpio_read_pin(pin) ? 0 : (MATRIX_ROW_SHIFTER << col_index);
}
}
@@ 101,103 101,103 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
static void select_col(uint8_t col) {
switch (col) {
case 0:
- writePinLow(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinHigh(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(B0);
break;
case 1:
- writePinLow(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinHigh(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(B0);
break;
case 2:
- writePinLow(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinHigh(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(B0);
break;
case 3:
- writePinLow(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinHigh(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(B0);
break;
case 4:
- writePinHigh(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinHigh(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(B0);
break;
case 5:
- writePinHigh(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinHigh(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(B0);
break;
case 6:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinHigh(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(B0);
break;
case 7:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinHigh(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(B0);
break;
case 8:
- writePinLow(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinHigh(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F1);
break;
case 9:
- writePinLow(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinHigh(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
break;
case 10:
- writePinLow(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinHigh(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F1);
break;
case 11:
- writePinLow(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinHigh(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
break;
case 12:
- writePinHigh(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinHigh(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F1);
break;
case 13:
- writePinHigh(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinHigh(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
break;
case 14:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinHigh(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_high(F1);
break;
case 15:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinHigh(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_high(F1);
break;
case 16:
- writePinLow(E6);
+ gpio_write_pin_low(E6);
break;
}
}
@@ 205,130 205,130 @@ static void select_col(uint8_t col) {
static void unselect_col(uint8_t col) {
switch (col) {
case 0:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinLow(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(B0);
break;
case 1:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinLow(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(B0);
break;
case 2:
- writePinHigh(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinLow(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(B0);
break;
case 3:
- writePinHigh(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinLow(B0);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(B0);
break;
case 4:
- writePinLow(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinLow(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(B0);
break;
case 5:
- writePinLow(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinLow(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(B0);
break;
case 6:
- writePinLow(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinLow(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(B0);
break;
case 7:
- writePinLow(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinLow(B0);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(B0);
break;
case 8:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinLow(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F1);
break;
case 9:
- writePinHigh(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinLow(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
break;
case 10:
- writePinHigh(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinLow(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F1);
break;
case 11:
- writePinHigh(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinLow(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
break;
case 12:
- writePinLow(B5);
- writePinHigh(B7);
- writePinHigh(F0);
- writePinLow(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F1);
break;
case 13:
- writePinLow(B5);
- writePinHigh(B7);
- writePinLow(F0);
- writePinLow(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
break;
case 14:
- writePinLow(B5);
- writePinLow(B7);
- writePinLow(F0);
- writePinLow(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_low(F0);
+ gpio_write_pin_low(F1);
break;
case 15:
- writePinLow(B5);
- writePinLow(B7);
- writePinHigh(F0);
- writePinLow(F1);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B7);
+ gpio_write_pin_high(F0);
+ gpio_write_pin_low(F1);
break;
case 16:
- writePinHigh(E6);
+ gpio_write_pin_high(E6);
break;
}
}
static void unselect_cols(void) {
//Native
- writePinHigh(E6);
+ gpio_write_pin_high(E6);
//Demultiplexer
- writePinLow(B0);
- writePinLow(F1);
- writePinHigh(B5);
- writePinHigh(B7);
- writePinHigh(F0);
+ gpio_write_pin_low(B0);
+ gpio_write_pin_low(F1);
+ gpio_write_pin_high(B5);
+ gpio_write_pin_high(B7);
+ gpio_write_pin_high(F0);
}
static void init_pins(void) {
unselect_cols();
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
- setPinOutput(B5);
- setPinOutput(B7);
- setPinOutput(F0);
- setPinOutput(B0);
- setPinOutput(F1);
- setPinOutput(E6);
+ gpio_set_pin_output(B5);
+ gpio_set_pin_output(B7);
+ gpio_set_pin_output(F0);
+ gpio_set_pin_output(B0);
+ gpio_set_pin_output(F1);
+ gpio_set_pin_output(E6);
}
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
@@ 344,7 344,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0) {
+ if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_matrix[row_index] |= (MATRIX_ROW_SHIFTER << current_col);
} else {
M keyboards/mechlovin/zed65/no_backlight/wearhaus66/wearhaus66.c => keyboards/mechlovin/zed65/no_backlight/wearhaus66/wearhaus66.c +1 -1
@@ 20,5 20,5 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
void keyboard_pre_init_user(void) {
// Call the keyboard pre init code.
// Set our LED pins as output
- setPinOutput(B7);
+ gpio_set_pin_output(B7);
}
M keyboards/mechwild/puckbuddy/puckbuddy.c => keyboards/mechwild/puckbuddy/puckbuddy.c +1 -1
@@ 21,7 21,7 @@ uint16_t dpi_array[] = GLIDEPOINT_DPI_OPTIONS;
void board_init(void) {
// B9 is configured as I2C1_SDA in the board file; that function must be
// disabled before using B7 as I2C1_SDA.
- setPinInputHigh(B9);
+ gpio_set_pin_input_high(B9);
}
#ifdef DYNAMIC_TAPPING_TERM_ENABLE
M keyboards/mechwild/sugarglider/sugarglider.c => keyboards/mechwild/sugarglider/sugarglider.c +12 -12
@@ 19,14 19,14 @@ uint16_t dpi_array[] = GLIDEPOINT_DPI_OPTIONS;
void board_init(void) {
// B9 is configured as I2C1_SDA in the board file; that function must be
// disabled before using B7 as I2C1_SDA.
- setPinInputHigh(B9);
- setPinOutput(B12);
- setPinOutput(B13);
- setPinOutput(B14);
- writePinLow(B12);
- writePinLow(B13);
- writePinLow(B14);
- setPinOutput(C13);
+ gpio_set_pin_input_high(B9);
+ gpio_set_pin_output(B12);
+ gpio_set_pin_output(B13);
+ gpio_set_pin_output(B14);
+ gpio_write_pin_low(B12);
+ gpio_write_pin_low(B13);
+ gpio_write_pin_low(B14);
+ gpio_set_pin_output(C13);
}
#ifdef DYNAMIC_TAPPING_TERM_ENABLE
@@ 110,10 110,10 @@ bool encoder_update_kb(uint8_t index, bool clockwise) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(B12, led_state.num_lock); // Updates status LEDs
- writePin(B13, led_state.caps_lock); // Updates status LEDs
- writePin(B14, led_state.scroll_lock); // Updates status LEDs
- writePin(C13, !led_state.caps_lock); // Updates status LEDs, this is the LED on the blackpill itself
+ gpio_write_pin(B12, led_state.num_lock); // Updates status LEDs
+ gpio_write_pin(B13, led_state.caps_lock); // Updates status LEDs
+ gpio_write_pin(B14, led_state.scroll_lock); // Updates status LEDs
+ gpio_write_pin(C13, !led_state.caps_lock); // Updates status LEDs, this is the LED on the blackpill itself
}
return res;
}
M keyboards/mexsistor/ludmila/matrix.c => keyboards/mexsistor/ludmila/matrix.c +8 -8
@@ 31,22 31,22 @@ extern matrix_row_t matrix[MATRIX_ROWS]; // debounced values
static void select_row(uint8_t row) {
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
-static void unselect_row(uint8_t row) { setPinInputHigh(row_pins[row]); }
+static void unselect_row(uint8_t row) { gpio_set_pin_input_high(row_pins[row]); }
static void unselect_rows(void) {
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void init_pins(void) {
unselect_rows();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 64,7 64,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
@@ 79,7 79,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
void matrix_init_custom(void) {
// initialize key pins
- setPinInput(ENC_SW);
+ gpio_set_pin_input(ENC_SW);
init_pins();
}
@@ 108,7 108,7 @@ static bool read_encoder_switches(matrix_row_t current_matrix[], uint8_t current
static uint8_t btn_1_array;
bool btn_1_pressed = 0;
btn_1_array <<= 1;
- btn_1_array |= readPin(ENC_SW);
+ btn_1_array |= gpio_read_pin(ENC_SW);
(btn_1_array == 0b11111111) ? (btn_1_pressed = 1) : (btn_1_pressed = 0);
// Populate the matrix row with the state of the encoder
M keyboards/miiiw/blackio83/rev_0100/matrix.c => keyboards/miiiw/blackio83/rev_0100/matrix.c +12 -12
@@ 34,7 34,7 @@ static pin_t dip_switch_pad[] = DIP_SWITCH_PINS;
void matrix_init_custom(void) {
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
- setPinInputLow(row_pins[row]);
+ gpio_set_pin_input_low(row_pins[row]);
}
shift_init();
@@ 65,12 65,12 @@ bool matrix_scan_custom(matrix_row_t current_matrix[]) {
void matrix_power_up(void) {
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
palDisableLineEvent(row_pins[row]);
- setPinInputLow(row_pins[row]);
+ gpio_set_pin_input_low(row_pins[row]);
}
init_cols();
#ifdef DIP_SWITCH_PINS
for (uint8_t i = 1; i < NUMBER_OF_DIP_SWITCHES; i++) {
- setPinInputHigh(dip_switch_pad[i]);
+ gpio_set_pin_input_high(dip_switch_pad[i]);
}
#endif
}
@@ 78,12 78,12 @@ void matrix_power_up(void) {
void matrix_power_down(void) {
unselect_cols();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
- setPinInputLow(row_pins[row]);
+ gpio_set_pin_input_low(row_pins[row]);
palEnableLineEvent(row_pins[row], PAL_EVENT_MODE_RISING_EDGE);
}
#ifdef DIP_SWITCH_PINS
for (uint8_t i = 1; i < NUMBER_OF_DIP_SWITCHES; i++) {
- setPinInputLow(dip_switch_pad[i]);
+ gpio_set_pin_input_low(dip_switch_pad[i]);
}
#endif
}
@@ 91,7 91,7 @@ void matrix_power_down(void) {
static uint8_t read_rows(void) {
uint8_t row_value = 0;
for(uint8_t row = 0; row < MATRIX_ROWS; row++) {
- row_value |= (readPin(row_pins[row]) << row);
+ row_value |= (gpio_read_pin(row_pins[row]) << row);
}
return row_value;
}
@@ 100,15 100,15 @@ static void init_cols(void) {
shift_writeAll(0);
for(uint8_t col = 0; col < MATRIX_COLS; col++) {
if(col_pins[col] < H0) {
- setPinOutput(col_pins[col]);
- writePinLow(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
}
}
static void select_col(uint8_t col) {
if(col_pins[col] < H0){
- writePinHigh(col_pins[col]);
+ gpio_write_pin_high(col_pins[col]);
waitInputPinDelay();
waitInputPinDelay();
waitInputPinDelay();
@@ 122,7 122,7 @@ static void select_col(uint8_t col) {
static void unselect_col(uint8_t col) {
if(col_pins[col] < H0){
- writePinLow(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}else{
shift_writePin(col_pins[col], 0);
}
@@ 132,8 132,8 @@ static void unselect_cols(void) {
shift_writeAll(1);
for(uint8_t col = 0; col < MATRIX_COLS; col++) {
if(col_pins[col] < H0) {
- setPinOutput(col_pins[col]);
- writePinHigh(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_high(col_pins[col]);
}
}
}
M keyboards/miiiw/blackio83/rev_0100/rev_0100.c => keyboards/miiiw/blackio83/rev_0100/rev_0100.c +17 -17
@@ 49,25 49,25 @@ void ws2812_poweron(void) {
if(p_setup) return;
p_setup = true;
s_init = false;
- setPinOutput(RGB_EN_PIN);
- writePinHigh(RGB_EN_PIN);
+ gpio_set_pin_output(RGB_EN_PIN);
+ gpio_write_pin_high(RGB_EN_PIN);
}
void ws2812_poweroff(void) {
if(!p_setup) return;
p_setup = false;
- setPinInputLow(WS2812_DI_PIN);
- writePinLow(RGB_EN_PIN);
+ gpio_set_pin_input_low(WS2812_DI_PIN);
+ gpio_write_pin_low(RGB_EN_PIN);
}
void keyboard_pre_init_kb() {
keyboard_pre_init_user();
- setPinInputLow(MWPROTO_STATUS_PIN);
- setPinOutput(MWPROTO_WAKEUP_PIN);
- writePinLow(MWPROTO_WAKEUP_PIN);
+ gpio_set_pin_input_low(MWPROTO_STATUS_PIN);
+ gpio_set_pin_output(MWPROTO_WAKEUP_PIN);
+ gpio_write_pin_low(MWPROTO_WAKEUP_PIN);
wait_ms(2);
- writePinHigh(MWPROTO_WAKEUP_PIN);
+ gpio_write_pin_high(MWPROTO_WAKEUP_PIN);
palSetLineMode(MWPROTO_TX_PIN, PAL_MODE_ALTERNATE(MWPROTO_TX_PAL_MODE) | PAL_OUTPUT_TYPE_OPENDRAIN);
sdStart(&MWPROTO_DRIVER, &mwproto_uart_config);
@@ 84,14 84,14 @@ void keyboard_post_init_kb(void) {
"BUILD: " __DATE__ "\n"
); /* clang-format on */
- writePinLow(MWPROTO_WAKEUP_PIN);
+ gpio_write_pin_low(MWPROTO_WAKEUP_PIN);
wait_ms(50);
sdPutI(&MWPROTO_DRIVER, 0xA5);
sdPutI(&MWPROTO_DRIVER, 0x12);
sdPutI(&MWPROTO_DRIVER, 0x01);
sdPutI(&MWPROTO_DRIVER, 0x02);
sdPutI(&MWPROTO_DRIVER, 0xB4);
- writePinHigh(MWPROTO_WAKEUP_PIN);
+ gpio_write_pin_high(MWPROTO_WAKEUP_PIN);
ws2812_poweron();
loop10hz_token = defer_exec(LOOP_10HZ_PERIOD, loop_10Hz, NULL);
@@ 117,7 117,7 @@ bool dip_switch_update_mask_kb(uint32_t state) {
usbDisconnectBus(&USB_DRIVER);
usbStop(&USB_DRIVER);
shutdown_user(true);
- setPinInputHigh(POWER_SWITCH_PIN);
+ gpio_set_pin_input_high(POWER_SWITCH_PIN);
palEnableLineEvent(POWER_SWITCH_PIN, PAL_EVENT_MODE_RISING_EDGE);
POWER_EnterSleep();
}
@@ 132,8 132,8 @@ uint32_t loop_10Hz(uint32_t trigger_time, void *cb_arg) {
static uint32_t pmu_timer = 0;
if(timer_elapsed32(pmu_timer) > 3000) {
pmu_timer = timer_read32();
- writePinLow(MWPROTO_WAKEUP_PIN);
- if(readPin(MWPROTO_STATUS_PIN))
+ gpio_write_pin_low(MWPROTO_WAKEUP_PIN);
+ if(gpio_read_pin(MWPROTO_STATUS_PIN))
wait_us(500);
else
wait_us(1500);
@@ 141,7 141,7 @@ uint32_t loop_10Hz(uint32_t trigger_time, void *cb_arg) {
sdPutI(&MWPROTO_DRIVER, 0x28);
sdPutI(&MWPROTO_DRIVER, 0x00);
sdPutI(&MWPROTO_DRIVER, 0x8D);
- writePinHigh(MWPROTO_WAKEUP_PIN);
+ gpio_write_pin_high(MWPROTO_WAKEUP_PIN);
}
}
@@ 151,8 151,8 @@ uint32_t loop_10Hz(uint32_t trigger_time, void *cb_arg) {
matrix[2] == 0 && matrix[3] == 0 && matrix[4] == 0 && matrix[5] == 0x201) {
if(restore_tick++ > 50) {
restore_tick = 0;
- writePinLow(MWPROTO_WAKEUP_PIN);
- if(readPin(MWPROTO_STATUS_PIN))
+ gpio_write_pin_low(MWPROTO_WAKEUP_PIN);
+ if(gpio_read_pin(MWPROTO_STATUS_PIN))
wait_us(500);
else
wait_us(1500);
@@ 161,7 161,7 @@ uint32_t loop_10Hz(uint32_t trigger_time, void *cb_arg) {
sdPutI(&MWPROTO_DRIVER, 0x01);
sdPutI(&MWPROTO_DRIVER, 0x0F);
sdPutI(&MWPROTO_DRIVER, 0xB4);
- writePinHigh(MWPROTO_WAKEUP_PIN);
+ gpio_write_pin_high(MWPROTO_WAKEUP_PIN);
wait_ms(50);
eeconfig_init();
#ifdef RGB_MATRIX_ENABLE
M keyboards/miiiw/common/shift_register.c => keyboards/miiiw/common/shift_register.c +18 -18
@@ 23,30 23,30 @@ static uint8_t shift_values[SHR_SERIES_NUM] = {0};
void shift_init(void) {
#ifdef SHR_OE_PIN
- setPinOutput(SHR_OE_PIN);
- writePinHigh(SHR_OE_PIN);
+ gpio_set_pin_output(SHR_OE_PIN);
+ gpio_write_pin_high(SHR_OE_PIN);
#endif
- setPinOutput(SHR_DATA_PIN);
- setPinOutput(SHR_LATCH_PIN);
- setPinOutput(SHR_CLOCK_PIN);
+ gpio_set_pin_output(SHR_DATA_PIN);
+ gpio_set_pin_output(SHR_LATCH_PIN);
+ gpio_set_pin_output(SHR_CLOCK_PIN);
}
void shift_enable(void) {
#ifdef SHR_OE_PIN
- writePinLow(SHR_OE_PIN);
+ gpio_write_pin_low(SHR_OE_PIN);
#endif
- writePinLow(SHR_DATA_PIN);
- writePinLow(SHR_LATCH_PIN);
- writePinLow(SHR_CLOCK_PIN);
+ gpio_write_pin_low(SHR_DATA_PIN);
+ gpio_write_pin_low(SHR_LATCH_PIN);
+ gpio_write_pin_low(SHR_CLOCK_PIN);
}
void shift_disable(void) {
#ifdef SHR_OE_PIN
- writePinHigh(SHR_OE_PIN);
+ gpio_write_pin_high(SHR_OE_PIN);
#endif
- writePinLow(SHR_DATA_PIN);
- writePinLow(SHR_LATCH_PIN);
- writePinLow(SHR_CLOCK_PIN);
+ gpio_write_pin_low(SHR_DATA_PIN);
+ gpio_write_pin_low(SHR_LATCH_PIN);
+ gpio_write_pin_low(SHR_CLOCK_PIN);
}
void shift_writePin(pin_t pin, int level) {
@@ 78,13 78,13 @@ void shift_writeAll(int level) {
static void shift_out(void) {
uint8_t n = SHR_SERIES_NUM;
- writePinLow(SHR_LATCH_PIN);
+ gpio_write_pin_low(SHR_LATCH_PIN);
while(n--){
for (uint8_t i = 0; i < 8; i++) {
- writePinLow(SHR_CLOCK_PIN);
- writePin(SHR_DATA_PIN, shift_values[n] & (0x80 >> i));
- writePinHigh(SHR_CLOCK_PIN);
+ gpio_write_pin_low(SHR_CLOCK_PIN);
+ gpio_write_pin(SHR_DATA_PIN, shift_values[n] & (0x80 >> i));
+ gpio_write_pin_high(SHR_CLOCK_PIN);
}
}
- writePinHigh(SHR_LATCH_PIN);
+ gpio_write_pin_high(SHR_LATCH_PIN);
}
M keyboards/mlego/m48/m48.h => keyboards/mlego/m48/m48.h +3 -3
@@ 21,18 21,18 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
static inline void led_lwr(const bool on) {
#ifdef LED_NUM_LOCK_PIN
- writePin(LED_NUM_LOCK_PIN, on);
+ gpio_write_pin(LED_NUM_LOCK_PIN, on);
#endif
}
static inline void led_rse(const bool on) {
#ifdef LED_SCROLL_LOCK_PIN
- writePin(LED_SCROLL_LOCK_PIN, on);
+ gpio_write_pin(LED_SCROLL_LOCK_PIN, on);
#endif
}
static inline void led_caps(const bool on) {
#ifdef LED_CAPS_LOCK_PIN
- writePin(LED_CAPS_LOCK_PIN, !on);
+ gpio_write_pin(LED_CAPS_LOCK_PIN, !on);
#endif
}
M keyboards/mlego/m60/m60.h => keyboards/mlego/m60/m60.h +3 -3
@@ 21,18 21,18 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
static inline void led_lwr(const bool on) {
#ifdef LED_NUM_LOCK_PIN
- writePin(LED_NUM_LOCK_PIN, on);
+ gpio_write_pin(LED_NUM_LOCK_PIN, on);
#endif
}
static inline void led_rse(const bool on) {
#ifdef LED_SCROLL_LOCK_PIN
- writePin(LED_SCROLL_LOCK_PIN, on);
+ gpio_write_pin(LED_SCROLL_LOCK_PIN, on);
#endif
}
static inline void led_caps(const bool on) {
#ifdef LED_CAPS_LOCK_PIN
- writePin(LED_CAPS_LOCK_PIN, !on);
+ gpio_write_pin(LED_CAPS_LOCK_PIN, !on);
#endif
}
M keyboards/mlego/m60_split/m60_split.h => keyboards/mlego/m60_split/m60_split.h +3 -3
@@ 19,19 19,19 @@
static inline void led_lwr(const bool on) {
#ifdef LED_NUM_LOCK_PIN
- writePin(LED_NUM_LOCK_PIN, on);
+ gpio_write_pin(LED_NUM_LOCK_PIN, on);
#endif
}
static inline void led_rse(const bool on) {
#ifdef LED_SCROLL_LOCK_PIN
- writePin(LED_SCROLL_LOCK_PIN, on);
+ gpio_write_pin(LED_SCROLL_LOCK_PIN, on);
#endif
}
static inline void led_caps(const bool on) {
#ifdef LED_CAPS_LOCK_PIN
- writePin(LED_CAPS_LOCK_PIN, !on);
+ gpio_write_pin(LED_CAPS_LOCK_PIN, !on);
#endif
}
M keyboards/mlego/m65/m65.h => keyboards/mlego/m65/m65.h +8 -8
@@ 30,14 30,14 @@ void set_led_toggle(const uint8_t, const bool);
static inline void init_lwr_rse_led(void) {
#if defined(LED_LWR_PIN)
- setPinOutput(LED_LWR_PIN);
- writePin(LED_LWR_PIN, false);
+ gpio_set_pin_output(LED_LWR_PIN);
+ gpio_write_pin(LED_LWR_PIN, false);
wait_ms(30);
#endif
#if defined(LED_RSE_PIN)
- setPinOutput(LED_RSE_PIN);
- writePin(LED_RSE_PIN, false);
+ gpio_set_pin_output(LED_RSE_PIN);
+ gpio_write_pin(LED_RSE_PIN, false);
wait_ms(30);
#endif
}
@@ 46,9 46,9 @@ static inline void led_lwr(const bool on) {
#if defined(LED_LWR_PIN)
if ((PRODUCT_ID == 0x6064) || (PRODUCT_ID == 0x6065) ||
(PRODUCT_ID == 0x6066) || (PRODUCT_ID == 0x6067)) {
- writePin(LED_LWR_PIN, !on);
+ gpio_write_pin(LED_LWR_PIN, !on);
}else{
- writePin(LED_LWR_PIN, on);
+ gpio_write_pin(LED_LWR_PIN, on);
}
#endif
}
@@ 57,9 57,9 @@ static inline void led_rse(const bool on) {
#if defined(LED_RSE_PIN)
if ((PRODUCT_ID == 0x6064) || (PRODUCT_ID == 0x6065) ||
(PRODUCT_ID == 0x6066) || (PRODUCT_ID == 0x6067)) {
- writePin(LED_RSE_PIN, !on);
+ gpio_write_pin(LED_RSE_PIN, !on);
}else{
- writePin(LED_RSE_PIN, on);
+ gpio_write_pin(LED_RSE_PIN, on);
}
#endif
}
M keyboards/mode/m65ha_alpha/m65ha_alpha.c => keyboards/mode/m65ha_alpha/m65ha_alpha.c +3 -3
@@ 18,7 18,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "quantum.h"
void board_init(void) {
- setPinInput(B10);
+ gpio_set_pin_input(B10);
}
void led_init_ports(void) {
@@ 54,12 54,12 @@ void led_init_ports(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- // writePin sets the pin high for 1 and low for 0.
+ // gpio_write_pin sets the pin high for 1 and low for 0.
// In this example the pins are inverted, setting
// it low/0 turns it on, and high/1 turns the LED off.
// This behavior depends on whether the LED is between the pin
// and VCC or the pin and GND.
- writePin(LED_CAPS_LOCK_PIN, !led_state.caps_lock);
+ gpio_write_pin(LED_CAPS_LOCK_PIN, !led_state.caps_lock);
}
return res;
}
M keyboards/mode/m65hi_alpha/m65hi_alpha.c => keyboards/mode/m65hi_alpha/m65hi_alpha.c +3 -3
@@ 18,7 18,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "quantum.h"
void board_init(void) {
- setPinInput(B10);
+ gpio_set_pin_input(B10);
}
void led_init_ports(void) {
@@ 54,12 54,12 @@ void led_init_ports(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- // writePin sets the pin high for 1 and low for 0.
+ // gpio_write_pin sets the pin high for 1 and low for 0.
// In this example the pins are inverted, setting
// it low/0 turns it on, and high/1 turns the LED off.
// This behavior depends on whether the LED is between the pin
// and VCC or the pin and GND.
- writePin(LED_CAPS_LOCK_PIN, !led_state.caps_lock);
+ gpio_write_pin(LED_CAPS_LOCK_PIN, !led_state.caps_lock);
}
return res;
}
M keyboards/mode/m65s/m65s.c => keyboards/mode/m65s/m65s.c +3 -3
@@ 18,7 18,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "quantum.h"
void board_init(void) {
- setPinInput(B10);
+ gpio_set_pin_input(B10);
}
void led_init_ports(void) {
@@ 55,12 55,12 @@ void led_init_ports(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- // writePin sets the pin high for 1 and low for 0.
+ // gpio_write_pin sets the pin high for 1 and low for 0.
// In this example the pins are inverted, setting
// it low/0 turns it on, and high/1 turns the LED off.
// This behavior depends on whether the LED is between the pin
// and VCC or the pin and GND.
- writePin(LED_CAPS_LOCK_PIN, !led_state.caps_lock);
+ gpio_write_pin(LED_CAPS_LOCK_PIN, !led_state.caps_lock);
}
return res;
}
M keyboards/monsgeek/m3/m3.c => keyboards/monsgeek/m3/m3.c +7 -7
@@ 136,15 136,15 @@ enum __layers {
};
void matrix_init_kb(void) {
- setPinOutput(LED_MAC_OS_PIN); // LDE2 MAC\WIN
- writePinLow(LED_MAC_OS_PIN);
- setPinOutput(LED_WIN_LOCK_PIN); // LED3 Win Lock
- writePinLow(LED_WIN_LOCK_PIN);
+ gpio_set_pin_output(LED_MAC_OS_PIN); // LDE2 MAC\WIN
+ gpio_write_pin_low(LED_MAC_OS_PIN);
+ gpio_set_pin_output(LED_WIN_LOCK_PIN); // LED3 Win Lock
+ gpio_write_pin_low(LED_WIN_LOCK_PIN);
}
void housekeeping_task_kb(void){
- writePin(LED_MAC_OS_PIN, (get_highest_layer(default_layer_state) == 3));
- writePin(LED_WIN_LOCK_PIN, keymap_config.no_gui);
+ gpio_write_pin(LED_MAC_OS_PIN, (get_highest_layer(default_layer_state) == 3));
+ gpio_write_pin(LED_WIN_LOCK_PIN, keymap_config.no_gui);
}
bool process_record_kb(uint16_t keycode, keyrecord_t* record) {
@@ 166,7 166,7 @@ bool process_record_kb(uint16_t keycode, keyrecord_t* record) {
return false;
case GU_TOGG:
if (record->event.pressed) {
- writePin(LED_WIN_LOCK_PIN, !keymap_config.no_gui);
+ gpio_write_pin(LED_WIN_LOCK_PIN, !keymap_config.no_gui);
}
return true;
case RGB_TOG:
M keyboards/monsgeek/m5/m5.c => keyboards/monsgeek/m5/m5.c +3 -3
@@ 149,15 149,15 @@ const snled27351_led_t PROGMEM g_snled27351_leds[SNLED27351_LED_COUNT] = {
#endif
void keyboard_pre_init_kb(void) {
- setPinOutput(LED_WIN_LOCK_PIN); // LED3 Win Lock
- writePinLow(LED_WIN_LOCK_PIN);
+ gpio_set_pin_output(LED_WIN_LOCK_PIN); // LED3 Win Lock
+ gpio_write_pin_low(LED_WIN_LOCK_PIN);
keyboard_pre_init_user();
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if (res) {
- writePin(LED_WIN_LOCK_PIN, keymap_config.no_gui);
+ gpio_write_pin(LED_WIN_LOCK_PIN, keymap_config.no_gui);
}
return res;
}
M keyboards/monstargear/xo87/solderable/solderable.c => keyboards/monstargear/xo87/solderable/solderable.c +31 -31
@@ 23,28 23,28 @@
#define ledCapSP (80+8)
void backlight_init_ports(void) {
- setPinOutput(Lseg0);
- setPinOutput(Lseg1);
- setPinOutput(Lseg2);
- setPinOutput(Lseg3);
- setPinOutput(Lseg4);
- setPinOutput(Lseg5);
- setPinOutput(Lcom0);
- setPinOutput(Lcom1);
- setPinOutput(Lcom2);
- setPinOutput(Lcom3);
- setPinOutput(Lcom4);
- setPinOutput(Lcom5);
- setPinOutput(Lcom6);
- setPinOutput(Lcom7);
- setPinOutput(Lcom8);
- setPinOutput(Lcom9);
- setPinOutput(Lcom10);
- setPinOutput(Lcom11);
- setPinOutput(Lcom12);
- setPinOutput(Lcom13);
- setPinOutput(Lcom14);
- setPinOutput(Lcom15);
+ gpio_set_pin_output(Lseg0);
+ gpio_set_pin_output(Lseg1);
+ gpio_set_pin_output(Lseg2);
+ gpio_set_pin_output(Lseg3);
+ gpio_set_pin_output(Lseg4);
+ gpio_set_pin_output(Lseg5);
+ gpio_set_pin_output(Lcom0);
+ gpio_set_pin_output(Lcom1);
+ gpio_set_pin_output(Lcom2);
+ gpio_set_pin_output(Lcom3);
+ gpio_set_pin_output(Lcom4);
+ gpio_set_pin_output(Lcom5);
+ gpio_set_pin_output(Lcom6);
+ gpio_set_pin_output(Lcom7);
+ gpio_set_pin_output(Lcom8);
+ gpio_set_pin_output(Lcom9);
+ gpio_set_pin_output(Lcom10);
+ gpio_set_pin_output(Lcom11);
+ gpio_set_pin_output(Lcom12);
+ gpio_set_pin_output(Lcom13);
+ gpio_set_pin_output(Lcom14);
+ gpio_set_pin_output(Lcom15);
}
void backlight_set(uint8_t level) {
@@ 54,22 54,22 @@ void backlight_task(void) {
// This is a temporary workaround to get the status LEDs working until we can figure out the LED matrix
led_t host_leds = host_keyboard_led_state();
if (host_leds.scroll_lock) {
- writePinHigh(Lcom3);
- writePinHigh(Lseg5);
+ gpio_write_pin_high(Lcom3);
+ gpio_write_pin_high(Lseg5);
} else {
- writePinLow(Lcom3);
+ gpio_write_pin_low(Lcom3);
}
if (host_leds.num_lock) {
- writePinHigh(Lcom7);
- writePinHigh(Lseg5);
+ gpio_write_pin_high(Lcom7);
+ gpio_write_pin_high(Lseg5);
} else {
- writePinLow(Lcom7);
+ gpio_write_pin_low(Lcom7);
}
if (host_leds.caps_lock) {
- writePinHigh(Lcom8);
- writePinHigh(Lseg5);
+ gpio_write_pin_high(Lcom8);
+ gpio_write_pin_high(Lseg5);
} else {
- writePinLow(Lcom8);
+ gpio_write_pin_low(Lcom8);
}
}
M keyboards/neson_design/700e/700e.c => keyboards/neson_design/700e/700e.c +3 -3
@@ 292,8 292,8 @@ const is31fl3731_led_t PROGMEM g_is31fl3731_leds[IS31FL3731_LED_COUNT] = {
void matrix_init_kb(void)
{
- setPinOutput(LED_CAPS_LOCK_PIN);
- writePinLow(LED_CAPS_LOCK_PIN);
+ gpio_set_pin_output(LED_CAPS_LOCK_PIN);
+ gpio_write_pin_low(LED_CAPS_LOCK_PIN);
is31fl3731_init_drivers();
@@ 363,7 363,7 @@ bool led_update_kb(led_t led_state)
{
bool res = led_update_user(led_state);
if (res) {
- writePin(LED_CAPS_LOCK_PIN, led_state.caps_lock);
+ gpio_write_pin(LED_CAPS_LOCK_PIN, led_state.caps_lock);
if (rgb_state.state != SELF_TESTING) {
if (led_state.caps_lock) {
M keyboards/neson_design/n6/n6.c => keyboards/neson_design/n6/n6.c +3 -3
@@ 296,8 296,8 @@ const is31fl3731_led_t PROGMEM g_is31fl3731_leds[IS31FL3731_LED_COUNT] = {
void matrix_init_kb(void)
{
- setPinOutput(LED_CAPS_LOCK_PIN);
- writePinLow(LED_CAPS_LOCK_PIN);
+ gpio_set_pin_output(LED_CAPS_LOCK_PIN);
+ gpio_write_pin_low(LED_CAPS_LOCK_PIN);
is31fl3731_init_drivers();
@@ 358,7 358,7 @@ bool led_update_kb(led_t led_state)
{
bool res = led_update_user(led_state);
if (res) {
- writePin(LED_CAPS_LOCK_PIN, led_state.caps_lock);
+ gpio_write_pin(LED_CAPS_LOCK_PIN, led_state.caps_lock);
if (rgb_state.state != SELF_TESTING) {
if (led_state.caps_lock) {
M keyboards/nopunin10did/kastenwagen1840/kastenwagen1840.c => keyboards/nopunin10did/kastenwagen1840/kastenwagen1840.c +12 -12
@@ 19,29 19,29 @@
#ifndef LAYER_LED_DISABLE
void keyboard_pre_init_kb(void) {
- setPinOutput(LED_INDICATOR_TOP);
- setPinOutput(LED_INDICATOR_MID);
- setPinOutput(LED_INDICATOR_BOT);
+ gpio_set_pin_output(LED_INDICATOR_TOP);
+ gpio_set_pin_output(LED_INDICATOR_MID);
+ gpio_set_pin_output(LED_INDICATOR_BOT);
keyboard_pre_init_user();
}
__attribute__((weak)) layer_state_t layer_state_set_user(layer_state_t state) {
- writePinHigh(LED_INDICATOR_TOP);
- writePinHigh(LED_INDICATOR_MID);
- writePinHigh(LED_INDICATOR_BOT);
+ gpio_write_pin_high(LED_INDICATOR_TOP);
+ gpio_write_pin_high(LED_INDICATOR_MID);
+ gpio_write_pin_high(LED_INDICATOR_BOT);
switch(get_highest_layer(state) % 4) {
case 1:
- writePinLow(LED_INDICATOR_TOP);
- writePinLow(LED_INDICATOR_MID);
+ gpio_write_pin_low(LED_INDICATOR_TOP);
+ gpio_write_pin_low(LED_INDICATOR_MID);
break;
case 2:
- writePinLow(LED_INDICATOR_TOP);
- writePinLow(LED_INDICATOR_BOT);
+ gpio_write_pin_low(LED_INDICATOR_TOP);
+ gpio_write_pin_low(LED_INDICATOR_BOT);
break;
case 3:
- writePinLow(LED_INDICATOR_MID);
- writePinLow(LED_INDICATOR_BOT);
+ gpio_write_pin_low(LED_INDICATOR_MID);
+ gpio_write_pin_low(LED_INDICATOR_BOT);
break;
}
return state;
M keyboards/nopunin10did/kastenwagen48/kastenwagen48.c => keyboards/nopunin10did/kastenwagen48/kastenwagen48.c +12 -12
@@ 19,29 19,29 @@
#ifndef LAYER_LED_DISABLE
void keyboard_pre_init_kb(void) {
- setPinOutput(LED_INDICATOR_TOP);
- setPinOutput(LED_INDICATOR_MID);
- setPinOutput(LED_INDICATOR_BOT);
+ gpio_set_pin_output(LED_INDICATOR_TOP);
+ gpio_set_pin_output(LED_INDICATOR_MID);
+ gpio_set_pin_output(LED_INDICATOR_BOT);
keyboard_pre_init_user();
}
__attribute__((weak)) layer_state_t layer_state_set_user(layer_state_t state) {
- writePinHigh(LED_INDICATOR_TOP);
- writePinHigh(LED_INDICATOR_MID);
- writePinHigh(LED_INDICATOR_BOT);
+ gpio_write_pin_high(LED_INDICATOR_TOP);
+ gpio_write_pin_high(LED_INDICATOR_MID);
+ gpio_write_pin_high(LED_INDICATOR_BOT);
switch(get_highest_layer(state) % 4) {
case 1:
- writePinLow(LED_INDICATOR_TOP);
- writePinLow(LED_INDICATOR_MID);
+ gpio_write_pin_low(LED_INDICATOR_TOP);
+ gpio_write_pin_low(LED_INDICATOR_MID);
break;
case 2:
- writePinLow(LED_INDICATOR_TOP);
- writePinLow(LED_INDICATOR_BOT);
+ gpio_write_pin_low(LED_INDICATOR_TOP);
+ gpio_write_pin_low(LED_INDICATOR_BOT);
break;
case 3:
- writePinLow(LED_INDICATOR_MID);
- writePinLow(LED_INDICATOR_BOT);
+ gpio_write_pin_low(LED_INDICATOR_MID);
+ gpio_write_pin_low(LED_INDICATOR_BOT);
break;
}
return state;
M keyboards/novelkeys/nk65b/nk65b.c => keyboards/novelkeys/nk65b/nk65b.c +2 -2
@@ 24,8 24,8 @@ void led_init_ports(void) {
}
layer_state_t layer_state_set_kb(layer_state_t state) {
- writePin(A15, !layer_state_cmp(state, 1));
- writePin(B3, !layer_state_cmp(state, 2));
+ gpio_write_pin(A15, !layer_state_cmp(state, 1));
+ gpio_write_pin(B3, !layer_state_cmp(state, 2));
return layer_state_set_user(state);
}
M keyboards/novelkeys/nk87b/nk87b.c => keyboards/novelkeys/nk87b/nk87b.c +2 -2
@@ 25,8 25,8 @@ void led_init_ports(void) {
}
layer_state_t layer_state_set_kb(layer_state_t state) {
- writePin(A3, !layer_state_cmp(state, 1));
- writePin(A4, !layer_state_cmp(state, 2));
+ gpio_write_pin(A3, !layer_state_cmp(state, 1));
+ gpio_write_pin(A4, !layer_state_cmp(state, 2));
return layer_state_set_user(state);
}
M keyboards/noxary/220/220.c => keyboards/noxary/220/220.c +2 -2
@@ 22,13 22,13 @@
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
- setPinOutput(C6);
+ gpio_set_pin_output(C6);
matrix_init_user();
}
bool led_update_kb(led_t led_state) {
if(led_update_user(led_state)) {
- writePin(C6, led_state.num_lock);
+ gpio_write_pin(C6, led_state.num_lock);
}
return true;
}=
\ No newline at end of file
M keyboards/noxary/268_2/268_2.c => keyboards/noxary/268_2/268_2.c +2 -2
@@ 18,13 18,13 @@
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
- setPinOutput(B0);
+ gpio_set_pin_output(B0);
matrix_init_user();
}
bool led_update_kb(led_t led_state) {
if(led_update_user(led_state)) {
- writePin(B0, led_state.caps_lock);
+ gpio_write_pin(B0, led_state.caps_lock);
}
return true;
}
M keyboards/noxary/280/280.c => keyboards/noxary/280/280.c +4 -4
@@ 23,15 23,15 @@
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
- setPinOutput(D5);
- setPinOutput(D0);
+ gpio_set_pin_output(D5);
+ gpio_set_pin_output(D0);
matrix_init_user();
}
bool led_update_kb(led_t led_state) {
if(led_update_user(led_state)) {
- writePin(D5, led_state.caps_lock);
- writePin(D0, led_state.scroll_lock);
+ gpio_write_pin(D5, led_state.caps_lock);
+ gpio_write_pin(D0, led_state.scroll_lock);
}
return true;
}=
\ No newline at end of file
M keyboards/noxary/x268/x268.c => keyboards/noxary/x268/x268.c +2 -2
@@ 22,13 22,13 @@
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
- setPinOutput(B0);
+ gpio_set_pin_output(B0);
matrix_init_user();
}
bool led_update_kb(led_t led_state) {
if(led_update_user(led_state)) {
- writePin(B0, led_state.caps_lock);
+ gpio_write_pin(B0, led_state.caps_lock);
}
return true;
}
M keyboards/nullbitsco/common/bitc_led.c => keyboards/nullbitsco/common/bitc_led.c +5 -5
@@ 18,17 18,17 @@
void set_bitc_LED(uint8_t mode) {
switch(mode) {
case LED_ON:
- setPinOutput(PIN_LED);
- writePin(PIN_LED, GPIO_STATE_HIGH);
+ gpio_set_pin_output(PIN_LED);
+ gpio_write_pin(PIN_LED, GPIO_STATE_HIGH);
break;
case LED_DIM:
- setPinInput(PIN_LED);
+ gpio_set_pin_input(PIN_LED);
break;
case LED_OFF:
- setPinOutput(PIN_LED);
- writePin(PIN_LED, GPIO_STATE_LOW);
+ gpio_set_pin_output(PIN_LED);
+ gpio_write_pin(PIN_LED, GPIO_STATE_LOW);
break;
default:
M keyboards/nullbitsco/nibble/big_led.c => keyboards/nullbitsco/nibble/big_led.c +12 -12
@@ 24,13 24,13 @@ void set_big_LED_rgb(uint8_t r_mode, uint8_t g_mode, uint8_t b_mode) {
void set_big_LED_r(uint8_t mode) {
switch(mode) {
case LED_ON:
- setPinOutput(BIG_LED_R_PIN);
- writePin(BIG_LED_R_PIN, GPIO_STATE_HIGH);
+ gpio_set_pin_output(BIG_LED_R_PIN);
+ gpio_write_pin(BIG_LED_R_PIN, GPIO_STATE_HIGH);
break;
case LED_OFF:
- setPinOutput(BIG_LED_R_PIN);
- writePin(BIG_LED_R_PIN, GPIO_STATE_LOW);
+ gpio_set_pin_output(BIG_LED_R_PIN);
+ gpio_write_pin(BIG_LED_R_PIN, GPIO_STATE_LOW);
break;
default:
@@ 41,13 41,13 @@ void set_big_LED_r(uint8_t mode) {
void set_big_LED_g(uint8_t mode) {
switch(mode) {
case LED_ON:
- setPinOutput(BIG_LED_G_PIN);
- writePin(BIG_LED_G_PIN, GPIO_STATE_HIGH);
+ gpio_set_pin_output(BIG_LED_G_PIN);
+ gpio_write_pin(BIG_LED_G_PIN, GPIO_STATE_HIGH);
break;
case LED_OFF:
- setPinOutput(BIG_LED_G_PIN);
- writePin(BIG_LED_G_PIN, GPIO_STATE_LOW);
+ gpio_set_pin_output(BIG_LED_G_PIN);
+ gpio_write_pin(BIG_LED_G_PIN, GPIO_STATE_LOW);
break;
default:
@@ 58,13 58,13 @@ void set_big_LED_g(uint8_t mode) {
void set_big_LED_b(uint8_t mode) {
switch(mode) {
case LED_ON:
- setPinOutput(BIG_LED_B_PIN);
- writePin(BIG_LED_B_PIN, GPIO_STATE_HIGH);
+ gpio_set_pin_output(BIG_LED_B_PIN);
+ gpio_write_pin(BIG_LED_B_PIN, GPIO_STATE_HIGH);
break;
case LED_OFF:
- setPinOutput(BIG_LED_B_PIN);
- writePin(BIG_LED_B_PIN, GPIO_STATE_LOW);
+ gpio_set_pin_output(BIG_LED_B_PIN);
+ gpio_write_pin(BIG_LED_B_PIN, GPIO_STATE_LOW);
break;
default:
M keyboards/nullbitsco/nibble/matrix.c => keyboards/nullbitsco/nibble/matrix.c +5 -5
@@ 27,17 27,17 @@ static const uint8_t col_pins[MATRIX_MUX_COLS] = MATRIX_COL_MUX_PINS;
static void init_pins(void) {
// Set cols to outputs, low
for (uint8_t pin = 0; pin < MATRIX_MUX_COLS; pin++) {
- setPinOutput(col_pins[pin]);
+ gpio_set_pin_output(col_pins[pin]);
}
// Unselect cols
for (uint8_t bit = 0; bit < MATRIX_MUX_COLS; bit++) {
- writePinLow(col_pins[bit]);
+ gpio_write_pin_low(col_pins[bit]);
}
// Set rows to input, pullup
for (uint8_t pin = 0; pin < MATRIX_ROWS; pin++) {
- setPinInputHigh(row_pins[pin]);
+ gpio_set_pin_input_high(row_pins[pin]);
}
}
@@ 45,7 45,7 @@ static void select_col(uint8_t col)
{
for (uint8_t bit = 0; bit < MATRIX_MUX_COLS; bit++) {
uint8_t state = (col & (0b1 << bit)) >> bit;
- writePin(col_pins[bit], state);
+ gpio_write_pin(col_pins[bit], state);
}
}
@@ 60,7 60,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
{
matrix_row_t last_row_value = current_matrix[row_index];
- if (!readPin(row_pins[row_index]))
+ if (!gpio_read_pin(row_pins[row_index]))
{
current_matrix[row_index] |= (COL_SHIFTER << current_col);
}
M keyboards/nullbitsco/scramble/v1/v1.c => keyboards/nullbitsco/scramble/v1/v1.c +5 -5
@@ 6,17 6,17 @@
void set_scramble_LED(uint8_t mode) {
switch(mode) {
case LED_ON:
- setPinOutput(PIN_LED);
- writePin(PIN_LED, GPIO_STATE_HIGH);
+ gpio_set_pin_output(PIN_LED);
+ gpio_write_pin(PIN_LED, GPIO_STATE_HIGH);
break;
case LED_DIM:
- setPinInput(PIN_LED);
+ gpio_set_pin_input(PIN_LED);
break;
case LED_OFF:
- setPinOutput(PIN_LED);
- writePin(PIN_LED, GPIO_STATE_LOW);
+ gpio_set_pin_output(PIN_LED);
+ gpio_write_pin(PIN_LED, GPIO_STATE_LOW);
break;
default:
M keyboards/nullbitsco/snap/matrix.c => keyboards/nullbitsco/snap/matrix.c +7 -7
@@ 37,23 37,23 @@ static uint8_t* col_pins = col_pins_left;
static void init_pins(void) {
// Set cols to outputs, low
for (uint8_t pin = 0; pin < MATRIX_MUX_COLS; pin++) {
- setPinOutput(col_pins[pin]);
+ gpio_set_pin_output(col_pins[pin]);
}
// Unselect cols
for (uint8_t bit = 0; bit < MATRIX_MUX_COLS; bit++) {
- writePinLow(col_pins[bit]);
+ gpio_write_pin_low(col_pins[bit]);
}
// Set rows to input, pullup
for (uint8_t pin = 0; pin < ROWS_PER_HAND; pin++) {
- setPinInputHigh(row_pins[pin]);
+ gpio_set_pin_input_high(row_pins[pin]);
}
// Set extended pin (only on right side)
if (!isLeftHand) {
// Set extended pin to input, pullup
- setPinInputHigh(MATRIX_EXT_PIN_RIGHT);
+ gpio_set_pin_input_high(MATRIX_EXT_PIN_RIGHT);
}
}
@@ 61,7 61,7 @@ static void select_col(uint8_t col) {
// Drive demux with correct column address
for (uint8_t bit = 0; bit < MATRIX_MUX_COLS; bit++) {
uint8_t state = (col & (0b1 << bit)) >> bit;
- writePin(col_pins[bit], !state);
+ gpio_write_pin(col_pins[bit], !state);
}
}
@@ 71,7 71,7 @@ static void read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
// Read each row sequentially
for (uint8_t row_index = 0; row_index < ROWS_PER_HAND; row_index++) {
- if (readPin(row_pins[row_index]) == 0) {
+ if (gpio_read_pin(row_pins[row_index]) == 0) {
current_matrix[row_index] |= (COL_SHIFTER << current_col);
} else {
current_matrix[row_index] &= ~(COL_SHIFTER << current_col);
@@ 82,7 82,7 @@ static void read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
static void read_ext_pin(matrix_row_t current_matrix[]) {
// Read the state of the extended matrix pin
if (!isLeftHand) {
- if (readPin(MATRIX_EXT_PIN_RIGHT) == 0) {
+ if (gpio_read_pin(MATRIX_EXT_PIN_RIGHT) == 0) {
current_matrix[EXT_PIN_ROW] |= (COL_SHIFTER << EXT_PIN_COL);
} else {
current_matrix[EXT_PIN_ROW] &= ~(COL_SHIFTER << EXT_PIN_COL);
M keyboards/om60/matrix.c => keyboards/om60/matrix.c +12 -12
@@ 31,37 31,37 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static void select_row(uint8_t row)
{
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row)
{
- setPinInputHigh(row_pins[row]);
+ gpio_set_pin_input_high(row_pins[row]);
}
static void unselect_rows(void)
{
for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void select_col(uint8_t col)
{
- setPinOutput(col_pins[col]);
- writePinLow(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
- setPinInputHigh(col_pins[col]);
+ gpio_set_pin_input_high(col_pins[col]);
}
static void unselect_cols(void)
{
for(uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 69,10 69,10 @@ static void init_pins(void) {
unselect_rows();
unselect_cols();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
@@ 92,7 92,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index);
@@ 120,7 120,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[tmp];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0)
+ if (gpio_read_pin(row_pins[row_index]) == 0)
{
// Pin LO, set col bit
current_matrix[tmp] |= (ROW_SHIFTER << current_col);
M keyboards/opendeck/32/rev1/rev1.c => keyboards/opendeck/32/rev1/rev1.c +3 -3
@@ 90,12 90,12 @@ led_config_t g_led_config = {
void keyboard_pre_init_kb(void) {
// Light power LED
- setPinOutput(POWER_LED_PIN);
- writePinLow(POWER_LED_PIN);
+ gpio_set_pin_output(POWER_LED_PIN);
+ gpio_write_pin_low(POWER_LED_PIN);
// We don't use this feature of the IS31FL3731 but it is electrically connected
// Make sure not to drive it
- setPinInput(IS31FL3731_IRQ_PIN);
+ gpio_set_pin_input(IS31FL3731_IRQ_PIN);
keyboard_pre_init_user();
}
M keyboards/ortho5by12/ortho5by12.c => keyboards/ortho5by12/ortho5by12.c +4 -4
@@ 16,15 16,15 @@
#include "quantum.h"
void matrix_init_kb(void) {
- setPinOutput(C4);
- setPinOutput(C5);
+ gpio_set_pin_output(C4);
+ gpio_set_pin_output(C5);
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(C4, led_state.num_lock);
- writePin(C5, led_state.caps_lock);
+ gpio_write_pin(C4, led_state.num_lock);
+ gpio_write_pin(C5, led_state.caps_lock);
}
return res;
}
M keyboards/peej/lumberjack/lumberjack.c => keyboards/peej/lumberjack/lumberjack.c +2 -2
@@ 17,8 17,8 @@
#include "lumberjack.h"
void keyboard_pre_init_kb() {
- setPinOutput(LED1);
- setPinOutput(LED2);
+ gpio_set_pin_output(LED1);
+ gpio_set_pin_output(LED2);
keyboard_pre_init_user();
}
M keyboards/peej/rosaline/rosaline.c => keyboards/peej/rosaline/rosaline.c +2 -2
@@ 17,13 17,13 @@
#include "quantum.h"
bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
- writePin(LED1, record->event.pressed);
+ gpio_write_pin(LED1, record->event.pressed);
return process_record_user(keycode, record);
}
layer_state_t layer_state_set_kb(layer_state_t state) {
- writePin(LED2, state);
+ gpio_write_pin(LED2, state);
return layer_state_set_user(state);
}
M keyboards/percent/canoe_gen2/canoe_gen2.c => keyboards/percent/canoe_gen2/canoe_gen2.c +4 -4
@@ 18,15 18,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(E6);
- writePinHigh(E6);
-
+ gpio_set_pin_output(E6);
+ gpio_write_pin_high(E6);
+
keyboard_pre_init_user();
}
bool led_update_kb(led_t led_state) {
if(led_update_user(led_state)) {
- writePin(E6, !led_state.caps_lock);
+ gpio_write_pin(E6, !led_state.caps_lock);
}
return true;
M keyboards/pica40/rev2/rev2.c => keyboards/pica40/rev2/rev2.c +7 -7
@@ 11,7 11,7 @@
// custom handler that returns encoder B pin status from slave side
void encoder_sync_slave_handler(uint8_t in_buflen, const void *in_data, uint8_t out_buflen, void *out_data) {
- *(uint8_t *)out_data = readPin(ENCODER_PIN_B) ? 1 : 0;
+ *(uint8_t *)out_data = gpio_read_pin(ENCODER_PIN_B) ? 1 : 0;
}
void encoder_quadrature_init_pin(uint8_t index, bool pad_b) {}
@@ 22,7 22,7 @@ uint8_t encoder_quadrature_read_pin(uint8_t index, bool pad_b) {
transaction_rpc_recv(ENCODER_SYNC, sizeof(data), &data);
return data;
}
- return readPin(ENCODER_PIN_A) ? 1 : 0;
+ return gpio_read_pin(ENCODER_PIN_A) ? 1 : 0;
}
#endif // ENCODER_ENABLE
@@ 53,11 53,11 @@ bool should_set_rgblight = false;
#endif // defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_LAYERS)
void keyboard_post_init_kb(void) {
- setPinOutput(PICA40_RGB_POWER_PIN);
+ gpio_set_pin_output(PICA40_RGB_POWER_PIN);
#ifdef ENCODER_ENABLE
- setPinInputHigh(ENCODER_PIN_A);
- setPinInputHigh(ENCODER_PIN_B);
+ gpio_set_pin_input_high(ENCODER_PIN_A);
+ gpio_set_pin_input_high(ENCODER_PIN_B);
transaction_register_rpc(ENCODER_SYNC, encoder_sync_slave_handler);
#endif // ENCODER_ENABLE
@@ 113,9 113,9 @@ void housekeeping_task_kb(void) {
should_set_rgblight = true;
if (is_layer_active) {
- writePinHigh(PICA40_RGB_POWER_PIN);
+ gpio_write_pin_high(PICA40_RGB_POWER_PIN);
} else {
- writePinLow(PICA40_RGB_POWER_PIN);
+ gpio_write_pin_low(PICA40_RGB_POWER_PIN);
}
}
}
M keyboards/planck/planck.c => keyboards/planck/planck.c +2 -2
@@ 4,8 4,8 @@ __attribute__ ((weak))
void matrix_init_kb(void) {
// Turn status LED on, with the exception of THK
#if defined(__AVR_ATmega32U4__)
- setPinOutput(E6);
- writePinHigh(E6);
+ gpio_set_pin_output(E6);
+ gpio_write_pin_high(E6);
#endif
matrix_init_user();
M keyboards/planck/rev6_drop/matrix.c => keyboards/planck/rev6_drop/matrix.c +6 -6
@@ 27,13 27,13 @@ static matrix_row_t matrix_inverted[MATRIX_COLS];
void matrix_init_custom(void) {
// actual matrix setup - cols
for (int i = 0; i < MATRIX_COLS; i++) {
- setPinOutput(matrix_col_pins[i]);
- writePinLow(matrix_col_pins[i]);
+ gpio_set_pin_output(matrix_col_pins[i]);
+ gpio_write_pin_low(matrix_col_pins[i]);
}
// rows
for (int i = 0; i < MATRIX_ROWS; i++) {
- setPinInputLow(matrix_row_pins[i]);
+ gpio_set_pin_input_low(matrix_row_pins[i]);
}
}
@@ 45,18 45,18 @@ bool matrix_scan_custom(matrix_row_t current_matrix[]) {
matrix_row_t data = 0;
// strobe col
- writePinHigh(matrix_col_pins[col]);
+ gpio_write_pin_high(matrix_col_pins[col]);
// need wait to settle pin state
wait_us(20);
// read row data
for (int row = 0; row < MATRIX_ROWS; row++) {
- data |= (readPin(matrix_row_pins[row]) << row);
+ data |= (gpio_read_pin(matrix_row_pins[row]) << row);
}
// unstrobe col
- writePinLow(matrix_col_pins[col]);
+ gpio_write_pin_low(matrix_col_pins[col]);
if (matrix_inverted[col] != data) {
matrix_inverted[col] = data;
M keyboards/planck/rev7/matrix.c => keyboards/planck/rev7/matrix.c +13 -13
@@ 44,18 44,18 @@ static matrix_row_t matrix_inverted[MATRIX_COLS];
void matrix_init_custom(void) {
// actual matrix setup - cols
for (int i = 0; i < MATRIX_COLS; i++) {
- setPinOutput(matrix_col_pins[i]);
- writePinLow(matrix_col_pins[i]);
+ gpio_set_pin_output(matrix_col_pins[i]);
+ gpio_write_pin_low(matrix_col_pins[i]);
}
// rows
for (int i = 0; i < MATRIX_ROWS; i++) {
- setPinInputLow(matrix_row_pins[i]);
+ gpio_set_pin_input_low(matrix_row_pins[i]);
}
// encoder A & B setup
- setPinInputLow(B12);
- setPinInputLow(B13);
+ gpio_set_pin_input_low(B12);
+ gpio_set_pin_input_low(B13);
#ifndef PLANCK_WATCHDOG_DISABLE
wdgInit();
@@ 81,18 81,18 @@ bool matrix_scan_custom(matrix_row_t current_matrix[]) {
matrix_row_t data = 0;
// strobe col
- writePinHigh(matrix_col_pins[col]);
+ gpio_write_pin_high(matrix_col_pins[col]);
// need wait to settle pin state
wait_us(20);
// read row data
for (int row = 0; row < MATRIX_ROWS; row++) {
- data |= (readPin(matrix_row_pins[row]) << row);
+ data |= (gpio_read_pin(matrix_row_pins[row]) << row);
}
// unstrobe col
- writePinLow(matrix_col_pins[col]);
+ gpio_write_pin_low(matrix_col_pins[col]);
if (matrix_inverted[col] != data) {
matrix_inverted[col] = data;
@@ 113,11 113,11 @@ bool matrix_scan_custom(matrix_row_t current_matrix[]) {
uint8_t encoder_quadrature_read_pin(uint8_t index, bool pad_b) {
pin_t pin = pad_b ? B13: B12;
- setPinInputHigh(pin);
- writePinLow(matrix_row_pins[index]);
+ gpio_set_pin_input_high(pin);
+ gpio_write_pin_low(matrix_row_pins[index]);
wait_us(10);
- uint8_t ret = readPin(pin) ? 1 : 0;
- setPinInputLow(matrix_row_pins[index]);
- setPinInputLow(pin);
+ uint8_t ret = gpio_read_pin(pin) ? 1 : 0;
+ gpio_set_pin_input_low(matrix_row_pins[index]);
+ gpio_set_pin_input_low(pin);
return ret;
}
M keyboards/pom_keyboards/tnln95/tnln95.c => keyboards/pom_keyboards/tnln95/tnln95.c +6 -6
@@ 16,11 16,11 @@
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(B1);
- setPinOutput(B2);
+ gpio_set_pin_output(B1);
+ gpio_set_pin_output(B2);
/* I will add function to these later */
- // setPinOutput(B3);
- // setPinOutput(E2);
+ // gpio_set_pin_output(B3);
+ // gpio_set_pin_output(E2);
keyboard_pre_init_user();
}
@@ 28,8 28,8 @@ void keyboard_pre_init_kb(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(B1, led_state.num_lock);
- writePin(B2, led_state.caps_lock);
+ gpio_write_pin(B1, led_state.num_lock);
+ gpio_write_pin(B2, led_state.caps_lock);
}
return res;
}
M keyboards/preonic/rev1/rev1.c => keyboards/preonic/rev1/rev1.c +2 -2
@@ 18,8 18,8 @@
void matrix_init_kb(void) {
// Turn status LED on
- setPinOutput(E6);
- writePinHigh(E6);
+ gpio_set_pin_output(E6);
+ gpio_write_pin_high(E6);
matrix_init_user();
};
M keyboards/preonic/rev2/rev2.c => keyboards/preonic/rev2/rev2.c +2 -2
@@ 18,8 18,8 @@
void matrix_init_kb(void) {
// Turn status LED on
- setPinOutput(E6);
- writePinHigh(E6);
+ gpio_set_pin_output(E6);
+ gpio_write_pin_high(E6);
matrix_init_user();
};
M keyboards/primekb/meridian/meridian.c => keyboards/primekb/meridian/meridian.c +2 -2
@@ 19,7 19,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
//Initialize B12 for in-switch caps lock
void keyboard_pre_init_kb(void){
- setPinOutput(B12);
+ gpio_set_pin_output(B12);
keyboard_pre_init_user();
}
@@ 35,7 35,7 @@ void keyboard_post_init_user(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if (res) {
- // writePin(B12, !led_state.caps_lock); //Un-comment this line to enable in-switch capslock indicator
+ // gpio_write_pin(B12, !led_state.caps_lock); //Un-comment this line to enable in-switch capslock indicator
if (led_state.caps_lock) {
rgblight_setrgb_at(0, 255, 0, 0); //green
} else {
M keyboards/projectd/65/projectd_65_ansi/projectd_65_ansi.c => keyboards/projectd/65/projectd_65_ansi/projectd_65_ansi.c +3 -3
@@ 118,9 118,9 @@ void spi_init(void) {
is_initialised = true;
// Try releasing special pins for a short time
- setPinInput(SPI_SCK_PIN);
- setPinInput(SPI_MOSI_PIN);
- setPinInput(SPI_MISO_PIN);
+ gpio_set_pin_input(SPI_SCK_PIN);
+ gpio_set_pin_input(SPI_MOSI_PIN);
+ gpio_set_pin_input(SPI_MISO_PIN);
chThdSleepMilliseconds(10);
M keyboards/projectd/75/ansi/ansi.c => keyboards/projectd/75/ansi/ansi.c +3 -3
@@ 134,9 134,9 @@ void spi_init(void) {
is_initialised = true;
// Try releasing special pins for a short time
- setPinInput(SPI_SCK_PIN);
- setPinInput(SPI_MOSI_PIN);
- setPinInput(SPI_MISO_PIN);
+ gpio_set_pin_input(SPI_SCK_PIN);
+ gpio_set_pin_input(SPI_MOSI_PIN);
+ gpio_set_pin_input(SPI_MISO_PIN);
chThdSleepMilliseconds(10);
M keyboards/projectkb/alice/alice.c => keyboards/projectkb/alice/alice.c +6 -6
@@ 1,9 1,9 @@
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(INDICATOR_PIN_0);
- setPinOutput(INDICATOR_PIN_1);
- setPinOutput(INDICATOR_PIN_2);
+ gpio_set_pin_output(INDICATOR_PIN_0);
+ gpio_set_pin_output(INDICATOR_PIN_1);
+ gpio_set_pin_output(INDICATOR_PIN_2);
keyboard_pre_init_user();
}
@@ 12,9 12,9 @@ void keyboard_pre_init_kb(void) {
bool led_update_kb(led_t led_state) {
bool runDefault = led_update_user(led_state);
if (runDefault) {
- writePin(INDICATOR_PIN_0, !led_state.num_lock);
- writePin(INDICATOR_PIN_1, !led_state.caps_lock);
- writePin(INDICATOR_PIN_2, !led_state.scroll_lock);
+ gpio_write_pin(INDICATOR_PIN_0, !led_state.num_lock);
+ gpio_write_pin(INDICATOR_PIN_1, !led_state.caps_lock);
+ gpio_write_pin(INDICATOR_PIN_2, !led_state.scroll_lock);
}
return runDefault;
}
M keyboards/protozoa/event_horizon/event_horizon.c => keyboards/protozoa/event_horizon/event_horizon.c +1 -1
@@ 17,5 17,5 @@
void led_init_ports(void) {
// Set our LED pins as open drain outputs
- setPinOutputOpenDrain(LED_CAPS_LOCK_PIN);
+ gpio_set_pin_output_open_drain(LED_CAPS_LOCK_PIN);
}
M keyboards/punk75/punk75.c => keyboards/punk75/punk75.c +2 -2
@@ 18,7 18,7 @@
void matrix_init_kb(void) {
// Set our LED pin as output
- setPinOutput(LED);
+ gpio_set_pin_output(LED);
matrix_init_user();
}
@@ 26,7 26,7 @@ void matrix_init_kb(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(LED, !led_state.caps_lock);
+ gpio_write_pin(LED, !led_state.caps_lock);
}
return res;
}
M keyboards/quad_h/lb75/lb75.c => keyboards/quad_h/lb75/lb75.c +4 -4
@@ 20,8 20,8 @@ void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
- setPinOutput(B1);
- setPinOutput(B2);
+ gpio_set_pin_output(B1);
+ gpio_set_pin_output(B2);
matrix_init_user();
}
@@ 30,8 30,8 @@ bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(B1, !led_state.caps_lock);
- writePin(B2, !led_state.scroll_lock);
+ gpio_write_pin(B1, !led_state.caps_lock);
+ gpio_write_pin(B2, !led_state.scroll_lock);
}
return res;
M keyboards/qvex/lynepad/lynepad.c => keyboards/qvex/lynepad/lynepad.c +12 -12
@@ 15,12 15,12 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
void keyboard_pre_init_kb(void) {
// Encoder pins
- setPinInput(PIN_TW_SW);
- setPinInput(PIN_RJ_SW);
- setPinInput(PIN_RJ_DIR_A);
- setPinInput(PIN_RJ_DIR_C);
- setPinInput(PIN_RJ_DIR_B);
- setPinInput(PIN_RJ_DIR_D);
+ gpio_set_pin_input(PIN_TW_SW);
+ gpio_set_pin_input(PIN_RJ_SW);
+ gpio_set_pin_input(PIN_RJ_DIR_A);
+ gpio_set_pin_input(PIN_RJ_DIR_C);
+ gpio_set_pin_input(PIN_RJ_DIR_B);
+ gpio_set_pin_input(PIN_RJ_DIR_D);
keyboard_pre_init_user();
}
@@ 40,18 40,18 @@ int16_t enc2RightPrev = 1;
void matrix_scan_kb(void) {
enc1CenterPrev = enc1Center;
- enc1Center = readPin(PIN_TW_SW);
+ enc1Center = gpio_read_pin(PIN_TW_SW);
enc2CenterPrev = enc2Center;
- enc2Center = readPin(PIN_RJ_SW);
+ enc2Center = gpio_read_pin(PIN_RJ_SW);
enc2UpPrev = enc2Up;
- enc2Up = readPin(PIN_RJ_DIR_A);
+ enc2Up = gpio_read_pin(PIN_RJ_DIR_A);
enc2DownPrev = enc2Down;
- enc2Down = readPin(PIN_RJ_DIR_C);
+ enc2Down = gpio_read_pin(PIN_RJ_DIR_C);
enc2LeftPrev = enc2Left;
- enc2Left = readPin(PIN_RJ_DIR_B);
+ enc2Left = gpio_read_pin(PIN_RJ_DIR_B);
enc2RightPrev = enc2Right;
- enc2Right = readPin(PIN_RJ_DIR_D);
+ enc2Right = gpio_read_pin(PIN_RJ_DIR_D);
// Ensure any user customizations are called (for some reason this wasn't happening by default)
matrix_scan_user();
M keyboards/qvex/lynepad2/matrix.c => keyboards/qvex/lynepad2/matrix.c +18 -18
@@ 24,31 24,31 @@ extern matrix_row_t raw_matrix[MATRIX_ROWS]; // raw values
extern matrix_row_t matrix[MATRIX_ROWS]; // debounced values
static void select_row(uint8_t row) {
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row) {
- setPinInputHigh(row_pins[row]);
+ gpio_set_pin_input_high(row_pins[row]);
}
static void unselect_rows(void) {
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void init_pins(void) {
unselect_rows();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
- setPinInputHigh(PIN_JU);
- setPinInputHigh(PIN_JD);
- setPinInputHigh(PIN_JL);
- setPinInputHigh(PIN_JR);
- setPinInputHigh(PIN_JC);
- setPinInputHigh(PIN_TC);
+ gpio_set_pin_input_high(PIN_JU);
+ gpio_set_pin_input_high(PIN_JD);
+ gpio_set_pin_input_high(PIN_JL);
+ gpio_set_pin_input_high(PIN_JR);
+ gpio_set_pin_input_high(PIN_JC);
+ gpio_set_pin_input_high(PIN_TC);
}
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
@@ 62,7 62,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
wait_us(30);
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
current_matrix[current_row] |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
}
@@ 78,16 78,16 @@ static bool read_encoder_switches(matrix_row_t current_matrix[]) {
current_matrix[3] = 0;
current_matrix[4] = 0;
- current_matrix[4] |= !readPin(PIN_TC) ? (1 << 1) : 0;
+ current_matrix[4] |= !gpio_read_pin(PIN_TC) ? (1 << 1) : 0;
- if (!readPin(PIN_JC)) {
- if (!readPin(PIN_JU)) {
+ if (!gpio_read_pin(PIN_JC)) {
+ if (!gpio_read_pin(PIN_JU)) {
current_matrix[3] |= (1 << 0);
- } else if (!readPin(PIN_JD)) {
+ } else if (!gpio_read_pin(PIN_JD)) {
current_matrix[3] |= (1 << 1);
- } else if (!readPin(PIN_JL)) {
+ } else if (!gpio_read_pin(PIN_JL)) {
current_matrix[3] |= (1 << 2);
- } else if (!readPin(PIN_JR)) {
+ } else if (!gpio_read_pin(PIN_JR)) {
current_matrix[3] |= (1 << 3);
} else {
current_matrix[4] |= (1 << 0);
M keyboards/rart/rartlite/rartlite.c => keyboards/rart/rartlite/rartlite.c +2 -2
@@ 15,12 15,12 @@
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(B1);
+ gpio_set_pin_output(B1);
keyboard_pre_init_user();
}
layer_state_t layer_state_set_kb(layer_state_t state) {
- writePin(B1, layer_state_cmp(state, 1));
+ gpio_write_pin(B1, layer_state_cmp(state, 1));
return layer_state_set_user(state);
}
M keyboards/rate/pistachio_pro/matrix.c => keyboards/rate/pistachio_pro/matrix.c +5 -5
@@ 22,13 22,13 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinInputHigh_atomic(pin_t pin) {
- ATOMIC_BLOCK_FORCEON { setPinInputHigh(pin); }
+ ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); }
}
static void select_row(uint8_t row) {
@@ 81,7 81,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS / 2; col_index++) {
// Check row pin state
- if (readPin(col_pins[col_index])) {
+ if (gpio_read_pin(col_pins[col_index])) {
// Pin HI, clear col bit
current_matrix[current_row] &= ~(MATRIX_ROW_SHIFTER << col_index);
} else {
@@ 109,7 109,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
- if (readPin(row_pins[row_index])) {
+ if (gpio_read_pin(row_pins[row_index])) {
// Pin HI, clear col bit
current_matrix[row_index] &= ~(MATRIX_ROW_SHIFTER << ( current_col + MATRIX_COLS/2));
} else {
M keyboards/redox/wireless/wireless.c => keyboards/redox/wireless/wireless.c +8 -8
@@ 18,15 18,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "wireless.h"
void led_init(void) {
- setPinOutput(D0);
- setPinOutput(D1);
- setPinOutput(F4);
- setPinOutput(F5);
+ gpio_set_pin_output(D0);
+ gpio_set_pin_output(D1);
+ gpio_set_pin_output(F4);
+ gpio_set_pin_output(F5);
- writePinHigh(D0);
- writePinHigh(D1);
- writePinHigh(F4);
- writePinHigh(F5);
+ gpio_write_pin_high(D0);
+ gpio_write_pin_high(D1);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_high(F5);
}
M keyboards/redox/wireless/wireless.h => keyboards/redox/wireless/wireless.h +8 -8
@@ 19,14 19,14 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "quantum.h"
-#define red_led_off writePinHigh(F5)
-#define red_led_on writePinLow(F5)
-#define blu_led_off writePinHigh(F4)
-#define blu_led_on writePinLow(F4)
-#define grn_led_off writePinHigh(D1)
-#define grn_led_on writePinLow(D1)
-#define wht_led_off writePinHigh(D0)
-#define wht_led_on writePinLow(D0)
+#define red_led_off gpio_write_pin_high(F5)
+#define red_led_on gpio_write_pin_low(F5)
+#define blu_led_off gpio_write_pin_high(F4)
+#define blu_led_on gpio_write_pin_low(F4)
+#define grn_led_off gpio_write_pin_high(D1)
+#define grn_led_on gpio_write_pin_low(D1)
+#define wht_led_off gpio_write_pin_high(D0)
+#define wht_led_on gpio_write_pin_low(D0)
#define set_led_off red_led_off; grn_led_off; blu_led_off; wht_led_off
#define set_led_red red_led_on; grn_led_off; blu_led_off; wht_led_off
M keyboards/redscarf_i/redscarf_i.c => keyboards/redscarf_i/redscarf_i.c +13 -13
@@ 18,19 18,19 @@
void keyboard_pre_init_kb(void) {
// initialize top row leds
- setPinOutput(F7);
- setPinOutput(F6);
- setPinOutput(F5);
+ gpio_set_pin_output(F7);
+ gpio_set_pin_output(F6);
+ gpio_set_pin_output(F5);
// and then turn them off
- writePinHigh(F7);
- writePinHigh(F6);
- writePinHigh(F5);
+ gpio_write_pin_high(F7);
+ gpio_write_pin_high(F6);
+ gpio_write_pin_high(F5);
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(F7, !led_state.num_lock);
+ gpio_write_pin(F7, !led_state.num_lock);
}
return res;
}
@@ 38,16 38,16 @@ bool led_update_kb(led_t led_state) {
layer_state_t layer_state_set_kb(layer_state_t state) {
switch (get_highest_layer(state)) {
case 1:
- writePinHigh(F6);
- writePinLow(F5);
+ gpio_write_pin_high(F6);
+ gpio_write_pin_low(F5);
break;
case 2:
- writePinLow(F6);
- writePinHigh(F5);
+ gpio_write_pin_low(F6);
+ gpio_write_pin_high(F5);
break;
default:
- writePinHigh(F6);
- writePinHigh(F5);
+ gpio_write_pin_high(F6);
+ gpio_write_pin_high(F5);
break;
}
return state;
M keyboards/redscarf_iiplus/verb/matrix.c => keyboards/redscarf_iiplus/verb/matrix.c +38 -38
@@ 114,7 114,7 @@ static void init_pins(void) {
for (int col = 0; col < MATRIX_COLS; col++) {
pin_t pin = direct_pins[row][col];
if (pin != NO_PIN) {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
}
@@ 127,7 127,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
pin_t pin = direct_pins[current_row][col_index];
if (pin != NO_PIN) {
- current_matrix[current_row] |= readPin(pin) ? 0 : (ROW_SHIFTER << col_index);
+ current_matrix[current_row] |= gpio_read_pin(pin) ? 0 : (ROW_SHIFTER << col_index);
}
}
@@ 150,27 150,27 @@ static void select_row(uint8_t col)
{
switch (col) {
case 0:
- writePinLow(B0);
- writePinLow(B1);
- writePinLow(B2);
+ gpio_write_pin_low(B0);
+ gpio_write_pin_low(B1);
+ gpio_write_pin_low(B2);
break;
case 1:
- writePinLow(B0);
- writePinLow(B1);
+ gpio_write_pin_low(B0);
+ gpio_write_pin_low(B1);
break;
case 2:
- writePinLow(B0);
- writePinLow(B2);
+ gpio_write_pin_low(B0);
+ gpio_write_pin_low(B2);
break;
case 3:
- writePinLow(B0);
+ gpio_write_pin_low(B0);
break;
case 4:
- writePinLow(B1);
- writePinLow(B2);
+ gpio_write_pin_low(B1);
+ gpio_write_pin_low(B2);
break;
case 5:
- writePinLow(B1);
+ gpio_write_pin_low(B1);
break;
}
}
@@ 179,46 179,46 @@ static void unselect_row(uint8_t col)
{
switch (col) {
case 0:
- writePinHigh(B0);
- writePinHigh(B1);
- writePinHigh(B2);
+ gpio_write_pin_high(B0);
+ gpio_write_pin_high(B1);
+ gpio_write_pin_high(B2);
break;
case 1:
- writePinHigh(B0);
- writePinHigh(B1);
+ gpio_write_pin_high(B0);
+ gpio_write_pin_high(B1);
break;
case 2:
- writePinHigh(B0);
- writePinHigh(B2);
+ gpio_write_pin_high(B0);
+ gpio_write_pin_high(B2);
break;
case 3:
- writePinHigh(B0);
+ gpio_write_pin_high(B0);
break;
case 4:
- writePinHigh(B1);
- writePinHigh(B2);
+ gpio_write_pin_high(B1);
+ gpio_write_pin_high(B2);
break;
case 5:
- writePinHigh(B1);
+ gpio_write_pin_high(B1);
break;
}
}
static void unselect_rows(void)
{
- setPinOutput(B0);
- setPinOutput(B1);
- setPinOutput(B2);
+ gpio_set_pin_output(B0);
+ gpio_set_pin_output(B1);
+ gpio_set_pin_output(B2);
// make all pins high to select Y7, nothing is connected to that (otherwise the first row will act weird)
- writePinHigh(B0);
- writePinHigh(B1);
- writePinHigh(B2);
+ gpio_write_pin_high(B0);
+ gpio_write_pin_high(B1);
+ gpio_write_pin_high(B2);
}
static void init_pins(void) {
unselect_rows();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 238,7 238,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index);
@@ 254,26 254,26 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
static void select_col(uint8_t col)
{
- setPinOutput(col_pins[col]);
- writePinLow(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
- setPinInputHigh(col_pins[col]);
+ gpio_set_pin_input_high(col_pins[col]);
}
static void unselect_cols(void)
{
for(uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
static void init_pins(void) {
unselect_cols();
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
@@ 293,7 293,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0)
+ if (gpio_read_pin(row_pins[row_index]) == 0)
{
// Pin LO, set col bit
current_matrix[row_index] |= (ROW_SHIFTER << current_col);
M keyboards/redscarf_iiplus/verc/matrix.c => keyboards/redscarf_iiplus/verc/matrix.c +38 -38
@@ 114,7 114,7 @@ static void init_pins(void) {
for (int col = 0; col < MATRIX_COLS; col++) {
pin_t pin = direct_pins[row][col];
if (pin != NO_PIN) {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
}
@@ 127,7 127,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
pin_t pin = direct_pins[current_row][col_index];
if (pin != NO_PIN) {
- current_matrix[current_row] |= readPin(pin) ? 0 : (ROW_SHIFTER << col_index);
+ current_matrix[current_row] |= gpio_read_pin(pin) ? 0 : (ROW_SHIFTER << col_index);
}
}
@@ 150,27 150,27 @@ static void select_row(uint8_t col)
{
switch (col) {
case 0:
- writePinLow(B0);
- writePinLow(B1);
- writePinLow(B2);
+ gpio_write_pin_low(B0);
+ gpio_write_pin_low(B1);
+ gpio_write_pin_low(B2);
break;
case 1:
- writePinLow(B0);
- writePinLow(B1);
+ gpio_write_pin_low(B0);
+ gpio_write_pin_low(B1);
break;
case 2:
- writePinLow(B0);
- writePinLow(B2);
+ gpio_write_pin_low(B0);
+ gpio_write_pin_low(B2);
break;
case 3:
- writePinLow(B0);
+ gpio_write_pin_low(B0);
break;
case 4:
- writePinLow(B1);
- writePinLow(B2);
+ gpio_write_pin_low(B1);
+ gpio_write_pin_low(B2);
break;
case 5:
- writePinLow(B1);
+ gpio_write_pin_low(B1);
break;
}
}
@@ 179,46 179,46 @@ static void unselect_row(uint8_t col)
{
switch (col) {
case 0:
- writePinHigh(B0);
- writePinHigh(B1);
- writePinHigh(B2);
+ gpio_write_pin_high(B0);
+ gpio_write_pin_high(B1);
+ gpio_write_pin_high(B2);
break;
case 1:
- writePinHigh(B0);
- writePinHigh(B1);
+ gpio_write_pin_high(B0);
+ gpio_write_pin_high(B1);
break;
case 2:
- writePinHigh(B0);
- writePinHigh(B2);
+ gpio_write_pin_high(B0);
+ gpio_write_pin_high(B2);
break;
case 3:
- writePinHigh(B0);
+ gpio_write_pin_high(B0);
break;
case 4:
- writePinHigh(B1);
- writePinHigh(B2);
+ gpio_write_pin_high(B1);
+ gpio_write_pin_high(B2);
break;
case 5:
- writePinHigh(B1);
+ gpio_write_pin_high(B1);
break;
}
}
static void unselect_rows(void)
{
- setPinOutput(B0);
- setPinOutput(B1);
- setPinOutput(B2);
+ gpio_set_pin_output(B0);
+ gpio_set_pin_output(B1);
+ gpio_set_pin_output(B2);
// make all pins high to select Y7, nothing is connected to that (otherwise the first row will act weird)
- writePinHigh(B0);
- writePinHigh(B1);
- writePinHigh(B2);
+ gpio_write_pin_high(B0);
+ gpio_write_pin_high(B1);
+ gpio_write_pin_high(B2);
}
static void init_pins(void) {
unselect_rows();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 238,7 238,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index);
@@ 254,26 254,26 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
static void select_col(uint8_t col)
{
- setPinOutput(col_pins[col]);
- writePinLow(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
- setPinInputHigh(col_pins[col]);
+ gpio_set_pin_input_high(col_pins[col]);
}
static void unselect_cols(void)
{
for(uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
static void init_pins(void) {
unselect_cols();
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
@@ 293,7 293,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0)
+ if (gpio_read_pin(row_pins[row_index]) == 0)
{
// Pin LO, set col bit
current_matrix[row_index] |= (ROW_SHIFTER << current_col);
M keyboards/redscarf_iiplus/verd/matrix.c => keyboards/redscarf_iiplus/verd/matrix.c +38 -38
@@ 114,7 114,7 @@ static void init_pins(void) {
for (int col = 0; col < MATRIX_COLS; col++) {
pin_t pin = direct_pins[row][col];
if (pin != NO_PIN) {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
}
@@ 127,7 127,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
pin_t pin = direct_pins[current_row][col_index];
if (pin != NO_PIN) {
- current_matrix[current_row] |= readPin(pin) ? 0 : (ROW_SHIFTER << col_index);
+ current_matrix[current_row] |= gpio_read_pin(pin) ? 0 : (ROW_SHIFTER << col_index);
}
}
@@ 150,27 150,27 @@ static void select_row(uint8_t col)
{
switch (col) {
case 0:
- writePinLow(B0);
- writePinLow(B1);
- writePinLow(B2);
+ gpio_write_pin_low(B0);
+ gpio_write_pin_low(B1);
+ gpio_write_pin_low(B2);
break;
case 1:
- writePinLow(B0);
- writePinLow(B1);
+ gpio_write_pin_low(B0);
+ gpio_write_pin_low(B1);
break;
case 2:
- writePinLow(B0);
- writePinLow(B2);
+ gpio_write_pin_low(B0);
+ gpio_write_pin_low(B2);
break;
case 3:
- writePinLow(B0);
+ gpio_write_pin_low(B0);
break;
case 4:
- writePinLow(B1);
- writePinLow(B2);
+ gpio_write_pin_low(B1);
+ gpio_write_pin_low(B2);
break;
case 5:
- writePinLow(B1);
+ gpio_write_pin_low(B1);
break;
}
}
@@ 179,46 179,46 @@ static void unselect_row(uint8_t col)
{
switch (col) {
case 0:
- writePinHigh(B0);
- writePinHigh(B1);
- writePinHigh(B2);
+ gpio_write_pin_high(B0);
+ gpio_write_pin_high(B1);
+ gpio_write_pin_high(B2);
break;
case 1:
- writePinHigh(B0);
- writePinHigh(B1);
+ gpio_write_pin_high(B0);
+ gpio_write_pin_high(B1);
break;
case 2:
- writePinHigh(B0);
- writePinHigh(B2);
+ gpio_write_pin_high(B0);
+ gpio_write_pin_high(B2);
break;
case 3:
- writePinHigh(B0);
+ gpio_write_pin_high(B0);
break;
case 4:
- writePinHigh(B1);
- writePinHigh(B2);
+ gpio_write_pin_high(B1);
+ gpio_write_pin_high(B2);
break;
case 5:
- writePinHigh(B1);
+ gpio_write_pin_high(B1);
break;
}
}
static void unselect_rows(void)
{
- setPinOutput(B0);
- setPinOutput(B1);
- setPinOutput(B2);
+ gpio_set_pin_output(B0);
+ gpio_set_pin_output(B1);
+ gpio_set_pin_output(B2);
// make all pins high to select Y7, nothing is connected to that (otherwise the first row will act weird)
- writePinHigh(B0);
- writePinHigh(B1);
- writePinHigh(B2);
+ gpio_write_pin_high(B0);
+ gpio_write_pin_high(B1);
+ gpio_write_pin_high(B2);
}
static void init_pins(void) {
unselect_rows();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 238,7 238,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index);
@@ 254,26 254,26 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
static void select_col(uint8_t col)
{
- setPinOutput(col_pins[col]);
- writePinLow(col_pins[col]);
+ gpio_set_pin_output(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
- setPinInputHigh(col_pins[col]);
+ gpio_set_pin_input_high(col_pins[col]);
}
static void unselect_cols(void)
{
for(uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
static void init_pins(void) {
unselect_cols();
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
@@ 293,7 293,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
- if (readPin(row_pins[row_index]) == 0)
+ if (gpio_read_pin(row_pins[row_index]) == 0)
{
// Pin LO, set col bit
current_matrix[row_index] |= (ROW_SHIFTER << current_col);
M keyboards/rmi_kb/wete/v1/v1.c => keyboards/rmi_kb/wete/v1/v1.c +6 -6
@@ 18,17 18,17 @@
void keyboard_pre_init_user(void) {
// Initialize indicator LED pins
- setPinOutput(A14); // Num Lock
- setPinOutput(A15); // Scroll Lock
- setPinOutput(B3); // Caps Lock
+ gpio_set_pin_output(A14); // Num Lock
+ gpio_set_pin_output(A15); // Scroll Lock
+ gpio_set_pin_output(B3); // Caps Lock
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if (res) {
- writePin(A14, !led_state.num_lock);
- writePin(A15, !led_state.scroll_lock);
- writePin(B3, !led_state.caps_lock);
+ gpio_write_pin(A14, !led_state.num_lock);
+ gpio_write_pin(A15, !led_state.scroll_lock);
+ gpio_write_pin(B3, !led_state.caps_lock);
}
return res;
M keyboards/rookiebwoy/neopad/rev1/rev1.c => keyboards/rookiebwoy/neopad/rev1/rev1.c +10 -10
@@ 17,8 17,8 @@
void keyboard_pre_init_kb(void) {
// Set LED IO as outputs
- setPinOutput(LED_00);
- setPinOutput(LED_01);
+ gpio_set_pin_output(LED_00);
+ gpio_set_pin_output(LED_01);
keyboard_pre_init_user();
}
@@ 27,8 27,8 @@ bool shutdown_kb(bool jump_to_bootloader) {
return false;
}
// Shutdown LEDs
- writePinLow(LED_00);
- writePinLow(LED_01);
+ gpio_write_pin_low(LED_00);
+ gpio_write_pin_low(LED_01);
return true;
}
@@ 37,8 37,8 @@ layer_state_t layer_state_set_kb(layer_state_t state) {
// Layer LEDs act as binary indication of current layer
uint8_t layer = get_highest_layer(state);
- writePin(LED_00, layer & 0b1);
- writePin(LED_01, (layer >> 1) & 0b1);
+ gpio_write_pin(LED_00, layer & 0b1);
+ gpio_write_pin(LED_01, (layer >> 1) & 0b1);
return state;
}
@@ 51,11 51,11 @@ void matrix_init_kb(void) {
// runs once when the firmware starts up
uint8_t led_delay_ms = 80;
for (int i = 0; i < 2; i++) {
- writePinHigh(LED_00);
- writePinHigh(LED_01);
+ gpio_write_pin_high(LED_00);
+ gpio_write_pin_high(LED_01);
wait_ms(led_delay_ms);
- writePinLow(LED_00);
- writePinLow(LED_01);
+ gpio_write_pin_low(LED_00);
+ gpio_write_pin_low(LED_01);
if (i < 1) {
wait_ms(led_delay_ms);
}
M keyboards/rubi/rubi.c => keyboards/rubi/rubi.c +1 -1
@@ 68,7 68,7 @@ bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if (res) {
- writePin(C6, led_state.num_lock);
+ gpio_write_pin(C6, led_state.num_lock);
}
return true;
}
M keyboards/ryanskidmore/rskeys100/matrix.c => keyboards/ryanskidmore/rskeys100/matrix.c +22 -22
@@ 30,16 30,16 @@ static void shift_out_single(uint8_t value);
static void shift_out(uint32_t value);
void matrix_init_custom(void) {
- setPinInput(ROW_A);
- setPinInput(ROW_B);
- setPinInput(ROW_C);
- setPinInput(ROW_D);
- setPinInput(ROW_E);
- setPinInput(ROW_F);
-
- setPinOutput(SHR_DATA);
- setPinOutput(SHR_LATCH);
- setPinOutput(SHR_CLOCK);
+ gpio_set_pin_input(ROW_A);
+ gpio_set_pin_input(ROW_B);
+ gpio_set_pin_input(ROW_C);
+ gpio_set_pin_input(ROW_D);
+ gpio_set_pin_input(ROW_E);
+ gpio_set_pin_input(ROW_F);
+
+ gpio_set_pin_output(SHR_DATA);
+ gpio_set_pin_output(SHR_LATCH);
+ gpio_set_pin_output(SHR_CLOCK);
}
bool matrix_scan_custom(matrix_row_t current_matrix[]) {
@@ 63,12 63,12 @@ bool matrix_scan_custom(matrix_row_t current_matrix[]) {
}
static uint8_t read_rows(void) {
- return (readPin(ROW_F) << 5)
- | (readPin(ROW_E) << 4)
- | (readPin(ROW_D) << 3)
- | (readPin(ROW_C) << 2)
- | (readPin(ROW_B) << 1)
- | (readPin(ROW_A) );
+ return (gpio_read_pin(ROW_F) << 5)
+ | (gpio_read_pin(ROW_E) << 4)
+ | (gpio_read_pin(ROW_D) << 3)
+ | (gpio_read_pin(ROW_C) << 2)
+ | (gpio_read_pin(ROW_B) << 1)
+ | (gpio_read_pin(ROW_A) );
}
static void select_col(uint8_t col) {
@@ 76,7 76,7 @@ static void select_col(uint8_t col) {
}
static void shift_out(uint32_t value) {
- writePinLow(SHR_LATCH);
+ gpio_write_pin_low(SHR_LATCH);
uint8_t first_byte = (value >> 16) & 0xFF;
uint8_t second_byte = (value >> 8) & 0xFF;
uint8_t third_byte = (uint8_t)(value & 0xFF);
@@ 84,7 84,7 @@ static void shift_out(uint32_t value) {
shift_out_single(first_byte);
shift_out_single(second_byte);
shift_out_single(third_byte);
- writePinHigh(SHR_LATCH);
+ gpio_write_pin_high(SHR_LATCH);
/* We delay here to prevent multiple consecutive keys being triggered with a single switch press */
_delay_us(10);
}
@@ 92,9 92,9 @@ static void shift_out(uint32_t value) {
static void shift_out_single(uint8_t value) {
for (uint8_t i = 0; i < 8; i++) {
if (value & 0b10000000) {
- writePinHigh(SHR_DATA);
+ gpio_write_pin_high(SHR_DATA);
} else {
- writePinLow(SHR_DATA);
+ gpio_write_pin_low(SHR_DATA);
}
shift_pulse();
@@ 103,6 103,6 @@ static void shift_out_single(uint8_t value) {
}
static inline void shift_pulse(void) {
- writePinHigh(SHR_CLOCK);
- writePinLow(SHR_CLOCK);
+ gpio_write_pin_high(SHR_CLOCK);
+ gpio_write_pin_low(SHR_CLOCK);
}=
\ No newline at end of file
M keyboards/sekigon/grs_70ec/ec_switch_matrix.c => keyboards/sekigon/grs_70ec/ec_switch_matrix.c +13 -13
@@ 29,35 29,35 @@ _Static_assert(sizeof(mux_sel_pins) == 3, "invalid MUX_SEL_PINS");
static ecsm_config_t config;
static uint16_t ecsm_sw_value[MATRIX_ROWS][MATRIX_COLS];
-static inline void discharge_capacitor(void) { setPinOutput(DISCHARGE_PIN); }
+static inline void discharge_capacitor(void) { gpio_set_pin_output(DISCHARGE_PIN); }
static inline void charge_capacitor(uint8_t row) {
- setPinInput(DISCHARGE_PIN);
- writePinHigh(row_pins[row]);
+ gpio_set_pin_input(DISCHARGE_PIN);
+ gpio_write_pin_high(row_pins[row]);
}
static inline void clear_all_row_pins(void) {
for (int row = 0; row < sizeof(row_pins); row++) {
- writePinLow(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
}
static inline void init_mux_sel(void) {
for (int idx = 0; idx < sizeof(mux_sel_pins); idx++) {
- setPinOutput(mux_sel_pins[idx]);
+ gpio_set_pin_output(mux_sel_pins[idx]);
}
}
static inline void select_mux(uint8_t col) {
uint8_t ch = col_channels[col];
- writePin(mux_sel_pins[0], ch & 1);
- writePin(mux_sel_pins[1], ch & 2);
- writePin(mux_sel_pins[2], ch & 4);
+ gpio_write_pin(mux_sel_pins[0], ch & 1);
+ gpio_write_pin(mux_sel_pins[1], ch & 2);
+ gpio_write_pin(mux_sel_pins[2], ch & 4);
}
static inline void init_row(void) {
for (int idx = 0; idx < sizeof(row_pins); idx++) {
- setPinOutput(row_pins[idx]);
- writePinLow(row_pins[idx]);
+ gpio_set_pin_output(row_pins[idx]);
+ gpio_write_pin_low(row_pins[idx]);
}
}
@@ 67,8 67,8 @@ int ecsm_init(ecsm_config_t const* const ecsm_config) {
config = *ecsm_config;
// initialize discharge pin as discharge mode
- writePinLow(DISCHARGE_PIN);
- setPinOutput(DISCHARGE_PIN);
+ gpio_write_pin_low(DISCHARGE_PIN);
+ gpio_set_pin_output(DISCHARGE_PIN);
// set analog reference
analogReference(ADC_REF_POWER);
@@ 80,7 80,7 @@ int ecsm_init(ecsm_config_t const* const ecsm_config) {
init_mux_sel();
// set discharge pin to charge mode
- setPinInput(DISCHARGE_PIN);
+ gpio_set_pin_input(DISCHARGE_PIN);
return 0;
}
M keyboards/sekigon/grs_70ec/grs_70ec.c => keyboards/sekigon/grs_70ec/grs_70ec.c +5 -5
@@ 17,11 17,11 @@
#include "grs_70ec.h"
void led_on(void) {
- setPinOutput(D2);
- writePinHigh(D2);
+ gpio_set_pin_output(D2);
+ gpio_write_pin_high(D2);
}
-void led_off(void) { writePinLow(D2); }
+void led_off(void) { gpio_write_pin_low(D2); }
void keyboard_post_init_kb(void) {
led_on();
@@ 31,8 31,8 @@ void keyboard_post_init_kb(void) {
void keyboard_pre_init_kb(void) {
// Turn on extern circuit
- setPinOutput(F7);
- writePinHigh(F7);
+ gpio_set_pin_output(F7);
+ gpio_write_pin_high(F7);
keyboard_pre_init_user();
}
M keyboards/sergiopoverony/creator_pro/creator_pro.c => keyboards/sergiopoverony/creator_pro/creator_pro.c +7 -7
@@ 19,15 19,15 @@
void matrix_init_kb(void) {
matrix_init_user();
/* led pins */
- setPinOutput(RED_LED);
- setPinOutput(BLUE_LED);
- setPinOutput(GREEN_LED);
+ gpio_set_pin_output(RED_LED);
+ gpio_set_pin_output(BLUE_LED);
+ gpio_set_pin_output(GREEN_LED);
}
void turn_off_leds(void) {
- writePinLow(RED_LED);
- writePinLow(BLUE_LED);
- writePinLow(GREEN_LED);
+ gpio_write_pin_low(RED_LED);
+ gpio_write_pin_low(BLUE_LED);
+ gpio_write_pin_low(GREEN_LED);
}
void turn_on_led(pin_t pin) {
- writePinHigh(pin);
+ gpio_write_pin_high(pin);
}
M keyboards/skyloong/gk61/pro/pro.c => keyboards/skyloong/gk61/pro/pro.c +2 -2
@@ 213,14 213,14 @@ bool rgb_matrix_indicators_advanced_kb(uint8_t led_min, uint8_t led_max) {
void suspend_power_down_kb() {
# ifdef RGB_MATRIX_ENABLE
- writePinLow(IS31FL3743A_SDB_PIN);
+ gpio_write_pin_low(IS31FL3743A_SDB_PIN);
# endif
suspend_power_down_user();
}
void suspend_wakeup_init_kb() {
# ifdef RGB_MATRIX_ENABLE
- writePinHigh(IS31FL3743A_SDB_PIN);
+ gpio_write_pin_high(IS31FL3743A_SDB_PIN);
# endif
suspend_wakeup_init_user();
}
M keyboards/skyloong/gk61/pro_48/pro_48.c => keyboards/skyloong/gk61/pro_48/pro_48.c +2 -2
@@ 149,12 149,12 @@ bool rgb_matrix_indicators_advanced_kb(uint8_t led_min, uint8_t led_max) {
void suspend_power_down_kb(void) {
- writePinLow(IS31FL3743A_SDB_PIN);
+ gpio_write_pin_low(IS31FL3743A_SDB_PIN);
suspend_power_down_user();
}
void suspend_wakeup_init_kb(void) {
- writePinHigh(IS31FL3743A_SDB_PIN);
+ gpio_write_pin_high(IS31FL3743A_SDB_PIN);
suspend_wakeup_init_user();
}
#endif
M keyboards/skyloong/gk61/v1/v1.c => keyboards/skyloong/gk61/v1/v1.c +2 -2
@@ 102,13 102,13 @@ const snled27351_led_t PROGMEM g_snled27351_leds[SNLED27351_LED_COUNT] = {
#endif // RGB_MATRIX_ENABLE
void suspend_power_down_kb() {
- writePinLow(SNLED27351_SDB_PIN);
+ gpio_write_pin_low(SNLED27351_SDB_PIN);
suspend_power_down_user();
}
void suspend_wakeup_init_kb() {
- writePinHigh(SNLED27351_SDB_PIN);
+ gpio_write_pin_high(SNLED27351_SDB_PIN);
suspend_wakeup_init_user();
}
M keyboards/smithrune/iron165r2/iron165r2.c => keyboards/smithrune/iron165r2/iron165r2.c +3 -3
@@ 17,8 17,8 @@
#include "quantum.h"
void board_init(void) {
- setPinInput(B6);
- setPinInput(B7);
+ gpio_set_pin_input(B6);
+ gpio_set_pin_input(B7);
#if defined (LINE_RGBS)
rgblight_set_effect_range(0,16);
#elif defined (RUNE_RGBS)
@@ 30,6 30,6 @@ void board_init(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
- if(res) writePin(LED_CAPS_LOCK_PIN, led_state.caps_lock);
+ if(res) gpio_write_pin(LED_CAPS_LOCK_PIN, led_state.caps_lock);
return res;
}
M keyboards/sneakbox/aliceclone/aliceclone.c => keyboards/sneakbox/aliceclone/aliceclone.c +6 -6
@@ 18,9 18,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(D7);
- setPinOutput(D6);
- setPinOutput(D4);
+ gpio_set_pin_output(D7);
+ gpio_set_pin_output(D6);
+ gpio_set_pin_output(D4);
keyboard_pre_init_user();
}
@@ 28,9 28,9 @@ void keyboard_pre_init_kb(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(D7, led_state.num_lock);
- writePin(D6, led_state.caps_lock);
- writePin(D4, led_state.scroll_lock);
+ gpio_write_pin(D7, led_state.num_lock);
+ gpio_write_pin(D6, led_state.caps_lock);
+ gpio_write_pin(D4, led_state.scroll_lock);
}
return res;
}
M keyboards/snes_macropad/matrix.c => keyboards/snes_macropad/matrix.c +30 -30
@@ 36,48 36,48 @@ static const int kbd_pin_map[] = {
void matrix_init_custom(void) {
// init snes controller
- setPinInputHigh(SNES_D0);
+ gpio_set_pin_input_high(SNES_D0);
// todo: look into protocol for other strange snes controllers that use D1 and IO
- // setPinInputHigh(SNES_D1);
- // setPinInputHigh(SNES_IO);
- setPinOutput(SNES_CLOCK);
- setPinOutput(SNES_LATCH);
- writePinLow(SNES_CLOCK);
- writePinLow(SNES_LATCH);
+ // gpio_set_pin_input_high(SNES_D1);
+ // gpio_set_pin_input_high(SNES_IO);
+ gpio_set_pin_output(SNES_CLOCK);
+ gpio_set_pin_output(SNES_LATCH);
+ gpio_write_pin_low(SNES_CLOCK);
+ gpio_write_pin_low(SNES_LATCH);
// init rows
- setPinOutput(KBD_ROW0);
- setPinOutput(KBD_ROW1);
- setPinOutput(KBD_ROW2);
- writePinHigh(KBD_ROW0);
- writePinHigh(KBD_ROW1);
- writePinHigh(KBD_ROW2);
+ gpio_set_pin_output(KBD_ROW0);
+ gpio_set_pin_output(KBD_ROW1);
+ gpio_set_pin_output(KBD_ROW2);
+ gpio_write_pin_high(KBD_ROW0);
+ gpio_write_pin_high(KBD_ROW1);
+ gpio_write_pin_high(KBD_ROW2);
// init columns
- setPinInputHigh(KBD_COL0);
- setPinInputHigh(KBD_COL1);
- setPinInputHigh(KBD_COL2);
- setPinInputHigh(KBD_COL3);
+ gpio_set_pin_input_high(KBD_COL0);
+ gpio_set_pin_input_high(KBD_COL1);
+ gpio_set_pin_input_high(KBD_COL2);
+ gpio_set_pin_input_high(KBD_COL3);
}
static matrix_row_t readRow(size_t row, int setupDelay) {
const int pin = kbd_pin_map[row];
// select the row
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
wait_us(setupDelay);
// read the column data
const matrix_row_t ret =
- (readPin(KBD_COL0) ? 0 : 1 << 0)
- | (readPin(KBD_COL1) ? 0 : 1 << 1)
- | (readPin(KBD_COL2) ? 0 : 1 << 2)
- | (readPin(KBD_COL3) ? 0 : 1 << 3);
+ (gpio_read_pin(KBD_COL0) ? 0 : 1 << 0)
+ | (gpio_read_pin(KBD_COL1) ? 0 : 1 << 1)
+ | (gpio_read_pin(KBD_COL2) ? 0 : 1 << 2)
+ | (gpio_read_pin(KBD_COL3) ? 0 : 1 << 3);
// deselect the row
- setPinOutput(pin);
- writePinHigh(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_high(pin);
return ret;
}
@@ 103,7 103,7 @@ static matrix_row_t getBits(uint16_t value, size_t bit0, size_t bit1, size_t bit
static void readSnesController(matrix_row_t current_matrix[]) {
uint16_t controller = 0;
- writePinHigh(SNES_LATCH);
+ gpio_write_pin_high(SNES_LATCH);
for (size_t bit = 0; bit < SNES_DATA_BITS; ++bit) {
// Wait for shift register to setup the data line
@@ 111,16 111,16 @@ static void readSnesController(matrix_row_t current_matrix[]) {
// Shift accumulated data and read data pin
controller <<= 1;
- controller |= readPin(SNES_D0) ? 0 : 1;
+ controller |= gpio_read_pin(SNES_D0) ? 0 : 1;
// todo: maybe read D1 and IO here too
// Shift next bit in
- writePinHigh(SNES_CLOCK);
+ gpio_write_pin_high(SNES_CLOCK);
wait_us(SNES_CLOCK_PULSE_DURATION);
- writePinLow(SNES_CLOCK);
+ gpio_write_pin_low(SNES_CLOCK);
}
- writePinLow(SNES_LATCH);
+ gpio_write_pin_low(SNES_LATCH);
controller >>= 4;
M keyboards/splitkb/aurora/helix/rev1/rev1.c => keyboards/splitkb/aurora/helix/rev1/rev1.c +2 -2
@@ 24,8 24,8 @@ static enum { UNKNOWN, LEFT, RIGHT } hand_side = UNKNOWN;
if (hand_side == UNKNOWN) {
#if defined(SPLIT_HAND_PIN)
// Test pin SPLIT_HAND_PIN for High/Low, if low it's right hand
- setPinInput(SPLIT_HAND_PIN);
- hand_side = readPin(SPLIT_HAND_PIN) ? LEFT : RIGHT;
+ gpio_set_pin_input(SPLIT_HAND_PIN);
+ hand_side = gpio_read_pin(SPLIT_HAND_PIN) ? LEFT : RIGHT;
return (hand_side == LEFT);
#endif
hand_side = is_keyboard_master() ? LEFT : RIGHT;
M keyboards/sthlmkb/lagom/matrix.c => keyboards/sthlmkb/lagom/matrix.c +5 -5
@@ 27,17 27,17 @@ static const uint8_t col_pins[MATRIX_MUX_COLS] = MATRIX_COL_MUX_PINS;
static void init_pins(void) {
// Set cols to outputs, low
for (uint8_t pin = 0; pin < MATRIX_MUX_COLS; pin++) {
- setPinOutput(col_pins[pin]);
+ gpio_set_pin_output(col_pins[pin]);
}
// Unselect cols
for (uint8_t bit = 0; bit < MATRIX_MUX_COLS; bit++) {
- writePinLow(col_pins[bit]);
+ gpio_write_pin_low(col_pins[bit]);
}
// Set rows to input, pullup
for (uint8_t pin = 0; pin < MATRIX_ROWS; pin++) {
- setPinInputHigh(row_pins[pin]);
+ gpio_set_pin_input_high(row_pins[pin]);
}
}
@@ 45,7 45,7 @@ static void select_col(uint8_t col)
{
for (uint8_t bit = 0; bit < MATRIX_MUX_COLS; bit++) {
uint8_t state = (col & (0b1 << bit)) >> bit;
- writePin(col_pins[bit], state);
+ gpio_write_pin(col_pins[bit], state);
}
}
@@ 60,7 60,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
{
matrix_row_t last_row_value = current_matrix[row_index];
- if (!readPin(row_pins[row_index]))
+ if (!gpio_read_pin(row_pins[row_index]))
{
current_matrix[row_index] |= (COL_SHIFTER << current_col);
}
M keyboards/strech/soulstone/soulstone.c => keyboards/strech/soulstone/soulstone.c +3 -3
@@ 18,13 18,13 @@
// Prepare layer indicator LED
void keyboard_post_init_kb(void) {
- setPinOutput(LAYER_INDICATOR_LED_PIN);
- writePinLow(LAYER_INDICATOR_LED_PIN);
+ gpio_set_pin_output(LAYER_INDICATOR_LED_PIN);
+ gpio_write_pin_low(LAYER_INDICATOR_LED_PIN);
keyboard_post_init_user();
}
// Function for layer indicator LED
layer_state_t layer_state_set_kb(layer_state_t state) {
- writePin(LAYER_INDICATOR_LED_PIN, !layer_state_cmp(state, 0));
+ gpio_write_pin(LAYER_INDICATOR_LED_PIN, !layer_state_cmp(state, 0));
return layer_state_set_user(state);
}
M keyboards/switchplate/southpaw_65/southpaw_65.c => keyboards/switchplate/southpaw_65/southpaw_65.c +2 -2
@@ 16,7 16,7 @@
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(B6);
+ gpio_set_pin_output(B6);
keyboard_pre_init_user();
}
@@ 24,7 24,7 @@ void keyboard_pre_init_kb(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(B6, !led_state.caps_lock);
+ gpio_write_pin(B6, !led_state.caps_lock);
}
return res;
}
M keyboards/switchplate/southpaw_fullsize/southpaw_fullsize.c => keyboards/switchplate/southpaw_fullsize/southpaw_fullsize.c +6 -6
@@ 30,9 30,9 @@ void matrix_init_kb(void) {
// runs once when the firmware starts up
// D3 Numlock, D4 Capslock, D5 Scrlock
- setPinOutput(INDICATOR_NUM);
- setPinOutput(INDICATOR_CAPS);
- setPinOutput(INDICATOR_SCR);
+ gpio_set_pin_output(INDICATOR_NUM);
+ gpio_set_pin_output(INDICATOR_CAPS);
+ gpio_set_pin_output(INDICATOR_SCR);
matrix_init_user();
}
@@ 42,9 42,9 @@ bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if (res)
{
- writePin(INDICATOR_NUM, !led_state.num_lock);
- writePin(INDICATOR_CAPS, !led_state.caps_lock);
- writePin(INDICATOR_SCR, !led_state.scroll_lock);
+ gpio_write_pin(INDICATOR_NUM, !led_state.num_lock);
+ gpio_write_pin(INDICATOR_CAPS, !led_state.caps_lock);
+ gpio_write_pin(INDICATOR_SCR, !led_state.scroll_lock);
}
return res;
}
M keyboards/team0110/p1800fl/p1800fl.c => keyboards/team0110/p1800fl/p1800fl.c +3 -3
@@ 19,9 19,9 @@
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(D3, led_state.num_lock);
- writePin(D5, led_state.caps_lock);
- writePin(C6, led_state.scroll_lock);
+ gpio_write_pin(D3, led_state.num_lock);
+ gpio_write_pin(D5, led_state.caps_lock);
+ gpio_write_pin(C6, led_state.scroll_lock);
}
return res;
}
M keyboards/technika/technika.c => keyboards/technika/technika.c +3 -3
@@ 18,9 18,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(A15);
- setPinOutput(B3);
- setPinOutput(B4);
+ gpio_set_pin_output(A15);
+ gpio_set_pin_output(B3);
+ gpio_set_pin_output(B4);
keyboard_pre_init_user();
}
M keyboards/telophase/telophase.c => keyboards/telophase/telophase.c +6 -6
@@ 18,12 18,12 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "telophase.h"
void led_init(void) {
- setPinOutput(D1);
- setPinOutput(F4);
- setPinOutput(F5);
- writePinHigh(D1);
- writePinHigh(F4);
- writePinHigh(F5);
+ gpio_set_pin_output(D1);
+ gpio_set_pin_output(F4);
+ gpio_set_pin_output(F5);
+ gpio_write_pin_high(D1);
+ gpio_write_pin_high(F4);
+ gpio_write_pin_high(F5);
}
void matrix_init_kb(void) {
M keyboards/telophase/telophase.h => keyboards/telophase/telophase.h +6 -6
@@ 19,12 19,12 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "quantum.h"
-#define red_led_off writePinHigh(F5)
-#define red_led_on writePinLow(F5)
-#define blu_led_off writePinHigh(F4)
-#define blu_led_on writePinLow(F4)
-#define grn_led_off writePinHigh(D1)
-#define grn_led_on writePinLow(D1)
+#define red_led_off gpio_write_pin_high(F5)
+#define red_led_on gpio_write_pin_low(F5)
+#define blu_led_off gpio_write_pin_high(F4)
+#define blu_led_on gpio_write_pin_low(F4)
+#define grn_led_off gpio_write_pin_high(D1)
+#define grn_led_on gpio_write_pin_low(D1)
#define set_led_off red_led_off; grn_led_off; blu_led_off
#define set_led_red red_led_on; grn_led_off; blu_led_off
M keyboards/tkc/m0lly/m0lly.c => keyboards/tkc/m0lly/m0lly.c +4 -4
@@ 17,11 17,11 @@
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinInputHigh(D0);
- setPinInputHigh(D1);
+ gpio_set_pin_input_high(D0);
+ gpio_set_pin_input_high(D1);
- setPinOutput(B7);
- writePinHigh(B7);
+ gpio_set_pin_output(B7);
+ gpio_write_pin_high(B7);
keyboard_pre_init_user();
}
M keyboards/tkc/osav2/osav2.c => keyboards/tkc/osav2/osav2.c +6 -6
@@ 16,18 16,18 @@
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(C7);
- setPinOutput(C6);
- setPinOutput(B6);
+ gpio_set_pin_output(C7);
+ gpio_set_pin_output(C6);
+ gpio_set_pin_output(B6);
keyboard_pre_init_user();
}
bool led_update_kb(led_t led_state) {
if (led_update_user(led_state)) {
- writePin(C7, led_state.num_lock);
- writePin(C6, led_state.caps_lock);
- writePin(B6, led_state.scroll_lock);
+ gpio_write_pin(C7, led_state.num_lock);
+ gpio_write_pin(C6, led_state.caps_lock);
+ gpio_write_pin(B6, led_state.scroll_lock);
}
return true;
}
M keyboards/tkc/tkc1800/tkc1800.c => keyboards/tkc/tkc1800/tkc1800.c +4 -4
@@ 16,11 16,11 @@
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinInputHigh(D0);
- setPinInputHigh(D1);
+ gpio_set_pin_input_high(D0);
+ gpio_set_pin_input_high(D1);
- setPinOutput(B7);
- writePinHigh(B7);
+ gpio_set_pin_output(B7);
+ gpio_write_pin_high(B7);
keyboard_pre_init_user();
}
M keyboards/torn/matrix.c => keyboards/torn/matrix.c +6 -6
@@ 30,15 30,15 @@ static const mcp23018_pin_t secondary_row_pins[MATRIX_ROWS] = SECONDARY_RO
static const mcp23018_pin_t secondary_col_pins[SPLIT_MATRIX_COLS] = SECONDARY_COL_PINS;
static void select_row(uint8_t row) {
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
-static void unselect_row(uint8_t row) { setPinInputHigh(row_pins[row]); }
+static void unselect_row(uint8_t row) { gpio_set_pin_input_high(row_pins[row]); }
static void unselect_rows(void) {
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
@@ 50,7 50,7 @@ static void select_secondary_row(uint8_t row) {
static void init_pins(void) {
unselect_rows();
for (uint8_t x = 0; x < SPLIT_MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 60,7 60,7 @@ static matrix_row_t read_cols(void) {
// For each col...
for (uint8_t col_index = 0; col_index < SPLIT_MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
state |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
M keyboards/touchpad/matrix.c => keyboards/touchpad/matrix.c +34 -34
@@ 127,32 127,32 @@ void matrix_init(void) {
i2c_init();
//Motor enable
- setPinOutput(E6);
+ gpio_set_pin_output(E6);
//Motor PWM
- setPinOutput(D7);
+ gpio_set_pin_output(D7);
//Power LED
- setPinOutput(B7);
- writePinHigh(B7);
+ gpio_set_pin_output(B7);
+ gpio_write_pin_high(B7);
//LEDs Columns
- setPinOutput(F7);
- setPinOutput(F6);
- setPinOutput(F5);
- setPinOutput(F4);
- setPinOutput(F1);
- setPinOutput(F0);
+ gpio_set_pin_output(F7);
+ gpio_set_pin_output(F6);
+ gpio_set_pin_output(F5);
+ gpio_set_pin_output(F4);
+ gpio_set_pin_output(F1);
+ gpio_set_pin_output(F0);
//LEDs Rows
- setPinOutput(D6);
- setPinOutput(B4);
- setPinOutput(B5);
- setPinOutput(B6);
- setPinOutput(C6);
- setPinOutput(C7);
+ gpio_set_pin_output(D6);
+ gpio_set_pin_output(B4);
+ gpio_set_pin_output(B5);
+ gpio_set_pin_output(B6);
+ gpio_set_pin_output(C6);
+ gpio_set_pin_output(C7);
//Capacitive Interrupt
- setPinInput(D2);
+ gpio_set_pin_input(D2);
capSetup();
writeDataToTS(0x06, 0x12); //Calibrate capacitive touch IC
@@ 208,7 208,7 @@ void touchClearCurrentDetections(void) {
//Check interrupt pin
uint8_t isTouchChangeDetected(void) {
- return !readPin(D2);
+ return !gpio_read_pin(D2);
}
uint8_t matrix_scan(void) {
@@ 232,34 232,34 @@ uint8_t matrix_scan(void) {
for (uint8_t c = 0; c < 6; c++) {
for (uint8_t r = 0; r < 6; r++) {
switch (r) {
- case 0: writePin(D6, matrix_is_on(r, c)); break;
- case 1: writePin(B4, matrix_is_on(r, c)); break;
- case 2: writePin(B5, matrix_is_on(r, c)); break;
- case 3: writePin(B6, matrix_is_on(r, c)); break;
- case 4: writePin(C6, matrix_is_on(r, c)); break;
- case 5: writePin(C7, matrix_is_on(r, c)); break;
+ case 0: gpio_write_pin(D6, matrix_is_on(r, c)); break;
+ case 1: gpio_write_pin(B4, matrix_is_on(r, c)); break;
+ case 2: gpio_write_pin(B5, matrix_is_on(r, c)); break;
+ case 3: gpio_write_pin(B6, matrix_is_on(r, c)); break;
+ case 4: gpio_write_pin(C6, matrix_is_on(r, c)); break;
+ case 5: gpio_write_pin(C7, matrix_is_on(r, c)); break;
}
switch (c) {
- case 0: writePin(F5, !matrix_is_on(r, c)); break;
- case 1: writePin(F4, !matrix_is_on(r, c)); break;
- case 2: writePin(F1, !matrix_is_on(r, c)); break;
- case 3: writePin(F0, !matrix_is_on(r, c)); break;
- case 4: writePin(F6, !matrix_is_on(r, c)); break;
- case 5: writePin(F7, !matrix_is_on(r, c)); break;
+ case 0: gpio_write_pin(F5, !matrix_is_on(r, c)); break;
+ case 1: gpio_write_pin(F4, !matrix_is_on(r, c)); break;
+ case 2: gpio_write_pin(F1, !matrix_is_on(r, c)); break;
+ case 3: gpio_write_pin(F0, !matrix_is_on(r, c)); break;
+ case 4: gpio_write_pin(F6, !matrix_is_on(r, c)); break;
+ case 5: gpio_write_pin(F7, !matrix_is_on(r, c)); break;
}
}
}
if (vibrate == VIBRATE_LENGTH) {
- writePinHigh(E6);
- writePinHigh(D7);
+ gpio_write_pin_high(E6);
+ gpio_write_pin_high(D7);
vibrate--;
} else if (vibrate > 0) {
vibrate--;
} else if (vibrate == 0) {
- writePinLow(D7);
- writePinLow(E6);
+ gpio_write_pin_low(D7);
+ gpio_write_pin_low(E6);
}
matrix_scan_kb();
M keyboards/tr60w/tr60w.c => keyboards/tr60w/tr60w.c +3 -3
@@ 3,9 3,9 @@
bool led_update_kb(led_t led_state) {
bool runDefault = led_update_user(led_state);
if (runDefault) {
- writePin(B1, !led_state.num_lock);
- writePin(B2, !led_state.caps_lock);
- writePin(B3, !led_state.scroll_lock);
+ gpio_write_pin(B1, !led_state.num_lock);
+ gpio_write_pin(B2, !led_state.caps_lock);
+ gpio_write_pin(B3, !led_state.scroll_lock);
}
return runDefault;
}
M keyboards/tzarc/djinn/djinn.c => keyboards/tzarc/djinn/djinn.c +22 -22
@@ 46,23 46,23 @@ void keyboard_post_init_kb(void) {
memset(&kb_state, 0, sizeof(kb_state));
// Turn off increased current limits
- setPinOutput(RGB_CURR_1500mA_OK_PIN);
- writePinLow(RGB_CURR_1500mA_OK_PIN);
- setPinOutput(RGB_CURR_3000mA_OK_PIN);
- writePinLow(RGB_CURR_3000mA_OK_PIN);
+ gpio_set_pin_output(RGB_CURR_1500mA_OK_PIN);
+ gpio_write_pin_low(RGB_CURR_1500mA_OK_PIN);
+ gpio_set_pin_output(RGB_CURR_3000mA_OK_PIN);
+ gpio_write_pin_low(RGB_CURR_3000mA_OK_PIN);
// Turn on the RGB
- setPinOutput(RGB_POWER_ENABLE_PIN);
- writePinHigh(RGB_POWER_ENABLE_PIN);
+ gpio_set_pin_output(RGB_POWER_ENABLE_PIN);
+ gpio_write_pin_high(RGB_POWER_ENABLE_PIN);
#ifdef EXTERNAL_FLASH_SPI_SLAVE_SELECT_PIN
- setPinOutput(EXTERNAL_FLASH_SPI_SLAVE_SELECT_PIN);
- writePinHigh(EXTERNAL_FLASH_SPI_SLAVE_SELECT_PIN);
+ gpio_set_pin_output(EXTERNAL_FLASH_SPI_SLAVE_SELECT_PIN);
+ gpio_write_pin_high(EXTERNAL_FLASH_SPI_SLAVE_SELECT_PIN);
#endif // EXTERNAL_FLASH_SPI_SLAVE_SELECT_PIN
// Turn on the LCD
- setPinOutput(LCD_POWER_ENABLE_PIN);
- writePinHigh(LCD_POWER_ENABLE_PIN);
+ gpio_set_pin_output(LCD_POWER_ENABLE_PIN);
+ gpio_write_pin_high(LCD_POWER_ENABLE_PIN);
// Let the LCD get some power...
wait_ms(150);
@@ 148,16 148,16 @@ void housekeeping_task_kb(void) {
switch (current_setting) {
default:
case USBPD_500MA:
- writePinLow(RGB_CURR_1500mA_OK_PIN);
- writePinLow(RGB_CURR_3000mA_OK_PIN);
+ gpio_write_pin_low(RGB_CURR_1500mA_OK_PIN);
+ gpio_write_pin_low(RGB_CURR_3000mA_OK_PIN);
break;
case USBPD_1500MA:
- writePinHigh(RGB_CURR_1500mA_OK_PIN);
- writePinLow(RGB_CURR_3000mA_OK_PIN);
+ gpio_write_pin_high(RGB_CURR_1500mA_OK_PIN);
+ gpio_write_pin_low(RGB_CURR_3000mA_OK_PIN);
break;
case USBPD_3000MA:
- writePinHigh(RGB_CURR_1500mA_OK_PIN);
- writePinHigh(RGB_CURR_3000mA_OK_PIN);
+ gpio_write_pin_high(RGB_CURR_1500mA_OK_PIN);
+ gpio_write_pin_high(RGB_CURR_3000mA_OK_PIN);
break;
}
#else
@@ 166,12 166,12 @@ void housekeeping_task_kb(void) {
default:
case USBPD_500MA:
case USBPD_1500MA:
- writePinLow(RGB_CURR_1500mA_OK_PIN);
- writePinLow(RGB_CURR_3000mA_OK_PIN);
+ gpio_write_pin_low(RGB_CURR_1500mA_OK_PIN);
+ gpio_write_pin_low(RGB_CURR_3000mA_OK_PIN);
break;
case USBPD_3000MA:
- writePinHigh(RGB_CURR_1500mA_OK_PIN);
- writePinLow(RGB_CURR_3000mA_OK_PIN);
+ gpio_write_pin_high(RGB_CURR_1500mA_OK_PIN);
+ gpio_write_pin_low(RGB_CURR_3000mA_OK_PIN);
break;
}
#endif
@@ 189,7 189,7 @@ void housekeeping_task_kb(void) {
// Enable/disable RGB
if (peripherals_on) {
// Turn on RGB
- writePinHigh(RGB_POWER_ENABLE_PIN);
+ gpio_write_pin_high(RGB_POWER_ENABLE_PIN);
// Modify the RGB state if different to the LCD state
if (rgb_matrix_is_enabled() != peripherals_on) {
// Wait for a small amount of time to allow the RGB capacitors to charge, before enabling RGB output
@@ 199,7 199,7 @@ void housekeeping_task_kb(void) {
}
} else {
// Turn off RGB
- writePinLow(RGB_POWER_ENABLE_PIN);
+ gpio_write_pin_low(RGB_POWER_ENABLE_PIN);
// Disable the PWM output for the RGB
if (rgb_matrix_is_enabled() != peripherals_on) {
rgb_matrix_disable_noeeprom();
M keyboards/tzarc/djinn/djinn_portscan_matrix.c => keyboards/tzarc/djinn/djinn_portscan_matrix.c +13 -13
@@ 16,7 16,7 @@ void matrix_wait_for_pin(pin_t pin, uint8_t target_state) {
rtcnt_t start = chSysGetRealtimeCounterX();
rtcnt_t end = start + 5000;
while (chSysIsCounterWithinX(chSysGetRealtimeCounterX(), start, end)) {
- if (readPin(pin) == target_state) {
+ if (gpio_read_pin(pin) == target_state) {
break;
}
}
@@ 36,10 36,10 @@ static void dummy_vt_callback(virtual_timer_t *vtp, void *p) {}
void matrix_init_custom(void) {
for (int i = 0; i < MATRIX_ROWS; ++i) {
- setPinInputHigh(row_pins[i]);
+ gpio_set_pin_input_high(row_pins[i]);
}
for (int i = 0; i < MATRIX_COLS; ++i) {
- setPinInputHigh(col_pins[i]);
+ gpio_set_pin_input_high(col_pins[i]);
}
// Start a virtual timer so we'll still get periodic wakeups, now that USB SOF doesn't wake up the main loop
@@ 56,8 56,8 @@ bool matrix_scan_custom(matrix_row_t current_matrix[]) {
pin_t curr_col_pin = col_pins[current_col];
// Setup the output column pin
- setPinOutput(curr_col_pin);
- writePinLow(curr_col_pin);
+ gpio_set_pin_output(curr_col_pin);
+ gpio_write_pin_low(curr_col_pin);
matrix_wait_for_pin(curr_col_pin, 0);
// Read the row ports
@@ 65,7 65,7 @@ bool matrix_scan_custom(matrix_row_t current_matrix[]) {
uint32_t gpio_c = palReadPort(GPIOC);
// Unselect the row pin
- setPinInputHigh(curr_col_pin);
+ gpio_set_pin_input_high(curr_col_pin);
// Construct the packed bitmask for the pins
uint32_t readback = ~(((gpio_b & GPIOB_BITMASK) >> GPIOB_OFFSET) | (((gpio_c & GPIOC_BITMASK) >> GPIOC_OFFSET) << GPIOB_COUNT));
@@ 98,11 98,11 @@ bool matrix_scan_custom(matrix_row_t current_matrix[]) {
void matrix_wait_for_interrupt(void) {
// Set up row/col pins and attach callback
for (int i = 0; i < ARRAY_SIZE(col_pins); ++i) {
- setPinOutput(col_pins[i]);
- writePinLow(col_pins[i]);
+ gpio_set_pin_output(col_pins[i]);
+ gpio_write_pin_low(col_pins[i]);
}
for (int i = 0; i < ARRAY_SIZE(row_pins); ++i) {
- setPinInputHigh(row_pins[i]);
+ gpio_set_pin_input_high(row_pins[i]);
palEnableLineEvent(row_pins[i], PAL_EVENT_MODE_BOTH_EDGES);
}
@@ 112,11 112,11 @@ void matrix_wait_for_interrupt(void) {
// Now that the interrupt has woken us up, reset all the row/col pins back to defaults
for (int i = 0; i < ARRAY_SIZE(row_pins); ++i) {
palDisableLineEvent(row_pins[i]);
- writePinHigh(row_pins[i]);
- setPinInputHigh(row_pins[i]);
+ gpio_write_pin_high(row_pins[i]);
+ gpio_set_pin_input_high(row_pins[i]);
}
for (int i = 0; i < ARRAY_SIZE(col_pins); ++i) {
- writePinHigh(col_pins[i]);
- setPinInputHigh(col_pins[i]);
+ gpio_write_pin_high(col_pins[i]);
+ gpio_set_pin_input_high(col_pins[i]);
}
}
M keyboards/tzarc/ghoul/ghoul.c => keyboards/tzarc/ghoul/ghoul.c +6 -6
@@ 6,8 6,8 @@
void keyboard_post_init_kb(void) {
// Enable RGB current limiter and wait for a bit before allowing RGB to continue
- setPinOutput(RGB_ENABLE_PIN);
- writePinHigh(RGB_ENABLE_PIN);
+ gpio_set_pin_output(RGB_ENABLE_PIN);
+ gpio_write_pin_high(RGB_ENABLE_PIN);
wait_ms(20);
// Offload to the user func
@@ 16,12 16,12 @@ void keyboard_post_init_kb(void) {
void matrix_init_custom(void) {
// SPI Matrix
- setPinOutput(SPI_MATRIX_CHIP_SELECT_PIN);
- writePinHigh(SPI_MATRIX_CHIP_SELECT_PIN);
+ gpio_set_pin_output(SPI_MATRIX_CHIP_SELECT_PIN);
+ gpio_write_pin_high(SPI_MATRIX_CHIP_SELECT_PIN);
spi_init();
// Encoder pushbutton
- setPinInputLow(ENCODER_PUSHBUTTON_PIN);
+ gpio_set_pin_input_low(ENCODER_PUSHBUTTON_PIN);
}
bool matrix_scan_custom(matrix_row_t current_matrix[]) {
@@ 33,7 33,7 @@ bool matrix_scan_custom(matrix_row_t current_matrix[]) {
spi_stop();
// Read from the encoder pushbutton
- temp_matrix[5] = readPin(ENCODER_PUSHBUTTON_PIN) ? 1 : 0;
+ temp_matrix[5] = gpio_read_pin(ENCODER_PUSHBUTTON_PIN) ? 1 : 0;
// Check if we've changed, return the last-read data
bool changed = memcmp(current_matrix, temp_matrix, sizeof(temp_matrix)) != 0;
M keyboards/unicomp/spacesaver_m_post_2013/overnumpad_1xb/overnumpad_1xb.c => keyboards/unicomp/spacesaver_m_post_2013/overnumpad_1xb/overnumpad_1xb.c +5 -5
@@ 20,19 20,19 @@ void keyboard_post_init_kb(void)
{
// Led pins:
// C12 is the left-most led, normally Num Lock, but on Spacesaver M it's Caps Lock. Configured in info.json
- setPinOutput(C11); // middle led, always off on Spacesaver M
- writePin(C11, 0);
- setPinOutput(C10); // right-most led, normally Scroll Lock, but on Spacesaver M indicates function layer
+ gpio_set_pin_output(C11); // middle led, always off on Spacesaver M
+ gpio_write_pin(C11, 0);
+ gpio_set_pin_output(C10); // right-most led, normally Scroll Lock, but on Spacesaver M indicates function layer
}
layer_state_t layer_state_set_kb(layer_state_t state) {
switch (get_highest_layer(state)) {
case 0:
- writePin(C10, 0);
+ gpio_write_pin(C10, 0);
break;
default:
- writePin(C10, 1);
+ gpio_write_pin(C10, 1);
break;
}
return layer_state_set_user(state);
M keyboards/unicomp/spacesaver_m_pre_2013/overnumpad_1xb/overnumpad_1xb.c => keyboards/unicomp/spacesaver_m_pre_2013/overnumpad_1xb/overnumpad_1xb.c +5 -5
@@ 20,18 20,18 @@ void keyboard_post_init_kb(void)
{
// Led pins:
// C12 is the left-most led, normally Num Lock, but on Spacesaver M it's Caps Lock. Configured in info.json
- setPinOutput(C11); // middle led, always off on Spacesaver M
- writePin(C11, 0);
- setPinOutput(C10); // right-most led, normally Scroll Lock, but on Spacesaver M indicates function layer
+ gpio_set_pin_output(C11); // middle led, always off on Spacesaver M
+ gpio_write_pin(C11, 0);
+ gpio_set_pin_output(C10); // right-most led, normally Scroll Lock, but on Spacesaver M indicates function layer
}
layer_state_t layer_state_set_kb(layer_state_t state) {
switch (get_highest_layer(state)) {
case 0:
- writePin(C10, 0);
+ gpio_write_pin(C10, 0);
break;
default:
- writePin(C10, 1);
+ gpio_write_pin(C10, 1);
break;
}
return layer_state_set_user(state);
M keyboards/viktus/minne_topre/ec.c => keyboards/viktus/minne_topre/ec.c +13 -13
@@ 48,35 48,35 @@ _Static_assert(sizeof(mux_sel_pins) == 3, "invalid MUX_SEL_PINS");
static ec_config_t config;
static uint16_t ec_sw_value[MATRIX_COLS][MATRIX_ROWS];
-static inline void discharge_capacitor(void) { setPinOutput(DISCHARGE_PIN); }
+static inline void discharge_capacitor(void) { gpio_set_pin_output(DISCHARGE_PIN); }
static inline void charge_capacitor(uint8_t col) {
- setPinInput(DISCHARGE_PIN);
- writePinHigh(col_pins[col]);
+ gpio_set_pin_input(DISCHARGE_PIN);
+ gpio_write_pin_high(col_pins[col]);
}
static inline void clear_all_col_pins(void) {
for (int col = 0; col < sizeof(col_pins); col++) {
- writePinLow(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
}
void init_mux_sel(void) {
for (int idx = 0; idx < sizeof(mux_sel_pins); idx++) {
- setPinOutput(mux_sel_pins[idx]);
+ gpio_set_pin_output(mux_sel_pins[idx]);
}
}
void select_mux(uint8_t row) {
uint8_t ch = row_channels[row];
- writePin(mux_sel_pins[0], ch & 1);
- writePin(mux_sel_pins[1], ch & 2);
- writePin(mux_sel_pins[2], ch & 4);
+ gpio_write_pin(mux_sel_pins[0], ch & 1);
+ gpio_write_pin(mux_sel_pins[1], ch & 2);
+ gpio_write_pin(mux_sel_pins[2], ch & 4);
}
void init_col(void) {
for (int idx = 0; idx < sizeof(col_pins); idx++) {
- setPinOutput(col_pins[idx]);
- writePinLow(col_pins[idx]);
+ gpio_set_pin_output(col_pins[idx]);
+ gpio_write_pin_low(col_pins[idx]);
}
}
@@ 85,8 85,8 @@ void ec_init(ec_config_t const* const ec_config) {
config = *ec_config;
// initialize discharge pin as discharge mode
- writePinLow(DISCHARGE_PIN);
- setPinOutput(DISCHARGE_PIN);
+ gpio_write_pin_low(DISCHARGE_PIN);
+ gpio_set_pin_output(DISCHARGE_PIN);
// set analog reference
analogReference(ADC_REF_POWER);
@@ 98,7 98,7 @@ void ec_init(ec_config_t const* const ec_config) {
init_mux_sel();
// set discharge pin to charge mode
- setPinInput(DISCHARGE_PIN);
+ gpio_set_pin_input(DISCHARGE_PIN);
}
uint16_t ec_readkey_raw(uint8_t col, uint8_t row) {
M keyboards/viktus/osav2_numpad_topre/ec.c => keyboards/viktus/osav2_numpad_topre/ec.c +13 -13
@@ 48,35 48,35 @@ _Static_assert(sizeof(mux_sel_pins) == 3, "invalid MUX_SEL_PINS");
static ec_config_t config;
static uint16_t ec_sw_value[MATRIX_COLS][MATRIX_ROWS];
-static inline void discharge_capacitor(void) { setPinOutput(DISCHARGE_PIN); }
+static inline void discharge_capacitor(void) { gpio_set_pin_output(DISCHARGE_PIN); }
static inline void charge_capacitor(uint8_t col) {
- setPinInput(DISCHARGE_PIN);
- writePinHigh(col_pins[col]);
+ gpio_set_pin_input(DISCHARGE_PIN);
+ gpio_write_pin_high(col_pins[col]);
}
static inline void clear_all_col_pins(void) {
for (int col = 0; col < sizeof(col_pins); col++) {
- writePinLow(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
}
void init_mux_sel(void) {
for (int idx = 0; idx < sizeof(mux_sel_pins); idx++) {
- setPinOutput(mux_sel_pins[idx]);
+ gpio_set_pin_output(mux_sel_pins[idx]);
}
}
void select_mux(uint8_t row) {
uint8_t ch = row_channels[row];
- writePin(mux_sel_pins[0], ch & 1);
- writePin(mux_sel_pins[1], ch & 2);
- writePin(mux_sel_pins[2], ch & 4);
+ gpio_write_pin(mux_sel_pins[0], ch & 1);
+ gpio_write_pin(mux_sel_pins[1], ch & 2);
+ gpio_write_pin(mux_sel_pins[2], ch & 4);
}
void init_col(void) {
for (int idx = 0; idx < sizeof(col_pins); idx++) {
- setPinOutput(col_pins[idx]);
- writePinLow(col_pins[idx]);
+ gpio_set_pin_output(col_pins[idx]);
+ gpio_write_pin_low(col_pins[idx]);
}
}
@@ 85,8 85,8 @@ void ec_init(ec_config_t const* const ec_config) {
config = *ec_config;
// initialize discharge pin as discharge mode
- writePinLow(DISCHARGE_PIN);
- setPinOutput(DISCHARGE_PIN);
+ gpio_write_pin_low(DISCHARGE_PIN);
+ gpio_set_pin_output(DISCHARGE_PIN);
// set analog reference
analogReference(ADC_REF_POWER);
@@ 98,7 98,7 @@ void ec_init(ec_config_t const* const ec_config) {
init_mux_sel();
// set discharge pin to charge mode
- setPinInput(DISCHARGE_PIN);
+ gpio_set_pin_input(DISCHARGE_PIN);
}
uint16_t ec_readkey_raw(uint8_t col, uint8_t row) {
M keyboards/viktus/osav2_topre/ec.c => keyboards/viktus/osav2_topre/ec.c +13 -13
@@ 48,35 48,35 @@ _Static_assert(sizeof(mux_sel_pins) == 3, "invalid MUX_SEL_PINS");
static ec_config_t config;
static uint16_t ec_sw_value[MATRIX_COLS][MATRIX_ROWS];
-static inline void discharge_capacitor(void) { setPinOutput(DISCHARGE_PIN); }
+static inline void discharge_capacitor(void) { gpio_set_pin_output(DISCHARGE_PIN); }
static inline void charge_capacitor(uint8_t col) {
- setPinInput(DISCHARGE_PIN);
- writePinHigh(col_pins[col]);
+ gpio_set_pin_input(DISCHARGE_PIN);
+ gpio_write_pin_high(col_pins[col]);
}
static inline void clear_all_col_pins(void) {
for (int col = 0; col < sizeof(col_pins); col++) {
- writePinLow(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
}
void init_mux_sel(void) {
for (int idx = 0; idx < sizeof(mux_sel_pins); idx++) {
- setPinOutput(mux_sel_pins[idx]);
+ gpio_set_pin_output(mux_sel_pins[idx]);
}
}
void select_mux(uint8_t row) {
uint8_t ch = row_channels[row];
- writePin(mux_sel_pins[0], ch & 1);
- writePin(mux_sel_pins[1], ch & 2);
- writePin(mux_sel_pins[2], ch & 4);
+ gpio_write_pin(mux_sel_pins[0], ch & 1);
+ gpio_write_pin(mux_sel_pins[1], ch & 2);
+ gpio_write_pin(mux_sel_pins[2], ch & 4);
}
void init_col(void) {
for (int idx = 0; idx < sizeof(col_pins); idx++) {
- setPinOutput(col_pins[idx]);
- writePinLow(col_pins[idx]);
+ gpio_set_pin_output(col_pins[idx]);
+ gpio_write_pin_low(col_pins[idx]);
}
}
@@ 85,8 85,8 @@ void ec_init(ec_config_t const* const ec_config) {
config = *ec_config;
// initialize discharge pin as discharge mode
- writePinLow(DISCHARGE_PIN);
- setPinOutput(DISCHARGE_PIN);
+ gpio_write_pin_low(DISCHARGE_PIN);
+ gpio_set_pin_output(DISCHARGE_PIN);
// set analog reference
analogReference(ADC_REF_POWER);
@@ 98,7 98,7 @@ void ec_init(ec_config_t const* const ec_config) {
init_mux_sel();
// set discharge pin to charge mode
- setPinInput(DISCHARGE_PIN);
+ gpio_set_pin_input(DISCHARGE_PIN);
}
uint16_t ec_readkey_raw(uint8_t col, uint8_t row) {
M keyboards/viktus/sp111/matrix.c => keyboards/viktus/sp111/matrix.c +6 -6
@@ 33,22 33,22 @@ static const pin_t col_pins[MATRIX_COLS] = {F5, F6, F7, C7, C6, B6, B5, D3,
//_____REGULAR funcs____________________________________________________________
static void select_row(uint8_t row) {
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
-static void unselect_row(uint8_t row) { setPinInputHigh(row_pins[row]); }
+static void unselect_row(uint8_t row) { gpio_set_pin_input_high(row_pins[row]); }
static void unselect_rows(void) {
for (uint8_t x = 0; x < MATRIX_ROWS / 2; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void init_pins(void) {
unselect_rows();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 66,7 66,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_row_value |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
M keyboards/viktus/sp111/sp111.c => keyboards/viktus/sp111/sp111.c +8 -8
@@ 17,16 17,16 @@
void keyboard_pre_init_kb(void) {
// enable built in pullups to avoid timeouts when right hand not connected
- setPinInputHigh(D0);
- setPinInputHigh(D1);
+ gpio_set_pin_input_high(D0);
+ gpio_set_pin_input_high(D1);
keyboard_pre_init_user();
}
void matrix_init_kb(void) {
- setPinOutput(F0);
- setPinOutput(F1);
- setPinOutput(F4);
+ gpio_set_pin_output(F0);
+ gpio_set_pin_output(F1);
+ gpio_set_pin_output(F4);
matrix_init_user();
}
@@ 34,9 34,9 @@ void matrix_init_kb(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if (res) {
- writePin(F0, led_state.num_lock);
- writePin(F1, led_state.caps_lock);
- writePin(F4, led_state.scroll_lock);
+ gpio_write_pin(F0, led_state.num_lock);
+ gpio_write_pin(F1, led_state.caps_lock);
+ gpio_write_pin(F4, led_state.scroll_lock);
}
return res;
}
M keyboards/viktus/sp111_v2/sp111_v2.c => keyboards/viktus/sp111_v2/sp111_v2.c +2 -2
@@ 5,8 5,8 @@
void keyboard_pre_init_kb(void) {
// enable built in pullups to avoid timeouts when right hand not connected
- setPinInputHigh(D0);
- setPinInputHigh(D1);
+ gpio_set_pin_input_high(D0);
+ gpio_set_pin_input_high(D1);
keyboard_pre_init_user();
}
M keyboards/viktus/sp_mini/sp_mini.c => keyboards/viktus/sp_mini/sp_mini.c +2 -2
@@ 18,8 18,8 @@
void keyboard_pre_init_kb(void) {
// enable built in pullups to avoid timeouts when right hand not connected
- setPinInputHigh(D0);
- setPinInputHigh(D1);
+ gpio_set_pin_input_high(D0);
+ gpio_set_pin_input_high(D1);
keyboard_pre_init_user();
}
M keyboards/viktus/styrka_topre/ec.c => keyboards/viktus/styrka_topre/ec.c +13 -13
@@ 49,35 49,35 @@ _Static_assert(sizeof(mux_sel_pins) == 3, "invalid MUX_SEL_PINS");
static ec_config_t config;
static uint16_t ec_sw_value[MATRIX_COLS][MATRIX_ROWS];
-static inline void discharge_capacitor(void) { setPinOutput(DISCHARGE_PIN); }
+static inline void discharge_capacitor(void) { gpio_set_pin_output(DISCHARGE_PIN); }
static inline void charge_capacitor(uint8_t col) {
- setPinInput(DISCHARGE_PIN);
- writePinHigh(col_pins[col]);
+ gpio_set_pin_input(DISCHARGE_PIN);
+ gpio_write_pin_high(col_pins[col]);
}
static inline void clear_all_col_pins(void) {
for (int col = 0; col < sizeof(col_pins); col++) {
- writePinLow(col_pins[col]);
+ gpio_write_pin_low(col_pins[col]);
}
}
void init_mux_sel(void) {
for (int idx = 0; idx < sizeof(mux_sel_pins); idx++) {
- setPinOutput(mux_sel_pins[idx]);
+ gpio_set_pin_output(mux_sel_pins[idx]);
}
}
void select_mux(uint8_t row) {
uint8_t ch = row_channels[row];
- writePin(mux_sel_pins[0], ch & 1);
- writePin(mux_sel_pins[1], ch & 2);
- writePin(mux_sel_pins[2], ch & 4);
+ gpio_write_pin(mux_sel_pins[0], ch & 1);
+ gpio_write_pin(mux_sel_pins[1], ch & 2);
+ gpio_write_pin(mux_sel_pins[2], ch & 4);
}
void init_col(void) {
for (int idx = 0; idx < sizeof(col_pins); idx++) {
- setPinOutput(col_pins[idx]);
- writePinLow(col_pins[idx]);
+ gpio_set_pin_output(col_pins[idx]);
+ gpio_write_pin_low(col_pins[idx]);
}
}
@@ 86,8 86,8 @@ void ec_init(ec_config_t const* const ec_config) {
config = *ec_config;
// initialize discharge pin as discharge mode
- writePinLow(DISCHARGE_PIN);
- setPinOutput(DISCHARGE_PIN);
+ gpio_write_pin_low(DISCHARGE_PIN);
+ gpio_set_pin_output(DISCHARGE_PIN);
// set analog reference
analogReference(ADC_REF_POWER);
@@ 99,7 99,7 @@ void ec_init(ec_config_t const* const ec_config) {
init_mux_sel();
// set discharge pin to charge mode
- setPinInput(DISCHARGE_PIN);
+ gpio_set_pin_input(DISCHARGE_PIN);
}
uint16_t ec_readkey_raw(uint8_t col, uint8_t row) {
M keyboards/vitamins_included/rev2/rev2.c => keyboards/vitamins_included/rev2/rev2.c +3 -3
@@ 7,9 7,9 @@ bool is_keyboard_left(void) {
return !is_keyboard_master();
#elif defined(SPLIT_HAND_PIN)
// Test pin SPLIT_HAND_PIN for High/Low, if low it's right hand
- setPinInputHigh(SPLIT_HAND_PIN);
- bool x = !readPin(SPLIT_HAND_PIN);
- setPinInput(SPLIT_HAND_PIN);
+ gpio_set_pin_input_high(SPLIT_HAND_PIN);
+ bool x = !gpio_read_pin(SPLIT_HAND_PIN);
+ gpio_set_pin_input(SPLIT_HAND_PIN);
return x;
#elif defined(EE_HANDS)
return eeprom_read_byte(EECONFIG_HANDEDNESS);
M keyboards/westfoxtrot/cypher/rev1/rev1.c => keyboards/westfoxtrot/cypher/rev1/rev1.c +4 -4
@@ 18,14 18,14 @@
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- // writePin sets the pin high for 1 and low for 0.
+ // gpio_write_pin sets the pin high for 1 and low for 0.
// In this example the pins are inverted, setting
// it low/0 turns it on, and high/1 turns the LED off.
// This behavior depends on whether the LED is between the pin
// and VCC or the pin and GND.
- writePin(F4, led_state.num_lock);
- writePin(F1, led_state.caps_lock);
- writePin(F5, led_state.scroll_lock);
+ gpio_write_pin(F4, led_state.num_lock);
+ gpio_write_pin(F1, led_state.caps_lock);
+ gpio_write_pin(F5, led_state.scroll_lock);
}
return res;
}
M keyboards/westfoxtrot/cypher/rev5/rev5.c => keyboards/westfoxtrot/cypher/rev5/rev5.c +4 -4
@@ 18,14 18,14 @@
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- // writePin sets the pin high for 1 and low for 0.
+ // gpio_write_pin sets the pin high for 1 and low for 0.
// In this example the pins are inverted, setting
// it low/0 turns it on, and high/1 turns the LED off.
// This behavior depends on whether the LED is between the pin
// and VCC or the pin and GND.
- writePin(D3, led_state.num_lock);
- writePin(D5, led_state.caps_lock);
- writePin(D2, led_state.scroll_lock);
+ gpio_write_pin(D3, led_state.num_lock);
+ gpio_write_pin(D5, led_state.caps_lock);
+ gpio_write_pin(D2, led_state.scroll_lock);
}
return res;
}
M keyboards/westfoxtrot/prophet/prophet.c => keyboards/westfoxtrot/prophet/prophet.c +4 -4
@@ 1,19 1,19 @@
#include "quantum.h"
void keyboard_pre_init_kb (void) {
- setPinOutput(B12);
- setPinOutput(B13);
+ gpio_set_pin_output(B12);
+ gpio_set_pin_output(B13);
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(B13, led_state.caps_lock);
+ gpio_write_pin(B13, led_state.caps_lock);
}
return res;
}
__attribute__((weak)) layer_state_t layer_state_set_user(layer_state_t state) {
- writePin(B12, layer_state_cmp(state, 1));
+ gpio_write_pin(B12, layer_state_cmp(state, 1));
return state;
}
M keyboards/wilba_tech/wt60_xt/wt60_xt.c => keyboards/wilba_tech/wt60_xt/wt60_xt.c +2 -2
@@ 51,14 51,14 @@ void eeconfig_init_kb(void) {
#endif // AUDIO_CLICKY
void keyboard_pre_init_kb(void) {
- setPinOutput(F1);
+ gpio_set_pin_output(F1);
keyboard_pre_init_user();
}
bool led_update_kb(led_t led_state) {
if (led_update_user(led_state)) {
- writePin(F1, led_state.caps_lock);
+ gpio_write_pin(F1, led_state.caps_lock);
}
#ifdef AUDIO_ENABLE
M keyboards/wilba_tech/wt69_a/wt69_a.c => keyboards/wilba_tech/wt69_a/wt69_a.c +2 -2
@@ 17,14 17,14 @@
#include "quantum.h"
void keyboard_pre_init_kb(void) {
- setPinOutput(F1);
+ gpio_set_pin_output(F1);
keyboard_pre_init_user();
}
bool led_update_kb(led_t led_state) {
if (led_update_user(led_state)) {
- writePin(F1, led_state.caps_lock);
+ gpio_write_pin(F1, led_state.caps_lock);
}
return true;
}
M keyboards/wilba_tech/wt70_jb/wt70_jb.c => keyboards/wilba_tech/wt70_jb/wt70_jb.c +2 -2
@@ 18,14 18,14 @@
bool g_first_execution = false;
void keyboard_pre_init_kb(void) {
- setPinOutput(F1);
+ gpio_set_pin_output(F1);
keyboard_pre_init_user();
}
bool led_update_kb(led_t led_state) {
if (led_update_user(led_state)) {
- writePin(F1, led_state.caps_lock);
+ gpio_write_pin(F1, led_state.caps_lock);
}
return true;
}
M keyboards/wolfmarkclub/wm1/wm1.c => keyboards/wolfmarkclub/wm1/wm1.c +6 -6
@@ 6,17 6,17 @@ void bootloader_jump(void) {
}
void matrix_init_kb(void) {
- setPinOutput(B1); // Top Indicator LED
- setPinOutput(B0); // Middle Indicator LED
- setPinOutput(C5); // Bottom Indicator LED
+ gpio_set_pin_output(B1); // Top Indicator LED
+ gpio_set_pin_output(B0); // Middle Indicator LED
+ gpio_set_pin_output(C5); // Bottom Indicator LED
matrix_init_user();
}
bool led_update_kb(led_t led_state) {
if(led_update_user(led_state)) {
- writePin(B1, led_state.caps_lock);
- writePin(B0, led_state.num_lock);
- writePin(C5, led_state.scroll_lock);
+ gpio_write_pin(B1, led_state.caps_lock);
+ gpio_write_pin(B0, led_state.num_lock);
+ gpio_write_pin(C5, led_state.scroll_lock);
}
return true;
}
M keyboards/work_louder/micro/matrix.c => keyboards/work_louder/micro/matrix.c +6 -6
@@ 22,27 22,27 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinLow(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_low(pin);
}
}
static inline void setPinOutput_writeHigh(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinOutput(pin);
- writePinHigh(pin);
+ gpio_set_pin_output(pin);
+ gpio_write_pin_high(pin);
}
}
static inline void setPinInputHigh_atomic(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
- setPinInputHigh(pin);
+ gpio_set_pin_input_high(pin);
}
}
static inline uint8_t readMatrixPin(pin_t pin) {
if (pin != NO_PIN) {
- return readPin(pin);
+ return gpio_read_pin(pin);
} else {
return 1;
}
M keyboards/work_louder/micro/micro.c => keyboards/work_louder/micro/micro.c +12 -12
@@ 49,29 49,29 @@ bool encoder_update_kb(uint8_t index, bool clockwise) {
#endif
void work_louder_micro_led_1_on(void) {
- setPinOutput(WORK_LOUDER_LED_PIN_1);
- writePin(WORK_LOUDER_LED_PIN_1, true);
+ gpio_set_pin_output(WORK_LOUDER_LED_PIN_1);
+ gpio_write_pin(WORK_LOUDER_LED_PIN_1, true);
}
void work_louder_micro_led_2_on(void) {
- setPinOutput(WORK_LOUDER_LED_PIN_2);
- writePin(WORK_LOUDER_LED_PIN_2, true);
+ gpio_set_pin_output(WORK_LOUDER_LED_PIN_2);
+ gpio_write_pin(WORK_LOUDER_LED_PIN_2, true);
}
void work_louder_micro_led_3_on(void) {
- setPinOutput(WORK_LOUDER_LED_PIN_3);
- writePin(WORK_LOUDER_LED_PIN_3, true);
+ gpio_set_pin_output(WORK_LOUDER_LED_PIN_3);
+ gpio_write_pin(WORK_LOUDER_LED_PIN_3, true);
}
void work_louder_micro_led_1_off(void) {
- setPinInput(WORK_LOUDER_LED_PIN_1);
- writePin(WORK_LOUDER_LED_PIN_1, false);
+ gpio_set_pin_input(WORK_LOUDER_LED_PIN_1);
+ gpio_write_pin(WORK_LOUDER_LED_PIN_1, false);
}
void work_louder_micro_led_2_off(void) {
- setPinInput(WORK_LOUDER_LED_PIN_2);
- writePin(WORK_LOUDER_LED_PIN_2, false);
+ gpio_set_pin_input(WORK_LOUDER_LED_PIN_2);
+ gpio_write_pin(WORK_LOUDER_LED_PIN_2, false);
}
void work_louder_micro_led_3_off(void) {
- setPinInput(WORK_LOUDER_LED_PIN_3);
- writePin(WORK_LOUDER_LED_PIN_3, false);
+ gpio_set_pin_input(WORK_LOUDER_LED_PIN_3);
+ gpio_write_pin(WORK_LOUDER_LED_PIN_3, false);
}
void work_louder_micro_led_all_on(void) {
M keyboards/work_louder/work_board/work_board.c => keyboards/work_louder/work_board/work_board.c +6 -6
@@ 111,13 111,13 @@ bool rgb_matrix_indicators_kb(void) {
}
void keyboard_pre_init_kb(void) {
- setPinOutput(B2);
- setPinOutput(B3);
- setPinOutput(B7);
+ gpio_set_pin_output(B2);
+ gpio_set_pin_output(B3);
+ gpio_set_pin_output(B7);
- writePinLow(B2);
- writePinLow(B3);
- writePinLow(B7);
+ gpio_write_pin_low(B2);
+ gpio_write_pin_low(B3);
+ gpio_write_pin_low(B7);
keyboard_pre_init_user();
}
M keyboards/wsk/g4m3ralpha/g4m3ralpha.c => keyboards/wsk/g4m3ralpha/g4m3ralpha.c +9 -9
@@ 18,12 18,12 @@
void matrix_init_kb(void) {
- setPinOutput(D3);
- writePinLow(D3);
- setPinOutput(D2);
- writePinLow(D2);
- setPinOutput(D0);
- writePinLow(D0);
+ gpio_set_pin_output(D3);
+ gpio_write_pin_low(D3);
+ gpio_set_pin_output(D2);
+ gpio_write_pin_low(D2);
+ gpio_set_pin_output(D0);
+ gpio_write_pin_low(D0);
matrix_init_user();
};
@@ 31,9 31,9 @@ void matrix_init_kb(void) {
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(D3, led_state.num_lock);
- writePin(D0, led_state.caps_lock);
- writePin(D2, led_state.scroll_lock);
+ gpio_write_pin(D3, led_state.num_lock);
+ gpio_write_pin(D0, led_state.caps_lock);
+ gpio_write_pin(D2, led_state.scroll_lock);
}
return res;
}
M keyboards/wuque/ikki68/ikki68.c => keyboards/wuque/ikki68/ikki68.c +2 -2
@@ 17,14 17,14 @@
#include "quantum.h"
void matrix_init_kb(void) {
- setPinOutput(C6);
+ gpio_set_pin_output(C6);
matrix_init_user();
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- writePin(C6, !led_state.caps_lock);
+ gpio_write_pin(C6, !led_state.caps_lock);
}
return res;
}
M keyboards/xiudi/xd75/xd75.c => keyboards/xiudi/xd75/xd75.c +9 -9
@@ 29,40 29,40 @@ void matrix_init_kb(void) {
}
void capslock_led_init(void) {
- setPinOutput(XD75_CAPSLOCK_LED);
+ gpio_set_pin_output(XD75_CAPSLOCK_LED);
capslock_led_off();
}
void capslock_led_off(void) {
- writePinHigh(XD75_CAPSLOCK_LED);
+ gpio_write_pin_high(XD75_CAPSLOCK_LED);
}
void capslock_led_on(void) {
- writePinLow(XD75_CAPSLOCK_LED);
+ gpio_write_pin_low(XD75_CAPSLOCK_LED);
}
void gp100_led_init(void) {
- setPinOutput(XD75_GP100_LED);
+ gpio_set_pin_output(XD75_GP100_LED);
gp100_led_off();
}
void gp100_led_off(void) {
- writePinHigh(XD75_GP100_LED);
+ gpio_write_pin_high(XD75_GP100_LED);
}
void gp100_led_on(void) {
- writePinLow(XD75_GP100_LED);
+ gpio_write_pin_low(XD75_GP100_LED);
}
void gp103_led_init(void) {
- setPinOutput(XD75_GP103_LED);
+ gpio_set_pin_output(XD75_GP103_LED);
gp103_led_off();
}
void gp103_led_off(void) {
- writePinLow(XD75_GP103_LED);
+ gpio_write_pin_low(XD75_GP103_LED);
}
void gp103_led_on(void) {
- writePinHigh(XD75_GP103_LED);
+ gpio_write_pin_high(XD75_GP103_LED);
}
M keyboards/ydkb/grape/matrix.c => keyboards/ydkb/grape/matrix.c +2 -2
@@ 38,7 38,7 @@ static void select_row(uint8_t row) {
static void init_pins(void) {
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
@@ 60,7 60,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
- uint8_t pin_state = readPin(col_pins[col_index]);
+ uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (row_shifter << col_index);
M keyboards/ydkb/yd68/yd68.c => keyboards/ydkb/yd68/yd68.c +8 -8
@@ 17,20 17,20 @@
void keyboard_pre_init_kb(void) {
//Backlight LEDs Output Low
- setPinOutput(D6);
- writePinLow(D6);
+ gpio_set_pin_output(D6);
+ gpio_write_pin_low(D6);
//RGB power output low
- setPinOutput(E2);
- writePinLow(E2);
+ gpio_set_pin_output(E2);
+ gpio_write_pin_low(E2);
//Bluetooth power output high
- setPinOutput(B2);
- writePinLow(B2);
+ gpio_set_pin_output(B2);
+ gpio_write_pin_low(B2);
//RGB data output low
- setPinOutput(B3);
- writePinLow(B3);
+ gpio_set_pin_output(B3);
+ gpio_write_pin_low(B3);
keyboard_pre_init_user();
}
M keyboards/yiancardesigns/barleycorn/barleycorn.c => keyboards/yiancardesigns/barleycorn/barleycorn.c +5 -5
@@ 17,21 17,21 @@
void keyboard_pre_init_kb(void) {
// Set our LED pins as output
- setPinOutput(B5);
- setPinOutput(C0);
+ gpio_set_pin_output(B5);
+ gpio_set_pin_output(C0);
keyboard_pre_init_user();
}
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if(res) {
- // writePin sets the pin high for 1 and low for 0.
+ // gpio_write_pin sets the pin high for 1 and low for 0.
// In this example the pins are inverted, setting
// it low/0 turns it on, and high/1 turns the LED off.
// This behavior depends on whether the LED is between the pin
// and VCC or the pin and GND.
- writePin(B5, led_state.caps_lock);
- writePin(C0, led_state.num_lock);
+ gpio_write_pin(B5, led_state.caps_lock);
+ gpio_write_pin(C0, led_state.num_lock);
}
return res;
}
M keyboards/yiancardesigns/barleycorn/matrix.c => keyboards/yiancardesigns/barleycorn/matrix.c +6 -6
@@ 23,17 23,17 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static void unselect_rows(void) {
for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void select_row(uint8_t row) {
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row) {
- setPinInputHigh(row_pins[row]);
+ gpio_set_pin_input_high(row_pins[row]);
}
static void init_pins(void) {
@@ 46,7 46,7 @@ static void init_pins(void) {
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
if ( x < 8 ) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
}
@@ 111,7 111,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
pin_state = port_expander_col_buffer[1] & (1 << 1);
break;
default :
- pin_state = readPin(col_pins[col_index]);
+ pin_state = gpio_read_pin(col_pins[col_index]);
}
// Populate the matrix row with the state of the col pin
M keyboards/yiancardesigns/gingham/matrix.c => keyboards/yiancardesigns/gingham/matrix.c +6 -6
@@ 23,17 23,17 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static void unselect_rows(void) {
for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void select_row(uint8_t row) {
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row) {
- setPinInputHigh(row_pins[row]);
+ gpio_set_pin_input_high(row_pins[row]);
}
static void init_pins(void) {
@@ 46,7 46,7 @@ static void init_pins(void) {
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
if ( (x > 0) && (x < 12) ) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
}
@@ 90,7 90,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
pin_state = pin_state & (1 << 1);
break;
default :
- pin_state = readPin(col_pins[col_index]);
+ pin_state = gpio_read_pin(col_pins[col_index]);
}
// Populate the matrix row with the state of the col pin
M keyboards/yiancardesigns/seigaiha/matrix.c => keyboards/yiancardesigns/seigaiha/matrix.c +6 -6
@@ 23,17 23,17 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static void unselect_rows(void) {
for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
- setPinInputHigh(row_pins[x]);
+ gpio_set_pin_input_high(row_pins[x]);
}
}
static void select_row(uint8_t row) {
- setPinOutput(row_pins[row]);
- writePinLow(row_pins[row]);
+ gpio_set_pin_output(row_pins[row]);
+ gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row) {
- setPinInputHigh(row_pins[row]);
+ gpio_set_pin_input_high(row_pins[row]);
}
static void init_pins(void) {
@@ 46,7 46,7 @@ static void init_pins(void) {
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
if ( x < 10 ) {
- setPinInputHigh(col_pins[x]);
+ gpio_set_pin_input_high(col_pins[x]);
}
}
}
@@ 96,7 96,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
pin_state = port_expander_col_buffer & (1 << 4);
break;
default :
- pin_state = readPin(col_pins[col_index]);
+ pin_state = gpio_read_pin(col_pins[col_index]);
}
// Populate the matrix row with the state of the col pin
M keyboards/ymdk/yd60mq/yd60mq.c => keyboards/ymdk/yd60mq/yd60mq.c +4 -4
@@ 2,20 2,20 @@
__attribute__((weak))
void matrix_init_kb(void){
- setPinOutput(F4);
- writePinHigh(F4);
+ gpio_set_pin_output(F4);
+ gpio_write_pin_high(F4);
}
__attribute__((weak))
bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state);
if (res) {
- // writePin sets the pin high for 1 and low for 0.
+ // gpio_write_pin sets the pin high for 1 and low for 0.
// In this example the pins are inverted, setting
// it low/0 turns it on, and high/1 turns the LED off.
// This behavior depends on whether the LED is between the pin
// and VCC or the pin and GND.
- writePin(F4, !led_state.caps_lock);
+ gpio_write_pin(F4, !led_state.caps_lock);
}
return res;
}
M keyboards/zsa/moonlander/matrix.c => keyboards/zsa/moonlander/matrix.c +32 -32
@@ 71,21 71,21 @@ void matrix_init_custom(void) {
dprintf("matrix init\n");
// debug_matrix = true;
// outputs
- setPinOutput(B10);
- setPinOutput(B11);
- setPinOutput(B12);
- setPinOutput(B13);
- setPinOutput(B14);
- setPinOutput(B15);
+ gpio_set_pin_output(B10);
+ gpio_set_pin_output(B11);
+ gpio_set_pin_output(B12);
+ gpio_set_pin_output(B13);
+ gpio_set_pin_output(B14);
+ gpio_set_pin_output(B15);
// inputs
- setPinInputLow(A0);
- setPinInputLow(A1);
- setPinInputLow(A2);
- setPinInputLow(A3);
- setPinInputLow(A6);
- setPinInputLow(A7);
- setPinInputLow(B0);
+ gpio_set_pin_input_low(A0);
+ gpio_set_pin_input_low(A1);
+ gpio_set_pin_input_low(A2);
+ gpio_set_pin_input_low(A3);
+ gpio_set_pin_input_low(A6);
+ gpio_set_pin_input_low(A7);
+ gpio_set_pin_input_low(B0);
mcp23018_init();
}
@@ 117,12 117,12 @@ bool matrix_scan_custom(matrix_row_t current_matrix[]) {
for (uint8_t row = 0; row <= ROWS_PER_HAND; row++) {
// strobe row
switch (row) {
- case 0: writePinHigh(B10); break;
- case 1: writePinHigh(B11); break;
- case 2: writePinHigh(B12); break;
- case 3: writePinHigh(B13); break;
- case 4: writePinHigh(B14); break;
- case 5: writePinHigh(B15); break;
+ case 0: gpio_write_pin_high(B10); break;
+ case 1: gpio_write_pin_high(B11); break;
+ case 2: gpio_write_pin_high(B12); break;
+ case 3: gpio_write_pin_high(B13); break;
+ case 4: gpio_write_pin_high(B14); break;
+ case 5: gpio_write_pin_high(B15); break;
case 6: break; // Left hand has 6 rows
}
@@ 170,22 170,22 @@ bool matrix_scan_custom(matrix_row_t current_matrix[]) {
}
// read col data
data = (
- (readPin(A0) << 0 ) |
- (readPin(A1) << 1 ) |
- (readPin(A2) << 2 ) |
- (readPin(A3) << 3 ) |
- (readPin(A6) << 4 ) |
- (readPin(A7) << 5 ) |
- (readPin(B0) << 6 )
+ (gpio_read_pin(A0) << 0 ) |
+ (gpio_read_pin(A1) << 1 ) |
+ (gpio_read_pin(A2) << 2 ) |
+ (gpio_read_pin(A3) << 3 ) |
+ (gpio_read_pin(A6) << 4 ) |
+ (gpio_read_pin(A7) << 5 ) |
+ (gpio_read_pin(B0) << 6 )
);
// unstrobe row
switch (row) {
- case 0: writePinLow(B10); break;
- case 1: writePinLow(B11); break;
- case 2: writePinLow(B12); break;
- case 3: writePinLow(B13); break;
- case 4: writePinLow(B14); break;
- case 5: writePinLow(B15); break;
+ case 0: gpio_write_pin_low(B10); break;
+ case 1: gpio_write_pin_low(B11); break;
+ case 2: gpio_write_pin_low(B12); break;
+ case 3: gpio_write_pin_low(B13); break;
+ case 4: gpio_write_pin_low(B14); break;
+ case 5: gpio_write_pin_low(B15); break;
case 6: break;
}
M keyboards/zsa/moonlander/moonlander.c => keyboards/zsa/moonlander/moonlander.c +6 -6
@@ 95,13 95,13 @@ static THD_FUNCTION(LEDThread, arg) {
}
void keyboard_pre_init_kb(void) {
- setPinOutput(B5);
- setPinOutput(B4);
- setPinOutput(B3);
+ gpio_set_pin_output(B5);
+ gpio_set_pin_output(B4);
+ gpio_set_pin_output(B3);
- writePinLow(B5);
- writePinLow(B4);
- writePinLow(B3);
+ gpio_write_pin_low(B5);
+ gpio_write_pin_low(B4);
+ gpio_write_pin_low(B3);
chThdCreateStatic(waLEDThread, sizeof(waLEDThread), NORMALPRIO - 16, LEDThread, NULL);
M keyboards/zsa/moonlander/moonlander.h => keyboards/zsa/moonlander/moonlander.h +3 -3
@@ 26,9 26,9 @@ extern bool mcp23018_leds[];
#define MCP23018_DEFAULT_ADDRESS 0b0100000
-#define ML_LED_1(status) writePin(B5, (bool)status)
-#define ML_LED_2(status) writePin(B4, (bool)status)
-#define ML_LED_3(status) writePin(B3, (bool)status)
+#define ML_LED_1(status) gpio_write_pin(B5, (bool)status)
+#define ML_LED_2(status) gpio_write_pin(B4, (bool)status)
+#define ML_LED_3(status) gpio_write_pin(B3, (bool)status)
#define ML_LED_4(status) mcp23018_leds[0] = (bool)status
#define ML_LED_5(status) mcp23018_leds[1] = (bool)status