Thread: implement read only, read/write1 clear and read/write registers

Originally Posted by Aslaville

I am trying to emulate a device's MMIO registers whereby some registers are read/write, read/write one to clear and finally read/write.

On what level? I mean, are you emulating the entire machine, with your code reading the instruction stream and acting on it; or are you emulating the registers for a normal application you have little control over?

Could you give some more context on what you are working on, please?

In the first case, you should incorporate the logic to the load/store part in your emulator. I'd use a small array of flags, not available to the emulated code, to store the readable and writable bit (two bits per register) per register, that the load/store part of your emulator checks. You should also consider what your emulator should do, if the code does an "illegal" access.

(I'm lazy, so I might instead use an array of two pointers per register, instead, so that each action on an MMIO register would call to a designated emulator function. Each 'read' function would return a full register word, with the load part picking only the proper subword of it if the load was narrower than a word. The 'write' functions would not return anything. I suspect this would be easier to maintain than a huge switch..case.)

In the second case, you're in for a bit of pain. It is certainly doable, and I can explain several different approaches for POSIXy systems in userspace, and at least one if you are using a Linux kernel module for the emulation.

Could you give some more context on what you are working on, please?

Sorry, Nominal Animal, I'd really love to, it's a cool project but you know NDAs and stuff

Anyways, jokes aside. Sorry for late reply I got busy with schoolwork.

Am trying to emulate a device with qemu. Actually I can already emulate the device am just polishing and stuff.

This is what happens in Qemu.

-Software reads/writes to MMIO trigger traps to which Qemu responds but calling calling an MMIO handler specific to the particular device and of course many other things happens but that's the basic overview.
-A programmer emulating a device has to implement the MMIO read/write handler - it has a general prototype.

I thought this was going to be hard to do, especially the ro/rw1c/rw1s but it proved too easy.

I just did this

Code:

/* 
  @ addr: address of mmio register to write to
  @ s : structure representing a device (it contains a static array representing the MMIO region and others representing special masks)
  @val : value to write
*/

static void mmio_write_long(struct device *s, uint64_t addr, uint32_t val)
{
     uint64_t romask = s->romask[addr]; //get the read only mask
     uint64_t w1cmask = s->r1cmask[addr]; //get the write 1 clear mask
     s->mmio[addr] = ((val & ~ romask) | ( val & ~ w1cmask)); //store value disregarding read only bit and clearing w1c bits
}

//And of course the code's not exactly as I wrote above but that's basically how it works