diff --git a/cargo/README.md b/cargo/README.md
index f8ec054..7e3058e 100644
--- a/cargo/README.md
+++ b/cargo/README.md
@@ -18,6 +18,8 @@
 ```sh
 $ export SIZE=256
 ```
+To run verilog generation and Chisel tests, sbt and verilator must be installed. For installation details see this [link](https://chipyard.readthedocs.io/en/latest/Chipyard-Basics/Initial-Repo-Setup.html#requirements)
+
 In order to generate verilog file SpectrometerTest.v which contains verilog code for digital spectrometer, run command:
 ```sh
 $ make verilog_spectrometer
@@ -26,10 +28,19 @@
 ```sh
 $ make test_spectrometer
 ```
+
 In order to run verilog tests for Spectravel connected to Caravel, PDK_ROOT and RISCV32 paths must be set. RISCV32 is path to RV32I Toolchain. For RV32I toolchain installation click [here](https://github.com/cliffordwolf/picorv32#building-a-pure-rv32i-toolchain). To check if paths are set, run command:
 ```sh
 $ make check-env
 ```
+Currently there are four different tests for Spectravel connected to Caravel:
+* plfg_nco_fft_mag_acc_utx - Data path is: PLFG -> NCO -> FFT -> MAG -> ACC -> UART output Tx
+* plfg_nco_fft_mag_acc_pout - Data path is: PLFG -> NCO -> FFT -> MAG -> ACC -> parallel output (8b AXI4-Stream)
+* pin_nco_fft_mag_acc_pout - Data path is: parallel input (8b AXI4-Stream) -> NCO -> FFT -> MAG -> ACC -> parallel output (8b AXI4-Stream)
+* pin_fft_mag_acc_pout - Data path is: parallel input (8b AXI4-Stream) -> FFT -> MAG -> ACC -> parallel output (8b AXI4-Stream)
+
+All tests contain C code where appropriate Spectravel registers are set in order to obtain desired functionality. Output of the Spectravel is compared with golden model generated with Chisel. In order for test to pass, Spectravel output data must be the same as golden model data.
+
 In order to test Spectravel added to the Caravel, run command:
 ```sh
 $ make test_top
@@ -39,6 +50,11 @@
 $ make clean_top
 ```
 
+In order to regenerate verilog code, run chisel tests and run Spectravel tests, run command:
+```sh
+$ make run_all
+```
+
 ## Address space for Spectravel
 ```
 User address space 0x3000_0000
