diff --git a/src/mame/drivers/ddenlovr.c b/src/mame/drivers/ddenlovr.c index 072a58d2838..d63c9a728f1 100644 --- a/src/mame/drivers/ddenlovr.c +++ b/src/mame/drivers/ddenlovr.c @@ -105,10 +105,6 @@ Notes: #include "includes/dynax.h" -UINT8 *ddenlovr_pixmap[8]; -static int extra_layers; - - /*************************************************************************** Blitter Data Format @@ -135,153 +131,220 @@ The drawing operation is verified (quiz365) to modify ddenlovr_blit_y. ***************************************************************************/ -static int ddenlovr_dest_layer; -static int ddenlovr_blit_flip; -static int ddenlovr_blit_x; -static int ddenlovr_blit_y; -static int ddenlovr_blit_address; -static int ddenlovr_blit_pen,ddenlovr_blit_pen_mode; -static int ddenlovr_blitter_irq_flag,ddenlovr_blitter_irq_enable; -static int ddenlovr_rect_width, ddenlovr_rect_height; -static int ddenlovr_clip_width, ddenlovr_clip_height; -static int ddenlovr_line_length; -static int ddenlovr_clip_ctrl,ddenlovr_clip_x,ddenlovr_clip_y; -static int ddenlovr_scroll[8*2]; -static int ddenlovr_priority, ddenlovr_priority2; -static int ddenlovr_bgcolor, ddenlovr_bgcolor2; -static int ddenlovr_layer_enable, ddenlovr_layer_enable2; -static int ddenlovr_palette_base[8], ddenlovr_palette_mask[8]; -static int ddenlovr_transparency_pen[8], ddenlovr_transparency_mask[8]; -static int ddenlovr_blit_reg; -static int ddenlovr_blit_pen_mask; // not implemented -static int ddenlovr_blit_rom_bits; // usually 8, 16 in hanakanz -static const int *ddenlovr_blit_commands; - enum { BLIT_NEXT = 0, BLIT_LINE, BLIT_COPY, BLIT_SKIP, BLIT_CHANGE_NUM, BLIT_CHANGE_PEN, BLIT_UNKNOWN, BLIT_STOP }; // 0 1 2 3 4 5 6 7 static const int ddenlovr_commands[8] = { BLIT_NEXT, BLIT_LINE, BLIT_COPY, BLIT_SKIP, BLIT_UNKNOWN, BLIT_CHANGE_NUM, BLIT_CHANGE_PEN, BLIT_STOP }; static const int hanakanz_commands[8] = { BLIT_NEXT, BLIT_CHANGE_PEN, BLIT_CHANGE_NUM, BLIT_UNKNOWN, BLIT_SKIP, BLIT_COPY, BLIT_LINE, BLIT_STOP }; static const int mjflove_commands[8] = { BLIT_STOP, BLIT_CHANGE_PEN, BLIT_CHANGE_NUM, BLIT_UNKNOWN, BLIT_SKIP, BLIT_COPY, BLIT_LINE, BLIT_NEXT }; -VIDEO_START(ddenlovr) +VIDEO_START( ddenlovr ) { + dynax_state *state = (dynax_state *)machine->driver_data; int i; + for (i = 0; i < 8; i++) { - ddenlovr_pixmap[i] = auto_alloc_array(machine, UINT8, 512*512); - ddenlovr_scroll[i*2+0] = ddenlovr_scroll[i*2+1] = 0; + state->ddenlovr_pixmap[i] = auto_alloc_array(machine, UINT8, 512 * 512); + state->ddenlovr_scroll[i * 2 + 0] = state->ddenlovr_scroll[i * 2 + 1] = 0; } - extra_layers = 0; + state->extra_layers = 0; - ddenlovr_clip_ctrl = 0x0f; - ddenlovr_layer_enable = ddenlovr_layer_enable2 = 0x0f; - ddenlovr_blit_pen_mask = 0xff; + state->ddenlovr_clip_ctrl = 0x0f; + state->ddenlovr_layer_enable = state->ddenlovr_layer_enable2 = 0x0f; + state->ddenlovr_blit_pen_mask = 0xff; // older games do not set these !? - ddenlovr_clip_width = 0x400; - ddenlovr_clip_height = 0x400; + state->ddenlovr_clip_width = 0x400; + state->ddenlovr_clip_height = 0x400; - ddenlovr_blit_rom_bits = 8; - ddenlovr_blit_commands = ddenlovr_commands; + state->ddenlovr_blit_rom_bits = 8; + state->ddenlovr_blit_commands = ddenlovr_commands; + + /* init to 0 the remaining elements */ + state->ddenlovr_dest_layer = 0; + state->ddenlovr_blit_flip = 0; + state->ddenlovr_blit_x = 0; + state->ddenlovr_blit_y = 0; + state->ddenlovr_blit_address = 0; + state->ddenlovr_blit_pen = 0; + state->ddenlovr_blit_pen_mode = 0; + state->ddenlovr_blitter_irq_flag = 0; + state->ddenlovr_blitter_irq_enable = 0; + state->ddenlovr_rect_width = 0; + state->ddenlovr_rect_height = 0; + state->ddenlovr_line_length = 0; + state->ddenlovr_clip_x = 0; + state->ddenlovr_clip_y = 0; + state->ddenlovr_priority = 0; + state->ddenlovr_priority2 = 0; + state->ddenlovr_bgcolor = 0; + state->ddenlovr_bgcolor2 = 0; + state->ddenlovr_blit_latch = 0; + state->ddenlovr_blit_regs[0] = 0; + state->ddenlovr_blit_regs[1] = 0; + + for (i = 0; i < 8; i++) + { + state->ddenlovr_palette_base[i] = 0; + state->ddenlovr_palette_mask[i] = 0; + state->ddenlovr_transparency_pen[i] = 0; + state->ddenlovr_transparency_mask[i] = 0; + } + + /* register save states */ + state_save_register_global(machine, state->ddenlovr_dest_layer); + state_save_register_global(machine, state->ddenlovr_blit_flip); + state_save_register_global(machine, state->ddenlovr_blit_x); + state_save_register_global(machine, state->ddenlovr_blit_y); + state_save_register_global(machine, state->ddenlovr_blit_address); + state_save_register_global(machine, state->ddenlovr_blit_pen); + state_save_register_global(machine, state->ddenlovr_blit_pen_mode); + state_save_register_global(machine, state->ddenlovr_blitter_irq_flag); + state_save_register_global(machine, state->ddenlovr_blitter_irq_enable); + state_save_register_global(machine, state->ddenlovr_rect_width); + state_save_register_global(machine, state->ddenlovr_rect_height); + state_save_register_global(machine, state->ddenlovr_clip_width); + state_save_register_global(machine, state->ddenlovr_clip_height); + state_save_register_global(machine, state->ddenlovr_line_length); + state_save_register_global(machine, state->ddenlovr_clip_ctrl); + state_save_register_global(machine, state->ddenlovr_clip_x); + state_save_register_global(machine, state->ddenlovr_clip_y); + state_save_register_global_array(machine, state->ddenlovr_scroll); + state_save_register_global(machine, state->ddenlovr_priority); + state_save_register_global(machine, state->ddenlovr_priority2); + state_save_register_global(machine, state->ddenlovr_bgcolor); + state_save_register_global(machine, state->ddenlovr_bgcolor2); + state_save_register_global(machine, state->ddenlovr_layer_enable); + state_save_register_global(machine, state->ddenlovr_layer_enable2); + state_save_register_global_array(machine, state->ddenlovr_palette_base); + state_save_register_global_array(machine, state->ddenlovr_palette_mask); + state_save_register_global_array(machine, state->ddenlovr_transparency_pen); + state_save_register_global_array(machine, state->ddenlovr_transparency_mask); + state_save_register_global(machine, state->ddenlovr_blit_latch); + state_save_register_global(machine, state->ddenlovr_blit_pen_mask); + state_save_register_global_array(machine, state->ddenlovr_blit_regs); + + state_save_register_global_pointer(machine, state->ddenlovr_pixmap[0], 512 * 512); + state_save_register_global_pointer(machine, state->ddenlovr_pixmap[1], 512 * 512); + state_save_register_global_pointer(machine, state->ddenlovr_pixmap[2], 512 * 512); + state_save_register_global_pointer(machine, state->ddenlovr_pixmap[3], 512 * 512); + state_save_register_global_pointer(machine, state->ddenlovr_pixmap[4], 512 * 512); + state_save_register_global_pointer(machine, state->ddenlovr_pixmap[5], 512 * 512); + state_save_register_global_pointer(machine, state->ddenlovr_pixmap[6], 512 * 512); + state_save_register_global_pointer(machine, state->ddenlovr_pixmap[7], 512 * 512); } -static VIDEO_START(mmpanic) +static VIDEO_START( mmpanic ) { + dynax_state *state = (dynax_state *)machine->driver_data; + VIDEO_START_CALL(ddenlovr); - extra_layers = 1; + state->extra_layers = 1; } -static VIDEO_START(hanakanz) +static VIDEO_START( hanakanz ) { + dynax_state *state = (dynax_state *)machine->driver_data; + VIDEO_START_CALL(ddenlovr); - ddenlovr_blit_rom_bits = 16; - ddenlovr_blit_commands = hanakanz_commands; + state->ddenlovr_blit_rom_bits = 16; + state->ddenlovr_blit_commands = hanakanz_commands; } -static VIDEO_START(mjflove) +static VIDEO_START( mjflove ) { + dynax_state *state = (dynax_state *)machine->driver_data; + VIDEO_START_CALL(ddenlovr); - ddenlovr_blit_commands = mjflove_commands; + state->ddenlovr_blit_commands = mjflove_commands; } static void ddenlovr_flipscreen_w( UINT8 data ) { - logerror("flipscreen = %02x (%s)\n",data,(data&1)?"off":"on"); + logerror("flipscreen = %02x (%s)\n", data, (data & 1) ? "off" : "on"); } -static void ddenlovr_blit_flip_w( UINT8 data ) +static void ddenlovr_blit_flip_w( running_machine *machine, UINT8 data ) { - if ((data ^ ddenlovr_blit_flip) & 0xec) + dynax_state *state = (dynax_state *)machine->driver_data; + + if ((data ^ state->ddenlovr_blit_flip) & 0xec) { #ifdef MAME_DEBUG - popmessage("warning ddenlovr_blit_flip = %02x",data); + popmessage("warning ddenlovr_blit_flip = %02x", data); #endif - logerror("warning ddenlovr_blit_flip = %02x\n",data); + logerror("warning ddenlovr_blit_flip = %02x\n", data); } - ddenlovr_blit_flip = data; + state->ddenlovr_blit_flip = data; } WRITE8_HANDLER( ddenlovr_bgcolor_w ) { - ddenlovr_bgcolor = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->ddenlovr_bgcolor = data; } static WRITE8_HANDLER( ddenlovr_bgcolor2_w ) { - ddenlovr_bgcolor2 = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->ddenlovr_bgcolor2 = data; } static WRITE16_HANDLER( ddenlovr16_bgcolor_w ) { if (ACCESSING_BITS_0_7) - ddenlovr_bgcolor_w(space,offset,data); + ddenlovr_bgcolor_w(space, offset, data); } WRITE8_HANDLER( ddenlovr_priority_w ) { - ddenlovr_priority = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->ddenlovr_priority = data; } static WRITE8_HANDLER( ddenlovr_priority2_w ) { - ddenlovr_priority2 = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->ddenlovr_priority2 = data; } static WRITE16_HANDLER( ddenlovr16_priority_w ) { if (ACCESSING_BITS_0_7) - ddenlovr_priority_w(space,offset,data); + ddenlovr_priority_w(space, offset, data); } WRITE8_HANDLER( ddenlovr_layer_enable_w ) { - ddenlovr_layer_enable = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->ddenlovr_layer_enable = data; } static WRITE8_HANDLER( ddenlovr_layer_enable2_w ) { - ddenlovr_layer_enable2 = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->ddenlovr_layer_enable2 = data; } static WRITE16_HANDLER( ddenlovr16_layer_enable_w ) { if (ACCESSING_BITS_0_7) - ddenlovr_layer_enable_w(space,offset,data); + ddenlovr_layer_enable_w(space, offset, data); } - -static void do_plot(int x,int y,int pen) +static void do_plot( running_machine *machine, int x, int y, int pen ) { + dynax_state *state = (dynax_state *)machine->driver_data; int addr, temp; int xclip, yclip; @@ -289,48 +352,48 @@ static void do_plot(int x,int y,int pen) x &= 0x1ff; // swap x & y (see hanakanz gal check) - if (ddenlovr_blit_flip & 0x10) { temp = x; x = y; y = temp; } + if (state->ddenlovr_blit_flip & 0x10) { temp = x; x = y; y = temp; } // clipping rectangle (see hanakanz / hkagerou gal check) #if 0 - xclip = (x < ddenlovr_clip_x) || (x > ddenlovr_clip_x+ddenlovr_clip_width); - yclip = (y < ddenlovr_clip_y) || (y > ddenlovr_clip_y+ddenlovr_clip_height); + xclip = (x < state->ddenlovr_clip_x) || (x > state->ddenlovr_clip_x + state->ddenlovr_clip_width); + yclip = (y < state->ddenlovr_clip_y) || (y > state->ddenlovr_clip_y + state->ddenlovr_clip_height); #else - xclip = (x < ddenlovr_clip_x) || (x > ddenlovr_clip_width); - yclip = (y < ddenlovr_clip_y) || (y > ddenlovr_clip_height); + xclip = (x < state->ddenlovr_clip_x) || (x > state->ddenlovr_clip_width); + yclip = (y < state->ddenlovr_clip_y) || (y > state->ddenlovr_clip_height); #endif - if (!(ddenlovr_clip_ctrl & 1) && xclip) return; - if (!(ddenlovr_clip_ctrl & 2) && !xclip) return; - if (!(ddenlovr_clip_ctrl & 4) && yclip) return; - if (!(ddenlovr_clip_ctrl & 8) && !yclip) return; + if (!(state->ddenlovr_clip_ctrl & 1) && xclip) return; + if (!(state->ddenlovr_clip_ctrl & 2) && !xclip) return; + if (!(state->ddenlovr_clip_ctrl & 4) && yclip) return; + if (!(state->ddenlovr_clip_ctrl & 8) && !yclip) return; addr = 512 * y + x; - if (ddenlovr_dest_layer & 0x0001) ddenlovr_pixmap[0][addr] = pen; - if (ddenlovr_dest_layer & 0x0002) ddenlovr_pixmap[1][addr] = pen; - if (ddenlovr_dest_layer & 0x0004) ddenlovr_pixmap[2][addr] = pen; - if (ddenlovr_dest_layer & 0x0008) ddenlovr_pixmap[3][addr] = pen; + if (state->ddenlovr_dest_layer & 0x0001) state->ddenlovr_pixmap[0][addr] = pen; + if (state->ddenlovr_dest_layer & 0x0002) state->ddenlovr_pixmap[1][addr] = pen; + if (state->ddenlovr_dest_layer & 0x0004) state->ddenlovr_pixmap[2][addr] = pen; + if (state->ddenlovr_dest_layer & 0x0008) state->ddenlovr_pixmap[3][addr] = pen; - if (!extra_layers) return; + if (!state->extra_layers) return; - if (ddenlovr_dest_layer & 0x0100) ddenlovr_pixmap[4][addr] = pen; - if (ddenlovr_dest_layer & 0x0200) ddenlovr_pixmap[5][addr] = pen; - if (ddenlovr_dest_layer & 0x0400) ddenlovr_pixmap[6][addr] = pen; - if (ddenlovr_dest_layer & 0x0800) ddenlovr_pixmap[7][addr] = pen; + if (state->ddenlovr_dest_layer & 0x0100) state->ddenlovr_pixmap[4][addr] = pen; + if (state->ddenlovr_dest_layer & 0x0200) state->ddenlovr_pixmap[5][addr] = pen; + if (state->ddenlovr_dest_layer & 0x0400) state->ddenlovr_pixmap[6][addr] = pen; + if (state->ddenlovr_dest_layer & 0x0800) state->ddenlovr_pixmap[7][addr] = pen; } -INLINE int fetch_bit(UINT8 *src_data,int src_len,int *bit_addr) +INLINE int fetch_bit( UINT8 *src_data, int src_len, int *bit_addr ) { int baddr = *bit_addr; *bit_addr = ((*bit_addr) + 1) & 0x7ffffff; - if (baddr/8 >= src_len) + if (baddr / 8 >= src_len) { #ifdef MAME_DEBUG - popmessage("GFX ROM OVER %06x",baddr/8); + popmessage("GFX ROM OVER %06x", baddr / 8); #endif return 1; } @@ -338,25 +401,25 @@ INLINE int fetch_bit(UINT8 *src_data,int src_len,int *bit_addr) return (src_data[baddr / 8] >> (7 - (baddr & 7))) & 1; } -INLINE int fetch_word(UINT8 *src_data,int src_len,int *bit_addr,int word_len) +INLINE int fetch_word( UINT8 *src_data, int src_len, int *bit_addr, int word_len ) { int res = 0; while (word_len--) { - res = (res << 1) | fetch_bit(src_data,src_len,bit_addr); + res = (res << 1) | fetch_bit(src_data, src_len, bit_addr); } return res; } -INLINE void log_draw_error(int src, int cmd) +INLINE void log_draw_error( int src, int cmd ) { #ifdef MAME_DEBUG - popmessage("%06x: warning unknown pixel command %02x",src,cmd); + popmessage("%06x: warning unknown pixel command %02x", src, cmd); #endif - logerror("%06x: warning unknown pixel command %02x\n",src,cmd); + logerror("%06x: warning unknown pixel command %02x\n", src, cmd); } /* Copy from ROM @@ -370,22 +433,23 @@ INLINE void log_draw_error(int src, int cmd) 06 blit_pen_mode (replace values stored in ROM) */ -static int blit_draw(running_machine *machine, int src,int sx) +static int blit_draw( running_machine *machine, int src, int sx ) { + dynax_state *state = (dynax_state *)machine->driver_data; UINT8 *src_data = memory_region(machine, "blitter"); int src_len = memory_region_length(machine, "blitter"); - int bit_addr = (src & 0xffffff) * ddenlovr_blit_rom_bits; /* convert to bit address */ + int bit_addr = (src & 0xffffff) * state->ddenlovr_blit_rom_bits; /* convert to bit address */ int pen_size, arg_size, cmd; int x; - int xinc = (ddenlovr_blit_flip & 1) ? -1 : 1; - int yinc = (ddenlovr_blit_flip & 2) ? -1 : 1; + int xinc = (state->ddenlovr_blit_flip & 1) ? -1 : 1; + int yinc = (state->ddenlovr_blit_flip & 2) ? -1 : 1; - pen_size = fetch_word(src_data,src_len,&bit_addr,4) + 1; - arg_size = fetch_word(src_data,src_len,&bit_addr,4) + 1; + pen_size = fetch_word(src_data, src_len, &bit_addr, 4) + 1; + arg_size = fetch_word(src_data, src_len, &bit_addr, 4) + 1; #ifdef MAME_DEBUG if (pen_size > 4 || arg_size > 8) - popmessage("warning: pen_size %d arg_size %d",pen_size,arg_size); + popmessage("warning: pen_size %d arg_size %d", pen_size, arg_size); #endif // sryudens game bug @@ -396,24 +460,27 @@ static int blit_draw(running_machine *machine, int src,int sx) for (;;) { - cmd = fetch_word(src_data,src_len,&bit_addr,3); - switch ( ddenlovr_blit_commands[cmd] ) + cmd = fetch_word(src_data, src_len, &bit_addr, 3); + switch (state->ddenlovr_blit_commands[cmd]) { case BLIT_NEXT: /* next line */ - ddenlovr_blit_y += yinc; + state->ddenlovr_blit_y += yinc; x = sx; break; case BLIT_LINE: { - int length = fetch_word(src_data,src_len,&bit_addr,arg_size); - int pen = fetch_word(src_data,src_len,&bit_addr,pen_size); - if (ddenlovr_blit_pen_mode) pen = (ddenlovr_blit_pen & 0x0f); - pen |= ddenlovr_blit_pen & 0xf0; + int length = fetch_word(src_data, src_len, &bit_addr, arg_size); + int pen = fetch_word(src_data, src_len, &bit_addr, pen_size); + + if (state->ddenlovr_blit_pen_mode) + pen = (state->ddenlovr_blit_pen & 0x0f); + pen |= state->ddenlovr_blit_pen & 0xf0; + while (length-- >= 0) { - do_plot(x,ddenlovr_blit_y,pen); + do_plot(machine, x, state->ddenlovr_blit_y, pen); x += xinc; } } @@ -421,35 +488,38 @@ static int blit_draw(running_machine *machine, int src,int sx) case BLIT_COPY: { - int length = fetch_word(src_data,src_len,&bit_addr,arg_size); + int length = fetch_word(src_data, src_len, &bit_addr, arg_size); + while (length-- >= 0) { - int pen = fetch_word(src_data,src_len,&bit_addr,pen_size); - if (ddenlovr_blit_pen_mode) pen = (ddenlovr_blit_pen & 0x0f); - pen |= ddenlovr_blit_pen & 0xf0; - do_plot(x,ddenlovr_blit_y,pen); + int pen = fetch_word(src_data, src_len, &bit_addr, pen_size); + if (state->ddenlovr_blit_pen_mode) + pen = (state->ddenlovr_blit_pen & 0x0f); + pen |= state->ddenlovr_blit_pen & 0xf0; + + do_plot(machine, x, state->ddenlovr_blit_y, pen); x += xinc; } } break; case BLIT_SKIP: - x += xinc * fetch_word(src_data,src_len,&bit_addr,arg_size); + x += xinc * fetch_word(src_data, src_len, &bit_addr, arg_size); break; case BLIT_CHANGE_NUM: - arg_size = fetch_word(src_data,src_len,&bit_addr,4) + 1; + arg_size = fetch_word(src_data, src_len, &bit_addr, 4) + 1; break; case BLIT_CHANGE_PEN: - pen_size = fetch_word(src_data,src_len,&bit_addr,3) + 1; + pen_size = fetch_word(src_data, src_len, &bit_addr, 3) + 1; break; default: - log_draw_error(src,cmd); + log_draw_error(src, cmd); // fall through case BLIT_STOP: - return ((bit_addr + ddenlovr_blit_rom_bits - 1) / ddenlovr_blit_rom_bits) & 0xffffff; + return ((bit_addr + state->ddenlovr_blit_rom_bits - 1) / state->ddenlovr_blit_rom_bits) & 0xffffff; } } } @@ -458,18 +528,19 @@ static int blit_draw(running_machine *machine, int src,int sx) /* Draw a simple rectangle */ -static void blit_rect_xywh(void) +static void blit_rect_xywh( running_machine *machine ) { - int x,y; + dynax_state *state = (dynax_state *)machine->driver_data; + int x, y; #ifdef MAME_DEBUG -// if (ddenlovr_clip_ctrl != 0x0f) -// popmessage("RECT clipx=%03x clipy=%03x ctrl=%x",ddenlovr_clip_x,ddenlovr_clip_y,ddenlovr_clip_ctrl); +// if (state->ddenlovr_clip_ctrl != 0x0f) +// popmessage("RECT clipx=%03x clipy=%03x ctrl=%x", state->ddenlovr_clip_x, state->ddenlovr_clip_y, state->ddenlovr_clip_ctrl); #endif - for (y = 0; y <= ddenlovr_rect_height; y++) - for (x = 0; x <= ddenlovr_rect_width; x++) - do_plot( x + ddenlovr_blit_x, y + ddenlovr_blit_y, ddenlovr_blit_pen); + for (y = 0; y <= state->ddenlovr_rect_height; y++) + for (x = 0; x <= state->ddenlovr_rect_width; x++) + do_plot(machine, x + state->ddenlovr_blit_x, y + state->ddenlovr_blit_y, state->ddenlovr_blit_pen); } @@ -484,32 +555,33 @@ static void blit_rect_xywh(void) 04 blit_pen 0c line_length - always 0? */ -static void blit_rect_yh(void) +static void blit_rect_yh( running_machine *machine ) { - int start = 512 * ddenlovr_blit_y; - int length = 512 * (ddenlovr_rect_height+1); + dynax_state *state = (dynax_state *)machine->driver_data; + int start = 512 * state->ddenlovr_blit_y; + int length = 512 * (state->ddenlovr_rect_height + 1); #ifdef MAME_DEBUG -// if (ddenlovr_clip_ctrl != 0x0f) -// popmessage("UNK8C clipx=%03x clipy=%03x ctrl=%x",ddenlovr_clip_x,ddenlovr_clip_y,ddenlovr_clip_ctrl); +// if (state->ddenlovr_clip_ctrl != 0x0f) +// popmessage("UNK8C clipx=%03x clipy=%03x ctrl=%x", state->ddenlovr_clip_x, state->ddenlovr_clip_y, state->ddenlovr_clip_ctrl); #endif - if (start < 512*512) + if (start < 512 * 512) { - if (start + length > 512*512) - length = 512*512 - start; + if (start + length > 512 * 512) + length = 512 * 512 - start; - if (ddenlovr_dest_layer & 0x0001) memset(ddenlovr_pixmap[0] + start,ddenlovr_blit_pen,length); - if (ddenlovr_dest_layer & 0x0002) memset(ddenlovr_pixmap[1] + start,ddenlovr_blit_pen,length); - if (ddenlovr_dest_layer & 0x0004) memset(ddenlovr_pixmap[2] + start,ddenlovr_blit_pen,length); - if (ddenlovr_dest_layer & 0x0008) memset(ddenlovr_pixmap[3] + start,ddenlovr_blit_pen,length); + if (state->ddenlovr_dest_layer & 0x0001) memset(state->ddenlovr_pixmap[0] + start, state->ddenlovr_blit_pen, length); + if (state->ddenlovr_dest_layer & 0x0002) memset(state->ddenlovr_pixmap[1] + start, state->ddenlovr_blit_pen, length); + if (state->ddenlovr_dest_layer & 0x0004) memset(state->ddenlovr_pixmap[2] + start, state->ddenlovr_blit_pen, length); + if (state->ddenlovr_dest_layer & 0x0008) memset(state->ddenlovr_pixmap[3] + start, state->ddenlovr_blit_pen, length); - if (!extra_layers) return; + if (!state->extra_layers) return; - if (ddenlovr_dest_layer & 0x0100) memset(ddenlovr_pixmap[4] + start,ddenlovr_blit_pen,length); - if (ddenlovr_dest_layer & 0x0200) memset(ddenlovr_pixmap[5] + start,ddenlovr_blit_pen,length); - if (ddenlovr_dest_layer & 0x0400) memset(ddenlovr_pixmap[6] + start,ddenlovr_blit_pen,length); - if (ddenlovr_dest_layer & 0x0800) memset(ddenlovr_pixmap[7] + start,ddenlovr_blit_pen,length); + if (state->ddenlovr_dest_layer & 0x0100) memset(state->ddenlovr_pixmap[4] + start, state->ddenlovr_blit_pen, length); + if (state->ddenlovr_dest_layer & 0x0200) memset(state->ddenlovr_pixmap[5] + start, state->ddenlovr_blit_pen, length); + if (state->ddenlovr_dest_layer & 0x0400) memset(state->ddenlovr_pixmap[6] + start, state->ddenlovr_blit_pen, length); + if (state->ddenlovr_dest_layer & 0x0800) memset(state->ddenlovr_pixmap[7] + start, state->ddenlovr_blit_pen, length); } } @@ -523,26 +595,27 @@ static void blit_rect_yh(void) 02 Y 04 blit_pen */ -static void blit_fill_xy(int x, int y) +static void blit_fill_xy( running_machine *machine, int x, int y ) { + dynax_state *state = (dynax_state *)machine->driver_data; int start = 512 * y + x; #ifdef MAME_DEBUG // if (x || y) -// popmessage("FILL command X %03x Y %03x",x,y); +// popmessage("FILL command X %03x Y %03x", x, y); #endif - if (ddenlovr_dest_layer & 0x0001) memset(ddenlovr_pixmap[0] + start,ddenlovr_blit_pen,512*512 - start); - if (ddenlovr_dest_layer & 0x0002) memset(ddenlovr_pixmap[1] + start,ddenlovr_blit_pen,512*512 - start); - if (ddenlovr_dest_layer & 0x0004) memset(ddenlovr_pixmap[2] + start,ddenlovr_blit_pen,512*512 - start); - if (ddenlovr_dest_layer & 0x0008) memset(ddenlovr_pixmap[3] + start,ddenlovr_blit_pen,512*512 - start); + if (state->ddenlovr_dest_layer & 0x0001) memset(state->ddenlovr_pixmap[0] + start, state->ddenlovr_blit_pen, 512 * 512 - start); + if (state->ddenlovr_dest_layer & 0x0002) memset(state->ddenlovr_pixmap[1] + start, state->ddenlovr_blit_pen, 512 * 512 - start); + if (state->ddenlovr_dest_layer & 0x0004) memset(state->ddenlovr_pixmap[2] + start, state->ddenlovr_blit_pen, 512 * 512 - start); + if (state->ddenlovr_dest_layer & 0x0008) memset(state->ddenlovr_pixmap[3] + start, state->ddenlovr_blit_pen, 512 * 512 - start); - if (!extra_layers) return; + if (!state->extra_layers) return; - if (ddenlovr_dest_layer & 0x0100) memset(ddenlovr_pixmap[4] + start,ddenlovr_blit_pen,512*512 - start); - if (ddenlovr_dest_layer & 0x0200) memset(ddenlovr_pixmap[5] + start,ddenlovr_blit_pen,512*512 - start); - if (ddenlovr_dest_layer & 0x0400) memset(ddenlovr_pixmap[6] + start,ddenlovr_blit_pen,512*512 - start); - if (ddenlovr_dest_layer & 0x0800) memset(ddenlovr_pixmap[7] + start,ddenlovr_blit_pen,512*512 - start); + if (state->ddenlovr_dest_layer & 0x0100) memset(state->ddenlovr_pixmap[4] + start, state->ddenlovr_blit_pen, 512 * 512 - start); + if (state->ddenlovr_dest_layer & 0x0200) memset(state->ddenlovr_pixmap[5] + start, state->ddenlovr_blit_pen, 512 * 512 - start); + if (state->ddenlovr_dest_layer & 0x0400) memset(state->ddenlovr_pixmap[6] + start, state->ddenlovr_blit_pen, 512 * 512 - start); + if (state->ddenlovr_dest_layer & 0x0800) memset(state->ddenlovr_pixmap[7] + start, state->ddenlovr_blit_pen, 512 * 512 - start); } @@ -557,22 +630,23 @@ static void blit_fill_xy(int x, int y) 04 blit_pen ddenlovr_blit_x and ddenlovr_blit_y are left pointing to the last pixel at the end of the command */ -static void blit_horiz_line(void) +static void blit_horiz_line( running_machine *machine ) { + dynax_state *state = (dynax_state *)machine->driver_data; int i; #ifdef MAME_DEBUG popmessage("LINE X"); - if (ddenlovr_clip_ctrl != 0x0f) - popmessage("LINE X clipx=%03x clipy=%03x ctrl=%x",ddenlovr_clip_x,ddenlovr_clip_y,ddenlovr_clip_ctrl); + if (state->ddenlovr_clip_ctrl != 0x0f) + popmessage("LINE X clipx=%03x clipy=%03x ctrl=%x", state->ddenlovr_clip_x, state->ddenlovr_clip_y, state->ddenlovr_clip_ctrl); - if (ddenlovr_blit_flip) - popmessage("LINE X flip=%x",ddenlovr_blit_flip); + if (state->ddenlovr_blit_flip) + popmessage("LINE X flip=%x", state->ddenlovr_blit_flip); #endif - for (i = 0; i <= ddenlovr_line_length; i++) - do_plot(ddenlovr_blit_x++,ddenlovr_blit_y,ddenlovr_blit_pen); + for (i = 0; i <= state->ddenlovr_line_length; i++) + do_plot(machine, state->ddenlovr_blit_x++, state->ddenlovr_blit_y, state->ddenlovr_blit_pen); } @@ -587,56 +661,59 @@ static void blit_horiz_line(void) 04 blit_pen ddenlovr_blit_x and ddenlovr_blit_y are left pointing to the last pixel at the end of the command */ -static void blit_vert_line(void) +static void blit_vert_line( running_machine *machine ) { + dynax_state *state = (dynax_state *)machine->driver_data; int i; #ifdef MAME_DEBUG popmessage("LINE Y"); - if (ddenlovr_clip_ctrl != 0x0f) - popmessage("LINE Y clipx=%03x clipy=%03x ctrl=%x",ddenlovr_clip_x,ddenlovr_clip_y,ddenlovr_clip_ctrl); + if (state->ddenlovr_clip_ctrl != 0x0f) + popmessage("LINE Y clipx=%03x clipy=%03x ctrl=%x", state->ddenlovr_clip_x, state->ddenlovr_clip_y, state->ddenlovr_clip_ctrl); #endif - for (i = 0; i <= ddenlovr_line_length; i++) - do_plot(ddenlovr_blit_x,ddenlovr_blit_y++,ddenlovr_blit_pen); + for (i = 0; i <= state->ddenlovr_line_length; i++) + do_plot(machine, state->ddenlovr_blit_x, state->ddenlovr_blit_y++, state->ddenlovr_blit_pen); } -INLINE void log_blit(running_machine *machine, int data) +INLINE void log_blit( running_machine *machine, int data ) { + dynax_state *state = (dynax_state *)machine->driver_data; + #if 1 logerror("%s: blit src %06x x %03x y %03x flags %02x layer %02x pen %02x penmode %02x w %03x h %03x linelen %03x flip %02x clip: ctrl %x xy %03x %03x wh %03x %03x\n", cpuexec_describe_context(machine), - ddenlovr_blit_address,ddenlovr_blit_x,ddenlovr_blit_y,data, - ddenlovr_dest_layer,ddenlovr_blit_pen,ddenlovr_blit_pen_mode,ddenlovr_rect_width,ddenlovr_rect_height,ddenlovr_line_length,ddenlovr_blit_flip, - ddenlovr_clip_ctrl,ddenlovr_clip_x,ddenlovr_clip_y, ddenlovr_clip_width,ddenlovr_clip_height ); + state->ddenlovr_blit_address, state->ddenlovr_blit_x, state->ddenlovr_blit_y, data, + state->ddenlovr_dest_layer, state->ddenlovr_blit_pen, state->ddenlovr_blit_pen_mode, state->ddenlovr_rect_width, state->ddenlovr_rect_height, state->ddenlovr_line_length, state->ddenlovr_blit_flip, + state->ddenlovr_clip_ctrl, state->ddenlovr_clip_x, state->ddenlovr_clip_y, state->ddenlovr_clip_width, state->ddenlovr_clip_height); #endif } -static void blitter_w(const address_space *space, int blitter, offs_t offset,UINT8 data,int irq_vector) +static void blitter_w( const address_space *space, int blitter, offs_t offset, UINT8 data, int irq_vector ) { - static int ddenlovr_blit_reg[2]; + dynax_state *state = (dynax_state *)space->machine->driver_data; int hi_bits; profiler_mark_start(PROFILER_VIDEO); - switch(offset) + switch (offset) { case 0: - ddenlovr_blit_reg[blitter] = data; + state->ddenlovr_blit_regs[blitter] = data; break; case 1: - hi_bits = (ddenlovr_blit_reg[blitter] & 0xc0) << 2; + hi_bits = (state->ddenlovr_blit_regs[blitter] & 0xc0) << 2; - switch(ddenlovr_blit_reg[blitter] & 0x3f) + switch (state->ddenlovr_blit_regs[blitter] & 0x3f) { case 0x00: - if (blitter) ddenlovr_dest_layer = (ddenlovr_dest_layer & 0x00ff) | (data<<8); - else ddenlovr_dest_layer = (ddenlovr_dest_layer & 0xff00) | (data<<0); + if (blitter) state->ddenlovr_dest_layer = (state->ddenlovr_dest_layer & 0x00ff) | (data << 8); + else state->ddenlovr_dest_layer = (state->ddenlovr_dest_layer & 0xff00) | (data << 0); break; case 0x01: @@ -644,60 +721,60 @@ profiler_mark_start(PROFILER_VIDEO); break; case 0x02: - ddenlovr_blit_y = data | hi_bits; + state->ddenlovr_blit_y = data | hi_bits; break; case 0x03: - ddenlovr_blit_flip_w(data); + ddenlovr_blit_flip_w(space->machine, data); break; case 0x04: - ddenlovr_blit_pen = data; + state->ddenlovr_blit_pen = data; break; case 0x05: - ddenlovr_blit_pen_mask = data; + state->ddenlovr_blit_pen_mask = data; break; case 0x06: // related to pen, can be 0 or 1 for 0x10 blitter command // 0 = only bits 7-4 of ddenlovr_blit_pen contain data // 1 = bits 3-0 contain data as well - ddenlovr_blit_pen_mode = data; + state->ddenlovr_blit_pen_mode = data; break; case 0x0a: - ddenlovr_rect_width = data | hi_bits; + state->ddenlovr_rect_width = data | hi_bits; break; case 0x0b: - ddenlovr_rect_height = data | hi_bits; + state->ddenlovr_rect_height = data | hi_bits; break; case 0x0c: - ddenlovr_line_length = data | hi_bits; + state->ddenlovr_line_length = data | hi_bits; break; case 0x0d: - ddenlovr_blit_address = (ddenlovr_blit_address & 0xffff00) | (data <<0); + state->ddenlovr_blit_address = (state->ddenlovr_blit_address & 0xffff00) | (data <<0); break; case 0x0e: - ddenlovr_blit_address = (ddenlovr_blit_address & 0xff00ff) | (data <<8); + state->ddenlovr_blit_address = (state->ddenlovr_blit_address & 0xff00ff) | (data <<8); break; case 0x0f: - ddenlovr_blit_address = (ddenlovr_blit_address & 0x00ffff) | (data<<16); + state->ddenlovr_blit_address = (state->ddenlovr_blit_address & 0x00ffff) | (data<<16); break; case 0x14: - ddenlovr_blit_x = data | hi_bits; + state->ddenlovr_blit_x = data | hi_bits; break; case 0x16: - ddenlovr_clip_x = data | hi_bits; + state->ddenlovr_clip_x = data | hi_bits; break; case 0x17: - ddenlovr_clip_y = data | hi_bits; + state->ddenlovr_clip_y = data | hi_bits; break; case 0x18: @@ -708,11 +785,11 @@ profiler_mark_start(PROFILER_VIDEO); case 0x1d: case 0x1e: case 0x1f: - ddenlovr_scroll[blitter*8 + (ddenlovr_blit_reg[blitter] & 7)] = data | hi_bits; + state->ddenlovr_scroll[blitter * 8 + (state->ddenlovr_blit_regs[blitter] & 7)] = data | hi_bits; break; case 0x20: - ddenlovr_clip_ctrl = data; + state->ddenlovr_clip_ctrl = data; break; case 0x24: @@ -721,33 +798,33 @@ profiler_mark_start(PROFILER_VIDEO); switch (data) { - case 0x04: blit_fill_xy(0, 0); + case 0x04: blit_fill_xy(space->machine, 0, 0); break; - case 0x14: blit_fill_xy(ddenlovr_blit_x, ddenlovr_blit_y); + case 0x14: blit_fill_xy(space->machine, state->ddenlovr_blit_x, state->ddenlovr_blit_y); break; - case 0x10: ddenlovr_blit_address = blit_draw(space->machine,ddenlovr_blit_address,ddenlovr_blit_x); + case 0x10: state->ddenlovr_blit_address = blit_draw(space->machine, state->ddenlovr_blit_address, state->ddenlovr_blit_x); break; - case 0x13: blit_horiz_line(); + case 0x13: blit_horiz_line(space->machine); break; - case 0x1b: blit_vert_line(); + case 0x1b: blit_vert_line(space->machine); break; - case 0x1c: blit_rect_xywh(); + case 0x1c: blit_rect_xywh(space->machine); break; // These two are issued one after the other (43 then 8c) // 8c is issued immediately after 43 has finished, without // changing any argument case 0x43: break; - case 0x8c: blit_rect_yh(); + case 0x8c: blit_rect_yh(space->machine); break; default: ; #ifdef MAME_DEBUG - popmessage("unknown blitter command %02x",data); + popmessage("unknown blitter command %02x", data); logerror("%06x: unknown blitter command %02x\n", cpu_get_pc(space->cpu), data); #endif } @@ -758,16 +835,16 @@ profiler_mark_start(PROFILER_VIDEO); else { /* ddenlovr */ - if (ddenlovr_blitter_irq_enable) + if (state->ddenlovr_blitter_irq_enable) { - ddenlovr_blitter_irq_flag = 1; - cpu_set_input_line(space->cpu,1,HOLD_LINE); + state->ddenlovr_blitter_irq_flag = 1; + cpu_set_input_line(space->cpu, 1, HOLD_LINE); } } break; default: - logerror("%06x: Blitter %d reg %02x = %02x\n", cpu_get_pc(space->cpu), blitter, ddenlovr_blit_reg[blitter], data); + logerror("%06x: Blitter %d reg %02x = %02x\n", cpu_get_pc(space->cpu), blitter, state->ddenlovr_blit_regs[blitter], data); break; } } @@ -779,9 +856,9 @@ profiler_mark_end(); // differences wrt blitter_data_w: slightly different blitter commands -static void blitter_w_funkyfig(running_machine *machine, int blitter, offs_t offset,UINT8 data,int irq_vector) +static void blitter_w_funkyfig( running_machine *machine, int blitter, offs_t offset, UINT8 data, int irq_vector ) { - static int ddenlovr_blit_reg[2]; + dynax_state *state = (dynax_state *)machine->driver_data; int hi_bits; profiler_mark_start(PROFILER_VIDEO); @@ -789,17 +866,17 @@ profiler_mark_start(PROFILER_VIDEO); switch(offset) { case 0: - ddenlovr_blit_reg[blitter] = data; + state->ddenlovr_blit_regs[blitter] = data; break; case 1: - hi_bits = (ddenlovr_blit_reg[blitter] & 0xc0) << 2; + hi_bits = (state->ddenlovr_blit_regs[blitter] & 0xc0) << 2; - switch(ddenlovr_blit_reg[blitter] & 0x3f) + switch (state->ddenlovr_blit_regs[blitter] & 0x3f) { case 0x00: - if (blitter) ddenlovr_dest_layer = (ddenlovr_dest_layer & 0x00ff) | (data<<8); - else ddenlovr_dest_layer = (ddenlovr_dest_layer & 0xff00) | (data<<0); + if (blitter) state->ddenlovr_dest_layer = (state->ddenlovr_dest_layer & 0x00ff) | (data << 8); + else state->ddenlovr_dest_layer = (state->ddenlovr_dest_layer & 0xff00) | (data << 0); break; case 0x01: @@ -807,60 +884,60 @@ profiler_mark_start(PROFILER_VIDEO); break; case 0x02: - ddenlovr_blit_y = data | hi_bits; + state->ddenlovr_blit_y = data | hi_bits; break; case 0x03: - ddenlovr_blit_flip_w(data); + ddenlovr_blit_flip_w(machine, data); break; case 0x04: - ddenlovr_blit_pen = data; + state->ddenlovr_blit_pen = data; break; case 0x05: - ddenlovr_blit_pen_mask = data; + state->ddenlovr_blit_pen_mask = data; break; case 0x06: // related to pen, can be 0 or 1 for 0x10 blitter command // 0 = only bits 7-4 of ddenlovr_blit_pen contain data // 1 = bits 3-0 contain data as well - ddenlovr_blit_pen_mode = data; + state->ddenlovr_blit_pen_mode = data; break; case 0x0a: - ddenlovr_rect_width = data | hi_bits; + state->ddenlovr_rect_width = data | hi_bits; break; case 0x0b: - ddenlovr_rect_height = data | hi_bits; + state->ddenlovr_rect_height = data | hi_bits; break; case 0x0c: - ddenlovr_line_length = data | hi_bits; + state->ddenlovr_line_length = data | hi_bits; break; case 0x0d: - ddenlovr_blit_address = (ddenlovr_blit_address & 0xffff00) | (data <<0); + state->ddenlovr_blit_address = (state->ddenlovr_blit_address & 0xffff00) | (data << 0); break; case 0x0e: - ddenlovr_blit_address = (ddenlovr_blit_address & 0xff00ff) | (data <<8); + state->ddenlovr_blit_address = (state->ddenlovr_blit_address & 0xff00ff) | (data << 8); break; case 0x0f: - ddenlovr_blit_address = (ddenlovr_blit_address & 0x00ffff) | (data<<16); + state->ddenlovr_blit_address = (state->ddenlovr_blit_address & 0x00ffff) | (data << 16); break; case 0x14: - ddenlovr_blit_x = data | hi_bits; + state->ddenlovr_blit_x = data | hi_bits; break; case 0x16: - ddenlovr_clip_x = data | hi_bits; + state->ddenlovr_clip_x = data | hi_bits; break; case 0x17: - ddenlovr_clip_y = data | hi_bits; + state->ddenlovr_clip_y = data | hi_bits; break; case 0x18: @@ -871,11 +948,11 @@ profiler_mark_start(PROFILER_VIDEO); case 0x1d: case 0x1e: case 0x1f: - ddenlovr_scroll[blitter*8 + (ddenlovr_blit_reg[blitter] & 7)] = data | hi_bits; + state->ddenlovr_scroll[blitter * 8 + (state->ddenlovr_blit_regs[blitter] & 7)] = data | hi_bits; break; case 0x20: - ddenlovr_clip_ctrl = data; + state->ddenlovr_clip_ctrl = data; break; case 0x24: @@ -886,46 +963,46 @@ profiler_mark_start(PROFILER_VIDEO); { case 0x84: // same as 04? - case 0x04: blit_fill_xy(0, 0); + case 0x04: blit_fill_xy(machine, 0, 0); break; // unused? -// case 0x14: blit_fill_xy(ddenlovr_blit_x, ddenlovr_blit_y); +// case 0x14: blit_fill_xy(machine, state->ddenlovr_blit_x, state->ddenlovr_blit_y); // break; - case 0x00/*0x10*/: ddenlovr_blit_address = blit_draw(machine,ddenlovr_blit_address,ddenlovr_blit_x); + case 0x00/*0x10*/: state->ddenlovr_blit_address = blit_draw(machine, state->ddenlovr_blit_address, state->ddenlovr_blit_x); break; case 0x0b: // same as 03? see the drawing of the R in "cRoss hatch" (key test) - case 0x03/*0x13*/: blit_horiz_line(); + case 0x03/*0x13*/: blit_horiz_line(machine); break; // unused? -// case 0x1b: blit_vert_line(); +// case 0x1b: blit_vert_line(machine); // break; - case 0x0c/*0x1c*/: blit_rect_xywh(); + case 0x0c/*0x1c*/: blit_rect_xywh(machine); break; // These two are issued one after the other (43 then 8c) // 8c is issued immediately after 43 has finished, without // changing any argument case 0x43: break; - case 0x8c: blit_rect_yh(); + case 0x8c: blit_rect_yh(machine); break; default: ; #ifdef MAME_DEBUG - popmessage("unknown blitter command %02x",data); + popmessage("unknown blitter command %02x", data); logerror("%s: unknown blitter command %02x\n", cpuexec_describe_context(machine), data); #endif } - cputag_set_input_line_and_vector(machine, "maincpu", 0, HOLD_LINE, irq_vector); + cpu_set_input_line_and_vector(state->maincpu, 0, HOLD_LINE, irq_vector); break; default: - logerror("%s: Blitter %d reg %02x = %02x\n", cpuexec_describe_context(machine), blitter, ddenlovr_blit_reg[blitter], data); + logerror("%s: Blitter %d reg %02x = %02x\n", cpuexec_describe_context(machine), blitter, state->ddenlovr_blit_regs[blitter], data); break; } } @@ -938,22 +1015,24 @@ profiler_mark_end(); static WRITE8_HANDLER( hanakanz_blitter_reg_w ) { - ddenlovr_blit_reg = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->ddenlovr_blit_latch = data; } // differences wrt blitter_data_w: registers are shuffled around, hi_bits in the low bits, clip_w/h, includes layers registers static WRITE8_HANDLER( hanakanz_blitter_data_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; int hi_bits; profiler_mark_start(PROFILER_VIDEO); - hi_bits = (ddenlovr_blit_reg & 0x03) << 8; + hi_bits = (state->ddenlovr_blit_latch & 0x03) << 8; - switch(ddenlovr_blit_reg & 0xfe) + switch (state->ddenlovr_blit_latch & 0xfe) { case 0x00: - ddenlovr_dest_layer = data; + state->ddenlovr_dest_layer = data; break; case 0x04: @@ -961,60 +1040,60 @@ profiler_mark_start(PROFILER_VIDEO); break; case 0x08: - ddenlovr_blit_y = data | hi_bits; + state->ddenlovr_blit_y = data | hi_bits; break; case 0x0c: - ddenlovr_blit_flip_w(data); + ddenlovr_blit_flip_w(space->machine, data); break; case 0x10: - ddenlovr_blit_pen = data; + state->ddenlovr_blit_pen = data; break; case 0x14: - ddenlovr_blit_pen_mask = data; + state->ddenlovr_blit_pen_mask = data; break; case 0x18: // related to pen, can be 0 or 1 for 0x10 blitter command // 0 = only bits 7-4 of ddenlovr_blit_pen contain data // 1 = bits 3-0 contain data as well - ddenlovr_blit_pen_mode = data; + state->ddenlovr_blit_pen_mode = data; break; case 0x28: - ddenlovr_rect_width = data | hi_bits; + state->ddenlovr_rect_width = data | hi_bits; break; case 0x2c: - ddenlovr_rect_height = data | hi_bits; + state->ddenlovr_rect_height = data | hi_bits; break; case 0x30: - ddenlovr_line_length = data | hi_bits; + state->ddenlovr_line_length = data | hi_bits; break; case 0x34: - ddenlovr_blit_address = (ddenlovr_blit_address & 0xffff00) | (data <<0); + state->ddenlovr_blit_address = (state->ddenlovr_blit_address & 0xffff00) | (data << 0); break; case 0x38: - ddenlovr_blit_address = (ddenlovr_blit_address & 0xff00ff) | (data <<8); + state->ddenlovr_blit_address = (state->ddenlovr_blit_address & 0xff00ff) | (data << 8); break; case 0x3c: - ddenlovr_blit_address = (ddenlovr_blit_address & 0x00ffff) | (data<<16); + state->ddenlovr_blit_address = (state->ddenlovr_blit_address & 0x00ffff) | (data << 16); break; case 0x50: - ddenlovr_blit_x = data | hi_bits; + state->ddenlovr_blit_x = data | hi_bits; break; case 0x58: - ddenlovr_clip_x = data | hi_bits; + state->ddenlovr_clip_x = data | hi_bits; break; case 0x5c: - ddenlovr_clip_y = data | hi_bits; + state->ddenlovr_clip_y = data | hi_bits; break; case 0x60: @@ -1025,61 +1104,61 @@ profiler_mark_start(PROFILER_VIDEO); case 0x74: case 0x78: case 0x7c: - ddenlovr_scroll[(ddenlovr_blit_reg & 0x1c) >> 2] = data | hi_bits; + state->ddenlovr_scroll[(state->ddenlovr_blit_latch & 0x1c) >> 2] = data | hi_bits; break; case 0x80: - ddenlovr_clip_ctrl = data; + state->ddenlovr_clip_ctrl = data; break; case 0x88: case 0x8a: // can be 3ff - ddenlovr_clip_height = data | hi_bits; + state->ddenlovr_clip_height = data | hi_bits; break; case 0x8c: case 0x8e: // can be 3ff - ddenlovr_clip_width = data | hi_bits; + state->ddenlovr_clip_width = data | hi_bits; break; case 0xc0: case 0xc2: case 0xc4: case 0xc6: - ddenlovr_palette_base[(ddenlovr_blit_reg >> 1) & 3] = data | (hi_bits & 0x100); + state->ddenlovr_palette_base[(state->ddenlovr_blit_latch >> 1) & 3] = data | (hi_bits & 0x100); break; case 0xc8: case 0xca: case 0xcc: case 0xce: - ddenlovr_palette_mask[(ddenlovr_blit_reg >> 1) & 3] = data; + state->ddenlovr_palette_mask[(state->ddenlovr_blit_latch >> 1) & 3] = data; break; case 0xd0: case 0xd2: case 0xd4: case 0xd6: - ddenlovr_transparency_pen[(ddenlovr_blit_reg >> 1) & 3] = data; + state->ddenlovr_transparency_pen[(state->ddenlovr_blit_latch >> 1) & 3] = data; break; case 0xd8: case 0xda: case 0xdc: case 0xde: - ddenlovr_transparency_mask[(ddenlovr_blit_reg >> 1) & 3] = data; + state->ddenlovr_transparency_mask[(state->ddenlovr_blit_latch >> 1) & 3] = data; break; case 0xe4: - ddenlovr_priority_w(space,0,data); + ddenlovr_priority_w(space, 0, data); break; case 0xe6: - ddenlovr_layer_enable_w(space,0,data); + ddenlovr_layer_enable_w(space, 0, data); break; case 0xe8: - ddenlovr_bgcolor = data | hi_bits; + state->ddenlovr_bgcolor = data | hi_bits; break; case 0x90: @@ -1088,33 +1167,33 @@ profiler_mark_start(PROFILER_VIDEO); switch (data) { - case 0x04: blit_fill_xy(0, 0); + case 0x04: blit_fill_xy(space->machine, 0, 0); break; - case 0x14: blit_fill_xy(ddenlovr_blit_x, ddenlovr_blit_y); + case 0x14: blit_fill_xy(space->machine, state->ddenlovr_blit_x, state->ddenlovr_blit_y); break; - case 0x10: ddenlovr_blit_address = blit_draw(space->machine,ddenlovr_blit_address,ddenlovr_blit_x); + case 0x10: state->ddenlovr_blit_address = blit_draw(space->machine, state->ddenlovr_blit_address, state->ddenlovr_blit_x); break; - case 0x13: blit_horiz_line(); + case 0x13: blit_horiz_line(space->machine); break; - case 0x1b: blit_vert_line(); + case 0x1b: blit_vert_line(space->machine); break; - case 0x1c: blit_rect_xywh(); + case 0x1c: blit_rect_xywh(space->machine); break; // These two are issued one after the other (43 then 8c) // 8c is issued immediately after 43 has finished, without // changing any argument case 0x43: break; - case 0x8c: blit_rect_yh(); + case 0x8c: blit_rect_yh(space->machine); break; default: ; #ifdef MAME_DEBUG - popmessage("unknown blitter command %02x",data); + popmessage("unknown blitter command %02x", data); logerror("%06x: unknown blitter command %02x\n", cpu_get_pc(space->cpu), data); #endif } @@ -1124,7 +1203,7 @@ profiler_mark_start(PROFILER_VIDEO); break; default: - logerror("%06x: Blitter 0 reg %02x = %02x\n", cpu_get_pc(space->cpu), ddenlovr_blit_reg, data); + logerror("%06x: Blitter 0 reg %02x = %02x\n", cpu_get_pc(space->cpu), state->ddenlovr_blit_latch, data); break; } @@ -1134,28 +1213,30 @@ profiler_mark_end(); static WRITE8_HANDLER( rongrong_blitter_w ) { - blitter_w(space, 0,offset,data,0xf8); + blitter_w(space, 0, offset, data, 0xf8); } static WRITE16_HANDLER( ddenlovr_blitter_w ) { if (ACCESSING_BITS_0_7) - blitter_w(space, 0,offset,data & 0xff,0); + blitter_w(space, 0, offset, data & 0xff, 0); } static WRITE16_HANDLER( ddenlovr_blitter_irq_ack_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; + if (ACCESSING_BITS_0_7) { if (data & 1) { - ddenlovr_blitter_irq_enable = 1; + state->ddenlovr_blitter_irq_enable = 1; } else { - ddenlovr_blitter_irq_enable = 0; - ddenlovr_blitter_irq_flag = 0; + state->ddenlovr_blitter_irq_enable = 0; + state->ddenlovr_blitter_irq_flag = 0; } } } @@ -1163,9 +1244,10 @@ static WRITE16_HANDLER( ddenlovr_blitter_irq_ack_w ) static READ8_HANDLER( rongrong_gfxrom_r ) { - UINT8 *rom = memory_region( space->machine, "blitter" ); - size_t size = memory_region_length( space->machine, "blitter" ); - int address = ddenlovr_blit_address; + dynax_state *state = (dynax_state *)space->machine->driver_data; + UINT8 *rom = memory_region(space->machine, "blitter"); + size_t size = memory_region_length(space->machine, "blitter"); + int address = state->ddenlovr_blit_address; if (address >= size) { @@ -1173,7 +1255,7 @@ static READ8_HANDLER( rongrong_gfxrom_r ) address %= size; } - ddenlovr_blit_address = (ddenlovr_blit_address + 1) & 0xffffff; + state->ddenlovr_blit_address = (state->ddenlovr_blit_address + 1) & 0xffffff; return rom[address]; } @@ -1185,29 +1267,30 @@ static READ16_HANDLER( ddenlovr_gfxrom_r ) -static void copylayer(bitmap_t *bitmap,const rectangle *cliprect,int layer) +static void copylayer(running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect, int layer ) { + dynax_state *state = (dynax_state *)machine->driver_data; int x,y; - int scrollx = ddenlovr_scroll[layer/4*8 + (layer%4) + 0]; - int scrolly = ddenlovr_scroll[layer/4*8 + (layer%4) + 4]; + int scrollx = state->ddenlovr_scroll[layer / 4 * 8 + (layer % 4) + 0]; + int scrolly = state->ddenlovr_scroll[layer / 4 * 8 + (layer % 4) + 4]; - int palbase = ddenlovr_palette_base[layer]; - int penmask = ddenlovr_palette_mask[layer]; + int palbase = state->ddenlovr_palette_base[layer]; + int penmask = state->ddenlovr_palette_mask[layer]; - int transpen = ddenlovr_transparency_pen[layer]; - int transmask = ddenlovr_transparency_mask[layer]; + int transpen = state->ddenlovr_transparency_pen[layer]; + int transmask = state->ddenlovr_transparency_mask[layer]; - palbase &= ~penmask; - transpen &= transmask; + palbase &= ~penmask; + transpen &= transmask; - if (((ddenlovr_layer_enable2 << 4) | ddenlovr_layer_enable) & (1 << layer)) + if (((state->ddenlovr_layer_enable2 << 4) | state->ddenlovr_layer_enable) & (1 << layer)) { - for (y = cliprect->min_y;y <= cliprect->max_y;y++) + for (y = cliprect->min_y; y <= cliprect->max_y; y++) { - for (x = cliprect->min_x;x <= cliprect->max_x;x++) + for (x = cliprect->min_x; x <= cliprect->max_x; x++) { - int pen = ddenlovr_pixmap[layer][512 * ((y + scrolly) & 0x1ff) + ((x + scrollx) & 0x1ff)]; - if ( (pen & transmask) != transpen ) + int pen = state->ddenlovr_pixmap[layer][512 * ((y + scrolly) & 0x1ff) + ((x + scrollx) & 0x1ff)]; + if ((pen & transmask) != transpen) { pen &= penmask; pen |= palbase; @@ -1220,6 +1303,8 @@ static void copylayer(bitmap_t *bitmap,const rectangle *cliprect,int layer) VIDEO_UPDATE(ddenlovr) { + dynax_state *state = (dynax_state *)screen->machine->driver_data; + static const int order[24][4] = { { 3,2,1,0 }, { 2,3,1,0 }, { 3,1,2,0 }, { 1,3,2,0 }, { 2,1,3,0 }, { 1,2,3,0 }, @@ -1230,24 +1315,24 @@ VIDEO_UPDATE(ddenlovr) int pri; - int enab = ddenlovr_layer_enable; - int enab2 = ddenlovr_layer_enable2; + int enab = state->ddenlovr_layer_enable; + int enab2 = state->ddenlovr_layer_enable2; #if 0 static int base = 0x0; const UINT8 *gfx = memory_region(screen->machine, "blitter"); int next; - memset(ddenlovr_pixmap[0],0,512*512); - memset(ddenlovr_pixmap[1],0,512*512); - memset(ddenlovr_pixmap[2],0,512*512); - memset(ddenlovr_pixmap[3],0,512*512); - ddenlovr_dest_layer = 8; - ddenlovr_blit_pen = 0; - ddenlovr_blit_pen_mode = 0; - ddenlovr_blit_y = 5; - ddenlovr_clip_ctrl = 0x0f; - next = blit_draw(screen->machine,base,0); - popmessage("GFX %06x",base); + memset(state->ddenlovr_pixmap[0], 0, 512 * 512); + memset(state->ddenlovr_pixmap[1], 0, 512 * 512); + memset(state->ddenlovr_pixmap[2], 0, 512 * 512); + memset(state->ddenlovr_pixmap[3], 0, 512 * 512); + state->ddenlovr_dest_layer = 8; + state->ddenlovr_blit_pen = 0; + state->ddenlovr_blit_pen_mode = 0; + state->ddenlovr_blit_y = 5; + state->ddenlovr_clip_ctrl = 0x0f; + next = blit_draw(screen->machine, base, 0); + popmessage("GFX %06x", base); if (input_code_pressed(screen->machine, KEYCODE_S)) base = next; if (input_code_pressed_once(screen->machine, KEYCODE_X)) base = next; if (input_code_pressed(screen->machine, KEYCODE_C)) { base--; while ((gfx[base] & 0xf0) != 0x30) base--; } @@ -1256,12 +1341,12 @@ VIDEO_UPDATE(ddenlovr) if (input_code_pressed_once(screen->machine, KEYCODE_F)) { base++; while ((gfx[base] & 0xf0) != 0x30) base++; } #endif - bitmap_fill(bitmap,cliprect,ddenlovr_bgcolor); + bitmap_fill(bitmap, cliprect, state->ddenlovr_bgcolor); #ifdef MAME_DEBUG if (input_code_pressed(screen->machine, KEYCODE_Z)) { - int mask,mask2; + int mask, mask2; mask = 0; @@ -1282,50 +1367,51 @@ VIDEO_UPDATE(ddenlovr) if (mask || mask2) { - ddenlovr_layer_enable &= mask; - ddenlovr_layer_enable2 &= mask2; + state->ddenlovr_layer_enable &= mask; + state->ddenlovr_layer_enable2 &= mask2; } } #endif - pri = ddenlovr_priority; + pri = state->ddenlovr_priority; - if (pri >= 24) - { - popmessage("priority = %02x",pri); - pri = 0; - } - - copylayer(bitmap,cliprect,order[pri][0]); - copylayer(bitmap,cliprect,order[pri][1]); - copylayer(bitmap,cliprect,order[pri][2]); - copylayer(bitmap,cliprect,order[pri][3]); - - if (extra_layers) + if (pri >= 24) { - pri = ddenlovr_priority2; - - if (pri >= 24) - { - popmessage("priority2 = %02x",pri); - pri = 0; - } - - copylayer(bitmap,cliprect,order[pri][0]+4); - copylayer(bitmap,cliprect,order[pri][1]+4); - copylayer(bitmap,cliprect,order[pri][2]+4); - copylayer(bitmap,cliprect,order[pri][3]+4); + popmessage("priority = %02x", pri); + pri = 0; } - ddenlovr_layer_enable = enab; - ddenlovr_layer_enable2 = enab2; + copylayer(screen->machine, bitmap, cliprect, order[pri][0]); + copylayer(screen->machine, bitmap, cliprect, order[pri][1]); + copylayer(screen->machine, bitmap, cliprect, order[pri][2]); + copylayer(screen->machine, bitmap, cliprect, order[pri][3]); + + if (state->extra_layers) + { + pri = state->ddenlovr_priority2; + + if (pri >= 24) + { + popmessage("priority2 = %02x", pri); + pri = 0; + } + + copylayer(screen->machine, bitmap, cliprect, order[pri][0] + 4); + copylayer(screen->machine, bitmap, cliprect, order[pri][1] + 4); + copylayer(screen->machine, bitmap, cliprect, order[pri][2] + 4); + copylayer(screen->machine, bitmap, cliprect, order[pri][3] + 4); + } + + state->ddenlovr_layer_enable = enab; + state->ddenlovr_layer_enable2 = enab2; return 0; } static CUSTOM_INPUT( ddenlovr_special_r ) { - return ddenlovr_blitter_irq_flag; + dynax_state *state = (dynax_state *)field->port->machine->driver_data; + return state->ddenlovr_blitter_irq_flag; } static WRITE16_HANDLER( ddenlovr_coincounter_0_w ) @@ -1340,92 +1426,113 @@ static WRITE16_HANDLER( ddenlovr_coincounter_1_w ) } -static UINT8 palram[0x200]; - static WRITE8_HANDLER( rongrong_palette_w ) { - int r,g,b,d1,d2,indx; + dynax_state *state = (dynax_state *)space->machine->driver_data; + int r, g, b, d1, d2, indx; - palram[offset] = data; + state->palram[offset] = data; indx = ((offset & 0x1e0) >> 1) | (offset & 0x00f); - d1 = palram[offset & ~0x10]; - d2 = palram[offset | 0x10]; + d1 = state->palram[offset & ~0x10]; + d2 = state->palram[offset | 0x10]; r = d1 & 0x1f; g = d2 & 0x1f; /* what were they smoking??? */ b = ((d1 & 0xe0) >> 5) | (d2 & 0xc0) >> 3; - palette_set_color_rgb(space->machine,indx,pal5bit(r),pal5bit(g),pal5bit(b)); + palette_set_color_rgb(space->machine, indx, pal5bit(r), pal5bit(g), pal5bit(b)); } static WRITE16_HANDLER( ddenlovr_palette_w ) { if (ACCESSING_BITS_0_7) - rongrong_palette_w(space,offset,data & 0xff); + rongrong_palette_w(space, offset, data & 0xff); } WRITE8_HANDLER( ddenlovr_palette_base_w ) { - ddenlovr_palette_base[offset] = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->ddenlovr_palette_base[offset] = data; } + static WRITE8_HANDLER( ddenlovr_palette_base2_w ) { - ddenlovr_palette_base[offset+4] = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->ddenlovr_palette_base[offset + 4] = data; } WRITE8_HANDLER( ddenlovr_palette_mask_w ) { - ddenlovr_palette_mask[offset] = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->ddenlovr_palette_mask[offset] = data; } + static WRITE8_HANDLER( ddenlovr_palette_mask2_w ) { - ddenlovr_palette_mask[offset+4] = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->ddenlovr_palette_mask[offset + 4] = data; } + WRITE8_HANDLER( ddenlovr_transparency_pen_w ) { - ddenlovr_transparency_pen[offset] = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->ddenlovr_transparency_pen[offset] = data; } + static WRITE8_HANDLER( ddenlovr_transparency_pen2_w ) { - ddenlovr_transparency_pen[offset+4] = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->ddenlovr_transparency_pen[offset + 4] = data; } + WRITE8_HANDLER( ddenlovr_transparency_mask_w ) { - ddenlovr_transparency_mask[offset] = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->ddenlovr_transparency_mask[offset] = data; } + static WRITE8_HANDLER( ddenlovr_transparency_mask2_w ) { - ddenlovr_transparency_mask[offset+4] = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->ddenlovr_transparency_mask[offset + 4] = data; } static WRITE16_HANDLER( ddenlovr16_palette_base_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; + if (ACCESSING_BITS_0_7) - ddenlovr_palette_base[offset] = data & 0xff; + state->ddenlovr_palette_base[offset] = data & 0xff; } static WRITE16_HANDLER( ddenlovr16_palette_mask_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; + if (ACCESSING_BITS_0_7) - ddenlovr_palette_mask[offset] = data & 0xff; + state->ddenlovr_palette_mask[offset] = data & 0xff; } static WRITE16_HANDLER( ddenlovr16_transparency_pen_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; + if (ACCESSING_BITS_0_7) - ddenlovr_transparency_pen[offset] = data & 0xff; + state->ddenlovr_transparency_pen[offset] = data & 0xff; } static WRITE16_HANDLER( ddenlovr16_transparency_mask_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; + if (ACCESSING_BITS_0_7) - ddenlovr_transparency_mask[offset] = data & 0xff; + state->ddenlovr_transparency_mask[offset] = data & 0xff; } @@ -1441,23 +1548,26 @@ static WRITE16_DEVICE_HANDLER( ddenlovr_oki_bank_w ) } -static int okibank; static WRITE16_DEVICE_HANDLER( quiz365_oki_bank1_w ) { + dynax_state *state = (dynax_state *)device->machine->driver_data; + if (ACCESSING_BITS_0_7) { - okibank = (okibank & 2) | (data & 1); - okim6295_set_bank_base(device, okibank * 0x40000); + state->okibank = (state->okibank & 2) | (data & 1); + okim6295_set_bank_base(device, state->okibank * 0x40000); } } static WRITE16_DEVICE_HANDLER( quiz365_oki_bank2_w ) { + dynax_state *state = (dynax_state *)device->machine->driver_data; + if (ACCESSING_BITS_0_7) { - okibank = (okibank & 1) | ((data & 1) << 1); - okim6295_set_bank_base(device, okibank * 0x40000); + state->okibank = (state->okibank & 1) | ((data & 1) << 1); + okim6295_set_bank_base(device, state->okibank * 0x40000); } } @@ -1470,39 +1580,45 @@ static READ8_HANDLER( unk_r ) static READ16_HANDLER( unk16_r ) { - return unk_r(space,offset); + return unk_r(space, offset); } -static UINT8 ddenlovr_select, ddenlovr_select2; - static WRITE8_DEVICE_HANDLER( ddenlovr_select_w ) { - ddenlovr_select = data; + dynax_state *state = (dynax_state *)device->machine->driver_data; + state->dsw_sel = data; } static WRITE16_HANDLER( ddenlovr_select_16_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; + if (ACCESSING_BITS_0_7) - ddenlovr_select = data; + state->dsw_sel = data; } static WRITE8_HANDLER( ddenlovr_select2_w ) { - ddenlovr_select2 = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->input_sel = data; } static WRITE16_HANDLER( ddenlovr_select2_16_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; + if (ACCESSING_BITS_0_7) - ddenlovr_select2 = data; + state->input_sel = data; } static READ8_HANDLER( rongrong_input2_r ) { -// logerror("%04x: input2_r offset %d select %x\n",cpu_get_pc(space->cpu),offset,ddenlovr_select2 ); + dynax_state *state = (dynax_state *)space->machine->driver_data; + +// logerror("%04x: input2_r offset %d select %x\n", cpu_get_pc(space->cpu), offset, state->input_sel); /* 0 and 1 are read from offset 1, 2 from offset 0... */ - switch( ddenlovr_select2 ) + switch (state->input_sel) { case 0x00: return input_port_read(space->machine, "P1"); case 0x01: return input_port_read(space->machine, "P2"); @@ -1514,19 +1630,23 @@ static READ8_HANDLER( rongrong_input2_r ) static READ8_DEVICE_HANDLER( quiz365_input_r ) { - if (!(ddenlovr_select & 0x01)) return input_port_read(device->machine, "DSW1"); - if (!(ddenlovr_select & 0x02)) return input_port_read(device->machine, "DSW2"); - if (!(ddenlovr_select & 0x04)) return input_port_read(device->machine, "DSW3"); - if (!(ddenlovr_select & 0x08)) return 0xff;//mame_rand(device->machine); - if (!(ddenlovr_select & 0x10)) return 0xff;//mame_rand(device->machine); + dynax_state *state = (dynax_state *)device->machine->driver_data; + + if (!(state->dsw_sel & 0x01)) return input_port_read(device->machine, "DSW1"); + if (!(state->dsw_sel & 0x02)) return input_port_read(device->machine, "DSW2"); + if (!(state->dsw_sel & 0x04)) return input_port_read(device->machine, "DSW3"); + if (!(state->dsw_sel & 0x08)) return 0xff;//mame_rand(device->machine); + if (!(state->dsw_sel & 0x10)) return 0xff;//mame_rand(device->machine); return 0xff; } static READ16_HANDLER( quiz365_input2_r ) { -// logerror("%04x: input2_r offset %d select %x\n",cpu_get_pc(space->cpu),offset,ddenlovr_select2 ); + dynax_state *state = (dynax_state *)space->machine->driver_data; + +// logerror("%04x: input2_r offset %d select %x\n",cpu_get_pc(space->cpu), offset, state->input_sel); /* 0 and 1 are read from offset 1, 2 from offset 0... */ - switch( ddenlovr_select2 ) + switch (state->input_sel) { case 0x10: return input_port_read(space->machine, "P1"); case 0x11: return input_port_read(space->machine, "P2"); @@ -1535,22 +1655,26 @@ static READ16_HANDLER( quiz365_input2_r ) return 0xff; } -static UINT8 rongrong_blitter_busy_select; static WRITE8_HANDLER( rongrong_blitter_busy_w ) { - rongrong_blitter_busy_select = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->rongrong_blitter_busy_select = data; + if (data != 0x18) - logerror("%04x: rongrong_blitter_busy_w data = %02x\n",cpu_get_pc(space->cpu),data); + logerror("%04x: rongrong_blitter_busy_w data = %02x\n", cpu_get_pc(space->cpu), data); } + static READ8_HANDLER( rongrong_blitter_busy_r ) { - switch( rongrong_blitter_busy_select ) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->rongrong_blitter_busy_select) { case 0x18: return 0; // bit 5 = blitter busy default: - logerror("%04x: rongrong_blitter_busy_r with select = %02x\n",cpu_get_pc(space->cpu),rongrong_blitter_busy_select); + logerror("%04x: rongrong_blitter_busy_r with select = %02x\n", cpu_get_pc(space->cpu), state->rongrong_blitter_busy_select); } return 0xff; } @@ -1558,9 +1682,11 @@ static READ8_HANDLER( rongrong_blitter_busy_r ) static WRITE16_HANDLER( quiz365_coincounter_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; + if (ACCESSING_BITS_0_7) { - if (ddenlovr_select2 == 0x1c) + if (state->input_sel == 0x1c) { coin_counter_w(space->machine, 0, ~data & 1); coin_counter_w(space->machine, 1, ~data & 4); @@ -1572,10 +1698,11 @@ static WRITE16_HANDLER( quiz365_coincounter_w ) 37,28,12 11 -> 88 67,4c,3a ?? -> 51 */ -static UINT16 quiz365_protection[2]; static READ16_HANDLER( quiz365_protection_r ) { - switch(quiz365_protection[0]) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->quiz365_protection[0]) { case 0x3a: return 0x0051; @@ -1583,9 +1710,11 @@ static READ16_HANDLER( quiz365_protection_r ) return 0x0088; } } + static WRITE16_HANDLER( quiz365_protection_w ) { - COMBINE_DATA(quiz365_protection + offset); + dynax_state *state = (dynax_state *)space->machine->driver_data; + COMBINE_DATA(state->quiz365_protection + offset); } static ADDRESS_MAP_START( quiz365_map, ADDRESS_SPACE_PROGRAM, 16 ) @@ -1625,14 +1754,13 @@ static ADDRESS_MAP_START( quiz365_map, ADDRESS_SPACE_PROGRAM, 16 ) ADDRESS_MAP_END -static UINT16 *ddenlovj_dsw_sel; - static READ16_HANDLER( ddenlovj_dsw_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; UINT16 dsw = 0; - if ((~*ddenlovj_dsw_sel) & 0x01) dsw |= input_port_read(space->machine, "DSW1"); - if ((~*ddenlovj_dsw_sel) & 0x02) dsw |= input_port_read(space->machine, "DSW2"); - if ((~*ddenlovj_dsw_sel) & 0x04) dsw |= input_port_read(space->machine, "DSW3"); + if ((~*state->dsw_sel16) & 0x01) dsw |= input_port_read(space->machine, "DSW1"); + if ((~*state->dsw_sel16) & 0x02) dsw |= input_port_read(space->machine, "DSW2"); + if ((~*state->dsw_sel16) & 0x04) dsw |= input_port_read(space->machine, "DSW3"); return dsw; } @@ -1648,7 +1776,8 @@ static WRITE16_HANDLER( ddenlovj_coincounter_w ) static CUSTOM_INPUT( ddenlovj_blitter_r ) { - return ddenlovr_blitter_irq_flag ? 0x03 : 0x00; // bit 4 = 1 -> blitter busy + dynax_state *state = (dynax_state *)field->port->machine->driver_data; + return state->ddenlovr_blitter_irq_flag ? 0x03 : 0x00; // bit 4 = 1 -> blitter busy } static ADDRESS_MAP_START( ddenlovj_map, ADDRESS_SPACE_PROGRAM, 16 ) @@ -1675,7 +1804,7 @@ static ADDRESS_MAP_START( ddenlovj_map, ADDRESS_SPACE_PROGRAM, 16 ) AM_RANGE(0x300184, 0x300185) AM_READ_PORT("SYSTEM") AM_RANGE(0x300186, 0x300187) AM_READ(ddenlovj_dsw_r) // DSW AM_RANGE(0x300188, 0x300189) AM_WRITE(ddenlovj_coincounter_w) // Coin Counters - AM_RANGE(0x30018a, 0x30018b) AM_WRITEONLY AM_BASE(&ddenlovj_dsw_sel) // DSW select + AM_RANGE(0x30018a, 0x30018b) AM_WRITEONLY AM_BASE_MEMBER(dynax_state, dsw_sel16) // DSW select AM_RANGE(0x30018c, 0x30018d) AM_DEVWRITE("oki", ddenlovr_oki_bank_w) AM_RANGE(0x3001ca, 0x3001cb) AM_WRITE(ddenlovr_blitter_irq_ack_w) // Blitter irq acknowledge AM_RANGE(0x300240, 0x300241) AM_DEVREADWRITE8("oki", okim6295_r, okim6295_w, 0x00ff)// Sound @@ -1683,35 +1812,38 @@ static ADDRESS_MAP_START( ddenlovj_map, ADDRESS_SPACE_PROGRAM, 16 ) ADDRESS_MAP_END -static UINT16 *ddenlovrk_protection1, *ddenlovrk_protection2; static READ16_HANDLER( ddenlovrk_protection1_r ) { - switch(*ddenlovrk_protection1) + dynax_state *state = (dynax_state *)space->machine->driver_data; + switch (*state->protection1) { case 0x007e: return 0x00aa; } - return *ddenlovrk_protection1; + return *state->protection1; } static READ16_HANDLER( ddenlovrk_protection2_r ) { - switch(*ddenlovrk_protection1) + dynax_state *state = (dynax_state *)space->machine->driver_data; + switch (*state->protection1) { - case 0x0000: return *ddenlovrk_protection2; + case 0x0000: return *state->protection2; } return 0x80; } static WRITE16_HANDLER( ddenlovrk_protection2_w ) { - COMBINE_DATA( ddenlovrk_protection2 ); - okim6295_set_bank_base(devtag_get_device(space->machine, "oki"), ((*ddenlovrk_protection2)&0x7) * 0x40000); + dynax_state *state = (dynax_state *)space->machine->driver_data; + + COMBINE_DATA(state->protection2); + okim6295_set_bank_base(state->oki, ((*state->protection2) & 0x7) * 0x40000); } static ADDRESS_MAP_START( ddenlovrk_map, ADDRESS_SPACE_PROGRAM, 16 ) AM_RANGE(0x000000, 0x07ffff) AM_ROM // ROM - AM_RANGE(0x100000, 0x100001) AM_RAM_READ(ddenlovrk_protection1_r) AM_BASE(&ddenlovrk_protection1) - AM_RANGE(0x200000, 0x200001) AM_READWRITE(ddenlovrk_protection2_r, ddenlovrk_protection2_w) AM_BASE(&ddenlovrk_protection2) + AM_RANGE(0x100000, 0x100001) AM_RAM_READ(ddenlovrk_protection1_r) AM_BASE_MEMBER(dynax_state, protection1) + AM_RANGE(0x200000, 0x200001) AM_READWRITE(ddenlovrk_protection2_r, ddenlovrk_protection2_w) AM_BASE_MEMBER(dynax_state, protection2) AM_RANGE(0xd00000, 0xd003ff) AM_WRITE(ddenlovr_palette_w) // Palette // AM_RANGE(0xd01000, 0xd017ff) AM_RAM // ? B0 on startup, then 00 @@ -1784,14 +1916,17 @@ ADDRESS_MAP_END static CUSTOM_INPUT( nettoqc_special_r ) { - return ddenlovr_blitter_irq_flag ? 0x03 : 0x00; + dynax_state *state = (dynax_state *)field->port->machine->driver_data; + return state->ddenlovr_blitter_irq_flag ? 0x03 : 0x00; } static READ16_HANDLER( nettoqc_input_r ) { - if (!(ddenlovr_select & 0x01)) return input_port_read(space->machine, "DSW1"); - if (!(ddenlovr_select & 0x02)) return input_port_read(space->machine, "DSW2"); - if (!(ddenlovr_select & 0x04)) return input_port_read(space->machine, "DSW3"); + dynax_state *state = (dynax_state *)space->machine->driver_data; + + if (!(state->dsw_sel & 0x01)) return input_port_read(space->machine, "DSW1"); + if (!(state->dsw_sel & 0x02)) return input_port_read(space->machine, "DSW2"); + if (!(state->dsw_sel & 0x04)) return input_port_read(space->machine, "DSW3"); return 0xffff; } @@ -1802,11 +1937,11 @@ static READ16_HANDLER( nettoqc_input_r ) Writes 67 4c 3a to 200e0b then 19 to 200e0d. Expects to read 51 from 200c03 */ -static UINT16 *nettoqc_protection_val; - static READ16_HANDLER( nettoqc_protection_r ) { - switch( nettoqc_protection_val[0] & 0xff ) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->protection1[0] & 0xff) { case 0x3a: return 0x0051; default: return 0x0088; @@ -1834,7 +1969,7 @@ static ADDRESS_MAP_START( nettoqc_map, ADDRESS_SPACE_PROGRAM, 16 ) AM_RANGE(0x200000, 0x2003ff) AM_WRITE(ddenlovr_palette_w) // Palette AM_RANGE(0x200c02, 0x200c03) AM_READ(nettoqc_protection_r) // - AM_RANGE(0x200e0a, 0x200e0d) AM_WRITEONLY AM_BASE(&nettoqc_protection_val) // + AM_RANGE(0x200e0a, 0x200e0d) AM_WRITEONLY AM_BASE_MEMBER(dynax_state, protection1) // AM_RANGE(0x201000, 0x2017ff) AM_WRITEONLY // ? AM_RANGE(0x300040, 0x300047) AM_WRITE(ddenlovr16_palette_base_w) @@ -1869,22 +2004,25 @@ ADDRESS_MAP_END static READ8_HANDLER( rongrong_input_r ) { - if (!(ddenlovr_select & 0x01)) return input_port_read(space->machine, "DSW1"); - if (!(ddenlovr_select & 0x02)) return input_port_read(space->machine, "DSW2"); - if (!(ddenlovr_select & 0x04)) return 0xff;//mame_rand(space->machine); - if (!(ddenlovr_select & 0x08)) return 0xff;//mame_rand(space->machine); - if (!(ddenlovr_select & 0x10)) return input_port_read(space->machine, "DSW3"); + dynax_state *state = (dynax_state *)space->machine->driver_data; + + if (!(state->dsw_sel & 0x01)) return input_port_read(space->machine, "DSW1"); + if (!(state->dsw_sel & 0x02)) return input_port_read(space->machine, "DSW2"); + if (!(state->dsw_sel & 0x04)) return 0xff;//mame_rand(space->machine); + if (!(state->dsw_sel & 0x08)) return 0xff;//mame_rand(space->machine); + if (!(state->dsw_sel & 0x10)) return input_port_read(space->machine, "DSW3"); return 0xff; } static WRITE8_HANDLER( rongrong_select_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; UINT8 *rom = memory_region(space->machine, "maincpu"); //logerror("%04x: rongrong_select_w %02x\n",cpu_get_pc(space->cpu),data); /* bits 0-4 = **both** ROM bank **AND** input select */ memory_set_bankptr(space->machine, "bank1", &rom[0x10000 + 0x8000 * (data & 0x1f)]); - ddenlovr_select = data; + state->dsw_sel = data; /* bits 5-7 = RAM bank */ memory_set_bankptr(space->machine, "bank2", &rom[0x110000 + 0x1000 * ((data & 0xe0) >> 5)]); @@ -1898,7 +2036,8 @@ static ADDRESS_MAP_START( quizchq_map, ADDRESS_SPACE_PROGRAM, 8 ) AM_RANGE(0x8000, 0xffff) AM_ROMBANK("bank1") AM_WRITE(rongrong_palette_w) // ROM (Banked) ADDRESS_MAP_END -static ADDRESS_MAP_START( quizchq_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) +static ADDRESS_MAP_START( quizchq_portmap, ADDRESS_SPACE_IO, 8 ) + ADDRESS_MAP_GLOBAL_MASK(0xff) AM_RANGE(0x00, 0x01) AM_WRITE(rongrong_blitter_w) AM_RANGE(0x03, 0x03) AM_READ(rongrong_gfxrom_r) AM_RANGE(0x1b, 0x1b) AM_READWRITE(rongrong_blitter_busy_r, rongrong_blitter_busy_w) @@ -1934,7 +2073,8 @@ static ADDRESS_MAP_START( rongrong_map, ADDRESS_SPACE_PROGRAM, 8 ) AM_RANGE(0x8000, 0xffff) AM_ROMBANK("bank1") AM_WRITE(rongrong_palette_w) // ROM (Banked) ADDRESS_MAP_END -static ADDRESS_MAP_START( rongrong_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) +static ADDRESS_MAP_START( rongrong_portmap, ADDRESS_SPACE_IO, 8 ) + ADDRESS_MAP_GLOBAL_MASK(0xff) AM_RANGE(0x00, 0x01) AM_WRITE(rongrong_blitter_w) AM_RANGE(0x03, 0x03) AM_READ(rongrong_gfxrom_r) AM_RANGE(0x1b, 0x1b) AM_READWRITE(rongrong_blitter_busy_r, rongrong_blitter_busy_w) @@ -1986,48 +2126,52 @@ static WRITE8_HANDLER( mmpanic_rombank_w ) static WRITE8_HANDLER( mmpanic_soundlatch_w ) { - soundlatch_w(space,0,data); - cputag_set_input_line(space->machine, "soundcpu", INPUT_LINE_NMI, PULSE_LINE); + dynax_state *state = (dynax_state *)space->machine->driver_data; + + soundlatch_w(space, 0, data); + cpu_set_input_line(state->soundcpu, INPUT_LINE_NMI, PULSE_LINE); } static WRITE8_HANDLER( mmpanic_blitter_w ) { - blitter_w(space, 0,offset,data,0xdf); // RST 18 + blitter_w(space, 0, offset, data, 0xdf); // RST 18 } static WRITE8_HANDLER( mmpanic_blitter2_w ) { - blitter_w(space, 1,offset,data,0xdf); // RST 18 + blitter_w(space, 1, offset, data, 0xdf); // RST 18 } -/* A led for each of the 9 buttons */ -static UINT16 mmpanic_leds; - static void mmpanic_update_leds(running_machine *machine) { - set_led_status(machine, 0,mmpanic_leds); + dynax_state *state = (dynax_state *)machine->driver_data; + set_led_status(machine, 0, state->mmpanic_leds); } /* leds 1-8 */ static WRITE8_HANDLER( mmpanic_leds_w ) { - mmpanic_leds = (mmpanic_leds & 0xff00) | data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->mmpanic_leds = (state->mmpanic_leds & 0xff00) | data; mmpanic_update_leds(space->machine); } /* led 9 */ static WRITE8_HANDLER( mmpanic_leds2_w ) { - mmpanic_leds = (mmpanic_leds & 0xfeff) | (data ? 0x0100 : 0); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->mmpanic_leds = (state->mmpanic_leds & 0xfeff) | (data ? 0x0100 : 0); mmpanic_update_leds(space->machine); } static WRITE8_HANDLER( mmpanic_lockout_w ) { - if (ddenlovr_select == 0x0c) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + if (state->dsw_sel == 0x0c) { - coin_counter_w(space->machine, 0,(~data) & 0x01); - coin_lockout_w(space->machine, 0,(~data) & 0x02); - set_led_status(space->machine, 1,(~data) & 0x04); + coin_counter_w(space->machine, 0, (~data) & 0x01); + coin_lockout_w(space->machine, 0, (~data) & 0x02); + set_led_status(space->machine, 1, (~data) & 0x04); } } @@ -2095,7 +2239,8 @@ static ADDRESS_MAP_START( mmpanic_sound_map, ADDRESS_SPACE_PROGRAM, 8 ) AM_RANGE(0x8000, 0xffff) AM_ROM // ROM ADDRESS_MAP_END -static ADDRESS_MAP_START( mmpanic_sound_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) +static ADDRESS_MAP_START( mmpanic_sound_portmap, ADDRESS_SPACE_IO, 8 ) + ADDRESS_MAP_GLOBAL_MASK(0xff) AM_RANGE(0x00, 0x00) AM_READ(soundlatch_r) AM_RANGE(0x02, 0x02) AM_READNOP // read just before port 00 AM_RANGE(0x04, 0x04) AM_NOP // read only once at the start @@ -2132,14 +2277,15 @@ static READ8_HANDLER( funkyfig_busy_r ) static WRITE8_HANDLER( funkyfig_blitter_w ) { - blitter_w_funkyfig(space->machine, 0,offset,data,0xe0); + blitter_w_funkyfig(space->machine, 0, offset, data, 0xe0); } static WRITE8_HANDLER( funkyfig_rombank_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; UINT8 *rom = memory_region(space->machine, "maincpu"); - ddenlovr_select = data; + state->dsw_sel = data; memory_set_bankptr(space->machine, "bank1", &rom[0x10000 + 0x8000 * (data & 0x0f)]); // bit 4 selects palette ram at 8000? @@ -2148,45 +2294,51 @@ static WRITE8_HANDLER( funkyfig_rombank_w ) static READ8_HANDLER( funkyfig_dsw_r ) { - if (!(ddenlovr_select & 0x01)) return input_port_read(space->machine, "DSW1"); - if (!(ddenlovr_select & 0x02)) return input_port_read(space->machine, "DSW2"); - if (!(ddenlovr_select & 0x04)) return input_port_read(space->machine, "DSW3"); - logerror("%06x: warning, unknown bits read, ddenlovr_select = %02x\n", cpu_get_pc(space->cpu), ddenlovr_select); + dynax_state *state = (dynax_state *)space->machine->driver_data; + + if (!(state->dsw_sel & 0x01)) return input_port_read(space->machine, "DSW1"); + if (!(state->dsw_sel & 0x02)) return input_port_read(space->machine, "DSW2"); + if (!(state->dsw_sel & 0x04)) return input_port_read(space->machine, "DSW3"); + logerror("%06x: warning, unknown bits read, ddenlovr_select = %02x\n", cpu_get_pc(space->cpu), state->dsw_sel); return 0xff; } -static UINT8 funkyfig_lockout; - static READ8_HANDLER( funkyfig_coin_r ) { - switch( ddenlovr_select2 ) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->input_sel) { case 0x22: return input_port_read(space->machine, "IN2"); - case 0x23: return funkyfig_lockout; + case 0x23: return state->funkyfig_lockout; } - logerror("%06x: warning, unknown bits read, ddenlovr_select2 = %02x\n", cpu_get_pc(space->cpu), ddenlovr_select2); + logerror("%06x: warning, unknown bits read, ddenlovr_select2 = %02x\n", cpu_get_pc(space->cpu), state->input_sel); return 0xff; } static READ8_HANDLER( funkyfig_key_r ) { - switch( ddenlovr_select2 ) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->input_sel) { case 0x20: return input_port_read(space->machine, "IN0"); case 0x21: return input_port_read(space->machine, "IN1"); } - logerror("%06x: warning, unknown bits read, ddenlovr_select2 = %02x\n", cpu_get_pc(space->cpu), ddenlovr_select2); + logerror("%06x: warning, unknown bits read, ddenlovr_select2 = %02x\n", cpu_get_pc(space->cpu), state->input_sel); return 0xff; } static WRITE8_HANDLER( funkyfig_lockout_w ) { - switch( ddenlovr_select2 ) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->input_sel) { case 0x2c: - funkyfig_lockout = data; - coin_counter_w(space->machine, 0, data & 0x01); - coin_lockout_w(space->machine, 0,(~data) & 0x02); + state->funkyfig_lockout = data; + coin_counter_w(space->machine, 0, data & 0x01); + coin_lockout_w(space->machine, 0, (~data) & 0x02); if (data & ~0x03) logerror("%06x: warning, unknown bits written, lockout = %02x\n", cpu_get_pc(space->cpu), data); break; @@ -2194,11 +2346,12 @@ static WRITE8_HANDLER( funkyfig_lockout_w ) // case 0xef: 16 bytes on startup default: - logerror("%06x: warning, unknown bits written, ddenlovr_select2 = %02x, data = %02x\n", cpu_get_pc(space->cpu), ddenlovr_select2, data); + logerror("%06x: warning, unknown bits written, ddenlovr_select2 = %02x, data = %02x\n", cpu_get_pc(space->cpu), state->input_sel, data); } } -static ADDRESS_MAP_START( funkyfig_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) +static ADDRESS_MAP_START( funkyfig_portmap, ADDRESS_SPACE_IO, 8 ) + ADDRESS_MAP_GLOBAL_MASK(0xff) AM_RANGE(0x00, 0x00) AM_DEVREADWRITE("oki", okim6295_r, okim6295_w) // Sound AM_RANGE(0x01, 0x01) AM_WRITE(mmpanic_leds_w) // Leds AM_RANGE(0x02, 0x02) AM_WRITE(mmpanic_soundlatch_w) // @@ -2230,7 +2383,8 @@ ADDRESS_MAP_END /* Sound CPU */ -static ADDRESS_MAP_START( funkyfig_sound_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) +static ADDRESS_MAP_START( funkyfig_sound_portmap, ADDRESS_SPACE_IO, 8 ) + ADDRESS_MAP_GLOBAL_MASK(0xff) AM_RANGE(0x02, 0x02) AM_READ(soundlatch_r) AM_RANGE(0x04, 0x04) AM_READNOP // read only once at the start ADDRESS_MAP_END @@ -2260,25 +2414,29 @@ static ADDRESS_MAP_START( hanakanz_map, ADDRESS_SPACE_PROGRAM, 8 ) ADDRESS_MAP_END -static UINT8 keyb,dsw; static WRITE8_HANDLER( hanakanz_keyb_w ) { - keyb = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->keyb = data; } + static WRITE8_HANDLER( hanakanz_dsw_w ) { - dsw = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->dsw_sel = data; } static READ8_HANDLER( hanakanz_keyb_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; + UINT8 val = 0xff; - if (!(keyb & 0x01)) val = input_port_read(space->machine, offset ? "KEY5" : "KEY0"); - else if (!(keyb & 0x02)) val = input_port_read(space->machine, offset ? "KEY6" : "KEY1"); - else if (!(keyb & 0x04)) val = input_port_read(space->machine, offset ? "KEY7" : "KEY2"); - else if (!(keyb & 0x08)) val = input_port_read(space->machine, offset ? "KEY8" : "KEY3"); - else if (!(keyb & 0x10)) val = input_port_read(space->machine, offset ? "KEY9" : "KEY4"); + if (!(state->keyb & 0x01)) val = input_port_read(space->machine, offset ? "KEY5" : "KEY0"); + else if (!(state->keyb & 0x02)) val = input_port_read(space->machine, offset ? "KEY6" : "KEY1"); + else if (!(state->keyb & 0x04)) val = input_port_read(space->machine, offset ? "KEY7" : "KEY2"); + else if (!(state->keyb & 0x08)) val = input_port_read(space->machine, offset ? "KEY8" : "KEY3"); + else if (!(state->keyb & 0x10)) val = input_port_read(space->machine, offset ? "KEY9" : "KEY4"); val |= input_port_read(space->machine, offset ? "HOPPER" : "BET"); return val; @@ -2286,11 +2444,13 @@ static READ8_HANDLER( hanakanz_keyb_r ) static READ8_HANDLER( hanakanz_dsw_r ) { - if (!(dsw & 0x01)) return input_port_read(space->machine, "DSW1"); - if (!(dsw & 0x02)) return input_port_read(space->machine, "DSW2"); - if (!(dsw & 0x04)) return input_port_read(space->machine, "DSW3"); - if (!(dsw & 0x08)) return input_port_read(space->machine, "DSW4"); - if (!(dsw & 0x10)) return input_port_read(space->machine, "DSW5"); + dynax_state *state = (dynax_state *)space->machine->driver_data; + + if (!(state->dsw_sel & 0x01)) return input_port_read(space->machine, "DSW1"); + if (!(state->dsw_sel & 0x02)) return input_port_read(space->machine, "DSW2"); + if (!(state->dsw_sel & 0x04)) return input_port_read(space->machine, "DSW3"); + if (!(state->dsw_sel & 0x08)) return input_port_read(space->machine, "DSW4"); + if (!(state->dsw_sel & 0x10)) return input_port_read(space->machine, "DSW5"); return 0xff; } @@ -2301,11 +2461,10 @@ static READ8_HANDLER( hanakanz_busy_r ) static READ8_HANDLER( hanakanz_gfxrom_r ) { - UINT8 *rom = memory_region( space->machine, "blitter" ); - size_t size = memory_region_length( space->machine, "blitter" ); - int address = (ddenlovr_blit_address & 0xffffff) * 2; - - static UINT8 romdata[2]; + dynax_state *state = (dynax_state *)space->machine->driver_data; + UINT8 *rom = memory_region(space->machine, "blitter"); + size_t size = memory_region_length(space->machine, "blitter"); + int address = (state->ddenlovr_blit_address & 0xffffff) * 2; if (address >= size) { @@ -2315,16 +2474,16 @@ static READ8_HANDLER( hanakanz_gfxrom_r ) if (offset == 0) { - romdata[0] = rom[address + 0]; - romdata[1] = rom[address + 1]; + state->romdata[0] = rom[address + 0]; + state->romdata[1] = rom[address + 1]; - ddenlovr_blit_address = (ddenlovr_blit_address + 1) & 0xffffff; + state->ddenlovr_blit_address = (state->ddenlovr_blit_address + 1) & 0xffffff; - return romdata[0]; + return state->romdata[0]; } else { - return romdata[1]; + return state->romdata[1]; } } @@ -2342,27 +2501,27 @@ static WRITE8_HANDLER( hanakanz_coincounter_w ) logerror("%04x: warning, coin counter = %02x\n", cpu_get_pc(space->cpu), data); #ifdef MAME_DEBUG -// popmessage("93 = %02x",data); +// popmessage("93 = %02x", data); #endif } static WRITE8_HANDLER( hanakanz_palette_w ) { - static int palette_index; + dynax_state *state = (dynax_state *)space->machine->driver_data; - if (ddenlovr_blit_reg & 0x80) + if (state->ddenlovr_blit_latch & 0x80) { - palette_index = data | ((ddenlovr_blit_reg & 1) << 8); + state->palette_index = data | ((state->ddenlovr_blit_latch & 1) << 8); } else { // 0bbggggg bbbrrrrr // 04343210 21043210 - int g = ddenlovr_blit_reg & 0x1f; + int g = state->ddenlovr_blit_latch & 0x1f; int r = data & 0x1f; - int b = ((data & 0xe0) >> 5) | ((ddenlovr_blit_reg & 0x60) >> 2); - palette_set_color_rgb(space->machine,(palette_index++)&0x1ff,pal5bit(r),pal5bit(g),pal5bit(b)); + int b = ((data & 0xe0) >> 5) | ((state->ddenlovr_blit_latch & 0x60) >> 2); + palette_set_color_rgb(space->machine, (state->palette_index++) & 0x1ff, pal5bit(r), pal5bit(g), pal5bit(b)); } } @@ -2376,7 +2535,8 @@ static READ8_HANDLER( hanakanz_rand_r ) return mame_rand(space->machine); } -static ADDRESS_MAP_START( hanakanz_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) +static ADDRESS_MAP_START( hanakanz_portmap, ADDRESS_SPACE_IO, 8 ) + ADDRESS_MAP_GLOBAL_MASK(0xff) AM_RANGE(0x2c, 0x2c) AM_READ(hanakanz_busy_r) AM_DEVWRITE("oki", hanakanz_oki_bank_w) AM_RANGE(0x2e, 0x2e) AM_WRITE(hanakanz_blitter_reg_w) AM_RANGE(0x30, 0x30) AM_WRITE(hanakanz_rombank_w) @@ -2396,7 +2556,8 @@ static ADDRESS_MAP_START( hanakanz_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GL ADDRESS_MAP_END -static ADDRESS_MAP_START( hkagerou_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) +static ADDRESS_MAP_START( hkagerou_portmap, ADDRESS_SPACE_IO, 8 ) + ADDRESS_MAP_GLOBAL_MASK(0xff) AM_RANGE(0x2c, 0x2c) AM_READ(hanakanz_busy_r) AM_DEVWRITE("oki", hanakanz_oki_bank_w) AM_RANGE(0x2e, 0x2e) AM_WRITE(hanakanz_blitter_reg_w) AM_RANGE(0x30, 0x30) AM_WRITE(hanakanz_rombank_w) @@ -2416,19 +2577,20 @@ static ADDRESS_MAP_START( hkagerou_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GL ADDRESS_MAP_END -static UINT8 mjreach1_protection_val; - static WRITE8_HANDLER( mjreach1_protection_w ) { - mjreach1_protection_val = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->prot_val = data; } static READ8_HANDLER( mjreach1_protection_r ) { - return mjreach1_protection_val; + dynax_state *state = (dynax_state *)space->machine->driver_data; + return state->prot_val; } -static ADDRESS_MAP_START( mjreach1_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) +static ADDRESS_MAP_START( mjreach1_portmap, ADDRESS_SPACE_IO, 8 ) + ADDRESS_MAP_GLOBAL_MASK(0xff) AM_RANGE(0x2c, 0x2c) AM_READ(hanakanz_busy_r) AM_DEVWRITE("oki", hanakanz_oki_bank_w) AM_RANGE(0x2e, 0x2e) AM_WRITE(hanakanz_blitter_reg_w) AM_RANGE(0x30, 0x30) AM_WRITE(hanakanz_rombank_w) @@ -2455,32 +2617,35 @@ ADDRESS_MAP_END static READ8_HANDLER( mjchuuka_keyb_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; UINT8 val = 0xff; - if (!(keyb & 0x01)) val = input_port_read(space->machine, offset ? "KEY5" : "KEY0"); - else if (!(keyb & 0x02)) val = input_port_read(space->machine, offset ? "KEY6" : "KEY1"); - else if (!(keyb & 0x04)) val = input_port_read(space->machine, offset ? "KEY7" : "KEY2"); - else if (!(keyb & 0x08)) val = input_port_read(space->machine, offset ? "KEY8" : "KEY3"); - else if (!(keyb & 0x10)) val = input_port_read(space->machine, offset ? "KEY9" : "KEY4"); + if (!(state->keyb & 0x01)) val = input_port_read(space->machine, offset ? "KEY5" : "KEY0"); + else if (!(state->keyb & 0x02)) val = input_port_read(space->machine, offset ? "KEY6" : "KEY1"); + else if (!(state->keyb & 0x04)) val = input_port_read(space->machine, offset ? "KEY7" : "KEY2"); + else if (!(state->keyb & 0x08)) val = input_port_read(space->machine, offset ? "KEY8" : "KEY3"); + else if (!(state->keyb & 0x10)) val = input_port_read(space->machine, offset ? "KEY9" : "KEY4"); val |= input_port_read(space->machine, offset ? "HOPPER" : "BET"); - if (offset) val |= 0x80; // blitter busy + + if (offset) + val |= 0x80; // blitter busy + return val; } static WRITE8_HANDLER( mjchuuka_blitter_w ) { - hanakanz_blitter_reg_w(space,0,offset >> 8); - hanakanz_blitter_data_w(space,0,data); + hanakanz_blitter_reg_w(space, 0, offset >> 8); + hanakanz_blitter_data_w(space, 0, data); } -static UINT8 mjchuuka_romdata[2]; - static void mjchuuka_get_romdata(running_machine *machine) { - UINT8 *rom = memory_region( machine, "blitter" ); - size_t size = memory_region_length( machine, "blitter" ); - int address = (ddenlovr_blit_address & 0xffffff) * 2; + dynax_state *state = (dynax_state *)machine->driver_data; + UINT8 *rom = memory_region(machine, "blitter"); + size_t size = memory_region_length(machine, "blitter"); + int address = (state->ddenlovr_blit_address & 0xffffff) * 2; if (address >= size) { @@ -2488,29 +2653,32 @@ static void mjchuuka_get_romdata(running_machine *machine) address %= size; } - mjchuuka_romdata[0] = rom[address + 0]; - mjchuuka_romdata[1] = rom[address + 1]; + state->romdata[0] = rom[address + 0]; + state->romdata[1] = rom[address + 1]; } static READ8_HANDLER( mjchuuka_gfxrom_0_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; mjchuuka_get_romdata(space->machine); - ddenlovr_blit_address++; - return mjchuuka_romdata[0]; + state->ddenlovr_blit_address++; + return state->romdata[0]; } + static READ8_HANDLER( mjchuuka_gfxrom_1_r ) { - return mjchuuka_romdata[1]; + dynax_state *state = (dynax_state *)space->machine->driver_data; + return state->romdata[1]; } static WRITE8_HANDLER( mjchuuka_palette_w ) { - static int palette_index; + dynax_state *state = (dynax_state *)space->machine->driver_data; UINT16 rgb = (offset & 0xff00) | data; if (rgb & 0x8000) { - palette_index = rgb & 0x1ff; + state->palette_index = rgb & 0x1ff; } else { @@ -2520,7 +2688,7 @@ static WRITE8_HANDLER( mjchuuka_palette_w ) int r = (rgb >> 0) & 0x1f; int g = (rgb >> 8) & 0x1f; int b = ((rgb >> 5) & 0x07) | ((rgb & 0x6000) >> 10); - palette_set_color_rgb(space->machine,(palette_index++)&0x1ff,pal5bit(r),pal5bit(g),pal5bit(b)); + palette_set_color_rgb(space->machine, (state->palette_index++) & 0x1ff, pal5bit(r), pal5bit(g), pal5bit(b)); } } @@ -2531,8 +2699,8 @@ static WRITE8_HANDLER( mjchuuka_coincounter_w ) // bit 3 = lockout // bit 8? - coin_counter_w(space->machine, 0, data & 0x01); - coin_lockout_w(space->machine, 0,(~data) & 0x08); + coin_counter_w(space->machine, 0, data & 0x01); + coin_lockout_w(space->machine, 0, (~data) & 0x08); if (data & 0x74) logerror("%04x: warning, coin counter = %02x\n", cpu_get_pc(space->cpu), data); @@ -2598,14 +2766,18 @@ static WRITE8_HANDLER( mjmyster_rambank_w ) static WRITE8_HANDLER( mjmyster_select2_w ) { - ddenlovr_select2 = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->input_sel = data; - if (data & 0x80) keyb = 1; + if (data & 0x80) + state->keyb = 1; } static READ8_HANDLER( mjmyster_coins_r ) { - switch( ddenlovr_select2 ) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->input_sel) { case 0x00: return input_port_read(space->machine, "SYSTEM"); case 0x01: return 0xff; @@ -2613,41 +2785,46 @@ static READ8_HANDLER( mjmyster_coins_r ) case 0x03: return 0xff; } - logerror("%06x: warning, unknown bits read, ddenlovr_select2 = %02x\n", cpu_get_pc(space->cpu), ddenlovr_select2); + logerror("%06x: warning, unknown bits read, ddenlovr_select2 = %02x\n", cpu_get_pc(space->cpu), state->input_sel); return 0xff; } static READ8_HANDLER( mjmyster_keyb_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; UINT8 ret = 0xff; - if (keyb & 0x01) ret = input_port_read(space->machine, "KEY0"); - else if (keyb & 0x02) ret = input_port_read(space->machine, "KEY1"); - else if (keyb & 0x04) ret = input_port_read(space->machine, "KEY2"); - else if (keyb & 0x08) ret = input_port_read(space->machine, "KEY3"); - else if (keyb & 0x10) ret = input_port_read(space->machine, "KEY4"); - else logerror("%06x: warning, unknown bits read, keyb = %02x\n", cpu_get_pc(space->cpu), keyb); + if (state->keyb & 0x01) ret = input_port_read(space->machine, "KEY0"); + else if (state->keyb & 0x02) ret = input_port_read(space->machine, "KEY1"); + else if (state->keyb & 0x04) ret = input_port_read(space->machine, "KEY2"); + else if (state->keyb & 0x08) ret = input_port_read(space->machine, "KEY3"); + else if (state->keyb & 0x10) ret = input_port_read(space->machine, "KEY4"); + else logerror("%06x: warning, unknown bits read, keyb = %02x\n", cpu_get_pc(space->cpu), state->keyb); - keyb <<= 1; + state->keyb <<= 1; return ret; } static READ8_HANDLER( mjmyster_dsw_r ) { - if (!(ddenlovr_select & 0x01)) return input_port_read(space->machine, "DSW4"); - if (!(ddenlovr_select & 0x02)) return input_port_read(space->machine, "DSW3"); - if (!(ddenlovr_select & 0x04)) return input_port_read(space->machine, "DSW2"); - if (!(ddenlovr_select & 0x08)) return input_port_read(space->machine, "DSW1"); - if (!(ddenlovr_select & 0x10)) return input_port_read(space->machine, "DSW5"); - logerror("%06x: warning, unknown bits read, ddenlovr_select = %02x\n", cpu_get_pc(space->cpu), ddenlovr_select); + dynax_state *state = (dynax_state *)space->machine->driver_data; + + if (!(state->dsw_sel & 0x01)) return input_port_read(space->machine, "DSW4"); + if (!(state->dsw_sel & 0x02)) return input_port_read(space->machine, "DSW3"); + if (!(state->dsw_sel & 0x04)) return input_port_read(space->machine, "DSW2"); + if (!(state->dsw_sel & 0x08)) return input_port_read(space->machine, "DSW1"); + if (!(state->dsw_sel & 0x10)) return input_port_read(space->machine, "DSW5"); + logerror("%06x: warning, unknown bits read, ddenlovr_select = %02x\n", cpu_get_pc(space->cpu), state->dsw_sel); return 0xff; } static WRITE8_HANDLER( mjmyster_coincounter_w ) { - switch( ddenlovr_select2 ) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->input_sel) { case 0x0c: coin_counter_w(space->machine, 0, (~data) & 0x01); // coin in @@ -2659,16 +2836,17 @@ static WRITE8_HANDLER( mjmyster_coincounter_w ) break; default: - logerror("%06x: warning, unknown bits written, ddenlovr_select2 = %02x, data = %02x\n", cpu_get_pc(space->cpu), ddenlovr_select2, data); + logerror("%06x: warning, unknown bits written, ddenlovr_select2 = %02x, data = %02x\n", cpu_get_pc(space->cpu), state->input_sel, data); } } static WRITE8_HANDLER( mjmyster_blitter_w ) { - blitter_w(space, 0,offset,data,0xfc); + blitter_w(space, 0, offset, data, 0xfc); } -static ADDRESS_MAP_START( mjmyster_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) +static ADDRESS_MAP_START( mjmyster_portmap, ADDRESS_SPACE_IO, 8 ) + ADDRESS_MAP_GLOBAL_MASK(0xff) AM_RANGE(0x00, 0x01) AM_WRITE(mjmyster_blitter_w) AM_RANGE(0x03, 0x03) AM_READ(rongrong_gfxrom_r) AM_RANGE(0x1c, 0x1c) AM_WRITE(mjmyster_rambank_w) @@ -2699,21 +2877,23 @@ ADDRESS_MAP_END Hanafuda Hana Ginga ***************************************************************************/ -static UINT8 hginga_rombank; static WRITE8_HANDLER( hginga_rombank_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; UINT8 *rom = memory_region(space->machine, "maincpu"); memory_set_bankptr(space->machine, "bank1", &rom[0x10000 + 0x8000 * (data & 0x7)]); - hginga_rombank = data; + state->hginga_rombank = data; } // similar to rongrong static READ8_HANDLER( hginga_protection_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; UINT8 *rom = memory_region(space->machine, "maincpu"); - if (hginga_rombank & 0x10) - return hanakanz_rand_r(space,0); - return rom[0x10000 + 0x8000 * (hginga_rombank & 0x7) + 0xf601 - 0x8000]; + + if (state->hginga_rombank & 0x10) + return hanakanz_rand_r(space, 0); + return rom[0x10000 + 0x8000 * (state->hginga_rombank & 0x7) + 0xf601 - 0x8000]; } static ADDRESS_MAP_START( hginga_map, ADDRESS_SPACE_PROGRAM, 8 ) @@ -2728,44 +2908,50 @@ ADDRESS_MAP_END static READ8_DEVICE_HANDLER( hginga_dsw_r ) { - if (!(ddenlovr_select & 0x01)) return input_port_read(device->machine, "DSW4"); - if (!(ddenlovr_select & 0x02)) return input_port_read(device->machine, "DSW3"); - if (!(ddenlovr_select & 0x04)) return input_port_read(device->machine, "DSW2"); - if (!(ddenlovr_select & 0x08)) return input_port_read(device->machine, "DSW1"); - if (!(ddenlovr_select & 0x10)) return input_port_read(device->machine, "DSW5"); - logerror("%s: warning, unknown bits read, ddenlovr_select = %02x\n", cpuexec_describe_context(device->machine), ddenlovr_select); + dynax_state *state = (dynax_state *)device->machine->driver_data; + + if (!(state->dsw_sel & 0x01)) return input_port_read(device->machine, "DSW4"); + if (!(state->dsw_sel & 0x02)) return input_port_read(device->machine, "DSW3"); + if (!(state->dsw_sel & 0x04)) return input_port_read(device->machine, "DSW2"); + if (!(state->dsw_sel & 0x08)) return input_port_read(device->machine, "DSW1"); + if (!(state->dsw_sel & 0x10)) return input_port_read(device->machine, "DSW5"); + + logerror("%s: warning, unknown bits read, ddenlovr_select = %02x\n", cpuexec_describe_context(device->machine), state->dsw_sel); return 0xff; } -static UINT8 hginga_select, hginga_ip, hginga_coins; - static WRITE8_HANDLER( hginga_input_w ) { - hginga_select = data; - hginga_ip = 0; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->input_sel = data; + state->keyb = 0; } static READ8_HANDLER( hginga_coins_r ) { - switch( hginga_select ) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->input_sel) { case 0x20: return input_port_read(space->machine, "SYSTEM"); case 0x21: return input_port_read(space->machine, "BET"); case 0x22: return 0x7f; // bit 7 = blitter busy, bit 6 = hopper - case 0x23: return hginga_coins; + case 0x23: return state->coins; } - logerror("%04x: coins_r with select = %02x\n", cpu_get_pc(space->cpu), hginga_select); + logerror("%04x: coins_r with select = %02x\n", cpu_get_pc(space->cpu), state->input_sel); return 0xff; } static WRITE8_HANDLER( hginga_80_w ) { -// popmessage("port 80 = %02x",data); +// popmessage("port 80 = %02x", data); } static WRITE8_HANDLER( hginga_coins_w ) { - switch( hginga_select ) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->input_sel) { case 0x2d: break; @@ -2777,46 +2963,48 @@ static WRITE8_HANDLER( hginga_coins_w ) // bit 7? coin_counter_w(space->machine, 0, data & 1); #ifdef MAME_DEBUG -// popmessage("COINS %02x",data); +// popmessage("COINS %02x", data); #endif - hginga_coins = data; + state->coins = data; break; default: - logerror("%04x: coins_w with select = %02x, data = %02x\n", cpu_get_pc(space->cpu), hginga_select, data); + logerror("%04x: coins_w with select = %02x, data = %02x\n", cpu_get_pc(space->cpu), state->input_sel, data); } } static READ8_HANDLER( hginga_input_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; static const char *const keynames0[] = { "KEY0", "KEY1", "KEY2", "KEY3", "KEY4" }; static const char *const keynames1[] = { "KEY5", "KEY6", "KEY7", "KEY8", "KEY9" }; - switch( hginga_select ) + switch (state->input_sel) { case 0x2d: return 0xff; // player 1 case 0xa1: - return input_port_read(space->machine, keynames0[hginga_ip++]); + return input_port_read(space->machine, keynames0[state->keyb++]); // player 2 case 0xa2: - return input_port_read(space->machine, keynames1[hginga_ip++]); + return input_port_read(space->machine, keynames1[state->keyb++]); } - logerror("%04x: input_r with select = %02x\n", cpu_get_pc(space->cpu), hginga_select); + logerror("%04x: input_r with select = %02x\n", cpu_get_pc(space->cpu), state->input_sel); return 0xff; } static WRITE8_HANDLER( hginga_blitter_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; if (offset == 0) { - ddenlovr_blit_reg = data; + state->ddenlovr_blit_latch = data; } else { - switch (ddenlovr_blit_reg & 0x3f) + switch (state->ddenlovr_blit_latch & 0x3f) { case 0x00: switch (data & 0xf) @@ -2835,10 +3023,11 @@ static WRITE8_HANDLER( hginga_blitter_w ) break; } } - blitter_w(space, 0,offset,data,0xfc); + blitter_w(space, 0, offset, data, 0xfc); } -static ADDRESS_MAP_START( hginga_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) +static ADDRESS_MAP_START( hginga_portmap, ADDRESS_SPACE_IO, 8 ) + ADDRESS_MAP_GLOBAL_MASK(0xff) AM_RANGE(0x00, 0x01) AM_WRITE(hginga_blitter_w) AM_RANGE(0x03, 0x03) AM_READ(rongrong_gfxrom_r) AM_RANGE(0x1c, 0x1c) AM_READNOP AM_WRITE(mjmyster_rambank_w) @@ -2868,66 +3057,77 @@ ADDRESS_MAP_END Hanafuda Hana Gokou ***************************************************************************/ -static UINT8 hgokou_hopper; - -static UINT8 hgokou_player_r(const address_space *space, int player) +static UINT8 hgokou_player_r( const address_space *space, int player ) { - UINT8 hopper_bit = ((hgokou_hopper && !(video_screen_get_frame_number(space->machine->primary_screen)%10)) ? 0 : (1<<6)); + dynax_state *state = (dynax_state *)space->machine->driver_data; + UINT8 hopper_bit = ((state->hopper && !(video_screen_get_frame_number(space->machine->primary_screen) % 10)) ? 0 : (1 << 6)); - if (!(ddenlovr_select2 & 0x01)) return input_port_read(space->machine, player ? "KEY5" : "KEY0") | hopper_bit; - if (!(ddenlovr_select2 & 0x02)) return input_port_read(space->machine, player ? "KEY6" : "KEY1") | hopper_bit; - if (!(ddenlovr_select2 & 0x04)) return input_port_read(space->machine, player ? "KEY7" : "KEY2") | hopper_bit; - if (!(ddenlovr_select2 & 0x08)) return input_port_read(space->machine, player ? "KEY8" : "KEY3") | hopper_bit; - if (!(ddenlovr_select2 & 0x10)) return input_port_read(space->machine, player ? "KEY9" : "KEY4") | hopper_bit; + if (!(state->input_sel & 0x01)) return input_port_read(space->machine, player ? "KEY5" : "KEY0") | hopper_bit; + if (!(state->input_sel & 0x02)) return input_port_read(space->machine, player ? "KEY6" : "KEY1") | hopper_bit; + if (!(state->input_sel & 0x04)) return input_port_read(space->machine, player ? "KEY7" : "KEY2") | hopper_bit; + if (!(state->input_sel & 0x08)) return input_port_read(space->machine, player ? "KEY8" : "KEY3") | hopper_bit; + if (!(state->input_sel & 0x10)) return input_port_read(space->machine, player ? "KEY9" : "KEY4") | hopper_bit; return 0x7f; // bit 7 = blitter busy, bit 6 = hopper } +static WRITE8_HANDLER( hgokou_dsw_sel_w ) +{ + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->dsw_sel = data; +} + static READ8_HANDLER( hgokou_input_r ) { - switch (hginga_select) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->dsw_sel) { case 0x20: return input_port_read(space->machine, "SYSTEM"); case 0x21: return hgokou_player_r(space, 1); case 0x22: return hgokou_player_r(space, 0); - case 0x23: return hginga_coins; + case 0x23: return state->coins; } - logerror("%06x: warning, unknown bits read, hginga_select = %02x\n", cpu_get_pc(space->cpu), hginga_select); + logerror("%06x: warning, unknown bits read, dsw_sel = %02x\n", cpu_get_pc(space->cpu), state->dsw_sel); return 0xff; } static WRITE8_HANDLER( hgokou_input_w ) { - switch (hginga_select) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->dsw_sel) { case 0x2c: // bit 0 = coin counter // bit 1 = out counter // bit 2 = hopper coin_counter_w(space->machine, 0, data & 1); - hgokou_hopper = data & 0x04; + state->hopper = data & 0x04; #ifdef MAME_DEBUG // popmessage("COINS %02x",data); #endif - hginga_coins = data; + state->coins = data; break; - case 0x2d: ddenlovr_select2 = data; break; + case 0x2d: state->input_sel = data; break; case 0x2f: break; // ? written with 2f default: - logerror("%04x: input_w with select = %02x, data = %02x\n",cpu_get_pc(space->cpu),hginga_select,data); + logerror("%04x: input_w with select = %02x, data = %02x\n", cpu_get_pc(space->cpu), state->dsw_sel, data); } } // similar to rongrong static READ8_HANDLER( hgokou_protection_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; UINT8 *rom = memory_region(space->machine, "maincpu"); - if (hginga_rombank == 0) - return hanakanz_rand_r(space,0); - return rom[0x10000 + 0x8000 * (hginga_rombank & 0x7) + 0xe601 - 0x8000]; + + if (state->hginga_rombank == 0) + return hanakanz_rand_r(space, 0); + return rom[0x10000 + 0x8000 * (state->hginga_rombank & 0x7) + 0xe601 - 0x8000]; } static ADDRESS_MAP_START( hgokou_map, ADDRESS_SPACE_PROGRAM, 8 ) @@ -2941,7 +3141,8 @@ static ADDRESS_MAP_START( hgokou_map, ADDRESS_SPACE_PROGRAM, 8 ) ADDRESS_MAP_END -static ADDRESS_MAP_START( hgokou_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) +static ADDRESS_MAP_START( hgokou_portmap, ADDRESS_SPACE_IO, 8 ) + ADDRESS_MAP_GLOBAL_MASK(0xff) AM_RANGE(0x00, 0x01) AM_WRITE(hginga_blitter_w) AM_RANGE(0x03, 0x03) AM_READ(rongrong_gfxrom_r) AM_RANGE(0x1c, 0x1c) AM_READNOP AM_WRITE(mjmyster_rambank_w) // ? ack on RTC int @@ -2955,7 +3156,7 @@ static ADDRESS_MAP_START( hgokou_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOB AM_RANGE(0x55, 0x55) AM_WRITE(ddenlovr_priority_w) AM_RANGE(0x56, 0x56) AM_WRITE(ddenlovr_layer_enable_w) AM_RANGE(0x58, 0x58) AM_READ(unk_r) // ? must be 78 on startup - AM_RANGE(0x60, 0x60) AM_WRITE(hginga_input_w) + AM_RANGE(0x60, 0x60) AM_WRITE(hgokou_dsw_sel_w) AM_RANGE(0x61, 0x61) AM_WRITE(hgokou_input_w) AM_RANGE(0x62, 0x62) AM_READ(hgokou_input_r) AM_RANGE(0x80, 0x80) AM_DEVREADWRITE("oki", okim6295_r, okim6295_w) @@ -2973,10 +3174,11 @@ ADDRESS_MAP_END static WRITE8_HANDLER( hparadis_select_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; UINT8 *rom = memory_region(space->machine, "maincpu"); - ddenlovr_select = data; - hginga_ip = 0; + state->dsw_sel = data; + state->keyb = 0; memory_set_bankptr(space->machine, "bank1", &rom[0x10000 + 0x8000 * (data & 0x07)]); memory_set_bankptr(space->machine, "bank2", &rom[0x50000 + 0x1000 * ((data & 0xe0) >> 5)]); @@ -2985,40 +3187,45 @@ static WRITE8_HANDLER( hparadis_select_w ) static READ8_HANDLER( hparadis_input_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; static const char *const keynames0[] = { "KEY0", "KEY1", "KEY2", "KEY3", "KEY4" }; static const char *const keynames1[] = { "KEY5", "KEY6", "KEY7", "KEY8", "KEY9" }; - switch (hginga_select) + switch (state->input_sel) { case 0x00: return input_port_read(space->machine, "P1"); case 0x01: return input_port_read(space->machine, "P2"); case 0x02: return input_port_read(space->machine, "SYSTEM"); case 0x0d: return 0x00; - case 0x80: return input_port_read(space->machine, keynames0[hginga_ip++]); // P1 (Keys) - case 0x81: return input_port_read(space->machine, keynames1[hginga_ip++]); // P2 (Keys) + case 0x80: return input_port_read(space->machine, keynames0[state->keyb++]); // P1 (Keys) + case 0x81: return input_port_read(space->machine, keynames1[state->keyb++]); // P2 (Keys) } - logerror("%06x: warning, unknown bits read, hginga_select = %02x\n", cpu_get_pc(space->cpu), hginga_select); + logerror("%06x: warning, unknown bits read, input_sel = %02x\n", cpu_get_pc(space->cpu), state->input_sel); return 0xff; } static READ8_HANDLER( hparadis_dsw_r ) { - if (!(ddenlovr_select & 0x01)) return input_port_read(space->machine, "DSW1"); - if (!(ddenlovr_select & 0x02)) return input_port_read(space->machine, "DSW2"); - if (!(ddenlovr_select & 0x04)) return 0xff; - if (!(ddenlovr_select & 0x08)) return 0xff; - if (!(ddenlovr_select & 0x10)) return input_port_read(space->machine, "DSW3"); + dynax_state *state = (dynax_state *)space->machine->driver_data; + + if (!(state->dsw_sel & 0x01)) return input_port_read(space->machine, "DSW1"); + if (!(state->dsw_sel & 0x02)) return input_port_read(space->machine, "DSW2"); + if (!(state->dsw_sel & 0x04)) return 0xff; + if (!(state->dsw_sel & 0x08)) return 0xff; + if (!(state->dsw_sel & 0x10)) return input_port_read(space->machine, "DSW3"); return 0xff; } static WRITE8_HANDLER( hparadis_coin_w ) { - switch ( hginga_select ) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->input_sel) { case 0x0c: coin_counter_w(space->machine, 0, data & 1); break; case 0x0d: break; default: - logerror("%04x: coins_w with select = %02x, data = %02x\n",cpu_get_pc(space->cpu),hginga_select,data); + logerror("%04x: coins_w with select = %02x, data = %02x\n",cpu_get_pc(space->cpu), state->input_sel, data); } } @@ -3031,7 +3238,8 @@ static ADDRESS_MAP_START( hparadis_map, ADDRESS_SPACE_PROGRAM, 8 ) ADDRESS_MAP_END // the RTC seems unused -static ADDRESS_MAP_START( hparadis_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) +static ADDRESS_MAP_START( hparadis_portmap, ADDRESS_SPACE_IO, 8 ) + ADDRESS_MAP_GLOBAL_MASK(0xff) AM_RANGE(0x00, 0x01) AM_WRITE(rongrong_blitter_w) AM_RANGE(0x03, 0x03) AM_READ(rongrong_gfxrom_r) AM_RANGE(0x1b, 0x1b) AM_READWRITE(rongrong_blitter_busy_r, rongrong_blitter_busy_w) @@ -3060,7 +3268,9 @@ ADDRESS_MAP_END static READ8_HANDLER( mjmywrld_coins_r ) { - switch( ddenlovr_select2 ) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->input_sel) { case 0x80: return input_port_read(space->machine, "SYSTEM"); case 0x81: return 0x00; @@ -3068,12 +3278,13 @@ static READ8_HANDLER( mjmywrld_coins_r ) case 0x83: return 0x00; } - logerror("%06x: warning, unknown bits read, ddenlovr_select2 = %02x\n", cpu_get_pc(space->cpu), ddenlovr_select2); + logerror("%06x: warning, unknown bits read, input_sel = %02x\n", cpu_get_pc(space->cpu), state->input_sel); return 0xff; } -static ADDRESS_MAP_START( mjmywrld_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) +static ADDRESS_MAP_START( mjmywrld_portmap, ADDRESS_SPACE_IO, 8 ) + ADDRESS_MAP_GLOBAL_MASK(0xff) AM_RANGE(0x00, 0x01) AM_WRITE(mjmyster_blitter_w) AM_RANGE(0x03, 0x03) AM_READ(rongrong_gfxrom_r) AM_RANGE(0x1c, 0x1c) AM_WRITE(mjmyster_rambank_w) @@ -3105,41 +3316,44 @@ ADDRESS_MAP_END Panel & Variety Akamaru Q Jousyou Dont-R ***************************************************************************/ -static UINT16 akamaru_protection1; static READ16_HANDLER( akamaru_protection1_r ) { - return (akamaru_protection1 & 0x0008) ? 0x0001 : 0x0000; + dynax_state *state = (dynax_state *)space->machine->driver_data; + return (state->prot_16 & 0x0008) ? 0x0001 : 0x0000; } + static WRITE16_HANDLER( akamaru_protection1_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; int bank; - COMBINE_DATA( &akamaru_protection1 ); - // BCD number? - bank = (((akamaru_protection1>>4)&0xf)%10) * 10 + ((akamaru_protection1&0xf)%10); - okim6295_set_bank_base(devtag_get_device(space->machine, "oki"), bank * 0x40000); -// popmessage("bank $%0x (%d)",akamaru_protection1, bank); + COMBINE_DATA(&state->prot_16); + // BCD number? + bank = (((state->prot_16 >> 4) & 0x0f) % 10) * 10 + ((state->prot_16 & 0x0f) % 10); + okim6295_set_bank_base(state->oki, bank * 0x40000); + +// popmessage("bank $%0x (%d)", state->prot_16, bank); } - -static UINT16 *akamaru_protection2; static READ16_HANDLER( akamaru_protection2_r ) { return 0x55; } -static UINT16 *akamaru_dsw_sel; static READ16_HANDLER( akamaru_dsw_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; UINT16 dsw = 0; - if (akamaru_dsw_sel[1] == 0xff) dsw |= input_port_read(space->machine, "DSW1"); - if (akamaru_dsw_sel[0] == 0xff) dsw |= input_port_read(space->machine, "DSW2"); + + if (state->dsw_sel16[1] == 0xff) dsw |= input_port_read(space->machine, "DSW1"); + if (state->dsw_sel16[0] == 0xff) dsw |= input_port_read(space->machine, "DSW2"); return dsw; } static READ16_HANDLER( akamaru_blitter_r ) { - return ddenlovr_blitter_irq_flag << 6; // bit 7 = 1 -> blitter busy + dynax_state *state = (dynax_state *)space->machine->driver_data; + return state->ddenlovr_blitter_irq_flag << 6; // bit 7 = 1 -> blitter busy } static READ16_HANDLER( akamaru_e0010d_r ) @@ -3172,7 +3386,7 @@ static ADDRESS_MAP_START( akamaru_map, ADDRESS_SPACE_PROGRAM, 16 ) AM_RANGE(0xe00104, 0xe00105) AM_READ_PORT("SYSTEM") AM_RANGE(0xe00106, 0xe00107) AM_READ(akamaru_protection2_r) - AM_RANGE(0xe00108, 0xe0010b) AM_WRITEONLY AM_BASE(&akamaru_protection2) + AM_RANGE(0xe00108, 0xe0010b) AM_WRITEONLY AM_BASE_MEMBER(dynax_state, protection2) AM_RANGE(0xe0010c, 0xe0010d) AM_READ(akamaru_e0010d_r) AM_RANGE(0xe00200, 0xe00201) AM_READ(akamaru_dsw_r) // DSW @@ -3180,7 +3394,7 @@ static ADDRESS_MAP_START( akamaru_map, ADDRESS_SPACE_PROGRAM, 16 ) AM_RANGE(0xe00204, 0xe00205) AM_READ(akamaru_blitter_r) // Blitter Busy & IRQ AM_RANGE(0xe00302, 0xe00303) AM_WRITE(ddenlovr_blitter_irq_ack_w) // Blitter irq acknowledge - AM_RANGE(0xe00304, 0xe00307) AM_WRITEONLY AM_BASE( &akamaru_dsw_sel) // DSW select + AM_RANGE(0xe00304, 0xe00307) AM_WRITEONLY AM_BASE_MEMBER(dynax_state, dsw_sel16) // DSW select AM_RANGE(0xe00308, 0xe00309) AM_WRITE(ddenlovr_coincounter_0_w) // Coin Counters AM_RANGE(0xe0030c, 0xe0030d) AM_WRITE(ddenlovr_coincounter_1_w) // @@ -3216,41 +3430,42 @@ static READ8_HANDLER( mjflove_protection_r ) static READ8_HANDLER( mjflove_keyb_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; UINT8 val = 0xff; - if (!(keyb & 0x01)) val = input_port_read(space->machine, offset ? "KEY5" : "KEY0"); - else if (!(keyb & 0x02)) val = input_port_read(space->machine, offset ? "KEY6" : "KEY1"); - else if (!(keyb & 0x04)) val = input_port_read(space->machine, offset ? "KEY7" : "KEY2"); - else if (!(keyb & 0x08)) val = input_port_read(space->machine, offset ? "KEY8" : "KEY3"); - else if (!(keyb & 0x10)) val = input_port_read(space->machine, offset ? "KEY9" : "KEY4"); + if (!(state->keyb & 0x01)) val = input_port_read(space->machine, offset ? "KEY5" : "KEY0"); + else if (!(state->keyb & 0x02)) val = input_port_read(space->machine, offset ? "KEY6" : "KEY1"); + else if (!(state->keyb & 0x04)) val = input_port_read(space->machine, offset ? "KEY7" : "KEY2"); + else if (!(state->keyb & 0x08)) val = input_port_read(space->machine, offset ? "KEY8" : "KEY3"); + else if (!(state->keyb & 0x10)) val = input_port_read(space->machine, offset ? "KEY9" : "KEY4"); return val; } -static UINT8 mjflove_irq_cause; - static CUSTOM_INPUT( mjflove_blitter_r ) { + dynax_state *state = (dynax_state *)field->port->machine->driver_data; + // bit 7 = 1 -> blitter busy // bit 6 = 0 -> VBLANK? // bit 5 = 0 -> RTC? - return mjflove_irq_cause; + return state->mjflove_irq_cause; } static WRITE8_HANDLER( mjflove_blitter_w ) { - blitter_w(space, 0,offset,data,0); + blitter_w(space, 0, offset, data, 0); } static WRITE8_HANDLER( mjflove_coincounter_w ) { // bit 0 = in counter - coin_counter_w(space->machine, 0, data & 0x01); + coin_counter_w(space->machine, 0, data & 0x01); if (data & 0xfe) { logerror("%04x: warning, coin counter = %02x\n", cpu_get_pc(space->cpu), data); -// popmessage("COIN = %02x",data); +// popmessage("COIN = %02x", data); } } @@ -3295,8 +3510,9 @@ static WRITE8_DEVICE_HANDLER( jongtei_okibank_w ) static WRITE8_HANDLER( jongtei_dsw_keyb_w ) { - dsw = data; - keyb = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->dsw_sel = data; + state->keyb = data; } static READ8_HANDLER( jongtei_busy_r ) @@ -3304,7 +3520,8 @@ static READ8_HANDLER( jongtei_busy_r ) return 0x04; // !bit 2 = blitter busy } -static ADDRESS_MAP_START( jongtei_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) +static ADDRESS_MAP_START( jongtei_portmap, ADDRESS_SPACE_IO, 8 ) + ADDRESS_MAP_GLOBAL_MASK(0xff) AM_RANGE(0x2c, 0x2c) AM_READ(jongtei_busy_r) AM_DEVWRITE("oki", jongtei_okibank_w) AM_RANGE(0x2e, 0x2e) AM_WRITE(hanakanz_blitter_reg_w) AM_RANGE(0x30, 0x30) AM_WRITE(hanakanz_rombank_w) @@ -3337,16 +3554,18 @@ ADDRESS_MAP_END static READ8_HANDLER( sryudens_keyb_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; UINT8 val = 0x3f; - if (!(keyb & 0x01)) val = input_port_read(space->machine, offset ? "KEY5" : "KEY0"); - else if (!(keyb & 0x02)) val = input_port_read(space->machine, offset ? "KEY6" : "KEY1"); - else if (!(keyb & 0x04)) val = input_port_read(space->machine, offset ? "KEY7" : "KEY2"); - else if (!(keyb & 0x08)) val = input_port_read(space->machine, offset ? "KEY8" : "KEY3"); - else if (!(keyb & 0x10)) val = input_port_read(space->machine, offset ? "KEY9" : "KEY4"); + if (!(state->keyb & 0x01)) val = input_port_read(space->machine, offset ? "KEY5" : "KEY0"); + else if (!(state->keyb & 0x02)) val = input_port_read(space->machine, offset ? "KEY6" : "KEY1"); + else if (!(state->keyb & 0x04)) val = input_port_read(space->machine, offset ? "KEY7" : "KEY2"); + else if (!(state->keyb & 0x08)) val = input_port_read(space->machine, offset ? "KEY8" : "KEY3"); + else if (!(state->keyb & 0x10)) val = input_port_read(space->machine, offset ? "KEY9" : "KEY4"); val |= input_port_read(space->machine, offset ? "HOPPER" : "BET"); - if (offset) val &= 0x7f; // bit 7 = blitter busy + if (offset) + val &= 0x7f; // bit 7 = blitter busy return val; } @@ -3364,7 +3583,7 @@ static WRITE8_HANDLER( sryudens_coincounter_w ) logerror("%04x: warning, coin counter = %02x\n", cpu_get_pc(space->cpu), data); #ifdef MAME_DEBUG -// popmessage("COIN = %02x",data); +// popmessage("COIN = %02x", data); #endif } @@ -3375,7 +3594,8 @@ static WRITE8_HANDLER( sryudens_rambank_w ) // logerror("%04x: rambank = %02x\n", cpu_get_pc(space->cpu), data); } -static ADDRESS_MAP_START( sryudens_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) +static ADDRESS_MAP_START( sryudens_portmap, ADDRESS_SPACE_IO, 8 ) + ADDRESS_MAP_GLOBAL_MASK(0xff) AM_RANGE(0x00, 0x00) AM_DEVREADWRITE("oki", okim6295_r, okim6295_w) AM_RANGE(0x02, 0x03) AM_DEVWRITE("ymsnd", ym2413_w) AM_RANGE(0x04, 0x05) AM_DEVWRITE("aysnd", ay8910_address_data_w) @@ -3412,26 +3632,29 @@ ADDRESS_MAP_END static READ8_HANDLER( daimyojn_keyb1_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; UINT8 val = 0x3f; - if (!(keyb & 0x01)) val = input_port_read(space->machine, "KEY0"); - else if (!(keyb & 0x02)) val = input_port_read(space->machine, "KEY1"); - else if (!(keyb & 0x04)) val = input_port_read(space->machine, "KEY2"); - else if (!(keyb & 0x08)) val = input_port_read(space->machine, "KEY3"); - else if (!(keyb & 0x10)) val = input_port_read(space->machine, "KEY4"); + if (!(state->keyb & 0x01)) val = input_port_read(space->machine, "KEY0"); + else if (!(state->keyb & 0x02)) val = input_port_read(space->machine, "KEY1"); + else if (!(state->keyb & 0x04)) val = input_port_read(space->machine, "KEY2"); + else if (!(state->keyb & 0x08)) val = input_port_read(space->machine, "KEY3"); + else if (!(state->keyb & 0x10)) val = input_port_read(space->machine, "KEY4"); val |= input_port_read(space->machine, "BET"); return val; } + static READ8_HANDLER( daimyojn_keyb2_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; UINT8 val = 0x3f; - if (!(keyb & 0x01)) val = input_port_read(space->machine, "KEY5"); - else if (!(keyb & 0x02)) val = input_port_read(space->machine, "KEY6"); - else if (!(keyb & 0x04)) val = input_port_read(space->machine, "KEY7"); - else if (!(keyb & 0x08)) val = input_port_read(space->machine, "KEY8"); - else if (!(keyb & 0x10)) val = input_port_read(space->machine, "KEY9"); + if (!(state->keyb & 0x01)) val = input_port_read(space->machine, "KEY5"); + else if (!(state->keyb & 0x02)) val = input_port_read(space->machine, "KEY6"); + else if (!(state->keyb & 0x04)) val = input_port_read(space->machine, "KEY7"); + else if (!(state->keyb & 0x08)) val = input_port_read(space->machine, "KEY8"); + else if (!(state->keyb & 0x10)) val = input_port_read(space->machine, "KEY9"); val |= input_port_read(space->machine, "HOPPER"); return val; @@ -3439,16 +3662,17 @@ static READ8_HANDLER( daimyojn_keyb2_r ) // 1B18: D4 ED 76 C9 CB // 1B1D: 96 AF 34 8B 89 -static UINT8 daimyojn_protection_val; static WRITE8_HANDLER( daimyojn_protection_w ) { - daimyojn_protection_val = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->prot_val = data; } static READ8_HANDLER( daimyojn_protection_r ) { - switch (daimyojn_protection_val) + dynax_state *state = (dynax_state *)space->machine->driver_data; + switch (state->prot_val) { case 0xd4: return 0x96; case 0xed: return 0xaf; @@ -3464,15 +3688,17 @@ static WRITE8_DEVICE_HANDLER( daimyojn_okibank_w ) okim6295_set_bank_base(device, ((data >> 4) & 0x01) * 0x40000); } -static UINT8 daimyojn_palette_sel; static WRITE8_HANDLER( daimyojn_palette_sel_w ) { - daimyojn_palette_sel = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->daimyojn_palette_sel = data; } static WRITE8_HANDLER( daimyojn_blitter_data_palette_w ) { - if (daimyojn_palette_sel & 0x01) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + if (state->daimyojn_palette_sel & 0x01) hanakanz_palette_w(space, offset, data); else hanakanz_blitter_data_w(space, offset, data); @@ -3484,7 +3710,8 @@ static READ8_HANDLER( daimyojn_year_hack_r ) return offset ? 1 : 0; // year = 0x10 (BCD) } -static ADDRESS_MAP_START( daimyojn_portmap, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) +static ADDRESS_MAP_START( daimyojn_portmap, ADDRESS_SPACE_IO, 8 ) + ADDRESS_MAP_GLOBAL_MASK(0xff) AM_RANGE(0x2c, 0x2c) AM_READ(jongtei_busy_r) AM_DEVWRITE("oki", daimyojn_okibank_w) AM_RANGE(0x2e, 0x2e) AM_WRITE(daimyojn_palette_sel_w) AM_RANGE(0x30, 0x30) AM_WRITE(hanakanz_blitter_reg_w) @@ -7334,17 +7561,91 @@ static INPUT_PORTS_START( daimyojn ) INPUT_PORTS_END +/*************************************************************************** + + + Machine Drivers + + +***************************************************************************/ + +static MACHINE_START( ddenlovr ) +{ + dynax_state *state = (dynax_state *)machine->driver_data; + + state->maincpu = devtag_get_device(machine, "maincpu"); + state->soundcpu = devtag_get_device(machine, "soundcpu"); + state->oki = devtag_get_device(machine, "oki"); + + state_save_register_global(machine, state->input_sel); + state_save_register_global(machine, state->dsw_sel); + state_save_register_global(machine, state->keyb); + state_save_register_global(machine, state->coins); + state_save_register_global(machine, state->hopper); + + state_save_register_global(machine, state->okibank); + state_save_register_global(machine, state->rongrong_blitter_busy_select); + + state_save_register_global(machine, state->prot_val); + state_save_register_global(machine, state->prot_16); + state_save_register_global_array(machine, state->quiz365_protection); + + state_save_register_global(machine, state->mmpanic_leds); + state_save_register_global(machine, state->funkyfig_lockout); + state_save_register_global_array(machine, state->romdata); + state_save_register_global(machine, state->palette_index); + state_save_register_global(machine, state->hginga_rombank); + state_save_register_global(machine, state->mjflove_irq_cause); + state_save_register_global(machine, state->daimyojn_palette_sel); + + state_save_register_global(machine, state->irq_count); +} + +static MACHINE_RESET( ddenlovr ) +{ + dynax_state *state = (dynax_state *)machine->driver_data; + + state->input_sel = 0; + state->dsw_sel = 0; + state->keyb = 0; + state->coins = 0; + state->hopper = 0; + + state->okibank = 0; + state->rongrong_blitter_busy_select = 0; + state->prot_val = 0; + state->prot_16 = 0; + state->mmpanic_leds = 0; + state->funkyfig_lockout = 0; + state->palette_index = 0; + state->hginga_rombank = 0; + state->mjflove_irq_cause = 0; + state->daimyojn_palette_sel = 0; + state->irq_count = 0; + + state->quiz365_protection[0] = 0; + state->quiz365_protection[1] = 0; + state->romdata[0] = 0; + state->romdata[1] = 0; +} + /*************************************************************************** Don Den Lover Vol.1 ***************************************************************************/ static MACHINE_DRIVER_START( ddenlovr ) + /* driver data */ + MDRV_DRIVER_DATA(dynax_state) + /* basic machine hardware */ MDRV_CPU_ADD("maincpu",M68000, XTAL_24MHz / 2) MDRV_CPU_PROGRAM_MAP(ddenlovr_map) MDRV_CPU_VBLANK_INT("screen", irq1_line_hold) + MDRV_MACHINE_START(ddenlovr) + MDRV_MACHINE_RESET(ddenlovr) + /* video hardware */ MDRV_SCREEN_ADD("screen", RASTER) MDRV_SCREEN_REFRESH_RATE(60) @@ -7442,7 +7743,7 @@ MACHINE_DRIVER_END */ static INTERRUPT_GEN( quizchq_irq ) { - static int count; + dynax_state *state = (dynax_state *)device->machine->driver_data; /* I haven't found a irq ack register, so I need this kludge to make sure I don't lose any interrupt generated by the blitter, @@ -7450,7 +7751,7 @@ static INTERRUPT_GEN( quizchq_irq ) if (device->get_runtime_int(CPUINFO_INT_INPUT_STATE + 0)) return; - if ((++count % 60) == 0) + if ((++state->irq_count % 60) == 0) cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0xfc); else cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0xee); @@ -7465,12 +7766,18 @@ static INTERRUPT_GEN( rtc_irq ) static MACHINE_DRIVER_START( quizchq ) + /* driver data */ + MDRV_DRIVER_DATA(dynax_state) + /* basic machine hardware */ MDRV_CPU_ADD("maincpu", Z80, 8000000) /* ? */ MDRV_CPU_PROGRAM_MAP(quizchq_map) MDRV_CPU_IO_MAP(quizchq_portmap) MDRV_CPU_VBLANK_INT("screen", quizchq_irq) + MDRV_MACHINE_START(ddenlovr) + MDRV_MACHINE_RESET(ddenlovr) + /* video hardware */ MDRV_SCREEN_ADD("screen", RASTER) MDRV_SCREEN_REFRESH_RATE(60) @@ -7522,7 +7829,7 @@ MACHINE_DRIVER_END */ static INTERRUPT_GEN( mmpanic_irq ) { - static int count; + dynax_state *state = (dynax_state *)device->machine->driver_data; /* I haven't found a irq ack register, so I need this kludge to make sure I don't lose any interrupt generated by the blitter, @@ -7530,7 +7837,7 @@ static INTERRUPT_GEN( mmpanic_irq ) if (device->get_runtime_int(CPUINFO_INT_INPUT_STATE + 0)) return; - if ((++count % 60) == 0) + if ((++state->irq_count % 60) == 0) cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0xe7); // RST 20, clock else cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0xcf); // RST 08, vblank @@ -7538,6 +7845,9 @@ static INTERRUPT_GEN( mmpanic_irq ) static MACHINE_DRIVER_START( mmpanic ) + /* driver data */ + MDRV_DRIVER_DATA(dynax_state) + /* basic machine hardware */ MDRV_CPU_ADD("maincpu", Z80, 8000000) MDRV_CPU_PROGRAM_MAP(mmpanic_map) @@ -7549,6 +7859,9 @@ static MACHINE_DRIVER_START( mmpanic ) MDRV_CPU_IO_MAP(mmpanic_sound_portmap) MDRV_CPU_VBLANK_INT("screen", irq0_line_hold) // NMI by main cpu + MDRV_MACHINE_START(ddenlovr) + MDRV_MACHINE_RESET(ddenlovr) + /* video hardware */ MDRV_SCREEN_ADD("screen", RASTER) MDRV_SCREEN_REFRESH_RATE(60) @@ -7594,7 +7907,7 @@ MACHINE_DRIVER_END */ static INTERRUPT_GEN( hanakanz_irq ) { - static int count; + dynax_state *state = (dynax_state *)device->machine->driver_data; /* I haven't found a irq ack register, so I need this kludge to make sure I don't lose any interrupt generated by the blitter, @@ -7602,7 +7915,7 @@ static INTERRUPT_GEN( hanakanz_irq ) if (device->get_runtime_int(CPUINFO_INT_INPUT_STATE + 0)) return; - if ((++count % 60) == 0) + if ((++state->irq_count % 60) == 0) cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0xe2); else cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0xe0); @@ -7610,12 +7923,18 @@ static INTERRUPT_GEN( hanakanz_irq ) static MACHINE_DRIVER_START( hanakanz ) + /* driver data */ + MDRV_DRIVER_DATA(dynax_state) + /* basic machine hardware */ MDRV_CPU_ADD("maincpu",Z80,8000000) // TMPZ84C015BF-8 MDRV_CPU_PROGRAM_MAP(hanakanz_map) MDRV_CPU_IO_MAP(hanakanz_portmap) MDRV_CPU_VBLANK_INT("screen", hanakanz_irq) + MDRV_MACHINE_START(ddenlovr) + MDRV_MACHINE_RESET(ddenlovr) + /* video hardware */ MDRV_SCREEN_ADD("screen", RASTER) MDRV_SCREEN_REFRESH_RATE(60) @@ -7670,7 +7989,7 @@ MACHINE_DRIVER_END */ static INTERRUPT_GEN( mjchuuka_irq ) { - static int count; + dynax_state *state = (dynax_state *)device->machine->driver_data; /* I haven't found a irq ack register, so I need this kludge to make sure I don't lose any interrupt generated by the blitter, @@ -7678,7 +7997,7 @@ static INTERRUPT_GEN( mjchuuka_irq ) if (device->get_runtime_int(CPUINFO_INT_INPUT_STATE + 0)) return; - if ((++count % 60) == 0) + if ((++state->irq_count % 60) == 0) cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0xfa); else cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0xf8); @@ -7736,7 +8055,7 @@ static INTERRUPT_GEN( mjmyster_irq ) if (device->get_runtime_int(CPUINFO_INT_INPUT_STATE + 0)) return; - switch( cpu_getiloops(device) ) + switch (cpu_getiloops(device)) { case 0: cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0xf8); break; case 1: cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0xfa); break; @@ -7784,7 +8103,7 @@ MACHINE_DRIVER_END */ static INTERRUPT_GEN( hginga_irq ) { - static int count; + dynax_state *state = (dynax_state *)device->machine->driver_data; /* I haven't found a irq ack register, so I need this kludge to make sure I don't lose any interrupt generated by the blitter, @@ -7792,7 +8111,7 @@ static INTERRUPT_GEN( hginga_irq ) if (device->get_runtime_int(CPUINFO_INT_INPUT_STATE + 0)) return; - if ((++count % 60) == 0) + if ((++state->irq_count % 60) == 0) cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0xee); else cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0xf8); @@ -7870,16 +8189,18 @@ MACHINE_DRIVER_END static INTERRUPT_GEN( mjflove_irq ) { - mjflove_irq_cause = 1 | (1 << 1); + dynax_state *state = (dynax_state *)device->machine->driver_data; + + state->mjflove_irq_cause = 1 | (1 << 1); switch (cpu_getiloops(device)) { case 0: - mjflove_irq_cause &= 1; + state->mjflove_irq_cause &= 1; cpu_set_input_line(device, 0, HOLD_LINE); break; case 1: - mjflove_irq_cause &= 1 << 1; + state->mjflove_irq_cause &= 1 << 1; cpu_set_input_line(device, 0, HOLD_LINE); break; } @@ -7917,12 +8238,18 @@ MACHINE_DRIVER_END static MACHINE_DRIVER_START( jongtei ) + /* driver data */ + MDRV_DRIVER_DATA(dynax_state) + /* basic machine hardware */ MDRV_CPU_ADD("maincpu",Z80, XTAL_20MHz / 2) // ? MDRV_CPU_PROGRAM_MAP(hanakanz_map) MDRV_CPU_IO_MAP(jongtei_portmap) MDRV_CPU_VBLANK_INT("screen", hanakanz_irq) + MDRV_MACHINE_START(ddenlovr) + MDRV_MACHINE_RESET(ddenlovr) + /* video hardware */ MDRV_SCREEN_ADD("screen", RASTER) MDRV_SCREEN_REFRESH_RATE(60) @@ -7957,12 +8284,18 @@ MACHINE_DRIVER_END static MACHINE_DRIVER_START( sryudens ) + /* driver data */ + MDRV_DRIVER_DATA(dynax_state) + /* basic machine hardware */ MDRV_CPU_ADD("maincpu",Z80, XTAL_16MHz / 2) // ? MDRV_CPU_PROGRAM_MAP(sryudens_map) MDRV_CPU_IO_MAP(sryudens_portmap) MDRV_CPU_VBLANK_INT("screen", mjchuuka_irq) + MDRV_MACHINE_START(ddenlovr) + MDRV_MACHINE_RESET(ddenlovr) + /* video hardware */ MDRV_SCREEN_ADD("screen", RASTER) MDRV_SCREEN_REFRESH_RATE(60.8532) // VSync 60.8532Hz, HSync 15.2790kHz @@ -8000,12 +8333,18 @@ MACHINE_DRIVER_END static MACHINE_DRIVER_START( daimyojn ) + /* driver data */ + MDRV_DRIVER_DATA(dynax_state) + /* basic machine hardware */ MDRV_CPU_ADD("maincpu",Z80, XTAL_20MHz / 2) MDRV_CPU_PROGRAM_MAP(hanakanz_map) MDRV_CPU_IO_MAP(daimyojn_portmap) MDRV_CPU_VBLANK_INT("screen", hanakanz_irq) + MDRV_MACHINE_START(ddenlovr) + MDRV_MACHINE_RESET(ddenlovr) + /* video hardware */ MDRV_SCREEN_ADD("screen", RASTER) MDRV_SCREEN_REFRESH_RATE(59.7922) // HSync 15.4248kHz diff --git a/src/mame/drivers/dynax.c b/src/mame/drivers/dynax.c index 2616300e887..3892243aa98 100644 --- a/src/mame/drivers/dynax.c +++ b/src/mame/drivers/dynax.c @@ -96,40 +96,40 @@ TODO: Sports Match ***************************************************************************/ -UINT8 dynax_blitter_irq; -static UINT8 dynax_sound_irq; -static UINT8 dynax_vblank_irq; /* It runs in IM 0, thus needs an opcode on the data bus */ -void sprtmtch_update_irq(running_machine *machine) +void sprtmtch_update_irq( running_machine *machine ) { - int irq = ((dynax_sound_irq) ? 0x08 : 0) | - ((dynax_vblank_irq) ? 0x10 : 0) | - ((dynax_blitter_irq) ? 0x20 : 0) ; - cputag_set_input_line_and_vector(machine, "maincpu", 0, irq ? ASSERT_LINE : CLEAR_LINE, 0xc7 | irq); /* rst $xx */ + dynax_state *state = (dynax_state *)machine->driver_data; + int irq = (state->sound_irq ? 0x08 : 0) | ((state->vblank_irq) ? 0x10 : 0) | ((state->blitter_irq) ? 0x20 : 0) ; + cpu_set_input_line_and_vector(state->maincpu, 0, irq ? ASSERT_LINE : CLEAR_LINE, 0xc7 | irq); /* rst $xx */ } static WRITE8_HANDLER( dynax_vblank_ack_w ) { - dynax_vblank_irq = 0; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->vblank_irq = 0; sprtmtch_update_irq(space->machine); } static WRITE8_HANDLER( dynax_blitter_ack_w ) { - dynax_blitter_irq = 0; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->blitter_irq = 0; sprtmtch_update_irq(space->machine); } static INTERRUPT_GEN( sprtmtch_vblank_interrupt ) { - dynax_vblank_irq = 1; + dynax_state *state = (dynax_state *)device->machine->driver_data; + state->vblank_irq = 1; sprtmtch_update_irq(device->machine); } -static void sprtmtch_sound_callback(running_device *device, int state) +static void sprtmtch_sound_callback( running_device *device, int state ) { - dynax_sound_irq = state; + dynax_state *driver_state = (dynax_state *)device->machine->driver_data; + driver_state->sound_irq = state; sprtmtch_update_irq(device->machine); } @@ -138,38 +138,39 @@ static void sprtmtch_sound_callback(running_device *device, int state) Jantouki - Main CPU ***************************************************************************/ -UINT8 dynax_blitter2_irq; - /* It runs in IM 0, thus needs an opcode on the data bus */ void jantouki_update_irq(running_machine *machine) { - int irq = ((dynax_blitter_irq) ? 0x08 : 0) | - ((dynax_blitter2_irq) ? 0x10 : 0) | - ((dynax_vblank_irq) ? 0x20 : 0) ; - cputag_set_input_line_and_vector(machine, "maincpu", 0, irq ? ASSERT_LINE : CLEAR_LINE, 0xc7 | irq); /* rst $xx */ + dynax_state *state = (dynax_state *)machine->driver_data; + int irq = ((state->blitter_irq) ? 0x08 : 0) | ((state->blitter2_irq) ? 0x10 : 0) | ((state->vblank_irq) ? 0x20 : 0) ; + cpu_set_input_line_and_vector(state->maincpu, 0, irq ? ASSERT_LINE : CLEAR_LINE, 0xc7 | irq); /* rst $xx */ } static WRITE8_HANDLER( jantouki_vblank_ack_w ) { - dynax_vblank_irq = 0; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->vblank_irq = 0; jantouki_update_irq(space->machine); } static WRITE8_HANDLER( jantouki_blitter_ack_w ) { - dynax_blitter_irq = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->blitter_irq = data; jantouki_update_irq(space->machine); } static WRITE8_HANDLER( jantouki_blitter2_ack_w ) { - dynax_blitter2_irq = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->blitter2_irq = data; jantouki_update_irq(space->machine); } static INTERRUPT_GEN( jantouki_vblank_interrupt ) { - dynax_vblank_irq = 1; + dynax_state *state = (dynax_state *)device->machine->driver_data; + state->vblank_irq = 1; jantouki_update_irq(device->machine); } @@ -178,32 +179,31 @@ static INTERRUPT_GEN( jantouki_vblank_interrupt ) Jantouki - Sound CPU ***************************************************************************/ -static UINT8 dynax_soundlatch_irq; -static UINT8 dynax_sound_vblank_irq; - static void jantouki_sound_update_irq(running_machine *machine) { - int irq = ((dynax_sound_irq) ? 0x08 : 0) | - ((dynax_soundlatch_irq) ? 0x10 : 0) | - ((dynax_sound_vblank_irq) ? 0x20 : 0) ; - cputag_set_input_line_and_vector(machine, "soundcpu", 0, irq ? ASSERT_LINE : CLEAR_LINE, 0xc7 | irq); /* rst $xx */ + dynax_state *state = (dynax_state *)machine->driver_data; + int irq = ((state->sound_irq) ? 0x08 : 0) | ((state->soundlatch_irq) ? 0x10 : 0) | ((state->sound_vblank_irq) ? 0x20 : 0) ; + cpu_set_input_line_and_vector(state->soundcpu, 0, irq ? ASSERT_LINE : CLEAR_LINE, 0xc7 | irq); /* rst $xx */ } static INTERRUPT_GEN( jantouki_sound_vblank_interrupt ) { - dynax_sound_vblank_irq = 1; + dynax_state *state = (dynax_state *)device->machine->driver_data; + state->sound_vblank_irq = 1; jantouki_sound_update_irq(device->machine); } static WRITE8_HANDLER( jantouki_sound_vblank_ack_w ) { - dynax_sound_vblank_irq = 0; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->sound_vblank_irq = 0; jantouki_sound_update_irq(space->machine); } static void jantouki_sound_callback(running_device *device, int state) { - dynax_sound_irq = state; + dynax_state *driver_state = (dynax_state *)device->machine->driver_data; + driver_state->sound_irq = state; jantouki_sound_update_irq(device->machine); } @@ -224,47 +224,52 @@ static WRITE8_HANDLER( dynax_coincounter_0_w ) { coin_counter_w(space->machine, 0, data); } + static WRITE8_HANDLER( dynax_coincounter_1_w ) { coin_counter_w(space->machine, 1, data); } -static READ8_HANDLER( ret_ff ) { return 0xff; } +static READ8_HANDLER( ret_ff ) +{ + return 0xff; +} -static int keyb; - static READ8_HANDLER( hanamai_keyboard_0_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; int res = 0x3f; /* the game reads all rows at once (keyb = 0) to check if a key is pressed */ - if (~keyb & 0x01) res &= input_port_read(space->machine, "KEY0"); - if (~keyb & 0x02) res &= input_port_read(space->machine, "KEY1"); - if (~keyb & 0x04) res &= input_port_read(space->machine, "KEY2"); - if (~keyb & 0x08) res &= input_port_read(space->machine, "KEY3"); - if (~keyb & 0x10) res &= input_port_read(space->machine, "KEY4"); + if (!BIT(state->keyb, 0)) res &= input_port_read(space->machine, "KEY0"); + if (!BIT(state->keyb, 1)) res &= input_port_read(space->machine, "KEY1"); + if (!BIT(state->keyb, 2)) res &= input_port_read(space->machine, "KEY2"); + if (!BIT(state->keyb, 3)) res &= input_port_read(space->machine, "KEY3"); + if (!BIT(state->keyb, 4)) res &= input_port_read(space->machine, "KEY4"); return res; } static READ8_HANDLER( hanamai_keyboard_1_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; int res = 0x3f; /* the game reads all rows at once (keyb = 0) to check if a key is pressed */ - if (~keyb & 0x01) res &= input_port_read(space->machine, "KEY5"); - if (~keyb & 0x02) res &= input_port_read(space->machine, "KEY6"); - if (~keyb & 0x04) res &= input_port_read(space->machine, "KEY7"); - if (~keyb & 0x08) res &= input_port_read(space->machine, "KEY8"); - if (~keyb & 0x10) res &= input_port_read(space->machine, "KEY9"); + if (!BIT(state->keyb, 0)) res &= input_port_read(space->machine, "KEY5"); + if (!BIT(state->keyb, 1)) res &= input_port_read(space->machine, "KEY6"); + if (!BIT(state->keyb, 2)) res &= input_port_read(space->machine, "KEY7"); + if (!BIT(state->keyb, 3)) res &= input_port_read(space->machine, "KEY8"); + if (!BIT(state->keyb, 4)) res &= input_port_read(space->machine, "KEY9"); return res; } static WRITE8_HANDLER( hanamai_keyboard_w ) { - keyb = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->keyb = data; } @@ -281,178 +286,185 @@ static WRITE8_HANDLER( jantouki_sound_rombank_w ) } -static int hnoridur_bank; - static WRITE8_HANDLER( hnoridur_rombank_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; UINT8 *ROM = memory_region(space->machine, "maincpu") + 0x10000 + 0x8000*data; //logerror("%04x: rom bank = %02x\n",cpu_get_pc(space->cpu),data); memory_set_bankptr(space->machine, "bank1",ROM); - hnoridur_bank = data; + state->hnoridur_bank = data; } -static UINT8 palette_ram[16*256*2]; -static int palbank; static WRITE8_HANDLER( hnoridur_palbank_w ) { - palbank = data & 0x0f; - dynax_blit_palbank_w(space,0,data); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->palbank = data & 0x0f; + dynax_blit_palbank_w(space, 0, data); } static WRITE8_HANDLER( hnoridur_palette_w ) { - switch (hnoridur_bank) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->hnoridur_bank) { case 0x10: - if (offset >= 0x100) return; - palette_ram[256*palbank + offset + 16*256] = data; + if (offset >= 0x100) + return; + state->palette_ram[256 * state->palbank + offset + 16 * 256] = data; break; case 0x14: - if (offset >= 0x100) return; - palette_ram[256*palbank + offset] = data; + if (offset >= 0x100) + return; + state->palette_ram[256 * state->palbank + offset] = data; break; // hnoridur: R/W RAM case 0x18: { - UINT8 *RAM = memory_region(space->machine, "maincpu") + 0x10000 + hnoridur_bank * 0x8000; + UINT8 *RAM = memory_region(space->machine, "maincpu") + 0x10000 + state->hnoridur_bank * 0x8000; RAM[offset] = data; return; } default: - popmessage("palette_w with bank = %02x",hnoridur_bank); + popmessage("palette_w with bank = %02x", state->hnoridur_bank); break; } { - int x = (palette_ram[256*palbank + offset]<<8) + palette_ram[256*palbank + offset + 16*256]; + int x = (state->palette_ram[256 * state->palbank + offset] << 8) + state->palette_ram[256 * state->palbank + offset + 16 * 256]; /* The bits are in reverse order! */ - int r = BITSWAP8((x >> 0) & 0x1f, 7,6,5, 0,1,2,3,4 ); - int g = BITSWAP8((x >> 5) & 0x1f, 7,6,5, 0,1,2,3,4 ); - int b = BITSWAP8((x >> 10) & 0x1f, 7,6,5, 0,1,2,3,4 ); - palette_set_color_rgb(space->machine,256*palbank + offset,pal5bit(r),pal5bit(g),pal5bit(b)); + int r = BITSWAP8((x >> 0) & 0x1f, 7, 6, 5, 0, 1, 2, 3, 4); + int g = BITSWAP8((x >> 5) & 0x1f, 7, 6, 5, 0, 1, 2, 3, 4); + int b = BITSWAP8((x >> 10) & 0x1f, 7, 6, 5, 0, 1, 2, 3, 4); + palette_set_color_rgb(space->machine, 256 * state->palbank + offset, pal5bit(r), pal5bit(g), pal5bit(b)); } } static WRITE8_HANDLER( yarunara_palette_w ) { - int addr = 512*palbank + offset; - switch (hnoridur_bank) + dynax_state *state = (dynax_state *)space->machine->driver_data; + int addr = 512 * state->palbank + offset; + + switch (state->hnoridur_bank) { case 0x10: - palette_ram[addr] = data; + state->palette_ram[addr] = data; break; case 0x1c: // RTC { - running_device *rtc = devtag_get_device(space->machine, "rtc"); - msm6242_w(rtc, offset, data); + msm6242_w(state->rtc, offset, data); } return; default: - popmessage("palette_w with bank = %02x",hnoridur_bank); + popmessage("palette_w with bank = %02x", state->hnoridur_bank); return; } { - int br = palette_ram[addr & ~0x10]; // bbbrrrrr - int bg = palette_ram[addr | 0x10]; // bb0ggggg + int br = state->palette_ram[addr & ~0x10]; // bbbrrrrr + int bg = state->palette_ram[addr | 0x10]; // bb0ggggg int r = br & 0x1f; int g = bg & 0x1f; - int b = ((bg & 0xc0)>>3) | ((br & 0xe0)>>5); - palette_set_color_rgb(space->machine, 256*palbank + ((offset&0xf)|((offset&0x1e0)>>1)) ,pal5bit(r),pal5bit(g),pal5bit(b)); + int b = ((bg & 0xc0) >> 3) | ((br & 0xe0) >> 5); + palette_set_color_rgb(space->machine, 256 * state->palbank + ((offset & 0x0f) | ((offset & 0x1e0) >> 1)), pal5bit(r), pal5bit(g), pal5bit(b)); } } static WRITE8_HANDLER( nanajign_palette_w ) { - switch (hnoridur_bank) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->hnoridur_bank) { case 0x10: - palette_ram[256*palbank + offset + 16*256] = data; + state->palette_ram[256 * state->palbank + offset + 16 * 256] = data; break; case 0x14: - palette_ram[256*palbank + offset] = data; + state->palette_ram[256 * state->palbank + offset] = data; break; default: - popmessage("palette_w with bank = %02x",hnoridur_bank); + popmessage("palette_w with bank = %02x", state->hnoridur_bank); break; } { - int bg = palette_ram[256*palbank + offset]; - int br = palette_ram[256*palbank + offset + 16*256]; + int bg = state->palette_ram[256 * state->palbank + offset]; + int br = state->palette_ram[256 * state->palbank + offset + 16 * 256]; int r = br & 0x1f; int g = bg & 0x1f; - int b = ((bg & 0xc0)>>3) | ((br & 0xe0)>>5); - palette_set_color_rgb(space->machine,256*palbank + offset,pal5bit(r),pal5bit(g),pal5bit(b)); + int b = ((bg & 0xc0) >> 3) | ((br & 0xe0) >> 5); + palette_set_color_rgb(space->machine, 256 * state->palbank + offset, pal5bit(r), pal5bit(g), pal5bit(b)); } } -static int msm5205next; -static int resetkludge; -static void adpcm_int(running_device *device) +static void adpcm_int( running_device *device ) { - static int toggle; + dynax_state *state = (dynax_state *)device->machine->driver_data; + msm5205_data_w(device, state->msm5205next >> 4); + state->msm5205next <<= 4; - msm5205_data_w(device,msm5205next >> 4); - msm5205next<<=4; + state->toggle = 1 - state->toggle; - toggle = 1 - toggle; - if (toggle) + if (state->toggle) { - if (resetkludge) // don't know what's wrong, but NMIs when the 5205 is reset make the game crash - cputag_set_input_line(device->machine, "maincpu", INPUT_LINE_NMI, PULSE_LINE); + if (state->resetkludge) // don't know what's wrong, but NMIs when the 5205 is reset make the game crash + cpu_set_input_line(state->maincpu, INPUT_LINE_NMI, PULSE_LINE); } } -static void adpcm_int_cpu1(running_device *device) + +static void adpcm_int_cpu1( running_device *device ) { - static int toggle; + dynax_state *state = (dynax_state *)device->machine->driver_data; + msm5205_data_w(device, state->msm5205next >> 4); + state->msm5205next <<= 4; - msm5205_data_w(device,msm5205next >> 4); - msm5205next<<=4; - - toggle = 1 - toggle; - if (toggle) + state->toggle_cpu1 = 1 - state->toggle_cpu1; + if (state->toggle_cpu1) { - if (resetkludge) // don't know what's wrong, but NMIs when the 5205 is reset make the game crash - cputag_set_input_line(device->machine, "soundcpu", INPUT_LINE_NMI, PULSE_LINE); // cpu1 + if (state->resetkludge) // don't know what's wrong, but NMIs when the 5205 is reset make the game crash + cpu_set_input_line(state->soundcpu, INPUT_LINE_NMI, PULSE_LINE); // cpu1 } } static WRITE8_HANDLER( adpcm_data_w ) { - msm5205next = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->msm5205next = data; } static WRITE8_DEVICE_HANDLER( adpcm_reset_w ) { - resetkludge = data & 1; - msm5205_reset_w(device,~data & 1); + dynax_state *state = (dynax_state *)device->machine->driver_data; + state->resetkludge = data & 1; + msm5205_reset_w(device, ~data & 1); } static MACHINE_RESET( adpcm ) { + dynax_state *state = (dynax_state *)machine->driver_data; /* start with the MSM5205 reset */ - resetkludge = 0; - msm5205_reset_w(devtag_get_device(machine, "msm"),1); + state->resetkludge = 0; + msm5205_reset_w(devtag_get_device(machine, "msm"), 1); } static WRITE8_HANDLER( yarunara_layer_half_w ) { - hanamai_layer_half_w(space,0,data >> 1); + hanamai_layer_half_w(space, 0, data >> 1); } + static WRITE8_HANDLER( yarunara_layer_half2_w ) { - hnoridur_layer_half2_w(space,0,data >> 1); + hnoridur_layer_half2_w(space, 0, data >> 1); } static ADDRESS_MAP_START( sprtmtch_mem_map, ADDRESS_SPACE_PROGRAM, 8 ) @@ -478,7 +490,7 @@ static ADDRESS_MAP_START( nanajign_mem_map, ADDRESS_SPACE_PROGRAM, 8 ) AM_RANGE( 0x0000, 0x5fff ) AM_ROM AM_RANGE( 0x6000, 0x6fff ) AM_RAM AM_RANGE( 0x7000, 0x7fff ) AM_RAM AM_BASE_SIZE_GENERIC(nvram) - AM_RANGE( 0x8000, 0x80ff ) AM_WRITE(nanajign_palette_w ) + AM_RANGE( 0x8000, 0x80ff ) AM_WRITE(nanajign_palette_w) AM_RANGE( 0x8000, 0xffff ) AM_ROMBANK("bank1") ADDRESS_MAP_END @@ -494,7 +506,7 @@ static ADDRESS_MAP_START( yarunara_mem_map, ADDRESS_SPACE_PROGRAM, 8 ) AM_RANGE( 0x6000, 0x6fff ) AM_RAM AM_RANGE( 0x7000, 0x7fff ) AM_RAM AM_BASE_SIZE_GENERIC(nvram) AM_RANGE( 0x8000, 0xffff ) AM_ROMBANK("bank1") - AM_RANGE( 0x8000, 0x81ff ) AM_WRITE(yarunara_palette_w ) // Palette or RTC + AM_RANGE( 0x8000, 0x81ff ) AM_WRITE(yarunara_palette_w) // Palette or RTC ADDRESS_MAP_END static ADDRESS_MAP_START( jantouki_mem_map, ADDRESS_SPACE_PROGRAM, 8 ) @@ -514,78 +526,78 @@ ADDRESS_MAP_END static ADDRESS_MAP_START( hanamai_io_map, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) - AM_RANGE( 0x00, 0x00 ) AM_WRITE ( dynax_extra_scrollx_w ) // screen scroll X - AM_RANGE( 0x20, 0x20 ) AM_WRITE ( dynax_extra_scrolly_w ) // screen scroll Y - AM_RANGE( 0x41, 0x47 ) AM_WRITE ( dynax_blitter_rev2_w ) // Blitter - AM_RANGE( 0x50, 0x50 ) AM_WRITE ( dynax_rombank_w ) // BANK ROM Select hnkochou only - AM_RANGE( 0x60, 0x60 ) AM_READ ( hanamai_keyboard_0_r ) // P1 - AM_RANGE( 0x61, 0x61 ) AM_READ ( hanamai_keyboard_1_r ) // P2 - AM_RANGE( 0x62, 0x62 ) AM_READ_PORT ( "COINS" ) // Coins - AM_RANGE( 0x63, 0x63 ) AM_READ ( ret_ff ) // ? - AM_RANGE( 0x64, 0x64 ) AM_WRITE ( hanamai_keyboard_w ) // keyboard row select - AM_RANGE( 0x65, 0x65 ) AM_WRITE ( dynax_rombank_w ) // BANK ROM Select hanamai only - AM_RANGE( 0x66, 0x66 ) AM_WRITE ( dynax_vblank_ack_w ) // VBlank IRQ Ack - AM_RANGE( 0x67, 0x67 ) AM_WRITE ( adpcm_data_w ) // MSM5205 data - AM_RANGE( 0x68, 0x68 ) AM_WRITE ( dynax_layer_enable_w ) // Layers Enable - AM_RANGE( 0x69, 0x69 ) AM_WRITE ( hanamai_priority_w ) // layer priority - AM_RANGE( 0x6a, 0x6a ) AM_WRITE ( dynax_blit_dest_w ) // Destination Layer - AM_RANGE( 0x6b, 0x6b ) AM_WRITE ( dynax_blit_pen_w ) // Destination Pen - AM_RANGE( 0x6c, 0x6c ) AM_WRITE ( dynax_blit_palette01_w ) // Layers Palettes (Low Bits) - AM_RANGE( 0x6d, 0x6d ) AM_WRITE ( dynax_blit_palette23_w ) // - AM_RANGE( 0x6e, 0x6e ) AM_WRITE ( dynax_blit_backpen_w ) // Background Color - AM_RANGE( 0x70, 0x70 ) AM_DEVWRITE ( "msm", adpcm_reset_w) // MSM5205 reset - AM_RANGE( 0x71, 0x71 ) AM_WRITE ( dynax_flipscreen_w ) // Flip Screen - AM_RANGE( 0x72, 0x72 ) AM_WRITE ( dynax_coincounter_0_w ) // Coin Counters - AM_RANGE( 0x73, 0x73 ) AM_WRITE ( dynax_coincounter_1_w ) // - AM_RANGE( 0x74, 0x74 ) AM_WRITE ( dynax_blitter_ack_w ) // Blitter IRQ Ack - AM_RANGE( 0x76, 0x76 ) AM_WRITE ( dynax_blit_palbank_w ) // Layers Palettes (High Bit) - AM_RANGE( 0x77, 0x77 ) AM_WRITE ( hanamai_layer_half_w ) // half of the interleaved layer to write to - AM_RANGE( 0x78, 0x79 ) AM_DEVREADWRITE("ymsnd", ym2203_r, ym2203_w ) // 2 x DSW - AM_RANGE( 0x7a, 0x7b ) AM_DEVWRITE ( "aysnd", ay8910_address_data_w ) // AY8910 + AM_RANGE( 0x00, 0x00 ) AM_WRITE(dynax_extra_scrollx_w) // screen scroll X + AM_RANGE( 0x20, 0x20 ) AM_WRITE(dynax_extra_scrolly_w) // screen scroll Y + AM_RANGE( 0x41, 0x47 ) AM_WRITE(dynax_blitter_rev2_w) // Blitter + AM_RANGE( 0x50, 0x50 ) AM_WRITE(dynax_rombank_w) // BANK ROM Select hnkochou only + AM_RANGE( 0x60, 0x60 ) AM_READ(hanamai_keyboard_0_r) // P1 + AM_RANGE( 0x61, 0x61 ) AM_READ(hanamai_keyboard_1_r) // P2 + AM_RANGE( 0x62, 0x62 ) AM_READ_PORT("COINS") // Coins + AM_RANGE( 0x63, 0x63 ) AM_READ(ret_ff) // ? + AM_RANGE( 0x64, 0x64 ) AM_WRITE(hanamai_keyboard_w) // keyboard row select + AM_RANGE( 0x65, 0x65 ) AM_WRITE(dynax_rombank_w) // BANK ROM Select hanamai only + AM_RANGE( 0x66, 0x66 ) AM_WRITE(dynax_vblank_ack_w) // VBlank IRQ Ack + AM_RANGE( 0x67, 0x67 ) AM_WRITE(adpcm_data_w) // MSM5205 data + AM_RANGE( 0x68, 0x68 ) AM_WRITE(dynax_layer_enable_w) // Layers Enable + AM_RANGE( 0x69, 0x69 ) AM_WRITE(hanamai_priority_w) // layer priority + AM_RANGE( 0x6a, 0x6a ) AM_WRITE(dynax_blit_dest_w) // Destination Layer + AM_RANGE( 0x6b, 0x6b ) AM_WRITE(dynax_blit_pen_w) // Destination Pen + AM_RANGE( 0x6c, 0x6c ) AM_WRITE(dynax_blit_palette01_w) // Layers Palettes (Low Bits) + AM_RANGE( 0x6d, 0x6d ) AM_WRITE(dynax_blit_palette23_w) // + AM_RANGE( 0x6e, 0x6e ) AM_WRITE(dynax_blit_backpen_w) // Background Color + AM_RANGE( 0x70, 0x70 ) AM_DEVWRITE("msm", adpcm_reset_w) // MSM5205 reset + AM_RANGE( 0x71, 0x71 ) AM_WRITE(dynax_flipscreen_w) // Flip Screen + AM_RANGE( 0x72, 0x72 ) AM_WRITE(dynax_coincounter_0_w) // Coin Counters + AM_RANGE( 0x73, 0x73 ) AM_WRITE(dynax_coincounter_1_w) // + AM_RANGE( 0x74, 0x74 ) AM_WRITE(dynax_blitter_ack_w) // Blitter IRQ Ack + AM_RANGE( 0x76, 0x76 ) AM_WRITE(dynax_blit_palbank_w) // Layers Palettes (High Bit) + AM_RANGE( 0x77, 0x77 ) AM_WRITE(hanamai_layer_half_w) // half of the interleaved layer to write to + AM_RANGE( 0x78, 0x79 ) AM_DEVREADWRITE("ymsnd", ym2203_r, ym2203_w) // 2 x DSW + AM_RANGE( 0x7a, 0x7b ) AM_DEVWRITE("aysnd", ay8910_address_data_w) // AY8910 // AM_RANGE( 0x7c, 0x7c ) AM_WRITENOP // CRT Controller // AM_RANGE( 0x7d, 0x7d ) AM_WRITENOP // - AM_RANGE( 0x7e, 0x7e ) AM_WRITE ( dynax_blit_romregion_w ) // Blitter ROM bank + AM_RANGE( 0x7e, 0x7e ) AM_WRITE(dynax_blit_romregion_w) // Blitter ROM bank ADDRESS_MAP_END static ADDRESS_MAP_START( hnoridur_io_map, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) - AM_RANGE( 0x01, 0x07 ) AM_WRITE ( dynax_blitter_rev2_w ) // Blitter + AM_RANGE( 0x01, 0x07 ) AM_WRITE(dynax_blitter_rev2_w) // Blitter // AM_RANGE( 0x10, 0x10 ) AM_WRITENOP // CRT Controller // AM_RANGE( 0x11, 0x11 ) AM_WRITENOP // CRT Controller - AM_RANGE( 0x20, 0x20 ) AM_WRITE ( hanamai_keyboard_w ) // keyboard row select - AM_RANGE( 0x21, 0x21 ) AM_READ_PORT ( "COINS" ) // Coins - AM_RANGE( 0x22, 0x22 ) AM_READ ( hanamai_keyboard_1_r ) // P2 - AM_RANGE( 0x23, 0x23 ) AM_READ ( hanamai_keyboard_0_r ) // P1 - AM_RANGE( 0x24, 0x24 ) AM_READ_PORT ( "DSW1" ) // DSW2 - AM_RANGE( 0x25, 0x25 ) AM_READ_PORT ( "DSW3" ) // DSW4 - AM_RANGE( 0x26, 0x26 ) AM_READ_PORT ( "DSW2" ) // DSW3 - AM_RANGE( 0x30, 0x30 ) AM_DEVWRITE ( "msm", adpcm_reset_w ) // MSM5205 reset - AM_RANGE( 0x32, 0x32 ) AM_WRITE ( adpcm_data_w ) // MSM5205 data - AM_RANGE( 0x34, 0x35 ) AM_DEVWRITE( "ymsnd", ym2413_w ) // - AM_RANGE( 0x36, 0x36 ) AM_DEVREAD ( "aysnd", ay8910_r ) // AY8910, DSW1 - AM_RANGE( 0x38, 0x38 ) AM_DEVWRITE ( "aysnd", ay8910_data_w ) // AY8910 - AM_RANGE( 0x3a, 0x3a ) AM_DEVWRITE ( "aysnd", ay8910_address_w ) // - AM_RANGE( 0x40, 0x40 ) AM_WRITE ( dynax_blit_pen_w ) // Destination Pen - AM_RANGE( 0x41, 0x41 ) AM_WRITE ( dynax_blit_dest_w ) // Destination Layer - AM_RANGE( 0x42, 0x42 ) AM_WRITE ( dynax_blit_palette01_w ) // Layers Palettes - AM_RANGE( 0x43, 0x43 ) AM_WRITE ( dynax_blit_palette23_w ) // - AM_RANGE( 0x44, 0x44 ) AM_WRITE ( hanamai_priority_w ) // layer priority and enable - AM_RANGE( 0x45, 0x45 ) AM_WRITE ( dynax_blit_backpen_w ) // Background Color - AM_RANGE( 0x46, 0x46 ) AM_WRITE ( dynax_blit_romregion_w ) // Blitter ROM bank - AM_RANGE( 0x47, 0x47 ) AM_WRITE ( hnoridur_palbank_w ) - AM_RANGE( 0x50, 0x50 ) AM_WRITE ( dynax_extra_scrollx_w ) // screen scroll X - AM_RANGE( 0x51, 0x51 ) AM_WRITE ( dynax_extra_scrolly_w ) // screen scroll Y - AM_RANGE( 0x54, 0x54 ) AM_WRITE ( hnoridur_rombank_w ) // BANK ROM Select - AM_RANGE( 0x55, 0x55 ) AM_WRITENOP // ? VBlank IRQ Ack - AM_RANGE( 0x56, 0x56 ) AM_WRITE ( dynax_vblank_ack_w ) // VBlank IRQ Ack - AM_RANGE( 0x57, 0x57 ) AM_READ ( ret_ff ) // ? - AM_RANGE( 0x60, 0x60 ) AM_WRITE ( dynax_flipscreen_w ) // Flip Screen - AM_RANGE( 0x61, 0x61 ) AM_WRITE ( hanamai_layer_half_w ) // half of the interleaved layer to write to - AM_RANGE( 0x62, 0x62 ) AM_WRITE ( hnoridur_layer_half2_w ) // - AM_RANGE( 0x67, 0x67 ) AM_WRITE ( dynax_blitter_ack_w ) // Blitter IRQ Ack - AM_RANGE( 0x70, 0x70 ) AM_WRITE ( dynax_coincounter_0_w ) // Coin Counters - AM_RANGE( 0x71, 0x71 ) AM_WRITE ( dynax_coincounter_1_w ) // + AM_RANGE( 0x20, 0x20 ) AM_WRITE(hanamai_keyboard_w) // keyboard row select + AM_RANGE( 0x21, 0x21 ) AM_READ_PORT("COINS") // Coins + AM_RANGE( 0x22, 0x22 ) AM_READ(hanamai_keyboard_1_r) // P2 + AM_RANGE( 0x23, 0x23 ) AM_READ(hanamai_keyboard_0_r) // P1 + AM_RANGE( 0x24, 0x24 ) AM_READ_PORT("DSW1") // DSW2 + AM_RANGE( 0x25, 0x25 ) AM_READ_PORT("DSW3") // DSW4 + AM_RANGE( 0x26, 0x26 ) AM_READ_PORT("DSW2") // DSW3 + AM_RANGE( 0x30, 0x30 ) AM_DEVWRITE("msm", adpcm_reset_w) // MSM5205 reset + AM_RANGE( 0x32, 0x32 ) AM_WRITE(adpcm_data_w) // MSM5205 data + AM_RANGE( 0x34, 0x35 ) AM_DEVWRITE("ymsnd", ym2413_w) // + AM_RANGE( 0x36, 0x36 ) AM_DEVREAD("aysnd", ay8910_r) // AY8910, DSW1 + AM_RANGE( 0x38, 0x38 ) AM_DEVWRITE("aysnd", ay8910_data_w) // AY8910 + AM_RANGE( 0x3a, 0x3a ) AM_DEVWRITE("aysnd", ay8910_address_w) // + AM_RANGE( 0x40, 0x40 ) AM_WRITE(dynax_blit_pen_w) // Destination Pen + AM_RANGE( 0x41, 0x41 ) AM_WRITE(dynax_blit_dest_w) // Destination Layer + AM_RANGE( 0x42, 0x42 ) AM_WRITE(dynax_blit_palette01_w) // Layers Palettes + AM_RANGE( 0x43, 0x43 ) AM_WRITE(dynax_blit_palette23_w) // + AM_RANGE( 0x44, 0x44 ) AM_WRITE(hanamai_priority_w) // layer priority and enable + AM_RANGE( 0x45, 0x45 ) AM_WRITE(dynax_blit_backpen_w) // Background Color + AM_RANGE( 0x46, 0x46 ) AM_WRITE(dynax_blit_romregion_w) // Blitter ROM bank + AM_RANGE( 0x47, 0x47 ) AM_WRITE(hnoridur_palbank_w) + AM_RANGE( 0x50, 0x50 ) AM_WRITE(dynax_extra_scrollx_w) // screen scroll X + AM_RANGE( 0x51, 0x51 ) AM_WRITE(dynax_extra_scrolly_w) // screen scroll Y + AM_RANGE( 0x54, 0x54 ) AM_WRITE(hnoridur_rombank_w) // BANK ROM Select + AM_RANGE( 0x55, 0x55 ) AM_WRITENOP // ? VBlank IRQ Ack + AM_RANGE( 0x56, 0x56 ) AM_WRITE(dynax_vblank_ack_w) // VBlank IRQ Ack + AM_RANGE( 0x57, 0x57 ) AM_READ(ret_ff) // ? + AM_RANGE( 0x60, 0x60 ) AM_WRITE(dynax_flipscreen_w) // Flip Screen + AM_RANGE( 0x61, 0x61 ) AM_WRITE(hanamai_layer_half_w) // half of the interleaved layer to write to + AM_RANGE( 0x62, 0x62 ) AM_WRITE(hnoridur_layer_half2_w) // + AM_RANGE( 0x67, 0x67 ) AM_WRITE(dynax_blitter_ack_w) // Blitter IRQ Ack + AM_RANGE( 0x70, 0x70 ) AM_WRITE(dynax_coincounter_0_w) // Coin Counters + AM_RANGE( 0x71, 0x71 ) AM_WRITE(dynax_coincounter_1_w) // ADDRESS_MAP_END /*************************************************************************** @@ -594,7 +606,8 @@ ADDRESS_MAP_END static WRITE8_HANDLER( hjingi_bank_w ) { - hnoridur_bank = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->hnoridur_bank = data; } static WRITE8_HANDLER( hjingi_lockout_w ) @@ -602,24 +615,26 @@ static WRITE8_HANDLER( hjingi_lockout_w ) coin_lockout_w(space->machine, 0, (~data) & 0x01); } -static UINT8 hjingi_hopper; static WRITE8_HANDLER( hjingi_hopper_w ) { - hjingi_hopper = data & 0x01; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->hopper = data & 0x01; } -static UINT8 hjingi_hopper_bit(running_machine *machine) +static UINT8 hjingi_hopper_bit( running_machine *machine ) { - return (hjingi_hopper && !(video_screen_get_frame_number(machine->primary_screen)%10)) ? 0 : (1<<6); + dynax_state *state = (dynax_state *)machine->driver_data; + return (state->hopper && !(video_screen_get_frame_number(machine->primary_screen) % 10)) ? 0 : (1 << 6); } static READ8_HANDLER( hjingi_keyboard_0_r ) { - return hanamai_keyboard_0_r(space,0) | hjingi_hopper_bit(space->machine); + return hanamai_keyboard_0_r(space, 0) | hjingi_hopper_bit(space->machine); } + static READ8_HANDLER( hjingi_keyboard_1_r ) { - return hanamai_keyboard_1_r(space,0) | input_port_read(space->machine, "BET"); + return hanamai_keyboard_1_r(space, 0) | input_port_read(space->machine, "BET"); } static ADDRESS_MAP_START( hjingi_mem_map, ADDRESS_SPACE_PROGRAM, 8 ) @@ -630,55 +645,55 @@ static ADDRESS_MAP_START( hjingi_mem_map, ADDRESS_SPACE_PROGRAM, 8 ) ADDRESS_MAP_END static ADDRESS_MAP_START( hjingi_io_map, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) - AM_RANGE( 0x01, 0x07 ) AM_WRITE ( dynax_blitter_rev2_w ) // Blitter + AM_RANGE( 0x01, 0x07 ) AM_WRITE(dynax_blitter_rev2_w) // Blitter // AM_RANGE( 0x10, 0x10 ) AM_WRITENOP // CRT Controller // AM_RANGE( 0x11, 0x11 ) AM_WRITENOP // CRT Controller - AM_RANGE( 0x20, 0x20 ) AM_WRITE ( hanamai_keyboard_w ) // keyboard row select - AM_RANGE( 0x21, 0x21 ) AM_READ_PORT ( "COINS" ) // Coins - AM_RANGE( 0x22, 0x22 ) AM_READ ( hjingi_keyboard_1_r ) // P2 + Hopper - AM_RANGE( 0x23, 0x23 ) AM_READ ( hjingi_keyboard_0_r ) // P1 + Hopper - AM_RANGE( 0x24, 0x24 ) AM_READ_PORT ( "DSW1" ) // DSW1 - AM_RANGE( 0x25, 0x25 ) AM_READ_PORT ( "DSW3" ) // DSW3 - AM_RANGE( 0x26, 0x26 ) AM_READ_PORT ( "DSW2" ) // DSW2 + AM_RANGE( 0x20, 0x20 ) AM_WRITE(hanamai_keyboard_w) // keyboard row select + AM_RANGE( 0x21, 0x21 ) AM_READ_PORT("COINS") // Coins + AM_RANGE( 0x22, 0x22 ) AM_READ(hjingi_keyboard_1_r) // P2 + Hopper + AM_RANGE( 0x23, 0x23 ) AM_READ(hjingi_keyboard_0_r) // P1 + Hopper + AM_RANGE( 0x24, 0x24 ) AM_READ_PORT("DSW1") // DSW1 + AM_RANGE( 0x25, 0x25 ) AM_READ_PORT("DSW3") // DSW3 + AM_RANGE( 0x26, 0x26 ) AM_READ_PORT("DSW2") // DSW2 - AM_RANGE( 0x30, 0x30 ) AM_DEVWRITE ( "msm", adpcm_reset_w ) // MSM5205 reset - AM_RANGE( 0x32, 0x32 ) AM_WRITE ( adpcm_data_w ) // MSM5205 data - AM_RANGE( 0x34, 0x35 ) AM_DEVWRITE( "ymsnd", ym2413_w ) // + AM_RANGE( 0x30, 0x30 ) AM_DEVWRITE("msm", adpcm_reset_w) // MSM5205 reset + AM_RANGE( 0x32, 0x32 ) AM_WRITE(adpcm_data_w) // MSM5205 data + AM_RANGE( 0x34, 0x35 ) AM_DEVWRITE("ymsnd", ym2413_w) // - AM_RANGE( 0x36, 0x36 ) AM_DEVREAD ( "aysnd", ay8910_r ) // AY8910, DSW1 - AM_RANGE( 0x38, 0x38 ) AM_DEVWRITE ( "aysnd", ay8910_data_w ) // AY8910 - AM_RANGE( 0x3a, 0x3a ) AM_DEVWRITE ( "aysnd", ay8910_address_w) // + AM_RANGE( 0x36, 0x36 ) AM_DEVREAD("aysnd", ay8910_r) // AY8910, DSW1 + AM_RANGE( 0x38, 0x38 ) AM_DEVWRITE("aysnd", ay8910_data_w) // AY8910 + AM_RANGE( 0x3a, 0x3a ) AM_DEVWRITE("aysnd", ay8910_address_w) // - AM_RANGE( 0x40, 0x40 ) AM_WRITE ( dynax_blit_pen_w ) // Destination Pen - AM_RANGE( 0x41, 0x41 ) AM_WRITE ( dynax_blit_dest_w ) // Destination Layer - AM_RANGE( 0x42, 0x42 ) AM_WRITE ( dynax_blit_palette01_w ) // Layers Palettes - AM_RANGE( 0x43, 0x43 ) AM_WRITE ( dynax_blit_palette23_w ) // - AM_RANGE( 0x44, 0x44 ) AM_WRITE ( hanamai_priority_w ) // layer priority and enable - AM_RANGE( 0x45, 0x45 ) AM_WRITE ( dynax_blit_backpen_w ) // Background Color - AM_RANGE( 0x46, 0x46 ) AM_WRITE ( dynax_blit_romregion_w ) // Blitter ROM bank - AM_RANGE( 0x47, 0x47 ) AM_WRITE ( hnoridur_palbank_w ) + AM_RANGE( 0x40, 0x40 ) AM_WRITE(dynax_blit_pen_w) // Destination Pen + AM_RANGE( 0x41, 0x41 ) AM_WRITE(dynax_blit_dest_w) // Destination Layer + AM_RANGE( 0x42, 0x42 ) AM_WRITE(dynax_blit_palette01_w) // Layers Palettes + AM_RANGE( 0x43, 0x43 ) AM_WRITE(dynax_blit_palette23_w) // + AM_RANGE( 0x44, 0x44 ) AM_WRITE(hanamai_priority_w) // layer priority and enable + AM_RANGE( 0x45, 0x45 ) AM_WRITE(dynax_blit_backpen_w) // Background Color + AM_RANGE( 0x46, 0x46 ) AM_WRITE(dynax_blit_romregion_w) // Blitter ROM bank + AM_RANGE( 0x47, 0x47 ) AM_WRITE(hnoridur_palbank_w) - AM_RANGE( 0x50, 0x50 ) AM_WRITE ( dynax_extra_scrollx_w ) // screen scroll X - AM_RANGE( 0x51, 0x51 ) AM_WRITE ( dynax_extra_scrolly_w ) // screen scroll Y + AM_RANGE( 0x50, 0x50 ) AM_WRITE(dynax_extra_scrollx_w) // screen scroll X + AM_RANGE( 0x51, 0x51 ) AM_WRITE(dynax_extra_scrolly_w) // screen scroll Y - AM_RANGE( 0x54, 0x54 ) AM_WRITE ( hjingi_bank_w ) // + AM_RANGE( 0x54, 0x54 ) AM_WRITE(hjingi_bank_w) // - AM_RANGE( 0x56, 0x56 ) AM_WRITE ( dynax_vblank_ack_w ) // VBlank IRQ Ack - AM_RANGE( 0x57, 0x57 ) AM_READ ( ret_ff ) // Blitter Busy - AM_RANGE( 0x67, 0x67 ) AM_WRITE ( dynax_blitter_ack_w ) // Blitter IRQ Ack + AM_RANGE( 0x56, 0x56 ) AM_WRITE(dynax_vblank_ack_w) // VBlank IRQ Ack + AM_RANGE( 0x57, 0x57 ) AM_READ(ret_ff) // Blitter Busy + AM_RANGE( 0x67, 0x67 ) AM_WRITE(dynax_blitter_ack_w) // Blitter IRQ Ack - AM_RANGE( 0x60, 0x60 ) AM_WRITE ( dynax_flipscreen_w ) // Flip Screen - AM_RANGE( 0x61, 0x61 ) AM_WRITE ( hanamai_layer_half_w ) // half of the interleaved layer to write to - AM_RANGE( 0x62, 0x62 ) AM_WRITE ( hnoridur_layer_half2_w ) // + AM_RANGE( 0x60, 0x60 ) AM_WRITE(dynax_flipscreen_w) // Flip Screen + AM_RANGE( 0x61, 0x61 ) AM_WRITE(hanamai_layer_half_w) // half of the interleaved layer to write to + AM_RANGE( 0x62, 0x62 ) AM_WRITE(hnoridur_layer_half2_w) // - AM_RANGE( 0x70, 0x70 ) AM_WRITE ( dynax_coincounter_0_w ) // Coin Counters - AM_RANGE( 0x71, 0x71 ) AM_WRITE ( dynax_coincounter_1_w ) // - AM_RANGE( 0x72, 0x72 ) AM_WRITE ( hjingi_hopper_w ) // Hopper - AM_RANGE( 0x73, 0x73 ) AM_WRITE ( hjingi_lockout_w ) // Coin Lockout + AM_RANGE( 0x70, 0x70 ) AM_WRITE(dynax_coincounter_0_w) // Coin Counters + AM_RANGE( 0x71, 0x71 ) AM_WRITE(dynax_coincounter_1_w) // + AM_RANGE( 0x72, 0x72 ) AM_WRITE(hjingi_hopper_w) // Hopper + AM_RANGE( 0x73, 0x73 ) AM_WRITE(hjingi_lockout_w) // Coin Lockout - AM_RANGE( 0x80, 0x80 ) AM_WRITE ( hnoridur_rombank_w ) // BANK ROM Select + AM_RANGE( 0x80, 0x80 ) AM_WRITE(hnoridur_rombank_w) // BANK ROM Select ADDRESS_MAP_END @@ -686,13 +701,14 @@ ADDRESS_MAP_END Yarunara / Quiz TV Q&Q / Mahjong Angels ***************************************************************************/ -static UINT8 yarunara_select, yarunara_ip; static WRITE8_HANDLER( yarunara_input_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; + switch (offset) { - case 0: yarunara_select = data; - yarunara_ip = 0; + case 0: state->input_sel = data; + state->keyb = 0; break; case 1: break; @@ -702,6 +718,7 @@ static WRITE8_HANDLER( yarunara_input_w ) static READ8_HANDLER( yarunara_input_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; static const char *const keynames0[] = { "KEY0", "KEY1", "KEY2", "KEY3", "KEY4" }; static const char *const keynames1[] = { "KEY5", "KEY6", "KEY7", "KEY8", "KEY9" }; @@ -709,35 +726,35 @@ static READ8_HANDLER( yarunara_input_r ) { case 0: { - switch( yarunara_select ) + switch (state->input_sel) { - case 0x00: - return input_port_read(space->machine, "COINS"); // coins + case 0x00: + return input_port_read(space->machine, "COINS"); // coins - case 0x02: - return 0xff; // bit 7 must be 1. Bit 2? + case 0x02: + return 0xff; // bit 7 must be 1. Bit 2? - default: - return 0xff; + default: + return 0xff; } } case 1: { - switch( yarunara_select ) + switch (state->input_sel) { - // player 2 - case 0x01: //quiztvqq - case 0x81: - return input_port_read(space->machine, keynames1[yarunara_ip++]); + // player 2 + case 0x01: //quiztvqq + case 0x81: + return input_port_read(space->machine, keynames1[state->keyb++]); - // player 1 - case 0x02: //quiztvqq - case 0x82: - return input_port_read(space->machine, keynames0[yarunara_ip++]); + // player 1 + case 0x02: //quiztvqq + case 0x82: + return input_port_read(space->machine, keynames0[state->keyb++]); - default: - return 0xff; + default: + return 0xff; } } } @@ -746,217 +763,215 @@ static READ8_HANDLER( yarunara_input_r ) static WRITE8_HANDLER( yarunara_rombank_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; UINT8 *rom = memory_region(space->machine, "maincpu") + 0x10000 + 0x8000 * data; memory_set_bankptr(space->machine, "bank1", rom); - hnoridur_bank = data; + state->hnoridur_bank = data; } static WRITE8_HANDLER( yarunara_flipscreen_w ) { - dynax_flipscreen_w(space,0,(data&2)?1:0); + dynax_flipscreen_w(space, 0, BIT(data, 1)); } + static WRITE8_HANDLER( yarunara_flipscreen_inv_w ) { - dynax_flipscreen_w(space,0,(data&2)?0:1); + dynax_flipscreen_w(space, 0, !BIT(data, 1)); } static WRITE8_HANDLER( yarunara_blit_romregion_w ) { switch(data) { - case 0x00: dynax_blit_romregion_w(space,0,0); return; - case 0x01: dynax_blit_romregion_w(space,0,1); return; - case 0x80: dynax_blit_romregion_w(space,0,2); return; - case 0x81: dynax_blit_romregion_w(space,0,3); return; - case 0x82: dynax_blit_romregion_w(space,0,4); return; // mjcomv1 + case 0x00: dynax_blit_romregion_w(space, 0, 0); return; + case 0x01: dynax_blit_romregion_w(space, 0, 1); return; + case 0x80: dynax_blit_romregion_w(space, 0, 2); return; + case 0x81: dynax_blit_romregion_w(space, 0, 3); return; + case 0x82: dynax_blit_romregion_w(space, 0, 4); return; // mjcomv1 } - logerror("%04x: unmapped romregion=%02X\n",cpu_get_pc(space->cpu),data); + logerror("%04x: unmapped romregion=%02X\n", cpu_get_pc(space->cpu), data); } static ADDRESS_MAP_START( yarunara_io_map, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) - AM_RANGE( 0x00, 0x01 ) AM_WRITE ( yarunara_input_w ) // Controls - AM_RANGE( 0x02, 0x03 ) AM_READ ( yarunara_input_r ) // - AM_RANGE( 0x11, 0x17 ) AM_WRITE ( dynax_blitter_rev2_w ) // Blitter - AM_RANGE( 0x20, 0x20 ) AM_DEVWRITE ( "msm", adpcm_reset_w ) // MSM5205 reset - AM_RANGE( 0x22, 0x22 ) AM_WRITE ( adpcm_data_w ) // MSM5205 data - AM_RANGE( 0x24, 0x25 ) AM_DEVWRITE( "ymsnd", ym2413_w ) // - AM_RANGE( 0x28, 0x28 ) AM_DEVWRITE ( "aysnd", ay8910_data_w ) // AY8910 - AM_RANGE( 0x2a, 0x2a ) AM_DEVWRITE ( "aysnd", ay8910_address_w ) // - AM_RANGE( 0x48, 0x48 ) AM_WRITE ( dynax_extra_scrollx_w ) // screen scroll X - AM_RANGE( 0x49, 0x49 ) AM_WRITE ( dynax_extra_scrolly_w ) // screen scroll Y - AM_RANGE( 0x4a, 0x4a ) AM_WRITE ( yarunara_rombank_w ) // BANK ROM Select - AM_RANGE( 0x4b, 0x4b ) AM_WRITE ( dynax_vblank_ack_w ) // VBlank IRQ Ack - AM_RANGE( 0x4c, 0x4c ) AM_READ_PORT ( "DSW0" ) // DSW 1 - AM_RANGE( 0x4f, 0x4f ) AM_READ_PORT ( "DSW1" ) // DSW 2 - AM_RANGE( 0x50, 0x50 ) AM_WRITE ( yarunara_flipscreen_w ) - AM_RANGE( 0x51, 0x51 ) AM_WRITE ( yarunara_layer_half_w ) // half of the interleaved layer to write to - AM_RANGE( 0x52, 0x52 ) AM_WRITE ( yarunara_layer_half2_w ) // + AM_RANGE( 0x00, 0x01 ) AM_WRITE(yarunara_input_w) // Controls + AM_RANGE( 0x02, 0x03 ) AM_READ(yarunara_input_r) // + AM_RANGE( 0x11, 0x17 ) AM_WRITE(dynax_blitter_rev2_w) // Blitter + AM_RANGE( 0x20, 0x20 ) AM_DEVWRITE("msm", adpcm_reset_w) // MSM5205 reset + AM_RANGE( 0x22, 0x22 ) AM_WRITE(adpcm_data_w) // MSM5205 data + AM_RANGE( 0x24, 0x25 ) AM_DEVWRITE("ymsnd", ym2413_w) // + AM_RANGE( 0x28, 0x28 ) AM_DEVWRITE("aysnd", ay8910_data_w) // AY8910 + AM_RANGE( 0x2a, 0x2a ) AM_DEVWRITE("aysnd", ay8910_address_w) // + AM_RANGE( 0x48, 0x48 ) AM_WRITE(dynax_extra_scrollx_w) // screen scroll X + AM_RANGE( 0x49, 0x49 ) AM_WRITE(dynax_extra_scrolly_w) // screen scroll Y + AM_RANGE( 0x4a, 0x4a ) AM_WRITE(yarunara_rombank_w) // BANK ROM Select + AM_RANGE( 0x4b, 0x4b ) AM_WRITE(dynax_vblank_ack_w) // VBlank IRQ Ack + AM_RANGE( 0x4c, 0x4c ) AM_READ_PORT("DSW0") // DSW 1 + AM_RANGE( 0x4f, 0x4f ) AM_READ_PORT("DSW1") // DSW 2 + AM_RANGE( 0x50, 0x50 ) AM_WRITE(yarunara_flipscreen_w) + AM_RANGE( 0x51, 0x51 ) AM_WRITE(yarunara_layer_half_w) // half of the interleaved layer to write to + AM_RANGE( 0x52, 0x52 ) AM_WRITE(yarunara_layer_half2_w) // // 53 ? // 54 ? - AM_RANGE( 0x57, 0x57 ) AM_WRITE ( dynax_blitter_ack_w ) // Blitter IRQ Ack - AM_RANGE( 0x68, 0x68 ) AM_WRITE ( dynax_blit_pen_w ) // Destination Pen - AM_RANGE( 0x69, 0x69 ) AM_WRITE ( dynax_blit_dest_w ) // Destination Layer - AM_RANGE( 0x6a, 0x6a ) AM_WRITE ( dynax_blit_palette01_w ) // Layers Palettes - AM_RANGE( 0x6b, 0x6b ) AM_WRITE ( dynax_blit_palette23_w ) // - AM_RANGE( 0x6c, 0x6c ) AM_WRITE ( hanamai_priority_w ) // layer priority and enable - AM_RANGE( 0x6d, 0x6d ) AM_WRITE ( dynax_blit_backpen_w ) // Background Color - AM_RANGE( 0x6e, 0x6e ) AM_WRITE ( yarunara_blit_romregion_w ) // Blitter ROM bank + AM_RANGE( 0x57, 0x57 ) AM_WRITE(dynax_blitter_ack_w) // Blitter IRQ Ack + AM_RANGE( 0x68, 0x68 ) AM_WRITE(dynax_blit_pen_w) // Destination Pen + AM_RANGE( 0x69, 0x69 ) AM_WRITE(dynax_blit_dest_w) // Destination Layer + AM_RANGE( 0x6a, 0x6a ) AM_WRITE(dynax_blit_palette01_w) // Layers Palettes + AM_RANGE( 0x6b, 0x6b ) AM_WRITE(dynax_blit_palette23_w) // + AM_RANGE( 0x6c, 0x6c ) AM_WRITE(hanamai_priority_w) // layer priority and enable + AM_RANGE( 0x6d, 0x6d ) AM_WRITE(dynax_blit_backpen_w) // Background Color + AM_RANGE( 0x6e, 0x6e ) AM_WRITE(yarunara_blit_romregion_w) // Blitter ROM bank ADDRESS_MAP_END // Almost identical to hnoridur static ADDRESS_MAP_START( mcnpshnt_io_map, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) - AM_RANGE( 0x01, 0x07 ) AM_WRITE ( dynax_blitter_rev2_w ) // Blitter + AM_RANGE( 0x01, 0x07 ) AM_WRITE(dynax_blitter_rev2_w) // Blitter // AM_RANGE( 0x10, 0x10 ) AM_WRITENOP // CRT Controller // AM_RANGE( 0x11, 0x11 ) AM_WRITENOP // CRT Controller - AM_RANGE( 0x20, 0x20 ) AM_WRITE ( hanamai_keyboard_w ) // keyboard row select - AM_RANGE( 0x21, 0x21 ) AM_READ_PORT ( "COINS" ) // Coins - AM_RANGE( 0x22, 0x22 ) AM_READ ( hanamai_keyboard_1_r ) // P2 - AM_RANGE( 0x23, 0x23 ) AM_READ ( hanamai_keyboard_0_r ) // P1 - AM_RANGE( 0x24, 0x24 ) AM_READ_PORT ( "DSW0" ) // DSW2 - AM_RANGE( 0x26, 0x26 ) AM_READ_PORT ( "DSW1" ) // DSW3 - AM_RANGE( 0x30, 0x30 ) AM_DEVWRITE ( "msm", adpcm_reset_w ) // MSM5205 reset - AM_RANGE( 0x32, 0x32 ) AM_WRITE ( adpcm_data_w ) // MSM5205 data - AM_RANGE( 0x34, 0x35 ) AM_DEVWRITE( "ymsnd", ym2413_w ) // - AM_RANGE( 0x38, 0x38 ) AM_DEVWRITE ( "aysnd", ay8910_data_w ) // AY8910 - AM_RANGE( 0x3a, 0x3a ) AM_DEVWRITE ( "aysnd", ay8910_address_w ) // - AM_RANGE( 0x40, 0x40 ) AM_WRITE ( dynax_blit_pen_w ) // Destination Pen - AM_RANGE( 0x41, 0x41 ) AM_WRITE ( dynax_blit_dest_w ) // Destination Layer - AM_RANGE( 0x42, 0x42 ) AM_WRITE ( dynax_blit_palette01_w ) // Layers Palettes - AM_RANGE( 0x43, 0x43 ) AM_WRITE ( dynax_blit_palette23_w ) // - AM_RANGE( 0x44, 0x44 ) AM_WRITE ( hanamai_priority_w ) // layer priority and enable - AM_RANGE( 0x45, 0x45 ) AM_WRITE ( dynax_blit_backpen_w ) // Background Color - AM_RANGE( 0x46, 0x46 ) AM_WRITE ( yarunara_blit_romregion_w ) // Blitter ROM bank - AM_RANGE( 0x47, 0x47 ) AM_WRITE ( hnoridur_palbank_w ) - AM_RANGE( 0x50, 0x50 ) AM_WRITE ( dynax_extra_scrollx_w ) // screen scroll X - AM_RANGE( 0x51, 0x51 ) AM_WRITE ( dynax_extra_scrolly_w ) // screen scroll Y - AM_RANGE( 0x54, 0x54 ) AM_WRITE ( hnoridur_rombank_w ) // BANK ROM Select - AM_RANGE( 0x56, 0x56 ) AM_WRITE ( dynax_vblank_ack_w ) // VBlank IRQ Ack - AM_RANGE( 0x57, 0x57 ) AM_READ ( ret_ff ) // ? - AM_RANGE( 0x60, 0x60 ) AM_WRITE ( dynax_flipscreen_w ) // Flip Screen - AM_RANGE( 0x61, 0x61 ) AM_WRITE ( hanamai_layer_half_w ) // half of the interleaved layer to write to - AM_RANGE( 0x62, 0x62 ) AM_WRITE ( hnoridur_layer_half2_w ) // - AM_RANGE( 0x67, 0x67 ) AM_WRITE ( dynax_blitter_ack_w ) // Blitter IRQ Ack - AM_RANGE( 0x70, 0x70 ) AM_WRITE ( dynax_coincounter_0_w ) // Coin Counters - AM_RANGE( 0x71, 0x71 ) AM_WRITE ( dynax_coincounter_1_w ) // + AM_RANGE( 0x20, 0x20 ) AM_WRITE(hanamai_keyboard_w) // keyboard row select + AM_RANGE( 0x21, 0x21 ) AM_READ_PORT("COINS") // Coins + AM_RANGE( 0x22, 0x22 ) AM_READ(hanamai_keyboard_1_r) // P2 + AM_RANGE( 0x23, 0x23 ) AM_READ(hanamai_keyboard_0_r) // P1 + AM_RANGE( 0x24, 0x24 ) AM_READ_PORT("DSW0") // DSW2 + AM_RANGE( 0x26, 0x26 ) AM_READ_PORT("DSW1") // DSW3 + AM_RANGE( 0x30, 0x30 ) AM_DEVWRITE("msm", adpcm_reset_w) // MSM5205 reset + AM_RANGE( 0x32, 0x32 ) AM_WRITE(adpcm_data_w) // MSM5205 data + AM_RANGE( 0x34, 0x35 ) AM_DEVWRITE("ymsnd", ym2413_w) // + AM_RANGE( 0x38, 0x38 ) AM_DEVWRITE("aysnd", ay8910_data_w) // AY8910 + AM_RANGE( 0x3a, 0x3a ) AM_DEVWRITE("aysnd", ay8910_address_w) // + AM_RANGE( 0x40, 0x40 ) AM_WRITE(dynax_blit_pen_w) // Destination Pen + AM_RANGE( 0x41, 0x41 ) AM_WRITE(dynax_blit_dest_w) // Destination Layer + AM_RANGE( 0x42, 0x42 ) AM_WRITE(dynax_blit_palette01_w) // Layers Palettes + AM_RANGE( 0x43, 0x43 ) AM_WRITE(dynax_blit_palette23_w) // + AM_RANGE( 0x44, 0x44 ) AM_WRITE(hanamai_priority_w) // layer priority and enable + AM_RANGE( 0x45, 0x45 ) AM_WRITE(dynax_blit_backpen_w) // Background Color + AM_RANGE( 0x46, 0x46 ) AM_WRITE(yarunara_blit_romregion_w) // Blitter ROM bank + AM_RANGE( 0x47, 0x47 ) AM_WRITE(hnoridur_palbank_w) + AM_RANGE( 0x50, 0x50 ) AM_WRITE(dynax_extra_scrollx_w) // screen scroll X + AM_RANGE( 0x51, 0x51 ) AM_WRITE(dynax_extra_scrolly_w) // screen scroll Y + AM_RANGE( 0x54, 0x54 ) AM_WRITE(hnoridur_rombank_w) // BANK ROM Select + AM_RANGE( 0x56, 0x56 ) AM_WRITE(dynax_vblank_ack_w) // VBlank IRQ Ack + AM_RANGE( 0x57, 0x57 ) AM_READ(ret_ff) // ? + AM_RANGE( 0x60, 0x60 ) AM_WRITE(dynax_flipscreen_w) // Flip Screen + AM_RANGE( 0x61, 0x61 ) AM_WRITE(hanamai_layer_half_w) // half of the interleaved layer to write to + AM_RANGE( 0x62, 0x62 ) AM_WRITE(hnoridur_layer_half2_w) // + AM_RANGE( 0x67, 0x67 ) AM_WRITE(dynax_blitter_ack_w) // Blitter IRQ Ack + AM_RANGE( 0x70, 0x70 ) AM_WRITE(dynax_coincounter_0_w) // Coin Counters + AM_RANGE( 0x71, 0x71 ) AM_WRITE(dynax_coincounter_1_w) // ADDRESS_MAP_END static ADDRESS_MAP_START( sprtmtch_io_map, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) - AM_RANGE( 0x01, 0x07 ) AM_WRITE ( dynax_blitter_rev2_w ) // Blitter - AM_RANGE( 0x10, 0x11 ) AM_DEVREADWRITE("ymsnd", ym2203_r, ym2203_w ) // 2 x DSW + AM_RANGE( 0x01, 0x07 ) AM_WRITE(dynax_blitter_rev2_w) // Blitter + AM_RANGE( 0x10, 0x11 ) AM_DEVREADWRITE("ymsnd", ym2203_r, ym2203_w) // 2 x DSW // AM_RANGE( 0x12, 0x12 ) AM_WRITENOP // CRT Controller // AM_RANGE( 0x13, 0x13 ) AM_WRITENOP // CRT Controller - AM_RANGE( 0x20, 0x20 ) AM_READ_PORT ( "P1" ) // P1 - AM_RANGE( 0x21, 0x21 ) AM_READ_PORT ( "P2" ) // P2 - AM_RANGE( 0x22, 0x22 ) AM_READ_PORT ( "COINS" ) // Coins - AM_RANGE( 0x23, 0x23 ) AM_READ ( ret_ff ) // ? - AM_RANGE( 0x30, 0x30 ) AM_WRITE ( dynax_layer_enable_w ) // Layers Enable - AM_RANGE( 0x31, 0x31 ) AM_WRITE ( dynax_rombank_w ) // BANK ROM Select - AM_RANGE( 0x32, 0x32 ) AM_WRITE ( dynax_blit_dest_w ) // Destination Layer - AM_RANGE( 0x33, 0x33 ) AM_WRITE ( dynax_blit_pen_w ) // Destination Pen - AM_RANGE( 0x34, 0x34 ) AM_WRITE ( dynax_blit_palette01_w ) // Layers Palettes (Low Bits) - AM_RANGE( 0x35, 0x35 ) AM_WRITE ( dynax_blit_palette23_w ) // - AM_RANGE( 0x36, 0x36 ) AM_WRITE ( dynax_blit_backpen_w ) // Background Color - AM_RANGE( 0x37, 0x37 ) AM_WRITE ( dynax_vblank_ack_w ) // VBlank IRQ Ack -// AM_RANGE( 0x40, 0x40 ) AM_DEVWRITE ( "msm", adpcm_reset_w ) // MSM5205 reset - AM_RANGE( 0x41, 0x41 ) AM_WRITE ( dynax_flipscreen_w ) // Flip Screen - AM_RANGE( 0x42, 0x42 ) AM_WRITE ( dynax_coincounter_0_w ) // Coin Counters - AM_RANGE( 0x43, 0x43 ) AM_WRITE ( dynax_coincounter_1_w ) // - AM_RANGE( 0x44, 0x44 ) AM_WRITE ( dynax_blitter_ack_w ) // Blitter IRQ Ack - AM_RANGE( 0x45, 0x45 ) AM_WRITE ( dynax_blit_palbank_w ) // Layers Palettes (High Bit) + AM_RANGE( 0x20, 0x20 ) AM_READ_PORT("P1") // P1 + AM_RANGE( 0x21, 0x21 ) AM_READ_PORT("P2") // P2 + AM_RANGE( 0x22, 0x22 ) AM_READ_PORT("COINS") // Coins + AM_RANGE( 0x23, 0x23 ) AM_READ(ret_ff) // ? + AM_RANGE( 0x30, 0x30 ) AM_WRITE(dynax_layer_enable_w) // Layers Enable + AM_RANGE( 0x31, 0x31 ) AM_WRITE(dynax_rombank_w) // BANK ROM Select + AM_RANGE( 0x32, 0x32 ) AM_WRITE(dynax_blit_dest_w) // Destination Layer + AM_RANGE( 0x33, 0x33 ) AM_WRITE(dynax_blit_pen_w) // Destination Pen + AM_RANGE( 0x34, 0x34 ) AM_WRITE(dynax_blit_palette01_w) // Layers Palettes (Low Bits) + AM_RANGE( 0x35, 0x35 ) AM_WRITE(dynax_blit_palette23_w) // + AM_RANGE( 0x36, 0x36 ) AM_WRITE(dynax_blit_backpen_w) // Background Color + AM_RANGE( 0x37, 0x37 ) AM_WRITE(dynax_vblank_ack_w) // VBlank IRQ Ack +// AM_RANGE( 0x40, 0x40 ) AM_DEVWRITE("msm", adpcm_reset_w) // MSM5205 reset + AM_RANGE( 0x41, 0x41 ) AM_WRITE(dynax_flipscreen_w) // Flip Screen + AM_RANGE( 0x42, 0x42 ) AM_WRITE(dynax_coincounter_0_w) // Coin Counters + AM_RANGE( 0x43, 0x43 ) AM_WRITE(dynax_coincounter_1_w) // + AM_RANGE( 0x44, 0x44 ) AM_WRITE(dynax_blitter_ack_w) // Blitter IRQ Ack + AM_RANGE( 0x45, 0x45 ) AM_WRITE(dynax_blit_palbank_w) // Layers Palettes (High Bit) ADDRESS_MAP_END static ADDRESS_MAP_START( mjfriday_io_map, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) - AM_RANGE( 0x00, 0x00 ) AM_WRITE ( dynax_blit_pen_w ) // Destination Pen - AM_RANGE( 0x01, 0x01 ) AM_WRITE ( dynax_blit_palette01_w ) // Layers Palettes (Low Bits) - AM_RANGE( 0x02, 0x02 ) AM_WRITE ( dynax_rombank_w ) // BANK ROM Select - AM_RANGE( 0x03, 0x03 ) AM_WRITE ( dynax_blit_backpen_w ) // Background Color - AM_RANGE( 0x10, 0x11 ) AM_WRITE ( mjdialq2_blit_dest_w ) // Destination Layer - AM_RANGE( 0x12, 0x12 ) AM_WRITE ( dynax_blit_palbank_w ) // Layers Palettes (High Bit) - AM_RANGE( 0x13, 0x13 ) AM_WRITE ( dynax_flipscreen_w ) // Flip Screen - AM_RANGE( 0x14, 0x14 ) AM_WRITE ( dynax_coincounter_0_w ) // Coin Counters - AM_RANGE( 0x15, 0x15 ) AM_WRITE ( dynax_coincounter_1_w ) // - AM_RANGE( 0x16, 0x17 ) AM_WRITE ( mjdialq2_layer_enable_w ) // Layers Enable - AM_RANGE( 0x41, 0x47 ) AM_WRITE ( dynax_blitter_rev2_w ) // Blitter + AM_RANGE( 0x00, 0x00 ) AM_WRITE(dynax_blit_pen_w) // Destination Pen + AM_RANGE( 0x01, 0x01 ) AM_WRITE(dynax_blit_palette01_w) // Layers Palettes (Low Bits) + AM_RANGE( 0x02, 0x02 ) AM_WRITE(dynax_rombank_w) // BANK ROM Select + AM_RANGE( 0x03, 0x03 ) AM_WRITE(dynax_blit_backpen_w) // Background Color + AM_RANGE( 0x10, 0x11 ) AM_WRITE(mjdialq2_blit_dest_w) // Destination Layer + AM_RANGE( 0x12, 0x12 ) AM_WRITE(dynax_blit_palbank_w) // Layers Palettes (High Bit) + AM_RANGE( 0x13, 0x13 ) AM_WRITE(dynax_flipscreen_w) // Flip Screen + AM_RANGE( 0x14, 0x14 ) AM_WRITE(dynax_coincounter_0_w) // Coin Counters + AM_RANGE( 0x15, 0x15 ) AM_WRITE(dynax_coincounter_1_w) // + AM_RANGE( 0x16, 0x17 ) AM_WRITE(mjdialq2_layer_enable_w) // Layers Enable + AM_RANGE( 0x41, 0x47 ) AM_WRITE(dynax_blitter_rev2_w) // Blitter // AM_RANGE( 0x50, 0x50 ) AM_WRITENOP // CRT Controller // AM_RANGE( 0x51, 0x51 ) AM_WRITENOP // CRT Controller - AM_RANGE( 0x60, 0x60 ) AM_WRITE ( hanamai_keyboard_w ) // keyboard row select - AM_RANGE( 0x61, 0x61 ) AM_READ_PORT ( "COINS" ) // Coins - AM_RANGE( 0x62, 0x62 ) AM_READ ( hanamai_keyboard_1_r ) // P2 - AM_RANGE( 0x63, 0x63 ) AM_READ ( hanamai_keyboard_0_r ) // P1 - AM_RANGE( 0x64, 0x64 ) AM_READ_PORT ( "DSW0" ) // DSW - AM_RANGE( 0x67, 0x67 ) AM_READ_PORT ( "DSW1" ) // DSW - AM_RANGE( 0x70, 0x71 ) AM_DEVWRITE ( "ymsnd", ym2413_w ) // + AM_RANGE( 0x60, 0x60 ) AM_WRITE(hanamai_keyboard_w) // keyboard row select + AM_RANGE( 0x61, 0x61 ) AM_READ_PORT("COINS") // Coins + AM_RANGE( 0x62, 0x62 ) AM_READ(hanamai_keyboard_1_r) // P2 + AM_RANGE( 0x63, 0x63 ) AM_READ(hanamai_keyboard_0_r) // P1 + AM_RANGE( 0x64, 0x64 ) AM_READ_PORT("DSW0") // DSW + AM_RANGE( 0x67, 0x67 ) AM_READ_PORT("DSW1") // DSW + AM_RANGE( 0x70, 0x71 ) AM_DEVWRITE("ymsnd", ym2413_w) // // AM_RANGE( 0x80, 0x80 ) AM_WRITENOP // IRQ ack? ADDRESS_MAP_END static ADDRESS_MAP_START( nanajign_io_map, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) - AM_RANGE( 0x00, 0x00 ) AM_DEVWRITE ( "msm", adpcm_reset_w ) // MSM5205 reset - AM_RANGE( 0x02, 0x02 ) AM_WRITE ( adpcm_data_w ) // MSM5205 data - AM_RANGE( 0x04, 0x05 ) AM_DEVWRITE( "ymsnd", ym2413_w ) // - AM_RANGE( 0x08, 0x08 ) AM_DEVWRITE ( "aysnd", ay8910_data_w ) // AY8910 - AM_RANGE( 0x0a, 0x0a ) AM_DEVWRITE ( "aysnd", ay8910_address_w ) // - AM_RANGE( 0x10, 0x10 ) AM_WRITE ( hanamai_keyboard_w ) // keyboard row select - AM_RANGE( 0x11, 0x11 ) AM_READ_PORT ( "COINS" ) // Coins - AM_RANGE( 0x12, 0x12 ) AM_READ ( hanamai_keyboard_1_r ) // P2 - AM_RANGE( 0x13, 0x13 ) AM_READ ( hanamai_keyboard_0_r ) // P1 - AM_RANGE( 0x14, 0x14 ) AM_READ_PORT ( "DSW0" ) // DSW1 - AM_RANGE( 0x15, 0x15 ) AM_READ_PORT ( "DSW1" ) // DSW2 - AM_RANGE( 0x16, 0x16 ) AM_READ_PORT ( "DSW2" ) // DSW3 + AM_RANGE( 0x00, 0x00 ) AM_DEVWRITE("msm", adpcm_reset_w) // MSM5205 reset + AM_RANGE( 0x02, 0x02 ) AM_WRITE(adpcm_data_w) // MSM5205 data + AM_RANGE( 0x04, 0x05 ) AM_DEVWRITE("ymsnd", ym2413_w) // + AM_RANGE( 0x08, 0x08 ) AM_DEVWRITE("aysnd", ay8910_data_w) // AY8910 + AM_RANGE( 0x0a, 0x0a ) AM_DEVWRITE("aysnd", ay8910_address_w) // + AM_RANGE( 0x10, 0x10 ) AM_WRITE(hanamai_keyboard_w) // keyboard row select + AM_RANGE( 0x11, 0x11 ) AM_READ_PORT("COINS") // Coins + AM_RANGE( 0x12, 0x12 ) AM_READ(hanamai_keyboard_1_r) // P2 + AM_RANGE( 0x13, 0x13 ) AM_READ(hanamai_keyboard_0_r) // P1 + AM_RANGE( 0x14, 0x14 ) AM_READ_PORT("DSW0") // DSW1 + AM_RANGE( 0x15, 0x15 ) AM_READ_PORT("DSW1") // DSW2 + AM_RANGE( 0x16, 0x16 ) AM_READ_PORT("DSW2") // DSW3 // AM_RANGE( 0x20, 0x21 ) AM_WRITENOP // CRT Controller - AM_RANGE( 0x31, 0x37 ) AM_WRITE ( dynax_blitter_rev2_w ) // Blitter - AM_RANGE( 0x40, 0x40 ) AM_WRITE ( dynax_coincounter_0_w ) // Coin Counter - AM_RANGE( 0x50, 0x50 ) AM_WRITE ( dynax_flipscreen_w ) // Flip Screen - AM_RANGE( 0x51, 0x51 ) AM_WRITE ( hanamai_layer_half_w ) // half of the interleaved layer to write to - AM_RANGE( 0x52, 0x52 ) AM_WRITE ( hnoridur_layer_half2_w ) // - AM_RANGE( 0x57, 0x57 ) AM_WRITE ( dynax_blitter_ack_w ) // Blitter IRQ Ack - AM_RANGE( 0x60, 0x60 ) AM_WRITE ( dynax_extra_scrollx_w ) // screen scroll X - AM_RANGE( 0x62, 0x62 ) AM_WRITE ( dynax_extra_scrolly_w ) // screen scroll Y - AM_RANGE( 0x6a, 0x6a ) AM_WRITE ( hnoridur_rombank_w ) // BANK ROM Select - AM_RANGE( 0x6c, 0x6c ) AM_WRITE ( dynax_vblank_ack_w ) // VBlank IRQ Ack - AM_RANGE( 0x70, 0x70 ) AM_WRITE ( dynax_blit_pen_w ) // Destination Pen - AM_RANGE( 0x71, 0x71 ) AM_WRITE ( dynax_blit_dest_w ) // Destination Layer - AM_RANGE( 0x72, 0x72 ) AM_WRITE ( dynax_blit_palette01_w ) // Layers Palettes - AM_RANGE( 0x73, 0x73 ) AM_WRITE ( dynax_blit_palette23_w ) // - AM_RANGE( 0x74, 0x74 ) AM_WRITE ( hanamai_priority_w ) // layer priority and enable - AM_RANGE( 0x75, 0x75 ) AM_WRITE ( dynax_blit_backpen_w ) // Background Color - AM_RANGE( 0x76, 0x76 ) AM_WRITE ( yarunara_blit_romregion_w ) // Blitter ROM bank - AM_RANGE( 0x77, 0x77 ) AM_WRITE ( hnoridur_palbank_w ) + AM_RANGE( 0x31, 0x37 ) AM_WRITE(dynax_blitter_rev2_w) // Blitter + AM_RANGE( 0x40, 0x40 ) AM_WRITE(dynax_coincounter_0_w) // Coin Counter + AM_RANGE( 0x50, 0x50 ) AM_WRITE(dynax_flipscreen_w) // Flip Screen + AM_RANGE( 0x51, 0x51 ) AM_WRITE(hanamai_layer_half_w) // half of the interleaved layer to write to + AM_RANGE( 0x52, 0x52 ) AM_WRITE(hnoridur_layer_half2_w) // + AM_RANGE( 0x57, 0x57 ) AM_WRITE(dynax_blitter_ack_w) // Blitter IRQ Ack + AM_RANGE( 0x60, 0x60 ) AM_WRITE(dynax_extra_scrollx_w) // screen scroll X + AM_RANGE( 0x62, 0x62 ) AM_WRITE(dynax_extra_scrolly_w) // screen scroll Y + AM_RANGE( 0x6a, 0x6a ) AM_WRITE(hnoridur_rombank_w) // BANK ROM Select + AM_RANGE( 0x6c, 0x6c ) AM_WRITE(dynax_vblank_ack_w) // VBlank IRQ Ack + AM_RANGE( 0x70, 0x70 ) AM_WRITE(dynax_blit_pen_w) // Destination Pen + AM_RANGE( 0x71, 0x71 ) AM_WRITE(dynax_blit_dest_w) // Destination Layer + AM_RANGE( 0x72, 0x72 ) AM_WRITE(dynax_blit_palette01_w) // Layers Palettes + AM_RANGE( 0x73, 0x73 ) AM_WRITE(dynax_blit_palette23_w) // + AM_RANGE( 0x74, 0x74 ) AM_WRITE(hanamai_priority_w) // layer priority and enable + AM_RANGE( 0x75, 0x75 ) AM_WRITE(dynax_blit_backpen_w) // Background Color + AM_RANGE( 0x76, 0x76 ) AM_WRITE(yarunara_blit_romregion_w) // Blitter ROM bank + AM_RANGE( 0x77, 0x77 ) AM_WRITE(hnoridur_palbank_w) ADDRESS_MAP_END - - - /*************************************************************************** Jantouki - Main CPU ***************************************************************************/ -static UINT8 dynax_soundlatch_ack; -static UINT8 dynax_soundlatch_full; -static UINT8 latch; - static READ8_HANDLER( jantouki_soundlatch_ack_r ) { - return (dynax_soundlatch_ack) ? 0x80 : 0; + dynax_state *state = (dynax_state *)space->machine->driver_data; + return (state->soundlatch_ack) ? 0x80 : 0; } static WRITE8_HANDLER( jantouki_soundlatch_w ) { - dynax_soundlatch_ack = 1; - dynax_soundlatch_full = 1; - dynax_soundlatch_irq = 1; - latch = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + + state->soundlatch_ack = 1; + state->soundlatch_full = 1; + state->soundlatch_irq = 1; + state->latch = data; jantouki_sound_update_irq(space->machine); } @@ -969,40 +984,40 @@ static WRITE8_HANDLER( jantouki_rombank_w ) { UINT8 *ROM = memory_region(space->machine, "maincpu"); memory_set_bankptr(space->machine, "bank1",&ROM[0x8000 + 0x8000*(data&0x0f)]); - set_led_status(space->machine, 0,data & 0x10); // maybe + set_led_status(space->machine, 0, data & 0x10); // maybe } static ADDRESS_MAP_START( jantouki_io_map, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) // AM_RANGE( 0x40, 0x41 ) AM_WRITENOP // CRT Controller - AM_RANGE( 0x48, 0x48 ) AM_WRITE ( jantouki_rombank_w ) // BANK ROM Select - AM_RANGE( 0x49, 0x49 ) AM_WRITE ( jantouki_soundlatch_w ) // To Sound CPU - AM_RANGE( 0x4a, 0x4a ) AM_READ ( jantouki_soundlatch_ack_r ) // Soundlatch status - AM_RANGE( 0x4b, 0x4b ) AM_WRITE ( dynax_blit2_dest_w ) // Destination Layer 2 - AM_RANGE( 0x4d, 0x4d ) AM_WRITE ( dynax_blit_dest_w ) // Destination Layer - AM_RANGE( 0x4f, 0x4f ) AM_WRITE ( dynax_blit2_romregion_w ) // Blitter 2 ROM bank - AM_RANGE( 0x50, 0x50 ) AM_WRITE ( jantouki_vblank_ack_w ) // VBlank IRQ Ack - AM_RANGE( 0x51, 0x51 ) AM_WRITE ( hanamai_keyboard_w ) // keyboard row select - AM_RANGE( 0x52, 0x52 ) AM_READ ( hanamai_keyboard_0_r ) // P1 - AM_RANGE( 0x54, 0x54 ) AM_READ_PORT ( "COINS" ) // Coins - AM_RANGE( 0x55, 0x55 ) AM_READ_PORT ( "DSW0" ) // DSW1 - AM_RANGE( 0x56, 0x56 ) AM_READ_PORT ( "DSW1" ) // DSW2 - AM_RANGE( 0x58, 0x58 ) AM_WRITE ( dynax_coincounter_0_w ) // Coin Counter - AM_RANGE( 0x5b, 0x5b ) AM_WRITE ( dynax_blit2_palbank_w ) // Layers Palettes (High Bit) - AM_RANGE( 0x5d, 0x5d ) AM_WRITE ( dynax_blit_palbank_w ) // - AM_RANGE( 0x5e, 0x5e ) AM_WRITE ( jantouki_blitter_ack_w ) // Blitter IRQ Ack - AM_RANGE( 0x5f, 0x5f ) AM_WRITE ( jantouki_blitter2_ack_w ) // Blitter 2 IRQ Ack - AM_RANGE( 0x60, 0x60 ) AM_WRITE ( dynax_blit_palette67_w ) // Layers Palettes (Low Bits) - AM_RANGE( 0x61, 0x61 ) AM_WRITE ( dynax_blit_palette45_w ) // - AM_RANGE( 0x62, 0x62 ) AM_WRITE ( dynax_blit_palette23_w ) // - AM_RANGE( 0x63, 0x63 ) AM_WRITE ( dynax_blit_palette01_w ) // - AM_RANGE( 0x64, 0x64 ) AM_WRITE ( dynax_blit_backpen_w ) // Background Color - AM_RANGE( 0x65, 0x65 ) AM_WRITE ( dynax_blit2_pen_w ) // Destination Pen 2 - AM_RANGE( 0x66, 0x66 ) AM_WRITE ( dynax_blit_pen_w ) // Destination Pen - AM_RANGE( 0x67, 0x67 ) AM_READ ( jantouki_blitter_busy_r ) // - AM_RANGE( 0x69, 0x6f ) AM_WRITE ( jantouki_blitter2_rev2_w ) // Blitter 2 - AM_RANGE( 0x71, 0x77 ) AM_WRITE ( jantouki_blitter_rev2_w ) // Blitter - AM_RANGE( 0x78, 0x7e ) AM_WRITE ( jantouki_layer_enable_w ) // Layers Enable + AM_RANGE( 0x48, 0x48 ) AM_WRITE(jantouki_rombank_w) // BANK ROM Select + AM_RANGE( 0x49, 0x49 ) AM_WRITE(jantouki_soundlatch_w) // To Sound CPU + AM_RANGE( 0x4a, 0x4a ) AM_READ(jantouki_soundlatch_ack_r) // Soundlatch status + AM_RANGE( 0x4b, 0x4b ) AM_WRITE(dynax_blit2_dest_w) // Destination Layer 2 + AM_RANGE( 0x4d, 0x4d ) AM_WRITE(dynax_blit_dest_w) // Destination Layer + AM_RANGE( 0x4f, 0x4f ) AM_WRITE(dynax_blit2_romregion_w) // Blitter 2 ROM bank + AM_RANGE( 0x50, 0x50 ) AM_WRITE(jantouki_vblank_ack_w) // VBlank IRQ Ack + AM_RANGE( 0x51, 0x51 ) AM_WRITE(hanamai_keyboard_w) // keyboard row select + AM_RANGE( 0x52, 0x52 ) AM_READ(hanamai_keyboard_0_r) // P1 + AM_RANGE( 0x54, 0x54 ) AM_READ_PORT("COINS") // Coins + AM_RANGE( 0x55, 0x55 ) AM_READ_PORT("DSW0") // DSW1 + AM_RANGE( 0x56, 0x56 ) AM_READ_PORT("DSW1") // DSW2 + AM_RANGE( 0x58, 0x58 ) AM_WRITE(dynax_coincounter_0_w) // Coin Counter + AM_RANGE( 0x5b, 0x5b ) AM_WRITE(dynax_blit2_palbank_w) // Layers Palettes (High Bit) + AM_RANGE( 0x5d, 0x5d ) AM_WRITE(dynax_blit_palbank_w) // + AM_RANGE( 0x5e, 0x5e ) AM_WRITE(jantouki_blitter_ack_w) // Blitter IRQ Ack + AM_RANGE( 0x5f, 0x5f ) AM_WRITE(jantouki_blitter2_ack_w) // Blitter 2 IRQ Ack + AM_RANGE( 0x60, 0x60 ) AM_WRITE(dynax_blit_palette67_w) // Layers Palettes (Low Bits) + AM_RANGE( 0x61, 0x61 ) AM_WRITE(dynax_blit_palette45_w) // + AM_RANGE( 0x62, 0x62 ) AM_WRITE(dynax_blit_palette23_w) // + AM_RANGE( 0x63, 0x63 ) AM_WRITE(dynax_blit_palette01_w) // + AM_RANGE( 0x64, 0x64 ) AM_WRITE(dynax_blit_backpen_w) // Background Color + AM_RANGE( 0x65, 0x65 ) AM_WRITE(dynax_blit2_pen_w) // Destination Pen 2 + AM_RANGE( 0x66, 0x66 ) AM_WRITE(dynax_blit_pen_w) // Destination Pen + AM_RANGE( 0x67, 0x67 ) AM_READ(jantouki_blitter_busy_r) // + AM_RANGE( 0x69, 0x6f ) AM_WRITE(jantouki_blitter2_rev2_w) // Blitter 2 + AM_RANGE( 0x71, 0x77 ) AM_WRITE(jantouki_blitter_rev2_w) // Blitter + AM_RANGE( 0x78, 0x7e ) AM_WRITE(jantouki_layer_enable_w) // Layers Enable ADDRESS_MAP_END /*************************************************************************** @@ -1011,34 +1026,37 @@ ADDRESS_MAP_END static WRITE8_HANDLER( jantouki_soundlatch_ack_w ) { - dynax_soundlatch_ack = data; - dynax_soundlatch_irq = 0; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->soundlatch_ack = data; + state->soundlatch_irq = 0; jantouki_sound_update_irq(space->machine); } static READ8_HANDLER( jantouki_soundlatch_r ) { - dynax_soundlatch_full = 0; - return latch; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->soundlatch_full = 0; + return state->latch; } static READ8_HANDLER( jantouki_soundlatch_status_r ) { - return (dynax_soundlatch_full) ? 0 : 0x80; + dynax_state *state = (dynax_state *)space->machine->driver_data; + return (state->soundlatch_full) ? 0 : 0x80; } static ADDRESS_MAP_START( jantouki_sound_io_map, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) - AM_RANGE( 0x00, 0x00 ) AM_WRITE ( jantouki_sound_rombank_w ) // BANK ROM Select - AM_RANGE( 0x10, 0x10 ) AM_WRITE ( jantouki_sound_vblank_ack_w ) // VBlank IRQ Ack - AM_RANGE( 0x21, 0x21 ) AM_DEVREAD ( "aysnd", ay8910_r ) // AY8910 - AM_RANGE( 0x22, 0x23 ) AM_DEVWRITE ( "aysnd", ay8910_data_address_w ) // + AM_RANGE( 0x00, 0x00 ) AM_WRITE(jantouki_sound_rombank_w) // BANK ROM Select + AM_RANGE( 0x10, 0x10 ) AM_WRITE(jantouki_sound_vblank_ack_w) // VBlank IRQ Ack + AM_RANGE( 0x21, 0x21 ) AM_DEVREAD("aysnd", ay8910_r) // AY8910 + AM_RANGE( 0x22, 0x23 ) AM_DEVWRITE("aysnd", ay8910_data_address_w) // AM_RANGE( 0x28, 0x29 ) AM_DEVREADWRITE("ymsnd", ym2203_r, ym2203_w) // - AM_RANGE( 0x30, 0x30 ) AM_DEVWRITE ( "msm", adpcm_reset_w ) // MSM5205 reset - AM_RANGE( 0x40, 0x40 ) AM_WRITE ( adpcm_data_w ) // MSM5205 data - AM_RANGE( 0x50, 0x50 ) AM_READ ( jantouki_soundlatch_status_r ) // Soundlatch status - AM_RANGE( 0x60, 0x60 ) AM_WRITE ( jantouki_soundlatch_ack_w ) // Soundlatch status - AM_RANGE( 0x70, 0x70 ) AM_READ ( jantouki_soundlatch_r ) // From Main CPU + AM_RANGE( 0x30, 0x30 ) AM_DEVWRITE("msm", adpcm_reset_w) // MSM5205 reset + AM_RANGE( 0x40, 0x40 ) AM_WRITE(adpcm_data_w) // MSM5205 data + AM_RANGE( 0x50, 0x50 ) AM_READ(jantouki_soundlatch_status_r) // Soundlatch status + AM_RANGE( 0x60, 0x60 ) AM_WRITE(jantouki_soundlatch_ack_w) // Soundlatch status + AM_RANGE( 0x70, 0x70 ) AM_READ(jantouki_soundlatch_r) // From Main CPU ADDRESS_MAP_END @@ -1054,7 +1072,8 @@ static READ8_HANDLER( mjelctrn_keyboard_1_r ) static READ8_HANDLER( mjelctrn_dsw_r ) { - int dsw = (keyb & 0xc0) >> 6; + dynax_state *state = (dynax_state *)space->machine->driver_data; + int dsw = (state->keyb & 0xc0) >> 6; static const char *const dswnames[] = { "DSW0", "DSW1", "DSW3", "DSW4" }; return input_port_read(space->machine, dswnames[dsw]); @@ -1062,45 +1081,46 @@ static READ8_HANDLER( mjelctrn_dsw_r ) static WRITE8_HANDLER( mjelctrn_blitter_ack_w ) { - dynax_blitter_irq = 0; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->blitter_irq = 0; } static ADDRESS_MAP_START( mjelctrn_io_map, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) - AM_RANGE( 0x00, 0x00 ) AM_DEVWRITE ( "msm", adpcm_reset_w ) // MSM5205 reset - AM_RANGE( 0x02, 0x02 ) AM_WRITE ( adpcm_data_w ) // MSM5205 data - AM_RANGE( 0x04, 0x05 ) AM_DEVWRITE( "ymsnd", ym2413_w ) // - AM_RANGE( 0x08, 0x08 ) AM_DEVWRITE( "aysnd", ay8910_data_w ) // AY8910 - AM_RANGE( 0x0a, 0x0a ) AM_DEVWRITE( "aysnd", ay8910_address_w ) // - AM_RANGE( 0x11, 0x12 ) AM_WRITE ( mjelctrn_blitter_ack_w ) //? + AM_RANGE( 0x00, 0x00 ) AM_DEVWRITE("msm", adpcm_reset_w) // MSM5205 reset + AM_RANGE( 0x02, 0x02 ) AM_WRITE(adpcm_data_w) // MSM5205 data + AM_RANGE( 0x04, 0x05 ) AM_DEVWRITE("ymsnd", ym2413_w) // + AM_RANGE( 0x08, 0x08 ) AM_DEVWRITE("aysnd", ay8910_data_w) // AY8910 + AM_RANGE( 0x0a, 0x0a ) AM_DEVWRITE("aysnd", ay8910_address_w) // + AM_RANGE( 0x11, 0x12 ) AM_WRITE(mjelctrn_blitter_ack_w) //? // AM_RANGE( 0x20, 0x20 ) AM_WRITENOP // CRT Controller // AM_RANGE( 0x21, 0x21 ) AM_WRITENOP // CRT Controller - AM_RANGE( 0x40, 0x40 ) AM_WRITE ( dynax_coincounter_0_w ) // Coin Counters - AM_RANGE( 0x41, 0x41 ) AM_WRITE ( dynax_coincounter_1_w ) // - AM_RANGE( 0x60, 0x60 ) AM_WRITE ( dynax_extra_scrollx_w ) // screen scroll X - AM_RANGE( 0x62, 0x62 ) AM_WRITE ( dynax_extra_scrolly_w ) // screen scroll Y -// AM_RANGE( 0x64, 0x64 ) AM_WRITE ( dynax_extra_scrollx_w ) // screen scroll X -// AM_RANGE( 0x66, 0x66 ) AM_WRITE ( dynax_extra_scrolly_w ) // screen scroll Y - AM_RANGE( 0x6a, 0x6a ) AM_WRITE ( hnoridur_rombank_w ) // BANK ROM Select - AM_RANGE( 0x80, 0x80 ) AM_WRITE ( hanamai_keyboard_w ) // keyboard row select - AM_RANGE( 0x81, 0x81 ) AM_READ_PORT ( "COINS" ) // Coins - AM_RANGE( 0x82, 0x82 ) AM_READ ( mjelctrn_keyboard_1_r ) // P2 - AM_RANGE( 0x83, 0x83 ) AM_READ ( hanamai_keyboard_0_r ) // P1 - AM_RANGE( 0x84, 0x84 ) AM_READ ( mjelctrn_dsw_r ) // DSW x 4 - AM_RANGE( 0x85, 0x85 ) AM_READ ( ret_ff ) // ? - AM_RANGE( 0xa1, 0xa7 ) AM_WRITE ( dynax_blitter_rev2_w ) // Blitter - AM_RANGE( 0xc0, 0xc0 ) AM_WRITE ( dynax_flipscreen_w ) // Flip Screen - AM_RANGE( 0xc1, 0xc1 ) AM_WRITE ( hanamai_layer_half_w ) // half of the interleaved layer to write to - AM_RANGE( 0xc2, 0xc2 ) AM_WRITE ( hnoridur_layer_half2_w ) // + AM_RANGE( 0x40, 0x40 ) AM_WRITE(dynax_coincounter_0_w) // Coin Counters + AM_RANGE( 0x41, 0x41 ) AM_WRITE(dynax_coincounter_1_w) // + AM_RANGE( 0x60, 0x60 ) AM_WRITE(dynax_extra_scrollx_w) // screen scroll X + AM_RANGE( 0x62, 0x62 ) AM_WRITE(dynax_extra_scrolly_w) // screen scroll Y +// AM_RANGE( 0x64, 0x64 ) AM_WRITE(dynax_extra_scrollx_w) // screen scroll X +// AM_RANGE( 0x66, 0x66 ) AM_WRITE(dynax_extra_scrolly_w) // screen scroll Y + AM_RANGE( 0x6a, 0x6a ) AM_WRITE(hnoridur_rombank_w) // BANK ROM Select + AM_RANGE( 0x80, 0x80 ) AM_WRITE(hanamai_keyboard_w) // keyboard row select + AM_RANGE( 0x81, 0x81 ) AM_READ_PORT("COINS") // Coins + AM_RANGE( 0x82, 0x82 ) AM_READ(mjelctrn_keyboard_1_r) // P2 + AM_RANGE( 0x83, 0x83 ) AM_READ(hanamai_keyboard_0_r) // P1 + AM_RANGE( 0x84, 0x84 ) AM_READ(mjelctrn_dsw_r) // DSW x 4 + AM_RANGE( 0x85, 0x85 ) AM_READ(ret_ff) // ? + AM_RANGE( 0xa1, 0xa7 ) AM_WRITE(dynax_blitter_rev2_w) // Blitter + AM_RANGE( 0xc0, 0xc0 ) AM_WRITE(dynax_flipscreen_w) // Flip Screen + AM_RANGE( 0xc1, 0xc1 ) AM_WRITE(hanamai_layer_half_w) // half of the interleaved layer to write to + AM_RANGE( 0xc2, 0xc2 ) AM_WRITE(hnoridur_layer_half2_w) // // c3,c4 seem to be related to wrap around enable - AM_RANGE( 0xe0, 0xe0 ) AM_WRITE ( dynax_blit_pen_w ) // Destination Pen - AM_RANGE( 0xe1, 0xe1 ) AM_WRITE ( dynax_blit_dest_w ) // Destination Layer - AM_RANGE( 0xe2, 0xe2 ) AM_WRITE ( dynax_blit_palette01_w ) // Layers Palettes - AM_RANGE( 0xe3, 0xe3 ) AM_WRITE ( dynax_blit_palette23_w ) // - AM_RANGE( 0xe4, 0xe4 ) AM_WRITE ( hanamai_priority_w ) // layer priority and enable - AM_RANGE( 0xe5, 0xe5 ) AM_WRITE ( dynax_blit_backpen_w ) // Background Color - AM_RANGE( 0xe6, 0xe6 ) AM_WRITE ( yarunara_blit_romregion_w ) // Blitter ROM bank - AM_RANGE( 0xe7, 0xe7 ) AM_WRITE ( hnoridur_palbank_w ) + AM_RANGE( 0xe0, 0xe0 ) AM_WRITE(dynax_blit_pen_w) // Destination Pen + AM_RANGE( 0xe1, 0xe1 ) AM_WRITE(dynax_blit_dest_w) // Destination Layer + AM_RANGE( 0xe2, 0xe2 ) AM_WRITE(dynax_blit_palette01_w) // Layers Palettes + AM_RANGE( 0xe3, 0xe3 ) AM_WRITE(dynax_blit_palette23_w) // + AM_RANGE( 0xe4, 0xe4 ) AM_WRITE(hanamai_priority_w) // layer priority and enable + AM_RANGE( 0xe5, 0xe5 ) AM_WRITE(dynax_blit_backpen_w) // Background Color + AM_RANGE( 0xe6, 0xe6 ) AM_WRITE(yarunara_blit_romregion_w) // Blitter ROM bank + AM_RANGE( 0xe7, 0xe7 ) AM_WRITE(hnoridur_palbank_w) ADDRESS_MAP_END @@ -1108,97 +1128,106 @@ ADDRESS_MAP_END Hanafuda Hana Tengoku ***************************************************************************/ -static UINT8 htengoku_select, htengoku_dsw, htengoku_ip, htengoku_coins, htengoku_hopper; static WRITE8_HANDLER( htengoku_select_w ) { - htengoku_select = data; - htengoku_ip = 0; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->input_sel = data; + state->keyb = 0; } static WRITE8_DEVICE_HANDLER( htengoku_dsw_w ) { - htengoku_dsw = data; + dynax_state *state = (dynax_state *)device->machine->driver_data; + state->dsw_sel = data; } + static READ8_DEVICE_HANDLER( htengoku_dsw_r ) { - if (!(htengoku_dsw & 0x01)) return input_port_read(device->machine, "DSW0"); - if (!(htengoku_dsw & 0x02)) return input_port_read(device->machine, "DSW1"); - if (!(htengoku_dsw & 0x04)) return input_port_read(device->machine, "DSW2"); - if (!(htengoku_dsw & 0x08)) return input_port_read(device->machine, "DSW3"); - if (!(htengoku_dsw & 0x10)) return input_port_read(device->machine, "DSW4"); - logerror("%s: warning, unknown bits read, htengoku_dsw = %02x\n", cpuexec_describe_context(device->machine), htengoku_dsw); + dynax_state *state = (dynax_state *)device->machine->driver_data; + if (!BIT(state->dsw_sel, 0)) return input_port_read(device->machine, "DSW0"); + if (!BIT(state->dsw_sel, 1)) return input_port_read(device->machine, "DSW1"); + if (!BIT(state->dsw_sel, 2)) return input_port_read(device->machine, "DSW2"); + if (!BIT(state->dsw_sel, 3)) return input_port_read(device->machine, "DSW3"); + if (!BIT(state->dsw_sel, 4)) return input_port_read(device->machine, "DSW4"); + logerror("%s: warning, unknown bits read, dsw_sel = %02x\n", cpuexec_describe_context(device->machine), state->dsw_sel); return 0xff; } static WRITE8_HANDLER( htengoku_coin_w ) { - switch ( htengoku_select ) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->input_sel) { case 0x0c: // bit 0 = coin counter // bit 1 = out counter // bit 2 = hopper coin_counter_w(space->machine, 0, data & 1); - htengoku_hopper = data & 0x04; + state->hopper = data & 0x04; #ifdef MAME_DEBUG // popmessage("COINS %02x",data); #endif - htengoku_coins = data; + state->coins = data; case 0x0d: break; // ff resets input port sequence? case 0xff: break; // CRT controller? default: - logerror("%04x: coins_w with select = %02x, data = %02x\n", cpu_get_pc(space->cpu), htengoku_select,data); + logerror("%04x: coins_w with select = %02x, data = %02x\n", cpu_get_pc(space->cpu), state->input_sel, data); } } static READ8_HANDLER( htengoku_input_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; static const char *const keynames0[] = { "KEY0", "KEY1", "KEY2", "KEY3", "KEY4" }; static const char *const keynames1[] = { "KEY5", "KEY6", "KEY7", "KEY8", "KEY9" }; - switch( htengoku_select ) + switch (state->input_sel) { - case 0x81: return input_port_read(space->machine, keynames1[htengoku_ip++]); - case 0x82: return input_port_read(space->machine, keynames0[htengoku_ip++]); + case 0x81: return input_port_read(space->machine, keynames1[state->keyb++]); + case 0x82: return input_port_read(space->machine, keynames0[state->keyb++]); case 0x0d: return 0xff; // unused } - logerror("%04x: input_r with select = %02x\n", cpu_get_pc(space->cpu), htengoku_select); + logerror("%04x: input_r with select = %02x\n", cpu_get_pc(space->cpu), state->input_sel); return 0xff; } static READ8_HANDLER( htengoku_coin_r ) { - switch( htengoku_select ) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->input_sel) { case 0x00: return input_port_read(space->machine, "COINS"); case 0x01: return 0xff; //? - case 0x02: return 0xbf | ((htengoku_hopper && !(video_screen_get_frame_number(space->machine->primary_screen)%10)) ? 0 : (1<<6)); // bit 7 = blitter busy, bit 6 = hopper - case 0x03: return htengoku_coins; + case 0x02: return 0xbf | ((state->hopper && !(video_screen_get_frame_number(space->machine->primary_screen) % 10)) ? 0 : (1 << 6)); // bit 7 = blitter busy, bit 6 = hopper + case 0x03: return state->coins; } - logerror("%04x: coin_r with select = %02x\n", cpu_get_pc(space->cpu), htengoku_select); + logerror("%04x: coin_r with select = %02x\n", cpu_get_pc(space->cpu), state->input_sel); return 0xff; } static WRITE8_HANDLER( htengoku_rombank_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; UINT8 *rom = memory_region(space->machine, "maincpu") + 0x10000 + 0x8000 * (data & 0x7); memory_set_bankptr(space->machine, "bank1", rom); - hnoridur_bank = data; + state->hnoridur_bank = data; } static WRITE8_HANDLER( htengoku_blit_romregion_w ) { - switch(data) + switch (data) { - case 0x80: dynax_blit_romregion_w(space,0,0); return; - case 0x81: dynax_blit_romregion_w(space,0,1); return; - case 0x00: dynax_blit_romregion_w(space,0,2); return; + case 0x80: dynax_blit_romregion_w(space, 0, 0); return; + case 0x81: dynax_blit_romregion_w(space, 0, 1); return; + case 0x00: dynax_blit_romregion_w(space, 0, 2); return; } - logerror("%04x: unmapped romregion=%02X\n",cpu_get_pc(space->cpu),data); + logerror("%04x: unmapped romregion=%02X\n", cpu_get_pc(space->cpu), data); } static READ8_HANDLER( unk_r ) @@ -1208,36 +1237,36 @@ static READ8_HANDLER( unk_r ) static ADDRESS_MAP_START( htengoku_io_map, ADDRESS_SPACE_IO, 8 ) ADDRESS_MAP_GLOBAL_MASK(0xff) - AM_RANGE( 0x01, 0x07 ) AM_WRITE ( dynax_blitter_rev2_w ) // Blitter - AM_RANGE( 0x20, 0x20 ) AM_WRITE ( htengoku_select_w ) // Controls - AM_RANGE( 0x21, 0x21 ) AM_WRITE ( htengoku_coin_w ) // - AM_RANGE( 0x22, 0x22 ) AM_READ ( htengoku_coin_r ) // - AM_RANGE( 0x23, 0x23 ) AM_READ ( htengoku_input_r ) // - AM_RANGE( 0x40, 0x40 ) AM_DEVWRITE ( "aysnd", ay8910_address_w ) // AY8910 - AM_RANGE( 0x42, 0x42 ) AM_DEVREAD ( "aysnd", ay8910_r ) // - AM_RANGE( 0x44, 0x44 ) AM_DEVWRITE ( "aysnd", ay8910_data_w) // - AM_RANGE( 0x46, 0x47 ) AM_DEVWRITE( "ymsnd", ym2413_w ) // + AM_RANGE( 0x01, 0x07 ) AM_WRITE(dynax_blitter_rev2_w) // Blitter + AM_RANGE( 0x20, 0x20 ) AM_WRITE(htengoku_select_w) // Controls + AM_RANGE( 0x21, 0x21 ) AM_WRITE(htengoku_coin_w) // + AM_RANGE( 0x22, 0x22 ) AM_READ(htengoku_coin_r) // + AM_RANGE( 0x23, 0x23 ) AM_READ(htengoku_input_r) // + AM_RANGE( 0x40, 0x40 ) AM_DEVWRITE("aysnd", ay8910_address_w) // AY8910 + AM_RANGE( 0x42, 0x42 ) AM_DEVREAD("aysnd", ay8910_r) // + AM_RANGE( 0x44, 0x44 ) AM_DEVWRITE("aysnd", ay8910_data_w) // + AM_RANGE( 0x46, 0x47 ) AM_DEVWRITE("ymsnd", ym2413_w) // AM_RANGE( 0x80, 0x8f ) AM_DEVREADWRITE("rtc", msm6242_r, msm6242_w) // 6242RTC - AM_RANGE( 0xa0, 0xa3 ) AM_WRITE ( ddenlovr_palette_base_w ) // ddenlovr mixer chip - AM_RANGE( 0xa4, 0xa7 ) AM_WRITE ( ddenlovr_palette_mask_w ) - AM_RANGE( 0xa8, 0xab ) AM_WRITE ( ddenlovr_transparency_pen_w ) - AM_RANGE( 0xac, 0xaf ) AM_WRITE ( ddenlovr_transparency_mask_w ) + AM_RANGE( 0xa0, 0xa3 ) AM_WRITE(ddenlovr_palette_base_w) // ddenlovr mixer chip + AM_RANGE( 0xa4, 0xa7 ) AM_WRITE(ddenlovr_palette_mask_w) + AM_RANGE( 0xa8, 0xab ) AM_WRITE(ddenlovr_transparency_pen_w) + AM_RANGE( 0xac, 0xaf ) AM_WRITE(ddenlovr_transparency_mask_w) // b0-b3 ? - AM_RANGE( 0xb4, 0xb4 ) AM_WRITE ( ddenlovr_bgcolor_w ) - AM_RANGE( 0xb5, 0xb5 ) AM_WRITE ( ddenlovr_priority_w ) - AM_RANGE( 0xb6, 0xb6 ) AM_WRITE ( ddenlovr_layer_enable_w ) - AM_RANGE( 0xb8, 0xb8 ) AM_READ ( unk_r ) // ? must be 78 on startup - AM_RANGE( 0xc2, 0xc2 ) AM_WRITE ( htengoku_rombank_w ) // BANK ROM Select - AM_RANGE( 0xc0, 0xc0 ) AM_WRITE ( dynax_extra_scrollx_w ) // screen scroll X - AM_RANGE( 0xc1, 0xc1 ) AM_WRITE ( dynax_extra_scrolly_w ) // screen scroll Y - AM_RANGE( 0xc3, 0xc3 ) AM_WRITE ( dynax_vblank_ack_w ) // VBlank IRQ Ack - AM_RANGE( 0xc4, 0xc4 ) AM_WRITE ( dynax_blit_pen_w ) // Destination Pen - AM_RANGE( 0xc5, 0xc5 ) AM_WRITE ( dynax_blit_dest_w ) // Destination Layer - AM_RANGE( 0xc6, 0xc6 ) AM_WRITE ( htengoku_blit_romregion_w ) // Blitter ROM bank - AM_RANGE( 0xe0, 0xe0 ) AM_WRITE ( yarunara_flipscreen_w ) - AM_RANGE( 0xe1, 0xe1 ) AM_WRITE ( yarunara_layer_half_w ) // half of the interleaved layer to write to - AM_RANGE( 0xe2, 0xe2 ) AM_WRITE ( yarunara_layer_half2_w ) // - AM_RANGE( 0xe5, 0xe5 ) AM_WRITE ( dynax_blitter_ack_w ) // Blitter IRQ Ack + AM_RANGE( 0xb4, 0xb4 ) AM_WRITE(ddenlovr_bgcolor_w) + AM_RANGE( 0xb5, 0xb5 ) AM_WRITE(ddenlovr_priority_w) + AM_RANGE( 0xb6, 0xb6 ) AM_WRITE(ddenlovr_layer_enable_w) + AM_RANGE( 0xb8, 0xb8 ) AM_READ(unk_r) // ? must be 78 on startup + AM_RANGE( 0xc2, 0xc2 ) AM_WRITE(htengoku_rombank_w) // BANK ROM Select + AM_RANGE( 0xc0, 0xc0 ) AM_WRITE(dynax_extra_scrollx_w) // screen scroll X + AM_RANGE( 0xc1, 0xc1 ) AM_WRITE(dynax_extra_scrolly_w) // screen scroll Y + AM_RANGE( 0xc3, 0xc3 ) AM_WRITE(dynax_vblank_ack_w) // VBlank IRQ Ack + AM_RANGE( 0xc4, 0xc4 ) AM_WRITE(dynax_blit_pen_w) // Destination Pen + AM_RANGE( 0xc5, 0xc5 ) AM_WRITE(dynax_blit_dest_w) // Destination Layer + AM_RANGE( 0xc6, 0xc6 ) AM_WRITE(htengoku_blit_romregion_w) // Blitter ROM bank + AM_RANGE( 0xe0, 0xe0 ) AM_WRITE(yarunara_flipscreen_w) + AM_RANGE( 0xe1, 0xe1 ) AM_WRITE(yarunara_layer_half_w) // half of the interleaved layer to write to + AM_RANGE( 0xe2, 0xe2 ) AM_WRITE(yarunara_layer_half2_w) // + AM_RANGE( 0xe5, 0xe5 ) AM_WRITE(dynax_blitter_ack_w) // Blitter IRQ Ack ADDRESS_MAP_END @@ -1245,46 +1274,45 @@ ADDRESS_MAP_END Mahjong Tenkaigen ***************************************************************************/ -static int rombank; -static UINT8 *romptr; -static int tenkai_dswsel, tenkai_ipsel, tenkai_ip; -static UINT8 tenkai_p5_val; - static WRITE8_HANDLER( tenkai_ipsel_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; switch (offset) { - case 0: tenkai_ipsel = data; - tenkai_ip = 0; - break; + case 0: state->input_sel = data; + state->keyb = 0; + break; - case 1: break; + case 1: break; } } static WRITE8_HANDLER( tenkai_ip_w ) { - switch( tenkai_ipsel ) - { - case 0x0c: - coin_counter_w(space->machine, 0, data & 0x01); - coin_counter_w(space->machine, 1, data & 0x02); - // bit 2? - // bit 3? -// popmessage("%02x",data); - return; + dynax_state *state = (dynax_state *)space->machine->driver_data; - case 0x0d: - if (data != 0xff) - break; - return; + switch (state->input_sel) + { + case 0x0c: + coin_counter_w(space->machine, 0, data & 0x01); + coin_counter_w(space->machine, 1, data & 0x02); + // bit 2? + // bit 3? +// popmessage("%02x", data); + return; + + case 0x0d: + if (data != 0xff) + break; + return; } - logerror("%04x: unmapped ip_sel=%02x written with %02x\n", cpu_get_pc(space->cpu), tenkai_ipsel,data); + logerror("%04x: unmapped ip_sel=%02x written with %02x\n", cpu_get_pc(space->cpu), state->input_sel, data); } static READ8_HANDLER( tenkai_ip_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; static const char *const keynames0[] = { "KEY0", "KEY1", "KEY2", "KEY3", "KEY4" }; //static const char *const keynames1[] = { "KEY5", "KEY6", "KEY7", "KEY8", "KEY9" }; @@ -1292,38 +1320,38 @@ static READ8_HANDLER( tenkai_ip_r ) { case 0: { - switch( tenkai_ipsel ) + switch (state->input_sel) { case 0x00: return input_port_read(space->machine, "COINS"); // coins default: - logerror("%04x: unmapped ip_sel=%02x read from offs %x\n", cpu_get_pc(space->cpu), tenkai_ipsel, offset); + logerror("%04x: unmapped ip_sel=%02x read from offs %x\n", cpu_get_pc(space->cpu), state->input_sel, offset); return 0xff; } } case 1: { - switch( tenkai_ipsel ) + switch (state->input_sel) { case 0x0d: return 0xff; // player 2 case 0x81: - if (tenkai_ip >= 5) - logerror("%04x: unmapped tenkai_ip=%02x read\n", cpu_get_pc(space->cpu), tenkai_ip); - return 0xff;//input_port_read(space->machine, keynames1[tenkai_ip++]); + if (state->keyb >= 5) + logerror("%04x: unmapped keyb=%02x read\n", cpu_get_pc(space->cpu), state->keyb); + return 0xff;//input_port_read(space->machine, keynames1[state->keyb++]); // player 1 case 0x82: - if (tenkai_ip >= 5) - logerror("%04x: unmapped tenkai_ip=%02x read\n", cpu_get_pc(space->cpu), tenkai_ip); - return input_port_read(space->machine, keynames0[tenkai_ip++]); + if (state->keyb >= 5) + logerror("%04x: unmapped keyb=%02x read\n", cpu_get_pc(space->cpu), state->keyb); + return input_port_read(space->machine, keynames0[state->keyb++]); default: - logerror("%04x: unmapped ip_sel=%02x read from offs %x\n", cpu_get_pc(space->cpu), tenkai_ipsel, offset); + logerror("%04x: unmapped ip_sel=%02x read from offs %x\n", cpu_get_pc(space->cpu), state->input_sel, offset); return 0xff; } } @@ -1334,85 +1362,102 @@ static READ8_HANDLER( tenkai_ip_r ) static WRITE8_DEVICE_HANDLER( tenkai_dswsel_w ) { - tenkai_dswsel = data; + dynax_state *state = (dynax_state *)device->machine->driver_data; + state->dsw_sel = data; } + static READ8_DEVICE_HANDLER( tenkai_dsw_r ) { - if (~tenkai_dswsel & 0x01) return input_port_read(device->machine, "DSW0"); - if (~tenkai_dswsel & 0x02) return input_port_read(device->machine, "DSW1"); - if (~tenkai_dswsel & 0x04) return input_port_read(device->machine, "DSW2"); - if (~tenkai_dswsel & 0x08) return input_port_read(device->machine, "DSW3"); - if (~tenkai_dswsel & 0x10) return input_port_read(device->machine, "DSW4"); - logerror("%s: unmapped dsw %02x read\n",cpuexec_describe_context(device->machine),tenkai_dswsel); + dynax_state *state = (dynax_state *)device->machine->driver_data; + + if (!BIT(state->dsw_sel, 0)) return input_port_read(device->machine, "DSW0"); + if (!BIT(state->dsw_sel, 1)) return input_port_read(device->machine, "DSW1"); + if (!BIT(state->dsw_sel, 2)) return input_port_read(device->machine, "DSW2"); + if (!BIT(state->dsw_sel, 3)) return input_port_read(device->machine, "DSW3"); + if (!BIT(state->dsw_sel, 4)) return input_port_read(device->machine, "DSW4"); + logerror("%s: unmapped dsw %02x read\n", cpuexec_describe_context(device->machine), state->dsw_sel); + return 0xff; } static READ8_HANDLER( tenkai_palette_r ) { - return palette_ram[ 512*palbank + offset ]; + dynax_state *state = (dynax_state *)space->machine->driver_data; + return state->palette_ram[512 * state->palbank + offset]; } static WRITE8_HANDLER( tenkai_palette_w ) { - int addr = 512*palbank + offset; - palette_ram[addr] = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + int addr = 512 * state->palbank + offset; + state->palette_ram[addr] = data; + { - int br = palette_ram[addr & ~0x10]; // bbbrrrrr - int bg = palette_ram[addr | 0x10]; // bb0ggggg + int br = state->palette_ram[addr & ~0x10]; // bbbrrrrr + int bg = state->palette_ram[addr | 0x10]; // bb0ggggg int r = br & 0x1f; int g = bg & 0x1f; - int b = ((bg & 0xc0)>>3) | ((br & 0xe0)>>5); - palette_set_color_rgb(space->machine, 256*palbank + ((offset&0xf)|((offset&0x1e0)>>1)) ,pal5bit(r),pal5bit(g),pal5bit(b)); + int b = ((bg & 0xc0) >> 3) | ((br & 0xe0) >> 5); + palette_set_color_rgb(space->machine, 256 * state->palbank + ((offset & 0xf) | ((offset & 0x1e0) >> 1)), pal5bit(r), pal5bit(g), pal5bit(b)); } } -static void tenkai_update_rombank(running_machine *machine) +static void tenkai_update_rombank( running_machine *machine ) { - romptr = memory_region(machine, "maincpu") + 0x10000 + 0x8000 * rombank; -// logerror("rombank = %02x\n",rombank); + dynax_state *state = (dynax_state *)machine->driver_data; + state->romptr = memory_region(machine, "maincpu") + 0x10000 + 0x8000 * state->rombank; +// logerror("rombank = %02x\n", state->rombank); } static READ8_HANDLER( tenkai_p3_r ) { return 0x00; } + static WRITE8_HANDLER( tenkai_p3_w ) { - rombank = ((data & 0x04) << 1) | (rombank & 0x07); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->rombank = ((data & 0x04) << 1) | (state->rombank & 0x07); tenkai_update_rombank(space->machine); } static WRITE8_HANDLER( tenkai_p4_w ) { - rombank = (rombank & 0x08) | ((data & 0x0e) >> 1); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->rombank = (state->rombank & 0x08) | ((data & 0x0e) >> 1); tenkai_update_rombank(space->machine); } -// Added by Whistler - START + static READ8_HANDLER( tenkai_p5_r ) { - return tenkai_p5_val; + dynax_state *state = (dynax_state *)space->machine->driver_data; + return state->tenkai_p5_val; } + static WRITE8_HANDLER( tenkai_p6_w ) { - tenkai_p5_val &= 0x0f; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->tenkai_p5_val &= 0x0f; + if (data & 0x0f) - { - tenkai_p5_val |= (1 << 4); - } + state->tenkai_p5_val |= (1 << 4); } + static WRITE8_HANDLER( tenkai_p7_w ) { - tenkai_p5_val &= 0xf0; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->tenkai_p5_val &= 0xf0; + if (data & 0x03) - { - tenkai_p5_val |= (1 << 3); - } + state->tenkai_p5_val |= (1 << 3); } -// Added by Whistler - END + static WRITE8_HANDLER( tenkai_p8_w ) { - rombank = ((data & 0x08) << 1) | (rombank & 0x0f); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->rombank = ((data & 0x08) << 1) | (state->rombank & 0x0f); tenkai_update_rombank(space->machine); } + static READ8_HANDLER( tenkai_p8_r ) { return 0x00; @@ -1420,103 +1465,103 @@ static READ8_HANDLER( tenkai_p8_r ) static READ8_HANDLER( tenkai_8000_r ) { - if (rombank < 0x10) - { - return romptr[offset]; - } - else if ( (rombank == 0x10) && (offset < 0x10) ) - { - running_device *rtc = devtag_get_device(space->machine, "rtc"); - return msm6242_r(rtc, offset); - } - else if (rombank == 0x12) - { - return tenkai_palette_r(space,offset); - } + dynax_state *state = (dynax_state *)space->machine->driver_data; - logerror("%04x: unmapped offset %04X read with rombank=%02X\n",cpu_get_pc(space->cpu),offset,rombank); + if (state->rombank < 0x10) + return state->romptr[offset]; + else if ((state->rombank == 0x10) && (offset < 0x10)) + return msm6242_r(state->rtc, offset); + else if (state->rombank == 0x12) + return tenkai_palette_r(space, offset); + + logerror("%04x: unmapped offset %04X read with rombank=%02X\n", cpu_get_pc(space->cpu), offset, state->rombank); return 0x00; } static WRITE8_HANDLER( tenkai_8000_w ) { - if ( (rombank == 0x10) && (offset < 0x10) ) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + if ((state->rombank == 0x10) && (offset < 0x10)) { - running_device *rtc = devtag_get_device(space->machine, "rtc"); - msm6242_w(rtc, offset, data); + msm6242_w(state->rtc, offset, data); return; } - else if (rombank == 0x12) + else if (state->rombank == 0x12) { - tenkai_palette_w(space,offset,data); + tenkai_palette_w(space, offset, data); return; } - logerror("%04x: unmapped offset %04X=%02X written with rombank=%02X\n",cpu_get_pc(space->cpu),offset,data,rombank); + logerror("%04x: unmapped offset %04X=%02X written with rombank=%02X\n", cpu_get_pc(space->cpu), offset, data, state->rombank); } -static int tenkai_6c, tenkai_70; -static void tenkai_show_6c(void) +static void tenkai_show_6c( running_machine *machine ) { -// popmessage("%02x %02x",tenkai_6c,tenkai_70); +// dynax_state *state = (dynax_state *)machine->driver_data; +// popmessage("%02x %02x", state->tenkai_6c, state->tenkai_70); } + static WRITE8_HANDLER( tenkai_6c_w ) { - tenkai_6c = data; - tenkai_show_6c(); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->tenkai_6c = data; + tenkai_show_6c(space->machine); } + static WRITE8_HANDLER( tenkai_70_w ) { - tenkai_70 = data; - tenkai_show_6c(); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->tenkai_70 = data; + tenkai_show_6c(space->machine); } static WRITE8_HANDLER( tenkai_blit_romregion_w ) { - switch(data) + switch (data) { - case 0x00: dynax_blit_romregion_w(space,0,0); return; - case 0x83: dynax_blit_romregion_w(space,0,1); return; - case 0x80: dynax_blit_romregion_w(space,0,2); return; + case 0x00: dynax_blit_romregion_w(space, 0, 0); return; + case 0x83: dynax_blit_romregion_w(space, 0, 1); return; + case 0x80: dynax_blit_romregion_w(space, 0, 2); return; } - logerror("%04x: unmapped romregion=%02X\n",cpu_get_pc(space->cpu),data); + logerror("%04x: unmapped romregion=%02X\n", cpu_get_pc(space->cpu), data); } static ADDRESS_MAP_START( tenkai_map, ADDRESS_SPACE_PROGRAM, 8 ) AM_RANGE( 0x0000, 0x5fff ) AM_ROM AM_RANGE( 0x6000, 0x6fff ) AM_RAM AM_RANGE( 0x7000, 0x7fff ) AM_RAM AM_BASE_SIZE_GENERIC(nvram) - AM_RANGE( 0x8000, 0xffff ) AM_READWRITE( tenkai_8000_r, tenkai_8000_w ) - AM_RANGE( 0x10000, 0x10000 ) AM_DEVREAD ( "aysnd", ay8910_r ) // AY8910 - AM_RANGE( 0x10008, 0x10008 ) AM_DEVWRITE( "aysnd", ay8910_data_w ) // - AM_RANGE( 0x10010, 0x10010 ) AM_DEVWRITE( "aysnd", ay8910_address_w ) // - AM_RANGE( 0x10020, 0x10021 ) AM_DEVWRITE("ymsnd", ym2413_w ) // - AM_RANGE( 0x10040, 0x10040 ) AM_WRITE( dynax_blit_pen_w ) // Destination Pen - AM_RANGE( 0x10044, 0x10044 ) AM_WRITE( tenkai_blit_dest_w ) // Destination Layer - AM_RANGE( 0x10048, 0x10048 ) AM_WRITE( tenkai_blit_palette23_w ) // Layers Palettes - AM_RANGE( 0x1004c, 0x1004c ) AM_WRITE( tenkai_blit_palette01_w ) // - AM_RANGE( 0x10050, 0x10050 ) AM_WRITE( tenkai_priority_w ) // layer priority and enable - AM_RANGE( 0x10054, 0x10054 ) AM_WRITE( dynax_blit_backpen_w ) // Background Color - AM_RANGE( 0x10058, 0x10058 ) AM_WRITE( tenkai_blit_romregion_w ) // Blitter ROM bank - AM_RANGE( 0x10060, 0x10060 ) AM_WRITE( yarunara_flipscreen_inv_w) // Flip Screen - AM_RANGE( 0x10064, 0x10064 ) AM_WRITE( yarunara_layer_half_w ) // half of the interleaved layer to write to - AM_RANGE( 0x10068, 0x10068 ) AM_WRITE( yarunara_layer_half2_w ) // - AM_RANGE( 0x1006c, 0x1006c ) AM_WRITE( tenkai_6c_w ) // ? - AM_RANGE( 0x10070, 0x10070 ) AM_WRITE( tenkai_70_w ) // ? + AM_RANGE( 0x8000, 0xffff ) AM_READWRITE(tenkai_8000_r, tenkai_8000_w) + AM_RANGE( 0x10000, 0x10000 ) AM_DEVREAD("aysnd", ay8910_r) // AY8910 + AM_RANGE( 0x10008, 0x10008 ) AM_DEVWRITE("aysnd", ay8910_data_w) // + AM_RANGE( 0x10010, 0x10010 ) AM_DEVWRITE("aysnd", ay8910_address_w) // + AM_RANGE( 0x10020, 0x10021 ) AM_DEVWRITE("ymsnd", ym2413_w) // + AM_RANGE( 0x10040, 0x10040 ) AM_WRITE(dynax_blit_pen_w) // Destination Pen + AM_RANGE( 0x10044, 0x10044 ) AM_WRITE(tenkai_blit_dest_w) // Destination Layer + AM_RANGE( 0x10048, 0x10048 ) AM_WRITE(tenkai_blit_palette23_w) // Layers Palettes + AM_RANGE( 0x1004c, 0x1004c ) AM_WRITE(tenkai_blit_palette01_w) // + AM_RANGE( 0x10050, 0x10050 ) AM_WRITE(tenkai_priority_w) // layer priority and enable + AM_RANGE( 0x10054, 0x10054 ) AM_WRITE(dynax_blit_backpen_w) // Background Color + AM_RANGE( 0x10058, 0x10058 ) AM_WRITE(tenkai_blit_romregion_w) // Blitter ROM bank + AM_RANGE( 0x10060, 0x10060 ) AM_WRITE(yarunara_flipscreen_inv_w) // Flip Screen + AM_RANGE( 0x10064, 0x10064 ) AM_WRITE(yarunara_layer_half_w) // half of the interleaved layer to write to + AM_RANGE( 0x10068, 0x10068 ) AM_WRITE(yarunara_layer_half2_w) // + AM_RANGE( 0x1006c, 0x1006c ) AM_WRITE(tenkai_6c_w) // ? + AM_RANGE( 0x10070, 0x10070 ) AM_WRITE(tenkai_70_w) // ? AM_RANGE( 0x1007c, 0x1007c ) AM_WRITENOP // IRQ Ack? (0,2) - AM_RANGE( 0x100c0, 0x100c0 ) AM_WRITE( tenkai_ipsel_w ) - AM_RANGE( 0x100c1, 0x100c1 ) AM_WRITE( tenkai_ip_w ) - AM_RANGE( 0x100c2, 0x100c3 ) AM_READ ( tenkai_ip_r ) - AM_RANGE( 0x100e1, 0x100e7 ) AM_WRITE( tenkai_blitter_rev2_w ) // Blitter (inverted scroll values) + AM_RANGE( 0x100c0, 0x100c0 ) AM_WRITE(tenkai_ipsel_w) + AM_RANGE( 0x100c1, 0x100c1 ) AM_WRITE(tenkai_ip_w) + AM_RANGE( 0x100c2, 0x100c3 ) AM_READ(tenkai_ip_r) + AM_RANGE( 0x100e1, 0x100e7 ) AM_WRITE(tenkai_blitter_rev2_w) // Blitter (inverted scroll values) ADDRESS_MAP_END static ADDRESS_MAP_START( tenkai_io_map, ADDRESS_SPACE_IO, 8 ) - AM_RANGE( T90_P3, T90_P3 ) AM_READWRITE( tenkai_p3_r , tenkai_p3_w ) - AM_RANGE( T90_P4, T90_P4 ) AM_WRITE( tenkai_p4_w ) - AM_RANGE( T90_P5, T90_P5 ) AM_READ( tenkai_p5_r ) - AM_RANGE( T90_P6, T90_P6 ) AM_WRITE( tenkai_p6_w ) - AM_RANGE( T90_P7, T90_P7 ) AM_WRITE( tenkai_p7_w ) - AM_RANGE( T90_P8, T90_P8 ) AM_READWRITE( tenkai_p8_r, tenkai_p8_w ) + AM_RANGE( T90_P3, T90_P3 ) AM_READWRITE(tenkai_p3_r, tenkai_p3_w) + AM_RANGE( T90_P4, T90_P4 ) AM_WRITE(tenkai_p4_w) + AM_RANGE( T90_P5, T90_P5 ) AM_READ(tenkai_p5_r) + AM_RANGE( T90_P6, T90_P6 ) AM_WRITE(tenkai_p6_w) + AM_RANGE( T90_P7, T90_P7 ) AM_WRITE(tenkai_p7_w) + AM_RANGE( T90_P8, T90_P8 ) AM_READWRITE(tenkai_p8_r, tenkai_p8_w) ADDRESS_MAP_END /*************************************************************************** @@ -1525,25 +1570,27 @@ ADDRESS_MAP_END static READ8_HANDLER( gekisha_keyboard_0_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; int res = 0x3f; - if (~keyb & 0x01) res &= input_port_read(space->machine, "KEY0"); - if (~keyb & 0x02) res &= input_port_read(space->machine, "KEY1"); - if (~keyb & 0x04) res &= input_port_read(space->machine, "KEY2"); - if (~keyb & 0x08) res &= input_port_read(space->machine, "KEY3"); - if (~keyb & 0x10) res &= input_port_read(space->machine, "KEY4"); + if (!BIT(state->keyb, 0)) res &= input_port_read(space->machine, "KEY0"); + if (!BIT(state->keyb, 1)) res &= input_port_read(space->machine, "KEY1"); + if (!BIT(state->keyb, 2)) res &= input_port_read(space->machine, "KEY2"); + if (!BIT(state->keyb, 3)) res &= input_port_read(space->machine, "KEY3"); + if (!BIT(state->keyb, 4)) res &= input_port_read(space->machine, "KEY4"); return res; } static READ8_HANDLER( gekisha_keyboard_1_r ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; int res = 0x3f; - if (~keyb & 0x01) res &= input_port_read(space->machine, "KEY5"); - if (~keyb & 0x02) res &= input_port_read(space->machine, "KEY6"); - if (~keyb & 0x04) res &= input_port_read(space->machine, "KEY7"); - if (~keyb & 0x08) res &= input_port_read(space->machine, "KEY8"); - if (~keyb & 0x10) res &= input_port_read(space->machine, "KEY9"); + if (!BIT(state->keyb, 0)) res &= input_port_read(space->machine, "KEY5"); + if (!BIT(state->keyb, 1)) res &= input_port_read(space->machine, "KEY6"); + if (!BIT(state->keyb, 2)) res &= input_port_read(space->machine, "KEY7"); + if (!BIT(state->keyb, 3)) res &= input_port_read(space->machine, "KEY8"); + if (!BIT(state->keyb, 4)) res &= input_port_read(space->machine, "KEY9"); // bit 6 res |= input_port_read(space->machine, "BET"); @@ -1555,49 +1602,52 @@ static READ8_HANDLER( gekisha_keyboard_1_r ) static WRITE8_HANDLER( gekisha_hopper_w ) { - static UINT8 val[2]; - val[offset] = data; -// popmessage("%02x %02x",val[0],val[1]); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->gekisha_val[offset] = data; +// popmessage("%02x %02x", gekisha_val[0], gekisha_val[1]); } - -static UINT8 gekisha_rom_enable; -static UINT8 *gekisha_rom; -static void gekisha_set_rombank(running_machine *machine, UINT8 data) +static void gekisha_set_rombank( running_machine *machine, UINT8 data ) { - rombank = data; - gekisha_rom = memory_region(machine, "maincpu") + 0x8000 + rombank * 0x8000; + dynax_state *state = (dynax_state *)machine->driver_data; + state->rombank = data; + state->gekisha_rom = memory_region(machine, "maincpu") + 0x8000 + state->rombank * 0x8000; } static WRITE8_HANDLER( gekisha_p4_w ) { - gekisha_rom_enable = !(data & 0x08); - gekisha_set_rombank(space->machine, (data & 0x04) >> 2); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->gekisha_rom_enable = !BIT(data, 3); + gekisha_set_rombank(space->machine, BIT(data, 2)); } static READ8_HANDLER( gekisha_8000_r ) { - if (gekisha_rom_enable) - return gekisha_rom[offset]; + dynax_state *state = (dynax_state *)space->machine->driver_data; + + if (state->gekisha_rom_enable) + return state->gekisha_rom[offset]; switch (offset + 0x8000) { - case 0x8061: return input_port_read(space->machine, "COINS" ); + case 0x8061: return input_port_read(space->machine, "COINS"); case 0x8062: return gekisha_keyboard_1_r(space, 0); case 0x8063: return gekisha_keyboard_0_r(space, 0); - case 0x8064: return input_port_read(space->machine, "DSW1" ); - case 0x8065: return input_port_read(space->machine, "DSW3" ); - case 0x8066: return input_port_read(space->machine, "DSW4" ); - case 0x8067: return input_port_read(space->machine, "DSW2" ); + case 0x8064: return input_port_read(space->machine, "DSW1"); + case 0x8065: return input_port_read(space->machine, "DSW3"); + case 0x8066: return input_port_read(space->machine, "DSW4"); + case 0x8067: return input_port_read(space->machine, "DSW2"); } - logerror("%04x: unmapped offset %04X read with rombank=%02X\n",cpu_get_pc(space->cpu),offset,rombank); + logerror("%04x: unmapped offset %04X read with rombank=%02X\n",cpu_get_pc(space->cpu), offset, state->rombank); return 0x00; } static WRITE8_HANDLER( gekisha_8000_w ) { - if (!gekisha_rom_enable) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + if (!state->gekisha_rom_enable) { switch (offset + 0x8000) { @@ -1636,28 +1686,28 @@ static WRITE8_HANDLER( gekisha_8000_w ) case 0x8050: // CRT controller case 0x8051: return; - case 0x8070: ym2413_register_port_w(devtag_get_device(space->machine, "ymsnd"), 0, data); return; - case 0x8071: ym2413_data_port_w (devtag_get_device(space->machine, "ymsnd"), 0, data); return; + case 0x8070: ym2413_register_port_w(state->ymsnd, 0, data); return; + case 0x8071: ym2413_data_port_w(state->ymsnd, 0, data); return; - case 0x8060: keyb = data; return; + case 0x8060: state->keyb = data; return; // case 0x8080: // ? 0,1,6 (bit 0 = screen disable?) // popmessage("80 = %02x", data); // break; } } - logerror("%04x: unmapped offset %04X=%02X written with rombank=%02X\n",cpu_get_pc(space->cpu),offset,data,rombank); + logerror("%04x: unmapped offset %04X=%02X written with rombank=%02X\n", cpu_get_pc(space->cpu), offset, data, state->rombank); } static ADDRESS_MAP_START( gekisha_map, ADDRESS_SPACE_PROGRAM, 8 ) AM_RANGE( 0x0000, 0x6fff ) AM_ROM AM_RANGE( 0x7000, 0x7fff ) AM_RAM AM_BASE_SIZE_GENERIC(nvram) - AM_RANGE( 0x8000, 0xffff ) AM_READWRITE( gekisha_8000_r, gekisha_8000_w ) + AM_RANGE( 0x8000, 0xffff ) AM_READWRITE(gekisha_8000_r, gekisha_8000_w) ADDRESS_MAP_END static ADDRESS_MAP_START( gekisha_io_map, ADDRESS_SPACE_IO, 8 ) - AM_RANGE( T90_P4, T90_P4 ) AM_WRITE( gekisha_p4_w ) + AM_RANGE( T90_P4, T90_P4 ) AM_WRITE(gekisha_p4_w) ADDRESS_MAP_END @@ -1670,175 +1720,170 @@ ADDRESS_MAP_END ***************************************************************************/ static INPUT_PORTS_START( MAHJONG_KEYS ) - /* Keyboard 1 */ PORT_START("KEY0") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_A ) PORT_PLAYER(1) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_E ) PORT_PLAYER(1) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_I ) PORT_PLAYER(1) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_M ) PORT_PLAYER(1) - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_KAN ) PORT_PLAYER(1) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_START1 ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_A ) PORT_PLAYER(1) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_E ) PORT_PLAYER(1) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_I ) PORT_PLAYER(1) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_M ) PORT_PLAYER(1) + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_KAN ) PORT_PLAYER(1) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_START1 ) PORT_START("KEY1") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_B ) PORT_PLAYER(1) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_F ) PORT_PLAYER(1) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_J ) PORT_PLAYER(1) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_N ) PORT_PLAYER(1) - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_REACH ) PORT_PLAYER(1) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_B ) PORT_PLAYER(1) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_F ) PORT_PLAYER(1) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_J ) PORT_PLAYER(1) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_N ) PORT_PLAYER(1) + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_REACH ) PORT_PLAYER(1) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_START("KEY2") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_C ) PORT_PLAYER(1) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_G ) PORT_PLAYER(1) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_K ) PORT_PLAYER(1) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_CHI ) PORT_PLAYER(1) - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_RON ) PORT_PLAYER(1) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_C ) PORT_PLAYER(1) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_G ) PORT_PLAYER(1) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_K ) PORT_PLAYER(1) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_CHI ) PORT_PLAYER(1) + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_RON ) PORT_PLAYER(1) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_START("KEY3") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_D ) PORT_PLAYER(1) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_H ) PORT_PLAYER(1) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_L ) PORT_PLAYER(1) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_PON ) PORT_PLAYER(1) - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_D ) PORT_PLAYER(1) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_H ) PORT_PLAYER(1) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_L ) PORT_PLAYER(1) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_PON ) PORT_PLAYER(1) + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_START("KEY4") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_LAST_CHANCE ) PORT_PLAYER(1) // "l" - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_FLIP_FLOP ) PORT_PLAYER(1) // "f" - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_LAST_CHANCE ) PORT_PLAYER(1) // "l" + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_FLIP_FLOP ) PORT_PLAYER(1) // "f" + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) - /* Keyboard 2 */ PORT_START("KEY5") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_A ) PORT_PLAYER(2) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_E ) PORT_PLAYER(2) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_I ) PORT_PLAYER(2) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_M ) PORT_PLAYER(2) - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_KAN ) PORT_PLAYER(2) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_START2 ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_A ) PORT_PLAYER(2) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_E ) PORT_PLAYER(2) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_I ) PORT_PLAYER(2) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_M ) PORT_PLAYER(2) + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_KAN ) PORT_PLAYER(2) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_START2 ) PORT_START("KEY6") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_B ) PORT_PLAYER(2) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_F ) PORT_PLAYER(2) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_J ) PORT_PLAYER(2) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_N ) PORT_PLAYER(2) - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_REACH ) PORT_PLAYER(2) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_B ) PORT_PLAYER(2) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_F ) PORT_PLAYER(2) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_J ) PORT_PLAYER(2) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_N ) PORT_PLAYER(2) + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_REACH ) PORT_PLAYER(2) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_START("KEY7") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_C ) PORT_PLAYER(2) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_G ) PORT_PLAYER(2) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_K ) PORT_PLAYER(2) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_CHI ) PORT_PLAYER(2) - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_RON ) PORT_PLAYER(2) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_C ) PORT_PLAYER(2) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_G ) PORT_PLAYER(2) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_K ) PORT_PLAYER(2) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_CHI ) PORT_PLAYER(2) + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_RON ) PORT_PLAYER(2) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_START("KEY8") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_D ) PORT_PLAYER(2) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_H ) PORT_PLAYER(2) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_L ) PORT_PLAYER(2) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_PON ) PORT_PLAYER(2) - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_D ) PORT_PLAYER(2) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_H ) PORT_PLAYER(2) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_L ) PORT_PLAYER(2) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_PON ) PORT_PLAYER(2) + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_START("KEY9") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_LAST_CHANCE ) PORT_PLAYER(2) // "l" - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_FLIP_FLOP ) PORT_PLAYER(2) // "f" - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_LAST_CHANCE ) PORT_PLAYER(2) // "l" + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_FLIP_FLOP ) PORT_PLAYER(2) // "f" + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) INPUT_PORTS_END static INPUT_PORTS_START( MAHJONG_KEYS_BET ) - /* Keyboard 1 */ PORT_START("KEY0") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_A ) PORT_PLAYER(1) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_E ) PORT_PLAYER(1) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_I ) PORT_PLAYER(1) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_M ) PORT_PLAYER(1) - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_KAN ) PORT_PLAYER(1) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_START1 ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_A ) PORT_PLAYER(1) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_E ) PORT_PLAYER(1) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_I ) PORT_PLAYER(1) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_M ) PORT_PLAYER(1) + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_KAN ) PORT_PLAYER(1) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_START1 ) PORT_START("KEY1") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_B ) PORT_PLAYER(1) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_F ) PORT_PLAYER(1) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_J ) PORT_PLAYER(1) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_N ) PORT_PLAYER(1) - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_REACH ) PORT_PLAYER(1) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_MAHJONG_BET ) PORT_PLAYER(1) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_B ) PORT_PLAYER(1) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_F ) PORT_PLAYER(1) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_J ) PORT_PLAYER(1) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_N ) PORT_PLAYER(1) + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_REACH ) PORT_PLAYER(1) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_MAHJONG_BET ) PORT_PLAYER(1) PORT_START("KEY2") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_C ) PORT_PLAYER(1) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_G ) PORT_PLAYER(1) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_K ) PORT_PLAYER(1) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_CHI ) PORT_PLAYER(1) - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_RON ) PORT_PLAYER(1) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_C ) PORT_PLAYER(1) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_G ) PORT_PLAYER(1) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_K ) PORT_PLAYER(1) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_CHI ) PORT_PLAYER(1) + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_RON ) PORT_PLAYER(1) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_START("KEY3") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_D ) PORT_PLAYER(1) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_H ) PORT_PLAYER(1) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_L ) PORT_PLAYER(1) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_PON ) PORT_PLAYER(1) - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_D ) PORT_PLAYER(1) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_H ) PORT_PLAYER(1) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_L ) PORT_PLAYER(1) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_PON ) PORT_PLAYER(1) + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_START("KEY4") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_LAST_CHANCE ) PORT_PLAYER(1) // "l" - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_SCORE ) PORT_PLAYER(1) // "t" - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_DOUBLE_UP ) PORT_PLAYER(1) // "w" - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_FLIP_FLOP ) PORT_PLAYER(1) // "f" - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_BIG ) PORT_PLAYER(1) // "b" - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_MAHJONG_SMALL ) PORT_PLAYER(1) // "s" + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_LAST_CHANCE ) PORT_PLAYER(1) // "l" + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_SCORE ) PORT_PLAYER(1) // "t" + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_DOUBLE_UP ) PORT_PLAYER(1) // "w" + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_FLIP_FLOP ) PORT_PLAYER(1) // "f" + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_BIG ) PORT_PLAYER(1) // "b" + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_MAHJONG_SMALL ) PORT_PLAYER(1) // "s" - /* Keyboard 2 */ PORT_START("KEY5") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_A ) PORT_PLAYER(2) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_E ) PORT_PLAYER(2) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_I ) PORT_PLAYER(2) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_M ) PORT_PLAYER(2) - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_KAN ) PORT_PLAYER(2) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_START2 ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_A ) PORT_PLAYER(2) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_E ) PORT_PLAYER(2) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_I ) PORT_PLAYER(2) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_M ) PORT_PLAYER(2) + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_KAN ) PORT_PLAYER(2) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_START2 ) PORT_START("KEY6") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_B ) PORT_PLAYER(2) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_F ) PORT_PLAYER(2) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_J ) PORT_PLAYER(2) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_N ) PORT_PLAYER(2) - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_REACH ) PORT_PLAYER(2) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_MAHJONG_BET ) PORT_PLAYER(2) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_B ) PORT_PLAYER(2) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_F ) PORT_PLAYER(2) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_J ) PORT_PLAYER(2) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_N ) PORT_PLAYER(2) + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_REACH ) PORT_PLAYER(2) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_MAHJONG_BET ) PORT_PLAYER(2) PORT_START("KEY7") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_C ) PORT_PLAYER(2) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_G ) PORT_PLAYER(2) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_K ) PORT_PLAYER(2) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_CHI ) PORT_PLAYER(2) - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_RON ) PORT_PLAYER(2) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_C ) PORT_PLAYER(2) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_G ) PORT_PLAYER(2) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_K ) PORT_PLAYER(2) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_CHI ) PORT_PLAYER(2) + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_RON ) PORT_PLAYER(2) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_START("KEY8") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_D ) PORT_PLAYER(2) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_H ) PORT_PLAYER(2) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_L ) PORT_PLAYER(2) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_PON ) PORT_PLAYER(2) - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_D ) PORT_PLAYER(2) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_H ) PORT_PLAYER(2) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_L ) PORT_PLAYER(2) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_PON ) PORT_PLAYER(2) + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_START("KEY9") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_LAST_CHANCE ) PORT_PLAYER(2) // "l" - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_SCORE ) PORT_PLAYER(2) // "t" - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_DOUBLE_UP ) PORT_PLAYER(2) // "w" - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_FLIP_FLOP ) PORT_PLAYER(2) // "f" - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_BIG ) PORT_PLAYER(2) // "b" - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_MAHJONG_SMALL ) PORT_PLAYER(2) // "s" + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_MAHJONG_LAST_CHANCE ) PORT_PLAYER(2) // "l" + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_MAHJONG_SCORE ) PORT_PLAYER(2) // "t" + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_MAHJONG_DOUBLE_UP ) PORT_PLAYER(2) // "w" + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_MAHJONG_FLIP_FLOP ) PORT_PLAYER(2) // "f" + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_BIG ) PORT_PLAYER(2) // "b" + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_MAHJONG_SMALL ) PORT_PLAYER(2) // "s" INPUT_PORTS_END static INPUT_PORTS_START( HANAFUDA_KEYS ) - /* Keyboard 1 */ PORT_START("KEY0") PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_HANAFUDA_A ) PORT_PLAYER(1) PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_HANAFUDA_E ) PORT_PLAYER(1) @@ -1879,7 +1924,6 @@ static INPUT_PORTS_START( HANAFUDA_KEYS ) PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) - /* Keyboard 2 */ PORT_START("KEY5") PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_HANAFUDA_A ) PORT_PLAYER(2) PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_HANAFUDA_E ) PORT_PLAYER(2) @@ -1922,7 +1966,6 @@ static INPUT_PORTS_START( HANAFUDA_KEYS ) INPUT_PORTS_END static INPUT_PORTS_START( HANAFUDA_KEYS_BET ) - /* Keyboard 1 */ PORT_START("KEY0") PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_HANAFUDA_A ) PORT_PLAYER(1) PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_HANAFUDA_E ) PORT_PLAYER(1) @@ -1963,7 +2006,6 @@ static INPUT_PORTS_START( HANAFUDA_KEYS_BET ) PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_MAHJONG_BIG ) // "b" PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_MAHJONG_SMALL ) // "s" - /* Keyboard 2 */ PORT_START("KEY5") PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_HANAFUDA_A ) PORT_PLAYER(2) PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_HANAFUDA_E ) PORT_PLAYER(2) @@ -2006,7 +2048,6 @@ static INPUT_PORTS_START( HANAFUDA_KEYS_BET ) INPUT_PORTS_END static INPUT_PORTS_START( HANAFUDA_KEYS_BET_ALT ) - /* Keyboard 1 */ PORT_START("KEY0") PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_HANAFUDA_A ) PORT_PLAYER(1) PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_HANAFUDA_E ) PORT_PLAYER(1) @@ -2049,7 +2090,6 @@ static INPUT_PORTS_START( HANAFUDA_KEYS_BET_ALT ) PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN ) - /* Keyboard 2 */ PORT_START("KEY5") PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_HANAFUDA_A ) PORT_PLAYER(2) PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_HANAFUDA_E ) PORT_PLAYER(2) @@ -2146,14 +2186,14 @@ static INPUT_PORTS_START( hanamai ) PORT_DIPSETTING( 0x00, DEF_STR( On ) ) PORT_START("COINS") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME(DEF_STR( Test )) PORT_CODE(KEYCODE_F1) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_SERVICE2 ) // Analyzer - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_SERVICE3 ) // Memory Reset - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_COIN1 ) - PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_SERVICE1 ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME(DEF_STR( Test )) PORT_CODE(KEYCODE_F1) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_SERVICE2 ) // Analyzer + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_SERVICE3 ) // Memory Reset + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_COIN1 ) + PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_SERVICE1 ) PORT_INCLUDE( HANAFUDA_KEYS ) INPUT_PORTS_END @@ -2275,18 +2315,18 @@ static INPUT_PORTS_START( hnoridur ) PORT_DIPSETTING( 0x00, DEF_STR( On ) ) PORT_START("COINS") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME(DEF_STR( Test )) PORT_CODE(KEYCODE_F1) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_SERVICE2 ) // Analyzer - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_SERVICE3 ) // Memory Reset - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_COIN1 ) - PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_SERVICE1 ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME(DEF_STR( Test )) PORT_CODE(KEYCODE_F1) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_SERVICE2 ) // Analyzer + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_SERVICE3 ) // Memory Reset + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_COIN1 ) + PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_SERVICE1 ) PORT_INCLUDE( HANAFUDA_KEYS ) - PORT_START("DSW2") /* IN13 */ + PORT_START("DSW2") PORT_DIPNAME( 0x01, 0x01, DEF_STR( Unknown ) ) PORT_DIPSETTING( 0x01, DEF_STR( Off ) ) PORT_DIPSETTING( 0x00, DEF_STR( On ) ) @@ -2312,7 +2352,7 @@ static INPUT_PORTS_START( hnoridur ) PORT_DIPSETTING( 0x80, DEF_STR( Off ) ) PORT_DIPSETTING( 0x00, DEF_STR( On ) ) - PORT_START("DSW3") /* IN14 */ + PORT_START("DSW3") PORT_DIPNAME( 0x01, 0x01, DEF_STR( Unknown ) ) PORT_DIPSETTING( 0x01, DEF_STR( Off ) ) PORT_DIPSETTING( 0x00, DEF_STR( On ) ) @@ -2441,13 +2481,13 @@ static INPUT_PORTS_START( hjingi ) PORT_START("COINS") PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_GAMBLE_PAYOUT ) PORT_CODE(KEYCODE_4) // Pay - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_SERVICE4 ) // 18B - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME(DEF_STR( Test )) PORT_CODE(KEYCODE_F1) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_SERVICE2 ) // Analyzer - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_SERVICE3 ) // Memory Reset + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_SERVICE4 ) // 18B + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME(DEF_STR( Test )) PORT_CODE(KEYCODE_F1) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_SERVICE2 ) // Analyzer + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_SERVICE3 ) // Memory Reset PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_COIN2 ) // Key In - PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_COIN1 ) - PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_SERVICE1 ) // 18A + PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_COIN1 ) + PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_SERVICE1 ) // 18A PORT_INCLUDE( HANAFUDA_KEYS_BET ) // PORT_INCLUDE( HANAFUDA_KEYS_BET_ALT ) @@ -2843,16 +2883,15 @@ static INPUT_PORTS_START( quiztvqq ) PORT_SERVICE( 0x80, IP_ACTIVE_LOW ) PORT_START("COINS") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME(DEF_STR( Test )) PORT_CODE(KEYCODE_F1) // Test, during boot - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN ) - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_COIN2 ) - PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_COIN1 ) - PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME(DEF_STR( Test )) PORT_CODE(KEYCODE_F1) // Test, during boot + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_COIN2 ) + PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_COIN1 ) + PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN ) - /* Keyboard 1 */ PORT_START("KEY0") PORT_BIT(0x01, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_PLAYER(1) PORT_BIT(0x02, IP_ACTIVE_LOW, IPT_BUTTON2 ) PORT_PLAYER(1) @@ -2870,7 +2909,6 @@ static INPUT_PORTS_START( quiztvqq ) PORT_START("KEY4") PORT_BIT( 0x3f, IP_ACTIVE_LOW, IPT_UNKNOWN ) - /* Keyboard 2 */ PORT_START("KEY5") PORT_BIT(0x01, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_PLAYER(2) PORT_BIT(0x02, IP_ACTIVE_LOW, IPT_BUTTON2 ) PORT_PLAYER(2) @@ -3578,14 +3616,14 @@ static INPUT_PORTS_START( neruton ) PORT_DIPSETTING( 0x00, DEF_STR( On ) ) PORT_START("COINS") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_UNKNOWN ) // 17B - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_UNKNOWN ) // 18B - PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME(DEF_STR( Test )) PORT_CODE(KEYCODE_F1) // Test - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_SERVICE2 ) // Analyzer - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_SERVICE3 ) // Memory Reset - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) // 06B - PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_COIN1 ) // Coin - PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN ) // 18A + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_UNKNOWN ) // 17B + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_UNKNOWN ) // 18B + PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME(DEF_STR( Test )) PORT_CODE(KEYCODE_F1) // Test + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_SERVICE2 ) // Analyzer + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_SERVICE3 ) // Memory Reset + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_UNKNOWN ) // 06B + PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_COIN1 ) // Coin + PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN ) // 18A PORT_INCLUDE( MAHJONG_KEYS ) @@ -3888,14 +3926,14 @@ INPUT_PORTS_END static INPUT_PORTS_START( htengoku ) PORT_START("COINS") - PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_SERVICE4 ) // medal out - PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_SERVICE4 ) // medal out + PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_SERVICE ) PORT_NAME(DEF_STR( Test )) PORT_CODE(KEYCODE_F1) - PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_SERVICE2 ) // analyzer - PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_SERVICE3 ) // data clear - PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_COIN2 ) // note - PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_COIN1 ) - PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN ) + PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_SERVICE2 ) // analyzer + PORT_BIT( 0x10, IP_ACTIVE_LOW, IPT_SERVICE3 ) // data clear + PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_COIN2 ) // note + PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_COIN1 ) + PORT_BIT( 0x80, IP_ACTIVE_LOW, IPT_UNKNOWN ) PORT_INCLUDE( HANAFUDA_KEYS_BET ) @@ -4154,6 +4192,84 @@ INPUT_PORTS_END ***************************************************************************/ +static MACHINE_START( dynax ) +{ + dynax_state *state = (dynax_state *)machine->driver_data; + + state->maincpu = devtag_get_device(machine, "maincpu"); + state->soundcpu = devtag_get_device(machine, "soundcpu"); + state->rtc = devtag_get_device(machine, "rtc"); + state->ymsnd = devtag_get_device(machine, "ymsnd"); + + state_save_register_global(machine, state->sound_irq); + state_save_register_global(machine, state->vblank_irq); + state_save_register_global(machine, state->blitter_irq); + state_save_register_global(machine, state->blitter2_irq); + state_save_register_global(machine, state->soundlatch_irq); + state_save_register_global(machine, state->sound_vblank_irq); + + state_save_register_global(machine, state->input_sel); + state_save_register_global(machine, state->dsw_sel); + state_save_register_global(machine, state->keyb); + state_save_register_global(machine, state->coins); + state_save_register_global(machine, state->hopper); + state_save_register_global(machine, state->hnoridur_bank); + state_save_register_global(machine, state->palbank); + state_save_register_global(machine, state->msm5205next); + state_save_register_global(machine, state->resetkludge); + state_save_register_global(machine, state->toggle); + state_save_register_global(machine, state->toggle_cpu1); + state_save_register_global(machine, state->yarunara_clk_toggle); + state_save_register_global(machine, state->soundlatch_ack); + state_save_register_global(machine, state->soundlatch_full); + state_save_register_global(machine, state->latch); + state_save_register_global(machine, state->rombank); + state_save_register_global(machine, state->tenkai_p5_val); + state_save_register_global(machine, state->tenkai_6c); + state_save_register_global(machine, state->tenkai_70); + state_save_register_global_array(machine, state->gekisha_val); + state_save_register_global(machine, state->gekisha_rom_enable); +} + +static MACHINE_RESET( dynax ) +{ + dynax_state *state = (dynax_state *)machine->driver_data; + + if (devtag_get_device(machine, "msm") != NULL) + MACHINE_RESET_CALL(adpcm); + + state->sound_irq = 0; + state->vblank_irq = 0; + state->blitter_irq = 0; + state->blitter2_irq = 0; + state->soundlatch_irq = 0; + state->sound_vblank_irq = 0; + + state->input_sel = 0; + state->dsw_sel = 0; + state->keyb = 0; + state->coins = 0; + state->hopper = 0; + state->hnoridur_bank = 0; + state->palbank = 0; + state->msm5205next = 0; + state->resetkludge = 0; + state->toggle = 0; + state->toggle_cpu1 = 0; + state->yarunara_clk_toggle = 0; + state->soundlatch_ack = 0; + state->soundlatch_full = 0; + state->latch = 0; + state->rombank = 0; + state->tenkai_p5_val = 0; + state->tenkai_6c = 0; + state->tenkai_70 = 0; + state->gekisha_val[0] = 0; + state->gekisha_val[1] = 0; + state->gekisha_rom_enable = 0; +} + + /*************************************************************************** Hana no Mai ***************************************************************************/ @@ -4181,13 +4297,17 @@ static const msm5205_interface hanamai_msm5205_interface = static MACHINE_DRIVER_START( hanamai ) + /* driver data */ + MDRV_DRIVER_DATA(dynax_state) + /* basic machine hardware */ MDRV_CPU_ADD("maincpu",Z80,22000000 / 4) /* 5.5MHz */ MDRV_CPU_PROGRAM_MAP(sprtmtch_mem_map) MDRV_CPU_IO_MAP(hanamai_io_map) MDRV_CPU_VBLANK_INT("screen", sprtmtch_vblank_interrupt) /* IM 0 needs an opcode on the data bus */ - MDRV_MACHINE_RESET(adpcm) + MDRV_MACHINE_START(dynax) + MDRV_MACHINE_RESET(dynax) MDRV_NVRAM_HANDLER(generic_0fill) @@ -4238,13 +4358,17 @@ static const ay8910_interface hnoridur_ay8910_interface = static MACHINE_DRIVER_START( hnoridur ) + /* driver data */ + MDRV_DRIVER_DATA(dynax_state) + /* basic machine hardware */ MDRV_CPU_ADD("maincpu",Z80,22000000 / 4) /* 5.5MHz */ MDRV_CPU_PROGRAM_MAP(hnoridur_mem_map) MDRV_CPU_IO_MAP(hnoridur_io_map) MDRV_CPU_VBLANK_INT("screen", sprtmtch_vblank_interrupt) /* IM 0 needs an opcode on the data bus */ - MDRV_MACHINE_RESET(adpcm) + MDRV_MACHINE_START(dynax) + MDRV_MACHINE_RESET(dynax) MDRV_NVRAM_HANDLER(generic_0fill) @@ -4283,13 +4407,17 @@ MACHINE_DRIVER_END static MACHINE_DRIVER_START( hjingi ) + /* driver data */ + MDRV_DRIVER_DATA(dynax_state) + /* basic machine hardware */ MDRV_CPU_ADD("maincpu",Z80, XTAL_22MHz / 4) MDRV_CPU_PROGRAM_MAP(hjingi_mem_map) MDRV_CPU_IO_MAP(hjingi_io_map) MDRV_CPU_VBLANK_INT("screen", sprtmtch_vblank_interrupt) /* IM 0 needs an opcode on the data bus */ - MDRV_MACHINE_RESET(adpcm) + MDRV_MACHINE_START(dynax) + MDRV_MACHINE_RESET(dynax) MDRV_NVRAM_HANDLER(generic_0fill) @@ -4341,12 +4469,18 @@ static const ym2203_interface sprtmtch_ym2203_interface = static MACHINE_DRIVER_START( sprtmtch ) + /* driver data */ + MDRV_DRIVER_DATA(dynax_state) + /* basic machine hardware */ MDRV_CPU_ADD("maincpu", Z80,22000000 / 4) /* 5.5MHz */ MDRV_CPU_PROGRAM_MAP(sprtmtch_mem_map) MDRV_CPU_IO_MAP(sprtmtch_io_map) MDRV_CPU_VBLANK_INT("screen", sprtmtch_vblank_interrupt) /* IM 0 needs an opcode on the data bus */ + MDRV_MACHINE_START(dynax) + MDRV_MACHINE_RESET(dynax) + MDRV_NVRAM_HANDLER(generic_0fill) /* video hardware */ @@ -4381,12 +4515,18 @@ MACHINE_DRIVER_END static MACHINE_DRIVER_START( mjfriday ) + /* driver data */ + MDRV_DRIVER_DATA(dynax_state) + /* basic machine hardware */ MDRV_CPU_ADD("maincpu",Z80,24000000/4) /* 6 MHz? */ MDRV_CPU_PROGRAM_MAP(sprtmtch_mem_map) MDRV_CPU_IO_MAP(mjfriday_io_map) MDRV_CPU_VBLANK_INT("screen", irq0_line_hold) + MDRV_MACHINE_START(dynax) + MDRV_MACHINE_RESET(dynax) + MDRV_NVRAM_HANDLER(generic_0fill) /* video hardware */ @@ -4434,17 +4574,13 @@ MACHINE_DRIVER_END static INTERRUPT_GEN( yarunara_clock_interrupt ) { - static int i=0; - i^=1; + dynax_state *state = (dynax_state *)device->machine->driver_data; + state->yarunara_clk_toggle ^= 1; - if (i==1) - { - dynax_sound_irq = 0; - } + if (state->yarunara_clk_toggle == 1) + state->sound_irq = 0; else - { - dynax_sound_irq = 1; - } + state->sound_irq = 1; sprtmtch_update_irq(device->machine); } @@ -4519,8 +4655,22 @@ static const msm5205_interface jantouki_msm5205_interface = MSM5205_S48_4B /* 8 KHz, 4 Bits */ }; +static MACHINE_START( jantouki ) +{ + dynax_state *state = (dynax_state *)machine->driver_data; + + state->top_scr = devtag_get_device(machine, "top"); + state->bot_scr = devtag_get_device(machine, "bottom"); + + MACHINE_START_CALL(dynax); +} + + static MACHINE_DRIVER_START( jantouki ) + /* driver data */ + MDRV_DRIVER_DATA(dynax_state) + /* basic machine hardware */ MDRV_CPU_ADD("maincpu",Z80,22000000 / 4) /* 5.5MHz */ MDRV_CPU_PROGRAM_MAP(jantouki_mem_map) @@ -4532,7 +4682,8 @@ static MACHINE_DRIVER_START( jantouki ) MDRV_CPU_IO_MAP(jantouki_sound_io_map) MDRV_CPU_VBLANK_INT("top", jantouki_sound_vblank_interrupt) /* IM 0 needs an opcode on the data bus */ - MDRV_MACHINE_RESET(adpcm) + MDRV_MACHINE_START(jantouki) + MDRV_MACHINE_RESET(dynax) MDRV_NVRAM_HANDLER(generic_0fill) @@ -4587,17 +4738,20 @@ MACHINE_DRIVER_END /* It runs in IM 2, thus needs a vector on the data bus: 0xfa and 0xfc are very similar, they should be triggered by the blitter 0xf8 is vblank */ -void mjelctrn_update_irq(running_machine *machine) +void mjelctrn_update_irq( running_machine *machine ) { - dynax_blitter_irq = 1; - cputag_set_input_line_and_vector(machine, "maincpu", 0, HOLD_LINE, 0xfa); + dynax_state *state = (dynax_state *)machine->driver_data; + state->blitter_irq = 1; + cpu_set_input_line_and_vector(state->maincpu, 0, HOLD_LINE, 0xfa); } static INTERRUPT_GEN( mjelctrn_vblank_interrupt ) { + dynax_state *state = (dynax_state *)device->machine->driver_data; + // This is a kludge to avoid losing blitter interrupts // there should be a vblank ack mechanism - if (!dynax_blitter_irq) + if (!state->blitter_irq) cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0xf8); } @@ -4621,22 +4775,25 @@ MACHINE_DRIVER_END 0x42 and 0x44 are very similar, they should be triggered by the blitter 0x40 is vblank 0x46 is a periodic irq? */ -void neruton_update_irq(running_machine *machine) +void neruton_update_irq( running_machine *machine ) { - dynax_blitter_irq = 1; - cputag_set_input_line_and_vector(machine, "maincpu", 0, HOLD_LINE, 0x42); + dynax_state *state = (dynax_state *)machine->driver_data; + state->blitter_irq = 1; + cpu_set_input_line_and_vector(state->maincpu, 0, HOLD_LINE, 0x42); } static INTERRUPT_GEN( neruton_vblank_interrupt ) { + dynax_state *state = (dynax_state *)device->machine->driver_data; + // This is a kludge to avoid losing blitter interrupts // there should be a vblank ack mechanism - if (dynax_blitter_irq) return; + if (state->blitter_irq) return; - switch(cpu_getiloops(device)) + switch (cpu_getiloops(device)) { - case 0: cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0x40); break; - default: cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0x46); + case 0: cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0x40); break; + default: cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0x46); break; } } @@ -4658,9 +4815,11 @@ MACHINE_DRIVER_END 0x40 is vblank */ static INTERRUPT_GEN( majxtal7_vblank_interrupt ) { + dynax_state *state = (dynax_state *)device->machine->driver_data; + // This is a kludge to avoid losing blitter interrupts // there should be a vblank ack mechanism - if (dynax_blitter_irq) return; + if (state->blitter_irq) return; cpu_set_input_line_and_vector(device, 0, HOLD_LINE, 0x40); } @@ -4689,6 +4848,9 @@ static const ay8910_interface htengoku_ay8910_interface = static MACHINE_DRIVER_START( htengoku ) + /* driver data */ + MDRV_DRIVER_DATA(dynax_state) + /* basic machine hardware */ MDRV_CPU_ADD("maincpu",Z80,20000000 / 4) MDRV_CPU_PROGRAM_MAP(yarunara_mem_map) @@ -4696,6 +4858,9 @@ static MACHINE_DRIVER_START( htengoku ) MDRV_CPU_VBLANK_INT("screen", sprtmtch_vblank_interrupt) /* IM 0 needs an opcode on the data bus */ MDRV_CPU_PERIODIC_INT(yarunara_clock_interrupt, 60) // RTC + MDRV_MACHINE_START(dynax) + MDRV_MACHINE_RESET(dynax) + MDRV_NVRAM_HANDLER(generic_0fill) /* video hardware */ @@ -4733,11 +4898,11 @@ MACHINE_DRIVER_END static INTERRUPT_GEN( tenkai_interrupt ) { - switch(cpu_getiloops(device)) + switch (cpu_getiloops(device)) { - case 0: cpu_set_input_line(device, INPUT_LINE_IRQ0, HOLD_LINE); break; - case 1: cpu_set_input_line(device, INPUT_LINE_IRQ1, HOLD_LINE); break; - case 2: cpu_set_input_line(device, INPUT_LINE_IRQ2, HOLD_LINE); break; + case 0: cpu_set_input_line(device, INPUT_LINE_IRQ0, HOLD_LINE); break; + case 1: cpu_set_input_line(device, INPUT_LINE_IRQ1, HOLD_LINE); break; + case 2: cpu_set_input_line(device, INPUT_LINE_IRQ2, HOLD_LINE); break; } } @@ -4752,12 +4917,18 @@ static const ay8910_interface tenkai_ay8910_interface = static MACHINE_DRIVER_START( tenkai ) + /* driver data */ + MDRV_DRIVER_DATA(dynax_state) + /* basic machine hardware */ MDRV_CPU_ADD("maincpu",TMP91640, 21472700 / 2) MDRV_CPU_PROGRAM_MAP(tenkai_map) MDRV_CPU_IO_MAP(tenkai_io_map) MDRV_CPU_VBLANK_INT_HACK(tenkai_interrupt,3) + MDRV_MACHINE_START(dynax) + MDRV_MACHINE_RESET(dynax) + MDRV_NVRAM_HANDLER(generic_0fill) /* video hardware */ @@ -4799,17 +4970,23 @@ MACHINE_DRIVER_END static MACHINE_RESET( gekisha ) { + MACHINE_RESET_CALL(dynax); + gekisha_set_rombank(machine, 0); } static MACHINE_DRIVER_START( gekisha ) + /* driver data */ + MDRV_DRIVER_DATA(dynax_state) + /* basic machine hardware */ MDRV_CPU_ADD("maincpu",TMP90841, XTAL_10MHz ) // ? MDRV_CPU_PROGRAM_MAP(gekisha_map) MDRV_CPU_IO_MAP(gekisha_io_map) MDRV_CPU_VBLANK_INT("screen", irq0_line_hold) + MDRV_MACHINE_START(dynax) MDRV_MACHINE_RESET(gekisha) MDRV_NVRAM_HANDLER(generic_0fill) @@ -5183,17 +5360,17 @@ static DRIVER_INIT( blktouch ) UINT8 *src = (UINT8 *)memory_region(machine, "maincpu"); int i; - for (i=0;i<0x90000;i++) + for (i = 0; i < 0x90000; i++) { - src[i] = BITSWAP8(src[i],7,6,5,3,4,2,1,0); + src[i] = BITSWAP8(src[i], 7, 6, 5, 3, 4, 2, 1, 0); } src = (UINT8 *)memory_region(machine, "gfx1"); - for (i=0;i<0xc0000;i++) + for (i = 0; i < 0xc0000; i++) { - src[i] = BITSWAP8(src[i],7,6,5,3,4,2,1,0); + src[i] = BITSWAP8(src[i], 7, 6, 5, 3, 4, 2, 1, 0); } } @@ -5203,9 +5380,8 @@ static DRIVER_INIT( maya ) /* Address lines scrambling on 1 z80 rom */ int i; UINT8 *gfx = (UINT8 *)memory_region(machine, "gfx1"); - UINT8 *rom = memory_region(machine, "maincpu") + 0x28000, - *end = rom + 0x10000; - for (;rom < end; rom+=8) + UINT8 *rom = memory_region(machine, "maincpu") + 0x28000, *end = rom + 0x10000; + for ( ; rom < end; rom += 8) { UINT8 temp[8]; temp[0] = rom[0]; temp[1] = rom[1]; temp[2] = rom[2]; temp[3] = rom[3]; @@ -5925,7 +6101,7 @@ static DRIVER_INIT( mjelct3 ) size_t size = memory_region_length(machine, "maincpu"); UINT8 *rom1 = auto_alloc_array(machine, UINT8, size); - memcpy(rom1,rom,size); + memcpy(rom1, rom, size); for (i = 0; i < size; i++) rom[i] = BITSWAP8(rom1[BITSWAP24(i,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8, 1,6,5,4,3,2,7, 0)], 7,6, 1,4,3,2,5,0); auto_free(machine, rom1); @@ -5933,12 +6109,12 @@ static DRIVER_INIT( mjelct3 ) static DRIVER_INIT( mjelct3a ) { - int i,j; + int i, j; UINT8 *rom = memory_region(machine, "maincpu"); size_t size = memory_region_length(machine, "maincpu"); UINT8 *rom1 = auto_alloc_array(machine, UINT8, size); - memcpy(rom1,rom,size); + memcpy(rom1, rom, size); for (i = 0; i < size; i++) { j = i & ~0x7e00; diff --git a/src/mame/includes/dynax.h b/src/mame/includes/dynax.h index bd25cd40666..0fb012a8528 100644 --- a/src/mame/includes/dynax.h +++ b/src/mame/includes/dynax.h @@ -4,9 +4,130 @@ ***************************************************************************/ -//----------- defined in drivers/dynax.c ----------- +class dynax_state +{ +public: + static void *alloc(running_machine &machine) { return auto_alloc_clear(&machine, dynax_state(machine)); } -extern UINT8 dynax_blitter_irq, dynax_blitter2_irq; + dynax_state(running_machine &machine) { } + + // up to 8 layers, 2 images per layer (interleaved on screen) + UINT8 * pixmap[8][2]; + UINT8 * ddenlovr_pixmap[8]; + + /* irq */ + void (*update_irq_func)(running_machine *machine); // some games trigger IRQ at blitter end, some don't + UINT8 sound_irq; + UINT8 vblank_irq; + UINT8 blitter_irq, blitter2_irq; + UINT8 soundlatch_irq; + UINT8 sound_vblank_irq; + + /* blitters */ + int blit_scroll_x, blit2_scroll_x; + int blit_scroll_y, blit2_scroll_y; + int blit_wrap_enable, blit2_wrap_enable; + int blit_x, blit_y, blit2_x, blit2_y; + int blit_src, blit2_src; + int blit_romregion, blit2_romregion; + int blit_dest, blit2_dest; + int blit_pen, blit2_pen; + int blit_palbank, blit2_palbank; + int blit_palettes, blit2_palettes; + int layer_enable; + int blit_backpen; + + int hanamai_layer_half; + int hnoridur_layer_half2; + + int extra_scroll_x, extra_scroll_y; + int flipscreen; + + int layer_layout; + + const int *priority_table; + int hanamai_priority; + + /* ddenlovr blitter (TODO: merge with the above, where possible) */ + int extra_layers; + int ddenlovr_dest_layer; + int ddenlovr_blit_flip; + int ddenlovr_blit_x; + int ddenlovr_blit_y; + int ddenlovr_blit_address; + int ddenlovr_blit_pen,ddenlovr_blit_pen_mode; + int ddenlovr_blitter_irq_flag,ddenlovr_blitter_irq_enable; + int ddenlovr_rect_width, ddenlovr_rect_height; + int ddenlovr_clip_width, ddenlovr_clip_height; + int ddenlovr_line_length; + int ddenlovr_clip_ctrl,ddenlovr_clip_x,ddenlovr_clip_y; + int ddenlovr_scroll[8*2]; + int ddenlovr_priority, ddenlovr_priority2; + int ddenlovr_bgcolor, ddenlovr_bgcolor2; + int ddenlovr_layer_enable, ddenlovr_layer_enable2; + int ddenlovr_palette_base[8], ddenlovr_palette_mask[8]; + int ddenlovr_transparency_pen[8], ddenlovr_transparency_mask[8]; + int ddenlovr_blit_latch; + int ddenlovr_blit_pen_mask; // not implemented + int ddenlovr_blit_rom_bits; // usually 8, 16 in hanakanz + const int *ddenlovr_blit_commands; + int ddenlovr_blit_regs[2]; + + /* input */ + UINT8 input_sel, dsw_sel, keyb, coins, hopper; + + /* misc */ + int hnoridur_bank; + UINT8 palette_ram[16*256*2]; + int palbank; + int msm5205next; + int resetkludge; + int toggle, toggle_cpu1; + int yarunara_clk_toggle; + UINT8 soundlatch_ack; + UINT8 soundlatch_full; + UINT8 latch; + int rombank; + UINT8 *romptr; + UINT8 tenkai_p5_val; + int tenkai_6c, tenkai_70; + UINT8 gekisha_val[2]; + UINT8 gekisha_rom_enable; + UINT8 *gekisha_rom; + + /* ddenlovr misc (TODO: merge with the above, where possible) */ + UINT8 palram[0x200]; + int okibank; + UINT8 rongrong_blitter_busy_select; + + UINT16 *dsw_sel16; + UINT16 *protection1, *protection2; + UINT8 prot_val; + UINT16 prot_16; + UINT16 quiz365_protection[2]; + + UINT16 mmpanic_leds; /* A led for each of the 9 buttons */ + UINT8 funkyfig_lockout; + UINT8 romdata[2]; + int palette_index; + UINT8 hginga_rombank; + UINT8 mjflove_irq_cause; + UINT8 daimyojn_palette_sel; + + int irq_count; + + + /* devices */ + running_device *maincpu; + running_device *soundcpu; + running_device *rtc; + running_device *ymsnd; + running_device *oki; + running_device *top_scr; + running_device *bot_scr; +}; + +//----------- defined in drivers/dynax.c ----------- void sprtmtch_update_irq(running_machine *machine); void jantouki_update_irq(running_machine *machine); @@ -76,21 +197,12 @@ PALETTE_INIT( sprtmtch ); //----------- defined in drivers/ddenlovr.c ----------- WRITE8_HANDLER( ddenlovr_bgcolor_w ); - WRITE8_HANDLER( ddenlovr_priority_w ); - WRITE8_HANDLER( ddenlovr_layer_enable_w ); - WRITE8_HANDLER( ddenlovr_palette_base_w ); - WRITE8_HANDLER( ddenlovr_palette_mask_w ); - WRITE8_HANDLER( ddenlovr_transparency_pen_w ); - WRITE8_HANDLER( ddenlovr_transparency_mask_w ); -extern UINT8 *ddenlovr_pixmap[8]; - VIDEO_START(ddenlovr); VIDEO_UPDATE(ddenlovr); - diff --git a/src/mame/video/dynax.c b/src/mame/video/dynax.c index ceaa5258cdb..2f60dc995d2 100644 --- a/src/mame/video/dynax.c +++ b/src/mame/video/dynax.c @@ -30,14 +30,14 @@ PALETTE_INIT( sprtmtch ) { int i; - for (i = 0;i < machine->config->total_colors;i++) + for (i = 0; i < machine->config->total_colors; i++) { - int x = (color_prom[i]<<8) + color_prom[0x200+i]; + int x = (color_prom[i] << 8) + color_prom[0x200 + i]; /* The bits are in reverse order! */ - int r = BITSWAP8((x >> 0) & 0x1f, 7,6,5, 0,1,2,3,4 ); - int g = BITSWAP8((x >> 5) & 0x1f, 7,6,5, 0,1,2,3,4 ); - int b = BITSWAP8((x >> 10) & 0x1f, 7,6,5, 0,1,2,3,4 ); - palette_set_color_rgb(machine,i,pal5bit(r),pal5bit(g),pal5bit(b)); + int r = BITSWAP8((x >> 0) & 0x1f, 7, 6, 5, 0, 1, 2, 3, 4); + int g = BITSWAP8((x >> 5) & 0x1f, 7, 6, 5, 0, 1, 2, 3, 4); + int b = BITSWAP8((x >> 10) & 0x1f, 7, 6, 5, 0, 1, 2, 3, 4); + palette_set_color_rgb(machine, i, pal5bit(r), pal5bit(g), pal5bit(b)); } } @@ -49,204 +49,218 @@ PALETTE_INIT( sprtmtch ) ***************************************************************************/ - -static int dynax_blit_scroll_x, dynax_blit2_scroll_x; -static int dynax_blit_scroll_y, dynax_blit2_scroll_y; -static int dynax_blit_wrap_enable, dynax_blit2_wrap_enable; -static int blit_x,blit_y, blit2_x,blit2_y; -static int blit_src, blit2_src; -static const char * dynax_blit_romregion, *dynax_blit2_romregion; -static int dynax_blit_dest, dynax_blit2_dest; -static int dynax_blit_pen, dynax_blit2_pen; -static int dynax_blit_palbank, dynax_blit2_palbank; -static int dynax_blit_palettes, dynax_blit2_palettes; -static int dynax_layer_enable; -static int dynax_blit_backpen; - -static int hanamai_layer_half; -static int hnoridur_layer_half2; - -static int extra_scroll_x,extra_scroll_y; -static int flipscreen; - #define LAYOUT_HANAMAI 0 // 4 layers, interleaved #define LAYOUT_HNORIDUR 1 // same as hanamai but some bits are inverted and layer order is reversed #define LAYOUT_DRGPUNCH 2 // 3 couples of layers, interleaved #define LAYOUT_MJDIALQ2 3 // 2 layers #define LAYOUT_JANTOUKI 4 // 2 x (4 couples of layers, interleaved) -static int layer_layout; - -static void (*update_irq_func)(running_machine *machine); // some games trigger IRQ at blitter end, some don't - -// up to 8 layers, 2 images per layer (interleaved on screen) -static UINT8 *dynax_pixmap[8][2]; - - - WRITE8_HANDLER( dynax_extra_scrollx_w ) { - extra_scroll_x = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->extra_scroll_x = data; } WRITE8_HANDLER( dynax_extra_scrolly_w ) { - extra_scroll_y = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->extra_scroll_y = data; } /* Destination Pen */ WRITE8_HANDLER( dynax_blit_pen_w ) { - dynax_blit_pen = data; - LOG(("P=%02X ",data)); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->blit_pen = data; + LOG(("P=%02X ", data)); } + WRITE8_HANDLER( dynax_blit2_pen_w ) { - dynax_blit2_pen = data; - LOG(("P'=%02X ",data)); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->blit2_pen = data; + LOG(("P'=%02X ", data)); } + /* Destination Layers */ WRITE8_HANDLER( dynax_blit_dest_w ) { - dynax_blit_dest = data; - if (layer_layout == LAYOUT_HNORIDUR) - dynax_blit_dest = BITSWAP8(dynax_blit_dest ^ 0x0f, 7,6,5,4, 0,1,2,3); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->blit_dest = data; + if (state->layer_layout == LAYOUT_HNORIDUR) + state->blit_dest = BITSWAP8(state->blit_dest ^ 0x0f, 7, 6, 5, 4, 0, 1, 2, 3); - LOG(("D=%02X ",data)); + LOG(("D=%02X ", data)); } + WRITE8_HANDLER( dynax_blit2_dest_w ) { - dynax_blit2_dest = data; - LOG(("D'=%02X ",data)); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->blit2_dest = data; + LOG(("D'=%02X ", data)); } + WRITE8_HANDLER( tenkai_blit_dest_w ) { - dynax_blit_dest_w(space, 0, BITSWAP8(data, 7,6,5,4, 0,1,2,3)); + dynax_blit_dest_w(space, 0, BITSWAP8(data, 7, 6, 5, 4, 0, 1, 2, 3)); } + /* Background Color */ WRITE8_HANDLER( dynax_blit_backpen_w ) { - dynax_blit_backpen = data; - LOG(("B=%02X ",data)); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->blit_backpen = data; + LOG(("B=%02X ", data)); } + /* Layers 0&1 Palettes (Low Bits) */ WRITE8_HANDLER( dynax_blit_palette01_w ) { - if (layer_layout == LAYOUT_HNORIDUR) - dynax_blit_palettes = (dynax_blit_palettes & 0x00ff) | ((data&0x0f)<<12) | ((data&0xf0)<<4); + dynax_state *state = (dynax_state *)space->machine->driver_data; + if (state->layer_layout == LAYOUT_HNORIDUR) + state->blit_palettes = (state->blit_palettes & 0x00ff) | ((data & 0x0f) << 12) | ((data & 0xf0) << 4); else - dynax_blit_palettes = (dynax_blit_palettes & 0xff00) | data; - LOG(("P01=%02X ",data)); + state->blit_palettes = (state->blit_palettes & 0xff00) | data; + LOG(("P01=%02X ", data)); } + WRITE8_HANDLER( tenkai_blit_palette01_w ) { - dynax_blit_palettes = (dynax_blit_palettes & 0xff00) | data; - LOG(("P01=%02X ",data)); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->blit_palettes = (state->blit_palettes & 0xff00) | data; + LOG(("P01=%02X ", data)); } + /* Layers 4&5 Palettes (Low Bits) */ WRITE8_HANDLER( dynax_blit_palette45_w ) { - if (layer_layout == LAYOUT_HNORIDUR) - dynax_blit2_palettes = (dynax_blit2_palettes & 0x00ff) | ((data&0x0f)<<12) | ((data&0xf0)<<4); + dynax_state *state = (dynax_state *)space->machine->driver_data; + + if (state->layer_layout == LAYOUT_HNORIDUR) + state->blit2_palettes = (state->blit2_palettes & 0x00ff) | ((data & 0x0f) << 12) | ((data & 0xf0) << 4); else - dynax_blit2_palettes = (dynax_blit2_palettes & 0xff00) | data; - LOG(("P45=%02X ",data)); + state->blit2_palettes = (state->blit2_palettes & 0xff00) | data; + LOG(("P45=%02X ", data)); } + /* Layer 2&3 Palettes (Low Bits) */ WRITE8_HANDLER( dynax_blit_palette23_w ) { - if (layer_layout == LAYOUT_HNORIDUR) - dynax_blit_palettes = (dynax_blit_palettes & 0xff00) | ((data&0x0f)<<4) | ((data&0xf0)>>4); + dynax_state *state = (dynax_state *)space->machine->driver_data; + + if (state->layer_layout == LAYOUT_HNORIDUR) + state->blit_palettes = (state->blit_palettes & 0xff00) | ((data & 0x0f) << 4) | ((data & 0xf0) >> 4); else - dynax_blit_palettes = (dynax_blit_palettes & 0x00ff) | (data<<8); - LOG(("P23=%02X ",data)); + state->blit_palettes = (state->blit_palettes & 0x00ff) | (data << 8); + LOG(("P23=%02X ", data)); } + WRITE8_HANDLER( tenkai_blit_palette23_w ) { - dynax_blit_palettes = (dynax_blit_palettes & 0x00ff) | ((data&0x0f)<<12) | ((data&0xf0)<<4); - LOG(("P23=%02X ",data)); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->blit_palettes = (state->blit_palettes & 0x00ff) | ((data & 0x0f) << 12) | ((data & 0xf0) << 4); + LOG(("P23=%02X ", data)); } + + /* Layer 6&7 Palettes (Low Bits) */ WRITE8_HANDLER( dynax_blit_palette67_w ) { - if (layer_layout == LAYOUT_HNORIDUR) - dynax_blit2_palettes = (dynax_blit2_palettes & 0xff00) | ((data&0x0f)<<4) | ((data&0xf0)>>4); - else - dynax_blit2_palettes = (dynax_blit2_palettes & 0x00ff) | (data<<8); - LOG(("P67=%02X ",data)); -} + dynax_state *state = (dynax_state *)space->machine->driver_data; + if (state->layer_layout == LAYOUT_HNORIDUR) + state->blit2_palettes = (state->blit2_palettes & 0xff00) | ((data & 0x0f) << 4) | ((data & 0xf0) >> 4); + else + state->blit2_palettes = (state->blit2_palettes & 0x00ff) | (data << 8); + LOG(("P67=%02X ", data)); +} /* Layers Palettes (High Bits) */ WRITE8_HANDLER( dynax_blit_palbank_w ) { - dynax_blit_palbank = data; - LOG(("PB=%02X ",data)); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->blit_palbank = data; + LOG(("PB=%02X ", data)); } + WRITE8_HANDLER( dynax_blit2_palbank_w ) { - dynax_blit2_palbank = data; - LOG(("PB'=%02X ",data)); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->blit2_palbank = data; + LOG(("PB'=%02X ", data)); } + /* Which half of the layers to write two (interleaved games only) */ WRITE8_HANDLER( hanamai_layer_half_w ) { - hanamai_layer_half = (~data) & 1; - LOG(("H=%02X ",data)); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->hanamai_layer_half = (~data) & 1; + LOG(("H=%02X ", data)); } + /* Write to both halves of the layers (interleaved games only) */ WRITE8_HANDLER( hnoridur_layer_half2_w ) { - hnoridur_layer_half2 = (~data) & 1; - LOG(("H2=%02X ",data)); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->hnoridur_layer_half2 = (~data) & 1; + LOG(("H2=%02X ", data)); } WRITE8_HANDLER( mjdialq2_blit_dest_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; int mask = (2 >> offset); /* 1 or 2 */ - dynax_blit_dest &= ~mask; - if (~data & 1) dynax_blit_dest |= mask; + state->blit_dest &= ~mask; + + if (~data & 1) + state->blit_dest |= mask; } + /* Layers Enable */ WRITE8_HANDLER( dynax_layer_enable_w ) { - dynax_layer_enable = data; - LOG(("E=%02X ",data)); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->layer_enable = data; + LOG(("E=%02X ", data)); } WRITE8_HANDLER( jantouki_layer_enable_w ) { - int mask = 1 << (7-offset); - dynax_layer_enable = (dynax_layer_enable & ~mask) | ((data & 1) ? mask : 0); - dynax_layer_enable |= 1; + dynax_state *state = (dynax_state *)space->machine->driver_data; + int mask = 1 << (7 - offset); + state->layer_enable = (state->layer_enable & ~mask) | ((data & 1) ? mask : 0); + state->layer_enable |= 1; } WRITE8_HANDLER( mjdialq2_layer_enable_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; int mask = (2 >> offset); /* 1 or 2 */ - dynax_layer_enable &= ~mask; - if (~data & 1) dynax_layer_enable |= mask; + state->layer_enable &= ~mask; + if (~data & 1) + state->layer_enable |= mask; } WRITE8_HANDLER( dynax_flipscreen_w ) { - flipscreen = data & 1; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->flipscreen = data & 1; if (data & ~1) logerror("CPU#0 PC %06X: Warning, flip screen <- %02X\n", cpu_get_pc(space->cpu), data); - LOG(("F=%02X ",data)); + LOG(("F=%02X ", data)); } @@ -254,16 +268,18 @@ static const char *const gfxregions[] = { "gfx1", "gfx2", "gfx3", "gfx4", "gfx5" WRITE8_HANDLER( dynax_blit_romregion_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; if (data < ARRAY_LENGTH(gfxregions)) - dynax_blit_romregion = gfxregions[data]; - LOG(("GFX%X ",data+1)); + state->blit_romregion = data; + LOG(("GFX%X ", data + 1)); } WRITE8_HANDLER( dynax_blit2_romregion_w ) { - if (data+1 < ARRAY_LENGTH(gfxregions)) - dynax_blit2_romregion = gfxregions[data+1]; - LOG(("GFX%X' ",data+2)); + dynax_state *state = (dynax_state *)space->machine->driver_data; + if (data + 1 < ARRAY_LENGTH(gfxregions)) + state->blit2_romregion = data + 1; + LOG(("GFX%X' ", data + 2)); } /*************************************************************************** @@ -294,12 +310,13 @@ WRITE8_HANDLER( dynax_blit2_romregion_w ) /* Plot a pixel (in the pixmaps specified by dynax_blit_dest) */ -INLINE void blitter_plot_pixel(int layer,int mask, int x, int y, int pen, int wrap, int flags) +INLINE void blitter_plot_pixel( running_machine *machine, int layer, int mask, int x, int y, int pen, int wrap, int flags ) { + dynax_state *state = (dynax_state *)machine->driver_data; int addr; - if ( (y > 0xff) && (!(wrap & 2)) ) return; // fixes mjdialq2 & mjangels title screens - if ( (x > 0xff) && (!(wrap & 1)) ) return; + if ((y > 0xff) && (!(wrap & 2))) return; // fixes mjdialq2 & mjangels title screens + if ((x > 0xff) && (!(wrap & 1))) return; x &= 0xff; // confirmed by some mjdialq2 gfx and especially by mjfriday, which // uses the front layer to mask out the right side of the screen as @@ -309,49 +326,50 @@ INLINE void blitter_plot_pixel(int layer,int mask, int x, int y, int pen, int wr // mjdialq2 title screen so there's something we are missing. /* "Flip Screen" just means complement the coordinates to 255 */ - if (flipscreen) { x ^= 0xff; y ^= 0xff; } + if (state->flipscreen) { x ^= 0xff; y ^= 0xff; } /* Rotate: rotation = SWAPXY + FLIPY */ - if (flags & 0x08) { int t = x; x = y; y = t; } + if (flags & 0x08) { int t = x; x = y; y = t; } - addr = x + (y<<8); + addr = x + (y << 8); - switch (layer_layout) + switch (state->layer_layout) { case LAYOUT_HANAMAI: - if (mask & 0x01) dynax_pixmap[layer+0][hanamai_layer_half^flipscreen][addr] = pen; - if (mask & 0x02) dynax_pixmap[layer+1][hanamai_layer_half^flipscreen][addr] = pen; - if (mask & 0x04) dynax_pixmap[layer+2][hanamai_layer_half^flipscreen][addr] = pen; - if (mask & 0x08) dynax_pixmap[layer+3][hanamai_layer_half^flipscreen][addr] = pen; + if (BIT(mask, 0)) state->pixmap[layer + 0][state->hanamai_layer_half ^ state->flipscreen][addr] = pen; + if (BIT(mask, 1)) state->pixmap[layer + 1][state->hanamai_layer_half ^ state->flipscreen][addr] = pen; + if (BIT(mask, 2)) state->pixmap[layer + 2][state->hanamai_layer_half ^ state->flipscreen][addr] = pen; + if (BIT(mask, 3)) state->pixmap[layer + 3][state->hanamai_layer_half ^ state->flipscreen][addr] = pen; break; case LAYOUT_HNORIDUR: - if (mask & 0x01) dynax_pixmap[layer+0][hanamai_layer_half^flipscreen][addr] = pen; - if (mask & 0x02) dynax_pixmap[layer+1][hanamai_layer_half^flipscreen][addr] = pen; - if (mask & 0x04) dynax_pixmap[layer+2][hanamai_layer_half^flipscreen][addr] = pen; - if (mask & 0x08) dynax_pixmap[layer+3][hanamai_layer_half^flipscreen][addr] = pen; - if (!hnoridur_layer_half2) break; - if (mask & 0x01) dynax_pixmap[layer+0][1^hanamai_layer_half^flipscreen][addr] = pen; - if (mask & 0x02) dynax_pixmap[layer+1][1^hanamai_layer_half^flipscreen][addr] = pen; - if (mask & 0x04) dynax_pixmap[layer+2][1^hanamai_layer_half^flipscreen][addr] = pen; - if (mask & 0x08) dynax_pixmap[layer+3][1^hanamai_layer_half^flipscreen][addr] = pen; + if (BIT(mask, 0)) state->pixmap[layer + 0][state->hanamai_layer_half ^ state->flipscreen][addr] = pen; + if (BIT(mask, 1)) state->pixmap[layer + 1][state->hanamai_layer_half ^ state->flipscreen][addr] = pen; + if (BIT(mask, 2)) state->pixmap[layer + 2][state->hanamai_layer_half ^ state->flipscreen][addr] = pen; + if (BIT(mask, 3)) state->pixmap[layer + 3][state->hanamai_layer_half ^ state->flipscreen][addr] = pen; + if (!state->hnoridur_layer_half2) + break; + if (BIT(mask, 0)) state->pixmap[layer + 0][1 ^ state->hanamai_layer_half ^ state->flipscreen][addr] = pen; + if (BIT(mask, 1)) state->pixmap[layer + 1][1 ^ state->hanamai_layer_half ^ state->flipscreen][addr] = pen; + if (BIT(mask, 2)) state->pixmap[layer + 2][1 ^ state->hanamai_layer_half ^ state->flipscreen][addr] = pen; + if (BIT(mask, 3)) state->pixmap[layer + 3][1 ^ state->hanamai_layer_half ^ state->flipscreen][addr] = pen; break; case LAYOUT_JANTOUKI: - if (mask & 0x80) dynax_pixmap[layer+3][1^flipscreen][addr] = pen; - if (mask & 0x40) dynax_pixmap[layer+3][0^flipscreen][addr] = pen; + if (BIT(mask, 7)) state->pixmap[layer + 3][1 ^ state->flipscreen][addr] = pen; + if (BIT(mask, 6)) state->pixmap[layer + 3][0 ^ state->flipscreen][addr] = pen; case LAYOUT_DRGPUNCH: - if (mask & 0x20) dynax_pixmap[layer+2][1^flipscreen][addr] = pen; - if (mask & 0x10) dynax_pixmap[layer+2][0^flipscreen][addr] = pen; - if (mask & 0x08) dynax_pixmap[layer+1][1^flipscreen][addr] = pen; - if (mask & 0x04) dynax_pixmap[layer+1][0^flipscreen][addr] = pen; - if (mask & 0x02) dynax_pixmap[layer+0][1^flipscreen][addr] = pen; - if (mask & 0x01) dynax_pixmap[layer+0][0^flipscreen][addr] = pen; + if (BIT(mask, 5)) state->pixmap[layer + 2][1 ^ state->flipscreen][addr] = pen; + if (BIT(mask, 4)) state->pixmap[layer + 2][0 ^ state->flipscreen][addr] = pen; + if (BIT(mask, 3)) state->pixmap[layer + 1][1 ^ state->flipscreen][addr] = pen; + if (BIT(mask, 2)) state->pixmap[layer + 1][0 ^ state->flipscreen][addr] = pen; + if (BIT(mask, 1)) state->pixmap[layer + 0][1 ^ state->flipscreen][addr] = pen; + if (BIT(mask, 0)) state->pixmap[layer + 0][0 ^ state->flipscreen][addr] = pen; break; case LAYOUT_MJDIALQ2: - if (mask & 0x01) dynax_pixmap[layer+0][0][addr] = pen; - if (mask & 0x02) dynax_pixmap[layer+1][0][addr] = pen; + if (BIT(mask, 0)) state->pixmap[layer + 0][0][addr] = pen; + if (BIT(mask, 1)) state->pixmap[layer + 1][0][addr] = pen; break; } } @@ -359,74 +377,77 @@ INLINE void blitter_plot_pixel(int layer,int mask, int x, int y, int pen, int wr static int blitter_drawgfx( running_machine *machine, int layer, int mask, const char *gfx, int src, int pen, int x, int y, int wrap, int flags ) { + dynax_state *state = (dynax_state *)machine->driver_data; UINT8 cmd; - - UINT8 *ROM = memory_region( machine, gfx ); - size_t ROM_size = memory_region_length( machine, gfx ); + UINT8 *ROM = memory_region(machine, gfx); + size_t ROM_size = memory_region_length(machine, gfx); int sx; - if (layer_layout == LAYOUT_HNORIDUR) // e.g. yarunara - pen = ((pen >> 4) & 0xf) | ( (mask & 0x10) ? ((pen & 0x08) << 1) : 0 ); + if (state->layer_layout == LAYOUT_HNORIDUR) // e.g. yarunara + pen = ((pen >> 4) & 0xf) | ((mask & 0x10) ? ((pen & 0x08) << 1) : 0); else pen = (pen >> 4) & 0xf; -if (flags & 0xf4) popmessage("flags %02x",flags); - if ( flags & 1 ) + if (flags & 0xf4) + popmessage("flags %02x", flags); + + if (flags & 1) { - int start,len; + int start, len; /* Clear the buffer(s) starting from the given scanline and exit */ - int addr = x + (y<<8); + int addr = x + (y << 8); - if (flipscreen) + if (state->flipscreen) start = 0; else start = addr; len = 0x10000 - addr; - switch (layer_layout) + switch (state->layer_layout) { case LAYOUT_HANAMAI: - if (mask & 0x01) memset(&dynax_pixmap[layer+0][0][start],pen,len); - if (mask & 0x01) memset(&dynax_pixmap[layer+0][1][start],pen,len); - if (mask & 0x02) memset(&dynax_pixmap[layer+1][0][start],pen,len); - if (mask & 0x02) memset(&dynax_pixmap[layer+1][1][start],pen,len); - if (mask & 0x04) memset(&dynax_pixmap[layer+2][0][start],pen,len); - if (mask & 0x04) memset(&dynax_pixmap[layer+2][1][start],pen,len); - if (mask & 0x08) memset(&dynax_pixmap[layer+3][0][start],pen,len); - if (mask & 0x08) memset(&dynax_pixmap[layer+3][1][start],pen,len); + if (BIT(mask, 0)) memset(&state->pixmap[layer + 0][0][start], pen, len); + if (BIT(mask, 0)) memset(&state->pixmap[layer + 0][1][start], pen, len); + if (BIT(mask, 1)) memset(&state->pixmap[layer + 1][0][start], pen, len); + if (BIT(mask, 1)) memset(&state->pixmap[layer + 1][1][start], pen, len); + if (BIT(mask, 2)) memset(&state->pixmap[layer + 2][0][start], pen, len); + if (BIT(mask, 2)) memset(&state->pixmap[layer + 2][1][start], pen, len); + if (BIT(mask, 3)) memset(&state->pixmap[layer + 3][0][start], pen, len); + if (BIT(mask, 3)) memset(&state->pixmap[layer + 3][1][start], pen, len); break; case LAYOUT_HNORIDUR: - if (mask & 0x01) memset(&dynax_pixmap[layer+0][hanamai_layer_half][start],pen,len); - if (mask & 0x02) memset(&dynax_pixmap[layer+1][hanamai_layer_half][start],pen,len); - if (mask & 0x04) memset(&dynax_pixmap[layer+2][hanamai_layer_half][start],pen,len); - if (mask & 0x08) memset(&dynax_pixmap[layer+3][hanamai_layer_half][start],pen,len); - if (!hnoridur_layer_half2) break; - if (mask & 0x01) memset(&dynax_pixmap[layer+0][1-hanamai_layer_half][start],pen,len); - if (mask & 0x02) memset(&dynax_pixmap[layer+1][1-hanamai_layer_half][start],pen,len); - if (mask & 0x04) memset(&dynax_pixmap[layer+2][1-hanamai_layer_half][start],pen,len); - if (mask & 0x08) memset(&dynax_pixmap[layer+3][1-hanamai_layer_half][start],pen,len); + if (BIT(mask, 0)) memset(&state->pixmap[layer + 0][state->hanamai_layer_half][start], pen, len); + if (BIT(mask, 1)) memset(&state->pixmap[layer + 1][state->hanamai_layer_half][start], pen, len); + if (BIT(mask, 2)) memset(&state->pixmap[layer + 2][state->hanamai_layer_half][start], pen, len); + if (BIT(mask, 3)) memset(&state->pixmap[layer + 3][state->hanamai_layer_half][start], pen, len); + if (!state->hnoridur_layer_half2) + break; + if (BIT(mask, 0)) memset(&state->pixmap[layer + 0][1 - state->hanamai_layer_half][start], pen, len); + if (BIT(mask, 1)) memset(&state->pixmap[layer + 1][1 - state->hanamai_layer_half][start], pen, len); + if (BIT(mask, 2)) memset(&state->pixmap[layer + 2][1 - state->hanamai_layer_half][start], pen, len); + if (BIT(mask, 3)) memset(&state->pixmap[layer + 3][1 - state->hanamai_layer_half][start], pen, len); break; case LAYOUT_JANTOUKI: - if (mask & 0x80) memset(&dynax_pixmap[layer+3][1][start],pen,len); - if (mask & 0x40) memset(&dynax_pixmap[layer+3][0][start],pen,len); + if (BIT(mask, 7)) memset(&state->pixmap[layer + 3][1][start], pen, len); + if (BIT(mask, 6)) memset(&state->pixmap[layer + 3][0][start], pen, len); case LAYOUT_DRGPUNCH: - if (mask & 0x20) memset(&dynax_pixmap[layer+2][1][start],pen,len); - if (mask & 0x10) memset(&dynax_pixmap[layer+2][0][start],pen,len); - if (mask & 0x08) memset(&dynax_pixmap[layer+1][1][start],pen,len); - if (mask & 0x04) memset(&dynax_pixmap[layer+1][0][start],pen,len); - if (mask & 0x02) memset(&dynax_pixmap[layer+0][1][start],pen,len); - if (mask & 0x01) memset(&dynax_pixmap[layer+0][0][start],pen,len); + if (BIT(mask, 5)) memset(&state->pixmap[layer + 2][1][start], pen, len); + if (BIT(mask, 4)) memset(&state->pixmap[layer + 2][0][start], pen, len); + if (BIT(mask, 3)) memset(&state->pixmap[layer + 1][1][start], pen, len); + if (BIT(mask, 2)) memset(&state->pixmap[layer + 1][0][start], pen, len); + if (BIT(mask, 1)) memset(&state->pixmap[layer + 0][1][start], pen, len); + if (BIT(mask, 0)) memset(&state->pixmap[layer + 0][0][start], pen, len); break; case LAYOUT_MJDIALQ2: - if (mask & 0x01) memset(&dynax_pixmap[layer+0][0][start],pen,len); - if (mask & 0x02) memset(&dynax_pixmap[layer+1][0][start],pen,len); + if (BIT(mask, 0)) memset(&state->pixmap[layer + 0][0][start], pen, len); + if (BIT(mask, 1)) memset(&state->pixmap[layer + 1][0][start], pen, len); break; } @@ -441,13 +462,14 @@ if (flags & 0xf4) popmessage("flags %02x",flags); { if (src >= ROM_size) { -popmessage("GFXROM OVER %08x",src); + popmessage("GFXROM OVER %08x",src); return src; } + cmd = ROM[src++]; src &= 0xfffff; if (!(flags & 0x02)) // Ignore the pens specified in ROM, draw everything with the pen supplied as parameter - pen = (pen & 0xf0) | ((cmd & 0xf0)>>4); + pen = (pen & 0xf0) | ((cmd & 0xf0) >> 4); cmd = (cmd & 0x0f); switch (cmd) @@ -462,12 +484,12 @@ popmessage("GFXROM OVER %08x",src); break; case 0xe: // unused ? was "change dest mask" in the "rev1" blitter - popmessage("Blitter unknown command %06X: %02X\n", src-1, cmd); + popmessage("Blitter unknown command %06X: %02X\n", src - 1, cmd); case 0xd: // Skip X pixels if (src >= ROM_size) { -popmessage("GFXROM OVER %08x",src); + popmessage("GFXROM OVER %08x",src); return src; } x = sx + ROM[src++]; @@ -477,7 +499,7 @@ popmessage("GFXROM OVER %08x",src); case 0xc: // Draw N pixels if (src >= ROM_size) { -popmessage("GFXROM OVER %08x",src); + popmessage("GFXROM OVER %08x", src); return src; } cmd = ROM[src++]; @@ -496,7 +518,7 @@ popmessage("GFXROM OVER %08x",src); case 0x2: case 0x1: // Draw N pixels while (cmd--) - blitter_plot_pixel(layer, mask, x++, y, pen, wrap, flags); + blitter_plot_pixel(machine, layer, mask, x++, y, pen, wrap, flags); break; case 0x0: // Stop @@ -507,93 +529,90 @@ popmessage("GFXROM OVER %08x",src); -static void dynax_blitter_start(running_machine *machine, int flags) +static void dynax_blitter_start( running_machine *machine, int flags ) { + dynax_state *state = (dynax_state *)machine->driver_data; int blit_newsrc; - LOG(("XY=%X,%X SRC=%X BLIT=%X\n",blit_x,blit_y,blit_src,flags)); + LOG(("XY=%X,%X SRC=%X BLIT=%X\n", state->blit_x, state->blit_y, state->blit_src, flags)); - blit_newsrc = - blitter_drawgfx( + blit_newsrc = blitter_drawgfx( machine, 0, // layer - dynax_blit_dest, // layer mask - dynax_blit_romregion, // rom region - blit_src, // rom address - dynax_blit_pen, // pen - blit_x, blit_y, // x,y - dynax_blit_wrap_enable, // wrap around + state->blit_dest, // layer mask + gfxregions[state->blit_romregion], // rom region + state->blit_src, // rom address + state->blit_pen, // pen + state->blit_x, state->blit_y, // x,y + state->blit_wrap_enable, // wrap around flags // flags ); - blit_src = (blit_src & ~0x0fffff) | - (blit_newsrc & 0x0fffff) ; + state->blit_src = (state->blit_src & ~0x0fffff) | (blit_newsrc & 0x0fffff); /* Generate an IRQ */ - if (update_irq_func) + if (state->update_irq_func) { - dynax_blitter_irq = 1; - update_irq_func(machine); + state->blitter_irq = 1; + state->update_irq_func(machine); } } -static void jantouki_blitter_start(running_machine *machine, int flags) +static void jantouki_blitter_start( running_machine *machine, int flags ) { + dynax_state *state = (dynax_state *)machine->driver_data; int blit_newsrc; - LOG(("XY=%X,%X SRC=%X BLIT=%X\n",blit_x,blit_y,blit_src,flags)); + LOG(("XY=%X,%X SRC=%X BLIT=%X\n", state->blit_x, state->blit_y, state->blit_src, flags)); - blit_newsrc = - blitter_drawgfx( + blit_newsrc = blitter_drawgfx( machine, 0, // layer - dynax_blit_dest, // layer mask - dynax_blit_romregion, // rom region - blit_src, // rom address - dynax_blit_pen, // pen - blit_x, blit_y, // x,y - dynax_blit_wrap_enable, // wrap around + state->blit_dest, // layer mask + gfxregions[state->blit_romregion], // rom region + state->blit_src, // rom address + state->blit_pen, // pen + state->blit_x, state->blit_y, // x,y + state->blit_wrap_enable, // wrap around flags // flags ); - blit_src = (blit_src & ~0x0fffff) | - (blit_newsrc & 0x0fffff) ; + state->blit_src = (state->blit_src & ~0x0fffff) | (blit_newsrc & 0x0fffff); /* Generate an IRQ */ - if (update_irq_func) + if (state->update_irq_func) { - dynax_blitter_irq = 1; - update_irq_func(machine); + state->blitter_irq = 1; + state->update_irq_func(machine); } } -static void jantouki_blitter2_start(running_machine *machine, int flags) +static void jantouki_blitter2_start( running_machine *machine, int flags ) { + dynax_state *state = (dynax_state *)machine->driver_data; int blit2_newsrc; - LOG(("XY'=%X,%X SRC'=%X BLIT'=%02X\n",blit2_x,blit2_y,blit2_src,flags)); + LOG(("XY'=%X,%X SRC'=%X BLIT'=%02X\n", state->blit2_x, state->blit2_y, state->blit2_src, flags)); - blit2_newsrc = - blitter_drawgfx( + blit2_newsrc = blitter_drawgfx( machine, 4, // layer - dynax_blit2_dest, // layer mask - dynax_blit2_romregion, // rom region - blit2_src, // rom address - dynax_blit2_pen, // pen - blit2_x, blit2_y, // x,y - dynax_blit2_wrap_enable, // wrap around + state->blit2_dest, // layer mask + gfxregions[state->blit2_romregion], // rom region + state->blit2_src, // rom address + state->blit2_pen, // pen + state->blit2_x, state->blit2_y, // x,y + state->blit2_wrap_enable, // wrap around flags // flags ); - blit2_src = (blit2_src & ~0x0fffff) | - (blit2_newsrc & 0x0fffff) ; + state->blit2_src = (state->blit2_src & ~0x0fffff) | (blit2_newsrc & 0x0fffff); /* Generate an IRQ */ - if (update_irq_func) + if (state->update_irq_func) { - dynax_blitter2_irq = 1; - update_irq_func(machine); + state->blitter2_irq = 1; + state->update_irq_func(machine); } } @@ -601,17 +620,19 @@ static void jantouki_blitter2_start(running_machine *machine, int flags) static WRITE8_HANDLER( dynax_blit_scroll_w ) { - switch( blit_src & 0xc00000 ) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->blit_src & 0xc00000) { - case 0x000000: dynax_blit_scroll_x = data; - LOG(("SX=%02X ",data)); + case 0x000000: state->blit_scroll_x = data; + LOG(("SX=%02X ", data)); break; - case 0x400000: dynax_blit_scroll_y = data; - LOG(("SY=%02X ",data)); + case 0x400000: state->blit_scroll_y = data; + LOG(("SY=%02X ", data)); break; case 0x800000: - case 0xc00000: dynax_blit_wrap_enable = data; - LOG(("WE=%02X ",data)); + case 0xc00000: state->blit_wrap_enable = data; + LOG(("WE=%02X ", data)); break; } } @@ -619,95 +640,105 @@ static WRITE8_HANDLER( dynax_blit_scroll_w ) // inverted scroll values static WRITE8_HANDLER( tenkai_blit_scroll_w ) { - switch( blit_src & 0xc00000 ) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->blit_src & 0xc00000) { - case 0x000000: dynax_blit_scroll_x = ((data ^ 0xff) + 1) & 0xff; - LOG(("SX=%02X ",data)); + case 0x000000: state->blit_scroll_x = ((data ^ 0xff) + 1) & 0xff; + LOG(("SX=%02X ", data)); break; - case 0x400000: dynax_blit_scroll_y = data ^ 0xff; - LOG(("SY=%02X ",data)); + case 0x400000: state->blit_scroll_y = data ^ 0xff; + LOG(("SY=%02X ", data)); break; case 0x800000: - case 0xc00000: dynax_blit_wrap_enable = data; - LOG(("WE=%02X ",data)); + case 0xc00000: state->blit_wrap_enable = data; + LOG(("WE=%02X ", data)); break; } } static WRITE8_HANDLER( dynax_blit2_scroll_w ) { - switch( blit2_src & 0xc00000 ) + dynax_state *state = (dynax_state *)space->machine->driver_data; + + switch (state->blit2_src & 0xc00000) { - case 0x000000: dynax_blit2_scroll_x = data; - LOG(("SX'=%02X ",data)); + case 0x000000: state->blit2_scroll_x = data; + LOG(("SX'=%02X ", data)); break; - case 0x400000: dynax_blit2_scroll_y = data; - LOG(("SY'=%02X ",data)); + case 0x400000: state->blit2_scroll_y = data; + LOG(("SY'=%02X ", data)); break; case 0x800000: - case 0xc00000: dynax_blit2_wrap_enable = data; - LOG(("WE'=%02X ",data)); + case 0xc00000: state->blit2_wrap_enable = data; + LOG(("WE'=%02X ", data)); break; } } - - WRITE8_HANDLER( dynax_blitter_rev2_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; + switch (offset) { - case 0: dynax_blitter_start(space->machine,data); break; - case 1: blit_x = data; break; - case 2: blit_y = data; break; - case 3: blit_src = (blit_src & 0xffff00) | (data << 0); break; - case 4: blit_src = (blit_src & 0xff00ff) | (data << 8); break; - case 5: blit_src = (blit_src & 0x00ffff) | (data <<16); break; - case 6: dynax_blit_scroll_w(space,0,data); break; + case 0: dynax_blitter_start(space->machine, data); break; + case 1: state->blit_x = data; break; + case 2: state->blit_y = data; break; + case 3: state->blit_src = (state->blit_src & 0xffff00) | (data << 0); break; + case 4: state->blit_src = (state->blit_src & 0xff00ff) | (data << 8); break; + case 5: state->blit_src = (state->blit_src & 0x00ffff) | (data << 16); break; + case 6: dynax_blit_scroll_w(space, 0, data); break; } } // different scroll_w WRITE8_HANDLER( tenkai_blitter_rev2_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; + switch (offset) { - case 0: dynax_blitter_start(space->machine,data); break; - case 1: blit_x = data; break; - case 2: blit_y = data; break; - case 3: blit_src = (blit_src & 0xffff00) | (data << 0); break; - case 4: blit_src = (blit_src & 0xff00ff) | (data << 8); break; - case 5: blit_src = (blit_src & 0x00ffff) | (data <<16); break; - case 6: tenkai_blit_scroll_w(space,0,data); break; + case 0: dynax_blitter_start(space->machine, data); break; + case 1: state->blit_x = data; break; + case 2: state->blit_y = data; break; + case 3: state->blit_src = (state->blit_src & 0xffff00) | (data << 0); break; + case 4: state->blit_src = (state->blit_src & 0xff00ff) | (data << 8); break; + case 5: state->blit_src = (state->blit_src & 0x00ffff) | (data << 16); break; + case 6: tenkai_blit_scroll_w(space, 0, data); break; } } WRITE8_HANDLER( jantouki_blitter_rev2_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; + switch (offset) { - case 0: jantouki_blitter_start(space->machine,data); break; - case 1: blit_x = data; break; - case 2: blit_y = data; break; - case 3: blit_src = (blit_src & 0xffff00) | (data << 0); break; - case 4: blit_src = (blit_src & 0xff00ff) | (data << 8); break; - case 5: blit_src = (blit_src & 0x00ffff) | (data <<16); break; - case 6: dynax_blit_scroll_w(space,0,data); break; + case 0: jantouki_blitter_start(space->machine, data); break; + case 1: state->blit_x = data; break; + case 2: state->blit_y = data; break; + case 3: state->blit_src = (state->blit_src & 0xffff00) | (data << 0); break; + case 4: state->blit_src = (state->blit_src & 0xff00ff) | (data << 8); break; + case 5: state->blit_src = (state->blit_src & 0x00ffff) | (data << 16); break; + case 6: dynax_blit_scroll_w(space, 0, data); break; } } WRITE8_HANDLER( jantouki_blitter2_rev2_w ) { + dynax_state *state = (dynax_state *)space->machine->driver_data; + switch (offset) { case 0: jantouki_blitter2_start(space->machine,data); break; - case 1: blit2_x = data; break; - case 2: blit2_y = data; break; - case 3: blit2_src = (blit2_src & 0xffff00) | (data << 0); break; - case 4: blit2_src = (blit2_src & 0xff00ff) | (data << 8); break; - case 5: blit2_src = (blit2_src & 0x00ffff) | (data <<16); break; - case 6: dynax_blit2_scroll_w(space,0,data); break; + case 1: state->blit2_x = data; break; + case 2: state->blit2_y = data; break; + case 3: state->blit2_src = (state->blit2_src & 0xffff00) | (data << 0); break; + case 4: state->blit2_src = (state->blit2_src & 0xff00ff) | (data << 8); break; + case 5: state->blit2_src = (state->blit2_src & 0x00ffff) | (data << 16); break; + case 6: dynax_blit2_scroll_w(space, 0, data); break; } } @@ -720,131 +751,245 @@ WRITE8_HANDLER( jantouki_blitter2_rev2_w ) ***************************************************************************/ -static const int *priority_table; // 0 1 2 3 4 5 6 7 static const int priority_hnoridur[8] = { 0x0231, 0x2103, 0x3102, 0x2031, 0x3021, 0x1302, 0x2310, 0x1023 }; static const int priority_mcnpshnt[8] = { 0x3210, 0x2103, 0x3102, 0x2031, 0x3021, 0x1302, 0x2310, 0x1023 }; static const int priority_mjelctrn[8] = { 0x0231, 0x0321, 0x2031, 0x2301, 0x3021, 0x3201 ,0x0000, 0x0000 }; // this game doesn't use (hasn't?) layer 1 -static void Video_Reset(void) + +static void dynax_common_reset( running_machine *machine ) { - dynax_blit_romregion = "gfx1"; dynax_blit2_romregion = "gfx1"; - dynax_blit_dest = -1; dynax_blit2_dest = -1; - dynax_blit_pen = 0x7; dynax_blit2_pen = 0x7; - dynax_blit_palbank = 0; dynax_blit2_palbank = 0; - dynax_blit_palettes = 0; dynax_blit2_palettes = 0; - dynax_layer_enable = -1; - dynax_blit_backpen = 0; + dynax_state *state = (dynax_state *)machine->driver_data; - extra_scroll_x = 0; - extra_scroll_y = 0; + state->blit_romregion = 0; + state->blit2_romregion = 0; + state->blit_dest = -1; + state->blit2_dest = -1; + state->blit_pen = 0x7; + state->blit2_pen = 0x7; + state->blit_palbank = 0; + state->blit2_palbank = 0; + state->blit_palettes = 0; + state->blit2_palettes = 0; + state->layer_enable = -1; + state->blit_backpen = 0; - hnoridur_layer_half2 = 0; + state->extra_scroll_x = 0; + state->extra_scroll_y = 0; - update_irq_func = sprtmtch_update_irq; + state->hnoridur_layer_half2 = 0; + + state->update_irq_func = sprtmtch_update_irq; + + state->blit_scroll_x = 0; + state->blit2_scroll_x = 0; + state->blit_scroll_y = 0; + state->blit2_scroll_y = 0; + state->blit_wrap_enable = 0; + state->blit2_wrap_enable = 0; + state->blit_x = 0; + state->blit_y = 0; + state->blit2_x = 0; + state->blit2_y = 0; + state->blit_src = 0; + state->blit2_src = 0; + state->hanamai_layer_half = 0; + state->flipscreen = 0; + state->hanamai_priority = 0; + + state_save_register_global(machine, state->blit_romregion); + state_save_register_global(machine, state->blit2_romregion); + state_save_register_global(machine, state->blit_dest); + state_save_register_global(machine, state->blit2_dest); + state_save_register_global(machine, state->blit_pen); + state_save_register_global(machine, state->blit2_pen); + state_save_register_global(machine, state->blit_palbank); + state_save_register_global(machine, state->blit2_palbank); + state_save_register_global(machine, state->blit_palettes); + state_save_register_global(machine, state->blit2_palettes); + state_save_register_global(machine, state->layer_enable); + state_save_register_global(machine, state->blit_backpen); + state_save_register_global(machine, state->extra_scroll_x); + state_save_register_global(machine, state->extra_scroll_y); + state_save_register_global(machine, state->hnoridur_layer_half2); + + state_save_register_global(machine, state->blit_scroll_x); + state_save_register_global(machine, state->blit2_scroll_x); + state_save_register_global(machine, state->blit_scroll_y); + state_save_register_global(machine, state->blit2_scroll_y); + state_save_register_global(machine, state->blit_wrap_enable); + state_save_register_global(machine, state->blit2_wrap_enable); + state_save_register_global(machine, state->blit_x); + state_save_register_global(machine, state->blit_y); + state_save_register_global(machine, state->blit2_x); + state_save_register_global(machine, state->blit2_y); + state_save_register_global(machine, state->blit_src); + state_save_register_global(machine, state->blit2_src); + state_save_register_global(machine, state->hanamai_layer_half); + state_save_register_global(machine, state->flipscreen); + state_save_register_global(machine, state->hanamai_priority); } VIDEO_START( hanamai ) { - dynax_pixmap[0][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[0][1] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[1][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[1][1] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[2][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[2][1] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[3][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[3][1] = auto_alloc_array(machine, UINT8, 256*256); + dynax_state *state = (dynax_state *)machine->driver_data; - Video_Reset(); - layer_layout = LAYOUT_HANAMAI; + state->pixmap[0][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[0][1] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[1][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[1][1] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[2][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[2][1] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[3][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[3][1] = auto_alloc_array(machine, UINT8, 256 * 256); + + dynax_common_reset(machine); + state->layer_layout = LAYOUT_HANAMAI; + + state_save_register_global_pointer(machine, state->pixmap[0][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[0][1], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[1][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[1][1], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[2][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[2][1], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[3][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[3][1], 256 * 256); } VIDEO_START( hnoridur ) { - dynax_pixmap[0][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[0][1] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[1][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[1][1] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[2][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[2][1] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[3][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[3][1] = auto_alloc_array(machine, UINT8, 256*256); + dynax_state *state = (dynax_state *)machine->driver_data; - Video_Reset(); - layer_layout = LAYOUT_HNORIDUR; + state->pixmap[0][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[0][1] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[1][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[1][1] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[2][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[2][1] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[3][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[3][1] = auto_alloc_array(machine, UINT8, 256 * 256); - priority_table = priority_hnoridur; + dynax_common_reset(machine); + state->layer_layout = LAYOUT_HNORIDUR; + + state->priority_table = priority_hnoridur; + + state_save_register_global_pointer(machine, state->pixmap[0][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[0][1], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[1][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[1][1], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[2][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[2][1], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[3][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[3][1], 256 * 256); } VIDEO_START( mcnpshnt ) { + dynax_state *state = (dynax_state *)machine->driver_data; + VIDEO_START_CALL(hnoridur); - priority_table = priority_mcnpshnt; + state->priority_table = priority_mcnpshnt; } VIDEO_START( sprtmtch ) { - dynax_pixmap[0][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[0][1] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[1][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[1][1] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[2][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[2][1] = auto_alloc_array(machine, UINT8, 256*256); + dynax_state *state = (dynax_state *)machine->driver_data; - Video_Reset(); - layer_layout = LAYOUT_DRGPUNCH; + state->pixmap[0][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[0][1] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[1][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[1][1] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[2][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[2][1] = auto_alloc_array(machine, UINT8, 256 * 256); + + dynax_common_reset(machine); + state->layer_layout = LAYOUT_DRGPUNCH; + + state_save_register_global_pointer(machine, state->pixmap[0][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[0][1], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[1][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[1][1], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[2][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[2][1], 256 * 256); } VIDEO_START( jantouki ) { - dynax_pixmap[0][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[0][1] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[1][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[1][1] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[2][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[2][1] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[3][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[3][1] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[4][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[4][1] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[5][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[5][1] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[6][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[6][1] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[7][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[7][1] = auto_alloc_array(machine, UINT8, 256*256); + dynax_state *state = (dynax_state *)machine->driver_data; - Video_Reset(); - layer_layout = LAYOUT_JANTOUKI; + state->pixmap[0][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[0][1] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[1][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[1][1] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[2][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[2][1] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[3][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[3][1] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[4][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[4][1] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[5][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[5][1] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[6][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[6][1] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[7][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[7][1] = auto_alloc_array(machine, UINT8, 256 * 256); - update_irq_func = jantouki_update_irq; + dynax_common_reset(machine); + state->layer_layout = LAYOUT_JANTOUKI; + state->update_irq_func = jantouki_update_irq; + + state_save_register_global_pointer(machine, state->pixmap[0][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[0][1], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[1][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[1][1], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[2][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[2][1], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[3][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[3][1], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[4][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[4][1], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[5][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[5][1], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[6][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[6][1], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[7][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[7][1], 256 * 256); } VIDEO_START( mjdialq2 ) { - dynax_pixmap[0][0] = auto_alloc_array(machine, UINT8, 256*256); - dynax_pixmap[1][0] = auto_alloc_array(machine, UINT8, 256*256); + dynax_state *state = (dynax_state *)machine->driver_data; - Video_Reset(); - layer_layout = LAYOUT_MJDIALQ2; + state->pixmap[0][0] = auto_alloc_array(machine, UINT8, 256 * 256); + state->pixmap[1][0] = auto_alloc_array(machine, UINT8, 256 * 256); - update_irq_func = 0; + dynax_common_reset(machine); + state->layer_layout = LAYOUT_MJDIALQ2; + state->update_irq_func = 0; + + state_save_register_global_pointer(machine, state->pixmap[0][0], 256 * 256); + state_save_register_global_pointer(machine, state->pixmap[1][0], 256 * 256); } VIDEO_START( mjelctrn ) { + dynax_state *state = (dynax_state *)machine->driver_data; + VIDEO_START_CALL(hnoridur); - priority_table = priority_mjelctrn; - update_irq_func = mjelctrn_update_irq; + state->priority_table = priority_mjelctrn; + state->update_irq_func = mjelctrn_update_irq; } VIDEO_START( neruton ) { + dynax_state *state = (dynax_state *)machine->driver_data; + VIDEO_START_CALL(hnoridur); -// priority_table = priority_mjelctrn; - update_irq_func = neruton_update_irq; +// state->priority_table = priority_mjelctrn; + state->update_irq_func = neruton_update_irq; } /*************************************************************************** @@ -855,38 +1000,38 @@ VIDEO_START( neruton ) ***************************************************************************/ -static void hanamai_copylayer(bitmap_t *bitmap,const rectangle *cliprect,int i) +static void hanamai_copylayer( running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect, int i ) { + dynax_state *state = (dynax_state *)machine->driver_data; int color; - int scrollx,scrolly; + int scrollx, scrolly; - switch ( i ) + switch (i) { - case 0: color = (dynax_blit_palettes >> 0) & 0xf; break; - case 1: color = (dynax_blit_palettes >> 4) & 0xf; break; - case 2: color = (dynax_blit_palettes >> 8) & 0xf; break; - case 3: color = (dynax_blit_palettes >> 12) & 0xf; break; + case 0: color = (state->blit_palettes >> 0) & 0x0f; break; + case 1: color = (state->blit_palettes >> 4) & 0x0f; break; + case 2: color = (state->blit_palettes >> 8) & 0x0f; break; + case 3: color = (state->blit_palettes >> 12) & 0x0f; break; default: return; } - color += (dynax_blit_palbank & 0x0f) * 16; + color += (state->blit_palbank & 0x0f) * 16; - scrollx = dynax_blit_scroll_x; - scrolly = dynax_blit_scroll_y; + scrollx = state->blit_scroll_x; + scrolly = state->blit_scroll_y; - if ( (layer_layout == LAYOUT_HANAMAI && i == 1) || - (layer_layout == LAYOUT_HNORIDUR && i == 1) ) + if (i == 1 && (state->layer_layout == LAYOUT_HANAMAI || state->layer_layout == LAYOUT_HNORIDUR)) { - scrollx = extra_scroll_x; - scrolly = extra_scroll_y; + scrollx = state->extra_scroll_x; + scrolly = state->extra_scroll_y; } { - int dy,length,pen,offs; - UINT8 *src1 = dynax_pixmap[i][1]; - UINT8 *src2 = dynax_pixmap[i][0]; + int dy, length, pen, offs; + UINT8 *src1 = state->pixmap[i][1]; + UINT8 *src2 = state->pixmap[i][0]; - int palbase = 16*color; + int palbase = 16 * color; offs = 0; for (dy = 0; dy < 256; dy++) @@ -895,13 +1040,13 @@ static void hanamai_copylayer(bitmap_t *bitmap,const rectangle *cliprect,int i) UINT16 *dstbase = BITMAP_ADDR16(bitmap, (dy - scrolly) & 0xff, 0); length = scrollx; - dst = dstbase + 2*(256 - length); + dst = dstbase + 2 * (256 - length); while (length--) { pen = *(src1++); - if (pen) *dst = palbase + pen; + if (pen) *dst = palbase + pen; pen = *(src2++); - if (pen) *(dst+1) = palbase + pen; + if (pen) *(dst + 1) = palbase + pen; dst += 2; } @@ -910,9 +1055,9 @@ static void hanamai_copylayer(bitmap_t *bitmap,const rectangle *cliprect,int i) while (length--) { pen = *(src1++); - if (pen) *dst = palbase + pen; + if (pen) *dst = palbase + pen; pen = *(src2++); - if (pen) *(dst+1) = palbase + pen; + if (pen) *(dst + 1) = palbase + pen; dst += 2; } } @@ -920,40 +1065,41 @@ static void hanamai_copylayer(bitmap_t *bitmap,const rectangle *cliprect,int i) } -static void jantouki_copylayer(bitmap_t *bitmap,const rectangle *cliprect,int i, int y) +static void jantouki_copylayer( running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect, int i, int y ) { - int color,scrollx,scrolly,palettes,palbank; + dynax_state *state = (dynax_state *)machine->driver_data; + int color, scrollx, scrolly, palettes, palbank; if (i < 4) { - scrollx = dynax_blit_scroll_x; - scrolly = dynax_blit_scroll_y; - palettes = dynax_blit_palettes; - palbank = dynax_blit_palbank; + scrollx = state->blit_scroll_x; + scrolly = state->blit_scroll_y; + palettes = state->blit_palettes; + palbank = state->blit_palbank; } else { - scrollx = dynax_blit2_scroll_x; - scrolly = dynax_blit2_scroll_y; - palettes = dynax_blit2_palettes; - palbank = dynax_blit2_palbank; + scrollx = state->blit2_scroll_x; + scrolly = state->blit2_scroll_y; + palettes = state->blit2_palettes; + palbank = state->blit2_palbank; } - switch ( i % 4 ) + switch (i % 4) { - case 0: color = ((palettes >> 12) & 0xf) + ((palbank & 1) << 4); break; - case 1: color = ((palettes >> 8) & 0xf) + ((palbank & 1) << 4); break; - case 2: color = ((palettes >> 4) & 0xf) + ((palbank & 1) << 4); break; - case 3: color = ((palettes >> 0) & 0xf) + ((palbank & 1) << 4); break; + case 0: color = ((palettes >> 12) & 0x0f) + ((palbank & 1) << 4); break; + case 1: color = ((palettes >> 8) & 0x0f) + ((palbank & 1) << 4); break; + case 2: color = ((palettes >> 4) & 0x0f) + ((palbank & 1) << 4); break; + case 3: color = ((palettes >> 0) & 0x0f) + ((palbank & 1) << 4); break; default: return; } { - int dy,length,pen,offs; - UINT8 *src1 = dynax_pixmap[i][1]; - UINT8 *src2 = dynax_pixmap[i][0]; + int dy, length, pen, offs; + UINT8 *src1 = state->pixmap[i][1]; + UINT8 *src2 = state->pixmap[i][0]; - int palbase = 16*color; + int palbase = 16 * color; offs = 0; for (dy = 0; dy < 256; dy++) @@ -964,19 +1110,19 @@ static void jantouki_copylayer(bitmap_t *bitmap,const rectangle *cliprect,int i, if ((sy < cliprect->min_y) || (sy > cliprect->max_y)) { - src1+=256; - src2+=256; + src1 += 256; + src2 += 256; continue; } length = scrollx; - dst = dstbase + 2*(256 - length); + dst = dstbase + 2 * (256 - length); while (length--) { pen = *(src1++); - if (pen) *dst = palbase + pen; + if (pen) *dst = palbase + pen; pen = *(src2++); - if (pen) *(dst+1) = palbase + pen; + if (pen) *(dst + 1) = palbase + pen; dst += 2; } @@ -985,9 +1131,9 @@ static void jantouki_copylayer(bitmap_t *bitmap,const rectangle *cliprect,int i, while (length--) { pen = *(src1++); - if (pen) *dst = palbase + pen; + if (pen) *dst = palbase + pen; pen = *(src2++); - if (pen) *(dst+1) = palbase + pen; + if (pen) *(dst + 1) = palbase + pen; dst += 2; } } @@ -995,28 +1141,29 @@ static void jantouki_copylayer(bitmap_t *bitmap,const rectangle *cliprect,int i, } -static void mjdialq2_copylayer(bitmap_t *bitmap,const rectangle *cliprect,int i) +static void mjdialq2_copylayer( running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect, int i ) { + dynax_state *state = (dynax_state *)machine->driver_data; int color; - int scrollx,scrolly; + int scrollx, scrolly; - switch ( i ) + switch (i) { - case 0: color = (dynax_blit_palettes >> 4) & 0xf; break; - case 1: color = (dynax_blit_palettes >> 0) & 0xf; break; + case 0: color = (state->blit_palettes >> 4) & 0x0f; break; + case 1: color = (state->blit_palettes >> 0) & 0x0f; break; default: return; } - color += (dynax_blit_palbank & 1) * 16; + color += (state->blit_palbank & 1) * 16; - scrollx = dynax_blit_scroll_x; - scrolly = dynax_blit_scroll_y; + scrollx = state->blit_scroll_x; + scrolly = state->blit_scroll_y; { - int dy,length,pen,offs; - UINT8 *src = dynax_pixmap[i][0]; + int dy, length, pen, offs; + UINT8 *src = state->pixmap[i][0]; - int palbase = 16*color; + int palbase = 16 * color; offs = 0; for (dy = 0; dy < 256; dy++) @@ -1045,21 +1192,19 @@ static void mjdialq2_copylayer(bitmap_t *bitmap,const rectangle *cliprect,int i) } } - - -static int hanamai_priority; - WRITE8_HANDLER( hanamai_priority_w ) { - hanamai_priority = data; + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->hanamai_priority = data; } WRITE8_HANDLER( tenkai_priority_w ) { - hanamai_priority = BITSWAP8(data, 3,2,1,0, 4,7,5,6); + dynax_state *state = (dynax_state *)space->machine->driver_data; + state->hanamai_priority = BITSWAP8(data, 3, 2, 1, 0, 4, 7, 5, 6); } -static int debug_mask(running_machine *machine) +static int debug_mask( running_machine *machine ) { #ifdef MAME_DEBUG int msk = 0; @@ -1085,40 +1230,48 @@ static int debug_mask(running_machine *machine) I,O - Change palette (-,+) J,K & N,M - Change "tile" (-,+, slow & fast) R - move "tile" to the next 1/8th of the gfx */ -static int debug_viewer(running_machine *machine, bitmap_t *bitmap,const rectangle *cliprect) +static int debug_viewer( running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect ) { + #ifdef MAME_DEBUG static int toggle; - if (input_code_pressed_once(machine, KEYCODE_T)) toggle = 1-toggle; - if (toggle) { - UINT8 *RAM = memory_region( machine, "gfx1" ); - size_t size = memory_region_length( machine, "gfx1" ); + if (input_code_pressed_once(machine, KEYCODE_T)) toggle = 1 - toggle; + if (toggle) + { + dynax_state *state = (dynax_state *)machine->driver_data; + UINT8 *RAM = memory_region( machine, "gfx1" ); + size_t size = memory_region_length( machine, "gfx1" ); static int i = 0, c = 0, r = 0; - if (input_code_pressed_once(machine, KEYCODE_I)) c = (c-1) & 0x1f; - if (input_code_pressed_once(machine, KEYCODE_O)) c = (c+1) & 0x1f; - if (input_code_pressed_once(machine, KEYCODE_R)) { r = (r+1) & 0x7; i = size/8 * r; } + if (input_code_pressed_once(machine, KEYCODE_I)) c = (c - 1) & 0x1f; + if (input_code_pressed_once(machine, KEYCODE_O)) c = (c + 1) & 0x1f; + if (input_code_pressed_once(machine, KEYCODE_R)) { r = (r + 1) & 0x7; i = size / 8 * r; } if (input_code_pressed(machine, KEYCODE_M) | input_code_pressed_once(machine, KEYCODE_K)) { - while( i < size && RAM[i] ) i++; while( i < size && !RAM[i] ) i++; + while (i < size && RAM[i]) i++; while (i < size && !RAM[i]) i++; } if (input_code_pressed(machine, KEYCODE_N) | input_code_pressed_once(machine, KEYCODE_J)) { - if (i >= 2) i-=2; while( i > 0 && RAM[i] ) i--; i++; + if (i >= 2) i -= 2; while (i > 0 && RAM[i]) i--; i++; } dynax_blit_palettes = (c & 0xf) * 0x111; dynax_blit_palbank = (c >> 4) & 1; - bitmap_fill(bitmap,cliprect,0); - memset(dynax_pixmap[0][0],0,sizeof(UINT8)*0x100*0x100); - if (layer_layout != LAYOUT_MJDIALQ2) - memset(dynax_pixmap[0][1],0,sizeof(UINT8)*0x100*0x100); - for (hanamai_layer_half = 0; hanamai_layer_half < 2; hanamai_layer_half++) - blitter_drawgfx(machine,0,1,"gfx1",i,0,cliprect->min_x,cliprect->min_y,3,0); - if (layer_layout != LAYOUT_MJDIALQ2) hanamai_copylayer(bitmap, cliprect, 0); - else mjdialq2_copylayer(bitmap,cliprect, 0); - popmessage("%06X C%02X",i,c); + bitmap_fill(bitmap, cliprect, 0); + memset(state->pixmap[0][0], 0, sizeof(UINT8) * 0x100 * 0x100); + + if (state->layer_layout != LAYOUT_MJDIALQ2) + memset(state->pixmap[0][1], 0, sizeof(UINT8) * 0x100 * 0x100); + for (state->hanamai_layer_half = 0; state->hanamai_layer_half < 2; state->hanamai_layer_half++) + blitter_drawgfx(machine, 0, 1, "gfx1", i, 0, cliprect->min_x, cliprect->min_y, 3, 0); + + if (state->layer_layout != LAYOUT_MJDIALQ2) + hanamai_copylayer(machine, bitmap, cliprect, 0); + else + mjdialq2_copylayer(machine, bitmap, cliprect, 0); + + popmessage("%06X C%02X", i, c); return 1; } @@ -1130,21 +1283,24 @@ static int debug_viewer(running_machine *machine, bitmap_t *bitmap,const rectang VIDEO_UPDATE( hanamai ) { - int layers_ctrl = ~dynax_layer_enable; + dynax_state *state = (dynax_state *)screen->machine->driver_data; + int layers_ctrl = ~state->layer_enable; int lay[4]; - if (debug_viewer(screen->machine,bitmap,cliprect)) return 0; + if (debug_viewer(screen->machine, bitmap, cliprect)) + return 0; + layers_ctrl &= debug_mask(screen->machine); - bitmap_fill(bitmap, cliprect, - (dynax_blit_backpen & 0xff) + (dynax_blit_palbank & 1) * 256); + bitmap_fill(bitmap, cliprect, (state->blit_backpen & 0xff) + (state->blit_palbank & 1) * 256); /* bit 4 = display enable? */ - if (!(hanamai_priority & 0x10)) return 0; + if (!(state->hanamai_priority & 0x10)) + return 0; - switch (hanamai_priority) + switch (state->hanamai_priority) { - default: popmessage("unknown priority %02x",hanamai_priority); + default: popmessage("unknown priority %02x", state->hanamai_priority); case 0x10: lay[0] = 0; lay[1] = 1; lay[2] = 2; lay[3] = 3; break; case 0x11: lay[0] = 0; lay[1] = 3; lay[2] = 2; lay[3] = 1; break; case 0x12: lay[0] = 0; lay[1] = 1; lay[2] = 3; lay[3] = 2; break; @@ -1153,44 +1309,46 @@ VIDEO_UPDATE( hanamai ) case 0x15: lay[0] = 0; lay[1] = 2; lay[2] = 3; lay[3] = 1; break; } - if (layers_ctrl & (1 << lay[0])) hanamai_copylayer( bitmap, cliprect, lay[0] ); - if (layers_ctrl & (1 << lay[1])) hanamai_copylayer( bitmap, cliprect, lay[1] ); - if (layers_ctrl & (1 << lay[2])) hanamai_copylayer( bitmap, cliprect, lay[2] ); - if (layers_ctrl & (1 << lay[3])) hanamai_copylayer( bitmap, cliprect, lay[3] ); + if (BIT(layers_ctrl, lay[0])) hanamai_copylayer(screen->machine, bitmap, cliprect, lay[0]); + if (BIT(layers_ctrl, lay[1])) hanamai_copylayer(screen->machine, bitmap, cliprect, lay[1]); + if (BIT(layers_ctrl, lay[2])) hanamai_copylayer(screen->machine, bitmap, cliprect, lay[2]); + if (BIT(layers_ctrl, lay[3])) hanamai_copylayer(screen->machine, bitmap, cliprect, lay[3]); return 0; } VIDEO_UPDATE( hnoridur ) { - int layers_ctrl = ~BITSWAP8(hanamai_priority, 7,6,5,4, 0,1,2,3); + dynax_state *state = (dynax_state *)screen->machine->driver_data; + int layers_ctrl = ~BITSWAP8(state->hanamai_priority, 7, 6, 5, 4, 0, 1, 2, 3); int lay[4]; int pri; - if (debug_viewer(screen->machine,bitmap,cliprect)) return 0; + if (debug_viewer(screen->machine, bitmap, cliprect)) + return 0; + layers_ctrl &= debug_mask(screen->machine); - bitmap_fill(bitmap, cliprect, - (dynax_blit_backpen & 0xff) + (dynax_blit_palbank & 0x0f) * 256); + bitmap_fill(bitmap, cliprect, (state->blit_backpen & 0xff) + (state->blit_palbank & 0x0f) * 256); - pri = hanamai_priority >> 4; + pri = state->hanamai_priority >> 4; if (pri > 7) { - popmessage("unknown priority %02x",hanamai_priority); + popmessage("unknown priority %02x", state->hanamai_priority); pri = 0; } - pri = priority_table[pri]; + pri = state->priority_table[pri]; lay[0] = (pri >> 12) & 3; lay[1] = (pri >> 8) & 3; lay[2] = (pri >> 4) & 3; lay[3] = (pri >> 0) & 3; - if (layers_ctrl & (1 << lay[0])) hanamai_copylayer( bitmap, cliprect, lay[0] ); - if (layers_ctrl & (1 << lay[1])) hanamai_copylayer( bitmap, cliprect, lay[1] ); - if (layers_ctrl & (1 << lay[2])) hanamai_copylayer( bitmap, cliprect, lay[2] ); - if (layers_ctrl & (1 << lay[3])) hanamai_copylayer( bitmap, cliprect, lay[3] ); + if (BIT(layers_ctrl, lay[0])) hanamai_copylayer(screen->machine, bitmap, cliprect, lay[0]); + if (BIT(layers_ctrl, lay[1])) hanamai_copylayer(screen->machine, bitmap, cliprect, lay[1]); + if (BIT(layers_ctrl, lay[2])) hanamai_copylayer(screen->machine, bitmap, cliprect, lay[2]); + if (BIT(layers_ctrl, lay[3])) hanamai_copylayer(screen->machine, bitmap, cliprect, lay[3]); return 0; } @@ -1198,47 +1356,48 @@ VIDEO_UPDATE( hnoridur ) VIDEO_UPDATE( sprtmtch ) { - int layers_ctrl = ~dynax_layer_enable; + dynax_state *state = (dynax_state *)screen->machine->driver_data; + int layers_ctrl = ~state->layer_enable; + + if (debug_viewer(screen->machine,bitmap,cliprect)) + return 0; - if (debug_viewer(screen->machine,bitmap,cliprect)) return 0; layers_ctrl &= debug_mask(screen->machine); - bitmap_fill(bitmap, cliprect, - (dynax_blit_backpen & 0xff) + (dynax_blit_palbank & 1) * 256); + bitmap_fill(bitmap, cliprect, (state->blit_backpen & 0xff) + (state->blit_palbank & 1) * 256); - if (layers_ctrl & 1) hanamai_copylayer( bitmap, cliprect, 0 ); - if (layers_ctrl & 2) hanamai_copylayer( bitmap, cliprect, 1 ); - if (layers_ctrl & 4) hanamai_copylayer( bitmap, cliprect, 2 ); + if (BIT(layers_ctrl, 0)) hanamai_copylayer(screen->machine, bitmap, cliprect, 0); + if (BIT(layers_ctrl, 1)) hanamai_copylayer(screen->machine, bitmap, cliprect, 1); + if (BIT(layers_ctrl, 2)) hanamai_copylayer(screen->machine, bitmap, cliprect, 2); return 0; } VIDEO_UPDATE( jantouki ) { - int layers_ctrl = dynax_layer_enable; + dynax_state *state = (dynax_state *)screen->machine->driver_data; + int layers_ctrl = state->layer_enable; - running_device *top_screen = devtag_get_device(screen->machine, "top"); - running_device *bottom_screen = devtag_get_device(screen->machine, "bottom"); + if (debug_viewer(screen->machine, bitmap, cliprect)) + return 0; - if (debug_viewer(screen->machine,bitmap,cliprect)) return 0; layers_ctrl &= debug_mask(screen->machine); - bitmap_fill(bitmap, cliprect, - (dynax_blit_backpen & 0xff) + (dynax_blit_palbank & 1) * 256); + bitmap_fill(bitmap, cliprect, (state->blit_backpen & 0xff) + (state->blit_palbank & 1) * 256); - if (screen == top_screen) + if (screen == state->top_scr) { - // if (layers_ctrl & 0x01) jantouki_copylayer( bitmap, cliprect, 3, 0 ); - if (layers_ctrl & 0x02) jantouki_copylayer( bitmap, cliprect, 2, 0 ); - if (layers_ctrl & 0x04) jantouki_copylayer( bitmap, cliprect, 1, 0 ); - if (layers_ctrl & 0x08) jantouki_copylayer( bitmap, cliprect, 0, 0 ); + // if (BIT(layers_ctrl, 0)) jantouki_copylayer(screen->machine, bitmap, cliprect, 3, 0); + if (BIT(layers_ctrl, 1)) jantouki_copylayer(screen->machine, bitmap, cliprect, 2, 0); + if (BIT(layers_ctrl, 2)) jantouki_copylayer(screen->machine, bitmap, cliprect, 1, 0); + if (BIT(layers_ctrl, 3)) jantouki_copylayer(screen->machine, bitmap, cliprect, 0, 0); } - else if (screen == bottom_screen) + else if (screen == state->bot_scr) { - if (layers_ctrl & 0x01) jantouki_copylayer( bitmap, cliprect, 3, 0 ); - if (layers_ctrl & 0x10) jantouki_copylayer( bitmap, cliprect, 7, 0 ); - if (layers_ctrl & 0x20) jantouki_copylayer( bitmap, cliprect, 6, 0 ); - if (layers_ctrl & 0x40) jantouki_copylayer( bitmap, cliprect, 5, 0 ); - if (layers_ctrl & 0x80) jantouki_copylayer( bitmap, cliprect, 4, 0 ); + if (BIT(layers_ctrl, 0)) jantouki_copylayer(screen->machine, bitmap, cliprect, 3, 0); + if (BIT(layers_ctrl, 4)) jantouki_copylayer(screen->machine, bitmap, cliprect, 7, 0); + if (BIT(layers_ctrl, 5)) jantouki_copylayer(screen->machine, bitmap, cliprect, 6, 0); + if (BIT(layers_ctrl, 6)) jantouki_copylayer(screen->machine, bitmap, cliprect, 5, 0); + if (BIT(layers_ctrl, 7)) jantouki_copylayer(screen->machine, bitmap, cliprect, 4, 0); } return 0; } @@ -1246,16 +1405,18 @@ VIDEO_UPDATE( jantouki ) VIDEO_UPDATE( mjdialq2 ) { - int layers_ctrl = ~dynax_layer_enable; + dynax_state *state = (dynax_state *)screen->machine->driver_data; + int layers_ctrl = ~state->layer_enable; + + if (debug_viewer(screen->machine, bitmap, cliprect)) + return 0; - if (debug_viewer(screen->machine,bitmap,cliprect)) return 0; layers_ctrl &= debug_mask(screen->machine); - bitmap_fill(bitmap, cliprect, - (dynax_blit_backpen & 0xff) + (dynax_blit_palbank & 1) * 256); + bitmap_fill(bitmap, cliprect, (state->blit_backpen & 0xff) + (state->blit_palbank & 1) * 256); - if (layers_ctrl & 1) mjdialq2_copylayer( bitmap, cliprect, 0 ); - if (layers_ctrl & 2) mjdialq2_copylayer( bitmap, cliprect, 1 ); + if (BIT(layers_ctrl, 0)) mjdialq2_copylayer(screen->machine, bitmap, cliprect, 0); + if (BIT(layers_ctrl, 1)) mjdialq2_copylayer(screen->machine, bitmap, cliprect, 1); return 0; } @@ -1269,18 +1430,20 @@ VIDEO_START(htengoku) VIDEO_UPDATE(htengoku) { - int layer,x,y; + dynax_state *state = (dynax_state *)screen->machine->driver_data; + int layer, x, y; // render the layers, one by one, "dynax.c" style. Then convert the pixmaps to "ddenlovr.c" // format and let VIDEO_UPDATE(ddenlovr) do the final compositing (priorities + palettes) for (layer = 0; layer < 4; layer++) { - bitmap_fill(bitmap,cliprect,0); - hanamai_copylayer( bitmap, cliprect, layer ); + bitmap_fill(bitmap, cliprect, 0); + hanamai_copylayer(screen->machine, bitmap, cliprect, layer); - for (y=0; y < 256; y++) - for (x=0; x < 512; x++) - ddenlovr_pixmap[3-layer][y*512+x] = (UINT8)(*BITMAP_ADDR16(bitmap, y,x)); + for (y = 0; y < 256; y++) + for (x = 0; x < 512; x++) + state->ddenlovr_pixmap[3 - layer][y * 512 + x] = (UINT8)(*BITMAP_ADDR16(bitmap, y, x)); } + return VIDEO_UPDATE_CALL(ddenlovr); }