bbc_micro_types.h

Go to the documentation of this file.

/*a Includes */
include "video.h"

/*a Types */
/*t t_bbc_keyboard */
typedef struct {
    bit reset_pressed;        
    bit[64] keys_down_cols_0_to_7;
    bit[16] keys_down_cols_8_to_9;
} t_bbc_keyboard;

/*t t_bbc_pixels_per_clock */
typedef enum[3] {
    bbc_ppc_1,
    bbc_ppc_2,
    bbc_ppc_4,
    bbc_ppc_6,
    bbc_ppc_8,
} t_bbc_pixels_per_clock;

/*t t_bbc_display */
typedef struct {
    bit clock_enable;
    bit hsync;
    bit vsync;
    t_bbc_pixels_per_clock pixels_per_clock;
    bit[8] red;
    bit[8] green;
    bit[8] blue;
} t_bbc_display;

/*t t_bbc_display_sram_write */
typedef struct {
    bit enable;
    bit[48] data;
    bit[16] address;
} t_bbc_display_sram_write;

/*t t_bbc_floppy_sector_id */
typedef struct {
    bit[7] track;
    bit    head;
    bit[6] sector_number;
    bit[2] sector_length;
    bit    bad_crc;
    bit    bad_data_crc;
    bit    deleted_data;
} t_bbc_floppy_sector_id;

/*t t_bbc_floppy_op */
typedef struct {
    bit    step_out; // towards track 0
    bit    step_in;
    bit    next_id;
    bit    read_data_enable;
    bit    write_data_enable;
    bit[32] write_data;
    bit    write_sector_id_enable;
    t_bbc_floppy_sector_id sector_id;
} t_bbc_floppy_op;

/*t t_bbc_floppy_response */
typedef struct {
    bit sector_id_valid;
    t_bbc_floppy_sector_id sector_id;
    bit                   index; // assert if sector_id is the first sector of the track
    bit     read_data_valid;
    bit[32] read_data;
    bit    track_zero;    // assert if the current track is track 0
    bit    write_protect; // assert if the disk is write protected (independent of valid)
    bit    disk_ready;    // assert if the disk is loaded (independent of valid)
} t_bbc_floppy_response;

/*t t_bbc_floppy_sram_request */
typedef struct {
    bit enable;
    bit read_not_write;
    bit[20] address;
    bit[32] write_data;
} t_bbc_floppy_sram_request;

/*t t_bbc_floppy_sram_response */
typedef struct {
    bit ack;
    bit read_data_valid;
    bit[32] read_data;
} t_bbc_floppy_sram_response;

/*t t_bbc_clock_control */
typedef struct {
    bit enable_cpu               "Asserted if the rising edge of 'clk' should also be a rising CPU clock edge";
    bit will_enable_2MHz_video   "Asserted if 'enable_2MHz_video' will be asserted in the next 'clk' period";
    bit enable_2MHz_video        "Asserted if the rising  edge of 'clk' should also be a rising video '2MHz' clock edge";
    bit enable_1MHz_rising       "Asserted if the rising  edge of 'clk' should also be a rising '1MHz' clock edge";
    bit enable_1MHz_falling      "Asserted if the rising  edge of 'clk' should also be a falling '1MHz' clock edge";
    bit[2] phi                   "Phase of BBC 6502 clock operation - in a real BBC micro this comes from the CPU";
    bit reset_cpu                "Asserted if the CPU should be reset, controlled by a CSR register";
    bit[4] debug;
} t_bbc_clock_control;

/*t t_bbc_clock_status */
typedef struct {
    bit cpu_1MHz_access "Asserted by the BBC micro if a 1MHz peripheral is being accessed - this the CPU clock enables to align with the 1MHz clock enables";
} t_bbc_clock_status;

/*t t_bbc_micro_sram_request */
typedef struct {
    bit valid            "Asserted to indicate that an SRAM request is valid";
    bit read_enable      "Constant during 'valid', indicates if a read access is required. Exclusive with write_enable";
    bit write_enable     "Constant during 'valid', indicates if a write access is required. Exclusive with read_enable";
    bit[8] select        "Constant during 'valid', indicates which SRAM should be accessed. Usually one of t_bbc_sram_select";
    bit[24] address      "Constant during 'valid', indicates address in SRAM should be accessed.";
    bit[64] write_data   "Constant during 'valid', contains data to be written to SRAM (if write_enable is asserted) - ignored otherwise.";
} t_bbc_micro_sram_request;

/*t t_bbc_micro_sram_response */
typedef struct {
    bit ack               "Asserted to indicate that a SRAM request has been taken - held high until valid is deasserted";
    bit read_data_valid   "Asserted when the read data from an SRAM request is valid";
    bit[64] read_data     "Read data from an SRAM request, valid with read_data_valid, zero in all other cycles";
} t_bbc_micro_sram_response;

/*t t_bbc_csr_select */
typedef enum[16] {
    bbc_csr_select_clocks = 0,
    bbc_csr_select_display = 1,
    bbc_csr_select_floppy = 2,
    bbc_csr_select_keyboard = 3,
    bbc_csr_select_framebuffer = 4,
} t_bbc_csr_select;

/*t t_bbc_sram_select */
typedef enum[8] {
    bbc_sram_select_micro = 0,
    bbc_sram_select_display = 1,
    bbc_sram_select_floppy = 2,
    bbc_sram_select_cpu       = 16,
    bbc_sram_select_cpu_ram_0 = 16,
    bbc_sram_select_cpu_ram_1 = 17,
    bbc_sram_select_cpu_os    = 18,
    bbc_sram_select_cpu_teletext = 20,
    bbc_sram_select_cpu_rom_0 = 24,
    bbc_sram_select_cpu_rom_1 = 25,
    bbc_sram_select_cpu_rom_2 = 26,
    bbc_sram_select_cpu_rom_3 = 27,
} t_bbc_sram_select;