can.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021 Vestas Wind Systems A/S
 * Copyright (c) 2018 Karsten Koenig
 * Copyright (c) 2018 Alexander Wachter
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DRIVERS_CAN_H_
#define ZEPHYR_INCLUDE_DRIVERS_CAN_H_
 
#include <errno.h>
 
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/kernel.h>
#include <string.h>
#include <zephyr/sys_clock.h>
#include <zephyr/sys/util.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define CAN_STD_ID_MASK 0x7FFU
#define CAN_MAX_STD_ID CAN_STD_ID_MASK __DEPRECATED_MACRO
#define CAN_EXT_ID_MASK 0x1FFFFFFFU
#define CAN_MAX_EXT_ID CAN_EXT_ID_MASK __DEPRECATED_MACRO
#define CAN_MAX_DLC 8U
#define CANFD_MAX_DLC 15U
 
#ifndef CONFIG_CAN_FD_MODE
#define CAN_MAX_DLEN 8U
#else
#define CAN_MAX_DLEN 64U
#endif /* CONFIG_CAN_FD_MODE */
 
#define CAN_MODE_NORMAL 0
 
#define CAN_MODE_LOOPBACK BIT(0)
 
#define CAN_MODE_LISTENONLY BIT(1)
 
#define CAN_MODE_FD BIT(2)
 
#define CAN_MODE_ONE_SHOT BIT(3)
 
#define CAN_MODE_3_SAMPLES BIT(4)
 
#define CAN_MODE_MANUAL_RECOVERY BIT(5)
 
typedef uint32_t can_mode_t;
 
enum can_state {
 CAN_STATE_ERROR_ACTIVE,
 CAN_STATE_ERROR_WARNING,
 CAN_STATE_ERROR_PASSIVE,
 CAN_STATE_BUS_OFF,
 CAN_STATE_STOPPED,
};
 
#define CAN_FRAME_IDE BIT(0)
 
#define CAN_FRAME_RTR BIT(1)
 
#define CAN_FRAME_FDF BIT(2)
 
#define CAN_FRAME_BRS BIT(3)
 
#define CAN_FRAME_ESI BIT(4)
 
struct can_frame {
 uint32_t id;
 uint8_t dlc;
 uint8_t flags;
#if defined(CONFIG_CAN_RX_TIMESTAMP) || defined(__DOXYGEN__)
 uint16_t timestamp;
#else
 uint16_t reserved;
#endif
 union {
 uint8_t data[CAN_MAX_DLEN];
 uint32_t data_32[DIV_ROUND_UP(CAN_MAX_DLEN, sizeof(uint32_t))];
 };
};
 
#define CAN_FILTER_IDE BIT(0)
 
struct can_filter {
 uint32_t id;
 uint32_t mask;
 uint8_t flags;
};
 
struct can_bus_err_cnt {
 uint8_t tx_err_cnt;
 uint8_t rx_err_cnt;
};
 
struct can_timing {
 uint16_t sjw;
 uint16_t prop_seg;
 uint16_t phase_seg1;
 uint16_t phase_seg2;
 uint16_t prescaler;
};
 
typedef void (*can_tx_callback_t)(const struct device *dev, int error, void *user_data);
 
typedef void (*can_rx_callback_t)(const struct device *dev, struct can_frame *frame,
 void *user_data);
 
typedef void (*can_state_change_callback_t)(const struct device *dev,
 enum can_state state,
 struct can_bus_err_cnt err_cnt,
 void *user_data);
 
#define CAN_CALC_TDCO(_timing_data, _tdco_min, _tdco_max) \
 CLAMP((1U + _timing_data->prop_seg + _timing_data->phase_seg1) * _timing_data->prescaler, \
 _tdco_min, _tdco_max)
 
struct can_driver_config {
 const struct device *phy;
 uint32_t min_bitrate;
 uint32_t max_bitrate;
 uint32_t bus_speed;
 uint16_t sample_point;
#ifdef CONFIG_CAN_FD_MODE
 uint16_t sample_point_data;
 uint32_t bus_speed_data;
#endif /* CONFIG_CAN_FD_MODE */
};
 
