h2.h

#ifndef H2_H
#define H2_H

#include <stddef.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>

/**@note STK_SIZE is fixed to 64, but h2.vhd allows for the instantiation of
 * CPUs with different stack sizes, within reasonable limits, so long as they
 * are a power of 2. */

#define MAX_CORE             (8192u)
#define STK_SIZE             (64u)
#define START_ADDR           (0u)

#ifndef H2_CPU_ID_SIMULATION
#ifdef NO_MAIN
#define H2_CPU_ID_SIMULATION (0xD1ED)
#else
#define H2_CPU_ID_SIMULATION (0xDEADu)
#endif
#endif

#define H2_CPU_ID_VHDL       (0xCAFEu)

#define VGA_INIT_FILE        ("text.hex")  /**< default name for VGA screen */
#define FLASH_INIT_FILE      ("nvram.blk") /**< default file for flash initialization */

typedef struct {
	size_t length;
	uint16_t *points;
} break_point_t;

typedef struct {
	uint16_t core[MAX_CORE]; /**< main memory */
	uint16_t rstk[STK_SIZE]; /**< return stack */
	uint16_t dstk[STK_SIZE]; /**< variable stack */
	uint16_t pc;  /**< program counter */
	uint16_t tos; /**< top of stack */
	uint16_t rp;  /**< return stack pointer */
	uint16_t sp;  /**< variable stack pointer */
	bool     ie;  /**< interrupt enable */
	unsigned time; /**< cycles run for */

	break_point_t bp; /**< list of break points */
	uint16_t rpm; /**< maximum value of rp ever encountered */
	uint16_t spm; /**< maximum value of sp ever encountered */
} h2_t; /**< state of the H2 CPU */

typedef enum {
	SYMBOL_TYPE_LABEL,
	SYMBOL_TYPE_CALL,
	SYMBOL_TYPE_CONSTANT,
	SYMBOL_TYPE_VARIABLE,
} symbol_type_e;

typedef struct {
	symbol_type_e type;
	char *id;
	uint16_t value;
	bool hidden;
	bool used;
} symbol_t;

typedef struct {
	size_t length;
	symbol_t **symbols;
} symbol_table_t;

#define CLOCK_SPEED_HZ             (100000000ULL)

#define VGA_BUFFER_LENGTH          (1 << 13)
#define VGA_WIDTH                  (80)
#define VGA_HEIGHT                 (40)
#define VGA_AREA                   (VGA_WIDTH * VGA_HEIGHT)

#define VGA_CTL_B_BIT              (0)
#define VGA_CTL_G_BIT              (1)
#define VGA_CTL_R_BIT              (2)
#define VGA_CUR_MODE_BIT           (3)
#define VGA_CUR_BLINK_BIT          (4)
#define VGA_CUR_EN_BIT             (5)
#define VGA_EN_BIT                 (6)
#define VGA_SCREEN_SELECT_BIT      (7)

#define VGA_CTL_B                  (1 << VGA_CTL_B_BIT)
#define VGA_CTL_G                  (1 << VGA_CTL_G_BIT)
#define VGA_CTL_R                  (1 << VGA_CTL_R_BIT)
#define VGA_CUR_MODE               (1 << VGA_CUR_MODE_BIT)
#define VGA_CUR_BLINK              (1 << VGA_CUR_BLINK_BIT)
#define VGA_CUR_EN                 (1 << VGA_CUR_EN_BIT)
#define VGA_EN                     (1 << VGA_EN_BIT)
#define VGA_SCREEN_SELECT          (1 << VGA_SCREEN_SELECT_BIT)

#define TIMER_ENABLE_BIT           (15)
#define TIMER_RESET_BIT            (14)
#define TIMER_INTERRUPT_ENABLE_BIT (13)
#define TIMER_ENABLE               (1 << TIMER_ENABLE_BIT)
#define TIMER_RESET                (1 << TIMER_RESET_BIT)
#define TIMER_INTERRUPT_ENABLE     (1 << TIMER_INTERRUPT_ENABLE_BIT)

#define UART_FIFO_DEPTH            (8)
#define UART_BAUD_RATE             (115200)

#define UART_RX_FIFO_EMPTY_BIT     (8)
#define UART_RX_FIFO_FULL_BIT      (9)
#define UART_RX_RE_BIT             (10)
#define UART_TX_FIFO_EMPTY_BIT     (11)
#define UART_TX_FIFO_FULL_BIT      (12)
#define UART_TX_WE_BIT             (13)

