834 lines
25 KiB
C
834 lines
25 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.
|
|
*
|
|
* MDSI Genius VHR emulation.
|
|
*
|
|
*
|
|
*
|
|
* Authors: John Elliott, <jce@seasip.info>
|
|
* Miran Grca, <mgrca8@gmail.com>
|
|
*
|
|
* Copyright 2008-2019 John Elliott.
|
|
* Copyright 2016-2019 Miran Grca.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <wchar.h>
|
|
#include <86box/86box.h>
|
|
#include "cpu.h"
|
|
#include <86box/io.h>
|
|
#include <86box/timer.h>
|
|
#include <86box/pit.h>
|
|
#include <86box/mem.h>
|
|
#include <86box/rom.h>
|
|
#include <86box/device.h>
|
|
#include <86box/plat.h>
|
|
#include <86box/video.h>
|
|
|
|
#define BIOS_ROM_PATH "roms/video/genius/8x12.bin"
|
|
|
|
#define GENIUS_XSIZE 728
|
|
#define GENIUS_YSIZE 1008
|
|
|
|
extern uint8_t fontdat8x12[256][16];
|
|
|
|
static video_timings_t timing_genius = { .type = VIDEO_ISA, .write_b = 8, .write_w = 16, .write_l = 32, .read_b = 8, .read_w = 16, .read_l = 32 };
|
|
|
|
/* I'm at something of a disadvantage writing this emulation: I don't have an
|
|
* MDSI Genius card, nor do I have the BIOS extension (VHRBIOS.SYS) that came
|
|
* with it. What I do have are the GEM and Windows 1.04 drivers, plus a driver
|
|
* for a later MCA version of the card. The latter can be found at
|
|
* <http://files.mpoli.fi/hardware/DISPLAY/GENIUS/> and is necessary if you
|
|
* want the Windows driver to work.
|
|
*
|
|
* This emulation appears to work correctly with:
|
|
* The MCA drivers GMC_ANSI.SYS and INS_ANSI.SYS
|
|
* The GEM driver SDGEN9.VGA
|
|
* The Windows 1.04 driver GENIUS.DRV
|
|
*
|
|
* As far as I can see, the card uses a fixed resolution of 728x1008 pixels.
|
|
* It has the following modes of operation:
|
|
*
|
|
* > MDA-compatible: 80x25 text, each character 9x15 pixels.
|
|
* > CGA-compatible: 640x200 mono graphics
|
|
* > Dual: MDA text in the top half, CGA graphics in the bottom
|
|
* > Native text: 80x66 text, each character 9x15 pixels.
|
|
* > Native graphics: 728x1008 mono graphics.
|
|
*
|
|
* Under the covers, this seems to translate to:
|
|
* > Text framebuffer. At B000:0000, 16k. Displayed if enable bit is set
|
|
* in the MDA control register.
|
|
* > Graphics framebuffer. In native modes goes from A000:0000 to A000:FFFF
|
|
* and B800:0000 to B800:FFFF. In CGA-compatible
|
|
* mode only the section at B800:0000 to B800:7FFF
|
|
* is visible. Displayed if enable bit is set in the
|
|
* CGA control register.
|
|
*
|
|
* Two card-specific registers control text and graphics display:
|
|
*
|
|
* 03B0: Control register.
|
|
* Bit 0: Map all graphics framebuffer into memory.
|
|
* Bit 2: Unknown. Set by GMC /M; cleared by mode set or GMC /T.
|
|
* Bit 4: Set for CGA-compatible graphics, clear for native graphics.
|
|
* Bit 5: Set for black on white, clear for white on black.
|
|
*
|
|
* 03B1: Character height register.
|
|
* Bits 0-1: Character cell height (0 => 15, 1 => 14, 2 => 13, 3 => 12)
|
|
* Bit 4: Set to double character cell height (scanlines are doubled)
|
|
* Bit 7: Unknown, seems to be set for all modes except 80x66
|
|
*
|
|
* Not having the card also means I don't have its font. According to the
|
|
* card brochure the font is an 8x12 bitmap in a 9x15 character cell. I
|
|
* therefore generated it by taking the MDA font, increasing graphics to
|
|
* 16 pixels in height and reducing the height of characters so they fit
|
|
* in an 8x12 cell if necessary.
|
|
*/
|
|
|
|
typedef struct genius_t {
|
|
mem_mapping_t mapping;
|
|
|
|
uint8_t mda_crtc[32]; /* The 'CRTC' as the host PC sees it */
|
|
int mda_crtcreg; /* Current CRTC register */
|
|
uint8_t cga_crtc[32]; /* The 'CRTC' as the host PC sees it */
|
|
int cga_crtcreg; /* Current CRTC register */
|
|
uint8_t genius_control; /* Native control register
|
|
* I think bit 0 enables the full
|
|
* framebuffer.
|
|
*/
|
|
uint8_t genius_charh; /* Native character height register:
|
|
* 00h => chars are 15 pixels high
|
|
* 81h => chars are 14 pixels high
|
|
* 83h => chars are 12 pixels high
|
|
* 90h => chars are 30 pixels high [15 x 2]
|
|
* 93h => chars are 24 pixels high [12 x 2]
|
|
*/
|
|
uint8_t genius_mode; /* Current mode (see list at top of file) */
|
|
uint8_t cga_ctrl; /* Emulated CGA control register */
|
|
uint8_t mda_ctrl; /* Emulated MDA control register */
|
|
uint8_t cga_colour; /* Emulated CGA colour register (ignored) */
|
|
|
|
uint8_t mda_stat; /* MDA status (IN 0x3BA) */
|
|
uint8_t cga_stat; /* CGA status (IN 0x3DA) */
|
|
|
|
int font; /* Current font, 0 or 1 */
|
|
int enabled; /* Display enabled, 0 or 1 */
|
|
int detach; /* Detach cursor, 0 or 1 */
|
|
|
|
uint64_t dispontime, dispofftime;
|
|
pc_timer_t timer;
|
|
|
|
int linepos, displine;
|
|
int vc;
|
|
int dispon, blink;
|
|
int vsynctime;
|
|
|
|
uint8_t *vram;
|
|
} genius_t;
|
|
|
|
static uint8_t genius_pal[4];
|
|
|
|
/* Mapping of attributes to colours, in MDA emulation mode */
|
|
static uint8_t mdaattr[256][2][2];
|
|
|
|
void genius_recalctimings(genius_t *genius);
|
|
void genius_write(uint32_t addr, uint8_t val, void *priv);
|
|
uint8_t genius_read(uint32_t addr, void *priv);
|
|
|
|
void
|
|
genius_out(uint16_t addr, uint8_t val, void *priv)
|
|
{
|
|
genius_t *genius = (genius_t *) priv;
|
|
|
|
switch (addr) {
|
|
case 0x3b0: /* Command / control register */
|
|
genius->genius_control = val;
|
|
if (val & 1)
|
|
mem_mapping_set_addr(&genius->mapping, 0xa0000, 0x28000);
|
|
else
|
|
mem_mapping_set_addr(&genius->mapping, 0xb0000, 0x10000);
|
|
break;
|
|
|
|
case 0x3b1:
|
|
genius->genius_charh = val;
|
|
break;
|
|
|
|
/* Emulated CRTC, register select */
|
|
case 0x3b2:
|
|
case 0x3b4:
|
|
case 0x3b6:
|
|
genius->mda_crtcreg = val & 31;
|
|
break;
|
|
|
|
/* Emulated CRTC, value */
|
|
case 0x3b3:
|
|
case 0x3b5:
|
|
case 0x3b7:
|
|
genius->mda_crtc[genius->mda_crtcreg] = val;
|
|
genius_recalctimings(genius);
|
|
return;
|
|
|
|
/* Emulated MDA control register */
|
|
case 0x3b8:
|
|
genius->mda_ctrl = val;
|
|
return;
|
|
|
|
/* Emulated CRTC, register select */
|
|
case 0x3d0:
|
|
case 0x3d2:
|
|
case 0x3d4:
|
|
case 0x3d6:
|
|
genius->cga_crtcreg = val & 31;
|
|
break;
|
|
|
|
/* Emulated CRTC, value */
|
|
case 0x3d1:
|
|
case 0x3d3:
|
|
case 0x3d5:
|
|
case 0x3d7:
|
|
genius->cga_crtc[genius->cga_crtcreg] = val;
|
|
genius_recalctimings(genius);
|
|
return;
|
|
|
|
/* Emulated CGA control register */
|
|
case 0x3d8:
|
|
genius->cga_ctrl = val;
|
|
return;
|
|
/* Emulated CGA colour register */
|
|
case 0x3d9:
|
|
genius->cga_colour = val;
|
|
return;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
uint8_t
|
|
genius_in(uint16_t addr, void *priv)
|
|
{
|
|
const genius_t *genius = (genius_t *) priv;
|
|
uint8_t ret = 0xff;
|
|
|
|
switch (addr) {
|
|
case 0x3b0:
|
|
case 0x3b2:
|
|
case 0x3b4:
|
|
case 0x3b6:
|
|
ret = genius->mda_crtcreg;
|
|
break;
|
|
case 0x3b1:
|
|
case 0x3b3:
|
|
case 0x3b5:
|
|
case 0x3b7:
|
|
ret = genius->mda_crtc[genius->mda_crtcreg];
|
|
break;
|
|
case 0x3b8:
|
|
ret = genius->mda_ctrl;
|
|
break;
|
|
case 0x3ba:
|
|
ret = genius->mda_stat;
|
|
break;
|
|
case 0x3d0:
|
|
case 0x3d2:
|
|
case 0x3d4:
|
|
case 0x3d6:
|
|
ret = genius->cga_crtcreg;
|
|
break;
|
|
case 0x3d1:
|
|
case 0x3d3:
|
|
case 0x3d5:
|
|
case 0x3d7:
|
|
ret = genius->cga_crtc[genius->cga_crtcreg];
|
|
break;
|
|
case 0x3d8:
|
|
ret = genius->cga_ctrl;
|
|
break;
|
|
case 0x3d9:
|
|
ret = genius->cga_colour;
|
|
break;
|
|
case 0x3da:
|
|
ret = genius->cga_stat;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
genius_waitstates(void)
|
|
{
|
|
int ws_array[16] = { 3, 4, 5, 6, 7, 8, 4, 5, 6, 7, 8, 4, 5, 6, 7, 8 };
|
|
int ws;
|
|
|
|
ws = ws_array[cycles & 0xf];
|
|
cycles -= ws;
|
|
}
|
|
|
|
void
|
|
genius_write(uint32_t addr, uint8_t val, void *priv)
|
|
{
|
|
genius_t *genius = (genius_t *) priv;
|
|
genius_waitstates();
|
|
|
|
if (genius->genius_control & 1) {
|
|
if ((addr >= 0xa0000) && (addr < 0xb0000))
|
|
addr = (addr - 0xa0000) & 0xffff;
|
|
else if ((addr >= 0xb0000) && (addr < 0xb8000))
|
|
addr = ((addr - 0xb0000) & 0x7fff) + 0x10000;
|
|
else
|
|
addr = ((addr - 0xb8000) & 0xffff) + 0x18000;
|
|
} else {
|
|
/* If hi-res memory is disabled, only visible in the B000 segment */
|
|
if (addr >= 0xb8000)
|
|
addr = (addr & 0x3FFF) + 0x18000;
|
|
else
|
|
addr = (addr & 0x7FFF) + 0x10000;
|
|
}
|
|
|
|
genius->vram[addr] = val;
|
|
}
|
|
|
|
uint8_t
|
|
genius_read(uint32_t addr, void *priv)
|
|
{
|
|
const genius_t *genius = (genius_t *) priv;
|
|
uint8_t ret;
|
|
|
|
genius_waitstates();
|
|
|
|
if (genius->genius_control & 1) {
|
|
if ((addr >= 0xa0000) && (addr < 0xb0000))
|
|
addr = (addr - 0xa0000) & 0xffff;
|
|
else if ((addr >= 0xb0000) && (addr < 0xb8000))
|
|
addr = ((addr - 0xb0000) & 0x7fff) + 0x10000;
|
|
else
|
|
addr = ((addr - 0xb8000) & 0xffff) + 0x18000;
|
|
} else {
|
|
/* If hi-res memory is disabled, only visible in the B000 segment */
|
|
if (addr >= 0xb8000)
|
|
addr = (addr & 0x3FFF) + 0x18000;
|
|
else
|
|
addr = (addr & 0x7FFF) + 0x10000;
|
|
}
|
|
|
|
ret = genius->vram[addr];
|
|
return ret;
|
|
}
|
|
|
|
void
|
|
genius_recalctimings(genius_t *genius)
|
|
{
|
|
double disptime;
|
|
double _dispontime;
|
|
double _dispofftime;
|
|
|
|
disptime = 0x31;
|
|
_dispontime = 0x28;
|
|
_dispofftime = disptime - _dispontime;
|
|
_dispontime *= MDACONST;
|
|
_dispofftime *= MDACONST;
|
|
genius->dispontime = (uint64_t) (_dispontime);
|
|
genius->dispofftime = (uint64_t) (_dispofftime);
|
|
}
|
|
|
|
static int
|
|
genius_lines(genius_t *genius)
|
|
{
|
|
int ret = 350;
|
|
|
|
switch (genius->genius_charh & 0x13) {
|
|
case 0x00:
|
|
ret = 990; /* 80x66 */
|
|
break;
|
|
case 0x01:
|
|
ret = 980; /* 80x70 */
|
|
break;
|
|
case 0x02:
|
|
ret = 988; /* Guess: 80x76 */
|
|
break;
|
|
case 0x03:
|
|
ret = 984; /* 80x82 */
|
|
break;
|
|
case 0x10:
|
|
ret = 375; /* Logic says 80x33 but it appears to be 80x25 */
|
|
break;
|
|
case 0x11:
|
|
ret = 490; /* Guess: 80x35, fits the logic as well, half of 80x70 */
|
|
break;
|
|
case 0x12:
|
|
ret = 494; /* Guess: 80x38 */
|
|
break;
|
|
case 0x13:
|
|
ret = 492; /* 80x41 */
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Draw a single line of the screen in either text mode */
|
|
static void
|
|
genius_textline(genius_t *genius, uint8_t background, int mda, int cols80)
|
|
{
|
|
int w = 80; /* 80 characters across */
|
|
int cw = 9; /* Each character is 9 pixels wide */
|
|
uint8_t chr;
|
|
uint8_t attr;
|
|
uint8_t sc;
|
|
uint8_t ctrl;
|
|
const uint8_t *crtc;
|
|
uint8_t bitmap[2];
|
|
int blink;
|
|
int c;
|
|
int row;
|
|
int charh;
|
|
int drawcursor;
|
|
int cursorline;
|
|
uint16_t addr;
|
|
uint16_t ma = (genius->mda_crtc[13] | (genius->mda_crtc[12] << 8)) & 0x3fff;
|
|
uint16_t ca = (genius->mda_crtc[15] | (genius->mda_crtc[14] << 8)) & 0x3fff;
|
|
const uint8_t *framebuf = genius->vram + 0x10000;
|
|
uint32_t col;
|
|
uint32_t dl = genius->displine;
|
|
|
|
/* Character height is 12-15 */
|
|
if (mda) {
|
|
if (genius->displine >= genius_lines(genius))
|
|
return;
|
|
|
|
crtc = genius->mda_crtc;
|
|
ctrl = genius->mda_ctrl;
|
|
charh = 15 - (genius->genius_charh & 3);
|
|
|
|
#if 0
|
|
if (genius->genius_charh & 0x10) {
|
|
row = ((dl >> 1) / charh);
|
|
sc = ((dl >> 1) % charh);
|
|
} else {
|
|
row = (dl / charh);
|
|
sc = (dl % charh);
|
|
}
|
|
#else
|
|
row = (dl / charh);
|
|
sc = (dl % charh);
|
|
#endif
|
|
} else {
|
|
if ((genius->displine < 512) || (genius->displine >= 912))
|
|
return;
|
|
|
|
crtc = genius->cga_crtc;
|
|
ctrl = genius->cga_ctrl;
|
|
framebuf += 0x08000;
|
|
|
|
dl -= 512;
|
|
w = crtc[1];
|
|
cw = 8;
|
|
charh = crtc[9] + 1;
|
|
|
|
row = ((dl >> 1) / charh);
|
|
sc = ((dl >> 1) % charh);
|
|
}
|
|
|
|
ma = (crtc[13] | (crtc[12] << 8)) & 0x3fff;
|
|
ca = (crtc[15] | (crtc[14] << 8)) & 0x3fff;
|
|
|
|
addr = ((ma & ~1) + row * w) * 2;
|
|
|
|
if (!mda)
|
|
dl += 512;
|
|
|
|
ma += (row * w);
|
|
|
|
if ((crtc[10] & 0x60) == 0x20)
|
|
cursorline = 0;
|
|
else
|
|
cursorline = ((crtc[10] & 0x1F) <= sc) && ((crtc[11] & 0x1F) >= sc);
|
|
|
|
for (int x = 0; x < w; x++) {
|
|
#if 0
|
|
if ((genius->genius_charh & 0x10) && ((addr + 2 * x) > 0x0FFF))
|
|
chr = 0x00;
|
|
if ((genius->genius_charh & 0x10) && ((addr + 2 * x + 1) > 0x0FFF))
|
|
attr = 0x00;
|
|
#endif
|
|
chr = framebuf[(addr + 2 * x) & 0x3FFF];
|
|
attr = framebuf[(addr + 2 * x + 1) & 0x3FFF];
|
|
|
|
drawcursor = ((ma == ca) && cursorline && genius->enabled && (ctrl & 8));
|
|
|
|
switch (crtc[10] & 0x60) {
|
|
case 0x00:
|
|
drawcursor = drawcursor && (genius->blink & 16);
|
|
break;
|
|
case 0x60:
|
|
drawcursor = drawcursor && (genius->blink & 32);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
blink = ((genius->blink & 16) && (ctrl & 0x20) && (attr & 0x80) && !drawcursor);
|
|
|
|
if (ctrl & 0x20)
|
|
attr &= 0x7F;
|
|
|
|
/* MDA underline */
|
|
if (mda && (sc == charh) && ((attr & 7) == 1)) {
|
|
col = mdaattr[attr][blink][1];
|
|
|
|
if (genius->genius_control & 0x20)
|
|
col ^= 15;
|
|
|
|
for (c = 0; c < cw; c++) {
|
|
if (col != background) {
|
|
if (cols80)
|
|
buffer32->line[dl][(x * cw) + c] = col;
|
|
else {
|
|
buffer32->line[dl][((x * cw) << 1) + (c << 1)] = buffer32->line[dl][((x * cw) << 1) + (c << 1) + 1] = col;
|
|
}
|
|
}
|
|
}
|
|
} else { /* Draw 8 pixels of character */
|
|
if (mda)
|
|
bitmap[0] = fontdat8x12[chr][sc];
|
|
else
|
|
bitmap[0] = fontdat[chr][sc];
|
|
|
|
for (c = 0; c < 8; c++) {
|
|
col = mdaattr[attr][blink][(bitmap[0] & (1 << (c ^ 7))) ? 1 : 0];
|
|
if (!(genius->enabled) || !(ctrl & 8))
|
|
col = mdaattr[0][0][0];
|
|
|
|
if (genius->genius_control & 0x20)
|
|
col ^= 15;
|
|
|
|
if (col != background) {
|
|
if (cols80)
|
|
buffer32->line[dl][(x * cw) + c] = col;
|
|
else {
|
|
buffer32->line[dl][((x * cw) << 1) + (c << 1)] = buffer32->line[dl][((x * cw) << 1) + (c << 1) + 1] = col;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (cw == 9) {
|
|
/* The ninth pixel column... */
|
|
if ((chr & ~0x1f) == 0xc0) {
|
|
/* Echo column 8 for the graphics chars */
|
|
if (cols80) {
|
|
col = buffer32->line[dl][(x * cw) + 7];
|
|
if (col != background)
|
|
buffer32->line[dl][(x * cw) + 8] = col;
|
|
} else {
|
|
col = buffer32->line[dl][((x * cw) << 1) + 14];
|
|
if (col != background) {
|
|
buffer32->line[dl][((x * cw) << 1) + 16] = buffer32->line[dl][((x * cw) << 1) + 17] = col;
|
|
}
|
|
}
|
|
} else { /* Otherwise fill with background */
|
|
col = mdaattr[attr][blink][0];
|
|
if (genius->genius_control & 0x20)
|
|
col ^= 15;
|
|
if (col != background) {
|
|
if (cols80)
|
|
buffer32->line[dl][(x * cw) + 8] = col;
|
|
else {
|
|
buffer32->line[dl][((x * cw) << 1) + 16] = buffer32->line[dl][((x * cw) << 1) + 17] = col;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (drawcursor) {
|
|
for (c = 0; c < cw; c++) {
|
|
if (cols80)
|
|
buffer32->line[dl][(x * cw) + c] ^= mdaattr[attr][0][1];
|
|
else {
|
|
buffer32->line[dl][((x * cw) << 1) + (c << 1)] ^= mdaattr[attr][0][1];
|
|
buffer32->line[dl][((x * cw) << 1) + (c << 1) + 1] ^= mdaattr[attr][0][1];
|
|
}
|
|
}
|
|
}
|
|
++ma;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Draw a line in the CGA 640x200 mode */
|
|
void
|
|
genius_cgaline(genius_t *genius)
|
|
{
|
|
uint32_t dat;
|
|
uint32_t addr;
|
|
uint8_t ink_f;
|
|
uint8_t ink_b;
|
|
|
|
ink_f = (genius->genius_control & 0x20) ? genius_pal[0] : genius_pal[3];
|
|
ink_b = (genius->genius_control & 0x20) ? genius_pal[3] : genius_pal[0];
|
|
|
|
/* We draw the CGA at row 512 */
|
|
if ((genius->displine < 512) || (genius->displine >= 912))
|
|
return;
|
|
|
|
addr = 0x18000 + 80 * ((genius->displine - 512) >> 2);
|
|
if ((genius->displine - 512) & 2)
|
|
addr += 0x2000;
|
|
|
|
for (uint8_t x = 0; x < 80; x++) {
|
|
dat = genius->vram[addr];
|
|
addr++;
|
|
|
|
for (uint8_t c = 0; c < 8; c++) {
|
|
if (dat & 0x80)
|
|
buffer32->line[genius->displine][(x << 3) + c] = ink_f;
|
|
else
|
|
buffer32->line[genius->displine][(x << 3) + c] = ink_b;
|
|
|
|
dat = dat << 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Draw a line in the native high-resolution mode */
|
|
void
|
|
genius_hiresline(genius_t *genius)
|
|
{
|
|
uint32_t dat;
|
|
uint32_t addr;
|
|
uint8_t ink_f;
|
|
uint8_t ink_b;
|
|
|
|
ink_f = (genius->genius_control & 0x20) ? genius_pal[0] : genius_pal[3];
|
|
ink_b = (genius->genius_control & 0x20) ? genius_pal[3] : genius_pal[0];
|
|
|
|
/* The first 512 lines live at A0000 */
|
|
if (genius->displine < 512)
|
|
addr = 128 * genius->displine;
|
|
else /* The second 496 live at B8000 */
|
|
addr = 0x18000 + (128 * (genius->displine - 512));
|
|
|
|
for (uint8_t x = 0; x < 91; x++) {
|
|
dat = genius->vram[addr + x];
|
|
|
|
for (uint8_t c = 0; c < 8; c++) {
|
|
if (dat & 0x80)
|
|
buffer32->line[genius->displine][(x << 3) + c] = ink_f;
|
|
else
|
|
buffer32->line[genius->displine][(x << 3) + c] = ink_b;
|
|
|
|
dat = dat << 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
genius_poll(void *priv)
|
|
{
|
|
genius_t *genius = (genius_t *) priv;
|
|
uint8_t background;
|
|
|
|
if (!genius->linepos) {
|
|
timer_advance_u64(&genius->timer, genius->dispofftime);
|
|
genius->cga_stat |= 1;
|
|
genius->mda_stat |= 1;
|
|
genius->linepos = 1;
|
|
|
|
if (genius->dispon) {
|
|
if (genius->genius_control & 0x20)
|
|
background = genius_pal[3];
|
|
else
|
|
background = genius_pal[0];
|
|
|
|
if (genius->displine == 0)
|
|
video_wait_for_buffer();
|
|
|
|
/* Start off with a blank line */
|
|
for (uint16_t x = 0; x < GENIUS_XSIZE; x++)
|
|
buffer32->line[genius->displine][x] = background;
|
|
|
|
/* If graphics display enabled, draw graphics on top
|
|
* of the blanked line */
|
|
if (genius->cga_ctrl & 8) {
|
|
if (((genius->genius_control & 0x11) == 0x00) || (genius->genius_control & 0x08))
|
|
genius_cgaline(genius);
|
|
else if ((genius->genius_control & 0x11) == 0x01)
|
|
genius_hiresline(genius);
|
|
else {
|
|
if (genius->cga_ctrl & 2)
|
|
genius_cgaline(genius);
|
|
else {
|
|
if (genius->cga_ctrl & 1)
|
|
genius_textline(genius, background, 0, 1);
|
|
else
|
|
genius_textline(genius, background, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* If MDA display is enabled, draw MDA text on top
|
|
* of the lot */
|
|
if (genius->mda_ctrl & 8)
|
|
genius_textline(genius, background, 1, 1);
|
|
|
|
video_process_8(GENIUS_XSIZE, genius->displine);
|
|
}
|
|
genius->displine++;
|
|
/* Hardcode a fixed refresh rate and VSYNC timing */
|
|
if (genius->displine == 1008) { /* Start of VSYNC */
|
|
genius->cga_stat |= 8;
|
|
genius->mda_stat |= 8;
|
|
genius->dispon = 0;
|
|
}
|
|
if (genius->displine == 1040) { /* End of VSYNC */
|
|
genius->displine = 0;
|
|
genius->cga_stat &= ~8;
|
|
genius->mda_stat &= ~8;
|
|
genius->dispon = 1;
|
|
}
|
|
} else {
|
|
if (genius->dispon) {
|
|
genius->cga_stat &= ~1;
|
|
genius->mda_stat &= ~1;
|
|
}
|
|
timer_advance_u64(&genius->timer, genius->dispontime);
|
|
genius->linepos = 0;
|
|
|
|
if (genius->displine == 1008) {
|
|
/* Hardcode GENIUS_XSIZE * GENIUS_YSIZE window size */
|
|
if (GENIUS_XSIZE != xsize || GENIUS_YSIZE != ysize) {
|
|
xsize = GENIUS_XSIZE;
|
|
ysize = GENIUS_YSIZE;
|
|
if (xsize < 64)
|
|
xsize = 656;
|
|
if (ysize < 32)
|
|
ysize = 200;
|
|
set_screen_size(xsize, ysize);
|
|
|
|
if (video_force_resize_get())
|
|
video_force_resize_set(0);
|
|
}
|
|
|
|
video_blit_memtoscreen(0, 0, xsize, ysize);
|
|
|
|
frames++;
|
|
/* Fixed 728x1008 resolution */
|
|
video_res_x = GENIUS_XSIZE;
|
|
video_res_y = GENIUS_YSIZE;
|
|
video_bpp = 1;
|
|
genius->blink++;
|
|
}
|
|
}
|
|
}
|
|
|
|
void *
|
|
genius_init(UNUSED(const device_t *info))
|
|
{
|
|
genius_t *genius = malloc(sizeof(genius_t));
|
|
|
|
memset(genius, 0, sizeof(genius_t));
|
|
|
|
video_inform(VIDEO_FLAG_TYPE_MDA, &timing_genius);
|
|
|
|
/* 160k video RAM */
|
|
genius->vram = malloc(0x28000);
|
|
|
|
loadfont(BIOS_ROM_PATH, 4);
|
|
|
|
timer_add(&genius->timer, genius_poll, genius, 1);
|
|
|
|
/* Occupy memory between 0xB0000 and 0xBFFFF (moves to 0xA0000 in
|
|
* high-resolution modes) */
|
|
mem_mapping_add(&genius->mapping, 0xb0000, 0x10000, genius_read, NULL, NULL, genius_write, NULL, NULL, NULL, MEM_MAPPING_EXTERNAL, genius);
|
|
|
|
/* Respond to both MDA and CGA I/O ports */
|
|
io_sethandler(0x03b0, 0x000C, genius_in, NULL, NULL, genius_out, NULL, NULL, genius);
|
|
io_sethandler(0x03d0, 0x0010, genius_in, NULL, NULL, genius_out, NULL, NULL, genius);
|
|
|
|
genius_pal[0] = 0 + 16; /* 0 */
|
|
genius_pal[1] = 8 + 16; /* 8 */
|
|
genius_pal[2] = 7 + 16; /* 7 */
|
|
genius_pal[3] = 15 + 16; /* F */
|
|
|
|
/* MDA attributes */
|
|
/* I don't know if the Genius's MDA emulation actually does
|
|
* emulate bright / non-bright. For the time being pretend it does. */
|
|
for (uint16_t c = 0; c < 256; c++) {
|
|
mdaattr[c][0][0] = mdaattr[c][1][0] = mdaattr[c][1][1] = genius_pal[0];
|
|
if (c & 8)
|
|
mdaattr[c][0][1] = genius_pal[3];
|
|
else
|
|
mdaattr[c][0][1] = genius_pal[2];
|
|
}
|
|
mdaattr[0x70][0][1] = genius_pal[0];
|
|
mdaattr[0x70][0][0] = mdaattr[0x70][1][0] = mdaattr[0x70][1][1] = genius_pal[3];
|
|
mdaattr[0xF0][0][1] = genius_pal[0];
|
|
mdaattr[0xF0][0][0] = mdaattr[0xF0][1][0] = mdaattr[0xF0][1][1] = genius_pal[3];
|
|
mdaattr[0x78][0][1] = genius_pal[2];
|
|
mdaattr[0x78][0][0] = mdaattr[0x78][1][0] = mdaattr[0x78][1][1] = genius_pal[3];
|
|
mdaattr[0xF8][0][1] = genius_pal[2];
|
|
mdaattr[0xF8][0][0] = mdaattr[0xF8][1][0] = mdaattr[0xF8][1][1] = genius_pal[3];
|
|
mdaattr[0x00][0][1] = mdaattr[0x00][1][1] = genius_pal[0];
|
|
mdaattr[0x08][0][1] = mdaattr[0x08][1][1] = genius_pal[0];
|
|
mdaattr[0x80][0][1] = mdaattr[0x80][1][1] = genius_pal[0];
|
|
mdaattr[0x88][0][1] = mdaattr[0x88][1][1] = genius_pal[0];
|
|
|
|
/* Start off in 80x25 text mode */
|
|
genius->cga_stat = 0xF4;
|
|
genius->genius_mode = 2;
|
|
genius->enabled = 1;
|
|
genius->genius_charh = 0x90; /* Native character height register */
|
|
genius->genius_control |= 0x10;
|
|
return genius;
|
|
}
|
|
|
|
void
|
|
genius_close(void *priv)
|
|
{
|
|
genius_t *genius = (genius_t *) priv;
|
|
|
|
free(genius->vram);
|
|
free(genius);
|
|
}
|
|
|
|
static int
|
|
genius_available(void)
|
|
{
|
|
return rom_present(BIOS_ROM_PATH);
|
|
}
|
|
|
|
void
|
|
genius_speed_changed(void *priv)
|
|
{
|
|
genius_t *genius = (genius_t *) priv;
|
|
|
|
genius_recalctimings(genius);
|
|
}
|
|
|
|
const device_t genius_device = {
|
|
.name = "Genius VHR",
|
|
.internal_name = "genius",
|
|
.flags = DEVICE_ISA,
|
|
.local = 0,
|
|
.init = genius_init,
|
|
.close = genius_close,
|
|
.reset = NULL,
|
|
{ .available = genius_available },
|
|
.speed_changed = genius_speed_changed,
|
|
.force_redraw = NULL,
|
|
.config = NULL
|
|
};
|