From 238a43e587bfbe6574d34ef36553619249797260 Mon Sep 17 00:00:00 2001
From: Julian Blake Kongslie
Date: Wed, 7 Apr 2021 17:02:03 -0700
Subject: Switch back to $past-based scheduling; my clever idea wasn't clever
 enough.

---
 hdl/top.sv | 105 ++++++++++++++++++++++++++-----------------------------------
 1 file changed, 45 insertions(+), 60 deletions(-)

(limited to 'hdl/top.sv')

diff --git a/hdl/top.sv b/hdl/top.sv
index a1cdbf7..3cda157 100644
--- a/hdl/top.sv
+++ b/hdl/top.sv
@@ -41,14 +41,6 @@ mem
     ,   .read_data(mem_read_data)
     );
 
-`input(mem_ready)
-`output(mem_valid)
-`output(mem_address)
-`output(mem_write)
-`output(mem_write_data)
-`input(mem_read_valid)
-`input(mem_read_data)
-
 bit rx_ready;
 bit rx_valid;
 bit [7:0] rx_data;
@@ -72,13 +64,6 @@ jtag_uart
     ,   .tx_data(tx_data)
     );
 
-`output(rx_ready)
-`input(rx_valid)
-`input(rx_data)
-`input(tx_ready)
-`output(tx_valid)
-`output(tx_data)
-
 bit [ADDR_BITS-1:0] pc;
 bit [3:0] opcode;
 bit [7:0] operand;
@@ -99,33 +84,33 @@ enum
 
 always_ff @(posedge clk) begin
     if (reset) begin
-        mem_valid_ = 0;
-        rx_ready_ = 0;
-        tx_valid_ = 0;
-        tx_data_ = 0;
+        mem_valid = 0;
+        rx_ready = 0;
+        tx_valid = 0;
+        tx_data = 0;
         pc = 0;
         acc = 0;
         state = state.first;
     end else begin
-        if (tx_ready_) tx_valid_ = 0;
+        if (`lag(tx_ready)) tx_valid = 0;
 
         case (state)
             FETCH: begin
-                mem_valid_ = 1;
-                mem_address_ = pc;
-                mem_write_ = 0;
-                if (mem_ready_) begin
+                mem_valid = 1;
+                mem_address = pc;
+                mem_write = 0;
+                if (`lag(mem_ready)) begin
                     state = DECODE;
                     ++pc;
                 end
             end
 
             DECODE: begin
-                mem_valid_ = 0;
-                mem_write_ = 0;
-                if (mem_read_valid_) begin
+                mem_valid = 0;
+                mem_write = 0;
+                if (`lag(mem_read_valid)) begin
                     state = FETCH;
-                    {opcode, operand} = mem_read_data_;
+                    {opcode, operand} = `lag(mem_read_data);
                     sign_extended_operand = {{(DATA_BITS-8){operand[7]}}, operand};
                     case (opcode)
                         'h0: begin
@@ -150,7 +135,7 @@ always_ff @(posedge clk) begin
                             end
                         end
                         'h6: begin
-                            mem_write_data_ = acc % 10 + 'h30;
+                            mem_write_data = acc % 10 + 'h30;
                             acc = acc / 10;
                             address = {7'b0, operand[6:0]};
                             state = operand[7] ? INDIRECT : AGEN;
@@ -160,70 +145,70 @@ always_ff @(posedge clk) begin
             end
 
             INDIRECT: begin
-                mem_valid_ = 1;
-                mem_write_ = 0;
-                mem_address_ = address;
-                state = mem_ready_ ? INDIRECTED : INDIRECT;
+                mem_valid = 1;
+                mem_write = 0;
+                mem_address = address;
+                state = `lag(mem_ready) ? INDIRECTED : INDIRECT;
             end
 
             INDIRECTED: begin
-                if (mem_ready_) begin
-                    mem_valid_ = 0;
-                    mem_write_ = 0;
+                if (`lag(mem_ready)) begin
+                    mem_valid = 0;
+                    mem_write = 0;
                 end
-                if (mem_read_valid_) begin
-                    address = {{(ADDR_BITS - DATA_BITS){1'b0}}, mem_read_data_};
+                if (`lag(mem_read_valid)) begin
+                    address = {{(ADDR_BITS - DATA_BITS){1'b0}}, `lag(mem_read_data)};
                     state = AGEN;
                 end
             end
 
             AGEN: begin
-                mem_valid_ = 0;
-                mem_write_ = 0;
+                mem_valid = 0;
+                mem_write = 0;
                 state = FETCH;
                 case (opcode)
                     'h2: begin
-                        mem_valid_ = 1;
-                        mem_address_ = address;
-                        state = mem_ready_ ? MEMORY : AGEN;
+                        mem_valid = 1;
+                        mem_address = address;
+                        state = `lag(mem_ready) ? MEMORY : AGEN;
                     end
                     'h3: begin
-                        mem_valid_ = 1;
-                        mem_address_ = address;
-                        mem_write_ = 1;
-                        mem_write_data_ = acc;
-                        state = mem_ready_ ? FETCH : AGEN;
+                        mem_valid = 1;
+                        mem_address = address;
+                        mem_write = 1;
+                        mem_write_data = acc;
+                        state = `lag(mem_ready) ? FETCH : AGEN;
                     end
                     'h5: pc = address;
                     'h6: begin
-                        mem_valid_ = 1;
-                        mem_address_ = address;
-                        mem_write_ = 1;
-                        state = mem_ready_ ? FETCH : AGEN;
+                        mem_valid = 1;
+                        mem_address = address;
+                        mem_write = 1;
+                        state = `lag(mem_ready) ? FETCH : AGEN;
                     end
                 endcase
             end
 
             MEMORY: begin
-                if (mem_ready_) begin
-                    mem_valid_ = 0;
-                    mem_write_ = 0;
+                if (`lag(mem_ready)) begin
+                    mem_valid = 0;
+                    mem_write = 0;
                 end
                 state = FETCH;
                 case (opcode)
                     'h0: begin
                         if (operand[6]) begin
-                            if (tx_valid_) begin
+                            if (tx_valid) begin
                                 state = MEMORY;
                             end else begin
-                                tx_valid_ = 1;
-                                tx_data_ = acc[7:0];
+                                tx_valid = 1;
+                                tx_data = acc[7:0];
                             end
                         end
                     end
                     'h2: begin
-                        if (mem_read_valid_) begin
-                            acc = acc + mem_read_data_;
+                        if (`lag(mem_read_valid)) begin
+                            acc = acc + `lag(mem_read_data);
                         end else begin
                             state = MEMORY;
                         end
-- 
cgit v1.2.3