can.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021 Vestas Wind Systems A/S
 * Copyright (c) 2018 Alexander Wachter
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DRIVERS_CAN_H_
#define ZEPHYR_INCLUDE_DRIVERS_CAN_H_
 
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <string.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
#define CAN_EXT_ID_MASK 0x1FFFFFFFU
#define CAN_MAX_EXT_ID  CAN_EXT_ID_MASK
#define CAN_MAX_DLC     8U
#define CANFD_MAX_DLC   CONFIG_CANFD_MAX_DLC
 
#ifndef CONFIG_CANFD_MAX_DLC
#define CAN_MAX_DLEN    8U
#else
#if CONFIG_CANFD_MAX_DLC <= 8
#define CAN_MAX_DLEN    CONFIG_CANFD_MAX_DLC
#elif CONFIG_CANFD_MAX_DLC <= 12
#define CAN_MAX_DLEN    (CONFIG_CANFD_MAX_DLC + (CONFIG_CANFD_MAX_DLC - 8U) * 4U)
#elif CONFIG_CANFD_MAX_DLC == 13
#define CAN_MAX_DLEN    32U
#elif CONFIG_CANFD_MAX_DLC == 14
#define CAN_MAX_DLEN    48U
#elif CONFIG_CANFD_MAX_DLC == 15
#define CAN_MAX_DLEN    64U
#endif
#endif /* CONFIG_CANFD_MAX_DLC */
 
#define CAN_MODE_NORMAL     0
 
#define CAN_MODE_LOOPBACK   BIT(0)
 
#define CAN_MODE_LISTENONLY BIT(1)
 
#define CAN_MODE_FD         BIT(2)
 
typedef uint32_t can_mode_t;
 
enum can_state {
        CAN_ERROR_ACTIVE,
        CAN_ERROR_WARNING,
        CAN_ERROR_PASSIVE,
        CAN_BUS_OFF,
};
 
enum can_ide {
        CAN_STANDARD_IDENTIFIER,
        CAN_EXTENDED_IDENTIFIER
};
 
enum can_rtr {
        CAN_DATAFRAME,
        CAN_REMOTEREQUEST
};
 
struct zcan_frame {
        uint32_t id      : 29;
        uint32_t fd      : 1;
        uint32_t rtr     : 1;
        uint32_t id_type : 1;
        uint8_t dlc;
        uint8_t brs : 1;
        uint8_t res : 7; /* reserved/padding. */
#if defined(CONFIG_CAN_RX_TIMESTAMP) || defined(__DOXYGEN__)
        uint16_t timestamp;
#else
        uint8_t res0;  /* reserved/padding. */
        uint8_t res1;  /* reserved/padding. */
#endif
        union {
                uint8_t data[CAN_MAX_DLEN];
                uint32_t data_32[ceiling_fraction(CAN_MAX_DLEN, sizeof(uint32_t))];
        };
};
 
struct zcan_filter {
        uint32_t id           : 29;
        uint32_t res0         : 1;
        uint32_t rtr          : 1;
        uint32_t id_type      : 1;
        uint32_t id_mask      : 29;
        uint32_t res1         : 1;
        uint32_t rtr_mask     : 1;
        uint32_t res2         : 1;
};
 
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 zcan_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);
 
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_set_mode_t)(const struct device *dev, can_mode_t mode);
 
typedef int (*can_send_t)(const struct device *dev,
                          const struct zcan_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 zcan_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, enum can_ide id_type);
 
typedef int (*can_get_max_bitrate_t)(const struct device *dev, uint32_t *max_bitrate);
 
__subsystem struct can_driver_api {
        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_AUTO_BUS_OFF_RECOVERY) || defined(__DOXYGEN__)
        can_recover_t recover;
