altos: Support telefire products in cc1200 driver
[fw/altos] / src / drivers / ao_cc1200.c
index a3c1cbd4f92d390d556da7e43bdf86e2bdffe1ac..6bccb18863f9439ac0f4ed46f76dc7bd90adabcd 100644 (file)
@@ -20,6 +20,9 @@
 #include <ao_exti.h>
 #include <ao_fec.h>
 #include <ao_packet.h>
+#if HAS_PAD
+#include <ao_pad.h>
+#endif
 
 static uint8_t ao_radio_mutex;
 
@@ -28,16 +31,26 @@ static uint8_t ao_radio_abort;              /* radio operation should abort */
 
 int8_t ao_radio_rssi;                  /* Last received RSSI value */
 
+#ifndef CC1200_DEBUG
 #define CC1200_DEBUG           0
+#endif
+
+#ifndef CC1200_LOW_LEVEL_DEBUG
 #define CC1200_LOW_LEVEL_DEBUG 0
+#endif
+
 #define CC1200_TRACE           0
 #define CC1200_APRS_TRACE      0
 
 extern const uint32_t  ao_radio_cal;
 
+#ifdef AO_CC1200_FOSC
+#define FOSC   AO_CC1200_FOSC
+#else
 #define FOSC   40000000
+#endif
 
-#define ao_radio_select()      ao_spi_get_mask(AO_CC1200_SPI_CS_PORT,(1 << AO_CC1200_SPI_CS_PIN),AO_CC1200_SPI_BUS,AO_SPI_SPEED_125kHz)
+#define ao_radio_select()      ao_spi_get_mask(AO_CC1200_SPI_CS_PORT,(1 << AO_CC1200_SPI_CS_PIN),AO_CC1200_SPI_BUS,AO_SPI_SPEED_FAST)
 #define ao_radio_deselect()    ao_spi_put_mask(AO_CC1200_SPI_CS_PORT,(1 << AO_CC1200_SPI_CS_PIN),AO_CC1200_SPI_BUS)
 #define ao_radio_spi_send(d,l) ao_spi_send((d), (l), AO_CC1200_SPI_BUS)
 #define ao_radio_spi_send_fixed(d,l) ao_spi_send_fixed((d), (l), AO_CC1200_SPI_BUS)
@@ -295,20 +308,28 @@ ao_radio_idle(void)
  *     CHANBW = 5.0 (round to 9.5)
  */
 
+#if FOSC == 40000000
 #define PACKET_SYMBOL_RATE_M           1013008
-
 #define PACKET_SYMBOL_RATE_E_384       8
+#define PACKET_SYMBOL_RATE_E_96                6
+#define PACKET_SYMBOL_RATE_E_24                4
+#endif
+
+#if FOSC == 32000000
+#define PACKET_SYMBOL_RATE_M           239914
+#define PACKET_SYMBOL_RATE_E_384       9
+#define PACKET_SYMBOL_RATE_E_96                7
+#define PACKET_SYMBOL_RATE_E_24                5
+#endif
 
 /* 200 / 2 = 100 */
 #define PACKET_CHAN_BW_384     ((CC1200_CHAN_BW_ADC_CIC_DECFACT_12 << CC1200_CHAN_BW_ADC_CIC_DECFACT) | \
                                 (16 << CC1200_CHAN_BW_BB_CIC_DECFACT))
 
-#define PACKET_SYMBOL_RATE_E_96                6
 /* 200 / 10 = 20 */
 #define PACKET_CHAN_BW_96      ((CC1200_CHAN_BW_ADC_CIC_DECFACT_48 << CC1200_CHAN_BW_ADC_CIC_DECFACT) | \
                                 (16 << CC1200_CHAN_BW_BB_CIC_DECFACT))
 
-#define PACKET_SYMBOL_RATE_E_24                4
 /* 200 / 25 = 8 */
 #define PACKET_CHAN_BW_24      ((CC1200_CHAN_BW_ADC_CIC_DECFACT_48 << CC1200_CHAN_BW_ADC_CIC_DECFACT) | \
                                 (44 << CC1200_CHAN_BW_BB_CIC_DECFACT))
