drivers: ieee802154: Convert to use new logging
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:
parent
20295c821b
commit
90dc38f8c9
7 changed files with 321 additions and 340 deletions
|
@ -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"
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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();
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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;
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue