blob: 6df2367cebf308f2ff5f4aa0bd88d5f2ed473262 [file] [log] [blame]
/* ieee802154_nrf5.c - nRF5 802.15.4 driver */
/*
* Copyright (c) 2017 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#define LOG_MODULE_NAME ieee802154_nrf5
#if defined(CONFIG_IEEE802154_DRIVER_LOG_LEVEL)
#define LOG_LEVEL CONFIG_IEEE802154_DRIVER_LOG_LEVEL
#else
#define LOG_LEVEL LOG_LEVEL_NONE
#endif
#include <logging/log.h>
LOG_MODULE_REGISTER(LOG_MODULE_NAME);
#include <errno.h>
#include <kernel.h>
#include <arch/cpu.h>
#include <soc.h>
#include <device.h>
#include <init.h>
#include <net/net_if.h>
#include <net/net_pkt.h>
#if defined(CONFIG_NET_L2_OPENTHREAD)
#include <net/openthread.h>
#endif
#include <sys/byteorder.h>
#include <string.h>
#include <random/rand32.h>
#include <net/ieee802154_radio.h>
#include "ieee802154_nrf5.h"
#include "nrf_802154.h"
struct nrf5_802154_config {
void (*irq_config_func)(struct device *dev);
};
static struct nrf5_802154_data nrf5_data;
#define ACK_TIMEOUT K_MSEC(10)
/* Convenience defines for RADIO */
#define NRF5_802154_DATA(dev) \
((struct nrf5_802154_data * const)(dev)->driver_data)
#define NRF5_802154_CFG(dev) \
((struct nrf5_802154_config * const)(dev)->config->config_info)
static void nrf5_get_eui64(u8_t *mac)
{
memcpy(mac, (const u32_t *)&NRF_FICR->DEVICEID, 8);
}
static void nrf5_rx_thread(void *arg1, void *arg2, void *arg3)
{
struct device *dev = (struct device *)arg1;
struct nrf5_802154_data *nrf5_radio = NRF5_802154_DATA(dev);
struct net_pkt *pkt;
struct nrf5_802154_rx_frame *rx_frame;
u8_t pkt_len;
ARG_UNUSED(arg2);
ARG_UNUSED(arg3);
while (1) {
pkt = NULL;
rx_frame = NULL;
LOG_DBG("Waiting for frame");
rx_frame = k_fifo_get(&nrf5_radio->rx_fifo, K_FOREVER);
__ASSERT_NO_MSG(rx_frame->psdu);
/* rx_mpdu contains length, psdu, fcs|lqi
* The last 2 bytes contain LQI or FCS, depending if
* automatic CRC handling is enabled or not, respectively.
*/
if (IS_ENABLED(CONFIG_IEEE802154_RAW_MODE) ||
IS_ENABLED(CONFIG_NET_L2_OPENTHREAD)) {
pkt_len = rx_frame->psdu[0];
} else {
pkt_len = rx_frame->psdu[0] - NRF5_FCS_LENGTH;
}
__ASSERT_NO_MSG(pkt_len <= CONFIG_NET_BUF_DATA_SIZE);
LOG_DBG("Frame received");
pkt = net_pkt_alloc_with_buffer(nrf5_radio->iface, pkt_len,
AF_UNSPEC, 0, K_NO_WAIT);
if (!pkt) {
LOG_ERR("No pkt available");
goto drop;
}
if (net_pkt_write(pkt, rx_frame->psdu + 1, pkt_len)) {
goto drop;
}
net_pkt_set_ieee802154_lqi(pkt, rx_frame->lqi);
net_pkt_set_ieee802154_rssi(pkt, rx_frame->rssi);
LOG_DBG("Caught a packet (%u) (LQI: %u)",
pkt_len, rx_frame->lqi);
if (net_recv_data(nrf5_radio->iface, pkt) < 0) {
LOG_ERR("Packet dropped by NET stack");
goto drop;
}
nrf_802154_buffer_free_raw(rx_frame->psdu);
rx_frame->psdu = NULL;
if (LOG_LEVEL >= LOG_LEVEL_DBG) {
net_analyze_stack(
"nRF5 rx stack",
Z_THREAD_STACK_BUFFER(nrf5_radio->rx_stack),
K_THREAD_STACK_SIZEOF(nrf5_radio->rx_stack));
}
continue;
drop:
nrf_802154_buffer_free_raw(rx_frame->psdu);
rx_frame->psdu = NULL;
if (pkt) {
net_pkt_unref(pkt);
}
}
}
/* Radio device API */
static enum ieee802154_hw_caps nrf5_get_capabilities(struct device *dev)
{
return IEEE802154_HW_FCS | IEEE802154_HW_2_4_GHZ |
IEEE802154_HW_TX_RX_ACK | IEEE802154_HW_FILTER;
}
static int nrf5_cca(struct device *dev)
{
struct nrf5_802154_data *nrf5_radio = NRF5_802154_DATA(dev);
if (!nrf_802154_cca()) {
LOG_DBG("CCA failed");
return -EBUSY;
}
/* The nRF driver guarantees that a callback will be called once
* the CCA function is done, thus unlocking the semaphore.
*/
k_sem_take(&nrf5_radio->cca_wait, K_FOREVER);
LOG_DBG("Channel free? %d", nrf5_radio->channel_free);
return nrf5_radio->channel_free ? 0 : -EBUSY;
}
static int nrf5_set_channel(struct device *dev, u16_t channel)
{
ARG_UNUSED(dev);
LOG_DBG("%u", channel);
if (channel < 11 || channel > 26) {
return -EINVAL;
}
nrf_802154_channel_set(channel);
return 0;
}
static int nrf5_set_pan_id(struct device *dev, u16_t pan_id)
{
u8_t pan_id_le[2];
ARG_UNUSED(dev);
sys_put_le16(pan_id, pan_id_le);
nrf_802154_pan_id_set(pan_id_le);
LOG_DBG("0x%x", pan_id);
return 0;
}
static int nrf5_set_short_addr(struct device *dev, u16_t short_addr)
{
u8_t short_addr_le[2];
ARG_UNUSED(dev);
sys_put_le16(short_addr, short_addr_le);
nrf_802154_short_address_set(short_addr_le);
LOG_DBG("0x%x", short_addr);
return 0;
}
static int nrf5_set_ieee_addr(struct device *dev, const u8_t *ieee_addr)
{
ARG_UNUSED(dev);
LOG_DBG("IEEE address %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
ieee_addr[7], ieee_addr[6], ieee_addr[5], ieee_addr[4],
ieee_addr[3], ieee_addr[2], ieee_addr[1], ieee_addr[0]);
nrf_802154_extended_address_set(ieee_addr);
return 0;
}
static int nrf5_filter(struct device *dev, bool set,
enum ieee802154_filter_type type,
const struct ieee802154_filter *filter)
{
LOG_DBG("Applying filter %u", type);
if (!set) {
return -ENOTSUP;
}
if (type == IEEE802154_FILTER_TYPE_IEEE_ADDR) {
return nrf5_set_ieee_addr(dev, filter->ieee_addr);
} else if (type == IEEE802154_FILTER_TYPE_SHORT_ADDR) {
return nrf5_set_short_addr(dev, filter->short_addr);
} else if (type == IEEE802154_FILTER_TYPE_PAN_ID) {
return nrf5_set_pan_id(dev, filter->pan_id);
}
return -ENOTSUP;
}
static int nrf5_set_txpower(struct device *dev, s16_t dbm)
{
ARG_UNUSED(dev);
LOG_DBG("%d", dbm);
nrf_802154_tx_power_set(dbm);
return 0;
}
static int nrf5_tx(struct device *dev,
struct net_pkt *pkt,
struct net_buf *frag)
{
struct nrf5_802154_data *nrf5_radio = NRF5_802154_DATA(dev);
u8_t payload_len = frag->len;
u8_t *payload = frag->data;
LOG_DBG("%p (%u)", payload, payload_len);
nrf5_radio->tx_psdu[0] = payload_len + NRF5_FCS_LENGTH;
memcpy(nrf5_radio->tx_psdu + 1, payload, payload_len);
/* Reset semaphore in case ACK was received after timeout */
k_sem_reset(&nrf5_radio->tx_wait);
if (!nrf_802154_transmit_raw(nrf5_radio->tx_psdu, false)) {
LOG_ERR("Cannot send frame");
return -EIO;
}
LOG_DBG("Sending frame (ch:%d, txpower:%d)",
nrf_802154_channel_get(), nrf_802154_tx_power_get());
/* Wait for ack to be received */
if (k_sem_take(&nrf5_radio->tx_wait, ACK_TIMEOUT)) {
LOG_DBG("ACK not received");
if (!nrf_802154_receive()) {
LOG_ERR("Failed to switch back to receive state");
}
return -EIO;
}
LOG_DBG("Result: %d", nrf5_data.tx_result);
if (nrf5_radio->tx_result == NRF_802154_TX_ERROR_NONE) {
/* ACK frame not used currently. */
if (nrf5_radio->ack != NULL) {
nrf_802154_buffer_free_raw(nrf5_radio->ack);
}
nrf5_radio->ack = NULL;
return 0;
}
return -EIO;
}
static int nrf5_start(struct device *dev)
{
ARG_UNUSED(dev);
if (!nrf_802154_receive()) {
LOG_ERR("Failed to enter receive state");
return -EIO;
}
LOG_DBG("nRF5 802154 radio started (channel: %d)",
nrf_802154_channel_get());
return 0;
}
static int nrf5_stop(struct device *dev)
{
ARG_UNUSED(dev);
if (!nrf_802154_sleep()) {
LOG_ERR("Error while stopping radio");
return -EIO;
}
LOG_DBG("nRF5 802154 radio stopped");
return 0;
}
static void nrf5_radio_irq(void *arg)
{
ARG_UNUSED(arg);
nrf_802154_radio_irq_handler();
}
static void nrf5_irq_config(struct device *dev)
{
ARG_UNUSED(dev);
IRQ_CONNECT(RADIO_IRQn, NRF_802154_IRQ_PRIORITY,
nrf5_radio_irq, NULL, 0);
irq_enable(RADIO_IRQn);
}
static int nrf5_init(struct device *dev)
{
const struct nrf5_802154_config *nrf5_radio_cfg = NRF5_802154_CFG(dev);
struct nrf5_802154_data *nrf5_radio = NRF5_802154_DATA(dev);
k_fifo_init(&nrf5_radio->rx_fifo);
k_sem_init(&nrf5_radio->tx_wait, 0, 1);
k_sem_init(&nrf5_radio->cca_wait, 0, 1);
nrf_802154_init();
nrf5_radio_cfg->irq_config_func(dev);
k_thread_create(&nrf5_radio->rx_thread, nrf5_radio->rx_stack,
CONFIG_IEEE802154_NRF5_RX_STACK_SIZE,
nrf5_rx_thread, dev, NULL, NULL,
K_PRIO_COOP(2), 0, K_NO_WAIT);
k_thread_name_set(&nrf5_radio->rx_thread, "802154 RX");
LOG_INF("nRF5 802154 radio initialized");
return 0;
}
static void nrf5_iface_init(struct net_if *iface)
{
struct device *dev = net_if_get_device(iface);
struct nrf5_802154_data *nrf5_radio = NRF5_802154_DATA(dev);
nrf5_get_eui64(nrf5_radio->mac);
net_if_set_link_addr(iface, nrf5_radio->mac, sizeof(nrf5_radio->mac),
NET_LINK_IEEE802154);
nrf5_radio->iface = iface;
ieee802154_init(iface);
}
int nrf5_configure(struct device *dev, enum ieee802154_config_type type,
const struct ieee802154_config *config)
{
ARG_UNUSED(dev);
switch (type) {
case IEEE802154_CONFIG_AUTO_ACK_FPB:
nrf_802154_auto_pending_bit_set(config->auto_ack_fpb.enabled);
break;
case IEEE802154_CONFIG_ACK_FPB:
if (config->ack_fpb.enabled) {
if (!nrf_802154_pending_bit_for_addr_set(
config->ack_fpb.addr,
config->ack_fpb.extended)) {
return -ENOMEM;
}
break;
}
if (config->ack_fpb.addr != NULL) {
if (!nrf_802154_pending_bit_for_addr_clear(
config->ack_fpb.addr,
config->ack_fpb.extended)) {
return -ENOENT;
}
} else {
nrf_802154_pending_bit_for_addr_reset(
config->ack_fpb.extended);
}
break;
default:
return -EINVAL;
}
return 0;
}
/* nRF5 radio driver callbacks */
void nrf_802154_received_raw(uint8_t *data, int8_t power, uint8_t lqi)
{
for (u32_t i = 0; i < ARRAY_SIZE(nrf5_data.rx_frames); i++) {
if (nrf5_data.rx_frames[i].psdu != NULL) {
continue;
}
nrf5_data.rx_frames[i].psdu = data;
nrf5_data.rx_frames[i].rssi = power;
nrf5_data.rx_frames[i].lqi = lqi;
k_fifo_put(&nrf5_data.rx_fifo, &nrf5_data.rx_frames[i]);
return;
}
__ASSERT(false, "Not enough rx frames allocated for 15.4 driver");
}
void nrf_802154_receive_failed(nrf_802154_rx_error_t error)
{
/* Intentionally empty. */
}
void nrf_802154_transmitted_raw(const uint8_t *frame, uint8_t *ack,
int8_t power, uint8_t lqi)
{
ARG_UNUSED(frame);
ARG_UNUSED(power);
ARG_UNUSED(lqi);
nrf5_data.tx_result = NRF_802154_TX_ERROR_NONE;
nrf5_data.ack = ack;
k_sem_give(&nrf5_data.tx_wait);
}
void nrf_802154_transmit_failed(const uint8_t *frame,
nrf_802154_tx_error_t error)
{
ARG_UNUSED(frame);
nrf5_data.tx_result = error;
k_sem_give(&nrf5_data.tx_wait);
}
void nrf_802154_cca_done(bool channel_free)
{
nrf5_data.channel_free = channel_free;
k_sem_give(&nrf5_data.cca_wait);
}
void nrf_802154_cca_failed(nrf_802154_cca_error_t error)
{
ARG_UNUSED(error);
nrf5_data.channel_free = false;
k_sem_give(&nrf5_data.cca_wait);
}
static const struct nrf5_802154_config nrf5_radio_cfg = {
.irq_config_func = nrf5_irq_config,
};
static struct ieee802154_radio_api nrf5_radio_api = {
.iface_api.init = nrf5_iface_init,
.get_capabilities = nrf5_get_capabilities,
.cca = nrf5_cca,
.set_channel = nrf5_set_channel,
.filter = nrf5_filter,
.set_txpower = nrf5_set_txpower,
.start = nrf5_start,
.stop = nrf5_stop,
.tx = nrf5_tx,
.configure = nrf5_configure,
};
#if defined(CONFIG_NET_L2_IEEE802154)
#define L2 IEEE802154_L2
#define L2_CTX_TYPE NET_L2_GET_CTX_TYPE(IEEE802154_L2)
#define MTU 125
#elif defined(CONFIG_NET_L2_OPENTHREAD)
#define L2 OPENTHREAD_L2
#define L2_CTX_TYPE NET_L2_GET_CTX_TYPE(OPENTHREAD_L2)
#define MTU 1280
#endif
#if defined(CONFIG_NET_L2_IEEE802154) || defined(CONFIG_NET_L2_OPENTHREAD)
NET_DEVICE_INIT(nrf5_154_radio, CONFIG_IEEE802154_NRF5_DRV_NAME,
nrf5_init, &nrf5_data, &nrf5_radio_cfg,
CONFIG_IEEE802154_NRF5_INIT_PRIO,
&nrf5_radio_api, L2,
L2_CTX_TYPE, MTU);
NET_STACK_INFO_ADDR(RX, nrf5_154_radio,
CONFIG_IEEE802154_NRF5_RX_STACK_SIZE,
CONFIG_IEEE802154_NRF5_RX_STACK_SIZE,
nrf5_data.rx_stack, 0);
#else
DEVICE_AND_API_INIT(nrf5_154_radio, CONFIG_IEEE802154_NRF5_DRV_NAME,
nrf5_init, &nrf5_data, &nrf5_radio_cfg,
POST_KERNEL, CONFIG_IEEE802154_NRF5_INIT_PRIO,
&nrf5_radio_api);
#endif