Subversion Repositories datetime

// ============================================================================
//        __
//   \\__/ o\    (C) 2023  Robert Finch, Waterloo
//    \  __ /    All rights reserved.
//     \/_//     robfinch<remove>@finitron.ca
//       ||
//
//              
// BSD 3-Clause License
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its
//    contributors may be used to endorse or promote products derived from
//    this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// ============================================================================
//

module pci32_config(rst_i, clk_i, irq_i, irq_o, cs_config_i, 
        we_i, sel_i, adr_i, dat_i, dat_o, cs_bar0_o, cs_bar1_o, cs_bar2_o, irq_en_o);
input rst_i;
input clk_i;
input irq_i;
output reg [31:0] irq_o;
input cs_config_i;
input we_i;
input [3:0] sel_i;
input [31:0] adr_i;
input [31:0] dat_i;
output [31:0] dat_o;
output reg cs_bar0_o;
output reg cs_bar1_o;
output reg cs_bar2_o;
output reg irq_en_o;

parameter CFG_BUS = 8'd0;
parameter CFG_DEVICE = 5'd0;
parameter CFG_FUNC = 3'd0;
parameter CFG_VENDOR_ID =       16'h0;
parameter CFG_DEVICE_ID =       16'h0;
parameter CFG_SUBSYSTEM_VENDOR_ID       = 16'h0;
parameter CFG_SUBSYSTEM_ID = 16'h0;
parameter CFG_BAR0 = 32'h1;
parameter CFG_BAR1 = 32'h1;
parameter CFG_BAR2 = 32'h1;
parameter CFG_BAR0_MASK = 32'h0;
parameter CFG_BAR1_MASK = 32'h0;
parameter CFG_BAR2_MASK = 32'h0;
parameter CFG_ROM_ADDR = 32'hFFFFFFF0;

parameter CFG_REVISION_ID = 8'd0;
parameter CFG_PROGIF = 8'd1;
parameter CFG_SUBCLASS = 8'h80;                                 // 80 = Other
parameter CFG_CLASS = 8'h03;                                            // 03 = display controller
parameter CFG_CACHE_LINE_SIZE = 8'd8;           // 32-bit units
parameter CFG_MIN_GRANT = 8'h00;
parameter CFG_MAX_LATENCY = 8'h00;
parameter CFG_IRQ_LINE = 8'd16;

localparam CFG_HEADER_TYPE = 8'h00;                     // 00 = a general device

parameter MSIX = 1'b0;

integer n1;
reg [31:0] bar0;
reg [31:0] bar1;
reg [31:0] bar2;
reg [15:0] cmd_reg;
reg [15:0] cmdo_reg;
reg memory_space, io_space;
reg bus_master;
reg parity_err_resp;
reg serr_enable;
reg int_disable;
reg [7:0] latency_timer = 8'h00;

always_comb
begin
        cmdo_reg = cmd_reg;
        cmdo_reg[3] = 1'b0;                     // no special cycles
        cmdo_reg[4] = 1'b0;                     // memory write and invalidate supported
        cmdo_reg[5] = 1'b0;                     // VGA palette snoop
        cmdo_reg[7] = 1'b0;                     // reserved bit
        cmdo_reg[9] = 1'b1;                     // fast back-to-back enable
        cmdo_reg[15:11] = 5'd0; // reserved
end

reg [15:0] stat_reg;
reg [15:0] stato_reg;
always_comb
begin
        stato_reg = stat_reg;
        stato_reg[2:0] = 3'b0;  // reserved
        stato_reg[3] = irq_i;           // interrupt status
        stato_reg[4] = 1'b0;            // capabilities list
        stato_reg[5] = 1'b1;            // 66 MHz enable (N/A)
        stato_reg[6] = 1'b0;            // reserved
        stato_reg[7] = 1'b1;            // fast back-to-back capable
        stato_reg[10:9] = 2'b01;        // medium DEVSEL timing
end

reg [31:0] cfg_dat [0:63];
reg [31:0] cfg_out;
reg [7:0] irq_line;

initial begin
        for (n1 = 0; n1 < 64; n1 = n1 + 1)
                cfg_dat[n1] = 'd0;
end

wire cs = cs_config_i &&
        adr_i[27:20]==CFG_BUS &&
        adr_i[19:15]==CFG_DEVICE &&
        adr_i[14:12]==CFG_FUNC;

always_ff @(posedge clk_i)
if (rst_i) begin
        bar0 <= CFG_BAR0;
        bar1 <= CFG_BAR1;
        bar2 <= CFG_BAR2;
        cmd_reg <= 16'h4003;
        stat_reg <= 16'h0000;
        irq_line <= CFG_IRQ_LINE;
