sark.h

Go to the documentation of this file.

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
/*
 * Copyright (c) 2009 The University of Manchester
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef __SARK_H__
#define __SARK_H__
 
#include <spinnaker.h>
#include <version.h>
 
//------------------------------------------------------------------------------
 
#define SARK_EVENT      1   
 
//------------------------------------------------------------------------------
 
 
#define SVC_STACK          384  
#define IRQ_STACK          256  
#define FIQ_STACK          256  
 
 
// SARK configuration defaults - these can be modified at SARK
// start-up using "sark_config"
 
#define NUM_SDP_MSGS     4  
#define SARK_SLOT       15  
#define INIT_EVENTS     16  
 
#define DEAD_WORD       0xdeaddead  
 
//------------------------------------------------------------------------------
 
#ifdef DOXYGEN
typedef void (*int_handler) (void);
 
#else
#ifdef __GNUC__
# define INT_HANDLER \
    void __attribute__ ((interrupt ("IRQ")))
# define SARK_IS_A_MALLOC(size_arg) \
    __attribute__ ((malloc, alloc_size(size_arg), assume_aligned(4)))
# define SARK_IS_A_CALLOC(size_arg1, size_arg2) \
    __attribute__ ((malloc, alloc_size(size_arg1, size_arg2), assume_aligned(4)))
typedef void (*int_handler) (void);
 
#else
# define INT_HANDLER \
    __irq void
# define SARK_IS_A_MALLOC(size_arg) \
    __attribute__ ((malloc))
# define SARK_IS_A_CALLOC(size_arg1, size_arg2) \
    __attribute__ ((malloc))
typedef __irq void (*int_handler) (void);   
#endif
 
#endif
 
// doxygen has overrides for all of these.
#ifndef NONNULL
#define NONNULL __attribute__((nonnull))
#define NONNULL2 __attribute__((nonnull(2)))
#define NORETURN __attribute__((noreturn))
#endif
 
//------------------------------------------------------------------------------
 
// Useful macros...
 
#ifndef ntohs
 
# define ntohs(t) ((((t) & 0x00ff) << 8) | (((t) >> 8) & 0x00ff))
 
# define htons(t) ((((t) & 0x00ff) << 8) | (((t) >> 8) & 0x00ff))
 
#endif
 
# define CHIP_ID(x, y) (((x) << 8) + (y))
 
# define CHIP_X(id)    ((id) >> 8)
 
# define CHIP_Y(id)    ((id) & 255)
 
 
//------------------------------------------------------------------------------
 
// APLX definitions
 
enum sark_aplx_command {
    APLX_ACOPY = 1,     
    APLX_RCOPY = 2,     
    APLX_FILL = 3,      
    APLX_EXEC = 4,      
 
    APLX_END = 0xff     
};
 
#define APLX_ENTRY_SIZE 16      
#define APLX_BUF_SIZE   64      
 
#define APLX_BUFFER     (ITCM_TOP - APLX_BUF_SIZE)
 
//------------------------------------------------------------------------------
 
// IPTAG definitions
 
#define TAG_NONE        255     
#define TAG_HOST        0       
 
//------------------------------------------------------------------------------
 
// Definition of range of router MC entries which may be allocated
 
#define RTR_ALLOC_FIRST     1               
#define RTR_ALLOC_LAST      MC_TABLE_SIZE   
 
#define RTR_ALLOC_MAX       (RTR_ALLOC_LAST - RTR_ALLOC_FIRST)
 
// Flags to sark_xalloc() (etc)
 
#define ALLOC_LOCK      1       
#define ALLOC_ID        2       
 
#define ALLOC_TAG_RETRY 4
 
//------------------------------------------------------------------------------
 
enum spin_lock_e {
    LOCK_MSG,           
    LOCK_MBOX,          
    LOCK_ETHER,         
    LOCK_GPIO,          
    LOCK_API_ROOT,      
    LOCK_SEMA,          
    LOCK_HEAP,          
    LOCK_RTR            
};
 
typedef enum spin_lock_e spin_lock; 
 
 
#define A_LOCK_SEMA     5
 
//------------------------------------------------------------------------------
 
enum app_flags_e {
    APP_FLAG_WAIT       
};
 
 
//------------------------------------------------------------------------------
 
enum rte_code_e {
    RTE_NONE,           
    RTE_RESET,          
    RTE_UNDEF,          
    RTE_SVC,            
    RTE_PABT,           
    RTE_DABT,           
    RTE_IRQ,            
    RTE_FIQ,            
    RTE_VIC,            
 
    RTE_ABORT,          
    RTE_MALLOC,         
    RTE_DIV0,           
    RTE_EVENT,          
    RTE_SWERR,          
    RTE_IOBUF,          
    RTE_ENABLE,         
    RTE_NULL,           
    RTE_PKT,            
    RTE_TIMER,          
    RTE_API,            
    RTE_VER             
};
 
typedef enum rte_code_e rte_code;   
 
enum sark_alib_rte_codes {
    A_RTE_RESET = 1,    
    A_RTE_UNDEF = 2,    
    A_RTE_SVC = 3,      
    A_RTE_PABT = 4,     
    A_RTE_DABT = 5,     
    A_RTE_IRQ = 6,      
    A_RTE_FIQ = 7,      
    A_RTE_VIC = 8,      
};
 
//------------------------------------------------------------------------------
 
// Various enumerated types, etc
 
enum cpu_state_e {
    CPU_STATE_DEAD,     
    CPU_STATE_PWRDN,    
    CPU_STATE_RTE,      
    CPU_STATE_WDOG,     
 
    CPU_STATE_INIT,     
    CPU_STATE_WAIT,     
    CPU_STATE_SARK,     
    CPU_STATE_RUN,      
 
    CPU_STATE_SYNC0,    
    CPU_STATE_SYNC1,    
    CPU_STATE_PAUSE,    
    CPU_STATE_EXIT,     
 
    CPU_STATE_12,       
    CPU_STATE_13,       
    CPU_STATE_14,       
    CPU_STATE_IDLE      
};
 
typedef enum cpu_state_e cpu_state; 
 
#define A_STATE_RTE 2
 
enum event_type_e {
    EVENT_TIMER,        
    EVENT_RXPKT,        
    EVENT_SDP,          
    EVENT_USER,         
    EVENT_SIG,          
    EVENT_DMA,          
    EVENT_MAX=EVENT_DMA 
};
 
typedef enum event_type_e event_type;   
 
#define EVENT_COUNT 6
 
enum event_state_e {    // RUN must be first (0)
    EVENT_RUN,          
    EVENT_PAUSE,        
    EVENT_STOP          
};
 
typedef enum event_state_e event_state; 
 
enum vic_slot_e {
    SLOT_0,
    SLOT_1,
    SLOT_2,
    SLOT_3,
    SLOT_4,
    SLOT_5,
    SLOT_6,
    SLOT_7,
    SLOT_8,
    SLOT_9,
    SLOT_10,
    SLOT_11,
    SLOT_12,
    SLOT_13,
    SLOT_14,
    SLOT_15,
    SLOT_FIQ,           
    SLOT_MAX = SLOT_15  
};
 
typedef enum vic_slot_e vic_slot;   
 
enum event_priority_e {
    PRIO_0,
    PRIO_1,
    PRIO_2,
    PRIO_3,
    PRIO_MAX = PRIO_3
};
 
typedef enum event_priority_e event_priority;   
 
enum sw_err_mode_e {
    SW_OPT,             
    SW_NEVER,           
    SW_RTE              
};
 
typedef enum sw_err_mode_e sw_err_mode; 
 
enum sync_bool_e {
    SYNC_NOWAIT,        
    SYNC_WAIT           
};
 
typedef enum sync_bool_e sync_bool; 
 
//------------------------------------------------------------------------------
 
// LED definitions - pass these to "sark_led_set"
 
#define LED_ON(n)   (3 << (2 * n))  
#define LED_OFF(n)  (2 << (2 * n))  
#define LED_INV(n)  (1 << (2 * n))  
#define LED_FLIP(n) (1 << (2 * n))  
 
//------------------------------------------------------------------------------
 
enum shm_cmd_e {
    SHM_IDLE,           
    SHM_MSG,            
    SHM_NOP,            
    SHM_SIGNAL,         
    SHM_CMD             
};
 
typedef enum shm_cmd_e shm_cmd; 
 
//------------------------------------------------------------------------------
 
enum signal_e {
    SIG_INIT,           
    SIG_PWRDN,          
    SIG_STOP,           
    SIG_START,          
 
    SIG_SYNC0,          
    SIG_SYNC1,          
    SIG_PAUSE,          
    SIG_CONT,           
 
    SIG_EXIT,           
    SIG_TIMER,          
    SIG_USR0,           
    SIG_USR1,           
 
    SIG_USR2,           
    SIG_USR3,           
};
 
typedef enum signal_e signal;   
 
//------------------------------------------------------------------------------
 
 
# define IO_STD     ((char *) 0)    
# define IO_DBG     ((char *) 1)    
# define IO_BUF     ((char *) 2)    
# define IO_NULL    ((char *) 3)    
 
 
//------------------------------------------------------------------------------
 
enum sark_scp_command_codes {
    CMD_VER = 0,                
    CMD_RUN = 1,                
    CMD_READ = 2,               
    CMD_WRITE = 3,              
    CMD_APLX = 4,               
    CMD_FILL = 5,               
 
    // Following for monitors only
    CMD_COUNT = 15,             
    CMD_REMAP = 16,             
    CMD_LINK_READ = 17,         
    CMD_LINK_WRITE = 18,        
    CMD_AR = 19,                
 
    CMD_NNP = 20,               
    CMD_APP_COPY_RUN = 21,      
    CMD_SIG = 22,               
    CMD_FFD = 23,               
 
    CMD_AS = 24,                
    CMD_LED = 25,               
    CMD_IPTAG = 26,             
    CMD_SROM = 27,              
 
    CMD_ALLOC = 28,             
    CMD_RTR = 29,               
    CMD_RSVD = 30,              
    CMD_INFO = 31,              
    CMD_SYNC = 32,              
 
    // 48-63 reserved for BMP
 
    CMD_TUBE = 64               
};
 
enum sark_scp_return_codes {
    RC_OK = 0x80,               
    RC_LEN = 0x81,              
    RC_SUM = 0x82,              
    RC_CMD = 0x83,              
    RC_ARG = 0x84,              
    RC_PORT = 0x85,             
    RC_TIMEOUT = 0x86,          
    RC_ROUTE = 0x87,            
    RC_CPU = 0x88,              
    RC_DEAD = 0x89,             
    RC_BUF = 0x8a,              
    RC_P2P_NOREPLY = 0x8b,      
    RC_P2P_REJECT = 0x8c,       
    RC_P2P_BUSY = 0x8d,         
    RC_P2P_TIMEOUT = 0x8e,      
    RC_PKT_TX = 0x8f,           
};
 
enum sark_scp_memory_size_types {
    TYPE_BYTE = 0,              
    TYPE_HALF = 1,              
    TYPE_WORD = 2               
};
 
//------------------------------------------------------------------------------
 
// Misc typedefs
 
typedef struct divmod {
    uint div;           
    uint mod;           
} divmod_t;
 
typedef struct mem_link {
    struct mem_link *next;      
} mem_link_t;
 
typedef struct mem_block {
    mem_link_t *free;   
    ushort count;       
    ushort max;         
} mem_block_t;
 
 
typedef struct srom_data {
    ushort flags;       
    uchar  mac_addr[6]; 
    uchar  ip_addr[4];  
    uchar  gw_addr[4];  
    uchar  net_mask[4]; 
    ushort udp_port;    
    ushort __PAD1;      
    uint   __PAD2;      
    uint   __PAD3;      
} srom_data_t;
 
typedef struct rtr_entry {
    ushort next;        
    ushort free;        
    uint route;         
    uint key;           
    uint mask;          
} rtr_entry_t;
 
typedef struct app_data {
    uchar cores;        
    uchar clean;        
    uchar sema;         
    uchar lead;         
    uint mask;          
} app_data_t;
 
 
//------------------------------------------------------------------------------
 
// SDP messages
 
#define NUM_SDP_PORTS   8       
#define PORT_SHIFT      5       
#define PORT_MASK       0xe0    
#define CPU_MASK        0x1f    
 
#define PORT_ETH        255     
 
#define SDP_BUF_SIZE    256     
 
typedef struct sdp_msg {        // SDP message - 292 bytes
    struct sdp_msg *next;       
    ushort length;              
    ushort checksum;            
 
    // sdp_hdr_t (mandatory)
 
    uchar flags;                
    uchar tag;                  
    uchar dest_port;            
    uchar srce_port;            
    ushort dest_addr;           
    ushort srce_addr;           
 
    // cmd_hdr_t (optional)
 
    ushort cmd_rc;              
    ushort seq;                 
    uint arg1;                  
    uint arg2;                  
    uint arg3;                  
 
    // user data (optional)
 
    uchar data[SDP_BUF_SIZE];   
 
    uint __PAD1;                
} sdp_msg_t;
 
 
// Legacy definitions...
 
typedef struct sdp_hdr {
    uchar flags;
    uchar tag;
    uchar dest_port;
    uchar srce_port;
    ushort dest_addr;
    ushort srce_addr;
} sdp_hdr_t;
 
typedef struct cmd_hdr {
    ushort cmd_rc;
    ushort flags;
    uint arg1;
    uint arg2;
    uint arg3;
} cmd_hdr_t;
 
//------------------------------------------------------------------------------
 
// Heap data structures
 
typedef struct block {
    struct block *next;         
    struct block *free;         
} block_t;
 
typedef struct {
    block_t *free;              
    block_t *first;             
    block_t *last;              
    uint free_bytes;            
    uchar buffer[];             
} heap_t;
 
 
//------------------------------------------------------------------------------
 
// Struct "sark_vec" containing ARM exception vectors, etc
 
typedef struct event_vec {
    ushort proc;                
    uchar slot;                 
    uchar priority;             
} event_vec_t;
 
typedef struct sark_vec {
    int_handler reset_vec;      
    int_handler undef_vec;      
    int_handler svc_vec;        
    int_handler pabt_vec;       
    int_handler dabt_vec;       
    int_handler aplx_proc;      
    int_handler irq_vec;        
    int_handler fiq_vec;        
 
    ushort svc_stack;           
    ushort irq_stack;           
    ushort fiq_stack;           
    ushort stack_size;          
 
    uint *code_top;             
    uint *heap_base;            
    uint *stack_top;            
 
    uint stack_fill;            
 
    uchar num_msgs;             
    uchar sark_slot;            
 
    uchar num_events;           
    uchar api;                  
    uchar app_id;               
    volatile uchar app_flags;   
    ushort __PAD;               
 
    event_vec_t event[EVENT_COUNT]; 
} sark_vec_t;
 
static sark_vec_t * const sark_vec = (sark_vec_t *) 0x20;
 
//------------------------------------------------------------------------------
 
typedef struct vcpu {           // 128 bytes
    uint r[8];                  
    uint psr;                   
    uint sp;                    
    uint lr;                    
    uchar rt_code;              
    uchar phys_cpu;             
    uchar cpu_state;            
    uchar app_id;               
    void *mbox_ap_msg;          
    void *mbox_mp_msg;          
    volatile uchar mbox_ap_cmd; 
    volatile uchar mbox_mp_cmd; 
    ushort sw_count;            
    char *sw_file;              
    uint sw_line;               
    uint time;                  
    char app_name[16];          
    void *iobuf;                
    uint sw_ver;                
    uint __PAD[4];              
    uint user0;                 
    uint user1;                 
    uint user2;                 
    uint user3;                 
} vcpu_t;
 
 
// For "sark_alib.s" (maintain sync with vcpu_t)
 
#define VCPU_SIZE       128     
#define VCPU_RT_CODE    44      
#define VCPU_CPU_STATE  46      
#define VCPU_APP_ID     47      
 
//------------------------------------------------------------------------------
 
// Events
 
#define SARK_MSG_INT    (INT0_INT)  
#define SARK_SIG_INT    (INT1_INT)  
 
typedef void (*event_proc) (uint, uint);
 
typedef struct event {          // 28 bytes
    struct event *next;         
 
    event_proc proc;            
    uint arg1;                  
    uint arg2;                  
    uint time;                  
    uint ID;                    
 
    uchar reuse;                
    uchar __PAD1;               
    uchar __PAD2;               
    uchar __PAD3;               
} event_t;
 
typedef struct proc_queue {
    event_t *proc_head;         
    event_t *proc_tail;         
} proc_queue_t;
 
typedef struct pkt {
    uint ctrl;                  
    uint data;                  
    uint key;                   
} pkt_t;
 
typedef struct event_data {
    event_t *free;              
    event_t *timer_queue;       
 
    ushort count;               
    ushort max;                 
    uint id;                    
 
    uint failed;                
    uint rc;                    
 
    volatile uchar state;       
    uchar id_rsvd;              
    uchar wait;                 
    uchar user;                 
 
    uint ticks;                 
    uint arg1;                  
    uint arg2;                  
 
    sdp_msg_t *msg;             
    uint signal;                
 
    event_proc pause_proc;      
    uint pause_arg2;            
 
    uint exit_rc;               
 
    uchar pkt_insert;           
    uchar pkt_remove;           
    volatile uchar pkt_count;   
    uchar __PAD2;               
    ushort pkt_size;            
    ushort pkt_max;             
    pkt_t *pkt_queue;           
 
    uint vic_select;            
    uint vic_enable;            
    uint old_select;            
    uint old_enable;            
 
    int_handler fiq_vector;     
    int_handler old_vector;     
 
    int_handler vic_addr[EVENT_COUNT]; 
 
    proc_queue_t proc_queue[PRIO_MAX + 1];
} event_data_t;
 
//------------------------------------------------------------------------------
 
typedef struct sark_data {
    uint virt_cpu;              
    uint phys_cpu;              
 
    uint random[2];             
 
    uint *stack_base;           
    uint *heap_base;            
    heap_t *heap;               
 
    vcpu_t *vcpu;               
 
    mem_block_t msg_root;       
 
    uint msg_rcvd;              
    uint msg_sent;              
 
    ushort cpu_clk;             
    uchar sw_rte;               
    uchar __PAD1;               
    void *sdram_buf;            
    uint pkt_count;             
} sark_data_t;
 
//
 
#define SARK_VIRT_CPU 0  
#define SARK_RANDOM   8  
#define SARK_CPU_CLK  48 
 
//------------------------------------------------------------------------------
 
 
#define SV_SSIZE        32          
#define SV_USIZE        96          
#define SV_ISIZE        128         
#define SV_VSIZE        32          
#define SV_RSIZE        64          
#define SV_SIZE         0x1000      
 
#define SV_SROM         (SYSRAM_TOP - SV_SSIZE)          
#define SV_UBASE        (SV_SROM - SV_USIZE)             
#define SV_IBASE        (SV_UBASE - SV_ISIZE)            
#define SV_SV           SV_IBASE                         
 
#define SYS_BOOT        256                              
#define SYS_USER_TOP    (SYSRAM_TOP - SV_SIZE)           
#define SYS_USER_BASE   (SYSRAM_BASE + SYS_BOOT)         
 
#define SV_VECTORS      (SV_IBASE - SV_VSIZE)            
#define SV_RANDOM       (SV_VECTORS - SV_RSIZE)          
 
#define SV_VCPU         SYS_USER_TOP                     
#define SV_SPARE        (SV_VCPU + NUM_CPUS * VCPU_SIZE) 
#define SPARE_SIZE      (SV_RANDOM - SV_SPARE)           
 
#define SROM_FLAG_BASE  (SV_SROM)                        
#define STATUS_MAP_BASE (SV_UBASE)                       
#define RST_BLOCK_BASE  (SV_VECTORS)                     
 
// Bits in srom_data->flags
 
#define SRF_PRESENT     0x8000          
#define SRF_HW_VER      0x00f0          
#define SRF_PHY_INIT    0x0008          
#define SRF_PHY_RST     0x0004          
#define SRF_PHY_WAIT    0x0002          
#define SRF_ETH         0x0001          
#define SRF_NONE        0x0000          
 
typedef struct sv {
    ushort p2p_addr;            
    ushort p2p_dims;            
 
    ushort dbg_addr;            
    uchar  p2p_up;              
    uchar  last_id;             
 
    ushort eth_addr;            
    uchar hw_ver;               
    uchar eth_up;               
 
    uchar p2pb_repeats;         
    uchar p2p_sql;              
    uchar clk_div;              
    uchar tp_scale;             
 
    volatile uint64 clock_ms;   
    volatile ushort time_ms;    
    ushort ltpc_period;         
 
    volatile uint unix_time;    
    uint tp_timer;              
 
    ushort cpu_clk;             
    ushort mem_clk;             
 
    uchar forward;              
    uchar retry;                
    uchar peek_time;            
    uchar led_period;           
 
    uchar netinit_bc_wait;      
    uchar netinit_phase;        
    ushort p2p_root;            
 
    uint led0;                  
    uint led1;                  
    int clock_drift;            
                                //      NOTE: This is a fixed point number!!!
    uint random;                
 
    uchar root_chip;            
    uchar num_buf;              
    uchar boot_delay;           
    uchar soft_wdog;            
 
    uint sync_alignment;        
 
    heap_t *sysram_heap;        
    heap_t *sdram_heap;         
 
    uint iobuf_size;            
    uint *sdram_bufs;           
    uint sysbuf_size;           
    uint boot_sig;              
 
    uint mem_ptr;               
 
    volatile uchar lock;        
    uchar link_en;              
    uchar last_biff_id;         
    uchar bt_flags;             
 
    mem_block_t shm_root;       
 
    uint utmp0;                 
    uint utmp1;                 
    uint utmp2;                 
    uint utmp3;                 
 
    uchar status_map[20];       
    uchar p2v_map[20];          
    uchar v2p_map[20];          
 
    uchar num_cpus;             
    uchar rom_cpus;             
    ushort board_addr;          
 
    uint *sdram_base;           
    uint *sysram_base;          
    uint *sdram_sys;            
    vcpu_t *vcpu_base;          
 
    heap_t *sys_heap;           
    rtr_entry_t *rtr_copy;      
    uint *hop_table;            
    block_t** alloc_tag;        
    ushort rtr_free;            
    ushort p2p_active;          
    app_data_t *app_data;       
    sdp_msg_t *shm_buf;         
    uint mbox_flags;            
 
    uchar ip_addr[4];           
    uint fr_copy;               
    uint *board_info;           
    uint sw_ver;                
} sv_t;
 
 
// Pointers to useful bits of system RAM
 
static sv_t*   const sv         = (sv_t *)   SV_SV;
 
 
static vcpu_t* const sv_vcpu    = (vcpu_t *) SV_VCPU;
 
static uint*   const sv_srom    = (uint *)   SV_SROM;
static uint*   const sv_random  = (uint *)   SV_RANDOM;
static uint*   const sv_vectors = (uint *)   SV_VECTORS;
 
static uint*   const sv_board_info = (uint *)   SV_SPARE;
 
//------------------------------------------------------------------------------
 
// Various bits of global data
 
extern sark_data_t sark;
 
extern event_data_t event;
 
extern uint build_date;
 
extern char build_name[];
 
//------------------------------------------------------------------------------
 
// Routines exported by SARK - sark_alib.s
 
uint cpu_irq_enable (void);
 
uint cpu_irq_disable (void);
 
uint cpu_fiq_enable (void);
 
uint cpu_fiq_disable (void);
 
uint cpu_int_enable (void);
 
uint cpu_int_disable(void);
 
void cpu_int_restore (uint cpsr);
 
uint *cpu_get_sp (void);
 
uint cpu_get_cpsr (void);
 
void cpu_set_cpsr (uint cpsr);
 
uint cpu_get_cp15_cr (void);
 
void cpu_set_cp15_cr(uint value);
 
void cpu_wfi (void);
 
NORETURN void
cpu_sleep(void);
 
NORETURN void
cpu_shutdown(void);
 
NORETURN void
rt_error(uint code, ...);
 
NONNULL void
sark_mem_cpy(void *dest, const void *src, uint n);
 
NONNULL void
sark_str_cpy(char *dest, const char *src);
 
NONNULL uint
sark_str_len (char *string);
 
void sark_cpu_state (cpu_state state);
 
NONNULL void sark_msg_cpy(sdp_msg_t *to, sdp_msg_t *from);
 
NONNULL void
sark_word_cpy(void *dest, const void *src, uint n);
 
NONNULL void
sark_word_set(void *dest, uint data, uint n);
 
uint sark_lock_get (spin_lock lock);
 
void sark_lock_free (uint cpsr, spin_lock lock);
 
NONNULL uint sark_sema_raise(uchar *sema);
 
NONNULL uint sark_sema_lower(uchar *sema);
 
uint sark_app_raise(void);
 
uint sark_app_lower(void);
 
uint sark_app_sema (void);
 
uint sark_app_cores (void);
 
uint sark_app_lead (void);
 
void sark_srand (uint seed);
 
uint sark_rand (void);
 
divmod_t sark_div10 (uint n);
 
uint sark_count_bits(uint word);
 
void sark_bx (uint addr);
 
void sark_aplx (uint *table, uint app_id);
 
uint *cpu_init_mode (uint *stack, uint mode, uint size);
 
uint chksum_64 (uint a, uint b);
 
uint chksum_32(uint a);
 
//------------------------------------------------------------------------------
 
// Routines exported by SARK - sark_base.c
 
uint sark_chip_id (void);
 
uint sark_core_id(void);
 
uint sark_app_id(void);
 
static inline char *sark_app_name(void)
{
    return build_name;
}
 
sdp_msg_t *sark_msg_get (void);
 
void sark_msg_free (sdp_msg_t *msg);
 
NONNULL uint
sark_msg_send(sdp_msg_t *msg, uint timeout);
 
void sark_delay_us (uint delay);
 
void sw_error_fl (sw_err_mode mode, char *file, uint line);
 
# define sw_error(mode) sw_error_fl (mode, __FILE__, __LINE__)
 
uint sark_cmd_ver (sdp_msg_t *msg);
 
uint sark_cmd_read(sdp_msg_t *msg);
 
uint sark_cmd_write (sdp_msg_t *msg);
 
uint sark_cmd_fill(sdp_msg_t *msg);
 
void *sark_block_init(void *buf, uint size, uint count);
 
void *sark_block_get (mem_block_t *root);
 
void sark_block_free(mem_block_t *root, void *blk);
 
sdp_msg_t *sark_shmsg_get(void);
 
NONNULL void
sark_shmsg_free(sdp_msg_t *msg);
 
void sark_call_cpp_constructors(void);
 
 
//------------------------------------------------------------------------------
 
// Routines exported by SARK - sark_io.c
 
NONNULL2 void
io_printf(char *stream, char *format, ...);
 
void io_put_char(char *stream, uint c);
 
void sark_io_buf_reset (void);
 
//------------------------------------------------------------------------------
 
// Routines exported by SARK - sark_alloc.c
 
#ifndef DOXYGEN
SARK_IS_A_CALLOC(1, 2)
#endif
void *
sark_alloc(uint count, uint size);
 
NONNULL void
sark_free(void *ptr);
 
SARK_IS_A_MALLOC(2) void *
sark_xalloc(heap_t *heap, uint size, uint tag, uint flag);
 
NONNULL2 void
sark_xfree(heap_t *heap, void *ptr, uint flag);
 
uint sark_xfree_id(heap_t *heap, uint app_id, uint flag);
 
uint sark_heap_max(heap_t *heap, uint flag);
 
heap_t *sark_heap_init(uint *base, uint *top);
 
uint rtr_alloc(uint size);
 
uint rtr_alloc_id(uint size, uint app_id);
 
void rtr_free(uint entry, uint clear);
 
uint rtr_free_id(uint app_id, uint clear);
 
uint rtr_alloc_max(void);
 
void *sark_tag_ptr(uint tag, uint app_id);
 
//------------------------------------------------------------------------------
 
// Routines exported by SARK - sark_hw.c
 
void sark_vic_init (void);
 
NONNULL void
sark_vic_set(vic_slot slot, uint interrupt, uint enable, int_handler handler);
 
void sark_led_init (void);
 
void sark_led_set (uint leds);
 
uint rtr_mc_clear (uint start, uint count);
 
void rtr_mc_init (uint start);
 
NONNULL uint
rtr_mc_load(rtr_entry_t *e, uint count, uint offset, uint app_id);
 
uint rtr_mc_set (uint entry, uint key, uint mask, uint route);
 
NONNULL uint rtr_mc_get(uint entry, rtr_entry_t *r);
 
void rtr_fr_set (uint route);
 
uint rtr_fr_get(void);
 
void rtr_p2p_init (void);
 
void rtr_p2p_set(uint entry, uint value);
 
uint rtr_p2p_get(uint entry);
 
NONNULL void
rtr_diag_init(const uint *table);
 
void rtr_init (uint monitor);
 
uint v2p_mask (uint virt_mask);
 
uint pl340_init (uint mem_clk);
 
//------------------------------------------------------------------------------
 
// Routines exported by SARK - sark_event.c
 
uint event_alloc (uint events);
 
NONNULL
void event_free(event_t *e);
 
NONNULL event_t *
event_new(event_proc proc, uint arg1, uint arg2);
 
void event_config(event_t* event, event_proc proc, uint arg1, uint arg2);
 
uint pkt_tx_k (uint key);
//
uint pkt_tx_kd (uint key, uint data);
 
uint pkt_tx_kc (uint key, uint ctrl);
 
uint pkt_tx_kdc (uint key, uint data, uint ctrl);
 
uint event_start (uint period, uint events, sync_bool wait);
 
void event_pause (uint pause);
 
void event_stop (uint rc);
 
void event_wait (void);
 
NONNULL uint
event_queue(event_t *e, event_priority priority);
 
NONNULL uint
event_queue_proc(event_proc proc, uint arg1, uint arg2, event_priority priority);
 
void event_run(uint restart);
 
NONNULL void
event_register_int(event_proc proc, event_type event, vic_slot slot);
 
NONNULL void
event_register_queue(event_proc proc, event_type event, vic_slot slot,
    event_priority priority);
 
NONNULL void
event_register_pause(event_proc proc, uint arg2);
 
void event_enable (event_type event_num, uint enable);
 
void event_register_timer (vic_slot slot);
 
void event_register_pkt(uint queue_size, vic_slot slot);
 
uint event_user (uint arg1, uint arg2);
 
//------------------------------------------------------------------------------
 
// Routines exported by SARK - sark_timer.c
 
NONNULL void
timer_schedule(event_t *e, uint time);
 
NONNULL uint
timer_schedule_proc(event_proc proc, uint arg1, uint arg2, uint time);
 
NONNULL void timer_cancel(event_t *e, uint ID);
 
void timer_cancel_init(void);
 
 
//------------------------------------------------------------------------------
 
#endif