// ==================================================================== // // WD1793, WD1772, WD1773 replica (with write capability) // // Copyright (C) 2007,2008 Viacheslav Slavinsky // Copyright (C) 2016 Sorgelig // // Modifications for track size of 18 x 256 by Stan Hodge (SRH) 9/6/21 // Modifications not to reset the track and sector registers by SRH 12/18/21 // // This program is free software; you can redistribute it and/or modify it // under the terms of the GNU General Public License as published by the Free // Software Foundation; either version 2 of the License, or (at your option) // any later version. // // This program is distributed in the hope that it will be useful, but WITHOUT // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for // more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. // //============================================================================ module wd1793 #(parameter RWMODE=0, EDSK=1) ( input clk_sys, // sys clock input ce, // ce at CPU clock rate input reset, // async reset input io_en, input rd, // i/o read input wr, // i/o write input [1:0] addr, // i/o port addr input [7:0] din, // i/o data in output [7:0] dout, // i/o data out output drq, // DMA request output intrq, output busy, input wp, // write protect input [2:0] size_code, input layout, // 0 = Track-Side-Sector, 1 - Side-Track-Sector input side, input ready, // SD access (RWMODE == 1) input img_mounted, // signaling that new image has been mounted input [19:0] img_size, // size of image in bytes. 1MB MAX! output prepare, output[31:0] sd_lba, output reg sd_rd, output reg sd_wr, input sd_ack, input [8:0] sd_buff_addr, input [7:0] sd_buff_dout, output [7:0] sd_buff_din, input sd_buff_wr, // RAM access (RWMODE == 0) input input_active, input [19:0] input_addr, input [7:0] input_data, input input_wr, output[19:0] buff_addr, // buffer RAM address output buff_read, // buffer RAM read enable input [7:0] buff_din // buffer RAM data input ); // Possible track configs: // 0: 26 x 128 = 3.3KB // 1: 16 x 256 = 4.0KB // 2: 9 x 512 = 4.5KB // 3: 5 x 1024 = 5.0KB // 4: 10 x 512 = 5.0KB // 5: 18 x 256 = 4.5KB (SRH) assign dout = q; assign drq = s_drq; assign busy = s_busy; assign intrq = s_intrq; assign sd_lba = scan_active ? scan_addr[19:9] : buff_a[19:9] + sd_block; //assign sd_lba = scan_active ? scan_addr[19:9] : buff_a[19:8] + sd_block; (SRH) modified for 256 lba...[wrong] assign prepare = EDSK ? scan_active : img_mounted; assign buff_addr = {buff_a[19:9], 9'd0} + byte_addr; assign buff_read = ((addr == A_DATA) && buff_rd); reg [7:0] sectors_per_track, edsk_spt = 0; wire [10:0] sector_size = 11'd128 << wd_size_code; reg [10:0] byte_addr; reg [19:0] buff_a; reg [1:0] wd_size_code; wire [7:0] buff_dout; reg [1:0] sd_block = 0; reg format; generate if(RWMODE) begin wd1793_dpram sbuf ( .clock(clk_sys), .address_a({sd_block, sd_buff_addr}), .data_a(sd_buff_dout), .wren_a(sd_buff_wr & sd_ack), .q_a(sd_buff_din), .address_b(scan_active ? {2'b00, scan_addr[8:0]} : byte_addr), .data_b(format ? 8'd0 : din), .wren_b(wre & buff_wr & (addr == A_DATA) & ~scan_active), .q_b(buff_dout) ); reg buff_wr; end else begin assign buff_dout = 0; assign sd_buff_din = 0; end endgenerate reg var_size = 0; reg [19:0] disk_size; reg layout_r; wire [19:0] hs = (layout_r & side) ? disk_size >> 1 : 20'd0; wire [7:0] dts = {disk_track[6:0], side} >> layout_r; always @(posedge clk_sys) begin case({var_size,size_code}) 0: buff_a <= hs + {{1'b0, dts, 4'b0000} + {dts, 3'b000} + {dts, 1'b0} + wdreg_sector - 1'd1, 7'd0}; 1: buff_a <= hs + {{dts, 4'b0000} + wdreg_sector - 1'd1, 8'd0}; 2: buff_a <= hs + {{dts, 3'b000} + dts + wdreg_sector - 1'd1, 9'd0}; 3: buff_a <= hs + {{dts, 2'b00} + dts + wdreg_sector - 1'd1, 10'd0}; 4: buff_a <= hs + {{dts, 3'b000} +{dts, 1'b0} + wdreg_sector - 1'd1, 9'd0}; 5: buff_a <= hs + {{dts, 4'b0000} +{dts, 1'b0} + wdreg_sector - 1'd1, 8'd0}; //(SRH) default: buff_a <= edsk_offset; endcase case({var_size,size_code}) 0: sectors_per_track <= 26; 1: sectors_per_track <= 16; 2: sectors_per_track <= 9; 3: sectors_per_track <= 5; 4: sectors_per_track <= 10; 5: sectors_per_track <= 18; //(SRH) default: sectors_per_track <= edsk_spt; endcase case({var_size,size_code}) 0: wd_size_code <= 0; 1: wd_size_code <= 1; 2: wd_size_code <= 2; 3: wd_size_code <= 3; 4: wd_size_code <= 2; 5: wd_size_code <= 1; //(SRH) default: wd_size_code <= edsk_sizecode; endcase end reg [1:0] blk_size; always @* begin case(wd_size_code) 0: blk_size = 0; 1: blk_size = 0; 2: blk_size = buff_a[8:0] ? 2'd1 : 2'd0; 3: blk_size = buff_a[8:0] ? 2'd2 : 2'd1; endcase end // Register addresses localparam A_COMMAND = 0; localparam A_STATUS = 0; localparam A_TRACK = 1; localparam A_SECTOR = 2; localparam A_DATA = 3; // States typedef enum { STATE_IDLE, STATE_SEARCH, STATE_SEARCH_1, STATE_WAIT_READ, STATE_WAIT_READ_1, STATE_WAIT_READ_2, STATE_READ, STATE_READ_1, STATE_READ_2, STATE_READ_3, STATE_WAIT_WRITE, STATE_WAIT_WRITE_1, STATE_WAIT_WRITE_2, STATE_WRITE, STATE_WRITE_1, STATE_WRITE_2, STATE_ABORT, STATE_WAIT, STATE_WAIT_2, STATE_ENDCOMMAND } io_state_t; // common status bits wire s_readonly = (wp | !RWMODE); reg s_crcerr; reg s_headloaded, s_seekerr, s_index; // mode 1 reg s_lostdata, s_wrfault; // mode 2,3 // Command mode 0/1 for status register reg cmd_mode; // allow write protect flag reg s_wpe; // DRQ/BUSY are always going together reg [1:0] s_drq_busy; wire s_drq = s_drq_busy[1]; wire s_busy = s_drq_busy[0]; reg s_intrq; reg [7:0] wdreg_track; reg [7:0] wdreg_sector; reg [7:0] wdreg_data; wire [7:0] wdreg_status = cmd_mode == 0 ? {~ready, s_readonly & s_wpe, s_headloaded, s_seekerr | ~ready, s_crcerr, !disk_track, s_index, s_busy}: {~ready, s_readonly & s_wpe, s_wrfault, s_seekerr | ~ready, s_crcerr, s_lostdata, s_drq, s_busy}; reg [7:0] read_addr[6]; reg [7:0] q; always @* begin case (addr) A_STATUS: q = wdreg_status; A_TRACK: q = wdreg_track; A_SECTOR: q = wdreg_sector; A_DATA: q = (state == STATE_IDLE) ? wdreg_data : buff_rd ? (RWMODE ? buff_dout : buff_din) : read_addr[byte_addr[2:0]]; endcase end reg buff_rd; reg step_direction; // last step direction reg [7:0] disk_track; // "real" heads position reg [10:0] data_length; // this many bytes to transfer during read/write ops io_state_t state = STATE_IDLE; // Reusable expressions wire [7:0] next_track = (din[6] ? din[5] : step_direction) ? disk_track - 1'd1 : disk_track + 1'd1; wire [10:0] next_length = data_length - 1'b1; // Watchdog reg watchdog_set; wire watchdog_bark = (wd_timer == 0); reg [15:0] wd_timer; always @(posedge clk_sys) begin if(ce) begin if(watchdog_set) wd_timer <= 4096; else if(wd_timer != 0) wd_timer <= wd_timer - 1'b1; end end always @(posedge clk_sys) begin reg [23:0] cnt; if(ce) begin if(ready) begin if(cnt) cnt <= cnt - 1'b1; // else cnt <= 35000; else cnt <= 24'd1718400; end else cnt <= 0; s_index <= (cnt < 24'd1000); end end wire rde = rd & io_en; wire wre = wr & io_en; always @(posedge clk_sys) begin reg old_wr, old_rd; reg [2:0] cur_addr; reg read_data; reg write_data; reg rw_type; integer wait_time; reg [3:0] read_timer; reg [9:0] seektimer; reg [7:0] ra_sector; reg multisector; reg write; reg [5:0] ack; reg sd_busy; reg old_mounted; reg [3:0] scan_state; reg [1:0] scan_cnt; reg [1:0] blk_max; if(RWMODE) begin old_mounted <= img_mounted; if(old_mounted && ~img_mounted) begin if(EDSK) begin scan_active<= 1; scan_addr <= 0; scan_state <= 0; scan_wr <= 0; sd_block <= 0; end disk_size <= img_size[19:0]; layout_r <= layout; end end else begin scan_active <= input_active; scan_addr <= input_addr; scan_wr <= input_wr; if(scan_active & ~input_active) begin disk_size <= input_addr + 1'd1; layout_r <= layout; end end if(reset & ~scan_active) begin read_data <= 0; write_data <= 0; multisector <= 0; step_direction <= 0; // disk_track <= 0; // wdreg_track <= 0; // wdreg_sector <= 0; wdreg_data <= 0; data_length <= 0; byte_addr <=0; buff_rd <= 0; if(RWMODE) buff_wr <= 0; state <= STATE_IDLE; cmd_mode <= 0; s_wpe <= 1; {s_headloaded, s_seekerr, s_crcerr, s_intrq} <= 0; {s_wrfault, s_lostdata} <= 0; s_drq_busy <= 0; watchdog_set <= 0; seektimer <= 'h3FF; {ack, sd_wr, sd_rd, sd_busy} <= 0; ra_sector <= 1; end else if(ce) begin ack <= {ack[4:0], sd_ack}; if(ack[5:4] == 'b01) {sd_rd,sd_wr} <= 0; if(ack[5:4] == 'b10) sd_busy <= 0; if(RWMODE & scan_active) begin if(scan_addr >= img_size) scan_active <= 0; else begin case(scan_state) 0: begin sd_rd <= 1; sd_busy <= 1; scan_wr <= 0; scan_state <= 1; end 1: if(!sd_busy) begin scan_wr <= 1; scan_cnt <= 1; scan_state <= 2; end 2: begin scan_cnt <= scan_cnt + 1'd1; if(!scan_cnt) begin scan_wr <= ~scan_wr; if(scan_wr) begin scan_addr <= scan_addr + 1'b1; if(&scan_addr[8:0]) begin scan_active <= var_size; scan_state <= 0; end end end end endcase end end old_wr <=wre; old_rd <=rde; if((!old_rd && rde) || (!old_wr && wre)) cur_addr <= addr; //Register read operations if(old_rd && !rde && (cur_addr == A_STATUS)) s_intrq <= 0; //end of data reading if(old_rd && !rde && (cur_addr == A_DATA)) read_data <=1; //end of data writing if(old_wr && !wre && (cur_addr == A_DATA)) write_data <=1; case (state) /* Idle state or buffer to host transfer */ STATE_IDLE:; // do nothing STATE_SEARCH: begin if(!ready) begin s_seekerr <= 1; state <= STATE_ENDCOMMAND; end else begin seektimer <= seektimer - 1'b1; if(!seektimer) begin byte_addr <= 0; if(var_size) begin if(~format) edsk_addr <= edsk_start; if(EDSK) spt_addr <= (side ? spt_size>>1 : 8'd0) + disk_track; state <= STATE_SEARCH_1; end else begin if(!wdreg_sector || (wdreg_sector > sectors_per_track)) begin if(~format) s_seekerr <= 1; state <= STATE_ENDCOMMAND; end else begin state <= rw_type ? STATE_WAIT_READ : STATE_READ; end end end end end STATE_SEARCH_1: begin if(rw_type & (edsk_track == disk_track) & (edsk_side == side) & (format | (edsk_sector == wdreg_sector))) begin state <= STATE_WAIT_READ; end else if(~rw_type & (edsk_track == disk_track) & (edsk_side == side)) begin read_addr[0] <= edsk_trackf; read_addr[1] <= edsk_sidef; read_addr[2] <= edsk_sector; read_addr[3] <= edsk_sizecode; state <= STATE_READ; end else if(edsk_next == edsk_start) begin if(~format) s_seekerr <= 1; state <= STATE_ENDCOMMAND; end else begin edsk_addr <= edsk_next; end end // read before write in case if sector not aligned or smaller than 512b STATE_WAIT_READ: begin data_length <= sector_size; byte_addr <= buff_a[8:0]; blk_max <= blk_size; sd_block <= 0; state <= RWMODE ? STATE_WAIT_READ_1 : write ? STATE_WRITE : STATE_READ; end STATE_WAIT_READ_1: begin sd_busy <= 1; sd_rd <= 1; state <= STATE_WAIT_READ_2; end STATE_WAIT_READ_2: begin if(!sd_busy) begin sd_block <= sd_block + 1'd1; state <= write ? STATE_WRITE : STATE_READ; if(sd_block < blk_max) state <= STATE_WAIT_READ_1; end end STATE_READ: begin watchdog_set <= 1; read_timer <= 15; state <= STATE_READ_1; end STATE_READ_1: begin read_timer <= read_timer - 1'b1; if(!read_timer) begin read_data <= 0; watchdog_set <= 0; s_lostdata <= 0; s_drq_busy <= 2'b11; state <= STATE_READ_2; end end STATE_READ_2: begin if(watchdog_bark | (read_data & s_drq)) begin // reset drq until next byte is read, nothing is lost s_drq_busy <= 2'b01; s_lostdata <= watchdog_bark; if(next_length == 0) begin // either read the next sector, or stop if this is track end if(multisector) begin wdreg_sector <= wdreg_sector + 1'b1; state <= STATE_SEARCH; end else begin state <= STATE_ENDCOMMAND; end end else begin byte_addr <= byte_addr + 1'd1; data_length <= next_length; state <= STATE_READ; end end end STATE_WAIT_WRITE: begin if(!ready) begin s_wrfault <= 1; state <= STATE_ENDCOMMAND; end else begin sd_block <= 0; state <= STATE_WAIT_WRITE_1; end end STATE_WAIT_WRITE_1: begin sd_busy <= 1; sd_wr <= 1; state <= STATE_WAIT_WRITE_2; end STATE_WAIT_WRITE_2: begin if(!sd_busy) begin sd_block <= sd_block + 1'd1; if(sd_block < blk_max) state <= STATE_WAIT_WRITE_1; else begin if(format && var_size && !edsk_next) begin state <= STATE_ENDCOMMAND; end else if(multisector) begin edsk_addr <= edsk_next; wdreg_sector <= wdreg_sector + 1'b1; state <= STATE_SEARCH; end else begin state <= STATE_ENDCOMMAND; end end end end STATE_WRITE: begin watchdog_set <= 1; read_timer <= 15; state <= STATE_WRITE_1; end STATE_WRITE_1: begin read_timer <= read_timer - 1'b1; if(!read_timer) begin write_data <= 0; watchdog_set <= 0; s_lostdata <= 0; s_drq_busy <= 2'b11; state <= STATE_WRITE_2; end end STATE_WRITE_2: begin if(watchdog_bark | (write_data & s_drq)) begin s_drq_busy <= 2'b01; s_lostdata <= watchdog_bark; if(!next_length) state <= STATE_WAIT_WRITE; else begin byte_addr <= byte_addr + 1'd1; data_length <= next_length; state <= STATE_WRITE; end end end // Abort current operation ($D0) STATE_ABORT: begin data_length <= 0; {s_wrfault,s_seekerr,s_crcerr,s_lostdata} <= 0; state <= STATE_ENDCOMMAND; end STATE_WAIT: begin wait_time <= 4000; state <= STATE_WAIT_2; end STATE_WAIT_2: begin if(wait_time) wait_time <= wait_time - 1; else state <= STATE_ENDCOMMAND; end // End any command. STATE_ENDCOMMAND: begin format <= 0; buff_rd <= 0; if(RWMODE) buff_wr <=0; state <= STATE_IDLE; s_drq_busy <= 2'b00; seektimer <= 'h3FF; s_intrq <= 1; end endcase /* Register write operations */ if (!old_wr & wre) begin case (addr) A_COMMAND: begin s_intrq <= 0; if((state == STATE_IDLE) | (din[7:4] == 'hD)) begin cmd_mode <= din[7]; s_wpe <= ~din[7]; case (din[7:4]) 'h0: // RESTORE begin // head load as specified, index, track0 s_headloaded <= din[3]; wdreg_track <= 0; disk_track <= 0; // some programs like it when FDC gets busy for a while s_drq_busy <= 2'b01; state <= STATE_WAIT; end 'h1: // SEEK begin // set real track to datareg disk_track <= wdreg_data; s_headloaded <= din[3]; // fixed seek wdreg_track <= wdreg_data; // get busy s_drq_busy <= 2'b01; state <= STATE_WAIT; end 'h2, // STEP 'h3, // STEP & UPDATE 'h4, // STEP-IN 'h5, // STEP-IN & UPDATE 'h6, // STEP-OUT 'h7: // STEP-OUT & UPDATE begin // if direction is specified, store it for the next time if (din[6] == 1) step_direction <= din[5]; // 0: forward/in // perform step disk_track <= next_track; // update TRACK register too if asked to if (din[4]) wdreg_track <= next_track; s_headloaded <= din[3]; // some programs like it when FDC gets busy for a while s_drq_busy <= 2'b01; state <= STATE_WAIT; end 'h8, 'h9, // READ SECTORS 'hA, 'hB: // WRITE SECTORS begin // seek data // 5: 0: read, 1: write // 4: m: 0: one sector, 1: until the track ends // 3: S: SIDE // 2: E: some 15ms delay // 1: C: check side matching? // 0: 0 s_drq_busy <= 2'b01; {s_wrfault,s_seekerr,s_crcerr,s_lostdata} <= 0; {write,buff_rd} <= din[5] ? 2'b10 : 2'b01; if(RWMODE) buff_wr <= din[5]; if(din[6]) wdreg_sector <= 1; format <= din[6]; multisector <= din[4]; rw_type <= 1; write_data <= 0; read_data <= 0; edsk_start <= 0; edsk_addr <= 0; state <= STATE_SEARCH; s_wpe <= din[5]; if(s_readonly & din[5]) begin s_wrfault <= 1; state <= STATE_WAIT; end end 'hC: // READ ADDRESS begin // track, side, sector, sector size code, 2-byte checksum (crc?) s_drq_busy <= 2'b01; {s_wrfault,s_seekerr,s_crcerr,s_lostdata} <= 0; {write,buff_rd} <= 0; if(RWMODE) buff_wr <=0; format <= 0; multisector <= 0; rw_type <= 0; read_data <= 0; edsk_start <= edsk_next; data_length <= 6; read_addr[0] <= disk_track; read_addr[1] <= {7'b0, side}; read_addr[2] <= ra_sector; read_addr[3] <= wd_size_code; read_addr[4] <= 0; read_addr[5] <= 0; if(ra_sector >= sectors_per_track) ra_sector <= 1; else ra_sector <= ra_sector + 1'd1; state <= STATE_SEARCH; end 'hD: // interrupt begin cmd_mode <= 0; if(state != STATE_IDLE) state <= STATE_ABORT; else {s_wrfault,s_seekerr,s_crcerr,s_lostdata, s_drq_busy} <= 0; end 'hF: // WRITE TRACK begin s_wpe <= din[5]; {s_wrfault,s_seekerr,s_crcerr,s_lostdata} <= 0; s_drq_busy <= 2'b01; state <= STATE_WAIT; end 'hE: // READ TRACK begin {s_wrfault,s_crcerr,s_lostdata} <= 0; s_seekerr <= 1; s_drq_busy <= 2'b01; state <= STATE_WAIT; end endcase end end A_TRACK: if (!s_busy) wdreg_track <= din; A_SECTOR: if (!s_busy) {ra_sector, wdreg_sector} <= {din,din}; A_DATA: wdreg_data <= din; endcase end end end reg scan_active = 0; reg [19:0] scan_addr; reg scan_wr; reg [1:0] edsk_sizecode = 0; // sector size: 0=128K, 1=256K, 2=512K, 3=1024K reg edsk_side = 0; // Side number (0 or 1) reg [6:0] edsk_track = 0; // Track number reg [7:0] edsk_sector = 0; // Sector number 0..15 reg [19:0] edsk_offset = 0; reg [7:0] edsk_trackf = 0, edsk_sidef = 0; reg [10:0] edsk_addr, edsk_start; reg [10:0] edsk_size = 0; wire[10:0] edsk_next = ((edsk_addr + 1'd1) >= edsk_size) ? 11'd0 : edsk_addr + 1'd1; reg [7:0] spt_size = 0; generate if(EDSK) begin wire [7:0] scan_data = RWMODE ? buff_dout : input_data; reg [53:0] edsk[1992]; reg [7:0] spt[166]; reg [7:0] spt_addr; always @(posedge clk_sys) begin {edsk_track,edsk_side,edsk_trackf,edsk_sidef,edsk_sector,edsk_sizecode,edsk_offset} <= edsk[edsk_addr]; edsk_spt <= spt[spt_addr]; end reg [7:0] tpos; reg [7:0] tsize; reg [7:0] tsizes[166]; always @(posedge clk_sys) tsize <= tsizes[tpos]; wire[127:0] edsk_sig = "EXTENDED CPC DSK"; wire[127:0] sig_pos = edsk_sig >> (8'd120-(scan_addr[7:0]<<3)); always @(posedge clk_sys) begin reg old_active, old_wr; reg [13:0] hdr_pos, bcnt; reg [7:0] idStatus; reg [6:0] track; reg side; reg [7:0] sector; reg [1:0] sizecode; reg [7:0] crc1; reg [7:0] crc2; reg [7:0] sectors; reg [15:0] track_size, track_pos; reg [19:0] offset, offset1; reg [7:0] size_lo; reg [10:0] secpos; reg [7:0] trackf, sidef; old_active <= scan_active; if(scan_active & ~old_active) begin edsk_size <=0; spt_size <=0; track_pos <=0; var_size <=1; end old_wr <= scan_wr; if(scan_wr & ~old_wr & scan_active) begin if((scan_addr[19:0] < 16) & (sig_pos[7:0] != scan_data)) var_size <= 0; if(var_size) begin if( scan_addr == 48) spt_size <= scan_data; else if((scan_addr == 49) & (scan_data == 2)) spt_size <= spt_size << 1; else if( scan_addr == 52) begin track_size <= {scan_data, 8'd0}; track_pos <= 0; tpos <= 1; end else if((scan_addr > 52) & (scan_addr < 218)) begin tsizes[scan_addr - 52] <= scan_data; spt[scan_addr - 52] <= 0; end else if((scan_addr >= 256) && track_size) begin track_pos <= track_pos + 1'd1; case(track_pos) 00: offset <= scan_addr + 9'd256; 16: track <= scan_data[6:0]; 17: side <= scan_data[0]; 21: sectors <= scan_data; 22: spt[(side ? (spt_size >> 1) : 8'd0) + track] <= sectors; default: if((track_pos >= 24) && sectors) begin case(track_pos[2:0]) 0: begin trackf <= scan_data; secpos <= edsk_size; offset1 <= offset; end 1: sidef <= scan_data; 2: sector <= scan_data; 3: sizecode<= scan_data[1:0]; 6: size_lo <= scan_data; 7: begin if({scan_data, size_lo}) begin edsk[secpos] <= {track,side,trackf,sidef,sector,sizecode,offset1}; edsk_size <= edsk_size + 1'd1; offset <= offset + {scan_data, size_lo}; end sectors <= sectors - 1'd1; end default:; endcase end endcase if(track_pos >= (track_size - 1'd1)) begin track_size <= {tsize, 8'd0}; track_pos <= 0; tpos <= tpos + 1'd1; end end end end end end endgenerate endmodule module wd1793_dpram #(parameter DATAWIDTH=8, ADDRWIDTH=11) ( input clock, input [ADDRWIDTH-1:0] address_a, input [DATAWIDTH-1:0] data_a, input wren_a, output reg [DATAWIDTH-1:0] q_a, input [ADDRWIDTH-1:0] address_b, input [DATAWIDTH-1:0] data_b, input wren_b, output reg [DATAWIDTH-1:0] q_b ); logic [DATAWIDTH-1:0] ram[0:(1<