Foreword
In the previous pot we wrote a small program running under Linux that captures the Scan codes that gets pressed and released on a keyboard.This paved way for a future post where we will be delegating key presses in Linux to the C64 module.
In this post we will start with some Linux/C64 module integration.
In particular, we will be developing some functionality that allows us to toggle video output to the VGA screen between the Linux console and the video output from the C64 FPGA module.
Overview
Let us start by having an overview of what we want to achieve.The last time we work on our C64 CPGA module was in this post, where we have added a scaler for scaling up the video frames our C64 module produces, so that it fills the screen.
Obviously, when we toggle from our C64 video output to the Linux console, we will need to bypass this scaler. This bypass is depicted by the illustration below:
The red arrow indicates when we want to display the Linux console on the VGA screen, we need to bypass the video scaler, as well as the succeeding buffer. So, in this scenario we effectively outputting pixels directly from the first pixel buffer to the VGA screen.
Apart from bypassing the video scaler related components, we will also need to adjust the visible portion of the screen when toggling between the C64 video output and the Linux console. The Linux console will fill the whole screen, wheras the C64 module wont fit the complete width, e.g. a black band on the left and the right.
To trigger a change of video output source I will be utilising one of the push buttons on the Zybo board. When this button isn't pressed, we will show the Linux console on the VGA screen. If you push this button, the C64 screen will be shown. As soon as you release the button, the Linux console will be shown again.
In a future post we will be writing a program running under Linux that will automatically switch to the C64 screen when we run it, and switching back to the Linux console when we terminate this program.
Changing Framebuffer Addresses
Having to cater for two possible video sources (e.g. Linux console and C64), we need to assign a separate framebuffer area in memory for each.From a previously post we have seen that it is better to host a framebuffer area at the top of the Zybo RAM and permit Linux to only use memory below this region. This just avoid headaches of trying to get Linux allocating large chunks of physical contiguous memory.
To accommodate the Linux framebuffer console, we have decided to limit allowable Linux memory to 500MB and put the framebuffer at address 507MB, resolving to physical address 0x1fb00000.
For the C64 video output we can reserve a framebuffer at address 503MB. This in turn resolves to physcial address 0x1f700000.
In previous posts C64 video output was always written to address 0x200000, so we need to change this in the burst write unit of our C64 module
always @(negedge clk)
if (!reset | (next_frame & count_in_buf == 0))
begin
axi_start_address <= /*32'h200000*/32'h1f700000;
axi_data_inc <= 0;
end
else if (state == INIT_CMD)
begin
axi_start_address <= axi_start_address + axi_data_inc;
axi_data_inc <= {BURST_THRES,2'b0};
end
We have covered the core surrounding this code in a post a year or so ago. Basically this snippet keeps track of the address to use for each AXI burst. This gets reset at the beginning of each frame to display.
For our C64 video output we can always just use the same address. In case we change video source to Linux console, our C64 can continue writing its value output to its memory area without causing any harm.
So, our C64 module doesn't need much changes to accommodate two video sources. Our VGA module, however, needs to be able to read framebuffer data from two different areas.
For starters, we need to tell our VGA module which display mode we are in. We do this with an input port:
module vga(
input wire clk,
input wire clk_axi,
input wire reset,
output wire vert_sync,
output wire horiz_sync,
output wire [4:0] red,
output wire [5:0] green,
output wire [4:0] blue,
output wire [31:0] ip2bus_mst_addr,
output wire [11:0] ip2bus_mst_length,
input wire [31:0] ip2bus_mstrd_d,
output wire [4:0] ip2bus_inputs,
input wire [5:0] ip2bus_otputs,
input wire c64_mode_in,
...
);
...
reg c64_mode;
...
always @(posedge clk_axi)
c64_mode <= c64_mode_in;
...
Later in this post we will be connecting c64_mode_in to a toggle button present on the Zybo board.
I am sampling this input port to a flip-flop just to cater for potential button bounces. This is probably an overkill, but I am just doing this in case...
Next, we need to make the following modifications to our AXI burst read block within our VGA module:
burst_read_block my_read_block(
.clk(clk_axi),
.reset(reset),
.restart(trigger_restart_state == RESTART_STATE_RESTART),
.count_in_buf(),
.ip2bus_mst_addr(ip2bus_mst_addr),
.ip2bus_mst_length(ip2bus_mst_length),
.ip2bus_mstrd_d(ip2bus_mstrd_d),
.ip2bus_inputs(ip2bus_inputs),
.ip2bus_otputs(ip2bus_otputs),
.axi_d_out(axi_read_data),
.empty(axi_buffer_empty_temp),
.read(read_from_axi),
.start_address(c64_mode ? 32'h1f700000 : 32'h1fb00000)
);
We have added the start_address port in a previous post. Now we just take it one step further and provide a different adddress depending on whether c64_mode is enabled or not.
Different visible regions
Another difference between C64 video output and the Linux console we should address, is the difference between visible regions. The Linux console fills the screen whereas the C64 video output doesn't fill the whole width of the screen.Let us start by defining a computational logic output for indicating when we are in a visible portion of the screen:
...
assign visible_region_vga = (vert_pos_next > 0) & (vert_pos_next < 766) &
(horiz_pos_next > 0) & (horiz_pos_next < 1361);
assign visible_region_c64 = (vert_pos > 20) & (vert_pos < 760) &
(horiz_pos > 100) & (horiz_pos < 1175);
assign visible_region = c64_mode ? visible_region_c64 : visible_region_vga;
...
Together with the different visible regions, we also need to able to select pixel display data from different sources:
assign pixel_display_data = c64_mode ? fifo_data_read : out_pixel_buffer;
So, in C64 mode we output the FIFO pixel buffered data from the scalar unit. With the Linux console mode, we output directly from the 16-bit asynchronous FIFO buffer, which buffer data from the AXI burst unit.
All this we can combine into the following, which will give us a black border for the portion of the screen which the applicable video output doesn't fill:
assign out_pixel_buffer_final = visible_region ? pixel_display_data : 0;
The Final touches
We have developed the majority of functionality so that our FGPA design can display video from different sources.There is a couple of remaining things that needs to be implemented.
First thing we need to have a look at is controlling the reading of data from the Asynchronous FIFO.
In C64 mode the Scalar unit will control the reading from the Asynchronous FIFO, whereas in Linux Console mode we will trigger reads from this FIFO when we are in the visible portions of the screen.
This translates to the following change:
aFifo
#(.DATA_WIDTH(16))
my_fifo
(.Data_out(out_pixel_buffer),
.Empty_out(async_empty),
.ReadEn_in(c64_mode ? (nextDIn & data_valid_in) : visible_region_vga),
.RClk(clk),
.Data_in(shift_reg_16_bit[31:16]),
.Full_out(buffer_full),
.WriteEn_in((state_shift_reg == STATE_16_SHIFT_STORED | state_shift_reg == STATE_16_SHIFT_SHIFTED) & !buffer_full),
.WClk(clk_axi),
.Clear_in(trigger_restart_state == RESTART_STATE_RESTART)
);
The final thing we should address is the different orders pixels are stored for the two video sources for each 32-bit word received from the AXI bus. For instance, on the C64 module each 32-bit AXI word has the first pixel in line in the higher 16 bits, and the next pixel in line as the lower 16-bits.
On the Linux console video source has the first pixel in line in the lowest 16 bits of the 32-bit word, whereas the next pixel in line as the higher order 16-bits.
We need to account for this in our pixel splitter:
always @(posedge clk_axi)
if (read_from_axi)
shift_reg_16_bit <= c64_mode ? {axi_read_data[31:16], axi_read_data[15:0]} :
{ axi_read_data[15:0], axi_read_data[31:16]};
else if (state_shift_reg == STATE_16_SHIFT_STORED & !buffer_full)
shift_reg_16_bit <= {shift_reg_16_bit[15:0], 16'b0};
Testing the setup
Let us test the setup.We still need to link up the C64_mode pin on our VGA module to one of the push buttons.
Usually this involves adding an extra constraint to our constraint file (e.g. the XDC file).
Luckily we don't need to figure out these constraints from scratch, since the Home website of the Zybo board provides us with a template XDC file.
Scrolling down this template XDC, we eventually find the set of lines we are looking for:
##Buttons
#set_property -dict { PACKAGE_PIN R18 IOSTANDARD LVCMOS33 } [get_ports { btn[0] }]; #IO_L20N_T3_34 Sch=BTN0
#set_property -dict { PACKAGE_PIN P16 IOSTANDARD LVCMOS33 } [get_ports { btn[1] }]; #IO_L24N_T3_34 Sch=BTN1
#set_property -dict { PACKAGE_PIN V16 IOSTANDARD LVCMOS33 } [get_ports { btn[2] }]; #IO_L18P_T2_34 Sch=BTN2
#set_property -dict { PACKAGE_PIN Y16 IOSTANDARD LVCMOS33 } [get_ports { btn[3] }]; #IO_L7P_T1_34 Sch=BTN3
This declares a potential input port we can add to our design called btn.
This port, however, is declared as a 4 bit vector. From this 4 bit vector we only need one bit, meaning that we would need to write some extra Verilog code to split this vector into individual bits.
We could, however, simplify our life by not declaring these set of buttons as a vector constraint, but as individual ports:
##Buttons
#set_property -dict { PACKAGE_PIN R18 IOSTANDARD LVCMOS33 } [get_ports { btn_0 }]; #IO_L20N_T3_34 Sch=BTN0
#set_property -dict { PACKAGE_PIN P16 IOSTANDARD LVCMOS33 } [get_ports { btn_1 }]; #IO_L24N_T3_34 Sch=BTN1
#set_property -dict { PACKAGE_PIN V16 IOSTANDARD LVCMOS33 } [get_ports { btn_2 }]; #IO_L18P_T2_34 Sch=BTN2
#set_property -dict { PACKAGE_PIN Y16 IOSTANDARD LVCMOS33 } [get_ports { btn_3 }]; #IO_L7P_T1_34 Sch=BTN3
We can now just choose the applicable button we want and add it to our block design.
After synthesis, creating the bitstream, and creating a new boot.bin, we are now ready to run a test.
The following video shows the outcome:
We start off with the Linux console. As we press and release one of the push buttons, the C64 screen pops up and go back to the Linux console.
In Summary
In this post we have implemented functionality within our FPGA design in which we can switch between C64 video output and the Linux console.For now this switching can only be done via a push button on the Zybo board.
In the next post we will be redirecting keystrokes from Linux to our C64 FPGA module.
Till next time!
