Fix spinner, update sys (MiSTer-devel#8)

* Fix spinner output, update sys

* Release 20211127

Author: JimmyStones

releases/InputTest_20211127.rbf

@@ -561,8 +561,8 @@ void inputtester_advanced()
             px_last[inputindex] = px;
 
             // Draw spinner inputs (only update when update clock changes)
-            bool sx_toggle = CHECK_BIT(spinner[(inputindex * 8) + 1], 0);
-            signed char sx = spinner[(inputindex * 8)];
+            bool sx_toggle = CHECK_BIT(spinner[(inputindex * 2) + 1], 0);
+            signed char sx = spinner[(inputindex * 2)];
             if (sx_toggle != sx_toggle_last[inputindex])
             {
                 sx_pos[inputindex] += sx;

rtl/rom.hex

@@ -174,15 +174,16 @@ module screen_rotate
 
 	input         rotate_ccw,
 	input         no_rotate,
+	input         flip,
 
-	output        FB_EN,
-	output  [4:0] FB_FORMAT,
-	output [11:0] FB_WIDTH,
-	output [11:0] FB_HEIGHT,
-	output [31:0] FB_BASE,
-	output [13:0] FB_STRIDE,
-	input         FB_VBL,
-	input         FB_LL,
+	output            FB_EN,
+	output      [4:0] FB_FORMAT,
+	output reg [11:0] FB_WIDTH,
+	output reg [11:0] FB_HEIGHT,
+	output     [31:0] FB_BASE,
+	output     [13:0] FB_STRIDE,
+	input             FB_VBL,
+	input             FB_LL,
 
 	output        DDRAM_CLK,
 	input         DDRAM_BUSY,
@@ -196,6 +197,8 @@ module screen_rotate
 
 parameter MEM_BASE    = 7'b0010010; // buffer at 0x24000000, 3x8MB
 
+reg  do_flip;
+
 assign DDRAM_CLK      = CLK_VIDEO;
 assign DDRAM_BURSTCNT = 1;
 assign DDRAM_ADDR     = {MEM_BASE, i_fb, ram_addr[22:3]};
@@ -207,8 +210,6 @@ assign DDRAM_RD       = 0;
 assign FB_EN     = fb_en[2];
 assign FB_FORMAT = 5'b00110;
 assign FB_BASE   = {MEM_BASE,o_fb,23'd0};
-assign FB_WIDTH  = vsz;
-assign FB_HEIGHT = hsz;
 assign FB_STRIDE = stride;
 
 function [1:0] buf_next;
@@ -220,6 +221,17 @@ function [1:0] buf_next;
 	end
 endfunction
 
+always @(posedge CLK_VIDEO) begin
+	do_flip <= no_rotate && flip;
+	if( do_flip ) begin
+		FB_WIDTH  <= hsz;
+		FB_HEIGHT <= vsz;
+	end else begin
+		FB_WIDTH  <= vsz;
+		FB_HEIGHT <= hsz;
+	end
+end
+
 reg [1:0] i_fb,o_fb;
 always @(posedge CLK_VIDEO) begin
 	reg old_vbl,old_vs;
@@ -251,20 +263,23 @@ always @(posedge CLK_VIDEO) begin
 	if(CE_PIXEL) begin
 		old_vs <= VGA_VS;
 		old_de <= VGA_DE;
-		
+
 		hcnt <= hcnt + 1'd1;
 		if(~old_de & VGA_DE) begin
 			hcnt <= 1;
 			vcnt <= vcnt + 1'd1;
 		end
-		if(old_de & ~VGA_DE) hsz <= hcnt;
+		if(old_de & ~VGA_DE) begin
+			hsz <= hcnt;
+			if( do_flip ) bwidth <= hcnt + 2'd3;
+		end
 		if(~old_vs & VGA_VS) begin
 			vsz <= vcnt;
-			bwidth <= vcnt + 2'd3;
+			if( !do_flip ) bwidth <= vcnt + 2'd3;
 			vcnt <= 0;
-			fb_en <= {fb_en[1:0], ~no_rotate};
+			fb_en <= {fb_en[1:0], ~no_rotate | flip};
 		end
-		if(old_vs & ~VGA_VS) bufsize <= hsz * stride;
+		if(old_vs & ~VGA_VS) bufsize <= (do_flip ? vsz : hsz ) * stride;
 	end
 end
 
@@ -278,21 +293,25 @@ always @(posedge CLK_VIDEO) begin
 	reg old_vs, old_de;
 
 	ram_wr <= 0;
-	if(CE_PIXEL) begin
+	if(CE_PIXEL && FB_EN) begin
 		old_vs <= VGA_VS;
 		old_de <= VGA_DE;
 
 		if(~old_vs & VGA_VS) begin
-			next_addr <= rotate_ccw ? (bufsize - stride) : {vsz-1'd1, 2'b00};
+			next_addr <=
+				do_flip    ? bufsize-3'd4 :
+				rotate_ccw ? (bufsize - stride) : {vsz-1'd1, 2'b00};
 			hcnt <= rotate_ccw ? 3'd4 : {vsz-2'd2, 2'b00};
 		end
 		if(VGA_DE) begin
 			ram_wr <= 1;
-			ram_data <= {VGA_B,VGA_G,VGA_R};
+			ram_data <= {8'd0,VGA_B,VGA_G,VGA_R};
 			ram_addr <= next_addr;
-			next_addr <= rotate_ccw ? (next_addr - stride) : (next_addr + stride);
+			next_addr <=
+				do_flip    ? next_addr-3'd4 :
+				rotate_ccw ? (next_addr - stride) : (next_addr + stride);
 		end
-		if(old_de & ~VGA_DE) begin
+		if(old_de & ~VGA_DE & ~do_flip) begin
 			next_addr <= rotate_ccw ? (bufsize - stride + hcnt) : hcnt;
 			hcnt <= rotate_ccw ? (hcnt + 3'd4) : (hcnt - 3'd4);
 		end

src/inputtester.c

@@ -322,6 +322,7 @@ always@(posedge clk_sys) begin : uio_block
 				  'h36: begin io_dout <= info_n; info_n <= 0; end
 				  'h39: io_dout <= 1;
 				  'h3C: if(upload_req) begin io_dout <= 1; upload_req <= 0; end
+				  'h3E: io_dout <= 1; // shadow mask
 			endcase
 
 			sd_buff_addr <= 0;

sys/arcade_video.v

@@ -0,0 +1,144 @@
+module shadowmask
+(
+    input             clk,
+    input             clk_sys,
+	 
+    input             cmd_wr,
+    input      [15:0] cmd_in,
+
+    input      [23:0] din,
+    input             hs_in,vs_in,
+    input             de_in,
+
+    output reg [23:0] dout,
+    output reg        hs_out,vs_out,
+    output reg        de_out
+);
+
+
+//These are unused right now
+parameter MaxPatternWidth = 8;
+parameter MaxPatternHeight = 4;
+
+reg [3:0] hcount;
+reg [3:0] vcount;
+
+reg [3:0] hmax;
+reg [3:0] vmax;
+reg [3:0] hmax2;
+reg [3:0] vmax2;
+
+reg [2:0] hindex;
+reg [2:0] vindex;
+reg [2:0] hindex2;
+reg [2:0] vindex2;
+
+reg mask_2x;
+reg mask_rotate;
+reg mask_enable;
+
+always @(posedge clk) begin
+
+    reg old_hs, old_vs;
+    old_hs <= hs_in;
+    old_vs <= vs_in;
+    hcount <= hcount + 4'b1;
+
+    // hcount and vcount counts pixel rows and columns
+    // hindex and vindex half the value of the counters for double size patterns
+    // hindex2, vindex2 swap the h and v counters for drawing rotated masks
+    hindex <= mask_2x ? hcount[3:1] : hcount[2:0];
+    vindex <= mask_2x ? vcount[3:1] : vcount[2:0];
+    hindex2 <= mask_rotate ? vindex : hindex;
+    vindex2 <= mask_rotate ? hindex : vindex;
+
+    // hmax and vmax store these sizes
+    // hmax2 and vmax2 swap the values to handle rotation
+    hmax2 <= mask_rotate ? ( vmax << mask_2x ) : ( hmax << mask_2x );
+    vmax2 <= mask_rotate ? ( hmax << mask_2x ) : ( vmax << mask_2x );
+
+    if((old_vs && ~vs_in)) vcount <= 4'b0;
+    if(old_hs && ~hs_in) begin
+        vcount <= vcount + 4'b1;
+        hcount <= 4'b0;
+        if (vcount == (vmax2 + mask_2x)) vcount <= 4'b0;
+        end
+
+    if (hcount == (hmax2 + mask_2x)) hcount <= 4'b0;
+end
+
+wire [7:0] r,g,b;
+assign {r,g,b} = din;
+
+reg [23:0] d;
+
+// Each element of mask_lut is 3 bits. 1 each for R,G,B
+// Red   is   100 = 4
+// Green is   010 = 2
+// Blue  is   001 = 1
+// Magenta is 101 = 5
+// Gray is    000 = 0
+// White is   111 = 7
+// Yellow is  110 = 6
+// Cyan is    011 = 3
+
+// So the Pattern
+// r,r,g,g,b,b
+// r,r,g,g,b,b
+// g,b,b,r,r,g
+// g,b,b,r,r,g
+//
+// is
+// 4,4,2,2,1,1,5,3
+// 4,4,2,2,1,1,0,0,
+// 2,1,1,4,4,2,0,0
+// 2,1,1,4,4,2,0,0
+//
+// note that all rows are padded to 8 numbers although every pattern is 6 pixels wide
+// The last two entries of the top row "5,3" are the size of the mask. In this case
+// "5,3," means this pattern is 6x4 pixels.
+
+
+reg [2:0] mask_lut[64];
+
+always @(posedge clk) begin
+
+    reg rbit, gbit, bbit;
+    reg [23:0] dout1, dout2;
+    reg de1,de2,vs1,vs2,hs1,hs2;
+    reg [8:0] r2, g2, b2; //9 bits to handle overflow when we add to bright colors.
+    reg [7:0] r3, g3, b3; //These are the final colors.
+
+    {rbit,gbit, bbit} = mask_lut[{vindex2[2:0],hindex2[2:0]}];
+
+    // I add 12.5% of the Color value and then subrtact 50% if the mask should be dark
+    r2 <= r + {3'b0, r[7:3]} - (rbit ?  9'b0 : {2'b0, r[7:1]});
+    g2 <= g + {3'b0, g[7:3]} - (gbit ?  9'b0 : {2'b0, g[7:1]});
+    b2 <= b + {3'b0, b[7:3]} - (bbit ?  9'b0 : {2'b0, b[7:1]});
+
+    // Because a pixel can be brighter than 255 we have to clamp the value to 255.
+    r3 <= r2[8] ? 8'd255 : r2[7:0];
+    g3 <= g2[8] ? 8'd255 : g2[7:0];
+    b3 <= b2[8] ? 8'd255 : b2[7:0];
+
+    // I don't know how to keep the color aligned with the sync to avoid a shift.
+    // This code is left over from the original hdmi scanlines code.
+    dout <= ~mask_enable ? {r,g,b} : {r3 ,g3, b3};
+    vs_out <= mask_enable ? vs2 : vs_in;   vs2   <= vs1;   vs1   <= vs_in;
+    hs_out <= mask_enable ? hs2 : hs_in;   hs2   <= hs1;   hs1   <= hs_in;
+    de_out <= mask_enable ? de2 : de_in;   de2   <= de1;   de1   <= de_in;
+end
+
+// 000_000_000_000_000_
+always @(posedge clk_sys) begin
+    if (cmd_wr) begin
+        case(cmd_in[15:13])
+        3'b000: {mask_rotate, mask_2x, mask_enable} <= cmd_in[2:0];
+        3'b001: vmax <= cmd_in[3:0];
+        3'b010: hmax <= cmd_in[3:0];
+        3'b011: mask_lut[cmd_in[9:4]] <= cmd_in[2:0];
+        endcase
+    end
+end
+
+endmodule

sys/hps_io.sv

@@ -7,6 +7,7 @@ set_global_assignment -name SYSTEMVERILOG_FILE [file join $::quartus(qip_path) m
 set_global_assignment -name SYSTEMVERILOG_FILE [file join $::quartus(qip_path) hq2x.sv ]
 set_global_assignment -name VERILOG_FILE       [file join $::quartus(qip_path) scandoubler.v ]
 set_global_assignment -name VERILOG_FILE       [file join $::quartus(qip_path) scanlines.v ]
+set_global_assignment -name SYSTEMVERILOG_FILE [file join $::quartus(qip_path) shadowmask.sv ]
 set_global_assignment -name SYSTEMVERILOG_FILE [file join $::quartus(qip_path) video_cleaner.sv ]
 set_global_assignment -name SYSTEMVERILOG_FILE [file join $::quartus(qip_path) gamma_corr.sv ]
 set_global_assignment -name SYSTEMVERILOG_FILE [file join $::quartus(qip_path) video_mixer.sv ]

sys/shadowmask.sv

@@ -335,6 +335,7 @@ always@(posedge clk_sys) begin
 
 	old_strobe <= io_strobe;
 	coef_wr <= 0;
+	shadowmask_wr <= 0;
 
 	if(~io_uio) begin
 		has_cmd <= 0;
@@ -452,6 +453,7 @@ always@(posedge clk_sys) begin
 					 3: arc2y <= io_din[12:0];
 				endcase
 			end
+			if(cmd == 'h3E) {shadowmask_wr,shadowmask_data} <= {1'b1, io_din};
 		end
 	end
 
@@ -1079,6 +1081,31 @@ scanlines #(1) HDMI_scanlines
 	.de_out(hdmi_de_sl)
 );
 
+wire [23:0] hdmi_data_mask;
+wire        hdmi_de_mask, hdmi_vs_mask, hdmi_hs_mask;
+
+reg [15:0] shadowmask_data;
+reg        shadowmask_wr = 0;
+
+shadowmask HDMI_shadowmask
+(
+	.clk(clk_hdmi),
+	.clk_sys(clk_sys),
+
+	.cmd_wr(shadowmask_wr),
+	.cmd_in(shadowmask_data),
+
+	.din(hdmi_data_sl),
+	.hs_in(hdmi_hs_sl),
+	.vs_in(hdmi_vs_sl),
+	.de_in(hdmi_de_sl),
+	
+	.dout(hdmi_data_mask),
+	.hs_out(hdmi_hs_mask),
+	.vs_out(hdmi_vs_mask),
+	.de_out(hdmi_de_mask)
+);
+
 wire [23:0] hdmi_data_osd;
 wire        hdmi_de_osd, hdmi_vs_osd, hdmi_hs_osd;
 
@@ -1091,10 +1118,10 @@ osd hdmi_osd
 	.io_din(io_din),
 
 	.clk_video(clk_hdmi),
-	.din(hdmi_data_sl),
-	.hs_in(hdmi_hs_sl),
-	.vs_in(hdmi_vs_sl),
-	.de_in(hdmi_de_sl),
+	.din(hdmi_data_mask),
+	.hs_in(hdmi_hs_mask),
+	.vs_in(hdmi_vs_mask),
+	.de_in(hdmi_de_mask),
 
 	.dout(hdmi_data_osd),
 	.hs_out(hdmi_hs_osd),