osd-contiki/cpu/cc2430/dev/cc2430_rf.c
2012-12-16 19:28:55 +00:00

723 lines
17 KiB
C

/**
* \file
* CC2430 RF driver
* \author
* Zach Shelby <zach@sensinode.com> (Original)
* George Oikonomou - <oikonomou@users.sourceforge.net>
* (port to the netstack API, hexdump output, RX FIFO overflow fixes
* code cleanup, ...)
*
* bankable code for cc2430 rf driver. this code can be placed in any bank.
*
*/
#include <stdio.h>
#include "contiki.h"
#include "dev/radio.h"
#include "dev/cc2430_rf.h"
#include "cc2430_sfr.h"
#include "sys/clock.h"
#include "sys/rtimer.h"
#include "net/packetbuf.h"
#include "net/rime/rimestats.h"
#include "net/netstack.h"
#define CC2430_RF_TX_POWER_RECOMMENDED 0x5F
#ifdef CC2430_RF_CONF_TX_POWER
#define CC2430_RF_TX_POWER CC2430_RF_CONF_TX_POWER
#else
#define CC2430_RF_TX_POWER CC2430_RF_TX_POWER_RECOMMENDED
#endif
#ifdef CC2430_RF_CONF_CHANNEL
#define CC2430_RF_CHANNEL CC2430_RF_CONF_CHANNEL
#else
#define CC2430_RF_CHANNEL 18
#endif /* CC2430_RF_CONF_CHANNEL */
#define CC2430_CHANNEL_MIN 11
#define CC2430_CHANNEL_MAX 26
#ifdef CC2430_RF_CONF_AUTOACK
#define CC2430_RF_AUTOACK CC2430_RF_CONF_AUTOACK
#else
#define CC2430_RF_AUTOACK 1
#endif
#ifndef CC2430_CONF_CHECKSUM
#define CC2430_CONF_CHECKSUM 0
#endif /* CC2420_CONF_CHECKSUM */
#if CC2430_CONF_CHECKSUM
#include "lib/crc16.h"
#define CHECKSUM_LEN 2
#else
#define CHECKSUM_LEN 2
#endif /* CC2430_CONF_CHECKSUM */
#if DEBUG_LEDS
/* moved leds code to BANK1 to make space for cc2430_rf_process in HOME */
/* can't call code in BANK1 from alternate banks unless it is marked with __banked */
#include "dev/leds.h"
#define RF_RX_LED_ON() leds_on(LEDS_RED);
#define RF_RX_LED_OFF() leds_off(LEDS_RED);
#define RF_TX_LED_ON() leds_on(LEDS_GREEN);
#define RF_TX_LED_OFF() leds_off(LEDS_GREEN);
#else
#define RF_RX_LED_ON()
#define RF_RX_LED_OFF()
#define RF_TX_LED_ON()
#define RF_TX_LED_OFF()
#endif
#define DEBUG 0
#if DEBUG
#define PRINTF(...) printf(__VA_ARGS__)
#else
#define PRINTF(...) do {} while (0)
#endif
/* rf_flags bits */
#define RX_ACTIVE 0x80
#define TX_ACK 0x40
#define TX_ON_AIR 0x20
#define WAS_OFF 0x10
#define INITIALISED 0x01
#define RX_NO_DMA
/* Bits of the last byte in the RX FIFO */
#define CRC_BIT_MASK 0x80
#define LQI_BIT_MASK 0x7F
/* 192 ms, radio off -> on interval */
#define ONOFF_TIME ((RTIMER_ARCH_SECOND / 3125) + 4)
#if CC2430_RF_CONF_HEXDUMP
#include "uart1.h"
static const uint8_t magic[] = { 0x53, 0x6E, 0x69, 0x66 }; /* Snif */
#endif
#ifdef HAVE_RF_ERROR
uint8_t rf_error = 0;
#endif
/*---------------------------------------------------------------------------*/
#if !NETSTACK_CONF_SHORTCUTS
PROCESS(cc2430_rf_process, "CC2430 RF driver");
#endif
/*---------------------------------------------------------------------------*/
static uint8_t CC_AT_DATA rf_flags;
static uint8_t rf_channel;
static int on(void); /* prepare() needs our prototype */
static int off(void); /* transmit() needs our prototype */
static int channel_clear(void); /* transmit() needs our prototype */
/*---------------------------------------------------------------------------*/
/**
* Execute a single CSP command.
*
* \param command command to execute
*
*/
void
cc2430_rf_command(uint8_t command)
{
if(command >= 0xE0) { /*immediate strobe*/
uint8_t fifo_count;
switch (command) { /*hardware bug workaround*/
case ISRFOFF:
case ISRXON:
case ISTXON:
fifo_count = RXFIFOCNT;
RFST = command;
clock_delay_usec(2);
if(fifo_count != RXFIFOCNT) {
RFST = ISFLUSHRX;
RFST = ISFLUSHRX;
}
break;
default:
RFST = command;
}
} else if(command == SSTART) {
RFIF &= ~IRQ_CSP_STOP; /*clear IRQ flag*/
RFST = SSTOP; /*make sure there is a stop in the end*/
RFST = ISSTART; /*start execution*/
while((RFIF & IRQ_CSP_STOP) == 0);
} else {
RFST = command; /*write command*/
}
}
/*---------------------------------------------------------------------------*/
static void
flush_rx()
{
cc2430_rf_command(ISFLUSHRX);
cc2430_rf_command(ISFLUSHRX);
#if !NETSTACK_CONF_SHORTCUTS
IEN2 |= RFIE;
#endif
#if CC2430_RFERR_INTERRUPT
IEN0 |= RFERRIE;
#endif
RFIF &= ~IRQ_FIFOP;
}
/*---------------------------------------------------------------------------*/
/**
* Select RF channel.
*
* \param channel channel number to select
*
* \return channel value or negative (invalid channel number)
*/
/* channel freqdiv = (2048 + FSCTRL(9:0)) / 4
freq = (2048 + FSCTRL(9:0)) MHz */
int8_t
cc2430_rf_channel_set(uint8_t channel)
{
uint16_t freq;
if((channel < 11) || (channel > 26)) {
return -1;
}
cc2430_rf_command(ISSTOP); /*make sure CSP is not running*/
cc2430_rf_command(ISRFOFF);
/* Channel values: 11-26 */
freq = (uint16_t) channel - 11;
freq *= 5; /*channel spacing*/
freq += 357; /*correct channel range*/
freq |= 0x4000; /*LOCK_THR = 1*/
FSCTRLH = (freq >> 8);
FSCTRLL = (uint8_t)freq;
cc2430_rf_command(ISRXON);
rf_channel = channel;
return (int8_t) channel;
}
/*---------------------------------------------------------------------------*/
uint8_t
cc2430_rf_channel_get()
{
return rf_channel;
}
/*---------------------------------------------------------------------------*/
/**
* Select RF transmit power.
*
* \param new_power new power level
*
* \return new level
*/
uint8_t
cc2430_rf_power_set(uint8_t new_power)
{
/* Set transmitter power */
TXCTRLL = new_power;
return TXCTRLL;
}
/*---------------------------------------------------------------------------*/
#if 0 /* unused */
/**
* Enable RF transmitter.
*
*
* \return pdTRUE
* \return pdFALSE bus not free
*/
int
cc2430_rf_tx_enable(void)
{
DMAARM = 0x80 + (1 << 0); /*ABORT + channel bit*/
return 1;
}
#endif
/*---------------------------------------------------------------------------*/
/**
* Set MAC addresses
*
* \param pan The PAN address to set
* \param addr The short address to set
* \param ieee_addr The 64-bit IEEE address to set
*/
void
cc2430_rf_set_addr(unsigned pan, unsigned addr, const uint8_t *ieee_addr)
{
uint8_t f;
__xdata unsigned char *ptr;
PANIDH = pan >> 8;
PANIDL = pan & 0xff;
SHORTADDRH = addr >> 8;
SHORTADDRL = addr & 0xff;
if(ieee_addr != NULL) {
ptr = &IEEE_ADDR7;
/* LSB first, MSB last for 802.15.4 addresses in CC2420 */
for(f = 0; f < 8; f++) {
*ptr-- = ieee_addr[f];
}
}
}
#if 0 /* currently unused */
/*---------------------------------------------------------------------------*/
/**
* Channel energy detect.
*
* Coordinator use this function detect best channel for PAN-network.
* \return RSSI-energy level dBm.
* \return 0 operation failed.
*/
int8_t
cc2430_rf_analyze_rssi(void)
{
int8_t retval = -128;
/*pause_us(128);*/
retval = (int8_t)RSSIL;
retval -= 45;
return retval;
}
#endif /* currently unused */
/*---------------------------------------------------------------------------*/
/**
* Send ACK.
*
*\param pending set up pending flag if pending > 0.
*/
void
cc2430_rf_send_ack(uint8_t pending)
{
if(pending) {
cc2430_rf_command(ISACKPEND);
} else {
cc2430_rf_command(ISACK);
}
}
/*---------------------------------------------------------------------------*/
/* Netstack API radio driver functions */
/*---------------------------------------------------------------------------*/
static int
init(void)
{
if(rf_flags & INITIALISED) {
return 0;
}
PRINTF("cc2430_rf_init called\n");
RFPWR &= ~RREG_RADIO_PD; /*make sure it's powered*/
while((RFPWR & ADI_RADIO_PD) == 1);
while((RFIF & IRQ_RREG_ON) == 0); /*wait for power up*/
SLEEP &= ~OSC_PD; /*Osc on*/
while((SLEEP & XOSC_STB) == 0); /*wait for power up*/
rf_flags = 0;
FSMTC1 = 1; /*don't abort reception, if enable called, accept ack, auto rx after tx*/
MDMCTRL0H = 0x0A; /* Generic client, standard hysteresis, decoder on 0x0a */
MDMCTRL0L = 0xE2; /* automatic CRC, standard CCA and preamble 0xE2 */
#if CC2430_RF_AUTOACK
MDMCTRL0L |= 0x10;
#endif
MDMCTRL1H = 0x30; /* Defaults */
MDMCTRL1L = 0x0;
RXCTRL0H = 0x32; /* RX tuning optimized */
RXCTRL0L = 0xf5;
cc2430_rf_channel_set(CC2430_RF_CHANNEL);
cc2430_rf_command(ISFLUSHTX);
cc2430_rf_command(ISFLUSHRX);
/* Temporary values, main() will sort this out later on */
cc2430_rf_set_addr(0xffff, 0x0000, NULL);
RFIM = IRQ_FIFOP;
RFIF &= ~(IRQ_FIFOP);
S1CON &= ~(RFIF_0 | RFIF_1);
#if !NETSTACK_CONF_SHORTCUTS
IEN2 |= RFIE;
#endif
/* If contiki-conf.h turns on the RFERR interrupt, enable it here */
#if CC2430_RFERR_INTERRUPT
IEN0 |= RFERRIE;
#endif
RF_TX_LED_OFF();
RF_RX_LED_OFF();
rf_flags |= INITIALISED;
#if !NETSTACK_CONF_SHORTCUTS
process_start(&cc2430_rf_process, NULL);
#endif
cc2430_rf_power_set(CC2430_RF_TX_POWER);
return 1;
}
/*---------------------------------------------------------------------------*/
static int
prepare(const void *payload, unsigned short payload_len)
{
uint8_t i;
/*
* When we transmit in very quick bursts, make sure previous transmission
* is not still in progress before re-writing in the TX FIFO
*/
while(RFSTATUS & TX_ACTIVE);
if(rf_flags & TX_ACK) {
return -1;
}
if((rf_flags & RX_ACTIVE) == 0) {
on();
}
PRINTF("cc2430_rf: sending %u byte payload\n", payload_len);
cc2430_rf_command(ISFLUSHTX);
PRINTF("cc2430_rf: data = ");
/* Send the phy length byte first */
RFD = payload_len + CHECKSUM_LEN; /* Payload plus FCS */
PRINTF("(%d)", payload_len + CHECKSUM_LEN);
for(i = 0; i < payload_len; i++) {
RFD = ((unsigned char *)(payload))[i];
PRINTF("%02X", ((unsigned char *)(payload))[i]);
}
PRINTF("\n");
/* Leave space for the FCS */
RFD = 0;
RFD = 0;
return 0;
}
/*---------------------------------------------------------------------------*/
static int
transmit(unsigned short transmit_len)
{
uint8_t counter;
int ret = RADIO_TX_ERR;
if(!(rf_flags & RX_ACTIVE)) {
on();
rf_flags |= WAS_OFF;
}
if(channel_clear() == CC2430_CCA_BUSY) {
RIMESTATS_ADD(contentiondrop);
return RADIO_TX_COLLISION;
}
/*
* prepare() double checked that TX_ACTIVE is low. If SFD is high we are
* receiving. Abort transmission and bail out with RADIO_TX_COLLISION
*/
if(RFSTATUS & SFD) {
RIMESTATS_ADD(contentiondrop);
return RADIO_TX_COLLISION;
}
/* Start the transmission */
ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
ENERGEST_ON(ENERGEST_TYPE_TRANSMIT);
cc2430_rf_command(ISTXON);
counter = 0;
while(!(RFSTATUS & TX_ACTIVE) && (counter++ < 3)) {
clock_delay_usec(6);
}
if(!(RFSTATUS & TX_ACTIVE)) {
PRINTF("cc2430_rf: TX never active.\n");
cc2430_rf_command(ISFLUSHTX);
ret = RADIO_TX_ERR;
} else {
/* Wait for the transmission to finish */
while(RFSTATUS & TX_ACTIVE);
RF_RX_LED_OFF();
RF_TX_LED_ON();
ret = RADIO_TX_OK;
// rf_flags |= TX_ON_AIR;
}
ENERGEST_OFF(ENERGEST_TYPE_TRANSMIT);
ENERGEST_ON(ENERGEST_TYPE_LISTEN);
if(rf_flags & WAS_OFF) {
off();
}
RIMESTATS_ADD(lltx);
/* OK, sent. We are now ready to send more */
return ret;
}
/*---------------------------------------------------------------------------*/
static int
send(void *payload, unsigned short payload_len)
{
prepare(payload, payload_len);
return transmit(payload_len);
}
/*---------------------------------------------------------------------------*/
static int
read(void *buf, unsigned short bufsize)
{
uint8_t i;
uint8_t len;
uint8_t crc_corr;
int8_t rssi;
#if CC2420_CONF_CHECKSUM
uint16_t checksum;
#endif /* CC2420_CONF_CHECKSUM */
/* Don't interrupt us while emptying the FIFO */
#if !NETSTACK_CONF_SHORTCUTS
IEN2 &= ~RFIE;
#endif
#if CC2430_RFERR_INTERRUPT
IEN0 &= ~RFERRIE;
#endif
/* RX interrupt polled the cc2430_rf_process, now read the RX FIFO */
/* Check the length */
len = RFD;
/* Check for validity */
if(len > CC2430_MAX_PACKET_LEN) {
/* Oops, we must be out of sync. */
PRINTF("error: bad sync\n");
RIMESTATS_ADD(badsynch);
flush_rx();
return 0;
}
if(len <= CC2430_MIN_PACKET_LEN) {
PRINTF("error: too short\n");
RIMESTATS_ADD(tooshort);
flush_rx();
return 0;
}
if(len - CHECKSUM_LEN > bufsize) {
PRINTF("error: too long\n");
RIMESTATS_ADD(toolong);
flush_rx();
return 0;
}
#if CC2430_RF_CONF_HEXDUMP
/* If we reach here, chances are the FIFO is holding a valid frame */
uart1_writeb(magic[0]);
uart1_writeb(magic[1]);
uart1_writeb(magic[2]);
uart1_writeb(magic[3]);
uart1_writeb(len);
#endif
PRINTF("cc2430_rf: read = ");
PRINTF("(%d)", len);
len -= CHECKSUM_LEN;
for(i = 0; i < len; ++i) {
((unsigned char *)(buf))[i] = RFD;
#if CC2430_RF_CONF_HEXDUMP
uart1_writeb(((unsigned char *)(buf))[i]);
#endif
PRINTF("%02X", ((unsigned char *)(buf))[i]);
}
PRINTF("\n");
#if CC2430_CONF_CHECKSUM
/* Deal with the checksum */
checksum = RFD * 256;
checksum += RFD;
#endif /* CC2430_CONF_CHECKSUM */
/* Read the RSSI and CRC/Corr bytes */
rssi = ((int8_t) RFD) - 45;
crc_corr = RFD;
#if CC2430_RF_CONF_HEXDUMP
uart1_writeb(rssi);
uart1_writeb(crc_corr);
#endif
/* MS bit CRC OK/Not OK, 7 LS Bits, Correlation value */
if(crc_corr & CRC_BIT_MASK) {
packetbuf_set_attr(PACKETBUF_ATTR_RSSI, rssi);
packetbuf_set_attr(PACKETBUF_ATTR_LINK_QUALITY, crc_corr & LQI_BIT_MASK);
RIMESTATS_ADD(llrx);
} else {
RIMESTATS_ADD(badcrc);
flush_rx();
return 0;
}
/* If FIFOP==1 and FIFO==0 then we had a FIFO overflow at some point. */
if((RFSTATUS & (FIFO | FIFOP)) == FIFOP) {
/*
* If we reach here means that there might be more intact packets in the
* FIFO despite the overflow. This can happen with bursts of small packets.
*
* Only flush if the FIFO is actually empty. If not, then next pass we will
* pick up one more packet or flush due to an error.
*/
if(!RXFIFOCNT) {
flush_rx();
}
}
RF_RX_LED_OFF();
#if !NETSTACK_CONF_SHORTCUTS
IEN2 |= RFIE;
#endif
#if CC2430_RFERR_INTERRUPT
IEN0 |= RFERRIE;
#endif
RFIF &= ~IRQ_FIFOP;
return (len);
}
/*---------------------------------------------------------------------------*/
static int
channel_clear(void)
{
if(!(RFSTATUS & CCA)) {
return CC2430_CCA_BUSY;
}
return CC2430_CCA_CLEAR;
}
/*---------------------------------------------------------------------------*/
static int
receiving_packet(void)
{
/*
* SFD high while transmitting and receiving.
* TX_ACTIVE high only when transmitting
*
* RFSTATUS & (TX_ACTIVE | SFD) == SFD <=> receiving
*/
return (RFSTATUS & (TX_ACTIVE | SFD) == SFD);
}
/*---------------------------------------------------------------------------*/
static int
pending_packet(void)
{
return (RFSTATUS & FIFOP);
}
/*---------------------------------------------------------------------------*/
/**
* Enable RF receiver.
*
*
* \return pdTRUE
* \return pdFALSE bus not free
*/
static int
on(void)
{
rtimer_clock_t t0;
PRINTF("cc2430_rf_rx_enable called\n");
if(!(rf_flags & RX_ACTIVE)) {
t0 = RTIMER_NOW();
rf_flags |= RX_ACTIVE;
IOCFG0 = 0x7f; /* Set the FIFOP threshold 127 */
RSSIH = 0xd2; /* -84dbm = 0xd2 default, 0xe0 -70 dbm */
RFPWR &= ~RREG_RADIO_PD; /* make sure it's powered */
while((RFIF & IRQ_RREG_ON) == 0); /* wait for power up */
/* Make sure the RREG On Interrupt Flag is 0 next time we get called */
RFIF &= ~IRQ_RREG_ON;
cc2430_rf_command(ISRXON);
cc2430_rf_command(ISFLUSHRX);
while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + ONOFF_TIME));
}
PRINTF("cc2430_rf_rx_enable done\n");
ENERGEST_ON(ENERGEST_TYPE_LISTEN);
return 1;
}
/*---------------------------------------------------------------------------*/
/**
* Disable RF receiver.
*
*
* \return pdTRUE
* \return pdFALSE bus not free
*/
static int
off(void)
{
cc2430_rf_command(ISSTOP); /* make sure CSP is not running */
cc2430_rf_command(ISRFOFF);
RFPWR |= RREG_RADIO_PD; /* RF powerdown */
/* Clear the RREG On Interrupt Flag */
RFIF &= ~IRQ_RREG_ON;
rf_flags &= ~RX_ACTIVE;
rf_flags &= ~WAS_OFF;
ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
return 1;
}
/*---------------------------------------------------------------------------*/
const struct radio_driver cc2430_rf_driver = {
init,
prepare,
transmit,
send,
read,
channel_clear,
receiving_packet,
pending_packet,
on,
off,
};
/*---------------------------------------------------------------------------*/
#if !NETSTACK_CONF_SHORTCUTS
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(cc2430_rf_process, ev, data)
{
int len;
PROCESS_BEGIN();
while(1) {
PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_POLL);
packetbuf_clear();
len = read(packetbuf_dataptr(), PACKETBUF_SIZE);
if(len > 0) {
packetbuf_set_datalen(len);
NETSTACK_RDC.input();
}
}
PROCESS_END();
}
#endif
/*---------------------------------------------------------------------------*/