i2c.h

Go to the documentation of this file.

#ifndef NEXUS_I2C_H
#define NEXUS_I2C_H
 
#include "nexus/core/request.h"
#include "nexus/io/wake.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct nx_i2c_port nx_i2c_port_t;
typedef struct nx_i2c_endpoint nx_i2c_endpoint_t;
#define NX_I2C_MAX_MESSAGES      8U
#define NX_I2C_MAX_MESSAGE_BYTES 256U
typedef struct {
    uint8_t* data;
    size_t length;
    bool read;
} nx_i2c_message_t;

typedef struct {
    nx_request_t base;
    nx_i2c_message_t* messages;
    size_t count;
} nx_i2c_request_t;

typedef struct {
    nx_result_t (*recover)(void* context);
    nx_result_t (*cancel)(void* context, nx_i2c_request_t* request);
    void (*service)(void* context);
    nx_result_t (*stop)(void* context);
    nx_result_t (*attach_wake)(void* context, const nx_irq_wake_t* wake,
                               uint8_t syscall_ceiling);
} nx_i2c_ops_t;

struct nx_i2c_port {
    const nx_i2c_ops_t* ops;
    void* context;
};

typedef struct {
    nx_result_t (*transaction)(void* context, nx_i2c_message_t* messages,
                               size_t count, nx_time_us_t deadline,
                               size_t* transferred);
    nx_result_t (*submit)(void* context, nx_i2c_request_t* request);
    nx_result_t (*start_admitted)(void* context, nx_i2c_request_t* request);
    bool (*on_port)(const void* context, const nx_i2c_port_t* port);
} nx_i2c_endpoint_ops_t;

struct nx_i2c_endpoint {
    const nx_i2c_endpoint_ops_t* ops;
    void* context;
};

nx_result_t nx_i2c_endpoint_transaction(const nx_i2c_endpoint_t* endpoint,
                                        nx_i2c_message_t* messages,
                                        size_t count, nx_time_us_t deadline,
                                        size_t* transferred);
nx_result_t nx_i2c_port_recover(const nx_i2c_port_t* port);

nx_result_t nx_i2c_request_prepare(nx_i2c_request_t* request,
                                   nx_i2c_message_t* messages, size_t count,
                                   nx_time_us_t deadline);
nx_result_t nx_i2c_request_validate(const nx_i2c_request_t* request);
nx_result_t nx_i2c_endpoint_submit(const nx_i2c_endpoint_t* endpoint,
                                   nx_i2c_request_t* request);
nx_result_t nx_i2c_endpoint_start_admitted(const nx_i2c_endpoint_t* endpoint,
                                           nx_i2c_request_t* request);
bool nx_i2c_endpoint_on_port(const nx_i2c_endpoint_t* endpoint,
                             const nx_i2c_port_t* port);
nx_result_t nx_i2c_port_cancel(const nx_i2c_port_t* port,
                               nx_i2c_request_t* request);
void nx_i2c_port_service(const nx_i2c_port_t* port);
nx_result_t nx_i2c_port_stop(const nx_i2c_port_t* port);
nx_result_t nx_i2c_port_attach_wake(const nx_i2c_port_t* port,
                                    const nx_irq_wake_t* wake,
                                    uint8_t syscall_ceiling);
#ifdef __cplusplus
}
#endif
 
#endif