michaelh/zephyr
1
0
Fork 0
Code Releases Activity

drivers: ieee802154: Convert to use new logging

Browse source 
Convert the IEEE 802.15.4 drivers to use the new logging system.

Signed-off-by: Jukka Rissanen <jukka.rissanen@linux.intel.com>
This commit is contained in:
Jukka Rissanen 2018-09-03 17:28:47 +03:00
commit 90dc38f8c9
7 changed files with 321 additions and 340 deletions
Download patch file Download diff file Expand all files Collapse all files

25
drivers/ieee802154/Kconfig
View file

@ -15,24 +15,13 @@ menuconfig IEEE802154
if IEEE802154
config SYS_LOG_IEEE802154_DRIVER_LEVEL
int "IEEE802154 driver log level"
depends on SYS_LOG
default 0
help
Sets log level for 802.15.4 drivers.
Levels are:
- 0 OFF, do not write
- 1 ERROR, only write SYS_LOG_ERR
- 2 WARNING, write SYS_LOG_WRN in addition to previous level
- 3 INFO, write SYS_LOG_INF in addition to previous levels
- 4 DEBUG, write SYS_LOG_DBG in addition to previous levels
if NET_L2_IEEE802154
module=IEEE802154
module-dep=LOG
module-str=Log level for IEEE 802.15.4 driver
module-help=Sets log level for IEEE 802.15.4 Device Drivers.
source "subsys/net/Kconfig.template.log_config.net"
endif # NET_L2_IEEE802154
config IEEE802154_RAW_MODE
bool "Use IEEE 802.15.4 driver without the MAC stack"

106
drivers/ieee802154/ieee802154_cc1200.c
View file