@@ -593,14 +614,20 @@ ao_radio_set_mode(uint16_t new_mode)
                }
        }
 
-       if (changes & AO_RADIO_MODE_BITS_TX_BUF)
+       if (changes & AO_RADIO_MODE_BITS_TX_BUF) {
                ao_radio_reg_write(AO_CC1200_INT_GPIO_IOCFG, CC1200_IOCFG_GPIO_CFG_TXFIFO_THR);
+               ao_exti_set_mode(AO_CC1200_INT_PORT, AO_CC1200_INT_PIN, AO_EXTI_MODE_FALLING|AO_EXTI_PRIORITY_HIGH);
+       }
 
-       if (changes & AO_RADIO_MODE_BITS_TX_FINISH)
+       if (changes & AO_RADIO_MODE_BITS_TX_FINISH) {
                ao_radio_reg_write(AO_CC1200_INT_GPIO_IOCFG, CC1200_IOCFG_GPIO_CFG_PKT_SYNC_RXTX);
+               ao_exti_set_mode(AO_CC1200_INT_PORT, AO_CC1200_INT_PIN, AO_EXTI_MODE_FALLING|AO_EXTI_PRIORITY_HIGH);
+       }
 
-       if (changes & AO_RADIO_MODE_BITS_RX)
-               ao_radio_reg_write(AO_CC1200_INT_GPIO_IOCFG, CC1200_IOCFG_GPIO_CFG_PKT_SYNC_RXTX);
+       if (changes & AO_RADIO_MODE_BITS_RX) {
+               ao_radio_reg_write(AO_CC1200_INT_GPIO_IOCFG, CC1200_IOCFG_GPIO_CFG_MARC_MCU_WAKEUP);
+               ao_exti_set_mode(AO_CC1200_INT_PORT, AO_CC1200_INT_PIN, AO_EXTI_MODE_RISING|AO_EXTI_PRIORITY_HIGH);
+       }
 
        if (changes & AO_RADIO_MODE_BITS_RDF)
                ao_radio_set_regs(rdf_setup);
@@ -703,30 +730,11 @@ ao_radio_show_state(char *where)
 static void
 ao_radio_wait_isr(uint16_t timeout)
 {
-       uint8_t state;
-
-       state = ao_radio_state();
-       switch (state) {
-       case CC1200_STATUS_STATE_IDLE:
-       case CC1200_STATUS_STATE_RX_FIFO_ERROR:
-       case CC1200_STATUS_STATE_TX_FIFO_ERROR:
-#if CC1200_LOW_LEVEL_DEBUG
-               printf("before wait, state %d\n", state); flush();
-#endif
-               ao_radio_abort = 1;
-               return;
-       }
-
-       if (timeout)
-               ao_alarm(timeout);
-
        ao_arch_block_interrupts();
        while (!ao_radio_wake && !ao_radio_abort)
-               if (ao_sleep(&ao_radio_wake))
+               if (ao_sleep_for(&ao_radio_wake, timeout))
                        ao_radio_abort = 1;
        ao_arch_release_interrupts();
-       if (timeout)
-               ao_clear_alarm();
 }
 
 static void
@@ -742,6 +750,8 @@ ao_rdf_start(uint8_t len)
 static void
 ao_radio_run(void)
 {
+       ao_radio_wake = 0;
+       ao_radio_abort = 0;
        ao_radio_start_tx();
        ao_radio_wait_isr(0);
        if (!ao_radio_wake)
@@ -805,6 +815,9 @@ ao_radio_test_cmd(void)
 #endif
 #if PACKET_HAS_SLAVE
                ao_packet_slave_stop();
+#endif
+#if HAS_PAD
+               ao_pad_disable();
 #endif
                ao_radio_get(0xff);
                ao_radio_set_mode(AO_RADIO_MODE_TEST);
@@ -830,6 +843,9 @@ ao_radio_test_cmd(void)
                radio_on = 0;
 #if HAS_MONITOR
                ao_monitor_enable();
+#endif
+#if HAS_PAD
+               ao_pad_enable();
 #endif
        }
 }
