Proper way to emulate DMA transfers.

Hi all, I am currently writing an SNES emulator, and have been implementing the CPU so far. I have implemented about 120 opcodes and have gotten it to be able to execute some code in Super Mario World ROM. For debugging, I have it output some disassembly. I have gotten to the point where the SMW rom executes what looks to be a DMA transfer... I have never written an emulator for a game console before and was wondering if anyone here could point me in the right direction on how DMA transfer will work in an emulated sense.

My assumption is that CPU loop stops and we actually modify the array that represents RAM directly and move the PC value the number of bytes that were read? (In a sense, this would behave like an interrupt, right?)

The piece of disassembly I have encountered is along the lines of:



At $9277, I see there are bytes $42 and $26 loaded. Which prompts a series of consecutive bytes to follow:



I actually am using a disassembly for reference and it looks to be referring to this piece of code here:

Site for reference:
http://caffie.net:31415/root/smw-irq/bl ... ank_00.asm



Any thoughts?

Thanks!

documentation

HDMA is DMA that automatically runs in HBLANK when enabled.

I thought it was called HDMA because it ran in horizontal blanking, not vertical blanking.

...fixed.

So basically, I would watch for a flag in HBLANK or some sort and then proceed with emulating the transfers from there?

In my mind:
1. CPU execution stops due to HBLANK.
2. Handle the HDMA transfer. => From here, the PC is incremented to transfer the appropriate data.
3. Proceed with CPU execution again?

Thanks.

PC? As in the program counter? No, that shouldn't be touched at all, it transfers data from whatever HDMA tables are pointed to in the HDMA registers.

Ah, ok. I guess my main and probably very stupid question is... How would we move past the following bytes in the emulator:

If the PC (program counter) if left off around here:


Those would be interpreted as opcodes and operands -- but it looks like from the assembly reference, it looks to just be raw data.

The PC is never there in the first place, it doesn't need to move past them.

Did you already emulate the RTS opcode, or at least understand what RTS is supposed to do?

Ah I realize this now after tracing this... So basically it's something like this for this snippet of code:



X = $04

LDA $9277, X => LDA $927C, Then A = $00
STA $4370, X => STA $4374, Then $00 gets stored in $4370
DEX => X = 3

Repeat until X is negative

And we will have:



Apologies for being so newbie. Still trying to learn assembly, hehe.

Yes -- i realized now that it was my misunderstanding in the assembly code that caused me to trace it the incorrect way initially. But correct me if I am wrong:

RTS will basically:

- Pull the PC values from the stack.
-> increments the PC by 1 to point to the next instruction of where the jump occurred.