#define UART_RX_FIFO_EMPTY         (1 << UART_RX_FIFO_EMPTY_BIT)
#define UART_RX_FIFO_FULL          (1 << UART_RX_FIFO_FULL_BIT)
#define UART_RX_RE                 (1 << UART_RX_RE_BIT)
#define UART_TX_FIFO_EMPTY         (1 << UART_TX_FIFO_EMPTY_BIT)
#define UART_TX_FIFO_FULL          (1 << UART_TX_FIFO_FULL_BIT)
#define UART_TX_WE                 (1 << UART_TX_WE_BIT)

#define PS2_NEW_CHAR_BIT           (8)
#define PS2_NEW_CHAR               (1 << PS2_NEW_CHAR_BIT)

#define CHIP_MEMORY_SIZE           (8*1024*1024) /*NB. size in WORDs not bytes! */
#define FLASH_MASK_ADDR_UPPER_MASK (0x1ff)

#define FLASH_CHIP_SELECT_BIT      (10)
#define SRAM_CHIP_SELECT_BIT       (11)
#define FLASH_MEMORY_WAIT_BIT      (12)
#define FLASH_MEMORY_RESET_BIT     (13)
#define FLASH_MEMORY_OE_BIT        (14)
#define FLASH_MEMORY_WE_BIT        (15)

#define FLASH_CHIP_SELECT          (1 << FLASH_CHIP_SELECT_BIT)
#define SRAM_CHIP_SELECT           (1 << SRAM_CHIP_SELECT_BIT)
#define FLASH_MEMORY_WAIT          (1 << FLASH_MEMORY_WAIT_BIT)
#define FLASH_MEMORY_RESET         (1 << FLASH_MEMORY_RESET_BIT)
#define FLASH_MEMORY_OE            (1 << FLASH_MEMORY_OE_BIT)
#define FLASH_MEMORY_WE            (1 << FLASH_MEMORY_WE_BIT)

#define FLASH_BLOCK_MAX            (130)

typedef enum {
	FLASH_UNLOCKED,
	FLASH_LOCKED,
	FLASH_LOCKED_DOWN,
} flash_lock_t;

typedef struct {
	unsigned cycle;
	unsigned mode;
	unsigned we;
	unsigned cs;
	uint8_t  status;
	uint32_t arg1_address, arg2_address;
	uint16_t data;
	uint16_t nvram[CHIP_MEMORY_SIZE];
	uint8_t  locks[FLASH_BLOCK_MAX];
} flash_t;

typedef enum { /**@warning do not change the order or insert elements */
	BLACK,
	RED,
	GREEN,
	YELLOW,
	BLUE,
	MAGENTA,
	CYAN,
	WHITE,
} color_t;

typedef enum {
	TERMINAL_NORMAL_MODE,
	TERMINAL_CSI,
	TERMINAL_COMMAND,
	TERMINAL_NUMBER_1,
	TERMINAL_NUMBER_2,
	TERMINAL_DECTCEM,
	TERMINAL_STATE_END,
} terminal_state_t;

typedef struct {
	unsigned bold:          1;
	unsigned under_score:   1;
	unsigned blink:         1;
	unsigned reverse_video: 1;
	unsigned conceal:       1;
	unsigned foreground_color: 3;
	unsigned background_color: 3;
} vt100_attribute_t;

#define VT100_MAX_SIZE (8192)

typedef struct {
	size_t cursor;
	size_t cursor_saved;
	unsigned n1, n2;
	unsigned height;
	unsigned width;
	unsigned size;
	terminal_state_t state;
	bool blinks;
	bool cursor_on;
	vt100_attribute_t attribute, attribute_saved;
	vt100_attribute_t attributes[VT100_MAX_SIZE];
	uint8_t m[VT100_MAX_SIZE];
	uint8_t command_index;
} vt100_t;

typedef struct {
	uint8_t leds;
	vt100_t vt100;

	uint16_t timer_control;
	uint16_t timer;

	uint16_t irc_mask;

	uint8_t uart_getchar_register, ps2_getchar_register;

	uint16_t led_7_segments;

	uint16_t switches;
	uint16_t switches_previous;

	uint16_t vram[CHIP_MEMORY_SIZE];
	uint16_t mem_control;
	uint16_t mem_addr_low;
	uint16_t mem_dout;
	flash_t flash;

	bool wait;
	bool interrupt;
	uint8_t interrupt_selector;

	uint16_t uart_tx_baud, uart_rx_baud, uart_control;
} h2_soc_state_t;

typedef uint16_t (*h2_io_get)(h2_soc_state_t *soc, uint16_t addr, bool *debug_on);
typedef void     (*h2_io_set)(h2_soc_state_t *soc, uint16_t addr, uint16_t value, bool *debug_on);
typedef void     (*h2_io_update)(h2_soc_state_t *soc);