#endif /* CONFIG_CAN_AUTO_BUS_OFF_RECOVERY */
        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;
        can_get_max_bitrate_t get_max_bitrate;
        /* 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(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_END;
 
STATS_NAME_START(can)
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_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_BIT0_ERROR_INC(dev_)                  \
        STATS_INC(Z_CAN_GET_STATS(dev_), bit0_error)
 
#define CAN_STATS_BIT1_ERROR_INC(dev_)                  \
        STATS_INC(Z_CAN_GET_STATS(dev_), bit1_error)
 
#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 Z_CAN_DEVICE_STATE_DEFINE(node_id, dev_name)                    \
        static struct can_device_state Z_DEVICE_STATE_NAME(dev_name)    \
        __attribute__((__section__(".z_devstate")));
 
#define Z_CAN_INIT_FN(dev_name, init_fn)                                \
        static inline int UTIL_CAT(dev_name, _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, 6,       \
                           STATS_NAME_INIT_PARMS(can));                 \
                stats_register(dev->name, &(state->stats.s_hdr));       \
                return init_fn(dev);                                    \
        }
 
#define CAN_DEVICE_DT_DEFINE(node_id, init_fn, pm_device,               \
                             data_ptr, cfg_ptr, level, prio,            \
                             api_ptr, ...)                              \
        Z_CAN_DEVICE_STATE_DEFINE(node_id, Z_DEVICE_DT_DEV_NAME(node_id)); \
        Z_CAN_INIT_FN(Z_DEVICE_DT_DEV_NAME(node_id), init_fn)           \
        Z_DEVICE_DEFINE(node_id, Z_DEVICE_DT_DEV_NAME(node_id),         \
                        DEVICE_DT_NAME(node_id),                        \
                        &UTIL_CAT(Z_DEVICE_DT_DEV_NAME(node_id), _init), \
                        pm_device,                                      \
                        data_ptr, cfg_ptr, level, prio,                 \
                        api_ptr,                                        \
                        &(Z_DEVICE_STATE_NAME(Z_DEVICE_DT_DEV_NAME(node_id)).devstate), \
                        __VA_ARGS__)
 
#else /* CONFIG_CAN_STATS */
 
#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_DEVICE_DT_DEFINE(node_id, init_fn, pm_device,               \
                             data_ptr, cfg_ptr, level, prio,            \
                             api_ptr, ...)                              \
        DEVICE_DT_DEFINE(node_id, init_fn, pm_device,                   \
                             data_ptr, cfg_ptr, level, prio,            \
                             api_ptr, __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 int can_get_max_bitrate(const struct device *dev, uint32_t *max_bitrate);
 
static inline int z_impl_can_get_max_bitrate(const struct device *dev, uint32_t *max_bitrate)
{
        const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
        if (api->get_max_bitrate == NULL) {
                return -ENOSYS;
        }
 
        return api->get_max_bitrate(dev, max_bitrate);
}
 
__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);
 
#ifdef CONFIG_CAN_FD_MODE
static inline int z_impl_can_set_timing_data(const struct device *dev,
                                             const struct can_timing *timing_data)
{
        const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
        return api->set_timing_data(dev, timing_data);
}
#endif /* CONFIG_CAN_FD_MODE */
 
__syscall int can_set_bitrate_data(const struct device *dev, uint32_t bitrate_data);
 
int can_calc_prescaler(const struct device *dev, struct can_timing *timing,
                       uint32_t bitrate);
 
#define CAN_SJW_NO_CHANGE 0
 
__syscall int can_set_timing(const struct device *dev,
                             const struct can_timing *timing);
 
static inline int z_impl_can_set_timing(const struct device *dev,
                                        const struct can_timing *timing)
{
        const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
        return api->set_timing(dev, timing);
}
 
__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 int can_set_bitrate(const struct device *dev, uint32_t bitrate);
 
__syscall int can_send(const struct device *dev, const struct zcan_frame *frame,
                       k_timeout_t timeout, can_tx_callback_t callback,
                       void *user_data);
 
static inline int z_impl_can_send(const struct device *dev, const struct zcan_frame *frame,
                                  k_timeout_t timeout, can_tx_callback_t callback,
                                  void *user_data)
{
        const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
        return api->send(dev, frame, timeout, callback, user_data);
}
 