#define CAN_DT_DRIVER_CONFIG_GET(node_id, _min_bitrate, _max_bitrate) \
 { \
 .phy = DEVICE_DT_GET_OR_NULL(DT_PHANDLE(node_id, phys)), \
 .min_bitrate = DT_CAN_TRANSCEIVER_MIN_BITRATE(node_id, _min_bitrate), \
 .max_bitrate = DT_CAN_TRANSCEIVER_MAX_BITRATE(node_id, _max_bitrate), \
 .bus_speed = DT_PROP_OR(node_id, bus_speed, CONFIG_CAN_DEFAULT_BITRATE), \
 .sample_point = DT_PROP_OR(node_id, sample_point, 0), \
 IF_ENABLED(CONFIG_CAN_FD_MODE, \
 (.bus_speed_data = DT_PROP_OR(node_id, bus_speed_data, \
 CONFIG_CAN_DEFAULT_BITRATE_DATA), \
 .sample_point_data = DT_PROP_OR(node_id, sample_point_data, 0),)) \
 }
 
#define CAN_DT_DRIVER_CONFIG_INST_GET(inst, _min_bitrate, _max_bitrate) \
 CAN_DT_DRIVER_CONFIG_GET(DT_DRV_INST(inst), _min_bitrate, _max_bitrate)
 
struct can_driver_data {
 can_mode_t mode;
 bool started;
 can_state_change_callback_t state_change_cb;
 void *state_change_cb_user_data;
};
 
typedef int (*can_set_timing_t)(const struct device *dev,
 const struct can_timing *timing);
 
typedef int (*can_set_timing_data_t)(const struct device *dev,
 const struct can_timing *timing_data);
 
typedef int (*can_get_capabilities_t)(const struct device *dev, can_mode_t *cap);
 
typedef int (*can_start_t)(const struct device *dev);
 
typedef int (*can_stop_t)(const struct device *dev);
 
typedef int (*can_set_mode_t)(const struct device *dev, can_mode_t mode);
 
typedef int (*can_send_t)(const struct device *dev,
 const struct can_frame *frame,
 k_timeout_t timeout, can_tx_callback_t callback,
 void *user_data);
 
typedef int (*can_add_rx_filter_t)(const struct device *dev,
 can_rx_callback_t callback,
 void *user_data,
 const struct can_filter *filter);
 
typedef void (*can_remove_rx_filter_t)(const struct device *dev, int filter_id);
 
typedef int (*can_recover_t)(const struct device *dev, k_timeout_t timeout);
 
typedef int (*can_get_state_t)(const struct device *dev, enum can_state *state,
 struct can_bus_err_cnt *err_cnt);
 
typedef void(*can_set_state_change_callback_t)(const struct device *dev,
 can_state_change_callback_t callback,
 void *user_data);
 
typedef int (*can_get_core_clock_t)(const struct device *dev, uint32_t *rate);
 
typedef int (*can_get_max_filters_t)(const struct device *dev, bool ide);
 
__subsystem struct can_driver_api {
 can_get_capabilities_t get_capabilities;
 can_start_t start;
 can_stop_t stop;
 can_set_mode_t set_mode;
 can_set_timing_t set_timing;
 can_send_t send;
 can_add_rx_filter_t add_rx_filter;
 can_remove_rx_filter_t remove_rx_filter;
#if defined(CONFIG_CAN_MANUAL_RECOVERY_MODE) || defined(__DOXYGEN__)
 can_recover_t recover;
#endif /* CONFIG_CAN_MANUAL_RECOVERY_MODE */
 can_get_state_t get_state;
 can_set_state_change_callback_t set_state_change_callback;
 can_get_core_clock_t get_core_clock;
 can_get_max_filters_t get_max_filters;
 /* Min values for the timing registers */
 struct can_timing timing_min;
 /* Max values for the timing registers */
 struct can_timing timing_max;
#if defined(CONFIG_CAN_FD_MODE) || defined(__DOXYGEN__)
 can_set_timing_data_t set_timing_data;
 /* Min values for the timing registers during the data phase */
 struct can_timing timing_data_min;
 /* Max values for the timing registers during the data phase */
 struct can_timing timing_data_max;
#endif /* CONFIG_CAN_FD_MODE */
};
 
