X-Git-Url: https://git.gag.com/?p=fw%2Faltos;a=blobdiff_plain;f=src%2Fdrivers%2Fao_cc1120.c;h=07ebf8356cf5f3e108d4eaa202fd64e19d840d03;hp=7654af856a624b0b55c76b238ad55354317239e1;hb=f09b2fc7fcfb1b3dcb1a46a8b9856092dd59866b;hpb=bd05421991b596fe9cf73ee25c9046b0fb4e32f7

diff --git a/src/drivers/ao_cc1120.c b/src/drivers/ao_cc1120.c
index 7654af85..07ebf835 100644
--- a/src/drivers/ao_cc1120.c
+++ b/src/drivers/ao_cc1120.c
@@ -24,10 +24,13 @@
 #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;
-uint8_t ao_radio_in_recv;
+static uint8_t ao_radio_mutex;
+
+static uint8_t ao_radio_wake;		/* radio ready. Also used as sleep address */
+static uint8_t ao_radio_abort;		/* radio operation should abort */
+static uint8_t ao_radio_mcu_wake;	/* MARC status change */
+static uint8_t ao_radio_marc_status;	/* Last read MARC status value */
+static uint8_t ao_radio_tx_finished;	/* MARC status indicates TX finished */
 
 #define CC1120_DEBUG	AO_FEC_DEBUG
 #define CC1120_TRACE	0
@@ -36,7 +39,7 @@ extern const uint32_t	ao_radio_cal;
 
 #define FOSC	32000000
 
-#define ao_radio_select()	ao_spi_get_mask(AO_CC1120_SPI_CS_PORT,(1 << AO_CC1120_SPI_CS_PIN),AO_CC1120_SPI_BUS,AO_SPI_SPEED_1MHz)
+#define ao_radio_select()	ao_spi_get_mask(AO_CC1120_SPI_CS_PORT,(1 << AO_CC1120_SPI_CS_PIN),AO_CC1120_SPI_BUS,AO_SPI_SPEED_4MHz)
 #define ao_radio_deselect()	ao_spi_put_mask(AO_CC1120_SPI_CS_PORT,(1 << AO_CC1120_SPI_CS_PIN),AO_CC1120_SPI_BUS)
 #define ao_radio_spi_send(d,l)	ao_spi_send((d), (l), AO_CC1120_SPI_BUS)
 #define ao_radio_spi_send_fixed(d,l) ao_spi_send_fixed((d), (l), AO_CC1120_SPI_BUS)
@@ -218,13 +221,34 @@ ao_radio_recv_abort(void)
 #define ao_radio_rdf_value 0x55
 
 static uint8_t
-ao_radio_marc_status(void)
+ao_radio_get_marc_status(void)
 {
 	return ao_radio_reg_read(CC1120_MARC_STATUS1);
 }
 
 static void
-ao_radio_tx_isr(void)
+ao_radio_mcu_wakeup_isr(void)
+{
+	ao_radio_mcu_wake = 1;
+	ao_wakeup(&ao_radio_wake);
+}
+
+
+static void
+ao_radio_check_marc_status(void)
+{
+	ao_radio_mcu_wake = 0;
+	ao_radio_marc_status = ao_radio_get_marc_status();
+	
+	/* Anyt other than 'tx/rx finished' means an error occurred */
+	if (ao_radio_marc_status & ~(CC1120_MARC_STATUS1_TX_FINISHED|CC1120_MARC_STATUS1_RX_FINISHED))
+		ao_radio_abort = 1;
+	if (ao_radio_marc_status & (CC1120_MARC_STATUS1_TX_FINISHED))
+		ao_radio_tx_finished = 1;
+}
+
+static void
+ao_radio_isr(void)
 {
 	ao_exti_disable(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN);
 	ao_radio_wake = 1;
@@ -234,8 +258,10 @@ ao_radio_tx_isr(void)
 static void
 ao_radio_start_tx(void)
 {
-	ao_exti_set_callback(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN, ao_radio_tx_isr);
+	ao_exti_set_callback(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN, ao_radio_isr);
 	ao_exti_enable(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN);
+	ao_exti_enable(AO_CC1120_MCU_WAKEUP_PORT, AO_CC1120_MCU_WAKEUP_PIN);
+	ao_radio_tx_finished = 0;
 	ao_radio_strobe(CC1120_STX);
 }
 
@@ -246,7 +272,11 @@ ao_radio_idle(void)
 		uint8_t	state = ao_radio_strobe(CC1120_SIDLE);
 		if ((state >> CC1120_STATUS_STATE) == CC1120_STATUS_STATE_IDLE)
 			break;
+		if ((state >> CC1120_STATUS_STATE) == CC1120_STATUS_STATE_TX_FIFO_ERROR)
+			ao_radio_strobe(CC1120_SFTX);
 	}
+	/* Flush any pending TX bytes */
+	ao_radio_strobe(CC1120_SFTX);
 }
 
 /*
@@ -294,18 +324,19 @@ static const uint16_t packet_setup[] = {
 				 (0 << CC1120_PKT_CFG0_PKG_BIT_LEN) |
 				 (0 << CC1120_PKT_CFG0_UART_MODE_EN) |
 				 (0 << CC1120_PKT_CFG0_UART_SWAP_EN)),
+	AO_CC1120_MARC_GPIO_IOCFG,		CC1120_IOCFG_GPIO_CFG_MARC_MCU_WAKEUP,
 };
 
 static const uint16_t packet_tx_setup[] = {
 	CC1120_PKT_CFG2,	((CC1120_PKT_CFG2_CCA_MODE_ALWAYS_CLEAR << CC1120_PKT_CFG2_CCA_MODE) |
 				 (CC1120_PKT_CFG2_PKT_FORMAT_NORMAL << CC1120_PKT_CFG2_PKT_FORMAT)),
-	CC1120_IOCFG2, 		CC1120_IOCFG_GPIO_CFG_RX0TX1_CFG,
+	AO_CC1120_INT_GPIO_IOCFG, 		CC1120_IOCFG_GPIO_CFG_RX0TX1_CFG,
 };
 
 static const uint16_t packet_rx_setup[] = {
 	CC1120_PKT_CFG2,	((CC1120_PKT_CFG2_CCA_MODE_ALWAYS_CLEAR << CC1120_PKT_CFG2_CCA_MODE) |
 				 (CC1120_PKT_CFG2_PKT_FORMAT_SYNCHRONOUS_SERIAL << CC1120_PKT_CFG2_PKT_FORMAT)),
-	CC1120_IOCFG2, 		CC1120_IOCFG_GPIO_CFG_CLKEN_SOFT,
+	AO_CC1120_INT_GPIO_IOCFG, 		CC1120_IOCFG_GPIO_CFG_CLKEN_SOFT,
 };
 
 /*
@@ -455,10 +486,10 @@ ao_radio_set_mode(uint16_t new_mode)
 			ao_radio_reg_write(packet_tx_setup[i], packet_tx_setup[i+1]);
 		
 	if (changes & AO_RADIO_MODE_BITS_TX_BUF)
-		ao_radio_reg_write(CC1120_IOCFG2, CC1120_IOCFG_GPIO_CFG_TXFIFO_THR);
+		ao_radio_reg_write(AO_CC1120_INT_GPIO_IOCFG, CC1120_IOCFG_GPIO_CFG_TXFIFO_THR);
 
 	if (changes & AO_RADIO_MODE_BITS_TX_FINISH)
-		ao_radio_reg_write(CC1120_IOCFG2, CC1120_IOCFG_GPIO_CFG_RX0TX1_CFG);
+		ao_radio_reg_write(AO_CC1120_INT_GPIO_IOCFG, CC1120_IOCFG_GPIO_CFG_RX0TX1_CFG);
 
 	if (changes & AO_RADIO_MODE_BITS_PACKET_RX)
 		for (i = 0; i < sizeof (packet_rx_setup) / sizeof (packet_rx_setup[0]); i += 2)
@@ -551,9 +582,11 @@ ao_rdf_run(void)
 	ao_radio_start_tx();
 
 	ao_arch_block_interrupts();
-	while (!ao_radio_wake && !ao_radio_abort)
+	while (!ao_radio_wake && !ao_radio_abort && !ao_radio_mcu_wake)
 		ao_sleep(&ao_radio_wake);
 	ao_arch_release_interrupts();
+	if (ao_radio_mcu_wake)
+		ao_radio_check_marc_status();
 	if (!ao_radio_wake)
 		ao_radio_idle();
 	ao_radio_put();
@@ -644,13 +677,19 @@ ao_radio_test_cmd(void)
 }
 
 static void
-ao_radio_wait_isr(void)
+ao_radio_wait_isr(uint16_t timeout)
 {
-	ao_radio_wake = 0;
+	if (timeout)
+		ao_alarm(timeout);
 	ao_arch_block_interrupts();
-	while (!ao_radio_wake)
-		ao_sleep(&ao_radio_wake);
+	while (!ao_radio_wake && !ao_radio_mcu_wake && !ao_radio_abort)
+		if (ao_sleep(&ao_radio_wake))
+			ao_radio_abort = 1;
 	ao_arch_release_interrupts();
+	if (timeout)
+		ao_clear_alarm();
+	if (ao_radio_mcu_wake)
+		ao_radio_check_marc_status();
 }
 
 static uint8_t
@@ -659,11 +698,11 @@ ao_radio_wait_tx(uint8_t wait_fifo)
 	uint8_t	fifo_space = 0;
 
 	do {
-		ao_radio_wait_isr();
+		ao_radio_wait_isr(0);
 		if (!wait_fifo)
 			return 0;
 		fifo_space = ao_radio_tx_fifo_space();
-	} while (!fifo_space);
+	} while (!fifo_space && !ao_radio_abort);
 	return fifo_space;
 }
 
@@ -678,16 +717,23 @@ ao_radio_send(const void *d, uint8_t size)
 	uint8_t		this_len;
 	uint8_t		started = 0;
 	uint8_t		fifo_space;
+	uint8_t		q;
 
 	encode_len = ao_fec_encode(d, size, tx_data);
 
 	ao_radio_get(encode_len);
 
+	ao_radio_abort = 0;
+
+	/* Flush any pending TX bytes */
+	ao_radio_strobe(CC1120_SFTX);
+
 	started = 0;
 	fifo_space = CC1120_FIFO_SIZE;
 	while (encode_len) {
 		this_len = encode_len;
 
+		ao_radio_wake = 0;
 		if (this_len > fifo_space) {
 			this_len = fifo_space;
 			ao_radio_set_mode(AO_RADIO_MODE_PACKET_TX_BUF);
@@ -707,14 +753,20 @@ ao_radio_send(const void *d, uint8_t size)
 		}
 			
 		fifo_space = ao_radio_wait_tx(encode_len != 0);
+		if (ao_radio_abort) {
+			ao_radio_idle();
+			break;
+		}
 	}
