kst_link.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdbool.h>
#include <stdint.h>
 
#include "kst_reg.h"
#include "kst_session.h"
#include "link_pages.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#define KST_LINK_MINOR LINK_MINOR_PROG

#define KST_LINK_POLL_MS 50u
#define KST_LINK_IDLE_MS 500u

#define KST_LINK_RETRIES 3u

#define KST_LINK_NO_ANSWER (-1)
#define KST_LINK_ACK       0

typedef enum {
    KST_LINK_DOWN = 0,   
    KST_LINK_NO_PAGE,    
    KST_LINK_SYNC,       
    KST_LINK_READY,      
    KST_LINK_SENDING,    
    KST_LINK_RUNNING,    
    KST_LINK_FETCHING,   
    KST_LINK_PLANNING,   
} kst_link_phase_t;

typedef enum {
    KST_LINK_START_OK = 0,
    KST_LINK_START_DOWN,       
    KST_LINK_START_NO_PAGE,    
    KST_LINK_START_BUSY,       
    KST_LINK_START_ARG,        
    KST_LINK_START_NO_ENABLE,  
    KST_LINK_START_NO_IMAGE,   
    KST_LINK_START_NO_OP,      
} kst_link_start_t;

typedef struct {
    link_kst_op_t op;          
    uint8_t  port;             
    uint16_t supply_mv;        
    uint16_t supply_ma;        
    uint16_t leave_ms;         
    bool     write_enabled;    
    bool     confirm;          
    kst_image_t image;         
    kst_field_set_t unlock;    
    uint32_t id;               
} kst_link_request_t;

typedef enum {
    KST_LINK_OUT_NONE = 0,
    KST_LINK_OUT_DONE,       
    KST_LINK_OUT_REFUSED,    
    KST_LINK_OUT_NACK,       
    KST_LINK_OUT_NO_ANSWER,  
    KST_LINK_OUT_RESTARTED,  
    KST_LINK_OUT_DROPPED,    
} kst_link_outcome_kind_t;

typedef struct {
    kst_link_outcome_kind_t kind;
    link_kst_op_t      op;
    uint32_t id;                  
    link_kst_refusal_t refusal;   
    uint8_t  nack;                
    bool     taken;               
    uint8_t  result;              
    uint8_t  fail_reg;            
    uint8_t  steps_done;          
    uint16_t frames;              
    uint32_t diff_regs;           
    uint32_t bad_regs;            
} kst_link_outcome_t;

typedef struct {
    kst_link_phase_t phase;
    bool     known;            
    bool     was_held;         
    link_kst_state_t port;     
    uint8_t  port_no;          
    uint16_t flags;            
    link_kst_op_t op;          
    uint16_t frames;           
    bool     have_image;       
    bool     have_backup;               
    bool     have_results;     
    uint16_t fp_rules;         
    uint32_t fp_regs;          
    uint16_t half_min_ns;      
    uint16_t half_max_ns;               
    uint16_t delay_min_us;     
    uint16_t delay_max_us;              
} kst_link_readout_t;

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

typedef struct {
    bool     up;
    bool     page;
    uint16_t minor;            
    bool     known;            
    uint8_t  phase;            
    uint8_t  pending;          
    uint8_t  tries;            
    bool     was_held;         
 
    uint16_t status[LINK_KS_W_CMD_FRAME];
    bool     polled;           
    bool     poll_now;         
    uint32_t status_ms;        
    uint16_t seq;              
 
    /* The operation. */
    bool     active;           
    bool     verdict;          
    bool     taken;            
    uint8_t  op;               
    uint32_t id;               
    uint8_t  stage_at;         
    uint16_t staged[LINK_KS_W_STAGED];
    bool     supply_due;       
    uint16_t supply[2];        
    bool     leave_due;        
    uint16_t leave_ms;         
    uint16_t cmd_proto[LINK_KS_W_CMD_FRAME];  
 
    /* The command on its way, the operation's or an abort. */
    bool     cmd_live;
    bool     cmd_abort;
    bool     cmd_doubt;        
    uint16_t cmd[LINK_KS_W_CMD_FRAME];
    bool     abort_wanted;
 
    /* What was fetched. */
    uint8_t  fetch;            
    uint16_t end_status[LINK_KS_W_CMD_FRAME]; 
    bool     have_results;
    uint16_t results[LINK_KS_IMAGE - LINK_KS_FAIL];
    bool     have_image;
    uint16_t image_regs[LINK_KS_IMAGE_REGS];
    bool     have_backup;
    uint16_t backup_regs[LINK_KS_IMAGE_REGS];
 
    bool     outcome_new;
    kst_link_outcome_t outcome;
} kst_link_t;

void kst_link_init(kst_link_t *k);

void kst_link_lost(kst_link_t *k);

void kst_link_came_up(kst_link_t *k, uint16_t minor);

bool kst_link_has_page(const kst_link_t *k);

kst_link_start_t kst_link_start(kst_link_t *k, const kst_link_request_t *r);

kst_link_start_t kst_link_fetch(kst_link_t *k);

void kst_link_abort(kst_link_t *k);

bool kst_link_next(kst_link_t *k, uint32_t now_ms, kst_link_xfer_t *x);

void kst_link_done(kst_link_t *k, int result, const uint16_t *regs);

kst_link_phase_t kst_link_phase(const kst_link_t *k);

bool kst_link_outcome(kst_link_t *k, kst_link_outcome_t *out);

void kst_link_readout(const kst_link_t *k, kst_link_readout_t *r);

bool kst_link_image(const kst_link_t *k, kst_image_t *out);

bool kst_link_backup(const kst_link_t *k, kst_image_t *out);
 
#ifdef __cplusplus
}
#endif