#if defined(CONFIG_CAN_STATS) || defined(__DOXYGEN__)
 
#include <zephyr/stats/stats.h>
 
STATS_SECT_START(can)
STATS_SECT_ENTRY32(bit_error)
STATS_SECT_ENTRY32(bit0_error)
STATS_SECT_ENTRY32(bit1_error)
STATS_SECT_ENTRY32(stuff_error)
STATS_SECT_ENTRY32(crc_error)
STATS_SECT_ENTRY32(form_error)
STATS_SECT_ENTRY32(ack_error)
STATS_SECT_ENTRY32(rx_overrun)
STATS_SECT_END;
 
STATS_NAME_START(can)
STATS_NAME(can, bit_error)
STATS_NAME(can, bit0_error)
STATS_NAME(can, bit1_error)
STATS_NAME(can, stuff_error)
STATS_NAME(can, crc_error)
STATS_NAME(can, form_error)
STATS_NAME(can, ack_error)
STATS_NAME(can, rx_overrun)
STATS_NAME_END(can);
 
struct can_device_state {
 struct device_state devstate;
 struct stats_can stats;
};
 
#define Z_CAN_GET_STATS(dev_) \
 CONTAINER_OF(dev_->state, struct can_device_state, devstate)->stats
 
#define CAN_STATS_BIT_ERROR_INC(dev_) \
 STATS_INC(Z_CAN_GET_STATS(dev_), bit_error)
 
#define CAN_STATS_BIT0_ERROR_INC(dev_) \
 do { \
 STATS_INC(Z_CAN_GET_STATS(dev_), bit0_error); \
 CAN_STATS_BIT_ERROR_INC(dev_); \
 } while (0)
 
#define CAN_STATS_BIT1_ERROR_INC(dev_) \
 do { \
 STATS_INC(Z_CAN_GET_STATS(dev_), bit1_error); \
 CAN_STATS_BIT_ERROR_INC(dev_); \
 } while (0)
 
#define CAN_STATS_STUFF_ERROR_INC(dev_) \
 STATS_INC(Z_CAN_GET_STATS(dev_), stuff_error)
 
#define CAN_STATS_CRC_ERROR_INC(dev_) \
 STATS_INC(Z_CAN_GET_STATS(dev_), crc_error)
 
#define CAN_STATS_FORM_ERROR_INC(dev_) \
 STATS_INC(Z_CAN_GET_STATS(dev_), form_error)
 
#define CAN_STATS_ACK_ERROR_INC(dev_) \
 STATS_INC(Z_CAN_GET_STATS(dev_), ack_error)
 
#define CAN_STATS_RX_OVERRUN_INC(dev_) \
 STATS_INC(Z_CAN_GET_STATS(dev_), rx_overrun)
 
#define CAN_STATS_RESET(dev_) \
 stats_reset(&(Z_CAN_GET_STATS(dev_).s_hdr))
 
#define Z_CAN_DEVICE_STATE_DEFINE(dev_id) \
 static struct can_device_state Z_DEVICE_STATE_NAME(dev_id) \
 __attribute__((__section__(".z_devstate")))
 
#define Z_CAN_INIT_FN(dev_id, init_fn) \
 static inline int UTIL_CAT(dev_id, _init)(const struct device *dev) \
 { \
 struct can_device_state *state = \
 CONTAINER_OF(dev->state, struct can_device_state, devstate); \
 stats_init(&state->stats.s_hdr, STATS_SIZE_32, 8, \
 STATS_NAME_INIT_PARMS(can)); \
 stats_register(dev->name, &(state->stats.s_hdr)); \
 if (!is_null_no_warn(init_fn)) { \
 return init_fn(dev); \
 } \
 \
 return 0; \
 }
 
#define CAN_DEVICE_DT_DEFINE(node_id, init_fn, pm, data, config, level, \
 prio, api, ...) \
 Z_CAN_DEVICE_STATE_DEFINE(Z_DEVICE_DT_DEV_ID(node_id)); \
 Z_CAN_INIT_FN(Z_DEVICE_DT_DEV_ID(node_id), init_fn) \
 Z_DEVICE_DEFINE(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
 DEVICE_DT_NAME(node_id), \
 &UTIL_CAT(Z_DEVICE_DT_DEV_ID(node_id), _init), \
 pm, data, config, level, prio, api, \
 &(Z_DEVICE_STATE_NAME(Z_DEVICE_DT_DEV_ID(node_id)).devstate), \
 __VA_ARGS__)
 
