altos: profiling on STM32L

[fw/altos] / src / drivers / ao_cc1120.c

diff --git a/src/drivers/ao_cc1120.c b/src/drivers/ao_cc1120.c
index 1d28148ba2b4a74366a87c345cad72e6f9ebb02d..7428bead1131bc31bfafc3de6d6c12c2de214bdc 100644 (file)
--- a/src/drivers/ao_cc1120.c
+++ b/src/drivers/ao_cc1120.c
@@ -21,6 +21,9 @@
 #include <ao_fec.h>
 #include <ao_packet.h>
 
+#define AO_RADIO_MAX_RECV      sizeof(struct ao_packet)
+#define AO_RADIO_MAX_SEND      sizeof(struct ao_packet)
+
 uint8_t ao_radio_wake;
 uint8_t ao_radio_mutex;
 uint8_t ao_radio_abort;
@@ -29,7 +32,7 @@ uint8_t ao_radio_in_recv;
 #define CC1120_DEBUG   AO_FEC_DEBUG
 #define CC1120_TRACE   0
 
-const uint32_t ao_radio_cal = 0x6ca333;
+extern const uint32_t  ao_radio_cal;
 
 #define FOSC   32000000
 
@@ -160,7 +163,7 @@ ao_radio_fifo_read(uint8_t *data, uint8_t len)
 }
 
 static uint8_t
-ao_radio_fifo_write(uint8_t *data, uint8_t len)
+ao_radio_fifo_write_start(void)
 {
        uint8_t addr = ((0 << CC1120_READ)  |
                        (1 << CC1120_BURST) |
@@ -169,24 +172,28 @@ ao_radio_fifo_write(uint8_t *data, uint8_t len)
 
        ao_radio_select();
        ao_radio_duplex(&addr, &status, 1);
-       ao_radio_spi_send(data, len);
+       return status;
+}
+
+static inline uint8_t ao_radio_fifo_write_stop(uint8_t status) {
        ao_radio_deselect();
        return status;
 }
 
 static uint8_t
-ao_radio_fifo_write_fixed(uint8_t data, uint8_t len)
+ao_radio_fifo_write(uint8_t *data, uint8_t len)
 {
-       uint8_t addr = ((0 << CC1120_READ)  |
-                       (1 << CC1120_BURST) |
-                       CC1120_FIFO);
-       uint8_t status;
+       uint8_t status = ao_radio_fifo_write_start();
+       ao_radio_spi_send(data, len);
+       return ao_radio_fifo_write_stop(status);
+}
 
-       ao_radio_select();
-       ao_radio_duplex(&addr, &status, 1);
+static uint8_t
+ao_radio_fifo_write_fixed(uint8_t data, uint8_t len)
+{
+       uint8_t status = ao_radio_fifo_write_start();
        ao_radio_spi_send_fixed(data, len);
-       ao_radio_deselect();
-       return status;
+       return ao_radio_fifo_write_stop(status);
 }
 
 static uint8_t
@@ -446,19 +453,20 @@ ao_radio_get(uint8_t len)
 
 #define ao_radio_put() ao_mutex_put(&ao_radio_mutex)
 
-void
-ao_radio_rdf(uint8_t len)
+static void
+ao_rdf_start(uint8_t len)
 {
-       int i;
-
        ao_radio_abort = 0;
        ao_radio_get(len);
 
        ao_radio_set_mode(AO_RADIO_MODE_RDF);
        ao_radio_wake = 0;
 
-       ao_radio_fifo_write_fixed(ao_radio_rdf_value, len);
+}
 
+static void
+ao_rdf_run(void)
+{
        ao_radio_start_tx();
 
        cli();
@@ -470,6 +478,38 @@ ao_radio_rdf(uint8_t len)
        ao_radio_put();
 }
 
+void
+ao_radio_rdf(void)
+{
+       ao_rdf_start(AO_RADIO_RDF_LEN);
+
+       ao_radio_fifo_write_fixed(ao_radio_rdf_value, AO_RADIO_RDF_LEN);
+
+       ao_rdf_run();
+}
+
+void
+ao_radio_continuity(uint8_t c)
+{
+       uint8_t i;
+       uint8_t status;
+
+       ao_rdf_start(AO_RADIO_CONT_TOTAL_LEN);
+
+       status = ao_radio_fifo_write_start();
+       for (i = 0; i < 3; i++) {
+               ao_radio_spi_send_fixed(0x00, AO_RADIO_CONT_PAUSE_LEN);
+               if (i < c)
+                       ao_radio_spi_send_fixed(ao_radio_rdf_value, AO_RADIO_CONT_TONE_LEN);
+               else
+                       ao_radio_spi_send_fixed(0x00, AO_RADIO_CONT_TONE_LEN);
+       }
+       ao_radio_spi_send_fixed(0x00, AO_RADIO_CONT_PAUSE_LEN);
+       status = ao_radio_fifo_write_stop(status);
+       (void) status;
+       ao_rdf_run();
+}
+
 void
 ao_radio_rdf_abort(void)
 {
@@ -478,7 +518,7 @@ ao_radio_rdf_abort(void)
 }
 
 static void
-ao_radio_test(void)
+ao_radio_test_cmd(void)
 {
        uint8_t mode = 2;
        uint8_t radio_on;
@@ -522,18 +562,19 @@ ao_radio_test(void)
        }
 }
 
