Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-11 08:38:47 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Modernization of drivers part 25 (no whatsnew)

Browse Source
This commit is contained in:
Miodrag Milanovic 2013-02-14 10:36:12 +00:00
parent 85a6b693d2
commit d76ec3b040
24 changed files with 1249 additions and 1208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

109
src/mame/drivers/cyclemb.c
View File

@ -121,6 +121,11 @@ public:
virtual void palette_init(); virtual void palette_init();
UINT32 screen_update_cyclemb(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); UINT32 screen_update_cyclemb(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
UINT32 screen_update_skydest(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); UINT32 screen_update_skydest(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void cyclemb_draw_tilemap(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void cyclemb_draw_sprites(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void skydest_draw_tilemap(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void skydest_draw_sprites(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void skydest_i8741_reset();
}; };
@ -157,30 +162,27 @@ void cyclemb_state::video_start()
{ {
} }
static void cyclemb_draw_tilemap(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) void cyclemb_state::cyclemb_draw_tilemap(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{ {
cyclemb_state *state = screen.machine().driver_data<cyclemb_state>();
gfx_element *gfx = screen.machine().gfx[0]; gfx_element *gfx = screen.machine().gfx[0];
int x,y,count; int x,y,count;
UINT8 flip_screen = state->flip_screen();
count = 0; count = 0;
for (y=0;y<32;y++) for (y=0;y<32;y++)
{ {
for (x=0;x<64;x++) for (x=0;x<64;x++)
{ {
int attr = state->m_cram[count]; int attr = m_cram[count];
int tile = (state->m_vram[count]) | ((attr & 3)<<8); int tile = (m_vram[count]) | ((attr & 3)<<8);
int color = ((attr & 0xf8) >> 3) ^ 0x1f; int color = ((attr & 0xf8) >> 3) ^ 0x1f;
int odd_line = y & 1 ? 0x40 : 0x00; int odd_line = y & 1 ? 0x40 : 0x00;
// int sx_offs = flip_screen ? 512 : 0 // int sx_offs = flip_screen() ? 512 : 0
int scrollx = ((state->m_vram[(y/2)+odd_line]) + (state->m_cram[(y/2)+odd_line]<<8) + 48) & 0x1ff; int scrollx = ((m_vram[(y/2)+odd_line]) + (m_cram[(y/2)+odd_line]<<8) + 48) & 0x1ff;
if(!(attr & 4)) if(!(attr & 4))
color += 0x20;//screen.machine().rand(); color += 0x20;//screen.machine().rand();
if(flip_screen) if(flip_screen())
{ {
drawgfx_opaque(bitmap,cliprect,gfx,tile,color,1,1,512-(x*8)-scrollx,256-(y*8)); drawgfx_opaque(bitmap,cliprect,gfx,tile,color,1,1,512-(x*8)-scrollx,256-(y*8));
/* wrap-around */ /* wrap-around */
@ -209,10 +211,8 @@ static void cyclemb_draw_tilemap(screen_device &screen, bitmap_ind16 &bitmap, co
bank 3 bank 3
---- ---x [1] sprite enable flag? ---- ---x [1] sprite enable flag?
*/ */
static void cyclemb_draw_sprites(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) void cyclemb_state::cyclemb_draw_sprites(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{ {
cyclemb_state *state = screen.machine().driver_data<cyclemb_state>();
UINT8 flip_screen = state->flip_screen();
UINT8 col,fx,fy,region; UINT8 col,fx,fy,region;
UINT16 spr_offs,i; UINT16 spr_offs,i;
INT16 x,y; INT16 x,y;
@ -228,27 +228,27 @@ static void cyclemb_draw_sprites(screen_device &screen, bitmap_ind16 &bitmap, co
for(i=0;i<0x40;i+=2) for(i=0;i<0x40;i+=2)
{ {
y = 0xf1 - state->m_obj2_ram[i]; y = 0xf1 - m_obj2_ram[i];
x = state->m_obj2_ram[i+1] - 56; x = m_obj2_ram[i+1] - 56;
spr_offs = (state->m_obj1_ram[i+0]); spr_offs = (m_obj1_ram[i+0]);
spr_offs += ((state->m_obj3_ram[i+0] & 3) << 8); spr_offs += ((m_obj3_ram[i+0] & 3) << 8);
col = (state->m_obj1_ram[i+1] & 0x3f); col = (m_obj1_ram[i+1] & 0x3f);
region = ((state->m_obj3_ram[i] & 0x10) >> 4) + 1; region = ((m_obj3_ram[i] & 0x10) >> 4) + 1;
if(region == 2) if(region == 2)
{ {
spr_offs >>= 2; spr_offs >>= 2;
//spr_offs += ((state->m_obj3_ram[i+0] & 3) << 5); //spr_offs += ((m_obj3_ram[i+0] & 3) << 5);
y-=16; y-=16;
} }
if(state->m_obj3_ram[i+1] & 1) if(m_obj3_ram[i+1] & 1)
x+=256; x+=256;
//if(state->m_obj3_ram[i+1] & 2) //if(m_obj3_ram[i+1] & 2)
// x-=256; // x-=256;
fx = (state->m_obj3_ram[i+0] & 4) >> 2; fx = (m_obj3_ram[i+0] & 4) >> 2;
fy = (state->m_obj3_ram[i+0] & 8) >> 3; fy = (m_obj3_ram[i+0] & 8) >> 3;
if(flip_screen) if(flip_screen())
{ {
fx = !fx; fx = !fx;
fy = !fy; fy = !fy;
@ -258,12 +258,10 @@ static void cyclemb_draw_sprites(screen_device &screen, bitmap_ind16 &bitmap, co
} }
static void skydest_draw_tilemap(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) void cyclemb_state::skydest_draw_tilemap(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{ {
cyclemb_state *state = screen.machine().driver_data<cyclemb_state>();
gfx_element *gfx = screen.machine().gfx[0]; gfx_element *gfx = screen.machine().gfx[0];
int x,y; int x,y;
//UINT8 flip_screen = state->flip_screen();
for (y=0;y<32;y++) for (y=0;y<32;y++)
@ -272,13 +270,13 @@ static void skydest_draw_tilemap(screen_device &screen, bitmap_ind16 &bitmap, co
{ {
/* upper bits of the first address of cram seems to be related to colour cycling */ /* upper bits of the first address of cram seems to be related to colour cycling */
int attr = state->m_cram[x+y*64]; int attr = m_cram[x+y*64];
int tile = (state->m_vram[x+y*64]) | ((attr & 3)<<8); int tile = (m_vram[x+y*64]) | ((attr & 3)<<8);
int color = ((attr & 0xfc) >> 2); int color = ((attr & 0xfc) >> 2);
int scrollx = state->m_vram[0*64+0]; int scrollx = m_vram[0*64+0];
scrollx |= (state->m_cram[0*64+0] & 0x01)<<8; scrollx |= (m_cram[0*64+0] & 0x01)<<8;
int cycle = (state->m_cram[0*64+0] & 0xf0)>>4; int cycle = (m_cram[0*64+0] & 0xf0)>>4;
color ^= 0x3f; color ^= 0x3f;
// hardcoded to thie palette bit? // hardcoded to thie palette bit?
@ -288,9 +286,9 @@ static void skydest_draw_tilemap(screen_device &screen, bitmap_ind16 &bitmap, co
int scrolly; int scrolly;
if (x<32) if (x<32)
scrolly = state->m_vram[(x)*64+0]; scrolly = m_vram[(x)*64+0];
else else
scrolly = state->m_vram[(x-32)*64+1]; scrolly = m_vram[(x-32)*64+1];
drawgfx_opaque(bitmap,cliprect,gfx,tile,color,0,0,x*8+scrollx,((y*8)-scrolly)&0xff); drawgfx_opaque(bitmap,cliprect,gfx,tile,color,0,0,x*8+scrollx,((y*8)-scrolly)&0xff);
@ -313,42 +311,40 @@ static void skydest_draw_tilemap(screen_device &screen, bitmap_ind16 &bitmap, co
---- ---x [1] sprite enable flag? ---- ---x [1] sprite enable flag?
*/ */
static void skydest_draw_sprites(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) void cyclemb_state::skydest_draw_sprites(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{ {
cyclemb_state *state = screen.machine().driver_data<cyclemb_state>();
UINT8 flip_screen = state->flip_screen();
UINT8 col,fx,fy,region; UINT8 col,fx,fy,region;
UINT16 spr_offs,i; UINT16 spr_offs,i;
INT16 x,y; INT16 x,y;
// popmessage("%d %d",state->m_obj2_ram[0x0d], 0xf1 - state->m_obj2_ram[0x0c+1] + 68); // popmessage("%d %d",m_obj2_ram[0x0d], 0xf1 - m_obj2_ram[0x0c+1] + 68);
for(i=0;i<0x80;i+=2) for(i=0;i<0x80;i+=2)
{ {
y = state->m_obj2_ram[i] - 1; y = m_obj2_ram[i] - 1;
x = state->m_obj2_ram[i+1]; x = m_obj2_ram[i+1];
if(state->m_obj3_ram[i+1] & 1) if(m_obj3_ram[i+1] & 1)
x |= 0x100; x |= 0x100;
x = 0x138 - x; x = 0x138 - x;
spr_offs = (state->m_obj1_ram[i+0]); spr_offs = (m_obj1_ram[i+0]);
spr_offs += ((state->m_obj3_ram[i+0] & 3) << 8); spr_offs += ((m_obj3_ram[i+0] & 3) << 8);
col = (state->m_obj1_ram[i+1] & 0x3f); col = (m_obj1_ram[i+1] & 0x3f);
region = ((state->m_obj3_ram[i] & 0x10) >> 4) + 1; region = ((m_obj3_ram[i] & 0x10) >> 4) + 1;
if(region == 2) if(region == 2)
{ {
spr_offs >>= 2; spr_offs >>= 2;
// spr_offs += ((state->m_obj3_ram[i+0] & 3) << 5); // spr_offs += ((m_obj3_ram[i+0] & 3) << 5);
x-=16; x-=16;
} }
fx = (state->m_obj3_ram[i+0] & 4) >> 2; fx = (m_obj3_ram[i+0] & 4) >> 2;
fy = (state->m_obj3_ram[i+0] & 8) >> 3; fy = (m_obj3_ram[i+0] & 8) >> 3;
if(flip_screen) if(flip_screen())
{ {
fx = !fx; fx = !fx;
fy = !fy; fy = !fy;
@ -407,15 +403,14 @@ WRITE8_MEMBER(cyclemb_state::cyclemb_flip_w)
// a bunch of other things are setted here // a bunch of other things are setted here
} }
static void skydest_i8741_reset(running_machine &machine) void cyclemb_state::skydest_i8741_reset()
{ {
cyclemb_state *state = machine.driver_data<cyclemb_state>();
state->m_mcu[0].rxd = 0; m_mcu[0].rxd = 0;
state->m_mcu[0].txd = 0; m_mcu[0].txd = 0;
state->m_mcu[0].rst = 0; m_mcu[0].rst = 0;
state->m_mcu[0].state = 0; m_mcu[0].state = 0;
state->m_mcu[0].packet_type = 0; m_mcu[0].packet_type = 0;
} }
READ8_MEMBER( cyclemb_state::skydest_i8741_0_r ) READ8_MEMBER( cyclemb_state::skydest_i8741_0_r )
@ -595,7 +590,7 @@ ADDRESS_MAP_END
void cyclemb_state::machine_reset() void cyclemb_state::machine_reset()
{ {
skydest_i8741_reset(machine()); skydest_i8741_reset();
} }

16
src/mame/drivers/dwarfd.c
View File

@ -351,6 +351,7 @@ public:
virtual void palette_init(); virtual void palette_init();
UINT32 screen_update_dwarfd(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); UINT32 screen_update_dwarfd(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
TIMER_DEVICE_CALLBACK_MEMBER(dwarfd_interrupt); TIMER_DEVICE_CALLBACK_MEMBER(dwarfd_interrupt);
void drawCrt( bitmap_rgb32 &bitmap,const rectangle &cliprect );
}; };
@ -783,9 +784,8 @@ void dwarfd_state::video_start()
{ {
} }
static void drawCrt( running_machine &machine, bitmap_rgb32 &bitmap,const rectangle &cliprect ) void dwarfd_state::drawCrt( bitmap_rgb32 &bitmap,const rectangle &cliprect )
{ {
dwarfd_state *state = machine.driver_data<dwarfd_state>();
int x, y; int x, y;
for (y = 0; y < maxy; y++) for (y = 0; y < maxy; y++)
{ {
@ -804,7 +804,7 @@ static void drawCrt( running_machine &machine, bitmap_rgb32 &bitmap,const rectan
while (b == 0) while (b == 0)
{ {
if (count < 0x8000) if (count < 0x8000)
tile = state->m_videobuf[count++]; tile = m_videobuf[count++];
else else
return; return;
@ -823,19 +823,19 @@ static void drawCrt( running_machine &machine, bitmap_rgb32 &bitmap,const rectan
} }
if ((tile & 0xc0) == 0x80) if ((tile & 0xc0) == 0x80)
{ {
state->m_bank = (tile >> 2) & 3; m_bank = (tile >> 2) & 3;
} }
if ((tile & 0xc0) == 0xc0) if ((tile & 0xc0) == 0xc0)
{ {
b = 1; b = 1;
tile = machine.rand() & 0x7f;//(tile >> 2) & 0xf; tile = machine().rand() & 0x7f;//(tile >> 2) & 0xf;
} }
} }
else else
b = 1; b = 1;
} }
drawgfx_transpen(bitmap, cliprect, machine.gfx[0], drawgfx_transpen(bitmap, cliprect, machine().gfx[0],
tile + (state->m_bank + bank2) * 128, tile + (m_bank + bank2) * 128,
0, 0,
0, 0, 0, 0,
x*8,y*8,0); x*8,y*8,0);
@ -847,7 +847,7 @@ static void drawCrt( running_machine &machine, bitmap_rgb32 &bitmap,const rectan
UINT32 dwarfd_state::screen_update_dwarfd(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) UINT32 dwarfd_state::screen_update_dwarfd(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{ {
bitmap.fill(get_black_pen(machine()), cliprect); bitmap.fill(get_black_pen(machine()), cliprect);
drawCrt(machine(), bitmap, cliprect); drawCrt(bitmap, cliprect);
return 0; return 0;
} }

70
src/mame/drivers/halleys.c
View File

@ -269,6 +269,13 @@ public:
TIMER_CALLBACK_MEMBER(blitter_reset); TIMER_CALLBACK_MEMBER(blitter_reset);
TIMER_DEVICE_CALLBACK_MEMBER(halleys_scanline); TIMER_DEVICE_CALLBACK_MEMBER(halleys_scanline);
TIMER_DEVICE_CALLBACK_MEMBER(benberob_scanline); TIMER_DEVICE_CALLBACK_MEMBER(benberob_scanline);
void halleys_decode_rgb(UINT32 *r, UINT32 *g, UINT32 *b, int addr, int data);
void copy_scroll_op(bitmap_ind16 &bitmap, UINT16 *source, int sx, int sy);
void copy_scroll_xp(bitmap_ind16 &bitmap, UINT16 *source, int sx, int sy);
void copy_fixed_xp(bitmap_ind16 &bitmap, UINT16 *source);
void copy_fixed_2b(bitmap_ind16 &bitmap, UINT16 *source);
void filter_bitmap(bitmap_ind16 &bitmap, int mask);
void init_common();
}; };
@ -1159,14 +1166,13 @@ void halleys_state::palette_init()
} }
} }
static void halleys_decode_rgb(running_machine &machine, UINT32 *r, UINT32 *g, UINT32 *b, int addr, int data) void halleys_state::halleys_decode_rgb(UINT32 *r, UINT32 *g, UINT32 *b, int addr, int data)
{ {
/* /*
proms contain: proms contain:
00 00 00 00 c5 0b f3 17 fd cf 1f ef df bf 7f ff 00 00 00 00 c5 0b f3 17 fd cf 1f ef df bf 7f ff
00 00 00 00 01 61 29 26 0b f5 e2 17 57 fb cf f7 00 00 00 00 01 61 29 26 0b f5 e2 17 57 fb cf f7
*/ */
halleys_state *state = machine.driver_data<halleys_state>();
int latch1_273, latch2_273; int latch1_273, latch2_273;
UINT8 *sram_189; UINT8 *sram_189;
UINT8 *prom_6330; UINT8 *prom_6330;
@ -1174,10 +1180,10 @@ static void halleys_decode_rgb(running_machine &machine, UINT32 *r, UINT32 *g, U
int bit0, bit1, bit2, bit3, bit4; int bit0, bit1, bit2, bit3, bit4;
// the four 16x4-bit SN74S189 SRAM chips are assumed be the game's 32-byte palette RAM // the four 16x4-bit SN74S189 SRAM chips are assumed be the game's 32-byte palette RAM
sram_189 = state->m_generic_paletteram_8; sram_189 = m_generic_paletteram_8;
// each of the three 32-byte 6330 PROM is wired to an RGB component output // each of the three 32-byte 6330 PROM is wired to an RGB component output
prom_6330 = state->memregion("proms")->base(); prom_6330 = memregion("proms")->base();
// latch1 holds 8 bits from the selected palette RAM address // latch1 holds 8 bits from the selected palette RAM address
latch1_273 = sram_189[addr]; latch1_273 = sram_189[addr];
@ -1229,7 +1235,7 @@ WRITE8_MEMBER(halleys_state::halleys_paletteram_IIRRGGBB_w)
palette_set_color(machine(), offset+SP_ALPHA, MAKE_RGB(r, g, b)); palette_set_color(machine(), offset+SP_ALPHA, MAKE_RGB(r, g, b));
palette_set_color(machine(), offset+SP_COLLD, MAKE_RGB(r, g, b)); palette_set_color(machine(), offset+SP_COLLD, MAKE_RGB(r, g, b));
halleys_decode_rgb(machine(), &r, &g, &b, offset, 0); halleys_decode_rgb(&r, &g, &b, offset, 0);
palette_set_color(machine(), offset+0x20, MAKE_RGB(r, g, b)); palette_set_color(machine(), offset+0x20, MAKE_RGB(r, g, b));
} }
@ -1263,7 +1269,7 @@ void halleys_state::video_start()
} }
static void copy_scroll_op(bitmap_ind16 &bitmap, UINT16 *source, int sx, int sy) void halleys_state::copy_scroll_op(bitmap_ind16 &bitmap, UINT16 *source, int sx, int sy)
{ {
//-------------------------------------------------------------------------- //--------------------------------------------------------------------------
@ -1300,7 +1306,7 @@ static void copy_scroll_op(bitmap_ind16 &bitmap, UINT16 *source, int sx, int sy)
} }
static void copy_scroll_xp(bitmap_ind16 &bitmap, UINT16 *source, int sx, int sy) void halleys_state::copy_scroll_xp(bitmap_ind16 &bitmap, UINT16 *source, int sx, int sy)
{ {
//-------------------------------------------------------------------------- //--------------------------------------------------------------------------
@ -1358,7 +1364,7 @@ static void copy_scroll_xp(bitmap_ind16 &bitmap, UINT16 *source, int sx, int sy)
static void copy_fixed_xp(bitmap_ind16 &bitmap, UINT16 *source) void halleys_state::copy_fixed_xp(bitmap_ind16 &bitmap, UINT16 *source)
{ {
UINT16 *esi, *edi; UINT16 *esi, *edi;
int dst_pitch, ecx, edx; int dst_pitch, ecx, edx;
@ -1393,7 +1399,7 @@ static void copy_fixed_xp(bitmap_ind16 &bitmap, UINT16 *source)
} }
static void copy_fixed_2b(bitmap_ind16 &bitmap, UINT16 *source) void halleys_state::copy_fixed_2b(bitmap_ind16 &bitmap, UINT16 *source)
{ {
UINT16 *esi, *edi; UINT16 *esi, *edi;
int dst_pitch, ecx, edx; int dst_pitch, ecx, edx;
@ -1440,15 +1446,14 @@ static void copy_fixed_2b(bitmap_ind16 &bitmap, UINT16 *source)
} }
static void filter_bitmap(running_machine &machine, bitmap_ind16 &bitmap, int mask) void halleys_state::filter_bitmap(bitmap_ind16 &bitmap, int mask)
{ {
halleys_state *state = machine.driver_data<halleys_state>();
int dst_pitch; int dst_pitch;
UINT32 *pal_ptr, *edi; UINT32 *pal_ptr, *edi;
int esi, eax, ebx, ecx, edx; int esi, eax, ebx, ecx, edx;
pal_ptr = state->m_internal_palette; pal_ptr = m_internal_palette;
esi = mask | 0xffffff00; esi = mask | 0xffffff00;
edi = (UINT32*)&bitmap.pix16(VIS_MINY, VIS_MINX + CLIP_W); edi = (UINT32*)&bitmap.pix16(VIS_MINY, VIS_MINX + CLIP_W);
dst_pitch = bitmap.rowpixels() >> 1; dst_pitch = bitmap.rowpixels() >> 1;
@ -1504,7 +1509,7 @@ UINT32 halleys_state::screen_update_halleys(screen_device &screen, bitmap_ind16
// HALF-HACK: apply RGB filter when the following conditions are met // HALF-HACK: apply RGB filter when the following conditions are met
i = m_io_ram[0xa0]; i = m_io_ram[0xa0];
j = m_io_ram[0xa1]; j = m_io_ram[0xa1];
if (m_io_ram[0x2b] && (i>0xc6 && i<0xfe) && (j==0xc0 || j==0xed)) filter_bitmap(machine(), bitmap, i); if (m_io_ram[0x2b] && (i>0xc6 && i<0xfe) && (j==0xc0 || j==0xed)) filter_bitmap(bitmap, i);
return 0; return 0;
} }
@ -2148,44 +2153,43 @@ ROM_END
//************************************************************************** //**************************************************************************
// Driver Initializations // Driver Initializations
static void init_common(running_machine &machine) void halleys_state::init_common()
{ {
halleys_state *state = machine.driver_data<halleys_state>();
UINT8 *buf, *rom; UINT8 *buf, *rom;
int addr, i; int addr, i;
UINT8 al, ah, dl, dh; UINT8 al, ah, dl, dh;
// allocate memory for unpacked graphics // allocate memory for unpacked graphics
buf = auto_alloc_array(machine, UINT8, 0x100000); buf = auto_alloc_array(machine(), UINT8, 0x100000);
state->m_gfx_plane02 = buf; m_gfx_plane02 = buf;
state->m_gfx_plane13 = buf + 0x80000; m_gfx_plane13 = buf + 0x80000;
// allocate memory for render layers // allocate memory for render layers
buf = auto_alloc_array(machine, UINT8, SCREEN_BYTESIZE * MAX_LAYERS); buf = auto_alloc_array(machine(), UINT8, SCREEN_BYTESIZE * MAX_LAYERS);
for (i=0; i<MAX_LAYERS; buf+=SCREEN_BYTESIZE, i++) state->m_render_layer[i] = (UINT16*)buf; for (i=0; i<MAX_LAYERS; buf+=SCREEN_BYTESIZE, i++) m_render_layer[i] = (UINT16*)buf;
// allocate memory for pre-processed ROMs // allocate memory for pre-processed ROMs
state->m_gfx1_base = auto_alloc_array(machine, UINT8, 0x20000); m_gfx1_base = auto_alloc_array(machine(), UINT8, 0x20000);
// allocate memory for alpha table // allocate memory for alpha table
state->m_alpha_table = auto_alloc_array(machine, UINT32, 0x10000); m_alpha_table = auto_alloc_array(machine(), UINT32, 0x10000);
// allocate memory for internal palette // allocate memory for internal palette
state->m_internal_palette = auto_alloc_array(machine, UINT32, PALETTE_SIZE); m_internal_palette = auto_alloc_array(machine(), UINT32, PALETTE_SIZE);
// allocate memory for hardware collision list // allocate memory for hardware collision list
state->m_collision_list = auto_alloc_array(machine, UINT8, MAX_SPRITES); m_collision_list = auto_alloc_array(machine(), UINT8, MAX_SPRITES);
// decrypt main program ROM // decrypt main program ROM
rom = state->m_cpu1_base = state->memregion("maincpu")->base(); rom = m_cpu1_base = memregion("maincpu")->base();
buf = state->m_gfx1_base; buf = m_gfx1_base;
for (i=0; i<0x10000; i++) for (i=0; i<0x10000; i++)
{ {
@ -2197,15 +2201,15 @@ static void init_common(running_machine &machine)
// swap graphics ROM addresses and unpack each pixel // swap graphics ROM addresses and unpack each pixel
rom = machine.root_device().memregion("gfx1")->base(); rom = memregion("gfx1")->base();
buf = state->m_gfx_plane02; buf = m_gfx_plane02;
for (i=0xffff; i>=0; i--) for (i=0xffff; i>=0; i--)
{ {
al = rom[i]; al = rom[i];
ah = rom[i+0x10000]; ah = rom[i+0x10000];
state->m_gfx1_base[0xffff-i] = al; m_gfx1_base[0xffff-i] = al;
state->m_gfx1_base[0x1ffff-i] = ah; m_gfx1_base[0x1ffff-i] = ah;
buf[0] = dl = (al & 1) | (ah<<2 & 4); dl <<= 1; buf[0] = dl = (al & 1) | (ah<<2 & 4); dl <<= 1;
buf[1] = dh = (al>>1 & 1) | (ah<<1 & 4); dh <<= 1; buf[1] = dh = (al>>1 & 1) | (ah<<1 & 4); dh <<= 1;
@ -2233,7 +2237,7 @@ DRIVER_INIT_MEMBER(halleys_state,benberob)
{ {
m_game_id = GAME_BENBEROB; m_game_id = GAME_BENBEROB;
init_common(machine()); init_common();
m_blitter_reset_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(halleys_state::blitter_reset),this)); m_blitter_reset_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(halleys_state::blitter_reset),this));
} }
@ -2244,7 +2248,7 @@ DRIVER_INIT_MEMBER(halleys_state,halleys)
m_game_id = GAME_HALLEYS; m_game_id = GAME_HALLEYS;
m_collision_detection = 0xb114; m_collision_detection = 0xb114;
init_common(machine()); init_common();
} }
DRIVER_INIT_MEMBER(halleys_state,halley87) DRIVER_INIT_MEMBER(halleys_state,halley87)
@ -2252,7 +2256,7 @@ DRIVER_INIT_MEMBER(halleys_state,halley87)
m_game_id = GAME_HALLEYS; m_game_id = GAME_HALLEYS;
m_collision_detection = 0xb10d; m_collision_detection = 0xb10d;
init_common(machine()); init_common();
} }

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

@ -207,6 +207,16 @@ public:
UINT32 screen_update_jalmah(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); UINT32 screen_update_jalmah(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
UINT32 screen_update_urashima(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); UINT32 screen_update_urashima(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
TIMER_DEVICE_CALLBACK_MEMBER(jalmah_mcu_sim); TIMER_DEVICE_CALLBACK_MEMBER(jalmah_mcu_sim);
void jalmah_priority_system();
void draw_sc0_layer(bitmap_ind16 &bitmap, const rectangle &cliprect);
void draw_sc1_layer(bitmap_ind16 &bitmap, const rectangle &cliprect);
void draw_sc2_layer(bitmap_ind16 &bitmap, const rectangle &cliprect);
void draw_sc3_layer(bitmap_ind16 &bitmap, const rectangle &cliprect);
void daireika_palette_dma(UINT16 val);
void daireika_mcu_run();
void mjzoomin_mcu_run();
void urashima_mcu_run();
void second_mcu_run();
}; };
@ -366,76 +376,71 @@ etc.)
In the end the final results always are one bit assigned to each priority (i.e. most In the end the final results always are one bit assigned to each priority (i.e. most
priority = 8, then 4, 2 and finally 1). priority = 8, then 4, 2 and finally 1).
***************************************************************************************/ ***************************************************************************************/
static void jalmah_priority_system(running_machine &machine) void jalmah_state::jalmah_priority_system()
{ {
jalmah_state *state = machine.driver_data<jalmah_state>(); UINT8 *pri_rom = memregion("user1")->base();
UINT8 *pri_rom = state->memregion("user1")->base();
UINT8 i; UINT8 i;
UINT8 prinum[0x10]; UINT8 prinum[0x10];
state->m_sc0_prin = 0; m_sc0_prin = 0;
state->m_sc1_prin = 0; m_sc1_prin = 0;
state->m_sc2_prin = 0; m_sc2_prin = 0;
state->m_sc3_prin = 0; m_sc3_prin = 0;
for(i=0;i<0x10;i++) for(i=0;i<0x10;i++)
{ {
prinum[i] = pri_rom[i+state->m_pri*0x10]; prinum[i] = pri_rom[i+m_pri*0x10];
if(prinum[i] == 0) { state->m_sc0_prin++; } if(prinum[i] == 0) { m_sc0_prin++; }
if(prinum[i] == 1) { state->m_sc1_prin++; } if(prinum[i] == 1) { m_sc1_prin++; }
if(prinum[i] == 2) { state->m_sc2_prin++; } if(prinum[i] == 2) { m_sc2_prin++; }
if(prinum[i] == 3) { state->m_sc3_prin++; } if(prinum[i] == 3) { m_sc3_prin++; }
} }
//popmessage("%02x %02x %02x %02x",state->m_sc0_prin,state->m_sc1_prin,state->m_sc2_prin,state->m_sc3_prin); //popmessage("%02x %02x %02x %02x",m_sc0_prin,m_sc1_prin,m_sc2_prin,m_sc3_prin);
} }
static void draw_sc0_layer(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect) void jalmah_state::draw_sc0_layer(bitmap_ind16 &bitmap, const rectangle &cliprect)
{ {
jalmah_state *state = machine.driver_data<jalmah_state>(); switch(m_jm_vregs[0] & 3)
switch(state->m_jm_vregs[0] & 3)
{ {
case 0: state->m_sc0_tilemap_0->draw(bitmap, cliprect, 0,0); break; case 0: m_sc0_tilemap_0->draw(bitmap, cliprect, 0,0); break;
case 1: state->m_sc0_tilemap_1->draw(bitmap, cliprect, 0,0); break; case 1: m_sc0_tilemap_1->draw(bitmap, cliprect, 0,0); break;
case 2: state->m_sc0_tilemap_2->draw(bitmap, cliprect, 0,0); break; case 2: m_sc0_tilemap_2->draw(bitmap, cliprect, 0,0); break;
case 3: state->m_sc0_tilemap_3->draw(bitmap, cliprect, 0,0); break; case 3: m_sc0_tilemap_3->draw(bitmap, cliprect, 0,0); break;
} }
} }
static void draw_sc1_layer(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect) void jalmah_state::draw_sc1_layer(bitmap_ind16 &bitmap, const rectangle &cliprect)
{ {
jalmah_state *state = machine.driver_data<jalmah_state>(); switch(m_jm_vregs[1] & 3)
switch(state->m_jm_vregs[1] & 3)
{ {
case 0: state->m_sc1_tilemap_0->draw(bitmap, cliprect, 0,0); break; case 0: m_sc1_tilemap_0->draw(bitmap, cliprect, 0,0); break;
case 1: state->m_sc1_tilemap_1->draw(bitmap, cliprect, 0,0); break; case 1: m_sc1_tilemap_1->draw(bitmap, cliprect, 0,0); break;
case 2: state->m_sc1_tilemap_2->draw(bitmap, cliprect, 0,0); break; case 2: m_sc1_tilemap_2->draw(bitmap, cliprect, 0,0); break;
case 3: state->m_sc1_tilemap_3->draw(bitmap, cliprect, 0,0); break; case 3: m_sc1_tilemap_3->draw(bitmap, cliprect, 0,0); break;
} }
} }
static void draw_sc2_layer(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect) void jalmah_state::draw_sc2_layer(bitmap_ind16 &bitmap, const rectangle &cliprect)
{ {
jalmah_state *state = machine.driver_data<jalmah_state>(); switch(m_jm_vregs[2] & 3)
switch(state->m_jm_vregs[2] & 3)
{ {
case 0: state->m_sc2_tilemap_0->draw(bitmap, cliprect, 0,0); break; case 0: m_sc2_tilemap_0->draw(bitmap, cliprect, 0,0); break;
case 1: state->m_sc2_tilemap_1->draw(bitmap, cliprect, 0,0); break; case 1: m_sc2_tilemap_1->draw(bitmap, cliprect, 0,0); break;
case 2: state->m_sc2_tilemap_2->draw(bitmap, cliprect, 0,0); break; case 2: m_sc2_tilemap_2->draw(bitmap, cliprect, 0,0); break;
case 3: state->m_sc2_tilemap_3->draw(bitmap, cliprect, 0,0); break; case 3: m_sc2_tilemap_3->draw(bitmap, cliprect, 0,0); break;
} }
} }
static void draw_sc3_layer(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect) void jalmah_state::draw_sc3_layer(bitmap_ind16 &bitmap, const rectangle &cliprect)
{ {
jalmah_state *state = machine.driver_data<jalmah_state>(); switch(m_jm_vregs[3] & 3)
switch(state->m_jm_vregs[3] & 3)
{ {
case 0: case 0:
case 1: state->m_sc3_tilemap_0->draw(bitmap, cliprect, 0,0); break; case 1: m_sc3_tilemap_0->draw(bitmap, cliprect, 0,0); break;
case 2: state->m_sc3_tilemap_2->draw(bitmap, cliprect, 0,0); break; case 2: m_sc3_tilemap_2->draw(bitmap, cliprect, 0,0); break;
case 3: state->m_sc3_tilemap_3->draw(bitmap, cliprect, 0,0); break; case 3: m_sc3_tilemap_3->draw(bitmap, cliprect, 0,0); break;
} }
} }
@ -443,7 +448,7 @@ UINT32 jalmah_state::screen_update_jalmah(screen_device &screen, bitmap_ind16 &b
{ {
UINT16 *jm_scrollram = m_jm_scrollram; UINT16 *jm_scrollram = m_jm_scrollram;
UINT8 cur_prin; UINT8 cur_prin;
jalmah_priority_system(machine()); jalmah_priority_system();
m_sc0_tilemap_0->set_scrollx(0, jm_scrollram[0] & 0xfff); m_sc0_tilemap_0->set_scrollx(0, jm_scrollram[0] & 0xfff);
m_sc0_tilemap_1->set_scrollx(0, jm_scrollram[0] & 0x7ff); m_sc0_tilemap_1->set_scrollx(0, jm_scrollram[0] & 0x7ff);
@ -490,10 +495,10 @@ UINT32 jalmah_state::screen_update_jalmah(screen_device &screen, bitmap_ind16 &b
for(cur_prin=1;cur_prin<=0x8;cur_prin<<=1) for(cur_prin=1;cur_prin<=0x8;cur_prin<<=1)
{ {
if(cur_prin==m_sc0_prin) { draw_sc0_layer(machine(),bitmap,cliprect); } if(cur_prin==m_sc0_prin) { draw_sc0_layer(bitmap,cliprect); }
if(cur_prin==m_sc1_prin) { draw_sc1_layer(machine(),bitmap,cliprect); } if(cur_prin==m_sc1_prin) { draw_sc1_layer(bitmap,cliprect); }
if(cur_prin==m_sc2_prin) { draw_sc2_layer(machine(),bitmap,cliprect); } if(cur_prin==m_sc2_prin) { draw_sc2_layer(bitmap,cliprect); }
if(cur_prin==m_sc3_prin) { draw_sc3_layer(machine(),bitmap,cliprect); } if(cur_prin==m_sc3_prin) { draw_sc3_layer(bitmap,cliprect); }
} }
return 0; return 0;
@ -712,7 +717,7 @@ xxxx ---- MCU program revision
#define MCU_READ(tag, _bit_, _offset_, _retval_) \ #define MCU_READ(tag, _bit_, _offset_, _retval_) \
if((0xffff - machine.root_device().ioport(tag)->read()) & _bit_) { jm_shared_ram[_offset_] = _retval_; } if((0xffff - ioport(tag)->read()) & _bit_) { jm_shared_ram[_offset_] = _retval_; }
/*Funky "DMA" / protection thing*/ /*Funky "DMA" / protection thing*/
/*---- -x-- "DMA" execute.*/ /*---- -x-- "DMA" execute.*/
@ -728,10 +733,9 @@ WRITE16_MEMBER(jalmah_state::urashima_dma_w)
} }
/*same as $f00c0 sub-routine,but with additional work-around,to remove from here...*/ /*same as $f00c0 sub-routine,but with additional work-around,to remove from here...*/
static void daireika_palette_dma(running_machine &machine, UINT16 val) void jalmah_state::daireika_palette_dma(UINT16 val)
{ {
//jalmah_state *state = machine.driver_data<jalmah_state>(); address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
UINT32 index_1, index_2, src_addr, tmp_addr; UINT32 index_1, index_2, src_addr, tmp_addr;
/*a0=301c0+jm_shared_ram[0x540/2] & 0xf00 */ /*a0=301c0+jm_shared_ram[0x540/2] & 0xf00 */
/*a1=88000*/ /*a1=88000*/
@ -750,25 +754,24 @@ static void daireika_palette_dma(running_machine &machine, UINT16 val)
} }
/*RAM-based protection handlings*/ /*RAM-based protection handlings*/
static void daireika_mcu_run(running_machine &machine) void jalmah_state::daireika_mcu_run()
{ {
jalmah_state *state = machine.driver_data<jalmah_state>(); UINT16 *jm_shared_ram = m_jm_shared_ram;
UINT16 *jm_shared_ram = state->m_jm_shared_ram;
if(((jm_shared_ram[0x550/2] & 0xf00) == 0x700) && ((jm_shared_ram[0x540/2] & 0xf00) != state->m_dma_old)) if(((jm_shared_ram[0x550/2] & 0xf00) == 0x700) && ((jm_shared_ram[0x540/2] & 0xf00) != m_dma_old))
{ {
state->m_dma_old = jm_shared_ram[0x540/2] & 0xf00; m_dma_old = jm_shared_ram[0x540/2] & 0xf00;
daireika_palette_dma(machine,((jm_shared_ram[0x540/2] & 0x0f00) >> 8)); daireika_palette_dma(((jm_shared_ram[0x540/2] & 0x0f00) >> 8));
} }
if(state->m_test_mode) //service_mode if(m_test_mode) //service_mode
{ {
jm_shared_ram[0x000/2] = machine.root_device().ioport("KEY0")->read(); jm_shared_ram[0x000/2] = ioport("KEY0")->read();
jm_shared_ram[0x002/2] = machine.root_device().ioport("KEY1")->read(); jm_shared_ram[0x002/2] = ioport("KEY1")->read();
jm_shared_ram[0x004/2] = machine.root_device().ioport("KEY2")->read(); jm_shared_ram[0x004/2] = ioport("KEY2")->read();
jm_shared_ram[0x006/2] = machine.root_device().ioport("KEY3")->read(); jm_shared_ram[0x006/2] = ioport("KEY3")->read();
jm_shared_ram[0x008/2] = machine.root_device().ioport("KEY4")->read(); jm_shared_ram[0x008/2] = ioport("KEY4")->read();
jm_shared_ram[0x00a/2] = machine.root_device().ioport("KEY5")->read(); jm_shared_ram[0x00a/2] = ioport("KEY5")->read();
} }
else else
{ {
@ -795,24 +798,23 @@ static void daireika_mcu_run(running_machine &machine)
MCU_READ("KEY1", 0x0002, 0x000/2, 0x13); /*CHI (trusted)*/ MCU_READ("KEY1", 0x0002, 0x000/2, 0x13); /*CHI (trusted)*/
MCU_READ("KEY0", 0x0004, 0x000/2, 0x14); /*START1*/ MCU_READ("KEY0", 0x0004, 0x000/2, 0x14); /*START1*/
} }
state->m_prg_prot++; m_prg_prot++;
if(state->m_prg_prot > 0x10) { state->m_prg_prot = 0; } if(m_prg_prot > 0x10) { m_prg_prot = 0; }
jm_shared_ram[0x00e/2] = state->m_prg_prot; jm_shared_ram[0x00e/2] = m_prg_prot;
} }
static void mjzoomin_mcu_run(running_machine &machine) void jalmah_state::mjzoomin_mcu_run()
{ {
jalmah_state *state = machine.driver_data<jalmah_state>(); UINT16 *jm_shared_ram = m_jm_shared_ram;
UINT16 *jm_shared_ram = state->m_jm_shared_ram;
if(state->m_test_mode) //service_mode if(m_test_mode) //service_mode
{ {
jm_shared_ram[0x000/2] = state->ioport("KEY0")->read(); jm_shared_ram[0x000/2] = ioport("KEY0")->read();
jm_shared_ram[0x002/2] = state->ioport("KEY1")->read(); jm_shared_ram[0x002/2] = ioport("KEY1")->read();
jm_shared_ram[0x004/2] = state->ioport("KEY2")->read(); jm_shared_ram[0x004/2] = ioport("KEY2")->read();
jm_shared_ram[0x006/2] = state->ioport("KEY3")->read(); jm_shared_ram[0x006/2] = ioport("KEY3")->read();
jm_shared_ram[0x008/2] = state->ioport("KEY4")->read(); jm_shared_ram[0x008/2] = ioport("KEY4")->read();
jm_shared_ram[0x00a/2] = state->ioport("KEY5")->read(); jm_shared_ram[0x00a/2] = ioport("KEY5")->read();
} }
else else
{ {
@ -839,25 +841,24 @@ static void mjzoomin_mcu_run(running_machine &machine)
MCU_READ("KEY1", 0x0002, 0x000/2, 0x13); /*CHI (trusted)*/ MCU_READ("KEY1", 0x0002, 0x000/2, 0x13); /*CHI (trusted)*/
MCU_READ("KEY0", 0x0004, 0x000/2, 0x14); /*START1*/ MCU_READ("KEY0", 0x0004, 0x000/2, 0x14); /*START1*/
} }
jm_shared_ram[0x00c/2] = machine.rand() & 0xffff; jm_shared_ram[0x00c/2] = machine().rand() & 0xffff;
state->m_prg_prot++; m_prg_prot++;
if(state->m_prg_prot > 0x10) { state->m_prg_prot = 0; } if(m_prg_prot > 0x10) { m_prg_prot = 0; }
jm_shared_ram[0x00e/2] = state->m_prg_prot; jm_shared_ram[0x00e/2] = m_prg_prot;
} }
static void urashima_mcu_run(running_machine &machine) void jalmah_state::urashima_mcu_run()
{ {
jalmah_state *state = machine.driver_data<jalmah_state>(); UINT16 *jm_shared_ram = m_jm_shared_ram;
UINT16 *jm_shared_ram = state->m_jm_shared_ram;
if(state->m_test_mode) //service_mode if(m_test_mode) //service_mode
{ {
jm_shared_ram[0x300/2] = state->ioport("KEY0")->read(); jm_shared_ram[0x300/2] = ioport("KEY0")->read();
jm_shared_ram[0x302/2] = state->ioport("KEY1")->read(); jm_shared_ram[0x302/2] = ioport("KEY1")->read();
jm_shared_ram[0x304/2] = state->ioport("KEY2")->read(); jm_shared_ram[0x304/2] = ioport("KEY2")->read();
jm_shared_ram[0x306/2] = state->ioport("KEY3")->read(); jm_shared_ram[0x306/2] = ioport("KEY3")->read();
jm_shared_ram[0x308/2] = state->ioport("KEY4")->read(); jm_shared_ram[0x308/2] = ioport("KEY4")->read();
jm_shared_ram[0x30a/2] = state->ioport("KEY5")->read(); jm_shared_ram[0x30a/2] = ioport("KEY5")->read();
} }
else else
{ {
@ -884,21 +885,20 @@ static void urashima_mcu_run(running_machine &machine)
MCU_READ("KEY1", 0x0002, 0x300/2, 0x13); /*CHI (trusted)*/ MCU_READ("KEY1", 0x0002, 0x300/2, 0x13); /*CHI (trusted)*/
MCU_READ("KEY0", 0x0004, 0x300/2, 0x14); /*START1*/ MCU_READ("KEY0", 0x0004, 0x300/2, 0x14); /*START1*/
} }
jm_shared_ram[0x30c/2] = machine.rand() & 0xffff; jm_shared_ram[0x30c/2] = machine().rand() & 0xffff;
state->m_prg_prot++; m_prg_prot++;
if(state->m_prg_prot > 0x10) { state->m_prg_prot = 0; } if(m_prg_prot > 0x10) { m_prg_prot = 0; }
jm_shared_ram[0x30e/2] = state->m_prg_prot; jm_shared_ram[0x30e/2] = m_prg_prot;
} }
static void second_mcu_run(running_machine &machine) void jalmah_state::second_mcu_run()
{ {
jalmah_state *state = machine.driver_data<jalmah_state>(); UINT16 *jm_shared_ram = m_jm_shared_ram;
UINT16 *jm_shared_ram = state->m_jm_shared_ram; if(m_test_mode) //service_mode
if(state->m_test_mode) //service_mode
{ {
jm_shared_ram[0x200/2] = state->ioport("KEY0")->read(); jm_shared_ram[0x200/2] = ioport("KEY0")->read();
jm_shared_ram[0x202/2] = state->ioport("KEY1")->read(); jm_shared_ram[0x202/2] = ioport("KEY1")->read();
jm_shared_ram[0x204/2] = state->ioport("KEY2")->read(); jm_shared_ram[0x204/2] = ioport("KEY2")->read();
} }
else else
{ {
@ -927,7 +927,7 @@ static void second_mcu_run(running_machine &machine)
// MCU_READ("KEY0", 0x0004, 0x7b8/2, 0x03); /*START1(correct?) */ // MCU_READ("KEY0", 0x0004, 0x7b8/2, 0x03); /*START1(correct?) */
} }
jm_shared_ram[0x20c/2] = machine.rand() & 0xffff; //kakumei2 jm_shared_ram[0x20c/2] = machine().rand() & 0xffff; //kakumei2
} }
@ -943,12 +943,12 @@ TIMER_DEVICE_CALLBACK_MEMBER(jalmah_state::jalmah_mcu_sim)
#define KAKUMEI2_MCU (0x22) #define KAKUMEI2_MCU (0x22)
#define SUCHIPI_MCU (0x23) #define SUCHIPI_MCU (0x23)
*/ */
case MJZOOMIN_MCU: mjzoomin_mcu_run(machine()); break; case MJZOOMIN_MCU: mjzoomin_mcu_run(); break;
case DAIREIKA_MCU: daireika_mcu_run(machine()); break; case DAIREIKA_MCU: daireika_mcu_run(); break;
case URASHIMA_MCU: urashima_mcu_run(machine()); break; case URASHIMA_MCU: urashima_mcu_run(); break;
case KAKUMEI_MCU: case KAKUMEI_MCU:
case KAKUMEI2_MCU: case KAKUMEI2_MCU:
case SUCHIPI_MCU: second_mcu_run(machine()); break; case SUCHIPI_MCU: second_mcu_run(); break;
} }
} }

17
src/mame/drivers/jangou.c
View File

@ -91,6 +91,8 @@ public:
DECLARE_MACHINE_RESET(common); DECLARE_MACHINE_RESET(common);
UINT32 screen_update_jangou(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); UINT32 screen_update_jangou(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
TIMER_CALLBACK_MEMBER(cvsd_bit_timer_callback); TIMER_CALLBACK_MEMBER(cvsd_bit_timer_callback);
UINT8 jangou_gfx_nibble( UINT16 niboffset );
void plot_jangou_gfx_pixel( UINT8 pix, int x, int y );
}; };
@ -177,9 +179,9 @@ h [$16]
w [$17] w [$17]
*/ */
static UINT8 jangou_gfx_nibble( running_machine &machine, UINT16 niboffset ) UINT8 jangou_state::jangou_gfx_nibble( UINT16 niboffset )
{ {
const UINT8 *const blit_rom = machine.root_device().memregion("gfx")->base(); const UINT8 *const blit_rom = memregion("gfx")->base();
if (niboffset & 1) if (niboffset & 1)
return (blit_rom[(niboffset >> 1) & 0xffff] & 0xf0) >> 4; return (blit_rom[(niboffset >> 1) & 0xffff] & 0xf0) >> 4;
@ -187,18 +189,17 @@ static UINT8 jangou_gfx_nibble( running_machine &machine, UINT16 niboffset )
return (blit_rom[(niboffset >> 1) & 0xffff] & 0x0f); return (blit_rom[(niboffset >> 1) & 0xffff] & 0x0f);
} }
static void plot_jangou_gfx_pixel( running_machine &machine, UINT8 pix, int x, int y ) void jangou_state::plot_jangou_gfx_pixel( UINT8 pix, int x, int y )
{ {
jangou_state *state = machine.driver_data<jangou_state>();
if (y < 0 || y >= 512) if (y < 0 || y >= 512)
return; return;
if (x < 0 || x >= 512) if (x < 0 || x >= 512)
return; return;
if (x & 1) if (x & 1)
state->m_blit_buffer[(y * 256) + (x >> 1)] = (state->m_blit_buffer[(y * 256) + (x >> 1)] & 0x0f) | ((pix << 4) & 0xf0); m_blit_buffer[(y * 256) + (x >> 1)] = (m_blit_buffer[(y * 256) + (x >> 1)] & 0x0f) | ((pix << 4) & 0xf0);
else else
state->m_blit_buffer[(y * 256) + (x >> 1)] = (state->m_blit_buffer[(y * 256) + (x >> 1)] & 0xf0) | (pix & 0x0f); m_blit_buffer[(y * 256) + (x >> 1)] = (m_blit_buffer[(y * 256) + (x >> 1)] & 0xf0) | (pix & 0x0f);
} }
WRITE8_MEMBER(jangou_state::blitter_process_w) WRITE8_MEMBER(jangou_state::blitter_process_w)
@ -233,14 +234,14 @@ WRITE8_MEMBER(jangou_state::blitter_process_w)
{ {
int drawx = (x + xcount) & 0xff; int drawx = (x + xcount) & 0xff;
int drawy = (y + ycount) & 0xff; int drawy = (y + ycount) & 0xff;
UINT8 dat = jangou_gfx_nibble(machine(), src + count); UINT8 dat = jangou_gfx_nibble(src + count);
UINT8 cur_pen_hi = m_pen_data[(dat & 0xf0) >> 4]; UINT8 cur_pen_hi = m_pen_data[(dat & 0xf0) >> 4];
UINT8 cur_pen_lo = m_pen_data[(dat & 0x0f) >> 0]; UINT8 cur_pen_lo = m_pen_data[(dat & 0x0f) >> 0];
dat = cur_pen_lo | (cur_pen_hi << 4); dat = cur_pen_lo | (cur_pen_hi << 4);
if ((dat & 0xff) != 0) if ((dat & 0xff) != 0)
plot_jangou_gfx_pixel(machine(), dat, drawx, drawy); plot_jangou_gfx_pixel(dat, drawx, drawy);
if (!flipx) if (!flipx)
count--; count--;

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

@ -111,6 +111,7 @@ public:
DECLARE_PALETTE_INIT(kingdrby); DECLARE_PALETTE_INIT(kingdrby);
DECLARE_PALETTE_INIT(kingdrbb); DECLARE_PALETTE_INIT(kingdrbb);
UINT32 screen_update_kingdrby(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); UINT32 screen_update_kingdrby(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
}; };
@ -183,10 +184,9 @@ static const UINT8 hw_sprite[16] =
0x22, 0x22, 0x22, 0x22, 0x22, 0x11, 0x22, 0x22 0x22, 0x22, 0x22, 0x22, 0x22, 0x11, 0x22, 0x22
}; };
static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect) void kingdrby_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
{ {
kingdrby_state *state = machine.driver_data<kingdrby_state>(); UINT8 *spriteram = m_spriteram;
UINT8 *spriteram = state->m_spriteram;
int count = 0; int count = 0;
/*sprites not fully understood.*/ /*sprites not fully understood.*/
@ -217,13 +217,13 @@ static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const r
{ {
for(dy=0;dy<h;dy++) for(dy=0;dy<h;dy++)
for(dx=0;dx<w;dx++) for(dx=0;dx<w;dx++)
drawgfx_transpen(bitmap,cliprect,machine.gfx[0],spr_offs++,colour,1,0,((x+16*w)-(dx+1)*16),(y+dy*16),0); drawgfx_transpen(bitmap,cliprect,machine().gfx[0],spr_offs++,colour,1,0,((x+16*w)-(dx+1)*16),(y+dy*16),0);
} }
else else
{ {
for(dy=0;dy<h;dy++) for(dy=0;dy<h;dy++)
for(dx=0;dx<w;dx++) for(dx=0;dx<w;dx++)
drawgfx_transpen(bitmap,cliprect,machine.gfx[0],spr_offs++,colour,0,0,(x+dx*16),(y+dy*16),0); drawgfx_transpen(bitmap,cliprect,machine().gfx[0],spr_offs++,colour,0,0,(x+dx*16),(y+dy*16),0);
} }
} }
} }
@ -243,7 +243,7 @@ UINT32 kingdrby_state::screen_update_kingdrby(screen_device &screen, bitmap_ind1
/*TILEMAP_DRAW_CATEGORY + TILEMAP_DRAW_OPAQUE doesn't suit well?*/ /*TILEMAP_DRAW_CATEGORY + TILEMAP_DRAW_OPAQUE doesn't suit well?*/
m_sc0_tilemap->draw(bitmap, cliprect, 0,0); m_sc0_tilemap->draw(bitmap, cliprect, 0,0);
draw_sprites(machine(),bitmap,cliprect); draw_sprites(bitmap,cliprect);
m_sc1_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_CATEGORY(1),0); m_sc1_tilemap->draw(bitmap, cliprect, TILEMAP_DRAW_CATEGORY(1),0);
m_sc0w_tilemap->draw(bitmap, clip, 0,0); m_sc0w_tilemap->draw(bitmap, clip, 0,0);

480
src/mame/drivers/ksys573.c
View File

File diff suppressed because it is too large Load Diff

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

@ -88,11 +88,10 @@ public:
TILE_GET_INFO_MEMBER(get_fg_tile_info); TILE_GET_INFO_MEMBER(get_fg_tile_info);
virtual void video_start(); virtual void video_start();
UINT32 screen_update_limenko(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); UINT32 screen_update_limenko(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void draw_sprites(UINT32 *sprites, const rectangle &cliprect, int count);
void copy_sprites(bitmap_ind16 &bitmap, bitmap_ind16 &sprites_bitmap, bitmap_ind8 &priority_bitmap, const rectangle &cliprect);
}; };
static void draw_sprites(running_machine &machine, UINT32 *sprites, const rectangle &cliprect, int count);
/***************************************************************************************************** /*****************************************************************************************************
MISC FUNCTIONS MISC FUNCTIONS
*****************************************************************************************************/ *****************************************************************************************************/
@ -156,12 +155,12 @@ WRITE32_MEMBER(limenko_state::spriteram_buffer_w)
if(m_spriteram_bit) if(m_spriteram_bit)
{ {
// draw the sprites to the frame buffer // draw the sprites to the frame buffer
draw_sprites(machine(),m_spriteram2,clip,m_prev_sprites_count); draw_sprites(m_spriteram2,clip,m_prev_sprites_count);
} }
else else
{ {
// draw the sprites to the frame buffer // draw the sprites to the frame buffer
draw_sprites(machine(),m_spriteram,clip,m_prev_sprites_count); draw_sprites(m_spriteram,clip,m_prev_sprites_count);
} }
// buffer the next number of sprites to draw // buffer the next number of sprites to draw
@ -420,13 +419,12 @@ static void draw_single_sprite(bitmap_ind16 &dest_bmp,const rectangle &clip,gfx_
} }
// sprites aren't tile based (except for 8x8 ones) // sprites aren't tile based (except for 8x8 ones)
static void draw_sprites(running_machine &machine, UINT32 *sprites, const rectangle &cliprect, int count) void limenko_state::draw_sprites(UINT32 *sprites, const rectangle &cliprect, int count)
{ {
limenko_state *state = machine.driver_data<limenko_state>();
int i; int i;
UINT8 *base_gfx = state->memregion("gfx1")->base(); UINT8 *base_gfx = memregion("gfx1")->base();
UINT8 *gfx_max = base_gfx + state->memregion("gfx1")->bytes(); UINT8 *gfx_max = base_gfx + memregion("gfx1")->bytes();
UINT8 *gfxdata; UINT8 *gfxdata;
@ -463,31 +461,30 @@ static void draw_sprites(running_machine &machine, UINT32 *sprites, const rectan
continue; continue;
/* prepare GfxElement on the fly */ /* prepare GfxElement on the fly */
gfx_element gfx(machine, gfxdata, width, height, width, 0, 256); gfx_element gfx(machine(), gfxdata, width, height, width, 0, 256);
draw_single_sprite(state->m_sprites_bitmap,cliprect,&gfx,0,color,flipx,flipy,x,y,pri); draw_single_sprite(m_sprites_bitmap,cliprect,&gfx,0,color,flipx,flipy,x,y,pri);
// wrap around x // wrap around x
draw_single_sprite(state->m_sprites_bitmap,cliprect,&gfx,0,color,flipx,flipy,x-512,y,pri); draw_single_sprite(m_sprites_bitmap,cliprect,&gfx,0,color,flipx,flipy,x-512,y,pri);
// wrap around y // wrap around y
draw_single_sprite(state->m_sprites_bitmap,cliprect,&gfx,0,color,flipx,flipy,x,y-512,pri); draw_single_sprite(m_sprites_bitmap,cliprect,&gfx,0,color,flipx,flipy,x,y-512,pri);
// wrap around x and y // wrap around x and y
draw_single_sprite(state->m_sprites_bitmap,cliprect,&gfx,0,color,flipx,flipy,x-512,y-512,pri); draw_single_sprite(m_sprites_bitmap,cliprect,&gfx,0,color,flipx,flipy,x-512,y-512,pri);
} }
} }
static void copy_sprites(running_machine &machine, bitmap_ind16 &bitmap, bitmap_ind16 &sprites_bitmap, bitmap_ind8 &priority_bitmap, const rectangle &cliprect) void limenko_state::copy_sprites(bitmap_ind16 &bitmap, bitmap_ind16 &sprites_bitmap, bitmap_ind8 &priority_bitmap, const rectangle &cliprect)
{ {
limenko_state *state = machine.driver_data<limenko_state>();
int y; int y;
for( y=cliprect.min_y; y<=cliprect.max_y; y++ ) for( y=cliprect.min_y; y<=cliprect.max_y; y++ )
{ {
UINT16 *source = &sprites_bitmap.pix16(y); UINT16 *source = &sprites_bitmap.pix16(y);
UINT16 *dest = &bitmap.pix16(y); UINT16 *dest = &bitmap.pix16(y);
UINT8 *dest_pri = &priority_bitmap.pix8(y); UINT8 *dest_pri = &priority_bitmap.pix8(y);
UINT8 *source_pri = &state->m_sprites_bitmap_pri.pix8(y); UINT8 *source_pri = &m_sprites_bitmap_pri.pix8(y);
int x; int x;
for( x=cliprect.min_x; x<=cliprect.max_x; x++ ) for( x=cliprect.min_x; x<=cliprect.max_x; x++ )
@ -537,7 +534,7 @@ UINT32 limenko_state::screen_update_limenko(screen_device &screen, bitmap_ind16
m_fg_tilemap->draw(bitmap, cliprect, 0,1); m_fg_tilemap->draw(bitmap, cliprect, 0,1);
if(m_videoreg[0] & 8) if(m_videoreg[0] & 8)
copy_sprites(machine(), bitmap, m_sprites_bitmap, machine().priority_bitmap, cliprect); copy_sprites(bitmap, m_sprites_bitmap, machine().priority_bitmap, cliprect);
return 0; return 0;
} }

97
src/mame/drivers/meritm.c
View File

@ -245,6 +245,12 @@ public:
TIMER_DEVICE_CALLBACK_MEMBER(meritm_interrupt); TIMER_DEVICE_CALLBACK_MEMBER(meritm_interrupt);
TIMER_DEVICE_CALLBACK_MEMBER(vblank_start_tick); TIMER_DEVICE_CALLBACK_MEMBER(vblank_start_tick);
TIMER_DEVICE_CALLBACK_MEMBER(vblank_end_tick); TIMER_DEVICE_CALLBACK_MEMBER(vblank_end_tick);
void ds1204_w( ds1204_t *ds1204, int rst, int clk, int dq );
int ds1204_r(ds1204_t *ds1204);
void ds1204_init(const UINT8* key, const UINT8* nvram);
void meritm_crt250_switch_banks( );
void meritm_switch_banks( );
UINT8 binary_to_BCD(UINT8 data);
}; };
@ -265,7 +271,7 @@ public:
#define DS1204_STATE_WRITE_SECURITY_MATCH 3 #define DS1204_STATE_WRITE_SECURITY_MATCH 3
#define DS1204_STATE_READ_NVRAM 4 #define DS1204_STATE_READ_NVRAM 4
static void ds1204_w( ds1204_t *ds1204, int rst, int clk, int dq ) void meritm_state::ds1204_w( ds1204_t *ds1204, int rst, int clk, int dq )
{ {
//logerror("ds1204_w: rst = %d, clk = %d, dq = %d\n", rst, clk, dq ); //logerror("ds1204_w: rst = %d, clk = %d, dq = %d\n", rst, clk, dq );
if ( rst == 0 ) if ( rst == 0 )
@ -344,26 +350,25 @@ static void ds1204_w( ds1204_t *ds1204, int rst, int clk, int dq )
} }
}; };
static int ds1204_r(ds1204_t *ds1204) int meritm_state::ds1204_r(ds1204_t *ds1204)
{ {
//logerror("ds1204_r\n"); //logerror("ds1204_r\n");
return ds1204->out_bit; return ds1204->out_bit;
}; };
static void ds1204_init(running_machine &machine, const UINT8* key, const UINT8* nvram) void meritm_state::ds1204_init(const UINT8* key, const UINT8* nvram)
{ {
meritm_state *state = machine.driver_data<meritm_state>(); memset(&m_ds1204, 0, sizeof(m_ds1204));
memset(&state->m_ds1204, 0, sizeof(state->m_ds1204));
if (key) if (key)
memcpy(state->m_ds1204.key, key, sizeof(state->m_ds1204.key)); memcpy(m_ds1204.key, key, sizeof(m_ds1204.key));
if (nvram) if (nvram)
memcpy(state->m_ds1204.nvram, nvram, sizeof(state->m_ds1204.nvram)); memcpy(m_ds1204.nvram, nvram, sizeof(m_ds1204.nvram));
state_save_register_item(machine, "ds1204", NULL, 0, state->m_ds1204.state); state_save_register_item(machine(), "ds1204", NULL, 0, m_ds1204.state);
state_save_register_item(machine, "ds1204", NULL, 0, state->m_ds1204.read_ptr); state_save_register_item(machine(), "ds1204", NULL, 0, m_ds1204.read_ptr);
state_save_register_item(machine, "ds1204", NULL, 0, state->m_ds1204.last_clk); state_save_register_item(machine(), "ds1204", NULL, 0, m_ds1204.last_clk);
state_save_register_item(machine, "ds1204", NULL, 0, state->m_ds1204.out_bit); state_save_register_item(machine(), "ds1204", NULL, 0, m_ds1204.out_bit);
state_save_register_item_array(machine, "ds1204", NULL, 0, state->m_ds1204.command); state_save_register_item_array(machine(), "ds1204", NULL, 0, m_ds1204.command);
}; };
/************************************* /*************************************
@ -498,45 +503,43 @@ UINT32 meritm_state::screen_update_meritm(screen_device &screen, bitmap_ind16 &b
*************************************/ *************************************/
static void meritm_crt250_switch_banks( running_machine &machine ) void meritm_state::meritm_crt250_switch_banks( )
{ {
meritm_state *state = machine.driver_data<meritm_state>(); int rombank = (m_bank & 0x07) ^ 0x07;
int rombank = (state->m_bank & 0x07) ^ 0x07;
//logerror( "CRT250: Switching banks: rom = %0x (bank = %x)\n", rombank, state->m_bank ); //logerror( "CRT250: Switching banks: rom = %0x (bank = %x)\n", rombank, m_bank );
state->membank("bank1")->set_entry(rombank ); membank("bank1")->set_entry(rombank );
}; };
WRITE8_MEMBER(meritm_state::meritm_crt250_bank_w) WRITE8_MEMBER(meritm_state::meritm_crt250_bank_w)
{ {
meritm_crt250_switch_banks(machine()); meritm_crt250_switch_banks();
}; };
static void meritm_switch_banks( running_machine &machine ) void meritm_state::meritm_switch_banks( )
{ {
meritm_state *state = machine.driver_data<meritm_state>(); int rambank = (m_psd_a15 >> 2) & 0x3;
int rambank = (state->m_psd_a15 >> 2) & 0x3; int rombank = (((m_bank >> 3) & 0x3) << 5) |
int rombank = (((state->m_bank >> 3) & 0x3) << 5) | (((m_psd_a15 >> 1) & 0x1) << 4) |
(((state->m_psd_a15 >> 1) & 0x1) << 4) | (((m_bank & 0x07) ^ 0x07) << 1) |
(((state->m_bank & 0x07) ^ 0x07) << 1) | (m_psd_a15 & 0x1);
(state->m_psd_a15 & 0x1);
//logerror( "Switching banks: rom = %0x (bank = %x), ram = %0x\n", rombank, state->m_bank, rambank); //logerror( "Switching banks: rom = %0x (bank = %x), ram = %0x\n", rombank, m_bank, rambank);
state->membank("bank1")->set_entry(rombank ); membank("bank1")->set_entry(rombank );
state->membank("bank2")->set_entry(rombank | 0x01); membank("bank2")->set_entry(rombank | 0x01);
state->membank("bank3")->set_entry(rambank); membank("bank3")->set_entry(rambank);
}; };
WRITE8_MEMBER(meritm_state::meritm_psd_a15_w) WRITE8_MEMBER(meritm_state::meritm_psd_a15_w)
{ {
m_psd_a15 = data; m_psd_a15 = data;
//logerror( "Writing PSD_A15 with %02x at PC=%04X\n", data, space.device().safe_pc() ); //logerror( "Writing PSD_A15 with %02x at PC=%04X\n", data, space.device().safe_pc() );
meritm_switch_banks(machine()); meritm_switch_banks();
}; };
WRITE8_MEMBER(meritm_state::meritm_bank_w) WRITE8_MEMBER(meritm_state::meritm_bank_w)
{ {
meritm_switch_banks(machine()); meritm_switch_banks();
}; };
/************************************* /*************************************
@ -626,7 +629,7 @@ WRITE8_MEMBER(meritm_state::meritm_ds1644_w)
} }
}; };
static UINT8 binary_to_BCD(UINT8 data) UINT8 meritm_state::binary_to_BCD(UINT8 data)
{ {
data %= 100; data %= 100;
@ -1107,7 +1110,7 @@ void meritm_state::machine_start()
{ {
membank("bank1")->configure_entries(0, 8, memregion("maincpu")->base(), 0x10000); membank("bank1")->configure_entries(0, 8, memregion("maincpu")->base(), 0x10000);
m_bank = 0xff; m_bank = 0xff;
meritm_crt250_switch_banks(machine()); meritm_crt250_switch_banks();
MACHINE_START_CALL_MEMBER(merit_common); MACHINE_START_CALL_MEMBER(merit_common);
state_save_register_global(machine(), m_bank); state_save_register_global(machine(), m_bank);
@ -1135,7 +1138,7 @@ MACHINE_START_MEMBER(meritm_state,meritm_crt260)
membank("bank3")->configure_entries(0, 4, m_ram, 0x2000); membank("bank3")->configure_entries(0, 4, m_ram, 0x2000);
m_bank = 0xff; m_bank = 0xff;
m_psd_a15 = 0; m_psd_a15 = 0;
meritm_switch_banks(machine()); meritm_switch_banks();
MACHINE_START_CALL_MEMBER(merit_common); MACHINE_START_CALL_MEMBER(merit_common);
pc16552d_init(machine(), 0, UART_CLK, NULL, pc16650d_tx_callback); pc16552d_init(machine(), 0, UART_CLK, NULL, pc16650d_tx_callback);
state_save_register_global(machine(), m_bank); state_save_register_global(machine(), m_bank);
@ -2003,7 +2006,7 @@ DRIVER_INIT_MEMBER(meritm_state,pitbossm)
static const UINT8 pitbossm_ds1204_nvram[16] = static const UINT8 pitbossm_ds1204_nvram[16] =
{ 0x16, 0x90, 0xa0, 0x52, 0xd8, 0x6c, 0x12, 0xaf, 0x36, 0x22, 0x61, 0x35, 0x0d, 0x58, 0x0c, 0x00 }; { 0x16, 0x90, 0xa0, 0x52, 0xd8, 0x6c, 0x12, 0xaf, 0x36, 0x22, 0x61, 0x35, 0x0d, 0x58, 0x0c, 0x00 };
ds1204_init(machine(), pitbossm_ds1204_key, pitbossm_ds1204_nvram); ds1204_init(pitbossm_ds1204_key, pitbossm_ds1204_nvram);
}; };
@ -2015,7 +2018,7 @@ DRIVER_INIT_MEMBER(meritm_state,pbst30)
static const UINT8 pbst30b_ds1204_nvram[16] = static const UINT8 pbst30b_ds1204_nvram[16] =
{ 0x3e, 0x9a, 0x3c, 0x3f, 0x1d, 0x51, 0x72, 0xc9, 0x28, 0x2c, 0x1d, 0x2d, 0x0e, 0x56, 0x41, 0x00 }; { 0x3e, 0x9a, 0x3c, 0x3f, 0x1d, 0x51, 0x72, 0xc9, 0x28, 0x2c, 0x1d, 0x2d, 0x0e, 0x56, 0x41, 0x00 };
ds1204_init(machine(), pbst30b_ds1204_key, pbst30b_ds1204_nvram); ds1204_init(pbst30b_ds1204_key, pbst30b_ds1204_nvram);
}; };
@ -2027,7 +2030,7 @@ DRIVER_INIT_MEMBER(meritm_state,pbst30b)
static const UINT8 pbst30b_ds1204_nvram[16] = static const UINT8 pbst30b_ds1204_nvram[16] =
{ 0xa9, 0xdb, 0x41, 0xf8, 0xe4, 0x42, 0x20, 0x6e, 0xde, 0xaf, 0x4f, 0x046, 0x3d, 0x55, 0x44, 0x00 }; { 0xa9, 0xdb, 0x41, 0xf8, 0xe4, 0x42, 0x20, 0x6e, 0xde, 0xaf, 0x4f, 0x046, 0x3d, 0x55, 0x44, 0x00 };
ds1204_init(machine(), pbst30b_ds1204_key, pbst30b_ds1204_nvram); ds1204_init(pbst30b_ds1204_key, pbst30b_ds1204_nvram);
}; };
@ -2039,7 +2042,7 @@ DRIVER_INIT_MEMBER(meritm_state,megat2)
static const UINT8 pitbosmt_ds1204_nvram[16] = static const UINT8 pitbosmt_ds1204_nvram[16] =
{ 0x00, 0xfe, 0x03, 0x03, 0x08, 0x00, 0xa2, 0x03, 0x4b, 0x07, 0x00, 0xe6, 0x02, 0xd3, 0x05, 0x00 }; { 0x00, 0xfe, 0x03, 0x03, 0x08, 0x00, 0xa2, 0x03, 0x4b, 0x07, 0x00, 0xe6, 0x02, 0xd3, 0x05, 0x00 };
ds1204_init(machine(), pitbosmt_ds1204_key, pitbosmt_ds1204_nvram); ds1204_init(pitbosmt_ds1204_key, pitbosmt_ds1204_nvram);
}; };
@ -2051,7 +2054,7 @@ DRIVER_INIT_MEMBER(meritm_state,megat3)
static const UINT8 megat3_ds1204_nvram[16] = static const UINT8 megat3_ds1204_nvram[16] =
{ 0x51, 0xa1, 0xc0, 0x7c, 0x27, 0x6e, 0x51, 0xb9, 0xa5, 0xb2, 0x27, 0x0c, 0xb9, 0x88, 0x82, 0x2c }; { 0x51, 0xa1, 0xc0, 0x7c, 0x27, 0x6e, 0x51, 0xb9, 0xa5, 0xb2, 0x27, 0x0c, 0xb9, 0x88, 0x82, 0x2c };
ds1204_init(machine(), megat3_ds1204_key, megat3_ds1204_nvram); ds1204_init(megat3_ds1204_key, megat3_ds1204_nvram);
}; };
@ -2063,7 +2066,7 @@ DRIVER_INIT_MEMBER(meritm_state,megat3te)
static const UINT8 megat3_ds1204_nvram[16] = static const UINT8 megat3_ds1204_nvram[16] =
{ 0x99, 0x53, 0xfc, 0x29, 0x3a, 0x95, 0x8b, 0x58, 0xca, 0xca, 0x00, 0xc2, 0x30, 0x62, 0x0b, 0x96 }; { 0x99, 0x53, 0xfc, 0x29, 0x3a, 0x95, 0x8b, 0x58, 0xca, 0xca, 0x00, 0xc2, 0x30, 0x62, 0x0b, 0x96 };
ds1204_init(machine(), megat3_ds1204_key, megat3_ds1204_nvram); ds1204_init(megat3_ds1204_key, megat3_ds1204_nvram);
machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0xfff8, 0xffff, read8_delegate(FUNC(meritm_state::meritm_ds1644_r), this), write8_delegate(FUNC(meritm_state::meritm_ds1644_w), this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0xfff8, 0xffff, read8_delegate(FUNC(meritm_state::meritm_ds1644_r), this), write8_delegate(FUNC(meritm_state::meritm_ds1644_w), this));
@ -2074,7 +2077,7 @@ DRIVER_INIT_MEMBER(meritm_state,megat4)
static const UINT8 megat4_ds1204_nvram[16] = static const UINT8 megat4_ds1204_nvram[16] =
{ 0xe3, 0x08, 0x39, 0xd8, 0x4c, 0xbb, 0xc4, 0xf8, 0xf0, 0xe2, 0xd8, 0x77, 0xa8, 0x3d, 0x95, 0x02 }; { 0xe3, 0x08, 0x39, 0xd8, 0x4c, 0xbb, 0xc4, 0xf8, 0xf0, 0xe2, 0xd8, 0x77, 0xa8, 0x3d, 0x95, 0x02 };
ds1204_init(machine(), 0, megat4_ds1204_nvram); ds1204_init(0, megat4_ds1204_nvram);
} }
DRIVER_INIT_MEMBER(meritm_state,megat4c) DRIVER_INIT_MEMBER(meritm_state,megat4c)
@ -2085,7 +2088,7 @@ DRIVER_INIT_MEMBER(meritm_state,megat4c)
static const UINT8 megat4_ds1204_nvram[16] = static const UINT8 megat4_ds1204_nvram[16] =
{ 0xe3, 0x08, 0x39, 0xd8, 0x4c, 0xbb, 0xc4, 0xf8, 0xf0, 0xe2, 0xd8, 0x77, 0xa8, 0x3d, 0x95, 0x02 }; { 0xe3, 0x08, 0x39, 0xd8, 0x4c, 0xbb, 0xc4, 0xf8, 0xf0, 0xe2, 0xd8, 0x77, 0xa8, 0x3d, 0x95, 0x02 };
ds1204_init(machine(), megat4c_ds1204_key, megat4_ds1204_nvram); ds1204_init(megat4c_ds1204_key, megat4_ds1204_nvram);
} }
DRIVER_INIT_MEMBER(meritm_state,megat4te) DRIVER_INIT_MEMBER(meritm_state,megat4te)
@ -2093,7 +2096,7 @@ DRIVER_INIT_MEMBER(meritm_state,megat4te)
static const UINT8 megat4te_ds1204_nvram[16] = static const UINT8 megat4te_ds1204_nvram[16] =
{ 0x05, 0x21, 0x96, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 }; { 0x05, 0x21, 0x96, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 };
ds1204_init(machine(), 0, megat4te_ds1204_nvram); ds1204_init(0, megat4te_ds1204_nvram);
machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0xfff8, 0xffff, read8_delegate(FUNC(meritm_state::meritm_ds1644_r), this), write8_delegate(FUNC(meritm_state::meritm_ds1644_w), this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0xfff8, 0xffff, read8_delegate(FUNC(meritm_state::meritm_ds1644_r), this), write8_delegate(FUNC(meritm_state::meritm_ds1644_w), this));
@ -2104,7 +2107,7 @@ DRIVER_INIT_MEMBER(meritm_state,megat4st)
static const UINT8 megat4te_ds1204_nvram[16] = static const UINT8 megat4te_ds1204_nvram[16] =
{ 0x11, 0x04, 0x96, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 }; { 0x11, 0x04, 0x96, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 };
ds1204_init(machine(), 0, megat4te_ds1204_nvram); ds1204_init(0, megat4te_ds1204_nvram);
machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0xfff8, 0xffff, read8_delegate(FUNC(meritm_state::meritm_ds1644_r), this), write8_delegate(FUNC(meritm_state::meritm_ds1644_w), this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0xfff8, 0xffff, read8_delegate(FUNC(meritm_state::meritm_ds1644_r), this), write8_delegate(FUNC(meritm_state::meritm_ds1644_w), this));
@ -2115,7 +2118,7 @@ DRIVER_INIT_MEMBER(meritm_state,megat5)
static const UINT8 megat5_ds1204_nvram[16] = static const UINT8 megat5_ds1204_nvram[16] =
{ 0x06, 0x23, 0x97, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 }; { 0x06, 0x23, 0x97, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 };
ds1204_init(machine(), 0, megat5_ds1204_nvram); ds1204_init(0, megat5_ds1204_nvram);
} }
@ -2124,7 +2127,7 @@ DRIVER_INIT_MEMBER(meritm_state,megat5t)
static const UINT8 megat5_ds1204_nvram[16] = static const UINT8 megat5_ds1204_nvram[16] =
{ 0x08, 0x22, 0x97, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 }; { 0x08, 0x22, 0x97, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 };
ds1204_init(machine(), 0, megat5_ds1204_nvram); ds1204_init(0, megat5_ds1204_nvram);
machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0xfff8, 0xffff, read8_delegate(FUNC(meritm_state::meritm_ds1644_r), this), write8_delegate(FUNC(meritm_state::meritm_ds1644_w), this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0xfff8, 0xffff, read8_delegate(FUNC(meritm_state::meritm_ds1644_r), this), write8_delegate(FUNC(meritm_state::meritm_ds1644_w), this));
@ -2135,7 +2138,7 @@ DRIVER_INIT_MEMBER(meritm_state,megat6)
static const UINT8 megat6_ds1204_nvram[16] = static const UINT8 megat6_ds1204_nvram[16] =
{ 0x07, 0x15, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 }; { 0x07, 0x15, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 };
ds1204_init(machine(), 0, megat6_ds1204_nvram); ds1204_init(0, megat6_ds1204_nvram);
} }

141
src/mame/drivers/multigam.c
View File

@ -146,6 +146,13 @@ public:
DECLARE_MACHINE_START(supergm3); DECLARE_MACHINE_START(supergm3);
UINT32 screen_update_multigam(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); UINT32 screen_update_multigam(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
TIMER_CALLBACK_MEMBER(mmc1_resync_callback); TIMER_CALLBACK_MEMBER(mmc1_resync_callback);
void set_videorom_bank( int start, int count, int bank, int bank_size_in_kb);
void set_videoram_bank( int start, int count, int bank, int bank_size_in_kb);
void multigam_init_mmc3(UINT8 *prg_base, int prg_size, int chr_bank_base);
void multigam_init_mapper02(UINT8* prg_base, int prg_size);
void multigam_init_mmc1(UINT8 *prg_base, int prg_size, int chr_bank_base);
void supergm3_set_bank();
void multigm3_decrypt(UINT8* mem, int memsize, const UINT8* decode_nibble);
}; };
@ -203,7 +210,7 @@ READ8_MEMBER(multigam_state::multigam_nt_r)
static const char * const banknames[] = { "bank2", "bank3", "bank4", "bank5", "bank6", "bank7", "bank8", "bank9" }; static const char * const banknames[] = { "bank2", "bank3", "bank4", "bank5", "bank6", "bank7", "bank8", "bank9" };
static void set_videorom_bank(running_machine& machine, int start, int count, int bank, int bank_size_in_kb) void multigam_state::set_videorom_bank( int start, int count, int bank, int bank_size_in_kb)
{ {
int i; int i;
int offset = bank * (bank_size_in_kb * 0x400); int offset = bank * (bank_size_in_kb * 0x400);
@ -211,20 +218,19 @@ static void set_videorom_bank(running_machine& machine, int start, int count, in
/* count determines the size of the area mapped in KB */ /* count determines the size of the area mapped in KB */
for (i = 0; i < count; i++, offset += 0x400) for (i = 0; i < count; i++, offset += 0x400)
{ {
machine.root_device().membank(banknames[i + start])->set_base(machine.root_device().memregion("gfx1")->base() + offset); membank(banknames[i + start])->set_base(memregion("gfx1")->base() + offset);
} }
} }
static void set_videoram_bank(running_machine& machine, int start, int count, int bank, int bank_size_in_kb) void multigam_state::set_videoram_bank( int start, int count, int bank, int bank_size_in_kb)
{ {
multigam_state *state = machine.driver_data<multigam_state>();
int i; int i;
int offset = bank * (bank_size_in_kb * 0x400); int offset = bank * (bank_size_in_kb * 0x400);
/* bank_size_in_kb is used to determine how large the "bank" parameter is */ /* bank_size_in_kb is used to determine how large the "bank" parameter is */
/* count determines the size of the area mapped in KB */ /* count determines the size of the area mapped in KB */
for (i = 0; i < count; i++, offset += 0x400) for (i = 0; i < count; i++, offset += 0x400)
{ {
state->membank(banknames[i + start])->set_base(state->m_vram + offset); membank(banknames[i + start])->set_base(m_vram + offset);
} }
} }
@ -466,7 +472,7 @@ WRITE8_MEMBER(multigam_state::multigam3_mmc3_rom_switch_w)
case 1: /* char banking */ case 1: /* char banking */
data &= 0xfe; data &= 0xfe;
page ^= (cmd << 1); page ^= (cmd << 1);
set_videorom_bank(machine(), page, 2, m_multigam3_mmc3_chr_bank_base + data, 1); set_videorom_bank(page, 2, m_multigam3_mmc3_chr_bank_base + data, 1);
break; break;
case 2: /* char banking */ case 2: /* char banking */
@ -474,7 +480,7 @@ WRITE8_MEMBER(multigam_state::multigam3_mmc3_rom_switch_w)
case 4: /* char banking */ case 4: /* char banking */
case 5: /* char banking */ case 5: /* char banking */
page ^= cmd + 2; page ^= cmd + 2;
set_videorom_bank(machine(), page, 1, m_multigam3_mmc3_chr_bank_base + data, 1); set_videorom_bank(page, 1, m_multigam3_mmc3_chr_bank_base + data, 1);
break; break;
case 6: /* program banking */ case 6: /* program banking */
@ -559,36 +565,35 @@ WRITE8_MEMBER(multigam_state::multigam3_mmc3_rom_switch_w)
} }
} }
static void multigam_init_mmc3(running_machine &machine, UINT8 *prg_base, int prg_size, int chr_bank_base) void multigam_state::multigam_init_mmc3(UINT8 *prg_base, int prg_size, int chr_bank_base)
{ {
multigam_state *state = machine.driver_data<multigam_state>(); UINT8* dst = memregion("maincpu")->base();
UINT8* dst = state->memregion("maincpu")->base();
// Tom & Jerry in Super Game III enables 6000 ram, but does not read/write it // Tom & Jerry in Super Game III enables 6000 ram, but does not read/write it
// however, it expects ROM from 6000 there (code jumps to $6xxx) // however, it expects ROM from 6000 there (code jumps to $6xxx)
memcpy(state->m_multigmc_mmc3_6000_ram, dst + 0x6000, 0x2000); memcpy(m_multigmc_mmc3_6000_ram, dst + 0x6000, 0x2000);
memcpy(&dst[0x8000], prg_base + (prg_size - 0x4000), 0x4000); memcpy(&dst[0x8000], prg_base + (prg_size - 0x4000), 0x4000);
memcpy(&dst[0xc000], prg_base + (prg_size - 0x4000), 0x4000); memcpy(&dst[0xc000], prg_base + (prg_size - 0x4000), 0x4000);
machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x8000, 0xffff, write8_delegate(FUNC(multigam_state::multigam3_mmc3_rom_switch_w),state)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x8000, 0xffff, write8_delegate(FUNC(multigam_state::multigam3_mmc3_rom_switch_w),this));
state->m_multigam3_mmc3_banks[0] = 0x1e; m_multigam3_mmc3_banks[0] = 0x1e;
state->m_multigam3_mmc3_banks[1] = 0x1f; m_multigam3_mmc3_banks[1] = 0x1f;
state->m_multigam3_mmc3_scanline_counter = 0; m_multigam3_mmc3_scanline_counter = 0;
state->m_multigam3_mmc3_scanline_latch = 0; m_multigam3_mmc3_scanline_latch = 0;
state->m_multigam3_mmc3_4screen = 0; m_multigam3_mmc3_4screen = 0;
state->m_multigam3_mmc3_last_bank = 0xff; m_multigam3_mmc3_last_bank = 0xff;
state->m_multigam3_mmc3_prg_base = prg_base; m_multigam3_mmc3_prg_base = prg_base;
state->m_multigam3_mmc3_chr_bank_base = chr_bank_base; m_multigam3_mmc3_chr_bank_base = chr_bank_base;
state->m_multigam3_mmc3_prg_size = prg_size; m_multigam3_mmc3_prg_size = prg_size;
}; };
WRITE8_MEMBER(multigam_state::multigm3_mapper2_w) WRITE8_MEMBER(multigam_state::multigm3_mapper2_w)
{ {
if (m_game_gfx_bank & 0x80) if (m_game_gfx_bank & 0x80)
{ {
set_videorom_bank(machine(), 0, 8, (m_game_gfx_bank & 0x3c) + (data & 0x3), 8); set_videorom_bank(0, 8, (m_game_gfx_bank & 0x3c) + (data & 0x3), 8);
} }
else else
{ {
@ -598,7 +603,7 @@ WRITE8_MEMBER(multigam_state::multigm3_mapper2_w)
WRITE8_MEMBER(multigam_state::multigm3_switch_gfx_rom) WRITE8_MEMBER(multigam_state::multigm3_switch_gfx_rom)
{ {
set_videorom_bank(machine(), 0, 8, data & 0x3f, 8); set_videorom_bank(0, 8, data & 0x3f, 8);
set_mirroring(data & 0x40 ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT); set_mirroring(data & 0x40 ? PPU_MIRROR_HORZ : PPU_MIRROR_VERT);
m_game_gfx_bank = data; m_game_gfx_bank = data;
}; };
@ -611,7 +616,7 @@ WRITE8_MEMBER(multigam_state::multigm3_switch_prg_rom)
if (data == 0xa8) if (data == 0xa8)
{ {
multigam_init_mmc3(machine(), src + 0xa0000, 0x40000, 0x180); multigam_init_mmc3(src + 0xa0000, 0x40000, 0x180);
return; return;
} }
else else
@ -674,16 +679,15 @@ WRITE8_MEMBER(multigam_state::multigam3_mapper02_rom_switch_w)
memcpy(mem + 0x8000, m_mapper02_prg_base + 0x4000*(data & bankmask), 0x4000); memcpy(mem + 0x8000, m_mapper02_prg_base + 0x4000*(data & bankmask), 0x4000);
} }
static void multigam_init_mapper02(running_machine &machine, UINT8* prg_base, int prg_size) void multigam_state::multigam_init_mapper02(UINT8* prg_base, int prg_size)
{ {
multigam_state *state = machine.driver_data<multigam_state>(); ppu2c0x_device *ppu = machine().device<ppu2c0x_device>("ppu");
ppu2c0x_device *ppu = machine.device<ppu2c0x_device>("ppu"); UINT8* mem = memregion("maincpu")->base();
UINT8* mem = state->memregion("maincpu")->base();
memcpy(mem + 0x8000, prg_base + prg_size - 0x8000, 0x8000); memcpy(mem + 0x8000, prg_base + prg_size - 0x8000, 0x8000);
machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x8000, 0xffff, write8_delegate(FUNC(multigam_state::multigam3_mapper02_rom_switch_w),state)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x8000, 0xffff, write8_delegate(FUNC(multigam_state::multigam3_mapper02_rom_switch_w),this));
state->m_mapper02_prg_base = prg_base; m_mapper02_prg_base = prg_base;
state->m_mapper02_prg_size = prg_size; m_mapper02_prg_size = prg_size;
ppu->set_scanline_callback(0); ppu->set_scanline_callback(0);
} }
@ -779,18 +783,18 @@ WRITE8_MEMBER(multigam_state::mmc1_rom_switch_w)
case 1: /* video rom banking - bank 0 - 4k or 8k */ case 1: /* video rom banking - bank 0 - 4k or 8k */
if (m_mmc1_chr_bank_base == 0) if (m_mmc1_chr_bank_base == 0)
set_videoram_bank(machine(), 0, (m_vrom4k) ? 4 : 8, (m_mmc1_shiftreg & 0x1f), 4); set_videoram_bank(0, (m_vrom4k) ? 4 : 8, (m_mmc1_shiftreg & 0x1f), 4);
else else
set_videorom_bank(machine(), 0, (m_vrom4k) ? 4 : 8, m_mmc1_chr_bank_base + (m_mmc1_shiftreg & 0x1f), 4); set_videorom_bank(0, (m_vrom4k) ? 4 : 8, m_mmc1_chr_bank_base + (m_mmc1_shiftreg & 0x1f), 4);
break; break;
case 2: /* video rom banking - bank 1 - 4k only */ case 2: /* video rom banking - bank 1 - 4k only */
if (m_vrom4k) if (m_vrom4k)
{ {
if (m_mmc1_chr_bank_base == 0) if (m_mmc1_chr_bank_base == 0)
set_videoram_bank(machine(), 0, (m_vrom4k) ? 4 : 8, (m_mmc1_shiftreg & 0x1f), 4); set_videoram_bank(0, (m_vrom4k) ? 4 : 8, (m_mmc1_shiftreg & 0x1f), 4);
else else
set_videorom_bank(machine(), 4, 4, m_mmc1_chr_bank_base + (m_mmc1_shiftreg & 0x1f), 4); set_videorom_bank(4, 4, m_mmc1_chr_bank_base + (m_mmc1_shiftreg & 0x1f), 4);
} }
break; break;
@ -827,21 +831,20 @@ WRITE8_MEMBER(multigam_state::mmc1_rom_switch_w)
} }
} }
static void multigam_init_mmc1(running_machine &machine, UINT8 *prg_base, int prg_size, int chr_bank_base) void multigam_state::multigam_init_mmc1(UINT8 *prg_base, int prg_size, int chr_bank_base)
{ {
multigam_state *state = machine.driver_data<multigam_state>(); UINT8* dst = memregion("maincpu")->base();
UINT8* dst = state->memregion("maincpu")->base(); ppu2c0x_device *ppu = machine().device<ppu2c0x_device>("ppu");
ppu2c0x_device *ppu = machine.device<ppu2c0x_device>("ppu");
memcpy(&dst[0x8000], prg_base + (prg_size - 0x8000), 0x8000); memcpy(&dst[0x8000], prg_base + (prg_size - 0x8000), 0x8000);
machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x8000, 0xffff, write8_delegate(FUNC(multigam_state::mmc1_rom_switch_w),state)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x8000, 0xffff, write8_delegate(FUNC(multigam_state::mmc1_rom_switch_w),this));
state->m_mmc1_reg_write_enable = 1; m_mmc1_reg_write_enable = 1;
state->m_mmc1_rom_mask = (prg_size / 0x4000) - 1; m_mmc1_rom_mask = (prg_size / 0x4000) - 1;
state->m_mmc1_prg_base = prg_base; m_mmc1_prg_base = prg_base;
state->m_mmc1_prg_size = prg_size; m_mmc1_prg_size = prg_size;
state->m_mmc1_chr_bank_base = chr_bank_base; m_mmc1_chr_bank_base = chr_bank_base;
ppu->set_scanline_callback(0); ppu->set_scanline_callback(0);
}; };
@ -869,23 +872,22 @@ static void multigam_init_mmc1(running_machine &machine, UINT8 *prg_base, int pr
*/ */
static void supergm3_set_bank(running_machine &machine) void multigam_state::supergm3_set_bank()
{ {
multigam_state *state = machine.driver_data<multigam_state>(); ppu2c0x_device *ppu = machine().device<ppu2c0x_device>("ppu");
ppu2c0x_device *ppu = machine.device<ppu2c0x_device>("ppu"); UINT8* mem = memregion("maincpu")->base();
UINT8* mem = state->memregion("maincpu")->base();
// video bank // video bank
if (state->m_supergm3_chr_bank == 0x10 || if (m_supergm3_chr_bank == 0x10 ||
state->m_supergm3_chr_bank == 0x40 ) m_supergm3_chr_bank == 0x40 )
{ {
// VRAM // VRAM
ppu->space(AS_PROGRAM).install_read_bank(0x0000, 0x1fff, "bank1"); ppu->space(AS_PROGRAM).install_read_bank(0x0000, 0x1fff, "bank1");
ppu->space(AS_PROGRAM).install_write_bank(0x0000, 0x1fff, "bank1"); ppu->space(AS_PROGRAM).install_write_bank(0x0000, 0x1fff, "bank1");
state->membank("bank1")->set_base(state->m_vram); membank("bank1")->set_base(m_vram);
if (state->m_supergm3_chr_bank == 0x40) if (m_supergm3_chr_bank == 0x40)
state->set_mirroring(PPU_MIRROR_VERT); set_mirroring(PPU_MIRROR_VERT);
} }
else else
{ {
@ -899,39 +901,36 @@ static void supergm3_set_bank(running_machine &machine)
ppu->space(AS_PROGRAM).install_read_bank(0x1c00, 0x1fff, "bank9"); ppu->space(AS_PROGRAM).install_read_bank(0x1c00, 0x1fff, "bank9");
ppu->space(AS_PROGRAM).unmap_write(0x0000, 0x1fff); ppu->space(AS_PROGRAM).unmap_write(0x0000, 0x1fff);
set_videorom_bank(machine, 0, 8, 0, 8); set_videorom_bank(0, 8, 0, 8);
} }
// prg bank // prg bank
if ((state->m_supergm3_prg_bank & 0x80) == 0) if ((m_supergm3_prg_bank & 0x80) == 0)
{ {
// title screen // title screen
memcpy(mem + 0x8000, mem + 0x18000, 0x8000); memcpy(mem + 0x8000, mem + 0x18000, 0x8000);
state->membank("bank10")->set_base(mem + 0x6000); membank("bank10")->set_base(mem + 0x6000);
ppu->set_scanline_callback(0); ppu->set_scanline_callback(0);
} }
else if ((state->m_supergm3_prg_bank & 0x40) == 0) else if ((m_supergm3_prg_bank & 0x40) == 0)
{ {
// mapper 02 // mapper 02
multigam_init_mapper02(machine, multigam_init_mapper02(memregion("user1")->base() + (m_supergm3_prg_bank & 0x1f)*0x20000,
machine.root_device().memregion("user1")->base() + (state->m_supergm3_prg_bank & 0x1f)*0x20000,
0x20000); 0x20000);
} }
else if (state->m_supergm3_chr_bank & 0x10) else if (m_supergm3_chr_bank & 0x10)
{ {
// MMC3 // MMC3
multigam_init_mmc3(machine, multigam_init_mmc3(memregion("user1")->base() + (m_supergm3_prg_bank & 0x1f)*0x20000,
machine.root_device().memregion("user1")->base() + (state->m_supergm3_prg_bank & 0x1f)*0x20000, (m_supergm3_prg_bank & 0x20) ? 0x20000 : 0x40000,
(state->m_supergm3_prg_bank & 0x20) ? 0x20000 : 0x40000, (m_supergm3_chr_bank & 0x0f)*0x80);
(state->m_supergm3_chr_bank & 0x0f)*0x80);
} }
else else
{ {
//MMC1 //MMC1
multigam_init_mmc1(machine, multigam_init_mmc1(memregion("user1")->base() + (m_supergm3_prg_bank & 0x1f)*0x20000,
machine.root_device().memregion("user1")->base() + (state->m_supergm3_prg_bank & 0x1f)*0x20000,
0x20000, 0x20000,
(state->m_supergm3_chr_bank & 0x0f)*0x80/4 ); (m_supergm3_chr_bank & 0x0f)*0x80/4 );
} }
} }
@ -943,7 +942,7 @@ WRITE8_MEMBER(multigam_state::supergm3_prg_bank_w)
WRITE8_MEMBER(multigam_state::supergm3_chr_bank_w) WRITE8_MEMBER(multigam_state::supergm3_chr_bank_w)
{ {
m_supergm3_chr_bank = data; m_supergm3_chr_bank = data;
supergm3_set_bank(machine()); supergm3_set_bank();
} }
/****************************************************** /******************************************************
@ -1176,7 +1175,7 @@ MACHINE_START_MEMBER(multigam_state,multigm3)
machine().device("ppu")->memory().space(AS_PROGRAM).install_read_bank(0x1800, 0x1bff, "bank8"); machine().device("ppu")->memory().space(AS_PROGRAM).install_read_bank(0x1800, 0x1bff, "bank8");
machine().device("ppu")->memory().space(AS_PROGRAM).install_read_bank(0x1c00, 0x1fff, "bank9"); machine().device("ppu")->memory().space(AS_PROGRAM).install_read_bank(0x1c00, 0x1fff, "bank9");
set_videorom_bank(machine(), 0, 8, 0, 8); set_videorom_bank(0, 8, 0, 8);
}; };
MACHINE_START_MEMBER(multigam_state,supergm3) MACHINE_START_MEMBER(multigam_state,supergm3)
@ -1365,7 +1364,7 @@ DRIVER_INIT_MEMBER(multigam_state,multigam)
multigam_switch_prg_rom(space, 0x0, 0x01); multigam_switch_prg_rom(space, 0x0, 0x01);
} }
static void multigm3_decrypt(UINT8* mem, int memsize, const UINT8* decode_nibble) void multigam_state::multigm3_decrypt(UINT8* mem, int memsize, const UINT8* decode_nibble)
{ {
int i; int i;
for (i = 0; i < memsize; i++) for (i = 0; i < memsize; i++)

117
src/mame/drivers/namcos11.c
View File

@ -344,9 +344,13 @@ public:
TIMER_DEVICE_CALLBACK_MEMBER(mcu_irq0_cb); TIMER_DEVICE_CALLBACK_MEMBER(mcu_irq0_cb);
TIMER_DEVICE_CALLBACK_MEMBER(mcu_irq2_cb); TIMER_DEVICE_CALLBACK_MEMBER(mcu_irq2_cb);
TIMER_DEVICE_CALLBACK_MEMBER(mcu_adc_cb); TIMER_DEVICE_CALLBACK_MEMBER(mcu_adc_cb);
inline void ATTR_PRINTF(3,4) verboselog( int n_level, const char *s_fmt, ... );
inline void bankswitch_rom8( address_space &space, const char *bank, int n_data );
inline void bankswitch_rom64( address_space &space, const char *bank, int n_data );
void namcos11_init_common(int n_daughterboard);
}; };
INLINE void ATTR_PRINTF(3,4) verboselog( running_machine &machine, int n_level, const char *s_fmt, ... ) inline void ATTR_PRINTF(3,4) namcos11_state::verboselog( int n_level, const char *s_fmt, ... )
{ {
if( VERBOSE_LEVEL >= n_level ) if( VERBOSE_LEVEL >= n_level )
{ {
@ -355,13 +359,13 @@ INLINE void ATTR_PRINTF(3,4) verboselog( running_machine &machine, int n_level,
va_start( v, s_fmt ); va_start( v, s_fmt );
vsprintf( buf, s_fmt, v ); vsprintf( buf, s_fmt, v );
va_end( v ); va_end( v );
logerror( "%s: %s", machine.describe_context(), buf ); logerror( "%s: %s", machine().describe_context(), buf );
} }
} }
WRITE32_MEMBER(namcos11_state::keycus_w) WRITE32_MEMBER(namcos11_state::keycus_w)
{ {
verboselog( machine(), 1, "keycus_w( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(1, "keycus_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
COMBINE_DATA( &m_keycus[ offset ] ); COMBINE_DATA( &m_keycus[ offset ] );
} }
@ -383,7 +387,7 @@ READ32_MEMBER(namcos11_state::keycus_c406_r)
( ( namcos11_keycus[ 1 ] >> 8 ) & 0xf ); ( ( namcos11_keycus[ 1 ] >> 8 ) & 0xf );
break; break;
} }
verboselog( machine(), 1, "keycus_c406_r( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(1, "keycus_c406_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
return data; return data;
} }
@ -400,7 +404,7 @@ READ32_MEMBER(namcos11_state::keycus_c409_r)
data = ( data & 0x0000ffff ) | 0x000f0000; data = ( data & 0x0000ffff ) | 0x000f0000;
break; break;
} }
verboselog( machine(), 1, "keycus_c409_r( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(1, "keycus_c409_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
return data; return data;
} }
@ -435,7 +439,7 @@ READ32_MEMBER(namcos11_state::keycus_c410_r)
( ( ( n_value / 10000 ) % 10 ) << 16 ); ( ( ( n_value / 10000 ) % 10 ) << 16 );
break; break;
} }
verboselog( machine(), 1, "keycus_c410_r( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(1, "keycus_c410_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
return data; return data;
} }
@ -469,7 +473,7 @@ READ32_MEMBER(namcos11_state::keycus_c411_r)
break; break;
} }
verboselog( machine(), 1, "keycus_c411_r( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(1, "keycus_c411_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
return data; return data;
} }
@ -504,7 +508,7 @@ READ32_MEMBER(namcos11_state::keycus_c430_r)
( ( ( n_value / 1 ) % 10 ) << 16 ); ( ( ( n_value / 1 ) % 10 ) << 16 );
break; break;
} }
verboselog( machine(), 1, "keycus_c430_r( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(1, "keycus_c430_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
return data; return data;
} }
@ -537,7 +541,7 @@ READ32_MEMBER(namcos11_state::keycus_c431_r)
data = ( data & 0xffff0000 ) | ( ( n_value / 10000 ) % 10 ); data = ( data & 0xffff0000 ) | ( ( n_value / 10000 ) % 10 );
break; break;
} }
verboselog( machine(), 1, "keycus_c431_r( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(1, "keycus_c431_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
return data; return data;
} }
@ -571,7 +575,7 @@ READ32_MEMBER(namcos11_state::keycus_c432_r)
break; break;
} }
verboselog( machine(), 1, "keycus_c432_r( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(1, "keycus_c432_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
return data; return data;
} }
@ -592,7 +596,7 @@ READ32_MEMBER(namcos11_state::keycus_c442_r)
} }
break; break;
} }
verboselog( machine(), 1, "keycus_c442_r( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(1, "keycus_c442_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
return data; return data;
} }
@ -625,20 +629,20 @@ READ32_MEMBER(namcos11_state::keycus_c443_r)
} }
break; break;
} }
verboselog( machine(), 1, "keycus_c443_r( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(1, "keycus_c443_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
return data; return data;
} }
INLINE void bankswitch_rom8( address_space &space, const char *bank, int n_data ) inline void namcos11_state::bankswitch_rom8( address_space &space, const char *bank, int n_data )
{ {
space.machine().root_device().membank( bank )->set_entry( ( ( n_data & 0xc0 ) >> 4 ) + ( n_data & 0x03 ) ); membank( bank )->set_entry( ( ( n_data & 0xc0 ) >> 4 ) + ( n_data & 0x03 ) );
} }
static const char * const bankname[] = { "bank1", "bank2", "bank3", "bank4", "bank5", "bank6", "bank7", "bank8" }; static const char * const bankname[] = { "bank1", "bank2", "bank3", "bank4", "bank5", "bank6", "bank7", "bank8" };
WRITE32_MEMBER(namcos11_state::bankswitch_rom32_w) WRITE32_MEMBER(namcos11_state::bankswitch_rom32_w)
{ {
verboselog( machine(), 2, "bankswitch_rom32_w( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(2, "bankswitch_rom32_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
if( ACCESSING_BITS_0_15 ) if( ACCESSING_BITS_0_15 )
{ {
@ -652,7 +656,7 @@ WRITE32_MEMBER(namcos11_state::bankswitch_rom32_w)
WRITE32_MEMBER(namcos11_state::bankswitch_rom64_upper_w) WRITE32_MEMBER(namcos11_state::bankswitch_rom64_upper_w)
{ {
verboselog( machine(), 2, "bankswitch_rom64_upper_w( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(2, "bankswitch_rom64_upper_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
if( ACCESSING_BITS_0_15 ) if( ACCESSING_BITS_0_15 )
{ {
@ -664,17 +668,15 @@ WRITE32_MEMBER(namcos11_state::bankswitch_rom64_upper_w)
} }
} }
INLINE void bankswitch_rom64( address_space &space, const char *bank, int n_data ) inline void namcos11_state::bankswitch_rom64( address_space &space, const char *bank, int n_data )
{ {
namcos11_state *state = space.machine().driver_data<namcos11_state>();
/* todo: verify behaviour */ /* todo: verify behaviour */
state->membank( bank )->set_entry( ( ( ( ( n_data & 0xc0 ) >> 3 ) + ( n_data & 0x07 ) ) ^ state->m_n_bankoffset ) ); membank( bank )->set_entry( ( ( ( ( n_data & 0xc0 ) >> 3 ) + ( n_data & 0x07 ) ) ^ m_n_bankoffset ) );
} }
WRITE32_MEMBER(namcos11_state::bankswitch_rom64_w) WRITE32_MEMBER(namcos11_state::bankswitch_rom64_w)
{ {
verboselog( machine(), 2, "bankswitch_rom64_w( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(2, "bankswitch_rom64_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
if( ACCESSING_BITS_0_15 ) if( ACCESSING_BITS_0_15 )
{ {
@ -695,11 +697,11 @@ WRITE32_MEMBER(namcos11_state::lightgun_w)
output_set_value( "recoil0", !( data & 0x02 ) ); output_set_value( "recoil0", !( data & 0x02 ) );
output_set_value( "recoil1", !( data & 0x01 ) ); output_set_value( "recoil1", !( data & 0x01 ) );
verboselog( machine(), 1, "lightgun_w: outputs (%08x %08x)\n", data, mem_mask ); verboselog(1, "lightgun_w: outputs (%08x %08x)\n", data, mem_mask );
} }
if( ACCESSING_BITS_16_31 ) if( ACCESSING_BITS_16_31 )
{ {
verboselog( machine(), 2, "lightgun_w: start reading (%08x %08x)\n", data, mem_mask ); verboselog(2, "lightgun_w: start reading (%08x %08x)\n", data, mem_mask );
} }
} }
@ -721,7 +723,7 @@ READ32_MEMBER(namcos11_state::lightgun_r)
data = ( ioport( "GUN2Y" )->read() ) | ( ( ioport( "GUN2Y" )->read() + 1 ) << 16 ); data = ( ioport( "GUN2Y" )->read() ) | ( ( ioport( "GUN2Y" )->read() + 1 ) << 16 );
break; break;
} }
verboselog( machine(), 2, "lightgun_r( %08x, %08x ) %08x\n", offset, mem_mask, data ); verboselog(2, "lightgun_r( %08x, %08x ) %08x\n", offset, mem_mask, data );
return data; return data;
} }
@ -867,96 +869,95 @@ WRITE16_MEMBER(namcos11_state::c76_speedup_w)
COMBINE_DATA(&m_su_83); COMBINE_DATA(&m_su_83);
} }
static void namcos11_init_common(running_machine &machine, int n_daughterboard) void namcos11_state::namcos11_init_common(int n_daughterboard)
{ {
namcos11_state *state = machine.driver_data<namcos11_state>();
// C76 idle skipping, large speedboost // C76 idle skipping, large speedboost
if (C76_SPEEDUP) if (C76_SPEEDUP)
{ {
state->save_item( NAME(state->m_su_83) ); save_item( NAME(m_su_83) );
machine.device("c76")->memory().space(AS_PROGRAM).install_readwrite_handler(0x82, 0x83, read16_delegate(FUNC(namcos11_state::c76_speedup_r),state), write16_delegate(FUNC(namcos11_state::c76_speedup_w),state)); machine().device("c76")->memory().space(AS_PROGRAM).install_readwrite_handler(0x82, 0x83, read16_delegate(FUNC(namcos11_state::c76_speedup_r),this), write16_delegate(FUNC(namcos11_state::c76_speedup_w),this));
} }
if (!n_daughterboard) if (!n_daughterboard)
{ {
machine.device("maincpu")->memory().space(AS_PROGRAM).nop_write(0x1fa10020, 0x1fa1002f); machine().device("maincpu")->memory().space(AS_PROGRAM).nop_write(0x1fa10020, 0x1fa1002f);
return; return;
} }
// init banks // init banks
int bank; int bank;
UINT32 len = machine.root_device().memregion( "user2" )->bytes(); UINT32 len = memregion( "user2" )->bytes();
UINT8 *rgn = machine.root_device().memregion( "user2" )->base(); UINT8 *rgn = memregion( "user2" )->base();
machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x1f000000, 0x1f0fffff, "bank1" ); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x1f000000, 0x1f0fffff, "bank1" );
machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x1f100000, 0x1f1fffff, "bank2" ); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x1f100000, 0x1f1fffff, "bank2" );
machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x1f200000, 0x1f2fffff, "bank3" ); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x1f200000, 0x1f2fffff, "bank3" );
machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x1f300000, 0x1f3fffff, "bank4" ); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x1f300000, 0x1f3fffff, "bank4" );
machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x1f400000, 0x1f4fffff, "bank5" ); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x1f400000, 0x1f4fffff, "bank5" );
machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x1f500000, 0x1f5fffff, "bank6" ); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x1f500000, 0x1f5fffff, "bank6" );
machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x1f600000, 0x1f6fffff, "bank7" ); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x1f600000, 0x1f6fffff, "bank7" );
machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x1f700000, 0x1f7fffff, "bank8" ); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x1f700000, 0x1f7fffff, "bank8" );
for (bank = 0; bank < 8; bank++) for (bank = 0; bank < 8; bank++)
{ {
state->membank(bankname[bank])->configure_entries(0, len / ( 1024 * 1024 ), rgn, 1024 * 1024 ); membank(bankname[bank])->configure_entries(0, len / ( 1024 * 1024 ), rgn, 1024 * 1024 );
state->membank(bankname[bank])->set_entry(0 ); membank(bankname[bank])->set_entry(0 );
} }
if (n_daughterboard == 32) if (n_daughterboard == 32)
{ {
machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x1fa10020, 0x1fa1002f, write32_delegate(FUNC(namcos11_state::bankswitch_rom32_w),state)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x1fa10020, 0x1fa1002f, write32_delegate(FUNC(namcos11_state::bankswitch_rom32_w),this));
} }
if (n_daughterboard == 64) if (n_daughterboard == 64)
{ {
state->m_n_bankoffset = 0; m_n_bankoffset = 0;
machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x1f080000, 0x1f080003, write32_delegate(FUNC(namcos11_state::bankswitch_rom64_upper_w),state)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x1f080000, 0x1f080003, write32_delegate(FUNC(namcos11_state::bankswitch_rom64_upper_w),this));
machine.device("maincpu")->memory().space(AS_PROGRAM).nop_read(0x1fa10020, 0x1fa1002f); machine().device("maincpu")->memory().space(AS_PROGRAM).nop_read(0x1fa10020, 0x1fa1002f);
machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x1fa10020, 0x1fa1002f, write32_delegate(FUNC(namcos11_state::bankswitch_rom64_w),state)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x1fa10020, 0x1fa1002f, write32_delegate(FUNC(namcos11_state::bankswitch_rom64_w),this));
state->save_item( NAME(state->m_n_bankoffset) ); save_item( NAME(m_n_bankoffset) );
} }
} }
DRIVER_INIT_MEMBER(namcos11_state,tekken) DRIVER_INIT_MEMBER(namcos11_state,tekken)
{ {
namcos11_init_common(machine(), 32); namcos11_init_common(32);
} }
DRIVER_INIT_MEMBER(namcos11_state,tekken2) DRIVER_INIT_MEMBER(namcos11_state,tekken2)
{ {
machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c406_r),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c406_r),this));
namcos11_init_common(machine(), 32); namcos11_init_common(32);
} }
DRIVER_INIT_MEMBER(namcos11_state,souledge) DRIVER_INIT_MEMBER(namcos11_state,souledge)
{ {
machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c409_r),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c409_r),this));
namcos11_init_common(machine(), 32); namcos11_init_common(32);
} }
DRIVER_INIT_MEMBER(namcos11_state,dunkmnia) DRIVER_INIT_MEMBER(namcos11_state,dunkmnia)
{ {
machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c410_r),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c410_r),this));
namcos11_init_common(machine(), 32); namcos11_init_common(32);
} }
DRIVER_INIT_MEMBER(namcos11_state,primglex) DRIVER_INIT_MEMBER(namcos11_state,primglex)
{ {
machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c411_r),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c411_r),this));
namcos11_init_common(machine(), 32); namcos11_init_common(32);
} }
DRIVER_INIT_MEMBER(namcos11_state,xevi3dg) DRIVER_INIT_MEMBER(namcos11_state,xevi3dg)
{ {
machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c430_r),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c430_r),this));
namcos11_init_common(machine(), 32); namcos11_init_common(32);
} }
DRIVER_INIT_MEMBER(namcos11_state,danceyes) DRIVER_INIT_MEMBER(namcos11_state,danceyes)
{ {
machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c431_r),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c431_r),this));
namcos11_init_common(machine(), 32); namcos11_init_common(32);
} }
DRIVER_INIT_MEMBER(namcos11_state,pocketrc) DRIVER_INIT_MEMBER(namcos11_state,pocketrc)
@ -965,25 +966,25 @@ DRIVER_INIT_MEMBER(namcos11_state,pocketrc)
machine().device("c76")->memory().space(AS_IO).install_read_handler(M37710_ADC1_L, M37710_ADC1_L, read8_delegate(FUNC(namcos11_state::pocketrc_gas_r),this)); machine().device("c76")->memory().space(AS_IO).install_read_handler(M37710_ADC1_L, M37710_ADC1_L, read8_delegate(FUNC(namcos11_state::pocketrc_gas_r),this));
machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c432_r),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c432_r),this));
namcos11_init_common(machine(), 32); namcos11_init_common(32);
} }
DRIVER_INIT_MEMBER(namcos11_state,starswep) DRIVER_INIT_MEMBER(namcos11_state,starswep)
{ {
machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c442_r),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c442_r),this));
namcos11_init_common(machine(), 0); namcos11_init_common(0);
} }
DRIVER_INIT_MEMBER(namcos11_state,myangel3) DRIVER_INIT_MEMBER(namcos11_state,myangel3)
{ {
machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c443_r),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c443_r),this));
namcos11_init_common(machine(), 64); namcos11_init_common(64);
} }
DRIVER_INIT_MEMBER(namcos11_state,ptblank2ua) DRIVER_INIT_MEMBER(namcos11_state,ptblank2ua)
{ {
machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c443_r),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c443_r),this));
namcos11_init_common(machine(), 64); namcos11_init_common(64);
machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x1f788000, 0x1f788003, write32_delegate(FUNC(namcos11_state::lightgun_w),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x1f788000, 0x1f788003, write32_delegate(FUNC(namcos11_state::lightgun_w),this));
machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler (0x1f780000, 0x1f78000f, read32_delegate(FUNC(namcos11_state::lightgun_r),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler (0x1f780000, 0x1f78000f, read32_delegate(FUNC(namcos11_state::lightgun_r),this));

69
src/mame/drivers/namcos12.c
View File

@ -1096,9 +1096,13 @@ public:
DECLARE_DRIVER_INIT(ghlpanic); DECLARE_DRIVER_INIT(ghlpanic);
DECLARE_DRIVER_INIT(ptblank2); DECLARE_DRIVER_INIT(ptblank2);
DECLARE_MACHINE_RESET(namcos12); DECLARE_MACHINE_RESET(namcos12);
inline void ATTR_PRINTF(3,4) verboselog( int n_level, const char *s_fmt, ... );
void namcos12_rom_read( UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size );
void namcos12_sub_irq( screen_device &screen, bool vblank_state );
void system11gun_install( );
}; };
INLINE void ATTR_PRINTF(3,4) verboselog( running_machine &machine, int n_level, const char *s_fmt, ... ) inline void ATTR_PRINTF(3,4) namcos12_state::verboselog( int n_level, const char *s_fmt, ... )
{ {
if( VERBOSE_LEVEL >= n_level ) if( VERBOSE_LEVEL >= n_level )
{ {
@ -1107,19 +1111,19 @@ INLINE void ATTR_PRINTF(3,4) verboselog( running_machine &machine, int n_level,
va_start( v, s_fmt ); va_start( v, s_fmt );
vsprintf( buf, s_fmt, v ); vsprintf( buf, s_fmt, v );
va_end( v ); va_end( v );
logerror( "%s: %s", machine.describe_context(), buf ); logerror( "%s: %s", machine().describe_context(), buf );
} }
} }
WRITE32_MEMBER(namcos12_state::sharedram_w) WRITE32_MEMBER(namcos12_state::sharedram_w)
{ {
verboselog( machine(), 1, "sharedram_w( %08x, %08x, %08x )\n", ( offset * 4 ), data, mem_mask ); verboselog(1, "sharedram_w( %08x, %08x, %08x )\n", ( offset * 4 ), data, mem_mask );
COMBINE_DATA( &m_sharedram[ offset ] ); COMBINE_DATA( &m_sharedram[ offset ] );
} }
READ32_MEMBER(namcos12_state::sharedram_r) READ32_MEMBER(namcos12_state::sharedram_r)
{ {
verboselog( machine(), 1, "sharedram_r( %08x, %08x ) %08x\n", ( offset * 4 ), mem_mask, m_sharedram[ offset ] ); verboselog(1, "sharedram_r( %08x, %08x ) %08x\n", ( offset * 4 ), mem_mask, m_sharedram[ offset ] );
return m_sharedram[ offset ]; return m_sharedram[ offset ];
} }
@ -1159,7 +1163,7 @@ WRITE32_MEMBER(namcos12_state::bankoffset_w)
membank( "bank1" )->set_entry( m_n_bankoffset ); membank( "bank1" )->set_entry( m_n_bankoffset );
verboselog( machine(), 1, "bankoffset_w( %08x, %08x, %08x ) %08x\n", offset, data, mem_mask, m_n_bankoffset ); verboselog(1, "bankoffset_w( %08x, %08x, %08x ) %08x\n", offset, data, mem_mask, m_n_bankoffset );
} }
WRITE32_MEMBER(namcos12_state::dmaoffset_w) WRITE32_MEMBER(namcos12_state::dmaoffset_w)
@ -1172,10 +1176,10 @@ WRITE32_MEMBER(namcos12_state::dmaoffset_w)
{ {
m_n_dmaoffset = ( ( offset * 4 ) + 2 ) | ( data & 0xffff0000 ); m_n_dmaoffset = ( ( offset * 4 ) + 2 ) | ( data & 0xffff0000 );
} }
verboselog( machine(), 1, "dmaoffset_w( %08x, %08x, %08x ) %08x\n", offset, data, mem_mask, m_n_dmaoffset ); verboselog(1, "dmaoffset_w( %08x, %08x, %08x ) %08x\n", offset, data, mem_mask, m_n_dmaoffset );
} }
static void namcos12_rom_read( namcos12_state *state, UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size ) void namcos12_state::namcos12_rom_read( UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size )
{ {
const char *n_region; const char *n_region;
int n_offset; int n_offset;
@ -1187,32 +1191,32 @@ static void namcos12_rom_read( namcos12_state *state, UINT32 *p_n_psxram, UINT32
INT32 n_ramleft; INT32 n_ramleft;
// TODO: the check for going past the end of ram should be in dma.c // TODO: the check for going past the end of ram should be in dma.c
UINT32 m_n_psxramsize = state->memshare("share1")->bytes(); UINT32 m_n_psxramsize = memshare("share1")->bytes();
if(state->m_has_tektagt_dma && !state->m_n_dmaoffset) if(m_has_tektagt_dma && !m_n_dmaoffset)
{ {
n_region = "user2"; n_region = "user2";
n_offset = state->m_n_tektagdmaoffset & 0x7fffffff; n_offset = m_n_tektagdmaoffset & 0x7fffffff;
verboselog( state->machine(), 1, "namcos12_rom_read( %08x, %08x ) tektagt %08x\n", n_address, n_size, n_offset ); verboselog(1, "namcos12_rom_read( %08x, %08x ) tektagt %08x\n", n_address, n_size, n_offset );
} }
else if( ( state->m_n_dmaoffset >= 0x80000000 ) || ( state->m_n_dmabias == 0x1f300000 ) ) else if( ( m_n_dmaoffset >= 0x80000000 ) || ( m_n_dmabias == 0x1f300000 ) )
{ {
n_region = "user1"; n_region = "user1";
n_offset = state->m_n_dmaoffset & 0x003fffff; n_offset = m_n_dmaoffset & 0x003fffff;
verboselog( state->machine(), 1, "namcos12_rom_read( %08x, %08x ) boot %08x\n", n_address, n_size, n_offset ); verboselog(1, "namcos12_rom_read( %08x, %08x ) boot %08x\n", n_address, n_size, n_offset );
} }
else else
{ {
n_region = "user2"; n_region = "user2";
n_offset = state->m_n_dmaoffset & 0x7fffffff; n_offset = m_n_dmaoffset & 0x7fffffff;
verboselog( state->machine(), 1, "namcos12_rom_read( %08x, %08x ) game %08x\n", n_address, n_size, n_offset ); verboselog(1, "namcos12_rom_read( %08x, %08x ) game %08x\n", n_address, n_size, n_offset );
} }
source = (UINT16 *) state->memregion( n_region )->base(); source = (UINT16 *) memregion( n_region )->base();
n_romleft = ( state->memregion( n_region )->bytes() - n_offset ) / 4; n_romleft = ( memregion( n_region )->bytes() - n_offset ) / 4;
if( n_size > n_romleft ) if( n_size > n_romleft )
{ {
verboselog( state->machine(), 1, "namcos12_rom_read dma truncated %d to %d passed end of rom\n", n_size, n_romleft ); verboselog(1, "namcos12_rom_read dma truncated %d to %d passed end of rom\n", n_size, n_romleft );
n_size = n_romleft; n_size = n_romleft;
} }
@ -1221,7 +1225,7 @@ static void namcos12_rom_read( namcos12_state *state, UINT32 *p_n_psxram, UINT32
n_ramleft = ( m_n_psxramsize - n_address ) / 4; n_ramleft = ( m_n_psxramsize - n_address ) / 4;
if( n_size > n_ramleft ) if( n_size > n_ramleft )
{ {
verboselog( state->machine(), 1, "namcos12_rom_read dma truncated %d to %d passed end of ram\n", n_size, n_ramleft ); verboselog(1, "namcos12_rom_read dma truncated %d to %d passed end of ram\n", n_size, n_ramleft );
n_size = n_ramleft; n_size = n_ramleft;
} }
@ -1238,9 +1242,9 @@ static void namcos12_rom_read( namcos12_state *state, UINT32 *p_n_psxram, UINT32
} }
} }
static void namcos12_sub_irq( namcos12_state *state, screen_device &screen, bool vblank_state ) void namcos12_state::namcos12_sub_irq( screen_device &screen, bool vblank_state )
{ {
irq1_line_pulse( state->machine().device( "sub" ) ); irq1_line_pulse( *machine().device( "sub" ) );
} }
WRITE32_MEMBER(namcos12_state::s12_dma_bias_w) WRITE32_MEMBER(namcos12_state::s12_dma_bias_w)
@ -1279,11 +1283,11 @@ WRITE32_MEMBER(namcos12_state::system11gun_w)
output_set_value("P2_Start_lamp", (~data & 0x04)>>2); output_set_value("P2_Start_lamp", (~data & 0x04)>>2);
verboselog( machine(), 1, "system11gun_w: outputs (%08x %08x)\n", data, mem_mask ); verboselog(1, "system11gun_w: outputs (%08x %08x)\n", data, mem_mask );
} }
if( ACCESSING_BITS_16_31 ) if( ACCESSING_BITS_16_31 )
{ {
verboselog( machine(), 2, "system11gun_w: start reading (%08x %08x)\n", data, mem_mask ); verboselog(2, "system11gun_w: start reading (%08x %08x)\n", data, mem_mask );
} }
} }
@ -1305,15 +1309,14 @@ READ32_MEMBER(namcos12_state::system11gun_r)
data = ( ioport("LIGHT1_Y")->read() ) | ( ( ioport("LIGHT1_Y")->read() + 1 ) << 16 ); data = ( ioport("LIGHT1_Y")->read() ) | ( ( ioport("LIGHT1_Y")->read() + 1 ) << 16 );
break; break;
} }
verboselog( machine(), 2, "system11gun_r( %08x, %08x ) %08x\n", offset, mem_mask, data ); verboselog(2, "system11gun_r( %08x, %08x ) %08x\n", offset, mem_mask, data );
return data; return data;
} }
static void system11gun_install( running_machine &machine ) void namcos12_state::system11gun_install( )
{ {
namcos12_state *state = machine.driver_data<namcos12_state>(); machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x1f788000, 0x1f788003, write32_delegate(FUNC(namcos12_state::system11gun_w),this));
machine.device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0x1f788000, 0x1f788003, write32_delegate(FUNC(namcos12_state::system11gun_w),state)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler (0x1f780000, 0x1f78000f, read32_delegate(FUNC(namcos12_state::system11gun_r),this));
machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_handler (0x1f780000, 0x1f78000f, read32_delegate(FUNC(namcos12_state::system11gun_r),state));
} }
WRITE32_MEMBER(namcos12_state::kcoff_w) WRITE32_MEMBER(namcos12_state::kcoff_w)
@ -1606,14 +1609,14 @@ DRIVER_INIT_MEMBER(namcos12_state,ptblank2)
/* patch out wait for dma 5 to complete */ /* patch out wait for dma 5 to complete */
*( (UINT32 *)( memregion( "user1" )->base() + 0x331c4 ) ) = 0; *( (UINT32 *)( memregion( "user1" )->base() + 0x331c4 ) ) = 0;
system11gun_install(machine()); system11gun_install();
} }
DRIVER_INIT_MEMBER(namcos12_state,ghlpanic) DRIVER_INIT_MEMBER(namcos12_state,ghlpanic)
{ {
DRIVER_INIT_CALL(namcos12); DRIVER_INIT_CALL(namcos12);
system11gun_install(machine()); system11gun_install();
} }
static MACHINE_CONFIG_START( coh700, namcos12_state ) static MACHINE_CONFIG_START( coh700, namcos12_state )
@ -1621,7 +1624,7 @@ static MACHINE_CONFIG_START( coh700, namcos12_state )
MCFG_CPU_ADD( "maincpu", CXD8661R, XTAL_100MHz ) MCFG_CPU_ADD( "maincpu", CXD8661R, XTAL_100MHz )
MCFG_CPU_PROGRAM_MAP( namcos12_map) MCFG_CPU_PROGRAM_MAP( namcos12_map)
MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 5, psx_dma_read_delegate( FUNC( namcos12_rom_read ), (namcos12_state *) owner ) ) MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 5, psx_dma_read_delegate( FUNC( namcos12_state::namcos12_rom_read ), (namcos12_state *) owner ) )
MCFG_CPU_ADD("sub", H83002, 16737350 ) MCFG_CPU_ADD("sub", H83002, 16737350 )
MCFG_CPU_PROGRAM_MAP( s12h8rwmap) MCFG_CPU_PROGRAM_MAP( s12h8rwmap)
@ -1633,7 +1636,7 @@ static MACHINE_CONFIG_START( coh700, namcos12_state )
/* video hardware */ /* video hardware */
MCFG_PSXGPU_ADD( "maincpu", "gpu", CXD8654Q, 0x200000, XTAL_53_693175MHz ) MCFG_PSXGPU_ADD( "maincpu", "gpu", CXD8654Q, 0x200000, XTAL_53_693175MHz )
MCFG_PSXGPU_VBLANK_CALLBACK( vblank_state_delegate( FUNC( namcos12_sub_irq ), (namcos12_state *) owner ) ) MCFG_PSXGPU_VBLANK_CALLBACK( vblank_state_delegate( FUNC( namcos12_state::namcos12_sub_irq ), (namcos12_state *) owner ) )
/* sound hardware */ /* sound hardware */
MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker") MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")

