static WRITE8_HANDLER( videopin_led_w )
{
static const char* matrix[8][4] =
{
{ "LED26", "LED18", "LED11", "LED13" },
{ "LED25", "LED17", "LED10", "LED08" },
{ "LED24", "LED29", "LED09", "LED07" },
{ "LED23", "LED28", "LED04", "LED06" },
{ "LED22", "LED27", "LED03", "LED05" },
{ "LED21", "LED16", "LED02", "-" },
{ "LED20", "LED15", "LED01", "-" },
{ "LED19", "LED14", "LED12", "-" }
};
int i = (cpu_getscanline() >> 5) & 7;
artwork_show(matrix[i][0], data & 1);
artwork_show(matrix[i][1], data & 2);
artwork_show(matrix[i][2], data & 4);
artwork_show(matrix[i][3], data & 8);
if (i == 7)
{
set_led_status(0, data & 8); /* start button */
}
cpunum_set_input_line(0, 0, CLEAR_LINE);
}
static void update_palette(void)
{
int scanline = cpu_getscanline(), i;
if (scanline > 255) scanline = 0;
/* special case: the scanline is the same as last time, but a screen refresh has occurred */
if (scanline == last_scanline_palette && screen_refresh_counter)
{
for (i = 0; i < 256; i++)
{
/* mark the scanline dirty if it was a different palette */
if (scanline_palette[i] != palettebank_vis)
scanline_dirty[i] = 1;
scanline_palette[i] = palettebank_vis;
}
}
/* fill in the scanlines up till now */
else
{
for (i = last_scanline_palette; i != scanline; i = (i + 1) & 255)
{
/* mark the scanline dirty if it was a different palette */
if (scanline_palette[i] != palettebank_vis)
scanline_dirty[i] = 1;
scanline_palette[i] = palettebank_vis;
}
/* remember where we left off */
last_scanline_palette = scanline;
}
/* reset the screen refresh counter */
screen_refresh_counter = 0;
}
static READ8_HANDLER( register_r )
{
int regnum = offset >> 2;
UINT16 result;
/* extract the correct portion of the register */
result = tms34061.regs[regnum];
/* special cases: */
switch (regnum)
{
/* status register: a read here clears it */
case TMS34061_STATUS:
tms34061.regs[TMS34061_STATUS] = 0;
update_interrupts();
break;
/* vertical count register: return the current scanline */
case TMS34061_VERCOUNTER:
result = (cpu_getscanline() + tms34061.regs[TMS34061_VERENDBLNK]) % tms34061.regs[TMS34061_VERTOTAL];
break;
}
/* log it */
if (VERBOSE) logerror("%04X:tms34061 %s read = %04X\n", activecpu_get_pc(), regnames[regnum], result);
return (offset & 0x02) ? (result >> 8) : result;
}
static WRITE_HANDLER( blockade_videoram_w )
{
videoram_w(offset, data);
if (input_port_3_r(0) & 0x80)
{
logerror("blockade_videoram_w: scanline %d\n", cpu_getscanline());
cpu_spinuntil_int();
}
}
void system18_set_grayscale(int enable)
{
enable = (enable != 0);
if (enable != grayscale_enable)
{
force_partial_update(cpu_getscanline());
grayscale_enable = enable;
/* printf("Grayscale = %02X\n", enable); */
}
}
void system18_set_grayscale(int enable)
{
enable = (enable != 0);
if (enable != grayscale_enable)
{
video_screen_update_partial(0, cpu_getscanline());
grayscale_enable = enable;
// mame_printf_debug("Grayscale = %02X\n", enable);
}
}
ADDRESS_MAP_END
static READ8_HANDLER(homerun_40_r)
{
if(cpu_getscanline()>116)
return input_port_0_r(0)|0x40;
else
return input_port_0_r(0);
}
void system18_set_vdp_mixing(int mixing)
{
if (mixing != vdp_mixing)
{
force_partial_update(cpu_getscanline());
vdp_mixing = mixing;
#if DEBUG_VDP
printf("VDP mixing = %02X\n", mixing);
#endif
}
}
void system18_set_vdp_mixing(int mixing)
{
if (mixing != vdp_mixing)
{
video_screen_update_partial(0, cpu_getscanline());
vdp_mixing = mixing;
#if DEBUG_VDP
mame_printf_debug("VDP mixing = %02X\n", mixing);
#endif
}
}
void badlands_pf_bank_w(int offset, int data)
{
int oldword = READ_WORD(&atarigen_playfieldram[offset]);
int newword = COMBINE_WORD(oldword, data);
if (oldword != newword)
{
pf_state.param[0] = data & 1;
atarigen_pf_update(&pf_state, cpu_getscanline());
}
}
static WRITE8_HANDLER( register_w )
{
int regnum = offset >> 2;
/* certain registers affect the display directly */
if ((regnum >= TMS34061_HORENDSYNC && regnum <= TMS34061_DISPSTART) ||
(regnum == TMS34061_CONTROL2))
video_screen_update_partial(0, cpu_getscanline());
/* store the hi/lo half */
if (offset & 0x02)
tms34061.regs[regnum] = (tms34061.regs[regnum] & 0x00ff) | (data << 8);
else
tms34061.regs[regnum] = (tms34061.regs[regnum] & 0xff00) | data;
/* log it */
if (VERBOSE) logerror("%04X:tms34061 %s = %04X\n", activecpu_get_pc(), regnames[regnum], tms34061.regs[regnum]);
/* update the state of things */
switch (regnum)
{
/* vertical interrupt: adjust the timer */
case TMS34061_VERINT:
timer_adjust(tms34061.timer, get_verint_scanline_time(), 0, 0);
break;
/* XY offset: set the X and Y masks */
case TMS34061_XYOFFSET:
switch (tms34061.regs[TMS34061_XYOFFSET] & 0x00ff)
{
case 0x01: tms34061.yshift = 2; break;
case 0x02: tms34061.yshift = 3; break;
case 0x04: tms34061.yshift = 4; break;
case 0x08: tms34061.yshift = 5; break;
case 0x10: tms34061.yshift = 6; break;
case 0x20: tms34061.yshift = 7; break;
case 0x40: tms34061.yshift = 8; break;
case 0x80: tms34061.yshift = 9; break;
default: logerror("Invalid value for XYOFFSET = %04x\n", tms34061.regs[TMS34061_XYOFFSET]); break;
}
tms34061.xmask = (1 << tms34061.yshift) - 1;
break;
/* CONTROL1: they could have turned interrupts on */
case TMS34061_CONTROL1:
update_interrupts();
break;
/* other supported registers */
case TMS34061_XYADDRESS:
break;
}
}
void system18_set_vdp_enable(int enable)
{
enable = (enable != 0);
if (enable != vdp_enable)
{
video_screen_update_partial(0, cpu_getscanline());
vdp_enable = enable;
#if DEBUG_VDP
mame_printf_debug("VDP enable = %02X\n", enable);
#endif
}
}
void system18_set_vdp_enable(int enable)
{
enable = (enable != 0);
if (enable != vdp_enable)
{
force_partial_update(cpu_getscanline());
vdp_enable = enable;
#if DEBUG_VDP
printf("VDP enable = %02X\n", enable);
#endif
}
}
/* Video Interface */
static READ32_HANDLER( vi_reg_r )
{
switch (offset)
{
case 0x10/4: /* VI_CURRENT_REG */
return cpu_getscanline();
default:
logerror("vi_reg_r: %08X, %08X\n", offset, mem_mask);
}
return 0;
}
static READ_HANDLER( sprint2_sync_r )
{
UINT8 val = 0;
if (attract != 0)
{
val |= 0x10;
}
if (cpu_getscanline() == 261)
{
val |= 0x20; /* VRESET */
}
if (cpu_getscanline() >= 224)
{
val |= 0x40; /* VBLANK */
}
if (cpu_getscanline() >= 131)
{
val |= 0x80; /* 60 Hz? */
}
return val;
}
static READ8_HANDLER( wolfpack_misc_r )
{
UINT8 val = 0;
/* BIT0 => SPEECH BUSY */
/* BIT1 => COMP SIREN */
/* BIT2 => SPARE */
/* BIT3 => SPARE */
/* BIT4 => COL DETECT */
/* BIT5 => UNUSED */
/* BIT6 => UNUSED */
/* BIT7 => VBLANK */
if (!wolfpack_collision)
{
val |= 0x10;
}
if (cpu_getscanline() >= 240)
{
val |= 0x80;
}
return val;
}
static READ8_HANDLER( dorachan_status_r )
{
/* to avoid resetting (when player 2 starts) bit 0 need to be reversed when screen is flipped */
return ((cpu_getscanline()>100)?1:0)^(dorachan_ctrl>>6);
}
/* set the display enable bit */
void segac2_enable_display(int enable)
{
if (!cpu_getvblank())
force_partial_update(cpu_getscanline() + scanbase);
display_enable = enable;
}
atarigen_mo_free();
}
/*************************************
*
* Video data latch
*
*************************************/
void skullxbo_hscroll_w(int offset, int data)
{
/* update the playfield state */
pf_state.hscroll = (data >> 7) << 1;
atarigen_pf_update(&pf_state, cpu_getscanline());
}
void skullxbo_vscroll_w(int offset, int data)
{
/* adjust for the scanline we're currently on */
int scanline = cpu_getscanline();
if (scanline >= YDIM) scanline -= YDIM;
/* update the playfield state */
pf_state.vscroll = ((data >> 7) - scanline) & 0x1ff;
atarigen_pf_update(&pf_state, scanline);
}
/* set the display enable bit */
void segac2_enable_display(int enable)
{
if (!cpu_getvblank())
video_screen_update_partial(0, cpu_getscanline());
display_enable = enable;
}
void draw_border(mame_bitmap *bitmap,
int full_refresh, /* Full refresh flag */
int TopBorderLines, /* Border lines before actual screen */
int ScreenLines, /* Screen height in pixels */
int BottomBorderLines, /* Border lines below screen */
int LeftBorderPixels, /* Border pixels to the left of each screen line */
int ScreenPixels, /* Width of actual screen in pixels */
int RightBorderPixels, /* Border pixels to the right of each screen line */
int LeftBorderCycles, /* Cycles taken to draw left border of each scan line */
int ScreenCycles, /* Cycles taken to draw screen data part of each scan line */
int RightBorderCycles, /* Cycles taken to draw right border of each scan line */
int HorizontalRetraceCycles, /* Cycles taken to return to LHS of CRT after each scan line */
int VRetraceTime, /* Cycles taken before start of first border line */
int EventID) /* Event ID of border messages */
{
EVENT_LIST_ITEM *pItem;
int TotalScreenHeight = TopBorderLines+ScreenLines+BottomBorderLines;
int TotalScreenWidth = LeftBorderPixels+ScreenPixels+RightBorderPixels;
int DisplayCyclesPerLine = LeftBorderCycles+ScreenCycles+RightBorderCycles;
int CyclesPerLine = DisplayCyclesPerLine+HorizontalRetraceCycles;
int CyclesSoFar = 0;
int NumItems, CurrItem = 0, NextItem;
int Count, ScrX, NextScrX, ScrY;
rectangle r;
pItem = EventList_GetFirstItem();
NumItems = EventList_NumEvents();
if (NumItems)
{
int CyclesPerFrame = (int)(Machine->drv->cpu[0].cpu_clock / Machine->drv->frames_per_second);
logerror ("Event count = %d, curr cycle = %ld, total cycles = %ld \n", (int) NumItems, (long) TIME_TO_CYCLES(0,cpu_getscanline()*cpu_getscanlineperiod()), (long) CyclesPerFrame);
}
for (Count = 0; Count < NumItems; Count++)
{
logerror ("Event no %05d, ID = %04x, data = %04x, time = %ld\n", Count, pItem[Count].Event_ID, pItem[Count].Event_Data, (long) pItem[Count].Event_Time);
}
/* Find the first and second events with the correct ID */
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID))
CurrItem++;
NextItem = CurrItem + 1;
while ((NextItem < NumItems) && (pItem[NextItem].Event_ID != EventID))
NextItem++;
/* Single border colour */
if ((CurrItem < NumItems) && (NextItem >= NumItems))
CurrBorderColor = pItem[CurrItem].Event_Data;
if ((NextItem >= NumItems) && (CurrBorderColor==LastDisplayedBorderColor) && !full_refresh)
{
/* Do nothing if border colour has not changed */
}
else if (NextItem >= NumItems)
{
/* Single border colour - this is not strictly correct as the
colour change may have occurred midway through the frame
or after the last visible border line however the whole
border would be redrawn in the correct colour during the
next frame anyway! */
r.min_x = 0;
r.max_x = TotalScreenWidth-1;
r.min_y = 0;
r.max_y = TopBorderLines-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
r.min_x = 0;
r.max_x = LeftBorderPixels-1;
r.min_y = TopBorderLines;
r.max_y = TopBorderLines+ScreenLines-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
r.min_x = LeftBorderPixels+ScreenPixels;
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
r.min_x = 0;
r.max_x = TotalScreenWidth-1;
r.min_y = TopBorderLines+ScreenLines;
r.max_y = TotalScreenHeight-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
logerror ("Setting border colour to %d (Last = %d, Full Refresh = %d)\n", CurrBorderColor, LastDisplayedBorderColor, full_refresh);
LastDisplayedBorderColor = CurrBorderColor;
}
else
{
/* Multiple border colours */
/* Process entries before first displayed line */
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time <= VRetraceTime))
{
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
/* Draw top border */
CyclesSoFar = VRetraceTime;
for (ScrY = 0; ScrY < TopBorderLines; ScrY++)
{
r.min_x = 0;
r.min_y = r.max_y = ScrY;
if ((CurrItem >= NumItems) || (pItem[CurrItem].Event_Time >= (CyclesSoFar+DisplayCyclesPerLine)))
{
/* Single colour on line */
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
else
{
/* Multiple colours on a line */
ScrX = (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)TotalScreenWidth / (float)DisplayCyclesPerLine;
r.max_x = ScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time < (CyclesSoFar+DisplayCyclesPerLine)))
{
NextScrX = (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)TotalScreenWidth / (float)DisplayCyclesPerLine;
r.min_x = ScrX;
r.max_x = NextScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
ScrX = NextScrX;
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
r.min_x = ScrX;
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
/* Process colour changes during horizontal retrace */
CyclesSoFar+= CyclesPerLine;
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time <= CyclesSoFar))
{
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
}
/* Draw left and right borders next to screen lines */
for (ScrY = TopBorderLines; ScrY < (TopBorderLines+ScreenLines); ScrY++)
{
/* Draw left hand border */
r.min_x = 0;
r.min_y = r.max_y = ScrY;
if ((CurrItem >= NumItems) || (pItem[CurrItem].Event_Time >= (CyclesSoFar+LeftBorderCycles)))
{
/* Single colour */
r.max_x = LeftBorderPixels-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
else
{
/* Multiple colours */
ScrX = (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)LeftBorderPixels / (float)LeftBorderCycles;
r.max_x = ScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time < (CyclesSoFar+LeftBorderCycles)))
{
NextScrX = (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)LeftBorderPixels / (float)LeftBorderCycles;
r.min_x = ScrX;
r.max_x = NextScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
ScrX = NextScrX;
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
r.min_x = ScrX;
r.max_x = LeftBorderPixels-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
/* Process colour changes during screen draw */
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time <= (CyclesSoFar+LeftBorderCycles+ScreenCycles)))
{
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
/* Draw right hand border */
r.min_x = LeftBorderPixels+ScreenPixels;
if ((CurrItem >= NumItems) || (pItem[CurrItem].Event_Time >= (CyclesSoFar+DisplayCyclesPerLine)))
{
/* Single colour */
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
else
{
/* Multiple colours */
ScrX = LeftBorderPixels + ScreenPixels + (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)RightBorderPixels / (float)RightBorderCycles;
r.max_x = ScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time < (CyclesSoFar+DisplayCyclesPerLine)))
{
NextScrX = LeftBorderPixels + ScreenPixels + (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)RightBorderPixels / (float)RightBorderCycles;
r.min_x = ScrX;
r.max_x = NextScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
ScrX = NextScrX;
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
r.min_x = ScrX;
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
/* Process colour changes during horizontal retrace */
CyclesSoFar+= CyclesPerLine;
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time <= CyclesSoFar))
{
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
}
/* Draw bottom border */
for (ScrY = TopBorderLines+ScreenLines; ScrY < TotalScreenHeight; ScrY++)
{
r.min_x = 0;
r.min_y = r.max_y = ScrY;
if ((CurrItem >= NumItems) || (pItem[CurrItem].Event_Time >= (CyclesSoFar+DisplayCyclesPerLine)))
{
/* Single colour on line */
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
else
{
/* Multiple colours on a line */
ScrX = (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)TotalScreenWidth / (float)DisplayCyclesPerLine;
r.max_x = ScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time < (CyclesSoFar+DisplayCyclesPerLine)))
{
NextScrX = (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)TotalScreenWidth / (float)DisplayCyclesPerLine;
r.min_x = ScrX;
r.max_x = NextScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
ScrX = NextScrX;
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
r.min_x = ScrX;
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
/* Process colour changes during horizontal retrace */
CyclesSoFar+= CyclesPerLine;
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time <= CyclesSoFar))
{
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
}
/* Process colour changes after last displayed line */
while (CurrItem < NumItems)
{
if (pItem[CurrItem].Event_ID == EventID)
CurrBorderColor = pItem[CurrItem].Event_Data;
CurrItem++;
}
/* Set value to ensure redraw on next frame */
LastDisplayedBorderColor = -1;
logerror ("Multi coloured border drawn (last colour = %d)\n", CurrBorderColor);
}
/* Assume all other routines have processed their data from the list */
EventList_Reset();
EventList_SetOffsetStartTime ( TIME_TO_CYCLES(0,cpu_getscanline()*cpu_getscanlineperiod()) );
}
static void generate_interrupt(int state)
{
itech8_update_interrupts(-1, state, -1);
if (FULL_LOGGING && state) logerror("------------ DISPLAY INT (%d) --------------\n", cpu_getscanline());
}
void leland_vram_port_w(int offset, int data, int num)
{
struct vram_state_data *state = vram_state + num;
int addr = state->addr;
int plane = state->plane;
int inc = (offset >> 3) & 1;
int trans = (offset >> 4) & num;
/* if we're writing "behind the beam", make sure we've cached what was there */
if (addr < 0x7800)
{
int cur_scanline = cpu_getscanline();
int mod_scanline = addr / 0x80;
if (cur_scanline != next_update_scanline && mod_scanline < cur_scanline)
update_for_scanline(cur_scanline);
}
/*if (LOG_COMM && addr >= 0x7800)
logerror("%04X:%s comm write %04X = %02X\n", cpu_getpreviouspc(), num ? "slave" : "master", addr, data);*/
/* based on the low 3 bits of the offset, update the destination */
switch (offset & 7)
{
case 1: /* write hi = data, lo = latch */
leland_video_ram[addr + VRAM_HI] = data;
leland_video_ram[addr + VRAM_LO] = state->latch[0];
addr += inc;
break;
case 2: /* write hi = latch, lo = data */
leland_video_ram[addr + VRAM_HI] = state->latch[1];
leland_video_ram[addr + VRAM_LO] = data;
addr += inc;
break;
case 3: /* write hi/lo = data (alternating) */
if (trans)
{
if (!(data & 0xf0)) data |= leland_video_ram[addr + plane * VRAM_HI] & 0xf0;
if (!(data & 0x0f)) data |= leland_video_ram[addr + plane * VRAM_HI] & 0x0f;
}
leland_video_ram[addr + plane * VRAM_HI] = data;
addr += inc & plane;
plane ^= 1;
break;
case 5: /* write hi = data */
state->latch[1] = data;
if (trans)
{
if (!(data & 0xf0)) data |= leland_video_ram[addr + VRAM_HI] & 0xf0;
if (!(data & 0x0f)) data |= leland_video_ram[addr + VRAM_HI] & 0x0f;
}
leland_video_ram[addr + VRAM_HI] = data;
addr += inc;
break;
case 6: /* write lo = data */
state->latch[0] = data;
if (trans)
{
if (!(data & 0xf0)) data |= leland_video_ram[addr + VRAM_LO] & 0xf0;
if (!(data & 0x0f)) data |= leland_video_ram[addr + VRAM_LO] & 0x0f;
}
leland_video_ram[addr + VRAM_LO] = data;
addr += inc;
break;
default:
/*logerror("CPU #%d %04x Warning: Unknown video port %02x write (address=%04x value=%02x)\n",
cpu_getactivecpu(),cpu_get_pc(), offset, addr);*/
break;
}
/* update the address and plane */
state->addr = addr & 0x7fff;
state->plane = plane;
}