+static uint8_t tx_data[(AO_RADIO_MAX_SEND + 4) * 2];
+
 void
 ao_radio_send(const void *d, uint8_t size)
 {
        uint8_t         marc_status;
-       static uint8_t  encode[256];
-       uint8_t         *e = encode;
+       uint8_t         *e = tx_data;
        uint8_t         encode_len;
        uint8_t         this_len;
        uint8_t         started = 0;
        uint8_t         fifo_space;
 
-       encode_len = ao_fec_encode(d, size, encode);
+       encode_len = ao_fec_encode(d, size, tx_data);
 
        ao_radio_get(encode_len);
 
@@ -574,8 +615,6 @@ ao_radio_send(const void *d, uint8_t size)
        ao_radio_put();
 }
 
-#define AO_RADIO_MAX_RECV      90
-
 static uint8_t rx_data[(AO_RADIO_MAX_RECV + 4) * 2 * 8];
 static uint16_t        rx_data_count;
 static uint16_t        rx_data_consumed;
@@ -692,7 +731,7 @@ ao_radio_recv(__xdata void *d, uint8_t size)
 
        /* Convert from 'real' rssi to cc1111-style values */
 
-       rssi = (((int8_t) ao_radio_reg_read(CC1120_RSSI1)) + 74) * 2;
+       rssi = AO_RADIO_FROM_RSSI(ao_radio_reg_read(CC1120_RSSI1));
 
        ao_radio_put();
 
@@ -961,7 +1000,7 @@ ao_radio_test_recv()
                        printf ("CRC OK");
                else
                        printf ("CRC BAD");
-               printf (" RSSI %d", (int16_t) ((int8_t) bytes[32] >> 1) - 74);
+               printf (" RSSI %d", AO_RSSI_FROM_RADIO(bytes[32]));
                for (b = 0; b < 32; b++)
                        printf (" %02x", bytes[b]);
                printf ("\n");
@@ -971,7 +1010,7 @@ ao_radio_test_recv()
 #endif
 
 static const struct ao_cmds ao_radio_cmds[] = {
-       { ao_radio_test,        "C <1 start, 0 stop, none both>\0Radio carrier test" },
+       { ao_radio_test_cmd,    "C <1 start, 0 stop, none both>\0Radio carrier test" },
 #if CC1120_DEBUG
        { ao_radio_show,        "R\0Show CC1120 status" },
        { ao_radio_beep,        "b\0Emit an RDF beacon" },
@@ -989,14 +1028,16 @@ ao_radio_init(void)
        ao_radio_configured = 0;
        ao_spi_init_cs (AO_CC1120_SPI_CS_PORT, (1 << AO_CC1120_SPI_CS_PIN));
 
+#if 0
        AO_CC1120_SPI_CS_PORT->bsrr = ((uint32_t) (1 << AO_CC1120_SPI_CS_PIN));
        for (i = 0; i < 10000; i++) {
-               if ((SPI_2_GPIO->idr & (1 << SPI_2_MISO)) == 0)
+               if ((SPI_2_PORT->idr & (1 << SPI_2_MISO_PIN)) == 0)
                        break;
        }
        AO_CC1120_SPI_CS_PORT->bsrr = (1 << AO_CC1120_SPI_CS_PIN);
        if (i == 10000)
-               ao_panic(AO_PANIC_SELF_TEST);
+               ao_panic(AO_PANIC_SELF_TEST_CC1120);
+#endif
 
        /* Enable the EXTI interrupt for the appropriate pin */
        ao_enable_port(AO_CC1120_INT_PORT);