271 lines
7.1 KiB
C
271 lines
7.1 KiB
C
/*
|
|
* 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.
|
|
*
|
|
* STG1702 true colour RAMDAC emulation.
|
|
*
|
|
*
|
|
*
|
|
* Authors: Sarah Walker, <https://pcem-emulator.co.uk/>
|
|
* Miran Grca, <mgrca8@gmail.com>
|
|
*
|
|
* Copyright 2008-2018 Sarah Walker.
|
|
* Copyright 2016-2018 Miran Grca.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <wchar.h>
|
|
#include <86box/86box.h>
|
|
#include <86box/device.h>
|
|
#include <86box/mem.h>
|
|
#include <86box/timer.h>
|
|
#include <86box/video.h>
|
|
#include <86box/vid_svga.h>
|
|
#include <86box/plat_unused.h>
|
|
|
|
typedef struct stg_ramdac_t {
|
|
int magic_count, index;
|
|
uint8_t regs[256];
|
|
uint8_t command;
|
|
} stg_ramdac_t;
|
|
|
|
static int stg_state_read[2][8] = {
|
|
{1, 2, 3, 4, 0, 0, 0, 0},
|
|
{ 1, 2, 3, 4, 5, 6, 7, 7}
|
|
};
|
|
static int stg_state_write[8] = { 0, 0, 0, 0, 0, 6, 7, 7 };
|
|
|
|
void
|
|
stg_ramdac_set_bpp(svga_t *svga, stg_ramdac_t *ramdac)
|
|
{
|
|
if (ramdac->command & 0x8) {
|
|
switch (ramdac->regs[3]) {
|
|
default:
|
|
case 0:
|
|
case 5:
|
|
case 7:
|
|
svga->bpp = 8;
|
|
break;
|
|
case 1:
|
|
case 2:
|
|
case 8:
|
|
svga->bpp = 15;
|
|
break;
|
|
case 3:
|
|
case 6:
|
|
svga->bpp = 16;
|
|
break;
|
|
case 4:
|
|
case 9:
|
|
svga->bpp = 24;
|
|
break;
|
|
}
|
|
} else {
|
|
switch (ramdac->command >> 5) {
|
|
default:
|
|
case 0:
|
|
svga->bpp = 8;
|
|
break;
|
|
case 5:
|
|
svga->bpp = 15;
|
|
break;
|
|
case 6:
|
|
svga->bpp = 16;
|
|
break;
|
|
case 7:
|
|
svga->bpp = 24;
|
|
break;
|
|
}
|
|
}
|
|
|
|
svga_recalctimings(svga);
|
|
}
|
|
|
|
void
|
|
stg_ramdac_out(uint16_t addr, uint8_t val, void *priv, svga_t *svga)
|
|
{
|
|
stg_ramdac_t *ramdac = (stg_ramdac_t *) priv;
|
|
int didwrite;
|
|
int old;
|
|
|
|
switch (addr) {
|
|
case 0x3c6:
|
|
switch (ramdac->magic_count) {
|
|
/* 0 = PEL mask register */
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
break;
|
|
case 4: /* REG06 */
|
|
old = ramdac->command;
|
|
ramdac->command = val;
|
|
if ((old ^ val) & 8)
|
|
stg_ramdac_set_bpp(svga, ramdac);
|
|
else {
|
|
if ((old ^ val) & 0xE0)
|
|
stg_ramdac_set_bpp(svga, ramdac);
|
|
}
|
|
break;
|
|
case 5:
|
|
ramdac->index = (ramdac->index & 0xff00) | val;
|
|
break;
|
|
case 6:
|
|
ramdac->index = (ramdac->index & 0xff) | (val << 8);
|
|
break;
|
|
case 7:
|
|
if (ramdac->index < 0x100)
|
|
ramdac->regs[ramdac->index] = val;
|
|
if ((ramdac->index == 3) && (ramdac->command & 8))
|
|
stg_ramdac_set_bpp(svga, ramdac);
|
|
ramdac->index++;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
didwrite = (ramdac->magic_count >= 4);
|
|
ramdac->magic_count = stg_state_write[ramdac->magic_count & 7];
|
|
if (didwrite)
|
|
return;
|
|
break;
|
|
case 0x3c7:
|
|
case 0x3c8:
|
|
case 0x3c9:
|
|
ramdac->magic_count = 0;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
svga_out(addr, val, svga);
|
|
}
|
|
|
|
uint8_t
|
|
stg_ramdac_in(uint16_t addr, void *priv, svga_t *svga)
|
|
{
|
|
stg_ramdac_t *ramdac = (stg_ramdac_t *) priv;
|
|
uint8_t temp = 0xff;
|
|
|
|
switch (addr) {
|
|
case 0x3c6:
|
|
switch (ramdac->magic_count) {
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
temp = 0xff;
|
|
break;
|
|
case 4:
|
|
temp = ramdac->command;
|
|
break;
|
|
case 5:
|
|
temp = ramdac->index & 0xff;
|
|
break;
|
|
case 6:
|
|
temp = ramdac->index >> 8;
|
|
break;
|
|
case 7:
|
|
switch (ramdac->index) {
|
|
case 0:
|
|
temp = 0x44;
|
|
break;
|
|
case 1:
|
|
temp = 0x03;
|
|
break;
|
|
case 7:
|
|
temp = 0x88;
|
|
break;
|
|
default:
|
|
if (ramdac->index < 0x100)
|
|
temp = ramdac->regs[ramdac->index];
|
|
else
|
|
temp = 0xff;
|
|
break;
|
|
}
|
|
ramdac->index++;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
ramdac->magic_count = stg_state_read[(ramdac->command & 0x10) ? 1 : 0][ramdac->magic_count & 7];
|
|
return temp;
|
|
case 0x3c7:
|
|
case 0x3c8:
|
|
case 0x3c9:
|
|
ramdac->magic_count = 0;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return svga_in(addr, svga);
|
|
}
|
|
|
|
float
|
|
stg_getclock(int clock, void *priv)
|
|
{
|
|
stg_ramdac_t *ramdac = (stg_ramdac_t *) priv;
|
|
float t;
|
|
int m;
|
|
int n;
|
|
int n2;
|
|
const uint16_t *c;
|
|
|
|
if (clock == 0)
|
|
return 25175000.0;
|
|
if (clock == 1)
|
|
return 28322000.0;
|
|
|
|
clock ^= 1; /*Clocks 2 and 3 seem to be reversed*/
|
|
c = (uint16_t *) &ramdac->regs[0x20 + (clock << 1)];
|
|
m = (*c & 0xff) + 2; /* B+2 */
|
|
n = ((*c >> 8) & 0x1f) + 2; /* N1+2 */
|
|
n2 = ((*c >> 13) & 0x07); /* D */
|
|
n2 = (1 << n2);
|
|
t = (14318184.0f * (float) m) / (float) (n * n2);
|
|
|
|
return t;
|
|
}
|
|
|
|
static void *
|
|
stg_ramdac_init(UNUSED(const device_t *info))
|
|
{
|
|
stg_ramdac_t *ramdac = (stg_ramdac_t *) malloc(sizeof(stg_ramdac_t));
|
|
memset(ramdac, 0, sizeof(stg_ramdac_t));
|
|
|
|
return ramdac;
|
|
}
|
|
|
|
static void
|
|
stg_ramdac_close(void *priv)
|
|
{
|
|
stg_ramdac_t *ramdac = (stg_ramdac_t *) priv;
|
|
|
|
if (ramdac)
|
|
free(ramdac);
|
|
}
|
|
|
|
const device_t stg_ramdac_device = {
|
|
.name = "SGS-Thompson STG170x RAMDAC",
|
|
.internal_name = "stg_ramdac",
|
|
.flags = 0,
|
|
.local = 0,
|
|
.init = stg_ramdac_init,
|
|
.close = stg_ramdac_close,
|
|
.reset = NULL,
|
|
{ .available = NULL },
|
|
.speed_changed = NULL,
|
|
.force_redraw = NULL,
|
|
.config = NULL
|
|
};
|