diff --git a/src/machine/m_at_compaq.c b/src/machine/m_at_compaq.c index d22797090..f29a55842 100644 --- a/src/machine/m_at_compaq.c +++ b/src/machine/m_at_compaq.c @@ -20,10 +20,14 @@ #include #include #include +#include #include +#include #include "86box.h" #include "cpu.h" +#include "86box_io.h" #include "timer.h" +#include "pit.h" #include "mem.h" #include "rom.h" #include "device.h" @@ -32,21 +36,708 @@ #include "hdc.h" #include "hdc_ide.h" #include "machine.h" +#include "video.h" +#include "vid_cga.h" +#include "vid_cga_comp.h" enum { - COMPAQ_PORTABLEII = 0 -#if defined(DEV_BRANCH) && defined(USE_PORTABLE3) - , COMPAQ_PORTABLEIII, + COMPAQ_PORTABLEII = 0, + COMPAQ_PORTABLEIII, COMPAQ_PORTABLEIII386 -#endif +}; + +#define CGA_RGB 0 +#define CGA_COMPOSITE 1 + +#define COMPOSITE_OLD 0 +#define COMPOSITE_NEW 1 + +/*Very rough estimate*/ +#define VID_CLOCK (double)(651 * 416 * 60) + + +/* Mapping of attributes to colours */ +static uint32_t amber, black; +static uint32_t blinkcols[256][2]; +static uint32_t normcols[256][2]; + +/* Video options set by the motherboard; they will be picked up by the card + * on the next poll. + * + * Bit 3: Disable built-in video (for add-on card) + * Bit 2: Thin font + * Bits 0,1: Font set (not currently implemented) + */ +static int8_t cpq_st_display_internal = -1; + +static void +compaq_plasma_display_set(uint8_t internal) +{ + cpq_st_display_internal = internal; +} + +static uint8_t +compaq_plasma_display_get(void) +{ + return cpq_st_display_internal; +} + + +typedef struct compaq_plasma_t +{ + mem_mapping_t plasma_mapping; + cga_t cga; + uint8_t port_23c6; + uint8_t internal_monitor; + uint8_t attrmap; /* Attribute mapping register */ + int linepos, displine; + uint8_t *vram; + uint64_t dispontime, dispofftime; + int dispon; +} compaq_plasma_t; + +static uint8_t cga_crtcmask[32] = +{ + 0xff, 0xff, 0xff, 0xff, 0x7f, 0x1f, 0x7f, 0x7f, 0xf3, 0x1f, 0x7f, 0x1f, 0x3f, 0xff, 0x3f, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; /* Compaq Deskpro 386 remaps RAM from 0xA0000-0xFFFFF to 0xFA0000-0xFFFFFF */ static mem_mapping_t ram_mapping; +static void compaq_plasma_recalcattrs(compaq_plasma_t *self); + +static void +compaq_plasma_recalctimings(compaq_plasma_t *self) +{ + double _dispontime, _dispofftime, disptime; + + if (!self->internal_monitor && !(self->port_23c6 & 1)) { + cga_recalctimings(&self->cga); + return; + } + + disptime = 651; + _dispontime = 640; + _dispofftime = disptime - _dispontime; + self->dispontime = (uint64_t)(_dispontime * (cpuclock / VID_CLOCK) * (double)(1ull << 32)); + self->dispofftime = (uint64_t)(_dispofftime * (cpuclock / VID_CLOCK) * (double)(1ull << 32)); +} + +static void +compaq_plasma_write(uint32_t addr, uint8_t val, void *priv) +{ + compaq_plasma_t *self = (compaq_plasma_t *)priv; + + self->vram[addr & 0x7fff] = val; +} + + +static uint8_t +compaq_plasma_read(uint32_t addr, void *priv) +{ + compaq_plasma_t *self = (compaq_plasma_t *)priv; + uint8_t ret; + + ret = (self->vram[addr & 0x7fff]); + + return ret; +} + +/* Draw a row of text in 80-column mode */ +static void +compaq_plasma_text80(compaq_plasma_t *self) +{ + uint32_t cols[2]; + int x, c; + uint8_t chr, attr; + int drawcursor; + int cursorline; + int blink; + uint16_t addr; + uint8_t sc; + uint16_t ma = (self->cga.crtc[13] | (self->cga.crtc[12] << 8)) & 0x7fff; + uint16_t ca = (self->cga.crtc[15] | (self->cga.crtc[14] << 8)) & 0x7fff; + + sc = (self->displine) & 15; + addr = ((ma & ~1) + (self->displine >> 4) * 80) * 2; + ma += (self->displine >> 4) * 80; + + if ((self->cga.crtc[10] & 0x60) == 0x20) + cursorline = 0; + else + cursorline = ((self->cga.crtc[10] & 0x0F)*2 <= sc) && + ((self->cga.crtc[11] & 0x0F)*2 >= sc); + + for (x = 0; x < 80; x++) { + chr = self->vram[(addr + 2 * x) & 0x7FFF]; + attr = self->vram[(addr + 2 * x + 1) & 0x7FFF]; + drawcursor = ((ma == ca) && cursorline && + (self->cga.cgamode & 8) && (self->cga.cgablink & 16)); + + blink = ((self->cga.cgablink & 16) && (self->cga.cgamode & 0x20) && + (attr & 0x80) && !drawcursor); + + if (self->cga.cgamode & 0x20) { /* Blink */ + cols[1] = blinkcols[attr][1]; + cols[0] = blinkcols[attr][0]; + if (blink) + cols[1] = cols[0]; + } else { + cols[1] = normcols[attr][1]; + cols[0] = normcols[attr][0]; + } + if (drawcursor) { + for (c = 0; c < 8; c++) + ((uint32_t *)buffer32->line[self->displine])[(x << 3) + c] = cols[(fontdatm[chr][sc] & (1 << (c ^ 7))) ? 1 : 0] ^ (amber ^ black); + } else { + for (c = 0; c < 8; c++) + ((uint32_t *)buffer32->line[self->displine])[(x << 3) + c] = cols[(fontdatm[chr][sc] & (1 << (c ^ 7))) ? 1 : 0]; + } + ++ma; + } +} + +/* Draw a row of text in 40-column mode */ +static void +compaq_plasma_text40(compaq_plasma_t *self) +{ + uint32_t cols[2]; + int x, c; + uint8_t chr, attr; + int drawcursor; + int cursorline; + int blink; + uint16_t addr; + uint8_t sc; + uint16_t ma = (self->cga.crtc[13] | (self->cga.crtc[12] << 8)) & 0x7fff; + uint16_t ca = (self->cga.crtc[15] | (self->cga.crtc[14] << 8)) & 0x7fff; + + sc = (self->displine) & 15; + addr = ((ma & ~1) + (self->displine >> 4) * 40) * 2; + ma += (self->displine >> 4) * 40; + + if ((self->cga.crtc[10] & 0x60) == 0x20) + cursorline = 0; + else + cursorline = ((self->cga.crtc[10] & 0x0F)*2 <= sc) && + ((self->cga.crtc[11] & 0x0F)*2 >= sc); + + for (x = 0; x < 40; x++) { + chr = self->vram[(addr + 2 * x) & 0x7FFF]; + attr = self->vram[(addr + 2 * x + 1) & 0x7FFF]; + drawcursor = ((ma == ca) && cursorline && + (self->cga.cgamode & 8) && (self->cga.cgablink & 16)); + + blink = ((self->cga.cgablink & 16) && (self->cga.cgamode & 0x20) && + (attr & 0x80) && !drawcursor); + + if (self->cga.cgamode & 0x20) { /* Blink */ + cols[1] = blinkcols[attr][1]; + cols[0] = blinkcols[attr][0]; + if (blink) + cols[1] = cols[0]; + } else { + cols[1] = normcols[attr][1]; + cols[0] = normcols[attr][0]; + } + if (drawcursor) { + for (c = 0; c < 8; c++) { + ((uint32_t *)buffer32->line[self->displine])[(x << 4) + c*2] = + ((uint32_t *)buffer32->line[self->displine])[(x << 4) + c*2 + 1] = cols[(fontdatm[chr][sc] & (1 << (c ^ 7))) ? 1 : 0] ^ (amber ^ black); + } + } else { + for (c = 0; c < 8; c++) { + ((uint32_t *)buffer32->line[self->displine])[(x << 4) + c*2] = + ((uint32_t *)buffer32->line[self->displine])[(x << 4) + c*2+1] = cols[(fontdatm[chr][sc] & (1 << (c ^ 7))) ? 1 : 0]; + } + } + ++ma; + } +} + + +/* Draw a line in CGA 640x200 or Compaq Plasma 640x400 mode */ +static void +compaq_plasma_cgaline6(compaq_plasma_t *self) +{ + int x, c; + uint8_t dat; + uint32_t ink = 0; + uint16_t addr; + uint32_t fg = (self->cga.cgacol & 0x0F) ? amber : black; + uint32_t bg = black; + + uint16_t ma = (self->cga.crtc[13] | (self->cga.crtc[12] << 8)) & 0x7fff; + + if ((self->cga.crtc[9] == 3) || (self->port_23c6 & 1)) /* 640*400 */ { + addr = ((self->displine) & 1) * 0x2000 + + ((self->displine >> 1) & 1) * 0x4000 + + (self->displine >> 2) * 80 + + ((ma & ~1) << 1); + } else { + addr = ((self->displine >> 1) & 1) * 0x2000 + + (self->displine >> 2) * 80 + + ((ma & ~1) << 1); + } + for (x = 0; x < 80; x++) { + dat = self->vram[(addr & 0x7FFF)]; + addr++; + + for (c = 0; c < 8; c++) { + ink = (dat & 0x80) ? fg : bg; + if (!(self->cga.cgamode & 8)) ink = black; + ((uint32_t *)buffer32->line[self->displine])[x*8+c] = ink; + dat <<= 1; + } + } +} + +/* Draw a line in CGA 320x200 mode. Here the CGA colours are converted to + * dither patterns: colour 1 to 25% grey, colour 2 to 50% grey */ +static void +compaq_plasma_cgaline4(compaq_plasma_t *self) +{ + int x, c; + uint8_t dat, pattern; + uint32_t ink0 = 0, ink1 = 0; + uint16_t addr; + + uint16_t ma = (self->cga.crtc[13] | (self->cga.crtc[12] << 8)) & 0x7fff; + + /* 320*200 */ + addr = ((self->displine >> 1) & 1) * 0x2000 + + (self->displine >> 2) * 80 + + ((ma & ~1) << 1); + + for (x = 0; x < 80; x++) { + dat = self->vram[(addr & 0x7FFF)]; + addr++; + + for (c = 0; c < 4; c++) { + pattern = (dat & 0xC0) >> 6; + if (!(self->cga.cgamode & 8)) + pattern = 0; + + switch (pattern & 3) { + case 0: ink0 = ink1 = black; break; + case 1: if (self->displine & 1) { + ink0 = black; ink1 = black; + } else { + ink0 = amber; ink1 = black; + } + break; + case 2: if (self->displine & 1) { + ink0 = black; ink1 = amber; + } else { + ink0 = amber; ink1 = black; + } + break; + case 3: ink0 = ink1 = amber; break; + + } + ((uint32_t *)buffer32->line[self->displine])[x*8+2*c] = ink0; + ((uint32_t *)buffer32->line[self->displine])[x*8+2*c+1] = ink1; + dat <<= 2; + } + } +} + +static void +compaq_plasma_out(uint16_t addr, uint8_t val, void *priv) +{ + compaq_plasma_t *self = (compaq_plasma_t *)priv; + uint8_t old; + + switch (addr) { + /* Emulated CRTC, register select */ + case 0x3d4: + self->cga.crtcreg = val & 31; + break; + + /* Emulated CRTC, value */ + case 0x3d5: + old = self->cga.crtc[self->cga.crtcreg]; + self->cga.crtc[self->cga.crtcreg] = val & cga_crtcmask[self->cga.crtcreg]; + + /* Register 0x12 controls the attribute mappings for the + * plasma screen. */ + if (self->cga.crtcreg == 0x12) { + self->attrmap = val; + compaq_plasma_recalcattrs(self); + break; + } + + if (old != val) { + if (self->cga.crtcreg < 0xe || self->cga.crtcreg > 0x10) { + fullchange = changeframecount; + compaq_plasma_recalctimings(self); + } + } + break; + + case 0x3d8: + self->cga.cgamode = val; + break; + + case 0x3d9: + self->cga.cgacol = val; + break; + + case 0x13c6: + if (val & 8) + compaq_plasma_display_set(1); + else + compaq_plasma_display_set(0); + break; + + case 0x23c6: + self->port_23c6 = val; + if (val & 8) /* Disable internal CGA */ + mem_mapping_disable(&self->plasma_mapping); + else + mem_mapping_enable(&self->plasma_mapping); + break; + } +} + + +static uint8_t +compaq_plasma_in(uint16_t addr, void *priv) +{ + compaq_plasma_t *self = (compaq_plasma_t *)priv; + uint8_t ret = 0xff; + + switch (addr) { + case 0x3d4: + ret = self->cga.crtcreg; + break; + + case 0x3d5: + if (self->cga.crtcreg == 0x12) { + ret = self->attrmap & 0x0F; + if (self->internal_monitor) + ret |= 0x30; /* Plasma / CRT */ + } else + ret = self->cga.crtc[self->cga.crtcreg]; + break; + + case 0x3da: + ret = self->cga.cgastat; + break; + + case 0x13c6: + if (compaq_plasma_display_get()) + ret = 8; + else + ret = 0; + break; + + case 0x23c6: + ret = self->port_23c6; + break; + } + + return ret; +} + +static void +compaq_plasma_poll(void *p) +{ + compaq_plasma_t *self = (compaq_plasma_t *)p; + + /* Switch between internal plasma and external CRT display. */ + if (cpq_st_display_internal != -1 && cpq_st_display_internal != self->internal_monitor) { + self->internal_monitor = cpq_st_display_internal; + compaq_plasma_recalctimings(self); + } + + if (!self->internal_monitor && !(self->port_23c6 & 1)) { + cga_poll(&self->cga); + return; + } + + if (!self->linepos) { + timer_advance_u64(&self->cga.timer, self->dispofftime); + self->cga.cgastat |= 1; + self->linepos = 1; + if (self->dispon) { + if (self->displine == 0) + video_wait_for_buffer(); + + /* Graphics */ + if (self->cga.cgamode & 0x02) { + if (self->cga.cgamode & 0x10) + compaq_plasma_cgaline6(self); + else + compaq_plasma_cgaline4(self); + } + else if (self->cga.cgamode & 0x01) /* High-res text */ + compaq_plasma_text80(self); + else + compaq_plasma_text40(self); + } + self->displine++; + /* Hardcode a fixed refresh rate and VSYNC timing */ + if (self->displine == 400) { /* Start of VSYNC */ + self->cga.cgastat |= 8; + self->dispon = 0; + } + if (self->displine == 416) { /* End of VSYNC */ + self->displine = 0; + self->cga.cgastat &= ~8; + self->dispon = 1; + } + } else { + if (self->dispon) + self->cga.cgastat &= ~1; + + timer_advance_u64(&self->cga.timer, self->dispontime); + self->linepos = 0; + + if (self->displine == 400) { + /* Hardcode 640x400 window size */ + if ((640 != xsize) || (400 != ysize) || video_force_resize_get()) { + xsize = 640; + ysize = 400; + 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, 0, ysize, xsize, ysize); + frames++; + + /* Fixed 640x400 resolution */ + video_res_x = 640; + video_res_y = 400; + + if (self->cga.cgamode & 0x02) { + if (self->cga.cgamode & 0x10) + video_bpp = 1; + else + video_bpp = 2; + + } else + video_bpp = 0; + self->cga.cgablink++; + } + } +} + +static void +compaq_plasma_recalcattrs(compaq_plasma_t *self) +{ + int n; + + /* val behaves as follows: + * Bit 0: Attributes 01-06, 08-0E are inverse video + * Bit 1: Attributes 01-06, 08-0E are bold + * Bit 2: Attributes 11-16, 18-1F, 21-26, 28-2F ... F1-F6, F8-FF + * are inverse video + * Bit 3: Attributes 11-16, 18-1F, 21-26, 28-2F ... F1-F6, F8-FF + * are bold */ + + /* Set up colours */ + amber = makecol(0xff, 0x7D, 0x00); + black = makecol(0x64, 0x19, 0x00); + + /* Initialise the attribute mapping. Start by defaulting everything + * to black on amber, and with bold set by bit 3 */ + for (n = 0; n < 256; n++) { + blinkcols[n][0] = normcols[n][0] = amber; + blinkcols[n][1] = normcols[n][1] = black; + } + + /* Colours 0x11-0xFF are controlled by bits 2 and 3 of the + * passed value. Exclude x0 and x8, which are always black on + * amber. */ + for (n = 0x11; n <= 0xFF; n++) { + if ((n & 7) == 0) + continue; + if (self->attrmap & 4) { /* Inverse */ + blinkcols[n][0] = normcols[n][0] = amber; + blinkcols[n][1] = normcols[n][1] = black; + } else { /* Normal */ + blinkcols[n][0] = normcols[n][0] = black; + blinkcols[n][1] = normcols[n][1] = amber; + } + } + /* Set up the 01-0E range, controlled by bits 0 and 1 of the + * passed value. When blinking is enabled this also affects 81-8E. */ + for (n = 0x01; n <= 0x0E; n++) { + if (n == 7) + continue; + if (self->attrmap & 1) { + blinkcols[n][0] = normcols[n][0] = amber; + blinkcols[n][1] = normcols[n][1] = black; + blinkcols[n+128][0] = amber; + blinkcols[n+128][1] = black; + } else { + blinkcols[n][0] = normcols[n][0] = black; + blinkcols[n][1] = normcols[n][1] = amber; + blinkcols[n+128][0] = black; + blinkcols[n+128][1] = amber; + } + } + /* Colours 07 and 0F are always amber on black. If blinking is + * enabled so are 87 and 8F. */ + for (n = 0x07; n <= 0x0F; n += 8) { + blinkcols[n][0] = normcols[n][0] = black; + blinkcols[n][1] = normcols[n][1] = amber; + blinkcols[n+128][0] = black; + blinkcols[n+128][1] = amber; + } + /* When not blinking, colours 81-8F are always amber on black. */ + for (n = 0x81; n <= 0x8F; n ++) { + normcols[n][0] = black; + normcols[n][1] = amber; + } + + /* Finally do the ones which are solid black. These differ between + * the normal and blinking mappings */ + for (n = 0; n <= 0xFF; n += 0x11) + normcols[n][0] = normcols[n][1] = black; + + /* In the blinking range, 00 11 22 .. 77 and 80 91 A2 .. F7 are black */ + for (n = 0; n <= 0x77; n += 0x11) { + blinkcols[n][0] = blinkcols[n][1] = black; + blinkcols[n+128][0] = blinkcols[n+128][1] = black; + } +} + +static void * +compaq_plasma_init(const device_t *info) +{ + int display_type; + compaq_plasma_t *self = malloc(sizeof(compaq_plasma_t)); + memset(self, 0, sizeof(compaq_plasma_t)); + + display_type = device_get_config_int("display_type"); + self->cga.composite = (display_type != CGA_RGB); + self->cga.revision = device_get_config_int("composite_type"); + + self->vram = malloc(0x8000); + self->internal_monitor = 1; + + cga_comp_init(self->cga.revision); + timer_add(&self->cga.timer, compaq_plasma_poll, self, 1); + mem_mapping_add(&self->plasma_mapping, 0xb8000, 0x08000, compaq_plasma_read, NULL, NULL, compaq_plasma_write, NULL, NULL, NULL /*self->cga.vram*/, MEM_MAPPING_EXTERNAL, self); + io_sethandler(0x03d0, 0x0010, compaq_plasma_in, NULL, NULL, compaq_plasma_out, NULL, NULL, self); + io_sethandler(0x13c6, 0x0001, compaq_plasma_in, NULL, NULL, compaq_plasma_out, NULL, NULL, self); + io_sethandler(0x23c6, 0x0001, compaq_plasma_in, NULL, NULL, compaq_plasma_out, NULL, NULL, self); + + /* Default attribute mapping is 4 */ + self->attrmap = 4; + compaq_plasma_recalcattrs(self); + + self->cga.cgastat = 0xF4; + self->cga.vram = self->vram; + + overscan_x = overscan_y = 16; + + self->cga.rgb_type = device_get_config_int("rgb_type"); + cga_palette = (self->cga.rgb_type << 1); + cgapal_rebuild(); + + return self; +} + +static void +compaq_plasma_close(void *p) +{ + compaq_plasma_t *self = (compaq_plasma_t *)p; + + free(self->vram); + free(self); +} + +static void +compaq_plasma_speed_changed(void *p) +{ + compaq_plasma_t *self = (compaq_plasma_t *)p; + + compaq_plasma_recalctimings(self); +} + +const device_config_t compaq_plasma_config[] = +{ + { + "display_type", "Display type", CONFIG_SELECTION, "", CGA_RGB, + { + { + "RGB", CGA_RGB + }, + { + "Composite", CGA_COMPOSITE + }, + { + "" + } + } + }, + { + "composite_type", "Composite type", CONFIG_SELECTION, "", COMPOSITE_OLD, + { + { + "Old", COMPOSITE_OLD + }, + { + "New", COMPOSITE_NEW + }, + { + "" + } + } + }, + { + "rgb_type", "RGB type", CONFIG_SELECTION, "", 0, + { + { + "Color", 0 + }, + { + "Green Monochrome", 1 + }, + { + "Amber Monochrome", 2 + }, + { + "Gray Monochrome", 3 + }, + { + "Color (no brown)", 4 + }, + { + "" + } + } + }, + { + "", "", -1 + } +}; + + +static const device_t compaq_plasma_device = +{ + "Compaq Plasma", + 0, 0, + compaq_plasma_init, + compaq_plasma_close, + NULL, + NULL, + compaq_plasma_speed_changed, + NULL, + compaq_plasma_config +}; static uint8_t read_ram(uint32_t addr, void *priv) @@ -107,6 +798,11 @@ write_raml(uint32_t addr, uint32_t val, void *priv) mem_write_raml_page(addr, val, &pages[addr >> 12]); } +const device_t * +at_cpqiii_get_device(void) +{ + return &compaq_plasma_device; +} static void machine_at_compaq_init(const machine_t *model, int type) @@ -126,15 +822,17 @@ machine_at_compaq_init(const machine_t *model, int type) case COMPAQ_PORTABLEII: break; -#if defined(DEV_BRANCH) && defined(USE_PORTABLE3) case COMPAQ_PORTABLEIII: + if (gfxcard == VID_INTERNAL) + device_add(&compaq_plasma_device); break; case COMPAQ_PORTABLEIII386: if (hdc_current == 1) device_add(&ide_isa_device); + if (gfxcard == VID_INTERNAL) + device_add(&compaq_plasma_device); break; -#endif } } @@ -157,7 +855,6 @@ machine_at_portableii_init(const machine_t *model) } -#if defined(DEV_BRANCH) && defined(USE_PORTABLE3) int machine_at_portableiii_init(const machine_t *model) { @@ -192,4 +889,3 @@ machine_at_portableiii386_init(const machine_t *model) return ret; } -#endif diff --git a/src/machine/machine.h b/src/machine/machine.h index 7f584a5ea..48fac0728 100644 --- a/src/machine/machine.h +++ b/src/machine/machine.h @@ -237,9 +237,10 @@ extern int machine_at_cmdpc_init(const machine_t *); /* m_at_compaq.c */ extern int machine_at_portableii_init(const machine_t *); -#if defined(DEV_BRANCH) && defined(USE_PORTABLE3) extern int machine_at_portableiii_init(const machine_t *); extern int machine_at_portableiii386_init(const machine_t *); +#ifdef EMU_DEVICE_H +extern const device_t *at_cpqiii_get_device(void); #endif /* m_at_socket4_5.c */ diff --git a/src/machine/machine_table.c b/src/machine/machine_table.c index be958aa0f..f5721ad83 100644 --- a/src/machine/machine_table.c +++ b/src/machine/machine_table.c @@ -103,9 +103,7 @@ const machine_t machines[] = { { "[286 ISA] Quadtel 286 clone", "quadt286", {{"", cpus_286}, {"", NULL}, {"", NULL}, {"", NULL}, {"", NULL}}, MACHINE_ISA | MACHINE_AT, 512,16384, 128, 127, machine_at_quadt286_init, NULL }, { "[286 ISA] Commodore PC 30 III", "cmdpc30", {{"", cpus_286}, {"", NULL}, {"", NULL}, {"", NULL}, {"", NULL}}, MACHINE_ISA | MACHINE_AT, 640,16384, 128, 127, machine_at_cmdpc_init, NULL }, { "[286 ISA] Compaq Portable II", "portableii", {{"", cpus_286}, {"", NULL}, {"", NULL}, {"", NULL}, {"", NULL}}, MACHINE_ISA | MACHINE_AT, 640,16384, 128, 127, machine_at_portableii_init, NULL }, -#if defined(DEV_BRANCH) && defined(USE_PORTABLE3) - { "[286 ISA] Compaq Portable III", "portableiii", {{"", cpus_286}, {"", NULL}, {"", NULL}, {"", NULL}, {"", NULL}}, MACHINE_ISA | MACHINE_AT | MACHINE_VIDEO | MACHINE_VIDEO_FIXED, 640,16384, 128, 127, machine_at_portableiii_init, NULL }, -#endif + { "[286 ISA] Compaq Portable III", "portableiii", {{"", cpus_286}, {"", NULL}, {"", NULL}, {"", NULL}, {"", NULL}}, MACHINE_ISA | MACHINE_AT | MACHINE_VIDEO, 640,16384, 128, 127, machine_at_portableiii_init, at_cpqiii_get_device }, { "[286 ISA] GW-286CT GEAR", "gw286ct", {{"", cpus_286}, {"", NULL}, {"", NULL}, {"", NULL}, {"", NULL}}, MACHINE_ISA | MACHINE_AT, 512,16384, 128, 127, machine_at_gw286ct_init, NULL }, { "[286 ISA] Hyundai Super-286TR", "super286tr", {{"", cpus_286}, {"", NULL}, {"", NULL}, {"", NULL}, {"", NULL}}, MACHINE_ISA | MACHINE_AT, 512,16384, 128, 127, machine_at_super286tr_init, NULL }, { "[286 ISA] IBM AT", "ibmat", {{"", cpus_ibmat}, {"", NULL}, {"", NULL}, {"", NULL}, {"", NULL}}, MACHINE_ISA | MACHINE_AT, 256,15872, 128, 63, machine_at_ibm_init, NULL }, @@ -151,9 +149,7 @@ const machine_t machines[] = { #if defined(DEV_BRANCH) && defined(USE_MR495) { "[386DX ISA] MR 386DX clone", "mr386dx", {{"Intel", cpus_i386DX}, {"AMD", cpus_Am386DX}, {"Cyrix", cpus_486DLC}, {"", NULL}, {"", NULL}}, MACHINE_ISA | MACHINE_VLB | MACHINE_AT | MACHINE_HDC, 1, 32, 1, 127, machine_at_opti495_mr_init, NULL }, #endif -#if defined(DEV_BRANCH) && defined(USE_PORTABLE3) - { "[386DX ISA] Compaq Portable III (386)", "portableiii386", {{"Intel", cpus_i386DX}, {"AMD", cpus_Am386DX}, {"Cyrix", cpus_486DLC}, {"", NULL}, {"", NULL}}, MACHINE_ISA | MACHINE_AT | MACHINE_HDC | MACHINE_VIDEO | MACHINE_VIDEO_FIXED, 1, 14, 1, 127, machine_at_portableiii386_init, NULL }, -#endif + { "[386DX ISA] Compaq Portable III (386)", "portableiii386", {{"Intel", cpus_i386DX}, {"AMD", cpus_Am386DX}, {"Cyrix", cpus_486DLC}, {"", NULL}, {"", NULL}}, MACHINE_ISA | MACHINE_AT | MACHINE_HDC | MACHINE_VIDEO, 1, 14, 1, 127, machine_at_portableiii386_init, at_cpqiii_get_device }, { "[386DX MCA] IBM PS/2 model 70 (type 3)", "ibmps2_m70_type3", {{"Intel", cpus_i386DX}, {"AMD", cpus_Am386DX}, {"Cyrix", cpus_486DLC}, {"IBM",cpus_IBM486BL},{"", NULL}}, MACHINE_MCA | MACHINE_AT | MACHINE_PS2 | MACHINE_VIDEO, 2, 16, 2, 63, machine_ps2_model_70_type3_init, NULL }, { "[386DX MCA] IBM PS/2 model 80", "ibmps2_m80", {{"Intel", cpus_i386DX}, {"AMD", cpus_Am386DX}, {"Cyrix", cpus_486DLC}, {"IBM",cpus_IBM486BL},{"", NULL}}, MACHINE_MCA | MACHINE_AT | MACHINE_PS2 | MACHINE_VIDEO, 1, 12, 1, 63, machine_ps2_model_80_init, NULL },