86Box/src/video/vid_ht216.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.
 *
 *          Video 7 VGA 1024i emulation.
 *
 *
 *
 * Authors: Sarah Walker, <https://pcem-emulator.co.uk/>
 *          Miran Grca, <mgrca8@gmail.com>
 *
 *          Copyright 2019 Sarah Walker.
 *          Copyright 2019 Miran Grca.
 */
#include <stdarg.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <wchar.h>
#define HAVE_STDARG_H
#include <86box/86box.h>
#include "cpu.h"
#include <86box/io.h>
#include <86box/mca.h>
#include <86box/mem.h>
#include <86box/timer.h>
#include <86box/pic.h>
#include <86box/rom.h>
#include <86box/device.h>
#include <86box/video.h>
#include <86box/vid_8514a.h>
#include <86box/vid_xga.h>
#include <86box/vid_svga.h>
#include <86box/vid_svga_render.h>
#include <86box/vid_ati_eeprom.h>
#include <86box/vid_ati_mach8.h>
#include <86box/plat_fallthrough.h>
#include <86box/plat_unused.h>

typedef struct ht216_t {
    svga_t svga;

    mem_mapping_t linear_mapping;

    rom_t bios_rom;

    uint32_t vram_mask, linear_base;
    uint8_t  adjust_cursor, monitor_type;

    int ext_reg_enable;
    int isabus;
    int mca;

    uint8_t  read_bank_reg[2], write_bank_reg[2];
    uint16_t id, misc;
    uint32_t read_banks[2], write_banks[2];

    uint8_t bg_latch[8];
    uint8_t fg_latch[4];
    uint8_t bg_plane_sel, fg_plane_sel;

    uint8_t ht_regs[256];
    uint8_t extensions, reg_3cb;

    uint8_t pos_regs[8];
} ht216_t;

#define HT_MISC_PAGE_SEL (1 << 5)

/*Shifts CPU VRAM read address by 3 bits, for use with fat pixel color expansion*/
#define HT_REG_C8_MOVSB    (1 << 0)
#define HT_REG_C8_E256     (1 << 4)
#define HT_REG_C8_XLAM     (1 << 6)

#define HT_REG_CD_P8PCEXP  (1 << 0)
#define HT_REG_CD_FP8PCEXP (1 << 1)
#define HT_REG_CD_BMSKSL   (3 << 2)
#define HT_REG_CD_RMWMDE   (1 << 5)
/*Use GDC data rotate as offset when reading VRAM data into latches*/
#define HT_REG_CD_ASTODE (1 << 6)
#define HT_REG_CD_EXALU  (1 << 7)

#define HT_REG_E0_SBAE   (1 << 7)

#define HT_REG_F9_XPSEL  (1 << 0)

/*Enables A[14:15] of VRAM address in chain-4 modes*/
#define HT_REG_FC_ECOLRE (1 << 2)

#define HT_REG_FE_FBRC   (1 << 1)
#define HT_REG_FE_FBMC   (3 << 2)
#define HT_REG_FE_FBRSL  (3 << 4)

void ht216_remap(ht216_t *ht216);

void    ht216_out(uint16_t addr, uint8_t val, void *priv);
uint8_t ht216_in(uint16_t addr, void *priv);

#define BIOS_G2_GC205_PATH              "roms/video/video7/BIOS.BIN"
#define BIOS_VIDEO7_VGA_1024I_PATH      "roms/video/video7/Video Seven VGA 1024i - BIOS - v2.19 - 435-0062-05 - U17 - 27C256.BIN"
#define BIOS_RADIUS_SVGA_MULTIVIEW_PATH "roms/video/video7/U18.BIN"
#define BIOS_HT216_32_PATH              "roms/video/video7/HT21632.BIN"

static video_timings_t timing_v7vga_isa = { .type = VIDEO_ISA, .write_b = 3, .write_w = 3, .write_l = 6, .read_b = 5, .read_w = 5, .read_l = 10 };
static video_timings_t timing_v7vga_mca = { .type = VIDEO_MCA, .write_b = 4, .write_w = 5, .write_l = 10, .read_b = 5, .read_w = 5, .read_l = 10 };
static video_timings_t timing_v7vga_vlb = { .type = VIDEO_BUS, .write_b = 5, .write_w = 5, .write_l = 9, .read_b = 20, .read_w = 20, .read_l = 30 };

#ifdef ENABLE_HT216_LOG
int ht216_do_log = ENABLE_HT216_LOG;

static void
ht216_log(const char *fmt, ...)
{
    va_list ap;

    if (ht216_do_log) {
        va_start(ap, fmt);
        pclog_ex(fmt, ap);
        va_end(ap);
    }
}
#else
#    define ht216_log(fmt, ...)
#endif

/*Remap address for chain-4/doubleword style layout*/
static __inline uint32_t
dword_remap(svga_t *svga, uint32_t in_addr)
{
    if (svga->packed_chain4)
        return in_addr;
    return ((in_addr & 0xfffc) << 2) | ((in_addr & 0x30000) >> 14) | (in_addr & ~0x3ffff);
}

static void
ht216_recalc_bank_regs(ht216_t *ht216, int mode)
{
    const svga_t *svga = &ht216->svga;

    if (mode) {
        ht216->read_bank_reg[0]  = ht216->ht_regs[0xe8];
        ht216->write_bank_reg[0] = ht216->ht_regs[0xe8];
        ht216->read_bank_reg[1]  = ht216->ht_regs[0xe9];
        ht216->write_bank_reg[1] = ht216->ht_regs[0xe9];
    } else {
        ht216->read_bank_reg[0]  = ((ht216->ht_regs[0xf6] & 0xc) << 4);
        ht216->read_bank_reg[1]  = ((ht216->ht_regs[0xf6] & 0xc) << 4);
        ht216->write_bank_reg[0] = ((ht216->ht_regs[0xf6] & 0x3) << 6);
        ht216->write_bank_reg[1] = ((ht216->ht_regs[0xf6] & 0x3) << 6);

        if (svga->packed_chain4 || (ht216->ht_regs[0xfc] & HT_REG_FC_ECOLRE)) {
            ht216->read_bank_reg[0] |= (ht216->misc & 0x20);
            ht216->read_bank_reg[1] |= (ht216->misc & 0x20);
            ht216->write_bank_reg[0] |= (ht216->misc & 0x20);
            ht216->write_bank_reg[1] |= (ht216->misc & 0x20);
        }

        if (svga->packed_chain4 || ((ht216->ht_regs[0xfc] & 0x06) == 0x04)) {
            ht216->read_bank_reg[0] |= ((ht216->ht_regs[0xf9] & 1) << 4);
            ht216->read_bank_reg[1] |= ((ht216->ht_regs[0xf9] & 1) << 4);
            ht216->write_bank_reg[0] |= ((ht216->ht_regs[0xf9] & 1) << 4);
            ht216->write_bank_reg[1] |= ((ht216->ht_regs[0xf9] & 1) << 4);
        }
    }
}

