OpenCores
URL https://opencores.org/ocsvn/neorv32/neorv32/trunk

Subversion Repositories neorv32

[/] [neorv32/] [trunk/] [README.md] - Blame information for rev 45

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 40 zero_gravi
[![NEORV32](https://raw.githubusercontent.com/stnolting/neorv32/master/docs/figures/neorv32_logo.png)](https://github.com/stnolting/neorv32)
2 2 zero_gravi
 
3 37 zero_gravi
# The NEORV32 RISC-V Processor
4
 
5 43 zero_gravi
[![Processor Check](https://github.com/stnolting/neorv32/workflows/Processor%20Check/badge.svg)](https://github.com/stnolting/neorv32/actions?query=workflow%3A%22Processor+Check%22)
6
[![RISC-V Compliance](https://github.com/stnolting/neorv32/workflows/RISC-V%20Compliance/badge.svg)](https://github.com/stnolting/neorv32/actions?query=workflow%3A%22RISC-V+Compliance%22)
7 2 zero_gravi
[![license](https://img.shields.io/github/license/stnolting/neorv32)](https://github.com/stnolting/neorv32/blob/master/LICENSE)
8
[![release](https://img.shields.io/github/v/release/stnolting/neorv32)](https://github.com/stnolting/neorv32/releases)
9
 
10 32 zero_gravi
* [Overview](#Overview)
11
* [Project Status](#Status)
12 2 zero_gravi
* [Features](#Features)
13
* [FPGA Implementation Results](#FPGA-Implementation-Results)
14
* [Performance](#Performance)
15 30 zero_gravi
* [Top Entities](#Top-Entities)
16 2 zero_gravi
* [**Getting Started**](#Getting-Started)
17 40 zero_gravi
* [Contribute/Feedback/Questions](#ContributeFeedbackQuestions)
18 2 zero_gravi
* [Legal](#Legal)
19
 
20
 
21
 
22 32 zero_gravi
## Overview
23 2 zero_gravi
 
24 23 zero_gravi
The NEORV32 Processor is a customizable microcontroller-like system on chip (SoC) that is based
25 36 zero_gravi
on the RISC-V-compliant NEORV32 CPU. The processor is intended as *ready-to-go* auxiliary processor within a larger SoC
26 37 zero_gravi
designs or as stand-alone custom microcontroller.
27 2 zero_gravi
 
28 40 zero_gravi
The project’s change log is available in the [CHANGELOG.md](https://github.com/stnolting/neorv32/blob/master/CHANGELOG.md) file in the root directory of this repository.
29
To see the changes between releases visit the project's [release page](https://github.com/stnolting/neorv32/releases).
30 45 zero_gravi
 
31
The documentation of the software framework is available online on [GitHub-pages](https://stnolting.github.io/neorv32/files.html).
32 40 zero_gravi
For more detailed information take a look at the [:page_facing_up: NEORV32 data sheet](https://raw.githubusercontent.com/stnolting/neorv32/master/docs/NEORV32.pdf) (pdf).
33 11 zero_gravi
 
34 40 zero_gravi
 
35 32 zero_gravi
### Key Features
36 2 zero_gravi
 
37 37 zero_gravi
* RISC-V-[compliant](#Status) 32-bit `rv32i` [**NEORV32 CPU**](#NEORV32-CPU-Features), compliant to
38
  * Subset of the *Unprivileged ISA Specification* [(Version 2.2)](https://github.com/stnolting/neorv32/blob/master/docs/riscv-privileged.pdf)
39
  * Subset of the *Privileged Architecture Specification* [(Version 1.12-draft)](https://github.com/stnolting/neorv32/blob/master/docs/riscv-spec.pdf)
40 45 zero_gravi
* Configurable RISC-V-compliant CPU extensions
41 44 zero_gravi
  * `A` - atomic memory access instructions (optional)
42
  * `B` - Bit manipulation instructions (optional)
43
  * `C` - compressed instructions (16-bit) (optional)
44
  * `E` - embedded CPU (reduced register file (optional)
45
  * `I` - base integer instruction set (always enabled)
46
  * `M` - integer multiplication and division hardware (optional)
47
  * `U` - less-privileged *user mode* (optional)
48
  * `X` - NEORV32_specific extensions (always enabled)
49
  * `Zicsr` - control and status register access instructions (+ exception/irq system) (optional)
50
  * `Zifencei` - instruction stream synchronization (optional)
51
  * `PMP` - physical memory protection (optional)
52
  * `HPM` - hardware performance monitors (optional)
53 39 zero_gravi
* Full-scale RISC-V microcontroller system / **SoC** [**NEORV32 Processor**](#NEORV32-Processor-Features) with optional submodules
54 41 zero_gravi
  * optional embedded memories (instructions/data/bootloader, RAM/ROM) and caches
55 37 zero_gravi
  * timers (watch dog, RISC-V-compliant machine timer)
56 39 zero_gravi
  * serial interfaces (SPI, TWI, UART) and general purpose IO
57 37 zero_gravi
  * external bus interface (Wishbone / [AXI4](#AXI4-Connectivity))
58
  * [more ...](#NEORV32-Processor-Features)
59 36 zero_gravi
* Software framework
60 37 zero_gravi
  * core libraries for high-level usage of the provided functions and peripherals
61
  * application compilation based on [GNU makefiles](https://github.com/stnolting/neorv32/blob/master/sw/example/blink_led/makefile)
62 36 zero_gravi
  * GCC-based toolchain ([pre-compiled toolchains available](https://github.com/stnolting/riscv_gcc_prebuilt))
63 45 zero_gravi
  * bootloader with UART interface console
64 36 zero_gravi
  * runtime environment
65
  * several example programs
66 37 zero_gravi
  * [doxygen-based](https://github.com/stnolting/neorv32/blob/master/docs/doxygen_makefile_sw) documentation: available on [GitHub pages](https://stnolting.github.io/neorv32/files.html)
67 36 zero_gravi
  * [FreeRTOS port](https://github.com/stnolting/neorv32/blob/master/sw/example/demo_freeRTOS) available
68 34 zero_gravi
* [**Full-blown data sheet**](https://raw.githubusercontent.com/stnolting/neorv32/master/docs/NEORV32.pdf) (pdf)
69 32 zero_gravi
* Completely described in behavioral, platform-independent VHDL - no primitives, macros, etc.
70
* Fully synchronous design, no latches, no gated clocks
71
* Small hardware footprint and high operating frequency
72 15 zero_gravi
 
73 22 zero_gravi
 
74 2 zero_gravi
### Design Principles
75
 
76 39 zero_gravi
 * From zero to *hello_world*: Completely open source and documented.
77 2 zero_gravi
 * Plain VHDL without technology-specific parts like attributes, macros or primitives.
78
 * Easy to use – working out of the box.
79
 * Clean synchronous design, no wacky combinatorial interfaces.
80 23 zero_gravi
 * Be as small as possible – but with a reasonable size-performance tradeoff.
81 40 zero_gravi
 * Be as RISC-V-compliant as possible.
82
 * The processor has to fit in a Lattice iCE40 UltraPlus 5k low-power FPGA running at 20+ MHz.
83 2 zero_gravi
 
84
 
85 36 zero_gravi
### Status
86 3 zero_gravi
 
87 31 zero_gravi
The processor is [synthesizable](#FPGA-Implementation-Results) (tested on *real hardware* using Intel Quartus Prime, Xilinx Vivado and Lattice Radiant/Synplify Pro) and can successfully execute
88 30 zero_gravi
all the [provided example programs](https://github.com/stnolting/neorv32/tree/master/sw/example) including the [CoreMark benchmark](#CoreMark-Benchmark).
89 2 zero_gravi
 
90 40 zero_gravi
The processor passes the official `rv32_m/C`, `rv32_m/I`, `rv32_m/M`, `rv32_m/privilege` and `rv32_m/Zifencei`
91
[RISC-V compliance tests (new framework v2)](https://github.com/riscv/riscv-compliance).
92 2 zero_gravi
 
93 43 zero_gravi
| Project component | CI status |
94
|:----------------- |:----------|
95
| [NEORV32 processor](https://github.com/stnolting/neorv32)                                             | [![Processor Check](https://github.com/stnolting/neorv32/workflows/Processor%20Check/badge.svg)](https://github.com/stnolting/neorv32/actions?query=workflow%3A%22Processor+Check%22) |
96
| [SW Framework Documentation (online)](https://stnolting.github.io/neorv32/files.html)                 | [![Doc@GitHub-pages](https://github.com/stnolting/neorv32/workflows/Deploy%20SW%20Framework%20Documentation%20to%20GitHub-Pages/badge.svg)](https://stnolting.github.io/neorv32/files.html) |
97 45 zero_gravi
| [Pre-built toolchains](https://github.com/stnolting/riscv_gcc_prebuilt)                               | [![Test Toolchains](https://github.com/stnolting/riscv_gcc_prebuilt/workflows/Test%20Toolchains/badge.svg)](https://github.com/stnolting/riscv_gcc_prebuilt/actions?query=workflow%3A%22Test+Toolchains%22) |
98 43 zero_gravi
| [RISC-V compliance test](https://github.com/stnolting/neorv32/blob/master/riscv-compliance/README.md) | [![RISC-V Compliance](https://github.com/stnolting/neorv32/workflows/RISC-V%20Compliance/badge.svg)](https://github.com/stnolting/neorv32/actions?query=workflow%3A%22RISC-V+Compliance%22) |
99 6 zero_gravi
 
100
 
101 43 zero_gravi
 
102 39 zero_gravi
### To-Do / Wish List / Help Wanted
103 7 zero_gravi
 
104 35 zero_gravi
* Use LaTeX for data sheet
105 44 zero_gravi
* Further size and performance optimization
106 45 zero_gravi
* Further expand associativity configuration of instruction cache (4x/8x set-associativity)
107
* Add data cache
108 39 zero_gravi
* Burst mode for the external memory/bus interface
109 45 zero_gravi
* RISC-V `F` (using [`Zfinx`](https://github.com/riscv/riscv-zfinx/blob/master/Zfinx_spec.adoc)?) CPU extension (single-precision floating point)
110 44 zero_gravi
* Add template (HW module + intrinsics skeleton) for custom instructions?
111 45 zero_gravi
* Implement further RISC-V (or custom?) CPU extensions
112 42 zero_gravi
* More support for FreeRTOS (like *all* traps)
113 40 zero_gravi
* Port additional RTOSs (like [Zephyr](https://github.com/zephyrproject-rtos/zephyr) or [RIOT](https://www.riot-os.org))
114 45 zero_gravi
* Maybe port [CircuitPython](https://circuitpython.org/) (just for fun)
115 40 zero_gravi
* Add debugger ([RISC-V debug spec](https://github.com/riscv/riscv-debug-spec))
116 36 zero_gravi
* ...
117 40 zero_gravi
* [Ideas?](#ContributeFeedbackQuestions)
118 7 zero_gravi
 
119
 
120 36 zero_gravi
 
121 2 zero_gravi
## Features
122
 
123 34 zero_gravi
The full-blown data sheet of the NEORV32 Processor and CPU is available as pdf file:
124 40 zero_gravi
[:page_facing_up: NEORV32 data sheet](https://raw.githubusercontent.com/stnolting/neorv32/master/docs/NEORV32.pdf).
125 31 zero_gravi
 
126 44 zero_gravi
 
127 36 zero_gravi
### NEORV32 Processor Features
128 2 zero_gravi
 
129 11 zero_gravi
![neorv32 Overview](https://raw.githubusercontent.com/stnolting/neorv32/master/docs/figures/neorv32_processor.png)
130
 
131 23 zero_gravi
The NEORV32 Processor provides a full-scale microcontroller-like SoC based on the NEORV32 CPU. The setup
132 37 zero_gravi
is highly customizable via the processor's top generics and already provides the following *optional* modules:
133 2 zero_gravi
 
134 41 zero_gravi
* processor-internal data and instruction memories (**DMEM** / **IMEM**) & cache (**iCACHE**)
135
* bootloader (**BOOTLDROM**) with UART console and automatic application boot from SPI flash option
136 37 zero_gravi
* machine system timer (**MTIME**), RISC-V-compliant
137
* watchdog timer (**WDT**)
138
* universal asynchronous receiver and transmitter (**UART**) with simulation output option via text.io
139
* 8/16/24/32-bit serial peripheral interface controller (**SPI**) with 8 dedicated chip select lines
140
* two wire serial interface controller (**TWI**), with optional clock-stretching, compatible to the I²C standard
141
* general purpose parallel IO port (**GPIO**), 32xOut & 32xIn, with pin-change interrupt
142
* 32-bit external bus interface, Wishbone b4 compliant (**WISHBONE**), *standard* or *pipelined* handshake/transactions mode
143
* wrapper for **AXI4-Lite Master Interface** (see [AXI Connectivity](#AXI4-Connectivity))
144
* PWM controller with 4 channels and 8-bit duty cycle resolution (**PWM**)
145
* GARO-based true random number generator (**TRNG**)
146
* custom functions units (**CFU0** and **CFU1**) for tightly-coupled custom co-processors
147
* system configuration information memory to check hardware configuration by software (**SYSINFO**, mandatory - not *optional*)
148 23 zero_gravi
 
149 44 zero_gravi
 
150 36 zero_gravi
### NEORV32 CPU Features
151 2 zero_gravi
 
152 40 zero_gravi
The NEORV32 CPU is **compliant** to the
153 12 zero_gravi
[official RISC-V specifications (2.2)](https://raw.githubusercontent.com/stnolting/neorv32/master/docs/riscv-spec.pdf) including a subset of the
154 40 zero_gravi
[RISC-V privileged architecture specifications (1.12-draft)](https://raw.githubusercontent.com/stnolting/neorv32/master/docs/riscv-spec.pdf)
155
tested via the [official RISC-V Compliance Test Framework](https://github.com/riscv/riscv-compliance)
156
(see [`riscv-compliance/README`](https://github.com/stnolting/neorv32/blob/master/riscv-compliance/README.md)).
157 2 zero_gravi
 
158 11 zero_gravi
More information regarding the CPU including a detailed list of the instruction set and the available CSRs can be found in
159 40 zero_gravi
the [:page_facing_up: NEORV32 data sheet](https://raw.githubusercontent.com/stnolting/neorv32/master/docs/NEORV32.pdf).
160 11 zero_gravi
 
161
 
162
**General**:
163 26 zero_gravi
  * Modified Harvard architecture (separate CPU interfaces for data and instructions; NEORV32 processor: Single processor-internal bus via I/D mux)
164 12 zero_gravi
  * Two stages in-order pipeline (FETCH, EXECUTE); each stage uses a multi-cycle processing scheme
165 15 zero_gravi
  * No hardware support of unaligned accesses - they will trigger an exception
166 40 zero_gravi
  * BIG-ENDIAN byte-order, processor's external memory interface allows endianness configuration to connect to system with different endianness
167 23 zero_gravi
  * All reserved or unimplemented instructions will raise an illegal instruction exception
168 15 zero_gravi
  * Privilege levels: `machine` mode, `user` mode (if enabled via `U` extension)
169 33 zero_gravi
  * Official [RISC-V open-source architecture ID](https://github.com/riscv/riscv-isa-manual/blob/master/marchid.md)
170 11 zero_gravi
 
171
 
172 3 zero_gravi
**RV32I base instruction set** (`I` extension):
173 2 zero_gravi
  * ALU instructions: `LUI` `AUIPC` `ADDI` `SLTI` `SLTIU` `XORI` `ORI` `ANDI` `SLLI` `SRLI` `SRAI` `ADD` `SUB` `SLL` `SLT` `SLTU` `XOR` `SRL` `SRA` `OR` `AND`
174 7 zero_gravi
  * Jump and branch instructions: `JAL` `JALR` `BEQ` `BNE` `BLT` `BGE` `BLTU` `BGEU`
175 2 zero_gravi
  * Memory instructions: `LB` `LH` `LW` `LBU` `LHU` `SB` `SH` `SW`
176 8 zero_gravi
  * System instructions: `ECALL` `EBREAK` `FENCE`
177 40 zero_gravi
  * Pseudo-instructions are not listed
178 2 zero_gravi
 
179 3 zero_gravi
**Compressed instructions** (`C` extension):
180 2 zero_gravi
  * ALU instructions: `C.ADDI4SPN` `C.ADDI` `C.ADD` `C.ADDI16SP` `C.LI` `C.LUI` `C.SLLI` `C.SRLI` `C.SRAI` `C.ANDI` `C.SUB` `C.XOR` `C.OR` `C.AND` `C.MV` `C.NOP`
181 7 zero_gravi
  * Jump and branch instructions: `C.J` `C.JAL` `C.JR` `C.JALR` `C.BEQZ` `C.BNEZ`
182 2 zero_gravi
  * Memory instructions: `C.LW` `C.SW` `C.LWSP` `C.SWSP`
183 25 zero_gravi
  * System instructions: `C.EBREAK` (only with `Zicsr` extension)
184 40 zero_gravi
  * Pseudo-instructions are not listed
185 2 zero_gravi
 
186 3 zero_gravi
**Embedded CPU version** (`E` extension):
187 2 zero_gravi
  * Reduced register file (only the 16 lowest registers)
188
 
189 3 zero_gravi
**Integer multiplication and division hardware** (`M` extension):
190 2 zero_gravi
  * Multiplication instructions: `MUL` `MULH` `MULHSU` `MULHU`
191
  * Division instructions: `DIV` `DIVU` `REM` `REMU`
192 19 zero_gravi
  * By default, the multiplier and divider cores use an iterative bit-serial processing scheme
193
  * Multiplications can be mapped to DSPs via the `FAST_MUL_EN` generic to increase performance
194 2 zero_gravi
 
195 39 zero_gravi
**Atomic memory access** (`A` extension):
196 40 zero_gravi
  * Supported instructions: `LR.W` (load-reservate) `SC.W` (store-conditional)
197 39 zero_gravi
 
198 44 zero_gravi
**Bit manipulation instructions** (`B` extension implying `Zbb` extension):
199
  * :warning: RISC-V `B` extension is not officially ratified yet!
200
  * Compatible to [v0.94-draft](https://raw.githubusercontent.com/stnolting/neorv32/master/docs/bitmanip-draft.pdf) of the bit manipulation spec
201
  * Support via intrisc library (see [`sw/example/bit_manipulation`](https://github.com/stnolting/neorv32/tree/master/sw/example/bit_manipulation))
202
  * Only the `Zbb` base instructions subset is supported yet
203
  * Supported instructions: `CLZ` `CTZ` `CPOP` `SEXT.B` `SEXT.H` `MIN[U]` `MAX[U]` `ANDN` `ORN` `XNOR` `ROL` `ROR` `RORI` `zext`(*pseudo-instruction* for `PACK rd, rs, zero`) `rev8`(*pseudo-instruction* for `GREVI rd, rs, -8`) `orc.b`(*pseudo-instruction* for `GORCI rd, rs, 7`)
204
 
205 8 zero_gravi
**Privileged architecture / CSR access** (`Zicsr` extension):
206 2 zero_gravi
  * Privilege levels: `M-mode` (Machine mode)
207
  * CSR access instructions: `CSRRW` `CSRRS` `CSRRC` `CSRRWI` `CSRRSI` `CSRRCI`
208 8 zero_gravi
  * System instructions: `MRET` `WFI`
209 40 zero_gravi
  * Pseudo-instructions are not listed
210 42 zero_gravi
  * Counter CSRs: `[m]cycle[h]` `[m]instret[m]` `time[h]` `[m]hpmcounter*[h]`(3..31, configurable) `mcounteren` `mcountinhibit` `mhpmevent*`(3..31, configurable)
211
  * Machine CSRs: `mstatus[h]` `misa`(read-only!) `mie` `mtvec` `mscratch` `mepc` `mcause` `mtval` `mip` `mvendorid` [`marchid`](https://github.com/riscv/riscv-isa-manual/blob/master/marchid.md) `mimpid` `mhartid` `mzext`(custom)
212 2 zero_gravi
  * Supported exceptions and interrupts:
213
    * Misaligned instruction address
214 38 zero_gravi
    * Instruction access fault (via unacknowledged bus access after timeout)
215 2 zero_gravi
    * Illegal instruction
216 4 zero_gravi
    * Breakpoint (via `ebreak` instruction)
217 2 zero_gravi
    * Load address misaligned
218 38 zero_gravi
    * Load access fault (via unacknowledged bus access after timeout)
219 4 zero_gravi
    * Store address misaligned
220 38 zero_gravi
    * Store access fault (via unacknowledged bus access after timeout)
221 40 zero_gravi
    * Environment call from U-mode (via `ecall` instruction in user mode)
222
    * Environment call from M-mode (via `ecall` instruction in machine mode)
223
    * Machine timer interrupt `mti` (via processor's MTIME unit / external signal)
224 15 zero_gravi
    * Machine software interrupt `msi` (via external signal)
225
    * Machine external interrupt `mei` (via external signal)
226
    * Four fast interrupt requests (custom extension)
227 2 zero_gravi
 
228 15 zero_gravi
**Privileged architecture / User mode** (`U` extension, requires `Zicsr` extension):
229 16 zero_gravi
  * Privilege levels: `M-mode` (Machine mode) + `U-mode` (User mode)
230 15 zero_gravi
 
231 44 zero_gravi
**Privileged architecture / Instruction stream synchronization** (`Zifencei` extension):
232 41 zero_gravi
  * System instructions: `FENCE.I` (among others, used to clear and reload instruction cache)
233 8 zero_gravi
 
234 18 zero_gravi
**Privileged architecture / Physical memory protection** (`PMP`, requires `Zicsr` extension):
235 44 zero_gravi
  * Configurable number of regions (0..63)
236 42 zero_gravi
  * Additional machine CSRs: `pmpcfg*`(0..15) `pmpaddr*`(0..63)
237 2 zero_gravi
 
238 44 zero_gravi
**Privileged architecture / Hardware performance monitors** (`HPM`, requires `Zicsr` extension):
239
  * Configurable number of counters (0..29)
240
  * Additional machine CSRs: `mhpmevent*`(3..31) `[m]hpmcounter*[h]`(3..31)
241 15 zero_gravi
 
242 23 zero_gravi
 
243 44 zero_gravi
### :warning: Non-RISC-V-Compliant Issues and Limitations
244
 
245 40 zero_gravi
* CPU and Processor are BIG-ENDIAN, but this should be no problem as the external memory bus interface provides big- and little-endian configurations
246 30 zero_gravi
* `misa` CSR is read-only - no dynamic enabling/disabling of synthesized CPU extensions during runtime; for compatibility: write accesses (in m-mode) are ignored and do not cause an exception
247 42 zero_gravi
* The physical memory protection (**PMP**) only supports `NAPOT` mode yet and a minimal granularity of 8 bytes
248 39 zero_gravi
* The `A` extension only implements `lr.w` and `sc.w` instructions yet. However, these instructions are sufficient to emulate all further AMO operations
249 44 zero_gravi
* The `mcause` trap code `0x80000000` (originally reserved in the RISC-V specs) is used to indicate a hardware reset (as "non-maskable interrupt")
250
* The bit manipulation extension is not yet officially ratified, but is expected to stay unchanged. There is no software support in the upstream GCC RISC-V port yet. However, an intrinsic library is provided to utilize the provided bit manipulation extension from C-language code (see [`sw/example/bit_manipulation`](https://github.com/stnolting/neorv32/tree/master/sw/example/bit_manipulation)). NEORV32's `B`/`Zbb` extension is compliant to spec. version "0.94-draft".
251 23 zero_gravi
 
252
### NEORV32-Specific CPU Extensions
253
 
254
The NEORV32-specific extensions are always enabled and are indicated via the `X` bit in the `misa` CSR.
255
 
256
* Four *fast interrupt* request channels with according control/status bits in `mie` and `mip` and custom exception codes in `mcause`
257
* `mzext` CSR to check for implemented `Z*` CPU extensions (like `Zifencei`)
258 40 zero_gravi
* All undefined/umimplemented/malformed/illegal instructions do raise an illegal instruction exception
259 23 zero_gravi
 
260
 
261
 
262 2 zero_gravi
## FPGA Implementation Results
263
 
264 23 zero_gravi
### NEORV32 CPU
265
 
266
This chapter shows exemplary implementation results of the NEORV32 CPU for an **Intel Cyclone IV EP4CE22F17C6N FPGA** on
267 37 zero_gravi
a DE0-nano board. The design was synthesized using **Intel Quartus Prime Lite 20.1** ("balanced implementation"). The timing
268 4 zero_gravi
information is derived from the Timing Analyzer / Slow 1200mV 0C Model. If not otherwise specified, the default configuration
269 42 zero_gravi
of the CPU's generics is assumed (e.g. no physical memory protection, no hardware performance monitors).
270
No constraints were used at all. The `u` and `Zifencei` extensions have a negligible impact on the hardware requirements.
271 2 zero_gravi
 
272 45 zero_gravi
Results generated for hardware version [`1.5.0.3`](https://github.com/stnolting/neorv32/blob/master/CHANGELOG.md).
273 2 zero_gravi
 
274 44 zero_gravi
| CPU Configuration                        | LEs        | FFs      | Memory bits | DSPs | f_max   |
275
|:-----------------------------------------|:----------:|:--------:|:-----------:|:----:|:-------:|
276 45 zero_gravi
| `rv32i`                                  |       1190 |      512 |        1024 |    0 | 120 MHz |
277
| `rv32i`     + `u` + `Zicsr` + `Zifencei` |       1927 |      903 |        1024 |    0 | 123 MHz |
278
| `rv32im`    + `u` + `Zicsr` + `Zifencei` |       2471 |     1148 |        1024 |    0 | 120 MHz |
279
| `rv32imc`   + `u` + `Zicsr` + `Zifencei` |       2716 |     1165 |        1024 |    0 | 120 MHz |
280
| `rv32imac`  + `u` + `Zicsr` + `Zifencei` |       2736 |     1168 |        1024 |    0 | 120 MHz |
281
| `rv32imacb` + `u` + `Zicsr` + `Zifencei` |       3045 |     1260 |        1024 |    0 | 114 MHz |
282 2 zero_gravi
 
283 39 zero_gravi
Setups with enabled "embedded CPU extension" `E` show the same LUT and FF utilization and identical f_max. However, the size of the register file is cut in half.
284 2 zero_gravi
 
285 39 zero_gravi
 
286 23 zero_gravi
### NEORV32 Processor-Internal Peripherals and Memories
287
 
288 45 zero_gravi
Results generated for hardware version [`1.5.0.3`](https://github.com/stnolting/neorv32/blob/master/CHANGELOG.md).
289 11 zero_gravi
 
290 25 zero_gravi
| Module    | Description                                          | LEs | FFs | Memory bits | DSPs |
291 31 zero_gravi
|:----------|:-----------------------------------------------------|----:|----:|------------:|-----:|
292 37 zero_gravi
| BOOT ROM  | Bootloader ROM (default 4kB)                         |   3 |   1 |      32 768 |    0 |
293 40 zero_gravi
| BUSSWITCH | Mux for CPU I & D interfaces                         |  65 |   8 |           0 |    0 |
294 45 zero_gravi
| i-CACHE   | Proc.-int. nstruction cache (default 1x4x64 bytes)   | 234 | 156 |       8 192 |    0 |
295 34 zero_gravi
| CFU0      | Custom functions unit 0                              |   - |   - |           - |    - |
296
| CFU1      | Custom functions unit 1                              |   - |   - |           - |    - |
297 39 zero_gravi
| DMEM      | Processor-internal data memory (default 8kB)         |   6 |   2 |      65 536 |    0 |
298 40 zero_gravi
| GPIO      | General purpose input/output ports                   |  67 |  65 |           0 |    0 |
299 39 zero_gravi
| IMEM      | Processor-internal instruction memory (default 16kb) |   6 |   2 |     131 072 |    0 |
300 40 zero_gravi
| MTIME     | Machine system timer                                 | 274 | 166 |           0 |    0 |
301 39 zero_gravi
| PWM       | Pulse-width modulation controller                    |  71 |  69 |           0 |    0 |
302 40 zero_gravi
| SPI       | Serial peripheral interface                          | 138 | 124 |           0 |    0 |
303
| SYSINFO   | System configuration information memory              |  11 |  10 |           0 |    0 |
304 31 zero_gravi
| TRNG      | True random number generator                         | 132 | 105 |           0 |    0 |
305 40 zero_gravi
| TWI       | Two-wire interface                                   |  77 |  46 |           0 |    0 |
306
| UART      | Universal asynchronous receiver/transmitter          | 176 | 132 |           0 |    0 |
307
| WDT       | Watchdog timer                                       |  60 |  45 |           0 |    0 |
308 39 zero_gravi
| WISHBONE  | External memory interface                            | 129 | 104 |           0 |    0 |
309 2 zero_gravi
 
310
 
311 23 zero_gravi
### NEORV32 Processor - Exemplary FPGA Setups
312 6 zero_gravi
 
313 34 zero_gravi
Exemplary processor implementation results for different FPGA platforms. The processor setup uses *the default peripheral configuration* (like no _CFUs_ and no _TRNG_),
314 23 zero_gravi
no external memory interface and only internal instruction and data memories. IMEM uses 16kB and DMEM uses 8kB memory space. The setup's top entity connects most of the
315 11 zero_gravi
processor's [top entity](https://github.com/stnolting/neorv32/blob/master/rtl/core/neorv32_top.vhd) signals
316 40 zero_gravi
to FPGA pins - except for the Wishbone bus and the interrupt signals. The "default" strategy of each toolchain is used.
317 6 zero_gravi
 
318 40 zero_gravi
Results generated for hardware version [`1.4.9.0`](https://github.com/stnolting/neorv32/blob/master/CHANGELOG.md).
319 6 zero_gravi
 
320 40 zero_gravi
| Vendor  | FPGA                              | Board            | Toolchain                  | CPU Configuration                              | LUT / LE   | FF / REG   | DSP    | Memory Bits  | BRAM / EBR | SPRAM    | Frequency     |
321
|:--------|:----------------------------------|:-----------------|:---------------------------|:-----------------------------------------------|:-----------|:-----------|:-------|:-------------|:-----------|:---------|--------------:|
322
| Intel   | Cyclone IV `EP4CE22F17C6N`        | Terasic DE0-Nano | Quartus Prime Lite 20.1    | `rv32imc` + `u` + `Zicsr` + `Zifencei`         | 3813 (17%) | 1904  (8%) | 0 (0%) | 231424 (38%) |          - |        - |       119 MHz |
323
| Lattice | iCE40 UltraPlus `iCE40UP5K-SG48I` | Upduino v2.0     | Radiant 2.1 (Synplify Pro) | `rv32ic`  + `u` + `Zicsr` + `Zifencei`         | 4397 (83%) | 1679 (31%) | 0 (0%) |            - |   12 (40%) | 4 (100%) | *c* 22.15 MHz |
324
| Xilinx  | Artix-7 `XC7A35TICSG324-1L`       | Arty A7-35T      | Vivado 2019.2              | `rv32imc` + `u` + `Zicsr` + `Zifencei` + `PMP` | 2465 (12%) | 1912  (5%) | 0 (0%) |            - |    8 (16%) |        - |   *c* 100 MHz |
325 2 zero_gravi
 
326 23 zero_gravi
**_Notes_**
327 20 zero_gravi
* The Lattice iCE40 UltraPlus setup uses the FPGA's SPRAM memory primitives for the internal IMEM and DMEM (each 64kb).
328 12 zero_gravi
The FPGA-specific memory components can be found in [`rtl/fpga_specific`](https://github.com/stnolting/neorv32/blob/master/rtl/fpga_specific/lattice_ice40up).
329
* The clock frequencies marked with a "c" are constrained clocks. The remaining ones are _f_max_ results from the place and route timing reports.
330 11 zero_gravi
* The Upduino and the Arty board have on-board SPI flash memories for storing the FPGA configuration. These device can also be used by the default NEORV32
331
bootloader to store and automatically boot an application program after reset (both tested successfully).
332 40 zero_gravi
* The setups with `PMP` implement 2 regions with a minimal granularity of 64kB.
333 42 zero_gravi
* No HPM counters are implemented.
334 2 zero_gravi
 
335 22 zero_gravi
 
336
 
337 2 zero_gravi
## Performance
338
 
339
### CoreMark Benchmark
340
 
341
The [CoreMark CPU benchmark](https://www.eembc.org/coremark) was executed on the NEORV32 and is available in the
342
[sw/example/coremark](https://github.com/stnolting/neorv32/blob/master/sw/example/coremark) project folder. This benchmark
343
tests the capabilities of a CPU itself rather than the functions provided by the whole system / SoC.
344
 
345
~~~
346
**Configuration**
347 45 zero_gravi
Hardware:       32kB IMEM, 16kB DMEM, no caches, 100MHz clock
348 38 zero_gravi
CoreMark:       2000 iterations, MEM_METHOD is MEM_STACK
349
Compiler:       RISCV32-GCC 10.1.0 (rv32i toolchain)
350
Compiler flags: default, see makefile
351
Peripherals:    UART for printing the results
352 2 zero_gravi
~~~
353
 
354 42 zero_gravi
Results generated for hardware version [`1.4.9.8`](https://github.com/stnolting/neorv32/blob/master/CHANGELOG.md).
355
 
356
| CPU (including `Zicsr`)                     | Executable Size | Optimization | CoreMark Score | CoreMarks/MHz |
357 34 zero_gravi
|:--------------------------------------------|:---------------:|:------------:|:--------------:|:-------------:|
358 42 zero_gravi
| `rv32i`                                     |    28 756 bytes |        `-O3` |          36.36 |    **0.3636** |
359
| `rv32im`                                    |    27 516 bytes |        `-O3` |          68.97 |    **0.6897** |
360
| `rv32imc`                                   |    22 008 bytes |        `-O3` |          68.97 |    **0.6897** |
361
| `rv32imc` + `FAST_MUL_EN`                   |    22 008 bytes |        `-O3` |          86.96 |    **0.8696** |
362
| `rv32imc` + `FAST_MUL_EN` + `FAST_SHIFT_EN` |    22 008 bytes |        `-O3` |          90.91 |    **0.9091** |
363 2 zero_gravi
 
364 34 zero_gravi
The `FAST_MUL_EN` configuration uses DSPs for the multiplier of the `M` extension (enabled via the `FAST_MUL_EN` generic). The `FAST_SHIFT_EN` configuration
365
uses a barrel shifter for CPU shift operations (enabled via the `FAST_SHIFT_EN` generic).
366 2 zero_gravi
 
367 31 zero_gravi
When the `C` extension is enabled, branches to an unaligned uncompressed instruction require additional instruction fetch cycles.
368 22 zero_gravi
 
369 34 zero_gravi
 
370 2 zero_gravi
### Instruction Cycles
371
 
372 11 zero_gravi
The NEORV32 CPU is based on a two-stages pipelined architecutre. Each stage uses a multi-cycle processing scheme. Hence,
373 9 zero_gravi
each instruction requires several clock cycles to execute (2 cycles for ALU operations, ..., 40 cycles for divisions).
374
The average CPI (cycles per instruction) depends on the instruction mix of a specific applications and also on the available
375 42 zero_gravi
CPU extensions. *By default* the CPU-internal shifter (e.g. for the `SLL` instruction) as well as the multiplier and divider of the
376 2 zero_gravi
`M` extension use a bit-serial approach and require several cycles for completion.
377
 
378 6 zero_gravi
The following table shows the performance results for successfully running 2000 CoreMark
379 9 zero_gravi
iterations, which reflects a pretty good "real-life" work load. The average CPI is computed by
380 12 zero_gravi
dividing the total number of required clock cycles (only the timed core to avoid distortion due to IO wait cycles; sampled via the `cycle[h]` CSRs)
381 19 zero_gravi
by the number of executed instructions (`instret[h]` CSRs). The executables were generated using optimization `-O3`.
382 2 zero_gravi
 
383 42 zero_gravi
Results generated for hardware version [`1.4.9.8`](https://github.com/stnolting/neorv32/blob/master/CHANGELOG.md).
384 2 zero_gravi
 
385 42 zero_gravi
| CPU  (including `Zicsr`)                    | Required Clock Cycles | Executed Instructions | Average CPI |
386 34 zero_gravi
|:--------------------------------------------|----------------------:|----------------------:|:-----------:|
387 42 zero_gravi
| `rv32i`                                     |         5 595 750 503 |         1 466 028 607 |    **3.82** |
388
| `rv32im`                                    |         2 966 086 503 |           598 651 143 |    **4.95** |
389
| `rv32imc`                                   |         2 981 786 734 |           611 814 918 |    **4.87** |
390
| `rv32imc` + `FAST_MUL_EN`                   |         2 399 234 734 |           611 814 918 |    **3.92** |
391
| `rv32imc` + `FAST_MUL_EN` + `FAST_SHIFT_EN` |         2 265 135 174 |           611 814 948 |    **3.70** |
392 2 zero_gravi
 
393 34 zero_gravi
The `FAST_MUL_EN` configuration uses DSPs for the multiplier of the `M` extension (enabled via the `FAST_MUL_EN` generic). The `FAST_SHIFT_EN` configuration
394
uses a barrel shifter for CPU shift operations (enabled via the `FAST_SHIFT_EN` generic).
395
 
396 36 zero_gravi
When the `C` extension is enabled branches to an unaligned uncompressed instruction require additional instruction fetch cycles.
397 12 zero_gravi
 
398 22 zero_gravi
 
399 31 zero_gravi
 
400 14 zero_gravi
## Top Entities
401 2 zero_gravi
 
402 36 zero_gravi
The top entity of the **NEORV32 Processor** (SoC) is [`rtl/core/neorv32_top.vhd`](https://github.com/stnolting/neorv32/blob/master/rtl/core/neorv32_top.vhd).
403 2 zero_gravi
 
404 36 zero_gravi
All signals of the top entity are of type *std_ulogic* or *std_ulogic_vector*, respectively
405 34 zero_gravi
(except for the processor's TWI signals, which are of type *std_logic*). Leave all unused output ports unconnected (`open`) and tie all unused
406
input ports to zero (`'0'` or `(others => '0')`, respectively).
407 14 zero_gravi
 
408 36 zero_gravi
Use the top's generics to configure the system according to your needs. Each generic is initilized with the default configuration.
409 34 zero_gravi
Detailed information regarding the interface signals and configuration generics can be found in
410 40 zero_gravi
the [:page_facing_up: NEORV32 data sheet](https://raw.githubusercontent.com/stnolting/neorv32/master/docs/NEORV32.pdf) (pdf).
411 22 zero_gravi
 
412 23 zero_gravi
 
413 36 zero_gravi
### Using the CPU in Stand-Alone Mode
414 23 zero_gravi
 
415 36 zero_gravi
If you do not want to use the NEORV32 processor setup, you can also use the CPU in stand-alone mode and build your own system around it.
416
The top entity of the stand-alone **NEORV32 CPU** is [`rtl/core/neorv32_cpu.vhd`](https://github.com/stnolting/neorv32/blob/master/rtl/core/neorv32_cpu.vhd).
417
Note that the CPU uses a proprietary interface for accessing data and instruction memory. More information can be found in the
418 40 zero_gravi
[:page_facing_up: NEORV32 data sheet](https://raw.githubusercontent.com/stnolting/neorv32/master/docs/NEORV32.pdf).
419 14 zero_gravi
 
420 36 zero_gravi
:warning: It is recommended to use the processor setup even if you only want to use the CPU. Simply disable all the processor-internal modules via the generics
421
and you will get a "CPU wrapper" that provides a minimal CPU environment and an external memory interface (like AXI4). This setup also allows to further use the default
422
bootloader and application makefiles. From this base you can start building your own processor system.
423 2 zero_gravi
 
424 36 zero_gravi
 
425
### Alternative Top Entities
426
 
427
*Alternative top entities*, like the simplified ["hello world" test setup](#Create-a-new-Hardware-Project) or CPU/Processor
428
wrappers with resolved port signal types (i.e. *std_logic*), can be found in [`rtl/top_templates`](https://github.com/stnolting/neorv32/blob/master/rtl/top_templates).
429
 
430
 
431 35 zero_gravi
### AXI4 Connectivity
432 22 zero_gravi
 
433 35 zero_gravi
Via the [`rtl/top_templates/neorv32_top_axi4lite.vhd`](https://github.com/stnolting/neorv32/blob/master/rtl/top_templates/neorv32_top_axi4lite.vhd)
434
wrapper the NEORV32 provides an **AXI4-Lite** compatible master interface. This wrapper instantiates the default
435
[NEORV32 processor top entitiy](https://github.com/stnolting/neorv32/blob/master/rtl/core/neorv32_top.vhd) and implements a Wishbone to AXI4-Lite bridge.
436 2 zero_gravi
 
437 35 zero_gravi
The AXI4-Lite interface has been tested using Xilinx Vivado 19.2 block designer:
438
 
439
![AXI-SoC](https://raw.githubusercontent.com/stnolting/neorv32/master/docs/figures/neorv32_axi_soc.png)
440
 
441
The processor was packed as custom IP using `neorv32_top_axi4lite.vhd` as top entity. The AXI interface is automatically detected by the packager.
442
All remaining IO interfaces are available as custom signals. The configuration generics are available via the "customize IP" dialog.
443
In the figure above the resulting IP block is named "neorv32_top_axi4lite_v1_0".
444
*(Note: Use Syntheiss option "global" when generating the block design to maintain the internal TWI tri-state drivers.)*
445
 
446
The setup uses an AXI interconnect to attach two block RAMs to the processor. Since the processor in this example is configured *without* IMEM and DMEM,
447
the attached block RAMs are used for storing instructions and data: the first RAM is used as instruction memory
448
and is mapped to address `0x00000000 - 0x00003fff` (16kB), the second RAM is used as data memory and is mapped to address `0x80000000 - 0x80001fff` (8kB).
449
 
450
 
451
 
452 2 zero_gravi
## Getting Started
453
 
454
This overview is just a short excerpt from the *Let's Get It Started* section of the NEORV32 documentary:
455
 
456 40 zero_gravi
[:page_facing_up: NEORV32 data sheet](https://raw.githubusercontent.com/stnolting/neorv32/master/docs/NEORV32.pdf)
457 2 zero_gravi
 
458
 
459 14 zero_gravi
### Toolchain
460 2 zero_gravi
 
461
At first you need the **RISC-V GCC toolchain**. You can either [download the sources](https://github.com/riscv/riscv-gnu-toolchain)
462
and build the toolchain by yourself, or you can download a prebuilt one and install it.
463
 
464 23 zero_gravi
To build the toolchain by yourself, follow the official [build instructions](https://github.com/riscv/riscv-gnu-toolchain).
465 14 zero_gravi
Make sure to use the `ilp32` or `ilp32e` ABI.
466 2 zero_gravi
 
467 15 zero_gravi
**Alternatively**, you can download a prebuilt toolchain. I have uploaded the toolchains I am using to GitHub. These toolchains
468 40 zero_gravi
were compiled on a 64-bit x86 Ubuntu 20.04 LTS (Ubuntu on Windows, actually). Download the toolchain of choice:
469
[:octocat: github.com/stnolting/riscv_gcc_prebuilt](https://github.com/stnolting/riscv_gcc_prebuilt)
470 2 zero_gravi
 
471 45 zero_gravi
You can also use the toolchains provided by [SiFive](https://github.com/sifive/freedom-tools/releases). These are 64-bit toolchains that can also emit 32-bit
472
RISC-V code. They were compiled for more sophisticated machines (`imac`) so the according hardware extensions are *mandatory*
473 2 zero_gravi
 
474 45 zero_gravi
:warning: Keep in mind that – for instance – a `rv32imc` toolchain only provides library code compiled with compressed and
475
`mul`/`div` instructions! Hence, this code cannot be executed (without emulation) on an architecture without these extensions!
476
 
477
 
478 22 zero_gravi
### Dowload the NEORV32 Project
479 2 zero_gravi
 
480 23 zero_gravi
Get the sources of the NEORV32 Processor project. The simplest way is using `git clone` (suggested for easy project updates via `git pull`):
481 12 zero_gravi
 
482 2 zero_gravi
    $ git clone https://github.com/stnolting/neorv32.git
483
 
484 23 zero_gravi
Alternatively, you can either download a specific [release](https://github.com/stnolting/neorv32/releases) or get the most recent version
485
of this project as [`*.zip` file](https://github.com/stnolting/neorv32/archive/master.zip).
486 2 zero_gravi
 
487 22 zero_gravi
 
488
### Create a new Hardware Project
489
 
490 23 zero_gravi
Create a new project with your FPGA design tool of choice. Add all the `*.vhd` files from the [`rtl/core`](https://github.com/stnolting/neorv32/blob/master/rtl)
491
folder to this project. Make sure to add these files to a **new design library** called `neorv32`.
492
 
493 40 zero_gravi
You can either instantiate the [processor's top entity](https://github.com/stnolting/neorv32/blob/master/rtl/core/neorv32_top.vhd) or one of its
494 36 zero_gravi
[wrappers](https://github.com/stnolting/neorv32/blob/master/rtl/top_templates) in your own project. If you just want to try out the processor,
495
you can use the simple [test setup](https://github.com/stnolting/neorv32/blob/master/rtl/top_templates/neorv32_test_setup.vhd) as top entity.
496 2 zero_gravi
 
497 40 zero_gravi
![neorv32 test setup](https://raw.githubusercontent.com/stnolting/neorv32/master/docs/figures/neorv32_test_setup.png)
498
 
499
 
500 33 zero_gravi
This test setup instantiates the processor and implements most of the peripherals and some ISA extensions. Only the UART lines, clock, reset and some GPIO output signals are
501 25 zero_gravi
propagated as actual entity signals. Basically, it is a FPGA "hello world" example:
502 23 zero_gravi
 
503 2 zero_gravi
```vhdl
504 9 zero_gravi
  entity neorv32_test_setup is
505
    port (
506
      -- Global control --
507
      clk_i      : in  std_ulogic := '0'; -- global clock, rising edge
508
      rstn_i     : in  std_ulogic := '0'; -- global reset, low-active, async
509
      -- GPIO --
510
      gpio_o     : out std_ulogic_vector(7 downto 0); -- parallel output
511
      -- UART --
512
      uart_txd_o : out std_ulogic; -- UART send data
513
      uart_rxd_i : in  std_ulogic := '0' -- UART receive data
514
    );
515
  end neorv32_test_setup;
516 2 zero_gravi
```
517
 
518
 
519 23 zero_gravi
### Check the Toolchain
520 2 zero_gravi
 
521 11 zero_gravi
Make sure `GNU Make` and a native `GCC` compiler are installed. To test the installation of the RISC-V toolchain navigate to an example project like
522 2 zero_gravi
`sw/example/blink_led` and run:
523
 
524
    neorv32/sw/example/blink_led$ make check
525
 
526 23 zero_gravi
 
527
### Compiling an Example Program
528
 
529 9 zero_gravi
The NEORV32 project includes some [example programs](https://github.com/stnolting/neorv32/tree/master/sw/example) from
530
which you can start your own application. Simply compile one of these projects. This will create a NEORV32
531 23 zero_gravi
*executable* `neorv32_exe.bin` in the same folder:
532 2 zero_gravi
 
533 23 zero_gravi
    neorv32/sw/example/blink_led$ make clean_all exe
534 2 zero_gravi
 
535 23 zero_gravi
 
536
### Upload the Executable via the Bootloader
537
 
538 34 zero_gravi
You can upload a generated executable directly from the command line using the makefile's `upload` target. Replace `/dev/ttyUSB0` with
539
the according serial port.
540
 
541
    sw/exeample/blink_example$ make COM_PORT=/dev/ttyUSB0` upload
542
 
543
A more "secure" way is to use a dedicated terminal program. This allows to directly interact with the bootloader console.
544 23 zero_gravi
Connect your FPGA board via UART to your computer and open the according port to interface with the NEORV32 bootloader. The bootloader
545 2 zero_gravi
uses the following default UART configuration:
546
 
547 32 zero_gravi
* 19200 Baud
548
* 8 data bits
549
* 1 stop bit
550
* No parity bits
551
* No transmission / flow control protocol (raw bytes only)
552
* Newline on `\r\n` (carriage return & newline) - also for sent data
553 2 zero_gravi
 
554 23 zero_gravi
Use the bootloader console to upload the `neorv32_exe.bin` executable and run your application image.
555 2 zero_gravi
 
556 9 zero_gravi
```
557 43 zero_gravi
<< NEORV32 Bootloader >>
558
 
559
BLDV: Nov  7 2020
560
HWV:  0x01040606
561
CLK:  0x0134FD90 Hz
562
USER: 0x0001CE40
563
MISA: 0x42801104
564
PROC: 0x03FF0035
565
IMEM: 0x00010000 bytes @ 0x00000000
566
DMEM: 0x00010000 bytes @ 0x80000000
567
 
568
Autoboot in 8s. Press key to abort.
569
Aborted.
570
 
571
Available CMDs:
572
 h: Help
573
 r: Restart
574
 u: Upload
575
 s: Store to flash
576
 l: Load from flash
577
 e: Execute
578
CMD:> u
579
Awaiting neorv32_exe.bin... OK
580
CMD:> e
581
Booting...
582
 
583
Blinking LED demo program
584 9 zero_gravi
```
585 2 zero_gravi
 
586 40 zero_gravi
Going further: Take a look at the _Let's Get It Started!_ chapter of the [:page_facing_up: NEORV32 data sheet](https://raw.githubusercontent.com/stnolting/neorv32/master/docs/NEORV32.pdf).
587 2 zero_gravi
 
588
 
589
 
590 40 zero_gravi
## Contribute/Feedback/Questions
591 2 zero_gravi
 
592 9 zero_gravi
I'm always thankful for help! So if you have any questions, bug reports, ideas or if you want to give some kind of feedback, feel free
593 40 zero_gravi
to [:bulb: open a new issue](https://github.com/stnolting/neorv32/issues), start a new [:sparkles: discussion on GitHub](https://github.com/stnolting/neorv32/discussions)
594
or directly [:e-mail: drop me a line](mailto:stnolting@gmail.com).
595 2 zero_gravi
 
596 40 zero_gravi
If you'd like to directly contribute to this repository:
597 22 zero_gravi
 
598 40 zero_gravi
0. :star: this repository ;)
599
1. Check out the project's [code of conduct](https://github.com/stnolting/neorv32/tree/master/CODE_OF_CONDUCT.md)
600
2. [Fork](https://github.com/stnolting/neorv32/fork) this repository and clone the fork
601
3. Create a feature branch in your fork: `git checkout -b awesome_new_feature_branch`
602
4. Create a new remote for the upstream repo: `git remote add upstream https://github.com/stnolting/neorv32`
603
5. Commit your modifications: `git commit -m "Awesome new feature!"`
604
6. Push to the branch: `git push origin awesome_new_feature_branch`
605
7. Create a new [pull request](https://github.com/stnolting/neorv32/pulls)
606 2 zero_gravi
 
607 40 zero_gravi
 
608 11 zero_gravi
## Legal
609 2 zero_gravi
 
610 12 zero_gravi
This project is released under the BSD 3-Clause license. No copyright infringement intended.
611 11 zero_gravi
Other implied or used projects might have different licensing - see their documentation to get more information.
612
 
613 37 zero_gravi
#### Citing
614 11 zero_gravi
 
615 34 zero_gravi
If you are using the NEORV32 or some parts of the project in some kind of publication, please cite it as follows:
616 2 zero_gravi
 
617 34 zero_gravi
> S. Nolting, "The NEORV32 Processor", github.com/stnolting/neorv32
618 2 zero_gravi
 
619 9 zero_gravi
#### BSD 3-Clause License
620 2 zero_gravi
 
621 42 zero_gravi
Copyright (c) 2021, Stephan Nolting. All rights reserved.
622 2 zero_gravi
 
623
Redistribution and use in source and binary forms, with or without modification, are
624
permitted provided that the following conditions are met:
625
 
626
1. Redistributions of source code must retain the above copyright notice, this list of
627
conditions and the following disclaimer.
628
2. Redistributions in binary form must reproduce the above copyright notice, this list of
629
conditions and the following disclaimer in the documentation and/or other materials
630
provided with the distribution.
631
3. Neither the name of the copyright holder nor the names of its contributors may be used to
632
endorse or promote products derived from this software without specific prior written
633
permission.
634
 
635
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
636
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
637
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
638
COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
639
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
640
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
641
AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
642
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
643
OF THE POSSIBILITY OF SUCH DAMAGE.
644
 
645
 
646 9 zero_gravi
#### Limitation of Liability for External Links
647
 
648 36 zero_gravi
Our website contains links to the websites of third parties ("external links"). As the
649 9 zero_gravi
content of these websites is not under our control, we cannot assume any liability for
650
such external content. In all cases, the provider of information of the linked websites
651
is liable for the content and accuracy of the information provided. At the point in time
652
when the links were placed, no infringements of the law were recognisable to us. As soon
653
as an infringement of the law becomes known to us, we will immediately remove the
654
link in question.
655
 
656
 
657 11 zero_gravi
#### Proprietary  Notice
658 9 zero_gravi
 
659 2 zero_gravi
"Artix" and "Vivado" are trademarks of Xilinx Inc.
660
 
661 45 zero_gravi
"Cyclone" and "Quartus Prime Lite" are trademarks of Intel Corporation.
662 2 zero_gravi
 
663 35 zero_gravi
"iCE40", "UltraPlus" and "Radiant" are trademarks of Lattice Semiconductor Corporation.
664 11 zero_gravi
 
665 35 zero_gravi
"AXI", "AXI4" and "AXI4-Lite" are trademarks of Arm Holdings plc.
666 2 zero_gravi
 
667
 
668
 
669 18 zero_gravi
## Acknowledgements
670 9 zero_gravi
 
671 18 zero_gravi
[![RISC-V](https://raw.githubusercontent.com/stnolting/neorv32/master/docs/figures/riscv_logo.png)](https://riscv.org/)
672
 
673 23 zero_gravi
[RISC-V](https://riscv.org/) - Instruction Sets Want To Be Free!
674 11 zero_gravi
 
675 43 zero_gravi
Continous integration provided by [:octocat: GitHub Actions](https://github.com/features/actions) and powered by [GHDL](https://github.com/ghdl/ghdl).
676 2 zero_gravi
 
677
![Open Source Hardware Logo https://www.oshwa.org](https://raw.githubusercontent.com/stnolting/neorv32/master/docs/figures/oshw_logo.png)
678
 
679
This project is not affiliated with or endorsed by the Open Source Initiative (https://www.oshwa.org / https://opensource.org).
680
 
681 32 zero_gravi
--------
682 2 zero_gravi
 
683 36 zero_gravi
Made with :coffee: in Hannover, Germany :eu:

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.