Subversion Repositories forwardcom

//////////////////////////////////////////////////////////////////////////////////

// Engineer: Agner Fog

//

// Create Date:    2020-06-03

// Last modified:  2021-08-02

// Module Name:    data_cache

// Project Name:   ForwardCom soft core

// Target Devices: Artix 7

// Tool Versions:  Vivado v. 2020.1

// License:        CERN-OHL-W v. 2 or later

// Description:    data memory or data cache for read/write data

//

//////////////////////////////////////////////////////////////////////////////////

`include "defines.vh"

// read/write data memory or cache, (2**`DATA_ADDR_WIDTH) bytes = 2**16 = 64kB

module data_memory (

    input clock,                                    // clock

    input clock_enable,                             // clock enable. Used when single-stepping

    input [`COMMON_ADDR_WIDTH-1:0] read_write_addr, // Address for reading and writing from/to ram

                                                    // The lower 3 bits of read_write_addr indicate a byte within an 8 bytes line

    input read_enable,                              // read enable

    input [1:0] read_data_size,                     // 8, 16, 32, or 64 bits read

    input [7:0] write_enable,                       // write enable for each byte separately

    input [63:0] write_data_in,                     // Data in. Always 64 bits. Any part of the write bus can be used when the data size is less than 64 bits

`ifdef DISTRIBUTED_RAM                              // Distributed RAM takes a lot of FPGA resources

    output reg   [`RB1:0] read_data_out             // Data out

`else                                               // Block RAM

    output logic [`RB1:0] read_data_out             // Data out

`endif

);

// read/write data ram

reg [63:0] dataram [0:(2**(`DATA_ADDR_WIDTH-3))-1]; // 64kB RAM

// split read/write address into double-word index, and byte index

logic [`DATA_ADDR_WIDTH-4:0] address_hi;

logic [2:0] address_lo;

logic address_valid;

always_comb begin

    address_hi = read_write_addr[`DATA_ADDR_WIDTH-1:3]; // index to 64-bit lines

    address_lo = read_write_addr[2:0];                  // index to byte within line

    address_valid = read_write_addr[`COMMON_ADDR_WIDTH-1:`DATA_ADDR_WIDTH] == 0; // exclude code addresses

end

// Data write:

always_ff @(posedge clock) if (clock_enable & address_valid) begin

    // write data to RAM. Each byte enabled separately

    if (write_enable[0]) dataram[address_hi][ 7: 0] <= write_data_in[ 7: 0];

    if (write_enable[1]) dataram[address_hi][15: 8] <= write_data_in[15: 8];

    if (write_enable[2]) dataram[address_hi][23:16] <= write_data_in[23:16];

    if (write_enable[3]) dataram[address_hi][31:24] <= write_data_in[31:24];

    if (write_enable[4]) dataram[address_hi][39:32] <= write_data_in[39:32];

    if (write_enable[5]) dataram[address_hi][47:40] <= write_data_in[47:40];

    if (write_enable[6]) dataram[address_hi][55:48] <= write_data_in[55:48];

    if (write_enable[7]) dataram[address_hi][63:56] <= write_data_in[63:56];

end

// data read. Must have natural alignment

`ifdef DISTRIBUTED_RAM

// The multiplexer comes before the register. This is only possible with distributed RAM.

// Distributed RAM takes a lot of FPGA resources but may allow a slightly higher clock frequency.

always_ff @(posedge clock) if (clock_enable & address_valid & read_enable) begin

    // Each 64-bit RAM line may be divided into

    // eight bytes, four 16-bit halfwords, two 32-bit words, or one 64-bit double word:

    case (address_lo)

    0: read_data_out[7:0] <= dataram[address_hi][ 7: 0];

    1: read_data_out[7:0] <= dataram[address_hi][15: 8];

    2: read_data_out[7:0] <= dataram[address_hi][23:16];

    3: read_data_out[7:0] <= dataram[address_hi][31:24];

    4: read_data_out[7:0] <= dataram[address_hi][39:32];

    5: read_data_out[7:0] <= dataram[address_hi][47:40];

    6: read_data_out[7:0] <= dataram[address_hi][55:48];

    7: read_data_out[7:0] <= dataram[address_hi][63:56];

    endcase

    case (address_lo[2:1])

    0: read_data_out[15:8] <= dataram[address_hi][15: 8];

    1: read_data_out[15:8] <= dataram[address_hi][31:24];

    2: read_data_out[15:8] <= dataram[address_hi][47:40];

    3: read_data_out[15:8] <= dataram[address_hi][63:56];

    endcase

    case (address_lo[2])

    0: read_data_out[31:16] <= dataram[address_hi][31:16];

    1: read_data_out[31:16] <= dataram[address_hi][63:48];

    endcase

    `ifdef SUPPORT_64BIT

        read_data_out[63:32] <= dataram[address_hi][63:32];

    `endif

end

`else

// block RAM. The multiplexer must come after the register

reg [63:0] read_data;                    // a whole line read from the RAM

reg [2:0]  address_lo2;                  // address_lo saved

always_ff @(posedge clock) if (clock_enable & address_valid & read_enable) begin

    read_data   <= dataram[address_hi];  // read a 64 bits line from ram

    address_lo2 <= address_lo;           // save low part of address

end

always_comb begin

    // Each 64-bit RAM line may be divided into eight bytes, four 16-bit halfwords,

    // two 32-bit words, or one 64-bit double word.

    // The speed of this multiplexer is very critical because it adds to the delay

    // in the execution unit. We are saving time by not setting unused parts of

    // read_data_out to zero.

    case (address_lo2)

    0: read_data_out[7:0] = read_data[ 7: 0];

    1: read_data_out[7:0] = read_data[15: 8];

    2: read_data_out[7:0] = read_data[23:16];

    3: read_data_out[7:0] = read_data[31:24];

    4: read_data_out[7:0] = read_data[39:32];

    5: read_data_out[7:0] = read_data[47:40];

    6: read_data_out[7:0] = read_data[55:48];

    7: read_data_out[7:0] = read_data[63:56];

    endcase

    case (address_lo2[2:1])

    0: read_data_out[15:8] = read_data[15: 8];

    1: read_data_out[15:8] = read_data[31:24];

    2: read_data_out[15:8] = read_data[47:40];

    3: read_data_out[15:8] = read_data[63:56];

    endcase

    case (address_lo2[2])

    0: read_data_out[31:16] = read_data[31:16];

    1: read_data_out[31:16] = read_data[63:48];

    endcase

    `ifdef SUPPORT_64BIT

        read_data_out[63:32] = read_data[63:32];

    `endif

end

`endif

endmodule