@ -6,9 +6,11 @@
* SPDX-License-Identifier: Apache-2.0
*/
#define SYS_LOG_LEVEL CONFIG_SYS_LOG_IEEE802154_DRIVER_LEVEL
#define SYS_LOG_DOMAIN "dev/cc1200"
#include <logging/sys_log.h>
#define LOG_MODULE_NAME ieee802154_cc1200
#define LOG_LEVEL CONFIG_IEEE802154_LOG_LEVEL
#include <logging/log.h>
LOG_MODULE_REGISTER(LOG_MODULE_NAME);
#include <errno.h>
@ -49,30 +51,26 @@ static struct spi_cs_control cs_ctrl;
/***********************
* Debugging functions *
**********************/
#if CONFIG_SYS_LOG_IEEE802154_DRIVER_LEVEL == 4
static void _cc1200_print_status(u8_t status)
{
if (status == CC1200_STATUS_IDLE) {
SYS_LOG_DBG("Idling");
LOG_DBG("Idling");
} else if (status == CC1200_STATUS_RX) {
SYS_LOG_DBG("Receiving");
LOG_DBG("Receiving");
} else if (status == CC1200_STATUS_TX) {
SYS_LOG_DBG("Transmitting");
LOG_DBG("Transmitting");
} else if (status == CC1200_STATUS_FSTXON) {
SYS_LOG_DBG("FS TX on");
LOG_DBG("FS TX on");
} else if (status == CC1200_STATUS_CALIBRATE) {
SYS_LOG_DBG("Calibrating");
LOG_DBG("Calibrating");
} else if (status == CC1200_STATUS_SETTLING) {
SYS_LOG_DBG("Settling");
LOG_DBG("Settling");
} else if (status == CC1200_STATUS_RX_FIFO_ERROR) {
SYS_LOG_DBG("RX FIFO error!");
LOG_DBG("RX FIFO error!");
} else if (status == CC1200_STATUS_TX_FIFO_ERROR) {
SYS_LOG_DBG("TX FIFO error!");
LOG_DBG("TX FIFO error!");
}
}
#else
#define _cc1200_print_status(...)
#endif /* CONFIG_SYS_LOG_IEEE802154_DRIVER_LEVEL */
/*********************
* Generic functions *
@ -96,7 +94,7 @@ bool _cc1200_access_reg(struct cc1200_context *ctx, bool read, u8_t addr,
struct spi_buf_set tx = { .buffers = buf };
/*
SYS_LOG_DBG("%s: addr 0x%02x - Data %p Length %u - %s, %s",
LOG_DBG("%s: addr 0x%02x - Data %p Length %u - %s, %s",
read ? "Read" : "Write", addr, data, length,
extended ? "extended" : "normal",
burst ? "burst" : "single");
@ -288,7 +286,7 @@ static u32_t rf_evaluate_freq_setting(struct cc1200_context *ctx, u32_t chan)
((chan * (u32_t)ctx->rf_settings->channel_spacing) / 10);
lo_div = get_lo_divider(ctx);
SYS_LOG_DBG("Calculating freq for %u KHz RF (%u)", rf, lo_div);
LOG_DBG("Calculating freq for %u KHz RF (%u)", rf, lo_div);
while (rf > 0) {
u32_t hz, freq_tmp, rst;
@ -321,7 +319,7 @@ static u32_t rf_evaluate_freq_setting(struct cc1200_context *ctx, u32_t chan)
rf -= hz;
}
SYS_LOG_DBG("FREQ is 0x%06X", freq);
LOG_DBG("FREQ is 0x%06X", freq);
return freq;
}
@ -340,7 +338,7 @@ rf_install_settings(struct device *dev,
CC1200_RF_NON_EXT_SPACE_REGS,
CC1200_RF_EXT_SPACE_REGS, true, true) ||
!write_reg_pkt_len(cc1200, 0xFF)) {
SYS_LOG_ERR("Could not install RF settings");
LOG_ERR("Could not install RF settings");
return false;
}
@ -352,7 +350,7 @@ rf_install_settings(struct device *dev,
static int rf_calibrate(struct cc1200_context *ctx)
{
if (!instruct_scal(ctx)) {
SYS_LOG_ERR("Could not calibrate RF");
LOG_ERR("Could not calibrate RF");
return -EIO;
}
@ -362,7 +360,7 @@ static int rf_calibrate(struct cc1200_context *ctx)
if (!instruct_sidle(ctx) ||
!instruct_sfrx(ctx) ||
!instruct_srx(ctx)) {
SYS_LOG_ERR("Could not switch to RX");
LOG_ERR("Could not switch to RX");
return -EIO;
}
@ -466,49 +464,49 @@ static void cc1200_rx(struct device *dev)
k_sem_take(&cc1200->rx_lock, K_FOREVER);
if (get_status(cc1200) == CC1200_STATUS_RX_FIFO_ERROR) {
SYS_LOG_ERR("Fifo error");
LOG_ERR("Fifo error");
goto flush;
}
pkt_len = get_packet_length(cc1200);
if (!verify_rxfifo_validity(cc1200, pkt_len)) {
SYS_LOG_ERR("Invalid frame");
LOG_ERR("Invalid frame");
goto flush;
}
pkt = net_pkt_get_reserve_rx(0, K_NO_WAIT);
if (!pkt) {
SYS_LOG_ERR("No free pkt available");
LOG_ERR("No free pkt available");
goto flush;
}
pkt_frag = net_pkt_get_frag(pkt, K_NO_WAIT);
if (!pkt_frag) {
SYS_LOG_ERR("No free frag available");
LOG_ERR("No free frag available");
goto flush;
}
net_pkt_frag_insert(pkt, pkt_frag);
if (!read_rxfifo_content(cc1200, pkt_frag, pkt_len)) {
SYS_LOG_ERR("No content read");
LOG_ERR("No content read");
goto flush;
}
if (!verify_crc(cc1200, pkt)) {
SYS_LOG_ERR("Bad packet CRC");
LOG_ERR("Bad packet CRC");
goto out;
}
if (ieee802154_radio_handle_ack(cc1200->iface, pkt) == NET_OK) {
SYS_LOG_DBG("ACK packet handled");
LOG_DBG("ACK packet handled");
goto out;
}
SYS_LOG_DBG("Caught a packet (%u)", pkt_len);
LOG_DBG("Caught a packet (%u)", pkt_len);
if (net_recv_data(cc1200->iface, pkt) < 0) {
SYS_LOG_DBG("Packet dropped by NET stack");
LOG_DBG("Packet dropped by NET stack");
goto out;
}
@ -517,7 +515,7 @@ static void cc1200_rx(struct device *dev)
K_THREAD_STACK_SIZEOF(cc1200->rx_stack));
continue;
flush:
SYS_LOG_DBG("Flushing RX");
LOG_DBG("Flushing RX");
instruct_sidle(cc1200);
instruct_sfrx(cc1200);
instruct_srx(cc1200);
@ -551,7 +549,7 @@ static int cc1200_cca(struct device *dev)
}
}
SYS_LOG_WRN("Busy");
LOG_WRN("Busy");
return -EBUSY;
}
@ -573,7 +571,7 @@ static int cc1200_set_channel(struct device *dev, u16_t channel)
if (!write_reg_freq(cc1200, freq) ||
rf_calibrate(cc1200)) {
SYS_LOG_ERR("Could not set channel %u", channel);
LOG_ERR("Could not set channel %u", channel);
return -EIO;
}
}
@ -586,12 +584,12 @@ static int cc1200_set_txpower(struct device *dev, s16_t dbm)
struct cc1200_context *cc1200 = dev->driver_data;
u8_t pa_power_ramp;
SYS_LOG_DBG("%d dbm", dbm);
LOG_DBG("%d dbm", dbm);
/* See Section 7.1 */
dbm = ((dbm + 18) * 2) - 1;
if ((dbm <= 3) || (dbm >= 64)) {
SYS_LOG_ERR("Unhandled value");
LOG_ERR("Unhandled value");
return -EINVAL;
}
@ -599,7 +597,7 @@ static int cc1200_set_txpower(struct device *dev, s16_t dbm)
pa_power_ramp |= ((u8_t) dbm) & PA_POWER_RAMP_MASK;
if (!write_reg_pa_cfg1(cc1200, pa_power_ramp)) {
SYS_LOG_ERR("Could not proceed");
LOG_ERR("Could not proceed");
return -EIO;
}
@ -615,7 +613,7 @@ static int cc1200_tx(struct device *dev,
u8_t len = net_pkt_ll_reserve(pkt) + frag->len;
bool status = false;
SYS_LOG_DBG("%p (%u)", frag, len);
LOG_DBG("%p (%u)", frag, len);
/* ToDo:
* Supporting 802.15.4g will require to loop in pkt's frags
@ -626,14 +624,14 @@ static int cc1200_tx(struct device *dev,
!instruct_sfrx(cc1200) ||
!instruct_sftx(cc1200) ||
!instruct_sfstxon(cc1200)) {
SYS_LOG_ERR("Cannot switch to TX mode");
LOG_ERR("Cannot switch to TX mode");
goto out;
}
if (!write_txfifo(cc1200, &len, CC1200_PHY_HDR_LEN) ||
!write_txfifo(cc1200, frame, len) ||
read_reg_num_txbytes(cc1200) != (len + CC1200_PHY_HDR_LEN)) {
SYS_LOG_ERR("Cannot fill-in TX fifo");
LOG_ERR("Cannot fill-in TX fifo");
goto out;
}
@ -641,7 +639,7 @@ static int cc1200_tx(struct device *dev,
atomic_set(&cc1200->tx_start, 0);
if (!instruct_stx(cc1200)) {
SYS_LOG_ERR("Cannot start transmission");
LOG_ERR("Cannot start transmission");
goto out;
}
@ -657,7 +655,7 @@ out:
if (atomic_get(&cc1200->tx) == 1 &&
read_reg_num_txbytes(cc1200) != 0) {
SYS_LOG_ERR("TX Failed");
LOG_ERR("TX Failed");
atomic_set(&cc1200->tx_start, 0);
instruct_sftx(cc1200);
@ -682,7 +680,7 @@ static int cc1200_start(struct device *dev)
!instruct_sftx(cc1200) ||
!instruct_sfrx(cc1200) ||
rf_calibrate(cc1200)) {
SYS_LOG_ERR("Could not proceed");
LOG_ERR("Could not proceed");
return -EIO;
}
@ -700,7 +698,7 @@ static int cc1200_stop(struct device *dev)
enable_gpio0_interrupt(cc1200, false);
if (!instruct_spwd(cc1200)) {
SYS_LOG_ERR("Could not proceed");
LOG_ERR("Could not proceed");
return -EIO;
}
@ -723,7 +721,7 @@ static int power_on_and_setup(struct device *dev)
struct cc1200_context *cc1200 = dev->driver_data;
if (!instruct_sres(cc1200)) {
SYS_LOG_ERR("Cannot reset");
LOG_ERR("Cannot reset");
return -EIO;
}
@ -734,7 +732,7 @@ static int power_on_and_setup(struct device *dev)
if (!write_reg_iocfg3(cc1200, CC1200_IOCFG3) ||
!write_reg_iocfg2(cc1200, CC1200_IOCFG2) ||
!write_reg_iocfg0(cc1200, CC1200_IOCFG0)) {
SYS_LOG_ERR("Cannot configure GPIOs");
LOG_ERR("Cannot configure GPIOs");
return -EIO;
}
@ -750,7 +748,7 @@ static int configure_spi(struct device *dev)
cc1200->spi = device_get_binding(
CONFIG_IEEE802154_CC1200_SPI_DRV_NAME);
if (!cc1200->spi) {
SYS_LOG_ERR("Unable to get SPI device");
LOG_ERR("Unable to get SPI device");
return -ENODEV;
}
@ -758,7 +756,7 @@ static int configure_spi(struct device *dev)
cs_ctrl.gpio_dev = device_get_binding(
CONFIG_IEEE802154_CC1200_GPIO_SPI_CS_DRV_NAME);
if (!cs_ctrl.gpio_dev) {
SYS_LOG_ERR("Unable to get GPIO SPI CS device");
LOG_ERR("Unable to get GPIO SPI CS device");
return -ENODEV;
}
@ -767,7 +765,7 @@ static int configure_spi(struct device *dev)
cc1200->spi_cfg.cs = &cs_ctrl;
SYS_LOG_DBG("SPI GPIO CS configured on %s:%u",
LOG_DBG("SPI GPIO CS configured on %s:%u",
CONFIG_IEEE802154_CC1200_GPIO_SPI_CS_DRV_NAME,
CONFIG_IEEE802154_CC1200_GPIO_SPI_CS_PIN);
}
@ -791,19 +789,19 @@ static int cc1200_init(struct device *dev)
cc1200->gpios = cc1200_configure_gpios();
if (!cc1200->gpios) {
SYS_LOG_ERR("Configuring GPIOS failed");
LOG_ERR("Configuring GPIOS failed");
return -EIO;
}
if (configure_spi(dev) != 0) {
SYS_LOG_ERR("Configuring SPI failed");
LOG_ERR("Configuring SPI failed");
return -EIO;
}
SYS_LOG_DBG("GPIO and SPI configured");
LOG_DBG("GPIO and SPI configured");
if (power_on_and_setup(dev) != 0) {
SYS_LOG_ERR("Configuring CC1200 failed");
LOG_ERR("Configuring CC1200 failed");
return -EIO;
}
@ -812,7 +810,7 @@ static int cc1200_init(struct device *dev)
(k_thread_entry_t)cc1200_rx,
dev, NULL, NULL, K_PRIO_COOP(2), 0, 0);
SYS_LOG_INF("CC1200 initialized");
LOG_INF("CC1200 initialized");
return 0;
}
@ -823,7 +821,7 @@ static void cc1200_iface_init(struct net_if *iface)
struct cc1200_context *cc1200 = dev->driver_data;
u8_t *mac = get_mac(dev);
SYS_LOG_DBG("");
LOG_DBG("");
net_if_set_link_addr(iface, mac, 8, NET_LINK_IEEE802154);

198
drivers/ieee802154/ieee802154_cc2520.c
View file

@ -6,9 +6,11 @@
* SPDX-License-Identifier: Apache-2.0
*/
#define SYS_LOG_LEVEL CONFIG_SYS_LOG_IEEE802154_DRIVER_LEVEL
#define SYS_LOG_DOMAIN "dev/cc2520"
#include <logging/sys_log.h>
#define LOG_MODULE_NAME ieee802154_cc2520
#define LOG_LEVEL CONFIG_IEEE802154_LOG_LEVEL
#include <logging/log.h>
LOG_MODULE_REGISTER(LOG_MODULE_NAME);
#include <errno.h>
@ -62,21 +64,21 @@ static struct spi_cs_control cs_ctrl;
/*********
* DEBUG *
********/
#if CONFIG_SYS_LOG_IEEE802154_DRIVER_LEVEL == 4
#if CONFIG_IEEE802154_LOG_LEVEL == LOG_LEVEL_DBG
static inline void _cc2520_print_gpio_config(struct device *dev)
{
struct cc2520_context *cc2520 = dev->driver_data;
SYS_LOG_DBG("GPIOCTRL0/1/2/3/4/5 = 0x%x/0x%x/0x%x/0x%x/0x%x/0x%x",
LOG_DBG("GPIOCTRL0/1/2/3/4/5 = 0x%x/0x%x/0x%x/0x%x/0x%x/0x%x",
read_reg_gpioctrl0(cc2520),
read_reg_gpioctrl1(cc2520),
read_reg_gpioctrl2(cc2520),
read_reg_gpioctrl3(cc2520),
read_reg_gpioctrl4(cc2520),
read_reg_gpioctrl5(cc2520));
SYS_LOG_DBG("GPIOPOLARITY: 0x%x",
LOG_DBG("GPIOPOLARITY: 0x%x",
read_reg_gpiopolarity(cc2520));
SYS_LOG_DBG("GPIOCTRL: 0x%x",
LOG_DBG("GPIOCTRL: 0x%x",
read_reg_gpioctrl(cc2520));
}
@ -84,79 +86,75 @@ static inline void _cc2520_print_exceptions(struct cc2520_context *cc2520)
{
u8_t flag = read_reg_excflag0(cc2520);
SYS_LOG_DBG("EXCFLAG0:");
LOG_DBG("EXCFLAG0:");
if (flag & EXCFLAG0_RF_IDLE) {
SYS_LOG_BACKEND_FN("RF_IDLE ");
LOG_DBG(" RF_IDLE");
}
if (flag & EXCFLAG0_TX_FRM_DONE) {
SYS_LOG_BACKEND_FN("TX_FRM_DONE ");
LOG_DBG(" TX_FRM_DONE");
}
if (flag & EXCFLAG0_TX_ACK_DONE) {
SYS_LOG_BACKEND_FN("TX_ACK_DONE ");
LOG_DBG(" TX_ACK_DONE");
}
if (flag & EXCFLAG0_TX_UNDERFLOW) {
SYS_LOG_BACKEND_FN("TX_UNDERFLOW ");
LOG_DBG(" TX_UNDERFLOW");
}
if (flag & EXCFLAG0_TX_OVERFLOW) {
SYS_LOG_BACKEND_FN("TX_OVERFLOW ");
LOG_DBG(" TX_OVERFLOW");
}
if (flag & EXCFLAG0_RX_UNDERFLOW) {
SYS_LOG_BACKEND_FN("RX_UNDERFLOW ");
LOG_DBG(" RX_UNDERFLOW");
}
if (flag & EXCFLAG0_RX_OVERFLOW) {
SYS_LOG_BACKEND_FN("RX_OVERFLOW ");
LOG_DBG(" RX_OVERFLOW");
}
if (flag & EXCFLAG0_RXENABLE_ZERO) {
SYS_LOG_BACKEND_FN("RXENABLE_ZERO");
LOG_DBG(" RXENABLE_ZERO");
}
SYS_LOG_BACKEND_FN("\n");
flag = read_reg_excflag1(cc2520);
SYS_LOG_DBG("EXCFLAG1:");
if (flag & EXCFLAG1_RX_FRM_DONE) {
SYS_LOG_BACKEND_FN("RX_FRM_DONE ");
LOG_DBG(" RX_FRM_DONE");
}
if (flag & EXCFLAG1_RX_FRM_ACCEPTED) {
SYS_LOG_BACKEND_FN("RX_FRM_ACCEPTED ");
LOG_DBG(" RX_FRM_ACCEPTED");
}
if (flag & EXCFLAG1_SRC_MATCH_DONE) {
SYS_LOG_BACKEND_FN("SRC_MATCH_DONE ");
LOG_DBG(" SRC_MATCH_DONE");
}
if (flag & EXCFLAG1_SRC_MATCH_FOUND) {
SYS_LOG_BACKEND_FN("SRC_MATCH_FOUND ");
LOG_DBG(" SRC_MATCH_FOUND");
}
if (flag & EXCFLAG1_FIFOP) {
SYS_LOG_BACKEND_FN("FIFOP ");
LOG_DBG(" FIFOP");
}
if (flag & EXCFLAG1_SFD) {
SYS_LOG_BACKEND_FN("SFD ");
LOG_DBG(" SFD");
}
if (flag & EXCFLAG1_DPU_DONE_L) {
SYS_LOG_BACKEND_FN("DPU_DONE_L ");
LOG_DBG(" DPU_DONE_L");
}
if (flag & EXCFLAG1_DPU_DONE_H) {
SYS_LOG_BACKEND_FN("DPU_DONE_H");
LOG_DBG(" DPU_DONE_H");
}
SYS_LOG_BACKEND_FN("\n");
}
static inline void _cc2520_print_errors(struct cc2520_context *cc2520)
@ -166,40 +164,38 @@ static inline void _cc2520_print_errors(struct cc2520_context *cc2520)
SYS_LOG_DBG("EXCFLAG2:");
if (flag & EXCFLAG2_MEMADDR_ERROR) {
SYS_LOG_BACKEND_FN("MEMADDR_ERROR ");
LOG_DBG(" MEMADDR_ERROR");
}
if (flag & EXCFLAG2_USAGE_ERROR) {
SYS_LOG_BACKEND_FN("USAGE_ERROR ");
LOG_DBG(" USAGE_ERROR");
}
if (flag & EXCFLAG2_OPERAND_ERROR) {
SYS_LOG_BACKEND_FN("OPERAND_ERROR ");
LOG_DBG(" OPERAND_ERROR");
}
if (flag & EXCFLAG2_SPI_ERROR) {
SYS_LOG_BACKEND_FN("SPI_ERROR ");
LOG_DBG(" SPI_ERROR");
}
if (flag & EXCFLAG2_RF_NO_LOCK) {
SYS_LOG_BACKEND_FN("RF_NO_LOCK ");
LOG_DBG(" RF_NO_LOCK");
}
if (flag & EXCFLAG2_RX_FRM_ABORTED) {
SYS_LOG_BACKEND_FN("RX_FRM_ABORTED ");
LOG_DBG(" RX_FRM_ABORTED");
}
if (flag & EXCFLAG2_RFBUFMOV_TIMEOUT) {
SYS_LOG_BACKEND_FN("RFBUFMOV_TIMEOUT");
LOG_DBG(" RFBUFMOV_TIMEOUT");
}
SYS_LOG_BACKEND_FN("\n");
}
#else
#define _cc2520_print_gpio_config(...)
#define _cc2520_print_exceptions(...)
#define _cc2520_print_errors(...)
#endif /* CONFIG_SYS_LOG_IEEE802154_DRIVER_LEVEL == 4 */
#endif /* CONFIG_IEEE802154_LOG_LEVEL == 4 */
/*********************
@ -308,12 +304,12 @@ static int _cc2520_set_pan_id(struct device *dev, u16_t pan_id)
{
struct cc2520_context *cc2520 = dev->driver_data;
SYS_LOG_DBG("0x%x", pan_id);
LOG_DBG("0x%x", pan_id);
pan_id = sys_le16_to_cpu(pan_id);
if (!write_mem_pan_id(cc2520, (u8_t *) &pan_id)) {
SYS_LOG_ERR("Failed");
LOG_ERR("Failed");
return -EIO;
}
@ -324,12 +320,12 @@ static int _cc2520_set_short_addr(struct device *dev, u16_t short_addr)
{
struct cc2520_context *cc2520 = dev->driver_data;
SYS_LOG_DBG("0x%x", short_addr);
LOG_DBG("0x%x", short_addr);
short_addr = sys_le16_to_cpu(short_addr);
if (!write_mem_short_addr(cc2520, (u8_t *) &short_addr)) {
SYS_LOG_ERR("Failed");
LOG_ERR("Failed");
return -EIO;
}
@ -341,11 +337,11 @@ static int _cc2520_set_ieee_addr(struct device *dev, const u8_t *ieee_addr)
struct cc2520_context *cc2520 = dev->driver_data;
if (!write_mem_ext_addr(cc2520, (void *)ieee_addr)) {
SYS_LOG_ERR("Failed");
LOG_ERR("Failed");
return -EIO;
}
SYS_LOG_DBG("IEEE address %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
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]);
@ -553,7 +549,7 @@ static inline bool read_rxfifo_content(struct cc2520_context *ctx,
}
if (read_reg_excflag0(ctx) & EXCFLAG0_RX_UNDERFLOW) {
SYS_LOG_ERR("RX underflow!");
LOG_ERR("RX underflow!");
return false;
}
@ -631,7 +627,7 @@ static void cc2520_rx(int arg)
k_sem_take(&cc2520->rx_lock, K_FOREVER);
if (cc2520->overflow) {
SYS_LOG_ERR("RX overflow!");
LOG_ERR("RX overflow!");
cc2520->overflow = false;
goto flush;
@ -639,19 +635,19 @@ static void cc2520_rx(int arg)
pkt_len = read_rxfifo_length(cc2520) & 0x7f;
if (!verify_rxfifo_validity(cc2520, pkt_len)) {
SYS_LOG_ERR("Invalid content");
LOG_ERR("Invalid content");
goto flush;
}
pkt = net_pkt_get_reserve_rx(0, K_NO_WAIT);
if (!pkt) {
SYS_LOG_ERR("No pkt available");
LOG_ERR("No pkt available");
goto flush;
}
pkt_frag = net_pkt_get_frag(pkt, K_NO_WAIT);
if (!pkt_frag) {
SYS_LOG_ERR("No pkt_frag available");
LOG_ERR("No pkt_frag available");
goto flush;
}
@ -662,24 +658,24 @@ static void cc2520_rx(int arg)
}
if (!read_rxfifo_content(cc2520, pkt_frag, pkt_len)) {
SYS_LOG_ERR("No content read");
LOG_ERR("No content read");
goto flush;
}
if (!verify_crc(cc2520, pkt)) {
SYS_LOG_ERR("Bad packet CRC");
LOG_ERR("Bad packet CRC");
goto out;
}
if (ieee802154_radio_handle_ack(cc2520->iface, pkt) == NET_OK) {
SYS_LOG_DBG("ACK packet handled");
LOG_DBG("ACK packet handled");
goto out;
}
SYS_LOG_DBG("Caught a packet (%u)", pkt_len);
LOG_DBG("Caught a packet (%u)", pkt_len);
if (net_recv_data(cc2520->iface, pkt) < 0) {
SYS_LOG_DBG("Packet dropped by NET stack");
LOG_DBG("Packet dropped by NET stack");
goto out;
}
@ -714,7 +710,7 @@ static int cc2520_cca(struct device *dev)
struct cc2520_context *cc2520 = dev->driver_data;
if (!get_cca(cc2520)) {
SYS_LOG_WRN("Busy");
LOG_WRN("Busy");
return -EBUSY;
}
@ -725,7 +721,7 @@ static int cc2520_set_channel(struct device *dev, u16_t channel)
{
struct cc2520_context *cc2520 = dev->driver_data;
SYS_LOG_DBG("%u", channel);
LOG_DBG("%u", channel);
if (channel < 11 || channel > 26) {
return -EINVAL;
@ -735,7 +731,7 @@ static int cc2520_set_channel(struct device *dev, u16_t channel)
channel = 11 + 5 * (channel - 11);
if (!write_reg_freqctrl(cc2520, FREQCTRL_FREQ(channel))) {
SYS_LOG_ERR("Failed");
LOG_ERR("Failed");
return -EIO;
}
@ -747,7 +743,7 @@ static int cc2520_filter(struct device *dev,
enum ieee802154_filter_type type,
const struct ieee802154_filter *filter)
{
SYS_LOG_DBG("Applying filter %u", type);
LOG_DBG("Applying filter %u", type);
if (!set) {
return -ENOTSUP;
@ -769,7 +765,7 @@ static int cc2520_set_txpower(struct device *dev, s16_t dbm)
struct cc2520_context *cc2520 = dev->driver_data;
u8_t pwr;
SYS_LOG_DBG("%d", dbm);
LOG_DBG("%d", dbm);
/* See chapter 19 part 8 */
switch (dbm) {
@ -810,7 +806,7 @@ static int cc2520_set_txpower(struct device *dev, s16_t dbm)
return 0;
error:
SYS_LOG_ERR("Failed");
LOG_ERR("Failed");
return -EIO;
}
@ -824,17 +820,17 @@ static int cc2520_tx(struct device *dev,
u8_t retry = 2;
bool status;
SYS_LOG_DBG("%p (%u)", frag, len);
LOG_DBG("%p (%u)", frag, len);
if (!write_reg_excflag0(cc2520, EXCFLAG0_RESET_TX_FLAGS) ||
!write_txfifo_length(cc2520, len) ||
!write_txfifo_content(cc2520, frame, len)) {
SYS_LOG_ERR("Cannot feed in TX fifo");
LOG_ERR("Cannot feed in TX fifo");
goto error;
}
if (!verify_txfifo_status(cc2520, len)) {
SYS_LOG_ERR("Did not write properly into TX FIFO");
LOG_ERR("Did not write properly into TX FIFO");
goto error;
}
@ -848,7 +844,7 @@ static int cc2520_tx(struct device *dev,
k_sem_init(&cc2520->tx_sync, 0, UINT_MAX);
if (!instruct_stxoncca(cc2520)) {
SYS_LOG_ERR("Cannot start transmission");
LOG_ERR("Cannot start transmission");
goto error;
}
@ -870,7 +866,7 @@ error:
#ifdef CONFIG_IEEE802154_CC2520_CRYPTO
k_sem_give(&cc2520->access_lock);
#endif
SYS_LOG_ERR("No TX_FRM_DONE");
LOG_ERR("No TX_FRM_DONE");
_cc2520_print_exceptions(cc2520);
_cc2520_print_errors(cc2520);
@ -884,12 +880,10 @@ static int cc2520_start(struct device *dev)
{
struct cc2520_context *cc2520 = dev->driver_data;
SYS_LOG_DBG("");
if (!instruct_sxoscon(cc2520) ||
!instruct_srxon(cc2520) ||
!verify_osc_stabilization(cc2520)) {
SYS_LOG_ERR("Error starting CC2520");
LOG_ERR("Error starting CC2520");
return -EIO;
}
@ -905,8 +899,6 @@ static int cc2520_stop(struct device *dev)
{
struct cc2520_context *cc2520 = dev->driver_data;
SYS_LOG_DBG("");
flush_rxfifo(cc2520);
enable_fifop_interrupt(cc2520, false);
@ -914,7 +906,7 @@ static int cc2520_stop(struct device *dev)
if (!instruct_srfoff(cc2520) ||
!instruct_sxoscoff(cc2520)) {
SYS_LOG_ERR("Error stopping CC2520");
LOG_ERR("Error stopping CC2520");
return -EIO;
}
@ -997,7 +989,7 @@ static inline int configure_spi(struct device *dev)
cc2520->spi = device_get_binding(
CONFIG_IEEE802154_CC2520_SPI_DRV_NAME);
if (!cc2520->spi) {
SYS_LOG_ERR("Unable to get SPI device");
LOG_ERR("Unable to get SPI device");
return -ENODEV;
}
@ -1005,7 +997,7 @@ static inline int configure_spi(struct device *dev)
cs_ctrl.gpio_dev = device_get_binding(
CONFIG_IEEE802154_CC2520_GPIO_SPI_CS_DRV_NAME);
if (!cs_ctrl.gpio_dev) {
SYS_LOG_ERR("Unable to get GPIO SPI CS device");
LOG_ERR("Unable to get GPIO SPI CS device");
return -ENODEV;
}
@ -1014,7 +1006,7 @@ static inline int configure_spi(struct device *dev)
cc2520->spi_cfg.cs = &cs_ctrl;
SYS_LOG_DBG("SPI GPIO CS configured on %s:%u",
LOG_DBG("SPI GPIO CS configured on %s:%u",
CONFIG_IEEE802154_CC2520_GPIO_SPI_CS_DRV_NAME,
CONFIG_IEEE802154_CC2520_GPIO_SPI_CS_PIN);
#endif /* CONFIG_IEEE802154_CC2520_GPIO_SPI_CS */
@ -1039,19 +1031,19 @@ static int cc2520_init(struct device *dev)
cc2520->gpios = cc2520_configure_gpios();
if (!cc2520->gpios) {
SYS_LOG_ERR("Configuring GPIOS failed");
LOG_ERR("Configuring GPIOS failed");
return -EIO;
}
if (configure_spi(dev) != 0) {
SYS_LOG_ERR("Configuring SPI failed");
LOG_ERR("Configuring SPI failed");
return -EIO;
}
SYS_LOG_DBG("GPIO and SPI configured");
LOG_DBG("GPIO and SPI configured");
if (power_on_and_setup(dev) != 0) {
SYS_LOG_ERR("Configuring CC2520 failed");
LOG_ERR("Configuring CC2520 failed");
return -EIO;
}
@ -1060,7 +1052,7 @@ static int cc2520_init(struct device *dev)
(k_thread_entry_t)cc2520_rx,
dev, NULL, NULL, K_PRIO_COOP(2), 0, 0);
SYS_LOG_INF("CC2520 initialized");
LOG_INF("CC2520 initialized");
return 0;
}
@ -1071,8 +1063,6 @@ static void cc2520_iface_init(struct net_if *iface)
struct cc2520_context *cc2520 = dev->driver_data;
u8_t *mac = get_mac(dev);
SYS_LOG_DBG("");
net_if_set_link_addr(iface, mac, 8, NET_LINK_IEEE802154);
cc2520->iface = iface;
@ -1156,7 +1146,7 @@ static inline bool instruct_uccm_ccm(struct cc2520_context *cc2520,
int ret;
SYS_LOG_DBG("%sCCM(P={01} K={%02x} C={%02x} N={%02x}"
LOG_DBG("%sCCM(P={01} K={%02x} C={%02x} N={%02x}"
" A={%03x} E={%03x} F{%02x} M={%02x})",
uccm ? "U" : "", key_addr, auth_crypt, nonce_addr,
input_addr, output_addr, in_len, m);
@ -1179,7 +1169,7 @@ static inline bool instruct_uccm_ccm(struct cc2520_context *cc2520,
k_sem_give(&cc2520->access_lock);
if (ret) {
SYS_LOG_ERR("%sCCM Failed", uccm ? "U" : "");
LOG_ERR("%sCCM Failed", uccm ? "U" : "");
return false;
}
@ -1211,33 +1201,33 @@ static int insert_crypto_parameters(struct cipher_ctx *ctx,
u8_t m = 0;
if (!apkt->pkt->out_buf || !apkt->pkt->out_buf_max) {
SYS_LOG_ERR("Out buffer needs to be set");
LOG_ERR("Out buffer needs to be set");
return -EINVAL;
}
if (!ctx->key.bit_stream || !ctx->keylen) {
SYS_LOG_ERR("No key installed");
LOG_ERR("No key installed");
return -EINVAL;
}
if (!(ctx->flags & CAP_INPLACE_OPS)) {
SYS_LOG_ERR("It supports only in-place operation");
LOG_ERR("It supports only in-place operation");
return -EINVAL;
}
if (!apkt->ad || !apkt->ad_len) {
SYS_LOG_ERR("CCM needs associated data");
LOG_ERR("CCM needs associated data");
return -EINVAL;
}
if (apkt->pkt->in_buf && apkt->pkt->in_buf - apkt->ad_len != apkt->ad) {
SYS_LOG_ERR("In-place needs ad and input in same memory");
LOG_ERR("In-place needs ad and input in same memory");
return -EINVAL;
}
if (!apkt->pkt->in_buf) {
if (!ctx->mode_params.ccm_info.tag_len) {
SYS_LOG_ERR("Auth only needs a tag length");
LOG_ERR("Auth only needs a tag length");
return -EINVAL;
}
@ -1267,7 +1257,7 @@ static int insert_crypto_parameters(struct cipher_ctx *ctx,
/* Writing the frame in RAM */
if (!_cc2520_write_ram(cc2520, CC2520_MEM_DATA, in_buf, in_len)) {
SYS_LOG_ERR("Cannot write the frame in RAM");
LOG_ERR("Cannot write the frame in RAM");
return -EIO;
}
@ -1276,7 +1266,7 @@ static int insert_crypto_parameters(struct cipher_ctx *ctx,
/* Writing the key in RAM */
if (!_cc2520_write_ram(cc2520, CC2520_MEM_KEY, data, 16)) {
SYS_LOG_ERR("Cannot write the key in RAM");
LOG_ERR("Cannot write the key in RAM");
return -EIO;
}
@ -1284,7 +1274,7 @@ static int insert_crypto_parameters(struct cipher_ctx *ctx,
/* Writing the nonce in RAM */
if (!_cc2520_write_ram(cc2520, CC2520_MEM_NONCE, data, 16)) {
SYS_LOG_ERR("Cannot write the nonce in RAM");
LOG_ERR("Cannot write the nonce in RAM");
return -EIO;
}
@ -1300,18 +1290,18 @@ static int _cc2520_crypto_ccm(struct cipher_ctx *ctx,
int m;
if (!apkt || !apkt->pkt) {
SYS_LOG_ERR("Invalid crypto packet to operate with");
LOG_ERR("Invalid crypto packet to operate with");
return -EINVAL;
}
if (apkt->tag) {
SYS_LOG_ERR("CCM encryption does not take a tag");
LOG_ERR("CCM encryption does not take a tag");
return -EINVAL;
}
m = insert_crypto_parameters(ctx, apkt, ccm_nonce, &auth_crypt);
if (m < 0) {
SYS_LOG_ERR("Inserting crypto parameters failed");
LOG_ERR("Inserting crypto parameters failed");
return m;
}
@ -1319,7 +1309,7 @@ static int _cc2520_crypto_ccm(struct cipher_ctx *ctx,
(m ? ctx->mode_params.ccm_info.tag_len : 0);
if (apkt->pkt->out_len > apkt->pkt->out_buf_max) {
SYS_LOG_ERR("Result will not fit into out buffer %u vs %u",
LOG_ERR("Result will not fit into out buffer %u vs %u",
apkt->pkt->out_len, apkt->pkt->out_buf_max);
return -ENOBUFS;
}
@ -1329,7 +1319,7 @@ static int _cc2520_crypto_ccm(struct cipher_ctx *ctx,
0x000, apkt->ad_len, m) ||
!_cc2520_read_ram(cc2520, CC2520_MEM_DATA,
apkt->pkt->out_buf, apkt->pkt->out_len)) {
SYS_LOG_ERR("CCM or reading result from RAM failed");
LOG_ERR("CCM or reading result from RAM failed");
return -EIO;
}
@ -1347,12 +1337,12 @@ static int _cc2520_crypto_uccm(struct cipher_ctx *ctx,
int m;
if (!apkt || !apkt->pkt) {
SYS_LOG_ERR("Invalid crypto packet to operate with");
LOG_ERR("Invalid crypto packet to operate with");
return -EINVAL;
}
if (ctx->mode_params.ccm_info.tag_len && !apkt->tag) {
SYS_LOG_ERR("In case of MIC you need to provide a tag");
LOG_ERR("In case of MIC you need to provide a tag");
return -EINVAL;
}
@ -1368,12 +1358,12 @@ static int _cc2520_crypto_uccm(struct cipher_ctx *ctx,
0x000, apkt->ad_len, m) ||
!_cc2520_read_ram(cc2520, CC2520_MEM_DATA,
apkt->pkt->out_buf, apkt->pkt->out_len)) {
SYS_LOG_ERR("UCCM or reading result from RAM failed");
LOG_ERR("UCCM or reading result from RAM failed");
return -EIO;
}
if (m && (!(read_reg_dpustat(cc2520) & DPUSTAT_AUTHSTAT_H))) {
SYS_LOG_ERR("Authentication of the frame failed");
LOG_ERR("Authentication of the frame failed");
return -EBADMSG;
}
@ -1392,12 +1382,12 @@ static int cc2520_crypto_begin_session(struct device *dev,
enum cipher_op op_type)
{
if (algo != CRYPTO_CIPHER_ALGO_AES || mode != CRYPTO_CIPHER_MODE_CCM) {
SYS_LOG_ERR("Wrong algo (%u) or mode (%u)", algo, mode);
LOG_ERR("Wrong algo (%u) or mode (%u)", algo, mode);
return -EINVAL;
}
if (ctx->mode_params.ccm_info.nonce_len != 13) {
SYS_LOG_ERR("Nonce length erroneous (%u)",
LOG_ERR("Nonce length erroneous (%u)",
ctx->mode_params.ccm_info.nonce_len);
return -EINVAL;
}
@ -1427,7 +1417,7 @@ static int cc2520_crypto_free_session(struct device *dev,
static int cc2520_crypto_init(struct device *dev)
{
SYS_LOG_INF("CC2520 crypto part initialized");
LOG_INF("CC2520 crypto part initialized");
return 0;
}

58
drivers/ieee802154/ieee802154_kw41z.c
View file

@ -6,9 +6,11 @@
* SPDX-License-Identifier: Apache-2.0
*/
#define SYS_LOG_LEVEL CONFIG_SYS_LOG_IEEE802154_DRIVER_LEVEL
#define SYS_LOG_DOMAIN "IEEE802154_KW41Z"
#include <logging/sys_log.h>
#define LOG_MODULE_NAME ieee802154_kw41z
#define LOG_LEVEL CONFIG_IEEE802154_LOG_LEVEL
#include <logging/log.h>
LOG_MODULE_REGISTER(LOG_MODULE_NAME);
#include <zephyr.h>
#include <kernel.h>
@ -183,7 +185,7 @@ static inline void kw41z_wait_for_idle(void)
}
if (state != KW41Z_STATE_IDLE) {
SYS_LOG_ERR("Error waiting for idle state");
LOG_ERR("Error waiting for idle state");
}
}
@ -412,7 +414,7 @@ static int kw41z_filter(struct device *dev,
enum ieee802154_filter_type type,
const struct ieee802154_filter *filter)
{
SYS_LOG_DBG("Applying filter %u", type);
LOG_DBG("Applying filter %u", type);
if (!set) {
return -ENOTSUP;
@ -478,7 +480,7 @@ static inline void kw41z_rx(struct kw41z_context *kw41z, u8_t len)
u8_t pkt_len, hw_lqi;
int rslt;
SYS_LOG_DBG("ENTRY: len: %d", len);
LOG_DBG("ENTRY: len: %d", len);
#if defined(CONFIG_NET_L2_OPENTHREAD)
/*
@ -491,13 +493,13 @@ static inline void kw41z_rx(struct kw41z_context *kw41z, u8_t len)
pkt = net_pkt_get_reserve_rx(0, K_NO_WAIT);
if (!pkt) {
SYS_LOG_ERR("No buf available");
LOG_ERR("No buf available");
goto out;
}
frag = net_pkt_get_frag(pkt, K_NO_WAIT);
if (!frag) {
SYS_LOG_ERR("No frag available");
LOG_ERR("No frag available");
goto out;
}
@ -542,7 +544,7 @@ static inline void kw41z_rx(struct kw41z_context *kw41z, u8_t len)
rslt = net_recv_data(kw41z->iface, pkt);
if (rslt < 0) {
SYS_LOG_ERR("RCV Packet dropped by NET stack: %d", rslt);
LOG_ERR("RCV Packet dropped by NET stack: %d", rslt);
goto out;
}
@ -568,12 +570,12 @@ static int kw41z_tx(struct device *dev, struct net_pkt *pkt,
* state.
*/
if (kw41z_get_seq_state() != KW41Z_STATE_IDLE) {
SYS_LOG_WRN("Can't initiate new SEQ state");
LOG_WRN("Can't initiate new SEQ state");
return -EBUSY;
}
if (payload_len > KW41Z_PSDU_LENGTH) {
SYS_LOG_ERR("Payload too long");
LOG_ERR("Payload too long");
return 0;
}
@ -610,7 +612,7 @@ static int kw41z_tx(struct device *dev, struct net_pkt *pkt,
payload_len * KW41Z_PER_BYTE_TIME + 10 +
KW41Z_ACK_WAIT_TIME;
SYS_LOG_DBG("AUTOACK ENABLED: len: %d, timeout: %d, seq: %d",
LOG_DBG("AUTOACK ENABLED: len: %d, timeout: %d, seq: %d",
payload_len, tx_timeout,
(frag->data - net_pkt_ll_reserve(pkt))[2]);
@ -618,7 +620,7 @@ static int kw41z_tx(struct device *dev, struct net_pkt *pkt,
ZLL->PHY_CTRL |= ZLL_PHY_CTRL_RXACKRQD_MASK;
xcvseq = KW41Z_STATE_TXRX;
} else {
SYS_LOG_DBG("AUTOACK DISABLED: len: %d, seq: %d",
LOG_DBG("AUTOACK DISABLED: len: %d, seq: %d",
payload_len, (frag->data - net_pkt_ll_reserve(pkt))[2]);
ZLL->PHY_CTRL &= ~ZLL_PHY_CTRL_RXACKRQD_MASK;
@ -638,7 +640,7 @@ static int kw41z_tx(struct device *dev, struct net_pkt *pkt,
irq_unlock(key);
k_sem_take(&kw41z->seq_sync, K_FOREVER);
SYS_LOG_DBG("seq_retval: %d", kw41z->seq_retval);
LOG_DBG("seq_retval: %d", kw41z->seq_retval);
return kw41z->seq_retval;
}
@ -648,16 +650,14 @@ static void kw41z_isr(int unused)
u8_t state = kw41z_get_seq_state();
u8_t restart_rx = 1;
u32_t rx_len;
#if defined(CONFIG_KW41_DBG_TRACE) || \
(CONFIG_SYS_LOG_IEEE802154_DRIVER_LEVEL > SYS_LOG_LEVEL_INFO)
/*
* Variable is used in debug output to capture the state of the
* sequencer at interrupt.
*/
u32_t seq_state = ZLL->SEQ_STATE;
#endif
SYS_LOG_DBG("ENTRY: irqsts: 0x%08X, PHY_CTRL: 0x%08X, "
LOG_DBG("ENTRY: irqsts: 0x%08X, PHY_CTRL: 0x%08X, "
"SEQ_STATE: 0x%08X, SEQ_CTRL: 0x%08X, TMR: %d, state: %d",
irqsts, (unsigned int)ZLL->PHY_CTRL,
(unsigned int)seq_state,
@ -669,7 +669,7 @@ static void kw41z_isr(int unused)
ZLL->IRQSTS = irqsts;
if (irqsts & ZLL_IRQSTS_FILTERFAIL_IRQ_MASK) {
SYS_LOG_DBG("Incoming RX failed packet filtering rules: "
LOG_DBG("Incoming RX failed packet filtering rules: "
"CODE: 0x%08X, irqsts: 0x%08X, PHY_CTRL: 0x%08X, "
"SEQ_STATE: 0x%08X, state: %d",
(unsigned int)ZLL->FILTERFAIL_CODE,
@ -698,7 +698,7 @@ static void kw41z_isr(int unused)
if (rx_len > IEEE802154_ACK_LENGTH) {
SYS_LOG_DBG("WMRK irq: seq_state: 0x%08x, rx_len: %d",
LOG_DBG("WMRK irq: seq_state: 0x%08x, rx_len: %d",
seq_state, rx_len);
/*
* Assume the RX includes an auto-ACK so set the
@ -724,7 +724,7 @@ static void kw41z_isr(int unused)
* PLL unlock
*/
if (irqsts & ZLL_IRQSTS_PLL_UNLOCK_IRQ_MASK) {
SYS_LOG_ERR("PLL unlock error");
LOG_ERR("PLL unlock error");
kw41z_isr_seq_cleanup();
restart_rx = 1;
}
@ -736,7 +736,7 @@ static void kw41z_isr(int unused)
(!(irqsts & ZLL_IRQSTS_RXIRQ_MASK)) &&
(state != KW41Z_STATE_TX)) {
SYS_LOG_DBG("a) TMR3 timeout: irqsts: 0x%08X, "
LOG_DBG("a) TMR3 timeout: irqsts: 0x%08X, "
"seq_state: 0x%08X, PHY_CTRL: 0x%08X, "
"state: %d",
irqsts, seq_state,
@ -759,7 +759,7 @@ static void kw41z_isr(int unused)
switch (state) {
case KW41Z_STATE_RX:
SYS_LOG_DBG("RX seq done: SEQ_STATE: 0x%08X",
LOG_DBG("RX seq done: SEQ_STATE: 0x%08X",
(unsigned int)seq_state);
KW_DBG_TRACE(KW41_DBG_TRACE_RX, irqsts,
@ -780,10 +780,10 @@ static void kw41z_isr(int unused)
restart_rx = 1;
break;
case KW41Z_STATE_TXRX:
SYS_LOG_DBG("TXRX seq done");
LOG_DBG("TXRX seq done");
kw41z_tmr3_disable();
case KW41Z_STATE_TX:
SYS_LOG_DBG("TX seq done");
LOG_DBG("TX seq done");
KW_DBG_TRACE(KW41_DBG_TRACE_TX, irqsts,
(unsigned int)ZLL->PHY_CTRL, seq_state);
if (irqsts & ZLL_IRQSTS_CCA_MASK) {
@ -801,7 +801,7 @@ static void kw41z_isr(int unused)
break;
case KW41Z_STATE_CCA:
SYS_LOG_DBG("CCA seq done");
LOG_DBG("CCA seq done");
KW_DBG_TRACE(KW41_DBG_TRACE_CCA, irqsts,
(unsigned int)ZLL->PHY_CTRL, seq_state);
if (irqsts & ZLL_IRQSTS_CCA_MASK) {
@ -819,7 +819,7 @@ static void kw41z_isr(int unused)
k_sem_give(&kw41z_context_data.seq_sync);
break;
default:
SYS_LOG_DBG("Unhandled state: %d", state);
LOG_DBG("Unhandled state: %d", state);
restart_rx = 1;
break;
}
@ -829,7 +829,7 @@ static void kw41z_isr(int unused)
if ((irqsts & ZLL_IRQSTS_TMR3IRQ_MASK) &&
(!(irqsts & ZLL_IRQSTS_TMR3MSK_MASK))) {
SYS_LOG_DBG("b) TMR3 timeout: irqsts: 0x%08X, "
LOG_DBG("b) TMR3 timeout: irqsts: 0x%08X, "
"seq_state: 0x%08X, state: %d",
irqsts, seq_state, state);
@ -849,7 +849,7 @@ static void kw41z_isr(int unused)
/* Restart RX */
if (restart_rx) {
SYS_LOG_DBG("RESET RX");
LOG_DBG("RESET RX");
kw41z_phy_abort();
kw41z_set_seq_state(KW41Z_STATE_RX);
kw41z_enable_seq_irq();

194
drivers/ieee802154/ieee802154_mcr20a.c
View file

@ -6,9 +6,11 @@
* SPDX-License-Identifier: Apache-2.0
*/
#define SYS_LOG_LEVEL CONFIG_SYS_LOG_IEEE802154_DRIVER_LEVEL
#define SYS_LOG_DOMAIN "dev/mcr20a"
#include <logging/sys_log.h>
#define LOG_MODULE_NAME ieee802154_mcr20a
#define LOG_LEVEL CONFIG_IEEE802154_LOG_LEVEL
#include <logging/log.h>
LOG_MODULE_REGISTER(LOG_MODULE_NAME);
#include <errno.h>
@ -40,7 +42,7 @@
*/
#define _MAX_PKT_TX_DURATION (133 + 9 + 8 + 9)
#if (SYS_LOG_LEVEL == 4)
#if LOG_LEVEL == LOG_LEVEL_DBG
/* Prevent timer overflow during SYS_LOG_* output */
#define _MACACKWAITDURATION (864 / 16 + 11625)
#define MCR20A_SEQ_SYNC_TIMEOUT (200)
@ -173,7 +175,7 @@ u8_t _mcr20a_read_reg(struct mcr20a_context *dev, bool dreg, u8_t addr)
return cmd_buf[len - 1];
}
SYS_LOG_ERR("Failed");
LOG_ERR("Failed");
return 0;
}
@ -287,7 +289,7 @@ static int mcr20a_timer_set(struct mcr20a_context *mcr20a,
now = sys_le32_to_cpu(now);
next = now + timeout;
SYS_LOG_DBG("now: 0x%x set 0x%x", now, next);
LOG_DBG("now: 0x%x set 0x%x", now, next);
next = sys_cpu_to_le32(next);
switch (cmp_reg) {
@ -314,7 +316,7 @@ static int mcr20a_timer_set(struct mcr20a_context *mcr20a,
return 0;
error:
SYS_LOG_ERR("Failed");
LOG_ERR("Failed");
return -EIO;
}
@ -339,11 +341,11 @@ static int mcr20a_timer_init(struct device *dev, u8_t tb)
goto error;
}
SYS_LOG_DBG("done, timebase %d", tb);
LOG_DBG("done, timebase %d", tb);
return 0;
error:
SYS_LOG_ERR("Failed");
LOG_ERR("Failed");
return -EIO;
}
@ -375,7 +377,7 @@ static int mcr20a_t4cmp_set(struct mcr20a_context *mcr20a,
return 0;
error:
SYS_LOG_DBG("Failed");
LOG_DBG("Failed");
return -EIO;
}
@ -400,7 +402,7 @@ static int mcr20a_t4cmp_clear(struct mcr20a_context *mcr20a)
return 0;
error:
SYS_LOG_DBG("Failed");
LOG_DBG("Failed");
return -EIO;
}
@ -415,7 +417,7 @@ static inline void _xcvseq_wait_until_idle(struct mcr20a_context *mcr20a)
} while ((state & MCR20A_SEQ_STATE_MASK) && retries);
if (state & MCR20A_SEQ_STATE_MASK) {
SYS_LOG_ERR("Timeout");
LOG_ERR("Timeout");
}
}
@ -425,7 +427,7 @@ static inline int mcr20a_abort_sequence(struct mcr20a_context *mcr20a,
u8_t ctrl1;
ctrl1 = read_reg_phy_ctrl1(mcr20a);
SYS_LOG_DBG("CTRL1 0x%02x", ctrl1);
LOG_DBG("CTRL1 0x%02x", ctrl1);
if (((ctrl1 & MCR20A_PHY_CTRL1_XCVSEQ_MASK) == MCR20A_XCVSEQ_TX) ||
((ctrl1 & MCR20A_PHY_CTRL1_XCVSEQ_MASK) == MCR20A_XCVSEQ_TX_RX)) {
@ -548,25 +550,25 @@ static inline void mcr20a_rx(struct mcr20a_context *mcr20a, u8_t len)
pkt = net_pkt_get_reserve_rx(0, K_NO_WAIT);
if (!pkt) {
SYS_LOG_ERR("No buf available");
LOG_ERR("No buf available");
goto out;
}
frag = net_pkt_get_frag(pkt, K_NO_WAIT);
if (!frag) {
SYS_LOG_ERR("No frag available");
LOG_ERR("No frag available");
goto out;
}
net_pkt_frag_insert(pkt, frag);
if (!read_rxfifo_content(mcr20a, frag, pkt_len)) {
SYS_LOG_ERR("No content read");
LOG_ERR("No content read");
goto out;
}
if (ieee802154_radio_handle_ack(mcr20a->iface, pkt) == NET_OK) {
SYS_LOG_DBG("ACK packet handled");
LOG_DBG("ACK packet handled");
goto out;
}
@ -574,12 +576,12 @@ static inline void mcr20a_rx(struct mcr20a_context *mcr20a, u8_t len)
net_pkt_set_ieee802154_rssi(pkt, mcr20a_get_rssi(
net_pkt_ieee802154_lqi(pkt)));
SYS_LOG_DBG("Caught a packet (%u) (LQI: %u, RSSI: %u)",
LOG_DBG("Caught a packet (%u) (LQI: %u, RSSI: %u)",
pkt_len, net_pkt_ieee802154_lqi(pkt),
net_pkt_ieee802154_rssi(pkt));
if (net_recv_data(mcr20a->iface, pkt) < 0) {
SYS_LOG_DBG("Packet dropped by NET stack");
LOG_DBG("Packet dropped by NET stack");
goto out;
}
@ -610,9 +612,9 @@ static inline bool _irqsts1_event(struct mcr20a_context *mcr20a,
case MCR20A_XCVSEQ_RECEIVE:
if ((dregs[MCR20A_IRQSTS1] & MCR20A_IRQSTS1_RXIRQ)) {
if ((dregs[MCR20A_IRQSTS1] & MCR20A_IRQSTS1_TXIRQ)) {
SYS_LOG_DBG("Finished RxSeq + TxAck");
LOG_DBG("Finished RxSeq + TxAck");
} else {
SYS_LOG_DBG("Finished RxSeq");
LOG_DBG("Finished RxSeq");
}
mcr20a_rx(mcr20a, dregs[MCR20A_RX_FRM_LEN]);
@ -623,7 +625,7 @@ static inline bool _irqsts1_event(struct mcr20a_context *mcr20a,
case MCR20A_XCVSEQ_TX_RX:
if (dregs[MCR20A_IRQSTS1] & MCR20A_IRQSTS1_CCAIRQ) {
if (dregs[MCR20A_IRQSTS2] & MCR20A_IRQSTS2_CCA) {
SYS_LOG_DBG("Finished CCA, CH busy");
LOG_DBG("Finished CCA, CH busy");
atomic_set(&mcr20a->seq_retval, -EBUSY);
retval = true;
break;
@ -634,11 +636,11 @@ static inline bool _irqsts1_event(struct mcr20a_context *mcr20a,
atomic_set(&mcr20a->seq_retval, 0);
if ((dregs[MCR20A_IRQSTS1] & MCR20A_IRQSTS1_RXIRQ)) {
SYS_LOG_DBG("Finished TxSeq + RxAck");
LOG_DBG("Finished TxSeq + RxAck");
/* Got Ack, timer should be disabled. */
mcr20a_t4cmp_clear(mcr20a);
} else {
SYS_LOG_DBG("Finished TxSeq");
LOG_DBG("Finished TxSeq");
}
retval = true;
@ -652,7 +654,7 @@ static inline bool _irqsts1_event(struct mcr20a_context *mcr20a,
/* mcr20a_t4cmp_clear(mcr20a); */
if (dregs[MCR20A_IRQSTS2] & MCR20A_IRQSTS2_CCA) {
SYS_LOG_DBG("Finished CCA, CH busy");
LOG_DBG("Finished CCA, CH busy");
atomic_set(&mcr20a->seq_retval, -EBUSY);
} else {
/**
@ -660,7 +662,7 @@ static inline bool _irqsts1_event(struct mcr20a_context *mcr20a,
* a transmit sequence follows and
* set here the sequence manager to Idle.
*/
SYS_LOG_DBG("Finished CCA, CH idle");
LOG_DBG("Finished CCA, CH idle");
new_seq = MCR20A_XCVSEQ_IDLE;
atomic_set(&mcr20a->seq_retval, 0);
}
@ -670,8 +672,8 @@ static inline bool _irqsts1_event(struct mcr20a_context *mcr20a,
break;
case MCR20A_XCVSEQ_IDLE:
default:
SYS_LOG_ERR("SEQ triggered, but XCVSEQ is in the Idle state");
SYS_LOG_ERR("IRQSTS: 0x%02x", dregs[MCR20A_IRQSTS1]);
LOG_ERR("SEQ triggered, but XCVSEQ is in the Idle state");
LOG_ERR("IRQSTS: 0x%02x", dregs[MCR20A_IRQSTS1]);
break;
}
@ -692,7 +694,7 @@ static inline bool _irqsts3_event(struct mcr20a_context *mcr20a,
bool retval = false;
if (dregs[MCR20A_IRQSTS3] & MCR20A_IRQSTS3_TMR4IRQ) {
SYS_LOG_DBG("Sequence timeout, IRQSTSs 0x%02x 0x%02x 0x%02x",
LOG_DBG("Sequence timeout, IRQSTSs 0x%02x 0x%02x 0x%02x",
dregs[MCR20A_IRQSTS1],
dregs[MCR20A_IRQSTS2],
dregs[MCR20A_IRQSTS3]);
@ -706,7 +708,7 @@ static inline bool _irqsts3_event(struct mcr20a_context *mcr20a,
dregs[MCR20A_IRQSTS1] = MCR20A_IRQSTS1_IRQ_MASK;
retval = true;
} else {
SYS_LOG_ERR("IRQSTS3 contains untreated IRQs: 0x%02x",
LOG_ERR("IRQSTS3 contains untreated IRQs: 0x%02x",
dregs[MCR20A_IRQSTS3]);
}
@ -728,13 +730,13 @@ static void mcr20a_thread_main(void *arg)
set_new_seq = false;
if (!mcr20a_mask_irqb(mcr20a, true)) {
SYS_LOG_ERR("Failed to mask IRQ_B");
LOG_ERR("Failed to mask IRQ_B");
goto unmask_irqb;
}
/* Read the register from IRQSTS1 until CTRL4 */
if (!read_burst_irqsts1_ctrl4(mcr20a, dregs)) {
SYS_LOG_ERR("Failed to read register");
LOG_ERR("Failed to read register");
goto unmask_irqb;
}
/* make backup from PHY_CTRL1 register */
@ -747,11 +749,11 @@ static void mcr20a_thread_main(void *arg)
}
if (dregs[MCR20A_IRQSTS2] & MCR20A_IRQSTS2_IRQ_MASK) {
SYS_LOG_ERR("IRQSTS2 contains untreated IRQs: 0x%02x",
LOG_ERR("IRQSTS2 contains untreated IRQs: 0x%02x",
dregs[MCR20A_IRQSTS2]);
}
SYS_LOG_DBG("WB: 0x%02x | 0x%02x | 0x%02x",
LOG_DBG("WB: 0x%02x | 0x%02x | 0x%02x",
dregs[MCR20A_IRQSTS1],
dregs[MCR20A_IRQSTS2],
dregs[MCR20A_IRQSTS3]);
@ -761,23 +763,23 @@ static void mcr20a_thread_main(void *arg)
/* Reset sequence manager */
ctrl1 &= ~MCR20A_PHY_CTRL1_XCVSEQ_MASK;
if (!write_reg_phy_ctrl1(mcr20a, ctrl1)) {
SYS_LOG_ERR("Failed to reset SEQ manager");
LOG_ERR("Failed to reset SEQ manager");
}
_xcvseq_wait_until_idle(mcr20a);
if (!write_burst_irqsts1_ctrl1(mcr20a, dregs)) {
SYS_LOG_ERR("Failed to write CTRL1");
LOG_ERR("Failed to write CTRL1");
}
} else {
if (!write_burst_irqsts1_irqsts3(mcr20a, dregs)) {
SYS_LOG_ERR("Failed to write IRQSTS3");
LOG_ERR("Failed to write IRQSTS3");
}
}
unmask_irqb:
if (!mcr20a_mask_irqb(mcr20a, false)) {
SYS_LOG_ERR("Failed to unmask IRQ_B");
LOG_ERR("Failed to unmask IRQ_B");
}
k_mutex_unlock(&mcr20a->phy_mutex);
@ -835,7 +837,7 @@ static int mcr20a_set_cca_mode(struct device *dev, u8_t mode)
ctrl4 |= set_bits_phy_ctrl4_ccatype(mode);
if (!write_reg_phy_ctrl4(mcr20a, ctrl4)) {
SYS_LOG_ERR("Failed");
LOG_ERR("Failed");
return -EIO;
}
@ -859,37 +861,37 @@ static int mcr20a_cca(struct device *dev)
k_mutex_lock(&mcr20a->phy_mutex, K_FOREVER);
if (!mcr20a_mask_irqb(mcr20a, true)) {
SYS_LOG_ERR("Failed to mask IRQ_B");
LOG_ERR("Failed to mask IRQ_B");
goto error;
}
k_sem_init(&mcr20a->seq_sync, 0, 1);
if (mcr20a_abort_sequence(mcr20a, false)) {
SYS_LOG_ERR("Failed to reset XCV sequence");
LOG_ERR("Failed to reset XCV sequence");
goto error;
}
SYS_LOG_DBG("start CCA sequence");
LOG_DBG("start CCA sequence");
if (mcr20a_set_sequence(mcr20a, MCR20A_XCVSEQ_CCA)) {
SYS_LOG_ERR("Failed to reset XCV sequence");
LOG_ERR("Failed to reset XCV sequence");
goto error;
}
if (!mcr20a_mask_irqb(mcr20a, false)) {
SYS_LOG_ERR("Failed to unmask IRQ_B");
LOG_ERR("Failed to unmask IRQ_B");
goto error;
}
k_mutex_unlock(&mcr20a->phy_mutex);
retval = k_sem_take(&mcr20a->seq_sync, MCR20A_SEQ_SYNC_TIMEOUT);
if (retval) {
SYS_LOG_ERR("Timeout occurred, %d", retval);
LOG_ERR("Timeout occurred, %d", retval);
return retval;
}
SYS_LOG_DBG("done");
LOG_DBG("done");
return mcr20a->seq_retval;
@ -906,37 +908,37 @@ static int mcr20a_set_channel(struct device *dev, u16_t channel)
int retval = -EIO;
if (channel < 11 || channel > 26) {
SYS_LOG_ERR("Unsupported channel %u", channel);
LOG_ERR("Unsupported channel %u", channel);
return -EINVAL;
}
k_mutex_lock(&mcr20a->phy_mutex, K_FOREVER);
if (!mcr20a_mask_irqb(mcr20a, true)) {
SYS_LOG_ERR("Failed to mask IRQ_B");
LOG_ERR("Failed to mask IRQ_B");
goto out;
}
ctrl1 = read_reg_phy_ctrl1(mcr20a);
if (mcr20a_abort_sequence(mcr20a, true)) {
SYS_LOG_ERR("Failed to reset XCV sequence");
LOG_ERR("Failed to reset XCV sequence");
goto out;
}
SYS_LOG_DBG("%u", channel);
LOG_DBG("%u", channel);
channel -= 11;
buf[0] = set_bits_pll_int0_val(pll_int_lt[channel]);
buf[1] = (u8_t)pll_frac_lt[channel];
buf[2] = (u8_t)(pll_frac_lt[channel] >> 8);
if (!write_burst_pll_int0(mcr20a, buf)) {
SYS_LOG_ERR("Failed to set PLL");
LOG_ERR("Failed to set PLL");
goto out;
}
if (mcr20a_set_sequence(mcr20a, ctrl1)) {
SYS_LOG_ERR("Failed to restore XCV sequence");
LOG_ERR("Failed to restore XCV sequence");
goto out;
}
@ -944,7 +946,7 @@ static int mcr20a_set_channel(struct device *dev, u16_t channel)
out:
if (!mcr20a_mask_irqb(mcr20a, false)) {
SYS_LOG_ERR("Failed to unmask IRQ_B");
LOG_ERR("Failed to unmask IRQ_B");
retval = -EIO;
}
@ -961,13 +963,13 @@ static int mcr20a_set_pan_id(struct device *dev, u16_t pan_id)
k_mutex_lock(&mcr20a->phy_mutex, K_FOREVER);
if (!write_burst_pan_id(mcr20a, (u8_t *) &pan_id)) {
SYS_LOG_ERR("Failed");
LOG_ERR("Failed");
k_mutex_unlock(&mcr20a->phy_mutex);
return -EIO;
}
k_mutex_unlock(&mcr20a->phy_mutex);
SYS_LOG_DBG("0x%x", pan_id);
LOG_DBG("0x%x", pan_id);
return 0;
}
@ -980,13 +982,13 @@ static int mcr20a_set_short_addr(struct device *dev, u16_t short_addr)
k_mutex_lock(&mcr20a->phy_mutex, K_FOREVER);
if (!write_burst_short_addr(mcr20a, (u8_t *) &short_addr)) {
SYS_LOG_ERR("Failed");
LOG_ERR("Failed");
k_mutex_unlock(&mcr20a->phy_mutex);
return -EIO;
}
k_mutex_unlock(&mcr20a->phy_mutex);
SYS_LOG_DBG("0x%x", short_addr);
LOG_DBG("0x%x", short_addr);
return 0;
}
@ -998,13 +1000,13 @@ static int mcr20a_set_ieee_addr(struct device *dev, const u8_t *ieee_addr)
k_mutex_lock(&mcr20a->phy_mutex, K_FOREVER);
if (!write_burst_ext_addr(mcr20a, (void *)ieee_addr)) {
SYS_LOG_ERR("Failed");
LOG_ERR("Failed");
k_mutex_unlock(&mcr20a->phy_mutex);
return -EIO;
}
k_mutex_unlock(&mcr20a->phy_mutex);
SYS_LOG_DBG("IEEE address %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
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]);
@ -1016,7 +1018,7 @@ static int mcr20a_filter(struct device *dev,
enum ieee802154_filter_type type,
const struct ieee802154_filter *filter)
{
SYS_LOG_DBG("Applying filter %u", type);
LOG_DBG("Applying filter %u", type);
if (!set) {
return -ENOTSUP;
@ -1039,7 +1041,7 @@ static int mcr20a_set_txpower(struct device *dev, s16_t dbm)
u8_t pwr;
k_mutex_lock(&mcr20a->phy_mutex, K_FOREVER);
SYS_LOG_DBG("%d", dbm);
LOG_DBG("%d", dbm);
if ((dbm > MCR20A_OUTPUT_POWER_MAX) ||
(dbm < MCR20A_OUTPUT_POWER_MIN)) {
@ -1056,7 +1058,7 @@ static int mcr20a_set_txpower(struct device *dev, s16_t dbm)
error:
k_mutex_unlock(&mcr20a->phy_mutex);
SYS_LOG_DBG("Failed");
LOG_DBG("Failed");
return -EIO;
}
@ -1085,7 +1087,7 @@ static inline bool write_txfifo_content(struct mcr20a_context *dev,
};
if (payload_len > MCR20A_PSDU_LENGTH) {
SYS_LOG_ERR("Payload too long");
LOG_ERR("Payload too long");
return 0;
}
@ -1103,44 +1105,44 @@ static int mcr20a_tx(struct device *dev,
k_mutex_lock(&mcr20a->phy_mutex, K_FOREVER);
SYS_LOG_DBG("%p (%u)",
LOG_DBG("%p (%u)",
frag, net_pkt_ll_reserve(pkt) + frag->len);
if (!mcr20a_mask_irqb(mcr20a, true)) {
SYS_LOG_ERR("Failed to mask IRQ_B");
LOG_ERR("Failed to mask IRQ_B");
goto error;
}
if (mcr20a_abort_sequence(mcr20a, false)) {
SYS_LOG_ERR("Failed to reset XCV sequence");
LOG_ERR("Failed to reset XCV sequence");
goto error;
}
if (!write_txfifo_content(mcr20a, pkt, frag)) {
SYS_LOG_ERR("Did not write properly into TX FIFO");
LOG_ERR("Did not write properly into TX FIFO");
goto error;
}
k_sem_init(&mcr20a->seq_sync, 0, 1);
if (mcr20a_set_sequence(mcr20a, seq)) {
SYS_LOG_ERR("Cannot start transmission");
LOG_ERR("Cannot start transmission");
goto error;
}
if (!mcr20a_mask_irqb(mcr20a, false)) {
SYS_LOG_ERR("Failed to unmask IRQ_B");
LOG_ERR("Failed to unmask IRQ_B");
goto error;
}
k_mutex_unlock(&mcr20a->phy_mutex);
retval = k_sem_take(&mcr20a->seq_sync, MCR20A_SEQ_SYNC_TIMEOUT);
if (retval) {
SYS_LOG_ERR("Timeout occurred, %d", retval);
LOG_ERR("Timeout occurred, %d", retval);
return retval;
}
SYS_LOG_DBG("done");
LOG_DBG("done");
return mcr20a->seq_retval;
@ -1159,7 +1161,7 @@ static int mcr20a_start(struct device *dev)
enable_irqb_interrupt(mcr20a, false);
if (!write_reg_pwr_modes(mcr20a, MCR20A_PM_AUTODOZE)) {
SYS_LOG_ERR("Error starting MCR20A");
LOG_ERR("Error starting MCR20A");
goto error;
}
@ -1170,7 +1172,7 @@ static int mcr20a_start(struct device *dev)
} while (!(status & MCR20A_PWR_MODES_XTAL_READY) && timeout);
if (!(status & MCR20A_PWR_MODES_XTAL_READY)) {
SYS_LOG_ERR("Timeout, failed to wake up");
LOG_ERR("Timeout, failed to wake up");
goto error;
}
@ -1181,24 +1183,24 @@ static int mcr20a_start(struct device *dev)
MCR20A_IRQSTS3_TMR_MASK);
if (mcr20a_abort_sequence(mcr20a, true)) {
SYS_LOG_ERR("Failed to reset XCV sequence");
LOG_ERR("Failed to reset XCV sequence");
goto error;
}
if (mcr20a_set_sequence(mcr20a, MCR20A_XCVSEQ_RECEIVE)) {
SYS_LOG_ERR("Failed to set XCV sequence");
LOG_ERR("Failed to set XCV sequence");
goto error;
}
enable_irqb_interrupt(mcr20a, true);
if (!mcr20a_mask_irqb(mcr20a, false)) {
SYS_LOG_ERR("Failed to unmask IRQ_B");
LOG_ERR("Failed to unmask IRQ_B");
goto error;
}
k_mutex_unlock(&mcr20a->phy_mutex);
SYS_LOG_DBG("started");
LOG_DBG("started");
return 0;
@ -1215,12 +1217,12 @@ static int mcr20a_stop(struct device *dev)
k_mutex_lock(&mcr20a->phy_mutex, K_FOREVER);
if (!mcr20a_mask_irqb(mcr20a, true)) {
SYS_LOG_ERR("Failed to mask IRQ_B");
LOG_ERR("Failed to mask IRQ_B");
goto error;
}
if (mcr20a_abort_sequence(mcr20a, true)) {
SYS_LOG_ERR("Failed to reset XCV sequence");
LOG_ERR("Failed to reset XCV sequence");
goto error;
}
@ -1236,14 +1238,14 @@ static int mcr20a_stop(struct device *dev)
goto error;
}
SYS_LOG_DBG("stopped");
LOG_DBG("stopped");
k_mutex_unlock(&mcr20a->phy_mutex);
return 0;
error:
k_mutex_unlock(&mcr20a->phy_mutex);
SYS_LOG_ERR("Error stopping MCR20A");
LOG_ERR("Error stopping MCR20A");
return -EIO;
}
@ -1267,7 +1269,7 @@ static int mcr20a_update_overwrites(struct mcr20a_context *dev)
return 0;
error:
SYS_LOG_ERR("Error update overwrites");
LOG_ERR("Error update overwrites");
return -EIO;
}
@ -1291,7 +1293,7 @@ static int power_on_and_setup(struct device *dev)
} while (status && timeout);
if (status) {
SYS_LOG_ERR("Timeout, failed to get WAKE IRQ");
LOG_ERR("Timeout, failed to get WAKE IRQ");
return -EIO;
}
@ -1301,7 +1303,7 @@ static int power_on_and_setup(struct device *dev)
write_reg_clk_out_ctrl(mcr20a, tmp);
if (read_reg_clk_out_ctrl(mcr20a) != tmp) {
SYS_LOG_ERR("Failed to get device up");
LOG_ERR("Failed to get device up");
return -EIO;
}
@ -1342,7 +1344,7 @@ static inline int configure_gpios(struct device *dev)
/* setup gpio for the modem interrupt */
mcr20a->irq_gpio = device_get_binding(CONFIG_MCR20A_GPIO_IRQ_B_NAME);
if (mcr20a->irq_gpio == NULL) {
SYS_LOG_ERR("Failed to get pointer to %s device",
LOG_ERR("Failed to get pointer to %s device",
CONFIG_MCR20A_GPIO_IRQ_B_NAME);
return -EINVAL;
}
@ -1356,7 +1358,7 @@ static inline int configure_gpios(struct device *dev)
/* setup gpio for the modems reset */
mcr20a->reset_gpio = device_get_binding(CONFIG_MCR20A_GPIO_RESET_NAME);
if (mcr20a->reset_gpio == NULL) {
SYS_LOG_ERR("Failed to get pointer to %s device",
LOG_ERR("Failed to get pointer to %s device",
CONFIG_MCR20A_GPIO_RESET_NAME);
return -EINVAL;
}
@ -1375,7 +1377,7 @@ static inline int configure_spi(struct device *dev)
mcr20a->spi = device_get_binding(
CONFIG_IEEE802154_MCR20A_SPI_DRV_NAME);
if (!mcr20a->spi) {
SYS_LOG_ERR("Unable to get SPI device");
LOG_ERR("Unable to get SPI device");
return -ENODEV;
}
@ -1383,7 +1385,7 @@ static inline int configure_spi(struct device *dev)
mcr20a->cs_ctrl.gpio_dev = device_get_binding(
CONFIG_IEEE802154_MCR20A_GPIO_SPI_CS_DRV_NAME);
if (!mcr20a->cs_ctrl.gpio_dev) {
SYS_LOG_ERR("Unable to get GPIO SPI CS device");
LOG_ERR("Unable to get GPIO SPI CS device");
return -ENODEV;
}
@ -1392,7 +1394,7 @@ static inline int configure_spi(struct device *dev)
mcr20a->spi_cfg.cs = &mcr20a->cs_ctrl;
SYS_LOG_DBG("SPI GPIO CS configured on %s:%u",
LOG_DBG("SPI GPIO CS configured on %s:%u",
CONFIG_IEEE802154_MCR20A_GPIO_SPI_CS_DRV_NAME,
CONFIG_IEEE802154_MCR20A_GPIO_SPI_CS_PIN);
#endif /* CONFIG_IEEE802154_MCR20A_GPIO_SPI_CS */
@ -1401,7 +1403,7 @@ static inline int configure_spi(struct device *dev)
mcr20a->spi_cfg.operation = SPI_WORD_SET(8);
mcr20a->spi_cfg.slave = CONFIG_IEEE802154_MCR20A_SPI_SLAVE;
SYS_LOG_DBG("SPI configured %s, %d",
LOG_DBG("SPI configured %s, %d",
CONFIG_IEEE802154_MCR20A_SPI_DRV_NAME,
CONFIG_IEEE802154_MCR20A_SPI_SLAVE);
@ -1415,22 +1417,22 @@ static int mcr20a_init(struct device *dev)
k_mutex_init(&mcr20a->phy_mutex);
k_sem_init(&mcr20a->isr_sem, 0, 1);
SYS_LOG_DBG("\nInitialize MCR20A Transceiver\n");
LOG_DBG("\nInitialize MCR20A Transceiver\n");
if (configure_gpios(dev) != 0) {
SYS_LOG_ERR("Configuring GPIOS failed");
LOG_ERR("Configuring GPIOS failed");
return -EIO;
}
if (configure_spi(dev) != 0) {
SYS_LOG_ERR("Configuring SPI failed");
LOG_ERR("Configuring SPI failed");
return -EIO;
}
SYS_LOG_DBG("GPIO and SPI configured");
LOG_DBG("GPIO and SPI configured");
if (power_on_and_setup(dev) != 0) {
SYS_LOG_ERR("Configuring MCR20A failed");
LOG_ERR("Configuring MCR20A failed");
return -EIO;
}
@ -1454,7 +1456,7 @@ static void mcr20a_iface_init(struct net_if *iface)
ieee802154_init(iface);
SYS_LOG_DBG("done");
LOG_DBG("done");
}
static struct mcr20a_context mcr20a_context_data;

54
drivers/ieee802154/ieee802154_nrf5.c
View file

@ -6,9 +6,11 @@
* SPDX-License-Identifier: Apache-2.0
*/
#define SYS_LOG_LEVEL CONFIG_SYS_LOG_IEEE802154_DRIVER_LEVEL
#define SYS_LOG_DOMAIN "dev/nrf5_802154"
#include <logging/sys_log.h>
#define LOG_MODULE_NAME ieee802154_nrf5
#define LOG_LEVEL CONFIG_IEEE802154_LOG_LEVEL
#include <logging/log.h>
LOG_MODULE_REGISTER(LOG_MODULE_NAME);
#include <errno.h>
@ -71,20 +73,20 @@ static void nrf5_rx_thread(void *arg1, void *arg2, void *arg3)
while (1) {
pkt = NULL;
SYS_LOG_DBG("Waiting for frame");
LOG_DBG("Waiting for frame");
k_sem_take(&nrf5_radio->rx_wait, K_FOREVER);
SYS_LOG_DBG("Frame received");
LOG_DBG("Frame received");
pkt = net_pkt_get_reserve_rx(0, K_NO_WAIT);
if (!pkt) {
SYS_LOG_ERR("No pkt available");
LOG_ERR("No pkt available");
goto out;
}
frag = net_pkt_get_frag(pkt, K_NO_WAIT);
if (!frag) {
SYS_LOG_ERR("No frag available");
LOG_ERR("No frag available");
goto out;
}
@ -111,11 +113,11 @@ static void nrf5_rx_thread(void *arg1, void *arg2, void *arg3)
nrf_drv_radio802154_buffer_free(nrf5_radio->rx_psdu);
SYS_LOG_DBG("Caught a packet (%u) (LQI: %u)",
LOG_DBG("Caught a packet (%u) (LQI: %u)",
pkt_len, nrf5_radio->lqi);
if (net_recv_data(nrf5_radio->iface, pkt) < 0) {
SYS_LOG_DBG("Packet dropped by NET stack");
LOG_DBG("Packet dropped by NET stack");
goto out;
}
@ -158,7 +160,7 @@ static int nrf5_cca(struct device *dev)
* the ED function is done, thus unlocking the semaphore.
*/
k_sem_take(&nrf5_radio->cca_wait, K_FOREVER);
SYS_LOG_DBG("CCA: %d", nrf5_radio->channel_ed);
LOG_DBG("CCA: %d", nrf5_radio->channel_ed);
if (nrf5_radio->channel_ed > CONFIG_IEEE802154_NRF5_CCA_ED_THRESHOLD) {
return -EBUSY;
@ -171,7 +173,7 @@ static int nrf5_set_channel(struct device *dev, u16_t channel)
{
struct nrf5_802154_data *nrf5_radio = NRF5_802154_DATA(dev);
SYS_LOG_DBG("%u", channel);
LOG_DBG("%u", channel);
if (channel < 11 || channel > 26) {
return -EINVAL;
@ -194,7 +196,7 @@ static int nrf5_set_pan_id(struct device *dev, u16_t pan_id)
sys_put_le16(pan_id, pan_id_le);
nrf_drv_radio802154_pan_id_set(pan_id_le);
SYS_LOG_DBG("0x%x", pan_id);
LOG_DBG("0x%x", pan_id);
return 0;
}
@ -207,7 +209,7 @@ static int nrf5_set_short_addr(struct device *dev, u16_t short_addr)
sys_put_le16(short_addr, short_addr_le);
nrf_drv_radio802154_short_address_set(short_addr_le);
SYS_LOG_DBG("0x%x", short_addr);
LOG_DBG("0x%x", short_addr);
return 0;
}
@ -215,7 +217,7 @@ static int nrf5_set_ieee_addr(struct device *dev, const u8_t *ieee_addr)
{
ARG_UNUSED(dev);
SYS_LOG_DBG("IEEE address %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
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]);
@ -229,7 +231,7 @@ static int nrf5_filter(struct device *dev,
enum ieee802154_filter_type type,
const struct ieee802154_filter *filter)
{
SYS_LOG_DBG("Applying filter %u", type);
LOG_DBG("Applying filter %u", type);
if (!set) {
return -ENOTSUP;
@ -250,7 +252,7 @@ static int nrf5_set_txpower(struct device *dev, s16_t dbm)
{
struct nrf5_802154_data *nrf5_radio = NRF5_802154_DATA(dev);
SYS_LOG_DBG("%d", dbm);
LOG_DBG("%d", dbm);
nrf5_radio->txpower = dbm;
return 0;
@ -264,7 +266,7 @@ static int nrf5_tx(struct device *dev,
u8_t payload_len = net_pkt_ll_reserve(pkt) + frag->len;
u8_t *payload = frag->data - net_pkt_ll_reserve(pkt);
SYS_LOG_DBG("%p (%u)", payload, payload_len);
LOG_DBG("%p (%u)", payload, payload_len);
nrf5_radio->tx_success = false;
nrf5_radio->tx_psdu[0] = payload_len + NRF5_FCS_LENGTH;
@ -277,23 +279,23 @@ static int nrf5_tx(struct device *dev,
if (!nrf_drv_radio802154_transmit(nrf5_radio->tx_psdu,
nrf5_radio->channel,
nrf5_radio->txpower)) {
SYS_LOG_ERR("Cannot send frame");
LOG_ERR("Cannot send frame");
return -EIO;
}
SYS_LOG_DBG("Sending frame (ch:%d, txpower:%d)",
LOG_DBG("Sending frame (ch:%d, txpower:%d)",
nrf5_radio->channel,
nrf5_radio->txpower);
/* Wait for ack to be received */
if (k_sem_take(&nrf5_radio->tx_wait, ACK_TIMEOUT)) {
SYS_LOG_DBG("ACK not received");
LOG_DBG("ACK not received");
nrf_drv_radio802154_receive(nrf5_radio->channel, true);
return -EIO;
}
SYS_LOG_DBG("Result: %d", nrf5_data.tx_success);
LOG_DBG("Result: %d", nrf5_data.tx_success);
return nrf5_radio->tx_success ? 0 : -EBUSY;
}
@ -303,7 +305,7 @@ static int nrf5_start(struct device *dev)
struct nrf5_802154_data *nrf5_radio = NRF5_802154_DATA(dev);
nrf_drv_radio802154_receive(nrf5_radio->channel, false);
SYS_LOG_DBG("nRF5 802154 radio started (channel: %d)",
LOG_DBG("nRF5 802154 radio started (channel: %d)",
nrf5_radio->channel);
return 0;
@ -314,11 +316,11 @@ static int nrf5_stop(struct device *dev)
ARG_UNUSED(dev);
if (!nrf_drv_radio802154_sleep()) {
SYS_LOG_ERR("Error while stopping radio");
LOG_ERR("Error while stopping radio");
return -EIO;
}
SYS_LOG_DBG("nRF5 802154 radio stopped");
LOG_DBG("nRF5 802154 radio stopped");
return 0;
}
@ -364,7 +366,7 @@ static int nrf5_init(struct device *dev)
nrf5_rx_thread, dev, NULL, NULL,
K_PRIO_COOP(2), 0, 0);
SYS_LOG_INF("nRF5 802154 radio initialized");
LOG_INF("nRF5 802154 radio initialized");
return 0;
}
@ -374,7 +376,7 @@ 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);
SYS_LOG_DBG("");
LOG_DBG("");
nrf5_get_eui64(nrf5_radio->mac);
net_if_set_link_addr(iface,

26
drivers/ieee802154/ieee802154_uart_pipe.c
View file

@ -4,9 +4,11 @@
* SPDX-License-Identifier: Apache-2.0
*/
#define SYS_LOG_LEVEL CONFIG_SYS_LOG_IEEE802154_DRIVER_LEVEL
#define SYS_LOG_DOMAIN "net/ieee802154/upipe/"
#include <logging/sys_log.h>
#define LOG_MODULE_NAME ieee802154_uart_pipe
#define LOG_LEVEL CONFIG_IEEE802154_LOG_LEVEL
#include <logging/log.h>
LOG_MODULE_REGISTER(LOG_MODULE_NAME);
#include <errno.h>
@ -126,13 +128,13 @@ static u8_t *upipe_rx(u8_t *buf, size_t *off)
if (upipe->rx_len == upipe->rx_off) {
pkt = net_pkt_get_reserve_rx(0, K_NO_WAIT);
if (!pkt) {
SYS_LOG_DBG("No pkt available");
LOG_DBG("No pkt available");
goto flush;
}
frag = net_pkt_get_frag(pkt, K_NO_WAIT);
if (!frag) {
SYS_LOG_DBG("No fragment available");
LOG_DBG("No fragment available");
goto out;
}
@ -143,19 +145,19 @@ static u8_t *upipe_rx(u8_t *buf, size_t *off)
#if defined(CONFIG_IEEE802154_UPIPE_HW_FILTER)
if (received_dest_addr_matched(frag->data) == false) {
SYS_LOG_DBG("Packet received is not addressed to me");
LOG_DBG("Packet received is not addressed to me");
goto out;
}
#endif
if (ieee802154_radio_handle_ack(upipe->iface, pkt) == NET_OK) {
SYS_LOG_DBG("ACK packet handled");
LOG_DBG("ACK packet handled");
goto out;
}
SYS_LOG_DBG("Caught a packet (%u)", upipe->rx_len);
LOG_DBG("Caught a packet (%u)", upipe->rx_len);
if (net_recv_data(upipe->iface, pkt) < 0) {
SYS_LOG_DBG("Packet dropped by NET stack");
LOG_DBG("Packet dropped by NET stack");
goto out;
}
@ -237,7 +239,7 @@ static int upipe_filter(struct device *dev,
enum ieee802154_filter_type type,
const struct ieee802154_filter *filter)
{
SYS_LOG_DBG("Applying filter %u", type);
LOG_DBG("Applying filter %u", type);
if (!set) {
return -ENOTSUP;
@ -271,7 +273,7 @@ static int upipe_tx(struct device *dev,
struct upipe_context *upipe = dev->driver_data;
u8_t i, data;
SYS_LOG_DBG("%p (%u)", frag, len);
LOG_DBG("%p (%u)", frag, len);
if (upipe->stopped) {
return -EIO;
@ -357,8 +359,6 @@ static void upipe_iface_init(struct net_if *iface)
struct upipe_context *upipe = dev->driver_data;
u8_t *mac = get_mac(dev);
SYS_LOG_DBG("");
net_if_set_link_addr(iface, mac, 8, NET_LINK_IEEE802154);
upipe_dev = dev;