+	while (started && !ao_radio_abort && !ao_radio_tx_finished)
+		ao_radio_wait_isr(0);
 	ao_radio_put();
 }
 
 #define AO_RADIO_LOTS	64
 
 void
-ao_radio_send_lots(ao_radio_fill_func fill)
+ao_radio_send_aprs(ao_radio_fill_func fill)
 {
 	uint8_t	buf[AO_RADIO_LOTS], *b;
 	int	cnt;
@@ -742,13 +794,12 @@ ao_radio_send_lots(ao_radio_fill_func fill)
 			uint8_t	this_len = cnt;
 
 			/* Wait for some space in the fifo */
-			while ((fifo_space = ao_radio_tx_fifo_space()) == 0) {
+			while (!ao_radio_abort && (fifo_space = ao_radio_tx_fifo_space()) == 0) {
 				ao_radio_wake = 0;
-				ao_arch_block_interrupts();
-				while (!ao_radio_wake)
-					ao_sleep(&ao_radio_wake);
-				ao_arch_release_interrupts();
+				ao_radio_wait_isr(0);
 			}
+			if (ao_radio_abort)
+				break;
 			if (this_len > fifo_space)
 				this_len = fifo_space;
 
@@ -771,8 +822,13 @@ ao_radio_send_lots(ao_radio_fill_func fill)
 			} else
 				ao_exti_enable(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN);
 		}
