deac/osd-contiki
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
osd-contiki/cpu/cc26xx/dev/cc26xx-rf.c
Billy Kozak 99d74e949f CC26xx autoflush bad crc packets 
Setting bAutoFlushCrc=1 so that the radio co-processor will
automatically drop packets with bad crc.
2015-07-16 08:58:24 -06:00

2148 lines
67 KiB
C
Raw Blame History

/*
* Copyright (c) 2014, Texas Instruments Incorporated - http://www.ti.com/
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*---------------------------------------------------------------------------*/
/**
* \addtogroup cc26xx-rf
* @{
*
* \file
* Implementation of the CC26xx RF driver
*/
/*---------------------------------------------------------------------------*/
#include "contiki.h"
#include "dev/radio.h"
#include "dev/cc26xx-rf.h"
#include "dev/oscillators.h"
#include "net/packetbuf.h"
#include "net/rime/rimestats.h"
#include "net/linkaddr.h"
#include "net/netstack.h"
#include "sys/energest.h"
#include "sys/clock.h"
#include "sys/rtimer.h"
#include "sys/cc.h"
#include "lpm.h"
#include "ti-lib.h"
/*---------------------------------------------------------------------------*/
/* RF core and RF HAL API */
#include "hw_rfc_dbell.h"
#include "hw_rfc_pwr.h"
/*---------------------------------------------------------------------------*/
/* RF Core Mailbox API */
#include "mailbox.h"
#include "common_cmd.h"
#include "common_cmd_field.h"
#include "ble_cmd.h"
#include "ble_cmd_field.h"
#include "ieee_cmd.h"
#include "ieee_cmd_field.h"
#include "data_entry.h"
#include "ble_mailbox.h"
#include "ieee_mailbox.h"
/*---------------------------------------------------------------------------*/
#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include <stdbool.h>
/*---------------------------------------------------------------------------*/
#define BUSYWAIT_UNTIL(cond, max_time) \
do { \
rtimer_clock_t t0; \
t0 = RTIMER_NOW(); \
while(!(cond) && RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + (max_time))); \
} while(0)
/*---------------------------------------------------------------------------*/
#ifdef __GNUC__
#define CC_ALIGN_ATTR(n) __attribute__ ((aligned(n)))
#else
#define CC_ALIGN_ATTR(n)
#endif
/*---------------------------------------------------------------------------*/
#define DEBUG 0
#if DEBUG
#define PRINTF(...) printf(__VA_ARGS__)
#else
#define PRINTF(...)
#endif
/*---------------------------------------------------------------------------*/
/* Data entry status field constants */
#define DATA_ENTRY_STATUS_PENDING 0x00 /* Not in use by the Radio CPU */
#define DATA_ENTRY_STATUS_ACTIVE 0x01 /* Open for r/w by the radio CPU */
#define DATA_ENTRY_STATUS_BUSY 0x02 /* Ongoing r/w */
#define DATA_ENTRY_STATUS_FINISHED 0x03 /* Free to use and to free */
#define DATA_ENTRY_STATUS_UNFINISHED 0x04 /* Partial RX entry */
/*---------------------------------------------------------------------------*/
/* RF stats data structure */
static uint8_t rf_stats[16] = { 0 };
/*---------------------------------------------------------------------------*/
/* RF Command status constants - Correspond to values in the CMDSTA register */
#define RF_CMD_STATUS_PENDING 0x00
#define RF_CMD_STATUS_DONE 0x01
#define RF_CMD_STATUS_ILLEGAL_PTR 0x81
#define RF_CMD_STATUS_UNKNOWN_CMD 0x82
#define RF_CMD_STATUS_UNKNOWN_DIR_CMD 0x83
#define RF_CMD_STATUS_CONTEXT_ERR 0x85
#define RF_CMD_STATUS_SCHEDULING_ERR 0x86
#define RF_CMD_STATUS_PAR_ERR 0x87
#define RF_CMD_STATUS_QUEUE_ERR 0x88
#define RF_CMD_STATUS_QUEUE_BUSY 0x89
/* Status values starting with 0x8 correspond to errors */
#define RF_CMD_STATUS_ERR_MASK 0x80
/* Return values for rf_send_cmd_ok */
#define RF_CMD_ERROR 0
#define RF_CMD_OK 1
/* The size of the RF commands buffer */
#define RF_CMD_BUFFER_SIZE 128
/*---------------------------------------------------------------------------*/
/* RF Radio Op status constants. Field 'status' in Radio Op command struct */
#define RF_RADIO_OP_STATUS_IDLE 0x0000
#define RF_RADIO_OP_STATUS_PENDING 0x0001
#define RF_RADIO_OP_STATUS_ACTIVE 0x0002
#define RF_RADIO_OP_STATUS_SKIPPED 0x0003
#define RF_RADIO_OP_STATUS_DONE_OK 0x0400
#define RF_RADIO_OP_STATUS_DONE_COUNTDOWN 0x0401
#define RF_RADIO_OP_STATUS_DONE_RXERR 0x0402
#define RF_RADIO_OP_STATUS_DONE_TIMEOUT 0x0403
#define RF_RADIO_OP_STATUS_DONE_STOPPED 0x0404
#define RF_RADIO_OP_STATUS_DONE_ABORT 0x0405
#define RF_RADIO_OP_STATUS_ERROR_PAST_START 0x0800
#define RF_RADIO_OP_STATUS_ERROR_START_TRIG 0x0801
#define RF_RADIO_OP_STATUS_ERROR_CONDITION 0x0802
#define RF_RADIO_OP_STATUS_ERROR_PAR 0x0803
#define RF_RADIO_OP_STATUS_ERROR_POINTER 0x0804
#define RF_RADIO_OP_STATUS_ERROR_CMDID 0x0805
#define RF_RADIO_OP_STATUS_ERROR_NO_SETUP 0x0807
#define RF_RADIO_OP_STATUS_ERROR_NO_FS 0x0808
#define RF_RADIO_OP_STATUS_ERROR_SYNTH_PROG 0x0809
/* Additional Op status values for IEEE mode */
#define RF_RADIO_OP_STATUS_IEEE_SUSPENDED 0x2001
#define RF_RADIO_OP_STATUS_IEEE_DONE_OK 0x2400
#define RF_RADIO_OP_STATUS_IEEE_DONE_BUSY 0x2401
#define RF_RADIO_OP_STATUS_IEEE_DONE_STOPPED 0x2402
#define RF_RADIO_OP_STATUS_IEEE_DONE_ACK 0x2403
#define RF_RADIO_OP_STATUS_IEEE_DONE_ACKPEND 0x2404
#define RF_RADIO_OP_STATUS_IEEE_DONE_TIMEOUT 0x2405
#define RF_RADIO_OP_STATUS_IEEE_DONE_BGEND 0x2406
#define RF_RADIO_OP_STATUS_IEEE_DONE_ABORT 0x2407
#define RF_RADIO_OP_STATUS_ERROR_WRONG_BG 0x0806
#define RF_RADIO_OP_STATUS_IEEE_ERROR_PAR 0x2800
#define RF_RADIO_OP_STATUS_IEEE_ERROR_NO_SETUP 0x2801
#define RF_RADIO_OP_STATUS_IEEE_ERROR_NO_FS 0x2802
#define RF_RADIO_OP_STATUS_IEEE_ERROR_SYNTH_PROG 0x2803
#define RF_RADIO_OP_STATUS_IEEE_ERROR_RXOVF 0x2804
#define RF_RADIO_OP_STATUS_IEEE_ERROR_TXUNF 0x2805
/* Op status values for BLE mode */
#define RF_RADIO_OP_STATUS_BLE_DONE_OK 0x1400
#define RF_RADIO_OP_STATUS_BLE_DONE_RXTIMEOUT 0x1401
#define RF_RADIO_OP_STATUS_BLE_DONE_NOSYNC 0x1402
#define RF_RADIO_OP_STATUS_BLE_DONE_RXERR 0x1403
#define RF_RADIO_OP_STATUS_BLE_DONE_CONNECT 0x1404
#define RF_RADIO_OP_STATUS_BLE_DONE_MAXNACK 0x1405
#define RF_RADIO_OP_STATUS_BLE_DONE_ENDED 0x1406
#define RF_RADIO_OP_STATUS_BLE_DONE_ABORT 0x1407
#define RF_RADIO_OP_STATUS_BLE_DONE_STOPPED 0x1408
#define RF_RADIO_OP_STATUS_BLE_ERROR_PAR 0x1800
#define RF_RADIO_OP_STATUS_BLE_ERROR_RXBUF 0x1801
#define RF_RADIO_OP_STATUS_BLE_ERROR_NO_SETUP 0x1802
#define RF_RADIO_OP_STATUS_BLE_ERROR_NO_FS 0x1803
#define RF_RADIO_OP_STATUS_BLE_ERROR_SYNTH_PROG 0x1804
#define RF_RADIO_OP_STATUS_BLE_ERROR_RXOVF 0x1805
#define RF_RADIO_OP_STATUS_BLE_ERROR_TXUNF 0x1806
/* Bits 15:12 signify the protocol */
#define RF_RADIO_OP_STATUS_PROTO_MASK 0xF000
#define RF_RADIO_OP_STATUS_PROTO_GENERIC 0x0000
#define RF_RADIO_OP_STATUS_PROTO_BLE 0x1000
#define RF_RADIO_OP_STATUS_PROTO_IEEE 0x2000
#define RF_RADIO_OP_STATUS_PROTO_PROP 0x3000
/* Bits 11:10 signify Running / Done OK / Done with error */
#define RF_RADIO_OP_MASKED_STATUS 0x0C00
#define RF_RADIO_OP_MASKED_STATUS_RUNNING 0x0000
#define RF_RADIO_OP_MASKED_STATUS_DONE 0x0400
#define RF_RADIO_OP_MASKED_STATUS_ERROR 0x0800
/*---------------------------------------------------------------------------*/
/**
* \brief Returns the current status of a running Radio Op command
* \param a A pointer with the buffer used to initiate the command
* \return The value of the Radio Op buffer's status field
*
* This macro can be used to e.g. return the status of a previously
* initiated background operation, or of an immediate command
*/
#define RF_RADIO_OP_GET_STATUS(a) GET_FIELD_V(a, radioOp, status)
/*---------------------------------------------------------------------------*/
/* Special value returned by CMD_IEEE_CCA_REQ when an RSSI is not available */
#define RF_CMD_CCA_REQ_RSSI_UNKNOWN -128
/* Used for the return value of channel_clear */
#define RF_CCA_CLEAR 1
#define RF_CCA_BUSY 0
/* Used as an error return value for get_cca_info */
#define RF_GET_CCA_INFO_ERROR 0xFF
/*
* Values of the individual bits of the ccaInfo field in CMD_IEEE_CCA_REQ's
* status struct
*/
#define RF_CMD_CCA_REQ_CCA_STATE_IDLE 0 /* 00 */
#define RF_CMD_CCA_REQ_CCA_STATE_BUSY 1 /* 01 */
#define RF_CMD_CCA_REQ_CCA_STATE_INVALID 2 /* 10 */
/*---------------------------------------------------------------------------*/
#define RF_MODE_BLE 0
#define RF_MODE_IEEE 1
/*---------------------------------------------------------------------------*/
/* How long to wait for an ongoing ACK TX to finish before starting frame TX */
#define TX_WAIT_TIMEOUT (RTIMER_SECOND >> 11)
/* How long to wait for the RF to enter RX in rf_cmd_ieee_rx */
#define ENTER_RX_WAIT_TIMEOUT (RTIMER_SECOND >> 10)
/*---------------------------------------------------------------------------*/
/* TX Power dBm lookup table - values from SmartRF Studio */
typedef struct output_config {
radio_value_t dbm;
uint8_t register_ib;
uint8_t register_gc;
} output_config_t;
static const output_config_t output_power[] = {
{ 5, 0x29, 0x00 },
{ 4, 0x20, 0x00 },
{ 3, 0x19, 0x00 },
{ 2, 0x25, 0x01 },
{ 1, 0x21, 0x01 },
{ 0, 0x1D, 0x01 },
{ -3, 0x19, 0x03 },
{ -6, 0x13, 0x03 },
{ -9, 0x0F, 0x03 },
};
#define OUTPUT_CONFIG_COUNT (sizeof(output_power) / sizeof(output_config_t))
/* Max and Min Output Power in dBm */
#define OUTPUT_POWER_MIN (output_power[OUTPUT_CONFIG_COUNT - 1].dbm)
#define OUTPUT_POWER_MAX (output_power[0].dbm)
#define OUTPUT_POWER_UNKNOWN 0xFFFF
/* Default TX Power - position in output_power[] */
#define CC26XX_RF_TX_POWER 0
const output_config_t *tx_power_current = &output_power[0];
/*---------------------------------------------------------------------------*/
#define RF_CORE_CLOCKS_MASK (RFC_PWR_PWMCLKEN_RFC_M | RFC_PWR_PWMCLKEN_CPE_M \
| RFC_PWR_PWMCLKEN_CPERAM_M)
/*---------------------------------------------------------------------------*/
/* RF interrupts */
#define RX_IRQ IRQ_IEEE_RX_ENTRY_DONE
#define TX_ACK_IRQ IRQ_IEEE_TX_ACK
#define ERROR_IRQ IRQ_INTERNAL_ERROR
/* Those IRQs are enabled all the time */
#define ENABLED_IRQS (RX_IRQ + ERROR_IRQ)
/*
* We only enable this right before starting frame TX, so we can sleep while
* the TX is ongoing
*/
#define LAST_FG_CMD_DONE IRQ_LAST_FG_COMMAND_DONE
#define cc26xx_rf_cpe0_isr RFCCPE0IntHandler
#define cc26xx_rf_cpe1_isr RFCCPE1IntHandler
/*---------------------------------------------------------------------------*/
/*
* Buffers used to send commands to the RF core (generic and IEEE commands).
* Some of those buffers are re-usable, some are not.
*
* If you are uncertain, declare a new buffer.
*/
/*
* A buffer to send a CMD_IEEE_RX and to subsequently monitor its status
* Do not use this buffer for any commands other than CMD_IEEE_RX
*/
static uint8_t cmd_ieee_rx_buf[RF_CMD_BUFFER_SIZE] CC_ALIGN_ATTR(4);
/*
* A buffer used to send immediate and foreground Radio Op (e.g. CMD_IEEE_TX)
* commands.
*
* Do not re-use this buffer to send a command before the previous command
* has been completed.
*
* Do not intermingle preparation of this buffer to send a command with calls
* that might lead to a different command, since the latter will overwrite what
* you have written in preparation for the former.
*/
static uint8_t cmd_immediate_buf[RF_CMD_BUFFER_SIZE] CC_ALIGN_ATTR(4);
/*---------------------------------------------------------------------------*/
/* BLE macros, variables and buffers */
/* BLE Intervals: Send a burst of advertisements every BLE_ADV_INTERVAL secs */
#define BLE_ADV_INTERVAL (CLOCK_SECOND * 5)
#define BLE_ADV_DUTY_CYCLE (CLOCK_SECOND / 10)
#define BLE_ADV_MESSAGES 10
/* BLE Advertisement-related macros */
#define BLE_ADV_TYPE_DEVINFO 0x01
#define BLE_ADV_TYPE_NAME 0x09
#define BLE_ADV_TYPE_MANUFACTURER 0xFF
#define BLE_ADV_NAME_BUF_LEN 32
#define BLE_ADV_PAYLOAD_BUF_LEN 64
#define BLE_UUID_SIZE 16
#if CC26XX_RF_BLE_SUPPORT
/* BLE buffers / variables */
static unsigned char ble_cmd_buf[32] CC_ALIGN_ATTR(4) = { 0 };
static unsigned char ble_tx_rx_buf[128] CC_ALIGN_ATTR(4);
static uint8_t ble_mode_on;
/* BLE beacond config */
static struct ble_beacond_config {
clock_time_t interval;
char adv_name[BLE_ADV_NAME_BUF_LEN];
} beacond_config;
/* BLE overrides */
static uint32_t ble_overrides[] = {
0x00364038, /* Synth: Set RTRIM (POTAILRESTRIM) to 6 */
0x000784A3, /* Synth: Set FREF = 3.43 MHz (24 MHz / 7) */
0xA47E0583, /* Synth: Set loop bandwidth after lock to 80 kHz (K2) */
0xEAE00603, /* Synth: Set loop bandwidth after lock to 80 kHz (K3, LSB) */
0x00010623, /* Synth: Set loop bandwidth after lock to 80 kHz (K3, MSB) */
0x00456088, /* Adjust AGC reference level */
0xFFFFFFFF, /* End of override list */
};
PROCESS(cc26xx_rf_ble_beacon_process, "CC26xx RF BLE Beacon Process");
static void init_ble(void);
#else
#define init_ble(...)
#endif /* CC26XX_RF_BLE_SUPPORT */
/*---------------------------------------------------------------------------*/
#define RX_BUF_SIZE 140
/* Four receive buffers entries with room for 1 IEEE802.15.4 frame in each */
static uint8_t rx_buf_0[RX_BUF_SIZE] CC_ALIGN_ATTR(4);
static uint8_t rx_buf_1[RX_BUF_SIZE] CC_ALIGN_ATTR(4);
static uint8_t rx_buf_2[RX_BUF_SIZE] CC_ALIGN_ATTR(4);
static uint8_t rx_buf_3[RX_BUF_SIZE] CC_ALIGN_ATTR(4);
/* The RX Data Queue */
static dataQueue_t rx_data_queue = { 0 };
/* Receive entry pointer to keep track of read items */
volatile static uint8_t *rx_read_entry;
/*---------------------------------------------------------------------------*/
/* The outgoing frame buffer */
#define TX_BUF_SIZE 180
static uint8_t tx_buf[TX_BUF_SIZE];
/*---------------------------------------------------------------------------*/
/* Overrides for IEEE 802.15.4, differential mode */
static uint32_t ieee_overrides[] = {
0x00354038, /* Synth: Set RTRIM (POTAILRESTRIM) to 5 */
0x4001402D, /* Synth: Correct CKVD latency setting (address) */
0x00608402, /* Synth: Correct CKVD latency setting (value) */
0x4001405D, /* Synth: Set ANADIV DIV_BIAS_MODE to PG1 (address) */
0x1801F800, /* Synth: Set ANADIV DIV_BIAS_MODE to PG1 (value) */
0x000784A3, /* Synth: Set FREF = 3.43 MHz (24 MHz / 7) */
0xA47E0583, /* Synth: Set loop bandwidth after lock to 80 kHz (K2) */
0xEAE00603, /* Synth: Set loop bandwidth after lock to 80 kHz (K3, LSB) */
0x00010623, /* Synth: Set loop bandwidth after lock to 80 kHz (K3, MSB) */
0x002B50DC, /* Adjust AGC DC filter */
0x05000243, /* Increase synth programming timeout */
0x002082C3, /* Increase synth programming timeout */
0xFFFFFFFF, /* End of override list */
};
/*---------------------------------------------------------------------------*/
PROCESS(cc26xx_rf_process, "CC26xx RF driver");
/*---------------------------------------------------------------------------*/
static int on(void);
static int off(void);
static void setup_interrupts(void);
/*---------------------------------------------------------------------------*/
static uint8_t
rf_is_accessible(void)
{
if(ti_lib_prcm_rf_ready() &&
ti_lib_prcm_power_domain_status(PRCM_DOMAIN_RFCORE) ==
PRCM_DOMAIN_POWER_ON) {
return 1;
}
return 0;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Sends a command to the RF core.
*
* \param cmd The command value or a pointer to a command buffer
* \param status A pointer to a variable which will hold the status
* \return RF_CMD_OK or RF_CMD_ERROR
*
* This function supports all three types of command (Radio OP, immediate and
* direct)
*
* For immediate and Radio OPs, cmd is a pointer to the data structure
* containing the command and its parameters. This data structure must be
* 4-byte aligned.
*
* For direct commands, cmd contains the value of the command alongside its
* parameters
*
* The caller is responsible of allocating and populating cmd for Radio OP and
* immediate commands
*
* The caller is responsible for allocating status
*/
static uint_fast8_t
rf_send_cmd(uint32_t cmd, uint32_t *status)
{
uint32_t timeout_count = 0;
bool interrupts_disabled;
/*
* Make sure ContikiMAC doesn't turn us off from within an interrupt while
* we are accessing RF Core registers
*/
interrupts_disabled = ti_lib_int_master_disable();
if(!rf_is_accessible()) {
PRINTF("rf_send_cmd: RF was off\n");
if(!interrupts_disabled) {
ti_lib_int_master_enable();
}
return RF_CMD_ERROR;
}
HWREG(RFC_DBELL_BASE + RFC_DBELL_O_CMDR) = cmd;
do {
*status = HWREG(RFC_DBELL_BASE + RFC_DBELL_O_CMDSTA);
if(++timeout_count > 50000) {
PRINTF("rf_send_cmd: Timeout\n");
if(!interrupts_disabled) {
ti_lib_int_master_enable();
}
return RF_CMD_ERROR;
}
} while(*status == RF_CMD_STATUS_PENDING);
if(!interrupts_disabled) {
ti_lib_int_master_enable();
}
/*
* If we reach here the command is no longer pending. It is either completed
* successfully or with error
*/
return *status == RF_CMD_STATUS_DONE;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Checks whether the RFC domain is accessible and the RFC is in IEEE RX
* \return 1: RFC in RX mode (and therefore accessible too). 0 otherwise
*/
static uint8_t
rf_is_on(void)
{
if(!rf_is_accessible()) {
return 0;
}
return RF_RADIO_OP_GET_STATUS(cmd_ieee_rx_buf) == RF_RADIO_OP_STATUS_ACTIVE;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Check the RF's TX status
* \return 1 RF is transmitting
* \return 0 RF is not transmitting
*
* TX mode may be triggered either by a CMD_IEEE_TX or by the automatic
* transmission of an ACK frame.
*/
static uint8_t
transmitting(void)
{
uint32_t cmd_status;
/* If we are off, we are not in TX */
if(!rf_is_accessible()) {
return 0;
}
memset(cmd_immediate_buf, 0x00, SIZEOF_STRUCT(CMD_IEEE_CCA_REQ));
GET_FIELD(cmd_immediate_buf, command, commandNo) = CMD_IEEE_CCA_REQ;
if(rf_send_cmd((uint32_t)cmd_immediate_buf, &cmd_status) == RF_CMD_ERROR) {
PRINTF("transmitting: CMDSTA=0x%08lx, status=0x%04x\n",
cmd_status, RF_RADIO_OP_GET_STATUS(cmd_immediate_buf));
return 0;
}
if((GET_FIELD(cmd_immediate_buf, CMD_IEEE_CCA_REQ, currentRssi)
== RF_CMD_CCA_REQ_RSSI_UNKNOWN) &&
(GET_BITFIELD(cmd_immediate_buf, CMD_IEEE_CCA_REQ, ccaInfo, ccaEnergy)
== RF_CMD_CCA_REQ_CCA_STATE_BUSY)) {
return 1;
}
return 0;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Returns CCA information
* \return RF_GET_CCA_INFO_ERROR if the RF was not on
* \return On success, the return value is formatted as per the ccaInfo field
* of CMD_IEEE_CCA_REQ
*
* It is the caller's responsibility to make sure the RF is on. This function
* will return RF_GET_CCA_INFO_ERROR if the RF is off
*
* This function will in fact wait for a valid RSSI signal
*/
static uint8_t
get_cca_info(void)
{
uint32_t cmd_status;
int8_t rssi;
if(!rf_is_on()) {
PRINTF("get_cca_info: Not on\n");
return RF_GET_CCA_INFO_ERROR;
}
rssi = RF_CMD_CCA_REQ_RSSI_UNKNOWN;
while(rssi == RF_CMD_CCA_REQ_RSSI_UNKNOWN || rssi == 0) {
memset(cmd_immediate_buf, 0x00, SIZEOF_STRUCT(CMD_IEEE_CCA_REQ));
GET_FIELD(cmd_immediate_buf, command, commandNo) = CMD_IEEE_CCA_REQ;
if(rf_send_cmd((uint32_t)cmd_immediate_buf, &cmd_status) == RF_CMD_ERROR) {
PRINTF("get_cca_info: CMDSTA=0x%08lx, status=0x%04x\n",
cmd_status, RF_RADIO_OP_GET_STATUS(cmd_immediate_buf));
return RF_GET_CCA_INFO_ERROR;
}
rssi = GET_FIELD(cmd_immediate_buf, CMD_IEEE_CCA_REQ, currentRssi);
}
/* We have a valid RSSI signal. Return the CCA Info */
return GET_FIELD(cmd_immediate_buf, CMD_IEEE_CCA_REQ, ccaInfo);
}
/*---------------------------------------------------------------------------*/
/**
* \brief Reads the current signal strength (RSSI)
* \return The current RSSI in dBm or CMD_GET_RSSI_UNKNOWN
*
* This function reads the current RSSI on the currently configured
* channel.
*/
static radio_value_t
get_rssi(void)
{
uint32_t cmd_status;
int8_t rssi;
uint8_t was_off = 0;
/* If we are off, turn on first */
if(!rf_is_on()) {
was_off = 1;
if(on() != RF_CMD_OK) {
PRINTF("get_rssi: on() failed\n");
return RF_CMD_CCA_REQ_RSSI_UNKNOWN;
}
}
memset(cmd_immediate_buf, 0x00, SIZEOF_STRUCT(CMD_GET_RSSI));
GET_FIELD(cmd_immediate_buf, command, commandNo) = CMD_GET_RSSI;
if(rf_send_cmd((uint32_t)cmd_immediate_buf, &cmd_status) == RF_CMD_ERROR) {
rssi = RF_CMD_CCA_REQ_RSSI_UNKNOWN;
}
/* Current RSSI in bits 23:16 of cmd_status */
rssi = (cmd_status >> 16) & 0xFF;
/* If we were off, turn back off */
if(was_off) {
off();
}
return rssi;
}
/*---------------------------------------------------------------------------*/
/* Returns the current TX power in dBm */
static radio_value_t
get_tx_power(void)
{
return tx_power_current->dbm;
}
/*---------------------------------------------------------------------------*/
/*
* Set TX power to 'at least' power dBm
* This works with a lookup table. If the value of 'power' does not exist in
* the lookup table, TXPOWER will be set to the immediately higher available
* value
*/
static void
set_tx_power(radio_value_t power)
{
uint32_t cmd_status;
int i;
/* Send a CMD_SET_TX_POWER command to the RF */
memset(cmd_immediate_buf, 0x00, SIZEOF_STRUCT(CMD_SET_TX_POWER));
GET_FIELD(cmd_immediate_buf, command, commandNo) = CMD_SET_TX_POWER;
for(i = OUTPUT_CONFIG_COUNT - 1; i >= 0; --i) {
if(power <= output_power[i].dbm) {
GET_FIELD(cmd_immediate_buf, CMD_SET_TX_POWER, txPower) =
BITVALUE(CMD_SET_TX_POWER, txPower, IB, output_power[i].register_ib) |
BITVALUE(CMD_SET_TX_POWER, txPower, GC, output_power[i].register_gc) |
BITVALUE(CMD_SET_TX_POWER, txPower, tempCoeff, 0);
if(rf_send_cmd((uint32_t)cmd_immediate_buf, &cmd_status) == RF_CMD_OK) {
/* Success: Remember the new setting */
tx_power_current = &output_power[i];
} else {
PRINTF("set_tx_power: CMDSTA=0x%08lx\n", cmd_status);
}
return;
}
}
}
/*---------------------------------------------------------------------------*/
/**
* \brief Wait till running radio Op command completes
*
* \return RF_CMD_ERROR or RF_CMD_OK
*
* RF_CMD_OK will be returned if the Radio Op returned with
* RF_RADIO_OP_STATUS_DONE_OK
*
* RF_CMD_ERROR will be returned in the radio op returned with any other
* RF_RADIO_OP_STATUS_DONE_xyz
*/
static uint_fast8_t
rf_wait_cmd_completed_ok(uint8_t *cmd)
{
_TYPE_radioOp_status tmp_status;
uint32_t timeoutCount = 0;
/*
* 0x04XX=DONE, 0x0400=DONE_OK while all other "DONE" values means done
* but with some kind of error (ref. "Common radio operation status codes")
*/
do {
tmp_status = GET_FIELD_V(cmd, radioOp, status);
if(++timeoutCount > 500000) {
return RF_CMD_ERROR;
}
} while((tmp_status & RF_RADIO_OP_MASKED_STATUS) != RF_RADIO_OP_MASKED_STATUS_DONE);
return tmp_status == RF_RADIO_OP_STATUS_DONE_OK;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Builds common radio parameters for radio operations
*
* \param *cmd Pointer to buffer to add parameters to
* \param command Radio command number (e.g. COMMAND_RADIO_SETUP)
*
* \note The buffer must be emptied with memset() before calling this function
*
* \return None
*/
static void
rf_build_radio_op_cmd(uint8_t *cmd, uint16_t command)
{
GET_FIELD(cmd, radioOp, commandNo) = command;
GET_FIELD(cmd, radioOp, status) = IDLE;
GET_FIELD(cmd, radioOp, pNextOp) = NULL;
GET_FIELD(cmd, radioOp, startTime) = 0;
GET_FIELD(cmd, radioOp, startTrigger) = TRIG_NOW;
GET_FIELD(cmd, radioOp, condition) = COND_NEVER;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Sends a CMD_RADIO_SETUP for the selected mode (IEEE or BLE)
* \param mode RF_MODE_BLE or RF_MODE_IEEE
* \return RF_CMD_OK or RF_CMD_ERROR
*
* ToDo: Likely to need one more argument to set bNoAdi<foo> on first startup
* vs when coming back from sleep
*/
static uint8_t
rf_radio_setup(uint8_t mode)
{
uint32_t cmd_status;
/* Create radio setup command */
memset(cmd_immediate_buf, 0x00, SIZEOF_RADIO_OP(CMD_RADIO_SETUP));
rf_build_radio_op_cmd(cmd_immediate_buf, CMD_RADIO_SETUP);
/* Set output power to the current (or default) value */
GET_FIELD(cmd_immediate_buf, CMD_RADIO_SETUP, txPower) =
BITVALUE(CMD_RADIO_SETUP, txPower, IB, tx_power_current->register_ib) |
BITVALUE(CMD_RADIO_SETUP, txPower, GC, tx_power_current->register_gc) |
BITVALUE(CMD_RADIO_SETUP, txPower, tempCoeff, 0);
/* Do mode-dependent things (e.g. apply overrides) */
if(mode == RF_MODE_IEEE) {
/* Add override control pointer */
GET_FIELD(cmd_immediate_buf, CMD_RADIO_SETUP, pRegOverride) = ieee_overrides;
#if CC26XX_RF_BLE_SUPPORT
} else if(mode == RF_MODE_BLE) {
/* Add override control pointer */
GET_FIELD(cmd_immediate_buf, CMD_RADIO_SETUP, pRegOverride) = ble_overrides;
#endif
} else {
PRINTF("rf_radio_setup: Unknown mode %u\n", mode);
return RF_CMD_ERROR;
}
/* Lastly, set the mode */
GET_FIELD(cmd_immediate_buf, CMD_RADIO_SETUP, mode) = mode;
/* Send Radio setup to RF Core */
if(rf_send_cmd((uint32_t)cmd_immediate_buf, &cmd_status) != RF_CMD_OK) {
PRINTF("rf_radio_setup: CMD_RADIO_SETUP, CMDSTA=0x%08lx, status=0x%04x\n",
cmd_status, RF_RADIO_OP_GET_STATUS(cmd_immediate_buf));
return RF_CMD_ERROR;
}
/* Wait until radio setup is done */
if(rf_wait_cmd_completed_ok(cmd_immediate_buf) != RF_CMD_OK) {
PRINTF("rf_radio_setup: CMD_RADIO_SETUP wait, CMDSTA=0x%08lx, status=0x%04x\n",
cmd_status, RF_RADIO_OP_GET_STATUS(cmd_immediate_buf));
return RF_CMD_ERROR;
}
return RF_CMD_OK;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Applies patches (if any)
* \return RF_CMD_OK or RF_CMD_ERROR
*
* Currently patches are not required.
*/
static uint8_t
apply_patches()
{
uint32_t cmd_status;
/* Patch of uninitialized pointer */
*((uint32_t *)0x21000028) = 0x00000000;
/* Start radio timer (RAT) */
if(rf_send_cmd(CMDR_DIR_CMD(CMD_START_RAT), &cmd_status) != RF_CMD_OK) {
PRINTF("apply_patches: START_RAT fail, CMDSTA=0x%08lx\n", cmd_status);
return RF_CMD_ERROR;
}
return RF_CMD_OK;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Set up radio in IEEE802.15.4 RX mode
*
* \return RF_CMD_OK Succeeded
* \return RF_CMD_ERROR Failed
*
* This function assumes that cmd_ieee_rx_buf has been previously populated
* with correct values. This can be done through init_rf_params (sets defaults)
* or through Contiki's extended RF API (set_value, set_object)
*/
static uint8_t
rf_cmd_ieee_rx()
{
uint32_t cmd_status;
rtimer_clock_t t0;
int ret;
ret = rf_send_cmd((uint32_t)cmd_ieee_rx_buf, &cmd_status);
if(ret != RF_CMD_OK) {
PRINTF("rf_cmd_ieee_rx: ret=%d, CMDSTA=0x%08lx, status=0x%04x\n",
ret, cmd_status, RF_RADIO_OP_GET_STATUS(cmd_ieee_rx_buf));
}
t0 = RTIMER_NOW();
while(RF_RADIO_OP_GET_STATUS(cmd_ieee_rx_buf) != RF_RADIO_OP_STATUS_ACTIVE &&
(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + ENTER_RX_WAIT_TIMEOUT)));
/* Wait to enter RX */
if(RF_RADIO_OP_GET_STATUS(cmd_ieee_rx_buf) != RF_RADIO_OP_STATUS_ACTIVE) {
PRINTF("rf_cmd_ieee_rx: CMDSTA=0x%08lx, status=0x%04x\n",
cmd_status, RF_RADIO_OP_GET_STATUS(cmd_ieee_rx_buf));
return RF_CMD_ERROR;
}
return ret;
}
/*---------------------------------------------------------------------------*/
static void
init_rx_buffers(void)
{
/* Two-element circular buffer, hardcoded for now.. */
GET_FIELD(rx_buf_0, dataEntry, pNextEntry) = rx_buf_1;
GET_FIELD(rx_buf_0, dataEntry, config) = 0x04;
GET_FIELD(rx_buf_0, dataEntry, length) = sizeof(rx_buf_0) - 8;
GET_FIELD(rx_buf_1, dataEntry, pNextEntry) = rx_buf_2;
GET_FIELD(rx_buf_1, dataEntry, config) = 0x04;
GET_FIELD(rx_buf_1, dataEntry, length) = sizeof(rx_buf_1) - 8;
GET_FIELD(rx_buf_2, dataEntry, pNextEntry) = rx_buf_3;
GET_FIELD(rx_buf_2, dataEntry, config) = 0x04;
GET_FIELD(rx_buf_2, dataEntry, length) = sizeof(rx_buf_2) - 8;
/* Point to first element again */
GET_FIELD(rx_buf_3, dataEntry, pNextEntry) = rx_buf_0;
GET_FIELD(rx_buf_3, dataEntry, config) = 0x04;
GET_FIELD(rx_buf_3, dataEntry, length) = sizeof(rx_buf_3) - 8;
}
/*---------------------------------------------------------------------------*/
static void
init_rf_params(void)
{
memset(cmd_ieee_rx_buf, 0x00, SIZEOF_RADIO_OP(CMD_IEEE_RX));
GET_FIELD(cmd_ieee_rx_buf, radioOp, commandNo) = CMD_IEEE_RX;
GET_FIELD(cmd_ieee_rx_buf, radioOp, status) = IDLE;
GET_FIELD(cmd_ieee_rx_buf, radioOp, pNextOp) = NULL;
GET_FIELD(cmd_ieee_rx_buf, radioOp, startTime) = 0x00000000;
GET_FIELD(cmd_ieee_rx_buf, radioOp, startTrigger) = TRIG_NOW;
GET_FIELD(cmd_ieee_rx_buf, radioOp, condition) = COND_NEVER;
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, channel) = CC26XX_RF_CHANNEL;
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, rxConfig) =
BITVALUE(CMD_IEEE_RX, rxConfig, bAutoFlushCrc, 1) |
BITVALUE(CMD_IEEE_RX, rxConfig, bAutoFlushIgn, 0) |
BITVALUE(CMD_IEEE_RX, rxConfig, bIncludePhyHdr, 0) |
BITVALUE(CMD_IEEE_RX, rxConfig, bIncludeCrc, 1) |
BITVALUE(CMD_IEEE_RX, rxConfig, bAppendRssi, 1) |
BITVALUE(CMD_IEEE_RX, rxConfig, bAppendCorrCrc, 1) |
BITVALUE(CMD_IEEE_RX, rxConfig, bAppendSrcInd, 0) |
BITVALUE(CMD_IEEE_RX, rxConfig, bAppendTimestamp, 0);
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, pRxQ) = &rx_data_queue;
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, pOutput) = rf_stats;
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, frameFiltOpt) =
#if CC26XX_RF_CONF_PROMISCOUS
BITVALUE(CMD_IEEE_RX, frameFiltOpt, frameFiltEn, 0) |
#else
BITVALUE(CMD_IEEE_RX, frameFiltOpt, frameFiltEn, 1) |
#endif
BITVALUE(CMD_IEEE_RX, frameFiltOpt, frameFiltStop, 1) |
#if CC26XX_RF_CONF_AUTOACK
BITVALUE(CMD_IEEE_RX, frameFiltOpt, autoAckEn, 1) |
#else
BITVALUE(CMD_IEEE_RX, frameFiltOpt, autoAckEn, 0) |
#endif
BITVALUE(CMD_IEEE_RX, frameFiltOpt, slottedAckEn, 0) |
BITVALUE(CMD_IEEE_RX, frameFiltOpt, autoPendEn, 0) |
BITVALUE(CMD_IEEE_RX, frameFiltOpt, defaultPend, 0) |
BITVALUE(CMD_IEEE_RX, frameFiltOpt, bPendDataReqOnly, 0) |
BITVALUE(CMD_IEEE_RX, frameFiltOpt, bPanCoord, 0) |
BITVALUE(CMD_IEEE_RX, frameFiltOpt, maxFrameVersion, 1) |
BITVALUE(CMD_IEEE_RX, frameFiltOpt, bStrictLenFilter, 0);
/* Receive all frame types */
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, frameTypes) =
BITVALUE(CMD_IEEE_RX, frameTypes, bAcceptFt0Beacon, 1) |
BITVALUE(CMD_IEEE_RX, frameTypes, bAcceptFt1Data, 1) |
BITVALUE(CMD_IEEE_RX, frameTypes, bAcceptFt2Ack, 1) |
BITVALUE(CMD_IEEE_RX, frameTypes, bAcceptFt3MacCmd, 1) |
BITVALUE(CMD_IEEE_RX, frameTypes, bAcceptFt4Reserved, 1) |
BITVALUE(CMD_IEEE_RX, frameTypes, bAcceptFt5Reserved, 1) |
BITVALUE(CMD_IEEE_RX, frameTypes, bAcceptFt6Reserved, 1) |
BITVALUE(CMD_IEEE_RX, frameTypes, bAcceptFt7Reserved, 1);
/* Configure CCA settings */
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, ccaOpt) =
BITVALUE(CMD_IEEE_RX, ccaOpt, ccaEnEnergy, 1) |
BITVALUE(CMD_IEEE_RX, ccaOpt, ccaEnCorr, 1) |
BITVALUE(CMD_IEEE_RX, ccaOpt, ccaEnSync, 0) |
BITVALUE(CMD_IEEE_RX, ccaOpt, ccaCorrOp, 1) |
BITVALUE(CMD_IEEE_RX, ccaOpt, ccaSyncOp, 1) |
BITVALUE(CMD_IEEE_RX, ccaOpt, ccaCorrThr, 3);
/* Set CCA RSSI Threshold, 0xA6 corresponds to -90dBm (two's comp.)*/
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, ccaRssiThr) = 0xA6;
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, numExtEntries) = 0x00;
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, numShortEntries) = 0x00;
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, pExtEntryList) = 0;
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, pShortEntryList) = 0;
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, endTrigger) = TRIG_NEVER;
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, endTime) = 0x00000000;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Turn on power to the RFC and boot it.
*
* \return RF_CMD_OK or RF_CMD_ERROR
*/
static int
power_up(void)
{
uint32_t cmd_status;
bool interrupts_disabled = ti_lib_int_master_disable();
ti_lib_int_pend_clear(INT_RF_CPE0);
ti_lib_int_pend_clear(INT_RF_CPE1);
ti_lib_int_disable(INT_RF_CPE0);
ti_lib_int_disable(INT_RF_CPE1);
/* Enable RF Core power domain */
ti_lib_prcm_power_domain_on(PRCM_DOMAIN_RFCORE);
while(ti_lib_prcm_power_domain_status(PRCM_DOMAIN_RFCORE)
!= PRCM_DOMAIN_POWER_ON);
ti_lib_prcm_domain_enable(PRCM_DOMAIN_RFCORE);
ti_lib_prcm_load_set();
while(!ti_lib_prcm_load_get());
while(!rf_is_accessible()) {
PRINTF("power_up: Not ready\n");
}
HWREG(RFC_DBELL_NONBUF_BASE + RFC_DBELL_O_RFCPEIFG) = 0x0;
HWREG(RFC_DBELL_NONBUF_BASE + RFC_DBELL_O_RFCPEIEN) = 0x0;
ti_lib_int_enable(INT_RF_CPE0);
ti_lib_int_enable(INT_RF_CPE1);
if(!interrupts_disabled) {
ti_lib_int_master_enable();
}
/* Let CPE boot */
HWREG(RFC_PWR_NONBUF_BASE + RFC_PWR_O_PWMCLKEN) = RF_CORE_CLOCKS_MASK;
/* Send ping (to verify RFCore is ready and alive) */
if(rf_send_cmd(CMDR_DIR_CMD(CMD_PING), &cmd_status) != RF_CMD_OK) {
PRINTF("power_up: CMD_PING fail, CMDSTA=0x%08lx\n", cmd_status);
return RF_CMD_ERROR;
}
return RF_CMD_OK;
}
/*---------------------------------------------------------------------------*/
/**
* \brief Disable RFCORE clock domain in the MCU VD and turn off the RFCORE PD
*/
static void
power_down(void)
{
bool interrupts_disabled = ti_lib_int_master_disable();
ti_lib_int_disable(INT_RF_CPE0);
ti_lib_int_disable(INT_RF_CPE1);
if(rf_is_accessible()) {
HWREG(RFC_DBELL_NONBUF_BASE + RFC_DBELL_O_RFCPEIFG) = 0x0;
HWREG(RFC_DBELL_NONBUF_BASE + RFC_DBELL_O_RFCPEIEN) = 0x0;
}
/* Shut down the RFCORE clock domain in the MCU VD */
ti_lib_prcm_domain_disable(PRCM_DOMAIN_RFCORE);
ti_lib_prcm_load_set();
while(!ti_lib_prcm_load_get());
/* Turn off RFCORE PD */
ti_lib_prcm_power_domain_off(PRCM_DOMAIN_RFCORE);
while(ti_lib_prcm_power_domain_status(PRCM_DOMAIN_RFCORE)
!= PRCM_DOMAIN_POWER_OFF);
ti_lib_int_pend_clear(INT_RF_CPE0);
ti_lib_int_pend_clear(INT_RF_CPE1);
ti_lib_int_enable(INT_RF_CPE0);
ti_lib_int_enable(INT_RF_CPE1);
if(!interrupts_disabled) {
ti_lib_int_master_enable();
}
}
/*---------------------------------------------------------------------------*/
static int
rx_on(void)
{
int ret;
/* Get status of running IEEE_RX (if any) */
if(rf_is_on()) {
PRINTF("rx_on: We were on. PD=%u, RX=0x%04x \n", rf_is_accessible(),
RF_RADIO_OP_GET_STATUS(cmd_ieee_rx_buf));
return RF_CMD_OK;
}
/* Put CPE in RX using the currently configured parameters */
ret = rf_cmd_ieee_rx();
if(ret) {
ENERGEST_ON(ENERGEST_TYPE_LISTEN);
}
return ret;
}
/*---------------------------------------------------------------------------*/
static int
rx_off(void)
{
uint32_t cmd_status;
int ret;
/* If we are off, do nothing */
if(!rf_is_on()) {
return RF_CMD_OK;
}
/* Wait for ongoing ACK TX to finish */
while(transmitting());
/* Send a CMD_STOP command to RF Core */
if(rf_send_cmd(CMDR_DIR_CMD(CMD_ABORT), &cmd_status) != RF_CMD_OK) {
PRINTF("RX off: CMD_ABORT status=0x%08lx\n", cmd_status);
/* Continue nonetheless */
}
while(rf_is_on());
if(RF_RADIO_OP_GET_STATUS(cmd_ieee_rx_buf) == IEEE_DONE_STOPPED ||
RF_RADIO_OP_GET_STATUS(cmd_ieee_rx_buf) == IEEE_DONE_ABORT) {
/* Stopped gracefully */
ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
ret = RF_CMD_OK;
} else {
PRINTF("RX off: BG status=0x%04x\n", RF_RADIO_OP_GET_STATUS(cmd_ieee_rx_buf));
ret = RF_CMD_ERROR;
}
return ret;
}
/*---------------------------------------------------------------------------*/
static void
rx_isr(void)
{
process_poll(&cc26xx_rf_process);
}
/*---------------------------------------------------------------------------*/
void
cc26xx_rf_cpe1_isr(void)
{
ENERGEST_ON(ENERGEST_TYPE_IRQ);
ti_lib_int_master_disable();
PRINTF("RF Error\n");
if(!rf_is_accessible()) {
if(power_up() != RF_CMD_OK) {
return;
}
}
/* Clear interrupt flags */
HWREG(RFC_DBELL_NONBUF_BASE + RFC_DBELL_O_RFCPEIFG) = 0x0;
ti_lib_int_master_enable();
ENERGEST_OFF(ENERGEST_TYPE_IRQ);
}
/*---------------------------------------------------------------------------*/
void
cc26xx_rf_cpe0_isr(void)
{
ENERGEST_ON(ENERGEST_TYPE_IRQ);
if(!rf_is_accessible()) {
printf("RF ISR called but RF not ready... PANIC!!\n");
if(power_up() != RF_CMD_OK) {
PRINTF("power_up() failed\n");
return;
}
}
ti_lib_int_master_disable();
if(HWREG(RFC_DBELL_NONBUF_BASE + RFC_DBELL_O_RFCPEIFG) & RX_IRQ) {
rx_isr();
}
/* Clear interrupt flags */
HWREG(RFC_DBELL_NONBUF_BASE + RFC_DBELL_O_RFCPEIFG) = 0x0;
ti_lib_int_master_enable();
ENERGEST_OFF(ENERGEST_TYPE_IRQ);
}
/*---------------------------------------------------------------------------*/
static void
setup_interrupts(void)
{
bool interrupts_disabled;
/* We are already turned on by the caller, so this should not happen */
if(!rf_is_accessible()) {
PRINTF("setup_interrupts: No access\n");
return;
}
/* Disable interrupts */
interrupts_disabled = ti_lib_int_master_disable();
/* Set all interrupt channels to CPE0 channel, error to CPE1 */
HWREG(RFC_DBELL_NONBUF_BASE + RFC_DBELL_O_RFCPEISL) = ERROR_IRQ;
/* Acknowledge TX_Frame, Rx_Entry_Done and ERROR */
HWREG(RFC_DBELL_NONBUF_BASE + RFC_DBELL_O_RFCPEIEN) = ENABLED_IRQS;
/* Clear interrupt flags, active low clear(?) */
HWREG(RFC_DBELL_NONBUF_BASE + RFC_DBELL_O_RFCPEIFG) = 0x0;
ti_lib_int_pend_clear(INT_RF_CPE0);
ti_lib_int_pend_clear(INT_RF_CPE1);
ti_lib_int_enable(INT_RF_CPE0);
ti_lib_int_enable(INT_RF_CPE1);
if(!interrupts_disabled) {
ti_lib_int_master_enable();
}
}
/*---------------------------------------------------------------------------*/
static uint8_t
request(void)
{
/*
* We rely on the RDC layer to turn us on and off. Thus, if we are on we
* will only allow sleep, standby otherwise
*/
if(rf_is_on()) {
return LPM_MODE_SLEEP;
}
return LPM_MODE_MAX_SUPPORTED;
}
/*---------------------------------------------------------------------------*/
LPM_MODULE(cc26xx_rf_lpm_module, request, NULL, NULL, LPM_DOMAIN_NONE);
/*---------------------------------------------------------------------------*/
static int
init(void)
{
lpm_register_module(&cc26xx_rf_lpm_module);
/* Enable IEEE, BLE and Common-CMD APIs */
HWREG(PRCM_BASE + PRCM_O_RFCMODESEL) = PRCM_RFCMODESEL_CURR_MODE5;
/* Wipe out the BLE adv buffer */
init_ble();
/* Initialise RX buffers */
memset(rx_buf_0, 0, RX_BUF_SIZE);
memset(rx_buf_1, 0, RX_BUF_SIZE);
memset(rx_buf_2, 0, RX_BUF_SIZE);
memset(rx_buf_3, 0, RX_BUF_SIZE);
/* Set of RF Core data queue. Circular buffer, no last entry */
rx_data_queue.pCurrEntry = rx_buf_0;
rx_data_queue.pLastEntry = NULL;
/* Initialize current read pointer to first element (used in ISR) */
rx_read_entry = rx_buf_0;
/* Populate the RF parameters data structure with default values */
init_rf_params();
if(on() != RF_CMD_OK) {
PRINTF("init: on() failed\n");
return RF_CMD_ERROR;
}
ENERGEST_ON(ENERGEST_TYPE_LISTEN);
process_start(&cc26xx_rf_process, NULL);
return 1;
}
/*---------------------------------------------------------------------------*/
static int
prepare(const void *payload, unsigned short payload_len)
{
int len = MIN(payload_len, sizeof(tx_buf));
memcpy(tx_buf, payload, len);
return RF_CMD_OK;
}
/*---------------------------------------------------------------------------*/
static int
transmit(unsigned short transmit_len)
{
int ret;
uint8_t was_off = 0;
uint32_t cmd_status;
uint16_t stat;
uint8_t tx_active = 0;
rtimer_clock_t t0;
if(!rf_is_on()) {
was_off = 1;
if(on() != RF_CMD_OK) {
PRINTF("transmit: on() failed\n");
return RF_CMD_ERROR;
}
}
/*
* We are certainly not TXing a frame as a result of CMD_IEEE_TX, but we may
* be in the process of TXing an ACK. In that case, wait for the TX to finish
* or return after approx TX_WAIT_TIMEOUT
*/
t0 = RTIMER_NOW();
do {
tx_active = transmitting();
} while(tx_active == 1 &&
(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + TX_WAIT_TIMEOUT)));
if(tx_active) {
PRINTF("transmit: Already TXing and wait timed out\n");
if(was_off) {
off();
}
return RADIO_TX_COLLISION;
}
/* Send the CMD_IEEE_TX command */
memset(cmd_immediate_buf, 0, SIZEOF_RADIO_OP(CMD_IEEE_TX));
rf_build_radio_op_cmd(cmd_immediate_buf, CMD_IEEE_TX);
GET_FIELD(cmd_immediate_buf, CMD_IEEE_TX, payloadLen) = transmit_len;
GET_FIELD(cmd_immediate_buf, CMD_IEEE_TX, pPayload) = tx_buf;
/* Enable the LAST_FG_COMMAND_DONE interrupt, which will wake us up */
HWREG(RFC_DBELL_NONBUF_BASE + RFC_DBELL_O_RFCPEIEN) = ENABLED_IRQS +
LAST_FG_CMD_DONE;
ret = rf_send_cmd((uint32_t)cmd_immediate_buf, &cmd_status);
if(ret) {
/* If we enter here, TX actually started */
ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
ENERGEST_ON(ENERGEST_TYPE_TRANSMIT);
/* Idle away while the command is running */
while((RF_RADIO_OP_GET_STATUS(cmd_immediate_buf) & RF_RADIO_OP_MASKED_STATUS)
== RF_RADIO_OP_MASKED_STATUS_RUNNING) {
lpm_sleep();
}
stat = RF_RADIO_OP_GET_STATUS(cmd_immediate_buf);
if(stat == RF_RADIO_OP_STATUS_IEEE_DONE_OK) {
/* Sent OK */
RIMESTATS_ADD(lltx);
ret = RADIO_TX_OK;
} else {
/* Operation completed, but frame was not sent */
PRINTF("transmit: ret=%d, CMDSTA=0x%08lx, status=0x%04x\n", ret,
cmd_status, stat);
ret = RADIO_TX_ERR;
}
} else {
/* Failure sending the CMD_IEEE_TX command */
PRINTF("transmit: ret=%d, CMDSTA=0x%08lx, status=0x%04x\n",
ret, cmd_status, RF_RADIO_OP_GET_STATUS(cmd_immediate_buf));
ret = RADIO_TX_ERR;
}
/*
* Update ENERGEST state here, before a potential call to off(), which
* will correctly update it if required.
*/
ENERGEST_OFF(ENERGEST_TYPE_TRANSMIT);
ENERGEST_ON(ENERGEST_TYPE_LISTEN);
/*
* Disable LAST_FG_COMMAND_DONE interrupt. We don't really care about it
* except when we are transmitting
*/
HWREG(RFC_DBELL_NONBUF_BASE + RFC_DBELL_O_RFCPEIEN) = ENABLED_IRQS;
return ret;
}
/*---------------------------------------------------------------------------*/
static int
send(const void *payload, unsigned short payload_len)
{
prepare(payload, payload_len);
return transmit(payload_len);
}
/*---------------------------------------------------------------------------*/
static int
read_frame(void *buf, unsigned short buf_len)
{
int len = 0;
if(GET_FIELD_V(rx_read_entry, dataEntry, status) == DATA_ENTRY_STATUS_FINISHED) {
/* Set status to 0 "Pending" in element */
GET_FIELD_V(rx_read_entry, dataEntry, status) = DATA_ENTRY_STATUS_PENDING;
if(rx_read_entry[8] > 0) {
memcpy(buf, (char *)&rx_read_entry[9], buf_len);
/* Remove the footer */
len = MIN(buf_len, rx_read_entry[8] - 4);
int rssi = (int8_t)rx_read_entry[9 + len + 2];
packetbuf_set_attr(PACKETBUF_ATTR_RSSI, rssi);
RIMESTATS_ADD(llrx);
/* Clear the length byte */
rx_read_entry[8] = 0;
}
/* Move read entry pointer to next entry */
rx_read_entry = GET_FIELD_V(rx_read_entry, dataEntry, pNextEntry);
}
return len;
}
/*---------------------------------------------------------------------------*/
static int
channel_clear(void)
{
uint8_t was_off = 0;
uint8_t cca_info;
int ret = RF_CCA_CLEAR;
/*
* If we are in the middle of a BLE operation, we got called by ContikiMAC
* from within an interrupt context. Indicate a clear channel
*/
#if CC26XX_RF_BLE_SUPPORT
if(ble_mode_on) {
PRINTF("channel_clear: Interrupt context but BLE in progress\n");
return RF_CCA_CLEAR;
}
#endif
if(rf_is_on()) {
/*
* Wait for potential leftover ACK still being sent.
* Strictly speaking, if we are TXing an ACK then the channel is not clear.
* However, channel_clear is only ever called to determine whether there is
* someone else's packet in the air, not ours.
*
* We could probably even simply return that the channel is clear
*/
while(transmitting());
} else {
was_off = 1;
if(on() != RF_CMD_OK) {
PRINTF("channel_clear: on() failed\n");
if(was_off) {
off();
}
return RF_CCA_CLEAR;
}
}
cca_info = get_cca_info();
if(cca_info == RF_GET_CCA_INFO_ERROR) {
PRINTF("channel_clear: CCA error\n");
ret = RF_CCA_CLEAR;
} else {
/*
* cca_info bits 1:0 - ccaStatus
* Return 1 (clear) if idle or invalid.
*/
ret = (cca_info & 0x03) != RF_CMD_CCA_REQ_CCA_STATE_BUSY;
}
if(was_off) {
off();
}
return ret;
}
/*---------------------------------------------------------------------------*/
static int
receiving_packet(void)
{
int ret = 0;
uint8_t cca_info;
uint8_t was_off = 0;
if(!rf_is_on()) {
was_off = 1;
if(on() != RF_CMD_OK) {
PRINTF("receiving_packet: on() failed\n");
return RF_CMD_ERROR;
}
}
/*
* If we are in the middle of a BLE operation, we got called by ContikiMAC
* from within an interrupt context. We are not receiving
*/
#if CC26XX_RF_BLE_SUPPORT
if(ble_mode_on) {
PRINTF("receiving_packet: Interrupt context but BLE in progress\n");
return 0;
}
#endif
/* If we are off, we are not receiving */
if(!rf_is_on()) {
PRINTF("receiving_packet: We were off\n");
return 0;
}
/* If we are transmitting (can only be an ACK here), we are not receiving */
if(transmitting()) {
PRINTF("receiving_packet: We were TXing\n");
return 0;
}
cca_info = get_cca_info();
if(cca_info == RF_GET_CCA_INFO_ERROR) {
/* If we can't read CCA info, return "not receiving" */
ret = 0;
} else {
/* Return 1 (receiving) if ccaState is busy */
ret = (cca_info & 0x03) == RF_CMD_CCA_REQ_CCA_STATE_BUSY;
}
if(was_off) {
off();
}
return ret;
}
/*---------------------------------------------------------------------------*/
static int
pending_packet(void)
{
volatile uint8_t *current = rx_data_queue.pCurrEntry;
int rv = 0;
/* Go through all RX buffers and check their status */
do {
if(GET_FIELD_V(current, dataEntry, status) ==
DATA_ENTRY_STATUS_FINISHED) {
rv = 1;
process_poll(&cc26xx_rf_process);
}
current = GET_FIELD_V(current, dataEntry, pNextEntry);
} while(current != rx_data_queue.pCurrEntry);
/* If we didn't find an entry at status finished, no frames are pending */
return rv;
}
/*---------------------------------------------------------------------------*/
static int
on(void)
{
/*
* Request the HF XOSC as the source for the HF clock. Needed before we can
* use the FS. This will only request, it will _not_ perform the switch.
*/
oscillators_request_hf_xosc();
/*
* If we are in the middle of a BLE operation, we got called by ContikiMAC
* from within an interrupt context. Abort, but pretend everything is OK.
*/
#if CC26XX_RF_BLE_SUPPORT
if(ble_mode_on) {
PRINTF("on: Interrupt context but BLE in progress\n");
return RF_CMD_OK;
}
#endif
if(rf_is_on()) {
PRINTF("on: We were on. PD=%u, RX=0x%04x \n", rf_is_accessible(),
RF_RADIO_OP_GET_STATUS(cmd_ieee_rx_buf));
return RF_CMD_OK;
}
if(power_up() != RF_CMD_OK) {
PRINTF("on: power_up() failed\n");
return RF_CMD_ERROR;
}
if(apply_patches() != RF_CMD_OK) {
PRINTF("on: apply_patches() failed\n");
return RF_CMD_ERROR;
}
init_rx_buffers();
setup_interrupts();
/*
* Trigger a switch to the XOSC, so that we can subsequently use the RF FS
* This will block until the XOSC is actually ready, but give how we
* requested it early on, this won't be too long a wait/
*/
oscillators_switch_to_hf_xosc();
if(rf_radio_setup(RF_MODE_IEEE) != RF_CMD_OK) {
PRINTF("on: radio_setup() failed\n");
return RF_CMD_ERROR;
}
return rx_on();
}
/*---------------------------------------------------------------------------*/
static int
off(void)
{
/*
* If we are in the middle of a BLE operation, we got called by ContikiMAC
* from within an interrupt context. Abort, but pretend everything is OK.
*/
#if CC26XX_RF_BLE_SUPPORT
if(ble_mode_on) {
PRINTF("off: Interrupt context but BLE in progress\n");
return RF_CMD_OK;
}
#endif
while(transmitting());
power_down();
/* Switch HF clock source to the RCOSC to preserve power */
oscillators_switch_to_hf_rc();
/* We pulled the plug, so we need to restore the status manually */
GET_FIELD(cmd_ieee_rx_buf, radioOp, status) = IDLE;
/*
* Just in case there was an ongoing RX (which started after we begun the
* shutdown sequence), we don't want to leave the buffer in state == ongoing
*/
GET_FIELD_V(rx_buf_0, dataEntry, status) = DATA_ENTRY_STATUS_PENDING;
GET_FIELD_V(rx_buf_1, dataEntry, status) = DATA_ENTRY_STATUS_PENDING;
GET_FIELD_V(rx_buf_2, dataEntry, status) = DATA_ENTRY_STATUS_PENDING;
GET_FIELD_V(rx_buf_3, dataEntry, status) = DATA_ENTRY_STATUS_PENDING;
return RF_CMD_OK;
}
/*---------------------------------------------------------------------------*/
static radio_result_t
get_value(radio_param_t param, radio_value_t *value)
{
if(!value) {
return RADIO_RESULT_INVALID_VALUE;
}
switch(param) {
case RADIO_PARAM_POWER_MODE:
/* On / off */
*value = rf_is_on() ? RADIO_POWER_MODE_ON : RADIO_POWER_MODE_OFF;
return RADIO_RESULT_OK;
case RADIO_PARAM_CHANNEL:
*value = (radio_value_t)GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, channel);
return RADIO_RESULT_OK;
case RADIO_PARAM_PAN_ID:
*value = (radio_value_t)GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, localPanID);
return RADIO_RESULT_OK;
case RADIO_PARAM_16BIT_ADDR:
*value = (radio_value_t)GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, localShortAddr);
return RADIO_RESULT_OK;
case RADIO_PARAM_RX_MODE:
*value = 0;
if(GET_BITFIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, frameFiltOpt, frameFiltEn)) {
*value |= RADIO_RX_MODE_ADDRESS_FILTER;
}
if(GET_BITFIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, frameFiltOpt, autoAckEn)) {
*value |= RADIO_RX_MODE_AUTOACK;
}
return RADIO_RESULT_OK;
case RADIO_PARAM_TXPOWER:
*value = get_tx_power();
return RADIO_RESULT_OK;
case RADIO_PARAM_CCA_THRESHOLD:
*value = GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, ccaRssiThr);
return RADIO_RESULT_OK;
case RADIO_PARAM_RSSI:
*value = get_rssi();
if(*value == RF_CMD_CCA_REQ_RSSI_UNKNOWN) {
return RADIO_RESULT_ERROR;
} else {
return RADIO_RESULT_OK;
}
case RADIO_CONST_CHANNEL_MIN:
*value = CC26XX_RF_CHANNEL_MIN;
return RADIO_RESULT_OK;
case RADIO_CONST_CHANNEL_MAX:
*value = CC26XX_RF_CHANNEL_MAX;
return RADIO_RESULT_OK;
case RADIO_CONST_TXPOWER_MIN:
*value = OUTPUT_POWER_MIN;
return RADIO_RESULT_OK;
case RADIO_CONST_TXPOWER_MAX:
*value = OUTPUT_POWER_MAX;
return RADIO_RESULT_OK;
default:
return RADIO_RESULT_NOT_SUPPORTED;
}
}
/*---------------------------------------------------------------------------*/
static radio_result_t
set_value(radio_param_t param, radio_value_t value)
{
uint8_t was_off = 0;
radio_result_t rv;
switch(param) {
case RADIO_PARAM_POWER_MODE:
if(value == RADIO_POWER_MODE_ON) {
if(on() != RF_CMD_OK) {
PRINTF("set_value: on() failed (1)\n");
return RADIO_RESULT_ERROR;
}
return RADIO_RESULT_OK;
}
if(value == RADIO_POWER_MODE_OFF) {
off();
return RADIO_RESULT_OK;
}
return RADIO_RESULT_INVALID_VALUE;
case RADIO_PARAM_CHANNEL:
if(value < CC26XX_RF_CHANNEL_MIN ||
value > CC26XX_RF_CHANNEL_MAX) {
return RADIO_RESULT_INVALID_VALUE;
}
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, channel) = (uint8_t)value;
break;
case RADIO_PARAM_PAN_ID:
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, localPanID) = (uint16_t)value;
break;
case RADIO_PARAM_16BIT_ADDR:
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, localShortAddr) = (uint16_t)value;
break;
case RADIO_PARAM_RX_MODE:
{
if(value & ~(RADIO_RX_MODE_ADDRESS_FILTER |
RADIO_RX_MODE_AUTOACK)) {
return RADIO_RESULT_INVALID_VALUE;
}
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, frameFiltOpt) =
BITVALUE(CMD_IEEE_RX, frameFiltOpt, frameFiltEn,
(value & RADIO_RX_MODE_ADDRESS_FILTER) != 0) |
BITVALUE(CMD_IEEE_RX, frameFiltOpt, frameFiltStop, 1) |
BITVALUE(CMD_IEEE_RX, frameFiltOpt, autoAckEn,
(value & RADIO_RX_MODE_AUTOACK) != 0) |
BITVALUE(CMD_IEEE_RX, frameFiltOpt, slottedAckEn, 0) |
BITVALUE(CMD_IEEE_RX, frameFiltOpt, autoPendEn, 0) |
BITVALUE(CMD_IEEE_RX, frameFiltOpt, defaultPend, 0) |
BITVALUE(CMD_IEEE_RX, frameFiltOpt, bPendDataReqOnly, 0) |
BITVALUE(CMD_IEEE_RX, frameFiltOpt, bPanCoord, 0) |
BITVALUE(CMD_IEEE_RX, frameFiltOpt, bStrictLenFilter, 0);
break;
}
case RADIO_PARAM_TXPOWER:
if(value < OUTPUT_POWER_MIN || value > OUTPUT_POWER_MAX) {
return RADIO_RESULT_INVALID_VALUE;
}
set_tx_power(value);
return RADIO_RESULT_OK;
case RADIO_PARAM_CCA_THRESHOLD:
GET_FIELD(cmd_ieee_rx_buf, CMD_IEEE_RX, ccaRssiThr) = (int8_t)value;
break;
default:
return RADIO_RESULT_NOT_SUPPORTED;
}
/* If we reach here we had no errors. Apply new settings */
if(!rf_is_on()) {
was_off = 1;
if(on() != RF_CMD_OK) {
PRINTF("set_value: on() failed (2)\n");
return RADIO_RESULT_ERROR;
}
}
if(rx_off() != RF_CMD_OK) {
PRINTF("set_value: rx_off() failed\n");
rv = RADIO_RESULT_ERROR;
}
if(rx_on() != RF_CMD_OK) {
PRINTF("set_value: rx_on() failed\n");
rv = RADIO_RESULT_ERROR;
}
/* If we were off, turn back off */
if(was_off) {
off();
}
return rv;
}
/*---------------------------------------------------------------------------*/
static radio_result_t
get_object(radio_param_t param, void *dest, size_t size)
{
uint8_t *target;
uint8_t *src;
int i;
if(param == RADIO_PARAM_64BIT_ADDR) {
if(size != 8 || !dest) {
return RADIO_RESULT_INVALID_VALUE;
}
target = dest;
src = (uint8_t *)(GET_FIELD_PTR(cmd_ieee_rx_buf, CMD_IEEE_RX, localExtAddr));
for(i = 0; i < 8; i++) {
target[i] = src[7 - i];
}
return RADIO_RESULT_OK;
}
return RADIO_RESULT_NOT_SUPPORTED;
}
/*---------------------------------------------------------------------------*/
static radio_result_t
set_object(radio_param_t param, const void *src, size_t size)
{
uint8_t was_off = 0;
radio_result_t rv;
int i;
uint8_t *dst;
if(param == RADIO_PARAM_64BIT_ADDR) {
if(size != 8 || !src) {
return RADIO_RESULT_INVALID_VALUE;
}
dst = (uint8_t *)(GET_FIELD_PTR(cmd_ieee_rx_buf, CMD_IEEE_RX,
localExtAddr));
for(i = 0; i < 8; i++) {
dst[i] = ((uint8_t *)src)[7 - i];
}
if(!rf_is_on()) {
was_off = 1;
if(on() != RF_CMD_OK) {
PRINTF("set_object: on() failed\n");
return RADIO_RESULT_ERROR;
}
}
if(rx_off() != RF_CMD_OK) {
PRINTF("set_object: rx_off() failed\n");
rv = RADIO_RESULT_ERROR;
}
if(rx_on() != RF_CMD_OK) {
PRINTF("set_object: rx_on() failed\n");
rv = RADIO_RESULT_ERROR;
}
/* If we were off, turn back off */
if(was_off) {
off();
}
return rv;
}
return RADIO_RESULT_NOT_SUPPORTED;
}
/*---------------------------------------------------------------------------*/
const struct radio_driver cc26xx_rf_driver = {
init,
prepare,
transmit,
send,
read_frame,
channel_clear,
receiving_packet,
pending_packet,
on,
off,
get_value,
set_value,
get_object,
set_object,
};
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(cc26xx_rf_process, ev, data)
{
int len;
PROCESS_BEGIN();
while(1) {
PROCESS_WAIT_EVENT();
do {
packetbuf_clear();
len = read_frame(packetbuf_dataptr(), PACKETBUF_SIZE);
if(len > 0) {
packetbuf_set_datalen(len);
NETSTACK_RDC.input();
}
} while(len > 0);
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
#if CC26XX_RF_BLE_SUPPORT
/*---------------------------------------------------------------------------*/
/**
* \brief Builds common radio parameters for radio operations
*
* \param *cmd Pointer to buffer to add parameters to
* \param command Radio command number (e.g. COMMAND_RADIO_SETUP)
*
* \note The buffer must be emptied with memset() before calling this function
*
* \return None
*/
static void
rf_build_ble_radio_op_cmd(uint8_t *cmd, uint16_t command)
{
GET_FIELD(cmd, radioOp, commandNo) = command;
GET_FIELD(cmd, radioOp, status) = IDLE;
GET_FIELD(cmd, radioOp, pNextOp) = NULL;
GET_FIELD(cmd, radioOp, startTime) = 0;
GET_FIELD(cmd, radioOp, startTrigger) = TRIG_NOW;
GET_FIELD(cmd, radioOp, condition) = COND_NEVER;
}
/*---------------------------------------------------------------------------*/
static void
init_ble()
{
ble_mode_on = 0;
memset(beacond_config.adv_name, 0, BLE_ADV_NAME_BUF_LEN);
beacond_config.interval = BLE_ADV_INTERVAL;
}
/*---------------------------------------------------------------------------*/
static int
send_ble_adv_nc(int channel, uint8_t *output, uint8_t *adv_payload,
int adv_payload_len, uint16_t *dev_address)
{
uint32_t cmd_status;
int ret;
/* Erase ble_tx_rx_buf array */
memset(ble_tx_rx_buf, 0x00, SIZEOF_RADIO_OP(CMD_BLE_ADV_NC));
rf_build_ble_radio_op_cmd(ble_tx_rx_buf, CMD_BLE_ADV_NC);
GET_FIELD(ble_tx_rx_buf, bleRadioOp, channel) = channel;
GET_FIELD(ble_tx_rx_buf, bleRadioOp, whitening) = 0;
memset(ble_cmd_buf, 0x00, SIZEOF_STRUCT(bleAdvPar));
GET_FIELD(ble_tx_rx_buf, bleRadioOp, pParams) = (uint8_t *)ble_cmd_buf;
GET_FIELD(ble_tx_rx_buf, bleRadioOp, pOutput) = output;
/* Set up BLE Advertisement parameters */
GET_FIELD(ble_cmd_buf, bleAdvPar, pRxQ) = NULL;
GET_FIELD(ble_cmd_buf, bleAdvPar, rxConfig) = 0;
GET_FIELD(ble_cmd_buf, bleAdvPar, advConfig) = 0;
GET_FIELD(ble_cmd_buf, bleAdvPar, advLen) = adv_payload_len;
GET_FIELD(ble_cmd_buf, bleAdvPar, scanRspLen) = 0;
GET_FIELD(ble_cmd_buf, bleAdvPar, pAdvData) = adv_payload;
GET_FIELD(ble_cmd_buf, bleAdvPar, pScanRspData) = NULL;
GET_FIELD(ble_cmd_buf, bleAdvPar, pDeviceAddress) = dev_address;
GET_FIELD(ble_cmd_buf, bleAdvPar, pWhiteList) = NULL;
GET_FIELD(ble_cmd_buf, bleAdvPar, endTrigger) = TRIG_NEVER;
GET_FIELD(ble_cmd_buf, bleAdvPar, endTime) = TRIG_NEVER;
if(rf_send_cmd((uint32_t)ble_tx_rx_buf, &cmd_status) == RF_CMD_ERROR) {
PRINTF("send_ble_adv_nc: Chan=%d CMDSTA=0x%08lx, status=0x%04x\n",
channel, cmd_status, RF_RADIO_OP_GET_STATUS(ble_tx_rx_buf));
return RF_CMD_ERROR;
}
/* Wait for the ADV_NC to go out */
while((RF_RADIO_OP_GET_STATUS(ble_tx_rx_buf) & RF_RADIO_OP_MASKED_STATUS)
== RF_RADIO_OP_MASKED_STATUS_RUNNING);
if(RF_RADIO_OP_GET_STATUS(ble_tx_rx_buf) == RF_RADIO_OP_STATUS_BLE_DONE_OK) {
/* Sent OK */
ret = RF_CMD_OK;
} else {
/* Radio Op completed, but ADV NC was not sent */
PRINTF("send_ble_adv_nc: Chan=%d CMDSTA=0x%08lx, status=0x%04x\n",
channel, cmd_status, RF_RADIO_OP_GET_STATUS(ble_tx_rx_buf));
ret = RF_CMD_ERROR;
}
return ret;
}
/*---------------------------------------------------------------------------*/
static int
send_ble_adv(int channel, uint8_t *adv_payload, int adv_payload_len)
{
if(send_ble_adv_nc(channel, rf_stats, adv_payload, adv_payload_len,
(uint16_t *)&linkaddr_node_addr.u8[2]) != RF_CMD_OK) {
PRINTF("send_ble_adv: Channel=%d, Error advertising\n", channel);
/* Break the loop, but don't return just yet */
return RF_CMD_ERROR;
}
return RF_CMD_OK;
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(cc26xx_rf_ble_beacon_process, ev, data)
{
static struct etimer ble_adv_et;
static uint8_t payload[BLE_ADV_PAYLOAD_BUF_LEN];
static int p = 0;
static int i;
uint8_t was_on;
int j;
uint32_t cmd_status;
bool interrupts_disabled;
PROCESS_BEGIN();
while(1) {
etimer_set(&ble_adv_et, beacond_config.interval);
PROCESS_WAIT_EVENT();
if(ev == PROCESS_EVENT_EXIT) {
PROCESS_EXIT();
}
/* Set the adv payload each pass: The device name may have changed */
p = 0;
/* device info */
payload[p++] = 0x02; /* 2 bytes */
payload[p++] = BLE_ADV_TYPE_DEVINFO;
payload[p++] = 0x1a; /* LE general discoverable + BR/EDR */
payload[p++] = 1 + strlen(beacond_config.adv_name);
payload[p++] = BLE_ADV_TYPE_NAME;
memcpy(&payload[p], beacond_config.adv_name,
strlen(beacond_config.adv_name));
p += strlen(beacond_config.adv_name);
for(i = 0; i < BLE_ADV_MESSAGES; i++) {
/*
* Under ContikiMAC, some IEEE-related operations will be called from an
* interrupt context. We need those to see that we are in BLE mode.
*/
interrupts_disabled = ti_lib_int_master_disable();
ble_mode_on = 1;
if(!interrupts_disabled) {
ti_lib_int_master_enable();
}
/*
* Send BLE_ADV_MESSAGES beacon bursts. Each burst on all three
* channels, with a BLE_ADV_DUTY_CYCLE interval between bursts
*
* First, determine our state:
*
* If we are running NullRDC, we are likely in IEEE RX mode. We need to
* abort the IEEE BG Op before entering BLE mode.
* If we are ContikiMAC, we are likely off, in which case we need to
* boot the CPE before entering BLE mode
*/
was_on = rf_is_accessible();
if(was_on) {
/*
* We were on: If we are in the process of receiving an IEEE frame,
* abort the BLE beacon burst. Otherwise, terminate the IEEE BG Op
* so we can switch to BLE mode
*/
if(receiving_packet()) {
PRINTF("cc26xx_rf_ble_beacon_process: We were receiving\n");
/* Abort this pass */
break;
}
if(rx_off() != RF_CMD_OK) {
PRINTF("cc26xx_rf_ble_beacon_process: rx_off() failed\n");
/* Abort this pass */
break;
}
} else {
/* Request the HF XOSC to source the HF clock. */
oscillators_request_hf_xosc();
/* We were off: Boot the CPE */
if(power_up() != RF_CMD_OK) {
PRINTF("cc26xx_rf_ble_beacon_process: power_up() failed\n");
/* Abort this pass */
break;
}
if(apply_patches() != RF_CMD_OK) {
PRINTF("cc26xx_rf_ble_beacon_process: apply_patches() failed\n");
/* Abort this pass */
break;
}
/* Trigger a switch to the XOSC, so that we can use the FS */
oscillators_switch_to_hf_xosc();
}
/* Enter BLE mode */
if(rf_radio_setup(RF_MODE_BLE) != RF_CMD_OK) {
PRINTF("cc26xx_rf_ble_beacon_process: Error entering BLE mode\n");
/* Continue so we can at least try to restore our previous state */
} else {
/* Send advertising packets on all 3 advertising channels */
for(j = 37; j <= 39; j++) {
if(send_ble_adv(j, payload, p) != RF_CMD_OK) {
PRINTF("cc26xx_rf_ble_beacon_process: Channel=%d,"
"Error advertising\n", j);
/* Break the loop, but don't return just yet */
break;
}
}
}
/* Send a CMD_STOP command to RF Core */
if(rf_send_cmd(CMDR_DIR_CMD(CMD_STOP), &cmd_status) != RF_CMD_OK) {
PRINTF("cc26xx_rf_ble_beacon_process: status=0x%08lx\n", cmd_status);
/* Continue... */
}
if(was_on) {
/* We were on, go back to IEEE mode */
if(rf_radio_setup(RF_MODE_IEEE) != RF_CMD_OK) {
PRINTF("cc26xx_rf_ble_beacon_process: radio_setup() failed\n");
}
/* Enter IEEE RX mode */
if(rx_on() != RF_CMD_OK) {
PRINTF("cc26xx_rf_ble_beacon_process: rx_on() failed\n");
}
} else {
power_down();
/* Switch HF clock source to the RCOSC to preserve power */
oscillators_switch_to_hf_rc();
}
etimer_set(&ble_adv_et, BLE_ADV_DUTY_CYCLE);
interrupts_disabled = ti_lib_int_master_disable();
ble_mode_on = 0;
if(!interrupts_disabled) {
ti_lib_int_master_enable();
}
/* Wait unless this is the last burst */
if(i < BLE_ADV_MESSAGES - 1) {
PROCESS_WAIT_EVENT();
}
}
interrupts_disabled = ti_lib_int_master_disable();
ble_mode_on = 0;
if(!interrupts_disabled) {
ti_lib_int_master_enable();
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
#endif /* CC26XX_RF_BLE_SUPPORT */
/*---------------------------------------------------------------------------*/
void
cc26xx_rf_ble_beacond_config(clock_time_t interval, const char *name)
{
#if CC26XX_RF_BLE_SUPPORT
if(name != NULL) {
memset(beacond_config.adv_name, 0, BLE_ADV_NAME_BUF_LEN);
if(strlen(name) == 0 || strlen(name) >= BLE_ADV_NAME_BUF_LEN) {
return;
}
memcpy(beacond_config.adv_name, name, strlen(name));
}
if(interval != 0) {
beacond_config.interval = interval;
}
#endif
}
/*---------------------------------------------------------------------------*/
uint8_t
cc26xx_rf_ble_beacond_start()
{
#if CC26XX_RF_BLE_SUPPORT
if(beacond_config.adv_name[0] == 0) {
return RF_CMD_ERROR;
}
process_start(&cc26xx_rf_ble_beacon_process, NULL);
return RF_CMD_OK;
#else
return RF_CMD_ERROR;
#endif
}
/*---------------------------------------------------------------------------*/
void
cc26xx_rf_ble_beacond_stop()
{
#if CC26XX_RF_BLE_SUPPORT
process_exit(&cc26xx_rf_ble_beacon_process);
#endif
}
/*---------------------------------------------------------------------------*/
/** @} */
Reference in a new issue View git blame Copy permalink