altos: Eliminate 'pin' field from GPIO functions
authorKeith Packard <keithp@keithp.com>
Tue, 11 Sep 2018 17:40:24 +0000 (10:40 -0700)
committerKeith Packard <keithp@keithp.com>
Sat, 13 Oct 2018 15:23:25 +0000 (08:23 -0700)
This was used with the 8051 bit-addressing mode to provide
single-instruction access to GPIO pins.

Signed-off-by: Keith Packard <keithp@keithp.com>
38 files changed:
src/attiny/ao_arch_funcs.h
src/avr/ao_arch_funcs.h
src/drivers/ao_btm.c
src/drivers/ao_button.c
src/drivers/ao_cc1120.c
src/drivers/ao_cc1200.c
src/drivers/ao_companion.c
src/drivers/ao_mma655x.c
src/drivers/ao_ms5607.c
src/drivers/ao_pad.c
src/drivers/ao_ps2.c
src/drivers/ao_rn4678.c
src/drivers/ao_sdcard.c
src/drivers/ao_trng_send.c
src/drivers/ao_watchdog.c
src/easymega-v1.0/ao_pins.h
src/easymini-v1.0/ao_pins.h
src/easymini-v2.0/ao_pins.h
src/kernel/ao_ignite.c
src/kernel/ao_pyro.c
src/kernel/ao_tracker.c
src/lpc/ao_arch_funcs.h
src/lpc/ao_boot_pin.c
src/lpc/ao_usb_lpc.c
src/stm/ao_arch_funcs.h
src/stm/ao_led.c
src/stm/ao_serial_stm.c
src/stmf0/ao_arch_funcs.h
src/stmf0/ao_beep_stm.c
src/teleballoon-v2.0/ao_pins.h
src/telemega-v0.1/ao_pins.h
src/telemega-v1.0/ao_pins.h
src/telemega-v2.0/ao_pins.h
src/telemega-v3.0/ao_pins.h
src/telemetrum-v2.0/ao_pins.h
src/telemetrum-v3.0/ao_pins.h
src/telemini-v3.0/ao_pins.h
src/telemini-v3.0/ao_telemini.c

index 3590115..69b259d 100644 (file)
                (reg) |= (mask);                \
        } while (0)
 
-#define ao_spi_get_bit(reg,bit,pin,bus,speed) ao_spi_get_mask(reg,(1<<(bit)),bus,speed)
+#define ao_spi_get_bit(reg,bit,bus,speed) ao_spi_get_mask(reg,(1<<(bit)),bus,speed)
 
-#define ao_spi_put_bit(reg,bit,pin,bus) ao_spi_put_mask(reg,(1<<(bit)),bus)
+#define ao_spi_put_bit(reg,bit,bus) ao_spi_put_mask(reg,(1<<(bit)),bus)
 
 #define ao_gpio_token_paster(x,y)              x ## y
 #define ao_gpio_token_evaluator(x,y)   ao_gpio_token_paster(x,y)
 
-#define ao_gpio_set(port, bit, pin, v) do {    \
+#define ao_gpio_set(port, bit, v) do { \
                if (v)                          \
                        PORTB |= (1 << bit);    \
                else                            \
                        PORTB &= ~(1 << bit);   \
        } while (0)
 
-#define ao_gpio_get(port, bit, pin)    ((PORTB >> (bit)) & 1)
+#define ao_gpio_get(port, bit) ((PORTB >> (bit)) & 1)
 
 /*
  * The SPI mutex must be held to call either of these
@@ -50,8 +50,8 @@
  * from chip select low to chip select high
  */
 
-#define ao_enable_output(port, bit, pin, v) do {                       \
-               ao_gpio_set(port, bit, pin, v);                         \
+#define ao_enable_output(port, bit, v) do {                    \
+               ao_gpio_set(port, bit, v);                              \
                ao_gpio_token_evaluator(DDR,port) |= (1 << bit);        \
        } while (0)
 
index dc24866..f2a58af 100644 (file)
@@ -32,12 +32,12 @@ extern uint8_t      ao_spi_mutex;
                ao_mutex_put(&ao_spi_mutex);    \
        } while (0)
 
-#define ao_spi_get_bit(reg,bit,pin,bus,speed) do {     \
+#define ao_spi_get_bit(reg,bit,bus,speed) do { \
                ao_mutex_get(&ao_spi_mutex);    \
                (pin) = 0;                      \
        } while (0)
 
-#define ao_spi_put_bit(reg,bit,pin,bus) do {   \
+#define ao_spi_put_bit(reg,bit,bus) do {       \
                (pin) = 1;                      \
                ao_mutex_put(&ao_spi_mutex);    \
        } while (0)
@@ -46,7 +46,7 @@ extern uint8_t        ao_spi_mutex;
 #define ao_gpio_token_paster(x,y)              x ## y
 #define ao_gpio_token_evaluator(x,y)   ao_gpio_token_paster(x,y)
 
-#define ao_gpio_set(port, bit, pin, v) do {                            \
+#define ao_gpio_set(port, bit, v) do {                         \
                if (v)                                                  \
                        (ao_gpio_token_evaluator(PORT,port)) |= (1 << bit); \
                else                                                    \
@@ -59,8 +59,8 @@ extern uint8_t        ao_spi_mutex;
  * from chip select low to chip select high
  */
 
-#define ao_enable_output(port, bit, pin, v) do {                       \
-               ao_gpio_set(port, bit, pin, v);                         \
+#define ao_enable_output(port, bit, v) do {                    \
+               ao_gpio_set(port, bit, v);                              \
                ao_gpio_token_evaluator(DDR,port) |= (1 << bit);        \
        } while (0)
 
index 2930d00..04bf413 100644 (file)
@@ -347,7 +347,7 @@ ao_btm_check_link()
                );
 #else
        ao_arch_block_interrupts();