#else /* CONFIG_CAN_STATS */
 
#define CAN_STATS_BIT_ERROR_INC(dev_)
#define CAN_STATS_BIT0_ERROR_INC(dev_)
#define CAN_STATS_BIT1_ERROR_INC(dev_)
#define CAN_STATS_STUFF_ERROR_INC(dev_)
#define CAN_STATS_CRC_ERROR_INC(dev_)
#define CAN_STATS_FORM_ERROR_INC(dev_)
#define CAN_STATS_ACK_ERROR_INC(dev_)
#define CAN_STATS_RX_OVERRUN_INC(dev_)
#define CAN_STATS_RESET(dev_)
 
#define CAN_DEVICE_DT_DEFINE(node_id, init_fn, pm, data, config, level, \
 prio, api, ...) \
 DEVICE_DT_DEFINE(node_id, init_fn, pm, data, config, level, \
 prio, api, __VA_ARGS__)
 
#endif /* CONFIG_CAN_STATS */
 
#define CAN_DEVICE_DT_INST_DEFINE(inst, ...) \
 CAN_DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
 
__syscall int can_get_core_clock(const struct device *dev, uint32_t *rate);
 
static inline int z_impl_can_get_core_clock(const struct device *dev, uint32_t *rate)
{
 const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
 return api->get_core_clock(dev, rate);
}
 
__syscall uint32_t can_get_bitrate_min(const struct device *dev);
 
static inline uint32_t z_impl_can_get_bitrate_min(const struct device *dev)
{
 const struct can_driver_config *common = (const struct can_driver_config *)dev->config;
 
 return common->min_bitrate;
}
 
__deprecated static inline int can_get_min_bitrate(const struct device *dev, uint32_t *min_bitrate)
{
 *min_bitrate = can_get_bitrate_min(dev);
 
 return 0;
}
 
__syscall uint32_t can_get_bitrate_max(const struct device *dev);
 
static inline uint32_t z_impl_can_get_bitrate_max(const struct device *dev)
{
 const struct can_driver_config *common = (const struct can_driver_config *)dev->config;
 
 return common->max_bitrate;
}
 
__deprecated static inline int can_get_max_bitrate(const struct device *dev, uint32_t *max_bitrate)
{
 *max_bitrate = can_get_bitrate_max(dev);
 
 return 0;
}
 
__syscall const struct can_timing *can_get_timing_min(const struct device *dev);
 
static inline const struct can_timing *z_impl_can_get_timing_min(const struct device *dev)
{
 const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
 return &api->timing_min;
}
 
__syscall const struct can_timing *can_get_timing_max(const struct device *dev);
 
static inline const struct can_timing *z_impl_can_get_timing_max(const struct device *dev)
{
 const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
 return &api->timing_max;
}
 
__syscall int can_calc_timing(const struct device *dev, struct can_timing *res,
 uint32_t bitrate, uint16_t sample_pnt);
 
__syscall const struct can_timing *can_get_timing_data_min(const struct device *dev);
 
#ifdef CONFIG_CAN_FD_MODE
static inline const struct can_timing *z_impl_can_get_timing_data_min(const struct device *dev)
{
 const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
 return &api->timing_data_min;
}
#endif /* CONFIG_CAN_FD_MODE */
 
__syscall const struct can_timing *can_get_timing_data_max(const struct device *dev);
 
#ifdef CONFIG_CAN_FD_MODE
static inline const struct can_timing *z_impl_can_get_timing_data_max(const struct device *dev)
{
 const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
 return &api->timing_data_max;
}
#endif /* CONFIG_CAN_FD_MODE */
 
__syscall int can_calc_timing_data(const struct device *dev, struct can_timing *res,
 uint32_t bitrate, uint16_t sample_pnt);
 