typedef struct {
	h2_io_get in;
	h2_io_set out;
	h2_io_update update;
	h2_soc_state_t *soc;
} h2_io_t;

typedef enum {
	iUart         = 0x4000,
	iVT100        = 0x4002,
	iTimerDin     = 0x4004,
	iSwitches     = 0x4006,
	iMemDin       = 0x4008,
} h2_input_addr_t;

typedef enum {
	oUart         = 0x4000,
	oVT100        = 0x4002,
	oTimerCtrl    = 0x4004,
	oLeds         = 0x4006,
	oMemDout      = 0x4008,
	oMemControl   = 0x400A,
	oMemAddrLow   = 0x400C,
	o7SegLED      = 0x400E,
	oIrcMask      = 0x4010,
	oUartTxBaud   = 0x4012,
	oUartRxBaud   = 0x4014,
	oUartControl  = 0x4016,
} h2_output_addr_t;

typedef enum {
	isrEntry,
	isrRxFifoNotEmpty,
	isrRxFifoFull,
	isrTxFifoNotEmpty,
	isrTxFifoFull,
	isrKbdNew,
	isrTimer,
	isrDPadButton,
} h2_interrupt_address_t;

void *allocate_or_die(size_t length);
FILE *fopen_or_die(const char *file, const char *mode);

h2_t *h2_new(uint16_t start_address);
void h2_free(h2_t *h);
int h2_load(h2_t *h, FILE *hexfile);
int h2_save(const h2_t *h, FILE *output, bool full);
int h2_run(h2_t *h, h2_io_t *io, FILE *output, unsigned steps, symbol_table_t *symbols, bool run_debugger, FILE *trace);

uint16_t h2_io_memory_read_operation(const h2_soc_state_t *soc);
void soc_print(FILE *out, const h2_soc_state_t *soc);
h2_soc_state_t *h2_soc_state_new(void);
void h2_soc_state_free(h2_soc_state_t *soc);
h2_io_t *h2_io_new(void);
void h2_io_free(h2_io_t *io);

int binary_memory_save(FILE *output, const uint16_t *p, size_t length);
int binary_memory_load(FILE *input, uint16_t *p, size_t length);
int nvram_save(h2_io_t *io, const char *name);
int nvram_load_and_transfer(h2_io_t *io, const char *name, bool transfer_to_sram);

typedef uint8_t fifo_data_t;

typedef struct {
	size_t head;
	size_t tail;
	size_t size;
	fifo_data_t *buffer;
} fifo_t;

fifo_t *fifo_new(size_t size);
void fifo_free(fifo_t *fifo);
bool fifo_is_full(const fifo_t * fifo);
bool fifo_is_empty(const fifo_t * fifo);
size_t fifo_count(const fifo_t * fifo);
size_t fifo_push(fifo_t * fifo, fifo_data_t data);
size_t fifo_pop(fifo_t * fifo, fifo_data_t * data);

/** @warning LOG_FATAL level kills the program */
#define X_MACRO_LOGGING\
	X(LOG_MESSAGE_OFF,  "")\
	X(LOG_FATAL,        "fatal")\
	X(LOG_ERROR,        "error")\
	X(LOG_WARNING,      "warning")\
	X(LOG_NOTE,         "note")\
	X(LOG_DEBUG,        "debug")\
	X(LOG_ALL_MESSAGES, "any")

typedef enum {
#define X(ENUM, NAME) ENUM,
	X_MACRO_LOGGING
#undef X
} log_level_e;

extern log_level_e log_level;

#ifdef __GNUC__
#define LOGGER_PRINTF __attribute__((format(printf, 4, 5)))
#else
#define LOGGER_PRINTF
#endif

int logger(log_level_e level, const char *func,
		const unsigned line, const char *fmt, ...) LOGGER_PRINTF;

#define fatal(...)   logger(LOG_FATAL,   __func__, __LINE__, __VA_ARGS__)
#define error(...)   logger(LOG_ERROR,   __func__, __LINE__, __VA_ARGS__)
#define warning(...) logger(LOG_WARNING, __func__, __LINE__, __VA_ARGS__)
#define note(...)    logger(LOG_NOTE,    __func__, __LINE__, __VA_ARGS__)
#define debug(...)   logger(LOG_DEBUG,   __func__, __LINE__, __VA_ARGS__)

int memory_load(FILE *input, uint16_t *p, size_t length);
int memory_save(FILE *output, const uint16_t *p, size_t length);

#define BACKSPACE (8)
#define ESCAPE    (27)
#define DELETE    (127)  /* ASCII delete */

void vt100_update(vt100_t *t, uint8_t c);

#endif