14#ifndef ZEPHYR_INCLUDE_DRIVERS_CAN_H_
15#define ZEPHYR_INCLUDE_DRIVERS_CAN_H_
47#define CAN_STD_ID_MASK 0x7FFU
52#define CAN_EXT_ID_MASK 0x1FFFFFFFU
62#define CANFD_MAX_DLC 15U
68#ifndef CONFIG_CAN_FD_MODE
69#define CAN_MAX_DLEN 8U
71#define CAN_MAX_DLEN 64U
86#define CAN_MODE_NORMAL 0
89#define CAN_MODE_LOOPBACK BIT(0)
92#define CAN_MODE_LISTENONLY BIT(1)
95#define CAN_MODE_FD BIT(2)
98#define CAN_MODE_ONE_SHOT BIT(3)
101#define CAN_MODE_3_SAMPLES BIT(4)
104#define CAN_MODE_MANUAL_RECOVERY BIT(5)
142#define CAN_FRAME_IDE BIT(0)
145#define CAN_FRAME_RTR BIT(1)
148#define CAN_FRAME_FDF BIT(2)
151#define CAN_FRAME_BRS BIT(3)
156#define CAN_FRAME_ESI BIT(4)
170#if defined(CONFIG_CAN_RX_TIMESTAMP) || defined(__DOXYGEN__)
202#define CAN_FILTER_IDE BIT(0)
327#define CAN_CALC_TDCO(_timing_data, _tdco_min, _tdco_max) \
328 CLAMP((1U + _timing_data->prop_seg + _timing_data->phase_seg1) * _timing_data->prescaler, \
329 _tdco_min, _tdco_max)
337struct can_driver_config {
348#ifdef CONFIG_CAN_FD_MODE
363#define CAN_DT_DRIVER_CONFIG_GET(node_id, _min_bitrate, _max_bitrate) \
365 .phy = DEVICE_DT_GET_OR_NULL(DT_PHANDLE(node_id, phys)), \
366 .min_bitrate = DT_CAN_TRANSCEIVER_MIN_BITRATE(node_id, _min_bitrate), \
367 .max_bitrate = DT_CAN_TRANSCEIVER_MAX_BITRATE(node_id, _max_bitrate), \
368 .bitrate = DT_PROP_OR(node_id, bitrate, \
369 DT_PROP_OR(node_id, bus_speed, CONFIG_CAN_DEFAULT_BITRATE)), \
370 .sample_point = DT_PROP_OR(node_id, sample_point, 0), \
371 IF_ENABLED(CONFIG_CAN_FD_MODE, \
372 (.bitrate_data = DT_PROP_OR(node_id, bitrate_data, \
373 DT_PROP_OR(node_id, bus_speed_data, CONFIG_CAN_DEFAULT_BITRATE_DATA)), \
374 .sample_point_data = DT_PROP_OR(node_id, sample_point_data, 0),)) \
385#define CAN_DT_DRIVER_CONFIG_INST_GET(inst, _min_bitrate, _max_bitrate) \
386 CAN_DT_DRIVER_CONFIG_GET(DT_DRV_INST(inst), _min_bitrate, _max_bitrate)
394struct can_driver_data {
402 void *state_change_cb_user_data;
409typedef int (*can_set_timing_t)(
const struct device *dev,
416typedef int (*can_set_timing_data_t)(
const struct device *dev,
423typedef int (*can_get_capabilities_t)(
const struct device *dev,
can_mode_t *cap);
429typedef int (*can_start_t)(
const struct device *dev);
435typedef int (*can_stop_t)(
const struct device *dev);
450typedef int (*can_send_t)(
const struct device *dev,
459typedef int (*can_add_rx_filter_t)(
const struct device *dev,
468typedef void (*can_remove_rx_filter_t)(
const struct device *dev,
int filter_id);
487typedef void(*can_set_state_change_callback_t)(
const struct device *dev,
495typedef int (*can_get_core_clock_t)(
const struct device *dev,
uint32_t *rate);
501typedef int (*can_get_max_filters_t)(
const struct device *dev,
bool ide);
503__subsystem
struct can_driver_api {
504 can_get_capabilities_t get_capabilities;
507 can_set_mode_t set_mode;
508 can_set_timing_t set_timing;
510 can_add_rx_filter_t add_rx_filter;
511 can_remove_rx_filter_t remove_rx_filter;
512#if defined(CONFIG_CAN_MANUAL_RECOVERY_MODE) || defined(__DOXYGEN__)
513 can_recover_t recover;
515 can_get_state_t get_state;
516 can_set_state_change_callback_t set_state_change_callback;
517 can_get_core_clock_t get_core_clock;
518 can_get_max_filters_t get_max_filters;
523#if defined(CONFIG_CAN_FD_MODE) || defined(__DOXYGEN__)
524 can_set_timing_data_t set_timing_data;
534#if defined(CONFIG_CAN_STATS) || defined(__DOXYGEN__)
580#define Z_CAN_GET_STATS(dev_) \
581 CONTAINER_OF(dev_->state, struct can_device_state, devstate)->stats
601#define CAN_STATS_BIT_ERROR_INC(dev_) \
602 STATS_INC(Z_CAN_GET_STATS(dev_), bit_error)
615#define CAN_STATS_BIT0_ERROR_INC(dev_) \
617 STATS_INC(Z_CAN_GET_STATS(dev_), bit0_error); \
618 CAN_STATS_BIT_ERROR_INC(dev_); \
632#define CAN_STATS_BIT1_ERROR_INC(dev_) \
634 STATS_INC(Z_CAN_GET_STATS(dev_), bit1_error); \
635 CAN_STATS_BIT_ERROR_INC(dev_); \
646#define CAN_STATS_STUFF_ERROR_INC(dev_) \
647 STATS_INC(Z_CAN_GET_STATS(dev_), stuff_error)
657#define CAN_STATS_CRC_ERROR_INC(dev_) \
658 STATS_INC(Z_CAN_GET_STATS(dev_), crc_error)
668#define CAN_STATS_FORM_ERROR_INC(dev_) \
669 STATS_INC(Z_CAN_GET_STATS(dev_), form_error)
679#define CAN_STATS_ACK_ERROR_INC(dev_) \
680 STATS_INC(Z_CAN_GET_STATS(dev_), ack_error)
691#define CAN_STATS_RX_OVERRUN_INC(dev_) \
692 STATS_INC(Z_CAN_GET_STATS(dev_), rx_overrun)
702#define CAN_STATS_RESET(dev_) \
703 stats_reset(&(Z_CAN_GET_STATS(dev_).s_hdr))
710#define Z_CAN_DEVICE_STATE_DEFINE(dev_id) \
711 static struct can_device_state Z_DEVICE_STATE_NAME(dev_id) \
712 __attribute__((__section__(".z_devstate")))
720#define Z_CAN_INIT_FN(dev_id, init_fn) \
721 static inline int UTIL_CAT(dev_id, _init)(const struct device *dev) \
723 struct can_device_state *state = \
724 CONTAINER_OF(dev->state, struct can_device_state, devstate); \
725 stats_init(&state->stats.s_hdr, STATS_SIZE_32, 8, \
726 STATS_NAME_INIT_PARMS(can)); \
727 stats_register(dev->name, &(state->stats.s_hdr)); \
728 if (!is_null_no_warn(init_fn)) { \
729 return init_fn(dev); \
757#define CAN_DEVICE_DT_DEFINE(node_id, init_fn, pm, data, config, level, \
759 Z_CAN_DEVICE_STATE_DEFINE(Z_DEVICE_DT_DEV_ID(node_id)); \
760 Z_CAN_INIT_FN(Z_DEVICE_DT_DEV_ID(node_id), init_fn) \
761 Z_DEVICE_DEFINE(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
762 DEVICE_DT_NAME(node_id), \
763 &UTIL_CAT(Z_DEVICE_DT_DEV_ID(node_id), _init), \
764 pm, data, config, level, prio, api, \
765 &(Z_DEVICE_STATE_NAME(Z_DEVICE_DT_DEV_ID(node_id)).devstate), \
770#define CAN_STATS_BIT_ERROR_INC(dev_)
771#define CAN_STATS_BIT0_ERROR_INC(dev_)
772#define CAN_STATS_BIT1_ERROR_INC(dev_)
773#define CAN_STATS_STUFF_ERROR_INC(dev_)
774#define CAN_STATS_CRC_ERROR_INC(dev_)
775#define CAN_STATS_FORM_ERROR_INC(dev_)
776#define CAN_STATS_ACK_ERROR_INC(dev_)
777#define CAN_STATS_RX_OVERRUN_INC(dev_)
778#define CAN_STATS_RESET(dev_)
780#define CAN_DEVICE_DT_DEFINE(node_id, init_fn, pm, data, config, level, \
782 DEVICE_DT_DEFINE(node_id, init_fn, pm, data, config, level, \
783 prio, api, __VA_ARGS__)
794#define CAN_DEVICE_DT_INST_DEFINE(inst, ...) \
795 CAN_DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
817static inline int z_impl_can_get_core_clock(
const struct device *dev,
uint32_t *rate)
819 const struct can_driver_api *api = (
const struct can_driver_api *)dev->
api;
821 return api->get_core_clock(dev, rate);
842static inline uint32_t z_impl_can_get_bitrate_min(
const struct device *dev)
844 const struct can_driver_config *common = (
const struct can_driver_config *)dev->
config;
846 return common->min_bitrate;
867static inline uint32_t z_impl_can_get_bitrate_max(
const struct device *dev)
869 const struct can_driver_config *common = (
const struct can_driver_config *)dev->
config;
871 return common->max_bitrate;
883static inline const struct can_timing *z_impl_can_get_timing_min(
const struct device *dev)
885 const struct can_driver_api *api = (
const struct can_driver_api *)dev->
api;
887 return &api->timing_min;
899static inline const struct can_timing *z_impl_can_get_timing_max(
const struct device *dev)
901 const struct can_driver_api *api = (
const struct can_driver_api *)dev->
api;
903 return &api->timing_max;
950#ifdef CONFIG_CAN_FD_MODE
951static inline const struct can_timing *z_impl_can_get_timing_data_min(
const struct device *dev)
953 const struct can_driver_api *api = (
const struct can_driver_api *)dev->
api;
955 return &api->timing_data_min;
974#ifdef CONFIG_CAN_FD_MODE
975static inline const struct can_timing *z_impl_can_get_timing_data_max(
const struct device *dev)
977 const struct can_driver_api *api = (
const struct can_driver_api *)dev->
api;
979 return &api->timing_data_max;
1087static inline int z_impl_can_get_capabilities(
const struct device *dev,
can_mode_t *cap)
1089 const struct can_driver_api *api = (
const struct can_driver_api *)dev->
api;
1091 return api->get_capabilities(dev, cap);
1105static const struct device *z_impl_can_get_transceiver(
const struct device *dev)
1107 const struct can_driver_config *common = (
const struct can_driver_config *)dev->
config;
1131static inline int z_impl_can_start(
const struct device *dev)
1133 const struct can_driver_api *api = (
const struct can_driver_api *)dev->
api;
1135 return api->start(dev);
1155static inline int z_impl_can_stop(
const struct device *dev)
1157 const struct can_driver_api *api = (
const struct can_driver_api *)dev->
api;
1159 return api->stop(dev);
1174static inline int z_impl_can_set_mode(
const struct device *dev,
can_mode_t mode)
1176 const struct can_driver_api *api = (
const struct can_driver_api *)dev->
api;
1178 return api->set_mode(dev, mode);
1192 const struct can_driver_data *common = (
const struct can_driver_data *)dev->
data;
1194 return common->mode;
1312 void *user_data,
const struct can_filter *filter);
1324#define CAN_MSGQ_DEFINE(name, max_frames) \
1325 K_MSGQ_DEFINE(name, sizeof(struct can_frame), max_frames, 4)
1367static inline void z_impl_can_remove_rx_filter(
const struct device *dev,
int filter_id)
1369 const struct can_driver_api *api = (
const struct can_driver_api *)dev->
api;
1371 api->remove_rx_filter(dev, filter_id);
1389static inline int z_impl_can_get_max_filters(
const struct device *dev,
bool ide)
1391 const struct can_driver_api *api = (
const struct can_driver_api *)dev->
api;
1393 if (api->get_max_filters == NULL) {
1397 return api->get_max_filters(dev, ide);
1427 const struct can_driver_api *api = (
const struct can_driver_api *)dev->
api;
1429 return api->get_state(dev,
state, err_cnt);
1451#ifdef CONFIG_CAN_MANUAL_RECOVERY_MODE
1452static inline int z_impl_can_recover(
const struct device *dev,
k_timeout_t timeout)
1454 const struct can_driver_api *api = (
const struct can_driver_api *)dev->
api;
1456 if (api->recover == NULL) {
1460 return api->recover(dev, timeout);
1481 const struct can_driver_api *api = (
const struct can_driver_api *)dev->
api;
1483 api->set_state_change_callback(dev, callback, user_data);
1508#ifdef CONFIG_CAN_STATS
1509static inline uint32_t z_impl_can_stats_get_bit_errors(
const struct device *dev)
1511 return Z_CAN_GET_STATS(dev).bit_error;
1531#ifdef CONFIG_CAN_STATS
1532static inline uint32_t z_impl_can_stats_get_bit0_errors(
const struct device *dev)
1534 return Z_CAN_GET_STATS(dev).bit0_error;
1554#ifdef CONFIG_CAN_STATS
1555static inline uint32_t z_impl_can_stats_get_bit1_errors(
const struct device *dev)
1557 return Z_CAN_GET_STATS(dev).bit1_error;
1575#ifdef CONFIG_CAN_STATS
1576static inline uint32_t z_impl_can_stats_get_stuff_errors(
const struct device *dev)
1578 return Z_CAN_GET_STATS(dev).stuff_error;
1596#ifdef CONFIG_CAN_STATS
1597static inline uint32_t z_impl_can_stats_get_crc_errors(
const struct device *dev)
1599 return Z_CAN_GET_STATS(dev).crc_error;
1617#ifdef CONFIG_CAN_STATS
1618static inline uint32_t z_impl_can_stats_get_form_errors(
const struct device *dev)
1620 return Z_CAN_GET_STATS(dev).form_error;
1638#ifdef CONFIG_CAN_STATS
1639static inline uint32_t z_impl_can_stats_get_ack_errors(
const struct device *dev)
1641 return Z_CAN_GET_STATS(dev).ack_error;
1660#ifdef CONFIG_CAN_STATS
1661static inline uint32_t z_impl_can_stats_get_rx_overruns(
const struct device *dev)
1663 return Z_CAN_GET_STATS(dev).rx_overrun;
1684 static const uint8_t dlc_table[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 12,
1685 16, 20, 24, 32, 48, 64};
1699 return num_bytes <= 8 ? num_bytes :
1700 num_bytes <= 12 ? 9 :
1701 num_bytes <= 16 ? 10 :
1702 num_bytes <= 20 ? 11 :
1703 num_bytes <= 24 ? 12 :
1704 num_bytes <= 32 ? 13 :
1705 num_bytes <= 48 ? 14 :
1729 if ((frame->
id ^ filter->
id) & filter->
mask) {
1747#include <zephyr/syscalls/can.h>
void(* can_state_change_callback_t)(const struct device *dev, enum can_state state, struct can_bus_err_cnt err_cnt, void *user_data)
Defines the state change callback handler function signature.
Definition can.h:303
int can_set_bitrate(const struct device *dev, uint32_t bitrate)
Set the bitrate of the CAN controller.
int can_set_bitrate_data(const struct device *dev, uint32_t bitrate_data)
Set the bitrate for the data phase of the CAN FD controller.
uint32_t can_mode_t
Provides a type to hold CAN controller configuration flags.
Definition can.h:116
uint32_t can_stats_get_stuff_errors(const struct device *dev)
Get the stuffing error counter for a CAN device.
int can_stop(const struct device *dev)
Stop the CAN controller.
int can_set_timing(const struct device *dev, const struct can_timing *timing)
Configure the bus timing of a CAN controller.
uint32_t can_get_bitrate_max(const struct device *dev)
Get maximum supported bitrate.
uint32_t can_stats_get_bit_errors(const struct device *dev)
Get the bit error counter for a CAN device.
uint32_t can_stats_get_crc_errors(const struct device *dev)
Get the CRC error counter for a CAN device.
uint32_t can_get_bitrate_min(const struct device *dev)
Get minimum supported bitrate.
int can_calc_timing_data(const struct device *dev, struct can_timing *res, uint32_t bitrate, uint16_t sample_pnt)
Calculate timing parameters for the data phase.
int can_send(const struct device *dev, const struct can_frame *frame, k_timeout_t timeout, can_tx_callback_t callback, void *user_data)
Queue a CAN frame for transmission on the CAN bus.
const struct can_timing * can_get_timing_data_max(const struct device *dev)
Get the maximum supported timing parameter values for the data phase.
int can_get_core_clock(const struct device *dev, uint32_t *rate)
Get the CAN core clock rate.
int can_get_capabilities(const struct device *dev, can_mode_t *cap)
Get the supported modes of the CAN controller.
uint32_t can_stats_get_bit1_errors(const struct device *dev)
Get the bit1 error counter for a CAN device.
uint32_t can_stats_get_ack_errors(const struct device *dev)
Get the acknowledge error counter for a CAN device.
int can_get_max_filters(const struct device *dev, bool ide)
Get maximum number of RX filters.
const struct can_timing * can_get_timing_min(const struct device *dev)
Get the minimum supported timing parameter values.
int can_set_timing_data(const struct device *dev, const struct can_timing *timing_data)
Configure the bus timing for the data phase of a CAN FD controller.
const struct can_timing * can_get_timing_data_min(const struct device *dev)
Get the minimum supported timing parameter values for the data phase.
uint32_t can_stats_get_bit0_errors(const struct device *dev)
Get the bit0 error counter for a CAN device.
void can_remove_rx_filter(const struct device *dev, int filter_id)
Remove a CAN RX filter.
static uint8_t can_bytes_to_dlc(uint8_t num_bytes)
Convert from number of bytes to Data Length Code (DLC)
Definition can.h:1697
uint32_t can_stats_get_rx_overruns(const struct device *dev)
Get the RX overrun counter for a CAN device.
#define CAN_FRAME_IDE
Frame uses extended (29-bit) CAN ID.
Definition can.h:142
static uint8_t can_dlc_to_bytes(uint8_t dlc)
Convert from Data Length Code (DLC) to the number of data bytes.
Definition can.h:1682
int can_add_rx_filter_msgq(const struct device *dev, struct k_msgq *msgq, const struct can_filter *filter)
Simple wrapper function for adding a message queue for a given filter.
void(* can_rx_callback_t)(const struct device *dev, struct can_frame *frame, void *user_data)
Defines the application callback handler function signature for receiving.
Definition can.h:292
static bool can_frame_matches_filter(const struct can_frame *frame, const struct can_filter *filter)
Check if a CAN frame matches a CAN filter.
Definition can.h:1716
void(* can_tx_callback_t)(const struct device *dev, int error, void *user_data)
Defines the application callback handler function signature.
Definition can.h:283
int can_get_state(const struct device *dev, enum can_state *state, struct can_bus_err_cnt *err_cnt)
Get current CAN controller state.
can_mode_t can_get_mode(const struct device *dev)
Get the operation mode of the CAN controller.
const struct can_timing * can_get_timing_max(const struct device *dev)
Get the maximum supported timing parameter values.
uint32_t can_stats_get_form_errors(const struct device *dev)
Get the form error counter for a CAN device.
int can_calc_timing(const struct device *dev, struct can_timing *res, uint32_t bitrate, uint16_t sample_pnt)
Calculate timing parameters from bitrate and sample point.
int can_recover(const struct device *dev, k_timeout_t timeout)
Recover from bus-off state.
can_state
Defines the state of the CAN controller.
Definition can.h:121
static void can_set_state_change_callback(const struct device *dev, can_state_change_callback_t callback, void *user_data)
Set a callback for CAN controller state change events.
Definition can.h:1477
const struct device * can_get_transceiver(const struct device *dev)
Get the CAN transceiver associated with the CAN controller.
int can_set_mode(const struct device *dev, can_mode_t mode)
Set the CAN controller to the given operation mode.
int can_start(const struct device *dev)
Start the CAN controller.
int can_add_rx_filter(const struct device *dev, can_rx_callback_t callback, void *user_data, const struct can_filter *filter)
Add a callback function for a given CAN filter.
#define CAN_FILTER_IDE
Filter matches frames with extended (29-bit) CAN IDs.
Definition can.h:202
@ CAN_STATE_ERROR_ACTIVE
Error-active state (RX/TX error count < 96).
Definition can.h:123
@ CAN_STATE_ERROR_WARNING
Error-warning state (RX/TX error count < 128).
Definition can.h:125
@ CAN_STATE_STOPPED
CAN controller is stopped and does not participate in CAN communication.
Definition can.h:131
@ CAN_STATE_BUS_OFF
Bus-off state (RX/TX error count >= 256).
Definition can.h:129
@ CAN_STATE_ERROR_PASSIVE
Error-passive state (RX/TX error count < 256).
Definition can.h:127
#define MIN(a, b)
Obtain the minimum of two values.
Definition util.h:401
#define ARRAY_SIZE(array)
Number of elements in the given array.
Definition util.h:120
#define DIV_ROUND_UP(n, d)
Divide and round up.
Definition util.h:352
#define ENOSYS
Function not implemented.
Definition errno.h:82
state
Definition parser_state.h:29
ssize_t send(int sock, const void *buf, size_t len, int flags)
#define STATS_NAME_END(name__)
Definition stats.h:391
#define STATS_NAME(name__, entry__)
Definition stats.h:390
#define STATS_SECT_END
Ends a stats group struct definition.
Definition stats.h:89
#define STATS_SECT_ENTRY32(var__)
Definition stats.h:359
#define STATS_NAME_START(name__)
Definition stats.h:389
#define STATS_SECT_START(group__)
Definition stats.h:354
__UINT32_TYPE__ uint32_t
Definition stdint.h:90
__UINT8_TYPE__ uint8_t
Definition stdint.h:88
__UINT16_TYPE__ uint16_t
Definition stdint.h:89
CAN controller error counters.
Definition can.h:223
uint8_t tx_err_cnt
Value of the CAN controller transmit error counter.
Definition can.h:225
uint8_t rx_err_cnt
Value of the CAN controller receive error counter.
Definition can.h:227
CAN specific device state which allows for CAN device class specific additions.
Definition can.h:568
struct device_state devstate
Common device state.
Definition can.h:570
struct stats_can stats
CAN device statistics.
Definition can.h:572
CAN filter structure.
Definition can.h:209
uint32_t mask
CAN identifier matching mask.
Definition can.h:215
uint8_t flags
Flags.
Definition can.h:217
uint32_t id
CAN identifier to match.
Definition can.h:211
CAN frame structure.
Definition can.h:163
uint8_t dlc
Data Length Code (DLC) indicating data length in bytes.
Definition can.h:167
uint8_t flags
Flags.
Definition can.h:169
uint32_t id
Standard (11-bit) or extended (29-bit) CAN identifier.
Definition can.h:165
uint8_t data[CAN_MAX_DLEN]
Payload data accessed as unsigned 8 bit values.
Definition can.h:188
uint32_t data_32[DIV_ROUND_UP(CAN_MAX_DLEN, sizeof(uint32_t))]
Payload data accessed as unsigned 32 bit values.
Definition can.h:190
uint16_t timestamp
Captured value of the free-running timer in the CAN controller when this frame was received.
Definition can.h:178
CAN bus timing structure.
Definition can.h:262
uint16_t sjw
Synchronisation jump width.
Definition can.h:264
uint16_t phase_seg2
Phase segment 2.
Definition can.h:270
uint16_t prescaler
Prescaler value.
Definition can.h:272
uint16_t phase_seg1
Phase segment 1.
Definition can.h:268
uint16_t prop_seg
Propagation segment.
Definition can.h:266
Runtime device dynamic structure (in RAM) per driver instance.
Definition device.h:380
Runtime device structure (in ROM) per driver instance.
Definition device.h:412
void * data
Address of the device instance private data.
Definition device.h:422
const void * api
Address of the API structure exposed by the device instance.
Definition device.h:418
const void * config
Address of device instance config information.
Definition device.h:416
Message Queue Structure.
Definition kernel.h:4509
Kernel timeout type.
Definition sys_clock.h:65
Variables needed for system clock.