mirror/86Box
1
0
Fork 0
mirror of https://github.com/86Box/86Box.git synced 2026-02-22 09:35:32 -07:00
Code Issues Packages Projects Releases Activity

Merge remote-tracking branch 'origin/master' into version/4.1

Browse Source
This commit is contained in:
OBattler
2023-08-10 05:15:26 +02:00
parent 6796a45f7f 3462e563b8
commit 073193a66a
75 changed files with 1411 additions and 1188 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/cdrom/cdrom_image_backend.c
View File

@@ -652,9 +652,7 @@ cdi_cue_get_buffer(char *str, char **line, int up)
done = 1;
break;
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
default:
if (up && islower((int) *s))

4
src/cdrom/cdrom_mitsumi.c
View File

@@ -324,9 +324,7 @@ mitsumi_cdrom_out(uint16_t port, uint8_t val, void *priv)
break;
case 5:
dev->readmsf = 0;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 4:
case 3:
dev->readmsf |= CD_DCB(val) << ((dev->cmdrd_count - 3) << 3);

8
src/chipset/ali1621.c
View File

@@ -114,9 +114,7 @@ ali1621_smram_recalc(uint8_t val, ali1621_t *dev)
switch (val & 0x30) {
case 0x10: /* Open. */
access_normal = ACCESS_SMRAM_RX;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x30: /* Protect. */
access_smm |= ACCESS_SMRAM_R;
break;
@@ -129,9 +127,7 @@ ali1621_smram_recalc(uint8_t val, ali1621_t *dev)
switch (val & 0x30) {
case 0x10: /* Open. */
access_normal |= ACCESS_SMRAM_W;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x30: /* Protect. */
access_smm |= ACCESS_SMRAM_W;
break;

4
src/chipset/ali6117.c
View File

@@ -234,9 +234,7 @@ ali6117_reg_write(uint16_t addr, uint8_t val, void *priv)
case 0x12:
val &= 0xf7;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x14:
case 0x15:

4
src/chipset/opti283.c
View File

@@ -229,9 +229,7 @@ opti283_write(uint16_t addr, uint8_t val, void *priv)
case 0x14:
reset_on_hlt = !!(val & 0x40);
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x11:
case 0x12:
case 0x13:

4
src/chipset/via_pipc.c
View File

@@ -1477,9 +1477,7 @@ pipc_write(int func, int addr, uint8_t val, void *priv)
case 0xd2:
if (dev->local == VIA_PIPC_686B)
smbus_piix4_setclock(dev->smbus, (val & 0x04) ? 65536 : 16384);
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x90:
case 0x91:

8
src/device/kbc_at.c
View File

@@ -468,9 +468,7 @@ kbc_at_poll_at(atkbc_t *dev)
case STATE_KBC_AMI_OUT:
if (dev->status & STAT_OFULL)
break;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case STATE_MAIN_IBF:
default:
at_main_ibf:
@@ -593,9 +591,7 @@ kbc_at_poll_ps2(atkbc_t *dev)
case STATE_KBC_AMI_OUT:
if (dev->status & STAT_OFULL)
break;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case STATE_MAIN_IBF:
default:
ps2_main_ibf:

4
src/device/kbc_at_dev.c
View File

@@ -136,9 +136,7 @@ kbc_at_dev_poll(void *priv)
dev->port->wantcmd = 0;
break;
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case DEV_STATE_MAIN_WANT_IN:
/* Output command response and then return to main loop #2. */
if ((dev->port->out_new == -1) && (dev->cmd_queue_start != dev->cmd_queue_end)) {

18
src/device/mouse_serial.c
View File

@@ -28,8 +28,6 @@
#include <86box/serial.h>
#include <86box/mouse.h>
#include <86box/plat.h>
#include <86box/plat_fallthrough.h>
#include <86box/plat_unused.h>
#define SERMOUSE_PORT 0 /* attach to Serial0 */
@@ -672,9 +670,7 @@ ltsermouse_process_command(mouse_t *dev)
case 0x41:
/* Absolute Bit Pad One Packed Binary Format */
dev->abs_x = dev->abs_y = 0;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x42: /* Relative Bit Pad One Packed Binary Format */
case 0x53: /* MM Series Data Format */
case 0x54: /* Three Byte Packed Binary Format */
@@ -759,9 +755,7 @@ ltsermouse_process_data(mouse_t *dev)
switch (dev->ib) {
default:
mouse_serial_log("Serial mouse: Invalid period %02X, using 1200 bps\n", data);
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x6e:
dev->bps = 1200;
break;
@@ -870,14 +864,10 @@ ltsermouse_write(UNUSED(struct serial_s *serial), void *priv, uint8_t data)
case STATE_TRANSMIT:
case STATE_SKIP_REPORT:
sermouse_set_period(dev, 0.0);
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
default:
dev->state = STATE_COMMAND;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case STATE_DATA:
sermouse_timer(dev);
break;

2
src/device/postcard.c
View File

@@ -128,8 +128,6 @@ postcard_reset(void)
static void
postcard_write(uint16_t port, uint8_t val, UNUSED(void *priv))
{
uint8_t matches = 0;
if (postcard_written[port & POSTCARD_MASK] &&
(val == postcard_codes[port & POSTCARD_MASK]))
return;

5
src/device/smbus_ali7101.c
View File

@@ -193,10 +193,7 @@ smbus_ali7101_write(uint16_t addr, uint8_t val, void *priv)
case 0x4: /* block R/W */
timer_bytes++; /* count the SMBus length byte now */
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
default: /* unknown */
dev->next_stat = 0x20; /* raise DEV_ERR */

15
src/device/smbus_piix4.c
View File

@@ -195,10 +195,7 @@ smbus_piix4_write(uint16_t addr, uint8_t val, void *priv)
i2c_write(i2c_smbus, smbus_addr, dev->cmd);
timer_bytes++;
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0xc: /* I2C process call */
if (!read) { /* word write (only when writing) */
@@ -216,10 +213,7 @@ smbus_piix4_write(uint16_t addr, uint8_t val, void *priv)
case 0x5: /* block R/W */
timer_bytes++; /* count the SMBus length byte now */
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0xd: /* I2C block R/W */
i2c_write(i2c_smbus, smbus_addr, dev->cmd);
@@ -251,10 +245,7 @@ smbus_piix4_write(uint16_t addr, uint8_t val, void *priv)
/* command write */
i2c_write(i2c_smbus, smbus_addr, dev->cmd);
timer_bytes++;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0xe: /* I2C with 7-bit address */
if (!read) { /* word write (only when writing) */

8
src/disk/hdc_esdi_at.c
View File

@@ -338,9 +338,7 @@ esdi_write(uint16_t port, uint8_t val, void *priv)
esdi->command &= ~0x03;
if (val & 0x02)
fatal("Read with ECC\n");
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0xa0:
esdi->status = STAT_BUSY;
@@ -399,9 +397,7 @@ esdi_write(uint16_t port, uint8_t val, void *priv)
default:
esdi_at_log("WD1007: bad command %02X\n", val);
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0xe8: /*???*/
esdi->status = STAT_BUSY;
esdi_set_callback(esdi, 200 * HDC_TIME);

8
src/disk/hdc_ide.c
View File

@@ -1655,9 +1655,7 @@ ide_writeb(uint16_t addr, uint8_t val, void *priv)
disabled, the Read Multiple operation is rejected with an Aborted Com-
mand error. */
ide->blockcount = 0;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case WIN_READ:
case WIN_READ_NORETRY:
@@ -1706,9 +1704,7 @@ ide_writeb(uint16_t addr, uint8_t val, void *priv)
/* Turn on the activity indicator *here* so that it gets turned on
less times. */
ui_sb_update_icon(SB_HDD | hdd[ide->hdd_num].bus, 1);
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case WIN_WRITE:
case WIN_WRITE_NORETRY:

8
src/disk/hdc_st506_xt.c
View File

@@ -623,9 +623,7 @@ st506_callback(void *priv)
st506_complete(dev);
break;
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case CMD_FORMAT_TRACK:
case CMD_FORMAT_BAD_TRACK:
@@ -1608,9 +1606,7 @@ st506_init(const device_t *info)
case ST506_XT_TYPE_ST11R: /* Seagate ST-11R (RLL) */
dev->spt = RLL_SECTORS;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case ST506_XT_TYPE_ST11M: /* Seagate ST-11M (MFM) */
dev->nr_err = ERR_NOT_AVAILABLE;

12
src/disk/hdc_xta.c
View File

@@ -509,9 +509,7 @@ hdc_callback(void *priv)
case CMD_READ_VERIFY:
no_data = 1;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case CMD_READ_SECTORS:
if (!drive->present) {
@@ -536,9 +534,7 @@ hdc_callback(void *priv)
dev->buf_len = 512;
dev->state = STATE_SEND;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case STATE_SEND:
/* Activate the status icon. */
@@ -646,9 +642,7 @@ do_send:
dev->buf_len = 512;
dev->state = STATE_RECV;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case STATE_RECV:
/* Activate the status icon. */

9
src/disk/mo.c
View File

@@ -655,9 +655,8 @@ mo_update_request_length(mo_t *dev, int len, int block_len)
break;
}
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
default:
dev->packet_len = len;
break;
@@ -1344,9 +1343,7 @@ mo_command(scsi_common_t *sc, uint8_t *cdb)
mo_invalid_field(dev);
return;
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case GPCMD_SCSI_RESERVE:
case GPCMD_SCSI_RELEASE:
case GPCMD_TEST_UNIT_READY:

12
src/disk/zip.c
View File

@@ -821,9 +821,7 @@ zip_update_request_length(zip_t *dev, int len, int block_len)
break;
}
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
default:
dev->packet_len = len;
@@ -1411,9 +1409,7 @@ zip_command(scsi_common_t *sc, uint8_t *cdb)
zip_invalid_field(dev);
return;
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case GPCMD_SCSI_RESERVE:
case GPCMD_SCSI_RELEASE:
case GPCMD_TEST_UNIT_READY:
@@ -1576,9 +1572,7 @@ zip_command(scsi_common_t *sc, uint8_t *cdb)
zip_command_complete(dev);
break;
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case GPCMD_WRITE_6:
case GPCMD_WRITE_10:
case GPCMD_WRITE_AND_VERIFY_10:

12
src/floppy/fdc.c
View File

@@ -917,9 +917,7 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
fdc_bad_command(fdc);
break;
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x07: /*Recalibrate*/
fdc->pnum = 0;
fdc->ptot = 1;
@@ -962,9 +960,7 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
fdc_bad_command(fdc);
break;
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x10: /*Get version*/
case 0x14: /*Unlock*/
case 0x94: /*Lock*/
@@ -1086,9 +1082,7 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
case 0x16: /* Verify */
if (fdc->params[0] & 0x80)
fdc->sc = fdc->params[7];
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x06: /* Read data */
case 0x0c: /* Read deleted data */
fdc_io_command_phase1(fdc, 0);

12
src/floppy/fdd_86f.c
View File

@@ -1951,9 +1951,7 @@ d86f_format_track(int drive, int side, int do_write)
if (dev->datac == 3)
fdc_stop_id_request(d86f_fdc);
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case FMT_PRETRK_SYNC:
case FMT_SECTOR_DATA_SYNC:
@@ -2296,9 +2294,7 @@ d86f_turbo_poll(int drive, int side)
case STATE_0D_SPIN_TO_INDEX:
dev->sector_count = 0;
dev->datac = 5;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case STATE_02_SPIN_TO_INDEX:
dev->state++;
@@ -2343,9 +2339,7 @@ d86f_turbo_poll(int drive, int side)
dev->last_sector.id.r = dev->req_sector.id.r;
dev->last_sector.id.n = dev->req_sector.id.n;
d86f_handler[drive].set_sector(drive, side, dev->last_sector.id.c, dev->last_sector.id.h, dev->last_sector.id.r, dev->last_sector.id.n);
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case STATE_0A_FIND_ID:
dev->turbo_pos = 0;

9
src/include/86box/plat.h
View File

@@ -55,8 +55,13 @@ extern int strnicmp(const char *s1, const char *s2, size_t n);
# define off64_t off_t
#endif
#if !defined (__APPLE__) && !defined(__clang__)
# define FALLTHROUGH_ANNOTATION
#if __has_attribute(fallthrough)
# define fallthrough __attribute__((fallthrough))
#else
# if __has_attribute(__fallthrough__)
# define fallthrough __attribute__((__fallthrough__))
# endif
# define fallthrough do {} while (0) /* fallthrough */
#endif
#ifdef _MSC_VER

9
src/include/86box/plat_fallthrough.h
View File

@@ -18,8 +18,13 @@
#ifndef EMU_PLAT_FALLTHROUGH_H
#define EMU_PLAT_FALLTHROUGH_H
#if !defined (__APPLE__) && !defined(__clang__)
# define FALLTHROUGH_ANNOTATION
#if __has_attribute(__fallthrough__)
# define fallthrough __attribute__((__fallthrough__))
#else
# if __has_attribute(fallthrough)
# define fallthrough __attribute__((fallthrough))
# endif
# define fallthrough do {} while (0) /* fallthrough */
#endif
#endif /*EMU_PLAT_FALLTHROUGH_H*/

916
src/machine/m_at_socket370.c
View File

@@ -1,458 +1,458 @@
/*
* 86Box A hypervisor and IBM PC system emulator that specializes in
* running old operating systems and software designed for IBM
* PC systems and compatibles from 1981 through fairly recent
* system designs based on the PCI bus.
*
* This file is part of the 86Box distribution.
*
* Implementation of Socket 370(PGA370) machines.
*
*
*
* Authors: Miran Grca, <mgrca8@gmail.com>
*
* Copyright 2016-2019 Miran Grca.
*/
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include <86box/86box.h>
#include <86box/mem.h>
#include <86box/io.h>
#include <86box/rom.h>
#include <86box/pci.h>
#include <86box/device.h>
#include <86box/chipset.h>
#include <86box/hdc.h>
#include <86box/hdc_ide.h>
#include <86box/keyboard.h>
#include <86box/flash.h>
#include <86box/sio.h>
#include <86box/hwm.h>
#include <86box/spd.h>
#include <86box/video.h>
#include "cpu.h"
#include <86box/machine.h>
#include <86box/clock.h>
#include <86box/sound.h>
#include <86box/snd_ac97.h>
int
machine_at_s370slm_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/s370slm/3LM1202.rom",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 1, 2, 3, 4);
pci_register_slot(0x0F, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x10, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x12, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x14, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&i440lx_device);
device_add(&piix4e_device);
device_add(&w83977tf_device);
device_add(&keyboard_ps2_ami_pci_device);
device_add(&intel_flash_bxt_device);
spd_register(SPD_TYPE_SDRAM, 0x7, 256);
device_add(&w83781d_device); /* fans: CPU, Fan 2, Chassis; temperatures: unused, CPU, unused */
hwm_values.temperatures[0] = 0; /* unused */
hwm_values.temperatures[2] = 0; /* unused */
return ret;
}
int
machine_at_s1857_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/s1857/BX57200A.ROM",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 1, 2, 3, 4);
pci_register_slot(0x0F, PCI_CARD_SOUND, 1, 0, 0, 0);
pci_register_slot(0x10, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x11, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x12, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x13, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x14, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&i440bx_device);
device_add(&piix4e_device);
device_add(&keyboard_ps2_ami_pci_device);
device_add(&w83977ef_370_device);
device_add(&intel_flash_bxt_device);
spd_register(SPD_TYPE_SDRAM, 0x7, 256);
if (sound_card_current[0] == SOUND_INTERNAL) {
device_add(&es1371_onboard_device);
device_add(&cs4297_device); /* found on other Tyan boards around the same time */
}
return ret;
}
int
machine_at_p6bap_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/p6bap/bapa14a.BIN",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 0, 0, 3, 5);
pci_register_slot(0x09, PCI_CARD_NORMAL, 1, 2, 3, 5);
pci_register_slot(0x0a, PCI_CARD_NORMAL, 2, 3, 5, 1);
pci_register_slot(0x0b, PCI_CARD_NORMAL, 3, 5, 1, 2);
pci_register_slot(0x0c, PCI_CARD_NORMAL, 5, 1, 2, 3);
pci_register_slot(0x0d, PCI_CARD_NORMAL, 5, 3, 2, 1);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 5);
device_add(&via_apro133a_device); /* Rebranded as ET82C693A */
device_add(&via_vt82c596b_device); /* Rebranded as ET82C696B */
device_add(&w83977ef_device);
device_add(&keyboard_ps2_ami_pci_device);
device_add(&sst_flash_39sf020_device);
spd_register(SPD_TYPE_SDRAM, 0x7, 256);
return ret;
}
int
machine_at_p6bat_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/p6bat/bata+56.BIN",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 0, 0, 3, 5);
pci_register_slot(0x09, PCI_CARD_NORMAL, 1, 2, 3, 5);
pci_register_slot(0x0a, PCI_CARD_NORMAL, 2, 3, 5, 1);
pci_register_slot(0x0b, PCI_CARD_NORMAL, 3, 5, 1, 2);
pci_register_slot(0x0c, PCI_CARD_NORMAL, 5, 1, 2, 3);
pci_register_slot(0x0d, PCI_CARD_NORMAL, 5, 3, 2, 1);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 5);
device_add(&via_apro133_device);
device_add(&via_vt82c596b_device);
device_add(&w83977ef_device);
device_add(&keyboard_ps2_ami_pci_device);
device_add(&sst_flash_39sf020_device);
spd_register(SPD_TYPE_SDRAM, 0x7, 256);
if (sound_card_current[0] == SOUND_INTERNAL) {
device_add(&cmi8738_onboard_device);
}
return ret;
}
int
machine_at_cubx_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/cubx/1008cu.004",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x04, PCI_CARD_SOUTHBRIDGE, 1, 2, 3, 4);
pci_register_slot(0x07, PCI_CARD_IDE, 2, 3, 4, 1);
pci_register_slot(0x09, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x0A, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x0B, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x0C, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x0D, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x0E, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&i440bx_device);
device_add(&piix4e_device);
device_add(&keyboard_ps2_ami_pci_device);
device_add(&w83977ef_device);
device_add(ics9xxx_get(ICS9250_08));
device_add(&sst_flash_39sf020_device);
spd_register(SPD_TYPE_SDRAM, 0xF, 256);
device_add(&as99127f_device); /* fans: Chassis, CPU, Power; temperatures: MB, JTPWR, CPU */
return ret;
}
int
machine_at_atc7020bxii_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/atc7020bxii/7020s102.bin",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 1, 2, 3, 4);
pci_register_slot(0x0A, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x0B, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x0C, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x0D, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x0E, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&i440bx_device);
device_add(&slc90e66_device);
device_add(&keyboard_ps2_pci_device);
device_add(&w83977ef_device);
device_add(&sst_flash_39sf020_device);
spd_register(SPD_TYPE_SDRAM, 0xF, 256);
return ret;
}
int
machine_at_ambx133_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/ambx133/mkbx2vg2.bin",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 1, 2, 3, 4);
pci_register_slot(0x09, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x0A, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x0B, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x0C, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x0D, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&i440bx_device);
device_add(&piix4e_device);
device_add(&w83977ef_device);
device_add(&keyboard_ps2_ami_pci_device);
device_add(&sst_flash_39sf020_device);
spd_register(SPD_TYPE_SDRAM, 0x7, 256);
device_add(&gl518sm_2d_device); /* fans: CPUFAN1, CPUFAN2; temperature: CPU */
hwm_values.fans[1] += 500;
hwm_values.temperatures[0] += 4; /* CPU offset */
hwm_values.voltages[1] = RESISTOR_DIVIDER(12000, 10, 2); /* different 12V divider in BIOS (10K/2K?) */
return ret;
}
int
machine_at_awo671r_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/awo671r/a08139c.bin",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 1, 2, 3, 4);
pci_register_slot(0x09, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x0A, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x0B, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x0C, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x0D, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&i440bx_device);
device_add(&piix4e_device);
device_add_inst(&w83977ef_device, 1);
device_add_inst(&w83977ef_device, 2);
device_add(&keyboard_ps2_pci_device);
device_add(&sst_flash_39sf020_device);
spd_register(SPD_TYPE_SDRAM, 0x3, 256);
return ret;
}
int
machine_at_63a1_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/63a1/63a-q3.bin",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 1, 2, 3, 4);
pci_register_slot(0x08, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x09, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x0A, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x0B, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x0C, PCI_CARD_NORMAL, 1, 2, 3, 4); /* Integrated Sound? */
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&i440zx_device);
device_add(&piix4e_device);
device_add(&w83977tf_device);
device_add(&keyboard_ps2_ami_pci_device);
device_add(&intel_flash_bxt_device);
spd_register(SPD_TYPE_SDRAM, 0x3, 256);
return ret;
}
int
machine_at_apas3_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/apas3/V0218SAG.BIN",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 1, 2, 0, 0);
pci_register_slot(0x0F, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x10, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x13, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x14, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&via_apro_device);
device_add(&via_vt82c586b_device);
device_add(&fdc37c669_device);
device_add(&keyboard_ps2_ami_pci_device);
device_add(&sst_flash_39sf020_device);
spd_register(SPD_TYPE_SDRAM, 0x7, 256);
return ret;
}
int
machine_at_cuv4xls_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/cuv4xls/1005LS.001",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x04, PCI_CARD_SOUTHBRIDGE, 4, 1, 2, 3);
pci_register_slot(0x05, PCI_CARD_SOUND, 3, 0, 0, 0);
pci_register_slot(0x06, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x07, PCI_CARD_NORMAL, 2, 3, 0, 0);
pci_register_slot(0x08, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x09, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x0A, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x0B, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x14, PCI_CARD_NORMAL, 4, 0, 0, 0);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&via_apro133a_device);
device_add(&via_vt82c686b_device);
device_add(&keyboard_ps2_ami_pci_device);
device_add(ics9xxx_get(ICS9250_18));
device_add(&sst_flash_39sf020_device);
spd_register(SPD_TYPE_SDRAM, 0xF, 1024);
device_add(&as99127f_device); /* fans: Chassis, CPU, Power; temperatures: MB, JTPWR, CPU */
if (sound_card_current[0] == SOUND_INTERNAL)
device_add(&cmi8738_onboard_device);
return ret;
}
int
machine_at_6via90ap_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/6via90ap/90ap10.bin",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 1, 2, 3, 4);
pci_register_slot(0x09, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x0A, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x0B, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x0C, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x0D, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&via_apro133a_device);
device_add(&via_vt82c686b_device); /* fans: CPU1, CPU2; temperatures: CPU, System, unused */
device_add(&keyboard_ps2_ami_pci_device);
device_add(ics9xxx_get(ICS9250_18));
device_add(&sst_flash_39sf020_device);
spd_register(SPD_TYPE_SDRAM, 0x7, 1024);
hwm_values.temperatures[0] += 2; /* CPU offset */
hwm_values.temperatures[1] += 2; /* System offset */
hwm_values.temperatures[2] = 0; /* unused */
if (sound_card_current[0] == SOUND_INTERNAL)
device_add(&alc100_device); /* ALC100P identified on similar Acorp boards (694TA, 6VIA90A1) */
return ret;
}
/*
* 86Box A hypervisor and IBM PC system emulator that specializes in
* running old operating systems and software designed for IBM
* PC systems and compatibles from 1981 through fairly recent
* system designs based on the PCI bus.
*
* This file is part of the 86Box distribution.
*
* Implementation of Socket 370(PGA370) machines.
*
*
*
* Authors: Miran Grca, <mgrca8@gmail.com>
*
* Copyright 2016-2019 Miran Grca.
*/
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include <86box/86box.h>
#include <86box/mem.h>
#include <86box/io.h>
#include <86box/rom.h>
#include <86box/pci.h>
#include <86box/device.h>
#include <86box/chipset.h>
#include <86box/hdc.h>
#include <86box/hdc_ide.h>
#include <86box/keyboard.h>
#include <86box/flash.h>
#include <86box/sio.h>
#include <86box/hwm.h>
#include <86box/spd.h>
#include <86box/video.h>
#include "cpu.h"
#include <86box/machine.h>
#include <86box/clock.h>
#include <86box/sound.h>
#include <86box/snd_ac97.h>
int
machine_at_s370slm_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/s370slm/3LM1202.rom",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 1, 2, 3, 4);
pci_register_slot(0x0F, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x10, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x12, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x14, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&i440lx_device);
device_add(&piix4e_device);
device_add(&w83977tf_device);
device_add(&keyboard_ps2_ami_pci_device);
device_add(&intel_flash_bxt_device);
spd_register(SPD_TYPE_SDRAM, 0x7, 256);
device_add(&w83781d_device); /* fans: CPU, Fan 2, Chassis; temperatures: unused, CPU, unused */
hwm_values.temperatures[0] = 0; /* unused */
hwm_values.temperatures[2] = 0; /* unused */
return ret;
}
int
machine_at_s1857_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/s1857/BX57200A.ROM",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 1, 2, 3, 4);
pci_register_slot(0x0F, PCI_CARD_SOUND, 1, 0, 0, 0);
pci_register_slot(0x10, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x11, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x12, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x13, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x14, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&i440bx_device);
device_add(&piix4e_device);
device_add(&keyboard_ps2_ami_pci_device);
device_add(&w83977ef_370_device);
device_add(&intel_flash_bxt_device);
spd_register(SPD_TYPE_SDRAM, 0x7, 256);
if (sound_card_current[0] == SOUND_INTERNAL) {
device_add(&es1371_onboard_device);
device_add(&cs4297_device); /* found on other Tyan boards around the same time */
}
return ret;
}
int
machine_at_p6bap_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/p6bap/bapa14a.BIN",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 0, 0, 3, 5);
pci_register_slot(0x09, PCI_CARD_NORMAL, 1, 2, 3, 5);
pci_register_slot(0x0a, PCI_CARD_NORMAL, 2, 3, 5, 1);
pci_register_slot(0x0b, PCI_CARD_NORMAL, 3, 5, 1, 2);
pci_register_slot(0x0c, PCI_CARD_NORMAL, 5, 1, 2, 3);
pci_register_slot(0x0d, PCI_CARD_NORMAL, 5, 3, 2, 1);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 5);
device_add(&via_apro133a_device); /* Rebranded as ET82C693A */
device_add(&via_vt82c596b_device); /* Rebranded as ET82C696B */
device_add(&w83977ef_device);
device_add(&keyboard_ps2_ami_pci_device);
device_add(&sst_flash_39sf020_device);
spd_register(SPD_TYPE_SDRAM, 0x7, 256);
return ret;
}
int
machine_at_p6bat_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/p6bat/bata+56.BIN",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 0, 0, 3, 5);
pci_register_slot(0x09, PCI_CARD_NORMAL, 1, 2, 3, 5);
pci_register_slot(0x0a, PCI_CARD_NORMAL, 2, 3, 5, 1);
pci_register_slot(0x0b, PCI_CARD_NORMAL, 3, 5, 1, 2);
pci_register_slot(0x0c, PCI_CARD_NORMAL, 5, 1, 2, 3);
pci_register_slot(0x0d, PCI_CARD_NORMAL, 5, 3, 2, 1);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 5);
device_add(&via_apro133_device);
device_add(&via_vt82c596b_device);
device_add(&w83977ef_device);
device_add(&keyboard_ps2_ami_pci_device);
device_add(&sst_flash_39sf020_device);
spd_register(SPD_TYPE_SDRAM, 0x7, 256);
if (sound_card_current[0] == SOUND_INTERNAL) {
device_add(&cmi8738_onboard_device);
}
return ret;
}
int
machine_at_cubx_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/cubx/1008cu.004",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x04, PCI_CARD_SOUTHBRIDGE, 1, 2, 3, 4);
pci_register_slot(0x07, PCI_CARD_IDE, 2, 3, 4, 1);
pci_register_slot(0x09, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x0A, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x0B, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x0C, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x0D, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x0E, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&i440bx_device);
device_add(&piix4e_device);
device_add(&keyboard_ps2_ami_pci_device);
device_add(&w83977ef_device);
device_add(ics9xxx_get(ICS9250_08));
device_add(&sst_flash_39sf020_device);
spd_register(SPD_TYPE_SDRAM, 0xF, 256);
device_add(&as99127f_device); /* fans: Chassis, CPU, Power; temperatures: MB, JTPWR, CPU */
return ret;
}
int
machine_at_atc7020bxii_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/atc7020bxii/7020s102.bin",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 1, 2, 3, 4);
pci_register_slot(0x0A, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x0B, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x0C, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x0D, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x0E, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&i440bx_device);
device_add(&slc90e66_device);
device_add(&keyboard_ps2_pci_device);
device_add(&w83977ef_device);
device_add(&sst_flash_39sf020_device);
spd_register(SPD_TYPE_SDRAM, 0xF, 256);
return ret;
}
int
machine_at_ambx133_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/ambx133/mkbx2vg2.bin",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 1, 2, 3, 4);
pci_register_slot(0x09, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x0A, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x0B, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x0C, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x0D, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&i440bx_device);
device_add(&piix4e_device);
device_add(&w83977ef_device);
device_add(&keyboard_ps2_ami_pci_device);
device_add(&sst_flash_39sf020_device);
spd_register(SPD_TYPE_SDRAM, 0x7, 256);
device_add(&gl518sm_2d_device); /* fans: CPUFAN1, CPUFAN2; temperature: CPU */
hwm_values.fans[1] += 500;
hwm_values.temperatures[0] += 4; /* CPU offset */
hwm_values.voltages[1] = RESISTOR_DIVIDER(12000, 10, 2); /* different 12V divider in BIOS (10K/2K?) */
return ret;
}
int
machine_at_awo671r_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/awo671r/a08139c.bin",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 1, 2, 3, 4);
pci_register_slot(0x09, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x0A, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x0B, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x0C, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x0D, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&i440bx_device);
device_add(&piix4e_device);
device_add_inst(&w83977ef_device, 1);
device_add_inst(&w83977ef_device, 2);
device_add(&keyboard_ps2_pci_device);
device_add(&sst_flash_39sf020_device);
spd_register(SPD_TYPE_SDRAM, 0x3, 256);
return ret;
}
int
machine_at_63a1_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/63a1/63a-q3.bin",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 1, 2, 3, 4);
pci_register_slot(0x08, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x09, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x0A, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x0B, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x0C, PCI_CARD_NORMAL, 1, 2, 3, 4); /* Integrated Sound? */
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&i440zx_device);
device_add(&piix4e_device);
device_add(&w83977tf_device);
device_add(&keyboard_ps2_ami_pci_device);
device_add(&intel_flash_bxt_device);
spd_register(SPD_TYPE_SDRAM, 0x3, 256);
return ret;
}
int
machine_at_apas3_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/apas3/V0218SAG.BIN",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 1, 2, 0, 0);
pci_register_slot(0x0F, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x10, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x13, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x14, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&via_apro_device);
device_add(&via_vt82c586b_device);
device_add(&fdc37c669_device);
device_add(&keyboard_ps2_ami_pci_device);
device_add(&sst_flash_39sf020_device);
spd_register(SPD_TYPE_SDRAM, 0x7, 256);
return ret;
}
int
machine_at_cuv4xls_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/cuv4xls/1005LS.001",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x04, PCI_CARD_SOUTHBRIDGE, 4, 1, 2, 3);
pci_register_slot(0x05, PCI_CARD_SOUND, 3, 0, 0, 0);
pci_register_slot(0x06, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x07, PCI_CARD_NORMAL, 2, 3, 0, 0);
pci_register_slot(0x08, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x09, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x0A, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x0B, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x14, PCI_CARD_NORMAL, 4, 0, 0, 0);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&via_apro133a_device);
device_add(&via_vt82c686b_device);
device_add(&keyboard_ps2_ami_pci_device);
device_add(ics9xxx_get(ICS9250_18));
device_add(&sst_flash_39sf020_device);
spd_register(SPD_TYPE_SDRAM, 0xF, 1024);
device_add(&as99127f_device); /* fans: Chassis, CPU, Power; temperatures: MB, JTPWR, CPU */
if (sound_card_current[0] == SOUND_INTERNAL)
device_add(&cmi8738_onboard_device);
return ret;
}
int
machine_at_6via90ap_init(const machine_t *model)
{
int ret;
ret = bios_load_linear("roms/machines/6via90ap/90ap10.bin",
0x000c0000, 262144, 0);
if (bios_only || !ret)
return ret;
machine_at_common_init_ex(model, 2);
pci_init(PCI_CONFIG_TYPE_1);
pci_register_slot(0x00, PCI_CARD_NORTHBRIDGE, 0, 0, 0, 0);
pci_register_slot(0x07, PCI_CARD_SOUTHBRIDGE, 1, 2, 3, 4);
pci_register_slot(0x09, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x0A, PCI_CARD_NORMAL, 2, 3, 4, 1);
pci_register_slot(0x0B, PCI_CARD_NORMAL, 3, 4, 1, 2);
pci_register_slot(0x0C, PCI_CARD_NORMAL, 4, 1, 2, 3);
pci_register_slot(0x0D, PCI_CARD_NORMAL, 1, 2, 3, 4);
pci_register_slot(0x01, PCI_CARD_AGPBRIDGE, 1, 2, 3, 4);
device_add(&via_apro133a_device);
device_add(&via_vt82c686b_device); /* fans: CPU1, CPU2; temperatures: CPU, System, unused */
device_add(&keyboard_ps2_ami_pci_device);
device_add(ics9xxx_get(ICS9250_18));
device_add(&sst_flash_39sf020_device);
spd_register(SPD_TYPE_SDRAM, 0x7, 1024);
hwm_values.temperatures[0] += 2; /* CPU offset */
hwm_values.temperatures[1] += 2; /* System offset */
hwm_values.temperatures[2] = 0; /* unused */
if (sound_card_current[0] == SOUND_INTERNAL)
device_add(&alc100_device); /* ALC100P identified on similar Acorp boards (694TA, 6VIA90A1) */
return ret;
}

4
src/machine/m_elt.c
View File

@@ -124,9 +124,7 @@ elt_vid_out(uint16_t addr, uint8_t val, void *priv)
case 0x3d1:
if (cga->crtcreg >= 32)
return;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
default:
cga->crtcreg &= 31;

4
src/machine/m_ps1_hdc.c
View File

@@ -699,9 +699,7 @@ do_fmt:
/* Done with this track. */
dev->state = STATE_FDONE;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case STATE_FDONE:
/* One more track done. */
if (++start_cyl == end_cyl) {

4
src/network/net_ne2000.c
View File

@@ -759,9 +759,7 @@ nic_pci_write(UNUSED(int func), int addr, uint8_t val, void *priv)
case 0x10: /* PCI_BAR */
val &= 0xe0; /* 0xe0 acc to RTL DS */
val |= 0x01; /* re-enable IOIN bit */
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x11: /* PCI_BAR */
case 0x12: /* PCI_BAR */

5
src/network/net_wd8003.c
View File

@@ -735,9 +735,8 @@ wd_init(const device_t *info)
/* Ethernet, MCA, 5x3 interface chip, RAM 16k */
case WD8003EA:
dev->board_chip = WE_ID_SOFT_CONFIG;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
/* Ethernet, MCA, no interface chip, RAM 16k */
case WD8003ETA:
dev->board_chip |= WE_TYPE_WD8013EBT | WE_ID_BUS_MCA;

4
src/pci_dummy.c
View File

@@ -218,9 +218,7 @@ pci_dummy_pci_write(int func, int addr, uint8_t val, void *priv)
case 0x10: /* PCI_BAR */
val &= 0xe0; /* 0xe0 acc to RTL DS */
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x11: /* PCI_BAR */
/* Remove old I/O. */

4
src/printer/prt_escp.c
View File

@@ -1462,9 +1462,7 @@ process_char(escp_t *dev, uint8_t ch)
dev->curr_x = dev->left_margin;
if (!dev->autofeed)
return 1;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x0a: /* Line feed */
if (dev->font_style & STYLE_DOUBLEWIDTHONELINE) {

4
src/printer/prt_text.c
View File

@@ -283,9 +283,7 @@ process_char(prnt_t *dev, uint8_t ch)
dev->curr_x = 0;
if (!dev->autofeed)
return 1;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x0a: /* Line feed */
dev->curr_x = 0;

8
src/scsi/scsi_buslogic.c
View File

@@ -1232,9 +1232,7 @@ BuslogicPCIWrite(UNUSED(int func), int addr, uint8_t val, void *priv)
case 0x10:
val &= 0xe0;
val |= 1;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x11:
case 0x12:
@@ -1258,9 +1256,7 @@ BuslogicPCIWrite(UNUSED(int func), int addr, uint8_t val, void *priv)
case 0x14:
val &= 0xe0;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x15:
case 0x16:

12
src/scsi/scsi_cdrom.c
View File

@@ -883,9 +883,7 @@ scsi_cdrom_update_request_length(scsi_cdrom_t *dev, int len, int block_len)
break;
}
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
default:
dev->packet_len = len;
@@ -961,9 +959,7 @@ scsi_cdrom_command_common(scsi_cdrom_t *dev)
scsi_cdrom_log("CD-ROM %i: Seek period: %" PRIu64 " us\n",
dev->id, (uint64_t) period);
dev->callback += period;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x25:
case 0x42:
case 0x43:
@@ -1940,9 +1936,7 @@ begin:
/* IMPORTANT: Convert the command to new read CD
for pass through purposes. */
dev->current_cdb[0] = GPCMD_READ_CD;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case GPCMD_READ_6:
case GPCMD_READ_10:

4
src/scsi/scsi_disk.c
View File

@@ -597,9 +597,7 @@ scsi_disk_command(scsi_common_t *sc, uint8_t *cdb)
scsi_disk_invalid_field(dev);
return;
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case GPCMD_SCSI_RESERVE:
case GPCMD_SCSI_RELEASE:
case GPCMD_TEST_UNIT_READY:

4
src/scsi/scsi_pcscsi.c
View File

@@ -1030,9 +1030,7 @@ esp_reg_write(esp_t *dev, uint32_t saddr, uint32_t val)
switch (saddr) {
case ESP_TCHI:
dev->tchi_written = 1;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case ESP_TCLO:
case ESP_TCMID:
esp_log("Transfer count regs %02x = %i\n", saddr, val);

4
src/scsi/scsi_x54x.c
View File

@@ -490,9 +490,7 @@ x54x_bios_command(x54x_t *x54x, uint8_t max_id, BIOSCMD *cmd, int8_t islba)
default:
x54x_log("BIOS: Unimplemented command: %02X\n", cmd->command);
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x05: /* Format Track, invalid since SCSI has no tracks */
case 0x0a: /* ???? */
case 0x0b: /* ???? */

4
src/sound/snd_ac97_codec.c
View File

@@ -418,9 +418,7 @@ rate: /* Writable only if VRA/VRM is set. */
/* Get actual previous value. */
prev = dev->vendor_reg_pages[(i << 3) | ((reg & 0x0e) >> 1)];
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x5a ... 0x5e: /* Vendor Reserved */
case 0x70 ... 0x7a:

4
src/sound/snd_ad1848.c
View File

@@ -242,9 +242,7 @@ ad1848_write(uint16_t addr, uint8_t val, void *priv)
case 10:
if (ad1848->type < AD1848_TYPE_CS4235)
break;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 8:
updatefreq = 1;

4
src/sound/snd_cmi8x38.c
View File

@@ -469,9 +469,7 @@ cmi8x38_sb_mixer_write(uint16_t addr, uint8_t val, void *priv)
case 0xf8 ... 0xff:
if (dev->type == CMEDIA_CMI8338)
mixer->regs[mixer->index] = val;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0xf1 ... 0xf7:
return;

4
src/sound/snd_cs423x.c
View File

@@ -300,9 +300,7 @@ cs423x_write(uint16_t addr, uint8_t val, void *priv)
switch (val) {
case 0x55: /* Disable PnP Key */
dev->pnp_enable = 0;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x5a: /* Update Hardware Configuration Data */
cs423x_pnp_enable(dev, 0, 1);

4
src/sound/snd_gus.c
View File

@@ -643,9 +643,7 @@ writegus(uint16_t addr, uint8_t val, void *priv)
else if (gus->irq != -1)
picint(1 << gus->irq);
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x20d:
gus->sb_2xc = val;
break;

4
src/sound/snd_sb_dsp.c
View File

@@ -601,9 +601,7 @@ sb_exec_command(sb_dsp_t *dsp)
case 0x75: /* 4-bit ADPCM output with reference */
dsp->sbref = dsp->dma_readb(dsp->dma_priv);
dsp->sbstep = 0;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x74: /* 4-bit ADPCM output */
sb_start_dma(dsp, 1, 0, ADPCM_4, dsp->sb_data[0] + (dsp->sb_data[1] << 8));
dsp->sbdat2 = dsp->dma_readb(dsp->dma_priv);

4
src/video/vid_8514a.c
View File

@@ -536,9 +536,7 @@ ibm8514_accel_out_fifo(svga_t *svga, uint16_t port, uint32_t val, int len)
case 0x92e8:
if (len != 1)
dev->test = val;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0xd2e8:
if (len == 1)
dev->accel.err_term = (dev->accel.err_term & 0x3f00) | val;

32
src/video/vid_ati68860_ramdac.c
View File

@@ -65,9 +65,9 @@ typedef struct ati68860_ramdac_t {
} ati68860_ramdac_t;
void
ati68860_ramdac_out(uint16_t addr, uint8_t val, void *p, svga_t *svga)
ati68860_ramdac_out(uint16_t addr, uint8_t val, void *priv, svga_t *svga)
{
ati68860_ramdac_t *ramdac = (ati68860_ramdac_t *) p;
ati68860_ramdac_t *ramdac = (ati68860_ramdac_t *) priv;
switch (addr) {
case 0:
@@ -168,10 +168,10 @@ ati68860_ramdac_out(uint16_t addr, uint8_t val, void *p, svga_t *svga)
}
uint8_t
ati68860_ramdac_in(uint16_t addr, void *p, svga_t *svga)
ati68860_ramdac_in(uint16_t addr, void *priv, svga_t *svga)
{
ati68860_ramdac_t *ramdac = (ati68860_ramdac_t *) p;
uint8_t temp = 0;
const ati68860_ramdac_t *ramdac = (ati68860_ramdac_t *) priv;
uint8_t temp = 0;
switch (addr) {
case 0:
@@ -207,9 +207,9 @@ ati68860_ramdac_in(uint16_t addr, void *p, svga_t *svga)
}
void
ati68860_set_ramdac_type(void *p, int type)
ati68860_set_ramdac_type(void *priv, int type)
{
ati68860_ramdac_t *ramdac = (ati68860_ramdac_t *) p;
ati68860_ramdac_t *ramdac = (ati68860_ramdac_t *) priv;
if (ramdac->ramdac_type != type) {
ramdac->ramdac_type = type;
@@ -237,17 +237,17 @@ ati68860_ramdac_init(UNUSED(const device_t *info))
}
void
ati68860_ramdac_set_render(void *p, svga_t *svga)
ati68860_ramdac_set_render(void *priv, svga_t *svga)
{
ati68860_ramdac_t *ramdac = (ati68860_ramdac_t *) p;
ati68860_ramdac_t *ramdac = (ati68860_ramdac_t *) priv;
svga->render = ramdac->render;
}
void
ati68860_ramdac_set_pallook(void *p, int i, uint32_t col)
ati68860_ramdac_set_pallook(void *priv, int i, uint32_t col)
{
ati68860_ramdac_t *ramdac = (ati68860_ramdac_t *) p;
ati68860_ramdac_t *ramdac = (ati68860_ramdac_t *) priv;
ramdac->pallook[i] = col;
}
@@ -255,11 +255,11 @@ ati68860_ramdac_set_pallook(void *p, int i, uint32_t col)
void
ati68860_hwcursor_draw(svga_t *svga, int displine)
{
ati68860_ramdac_t *ramdac = (ati68860_ramdac_t *) svga->ramdac;
int offset;
uint8_t dat;
uint32_t col0 = ramdac->pallook[0];
uint32_t col1 = ramdac->pallook[1];
const ati68860_ramdac_t *ramdac = (ati68860_ramdac_t *) svga->ramdac;
int offset;
uint8_t dat;
uint32_t col0 = ramdac->pallook[0];
uint32_t col1 = ramdac->pallook[1];
offset = svga->dac_hwcursor_latch.xoff;
for (uint32_t x = 0; x < 64 - svga->dac_hwcursor_latch.xoff; x += 4) {

4
src/video/vid_ati_eeprom.c
View File

@@ -94,9 +94,7 @@ ati_eeprom_write(ati_eeprom_t *eeprom, int ena, int clk, int dat)
if (!dat)
break;
eeprom->state = EEPROM_OPCODE;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case EEPROM_OPCODE:
eeprom->opcode = (eeprom->opcode << 1) | (dat ? 1 : 0);
eeprom->count--;

12
src/video/vid_ati_mach64.c
View File

@@ -740,9 +740,7 @@ mach64_accel_write_fifo(mach64_t *mach64, uint32_t addr, uint8_t val)
case 0x11e:
case 0x11f:
WRITE8(addr, mach64->dst_height_width, val);
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x113:
if (((addr & 0x3ff) == 0x11b || (addr & 0x3ff) == 0x11f || (addr & 0x3ff) == 0x113) && !(val & 0x80)) {
mach64_start_fill(mach64);
@@ -965,9 +963,7 @@ mach64_accel_write_fifo(mach64_t *mach64, uint32_t addr, uint8_t val)
case 0x2a4:
case 0x2a5:
addr += 2;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x2aa:
case 0x2ab:
WRITE8(addr, mach64->sc_left_right, val);
@@ -982,9 +978,7 @@ mach64_accel_write_fifo(mach64_t *mach64, uint32_t addr, uint8_t val)
case 0x2b0:
case 0x2b1:
addr += 2;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x2b6:
case 0x2b7:
WRITE8(addr, mach64->sc_top_bottom, val);

5
src/video/vid_ati_mach8.c
View File

@@ -2861,9 +2861,8 @@ mach_accel_out_fifo(mach_t *mach, svga_t *svga, ibm8514_t *dev, uint16_t port, u
case 0x92e8:
if (len != 1)
dev->test = val;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0xd2e8:
mach_log("92E8 = %04x\n", val);
if (len == 1)

15
src/video/vid_att20c49x_ramdac.c
View File

@@ -28,8 +28,7 @@
#include <86box/video.h>
#include <86box/vid_svga.h>
typedef struct
{
typedef struct att49x_ramdac_t {
int type;
int state;
uint8_t ctrl;
@@ -42,9 +41,9 @@ enum {
};
static void
att49x_ramdac_control(uint8_t val, void *p, svga_t *svga)
att49x_ramdac_control(uint8_t val, void *priv, svga_t *svga)
{
att49x_ramdac_t *ramdac = (att49x_ramdac_t *) p;
att49x_ramdac_t *ramdac = (att49x_ramdac_t *) priv;
ramdac->ctrl = val;
switch ((ramdac->ctrl >> 5) & 7) {
case 0:
@@ -73,9 +72,9 @@ att49x_ramdac_control(uint8_t val, void *p, svga_t *svga)
}
void
att49x_ramdac_out(uint16_t addr, int rs2, uint8_t val, void *p, svga_t *svga)
att49x_ramdac_out(uint16_t addr, int rs2, uint8_t val, void *priv, svga_t *svga)
{
att49x_ramdac_t *ramdac = (att49x_ramdac_t *) p;
att49x_ramdac_t *ramdac = (att49x_ramdac_t *) priv;
uint8_t rs = (addr & 0x03);
rs |= ((!!rs2) << 2);
@@ -110,9 +109,9 @@ att49x_ramdac_out(uint16_t addr, int rs2, uint8_t val, void *p, svga_t *svga)
}
uint8_t
att49x_ramdac_in(uint16_t addr, int rs2, void *p, svga_t *svga)
att49x_ramdac_in(uint16_t addr, int rs2, void *priv, svga_t *svga)
{
att49x_ramdac_t *ramdac = (att49x_ramdac_t *) p;
att49x_ramdac_t *ramdac = (att49x_ramdac_t *) priv;
uint8_t temp = 0xff;
uint8_t rs = (addr & 0x03);
rs |= ((!!rs2) << 2);

15
src/video/vid_att2xc498_ramdac.c
View File

@@ -28,8 +28,7 @@
#include <86box/video.h>
#include <86box/vid_svga.h>
typedef struct
{
typedef struct att498_ramdac_t {
int type;
int state;
int loop;
@@ -37,9 +36,9 @@ typedef struct
} att498_ramdac_t;
static void
att498_ramdac_control(uint8_t val, void *p, svga_t *svga)
att498_ramdac_control(uint8_t val, void *priv, svga_t *svga)
{
att498_ramdac_t *ramdac = (att498_ramdac_t *) p;
att498_ramdac_t *ramdac = (att498_ramdac_t *) priv;
ramdac->ctrl = val;
if (val == 0xff)
@@ -73,9 +72,9 @@ att498_ramdac_control(uint8_t val, void *p, svga_t *svga)
}
void
att498_ramdac_out(uint16_t addr, int rs2, uint8_t val, void *p, svga_t *svga)
att498_ramdac_out(uint16_t addr, int rs2, uint8_t val, void *priv, svga_t *svga)
{
att498_ramdac_t *ramdac = (att498_ramdac_t *) p;
att498_ramdac_t *ramdac = (att498_ramdac_t *) priv;
uint8_t rs = (addr & 0x03);
rs |= ((!!rs2) << 2);
@@ -109,9 +108,9 @@ att498_ramdac_out(uint16_t addr, int rs2, uint8_t val, void *p, svga_t *svga)
}
uint8_t
att498_ramdac_in(uint16_t addr, int rs2, void *p, svga_t *svga)
att498_ramdac_in(uint16_t addr, int rs2, void *priv, svga_t *svga)
{
att498_ramdac_t *ramdac = (att498_ramdac_t *) p;
att498_ramdac_t *ramdac = (att498_ramdac_t *) priv;
uint8_t temp = 0xff;
uint8_t rs = (addr & 0x03);
rs |= ((!!rs2) << 2);

22
src/video/vid_bt48x_ramdac.c
View File

@@ -29,13 +29,13 @@
#include <86box/video.h>
#include <86box/vid_svga.h>
typedef struct
{
typedef struct bt48x_ramdac_t {
PALETTE extpal;
uint32_t extpallook[256];
uint8_t cursor32_data[256];
uint8_t cursor64_data[1024];
int hwc_y, hwc_x;
int hwc_y;
int hwc_x;
uint8_t cmd_r0;
uint8_t cmd_r1;
uint8_t cmd_r2;
@@ -85,9 +85,9 @@ bt48x_set_bpp(bt48x_ramdac_t *ramdac, svga_t *svga)
}
void
bt48x_ramdac_out(uint16_t addr, int rs2, int rs3, uint8_t val, void *p, svga_t *svga)
bt48x_ramdac_out(uint16_t addr, int rs2, int rs3, uint8_t val, void *priv, svga_t *svga)
{
bt48x_ramdac_t *ramdac = (bt48x_ramdac_t *) p;
bt48x_ramdac_t *ramdac = (bt48x_ramdac_t *) priv;
uint32_t o32;
uint8_t *cd;
uint16_t index;
@@ -233,11 +233,11 @@ bt48x_ramdac_out(uint16_t addr, int rs2, int rs3, uint8_t val, void *p, svga_t *
}
uint8_t
bt48x_ramdac_in(uint16_t addr, int rs2, int rs3, void *p, svga_t *svga)
bt48x_ramdac_in(uint16_t addr, int rs2, int rs3, void *priv, svga_t *svga)
{
bt48x_ramdac_t *ramdac = (bt48x_ramdac_t *) p;
bt48x_ramdac_t *ramdac = (bt48x_ramdac_t *) priv;
uint8_t temp = 0xff;
uint8_t *cd;
const uint8_t *cd;
uint16_t index;
uint8_t rs = (addr & 0x03);
uint16_t da_mask = 0x03ff;
@@ -360,9 +360,9 @@ bt48x_ramdac_in(uint16_t addr, int rs2, int rs3, void *p, svga_t *svga)
}
void
bt48x_recalctimings(void *p, svga_t *svga)
bt48x_recalctimings(void *priv, svga_t *svga)
{
bt48x_ramdac_t *ramdac = (bt48x_ramdac_t *) p;
const bt48x_ramdac_t *ramdac = (bt48x_ramdac_t *) priv;
svga->interlace = ramdac->cmd_r2 & 0x08;
if (ramdac->cmd_r3 & 0x08)
@@ -386,7 +386,7 @@ bt48x_hwcursor_draw(svga_t *svga, int displine)
uint32_t clr2;
uint32_t clr3;
uint32_t *p;
uint8_t *cd;
const uint8_t *cd;
bt48x_ramdac_t *ramdac = (bt48x_ramdac_t *) svga->ramdac;
clr1 = ramdac->extpallook[1];

323
src/video/vid_cl54xx.c
View File

@@ -39,6 +39,8 @@
#include <86box/vid_ddc.h>
#include <86box/vid_svga.h>
#include <86box/vid_svga_render.h>
#include <86box/plat_fallthrough.h>
#include <86box/plat_unused.h>
#define BIOS_GD5401_PATH "roms/video/cirruslogic/avga1.rom"
#define BIOS_GD5402_PATH "roms/video/cirruslogic/avga2.rom"
@@ -158,8 +160,9 @@ typedef struct gd54xx_t {
svga_t svga;
int has_bios, rev,
bit32;
int has_bios;
int rev;
int bit32;
rom_t bios_rom;
uint32_t vram_size;
@@ -174,45 +177,76 @@ typedef struct gd54xx_t {
} ramdac;
struct {
uint16_t width, height;
uint16_t dst_pitch, src_pitch;
uint16_t trans_col, trans_mask;
uint16_t width;
uint16_t height;
uint16_t dst_pitch;
uint16_t src_pitch;
uint16_t trans_col;
uint16_t trans_mask;
uint16_t height_internal;
uint16_t msd_buf_pos, msd_buf_cnt;
uint16_t msd_buf_pos;
uint16_t msd_buf_cnt;
uint8_t status;
uint8_t mask, mode, rop, modeext;
uint8_t ms_is_dest, msd_buf[32];
uint8_t mask;
uint8_t mode;
uint8_t rop;
uint8_t modeext;
uint8_t ms_is_dest;
uint8_t msd_buf[32];
uint32_t fg_col, bg_col;
uint32_t dst_addr_backup, src_addr_backup;
uint32_t dst_addr, src_addr;
uint32_t sys_src32, sys_cnt;
uint32_t fg_col;
uint32_t bg_col;
uint32_t dst_addr_backup;
uint32_t src_addr_backup;
uint32_t dst_addr;
uint32_t src_addr;
uint32_t sys_src32;
uint32_t sys_cnt;
/* Internal state */
int pixel_width, pattern_x;
int x_count, y_count;
int xx_count, dir;
int pixel_width;
int pattern_x;
int x_count;
int y_count;
int xx_count;
int dir;
int unlock_special;
} blt;
struct {
int mode;
uint16_t stride, r1sz, r1adjust, r2sz,
r2adjust, r2sdz, wvs, wve,
hzoom, vzoom;
uint8_t occlusion, colorkeycomparemask,
colorkeycompare;
int region1size, region2size,
colorkeymode;
uint16_t stride;
uint16_t r1sz;
uint16_t r1adjust;
uint16_t r2sz;
uint16_t r2adjust;
uint16_t r2sdz;
uint16_t wvs;
uint16_t wve;
uint16_t hzoom;
uint16_t vzoom;
uint8_t occlusion;
uint8_t colorkeycomparemask;
uint8_t colorkeycompare;
int region1size;
int region2size;
int colorkeymode;
uint32_t ck;
} overlay;
int pci, vlb, mca, countminusone;
int vblank_irq, vportsync;
int pci;
int vlb;
int mca;
int countminusone;
int vblank_irq;
int vportsync;
uint8_t pci_regs[256];
uint8_t int_line, unlocked, status, extensions;
uint8_t int_line;
uint8_t unlocked;
uint8_t status;
uint8_t extensions;
uint8_t crtcreg_mask;
uint8_t fc; /* Feature Connector */
@@ -224,14 +258,16 @@ typedef struct gd54xx_t {
uint8_t pos_regs[8];
uint32_t lfb_base, vgablt_base;
uint32_t lfb_base;
uint32_t vgablt_base;
int mmio_vram_overlap;
uint32_t extpallook[256];
PALETTE extpal;
void *i2c, *ddc;
void *i2c;
void *ddc;
} gd54xx_t;
static video_timings_t timing_gd54xx_isa = { .type = VIDEO_ISA, .write_b = 3, .write_w = 3, .write_l = 6, .read_b = 8, .read_w = 8, .read_l = 12 };
@@ -515,23 +551,23 @@ gd54xx_is_5422(svga_t *svga)
static void
gd54xx_overlay_draw(svga_t *svga, int displine)
{
gd54xx_t *gd54xx = (gd54xx_t *) svga->priv;
int shift = (svga->crtc[0x27] >= CIRRUS_ID_CLGD5446) ? 2 : 0;
int h_acc = svga->overlay_latch.h_acc;
int r[8];
int g[8];
int b[8];
int x_read = 4;
int x_write = 4;
uint32_t *p;
uint8_t *src = &svga->vram[(svga->overlay_latch.addr << shift) & svga->vram_mask];
int bpp = svga->bpp;
int bytesperpix = (bpp + 7) / 8;
uint8_t *src2 = &svga->vram[(svga->ma - (svga->hdisp * bytesperpix)) & svga->vram_display_mask];
int occl;
int ckval;
const gd54xx_t *gd54xx = (gd54xx_t *) svga->priv;
int shift = (svga->crtc[0x27] >= CIRRUS_ID_CLGD5446) ? 2 : 0;
int h_acc = svga->overlay_latch.h_acc;
int r[8];
int g[8];
int b[8];
int x_read = 4;
int x_write = 4;
uint32_t *p;
uint8_t *src = &svga->vram[(svga->overlay_latch.addr << shift) & svga->vram_mask];
int bpp = svga->bpp;
int bytesperpix = (bpp + 7) / 8;
uint8_t *src2 = &svga->vram[(svga->ma - (svga->hdisp * bytesperpix)) & svga->vram_display_mask];
int occl;
int ckval;
p = &((uint32_t *) svga->monitor->target_buffer->line[displine])[gd54xx->overlay.region1size + svga->x_add];
p = &(svga->monitor->target_buffer->line[displine])[gd54xx->overlay.region1size + svga->x_add];
src2 += gd54xx->overlay.region1size * bytesperpix;
OVERLAY_SAMPLE();
@@ -771,6 +807,9 @@ gd54xx_out(uint16_t addr, uint8_t val, void *priv)
else
return;
break;
default:
break;
}
return;
}
@@ -826,6 +865,9 @@ gd54xx_out(uint16_t addr, uint8_t val, void *priv)
svga->dac_addr = (svga->dac_addr + 1) & 255;
svga->dac_pos = 0;
break;
default:
break;
}
return;
case 0x3ce:
@@ -872,6 +914,9 @@ gd54xx_out(uint16_t addr, uint8_t val, void *priv)
case 7:
svga->colournocare = val;
break;
default:
break;
}
if ((svga->crtc[0x27] == CIRRUS_ID_CLGD5422) || (svga->crtc[0x27] == CIRRUS_ID_CLGD5424))
@@ -908,6 +953,7 @@ gd54xx_out(uint16_t addr, uint8_t val, void *priv)
}
svga->seqregs[2] &= 0x0f;
}
fallthrough;
case 0x09:
case 0x0a:
gd54xx_recalc_banking(gd54xx);
@@ -1027,6 +1073,9 @@ gd54xx_out(uint16_t addr, uint8_t val, void *priv)
case 0x39:
gd543x_mmio_write(0xb8021, val, gd54xx);
break;
default:
break;
}
}
return;
@@ -1142,6 +1191,9 @@ gd54xx_out(uint16_t addr, uint8_t val, void *priv)
svga->overlay.ena = (val & 1) != 0;
gd54xx_update_overlay(gd54xx);
break;
default:
break;
}
if (svga->crtcreg < 0xe || svga->crtcreg > 0x10) {
@@ -1155,6 +1207,9 @@ gd54xx_out(uint16_t addr, uint8_t val, void *priv)
}
}
break;
default:
break;
}
svga_out(addr, val, svga);
}
@@ -1225,6 +1280,9 @@ gd54xx_in(uint16_t addr, void *priv)
case 2048:
ret |= 0x18;
break;
default:
break;
}
}
break;
@@ -1249,6 +1307,9 @@ gd54xx_in(uint16_t addr, void *priv)
case 4096:
ret |= 0x98; /*64-bit (5434 and up) DRAM data bus width for 4M of memory*/
break;
default:
break;
}
break;
case 0x15: /*Scratch Pad 3 (Memory size for 543x)*/
@@ -1264,6 +1325,9 @@ gd54xx_in(uint16_t addr, void *priv)
case 4:
ret |= 0x04;
break;
default:
break;
}
}
break;
@@ -1301,6 +1365,9 @@ gd54xx_in(uint16_t addr, void *priv)
case 0x1e:
ret = gd54xx->vclk_d[svga->seqaddr - 0x1b];
break;
default:
break;
}
break;
} else
@@ -1356,6 +1423,9 @@ gd54xx_in(uint16_t addr, void *priv)
else
ret = svga->vgapal[index].b & 0x3f;
break;
default:
break;
}
break;
case 0x3ce:
@@ -1473,6 +1543,9 @@ gd54xx_in(uint16_t addr, void *priv)
gd54xx->vportsync = !gd54xx->vportsync;
ret = gd54xx->vportsync ? 0x80 : 0x00;
break;
default:
break;
}
} else {
if ((svga->gdcaddr < 2) && !gd54xx->unlocked)
@@ -1513,6 +1586,9 @@ gd54xx_in(uint16_t addr, void *priv)
if ((svga->crtc[0x27] == CIRRUS_ID_CLGD5430) || (svga->crtc[0x27] == CIRRUS_ID_CLGD5440))
ret = 0xff; /*Standard CL-GD5430/40*/
break;
default:
break;
}
break;
default:
@@ -1590,6 +1666,9 @@ gd543x_recalc_mapping(gd54xx_t *gd54xx)
svga->banked_mask = 0x7fff;
gd54xx->mmio_vram_overlap = 1;
break;
default:
break;
}
if ((svga->seqregs[0x17] & CIRRUS_MMIO_ENABLE) && (svga->seqregs[0x07] & 0x01) && (svga->crtc[0x27] >= CIRRUS_ID_CLGD5429)) {
@@ -1611,9 +1690,11 @@ gd543x_recalc_mapping(gd54xx_t *gd54xx)
}
} else if (gd54xx->pci) {
base = gd54xx->lfb_base;
/* if (svga->crtc[0x27] == CIRRUS_ID_CLGD5480)
size = 32 * 1024 * 1024;
else */
#if 0
if (svga->crtc[0x27] == CIRRUS_ID_CLGD5480)
size = 32 * 1024 * 1024;
else
#endif
if (svga->crtc[0x27] >= CIRRUS_ID_CLGD5436)
size = 16 * 1024 * 1024;
else
@@ -1649,10 +1730,10 @@ gd543x_recalc_mapping(gd54xx_t *gd54xx)
static void
gd54xx_recalctimings(svga_t *svga)
{
gd54xx_t *gd54xx = (gd54xx_t *) svga->priv;
uint8_t clocksel;
uint8_t rdmask;
uint8_t linedbl = svga->dispend * 9 / 10 >= svga->hdisp;
const gd54xx_t *gd54xx = (gd54xx_t *) svga->priv;
uint8_t clocksel;
uint8_t rdmask;
uint8_t linedbl = svga->dispend * 9 / 10 >= svga->hdisp;
svga->rowoffset = (svga->crtc[0x13]) | (((int) (uint32_t) (svga->crtc[0x1b] & 0x10)) << 4);
@@ -1788,8 +1869,14 @@ gd54xx_recalctimings(svga_t *svga)
else
svga->render = svga_render_8bpp_highres;
break;
default:
break;
}
break;
default:
break;
}
} else {
svga->bpp = 15;
@@ -1812,18 +1899,21 @@ gd54xx_recalctimings(svga_t *svga)
if (!gd54xx->vclk_n[clocksel] || !gd54xx->vclk_d[clocksel])
svga->clock = (cpuclock * (float) (1ULL << 32)) / ((svga->miscout & 0xc) ? 28322000.0 : 25175000.0);
else {
int n = gd54xx->vclk_n[clocksel] & 0x7f;
int d = (gd54xx->vclk_d[clocksel] & 0x3e) >> 1;
int m = gd54xx->vclk_d[clocksel] & 0x01 ? 2 : 1;
float freq = (14318184.0 * ((float) n / ((float) d * m)));
int n = gd54xx->vclk_n[clocksel] & 0x7f;
int d = (gd54xx->vclk_d[clocksel] & 0x3e) >> 1;
uint8_t m = gd54xx->vclk_d[clocksel] & 0x01 ? 2 : 1;
float freq = (14318184.0F * ((float) n / ((float) d * m)));
if (gd54xx_is_5422(svga)) {
switch (svga->seqregs[7] & (gd54xx_is_5434(svga) ? 0xe : 6)) {
case 2:
freq /= 2.0;
freq /= 2.0F;
break;
case 4:
if (!gd54xx_is_5434(svga))
freq /= 3.0;
freq /= 3.0F;
break;
default:
break;
}
}
@@ -1836,16 +1926,16 @@ gd54xx_recalctimings(svga_t *svga)
static void
gd54xx_hwcursor_draw(svga_t *svga, int displine)
{
gd54xx_t *gd54xx = (gd54xx_t *) svga->priv;
int comb;
int b0;
int b1;
uint8_t dat[2];
int offset = svga->hwcursor_latch.x - svga->hwcursor_latch.xoff;
int pitch = (svga->hwcursor.cur_xsize == 64) ? 16 : 4;
uint32_t bgcol = gd54xx->extpallook[0x00];
uint32_t fgcol = gd54xx->extpallook[0x0f];
uint8_t linedbl = svga->dispend * 9 / 10 >= svga->hdisp;
const gd54xx_t *gd54xx = (gd54xx_t *) svga->priv;
int comb;
int b0;
int b1;
uint8_t dat[2];
int offset = svga->hwcursor_latch.x - svga->hwcursor_latch.xoff;
int pitch = (svga->hwcursor.cur_xsize == 64) ? 16 : 4;
uint32_t bgcol = gd54xx->extpallook[0x00];
uint32_t fgcol = gd54xx->extpallook[0x0f];
uint8_t linedbl = svga->dispend * 9 / 10 >= svga->hdisp;
offset <<= linedbl;
@@ -1869,16 +1959,19 @@ gd54xx_hwcursor_draw(svga_t *svga, int displine)
break;
case 1:
/* The pixel is shown in the cursor background color */
((uint32_t *) svga->monitor->target_buffer->line[displine])[offset + svga->x_add] = bgcol;
(svga->monitor->target_buffer->line[displine])[offset + svga->x_add] = bgcol;
break;
case 2:
/* The pixel is shown as the inverse of the original screen pixel
(XOR cursor) */
((uint32_t *) svga->monitor->target_buffer->line[displine])[offset + svga->x_add] ^= 0xffffff;
(svga->monitor->target_buffer->line[displine])[offset + svga->x_add] ^= 0xffffff;
break;
case 3:
/* The pixel is shown in the cursor foreground color */
((uint32_t *) svga->monitor->target_buffer->line[displine])[offset + svga->x_add] = fgcol;
(svga->monitor->target_buffer->line[displine])[offset + svga->x_add] = fgcol;
break;
default:
break;
}
}
@@ -1947,6 +2040,9 @@ gd54xx_rop(gd54xx_t *gd54xx, uint8_t *res, uint8_t *dst, const uint8_t *src)
case 0xda:
*res = ~(*src & *dst);
break;
default:
break;
}
}
@@ -2120,6 +2216,9 @@ gd54xx_write_modes45(svga_t *svga, uint8_t val, uint32_t addr)
}
}
break;
default:
break;
}
svga->changedvram[addr >> 12] = changeframecount;
@@ -2135,7 +2234,7 @@ gd54xx_get_aperture(uint32_t addr)
static int
gd54xx_aperture2_enabled(gd54xx_t *gd54xx)
{
svga_t *svga = &gd54xx->svga;
const svga_t *svga = &gd54xx->svga;
if (svga->crtc[0x27] < CIRRUS_ID_CLGD5436)
return 0;
@@ -2171,8 +2270,8 @@ gd54xx_readb_linear(uint32_t addr, void *priv)
return gd54xx_mem_sys_dest_read(gd54xx);
switch (ap) {
case 0:
default:
case 0:
break;
case 1:
/* 0 -> 1, 1 -> 0, 2 -> 3, 3 -> 2 */
@@ -2218,12 +2317,13 @@ gd54xx_readw_linear(uint32_t addr, void *priv)
}
switch (ap) {
case 0:
default:
case 0:
return svga_readw_linear(addr, svga);
case 2:
/* 0 -> 3, 1 -> 2, 2 -> 1, 3 -> 0 */
addr ^= 0x00000002;
fallthrough;
case 1:
temp = svga_readb_linear(addr + 1, svga);
temp |= (svga_readb_linear(addr, svga) << 8);
@@ -2268,8 +2368,8 @@ gd54xx_readl_linear(uint32_t addr, void *priv)
}
switch (ap) {
case 0:
default:
case 0:
return svga_readl_linear(addr, svga);
case 1:
temp = svga_readb_linear(addr + 1, svga);
@@ -2297,7 +2397,7 @@ gd54xx_readl_linear(uint32_t addr, void *priv)
}
static uint8_t
gd5436_aperture2_readb(uint32_t addr, void *priv)
gd5436_aperture2_readb(UNUSED(uint32_t addr), void *priv)
{
gd54xx_t *gd54xx = (gd54xx_t *) priv;
@@ -2340,7 +2440,7 @@ gd5436_aperture2_readl(uint32_t addr, void *priv)
}
static void
gd5436_aperture2_writeb(uint32_t addr, uint8_t val, void *priv)
gd5436_aperture2_writeb(UNUSED(uint32_t addr), uint8_t val, void *priv)
{
gd54xx_t *gd54xx = (gd54xx_t *) priv;
@@ -2453,8 +2553,8 @@ gd54xx_writew_linear(uint32_t addr, uint16_t val, void *priv)
if (svga->writemode < 4) {
switch (ap) {
case 0:
default:
case 0:
svga_writew_linear(addr, val, svga);
return;
case 2:
@@ -2465,21 +2565,24 @@ gd54xx_writew_linear(uint32_t addr, uint16_t val, void *priv)
if (svga->fast)
cycles -= svga->monitor->mon_video_timing_write_w;
return;
case 3:
return;
}
} else {
switch (ap) {
case 0:
default:
case 0:
svga_write_linear(addr, val & 0xff, svga);
svga_write_linear(addr + 1, val >> 8, svga);
return;
case 2:
addr ^= 0x00000002;
fallthrough;
case 1:
svga_write_linear(addr + 1, val & 0xff, svga);
svga_write_linear(addr, val >> 8, svga);
return;
case 3:
return;
}
@@ -2519,8 +2622,8 @@ gd54xx_writel_linear(uint32_t addr, uint32_t val, void *priv)
if (svga->writemode < 4) {
switch (ap) {
case 0:
default:
case 0:
svga_writel_linear(addr, val, svga);
return;
case 1:
@@ -2534,13 +2637,14 @@ gd54xx_writel_linear(uint32_t addr, uint32_t val, void *priv)
svga_writeb_linear(addr + 2, val >> 8, svga);
svga_writeb_linear(addr + 1, val >> 16, svga);
svga_writeb_linear(addr, val >> 24, svga);
return;
case 3:
return;
}
} else {
switch (ap) {
case 0:
default:
case 0:
svga_write_linear(addr, val & 0xff, svga);
svga_write_linear(addr + 1, val >> 8, svga);
svga_write_linear(addr + 2, val >> 16, svga);
@@ -2557,6 +2661,7 @@ gd54xx_writel_linear(uint32_t addr, uint32_t val, void *priv)
svga_write_linear(addr + 2, val >> 8, svga);
svga_write_linear(addr + 1, val >> 16, svga);
svga_write_linear(addr, val >> 24, svga);
return;
case 3:
return;
}
@@ -2791,6 +2896,9 @@ gd543x_mmio_write(uint32_t addr, uint8_t val, void *priv)
gd54xx_start_blit(0, 0xffffffff, gd54xx, svga);
}
break;
default:
break;
}
} else if (gd54xx->mmio_vram_overlap)
gd54xx_write(addr, val, gd54xx);
@@ -2985,6 +3093,9 @@ gd543x_mmio_read(uint32_t addr, void *priv)
case 0x40:
ret = gd54xx->blt.status;
break;
default:
break;
}
} else if (gd54xx->mmio_vram_overlap)
ret = gd54xx_read(addr, gd54xx);
@@ -3154,6 +3265,9 @@ gd54xx_get_pixel_width(gd54xx_t *gd54xx)
case CIRRUS_BLTMODE_PIXELWIDTH32:
ret = 4;
break;
default:
break;
}
return ret;
@@ -3422,7 +3536,7 @@ gd54xx_normal_blit(uint32_t count, gd54xx_t *gd54xx, svga_t *svga)
dst = svga->vram[dst_addr & svga->vram_mask];
svga->changedvram[(dst_addr & svga->vram_mask) >> 12] = changeframecount;
gd54xx_rop(gd54xx, (uint8_t *) &dst, (uint8_t *) &dst, (const uint8_t *) &src);
gd54xx_rop(gd54xx, &dst, &dst, (const uint8_t *) &src);
if ((gd54xx->blt.mode & CIRRUS_BLTMODE_COLOREXPAND) && (gd54xx->blt.modeext & CIRRUS_BLTMODEEXT_COLOREXPINV))
mask = !mask;
@@ -3560,11 +3674,11 @@ gd54xx_start_blit(uint32_t cpu_dat, uint32_t count, gd54xx_t *gd54xx, svga_t *sv
}
static uint8_t
cl_pci_read(int func, int addr, void *priv)
cl_pci_read(UNUSED(int func), int addr, void *priv)
{
gd54xx_t *gd54xx = (gd54xx_t *) priv;
svga_t *svga = &gd54xx->svga;
uint8_t ret = 0x00;
const gd54xx_t *gd54xx = (gd54xx_t *) priv;
const svga_t *svga = &gd54xx->svga;
uint8_t ret = 0x00;
if ((addr >= 0x30) && (addr <= 0x33) && (!gd54xx->has_bios))
ret = 0x00;
@@ -3653,17 +3767,20 @@ cl_pci_read(int func, int addr, void *priv)
case 0x3d:
ret = PCI_INTA;
break;
default:
break;
}
return ret;
}
static void
cl_pci_write(int func, int addr, uint8_t val, void *priv)
cl_pci_write(UNUSED(int func), int addr, uint8_t val, void *priv)
{
gd54xx_t *gd54xx = (gd54xx_t *) priv;
svga_t *svga = &gd54xx->svga;
uint32_t byte;
gd54xx_t *gd54xx = (gd54xx_t *) priv;
const svga_t *svga = &gd54xx->svga;
uint32_t byte;
if ((addr >= 0x30) && (addr <= 0x33) && (!gd54xx->has_bios))
return;
@@ -3723,13 +3840,16 @@ cl_pci_write(int func, int addr, uint8_t val, void *priv)
case 0x3c:
gd54xx->int_line = val;
return;
default:
break;
}
}
static uint8_t
gd5428_mca_read(int port, void *priv)
{
gd54xx_t *gd54xx = (gd54xx_t *) priv;
const gd54xx_t *gd54xx = (gd54xx_t *) priv;
return gd54xx->pos_regs[port & 7];
}
@@ -3747,7 +3867,7 @@ gd5428_mca_write(int port, uint8_t val, void *priv)
}
static uint8_t
gd5428_mca_feedb(void *priv)
gd5428_mca_feedb(UNUSED(void *priv))
{
return 1;
}
@@ -3824,17 +3944,17 @@ gd54xx_reset(void *priv)
gd54xx->unlocked = 0;
}
static void
*
gd54xx_init(const device_t *info)
static void *
gd54xx_init(const device_t *info)
{
gd54xx_t *gd54xx = malloc(sizeof(gd54xx_t));
svga_t *svga = &gd54xx->svga;
int id = info->local & 0xff;
int vram;
char *romfn = NULL;
char *romfn1 = NULL;
char *romfn2 = NULL;
gd54xx_t *gd54xx = malloc(sizeof(gd54xx_t));
svga_t *svga = &gd54xx->svga;
int id = info->local & 0xff;
int vram;
const char *romfn = NULL;
const char *romfn1 = NULL;
const char *romfn2 = NULL;
memset(gd54xx, 0, sizeof(gd54xx_t));
gd54xx->pci = !!(info->flags & DEVICE_PCI);
@@ -3966,6 +4086,9 @@ static void
case CIRRUS_ID_CLGD5480:
romfn = BIOS_GD5480_PATH;
break;
default:
break;
}
if (info->flags & DEVICE_MCA) {

4
src/video/vid_colorplus.c
View File

@@ -135,8 +135,8 @@ colorplus_poll(void *priv)
0x18, 0x1A, 0x1C, 0x1E,
0x11, 0x13, 0x15, 0x17,
0x19, 0x1B, 0x1D, 0x1F };
uint8_t *plane0 = colorplus->cga.vram;
uint8_t *plane1 = colorplus->cga.vram + 0x4000;
const uint8_t *plane0 = colorplus->cga.vram;
const uint8_t *plane1 = colorplus->cga.vram + 0x4000;
/* If one of the extra modes is not selected, drop down to the CGA
* drawing code. */