__syscall int can_set_timing_data(const struct device *dev,
 const struct can_timing *timing_data);
 
__syscall int can_set_bitrate_data(const struct device *dev, uint32_t bitrate_data);
 
__deprecated int can_calc_prescaler(const struct device *dev, struct can_timing *timing,
 uint32_t bitrate);
 
__syscall int can_set_timing(const struct device *dev,
 const struct can_timing *timing);
 
__syscall int can_get_capabilities(const struct device *dev, can_mode_t *cap);
 
static inline int z_impl_can_get_capabilities(const struct device *dev, can_mode_t *cap)
{
 const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
 return api->get_capabilities(dev, cap);
}
 
__syscall const struct device *can_get_transceiver(const struct device *dev);
 
static const struct device *z_impl_can_get_transceiver(const struct device *dev)
{
 const struct can_driver_config *common = (const struct can_driver_config *)dev->config;
 
 return common->phy;
}
 
__syscall int can_start(const struct device *dev);
 
static inline int z_impl_can_start(const struct device *dev)
{
 const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
 return api->start(dev);
}
 
__syscall int can_stop(const struct device *dev);
 
static inline int z_impl_can_stop(const struct device *dev)
{
 const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
 return api->stop(dev);
}
 
__syscall int can_set_mode(const struct device *dev, can_mode_t mode);
 
static inline int z_impl_can_set_mode(const struct device *dev, can_mode_t mode)
{
 const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
 return api->set_mode(dev, mode);
}
 
__syscall can_mode_t can_get_mode(const struct device *dev);
 
static inline can_mode_t z_impl_can_get_mode(const struct device *dev)
{
 const struct can_driver_data *common = (const struct can_driver_data *)dev->data;
 
 return common->mode;
}
 
__syscall int can_set_bitrate(const struct device *dev, uint32_t bitrate);
 
__syscall int can_send(const struct device *dev, const struct can_frame *frame,
 k_timeout_t timeout, can_tx_callback_t callback,
 void *user_data);
 
int can_add_rx_filter(const struct device *dev, can_rx_callback_t callback,
 void *user_data, const struct can_filter *filter);
 
#define CAN_MSGQ_DEFINE(name, max_frames) \
 K_MSGQ_DEFINE(name, sizeof(struct can_frame), max_frames, 4)
 
__syscall int can_add_rx_filter_msgq(const struct device *dev, struct k_msgq *msgq,
 const struct can_filter *filter);
 
__syscall void can_remove_rx_filter(const struct device *dev, int filter_id);
 
static inline void z_impl_can_remove_rx_filter(const struct device *dev, int filter_id)
{
 const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
 return api->remove_rx_filter(dev, filter_id);
}
 
__syscall int can_get_max_filters(const struct device *dev, bool ide);
 
static inline int z_impl_can_get_max_filters(const struct device *dev, bool ide)
{
 const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
 if (api->get_max_filters == NULL) {
 return -ENOSYS;
 }
 
 return api->get_max_filters(dev, ide);
}
 
__syscall int can_get_state(const struct device *dev, enum can_state *state,
 struct can_bus_err_cnt *err_cnt);
 
static inline int z_impl_can_get_state(const struct device *dev, enum can_state *state,
 struct can_bus_err_cnt *err_cnt)
{
 const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
 return api->get_state(dev, state, err_cnt);
}
 
__syscall int can_recover(const struct device *dev, k_timeout_t timeout);
 
#ifdef CONFIG_CAN_MANUAL_RECOVERY_MODE
static inline int z_impl_can_recover(const struct device *dev, k_timeout_t timeout)
{
 const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
 if (api->recover == NULL) {
 return -ENOSYS;
 }
 
 return api->recover(dev, timeout);
}
#endif /* CONFIG_CAN_MANUAL_RECOVERY_MODE */
 
static inline void can_set_state_change_callback(const struct device *dev,
 can_state_change_callback_t callback,
 void *user_data)
{
 const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
 api->set_state_change_callback(dev, callback, user_data);
}
 
__syscall uint32_t can_stats_get_bit_errors(const struct device *dev);
 
