lin.h

Go to the documentation of this file.

/*
 * Copyright (c) 2025 Renesas Electronics Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#ifndef ZEPHYR_INCLUDE_ZEPHYR_DRIVERS_LIN_H
#define ZEPHYR_INCLUDE_ZEPHYR_DRIVERS_LIN_H
 
#include <errno.h>
 
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/clock.h>
#include <zephyr/sys/util.h>
 
#ifdef __cplusplus
extern "C" {
#endif



#define LIN_ID_MASK 0x3FU

#define LIN_MAX_DLEN 8U



#define LIN_BUS_CONFLICT_DETECTION BIT(0) 
#define LIN_BUS_AUTO_SYNC          BIT(1) 


typedef uint32_t lin_config_flags_t;

enum lin_checksum_type {
        LIN_CHECKSUM_CLASSIC = 0, 
        LIN_CHECKSUM_ENHANCED,    
};

enum lin_event_type {
        LIN_EVT_RX_HEADER = 0, 
        LIN_EVT_TX_HEADER,     
        LIN_EVT_RX_DATA,       
        LIN_EVT_TX_DATA,       
        LIN_EVT_TX_WAKEUP,     
        LIN_EVT_RX_WAKEUP,     
        LIN_EVT_ERR,           
};

#define LIN_ERR_BUS_COLLISION    BIT(0) 
#define LIN_ERR_INVALID_CHECKSUM BIT(1) 
#define LIN_ERR_COUNTER_OVERFLOW BIT(2) 
#define LIN_ERR_OVERRUN          BIT(3) 
#define LIN_ERR_PARITY           BIT(4) 
#define LIN_ERR_FRAMING          BIT(5) 

typedef uint32_t lin_error_flags_t;

enum lin_mode {
        LIN_MODE_COMMANDER = 0,
        LIN_MODE_RESPONDER,
};

struct lin_config {
        enum lin_mode mode;
        uint32_t baudrate;
        size_t break_len;
        size_t break_delimiter_len;
        lin_config_flags_t flags;
};

struct lin_msg {
        uint8_t id;
        uint8_t flags;
        uint8_t data_len;
        uint8_t reserved;
        union {
                uint8_t data[LIN_MAX_DLEN];
                uint32_t data_32[DIV_ROUND_UP(LIN_MAX_DLEN, sizeof(uint32_t))];
        };
        enum lin_checksum_type checksum_type;
};

struct lin_event {
        enum lin_event_type type;
        int status;
        union {
                struct {
                        uint8_t pid;
                } header;
                struct {
                        uint8_t pid;
                        uint8_t bytes_received;
                        uint8_t checksum;
                } data;
                lin_error_flags_t error_flags;
        };
};

typedef void (*lin_event_callback_t)(const struct device *dev, const struct lin_event *event,
                                     void *user_data);

struct lin_filter {
        uint8_t primary_pid;
        uint8_t secondary_pid;
        uint8_t mask;
};

typedef int (*lin_start_t)(const struct device *dev);

typedef int (*lin_stop_t)(const struct device *dev);

typedef int (*lin_configure_t)(const struct device *dev, const struct lin_config *config);

typedef int (*lin_get_config_t)(const struct device *dev, struct lin_config *config);

typedef int (*lin_send_t)(const struct device *dev, const struct lin_msg *msg, k_timeout_t timeout);

typedef int (*lin_receive_t)(const struct device *dev, struct lin_msg *msg, k_timeout_t timeout);

typedef int (*lin_response_t)(const struct device *dev, const struct lin_msg *msg,
                              k_timeout_t timeout);

typedef int (*lin_read_t)(const struct device *dev, struct lin_msg *msg, k_timeout_t timeout);

typedef int (*lin_wakeup_send_t)(const struct device *dev);

typedef int (*lin_set_event_callback_t)(const struct device *dev, lin_event_callback_t callback,
                                        void *user_data);

typedef int (*lin_set_rx_filter_t)(const struct device *dev, const struct lin_filter *filter);

struct lin_driver_config {
        const struct device *phy;
        uint32_t min_bitrate;
        uint32_t max_bitrate;
        uint32_t bitrate;
};

#define LIN_DT_DRIVER_CONFIG_GET(node_id, _min_bitrate, _max_bitrate)                              \
        {                                                                                          \
                .phy = DEVICE_DT_GET_OR_NULL(DT_PHANDLE(node_id, phys)),                           \
                .min_bitrate = DT_PROP_OR(node_id, min_bitrate, _min_bitrate),                     \
                .max_bitrate = DT_PROP_OR(node_id, max_bitrate, _max_bitrate),                     \
                .bitrate = DT_PROP_OR(node_id, bitrate, 0),                                        \
        }

#define LIN_DT_DRIVER_CONFIG_INST_GET(inst, _min_bitrate, _max_bitrate)                            \
        LIN_DT_DRIVER_CONFIG_GET(DT_DRV_INST(inst), _min_bitrate, _max_bitrate)

struct lin_driver_data {
        struct lin_config config;
        bool started;
        lin_event_callback_t callback;
        void *callback_data;
};

__subsystem struct lin_driver_api {
        lin_start_t start;
        lin_stop_t stop;
        lin_configure_t configure;
        lin_get_config_t get_config;
        lin_set_rx_filter_t set_rx_filter;
        lin_send_t send;
        lin_receive_t receive;
        lin_response_t response;
        lin_read_t read;
        lin_wakeup_send_t wakeup_send;
        lin_set_event_callback_t set_event_callback;
};

static inline uint8_t lin_get_frame_id(uint8_t pid)
{
        return pid & LIN_ID_MASK;
}

static inline uint8_t lin_compute_pid(uint8_t id)
{
        uint8_t p0 = (FIELD_GET(BIT(0), id) ^ FIELD_GET(BIT(1), id) ^ FIELD_GET(BIT(2), id) ^
                      FIELD_GET(BIT(4), id)) &
                     0x1U;
        uint8_t p1 = ~(FIELD_GET(BIT(1), id) ^ FIELD_GET(BIT(3), id) ^ FIELD_GET(BIT(4), id) ^
                       FIELD_GET(BIT(5), id)) &
                     0x1U;
 
        return (id & LIN_ID_MASK) | (p0 << 6) | (p1 << 7);
}

static inline bool lin_verify_pid(uint8_t pid)
{
        uint8_t id = lin_get_frame_id(pid);
 
        return lin_compute_pid(id) == pid;
}

__syscall const struct device *lin_get_transceiver(const struct device *dev);
 
static const struct device *z_impl_lin_get_transceiver(const struct device *dev)
{
        const struct lin_driver_config *config = dev->config;
 
        return config->phy;
}

__syscall int lin_start(const struct device *dev);
 
static inline int z_impl_lin_start(const struct device *dev)
{
        return DEVICE_API_GET(lin, dev)->start(dev);
}

__syscall int lin_stop(const struct device *dev);
 
static inline int z_impl_lin_stop(const struct device *dev)
{
        return DEVICE_API_GET(lin, dev)->stop(dev);
}

__syscall int lin_configure(const struct device *dev, const struct lin_config *config);
 
static inline int z_impl_lin_configure(const struct device *dev, const struct lin_config *config)
{
        return DEVICE_API_GET(lin, dev)->configure(dev, config);
}

__syscall int lin_get_config(const struct device *dev, struct lin_config *config);
 
static inline int z_impl_lin_get_config(const struct device *dev, struct lin_config *config)
{
        return DEVICE_API_GET(lin, dev)->get_config(dev, config);
}

__syscall int lin_send(const struct device *dev, const struct lin_msg *msg, k_timeout_t timeout);
 
static inline int z_impl_lin_send(const struct device *dev, const struct lin_msg *msg,
                                  k_timeout_t timeout)
{
        return DEVICE_API_GET(lin, dev)->send(dev, msg, timeout);
}

__syscall int lin_receive(const struct device *dev, struct lin_msg *msg, k_timeout_t timeout);
 
static inline int z_impl_lin_receive(const struct device *dev, struct lin_msg *msg,
                                     k_timeout_t timeout)
{
        return DEVICE_API_GET(lin, dev)->receive(dev, msg, timeout);
}

__syscall int lin_response(const struct device *dev, const struct lin_msg *msg,
                           k_timeout_t timeout);
 
static inline int z_impl_lin_response(const struct device *dev, const struct lin_msg *msg,
                                      k_timeout_t timeout)
{
        const struct lin_driver_api *api = DEVICE_API_GET(lin, dev);
 
        if (api->response == NULL) {
                return -ENOSYS;
        }
 
        return api->response(dev, msg, timeout);
}

__syscall int lin_read(const struct device *dev, struct lin_msg *msg, k_timeout_t timeout);
 
static inline int z_impl_lin_read(const struct device *dev, struct lin_msg *msg,
                                  k_timeout_t timeout)
{
        const struct lin_driver_api *api = DEVICE_API_GET(lin, dev);
 
        if (api->read == NULL) {
                return -ENOSYS;
        }
 
        return api->read(dev, msg, timeout);
}

__syscall int lin_wakeup_send(const struct device *dev);
 
static inline int z_impl_lin_wakeup_send(const struct device *dev)
{
        const struct lin_driver_api *api = DEVICE_API_GET(lin, dev);
 
        if (api->wakeup_send == NULL) {
                return -ENOSYS;
        }
 
        return api->wakeup_send(dev);
}

static inline int lin_set_event_callback(const struct device *dev, lin_event_callback_t callback,
                                         void *user_data)
{
        return DEVICE_API_GET(lin, dev)->set_event_callback(dev, callback, user_data);
}

__syscall int lin_set_rx_filter(const struct device *dev, const struct lin_filter *filter);
 
static inline int z_impl_lin_set_rx_filter(const struct device *dev,
                                           const struct lin_filter *filter)
{
        const struct lin_driver_api *api = DEVICE_API_GET(lin, dev);
 
        if (api->set_rx_filter == NULL) {
                return -ENOSYS;
        }
 
        return api->set_rx_filter(dev, filter);
}
 
#ifdef __cplusplus
}
#endif

 
#include <zephyr/syscalls/lin.h>
 
#endif /* ZEPHYR_INCLUDE_ZEPHYR_DRIVERS_LIN_H */