ge.h

Go to the documentation of this file.

#ifndef GE_H
#define GE_H
 
#include <stdint.h>
#include <stddef.h>
#include "opcodes.h"
#include "console.h"
#include "reader.h"
#include "channel.h"
 
#define CLOCK_PERIOD 14000 /* in usec, interval between pulse lines */
#define MEM_SIZE 65536
 
#define ENUMERATE_CLOCKS \
    X(TO00) \
    X(TO10) \
    X(TO11) \
    X(TO15) \
    X(TO19) \
    X(TO20) \
    X(TO25) \
    X(TO30) \
    X(TO40) \
    X(TO50) \
    X(TO50_1) \
    X(TO60) \
    X(TO64) \
    X(TO65) \
    X(TO70) \
    X(TO80) \
    X(TO89) \
    X(TO90) \
    X(TI05) \
    X(TI06) \
    X(TI10) \
    X(END_OF_STATUS)
 
enum clock {
    #define X(name) name ,
    ENUMERATE_CLOCKS
    #undef X
};
 
struct ge_counting_network {
    struct cmds {
        uint8_t from_zero:1;
        uint8_t decresing:1;
    } cmds;
};
 
struct ge_knot_no {
    uint8_t forcings;
 
    enum {
        KNOT_FORCING_NONE,
        KNOT_FORCING_NO_21,
        KNOT_FORCING_NO_43,
    } force_mode;
 
    enum {
        KNOT_PO_IN_NO,
        KNOT_V1_IN_NO,
        KNOT_V2_IN_NO,
        KNOT_V3_IN_NO,
        KNOT_V4_IN_NO,
        KNOT_L1_IN_NO,
        KNOT_L2_IN_NO,
        KNOT_L3_IN_NO,
        KNOT_AM_IN_NO,
        KNOT_RI_IN_NO_43,
    } cmd;
};
 
enum knot_ni_source {
    NS_CN1,
    NS_CN2,
    NS_CN3,
    NS_CN4,
    NS_RO1,
    NS_RO2,
    NS_UA2,
    NS_UA1,
};
 
struct ge_knot_ni {
    enum knot_ni_source ni1;
    enum knot_ni_source ni2;
    enum knot_ni_source ni3;
    enum knot_ni_source ni4;
};
 
struct ge {
    /* Main clock */
    enum clock current_clock;
    uint8_t halted;
    uint8_t powered;
 
    /* Lists of events and operations for all
     * pulses
     */
    struct pulse_event *on_pulse[END_OF_STATUS];
 
    uint16_t rPO;
 
    uint16_t instr_pc;
 
    uint16_t rV1; 
    uint16_t rV2; 
    uint16_t rV3; 
    uint16_t rV4; 
 
    uint16_t cr_cache[8];
 
    uint8_t rRI;
 
    uint16_t rL1;
    uint8_t  rL2; 
    uint16_t rL3; 
 
    struct ge_knot_no kNO;
 
    struct ge_knot_ni kNI;
 
    uint16_t rRO;
 
    uint16_t rVO;
 
    uint16_t rBO;
 
    uint8_t rFO;
 
    uint8_t rSO;
 
    uint8_t rSI;
 
    uint8_t rSA;
 
    uint8_t rRE;
    uint8_t rRA;
 
    uint8_t ffFI;
 
    uint8_t ffFA;
 
    /* Those two store which work channel the present cycle as been attributed to
     * (cpu fo. 130).
     * When setting RETO, if PAPA switch is set, rotary is neither in normal, nor
     * in position 8 to store in memory, should set ALTO */
    uint8_t RETO:1;
    uint8_t RET2:1;
 
    uint8_t AINI:1;
 
    uint8_t ALOI:1;
 
    uint8_t ALTO:1;
 
    uint8_t PODI:1;
 
    uint8_t ACIC:1;
 
    uint8_t ALAM:1;
 
    uint8_t AVER:1;
 
    uint8_t SA00:1;
 
    uint8_t ADIR:1;
 
    uint8_t RINT:1;
 
    uint8_t JS1:1;  
    uint8_t JS2:1;  
    uint8_t JE:1;   
    uint8_t INTE:1; 
 
    /* Busy Connector Logic */
 
    uint8_t PB06:1; 
    uint8_t PB07:1; 
    uint8_t PB26:1; 
    uint8_t PB36:1;
    uint8_t PB37:1;
 
    uint8_t PIC1:1;
 
    uint8_t RASI:1;
 
    uint8_t PUC2:1;
 
    uint8_t PUC3:1;
 
    uint8_t PEC1:1;
    uint8_t PEC1_pending:1;
 