end
else begin
        io_space <= cmdo_reg[0];
        memory_space <= cmdo_reg[1];
        bus_master <= cmdo_reg[2];
        parity_err_resp <= cmdo_reg[6];
        serr_enable <= cmdo_reg[8];
        int_disable <= cmdo_reg[10];
        irq_en_o <= ~cmdo_reg[10];

        if (cs) begin
                if (we_i)
                        case(adr_i[7:2])
                        5'h02:
                                begin
                                        if (sel_i[0]) cmd_reg[7:0] <= dat_i[7:0];
                                        if (sel_i[1]) cmd_reg[15:8] <= dat_i[15:8];
                                        if (sel_i[3]) begin
                                                if (dat_i[8]) stat_reg[8] <= 1'b0;
                                                if (dat_i[11]) stat_reg[11] <= 1'b0;
                                                if (dat_i[12]) stat_reg[12] <= 1'b0;
                                                if (dat_i[13]) stat_reg[13] <= 1'b0;
                                                if (dat_i[14]) stat_reg[14] <= 1'b0;
                                                if (dat_i[15]) stat_reg[15] <= 1'b0;
                                        end
                                end
                        5'h04:
                                if (&sel_i[3:0] && dat_i[31:0]==32'hFFFFFFFF)
                                        bar0 <= CFG_BAR0_MASK;
                                else begin
                                        if (sel_i[0])   bar0[7:0] <= dat_i[7:0];
                                        if (sel_i[1])   bar0[15:8] <= dat_i[15:8];
                                        if (sel_i[2])   bar0[23:16] <= dat_i[23:16];
                                        if (sel_i[3])   bar0[31:24] <= dat_i[31:24];
                                end
                        5'h05:                                  
                                if (&sel_i[3:0] && dat_i[31:0]==32'hFFFFFFFF)
                                        bar1 <= CFG_BAR1_MASK;
                                else begin
                                        if (sel_i[0])   bar1[7:0] <= dat_i[7:0];
                                        if (sel_i[1])   bar1[15:8] <= dat_i[15:8];
                                        if (sel_i[2])   bar1[23:16] <= dat_i[23:16];
                                        if (sel_i[3])   bar1[31:24] <= dat_i[31:24];
                                end
                        5'h06:                                  
                                if (&sel_i[3:0] && dat_i[31:0]==32'hFFFFFFFF)
                                        bar2 <= CFG_BAR2_MASK;
                                else begin
                                        if (sel_i[0])   bar2[7:0] <= dat_i[7:0];
                                        if (sel_i[1])   bar2[15:8] <= dat_i[15:8];
                                        if (sel_i[2])   bar2[23:16] <= dat_i[23:16];
                                        if (sel_i[3])   bar2[31:24] <= dat_i[31:24];
                                end
                        5'h0F:
                                if (sel_i[0]) irq_line <= dat_i[7:0];
                        default:
                                cfg_dat[adr_i[7:2]] <= dat_i;
                        endcase
                else
                        case(adr_i[7:2])
                        5'h00:  cfg_out <= {CFG_DEVICE_ID,CFG_VENDOR_ID};
                        5'h01:  cfg_out <= {stato_reg,cmdo_reg};
                        5'h02:  cfg_out <= {
                                CFG_CLASS,CFG_SUBCLASS,CFG_PROGIF,CFG_REVISION_ID};
                        5'h03:  cfg_out <= {8'h00,
                                CFG_HEADER_TYPE,latency_timer,CFG_CACHE_LINE_SIZE};
                        5'h04:  cfg_out <= bar0;
                        5'h05:  cfg_out <= bar1;
                        5'h06:  cfg_out <= bar2;
                        5'h07:  cfg_out <= 32'hFFFFFFFF;
                        5'h08:  cfg_out <= 32'hFFFFFFFF;
                        5'h09:  cfg_out <= 32'hFFFFFFFF;
                        5'h0A:  cfg_out <= 32'h0;
                        5'h0B:  cfg_out <= {CFG_SUBSYSTEM_ID,CFG_SUBSYSTEM_VENDOR_ID};
                        5'h0C:  cfg_out <= CFG_ROM_ADDR;
                        5'h0D:  cfg_out <= 32'h0;
                        5'h0E:  cfg_out <= 32'h0;
                        5'h0F:  cfg_out <= {8'd8,8'd0,8'd0,irq_line};
                        default:        cfg_out <= cfg_dat[adr_i[7:2]];
                        endcase
        end
end

always_comb
        irq_o = {31'd0,irq_i & ~int_disable} << irq_line;

always_comb
        cs_bar0_o = ((adr_i ^ bar0) & CFG_BAR0_MASK) == 'd0;
always_comb
        cs_bar1_o = ((adr_i ^ bar1) & CFG_BAR1_MASK) == 'd0;
always_comb
        cs_bar2_o = ((adr_i ^ bar2) & CFG_BAR2_MASK) == 'd0;
        
endmodule