173
src/mame/drivers/namcos23.c
View File

@ -1486,16 +1486,37 @@ public:
UINT32 screen_update_s23(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); UINT32 screen_update_s23(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
INTERRUPT_GEN_MEMBER(s23_interrupt); INTERRUPT_GEN_MEMBER(s23_interrupt);
TIMER_CALLBACK_MEMBER(c361_timer_cb); TIMER_CALLBACK_MEMBER(c361_timer_cb);
UINT8 nthbyte(const UINT32 *pSource, int offs);
UINT16 nthword(const UINT32 *pSource, int offs);
inline INT32 u32_to_s24(UINT32 v);
inline INT32 u32_to_s10(UINT32 v);
INT32 *p3d_getv(UINT16 id);
INT16 *p3d_getm(UINT16 id);
void p3d_matrix_set(const UINT16 *p, int size);
void p3d_vector_set(const UINT16 *p, int size);
void p3d_scaling_set(const UINT16 *p, int size);
void p3d_vector_matrix_mul(const UINT16 *p, int size);
void p3d_matrix_vector_mul(const UINT16 *p, int size);
void p3d_matrix_matrix_mul(const UINT16 *p, int size);
void p3d_render(const UINT16 *p, int size, bool use_scaling);
void p3d_flush(const UINT16 *p, int size);
void p3d_dma(address_space &space, UINT32 adr, UINT32 size);
void render_apply_transform(INT32 xi, INT32 yi, INT32 zi, const namcos23_render_entry *re, poly_vertex &pv);
void render_apply_matrot(INT32 xi, INT32 yi, INT32 zi, const namcos23_render_entry *re, INT32 &x, INT32 &y, INT32 &z);
void render_project(poly_vertex &pv);
void render_one_model(const namcos23_render_entry *re);
void render_flush(bitmap_rgb32 &bitmap);
void render_run(bitmap_rgb32 &bitmap);
}; };
static UINT8 nthbyte(const UINT32 *pSource, int offs) UINT8 namcos23_state::nthbyte(const UINT32 *pSource, int offs)
{ {
pSource += offs/4; pSource += offs/4;
return (pSource[0]<<((offs&3)*8))>>24; return (pSource[0]<<((offs&3)*8))>>24;
} }
static UINT16 nthword(const UINT32 *pSource, int offs) UINT16 namcos23_state::nthword(const UINT32 *pSource, int offs)
{ {
pSource += offs/2; pSource += offs/2;
return (pSource[0]<<((offs&1)*16))>>16; return (pSource[0]<<((offs&1)*16))>>16;
@ -1513,12 +1534,12 @@ static UINT16 nthword(const UINT32 *pSource, int offs)
// 3D hardware, to throw at least in part in video/namcos23.c // 3D hardware, to throw at least in part in video/namcos23.c
INLINE INT32 u32_to_s24(UINT32 v) inline INT32 namcos23_state::u32_to_s24(UINT32 v)
{ {
return v & 0x800000 ? v | 0xff000000 : v & 0xffffff; return v & 0x800000 ? v | 0xff000000 : v & 0xffffff;
} }
INLINE INT32 u32_to_s10(UINT32 v) inline INT32 namcos23_state::u32_to_s10(UINT32 v)
{ {
return v & 0x200 ? v | 0xfffffe00 : v & 0x1ff; return v & 0x200 ? v | 0xfffffe00 : v & 0x1ff;
} }
@ -1533,48 +1554,48 @@ INLINE UINT8 light(UINT8 c, float l)
return UINT8(l); return UINT8(l);
} }
static INT32 *p3d_getv(namcos23_state *state, UINT16 id) INT32 *namcos23_state::p3d_getv(UINT16 id)
{ {
if(id == 0x8000) if(id == 0x8000)
return state->m_light_vector; return m_light_vector;
if(id >= 0x100) if(id >= 0x100)
{ {
memset(state->m_spv, 0, sizeof(state->m_spv)); memset(m_spv, 0, sizeof(m_spv));
return state->m_spv; return m_spv;
} }
return state->m_vectors[id]; return m_vectors[id];
} }
static INT16 *p3d_getm(namcos23_state *state, UINT16 id) INT16 *namcos23_state::p3d_getm(UINT16 id)
{ {
if(id >= 0x100) if(id >= 0x100)
{ {
memset(state->m_spm, 0, sizeof(state->m_spm)); memset(m_spm, 0, sizeof(m_spm));
return state->m_spm; return m_spm;
} }
return state->m_matrices[id]; return m_matrices[id];
} }
static void p3d_matrix_set(namcos23_state *state, const UINT16 *p, int size) void namcos23_state::p3d_matrix_set(const UINT16 *p, int size)
{ {
if(size != 10) if(size != 10)
{ {
logerror("WARNING: p3d_matrix_set with size %d\n", size); logerror("WARNING: p3d_matrix_set with size %d\n", size);
return; return;
} }
INT16 *t = p3d_getm(state, *p++); INT16 *t = p3d_getm(*p++);
for(int i=0; i<9; i++) for(int i=0; i<9; i++)
t[i] = *p++; t[i] = *p++;
} }
static void p3d_vector_set(namcos23_state *state, const UINT16 *p, int size) void namcos23_state::p3d_vector_set(const UINT16 *p, int size)
{ {
if(size != 7) if(size != 7)
{ {
logerror("WARNING: p3d_vector_set with size %d\n", size); logerror("WARNING: p3d_vector_set with size %d\n", size);
return; return;
} }
INT32 *t = p3d_getv(state, *p++); INT32 *t = p3d_getv(*p++);
for(int i=0; i<3; i++) for(int i=0; i<3; i++)
{ {
t[i] = u32_to_s24((p[0] << 16) | p[1]); t[i] = u32_to_s24((p[0] << 16) | p[1]);
@ -1583,17 +1604,17 @@ static void p3d_vector_set(namcos23_state *state, const UINT16 *p, int size)
} }
static void p3d_scaling_set(namcos23_state *state, const UINT16 *p, int size) void namcos23_state::p3d_scaling_set(const UINT16 *p, int size)
{ {
if(size != 1) if(size != 1)
{ {
logerror("WARNING: p3d_scaling_set with size %d\n", size); logerror("WARNING: p3d_scaling_set with size %d\n", size);
return; return;
} }
state->m_scaling = *p; m_scaling = *p;
} }
static void p3d_vector_matrix_mul(namcos23_state *state, const UINT16 *p, int size) void namcos23_state::p3d_vector_matrix_mul(const UINT16 *p, int size)
{ {
if(size != 4) if(size != 4)
{ {
@ -1603,16 +1624,16 @@ static void p3d_vector_matrix_mul(namcos23_state *state, const UINT16 *p, int si
if(p[2] != 0xffff) if(p[2] != 0xffff)
logerror("WARNING: p3d_vector_matrix_mul with +2=%04x\n", p[2]); logerror("WARNING: p3d_vector_matrix_mul with +2=%04x\n", p[2]);
INT32 *t = p3d_getv(state, p[0]); INT32 *t = p3d_getv(p[0]);
const INT16 *m = p3d_getm(state, p[1]); const INT16 *m = p3d_getm(p[1]);
const INT32 *v = p3d_getv(state, p[3]); const INT32 *v = p3d_getv(p[3]);
t[0] = INT32((m[0]*INT64(v[0]) + m[3]*INT64(v[1]) + m[6]*INT64(v[2])) >> 14); t[0] = INT32((m[0]*INT64(v[0]) + m[3]*INT64(v[1]) + m[6]*INT64(v[2])) >> 14);
t[1] = INT32((m[1]*INT64(v[0]) + m[4]*INT64(v[1]) + m[7]*INT64(v[2])) >> 14); t[1] = INT32((m[1]*INT64(v[0]) + m[4]*INT64(v[1]) + m[7]*INT64(v[2])) >> 14);
t[2] = INT32((m[2]*INT64(v[0]) + m[5]*INT64(v[1]) + m[8]*INT64(v[2])) >> 14); t[2] = INT32((m[2]*INT64(v[0]) + m[5]*INT64(v[1]) + m[8]*INT64(v[2])) >> 14);
} }
static void p3d_matrix_vector_mul(namcos23_state *state, const UINT16 *p, int size) void namcos23_state::p3d_matrix_vector_mul(const UINT16 *p, int size)
{ {
if(size != 4) if(size != 4)
{ {
@ -1622,9 +1643,9 @@ static void p3d_matrix_vector_mul(namcos23_state *state, const UINT16 *p, int si
if(p[2] != 0xffff) if(p[2] != 0xffff)
logerror("WARNING: p3d_matrix_vector_mul with +2=%04x\n", p[2]); logerror("WARNING: p3d_matrix_vector_mul with +2=%04x\n", p[2]);
INT32 *t = p3d_getv(state, p[0]); INT32 *t = p3d_getv(p[0]);
const INT16 *m = p3d_getm(state, p[1]); const INT16 *m = p3d_getm(p[1]);
const INT32 *v = p3d_getv(state, p[3]); const INT32 *v = p3d_getv(p[3]);
t[0] = INT32((m[0]*INT64(v[0]) + m[1]*INT64(v[1]) + m[2]*INT64(v[2])) >> 14); t[0] = INT32((m[0]*INT64(v[0]) + m[1]*INT64(v[1]) + m[2]*INT64(v[2])) >> 14);
t[1] = INT32((m[3]*INT64(v[0]) + m[4]*INT64(v[1]) + m[7]*INT64(v[2])) >> 14); t[1] = INT32((m[3]*INT64(v[0]) + m[4]*INT64(v[1]) + m[7]*INT64(v[2])) >> 14);
@ -1632,7 +1653,7 @@ static void p3d_matrix_vector_mul(namcos23_state *state, const UINT16 *p, int si
} }
static void p3d_matrix_matrix_mul(namcos23_state *state, const UINT16 *p, int size) void namcos23_state::p3d_matrix_matrix_mul(const UINT16 *p, int size)
{ {
if(size != 4) if(size != 4)
{ {
@ -1642,9 +1663,9 @@ static void p3d_matrix_matrix_mul(namcos23_state *state, const UINT16 *p, int si
if(p[2] != 0xffff) if(p[2] != 0xffff)
logerror("WARNING: p3d_matrix_matrix_mul with +2=%04x\n", p[2]); logerror("WARNING: p3d_matrix_matrix_mul with +2=%04x\n", p[2]);
INT16 *t = p3d_getm(state, p[0]); INT16 *t = p3d_getm(p[0]);
const INT16 *m1 = p3d_getm(state, p[1]); const INT16 *m1 = p3d_getm(p[1]);
const INT16 *m2 = p3d_getm(state, p[3]); const INT16 *m2 = p3d_getm(p[3]);
t[0] = INT16((m1[0]*m2[0] + m1[1]*m2[3] + m1[2]*m2[6]) >> 14); t[0] = INT16((m1[0]*m2[0] + m1[1]*m2[3] + m1[2]*m2[6]) >> 14);
t[1] = INT16((m1[0]*m2[1] + m1[1]*m2[4] + m1[2]*m2[7]) >> 14); t[1] = INT16((m1[0]*m2[1] + m1[1]*m2[4] + m1[2]*m2[7]) >> 14);
@ -1658,9 +1679,9 @@ static void p3d_matrix_matrix_mul(namcos23_state *state, const UINT16 *p, int si
} }
static void p3d_render(namcos23_state *state, const UINT16 *p, int size, bool use_scaling) void namcos23_state::p3d_render(const UINT16 *p, int size, bool use_scaling)
{ {
render_t &render = state->m_render; render_t &render = m_render;
if(size != 3) if(size != 3)
{ {
@ -1677,13 +1698,13 @@ static void p3d_render(namcos23_state *state, const UINT16 *p, int size, bool us
} }
// Vector and matrix may be inverted // Vector and matrix may be inverted
const INT16 *m = p3d_getm(state, p[1]); const INT16 *m = p3d_getm(p[1]);
const INT32 *v = p3d_getv(state, p[2]); const INT32 *v = p3d_getv(p[2]);
namcos23_render_entry *re = render.entries[render.cur] + render.count[render.cur]; namcos23_render_entry *re = render.entries[render.cur] + render.count[render.cur];
re->type = MODEL; re->type = MODEL;
re->model.model = p[0]; re->model.model = p[0];
re->model.scaling = use_scaling ? state->m_scaling / 16384.0 : 1.0; re->model.scaling = use_scaling ? m_scaling / 16384.0 : 1.0;
memcpy(re->model.m, m, sizeof(re->model.m)); memcpy(re->model.m, m, sizeof(re->model.m));
memcpy(re->model.v, v, sizeof(re->model.v)); memcpy(re->model.v, v, sizeof(re->model.v));
if(0) if(0)
@ -1698,9 +1719,9 @@ static void p3d_render(namcos23_state *state, const UINT16 *p, int size, bool us
} }
static void p3d_flush(namcos23_state *state, const UINT16 *p, int size) void namcos23_state::p3d_flush(const UINT16 *p, int size)
{ {
render_t &render = state->m_render; render_t &render = m_render;
if(size != 0) if(size != 0)
{ {
@ -1713,9 +1734,8 @@ static void p3d_flush(namcos23_state *state, const UINT16 *p, int size)
render.count[render.cur]++; render.count[render.cur]++;
} }
static void p3d_dma(address_space &space, UINT32 adr, UINT32 size) void namcos23_state::p3d_dma(address_space &space, UINT32 adr, UINT32 size)
{ {
namcos23_state *state = space.machine().driver_data<namcos23_state>();
UINT16 buffer[256]; UINT16 buffer[256];
adr &= 0x1fffffff; adr &= 0x1fffffff;
int pos = 0; int pos = 0;
@ -1753,15 +1773,15 @@ static void p3d_dma(address_space &space, UINT32 adr, UINT32 size)
switch(h1) switch(h1)
{ {
case 0x0040: p3d_matrix_set(state, buffer, psize); break; case 0x0040: p3d_matrix_set(buffer, psize); break;
case 0x0050: p3d_vector_set(state, buffer, psize); break; case 0x0050: p3d_vector_set(buffer, psize); break;
case 0x0000: p3d_matrix_matrix_mul(state, buffer, psize); break; case 0x0000: p3d_matrix_matrix_mul(buffer, psize); break;
case 0x0810: p3d_matrix_vector_mul(state, buffer, psize); break; case 0x0810: p3d_matrix_vector_mul(buffer, psize); break;
case 0x1010: p3d_vector_matrix_mul(state, buffer, psize); break; case 0x1010: p3d_vector_matrix_mul(buffer, psize); break;
case 0x4400: p3d_scaling_set(state, buffer, psize); break; case 0x4400: p3d_scaling_set(buffer, psize); break;
case 0x8000: p3d_render(state, buffer, psize, false); break; case 0x8000: p3d_render(buffer, psize, false); break;
case 0x8080: p3d_render(state, buffer, psize, true); break; case 0x8080: p3d_render(buffer, psize, true); break;
case 0xc000: p3d_flush(state, buffer, psize); break; case 0xc000: p3d_flush(buffer, psize); break;
default: default:
if(0) if(0)
{ {
@ -1840,21 +1860,21 @@ static void render_scanline(void *dest, INT32 scanline, const poly_extent *exten
} }
} }
static void render_apply_transform(INT32 xi, INT32 yi, INT32 zi, const namcos23_render_entry *re, poly_vertex &pv) void namcos23_state::render_apply_transform(INT32 xi, INT32 yi, INT32 zi, const namcos23_render_entry *re, poly_vertex &pv)
{ {
pv.x = (INT32((re->model.m[0]*INT64(xi) + re->model.m[3]*INT64(yi) + re->model.m[6]*INT64(zi)) >> 14)*re->model.scaling + re->model.v[0])/16384.0; pv.x = (INT32((re->model.m[0]*INT64(xi) + re->model.m[3]*INT64(yi) + re->model.m[6]*INT64(zi)) >> 14)*re->model.scaling + re->model.v[0])/16384.0;
pv.y = (INT32((re->model.m[1]*INT64(xi) + re->model.m[4]*INT64(yi) + re->model.m[7]*INT64(zi)) >> 14)*re->model.scaling + re->model.v[1])/16384.0; pv.y = (INT32((re->model.m[1]*INT64(xi) + re->model.m[4]*INT64(yi) + re->model.m[7]*INT64(zi)) >> 14)*re->model.scaling + re->model.v[1])/16384.0;
pv.p[0] = (INT32((re->model.m[2]*INT64(xi) + re->model.m[5]*INT64(yi) + re->model.m[8]*INT64(zi)) >> 14)*re->model.scaling + re->model.v[2])/16384.0; pv.p[0] = (INT32((re->model.m[2]*INT64(xi) + re->model.m[5]*INT64(yi) + re->model.m[8]*INT64(zi)) >> 14)*re->model.scaling + re->model.v[2])/16384.0;
} }
static void render_apply_matrot(INT32 xi, INT32 yi, INT32 zi, const namcos23_render_entry *re, INT32 &x, INT32 &y, INT32 &z) void namcos23_state::render_apply_matrot(INT32 xi, INT32 yi, INT32 zi, const namcos23_render_entry *re, INT32 &x, INT32 &y, INT32 &z)
{ {
x = (re->model.m[0]*xi + re->model.m[3]*yi + re->model.m[6]*zi) >> 14; x = (re->model.m[0]*xi + re->model.m[3]*yi + re->model.m[6]*zi) >> 14;
y = (re->model.m[1]*xi + re->model.m[4]*yi + re->model.m[7]*zi) >> 14; y = (re->model.m[1]*xi + re->model.m[4]*yi + re->model.m[7]*zi) >> 14;
z = (re->model.m[2]*xi + re->model.m[5]*yi + re->model.m[8]*zi) >> 14; z = (re->model.m[2]*xi + re->model.m[5]*yi + re->model.m[8]*zi) >> 14;
} }
static void render_project(poly_vertex &pv) void namcos23_state::render_project(poly_vertex &pv)
{ {
// 768 validated by the title screen size on tc2: // 768 validated by the title screen size on tc2:
// texture is 640x480, x range is 3.125, y range is 2.34375, z is 3.75 // texture is 640x480, x range is 3.125, y range is 2.34375, z is 3.75
@ -1886,23 +1906,22 @@ static UINT32 render_texture_lookup_nocache_point(running_machine &machine, cons
return pens[color]; return pens[color];
} }
static void render_one_model(running_machine &machine, const namcos23_render_entry *re) void namcos23_state::render_one_model(const namcos23_render_entry *re)
{ {
namcos23_state *state = machine.driver_data<namcos23_state>(); render_t &render = m_render;
render_t &render = state->m_render; UINT32 adr = m_ptrom[re->model.model];
UINT32 adr = state->m_ptrom[re->model.model]; if(adr >= m_ptrom_limit)
if(adr >= state->m_ptrom_limit)
{ {
logerror("WARNING: model %04x base address %08x out-of-bounds - pointram?\n", re->model.model, adr); logerror("WARNING: model %04x base address %08x out-of-bounds - pointram?\n", re->model.model, adr);
return; return;
} }
while(adr < state->m_ptrom_limit) while(adr < m_ptrom_limit)
{ {
poly_vertex pv[15]; poly_vertex pv[15];
UINT32 type = state->m_ptrom[adr++]; UINT32 type = m_ptrom[adr++];
UINT32 h = state->m_ptrom[adr++]; UINT32 h = m_ptrom[adr++];
float tbase = (type >> 24) << 12; float tbase = (type >> 24) << 12;
@ -1923,16 +1942,16 @@ static void render_one_model(running_machine &machine, const namcos23_render_ent
adr += ne; adr += ne;
} }
else else
light = state->m_ptrom[adr++]; light = m_ptrom[adr++];
float minz = FLT_MAX; float minz = FLT_MAX;
float maxz = FLT_MIN; float maxz = FLT_MIN;
for(int i=0; i<ne; i++) for(int i=0; i<ne; i++)
{ {
UINT32 v1 = state->m_ptrom[adr++]; UINT32 v1 = m_ptrom[adr++];
UINT32 v2 = state->m_ptrom[adr++]; UINT32 v2 = m_ptrom[adr++];
UINT32 v3 = state->m_ptrom[adr++]; UINT32 v3 = m_ptrom[adr++];
render_apply_transform(u32_to_s24(v1), u32_to_s24(v2), u32_to_s24(v3), re, pv[i]); render_apply_transform(u32_to_s24(v1), u32_to_s24(v2), u32_to_s24(v3), re, pv[i]);
pv[i].p[1] = (((v1 >> 20) & 0xf00) | ((v2 >> 24 & 0xff))) + 0.5; pv[i].p[1] = (((v1 >> 20) & 0xf00) | ((v2 >> 24 & 0xff))) + 0.5;
@ -1953,14 +1972,14 @@ static void render_one_model(running_machine &machine, const namcos23_render_ent
break; break;
case 3: case 3:
{ {
UINT32 norm = state->m_ptrom[extptr++]; UINT32 norm = m_ptrom[extptr++];
INT32 nx = u32_to_s10(norm >> 20); INT32 nx = u32_to_s10(norm >> 20);
INT32 ny = u32_to_s10(norm >> 10); INT32 ny = u32_to_s10(norm >> 10);
INT32 nz = u32_to_s10(norm); INT32 nz = u32_to_s10(norm);
INT32 nrx, nry, nrz; INT32 nrx, nry, nrz;
render_apply_matrot(nx, ny, nz, re, nrx, nry, nrz); render_apply_matrot(nx, ny, nz, re, nrx, nry, nrz);
float lsi = float(nrx*state->m_light_vector[0] + nry*state->m_light_vector[1] + nrz*state->m_light_vector[2])/4194304.0; float lsi = float(nrx*m_light_vector[0] + nry*m_light_vector[1] + nrz*m_light_vector[2])/4194304.0;
if(lsi < 0) if(lsi < 0)
lsi = 0; lsi = 0;
@ -1987,9 +2006,9 @@ static void render_one_model(running_machine &machine, const namcos23_render_ent
} }
p->zkey = 0.5*(minz+maxz); p->zkey = 0.5*(minz+maxz);
p->front = !(h & 0x00000001); p->front = !(h & 0x00000001);
p->rd.machine = &machine; p->rd.machine = &machine();
p->rd.texture_lookup = render_texture_lookup_nocache_point; p->rd.texture_lookup = render_texture_lookup_nocache_point;
p->rd.pens = machine.pens + (color << 8); p->rd.pens = machine().pens + (color << 8);
render.poly_count++; render.poly_count++;
} }
@ -2009,10 +2028,9 @@ static int render_poly_compare(const void *i1, const void *i2)
return p1->zkey < p2->zkey ? 1 : p1->zkey > p2->zkey ? -1 : 0; return p1->zkey < p2->zkey ? 1 : p1->zkey > p2->zkey ? -1 : 0;
} }
static void render_flush(running_machine &machine, bitmap_rgb32 &bitmap) void namcos23_state::render_flush(bitmap_rgb32 &bitmap)
{ {
namcos23_state *state = machine.driver_data<namcos23_state>(); render_t &render = m_render;
render_t &render = state->m_render;
if(!render.poly_count) if(!render.poly_count)
return; return;
@ -2034,10 +2052,9 @@ static void render_flush(running_machine &machine, bitmap_rgb32 &bitmap)
render.poly_count = 0; render.poly_count = 0;
} }
static void render_run(running_machine &machine, bitmap_rgb32 &bitmap) void namcos23_state::render_run(bitmap_rgb32 &bitmap)
{ {
namcos23_state *state = machine.driver_data<namcos23_state>(); render_t &render = m_render;
render_t &render = state->m_render;
const namcos23_render_entry *re = render.entries[!render.cur]; const namcos23_render_entry *re = render.entries[!render.cur];
render.poly_count = 0; render.poly_count = 0;
@ -2046,15 +2063,15 @@ static void render_run(running_machine &machine, bitmap_rgb32 &bitmap)
switch(re->type) switch(re->type)
{ {
case MODEL: case MODEL:
render_one_model(machine, re); render_one_model(re);
break; break;
case FLUSH: case FLUSH:
render_flush(machine, bitmap); render_flush(bitmap);
break; break;
} }
re++; re++;
} }
render_flush(machine, bitmap); render_flush(bitmap);
poly_wait(render.polymgr, "render_run"); poly_wait(render.polymgr, "render_run");
} }
@ -2138,7 +2155,7 @@ UINT32 namcos23_state::screen_update_s23(screen_device &screen, bitmap_rgb32 &bi
update_mixer(); update_mixer();
bitmap.fill(m_c404.bgcolor, cliprect); bitmap.fill(m_c404.bgcolor, cliprect);
render_run(machine(), bitmap); render_run(bitmap);
m_bgtilemap->set_palette_offset(m_c404.palbase); m_bgtilemap->set_palette_offset(m_c404.palbase);
if (m_c404.layer & 4) if (m_c404.layer & 4)

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

@ -127,6 +127,7 @@ protected:
required_ioport m_io_dswc; required_ioport m_io_dswc;
UINT8 nightgal_gfx_nibble( int niboffset ); UINT8 nightgal_gfx_nibble( int niboffset );
void plot_nightgal_gfx_pixel( UINT8 pix, int x, int y );
}; };
@ -176,18 +177,17 @@ UINT8 nightgal_state::nightgal_gfx_nibble( int niboffset )
} }
} }
static void plot_nightgal_gfx_pixel( running_machine &machine, UINT8 pix, int x, int y ) void nightgal_state::plot_nightgal_gfx_pixel( UINT8 pix, int x, int y )
{ {
nightgal_state *state = machine.driver_data<nightgal_state>();
if (y >= 512) return; if (y >= 512) return;
if (x >= 512) return; if (x >= 512) return;
if (y < 0) return; if (y < 0) return;
if (x < 0) return; if (x < 0) return;
if (x & 1) if (x & 1)
state->m_blit_buffer[(y * 256) + (x >> 1)] = (state->m_blit_buffer[(y * 256) + (x >> 1)] & 0x0f) | ((pix << 4) & 0xf0); m_blit_buffer[(y * 256) + (x >> 1)] = (m_blit_buffer[(y * 256) + (x >> 1)] & 0x0f) | ((pix << 4) & 0xf0);
else else
state->m_blit_buffer[(y * 256) + (x >> 1)] = (state->m_blit_buffer[(y * 256) + (x >> 1)] & 0xf0) | (pix & 0x0f); m_blit_buffer[(y * 256) + (x >> 1)] = (m_blit_buffer[(y * 256) + (x >> 1)] & 0xf0) | (pix & 0x0f);
} }
WRITE8_MEMBER(nightgal_state::nsc_true_blitter_w) WRITE8_MEMBER(nightgal_state::nsc_true_blitter_w)
@ -231,7 +231,7 @@ WRITE8_MEMBER(nightgal_state::nsc_true_blitter_w)
dat = cur_pen_lo | (cur_pen_hi << 4); dat = cur_pen_lo | (cur_pen_hi << 4);
if ((dat & 0xff) != 0) if ((dat & 0xff) != 0)
plot_nightgal_gfx_pixel(machine(), dat, drawx, drawy); plot_nightgal_gfx_pixel(dat, drawx, drawy);
if (!flipx) if (!flipx)
count--; count--;
@ -286,7 +286,7 @@ WRITE8_MEMBER(nightgal_state::sexygal_nsc_true_blitter_w)
dat = cur_pen_lo | cur_pen_hi << 4; dat = cur_pen_lo | cur_pen_hi << 4;
if ((dat & 0xff) != 0) if ((dat & 0xff) != 0)
plot_nightgal_gfx_pixel(machine(), dat, drawx, drawy); plot_nightgal_gfx_pixel(dat, drawx, drawy);
if (!flipx) if (!flipx)
count--; count--;

22
src/mame/drivers/nmg5.c
View File

@ -279,6 +279,7 @@ public:
virtual void machine_reset(); virtual void machine_reset();
virtual void video_start(); virtual void video_start();
UINT32 screen_update_nmg5(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); UINT32 screen_update_nmg5(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
void draw_bitmap( bitmap_ind16 &bitmap );
}; };
@ -854,9 +855,8 @@ void nmg5_state::video_start()
static void draw_bitmap( running_machine &machine, bitmap_ind16 &bitmap ) void nmg5_state::draw_bitmap( bitmap_ind16 &bitmap )
{ {
nmg5_state *state = machine.driver_data<nmg5_state>();
int yyy = 256; int yyy = 256;
int xxx = 512 / 4; int xxx = 512 / 4;
UINT16 x, y, count; UINT16 x, y, count;
@ -869,13 +869,13 @@ static void draw_bitmap( running_machine &machine, bitmap_ind16 &bitmap )
{ {
for (x = 0; x < xxx; x++) for (x = 0; x < xxx; x++)
{ {
pix = (state->m_bitmap[count] & 0xf000) >> 12; pix = (m_bitmap[count] & 0xf000) >> 12;
if (pix) bitmap.pix16(y + yoff, x * 4 + 0 + xoff) = pix + 0x300; if (pix) bitmap.pix16(y + yoff, x * 4 + 0 + xoff) = pix + 0x300;
pix = (state->m_bitmap[count] & 0x0f00) >> 8; pix = (m_bitmap[count] & 0x0f00) >> 8;
if (pix) bitmap.pix16(y + yoff, x * 4 + 1 + xoff) = pix + 0x300; if (pix) bitmap.pix16(y + yoff, x * 4 + 1 + xoff) = pix + 0x300;
pix = (state->m_bitmap[count] & 0x00f0) >> 4; pix = (m_bitmap[count] & 0x00f0) >> 4;
if (pix) bitmap.pix16(y + yoff, x * 4 + 2 + xoff) = pix + 0x300; if (pix) bitmap.pix16(y + yoff, x * 4 + 2 + xoff) = pix + 0x300;
pix = (state->m_bitmap[count] & 0x000f) >> 0; pix = (m_bitmap[count] & 0x000f) >> 0;
if (pix) bitmap.pix16(y + yoff, x * 4 + 3 + xoff) = pix + 0x300; if (pix) bitmap.pix16(y + yoff, x * 4 + 3 + xoff) = pix + 0x300;
count++; count++;
@ -897,30 +897,30 @@ UINT32 nmg5_state::screen_update_nmg5(screen_device &screen, bitmap_ind16 &bitma
{ {
m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram, 0x400); m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram, 0x400);
m_fg_tilemap->draw(bitmap, cliprect, 0, 0); m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
draw_bitmap(machine(), bitmap); draw_bitmap(bitmap);
} }
else if (m_priority_reg == 1) else if (m_priority_reg == 1)
{ {
draw_bitmap(machine(), bitmap); draw_bitmap(bitmap);
m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram, 0x400); m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram, 0x400);
m_fg_tilemap->draw(bitmap, cliprect, 0, 0); m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
} }
else if (m_priority_reg == 2) else if (m_priority_reg == 2)
{ {
m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram, 0x400); m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram, 0x400);
draw_bitmap(machine(), bitmap); draw_bitmap(bitmap);
m_fg_tilemap->draw(bitmap, cliprect, 0, 0); m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
} }
else if (m_priority_reg == 3) else if (m_priority_reg == 3)
{ {
m_fg_tilemap->draw(bitmap, cliprect, 0, 0); m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram, 0x400); m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram, 0x400);
draw_bitmap(machine(), bitmap); draw_bitmap(bitmap);
} }
else if (m_priority_reg == 7) else if (m_priority_reg == 7)
{ {
m_fg_tilemap->draw(bitmap, cliprect, 0, 0); m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
draw_bitmap(machine(), bitmap); draw_bitmap(bitmap);
m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram, 0x400); m_sprgen->draw_sprites(bitmap, cliprect, m_spriteram, 0x400);
} }
return 0; return 0;

36
src/mame/drivers/peplus.c
View File

@ -268,6 +268,8 @@ public:
virtual void palette_init(); virtual void palette_init();
UINT32 screen_update_peplus(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); UINT32 screen_update_peplus(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
TIMER_CALLBACK_MEMBER(assert_lp_cb); TIMER_CALLBACK_MEMBER(assert_lp_cb);
void peplus_load_superdata(const char *bank_name);
void peplus_init();
}; };
static const UINT8 id_022[8] = { 0x00, 0x01, 0x04, 0x09, 0x13, 0x16, 0x18, 0x00 }; static const UINT8 id_022[8] = { 0x00, 0x01, 0x04, 0x09, 0x13, 0x16, 0x18, 0x00 };
@ -311,18 +313,17 @@ static MC6845_INTERFACE( mc6845_intf )
* Memory Copy * * Memory Copy *
***************/ ***************/
static void peplus_load_superdata(running_machine &machine, const char *bank_name) void peplus_state::peplus_load_superdata(const char *bank_name)
{ {
peplus_state *state = machine.driver_data<peplus_state>(); UINT8 *super_data = memregion(bank_name)->base();
UINT8 *super_data = state->memregion(bank_name)->base();
/* Distribute Superboard Data */ /* Distribute Superboard Data */
memcpy(state->m_s3000_ram, &super_data[0x3000], 0x1000); memcpy(m_s3000_ram, &super_data[0x3000], 0x1000);
memcpy(state->m_s5000_ram, &super_data[0x5000], 0x1000); memcpy(m_s5000_ram, &super_data[0x5000], 0x1000);
memcpy(state->m_s7000_ram, &super_data[0x7000], 0x1000); memcpy(m_s7000_ram, &super_data[0x7000], 0x1000);
memcpy(state->m_sb000_ram, &super_data[0xb000], 0x1000); memcpy(m_sb000_ram, &super_data[0xb000], 0x1000);
memcpy(state->m_sd000_ram, &super_data[0xd000], 0x1000); memcpy(m_sd000_ram, &super_data[0xd000], 0x1000);
memcpy(state->m_sf000_ram, &super_data[0xf000], 0x1000); memcpy(m_sf000_ram, &super_data[0xf000], 0x1000);
} }
@ -431,7 +432,7 @@ WRITE8_MEMBER(peplus_state::peplus_cmos_w)
if (offset == 0x1fff && m_wingboard && data < 5) if (offset == 0x1fff && m_wingboard && data < 5)
{ {
sprintf(bank_name, "user%d", data + 1); sprintf(bank_name, "user%d", data + 1);
peplus_load_superdata(machine(), bank_name); peplus_load_superdata(bank_name);
} }
m_cmos_ram[offset] = data; m_cmos_ram[offset] = data;
@ -1377,11 +1378,10 @@ MACHINE_CONFIG_END
*****************/ *****************/
/* Normal board */ /* Normal board */
static void peplus_init(running_machine &machine) void peplus_state::peplus_init()
{ {
peplus_state *state = machine.driver_data<peplus_state>();
/* default : no address to patch in program RAM to enable autohold feature */ /* default : no address to patch in program RAM to enable autohold feature */
state->m_autohold_addr = 0; m_autohold_addr = 0;
} }
@ -1394,7 +1394,7 @@ DRIVER_INIT_MEMBER(peplus_state,peplus)
{ {
m_wingboard = FALSE; m_wingboard = FALSE;
m_jumper_e16_e17 = FALSE; m_jumper_e16_e17 = FALSE;
peplus_init(machine()); peplus_init();
} }
/* Superboard */ /* Superboard */
@ -1402,9 +1402,9 @@ DRIVER_INIT_MEMBER(peplus_state,peplussb)
{ {
m_wingboard = FALSE; m_wingboard = FALSE;
m_jumper_e16_e17 = FALSE; m_jumper_e16_e17 = FALSE;
peplus_load_superdata(machine(), "user1"); peplus_load_superdata("user1");
peplus_init(machine()); peplus_init();
} }
/* Superboard with Attached Wingboard */ /* Superboard with Attached Wingboard */
@ -1412,9 +1412,9 @@ DRIVER_INIT_MEMBER(peplus_state,peplussbw)
{ {
m_wingboard = TRUE; m_wingboard = TRUE;
m_jumper_e16_e17 = TRUE; m_jumper_e16_e17 = TRUE;
peplus_load_superdata(machine(), "user1"); peplus_load_superdata("user1");
peplus_init(machine()); peplus_init();
} }

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

@ -496,26 +496,23 @@ public:
virtual void machine_reset(); virtual void machine_reset();
UINT32 screen_update_seattle(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); UINT32 screen_update_seattle(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
TIMER_CALLBACK_MEMBER(galileo_timer_callback); TIMER_CALLBACK_MEMBER(galileo_timer_callback);
void ethernet_interrupt_machine(int state);
void update_vblank_irq();
UINT32 pci_bridge_r(address_space &space, UINT8 reg, UINT8 type);
void pci_bridge_w(address_space &space, UINT8 reg, UINT8 type, UINT32 data);
UINT32 pci_3dfx_r(address_space &space, UINT8 reg, UINT8 type);
void pci_3dfx_w(address_space &space, UINT8 reg, UINT8 type, UINT32 data);
UINT32 pci_ide_r(address_space &space, UINT8 reg, UINT8 type);
void pci_ide_w(address_space &space, UINT8 reg, UINT8 type, UINT32 data);
void update_galileo_irqs();
int galileo_dma_fetch_next(address_space &space, int which);
void galileo_perform_dma(address_space &space, int which);
void galileo_reset();
void widget_reset();
void update_widget_irq();
void init_common(int ioasic, int serialnum, int yearoffs, int config);
}; };
/*************************************
*
* Prototypes
*
*************************************/
static void vblank_assert(device_t *device, int state);
static void update_vblank_irq(running_machine &machine);
static void galileo_reset(running_machine &machine);
static void galileo_perform_dma(address_space &space, int which);
static void voodoo_stall(device_t *device, int stall);
static void widget_reset(running_machine &machine);
static void update_widget_irq(running_machine &machine);
/************************************* /*************************************
* *
* Video start and update * Video start and update
@ -607,9 +604,9 @@ void seattle_state::machine_reset()
} }
/* reset the other devices */ /* reset the other devices */
galileo_reset(machine()); galileo_reset();
if (m_board_config == SEATTLE_WIDGET_CONFIG) if (m_board_config == SEATTLE_WIDGET_CONFIG)
widget_reset(machine()); widget_reset();
} }
@ -633,23 +630,23 @@ WRITE_LINE_MEMBER(seattle_state::ide_interrupt)
* *
*************************************/ *************************************/
static void ethernet_interrupt_machine(running_machine &machine, int state) void seattle_state::ethernet_interrupt_machine(int state)
{ {
seattle_state *drvstate = machine.driver_data<seattle_state>(); m_ethernet_irq_state = state;
drvstate->m_ethernet_irq_state = state; if (m_board_config == FLAGSTAFF_CONFIG)
if (drvstate->m_board_config == FLAGSTAFF_CONFIG)
{ {
UINT8 assert = drvstate->m_ethernet_irq_state && (*drvstate->m_interrupt_enable & (1 << ETHERNET_IRQ_SHIFT)); UINT8 assert = m_ethernet_irq_state && (*m_interrupt_enable & (1 << ETHERNET_IRQ_SHIFT));
if (drvstate->m_ethernet_irq_num != 0) if (m_ethernet_irq_num != 0)
machine.device("maincpu")->execute().set_input_line(drvstate->m_ethernet_irq_num, assert ? ASSERT_LINE : CLEAR_LINE); machine().device("maincpu")->execute().set_input_line(m_ethernet_irq_num, assert ? ASSERT_LINE : CLEAR_LINE);
} }
else if (drvstate->m_board_config == SEATTLE_WIDGET_CONFIG) else if (m_board_config == SEATTLE_WIDGET_CONFIG)
update_widget_irq(machine); update_widget_irq();
} }
static void ethernet_interrupt(device_t *device, int state) static void ethernet_interrupt(device_t *device, int state)
{ {
ethernet_interrupt_machine(device->machine(), state); seattle_state *drvstate = device->machine().driver_data<seattle_state>();
drvstate->ethernet_interrupt_machine(state);
} }
@ -728,8 +725,8 @@ WRITE32_MEMBER(seattle_state::interrupt_config_w)
} }
/* update the states */ /* update the states */
update_vblank_irq(machine()); update_vblank_irq();
ethernet_interrupt_machine(machine(), m_ethernet_irq_state); ethernet_interrupt_machine(m_ethernet_irq_state);
} }
@ -740,9 +737,9 @@ WRITE32_MEMBER(seattle_state::seattle_interrupt_enable_w)
if (old != *m_interrupt_enable) if (old != *m_interrupt_enable)
{ {
if (m_vblank_latch) if (m_vblank_latch)
update_vblank_irq(machine()); update_vblank_irq();
if (m_ethernet_irq_state) if (m_ethernet_irq_state)
ethernet_interrupt_machine(machine(), m_ethernet_irq_state); ethernet_interrupt_machine(m_ethernet_irq_state);
} }
} }
@ -754,19 +751,18 @@ WRITE32_MEMBER(seattle_state::seattle_interrupt_enable_w)
* *
*************************************/ *************************************/
static void update_vblank_irq(running_machine &machine) void seattle_state::update_vblank_irq()
{ {
seattle_state *drvstate = machine.driver_data<seattle_state>();
int state = CLEAR_LINE; int state = CLEAR_LINE;
/* skip if no interrupt configured */ /* skip if no interrupt configured */
if (drvstate->m_vblank_irq_num == 0) if (m_vblank_irq_num == 0)
return; return;
/* if the VBLANK has been latched, and the interrupt is enabled, assert */ /* if the VBLANK has been latched, and the interrupt is enabled, assert */
if (drvstate->m_vblank_latch && (*drvstate->m_interrupt_enable & (1 << VBLANK_IRQ_SHIFT))) if (m_vblank_latch && (*m_interrupt_enable & (1 << VBLANK_IRQ_SHIFT)))
state = ASSERT_LINE; state = ASSERT_LINE;
machine.device("maincpu")->execute().set_input_line(drvstate->m_vblank_irq_num, state); machine().device("maincpu")->execute().set_input_line(m_vblank_irq_num, state);
} }
@ -774,7 +770,7 @@ WRITE32_MEMBER(seattle_state::vblank_clear_w)
{ {
/* clear the latch and update the IRQ */ /* clear the latch and update the IRQ */
m_vblank_latch = 0; m_vblank_latch = 0;
update_vblank_irq(machine()); update_vblank_irq();
} }
@ -788,7 +784,7 @@ static void vblank_assert(device_t *device, int state)
if ((state && !(*drvstate->m_interrupt_enable & 0x100)) || (!state && (*drvstate->m_interrupt_enable & 0x100))) if ((state && !(*drvstate->m_interrupt_enable & 0x100)) || (!state && (*drvstate->m_interrupt_enable & 0x100)))
{ {
drvstate->m_vblank_latch = 1; drvstate->m_vblank_latch = 1;
update_vblank_irq(device->machine()); drvstate->update_vblank_irq();
} }
} }
@ -800,10 +796,9 @@ static void vblank_assert(device_t *device, int state)
* *
*************************************/ *************************************/
static UINT32 pci_bridge_r(address_space &space, UINT8 reg, UINT8 type) UINT32 seattle_state::pci_bridge_r(address_space &space, UINT8 reg, UINT8 type)
{ {
seattle_state *state = space.machine().driver_data<seattle_state>(); UINT32 result = m_galileo.pci_bridge_regs[reg];
UINT32 result = state->m_galileo.pci_bridge_regs[reg];
switch (reg) switch (reg)
{ {
@ -822,10 +817,9 @@ static UINT32 pci_bridge_r(address_space &space, UINT8 reg, UINT8 type)
} }
static void pci_bridge_w(address_space &space, UINT8 reg, UINT8 type, UINT32 data) void seattle_state::pci_bridge_w(address_space &space, UINT8 reg, UINT8 type, UINT32 data)
{ {
seattle_state *state = space.machine().driver_data<seattle_state>(); m_galileo.pci_bridge_regs[reg] = data;
state->m_galileo.pci_bridge_regs[reg] = data;
if (LOG_PCI) if (LOG_PCI)
logerror("%08X:PCI bridge write: reg %d type %d = %08X\n", space.device().safe_pc(), reg, type, data); logerror("%08X:PCI bridge write: reg %d type %d = %08X\n", space.device().safe_pc(), reg, type, data);
} }
@ -838,10 +832,9 @@ static void pci_bridge_w(address_space &space, UINT8 reg, UINT8 type, UINT32 dat
* *
*************************************/ *************************************/
static UINT32 pci_3dfx_r(address_space &space, UINT8 reg, UINT8 type) UINT32 seattle_state::pci_3dfx_r(address_space &space, UINT8 reg, UINT8 type)
{ {
seattle_state *state = space.machine().driver_data<seattle_state>(); UINT32 result = m_galileo.pci_3dfx_regs[reg];
UINT32 result = state->m_galileo.pci_3dfx_regs[reg];
switch (reg) switch (reg)
{ {
@ -860,21 +853,20 @@ static UINT32 pci_3dfx_r(address_space &space, UINT8 reg, UINT8 type)
} }
static void pci_3dfx_w(address_space &space, UINT8 reg, UINT8 type, UINT32 data) void seattle_state::pci_3dfx_w(address_space &space, UINT8 reg, UINT8 type, UINT32 data)
{ {
seattle_state *state = space.machine().driver_data<seattle_state>(); m_galileo.pci_3dfx_regs[reg] = data;
state->m_galileo.pci_3dfx_regs[reg] = data;
switch (reg) switch (reg)
{ {
case 0x04: /* address register */ case 0x04: /* address register */
state->m_galileo.pci_3dfx_regs[reg] &= 0xff000000; m_galileo.pci_3dfx_regs[reg] &= 0xff000000;
if (data != 0x08000000) if (data != 0x08000000)
logerror("3dfx not mapped where we expect it! (%08X)\n", data); logerror("3dfx not mapped where we expect it! (%08X)\n", data);
break; break;
case 0x10: /* initEnable register */ case 0x10: /* initEnable register */
voodoo_set_init_enable(state->m_voodoo, data); voodoo_set_init_enable(m_voodoo, data);
break; break;
} }
if (LOG_PCI) if (LOG_PCI)
@ -889,10 +881,9 @@ static void pci_3dfx_w(address_space &space, UINT8 reg, UINT8 type, UINT32 data)
* *
*************************************/ *************************************/
static UINT32 pci_ide_r(address_space &space, UINT8 reg, UINT8 type) UINT32 seattle_state::pci_ide_r(address_space &space, UINT8 reg, UINT8 type)
{ {
seattle_state *state = space.machine().driver_data<seattle_state>(); UINT32 result = m_galileo.pci_ide_regs[reg];
UINT32 result = state->m_galileo.pci_ide_regs[reg];
switch (reg) switch (reg)
{ {
@ -911,10 +902,9 @@ static UINT32 pci_ide_r(address_space &space, UINT8 reg, UINT8 type)
} }
static void pci_ide_w(address_space &space, UINT8 reg, UINT8 type, UINT32 data) void seattle_state::pci_ide_w(address_space &space, UINT8 reg, UINT8 type, UINT32 data)
{ {
seattle_state *state = space.machine().driver_data<seattle_state>(); m_galileo.pci_ide_regs[reg] = data;
state->m_galileo.pci_ide_regs[reg] = data;
if (LOG_PCI) if (LOG_PCI)
logerror("%08X:PCI bridge write: reg %d type %d = %08X\n", space.device().safe_pc(), reg, type, data); logerror("%08X:PCI bridge write: reg %d type %d = %08X\n", space.device().safe_pc(), reg, type, data);
} }
@ -927,15 +917,14 @@ static void pci_ide_w(address_space &space, UINT8 reg, UINT8 type, UINT32 data)
* *
*************************************/ *************************************/
static void update_galileo_irqs(running_machine &machine) void seattle_state::update_galileo_irqs()
{ {
seattle_state *drvstate = machine.driver_data<seattle_state>();
int state = CLEAR_LINE; int state = CLEAR_LINE;
/* if any unmasked interrupts are live, we generate */ /* if any unmasked interrupts are live, we generate */
if (drvstate->m_galileo.reg[GREG_INT_STATE] & drvstate->m_galileo.reg[GREG_INT_MASK]) if (m_galileo.reg[GREG_INT_STATE] & m_galileo.reg[GREG_INT_MASK])
state = ASSERT_LINE; state = ASSERT_LINE;
machine.device("maincpu")->execute().set_input_line(GALILEO_IRQ_NUM, state); machine().device("maincpu")->execute().set_input_line(GALILEO_IRQ_NUM, state);
if (LOG_GALILEO) if (LOG_GALILEO)
logerror("Galileo IRQ %s\n", (state == ASSERT_LINE) ? "asserted" : "cleared"); logerror("Galileo IRQ %s\n", (state == ASSERT_LINE) ? "asserted" : "cleared");
@ -963,7 +952,7 @@ TIMER_CALLBACK_MEMBER(seattle_state::galileo_timer_callback)
/* trigger the interrupt */ /* trigger the interrupt */
m_galileo.reg[GREG_INT_STATE] |= 1 << (GINT_T0EXP_SHIFT + which); m_galileo.reg[GREG_INT_STATE] |= 1 << (GINT_T0EXP_SHIFT + which);
update_galileo_irqs(machine()); update_galileo_irqs();
} }
@ -974,10 +963,9 @@ TIMER_CALLBACK_MEMBER(seattle_state::galileo_timer_callback)
* *
*************************************/ *************************************/
static int galileo_dma_fetch_next(address_space &space, int which) int seattle_state::galileo_dma_fetch_next(address_space &space, int which)
{ {
seattle_state *state = space.machine().driver_data<seattle_state>(); galileo_data &galileo = m_galileo;
galileo_data &galileo = state->m_galileo;
offs_t address = 0; offs_t address = 0;
UINT32 data; UINT32 data;
@ -991,7 +979,7 @@ static int galileo_dma_fetch_next(address_space &space, int which)
if (galileo.reg[GREG_DMA0_CONTROL + which] & 0x400) if (galileo.reg[GREG_DMA0_CONTROL + which] & 0x400)
{ {
galileo.reg[GREG_INT_STATE] |= 1 << (GINT_DMA0COMP_SHIFT + which); galileo.reg[GREG_INT_STATE] |= 1 << (GINT_DMA0COMP_SHIFT + which);
update_galileo_irqs(space.machine()); update_galileo_irqs();
} }
galileo.reg[GREG_DMA0_CONTROL + which] &= ~0x5000; galileo.reg[GREG_DMA0_CONTROL + which] &= ~0x5000;
return 0; return 0;
@ -1016,10 +1004,9 @@ static int galileo_dma_fetch_next(address_space &space, int which)
} }
static void galileo_perform_dma(address_space &space, int which) void seattle_state::galileo_perform_dma(address_space &space, int which)
{ {
seattle_state *state = space.machine().driver_data<seattle_state>(); galileo_data &galileo = m_galileo;
galileo_data &galileo = state->m_galileo;
do do
{ {
offs_t srcaddr = galileo.reg[GREG_DMA0_SOURCE + which]; offs_t srcaddr = galileo.reg[GREG_DMA0_SOURCE + which];
@ -1061,7 +1048,7 @@ static void galileo_perform_dma(address_space &space, int which)
while (bytesleft >= 4) while (bytesleft >= 4)
{ {
/* if the voodoo is stalled, stop early */ /* if the voodoo is stalled, stop early */
if (state->m_voodoo_stalled) if (m_voodoo_stalled)
{ {
if (LOG_DMA) if (LOG_DMA)
logerror("Stalled on voodoo with %d bytes left\n", bytesleft); logerror("Stalled on voodoo with %d bytes left\n", bytesleft);
@ -1069,7 +1056,7 @@ static void galileo_perform_dma(address_space &space, int which)
} }
/* write the data and advance */ /* write the data and advance */
voodoo_w(state->m_voodoo, space, (dstaddr & 0xffffff) / 4, space.read_dword(srcaddr), 0xffffffff); voodoo_w(m_voodoo, space, (dstaddr & 0xffffff) / 4, space.read_dword(srcaddr), 0xffffffff);
srcaddr += srcinc; srcaddr += srcinc;
dstaddr += dstinc; dstaddr += dstinc;
bytesleft -= 4; bytesleft -= 4;
@ -1102,7 +1089,7 @@ static void galileo_perform_dma(address_space &space, int which)
if (!(galileo.reg[GREG_DMA0_CONTROL + which] & 0x400)) if (!(galileo.reg[GREG_DMA0_CONTROL + which] & 0x400))
{ {
galileo.reg[GREG_INT_STATE] |= 1 << (GINT_DMA0COMP_SHIFT + which); galileo.reg[GREG_INT_STATE] |= 1 << (GINT_DMA0COMP_SHIFT + which);
update_galileo_irqs(space.machine()); update_galileo_irqs();
} }
} while (galileo_dma_fetch_next(space, which)); } while (galileo_dma_fetch_next(space, which));
@ -1117,10 +1104,9 @@ static void galileo_perform_dma(address_space &space, int which)
* *
*************************************/ *************************************/
static void galileo_reset(running_machine &machine) void seattle_state::galileo_reset()
{ {
seattle_state *state = machine.driver_data<seattle_state>(); memset(&m_galileo.reg, 0, sizeof(m_galileo.reg));
memset(&state->m_galileo.reg, 0, sizeof(state->m_galileo.reg));
} }
@ -1296,7 +1282,7 @@ WRITE32_MEMBER(seattle_state::galileo_w)
if (LOG_GALILEO) if (LOG_GALILEO)
logerror("%08X:Galileo write to IRQ clear = %08X & %08X\n", offset*4, data, mem_mask); logerror("%08X:Galileo write to IRQ clear = %08X & %08X\n", offset*4, data, mem_mask);
galileo.reg[offset] = oldata & data; galileo.reg[offset] = oldata & data;
update_galileo_irqs(machine()); update_galileo_irqs();
break; break;
case GREG_CONFIG_DATA: case GREG_CONFIG_DATA:
@ -1411,7 +1397,7 @@ static void voodoo_stall(device_t *device, int stall)
state->m_galileo.dma_stalled_on_voodoo[which] = FALSE; state->m_galileo.dma_stalled_on_voodoo[which] = FALSE;
/* resume execution */ /* resume execution */
galileo_perform_dma(space, which); state->galileo_perform_dma(space, which);
break; break;
} }
@ -1550,25 +1536,23 @@ WRITE32_MEMBER(seattle_state::ethernet_w)
* *
*************************************/ *************************************/
static void widget_reset(running_machine &machine) void seattle_state::widget_reset()
{ {
seattle_state *state = machine.driver_data<seattle_state>(); UINT8 saved_irq = m_widget.irq_num;
UINT8 saved_irq = state->m_widget.irq_num; memset(&m_widget, 0, sizeof(m_widget));
memset(&state->m_widget, 0, sizeof(state->m_widget)); m_widget.irq_num = saved_irq;
state->m_widget.irq_num = saved_irq;
} }
static void update_widget_irq(running_machine &machine) void seattle_state::update_widget_irq()
{ {
seattle_state *drvstate = machine.driver_data<seattle_state>(); UINT8 state = m_ethernet_irq_state << WINT_ETHERNET_SHIFT;
UINT8 state = drvstate->m_ethernet_irq_state << WINT_ETHERNET_SHIFT; UINT8 mask = m_widget.irq_mask;
UINT8 mask = drvstate->m_widget.irq_mask; UINT8 assert = ((mask & state) != 0) && (*m_interrupt_enable & (1 << WIDGET_IRQ_SHIFT));
UINT8 assert = ((mask & state) != 0) && (*drvstate->m_interrupt_enable & (1 << WIDGET_IRQ_SHIFT));
/* update the IRQ state */ /* update the IRQ state */
if (drvstate->m_widget.irq_num != 0) if (m_widget.irq_num != 0)
machine.device("maincpu")->execute().set_input_line(drvstate->m_widget.irq_num, assert ? ASSERT_LINE : CLEAR_LINE); machine().device("maincpu")->execute().set_input_line(m_widget.irq_num, assert ? ASSERT_LINE : CLEAR_LINE);
} }
@ -1617,7 +1601,7 @@ WRITE32_MEMBER(seattle_state::widget_w)
case WREG_INTERRUPT: case WREG_INTERRUPT:
m_widget.irq_mask = data; m_widget.irq_mask = data;
update_widget_irq(machine()); update_widget_irq();
break; break;
case WREG_ANALOG: case WREG_ANALOG:
@ -2856,33 +2840,32 @@ ROM_END
* *
*************************************/ *************************************/
static void init_common(running_machine &machine, int ioasic, int serialnum, int yearoffs, int config) void seattle_state::init_common(int ioasic, int serialnum, int yearoffs, int config)
{ {
seattle_state *state = machine.driver_data<seattle_state>();
/* initialize the subsystems */ /* initialize the subsystems */
midway_ioasic_init(machine, ioasic, serialnum, yearoffs, ioasic_irq); midway_ioasic_init(machine(),ioasic, serialnum, yearoffs, ioasic_irq);
/* switch off the configuration */ /* switch off the configuration */
state->m_board_config = config; m_board_config = config;
switch (config) switch (config)
{ {
case PHOENIX_CONFIG: case PHOENIX_CONFIG:
/* original Phoenix board only has 4MB of RAM */ /* original Phoenix board only has 4MB of RAM */
machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_readwrite(0x00400000, 0x007fffff); machine().device("maincpu")->memory().space(AS_PROGRAM).unmap_readwrite(0x00400000, 0x007fffff);
break; break;
case SEATTLE_WIDGET_CONFIG: case SEATTLE_WIDGET_CONFIG:
/* set up the widget board */ /* set up the widget board */
machine.device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0x16c00000, 0x16c0001f, read32_delegate(FUNC(seattle_state::widget_r),state), write32_delegate(FUNC(seattle_state::widget_w),state)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0x16c00000, 0x16c0001f, read32_delegate(FUNC(seattle_state::widget_r),this), write32_delegate(FUNC(seattle_state::widget_w),this));
break; break;
case FLAGSTAFF_CONFIG: case FLAGSTAFF_CONFIG:
/* set up the analog inputs */ /* set up the analog inputs */
machine.device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0x14000000, 0x14000003, read32_delegate(FUNC(seattle_state::analog_port_r),state), write32_delegate(FUNC(seattle_state::analog_port_w),state)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0x14000000, 0x14000003, read32_delegate(FUNC(seattle_state::analog_port_r),this), write32_delegate(FUNC(seattle_state::analog_port_w),this));
/* set up the ethernet controller */ /* set up the ethernet controller */
machine.device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0x16c00000, 0x16c0003f, read32_delegate(FUNC(seattle_state::ethernet_r),state), write32_delegate(FUNC(seattle_state::ethernet_w),state)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0x16c00000, 0x16c0003f, read32_delegate(FUNC(seattle_state::ethernet_r),this), write32_delegate(FUNC(seattle_state::ethernet_w),this));
break; break;
} }
} }
@ -2891,7 +2874,7 @@ static void init_common(running_machine &machine, int ioasic, int serialnum, int
DRIVER_INIT_MEMBER(seattle_state,wg3dh) DRIVER_INIT_MEMBER(seattle_state,wg3dh)
{ {
dcs2_init(machine(), 2, 0x3839); dcs2_init(machine(), 2, 0x3839);
init_common(machine(), MIDWAY_IOASIC_STANDARD, 310/* others? */, 80, PHOENIX_CONFIG); init_common(MIDWAY_IOASIC_STANDARD, 310/* others? */, 80, PHOENIX_CONFIG);
/* speedups */ /* speedups */
mips3drc_add_hotspot(machine().device("maincpu"), 0x8004413C, 0x0C0054B4, 250); /* confirmed */ mips3drc_add_hotspot(machine().device("maincpu"), 0x8004413C, 0x0C0054B4, 250); /* confirmed */
@ -2903,7 +2886,7 @@ DRIVER_INIT_MEMBER(seattle_state,wg3dh)
DRIVER_INIT_MEMBER(seattle_state,mace) DRIVER_INIT_MEMBER(seattle_state,mace)
{ {
dcs2_init(machine(), 2, 0x3839); dcs2_init(machine(), 2, 0x3839);
init_common(machine(), MIDWAY_IOASIC_MACE, 319/* others? */, 80, SEATTLE_CONFIG); init_common(MIDWAY_IOASIC_MACE, 319/* others? */, 80, SEATTLE_CONFIG);
/* speedups */ /* speedups */
mips3drc_add_hotspot(machine().device("maincpu"), 0x800108F8, 0x8C420000, 250); /* confirmed */ mips3drc_add_hotspot(machine().device("maincpu"), 0x800108F8, 0x8C420000, 250); /* confirmed */
@ -2913,7 +2896,7 @@ DRIVER_INIT_MEMBER(seattle_state,mace)
DRIVER_INIT_MEMBER(seattle_state,sfrush) DRIVER_INIT_MEMBER(seattle_state,sfrush)
{ {
cage_init(machine(), 0x5236); cage_init(machine(), 0x5236);
init_common(machine(), MIDWAY_IOASIC_STANDARD, 315/* no alternates */, 100, FLAGSTAFF_CONFIG); init_common(MIDWAY_IOASIC_STANDARD, 315/* no alternates */, 100, FLAGSTAFF_CONFIG);
/* speedups */ /* speedups */
mips3drc_add_hotspot(machine().device("maincpu"), 0x80059F34, 0x3C028012, 250); /* confirmed */ mips3drc_add_hotspot(machine().device("maincpu"), 0x80059F34, 0x3C028012, 250); /* confirmed */
@ -2925,7 +2908,7 @@ DRIVER_INIT_MEMBER(seattle_state,sfrush)
DRIVER_INIT_MEMBER(seattle_state,sfrushrk) DRIVER_INIT_MEMBER(seattle_state,sfrushrk)
{ {
cage_init(machine(), 0x5329); cage_init(machine(), 0x5329);
init_common(machine(), MIDWAY_IOASIC_SFRUSHRK, 331/* unknown */, 100, FLAGSTAFF_CONFIG); init_common(MIDWAY_IOASIC_SFRUSHRK, 331/* unknown */, 100, FLAGSTAFF_CONFIG);
/* speedups */ /* speedups */
mips3drc_add_hotspot(machine().device("maincpu"), 0x800343E8, 0x3C028012, 250); /* confirmed */ mips3drc_add_hotspot(machine().device("maincpu"), 0x800343E8, 0x3C028012, 250); /* confirmed */
@ -2938,7 +2921,7 @@ DRIVER_INIT_MEMBER(seattle_state,sfrushrk)
DRIVER_INIT_MEMBER(seattle_state,calspeed) DRIVER_INIT_MEMBER(seattle_state,calspeed)
{ {
dcs2_init(machine(), 2, 0x39c0); dcs2_init(machine(), 2, 0x39c0);
init_common(machine(), MIDWAY_IOASIC_CALSPEED, 328/* others? */, 100, SEATTLE_WIDGET_CONFIG); init_common(MIDWAY_IOASIC_CALSPEED, 328/* others? */, 100, SEATTLE_WIDGET_CONFIG);
midway_ioasic_set_auto_ack(1); midway_ioasic_set_auto_ack(1);
/* speedups */ /* speedups */
@ -2950,7 +2933,7 @@ DRIVER_INIT_MEMBER(seattle_state,calspeed)
DRIVER_INIT_MEMBER(seattle_state,vaportrx) DRIVER_INIT_MEMBER(seattle_state,vaportrx)
{ {
dcs2_init(machine(), 2, 0x39c2); dcs2_init(machine(), 2, 0x39c2);
init_common(machine(), MIDWAY_IOASIC_VAPORTRX, 324/* 334? unknown */, 100, SEATTLE_WIDGET_CONFIG); init_common(MIDWAY_IOASIC_VAPORTRX, 324/* 334? unknown */, 100, SEATTLE_WIDGET_CONFIG);
/* speedups */ /* speedups */
mips3drc_add_hotspot(machine().device("maincpu"), 0x80049F14, 0x3C028020, 250); /* confirmed */ mips3drc_add_hotspot(machine().device("maincpu"), 0x80049F14, 0x3C028020, 250); /* confirmed */
@ -2962,7 +2945,7 @@ DRIVER_INIT_MEMBER(seattle_state,vaportrx)
DRIVER_INIT_MEMBER(seattle_state,biofreak) DRIVER_INIT_MEMBER(seattle_state,biofreak)
{ {
dcs2_init(machine(), 2, 0x3835); dcs2_init(machine(), 2, 0x3835);
init_common(machine(), MIDWAY_IOASIC_STANDARD, 231/* no alternates */, 80, SEATTLE_CONFIG); init_common(MIDWAY_IOASIC_STANDARD, 231/* no alternates */, 80, SEATTLE_CONFIG);
/* speedups */ /* speedups */
} }
@ -2971,7 +2954,7 @@ DRIVER_INIT_MEMBER(seattle_state,biofreak)
DRIVER_INIT_MEMBER(seattle_state,blitz) DRIVER_INIT_MEMBER(seattle_state,blitz)
{ {
dcs2_init(machine(), 2, 0x39c2); dcs2_init(machine(), 2, 0x39c2);
init_common(machine(), MIDWAY_IOASIC_BLITZ99, 444/* or 528 */, 80, SEATTLE_CONFIG); init_common(MIDWAY_IOASIC_BLITZ99, 444/* or 528 */, 80, SEATTLE_CONFIG);
/* for some reason, the code in the ROM appears buggy; this is a small patch to fix it */ /* for some reason, the code in the ROM appears buggy; this is a small patch to fix it */
m_rombase[0x934/4] += 4; m_rombase[0x934/4] += 4;
@ -2985,7 +2968,7 @@ DRIVER_INIT_MEMBER(seattle_state,blitz)
DRIVER_INIT_MEMBER(seattle_state,blitz99) DRIVER_INIT_MEMBER(seattle_state,blitz99)
{ {
dcs2_init(machine(), 2, 0x0afb); dcs2_init(machine(), 2, 0x0afb);
init_common(machine(), MIDWAY_IOASIC_BLITZ99, 481/* or 484 or 520 */, 80, SEATTLE_CONFIG); init_common(MIDWAY_IOASIC_BLITZ99, 481/* or 484 or 520 */, 80, SEATTLE_CONFIG);
/* speedups */ /* speedups */
mips3drc_add_hotspot(machine().device("maincpu"), 0x8014E41C, 0x3C038025, 250); /* confirmed */ mips3drc_add_hotspot(machine().device("maincpu"), 0x8014E41C, 0x3C038025, 250); /* confirmed */
@ -2996,7 +2979,7 @@ DRIVER_INIT_MEMBER(seattle_state,blitz99)
DRIVER_INIT_MEMBER(seattle_state,blitz2k) DRIVER_INIT_MEMBER(seattle_state,blitz2k)
{ {
dcs2_init(machine(), 2, 0x0b5d); dcs2_init(machine(), 2, 0x0b5d);
init_common(machine(), MIDWAY_IOASIC_BLITZ99, 494/* or 498 */, 80, SEATTLE_CONFIG); init_common(MIDWAY_IOASIC_BLITZ99, 494/* or 498 */, 80, SEATTLE_CONFIG);
/* speedups */ /* speedups */
mips3drc_add_hotspot(machine().device("maincpu"), 0x8015773C, 0x3C038025, 250); /* confirmed */ mips3drc_add_hotspot(machine().device("maincpu"), 0x8015773C, 0x3C038025, 250); /* confirmed */
@ -3007,7 +2990,7 @@ DRIVER_INIT_MEMBER(seattle_state,blitz2k)
DRIVER_INIT_MEMBER(seattle_state,carnevil) DRIVER_INIT_MEMBER(seattle_state,carnevil)
{ {
dcs2_init(machine(), 2, 0x0af7); dcs2_init(machine(), 2, 0x0af7);
init_common(machine(), MIDWAY_IOASIC_CARNEVIL, 469/* 469 or 486 or 528 */, 80, SEATTLE_CONFIG); init_common(MIDWAY_IOASIC_CARNEVIL, 469/* 469 or 486 or 528 */, 80, SEATTLE_CONFIG);
/* set up the gun */ /* set up the gun */
machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0x16800000, 0x1680001f, read32_delegate(FUNC(seattle_state::carnevil_gun_r),this), write32_delegate(FUNC(seattle_state::carnevil_gun_w),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0x16800000, 0x1680001f, read32_delegate(FUNC(seattle_state::carnevil_gun_r),this), write32_delegate(FUNC(seattle_state::carnevil_gun_w),this));
@ -3021,7 +3004,7 @@ DRIVER_INIT_MEMBER(seattle_state,carnevil)
DRIVER_INIT_MEMBER(seattle_state,hyprdriv) DRIVER_INIT_MEMBER(seattle_state,hyprdriv)
{ {
dcs2_init(machine(), 2, 0x0af7); dcs2_init(machine(), 2, 0x0af7);
init_common(machine(), MIDWAY_IOASIC_HYPRDRIV, 469/* unknown */, 80, SEATTLE_WIDGET_CONFIG); init_common(MIDWAY_IOASIC_HYPRDRIV, 469/* unknown */, 80, SEATTLE_WIDGET_CONFIG);
/* speedups */ /* speedups */
mips3drc_add_hotspot(machine().device("maincpu"), 0x801643BC, 0x3C03801B, 250); /* confirmed */ mips3drc_add_hotspot(machine().device("maincpu"), 0x801643BC, 0x3C03801B, 250); /* confirmed */

18
src/mame/drivers/sigmab98.c
View File

@ -179,6 +179,7 @@ public:
void screen_eof_sammymdl(screen_device &screen, bool state); void screen_eof_sammymdl(screen_device &screen, bool state);
INTERRUPT_GEN_MEMBER(gegege_vblank_interrupt); INTERRUPT_GEN_MEMBER(gegege_vblank_interrupt);
TIMER_DEVICE_CALLBACK_MEMBER(sammymd1_irq); TIMER_DEVICE_CALLBACK_MEMBER(sammymd1_irq);
void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int pri_mask);
}; };
@ -224,11 +225,10 @@ public:
***************************************************************************/ ***************************************************************************/
static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int pri_mask) void sigmab98_state::draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, int pri_mask)
{ {
sigmab98_state *state = machine.driver_data<sigmab98_state>(); UINT8 *end = m_spriteram - 0x10;
UINT8 *end = state->m_spriteram - 0x10; UINT8 *s = end + m_spriteram.bytes();
UINT8 *s = end + state->m_spriteram.bytes();
for ( ; s != end; s -= 0x10 ) for ( ; s != end; s -= 0x10 )
{ {
@ -296,7 +296,7 @@ static void draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const r
{ {
for (x = x0; x != x1; x += dx) for (x = x0; x != x1; x += dx)
{ {
drawgfxzoom_transpen( bitmap, cliprect, machine.gfx[gfx], drawgfxzoom_transpen( bitmap, cliprect, machine().gfx[gfx],
code++, color, code++, color,
flipx, flipy, flipx, flipy,
(sx + x * dim) / 0x10000, (sy + y * dim) / 0x10000, (sx + x * dim) / 0x10000, (sy + y * dim) / 0x10000,
@ -325,10 +325,10 @@ UINT32 sigmab98_state::screen_update_sigmab98(screen_device &screen, bitmap_ind1
bitmap.fill(get_black_pen(machine()), cliprect); bitmap.fill(get_black_pen(machine()), cliprect);
// Draw from priority 3 (bottom, converted to a bitmask) to priority 0 (top) // Draw from priority 3 (bottom, converted to a bitmask) to priority 0 (top)
draw_sprites(machine(), bitmap, cliprect, layers_ctrl & 8); draw_sprites(bitmap, cliprect, layers_ctrl & 8);
draw_sprites(machine(), bitmap, cliprect, layers_ctrl & 4); draw_sprites(bitmap, cliprect, layers_ctrl & 4);
draw_sprites(machine(), bitmap, cliprect, layers_ctrl & 2); draw_sprites(bitmap, cliprect, layers_ctrl & 2);
draw_sprites(machine(), bitmap, cliprect, layers_ctrl & 1); draw_sprites(bitmap, cliprect, layers_ctrl & 1);
return 0; return 0;
} }

47
src/mame/drivers/taitogn.c
View File

@ -393,15 +393,19 @@ public:
DECLARE_DRIVER_INIT(coh3002t_mp); DECLARE_DRIVER_INIT(coh3002t_mp);
DECLARE_DRIVER_INIT(coh3002t); DECLARE_DRIVER_INIT(coh3002t);
DECLARE_MACHINE_RESET(coh3002t); DECLARE_MACHINE_RESET(coh3002t);
void rf5c296_reg_w(ATTR_UNUSED UINT8 reg, UINT8 data);
UINT8 rf5c296_reg_r(ATTR_UNUSED UINT8 reg);
UINT32 gen_flash_r(intelfsh16_device *device, offs_t offset, UINT32 mem_mask);
void gen_flash_w(intelfsh16_device *device, offs_t offset, UINT32 data, UINT32 mem_mask);
void install_handlers(int mode);
}; };
// rf5c296 is very inaccurate at that point, it hardcodes the gnet config // rf5c296 is very inaccurate at that point, it hardcodes the gnet config
static void rf5c296_reg_w(ATTR_UNUSED running_machine &machine, UINT8 reg, UINT8 data) void taitogn_state::rf5c296_reg_w(ATTR_UNUSED UINT8 reg, UINT8 data)
{ {
taitogn_state *state = machine.driver_data<taitogn_state>(); // fprintf(stderr, "rf5c296_reg_w %02x, %02x (%s)\n", reg, data, machine().describe_context());
// fprintf(stderr, "rf5c296_reg_w %02x, %02x (%s)\n", reg, data, machine.describe_context());
switch (reg) switch (reg)
{ {
// Interrupt and General Control Register // Interrupt and General Control Register
@ -409,10 +413,10 @@ static void rf5c296_reg_w(ATTR_UNUSED running_machine &machine, UINT8 reg, UINT8
// Check for card reset // Check for card reset
if (!(data & 0x40)) if (!(data & 0x40))
{ {
ide_controller_device *card = (ide_controller_device *) machine.device(":card"); ide_controller_device *card = (ide_controller_device *) machine().device(":card");
card->reset(); card->reset();
state->m_locked = 0x1ff; m_locked = 0x1ff;
card->ide_set_gnet_readlock(1); card->ide_set_gnet_readlock(1);
} }
break; break;
@ -422,9 +426,9 @@ static void rf5c296_reg_w(ATTR_UNUSED running_machine &machine, UINT8 reg, UINT8
} }
} }
static UINT8 rf5c296_reg_r(ATTR_UNUSED running_machine &machine, UINT8 reg) UINT8 taitogn_state::rf5c296_reg_r(ATTR_UNUSED UINT8 reg)
{ {
// fprintf(stderr, "rf5c296_reg_r %02x (%s)\n", reg, machine.describe_context()); // fprintf(stderr, "rf5c296_reg_r %02x (%s)\n", reg, machine().describe_context());
return 0x00; return 0x00;
} }
@ -439,7 +443,7 @@ WRITE32_MEMBER(taitogn_state::rf5c296_io_w)
if(ACCESSING_BITS_0_7) if(ACCESSING_BITS_0_7)
m_rf5c296_reg = data; m_rf5c296_reg = data;
if(ACCESSING_BITS_8_15) if(ACCESSING_BITS_8_15)
rf5c296_reg_w(machine(), m_rf5c296_reg, data >> 8); rf5c296_reg_w(m_rf5c296_reg, data >> 8);
} }
} }
@ -455,7 +459,7 @@ READ32_MEMBER(taitogn_state::rf5c296_io_r)
if(ACCESSING_BITS_0_7) if(ACCESSING_BITS_0_7)
res |= m_rf5c296_reg; res |= m_rf5c296_reg;
if(ACCESSING_BITS_8_15) if(ACCESSING_BITS_8_15)
res |= rf5c296_reg_r(machine(), m_rf5c296_reg) << 8; res |= rf5c296_reg_r(m_rf5c296_reg) << 8;
return res; return res;
} }
@ -507,7 +511,7 @@ WRITE32_MEMBER(taitogn_state::rf5c296_mem_w)
// Flash handling // Flash handling
static UINT32 gen_flash_r(intelfsh16_device *device, offs_t offset, UINT32 mem_mask) UINT32 taitogn_state::gen_flash_r(intelfsh16_device *device, offs_t offset, UINT32 mem_mask)
{ {
UINT32 res = 0; UINT32 res = 0;
offset *= 2; offset *= 2;
@ -518,7 +522,7 @@ static UINT32 gen_flash_r(intelfsh16_device *device, offs_t offset, UINT32 mem_m
return res; return res;
} }
static void gen_flash_w(intelfsh16_device *device, offs_t offset, UINT32 data, UINT32 mem_mask) void taitogn_state::gen_flash_w(intelfsh16_device *device, offs_t offset, UINT32 data, UINT32 mem_mask)
{ {
offset *= 2; offset *= 2;
if(ACCESSING_BITS_0_15) if(ACCESSING_BITS_0_15)
@ -578,22 +582,21 @@ WRITE32_MEMBER(taitogn_state::flash_s3_w)
gen_flash_w(m_sndflash[2], offset, data, mem_mask); gen_flash_w(m_sndflash[2], offset, data, mem_mask);
} }
static void install_handlers(running_machine &machine, int mode) void taitogn_state::install_handlers(int mode)
{ {
taitogn_state *state = machine.driver_data<taitogn_state>(); address_space &a = machine().device("maincpu")->memory().space(AS_PROGRAM);
address_space &a = machine.device("maincpu")->memory().space(AS_PROGRAM);
if(mode == 0) { if(mode == 0) {
// Mode 0 has access to the subbios, the mn102 flash and the rf5c296 mem zone // Mode 0 has access to the subbios, the mn102 flash and the rf5c296 mem zone
a.install_readwrite_handler(0x1f000000, 0x1f1fffff, read32_delegate(FUNC(taitogn_state::flash_subbios_r),state), write32_delegate(FUNC(taitogn_state::flash_subbios_w),state)); a.install_readwrite_handler(0x1f000000, 0x1f1fffff, read32_delegate(FUNC(taitogn_state::flash_subbios_r),this), write32_delegate(FUNC(taitogn_state::flash_subbios_w),this));
a.install_readwrite_handler(0x1f200000, 0x1f2fffff, read32_delegate(FUNC(taitogn_state::rf5c296_mem_r),state), write32_delegate(FUNC(taitogn_state::rf5c296_mem_w),state)); a.install_readwrite_handler(0x1f200000, 0x1f2fffff, read32_delegate(FUNC(taitogn_state::rf5c296_mem_r),this), write32_delegate(FUNC(taitogn_state::rf5c296_mem_w),this));
a.install_readwrite_handler(0x1f300000, 0x1f37ffff, read32_delegate(FUNC(taitogn_state::flash_mn102_r),state), write32_delegate(FUNC(taitogn_state::flash_mn102_w),state)); a.install_readwrite_handler(0x1f300000, 0x1f37ffff, read32_delegate(FUNC(taitogn_state::flash_mn102_r),this), write32_delegate(FUNC(taitogn_state::flash_mn102_w),this));
a.nop_readwrite(0x1f380000, 0x1f5fffff); a.nop_readwrite(0x1f380000, 0x1f5fffff);
} else { } else {
// Mode 1 has access to the 3 samples flashes // Mode 1 has access to the 3 samples flashes
a.install_readwrite_handler(0x1f000000, 0x1f1fffff, read32_delegate(FUNC(taitogn_state::flash_s1_r),state), write32_delegate(FUNC(taitogn_state::flash_s1_w),state)); a.install_readwrite_handler(0x1f000000, 0x1f1fffff, read32_delegate(FUNC(taitogn_state::flash_s1_r),this), write32_delegate(FUNC(taitogn_state::flash_s1_w),this));
a.install_readwrite_handler(0x1f200000, 0x1f3fffff, read32_delegate(FUNC(taitogn_state::flash_s2_r),state), write32_delegate(FUNC(taitogn_state::flash_s2_w),state)); a.install_readwrite_handler(0x1f200000, 0x1f3fffff, read32_delegate(FUNC(taitogn_state::flash_s2_r),this), write32_delegate(FUNC(taitogn_state::flash_s2_w),this));
a.install_readwrite_handler(0x1f400000, 0x1f5fffff, read32_delegate(FUNC(taitogn_state::flash_s3_r),state), write32_delegate(FUNC(taitogn_state::flash_s3_w),state)); a.install_readwrite_handler(0x1f400000, 0x1f5fffff, read32_delegate(FUNC(taitogn_state::flash_s3_r),this), write32_delegate(FUNC(taitogn_state::flash_s3_w),this));
} }
} }
@ -634,7 +637,7 @@ WRITE32_MEMBER(taitogn_state::control_w)
#endif #endif
if((p ^ m_control) & 0x04) if((p ^ m_control) & 0x04)
install_handlers(machine(), m_control & 4 ? 1 : 0); install_handlers(m_control & 4 ? 1 : 0);
} }
WRITE32_MEMBER(taitogn_state::control2_w) WRITE32_MEMBER(taitogn_state::control2_w)
@ -785,7 +788,7 @@ DRIVER_INIT_MEMBER(taitogn_state,coh3002t_mp)
MACHINE_RESET_MEMBER(taitogn_state,coh3002t) MACHINE_RESET_MEMBER(taitogn_state,coh3002t)
{ {
m_locked = 0x1ff; m_locked = 0x1ff;
install_handlers(machine(), 0); install_handlers(0);
m_control = 0; m_control = 0;
ide_controller_device *card = (ide_controller_device *) machine().device(":card"); ide_controller_device *card = (ide_controller_device *) machine().device(":card");

93
src/mame/drivers/taitotz.c
View File

@ -614,13 +614,20 @@ public:
DECLARE_READ8_MEMBER(tlcs_ide1_r); DECLARE_READ8_MEMBER(tlcs_ide1_r);
DECLARE_WRITE8_MEMBER(tlcs_ide1_w); DECLARE_WRITE8_MEMBER(tlcs_ide1_w);
DECLARE_WRITE_LINE_MEMBER(ide_interrupt); DECLARE_WRITE_LINE_MEMBER(ide_interrupt);
void taitotz_exit();
void draw_tile(taitotz_state *state, UINT32 pos, UINT32 tile);
UINT32 video_mem_r(taitotz_state *state, UINT32 address);
void video_mem_w(taitotz_state *state, UINT32 address, UINT32 data);
UINT32 video_reg_r(taitotz_state *state, UINT32 reg);
void video_reg_w(taitotz_state *state, UINT32 reg, UINT32 data);
void init_taitotz_152();
void init_taitotz_111a();
}; };
/* /*
static void taitotz_exit(running_machine &machine) void taitotz_state::taitotz_exit()
{ {
taitotz_state *state = machine.driver_data<taitotz_state>();
FILE *file; FILE *file;
int i; int i;
@ -628,30 +635,30 @@ static void taitotz_exit(running_machine &machine)
file = fopen("screen_ram.bin","wb"); file = fopen("screen_ram.bin","wb");
for (i=0; i < 0x200000; i++) for (i=0; i < 0x200000; i++)
{ {
fputc((UINT8)(state->m_screen_ram[i] >> 24), file); fputc((UINT8)(m_screen_ram[i] >> 24), file);
fputc((UINT8)(state->m_screen_ram[i] >> 16), file); fputc((UINT8)(m_screen_ram[i] >> 16), file);
fputc((UINT8)(state->m_screen_ram[i] >> 8), file); fputc((UINT8)(m_screen_ram[i] >> 8), file);
fputc((UINT8)(state->m_screen_ram[i] >> 0), file); fputc((UINT8)(m_screen_ram[i] >> 0), file);
} }
fclose(file); fclose(file);
file = fopen("frame_ram.bin","wb"); file = fopen("frame_ram.bin","wb");
for (i=0; i < 0x80000; i++) for (i=0; i < 0x80000; i++)
{ {
fputc((UINT8)(state->m_frame_ram[i] >> 24), file); fputc((UINT8)(m_frame_ram[i] >> 24), file);
fputc((UINT8)(state->m_frame_ram[i] >> 16), file); fputc((UINT8)(m_frame_ram[i] >> 16), file);
fputc((UINT8)(state->m_frame_ram[i] >> 8), file); fputc((UINT8)(m_frame_ram[i] >> 8), file);
fputc((UINT8)(state->m_frame_ram[i] >> 0), file); fputc((UINT8)(m_frame_ram[i] >> 0), file);
} }
fclose(file); fclose(file);
file = fopen("texture_ram.bin","wb"); file = fopen("texture_ram.bin","wb");
for (i=0; i < 0x800000; i++) for (i=0; i < 0x800000; i++)
{ {
fputc((UINT8)(state->m_texture_ram[i] >> 24), file); fputc((UINT8)(m_texture_ram[i] >> 24), file);
fputc((UINT8)(state->m_texture_ram[i] >> 16), file); fputc((UINT8)(m_texture_ram[i] >> 16), file);
fputc((UINT8)(state->m_texture_ram[i] >> 8), file); fputc((UINT8)(m_texture_ram[i] >> 8), file);
fputc((UINT8)(state->m_texture_ram[i] >> 0), file); fputc((UINT8)(m_texture_ram[i] >> 0), file);
} }
fclose(file); fclose(file);
@ -1396,7 +1403,7 @@ UINT32 taitotz_state::screen_update_taitotz(screen_device &screen, bitmap_rgb32
return 0; return 0;
} }
static void draw_tile(taitotz_state *state, UINT32 pos, UINT32 tile) void taitotz_state::draw_tile(taitotz_state *state, UINT32 pos, UINT32 tile)
{ {
int tileu = (tile & 0x1f) * 16; int tileu = (tile & 0x1f) * 16;
int tilev = ((tile >> 5)) * 16; int tilev = ((tile >> 5)) * 16;
@ -1404,8 +1411,8 @@ static void draw_tile(taitotz_state *state, UINT32 pos, UINT32 tile)
int tilex = (pos & 0x1f) * 16; int tilex = (pos & 0x1f) * 16;
int tiley = ((pos >> 5) & 0x1f) * 16; int tiley = ((pos >> 5) & 0x1f) * 16;
UINT16 *src_tile = (UINT16*)&state->m_screen_ram[0x180000]; UINT16 *src_tile = (UINT16*)&m_screen_ram[0x180000];
UINT16 *dst = (UINT16*)&state->m_screen_ram[state->m_scr_base]; UINT16 *dst = (UINT16*)&m_screen_ram[m_scr_base];
int v = tilev; int v = tilev;
@ -1438,19 +1445,19 @@ static void draw_tile(taitotz_state *state, UINT32 pos, UINT32 tile)
batlgr2 into 0x9e0000 batlgr2 into 0x9e0000
*/ */
static UINT32 video_mem_r(taitotz_state *state, UINT32 address) UINT32 taitotz_state::video_mem_r(taitotz_state *state, UINT32 address)
{ {
if (address >= 0x800000 && address < 0x1000000) if (address >= 0x800000 && address < 0x1000000)
{ {
return state->m_screen_ram[address - 0x800000]; return m_screen_ram[address - 0x800000];
} }
else if (address >= 0x1000000 && address < 0x1800000) else if (address >= 0x1000000 && address < 0x1800000)
{ {
return state->m_texture_ram[address - 0x1000000]; return m_texture_ram[address - 0x1000000];
} }
else if (address >= 0x1800000 && address < 0x1880000) else if (address >= 0x1800000 && address < 0x1880000)
{ {
return state->m_frame_ram[address - 0x1800000]; return m_frame_ram[address - 0x1800000];
} }
else else
{ {
@ -1459,19 +1466,19 @@ static UINT32 video_mem_r(taitotz_state *state, UINT32 address)
} }
} }
static void video_mem_w(taitotz_state *state, UINT32 address, UINT32 data) void taitotz_state::video_mem_w(taitotz_state *state, UINT32 address, UINT32 data)
{ {
if (address >= 0x800000 && address < 0x1000000) if (address >= 0x800000 && address < 0x1000000)
{ {
state->m_screen_ram[address - 0x800000] = data; m_screen_ram[address - 0x800000] = data;
} }
else if (address >= 0x1000000 && address < 0x1800000) else if (address >= 0x1000000 && address < 0x1800000)
{ {
state->m_texture_ram[address - 0x1000000] = data; m_texture_ram[address - 0x1000000] = data;
} }
else if (address >= 0x1800000 && address < 0x1880000) else if (address >= 0x1800000 && address < 0x1880000)
{ {
state->m_frame_ram[address - 0x1800000] = data; m_frame_ram[address - 0x1800000] = data;
} }
else else
{ {
@ -1479,7 +1486,7 @@ static void video_mem_w(taitotz_state *state, UINT32 address, UINT32 data)
} }
} }
static UINT32 video_reg_r(taitotz_state *state, UINT32 reg) UINT32 taitotz_state::video_reg_r(taitotz_state *state, UINT32 reg)
{ {
switch ((reg >> 28) & 0xf) switch ((reg >> 28) & 0xf)
{ {
@ -1487,8 +1494,8 @@ static UINT32 video_reg_r(taitotz_state *state, UINT32 reg)
{ {
if (reg == 0x10000105) // Gets spammed a lot. Probably a status register. if (reg == 0x10000105) // Gets spammed a lot. Probably a status register.
{ {
state->m_reg105 ^= 0xffffffff; m_reg105 ^= 0xffffffff;
return state->m_reg105; return m_reg105;
} }
logerror("video_reg_r: reg: %08X\n", reg); logerror("video_reg_r: reg: %08X\n", reg);
@ -1503,7 +1510,7 @@ static UINT32 video_reg_r(taitotz_state *state, UINT32 reg)
if (subreg < 0x10) if (subreg < 0x10)
{ {
return state->m_video_unk_reg[subreg]; return m_video_unk_reg[subreg];
} }
break; break;
} }
@ -1542,7 +1549,7 @@ video_reg_w: r: 20000003 d: 019501AA
video_reg_w: r: 20000004 d: 00000000 video_reg_w: r: 20000004 d: 00000000
*/ */
static void video_reg_w(taitotz_state *state, UINT32 reg, UINT32 data) void taitotz_state::video_reg_w(taitotz_state *state, UINT32 reg, UINT32 data)
{ {
switch ((reg >> 28) & 0xf) switch ((reg >> 28) & 0xf)
{ {
@ -1563,7 +1570,7 @@ static void video_reg_w(taitotz_state *state, UINT32 reg, UINT32 data)
int subreg = reg & 0xfffffff; int subreg = reg & 0xfffffff;
if (subreg < 0x10) if (subreg < 0x10)
{ {
state->m_video_unk_reg[subreg] = data; m_video_unk_reg[subreg] = data;
} }
logerror("video_reg_w: reg: %08X data: %08X\n", reg, data); logerror("video_reg_w: reg: %08X data: %08X\n", reg, data);
break; break;
@ -1577,8 +1584,8 @@ static void video_reg_w(taitotz_state *state, UINT32 reg, UINT32 data)
} }
case 0xb: // RAM write? case 0xb: // RAM write?
{ {
video_mem_w(state, state->m_video_ram_ptr, data); video_mem_w(state, m_video_ram_ptr, data);
state->m_video_ram_ptr++; m_video_ram_ptr++;
break; break;
} }
default: default:
@ -2596,17 +2603,17 @@ MACHINE_CONFIG_END
// Init for BIOS v1.52 // Init for BIOS v1.52
static void init_taitotz_152(running_machine &machine) void taitotz_state::init_taitotz_152()
{ {
UINT32 *rom = (UINT32*)machine.root_device().memregion("user1")->base(); UINT32 *rom = (UINT32*)machine().root_device().memregion("user1")->base();
rom[(0x2c87c^4)/4] = 0x38600000; // skip sound load timeout... rom[(0x2c87c^4)/4] = 0x38600000; // skip sound load timeout...
// rom[(0x2c620^4)/4] = 0x48000014; // ID check skip (not needed with correct serial number) // rom[(0x2c620^4)/4] = 0x48000014; // ID check skip (not needed with correct serial number)
} }
// Init for BIOS 1.11a // Init for BIOS 1.11a
static void init_taitotz_111a(running_machine &machine) void taitotz_state::init_taitotz_111a()
{ {
UINT32 *rom = (UINT32*)machine.root_device().memregion("user1")->base(); UINT32 *rom = (UINT32*)machine().root_device().memregion("user1")->base();
rom[(0x2b748^4)/4] = 0x480000b8; // skip sound load timeout rom[(0x2b748^4)/4] = 0x480000b8; // skip sound load timeout
} }
@ -2624,7 +2631,7 @@ static const char RAIZPIN_HDD_SERIAL[] = // "691934013492 "
DRIVER_INIT_MEMBER(taitotz_state,landhigh) DRIVER_INIT_MEMBER(taitotz_state,landhigh)
{ {
init_taitotz_152(machine()); init_taitotz_152();
m_hdd_serial_number = LANDHIGH_HDD_SERIAL; m_hdd_serial_number = LANDHIGH_HDD_SERIAL;
@ -2635,7 +2642,7 @@ DRIVER_INIT_MEMBER(taitotz_state,landhigh)
DRIVER_INIT_MEMBER(taitotz_state,batlgear) DRIVER_INIT_MEMBER(taitotz_state,batlgear)
{ {
init_taitotz_111a(machine()); init_taitotz_111a();
// unknown, not used by BIOS 1.11a // unknown, not used by BIOS 1.11a
m_hdd_serial_number = NULL; m_hdd_serial_number = NULL;
@ -2647,7 +2654,7 @@ DRIVER_INIT_MEMBER(taitotz_state,batlgear)
DRIVER_INIT_MEMBER(taitotz_state,batlgr2) DRIVER_INIT_MEMBER(taitotz_state,batlgr2)
{ {
init_taitotz_152(machine()); init_taitotz_152();
m_hdd_serial_number = BATLGR2_HDD_SERIAL; m_hdd_serial_number = BATLGR2_HDD_SERIAL;
@ -2658,7 +2665,7 @@ DRIVER_INIT_MEMBER(taitotz_state,batlgr2)
DRIVER_INIT_MEMBER(taitotz_state,batlgr2a) DRIVER_INIT_MEMBER(taitotz_state,batlgr2a)
{ {
init_taitotz_152(machine()); init_taitotz_152();
m_hdd_serial_number = BATLGR2A_HDD_SERIAL; m_hdd_serial_number = BATLGR2A_HDD_SERIAL;
@ -2669,7 +2676,7 @@ DRIVER_INIT_MEMBER(taitotz_state,batlgr2a)
DRIVER_INIT_MEMBER(taitotz_state,pwrshovl) DRIVER_INIT_MEMBER(taitotz_state,pwrshovl)
{ {
init_taitotz_111a(machine()); init_taitotz_111a();
// unknown, not used by BIOS 1.11a // unknown, not used by BIOS 1.11a
m_hdd_serial_number = NULL; m_hdd_serial_number = NULL;
@ -2681,7 +2688,7 @@ DRIVER_INIT_MEMBER(taitotz_state,pwrshovl)
DRIVER_INIT_MEMBER(taitotz_state,raizpin) DRIVER_INIT_MEMBER(taitotz_state,raizpin)
{ {
init_taitotz_152(machine()); init_taitotz_152();
m_hdd_serial_number = RAIZPIN_HDD_SERIAL; m_hdd_serial_number = RAIZPIN_HDD_SERIAL;

83
src/mame/drivers/tmaster.c
View File

@ -138,7 +138,7 @@ public:
UINT16 m_addr; UINT16 m_addr;
UINT32 m_gfx_offs; UINT32 m_gfx_offs;
UINT32 m_gfx_size; UINT32 m_gfx_size;
int (*m_compute_addr) (UINT16 reg_low, UINT16 reg_mid, UINT16 reg_high); int (tmaster_state::*m_compute_addr) (UINT16 reg_low, UINT16 reg_mid, UINT16 reg_high);
UINT16 m_galgames_cart; UINT16 m_galgames_cart;
UINT32 m_palette_offset; UINT32 m_palette_offset;
UINT8 m_palette_index; UINT8 m_palette_index;
@ -185,6 +185,11 @@ public:
DECLARE_VIDEO_START(galgames); DECLARE_VIDEO_START(galgames);
UINT32 screen_update_tmaster(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); UINT32 screen_update_tmaster(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
TIMER_DEVICE_CALLBACK_MEMBER(tm3k_interrupt); TIMER_DEVICE_CALLBACK_MEMBER(tm3k_interrupt);
UINT8 binary_to_BCD(UINT8 data);
int tmaster_compute_addr(UINT16 reg_low, UINT16 reg_mid, UINT16 reg_high);
int galgames_compute_addr(UINT16 reg_low, UINT16 reg_mid, UINT16 reg_high);
void tmaster_draw();
void galgames_update_rombank(UINT32 cart);
}; };
@ -248,7 +253,7 @@ static const microtouch_interface tmaster_microtouch_config =
***************************************************************************/ ***************************************************************************/
static UINT8 binary_to_BCD(UINT8 data) UINT8 tmaster_state::binary_to_BCD(UINT8 data)
{ {
data %= 100; data %= 100;
@ -328,12 +333,12 @@ WRITE16_MEMBER(tmaster_state::rtc_w)
***************************************************************************/ ***************************************************************************/
static int tmaster_compute_addr(UINT16 reg_low, UINT16 reg_mid, UINT16 reg_high) int tmaster_state::tmaster_compute_addr(UINT16 reg_low, UINT16 reg_mid, UINT16 reg_high)
{ {
return (reg_low & 0xff) | ((reg_mid & 0x1ff) << 8) | (reg_high << 17); return (reg_low & 0xff) | ((reg_mid & 0x1ff) << 8) | (reg_high << 17);
} }
static int galgames_compute_addr(UINT16 reg_low, UINT16 reg_mid, UINT16 reg_high) int tmaster_state::galgames_compute_addr(UINT16 reg_low, UINT16 reg_mid, UINT16 reg_high)
{ {
return reg_low | (reg_mid << 16); return reg_low | (reg_mid << 16);
} }
@ -350,13 +355,13 @@ VIDEO_START_MEMBER(tmaster_state,tmaster)
} }
} }
m_compute_addr = tmaster_compute_addr; m_compute_addr = &tmaster_state::tmaster_compute_addr;
} }
VIDEO_START_MEMBER(tmaster_state,galgames) VIDEO_START_MEMBER(tmaster_state,galgames)
{ {
VIDEO_START_CALL_MEMBER( tmaster ); VIDEO_START_CALL_MEMBER( tmaster );
m_compute_addr = galgames_compute_addr; m_compute_addr = &tmaster_state::galgames_compute_addr;
} }
UINT32 tmaster_state::screen_update_tmaster(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) UINT32 tmaster_state::screen_update_tmaster(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
@ -392,35 +397,34 @@ WRITE16_MEMBER(tmaster_state::tmaster_addr_w)
COMBINE_DATA( &m_addr ); COMBINE_DATA( &m_addr );
} }
static void tmaster_draw(running_machine &machine) void tmaster_state::tmaster_draw()
{ {
tmaster_state *state = machine.driver_data<tmaster_state>();
int x,y,x0,x1,y0,y1,dx,dy,flipx,flipy,sx,sy,sw,sh, addr, mode, layer,buffer, color; int x,y,x0,x1,y0,y1,dx,dy,flipx,flipy,sx,sy,sw,sh, addr, mode, layer,buffer, color;
UINT8 *gfxdata = state->memregion( "blitter" )->base() + state->m_gfx_offs; UINT8 *gfxdata = memregion( "blitter" )->base() + m_gfx_offs;
UINT16 pen; UINT16 pen;
buffer = (state->m_regs[0x02/2] >> 8) & 3; // 1 bit per layer, selects the currently displayed buffer buffer = (m_regs[0x02/2] >> 8) & 3; // 1 bit per layer, selects the currently displayed buffer
sw = state->m_regs[0x04/2]; sw = m_regs[0x04/2];
sx = state->m_regs[0x06/2]; sx = m_regs[0x06/2];
sh = state->m_regs[0x08/2] + 1; sh = m_regs[0x08/2] + 1;
sy = state->m_regs[0x0a/2]; sy = m_regs[0x0a/2];
addr = (*state->m_compute_addr)( addr = (this->*m_compute_addr)(
state->m_regs[0x0c/2], m_regs[0x0c/2],
state->m_regs[0x0e/2], state->m_addr); m_regs[0x0e/2], m_addr);
mode = state->m_regs[0x10/2]; mode = m_regs[0x10/2];
layer = (mode >> 7) & 1; // layer to draw to layer = (mode >> 7) & 1; // layer to draw to
buffer = ((mode >> 6) & 1) ^ ((buffer >> layer) & 1); // bit 6 selects whether to use the opposite buffer to that displayed buffer = ((mode >> 6) & 1) ^ ((buffer >> layer) & 1); // bit 6 selects whether to use the opposite buffer to that displayed
bitmap_ind16 &bitmap = state->m_bitmap[layer][buffer]; bitmap_ind16 &bitmap = m_bitmap[layer][buffer];
addr <<= 1; addr <<= 1;
#ifdef MAME_DEBUG #ifdef MAME_DEBUG
#if 0 #if 0
logerror("%s: blit w %03x, h %02x, x %03x, y %02x, src %06x, fill/addr %04x, repl/color %04x, mode %02x\n", machine.describe_context(), logerror("%s: blit w %03x, h %02x, x %03x, y %02x, src %06x, fill/addr %04x, repl/color %04x, mode %02x\n", machine().describe_context(),
sw,sh,sx,sy, addr, state->m_addr, state->m_color, mode sw,sh,sx,sy, addr, m_addr, m_color, mode
); );
#endif #endif
#endif #endif
@ -437,23 +441,23 @@ static void tmaster_draw(running_machine &machine)
sx = (sx & 0x7fff) - (sx & 0x8000); sx = (sx & 0x7fff) - (sx & 0x8000);
sy = (sy & 0x7fff) - (sy & 0x8000); sy = (sy & 0x7fff) - (sy & 0x8000);
color = (state->m_color & 0x0f) << 8; color = (m_color & 0x0f) << 8;
switch (mode & 0x20) switch (mode & 0x20)
{ {
case 0x00: // blit with transparency case 0x00: // blit with transparency
if (addr > state->m_gfx_size - sw*sh) if (addr > m_gfx_size - sw*sh)
{ {
logerror("%s: blit error, addr %06x out of bounds\n", machine.describe_context(),addr); logerror("%s: blit error, addr %06x out of bounds\n", machine().describe_context(),addr);
addr = state->m_gfx_size - sw*sh; addr = m_gfx_size - sw*sh;
} }
if ( mode & 0x200 ) if ( mode & 0x200 )
{ {
// copy from ROM, replacing occurrences of src pen with dst pen // copy from ROM, replacing occurrences of src pen with dst pen
UINT8 dst_pen = (state->m_color >> 8) & 0xff; UINT8 dst_pen = (m_color >> 8) & 0xff;
UINT8 src_pen = (state->m_color >> 0) & 0xff; UINT8 src_pen = (m_color >> 0) & 0xff;
for (y = y0; y != y1; y += dy) for (y = y0; y != y1; y += dy)
{ {
@ -487,7 +491,7 @@ static void tmaster_draw(running_machine &machine)
break; break;
case 0x20: // solid fill case 0x20: // solid fill
pen = ((state->m_addr >> 8) & 0xff) + color; pen = ((m_addr >> 8) & 0xff) + color;
if ((pen & 0xff) == 0xff) if ((pen & 0xff) == 0xff)
pen = 0xff; pen = 0xff;
@ -511,7 +515,7 @@ WRITE16_MEMBER(tmaster_state::tmaster_blitter_w)
switch (offset*2) switch (offset*2)
{ {
case 0x0e: case 0x0e:
tmaster_draw(machine()); tmaster_draw();
machine().device("maincpu")->execute().set_input_line(2, HOLD_LINE); machine().device("maincpu")->execute().set_input_line(2, HOLD_LINE);
break; break;
} }
@ -669,17 +673,16 @@ WRITE16_MEMBER(tmaster_state::galgames_okiram_w)
// Carts (preliminary, PIC communication is not implemented) // Carts (preliminary, PIC communication is not implemented)
static void galgames_update_rombank(running_machine &machine, UINT32 cart) void tmaster_state::galgames_update_rombank(UINT32 cart)
{ {
tmaster_state *state = machine.driver_data<tmaster_state>(); m_galgames_cart = cart;
state->m_galgames_cart = cart;
state->m_gfx_offs = 0x200000 * cart; m_gfx_offs = 0x200000 * cart;
if (state->membank(GALGAMES_BANK_000000_R)->entry() == GALGAMES_RAM) if (membank(GALGAMES_BANK_000000_R)->entry() == GALGAMES_RAM)
state->membank(GALGAMES_BANK_200000_R)->set_entry(GALGAMES_ROM0 + state->m_galgames_cart); // rom membank(GALGAMES_BANK_200000_R)->set_entry(GALGAMES_ROM0 + m_galgames_cart); // rom
state->membank(GALGAMES_BANK_240000_R)->set_entry(GALGAMES_ROM0 + state->m_galgames_cart); // rom membank(GALGAMES_BANK_240000_R)->set_entry(GALGAMES_ROM0 + m_galgames_cart); // rom
} }
WRITE16_MEMBER(tmaster_state::galgames_cart_sel_w) WRITE16_MEMBER(tmaster_state::galgames_cart_sel_w)
@ -703,12 +706,12 @@ WRITE16_MEMBER(tmaster_state::galgames_cart_sel_w)
case 0x03: case 0x03:
case 0x04: case 0x04:
machine().device<eeprom_device>(galgames_eeprom_names[data & 0xff])->set_cs_line(CLEAR_LINE); machine().device<eeprom_device>(galgames_eeprom_names[data & 0xff])->set_cs_line(CLEAR_LINE);
galgames_update_rombank(machine(), data & 0xff); galgames_update_rombank(data & 0xff);
break; break;
default: default:
machine().device<eeprom_device>(galgames_eeprom_names[0])->set_cs_line(CLEAR_LINE); machine().device<eeprom_device>(galgames_eeprom_names[0])->set_cs_line(CLEAR_LINE);
galgames_update_rombank(machine(), 0); galgames_update_rombank(0);
logerror("%06x: unknown cart sel = %04x\n", space.device().safe_pc(), data); logerror("%06x: unknown cart sel = %04x\n", space.device().safe_pc(), data);
break; break;
} }
@ -730,7 +733,7 @@ WRITE16_MEMBER(tmaster_state::galgames_cart_clock_w)
if ((data & 0xf7) == 0x05) if ((data & 0xf7) == 0x05)
{ {
membank(GALGAMES_BANK_000000_R)->set_entry(GALGAMES_RAM); // ram membank(GALGAMES_BANK_000000_R)->set_entry(GALGAMES_RAM); // ram
galgames_update_rombank(machine(), m_galgames_cart); galgames_update_rombank(m_galgames_cart);
logerror("%06x: romram bank = %04x\n", space.device().safe_pc(), data); logerror("%06x: romram bank = %04x\n", space.device().safe_pc(), data);
} }
else else
@ -972,7 +975,7 @@ MACHINE_RESET_MEMBER(tmaster_state,galgames)
membank(GALGAMES_BANK_240000_R)->set_entry(GALGAMES_ROM0); // rom membank(GALGAMES_BANK_240000_R)->set_entry(GALGAMES_ROM0); // rom
galgames_update_rombank(machine(), 0); galgames_update_rombank(0);
machine().device("maincpu")->reset(); machine().device("maincpu")->reset();
} }

210
src/mame/drivers/vegas.c
View File

@ -505,6 +505,12 @@ public:
UINT32 screen_update_vegas(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect); UINT32 screen_update_vegas(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
TIMER_CALLBACK_MEMBER(nile_timer_callback); TIMER_CALLBACK_MEMBER(nile_timer_callback);
void remap_dynamic_addresses(); void remap_dynamic_addresses();
void update_nile_irqs();
void update_sio_irqs();
inline void _add_dynamic_address(offs_t start, offs_t end, read32_space_func read, write32_space_func write, const char *rdname, const char *wrname);
inline void _add_dynamic_device_address(device_t *device, offs_t start, offs_t end, read32_device_func read, write32_device_func write, const char *rdname, const char *wrname);
void init_common(int ioasic, int serialnum);
}; };
@ -843,49 +849,48 @@ static WRITE32_HANDLER( pci_3dfx_w )
* *
*************************************/ *************************************/
static void update_nile_irqs(running_machine &machine) void vegas_state::update_nile_irqs()
{ {
vegas_state *state = machine.driver_data<vegas_state>(); UINT32 intctll = m_nile_regs[NREG_INTCTRL+0];
UINT32 intctll = state->m_nile_regs[NREG_INTCTRL+0]; UINT32 intctlh = m_nile_regs[NREG_INTCTRL+1];
UINT32 intctlh = state->m_nile_regs[NREG_INTCTRL+1];
UINT8 irq[6]; UINT8 irq[6];
int i; int i;
/* check for UART transmit IRQ enable and synthsize one */ /* check for UART transmit IRQ enable and synthsize one */
if (state->m_nile_regs[NREG_UARTIER] & 2) if (m_nile_regs[NREG_UARTIER] & 2)
state->m_nile_irq_state |= 0x0010; m_nile_irq_state |= 0x0010;
else else
state->m_nile_irq_state &= ~0x0010; m_nile_irq_state &= ~0x0010;
irq[0] = irq[1] = irq[2] = irq[3] = irq[4] = irq[5] = 0; irq[0] = irq[1] = irq[2] = irq[3] = irq[4] = irq[5] = 0;
state->m_nile_regs[NREG_INTSTAT0+0] = 0; m_nile_regs[NREG_INTSTAT0+0] = 0;
state->m_nile_regs[NREG_INTSTAT0+1] = 0; m_nile_regs[NREG_INTSTAT0+1] = 0;
state->m_nile_regs[NREG_INTSTAT1+0] = 0; m_nile_regs[NREG_INTSTAT1+0] = 0;
state->m_nile_regs[NREG_INTSTAT1+1] = 0; m_nile_regs[NREG_INTSTAT1+1] = 0;
/* handle the lower interrupts */ /* handle the lower interrupts */
for (i = 0; i < 8; i++) for (i = 0; i < 8; i++)
if (state->m_nile_irq_state & (1 << i)) if (m_nile_irq_state & (1 << i))
if ((intctll >> (4*i+3)) & 1) if ((intctll >> (4*i+3)) & 1)
{ {
int vector = (intctll >> (4*i)) & 7; int vector = (intctll >> (4*i)) & 7;
if (vector < 6) if (vector < 6)
{ {
irq[vector] = 1; irq[vector] = 1;
state->m_nile_regs[NREG_INTSTAT0 + vector/2] |= 1 << (i + 16*(vector&1)); m_nile_regs[NREG_INTSTAT0 + vector/2] |= 1 << (i + 16*(vector&1));
} }
} }
/* handle the upper interrupts */ /* handle the upper interrupts */
for (i = 0; i < 8; i++) for (i = 0; i < 8; i++)
if (state->m_nile_irq_state & (1 << (i+8))) if (m_nile_irq_state & (1 << (i+8)))
if ((intctlh >> (4*i+3)) & 1) if ((intctlh >> (4*i+3)) & 1)
{ {
int vector = (intctlh >> (4*i)) & 7; int vector = (intctlh >> (4*i)) & 7;
if (vector < 6) if (vector < 6)
{ {
irq[vector] = 1; irq[vector] = 1;
state->m_nile_regs[NREG_INTSTAT0 + vector/2] |= 1 << (i + 8 + 16*(vector&1)); m_nile_regs[NREG_INTSTAT0 + vector/2] |= 1 << (i + 8 + 16*(vector&1));
} }
} }
@ -896,12 +901,12 @@ static void update_nile_irqs(running_machine &machine)
if (irq[i]) if (irq[i])
{ {
if (LOG_NILE_IRQS) logerror(" 1"); if (LOG_NILE_IRQS) logerror(" 1");
machine.device("maincpu")->execute().set_input_line(MIPS3_IRQ0 + i, ASSERT_LINE); machine().device("maincpu")->execute().set_input_line(MIPS3_IRQ0 + i, ASSERT_LINE);
} }
else else
{ {
if (LOG_NILE_IRQS) logerror(" 0"); if (LOG_NILE_IRQS) logerror(" 0");
machine.device("maincpu")->execute().set_input_line(MIPS3_IRQ0 + i, CLEAR_LINE); machine().device("maincpu")->execute().set_input_line(MIPS3_IRQ0 + i, CLEAR_LINE);
} }
} }
if (LOG_NILE_IRQS) logerror("\n"); if (LOG_NILE_IRQS) logerror("\n");
@ -929,7 +934,7 @@ TIMER_CALLBACK_MEMBER(vegas_state::nile_timer_callback)
if (which == 3) if (which == 3)
m_nile_irq_state |= 1 << 5; m_nile_irq_state |= 1 << 5;
update_nile_irqs(machine()); update_nile_irqs();
} }
@ -1073,21 +1078,21 @@ static WRITE32_HANDLER( nile_w )
case NREG_INTCTRL+1: /* Interrupt control */ case NREG_INTCTRL+1: /* Interrupt control */
if (LOG_NILE) logerror("%08X:NILE WRITE: interrupt control(%03X) = %08X & %08X\n", space.device().safe_pc(), offset*4, data, mem_mask); if (LOG_NILE) logerror("%08X:NILE WRITE: interrupt control(%03X) = %08X & %08X\n", space.device().safe_pc(), offset*4, data, mem_mask);
logit = 0; logit = 0;
update_nile_irqs(space.machine()); state->update_nile_irqs();
break; break;
case NREG_INTSTAT0+0: /* Interrupt status 0 */ case NREG_INTSTAT0+0: /* Interrupt status 0 */
case NREG_INTSTAT0+1: /* Interrupt status 0 */ case NREG_INTSTAT0+1: /* Interrupt status 0 */
if (LOG_NILE) logerror("%08X:NILE WRITE: interrupt status 0(%03X) = %08X & %08X\n", space.device().safe_pc(), offset*4, data, mem_mask); if (LOG_NILE) logerror("%08X:NILE WRITE: interrupt status 0(%03X) = %08X & %08X\n", space.device().safe_pc(), offset*4, data, mem_mask);
logit = 0; logit = 0;
update_nile_irqs(space.machine()); state->update_nile_irqs();
break; break;
case NREG_INTSTAT1+0: /* Interrupt status 1 */ case NREG_INTSTAT1+0: /* Interrupt status 1 */
case NREG_INTSTAT1+1: /* Interrupt status 1 */ case NREG_INTSTAT1+1: /* Interrupt status 1 */
if (LOG_NILE) logerror("%08X:NILE WRITE: interrupt status 1/enable(%03X) = %08X & %08X\n", space.device().safe_pc(), offset*4, data, mem_mask); if (LOG_NILE) logerror("%08X:NILE WRITE: interrupt status 1/enable(%03X) = %08X & %08X\n", space.device().safe_pc(), offset*4, data, mem_mask);
logit = 0; logit = 0;
update_nile_irqs(space.machine()); state->update_nile_irqs();
break; break;
case NREG_INTCLR+0: /* Interrupt clear */ case NREG_INTCLR+0: /* Interrupt clear */
@ -1095,7 +1100,7 @@ static WRITE32_HANDLER( nile_w )
if (LOG_NILE) logerror("%08X:NILE WRITE: interrupt clear(%03X) = %08X & %08X\n", space.device().safe_pc(), offset*4, data, mem_mask); if (LOG_NILE) logerror("%08X:NILE WRITE: interrupt clear(%03X) = %08X & %08X\n", space.device().safe_pc(), offset*4, data, mem_mask);
logit = 0; logit = 0;
state->m_nile_irq_state &= ~(state->m_nile_regs[offset] & ~0xf00); state->m_nile_irq_state &= ~(state->m_nile_regs[offset] & ~0xf00);
update_nile_irqs(space.machine()); state->update_nile_irqs();
break; break;
case NREG_INTPPES+0: /* PCI Interrupt control */ case NREG_INTPPES+0: /* PCI Interrupt control */
@ -1170,7 +1175,7 @@ static WRITE32_HANDLER( nile_w )
logit = 0; logit = 0;
break; break;
case NREG_UARTIER: /* serial interrupt enable */ case NREG_UARTIER: /* serial interrupt enable */
update_nile_irqs(space.machine()); state->update_nile_irqs();
break; break;
case NREG_VID: case NREG_VID:
@ -1227,7 +1232,7 @@ WRITE_LINE_MEMBER(vegas_state::ide_interrupt)
m_nile_irq_state |= 0x800; m_nile_irq_state |= 0x800;
else else
m_nile_irq_state &= ~0x800; m_nile_irq_state &= ~0x800;
update_nile_irqs(machine()); update_nile_irqs();
} }
@ -1238,14 +1243,13 @@ WRITE_LINE_MEMBER(vegas_state::ide_interrupt)
* *
*************************************/ *************************************/
static void update_sio_irqs(running_machine &machine) void vegas_state::update_sio_irqs()
{ {
vegas_state *state = machine.driver_data<vegas_state>(); if (m_sio_irq_state & m_sio_irq_enable)
if (state->m_sio_irq_state & state->m_sio_irq_enable) m_nile_irq_state |= 0x400;
state->m_nile_irq_state |= 0x400;
else else
state->m_nile_irq_state &= ~0x400; m_nile_irq_state &= ~0x400;
update_nile_irqs(machine); update_nile_irqs();
} }
@ -1255,7 +1259,7 @@ static void vblank_assert(device_t *device, int state)
if (!drvstate->m_vblank_state && state) if (!drvstate->m_vblank_state && state)
{ {
drvstate->m_sio_irq_state |= 0x20; drvstate->m_sio_irq_state |= 0x20;
update_sio_irqs(device->machine()); drvstate->update_sio_irqs();
} }
drvstate->m_vblank_state = state; drvstate->m_vblank_state = state;
@ -1274,7 +1278,7 @@ static void ioasic_irq(running_machine &machine, int state)
drvstate->m_sio_irq_state |= 0x04; drvstate->m_sio_irq_state |= 0x04;
else else
drvstate->m_sio_irq_state &= ~0x04; drvstate->m_sio_irq_state &= ~0x04;
update_sio_irqs(machine); drvstate->update_sio_irqs();
} }
@ -1285,7 +1289,7 @@ static void ethernet_interrupt(device_t *device, int state)
drvstate->m_sio_irq_state |= 0x10; drvstate->m_sio_irq_state |= 0x10;
else else
drvstate->m_sio_irq_state &= ~0x10; drvstate->m_sio_irq_state &= ~0x10;
update_sio_irqs(device->machine()); drvstate->update_sio_irqs();
} }
@ -1314,7 +1318,7 @@ static WRITE32_HANDLER( sio_irq_clear_w )
if (!(data & 0x08)) if (!(data & 0x08))
{ {
state->m_sio_irq_state &= ~0x20; state->m_sio_irq_state &= ~0x20;
update_sio_irqs(space.machine()); state->update_sio_irqs();
} }
} }
} }
@ -1333,7 +1337,7 @@ static WRITE32_HANDLER( sio_irq_enable_w )
if (ACCESSING_BITS_0_7) if (ACCESSING_BITS_0_7)
{ {
state->m_sio_irq_enable = data; state->m_sio_irq_enable = data;
update_sio_irqs(space.machine()); state->update_sio_irqs();
} }
} }
@ -1507,37 +1511,37 @@ static WRITE32_HANDLER( dcs3_fifo_full_w )
* *
*************************************/ *************************************/
#define add_dynamic_address(st,s,e,r,w) _add_dynamic_address(st,s,e,r,w,#r,#w) #define add_dynamic_address(s,e,r,w) _add_dynamic_address(s,e,r,w,#r,#w)
#define add_dynamic_device_address(st,d,s,e,r,w) _add_dynamic_device_address(st,d,s,e,r,w,#r,#w) #define add_dynamic_device_address(d,s,e,r,w) _add_dynamic_device_address(d,s,e,r,w,#r,#w)
INLINE void _add_dynamic_address(vegas_state *state, offs_t start, offs_t end, read32_space_func read, write32_space_func write, const char *rdname, const char *wrname) inline void vegas_state::_add_dynamic_address(offs_t start, offs_t end, read32_space_func read, write32_space_func write, const char *rdname, const char *wrname)
{ {
dynamic_address *dynamic = state->m_dynamic; dynamic_address *dynamic = m_dynamic;
dynamic[state->m_dynamic_count].start = start; dynamic[m_dynamic_count].start = start;
dynamic[state->m_dynamic_count].end = end; dynamic[m_dynamic_count].end = end;
dynamic[state->m_dynamic_count].mread = read; dynamic[m_dynamic_count].mread = read;
dynamic[state->m_dynamic_count].mwrite = write; dynamic[m_dynamic_count].mwrite = write;
dynamic[state->m_dynamic_count].dread = NULL; dynamic[m_dynamic_count].dread = NULL;
dynamic[state->m_dynamic_count].dwrite = NULL; dynamic[m_dynamic_count].dwrite = NULL;
dynamic[state->m_dynamic_count].device = NULL; dynamic[m_dynamic_count].device = NULL;
dynamic[state->m_dynamic_count].rdname = rdname; dynamic[m_dynamic_count].rdname = rdname;
dynamic[state->m_dynamic_count].wrname = wrname; dynamic[m_dynamic_count].wrname = wrname;
state->m_dynamic_count++; m_dynamic_count++;
} }
INLINE void _add_dynamic_device_address(vegas_state *state, device_t *device, offs_t start, offs_t end, read32_device_func read, write32_device_func write, const char *rdname, const char *wrname) inline void vegas_state::_add_dynamic_device_address(device_t *device, offs_t start, offs_t end, read32_device_func read, write32_device_func write, const char *rdname, const char *wrname)
{ {
dynamic_address *dynamic = state->m_dynamic; dynamic_address *dynamic = m_dynamic;
dynamic[state->m_dynamic_count].start = start; dynamic[m_dynamic_count].start = start;
dynamic[state->m_dynamic_count].end = end; dynamic[m_dynamic_count].end = end;
dynamic[state->m_dynamic_count].mread = NULL; dynamic[m_dynamic_count].mread = NULL;
dynamic[state->m_dynamic_count].mwrite = NULL; dynamic[m_dynamic_count].mwrite = NULL;
dynamic[state->m_dynamic_count].dread = read; dynamic[m_dynamic_count].dread = read;
dynamic[state->m_dynamic_count].dwrite = write; dynamic[m_dynamic_count].dwrite = write;
dynamic[state->m_dynamic_count].device = device; dynamic[m_dynamic_count].device = device;
dynamic[state->m_dynamic_count].rdname = rdname; dynamic[m_dynamic_count].rdname = rdname;
dynamic[state->m_dynamic_count].wrname = wrname; dynamic[m_dynamic_count].wrname = wrname;
state->m_dynamic_count++; m_dynamic_count++;
} }
@ -1561,43 +1565,43 @@ void vegas_state::remap_dynamic_addresses()
base = m_nile_regs[NREG_DCS2] & 0x1fffff00; base = m_nile_regs[NREG_DCS2] & 0x1fffff00;
if (base >= m_rambase.bytes()) if (base >= m_rambase.bytes())
{ {
add_dynamic_address(this, base + 0x0000, base + 0x0003, sio_irq_clear_r, sio_irq_clear_w); add_dynamic_address(base + 0x0000, base + 0x0003, sio_irq_clear_r, sio_irq_clear_w);
add_dynamic_address(this, base + 0x1000, base + 0x1003, sio_irq_enable_r, sio_irq_enable_w); add_dynamic_address(base + 0x1000, base + 0x1003, sio_irq_enable_r, sio_irq_enable_w);
add_dynamic_address(this, base + 0x2000, base + 0x2003, sio_irq_cause_r, NULL); add_dynamic_address(base + 0x2000, base + 0x2003, sio_irq_cause_r, NULL);
add_dynamic_address(this, base + 0x3000, base + 0x3003, sio_irq_status_r, NULL); add_dynamic_address(base + 0x3000, base + 0x3003, sio_irq_status_r, NULL);
add_dynamic_address(this, base + 0x4000, base + 0x4003, sio_led_r, sio_led_w); add_dynamic_address(base + 0x4000, base + 0x4003, sio_led_r, sio_led_w);
add_dynamic_address(this, base + 0x5000, base + 0x5007, NOP_HANDLER, NULL); add_dynamic_address(base + 0x5000, base + 0x5007, NOP_HANDLER, NULL);
add_dynamic_address(this, base + 0x6000, base + 0x6003, NULL, cmos_unlock_w); add_dynamic_address(base + 0x6000, base + 0x6003, NULL, cmos_unlock_w);
add_dynamic_address(this, base + 0x7000, base + 0x7003, NULL, vegas_watchdog_w); add_dynamic_address(base + 0x7000, base + 0x7003, NULL, vegas_watchdog_w);
} }
/* DCS3 */ /* DCS3 */
base = m_nile_regs[NREG_DCS3] & 0x1fffff00; base = m_nile_regs[NREG_DCS3] & 0x1fffff00;
if (base >= m_rambase.bytes()) if (base >= m_rambase.bytes())
add_dynamic_address(this, base + 0x0000, base + 0x0003, analog_port_r, analog_port_w); add_dynamic_address(base + 0x0000, base + 0x0003, analog_port_r, analog_port_w);
/* DCS4 */ /* DCS4 */
base = m_nile_regs[NREG_DCS4] & 0x1fffff00; base = m_nile_regs[NREG_DCS4] & 0x1fffff00;
if (base >= m_rambase.bytes()) if (base >= m_rambase.bytes())
add_dynamic_address(this, base + 0x0000, base + 0x7fff, timekeeper_r, timekeeper_w); add_dynamic_address(base + 0x0000, base + 0x7fff, timekeeper_r, timekeeper_w);
/* DCS5 */ /* DCS5 */
base = m_nile_regs[NREG_DCS5] & 0x1fffff00; base = m_nile_regs[NREG_DCS5] & 0x1fffff00;
if (base >= m_rambase.bytes()) if (base >= m_rambase.bytes())
add_dynamic_address(this, base + 0x0000, base + 0x0003, sio_r, sio_w); add_dynamic_address(base + 0x0000, base + 0x0003, sio_r, sio_w);
/* DCS6 */ /* DCS6 */
base = m_nile_regs[NREG_DCS6] & 0x1fffff00; base = m_nile_regs[NREG_DCS6] & 0x1fffff00;
if (base >= m_rambase.bytes()) if (base >= m_rambase.bytes())
{ {
add_dynamic_address(this, base + 0x0000, base + 0x003f, midway_ioasic_packed_r, midway_ioasic_packed_w); add_dynamic_address(base + 0x0000, base + 0x003f, midway_ioasic_packed_r, midway_ioasic_packed_w);
add_dynamic_address(this, base + 0x1000, base + 0x1003, NULL, asic_fifo_w); add_dynamic_address(base + 0x1000, base + 0x1003, NULL, asic_fifo_w);
if (m_dcs_idma_cs != 0) if (m_dcs_idma_cs != 0)
add_dynamic_address(this, base + 0x3000, base + 0x3003, NULL, dcs3_fifo_full_w); add_dynamic_address(base + 0x3000, base + 0x3003, NULL, dcs3_fifo_full_w);
if (m_dcs_idma_cs == 6) if (m_dcs_idma_cs == 6)
{ {
add_dynamic_address(this, base + 0x5000, base + 0x5003, NULL, dsio_idma_addr_w); add_dynamic_address(base + 0x5000, base + 0x5003, NULL, dsio_idma_addr_w);
add_dynamic_address(this, base + 0x7000, base + 0x7003, dsio_idma_data_r, dsio_idma_data_w); add_dynamic_address(base + 0x7000, base + 0x7003, dsio_idma_data_r, dsio_idma_data_w);
} }
} }
@ -1605,11 +1609,11 @@ void vegas_state::remap_dynamic_addresses()
base = m_nile_regs[NREG_DCS7] & 0x1fffff00; base = m_nile_regs[NREG_DCS7] & 0x1fffff00;
if (base >= m_rambase.bytes()) if (base >= m_rambase.bytes())
{ {
add_dynamic_device_address(this, ethernet, base + 0x1000, base + 0x100f, ethernet_r, ethernet_w); add_dynamic_device_address(ethernet, base + 0x1000, base + 0x100f, ethernet_r, ethernet_w);
if (m_dcs_idma_cs == 7) if (m_dcs_idma_cs == 7)
{ {
add_dynamic_address(this, base + 0x5000, base + 0x5003, NULL, dsio_idma_addr_w); add_dynamic_address(base + 0x5000, base + 0x5003, NULL, dsio_idma_addr_w);
add_dynamic_address(this, base + 0x7000, base + 0x7003, dsio_idma_data_r, dsio_idma_data_w); add_dynamic_address(base + 0x7000, base + 0x7003, dsio_idma_data_r, dsio_idma_data_w);
} }
} }
@ -1619,8 +1623,8 @@ void vegas_state::remap_dynamic_addresses()
base = m_nile_regs[NREG_PCIW1] & 0x1fffff00; base = m_nile_regs[NREG_PCIW1] & 0x1fffff00;
if (base >= m_rambase.bytes()) if (base >= m_rambase.bytes())
{ {
add_dynamic_address(this, base + (1 << (21 + 4)) + 0x0000, base + (1 << (21 + 4)) + 0x00ff, pci_3dfx_r, pci_3dfx_w); add_dynamic_address(base + (1 << (21 + 4)) + 0x0000, base + (1 << (21 + 4)) + 0x00ff, pci_3dfx_r, pci_3dfx_w);
add_dynamic_address(this, base + (1 << (21 + 5)) + 0x0000, base + (1 << (21 + 5)) + 0x00ff, pci_ide_r, pci_ide_w); add_dynamic_address(base + (1 << (21 + 5)) + 0x0000, base + (1 << (21 + 5)) + 0x00ff, pci_ide_r, pci_ide_w);
} }
} }
@ -1630,39 +1634,39 @@ void vegas_state::remap_dynamic_addresses()
/* IDE controller */ /* IDE controller */
base = m_pci_ide_regs[0x04] & 0xfffffff0; base = m_pci_ide_regs[0x04] & 0xfffffff0;
if (base >= m_rambase.bytes() && base < 0x20000000) if (base >= m_rambase.bytes() && base < 0x20000000)
add_dynamic_device_address(this, ide, base + 0x0000, base + 0x000f, ide_main_r, ide_main_w); add_dynamic_device_address(ide, base + 0x0000, base + 0x000f, ide_main_r, ide_main_w);
base = m_pci_ide_regs[0x05] & 0xfffffffc; base = m_pci_ide_regs[0x05] & 0xfffffffc;
if (base >= m_rambase.bytes() && base < 0x20000000) if (base >= m_rambase.bytes() && base < 0x20000000)
add_dynamic_device_address(this, ide, base + 0x0000, base + 0x0003, ide_alt_r, ide_alt_w); add_dynamic_device_address(ide, base + 0x0000, base + 0x0003, ide_alt_r, ide_alt_w);
base = m_pci_ide_regs[0x08] & 0xfffffff0; base = m_pci_ide_regs[0x08] & 0xfffffff0;
if (base >= m_rambase.bytes() && base < 0x20000000) if (base >= m_rambase.bytes() && base < 0x20000000)
add_dynamic_device_address(this, ide, base + 0x0000, base + 0x0007, ide_bus_master32_r, ide_bus_master32_w); add_dynamic_device_address(ide, base + 0x0000, base + 0x0007, ide_bus_master32_r, ide_bus_master32_w);
/* 3dfx card */ /* 3dfx card */
base = m_pci_3dfx_regs[0x04] & 0xfffffff0; base = m_pci_3dfx_regs[0x04] & 0xfffffff0;
if (base >= m_rambase.bytes() && base < 0x20000000) if (base >= m_rambase.bytes() && base < 0x20000000)
{ {
if (voodoo_type == TYPE_VOODOO_2) if (voodoo_type == TYPE_VOODOO_2)
add_dynamic_device_address(this, m_voodoo, base + 0x000000, base + 0xffffff, voodoo_r, voodoo_w); add_dynamic_device_address(m_voodoo, base + 0x000000, base + 0xffffff, voodoo_r, voodoo_w);
else else
add_dynamic_device_address(this, m_voodoo, base + 0x000000, base + 0x1ffffff, banshee_r, banshee_w); add_dynamic_device_address(m_voodoo, base + 0x000000, base + 0x1ffffff, banshee_r, banshee_w);
} }
if (voodoo_type >= TYPE_VOODOO_BANSHEE) if (voodoo_type >= TYPE_VOODOO_BANSHEE)
{ {
base = m_pci_3dfx_regs[0x05] & 0xfffffff0; base = m_pci_3dfx_regs[0x05] & 0xfffffff0;
if (base >= m_rambase.bytes() && base < 0x20000000) if (base >= m_rambase.bytes() && base < 0x20000000)
add_dynamic_device_address(this, m_voodoo, base + 0x0000000, base + 0x1ffffff, banshee_fb_r, banshee_fb_w); add_dynamic_device_address(m_voodoo, base + 0x0000000, base + 0x1ffffff, banshee_fb_r, banshee_fb_w);
base = m_pci_3dfx_regs[0x06] & 0xfffffff0; base = m_pci_3dfx_regs[0x06] & 0xfffffff0;
if (base >= m_rambase.bytes() && base < 0x20000000) if (base >= m_rambase.bytes() && base < 0x20000000)
add_dynamic_device_address(this, m_voodoo, base + 0x0000000, base + 0x00000ff, banshee_io_r, banshee_io_w); add_dynamic_device_address(m_voodoo, base + 0x0000000, base + 0x00000ff, banshee_io_r, banshee_io_w);
base = m_pci_3dfx_regs[0x0c] & 0xffff0000; base = m_pci_3dfx_regs[0x0c] & 0xffff0000;
if (base >= m_rambase.bytes() && base < 0x20000000) if (base >= m_rambase.bytes() && base < 0x20000000)
add_dynamic_device_address(this, m_voodoo, base + 0x0000000, base + 0x000ffff, banshee_rom_r, NULL); add_dynamic_device_address(m_voodoo, base + 0x0000000, base + 0x000ffff, banshee_rom_r, NULL);
} }
} }
@ -2473,10 +2477,10 @@ ROM_END
* *
*************************************/ *************************************/
static void init_common(running_machine &machine, int ioasic, int serialnum) void vegas_state::init_common(int ioasic, int serialnum)
{ {
/* initialize the subsystems */ /* initialize the subsystems */
midway_ioasic_init(machine, ioasic, serialnum, 80, ioasic_irq); midway_ioasic_init(machine(), ioasic, serialnum, 80, ioasic_irq);
midway_ioasic_set_auto_ack(1); midway_ioasic_set_auto_ack(1);
} }
@ -2484,7 +2488,7 @@ static void init_common(running_machine &machine, int ioasic, int serialnum)
DRIVER_INIT_MEMBER(vegas_state,gauntleg) DRIVER_INIT_MEMBER(vegas_state,gauntleg)
{ {
dcs2_init(machine(), 4, 0x0b5d); dcs2_init(machine(), 4, 0x0b5d);
init_common(machine(), MIDWAY_IOASIC_CALSPEED, 340/* 340=39", 322=27", others? */); init_common(MIDWAY_IOASIC_CALSPEED, 340/* 340=39", 322=27", others? */);
/* speedups */ /* speedups */
mips3drc_add_hotspot(machine().device("maincpu"), 0x80015430, 0x8CC38060, 250); /* confirmed */ mips3drc_add_hotspot(machine().device("maincpu"), 0x80015430, 0x8CC38060, 250); /* confirmed */
@ -2497,7 +2501,7 @@ DRIVER_INIT_MEMBER(vegas_state,gauntleg)
DRIVER_INIT_MEMBER(vegas_state,gauntdl) DRIVER_INIT_MEMBER(vegas_state,gauntdl)
{ {
dcs2_init(machine(), 4, 0x0b5d); dcs2_init(machine(), 4, 0x0b5d);
init_common(machine(), MIDWAY_IOASIC_GAUNTDL, 346/* 347, others? */); init_common(MIDWAY_IOASIC_GAUNTDL, 346/* 347, others? */);
/* speedups */ /* speedups */
mips3drc_add_hotspot(machine().device("maincpu"), 0x800158B8, 0x8CC3CC40, 250); /* confirmed */ mips3drc_add_hotspot(machine().device("maincpu"), 0x800158B8, 0x8CC3CC40, 250); /* confirmed */
@ -2510,7 +2514,7 @@ DRIVER_INIT_MEMBER(vegas_state,gauntdl)
DRIVER_INIT_MEMBER(vegas_state,warfa) DRIVER_INIT_MEMBER(vegas_state,warfa)
{ {
dcs2_init(machine(), 4, 0x0b5d); dcs2_init(machine(), 4, 0x0b5d);
init_common(machine(), MIDWAY_IOASIC_MACE, 337/* others? */); init_common(MIDWAY_IOASIC_MACE, 337/* others? */);
/* speedups */ /* speedups */
mips3drc_add_hotspot(machine().device("maincpu"), 0x8009436C, 0x0C031663, 250); /* confirmed */ mips3drc_add_hotspot(machine().device("maincpu"), 0x8009436C, 0x0C031663, 250); /* confirmed */
@ -2520,7 +2524,7 @@ DRIVER_INIT_MEMBER(vegas_state,warfa)
DRIVER_INIT_MEMBER(vegas_state,tenthdeg) DRIVER_INIT_MEMBER(vegas_state,tenthdeg)
{ {
dcs2_init(machine(), 4, 0x0afb); dcs2_init(machine(), 4, 0x0afb);
init_common(machine(), MIDWAY_IOASIC_GAUNTDL, 330/* others? */); init_common(MIDWAY_IOASIC_GAUNTDL, 330/* others? */);
/* speedups */ /* speedups */
mips3drc_add_hotspot(machine().device("maincpu"), 0x80051CD8, 0x0C023C15, 250); /* confirmed */ mips3drc_add_hotspot(machine().device("maincpu"), 0x80051CD8, 0x0C023C15, 250); /* confirmed */
@ -2533,21 +2537,21 @@ DRIVER_INIT_MEMBER(vegas_state,tenthdeg)
DRIVER_INIT_MEMBER(vegas_state,roadburn) DRIVER_INIT_MEMBER(vegas_state,roadburn)
{ {
dcs2_init(machine(), 4, 0); /* no place to hook :-( */ dcs2_init(machine(), 4, 0); /* no place to hook :-( */
init_common(machine(), MIDWAY_IOASIC_STANDARD, 325/* others? */); init_common(MIDWAY_IOASIC_STANDARD, 325/* others? */);
} }
DRIVER_INIT_MEMBER(vegas_state,nbashowt) DRIVER_INIT_MEMBER(vegas_state,nbashowt)
{ {
dcs2_init(machine(), 4, 0); dcs2_init(machine(), 4, 0);
init_common(machine(), MIDWAY_IOASIC_MACE, 528/* or 478 or 487 */); init_common(MIDWAY_IOASIC_MACE, 528/* or 478 or 487 */);
} }
DRIVER_INIT_MEMBER(vegas_state,nbanfl) DRIVER_INIT_MEMBER(vegas_state,nbanfl)
{ {
dcs2_init(machine(), 4, 0); dcs2_init(machine(), 4, 0);
init_common(machine(), MIDWAY_IOASIC_BLITZ99, 498/* or 478 or 487 */); init_common(MIDWAY_IOASIC_BLITZ99, 498/* or 478 or 487 */);
/* NOT: MACE */ /* NOT: MACE */
} }
@ -2555,28 +2559,28 @@ DRIVER_INIT_MEMBER(vegas_state,nbanfl)
DRIVER_INIT_MEMBER(vegas_state,sf2049) DRIVER_INIT_MEMBER(vegas_state,sf2049)
{ {
dcs2_init(machine(), 8, 0); dcs2_init(machine(), 8, 0);
init_common(machine(), MIDWAY_IOASIC_STANDARD, 336/* others? */); init_common(MIDWAY_IOASIC_STANDARD, 336/* others? */);
} }
DRIVER_INIT_MEMBER(vegas_state,sf2049se) DRIVER_INIT_MEMBER(vegas_state,sf2049se)
{ {
dcs2_init(machine(), 8, 0); dcs2_init(machine(), 8, 0);
init_common(machine(), MIDWAY_IOASIC_SFRUSHRK, 336/* others? */); init_common(MIDWAY_IOASIC_SFRUSHRK, 336/* others? */);
} }
DRIVER_INIT_MEMBER(vegas_state,sf2049te) DRIVER_INIT_MEMBER(vegas_state,sf2049te)
{ {
dcs2_init(machine(), 8, 0); dcs2_init(machine(), 8, 0);
init_common(machine(), MIDWAY_IOASIC_SFRUSHRK, 348/* others? */); init_common(MIDWAY_IOASIC_SFRUSHRK, 348/* others? */);
} }
DRIVER_INIT_MEMBER(vegas_state,cartfury) DRIVER_INIT_MEMBER(vegas_state,cartfury)
{ {
dcs2_init(machine(), 4, 0); dcs2_init(machine(), 4, 0);
init_common(machine(), MIDWAY_IOASIC_CARNEVIL, 495/* others? */); init_common(MIDWAY_IOASIC_CARNEVIL, 495/* others? */);
} }

71
src/mame/drivers/viper.c
View File

@ -351,6 +351,13 @@ public:
INTERRUPT_GEN_MEMBER(viper_vblank); INTERRUPT_GEN_MEMBER(viper_vblank);
TIMER_CALLBACK_MEMBER(epic_global_timer_callback); TIMER_CALLBACK_MEMBER(epic_global_timer_callback);
TIMER_CALLBACK_MEMBER(ds2430_timer_callback); TIMER_CALLBACK_MEMBER(ds2430_timer_callback);
const char* epic_get_register_name(UINT32 reg);
void epic_update_interrupts();
void mpc8240_interrupt(int irq);
void mpc8240_epic_init();
void mpc8240_epic_reset(void);
int ds2430_insert_cmd_bit(int bit);
void DS2430_w(int bit);
}; };
UINT32 viper_state::screen_update_viper(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) UINT32 viper_state::screen_update_viper(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
@ -454,8 +461,6 @@ WRITE64_MEMBER(viper_state::pci_config_data_w)
/*****************************************************************************/ /*****************************************************************************/
// MPC8240 Embedded Programmable Interrupt Controller (EPIC) // MPC8240 Embedded Programmable Interrupt Controller (EPIC)
static void mpc8240_interrupt(running_machine &machine, int irq);
#define MPC8240_IRQ0 0 #define MPC8240_IRQ0 0
#define MPC8240_IRQ1 1 #define MPC8240_IRQ1 1
#define MPC8240_IRQ2 2 #define MPC8240_IRQ2 2
@ -530,7 +535,7 @@ struct MPC8240_EPIC
static MPC8240_EPIC epic; static MPC8240_EPIC epic;
#if VIPER_DEBUG_EPIC_REGS #if VIPER_DEBUG_EPIC_REGS
static const char* epic_get_register_name(UINT32 reg) const viper_state::char* epic_get_register_name(UINT32 reg)
{ {
switch (reg >> 16) switch (reg >> 16)
{ {
@ -663,11 +668,11 @@ TIMER_CALLBACK_MEMBER(viper_state::epic_global_timer_callback)
epic.global_timer[timer_num].timer->reset(); epic.global_timer[timer_num].timer->reset();
} }
mpc8240_interrupt(machine(), MPC8240_GTIMER0_IRQ + timer_num); mpc8240_interrupt(MPC8240_GTIMER0_IRQ + timer_num);
} }
static void epic_update_interrupts(running_machine &machine) void viper_state::epic_update_interrupts()
{ {
int i; int i;
@ -709,11 +714,11 @@ static void epic_update_interrupts(running_machine &machine)
printf("vector = %02X\n", epic.iack); printf("vector = %02X\n", epic.iack);
#endif #endif
machine.device("maincpu")->execute().set_input_line(INPUT_LINE_IRQ0, ASSERT_LINE); machine().device("maincpu")->execute().set_input_line(INPUT_LINE_IRQ0, ASSERT_LINE);
} }
else else
{ {
machine.device("maincpu")->execute().set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE); machine().device("maincpu")->execute().set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
} }
} }
@ -783,7 +788,7 @@ READ32_MEMBER(viper_state::epic_r)
if (epic.i2c_cr & 0x40) if (epic.i2c_cr & 0x40)
{ {
printf("I2C interrupt\n"); printf("I2C interrupt\n");
mpc8240_interrupt(machine(), MPC8240_I2C_IRQ); mpc8240_interrupt(MPC8240_I2C_IRQ);
// set interrupt flag in status register // set interrupt flag in status register
epic.i2c_sr |= 0x2; epic.i2c_sr |= 0x2;
@ -802,7 +807,7 @@ READ32_MEMBER(viper_state::epic_r)
/*if (epic.i2c_cr & 0x40) /*if (epic.i2c_cr & 0x40)
{ {
printf("I2C interrupt\n"); printf("I2C interrupt\n");
mpc8240_interrupt(machine, MPC8240_I2C_IRQ); mpc8240_interrupt(MPC8240_I2C_IRQ);
// set interrupt flag in status register // set interrupt flag in status register
epic.i2c_sr |= 0x2; epic.i2c_sr |= 0x2;
@ -886,7 +891,7 @@ READ32_MEMBER(viper_state::epic_r)
{ {
case 0x00a0: // Offset 0x600A0 - IACK case 0x00a0: // Offset 0x600A0 - IACK
{ {
epic_update_interrupts(machine()); epic_update_interrupts();
if (epic.active_irq >= 0) if (epic.active_irq >= 0)
{ {
@ -988,7 +993,7 @@ WRITE32_MEMBER(viper_state::epic_w)
#if VIPER_DEBUG_EPIC_I2C #if VIPER_DEBUG_EPIC_I2C
printf("I2C interrupt\n"); printf("I2C interrupt\n");
#endif #endif
mpc8240_interrupt(machine(), MPC8240_I2C_IRQ); mpc8240_interrupt(MPC8240_I2C_IRQ);
// set interrupt flag in status register // set interrupt flag in status register
epic.i2c_sr |= 0x2; epic.i2c_sr |= 0x2;
@ -1010,7 +1015,7 @@ WRITE32_MEMBER(viper_state::epic_w)
#if VIPER_DEBUG_EPIC_I2C #if VIPER_DEBUG_EPIC_I2C
printf("I2C interrupt\n"); printf("I2C interrupt\n");
#endif #endif
mpc8240_interrupt(machine(), MPC8240_I2C_IRQ); mpc8240_interrupt(MPC8240_I2C_IRQ);
// set interrupt flag in status register // set interrupt flag in status register
epic.i2c_sr |= 0x2; epic.i2c_sr |= 0x2;
@ -1051,7 +1056,7 @@ WRITE32_MEMBER(viper_state::epic_w)
epic.irq[MPC8240_GTIMER0_IRQ + timer_num].priority = (data >> 16) & 0xf; epic.irq[MPC8240_GTIMER0_IRQ + timer_num].priority = (data >> 16) & 0xf;
epic.irq[MPC8240_GTIMER0_IRQ + timer_num].vector = data & 0xff; epic.irq[MPC8240_GTIMER0_IRQ + timer_num].vector = data & 0xff;
epic_update_interrupts(machine()); epic_update_interrupts();
break; break;
} }
case 0x1130: // Offset 0x41130 - Global timer 0 destination register case 0x1130: // Offset 0x41130 - Global timer 0 destination register
@ -1063,7 +1068,7 @@ WRITE32_MEMBER(viper_state::epic_w)
epic.irq[MPC8240_GTIMER0_IRQ + timer_num].destination = data & 0x1; epic.irq[MPC8240_GTIMER0_IRQ + timer_num].destination = data & 0x1;
epic_update_interrupts(machine()); epic_update_interrupts();
break; break;
} }
case 0x1110: // Offset 0x41110 - Global timer 0 base count register case 0x1110: // Offset 0x41110 - Global timer 0 base count register
@ -1123,7 +1128,7 @@ WRITE32_MEMBER(viper_state::epic_w)
epic.irq[MPC8240_IRQ0 + irq].priority = (data >> 16) & 0xf; epic.irq[MPC8240_IRQ0 + irq].priority = (data >> 16) & 0xf;
epic.irq[MPC8240_IRQ0 + irq].vector = data & 0xff; epic.irq[MPC8240_IRQ0 + irq].vector = data & 0xff;
epic_update_interrupts(machine()); epic_update_interrupts();
break; break;
} }
case 0x1020: // Offset 0x51020 - I2C IRQ vector/priority register case 0x1020: // Offset 0x51020 - I2C IRQ vector/priority register
@ -1132,7 +1137,7 @@ WRITE32_MEMBER(viper_state::epic_w)
epic.irq[MPC8240_I2C_IRQ].priority = (data >> 16) & 0xf; epic.irq[MPC8240_I2C_IRQ].priority = (data >> 16) & 0xf;
epic.irq[MPC8240_I2C_IRQ].vector = data & 0xff; epic.irq[MPC8240_I2C_IRQ].vector = data & 0xff;
epic_update_interrupts(machine()); epic_update_interrupts();
break; break;
} }
case 0x0210: // Offset 0x50210 - IRQ0 destination register case 0x0210: // Offset 0x50210 - IRQ0 destination register
@ -1156,13 +1161,13 @@ WRITE32_MEMBER(viper_state::epic_w)
epic.irq[MPC8240_IRQ0 + irq].destination = data & 0x1; epic.irq[MPC8240_IRQ0 + irq].destination = data & 0x1;
epic_update_interrupts(machine()); epic_update_interrupts();
break; break;
} }
case 0x1030: // Offset 0x51030 - I2C IRQ destination register case 0x1030: // Offset 0x51030 - I2C IRQ destination register
{ {
epic.irq[MPC8240_I2C_IRQ].destination = data & 0x1; epic.irq[MPC8240_I2C_IRQ].destination = data & 0x1;
epic_update_interrupts(machine()); epic_update_interrupts();
break; break;
} }
} }
@ -1182,7 +1187,7 @@ WRITE32_MEMBER(viper_state::epic_w)
epic.irq[epic.active_irq].active = 0; epic.irq[epic.active_irq].active = 0;
epic.active_irq = -1; epic.active_irq = -1;
epic_update_interrupts(machine()); epic_update_interrupts();
break; break;
} }
break; break;
@ -1200,22 +1205,21 @@ WRITE64_MEMBER(viper_state::epic_64be_w)
} }
*/ */
static void mpc8240_interrupt(running_machine &machine, int irq) void viper_state::mpc8240_interrupt(int irq)
{ {
epic.irq[irq].pending = 1; epic.irq[irq].pending = 1;
epic_update_interrupts(machine); epic_update_interrupts();
} }
static void mpc8240_epic_init(running_machine &machine) void viper_state::mpc8240_epic_init()
{ {
viper_state *state = machine.driver_data<viper_state>(); epic.global_timer[0].timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(viper_state::epic_global_timer_callback),this));
epic.global_timer[0].timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(viper_state::epic_global_timer_callback),state)); epic.global_timer[1].timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(viper_state::epic_global_timer_callback),this));
epic.global_timer[1].timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(viper_state::epic_global_timer_callback),state)); epic.global_timer[2].timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(viper_state::epic_global_timer_callback),this));
epic.global_timer[2].timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(viper_state::epic_global_timer_callback),state)); epic.global_timer[3].timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(viper_state::epic_global_timer_callback),this));
epic.global_timer[3].timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(viper_state::epic_global_timer_callback),state));
} }
static void mpc8240_epic_reset(void) void viper_state::mpc8240_epic_reset(void)
{ {
int i; int i;
@ -1706,7 +1710,7 @@ READ64_MEMBER(viper_state::unk1_r)
} }
static int ds2430_insert_cmd_bit(int bit) int viper_state::ds2430_insert_cmd_bit(int bit)
{ {
ds2430_data <<= 1; ds2430_data <<= 1;
ds2430_data |= bit & 1; ds2430_data |= bit & 1;
@ -1722,7 +1726,7 @@ static int ds2430_insert_cmd_bit(int bit)
return 0; return 0;
} }
static void DS2430_w(int bit) void viper_state::DS2430_w(int bit)
{ {
switch (ds2430_state) switch (ds2430_state)
{ {
@ -1986,20 +1990,21 @@ static const powerpc_config viper_ppc_cfg =
INTERRUPT_GEN_MEMBER(viper_state::viper_vblank) INTERRUPT_GEN_MEMBER(viper_state::viper_vblank)
{ {
mpc8240_interrupt(machine(), MPC8240_IRQ0); mpc8240_interrupt(MPC8240_IRQ0);
//mpc8240_interrupt(device.machine, MPC8240_IRQ3); //mpc8240_interrupt(device.machine, MPC8240_IRQ3);
} }
static void voodoo_vblank(device_t *device, int state) static void voodoo_vblank(device_t *device, int state)
{ {
mpc8240_interrupt(device->machine(), MPC8240_IRQ4); viper_state *drvstate = device->machine().driver_data<viper_state>();
drvstate->mpc8240_interrupt(MPC8240_IRQ4);
} }
void viper_state::machine_start() void viper_state::machine_start()
{ {
ds2430_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(viper_state::ds2430_timer_callback),this)); ds2430_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(viper_state::ds2430_timer_callback),this));
ds2430_bit_timer = machine().device<timer_device>("ds2430_timer2"); ds2430_bit_timer = machine().device<timer_device>("ds2430_timer2");
mpc8240_epic_init(machine()); mpc8240_epic_init();
/* set conservative DRC options */ /* set conservative DRC options */
ppcdrc_set_options(machine().device("maincpu"), PPCDRC_COMPATIBLE_OPTIONS); ppcdrc_set_options(machine().device("maincpu"), PPCDRC_COMPATIBLE_OPTIONS);

106
src/mame/drivers/zn.c
View File

@ -124,9 +124,16 @@ public:
DECLARE_MACHINE_RESET(coh1002v); DECLARE_MACHINE_RESET(coh1002v);
DECLARE_MACHINE_RESET(coh1002m); DECLARE_MACHINE_RESET(coh1002m);
INTERRUPT_GEN_MEMBER(qsound_interrupt); INTERRUPT_GEN_MEMBER(qsound_interrupt);
inline void ATTR_PRINTF(3,4) verboselog( int n_level, const char *s_fmt, ... );
inline UINT8 psxreadbyte( UINT32 *p_n_psxram, UINT32 n_address );
inline void psxwritebyte( UINT32 *p_n_psxram, UINT32 n_address, UINT8 n_data );
void zn_driver_init( );
void atpsx_dma_read(UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size );
void atpsx_dma_write(UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size );
void jdredd_vblank(screen_device &screen, bool vblank_state);
}; };
INLINE void ATTR_PRINTF(3,4) verboselog( running_machine &machine, int n_level, const char *s_fmt, ... ) inline void ATTR_PRINTF(3,4) zn_state::verboselog( int n_level, const char *s_fmt, ... )
{ {
if( VERBOSE_LEVEL >= n_level ) if( VERBOSE_LEVEL >= n_level )
{ {
@ -135,18 +142,18 @@ INLINE void ATTR_PRINTF(3,4) verboselog( running_machine &machine, int n_level,
va_start( v, s_fmt ); va_start( v, s_fmt );
vsprintf( buf, s_fmt, v ); vsprintf( buf, s_fmt, v );
va_end( v ); va_end( v );
logerror( "%s: %s", machine.describe_context(), buf ); logerror( "%s: %s", machine().describe_context(), buf );
} }
} }
#ifdef UNUSED_FUNCTION #ifdef UNUSED_FUNCTION
INLINE UINT8 psxreadbyte( UINT32 *p_n_psxram, UINT32 n_address ) inline UINT8 zn_state::psxreadbyte( UINT32 *p_n_psxram, UINT32 n_address )
{ {
return *( (UINT8 *)p_n_psxram + BYTE4_XOR_LE( n_address ) ); return *( (UINT8 *)p_n_psxram + BYTE4_XOR_LE( n_address ) );
} }
#endif #endif
INLINE void psxwritebyte( UINT32 *p_n_psxram, UINT32 n_address, UINT8 n_data ) inline void zn_state::psxwritebyte( UINT32 *p_n_psxram, UINT32 n_address, UINT8 n_data )
{ {
*( (UINT8 *)p_n_psxram + BYTE4_XOR_LE( n_address ) ) = n_data; *( (UINT8 *)p_n_psxram + BYTE4_XOR_LE( n_address ) ) = n_data;
} }
@ -312,7 +319,7 @@ static const struct
READ32_MEMBER(zn_state::znsecsel_r) READ32_MEMBER(zn_state::znsecsel_r)
{ {
verboselog( machine(), 2, "znsecsel_r( %08x, %08x )\n", offset, mem_mask ); verboselog(2, "znsecsel_r( %08x, %08x )\n", offset, mem_mask );
return m_n_znsecsel; return m_n_znsecsel;
} }
@ -324,7 +331,7 @@ WRITE32_MEMBER(zn_state::znsecsel_w)
m_znsec1->select( ( m_n_znsecsel >> 3 ) & 1 ); m_znsec1->select( ( m_n_znsecsel >> 3 ) & 1 );
m_zndip->select( ( m_n_znsecsel & 0x8c ) != 0x8c ); m_zndip->select( ( m_n_znsecsel & 0x8c ) != 0x8c );
verboselog( machine(), 2, "znsecsel_w( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(2, "znsecsel_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
} }
READ32_MEMBER(zn_state::boardconfig_r) READ32_MEMBER(zn_state::boardconfig_r)
@ -360,7 +367,7 @@ READ32_MEMBER(zn_state::boardconfig_r)
READ32_MEMBER(zn_state::unknown_r) READ32_MEMBER(zn_state::unknown_r)
{ {
verboselog( machine(), 0, "unknown_r( %08x, %08x )\n", offset, mem_mask ); verboselog(0, "unknown_r( %08x, %08x )\n", offset, mem_mask );
return 0xffffffff; return 0xffffffff;
} }
@ -374,7 +381,7 @@ WRITE32_MEMBER(zn_state::coin_w)
*/ */
if( ( data & ~0x23 ) != 0 ) if( ( data & ~0x23 ) != 0 )
{ {
verboselog( machine(), 0, "coin_w %08x\n", data ); verboselog(0, "coin_w %08x\n", data );
} }
} }
@ -406,18 +413,17 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( link_map, AS_PROGRAM, 8, zn_state ) static ADDRESS_MAP_START( link_map, AS_PROGRAM, 8, zn_state )
ADDRESS_MAP_END ADDRESS_MAP_END
static void zn_driver_init( running_machine &machine ) void zn_state::zn_driver_init( )
{ {
zn_state *state = machine.driver_data<zn_state>();
int n_game; int n_game;
n_game = 0; n_game = 0;
while( zn_config_table[ n_game ].s_name != NULL ) while( zn_config_table[ n_game ].s_name != NULL )
{ {
if( strcmp( machine.system().name, zn_config_table[ n_game ].s_name ) == 0 ) if( strcmp( machine().system().name, zn_config_table[ n_game ].s_name ) == 0 )
{ {
state->m_znsec0->init( zn_config_table[ n_game ].p_n_mainsec ); m_znsec0->init( zn_config_table[ n_game ].p_n_mainsec );
state->m_znsec1->init( zn_config_table[ n_game ].p_n_gamesec ); m_znsec1->init( zn_config_table[ n_game ].p_n_gamesec );
// psx_sio_install_handler( machine, 0, sio_pad_handler ); // psx_sio_install_handler( machine, 0, sio_pad_handler );
break; break;
} }
@ -591,7 +597,7 @@ Notes:
READ32_MEMBER(zn_state::capcom_kickharness_r) READ32_MEMBER(zn_state::capcom_kickharness_r)
{ {
/* required for buttons 4,5&6 */ /* required for buttons 4,5&6 */
verboselog( machine(), 2, "capcom_kickharness_r( %08x, %08x )\n", offset, mem_mask ); verboselog(2, "capcom_kickharness_r( %08x, %08x )\n", offset, mem_mask );
return 0xffffffff; return 0xffffffff;
} }
@ -626,7 +632,7 @@ DRIVER_INIT_MEMBER(zn_state,coh1000c)
machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank ( 0x1fb80000, 0x1fbfffff, "bank3" ); /* country rom */ machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank ( 0x1fb80000, 0x1fbfffff, "bank3" ); /* country rom */
machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler( 0x1fb60000, 0x1fb60003, write32_delegate(FUNC(zn_state::zn_qsound_w),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler( 0x1fb60000, 0x1fb60003, write32_delegate(FUNC(zn_state::zn_qsound_w),this));
zn_driver_init(machine()); zn_driver_init();
if( strcmp( machine().system().name, "glpracr" ) == 0 || if( strcmp( machine().system().name, "glpracr" ) == 0 ||
strcmp( machine().system().name, "glpracr2l" ) == 0 ) strcmp( machine().system().name, "glpracr2l" ) == 0 )
@ -842,7 +848,7 @@ DRIVER_INIT_MEMBER(zn_state,coh3002c)
machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank ( 0x1fb80000, 0x1fbfffff, "bank3" ); /* country rom */ machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank ( 0x1fb80000, 0x1fbfffff, "bank3" ); /* country rom */
machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler( 0x1fb60000, 0x1fb60003, write32_delegate(FUNC(zn_state::zn_qsound_w),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler( 0x1fb60000, 0x1fb60003, write32_delegate(FUNC(zn_state::zn_qsound_w),this));
zn_driver_init(machine()); zn_driver_init();
} }
MACHINE_RESET_MEMBER(zn_state,coh3002c) MACHINE_RESET_MEMBER(zn_state,coh3002c)
@ -1088,7 +1094,7 @@ WRITE32_MEMBER(zn_state::bank_coh1000t_w)
{ {
device_t *mb3773 = machine().device("mb3773"); device_t *mb3773 = machine().device("mb3773");
mb3773_set_ck(mb3773, (data & 0x20) >> 5); mb3773_set_ck(mb3773, (data & 0x20) >> 5);
verboselog( machine(), 1, "bank_coh1000t_w( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(1, "bank_coh1000t_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
membank( "bank1" )->set_base( memregion( "user2" )->base() + ( ( data & 3 ) * 0x800000 ) ); membank( "bank1" )->set_base( memregion( "user2" )->base() + ( ( data & 3 ) * 0x800000 ) );
} }
@ -1127,7 +1133,7 @@ DRIVER_INIT_MEMBER(zn_state,coh1000ta)
machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler( 0x1fb80000, 0x1fb80003, read32_delegate(FUNC(zn_state::taitofx1a_ymsound_r),this), write32_delegate(FUNC(zn_state::taitofx1a_ymsound_w),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler( 0x1fb80000, 0x1fb80003, read32_delegate(FUNC(zn_state::taitofx1a_ymsound_r),this), write32_delegate(FUNC(zn_state::taitofx1a_ymsound_w),this));
machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_bank( 0x1fbe0000, 0x1fbe0000 + ( m_taitofx1_eeprom_size1 - 1 ), "bank2" ); machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_bank( 0x1fbe0000, 0x1fbe0000 + ( m_taitofx1_eeprom_size1 - 1 ), "bank2" );
zn_driver_init(machine()); zn_driver_init();
} }
MACHINE_RESET_MEMBER(zn_state,coh1000ta) MACHINE_RESET_MEMBER(zn_state,coh1000ta)
@ -1186,18 +1192,18 @@ MACHINE_CONFIG_END
WRITE32_MEMBER(zn_state::taitofx1b_volume_w) WRITE32_MEMBER(zn_state::taitofx1b_volume_w)
{ {
verboselog( machine(), 1, "taitofx1_volume_w( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(1, "taitofx1_volume_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
} }
WRITE32_MEMBER(zn_state::taitofx1b_sound_w) WRITE32_MEMBER(zn_state::taitofx1b_sound_w)
{ {
verboselog( machine(), 1, "taitofx1_sound_w( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(1, "taitofx1_sound_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
} }
READ32_MEMBER(zn_state::taitofx1b_sound_r) READ32_MEMBER(zn_state::taitofx1b_sound_r)
{ {
UINT32 data = 0; // bit 0 = busy? UINT32 data = 0; // bit 0 = busy?
verboselog( machine(), 1, "taitofx1_sound_r( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(1, "taitofx1_sound_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
return data; return data;
} }
@ -1217,7 +1223,7 @@ DRIVER_INIT_MEMBER(zn_state,coh1000tb)
machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler ( 0x1fbc0000, 0x1fbc0003, read32_delegate(FUNC(zn_state::taitofx1b_sound_r),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_handler ( 0x1fbc0000, 0x1fbc0003, read32_delegate(FUNC(zn_state::taitofx1b_sound_r),this));
machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_bank( 0x1fbe0000, 0x1fbe0000 + ( m_taitofx1_eeprom_size2 - 1 ), "bank3" ); machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_bank( 0x1fbe0000, 0x1fbe0000 + ( m_taitofx1_eeprom_size2 - 1 ), "bank3" );
zn_driver_init(machine()); zn_driver_init();
} }
MACHINE_RESET_MEMBER(zn_state,coh1000tb) MACHINE_RESET_MEMBER(zn_state,coh1000tb)
@ -1354,9 +1360,9 @@ Notes:
*2 - Unpopulated DIP28 socket *2 - Unpopulated DIP28 socket
*/ */
static void atpsx_dma_read( zn_state *state, UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size ) void zn_state::atpsx_dma_read( UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size )
{ {
device_t *ide = state->machine().device("ide"); device_t *ide = machine().device("ide");
logerror("DMA read: %d bytes (%d words) to %08x\n", n_size<<2, n_size, n_address); logerror("DMA read: %d bytes (%d words) to %08x\n", n_size<<2, n_size, n_address);
@ -1369,7 +1375,7 @@ static void atpsx_dma_read( zn_state *state, UINT32 *p_n_psxram, UINT32 n_addres
/* dma size is in 32-bit words, convert to bytes */ /* dma size is in 32-bit words, convert to bytes */
n_size <<= 2; n_size <<= 2;
address_space &space = state->machine().firstcpu->space(AS_PROGRAM); address_space &space = machine().firstcpu->space(AS_PROGRAM);
while( n_size > 0 ) while( n_size > 0 )
{ {
psxwritebyte( p_n_psxram, n_address, ide_controller32_r( ide, space, 0x1f0 / 4, 0x000000ff ) ); psxwritebyte( p_n_psxram, n_address, ide_controller32_r( ide, space, 0x1f0 / 4, 0x000000ff ) );
@ -1378,7 +1384,7 @@ static void atpsx_dma_read( zn_state *state, UINT32 *p_n_psxram, UINT32 n_addres
} }
} }
static void atpsx_dma_write( zn_state *state, UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size ) void zn_state::atpsx_dma_write( UINT32 *p_n_psxram, UINT32 n_address, INT32 n_size )
{ {
logerror("DMA write from %08x for %d bytes\n", n_address, n_size<<2); logerror("DMA write from %08x for %d bytes\n", n_address, n_size<<2);
} }
@ -1393,7 +1399,7 @@ DRIVER_INIT_MEMBER(zn_state,coh1000w)
machine().device("maincpu")->memory().space(AS_PROGRAM).nop_readwrite ( 0x1f7e8000, 0x1f7e8003); machine().device("maincpu")->memory().space(AS_PROGRAM).nop_readwrite ( 0x1f7e8000, 0x1f7e8003);
machine().device("maincpu")->memory().space(AS_PROGRAM).install_legacy_readwrite_handler( *ide, 0x1f7f4000, 0x1f7f4fff, FUNC(ide_controller32_r), FUNC(ide_controller32_w) ); machine().device("maincpu")->memory().space(AS_PROGRAM).install_legacy_readwrite_handler( *ide, 0x1f7f4000, 0x1f7f4fff, FUNC(ide_controller32_r), FUNC(ide_controller32_w) );
zn_driver_init(machine()); zn_driver_init();
} }
MACHINE_RESET_MEMBER(zn_state,coh1000w) MACHINE_RESET_MEMBER(zn_state,coh1000w)
@ -1408,8 +1414,8 @@ static MACHINE_CONFIG_DERIVED( coh1000w, zn1_2mb_vram )
MCFG_IDE_CONTROLLER_ADD("ide", ide_devices, "hdd", NULL, true) MCFG_IDE_CONTROLLER_ADD("ide", ide_devices, "hdd", NULL, true)
MCFG_IDE_CONTROLLER_IRQ_HANDLER(DEVWRITELINE("maincpu:irq", psxirq_device, intin10)) MCFG_IDE_CONTROLLER_IRQ_HANDLER(DEVWRITELINE("maincpu:irq", psxirq_device, intin10))
MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 5, psx_dma_read_delegate( FUNC( atpsx_dma_read ), (zn_state *) owner ) ) MCFG_PSX_DMA_CHANNEL_READ( "maincpu", 5, psx_dma_read_delegate( FUNC( zn_state::atpsx_dma_read ), (zn_state *) owner ) )
MCFG_PSX_DMA_CHANNEL_WRITE( "maincpu", 5, psx_dma_write_delegate( FUNC( atpsx_dma_write ), (zn_state *) owner ) ) MCFG_PSX_DMA_CHANNEL_WRITE( "maincpu", 5, psx_dma_write_delegate( FUNC( zn_state::atpsx_dma_write ), (zn_state *) owner ) )
MACHINE_CONFIG_END MACHINE_CONFIG_END
/* /*
@ -1580,7 +1586,7 @@ DRIVER_INIT_MEMBER(zn_state,coh1002e)
machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler( 0x1fa10300, 0x1fa10303, write32_delegate(FUNC(zn_state::coh1002e_bank_w),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler( 0x1fa10300, 0x1fa10303, write32_delegate(FUNC(zn_state::coh1002e_bank_w),this));
machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler( 0x1fb00000, 0x1fb00007, write32_delegate(FUNC(zn_state::coh1002e_latch_w),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler( 0x1fb00000, 0x1fb00007, write32_delegate(FUNC(zn_state::coh1002e_latch_w),this));
zn_driver_init(machine()); zn_driver_init();
} }
MACHINE_RESET_MEMBER(zn_state,coh1002e) MACHINE_RESET_MEMBER(zn_state,coh1002e)
@ -1722,7 +1728,7 @@ DRIVER_INIT_MEMBER(zn_state,bam2)
machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler( 0x1fa10300, 0x1fa10303, write32_delegate(FUNC(zn_state::bam2_sec_w),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler( 0x1fa10300, 0x1fa10303, write32_delegate(FUNC(zn_state::bam2_sec_w),this));
machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler( 0x1fb00000, 0x1fb00007, write32_delegate(FUNC(zn_state::bam2_mcu_w),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler( 0x1fb00000, 0x1fb00007, write32_delegate(FUNC(zn_state::bam2_mcu_w),this));
zn_driver_init(machine()); zn_driver_init();
} }
MACHINE_RESET_MEMBER(zn_state,bam2) MACHINE_RESET_MEMBER(zn_state,bam2)
@ -1963,47 +1969,47 @@ CUSTOM_INPUT_MEMBER(zn_state::jdredd_gun_mux_read)
return m_jdredd_gun_mux; return m_jdredd_gun_mux;
} }
void jdredd_vblank(zn_state *state, screen_device &screen, bool vblank_state) void zn_state::jdredd_vblank(screen_device &screen, bool vblank_state)
{ {
int x; int x;
int y; int y;
if( vblank_state ) if( vblank_state )
{ {
state->m_jdredd_gun_mux = !state->m_jdredd_gun_mux; m_jdredd_gun_mux = !m_jdredd_gun_mux;
if( state->m_jdredd_gun_mux == 0 ) if( m_jdredd_gun_mux == 0 )
{ {
x = state->ioport("GUN1X")->read(); x = ioport("GUN1X")->read();
y = state->ioport("GUN1Y")->read(); y = ioport("GUN1Y")->read();
} }
else else
{ {
x = state->ioport("GUN2X")->read(); x = ioport("GUN2X")->read();
y = state->ioport("GUN2Y")->read(); y = ioport("GUN2Y")->read();
} }
if( x > 0x393 && x < 0xcb2 && if( x > 0x393 && x < 0xcb2 &&
y > 0x02d && y < 0x217 ) y > 0x02d && y < 0x217 )
{ {
state->m_gpu->lightgun_set( x, y ); m_gpu->lightgun_set( x, y );
} }
} }
} }
WRITE32_MEMBER(zn_state::acpsx_00_w) WRITE32_MEMBER(zn_state::acpsx_00_w)
{ {
verboselog( machine(), 0, "acpsx_00_w( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(0, "acpsx_00_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
} }
WRITE32_MEMBER(zn_state::acpsx_10_w) WRITE32_MEMBER(zn_state::acpsx_10_w)
{ {
verboselog( machine(), 0, "acpsx_10_w( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(0, "acpsx_10_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
} }
WRITE32_MEMBER(zn_state::nbajamex_80_w) WRITE32_MEMBER(zn_state::nbajamex_80_w)
{ {
verboselog( machine(), 0, "nbajamex_80_w( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(0, "nbajamex_80_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
psxirq_device *psxirq = (psxirq_device *) machine().device("maincpu:irq"); psxirq_device *psxirq = (psxirq_device *) machine().device("maincpu:irq");
psxirq->intin10(1); psxirq->intin10(1);
} }
@ -2011,14 +2017,14 @@ WRITE32_MEMBER(zn_state::nbajamex_80_w)
READ32_MEMBER(zn_state::nbajamex_08_r) READ32_MEMBER(zn_state::nbajamex_08_r)
{ {
UINT32 data = 0xffffffff; UINT32 data = 0xffffffff;
verboselog( machine(), 0, "nbajamex_08_r( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(0, "nbajamex_08_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
return data; return data;
} }
READ32_MEMBER(zn_state::nbajamex_80_r) READ32_MEMBER(zn_state::nbajamex_80_r)
{ {
UINT32 data = 0xffffffff; UINT32 data = 0xffffffff;
verboselog( machine(), 0, "nbajamex_80_r( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(0, "nbajamex_80_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
return data; return data;
} }
@ -2048,7 +2054,7 @@ DRIVER_INIT_MEMBER(zn_state,coh1000a)
machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0x1fbfff90, 0x1fbfff9f, read32_delegate(FUNC(zn_state::jdredd_ide_r),this), write32_delegate(FUNC(zn_state::jdredd_ide_w),this) ); machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler(0x1fbfff90, 0x1fbfff9f, read32_delegate(FUNC(zn_state::jdredd_ide_r),this), write32_delegate(FUNC(zn_state::jdredd_ide_w),this) );
} }
zn_driver_init(machine()); zn_driver_init();
} }
MACHINE_RESET_MEMBER(zn_state,coh1000a) MACHINE_RESET_MEMBER(zn_state,coh1000a)
@ -2069,7 +2075,7 @@ MACHINE_CONFIG_END
static MACHINE_CONFIG_DERIVED( coh1000a_ide, zn1_2mb_vram ) static MACHINE_CONFIG_DERIVED( coh1000a_ide, zn1_2mb_vram )
MCFG_DEVICE_MODIFY( "gpu" ) MCFG_DEVICE_MODIFY( "gpu" )
MCFG_PSXGPU_VBLANK_CALLBACK( vblank_state_delegate( FUNC( jdredd_vblank ), (zn_state *) owner ) ) MCFG_PSXGPU_VBLANK_CALLBACK( vblank_state_delegate( FUNC( zn_state::jdredd_vblank ), (zn_state *) owner ) )
MCFG_MACHINE_RESET_OVERRIDE(zn_state, coh1000a ) MCFG_MACHINE_RESET_OVERRIDE(zn_state, coh1000a )
@ -2203,7 +2209,7 @@ DRIVER_INIT_MEMBER(zn_state,coh1001l)
machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank ( 0x1f000000, 0x1f7fffff, "bank1" ); /* banked rom */ machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank ( 0x1f000000, 0x1f7fffff, "bank1" ); /* banked rom */
machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler( 0x1fb00000, 0x1fb00003, write32_delegate(FUNC(zn_state::coh1001l_bnk_w),this) ); machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler( 0x1fb00000, 0x1fb00003, write32_delegate(FUNC(zn_state::coh1001l_bnk_w),this) );
zn_driver_init(machine()); zn_driver_init();
} }
MACHINE_RESET_MEMBER(zn_state,coh1001l) MACHINE_RESET_MEMBER(zn_state,coh1001l)
@ -2245,7 +2251,7 @@ DRIVER_INIT_MEMBER(zn_state,coh1002v)
machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank ( 0x1fb00000, 0x1fbfffff, "bank2" ); machine().device("maincpu")->memory().space(AS_PROGRAM).install_read_bank ( 0x1fb00000, 0x1fbfffff, "bank2" );
machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler( 0x1fb00000, 0x1fb00003, write32_delegate(FUNC(zn_state::coh1002v_bnk_w),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler( 0x1fb00000, 0x1fb00003, write32_delegate(FUNC(zn_state::coh1002v_bnk_w),this));
zn_driver_init(machine()); zn_driver_init();
} }
MACHINE_RESET_MEMBER(zn_state,coh1002v) MACHINE_RESET_MEMBER(zn_state,coh1002v)
@ -2418,7 +2424,7 @@ Notes:
WRITE32_MEMBER(zn_state::coh1002m_bank_w) WRITE32_MEMBER(zn_state::coh1002m_bank_w)
{ {
verboselog( machine(), 1, "coh1002m_bank_w( %08x, %08x, %08x )\n", offset, data, mem_mask ); verboselog(1, "coh1002m_bank_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
membank( "bank1" )->set_base( memregion( "user2" )->base() + ((data>>16) * 0x800000) ); membank( "bank1" )->set_base( memregion( "user2" )->base() + ((data>>16) * 0x800000) );
} }
@ -2447,7 +2453,7 @@ DRIVER_INIT_MEMBER(zn_state,coh1002m)
machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler( 0x1fb00000, 0x1fb00003, read32_delegate(FUNC(zn_state::cbaj_z80_r),this), write32_delegate(FUNC(zn_state::cbaj_z80_w),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_readwrite_handler( 0x1fb00000, 0x1fb00003, read32_delegate(FUNC(zn_state::cbaj_z80_r),this), write32_delegate(FUNC(zn_state::cbaj_z80_w),this));
machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler ( 0x1fb00004, 0x1fb00007, write32_delegate(FUNC(zn_state::coh1002m_bank_w),this)); machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler ( 0x1fb00004, 0x1fb00007, write32_delegate(FUNC(zn_state::coh1002m_bank_w),this));
zn_driver_init(machine()); zn_driver_init();
} }
MACHINE_RESET_MEMBER(zn_state,coh1002m) MACHINE_RESET_MEMBER(zn_state,coh1002m)