michaelh/zephyr
1
0
Fork 0
Code Releases Activity

drivers: can: rename can_state enumerations

Browse source 
Rename the can_state enumerations to contain the word STATE to make their
meaning more clear:
- CAN_ERROR_ACTIVE  => CAN_STATE_ERROR_ACTIVE
- CAN_ERROR_WARNING => CAN_STATE_ERROR_WARNING
- CAN_ERROR_PASSIVE => CAN_STATE_ERROR_PASSIVE
- CAN_BUS_OFF       => CAN_STATE_BUS_OFF

Signed-off-by: Henrik Brix Andersen <hebad@vestas.com>
This commit is contained in:
Henrik Brix Andersen 2022-08-18 16:14:48 +02:00 • committed by Fabio Baltieri
commit 590cd5cb72
11 changed files with 51 additions and 51 deletions
Download patch file Download diff file Expand all files Collapse all files

4
doc/releases/release-notes-3.0.rst
View file

@ -466,13 +466,13 @@ Drivers and Sensors
* CAN * CAN
* Renamed ``zephyr,can-primary`` chosen property to ``zephyr,canbus``. * Renamed ``zephyr,can-primary`` chosen property to ``zephyr,canbus``.
* Added :c:macro:`CAN_ERROR_WARNING` CAN controller state. * Added :c:macro:`CAN_STATE_ERROR_WARNING` CAN controller state.
* Added Atmel SAM Bosch M_CAN CAN-FD driver. * Added Atmel SAM Bosch M_CAN CAN-FD driver.
* Added NXP LPCXpresso Bosch M_CAN CAN-FD driver. * Added NXP LPCXpresso Bosch M_CAN CAN-FD driver.
* Added ST STM32H7 Bosch M_CAN CAN-FD driver. * Added ST STM32H7 Bosch M_CAN CAN-FD driver.
* Rework transmission error handling the NXP FlexCAN driver to automatically * Rework transmission error handling the NXP FlexCAN driver to automatically
retry transmission in case or arbitration lost or missing acknowledge and retry transmission in case or arbitration lost or missing acknowledge and
to fail early in :c:func:`can_send` if in :c:macro:`CAN_BUS_OFF` state. to fail early in :c:func:`can_send` if in :c:macro:`CAN_STATE_BUS_OFF`.
* Added support for disabling automatic retransmissions ("one-shot" mode") to * Added support for disabling automatic retransmissions ("one-shot" mode") to
the ST STM32 bxCAN driver. the ST STM32 bxCAN driver.
* Converted the emulated CAN loopback driver to be configured through * Converted the emulated CAN loopback driver to be configured through

2
drivers/can/can_loopback.c
View file

