hitec_link.h

Go to the documentation of this file.

#ifndef RCBENCH_HITEC_LINK_H
#define RCBENCH_HITEC_LINK_H
 
#include <stdbool.h>
#include <stdint.h>
 
#include "hitec_session.h"
#include "hitec_wire.h"
#include "link_pages.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#define HITEC_LINK_MINOR LINK_MINOR_HITEC

#define HITEC_LINK_POLL_MS 5u
#define HITEC_LINK_HELD_MS 100u
#define HITEC_LINK_IDLE_MS 500u
#define HITEC_LINK_RETRIES 3u
#define HITEC_LINK_PASS_MAX 4u
#define HITEC_LINK_RUN_MAX_MS 25000u
#define HITEC_LINK_NO_PIN 0xFFFFu

#define HITEC_LINK_NO_ANSWER (-1)
#define HITEC_LINK_ACK       0

typedef enum {
    HITEC_LINK_DOWN = 0,   
    HITEC_LINK_NO_PAGE,    
    HITEC_LINK_SYNC,       
    HITEC_LINK_READY,      
    HITEC_LINK_SENDING,    
    HITEC_LINK_RUNNING,    
    HITEC_LINK_FETCHING,   
} hitec_link_phase_t;

typedef enum {
    HITEC_LINK_START_OK = 0,
    HITEC_LINK_START_DOWN,     
    HITEC_LINK_START_NO_PAGE,  
    HITEC_LINK_START_BUSY,     
    HITEC_LINK_START_ARG,      
} hitec_link_start_t;

typedef enum {
    HITEC_LINK_OUT_NONE = 0,
    HITEC_LINK_OUT_DONE,       
    HITEC_LINK_OUT_REFUSED,    
    HITEC_LINK_OUT_NACK,       
    HITEC_LINK_OUT_NO_ANSWER,  
    HITEC_LINK_OUT_RESTARTED,  
    HITEC_LINK_OUT_DROPPED,    
} hitec_link_outcome_kind_t;

typedef struct {
    hitec_link_outcome_kind_t kind; 
    link_hitec_op_t op;         
    uint8_t  port;              
    uint32_t id;                
    link_hitec_refusal_t refusal; 
    uint8_t  nack;              
    bool     taken;             
    uint8_t  result;            
    hitec_ses_result_t ses;
    bool     have_cap;          
    uint16_t cap;               
    uint8_t  answer_id;         
    uint8_t  n;                 
    uint8_t  bytes[HITEC_RX_MAX]; 
    bool     have_run;          
    uint32_t delay_ns;          
    uint32_t t_us;              
    uint32_t window_us;         
    uint16_t framing;           
} hitec_link_outcome_t;

typedef struct {
    hitec_link_phase_t phase; 
    uint16_t minor;          
    bool     hold_supply;    
    bool     known;          
    link_hitec_state_t state; 
    uint8_t  port_no;        
    uint16_t flags;          
    bool     held;           
    bool     stopped;        
    bool     ours;           
    uint16_t seq;            
    link_hitec_op_t op;      
    uint16_t count;          
    bool     have_line;      
    uint16_t pin;            
    uint16_t line;           
    uint16_t bit_ns;         
} hitec_link_readout_t;

typedef struct {
    bool     write;          
    uint8_t  page;           
    uint8_t  off;            
    uint8_t  n;              
    uint16_t regs[4];        
} hitec_link_xfer_t;

typedef int (*hitec_link_xchg_fn)(void *ctx, const hitec_link_xfer_t *x,
                                  uint16_t *regs);

#define HITEC_LINK_STAGED (LINK_HT_W_STAGED + 1u)

typedef struct {
    uint8_t  up;             
    uint8_t  page;           
    uint16_t minor;          
    uint8_t  known;          
    uint8_t  phase;          
    uint8_t  pending;        
    uint8_t  tries;          
    uint8_t  polled;         
    uint8_t  poll_now;       
    uint32_t status_ms;      
    uint32_t now_ms;         
    uint16_t seq;            
    uint16_t status[LINK_HT_DATA]; 
    uint8_t  ours;           
    uint8_t  have_line;      
    uint16_t line[3];        
 
    /* The request. */
    uint8_t  active;         
    uint8_t  op;             
    uint8_t  port;           
    uint32_t id;             
    uint8_t  stage_at;       
    uint16_t staged[HITEC_LINK_STAGED]; 
    uint16_t cmd_proto[LINK_HT_W_CMD_FRAME]; 
    uint8_t  verdict;        
    uint8_t  taken;          
    uint32_t taken_ms;       
    uint8_t  limit_cut;      
 
    /* The command on its way: the request's, or an abort. */
    uint8_t  cmd_live;       
    uint8_t  cmd_abort;      
    uint8_t  cmd_tries;      
    uint8_t  cmd_doubt;      
    uint8_t  doubt_abort;    
    uint8_t  doubt_nack;     
    uint16_t cmd[LINK_HT_W_CMD_FRAME]; 
    uint8_t  abort_wanted;   
 
    uint16_t end[LINK_HT_DATA]; 
    uint8_t  outcome_new;    
    hitec_link_outcome_t outcome; 
} hitec_link_t;

void hitec_link_init(hitec_link_t *l);

void hitec_link_lost(hitec_link_t *l);

void hitec_link_came_up(hitec_link_t *l, uint16_t minor);

bool hitec_link_has_page(const hitec_link_t *l);

hitec_link_start_t hitec_link_open(hitec_link_t *l, uint8_t port,
                                   uint8_t family, uint8_t drive,
                                   uint32_t id);

hitec_link_start_t hitec_link_close(hitec_link_t *l, uint8_t port,
                                    uint32_t id);

hitec_link_start_t hitec_link_clear(hitec_link_t *l, uint8_t port,
                                    uint32_t id);

hitec_link_start_t hitec_link_step(hitec_link_t *l, uint8_t port,
                                   const hitec_ses_step_t *st, uint16_t mv,
                                   uint16_t ma, uint32_t id);

void hitec_link_abort(hitec_link_t *l);

bool hitec_link_next(hitec_link_t *l, uint32_t now_ms, hitec_link_xfer_t *x);

void hitec_link_done(hitec_link_t *l, int result, const uint16_t *regs);

unsigned hitec_link_service(hitec_link_t *l, uint32_t now_ms,
                            hitec_link_xchg_fn xchg, void *ctx);

hitec_link_phase_t hitec_link_phase(const hitec_link_t *l);

bool hitec_link_outcome(hitec_link_t *l, hitec_link_outcome_t *out);

void hitec_link_readout(const hitec_link_t *l, hitec_link_readout_t *r);
 
#ifdef __cplusplus
}
#endif
 
#endif /* RCBENCH_HITEC_LINK_H */