`include "util.svh"

module top
    (   input   bit native_clk  // verilator public
    ,   input   bit reset_n     // verilator public

    ,   inout   wire [10:1]  gpioa
    ,   inout   wire [28:13] gpiob
    ,   inout   wire [40:31] gpioc
    );

bit clk;
bit reset;

clock // 45 MHz
    #(  .MULTIPLY_BY(9)
    ,   .DIVIDE_BY(10)
    ) pll
    (   .native_clk(native_clk)
    ,   .reset_n(reset_n)
    ,   .target_clk(clk)
    ,   .reset(reset)
    );

bit slowclk;
bit slowreset;
clock // 100 kHz
    #(  .MULTIPLY_BY(1)
    ,   .DIVIDE_BY(500)
    ) slowpll
    (   .native_clk(native_clk)
    ,   .reset_n(reset_n)
    ,   .target_clk(slowclk)
    ,   .reset(slowreset)
    );

bit [8:1][12:1] led;
bit [3:1][12:1] switch;

panel fp
    (   .clk(slowclk)
    ,   .reset(slowreset)

    ,   .led(led)
    ,   .switch(switch)

    ,   .gpioa(gpioa)
    ,   .gpiob(gpiob)
    ,   .gpioc(gpioc)
    );

bit [3:1] switch_df;
bit [3:1] switch_if;
bit [12:1] switch_sr;
bit switch_start;
bit switch_load_add;
bit switch_dep;
bit switch_exam;
bit switch_cont;
bit switch_stop;
bit switch_sing_step;
bit switch_sing_inst;

assign switch_df = switch[2][3:1];
assign switch_if = switch[2][6:4];
assign switch_sr = switch[1];
assign switch_start = switch[3][1];
assign switch_load_add = switch[3][2];
assign switch_dep = switch[3][3];
assign switch_exam = switch[3][4];
assign switch_cont = switch[3][5];
assign switch_stop = switch[3][6];
assign switch_sing_step = switch[3][7];
assign switch_sing_inst = switch[3][8];

bit [11:0] led_pc;
bit [11:0] led_memaddr;
bit [11:0] led_memdata;
bit [11:0] led_acc;
bit [11:0] led_mq;
bit led_and;
bit led_tad;
bit led_isz;
bit led_dca;
bit led_jms;
bit led_jmp;
bit led_iot;
bit led_opr;
bit led_fetch;
bit led_execute;
bit led_defer;
bit led_word_count;
bit led_current_address;
bit led_break;
bit led_ion;
bit led_pause;
bit led_run;
bit [4:0] led_step_counter;
bit [2:0] led_df;
bit [2:0] led_if;
bit led_link;

assign led[1] = {led_pc[0], led_pc[1], led_pc[2], led_pc[3], led_pc[4], led_pc[5], led_pc[6], led_pc[7], led_pc[8], led_pc[9], led_pc[10], led_pc[11]};
assign led[2] = {led_memaddr[0], led_memaddr[1], led_memaddr[2], led_memaddr[3], led_memaddr[4], led_memaddr[5], led_memaddr[6], led_memaddr[7], led_memaddr[8], led_memaddr[9], led_memaddr[10], led_memaddr[11]};
assign led[3] = {led_memdata[0], led_memdata[1], led_memdata[2], led_memdata[3], led_memdata[4], led_memdata[5], led_memdata[6], led_memdata[7], led_memdata[8], led_memdata[9], led_memdata[10], led_memdata[11]};
assign led[4] = {led_acc[0], led_acc[1], led_acc[2], led_acc[3], led_acc[4], led_acc[5], led_acc[6], led_acc[7], led_acc[8], led_acc[9], led_acc[10], led_acc[11]};
assign led[5] = {led_mq[0], led_mq[1], led_mq[2], led_mq[3], led_mq[4], led_mq[5], led_mq[6], led_mq[7], led_mq[8], led_mq[9], led_mq[10], led_mq[11]};
assign led[6] = {led_word_count, led_defer, led_execute, led_fetch, led_opr, led_iot, led_jmp, led_jms, led_dca, led_isz, led_tad, led_and};
assign led[7] = {led_step_counter, led_run, led_pause, led_ion, led_break, led_current_address};
assign led[8] = {led_link, led_if, led_df};

core cpu
    (   .clk(clk)
    ,   .reset(reset)

    ,   .switch_cont(switch_cont)

    ,   .led_pc(led_pc)
    ,   .led_memaddr(led_memaddr)
    ,   .led_memdata(led_memdata)
    ,   .led_acc(led_acc)
    ,   .led_mq(led_mq)
    ,   .led_and(led_and)
    ,   .led_tad(led_tad)
    ,   .led_isz(led_isz)
    ,   .led_dca(led_dca)
    ,   .led_jms(led_jms)
    ,   .led_jmp(led_jmp)
    ,   .led_iot(led_iot)
    ,   .led_opr(led_opr)
    ,   .led_fetch(led_fetch)
    ,   .led_execute(led_execute)
    ,   .led_defer(led_defer)
    ,   .led_word_count(led_word_count)
    ,   .led_current_address(led_current_address)
    ,   .led_break(led_break)
    ,   .led_ion(led_ion)
    ,   .led_pause(led_pause)
    ,   .led_run(led_run)
    ,   .led_step_counter(led_step_counter)
    ,   .led_df(led_df)
    ,   .led_if(led_if)
    ,   .led_link(led_link)
    );

endmodule