I downloaded pulp riscv gnu toolchain and pulp sdk. I there a way to add a custom instruction to the riscv cross compiler?

Hi
I want to run simple hello.c example So I compiled as following:
riscv64-unknown-elf-gcc hello.c -L linker.lds -o hello.elf
where linker.lds is :

Hi,
I've already run "Hello" case successfully with Xcelium, now I have some further questions:
1. In readme I see it says "Either the RI5CY core or the Ibex one as main core". So by default, if I've built everything following readme, which core is used in the Soc?
2. In ARM cores, there is usually a program counter (PC) register, so that users can simply know where the issue happens (with disassembly code). Is there the similar register in Pulpissimo?
3. I see ./sim/boot/boot_code.cde is loaded in boot_rom. Is this boot_code.cde necessary for all the cases? Via the waveform of "Hello" case, I see something is read from boot_rom, but i'm not sure if the boot code is really used or not. What does the boot code do? Initialize the SoC? If I put my executable in SPI flash, can I still reuse the boot code before jumping to SPI content?

Hey,

What kind of setup do you people use to work with pulpissimo?
I would also like to know about editor extensions that might provide auto-completion, jumping to definition and integration with make build errors.

Goodmirning everyone  

I was trying to track some signals using che schematic tracer built inside Vsim. I tried to do this using the hello test program inside the pulp-rt-examples repo.

I called the simulation enabling the gui using the commands:

Hello, and thanks for let me join inside your community!

I am writing this thread for sharing to all of you the problem I faced building PULP-sdk on a centOS 7 distribution; and how I solved that without let other people to struggle as I did for solving this.

I was trying to recreate and setup the PULPissimo platform due to functionality analysis. I Have installed each of the requested components (gcc, pulp-sdk, pulp-builder, PULPissimo) inside a generic root project folder called  <user_project_folder_path>. Each of those component has been built inside a dedicated folder. In order to be able to simulate the platform, one of the needed steps is to setup and build the sdk. I moved to the PULP sdk main page, and then followed these steps:
Then, I Set the requested env variables, linking the toolchain and vsim paths:

make all, I’ve been able to complete the whole sdk build and setup process, which let me able to move throught the following steps in the process. I still don’t know if this error come for some kind of lacks inside my system or not. If someone inside the PULP team want to try and replicate the behaviour, would be nice to fix the missing dependence from the git list in order to solve this problem for all the users which are using the same operating system as me. Anyway, I Hope this might be useful for all those people will found the same error: here’s the fix which can help you saving a lot of precious time

How can I view the intermediate trees generated after make clean all run in hello example

I couldn't think of a more descriptive title so let me please explain what i am trying to achieve.

I'm using a hardware accelerator and have quite some amount of data (weights, inputs, etc) that i need to send to the accelerator.
The idea was to use the SPI flash model to store the flash_stim (and the other data) in the flash memory, without using the UserPreload feature.
Now there are a few things that aren't clear to me which i couldn't resolve by reading the issues on github or reading the forum.

Here is my approach so far:

First i wrote an application to send data to the flash memory, similar to the send example.
I created an array that contains some data with the intend of having this array contain the data from the flash_stim.slm file (without the addresses).
This worked for smaller data sets where i defined an array with random sample data to send to the flash.
At some point the array (and therefore the whole code) was simply too big to fit in the Pri banks of the L2 memory and i was stuck in "Waiting for end of computation".

So now i am using JTAG to load my data into the non Pri banks of the L2 memory.
The goal is to send this data to the flash memory, effectively making the flash memory contain the same data as if i had been using the UserPreload feature of the S25FS256S model.
Sending data to the L2 via JTAG of course works fine but also raises the first question.
There are different stimuli files for either JTAG (stim.txt) or STANDALONE (flash_stim.slm).
Effectively they should both do the same thing in the end, but are different in size and format.
For example i can't use readmemh to load the flash_stim.slm into the stimuli array.

As far as i understand there is no way to directly load the flash memory via JTAG because it's not memory mapped, correct?
If this is true, then would the correct way to do this be:
1) Use JTAG to load the image (in this case the stim.txt) into L2 just as you would do when booting from L2 but use a different address (e.g. 0x1C030000).
2) Use SPI to transfer that data to the flash memory (this i do by code, similar to the send example i mentioned, using pulp_read32 to get the data from L2, but this seems rather inefficient).
3) Now i should be able to boot from ROM even tho i didn't use the UserPreload feature.

What i am wondering about are the following things:
- Is the way i described above the correct or rather most efficient way to do this?
- Is there a way to load the flash_stim.sml to flash without using the UserPreload feature or converting the format so readmemh can be used?
- This issue mentions the way to do this would be to write data from JTAG to L2 (like i am doing too) and then to engage the udma to transfer this data to the flash. Unfortunately i'm not sure how you would do this and i couldn't find a documentation or guide on this.

Thank you for your help,
LPLA

Hi, I'm trying to add hardware accelerator to the system that would connect with axi-lite slave to pulpissimo.
The system already has master there that I can access from CPU?
I have skimmed through pulpissimo datasheet and bit of the code but I'm lost here.
Got any pointers?

I have been looking into using udma_qpsi (https://github.com/pulp-platform/udma_qspi) logic in SPI_STD mode. I noticed that when in SPI_STD mode for sampling data_rx in udma_spim_txrx module, spi_sdi1_i is used instead of spi_sdi0_i. 


udma_spim_txrx.sv
 line 264: s_data_rx[s_bit_index] = spi_sdi1_i;

However for data_tx spi_sdo0 is used

line 234: s_spi_sdo0 = r_tx_shift_reg[s_bit_index];


Was this intentional? If so, is there a reason behind it?

Thanks!