#ifdef CONFIG_CAN_STATS
static inline uint32_t z_impl_can_stats_get_bit_errors(const struct device *dev)
{
 return Z_CAN_GET_STATS(dev).bit_error;
}
#endif /* CONFIG_CAN_STATS */
 
__syscall uint32_t can_stats_get_bit0_errors(const struct device *dev);
 
#ifdef CONFIG_CAN_STATS
static inline uint32_t z_impl_can_stats_get_bit0_errors(const struct device *dev)
{
 return Z_CAN_GET_STATS(dev).bit0_error;
}
#endif /* CONFIG_CAN_STATS */
 
__syscall uint32_t can_stats_get_bit1_errors(const struct device *dev);
 
#ifdef CONFIG_CAN_STATS
static inline uint32_t z_impl_can_stats_get_bit1_errors(const struct device *dev)
{
 return Z_CAN_GET_STATS(dev).bit1_error;
}
#endif /* CONFIG_CAN_STATS */
 
__syscall uint32_t can_stats_get_stuff_errors(const struct device *dev);
 
#ifdef CONFIG_CAN_STATS
static inline uint32_t z_impl_can_stats_get_stuff_errors(const struct device *dev)
{
 return Z_CAN_GET_STATS(dev).stuff_error;
}
#endif /* CONFIG_CAN_STATS */
 
__syscall uint32_t can_stats_get_crc_errors(const struct device *dev);
 
#ifdef CONFIG_CAN_STATS
static inline uint32_t z_impl_can_stats_get_crc_errors(const struct device *dev)
{
 return Z_CAN_GET_STATS(dev).crc_error;
}
#endif /* CONFIG_CAN_STATS */
 
__syscall uint32_t can_stats_get_form_errors(const struct device *dev);
 
#ifdef CONFIG_CAN_STATS
static inline uint32_t z_impl_can_stats_get_form_errors(const struct device *dev)
{
 return Z_CAN_GET_STATS(dev).form_error;
}
#endif /* CONFIG_CAN_STATS */
 
__syscall uint32_t can_stats_get_ack_errors(const struct device *dev);
 
#ifdef CONFIG_CAN_STATS
static inline uint32_t z_impl_can_stats_get_ack_errors(const struct device *dev)
{
 return Z_CAN_GET_STATS(dev).ack_error;
}
#endif /* CONFIG_CAN_STATS */
 
__syscall uint32_t can_stats_get_rx_overruns(const struct device *dev);
 
#ifdef CONFIG_CAN_STATS
static inline uint32_t z_impl_can_stats_get_rx_overruns(const struct device *dev)
{
 return Z_CAN_GET_STATS(dev).rx_overrun;
}
#endif /* CONFIG_CAN_STATS */
 
static inline uint8_t can_dlc_to_bytes(uint8_t dlc)
{
 static const uint8_t dlc_table[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 12,
 16, 20, 24, 32, 48, 64};
 
 return dlc_table[MIN(dlc, ARRAY_SIZE(dlc_table) - 1)];
}
 
static inline uint8_t can_bytes_to_dlc(uint8_t num_bytes)
{
 return num_bytes <= 8 ? num_bytes :
 num_bytes <= 12 ? 9 :
 num_bytes <= 16 ? 10 :
 num_bytes <= 20 ? 11 :
 num_bytes <= 24 ? 12 :
 num_bytes <= 32 ? 13 :
 num_bytes <= 48 ? 14 :
 15;
}
 
static inline bool can_frame_matches_filter(const struct can_frame *frame,
 const struct can_filter *filter)
{
 if ((frame->flags & CAN_FRAME_IDE) != 0 && (filter->flags & CAN_FILTER_IDE) == 0) {
 /* Extended (29-bit) ID frame, standard (11-bit) filter */
 return false;
 }
 
 if ((frame->flags & CAN_FRAME_IDE) == 0 && (filter->flags & CAN_FILTER_IDE) != 0) {
 /* Standard (11-bit) ID frame, extended (29-bit) filter */
 return false;
 }
 
 if ((frame->id ^ filter->id) & filter->mask) {
 /* Masked ID mismatch */
 return false;
 }
 
 return true;
}
 
#ifdef __cplusplus
}
#endif
 
#include <syscalls/can.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_CAN_H_ */