mirror of https://github.com/bsnes-emu/bsnes.git
286 lines
7.5 KiB
C++
286 lines
7.5 KiB
C++
auto CPU::dma_add_clocks(uint clocks) -> void {
|
|
status.dma_clocks += clocks;
|
|
add_clocks(clocks);
|
|
}
|
|
|
|
//=============
|
|
//memory access
|
|
//=============
|
|
|
|
auto CPU::dma_transfer_valid(uint8 bbus, uint32 abus) -> bool {
|
|
//transfers from WRAM to WRAM are invalid; chip only has one address bus
|
|
if(bbus == 0x80 && ((abus & 0xfe0000) == 0x7e0000 || (abus & 0x40e000) == 0x0000)) return false;
|
|
return true;
|
|
}
|
|
|
|
auto CPU::dma_addr_valid(uint32 abus) -> bool {
|
|
//A-bus access to B-bus or S-CPU registers are invalid
|
|
if((abus & 0x40ff00) == 0x2100) return false; //$[00-3f|80-bf]:[2100-21ff]
|
|
if((abus & 0x40fe00) == 0x4000) return false; //$[00-3f|80-bf]:[4000-41ff]
|
|
if((abus & 0x40ffe0) == 0x4200) return false; //$[00-3f|80-bf]:[4200-421f]
|
|
if((abus & 0x40ff80) == 0x4300) return false; //$[00-3f|80-bf]:[4300-437f]
|
|
return true;
|
|
}
|
|
|
|
auto CPU::dma_read(uint32 abus) -> uint8 {
|
|
if(dma_addr_valid(abus) == false) return 0x00;
|
|
return bus.read(abus, regs.mdr);
|
|
}
|
|
|
|
//simulate two-stage pipeline for DMA transfers; example:
|
|
//cycle 0: read N+0
|
|
//cycle 1: write N+0 & read N+1 (parallel; one on A-bus, one on B-bus)
|
|
//cycle 2: write N+1 & read N+2 (parallel)
|
|
//cycle 3: write N+2
|
|
auto CPU::dma_write(bool valid, uint addr, uint8 data) -> void {
|
|
if(pipe.valid) bus.write(pipe.addr, pipe.data);
|
|
pipe.valid = valid;
|
|
pipe.addr = addr;
|
|
pipe.data = data;
|
|
}
|
|
|
|
auto CPU::dma_transfer(bool direction, uint8 bbus, uint32 abus) -> void {
|
|
if(direction == 0) {
|
|
dma_add_clocks(4);
|
|
regs.mdr = dma_read(abus);
|
|
dma_add_clocks(4);
|
|
dma_write(dma_transfer_valid(bbus, abus), 0x2100 | bbus, regs.mdr);
|
|
} else {
|
|
dma_add_clocks(4);
|
|
regs.mdr = dma_transfer_valid(bbus, abus) ? bus.read(0x2100 | bbus, regs.mdr) : (uint8)0x00;
|
|
dma_add_clocks(4);
|
|
dma_write(dma_addr_valid(abus), abus, regs.mdr);
|
|
}
|
|
}
|
|
|
|
//===================
|
|
//address calculation
|
|
//===================
|
|
|
|
auto CPU::dma_bbus(uint i, uint index) -> uint8 {
|
|
switch(channel[i].transfer_mode) { default:
|
|
case 0: return (channel[i].dest_addr); //0
|
|
case 1: return (channel[i].dest_addr + (index & 1)); //0,1
|
|
case 2: return (channel[i].dest_addr); //0,0
|
|
case 3: return (channel[i].dest_addr + ((index >> 1) & 1)); //0,0,1,1
|
|
case 4: return (channel[i].dest_addr + (index & 3)); //0,1,2,3
|
|
case 5: return (channel[i].dest_addr + (index & 1)); //0,1,0,1
|
|
case 6: return (channel[i].dest_addr); //0,0 [2]
|
|
case 7: return (channel[i].dest_addr + ((index >> 1) & 1)); //0,0,1,1 [3]
|
|
}
|
|
}
|
|
|
|
inline auto CPU::dma_addr(uint i) -> uint32 {
|
|
uint32 r = (channel[i].source_bank << 16) | (channel[i].source_addr);
|
|
|
|
if(channel[i].fixed_transfer == false) {
|
|
if(channel[i].reverse_transfer == false) {
|
|
channel[i].source_addr++;
|
|
} else {
|
|
channel[i].source_addr--;
|
|
}
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
inline auto CPU::hdma_addr(uint i) -> uint32 {
|
|
return (channel[i].source_bank << 16) | (channel[i].hdma_addr++);
|
|
}
|
|
|
|
inline auto CPU::hdma_iaddr(uint i) -> uint32 {
|
|
return (channel[i].indirect_bank << 16) | (channel[i].indirect_addr++);
|
|
}
|
|
|
|
//==============
|
|
//channel status
|
|
//==============
|
|
|
|
auto CPU::dma_enabled_channels() -> uint8 {
|
|
uint8 r = 0;
|
|
for(uint i = 0; i < 8; i++) {
|
|
if(channel[i].dma_enabled) r++;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
inline auto CPU::hdma_active(uint i) -> bool {
|
|
return (channel[i].hdma_enabled && !channel[i].hdma_completed);
|
|
}
|
|
|
|
inline auto CPU::hdma_active_after(uint i) -> bool {
|
|
for(uint n = i + 1; n < 8; n++) {
|
|
if(hdma_active(n) == true) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
inline auto CPU::hdma_enabled_channels() -> uint8 {
|
|
uint8 r = 0;
|
|
for(uint i = 0; i < 8; i++) {
|
|
if(channel[i].hdma_enabled) r++;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
inline auto CPU::hdma_active_channels() -> uint8 {
|
|
uint8 r = 0;
|
|
for(uint i = 0; i < 8; i++) {
|
|
if(hdma_active(i) == true) r++;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
//==============
|
|
//core functions
|
|
//==============
|
|
|
|
auto CPU::dma_run() -> void {
|
|
dma_add_clocks(8);
|
|
dma_write(false);
|
|
dma_edge();
|
|
|
|
for(uint i = 0; i < 8; i++) {
|
|
if(channel[i].dma_enabled == false) continue;
|
|
|
|
uint index = 0;
|
|
do {
|
|
dma_transfer(channel[i].direction, dma_bbus(i, index++), dma_addr(i));
|
|
dma_edge();
|
|
} while(channel[i].dma_enabled && --channel[i].transfer_size);
|
|
|
|
dma_add_clocks(8);
|
|
dma_write(false);
|
|
dma_edge();
|
|
|
|
channel[i].dma_enabled = false;
|
|
}
|
|
|
|
status.irq_lock = true;
|
|
}
|
|
|
|
auto CPU::hdma_update(uint i) -> void {
|
|
dma_add_clocks(4);
|
|
regs.mdr = dma_read((channel[i].source_bank << 16) | channel[i].hdma_addr);
|
|
dma_add_clocks(4);
|
|
dma_write(false);
|
|
|
|
if((channel[i].line_counter & 0x7f) == 0) {
|
|
channel[i].line_counter = regs.mdr;
|
|
channel[i].hdma_addr++;
|
|
|
|
channel[i].hdma_completed = (channel[i].line_counter == 0);
|
|
channel[i].hdma_do_transfer = !channel[i].hdma_completed;
|
|
|
|
if(channel[i].indirect) {
|
|
dma_add_clocks(4);
|
|
regs.mdr = dma_read(hdma_addr(i));
|
|
channel[i].indirect_addr = regs.mdr << 8;
|
|
dma_add_clocks(4);
|
|
dma_write(false);
|
|
|
|
if(!channel[i].hdma_completed || hdma_active_after(i)) {
|
|
dma_add_clocks(4);
|
|
regs.mdr = dma_read(hdma_addr(i));
|
|
channel[i].indirect_addr >>= 8;
|
|
channel[i].indirect_addr |= regs.mdr << 8;
|
|
dma_add_clocks(4);
|
|
dma_write(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
auto CPU::hdma_run() -> void {
|
|
dma_add_clocks(8);
|
|
dma_write(false);
|
|
|
|
for(uint i = 0; i < 8; i++) {
|
|
if(hdma_active(i) == false) continue;
|
|
channel[i].dma_enabled = false; //HDMA run during DMA will stop DMA mid-transfer
|
|
|
|
if(channel[i].hdma_do_transfer) {
|
|
static const uint transfer_length[8] = {1, 2, 2, 4, 4, 4, 2, 4};
|
|
uint length = transfer_length[channel[i].transfer_mode];
|
|
for(uint index = 0; index < length; index++) {
|
|
uint addr = channel[i].indirect == false ? hdma_addr(i) : hdma_iaddr(i);
|
|
dma_transfer(channel[i].direction, dma_bbus(i, index), addr);
|
|
}
|
|
}
|
|
}
|
|
|
|
for(uint i = 0; i < 8; i++) {
|
|
if(hdma_active(i) == false) continue;
|
|
|
|
channel[i].line_counter--;
|
|
channel[i].hdma_do_transfer = channel[i].line_counter & 0x80;
|
|
hdma_update(i);
|
|
}
|
|
|
|
status.irq_lock = true;
|
|
}
|
|
|
|
auto CPU::hdma_init_reset() -> void {
|
|
for(uint i = 0; i < 8; i++) {
|
|
channel[i].hdma_completed = false;
|
|
channel[i].hdma_do_transfer = false;
|
|
}
|
|
}
|
|
|
|
auto CPU::hdma_init() -> void {
|
|
dma_add_clocks(8);
|
|
dma_write(false);
|
|
|
|
for(uint i = 0; i < 8; i++) {
|
|
if(!channel[i].hdma_enabled) continue;
|
|
channel[i].dma_enabled = false; //HDMA init during DMA will stop DMA mid-transfer
|
|
|
|
channel[i].hdma_addr = channel[i].source_addr;
|
|
channel[i].line_counter = 0;
|
|
hdma_update(i);
|
|
}
|
|
|
|
status.irq_lock = true;
|
|
}
|
|
|
|
//==============
|
|
//initialization
|
|
//==============
|
|
|
|
auto CPU::dma_power() -> void {
|
|
for(uint i = 0; i < 8; i++) {
|
|
channel[i].direction = 1;
|
|
channel[i].indirect = true;
|
|
channel[i].unused = true;
|
|
channel[i].reverse_transfer = true;
|
|
channel[i].fixed_transfer = true;
|
|
channel[i].transfer_mode = 7;
|
|
|
|
channel[i].dest_addr = 0xff;
|
|
|
|
channel[i].source_addr = 0xffff;
|
|
channel[i].source_bank = 0xff;
|
|
|
|
channel[i].transfer_size = 0xffff;
|
|
channel[i].indirect_bank = 0xff;
|
|
|
|
channel[i].hdma_addr = 0xffff;
|
|
channel[i].line_counter = 0xff;
|
|
channel[i].unknown = 0xff;
|
|
}
|
|
}
|
|
|
|
auto CPU::dma_reset() -> void {
|
|
for(uint i = 0; i < 8; i++) {
|
|
channel[i].dma_enabled = false;
|
|
channel[i].hdma_enabled = false;
|
|
|
|
channel[i].hdma_completed = false;
|
|
channel[i].hdma_do_transfer = false;
|
|
}
|
|
|
|
pipe.valid = false;
|
|
pipe.addr = 0;
|
|
pipe.data = 0;
|
|
}
|