    uint8_t RUF1:1;
 
    uint8_t URPE:1;
    uint8_t URPU:1;
 
    /* Cycle Attribution Logic */
    /* ----------------------- */
 
    /* Asyncronous flip flops */
 
    uint8_t RC00:1;
 
    uint8_t RC01:1;
 
    uint8_t RC02:1;
 
    uint8_t RC03:1;
 
    uint8_t RIA0:1;
 
    uint8_t RESI:1;
 
    uint8_t RIA2:1;
 
    uint8_t RIA3:1;
 
    uint8_t RECE:1;
 
    uint8_t RIG1:1;
 
    uint8_t RIG3:1;
 
    uint8_t RACI:1;
 
    uint8_t RAVI:1;
 
    uint8_t RT121:1;
    uint8_t RT131:1;
 
    uint8_t future_state;
 
    enum ge_console_rotary register_selector;
 
    struct ge_console_switches console_switches;
 
    uint8_t step_by_step:1;  
 
    enum {
        MC_NONE,
        MC_READ,
        MC_WRITE,
    } memory_command;
 
    uint8_t mem[MEM_SIZE]; 
 
    uint8_t mem_parity[MEM_SIZE];
 
    uint8_t mem_written[MEM_SIZE];
 
    uint32_t mem_size;
 
    uint8_t mem_check;
 
    uint8_t inv_add;
 
    uint8_t inject_chan1_status;
 
    struct ge_counting_network counting_network;
 
    struct ge_integrated_reader integrated_reader;
 
    struct ge_integrated_printer {
        int      present;
        char     out[65536];    /* captured printed chars; per-frame staging only
                                 * (the wasm console drains+clears each frame, the
                                 * CLI reads it at end). Sized for a catch-up
                                 * frame's burst so fast/backgrounded printing
                                 * doesn't overflow before the drain. */
        int      out_len;
        uint8_t  kbd[256];      /* operator keyboard input queue */
        int      kbd_head, kbd_tail;
        /* Channel-2 OUTPUT transfer engine (printer.c): while out_active, the
         * printer requests a channel-2 cycle (RC02) per character so the rSI
         * output state (0x02) drains out_remaining bytes from V4, then ends.
         * out_saved_so preserves the CPU sequencer across the (overlapped)
         * transfer — fsn advances SO on RIA0, which the stolen channel-2 cycles
         * would otherwise clobber; we restore it when the transfer ends. */
        int      out_active;
        int      out_remaining;
        int      out_total;
        int      out_line_mode;
        uint8_t  out_saved_so;
    } integrated_printer;
 
    struct ge_connector ST3;
 
    struct ge_connector ST4;
 
    struct ge_channel channel2;
 
    struct ge_peri *peri;
 
    void *std_core;
 
    uint8_t TO50_did_CI32_or_CI33:1;
};
 
void ge_init(struct ge *ge);
 
int ge_deinit(struct ge *ge);
 
int ge_load_program(struct ge *ge, uint8_t *program, uint8_t size);
 
int ge_load_image(struct ge *ge, const uint8_t *image, size_t size,
                  uint16_t origin);
 
void ge_enter(struct ge *ge, uint16_t entry);
 
void ge_mem_store8(struct ge *ge, uint16_t addr, uint8_t val);
 
void ge_seed_segment_bases(struct ge *ge);
 
int ge_run(struct ge *ge);
 
int ge_run_pulse(struct ge *ge);
 
int ge_run_cycle(struct ge *ge);
 
void ge_clear(struct ge * ge);
 
void ge_load(struct ge * ge);
 
void ge_load_1(struct ge * ge);
 
void ge_load_2(struct ge * ge);
 
void ge_start(struct ge * ge);
 
typedef void (*on_pulse_cb)(struct ge *);
 
struct pulse_event {
    on_pulse_cb cb;
    struct pulse_event *next;
};
 
/* Defined in pulse.c: execute pulse events */
void pulse(struct ge *ge);
 
struct ge_peri {
    struct ge_peri *next;
    int (*init)(struct ge*, void*);
    int (*on_pulse)(struct ge*, void*);
    int (*on_clock)(struct ge*, void*);
    int (*deinit)(struct ge*, void*);
    void *ctx;
};
 
int ge_register_peri(struct ge *ge, struct ge_peri *p);
 
void fsn_last_clock(struct ge *ge);
 
void connectors_first_clock(struct ge *ge);
 
const char *ge_clock_name(enum clock c);
 
void ge_print_registers_verbose(struct ge *ge);
 
#endif /* GE_H */