scamp.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 SCAMP_H
#define SCAMP_H
 
//------------------------------------------------------------------------------
 
#define MAX_CPUS                20                      
 
#define MONITOR_CPU             0                       
//------------------------------------------------------------------------------
 
 
#define SCAMP_MC_ROUTING_KEY    0xffff5554
 
#define SCAMP_MC_ROUTING_MASK   0xfffffffe
 
// The meaning of the individual keys - an enum might be better but doesn't
// work because the 'enumeration value is out of "signed int" range'
 
#define SCAMP_MC_TIME_SYNC_KEY 0xffff5554
 
#define SCAMP_MC_SIGNAL_KEY 0xffff5555
 
#define MC_SLOT SLOT_FIQ
//------------------------------------------------------------------------------
 
 
// These settings handle a boot image of size BLOCK_COUNT * BYTE_COUNT bytes
// Image sizes < 32kB are possible.
// BLOCK_COUNT * BYTE_COUNT must be < 32kB
 
#define BLOCK_COUNT     32      // From 1-32
#define WORD_COUNT      256     // From 1-256
#define BYTE_COUNT      (WORD_COUNT * sizeof(uint))
#define BOOT_IMAGE_SIZE (BLOCK_COUNT * BYTE_COUNT)
//------------------------------------------------------------------------------
 
// IPTag table sizes
 
#define TAG_FIXED_SIZE          8       // At bottom of table
#define TAG_POOL_SIZE           8
 
#define FIRST_POOL_TAG          TAG_FIXED_SIZE
#define LAST_POOL_TAG           (TAG_FIXED_SIZE + TAG_POOL_SIZE - 1)
 
#define TAG_TABLE_SIZE          (TAG_FIXED_SIZE + TAG_POOL_SIZE)
 
// IPTAG definitions
enum scamp_iptag_commands {
    IPTAG_NEW = 0,              
    IPTAG_SET = 1,              
    IPTAG_GET = 2,              
    IPTAG_CLR = 3,              
    IPTAG_TTO = 4,              
 
    IPTAG_MAX = 4               
};
 
enum scamp_iptag_flags {
    IPFLAG_VALID =      0x8000, 
    IPFLAG_TRANS =      0x4000, 
    IPFLAG_ARP =        0x2000, 
 
    IPFLAG_USE_SENDER = 0x0400, 
    IPFLAG_REV =        0x0200, 
    IPFLAG_STRIP =      0x0100  
};
 
//------------------------------------------------------------------------------
 
 
enum scamp_sdp_flags {
    SDPF_REPLY =        0x80,   
    SDPF_SUM =          0x40,   
    SDPF_NR =           0x20    
};
 
//------------------------------------------------------------------------------
 
 
enum scamp_failure_codes {
    FAIL_RESET =        0xc0,   
    FAIL_ROMX =         0xc1,   
    FAIL_ITCM0 =        0xc2,   
    FAIL_ITCM1 =        0xc3,   
    FAIL_DTCM =         0xc4,   
 
    FAIL_TIMER =        0xc5,   
    FAIL_VIC =          0xc6,   
    FAIL_CC =           0xc7,   
    FAIL_DMA =          0xc8,   
 
    FAIL_MP =           0xc9,   
    FAIL_LATE =         0xca,   
    FAIL_MANUF =        0xcb,   
    FAIL_SLEEP =        0xcc,   
 
    FAIL_TLM =          0xcf,   
 
    FAIL_VEC =          0xa0,   
};
 
//------------------------------------------------------------------------------
 
 
enum scamp_nn_opcodes {
    NN_CMD_SIG0 =  0,  
    NN_CMD_RTRC =  1,  
    NN_CMD_LTPC =  2,  
    NN_CMD_SP_3 =  3,  
 
    NN_CMD_SIG1 =  4,  
    NN_CMD_P2PC =  5,  
    NN_CMD_FFS =   6,  
    NN_CMD_FFCS =  7,  
 
    NN_CMD_P2PB =  8,  
    NN_CMD_LKSYN = 9,  
    NN_CMD_NISYN = 10, 
    NN_CMD_BIFF =  11, 
 
    NN_CMD_FBS =   12, 
    NN_CMD_FBD =   13,
    NN_CMD_FBE =   14,
    NN_CMD_FFE =   15
};
enum scamp_nn_p2p_config_subcommands {
    P2PC_ADDR = 0, 
    P2PC_NEW = 1,  
    P2PC_DIMS = 2, 
    P2PC_RETH = 3  
};
 
//------------------------------------------------------------------------------
 
 
enum scamp_p2p_type_codes {
    P2P_DATA =  0,      
    P2P_CTRL =  1,      
    P2P_LEVEL = 2       
};
 
enum scamp_p2p_control_message_codes {
    P2P_OPEN_REQ =      (1 << 24),      
    P2P_OPEN_ACK =      (2 << 24),      
    P2P_DATA_ACK =      (3 << 24),      
    P2P_CLOSE_REQ =     (4 << 24),      
    P2P_CLOSE_ACK =     (5 << 24),      
    P2P_PING =          (6 << 24),      
    P2P_COUNT_REQ =     (7 << 24),      
    P2P_COUNT_RESP =    (8 << 24)       
};
 
#define P2P_DEF_SQL     4               
 
//------------------------------------------------------------------------------
#define NO_IDEA                 (-1024)
 
#define P2P_ADDR_TABLE_BYTES    (512 * 512 / 8)
 
#define P2PB_OFFSET_USEC 100
 
 
//------------------------------------------------------------------------------
 
 
#define NODE_DLY_NS             500     
#define BRD_DLY_NS              900     
#define TOP_DLY_US              155     
 
 
//------------------------------------------------------------------------------
 
 
#define NN_HOP_MASK     0x3ff           
 
