radix: reading first page table entry

add walk_tree arguments it needs
see https://bugs.libre-soc.org/show_bug.cgi?id=604#c13

fix address must convert to SelectableInt

call decode_ptre on address to obtain shift, mbits, and pgbase

whitespace

RADIX: call self._walk_tree in ld and st

debug radix mmu ISACaller

comment out broken spr code

_walk_tree: access sprs

create first check_perms RADIX ISACaller function

move Mem class out of ISACaller

cleanup imports

move ISACaller RADIX MMU class to separate module

add pgtable and pte calculation to RADIX ISACaller

Enable VL==0 vector instruction skip test case

Add some extra debug traces to the GTKWave document

Create a new signal for the Simulator to wait on

We wait on "core busy" before simulating an instruction. Trouble is, on a
VL==0 loop, there is no issue, so busy is never toggled. As a solution,
export a new insn_done signal with is pulsed either at end of Execute, or
when going back to Fetch due to skipping a vector instruction.

start adding _get_prtable_addr

actually make it possible to disable svp64 on commandline of test_issuer.py

add option in TestRunner to disable svp64 via commandline test_runner.py nosvp64
currently does nothing

add option to cut out SVP64 from PowerDecoder2

correct comments in sv.add rc=1

Remove the unused internal insn_done signal

This was used previously to enable writing to the PC register, but it's
done now within a state transition.

Fix argument order to match function declaration

No harm was done, since the second inversion undid the first.
Just the VCD traces were switched.

Fix missing NIA update on ISACaller

The effect of this bug was mostly hidden because NIA is later updated at
the end of the SV Loop, in call(). However, in a VL==0 loop, the effect
is apparent, as PC is incremented by 4 instead of 8.

whoops should be "make gitupdate"

RADIX: read SPRs

RADIX: implement memassign and call

add SVSTATE read to DMI interface

Merge WAIT_RESET into INSN_FETCH on the Issue FSM

In a VL==0 loop, while we are skipping vector instructions, there needs to
be a way to stop the core. Unfortunately, this means duplicating the
corresponding code at instruction end, since there is no state in common
on either loop (the VL==0 instruction skip loop and the VL>1 vector loop).

This does makes it a little non-deterministic.

Normally, we would stop the core at instruction end, but could instead end
up stopping at instruction start. For this to happen, you need to stop the
core at the right moment, just after the instruction ended and before
the next instruction begins.

A way to avoid this, if necessary, would be to create a duplicate of the
INSN_FETCH state, that doesn't wait on "core stop" release.

Since we are now waiting on "core stop" release at instruction start
anyway, there is no need for the special WAIT_RESET state anymore.

move DMI stuff to separate function in issuer.py

update comments in issuer.py

add Rc=1 SVP64 unit test to svp64_cases.py

Implement the VL==0 loop

Just after decode, decide whether we proceed to Execute, or shortcut it
directly to the next Fetch.

Allow updating the PC and SVSTATE registers while stopped

While the fetch address was overridden by a PC reset, the PC register
itself was updated (with NIA) only after the first instruction ended. Use
the time while the core is stopped to recognise and update the PC and
SVSTATE registers, before the first instruction starts.

Enable the Simple-V loop test case

Begin to implement the Simple-V loop

After returning from executing an instruction, decide whether to return
to Fetch, or go repeat Execute again.

1) If PC or SVSTATE were updated, go directly to Fetch, without updating
   either
2) If there is no vector output, or it's the last VL loop iteration, go
   back to Fetch as well, but update the PC. In the latter case, also
   reset SRCSTEP
3) Otherwise, we are still in the loop, so increment SVSTEP, and go back
   to Execute. But, first, pass through a new state, DECODE_SV, so the new
   register numbers can be decoded.

Do not reset pc_changed and sv_changed at instruction end

We need these outputs to hold stable, so the Issue FSM can know whether
it can return to the Simple-V loop, or must return to Fetch. A good place
to reset these is at the start, before any instruction is executed.

Make the raw opcode input port of the decoder stay stable