void
ht216_out(uint16_t addr, uint8_t val, void *priv)
{
    ht216_t *ht216 = (ht216_t *) priv;
    svga_t  *svga  = &ht216->svga;
    uint8_t  old;

    ht216_log("ht216 %i out %04X %02X %04X:%04X\n", svga->miscout & 1, addr, val, CS, cpu_state.pc);

    if (((addr & 0xfff0) == 0x3d0 || (addr & 0xfff0) == 0x3b0) && !(svga->miscout & 1))
        addr ^= 0x60;

    switch (addr) {
        case 0x3c2:
            /*Bit 17 of the display memory address, only active on odd/even modes, has no effect on graphics modes.*/
            ht216->misc   = val;
            svga->miscout = val;
            ht216_log("HT216 misc val = %02x, mode = 0, chain4 = %x\n", val, svga->chain4);
            ht216_recalc_bank_regs(ht216, 0);
            ht216_remap(ht216);
            svga_recalctimings(svga);
            break;

        case 0x3c4:
            svga->seqaddr = val;
            break;

        case 0x3c5:
            if (svga->seqaddr == 4) {
                svga->chain2_write = !(val & 4);
                svga->chain4       = val & 8;
                ht216_remap(ht216);
            } else if (svga->seqaddr == 6) {
                if (val == 0xea)
                    ht216->ext_reg_enable = 1;
                else if (val == 0xae)
                    ht216->ext_reg_enable = 0;
#ifdef ENABLE_HT216_LOG
                /* Functionality to output to the console a dump of all registers for debugging purposes. */
            } else if (svga->seqaddr == 0x7f) {
                ht216_log(" 8  |   0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F\n");
                ht216_log("----+-------------------------------------------------\n");
                ht216_log(" 8  |  %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n",
                          ht216->ht_regs[0x80], ht216->ht_regs[0x81], ht216->ht_regs[0x82], ht216->ht_regs[0x83],
                          ht216->ht_regs[0x84], ht216->ht_regs[0x85], ht216->ht_regs[0x86], ht216->ht_regs[0x87],
                          ht216->ht_regs[0x88], ht216->ht_regs[0x89], ht216->ht_regs[0x8a], ht216->ht_regs[0x8b],
                          ht216->ht_regs[0x8c], ht216->ht_regs[0x8d], ht216->ht_regs[0x8e], ht216->ht_regs[0x8f]);
                ht216_log(" 9  |  %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n",
                          ht216->ht_regs[0x90], ht216->ht_regs[0x91], ht216->ht_regs[0x92], ht216->ht_regs[0x93],
                          ht216->ht_regs[0x94], ht216->ht_regs[0x95], ht216->ht_regs[0x96], ht216->ht_regs[0x97],
                          ht216->ht_regs[0x98], ht216->ht_regs[0x99], ht216->ht_regs[0x9a], ht216->ht_regs[0x9b],
                          ht216->ht_regs[0x9c], ht216->ht_regs[0x9d], ht216->ht_regs[0x9e], ht216->ht_regs[0x9f]);
                ht216_log(" A  |  %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n",
                          ht216->ht_regs[0xa0], ht216->ht_regs[0xa1], ht216->ht_regs[0xa2], ht216->ht_regs[0xa3],
                          ht216->ht_regs[0xa4], ht216->ht_regs[0xa5], ht216->ht_regs[0xa6], ht216->ht_regs[0xa7],
                          ht216->ht_regs[0xa8], ht216->ht_regs[0xa9], ht216->ht_regs[0xaa], ht216->ht_regs[0xab],
                          ht216->ht_regs[0xac], ht216->ht_regs[0xad], ht216->ht_regs[0xae], ht216->ht_regs[0xaf]);
                ht216_log(" B  |  %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n",
                          ht216->ht_regs[0xb0], ht216->ht_regs[0xb1], ht216->ht_regs[0xb2], ht216->ht_regs[0xb3],
                          ht216->ht_regs[0xb4], ht216->ht_regs[0xb5], ht216->ht_regs[0xb6], ht216->ht_regs[0xb7],
                          ht216->ht_regs[0xb8], ht216->ht_regs[0xb9], ht216->ht_regs[0xba], ht216->ht_regs[0xbb],
                          ht216->ht_regs[0xbc], ht216->ht_regs[0xbd], ht216->ht_regs[0xbe], ht216->ht_regs[0xbf]);
                ht216_log(" C  |  %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n",
                          ht216->ht_regs[0xc0], ht216->ht_regs[0xc1], ht216->ht_regs[0xc2], ht216->ht_regs[0xc3],
                          ht216->ht_regs[0xc4], ht216->ht_regs[0xc5], ht216->ht_regs[0xc6], ht216->ht_regs[0xc7],
                          ht216->ht_regs[0xc8], ht216->ht_regs[0xc9], ht216->ht_regs[0xca], ht216->ht_regs[0xcb],
                          ht216->ht_regs[0xcc], ht216->ht_regs[0xcd], ht216->ht_regs[0xce], ht216->ht_regs[0xcf]);
                ht216_log(" D  |  %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n",
                          ht216->ht_regs[0xd0], ht216->ht_regs[0xd1], ht216->ht_regs[0xd2], ht216->ht_regs[0xd3],
                          ht216->ht_regs[0xd4], ht216->ht_regs[0xd5], ht216->ht_regs[0xd6], ht216->ht_regs[0xd7],
                          ht216->ht_regs[0xd8], ht216->ht_regs[0xd9], ht216->ht_regs[0xda], ht216->ht_regs[0xdb],
                          ht216->ht_regs[0xdc], ht216->ht_regs[0xdd], ht216->ht_regs[0xde], ht216->ht_regs[0xdf]);
                ht216_log(" E  |  %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n",
                          ht216->ht_regs[0xe0], ht216->ht_regs[0xe1], ht216->ht_regs[0xe2], ht216->ht_regs[0xe3],
                          ht216->ht_regs[0xe4], ht216->ht_regs[0xe5], ht216->ht_regs[0xe6], ht216->ht_regs[0xe7],
                          ht216->ht_regs[0xe8], ht216->ht_regs[0xe9], ht216->ht_regs[0xea], ht216->ht_regs[0xeb],
                          ht216->ht_regs[0xec], ht216->ht_regs[0xed], ht216->ht_regs[0xee], ht216->ht_regs[0xef]);
                ht216_log(" F  |  %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n",
                          ht216->ht_regs[0xf0], ht216->ht_regs[0xf1], ht216->ht_regs[0xf2], ht216->ht_regs[0xf3],
                          ht216->ht_regs[0xf4], ht216->ht_regs[0xf5], ht216->ht_regs[0xf6], ht216->ht_regs[0xf7],
                          ht216->ht_regs[0xf8], ht216->ht_regs[0xf9], ht216->ht_regs[0xfa], ht216->ht_regs[0xfb],
                          ht216->ht_regs[0xfc], ht216->ht_regs[0xfd], ht216->ht_regs[0xfe], ht216->ht_regs[0xff]);
                return;
#endif
            } else if (svga->seqaddr >= 0x80 && ht216->ext_reg_enable) {
                old                                  = ht216->ht_regs[svga->seqaddr & 0xff];
                ht216->ht_regs[svga->seqaddr & 0xff] = val;

                switch (svga->seqaddr & 0xff) {
                    case 0x83:
                        svga->attraddr = val & 0x1f;
                        svga->attrff   = !!(val & 0x80);
                        break;

                    case 0x94:
                    case 0xff:
                        svga->hwcursor.addr = ((ht216->ht_regs[0x94] << 6) | 0xc000 | ((ht216->ht_regs[0xff] & 0x60) << 11)) << 2;
                        svga->hwcursor.addr &= svga->vram_mask;
                        if (svga->crtc[0x17] == 0xeb) /*Looks like that 1024x768 mono mode expects 512K of video memory*/
                            svga->hwcursor.addr += 0x40000;
                        break;
                    case 0x9c:
                    case 0x9d:
                        svga->hwcursor.x = ht216->ht_regs[0x9d] | ((ht216->ht_regs[0x9c] & 7) << 8);
                        break;
                    case 0x9e:
                    case 0x9f:
                        svga->hwcursor.y = ht216->ht_regs[0x9f] | ((ht216->ht_regs[0x9e] & 3) << 8);
                        break;

                    case 0xa0:
                        svga->latch.b[0] = val;
                        break;
                    case 0xa1:
                        svga->latch.b[1] = val;
                        break;
                    case 0xa2:
                        svga->latch.b[2] = val;
                        break;
                    case 0xa3:
                        svga->latch.b[3] = val;
                        break;

                    case 0xa4:
                    case 0xf8:
                        svga->fullchange = changeframecount;
                        svga_recalctimings(svga);
                        break;

                    case 0xa5:
                        svga->hwcursor.ena = !!(val & 0x80);
                        break;

                    case 0xc0:
                        break;

                    case 0xc1:
                        break;

                    case 0xc8:
                        if ((old ^ val) & HT_REG_C8_E256) {
                            svga->fullchange = changeframecount;
                            svga_recalctimings(svga);
                        }
                        ht216_remap(ht216);
                        break;

                    case 0xca:
                        if (ht216->id == 0x7861)
                            svga_recalctimings(svga);
                        break;

                    case 0xc9:
                    case 0xcf:
                        ht216_remap(ht216);
                        break;

                    case 0xe0:
                        svga->adv_flags &= ~FLAG_RAMDAC_SHIFT;
                        if (val & 0x04)
                            svga->adv_flags |= FLAG_RAMDAC_SHIFT;
                        svga_recalctimings(svga);
                        fallthrough;
                    /*Bank registers*/
                    case 0xe8:
                    case 0xe9:
                        ht216_log("HT216 reg 0x%02x write = %02x, mode = 1, chain4 = %x\n", svga->seqaddr & 0xff, val, svga->chain4);
                        ht216_recalc_bank_regs(ht216, 1);
                        ht216_remap(ht216);
                        break;

                    case 0xec:
                        ht216->fg_latch[0] = val;
                        break;
                    case 0xed:
                        ht216->fg_latch[1] = val;
                        break;
                    case 0xee:
                        ht216->fg_latch[2] = val;
                        break;
                    case 0xef:
                        ht216->fg_latch[3] = val;
                        break;

                    case 0xf0:
                        ht216->fg_latch[ht216->fg_plane_sel] = val;
                        ht216->fg_plane_sel                  = (ht216->fg_plane_sel + 1) & 3;
                        break;

                    case 0xf1:
                        ht216->bg_plane_sel = val & 3;
                        ht216->fg_plane_sel = (val & 0x30) >> 4;
                        break;

                    case 0xf2:
                        svga->latch.b[ht216->bg_plane_sel] = val;
                        ht216->bg_plane_sel                = (ht216->bg_plane_sel + 1) & 3;
                        break;

                    case 0xf6:
                        /*Bits 18 and 19 of the display memory address*/
                        ht216_log("HT216 reg 0xf6 write = %02x, mode = 0, chain4 = %x, vram mask = %08x, cr17 = %02x\n", val, svga->chain4, svga->vram_display_mask, svga->crtc[0x17]);
                        ht216_recalc_bank_regs(ht216, 0);
                        ht216_remap(ht216);
                        svga->fullchange = changeframecount;
                        svga_recalctimings(svga);
                        break;

                    case 0xf9:
                        /*Bit 16 of the display memory address, only active when in chain4 mode and 256 color mode.*/
                        ht216_log("HT216 reg 0xf9 write = %02x, mode = 0, chain4 = %x\n", val & HT_REG_F9_XPSEL, svga->chain4);
                        ht216_recalc_bank_regs(ht216, 0);
                        ht216_remap(ht216);
                        break;

                    case 0xfc:
                        ht216_log("HT216 reg 0xfc write = %02x, mode = 0, chain4 = %x, bit 7 = %02x, packedchain = %02x\n", val, svga->chain4, val & 0x80, val & 0x20);
                        svga->packed_chain4 = !!(val & 0x20);
                        ht216_recalc_bank_regs(ht216, 0);
                        ht216_remap(ht216);
                        svga->fullchange = changeframecount;
                        svga_recalctimings(svga);
                        break;

                    default:
                        break;
                }
                return;
            }
            break;

        case 0x3c6:
        case 0x3c7:
        case 0x3c8:
        case 0x3c9:
            if (ht216->id == 0x7152)
                sc1148x_ramdac_out(addr, 0, val, svga->ramdac, svga);
            else
                svga_out(addr, val, svga);
            return;

        case 0x3cb:
            if (ht216->id == 0x7152) {
                ht216->reg_3cb = val;
                svga_set_ramdac_type(svga, (val & 0x20) ? RAMDAC_6BIT : RAMDAC_8BIT);
            }
            break;

        case 0x3cf:
            if (svga->gdcaddr == 5) {
                svga->chain2_read = val & 0x10;
                ht216_remap(ht216);
            } else if (svga->gdcaddr == 6) {
                if (val & 8)
                    svga->banked_mask = 0x7fff;
                else
                    svga->banked_mask = 0xffff;
            }

            if (svga->gdcaddr <= 8)
                svga->fast = (svga->gdcreg[8] == 0xff && !(svga->gdcreg[3] & 0x18) && !svga->gdcreg[1]) && svga->chain4 && svga->packed_chain4;
            break;

        case 0x3D4:
            svga->crtcreg = val & 0x3f;
            return;
        case 0x3D5:
            if ((svga->crtcreg < 7) && (svga->crtc[0x11] & 0x80))
                return;
            if ((svga->crtcreg == 7) && (svga->crtc[0x11] & 0x80))
                val = (svga->crtc[7] & ~0x10) | (val & 0x10);

            old                       = svga->crtc[svga->crtcreg];
            svga->crtc[svga->crtcreg] = val;

            if (old != val) {
                if (svga->crtcreg < 0xe || svga->crtcreg > 0x10) {
                    if ((svga->crtcreg == 0xc) || (svga->crtcreg == 0xd)) {
                        svga->fullchange = 3;
                        svga->ma_latch   = ((svga->crtc[0xc] << 8) | svga->crtc[0xd]) + ((svga->crtc[8] & 0x60) >> 5);
                    } else {
                        svga->fullchange = changeframecount;
                        svga_recalctimings(svga);
                    }
                }
            }
            break;

        case 0x46e8:
            io_removehandler(0x03c0, 0x0020, ht216_in, NULL, NULL, ht216_out, NULL, NULL, ht216);
            mem_mapping_disable(&svga->mapping);
            mem_mapping_disable(&ht216->linear_mapping);
            if (val & 8) {
                io_sethandler(0x03c0, 0x0020, ht216_in, NULL, NULL, ht216_out, NULL, NULL, ht216);
                mem_mapping_enable(&svga->mapping);
                ht216_remap(ht216);
            }
            break;

        default:
            break;
    }

    svga_out(addr, val, svga);
}

