can.h

Go to the documentation of this file.

#ifndef NEXUS_IO_CAN_H
#define NEXUS_IO_CAN_H
 
#include "nexus/core/request.h"
#include "nexus/io/wake.h"
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum { NX_CAN_STANDARD, NX_CAN_EXTENDED } nx_can_format_t;
typedef enum { NX_CAN_DATA, NX_CAN_REMOTE } nx_can_frame_kind_t;
typedef struct {
    uint32_t id;
    nx_can_format_t format;
    nx_can_frame_kind_t kind;
    uint8_t dlc;
    uint8_t data[8];
} nx_can_frame_t;

typedef struct {
    nx_request_t base;
    nx_can_frame_t frame;
} nx_can_tx_request_t;
typedef enum { NX_CAN_EVENT_FRAME, NX_CAN_EVENT_LOSS } nx_can_event_kind_t;
#define NX_CAN_LOSS_SOFTWARE             1U
#define NX_CAN_LOSS_HARDWARE_LOWER_BOUND 2U
#define NX_CAN_LOSS_SATURATED            4U
#define NX_CAN_DLC_NORMALIZED            8U
typedef struct {
    nx_can_frame_t frame;
    nx_time_us_t timestamp_us;
    uint64_t lost;
    uint32_t flags;
    nx_can_event_kind_t kind;
    uint8_t fifo;
    uint8_t filter;
    uint8_t raw_dlc;
} nx_can_event_t;

typedef struct {
    bool started;
    bool closing;
    bool bus_off;
    uint8_t pending;
    uint8_t transmit_errors;
    uint8_t receive_errors;
    uint8_t last_error;
} nx_can_state_t;

typedef struct {
    nx_result_t (*submit)(void*, nx_can_tx_request_t*);
    nx_result_t (*cancel)(void*, nx_can_tx_request_t*);
    nx_result_t (*service)(void*);
    nx_result_t (*read_events)(void*, nx_can_event_t*, size_t, size_t*);
    nx_result_t (*state)(void*, nx_can_state_t*);
    nx_result_t (*stop)(void*);
    nx_result_t (*recover)(void*);
    nx_result_t (*attach_wake)(void*, const nx_irq_wake_t*, uint8_t);
} nx_can_ops_t;

typedef struct {
    const nx_can_ops_t* ops;
    void* context;
} nx_can_port_t;

nx_result_t nx_can_tx_prepare(nx_can_tx_request_t* request,
                              const nx_can_frame_t* frame,
                              nx_time_us_t deadline);
nx_result_t nx_can_port_submit(const nx_can_port_t* port,
                               nx_can_tx_request_t* request);
nx_result_t nx_can_port_cancel(const nx_can_port_t* port,
                               nx_can_tx_request_t* request);
nx_result_t nx_can_port_service(const nx_can_port_t* port);
nx_result_t nx_can_port_read_events(const nx_can_port_t* port,
                                    nx_can_event_t* events, size_t capacity,
                                    size_t* count);
nx_result_t nx_can_port_state(const nx_can_port_t* port, nx_can_state_t* state);
nx_result_t nx_can_port_stop(const nx_can_port_t* port);
nx_result_t nx_can_port_recover(const nx_can_port_t* port);
nx_result_t nx_can_port_attach_wake(const nx_can_port_t* port,
                                    const nx_irq_wake_t* wake,
                                    uint8_t syscall_ceiling);
#ifdef __cplusplus
}
#endif
#endif