usb_device.h

Go to the documentation of this file.

#ifndef NEXUS_USB_DEVICE_H
#define NEXUS_USB_DEVICE_H
#include "nexus/core/request.h"
#include "nexus/io/wake.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef enum { NX_USB_DATA, NX_USB_STATUS } nx_usb_stage_t;
typedef struct {
    nx_request_t base;
    const uint8_t* in;
    uint8_t* out;
    size_t length;
    uint64_t control_epoch;
    nx_usb_stage_t stage;
} nx_usb_request_t;
typedef struct {
    uint8_t request_type;
    uint8_t request;
    uint16_t value;
    uint16_t index;
    uint16_t length;
    uint64_t epoch;
} nx_usb_setup_t;
typedef enum {
    NX_USB_EVENT_SETUP,
    NX_USB_EVENT_RESET,
    NX_USB_EVENT_SUSPEND,
    NX_USB_EVENT_RESUME,
    NX_USB_EVENT_LOSS
} nx_usb_event_kind_t;
typedef struct {
    nx_usb_setup_t setup;
    nx_time_us_t timestamp_us;
    uint64_t lost;
    nx_usb_event_kind_t kind;
} nx_usb_event_t;
typedef struct {
    nx_usb_setup_t setup;
    uint64_t epoch;
    uint64_t lost_events;
    bool started;
    bool closing;
    bool suspended;
    bool control_pending;
    uint8_t address;
} nx_usb_device_state_t;

typedef struct {
    nx_result_t (*submit)(void*, nx_usb_request_t*);
    nx_result_t (*cancel)(void*, nx_usb_request_t*);
    nx_result_t (*stall)(void*, bool);
} nx_usb_endpoint_ops_t;
typedef struct {
    const nx_usb_endpoint_ops_t* ops;
    void* context;
} nx_usb_endpoint_port_t;

typedef struct {
    nx_result_t (*service)(void*);
    nx_result_t (*read_events)(void*, nx_usb_event_t*, size_t, size_t*);
    nx_result_t (*state)(void*, nx_usb_device_state_t*);
    nx_result_t (*address)(void*, uint64_t, uint8_t);
    nx_result_t (*attach_wake)(void*, const nx_irq_wake_t*, uint8_t);
    nx_result_t (*stop)(void*);
} nx_usb_device_ops_t;
typedef struct {
    const nx_usb_device_ops_t* ops;
    void* context;
} nx_usb_device_port_t;

nx_result_t nx_usb_in_prepare(nx_usb_request_t* request, const uint8_t* bytes,
                              size_t length, nx_usb_stage_t stage,
                              uint64_t epoch, nx_time_us_t deadline);
nx_result_t nx_usb_out_prepare(nx_usb_request_t* request, uint8_t* bytes,
                               size_t capacity, nx_usb_stage_t stage,
                               uint64_t epoch, nx_time_us_t deadline);
nx_result_t nx_usb_endpoint_submit(const nx_usb_endpoint_port_t* port,
                                   nx_usb_request_t* request);
nx_result_t nx_usb_endpoint_cancel(const nx_usb_endpoint_port_t* port,
                                   nx_usb_request_t* request);
nx_result_t nx_usb_endpoint_stall(const nx_usb_endpoint_port_t* port,
                                  bool stalled);
nx_result_t nx_usb_device_service(const nx_usb_device_port_t* port);
nx_result_t nx_usb_device_read_events(const nx_usb_device_port_t* port,
                                      nx_usb_event_t* events, size_t capacity,
                                      size_t* count);
nx_result_t nx_usb_device_state(const nx_usb_device_port_t* port,
                                nx_usb_device_state_t* state);
nx_result_t nx_usb_device_address(const nx_usb_device_port_t* port,
                                  uint64_t epoch, uint8_t address);
nx_result_t nx_usb_device_attach_wake(const nx_usb_device_port_t* port,
                                      const nx_irq_wake_t* wake,
                                      uint8_t syscall_ceiling);
nx_result_t nx_usb_device_stop(const nx_usb_device_port_t* port);
#ifdef __cplusplus
}
#endif
#endif