altos: Switch drivers to ao_arch_block/release_interrupts

Stop using cli/sei, which are avr-specific

Signed-off-by: Keith Packard <keithp@keithp.com>

diff --git a/src/core/ao_ignite.c b/src/core/ao_ignite.c
index 693b7c7aaeb17e3dc384852bc46204ed546fa156..74bd0c5aea021a55a4e7f16d45300f9fcb97bebe 100644 (file)
--- a/src/core/ao_ignite.c
+++ b/src/core/ao_ignite.c
@@ -23,10 +23,10 @@ __xdata struct ao_ignition ao_ignition[2];
 void
 ao_ignite(enum ao_igniter igniter)
 {
-       cli();
+       ao_arch_block_interrupts();
        ao_ignition[igniter].request = 1;
        ao_wakeup(&ao_ignition);
-       sei();
+       ao_arch_release_interrupts();
 }
 
 #ifndef AO_SENSE_DROGUE

diff --git a/src/drivers/ao_cc1120.c b/src/drivers/ao_cc1120.c
index 7428bead1131bc31bfafc3de6d6c12c2de214bdc..bad313ebaad23bdac7886812c48d3f51678ec7f6 100644 (file)
--- a/src/drivers/ao_cc1120.c
+++ b/src/drivers/ao_cc1120.c
@@ -469,10 +469,10 @@ ao_rdf_run(void)
 {
        ao_radio_start_tx();
 
-       cli();
+       ao_arch_block_interrupts();
        while (!ao_radio_wake && !ao_radio_abort)
                ao_sleep(&ao_radio_wake);
-       sei();
+       ao_arch_release_interrupts();
        if (!ao_radio_wake)
                ao_radio_idle();
        ao_radio_put();
@@ -603,10 +603,10 @@ ao_radio_send(const void *d, uint8_t size)
                        
                do {
                        ao_radio_wake = 0;
-                       cli();
+                       ao_arch_block_interrupts();
                        while (!ao_radio_wake)
                                ao_sleep(&ao_radio_wake);
-                       sei();
+                       ao_arch_release_interrupts();
                        if (!encode_len)
                                break;
                        fifo_space = ao_radio_tx_fifo_space();
@@ -660,14 +660,14 @@ ao_radio_rx_isr(void)
 static uint16_t
 ao_radio_rx_wait(void)
 {
-       cli();
+       ao_arch_block_interrupts();
        rx_waiting = 1;
        while (rx_data_cur - rx_data_consumed < AO_FEC_DECODE_BLOCK &&
               !ao_radio_abort) {
                ao_sleep(&ao_radio_wake);
        }
        rx_waiting = 0;
-       sei();
+       ao_arch_release_interrupts();
        if (ao_radio_abort)
                return 0;
        rx_data_consumed += AO_FEC_DECODE_BLOCK;

diff --git a/src/drivers/ao_ms5607.c b/src/drivers/ao_ms5607.c
index ce0bcf4bcfb79e6a123e00a62c78d7d315c47f01..55bea563498701775f1580f28bc8e122dd92bfb0 100644 (file)
--- a/src/drivers/ao_ms5607.c
+++ b/src/drivers/ao_ms5607.c
@@ -130,7 +130,6 @@ static uint32_t
 ao_ms5607_get_sample(uint8_t cmd) {
        uint8_t reply[3];
        uint8_t read;
-       uint32_t loops;
 
        ao_ms5607_done = 0;
 
@@ -142,15 +141,10 @@ ao_ms5607_get_sample(uint8_t cmd) {
 #if AO_MS5607_PRIVATE_PINS
        ao_spi_put(AO_MS5607_SPI_INDEX);
 #endif
-//     loops = 0;
-       cli();
-       while (!ao_ms5607_done) {
-//             loops++;
+       ao_arch_block_interrupts();
+       while (!ao_ms5607_done)
                ao_sleep((void *) &ao_ms5607_done);
-       }
-       sei();
-//     if (loops > 1)
-//             printf ("ms5607 loops %d\n", loops);
+       ao_arch_release_interrupts();
 #if AO_MS5607_PRIVATE_PINS
        stm_gpio_set(AO_MS5607_CS_PORT, AO_MS5607_CS_PIN, 1);
 #else

diff --git a/src/drivers/ao_radio_master.c b/src/drivers/ao_radio_master.c
index 4a37ace06c39aefd66501e79af0aea295244bd5d..1e0050c8d4bc822921ce61d9113bf5c6bb9d9863 100644 (file)
--- a/src/drivers/ao_radio_master.c
+++ b/src/drivers/ao_radio_master.c
@@ -75,7 +75,7 @@ ao_radio_master_send(void)
         */
 
        PRINTD("Waiting radio ready\n");
-       cli();
+       ao_arch_block_interrupts();
        ao_radio_ready = ao_gpio_get(AO_RADIO_INT_PORT,
                                     AO_RADIO_INT_PIN, AO_RADIO_INT);
        ret = 0;
@@ -84,7 +84,7 @@ ao_radio_master_send(void)
                if (ret)
                        break;
        }
-       sei();
+       ao_arch_release_interrupts();
        if (ret)
                return 0;
 
@@ -99,11 +99,11 @@ ao_radio_master_send(void)
                    AO_RADIO_SPI_BUS);
        ao_radio_master_stop();
        PRINTD("waiting for send done %d\n", ao_radio_done);
-       cli();
+       ao_arch_block_interrupts();
        while (!ao_radio_done)
                if (ao_sleep((void *) &ao_radio_done))
                        break;
-       sei();
+       ao_arch_release_interrupts();
        PRINTD ("sent, radio done %d isr_0 %d isr_1 %d\n", ao_radio_done, isr_0_count, isr_1_count);
        return ao_radio_done;
 }

diff --git a/src/stm/ao_i2c_stm.c b/src/stm/ao_i2c_stm.c
index b6dd7056e426e6db55b6b89413f059cbeba952e1..779e227503110971abcb3c8aa14744ef1594b1ed 100644 (file)
--- a/src/stm/ao_i2c_stm.c
+++ b/src/stm/ao_i2c_stm.c
@@ -197,13 +197,13 @@ ao_i2c_start(uint8_t index, uint16_t addr)
                        break;
        }
        ao_alarm(AO_MS_TO_TICKS(250));
-       cli();
+       ao_arch_block_interrupts();
        stm_i2c->cr2 = AO_STM_I2C_CR2 | (1 << STM_I2C_CR2_ITEVTEN) | (1 << STM_I2C_CR2_ITERREN);
        ao_i2c_ev_isr(index);
        while (ao_i2c_state[index] == I2C_IDLE)
                if (ao_sleep(&ao_i2c_state[index]))
                        break;
-       sei();
+       ao_arch_release_interrupts();
        ao_clear_alarm();
        return ao_i2c_state[index] == I2C_RUNNING;
 }