uint8_t
ht216_in(uint16_t addr, void *priv)
{
    ht216_t *ht216 = (ht216_t *) priv;
    svga_t  *svga  = &ht216->svga;
    uint8_t  ret   = 0xff;

    if (((addr & 0xfff0) == 0x3d0 || (addr & 0xfff0) == 0x3b0) && !(svga->miscout & 1))
        addr ^= 0x60;

    switch (addr) {
        case 0x105:
            if (ht216->isabus && (ht216->id == 0x7152)) {
                ret &= ~0x03;
                return ret;
            }
            break;

        case 0x3c4:
            return svga->seqaddr;

        case 0x3c5:
            if (svga->seqaddr == 6)
                return ht216->ext_reg_enable;
            else if (svga->seqaddr >= 0x80) {
                if (ht216->ext_reg_enable) {
                    ret = ht216->ht_regs[svga->seqaddr & 0xff];

                    switch (svga->seqaddr & 0xff) {
                        case 0x83:
                            if (svga->attrff)
                                ret = svga->attraddr | 0x80;
                            else
                                ret = svga->attraddr;
                            break;

                        case 0x8e:
                            ret = ht216->id & 0xff;
                            break;
                        case 0x8f:
                            ret = (ht216->id >> 8) & 0xff;
                            break;

                        case 0xa0:
                            ret = svga->latch.b[0];
                            break;
                        case 0xa1:
                            ret = svga->latch.b[1];
                            break;
                        case 0xa2:
                            ret = svga->latch.b[2];
                            break;
                        case 0xa3:
                            ret = svga->latch.b[3];
                            break;

                        case 0xf0:
                            ret                 = ht216->fg_latch[ht216->fg_plane_sel];
                            ht216->fg_plane_sel = 0;
                            break;

                        case 0xf2:
                            ret                 = svga->latch.b[ht216->bg_plane_sel];
                            ht216->bg_plane_sel = 0;
                            break;

                        default:
                            break;
                    }

                    return ret;
                } else
                    return 0xff;
            }
            break;

        case 0x3c6:
        case 0x3c7:
        case 0x3c8:
        case 0x3c9:
            if (ht216->id == 0x7152)
                return sc1148x_ramdac_in(addr, 0, svga->ramdac, svga);
            return svga_in(addr, svga);

        case 0x3cb:
            if (ht216->id == 0x7152)
                return ht216->reg_3cb;
            break;

        case 0x3cc:
            return svga->miscout;

        case 0x3D4:
            return svga->crtcreg;
        case 0x3D5:
            if (svga->crtcreg == 0x1f)
                return svga->crtc[0xc] ^ 0xea;
            return svga->crtc[svga->crtcreg];

        default:
            break;
    }

    return svga_in(addr, svga);
}

void
ht216_remap(ht216_t *ht216)
{
    svga_t *svga = &ht216->svga;

    mem_mapping_disable(&ht216->linear_mapping);
    if (ht216->ht_regs[0xc8] & HT_REG_C8_XLAM) {
        /*Linear mapping enabled*/
        ht216_log("Linear mapping enabled\n");
        ht216->linear_base = ((ht216->ht_regs[0xc9] & 0xf) << 20) | (ht216->ht_regs[0xcf] << 24);
        mem_mapping_disable(&svga->mapping);
        mem_mapping_set_addr(&ht216->linear_mapping, ht216->linear_base, 0x100000);
    }

    ht216->read_banks[0]  = ht216->read_bank_reg[0] << 12;
    ht216->write_banks[0] = ht216->write_bank_reg[0] << 12;

    /* Split bank: two banks used */
    if (ht216->ht_regs[0xe0] & HT_REG_E0_SBAE) {
        ht216->read_banks[1]  = ht216->read_bank_reg[1] << 12;
        ht216->write_banks[1] = ht216->write_bank_reg[1] << 12;
    }

    if (!svga->chain4) {
        ht216->read_banks[0]  = ((ht216->read_banks[0] & 0xc0000) >> 2) | (ht216->read_banks[0] & 0xffff);
        ht216->read_banks[1]  = ((ht216->read_banks[1] & 0xc0000) >> 2) | (ht216->read_banks[1] & 0xffff);
        ht216->write_banks[0] = ((ht216->write_banks[0] & 0xc0000) >> 2) | (ht216->write_banks[0] & 0xffff);
        ht216->write_banks[1] = ((ht216->write_banks[1] & 0xc0000) >> 2) | (ht216->write_banks[1] & 0xffff);
    }

    if (!(ht216->ht_regs[0xe0] & HT_REG_E0_SBAE)) {
        ht216->read_banks[1]  = ht216->read_banks[0] + 0x8000;
        ht216->write_banks[1] = ht216->write_banks[0] + 0x8000;
    }

#ifdef ENABLE_HT216_LOG
    ht216_log("Registers: %02X, %02X, %02X, %02X, %02X\n", ht216->misc, ht216->ht_regs[0xe8], ht216->ht_regs[0xe9],
              ht216->ht_regs[0xf6], ht216->ht_regs[0xf9]);
    ht216_log("Banks: %08X, %08X, %08X, %08X\n", ht216->read_banks[0], ht216->read_banks[1],
              ht216->write_banks[0], ht216->write_banks[1]);
#endif
}

