3 * Copyright 2018 Jacob Lifshay
5 * Permission is hereby granted, free of charge, to any person obtaining a copy
6 * of this software and associated documentation files (the "Software"), to deal
7 * in the Software without restriction, including without limitation the rights
8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 * copies of the Software, and to permit persons to whom the Software is
10 * furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice shall be included in all
13 * copies or substantial portions of the Software.
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31 from migen
.fhdl
import verilog
32 from migen
.fhdl
.structure
import _Operator
34 from riscvdefs
import *
37 class MemoryInterface
:
38 fetch_address
= Signal(32, name
="memory_interface_fetch_address") # XXX [2:]
39 fetch_data
= Signal(32, name
="memory_interface_fetch_data")
40 fetch_valid
= Signal(name
="memory_interface_fetch_valid")
41 rw_address
= Signal(32, name
="memory_interface_rw_address") # XXX [2:]
42 rw_byte_mask
= Signal(4, name
="memory_interface_rw_byte_mask")
43 rw_read_not_write
= Signal(name
="memory_interface_rw_read_not_write")
44 rw_active
= Signal(name
="memory_interface_rw_active")
45 rw_data_in
= Signal(32, name
="memory_interface_rw_data_in")
46 rw_data_out
= Signal(32, name
="memory_interface_rw_data_out")
47 rw_address_valid
= Signal(name
="memory_interface_rw_address_valid")
48 rw_wait
= Signal(name
="memory_interface_rw_wait")
52 funct7
= Signal(7, name
="decoder_funct7")
53 funct3
= Signal(3, name
="decoder_funct3")
54 rd
= Signal(5, name
="decoder_rd")
55 rs1
= Signal(5, name
="decoder_rs1")
56 rs2
= Signal(5, name
="decoder_rs2")
57 immediate
= Signal(32, name
="decoder_immediate")
58 opcode
= Signal(7, name
="decoder_opcode")
59 act
= Signal(decode_action
, name
="decoder_action")
63 def __init__(self
, comb
, sync
):
66 self
.mpie
= Signal(name
="mstatus_mpie")
67 self
.mie
= Signal(name
="mstatus_mie")
68 self
.mstatus
= Signal(32, name
="mstatus")
70 self
.sync
+= self
.mie
.eq(0)
71 self
.sync
+= self
.mpie
.eq(0)
72 self
.sync
+= self
.mstatus
.eq(0)
76 def __init__(self
, comb
, sync
):
79 self
.meie
= Signal(name
="mie_meie")
80 self
.mtie
= Signal(name
="mie_mtie")
81 self
.msie
= Signal(name
="mie_msie")
91 def __init__(self
, comb
, sync
):
94 self
.mcause
= Signal(32)
95 self
.mepc
= Signal(32)
96 self
.mscratch
= Signal(32)
97 self
.sync
+= self
.mcause
.eq(0)
98 self
.sync
+= self
.mepc
.eq(0) # 32'hXXXXXXXX;
99 self
.sync
+= self
.mscratch
.eq(0) # 32'hXXXXXXXX;
103 def __init__(self
, comb
, sync
):
106 self
.misa
= Signal(32)
108 for l
in list(string
.ascii_lowercase
):
109 value
= 1 if l
== 'i' else 0
110 cl
.append(Constant(value
))
111 cl
.append(Constant(0, 4))
112 cl
.append(Constant(0b01, 2))
113 self
.comb
+= self
.misa
.eq(Cat(cl
))
117 def __init__(self
, comb
, sync
):
120 self
.action
= Signal(fetch_action
, name
="fetch_action")
121 self
.target_pc
= Signal(32, name
="fetch_target_pc")
122 self
.output_pc
= Signal(32, name
="fetch_output_pc")
123 self
.output_instruction
= Signal(32, name
="fetch_ouutput_instruction")
124 self
.output_state
= Signal(fetch_output_state
,name
="fetch_output_state")
127 def __init__(self
, comb
, sync
, dc
, register_rs1
):
130 self
.number
= Signal(12, name
="csr_number")
131 self
.input_value
= Signal(32, name
="csr_input_value")
132 self
.reads
= Signal(name
="csr_reads")
133 self
.writes
= Signal(name
="csr_writes")
134 self
.op_is_valid
= Signal(name
="csr_op_is_valid")
136 self
.comb
+= self
.number
.eq(dc
.immediate
)
137 self
.comb
+= self
.input_value
.eq(Mux(dc
.funct3
[2],
140 self
.comb
+= self
.reads
.eq(dc
.funct3
[1] |
(dc
.rd
!= 0))
141 self
.comb
+= self
.writes
.eq(~dc
.funct3
[1] |
(dc
.rs1
!= 0))
143 self
.comb
+= self
.get_csr_op_is_valid()
145 def get_csr_op_is_valid(self
):
146 """ determines if a CSR is valid
150 for f
in [csr_ustatus
, csr_fflags
, csr_frm
, csr_fcsr
,
151 csr_uie
, csr_utvec
, csr_uscratch
, csr_uepc
,
152 csr_ucause
, csr_utval
, csr_uip
, csr_sstatus
,
153 csr_sedeleg
, csr_sideleg
, csr_sie
, csr_stvec
,
154 csr_scounteren
, csr_sscratch
, csr_sepc
, csr_scause
,
155 csr_stval
, csr_sip
, csr_satp
, csr_medeleg
,
156 csr_mideleg
, csr_dcsr
, csr_dpc
, csr_dscratch
]:
157 c
[f
] = self
.op_is_valid
.eq(0)
159 # not-writeable -> ok
160 for f
in [csr_cycle
, csr_time
, csr_instret
, csr_cycleh
,
161 csr_timeh
, csr_instreth
, csr_mvendorid
, csr_marchid
,
162 csr_mimpid
, csr_mhartid
]:
163 c
[f
] = self
.op_is_valid
.eq(~self
.writes
)
166 for f
in [csr_misa
, csr_mstatus
, csr_mie
, csr_mtvec
,
167 csr_mscratch
, csr_mepc
, csr_mcause
, csr_mip
]:
168 c
[f
] = self
.op_is_valid
.eq(1)
170 # not implemented / default
171 for f
in [csr_mcounteren
, csr_mtval
, csr_mcycle
, csr_minstret
,
172 csr_mcycleh
, csr_minstreth
, "default"]:
173 c
[f
] = self
.op_is_valid
.eq(0)
175 return Case(self
.number
, c
)
177 def evaluate_csr_funct3_op(self
, funct3
, previous
, written
):
178 c
= { "default": written
.eq(Constant(0, 32))}
179 for f
in [F3
.csrrw
, F3
.csrrwi
]:
180 c
[f
] = written
.eq(self
.input_value
)
181 for f
in [F3
.csrrs
, F3
.csrrsi
]:
182 c
[f
] = written
.eq(self
.input_value | previous
)
183 for f
in [F3
.csrrc
, F3
.csrrci
]:
184 c
[f
] = written
.eq(~self
.input_value
& previous
)
185 return Case(funct3
, c
)
189 def __init__(self
, comb
):
192 self
.cycle_counter
= Signal(64); # TODO: implement cycle_counter
193 self
.time_counter
= Signal(64); # TODO: implement time_counter
194 self
.instret_counter
= Signal(64); # TODO: implement instret_counter
196 self
.mvendorid
= Signal(32)
197 self
.marchid
= Signal(32)
198 self
.mimpid
= Signal(32)
199 self
.mhartid
= Signal(32)
200 self
.comb
+= self
.mvendorid
.eq(Constant(0, 32))
201 self
.comb
+= self
.marchid
.eq(Constant(0, 32))
202 self
.comb
+= self
.mimpid
.eq(Constant(0, 32))
203 self
.comb
+= self
.mhartid
.eq(Constant(0, 32))
206 def __init__(self
, comb
, sync
):
210 self
.ra_en
= Signal(reset
=1, name
="regfile_ra_en") # TODO: ondemand en
211 self
.rs1
= Signal(32, name
="regfile_rs1")
212 self
.rs_a
= Signal(5, name
="regfile_rs_a")
214 self
.rb_en
= Signal(reset
=1, name
="regfile_rb_en") # TODO: ondemand en
215 self
.rs2
= Signal(32, name
="regfile_rs2")
216 self
.rs_b
= Signal(5, name
="regfile_rs_b")
218 self
.w_en
= Signal(name
="regfile_w_en")
219 self
.wval
= Signal(32, name
="regfile_wval")
220 self
.rd
= Signal(32, name
="regfile_rd")
226 def get_lsbm(self
, dc
):
227 return Cat(Constant(1),
228 Mux((dc
.funct3
[1] | dc
.funct3
[0]),
229 Constant(1), Constant(0)),
231 Constant(0b11, 2), Constant(0, 2)))
233 # XXX this happens to get done by various self.sync actions
234 #def reset_to_initial(self, m, mstatus, mie, registers):
235 # return [m.mcause.eq(0),
238 def handle_trap(self
, mcause
, mepc
, mie
, mpie
):
239 s
= [mcause
.eq(self
.new_mcause
),
240 mepc
.eq(self
.new_mepc
),
241 mpie
.eq(self
.new_mpie
),
242 mie
.eq(self
.new_mie
)]
245 def main_block(self
, mtvec
, mip
, minfo
, misa
, csr
, mi
, m
, mstatus
, mie
,
247 load_store_misaligned
,
248 loaded_value
, alu_result
,
252 c
[FOS
.trap
] = self
.handle_trap(m
.mcause
, m
.mepc
,
253 mstatus
.mie
, mstatus
.mpie
)
254 c
[FOS
.valid
] = self
.handle_valid(mtvec
, mip
, minfo
, misa
, csr
, mi
, m
,
255 mstatus
, mie
, ft
, dc
,
256 load_store_misaligned
,
260 return [self
.regs
.w_en
.eq(0),
261 Case(ft
.output_state
, c
),
262 self
.regs
.w_en
.eq(0)]
264 def write_register(self
, rd
, val
):
265 return [self
.regs
.rd
.eq(rd
),
266 self
.regs
.wval
.eq(val
),
270 def handle_valid(self
, mtvec
, mip
, minfo
, misa
, csr
, mi
, m
, mstatus
, mie
,
272 load_store_misaligned
,
273 loaded_value
, alu_result
,
275 # fetch action ack trap
276 i
= If((ft
.action
== FA
.ack_trap
) |
(ft
.action
== FA
.noerror_trap
),
277 self
.handle_trap(m
.mcause
, m
.mepc
, mstatus
.mie
, mstatus
.mpie
)
281 i
= i
.Elif((dc
.act
& DA
.load
) != 0,
283 self
.write_register(dc
.rd
, loaded_value
)
288 i
= i
.Elif((dc
.act
& DA
.op_op_imm
) != 0,
289 self
.write_register(dc
.rd
, alu_result
)
293 i
= i
.Elif((dc
.act
& DA
.lui_auipc
) != 0,
294 self
.write_register(dc
.rd
, lui_auipc_result
)
298 i
= i
.Elif((dc
.act
& (DA
.jal | DA
.jalr
)) != 0,
299 self
.write_register(dc
.rd
, ft
.output_pc
+ 4)
302 i
= i
.Elif((dc
.act
& DA
.csr
) != 0,
303 self
.handle_csr(mtvec
, mip
, minfo
, misa
, mstatus
, mie
, m
,
307 # fence, store, branch
308 i
= i
.Elif((dc
.act
& (DA
.fence | DA
.fence_i |
309 DA
.store | DA
.branch
)) != 0,
315 def handle_csr(self
, mtvec
, mip
, minfo
, misa
, mstatus
, mie
, m
, dc
, csr
):
316 csr_output_value
= Signal(32)
317 csr_written_value
= Signal(32)
321 c
[csr_cycle
] = csr_output_value
.eq(minfo
.cycle_counter
[0:32])
322 c
[csr_cycleh
] = csr_output_value
.eq(minfo
.cycle_counter
[32:64])
324 c
[csr_time
] = csr_output_value
.eq(minfo
.time_counter
[0:32])
325 c
[csr_timeh
] = csr_output_value
.eq(minfo
.time_counter
[32:64])
327 c
[csr_instret
] = csr_output_value
.eq(minfo
.instret_counter
[0:32])
328 c
[csr_instreth
] = csr_output_value
.eq(minfo
.instret_counter
[32:64])
329 # mvendorid/march/mimpl/mhart
330 c
[csr_mvendorid
] = csr_output_value
.eq(minfo
.mvendorid
)
331 c
[csr_marchid
] = csr_output_value
.eq(minfo
.marchid
)
332 c
[csr_mimpid
] = csr_output_value
.eq(minfo
.mimpid
)
333 c
[csr_mhartid
] = csr_output_value
.eq(minfo
.mhartid
)
335 c
[csr_misa
] = csr_output_value
.eq(misa
.misa
)
338 csr_output_value
.eq(mstatus
.mstatus
),
339 csr
.evaluate_csr_funct3_op(dc
.funct3
, csr_output_value
,
341 mstatus
.mpie
.eq(csr_written_value
[7]),
342 mstatus
.mie
.eq(csr_written_value
[3])
346 csr_output_value
.eq(mie
.mie
),
347 csr
.evaluate_csr_funct3_op(dc
.funct3
, csr_output_value
,
349 mie
.meie
.eq(csr_written_value
[11]),
350 mie
.mtie
.eq(csr_written_value
[7]),
351 mie
.msie
.eq(csr_written_value
[3]),
354 c
[csr_mtvec
] = csr_output_value
.eq(mtvec
)
357 csr_output_value
.eq(m
.mscratch
),
358 csr
.evaluate_csr_funct3_op(dc
.funct3
, csr_output_value
,
361 m
.mscratch
.eq(csr_written_value
),
366 csr_output_value
.eq(m
.mepc
),
367 csr
.evaluate_csr_funct3_op(dc
.funct3
, csr_output_value
,
370 m
.mepc
.eq(csr_written_value
),
376 csr_output_value
.eq(m
.mcause
),
377 csr
.evaluate_csr_funct3_op(dc
.funct3
, csr_output_value
,
380 m
.mcause
.eq(csr_written_value
),
386 csr_output_value
.eq(mip
.mip
),
387 csr
.evaluate_csr_funct3_op(dc
.funct3
, csr_output_value
,
391 return [Case(csr
.number
, c
),
393 self
.write_register(dc
.rd
, csr_output_value
)
397 Module
.__init
__(self
)
398 self
.clk
= ClockSignal()
399 self
.reset
= ResetSignal()
400 self
.tty_write
= Signal()
401 self
.tty_write_data
= Signal(8)
402 self
.tty_write_busy
= Signal()
403 self
.switch_2
= Signal()
404 self
.switch_3
= Signal()
405 self
.led_1
= Signal()
406 self
.led_3
= Signal()
408 ram_size
= Constant(0x8000)
409 ram_start
= Constant(0x10000, 32)
410 reset_vector
= Signal(32)
413 reset_vector
.eq(ram_start
)
414 mtvec
.eq(ram_start
+ 0x40)
416 self
.regs
= Regs(self
.comb
, self
.sync
)
418 rf
= Instance("RegFile", name
="regfile",
419 i_ra_en
= self
.regs
.ra_en
,
420 i_rb_en
= self
.regs
.rb_en
,
421 i_w_en
= self
.regs
.w_en
,
422 o_read_a
= self
.regs
.rs1
,
423 o_read_b
= self
.regs
.rs2
,
424 i_writeval
= self
.regs
.wval
,
425 i_rs_a
= self
.regs
.rs_a
,
426 i_rs_b
= self
.regs
.rs_b
,
431 mi
= MemoryInterface()
433 mii
= Instance("cpu_memory_interface", name
="memory_instance",
434 p_ram_size
= ram_size
,
435 p_ram_start
= ram_start
,
438 i_fetch_address
= mi
.fetch_address
,
439 o_fetch_data
= mi
.fetch_data
,
440 o_fetch_valid
= mi
.fetch_valid
,
441 i_rw_address
= mi
.rw_address
,
442 i_rw_byte_mask
= mi
.rw_byte_mask
,
443 i_rw_read_not_write
= mi
.rw_read_not_write
,
444 i_rw_active
= mi
.rw_active
,
445 i_rw_data_in
= mi
.rw_data_in
,
446 o_rw_data_out
= mi
.rw_data_out
,
447 o_rw_address_valid
= mi
.rw_address_valid
,
448 o_rw_wait
= mi
.rw_wait
,
449 o_tty_write
= self
.tty_write
,
450 o_tty_write_data
= self
.tty_write_data
,
451 i_tty_write_busy
= self
.tty_write_busy
,
452 i_switch_2
= self
.switch_2
,
453 i_switch_3
= self
.switch_3
,
454 o_led_1
= self
.led_1
,
459 ft
= Fetch(self
.comb
, self
.sync
)
461 fs
= Instance("CPUFetchStage", name
="fetch_stage",
464 o_memory_interface_fetch_address
= mi
.fetch_address
,
465 i_memory_interface_fetch_data
= mi
.fetch_data
,
466 i_memory_interface_fetch_valid
= mi
.fetch_valid
,
467 i_fetch_action
= ft
.action
,
468 i_target_pc
= ft
.target_pc
,
469 o_output_pc
= ft
.output_pc
,
470 o_output_instruction
= ft
.output_instruction
,
471 o_output_state
= ft
.output_state
,
472 i_reset_vector
= reset_vector
,
479 cd
= Instance("CPUDecoder", name
="decoder",
480 i_instruction
= ft
.output_instruction
,
481 o_funct7
= dc
.funct7
,
482 o_funct3
= dc
.funct3
,
486 o_immediate
= dc
.immediate
,
487 o_opcode
= dc
.opcode
,
488 o_decode_action
= dc
.act
492 self
.comb
+= self
.regs
.rs_a
.eq(dc
.rs1
)
493 self
.comb
+= self
.regs
.rs_b
.eq(dc
.rs2
)
495 load_store_address
= Signal(32)
496 load_store_address_low_2
= Signal(2)
497 load_store_misaligned
= Signal()
498 unmasked_loaded_value
= Signal(32)
499 loaded_value
= Signal(32)
501 lsc
= Instance("CPULoadStoreCalc", name
="cpu_loadstore_calc",
502 i_dc_immediate
= dc
.immediate
,
503 i_dc_funct3
= dc
.funct3
,
504 i_rs1
= self
.regs
.rs1
,
505 i_rs2
= self
.regs
.rs2
,
506 i_rw_data_in
= mi
.rw_data_in
,
507 i_rw_data_out
= mi
.rw_data_out
,
508 o_load_store_address
= load_store_address
,
509 o_load_store_address_low_2
= load_store_address_low_2
,
510 o_load_store_misaligned
= load_store_misaligned
,
511 o_loaded_value
= loaded_value
)
515 # XXX rwaddr not 31:2 any more
516 self
.comb
+= mi
.rw_address
.eq(load_store_address
[2:])
518 unshifted_load_store_byte_mask
= Signal(4)
520 self
.comb
+= unshifted_load_store_byte_mask
.eq(self
.get_lsbm(dc
))
522 # XXX yuck. this will cause migen simulation to fail
523 # (however conversion to verilog works)
524 self
.comb
+= mi
.rw_byte_mask
.eq(
525 _Operator("<<", [unshifted_load_store_byte_mask
,
526 load_store_address_low_2
]))
528 self
.comb
+= mi
.rw_active
.eq(~self
.reset
529 & (ft
.output_state
== FOS
.valid
)
530 & ~load_store_misaligned
531 & ((dc
.act
& (DA
.load | DA
.store
)) != 0))
533 self
.comb
+= mi
.rw_read_not_write
.eq(~dc
.opcode
[5])
538 alu_result
= Signal(32)
540 self
.comb
+= alu_a
.eq(self
.regs
.rs1
)
541 self
.comb
+= alu_b
.eq(Mux(dc
.opcode
[5],
545 ali
= Instance("cpu_alu", name
="alu",
546 i_funct7
= dc
.funct7
,
547 i_funct3
= dc
.funct3
,
548 i_opcode
= dc
.opcode
,
551 o_result
= alu_result
555 lui_auipc_result
= Signal(32)
556 self
.comb
+= lui_auipc_result
.eq(Mux(dc
.opcode
[5],
558 dc
.immediate
+ ft
.output_pc
))
560 self
.comb
+= ft
.target_pc
.eq(Cat(0,
561 Mux(dc
.opcode
!= OP
.jalr
,
563 self
.regs
.rs1
[1:32] + dc
.immediate
[1:32])))
565 misaligned_jump_target
= Signal()
566 self
.comb
+= misaligned_jump_target
.eq(ft
.target_pc
[1])
568 branch_arg_a
= Signal(32)
569 branch_arg_b
= Signal(32)
570 self
.comb
+= branch_arg_a
.eq(Cat( self
.regs
.rs1
[0:31],
571 self
.regs
.rs1
[31] ^ ~dc
.funct3
[1]))
572 self
.comb
+= branch_arg_b
.eq(Cat( self
.regs
.rs2
[0:31],
573 self
.regs
.rs2
[31] ^ ~dc
.funct3
[1]))
575 branch_taken
= Signal()
576 self
.comb
+= branch_taken
.eq(dc
.funct3
[0] ^
578 branch_arg_a
< branch_arg_b
,
579 branch_arg_a
== branch_arg_b
))
581 m
= M(self
.comb
, self
.sync
)
582 mstatus
= MStatus(self
.comb
, self
.sync
)
583 mie
= MIE(self
.comb
, self
.sync
)
584 misa
= Misa(self
.comb
, self
.sync
)
587 mp
= Instance("CPUMIP", name
="cpu_mip",
592 mii
= Instance("CPUMIE", name
="cpu_mie",
600 ms
= Instance("CPUMStatus", name
="cpu_mstatus",
601 o_mstatus
= mstatus
.mstatus
,
602 i_mpie
= mstatus
.mpie
,
608 csr
= CSR(self
.comb
, self
.sync
, dc
, self
.regs
.rs1
)
610 fi
= Instance("CPUFetchAction", name
="cpu_fetch_action",
611 o_fetch_action
= ft
.action
,
612 i_output_state
= ft
.output_state
,
614 i_load_store_misaligned
= load_store_misaligned
,
615 i_mi_rw_wait
= mi
.rw_wait
,
616 i_mi_rw_address_valid
= mi
.rw_address_valid
,
617 i_branch_taken
= branch_taken
,
618 i_misaligned_jump_target
= misaligned_jump_target
,
619 i_csr_op_is_valid
= csr
.op_is_valid
)
623 minfo
= MInfo(self
.comb
)
625 self
.new_mcause
= Signal(32)
626 self
.new_mepc
= Signal(32)
627 self
.new_mpie
= Signal()
628 self
.new_mie
= Signal()
630 ht
= Instance("CPUHandleTrap", "cpu_handle_trap",
631 i_ft_action
= ft
.action
,
632 i_ft_output_pc
= ft
.output_pc
,
633 i_dc_action
= dc
.act
,
634 i_dc_immediate
= dc
.immediate
,
635 i_load_store_misaligned
= load_store_misaligned
,
637 o_mcause
= self
.new_mcause
,
638 o_mepc
= self
.new_mepc
,
639 o_mpie
= self
.new_mpie
,
640 o_mie
= self
.new_mie
)
644 self
.sync
+= If(~self
.reset
,
645 self
.main_block(mtvec
, mip
, minfo
, misa
, csr
, mi
, m
,
646 mstatus
, mie
, ft
, dc
,
647 load_store_misaligned
,
653 if __name__
== "__main__":
655 print(verilog
.convert(example
,
658 example
.tty_write_data
,
659 example
.tty_write_busy
,