spi.h

Go to the documentation of this file.

#ifndef NEXUS_SPI_H
#define NEXUS_SPI_H
 
#include "nexus/core/request.h"
#include "nexus/io/wake.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct nx_spi_port nx_spi_port_t;
typedef struct nx_spi_endpoint nx_spi_endpoint_t;

#define NX_SPI_MEMORY_TX_FIXED 1U
#define NX_SPI_MEMORY_RX_FIXED 2U

typedef struct {
    nx_request_t base;
    const uint8_t* tx;
    uint8_t* rx;
    size_t length;
} nx_spi_request_t;

typedef struct {
    nx_result_t (*recover)(void* context);
    nx_result_t (*cancel)(void* context, nx_spi_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_spi_ops_t;

struct nx_spi_port {
    const nx_spi_ops_t* ops;
    void* context;
};

typedef struct {
    nx_result_t (*transfer)(void* context, const uint8_t* tx, uint8_t* rx,
                            size_t length, nx_time_us_t deadline,
                            size_t* transferred);
    nx_result_t (*submit)(void* context, nx_spi_request_t* request);
    nx_result_t (*start_admitted)(void* context, nx_spi_request_t* request);
    bool (*on_port)(const void* context, const nx_spi_port_t* port);
    nx_result_t (*submit_memory)(void* context, nx_spi_request_t* request,
                                 uint8_t memory_flags);
} nx_spi_endpoint_ops_t;

struct nx_spi_endpoint {
    const nx_spi_endpoint_ops_t* ops;
    void* context;
};

nx_result_t nx_spi_endpoint_transfer(const nx_spi_endpoint_t* endpoint,
                                     const uint8_t* tx, uint8_t* rx,
                                     size_t length, nx_time_us_t deadline,
                                     size_t* transferred);
nx_result_t nx_spi_port_recover(const nx_spi_port_t* port);
nx_result_t nx_spi_request_prepare(nx_spi_request_t* request, const uint8_t* tx,
                                   uint8_t* rx, size_t length,
                                   nx_time_us_t deadline);
nx_result_t nx_spi_endpoint_submit(const nx_spi_endpoint_t* endpoint,
                                   nx_spi_request_t* request);
nx_result_t nx_spi_endpoint_submit_memory(const nx_spi_endpoint_t* endpoint,
                                          nx_spi_request_t* request,
                                          uint8_t memory_flags);
nx_result_t nx_spi_endpoint_start_admitted(const nx_spi_endpoint_t* endpoint,
                                           nx_spi_request_t* request);
bool nx_spi_endpoint_on_port(const nx_spi_endpoint_t* endpoint,
                             const nx_spi_port_t* port);
nx_result_t nx_spi_port_cancel(const nx_spi_port_t* port,
                               nx_spi_request_t* request);
void nx_spi_port_service(const nx_spi_port_t* port);
nx_result_t nx_spi_port_stop(const nx_spi_port_t* port);
nx_result_t nx_spi_port_attach_wake(const nx_spi_port_t* port,
                                    const nx_irq_wake_t* wake,
                                    uint8_t syscall_ceiling);
#ifdef __cplusplus
}
#endif
 
#endif