void
ht216_recalctimings(svga_t *svga)
{
    ht216_t   *ht216      = (ht216_t *) svga->priv;
    ibm8514_t *dev        = (ibm8514_t *) svga->dev8514;
    mach_t    *mach       = (mach_t *) svga->ext8514;
    int      high_res_256 = 0;


    if (ht216->id == 0x7861) {
        if (ht216->ht_regs[0xe0] & 0x20) {
            if (ht216->ht_regs[0xca] & 0x01)
                svga->htotal |= 0x200;
            if (ht216->ht_regs[0xca] & 0x04)
                svga->hblankstart |= 0x200;
        }
    }

    switch ((((((svga->miscout >> 2) & 3) || ((ht216->ht_regs[0xa4] >> 2) & 3)) | ((ht216->ht_regs[0xa4] >> 2) & 4)) || ((ht216->ht_regs[0xf8] >> 5) & 0x0f)) | ((ht216->ht_regs[0xf8] << 1) & 8)) {
        case 0:
        case 1:
            break;
        case 4:
            svga->clock = (cpuclock * (double) (1ULL << 32)) / 50350000.0;
            break;
        case 5:
            svga->clock = (cpuclock * (double) (1ULL << 32)) / 65000000.0;
            break;
        case 7:
            svga->clock = (cpuclock * (double) (1ULL << 32)) / 40000000.0;
            break;
        default:
            svga->clock = (cpuclock * (double) (1ULL << 32)) / 36000000.0;
            break;
    }

    svga->ma_latch |= ((ht216->ht_regs[0xf6] & 0x30) << 12);

    if (ht216->ht_regs[0xf6] & 0x80)
        svga->ma_latch = ((ht216->ht_regs[0xf6] & 0x30) << 12);

    svga->interlace = ht216->ht_regs[0xe0] & 0x01;

    if (svga->interlace)
        high_res_256 = (svga->htotal << 3) > (svga->vtotal << 2);
    else
        high_res_256 = (svga->htotal << 3) > (svga->vtotal << 1);

    ht216->adjust_cursor = 0;

    if (!svga->scrblank && svga->attr_palette_enable) {
        if (!(svga->gdcreg[6] & 1) && !(svga->attrregs[0x10] & 1)) { /*Text mode*/
            if (svga->seqregs[1] & 8) /*40 column*/
                svga->render = svga_render_text_40;
            else
                svga->render = svga_render_text_80;

            if (ibm8514_active && (svga->dev8514 != NULL)) {
                if (svga->ext8514 != NULL) {
                    if (!(dev->accel.advfunc_cntl & 0x01) && !(mach->accel.clock_sel & 0x01)) /*FIXME: Possibly a BIOS bug within the V7 chips when it's used with a 8514/A card?*/
                        dev->on &= ~0x01;
                }
            }
        } else {
            if (svga->crtc[0x17] == 0xeb) {
                svga->rowoffset <<= 1;
                svga->render = svga_render_2bpp_headland_highres;
            }

            if (svga->bpp == 8) {
                ht216_log("regC8 = %02x, gdcreg5 bit 6 = %02x, no lowres = %02x, regf8 bit 7 = %02x, regfc = %02x\n", ht216->ht_regs[0xc8] & HT_REG_C8_E256, svga->gdcreg[5] & 0x40, !svga->lowres, ht216->ht_regs[0xf6] & 0x80, ht216->ht_regs[0xfc] & HT_REG_FC_ECOLRE);
                if (((ht216->ht_regs[0xc8] & HT_REG_C8_E256) || (svga->gdcreg[5] & 0x40)) && (!svga->lowres || (ht216->ht_regs[0xf6] & 0x80))) {
                    if (high_res_256) {
                        svga->hdisp >>= 1;
                        ht216->adjust_cursor = 1;
                    }
                    svga->render = svga_render_8bpp_highres;
                } else if (svga->lowres) {
                    if (high_res_256) {
                        svga->hdisp >>= 1;
                        ht216->adjust_cursor = 1;
                        svga->render         = svga_render_8bpp_highres;
                    } else {
                        ht216_log("8bpp low, packed = %02x, chain4 = %02x\n", svga->packed_chain4, svga->chain4);
                        svga->render = svga_render_8bpp_lowres;
                    }
                } else if (ht216->ht_regs[0xfc] & HT_REG_FC_ECOLRE) {
                    if (ht216->id == 0x7152) {
                        svga->hdisp = svga->crtc[1] - ((svga->crtc[5] & 0x60) >> 5);
                        if (!(svga->crtc[1] & 1))
                            svga->hdisp--;
                        svga->hdisp++;
                        svga->hdisp *= svga->dots_per_clock;
                        svga->rowoffset <<= 1;
                        if ((svga->crtc[0x17] & 0x60) == 0x20) /*Would result in a garbled screen with trailing cursor glitches*/
                            svga->crtc[0x17] |= 0x40;
                    }
                    svga->render = svga_render_8bpp_highres;
                }
            } else if (svga->bpp == 15) {
                svga->rowoffset <<= 1;
                svga->hdisp >>= 1;
                if ((svga->crtc[0x17] & 0x60) == 0x20) /*Would result in a garbled screen with trailing cursor glitches*/
                    svga->crtc[0x17] |= 0x40;
                svga->render = svga_render_15bpp_highres;
            }
        }
    }

    if (svga->crtc[0x17] == 0xeb) /*Looks like 1024x768 mono mode expects 512K of video memory*/
        svga->vram_display_mask = 0x7ffff;
    else
        svga->vram_display_mask = (ht216->ht_regs[0xf6] & 0x40) ? ht216->vram_mask : 0x3ffff;
}

static void
ht216_hwcursor_draw(svga_t *svga, int displine)
{
    const ht216_t *ht216 = (ht216_t *) svga->priv;
    int            shift = (ht216->adjust_cursor ? 2 : 1);
    uint32_t       dat[2];
    int            offset = svga->hwcursor_latch.x + svga->hwcursor_latch.xoff;
    int            width  = (ht216->adjust_cursor ? 16 : 32);

    if (ht216->adjust_cursor)
        offset >>= 1;

    if (svga->interlace && svga->hwcursor_oddeven)
        svga->hwcursor_latch.addr += 4;

    dat[0] = (svga->vram[svga->hwcursor_latch.addr] << 24) | (svga->vram[svga->hwcursor_latch.addr + 1] << 16) | (svga->vram[svga->hwcursor_latch.addr + 2] << 8) | svga->vram[svga->hwcursor_latch.addr + 3];
    dat[1] = (svga->vram[svga->hwcursor_latch.addr + 128] << 24) | (svga->vram[svga->hwcursor_latch.addr + 128 + 1] << 16) | (svga->vram[svga->hwcursor_latch.addr + 128 + 2] << 8) | svga->vram[svga->hwcursor_latch.addr + 128 + 3];

    for (int x = 0; x < width; x++) {
        if (!(dat[0] & 0x80000000))
            svga->monitor->target_buffer->line[displine][svga->x_add + offset + x] = 0;
        if (dat[1] & 0x80000000)
            svga->monitor->target_buffer->line[displine][svga->x_add + offset + x] ^= 0xffffff;

        dat[0] <<= shift;
        dat[1] <<= shift;
    }

    svga->hwcursor_latch.addr += 4;
    if (svga->interlace && !svga->hwcursor_oddeven)
        svga->hwcursor_latch.addr += 4;
}

static __inline uint8_t
extalu(int op, uint8_t input_a, uint8_t input_b)
{
    uint8_t val;

    switch (op) {
        case 0x0:
            val = 0;
            break;
        case 0x1:
            val = ~(input_a | input_b);
            break;
        case 0x2:
            val = input_a & ~input_b;
            break;
        case 0x3:
            val = ~input_b;
            break;
        case 0x4:
            val = ~input_a & input_b;
            break;
        case 0x5:
            val = ~input_a;
            break;
        case 0x6:
            val = input_a ^ input_b;
            break;
        case 0x7:
            val = ~(input_a & input_b);
            break;
        case 0x8:
            val = input_a & input_b;
            break;
        case 0x9:
            val = ~(input_a ^ input_b);
            break;
        case 0xa:
            val = input_a;
            break;
        case 0xb:
            val = input_a | ~input_b;
            break;
        case 0xc:
            val = input_b;
            break;
        case 0xd:
            val = ~input_a | input_b;
            break;
        case 0xe:
            val = input_a | input_b;
            break;
        case 0xf:
        default:
            val = 0xff;
            break;
    }

    return val;
}

static void
ht216_dm_write(ht216_t *ht216, uint32_t addr, uint8_t cpu_dat, uint8_t cpu_dat_unexpanded)
{
    svga_t *svga       = &ht216->svga;
    int     writemask2 = svga->writemask;
    int     reset_wm   = 0;
    latch_t vall;
    uint8_t i;
    uint8_t wm = svga->writemask;
    uint8_t count = 4;
    uint8_t fg_data[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };

    if (ht216->ht_regs[0xcd] & HT_REG_CD_P8PCEXP)
        writemask2 = svga->seqregs[2];

    if (!(svga->gdcreg[6] & 1))
        svga->fullchange = 2;

    if (svga->chain4) {
        writemask2 = 1 << (addr & 3);
        addr       = dword_remap(svga, addr) & ~3;
    } else if (svga->chain2_write && (svga->crtc[0x17] != 0xeb)) {
        writemask2 &= ~0xa;
        if (addr & 1)
            writemask2 <<= 1;
        addr &= ~1;
        addr <<= 2;
    } else
        addr <<= 2;

    if (addr >= svga->vram_max)
        return;

    svga->changedvram[addr >> 12] = changeframecount;

    if (ht216->ht_regs[0xcd] & HT_REG_CD_P8PCEXP)
        count = 8;

    switch (ht216->ht_regs[0xfe] & HT_REG_FE_FBMC) {
        case 0x00:
            for (i = 0; i < count; i++)
                fg_data[i] = cpu_dat;
            break;
        case 0x04:
            if (ht216->ht_regs[0xfe] & HT_REG_FE_FBRC) {
                for (i = 0; i < count; i++) {
                    if (ht216->ht_regs[0xfa] & (1 << i))
                        fg_data[i] = cpu_dat_unexpanded;
                    else if (ht216->ht_regs[0xfb] & (1 << i))
                        fg_data[i] = 0xff - cpu_dat_unexpanded;
                }
            } else {
                for (i = 0; i < count; i++) {
                    if (ht216->ht_regs[0xfa] & (1 << i))
                        fg_data[i] = ht216->ht_regs[0xf5];
                    else if (ht216->ht_regs[0xfb] & (1 << i))
                        fg_data[i] = 0xff - ht216->ht_regs[0xf5];
                }
            }
            break;
        case 0x08:
        case 0x0c:
            for (i = 0; i < count; i++)
                fg_data[i] = ht216->fg_latch[i];
            break;

        default:
            break;
    }

    switch (svga->writemode) {
        case 0:
            if ((svga->gdcreg[8] == 0xff) && !(svga->gdcreg[3] & 0x18) && (!svga->gdcreg[1] || svga->set_reset_disabled)) {
                for (i = 0; i < count; i++) {
                    if (ht216->ht_regs[0xcd] & HT_REG_CD_P8PCEXP) {
                        if (writemask2 & (0x80 >> i))
                            svga->vram[addr | i] = fg_data[i];
                    } else {
                        if (writemask2 & (1 << i))
                            svga->vram[addr | i] = fg_data[i];
                    }
                }
                return;
            } else {
                for (i = 0; i < count; i++) {
                    if (svga->gdcreg[1] & (1 << i))
                        vall.b[i] = !!(svga->gdcreg[0] & (1 << i)) * 0xff;
                    else
                        vall.b[i] = fg_data[i];
                }
            }
            break;
        case 1:
            for (i = 0; i < count; i++) {
                if (ht216->ht_regs[0xcd] & HT_REG_CD_P8PCEXP) {
                    if (writemask2 & (0x80 >> i))
                        svga->vram[addr | i] = svga->latch.b[i];
                } else {
                    if (writemask2 & (1 << i))
                        svga->vram[addr | i] = svga->latch.b[i];
                }
            }
            return;
        case 2:
            for (i = 0; i < count; i++)
                vall.b[i] = !!(cpu_dat & (1 << i)) * 0xff;

            if (!(svga->gdcreg[3] & 0x18) && (!svga->gdcreg[1] || svga->set_reset_disabled)) {
                for (i = 0; i < count; i++) {
                    if (ht216->ht_regs[0xcd] & HT_REG_CD_P8PCEXP) {
                        if (writemask2 & (0x80 >> i))
                            svga->vram[addr | i] = (vall.b[i] & svga->gdcreg[8]) | (svga->latch.b[i] & ~svga->gdcreg[8]);
                    } else {
                        if (writemask2 & (1 << i))
                            svga->vram[addr | i] = (vall.b[i] & svga->gdcreg[8]) | (svga->latch.b[i] & ~svga->gdcreg[8]);
                    }
                }
                return;
            }
            break;
        case 3:
            wm = svga->gdcreg[8];
            svga->gdcreg[8] &= cpu_dat;

            for (i = 0; i < count; i++)
                vall.b[i] = !!(svga->gdcreg[0] & (1 << i)) * 0xff;

            reset_wm = 1;
            break;

        default:
            break;
    }

    switch (svga->gdcreg[3] & 0x18) {
        case 0x00: /* Set */
            for (i = 0; i < count; i++) {
                if (ht216->ht_regs[0xcd] & HT_REG_CD_P8PCEXP) {
                    if (writemask2 & (0x80 >> i))
                        svga->vram[addr | i] = (vall.b[i] & svga->gdcreg[8]) | (svga->latch.b[i] & ~svga->gdcreg[8]);
                } else {
                    if (writemask2 & (1 << i))
                        svga->vram[addr | i] = (vall.b[i] & svga->gdcreg[8]) | (svga->latch.b[i] & ~svga->gdcreg[8]);
                }
            }
            break;
        case 0x08: /* AND */
            for (i = 0; i < count; i++) {
                if (ht216->ht_regs[0xcd] & HT_REG_CD_P8PCEXP) {
                    if (writemask2 & (0x80 >> i))
                        svga->vram[addr | i] = (vall.b[i] | ~svga->gdcreg[8]) & svga->latch.b[i];
                } else {
                    if (writemask2 & (1 << i))
                        svga->vram[addr | i] = (vall.b[i] | ~svga->gdcreg[8]) & svga->latch.b[i];
                }
            }
            break;
        case 0x10: /* OR */
            for (i = 0; i < count; i++) {
                if (ht216->ht_regs[0xcd] & HT_REG_CD_P8PCEXP) {
                    if (writemask2 & (0x80 >> i))
                        svga->vram[addr | i] = (vall.b[i] & svga->gdcreg[8]) | svga->latch.b[i];
                } else {
                    if (writemask2 & (1 << i))
                        svga->vram[addr | i] = (vall.b[i] & svga->gdcreg[8]) | svga->latch.b[i];
                }
            }
            break;
        case 0x18: /* XOR */
            for (i = 0; i < count; i++) {
                if (ht216->ht_regs[0xcd] & HT_REG_CD_P8PCEXP) {
                    if (writemask2 & (0x80 >> i))
                        svga->vram[addr | i] = (vall.b[i] & svga->gdcreg[8]) ^ svga->latch.b[i];
                } else {
                    if (writemask2 & (1 << i))
                        svga->vram[addr | i] = (vall.b[i] & svga->gdcreg[8]) ^ svga->latch.b[i];
                }
            }
            break;

        default:
            break;
    }

    if (reset_wm)
        svga->gdcreg[8] = wm;
}

static void
ht216_dm_extalu_write(ht216_t *ht216, uint32_t addr, uint8_t cpu_dat, uint8_t bit_mask, uint8_t cpu_dat_unexpanded, uint8_t rop_select)
{
    /*Input B = CD.5
      Input A = FE[3:2]
            00 = Set/Reset output mode
                    output = CPU-side ALU input
            01 = Solid fg/bg mode (3C4:FA/FB)
                    Bit mask = 3CF.F5 or CPU byte
            10 = Dithered fg  (3CF:EC-EF)
            11 = RMW (dest data) (set if CD.5 = 1)
      F/B ROP select = FE[5:4]
            00 = CPU byte
            01 = Bit mask (3CF:8)
            1x = (3C4:F5)*/
    svga_t  *svga    = &ht216->svga;
    uint8_t  input_a = 0;
    uint8_t  input_b = 0;
    uint8_t  fg;
    uint8_t  bg;
    uint8_t  output;
    uint32_t remapped_addr = dword_remap(svga, addr);

    if (ht216->ht_regs[0xcd] & HT_REG_CD_RMWMDE) /*RMW*/
        input_b = svga->vram[remapped_addr];
    else
        input_b = ht216->bg_latch[addr & 7];

    switch (ht216->ht_regs[0xfe] & HT_REG_FE_FBMC) {
        case 0x00:
            input_a = cpu_dat;
            break;
        case 0x04:
            if (ht216->ht_regs[0xfe] & HT_REG_FE_FBRC)
                input_a = (cpu_dat_unexpanded & (1 << ((addr & 7) ^ 7))) ? ht216->ht_regs[0xfa] : ht216->ht_regs[0xfb];
            else
                input_a = (ht216->ht_regs[0xf5] & (1 << ((addr & 7) ^ 7))) ? ht216->ht_regs[0xfa] : ht216->ht_regs[0xfb];
            break;
        case 0x08:
            input_a = ht216->fg_latch[addr & 3];
            break;
        case 0x0c:
            input_a = ht216->bg_latch[addr & 7];
            break;

        default:
            break;
    }

    fg                                     = extalu(ht216->ht_regs[0xce] >> 4, input_a, input_b);
    bg                                     = extalu(ht216->ht_regs[0xce] & 0xf, input_a, input_b);
    output                                 = (fg & rop_select) | (bg & ~rop_select);
    svga->vram[addr]                       = (svga->vram[remapped_addr] & ~bit_mask) | (output & bit_mask);
    svga->changedvram[remapped_addr >> 12] = changeframecount;
}

