Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-23 22:20:01 +03:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

Most of the rest of the drivers converted.

Browse Source
This commit is contained in:
Aaron Giles 2008-11-23 22:32:24 +00:00
parent 73fb264753
commit 484da94b18
38 changed files with 373 additions and 355 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/mame/audio/dcs.c
View File

@ -968,6 +968,8 @@ void dcs2_init(running_machine *machine, int dram_in_mb, offs_t polling_offset)
dcs.rev = 4;
soundbank_words = 0x800;
}
dcs.program = cpu_get_address_space(dcs.cpu, ADDRESS_SPACE_PROGRAM);
dcs.data = cpu_get_address_space(dcs.cpu, ADDRESS_SPACE_DATA);
dcs.channels = 2;
/* initialize the ADSP Tx and timer callbacks */

10
src/mame/drivers/gamecstl.c
View File

@ -421,12 +421,13 @@ static WRITE8_HANDLER(at_page8_w)
static DMA8237_MEM_READ( pc_dma_read_byte )
{
const address_space *space = cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_PROGRAM);
UINT8 result;
offs_t page_offset = (((offs_t) dma_offset[0][channel]) << 16)
& 0xFF0000;
cpu_push_context(device->machine->cpu[0]);
result = program_read_byte(page_offset + offset);
cpu_push_context(space->cpu);
result = memory_read_byte(space, page_offset + offset);
cpu_pop_context();
return result;
@ -435,11 +436,12 @@ static DMA8237_MEM_READ( pc_dma_read_byte )
static DMA8237_MEM_WRITE( pc_dma_write_byte )
{
const address_space *space = cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_PROGRAM);
offs_t page_offset = (((offs_t) dma_offset[0][channel]) << 16)
& 0xFF0000;
cpu_push_context(device->machine->cpu[0]);
program_write_byte(page_offset + offset, data);
cpu_push_context(space->cpu);
memory_write_byte(space, page_offset + offset, data);
cpu_pop_context();
}

4
src/mame/drivers/harddriv.c
View File

@ -3710,12 +3710,12 @@ static READ32_HANDLER( rddsp32_speedup_r )
if (cpu_get_pc(space->cpu) == rddsp32_speedup_pc && (*rddsp32_speedup >> 16) == 0)
{
UINT32 r14 = cpu_get_reg(space->cpu, DSP32_R14);
UINT32 r1 = program_read_word(r14 - 0x14);
UINT32 r1 = memory_read_word(space, r14 - 0x14);
int cycles_to_burn = 17 * 4 * (0x2bc - r1 - 2);
if (cycles_to_burn > 20 * 4)
{
cpu_eat_cycles(space->cpu, cycles_to_burn);
program_write_word(r14 - 0x14, r1 + cycles_to_burn / 17);
memory_write_word(space, r14 - 0x14, r1 + cycles_to_burn / 17);
}
msp_speedup_count[0]++;
}

8
src/mame/drivers/hng64.c
View File