-       if (ao_gpio_get(AO_BTM_INT_PORT, AO_BTM_INT_PIN, AO_BTM_INT) == 0) {
+       if (ao_gpio_get(AO_BTM_INT_PORT, AO_BTM_INT_PIN) == 0) {
                ao_btm_connected = 1;
        } else {
                ao_btm_connected = 0;
@@ -455,7 +455,7 @@ ao_btm_init (void)
        ao_serial_btm_set_speed(AO_SERIAL_SPEED_19200);
 
 #ifdef AO_BTM_RESET_PORT
-       ao_enable_output(AO_BTM_RESET_PORT,AO_BTM_RESET_PIN,AO_BTM_RESET,0);
+       ao_enable_output(AO_BTM_RESET_PORT,AO_BTM_RESET_PIN,0);
 #endif
 
 #ifdef AO_BTM_INT_PORT
index f6a9676..c8103e8 100644 (file)
@@ -37,7 +37,6 @@ static struct ao_button_state ao_button_state[AO_BUTTON_COUNT];
 
 #define port(q)        AO_BUTTON_ ## q ## _PORT
 #define bit(q) AO_BUTTON_ ## q
-#define pin(q) AO_BUTTON_ ## q ## _PIN
 
 #ifndef AO_BUTTON_INVERTED
 #define AO_BUTTON_INVERTED     1
@@ -45,9 +44,9 @@ static struct ao_button_state ao_button_state[AO_BUTTON_COUNT];
 
 #if AO_BUTTON_INVERTED
 /* pins are inverted */
-#define ao_button_value(b)     !ao_gpio_get(port(b), bit(b), pin(b))
+#define ao_button_value(b)     !ao_gpio_get(port(b), bit(b))
 #else
-#define ao_button_value(b)     ao_gpio_get(port(b), bit(b), pin(b))
+#define ao_button_value(b)     ao_gpio_get(port(b), bit(b))
 #endif
 
 static uint8_t
index aea0a3f..b1a1377 100644 (file)
@@ -208,7 +208,7 @@ ao_radio_fifo_write_fixed(uint8_t data, uint8_t len)
 static uint8_t
 ao_radio_int_pin(void)
 {
-       return ao_gpio_get(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN, AO_CC1120_INT);
+       return ao_gpio_get(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN);
 }
 
 #if CC1120_DEBUG
index 45f5711..105e0d5 100644 (file)
@@ -192,7 +192,7 @@ ao_radio_fifo_write_fixed(uint8_t data, uint8_t len)
 static uint8_t
 ao_radio_int_pin(void)
 {
-       return ao_gpio_get(AO_CC1200_INT_PORT, AO_CC1200_INT_PIN, AO_CC1200_INT);
+       return ao_gpio_get(AO_CC1200_INT_PORT, AO_CC1200_INT_PIN);
 }
 
 static uint8_t
index 3967090..44868fb 100644 (file)
@@ -31,7 +31,6 @@
 #define COMPANION_SELECT()     do {                    \
                ao_spi_get_bit(AO_COMPANION_CS_PORT,    \
                               AO_COMPANION_CS_PIN,     \
-                              AO_COMPANION_CS,         \
                               AO_COMPANION_SPI_BUS,    \
                               AO_SPI_SPEED_200kHz);    \
        } while (0)
@@ -39,7 +38,6 @@
 #define COMPANION_DESELECT()   do {                    \
                ao_spi_put_bit(AO_COMPANION_CS_PORT,    \
                               AO_COMPANION_CS_PIN,     \
-                              AO_COMPANION_CS,         \
                               AO_COMPANION_SPI_BUS);   \
        } while (0)
 
@@ -144,7 +142,7 @@ static struct ao_task ao_companion_task;
 void
 ao_companion_init(void)
 {
-       ao_enable_output(AO_COMPANION_CS_PORT, AO_COMPANION_CS_PIN, AO_COMPANION_CS, 1);
+       ao_enable_output(AO_COMPANION_CS_PORT, AO_COMPANION_CS_PIN, 1);
        ao_cmd_register(&ao_companion_cmds[0]);
        ao_add_task(&ao_companion_task, ao_companion, "companion");
 }
index a48c1db..e8eeea6 100644 (file)
@@ -34,7 +34,6 @@ static void
 ao_mma655x_start(void) {
        ao_spi_get_bit(AO_MMA655X_CS_PORT,
                       AO_MMA655X_CS_PIN,
-                      AO_MMA655X_CS,
                       AO_MMA655X_SPI_INDEX,
                       AO_SPI_SPEED_FAST);
 }
@@ -43,19 +42,18 @@ static void
 ao_mma655x_stop(void) {
        ao_spi_put_bit(AO_MMA655X_CS_PORT,
                       AO_MMA655X_CS_PIN,
-                      AO_MMA655X_CS,
                       AO_MMA655X_SPI_INDEX);
 }
 
 static void
 ao_mma655x_restart(void) {
        uint8_t i;
-       ao_gpio_set(AO_MMA655X_CS_PORT, AO_MMA655X_CS_PIN, AO_MMA655X_CS, 1);
+       ao_gpio_set(AO_MMA655X_CS_PORT, AO_MMA655X_CS_PIN, 1);
 
        /* Emperical testing on STM32L151 at 32MHz for this delay amount */
        for (i = 0; i < 10; i++)
                ao_arch_nop();
-       ao_gpio_set(AO_MMA655X_CS_PORT, AO_MMA655X_CS_PIN, AO_MMA655X_CS, 0);
+       ao_gpio_set(AO_MMA655X_CS_PORT, AO_MMA655X_CS_PIN, 0);
 }
 
 static uint8_t
index a468fee..a00d54c 100644 (file)
@@ -31,12 +31,12 @@ static uint8_t              ms5607_configured;
 
 static void
 ao_ms5607_start(void) {
-       ao_spi_get_bit(AO_MS5607_CS_PORT, AO_MS5607_CS_PIN, AO_MS5607_CS, AO_MS5607_SPI_INDEX, AO_MS5607_SPI_SPEED);
+       ao_spi_get_bit(AO_MS5607_CS_PORT, AO_MS5607_CS_PIN, AO_MS5607_SPI_INDEX, AO_MS5607_SPI_SPEED);
 }
 
 static void
 ao_ms5607_stop(void) {
-       ao_spi_put_bit(AO_MS5607_CS_PORT, AO_MS5607_CS_PIN, AO_MS5607_CS, AO_MS5607_SPI_INDEX);
+       ao_spi_put_bit(AO_MS5607_CS_PORT, AO_MS5607_CS_PIN, AO_MS5607_SPI_INDEX);
 }
 
 static void
@@ -164,7 +164,7 @@ ao_ms5607_get_sample(uint8_t cmd) {
        ao_spi_put(AO_MS5607_SPI_INDEX);
 #endif
        ao_arch_block_interrupts();
-       while (!ao_gpio_get(AO_MS5607_MISO_PORT, AO_MS5607_MISO_PIN, AO_MS5607_MISO) &&
+       while (!ao_gpio_get(AO_MS5607_MISO_PORT, AO_MS5607_MISO_PIN) &&
               !ao_ms5607_done)
                ao_sleep((void *) &ao_ms5607_done);
        ao_arch_release_interrupts();
index c08798a..85691f5 100644 (file)
@@ -50,7 +50,7 @@ static void
 ao_siren(uint8_t v)
 {
 #ifdef AO_SIREN
-       ao_gpio_set(AO_SIREN_PORT, AO_SIREN_PIN, AO_SIREN, v);
+       ao_gpio_set(AO_SIREN_PORT, AO_SIREN_PIN, v);
 #else
 #if HAS_BEEP
        ao_beep(v ? AO_BEEP_MID : 0);
@@ -64,7 +64,7 @@ static void
 ao_strobe(uint8_t v)
 {
 #ifdef AO_STROBE
-       ao_gpio_set(AO_STROBE_PORT, AO_STROBE_PIN, AO_STROBE, v);
+       ao_gpio_set(AO_STROBE_PORT, AO_STROBE_PIN, v);
 #else
        (void) v;
 #endif
@@ -589,34 +589,34 @@ ao_pad_init(void)
        }
 #endif
 #if AO_PAD_NUM > 0
-       ao_enable_output(AO_PAD_0_PORT, AO_PAD_PIN_0, AO_PAD_0, 0);
+       ao_enable_output(AO_PAD_0_PORT, AO_PAD_PIN_0, 0);
 #endif
 #if AO_PAD_NUM > 1
-       ao_enable_output(AO_PAD_1_PORT, AO_PAD_PIN_1, AO_PAD_1, 0);
+       ao_enable_output(AO_PAD_1_PORT, AO_PAD_PIN_1, 0);
 #endif
 #if AO_PAD_NUM > 2
-       ao_enable_output(AO_PAD_2_PORT, AO_PAD_PIN_2, AO_PAD_2, 0);
+       ao_enable_output(AO_PAD_2_PORT, AO_PAD_PIN_2, 0);
 #endif
 #if AO_PAD_NUM > 3
-       ao_enable_output(AO_PAD_3_PORT, AO_PAD_PIN_3, AO_PAD_3, 0);
+       ao_enable_output(AO_PAD_3_PORT, AO_PAD_PIN_3, 0);
 #endif
 #if AO_PAD_NUM > 4
-       ao_enable_output(AO_PAD_4_PORT, AO_PAD_PIN_4, AO_PAD_4, 0);
+       ao_enable_output(AO_PAD_4_PORT, AO_PAD_PIN_4, 0);
 #endif
 #if AO_PAD_NUM > 5
-       ao_enable_output(AO_PAD_5_PORT, AO_PAD_PIN_5, AO_PAD_5, 0);
+       ao_enable_output(AO_PAD_5_PORT, AO_PAD_PIN_5, 0);
 #endif
 #if AO_PAD_NUM > 5
-       ao_enable_output(AO_PAD_6_PORT, AO_PAD_PIN_6, AO_PAD_6, 0);
+       ao_enable_output(AO_PAD_6_PORT, AO_PAD_PIN_6, 0);
 #endif
 #if AO_PAD_NUM > 7
-       ao_enable_output(AO_PAD_7_PORT, AO_PAD_PIN_7, AO_PAD_7, 0);
+       ao_enable_output(AO_PAD_7_PORT, AO_PAD_PIN_7, 0);
 #endif
 #ifdef AO_STROBE
-       ao_enable_output(AO_STROBE_PORT, AO_STROBE_PIN, AO_STROBE, 0);
+       ao_enable_output(AO_STROBE_PORT, AO_STROBE_PIN, 0);
 #endif
 #ifdef AO_SIREN
-       ao_enable_output(AO_SIREN_PORT, AO_SIREN_PIN, AO_SIREN, 0);
+       ao_enable_output(AO_SIREN_PORT, AO_SIREN_PIN, 0);
 #endif
        ao_cmd_register(&ao_pad_cmds[0]);
        ao_add_task(&ao_pad_task, ao_pad, "pad listener");
index 29eecea..c7520b3 100644 (file)
@@ -91,11 +91,11 @@ ao_ps2_put(uint8_t c)
        ao_arch_release_interrupts();
 
        /* pull the clock pin down */
-       ao_enable_output(AO_PS2_CLOCK_PORT, AO_PS2_CLOCK_BIT, AO_PS2_CLOCK_PIN, 0);
+       ao_enable_output(AO_PS2_CLOCK_PORT, AO_PS2_CLOCK_BIT, 0);
        ao_delay(0);
 
        /* pull the data pin down for the start bit */
-       ao_enable_output(AO_PS2_DATA_PORT, AO_PS2_DATA_BIT, AO_PS2_DATA_PIN, 0);
+       ao_enable_output(AO_PS2_DATA_PORT, AO_PS2_DATA_BIT, 0);
        ao_delay(0);
 
        /* switch back to input mode for the interrupt to work */
@@ -369,7 +369,7 @@ ao_ps2_isr(void)
        uint8_t bit;
 
        if (ao_ps2_tx_count) {
-               ao_gpio_set(AO_PS2_DATA_PORT, AO_PS2_DATA_BIT, AO_PS2_DATA_PIN, ao_ps2_tx&1);
+               ao_gpio_set(AO_PS2_DATA_PORT, AO_PS2_DATA_BIT, ao_ps2_tx&1);
                ao_ps2_tx >>= 1;
                ao_ps2_tx_count--;
                if (!ao_ps2_tx_count) {
@@ -383,7 +383,7 @@ ao_ps2_isr(void)
                ao_ps2_count = 0;
        ao_ps2_tick = ao_tick_count;
 
-       bit = ao_gpio_get(AO_PS2_DATA_PORT, AO_PS2_DATA_BIT, AO_PS2_DATA_PIN);
+       bit = ao_gpio_get(AO_PS2_DATA_PORT, AO_PS2_DATA_BIT);
        if (ao_ps2_count == 0) {
                /* check for start bit, ignore if not zero */
                if (bit)
index 98dc35b..4ace4b7 100644 (file)
@@ -335,7 +335,7 @@ ao_rn_get_name(char *name, int len)
 static void
 ao_rn_check_link(void)
 {
-       ao_rn_connected = 1 - ao_gpio_get(AO_RN_CONNECTED_PORT, AO_RN_CONNECTED_PIN, foo);
+       ao_rn_connected = 1 - ao_gpio_get(AO_RN_CONNECTED_PORT, AO_RN_CONNECTED_PIN);
 }
 
 static void
@@ -384,17 +384,17 @@ ao_rn(void)
        ao_rn_dbg("ao_rn top\n");
 
        /* Select CMD mode after the device gets out of reset */
-       ao_gpio_set(AO_RN_CMD_PORT, AO_RN_CMD_PIN, foo, AO_RN_CMD_CMD);
+       ao_gpio_set(AO_RN_CMD_PORT, AO_RN_CMD_PIN, AO_RN_CMD_CMD);
 
        for (i = 0; i < 3; i++) {
                ao_rn_dbg("reset device\n");
 
-               ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, foo, 0);
+               ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, 0);
                ao_delay(AO_MS_TO_TICKS(100));
 
                /* Reboot the RN4678 and wait for it to start talking */
                ao_rn_drain();
-               ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, foo, 1);
+               ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, 1);
                status = ao_rn_wait_for(AO_RN_REBOOT_TIMEOUT, AO_RN_REBOOT_MSG);
                if (status != AO_RN_OK) {
                        ao_rn_dbg("reboot failed\n");
@@ -468,7 +468,7 @@ ao_rn(void)
        if (status != AO_RN_OK)
                ao_bt_panic(4);
 
-       ao_gpio_set(AO_RN_CMD_PORT, AO_RN_CMD_PIN, foo, AO_RN_CMD_DATA);
+       ao_gpio_set(AO_RN_CMD_PORT, AO_RN_CMD_PIN, AO_RN_CMD_DATA);
 
        /* Wait for the hardware to finish sending messages, then clear the queue */
        ao_delay(AO_MS_TO_TICKS(200));
@@ -530,16 +530,16 @@ ao_rn_factory(void)
         */
 
        /* Select our target output pin */
-       ao_enable_output(AO_RN_P3_1_PORT, AO_RN_P3_1_PIN, foo, v);
+       ao_enable_output(AO_RN_P3_1_PORT, AO_RN_P3_1_PIN, v);
 
        /* Turn off the BT device using the SW_BTN pin */
        printf("Power down BT\n"); flush();
-       ao_gpio_set(AO_RN_SW_BTN_PORT, AO_RN_SW_BTN_PIN, foo, 0);
+       ao_gpio_set(AO_RN_SW_BTN_PORT, AO_RN_SW_BTN_PIN, 0);
        ao_delay(AO_MS_TO_TICKS(1000));
 
        /* And turn it back on */
        printf("Power up BT\n"); flush();
-       ao_gpio_set(AO_RN_SW_BTN_PORT, AO_RN_SW_BTN_PIN, foo, 1);
+       ao_gpio_set(AO_RN_SW_BTN_PORT, AO_RN_SW_BTN_PIN, 1);
 
        /* Right after power on, poke P3_1 five times to force a
         * factory reset
@@ -547,7 +547,7 @@ ao_rn_factory(void)
        for (i = 0; i < 20; i++) {
                v = 1-v;
                ao_delay(AO_MS_TO_TICKS(50));
-               ao_gpio_set(AO_RN_P3_1_PORT, AO_RN_P3_1_PIN, foo, v);
+               ao_gpio_set(AO_RN_P3_1_PORT, AO_RN_P3_1_PIN, v);
                ao_led_toggle(AO_BT_LED);
        }
 
@@ -556,9 +556,9 @@ ao_rn_factory(void)
 
        printf("Reboot BT\n"); flush();
        ao_delay(AO_MS_TO_TICKS(100));
-       ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, foo, 0);
+       ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, 0);
        ao_delay(AO_MS_TO_TICKS(100));
-       ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, foo, 1);
+       ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, 1);
 }
 
 #if AO_RN_DEBUG
@@ -588,13 +588,13 @@ ao_rn4678_init(void)
        ao_serial_rn_set_speed(AO_SERIAL_SPEED_115200);
 
        /* Reset line */
-       ao_enable_output(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, foo, 0);
+       ao_enable_output(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, 0);
 
        /* SW_BTN */
-       ao_enable_output(AO_RN_SW_BTN_PORT, AO_RN_SW_BTN_PIN, foo, 1);
+       ao_enable_output(AO_RN_SW_BTN_PORT, AO_RN_SW_BTN_PIN, 1);
 
        /* P3_7 command/data selector */
-       ao_enable_output(AO_RN_CMD_PORT, AO_RN_CMD_PIN, foo, AO_RN_CMD_CMD);
+       ao_enable_output(AO_RN_CMD_PORT, AO_RN_CMD_PIN, AO_RN_CMD_CMD);
 
        ao_enable_input(AO_RN_CONNECTED_PORT, AO_RN_CONNECTED_PIN, AO_EXTI_MODE_PULL_NONE);
        ao_exti_setup(AO_RN_CONNECTED_PORT, AO_RN_CONNECTED_PIN,
index 4545400..9d36c39 100644 (file)
@@ -34,8 +34,8 @@ extern uint8_t ao_radio_mutex;
 #define ao_sdcard_send_fixed(d,l)      ao_spi_send_fixed((d), (l), AO_SDCARD_SPI_BUS)
 #define ao_sdcard_send(d,l)            ao_spi_send((d), (l), AO_SDCARD_SPI_BUS)
 #define ao_sdcard_recv(d,l)            ao_spi_recv((d), (l), AO_SDCARD_SPI_BUS)
-#define ao_sdcard_select()             ao_gpio_set(AO_SDCARD_SPI_CS_PORT,AO_SDCARD_SPI_CS_PIN,AO_SDCARD_SPI_CS,0)
-#define ao_sdcard_deselect()           ao_gpio_set(AO_SDCARD_SPI_CS_PORT,AO_SDCARD_SPI_CS_PIN,AO_SDCARD_SPI_CS,1)
+#define ao_sdcard_select()             ao_gpio_set(AO_SDCARD_SPI_CS_PORT,AO_SDCARD_SPI_CS_PIN,0)
+#define ao_sdcard_deselect()           ao_gpio_set(AO_SDCARD_SPI_CS_PORT,AO_SDCARD_SPI_CS_PIN,1)
 
 /* Include SD card commands */
 #ifndef SDCARD_DEBUG
index e8df4ce..adeed59 100644 (file)
@@ -140,7 +140,7 @@ ao_trng_send(void)
        usb_buf_id = ao_usb_alloc(buffer);
 
 #ifdef AO_TRNG_ENABLE_PORT
-       ao_gpio_set(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, AO_TRNG_ENABLE_PIN, 1);
+       ao_gpio_set(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, 1);
 #endif
        trng_power_time = ao_time();
 
@@ -211,7 +211,7 @@ static void ao_trng_suspend(void *arg)
 {
        (void) arg;
 #ifdef AO_TRNG_ENABLE_PORT
-       ao_gpio_set(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, AO_TRNG_ENABLE_PIN, 0);
+       ao_gpio_set(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, 0);
 #endif
        trng_running = false;
 }
@@ -220,7 +220,7 @@ static void ao_trng_resume(void *arg)
 {
        (void) arg;
 #ifdef AO_TRNG_ENABLE_PORT
-       ao_gpio_set(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, AO_TRNG_ENABLE_PIN, 1);
+       ao_gpio_set(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, 1);
 #endif
        trng_power_time = ao_time();
 }
@@ -236,7 +236,7 @@ void
 ao_trng_send_init(void)
 {
 #ifdef AO_TRNG_ENABLE_PORT
-       ao_enable_output(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, AO_TRNG_ENABLE_PIN, 0);
+       ao_enable_output(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, 0);
        ao_power_register(&ao_trng_power);
 #endif
        ao_enable_input(AO_RAW_PORT, AO_RAW_BIT, AO_EXTI_MODE_PULL_UP);
index 4d774c3..612496b 100644 (file)
@@ -28,9 +28,9 @@ ao_watchdog(void)
                        ao_sleep(&ao_watchdog_enabled);
                while (ao_watchdog_enabled) {
                        ao_delay(AO_WATCHDOG_INTERVAL);
-                       ao_gpio_set(AO_WATCHDOG_PORT, AO_WATCHDOG_BIT, AO_WATCHDOG_PIN, 1);
+                       ao_gpio_set(AO_WATCHDOG_PORT, AO_WATCHDOG_BIT, 1);
                        ao_delay(1);
-                       ao_gpio_set(AO_WATCHDOG_PORT, AO_WATCHDOG_BIT, AO_WATCHDOG_PIN, 0);
+                       ao_gpio_set(AO_WATCHDOG_PORT, AO_WATCHDOG_BIT, 0);
                }
        }
 }
@@ -56,7 +56,7 @@ static struct ao_task watchdog_task;
 void
 ao_watchdog_init(void)
 {
-       ao_enable_output(AO_WATCHDOG_PORT, AO_WATCHDOG_BIT, AO_WATCHDOG, 0);
+       ao_enable_output(AO_WATCHDOG_PORT, AO_WATCHDOG_BIT, 0);
        ao_cmd_register(&ao_watchdog_cmds[0]);
        ao_add_task(&watchdog_task, ao_watchdog, "watchdog");
 }
index b801647..e7382e4 100644 (file)
 /* Number of general purpose pyro channels available */
 #define AO_PYRO_NUM    4
 
-#define AO_IGNITER_SET_DROGUE(v)       stm_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v)
-#define AO_IGNITER_SET_MAIN(v)         stm_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v)
-
 /*
  * ADC
  */
index 45c6891..201b913 100644 (file)
@@ -123,11 +123,9 @@ struct ao_adc {
 
 #define AO_IGNITER_DROGUE_PORT 0
 #define AO_IGNITER_DROGUE_PIN  2
-#define AO_IGNITER_SET_DROGUE(v)       ao_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, AO_IGNITER_DROGUE, v)
 
 #define AO_IGNITER_MAIN_PORT   0
 #define AO_IGNITER_MAIN_PIN    3
-#define AO_IGNITER_SET_MAIN(v)         ao_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, AO_IGNITER_MAIN, v)
 
 #define AO_SENSE_DROGUE(p)     ((p)->adc.sense_a)
 #define AO_SENSE_MAIN(p)       ((p)->adc.sense_m)
index 47eb577..38d4631 100644 (file)
@@ -132,11 +132,9 @@ struct ao_adc {
 
 #define AO_IGNITER_DROGUE_PORT (&stm_gpioa)
 #define AO_IGNITER_DROGUE_PIN  3
-#define AO_IGNITER_SET_DROGUE(v)       ao_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, AO_IGNITER_DROGUE, v)
 
 #define AO_IGNITER_MAIN_PORT   (&stm_gpiob)
 #define AO_IGNITER_MAIN_PIN    7
-#define AO_IGNITER_SET_MAIN(v) ao_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, AO_IGNITER_MAIN, v)
 
 #define AO_SENSE_DROGUE(p)     ((p)->adc.sense_a)
 #define AO_SENSE_MAIN(p)       ((p)->adc.sense_m)
index 5f41c55..a6ff997 100644 (file)
@@ -72,10 +72,8 @@ ao_igniter_status(enum ao_igniter igniter)
                return ao_igniter_unknown;
 }
 
-#ifndef AO_IGNITER_SET_DROGUE
-#define AO_IGNITER_SET_DROGUE(v)       AO_IGNITER_DROGUE = (v)
-#define AO_IGNITER_SET_MAIN(v)         AO_IGNITER_MAIN = (v)
-#endif
+#define AO_IGNITER_SET_DROGUE(v)       ao_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v)
+#define AO_IGNITER_SET_MAIN(v)         ao_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v)
 
 #ifndef AO_IGNITER_FIRE_TIME
 #define AO_IGNITER_FIRE_TIME           AO_MS_TO_TICKS(50)
@@ -226,8 +224,8 @@ struct ao_task ao_igniter_task;
 void
 ao_ignite_set_pins(void)
 {
-       ao_enable_output(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, AO_IGNITER_DROGUE, 0);
-       ao_enable_output(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, AO_IGNITER_MAIN, 0);
+       ao_enable_output(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, 0);
+       ao_enable_output(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, 0);
 }
 #endif
 
index c01c951..30d1518 100644 (file)
@@ -216,28 +216,28 @@ ao_pyro_pin_set(uint8_t p, uint8_t v)
 {
        switch (p) {
 #if AO_PYRO_NUM > 0
-       case 0: ao_gpio_set(AO_PYRO_PORT_0, AO_PYRO_PIN_0, AO_PYRO_0, v); break;
+       case 0: ao_gpio_set(AO_PYRO_PORT_0, AO_PYRO_PIN_0, v); break;
 #endif
 #if AO_PYRO_NUM > 1
-       case 1: ao_gpio_set(AO_PYRO_PORT_1, AO_PYRO_PIN_1, AO_PYRO_1, v); break;
+       case 1: ao_gpio_set(AO_PYRO_PORT_1, AO_PYRO_PIN_1, v); break;
 #endif
 #if AO_PYRO_NUM > 2
-       case 2: ao_gpio_set(AO_PYRO_PORT_2, AO_PYRO_PIN_2, AO_PYRO_2, v); break;
+       case 2: ao_gpio_set(AO_PYRO_PORT_2, AO_PYRO_PIN_2, v); break;
 #endif
 #if AO_PYRO_NUM > 3
-       case 3: ao_gpio_set(AO_PYRO_PORT_3, AO_PYRO_PIN_3, AO_PYRO_3, v); break;
+       case 3: ao_gpio_set(AO_PYRO_PORT_3, AO_PYRO_PIN_3, v); break;
 #endif
 #if AO_PYRO_NUM > 4
-       case 4: ao_gpio_set(AO_PYRO_PORT_4, AO_PYRO_PIN_4, AO_PYRO_4, v); break;
+       case 4: ao_gpio_set(AO_PYRO_PORT_4, AO_PYRO_PIN_4, v); break;
 #endif
 #if AO_PYRO_NUM > 5
-       case 5: ao_gpio_set(AO_PYRO_PORT_5, AO_PYRO_PIN_5, AO_PYRO_5, v); break;
+       case 5: ao_gpio_set(AO_PYRO_PORT_5, AO_PYRO_PIN_5, v); break;
 #endif
 #if AO_PYRO_NUM > 6
-       case 6: ao_gpio_set(AO_PYRO_PORT_6, AO_PYRO_PIN_6, AO_PYRO_6, v); break;
+       case 6: ao_gpio_set(AO_PYRO_PORT_6, AO_PYRO_PIN_6, v); break;
 #endif
 #if AO_PYRO_NUM > 7
-       case 7: ao_gpio_set(AO_PYRO_PORT_7, AO_PYRO_PIN_7, AO_PYRO_7, v); break;
+       case 7: ao_gpio_set(AO_PYRO_PORT_7, AO_PYRO_PIN_7, v); break;
 #endif
        default: break;
        }
@@ -555,28 +555,28 @@ void
 ao_pyro_init(void)
 {
 #if AO_PYRO_NUM > 0
-       ao_enable_output(AO_PYRO_PORT_0, AO_PYRO_PIN_0, AO_PYRO_0, 0);
+       ao_enable_output(AO_PYRO_PORT_0, AO_PYRO_PIN_0, 0);
 #endif
 #if AO_PYRO_NUM > 1
-       ao_enable_output(AO_PYRO_PORT_1, AO_PYRO_PIN_1, AO_PYRO_1, 0);
+       ao_enable_output(AO_PYRO_PORT_1, AO_PYRO_PIN_1, 0);
 #endif
 #if AO_PYRO_NUM > 2
-       ao_enable_output(AO_PYRO_PORT_2, AO_PYRO_PIN_2, AO_PYRO_2, 0);
+       ao_enable_output(AO_PYRO_PORT_2, AO_PYRO_PIN_2, 0);
 #endif
 #if AO_PYRO_NUM > 3
-       ao_enable_output(AO_PYRO_PORT_3, AO_PYRO_PIN_3, AO_PYRO_3, 0);
+       ao_enable_output(AO_PYRO_PORT_3, AO_PYRO_PIN_3, 0);
 #endif
 #if AO_PYRO_NUM > 4
-       ao_enable_output(AO_PYRO_PORT_4, AO_PYRO_PIN_4, AO_PYRO_4, 0);
+       ao_enable_output(AO_PYRO_PORT_4, AO_PYRO_PIN_4, 0);
 #endif
 #if AO_PYRO_NUM > 5
-       ao_enable_output(AO_PYRO_PORT_5, AO_PYRO_PIN_5, AO_PYRO_5, 0);
+       ao_enable_output(AO_PYRO_PORT_5, AO_PYRO_PIN_5, 0);
 #endif
 #if AO_PYRO_NUM > 6
-       ao_enable_output(AO_PYRO_PORT_6, AO_PYRO_PIN_6, AO_PYRO_6, 0);
+       ao_enable_output(AO_PYRO_PORT_6, AO_PYRO_PIN_6, 0);
 #endif
 #if AO_PYRO_NUM > 7
-       ao_enable_output(AO_PYRO_PORT_7, AO_PYRO_PIN_7, AO_PYRO_7, 0);
+       ao_enable_output(AO_PYRO_PORT_7, AO_PYRO_PIN_7, 0);
 #endif
        ao_add_task(&ao_pyro_task, ao_pyro, "pyro");
 }
index f79bd18..1454c17 100644 (file)
@@ -30,7 +30,7 @@ static uint8_t                ao_tracker_force_telem;
 static inline uint8_t
 ao_usb_connected(void)
 {
-       return ao_gpio_get(AO_USB_CONNECT_PORT, AO_USB_CONNECT_PIN, AO_USB_CONNECT) != 0;
+       return ao_gpio_get(AO_USB_CONNECT_PORT, AO_USB_CONNECT_PIN) != 0;
 }
 #else
 #define ao_usb_connected()     1
index 15106de..0454b38 100644 (file)
 #ifndef _AO_ARCH_FUNCS_H_
 #define _AO_ARCH_FUNCS_H_
 
-#define ao_spi_get_bit(reg,bit,pin,bus,speed) ao_spi_get_mask(reg,(1<<bit),bus,speed)
-#define ao_spi_put_bit(reg,bit,pin,bus) ao_spi_put_mask(reg,(1<<bit),bus)
+#define ao_spi_get_bit(reg,bit,bus,speed) ao_spi_get_mask(reg,(1<<bit),bus,speed)
+#define ao_spi_put_bit(reg,bit,bus) ao_spi_put_mask(reg,(1<<bit),bus)
 
 #define ao_enable_port(port) (lpc_scb.sysahbclkctrl |= (1 << LPC_SCB_SYSAHBCLKCTRL_GPIO))
 #define ao_disable_port(port) (lpc_scb.sysahbclkctrl &= ~(1 << LPC_SCB_SYSAHBCLKCTRL_GPIO))
 
 #define lpc_all_bit(port,bit)  (((port) << 5) | (bit))
 
-#define ao_gpio_set(port, bit, pin, v) (lpc_gpio.byte[lpc_all_bit(port,bit)] = (v))
+#define ao_gpio_set(port, bit, v)      (lpc_gpio.byte[lpc_all_bit(port,bit)] = (v))
 
-#define ao_gpio_get(port, bit, pin)    (lpc_gpio.byte[lpc_all_bit(port,bit)])
+#define ao_gpio_get(port, bit)         (lpc_gpio.byte[lpc_all_bit(port,bit)])
 
 #define PORT0_JTAG_REGS        ((1 << 11) | (1 << 12) | (1 << 14))
 
@@ -41,10 +41,10 @@ static inline void lpc_set_gpio(int port, int bit) {
        }
 }
 
-#define ao_enable_output(port,bit,pin,v) do {                  \
+#define ao_enable_output(port,bit,v) do {                      \
                ao_enable_port(port);                           \
                lpc_set_gpio(port,bit);                         \
-               ao_gpio_set(port, bit, pin, v);                 \
+               ao_gpio_set(port, bit, v);                      \
                lpc_gpio.dir[port] |= (1 << bit);               \
        } while (0)
 
@@ -204,8 +204,8 @@ static inline void ao_arch_restore_stack(void) {
                ao_spi_put(bus);                \
        } while (0)
 
-#define ao_spi_get_bit(reg,bit,pin,bus,speed) ao_spi_get_mask(reg,(1<<bit),bus,speed)
-#define ao_spi_put_bit(reg,bit,pin,bus) ao_spi_put_mask(reg,(1<<bit),bus)
+#define ao_spi_get_bit(reg,bit,bus,speed) ao_spi_get_mask(reg,(1<<bit),bus,speed)
+#define ao_spi_put_bit(reg,bit,bus) ao_spi_put_mask(reg,(1<<bit),bus)
 
 void
 ao_spi_get(uint8_t spi_index, uint32_t speed);
@@ -254,7 +254,7 @@ static inline void ao_spi_send_byte(uint8_t byte, uint8_t spi_index)
                uint8_t __bit__;                                        \
                for (__bit__ = 0; __bit__ < 32; __bit__++) {            \
                        if (mask & (1 << __bit__))                      \
-                               ao_enable_output(port, __bit__, PIN, 1); \
+                               ao_enable_output(port, __bit__, 1); \
                }                                                       \
        } while (0)
 
index e3c7d0c..a51c7f8 100644 (file)
@@ -36,7 +36,7 @@ ao_boot_check_pin(void)
                ao_arch_nop();
 
        /* Read the value */
-       v = ao_gpio_get(AO_BOOT_APPLICATION_GPIO, AO_BOOT_APPLICATION_PIN, AO_BOOT_APPLICATION);
+       v = ao_gpio_get(AO_BOOT_APPLICATION_GPIO, AO_BOOT_APPLICATION_PIN);
 
        /* Reset the chip to turn off the port and the power interface clock */
        ao_gpio_set_mode(AO_BOOT_APPLICATION_GPIO, AO_BOOT_APPLICATION_PIN, 0);
index 5cd7aa5..594114b 100644 (file)
@@ -857,7 +857,7 @@ ao_usb_disable(void)
        ao_arch_block_interrupts();
 
 #if HAS_USB_PULLUP
-       ao_gpio_set(AO_USB_PULLUP_PORT, AO_USB_PULLUP_PIN, AO_USB_PULLUP, 0);
+       ao_gpio_set(AO_USB_PULLUP_PORT, AO_USB_PULLUP_PIN, 0);
 #endif
        /* Disable interrupts */
        lpc_usb.inten = 0;
@@ -975,7 +975,7 @@ ao_usb_enable(void)
        ao_usb_set_ep0();
 
 #if HAS_USB_PULLUP
-       ao_gpio_set(AO_USB_PULLUP_PORT, AO_USB_PULLUP_PIN, AO_USB_PULLUP, 1);
+       ao_gpio_set(AO_USB_PULLUP_PORT, AO_USB_PULLUP_PIN, 1);
 #endif
 }
 
@@ -1014,7 +1014,7 @@ ao_usb_init(void)
 {
 #if HAS_USB_PULLUP
        int     i;
-       ao_enable_output(AO_USB_PULLUP_PORT, AO_USB_PULLUP_PIN, AO_USB_PULLUP, 0);
+       ao_enable_output(AO_USB_PULLUP_PORT, AO_USB_PULLUP_PIN, 0);
 
        for (i = 0; i < 40000; i++)
                ao_arch_nop();
index 522059b..9bb598f 100644 (file)
@@ -166,8 +166,8 @@ ao_spi_try_get_mask(struct stm_gpio *reg, uint16_t mask, uint8_t bus, uint32_t s
                ao_spi_put(bus);                \
        } while (0)
 
-#define ao_spi_get_bit(reg,bit,pin,bus,speed) ao_spi_get_mask(reg,(1<<bit),bus,speed)
-#define ao_spi_put_bit(reg,bit,pin,bus) ao_spi_put_mask(reg,(1<<bit),bus)
+#define ao_spi_get_bit(reg,bit,bus,speed) ao_spi_get_mask(reg,(1<<bit),bus,speed)
+#define ao_spi_put_bit(reg,bit,bus) ao_spi_put_mask(reg,(1<<bit),bus)
 
 #define ao_enable_port(port) do {                                      \
                if ((port) == &stm_gpioa)                               \
@@ -196,9 +196,9 @@ ao_spi_try_get_mask(struct stm_gpio *reg, uint16_t mask, uint8_t bus, uint32_t s
        } while (0)
 
 
-#define ao_gpio_set(port, bit, pin, v) stm_gpio_set(port, bit, v)
+#define ao_gpio_set(port, bit, v) stm_gpio_set(port, bit, v)
 
-#define ao_gpio_get(port, bit, pin) stm_gpio_get(port, bit)
+#define ao_gpio_get(port, bit) stm_gpio_get(port, bit)
 
 #define ao_gpio_set_bits(port, bits) stm_gpio_set_bits(port, bits)
 
@@ -208,9 +208,9 @@ ao_spi_try_get_mask(struct stm_gpio *reg, uint16_t mask, uint8_t bus, uint32_t s
 
 #define ao_gpio_get_all(port) stm_gpio_get_all(port)
 
-#define ao_enable_output(port,bit,pin,v) do {                  \
+#define ao_enable_output(port,bit,v) do {                      \
                ao_enable_port(port);                           \
-               ao_gpio_set(port, bit, pin, v);                 \
+               ao_gpio_set(port, bit, v);                      \
                stm_moder_set(port, bit, STM_MODER_OUTPUT);\
        } while (0)
 
@@ -223,7 +223,7 @@ ao_spi_try_get_mask(struct stm_gpio *reg, uint16_t mask, uint8_t bus, uint32_t s
 #define AO_OUTPUT_PUSH_PULL    STM_OTYPER_PUSH_PULL
 #define AO_OUTPUT_OPEN_DRAIN   STM_OTYPER_OPEN_DRAIN
 
-#define ao_gpio_set_output_mode(port,bit,pin,mode) \
+#define ao_gpio_set_output_mode(port,bit,mode) \
        stm_otyper_set(port, pin, mode)
 
 #define ao_gpio_set_mode(port,bit,mode) do {                           \
@@ -248,8 +248,8 @@ ao_spi_try_get_mask(struct stm_gpio *reg, uint16_t mask, uint8_t bus, uint32_t s
                stm_moder_set(port, bit, STM_MODER_INPUT);      \
        } while (0)
 
-#define ao_set_output(port, bit, pin, v) do {                  \
-               ao_gpio_set(port, bit, pin, v);                 \
+#define ao_set_output(port, bit, v) do {                       \
+               ao_gpio_set(port, bit, v);                      \
                stm_moder_set(port, bit, STM_MODER_OUTPUT);     \
        } while (0)
 
index bd83f4e..481a6e8 100644 (file)
@@ -83,7 +83,7 @@ ao_led_on(AO_LED_TYPE colors)
        AO_LED_TYPE i;
        for (i = 0; i < N_LED; i++)
                if (colors & (1 << i))
-                       ao_gpio_set(ao_leds[i].port, ao_leds[i].pin, foo, 1);
+                       ao_gpio_set(ao_leds[i].port, ao_leds[i].pin, 1);
 #else
 #ifdef LED_PORT
        LED_PORT->bsrr = (colors & ao_led_enable);
@@ -105,7 +105,7 @@ ao_led_off(AO_LED_TYPE colors)
        AO_LED_TYPE i;
        for (i = 0; i < N_LED; i++)
                if (colors & (1 << i))
-                       ao_gpio_set(ao_leds[i].port, ao_leds[i].pin, foo, 0);
+                       ao_gpio_set(ao_leds[i].port, ao_leds[i].pin, 0);
 #else
 #ifdef LED_PORT
        LED_PORT->bsrr = (uint32_t) (colors & ao_led_enable) << 16;
@@ -137,7 +137,7 @@ ao_led_toggle(AO_LED_TYPE colors)
        AO_LED_TYPE i;
        for (i = 0; i < N_LED; i++)
                if (colors & (1 << i))
-                       ao_gpio_set(ao_leds[i].port, ao_leds[i].pin, foo, ~ao_gpio_get(ao_leds[i].port, ao_leds[i].pin, foo));
+                       ao_gpio_set(ao_leds[i].port, ao_leds[i].pin, ~ao_gpio_get(ao_leds[i].port, ao_leds[i].pin));
 #else
 #ifdef LED_PORT
        LED_PORT->odr ^= (colors & ao_led_enable);
@@ -173,7 +173,7 @@ ao_led_init(AO_LED_TYPE enable)
        ao_led_enable = enable;
 #if LED_PER_LED
        for (bit = 0; bit < N_LED; bit++)
-               ao_enable_output(ao_leds[bit].port, ao_leds[bit].pin, foo, 0);
+               ao_enable_output(ao_leds[bit].port, ao_leds[bit].pin, 0);
 #else
 #ifdef LED_PORT
        stm_rcc.ahbenr |= (1 << LED_PORT_ENABLE);
index 2afee5b..c1a2f1b 100644 (file)
@@ -33,7 +33,7 @@ _ao_usart_tx_start(struct ao_stm_usart *usart)
 {
        if (!ao_fifo_empty(usart->tx_fifo)) {
 #if HAS_SERIAL_SW_FLOW
-               if (usart->gpio_cts && ao_gpio_get(usart->gpio_cts, usart->pin_cts, foo) == 1) {
+               if (usart->gpio_cts && ao_gpio_get(usart->gpio_cts, usart->pin_cts) == 1) {
                        ao_exti_enable(usart->gpio_cts, usart->pin_cts);
                        return 0;
                }
@@ -73,7 +73,7 @@ _ao_usart_rx(struct ao_stm_usart *usart, int is_stdin)
                         * for it to drain a bunch
                         */
                        if (usart->gpio_rts && ao_fifo_mostly(usart->rx_fifo)) {
-                               ao_gpio_set(usart->gpio_rts, usart->pin_rts, usart->pin_rts, 1);
+                               ao_gpio_set(usart->gpio_rts, usart->pin_rts, 1);
                                usart->rts = 0;
                        }
 #endif
@@ -118,7 +118,7 @@ _ao_usart_pollchar(struct ao_stm_usart *usart)
 #if HAS_SERIAL_SW_FLOW
                /* If we've cleared RTS, check if there's space now and turn it back on */
                if (usart->gpio_rts && usart->rts == 0 && ao_fifo_barely(usart->rx_fifo)) {
-                       ao_gpio_set(usart->gpio_rts, usart->pin_rts, foo, 0);
+                       ao_gpio_set(usart->gpio_rts, usart->pin_rts, 0);
                        usart->rts = 1;
                }
 #endif
@@ -403,7 +403,7 @@ ao_serial_set_sw_rts_cts(struct ao_stm_usart *usart,
 {
        /* Pull RTS low to note that there's space in the FIFO
         */
-       ao_enable_output(port_rts, pin_rts, foo, 0);
+       ao_enable_output(port_rts, pin_rts, 0);
        usart->gpio_rts = port_rts;
        usart->pin_rts = pin_rts;
        usart->rts = 1;
index 96c033f..70f273d 100644 (file)
@@ -168,8 +168,8 @@ ao_spi_try_get_mask(struct stm_gpio *reg, uint16_t mask, uint8_t bus, uint32_t s
                ao_spi_put(bus);                \
        } while (0)
 
-#define ao_spi_get_bit(reg,bit,pin,bus,speed) ao_spi_get_mask(reg,(1<<bit),bus,speed)
-#define ao_spi_put_bit(reg,bit,pin,bus) ao_spi_put_mask(reg,(1<<bit),bus)
+#define ao_spi_get_bit(reg,bit,bus,speed) ao_spi_get_mask(reg,(1<<bit),bus,speed)
+#define ao_spi_put_bit(reg,bit,bus) ao_spi_put_mask(reg,(1<<bit),bus)
 
 #if AO_POWER_MANAGEMENT
 extern struct ao_power ao_power_gpioa;
@@ -212,13 +212,13 @@ static inline void ao_disable_port(struct stm_gpio *port)
        }
 }
 
-#define ao_gpio_set(port, bit, pin, v) stm_gpio_set(port, bit, v)
+#define ao_gpio_set(port, bit, v) stm_gpio_set(port, bit, v)
 
-#define ao_gpio_get(port, bit, pin) stm_gpio_get(port, bit)
+#define ao_gpio_get(port, bit) stm_gpio_get(port, bit)
 
-#define ao_enable_output(port,bit,pin,v) do {                  \
+#define ao_enable_output(port,bit,v) do {                      \
                ao_enable_port(port);                           \
-               ao_gpio_set(port, bit, pin, v);                 \
+               ao_gpio_set(port, bit, v);                      \
                stm_moder_set(port, bit, STM_MODER_OUTPUT);\
        } while (0)
 
@@ -238,7 +238,7 @@ static inline void ao_disable_port(struct stm_gpio *port)
        } while (0)
 
 #define ao_enable_cs(port,bit) do {                            \
-               ao_enable_output(port, bit, pin, 1);            \
+               ao_enable_output(port, bit, 1);         \
        } while (0)
 
 #define ao_spi_init_cs(port, mask) do {                                \
index abcc116..31af7f4 100644 (file)
@@ -386,7 +386,7 @@ ao_beep_for(uint8_t beep, uint16_t ticks)
 void
 ao_beep_init(void)
 {
-       ao_enable_output(BEEPER_PORT, BEEPER_PIN, BEEPER, 0);
+       ao_enable_output(BEEPER_PORT, BEEPER_PIN, 0);
 
        /* Leave the timer off until requested */
        stm_rcc_enr &= ~(1 << STM_RCC_TIMER);
index d98e85d..4f27bad 100644 (file)
 #define AO_IGNITER_MAIN_PORT   (&stm_gpioa)
 #define AO_IGNITER_MAIN_PIN    9
 
-#define AO_IGNITER_SET_DROGUE(v)       stm_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v)
-#define AO_IGNITER_SET_MAIN(v)         stm_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v)
-
 /*
  * ADC
  */
index 94e77f9..64535c3 100644 (file)
 /* Number of general purpose pyro channels available */
 #define AO_PYRO_NUM    4
 
-#define AO_IGNITER_SET_DROGUE(v)       stm_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v)
-#define AO_IGNITER_SET_MAIN(v)         stm_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v)
-
 /*
  * ADC
  */
index d44394f..354da6a 100644 (file)
 /* Number of general purpose pyro channels available */
 #define AO_PYRO_NUM    4
 
-#define AO_IGNITER_SET_DROGUE(v)       stm_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v)
-#define AO_IGNITER_SET_MAIN(v)         stm_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v)
-
 /*
  * ADC
  */
index 42c00c9..4620788 100644 (file)
 /* Number of general purpose pyro channels available */
 #define AO_PYRO_NUM    4
 
-#define AO_IGNITER_SET_DROGUE(v)       stm_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v)
-#define AO_IGNITER_SET_MAIN(v)         stm_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v)
-
 /*
  * ADC
  */
index 7327860..ddcd0eb 100644 (file)
 /* Number of general purpose pyro channels available */
 #define AO_PYRO_NUM    4
 
-#define AO_IGNITER_SET_DROGUE(v)       stm_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v)
-#define AO_IGNITER_SET_MAIN(v)         stm_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v)
-
 /*
  * ADC
  */
index d26a519..47f6dd2 100644 (file)
 #define AO_IGNITER_MAIN_PORT   (&stm_gpioa)
 #define AO_IGNITER_MAIN_PIN    9
 
-#define AO_IGNITER_SET_DROGUE(v)       stm_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v)
-#define AO_IGNITER_SET_MAIN(v)         stm_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v)
-
 /*
  * ADC
  */
index 6d4369c..a8043bb 100644 (file)
 #define AO_IGNITER_MAIN_PORT   (&stm_gpioa)
 #define AO_IGNITER_MAIN_PIN    9
 
-#define AO_IGNITER_SET_DROGUE(v)       stm_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v)
-#define AO_IGNITER_SET_MAIN(v)         stm_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v)
-
 /*
  * ADC
  */
index 17cff2a..546d91e 100644 (file)
@@ -165,11 +165,9 @@ struct ao_adc {
 
 #define AO_IGNITER_DROGUE_PORT (&stm_gpiob)
 #define AO_IGNITER_DROGUE_PIN  7
-#define AO_IGNITER_SET_DROGUE(v)       ao_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, AO_IGNITER_DROGUE, v)
 
 #define AO_IGNITER_MAIN_PORT   (&stm_gpiob)
 #define AO_IGNITER_MAIN_PIN    6
-#define AO_IGNITER_SET_MAIN(v)         ao_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, AO_IGNITER_MAIN, v)
 
 #define AO_SENSE_DROGUE(p)     ((p)->adc.sense_a)
 #define AO_SENSE_MAIN(p)       ((p)->adc.sense_m)
index a2c0a59..66f75f0 100644 (file)
@@ -26,7 +26,7 @@ ao_check_recovery(void)
        ao_enable_input(AO_RECOVERY_PORT, AO_RECOVERY_PIN, AO_RECOVERY_MODE);
        for (i = 0; i < 100; i++)
                ao_arch_nop();
-       if (ao_gpio_get(AO_RECOVERY_PORT, AO_RECOVERY_PIN, AO_RECOVERY) == AO_RECOVERY_VALUE) {
+       if (ao_gpio_get(AO_RECOVERY_PORT, AO_RECOVERY_PIN) == AO_RECOVERY_VALUE) {
                ao_flight_force_idle = 1;
                ao_force_freq = 1;
        }