Forwarding to external memory when internal memory is implemented

[jaaaaaaaaan]

Hello. I can't understand how neoRV32 handles calls to ext. memory when both internal memories are present. Quote from manual:

All memory accesses from the CPU, that do not target the internal bootloader ROM, the internal IO region or the internal data/instruction memories (if implemented at all) are forwarded to the Wishbone gateway and thus to the external memory interface

Another quote from same manual:

If the IMEM (internal or external) is less than the (default) maximum size (2GB), there is a "dead address space" between it and the DMEM. This provides an additional safety feature since data corrupting scenarios like stack overflow cannot directly corrupt the content of the IMEM: any access to the "dead address space" in between will raise an exception that can be caught by the runtime environment.

Aaaand there is this memory map too

So If I would want to access memory with address 0x80000000 + MEM_INT_DMEM_SIZE + 0x10 it would be forwarded to ext. mem. without raising an exception? (assuming ofc that ext. mem. interface is enabled and said address is < Bootloader ROM addr.) If it will not raise an exception, and it will actually be forwarded, then my peripheral should have address somewhere from 0x80000000 + MEM_INT_DMEM_SIZE + 1 to Bootloader ROM addr, yes?

[stnolting]

So If I would want to access memory with address 0x80000000 + MEM_INT_DMEM_SIZE + 0x10 it would be forwarded to ext. mem. without raising an exception? (assuming ofc that ext. mem. interface is enabled and said address is < Bootloader ROM addr.)

You are right.
The CPU / processor will not raise an exception in this scenario. But there might be an exception if there is no device responding when accessing this specific address.

If it will not raise an exception, and it will actually be forwarded, then my peripheral should have address somewhere from 0x80000000 + MEM_INT_DMEM_SIZE + 1 to Bootloader ROM addr, yes?

This is also correct. But you don't have to place your module's address space so "close" to the internal DMEM address space. For instance, you could use 0xF0000000 as base address for your custom modules.

[jaaaaaaaaan]

Thanks! I would like to ask one more question, if you don't mind. If I would assign this peripheral of mine to address 0xF0000000 then to access it from C code I should do something like this :

  *(uint32_t*) 0xF0000000 = 0xFFFFFFFF; //write all ones to 32bit peripheral register 
  uint32_t x = *(uint32_t*) 0xF0000000; //read 32 bit from peripheral
  //operate on 8 bit fragment of peripheral
  *(((uint8_t*) 0xF0000000) + 1) = 0x00; //now if peripheral was just memory then under address 0xF0000000 should be stored either 
                                         //0xFF00FFFF (for big endian interface)  or 0xFFFF00FF (for little endian interface)```

Is it correct?

[stnolting]

Thanks! I would like to ask one more question, if you don't mind.

Questions are always welcome 😉

If I would assign this peripheral of mine to address 0xF0000000 then to access it from C code I should do something like this

I have not tested your code, but it looks fine.
Your question is related to this discussion #57. The NEORV32 software framework provides low-level load/store functions to access memory-mapped registers:

void neorv32_cpu_store_unsigned_word(uint32_t addr, uint32_t wdata);
void neorv32_cpu_store_unsigned_half(uint32_t addr, uint16_t wdata);
void neorv32_cpu_store_unsigned_byte(uint32_t addr, uint8_t  wdata);

uint32_t neorv32_cpu_load_unsigned_word(uint32_t addr);
uint16_t neorv32_cpu_load_unsigned_half(uint32_t addr);
uint8_t  neorv32_cpu_load_unsigned_byte(uint32_t addr);

Here is the according doxygen documentation: https://stnolting.github.io/neorv32/sw/neorv32__cpu_8h.html#a173bb06b4ae9c8964469068dafcb7b0e

So if you want to write 0xCAFE1234 to address 0xF000000 you could do:

neorv32_cpu_store_unsigned_word(0xF0000000, 0xCAFE1234);

⚠️ make sure the access address is always aligned to the according data size - otherwise an address alignment exception will be raised. For example, when accessing 32-bit words the address has to be aligned to a 32-bit boundary (bits 1:0 of the address have to be 00).

[jaaaaaaaaan]

Thanks again, I'm gonna check out those links.

[stnolting]

Feel free to ask if you have further questions (or any implementation troubles) 👍