@ -644,7 +644,7 @@ static READ32_HANDLER( hng64_port_read )
/* preliminary dma code, dma is used to copy program code -> ram */
static int hng_dma_start,hng_dma_dst,hng_dma_len;
static void hng64_do_dma (void)
static void hng64_do_dma (const address_space *space)
{
logerror("Performing DMA Start %08x Len %08x Dst %08x\n",hng_dma_start, hng_dma_len, hng_dma_dst);
@ -652,8 +652,8 @@ static void hng64_do_dma (void)
{
UINT32 dat;
dat = program_read_dword(hng_dma_start);
program_write_dword(hng_dma_dst,dat);
dat = memory_read_dword(space,hng_dma_start);
memory_write_dword(space,hng_dma_dst,dat);
hng_dma_start+=4;
hng_dma_dst+=4;
hng_dma_len--;
@ -680,7 +680,7 @@ static WRITE32_HANDLER( hng_dma_len_w )
{
logerror ("DMA Len Write %08x\n",data);
hng_dma_len = data;
hng64_do_dma();
hng64_do_dma(space);
}

7
src/mame/drivers/jalmah.c
View File

@ -634,13 +634,14 @@ static WRITE16_HANDLER( urashima_dma_w )
{
UINT32 i;
for(i=0;i<0x200;i+=2)
program_write_word(0x88200+i,program_read_word(0x88400+i));
memory_write_word(space,0x88200+i,memory_read_word(space,0x88400+i));
}
}
/*same as $f00c0 sub-routine,but with additional work-around,to remove from here...*/
static void daireika_palette_dma(running_machine *machine,UINT16 val)
{
const address_space *space = cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM);
UINT32 index_1,index_2,src_addr,tmp_addr;
/*a0=301c0+jm_shared_ram[0x540/2] & 0xf00 */
/*a1=88000*/
@ -649,10 +650,10 @@ static void daireika_palette_dma(running_machine *machine,UINT16 val)
for(index_1=0;index_1<0x200;index_1+=0x20)
{
tmp_addr = src_addr;
src_addr = program_read_dword(src_addr);
src_addr = memory_read_dword(space,src_addr);
for(index_2=0;index_2<0x20;index_2+=2)
program_write_word(0x88000+index_2+index_1,program_read_word(src_addr+index_2));
memory_write_word(space,0x88000+index_2+index_1,memory_read_word(space,src_addr+index_2));
src_addr = tmp_addr + 4;
}

108
src/mame/drivers/konamigx.c
View File

@ -203,7 +203,7 @@ static struct sprite_entry {
UINT32 adr;
} sprites[0x100];
static void generate_sprites(UINT32 src, UINT32 spr, int count)
static void generate_sprites(const address_space *space, UINT32 src, UINT32 spr, int count)
{
int i;
int scount;
@ -214,9 +214,9 @@ static void generate_sprites(UINT32 src, UINT32 spr, int count)
for(i=0; i<count; i++) {
UINT32 adr = src + 0x100*i;
int pri;
if(!program_read_word(adr+2))
if(!memory_read_word(space, adr+2))
continue;
pri = program_read_word(adr+28);
pri = memory_read_word(space, adr+28);
if(pri < 256) {
sprites[ecount].pri = pri;
@ -229,39 +229,39 @@ static void generate_sprites(UINT32 src, UINT32 spr, int count)
for(i=0; i<ecount; i++) {
UINT32 adr = sprites[i].adr;
if(adr) {
UINT32 set =(program_read_word(adr) << 16)|program_read_word(adr+2);
UINT16 glob_x = program_read_word(adr+4);
UINT16 glob_y = program_read_word(adr+8);
UINT16 flip_x = program_read_word(adr+12) ? 0x1000 : 0x0000;
UINT16 flip_y = program_read_word(adr+14) ? 0x2000 : 0x0000;
UINT32 set =(memory_read_word(space, adr) << 16)|memory_read_word(space, adr+2);
UINT16 glob_x = memory_read_word(space, adr+4);
UINT16 glob_y = memory_read_word(space, adr+8);
UINT16 flip_x = memory_read_word(space, adr+12) ? 0x1000 : 0x0000;
UINT16 flip_y = memory_read_word(space, adr+14) ? 0x2000 : 0x0000;
UINT16 glob_f = flip_x | (flip_y ^ 0x2000);
UINT16 zoom_x = program_read_word(adr+20);
UINT16 zoom_y = program_read_word(adr+22);
UINT16 zoom_x = memory_read_word(space, adr+20);
UINT16 zoom_y = memory_read_word(space, adr+22);
UINT16 color_val = 0x0000;
UINT16 color_mask = 0xffff;
UINT16 color_set = 0x0000;
UINT16 color_rotate = 0x0000;
UINT16 v;
v = program_read_word(adr+24);
v = memory_read_word(space, adr+24);
if(v & 0x8000) {
color_mask = 0xf3ff;
color_val |= (v & 3) << 10;
}
v = program_read_word(adr+26);
v = memory_read_word(space, adr+26);
if(v & 0x8000) {
color_mask &= 0xfcff;
color_val |= (v & 3) << 8;
}
v = program_read_word(adr+18);
v = memory_read_word(space, adr+18);
if(v & 0x8000) {
color_mask &= 0xff1f;
color_val |= v & 0xe0;
}
v = program_read_word(adr+16);
v = memory_read_word(space, adr+16);
if(v & 0x8000)
color_set = v & 0x1f;
if(v & 0x4000)
@ -274,14 +274,14 @@ static void generate_sprites(UINT32 src, UINT32 spr, int count)
if(set >= 0x200000 && set < 0xd00000)
{
UINT16 count2 = program_read_word(set);
UINT16 count2 = memory_read_word(space, set);
set += 2;
while(count2) {
UINT16 idx = program_read_word(set);
UINT16 flip = program_read_word(set+2);
UINT16 col = program_read_word(set+4);
short y = program_read_word(set+6);
short x = program_read_word(set+8);
UINT16 idx = memory_read_word(space, set);
UINT16 flip = memory_read_word(space, set+2);
UINT16 col = memory_read_word(space, set+4);
short y = memory_read_word(space, set+6);
short x = memory_read_word(space, set+8);
if(idx == 0xffff) {
set = (flip<<16) | col;
@ -316,13 +316,13 @@ static void generate_sprites(UINT32 src, UINT32 spr, int count)
if(color_rotate)
col = (col & 0xffe0) | ((col + color_rotate) & 0x1f);
program_write_word(spr , (flip ^ glob_f) | sprites[i].pri);
program_write_word(spr+ 2, idx);
program_write_word(spr+ 4, y);
program_write_word(spr+ 6, x);
program_write_word(spr+ 8, zoom_y);
program_write_word(spr+10, zoom_x);
program_write_word(spr+12, col);
memory_write_word(space, spr , (flip ^ glob_f) | sprites[i].pri);
memory_write_word(space, spr+ 2, idx);
memory_write_word(space, spr+ 4, y);
memory_write_word(space, spr+ 6, x);
memory_write_word(space, spr+ 8, zoom_y);
memory_write_word(space, spr+10, zoom_x);
memory_write_word(space, spr+12, col);
spr += 16;
scount++;
if(scount == 256)
@ -335,45 +335,45 @@ static void generate_sprites(UINT32 src, UINT32 spr, int count)
}
}
while(scount < 256) {
program_write_word(spr, scount);
memory_write_word(space, spr, scount);
scount++;
spr += 16;
}
}
static void tkmmpzdm_esc(UINT32 p1, UINT32 p2, UINT32 p3, UINT32 p4)
static void tkmmpzdm_esc(const address_space *space, UINT32 p1, UINT32 p2, UINT32 p3, UINT32 p4)
{
konamigx_esc_alert(gx_workram, 0x0142, 0x100, 0);
}
static void dragoonj_esc(UINT32 p1, UINT32 p2, UINT32 p3, UINT32 p4)
static void dragoonj_esc(const address_space *space, UINT32 p1, UINT32 p2, UINT32 p3, UINT32 p4)
{
konamigx_esc_alert(gx_workram, 0x5c00, 0x100, 0);
}
static void sal2_esc(UINT32 p1, UINT32 p2, UINT32 p3, UINT32 p4)
static void sal2_esc(const address_space *space, UINT32 p1, UINT32 p2, UINT32 p3, UINT32 p4)
{
konamigx_esc_alert(gx_workram, 0x1c8c, 0x172, 1);
}
static void sexyparo_esc(UINT32 p1, UINT32 p2, UINT32 p3, UINT32 p4)
static void sexyparo_esc(const address_space *space, UINT32 p1, UINT32 p2, UINT32 p3, UINT32 p4)
{
// The d20000 should probably be p3
generate_sprites(0xc00604, 0xd20000, 0xfc);
generate_sprites(space, 0xc00604, 0xd20000, 0xfc);
}
static void tbyahhoo_esc(UINT32 p1, UINT32 p2, UINT32 p3, UINT32 p4)
static void tbyahhoo_esc(const address_space *space, UINT32 p1, UINT32 p2, UINT32 p3, UINT32 p4)
{
generate_sprites(0xc00000, 0xd20000, 0x100);
generate_sprites(space, 0xc00000, 0xd20000, 0x100);
}
static void daiskiss_esc(UINT32 p1, UINT32 p2, UINT32 p3, UINT32 p4)
static void daiskiss_esc(const address_space *space, UINT32 p1, UINT32 p2, UINT32 p3, UINT32 p4)
{
generate_sprites(0xc00000, 0xd20000, 0x100);
generate_sprites(space, 0xc00000, 0xd20000, 0x100);
}
static UINT8 esc_program[4096];
static void (*esc_cb)(UINT32 p1, UINT32 p2, UINT32 p3, UINT32 p4);
static void (*esc_cb)(const address_space *space, UINT32 p1, UINT32 p2, UINT32 p3, UINT32 p4);
static WRITE32_HANDLER( esc_w )
{
@ -393,7 +393,7 @@ static WRITE32_HANDLER( esc_w )
}
/* the master opcode can be at an unaligned address, so get it "safely" */
opcode = (program_read_word(data+2))|(program_read_word(data)<<16);
opcode = (memory_read_word(space, data+2))|(memory_read_word(space, data)<<16);
/* if there's an OBJECT_MAGIC_ID, that means
there is a valid ESC command packet. */
@ -401,15 +401,15 @@ static WRITE32_HANDLER( esc_w )
{
int i;
/* get the subop now */
opcode = program_read_byte(data+8);
params = (program_read_word(data+12) << 16) | program_read_word(data+14);
opcode = memory_read_byte(space, data+8);
params = (memory_read_word(space, data+12) << 16) | memory_read_word(space, data+14);
switch(opcode) {
case 5: // Reset
break;
case 2: // Load program
for(i=0; i<4096; i++)
esc_program[i] = program_read_byte(params+i);
esc_program[i] = memory_read_byte(space, params+i);
/*
{
FILE *f;
@ -424,18 +424,18 @@ static WRITE32_HANDLER( esc_w )
break;
case 1: // Run program
if(esc_cb) {
UINT32 p1 = (program_read_word(params+0)<<16) | program_read_word(params+2);
UINT32 p2 = (program_read_word(params+4)<<16) | program_read_word(params+6);
UINT32 p3 = (program_read_word(params+8)<<16) | program_read_word(params+10);
UINT32 p4 = (program_read_word(params+12)<<16) | program_read_word(params+14);
esc_cb(p1, p2, p3, p4);
UINT32 p1 = (memory_read_word(space, params+0)<<16) | memory_read_word(space, params+2);
UINT32 p2 = (memory_read_word(space, params+4)<<16) | memory_read_word(space, params+6);
UINT32 p3 = (memory_read_word(space, params+8)<<16) | memory_read_word(space, params+10);
UINT32 p4 = (memory_read_word(space, params+12)<<16) | memory_read_word(space, params+14);
esc_cb(space, p1, p2, p3, p4);
}
break;
default:
// logerror("Unknown ESC opcode %d\n", opcode);
break;
}
program_write_byte(data+9, ESTATE_END);
memory_write_byte(space, data+9, ESTATE_END);
if (konamigx_wrport1_1 & 0x10)
{
@ -1052,15 +1052,15 @@ static WRITE32_HANDLER( type4_prot_w )
// memcpy from c01000 to c01400 for 0x400 bytes (startup check for type 4 games)
for (i = 0; i < 0x400; i += 2)
{
program_write_word(0xc01400+i, program_read_word(0xc01000+i));
memory_write_word(space, 0xc01400+i, memory_read_word(space, 0xc01000+i));
}
}
else if(last_prot_op == 0x57a) // winspike
{
program_write_dword(0xc10f00, program_read_dword(0xc00f10));
program_write_dword(0xc10f04, program_read_dword(0xc00f14));
program_write_dword(0xc0fe00, program_read_dword(0xc00f30));
program_write_dword(0xc0fe04, program_read_dword(0xc00f34));
memory_write_dword(space, 0xc10f00, memory_read_dword(space, 0xc00f10));
memory_write_dword(space, 0xc10f04, memory_read_dword(space, 0xc00f14));
memory_write_dword(space, 0xc0fe00, memory_read_dword(space, 0xc00f30));
memory_write_dword(space, 0xc0fe04, memory_read_dword(space, 0xc00f34));
}
else if(last_prot_op == 0xd97) // rushhero
{
@ -1072,7 +1072,7 @@ static WRITE32_HANDLER( type4_prot_w )
{
for (i = 0; i <= 0x10; i += 4)
{
program_write_dword(dst + i, program_read_dword(src+i));
memory_write_dword(space, dst + i, memory_read_dword(space, src+i));
}
src -= 0x10;

49
src/mame/drivers/lockon.c
View File

@ -71,10 +71,11 @@ static WRITE16_HANDLER( adrst_w )
static READ16_HANDLER( main_gnd_r )
{
const address_space *gndspace = cpu_get_address_space(space->machine->cpu[GROUND_CPU], ADDRESS_SPACE_PROGRAM);
UINT16 result;
cpu_push_context(space->machine->cpu[GROUND_CPU]);
result = program_read_word(V30_GND_ADDR | offset * 2);
cpu_push_context(gndspace->cpu);
result = memory_read_word(gndspace, V30_GND_ADDR | offset * 2);
cpu_pop_context();
return result;
@ -82,22 +83,24 @@ static READ16_HANDLER( main_gnd_r )
static WRITE16_HANDLER( main_gnd_w )
{
cpu_push_context(space->machine->cpu[GROUND_CPU]);
const address_space *gndspace = cpu_get_address_space(space->machine->cpu[GROUND_CPU], ADDRESS_SPACE_PROGRAM);
cpu_push_context(gndspace->cpu);
if (ACCESSING_BITS_0_7)
program_write_byte(V30_GND_ADDR | (offset * 2 + 0), data);
memory_write_byte(gndspace, V30_GND_ADDR | (offset * 2 + 0), data);
if (ACCESSING_BITS_8_15)
program_write_byte(V30_GND_ADDR | (offset * 2 + 1), data >> 8);
memory_write_byte(gndspace, V30_GND_ADDR | (offset * 2 + 1), data >> 8);
cpu_pop_context();
}
static READ16_HANDLER( main_obj_r )
{
const address_space *objspace = cpu_get_address_space(space->machine->cpu[OBJECT_CPU], ADDRESS_SPACE_PROGRAM);
UINT16 result;
cpu_push_context(space->machine->cpu[OBJECT_CPU]);
result = program_read_word(V30_OBJ_ADDR | offset * 2);
cpu_push_context(objspace->cpu);
result = memory_read_word(objspace, V30_OBJ_ADDR | offset * 2);
cpu_pop_context();
return result;
@ -105,12 +108,13 @@ static READ16_HANDLER( main_obj_r )
static WRITE16_HANDLER( main_obj_w )
{
cpu_push_context(space->machine->cpu[OBJECT_CPU]);
const address_space *objspace = cpu_get_address_space(space->machine->cpu[OBJECT_CPU], ADDRESS_SPACE_PROGRAM);
cpu_push_context(objspace->cpu);
if (ACCESSING_BITS_0_7)
program_write_byte(V30_OBJ_ADDR | (offset * 2 + 0), data);
memory_write_byte(objspace, V30_OBJ_ADDR | (offset * 2 + 0), data);
if (ACCESSING_BITS_8_15)
program_write_byte(V30_OBJ_ADDR | (offset * 2 + 1), data >> 8);
memory_write_byte(objspace, V30_OBJ_ADDR | (offset * 2 + 1), data >> 8);
cpu_pop_context();
}
@ -119,28 +123,32 @@ static WRITE16_HANDLER( tst_w )
{
if (offset < 0x800)
{
cpu_push_context(space->machine->cpu[GROUND_CPU]);
const address_space *gndspace = cpu_get_address_space(space->machine->cpu[GROUND_CPU], ADDRESS_SPACE_PROGRAM);
const address_space *objspace = cpu_get_address_space(space->machine->cpu[OBJECT_CPU], ADDRESS_SPACE_PROGRAM);
cpu_push_context(gndspace->cpu);
if (ACCESSING_BITS_0_7)
program_write_byte(V30_GND_ADDR | (offset * 2 + 0), data);
memory_write_byte(gndspace, V30_GND_ADDR | (offset * 2 + 0), data);
if (ACCESSING_BITS_8_15)
program_write_byte(V30_GND_ADDR | (offset * 2 + 1), data >> 8);
memory_write_byte(gndspace, V30_GND_ADDR | (offset * 2 + 1), data >> 8);
cpu_pop_context();
cpu_push_context(space->machine->cpu[OBJECT_CPU]);
cpu_push_context(objspace->cpu);
if (ACCESSING_BITS_0_7)
program_write_byte(V30_OBJ_ADDR | (offset * 2 + 0), data);
memory_write_byte(objspace, V30_OBJ_ADDR | (offset * 2 + 0), data);
if (ACCESSING_BITS_8_15)
program_write_byte(V30_OBJ_ADDR | (offset * 2 + 1), data >> 8);
memory_write_byte(objspace, V30_OBJ_ADDR | (offset * 2 + 1), data >> 8);
cpu_pop_context();
}
}
static READ16_HANDLER( main_z80_r )
{
const address_space *sndspace = cpu_get_address_space(space->machine->cpu[SOUND_CPU], ADDRESS_SPACE_PROGRAM);
UINT16 val;
cpu_push_context(space->machine->cpu[SOUND_CPU]);
val = program_read_byte(offset);
cpu_push_context(sndspace->cpu);
val = memory_read_byte(sndspace, offset);
cpu_pop_context();
return 0xff00 | val;
@ -148,8 +156,9 @@ static READ16_HANDLER( main_z80_r )
static WRITE16_HANDLER( main_z80_w )
{
cpu_push_context(space->machine->cpu[SOUND_CPU]);
program_write_byte(offset, data);
const address_space *sndspace = cpu_get_address_space(space->machine->cpu[SOUND_CPU], ADDRESS_SPACE_PROGRAM);
cpu_push_context(sndspace->cpu);
memory_write_byte(sndspace, offset, data);
cpu_pop_context();
}

10
src/mame/drivers/mario.c
View File

@ -127,10 +127,11 @@ static const z80dma_interface mario_dma =
static READ8_DEVICE_HANDLER(mario_dma_read_byte)
{
const address_space *space = cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_PROGRAM);
UINT8 result;
cpu_push_context(device->machine->cpu[0]);
result = program_read_byte(offset);
cpu_push_context(space->cpu);
result = memory_read_byte(space, offset);
cpu_pop_context();
return result;
@ -138,8 +139,9 @@ static READ8_DEVICE_HANDLER(mario_dma_read_byte)
static WRITE8_DEVICE_HANDLER(mario_dma_write_byte)
{
cpu_push_context(device->machine->cpu[0]);
program_write_byte(offset, data);
const address_space *space = cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_PROGRAM);
cpu_push_context(space->cpu);
memory_write_byte(space, offset, data);
cpu_pop_context();
}

10
src/mame/drivers/mediagx.c
View File

@ -772,12 +772,13 @@ static WRITE8_HANDLER(at_page8_w)
static DMA8237_MEM_READ( pc_dma_read_byte )
{
const address_space *space = cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_PROGRAM);
UINT8 result;
offs_t page_offset = (((offs_t) dma_offset[0][channel]) << 16)
& 0xFF0000;
cpu_push_context(device->machine->cpu[0]);
result = program_read_byte(page_offset + offset);
cpu_push_context(space->cpu);
result = memory_read_byte(space, page_offset + offset);
cpu_pop_context();
return result;
@ -786,11 +787,12 @@ static DMA8237_MEM_READ( pc_dma_read_byte )
static DMA8237_MEM_WRITE( pc_dma_write_byte )
{
const address_space *space = cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_PROGRAM);
offs_t page_offset = (((offs_t) dma_offset[0][channel]) << 16)
& 0xFF0000;
cpu_push_context(device->machine->cpu[0]);
program_write_byte(page_offset + offset, data);
cpu_push_context(space->cpu);
memory_write_byte(space, page_offset + offset, data);
cpu_pop_context();
}

6
src/mame/drivers/megadriv.c
View File

@ -178,7 +178,7 @@ static bitmap_t* render_bitmap;
#ifdef UNUSED_FUNCTION
/* taken from segaic16.c */
/* doesn't seem to meet my needs, not used */
static UINT16 read_next_instruction(void)
static UINT16 read_next_instruction(const address_space *space)
{
static UINT8 recurse = 0;
UINT16 result;
@ -197,7 +197,7 @@ static UINT16 read_next_instruction(void)
/* read original encrypted memory at that address */
recurse = 1;
result = program_read_word_16be(cpu_get_pc(machine->activecpu));
result = memory_read_word(space, cpu_get_pc(space->cpu));
recurse = 0;
return result;
}
@ -2288,7 +2288,7 @@ static READ16_HANDLER( megadriv_68k_check_z80_bus )
the value is never zero. Time Killers is the most fussy, and doesn't like the
read_next_instruction function from system16, so I just return a random value
in the unused bits */
UINT16 nextvalue = mame_rand(space->machine);//read_next_instruction()&0xff00;
UINT16 nextvalue = mame_rand(space->machine);//read_next_instruction(space)&0xff00;
/* Check if the 68k has the z80 bus */

3
src/mame/drivers/model3.c
View File

@ -767,8 +767,9 @@ static WRITE64_HANDLER(scsi_w)
static UINT32 scsi_fetch(UINT32 dsp)
{
const address_space *space = cpu_get_address_space(Machine->cpu[0], ADDRESS_SPACE_PROGRAM);
UINT32 result;
result = program_read_dword_64be(dsp);
result = memory_read_dword(space, dsp);
return FLIPENDIAN_INT32(result);
}

6
src/mame/drivers/moo.c
View File

@ -283,11 +283,11 @@ static WRITE16_HANDLER( moo_prot_w )
while (length)
{
a = program_read_word(src1);
b = program_read_word(src2);
a = memory_read_word(space, src1);
b = memory_read_word(space, src2);
res = a+2*b;
program_write_word(dst, res);
memory_write_word(space, dst, res);
src1 += 2;
src2 += 2;

2
src/mame/drivers/neogeo.c
View File

@ -392,7 +392,7 @@ READ16_HANDLER( neogeo_unmapped_r )
else
{
recurse = 1;
ret = program_read_word(cpu_get_pc(space->cpu));
ret = memory_read_word(space, cpu_get_pc(space->cpu));
recurse = 0;
}

2
src/mame/drivers/offtwall.c
View File

@ -160,7 +160,7 @@ static READ16_HANDLER( bankrom_r )
ROM bank area, we need to return the correct value to give the proper checksum */
if ((offset == 0x3000 || offset == 0x3001) && cpu_get_previouspc(space->cpu) > 0x37000)
{
UINT32 checksum = (program_read_word(0x3fd210) << 16) | program_read_word(0x3fd212);
UINT32 checksum = (memory_read_word(space, 0x3fd210) << 16) | memory_read_word(space, 0x3fd212);
UINT32 us = 0xaaaa5555 - checksum;
if (offset == 0x3001)
return us & 0xffff;

8
src/mame/drivers/punchout.c
View File

@ -173,10 +173,10 @@ static READ8_HANDLER( spunchout_prot_r ) {
switch ( offset ) {
case 0x00:
if ( prot_mode_sel == 0x0a )
return program_read_byte(0xd012);
return memory_read_byte(space, 0xd012);
if ( prot_mode_sel == 0x0b || prot_mode_sel == 0x23 )
return program_read_byte(0xd7c1);
return memory_read_byte(space, 0xd7c1);
return prot_mem[offset];
break;
@ -248,12 +248,12 @@ static WRITE8_HANDLER( spunchout_prot_w ) {
switch ( offset ) {
case 0x00:
if ( prot_mode_sel == 0x0a ) {
program_write_byte(0xd012, data);
memory_write_byte(space, 0xd012, data);
return;
}
if ( prot_mode_sel == 0x0b || prot_mode_sel == 0x23 ) {
program_write_byte(0xd7c1, data);
memory_write_byte(space, 0xd7c1, data);
return;
}

33
src/mame/drivers/seattle.c
View File

@ -472,7 +472,7 @@ static void vblank_assert(const device_config *device, int state);
static void update_vblank_irq(running_machine *machine);
static void galileo_reset(void);
static TIMER_CALLBACK( galileo_timer_callback );
static void galileo_perform_dma(running_machine *machine, int which);
static void galileo_perform_dma(const address_space *space, int which);
static void voodoo_stall(const device_config *device, int stall);
static void widget_reset(running_machine *machine);
static void update_widget_irq(running_machine *machine);
@ -936,7 +936,7 @@ static TIMER_CALLBACK( galileo_timer_callback )
*
*************************************/
static int galileo_dma_fetch_next(running_machine *machine, int which)
static int galileo_dma_fetch_next(const address_space *space, int which)
{
offs_t address = 0;
UINT32 data;
@ -951,32 +951,32 @@ static int galileo_dma_fetch_next(running_machine *machine, int which)
if (galileo.reg[GREG_DMA0_CONTROL + which] & 0x400)
{
galileo.reg[GREG_INT_STATE] |= 1 << (GINT_DMA0COMP_SHIFT + which);
update_galileo_irqs(machine);
update_galileo_irqs(space->machine);
}
galileo.reg[GREG_DMA0_CONTROL + which] &= ~0x5000;
return 0;
}
/* fetch the byte count */
data = program_read_dword(address); address += 4;
data = memory_read_dword(space, address); address += 4;
galileo.reg[GREG_DMA0_COUNT + which] = data;
/* fetch the source address */
data = program_read_dword(address); address += 4;
data = memory_read_dword(space, address); address += 4;
galileo.reg[GREG_DMA0_SOURCE + which] = data;
/* fetch the dest address */
data = program_read_dword(address); address += 4;
data = memory_read_dword(space, address); address += 4;
galileo.reg[GREG_DMA0_DEST + which] = data;
/* fetch the next record address */
data = program_read_dword(address); address += 4;
data = memory_read_dword(space, address); address += 4;
galileo.reg[GREG_DMA0_NEXT + which] = data;
return 1;
}
static void galileo_perform_dma(running_machine *machine, int which)
static void galileo_perform_dma(const address_space *space, int which)
{
do
{
@ -1027,7 +1027,7 @@ static void galileo_perform_dma(running_machine *machine, int which)
}
/* write the data and advance */
voodoo_w(voodoo_device, (dstaddr & 0xffffff) / 4, program_read_dword(srcaddr), 0xffffffff);
voodoo_w(voodoo_device, (dstaddr & 0xffffff) / 4, memory_read_dword(space, srcaddr), 0xffffffff);
srcaddr += srcinc;
dstaddr += dstinc;
bytesleft -= 4;
@ -1039,7 +1039,7 @@ static void galileo_perform_dma(running_machine *machine, int which)
{
while (bytesleft > 0)
{
program_write_byte(dstaddr, program_read_byte(srcaddr));
memory_write_byte(space, dstaddr, memory_read_byte(space, srcaddr));
srcaddr += srcinc;
dstaddr += dstinc;
bytesleft--;
@ -1060,9 +1060,9 @@ static void galileo_perform_dma(running_machine *machine, int which)
if (!(galileo.reg[GREG_DMA0_CONTROL + which] & 0x400))
{
galileo.reg[GREG_INT_STATE] |= 1 << (GINT_DMA0COMP_SHIFT + which);
update_galileo_irqs(machine);
update_galileo_irqs(space->machine);
}
} while (galileo_dma_fetch_next(machine, which));
} while (galileo_dma_fetch_next(space, which));
galileo.reg[GREG_DMA0_CONTROL + which] &= ~0x5000;
}
@ -1186,12 +1186,12 @@ static WRITE32_HANDLER( galileo_w )
/* fetch next record */
if (data & 0x2000)
galileo_dma_fetch_next(space->machine, which);
galileo_dma_fetch_next(space, which);
galileo.reg[offset] &= ~0x2000;
/* if enabling, start the DMA */
if (!(oldata & 0x1000) && (data & 0x1000))
galileo_perform_dma(space->machine, which);
galileo_perform_dma(space, which);
break;
}
@ -1358,14 +1358,15 @@ static void voodoo_stall(const device_config *device, int stall)
for (which = 0; which < 4; which++)
if (galileo.dma_stalled_on_voodoo[which])
{
const address_space *space = cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_PROGRAM);
if (LOG_DMA) logerror("Resuming DMA%d on voodoo\n", which);
/* mark this DMA as no longer stalled */
galileo.dma_stalled_on_voodoo[which] = FALSE;
/* resume execution */
cpu_push_context(device->machine->cpu[0]);
galileo_perform_dma(device->machine, which);
cpu_push_context(space->cpu);
galileo_perform_dma(space, which);
cpu_pop_context();
break;
}

26
src/mame/drivers/segag80r.c
View File

@ -183,29 +183,23 @@ static MACHINE_RESET( pignewt )
*
*************************************/
static offs_t decrypt_offset(running_machine *machine, offs_t offset)
static offs_t decrypt_offset(const address_space *space, offs_t offset)
{
offs_t pc;
/* if no active CPU, don't do anything */
if (cpunum_get_active() == -1)
return offset;
/* ignore anything but accesses via opcode $32 (LD $(XXYY),A) */
pc = cpu_get_previouspc(machine->activecpu);
if ((UINT16)pc == 0xffff || program_read_byte(pc) != 0x32)
offs_t pc = cpu_get_previouspc(space->cpu);
if ((UINT16)pc == 0xffff || memory_read_byte(space, pc) != 0x32)
return offset;
/* fetch the low byte of the address and munge it */
return (offset & 0xff00) | (*sega_decrypt)(pc, program_read_byte(pc + 1));
return (offset & 0xff00) | (*sega_decrypt)(pc, memory_read_byte(space, pc + 1));
}
static WRITE8_HANDLER( mainram_w ) { mainram[decrypt_offset(space->machine, offset)] = data; }
static WRITE8_HANDLER( vidram_w ) { segag80r_videoram_w(space, decrypt_offset(space->machine, offset), data); }
static WRITE8_HANDLER( monsterb_vidram_w ) { monsterb_videoram_w(space, decrypt_offset(space->machine, offset), data); }
static WRITE8_HANDLER( pignewt_vidram_w ) { pignewt_videoram_w(space, decrypt_offset(space->machine, offset), data); }
static WRITE8_HANDLER( sindbadm_vidram_w ) { sindbadm_videoram_w(space, decrypt_offset(space->machine, offset), data); }
static WRITE8_HANDLER( usb_ram_w ) { sega_usb_ram_w(space, decrypt_offset(space->machine, offset), data); }
static WRITE8_HANDLER( mainram_w ) { mainram[decrypt_offset(space, offset)] = data; }
static WRITE8_HANDLER( vidram_w ) { segag80r_videoram_w(space, decrypt_offset(space, offset), data); }
static WRITE8_HANDLER( monsterb_vidram_w ) { monsterb_videoram_w(space, decrypt_offset(space, offset), data); }
static WRITE8_HANDLER( pignewt_vidram_w ) { pignewt_videoram_w(space, decrypt_offset(space, offset), data); }
static WRITE8_HANDLER( sindbadm_vidram_w ) { sindbadm_videoram_w(space, decrypt_offset(space, offset), data); }
static WRITE8_HANDLER( usb_ram_w ) { sega_usb_ram_w(space, decrypt_offset(space, offset), data); }

20
src/mame/drivers/segag80v.c
View File

@ -212,26 +212,20 @@ static MACHINE_RESET( g80v )
*
*************************************/
static offs_t decrypt_offset(running_machine *machine, offs_t offset)
static offs_t decrypt_offset(const address_space *space, offs_t offset)
{
offs_t pc;
/* if no active CPU, don't do anything */
if (machine->activecpu == NULL)
return offset;
/* ignore anything but accesses via opcode $32 (LD $(XXYY),A) */
pc = cpu_get_previouspc(machine->activecpu);
if ((UINT16)pc == 0xffff || program_read_byte(pc) != 0x32)
offs_t pc = cpu_get_previouspc(space->cpu);
if ((UINT16)pc == 0xffff || memory_read_byte(space, pc) != 0x32)
return offset;
/* fetch the low byte of the address and munge it */
return (offset & 0xff00) | (*sega_decrypt)(pc, program_read_byte(pc + 1));
return (offset & 0xff00) | (*sega_decrypt)(pc, memory_read_byte(space, pc + 1));
}
static WRITE8_HANDLER( mainram_w ) { mainram[decrypt_offset(space->machine, offset)] = data; }
static WRITE8_HANDLER( usb_ram_w ) { sega_usb_ram_w(space, decrypt_offset(space->machine, offset), data); }
static WRITE8_HANDLER( vectorram_w ) { vectorram[decrypt_offset(space->machine, offset)] = data; }
static WRITE8_HANDLER( mainram_w ) { mainram[decrypt_offset(space, offset)] = data; }
static WRITE8_HANDLER( usb_ram_w ) { sega_usb_ram_w(space, decrypt_offset(space, offset), data); }
static WRITE8_HANDLER( vectorram_w ) { vectorram[decrypt_offset(space, offset)] = data; }

4
src/mame/drivers/segas32.c
View File

@ -364,7 +364,7 @@ static UINT8 analog_bank;
static UINT8 analog_value[4];
static UINT8 sonic_last[6];
static void (*system32_prot_vblank)(void);
static void (*system32_prot_vblank)(const device_config *device);
@ -573,7 +573,7 @@ static INTERRUPT_GEN( start_of_vblank_int )
system32_set_vblank(1);
timer_set(video_screen_get_time_until_pos(device->machine->primary_screen, 0, 0), NULL, 0, end_of_vblank_int);
if (system32_prot_vblank)
(*system32_prot_vblank)();
(*system32_prot_vblank)(device);
}

2
src/mame/drivers/seta2.c
View File

@ -679,7 +679,7 @@ ADDRESS_MAP_END
The offset to use is stored in RAM at address 0x20BA16 */
static READ16_HANDLER( pzlbowl_protection_r )
{
UINT32 address = (program_read_word(0x20ba16) << 16) | program_read_word(0x20ba18);
UINT32 address = (memory_read_word(space, 0x20ba16) << 16) | memory_read_word(space, 0x20ba18);
return memory_region(space->machine, "main")[address - 2];
}

64
src/mame/drivers/sf.c
View File

@ -61,10 +61,10 @@ static WRITE16_HANDLER( soundcmd_w )
/* The protection of the japanese version */
/* I'd love to see someone dump the 68705 rom */
static void write_dword(offs_t offset,UINT32 data)
static void write_dword(const address_space *space,offs_t offset,UINT32 data)
{
program_write_word(offset,data >> 16);
program_write_word(offset+2,data);
memory_write_word(space, offset,data >> 16);
memory_write_word(space, offset+2,data);
}
static WRITE16_HANDLER( protection_w )
@ -78,31 +78,31 @@ static WRITE16_HANDLER( protection_w )
int map;
map = maplist
[program_read_byte(0xffc006)]
[(program_read_byte(0xffc003)<<1) + (program_read_word(0xffc004)>>8)];
[memory_read_byte(space, 0xffc006)]
[(memory_read_byte(space, 0xffc003)<<1) + (memory_read_word(space, 0xffc004)>>8)];
switch(program_read_byte(0xffc684)) {
switch(memory_read_byte(space, 0xffc684)) {
case 1:
{
int base;
base = 0x1b6e8+0x300e*map;
write_dword(0xffc01c, 0x16bfc+0x270*map);
write_dword(0xffc020, base+0x80);
write_dword(0xffc024, base);
write_dword(0xffc028, base+0x86);
write_dword(0xffc02c, base+0x8e);
write_dword(0xffc030, base+0x20e);
write_dword(0xffc034, base+0x30e);
write_dword(0xffc038, base+0x38e);
write_dword(0xffc03c, base+0x40e);
write_dword(0xffc040, base+0x80e);
write_dword(0xffc044, base+0xc0e);
write_dword(0xffc048, base+0x180e);
write_dword(0xffc04c, base+0x240e);
write_dword(0xffc050, 0x19548+0x60*map);
write_dword(0xffc054, 0x19578+0x60*map);
write_dword(space, 0xffc01c, 0x16bfc+0x270*map);
write_dword(space, 0xffc020, base+0x80);
write_dword(space, 0xffc024, base);
write_dword(space, 0xffc028, base+0x86);
write_dword(space, 0xffc02c, base+0x8e);
write_dword(space, 0xffc030, base+0x20e);
write_dword(space, 0xffc034, base+0x30e);
write_dword(space, 0xffc038, base+0x38e);
write_dword(space, 0xffc03c, base+0x40e);
write_dword(space, 0xffc040, base+0x80e);
write_dword(space, 0xffc044, base+0xc0e);
write_dword(space, 0xffc048, base+0x180e);
write_dword(space, 0xffc04c, base+0x240e);
write_dword(space, 0xffc050, 0x19548+0x60*map);
write_dword(space, 0xffc054, 0x19578+0x60*map);
break;
}
case 2:
@ -117,10 +117,10 @@ static WRITE16_HANDLER( protection_w )
int d1 = delta1[map] + 0xc0;
int d2 = delta2[map];
program_write_word(0xffc680, d1);
program_write_word(0xffc682, d2);
program_write_word(0xffc00c, 0xc0);
program_write_word(0xffc00e, 0);
memory_write_word(space, 0xffc680, d1);
memory_write_word(space, 0xffc682, d2);
memory_write_word(space, 0xffc00c, 0xc0);
memory_write_word(space, 0xffc00e, 0);
sf_fg_scroll_w(space, 0, d1, 0xffff);
sf_bg_scroll_w(space, 0, d2, 0xffff);
@ -128,12 +128,12 @@ static WRITE16_HANDLER( protection_w )
}
case 4:
{
int pos = program_read_byte(0xffc010);
int pos = memory_read_byte(space, 0xffc010);
pos = (pos+1) & 3;
program_write_byte(0xffc010, pos);
memory_write_byte(space, 0xffc010, pos);
if(!pos) {
int d1 = program_read_word(0xffc682);
int off = program_read_word(0xffc00e);
int d1 = memory_read_word(space, 0xffc682);
int off = memory_read_word(space, 0xffc00e);
if(off!=512) {
off++;
d1++;
@ -141,8 +141,8 @@ static WRITE16_HANDLER( protection_w )
off = 0;
d1 -= 512;
}
program_write_word(0xffc682, d1);
program_write_word(0xffc00e, off);
memory_write_word(space, 0xffc682, d1);
memory_write_word(space, 0xffc00e, off);
sf_bg_scroll_w(space, 0, d1, 0xffff);
}
break;
@ -150,7 +150,7 @@ static WRITE16_HANDLER( protection_w )
default:
{
logerror("Write protection at %06x (%04x)\n", cpu_get_pc(space->cpu), data&0xffff);
logerror("*** Unknown protection %d\n", program_read_byte(0xffc684));
logerror("*** Unknown protection %d\n", memory_read_byte(space, 0xffc684));
break;
}
}

112
src/mame/drivers/stv.c
View File

@ -236,12 +236,12 @@ struct
UINT8 abus;
}stv_irq;
static void dma_direct_lv0(running_machine *machine); /*DMA level 0 direct transfer function*/
static void dma_direct_lv1(running_machine *machine); /*DMA level 1 direct transfer function*/
static void dma_direct_lv2(running_machine *machine); /*DMA level 2 direct transfer function*/
static void dma_indirect_lv0(running_machine *machine); /*DMA level 0 indirect transfer function*/
static void dma_indirect_lv1(running_machine *machine); /*DMA level 1 indirect transfer function*/
static void dma_indirect_lv2(running_machine *machine); /*DMA level 2 indirect transfer function*/
static void dma_direct_lv0(const address_space *space); /*DMA level 0 direct transfer function*/
static void dma_direct_lv1(const address_space *space); /*DMA level 1 direct transfer function*/
static void dma_direct_lv2(const address_space *space); /*DMA level 2 direct transfer function*/
static void dma_indirect_lv0(const address_space *space); /*DMA level 0 indirect transfer function*/
static void dma_indirect_lv1(const address_space *space); /*DMA level 1 indirect transfer function*/
static void dma_indirect_lv2(const address_space *space); /*DMA level 2 indirect transfer function*/
int minit_boost,sinit_boost;
@ -1160,8 +1160,8 @@ static WRITE32_HANDLER( stv_scu_w32 )
*/
if(stv_scu[4] & 1 && ((stv_scu[5] & 7) == 7) && stv_scu[4] & 0x100)
{
if(DIRECT_MODE(0)) { dma_direct_lv0(space->machine); }
else { dma_indirect_lv0(space->machine); }
if(DIRECT_MODE(0)) { dma_direct_lv0(space); }
else { dma_indirect_lv0(space); }
stv_scu[4]^=1;//disable starting bit.
@ -1221,8 +1221,8 @@ static WRITE32_HANDLER( stv_scu_w32 )
case 12:
if(stv_scu[12] & 1 && ((stv_scu[13] & 7) == 7) && stv_scu[12] & 0x100)
{
if(DIRECT_MODE(1)) { dma_direct_lv1(space->machine); }
else { dma_indirect_lv1(space->machine); }
if(DIRECT_MODE(1)) { dma_direct_lv1(space); }
else { dma_indirect_lv1(space); }
stv_scu[12]^=1;
@ -1271,8 +1271,8 @@ static WRITE32_HANDLER( stv_scu_w32 )
case 20:
if(stv_scu[20] & 1 && ((stv_scu[21] & 7) == 7) && stv_scu[20] & 0x100)
{
if(DIRECT_MODE(2)) { dma_direct_lv2(space->machine); }
else { dma_indirect_lv2(space->machine); }
if(DIRECT_MODE(2)) { dma_direct_lv2(space); }
else { dma_indirect_lv2(space); }
stv_scu[20]^=1;
@ -1301,7 +1301,7 @@ static WRITE32_HANDLER( stv_scu_w32 )
/*DSP section*/
/*Use functions so it is easier to work out*/
case 32:
dsp_prg_ctrl(space->machine, data);
dsp_prg_ctrl(space, data);
if(LOG_SCU) logerror("SCU DSP: Program Control Port Access %08x\n",data);
break;
case 33:
@ -1417,7 +1417,7 @@ static TIMER_CALLBACK( dma_lv2_ended )
D2MV_0;
}
static void dma_direct_lv0(running_machine *machine)
static void dma_direct_lv0(const address_space *space)
{
static UINT32 tmp_src,tmp_dst,tmp_size;
if(LOG_SCU) logerror("DMA lv 0 transfer START\n"
@ -1491,18 +1491,18 @@ static void dma_direct_lv0(running_machine *machine)
for (; scu_size_0 > 0; scu_size_0-=scu_dst_add_0)
{
if(scu_dst_add_0 == 2)
program_write_word(scu_dst_0,program_read_word(scu_src_0));
memory_write_word(space,scu_dst_0,memory_read_word(space,scu_src_0));
else if(scu_dst_add_0 == 8)
{
program_write_word(scu_dst_0,program_read_word(scu_src_0));
program_write_word(scu_dst_0+2,program_read_word(scu_src_0));
program_write_word(scu_dst_0+4,program_read_word(scu_src_0+2));
program_write_word(scu_dst_0+6,program_read_word(scu_src_0+2));
memory_write_word(space,scu_dst_0,memory_read_word(space,scu_src_0));
memory_write_word(space,scu_dst_0+2,memory_read_word(space,scu_src_0));
memory_write_word(space,scu_dst_0+4,memory_read_word(space,scu_src_0+2));
memory_write_word(space,scu_dst_0+6,memory_read_word(space,scu_src_0+2));
}
else
{
program_write_word(scu_dst_0,program_read_word(scu_src_0));
program_write_word(scu_dst_0+2,program_read_word(scu_src_0+2));
memory_write_word(space,scu_dst_0,memory_read_word(space,scu_src_0));
memory_write_word(space,scu_dst_0+2,memory_read_word(space,scu_src_0+2));
}
scu_dst_0+=scu_dst_add_0;
@ -1526,7 +1526,7 @@ static void dma_direct_lv0(running_machine *machine)
}
}
static void dma_direct_lv1(running_machine *machine)
static void dma_direct_lv1(const address_space *space)
{
static UINT32 tmp_src,tmp_dst,tmp_size;
if(LOG_SCU) logerror("DMA lv 1 transfer START\n"
@ -1600,11 +1600,11 @@ static void dma_direct_lv1(running_machine *machine)
for (; scu_size_1 > 0; scu_size_1-=scu_dst_add_1)
{
if(scu_dst_add_1 == 2)
program_write_word(scu_dst_1,program_read_word(scu_src_1));
memory_write_word(space,scu_dst_1,memory_read_word(space,scu_src_1));
else
{
program_write_word(scu_dst_1,program_read_word(scu_src_1));
program_write_word(scu_dst_1+2,program_read_word(scu_src_1+2));
memory_write_word(space,scu_dst_1,memory_read_word(space,scu_src_1));
memory_write_word(space,scu_dst_1+2,memory_read_word(space,scu_src_1+2));
}
scu_dst_1+=scu_dst_add_1;
@ -1627,7 +1627,7 @@ static void dma_direct_lv1(running_machine *machine)
}
}
static void dma_direct_lv2(running_machine *machine)
static void dma_direct_lv2(const address_space *space)
{
static UINT32 tmp_src,tmp_dst,tmp_size;
if(LOG_SCU) logerror("DMA lv 2 transfer START\n"
@ -1701,11 +1701,11 @@ static void dma_direct_lv2(running_machine *machine)
for (; scu_size_2 > 0; scu_size_2-=scu_dst_add_2)
{
if(scu_dst_add_2 == 2)
program_write_word(scu_dst_2,program_read_word(scu_src_2));
memory_write_word(space,scu_dst_2,memory_read_word(space,scu_src_2));
else
{
program_write_word(scu_dst_2,program_read_word(scu_src_2));
program_write_word(scu_dst_2+2,program_read_word(scu_src_2+2));
memory_write_word(space,scu_dst_2,memory_read_word(space,scu_src_2));
memory_write_word(space,scu_dst_2+2,memory_read_word(space,scu_src_2+2));
}
scu_dst_2+=scu_dst_add_2;
@ -1728,7 +1728,7 @@ static void dma_direct_lv2(running_machine *machine)
}
}
static void dma_indirect_lv0(running_machine *machine)
static void dma_indirect_lv0(const address_space *space)
{
/*Helper to get out of the cycle*/
UINT8 job_done = 0;
@ -1745,9 +1745,9 @@ static void dma_indirect_lv0(running_machine *machine)
tmp_src = scu_index_0;
/*Thanks for Runik of Saturnin for pointing this out...*/
scu_size_0 = program_read_dword(scu_index_0);
scu_src_0 = program_read_dword(scu_index_0+8);
scu_dst_0 = program_read_dword(scu_index_0+4);
scu_size_0 = memory_read_dword(space,scu_index_0);
scu_src_0 = memory_read_dword(space,scu_index_0+8);
scu_dst_0 = memory_read_dword(space,scu_index_0+4);
/*Indirect Mode end factor*/
if(scu_src_0 & 0x80000000)
@ -1771,7 +1771,7 @@ static void dma_indirect_lv0(running_machine *machine)
for (; scu_size_0 > 0; scu_size_0-=scu_dst_add_0)
{
if(scu_dst_add_0 == 2)
program_write_word(scu_dst_0,program_read_word(scu_src_0));
memory_write_word(space,scu_dst_0,memory_read_word(space,scu_src_0));
else
{
/* some games, eg columns97 are a bit weird, I'm not sure this is correct
@ -1779,15 +1779,15 @@ static void dma_indirect_lv0(running_machine *machine)
can't access 2 byte boundaries, and the end of the sprite list never gets marked,
the length of the transfer is also set to a 2 byte boundary, maybe the add values
should be different, I don't know */
program_write_word(scu_dst_0,program_read_word(scu_src_0));
program_write_word(scu_dst_0+2,program_read_word(scu_src_0+2));
memory_write_word(space,scu_dst_0,memory_read_word(space,scu_src_0));
memory_write_word(space,scu_dst_0+2,memory_read_word(space,scu_src_0+2));
}
scu_dst_0+=scu_dst_add_0;
scu_src_0+=scu_src_add_0;
}
//if(DRUP(0)) program_write_dword(tmp_src+8,scu_src_0|job_done ? 0x80000000 : 0);
//if(DWUP(0)) program_write_dword(tmp_src+4,scu_dst_0);
//if(DRUP(0)) memory_write_dword(space,tmp_src+8,scu_src_0|job_done ? 0x80000000 : 0);
//if(DWUP(0)) memory_write_dword(space,tmp_src+4,scu_dst_0);
scu_index_0 = tmp_src+0xc;
@ -1796,7 +1796,7 @@ static void dma_indirect_lv0(running_machine *machine)
timer_set(ATTOTIME_IN_USEC(300), NULL, 0, dma_lv0_ended);
}
static void dma_indirect_lv1(running_machine *machine)
static void dma_indirect_lv1(const address_space *space)
{
/*Helper to get out of the cycle*/
UINT8 job_done = 0;
@ -1812,9 +1812,9 @@ static void dma_indirect_lv1(running_machine *machine)
do{
tmp_src = scu_index_1;
scu_size_1 = program_read_dword(scu_index_1);
scu_src_1 = program_read_dword(scu_index_1+8);
scu_dst_1 = program_read_dword(scu_index_1+4);
scu_size_1 = memory_read_dword(space,scu_index_1);
scu_src_1 = memory_read_dword(space,scu_index_1+8);
scu_dst_1 = memory_read_dword(space,scu_index_1+4);
/*Indirect Mode end factor*/
if(scu_src_1 & 0x80000000)
@ -1840,7 +1840,7 @@ static void dma_indirect_lv1(running_machine *machine)
{
if(scu_dst_add_1 == 2)
program_write_word(scu_dst_1,program_read_word(scu_src_1));
memory_write_word(space,scu_dst_1,memory_read_word(space,scu_src_1));
else
{
/* some games, eg columns97 are a bit weird, I'm not sure this is correct
@ -1848,15 +1848,15 @@ static void dma_indirect_lv1(running_machine *machine)
can't access 2 byte boundaries, and the end of the sprite list never gets marked,
the length of the transfer is also set to a 2 byte boundary, maybe the add values
should be different, I don't know */
program_write_word(scu_dst_1,program_read_word(scu_src_1));
program_write_word(scu_dst_1+2,program_read_word(scu_src_1+2));
memory_write_word(space,scu_dst_1,memory_read_word(space,scu_src_1));
memory_write_word(space,scu_dst_1+2,memory_read_word(space,scu_src_1+2));
}
scu_dst_1+=scu_dst_add_1;
scu_src_1+=scu_src_add_1;
}
//if(DRUP(1)) program_write_dword(tmp_src+8,scu_src_1|job_done ? 0x80000000 : 0);
//if(DWUP(1)) program_write_dword(tmp_src+4,scu_dst_1);
//if(DRUP(1)) memory_write_dword(space,tmp_src+8,scu_src_1|job_done ? 0x80000000 : 0);
//if(DWUP(1)) memory_write_dword(space,tmp_src+4,scu_dst_1);
scu_index_1 = tmp_src+0xc;
@ -1865,7 +1865,7 @@ static void dma_indirect_lv1(running_machine *machine)
timer_set(ATTOTIME_IN_USEC(300), NULL, 0, dma_lv1_ended);
}
static void dma_indirect_lv2(running_machine *machine)
static void dma_indirect_lv2(const address_space *space)
{
/*Helper to get out of the cycle*/
UINT8 job_done = 0;
@ -1881,9 +1881,9 @@ static void dma_indirect_lv2(running_machine *machine)
do{
tmp_src = scu_index_2;
scu_size_2 = program_read_dword(scu_index_2);
scu_src_2 = program_read_dword(scu_index_2+8);
scu_dst_2 = program_read_dword(scu_index_2+4);
scu_size_2 = memory_read_dword(space,scu_index_2);
scu_src_2 = memory_read_dword(space,scu_index_2+8);
scu_dst_2 = memory_read_dword(space,scu_index_2+4);
/*Indirect Mode end factor*/
if(scu_src_2 & 0x80000000)
@ -1907,7 +1907,7 @@ static void dma_indirect_lv2(running_machine *machine)
for (; scu_size_2 > 0; scu_size_2-=scu_dst_add_2)
{
if(scu_dst_add_2 == 2)
program_write_word(scu_dst_2,program_read_word(scu_src_2));
memory_write_word(space,scu_dst_2,memory_read_word(space,scu_src_2));
else
{
/* some games, eg columns97 are a bit weird, I'm not sure this is correct
@ -1915,16 +1915,16 @@ static void dma_indirect_lv2(running_machine *machine)
can't access 2 byte boundaries, and the end of the sprite list never gets marked,
the length of the transfer is also set to a 2 byte boundary, maybe the add values
should be different, I don't know */
program_write_word(scu_dst_2,program_read_word(scu_src_2));
program_write_word(scu_dst_2+2,program_read_word(scu_src_2+2));
memory_write_word(space,scu_dst_2,memory_read_word(space,scu_src_2));
memory_write_word(space,scu_dst_2+2,memory_read_word(space,scu_src_2+2));
}
scu_dst_2+=scu_dst_add_2;
scu_src_2+=scu_src_add_2;
}
//if(DRUP(2)) program_write_dword(tmp_src+8,scu_src_2|job_done ? 0x80000000 : 0);
//if(DWUP(2)) program_write_dword(tmp_src+4,scu_dst_2);
//if(DRUP(2)) memory_write_dword(space,tmp_src+8,scu_src_2|job_done ? 0x80000000 : 0);
//if(DWUP(2)) memory_write_dword(space,tmp_src+4,scu_dst_2);
scu_index_2 = tmp_src+0xc;

10
src/mame/drivers/taitowlf.c
View File

@ -366,12 +366,13 @@ static WRITE8_HANDLER(at_page8_w)
static DMA8237_MEM_READ( pc_dma_read_byte )
{
const address_space *space = cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_PROGRAM);
UINT8 result;
offs_t page_offset = (((offs_t) dma_offset[0][channel]) << 16)
& 0xFF0000;
cpu_push_context(device->machine->cpu[0]);
result = program_read_byte(page_offset + offset);
cpu_push_context(space->cpu);
result = memory_read_byte(space, page_offset + offset);
cpu_pop_context();
return result;
@ -380,11 +381,12 @@ static DMA8237_MEM_READ( pc_dma_read_byte )
static DMA8237_MEM_WRITE( pc_dma_write_byte )
{
const address_space *space = cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_PROGRAM);
offs_t page_offset = (((offs_t) dma_offset[0][channel]) << 16)
& 0xFF0000;
cpu_push_context(device->machine->cpu[0]);
program_write_byte(page_offset + offset, data);
cpu_push_context(space->cpu);
memory_write_byte(space, page_offset + offset, data);
cpu_pop_context();
}

2
src/mame/drivers/thunderj.c
View File

@ -163,7 +163,7 @@ static READ16_HANDLER( thunderj_atarivc_r )
/* Use these lines to detect when things go south: */
#if 0
if (program_read_word(0x163482) > 0xfff)
if (memory_read_word(space, 0x163482) > 0xfff)
mame_printf_debug("You're screwed!");
#endif

24
src/mame/drivers/tmnt.c
View File

@ -350,8 +350,8 @@ static READ16_HANDLER( punkshot_kludge_r )
/* protection simulation derived from a bootleg */
static READ16_HANDLER( ssriders_protection_r )
{
int data = program_read_word(0x105a0a);
int cmd = program_read_word(0x1058fc);
int data = memory_read_word(space, 0x105a0a);
int cmd = memory_read_word(space, 0x1058fc);
switch (cmd)
{
@ -378,9 +378,9 @@ static READ16_HANDLER( ssriders_protection_r )
case 0x8abc:
/* collision table */
data = -program_read_word(0x105818);
data = -memory_read_word(space, 0x105818);
data = ((data / 8 - 4) & 0x1f) * 0x40;
data += ((program_read_word(0x105cb0) +
data += ((memory_read_word(space, 0x105cb0) +
256*K052109_r(space,0x1a01) + K052109_r(space,0x1a00) - 6) / 8 + 12) & 0x3f;
return data;
@ -405,7 +405,7 @@ static WRITE16_HANDLER( ssriders_protection_w )
for (i = 0;i < 128;i++)
{
if ((program_read_word(0x180006 + 128*i) >> 8) == logical_pri)
if ((memory_read_word(space, 0x180006 + 128*i) >> 8) == logical_pri)
{
K053245_word_w(space,8*i,hardware_pri,0x00ff);
hardware_pri++;
@ -1012,9 +1012,9 @@ static WRITE16_HANDLER( tmnt2_1c0800_w )
CellVar >>= 1;
cpu_writemem24bew_word(dst+0x00, 0x8000 | ((src[1] & 0xfc00) >> 2)); /* size, flip xy */
cpu_writemem24bew_word(dst+0x04, src[0]); /* code */
cpu_writemem24bew_word(dst+0x18, (src[1] & 0x3ff) ^ /* color, mirror, priority */
memory_write_word(space,dst+0x00, 0x8000 | ((src[1] & 0xfc00) >> 2)); /* size, flip xy */
memory_write_word(space,dst+0x04, src[0]); /* code */
memory_write_word(space,dst+0x18, (src[1] & 0x3ff) ^ /* color, mirror, priority */
(sunset_104000[CellVar + 0x00] & 0x0060));
/* base color modifier */
@ -1024,24 +1024,24 @@ static WRITE16_HANDLER( tmnt2_1c0800_w )
/* Also, the bosses don't blink when they are about to die - don't know */
/* if this is correct or not. */
// if (sunset_104000[CellVar + 0x15] & 0x001f)
// cpu_writemem24bew_word(dst+0x18,(program_read_word(dst+0x18) & 0xffe0) |
// memory_write_word(dst+0x18,(memory_read_word(space, dst+0x18) & 0xffe0) |
// (sunset_104000[CellVar + 0x15] & 0x001f));
x = src[2];
if (sunset_104000[CellVar + 0x00] & 0x4000)
{
/* flip x */
cpu_writemem24bew_word(dst+0x00,program_read_word(dst+0x00) ^ 0x1000);
memory_write_word(space,dst+0x00,memory_read_word(space, dst+0x00) ^ 0x1000);
x = -x;
}
x += sunset_104000[CellVar + 0x06];
cpu_writemem24bew_word(dst+0x0c,x);
memory_write_word(space,dst+0x0c,x);
y = src[3];
y += sunset_104000[CellVar + 0x07];
/* don't do second offset for shadows */
if ((tmnt2_1c0800[0x08] & 0x00ff) != 0x01)
y += sunset_104000[CellVar + 0x08];
cpu_writemem24bew_word(dst+0x08,y);
memory_write_word(space,dst+0x08,y);
#if 0
logerror("copy command %04x sprite %08x data %08x: %04x%04x %04x%04x modifiers %08x:%04x%04x %04x%04x %04x%04x %04x%04x %04x%04x %04x%04x %04x%04x %04x%04x %04x%04x %04x%04x %04x%04x %04x%04x\n",
tmnt2_1c0800[0x05],

10
src/mame/drivers/tx1.c
View File

@ -97,10 +97,11 @@ static INTERRUPT_GEN( z80_irq )
static READ16_HANDLER( z80_shared_r )
{
const address_space *cpu2space = cpu_get_address_space(space->machine->cpu[2], ADDRESS_SPACE_PROGRAM);
UINT16 result = 0xffff;
cpu_push_context(space->machine->cpu[2]);
result = program_read_byte(offset);
cpu_push_context(cpu2space->cpu);
result = memory_read_byte(cpu2space, offset);
cpu_pop_context();
return result;
@ -108,8 +109,9 @@ static READ16_HANDLER( z80_shared_r )
static WRITE16_HANDLER( z80_shared_w )
{
cpu_push_context(space->machine->cpu[2]);
program_write_byte(offset, data & 0xff);
const address_space *cpu2space = cpu_get_address_space(space->machine->cpu[2], ADDRESS_SPACE_PROGRAM);
cpu_push_context(cpu2space->cpu);
memory_write_byte(cpu2space, offset, data & 0xff);
cpu_pop_context();
}

12
src/mame/drivers/wecleman.c
View File

@ -490,7 +490,7 @@ static WRITE16_HANDLER( blitter_w )
for ( ; size > 0 ; size--)
{
/* maybe slower than a memcpy but safer (and errors are logged) */
program_write_word(dest,program_read_word(src));
memory_write_word(space, dest, memory_read_word(space, src));
src += 2;
dest += 2;
}
@ -503,23 +503,23 @@ static WRITE16_HANDLER( blitter_w )
int i, j, destptr;
/* Read offset of source from the list of blits */
i = src + program_read_word(list+2);
i = src + memory_read_word(space, list+2);
j = i + (size<<1);
destptr = dest;
for (; i<j; destptr+=2, i+=2)
program_write_word(destptr, program_read_word(i));
memory_write_word(space, destptr, memory_read_word(space, i));
destptr = dest + 14;
i = program_read_word(list) + spr_color_offs;
program_write_word(destptr, i);
i = memory_read_word(space, list) + spr_color_offs;
memory_write_word(space, destptr, i);
dest += 16;
list += 4;
}
/* hack for the blit to Sprites RAM - Sprite list end-marker */
program_write_word(dest,0xFFFF);
memory_write_word(space, dest, 0xFFFF);
}
}
}

2
src/mame/includes/segas32.h
View File

@ -23,7 +23,7 @@ WRITE16_HANDLER( brival_protection_w );
READ16_HANDLER( darkedge_protection_r );
WRITE16_HANDLER( darkedge_protection_w );
void darkedge_fd1149_vblank(void);
void darkedge_fd1149_vblank(const device_config *device);
WRITE16_HANDLER( jleague_protection_w );
READ16_HANDLER( dbzvrvs_protection_r );

35
src/mame/machine/cubocd32.c
View File

@ -498,7 +498,7 @@ static void akiko_start_dma( void )
timer_adjust_oneshot( akiko.dma_timer, ATTOTIME_IN_USEC( CD_SECTOR_TIME / akiko.cdrom_speed ), 0 );
}
static void akiko_setup_response( int len, UINT8 *r1 )
static void akiko_setup_response( const address_space *space, int len, UINT8 *r1 )
{
int resp_addr = akiko.cdrom_address[1];
UINT8 resp_csum = 0xff;
@ -517,7 +517,7 @@ static void akiko_setup_response( int len, UINT8 *r1 )
for( i = 0; i < len; i++ )
{
program_write_byte( resp_addr + ((akiko.cdrom_cmd_resp + i) & 0xff), resp_buffer[i] );
memory_write_byte( space, resp_addr + ((akiko.cdrom_cmd_resp + i) & 0xff), resp_buffer[i] );
}
akiko.cdrom_cmd_resp = (akiko.cdrom_cmd_resp+len) & 0xff;
@ -545,6 +545,7 @@ static TIMER_CALLBACK( akiko_cd_delayed_cmd )
if ( param == 0x05 )
{
const address_space *space = cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM);
if (LOG_AKIKO_CD) logerror( "AKIKO: Completing Command %d\n", param );
resp[0] = 0x06;
@ -552,7 +553,7 @@ static TIMER_CALLBACK( akiko_cd_delayed_cmd )
if ( akiko.cdrom == NULL || akiko.cdrom_numtracks == 0 )
{
resp[1] = 0x80;
akiko_setup_response( 15, resp );
akiko_setup_response( space, 15, resp );
}
else
{
@ -561,12 +562,12 @@ static TIMER_CALLBACK( akiko_cd_delayed_cmd )
akiko.cdrom_track_index = ( akiko.cdrom_track_index + 1 ) % akiko.cdrom_numtracks;
akiko_setup_response( 15, resp );
akiko_setup_response( space, 15, resp );
}
}
}
static void akiko_update_cdrom( void )
static void akiko_update_cdrom(const address_space *space)
{
UINT8 resp[32], cmdbuf[32];
@ -576,7 +577,7 @@ static void akiko_update_cdrom( void )
while ( akiko.cdrom_cmd_start != akiko.cdrom_cmd_end )
{
UINT32 cmd_addr = akiko.cdrom_address[1] + 0x200 + akiko.cdrom_cmd_start;
int cmd = program_read_byte( cmd_addr );
int cmd = memory_read_byte( space, cmd_addr );
memset( resp, 0, sizeof( resp ) );
resp[0] = cmd;
@ -596,7 +597,7 @@ static void akiko_update_cdrom( void )
akiko.cdrom_cmd_start = (akiko.cdrom_cmd_start+2) & 0xff;
akiko_setup_response( 2, resp );
akiko_setup_response( space, 2, resp );
}
else if ( cmd == 0x03 ) /* unpause audio (and check audiocd playing status) */
{
@ -609,7 +610,7 @@ static void akiko_update_cdrom( void )
akiko.cdrom_cmd_start = (akiko.cdrom_cmd_start+2) & 0xff;
akiko_setup_response( 2, resp );
akiko_setup_response( space, 2, resp );
}
else if ( cmd == 0x04 ) /* seek/read/play cd multi command */
{
@ -618,7 +619,7 @@ static void akiko_update_cdrom( void )
for( i = 0; i < 13; i++ )
{
cmdbuf[i] = program_read_byte( cmd_addr );
cmdbuf[i] = memory_read_byte( space, cmd_addr );
cmd_addr &= 0xffffff00;
cmd_addr += ( akiko.cdrom_cmd_start + i + 1 ) & 0xff;
}
@ -628,7 +629,7 @@ static void akiko_update_cdrom( void )
if ( akiko.cdrom == NULL || akiko.cdrom_numtracks == 0 )
{
resp[1] = 0x80;
akiko_setup_response( 2, resp );
akiko_setup_response( space, 2, resp );
}
else
{
@ -671,7 +672,7 @@ static void akiko_update_cdrom( void )
}
}
akiko_setup_response( 2, resp );
akiko_setup_response( space, 2, resp );
}
}
else if ( cmd == 0x05 ) /* read toc */
@ -724,7 +725,7 @@ static void akiko_update_cdrom( void )
resp[1] = 0x80;
}
akiko_setup_response( 15, resp );
akiko_setup_response( space, 15, resp );
}
else if ( cmd == 0x07 ) /* check door status */
{
@ -735,7 +736,7 @@ static void akiko_update_cdrom( void )
if ( akiko.cdrom == NULL || akiko.cdrom_numtracks == 0 )
resp[1] = 0x80;
akiko_setup_response( 20, resp );
akiko_setup_response( space, 20, resp );
break;
}
else
@ -773,7 +774,7 @@ READ32_HANDLER(amiga_akiko32_r)
return akiko.cdrom_address[1];
case 0x18/4: /* CDROM COMMAND 1 */
akiko_update_cdrom();
akiko_update_cdrom(space);
retval = akiko.cdrom_cmd_start;
retval <<= 8;
retval |= akiko.cdrom_cmd_resp;
@ -781,7 +782,7 @@ READ32_HANDLER(amiga_akiko32_r)
return retval;
case 0x1C/4: /* CDROM COMMAND 2 */
akiko_update_cdrom();
akiko_update_cdrom(space);
retval = akiko.cdrom_cmd_end;
retval <<= 16;
return retval;
@ -840,14 +841,14 @@ WRITE32_HANDLER(amiga_akiko32_w)
if ( ACCESSING_BITS_8_15 )
akiko.cdrom_cmd_resp = ( data >> 8 ) & 0xff;
akiko_update_cdrom();
akiko_update_cdrom(space);
break;
case 0x1C/4: /* CDROM COMMAND 2 */
if ( ACCESSING_BITS_16_23 )
akiko.cdrom_cmd_end = ( data >> 16 ) & 0xff;
akiko_update_cdrom();
akiko_update_cdrom(space);
break;
case 0x20/4: /* CDROM DMA SECTOR READ REQUEST WRITE */

52
src/mame/machine/konamigx.c
View File

@ -1864,7 +1864,7 @@ WRITE16_HANDLER( K055550_word_w )
lim = adr+bsize*count;
for(i=adr; i<lim; i+=2)
program_write_word(i, prot_data[0x1a/2]);
memory_write_word(space, i, prot_data[0x1a/2]);
break;
// WARNING: The following cases are speculation based with questionable accuracy!(AAT)
@ -1895,41 +1895,41 @@ WRITE16_HANDLER( K055550_word_w )
// let's hope GCC will inline the mem24bew calls
for (src=adr; src<srcend; src+=bsize)
{
cx1 = (short)program_read_word(src);
sx1 = (short)program_read_word(src + 2);
wx1 = (short)program_read_word(src + 4);
cx1 = (short)memory_read_word(space, src);
sx1 = (short)memory_read_word(space, src + 2);
wx1 = (short)memory_read_word(space, src + 4);
cy1 = (short)program_read_word(src + 6);
sy1 = (short)program_read_word(src + 8);
wy1 = (short)program_read_word(src +10);
cy1 = (short)memory_read_word(space, src + 6);
sy1 = (short)memory_read_word(space, src + 8);
wy1 = (short)memory_read_word(space, src +10);
cz1 = (short)program_read_word(src +12);
sz1 = (short)program_read_word(src +14);
wz1 = (short)program_read_word(src +16);
cz1 = (short)memory_read_word(space, src +12);
sz1 = (short)memory_read_word(space, src +14);
wz1 = (short)memory_read_word(space, src +16);
count = i = src + skip;
tgt = src + bsize;
for (; count<tgt; count++) program_write_byte(count, 0);
for (; count<tgt; count++) memory_write_byte(space, count, 0);
for (; tgt<tgtend; i++, tgt+=bsize)
{
c2 = (short)program_read_word(tgt);
s2 = (short)program_read_word(tgt + 2);
w2 = (short)program_read_word(tgt + 4);
c2 = (short)memory_read_word(space, tgt);
s2 = (short)memory_read_word(space, tgt + 2);
w2 = (short)memory_read_word(space, tgt + 4);
if (abs((cx1+sx1)-(c2+s2))>=wx1+w2) continue; // X rejection
c2 = (short)program_read_word(tgt + 6);
s2 = (short)program_read_word(tgt + 8);
w2 = (short)program_read_word(tgt +10);
c2 = (short)memory_read_word(space, tgt + 6);
s2 = (short)memory_read_word(space, tgt + 8);
w2 = (short)memory_read_word(space, tgt +10);
if (abs((cy1+sy1)-(c2+s2))>=wy1+w2) continue; // Y rejection
c2 = (short)program_read_word(tgt +12);
s2 = (short)program_read_word(tgt +14);
w2 = (short)program_read_word(tgt +16);
c2 = (short)memory_read_word(space, tgt +12);
s2 = (short)memory_read_word(space, tgt +14);
w2 = (short)memory_read_word(space, tgt +16);
if (abs((cz1+sz1)-(c2+s2))>=wz1+w2) continue; // Z rejection
program_write_byte(i, 0x80); // collision confirmed
memory_write_byte(space, i, 0x80); // collision confirmed
}
}
break;
@ -2003,13 +2003,13 @@ WRITE16_HANDLER( K053990_martchmp_word_w )
if (element_size == 1)
for (i=src_count; i; i--)
{
program_write_byte(dst_addr, program_read_byte(src_addr));
memory_write_byte(space, dst_addr, memory_read_byte(space, src_addr));
src_addr += src_skip;
dst_addr += dst_skip;
}
else for (i=src_count; i; i--)
{
program_write_word(dst_addr, program_read_word(src_addr));
memory_write_word(space, dst_addr, memory_read_word(space, src_addr));
src_addr += src_skip;
dst_addr += dst_skip;
}
@ -2034,15 +2034,15 @@ WRITE16_HANDLER( K053990_martchmp_word_w )
for (i=mod_count; i; i--)
{
mod_val = program_read_word(mod_addr);
mod_val = memory_read_word(space, mod_addr);
mod_addr += mod_skip;
mod_data = program_read_word(src_addr);
mod_data = memory_read_word(space, src_addr);
src_addr += src_skip;
mod_data += mod_val;
program_write_word(dst_addr, mod_data);
memory_write_word(space, dst_addr, mod_data);
dst_addr += dst_skip;
}
break;

2
src/mame/machine/midyunit.c
View File

@ -96,7 +96,7 @@ WRITE16_HANDLER( midyunit_cmos_enable_w )
{
if (data == 0x500)
{
prot_result = program_read_word(TOBYTE(0x10a4390)) << 4;
prot_result = memory_read_word(space, TOBYTE(0x10a4390)) << 4;
logerror(" desired result = %04X\n", prot_result);
}
}

16
src/mame/machine/n64.c
View File

@ -978,8 +978,8 @@ WRITE32_HANDLER( n64_pi_reg_w )
{
for (i=0; i < dma_length; i++)
{
UINT8 b = program_read_byte_32be(pi_dram_addr);
program_write_byte_32be(pi_cart_addr, b);
UINT8 b = memory_read_byte(space, pi_dram_addr);
memory_write_byte(space, pi_cart_addr, b);
pi_cart_addr += 1;
pi_dram_addr += 1;
}
@ -1005,13 +1005,13 @@ WRITE32_HANDLER( n64_pi_reg_w )
{
for (i=0; i < dma_length; i++)
{
/*UINT32 d = program_read_dword_32be(pi_cart_addr);
program_write_dword_32be(pi_dram_addr, d);
/*UINT32 d = memory_read_dword(space, pi_cart_addr);
memory_write_dword(space, pi_dram_addr, d);
pi_cart_addr += 4;
pi_dram_addr += 4;*/
UINT8 b = program_read_byte_32be(pi_cart_addr);
program_write_byte_32be(pi_dram_addr, b);
UINT8 b = memory_read_byte(space, pi_cart_addr);
memory_write_byte(space, pi_dram_addr, b);
pi_cart_addr += 1;
pi_dram_addr += 1;
}
@ -1021,8 +1021,8 @@ WRITE32_HANDLER( n64_pi_reg_w )
if (pi_first_dma)
{
// TODO: CIC-6105 has different address...
program_write_dword_32be(0x00000318, 0x400000);
program_write_dword_32be(0x000003f0, 0x800000);
memory_write_dword(space, 0x00000318, 0x400000);
memory_write_dword(space, 0x000003f0, 0x800000);
pi_first_dma = 0;
}

9
src/mame/machine/pitnrun.c
View File

@ -106,6 +106,7 @@ static TIMER_CALLBACK( pitnrun_mcu_status_real_w )
WRITE8_HANDLER( pitnrun_68705_portB_w )
{
const address_space *cpu0space = cpu_get_address_space(space->machine->cpu[0], ADDRESS_SPACE_PROGRAM);
if (~data & 0x02)
{
/* 68705 is going to read data from the Z80 */
@ -120,14 +121,14 @@ WRITE8_HANDLER( pitnrun_68705_portB_w )
}
if (~data & 0x10)
{
cpu_push_context(space->machine->cpu[0]);
program_write_byte(address, portA_out);
cpu_push_context(cpu0space->cpu);
memory_write_byte(cpu0space, address, portA_out);
cpu_pop_context();
}
if (~data & 0x20)
{
cpu_push_context(space->machine->cpu[0]);
portA_in = program_read_byte(address);
cpu_push_context(cpu0space->cpu);
portA_in = memory_read_byte(cpu0space, address);
cpu_pop_context();
}
if (~data & 0x40)

4
src/mame/machine/scramble.c
View File

@ -166,12 +166,12 @@ static WRITE8_HANDLER( cavelon_banksw_w )
READ8_HANDLER( hunchbks_mirror_r )
{
return program_read_byte(0x1000+offset);
return memory_read_byte(space, 0x1000+offset);
}
WRITE8_HANDLER( hunchbks_mirror_w )
{
program_write_byte(0x1000+offset,data);
memory_write_byte(space, 0x1000+offset,data);
}
static WRITE8_DEVICE_HANDLER( sound_latch_w )

16
src/mame/machine/scudsp.c
View File

@ -313,12 +313,12 @@ static UINT32 dsp_get_mem_source_dma( UINT32 memcode, UINT32 counter )
return 0;
}
void dsp_prg_ctrl(running_machine *machine, UINT32 data)
void dsp_prg_ctrl(const address_space *space, UINT32 data)
{
if(LEF) dsp_reg.pc = (data & 0xff);
if(EXF) dsp_execute_program();
if(EXF) dsp_execute_program(space);
if(EF && (!(stv_scu[40] & 0x0020)))
cpu_set_input_line_and_vector(machine->cpu[0], 0xa, HOLD_LINE , 0x45);
cpu_set_input_line_and_vector(space->machine->cpu[0], 0xa, HOLD_LINE , 0x45);
}
void dsp_prg_data(UINT32 data)
@ -591,7 +591,7 @@ static void dsp_move_immediate( void )
}
static void dsp_dma( void )
static void dsp_dma( const address_space *space )
{
UINT8 hold = (opcode & 0x4000) >> 14;
UINT32 add = (opcode & 0x38000) >> 15;
@ -650,7 +650,7 @@ static void dsp_dma( void )
if ( source >= 0x06000000 && source <= 0x060fffff )
{
data = program_read_dword(source );
data = memory_read_dword(space, source );
}
else
{
@ -688,7 +688,7 @@ static void dsp_dma( void )
#endif
for ( counter = 0; counter < transfer_cnt; counter++ )
{
program_write_dword(dest, dsp_get_mem_source_dma( dsp_mem, counter ) );
memory_write_dword(space, dest, dsp_get_mem_source_dma( dsp_mem, counter ) );
dest += add;
}
@ -787,7 +787,7 @@ static void dsp_dump_mem( FILE *f )
}
#endif
void dsp_execute_program()
void dsp_execute_program(const address_space *dmaspace)
{
UINT32 cycles_run = 0;
UINT8 cont = 1;
@ -837,7 +837,7 @@ void dsp_execute_program()
switch( (opcode & 0x30000000) >> 28 )
{
case 0x00:
dsp_dma();
dsp_dma(dmaspace);
break;
case 0x01:
dsp_jump();

4
src/mame/machine/scudsp.h
View File

@ -1,9 +1,9 @@
/*SCU DSP stuff*/
extern void dsp_prg_ctrl(running_machine *machine, UINT32 data);
extern void dsp_prg_ctrl(const address_space *space, UINT32 data);
extern void dsp_prg_data(UINT32 data);
extern void dsp_ram_addr_ctrl(UINT32 data);
extern void dsp_ram_addr_w(UINT32 data);
extern UINT32 dsp_ram_addr_r(void);
extern void dsp_execute_program(void);
extern void dsp_execute_program(const address_space *dmaspace);

12
src/mame/machine/segaic16.c
View File

@ -111,7 +111,7 @@ READ16_HANDLER( segaic16_open_bus_r )
/* read original encrypted memory at that address */
recurse = 1;
result = program_read_word_16be(cpu_get_pc(space->cpu));
result = memory_read_word_16be(space, cpu_get_pc(space->cpu));
recurse = 0;
return result;
}
@ -238,17 +238,19 @@ static void memory_mapper_w(const address_space *space, struct memory_mapper_chi
/* 02 - read data into latches 00,01 from 2 * (address in 07,08,09) */
if (data == 0x01)
{
const address_space *targetspace = cpu_get_address_space(chip->cpu, ADDRESS_SPACE_PROGRAM);
offs_t addr = (chip->regs[0x0a] << 17) | (chip->regs[0x0b] << 9) | (chip->regs[0x0c] << 1);
cpu_push_context(chip->cpu);
program_write_word_16be(addr, (chip->regs[0x00] << 8) | chip->regs[0x01]);
cpu_push_context(targetspace->cpu);
memory_write_word(targetspace, addr, (chip->regs[0x00] << 8) | chip->regs[0x01]);
cpu_pop_context();
}
else if (data == 0x02)
{
const address_space *targetspace = cpu_get_address_space(chip->cpu, ADDRESS_SPACE_PROGRAM);
offs_t addr = (chip->regs[0x07] << 17) | (chip->regs[0x08] << 9) | (chip->regs[0x09] << 1);
UINT16 result;
cpu_push_context(chip->cpu);
result = program_read_word_16be(addr);
cpu_push_context(targetspace->cpu);
result = memory_read_word(targetspace, addr);
cpu_pop_context();
chip->regs[0x00] = result >> 8;
chip->regs[0x01] = result;

22
src/mame/machine/segas32.c
View File

@ -228,17 +228,19 @@ WRITE16_HANDLER(brival_protection_w)
******************************************************************************
******************************************************************************/
void darkedge_fd1149_vblank(void)
void darkedge_fd1149_vblank(const device_config *device)
{
program_write_word(0x20f072, 0);
program_write_word(0x20f082, 0);
const address_space *space = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM);
if( program_read_byte(0x20a12c) != 0 )
memory_write_word(space, 0x20f072, 0);
memory_write_word(space, 0x20f082, 0);
if( memory_read_byte(space, 0x20a12c) != 0 )
{
program_write_byte(0x20a12c, program_read_byte(0x20a12c)-1 );
memory_write_byte(space, 0x20a12c, memory_read_byte(space, 0x20a12c)-1 );
if( program_read_byte(0x20a12c) == 0 )
program_write_byte(0x20a12e, 1);
if( memory_read_byte(space, 0x20a12c) == 0 )
memory_write_byte(space, 0x20a12e, 1);
}
}
@ -267,7 +269,7 @@ READ16_HANDLER( darkedge_protection_r )
WRITE16_HANDLER( dbzvrvs_protection_w )
{
program_write_word( 0x2080c8, program_read_word( 0x200044 ) );
memory_write_word( space, 0x2080c8, memory_read_word( space, 0x200044 ) );
}
@ -331,12 +333,12 @@ WRITE16_HANDLER( jleague_protection_w )
// Map team browser selection to opponent browser selection
// using same lookup table that V60 uses for sound sample mapping.
case 0:
program_write_byte( 0x20f708, program_read_word( 0x7bbc0 + data*2 ) );
memory_write_byte( space, 0x20f708, memory_read_word( space, 0x7bbc0 + data*2 ) );
break;
// move on to team browser
case 4/2:
program_write_byte( 0x200016, data & 0xff );
memory_write_byte( space, 0x200016, data & 0xff );
break;
default: