mirrors/Bochs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
0311f47bc3
Bochs/bochs/iodev/display/voodoo.cc

858 lines
30 KiB
C++
Raw Normal View History

Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
/////////////////////////////////////////////////////////////////////////
// $Id$
/////////////////////////////////////////////////////////////////////////
//
Removed unused argc and argv parameters from plugin init functions.
2017-01-28 12:52:09 +03:00
// Copyright (C) 2012-2017 The Bochs Project
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/////////////////////////////////////////////////////////////////////////
/*
* Portion of this software comes with the following license
*/
/***************************************************************************
Copyright Aaron Giles
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
* Neither the name 'MAME' nor the names of its contributors may be
used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
***************************************************************************/
// 3dfx Voodoo Graphics (SST-1/2) emulation (based on a patch for DOSBox)
// Define BX_PLUGGABLE in files that can be compiled into plugins. For
// platforms that require a special tag on exported symbols, BX_PLUGGABLE
// is used to know when we are exporting symbols and when we are importing.
#define BX_PLUGGABLE
#include "iodev.h"
#if BX_SUPPORT_PCI && BX_SUPPORT_VOODOO
#include "pci.h"
#include "vgacore.h"
#include "voodoo.h"
#include "virt_timer.h"
Moved all Bochs multi-threading definitions from bochs.h and osdep.h to a new file called "bxthread.h".
2017-09-10 18:55:13 +03:00
#include "bxthread.h"
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
#define LOG_THIS theVoodooDevice->
bx_voodoo_c* theVoodooDevice = NULL;
#include "voodoo_types.h"
#include "voodoo_data.h"
#include "voodoo_main.h"
Set up the correct clock value for the selected Voodoo model.
2014-01-01 22:23:37 +04:00
voodoo_state *v;
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
#include "voodoo_func.h"
Added bochsrc option for the Voodoo Graphics emulation. Some code for Voodoo2 model exists, but needs to be verified.
2013-12-22 23:50:29 +04:00
// builtin configuration handling functions
void voodoo_init_options(void)
{
static const char *voodoo_model_list[] = {
"voodoo1",
"voodoo2",
NULL
};
bx_param_c *display = SIM->get_param("display");
bx_list_c *menu = new bx_list_c(display, "voodoo", "Voodoo Graphics");
menu->set_options(menu->SHOW_PARENT);
bx_param_bool_c *enabled = new bx_param_bool_c(menu,
"enabled",
"Enable Voodoo Graphics emulation",
"Enables the 3dfx Voodoo Graphics emulation",
Some work on the Voodoo emulation - destructor: free memory only when initialized - parameter 'enabled' must be initialized with 1 (TODO: fix other plugins) - PCI register fixes (Voodoo2 now detected, but not usable)
2013-12-30 16:50:34 +04:00
1);
Added bochsrc option for the Voodoo Graphics emulation. Some code for Voodoo2 model exists, but needs to be verified.
2013-12-22 23:50:29 +04:00
new bx_param_enum_c(menu,
"model",
"Voodoo model",
"Selects the Voodoo model to emulate.",
voodoo_model_list,
VOODOO_1, VOODOO_1);
enabled->set_dependent_list(menu->clone());
}
Bit32s voodoo_options_parser(const char *context, int num_params, char *params[])
{
if (!strcmp(params[0], "voodoo")) {
bx_list_c *base = (bx_list_c*) SIM->get_param(BXPN_VOODOO);
for (int i = 1; i < num_params; i++) {
if (SIM->parse_param_from_list(context, params[i], base) < 0) {
BX_ERROR(("%s: unknown parameter for voodoo ignored.", context));
}
}
} else {
BX_PANIC(("%s: unknown directive '%s'", context, params[0]));
}
return 0;
}
Bit32s voodoo_options_save(FILE *fp)
{
return SIM->write_param_list(fp, (bx_list_c*) SIM->get_param(BXPN_VOODOO), NULL, 0);
}
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
// device plugin entry points
Removed unused argc and argv parameters from plugin init functions.
2017-01-28 12:52:09 +03:00
int CDECL libvoodoo_LTX_plugin_init(plugin_t *plugin, plugintype_t type)
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
{
theVoodooDevice = new bx_voodoo_c();
BX_REGISTER_DEVICE_DEVMODEL(plugin, type, theVoodooDevice, BX_PLUGIN_VOODOO);
Added bochsrc option for the Voodoo Graphics emulation. Some code for Voodoo2 model exists, but needs to be verified.
2013-12-22 23:50:29 +04:00
// add new configuration parameter for the config interface
voodoo_init_options();
// register add-on option for bochsrc and command line
SIM->register_addon_option("voodoo", voodoo_options_parser, voodoo_options_save);
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
return 0; // Success
}
Fixed broken MSVC plugins support (many CDECL additions required) TODO: check for remaining CDECL issues (hdimage mode 'dll') and update project files
2014-06-08 12:40:08 +04:00
void CDECL libvoodoo_LTX_plugin_fini(void)
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
{
Added bochsrc option for the Voodoo Graphics emulation. Some code for Voodoo2 model exists, but needs to be verified.
2013-12-22 23:50:29 +04:00
SIM->unregister_addon_option("voodoo");
bx_list_c *menu = (bx_list_c*)SIM->get_param("display");
menu->remove("voodoo");
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
delete theVoodooDevice;
}
Started preparing the Voodoo code for the PCI FIFO / memory FIFO implementation. - Initialize the thread and event stuff for both Voodoo models. - Rewrite of the event handling code to manage different events.
2017-08-20 23:25:45 +03:00
// FIFO thread
Some work on the Voodoo2 CMDFIFO support. - Added CMDFIFO thread similar to the sound output thread. - split register write function in 2 functions: register_w_common() handles the CMDFIFO writes and valid registers in CMDFIFO mode. It forwards write accesses to other registers to register_w() (Voodoo1 and non-CMDFIFO mode). The CMDFIFO thread also calls register_w() when processing data. - The CMDFIFO thread processes all data, but it does not yet execute type 3 requests (extended triangle generator missing). - TODO #1: implement Voodoo2 specific triangle functions (for CMDFIFO). - TODO #2: implement 2D bitblt engine.
2017-05-14 18:53:29 +03:00
Started preparing the Voodoo code for the PCI FIFO / memory FIFO implementation. - Initialize the thread and event stuff for both Voodoo models. - Rewrite of the event handling code to manage different events.
2017-08-20 23:25:45 +03:00
BX_THREAD_FUNC(fifo_thread, indata)
Some work on the Voodoo2 CMDFIFO support. - Added CMDFIFO thread similar to the sound output thread. - split register write function in 2 functions: register_w_common() handles the CMDFIFO writes and valid registers in CMDFIFO mode. It forwards write accesses to other registers to register_w() (Voodoo1 and non-CMDFIFO mode). The CMDFIFO thread also calls register_w() when processing data. - The CMDFIFO thread processes all data, but it does not yet execute type 3 requests (extended triangle generator missing). - TODO #1: implement Voodoo2 specific triangle functions (for CMDFIFO). - TODO #2: implement 2D bitblt engine.
2017-05-14 18:53:29 +03:00
{
Implemented memory FIFO to speed up the Voodoo1 emulation. The PCI FIFO with it's 64 entries is still not present, since it makes the emulation a few percent slower due to the overhead of the FIFO code. The memory FIFO has 64k entries and makes a speedup of around 75 % possible.
2017-09-01 20:30:49 +03:00
Bit32u type, offset = 0, data = 0, regnum;
Implemented combined PCI / memory FIFO. This is required for running Voodoo1 games / demos correctly on the Voodoo2 model. I noticed a small slowdown (2 or 3 percent) on the Voodoo1.
2017-09-08 19:17:20 +03:00
fifo_state *fifo;
Implemented memory FIFO to speed up the Voodoo1 emulation. The PCI FIFO with it's 64 entries is still not present, since it makes the emulation a few percent slower due to the overhead of the FIFO code. The memory FIFO has 64k entries and makes a speedup of around 75 % possible.
2017-09-01 20:30:49 +03:00
Some work on the Voodoo2 CMDFIFO support. - Added CMDFIFO thread similar to the sound output thread. - split register write function in 2 functions: register_w_common() handles the CMDFIFO writes and valid registers in CMDFIFO mode. It forwards write accesses to other registers to register_w() (Voodoo1 and non-CMDFIFO mode). The CMDFIFO thread also calls register_w() when processing data. - The CMDFIFO thread processes all data, but it does not yet execute type 3 requests (extended triangle generator missing). - TODO #1: implement Voodoo2 specific triangle functions (for CMDFIFO). - TODO #2: implement 2D bitblt engine.
2017-05-14 18:53:29 +03:00
UNUSED(indata);
Bochs thread handling improvements: - Modified win32 thread macros to use the handle instead of the id. - Added new macro BX_THREAD_KILL to terminate threads. Voodoo thread changes: - Let the cmdfifo_thread sleep while the CMDFIFO is disabled. - Kill the cmdfifo_thread in destructor and removed old thread control code.
2017-05-18 21:34:00 +03:00
while (1) {
Moved event / wait stuff from the Voodoo code to osdep.cc fot the usage in other parts of Bochs.
2017-09-10 09:50:07 +03:00
if (bx_wait_for_event(&fifo_wakeup)) {
Implemented combined PCI / memory FIFO. This is required for running Voodoo1 games / demos correctly on the Voodoo2 model. I noticed a small slowdown (2 or 3 percent) on the Voodoo1.
2017-09-08 19:17:20 +03:00
BX_LOCK(fifo_mutex);
while (1) {
if (!fifo_empty(&v->fbi.fifo)) {
fifo = &v->fbi.fifo;
} else if (!fifo_empty(&v->pci.fifo)) {
fifo = &v->pci.fifo;
} else {
break;
}
type = fifo_remove(fifo, &offset, &data);
BX_UNLOCK(fifo_mutex);
Implemented memory FIFO to speed up the Voodoo1 emulation. The PCI FIFO with it's 64 entries is still not present, since it makes the emulation a few percent slower due to the overhead of the FIFO code. The memory FIFO has 64k entries and makes a speedup of around 75 % possible.
2017-09-01 20:30:49 +03:00
switch (type) {
case FIFO_WR_REG:
if ((offset & 0x800c0) == 0x80000 && v->alt_regmap)
regnum = register_alias_map[offset & 0x3f];
else
regnum = offset & 0xff;
register_w(offset, data, 0);
if ((regnum == triangleCMD) || (regnum == ftriangleCMD) || (regnum == nopCMD) ||
(regnum == fastfillCMD) || (regnum == swapbufferCMD)) {
BX_LOCK(fifo_mutex);
v->pci.op_pending--;
BX_UNLOCK(fifo_mutex);
}
break;
case FIFO_WR_TEX:
texture_w(offset, data);
break;
Memory FIFO fix: 16-bit write support for the FBI video memory was missing.
2017-09-03 23:51:37 +03:00
case FIFO_WR_FBI_32:
lfb_w(offset, data, 0xffffffff);
break;
case FIFO_WR_FBI_16L:
lfb_w(offset, data, 0x0000ffff);
break;
case FIFO_WR_FBI_16H:
lfb_w(offset, data, 0xffff0000);
break;
Implemented memory FIFO to speed up the Voodoo1 emulation. The PCI FIFO with it's 64 entries is still not present, since it makes the emulation a few percent slower due to the overhead of the FIFO code. The memory FIFO has 64k entries and makes a speedup of around 75 % possible.
2017-09-01 20:30:49 +03:00
}
Implemented combined PCI / memory FIFO. This is required for running Voodoo1 games / demos correctly on the Voodoo2 model. I noticed a small slowdown (2 or 3 percent) on the Voodoo1.
2017-09-08 19:17:20 +03:00
BX_LOCK(fifo_mutex);
Implemented memory FIFO to speed up the Voodoo1 emulation. The PCI FIFO with it's 64 entries is still not present, since it makes the emulation a few percent slower due to the overhead of the FIFO code. The memory FIFO has 64k entries and makes a speedup of around 75 % possible.
2017-09-01 20:30:49 +03:00
}
Implemented combined PCI / memory FIFO. This is required for running Voodoo1 games / demos correctly on the Voodoo2 model. I noticed a small slowdown (2 or 3 percent) on the Voodoo1.
2017-09-08 19:17:20 +03:00
v->pci.op_pending = 0;
BX_UNLOCK(fifo_mutex);
Store FIFO presence in variable "enabled" and report the state change of the currently unimplemented FIFOs.
2017-08-25 00:08:21 +03:00
if (v->fbi.cmdfifo[0].enabled) {
Some improvements in the Voodoo2 CMDFIFO code. TODO: Check whether or not there are still simulation freezes caused by CMDFIFO.
2017-09-12 19:29:02 +03:00
BX_LOCK(cmdfifo_mutex);
while (v->fbi.cmdfifo[0].cmd_ready) {
Started preparing the Voodoo code for the PCI FIFO / memory FIFO implementation. - Initialize the thread and event stuff for both Voodoo models. - Rewrite of the event handling code to manage different events.
2017-08-20 23:25:45 +03:00
cmdfifo_process();
}
BX_UNLOCK(cmdfifo_mutex);
Now using WIN32 event / wait functions in the Voodoo2 thread. I noticed a speed improvement of around 10 % (tested with donut demo only). TODO: Use similar functions of the pthread library for improvements on other platforms.
2017-08-08 21:23:12 +03:00
}
}
Some work on the Voodoo2 CMDFIFO support. - Added CMDFIFO thread similar to the sound output thread. - split register write function in 2 functions: register_w_common() handles the CMDFIFO writes and valid registers in CMDFIFO mode. It forwards write accesses to other registers to register_w() (Voodoo1 and non-CMDFIFO mode). The CMDFIFO thread also calls register_w() when processing data. - The CMDFIFO thread processes all data, but it does not yet execute type 3 requests (extended triangle generator missing). - TODO #1: implement Voodoo2 specific triangle functions (for CMDFIFO). - TODO #2: implement 2D bitblt engine.
2017-05-14 18:53:29 +03:00
}
BX_THREAD_EXIT;
}
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
// the device object
bx_voodoo_c::bx_voodoo_c()
{
Added symbol BX_NULL_PREFIX and fixed textconfig log options table. If log module name not specified, use device log prefix converted to lower case as the name and simplified setting up some short prefixes.
2013-12-31 13:20:08 +04:00
put("VOODOO");
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
s.mode_change_timer_id = BX_NULL_TIMER_HANDLE;
Some work on the timing code of the Bochs display adapters. - Voodoo: Use the VGA/Cirrus timers to drive the gui screen update. The vertical retrace emulation is still driven by a separate timer. - VGA/Cirrus: Since we are using the virtual timer, we also have to read time_usec() from it. - vgacore: removed unused timer methods.
2017-05-01 14:54:12 +03:00
s.vertical_timer_id = BX_NULL_TIMER_HANDLE;
Some work on the Voodoo emulation - destructor: free memory only when initialized - parameter 'enabled' must be initialized with 1 (TODO: fix other plugins) - PCI register fixes (Voodoo2 now detected, but not usable)
2013-12-30 16:50:34 +04:00
v = NULL;
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
}
bx_voodoo_c::~bx_voodoo_c()
{
Started preparing the Voodoo code for the PCI FIFO / memory FIFO implementation. - Initialize the thread and event stuff for both Voodoo models. - Rewrite of the event handling code to manage different events.
2017-08-20 23:25:45 +03:00
BX_THREAD_KILL(fifo_thread_var);
Implemented memory FIFO to speed up the Voodoo1 emulation. The PCI FIFO with it's 64 entries is still not present, since it makes the emulation a few percent slower due to the overhead of the FIFO code. The memory FIFO has 64k entries and makes a speedup of around 75 % possible.
2017-09-01 20:30:49 +03:00
BX_FINI_MUTEX(fifo_mutex);
Bochs thread handling improvements: - Modified win32 thread macros to use the handle instead of the id. - Added new macro BX_THREAD_KILL to terminate threads. Voodoo thread changes: - Let the cmdfifo_thread sleep while the CMDFIFO is disabled. - Kill the cmdfifo_thread in destructor and removed old thread control code.
2017-05-18 21:34:00 +03:00
if (BX_VOODOO_THIS s.model == VOODOO_2) {
Some work on the Voodoo2 CMDFIFO support. - Added CMDFIFO thread similar to the sound output thread. - split register write function in 2 functions: register_w_common() handles the CMDFIFO writes and valid registers in CMDFIFO mode. It forwards write accesses to other registers to register_w() (Voodoo1 and non-CMDFIFO mode). The CMDFIFO thread also calls register_w() when processing data. - The CMDFIFO thread processes all data, but it does not yet execute type 3 requests (extended triangle generator missing). - TODO #1: implement Voodoo2 specific triangle functions (for CMDFIFO). - TODO #2: implement 2D bitblt engine.
2017-05-14 18:53:29 +03:00
BX_FINI_MUTEX(cmdfifo_mutex);
Started preparing the Voodoo code for the PCI FIFO / memory FIFO implementation. - Initialize the thread and event stuff for both Voodoo models. - Rewrite of the event handling code to manage different events.
2017-08-20 23:25:45 +03:00
}
Moved event / wait stuff from the Voodoo code to osdep.cc fot the usage in other parts of Bochs.
2017-09-10 09:50:07 +03:00
bx_destroy_event(&fifo_wakeup);
bx_destroy_event(&fifo_not_full);
Some work on the Voodoo emulation - destructor: free memory only when initialized - parameter 'enabled' must be initialized with 1 (TODO: fix other plugins) - PCI register fixes (Voodoo2 now detected, but not usable)
2013-12-30 16:50:34 +04:00
if (v != NULL) {
free(v->fbi.ram);
free(v->tmu[0].ram);
free(v->tmu[1].ram);
delete v;
}
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
BX_DEBUG(("Exit"));
}
void bx_voodoo_c::init(void)
{
Added bochsrc option for the Voodoo Graphics emulation. Some code for Voodoo2 model exists, but needs to be verified.
2013-12-22 23:50:29 +04:00
// Read in values from config interface
bx_list_c *base = (bx_list_c*) SIM->get_param(BXPN_VOODOO);
// Check if the device is disabled or not configured
if (!SIM->get_param_bool("enabled", base)->get()) {
BX_INFO(("Voodoo disabled"));
// mark unused plugin for removal
((bx_param_bool_c*)((bx_list_c*)SIM->get_param(BXPN_PLUGIN_CTRL))->get_by_name("voodoo"))->set(0);
return;
}
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
BX_VOODOO_THIS s.devfunc = 0x00;
DEV_register_pci_handlers(this, &BX_VOODOO_THIS s.devfunc, BX_PLUGIN_VOODOO,
"Experimental 3dfx Voodoo Graphics (SST-1/2)");
if (BX_VOODOO_THIS s.mode_change_timer_id == BX_NULL_TIMER_HANDLE) {
BX_VOODOO_THIS s.mode_change_timer_id = bx_virt_timer.register_timer(this, mode_change_timer_handler,
Rewrite of the virtual timer code to support both modes at the same timer. The timers now have a new member 'realtime' and they are driven by the selected engine. The VGA update timer and the status LED timer now always use the realtime mode, but the PIT and CMOS RTC depend on the clock options.
2014-10-19 12:54:16 +04:00
1000, 0, 0, 0, "voodoo_mode_change");
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
}
Some work on the timing code of the Bochs display adapters. - Voodoo: Use the VGA/Cirrus timers to drive the gui screen update. The vertical retrace emulation is still driven by a separate timer. - VGA/Cirrus: Since we are using the virtual timer, we also have to read time_usec() from it. - vgacore: removed unused timer methods.
2017-05-01 14:54:12 +03:00
if (BX_VOODOO_THIS s.vertical_timer_id == BX_NULL_TIMER_HANDLE) {
BX_VOODOO_THIS s.vertical_timer_id = bx_virt_timer.register_timer(this, vertical_timer_handler,
Removed Voodoo realtime option. Since the gui screen update timing is now controlled by the 'vga' option and Voodoo2 CMDFIFO thread has the best performance with realtime mode disabled, this option is now obsolete.
2017-08-18 18:19:30 +03:00
50000, 1, 0, 0, "vertical_timer");
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
}
- enable Voodoo clock in init() - don't enable Voodoo mode if hSync or vSync are still 0 to avoid Bochs crash (division by zero error) - handle PCI register 0x40 (initEnable) - fixed reported display size
2012-09-30 16:11:01 +04:00
BX_VOODOO_THIS s.vdraw.clock_enabled = 1;
Some work on the Voodoo emulation - fixed behaviour of the initEnable register - fixed some uninitialized variables - some other small fixes and cleanups
2014-01-03 02:34:01 +04:00
BX_VOODOO_THIS s.vdraw.output_on = 0;
BX_VOODOO_THIS s.vdraw.override_on = 0;
BX_VOODOO_THIS s.vdraw.screen_update_pending = 0;
Some work on the timing code of the Bochs display adapters. - Voodoo: Use the VGA/Cirrus timers to drive the gui screen update. The vertical retrace emulation is still driven by a separate timer. - VGA/Cirrus: Since we are using the virtual timer, we also have to read time_usec() from it. - vgacore: removed unused timer methods.
2017-05-01 14:54:12 +03:00
BX_VOODOO_THIS s.vdraw.gui_update_pending = 0;
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
v = new voodoo_state;
Continued preparing Voodoo2 CMDFIFO support. - Zero out voodoo device state in init(). - Added the CMDFIFO state to save/restore list. - Added CMDFIFO register handling in read/write functions. - Added new function cmdfifo_put(). - TODO: CMDFIFO thread.
2017-05-13 14:52:49 +03:00
memset(v, 0, sizeof(voodoo_state));
- Some work on the Voodoo Graphics emulation - Store the Voodoo model in structure bx_voodoo_t. - The PCI initEnable register of the Voodoo2 model has a read-only secondary revision ID in bits 12..15. Now the Voodoo2 is correctly detected by the Windows driver, but display is not yet working (blank screen). - Reset now disables VGA override. - PCI: Moved PCI device base class methods to the end of file devices.cc and re-define LOG_THIS to use the correct log module and prefix.
2017-04-28 21:45:45 +03:00
BX_VOODOO_THIS s.model = (Bit8u)SIM->get_param_enum("model", base)->get();
if (BX_VOODOO_THIS s.model == VOODOO_2) {
Added new method for the init of the readonly registers in the PCI config space and cleaned up the PCI devices code.
2013-12-31 02:39:21 +04:00
init_pci_conf(0x121a, 0x0002, 0x02, 0x038000, 0x00);
Some work on the Voodoo emulation - destructor: free memory only when initialized - parameter 'enabled' must be initialized with 1 (TODO: fix other plugins) - PCI register fixes (Voodoo2 now detected, but not usable)
2013-12-30 16:50:34 +04:00
BX_VOODOO_THIS pci_conf[0x10] = 0x08;
Some fixes for the Voodoo emulation (Voodoo2 still not usable in Win95) - fixed clock values (assigned to wrong model) - LFB read/write: don't limit y values to 1023 (4MB now usable this way) - additional Voodoo2 fbiInit* register writes now handled like the Voodoo1 ones
2014-01-03 20:42:31 +04:00
} else {
init_pci_conf(0x121a, 0x0001, 0x02, 0x000000, 0x00);
Some work on the Voodoo emulation - destructor: free memory only when initialized - parameter 'enabled' must be initialized with 1 (TODO: fix other plugins) - PCI register fixes (Voodoo2 now detected, but not usable)
2013-12-30 16:50:34 +04:00
}
Added new method for the init of the readonly registers in the PCI config space and cleaned up the PCI devices code.
2013-12-31 02:39:21 +04:00
BX_VOODOO_THIS pci_conf[0x3d] = BX_PCI_INTA;
BX_VOODOO_THIS pci_base_address[0] = 0;
Implemented memory FIFO to speed up the Voodoo1 emulation. The PCI FIFO with it's 64 entries is still not present, since it makes the emulation a few percent slower due to the overhead of the FIFO code. The memory FIFO has 64k entries and makes a speedup of around 75 % possible.
2017-09-01 20:30:49 +03:00
BX_INIT_MUTEX(fifo_mutex);
Some work on the Voodoo2 CMDFIFO support. - Added CMDFIFO thread similar to the sound output thread. - split register write function in 2 functions: register_w_common() handles the CMDFIFO writes and valid registers in CMDFIFO mode. It forwards write accesses to other registers to register_w() (Voodoo1 and non-CMDFIFO mode). The CMDFIFO thread also calls register_w() when processing data. - The CMDFIFO thread processes all data, but it does not yet execute type 3 requests (extended triangle generator missing). - TODO #1: implement Voodoo2 specific triangle functions (for CMDFIFO). - TODO #2: implement 2D bitblt engine.
2017-05-14 18:53:29 +03:00
if (BX_VOODOO_THIS s.model == VOODOO_2) {
Minimal improvement in the CMDFIFO code: calculate needed depth for current command and execute it when there is enough data present (code partly ported from voodoo.h.txt). TODO: Use "wait for event / condition" functions instead of msleep() if there is a performance improvement with it.
2017-07-17 21:07:28 +03:00
v->fbi.cmdfifo[0].depth_needed = BX_MAX_BIT32U;
Some work on the Voodoo2 CMDFIFO support. - Added CMDFIFO thread similar to the sound output thread. - split register write function in 2 functions: register_w_common() handles the CMDFIFO writes and valid registers in CMDFIFO mode. It forwards write accesses to other registers to register_w() (Voodoo1 and non-CMDFIFO mode). The CMDFIFO thread also calls register_w() when processing data. - The CMDFIFO thread processes all data, but it does not yet execute type 3 requests (extended triangle generator missing). - TODO #1: implement Voodoo2 specific triangle functions (for CMDFIFO). - TODO #2: implement 2D bitblt engine.
2017-05-14 18:53:29 +03:00
BX_INIT_MUTEX(cmdfifo_mutex);
Started preparing the Voodoo code for the PCI FIFO / memory FIFO implementation. - Initialize the thread and event stuff for both Voodoo models. - Rewrite of the event handling code to manage different events.
2017-08-20 23:25:45 +03:00
}
Some Voodoo emulation fixes. - voodoo_init() must be called after initializing FIFO mutex. - The 'op_pending' counter must be reset after resetting FIFOs. - Fixed an MSVC warning and removed obsolete comment. - FIXME: There are still some conditions that can freeze the Voodoo display.
2017-09-03 11:28:16 +03:00
voodoo_init(BX_VOODOO_THIS s.model);
Moved event / wait stuff from the Voodoo code to osdep.cc fot the usage in other parts of Bochs.
2017-09-10 09:50:07 +03:00
bx_create_event(&fifo_wakeup);
bx_create_event(&fifo_not_full);
bx_set_event(&fifo_not_full);
Started preparing the Voodoo code for the PCI FIFO / memory FIFO implementation. - Initialize the thread and event stuff for both Voodoo models. - Rewrite of the event handling code to manage different events.
2017-08-20 23:25:45 +03:00
BX_THREAD_CREATE(fifo_thread, this, fifo_thread_var);
Some work on the Voodoo2 CMDFIFO support. - Added CMDFIFO thread similar to the sound output thread. - split register write function in 2 functions: register_w_common() handles the CMDFIFO writes and valid registers in CMDFIFO mode. It forwards write accesses to other registers to register_w() (Voodoo1 and non-CMDFIFO mode). The CMDFIFO thread also calls register_w() when processing data. - The CMDFIFO thread processes all data, but it does not yet execute type 3 requests (extended triangle generator missing). - TODO #1: implement Voodoo2 specific triangle functions (for CMDFIFO). - TODO #2: implement 2D bitblt engine.
2017-05-14 18:53:29 +03:00
Some work on the Voodoo emulation - fixed behaviour of the initEnable register - fixed some uninitialized variables - some other small fixes and cleanups
2014-01-03 02:34:01 +04:00
BX_INFO(("3dfx Voodoo Graphics adapter (model=%s) initialized",
SIM->get_param_enum("model", base)->get_selected()));
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
}
void bx_voodoo_c::reset(unsigned type)
{
unsigned i;
static const struct reset_vals_t {
unsigned addr;
unsigned char val;
} reset_vals[] = {
{ 0x04, 0x00 }, { 0x05, 0x00 }, // command io / memory
{ 0x06, 0x00 }, { 0x07, 0x00 }, // status
// address space 0x10 - 0x13
Some work on the Voodoo emulation - destructor: free memory only when initialized - parameter 'enabled' must be initialized with 1 (TODO: fix other plugins) - PCI register fixes (Voodoo2 now detected, but not usable)
2013-12-30 16:50:34 +04:00
{ 0x11, 0x00 },
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
{ 0x12, 0x00 }, { 0x13, 0x00 },
{ 0x3c, 0x00 }, // IRQ
// initEnable
{ 0x40, 0x00 }, { 0x41, 0x00 },
{ 0x42, 0x00 }, { 0x43, 0x00 },
// busSnoop0
{ 0x44, 0x00 }, { 0x45, 0x00 },
{ 0x46, 0x00 }, { 0x47, 0x00 },
// busSnoop1
{ 0x48, 0x00 }, { 0x49, 0x00 },
{ 0x4a, 0x00 }, { 0x4b, 0x00 },
};
for (i = 0; i < sizeof(reset_vals) / sizeof(*reset_vals); ++i) {
BX_VOODOO_THIS pci_conf[reset_vals[i].addr] = reset_vals[i].val;
}
- Some work on the Voodoo Graphics emulation - Store the Voodoo model in structure bx_voodoo_t. - The PCI initEnable register of the Voodoo2 model has a read-only secondary revision ID in bits 12..15. Now the Voodoo2 is correctly detected by the Windows driver, but display is not yet working (blank screen). - Reset now disables VGA override. - PCI: Moved PCI device base class methods to the end of file devices.cc and re-define LOG_THIS to use the correct log module and prefix.
2017-04-28 21:45:45 +03:00
if (BX_VOODOO_THIS s.model == VOODOO_2) {
BX_VOODOO_THIS pci_conf[0x41] = 0x50;
v->pci.init_enable = 0x5000;
} else {
v->pci.init_enable = 0x0000;
}
if ((!BX_VOODOO_THIS s.vdraw.clock_enabled || !BX_VOODOO_THIS s.vdraw.output_on) && BX_VOODOO_THIS s.vdraw.override_on) {
mode_change_timer_handler(NULL);
}
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
// Deassert IRQ
set_irq_level(0);
}
void bx_voodoo_c::register_state(void)
{
- continued work on save/restore support (still incomplete)
2012-10-03 12:12:35 +04:00
char name[8];
- some more work on save/restore support (now almost usable) - TODO: add graphics snapshot support
2012-10-12 19:14:30 +04:00
int i, j, k;
- continued work on save/restore support (still incomplete)
2012-10-03 12:12:35 +04:00
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
bx_list_c *list = new bx_list_c(SIM->get_bochs_root(), "voodoo", "Voodoo State");
bx_list_c *vstate = new bx_list_c(list, "vstate", "Voodoo Device State");
new bx_shadow_data_c(vstate, "reg", (Bit8u*)v->reg, sizeof(v->reg));
- some more work on save/restore support (now almost usable) - TODO: add graphics snapshot support
2012-10-12 19:14:30 +04:00
new bx_shadow_num_c(vstate, "alt_regmap", &v->alt_regmap);
- skip screen update if video is unchanged - some work on save/restore support (not yet complete) - changed some variable types to bx_bool
2012-10-01 21:02:18 +04:00
new bx_shadow_num_c(vstate, "pci_init_enable", &v->pci.init_enable, BASE_HEX);
- continued work on save/restore support (still incomplete)
2012-10-03 12:12:35 +04:00
bx_list_c *dac = new bx_list_c(vstate, "dac", "DAC");
- some more work on save/restore support (now almost usable) - TODO: add graphics snapshot support
2012-10-12 19:14:30 +04:00
for (i = 0; i < 8; i++) {
sprintf(name, "reg%d", i);
new bx_shadow_num_c(dac, name, &v->dac.reg[i], BASE_HEX);
- continued work on save/restore support (still incomplete)
2012-10-03 12:12:35 +04:00
}
new bx_shadow_num_c(dac, "read_result", &v->dac.read_result, BASE_HEX);
Fixed Voodoo pixel clock calculation. - Now using float type for the 'clk0_freq' variable. - DAC register 6 can switch to half pixel clock (ported from PCem). - Writing value 0xf8 to PLL register 0x0e completes clock #0 setup.
2017-08-21 22:33:29 +03:00
new bx_shadow_num_c(dac, "clk0_freq", &v->dac.clk0_freq);
- skip screen update if video is unchanged - some work on save/restore support (not yet complete) - changed some variable types to bx_bool
2012-10-01 21:02:18 +04:00
bx_list_c *fbi = new bx_list_c(vstate, "fbi", "framebuffer");
new bx_shadow_data_c(fbi, "ram", v->fbi.ram, (4 << 20));
new bx_shadow_num_c(fbi, "rgboffs0", &v->fbi.rgboffs[0], BASE_HEX);
new bx_shadow_num_c(fbi, "rgboffs1", &v->fbi.rgboffs[1], BASE_HEX);
new bx_shadow_num_c(fbi, "rgboffs2", &v->fbi.rgboffs[2], BASE_HEX);
new bx_shadow_num_c(fbi, "auxoffs", &v->fbi.auxoffs, BASE_HEX);
new bx_shadow_num_c(fbi, "frontbuf", &v->fbi.frontbuf);
new bx_shadow_num_c(fbi, "backbuf", &v->fbi.backbuf);
new bx_shadow_num_c(fbi, "swaps_pending", &v->fbi.swaps_pending);
- continued work on save/restore support (still incomplete)
2012-10-03 12:12:35 +04:00
new bx_shadow_num_c(fbi, "yorigin", &v->fbi.yorigin);
- skip screen update if video is unchanged - some work on save/restore support (not yet complete) - changed some variable types to bx_bool
2012-10-01 21:02:18 +04:00
new bx_shadow_num_c(fbi, "width", &v->fbi.width);
new bx_shadow_num_c(fbi, "height", &v->fbi.height);
new bx_shadow_num_c(fbi, "rowpixels", &v->fbi.rowpixels);
- continued work on save/restore support (still incomplete)
2012-10-03 12:12:35 +04:00
new bx_shadow_num_c(fbi, "vblank", &v->fbi.vblank);
new bx_shadow_num_c(fbi, "vblank_count", &v->fbi.vblank_count);
- skip screen update if video is unchanged - some work on save/restore support (not yet complete) - changed some variable types to bx_bool
2012-10-01 21:02:18 +04:00
new bx_shadow_bool_c(fbi, "vblank_swap_pending", &v->fbi.vblank_swap_pending);
- continued work on save/restore support (still incomplete)
2012-10-03 12:12:35 +04:00
new bx_shadow_num_c(fbi, "vblank_swap", &v->fbi.vblank_swap);
new bx_shadow_num_c(fbi, "vblank_dont_swap", &v->fbi.vblank_dont_swap);
- skip screen update if video is unchanged - some work on save/restore support (not yet complete) - changed some variable types to bx_bool
2012-10-01 21:02:18 +04:00
new bx_shadow_bool_c(fbi, "cheating_allowed", &v->fbi.cheating_allowed);
- continued work on save/restore support (still incomplete)
2012-10-03 12:12:35 +04:00
new bx_shadow_num_c(fbi, "sign", &v->fbi.sign);
new bx_shadow_num_c(fbi, "ax", &v->fbi.ax);
new bx_shadow_num_c(fbi, "ay", &v->fbi.ay);
new bx_shadow_num_c(fbi, "bx", &v->fbi.bx);
new bx_shadow_num_c(fbi, "by", &v->fbi.by);
new bx_shadow_num_c(fbi, "cx", &v->fbi.cx);
new bx_shadow_num_c(fbi, "cy", &v->fbi.cy);
new bx_shadow_num_c(fbi, "startr", &v->fbi.startr);
new bx_shadow_num_c(fbi, "startg", &v->fbi.startg);
new bx_shadow_num_c(fbi, "startb", &v->fbi.startb);
new bx_shadow_num_c(fbi, "starta", &v->fbi.starta);
new bx_shadow_num_c(fbi, "startz", &v->fbi.startz);
new bx_shadow_num_c(fbi, "startw", &v->fbi.startw);
new bx_shadow_num_c(fbi, "drdx", &v->fbi.drdx);
new bx_shadow_num_c(fbi, "dgdx", &v->fbi.dgdx);
new bx_shadow_num_c(fbi, "dbdx", &v->fbi.dbdx);
new bx_shadow_num_c(fbi, "dadx", &v->fbi.dadx);
new bx_shadow_num_c(fbi, "dzdx", &v->fbi.dzdx);
new bx_shadow_num_c(fbi, "dwdx", &v->fbi.dwdx);
new bx_shadow_num_c(fbi, "drdy", &v->fbi.drdy);
new bx_shadow_num_c(fbi, "dgdy", &v->fbi.dgdy);
new bx_shadow_num_c(fbi, "dbdy", &v->fbi.dbdy);
new bx_shadow_num_c(fbi, "dady", &v->fbi.dady);
new bx_shadow_num_c(fbi, "dzdy", &v->fbi.dzdy);
new bx_shadow_num_c(fbi, "dwdy", &v->fbi.dwdy);
Continued work on Voodoo2 support (some demos now working). - Added capability to save/restore float type values in paramtree / siminterface. - Added Voodoo2 triangle generator data to save/restore list. - Implemented bitBLT function "SGRAM fill". - Minor other changes and cleanups. - TODO: remaining bitBLT functions, thread handling improvements.
2017-05-16 23:37:01 +03:00
new bx_shadow_num_c(fbi, "sverts", &v->fbi.sverts);
bx_list_c *svert = new bx_list_c(fbi, "svert", "");
for (i = 0; i < 3; i++) {
sprintf(name, "%d", i);
bx_list_c *num = new bx_list_c(svert, name, "");
new bx_shadow_num_c(num, "x", &v->fbi.svert[i].x);
new bx_shadow_num_c(num, "y", &v->fbi.svert[i].y);
new bx_shadow_num_c(num, "a", &v->fbi.svert[i].a);
new bx_shadow_num_c(num, "r", &v->fbi.svert[i].r);
new bx_shadow_num_c(num, "g", &v->fbi.svert[i].g);
new bx_shadow_num_c(num, "b", &v->fbi.svert[i].b);
new bx_shadow_num_c(num, "z", &v->fbi.svert[i].z);
new bx_shadow_num_c(num, "wb", &v->fbi.svert[i].wb);
new bx_shadow_num_c(num, "w0", &v->fbi.svert[i].w0);
new bx_shadow_num_c(num, "s0", &v->fbi.svert[i].s0);
new bx_shadow_num_c(num, "t0", &v->fbi.svert[i].t0);
new bx_shadow_num_c(num, "w1", &v->fbi.svert[i].w1);
new bx_shadow_num_c(num, "s1", &v->fbi.svert[i].s1);
new bx_shadow_num_c(num, "t1", &v->fbi.svert[i].t1);
}
Continued preparing Voodoo2 CMDFIFO support. - Zero out voodoo device state in init(). - Added the CMDFIFO state to save/restore list. - Added CMDFIFO register handling in read/write functions. - Added new function cmdfifo_put(). - TODO: CMDFIFO thread.
2017-05-13 14:52:49 +03:00
bx_list_c *cmdfifo = new bx_list_c(fbi, "cmdfifo", "");
for (i = 0; i < 2; i++) {
sprintf(name, "%d", i);
bx_list_c *num = new bx_list_c(cmdfifo, name, "");
Store FIFO presence in variable "enabled" and report the state change of the currently unimplemented FIFOs.
2017-08-25 00:08:21 +03:00
new bx_shadow_bool_c(num, "enabled", &v->fbi.cmdfifo[i].enabled, BASE_HEX);
Continued preparing Voodoo2 CMDFIFO support. - Zero out voodoo device state in init(). - Added the CMDFIFO state to save/restore list. - Added CMDFIFO register handling in read/write functions. - Added new function cmdfifo_put(). - TODO: CMDFIFO thread.
2017-05-13 14:52:49 +03:00
new bx_shadow_num_c(num, "base", &v->fbi.cmdfifo[i].base, BASE_HEX);
new bx_shadow_num_c(num, "end", &v->fbi.cmdfifo[i].end, BASE_HEX);
new bx_shadow_num_c(num, "rdptr", &v->fbi.cmdfifo[i].rdptr, BASE_HEX);
new bx_shadow_num_c(num, "amin", &v->fbi.cmdfifo[i].amin, BASE_HEX);
new bx_shadow_num_c(num, "amax", &v->fbi.cmdfifo[i].amax, BASE_HEX);
First version of the Voodoo2 CMDFIFO thread using "pthread cond" code on non-WIN32 platforms instead of BX_MSLEEP(). The donut demo is once again a little bit slower, but on other tests the IPS values are still okay. Cleaned up the code a little bit and added save/restore stuff for the new code.
2017-08-17 22:15:02 +03:00
new bx_shadow_num_c(num, "depth", &v->fbi.cmdfifo[i].depth);
new bx_shadow_num_c(num, "depth_needed", &v->fbi.cmdfifo[i].depth_needed);
new bx_shadow_bool_c(num, "cmd_ready", &v->fbi.cmdfifo[i].cmd_ready);
Continued preparing Voodoo2 CMDFIFO support. - Zero out voodoo device state in init(). - Added the CMDFIFO state to save/restore list. - Added CMDFIFO register handling in read/write functions. - Added new function cmdfifo_put(). - TODO: CMDFIFO thread.
2017-05-13 14:52:49 +03:00
}
- continued work on save/restore support (still incomplete)
2012-10-03 12:12:35 +04:00
bx_list_c *fogblend = new bx_list_c(fbi, "fogblend", "");
- some more work on save/restore support (now almost usable) - TODO: add graphics snapshot support
2012-10-12 19:14:30 +04:00
for (i = 0; i < 64; i++) {
sprintf(name, "%d", i);
new bx_shadow_num_c(fogblend, name, &v->fbi.fogblend[i]);
- continued work on save/restore support (still incomplete)
2012-10-03 12:12:35 +04:00
}
bx_list_c *fogdelta = new bx_list_c(fbi, "fogdelta", "");
- some more work on save/restore support (now almost usable) - TODO: add graphics snapshot support
2012-10-12 19:14:30 +04:00
for (i = 0; i < 64; i++) {
sprintf(name, "%d", i);
new bx_shadow_num_c(fogdelta, name, &v->fbi.fogdelta[i]);
- continued work on save/restore support (still incomplete)
2012-10-03 12:12:35 +04:00
}
- skip screen update if video is unchanged - some work on save/restore support (not yet complete) - changed some variable types to bx_bool
2012-10-01 21:02:18 +04:00
new bx_shadow_data_c(fbi, "clut", (Bit8u*)v->fbi.clut, sizeof(v->fbi.clut));
new bx_shadow_bool_c(fbi, "clut_dirty", &v->fbi.clut_dirty);
- continued work on save/restore support (still incomplete)
2012-10-03 12:12:35 +04:00
bx_list_c *tmu = new bx_list_c(vstate, "tmu", "textures");
Fixed possible segfault caused by Voodoo2 control panel applet. Added some reserved register names for debug output and minor code cleanup.
2014-01-05 18:01:10 +04:00
for (i = 0; i < MAX_TMU; i++) {
- continued work on save/restore support (still incomplete)
2012-10-03 12:12:35 +04:00
sprintf(name, "%d", i);
bx_list_c *num = new bx_list_c(tmu, name, "");
new bx_shadow_data_c(num, "ram", v->tmu[i].ram, (4 << 20));
new bx_shadow_bool_c(num, "regdirty", &v->tmu[i].regdirty);
new bx_shadow_num_c(num, "starts", &v->tmu[i].starts);
new bx_shadow_num_c(num, "startt", &v->tmu[i].startt);
new bx_shadow_num_c(num, "startw", &v->tmu[i].startw);
new bx_shadow_num_c(num, "dsdx", &v->tmu[i].dsdx);
new bx_shadow_num_c(num, "dtdx", &v->tmu[i].dtdx);
new bx_shadow_num_c(num, "dwdx", &v->tmu[i].dwdx);
new bx_shadow_num_c(num, "dsdy", &v->tmu[i].dsdy);
new bx_shadow_num_c(num, "dtdy", &v->tmu[i].dtdy);
new bx_shadow_num_c(num, "dwdy", &v->tmu[i].dwdy);
new bx_shadow_num_c(num, "lodmin", &v->tmu[i].lodmin);
new bx_shadow_num_c(num, "lodmax", &v->tmu[i].lodmax);
new bx_shadow_num_c(num, "lodbias", &v->tmu[i].lodbias);
new bx_shadow_num_c(num, "lodmask", &v->tmu[i].lodmask);
bx_list_c *lodoffs = new bx_list_c(num, "lodoffset", "");
- some more work on save/restore support (now almost usable) - TODO: add graphics snapshot support
2012-10-12 19:14:30 +04:00
for (j = 0; j < 9; j++) {
- continued work on save/restore support (still incomplete)
2012-10-03 12:12:35 +04:00
sprintf(name, "%d", j);
new bx_shadow_num_c(lodoffs, name, &v->tmu[i].lodoffset[j]);
}
new bx_shadow_num_c(num, "detailmax", &v->tmu[i].detailmax);
new bx_shadow_num_c(num, "detailbias", &v->tmu[i].detailbias);
new bx_shadow_num_c(num, "wmask", &v->tmu[i].wmask);
new bx_shadow_num_c(num, "hmask", &v->tmu[i].hmask);
- some more work on save/restore support (now almost usable) - TODO: add graphics snapshot support
2012-10-12 19:14:30 +04:00
bx_list_c *ncc = new bx_list_c(num, "ncc", "");
for (j = 0; j < 2; j++) {
sprintf(name, "%d", j);
bx_list_c *ncct = new bx_list_c(ncc, name, "");
new bx_shadow_bool_c(ncct, "dirty", &v->tmu[i].ncc[j].dirty);
bx_list_c *ir = new bx_list_c(ncct, "ir", "");
bx_list_c *ig = new bx_list_c(ncct, "ig", "");
bx_list_c *ib = new bx_list_c(ncct, "ib", "");
bx_list_c *qr = new bx_list_c(ncct, "qr", "");
bx_list_c *qg = new bx_list_c(ncct, "qg", "");
bx_list_c *qb = new bx_list_c(ncct, "qb", "");
for (k = 0; k < 4; k++) {
sprintf(name, "%d", k);
new bx_shadow_num_c(ir, name, &v->tmu[i].ncc[j].ir[k]);
new bx_shadow_num_c(ig, name, &v->tmu[i].ncc[j].ig[k]);
new bx_shadow_num_c(ib, name, &v->tmu[i].ncc[j].ib[k]);
new bx_shadow_num_c(qr, name, &v->tmu[i].ncc[j].qr[k]);
new bx_shadow_num_c(qg, name, &v->tmu[i].ncc[j].qg[k]);
new bx_shadow_num_c(qb, name, &v->tmu[i].ncc[j].qb[k]);
}
bx_list_c *y = new bx_list_c(ncct, "y", "");
for (k = 0; k < 16; k++) {
sprintf(name, "%d", k);
new bx_shadow_num_c(y, name, &v->tmu[i].ncc[j].y[k]);
}
new bx_shadow_data_c(ncct, "texel", (Bit8u*)v->tmu[i].ncc[j].texel, 256 * sizeof(rgb_t));
}
- continued work on save/restore support (still incomplete)
2012-10-03 12:12:35 +04:00
new bx_shadow_data_c(num, "palette", (Bit8u*)v->tmu[i].palette, 256 * sizeof(rgb_t));
new bx_shadow_data_c(num, "palettea", (Bit8u*)v->tmu[i].palettea, 256 * sizeof(rgb_t));
}
new bx_shadow_num_c(vstate, "send_config", &v->send_config);
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
bx_list_c *vdraw = new bx_list_c(list, "vdraw", "Voodoo Draw State");
new bx_shadow_bool_c(vdraw, "clock_enabled", &BX_VOODOO_THIS s.vdraw.clock_enabled);
new bx_shadow_bool_c(vdraw, "output_on", &BX_VOODOO_THIS s.vdraw.output_on);
new bx_shadow_bool_c(vdraw, "override_on", &BX_VOODOO_THIS s.vdraw.override_on);
register_pci_state(list);
}
void bx_voodoo_c::after_restore_state(void)
{
if (DEV_pci_set_base_mem(BX_VOODOO_THIS_PTR, mem_read_handler, mem_write_handler,
&BX_VOODOO_THIS pci_base_address[0],
&BX_VOODOO_THIS pci_conf[0x10],
0x1000000)) {
BX_INFO(("new mem base address: 0x%08x", BX_VOODOO_THIS pci_base_address[0]));
}
Fixed save/restore failure.
2017-07-13 00:01:58 +03:00
if (BX_VOODOO_THIS s.vdraw.override_on) {
// force update
v->fbi.video_changed = 1;
Removed Voodoo realtime option. Since the gui screen update timing is now controlled by the 'vga' option and Voodoo2 CMDFIFO thread has the best performance with realtime mode disabled, this option is now obsolete.
2017-08-18 18:19:30 +03:00
BX_VOODOO_THIS s.vdraw.frame_start = bx_virt_timer.time_usec(0);
Fixed save/restore failure.
2017-07-13 00:01:58 +03:00
BX_VOODOO_THIS update_timing();
DEV_vga_set_override(1, BX_VOODOO_THIS_PTR);
}
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
}
bx_bool bx_voodoo_c::mem_read_handler(bx_phy_address addr, unsigned len,
void *data, void *param)
{
Bit32u *data_ptr = (Bit32u*)data;
*data_ptr = voodoo_r((addr>>2) & 0x3FFFFF);
return 1;
}
bx_bool bx_voodoo_c::mem_write_handler(bx_phy_address addr, unsigned len,
void *data, void *param)
{
Bit32u val = *(Bit32u*)data;
if (len == 4) {
voodoo_w((addr>>2) & 0x3FFFFF, val, 0xffffffff);
} else if (len == 2) {
if (addr & 3) {
voodoo_w((addr>>2) & 0x3FFFFF, val<<16, 0xffff0000);
} else {
voodoo_w((addr>>2) & 0x3FFFFF, val, 0x0000ffff);
}
}
return 1;
}
void bx_voodoo_c::mode_change_timer_handler(void *this_ptr)
{
UNUSED(this_ptr);
BX_VOODOO_THIS s.vdraw.screen_update_pending = 0;
if ((!BX_VOODOO_THIS s.vdraw.clock_enabled || !BX_VOODOO_THIS s.vdraw.output_on) && BX_VOODOO_THIS s.vdraw.override_on) {
// switching off
Some work on the timing code of the Bochs display adapters. - Voodoo: Use the VGA/Cirrus timers to drive the gui screen update. The vertical retrace emulation is still driven by a separate timer. - VGA/Cirrus: Since we are using the virtual timer, we also have to read time_usec() from it. - vgacore: removed unused timer methods.
2017-05-01 14:54:12 +03:00
bx_virt_timer.deactivate_timer(BX_VOODOO_THIS s.vertical_timer_id);
Graphics snapshot feature re-implemented for the new graphics API - graphics_tile_info() split into a common and specific part - store snapshot mode in structure bx_svga_tileinfo_t - in snapshot mode, display adapters copy raw data to buffer - rewrite of the trigger_timer() code to make it work in all cases - added new class bx_nonvga_device_c to make forwarding refresh requests to the Voodoo adapter possible
2012-10-25 19:53:04 +04:00
DEV_vga_set_override(0, NULL);
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
BX_VOODOO_THIS s.vdraw.override_on = 0;
Implemented more accurate screen update timing calculation using the RAMDAC video clock. Removed dependencies to the cpu / memory clock.
2014-01-08 02:32:22 +04:00
BX_VOODOO_THIS s.vdraw.width = 0;
BX_VOODOO_THIS s.vdraw.height = 0;
- Some work on the Voodoo Graphics emulation (Voodoo2 specific) - prepared hRetrace value implementation (cannot be enabled yet, since the driver passes this test and gets confused in next stage (segfault). - Detect CMDFIFO access (not present yet). - Report disabling Voodoo graphics mode. - TODO #1: Fix Voodoo2 to make it usable. - TODO #2: Split update code and drive gui screen updates from the VGA timer (finally remove new realtime option again).
2017-05-01 12:11:12 +03:00
BX_INFO(("Voodoo output disabled"));
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
}
if ((BX_VOODOO_THIS s.vdraw.clock_enabled && BX_VOODOO_THIS s.vdraw.output_on) && !BX_VOODOO_THIS s.vdraw.override_on) {
// switching on
Implemented more accurate screen update timing calculation using the RAMDAC video clock. Removed dependencies to the cpu / memory clock.
2014-01-08 02:32:22 +04:00
if (!BX_VOODOO_THIS update_timing())
return;
Graphics snapshot feature re-implemented for the new graphics API - graphics_tile_info() split into a common and specific part - store snapshot mode in structure bx_svga_tileinfo_t - in snapshot mode, display adapters copy raw data to buffer - rewrite of the trigger_timer() code to make it work in all cases - added new class bx_nonvga_device_c to make forwarding refresh requests to the Voodoo adapter possible
2012-10-25 19:53:04 +04:00
DEV_vga_set_override(1, BX_VOODOO_THIS_PTR);
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
BX_VOODOO_THIS s.vdraw.override_on = 1;
Implemented more accurate screen update timing calculation using the RAMDAC video clock. Removed dependencies to the cpu / memory clock.
2014-01-08 02:32:22 +04:00
}
}
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
Implemented more accurate screen update timing calculation using the RAMDAC video clock. Removed dependencies to the cpu / memory clock.
2014-01-08 02:32:22 +04:00
bx_bool bx_voodoo_c::update_timing(void)
{
- Some work on the Voodoo Graphics emulation (Voodoo2 specific) - prepared hRetrace value implementation (cannot be enabled yet, since the driver passes this test and gets confused in next stage (segfault). - Detect CMDFIFO access (not present yet). - Report disabling Voodoo graphics mode. - TODO #1: Fix Voodoo2 to make it usable. - TODO #2: Split update code and drive gui screen updates from the VGA timer (finally remove new realtime option again).
2017-05-01 12:11:12 +03:00
int htotal, vtotal, hsync, vsync;
- Some work on the Voodoo Graphics emulation - Since we are using the virtual timer, so we have to read time_usec() from it, too (TODO: realtime mode is hardcoded, maybe add an option). - Voodoo1 and Voodoo2 have different timing register widths. - Fixed vertical retrace value returned by get_retrace(). - Prepared separate hvRetrace register (TODO: hRetrace).
2017-04-29 13:25:57 +03:00
Implemented more accurate screen update timing calculation using the RAMDAC video clock. Removed dependencies to the cpu / memory clock.
2014-01-08 02:32:22 +04:00
if (!BX_VOODOO_THIS s.vdraw.clock_enabled || !BX_VOODOO_THIS s.vdraw.output_on)
return 0;
if ((v->reg[hSync].u == 0) || (v->reg[vSync].u == 0))
return 0;
- Some work on the Voodoo Graphics emulation - Since we are using the virtual timer, so we have to read time_usec() from it, too (TODO: realtime mode is hardcoded, maybe add an option). - Voodoo1 and Voodoo2 have different timing register widths. - Fixed vertical retrace value returned by get_retrace(). - Prepared separate hvRetrace register (TODO: hRetrace).
2017-04-29 13:25:57 +03:00
if (BX_VOODOO_THIS s.model == VOODOO_2) {
htotal = ((v->reg[hSync].u >> 16) & 0x7ff) + 1 + (v->reg[hSync].u & 0x1ff) + 1;
vtotal = ((v->reg[vSync].u >> 16) & 0x1fff) + (v->reg[vSync].u & 0x1fff);
- Some work on the Voodoo Graphics emulation (Voodoo2 specific) - prepared hRetrace value implementation (cannot be enabled yet, since the driver passes this test and gets confused in next stage (segfault). - Detect CMDFIFO access (not present yet). - Report disabling Voodoo graphics mode. - TODO #1: Fix Voodoo2 to make it usable. - TODO #2: Split update code and drive gui screen updates from the VGA timer (finally remove new realtime option again).
2017-05-01 12:11:12 +03:00
hsync = ((v->reg[hSync].u >> 16) & 0x7ff);
- Some work on the Voodoo Graphics emulation - Since we are using the virtual timer, so we have to read time_usec() from it, too (TODO: realtime mode is hardcoded, maybe add an option). - Voodoo1 and Voodoo2 have different timing register widths. - Fixed vertical retrace value returned by get_retrace(). - Prepared separate hvRetrace register (TODO: hRetrace).
2017-04-29 13:25:57 +03:00
vsync = ((v->reg[vSync].u >> 16) & 0x1fff);
} else {
htotal = ((v->reg[hSync].u >> 16) & 0x3ff) + 1 + (v->reg[hSync].u & 0xff) + 1;
vtotal = ((v->reg[vSync].u >> 16) & 0xfff) + (v->reg[vSync].u & 0xfff);
- Some work on the Voodoo Graphics emulation (Voodoo2 specific) - prepared hRetrace value implementation (cannot be enabled yet, since the driver passes this test and gets confused in next stage (segfault). - Detect CMDFIFO access (not present yet). - Report disabling Voodoo graphics mode. - TODO #1: Fix Voodoo2 to make it usable. - TODO #2: Split update code and drive gui screen updates from the VGA timer (finally remove new realtime option again).
2017-05-01 12:11:12 +03:00
hsync = ((v->reg[hSync].u >> 16) & 0x3ff);
- Some work on the Voodoo Graphics emulation - Since we are using the virtual timer, so we have to read time_usec() from it, too (TODO: realtime mode is hardcoded, maybe add an option). - Voodoo1 and Voodoo2 have different timing register widths. - Fixed vertical retrace value returned by get_retrace(). - Prepared separate hvRetrace register (TODO: hRetrace).
2017-04-29 13:25:57 +03:00
vsync = ((v->reg[vSync].u >> 16) & 0xfff);
}
Fixed Voodoo pixel clock calculation. - Now using float type for the 'clk0_freq' variable. - DAC register 6 can switch to half pixel clock (ported from PCem). - Writing value 0xf8 to PLL register 0x0e completes clock #0 setup.
2017-08-21 22:33:29 +03:00
float hfreq = v->dac.clk0_freq / (float)htotal;
Implemented more accurate screen update timing calculation using the RAMDAC video clock. Removed dependencies to the cpu / memory clock.
2014-01-08 02:32:22 +04:00
if (((v->reg[fbiInit1].u >> 20) & 3) == 1) { // VCLK div 2
hfreq /= 2;
}
Fixed Voodoo pixel clock calculation. - Now using float type for the 'clk0_freq' variable. - DAC register 6 can switch to half pixel clock (ported from PCem). - Writing value 0xf8 to PLL register 0x0e completes clock #0 setup.
2017-08-21 22:33:29 +03:00
float vfreq = hfreq / (float)vtotal;
Voodoo vertical retrace fixes - vertical retrace bit in status register must be inverted - implemented registers vRetrace and hvRetrace (vSyncOff only)
2014-01-15 21:29:28 +04:00
BX_VOODOO_THIS s.vdraw.htotal_usec = (unsigned)(1000000.0 / hfreq);
- Some work on the Voodoo Graphics emulation (Voodoo2 specific) - prepared hRetrace value implementation (cannot be enabled yet, since the driver passes this test and gets confused in next stage (segfault). - Detect CMDFIFO access (not present yet). - Report disabling Voodoo graphics mode. - TODO #1: Fix Voodoo2 to make it usable. - TODO #2: Split update code and drive gui screen updates from the VGA timer (finally remove new realtime option again).
2017-05-01 12:11:12 +03:00
BX_VOODOO_THIS s.vdraw.vtotal_usec = (unsigned)(1000000.0 / vfreq);
BX_VOODOO_THIS s.vdraw.htime_to_pixel = (double)htotal / (1000000.0 / hfreq);
BX_VOODOO_THIS s.vdraw.hsync_usec = BX_VOODOO_THIS s.vdraw.htotal_usec * hsync / htotal;
Voodoo vertical retrace fixes - vertical retrace bit in status register must be inverted - implemented registers vRetrace and hvRetrace (vSyncOff only)
2014-01-15 21:29:28 +04:00
BX_VOODOO_THIS s.vdraw.vsync_usec = vsync * BX_VOODOO_THIS s.vdraw.htotal_usec;
Implemented more accurate screen update timing calculation using the RAMDAC video clock. Removed dependencies to the cpu / memory clock.
2014-01-08 02:32:22 +04:00
if ((BX_VOODOO_THIS s.vdraw.width != v->fbi.width) ||
(BX_VOODOO_THIS s.vdraw.height != v->fbi.height)) {
BX_VOODOO_THIS s.vdraw.width = v->fbi.width;
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
BX_VOODOO_THIS s.vdraw.height = v->fbi.height;
Implemented more accurate screen update timing calculation using the RAMDAC video clock. Removed dependencies to the cpu / memory clock.
2014-01-08 02:32:22 +04:00
bx_gui->dimension_update(v->fbi.width, v->fbi.height, 0, 0, 16);
Some work on the timing code of the Bochs display adapters. - Voodoo: Use the VGA/Cirrus timers to drive the gui screen update. The vertical retrace emulation is still driven by a separate timer. - VGA/Cirrus: Since we are using the virtual timer, we also have to read time_usec() from it. - vgacore: removed unused timer methods.
2017-05-01 14:54:12 +03:00
vertical_timer_handler(NULL);
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
}
Implemented more accurate screen update timing calculation using the RAMDAC video clock. Removed dependencies to the cpu / memory clock.
2014-01-08 02:32:22 +04:00
BX_INFO(("Voodoo output %dx%d@%uHz", v->fbi.width, v->fbi.height, (unsigned)vfreq));
Some work on the timing code of the Bochs display adapters. - Voodoo: Use the VGA/Cirrus timers to drive the gui screen update. The vertical retrace emulation is still driven by a separate timer. - VGA/Cirrus: Since we are using the virtual timer, we also have to read time_usec() from it. - vgacore: removed unused timer methods.
2017-05-01 14:54:12 +03:00
bx_virt_timer.activate_timer(BX_VOODOO_THIS s.vertical_timer_id, (Bit32u)BX_VOODOO_THIS s.vdraw.vtotal_usec, 1);
Implemented more accurate screen update timing calculation using the RAMDAC video clock. Removed dependencies to the cpu / memory clock.
2014-01-08 02:32:22 +04:00
return 1;
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
}
vga refresh framework changes - renamed trigger_timer() methods to refresh_display() - new argument 'redraw' added to force a refresh of the entire screen (used in snapshot mode) - siminterface method refresh_vga() now checks if the Bochs gui init is complete - use SIM->refresh_vga() in some more cases
2012-10-28 12:23:39 +04:00
void bx_voodoo_c::refresh_display(void *this_ptr, bx_bool redraw)
Graphics snapshot feature re-implemented for the new graphics API - graphics_tile_info() split into a common and specific part - store snapshot mode in structure bx_svga_tileinfo_t - in snapshot mode, display adapters copy raw data to buffer - rewrite of the trigger_timer() code to make it work in all cases - added new class bx_nonvga_device_c to make forwarding refresh requests to the Voodoo adapter possible
2012-10-25 19:53:04 +04:00
{
vga refresh framework changes - renamed trigger_timer() methods to refresh_display() - new argument 'redraw' added to force a refresh of the entire screen (used in snapshot mode) - siminterface method refresh_vga() now checks if the Bochs gui init is complete - use SIM->refresh_vga() in some more cases
2012-10-28 12:23:39 +04:00
if (redraw) {
redraw_area(0, 0, v->fbi.width, v->fbi.height);
}
Some work on the timing code of the Bochs display adapters. - Voodoo: Use the VGA/Cirrus timers to drive the gui screen update. The vertical retrace emulation is still driven by a separate timer. - VGA/Cirrus: Since we are using the virtual timer, we also have to read time_usec() from it. - vgacore: removed unused timer methods.
2017-05-01 14:54:12 +03:00
vertical_timer_handler(this_ptr);
Graphics snapshot feature re-implemented for the new graphics API - graphics_tile_info() split into a common and specific part - store snapshot mode in structure bx_svga_tileinfo_t - in snapshot mode, display adapters copy raw data to buffer - rewrite of the trigger_timer() code to make it work in all cases - added new class bx_nonvga_device_c to make forwarding refresh requests to the Voodoo adapter possible
2012-10-25 19:53:04 +04:00
}
Some work on the timing code of the Bochs display adapters. - Voodoo: Use the VGA/Cirrus timers to drive the gui screen update. The vertical retrace emulation is still driven by a separate timer. - VGA/Cirrus: Since we are using the virtual timer, we also have to read time_usec() from it. - vgacore: removed unused timer methods.
2017-05-01 14:54:12 +03:00
void bx_voodoo_c::vertical_timer_handler(void *this_ptr)
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
{
UNUSED(this_ptr);
Removed Voodoo realtime option. Since the gui screen update timing is now controlled by the 'vga' option and Voodoo2 CMDFIFO thread has the best performance with realtime mode disabled, this option is now obsolete.
2017-08-18 18:19:30 +03:00
BX_VOODOO_THIS s.vdraw.frame_start = bx_virt_timer.time_usec(0);
Some work on the timing code of the Bochs display adapters. - Voodoo: Use the VGA/Cirrus timers to drive the gui screen update. The vertical retrace emulation is still driven by a separate timer. - VGA/Cirrus: Since we are using the virtual timer, we also have to read time_usec() from it. - vgacore: removed unused timer methods.
2017-05-01 14:54:12 +03:00
Implemented combined PCI / memory FIFO. This is required for running Voodoo1 games / demos correctly on the Voodoo2 model. I noticed a small slowdown (2 or 3 percent) on the Voodoo1.
2017-09-08 19:17:20 +03:00
BX_LOCK(fifo_mutex);
if (!fifo_empty(&v->pci.fifo) || !fifo_empty(&v->fbi.fifo)) {
Moved event / wait stuff from the Voodoo code to osdep.cc fot the usage in other parts of Bochs.
2017-09-10 09:50:07 +03:00
bx_set_event(&fifo_wakeup);
Implemented memory FIFO to speed up the Voodoo1 emulation. The PCI FIFO with it's 64 entries is still not present, since it makes the emulation a few percent slower due to the overhead of the FIFO code. The memory FIFO has 64k entries and makes a speedup of around 75 % possible.
2017-09-01 20:30:49 +03:00
}
Implemented combined PCI / memory FIFO. This is required for running Voodoo1 games / demos correctly on the Voodoo2 model. I noticed a small slowdown (2 or 3 percent) on the Voodoo1.
2017-09-08 19:17:20 +03:00
BX_UNLOCK(fifo_mutex);
Voodoo2: Now only start processing of the CMDFIFO at the vertical retrace. I noticed a speed improvement of around 10 % (tested with donut demo only).
2017-08-16 00:30:45 +03:00
if (v->fbi.cmdfifo[0].cmd_ready) {
Moved event / wait stuff from the Voodoo code to osdep.cc fot the usage in other parts of Bochs.
2017-09-10 09:50:07 +03:00
bx_set_event(&fifo_wakeup);
Voodoo2: Now only start processing of the CMDFIFO at the vertical retrace. I noticed a speed improvement of around 10 % (tested with donut demo only).
2017-08-16 00:30:45 +03:00
}
Some work on the timing code of the Bochs display adapters. - Voodoo: Use the VGA/Cirrus timers to drive the gui screen update. The vertical retrace emulation is still driven by a separate timer. - VGA/Cirrus: Since we are using the virtual timer, we also have to read time_usec() from it. - vgacore: removed unused timer methods.
2017-05-01 14:54:12 +03:00
if (v->fbi.vblank_swap_pending) {
swap_buffers(v);
}
rectangle re;
re.min_x = re.min_y = 0;
re.max_x = v->fbi.width;
re.max_y = v->fbi.height;
if (!voodoo_update(&re))
return;
BX_VOODOO_THIS s.vdraw.gui_update_pending = 1;
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
}
void bx_voodoo_c::update(void)
{
unsigned pitch;
unsigned xc, yc, xti, yti;
unsigned r, c, w, h;
int i;
unsigned long colour;
Bit8u * vid_ptr, * vid_ptr2;
Bit8u * tile_ptr, * tile_ptr2;
bx_svga_tileinfo_t info;
Some work on the timing code of the Bochs display adapters. - Voodoo: Use the VGA/Cirrus timers to drive the gui screen update. The vertical retrace emulation is still driven by a separate timer. - VGA/Cirrus: Since we are using the virtual timer, we also have to read time_usec() from it. - vgacore: removed unused timer methods.
2017-05-01 14:54:12 +03:00
if (!BX_VOODOO_THIS s.vdraw.gui_update_pending)
- skip screen update if video is unchanged - some work on save/restore support (not yet complete) - changed some variable types to bx_bool
2012-10-01 21:02:18 +04:00
return;
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
Bit8u *disp_ptr = (Bit8u*)(v->fbi.ram + v->fbi.rgboffs[v->fbi.frontbuf]);
pitch = v->fbi.rowpixels * 2;
Graphics snapshot feature re-implemented for the new graphics API - graphics_tile_info() split into a common and specific part - store snapshot mode in structure bx_svga_tileinfo_t - in snapshot mode, display adapters copy raw data to buffer - rewrite of the trigger_timer() code to make it work in all cases - added new class bx_nonvga_device_c to make forwarding refresh requests to the Voodoo adapter possible
2012-10-25 19:53:04 +04:00
if (bx_gui->graphics_tile_info_common(&info)) {
if (info.snapshot_mode) {
vid_ptr = disp_ptr;
tile_ptr = bx_gui->get_snapshot_buffer();
if (tile_ptr != NULL) {
for (yc = 0; yc < BX_VOODOO_THIS s.vdraw.height; yc++) {
memcpy(tile_ptr, vid_ptr, info.pitch);
vid_ptr += pitch;
tile_ptr += info.pitch;
}
}
} else if (info.is_indexed) {
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
BX_ERROR(("current guest pixel format is unsupported on indexed colour host displays"));
} else {
for (yc=0, yti = 0; yc<BX_VOODOO_THIS s.vdraw.height; yc+=Y_TILESIZE, yti++) {
for (xc=0, xti = 0; xc<BX_VOODOO_THIS s.vdraw.width; xc+=X_TILESIZE, xti++) {
vid_ptr = disp_ptr + (yc * pitch + (xc<<1));
tile_ptr = bx_gui->graphics_tile_get(xc, yc, &w, &h);
for (r=0; r<h; r++) {
vid_ptr2 = vid_ptr;
tile_ptr2 = tile_ptr;
for (c=0; c<w; c++) {
colour = *(vid_ptr2++);
colour |= *(vid_ptr2++) << 8;
colour = MAKE_COLOUR(
colour & 0x001f, 5, info.blue_shift, info.blue_mask,
colour & 0x07e0, 11, info.green_shift, info.green_mask,
colour & 0xf800, 16, info.red_shift, info.red_mask);
if (info.is_little_endian) {
for (i=0; i<info.bpp; i+=8) {
*(tile_ptr2++) = (Bit8u)(colour >> i);
}
} else {
for (i=info.bpp-8; i>-8; i-=8) {
*(tile_ptr2++) = (Bit8u)(colour >> i);
}
}
}
vid_ptr += pitch;
tile_ptr += info.pitch;
}
bx_gui->graphics_tile_update_in_place(xc, yc, w, h);
}
}
}
} else {
BX_PANIC(("cannot get svga tile info"));
}
Some work on the timing code of the Bochs display adapters. - Voodoo: Use the VGA/Cirrus timers to drive the gui screen update. The vertical retrace emulation is still driven by a separate timer. - VGA/Cirrus: Since we are using the virtual timer, we also have to read time_usec() from it. - vgacore: removed unused timer methods.
2017-05-01 14:54:12 +03:00
BX_VOODOO_THIS s.vdraw.gui_update_pending = 0;
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
}
Graphics snapshot feature re-implemented for the new graphics API - graphics_tile_info() split into a common and specific part - store snapshot mode in structure bx_svga_tileinfo_t - in snapshot mode, display adapters copy raw data to buffer - rewrite of the trigger_timer() code to make it work in all cases - added new class bx_nonvga_device_c to make forwarding refresh requests to the Voodoo adapter possible
2012-10-25 19:53:04 +04:00
void bx_voodoo_c::redraw_area(unsigned x0, unsigned y0, unsigned width,
unsigned height)
{
// TODO: implement tile-based update mechanism
v->fbi.video_changed = 1;
}
- Some work on the Voodoo Graphics emulation (Voodoo2 specific) - prepared hRetrace value implementation (cannot be enabled yet, since the driver passes this test and gets confused in next stage (segfault). - Detect CMDFIFO access (not present yet). - Report disabling Voodoo graphics mode. - TODO #1: Fix Voodoo2 to make it usable. - TODO #2: Split update code and drive gui screen updates from the VGA timer (finally remove new realtime option again).
2017-05-01 12:11:12 +03:00
Bit32u bx_voodoo_c::get_retrace(bx_bool hv)
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
{
Removed Voodoo realtime option. Since the gui screen update timing is now controlled by the 'vga' option and Voodoo2 CMDFIFO thread has the best performance with realtime mode disabled, this option is now obsolete.
2017-08-18 18:19:30 +03:00
Bit64u time_in_frame = bx_virt_timer.time_usec(0) - BX_VOODOO_THIS s.vdraw.frame_start;
- Some work on the Voodoo Graphics emulation - Since we are using the virtual timer, so we have to read time_usec() from it, too (TODO: realtime mode is hardcoded, maybe add an option). - Voodoo1 and Voodoo2 have different timing register widths. - Fixed vertical retrace value returned by get_retrace(). - Prepared separate hvRetrace register (TODO: hRetrace).
2017-04-29 13:25:57 +03:00
if (time_in_frame >= BX_VOODOO_THIS s.vdraw.vsync_usec) {
Voodoo vertical retrace fixes - vertical retrace bit in status register must be inverted - implemented registers vRetrace and hvRetrace (vSyncOff only)
2014-01-15 21:29:28 +04:00
return 0;
} else {
- Some work on the Voodoo Graphics emulation (Voodoo2 specific) - prepared hRetrace value implementation (cannot be enabled yet, since the driver passes this test and gets confused in next stage (segfault). - Detect CMDFIFO access (not present yet). - Report disabling Voodoo graphics mode. - TODO #1: Fix Voodoo2 to make it usable. - TODO #2: Split update code and drive gui screen updates from the VGA timer (finally remove new realtime option again).
2017-05-01 12:11:12 +03:00
Bit32u value = (Bit32u)(time_in_frame / BX_VOODOO_THIS s.vdraw.htotal_usec + 1);
if (hv) {
Bit32u time_in_line = (Bit32u)(time_in_frame % BX_VOODOO_THIS s.vdraw.htotal_usec);
Bit32u hpixel = (Bit32u)(time_in_line * BX_VOODOO_THIS s.vdraw.htime_to_pixel);
if (time_in_line < BX_VOODOO_THIS s.vdraw.hsync_usec) {
Fixed check for unimplemented CMDFIFO and return for now if write would be valid. The hRetrace value can be set now, since Bochs no longer crashes. TODO: Implement enough of the FIFO stuff to make the Win9x driver for the Voodoo2 work.
2017-05-06 13:07:28 +03:00
value |= ((hpixel + 1) << 16);
- Some work on the Voodoo Graphics emulation (Voodoo2 specific) - prepared hRetrace value implementation (cannot be enabled yet, since the driver passes this test and gets confused in next stage (segfault). - Detect CMDFIFO access (not present yet). - Report disabling Voodoo graphics mode. - TODO #1: Fix Voodoo2 to make it usable. - TODO #2: Split update code and drive gui screen updates from the VGA timer (finally remove new realtime option again).
2017-05-01 12:11:12 +03:00
}
}
return value;
Voodoo vertical retrace fixes - vertical retrace bit in status register must be inverted - implemented registers vRetrace and hvRetrace (vSyncOff only)
2014-01-15 21:29:28 +04:00
}
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
}
void bx_voodoo_c::output_enable(bx_bool enabled)
{
if (BX_VOODOO_THIS s.vdraw.output_on != enabled) {
BX_VOODOO_THIS s.vdraw.output_on = enabled;
update_screen_start();
}
}
void bx_voodoo_c::update_screen_start(void)
{
if (!BX_VOODOO_THIS s.vdraw.screen_update_pending) {
BX_VOODOO_THIS s.vdraw.screen_update_pending = 1;
bx_virt_timer.activate_timer(BX_VOODOO_THIS s.mode_change_timer_id, 1000, 0);
}
}
void bx_voodoo_c::set_irq_level(bx_bool level)
{
DEV_pci_set_irq(BX_VOODOO_THIS s.devfunc, BX_VOODOO_THIS pci_conf[0x3d], level);
}
// pci configuration space write callback handler
void bx_voodoo_c::pci_write_handler(Bit8u address, Bit32u value, unsigned io_len)
{
Bit8u value8, oldval;
bx_bool baseaddr_change = 0;
if ((address >= 0x14) && (address < 0x34))
return;
for (unsigned i=0; i<io_len; i++) {
value8 = (value >> (i*8)) & 0xFF;
oldval = BX_VOODOO_THIS pci_conf[address+i];
switch (address+i) {
case 0x04:
value8 &= 0x02;
break;
case 0x3c:
if (value8 != oldval) {
BX_INFO(("new irq line = %d", value8));
}
break;
case 0x10:
value8 = (value8 & 0xf0) | (oldval & 0x0f);
case 0x11:
case 0x12:
case 0x13:
baseaddr_change |= (value8 != oldval);
break;
- enable Voodoo clock in init() - don't enable Voodoo mode if hSync or vSync are still 0 to avoid Bochs crash (division by zero error) - handle PCI register 0x40 (initEnable) - fixed reported display size
2012-09-30 16:11:01 +04:00
case 0x40:
case 0x41:
Some work on the Voodoo emulation - fixed behaviour of the initEnable register - fixed some uninitialized variables - some other small fixes and cleanups
2014-01-03 02:34:01 +04:00
case 0x42:
case 0x43:
Store FIFO presence in variable "enabled" and report the state change of the currently unimplemented FIFOs.
2017-08-25 00:08:21 +03:00
if (((address+i) == 0x40) && ((value8 ^ oldval) & 0x02)) {
v->pci.fifo.enabled = ((value8 & 0x02) > 0);
Implemented memory FIFO to speed up the Voodoo1 emulation. The PCI FIFO with it's 64 entries is still not present, since it makes the emulation a few percent slower due to the overhead of the FIFO code. The memory FIFO has 64k entries and makes a speedup of around 75 % possible.
2017-09-01 20:30:49 +03:00
if (!v->pci.fifo.enabled && !fifo_empty(&v->pci.fifo)) {
Moved event / wait stuff from the Voodoo code to osdep.cc fot the usage in other parts of Bochs.
2017-09-10 09:50:07 +03:00
bx_set_event(&fifo_wakeup);
Implemented memory FIFO to speed up the Voodoo1 emulation. The PCI FIFO with it's 64 entries is still not present, since it makes the emulation a few percent slower due to the overhead of the FIFO code. The memory FIFO has 64k entries and makes a speedup of around 75 % possible.
2017-09-01 20:30:49 +03:00
}
BX_DEBUG(("PCI FIFO now %sabled (not implemented)", v->pci.fifo.enabled ? "en":"dis"));
Store FIFO presence in variable "enabled" and report the state change of the currently unimplemented FIFOs.
2017-08-25 00:08:21 +03:00
}
- Some work on the Voodoo Graphics emulation - Store the Voodoo model in structure bx_voodoo_t. - The PCI initEnable register of the Voodoo2 model has a read-only secondary revision ID in bits 12..15. Now the Voodoo2 is correctly detected by the Windows driver, but display is not yet working (blank screen). - Reset now disables VGA override. - PCI: Moved PCI device base class methods to the end of file devices.cc and re-define LOG_THIS to use the correct log module and prefix.
2017-04-28 21:45:45 +03:00
if (((address+i) == 0x41) && (BX_VOODOO_THIS s.model == VOODOO_2)) {
value8 &= 0x0f;
value8 |= 0x50;
}
- enable Voodoo clock in init() - don't enable Voodoo mode if hSync or vSync are still 0 to avoid Bochs crash (division by zero error) - handle PCI register 0x40 (initEnable) - fixed reported display size
2012-09-30 16:11:01 +04:00
v->pci.init_enable &= ~(0xff << (i*8));
v->pci.init_enable |= (value8 << (i*8));
break;
Applied initial version of the 3dfx Voodoo Graphics emulation. The Voodoo core is based on a patch originally designed for DOSBox. Currently only the Voodoo1 adapter model can be emulation. The emulation is currently slow, but we intend to clean up and optimize the code. Running the 3D engine in a separate thread is also planned. To compile with Voodoo support the configure option "--enable-voodoo" must be used. Then the device can be activated with "plugin_ctrl: voodoo=1" in bochsrc or on the command line. The device will be assigned automatically to a PCI slot unless you do that manually. A specific bochsrc option to select the adapter model will be added when the code has support for it.
2012-09-15 01:50:50 +04:00
case 0xc0:
BX_VOODOO_THIS s.vdraw.clock_enabled = 1;
update_screen_start();
break;
case 0xe0:
BX_VOODOO_THIS s.vdraw.clock_enabled = 0;
update_screen_start();
break;
default:
value8 = oldval;
}
BX_VOODOO_THIS pci_conf[address+i] = value8;
}
if (baseaddr_change) {
if (DEV_pci_set_base_mem(BX_VOODOO_THIS_PTR, mem_read_handler, mem_write_handler,
&BX_VOODOO_THIS pci_base_address[0],
&BX_VOODOO_THIS pci_conf[0x10],
0x1000000)) {
BX_INFO(("new mem base address: 0x%08x", BX_VOODOO_THIS pci_base_address[0]));
}
}
if (io_len == 1)
BX_DEBUG(("write PCI register 0x%02x value 0x%02x", address, value));
else if (io_len == 2)
BX_DEBUG(("write PCI register 0x%02x value 0x%04x", address, value));
else if (io_len == 4)
BX_DEBUG(("write PCI register 0x%02x value 0x%08x", address, value));
}
#endif // BX_SUPPORT_PCI && BX_SUPPORT_VOODOO
Reference in New Issue Copy Permalink