static inline int can_add_rx_filter(const struct device *dev, can_rx_callback_t callback,
                                    void *user_data, const struct zcan_filter *filter)
{
        const struct can_driver_api *api = (const struct can_driver_api *)dev->api;
 
        return api->add_rx_filter(dev, callback, user_data, filter);
}
 
#define CAN_MSGQ_DEFINE(name, max_frames) \
        K_MSGQ_DEFINE(name, sizeof(struct zcan_frame), max_frames, 4)
 
__syscall int can_add_rx_filter_msgq(const struct device *dev, struct k_msgq *msgq,
                                     const struct zcan_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, enum can_ide id_type);
 
static inline int z_impl_can_get_max_filters(const struct device *dev, enum can_ide id_type)
{
        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, id_type);
}
 
__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);
}
 
#if !defined(CONFIG_CAN_AUTO_BUS_OFF_RECOVERY) || defined(__DOXYGEN__)
__syscall int can_recover(const struct device *dev, k_timeout_t timeout);
 
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;
 
        return api->recover(dev, timeout);
}
#else /* CONFIG_CAN_AUTO_BUS_OFF_RECOVERY */
/* This implementation prevents inking errors for auto recovery */
static inline int z_impl_can_recover(const struct device *dev, k_timeout_t timeout)
{
        ARG_UNUSED(dev);
        ARG_UNUSED(timeout);
        return 0;
}
#endif /* !CONFIG_CAN_AUTO_BUS_OFF_RECOVERY */
 
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);
}
 
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 > 0x0F ? 64 : dlc_table[dlc];
}
 
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;
}
 
typedef uint32_t canid_t;
 
struct can_frame {
        canid_t can_id;
 
        uint8_t can_dlc;
 
        uint8_t pad;   /* padding. */
        uint8_t res0;  /* reserved/padding. */
        uint8_t res1;  /* reserved/padding. */
        uint8_t data[CAN_MAX_DLEN];
};
 
struct can_filter {
        canid_t can_id;
        canid_t can_mask;
};
 
static inline void can_copy_frame_to_zframe(const struct can_frame *frame,
                                            struct zcan_frame *zframe)
{
        zframe->id_type = (frame->can_id & BIT(31)) >> 31;
        zframe->rtr = (frame->can_id & BIT(30)) >> 30;
        zframe->id = frame->can_id & BIT_MASK(29);
        zframe->dlc = frame->can_dlc;
        memcpy(zframe->data, frame->data, sizeof(zframe->data));
}
 
static inline void can_copy_zframe_to_frame(const struct zcan_frame *zframe,
                                            struct can_frame *frame)
{
        frame->can_id = (zframe->id_type << 31) | (zframe->rtr << 30) | zframe->id;
        frame->can_dlc = zframe->dlc;
        memcpy(frame->data, zframe->data, sizeof(frame->data));
}
 
static inline void can_copy_filter_to_zfilter(const struct can_filter *filter,
                                              struct zcan_filter *zfilter)
{
        zfilter->id_type = (filter->can_id & BIT(31)) >> 31;
        zfilter->rtr = (filter->can_id & BIT(30)) >> 30;
        zfilter->id = filter->can_id & BIT_MASK(29);
        zfilter->rtr_mask = (filter->can_mask & BIT(30)) >> 30;
        zfilter->id_mask = filter->can_mask & BIT_MASK(29);
}
 
static inline void can_copy_zfilter_to_filter(const struct zcan_filter *zfilter,
                                              struct can_filter *filter)
{
        filter->can_id = (zfilter->id_type << 31) |
                (zfilter->rtr << 30) | zfilter->id;
        filter->can_mask = (zfilter->rtr_mask << 30) |
                (zfilter->id_type << 31) | zfilter->id_mask;
}
 
#ifdef __cplusplus
}
#endif
 
#include <syscalls/can.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_CAN_H_ */