2 Copyright (c) 2013, IIT Madras
5 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
7 * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
8 * 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.
9 * Neither the name of IIT Madras nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
11 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.
12 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
17 To use the following registers:
20 > Memory mapped mode should continue to fetch data and fill the fifo even if the Core
22 * Done Status polling mode.
23 > This could not be replicated since the tof flag is set.
24 Memory mapped mode with dcyc =10 creates an extra cycle after Dummy phase.
25 > Data Read phase is on posedge and Data write is on negdege
26 -- send the received arid and bid's so that DMA can identify. duplicate instead of extend
30 import Semi_FIFOF :: *;
31 import AXI4_Lite_Types :: *;
32 import AXI4_Lite_Fabric :: *;
35 import SpecialFIFOs::*;
37 import DefaultValue :: *;
38 `include "instance_defines.bsv"
42 import UniqueWrappers :: * ;
45 (*always_ready, always_enabled*)
47 /*(* always_ready, result="clk_o" *) */
48 interface Get#(Bit#(1)) clk_o;
49 /*(* always_ready, result="io_o" *) */
50 interface Get#(Bit#(4)) io_o;
51 /*(* always_ready, result="io0_sdio_ctrl" *) */
52 method Bit#(9) io0_sdio_ctrl;
53 /*(* always_ready, result="io1_sdio_ctrl" *) */
54 method Bit#(9) io1_sdio_ctrl;
55 /*(* always_ready, result="io2_sdio_ctrl" *) */
56 method Bit#(9) io2_sdio_ctrl;
57 /*(* always_ready, result="io3_sdio_ctrl" *) */
58 method Bit#(9) io3_sdio_ctrl;
59 /*(* always_ready, result="io_enable" *)*/
60 interface Get#(Bit#(4)) io_enable;
61 /*(* always_ready, always_enabled *) */
62 //method Action io_i ((* port="io_i" *) Bit#(4) io_in); // in
63 interface Put#(Bit#(4)) io_i;
64 /*(* always_ready, result="ncs_o" *) */
65 interface Get#(Bit#(1)) ncs_o;
69 interface QSPI_out out;
70 interface AXI4_Lite_Slave_IFC#(`PADDR,`Reg_width,`USERSPACE) slave;
71 method Bit#(6) interrupts; // 0=TOF, 1=SMF, 2=Threshold, 3=TCF, 4=TEF 5 = request_ready
73 method Phase curphase;
77 function Reg#(t) readOnlyReg(t r);
78 return (interface Reg;
80 method Action _write(t x) = noAction;
84 function Reg#(t) conditionalWrite(Reg#(t) r, Bool a);
85 return (interface Reg;
86 method t _read = r._read;
87 method Action _write(t x);
94 function Reg#(t) clearSideEffect(Reg#(t) r, Action a, Action b)
95 provisos( Literal#(t),Eq#(t));
96 return (interface Reg;
97 method t _read = r._read;
98 method Action _write(t x);
108 function Reg#(Bit#(32)) writeSideEffect(Reg#(Bit#(32)) r, Action a);
109 return (interface Reg;
110 method Bit#(32) _read = r._read;
111 method Action _write(Bit#(32) x);
118 function Reg#(Bit#(n)) writeCCREffect(Reg#(Bit#(n)) r, Action a, Action b);
119 return (interface Reg;
120 method Bit#(n) _read = r._read;
121 method Action _write(Bit#(n) x);
123 `ifdef verbose1 $display("x: %h",x); `endif
124 if(x[11:10]==0 && (x[27:26] == 'b00 || x[27:26]=='b01 || x[25:24]=='b0) && x[9:8]!=0) begin // no address required and nodata from firmware (i.e. no write)
127 if(x[27:26]=='b11) //Memory Mapped Mode
133 typedef enum {Instruction_phase=0,
135 AlternateByte_phase=2,
139 Idle=6} Phase deriving (Bits,Eq,FShow);
142 module mkqspi(Ifc_qspi);
144 AXI4_Lite_Slave_Xactor_IFC #(`PADDR, `Reg_width, `USERSPACE) s_xactor <- mkAXI4_Lite_Slave_Xactor;
145 /*************** List of implementation defined Registers *****************/
146 Reg#(bit) rg_clk <-mkReg(1);
147 Reg#(Bit#(8)) rg_clk_counter<-mkReg(0);
148 MIMOConfiguration cfg=defaultValue;
150 MIMO#(4,4,16,Bit#(8)) fifo <-mkMIMO(cfg);
151 Reg#(Phase) rg_phase <-mkReg(Idle);
152 Reg#(Phase) rg_phase_delayed <-mkReg(Idle);
153 Reg#(Bit#(4)) rg_output <-mkReg(0);
154 Reg#(Bit#(4)) rg_output_en <-mkReg(0);
155 Reg#(Bool) rg_input_en <-mkReg(False);
156 Wire#(Bit#(4)) rg_input <-mkDWire(0);
157 Reg#(Bit#(32)) rg_count_bits <-mkReg(0); // count bits to be transfered
158 Reg#(Bit#(32)) rg_count_bytes <-mkReg(0); // count bytes to be transfered
159 Wire#(Bool) wr_sdr_clock <-mkDWire(False); // use this to trigger posedge of sclk
160 Reg#(Bool) wr_sdr_delayed <- mkReg(False);
161 Reg#(Bool) wr_instruction_written<-mkDReg(False); // this wire is se when the instruction is written by the AXI Master
162 Reg#(Bool) wr_address_written<-mkDReg(False); // this wire is set when the address is written by the AXI Master
163 Reg#(Bool) wr_read_request_from_AXI<-mkDReg(False); // this wire is set when the address is written by the AXI Master
164 Reg#(Bool) wr_data_written<-mkDReg(False); // this wire is set when the data is written by the AXI Master
165 Reg#(Bool) instruction_sent<-mkReg(False); // This register is set when the instruction has been sent once to the flash
166 Reg#(Bit#(1)) ncs <-mkReg(1); // this is the chip select
167 Reg#(Bit#(1)) delay_ncs <-mkReg(1); // this is the chip select
168 Wire#(Bool) wr_status_read<-mkDWire(False); // this wire is set when the status register is written
169 Wire#(Bool) wr_data_read<-mkDWire(False); // this wire is set when the data register is written
170 Reg#(Bool) half_cycle_delay<-mkReg(False);
171 Reg#(Bit#(16)) timecounter<-mkReg(0);
172 Reg#(Bool) read_true <- mkReg(False);
173 Reg#(Bool) first_read <- mkReg(False);
174 /*************** End of implementation defined Registers *****************/
176 /*************** List of QSPI defined Registers *****************/
177 Reg#(Bit#(1)) sr_busy <-mkConfigReg(0); // set when the operation is in progress.
178 Reg#(Bit#(5)) sr_flevel <-mkReg(0); // FIFO Level. Number of valid bytes held in the FIFO. 0: empty
179 Reg#(Bit#(1)) sr_tof <-mkReg(0); // set when the timeout occurs.
180 Reg#(Bit#(1)) sr_smf <-mkReg(0); // set when the unmasked receieved data matches psmar.
181 Reg#(Bit#(1)) sr_ftf <-mkReg(0); // set when the FIFO threshold is reached.
182 Reg#(Bit#(1)) sr_tcf <-mkReg(0); // set when programmed number of data has been transfered or when aborted.
183 Reg#(Bit#(1)) delay_sr_tcf <-mkReg(0); // set when programmed number of data has been transfered or when aborted.
184 Reg#(Bit#(1)) sr_tef <-mkReg(0); // set when an error occurs on transfer.
185 Reg#(Bit#(32)) sr = concatReg9(readOnlyReg(19'd0),readOnlyReg(sr_flevel),readOnlyReg(2'd0),readOnlyReg(sr_busy),readOnlyReg(sr_tof),readOnlyReg(sr_smf),readOnlyReg(sr_ftf),readOnlyReg(sr_tcf),readOnlyReg(sr_tef));
188 Reg#(Bit#(8)) prescaler<-mkReg(0);
189 Reg#(Bit#(8)) cr_prescaler=conditionalWrite(prescaler,sr_busy==0); // prescaler register part of the control register.
190 Reg#(Bit#(1)) pmm <-mkReg(0);
191 Reg#(Bit#(1)) cr_pmm =conditionalWrite(pmm,sr_busy==0); // polling match mode. 0: AND match and 1: OR match.
192 Reg#(Bit#(1)) apms <-mkReg(0);
193 Reg#(Bit#(1)) cr_apms =conditionalWrite(apms,sr_busy==0); // automatic poll mode stop. 1: stop when match. 0: stopped by disabling qspi.
194 Reg#(Bit#(1)) cr_toie <-mkReg(0); // enabled interrupt on time-out.
195 Reg#(Bit#(1)) cr_smie <-mkReg(0); // enables status match interrupt.
196 Reg#(Bit#(1)) cr_ftie <-mkReg(0); // enables interrupt on FIFO threshold.
197 Reg#(Bit#(1)) cr_tcie <-mkReg(0); // enables interrupt on completion of transfer.
198 Reg#(Bit#(1)) cr_teie <-mkReg(0); // enables interrupt on error of transfer.
199 Reg#(Bit#(4)) cr_fthres<-mkReg(0); // defines the number of bytes in the FIFO that will cause the FTF in sr to be raised.
200 Reg#(Bit#(1)) fsel<-mkReg(0);
201 Reg#(Bit#(1)) cr_fsel=conditionalWrite(fsel,sr_busy==0); // used for flash memory selection TODO: Not required.
202 Reg#(Bit#(1)) dfm<-mkReg(0);
203 Reg#(Bit#(1)) cr_dfm =conditionalWrite(dfm,sr_busy==0); // used for dual flash mode TODO: Not required.
204 Reg#(Bit#(1)) sshift<-mkReg(0);
205 Reg#(Bit#(1)) cr_sshift =conditionalWrite(sshift,sr_busy==0); // sample shift to account for delays from the flash. TODO: Might not be required.
206 Reg#(Bit#(1)) tcen<-mkReg(0);
207 Reg#(Bit#(1)) cr_tcen =conditionalWrite(tcen,sr_busy==0); // enables the timeout counter.
208 Reg#(Bit#(1)) cr_dmaen <- mkReg(0); // enables the dma transfer.
209 Reg#(Bit#(1)) cr_abort <- mkReg(0); // this bit aborts the ongoing transaction.
210 Reg#(Bit#(1)) cr_en <-mkReg(0); // this bit enables the qspi.
211 Reg#(Bit#(32)) cr=concatReg19(cr_prescaler,cr_pmm,cr_apms,readOnlyReg(1'b0),cr_toie,cr_smie,cr_ftie,cr_tcie,cr_teie,readOnlyReg(4'd0),cr_fthres,cr_fsel,cr_dfm,readOnlyReg(1'b0),cr_sshift,cr_tcen,cr_dmaen,cr_abort,cr_en);
213 Reg#(Bit#(5)) fsize<-mkReg(0);
214 Reg#(Bit#(5)) dcr_fsize =conditionalWrite(fsize,sr_busy==0); // flash memory size.
215 Reg#(Bit#(3)) csht <-mkReg(0);
216 Reg#(Bit#(3)) dcr_csht = conditionalWrite(csht,sr_busy==0); // chip select high time.
217 Reg#(Bit#(1)) ckmode <-mkReg(0);
218 Reg#(Bit#(1)) dcr_ckmode =conditionalWrite(ckmode,sr_busy==0); // mode 0 or mode 3.
219 Reg#(Bit#(8)) dcr_mode_byte <- mkReg(0);
220 Reg#(Bit#(32)) dcr = concatReg7(readOnlyReg(3'd0),dcr_mode_byte,dcr_fsize,readOnlyReg(5'd0),dcr_csht,readOnlyReg(7'd0),dcr_ckmode);
221 Reg#(Bit#(32)) rg_mode_bytes = concatReg2(dcr_mode_byte,readOnlyReg(24'd0));
222 Reg#(Bit#(5)) rg_mode_byte_counter <- mkReg('d31);
224 Reg#(Bit#(1)) fcr_ctof <-mkReg(0); // writing 1 clears the sr_tof flag.
225 Reg#(Bit#(1)) fcr_csmf <-mkReg(0); // writing 1 clears the sr_smf flag.
226 Reg#(Bit#(1)) fcr_ctcf <-mkReg(0); // writing 1 clears the sr_tcf flag.
227 Reg#(Bit#(1)) fcr_ctef <-mkReg(0); // writing 1 clears the sr_tef flag.
228 Reg#(Bit#(32)) fcr=concatReg6(readOnlyReg(27'd0),clearSideEffect(fcr_ctof,sr_tof._write(0),noAction),clearSideEffect(fcr_csmf,sr_smf._write(0),noAction),readOnlyReg(1'b0),clearSideEffect(fcr_ctcf,sr_tcf._write(0),delay_sr_tcf._write(0)),clearSideEffect(fcr_ctef,sr_tef._write(0),noAction));
230 Reg#(Bit#(32)) data_length<-mkReg(0);
231 Reg#(Bit#(32)) dlr=conditionalWrite(data_length,sr_busy==0); // data length register
233 Reg#(Bit#(1)) ddrm<-mkReg(0);
234 Reg#(Bit#(1)) ccr_ddrm =conditionalWrite(ddrm,sr_busy==0); // double data rate mode.
235 Reg#(Bit#(1)) dhhc <-mkReg(0);
236 Reg#(Bit#(1)) ccr_dhhc =conditionalWrite(dhhc,sr_busy==0); // delay output by 1/4 in DDR mode. TODO: Not required.
237 Reg#(Bit#(1)) sioo <-mkReg(0);
238 Reg#(Bit#(1)) ccr_sioo =conditionalWrite(sioo,sr_busy==0); // send instruction based on mode selected.
239 Reg#(Bit#(2)) fmode <-mkReg(0);
240 Reg#(Bit#(2)) ccr_fmode =conditionalWrite(fmode,sr_busy==0); // 00: indirect Read, 01: indirect Write, 10: Auto polling, 11: MMapped.
241 Reg#(Bit#(2)) dmode <-mkReg(0);
242 Reg#(Bit#(2)) ccr_dmode =conditionalWrite(dmode,sr_busy==0); // data mode. 01: single line, 10: two line, 11: four lines.
243 Reg#(Bit#(5)) dcyc <-mkReg(0);
244 Reg#(Bit#(5)) ccr_dcyc =conditionalWrite(dcyc,sr_busy==0); // number of dummy cycles.
245 Reg#(Bit#(2)) absize <-mkReg(0);
246 Reg#(Bit#(2)) ccr_absize=conditionalWrite(absize,sr_busy==0); // number of alternate byte sizes.
247 Reg#(Bit#(2)) abmode <-mkReg(0);
248 Reg#(Bit#(2)) ccr_abmode=conditionalWrite(abmode,sr_busy==0); // alternate byte mode.
249 Reg#(Bit#(2)) adsize <-mkReg(0);
250 Reg#(Bit#(2)) ccr_adsize=conditionalWrite(adsize,sr_busy==0); // address size.
251 Reg#(Bit#(2)) admode <-mkReg(0);
252 Reg#(Bit#(2)) ccr_admode=conditionalWrite(admode,sr_busy==0); // address mode.
253 Reg#(Bit#(2)) imode <-mkReg(0);
254 Reg#(Bit#(2)) ccr_imode =conditionalWrite(imode,sr_busy==0); // instruction mode.
255 Reg#(Bit#(8)) instruction <-mkReg(0);
256 Reg#(Bit#(8)) ccr_instruction =conditionalWrite(instruction,sr_busy==0); // instruction to be sent externally.
257 Reg#(Bit#(1)) ccr_dummy_confirmation <- mkReg(0); //Programming Dummy confirmation bit needed by Micron model to trigger XIP mode
258 Reg#(Bit#(1)) ccr_dummy_bit <- mkReg(0); //Dummy bit to be sent
259 Reg#(Bit#(32)) ccr =writeCCREffect(concatReg14(ccr_ddrm,ccr_dhhc,ccr_dummy_bit,ccr_sioo,ccr_fmode,ccr_dmode,ccr_dummy_confirmation,ccr_dcyc,ccr_absize,ccr_abmode,ccr_adsize,ccr_admode,ccr_imode,ccr_instruction),wr_instruction_written._write(True),first_read._write(True));
261 Reg#(Bit#(32)) mm_data_length <-mkConfigReg(0);
262 Reg#(Bit#(28)) mm_address <-mkConfigReg(0);
263 Reg#(Bit#(28)) rg_prev_addr <- mkConfigReg(0);
264 Reg#(Bit#(32)) rg_address <-mkReg(0);
265 Reg#(Bit#(32)) ar =conditionalWrite(writeSideEffect(rg_address,wr_address_written._write(True)),sr_busy==0 && ccr_fmode!='b11); // address register
267 Reg#(Bit#(32)) rg_alternatebyte_reg<-mkReg(0);
268 Reg#(Bit#(32)) abr=conditionalWrite(rg_alternatebyte_reg,sr_busy==0); // alternate byte register
270 Reg#(Bit#(32)) rg_data <-mkReg(0);
271 Reg#(Bit#(32)) dr =writeSideEffect(rg_data,wr_data_written._write(True)); // data register
273 Reg#(Bit#(32)) rg_psmkr <-mkReg(0);
274 Reg#(Bit#(32)) psmkr =conditionalWrite(rg_psmkr,sr_busy==0); // polling status mask register
276 Reg#(Bit#(32)) rg_psmar <-mkReg(0);
277 Reg#(Bit#(32)) psmar =conditionalWrite(rg_psmar,sr_busy==0); // polling statue match register
279 Reg#(Bit#(16)) pir_interval <-mkReg(0); // polling interval
280 Reg#(Bit#(32)) pir =conditionalWrite(concatReg2(readOnlyReg(16'd0),pir_interval),sr_busy==0); // polling interval register
282 Reg#(Bit#(16)) lptr_timeout <-mkReg(0); // timeout period
283 Reg#(Bit#(32)) lptr =conditionalWrite(concatReg2(readOnlyReg(16'd0),lptr_timeout),sr_busy==0); // low power timeout register.
284 Reg#(Bool) thres <- mkReg(False);
285 Reg#(Bit#(32)) sdio0r <- mkReg(32'h00000073);
286 Reg#(Bit#(32)) sdio1r <- mkReg(32'h00000073);
287 Reg#(Bit#(32)) sdio2r <- mkReg(32'h00000073);
288 Reg#(Bit#(32)) sdio3r <- mkReg(32'h00000073);
289 Reg#(Bool) rg_request_ready <- mkReg(True);
290 Bool ddr_clock = ((wr_sdr_clock&&!wr_sdr_delayed)||(!wr_sdr_clock&&wr_sdr_delayed));
291 Bool transfer_cond = (sr_busy==1 && cr_abort==0 && cr_en==1);
292 Bool clock_cond = ((wr_sdr_clock && ccr_ddrm==0) || (ddr_clock && ccr_ddrm==1));
293 Bool qspi_flush = (cr_abort==1 || cr_en==0);
294 /*************** End of QSPI defined Registers *****************/
295 function Reg#(Bit#(32)) access_register(Bit#(8) address);
296 Reg#(Bit#(32)) register=(
315 default: readOnlyReg(0);
321 /* This function defines the next phase that needs to be executed. indicates if
322 the operation is over and also the value of rg_count_bits for the next phase*/
323 function Tuple3#(Bit#(32),Bit#(1),Phase) phase_change(Phase current_phase, Bit#(32) count_val, Bit#(1) smf);
324 Phase next_phase=Idle;
325 if(current_phase==Idle)
326 next_phase=Instruction_phase;
327 if(current_phase==Instruction_phase)
328 next_phase=Address_phase;
329 if(current_phase==Address_phase)
330 next_phase=AlternateByte_phase;
331 if(current_phase==AlternateByte_phase)
332 next_phase=Dummy_phase;
333 if(current_phase==Dummy_phase)
334 next_phase=(ccr_fmode=='b00)?DataWrite_phase:DataRead_phase;
335 if(current_phase==DataRead_phase)begin
336 if(ccr_fmode=='b01 || ccr_fmode=='b10) // indirect modes
338 else if(ccr_fmode=='b10) // auto-status polling mode
342 next_phase=Dummy_phase;
344 next_phase=DataRead_phase; //Memory Mapped mode
346 if(current_phase==DataWrite_phase)
349 if(next_phase==Instruction_phase && (ccr_imode==0||(ccr_sioo==1 && instruction_sent))) // if single instruction mode or no instruction mode
350 next_phase=Address_phase;
351 if(next_phase==Address_phase && ccr_admode==0)
352 next_phase=AlternateByte_phase;
353 if(next_phase==AlternateByte_phase && ccr_abmode==0)
354 next_phase=Dummy_phase;
355 if(next_phase==Dummy_phase && ccr_dcyc==0)
356 next_phase=ccr_fmode==0?DataWrite_phase:DataRead_phase;
357 if(next_phase==Dummy_phase && (ccr_fmode=='b10 && pir_interval==0))begin // TODO Check if this is correct or needs more logic.
358 next_phase=Instruction_phase;
360 if((next_phase==DataWrite_phase || next_phase==DataRead_phase) && ccr_dmode==0 && ccr_fmode!='b11)begin
361 if(ccr_fmode=='b01 || ccr_fmode=='b00)
363 else if(ccr_fmode=='b10)
367 next_phase=Dummy_phase;
370 if(next_phase==Instruction_phase)begin
373 if(next_phase==Address_phase)begin
374 count_val=(ccr_fmode=='b11)?32:(case(ccr_adsize) 0:8; 1:16; 2:24; 3:32; endcase);
376 if(next_phase==AlternateByte_phase)begin
377 count_val=(case(ccr_absize) 0:8; 1:16; 2:24; 3:32; endcase);
379 if(next_phase==Dummy_phase)begin
380 count_val=(ccr_fmode=='b10)? zeroExtend(pir_interval):zeroExtend(ccr_dcyc);
382 if(next_phase==DataWrite_phase)begin
385 if(next_phase==DataRead_phase)begin
389 if(current_phase!=Idle && next_phase==Idle && (ccr_fmode=='b00 || ccr_fmode=='b01))begin // only in indirect mode raise completion of transfer TODO remove ccr_fmode=='b11 from this line.
392 return tuple3(count_val,tcf,next_phase);
395 Wrapper3#(Phase,Bit#(32),Bit#(1),Tuple3#(Bit#(32),Bit#(1),Phase)) change_phase<-mkUniqueWrapper3(phase_change);
396 /* This rule receives the write request from the AXI and updates the relevant
397 QSPI register set using the lower 12 bits as address map */
398 rule rl_write_request_from_AXI;
399 let aw <- pop_o (s_xactor.o_wr_addr);
400 let w <- pop_o (s_xactor.o_wr_data);
401 AXI4_Lite_Resp axi4_bresp = AXI4_LITE_OKAY;
402 if(ccr_fmode=='b11 && aw.awaddr[7:0]==`DR) begin //Undefined behavior when written into integral fields in CR, CCR!!!
403 axi4_bresp = AXI4_LITE_SLVERR;
404 `ifdef verbose $display("Sending AXI4_LITE_SLVERR because store in memory mapped mode and not clearing Interrupt Flags"); `endif
406 `ifdef verbose $display($time,"\tReceived AXI write request to Address: %h Data: %h Size: %h",aw.awaddr,w.wdata,aw.awsize); `endif
407 if(aw.awaddr[7:0]==`DR)begin
408 if(aw.awsize==0)begin
409 dr[7:0]<=w.wdata[7:0];
410 Vector#(4,Bit#(8)) temp=newVector();
411 temp[0]=w.wdata[7:0];
412 if(fifo.enqReadyN(1))
415 else if(aw.awsize==1)begin
416 dr[15:0]<=w.wdata[15:0];
417 Vector#(4,Bit#(8)) temp = newVector();
418 temp[0]=w.wdata[7:0];
419 temp[1]=w.wdata[15:8];
420 if(fifo.enqReadyN(2))
423 else if(aw.awsize==2)begin
425 Vector#(4,Bit#(8)) temp = newVector();
426 temp[3]=w.wdata[31:24];
427 temp[2]=w.wdata[23:16];
428 temp[1]=w.wdata[15:8];
429 temp[0]=w.wdata[7:0];
430 if(fifo.enqReadyN(4))
434 axi4_bresp = AXI4_LITE_SLVERR;
435 `ifdef verbose $display("Sending AXI4_LITE_SLVERR because DR awsize is 64-bit"); `endif
439 let reg1=access_register(aw.awaddr[7:0]);
440 `ifdef verbose $display("Write Reg access: %h Write Data: %h Size: %h",aw.awaddr[7:0],w.wdata,aw.awsize); `endif
441 //Byte and Half-Word Writes are not permitted in ConfigReg Space
442 if(aw.awsize==2) // 32 bits
445 axi4_bresp = AXI4_LITE_SLVERR;
446 `ifdef verbose $display("Sending SLVERR because Accessed register's awsize was different"); `endif
450 let b = AXI4_Lite_Wr_Resp {bresp: axi4_bresp, buser: aw.awuser};
451 s_xactor.i_wr_resp.enq (b);
454 /* This rule receives the read request from the AXI and responds with the relevant
455 QSPI register set using the lower 12 bits as address map */
456 (*descending_urgency="rl_read_request_from_AXI,rl_write_request_from_AXI"*) //experimental
457 rule rl_read_request_from_AXI(rg_request_ready==True);
458 let axir<- pop_o(s_xactor.o_rd_addr);
459 Bool request_ready = True;
460 `ifdef verbose $display($time,"\tReceived AXI read request to Address: %h Size: %h",axir.araddr,axir.arsize); `endif
461 if((axir.araddr[27:0]>=`STARTMM && axir.araddr[27:0]<=`ENDMM) && axir.araddr[31]==1'b1)begin // memory mapped space
463 wr_read_request_from_AXI<=True; //Could this lead to some error? Need to think about this, without fail
464 AXI4_Lite_Resp axi4_rresp = AXI4_LITE_OKAY;
465 mm_address<=truncate(axir.araddr);
466 Bit#(4) data_length = axir.arsize==0?1:axir.arsize==1?2:axir.arsize==2?4:8;
467 mm_data_length<= zeroExtend(data_length);
468 Bit#(28) address_limit = 1 << dcr_fsize;
470 //It is forbidden to access the flash bank area before the SPI is properly configured -- fmode is '11??
471 //If not sending a SLVERR now if the mode is not memory mapped and if an access is made outside allowed
472 if(ccr_fmode!='b11 || axir.araddr[27:0] > address_limit) begin
473 `ifdef verbose $display("Sending Slave Error ccr_fmode: %h mm_address: %h address_limit: %h dcr_fsize: %h",ccr_fmode,mm_address,address_limit, dcr_fsize); `endif
474 axi4_rresp = AXI4_LITE_SLVERR;
475 let r = AXI4_Lite_Rd_Data {rresp: axi4_rresp, rdata: 0 , ruser: 0};
476 s_xactor.i_rd_data.enq(r);
477 axi4_rresp = AXI4_LITE_SLVERR;
478 rg_phase <= Idle; //Will this work?
481 ncs <= 1; //Just resetting all the parameters, just in case. Should Ask Neel
484 else if(sr_busy==1 ||thres) begin //Bus is busy with Memory mapped maybe?
485 `ifdef verbose $display($time,"sr_busy: %d, thres: %d rg_prev_addr: %h axir.araddr: %h fifo_count: %d", sr_busy, thres, rg_prev_addr, axir.araddr, fifo.count); `endif
486 Bit#(28) eff_addr = rg_prev_addr + zeroExtend(data_length);
487 if((eff_addr!= truncate(axir.araddr)) || pack(fifo.count)==0 || ccr_dummy_bit==1'b1) begin
488 `ifdef verbose $display($time,"Not Equal eff_addr: %h mm_address : %h axir.araddr: %h rg_prev_addr: %h data_length : %h sum : %h fifo.count: %h ccr_dummy_bit: %h",eff_addr,mm_address,axir.araddr,rg_prev_addr,data_length,rg_prev_addr+zeroExtend(data_length),pack(fifo.count),ccr_dummy_bit); `endif
494 //$display($time,"Setting Thres to FALSE");
496 request_ready = False;
498 else if(!first_read) begin
499 request_ready = True;
500 rg_prev_addr <= truncate(axir.araddr);
502 if(axir.arsize==0) begin // 8 bits
503 if(fifo.deqReadyN(1))begin
504 let temp=fifo.first[0];
505 reg1=duplicate(temp);
509 else if(axir.arsize==1) begin // 16 bits
510 if(fifo.deqReadyN(2)) begin
511 let temp={fifo.first[0],fifo.first[1]};
512 reg1=duplicate(temp);
516 else if(axir.arsize==2) begin // 32 bits
517 if(fifo.deqReadyN(4)) begin
518 let temp={fifo.first[0],fifo.first[1],fifo.first[2],fifo.first[3]};
519 reg1=duplicate(temp);
524 axi4_rresp = AXI4_LITE_SLVERR;
525 `ifdef verbose $display("Sending Response to the core: reg1: %h", reg1); `endif
526 let r = AXI4_Lite_Rd_Data {rresp: axi4_rresp, rdata: duplicate(reg1) , ruser: 0};
527 s_xactor.i_rd_data.enq(r);
532 let reg1=access_register(axir.araddr[7:0]);
533 `ifdef verbose $display("Reg Read Access: %h arsize: %h",axir.araddr[7:0], axir.arsize); `endif
534 if(axir.araddr[7:0]==`SR)
535 wr_status_read<=True;
536 if(axir.araddr[7:0]==`DR)begin // accessing the data register for read.
537 `ifdef verbose $display("Accessed DR fifo_count : %d axi.arsize: %d", fifo.count, axir.arsize); `endif
540 if(axir.arsize==0) begin // 8 bits
541 if(fifo.deqReadyN(1))begin
542 let temp=fifo.first[0];
543 reg1=duplicate(temp);
547 else if(axir.arsize==1) begin // 16 bits
548 if(fifo.deqReadyN(2)) begin
549 let temp={fifo.first[0],fifo.first[1]};
550 reg1=duplicate(temp);
554 else /*if(axir.arsize==2)*/ begin // 32 bits -- Even if the request is a long int, respond with int since that's the max we can do
555 if(fifo.deqReadyN(4)) begin
556 let temp={fifo.first[0],fifo.first[1],fifo.first[2],fifo.first[3]};
557 reg1=duplicate(temp);
562 `ifdef verbose $display("Sending Response : reg1: %x", reg1); `endif
563 let r = AXI4_Lite_Rd_Data {rresp: AXI4_LITE_OKAY, rdata: duplicate(reg1) ,ruser: 0};
564 request_ready = True;
565 s_xactor.i_rd_data.enq(r);
567 rg_request_ready <= request_ready;
568 `ifdef verbose $display($time,"QSPI: Is Request ready? : %h",request_ready); `endif
572 rule timeout_counter;
573 if(cr_tcen==1 && sr_tof==0) // timecounter is enabled
574 if(timecounter==lptr_timeout[15:0])begin
579 timecounter<=timecounter+1;
582 rule delayed_sr_tcf_signal(transfer_cond &&
583 ((ccr_ddrm==1 && ddr_clock && (ccr_admode!=0 || ccr_dmode!=0)) || wr_sdr_clock));
584 sr_tcf<=delay_sr_tcf;
587 rule delayed_ncs_generation;
592 wr_sdr_delayed <= wr_sdr_clock;
596 /* This rule generates the clk signal. The Prescaler register defines the
597 division factor wrt to the Global clock. The prescaler will only work when the
598 chip select is low i.e when the operation has been initiated. */
599 rule rl_generate_clk_from_master;
600 if(delay_ncs==1)begin
603 `ifdef verbose1 $display("dcr_ckmode: %h",dcr_ckmode); `endif
606 let half_clock_value=cr_prescaler>>1;
607 if(cr_prescaler[0]==0)begin // odd division
608 if(rg_clk_counter<=half_clock_value)
612 if(rg_clk_counter==cr_prescaler)
615 rg_clk_counter<=rg_clk_counter+1;
616 if(rg_clk_counter == half_clock_value || rg_clk_counter==cr_prescaler)begin
617 wr_sdr_clock<=rg_phase==DataRead_phase?unpack(~rg_clk):unpack(rg_clk);
620 else begin // even division
621 if(rg_clk_counter==half_clock_value)begin
624 wr_sdr_clock<=rg_phase==DataRead_phase?unpack(~rg_clk):unpack(rg_clk);
626 else if(delay_ncs==0)
627 rg_clk_counter<=rg_clk_counter+1;
632 /* update the status flag on each cycle */
633 rule rl_update_fifo_level;
634 sr_flevel<=pack(fifo.count);
636 /* set the fifo threshold flag when the FIFO level is equal to the FTHRESH value */
637 (*preempts="rl_set_busy_signal,rl_update_threshold_flag"*)
638 rule rl_update_threshold_flag;
639 if(ccr_fmode=='b00)begin// indirect write mode
640 sr_ftf<=pack(16-pack(fifo.count)>={1'b0,cr_fthres}+1);
642 else if(ccr_fmode=='b01) begin
643 sr_ftf<=pack(pack(fifo.count)>=({1'b0,cr_fthres}+1));
644 `ifdef verbose1 $display("fifo count: %d fthres: %d",fifo.count,cr_fthres); `endif
646 else if(ccr_fmode=='b10 && wr_status_read)begin // auto_status polling mode
649 else if(ccr_fmode=='b10 && wr_data_read)begin // auto_status polling mode
652 else if(ccr_fmode=='b11 && pack(fifo.count)>={1'b0,cr_fthres}+1) begin
655 rg_phase<=Idle; // Will this work?
657 rg_request_ready <= True;
658 // $display($time,"THRES is being set to TRUE kyaaaa?");
662 /* If abort is raised or the QSPI is disabled go back to Idle Phase*/
663 //(*descending_urgency = "if_abort,rl_read_request_from_AXI"*)
664 //(*descending_urgency = "if_abort,rl_write_request_from_AXI"*)
665 (*preempts = "if_abort,rl_update_threshold_flag"*)
666 rule if_abort(qspi_flush);
667 //$display("Received Abort or Disable request, going to idle");
674 instruction_sent <= False;
675 half_cycle_delay <= False;
676 fifo.clear(); //What if its already empty? clearing the fifo, so doesn't matter
679 /*operate the busy signal in different mode */
680 rule rl_reset_busy_signal(sr_busy==1);
685 else if(ccr_fmode=='b00 || ccr_fmode=='b01)begin // indirect write or read mode;
686 if(/*fifo.count==0 &&*/ sr_tcf==1)begin // if FIFO is empty and the transaction is complete
691 else if(ccr_fmode=='b10)begin // automatic polling mode
697 else if(ccr_fmode=='b11)begin
698 if(sr_tof==1 || cr_en==0 || cr_abort==1) begin// timeout event
704 (*descending_urgency="rl_set_busy_signal,rl_read_request_from_AXI"*)
705 (*descending_urgency="rl_set_busy_signal,rl_write_request_from_AXI"*)
706 rule rl_set_busy_signal(sr_busy==0 && rg_phase==Idle && cr_abort==0 && cr_en==1);
708 instruction_sent<=False;
709 `ifdef verbose1 $display($time,"\tWaiting for change in phase wr_read_request_from_AXI: %b ccr_fmode: %h thres: %h",wr_read_request_from_AXI,ccr_fmode,thres); `endif
710 if(wr_instruction_written)begin
713 rg_phase<=Instruction_phase;
716 else if((wr_address_written && ccr_admode!=0 && (ccr_fmode=='b01 || ccr_dmode=='d0 || ccr_fmode=='b10))|| (wr_data_written && ccr_admode!=0 && ccr_dmode!=0 && ccr_fmode=='b00))begin
717 sr_busy<=1; // start some transaction
718 `ifdef verbose $display("Address Written and going to Some mode"); `endif
720 let {x,y,z}<-change_phase.func(rg_phase,0,0);
724 `ifdef verbose $display("Mode is :",fshow(z),"Count_bits : %d",x); `endif
725 if(z==DataRead_phase)
728 else if(wr_read_request_from_AXI && ccr_fmode=='b11 && !thres)begin // memory-mapped mode.
729 `ifdef verbose $display("Entering Memory mapped mode"); `endif
732 let {x,y,z}<-change_phase.func(rg_phase,0,0);
736 `ifdef verbose $display("rg_phase :",fshow(z)); `endif
737 if(z==DataRead_phase)
742 /* This rule generates the error signal interrupt in different scenarios */
743 rule set_error_signal;
744 Bit#(32) actual_address=1<<(dcr_fsize);
745 if(wr_address_written && ar>actual_address && (ccr_fmode=='b00 || ccr_fmode=='b01))
747 else if(wr_address_written && ar+dlr>actual_address &&(ccr_fmode=='b00 || ccr_fmode=='b01))
749 else if(wr_address_written)
753 /* Rule to transfer the instruction of 8-bits outside. THe size of instruction is fixed
754 to 8 bits by protocol. Instruction phase will always be in SDR mode */
755 rule rl_transfer_instruction(rg_phase==Instruction_phase && transfer_cond && wr_sdr_clock && !qspi_flush);
756 Bool end_of_phase=False;
757 let reverse_instruction=ccr_instruction;
758 let count_val=rg_count_bits;
759 `ifdef verbose1 $display("Executing Instruction Phase SPI Mode: %b Count_bits: %d InstructionReverse: %h",ccr_imode,rg_count_bits,reverse_instruction); `endif
761 if(ccr_imode=='b01)begin // single spi mode;
763 rg_output<={1'b1,1'b0,1'b0,reverse_instruction[rg_count_bits-1]};
764 if(rg_count_bits==1)begin// end of instruction stream
768 count_val=rg_count_bits-1;
770 else if (ccr_imode=='b10)begin // dual mode;
772 rg_output<={1'b1,1'b0,reverse_instruction[rg_count_bits-1:rg_count_bits-2]};
773 if(rg_count_bits==2)begin// end of instruction stream
777 count_val=rg_count_bits-2;
779 else if (ccr_imode=='b11)begin // quad mode;
781 rg_output<=reverse_instruction[rg_count_bits-1:rg_count_bits-4];
782 if(rg_count_bits==4)begin// end of instruction stream
786 count_val=rg_count_bits-4;
788 if(end_of_phase || ccr_imode==0)begin // end of instruction or no instruction phase
789 let {x,y,z}<-change_phase.func(rg_phase,count_val,0);
790 instruction_sent<=True;
796 half_cycle_delay<=True;
797 if(z==DataRead_phase)
801 rg_count_bits<=count_val;
802 rg_output_en<=enable_o;
805 /* Rule to transfer the address bits of address outside. The size of address is
806 defined by the ccr_adsize register in ccr */
807 rule rl_transfer_address(rg_phase==Address_phase && transfer_cond && clock_cond && !qspi_flush);
808 if(half_cycle_delay) begin
809 half_cycle_delay<=False;
810 read_true <= True; //A workaround for the delay .. For DDR mode, the clock should be pushed one cycle and not half
815 Bool end_of_phase=False;
817 let count_val=rg_count_bits;
818 Bit#(32) address=(ccr_fmode=='b11)?zeroExtend(mm_address):ar;
819 rg_prev_addr <= truncate(address);
820 `ifdef verbose1 $display($time,"Executing Address Phase SPI Mode: %b Address Size: %d Count_bits: %d Address: %b",ccr_admode,ccr_adsize,rg_count_bits,address); `endif
821 if(ccr_admode=='b01)begin // single spi mode;
823 rg_output<={1'b1,1'b0,1'b0,address[rg_count_bits-1]};
824 `ifdef verbose $display($time,"Single: Sending Address bit %h bit_number: %d total_address: %h",rg_count_bits-1,address[rg_count_bits-1],address); `endif
825 if(rg_count_bits==1)begin// end of address stream
829 count_val=rg_count_bits-1;
831 else if (ccr_admode=='b10)begin // dual mode;
833 rg_output<={1'b1,1'b0,address[rg_count_bits-1:rg_count_bits-2]};
834 `ifdef verbose $display($time,"Double: Sending Address bit %h bit_number: %d total_address: %h",rg_count_bits-1,address[rg_count_bits-1],address); `endif
835 if(rg_count_bits==2)begin// end of address stream
839 count_val=rg_count_bits-2;
841 else if (ccr_admode=='b11)begin // quad mode;
843 rg_output<=address[rg_count_bits-1:rg_count_bits-4];
844 `ifdef verbose $display($time,"Quad: Sending Address bit %h bit_number: %d total_address: %h",rg_count_bits-1,address[rg_count_bits-1],address); `endif
845 if(rg_count_bits==4)begin// end of address stream
849 count_val=rg_count_bits-4;
851 if(end_of_phase || ccr_admode==0)begin // end of address phase
852 let {x,y,z}<-change_phase.func(rg_phase,count_val,0);
857 if(z==DataRead_phase)
861 rg_count_bits<=count_val;
862 rg_output_en<=enable_o;
866 /* Rule to transfer the alternate bytes. The size of alternate bytes is
867 defined by the ccr_absize register in ccr */
868 rule rl_transfer_alternatebytes(rg_phase==AlternateByte_phase && transfer_cond && clock_cond && !qspi_flush);
869 Bool end_of_phase=False;
870 let count_val=rg_count_bits;
871 `ifdef verbose1 $display("Executing AltByte Phase SPI Mode: %b AltByte Size: %d Count_bits: %d AltByte: %b",ccr_abmode,ccr_absize,rg_count_bits,abr); `endif
873 if(ccr_abmode=='b01)begin // single spi mode;
875 rg_output<={1'b1,1'b0,1'b0,abr[rg_count_bits-1]};
876 if(rg_count_bits==1)begin// end of instruction stream
880 count_val=rg_count_bits-1;
882 else if (ccr_abmode=='b10)begin // dual mode;
884 rg_output<={1'b1,1'b0,abr[rg_count_bits-1:rg_count_bits-2]};
885 if(rg_count_bits==2)begin// end of instruction stream
889 count_val=rg_count_bits-2;
891 else if (ccr_abmode=='b11)begin // quad mode;
893 rg_output<=abr[rg_count_bits-1:rg_count_bits-4];
894 if(rg_count_bits==4)begin// end of instruction stream
898 count_val=rg_count_bits-4;
900 if(end_of_phase || ccr_abmode==0)begin // end of alternate byte phase
901 let {x,y,z}<-change_phase.func(rg_phase,count_val,0);
906 if(z==DataRead_phase)
907 read_true <= True;end
909 rg_count_bits<=count_val;
910 rg_output_en<=enable_o;
914 rule rl_transfer_dummy_cycle(rg_phase==Dummy_phase && transfer_cond && wr_sdr_clock && !qspi_flush);
915 let {x,y,z} <- change_phase.func(rg_phase,rg_count_bits,0);
916 Bit#(5) count_val = rg_mode_byte_counter;
917 Bit#(4) enable_o = rg_output_en;
918 `ifdef verbose $display("\t Executing Dummy Phase: rg_mode_bytes: %b rg_mode_byte_counter: %d",rg_mode_bytes, rg_mode_byte_counter); `endif
919 if(ccr_dmode==1) begin
920 if(ccr_dummy_confirmation==1) begin
921 //rg_output_en <= 4'b1101;
923 rg_output <= {1'b1,1'b0,1'b0,rg_mode_bytes[rg_mode_byte_counter]};
925 count_val = count_val - 1;
930 //rg_output_en <= 4'b1101;
932 rg_output <= {1'b1,1'b0,1'b0,1'b0};
935 else if(ccr_dmode==2) begin
936 if(ccr_dummy_confirmation==1) begin
937 //rg_output_en <= 4'b1111;
939 rg_output <= {1'b1,1'b0,rg_mode_bytes[rg_mode_byte_counter:rg_mode_byte_counter-1]};
941 count_val = count_val - 2;
946 //rg_output_en <= 4'b1100;
948 rg_output <= {1'b1,1'b0,1'b0,1'b0};
952 if(ccr_dummy_confirmation==1) begin
953 //rg_output_en <= 4'b1111;
955 rg_output <= rg_mode_bytes[rg_mode_byte_counter:rg_mode_byte_counter-3];
957 count_val = count_val - 4;
962 //rg_output_en <= 4'b0000;
966 if(rg_count_bits==0 || (rg_count_bits==1 && z!=DataRead_phase))begin // end of dummy cycles;
969 `ifdef verbose $display("From Dummy to :",fshow(z)); `endif
970 if(z==DataRead_phase)
974 rg_mode_byte_counter <= 'd-1; //All ones
976 half_cycle_delay<=True;
979 rg_count_bits<=rg_count_bits-1;
980 rg_mode_byte_counter <= count_val;
981 rg_output_en <= enable_o;
986 /* Rule to transfer the dummy_cycles. The size of dummy cycles is
987 defined by the ccr_dcyc register in ccr. The number of dummy cycles should be calculated of
988 the complete cycle even in DDR mode hence using sdr clock*/
989 /* rule rl_transfer_dummy_cycle(rg_phase==Dummy_phase && transfer_cond && wr_sdr_clock && !qspi_flush);
990 let {x,y,z}<-change_phase.func(rg_phase,rg_count_bits,0);
991 `ifdef verbose $display($time,"Executing Dummy Phase, Dummy_confirmation_bit : %d dummy_bit : %d", ccr_dummy_confirmation, ccr_dummy_bit); `endif
992 if(ccr_dmode==1) begin
993 if(ccr_dummy_confirmation==1) begin
994 rg_output_en <= 4'b1101;
995 rg_output <= {1'b1,1'b0,1'b0,ccr_dummy_bit};
996 ccr_dummy_confirmation<=0;
999 rg_output_en <= 4'b1101;
1000 rg_output <= {1'b1,1'b0,1'b0,1'b0};
1003 else if(ccr_dmode==2) begin
1004 if(ccr_dummy_confirmation==1) begin
1005 rg_output_en <= 4'b1101;
1006 rg_output <= {1'b1,1'b0,1'b0,ccr_dummy_bit};
1007 ccr_dummy_confirmation <= 0;
1010 rg_output_en <= 4'b1100;
1011 rg_output <= {1'b1,1'b0,1'b0,1'b0};
1015 if(ccr_dummy_confirmation==1) begin
1016 `ifdef verbose $display("Data going to output %d", ccr_dummy_bit); `endif
1018 rg_output[0] <= ccr_dummy_bit;
1019 ccr_dummy_confirmation<=0;
1024 if(rg_count_bits==0 || (rg_count_bits==1 && z!=DataRead_phase))begin // end of dummy cycles;
1027 `ifdef verbose $display("From Dummy to :",fshow(z)); `endif
1028 if(z==DataRead_phase)
1033 half_cycle_delay<=True;
1036 rg_count_bits<=rg_count_bits-1;
1040 /* read data from the flash memory and store it in the DLR register. Simulataneously
1041 put Bytes in the FIFO*/
1042 (*descending_urgency="rl_data_read_phase,rl_read_request_from_AXI"*)
1043 (*descending_urgency="rl_data_read_phase,rl_write_request_from_AXI"*)
1044 rule rl_data_read_phase(rg_phase==DataRead_phase /*&& ccr_fmode!='b11*/ && transfer_cond && clock_cond && !qspi_flush);
1046 if(half_cycle_delay || read_true) begin
1047 half_cycle_delay<=False;
1051 Bit#(32) data_reg=dr;
1052 Bit#(32) count_byte=rg_count_bytes;
1053 Bit#(32) count_bits=rg_count_bits;
1054 Bit#(32) data_length1=(ccr_fmode=='b11)?mm_data_length:dlr;
1055 `ifdef verbose1 $display($time,"Executing DataRead Phase SPI Mode: %b DLR : %d Count_bits: %d Input :%b ccr_ddrm: %b",ccr_dmode,data_length1,rg_count_bits,rg_input,ccr_ddrm); `endif
1056 /* write incoming bit to the data register */
1057 if(ccr_dmode==1)begin // single line mode;
1058 data_reg=data_reg<<1;
1059 data_reg[0]=rg_input[1];
1060 `ifdef verbose $display($time,"Single data_reg : %b",data_reg); `endif
1061 count_bits=count_bits+1;
1062 rg_output_en <= 4'b1101;
1063 rg_output <= {1'b1,1'b0,1'b0,1'b0};
1066 else if(ccr_dmode==2)begin // dual line mode;
1067 rg_output_en <= 4'b1100;
1068 data_reg=data_reg<<2;
1069 data_reg[1:0]=rg_input[1:0];
1070 `ifdef verbose $display($time,"Dual data_reg : %b",data_reg); `endif
1071 count_bits=count_bits+1;
1072 rg_output <= {1'b1,1'b0,1'b0,1'b0};
1074 else if(ccr_dmode==3) begin// quad line mode;
1075 rg_output_en <= 4'b0000;
1076 data_reg=data_reg<<4;
1077 data_reg[3:0]=rg_input;
1078 `ifdef verbose $display($time,"Quad data_reg : %b",data_reg); `endif
1079 count_bits=count_bits+1;
1082 /* write the last successfully received byte into the FIFO */
1083 if(ccr_dmode==1)begin// single line mode
1084 if(count_byte==data_length-1 && ccr_ddrm==1 && count_bits[2:0]=='b111) //To make sure that the Flash does not send any data the next half edge since ncs is made 1 after the second edge
1086 if(rg_count_bits[2:0]=='b111)begin // multiple of eight bits have been read.
1087 `ifdef verbose1 $display("Enquing FIFO"); `endif
1088 Vector#(4,Bit#(8)) temp = newVector();
1089 temp[0]=data_reg[7:0];
1090 `ifdef verbose $display($time,"Single Enqueing FIFO : data is %h",temp[0]); `endif
1093 count_byte=count_byte+1;
1096 else if(ccr_dmode==2) begin // dual line mode
1097 if(count_byte==data_length-1 && ccr_ddrm==1 && count_bits[1:0]=='b11) //To make sure that the Flash does not send any data the next half edge since ncs is made 1 after the second edge
1099 if(rg_count_bits[1:0]=='b11)begin // multiple of eight bits have been read.
1100 `ifdef verbose1 $display("Enquing FIFO"); `endif
1101 Vector#(4,Bit#(8)) temp = newVector();
1102 temp[0]=data_reg[7:0];
1103 `ifdef verbose $display($time,"Dual Enqueing FIFO : data is %h",temp[0]); `endif
1106 count_byte=count_byte+1;
1109 else if(ccr_dmode==3) begin // quad line mode
1110 if(count_byte==data_length-1 && ccr_ddrm==1 && count_bits[0]=='b1) //To make sure that the Flash does not send any data the next half edge since ncs is made 1 after the second edge
1112 if(rg_count_bits[0]=='b1)begin // multiple of eight bits have been read.
1113 `ifdef verbose1 $display("Enquing FIFO"); `endif
1114 Vector#(4,Bit#(8)) temp = newVector();
1115 temp[0]=data_reg[7:0];
1116 `ifdef verbose $display($time,"Quad Enqueing FIFO : data is %h",temp[0]); `endif
1119 count_byte=count_byte+1;
1124 `ifdef verbose $display("count_byte: %d data_length1: %d",count_byte,data_length1); `endif
1125 /* condition for termination of dataread_phase */
1126 if(data_length1!='hFFFFFFFF)begin // if limit is not undefined
1127 if(count_byte==data_length1)begin // if limit has bee reached.
1128 `ifdef verbose $display($time,"Limit has reached: rg_count_bytes %h data_length %h",count_byte,data_length); `endif
1129 if(ccr_fmode=='b10)begin // auto-status polling mode
1130 if(cr_pmm==0)begin // ANDed mode
1131 if((psmar&psmkr) == (psmkr&dr)) // is the unmasked bits match
1136 else begin// ORed mode
1146 else if(ccr_fmode=='b11)begin// memory mapped mode
1147 if(first_read) begin
1148 `ifdef verbose $display("Sending response back to the proc data_reg: %h",data_reg); `endif
1149 let r = AXI4_Lite_Rd_Data {rresp: AXI4_LITE_OKAY, rdata: duplicate(data_reg) , ruser: 0};
1150 s_xactor.i_rd_data.enq(r);
1151 first_read <= False;
1152 //rg_request_ready <= True;
1155 let {x,y,z}<-change_phase.func(rg_phase,rg_count_bits,smf);
1156 /* if(z==DataRead_phase)
1157 read_true <= True;*/
1159 `ifdef verbose $display("rg_phase:",fshow(z),"sr_tcf: %d",y); `endif
1160 sr_tcf<=y; // set completion of transfer flag
1165 rg_count_bytes<=count_byte;
1166 rg_count_bits<=count_bits;
1169 else if(dcr_fsize!='h1f)begin // if limit is not infinite
1170 Bit#(32) new_limit=1<<(dcr_fsize);
1171 `ifdef verbose1 $display("Sending completion -- newlimit : %h",new_limit); `endif
1172 if(truncate(rg_count_bytes)==new_limit)begin // if reached end of Flash memory
1173 let {x,y,z}<-change_phase.func(rg_phase,rg_count_bits,smf&cr_apms);
1175 if(z==DataRead_phase)
1177 sr_tcf<=y; // set completion of transfer flag
1182 rg_count_bytes<=count_byte;
1183 rg_count_bits<=count_bits;
1186 else begin // keep looping untill abort signal is not raised.
1187 rg_count_bytes<=count_byte;
1188 rg_count_bits<=count_bits;
1195 /* write data from the FIFO to the FLASH. Simulataneously*/
1196 (*descending_urgency="rl_data_write_phase,rl_read_request_from_AXI"*)
1197 (*descending_urgency="rl_data_write_phase,rl_write_request_from_AXI"*)
1198 rule rl_data_write_phase(rg_phase==DataWrite_phase && transfer_cond && clock_cond && !qspi_flush);
1199 if(half_cycle_delay)
1200 half_cycle_delay<=False;
1202 Bit#(8) data_reg=fifo.first()[0];
1203 Bit#(32) count_byte=rg_count_bytes;
1204 Bit#(32) count_bits=rg_count_bits;
1206 /* write incoming bit to the data register */
1207 if(ccr_dmode==1)begin // single line mode;
1209 rg_output<={1'b1,1'b0,1'b0,data_reg[rg_count_bits-1]};
1210 count_bits=count_bits-1;
1212 else if(ccr_dmode==2)begin // dual line mode;
1214 rg_output<={1'b1,1'b0,data_reg[rg_count_bits-1:rg_count_bits-2]};
1215 count_bits=count_bits-2;
1217 else if(ccr_dmode==3) begin// quad line mode;
1219 rg_output<=data_reg[rg_count_bits-1:rg_count_bits-4];
1220 count_bits=count_bits-4;
1222 `ifdef verbose1 $display("Executing DataWrite Phase SPI Mode: %b DLR : %d Count_bits: %d Input :%b Enable: %b",ccr_dmode,dlr,rg_count_bits,rg_input,enable_o); `endif
1224 /* write the last successfully received byte into the FIFO */
1225 if(ccr_dmode==1)begin// single line mode
1226 if(rg_count_bits==1)begin // multiple of eight bits have been read.
1228 count_byte=count_byte+1;
1232 else if(ccr_dmode==2) begin // dual line mode
1233 if(rg_count_bits==2)begin // multiple of eight bits have been read.
1235 count_byte=count_byte+1;
1239 else if(ccr_dmode==3) begin // quad line mode
1240 if(rg_count_bits==4)begin // multiple of eight bits have been read.
1242 count_byte=count_byte+1;
1247 /* condition for termination of dataread_phase */
1248 if(dlr!='hFFFFFFFF)begin // if limit is not undefined
1249 if(rg_count_bytes==dlr)begin // if limit has bee reached.
1251 sr_tcf<=1; // set completion of transfer flag
1256 rg_count_bytes<=count_byte;
1257 rg_count_bits<=count_bits;
1260 else if(dcr_fsize!='h1f)begin // if limit is not infinite
1261 Bit#(32) new_limit=1<<(dcr_fsize);
1262 if(truncate(rg_count_bytes)==new_limit)begin // if reached end of Flash memory
1264 sr_tcf<=1; // set completion of transfer flag
1269 rg_count_bytes<=count_byte;
1270 rg_count_bits<=count_bits;
1273 else begin // keep looping untill abort signal is not raised.
1274 rg_count_bytes<=count_byte;
1275 rg_count_bits<=count_bits;
1277 rg_output_en<=enable_o;
1281 rule display_all_Registers;
1282 `ifdef verbose1 $display($time,"\tPhase: ",fshow(rg_phase)," CR WRitten %d",wr_instruction_written, "Address Written: %d",wr_address_written); `endif
1283 `ifdef verbose1 $display($time,"\tCR: %h\tDCR: %h\tSR: %h\tFCR: %h",cr,dcr,sr,fcr); `endif
1284 `ifdef verbose1 $display($time,"\tDLR: %h\tCCR: %h\tAR: %h\tABR: %h",dlr,ccr,ar,abr); `endif
1285 `ifdef verbose1 $display($time,"\tDR: %h\tPSMKR: %h\tPSMAR: %h\tPIR: %h",dr,psmkr,psmar,pir,"\n"); `endif
1289 rule delay_phase(((wr_sdr_clock && ccr_ddrm==0) || (ddr_clock && ccr_ddrm==1)));
1290 rg_phase_delayed<=rg_phase;
1294 interface QSPI_out out;
1295 method Bit#(9) io0_sdio_ctrl;
1298 method Bit#(9) io1_sdio_ctrl;
1301 method Bit#(9) io2_sdio_ctrl;
1304 method Bit#(9) io3_sdio_ctrl;
1307 interface clk_o = interface Get
1308 method ActionValue#(Bit#(1)) get;
1309 return delay_ncs==1?dcr_ckmode:rg_clk;
1312 interface io_o = interface Get
1313 method ActionValue#(Bit#(4)) get;
1317 interface io_enable = interface Get
1318 method ActionValue#(Bit#(4)) get;
1319 return rg_output_en;
1322 interface io_in = interface Put
1323 method Action put(Bit#(4) in);
1327 interface ncs_o = interface Get
1328 method ActionValue#(Bit#(1)) get;
1334 interface slave= s_xactor.axi_side;
1336 method Bit#(6) interrupts; // 0=TOF, 1=SMF, 2=Threshold, 3=TCF, 4=TEF 5=request_ready
1337 return {pack(rg_request_ready),sr_tef&cr_teie, sr_tcf&cr_tcie, sr_ftf&cr_ftie, sr_smf&cr_smie , sr_tof&cr_toie};
1339 `ifdef simulate method curphase = rg_phase_delayed; `endif