@ -258,7 +258,7 @@ static int can_loopback_get_state(const struct device *dev, enum can_state *stat
ARG_UNUSED(dev); ARG_UNUSED(dev);
if (state != NULL) { if (state != NULL) {
*state = CAN_ERROR_ACTIVE; *state = CAN_STATE_ERROR_ACTIVE;
} }
if (err_cnt) { if (err_cnt) {

8
drivers/can/can_mcan.c
View file

@ -748,13 +748,13 @@ int can_mcan_get_state(const struct device *dev, enum can_state *state,
if (state != NULL) { if (state != NULL) {
if (can->psr & CAN_MCAN_PSR_BO) { if (can->psr & CAN_MCAN_PSR_BO) {
*state = CAN_BUS_OFF; *state = CAN_STATE_BUS_OFF;
} else if (can->psr & CAN_MCAN_PSR_EP) { } else if (can->psr & CAN_MCAN_PSR_EP) {
*state = CAN_ERROR_PASSIVE; *state = CAN_STATE_ERROR_PASSIVE;
} else if (can->psr & CAN_MCAN_PSR_EW) { } else if (can->psr & CAN_MCAN_PSR_EW) {
*state = CAN_ERROR_WARNING; *state = CAN_STATE_ERROR_WARNING;
} else { } else {
*state = CAN_ERROR_ACTIVE; *state = CAN_STATE_ERROR_ACTIVE;
} }
} }

10
drivers/can/can_mcp2515.c
View file

@ -693,13 +693,13 @@ static int mcp2515_get_state(const struct device *dev, enum can_state *state,
if (state != NULL) { if (state != NULL) {
if (eflg & MCP2515_EFLG_TXBO) { if (eflg & MCP2515_EFLG_TXBO) {
*state = CAN_BUS_OFF; *state = CAN_STATE_BUS_OFF;
} else if ((eflg & MCP2515_EFLG_RXEP) || (eflg & MCP2515_EFLG_TXEP)) { } else if ((eflg & MCP2515_EFLG_RXEP) || (eflg & MCP2515_EFLG_TXEP)) {
*state = CAN_ERROR_PASSIVE; *state = CAN_STATE_ERROR_PASSIVE;
} else if (eflg & MCP2515_EFLG_EWARN) { } else if (eflg & MCP2515_EFLG_EWARN) {
*state = CAN_ERROR_WARNING; *state = CAN_STATE_ERROR_WARNING;
} else { } else {
*state = CAN_ERROR_ACTIVE; *state = CAN_STATE_ERROR_ACTIVE;
} }
} }
@ -934,7 +934,7 @@ static int mcp2515_init(const struct device *dev)
(void)memset(dev_data->rx_cb, 0, sizeof(dev_data->rx_cb)); (void)memset(dev_data->rx_cb, 0, sizeof(dev_data->rx_cb));
(void)memset(dev_data->filter, 0, sizeof(dev_data->filter)); (void)memset(dev_data->filter, 0, sizeof(dev_data->filter));
dev_data->old_state = CAN_ERROR_ACTIVE; dev_data->old_state = CAN_STATE_ERROR_ACTIVE;
timing.sjw = dev_cfg->tq_sjw; timing.sjw = dev_cfg->tq_sjw;
if (dev_cfg->sample_point && USE_SP_ALGO) { if (dev_cfg->sample_point && USE_SP_ALGO) {

16
drivers/can/can_mcux_flexcan.c
View file

@ -325,14 +325,14 @@ static int mcux_flexcan_get_state(const struct device *dev, enum can_state *stat
status_flags = FLEXCAN_GetStatusFlags(config->base); status_flags = FLEXCAN_GetStatusFlags(config->base);
if ((status_flags & CAN_ESR1_FLTCONF(2)) != 0U) { if ((status_flags & CAN_ESR1_FLTCONF(2)) != 0U) {
*state = CAN_BUS_OFF; *state = CAN_STATE_BUS_OFF;
} else if ((status_flags & CAN_ESR1_FLTCONF(1)) != 0U) { } else if ((status_flags & CAN_ESR1_FLTCONF(1)) != 0U) {
*state = CAN_ERROR_PASSIVE; *state = CAN_STATE_ERROR_PASSIVE;
} else if ((status_flags & } else if ((status_flags &
(kFLEXCAN_TxErrorWarningFlag | kFLEXCAN_RxErrorWarningFlag)) != 0) { (kFLEXCAN_TxErrorWarningFlag | kFLEXCAN_RxErrorWarningFlag)) != 0) {
*state = CAN_ERROR_WARNING; *state = CAN_STATE_ERROR_WARNING;
} else { } else {
*state = CAN_ERROR_ACTIVE; *state = CAN_STATE_ERROR_ACTIVE;
} }
} }
@ -362,7 +362,7 @@ static int mcux_flexcan_send(const struct device *dev,
} }
(void)mcux_flexcan_get_state(dev, &state, NULL); (void)mcux_flexcan_get_state(dev, &state, NULL);
if (state == CAN_BUS_OFF) { if (state == CAN_STATE_BUS_OFF) {
LOG_DBG("Transmit failed, bus-off"); LOG_DBG("Transmit failed, bus-off");
return -ENETDOWN; return -ENETDOWN;
} }
@ -471,7 +471,7 @@ static int mcux_flexcan_recover(const struct device *dev, k_timeout_t timeout)
int ret = 0; int ret = 0;
(void)mcux_flexcan_get_state(dev, &state, NULL); (void)mcux_flexcan_get_state(dev, &state, NULL);
if (state != CAN_BUS_OFF) { if (state != CAN_STATE_BUS_OFF) {
return 0; return 0;
} }
@ -481,7 +481,7 @@ static int mcux_flexcan_recover(const struct device *dev, k_timeout_t timeout)
if (!K_TIMEOUT_EQ(timeout, K_NO_WAIT)) { if (!K_TIMEOUT_EQ(timeout, K_NO_WAIT)) {
(void)mcux_flexcan_get_state(dev, &state, NULL); (void)mcux_flexcan_get_state(dev, &state, NULL);
while (state == CAN_BUS_OFF) { while (state == CAN_STATE_BUS_OFF) {
if (!K_TIMEOUT_EQ(timeout, K_FOREVER) && if (!K_TIMEOUT_EQ(timeout, K_FOREVER) &&
k_uptime_ticks() - start_time >= timeout.ticks) { k_uptime_ticks() - start_time >= timeout.ticks) {
ret = -EAGAIN; ret = -EAGAIN;
@ -571,7 +571,7 @@ static inline void mcux_flexcan_transfer_error_status(const struct device *dev,
} }
} }
if (state == CAN_BUS_OFF) { if (state == CAN_STATE_BUS_OFF) {
/* Abort any pending TX frames in case of bus-off */ /* Abort any pending TX frames in case of bus-off */
for (alloc = 0; alloc < MCUX_FLEXCAN_MAX_TX; alloc++) { for (alloc = 0; alloc < MCUX_FLEXCAN_MAX_TX; alloc++) {
/* Copy callback function and argument before clearing bit */ /* Copy callback function and argument before clearing bit */

14
drivers/can/can_rcar.c
View file

@ -322,14 +322,14 @@ static void can_rcar_error(const struct device *dev)
/* Clear interrupt condition */ /* Clear interrupt condition */
sys_write8((uint8_t)~RCAR_CAN_EIFR_EWIF, sys_write8((uint8_t)~RCAR_CAN_EIFR_EWIF,
config->reg_addr + RCAR_CAN_EIFR); config->reg_addr + RCAR_CAN_EIFR);
can_rcar_state_change(dev, CAN_ERROR_WARNING); can_rcar_state_change(dev, CAN_STATE_ERROR_WARNING);
} }
if (eifr & RCAR_CAN_EIFR_EPIF) { if (eifr & RCAR_CAN_EIFR_EPIF) {
LOG_DBG("Error passive interrupt\n"); LOG_DBG("Error passive interrupt\n");
/* Clear interrupt condition */ /* Clear interrupt condition */
sys_write8((uint8_t)~RCAR_CAN_EIFR_EPIF, sys_write8((uint8_t)~RCAR_CAN_EIFR_EPIF,
config->reg_addr + RCAR_CAN_EIFR); config->reg_addr + RCAR_CAN_EIFR);
can_rcar_state_change(dev, CAN_ERROR_PASSIVE); can_rcar_state_change(dev, CAN_STATE_ERROR_PASSIVE);
} }
if (eifr & RCAR_CAN_EIFR_BORIF) { if (eifr & RCAR_CAN_EIFR_BORIF) {
LOG_DBG("Bus-off recovery interrupt\n"); LOG_DBG("Bus-off recovery interrupt\n");
@ -337,7 +337,7 @@ static void can_rcar_error(const struct device *dev)
/* Clear interrupt condition */ /* Clear interrupt condition */
sys_write8((uint8_t)~RCAR_CAN_EIFR_BORIF, sys_write8((uint8_t)~RCAR_CAN_EIFR_BORIF,
config->reg_addr + RCAR_CAN_EIFR); config->reg_addr + RCAR_CAN_EIFR);
can_rcar_state_change(dev, CAN_BUS_OFF); can_rcar_state_change(dev, CAN_STATE_BUS_OFF);
} }
if (eifr & RCAR_CAN_EIFR_BOEIF) { if (eifr & RCAR_CAN_EIFR_BOEIF) {
LOG_DBG("Bus-off entry interrupt\n"); LOG_DBG("Bus-off entry interrupt\n");
@ -345,7 +345,7 @@ static void can_rcar_error(const struct device *dev)
/* Clear interrupt condition */ /* Clear interrupt condition */
sys_write8((uint8_t)~RCAR_CAN_EIFR_BOEIF, sys_write8((uint8_t)~RCAR_CAN_EIFR_BOEIF,
config->reg_addr + RCAR_CAN_EIFR); config->reg_addr + RCAR_CAN_EIFR);
can_rcar_state_change(dev, CAN_BUS_OFF); can_rcar_state_change(dev, CAN_STATE_BUS_OFF);
} }
if (eifr & RCAR_CAN_EIFR_ORIF) { if (eifr & RCAR_CAN_EIFR_ORIF) {
LOG_DBG("Receive overrun error interrupt\n"); LOG_DBG("Receive overrun error interrupt\n");
@ -754,7 +754,7 @@ static int can_rcar_recover(const struct device *dev, k_timeout_t timeout)
int64_t start_time; int64_t start_time;
int ret; int ret;
if (data->state != CAN_BUS_OFF) { if (data->state != CAN_STATE_BUS_OFF) {
return 0; return 0;
} }
@ -763,7 +763,7 @@ static int can_rcar_recover(const struct device *dev, k_timeout_t timeout)
} }
start_time = k_uptime_ticks(); start_time = k_uptime_ticks();
while (data->state == CAN_BUS_OFF) { while (data->state == CAN_STATE_BUS_OFF) {
ret = can_rcar_enter_operation_mode(config); ret = can_rcar_enter_operation_mode(config);
if (ret != 0) { if (ret != 0) {
goto done; goto done;
@ -930,7 +930,7 @@ static int can_rcar_init(const struct device *dev)
data->tx_unsent = 0; data->tx_unsent = 0;
memset(data->rx_callback, 0, sizeof(data->rx_callback)); memset(data->rx_callback, 0, sizeof(data->rx_callback));
data->state = CAN_ERROR_ACTIVE; data->state = CAN_STATE_ERROR_ACTIVE;
data->state_change_cb = NULL; data->state_change_cb = NULL;
data->state_change_cb_data = NULL; data->state_change_cb_data = NULL;

16
drivers/can/can_sja1000.c
View file

@ -311,7 +311,7 @@ int can_sja1000_send(const struct device *dev, const struct can_frame *frame, k_
return -EINVAL; return -EINVAL;
} }
if (data->state == CAN_BUS_OFF) { if (data->state == CAN_STATE_BUS_OFF) {
LOG_DBG("transmit failed, bus-off"); LOG_DBG("transmit failed, bus-off");
return -ENETDOWN; return -ENETDOWN;
} }
@ -543,7 +543,7 @@ static void can_sja1000_handle_error_warning_irq(const struct device *dev)
sr = can_sja1000_read_reg(dev, CAN_SJA1000_SR); sr = can_sja1000_read_reg(dev, CAN_SJA1000_SR);
if ((sr & CAN_SJA1000_SR_BS) != 0) { if ((sr & CAN_SJA1000_SR_BS) != 0) {
data->state = CAN_BUS_OFF; data->state = CAN_STATE_BUS_OFF;
can_sja1000_tx_done(dev, -ENETDOWN); can_sja1000_tx_done(dev, -ENETDOWN);
#ifdef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY #ifdef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY
/* Recover bus now unless interrupted in the middle of a MOD register change. */ /* Recover bus now unless interrupted in the middle of a MOD register change. */
@ -554,9 +554,9 @@ static void can_sja1000_handle_error_warning_irq(const struct device *dev)
} }
#endif /* CONFIG_CAN_AUTO_BUS_OFF_RECOVERY */ #endif /* CONFIG_CAN_AUTO_BUS_OFF_RECOVERY */
} else if ((sr & CAN_SJA1000_SR_ES) != 0) { } else if ((sr & CAN_SJA1000_SR_ES) != 0) {
data->state = CAN_ERROR_WARNING; data->state = CAN_STATE_ERROR_WARNING;
} else { } else {
data->state = CAN_ERROR_ACTIVE; data->state = CAN_STATE_ERROR_ACTIVE;
} }
} }
@ -564,10 +564,10 @@ static void can_sja1000_handle_error_passive_irq(const struct device *dev)
{ {
struct can_sja1000_data *data = dev->data; struct can_sja1000_data *data = dev->data;
if (data->state == CAN_ERROR_PASSIVE) { if (data->state == CAN_STATE_ERROR_PASSIVE) {
data->state = CAN_ERROR_WARNING; data->state = CAN_STATE_ERROR_WARNING;
} else { } else {
data->state = CAN_ERROR_PASSIVE; data->state = CAN_STATE_ERROR_PASSIVE;
} }
} }
@ -626,7 +626,7 @@ int can_sja1000_init(const struct device *dev)
k_sem_init(&data->tx_idle, 1, 1); k_sem_init(&data->tx_idle, 1, 1);
k_sem_init(&data->tx_done, 0, 1); k_sem_init(&data->tx_done, 0, 1);
data->state = CAN_ERROR_ACTIVE; data->state = CAN_STATE_ERROR_ACTIVE;
/* See NXP SJA1000 Application Note AN97076 (figure 12) for initialization sequence */ /* See NXP SJA1000 Application Note AN97076 (figure 12) for initialization sequence */

8
drivers/can/can_stm32.c
View file

@ -131,13 +131,13 @@ static int can_stm32_get_state(const struct device *dev, enum can_state *state,
if (state != NULL) { if (state != NULL) {
if (can->ESR & CAN_ESR_BOFF) { if (can->ESR & CAN_ESR_BOFF) {
*state = CAN_BUS_OFF; *state = CAN_STATE_BUS_OFF;
} else if (can->ESR & CAN_ESR_EPVF) { } else if (can->ESR & CAN_ESR_EPVF) {
*state = CAN_ERROR_PASSIVE; *state = CAN_STATE_ERROR_PASSIVE;
} else if (can->ESR & CAN_ESR_EWGF) { } else if (can->ESR & CAN_ESR_EWGF) {
*state = CAN_ERROR_WARNING; *state = CAN_STATE_ERROR_WARNING;
} else { } else {
*state = CAN_ERROR_ACTIVE; *state = CAN_STATE_ERROR_ACTIVE;
} }
} }

10
include/zephyr/drivers/can.h
View file

@ -106,17 +106,17 @@ extern "C" {
typedef uint32_t can_mode_t; typedef uint32_t can_mode_t;
/** /**
* @brief Defines the state of the CAN bus * @brief Defines the state of the CAN controller
*/ */
enum can_state { enum can_state {
/** Error-active state (RX/TX error count < 96). */ /** Error-active state (RX/TX error count < 96). */
CAN_ERROR_ACTIVE, CAN_STATE_ERROR_ACTIVE,
/** Error-warning state (RX/TX error count < 128). */ /** Error-warning state (RX/TX error count < 128). */
CAN_ERROR_WARNING, CAN_STATE_ERROR_WARNING,
/** Error-passive state (RX/TX error count < 256). */ /** Error-passive state (RX/TX error count < 256). */
CAN_ERROR_PASSIVE, CAN_STATE_ERROR_PASSIVE,
/** Bus-off state (RX/TX error count >= 256). */ /** Bus-off state (RX/TX error count >= 256). */
CAN_BUS_OFF, CAN_STATE_BUS_OFF,
}; };
/** /**

2
modules/canopennode/CO_driver.c
View file

@ -433,7 +433,7 @@ void CO_CANverifyErrors(CO_CANmodule_t *CANmodule)
if (errors != CANmodule->errors) { if (errors != CANmodule->errors) {
CANmodule->errors = errors; CANmodule->errors = errors;
if (state == CAN_BUS_OFF) { if (state == CAN_STATE_BUS_OFF) {
/* Bus off */ /* Bus off */
CO_errorReport(em, CO_EM_CAN_TX_BUS_OFF, CO_errorReport(em, CO_EM_CAN_TX_BUS_OFF,
CO_EMC_BUS_OFF_RECOVERED, errors); CO_EMC_BUS_OFF_RECOVERED, errors);

12
samples/drivers/can/src/main.c
View file

@ -109,13 +109,13 @@ void change_led_work_handler(struct k_work *work)
char *state_to_str(enum can_state state) char *state_to_str(enum can_state state)
{ {
switch (state) { switch (state) {
case CAN_ERROR_ACTIVE: case CAN_STATE_ERROR_ACTIVE:
return "error-active"; return "error-active";
case CAN_ERROR_WARNING: case CAN_STATE_ERROR_WARNING:
return "error-warning"; return "error-warning";
case CAN_ERROR_PASSIVE: case CAN_STATE_ERROR_PASSIVE:
return "error-passive"; return "error-passive";
case CAN_BUS_OFF: case CAN_STATE_BUS_OFF:
return "bus-off"; return "bus-off";
default: default:
return "unknown"; return "unknown";
@ -126,7 +126,7 @@ void poll_state_thread(void *unused1, void *unused2, void *unused3)
{ {
struct can_bus_err_cnt err_cnt = {0, 0}; struct can_bus_err_cnt err_cnt = {0, 0};
struct can_bus_err_cnt err_cnt_prev = {0, 0}; struct can_bus_err_cnt err_cnt_prev = {0, 0};
enum can_state state_prev = CAN_ERROR_ACTIVE; enum can_state state_prev = CAN_STATE_ERROR_ACTIVE;
enum can_state state; enum can_state state;
int err; int err;
@ -165,7 +165,7 @@ void state_change_work_handler(struct k_work *work)
current_err_cnt.rx_err_cnt, current_err_cnt.tx_err_cnt); current_err_cnt.rx_err_cnt, current_err_cnt.tx_err_cnt);
#ifndef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY #ifndef CONFIG_CAN_AUTO_BUS_OFF_RECOVERY
if (current_state == CAN_BUS_OFF) { if (current_state == CAN_STATE_BUS_OFF) {
printk("Recover from bus-off\n"); printk("Recover from bus-off\n");
if (can_recover(can_dev, K_MSEC(100)) != 0) { if (can_recover(can_dev, K_MSEC(100)) != 0) {