@@ -263,7 +263,7 @@ ao_i2c_send(void *block, uint16_t len, uint8_t index, uint8_t stop)
                           
        ao_dma_start(tx_dma_index);
        ao_alarm(1 + len);
-       cli();
+       ao_arch_block_interrupts();
        while (!ao_dma_done[tx_dma_index])
                if (ao_sleep(&ao_dma_done[tx_dma_index]))
                        break;
@@ -274,7 +274,7 @@ ao_i2c_send(void *block, uint16_t len, uint8_t index, uint8_t stop)
                if (ao_sleep(&ao_i2c_state[index]))
                        break;
        stm_i2c->cr2 = AO_STM_I2C_CR2;
-       sei();
+       ao_arch_release_interrupts();
        if (stop) {
                stm_i2c->cr1 = AO_STM_I2C_CR1 | (1 << STM_I2C_CR1_STOP);
                ao_i2c_wait_stop(index);
@@ -328,11 +328,11 @@ ao_i2c_recv(void *block, uint16_t len, uint8_t index, uint8_t stop)
                        stm_i2c->cr1 = AO_STM_I2C_CR1 | (1 << STM_I2C_CR1_STOP);
 
                ao_alarm(1);
-               cli();
+               ao_arch_block_interrupts();
                while (ao_i2c_recv_len[index])
                        if (ao_sleep(&ao_i2c_recv_len[index]))
                                break;
-               sei();
+               ao_arch_release_interrupts();
                ret = ao_i2c_recv_len[index] == 0;
                ao_clear_alarm();
        } else {
@@ -358,11 +358,11 @@ ao_i2c_recv(void *block, uint16_t len, uint8_t index, uint8_t stop)
 
                ao_dma_start(rx_dma_index);
                ao_alarm(len);
-               cli();
+               ao_arch_block_interrupts();
                while (!ao_dma_done[rx_dma_index])
                        if (ao_sleep(&ao_dma_done[rx_dma_index]))
                                break;
-               sei();
+               ao_arch_release_interrupts();
                ao_clear_alarm();
                ret = ao_dma_done[rx_dma_index];
                ao_dma_done_transfer(rx_dma_index);

diff --git a/src/stm/ao_lcd_stm.c b/src/stm/ao_lcd_stm.c
index 0f9a8eb53ee4325ab2c55f24be7df6b413a9604d..4f2a2242aeded5e0ef55e7d4b00dfa751b1b30a7 100644 (file)
--- a/src/stm/ao_lcd_stm.c
+++ b/src/stm/ao_lcd_stm.c
@@ -253,12 +253,12 @@ ao_lcd_stm_fcr_sync(void)
 void
 ao_lcd_flush(void)
 {
-       cli();
+       ao_arch_block_interrupts();
        ao_lcd_update_active = 1;
        stm_lcd.sr = (1 << STM_LCD_SR_UDR);
        while (ao_lcd_update_active)
                ao_sleep(&ao_lcd_update_active);
-       sei();
+       ao_arch_release_interrupts();
 }
 
 void

diff --git a/src/stm/ao_serial_stm.c b/src/stm/ao_serial_stm.c
index 406da9fbb6739099c12fa4867eec61611a5f7a88..00409f4a85957e16e53825f4e8420e85a168c535 100644 (file)
--- a/src/stm/ao_serial_stm.c
+++ b/src/stm/ao_serial_stm.c
@@ -34,7 +34,7 @@ ao_debug_out(char c)
 }
 
 static void
