src/mess/video/abc800.c
| r0 | r3470 | |
| 1 | /*****************************************************************************
|
| 2 | *
|
| 3 | * video/abc800.c
|
| 4 | *
|
| 5 | ****************************************************************************/
|
| 6 | |
| 7 | /*
|
| 8 | |
| 9 | TODO:
|
| 10 | |
| 11 | - add proper screen parameters to startup
|
| 12 | - abc800m high resolution (HR)
|
| 13 | - abc800c row update
|
| 14 | - abc800c palette
|
| 15 | - abc800c high resolution (HR)
|
| 16 | |
| 17 | */
|
| 18 | |
| 19 | #include "driver.h"
|
| 20 | #include "includes/abc80x.h"
|
| 21 | #include "machine/z80dart.h"
|
| 22 | #include "video/mc6845.h"
|
| 23 | |
| 24 | /* Palette Initialization */
|
| 25 | |
| 26 | static PALETTE_INIT( abc800m )
|
| 27 | {
|
| 28 | palette_set_color_rgb(machine, 0, 0x00, 0x00, 0x00); // black
|
| 29 | palette_set_color_rgb(machine, 1, 0xff, 0xff, 0x00); // yellow (really white, but blue signal is disconnected from monitor)
|
| 30 | }
|
| 31 | |
| 32 | static PALETTE_INIT( abc800c )
|
| 33 | {
|
| 34 | palette_set_color_rgb(machine, 0, 0x00, 0x00, 0x00); // black
|
| 35 | palette_set_color_rgb(machine, 1, 0x00, 0x00, 0xff); // blue
|
| 36 | palette_set_color_rgb(machine, 2, 0xff, 0x00, 0x00); // red
|
| 37 | palette_set_color_rgb(machine, 3, 0xff, 0x00, 0xff); // magenta
|
| 38 | palette_set_color_rgb(machine, 4, 0x00, 0xff, 0x00); // green
|
| 39 | palette_set_color_rgb(machine, 5, 0x00, 0xff, 0xff); // cyan
|
| 40 | palette_set_color_rgb(machine, 6, 0xff, 0xff, 0x00); // yellow
|
| 41 | palette_set_color_rgb(machine, 7, 0xff, 0xff, 0xff); // white
|
| 42 | }
|
| 43 | |
| 44 | /* External Interface */
|
| 45 | |
| 46 | WRITE8_HANDLER( abc800m_hrs_w )
|
| 47 | {
|
| 48 | }
|
| 49 | |
| 50 | WRITE8_HANDLER( abc800m_hrc_w )
|
| 51 | {
|
| 52 | }
|
| 53 | |
| 54 | WRITE8_HANDLER( abc800c_hrs_w )
|
| 55 | {
|
| 56 | }
|
| 57 | |
| 58 | WRITE8_HANDLER( abc800c_hrc_w )
|
| 59 | {
|
| 60 | }
|
| 61 | |
| 62 | /* MC6845 Row Update */
|
| 63 | |
| 64 | static MC6845_UPDATE_ROW( abc800m_update_row )
|
| 65 | {
|
| 66 | abc800_state *state = device->machine->driver_data;
|
| 67 | |
| 68 | int column;
|
| 69 | |
| 70 | for (column = 0; column < x_count; column++)
|
| 71 | {
|
| 72 | int bit;
|
| 73 | |
| 74 | UINT16 address = (videoram[(ma + column) & 0x7ff] << 4) | (ra & 0x0f);
|
| 75 | UINT8 data = (state->char_rom[address & 0x7ff] & 0x3f);
|
| 76 | |
| 77 | if (column == cursor_x)
|
| 78 | {
|
| 79 | data = 0x3f;
|
| 80 | }
|
| 81 | |
| 82 | data <<= 2;
|
| 83 | |
| 84 | for (bit = 0; bit < ABC800_CHAR_WIDTH; bit++)
|
| 85 | {
|
| 86 | int x = (column * ABC800_CHAR_WIDTH) + bit;
|
| 87 | int color = BIT(data, 7);
|
| 88 | |
| 89 | *BITMAP_ADDR16(bitmap, y, x) = color;
|
| 90 | |
| 91 | data <<= 1;
|
| 92 | }
|
| 93 | }
|
| 94 | }
|
| 95 | |
| 96 | static MC6845_ON_VSYNC_CHANGED(abc800_vsync_changed)
|
| 97 | {
|
| 98 | abc800_state *state = device->machine->driver_data;
|
| 99 | |
| 100 | z80dart_set_ri(state->z80dart, 1, vsync);
|
| 101 | }
|
| 102 | |
| 103 | static MC6845_UPDATE_ROW( abc800c_update_row )
|
| 104 | {
|
| 105 | }
|
| 106 | |
| 107 | /* MC6845 Interfaces */
|
| 108 | |
| 109 | static const mc6845_interface abc800m_mc6845_interface = {
|
| 110 | SCREEN_TAG,
|
| 111 | ABC800_CCLK,
|
| 112 | ABC800_CHAR_WIDTH,
|
| 113 | NULL,
|
| 114 | abc800m_update_row,
|
| 115 | NULL,
|
| 116 | NULL,
|
| 117 | NULL,
|
| 118 | abc800_vsync_changed
|
| 119 | };
|
| 120 | |
| 121 | static const mc6845_interface abc800c_mc6845_interface = {
|
| 122 | SCREEN_TAG,
|
| 123 | ABC800_CCLK,
|
| 124 | ABC800_CHAR_WIDTH,
|
| 125 | NULL,
|
| 126 | abc800c_update_row,
|
| 127 | NULL,
|
| 128 | NULL,
|
| 129 | NULL,
|
| 130 | abc800_vsync_changed
|
| 131 | };
|
| 132 | |
| 133 | /* Video Start */
|
| 134 | |
| 135 | static VIDEO_START( abc800 )
|
| 136 | {
|
| 137 | abc800_state *state = machine->driver_data;
|
| 138 | |
| 139 | /* find devices */
|
| 140 | |
| 141 | state->mc6845 = devtag_get_device(machine, MC6845, MC6845_TAG);
|
| 142 | |
| 143 | /* find memory regions */
|
| 144 | |
| 145 | state->char_rom = memory_region(machine, "chargen");
|
| 146 | }
|
| 147 | |
| 148 | /* Video Update */
|
| 149 | |
| 150 | static VIDEO_UPDATE( abc800m )
|
| 151 | {
|
| 152 | abc800_state *state = screen->machine->driver_data;
|
| 153 |
|
| 154 | mc6845_update(state->mc6845, bitmap, cliprect);
|
| 155 |
|
| 156 | return 0;
|
| 157 | }
|
| 158 | |
| 159 | static VIDEO_UPDATE( abc800c )
|
| 160 | {
|
| 161 | abc800_state *state = screen->machine->driver_data;
|
| 162 |
|
| 163 | mc6845_update(state->mc6845, bitmap, cliprect);
|
| 164 |
|
| 165 | return 0;
|
| 166 | }
|
| 167 | |
| 168 | /* Machine Drivers */
|
| 169 | |
| 170 | MACHINE_DRIVER_START( abc800m_video )
|
| 171 | // device interface
|
| 172 | MDRV_DEVICE_ADD(MC6845_TAG, MC6845)
|
| 173 | MDRV_DEVICE_CONFIG(abc800m_mc6845_interface)
|
| 174 | |
| 175 | // video hardware
|
| 176 | MDRV_SCREEN_ADD(SCREEN_TAG, RASTER)
|
| 177 | MDRV_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16)
|
| 178 | |
| 179 | MDRV_SCREEN_REFRESH_RATE(60)
|
| 180 | MDRV_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500))
|
| 181 | MDRV_SCREEN_SIZE(640, 400)
|
| 182 | MDRV_SCREEN_VISIBLE_AREA(0,640-1, 0, 400-1)
|
| 183 | |
| 184 | MDRV_PALETTE_LENGTH(2)
|
| 185 | |
| 186 | MDRV_PALETTE_INIT(abc800m)
|
| 187 | MDRV_VIDEO_START(abc800)
|
| 188 | MDRV_VIDEO_UPDATE(abc800m)
|
| 189 | MACHINE_DRIVER_END
|
| 190 | |
| 191 | MACHINE_DRIVER_START( abc800c_video )
|
| 192 | // device interface
|
| 193 | MDRV_DEVICE_ADD(MC6845_TAG, MC6845)
|
| 194 | MDRV_DEVICE_CONFIG(abc800c_mc6845_interface)
|
| 195 | |
| 196 | // video hardware
|
| 197 | MDRV_SCREEN_ADD(SCREEN_TAG, RASTER)
|
| 198 | MDRV_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16)
|
| 199 | |
| 200 | MDRV_SCREEN_REFRESH_RATE(60)
|
| 201 | MDRV_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500))
|
| 202 | MDRV_SCREEN_SIZE(640, 400)
|
| 203 | MDRV_SCREEN_VISIBLE_AREA(0,640-1, 0, 400-1)
|
| 204 | |
| 205 | MDRV_PALETTE_LENGTH(2)
|
| 206 | |
| 207 | MDRV_PALETTE_INIT(abc800c)
|
| 208 | MDRV_VIDEO_START(abc800)
|
| 209 | MDRV_VIDEO_UPDATE(abc800c)
|
| 210 | MACHINE_DRIVER_END
|
src/mess/video/abc802.c
| r0 | r3470 | |
| 1 | /*****************************************************************************
|
| 2 | *
|
| 3 | * video/abc802.c
|
| 4 | *
|
| 5 | ****************************************************************************/
|
| 6 | |
| 7 | /*
|
| 8 | |
| 9 | TODO:
|
| 10 | |
| 11 | - add proper screen parameters to startup
|
| 12 | - abc802 delay CUR and DEN by 3 CCLK's
|
| 13 | |
| 14 | */
|
| 15 | |
| 16 | /*
|
| 17 | |
| 18 | ABC 802 Video
|
| 19 | *************
|
| 20 | |
| 21 | 74LS166 @ 8B
|
| 22 | ------------
|
| 23 | |
| 24 | A <- ATTHAND INV
|
| 25 | B <- ATTHAND INV
|
| 26 | C <- ATTHAND O0
|
| 27 | D <- ATTHAND O1
|
| 28 | E <- CHARGEN A2
|
| 29 | F <- CHARGEN A3
|
| 30 | G <- CHARGEN A4
|
| 31 | H <- CHARGEN A5
|
| 32 | |
| 33 | SI <- ATTHAND RI
|
| 34 | |
| 35 | CHARGEN @ 3G
|
| 36 | ------------
|
| 37 | |
| 38 | A0 <- CRTC RA0
|
| 39 | A1 <- CRTC RA1
|
| 40 | A2 <- CRTC RA2
|
| 41 | A3 <- CRTC RA3
|
| 42 | A4 <- TX DATA 0
|
| 43 | A5 <- TX DATA 1
|
| 44 | A6 <- TX DATA 2
|
| 45 | A7 <- TX DATA 3
|
| 46 | A8 <- TX DATA 4
|
| 47 | A9 <- TX DATA 5
|
| 48 | A10 <- TX DATA 6
|
| 49 | A11 <- ATTHAND RG
|
| 50 | A12 <- TX DATA 7
|
| 51 | |
| 52 | D0 -> ATTHAND AT0
|
| 53 | D1 -> ATTHAND AT1
|
| 54 | D2 -> 74LS166 E
|
| 55 | D3 -> 74LS166 F
|
| 56 | D4 -> 74LS166 G
|
| 57 | D5 -> 74LS166 H
|
| 58 | D6 -> ATTHAND ATD
|
| 59 | D7 -> ATTHAND ATE
|
| 60 | |
| 61 | Notes:
|
| 62 | |
| 63 | - lines A0 thru A3 are pulled high when cursor is enabled
|
| 64 | |
| 65 | ATTHAND @ 2G
|
| 66 | ------------
|
| 67 | |
| 68 | AT0 <- CHARGEN D0
|
| 69 | AT1 <- CHARGEN D1
|
| 70 | ATD <- CHARGEN D6
|
| 71 | ATE <- CHARGEN D7
|
| 72 | CUR <- CUR-3
|
| 73 | FC <- FLSHCLK
|
| 74 | IHS <- HS
|
| 75 | LL <- 74LS166 L
|
| 76 | |
| 77 | O0 -> 74LS166 C
|
| 78 | O1 -> 74LS166 D
|
| 79 | RG -> CHARGEN A11
|
| 80 | RI -> 74LS166 SI
|
| 81 | INV -> 74LS166 A, 74LS166 B
|
| 82 | O ->
|
| 83 | |
| 84 | PAL equation:
|
| 85 | |
| 86 | IF (VCC) *OS = FC + RF / RC
|
| 87 | *RG: = HS / *RG + *ATE / *RG + ATD / *RG + LL /
|
| 88 | *RG + AT1 / *RG + AT0 / ATE + *ATD + *LL +
|
| 89 | *AT1 + *AT0
|
| 90 | *RI: = *RI + *INV / *RI + LL / *INV + *LL
|
| 91 | *RF: = HS / *RF + *ATE / *RF + ATD / *RF + LL /
|
| 92 | *RF + AT1 / *RF + AT0 / ATE + *ATD + *LL +
|
| 93 | *AT1 + AT0
|
| 94 | *RC: = HS / *RC + *ATE / *RC + *ATD / *RC + LL /
|
| 95 | *RC + *ATI / *RC + AT0 / ATE + *LL + *AT1 +
|
| 96 | *AT0
|
| 97 | IF (VCC) *O0 = *CUR + *AT0 / *CUR + ATE
|
| 98 | *O1 = *CUR + *AT1 / *CUR + ATE
|
| 99 | |
| 100 | |
| 101 | ATD Attribute data
|
| 102 | ATE Attribute enable
|
| 103 | AT0,AT1 Attribute address
|
| 104 | CUR Cursor
|
| 105 | FC FLSH clock
|
| 106 | HS Horizontal sync
|
| 107 | INV Inverted signal input
|
| 108 | LL Load when Low
|
| 109 | OEL Output Enable when Low
|
| 110 | RC
|
| 111 | RF Row flash
|
| 112 | RG Row graphic
|
| 113 | RI Row inverted
|
| 114 | |
| 115 | */
|
| 116 | |
| 117 | #include "driver.h"
|
| 118 | #include "includes/abc80x.h"
|
| 119 | #include "machine/z80dart.h"
|
| 120 | #include "video/mc6845.h"
|
| 121 | |
| 122 | /* MC6845 Row Update */
|
| 123 | |
| 124 | static MC6845_UPDATE_ROW( abc802_update_row )
|
| 125 | {
|
| 126 | abc802_state *state = device->machine->driver_data;
|
| 127 | |
| 128 | int column;
|
| 129 | |
| 130 | for (column = 0; column < x_count; column++)
|
| 131 | {
|
| 132 | int bit;
|
| 133 | |
| 134 | UINT8 code = videoram[(ma + column) & 0x7ff];
|
| 135 | UINT16 address = ((code & 0x80) << 5) | ((code & 0x7f) << 4);
|
| 136 | UINT8 ra_latch = ra;
|
| 137 | UINT8 data;
|
| 138 | |
| 139 | if (column == cursor_x)
|
| 140 | {
|
| 141 | ra_latch = 0x0f;
|
| 142 | }
|
| 143 | |
| 144 | data = state->char_rom[(address + ra_latch) & 0x1fff];
|
| 145 | |
| 146 | if (data & ABC802_ATE)
|
| 147 | {
|
| 148 | int rf = 0, rc = 0;
|
| 149 | |
| 150 | if (data & ABC802_ATD)
|
| 151 | {
|
| 152 | int attr = data & 0x03;
|
| 153 | |
| 154 | switch (attr)
|
| 155 | {
|
| 156 | case 0x00:
|
| 157 | // RG = 1
|
| 158 | address |= 0x800;
|
| 159 | break;
|
| 160 | |
| 161 | case 0x01:
|
| 162 | rf = 1;
|
| 163 | break;
|
| 164 | |
| 165 | case 0x02:
|
| 166 | rc = 1;
|
| 167 | break;
|
| 168 | |
| 169 | case 0x03:
|
| 170 | // undefined
|
| 171 | break;
|
| 172 | }
|
| 173 | |
| 174 | if ((state->flshclk && rf) || rc)
|
| 175 | {
|
| 176 | ra_latch = 0x0e;
|
| 177 | }
|
| 178 | }
|
| 179 | |
| 180 | // reload data and mask out two bottom bits
|
| 181 | data = state->char_rom[(address + ra_latch) & 0x1fff] & 0xfc;
|
| 182 | }
|
| 183 | |
| 184 | data <<= 2;
|
| 185 | |
| 186 | if (state->mux80_40)
|
| 187 | {
|
| 188 | for (bit = 0; bit < ABC800_CHAR_WIDTH; bit++)
|
| 189 | {
|
| 190 | int x = (column * ABC800_CHAR_WIDTH) + bit;
|
| 191 | int color = BIT(data, 7) ^ BIT(code, 7);
|
| 192 | |
| 193 | *BITMAP_ADDR16(bitmap, y, x) = color;
|
| 194 | |
| 195 | data <<= 1;
|
| 196 | }
|
| 197 | }
|
| 198 | else
|
| 199 | {
|
| 200 | for (bit = 0; bit < ABC800_CHAR_WIDTH; bit++)
|
| 201 | {
|
| 202 | int x = (column * ABC800_CHAR_WIDTH) + (bit << 1);
|
| 203 | int color = BIT(data, 7) ^ BIT(code, 7);
|
| 204 | |
| 205 | *BITMAP_ADDR16(bitmap, y, x) = color;
|
| 206 | *BITMAP_ADDR16(bitmap, y, x + 1) = color;
|
| 207 | |
| 208 | data <<= 1;
|
| 209 | }
|
| 210 | |
| 211 | column++;
|
| 212 | }
|
| 213 | }
|
| 214 | }
|
| 215 | |
| 216 | static MC6845_ON_VSYNC_CHANGED(abc802_vsync_changed)
|
| 217 | {
|
| 218 | abc802_state *state = device->machine->driver_data;
|
| 219 | |
| 220 | if (!vsync)
|
| 221 | {
|
| 222 | /* flash clock */
|
| 223 | if (state->flshclk_ctr == 31)
|
| 224 | {
|
| 225 | state->flshclk = 1;
|
| 226 | state->flshclk_ctr = 0;
|
| 227 | }
|
| 228 | else
|
| 229 | {
|
| 230 | state->flshclk = 0;
|
| 231 | state->flshclk_ctr++;
|
| 232 | }
|
| 233 | }
|
| 234 | |
| 235 | z80dart_set_ri(state->z80dart, 1, vsync);
|
| 236 | }
|
| 237 | |
| 238 | /* MC6845 Interfaces */
|
| 239 | |
| 240 | static const mc6845_interface abc802_mc6845_interface = {
|
| 241 | SCREEN_TAG,
|
| 242 | ABC800_CCLK,
|
| 243 | ABC800_CHAR_WIDTH,
|
| 244 | NULL,
|
| 245 | abc802_update_row,
|
| 246 | NULL,
|
| 247 | NULL,
|
| 248 | NULL,
|
| 249 | abc802_vsync_changed
|
| 250 | };
|
| 251 | |
| 252 | /* Video Start */
|
| 253 | |
| 254 | static VIDEO_START( abc802 )
|
| 255 | {
|
| 256 | abc802_state *state = machine->driver_data;
|
| 257 | |
| 258 | /* find devices */
|
| 259 | |
| 260 | state->mc6845 = devtag_get_device(machine, MC6845, MC6845_TAG);
|
| 261 | |
| 262 | /* find memory regions */
|
| 263 | |
| 264 | state->char_rom = memory_region(machine, "chargen");
|
| 265 | |
| 266 | /* register for state saving */
|
| 267 | |
| 268 | state_save_register_global(state->flshclk_ctr);
|
| 269 | state_save_register_global(state->flshclk);
|
| 270 | state_save_register_global(state->mux80_40);
|
| 271 | }
|
| 272 | |
| 273 | /* Video Update */
|
| 274 | |
| 275 | static VIDEO_UPDATE( abc802 )
|
| 276 | {
|
| 277 | abc802_state *state = screen->machine->driver_data;
|
| 278 |
|
| 279 | mc6845_update(state->mc6845, bitmap, cliprect);
|
| 280 |
|
| 281 | return 0;
|
| 282 | }
|
| 283 | |
| 284 | /* Machine Drivers */
|
| 285 | |
| 286 | MACHINE_DRIVER_START( abc802_video )
|
| 287 | // device interface
|
| 288 | MDRV_DEVICE_ADD(MC6845_TAG, MC6845)
|
| 289 | MDRV_DEVICE_CONFIG(abc802_mc6845_interface)
|
| 290 | |
| 291 | // video hardware
|
| 292 | MDRV_SCREEN_ADD(SCREEN_TAG, RASTER)
|
| 293 | MDRV_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16)
|
| 294 | |
| 295 | MDRV_SCREEN_REFRESH_RATE(60)
|
| 296 | MDRV_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500))
|
| 297 | MDRV_SCREEN_SIZE(640, 400)
|
| 298 | MDRV_SCREEN_VISIBLE_AREA(0,640-1, 0, 400-1)
|
| 299 | |
| 300 | MDRV_PALETTE_LENGTH(2)
|
| 301 | |
| 302 | MDRV_PALETTE_INIT(black_and_white)
|
| 303 | MDRV_VIDEO_START(abc802)
|
| 304 | MDRV_VIDEO_UPDATE(abc802)
|
| 305 | MACHINE_DRIVER_END
|
src/mess/drivers/abc80x.c
| r3469 | r3470 | |
| 88 | 88 | |
| 89 | 89 | /* Keyboard HACK */ |
| 90 | 90 | |
| 91 | | static emu_timer *abc800_keyboard_timer; |
| 92 | 91 | static int keylatch; |
| 93 | 92 | |
| 94 | 93 | static const UINT8 abc800_keycodes[7*4][8] = |
| 95 | 94 | { |
| 96 | 95 | // unshift |
| 97 | 96 | { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38 }, |
| 98 | | { 0x39, 0x30, 0x2B, 0x60, 0x3C, 0x71, 0x77, 0x65 }, |
| 99 | | { 0x72, 0x74, 0x79, 0x75, 0x69, 0x6F, 0x70, 0x7D }, |
| 100 | | { 0x7E, 0x0D, 0x61, 0x73, 0x64, 0x66, 0x67, 0x68 }, |
| 101 | | { 0x6A, 0x6B, 0x6C, 0x7C, 0x7B, 0x27, 0x08, 0x7A }, |
| 102 | | { 0x78, 0x63, 0x76, 0x62, 0x6E, 0x6D, 0x2C, 0x2E }, |
| 103 | | { 0x2D, 0x09, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00 }, |
| 97 | { 0x39, 0x30, 0x2b, 0x60, 0x3c, 0x71, 0x77, 0x65 }, |
| 98 | { 0x72, 0x74, 0x79, 0x75, 0x69, 0x6f, 0x70, 0x7d }, |
| 99 | { 0x7e, 0x0d, 0x61, 0x73, 0x64, 0x66, 0x67, 0x68 }, |
| 100 | { 0x6a, 0x6b, 0x6c, 0x7c, 0x7b, 0x27, 0x08, 0x7a }, |
| 101 | { 0x78, 0x63, 0x76, 0x62, 0x6e, 0x6d, 0x2c, 0x2e }, |
| 102 | { 0x2d, 0x09, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00 }, |
| 104 | 103 | |
| 105 | 104 | // shift |
| 106 | 105 | { 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x2f, 0x28 }, |
| r3469 | r3470 | |
| 189 | 188 | } |
| 190 | 189 | } |
| 191 | 190 | |
| 192 | | static TIMER_CALLBACK( abc800_keyboard_tick ) |
| 191 | static TIMER_DEVICE_CALLBACK( abc800_keyboard_tick ) |
| 193 | 192 | { |
| 194 | | abc800_keyboard_scan(machine); |
| 193 | abc800_keyboard_scan(timer->machine); |
| 195 | 194 | } |
| 196 | 195 | |
| 197 | 196 | /* Read/Write Handlers */ |
| r3469 | r3470 | |
| 707 | 706 | state->abc77_txd = level; |
| 708 | 707 | } |
| 709 | 708 | |
| 709 | static ABC77_ON_CLOCK_CHANGED( abc800_abc77_clock_changed ) |
| 710 | { |
| 711 | // abc800_state *state = device->machine->driver_data; |
| 712 | |
| 713 | /* clock into DART RxTxCB (Receiver/Transmitter Clock B) */ |
| 714 | } |
| 715 | |
| 710 | 716 | static ABC77_ON_KEYDOWN_CHANGED( abc800_abc77_keydown_changed ) |
| 711 | 717 | { |
| 712 | 718 | abc800_state *state = device->machine->driver_data; |
| r3469 | r3470 | |
| 717 | 723 | static ABC77_INTERFACE( abc800_abc77_intf ) |
| 718 | 724 | { |
| 719 | 725 | abc800_abc77_txd_changed, |
| 726 | abc800_abc77_clock_changed, |
| 720 | 727 | abc800_abc77_keydown_changed |
| 721 | 728 | }; |
| 722 | 729 | |
| 723 | 730 | static WRITE8_DEVICE_HANDLER( abc800_ctc_z2_w ) |
| 724 | 731 | { |
| 725 | | // write to DART channel A RxC/TxC |
| 732 | //abc800_state *state = device->machine->driver_data; |
| 733 | |
| 734 | /* write to DART channel A RxC/TxC */ |
| 726 | 735 | } |
| 727 | 736 | |
| 728 | 737 | static const z80ctc_interface abc800_ctc_intf = |
| r3469 | r3470 | |
| 791 | 800 | { NULL } |
| 792 | 801 | }; |
| 793 | 802 | |
| 794 | | static TIMER_CALLBACK(abc800_ctc_tick) |
| 803 | static void abc800_ctc_trg_w(const device_config *z80ctc) |
| 795 | 804 | { |
| 796 | | const device_config *device = ptr; |
| 805 | z80ctc_trg_w(z80ctc, 0, 1); |
| 806 | z80ctc_trg_w(z80ctc, 0, 0); |
| 797 | 807 | |
| 798 | | z80ctc_trg_w(device, 0, 1); |
| 799 | | z80ctc_trg_w(device, 0, 0); |
| 800 | | z80ctc_trg_w(device, 1, 1); |
| 801 | | z80ctc_trg_w(device, 1, 0); |
| 802 | | z80ctc_trg_w(device, 2, 1); |
| 803 | | z80ctc_trg_w(device, 2, 0); |
| 808 | z80ctc_trg_w(z80ctc, 1, 1); |
| 809 | z80ctc_trg_w(z80ctc, 1, 0); |
| 810 | |
| 811 | z80ctc_trg_w(z80ctc, 2, 1); |
| 812 | z80ctc_trg_w(z80ctc, 2, 0); |
| 804 | 813 | } |
| 805 | 814 | |
| 815 | static TIMER_DEVICE_CALLBACK( abc800_ctc_tick ) |
| 816 | { |
| 817 | abc800_state *state = timer->machine->driver_data; |
| 818 | |
| 819 | abc800_ctc_trg_w(state->z80ctc); |
| 820 | } |
| 821 | |
| 806 | 822 | static MACHINE_START( abc800 ) |
| 807 | 823 | { |
| 808 | 824 | abc800_state *state = machine->driver_data; |
| 809 | 825 | |
| 810 | | /* keyboard HACK */ |
| 811 | | |
| 812 | | abc800_keyboard_timer = timer_alloc(abc800_keyboard_tick, NULL); |
| 813 | | timer_adjust_periodic(abc800_keyboard_timer, attotime_zero, 0, ATTOTIME_IN_USEC(2500)); |
| 814 | | |
| 815 | 826 | /* find devices */ |
| 816 | 827 | |
| 817 | 828 | state->z80ctc = devtag_get_device(machine, Z80CTC, Z80CTC_TAG); |
| 818 | 829 | state->z80dart = devtag_get_device(machine, Z80DART, Z80DART_TAG); |
| 819 | 830 | state->z80sio = devtag_get_device(machine, Z80SIO, Z80SIO_TAG); |
| 820 | | |
| 821 | | /* allocate timer */ |
| 822 | | |
| 823 | | state->ctc_timer = timer_alloc(abc800_ctc_tick, (void *)state->z80ctc ); |
| 824 | | timer_adjust_periodic(state->ctc_timer, attotime_zero, 0, ATTOTIME_IN_HZ(ABC800_X01/2/2/2)); |
| 831 | //state->abc77 = devtag_get_device(machine, ABC77, ABC77_TAG); |
| 825 | 832 | } |
| 826 | 833 | |
| 827 | 834 | // ABC802 |
| r3469 | r3470 | |
| 833 | 840 | state->abc77_txd = level; |
| 834 | 841 | } |
| 835 | 842 | |
| 843 | static ABC77_ON_CLOCK_CHANGED( abc802_abc77_clock_changed ) |
| 844 | { |
| 845 | // abc802_state *state = device->machine->driver_data; |
| 846 | |
| 847 | /* clock into DART RxTxCB (Receiver/Transmitter Clock B) */ |
| 848 | } |
| 849 | |
| 836 | 850 | static ABC77_ON_KEYDOWN_CHANGED( abc802_abc77_keydown_changed ) |
| 837 | 851 | { |
| 838 | 852 | abc802_state *state = device->machine->driver_data; |
| r3469 | r3470 | |
| 843 | 857 | static ABC77_INTERFACE( abc802_abc77_intf ) |
| 844 | 858 | { |
| 845 | 859 | abc802_abc77_txd_changed, |
| 860 | abc802_abc77_clock_changed, |
| 846 | 861 | abc802_abc77_keydown_changed |
| 847 | 862 | }; |
| 848 | 863 | |
| r3469 | r3470 | |
| 876 | 891 | dart_serial_receive /* receive handler */ |
| 877 | 892 | }; |
| 878 | 893 | |
| 894 | static TIMER_DEVICE_CALLBACK( abc802_ctc_tick ) |
| 895 | { |
| 896 | abc802_state *state = timer->machine->driver_data; |
| 897 | |
| 898 | abc800_ctc_trg_w(state->z80ctc); |
| 899 | } |
| 900 | |
| 901 | static WRITE8_DEVICE_HANDLER( abc802_ctc_z2_w ) |
| 902 | { |
| 903 | // abc802_state *state = device->machine->driver_data; |
| 904 | |
| 905 | /* write to DART channel A RxC/TxC */ |
| 906 | } |
| 907 | |
| 908 | static const z80ctc_interface abc802_ctc_intf = |
| 909 | { |
| 910 | Z80_TAG, /* cpu */ |
| 911 | ABC800_X01/2/2, /* clock */ |
| 912 | 0, /* timer disables */ |
| 913 | 0, /* interrupt handler */ |
| 914 | 0, /* ZC/TO0 callback */ |
| 915 | 0, /* ZC/TO1 callback */ |
| 916 | abc802_ctc_z2_w /* ZC/TO2 callback */ |
| 917 | }; |
| 918 | |
| 879 | 919 | static MACHINE_START( abc802 ) |
| 880 | 920 | { |
| 881 | 921 | abc802_state *state = machine->driver_data; |
| r3469 | r3470 | |
| 885 | 925 | state->z80ctc = devtag_get_device(machine, Z80CTC, Z80CTC_TAG); |
| 886 | 926 | state->z80dart = devtag_get_device(machine, Z80DART, Z80DART_TAG); |
| 887 | 927 | state->z80sio = devtag_get_device(machine, Z80SIO, Z80SIO_TAG); |
| 928 | state->abc77 = devtag_get_device(machine, ABC77, ABC77_TAG); |
| 888 | 929 | |
| 889 | | /* allocate timer */ |
| 890 | | |
| 891 | | state->ctc_timer = timer_alloc(abc800_ctc_tick, (void *)state->z80ctc ); |
| 892 | | timer_adjust_periodic(state->ctc_timer, attotime_zero, 0, ATTOTIME_IN_HZ(ABC800_X01/2/2/2)); |
| 893 | | |
| 894 | 930 | /* configure memory */ |
| 895 | 931 | |
| 896 | 932 | memory_configure_bank(1, 0, 1, memory_region(machine, Z80_TAG), 0); |
| r3469 | r3470 | |
| 911 | 947 | state->abc77_txd = level; |
| 912 | 948 | } |
| 913 | 949 | |
| 950 | static ABC77_ON_CLOCK_CHANGED( abc806_abc77_clock_changed ) |
| 951 | { |
| 952 | // abc806_state *state = device->machine->driver_data; |
| 953 | |
| 954 | /* clock into DART RxTxCB (Receiver/Transmitter Clock B) */ |
| 955 | } |
| 956 | |
| 914 | 957 | static ABC77_ON_KEYDOWN_CHANGED( abc806_abc77_keydown_changed ) |
| 915 | 958 | { |
| 916 | 959 | abc806_state *state = device->machine->driver_data; |
| r3469 | r3470 | |
| 921 | 964 | static ABC77_INTERFACE( abc806_abc77_intf ) |
| 922 | 965 | { |
| 923 | 966 | abc806_abc77_txd_changed, |
| 967 | abc806_abc77_clock_changed, |
| 924 | 968 | abc806_abc77_keydown_changed |
| 925 | 969 | }; |
| 926 | 970 | |
| r3469 | r3470 | |
| 951 | 995 | dart_serial_receive /* receive handler */ |
| 952 | 996 | }; |
| 953 | 997 | |
| 998 | static TIMER_DEVICE_CALLBACK( abc806_ctc_tick ) |
| 999 | { |
| 1000 | abc806_state *state = timer->machine->driver_data; |
| 1001 | |
| 1002 | abc800_ctc_trg_w(state->z80ctc); |
| 1003 | } |
| 1004 | |
| 1005 | static WRITE8_DEVICE_HANDLER( abc806_ctc_z2_w ) |
| 1006 | { |
| 1007 | // abc806_state *state = device->machine->driver_data; |
| 1008 | |
| 1009 | /* write to DART channel A RxC/TxC */ |
| 1010 | } |
| 1011 | |
| 1012 | static const z80ctc_interface abc806_ctc_intf = |
| 1013 | { |
| 1014 | Z80_TAG, /* cpu */ |
| 1015 | ABC800_X01/2/2, /* clock */ |
| 1016 | 0, /* timer disables */ |
| 1017 | 0, /* interrupt handler */ |
| 1018 | 0, /* ZC/TO0 callback */ |
| 1019 | 0, /* ZC/TO1 callback */ |
| 1020 | abc806_ctc_z2_w /* ZC/TO2 callback */ |
| 1021 | }; |
| 1022 | |
| 954 | 1023 | static MACHINE_START( abc806 ) |
| 955 | 1024 | { |
| 956 | 1025 | abc806_state *state = machine->driver_data; |
| r3469 | r3470 | |
| 964 | 1033 | state->z80dart = devtag_get_device(machine, Z80DART, Z80DART_TAG); |
| 965 | 1034 | state->z80sio = devtag_get_device(machine, Z80SIO, Z80SIO_TAG); |
| 966 | 1035 | state->e0516 = devtag_get_device(machine, E0516, E0516_TAG); |
| 1036 | state->abc77 = devtag_get_device(machine, ABC77, ABC77_TAG); |
| 967 | 1037 | |
| 968 | | /* allocate timer */ |
| 969 | | |
| 970 | | state->ctc_timer = timer_alloc(abc800_ctc_tick, (void *)state->z80ctc ); |
| 971 | | timer_adjust_periodic(state->ctc_timer, attotime_zero, 0, ATTOTIME_IN_HZ(ABC800_X01/2/2/2)); |
| 972 | | |
| 973 | 1038 | /* setup memory banking */ |
| 974 | 1039 | |
| 975 | 1040 | state->videoram = auto_malloc(ABC806_VIDEO_RAM_SIZE); |
| r3469 | r3470 | |
| 1019 | 1084 | |
| 1020 | 1085 | MDRV_MACHINE_START(abc800) |
| 1021 | 1086 | |
| 1087 | /* fake keyboard */ |
| 1088 | MDRV_TIMER_ADD_PERIODIC("keyboard", abc800_keyboard_tick, USEC(2500)) |
| 1089 | |
| 1022 | 1090 | /* ABC-77 keyboard */ |
| 1023 | 1091 | /* MDRV_SPEAKER_STANDARD_MONO("mono") |
| 1024 | 1092 | MDRV_DEVICE_ADD(ABC77_TAG, ABC77) |
| r3469 | r3470 | |
| 1027 | 1095 | /* video hardware */ |
| 1028 | 1096 | MDRV_IMPORT_FROM(abc800m_video) |
| 1029 | 1097 | |
| 1098 | /* Z80 CTC */ |
| 1030 | 1099 | MDRV_Z80CTC_ADD( Z80CTC_TAG, abc800_ctc_intf ) |
| 1100 | MDRV_TIMER_ADD_PERIODIC("ctc", abc800_ctc_tick, HZ(ABC800_X01/2/2/2)) |
| 1101 | |
| 1102 | /* Z80 SIO/2 */ |
| 1031 | 1103 | MDRV_Z80SIO_ADD( Z80SIO_TAG, abc800_sio_intf ) |
| 1104 | |
| 1105 | /* Z80 DART */ |
| 1032 | 1106 | MDRV_Z80DART_ADD( Z80DART_TAG, abc800_dart_intf ) |
| 1033 | 1107 | |
| 1034 | 1108 | /* printer */ |
| r3469 | r3470 | |
| 1049 | 1123 | |
| 1050 | 1124 | MDRV_MACHINE_START(abc800) |
| 1051 | 1125 | |
| 1126 | /* fake keyboard */ |
| 1127 | MDRV_TIMER_ADD_PERIODIC("keyboard", abc800_keyboard_tick, USEC(2500)) |
| 1128 | |
| 1052 | 1129 | /* ABC-77 keyboard */ |
| 1053 | 1130 | /* MDRV_SPEAKER_STANDARD_MONO("mono") |
| 1054 | 1131 | MDRV_DEVICE_ADD(ABC77_TAG, ABC77) |
| r3469 | r3470 | |
| 1057 | 1134 | /* video hardware */ |
| 1058 | 1135 | MDRV_IMPORT_FROM(abc800c_video) |
| 1059 | 1136 | |
| 1137 | /* Z80 CTC */ |
| 1060 | 1138 | MDRV_Z80CTC_ADD( Z80CTC_TAG, abc800_ctc_intf ) |
| 1139 | MDRV_TIMER_ADD_PERIODIC("ctc", abc800_ctc_tick, HZ(ABC800_X01/2/2/2)) |
| 1140 | |
| 1141 | /* Z80 SIO/2 */ |
| 1061 | 1142 | MDRV_Z80SIO_ADD( Z80SIO_TAG, abc800_sio_intf ) |
| 1143 | |
| 1144 | /* Z80 DART */ |
| 1062 | 1145 | MDRV_Z80DART_ADD( Z80DART_TAG, abc800_dart_intf ) |
| 1063 | 1146 | |
| 1064 | 1147 | /* printer */ |
| r3469 | r3470 | |
| 1088 | 1171 | /* video hardware */ |
| 1089 | 1172 | MDRV_IMPORT_FROM(abc802_video) |
| 1090 | 1173 | |
| 1091 | | MDRV_Z80CTC_ADD( Z80CTC_TAG, abc800_ctc_intf ) |
| 1174 | /* Z80 CTC */ |
| 1175 | MDRV_Z80CTC_ADD( Z80CTC_TAG, abc802_ctc_intf ) |
| 1176 | MDRV_TIMER_ADD_PERIODIC("ctc", abc802_ctc_tick, HZ(ABC800_X01/2/2/2)) |
| 1177 | |
| 1178 | /* Z80 SIO/2 */ |
| 1092 | 1179 | MDRV_Z80SIO_ADD( Z80SIO_TAG, abc800_sio_intf ) |
| 1093 | | MDRV_Z80DART_ADD( Z80DART_TAG, abc802_dart_intf ) |
| 1094 | 1180 | |
| 1181 | /* Z80 DART */ |
| 1182 | MDRV_Z80DART_ADD( Z80DART_TAG, abc800_dart_intf ) |
| 1183 | |
| 1095 | 1184 | /* printer */ |
| 1096 | 1185 | MDRV_DEVICE_ADD("printer", PRINTER) |
| 1097 | 1186 | |
| r3469 | r3470 | |
| 1119 | 1208 | /* video hardware */ |
| 1120 | 1209 | MDRV_IMPORT_FROM(abc806_video) |
| 1121 | 1210 | |
| 1122 | | MDRV_Z80CTC_ADD( Z80CTC_TAG, abc800_ctc_intf ) |
| 1211 | /* Z80 CTC */ |
| 1212 | MDRV_Z80CTC_ADD( Z80CTC_TAG, abc806_ctc_intf ) |
| 1213 | MDRV_TIMER_ADD_PERIODIC("ctc", abc806_ctc_tick, HZ(ABC800_X01/2/2/2)) |
| 1214 | |
| 1215 | /* Z80 SIO/2 */ |
| 1123 | 1216 | MDRV_Z80SIO_ADD( Z80SIO_TAG, abc800_sio_intf ) |
| 1124 | | MDRV_Z80DART_ADD( Z80DART_TAG, abc806_dart_intf ) |
| 1125 | 1217 | |
| 1218 | /* Z80 DART */ |
| 1219 | MDRV_Z80DART_ADD( Z80DART_TAG, abc800_dart_intf ) |
| 1220 | |
| 1126 | 1221 | /* real time clock */ |
| 1127 | 1222 | MDRV_DEVICE_ADD(E0516_TAG, E0516) |
| 1128 | 1223 | MDRV_DEVICE_CONFIG(abc806_e0516_intf) |