static void
ht216_dm_masked_write(ht216_t *ht216, uint32_t addr, uint8_t val, uint8_t bit_mask)
{
    svga_t *svga       = &ht216->svga;
    int     writemask2 = svga->writemask;
    uint8_t count      = 4;
    uint8_t i;
    uint8_t full_mask  = 0x0f;

    if (ht216->ht_regs[0xcd] & HT_REG_CD_P8PCEXP)
        writemask2 = svga->seqregs[2];

    if (!(svga->gdcreg[6] & 1))
        svga->fullchange = 2;

    if (svga->chain4) {
        writemask2 = 1 << (addr & 3);
        addr       = dword_remap(svga, addr) & ~3;
    } else if (svga->chain2_write) {
        writemask2 &= ~0xa;
        if (addr & 1)
            writemask2 <<= 1;
        addr &= ~1;
        addr <<= 2;
    } else
        addr <<= 2;

    if (addr >= svga->vram_max)
        return;

    addr &= svga->decode_mask;

    if (addr >= svga->vram_max)
        return;

    addr &= svga->vram_mask;

    svga->changedvram[addr >> 12] = changeframecount;

    if (ht216->ht_regs[0xcd] & HT_REG_CD_P8PCEXP) {
        count     = 8;
        full_mask = 0xff;
    }

    if (bit_mask == 0xff) {
        for (i = 0; i < count; i++) {
            if (writemask2 & (1 << i))
                svga->vram[addr | i] = val;
        }
    } else {
        if (writemask2 == full_mask) {
            for (i = 0; i < count; i++)
                svga->vram[addr | i] = (svga->latch.b[i] & bit_mask) | (svga->vram[addr | i] & ~bit_mask);
        } else {
            for (i = 0; i < count; i++) {
                if (writemask2 & (1 << i))
                    svga->vram[addr | i] = (val & bit_mask) | (svga->vram[addr | i] & ~bit_mask);
            }
        }
    }
}

static void
ht216_write_common(ht216_t *ht216, uint32_t addr, uint8_t val)
{
    /*Input B = CD.5
      Input A = FE[3:2]
            00 = Set/Reset output mode
                 output = CPU-side ALU input
            01 = Solid fg/bg mode (3C4:FA/FB)
                 Bit mask = 3CF.F5 or CPU byte
            10 = Dithered fg  (3CF:EC-EF)
            11 = RMW (dest data) (set if CD.5 = 1)
      F/B ROP select = FE[5:4]
            00 = CPU byte
            01 = Bit mask (3CF:8)
            1x = (3C4:F5)
    */
    const svga_t *svga       = &ht216->svga;
    int           i;
    uint8_t       bit_mask   = 0;
    uint8_t       rop_select = 0;

    cycles -= video_timing_write_b;

    addr &= svga->vram_mask;

    val = ((val >> (svga->gdcreg[3] & 7)) | (val << (8 - (svga->gdcreg[3] & 7))));

    if (ht216->ht_regs[0xcd] & HT_REG_CD_EXALU) {
        /*Extended ALU*/
        switch (ht216->ht_regs[0xfe] & HT_REG_FE_FBRSL) {
            case 0x00:
                rop_select = val;
                break;
            case 0x10:
                rop_select = svga->gdcreg[8];
                break;
            case 0x20:
            case 0x30:
                rop_select = ht216->ht_regs[0xf5];
                break;

            default:
                break;
        }
        switch (ht216->ht_regs[0xcd] & HT_REG_CD_BMSKSL) {
            case 0x00:
                bit_mask = svga->gdcreg[8];
                break;
            case 0x04:
                bit_mask = val;
                break;
            case 0x08:
            case 0x0c:
                bit_mask = ht216->ht_regs[0xf5];
                break;

            default:
                break;
        }

        if (ht216->ht_regs[0xcd] & HT_REG_CD_FP8PCEXP) { /*1->8 bit expansion*/
            addr = (addr << 3) & 0xfffff;
            for (i = 0; i < 8; i++)
                ht216_dm_extalu_write(ht216, addr + i, (val & (0x80 >> i)) ? 0xff : 0, (bit_mask & (0x80 >> i)) ? 0xff : 0, val, (rop_select & (0x80 >> i)) ? 0xff : 0);
        } else {
            ht216_dm_extalu_write(ht216, addr, val, bit_mask, val, rop_select);
        }
    } else if (ht216->ht_regs[0xf3]) {
        if (ht216->ht_regs[0xf3] & 2) {
            ht216_dm_masked_write(ht216, addr, val, val);
        } else
            ht216_dm_masked_write(ht216, addr, val, ht216->ht_regs[0xf4]);
    } else {
        if (ht216->ht_regs[0xcd] & HT_REG_CD_FP8PCEXP) { /*1->8 bit expansion*/
            addr = (addr << 3) & 0xfffff;
            for (i = 0; i < 8; i++)
                ht216_dm_write(ht216, addr + i, (val & (0x80 >> i)) ? 0xff : 0, val);
        } else {
            ht216_dm_write(ht216, addr, val, val);
        }
    }
}

static void
ht216_write(uint32_t addr, uint8_t val, void *priv)
{
    ht216_t *ht216     = (ht216_t *) priv;
    svga_t  *svga      = &ht216->svga;
    uint32_t prev_addr = addr;

    xga_write_test(addr, val, svga);

    addr &= svga->banked_mask;
    addr = (addr & 0x7fff) + ht216->write_banks[(addr >> 15) & 1];

    if (svga->crtc[0x17] == 0xeb && !(svga->gdcreg[6] & 0xc) && prev_addr >= 0xb0000)
        addr += 0x10000;
    else if (svga->chain4 && ((ht216->ht_regs[0xfc] & 0x06) == 0x06))
        addr = (addr & 0xfffeffff) | (prev_addr & 0x10000);

    if (!ht216->ht_regs[0xcd] && !ht216->ht_regs[0xfe] && !ht216->ht_regs[0xf3] && svga->crtc[0x17] != 0xeb) {
        svga_write_linear(addr, val, svga);
    } else
        ht216_write_common(ht216, addr, val);
}

static void
ht216_writew(uint32_t addr, uint16_t val, void *priv)
{
    ht216_t *ht216     = (ht216_t *) priv;
    svga_t  *svga      = &ht216->svga;
    uint32_t prev_addr = addr;

    xga_write_test(addr, val, svga);
    xga_write_test(addr + 1, val >> 8, svga);

    addr &= svga->banked_mask;
    addr = (addr & 0x7fff) + ht216->write_banks[(addr >> 15) & 1];

    if (svga->crtc[0x17] == 0xeb && !(svga->gdcreg[6] & 0xc) && prev_addr >= 0xb0000)
        addr += 0x10000;
    else if (svga->chain4 && ((ht216->ht_regs[0xfc] & 0x06) == 0x06))
        addr = (addr & 0xfffeffff) | (prev_addr & 0x10000);

    if (!ht216->ht_regs[0xcd] && !ht216->ht_regs[0xfe] && !ht216->ht_regs[0xf3] && svga->crtc[0x17] != 0xeb)
        svga_writew_linear(addr, val, svga);
    else {
        ht216_write_common(ht216, addr, val);
        ht216_write_common(ht216, addr + 1, val >> 8);
    }
}

static void
ht216_writel(uint32_t addr, uint32_t val, void *priv)
{
    ht216_t *ht216     = (ht216_t *) priv;
    svga_t  *svga      = &ht216->svga;
    uint32_t prev_addr = addr;

    xga_write_test(addr, val, svga);
    xga_write_test(addr + 1, val >> 8, svga);
    xga_write_test(addr + 2, val >> 16, svga);
    xga_write_test(addr + 3, val >> 24, svga);

    addr &= svga->banked_mask;
    addr = (addr & 0x7fff) + ht216->write_banks[(addr >> 15) & 1];

    if (svga->crtc[0x17] == 0xeb && !(svga->gdcreg[6] & 0xc) && prev_addr >= 0xb0000)
        addr += 0x10000;
    else if (svga->chain4 && ((ht216->ht_regs[0xfc] & 0x06) == 0x06))
        addr = (addr & 0xfffeffff) | (prev_addr & 0x10000);

    if (!ht216->ht_regs[0xcd] && !ht216->ht_regs[0xfe] && !ht216->ht_regs[0xf3] && svga->crtc[0x17] != 0xeb)
        svga_writel_linear(addr, val, svga);
    else {
        ht216_write_common(ht216, addr, val);
        ht216_write_common(ht216, addr + 1, val >> 8);
        ht216_write_common(ht216, addr + 2, val >> 16);
        ht216_write_common(ht216, addr + 3, val >> 24);
    }
}

static void
ht216_write_linear(uint32_t addr, uint8_t val, void *priv)
{
    ht216_t *ht216 = (ht216_t *) priv;
    svga_t  *svga  = &ht216->svga;

    addr -= ht216->linear_base;
    if (!svga->chain4) /*Bits 16 and 17 of linear address are unused in planar modes*/
        addr = (addr & 0xffff) | ((addr & 0xc0000) >> 2);
    addr += ht216->write_banks[0];

    if (!ht216->ht_regs[0xcd] && !ht216->ht_regs[0xfe])
        svga_write_linear(addr, val, svga);
    else
        ht216_write_common(ht216, addr, val);
}

static void
ht216_writew_linear(uint32_t addr, uint16_t val, void *priv)
{
    ht216_t *ht216 = (ht216_t *) priv;
    svga_t  *svga  = &ht216->svga;

    addr -= ht216->linear_base;
    if (!svga->chain4) /*Bits 16 and 17 of linear address are unused in planar modes*/
        addr = (addr & 0xffff) | ((addr & 0xc0000) >> 2);
    addr += ht216->write_banks[0];

    if (!ht216->ht_regs[0xcd] && !ht216->ht_regs[0xfe])
        svga_writew_linear(addr, val, svga);
    else {
        ht216_write_common(ht216, addr, val);
        ht216_write_common(ht216, addr + 1, val >> 8);
    }
}

