Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-06-28 15:14:21 +03:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

some more Voodoo cleanup (nw)

Browse Source
This commit is contained in:
Vas Crabb 2017-05-25 17:26:08 +10:00
parent 2a82145b2e
commit 23e1e845a8
2 changed files with 162 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

350
src/devices/video/voodoo.cpp
View File

@ -416,24 +416,21 @@ int voodoo_device::voodoo_update(bitmap_rgb32 &bitmap, const rectangle &cliprect
int voodoo_device::voodoo_get_type() int voodoo_device::voodoo_get_type()
{ {
voodoo_device *vd = this; return vd_type;
return vd->vd_type;
} }
int voodoo_device::voodoo_is_stalled() int voodoo_device::voodoo_is_stalled()
{ {
voodoo_device *vd = this; return pci.stall_state != NOT_STALLED;
return (vd->pci.stall_state != NOT_STALLED);
} }
void voodoo_device::voodoo_set_init_enable(uint32_t newval) void voodoo_device::voodoo_set_init_enable(uint32_t newval)
{ {
voodoo_device *vd = this; pci.init_enable = newval;
vd->pci.init_enable = newval;
if (LOG_REGISTERS) if (LOG_REGISTERS)
logerror("VOODOO.%d.REG:initEnable write = %08X\n", vd->index, newval); logerror("VOODOO.%d.REG:initEnable write = %08X\n", index, newval);
} }
@ -530,73 +527,71 @@ void voodoo_device::tmu_shared_state::init()
} }
void voodoo_device::init_tmu(voodoo_device* vd, tmu_state *t, voodoo_reg *reg, void *memory, int tmem) void voodoo_device::tmu_state::init(uint8_t vdt, tmu_shared_state &share, voodoo_reg *r, void *memory, int tmem)
{ {
/* allocate texture RAM */ /* allocate texture RAM */
t->ram = (uint8_t *)memory; ram = reinterpret_cast<uint8_t *>(memory);
t->mask = tmem - 1; mask = tmem - 1;
t->reg = reg; reg = r;
t->regdirty = true; regdirty = true;
t->bilinear_mask = (vd->vd_type >= TYPE_VOODOO_2) ? 0xff : 0xf0; bilinear_mask = (vdt >= TYPE_VOODOO_2) ? 0xff : 0xf0;
/* mark the NCC tables dirty and configure their registers */ /* mark the NCC tables dirty and configure their registers */
t->ncc[0].dirty = t->ncc[1].dirty = true; ncc[0].dirty = ncc[1].dirty = true;
t->ncc[0].reg = &t->reg[nccTable+0]; ncc[0].reg = &reg[nccTable+0];
t->ncc[1].reg = &t->reg[nccTable+12]; ncc[1].reg = &reg[nccTable+12];
/* create pointers to all the tables */ /* create pointers to all the tables */
t->texel[0] = vd->tmushare.rgb332; texel[0] = share.rgb332;
t->texel[1] = t->ncc[0].texel; texel[1] = ncc[0].texel;
t->texel[2] = vd->tmushare.alpha8; texel[2] = share.alpha8;
t->texel[3] = vd->tmushare.int8; texel[3] = share.int8;
t->texel[4] = vd->tmushare.ai44; texel[4] = share.ai44;
t->texel[5] = t->palette; texel[5] = palette;
t->texel[6] = (vd->vd_type >= TYPE_VOODOO_2) ? t->palettea : nullptr; texel[6] = (vdt >= TYPE_VOODOO_2) ? palettea : nullptr;
t->texel[7] = nullptr; texel[7] = nullptr;
t->texel[8] = vd->tmushare.rgb332; texel[8] = share.rgb332;
t->texel[9] = t->ncc[0].texel; texel[9] = ncc[0].texel;
t->texel[10] = vd->tmushare.rgb565; texel[10] = share.rgb565;
t->texel[11] = vd->tmushare.argb1555; texel[11] = share.argb1555;
t->texel[12] = vd->tmushare.argb4444; texel[12] = share.argb4444;
t->texel[13] = vd->tmushare.int8; texel[13] = share.int8;
t->texel[14] = t->palette; texel[14] = palette;
t->texel[15] = nullptr; texel[15] = nullptr;
t->lookup = t->texel[0]; lookup = texel[0];
/* attach the palette to NCC table 0 */ /* attach the palette to NCC table 0 */
t->ncc[0].palette = t->palette; ncc[0].palette = palette;
if (vd->vd_type >= TYPE_VOODOO_2) if (vdt >= TYPE_VOODOO_2)
t->ncc[0].palettea = t->palettea; ncc[0].palettea = palettea;
/* set up texture address calculations */ /* set up texture address calculations */
if (vd->vd_type <= TYPE_VOODOO_2) if (vdt <= TYPE_VOODOO_2)
{ {
t->texaddr_mask = 0x0fffff; texaddr_mask = 0x0fffff;
t->texaddr_shift = 3; texaddr_shift = 3;
} }
else else
{ {
t->texaddr_mask = 0xfffff0; texaddr_mask = 0xfffff0;
t->texaddr_shift = 0; texaddr_shift = 0;
} }
} }
void voodoo_device::voodoo_postload(voodoo_device *vd) void voodoo_device::voodoo_postload()
{ {
int index, subindex; fbi.clut_dirty = true;
for (int index = 0; index < ARRAY_LENGTH(tmu); index++)
vd->fbi.clut_dirty = true;
for (index = 0; index < ARRAY_LENGTH(vd->tmu); index++)
{ {
vd->tmu[index].regdirty = true; tmu[index].regdirty = true;
for (subindex = 0; subindex < ARRAY_LENGTH(vd->tmu[index].ncc); subindex++) for (int subindex = 0; subindex < ARRAY_LENGTH(tmu[index].ncc); subindex++)
vd->tmu[index].ncc[subindex].dirty = true; tmu[index].ncc[subindex].dirty = true;
} }
/* recompute video memory to get the FBI FIFO base recomputed */ /* recompute video memory to get the FBI FIFO base recomputed */
if (vd->vd_type <= TYPE_VOODOO_2) if (vd_type <= TYPE_VOODOO_2)
recompute_video_memory(vd); recompute_video_memory();
} }
@ -862,7 +857,7 @@ void voodoo_device::swap_buffers(voodoo_device *vd)
/* we may be able to unstall now */ /* we may be able to unstall now */
if (vd->pci.stall_state != NOT_STALLED) if (vd->pci.stall_state != NOT_STALLED)
check_stalled_cpu(vd, vd->machine().time()); vd->check_stalled_cpu(vd->machine().time());
/* periodically log rasterizer info */ /* periodically log rasterizer info */
vd->stats.swaps++; vd->stats.swaps++;
@ -1051,103 +1046,102 @@ void voodoo_device::soft_reset()
* *
*************************************/ *************************************/
void voodoo_device::recompute_video_memory(voodoo_device *vd) void voodoo_device::recompute_video_memory()
{ {
uint32_t buffer_pages = FBIINIT2_VIDEO_BUFFER_OFFSET(vd->reg[fbiInit2].u); uint32_t const buffer_pages = FBIINIT2_VIDEO_BUFFER_OFFSET(reg[fbiInit2].u);
uint32_t fifo_start_page = FBIINIT4_MEMORY_FIFO_START_ROW(vd->reg[fbiInit4].u); uint32_t const fifo_start_page = FBIINIT4_MEMORY_FIFO_START_ROW(reg[fbiInit4].u);
uint32_t fifo_last_page = FBIINIT4_MEMORY_FIFO_STOP_ROW(vd->reg[fbiInit4].u); uint32_t fifo_last_page = FBIINIT4_MEMORY_FIFO_STOP_ROW(reg[fbiInit4].u);
uint32_t memory_config; uint32_t memory_config;
int buf;
/* memory config is determined differently between V1 and V2 */ /* memory config is determined differently between V1 and V2 */
memory_config = FBIINIT2_ENABLE_TRIPLE_BUF(vd->reg[fbiInit2].u); memory_config = FBIINIT2_ENABLE_TRIPLE_BUF(reg[fbiInit2].u);
if (vd->vd_type == TYPE_VOODOO_2 && memory_config == 0) if (vd_type == TYPE_VOODOO_2 && memory_config == 0)
memory_config = FBIINIT5_BUFFER_ALLOCATION(vd->reg[fbiInit5].u); memory_config = FBIINIT5_BUFFER_ALLOCATION(reg[fbiInit5].u);
/* tiles are 64x16/32; x_tiles specifies how many half-tiles */ /* tiles are 64x16/32; x_tiles specifies how many half-tiles */
vd->fbi.tile_width = (vd->vd_type == TYPE_VOODOO_1) ? 64 : 32; fbi.tile_width = (vd_type == TYPE_VOODOO_1) ? 64 : 32;
vd->fbi.tile_height = (vd->vd_type == TYPE_VOODOO_1) ? 16 : 32; fbi.tile_height = (vd_type == TYPE_VOODOO_1) ? 16 : 32;
vd->fbi.x_tiles = FBIINIT1_X_VIDEO_TILES(vd->reg[fbiInit1].u); fbi.x_tiles = FBIINIT1_X_VIDEO_TILES(reg[fbiInit1].u);
if (vd->vd_type == TYPE_VOODOO_2) if (vd_type == TYPE_VOODOO_2)
{ {
vd->fbi.x_tiles = (vd->fbi.x_tiles << 1) | fbi.x_tiles = (fbi.x_tiles << 1) |
(FBIINIT1_X_VIDEO_TILES_BIT5(vd->reg[fbiInit1].u) << 5) | (FBIINIT1_X_VIDEO_TILES_BIT5(reg[fbiInit1].u) << 5) |
(FBIINIT6_X_VIDEO_TILES_BIT0(vd->reg[fbiInit6].u)); (FBIINIT6_X_VIDEO_TILES_BIT0(reg[fbiInit6].u));
} }
vd->fbi.rowpixels = vd->fbi.tile_width * vd->fbi.x_tiles; fbi.rowpixels = fbi.tile_width * fbi.x_tiles;
// logerror("VOODOO.%d.VIDMEM: buffer_pages=%X fifo=%X-%X tiles=%X rowpix=%d\n", vd->index, buffer_pages, fifo_start_page, fifo_last_page, vd->fbi.x_tiles, vd->fbi.rowpixels); // logerror("VOODOO.%d.VIDMEM: buffer_pages=%X fifo=%X-%X tiles=%X rowpix=%d\n", index, buffer_pages, fifo_start_page, fifo_last_page, fbi.x_tiles, fbi.rowpixels);
/* first RGB buffer always starts at 0 */ /* first RGB buffer always starts at 0 */
vd->fbi.rgboffs[0] = 0; fbi.rgboffs[0] = 0;
/* second RGB buffer starts immediately afterwards */ /* second RGB buffer starts immediately afterwards */
vd->fbi.rgboffs[1] = buffer_pages * 0x1000; fbi.rgboffs[1] = buffer_pages * 0x1000;
/* remaining buffers are based on the config */ /* remaining buffers are based on the config */
switch (memory_config) switch (memory_config)
{ {
case 3: /* reserved */ case 3: /* reserved */
vd->logerror("VOODOO.%d.ERROR:Unexpected memory configuration in recompute_video_memory!\n", vd->index); logerror("VOODOO.%d.ERROR:Unexpected memory configuration in recompute_video_memory!\n", index);
case 0: /* 2 color buffers, 1 aux buffer */ case 0: /* 2 color buffers, 1 aux buffer */
vd->fbi.rgboffs[2] = ~0; fbi.rgboffs[2] = ~0;
vd->fbi.auxoffs = 2 * buffer_pages * 0x1000; fbi.auxoffs = 2 * buffer_pages * 0x1000;
break; break;
case 1: /* 3 color buffers, 0 aux buffers */ case 1: /* 3 color buffers, 0 aux buffers */
vd->fbi.rgboffs[2] = 2 * buffer_pages * 0x1000; fbi.rgboffs[2] = 2 * buffer_pages * 0x1000;
vd->fbi.auxoffs = ~0; fbi.auxoffs = ~0;
break; break;
case 2: /* 3 color buffers, 1 aux buffers */ case 2: /* 3 color buffers, 1 aux buffers */
vd->fbi.rgboffs[2] = 2 * buffer_pages * 0x1000; fbi.rgboffs[2] = 2 * buffer_pages * 0x1000;
vd->fbi.auxoffs = 3 * buffer_pages * 0x1000; fbi.auxoffs = 3 * buffer_pages * 0x1000;
break; break;
} }
/* clamp the RGB buffers to video memory */ /* clamp the RGB buffers to video memory */
for (buf = 0; buf < 3; buf++) for (int buf = 0; buf < 3; buf++)
if (vd->fbi.rgboffs[buf] != ~0 && vd->fbi.rgboffs[buf] > vd->fbi.mask) if (fbi.rgboffs[buf] != ~0 && fbi.rgboffs[buf] > fbi.mask)
vd->fbi.rgboffs[buf] = vd->fbi.mask; fbi.rgboffs[buf] = fbi.mask;
/* clamp the aux buffer to video memory */ /* clamp the aux buffer to video memory */
if (vd->fbi.auxoffs != ~0 && vd->fbi.auxoffs > vd->fbi.mask) if (fbi.auxoffs != ~0 && fbi.auxoffs > fbi.mask)
vd->fbi.auxoffs = vd->fbi.mask; fbi.auxoffs = fbi.mask;
/* osd_printf_debug("rgb[0] = %08X rgb[1] = %08X rgb[2] = %08X aux = %08X\n", /* osd_printf_debug("rgb[0] = %08X rgb[1] = %08X rgb[2] = %08X aux = %08X\n",
vd->fbi.rgboffs[0], vd->fbi.rgboffs[1], vd->fbi.rgboffs[2], vd->fbi.auxoffs);*/ fbi.rgboffs[0], fbi.rgboffs[1], fbi.rgboffs[2], fbi.auxoffs);*/
/* compute the memory FIFO location and size */ /* compute the memory FIFO location and size */
if (fifo_last_page > vd->fbi.mask / 0x1000) if (fifo_last_page > fbi.mask / 0x1000)
fifo_last_page = vd->fbi.mask / 0x1000; fifo_last_page = fbi.mask / 0x1000;
/* is it valid and enabled? */ /* is it valid and enabled? */
if (fifo_start_page <= fifo_last_page && FBIINIT0_ENABLE_MEMORY_FIFO(vd->reg[fbiInit0].u)) if (fifo_start_page <= fifo_last_page && FBIINIT0_ENABLE_MEMORY_FIFO(reg[fbiInit0].u))
{ {
vd->fbi.fifo.base = (uint32_t *)(vd->fbi.ram + fifo_start_page * 0x1000); fbi.fifo.base = (uint32_t *)(fbi.ram + fifo_start_page * 0x1000);
vd->fbi.fifo.size = (fifo_last_page + 1 - fifo_start_page) * 0x1000 / 4; fbi.fifo.size = (fifo_last_page + 1 - fifo_start_page) * 0x1000 / 4;
if (vd->fbi.fifo.size > 65536*2) if (fbi.fifo.size > 65536*2)
vd->fbi.fifo.size = 65536*2; fbi.fifo.size = 65536*2;
} }
/* if not, disable the FIFO */ /* if not, disable the FIFO */
else else
{ {
vd->fbi.fifo.base = nullptr; fbi.fifo.base = nullptr;
vd->fbi.fifo.size = 0; fbi.fifo.size = 0;
} }
/* reset the FIFO */ /* reset the FIFO */
vd->fbi.fifo.reset(); fbi.fifo.reset();
/* reset our front/back buffers if they are out of range */ /* reset our front/back buffers if they are out of range */
if (vd->fbi.rgboffs[2] == ~0) if (fbi.rgboffs[2] == ~0)
{ {
if (vd->fbi.frontbuf == 2) if (fbi.frontbuf == 2)
vd->fbi.frontbuf = 0; fbi.frontbuf = 0;
if (vd->fbi.backbuf == 2) if (fbi.backbuf == 2)
vd->fbi.backbuf = 0; fbi.backbuf = 0;
} }
} }
@ -2076,81 +2070,81 @@ void voodoo_device::cmdfifo_w(voodoo_device *vd, cmdfifo_info *f, offs_t offset,
TIMER_CALLBACK_MEMBER( voodoo_device::stall_cpu_callback ) TIMER_CALLBACK_MEMBER( voodoo_device::stall_cpu_callback )
{ {
check_stalled_cpu(this, machine().time()); check_stalled_cpu(machine().time());
} }
void voodoo_device::check_stalled_cpu(voodoo_device* vd, attotime current_time) void voodoo_device::check_stalled_cpu(attotime current_time)
{ {
int resume = false; int resume = false;
/* flush anything we can */ /* flush anything we can */
if (vd->pci.op_pending) if (pci.op_pending)
flush_fifos(vd, current_time); flush_fifos(this, current_time);
/* if we're just stalled until the LWM is passed, see if we're ok now */ /* if we're just stalled until the LWM is passed, see if we're ok now */
if (vd->pci.stall_state == STALLED_UNTIL_FIFO_LWM) if (pci.stall_state == STALLED_UNTIL_FIFO_LWM)
{ {
/* if there's room in the memory FIFO now, we can proceed */ /* if there's room in the memory FIFO now, we can proceed */
if (FBIINIT0_ENABLE_MEMORY_FIFO(vd->reg[fbiInit0].u)) if (FBIINIT0_ENABLE_MEMORY_FIFO(reg[fbiInit0].u))
{ {
if (vd->fbi.fifo.items() < 2 * 32 * FBIINIT0_MEMORY_FIFO_HWM(vd->reg[fbiInit0].u)) if (fbi.fifo.items() < 2 * 32 * FBIINIT0_MEMORY_FIFO_HWM(reg[fbiInit0].u))
resume = true; resume = true;
} }
else if (vd->pci.fifo.space() > 2 * FBIINIT0_PCI_FIFO_LWM(vd->reg[fbiInit0].u)) else if (pci.fifo.space() > 2 * FBIINIT0_PCI_FIFO_LWM(reg[fbiInit0].u))
resume = true; resume = true;
} }
/* if we're stalled until the FIFOs are empty, check now */ /* if we're stalled until the FIFOs are empty, check now */
else if (vd->pci.stall_state == STALLED_UNTIL_FIFO_EMPTY) else if (pci.stall_state == STALLED_UNTIL_FIFO_EMPTY)
{ {
if (FBIINIT0_ENABLE_MEMORY_FIFO(vd->reg[fbiInit0].u)) if (FBIINIT0_ENABLE_MEMORY_FIFO(reg[fbiInit0].u))
{ {
if (vd->fbi.fifo.empty() && vd->pci.fifo.empty()) if (fbi.fifo.empty() && pci.fifo.empty())
resume = true; resume = true;
} }
else if (vd->pci.fifo.empty()) else if (pci.fifo.empty())
resume = true; resume = true;
} }
/* resume if necessary */ /* resume if necessary */
if (resume || !vd->pci.op_pending) if (resume || !pci.op_pending)
{ {
if (LOG_FIFO) vd->logerror("VOODOO.%d.FIFO:Stall condition cleared; resuming\n", vd->index); if (LOG_FIFO) logerror("VOODOO.%d.FIFO:Stall condition cleared; resuming\n", index);
vd->pci.stall_state = NOT_STALLED; pci.stall_state = NOT_STALLED;
/* either call the callback, or trigger the trigger */ /* either call the callback, or trigger the trigger */
if (!vd->m_stall.isnull()) if (!m_stall.isnull())
vd->m_stall(false); m_stall(false);
else else
vd->machine().scheduler().trigger(vd->trigger); machine().scheduler().trigger(trigger);
} }
/* if not, set a timer for the next one */ /* if not, set a timer for the next one */
else else
{ {
vd->pci.continue_timer->adjust(vd->pci.op_end_time - current_time); pci.continue_timer->adjust(pci.op_end_time - current_time);
} }
} }
void voodoo_device::stall_cpu(voodoo_device *vd, int state, attotime current_time) void voodoo_device::stall_cpu(int state, attotime current_time)
{ {
/* sanity check */ /* sanity check */
if (!vd->pci.op_pending) fatalerror("FIFOs not empty, no op pending!\n"); if (!pci.op_pending) fatalerror("FIFOs not empty, no op pending!\n");
/* set the state and update statistics */ /* set the state and update statistics */
vd->pci.stall_state = state; pci.stall_state = state;
vd->stats.stalls++; stats.stalls++;
/* either call the callback, or spin the CPU */ /* either call the callback, or spin the CPU */
if (!vd->m_stall.isnull()) if (!m_stall.isnull())
vd->m_stall(true); m_stall(true);
else else
vd->cpu->execute().spin_until_trigger(vd->trigger); cpu->execute().spin_until_trigger(trigger);
/* set a timer to clear the stall */ /* set a timer to clear the stall */
vd->pci.continue_timer->adjust(vd->pci.op_end_time - current_time); pci.continue_timer->adjust(pci.op_end_time - current_time);
} }
@ -2626,7 +2620,7 @@ int32_t voodoo_device::register_w(voodoo_device *vd, offs_t offset, uint32_t dat
/* if changing dimensions, update video memory layout */ /* if changing dimensions, update video memory layout */
if (regnum == videoDimensions) if (regnum == videoDimensions)
recompute_video_memory(vd); vd->recompute_video_memory();
} }
} }
break; break;
@ -2641,7 +2635,7 @@ int32_t voodoo_device::register_w(voodoo_device *vd, offs_t offset, uint32_t dat
vd->soft_reset(); vd->soft_reset();
if (FBIINIT0_FIFO_RESET(data)) if (FBIINIT0_FIFO_RESET(data))
vd->pci.fifo.reset(); vd->pci.fifo.reset();
recompute_video_memory(vd); vd->recompute_video_memory();
} }
break; break;
@ -2661,7 +2655,7 @@ int32_t voodoo_device::register_w(voodoo_device *vd, offs_t offset, uint32_t dat
if (vd->vd_type <= TYPE_VOODOO_2 && (chips & 1) && INITEN_ENABLE_HW_INIT(vd->pci.init_enable)) if (vd->vd_type <= TYPE_VOODOO_2 && (chips & 1) && INITEN_ENABLE_HW_INIT(vd->pci.init_enable))
{ {
vd->reg[regnum].u = data; vd->reg[regnum].u = data;
recompute_video_memory(vd); vd->recompute_video_memory();
vd->fbi.video_changed = true; vd->fbi.video_changed = true;
} }
break; break;
@ -2673,7 +2667,7 @@ int32_t voodoo_device::register_w(voodoo_device *vd, offs_t offset, uint32_t dat
vd->reg[regnum].u = data; vd->reg[regnum].u = data;
vd->alt_regmap = FBIINIT3_TRI_REGISTER_REMAP(data); vd->alt_regmap = FBIINIT3_TRI_REGISTER_REMAP(data);
vd->fbi.yorigin = FBIINIT3_YORIGIN_SUBTRACT(vd->reg[fbiInit3].u); vd->fbi.yorigin = FBIINIT3_YORIGIN_SUBTRACT(vd->reg[fbiInit3].u);
recompute_video_memory(vd); vd->recompute_video_memory();
} }
break; break;
@ -2904,25 +2898,20 @@ default_case:
* Voodoo LFB writes * Voodoo LFB writes
* *
*************************************/ *************************************/
int32_t voodoo_device::lfb_direct_w(voodoo_device *vd, offs_t offset, uint32_t data, uint32_t mem_mask) int32_t voodoo_device::lfb_direct_w(offs_t offset, uint32_t data, uint32_t mem_mask)
{ {
uint16_t *dest;
uint32_t destmax;
int x, y;
uint32_t bufoffs;
/* statistics */ /* statistics */
vd->stats.lfb_writes++; stats.lfb_writes++;
/* byte swizzling */ /* byte swizzling */
if (LFBMODE_BYTE_SWIZZLE_WRITES(vd->reg[lfbMode].u)) if (LFBMODE_BYTE_SWIZZLE_WRITES(reg[lfbMode].u))
{ {
data = flipendian_int32(data); data = flipendian_int32(data);
mem_mask = flipendian_int32(mem_mask); mem_mask = flipendian_int32(mem_mask);
} }
/* word swapping */ /* word swapping */
if (LFBMODE_WORD_SWAP_WRITES(vd->reg[lfbMode].u)) if (LFBMODE_WORD_SWAP_WRITES(reg[lfbMode].u))
{ {
data = (data << 16) | (data >> 16); data = (data << 16) | (data >> 16);
mem_mask = (mem_mask << 16) | (mem_mask >> 16); mem_mask = (mem_mask << 16) | (mem_mask >> 16);
@ -2932,20 +2921,20 @@ int32_t voodoo_device::lfb_direct_w(voodoo_device *vd, offs_t offset, uint32_t d
// For direct lfb access just write the data // For direct lfb access just write the data
/* compute X,Y */ /* compute X,Y */
offset <<= 1; offset <<= 1;
x = offset & ((1 << vd->fbi.lfb_stride) - 1); int const x = offset & ((1 << fbi.lfb_stride) - 1);
y = (offset >> vd->fbi.lfb_stride); int const y = (offset >> fbi.lfb_stride);
dest = (uint16_t *)(vd->fbi.ram + vd->fbi.lfb_base*4); uint16_t *const dest = (uint16_t *)(fbi.ram + fbi.lfb_base*4);
destmax = (vd->fbi.mask + 1 - vd->fbi.lfb_base*4) / 2; uint32_t const destmax = (fbi.mask + 1 - fbi.lfb_base*4) / 2;
bufoffs = y * vd->fbi.rowpixels + x; uint32_t const bufoffs = y * fbi.rowpixels + x;
if (bufoffs >= destmax) { if (bufoffs >= destmax) {
vd->logerror("lfb_direct_w: Buffer offset out of bounds x=%i y=%i offset=%08X bufoffs=%08X data=%08X\n", x, y, offset, (uint32_t) bufoffs, data); logerror("lfb_direct_w: Buffer offset out of bounds x=%i y=%i offset=%08X bufoffs=%08X data=%08X\n", x, y, offset, (uint32_t) bufoffs, data);
return 0; return 0;
} }
if (ACCESSING_BITS_0_15) if (ACCESSING_BITS_0_15)
dest[bufoffs + 0] = data&0xffff; dest[bufoffs + 0] = data&0xffff;
if (ACCESSING_BITS_16_31) if (ACCESSING_BITS_16_31)
dest[bufoffs + 1] = data>>16; dest[bufoffs + 1] = data>>16;
if (LOG_LFB) vd->logerror("VOODOO.%d.LFB:write direct (%d,%d) = %08X & %08X\n", vd->index, x, y, data, mem_mask); if (LOG_LFB) logerror("VOODOO.%d.LFB:write direct (%d,%d) = %08X & %08X\n", index, x, y, data, mem_mask);
return 0; return 0;
} }
@ -3782,7 +3771,7 @@ WRITE32_MEMBER( voodoo_device::voodoo_w )
fbi.fifo.items() >= 2 * 32 * FBIINIT0_MEMORY_FIFO_HWM(reg[fbiInit0].u)) fbi.fifo.items() >= 2 * 32 * FBIINIT0_MEMORY_FIFO_HWM(reg[fbiInit0].u))
{ {
if (LOG_FIFO) logerror("VOODOO.%d.FIFO:voodoo_w hit memory FIFO HWM -- stalling\n", index); if (LOG_FIFO) logerror("VOODOO.%d.FIFO:voodoo_w hit memory FIFO HWM -- stalling\n", index);
stall_cpu(this, STALLED_UNTIL_FIFO_LWM, machine().time()); stall_cpu(STALLED_UNTIL_FIFO_LWM, machine().time());
} }
} }
@ -3791,14 +3780,14 @@ WRITE32_MEMBER( voodoo_device::voodoo_w )
pci.fifo.space() <= 2 * FBIINIT0_PCI_FIFO_LWM(reg[fbiInit0].u)) pci.fifo.space() <= 2 * FBIINIT0_PCI_FIFO_LWM(reg[fbiInit0].u))
{ {
if (LOG_FIFO) logerror("VOODOO.%d.FIFO:voodoo_w hit PCI FIFO free LWM -- stalling\n", index); if (LOG_FIFO) logerror("VOODOO.%d.FIFO:voodoo_w hit PCI FIFO free LWM -- stalling\n", index);
stall_cpu(this, STALLED_UNTIL_FIFO_LWM, machine().time()); stall_cpu(STALLED_UNTIL_FIFO_LWM, machine().time());
} }
/* if we weren't ready, and this is a non-FIFO access, stall until the FIFOs are clear */ /* if we weren't ready, and this is a non-FIFO access, stall until the FIFOs are clear */
if (stall) if (stall)
{ {
if (LOG_FIFO_VERBOSE) logerror("VOODOO.%d.FIFO:voodoo_w wrote non-FIFO register -- stalling until clear\n", index); if (LOG_FIFO_VERBOSE) logerror("VOODOO.%d.FIFO:voodoo_w wrote non-FIFO register -- stalling until clear\n", index);
stall_cpu(this, STALLED_UNTIL_FIFO_EMPTY, machine().time()); stall_cpu(STALLED_UNTIL_FIFO_EMPTY, machine().time());
} }
g_profiler.stop(); g_profiler.stop();
@ -4783,7 +4772,7 @@ WRITE32_MEMBER( voodoo_banshee_device::banshee_fb_w )
} }
} }
else else
lfb_direct_w(this, offset - fbi.lfb_base, data, mem_mask); lfb_direct_w(offset - fbi.lfb_base, data, mem_mask);
} }
@ -4951,7 +4940,7 @@ WRITE32_MEMBER( voodoo_banshee_device::banshee_io_w )
device start callback device start callback
-------------------------------------------------*/ -------------------------------------------------*/
void voodoo_device::common_start_voodoo(uint8_t type) void voodoo_device::device_start()
{ {
const raster_info *info; const raster_info *info;
void *fbmem, *tmumem[2]; void *fbmem, *tmumem[2];
@ -4963,8 +4952,6 @@ void voodoo_device::common_start_voodoo(uint8_t type)
assert(m_cputag != nullptr); assert(m_cputag != nullptr);
assert(m_fbmem > 0); assert(m_fbmem > 0);
vd_type = type;
/* copy config data */ /* copy config data */
freq = clock(); freq = clock();
m_vblank.resolve(); m_vblank.resolve();
@ -5071,7 +5058,7 @@ void voodoo_device::common_start_voodoo(uint8_t type)
pci.fifo.size = 64*2; pci.fifo.size = 64*2;
pci.fifo.in = pci.fifo.out = 0; pci.fifo.in = pci.fifo.out = 0;
pci.stall_state = NOT_STALLED; pci.stall_state = NOT_STALLED;
pci.continue_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(voodoo_device::stall_cpu_callback),this), nullptr); pci.continue_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(voodoo_device::stall_cpu_callback), this), nullptr);
/* allocate memory */ /* allocate memory */
tmumem0 = m_tmumem0; tmumem0 = m_tmumem0;
@ -5099,11 +5086,11 @@ void voodoo_device::common_start_voodoo(uint8_t type)
tmushare.init(); tmushare.init();
/* set up the TMUs */ /* set up the TMUs */
init_tmu(this, &tmu[0], &reg[0x100], tmumem[0], tmumem0 << 20); tmu[0].init(vd_type, tmushare, &reg[0x100], tmumem[0], tmumem0 << 20);
chipmask |= 0x02; chipmask |= 0x02;
if (tmumem1 != 0) if (tmumem1 != 0)
{ {
init_tmu(this, &tmu[1], &reg[0x200], tmumem[1], tmumem1 << 20); tmu[1].init(vd_type, tmushare, &reg[0x200], tmumem[1], tmumem1 << 20);
chipmask |= 0x04; chipmask |= 0x04;
tmu_config |= 0x40; tmu_config |= 0x40;
} }
@ -5771,7 +5758,7 @@ void voodoo_device::dump_rasterizer_stats(voodoo_device *vd)
} }
} }
voodoo_device::voodoo_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock) voodoo_device::voodoo_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock, uint8_t vdt)
: device_t(mconfig, type, tag, owner, clock) : device_t(mconfig, type, tag, owner, clock)
, m_fbmem(0) , m_fbmem(0)
, m_tmumem0(0) , m_tmumem0(0)
@ -5780,6 +5767,7 @@ voodoo_device::voodoo_device(const machine_config &mconfig, device_type type, co
, m_cputag(nullptr) , m_cputag(nullptr)
, m_vblank(*this) , m_vblank(*this)
, m_stall(*this) , m_stall(*this)
, vd_type(vdt)
{ {
} }
@ -5811,75 +5799,39 @@ void voodoo_device::device_stop()
DEFINE_DEVICE_TYPE(VOODOO_1, voodoo_1_device, "voodoo_1", "3dfx Voodoo Graphics") DEFINE_DEVICE_TYPE(VOODOO_1, voodoo_1_device, "voodoo_1", "3dfx Voodoo Graphics")
voodoo_1_device::voodoo_1_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) voodoo_1_device::voodoo_1_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: voodoo_device(mconfig, VOODOO_1, tag, owner, clock) : voodoo_device(mconfig, VOODOO_1, tag, owner, clock, TYPE_VOODOO_1)
{ {
} }
//-------------------------------------------------
// device_start - device-specific startup
//-------------------------------------------------
void voodoo_1_device::device_start()
{
common_start_voodoo(TYPE_VOODOO_1);
}
DEFINE_DEVICE_TYPE(VOODOO_2, voodoo_2_device, "voodoo_2", "3dfx Voodoo 2") DEFINE_DEVICE_TYPE(VOODOO_2, voodoo_2_device, "voodoo_2", "3dfx Voodoo 2")
voodoo_2_device::voodoo_2_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) voodoo_2_device::voodoo_2_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: voodoo_device(mconfig, VOODOO_2, tag, owner, clock) : voodoo_device(mconfig, VOODOO_2, tag, owner, clock, TYPE_VOODOO_2)
{ {
} }
//-------------------------------------------------
// device_start - device-specific startup
//-------------------------------------------------
void voodoo_2_device::device_start()
{
common_start_voodoo(TYPE_VOODOO_2);
}
DEFINE_DEVICE_TYPE(VOODOO_BANSHEE, voodoo_banshee_device, "voodoo_banshee", "3dfx Voodoo Banshee") DEFINE_DEVICE_TYPE(VOODOO_BANSHEE, voodoo_banshee_device, "voodoo_banshee", "3dfx Voodoo Banshee")
voodoo_banshee_device::voodoo_banshee_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) voodoo_banshee_device::voodoo_banshee_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: voodoo_banshee_device(mconfig, VOODOO_BANSHEE, tag, owner, clock) : voodoo_banshee_device(mconfig, VOODOO_BANSHEE, tag, owner, clock, TYPE_VOODOO_BANSHEE)
{ {
} }
voodoo_banshee_device::voodoo_banshee_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock) voodoo_banshee_device::voodoo_banshee_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock, uint8_t vdt)
: voodoo_device(mconfig, type, tag, owner, clock) : voodoo_device(mconfig, type, tag, owner, clock, vdt)
{ {
} }
//-------------------------------------------------
// device_start - device-specific startup
//-------------------------------------------------
void voodoo_banshee_device::device_start()
{
common_start_voodoo(TYPE_VOODOO_BANSHEE);
}
DEFINE_DEVICE_TYPE(VOODOO_3, voodoo_3_device, "voodoo_3", "3dfx Voodoo 3") DEFINE_DEVICE_TYPE(VOODOO_3, voodoo_3_device, "voodoo_3", "3dfx Voodoo 3")
voodoo_3_device::voodoo_3_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) voodoo_3_device::voodoo_3_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: voodoo_banshee_device(mconfig, VOODOO_3, tag, owner, clock) : voodoo_banshee_device(mconfig, VOODOO_3, tag, owner, clock, TYPE_VOODOO_3)
{ {
} }
//-------------------------------------------------
// device_start - device-specific startup
//-------------------------------------------------
void voodoo_3_device::device_start()
{
common_start_voodoo(TYPE_VOODOO_3);
}
/*************************************************************************** /***************************************************************************

35
src/devices/video/voodoo.h
View File

@ -1450,9 +1450,6 @@ public:
DECLARE_READ32_MEMBER( voodoo_r ); DECLARE_READ32_MEMBER( voodoo_r );
DECLARE_WRITE32_MEMBER( voodoo_w ); DECLARE_WRITE32_MEMBER( voodoo_w );
// access to legacy token
void common_start_voodoo(uint8_t type);
uint8_t m_fbmem; uint8_t m_fbmem;
uint8_t m_tmumem0; uint8_t m_tmumem0;
uint8_t m_tmumem1; uint8_t m_tmumem1;
@ -1465,7 +1462,7 @@ public:
TIMER_CALLBACK_MEMBER( stall_cpu_callback ); TIMER_CALLBACK_MEMBER( stall_cpu_callback );
TIMER_CALLBACK_MEMBER( vblank_callback ); TIMER_CALLBACK_MEMBER( vblank_callback );
static void voodoo_postload(voodoo_device *vd); void voodoo_postload();
int voodoo_update(bitmap_rgb32 &bitmap, const rectangle &cliprect); int voodoo_update(bitmap_rgb32 &bitmap, const rectangle &cliprect);
int voodoo_get_type(); int voodoo_get_type();
@ -1473,12 +1470,14 @@ public:
void voodoo_set_init_enable(uint32_t newval); void voodoo_set_init_enable(uint32_t newval);
protected: protected:
voodoo_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock); voodoo_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock, uint8_t vdt);
// device-level overrides // device-level overrides
virtual void device_start() override;
virtual void device_stop() override; virtual void device_stop() override;
virtual void device_reset() override; virtual void device_reset() override;
struct tmu_shared_state;
struct voodoo_stats struct voodoo_stats
{ {
@ -1566,6 +1565,7 @@ protected:
struct tmu_state struct tmu_state
{ {
void recompute_texture_params(); void recompute_texture_params();
void init(uint8_t vdt, tmu_shared_state &share, voodoo_reg *r, void *memory, int tmem);
int32_t prepare(); int32_t prepare();
rgbaint_t genTexture(int32_t x, const uint8_t *dither4, const uint32_t TEXMODE, rgb_t *LOOKUP, int32_t LODBASE, int64_t ITERS, int64_t ITERT, int64_t ITERW, int32_t &lod); rgbaint_t genTexture(int32_t x, const uint8_t *dither4, const uint32_t TEXMODE, rgb_t *LOOKUP, int32_t LODBASE, int64_t ITERS, int64_t ITERT, int64_t ITERW, int32_t &lod);
rgbaint_t combineTexture(const uint32_t TEXMODE, rgbaint_t c_local, rgbaint_t c_other, int32_t lod); rgbaint_t combineTexture(const uint32_t TEXMODE, rgbaint_t c_local, rgbaint_t c_other, int32_t lod);
@ -1782,19 +1782,18 @@ protected:
// not all of these need to be static, review. // not all of these need to be static, review.
static void check_stalled_cpu(voodoo_device* vd, attotime current_time); void check_stalled_cpu(attotime current_time);
static void flush_fifos( voodoo_device* vd, attotime current_time); static void flush_fifos( voodoo_device* vd, attotime current_time);
static void init_fbi(voodoo_device *vd, fbi_state *f, void *memory, int fbmem); static void init_fbi(voodoo_device *vd, fbi_state *f, void *memory, int fbmem);
static int32_t register_w(voodoo_device *vd, offs_t offset, uint32_t data); static int32_t register_w(voodoo_device *vd, offs_t offset, uint32_t data);
static int32_t swapbuffer(voodoo_device *vd, uint32_t data); static int32_t swapbuffer(voodoo_device *vd, uint32_t data);
static void init_tmu(voodoo_device *vd, tmu_state *t, voodoo_reg *reg, void *memory, int tmem);
static int32_t lfb_w(voodoo_device *vd, offs_t offset, uint32_t data, uint32_t mem_mask); static int32_t lfb_w(voodoo_device *vd, offs_t offset, uint32_t data, uint32_t mem_mask);
static int32_t texture_w(voodoo_device *vd, offs_t offset, uint32_t data); static int32_t texture_w(voodoo_device *vd, offs_t offset, uint32_t data);
static int32_t lfb_direct_w(voodoo_device *vd, offs_t offset, uint32_t data, uint32_t mem_mask); int32_t lfb_direct_w(offs_t offset, uint32_t data, uint32_t mem_mask);
static int32_t banshee_2d_w(voodoo_device *vd, offs_t offset, uint32_t data); static int32_t banshee_2d_w(voodoo_device *vd, offs_t offset, uint32_t data);
static void stall_cpu(voodoo_device *vd, int state, attotime current_time); void stall_cpu(int state, attotime current_time);
void soft_reset(); void soft_reset();
static void recompute_video_memory(voodoo_device *vd); void recompute_video_memory();
static int32_t fastfill(voodoo_device *vd); static int32_t fastfill(voodoo_device *vd);
static int32_t triangle(voodoo_device *vd); static int32_t triangle(voodoo_device *vd);
static int32_t begin_triangle(voodoo_device *vd); static int32_t begin_triangle(voodoo_device *vd);
@ -1843,7 +1842,7 @@ public:
uint8_t index; /* index of board */ uint8_t index; /* index of board */
screen_device *screen; /* the screen we are acting on */ screen_device *screen; /* the screen we are acting on */
device_t *cpu; /* the CPU we interact with */ device_t *cpu; /* the CPU we interact with */
uint8_t vd_type; /* type of system */ const uint8_t vd_type; /* type of system */
uint8_t chipmask; /* mask for which chips are available */ uint8_t chipmask; /* mask for which chips are available */
uint32_t freq; /* operating frequency */ uint32_t freq; /* operating frequency */
attoseconds_t attoseconds_per_cycle; /* attoseconds per cycle */ attoseconds_t attoseconds_per_cycle; /* attoseconds per cycle */
@ -1884,10 +1883,6 @@ class voodoo_1_device : public voodoo_device
{ {
public: public:
voodoo_1_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock); voodoo_1_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
protected:
// device-level overrides
virtual void device_start() override;
}; };
@ -1895,9 +1890,6 @@ class voodoo_2_device : public voodoo_device
{ {
public: public:
voodoo_2_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock); voodoo_2_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
protected:
// device-level overrides
virtual void device_start() override;
}; };
@ -1917,10 +1909,9 @@ public:
DECLARE_WRITE8_MEMBER(banshee_vga_w); DECLARE_WRITE8_MEMBER(banshee_vga_w);
protected: protected:
voodoo_banshee_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock); voodoo_banshee_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock, uint8_t vdt);
// device-level overrides // device-level overrides
virtual void device_start() override;
DECLARE_READ32_MEMBER( banshee_agp_r ); DECLARE_READ32_MEMBER( banshee_agp_r );
DECLARE_WRITE32_MEMBER( banshee_agp_w ); DECLARE_WRITE32_MEMBER( banshee_agp_w );
}; };
@ -1930,10 +1921,6 @@ class voodoo_3_device : public voodoo_banshee_device
{ {
public: public:
voodoo_3_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock); voodoo_3_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
protected:
// device-level overrides
virtual void device_start() override;
}; };