#define HOP_TABLE_SIZE  65536           
 
//------------------------------------------------------------------------------
 
 
enum netinit_phase_e {
    NETINIT_PHASE_P2P_ADDR,
    NETINIT_PHASE_P2P_DIMS,
    NETINIT_PHASE_BIFF,
    NETINIT_PHASE_P2P_TABLE_ETH,
    NETINIT_PHASE_P2P_TABLE_R_ETH,
    NETINIT_PHASE_P2P_TABLE,
    NETINIT_PHASE_SET_ETHERNET_ADDR,
    NETINIT_PHASE_DEL,
    NETINIT_PHASE_DONE = 0xFF,
};
 
enum ethinit_phase_e {
    ETHINIT_PHASE_WAIT_1,
    ETHINIT_PHASE_WAIT_2,
    ETHINIT_PHASE_DONE = 0xFF,
};
 
//------------------------------------------------------------------------------
 
enum alloc_cmd_e {
    ALLOC_SDRAM,                
    FREE_SDRAM,                 
    FREE_SDRAM_ID,              
    ALLOC_RTR,                  
    FREE_RTR,                   
    FREE_RTR_ID,                
    SDRAM_SPACE,                
    HEAP_TAG_PTR,               
    ALLOC_MAX=HEAP_TAG_PTR      
};
 
//------------------------------------------------------------------------------
 
 
typedef struct {
    uchar ip[4];                
    uchar mac[6];               
    ushort tx_port;             
    ushort timeout;             
    ushort flags;               
    uint count;                 
    ushort rx_port;             
    ushort dest_addr;           
    uchar dest_port;            
    uchar __PAD1[7];
} iptag_t;
 
#define PKT_QUEUE_SIZE          32
 
typedef struct pkt_queue_t {
    uchar insert;               
    uchar remove;               
    volatile uchar count;
    uchar max;
    pkt_t queue[PKT_QUEUE_SIZE];
} pkt_queue_t;
 
typedef struct pkt_buf_t {
    struct pkt_buf_t *next;     
    volatile uchar flags;       
    uchar fwd;                  
    uchar delay;                
    uchar link;                 
    pkt_t pkt;                  
} pkt_buf_t;
 
typedef struct {        // 64 bytes
    uint   level_addr;  
    ushort sent;        
    ushort rcvd;        
    ushort parent;      
    ushort __PAD1;
    uint result;        
    ushort addr[16];    
    uchar  valid[16];   
} level_t;
 
//------------------------------------------------------------------------------
 
 
extern uint pkt_tx(uint tcr, uint data, uint key);
extern uint pkt_tx_wait(uint tcr, uint data, uint key);
extern void proc_byte_set(uint a1, uint a2);
extern void proc_word_set(uint a1, uint a2);
extern void msg_queue_insert(sdp_msg_t *msg, uint srce_ip);
extern uint iptag_new(void);
extern void assign_virt_cpu(uint phys_cpu);
extern void remap_phys_cores(uint phys_cores);
extern void delegate(void);
 
 
extern void compute_eth(void);
extern void compute_level(uint p2p_addr);
extern void ff_nn_send(uint key, uint data, uint fwd_rty, uint log);
extern void biff_nn_send(uint data);
extern void nn_cmd_biff(uint x, uint y, uint data);
extern void nn_mark(uint key);
extern uint link_read_word(uint addr, uint link, uint *buf, uint timeout);
extern uint link_write_word(uint addr, uint link, uint *buf, uint timeout);
extern uint next_id(void);
extern void nn_init(void);
extern void proc_ffe(uint aplx_addr, uint cpu_mask);
 
 
extern uint cmd_srom(sdp_msg_t *msg);
 
 
extern void vic_setup(void);
 
 
extern void img_cp_exe(void);
 
 
extern void proc_start_app(uint aplx_addr, uint id_op_mask);
extern void signal_app(uint data);
extern void boot_ap(void);
extern void clock_ap(uint virt_mask, uint enable);
extern void reset_ap(uint virt_mask);
 
 
extern uint p2p_send_msg(uint addr, sdp_msg_t *msg);
extern void desc_init(void);
extern uint p2p_send_ping(uint addr, uint link);
extern void p2p_req_count(uint addr, uint app_id, uint state);
 
 
extern void p2pc_addr_nn_send(uint arg1, uint arg2);
extern void p2pc_dims_nn_send(uint arg1, uint arg2);
extern void p2pb_nn_send(uint arg1, uint arg2);
 
 
extern uint scamp_debug(sdp_msg_t *msg, uint srce_ip);
 
 
extern void boot_nn(uint hw_ver);
 
 
//------------------------------------------------------------------------------
 
extern srom_data_t srom;
 
extern uint link_en;
extern uint num_cpus;
 
extern iptag_t tag_table[];
extern uint tag_tto;
 
extern uchar v2p_map[MAX_CPUS];
 
extern volatile enum netinit_phase_e netinit_phase;
extern volatile enum ethinit_phase_e ethinit_phase;
 
extern uint mon_del;
 
extern uint* hop_table;
 
extern uchar core_app[MAX_CPUS];
extern uint app_mask[256];
 
extern uint p2p_addr;
extern uint p2p_dims;
extern uint p2p_root;
extern uint p2p_up;
 
extern volatile uint ticks_since_last_p2pc_new;
extern volatile uint ticks_since_last_p2pc_dims;
extern volatile int p2p_addr_guess_x;
extern volatile int p2p_addr_guess_y;
extern volatile int p2p_min_x;
extern volatile int p2p_max_x;
extern volatile int p2p_min_y;
extern volatile int p2p_max_y;
extern uchar *p2p_addr_table;
 
//------------------------------------------------------------------------------
 
#endif