static void
ht216_writel_linear(uint32_t addr, uint32_t val, void *priv)
{
    ht216_t *ht216 = (ht216_t *) priv;
    svga_t  *svga  = &ht216->svga;

    addr -= ht216->linear_base;
    if (!svga->chain4) /*Bits 16 and 17 of linear address are unused in planar modes*/
        addr = (addr & 0xffff) | ((addr & 0xc0000) >> 2);
    addr += ht216->write_banks[0];

    if (!ht216->ht_regs[0xcd] && !ht216->ht_regs[0xfe])
        svga_writel_linear(addr, val, svga);
    else {
        ht216_write_common(ht216, addr, val);
        ht216_write_common(ht216, addr + 1, val >> 8);
        ht216_write_common(ht216, addr + 2, val >> 16);
        ht216_write_common(ht216, addr + 3, val >> 24);
    }
}

static uint8_t
ht216_read_common(ht216_t *ht216, uint32_t addr)
{
    svga_t  *svga       = &ht216->svga;
    uint32_t latch_addr = 0;
    int      offset;
    int      readplane = svga->readplane;
    uint8_t  or;
    uint8_t  count = 2;
    uint8_t  temp;
    uint8_t  ret;

    if (ht216->ht_regs[0xc8] & HT_REG_C8_MOVSB)
        addr <<= 3;

    addr &= svga->vram_mask;

    cycles -= video_timing_read_b;

    count = (1 << count);

    if (svga->chain4 && svga->packed_chain4) {
        addr &= svga->decode_mask;
        if (addr >= svga->vram_max)
            return 0xff;
        latch_addr = (addr & svga->vram_mask) & ~7;
        if (ht216->ht_regs[0xcd] & HT_REG_CD_ASTODE)
            latch_addr += (svga->gdcreg[3] & 7);
        for (uint8_t i = 0; i < 8; i++)
            ht216->bg_latch[i] = svga->vram[dword_remap(svga, latch_addr + i)];
        return svga->vram[dword_remap(svga, addr) & svga->vram_mask];
    } else if (svga->chain4) {
        readplane = addr & 3;
        addr      = ((addr & 0xfffc) << 2) | ((addr & 0x30000) >> 14) | (addr & ~0x3ffff);
    } else if (svga->chain2_read && (svga->crtc[0x17] != 0xeb)) {
        readplane = (readplane & 2) | (addr & 1);
        addr &= ~1;
        addr <<= 2;
    } else
        addr <<= 2;

    addr &= svga->decode_mask;

    if (addr >= svga->vram_max)
        return 0xff;

    addr &= svga->vram_mask;

    latch_addr = addr & ~7;
    if (ht216->ht_regs[0xcd] & HT_REG_CD_ASTODE) {
        offset = addr & 7;
        for (uint8_t i = 0; i < 8; i++)
            ht216->bg_latch[i] = svga->vram[latch_addr | ((offset + i) & 7)];
    } else {
        for (uint8_t i = 0; i < 8; i++)
            ht216->bg_latch[i] = svga->vram[latch_addr | i];
    }

    or = addr & 4;
    for (uint8_t i = 0; i < 4; i++)
        svga->latch.b[i] = ht216->bg_latch[i | or ];

    if (svga->readmode) {
        temp = 0xff;

        for (uint8_t pixel = 0; pixel < 8; pixel++) {
            for (uint8_t plane = 0; plane < (uint8_t)(1 << count); plane++) {
                if (svga->colournocare & (1 << plane)) {
                    /* If we care about a plane, and the pixel has a mismatch on it, clear its bit. */
                    if (((svga->latch.b[plane] >> pixel) & 1) != ((svga->colourcompare >> plane) & 1))
                        temp &= ~(1 << pixel);
                }
            }
        }

        ret = temp;
    } else
        ret = svga->vram[addr | readplane];

    return ret;
}

static uint8_t
ht216_read(uint32_t addr, void *priv)
{
    ht216_t      *ht216     = (ht216_t *) priv;
    svga_t       *svga      = &ht216->svga;
    uint32_t      prev_addr = addr;

    (void) xga_read_test(addr, svga);

    addr &= svga->banked_mask;
    addr = (addr & 0x7fff) + ht216->read_banks[(addr >> 15) & 1];

    if (svga->crtc[0x17] == 0xeb && !(svga->gdcreg[6] & 0xc) && prev_addr >= 0xb0000)
        addr += 0x10000;
    else if (svga->chain4 && ((ht216->ht_regs[0xfc] & 0x06) == 0x06))
        addr = (addr & 0xfffeffff) | (prev_addr & 0x10000);

    return ht216_read_common(ht216, addr);
}

static uint8_t
ht216_read_linear(uint32_t addr, void *priv)
{
    ht216_t      *ht216 = (ht216_t *) priv;
    const svga_t *svga  = &ht216->svga;

    addr -= ht216->linear_base;
    if (!svga->chain4) /*Bits 16 and 17 of linear address are unused in planar modes*/
        addr = (addr & 0xffff) | ((addr & 0xc0000) >> 2);
    addr += ht216->read_banks[0];

    return ht216_read_common(ht216, addr);
}

static uint8_t
radius_mca_read(int port, void *priv)
{
    const ht216_t *ht216 = (ht216_t *) priv;

    ht216_log("Port %03x MCA read = %02x\n", port, ht216->pos_regs[port & 7]);

    return (ht216->pos_regs[port & 7]);
}

static void
radius_mca_write(int port, uint8_t val, void *priv)
{
    ht216_t *ht216 = (ht216_t *) priv;

    /* MCA does not write registers below 0x0100. */
    if (port < 0x0102)
        return;

    ht216_log("Port %03x MCA write = %02x, setup mode = %02x\n", port, val, ht216->ht_regs[0xfc] & 0x80);

    /* Save the MCA register value. */
    ht216->pos_regs[port & 7] = val;
}

static uint8_t
radius_mca_feedb(UNUSED(void *priv))
{
    return 1;
}