-ao_usart_tx_start(struct ao_stm_usart *usart)
+_ao_usart_tx_start(struct ao_stm_usart *usart)
 {
        if (!ao_fifo_empty(usart->tx_fifo) && !usart->tx_started)
        {
@@ -61,7 +61,7 @@ ao_usart_isr(struct ao_stm_usart *usart, int stdin)
        }
        if (sr & (1 << STM_USART_SR_TC)) {
                usart->tx_started = 0;
-               ao_usart_tx_start(usart);
+               _ao_usart_tx_start(usart);
                ao_wakeup(&usart->tx_fifo);
        }
 }
@@ -70,11 +70,11 @@ char
 ao_usart_getchar(struct ao_stm_usart *usart)
 {
        char c;
-       cli();
+       ao_arch_block_interrupts();
        while (ao_fifo_empty(usart->rx_fifo))
                ao_sleep(&usart->rx_fifo);
        ao_fifo_remove(usart->rx_fifo, c);
-       sei();
+       ao_arch_release_interrupts();
        return c;
 }
 
@@ -82,34 +82,34 @@ char
 ao_usart_pollchar(struct ao_stm_usart *usart)
 {
        char    c;
-       cli();
-       if (ao_fifo_empty(usart->rx_fifo)) {
-               sei();
-               return AO_READ_AGAIN;
-       }
-       ao_fifo_remove(usart->rx_fifo,c);
-       sei();
+       
+       ao_arch_block_interrupts();
+       if (ao_fifo_empty(usart->rx_fifo))
+               c = AO_READ_AGAIN;
+       else
+               ao_fifo_remove(usart->rx_fifo,c);
+       ao_arch_release_interrupts();
        return c;
 }
 
 void
 ao_usart_putchar(struct ao_stm_usart *usart, char c)
 {
-       cli();
+       ao_arch_block_interrupts();
        while (ao_fifo_full(usart->tx_fifo))
                ao_sleep(&usart->tx_fifo);
        ao_fifo_insert(usart->tx_fifo, c);
-       ao_usart_tx_start(usart);
-       sei();
+       _ao_usart_tx_start(usart);
+       ao_arch_release_interrupts();
 }
 
 void
 ao_usart_drain(struct ao_stm_usart *usart)
 {
-       cli();
+       ao_arch_block_interrupts();
        while (!ao_fifo_empty(usart->tx_fifo))
                ao_sleep(&usart->tx_fifo);
-       sei();
+       ao_arch_release_interrupts();
 }
 
 static const struct {

diff --git a/src/stm/ao_usb_stm.c b/src/stm/ao_usb_stm.c
index 8e7dacc53e2bf98e37d4bb3d0ad48cbc2ef1fa92..d93a0c174c16a7a851669241fa98fbd68083d2d9 100644 (file)
--- a/src/stm/ao_usb_stm.c
+++ b/src/stm/ao_usb_stm.c
@@ -223,16 +223,16 @@ _ao_usb_set_stat_tx(int ep, uint32_t stat_tx)
 static void
 ao_usb_set_stat_tx(int ep, uint32_t stat_tx)
 {
-       cli();
+       ao_arch_block_interrupts();
        _ao_usb_set_stat_tx(ep, stat_tx);
-       sei();
+       ao_arch_release_interrupts();
 }
 
 static void
 ao_usb_set_stat_rx(int ep, uint32_t stat_rx) {
        uint32_t        epr_write, epr_old;
 
-       cli();
+       ao_arch_block_interrupts();
        epr_write = epr_old = stm_usb.epr[ep];
        epr_write &= STM_USB_EPR_PRESERVE_MASK;
        epr_write |= STM_USB_EPR_INVARIANT;
@@ -240,7 +240,7 @@ ao_usb_set_stat_rx(int ep, uint32_t stat_rx) {
                              STM_USB_EPR_STAT_RX_MASK << STM_USB_EPR_STAT_RX,
                              stat_rx << STM_USB_EPR_STAT_RX);
        stm_usb.epr[ep] = epr_write;
-       sei();
+       ao_arch_release_interrupts();
 }
 
 /*
@@ -251,7 +251,7 @@ static void
 ao_usb_init_ep(uint8_t ep, uint32_t addr, uint32_t type, uint32_t stat_rx, uint32_t stat_tx)
 {
        uint32_t                epr;
-       cli();
+       ao_arch_block_interrupts();
        epr = stm_usb.epr[ep];
        epr = ((0 << STM_USB_EPR_CTR_RX) |
               (epr & (1 << STM_USB_EPR_DTOG_RX)) |
@@ -267,7 +267,7 @@ ao_usb_init_ep(uint8_t ep, uint32_t addr, uint32_t type, uint32_t stat_rx, uint3
                          (stat_tx << STM_USB_EPR_STAT_TX)) |
               (addr << STM_USB_EPR_EA));
        stm_usb.epr[ep] = epr;
-       sei();
+       ao_arch_release_interrupts();
        debug ("writing epr[%d] 0x%08x wrote 0x%08x\n",
               ep, epr, stm_usb.epr[ep]);
 }