4
src/video/vid_et4000.c
View File

@@ -433,9 +433,7 @@ et4000_kasan_out(uint16_t addr, uint8_t val, void *priv)
case 5:
et4000->kasan_cfg_regs[5] = val;
et4000->svga.ksc5601_english_font_type = 0x100 | val;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 6:
case 7:
et4000->svga.ksc5601_udc_area_msb[et4000->kasan_cfg_index - 0xF6] = val;

4
src/video/vid_ht216.c
View File

@@ -321,9 +321,7 @@ ht216_out(uint16_t addr, uint8_t val, void *priv)
svga->adv_flags &= ~FLAG_RAMDAC_SHIFT;
if (val & 0x04)
svga->adv_flags |= FLAG_RAMDAC_SHIFT;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
/*Bank registers*/
case 0xe8:
case 0xe9:

227
src/video/vid_ibm_rgb528_ramdac.c
View File

@@ -27,32 +27,41 @@
#include <86box/vid_svga.h>
#include <86box/plat_unused.h>
typedef union {
typedef union ibm_rgb528_pixel8_t {
uint8_t pixel;
struct {
uint8_t b : 2, g : 3, r : 2;
uint8_t b : 2;
uint8_t g : 3;
uint8_t r : 2;
};
} ibm_rgb528_pixel8_t;
typedef union {
typedef union ibm_rgb528_pixel16_t {
uint16_t pixel;
struct {
uint16_t b_ : 5, g_ : 6, r_ : 5;
uint16_t b_ : 5;
uint16_t g_ : 6;
uint16_t r_ : 5;
};
struct {
uint16_t b : 5, g : 5, r : 5, c : 1;
uint16_t b : 5;
uint16_t g : 5;
uint16_t r : 5;
uint16_t c : 1;
};
} ibm_rgb528_pixel16_t;
typedef union {
typedef union ibm_rgb528_pixel32_t {
uint32_t pixel;
struct {
uint8_t b, g, r, a;
uint8_t b;
uint8_t g;
uint8_t r;
uint8_t a;
};
} ibm_rgb528_pixel32_t;
typedef struct
{
typedef struct ibm_rgb528_ramdac_t {
PALETTE extpal;
uint32_t extpallook[256];
uint8_t indexed_data[2048];
@@ -60,33 +69,37 @@ typedef struct
uint8_t cursor64_data[1024];
uint8_t palettes[3][256];
ibm_rgb528_pixel32_t extra_pal[4];
int16_t hwc_y, hwc_x;
uint16_t index, smlc_part;
int16_t hwc_y;
int16_t hwc_x;
uint16_t index;
uint16_t smlc_part;
uint8_t cmd_r0;
uint8_t cmd_r1;
uint8_t cmd_r2;
uint8_t cmd_r3;
uint8_t cmd_r4;
uint8_t status, indx_cntl;
uint8_t cursor_array,
cursor_hotspot_x, cursor_hotspot_y;
uint8_t status;
uint8_t indx_cntl;
uint8_t cursor_array;
uint8_t cursor_hotspot_x;
uint8_t cursor_hotspot_y;
} ibm_rgb528_ramdac_t;
void
ibm_rgb528_render_4bpp(svga_t *svga)
{
uint32_t *p;
ibm_rgb528_pixel32_t dat_out;
uint8_t dat;
uint32_t dat32 = 0x00000000;
uint64_t dat64 = 0x0000000000000000ULL;
uint64_t dat642 = 0x0000000000000000ULL;
ibm_rgb528_ramdac_t *ramdac = (ibm_rgb528_ramdac_t *) svga->ramdac;
uint8_t b8_dcol = (ramdac->indexed_data[0x0c] & 0xc0) >> 6;
uint8_t partition = (ramdac->indexed_data[0x07] & 0x0f) << 4;
uint8_t swap_word = ramdac->indexed_data[0x72] & 0x10;
uint8_t swap_nib = ramdac->indexed_data[0x72] & 0x21;
uint8_t vram_size = ramdac->indexed_data[0x70] & 0x03;
uint32_t *p;
ibm_rgb528_pixel32_t dat_out;
uint8_t dat;
uint32_t dat32 = 0x00000000;
uint64_t dat64 = 0x0000000000000000ULL;
uint64_t dat642 = 0x0000000000000000ULL;
const ibm_rgb528_ramdac_t *ramdac = (ibm_rgb528_ramdac_t *) svga->ramdac;
uint8_t b8_dcol = (ramdac->indexed_data[0x0c] & 0xc0) >> 6;
uint8_t partition = (ramdac->indexed_data[0x07] & 0x0f) << 4;
uint8_t swap_word = ramdac->indexed_data[0x72] & 0x10;
uint8_t swap_nib = ramdac->indexed_data[0x72] & 0x21;
uint8_t vram_size = ramdac->indexed_data[0x70] & 0x03;
if ((svga->displine + svga->y_add) < 0)
return;
@@ -155,16 +168,16 @@ ibm_rgb528_render_4bpp(svga_t *svga)
void
ibm_rgb528_render_8bpp(svga_t *svga)
{
uint32_t *p;
ibm_rgb528_pixel32_t dat_out;
uint8_t dat;
uint32_t dat32 = 0x00000000;
uint64_t dat64 = 0x0000000000000000ULL;
uint64_t dat642 = 0x0000000000000000ULL;
ibm_rgb528_ramdac_t *ramdac = (ibm_rgb528_ramdac_t *) svga->ramdac;
uint8_t b8_dcol = (ramdac->indexed_data[0x0c] & 0xc0) >> 6;
uint8_t swap_word = ramdac->indexed_data[0x72] & 0x10;
uint8_t vram_size = ramdac->indexed_data[0x70] & 0x03;
uint32_t *p;
ibm_rgb528_pixel32_t dat_out;
uint8_t dat;
uint32_t dat32 = 0x00000000;
uint64_t dat64 = 0x0000000000000000ULL;
uint64_t dat642 = 0x0000000000000000ULL;
const ibm_rgb528_ramdac_t *ramdac = (ibm_rgb528_ramdac_t *) svga->ramdac;
uint8_t b8_dcol = (ramdac->indexed_data[0x0c] & 0xc0) >> 6;
uint8_t swap_word = ramdac->indexed_data[0x72] & 0x10;
uint8_t vram_size = ramdac->indexed_data[0x70] & 0x03;
if ((svga->displine + svga->y_add) < 0)
return;
@@ -224,24 +237,24 @@ ibm_rgb528_render_8bpp(svga_t *svga)
void
ibm_rgb528_render_15_16bpp(svga_t *svga)
{
uint32_t *p;
ibm_rgb528_pixel16_t *dat_ex;
ibm_rgb528_pixel32_t dat_out;
uint16_t dat;
uint32_t dat32 = 0x00000000;
uint64_t dat64 = 0x0000000000000000ULL;
uint64_t dat642 = 0x0000000000000000ULL;
ibm_rgb528_ramdac_t *ramdac = (ibm_rgb528_ramdac_t *) svga->ramdac;
uint8_t b16_dcol = (ramdac->indexed_data[0x0c] & 0xc0) >> 6;
uint8_t by16_pol = ramdac->indexed_data[0x0c] & 0x20;
uint8_t b555_565 = ramdac->indexed_data[0x0c] & 0x02;
uint8_t bspr_cnt = ramdac->indexed_data[0x0c] & 0x01;
uint8_t partition = (ramdac->indexed_data[0x07] & 0x0e) << 4;
uint8_t b6bit_lin = ramdac->indexed_data[0x07] & 0x80;
uint8_t swaprb = ramdac->indexed_data[0x72] & 0x80;
uint8_t swap_word = ramdac->indexed_data[0x72] & 0x10;
uint8_t vram_size = ramdac->indexed_data[0x70] & 0x01;
uint8_t temp;
uint32_t *p;
ibm_rgb528_pixel16_t *dat_ex;
ibm_rgb528_pixel32_t dat_out;
uint16_t dat;
uint32_t dat32 = 0x00000000;
uint64_t dat64 = 0x0000000000000000ULL;
uint64_t dat642 = 0x0000000000000000ULL;
const ibm_rgb528_ramdac_t *ramdac = (ibm_rgb528_ramdac_t *) svga->ramdac;
uint8_t b16_dcol = (ramdac->indexed_data[0x0c] & 0xc0) >> 6;
uint8_t by16_pol = ramdac->indexed_data[0x0c] & 0x20;
uint8_t b555_565 = ramdac->indexed_data[0x0c] & 0x02;
uint8_t bspr_cnt = ramdac->indexed_data[0x0c] & 0x01;
uint8_t partition = (ramdac->indexed_data[0x07] & 0x0e) << 4;
uint8_t b6bit_lin = ramdac->indexed_data[0x07] & 0x80;
uint8_t swaprb = ramdac->indexed_data[0x72] & 0x80;
uint8_t swap_word = ramdac->indexed_data[0x72] & 0x10;
uint8_t vram_size = ramdac->indexed_data[0x70] & 0x01;
uint8_t temp;
if ((svga->displine + svga->y_add) < 0)
return;
@@ -349,18 +362,18 @@ ibm_rgb528_render_15_16bpp(svga_t *svga)
void
ibm_rgb528_render_24bpp(svga_t *svga)
{
uint32_t *p;
ibm_rgb528_pixel32_t *dat_ex;
uint32_t dat;
uint64_t dat64[6];
uint8_t *dat8 = (uint8_t *) dat64;
ibm_rgb528_ramdac_t *ramdac = (ibm_rgb528_ramdac_t *) svga->ramdac;
uint8_t b24_dcol = ramdac->indexed_data[0x0d] & 0x01;
uint8_t swaprb = ramdac->indexed_data[0x72] & 0x80;
uint8_t swap_word = ramdac->indexed_data[0x72] & 0x10;
uint8_t vram_size = ramdac->indexed_data[0x70] & 0x01;
uint8_t b6bit_lin = ramdac->indexed_data[0x07] & 0x80;
uint8_t temp;
uint32_t *p;
ibm_rgb528_pixel32_t *dat_ex;
uint32_t dat;
uint64_t dat64[6];
uint8_t *dat8 = (uint8_t *) dat64;
const ibm_rgb528_ramdac_t *ramdac = (ibm_rgb528_ramdac_t *) svga->ramdac;
uint8_t b24_dcol = ramdac->indexed_data[0x0d] & 0x01;
uint8_t swaprb = ramdac->indexed_data[0x72] & 0x80;
uint8_t swap_word = ramdac->indexed_data[0x72] & 0x10;
uint8_t vram_size = ramdac->indexed_data[0x70] & 0x01;
uint8_t b6bit_lin = ramdac->indexed_data[0x07] & 0x80;
uint8_t temp;
if ((svga->displine + svga->y_add) < 0)
return;
@@ -438,19 +451,19 @@ ibm_rgb528_render_24bpp(svga_t *svga)
void
ibm_rgb528_render_32bpp(svga_t *svga)
{
uint32_t *p;
ibm_rgb528_pixel32_t *dat_ex;
uint32_t dat = 0x00000000;
uint64_t dat64 = 0x0000000000000000ULL;
uint64_t dat642 = 0x0000000000000000ULL;
ibm_rgb528_ramdac_t *ramdac = (ibm_rgb528_ramdac_t *) svga->ramdac;
uint8_t b32_dcol = ramdac->indexed_data[0x0e] & 0x03;
uint8_t by32_pol = ramdac->indexed_data[0x0e] & 0x04;
uint8_t swaprb = ramdac->indexed_data[0x72] & 0x80;
uint8_t swap_word = ramdac->indexed_data[0x72] & 0x10;
uint8_t vram_size = ramdac->indexed_data[0x70] & 0x01;
uint8_t b6bit_lin = ramdac->indexed_data[0x07] & 0x80;
uint8_t temp;
uint32_t *p;
ibm_rgb528_pixel32_t *dat_ex;
uint32_t dat = 0x00000000;
uint64_t dat64 = 0x0000000000000000ULL;
uint64_t dat642 = 0x0000000000000000ULL;
const ibm_rgb528_ramdac_t *ramdac = (ibm_rgb528_ramdac_t *) svga->ramdac;
uint8_t b32_dcol = ramdac->indexed_data[0x0e] & 0x03;
uint8_t by32_pol = ramdac->indexed_data[0x0e] & 0x04;
uint8_t swaprb = ramdac->indexed_data[0x72] & 0x80;
uint8_t swap_word = ramdac->indexed_data[0x72] & 0x10;
uint8_t vram_size = ramdac->indexed_data[0x70] & 0x01;
uint8_t b6bit_lin = ramdac->indexed_data[0x07] & 0x80;
uint8_t temp;
if ((svga->displine + svga->y_add) < 0)
return;
@@ -551,9 +564,9 @@ ibm_rgb528_set_bpp(ibm_rgb528_ramdac_t *ramdac, svga_t *svga)
}
void
ibm_rgb528_ramdac_out(uint16_t addr, int rs2, uint8_t val, void *p, svga_t *svga)
ibm_rgb528_ramdac_out(uint16_t addr, int rs2, uint8_t val, void *priv, svga_t *svga)
{
ibm_rgb528_ramdac_t *ramdac = (ibm_rgb528_ramdac_t *) p;
ibm_rgb528_ramdac_t *ramdac = (ibm_rgb528_ramdac_t *) priv;
uint16_t index;
uint8_t rs = (addr & 0x03);
uint16_t da_mask = 0x03ff;
@@ -612,6 +625,9 @@ ibm_rgb528_ramdac_out(uint16_t addr, int rs2, uint8_t val, void *p, svga_t *svga
case 0xc0:
ramdac->smlc_part = 0x0400;
break;
default:
break;
}
svga->dac_hwcursor.addr = ramdac->smlc_part;
svga->dac_hwcursor.cur_xsize = svga->dac_hwcursor.cur_ysize = (val & 0x04) ? 64 : 32;
@@ -712,15 +728,18 @@ ibm_rgb528_ramdac_out(uint16_t addr, int rs2, uint8_t val, void *p, svga_t *svga
case 0x07:
ramdac->indx_cntl = val & 0x01;
break;
default:
break;
}
return;
}
uint8_t
ibm_rgb528_ramdac_in(uint16_t addr, int rs2, void *p, svga_t *svga)
ibm_rgb528_ramdac_in(uint16_t addr, int rs2, void *priv, svga_t *svga)
{
ibm_rgb528_ramdac_t *ramdac = (ibm_rgb528_ramdac_t *) p;
ibm_rgb528_ramdac_t *ramdac = (ibm_rgb528_ramdac_t *) priv;
uint8_t temp = 0xff;
uint8_t rs = (addr & 0x03);
uint8_t loc_read = (ramdac->indexed_data[0x30] & 0x10);
@@ -781,15 +800,18 @@ ibm_rgb528_ramdac_in(uint16_t addr, int rs2, void *p, svga_t *svga)
case 0x07:
temp = ramdac->indx_cntl;
break;
default:
break;
}
return temp;
}
void
ibm_rgb528_recalctimings(void *p, svga_t *svga)
ibm_rgb528_recalctimings(void *priv, svga_t *svga)
{
ibm_rgb528_ramdac_t *ramdac = (ibm_rgb528_ramdac_t *) p;
const ibm_rgb528_ramdac_t *ramdac = (ibm_rgb528_ramdac_t *) priv;
svga->interlace = ramdac->indexed_data[0x071] & 0x20;
@@ -814,6 +836,9 @@ ibm_rgb528_recalctimings(void *p, svga_t *svga)
case 32:
svga->render = ibm_rgb528_render_32bpp;
break;
default:
break;
}
}
}
@@ -824,16 +849,16 @@ ibm_rgb528_recalctimings(void *p, svga_t *svga)
void
ibm_rgb528_hwcursor_draw(svga_t *svga, int displine)
{
uint8_t dat;
uint8_t four_pixels = 0x00;
int pitch;
int x_pos;
int y_pos;
int offset = svga->dac_hwcursor_latch.x - svga->dac_hwcursor_latch.xoff;
uint32_t *p;
ibm_rgb528_ramdac_t *ramdac = (ibm_rgb528_ramdac_t *) svga->ramdac;
uint8_t pix_ordr = ramdac->indexed_data[0x30] & 0x20;
uint8_t cursor_mode = ramdac->indexed_data[0x30] & 0x03;
uint8_t dat;
uint8_t four_pixels = 0x00;
int pitch;
int x_pos;
int y_pos;
int offset = svga->dac_hwcursor_latch.x - svga->dac_hwcursor_latch.xoff;
uint32_t *p;
const ibm_rgb528_ramdac_t *ramdac = (ibm_rgb528_ramdac_t *) svga->ramdac;
uint8_t pix_ordr = ramdac->indexed_data[0x30] & 0x20;
uint8_t cursor_mode = ramdac->indexed_data[0x30] & 0x03;
/* The planes come in one part, and each plane is 2bpp,
so a 32x32 cursor has 8 bytes per line, and a 64x64
@@ -873,6 +898,9 @@ ibm_rgb528_hwcursor_draw(svga_t *svga, int displine)
/* Cursor Color 3 */
p[x_pos] = ramdac->extra_pal[2].pixel;
break;
default:
break;
}
break;
case 0x02:
@@ -889,6 +917,9 @@ ibm_rgb528_hwcursor_draw(svga_t *svga, int displine)
/* Complement */
p[x_pos] ^= 0xffffff;
break;
default:
break;
}
break;
case 0x03:
@@ -901,8 +932,14 @@ ibm_rgb528_hwcursor_draw(svga_t *svga, int displine)
/* Cursor Color 2 */
p[x_pos] = ramdac->extra_pal[1].pixel;
break;
default:
break;
}
break;
default:
break;
}
if ((x & 3) == 3)

11
src/video/vid_icd2061.c
View File

@@ -34,9 +34,12 @@
typedef struct icd2061_t {
float freq[3];
int count, bit_count,
unlocked, state;
uint32_t data, ctrl;
int count;
int bit_count;
int unlocked;
int state;
uint32_t data;
uint32_t ctrl;
} icd2061_t;
#ifdef ENABLE_ICD2061_LOG
@@ -138,7 +141,7 @@ icd2061_write(void *p, int val)
float
icd2061_getclock(int clock, void *priv)
{
icd2061_t *icd2061 = (icd2061_t *) priv;
const icd2061_t *icd2061 = (icd2061_t *) priv;
if (clock > 2)
clock = 2;

5
src/video/vid_ics2494.c
View File

@@ -51,7 +51,7 @@ ics2494_log(const char *fmt, ...)
float
ics2494_getclock(int clock, void *priv)
{
ics2494_t *ics2494 = (ics2494_t *) priv;
const ics2494_t *ics2494 = (ics2494_t *) priv;
if (clock > 15)
clock = 15;
@@ -85,6 +85,9 @@ ics2494_init(const device_t *info)
ics2494->freq[0xe] = 75000000.0;
ics2494->freq[0xf] = 94500000.0;
break;
default:
break;
}
return ics2494;

17
src/video/vid_ics2595.c
View File

@@ -26,9 +26,11 @@
#include <86box/plat_unused.h>
typedef struct ics2595_t {
int oldfs3, oldfs2;
int oldfs3;
int oldfs2;
int dat;
int pos, state;
int pos;
int state;
double clocks[16];
double output_clock;
@@ -43,9 +45,9 @@ enum {
static int ics2595_div[4] = { 8, 4, 2, 1 };
void
ics2595_write(void *p, int strobe, int dat)
ics2595_write(void *priv, int strobe, int dat)
{
ics2595_t *ics2595 = (ics2595_t *) p;
ics2595_t *ics2595 = (ics2595_t *) priv;
int d;
int n;
int l;
@@ -88,6 +90,7 @@ static void *
ics2595_init(UNUSED(const device_t *info))
{
ics2595_t *ics2595 = (ics2595_t *) malloc(sizeof(ics2595_t));
memset(ics2595, 0, sizeof(ics2595_t));
return ics2595;
@@ -105,15 +108,15 @@ ics2595_close(void *priv)
double
ics2595_getclock(void *priv)
{
ics2595_t *ics2595 = (ics2595_t *) priv;
const ics2595_t *ics2595 = (ics2595_t *) priv;
return ics2595->output_clock;
}
void
ics2595_setclock(void *p, double clock)
ics2595_setclock(void *priv, double clock)
{
ics2595_t *ics2595 = (ics2595_t *) p;
ics2595_t *ics2595 = (ics2595_t *) priv;
ics2595->output_clock = clock;
}

10
src/video/vid_mga.c
View File

@@ -665,9 +665,7 @@ mystique_out(uint16_t addr, uint8_t val, void *priv)
switch (addr) {
case 0x3c8:
mystique->xreg_idx = val;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 0x3c6:
case 0x3c7:
case 0x3c9:
@@ -5525,10 +5523,10 @@ mystique_init(const device_t *info)
NULL, 0, mystique);
mem_mapping_disable(&mystique->iload_mapping);
if (romfn = NULL)
pci_add_card(PCI_ADD_NORMAL, mystique_pci_read, mystique_pci_write, mystique, &mystique->pci_slot);
else
if (romfn == NULL)
pci_add_card(PCI_ADD_VIDEO, mystique_pci_read, mystique_pci_write, mystique, &mystique->pci_slot);
else
pci_add_card(PCI_ADD_NORMAL, mystique_pci_read, mystique_pci_write, mystique, &mystique->pci_slot);
mystique->pci_regs[0x06] = 0x80;
mystique->pci_regs[0x07] = 0 << 1;
mystique->pci_regs[0x2c] = mystique->bios_rom.rom[0x7ff8];

16
src/video/vid_s3_virge.c
View File

@@ -3516,9 +3516,7 @@ s3_virge_hwcursor_draw(svga_t *svga, int displine)
bg = svga->pallook[virge->hwc_bg_col & 0xff];
break;
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 15:
if (virge->chip != S3_VIRGEGX2) {
@@ -3526,9 +3524,7 @@ s3_virge_hwcursor_draw(svga_t *svga, int displine)
bg = video_15to32[virge->hwc_bg_col & 0xffff];
break;
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 16:
if (virge->chip != S3_VIRGEGX2) {
@@ -3536,9 +3532,7 @@ s3_virge_hwcursor_draw(svga_t *svga, int displine)
bg = video_16to32[virge->hwc_bg_col & 0xffff];
break;
}
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
case 24:
case 32:
@@ -4343,9 +4337,7 @@ s3_virge_init(const device_t *info)
case S3_VIRGE_GX:
virge->virge_rev = 0x01;
#ifdef FALLTHROUGH_ANNOTATION
[[fallthrough]];
#endif
fallthrough;
default:
virge->fifo_slots_num = 8;

14
src/video/vid_sc1148x_ramdac.c
View File

@@ -28,8 +28,7 @@
#include <86box/video.h>
#include <86box/vid_svga.h>
typedef struct
{
typedef struct sc1148x_ramdac_t {
int type;
int state;
int rs2;
@@ -37,9 +36,9 @@ typedef struct
} sc1148x_ramdac_t;
void
sc1148x_ramdac_out(uint16_t addr, int rs2, uint8_t val, void *p, svga_t *svga)
sc1148x_ramdac_out(uint16_t addr, int rs2, uint8_t val, void *priv, svga_t *svga)
{
sc1148x_ramdac_t *ramdac = (sc1148x_ramdac_t *) p;
sc1148x_ramdac_t *ramdac = (sc1148x_ramdac_t *) priv;
uint8_t rs = (addr & 0x03) | ((!!rs2) << 2);
int oldbpp = 0;
@@ -72,6 +71,9 @@ sc1148x_ramdac_out(uint16_t addr, int rs2, uint8_t val, void *p, svga_t *svga)
} else if (val == 0x00)
svga->bpp = 8;
break;
default:
break;
}
if (oldbpp != svga->bpp)
svga_recalctimings(svga);
@@ -90,9 +92,9 @@ sc1148x_ramdac_out(uint16_t addr, int rs2, uint8_t val, void *p, svga_t *svga)
}
uint8_t
sc1148x_ramdac_in(uint16_t addr, int rs2, void *p, svga_t *svga)
sc1148x_ramdac_in(uint16_t addr, int rs2, void *priv, svga_t *svga)
{
sc1148x_ramdac_t *ramdac = (sc1148x_ramdac_t *) p;
sc1148x_ramdac_t *ramdac = (sc1148x_ramdac_t *) priv;
uint8_t ret = 0xff;
uint8_t rs = (addr & 0x03) | ((!!rs2) << 2);

27
src/video/vid_sc1502x_ramdac.c
View File

@@ -29,17 +29,17 @@
#include <86box/timer.h>
#include <86box/video.h>
#include <86box/vid_svga.h>
#include <86box/plat_unused.h>
typedef struct
{
typedef struct sc1502x_ramdac_t {
int state;
uint8_t ctrl;
} sc1502x_ramdac_t;
void
sc1502x_ramdac_out(uint16_t addr, uint8_t val, void *p, svga_t *svga)
sc1502x_ramdac_out(uint16_t addr, uint8_t val, void *priv, svga_t *svga)
{
sc1502x_ramdac_t *ramdac = (sc1502x_ramdac_t *) p;
sc1502x_ramdac_t *ramdac = (sc1502x_ramdac_t *) priv;
int oldbpp = 0;
switch (addr) {
@@ -63,6 +63,9 @@ sc1502x_ramdac_out(uint16_t addr, uint8_t val, void *p, svga_t *svga)
case 0x20:
svga->bpp = 24;
break;
default:
break;
}
break;
case 4:
@@ -81,13 +84,17 @@ sc1502x_ramdac_out(uint16_t addr, uint8_t val, void *p, svga_t *svga)
case 0x20:
svga->bpp = 24;
break;
default:
break;
}
break;
} else {
svga->bpp = 16;
break;
}
break;
default:
break;
}
if (oldbpp != svga->bpp)
svga_recalctimings(svga);
@@ -100,6 +107,9 @@ sc1502x_ramdac_out(uint16_t addr, uint8_t val, void *p, svga_t *svga)
case 0x3C9:
ramdac->state = 0;
break;
default:
break;
}
svga_out(addr, val, svga);
@@ -125,13 +135,16 @@ sc1502x_ramdac_in(uint16_t addr, void *p, svga_t *svga)
case 0x3C9:
ramdac->state = 0;
break;
default:
break;
}
return temp;
}
static void *
sc1502x_ramdac_init(const device_t *info)
sc1502x_ramdac_init(UNUSED(const device_t *info))
{
sc1502x_ramdac_t *ramdac = (sc1502x_ramdac_t *) malloc(sizeof(sc1502x_ramdac_t));
memset(ramdac, 0, sizeof(sc1502x_ramdac_t));

42
src/video/vid_sdac_ramdac.c
View File

@@ -44,10 +44,13 @@ enum {
typedef struct sdac_ramdac_t {
uint16_t regs[256];
int magic_count,
windex, rindex,
reg_ff, rs2;
uint8_t type, command;
int magic_count;
int windex;
int rindex;
int reg_ff;
int rs2;
uint8_t type;
uint8_t command;
} sdac_ramdac_t;
static void
@@ -59,8 +62,8 @@ sdac_control_write(sdac_ramdac_t *ramdac, svga_t *svga, uint8_t val)
case ICS_5300:
case ICS_5301:
switch (val >> 5) {
case 0x00:
default:
case 0x00:
svga->bpp = 8;
break;
case 0x01:
@@ -82,9 +85,9 @@ sdac_control_write(sdac_ramdac_t *ramdac, svga_t *svga, uint8_t val)
case ICS_5341:
case ICS_5342:
switch (val >> 4) {
default:
case 0x00:
case 0x01: /* This is actually 8bpp with two pixels read at a time. */
default:
svga->bpp = 8;
break;
case 0x02:
@@ -108,6 +111,9 @@ sdac_control_write(sdac_ramdac_t *ramdac, svga_t *svga, uint8_t val)
break;
}
break;
default:
break;
}
svga_recalctimings(svga);
@@ -144,9 +150,9 @@ sdac_reg_read(sdac_ramdac_t *ramdac, int reg)
}
void
sdac_ramdac_out(uint16_t addr, int rs2, uint8_t val, void *p, svga_t *svga)
sdac_ramdac_out(uint16_t addr, int rs2, uint8_t val, void *priv, svga_t *svga)
{
sdac_ramdac_t *ramdac = (sdac_ramdac_t *) p;
sdac_ramdac_t *ramdac = (sdac_ramdac_t *) priv;
uint8_t rs = (addr & 0x03);
rs |= ((!!rs2) << 2);
@@ -184,13 +190,16 @@ sdac_ramdac_out(uint16_t addr, int rs2, uint8_t val, void *p, svga_t *svga)
ramdac->rindex = val;
ramdac->reg_ff = 0;
break;
default:
break;
}
}
uint8_t
sdac_ramdac_in(uint16_t addr, int rs2, void *p, svga_t *svga)
sdac_ramdac_in(uint16_t addr, int rs2, void *priv, svga_t *svga)
{
sdac_ramdac_t *ramdac = (sdac_ramdac_t *) p;
sdac_ramdac_t *ramdac = (sdac_ramdac_t *) priv;
uint8_t temp = 0xff;
uint8_t rs = (addr & 0x03);
rs |= ((!!rs2) << 2);
@@ -237,6 +246,9 @@ sdac_ramdac_in(uint16_t addr, int rs2, void *p, svga_t *svga)
case 0x07:
temp = ramdac->rindex;
break;
default:
break;
}
return temp;
@@ -245,11 +257,11 @@ sdac_ramdac_in(uint16_t addr, int rs2, void *p, svga_t *svga)
float
sdac_getclock(int clock, void *priv)
{
sdac_ramdac_t *ramdac = (sdac_ramdac_t *) priv;
float t;
int m;
int n1;
int n2;
const sdac_ramdac_t *ramdac = (sdac_ramdac_t *) priv;
float t;
int m;
int n1;
int n2;
if (ramdac->regs[0xe] & (1 << 5))
clock = ramdac->regs[0xe] & 7;

2
src/video/vid_table.c
View File

@@ -38,7 +38,7 @@
#include <86box/vid_mda.h>
#include <86box/vid_xga_device.h>
typedef struct {
typedef struct video_card_t {
const device_t *device;
int flags;
} VIDEO_CARD;

16
src/video/vid_tkd8001_ramdac.c
View File

@@ -27,6 +27,7 @@
#include <86box/mem.h>
#include <86box/video.h>
#include <86box/vid_svga.h>
#include <86box/plat_unused.h>
typedef struct tkd8001_ramdac_t {
int state;
@@ -34,9 +35,9 @@ typedef struct tkd8001_ramdac_t {
} tkd8001_ramdac_t;
void
tkd8001_ramdac_out(uint16_t addr, uint8_t val, void *p, svga_t *svga)
tkd8001_ramdac_out(uint16_t addr, uint8_t val, void *priv, svga_t *svga)
{
tkd8001_ramdac_t *ramdac = (tkd8001_ramdac_t *) p;
tkd8001_ramdac_t *ramdac = (tkd8001_ramdac_t *) priv;
switch (addr) {
case 0x3C6:
@@ -59,6 +60,9 @@ tkd8001_ramdac_out(uint16_t addr, uint8_t val, void *p, svga_t *svga)
case 7:
svga->bpp = 16;
break;
default:
break;
}
return;
}
@@ -68,6 +72,9 @@ tkd8001_ramdac_out(uint16_t addr, uint8_t val, void *p, svga_t *svga)
case 0x3C9:
ramdac->state = 0;
break;
default:
break;
}
svga_out(addr, val, svga);
@@ -89,12 +96,15 @@ tkd8001_ramdac_in(uint16_t addr, void *p, svga_t *svga)
case 0x3C9:
ramdac->state = 0;
break;
default:
break;
}
return svga_in(addr, svga);
}
static void *
tkd8001_ramdac_init(const device_t *info)
tkd8001_ramdac_init(UNUSED(const device_t *info))
{
tkd8001_ramdac_t *ramdac = (tkd8001_ramdac_t *) malloc(sizeof(tkd8001_ramdac_t));
memset(ramdac, 0, sizeof(tkd8001_ramdac_t));

99
src/video/vid_tvp3026_ramdac.c
View File

@@ -27,15 +27,17 @@
#include <86box/timer.h>
#include <86box/video.h>
#include <86box/vid_svga.h>
#include <86box/plat_fallthrough.h>
typedef struct
{
typedef struct tvp3026_ramdac_t {
PALETTE extpal;
uint32_t extpallook[256];
uint8_t cursor64_data[1024];
int hwc_y, hwc_x;
int hwc_y;
int hwc_x;
uint8_t ind_idx;
uint8_t dcc, dc_init;
uint8_t dcc;
uint8_t dc_init;
uint8_t ccr;
uint8_t true_color;
uint8_t latch_cntl;
@@ -48,9 +50,10 @@ typedef struct
uint8_t mode;
uint8_t pll_addr;
uint8_t clock_sel;
struct
{
uint8_t m, n, p;
struct {
uint8_t m;
uint8_t n;
uint8_t p;
} pix, mem, loop;
} tvp3026_ramdac_t;
@@ -83,15 +86,18 @@ tvp3026_set_bpp(tvp3026_ramdac_t *ramdac, svga_t *svga)
case 0x0f:
svga->bpp = 24;
break;
default:
break;
}
}
svga_recalctimings(svga);
}
void
tvp3026_ramdac_out(uint16_t addr, int rs2, int rs3, uint8_t val, void *p, svga_t *svga)
tvp3026_ramdac_out(uint16_t addr, int rs2, int rs3, uint8_t val, void *priv, svga_t *svga)
{
tvp3026_ramdac_t *ramdac = (tvp3026_ramdac_t *) p;
tvp3026_ramdac_t *ramdac = (tvp3026_ramdac_t *) priv;
uint32_t o32;
uint8_t *cd;
uint16_t index;
@@ -103,6 +109,7 @@ tvp3026_ramdac_out(uint16_t addr, int rs2, int rs3, uint8_t val, void *p, svga_t
switch (rs) {
case 0x00: /* Palette Write Index Register (RS value = 0000) */
ramdac->ind_idx = val;
fallthrough;
case 0x04: /* Ext Palette Write Index Register (RS value = 0100) */
case 0x03:
case 0x07: /* Ext Palette Read Index Register (RS value = 0111) */
@@ -147,6 +154,9 @@ tvp3026_ramdac_out(uint16_t addr, int rs2, int rs3, uint8_t val, void *p, svga_t
svga->dac_addr = (svga->dac_addr + 1) & 0xff;
svga->dac_pos = 0;
break;
default:
break;
}
break;
case 0x09: /* Direct Cursor Control (RS value = 1001) */
@@ -215,6 +225,9 @@ tvp3026_ramdac_out(uint16_t addr, int rs2, int rs3, uint8_t val, void *p, svga_t
case 2:
ramdac->pix.p = val;
break;
default:
break;
}
ramdac->pll_addr = ((ramdac->pll_addr + 1) & 3) | (ramdac->pll_addr & 0xfc);
break;
@@ -229,6 +242,9 @@ tvp3026_ramdac_out(uint16_t addr, int rs2, int rs3, uint8_t val, void *p, svga_t
case 2:
ramdac->mem.p = val;
break;
default:
break;
}
ramdac->pll_addr = ((ramdac->pll_addr + 4) & 0x0c) | (ramdac->pll_addr & 0xf3);
break;
@@ -243,12 +259,18 @@ tvp3026_ramdac_out(uint16_t addr, int rs2, int rs3, uint8_t val, void *p, svga_t
case 2:
ramdac->loop.p = val;
break;
default:
break;
}
ramdac->pll_addr = ((ramdac->pll_addr + 0x10) & 0x30) | (ramdac->pll_addr & 0xcf);
break;
case 0x39: /* MCLK/Loop Clock Control */
ramdac->mclk = val;
break;
default:
break;
}
break;
case 0x0b: /* Cursor RAM Data Register (RS value = 1011) */
@@ -273,17 +295,20 @@ tvp3026_ramdac_out(uint16_t addr, int rs2, int rs3, uint8_t val, void *p, svga_t
ramdac->hwc_y = (ramdac->hwc_y & 0x00ff) | ((val & 0x0f) << 8);
svga->dac_hwcursor.y = ramdac->hwc_y - svga->dac_hwcursor.cur_ysize;
break;
default:
break;
}
return;
}
uint8_t
tvp3026_ramdac_in(uint16_t addr, int rs2, int rs3, void *p, svga_t *svga)
tvp3026_ramdac_in(uint16_t addr, int rs2, int rs3, void *priv, svga_t *svga)
{
tvp3026_ramdac_t *ramdac = (tvp3026_ramdac_t *) p;
tvp3026_ramdac_t *ramdac = (tvp3026_ramdac_t *) priv;
uint8_t temp = 0xff;
uint8_t *cd;
const uint8_t *cd;
uint16_t index;
uint8_t rs = (addr & 0x03);
uint16_t da_mask = 0x03ff;
@@ -327,6 +352,9 @@ tvp3026_ramdac_in(uint16_t addr, int rs2, int rs3, void *p, svga_t *svga)
else
temp = ramdac->extpal[index].b & 0x3f;
break;
default:
break;
}
break;
case 0x09: /* Direct Cursor Control (RS value = 1001) */
@@ -378,6 +406,9 @@ tvp3026_ramdac_in(uint16_t addr, int rs2, int rs3, void *p, svga_t *svga)
case 3:
temp = 0x40; /*PLL locked to frequency*/
break;
default:
break;
}
break;
case 0x2e: /* Memory Clock PLL Data */
@@ -394,6 +425,9 @@ tvp3026_ramdac_in(uint16_t addr, int rs2, int rs3, void *p, svga_t *svga)
case 3:
temp = 0x40; /*PLL locked to frequency*/
break;
default:
break;
}
break;
case 0x2f: /* Loop Clock PLL Data */
@@ -407,6 +441,9 @@ tvp3026_ramdac_in(uint16_t addr, int rs2, int rs3, void *p, svga_t *svga)
case 2:
temp = ramdac->loop.p;
break;
default:
break;
}
break;
case 0x39: /* MCLK/Loop Clock Control */
@@ -415,6 +452,9 @@ tvp3026_ramdac_in(uint16_t addr, int rs2, int rs3, void *p, svga_t *svga)
case 0x3f: /* ID */
temp = 0x26;
break;
default:
break;
}
break;
case 0x0b: /* Cursor RAM Data Register (RS value = 1011) */
@@ -436,15 +476,18 @@ tvp3026_ramdac_in(uint16_t addr, int rs2, int rs3, void *p, svga_t *svga)
case 0x0f: /* Cursor Y High Register (RS value = 1111) */
temp = (ramdac->hwc_y >> 8) & 0xff;
break;
default:
break;
}
return temp;
}
void
tvp3026_recalctimings(void *p, svga_t *svga)
tvp3026_recalctimings(void *priv, svga_t *svga)
{
tvp3026_ramdac_t *ramdac = (tvp3026_ramdac_t *) p;
const tvp3026_ramdac_t *ramdac = (tvp3026_ramdac_t *) priv;
svga->interlace = (ramdac->ccr & 0x40);
}
@@ -466,7 +509,7 @@ tvp3026_hwcursor_draw(svga_t *svga, int displine)
uint32_t clr2;
uint32_t clr3;
uint32_t *p;
uint8_t *cd;
const uint8_t *cd;
tvp3026_ramdac_t *ramdac = (tvp3026_ramdac_t *) svga->ramdac;
clr1 = ramdac->extpallook[1];
@@ -513,6 +556,9 @@ tvp3026_hwcursor_draw(svga_t *svga, int displine)
case 3:
p[x_pos] = clr3;
break;
default:
break;
}
break;
case 2: /* XGA */
@@ -526,6 +572,9 @@ tvp3026_hwcursor_draw(svga_t *svga, int displine)
case 3:
p[x_pos] ^= 0xffffff;
break;
default:
break;
}
break;
case 3: /* X-Windows */
@@ -536,8 +585,14 @@ tvp3026_hwcursor_draw(svga_t *svga, int displine)
case 3:
p[x_pos] = clr2;
break;
default:
break;
}
break;
default:
break;
}
}
offset++;
@@ -552,12 +607,12 @@ tvp3026_hwcursor_draw(svga_t *svga, int displine)
float
tvp3026_getclock(int clock, void *priv)
{
tvp3026_ramdac_t *ramdac = (tvp3026_ramdac_t *) priv;
int n;
int m;
int pl;
float f_vco;
float f_pll;
const tvp3026_ramdac_t *ramdac = (tvp3026_ramdac_t *) priv;
int n;
int m;
int pl;
float f_vco;
float f_pll;
if (clock == 0)
return 25175000.0;
@@ -569,7 +624,7 @@ tvp3026_getclock(int clock, void *priv)
n = ramdac->pix.n & 0x3f;
m = ramdac->pix.m & 0x3f;
pl = ramdac->pix.p & 0x03;
f_vco = 8.0 * 14318184 * (float) (65 - m) / (float) (65 - n);
f_vco = 8.0f * 14318184 * (float) (65 - m) / (float) (65 - n);
f_pll = f_vco / (float) (1 << pl);
return f_pll;

62
src/video/vid_voodoo.c
View File

@@ -160,8 +160,8 @@ voodoo_readw(uint32_t addr, void *priv)
if ((addr & 0xc00000) == 0x400000) /*Framebuffer*/
{
if (SLI_ENABLED) {
voodoo_set_t *set = voodoo->set;
int y = (addr >> 11) & 0x3ff;
const voodoo_set_t *set = voodoo->set;
int y = (addr >> 11) & 0x3ff;
if (y & 1)
voodoo = set->voodoos[1];
@@ -194,13 +194,12 @@ voodoo_readl(uint32_t addr, void *priv)
cycles -= voodoo->read_time;
if (addr & 0x800000) /*Texture*/
{
if (addr & 0x800000) { /*Texture*/
} else if (addr & 0x400000) /*Framebuffer*/
{
if (SLI_ENABLED) {
voodoo_set_t *set = voodoo->set;
int y = (addr >> 11) & 0x3ff;
const voodoo_set_t *set = voodoo->set;
int y = (addr >> 11) & 0x3ff;
if (y & 1)
voodoo = set->voodoos[1];
@@ -429,7 +428,9 @@ voodoo_writel(uint32_t addr, uint32_t val, void *priv)
{
voodoo_queue_command(voodoo, addr | FIFO_WRITEL_FB, val);
} else if ((addr & 0x200000) && (voodoo->fbiInit7 & FBIINIT7_CMDFIFO_ENABLE)) {
// voodoo_log("Write CMDFIFO %08x(%08x) %08x %08x\n", addr, voodoo->cmdfifo_base + (addr & 0x3fffc), val, (voodoo->cmdfifo_base + (addr & 0x3fffc)) & voodoo->fb_mask);
#if 0
voodoo_log("Write CMDFIFO %08x(%08x) %08x %08x\n", addr, voodoo->cmdfifo_base + (addr & 0x3fffc), val, (voodoo->cmdfifo_base + (addr & 0x3fffc)) & voodoo->fb_mask);
#endif
*(uint32_t *) &voodoo->fb_mem[(voodoo->cmdfifo_base + (addr & 0x3fffc)) & voodoo->fb_mask] = val;
voodoo->cmdfifo_depth_wr++;
if ((voodoo->cmdfifo_depth_wr - voodoo->cmdfifo_depth_rd) < 20)
@@ -492,7 +493,9 @@ voodoo_writel(uint32_t addr, uint32_t val, void *priv)
if (voodoo->initEnable & 0x01) {
voodoo->fbiInit4 = val;
voodoo->read_time = pci_nonburst_time + pci_burst_time * ((voodoo->fbiInit4 & 1) ? 2 : 1);
// voodoo_log("fbiInit4 write %08x - read_time=%i\n", val, voodoo->read_time);
#if 0
voodoo_log("fbiInit4 write %08x - read_time=%i\n", val, voodoo->read_time);
#endif
}
break;
case SST_backPorch:
@@ -538,7 +541,9 @@ voodoo_writel(uint32_t addr, uint32_t val, void *priv)
voodoo->fbiInit1 = (val & ~5) | (voodoo->fbiInit1 & 5);
voodoo->write_time = pci_nonburst_time + pci_burst_time * ((voodoo->fbiInit1 & 2) ? 1 : 0);
voodoo->burst_time = pci_burst_time * ((voodoo->fbiInit1 & 2) ? 2 : 1);
// voodoo_log("fbiInit1 write %08x - write_time=%i burst_time=%i\n", val, voodoo->write_time, voodoo->burst_time);
#if 0
voodoo_log("fbiInit1 write %08x - write_time=%i burst_time=%i\n", val, voodoo->write_time, voodoo->burst_time);
#endif
}
break;
case SST_fbiInit2:
@@ -590,6 +595,9 @@ voodoo_writel(uint32_t addr, uint32_t val, void *priv)
case 0x0b:
voodoo->dac_readdata = 0x79;
break;
default:
break;
}
} else
voodoo->dac_readdata = voodoo->dac_data[voodoo->dac_readdata & 7];
@@ -599,7 +607,9 @@ voodoo_writel(uint32_t addr, uint32_t val, void *priv)
voodoo->dac_pll_regs[voodoo->dac_data[4] & 0xf] = (voodoo->dac_pll_regs[voodoo->dac_data[4] & 0xf] & 0xff00) | val;
else
voodoo->dac_pll_regs[voodoo->dac_data[4] & 0xf] = (voodoo->dac_pll_regs[voodoo->dac_data[4] & 0xf] & 0xff) | (val << 8);
// voodoo_log("Write PLL reg %x %04x\n", voodoo->dac_data[4] & 0xf, voodoo->dac_pll_regs[voodoo->dac_data[4] & 0xf]);
#if 0
voodoo_log("Write PLL reg %x %04x\n", voodoo->dac_data[4] & 0xf, voodoo->dac_pll_regs[voodoo->dac_data[4] & 0xf]);
#endif
voodoo->dac_reg_ff = !voodoo->dac_reg_ff;
if (!voodoo->dac_reg_ff)
voodoo->dac_data[4]++;
@@ -642,7 +652,9 @@ voodoo_writel(uint32_t addr, uint32_t val, void *priv)
case SST_cmdFifoBaseAddr:
voodoo->cmdfifo_base = (val & 0x3ff) << 12;
voodoo->cmdfifo_end = ((val >> 16) & 0x3ff) << 12;
// voodoo_log("CMDFIFO base=%08x end=%08x\n", voodoo->cmdfifo_base, voodoo->cmdfifo_end);
#if 0
voodoo_log("CMDFIFO base=%08x end=%08x\n", voodoo->cmdfifo_base, voodoo->cmdfifo_end);
#endif
break;
case SST_cmdFifoRdPtr:
@@ -672,14 +684,14 @@ voodoo_writel(uint32_t addr, uint32_t val, void *priv)
static uint16_t
voodoo_snoop_readw(uint32_t addr, void *priv)
{
voodoo_set_t *set = (voodoo_set_t *) priv;
const voodoo_set_t *set = (voodoo_set_t *) priv;
return voodoo_readw(addr, set->voodoos[0]);
}
static uint32_t
voodoo_snoop_readl(uint32_t addr, void *priv)
{
voodoo_set_t *set = (voodoo_set_t *) priv;
const voodoo_set_t *set = (voodoo_set_t *) priv;
return voodoo_readl(addr, set->voodoos[0]);
}
@@ -687,7 +699,7 @@ voodoo_snoop_readl(uint32_t addr, void *priv)
static void
voodoo_snoop_writew(uint32_t addr, uint16_t val, void *priv)
{
voodoo_set_t *set = (voodoo_set_t *) priv;
const voodoo_set_t *set = (voodoo_set_t *) priv;
voodoo_writew(addr, val, set->voodoos[0]);
voodoo_writew(addr, val, set->voodoos[1]);
@@ -695,7 +707,7 @@ voodoo_snoop_writew(uint32_t addr, uint16_t val, void *priv)
static void
voodoo_snoop_writel(uint32_t addr, uint32_t val, void *priv)
{
voodoo_set_t *set = (voodoo_set_t *) priv;
const voodoo_set_t *set = (voodoo_set_t *) priv;
voodoo_writel(addr, val, set->voodoos[0]);
voodoo_writel(addr, val, set->voodoos[1]);
@@ -749,7 +761,7 @@ voodoo_recalcmapping(voodoo_set_t *set)
uint8_t
voodoo_pci_read(int func, int addr, void *priv)
{
voodoo_t *voodoo = (voodoo_t *) priv;
const voodoo_t *voodoo = (voodoo_t *) priv;
if (func)
return 0;
@@ -803,6 +815,9 @@ voodoo_pci_read(int func, int addr, void *priv)
return (voodoo->initEnable >> 16) & 0xff;
case 0x43:
return (voodoo->initEnable >> 24) & 0xff;
default:
break;
}
return 0;
}
@@ -844,13 +859,16 @@ voodoo_pci_write(int func, int addr, uint8_t val, void *priv)
voodoo->initEnable = (voodoo->initEnable & ~0xff000000) | (val << 24);
voodoo_recalcmapping(voodoo->set);
break;
default:
break;
}
}
static void
voodoo_speed_changed(void *priv)
{
voodoo_set_t *voodoo_set = (voodoo_set_t *) priv;
const voodoo_set_t *voodoo_set = (voodoo_set_t *) priv;
voodoo_pixelclock_update(voodoo_set->voodoos[0]);
voodoo_set->voodoos[0]->read_time = pci_nonburst_time + pci_burst_time * ((voodoo_set->voodoos[0]->fbiInit4 & 1) ? 2 : 1);
@@ -870,7 +888,7 @@ voodoo_speed_changed(void *priv)
static void
voodoo_force_blit(void *priv)
{
voodoo_set_t *voodoo_set = (voodoo_set_t *) priv;
const voodoo_set_t *voodoo_set = (voodoo_set_t *) priv;
thread_wait_mutex(voodoo_set->voodoos[0]->force_blit_mutex);
if (voodoo_set->voodoos[0]->can_blit) {
@@ -916,6 +934,9 @@ voodoo_card_init(void)
case VOODOO_2:
voodoo->dual_tmus = 1;
break;
default:
break;
}
if (voodoo->type == VOODOO_2) /*generate filter lookup tables*/
@@ -1163,7 +1184,7 @@ voodoo_2d3d_card_init(int type)
}
void *
voodoo_init(const device_t *info)
voodoo_init(UNUSED(const device_t *info))
{
voodoo_set_t *voodoo_set = malloc(sizeof(voodoo_set_t));
uint32_t tmuConfig = 1;
@@ -1205,6 +1226,9 @@ voodoo_init(const device_t *info)
case VOODOO_2:
tmuConfig = 1 | (3 << 6);
break;
default:
break;
}
voodoo_set->voodoos[0]->tmuConfig = tmuConfig;

159
src/video/vid_voodoo_banshee.c
View File

@@ -373,6 +373,9 @@ banshee_out(uint16_t addr, uint8_t val, void *priv)
}
}
break;
default:
break;
}
svga_out(addr, val, svga);
}
@@ -433,8 +436,7 @@ banshee_updatemapping(banshee_t *banshee)
}
banshee_log("Update mapping - bank %02X ", svga->gdcreg[6] & 0xc);
switch (svga->gdcreg[6] & 0xc) /*Banked framebuffer*/
{
switch (svga->gdcreg[6] & 0xc) { /*Banked framebuffer*/
case 0x0: /*128k at A0000*/
mem_mapping_set_addr(&svga->mapping, 0xa0000, 0x20000);
svga->banked_mask = 0xffff;
@@ -451,6 +453,9 @@ banshee_updatemapping(banshee_t *banshee)
mem_mapping_set_addr(&svga->mapping, 0xb8000, 0x08000);
svga->banked_mask = 0x7fff;
break;
default:
break;
}
banshee_log("Linear framebuffer %08X ", banshee->memBaseAddr1);
@@ -464,7 +469,7 @@ static void
banshee_render_16bpp_tiled(svga_t *svga)
{
banshee_t *banshee = (banshee_t *) svga->priv;
uint32_t *p = &((uint32_t *) svga->monitor->target_buffer->line[svga->displine + svga->y_add])[svga->x_add];
uint32_t *p = &(svga->monitor->target_buffer->line[svga->displine + svga->y_add])[svga->x_add];
uint32_t addr;
int drawn = 0;
@@ -480,7 +485,7 @@ banshee_render_16bpp_tiled(svga_t *svga)
if (svga->hwcursor_on || svga->overlay_on)
svga->changedvram[addr >> 12] = 2;
if (svga->changedvram[addr >> 12] || svga->fullchange) {
uint16_t *vram_p = (uint16_t *) &svga->vram[addr & svga->vram_display_mask];
const uint16_t *vram_p = (uint16_t *) &svga->vram[addr & svga->vram_display_mask];
for (uint8_t xx = 0; xx < 64; xx++)
*p++ = video_16to32[*vram_p++];
@@ -503,8 +508,8 @@ banshee_render_16bpp_tiled(svga_t *svga)
static void
banshee_recalctimings(svga_t *svga)
{
banshee_t *banshee = (banshee_t *) svga->priv;
voodoo_t *voodoo = banshee->voodoo;
banshee_t *banshee = (banshee_t *) svga->priv;
const voodoo_t *voodoo = banshee->voodoo;
/*7 R/W Horizontal Retrace End bit 5. -
6 R/W Horizontal Retrace Start bit 8 0x4
@@ -908,10 +913,11 @@ banshee_ext_outl(uint16_t addr, uint32_t val, void *priv)
svga->fullchange = changeframecount;
svga_recalctimings(svga);
break;
#if 0
default:
#if 0
fatal("bad banshee_ext_outl: addr=%04x val=%08x\n", addr, val);
#endif
break;
}
}
@@ -999,15 +1005,14 @@ banshee_ext_in(uint16_t addr, void *priv)
static uint32_t
banshee_status(banshee_t *banshee)
{
voodoo_t *voodoo = banshee->voodoo;
svga_t *svga = &banshee->svga;
int fifo_entries = FIFO_ENTRIES;
int swap_count = voodoo->swap_count;
int written = voodoo->cmd_written + voodoo->cmd_written_fifo;
int busy = (written - voodoo->cmd_read) || (voodoo->cmdfifo_depth_rd != voodoo->cmdfifo_depth_wr) || voodoo->render_voodoo_busy[0] || voodoo->render_voodoo_busy[1] || voodoo->render_voodoo_busy[2] || voodoo->render_voodoo_busy[3] || voodoo->voodoo_busy;
uint32_t ret;
voodoo_t *voodoo = banshee->voodoo;
const svga_t *svga = &banshee->svga;
int fifo_entries = FIFO_ENTRIES;
int swap_count = voodoo->swap_count;
int written = voodoo->cmd_written + voodoo->cmd_written_fifo;
int busy = (written - voodoo->cmd_read) || (voodoo->cmdfifo_depth_rd != voodoo->cmdfifo_depth_wr) || voodoo->render_voodoo_busy[0] || voodoo->render_voodoo_busy[1] || voodoo->render_voodoo_busy[2] || voodoo->render_voodoo_busy[3] || voodoo->voodoo_busy;
uint32_t ret = 0;
ret = 0;
if (fifo_entries < 0x20)
ret |= 0x1f - fifo_entries;
else
@@ -1040,10 +1045,10 @@ banshee_status(banshee_t *banshee)
static uint32_t
banshee_ext_inl(uint16_t addr, void *priv)
{
banshee_t *banshee = (banshee_t *) priv;
voodoo_t *voodoo = banshee->voodoo;
svga_t *svga = &banshee->svga;
uint32_t ret = 0xffffffff;
banshee_t *banshee = (banshee_t *) priv;
const voodoo_t *voodoo = banshee->voodoo;
const svga_t *svga = &banshee->svga;
uint32_t ret = 0xffffffff;
cycles -= voodoo->read_time;
@@ -1215,8 +1220,8 @@ banshee_reg_readw(uint32_t addr, void *priv)
static uint32_t
banshee_cmd_read(banshee_t *banshee, uint32_t addr)
{
voodoo_t *voodoo = banshee->voodoo;
uint32_t ret = 0xffffffff;
const voodoo_t *voodoo = banshee->voodoo;
uint32_t ret = 0xffffffff;
switch (addr & 0x1fc) {
case Agp_agpHostAddressLow:
@@ -1422,6 +1427,9 @@ banshee_reg_readl(uint32_t addr, void *priv)
break;
}
break;
default:
break;
}
#if 0
@@ -1470,6 +1478,9 @@ banshee_reg_writew(uint32_t addr, uint16_t val, void *priv)
case 0x1f00000:
voodoo_queue_command(voodoo, (addr & 0xffffff) | FIFO_WRITEW_FB, val);
break;
default:
break;
}
}
@@ -1682,15 +1693,18 @@ banshee_reg_writel(uint32_t addr, uint32_t val, void *priv)
case 0x1f00000:
voodoo_queue_command(voodoo, (addr & 0xfffffc) | FIFO_WRITEL_FB, val);
break;
default:
break;
}
}
static uint8_t
banshee_read_linear(uint32_t addr, void *priv)
{
banshee_t *banshee = (banshee_t *) priv;
voodoo_t *voodoo = banshee->voodoo;
svga_t *svga = &banshee->svga;
banshee_t *banshee = (banshee_t *) priv;
const voodoo_t *voodoo = banshee->voodoo;
const svga_t *svga = &banshee->svga;
cycles -= voodoo->read_time;
@@ -1726,9 +1740,9 @@ banshee_read_linear(uint32_t addr, void *priv)
static uint16_t
banshee_read_linear_w(uint32_t addr, void *priv)
{
banshee_t *banshee = (banshee_t *) priv;
voodoo_t *voodoo = banshee->voodoo;
svga_t *svga = &banshee->svga;
banshee_t *banshee = (banshee_t *) priv;
const voodoo_t *voodoo = banshee->voodoo;
svga_t *svga = &banshee->svga;
if (addr & 1)
return banshee_read_linear(addr, priv) | (banshee_read_linear(addr + 1, priv) << 8);
@@ -1766,9 +1780,9 @@ banshee_read_linear_w(uint32_t addr, void *priv)
static uint32_t
banshee_read_linear_l(uint32_t addr, void *priv)
{
banshee_t *banshee = (banshee_t *) priv;
voodoo_t *voodoo = banshee->voodoo;
svga_t *svga = &banshee->svga;
banshee_t *banshee = (banshee_t *) priv;
const voodoo_t *voodoo = banshee->voodoo;
svga_t *svga = &banshee->svga;
if (addr & 3)
return banshee_read_linear_w(addr, priv) | (banshee_read_linear_w(addr + 2, priv) << 16);
@@ -1807,9 +1821,9 @@ banshee_read_linear_l(uint32_t addr, void *priv)
static void
banshee_write_linear(uint32_t addr, uint8_t val, void *priv)
{
banshee_t *banshee = (banshee_t *) priv;
voodoo_t *voodoo = banshee->voodoo;
svga_t *svga = &banshee->svga;
banshee_t *banshee = (banshee_t *) priv;
const voodoo_t *voodoo = banshee->voodoo;
svga_t *svga = &banshee->svga;
cycles -= voodoo->write_time;
@@ -1842,9 +1856,9 @@ banshee_write_linear(uint32_t addr, uint8_t val, void *priv)
static void
banshee_write_linear_w(uint32_t addr, uint16_t val, void *priv)
{
banshee_t *banshee = (banshee_t *) priv;
voodoo_t *voodoo = banshee->voodoo;
svga_t *svga = &banshee->svga;
banshee_t *banshee = (banshee_t *) priv;
const voodoo_t *voodoo = banshee->voodoo;
svga_t *svga = &banshee->svga;
if (addr & 1) {
banshee_write_linear(addr, val, priv);
@@ -1984,14 +1998,14 @@ banshee_write_linear_l(uint32_t addr, uint32_t val, void *priv)
void
banshee_hwcursor_draw(svga_t *svga, int displine)
{
banshee_t *banshee = (banshee_t *) svga->priv;
int x;
int x_off;
int xx;
uint32_t col0 = banshee->hwCurC0;
uint32_t col1 = banshee->hwCurC1;
uint8_t plane0[8];
uint8_t plane1[8];
const banshee_t *banshee = (banshee_t *) svga->priv;
int x;
int x_off;
int xx;
uint32_t col0 = banshee->hwCurC0;
uint32_t col1 = banshee->hwCurC1;
uint8_t plane0[8];
uint8_t plane1[8];
for (uint8_t c = 0; c < 8; c++)
plane0[c] = svga->vram[svga->hwcursor_latch.addr + c];
@@ -2007,7 +2021,7 @@ banshee_hwcursor_draw(svga_t *svga, int displine)
if (x_off > -8) {
for (xx = 0; xx < 8; xx++) {
if (plane0[x >> 3] & (1 << 7))
((uint32_t *) svga->monitor->target_buffer->line[displine])[x_off + xx + svga->x_add] = (plane1[x >> 3] & (1 << 7)) ? col1 : col0;
(svga->monitor->target_buffer->line[displine])[x_off + xx + svga->x_add] = (plane1[x >> 3] & (1 << 7)) ? col1 : col0;
plane0[x >> 3] <<= 1;
plane1[x >> 3] <<= 1;
@@ -2022,9 +2036,9 @@ banshee_hwcursor_draw(svga_t *svga, int displine)
if (x_off > -8) {
for (xx = 0; xx < 8; xx++) {
if (!(plane0[x >> 3] & (1 << 7)))
((uint32_t *) svga->monitor->target_buffer->line[displine])[x_off + xx + svga->x_add] = (plane1[x >> 3] & (1 << 7)) ? col1 : col0;
(svga->monitor->target_buffer->line[displine])[x_off + xx + svga->x_add] = (plane1[x >> 3] & (1 << 7)) ? col1 : col0;
else if (plane1[x >> 3] & (1 << 7))
((uint32_t *) svga->monitor->target_buffer->line[displine])[x_off + xx + svga->x_add] ^= 0xffffff;
(svga->monitor->target_buffer->line[displine])[x_off + xx + svga->x_add] ^= 0xffffff;
plane0[x >> 3] <<= 1;
plane1[x >> 3] <<= 1;
@@ -2189,8 +2203,6 @@ banshee_hwcursor_draw(svga_t *svga, int displine)
void
voodoo_generate_vb_filters(voodoo_t *voodoo, int fcr, int fcg)
{
int g;
int h;
float difference;
float diffg;
float thiscol;
@@ -2204,10 +2216,8 @@ voodoo_generate_vb_filters(voodoo_t *voodoo, int fcr, int fcg)
fcg *= hack;
/* box prefilter */
for (g = 0; g < 256; g++) // pixel 1 - our target pixel we want to bleed into
{
for (h = 0; h < 256; h++) // pixel 2 - our main pixel
{
for (uint16_t g = 0; g < 256; g++) { // pixel 1 - our target pixel we want to bleed into
for (uint16_t h = 0; h < 256; h++) { // pixel 2 - our main pixel
float avg;
float avgdiff;
@@ -2289,10 +2299,8 @@ voodoo_generate_vb_filters(voodoo_t *voodoo, int fcr, int fcg)
fcg *= 6;
#endif
for (g = 0; g < 256; g++) // pixel 1
{
for (h = 0; h < 256; h++) // pixel 2
{
for (uint16_t g = 0; g < 256; g++) { // pixel 1
for (uint16_t h = 0; h < 256; h++) { // pixel 2
difference = (float) (h - g);
diffg = difference;
@@ -2332,18 +2340,18 @@ voodoo_generate_vb_filters(voodoo_t *voodoo, int fcr, int fcg)
static void
banshee_overlay_draw(svga_t *svga, int displine)
{
banshee_t *banshee = (banshee_t *) svga->priv;
voodoo_t *voodoo = banshee->voodoo;
uint32_t *p;
int x;
int y = voodoo->overlay.src_y >> 20;
uint32_t src_addr = svga->overlay_latch.addr + ((banshee->vidProcCfg & VIDPROCCFG_OVERLAY_TILE) ? ((y & 31) * 128 + (y >> 5) * svga->overlay_latch.pitch) : y * svga->overlay_latch.pitch);
uint32_t src_addr2 = svga->overlay_latch.addr + ((banshee->vidProcCfg & VIDPROCCFG_OVERLAY_TILE) ? (((y + 1) & 31) * 128 + ((y + 1) >> 5) * svga->overlay_latch.pitch) : (y + 1) * svga->overlay_latch.pitch);
uint8_t *src = &svga->vram[src_addr & svga->vram_mask];
uint32_t src_x = 0;
unsigned int y_coeff = (voodoo->overlay.src_y & 0xfffff) >> 4;
int skip_filtering;
uint32_t *clut = &svga->pallook[(banshee->vidProcCfg & VIDPROCCFG_OVERLAY_CLUT_SEL) ? 256 : 0];
banshee_t *banshee = (banshee_t *) svga->priv;
voodoo_t *voodoo = banshee->voodoo;
uint32_t *p;
int x;
int y = voodoo->overlay.src_y >> 20;
uint32_t src_addr = svga->overlay_latch.addr + ((banshee->vidProcCfg & VIDPROCCFG_OVERLAY_TILE) ? ((y & 31) * 128 + (y >> 5) * svga->overlay_latch.pitch) : y * svga->overlay_latch.pitch);
uint32_t src_addr2 = svga->overlay_latch.addr + ((banshee->vidProcCfg & VIDPROCCFG_OVERLAY_TILE) ? (((y + 1) & 31) * 128 + ((y + 1) >> 5) * svga->overlay_latch.pitch) : (y + 1) * svga->overlay_latch.pitch);
uint8_t *src = &svga->vram[src_addr & svga->vram_mask];
uint32_t src_x = 0;
unsigned int y_coeff = (voodoo->overlay.src_y & 0xfffff) >> 4;
int skip_filtering;
const uint32_t *clut = &svga->pallook[(banshee->vidProcCfg & VIDPROCCFG_OVERLAY_CLUT_SEL) ? 256 : 0];
if (svga->render == svga_render_null && !svga->changedvram[src_addr >> 12] && !svga->changedvram[src_addr2 >> 12] && !svga->fullchange && ((voodoo->overlay.src_y >> 20) < 2048 && !voodoo->dirty_line[voodoo->overlay.src_y >> 20]) && !(banshee->vidProcCfg & VIDPROCCFG_V_SCALE_ENABLE)) {
voodoo->overlay.src_y += (1 << 20);
@@ -2357,7 +2365,7 @@ banshee_overlay_draw(svga_t *svga, int displine)
if (src_addr >= 0x800000)
fatal("overlay out of range!\n");
#endif
p = &((uint32_t *) svga->monitor->target_buffer->line[displine])[svga->overlay_latch.x + svga->x_add];
p = &(svga->monitor->target_buffer->line[displine])[svga->overlay_latch.x + svga->x_add];
if (banshee->voodoo->scrfilter && banshee->voodoo->scrfilterEnabled)
skip_filtering = ((banshee->vidProcCfg & VIDPROCCFG_FILTER_MODE_MASK) != VIDPROCCFG_FILTER_MODE_BILINEAR && !(banshee->vidProcCfg & VIDPROCCFG_H_SCALE_ENABLE) && !(banshee->vidProcCfg & VIDPROCCFG_FILTER_MODE_DITHER_4X4) && !(banshee->vidProcCfg & VIDPROCCFG_FILTER_MODE_DITHER_2X2));
@@ -2611,7 +2619,7 @@ banshee_vsync_callback(svga_t *svga)
static uint8_t
banshee_pci_read(int func, int addr, void *priv)
{
banshee_t *banshee = (banshee_t *) priv;
const banshee_t *banshee = (banshee_t *) priv;
#if 0
svga_t *svga = &banshee->svga;
#endif
@@ -2806,6 +2814,9 @@ banshee_pci_read(int func, int addr, void *priv)
case 0x67:
ret = banshee->pci_regs[0x67];
break;
default:
break;
}
#if 0
banshee_log("%02X\n", ret);
@@ -2935,6 +2946,9 @@ banshee_pci_write(int func, int addr, uint8_t val, void *priv)
case 0x66:
banshee->pci_regs[0x66] = val & 0xc0;
return;
default:
break;
}
}
@@ -3244,6 +3258,9 @@ banshee_init_common(const device_t *info, char *fn, int has_sgram, int type, int
banshee->pci_regs[0x2e] = 0x54;
banshee->pci_regs[0x2f] = 0x00;
break;
default:
break;
}
video_inform(VIDEO_FLAG_TYPE_SPECIAL, banshee->agp ? &timing_banshee_agp : &timing_banshee);

95
src/video/vid_voodoo_banshee_blitter.c
View File

@@ -250,6 +250,9 @@ PLOT(voodoo_t *voodoo, int x, int y, int pat_x, int pat_y, uint8_t pattern_mask,
voodoo->changedvram[addr >> 12] = changeframecount;
break;
}
default:
break;
}
}
@@ -293,6 +296,9 @@ PLOT_LINE(voodoo_t *voodoo, int x, int y, UNUSED(uint8_t rop), uint32_t pattern,
voodoo->changedvram[addr >> 12] = changeframecount;
break;
}
default:
break;
}
}
@@ -364,6 +370,9 @@ update_src_stride(voodoo_t *voodoo)
bansheeblt_log("Dword packing %08x %08x\n", voodoo->banshee_blt.src_stride_dest, voodoo->banshee_blt.host_data_size_dest);
#endif
break;
default:
break;
}
}
@@ -385,12 +394,12 @@ end_command(voodoo_t *voodoo)
static void
banshee_do_rectfill(voodoo_t *voodoo)
{
clip_t *clip = &voodoo->banshee_blt.clip[(voodoo->banshee_blt.command & COMMAND_CLIP_SEL) ? 1 : 0];
int dst_y = voodoo->banshee_blt.dstY;
uint8_t *pattern_mono = (uint8_t *) voodoo->banshee_blt.colorPattern;
int pat_y = (voodoo->banshee_blt.commandExtra & CMDEXTRA_FORCE_PAT_ROW0) ? 0 : (voodoo->banshee_blt.patoff_y + voodoo->banshee_blt.dstY);
int use_pattern_trans = (voodoo->banshee_blt.command & (COMMAND_PATTERN_MONO | COMMAND_TRANS_MONO)) == (COMMAND_PATTERN_MONO | COMMAND_TRANS_MONO);
uint8_t rop = voodoo->banshee_blt.command >> 24;
const clip_t *clip = &voodoo->banshee_blt.clip[(voodoo->banshee_blt.command & COMMAND_CLIP_SEL) ? 1 : 0];
int dst_y = voodoo->banshee_blt.dstY;
const uint8_t *pattern_mono = (uint8_t *) voodoo->banshee_blt.colorPattern;
int pat_y = (voodoo->banshee_blt.commandExtra & CMDEXTRA_FORCE_PAT_ROW0) ? 0 : (voodoo->banshee_blt.patoff_y + voodoo->banshee_blt.dstY);
int use_pattern_trans = (voodoo->banshee_blt.command & (COMMAND_PATTERN_MONO | COMMAND_TRANS_MONO)) == (COMMAND_PATTERN_MONO | COMMAND_TRANS_MONO);
uint8_t rop = voodoo->banshee_blt.command >> 24;
#if 0
bansheeblt_log("banshee_do_rectfill: size=%i,%i dst=%i,%i\n", voodoo->banshee_blt.dstSizeX, voodoo->banshee_blt.dstSizeY, voodoo->banshee_blt.dstX, voodoo->banshee_blt.dstY);
@@ -519,13 +528,13 @@ DECODE_YUYV422_16BPP(uint16_t *buf, uint8_t *src)
static void
do_screen_to_screen_line(voodoo_t *voodoo, uint8_t *src_p, int use_x_dir, int src_x, int src_tiled)
{
clip_t *clip = &voodoo->banshee_blt.clip[(voodoo->banshee_blt.command & COMMAND_CLIP_SEL) ? 1 : 0];
int dst_y = voodoo->banshee_blt.dstY;
int pat_y = (voodoo->banshee_blt.commandExtra & CMDEXTRA_FORCE_PAT_ROW0) ? 0 : (voodoo->banshee_blt.patoff_y + voodoo->banshee_blt.dstY);
uint8_t *pattern_mono = (uint8_t *) voodoo->banshee_blt.colorPattern;
int use_pattern_trans = (voodoo->banshee_blt.command & (COMMAND_PATTERN_MONO | COMMAND_TRANS_MONO)) == (COMMAND_PATTERN_MONO | COMMAND_TRANS_MONO);
uint8_t rop = voodoo->banshee_blt.command >> 24;
int src_colorkey;
const clip_t *clip = &voodoo->banshee_blt.clip[(voodoo->banshee_blt.command & COMMAND_CLIP_SEL) ? 1 : 0];
int dst_y = voodoo->banshee_blt.dstY;
int pat_y = (voodoo->banshee_blt.commandExtra & CMDEXTRA_FORCE_PAT_ROW0) ? 0 : (voodoo->banshee_blt.patoff_y + voodoo->banshee_blt.dstY);
const uint8_t *pattern_mono = (uint8_t *) voodoo->banshee_blt.colorPattern;
int use_pattern_trans = (voodoo->banshee_blt.command & (COMMAND_PATTERN_MONO | COMMAND_TRANS_MONO)) == (COMMAND_PATTERN_MONO | COMMAND_TRANS_MONO);
uint8_t rop = voodoo->banshee_blt.command >> 24;
int src_colorkey;
switch (voodoo->banshee_blt.srcFormat & SRC_FORMAT_COL_MASK) {
case SRC_FORMAT_COL_8_BPP:
@@ -601,6 +610,9 @@ do_screen_to_screen_line(voodoo_t *voodoo, uint8_t *src_p, int use_x_dir, int sr
voodoo->changedvram[dst_addr >> 12] = changeframecount;
break;
}
default:
break;
}
}
if (use_x_dir) {
@@ -619,7 +631,9 @@ do_screen_to_screen_line(voodoo_t *voodoo, uint8_t *src_p, int use_x_dir, int sr
} else {
/*Conversion required*/
if (dst_y >= clip->y_min && dst_y < clip->y_max) {
// int src_x = voodoo->banshee_blt.srcX;
#if 0
int src_x = voodoo->banshee_blt.srcX;
#endif
int dst_x = voodoo->banshee_blt.dstX;
int pat_x = voodoo->banshee_blt.patoff_x + voodoo->banshee_blt.dstX;
uint8_t pattern_mask = pattern_mono[pat_y & 7];
@@ -777,7 +791,7 @@ banshee_do_screen_to_screen_blt(voodoo_t *voodoo)
}
static void
banshee_do_host_to_screen_blt(voodoo_t *voodoo, int count, uint32_t data)
banshee_do_host_to_screen_blt(voodoo_t *voodoo, UNUSED(int count), uint32_t data)
{
#if 0
if (voodoo->banshee_blt.dstBaseAddr == 0xee5194)
@@ -849,15 +863,15 @@ banshee_do_host_to_screen_blt(voodoo_t *voodoo, int count, uint32_t data)
static void
do_screen_to_screen_stretch_line(voodoo_t *voodoo, uint8_t *src_p, int src_x, int *src_y)
{
clip_t *clip = &voodoo->banshee_blt.clip[(voodoo->banshee_blt.command & COMMAND_CLIP_SEL) ? 1 : 0];
const clip_t *clip = &voodoo->banshee_blt.clip[(voodoo->banshee_blt.command & COMMAND_CLIP_SEL) ? 1 : 0];
#if 0
int src_y = voodoo->banshee_blt.srcY;
#endif
int dst_y = voodoo->banshee_blt.dstY;
int pat_y = (voodoo->banshee_blt.commandExtra & CMDEXTRA_FORCE_PAT_ROW0) ? 0 : (voodoo->banshee_blt.patoff_y + voodoo->banshee_blt.dstY);
uint8_t *pattern_mono = (uint8_t *) voodoo->banshee_blt.colorPattern;
int use_pattern_trans = (voodoo->banshee_blt.command & (COMMAND_PATTERN_MONO | COMMAND_TRANS_MONO)) == (COMMAND_PATTERN_MONO | COMMAND_TRANS_MONO);
uint32_t *colorPattern = voodoo->banshee_blt.colorPattern;
int dst_y = voodoo->banshee_blt.dstY;
int pat_y = (voodoo->banshee_blt.commandExtra & CMDEXTRA_FORCE_PAT_ROW0) ? 0 : (voodoo->banshee_blt.patoff_y + voodoo->banshee_blt.dstY);
const uint8_t *pattern_mono = (uint8_t *) voodoo->banshee_blt.colorPattern;
int use_pattern_trans = (voodoo->banshee_blt.command & (COMMAND_PATTERN_MONO | COMMAND_TRANS_MONO)) == (COMMAND_PATTERN_MONO | COMMAND_TRANS_MONO);
const uint32_t *colorPattern = voodoo->banshee_blt.colorPattern;
#if 0
int error_y = voodoo->banshee_blt.dstSizeY / 2;
@@ -891,7 +905,9 @@ do_screen_to_screen_stretch_line(voodoo_t *voodoo, uint8_t *src_p, int src_x, in
uint32_t pattern = (voodoo->banshee_blt.command & COMMAND_PATTERN_MONO) ? ((pattern_mask & (1 << (7 - (pat_x & 7)))) ? voodoo->banshee_blt.colorFore : voodoo->banshee_blt.colorBack) : colorPattern[(pat_x & 7) + (pat_y & 7) * 8];
voodoo->vram[dst_addr] = MIX(voodoo, dest, src, pattern, COLORKEY_8, COLORKEY_8);
// bansheeblt_log("%i,%i : sdp=%02x,%02x,%02x res=%02x\n", voodoo->banshee_blt.cur_x, voodoo->banshee_blt.cur_y, src, dest, pattern, voodoo->vram[dst_addr]);
#if 0
bansheeblt_log("%i,%i : sdp=%02x,%02x,%02x res=%02x\n", voodoo->banshee_blt.cur_x, voodoo->banshee_blt.cur_y, src, dest, pattern, voodoo->vram[dst_addr]);
#endif
voodoo->changedvram[dst_addr >> 12] = changeframecount;
break;
}
@@ -937,6 +953,9 @@ do_screen_to_screen_stretch_line(voodoo_t *voodoo, uint8_t *src_p, int src_x, in
voodoo->changedvram[dst_addr >> 12] = changeframecount;
break;
}
default:
break;
}
}
@@ -1063,16 +1082,16 @@ step_line(voodoo_t *voodoo)
static void
banshee_do_line(voodoo_t *voodoo, int draw_last_pixel)
{
clip_t *clip = &voodoo->banshee_blt.clip[(voodoo->banshee_blt.command & COMMAND_CLIP_SEL) ? 1 : 0];
uint8_t rop = voodoo->banshee_blt.command >> 24;
int dx = ABS(voodoo->banshee_blt.dstX - voodoo->banshee_blt.srcX);
int dy = ABS(voodoo->banshee_blt.dstY - voodoo->banshee_blt.srcY);
int x_inc = (voodoo->banshee_blt.dstX > voodoo->banshee_blt.srcX) ? 1 : -1;
int y_inc = (voodoo->banshee_blt.dstY > voodoo->banshee_blt.srcY) ? 1 : -1;
int x = voodoo->banshee_blt.srcX;
int y = voodoo->banshee_blt.srcY;
int error;
uint32_t stipple = (voodoo->banshee_blt.command & COMMAND_STIPPLE_LINE) ? voodoo->banshee_blt.lineStipple : ~0;
const clip_t *clip = &voodoo->banshee_blt.clip[(voodoo->banshee_blt.command & COMMAND_CLIP_SEL) ? 1 : 0];
uint8_t rop = voodoo->banshee_blt.command >> 24;
int dx = ABS(voodoo->banshee_blt.dstX - voodoo->banshee_blt.srcX);
int dy = ABS(voodoo->banshee_blt.dstY - voodoo->banshee_blt.srcY);
int x_inc = (voodoo->banshee_blt.dstX > voodoo->banshee_blt.srcX) ? 1 : -1;
int y_inc = (voodoo->banshee_blt.dstY > voodoo->banshee_blt.srcY) ? 1 : -1;
int x = voodoo->banshee_blt.srcX;
int y = voodoo->banshee_blt.srcY;
int error;
uint32_t stipple = (voodoo->banshee_blt.command & COMMAND_STIPPLE_LINE) ? voodoo->banshee_blt.lineStipple : ~0;
if (dx > dy) /*X major*/
{
@@ -1143,12 +1162,12 @@ banshee_polyfill_start(voodoo_t *voodoo)
static void
banshee_polyfill_continue(voodoo_t *voodoo, uint32_t data)
{
clip_t *clip = &voodoo->banshee_blt.clip[(voodoo->banshee_blt.command & COMMAND_CLIP_SEL) ? 1 : 0];
uint8_t *pattern_mono = (uint8_t *) voodoo->banshee_blt.colorPattern;
int use_pattern_trans = (voodoo->banshee_blt.command & (COMMAND_PATTERN_MONO | COMMAND_TRANS_MONO)) == (COMMAND_PATTERN_MONO | COMMAND_TRANS_MONO);
uint8_t rop = voodoo->banshee_blt.command >> 24;
int y = MAX(voodoo->banshee_blt.ly[0], voodoo->banshee_blt.ry[0]);
int y_end;
const clip_t *clip = &voodoo->banshee_blt.clip[(voodoo->banshee_blt.command & COMMAND_CLIP_SEL) ? 1 : 0];
const uint8_t *pattern_mono = (uint8_t *) voodoo->banshee_blt.colorPattern;
int use_pattern_trans = (voodoo->banshee_blt.command & (COMMAND_PATTERN_MONO | COMMAND_TRANS_MONO)) == (COMMAND_PATTERN_MONO | COMMAND_TRANS_MONO);
uint8_t rop = voodoo->banshee_blt.command >> 24;
int y = MAX(voodoo->banshee_blt.ly[0], voodoo->banshee_blt.ry[0]);
int y_end;
#if 0
bansheeblt_log("Polyfill : data %08x\n", data);

34
src/video/vid_voodoo_blitter.c
View File

@@ -163,8 +163,6 @@ voodoo_v2_blit_start(voodoo_t *voodoo)
int dst_stride = (voodoo->bltCommand & BLTCMD_DST_TILED) ? ((voodoo->bltDstXYStride & 0x3f) * 32 * 2) : (voodoo->bltDstXYStride & 0xff8);
uint32_t src_base_addr = (voodoo->bltCommand & BLTCMD_SRC_TILED) ? ((voodoo->bltSrcBaseAddr & 0x3ff) << 12) : (voodoo->bltSrcBaseAddr & 0x3ffff8);
uint32_t dst_base_addr = (voodoo->bltCommand & BLTCMD_DST_TILED) ? ((voodoo->bltDstBaseAddr & 0x3ff) << 12) : (voodoo->bltDstBaseAddr & 0x3ffff8);
int x;
int y;
#if 0
voodooblt_log("blit_start: command=%08x srcX=%i srcY=%i dstX=%i dstY=%i sizeX=%i sizeY=%i color=%04x,%04x\n",
@@ -175,13 +173,13 @@ voodoo_v2_blit_start(voodoo_t *voodoo)
switch (voodoo->bltCommand & BLIT_COMMAND_MASK) {
case BLIT_COMMAND_SCREEN_TO_SCREEN:
for (y = 0; y <= size_y; y++) {
uint16_t *src = (uint16_t *) &voodoo->fb_mem[src_base_addr + src_y * src_stride];
uint16_t *dst = (uint16_t *) &voodoo->fb_mem[dst_base_addr + dst_y * dst_stride];
int src_x = voodoo->bltSrcX;
int dst_x = voodoo->bltDstX;
for (int y = 0; y <= size_y; y++) {
const uint16_t *src = (uint16_t *) &voodoo->fb_mem[src_base_addr + src_y * src_stride];
uint16_t *dst = (uint16_t *) &voodoo->fb_mem[dst_base_addr + dst_y * dst_stride];
int src_x = voodoo->bltSrcX;
int dst_x = voodoo->bltDstX;
for (x = 0; x <= size_x; x++) {
for (int x = 0; x <= size_x; x++) {
uint16_t src_dat = src[src_x];
uint16_t dst_dat = dst[dst_x];
int rop = 0;
@@ -233,7 +231,7 @@ skip_pixel_blit:
break;
case BLIT_COMMAND_RECT_FILL:
for (y = 0; y <= size_y; y++) {
for (int y = 0; y <= size_y; y++) {
uint16_t *dst;
int dst_x = voodoo->bltDstX;
@@ -244,7 +242,7 @@ skip_pixel_blit:
} else
dst = (uint16_t *) &voodoo->fb_mem[dst_base_addr + dst_y * dst_stride];
for (x = 0; x <= size_x; x++) {
for (int x = 0; x <= size_x; x++) {
if (voodoo->bltCommand & BLIT_CLIPPING_ENABLED) {
if (dst_x < voodoo->bltClipLeft || dst_x >= voodoo->bltClipRight || dst_y < voodoo->bltClipLowY || dst_y >= voodoo->bltClipHighY)
goto skip_pixel_fill;
@@ -267,7 +265,7 @@ skip_line_fill:
dat64 = voodoo->bltColorFg | ((uint64_t) voodoo->bltColorFg << 16) | ((uint64_t) voodoo->bltColorFg << 32) | ((uint64_t) voodoo->bltColorFg << 48);
for (y = 0; y <= size_y; y++) {
for (int y = 0; y <= size_y; y++) {
uint64_t *dst;
/*This may be wrong*/
@@ -284,7 +282,7 @@ skip_line_fill:
dst = (uint64_t *) &voodoo->fb_mem[(dst_y * 512 * 8 + dst_x * 8) & voodoo->fb_mask];
for (x = 0; x <= size_x; x++)
for (int x = 0; x <= size_x; x++)
dst[x] = dat64;
dst_y++;
@@ -347,6 +345,9 @@ voodoo_v2_blit_data(voodoo_t *voodoo, uint32_t data)
case BLIT_SRC_RGB_BGRA:
src_dat = ((data & 0xf800) >> 11) | (data & 0x07c0) | ((data & 0x0038) << 11);
break;
default:
break;
}
data >>= 16;
src_bits -= 16;
@@ -375,6 +376,9 @@ voodoo_v2_blit_data(voodoo_t *voodoo, uint32_t data)
g = (data >> 16) & 0xff;
b = (data >> 24) & 0xff;
break;
default:
break;
}
switch (voodoo->bltCommand & BLIT_SRC_FORMAT) {
case BLIT_SRC_24BPP:
@@ -392,9 +396,15 @@ voodoo_v2_blit_data(voodoo_t *voodoo, uint32_t data)
b = dither_rb[b][voodoo->blt.dst_y & 3][x & 3];
src_dat = (b >> 3) | ((g & 0xfc) << 3) | ((r & 0xf8) << 8);
break;
default:
break;
}
src_bits = 0;
break;
default:
break;
}
if (SLI_ENABLED) {

4
src/video/vid_voodoo_display.c
View File

@@ -509,8 +509,8 @@ voodoo_filterline_v2(voodoo_t *voodoo, uint8_t *fil, int column, uint16_t *src,
void
voodoo_callback(void *priv)
{
voodoo_t *voodoo = (voodoo_t *) priv;
monitor_t *monitor = &monitors[voodoo->monitor_index];
voodoo_t *voodoo = (voodoo_t *) priv;
const monitor_t *monitor = &monitors[voodoo->monitor_index];
if (voodoo->fbiInit0 & FBIINIT0_VGA_PASS) {
if (voodoo->line < voodoo->v_disp) {

46
src/video/vid_voodoo_fb.c
View File

@@ -76,7 +76,7 @@ voodoo_fb_readw(uint32_t addr, void *priv)
}
if (SLI_ENABLED) {
voodoo_set_t *set = voodoo->set;
const voodoo_set_t *set = voodoo->set;
if (y & 1)
voodoo = set->voodoos[1];
@@ -117,7 +117,7 @@ voodoo_fb_readl(uint32_t addr, void *priv)
}
if (SLI_ENABLED) {
voodoo_set_t *set = voodoo->set;
const voodoo_set_t *set = voodoo->set;
if (y & 1)
voodoo = set->voodoos[1];
@@ -170,16 +170,16 @@ do_dither(voodoo_params_t *params, rgba8_t col, int x, int y)
void
voodoo_fb_writew(uint32_t addr, uint16_t val, void *priv)
{
voodoo_t *voodoo = (voodoo_t *) priv;
voodoo_params_t *params = &voodoo->params;
int x;
int y;
uint32_t write_addr;
uint32_t write_addr_aux;
rgba8_t colour_data;
uint16_t depth_data;
uint8_t alpha_data;
int write_mask = 0;
voodoo_t *voodoo = (voodoo_t *) priv;
const voodoo_params_t *params = &voodoo->params;
int x;
int y;
uint32_t write_addr;
uint32_t write_addr_aux;
rgba8_t colour_data;
uint16_t depth_data;
uint8_t alpha_data;
int write_mask = 0;
colour_data.r = colour_data.g = colour_data.b = colour_data.a = 0;
@@ -310,17 +310,17 @@ skip_pixel:
void
voodoo_fb_writel(uint32_t addr, uint32_t val, void *priv)
{
voodoo_t *voodoo = (voodoo_t *) priv;
voodoo_params_t *params = &voodoo->params;
int x;
int y;
uint32_t write_addr;
uint32_t write_addr_aux;
rgba8_t colour_data[2];
uint16_t depth_data[2];
uint8_t alpha_data[2];
int write_mask = 0;
int count = 1;
voodoo_t *voodoo = (voodoo_t *) priv;
const voodoo_params_t *params = &voodoo->params;
int x;
int y;
uint32_t write_addr;
uint32_t write_addr_aux;
rgba8_t colour_data[2];
uint16_t depth_data[2];
uint8_t alpha_data[2];
int write_mask = 0;
int count = 1;
depth_data[0] = depth_data[1] = voodoo->params.zaColor & 0xffff;
alpha_data[0] = alpha_data[1] = voodoo->params.zaColor >> 24;

4
src/video/vid_voodoo_reg.c
View File

@@ -1121,6 +1121,7 @@ voodoo_reg_writel(uint32_t addr, uint32_t val, void *priv)
}
break;
}
fallthrough;
case SST_nccTable0_I2:
if (!(val & (1 << 31))) {
if (chip & CHIP_TREX0) {
@@ -1359,5 +1360,8 @@ voodoo_reg_writel(uint32_t addr, uint32_t val, void *priv)
case SST_leftOverlayBuf:
voodoo->leftOverlayBuf = val;
break;
default:
break;
}
}

21
src/video/vid_voodoo_render.c
View File

@@ -475,6 +475,9 @@ voodoo_tmu_fetch_and_blend(voodoo_t *voodoo, voodoo_params_t *params, voodoo_sta
case TC_MSELECT_LOD_FRAC:
factor_r = factor_g = factor_b = state->lod_frac[1];
break;
default:
break;
}
if (!c_reverse) {
r = (-state->tex_r[1] * (factor_r + 1)) >> 8;
@@ -520,6 +523,9 @@ voodoo_tmu_fetch_and_blend(voodoo_t *voodoo, voodoo_params_t *params, voodoo_sta
case TCA_MSELECT_LOD_FRAC:
factor_a = state->lod_frac[1];
break;
default:
break;
}
if (!a_reverse)
a = (-state->tex_a[1] * ((factor_a ^ 0xff) + 1)) >> 8;
@@ -575,6 +581,9 @@ voodoo_tmu_fetch_and_blend(voodoo_t *voodoo, voodoo_params_t *params, voodoo_sta
case TC_MSELECT_LOD_FRAC:
factor_r = factor_g = factor_b = state->lod_frac[0];
break;
default:
break;
}
if (!c_reverse) {
r = (r * (factor_r + 1)) >> 8;
@@ -622,6 +631,9 @@ voodoo_tmu_fetch_and_blend(voodoo_t *voodoo, voodoo_params_t *params, voodoo_sta
case TCA_MSELECT_LOD_FRAC:
factor_a = state->lod_frac[0];
break;
default:
break;
}
if (a_reverse)
a = (a * ((factor_a ^ 0xff) + 1)) >> 8;
@@ -1073,6 +1085,9 @@ voodoo_half_triangle(voodoo_t *voodoo, voodoo_params_t *params, voodoo_state_t *
cother_g = src_g;
cother_b = src_b;
break;
default:
break;
}
switch (cca_localselect) {
@@ -1460,15 +1475,15 @@ voodoo_triangle(voodoo_t *voodoo, voodoo_params_t *params, int odd_even)
vertexCy_adjusted = (state.vertexCy + 7) >> 4;
if (state.vertexBy - state.vertexAy)
state.dxAB = (int) ((((int64_t) state.vertexBx << 12) - ((int64_t) state.vertexAx << 12)) << 4) / (int) (state.vertexBy - state.vertexAy);
state.dxAB = (int) ((((int64_t) state.vertexBx << 12) - ((int64_t) state.vertexAx << 12)) << 4) / (state.vertexBy - state.vertexAy);
else
state.dxAB = 0;
if (state.vertexCy - state.vertexAy)
state.dxAC = (int) ((((int64_t) state.vertexCx << 12) - ((int64_t) state.vertexAx << 12)) << 4) / (int) (state.vertexCy - state.vertexAy);
state.dxAC = (int) ((((int64_t) state.vertexCx << 12) - ((int64_t) state.vertexAx << 12)) << 4) / (state.vertexCy - state.vertexAy);
else
state.dxAC = 0;
if (state.vertexCy - state.vertexBy)
state.dxBC = (int) ((((int64_t) state.vertexCx << 12) - ((int64_t) state.vertexBx << 12)) << 4) / (int) (state.vertexCy - state.vertexBy);
state.dxBC = (int) ((((int64_t) state.vertexCx << 12) - ((int64_t) state.vertexBx << 12)) << 4) / (state.vertexCy - state.vertexBy);
else
state.dxBC = 0;

28
src/video/vid_voodoo_texture.c
View File

@@ -192,7 +192,9 @@ voodoo_recalc_tex3(voodoo_t *voodoo, int tmu)
if ((voodoo->params.textureMode[tmu] & TEXTUREMODE_TRILINEAR) && (voodoo->params.tLOD[tmu] & LOD_ODD))
tex_lod++; /*Skip LOD 0*/
// voodoo_texture_log("TMU %i: %08x\n", tmu, voodoo->params.textureMode[tmu]);
#if 0
voodoo_texture_log("TMU %i: %08x\n", tmu, voodoo->params.textureMode[tmu]);
#endif
for (lod = 0; lod <= LOD_MAX + 1; lod++) {
if (voodoo->params.tLOD[tmu] & LOD_TMULTIBASEADDR) {
switch (tex_lod) {
@@ -302,18 +304,22 @@ voodoo_use_texture(voodoo_t *voodoo, voodoo_params_t *params, int tmu)
lod_min = (params->tLOD[tmu] >> 2) & 15;
lod_max = (params->tLOD[tmu] >> 8) & 15;
// voodoo_texture_log(" add new texture to %i tformat=%i %08x LOD=%i-%i tmu=%i\n", c, voodoo->params.tformat[tmu], params->texBaseAddr[tmu], lod_min, lod_max, tmu);
#if 0
voodoo_texture_log(" add new texture to %i tformat=%i %08x LOD=%i-%i tmu=%i\n", c, voodoo->params.tformat[tmu], params->texBaseAddr[tmu], lod_min, lod_max, tmu);
#endif
lod_min = MIN(lod_min, 8);
lod_max = MIN(lod_max, 8);
for (int lod = lod_min; lod <= lod_max; lod++) {
uint32_t *base = &voodoo->texture_cache[tmu][c].data[texture_offset[lod]];
uint32_t tex_addr = params->tex_base[tmu][lod] & voodoo->texture_mask;
int x;
int y;
int shift = 8 - params->tex_lod[tmu][lod];
rgba_u *pal;
uint32_t *base = &voodoo->texture_cache[tmu][c].data[texture_offset[lod]];
uint32_t tex_addr = params->tex_base[tmu][lod] & voodoo->texture_mask;
int x;
int y;
int shift = 8 - params->tex_lod[tmu][lod];
const rgba_u *pal;
// voodoo_texture_log(" LOD %i : %08x - %08x %i %i,%i\n", lod, params->tex_base[tmu][lod] & voodoo->texture_mask, addr, voodoo->params.tformat[tmu], voodoo->params.tex_w_mask[tmu][lod],voodoo->params.tex_h_mask[tmu][lod]);
#if 0
voodoo_texture_log(" LOD %i : %08x - %08x %i %i,%i\n", lod, params->tex_base[tmu][lod] & voodoo->texture_mask, addr, voodoo->params.tformat[tmu], voodoo->params.tex_w_mask[tmu][lod],voodoo->params.tex_h_mask[tmu][lod]);
#endif
switch (params->tformat[tmu]) {
case TEX_RGB332:
@@ -566,7 +572,9 @@ flush_texture_cache(voodoo_t *voodoo, uint32_t dirty_addr, int tmu)
if (addr_end_masked < addr_start_masked)
addr_end_masked = voodoo->texture_mask + 1;
if (dirty_addr >= addr_start_masked && dirty_addr < addr_end_masked) {
// voodoo_texture_log(" Evict texture %i %08x\n", c, voodoo->texture_cache[tmu][c].base);
#if 0
voodoo_texture_log(" Evict texture %i %08x\n", c, voodoo->texture_cache[tmu][c].base);
#endif
if (voodoo->texture_cache[tmu][c].refcount != voodoo->texture_cache[tmu][c].refcount_r[0] || (voodoo->render_threads == 2 && voodoo->texture_cache[tmu][c].refcount != voodoo->texture_cache[tmu][c].refcount_r[1]))
wait_for_idle = 1;

36
src/video/video.c
View File

@@ -308,13 +308,13 @@ static png_infop info_ptr[MONITORS_NUM];
static void
video_take_screenshot_monitor(const char *fn, uint32_t *buf, int start_x, int start_y, int row_len, int monitor_index)
{
png_bytep *b_rgb = NULL;
FILE *fp = NULL;
uint32_t temp = 0x00000000;
blit_data_t *blit_data_ptr = monitors[monitor_index].mon_blit_data_ptr;
png_bytep *b_rgb = NULL;
FILE *fp = NULL;
uint32_t temp = 0x00000000;
const blit_data_t *blit_data_ptr = monitors[monitor_index].mon_blit_data_ptr;
/* create file */
fp = plat_fopen((char *) fn, (char *) "wb");
fp = plat_fopen(fn, (const char *) "wb");
if (!fp) {
video_log("[video_take_screenshot] File %s could not be opened for writing", fn);
return;
@@ -423,8 +423,8 @@ void *
video_transform_copy(void *__restrict _Dst, const void *__restrict _Src, size_t _Size)
#endif
{
uint32_t *dest_ex = (uint32_t *) _Dst;
uint32_t *src_ex = (uint32_t *) _Src;
uint32_t *dest_ex = (uint32_t *) _Dst;
const uint32_t *src_ex = (const uint32_t *) _Src;
_Size /= sizeof(uint32_t);
@@ -496,8 +496,8 @@ pixel_to_color(uint8_t *pixels32, uint8_t pos)
uint32_t temp;
temp = *(pixels32 + pos) & 0x03;
switch (temp) {
case 0:
default:
case 0:
return 0x00;
case 1:
return 0x07;
@@ -774,23 +774,27 @@ hline(bitmap_t *b, int x1, int y, int x2, uint32_t col)
}
void
blit(bitmap_t *src, bitmap_t *dst, int x1, int y1, int x2, int y2, int xs, int ys)
blit(UNUSED(bitmap_t *src), UNUSED(bitmap_t *dst), UNUSED(int x1), UNUSED(int y1), UNUSED(int x2), UNUSED(int y2), UNUSED(int xs), UNUSED(int ys))
{
//
}
void
stretch_blit(bitmap_t *src, bitmap_t *dst, int x1, int y1, int xs1, int ys1, int x2, int y2, int xs2, int ys2)
stretch_blit(UNUSED(bitmap_t *src), UNUSED(bitmap_t *dst), UNUSED(int x1), UNUSED(int y1), UNUSED(int xs1), UNUSED(int ys1), UNUSED(int x2), UNUSED(int y2), UNUSED(int xs2), UNUSED(int ys2))
{
//
}
void
rectfill(bitmap_t *b, int x1, int y1, int x2, int y2, uint32_t col)
rectfill(UNUSED(bitmap_t *b), UNUSED(int x1), UNUSED(int y1), UNUSED(int x2), UNUSED(int y2), UNUSED(uint32_t col))
{
//
}
void
set_palette(PALETTE p)
set_palette(UNUSED(PALETTE p))
{
//
}
void
@@ -1115,8 +1119,10 @@ uint32_t
video_color_transform(uint32_t color)
{
uint8_t *clr8 = (uint8_t *) &color;
/* if (!video_grayscale && !invert_display)
return color; */
#if 0
if (!video_grayscale && !invert_display)
return color;
#endif
if (video_grayscale) {
if (video_graytype) {
if (video_graytype == 1)
@@ -1129,7 +1135,7 @@ video_color_transform(uint32_t color)
case 2:
case 3:
case 4:
color = (uint32_t) shade[video_grayscale][color];
color = shade[video_grayscale][color];
break;
default:
clr8[3] = 0;