void *
ht216_init(const device_t *info, uint32_t mem_size, int has_rom)
{
    ht216_t *ht216 = malloc(sizeof(ht216_t));
    svga_t  *svga;

    memset(ht216, 0, sizeof(ht216_t));
    svga = &ht216->svga;

    if (info->flags & DEVICE_VLB)
        video_inform(VIDEO_FLAG_TYPE_SPECIAL, &timing_v7vga_vlb);
    else if (info->flags & DEVICE_MCA)
        video_inform(VIDEO_FLAG_TYPE_SPECIAL, &timing_v7vga_mca);
    else
        video_inform(VIDEO_FLAG_TYPE_SPECIAL, &timing_v7vga_isa);

    svga_init(info, svga, ht216, mem_size,
              ht216_recalctimings,
              ht216_in, ht216_out,
              ht216_hwcursor_draw,
              NULL);

    switch (has_rom) {
        case 1:
            rom_init(&ht216->bios_rom, BIOS_G2_GC205_PATH, 0xc0000, 0x8000, 0x7fff, 0, MEM_MAPPING_EXTERNAL);
            break;
        case 2:
            rom_init(&ht216->bios_rom, BIOS_VIDEO7_VGA_1024I_PATH, 0xc0000, 0x8000, 0x7fff, 0, MEM_MAPPING_EXTERNAL);
            break;
        case 3:
            ht216->monitor_type = device_get_config_int("monitor_type");
            rom_init(&ht216->bios_rom, BIOS_HT216_32_PATH, 0xc0000, 0x8000, 0x7fff, 0, MEM_MAPPING_EXTERNAL);
            /* Patch the BIOS for monitor type. */
            if (ht216->monitor_type & 0x10) {
                /* Color */
                ht216->bios_rom.rom[0x0526] = 0x0c;
                ht216->bios_rom.rom[0x0528] = 0xeb;
                ht216->bios_rom.rom[0x7fff] += 0x26;
            } else {
                /* Mono */
                ht216->bios_rom.rom[0x0526] = 0x24;
                ht216->bios_rom.rom[0x0527] = 0xef;
                ht216->bios_rom.rom[0x0528] = ht216->bios_rom.rom[0x0529] = 0x90;
                ht216->bios_rom.rom[0x7fff] += 0xfe;
            }
            /* Patch bios for interlaced/non-interlaced. */
            if (ht216->monitor_type & 0x08) {
                /* Non-Interlaced */
                ht216->bios_rom.rom[0x170b] = 0x0c;
                ht216->bios_rom.rom[0x170d] = ht216->bios_rom.rom[0x170e] = 0x90;
                ht216->bios_rom.rom[0x7fff] += 0xf4;
            } else {
                /* Interlaced */
                ht216->bios_rom.rom[0x170b] = 0x24;
                ht216->bios_rom.rom[0x170c] = 0xf7;
                ht216->bios_rom.rom[0x170d] = 0xeb;
                ht216->bios_rom.rom[0x7fff] += 0x1e;
            }
            break;
        case 4:
            if (info->local == 0x7152) {
                if (info->flags & DEVICE_MCA) {
                    ht216->pos_regs[0] = 0xb7;
                    ht216->pos_regs[1] = 0x80;
                    mca_add(radius_mca_read, radius_mca_write, radius_mca_feedb, NULL, ht216);
                } else
                    io_sethandler(0x0105, 0x0001, ht216_in, NULL, NULL, NULL, NULL, NULL, ht216);
            }
            rom_init(&ht216->bios_rom, BIOS_RADIUS_SVGA_MULTIVIEW_PATH, 0xc0000, 0x8000, 0x7fff, 0, MEM_MAPPING_EXTERNAL);
            break;

        default:
            break;
    }

    svga->hwcursor.cur_ysize = 32;
    ht216->vram_mask         = mem_size - 1;
    svga->decode_mask        = mem_size - 1;

    if (has_rom == 4)
        svga->ramdac = device_add(&sc11484_nors2_ramdac_device);

    svga->read = ht216_read;
    svga->readw = NULL;
    svga->readl = NULL;
    svga->write = ht216_write;
    svga->writew = ht216_writew;
    if ((info->flags & DEVICE_VLB) || (info->flags & DEVICE_MCA)) {
        svga->writel = ht216_writel;
        mem_mapping_set_handler(&svga->mapping, ht216_read, NULL, NULL, ht216_write, ht216_writew, ht216_writel);
        mem_mapping_add(&ht216->linear_mapping, 0, 0, ht216_read_linear, NULL, NULL, ht216_write_linear, ht216_writew_linear, ht216_writel_linear, NULL, MEM_MAPPING_EXTERNAL, svga);
    } else {
        svga->writel = NULL;
        mem_mapping_set_handler(&svga->mapping, ht216_read, NULL, NULL, ht216_write, ht216_writew, NULL);
        mem_mapping_add(&ht216->linear_mapping, 0, 0, ht216_read_linear, NULL, NULL, ht216_write_linear, ht216_writew_linear, NULL, NULL, MEM_MAPPING_EXTERNAL, svga);
    }
    mem_mapping_set_p(&svga->mapping, ht216);
    mem_mapping_disable(&ht216->linear_mapping);

    ht216->id     = info->local;
    ht216->isabus = (info->flags & DEVICE_ISA);
    ht216->mca    = (info->flags & DEVICE_MCA);

    io_sethandler(0x03c0, 0x0020, ht216_in, NULL, NULL, ht216_out, NULL, NULL, ht216);
    io_sethandler(0x46e8, 0x0001, ht216_in, NULL, NULL, ht216_out, NULL, NULL, ht216);

    svga->bpp     = 8;
    svga->miscout = 1;

    if (ht216->id == 0x7861)
        ht216->ht_regs[0xb4] = 0x08; /*32-bit DRAM bus*/

    if (ht216->id == 0x7152)
        ht216->reg_3cb = 0x20;

    /* Initialize the cursor pointer towards the end of its segment, needed for ht256sf.drv to work correctly
       when Windows 3.1 is started after boot. */
    ht216->ht_regs[0x94] = 0xff;

    svga->adv_flags = 0;

    return ht216;
}

static void *
g2_gc205_init(const device_t *info)
{
    ht216_t *ht216 = ht216_init(info, 1 << 19, 1);

    return ht216;
}

static void *
v7_vga_1024i_init(const device_t *info)
{
    ht216_t *ht216 = ht216_init(info, device_get_config_int("memory") << 10, 2);

    return ht216;
}

static void *
ht216_pb410a_init(const device_t *info)
{
    ht216_t *ht216 = ht216_init(info, 1 << 20, 0);

    return ht216;
}

static void *
ht216_standalone_init(const device_t *info)
{
    ht216_t *ht216 = ht216_init(info, 1 << 20, 3);

    return ht216;
}

static void *
radius_svga_multiview_init(const device_t *info)
{
    ht216_t *ht216 = ht216_init(info, 1 << 20, 4);

    return ht216;
}

static int
g2_gc205_available(void)
{
    return rom_present(BIOS_G2_GC205_PATH);
}

static int
v7_vga_1024i_available(void)
{
    return rom_present(BIOS_VIDEO7_VGA_1024I_PATH);
}

static int
ht216_standalone_available(void)
{
    return rom_present(BIOS_HT216_32_PATH);
}

static int
radius_svga_multiview_available(void)
{
    return rom_present(BIOS_RADIUS_SVGA_MULTIVIEW_PATH);
}

void
ht216_close(void *priv)
{
    ht216_t *ht216 = (ht216_t *) priv;

    svga_close(&ht216->svga);

    free(ht216);
}

void
ht216_speed_changed(void *priv)
{
    ht216_t *ht216 = (ht216_t *) priv;

    svga_recalctimings(&ht216->svga);
}

void
ht216_force_redraw(void *priv)
{
    ht216_t *ht216 = (ht216_t *) priv;

    ht216->svga.fullchange = changeframecount;
}

// clang-format off
static const device_config_t v7_vga_1024i_config[] = {
    {
        .name           = "memory",
        .description    = "Memory size",
        .type           = CONFIG_SELECTION,
        .default_string = NULL,
        .default_int    = 512,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = {
            { .description = "256 KB", .value = 256 },
            { .description = "512 KB", .value = 512 },
            { .description = ""                     }
        },
        .bios           = { { 0 } }
    },
    { .name = "", .description = "", .type = CONFIG_END }
};

static const device_config_t ht216_32_standalone_config[] = {
    {
        .name           = "monitor_type",
        .description    = "Monitor type",
        .type           = CONFIG_SELECTION,
        .default_string = NULL,
        .default_int    = 0x18,
        .file_filter    = NULL,
        .spinner        = { 0 },
        .selection      = {
            { .description = "Mono Interlaced",      .value = 0x00 },
            { .description = "Mono Non-Interlaced",  .value = 0x08 },
            { .description = "Color Interlaced",     .value = 0x10 },
            { .description = "Color Non-Interlaced", .value = 0x18 },
            { .description = ""                                    }
        },
        .bios           = { { 0 } }
    },
    { .name = "", .description = "", .type = CONFIG_END }
};
// clang-format on

const device_t g2_gc205_device = {
    .name          = "G2 GC205",
    .internal_name = "g2_gc205",
    .flags         = DEVICE_ISA,
    .local         = 0x7070,
    .init          = g2_gc205_init,
    .close         = ht216_close,
    .reset         = NULL,
    .available     = g2_gc205_available,
    .speed_changed = ht216_speed_changed,
    .force_redraw  = ht216_force_redraw,
    .config        = NULL
};

const device_t v7_vga_1024i_device = {
    .name          = "Video 7 VGA 1024i (HT208)",
    .internal_name = "v7_vga_1024i",
    .flags         = DEVICE_ISA,
    .local         = 0x7140,
    .init          = v7_vga_1024i_init,
    .close         = ht216_close,
    .reset         = NULL,
    .available     = v7_vga_1024i_available,
    .speed_changed = ht216_speed_changed,
    .force_redraw  = ht216_force_redraw,
    .config        = v7_vga_1024i_config
};

const device_t ht216_32_pb410a_device = {
    .name          = "Headland HT216-32 (Packard Bell PB410A)",
    .internal_name = "ht216_32_pb410a",
    .flags         = DEVICE_VLB,
    .local         = 0x7861, /*HT216-32*/
    .init          = ht216_pb410a_init,
    .close         = ht216_close,
    .reset         = NULL,
    .available     = NULL,
    .speed_changed = ht216_speed_changed,
    .force_redraw  = ht216_force_redraw,
    .config        = NULL
};

const device_t ht216_32_standalone_device = {
    .name          = "Headland HT216-32",
    .internal_name = "ht216_32",
    .flags         = DEVICE_VLB,
    .local         = 0x7861, /*HT216-32*/
    .init          = ht216_standalone_init,
    .close         = ht216_close,
    .reset         = NULL,
    .available     = ht216_standalone_available,
    .speed_changed = ht216_speed_changed,
    .force_redraw  = ht216_force_redraw,
    .config        = ht216_32_standalone_config
};

const device_t radius_svga_multiview_isa_device = {
    .name          = "Radius SVGA Multiview ISA (HT209)",
    .internal_name = "radius_isa",
    .flags         = DEVICE_ISA16,
    .local         = 0x7152, /*HT209*/
    .init          = radius_svga_multiview_init,
    .close         = ht216_close,
    .reset         = NULL,
    .available     = radius_svga_multiview_available,
    .speed_changed = ht216_speed_changed,
    .force_redraw  = ht216_force_redraw,
    .config        = NULL
};

const device_t radius_svga_multiview_mca_device = {
    .name          = "Radius SVGA Multiview MCA (HT209)",
    .internal_name = "radius_mc",
    .flags         = DEVICE_MCA,
    .local         = 0x7152, /*HT209*/
    .init          = radius_svga_multiview_init,
    .close         = ht216_close,
    .reset         = NULL,
    .available     = radius_svga_multiview_available,
    .speed_changed = ht216_speed_changed,
    .force_redraw  = ht216_force_redraw,
    .config        = NULL
};