During a Simple-V loop, the decoder will be reused repeatedly, so its
raw opcode input needs to hold stable. An alternate way would be to
pass the raw opcode and the SVP64 RM field to the issue FSM, so it could
supply these decoder inputs when needed.

remove blackbox attribute on SPBlock_512W64B8W

add SPBlock_512W64B8W.v blackbox file

remove sram4k wishbone bte/cti in litex interconnect

litex expects wishbone "err" signals even if not used

extend name of sram4k block with _wb suffix

unit test: pass bool mmu

add comments and more stub functions

add segment_check function, plus quick test.
also fix order because SelectableInt deals in BE

add decode_prte function to RADIX

add trivial LD/ST redirectors into RADIX ISACaller

Move writing of the PC state register to the issue FSM

Before fetch, update the PC state register with the NIA, unless PC was
modified in execute.

Move the wait on "core stop" out of fetch, and into issue

During a Simple-V loop, the fetch FSM will sit idle, unable to pause the
execution. A good alternate place to wait on "core stop" release is at
instruction end, before either fetching a new instruction, or going back
to the SV loop.

On system initialization, we need to pause as well, since there was no
instruction which ended previously.

removing --user from make develop

whitespace

update test_caller_radix.py

ISACaller: add option mmu

whoops microwatt already allocates SPR 720

add comments from gem5-experimental mmu

add cached pgtbl0/3

add two functions for checking permissions, to be based on microwatt

add RADIX skeleton and unit test

add debug strings

remove singleton pattern

add pywriter Makefile entry

cur_state is a global, does not have to be passed as a parameter in TestIssuer

set SVSTATE in TestRunner using new TestIssuer.svstate_i

add svstate_i to TestIssuer which mirrors pc_i

comment out changing SPR 720 because 720 is not supported by the MMU pipe

sort out SPR setting in MMU

operating correctly, not directing MMU SPRs to SPR Pipeline,
failure with PC likely due to ISACaller not supporting SPR 720

must always set ok for writing out data otherwise it never hits regfile
(and causes compunit to fail)

Revert "fix Bug 607 - unnecessary code added related to MMU in PowerDecoder2"

This reverts commit 0b31706069567c4124ebac487f238342cc540d79.

move SVP64 RM decoder to separate module

add additional SVP64 RM decode fields

start on SVP64 RM Mode decoder

more SVP64 enums

add SVP64 RM sub-field enums

move SVP64 Extra decoders to separate module

fix syntax error

move SVP64PrefixDecoder to separate module

add PowerDecoder.no_in_vec

add svp64_instrs to power_svp64

fix Bug 607 - unnecessary code added related to MMU in PowerDecoder2

fix Bug 603 - use SPR names/numbers from sprs.csv

use PowerDecoder2.no_out_vec instead of manual vector detection in ISACaller

add corresponding VL=0 unit test as from 161b7d67b in svp64_cases.py

Add traces for the new FSM

Add a vector case with VL == 0

This will be useful for testing the fetch <-> issue loop.

comment on CoreState

remove sv_changed input to fetch_fsm, add it to issue_fsm TestIssuer

moving new_svstate and update_svstate into issue FSM TestIssuer

move fetch_insn_o into issue_fsm TestIssuer

add comments, missing that VL loop ends after execution if no_out_vec set
SVP64 TestIssuer

Implement a decode/issue FSM between fetch and execute

The idea is for it to:
* keep looping "fetch" while VL==0 on a vector instruction.
* keep looping "execute" while SRCSTEP != VL-1.
* unless PC/SVSTATE was modified by "execute", in that case do go back
to "fetch".
* update PC and SRCSTEP accordingly.

wb_get: write outputs to seperate logfile too

update mmu testcase

test_runner.py: add needed imports

add comments explaining split
https://bugs.libre-soc.org/show_bug.cgi?id=606

move DecodeCROut/In (at last) out of PowerDecoderSubset and into PowerDecoder2
https://bugs.libre-soc.org/show_bug.cgi?id=606

start making write_cr0 independent of DecodeCROut
https://bugs.libre-soc.org/show_bug.cgi?id=606

deduplicate