Subversion Repositories neorv32

:sectnums:

=== Rationale

**Why did you make this?**

I am fascinated by processor and CPU architecture design: it is the magic frontier where software meets hardware.

This project has started as something like a _journey_ into this magic realm to understand how things actually work

down on this very low level.

But there is more! When I started to dive into the emerging RISC-V ecosystem I felt overwhelmed by the complexity.

As a beginner it is hard to get an overview - especially when you want to setup a minimal platform to tinker with:

Which core to use? How to get the right toolchain? What features do I need? How does the booting work? How do I

create an actual executable? How to get that into the hardware? How to customize things? **_Where to start???_**

So this project aims to provides a _simple to understand_ and _easy to use_ yet _powerful_ and _flexible_ platform

that targets FPGA and RISC-V beginners as well as advanced users. Join me and us on this journey! 🙃

**Why a _soft_-core processor?**

As a matter of fact soft-core processors _cannot_ compete with discrete or FPGA hard-macro processors in terms

of performance, energy and size. But they do fill a niche in FPGA design space. For example, soft-core processors

allow to implement the _control flow part_ of certain applications (like communication protocol handling) using

software like plain C. This provides high flexibility as software can be easily changed, re-compiled and

re-uploaded again.

Furthermore, the concept of flexibility applies to all aspects of a soft-core processor. The user can add

_exactly_ the features that are required by the application: additional memories, custom interfaces, specialized

IP and even user-defined instructions.

**Why RISC-V?**

[quote, RISC-V International, https://riscv.org/about/]

____

RISC-V is a free and open ISA enabling a new era of processor innovation through open standard collaboration.

____

While open-source has already become quite popular in _software_, hardware projects still need to catch up.

Admittedly, there has been quite a development, but mainly in terms of _platforms_ and _applications_ (so

schematics, PCBs, etc.). Although processors and CPUs are the heart of almost every digital system, having a true

open-source silicon is still a rarity. RISC-V aims to change that. Even it is _just one approach_, it helps paving

the road for future development.

Furthermore, I welcome the community aspect of RISC-V. The ISA and everything beyond is developed with direct

contact to the community: this includes businesses and professionals but also hobbyist, amateurs and people

that are just curious. Everyone can join discussions and contribute to RISC-V in their very own way.

Finally, I really like the RISC-V ISA itself. It aims to be a clean, orthogonal and "intuitive" ISA that

resembles with the basic concepts of _RISC_: simple yet effective.

**Yet another RISC-V core? What makes it special?**

The NEORV32 is not based on another RISC-V core. It was build entirely from ground up (just following the official

ISA specs) having a different design goal in mind. The project does not intend to replace certain RISC-V cores or

just beat existing ones like https://github.com/SpinalHDL/VexRiscv[VexRISC] in terms of performance or

https://github.com/olofk/serv[SERV] in terms of size.

The project aims to provide _another option_ in the RISC-V / soft-core design space with a different performance

vs. size trade-off and a different focus: _embrace_ concepts like documentation, platform-independence / portability,

RISC-V compatibility, _customization_ and _ease of use_. See the <<_project_key_features>> below.

Furthermore, the NEORV32 pays special focus on _execution safety_ using <<_full_virtualization>>. The CPU aims to

provide fall-backs for _everything that could go wrong_. This includes malformed instruction words, privilege escalations

and even memory accesses that are checked for address space holes and deterministic response times from memory-mapped

devices. Precise exceptions allow a defined and fully-synchronized state of the CPU at every time.

├setups                - Example setups for various FPGAs, boards and toolchains

│└...

│