@@ -858,6 +874,7 @@ ao_radio_send_aprs(ao_radio_fill_func fill)
        uint8_t started = 0;
        uint8_t fifo_space;
 
+       ao_radio_abort = 0;
        ao_radio_get(0xff);
        fifo_space = CC1200_FIFO_SIZE;
        while (!done) {
@@ -996,14 +1013,79 @@ ao_radio_dump_state(struct ao_radio_state *s)
 uint8_t
 ao_radio_recv(__xdata void *d, uint8_t size, uint8_t timeout)
 {
-       ao_radio_abort = 0;
+       uint8_t success = 0;
 
+       ao_radio_abort = 0;
        ao_radio_get(size - 2);
        ao_radio_set_mode(AO_RADIO_MODE_PACKET_RX);
        ao_radio_wake = 0;
        ao_radio_start_rx();
-       ao_radio_wait_isr(timeout);
-       if (ao_radio_wake) {
+
+       while (!ao_radio_abort) {
+               ao_radio_wait_isr(timeout);
+               if (ao_radio_wake) {
+                       uint8_t         marc_status1 = ao_radio_reg_read(CC1200_MARC_STATUS1);
+
+                       /* Check the receiver status to see what happened
+                        */
+                       switch (marc_status1) {
+                       case CC1200_MARC_STATUS1_RX_FINISHED:
+                       case CC1200_MARC_STATUS1_ADDRESS:
+                       case CC1200_MARC_STATUS1_CRC:
+                               /* Normal return, go fetch the bytes from the FIFO
+                                * and give them back to the caller
+                                */
+                               success = 1;
+                               break;
+                       case CC1200_MARC_STATUS1_RX_TIMEOUT:
+                       case CC1200_MARC_STATUS1_RX_TERMINATION:
+                       case CC1200_MARC_STATUS1_EWOR_SYNC_LOST:
+                       case CC1200_MARC_STATUS1_MAXIMUM_LENGTH:
+                       case CC1200_MARC_STATUS1_RX_FIFO_OVERFLOW:
+                       case CC1200_MARC_STATUS1_RX_FIFO_UNDERFLOW:
+                               /* Something weird happened; reset the radio and
+                                * return failure
+                                */
+                               success = 0;
+                               break;
+                       default:
+                               /* some other status; go wait for the radio to do something useful
+                                */
+                               continue;
+                       }
+                       break;
+               } else {
+                       uint8_t modem_status1 = ao_radio_reg_read(CC1200_MODEM_STATUS1);
+
+                       /* Check to see if the packet header has been seen, in which case we'll
+                        * want to keep waiting for the rest of the packet to appear
+                        */
+                       if (modem_status1 & (1 << CC1200_MODEM_STATUS1_SYNC_FOUND))
+                       {
+                               ao_radio_abort = 0;
+
+                               /* Set a timeout based on the packet length so that we make sure to
+                                * wait long enough to receive the whole thing.
+                                *
+                                * timeout = bits * FEC expansion / rate
+                                */
+                               switch (ao_config.radio_rate) {
+                               default:
+                               case AO_RADIO_RATE_38400:
+                                       timeout = AO_MS_TO_TICKS(size * (8 * 2 * 10) / 384) + 1;
+                                       break;
+                               case AO_RADIO_RATE_9600:
+                                       timeout = AO_MS_TO_TICKS(size * (8 * 2 * 10) / 96) + 1;
+                                       break;
+                               case AO_RADIO_RATE_2400:
+                                       timeout = AO_MS_TO_TICKS(size * (8 * 2 * 10) / 24) + 1;
+                                       break;
+                               }
+                       }
+               }
+       }
+
+       if (success) {
                int8_t  rssi;
                uint8_t status;
 
@@ -1024,7 +1106,7 @@ ao_radio_recv(__xdata void *d, uint8_t size, uint8_t timeout)
        }
 
        ao_radio_put();
-       return ao_radio_wake;
+       return success;
 }