+		if (ao_radio_abort) {
+			ao_radio_idle();
+			break;
+		}
 		/* Wait for the transmitter to go idle */
-		ao_radio_wait_isr();
+		ao_radio_wake = 0;
+		ao_radio_wait_isr(0);
 	}
 	ao_radio_put();
 }
@@ -797,8 +853,8 @@ ao_radio_rx_isr(void)
 {
 	uint8_t	d;
 
-	d = stm_spi2.dr;
-	stm_spi2.dr = 0;
+	d = AO_CC1120_SPI.dr;
+	AO_CC1120_SPI.dr = 0;
 	if (rx_ignore == 0) {
 		if (rx_data_cur >= rx_data_count)
 			ao_exti_disable(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN);
@@ -822,14 +878,23 @@ ao_radio_rx_isr(void)
 static uint16_t
 ao_radio_rx_wait(void)
 {
-	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;
-	ao_arch_release_interrupts();
+	do {
+		if (ao_radio_mcu_wake)
+			ao_radio_check_marc_status();
+		ao_alarm(AO_MS_TO_TICKS(100));
+		ao_arch_block_interrupts();
+		rx_waiting = 1;
+		while (rx_data_cur - rx_data_consumed < AO_FEC_DECODE_BLOCK &&
+		       !ao_radio_abort &&
+		       !ao_radio_mcu_wake)
+		{
+			if (ao_sleep(&ao_radio_wake))
+				ao_radio_abort = 1;
+		}
+		rx_waiting = 0;
+		ao_arch_release_interrupts();
+		ao_clear_alarm();
+	} while (ao_radio_mcu_wake);
 	if (ao_radio_abort)
 		return 0;
 	rx_data_consumed += AO_FEC_DECODE_BLOCK;
@@ -840,7 +905,7 @@ ao_radio_rx_wait(void)
 }
 
 uint8_t
-ao_radio_recv(__xdata void *d, uint8_t size)
+ao_radio_recv(__xdata void *d, uint8_t size, uint8_t timeout)
 {
 	uint8_t		len;
 	uint16_t	i;
@@ -865,30 +930,53 @@ ao_radio_recv(__xdata void *d, uint8_t size)
 	rx_data_consumed = 0;
 	rx_ignore = 2;
 
+	/* Must be set before changing the frequency; any abort
+	 * after the frequency is set needs to terminate the read
+	 * so that the registers can be reprogrammed
+	 */
 	ao_radio_abort = 0;
-	ao_radio_in_recv = 1;
+
 	/* configure interrupt pin */
 	ao_radio_get(len);
 	ao_radio_set_mode(AO_RADIO_MODE_PACKET_RX);
 
 	ao_radio_wake = 0;
+	ao_radio_mcu_wake = 0;
 
-	stm_spi2.cr2 = 0;
+	AO_CC1120_SPI.cr2 = 0;
 
 	/* clear any RXNE */
-	(void) stm_spi2.dr;
+	(void) AO_CC1120_SPI.dr;
 
-	ao_exti_set_callback(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN, ao_radio_rx_isr);
+	/* Have the radio signal when the preamble quality goes high */
+	ao_radio_reg_write(AO_CC1120_INT_GPIO_IOCFG, CC1120_IOCFG_GPIO_CFG_PQT_REACHED);
+	ao_exti_set_mode(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN,
+			 AO_EXTI_MODE_RISING|AO_EXTI_PRIORITY_HIGH);
+	ao_exti_set_callback(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN, ao_radio_isr);
 	ao_exti_enable(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN);
+	ao_exti_enable(AO_CC1120_MCU_WAKEUP_PORT, AO_CC1120_MCU_WAKEUP_PIN);
 
 	ao_radio_strobe(CC1120_SRX);
 
+	/* Wait for the preamble to appear */
+	ao_radio_wait_isr(timeout);
+	if (ao_radio_abort)
+		goto abort;
+
+	ao_radio_reg_write(AO_CC1120_INT_GPIO_IOCFG, CC1120_IOCFG_GPIO_CFG_CLKEN_SOFT);
+	ao_exti_set_mode(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN,
+			 AO_EXTI_MODE_FALLING|AO_EXTI_PRIORITY_HIGH);
+
+	ao_exti_set_callback(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN, ao_radio_rx_isr);
+	ao_exti_enable(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN);
+
 	ao_radio_burst_read_start(CC1120_SOFT_RX_DATA_OUT);
 
 	ret = ao_fec_decode(rx_data, rx_data_count, d, size + 2, ao_radio_rx_wait);
 
 	ao_radio_burst_read_stop();
 
+abort:
 	ao_radio_strobe(CC1120_SIDLE);
 
 	/* Convert from 'real' rssi to cc1111-style values */
@@ -901,11 +989,6 @@ ao_radio_recv(__xdata void *d, uint8_t size)
 
 	((uint8_t *) d)[size] = (uint8_t) rssi;
 
-	ao_radio_in_recv = 0;
-
-	if (ao_radio_abort)
-		ao_delay(1);
-
 #if AO_PROFILE
 	rx_last_done_tick = rx_done_tick;
 	rx_done_tick = ao_profile_tick();
@@ -1125,7 +1208,7 @@ static void ao_radio_show(void) {
 	printf ("Status:   %02x\n", status);
 	printf ("CHIP_RDY: %d\n", (status >> CC1120_STATUS_CHIP_RDY) & 1);
 	printf ("STATE:    %s\n", cc1120_state_name[(status >> CC1120_STATUS_STATE) & CC1120_STATUS_STATE_MASK]);
-	printf ("MARC:     %02x\n", ao_radio_marc_status());
+	printf ("MARC:     %02x\n", ao_radio_get_marc_status());
 
 	for (i = 0; i < AO_NUM_CC1120_REG; i++)
 		printf ("\t%02x %-20.20s\n", ao_radio_reg_read(ao_cc1120_reg[i].addr), ao_cc1120_reg[i].name);
@@ -1133,7 +1216,7 @@ static void ao_radio_show(void) {
 }
 
 static void ao_radio_beep(void) {
-	ao_radio_rdf(RDF_PACKET_LEN);
+	ao_radio_rdf();
 }
 
 static void ao_radio_packet(void) {
@@ -1169,6 +1252,7 @@ ao_radio_test_recv()
 	}
 }
 
+#if HAS_APRS
 #include <ao_aprs.h>
 
 static void
@@ -1177,13 +1261,16 @@ ao_radio_aprs()
 	ao_packet_slave_stop();
 	ao_aprs_send();
 }
+#endif
 
 #endif
 
 static const struct ao_cmds ao_radio_cmds[] = {
 	{ ao_radio_test_cmd,	"C <1 start, 0 stop, none both>\0Radio carrier test" },
 #if CC1120_DEBUG
+#if HAS_APRS
 	{ ao_radio_aprs,	"G\0Send APRS packet" },
+#endif
 	{ ao_radio_show,	"R\0Show CC1120 status" },
 	{ ao_radio_beep,	"b\0Emit an RDF beacon" },
 	{ ao_radio_packet,	"p\0Send a test packet" },
@@ -1215,7 +1302,13 @@ ao_radio_init(void)
 	ao_enable_port(AO_CC1120_INT_PORT);
 	ao_exti_setup(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN,
 		      AO_EXTI_MODE_FALLING|AO_EXTI_PRIORITY_HIGH,
-		      ao_radio_tx_isr);
+		      ao_radio_isr);
+
+	/* Enable the hacked up GPIO3 pin */
+	ao_enable_port(AO_CC1120_MCU_WAKEUP_PORT);
+	ao_exti_setup(AO_CC1120_MCU_WAKEUP_PORT, AO_CC1120_MCU_WAKEUP_PIN,
+		      AO_EXTI_MODE_FALLING|AO_EXTI_PRIORITY_MED,
+		      ao_radio_mcu_wakeup_isr);
 
 	ao_cmd_register(&ao_radio_cmds[0]);
 }