diff options
Diffstat (limited to 'src/devices/bus/sbus/cgsix.cpp')
-rw-r--r-- | src/devices/bus/sbus/cgsix.cpp | 311 |
1 files changed, 251 insertions, 60 deletions
diff --git a/src/devices/bus/sbus/cgsix.cpp b/src/devices/bus/sbus/cgsix.cpp index beebe3dadd9..46685deb58a 100644 --- a/src/devices/bus/sbus/cgsix.cpp +++ b/src/devices/bus/sbus/cgsix.cpp @@ -21,6 +21,10 @@ void sbus_cgsix_device::base_map(address_map &map) map(0x00000000, 0x01ffffff).rw(FUNC(sbus_cgsix_device::unknown_r), FUNC(sbus_cgsix_device::unknown_w)); map(0x00000000, 0x00007fff).r(FUNC(sbus_cgsix_device::rom_r)); map(0x00200000, 0x0020000f).m(m_ramdac, FUNC(bt458_device::map)).umask32(0xff000000); + map(0x00300000, 0x00300fff).rw(FUNC(sbus_cgsix_device::fbc_r), FUNC(sbus_cgsix_device::fbc_w)); + map(0x00301818, 0x0030181b).rw(FUNC(sbus_cgsix_device::thc_misc_r), FUNC(sbus_cgsix_device::thc_misc_w)); + map(0x003018fc, 0x003018ff).rw(FUNC(sbus_cgsix_device::cursor_address_r), FUNC(sbus_cgsix_device::cursor_address_w)); + map(0x00301900, 0x003019ff).rw(FUNC(sbus_cgsix_device::cursor_ram_r), FUNC(sbus_cgsix_device::cursor_ram_w)); map(0x00700000, 0x00700fff).rw(FUNC(sbus_cgsix_device::fbc_r), FUNC(sbus_cgsix_device::fbc_w)); } @@ -36,10 +40,14 @@ sbus_cgsix_device::sbus_cgsix_device(const machine_config &mconfig, device_type void sbus_cgsix_device::device_start() { m_vram = std::make_unique<uint32_t[]>(m_vram_size / 4); - save_pointer(NAME(m_vram), m_vram_size / 4); save_item(NAME(m_vram_size)); + m_cursor_ram = std::make_unique<uint32_t[]>(32 * 2); + save_pointer(NAME(m_cursor_ram), 32 * 2); + + save_item(NAME(m_fbc.m_config)); + save_item(NAME(m_fbc.m_misc)); save_item(NAME(m_fbc.m_clip_check)); save_item(NAME(m_fbc.m_status)); save_item(NAME(m_fbc.m_draw_status)); @@ -84,6 +92,8 @@ void sbus_cgsix_device::device_start() save_item(NAME(m_fbc.m_pixel_mask)); save_item(NAME(m_fbc.m_patt_align)); + save_item(NAME(m_fbc.m_patt_align_x)); + save_item(NAME(m_fbc.m_patt_align_y)); save_item(NAME(m_fbc.m_pattern)); save_item(NAME(m_fbc.m_ipoint_absx)); @@ -143,39 +153,50 @@ void sbus_cgsix_device::device_start() save_item(NAME(m_fbc.m_vertex_count)); - for (int i = 0; i < 0x1000; i++) - { - save_item(NAME(m_fbc.m_prim_buf[i].m_absx), i); - save_item(NAME(m_fbc.m_prim_buf[i].m_absy), i); - save_item(NAME(m_fbc.m_prim_buf[i].m_absz), i); - save_item(NAME(m_fbc.m_prim_buf[i].m_relx), i); - save_item(NAME(m_fbc.m_prim_buf[i].m_rely), i); - save_item(NAME(m_fbc.m_prim_buf[i].m_relz), i); - save_item(NAME(m_fbc.m_prim_buf[i].m_r), i); - save_item(NAME(m_fbc.m_prim_buf[i].m_g), i); - save_item(NAME(m_fbc.m_prim_buf[i].m_b), i); - save_item(NAME(m_fbc.m_prim_buf[i].m_a), i); - } + m_fbc.m_prim_buf = std::make_unique<vertex[]>(0x1000); // Unknown size on hardware + save_pointer(NAME(reinterpret_cast<uint8_t*>(m_fbc.m_prim_buf.get())), sizeof(vertex) * 0x1000); save_item(NAME(m_fbc.m_curr_prim_type)); + + save_item(NAME(m_thc_misc)); + save_item(NAME(m_cursor_x)); + save_item(NAME(m_cursor_y)); } void sbus_cgsix_device::device_reset() { - memset(&m_fbc, 0, sizeof(m_fbc)); + m_fbc.m_vertex_count = 0; + m_thc_misc = 0; } uint32_t sbus_cgsix_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) { - const pen_t *pens = m_ramdac->pens(); - uint8_t *vram = (uint8_t *)&m_vram[0]; + pen_t const *const pens = m_ramdac->pens(); + auto const vram = util::big_endian_cast<uint8_t const>(&m_vram[0]); - for (int y = 0; y < 900; y++) + for (int16_t y = 0; y < 900; y++) { - uint32_t *scanline = &bitmap.pix32(y); - for (int x = 0; x < 1152; x++) + uint32_t *scanline = &bitmap.pix(y); + const bool cursor_row_hit = (y >= m_cursor_y && y < (m_cursor_y + 32)); + for (int16_t x = 0; x < 1152; x++) { - const uint8_t pixel = vram[y * 1152 + BYTE4_XOR_BE(x)]; + uint8_t cursor_pixel = 0; + const bool cursor_column_hit = (x >= m_cursor_x && x < (m_cursor_x + 32)); + if (cursor_row_hit && cursor_column_hit) + { + const int16_t cursor_row = y - m_cursor_y; + const uint32_t cursor_bit = 31 - (x - m_cursor_x); + const uint32_t cursor_plane_a = m_cursor_ram[cursor_row]; + const uint32_t cursor_plane_b = m_cursor_ram[cursor_row + 32]; + cursor_pixel = (BIT(cursor_plane_b, cursor_bit) << 1) | BIT(cursor_plane_a, cursor_bit); + if (cursor_pixel) + { + *scanline++ = pens[0x100 + cursor_pixel]; + continue; + } + } + + const uint8_t pixel = vram[y * 1152 + x]; *scanline++ = pens[pixel]; } } @@ -183,36 +204,42 @@ uint32_t sbus_cgsix_device::screen_update(screen_device &screen, bitmap_rgb32 &b return 0; } -READ32_MEMBER(sbus_cgsix_device::rom_r) +uint32_t sbus_cgsix_device::rom_r(offs_t offset) { return ((uint32_t*)m_rom->base())[offset]; } -READ32_MEMBER(sbus_cgsix_device::unknown_r) +uint32_t sbus_cgsix_device::unknown_r(offs_t offset, uint32_t mem_mask) { logerror("%s: unknown_r: %08x & %08x\n", machine().describe_context(), offset << 2, mem_mask); return 0; } -WRITE32_MEMBER(sbus_cgsix_device::unknown_w) +void sbus_cgsix_device::unknown_w(offs_t offset, uint32_t data, uint32_t mem_mask) { logerror("%s: unknown_w: %08x = %08x & %08x\n", machine().describe_context(), offset << 2, data, mem_mask); } -READ32_MEMBER(sbus_cgsix_device::vram_r) +uint32_t sbus_cgsix_device::vram_r(offs_t offset) { return m_vram[offset]; } -WRITE32_MEMBER(sbus_cgsix_device::vram_w) +void sbus_cgsix_device::vram_w(offs_t offset, uint32_t data, uint32_t mem_mask) { COMBINE_DATA(&m_vram[offset]); } -uint8_t sbus_cgsix_device::perform_rasterop(uint8_t src, uint8_t dst) +uint8_t sbus_cgsix_device::perform_rasterop(uint8_t src, uint8_t dst, uint8_t mask) { const uint32_t rops[4] = { fbc_rasterop_rop00(), fbc_rasterop_rop01(), fbc_rasterop_rop10(), fbc_rasterop_rop11() }; + if (fbc_misc_data() == FBC_MISC_DATA_COLOR1) + { + src = BIT(src, 0) * 0xff; + dst = BIT(dst, 0) * 0xff; + } + uint8_t result = 0; //logerror("src:%02x dst:%02x\n", src, dst); for (int bit = 0; bit < 8; bit++) @@ -223,7 +250,8 @@ uint8_t sbus_cgsix_device::perform_rasterop(uint8_t src, uint8_t dst) const uint8_t s = src & mask; const uint8_t d = dst & mask; const uint32_t rop = rops[f | b]; - //logerror("f:%d b:%d s:%02x d:%02x rop:%d\n", f >> 1, b, s, d, rop); + //if (fbc_misc_data() == FBC_MISC_DATA_COLOR8) + //logerror("f:%d b:%d s:%02x d:%02x rop:%d\n", f >> 1, b, s, d, rop); uint8_t value = 0; switch (rop) @@ -248,31 +276,45 @@ uint8_t sbus_cgsix_device::perform_rasterop(uint8_t src, uint8_t dst) } result |= value & mask; } + //if (fbc_misc_data() == FBC_MISC_DATA_COLOR8) + //logerror("result: %02x\n", result); return result; } void sbus_cgsix_device::handle_font_poke() { - if (fbc_misc_draw() != FBC_MISC_DRAW_RENDER) + if (fbc_misc_draw() > FBC_MISC_DRAW_RENDER) { logerror("handle_font_poke: Unsupported font draw mode %d, abandoning draw\n", fbc_misc_draw()); return; } + const bool color8 = (fbc_misc_data() == FBC_MISC_DATA_COLOR8); + + uint32_t pixel_mask = fbc_get_pixel_mask(); + uint8_t plane_mask = fbc_get_plane_mask(); + const uint32_t daddr = m_fbc.m_y0 * 1152; - uint8_t *vram = (uint8_t*)&m_vram[0]; - vram += daddr; + auto const vram = util::big_endian_cast<uint8_t>(&m_vram[0]) + daddr; const int width = (int)m_fbc.m_x1 - (int)m_fbc.m_x0; const uint32_t font = m_fbc.m_font; uint32_t x = m_fbc.m_x0; - logerror("Width: %d, bits %d to %d\n", width, 31, 31 - width); - for (int bit = 31; bit >= (31 - width); bit--) + //logerror("Width: %d, bits %d to %d\n", width, 31, 31 - width); + int step_size = color8 ? 8 : 1; + int start_bit = 32 - step_size; + + for (int bit = start_bit; bit >= (start_bit - width * step_size) && x < 1152; bit -= step_size, x++) { - const uint8_t src = BIT(font, bit) ? 0xff : 0x00; - const uint8_t dst = vram[BYTE4_XOR_BE(x)]; - vram[BYTE4_XOR_BE(x)]= perform_rasterop(src, dst); - x++; - if (x >= 1152) break; + if (!BIT(pixel_mask, 31 - (x % 32))) + continue; + + uint8_t src = 0; + if (color8) + src = (font >> bit) & 0xff; + else + src = BIT(font, bit) ? 0xff : 0x00; + const uint8_t dst = vram[x]; + vram[x] = perform_rasterop(src, dst, plane_mask); } m_fbc.m_x0 += m_fbc.m_autoincx; m_fbc.m_x1 += m_fbc.m_autoincx; @@ -280,10 +322,42 @@ void sbus_cgsix_device::handle_font_poke() m_fbc.m_y1 += m_fbc.m_autoincy; } +uint32_t sbus_cgsix_device::fbc_get_pixel_mask() +{ + switch (fbc_rasterop_pixel()) + { + default: // Ignore + return 0xffffffff; + case 1: // Zeros + return 0x00000000; + case 2: // Ones + return 0xffffffff; + break; + case 3: // Mask + return m_fbc.m_pixel_mask; + } +} + +uint8_t sbus_cgsix_device::fbc_get_plane_mask() +{ + switch (fbc_rasterop_plane()) + { + default: // Ignore + return 0xff; + case 1: // Zeros + return 0x00; + case 2: // Ones + return 0xff; + break; + case 3: // Mask + return (uint8_t)m_fbc.m_plane_mask; + } +} + // NOTE: This is basically untested, and probably full of bugs! void sbus_cgsix_device::handle_draw_command() { - if (fbc_misc_draw() != FBC_MISC_DRAW_RENDER) + if (fbc_misc_draw() > FBC_MISC_DRAW_RENDER) { logerror("handle_draw_command: Unsupported draw mode %d, abandoning draw\n", fbc_misc_draw()); return; @@ -301,23 +375,48 @@ void sbus_cgsix_device::handle_draw_command() return; } - uint8_t *vram = (uint8_t*)&m_vram[0]; + auto const vram = util::big_endian_cast<uint8_t>(&m_vram[0]); + + uint32_t pixel_mask = fbc_get_pixel_mask(); + uint8_t plane_mask = fbc_get_plane_mask(); uint32_t vindex = 0; while (vindex < m_fbc.m_vertex_count) { - vertex_t &v0 = m_fbc.m_prim_buf[vindex++]; - vertex_t &v1 = m_fbc.m_prim_buf[vindex++]; + vertex &v0 = m_fbc.m_prim_buf[vindex++]; + vertex &v1 = m_fbc.m_prim_buf[vindex++]; for (uint32_t y = v0.m_absy; y <= v1.m_absy; y++) { - uint8_t *line = &vram[y * 1152]; + auto const line = vram + (y * 1152); + const uint16_t patt_y_index = (y - m_fbc.m_patt_align_y) % 16; for (uint32_t x = v0.m_absx; x <= v1.m_absx; x++) { - const uint32_t native_x = BYTE4_XOR_BE(x); - const uint8_t src = line[native_x]; - const uint8_t dst = src; - line[native_x] = perform_rasterop(src, dst); + if (!BIT(pixel_mask, 31 - (x % 32))) + continue; + + uint8_t src = line[x]; + + switch (fbc_rasterop_pattern()) + { + default: // Ignore + break; + case 1: // Zeroes + src = 0x00; + break; + case 2: // Ones + src = 0xff; + break; + case 3: // Pattern register + { + const uint16_t patt_x_index = 15 - ((x - m_fbc.m_patt_align_x) % 16); + src = BIT(m_fbc.m_patterns[patt_y_index], patt_x_index) ? 0xff : 0x00; + break; + } + } + + const uint8_t dst = line[x]; + line[x] = perform_rasterop(src, dst, plane_mask); } } } @@ -327,7 +426,7 @@ void sbus_cgsix_device::handle_draw_command() // NOTE: This is basically untested, and probably full of bugs! void sbus_cgsix_device::handle_blit_command() { - uint8_t *vram = (uint8_t*)&m_vram[0]; + auto const vram = util::big_endian_cast<uint8_t>(&m_vram[0]); const uint32_t fbw = 1152;//(m_fbc.m_clip_maxx + 1); logerror("Copying from %d,%d-%d,%d to %d,%d-%d,%d, width %d, height %d\n" , m_fbc.m_x0, m_fbc.m_y0 @@ -339,27 +438,32 @@ void sbus_cgsix_device::handle_blit_command() uint32_t dsty = m_fbc.m_y2; for (; srcy < m_fbc.m_y1; srcy++, dsty++) { - uint8_t *srcline = &vram[srcy * fbw]; - uint8_t *dstline = &vram[dsty * fbw]; + auto srcline = vram + (srcy * fbw); + auto dstline = vram + (dsty * fbw); uint32_t srcx = m_fbc.m_x0; uint32_t dstx = m_fbc.m_x2; for (; srcx < m_fbc.m_x1; srcx++, dstx++) { - const uint32_t native_dstx = BYTE4_XOR_BE(dstx); - const uint8_t src = srcline[BYTE4_XOR_BE(srcx)]; - const uint8_t dst = dstline[native_dstx]; + const uint8_t src = srcline[srcx]; + const uint8_t dst = dstline[dstx]; const uint8_t result = perform_rasterop(src, dst); //logerror("vram[%d] = %02x\n", result); - dstline[native_dstx] = result; + dstline[dstx] = result; } } } -READ32_MEMBER(sbus_cgsix_device::fbc_r) +uint32_t sbus_cgsix_device::fbc_r(offs_t offset, uint32_t mem_mask) { uint32_t ret = 0; switch (offset) { + case FBC_CONFIG: + { + const uint32_t data = (m_fbc.m_config & FBC_CONFIG_MASK) | FBC_CONFIG_FBID | FBC_CONFIG_VERSION; + logerror("%s: fbc_r: CONFIG (%08x & %08x)\n", machine().describe_context(), data, mem_mask); + return data; + } case FBC_MISC: logerror("fbc_r: MISC (%08x & %08x)\n", m_fbc.m_misc, mem_mask); return m_fbc.m_misc; @@ -662,7 +766,7 @@ READ32_MEMBER(sbus_cgsix_device::fbc_r) return ret; } -WRITE32_MEMBER(sbus_cgsix_device::fbc_w) +void sbus_cgsix_device::fbc_w(offs_t offset, uint32_t data, uint32_t mem_mask) { static char const *const misc_bdisp_name[4] = { "IGNORE", "0", "1", "ILLEGAL" }; static char const *const misc_bread_name[4] = { "IGNORE", "0", "1", "ILLEGAL" }; @@ -686,6 +790,10 @@ WRITE32_MEMBER(sbus_cgsix_device::fbc_w) switch (offset) { + case FBC_CONFIG: + COMBINE_DATA(&m_fbc.m_config); + logerror("fbc_w: CONFIG = %08x & %08x)\n", data, mem_mask); + break; case FBC_MISC: COMBINE_DATA(&m_fbc.m_misc); logerror("fbc_w: MISC = %08x & %08x\n", data, mem_mask); @@ -818,7 +926,7 @@ WRITE32_MEMBER(sbus_cgsix_device::fbc_w) COMBINE_DATA(&m_fbc.m_clip_maxx); break; case FBC_CLIP_MAXY: - logerror("fbc_w: CLIP_MAXY (%08x & %08x\n", data, mem_mask); + logerror("fbc_w: CLIP_MAXY = %08x & %08x\n", data, mem_mask); COMBINE_DATA(&m_fbc.m_clip_maxy); break; @@ -857,38 +965,56 @@ WRITE32_MEMBER(sbus_cgsix_device::fbc_w) case FBC_PATT_ALIGN: logerror("fbc_w: PATT_ALIGN = %08x & %08x\n", data, mem_mask); COMBINE_DATA(&m_fbc.m_patt_align); + m_fbc.m_patt_align_x = (m_fbc.m_patt_align >> 16) & 0x000f; + m_fbc.m_patt_align_y = m_fbc.m_patt_align & 0x000f; break; case FBC_PATTERN0: logerror("fbc_w: PATTERN0 = %08x & %08x\n", data, mem_mask); COMBINE_DATA(&m_fbc.m_pattern[0]); + m_fbc.m_patterns[0] = m_fbc.m_pattern[0] >> 16; + m_fbc.m_patterns[1] = (uint16_t)m_fbc.m_pattern[0]; break; case FBC_PATTERN1: logerror("fbc_w: PATTERN1 = %08x & %08x\n", data, mem_mask); COMBINE_DATA(&m_fbc.m_pattern[1]); + m_fbc.m_patterns[2] = m_fbc.m_pattern[1] >> 16; + m_fbc.m_patterns[3] = (uint16_t)m_fbc.m_pattern[1]; break; case FBC_PATTERN2: logerror("fbc_w: PATTERN2 = %08x & %08x\n", data, mem_mask); COMBINE_DATA(&m_fbc.m_pattern[2]); + m_fbc.m_patterns[4] = m_fbc.m_pattern[2] >> 16; + m_fbc.m_patterns[5] = (uint16_t)m_fbc.m_pattern[2]; break; case FBC_PATTERN3: logerror("fbc_w: PATTERN3 = %08x & %08x\n", data, mem_mask); COMBINE_DATA(&m_fbc.m_pattern[3]); + m_fbc.m_patterns[6] = m_fbc.m_pattern[3] >> 16; + m_fbc.m_patterns[7] = (uint16_t)m_fbc.m_pattern[3]; break; case FBC_PATTERN4: logerror("fbc_w: PATTERN4 = %08x & %08x\n", data, mem_mask); COMBINE_DATA(&m_fbc.m_pattern[4]); + m_fbc.m_patterns[8] = m_fbc.m_pattern[4] >> 16; + m_fbc.m_patterns[9] = (uint16_t)m_fbc.m_pattern[4]; break; case FBC_PATTERN5: logerror("fbc_w: PATTERN5 = %08x & %08x\n", data, mem_mask); COMBINE_DATA(&m_fbc.m_pattern[5]); + m_fbc.m_patterns[10] = m_fbc.m_pattern[5] >> 16; + m_fbc.m_patterns[11] = (uint16_t)m_fbc.m_pattern[5]; break; case FBC_PATTERN6: logerror("fbc_w: PATTERN6 = %08x & %08x\n", data, mem_mask); COMBINE_DATA(&m_fbc.m_pattern[6]); + m_fbc.m_patterns[12] = m_fbc.m_pattern[6] >> 16; + m_fbc.m_patterns[13] = (uint16_t)m_fbc.m_pattern[6]; break; case FBC_PATTERN7: logerror("fbc_w: PATTERN7 = %08x & %08x\n", data, mem_mask); COMBINE_DATA(&m_fbc.m_pattern[7]); + m_fbc.m_patterns[14] = m_fbc.m_pattern[7] >> 16; + m_fbc.m_patterns[15] = (uint16_t)m_fbc.m_pattern[7]; break; case FBC_IPOINT_ABSX: @@ -1104,6 +1230,71 @@ WRITE32_MEMBER(sbus_cgsix_device::fbc_w) } } +uint32_t sbus_cgsix_device::cursor_address_r() +{ + return (m_cursor_x << 16) | (uint16_t)m_cursor_y; +} + +void sbus_cgsix_device::cursor_address_w(uint32_t data) +{ + m_cursor_x = (int16_t)(data >> 16); + m_cursor_y = (int16_t)data; +} + +uint32_t sbus_cgsix_device::cursor_ram_r(offs_t offset) +{ + return m_cursor_ram[offset]; +} + +void sbus_cgsix_device::cursor_ram_w(offs_t offset, uint32_t data, uint32_t mem_mask) +{ + COMBINE_DATA(&m_cursor_ram[offset]); +} + +uint32_t sbus_cgsix_device::thc_misc_r(offs_t offset, uint32_t mem_mask) +{ + logerror("thc_misc_r: %08x & %08x\n", m_thc_misc | THC_MISC_REV, mem_mask); + return m_thc_misc | THC_MISC_REV; +} + +void sbus_cgsix_device::thc_misc_w(offs_t offset, uint32_t data, uint32_t mem_mask) +{ + logerror("thc_misc_w: %08x & %08x\n", data, mem_mask); + if (BIT(data, THC_MISC_IRQ_BIT) && BIT(m_thc_misc, THC_MISC_IRQ_BIT)) + { + data &= ~(1 << THC_MISC_IRQ_BIT); + lower_irq(4); + } + if (BIT(data, THC_MISC_IRQEN_BIT)) + { + data &= ~(1 << THC_MISC_IRQ_BIT); + } + + COMBINE_DATA(&m_thc_misc); + m_thc_misc &= THC_MISC_WRITE_MASK; +} + +void sbus_cgsix_device::vblank_w(int state) +{ + int old_state = BIT(m_thc_misc, THC_MISC_VSYNC_BIT); + if (old_state != state) + { + if (state) + { + m_thc_misc |= 1 << THC_MISC_VSYNC_BIT; + if (BIT(m_thc_misc, THC_MISC_IRQEN_BIT)) + { + m_thc_misc |= 1 << THC_MISC_IRQ_BIT; + raise_irq(4); + } + } + else + { + m_thc_misc &= ~(1 << THC_MISC_VSYNC_BIT); + } + } +} + //------------------------------------------------- // TurboGX implementation //------------------------------------------------- @@ -1128,9 +1319,8 @@ void sbus_turbogx_device::device_add_mconfig(machine_config &config) { SCREEN(config, m_screen, SCREEN_TYPE_RASTER); m_screen->set_screen_update(FUNC(sbus_turbogx_device::screen_update)); - m_screen->set_size(1152, 900); - m_screen->set_visarea(0, 1152-1, 0, 900-1); - m_screen->set_refresh_hz(72); + m_screen->set_raw(105.561_MHz_XTAL, 1472, 0, 1152, 943, 0, 900); + m_screen->screen_vblank().set(FUNC(sbus_turbogx_device::vblank_w)); BT458(config, m_ramdac, 0); } @@ -1172,6 +1362,7 @@ void sbus_turbogxp_device::device_add_mconfig(machine_config &config) m_screen->set_size(1152, 900); m_screen->set_visarea(0, 1152-1, 0, 900-1); m_screen->set_refresh_hz(72); + m_screen->screen_vblank().set(FUNC(sbus_turbogxp_device::vblank_w)); BT467(config, m_ramdac, 0); } |