src/mess/drivers/beehive.c
| r11049 | r11050 | |
| 10 | 10 | for the moment. |
| 11 | 11 | |
| 12 | 12 | ****************************************************************************/ |
| 13 | #define ADDRESS_MAP_MODERN |
| 13 | 14 | |
| 14 | 15 | #include "emu.h" |
| 15 | 16 | #include "cpu/i8085/i8085.h" |
| 16 | 17 | |
| 18 | #define MACHINE_RESET_MEMBER(name) void name::machine_reset() |
| 19 | #define VIDEO_START_MEMBER(name) void name::video_start() |
| 20 | #define SCREEN_UPDATE_MEMBER(name) bool name::screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect) |
| 17 | 21 | |
| 18 | 22 | class beehive_state : public driver_device |
| 19 | 23 | { |
| 20 | 24 | public: |
| 21 | 25 | beehive_state(running_machine &machine, const driver_device_config_base &config) |
| 22 | | : driver_device(machine, config) { } |
| 26 | : driver_device(machine, config), |
| 27 | m_maincpu(*this, "maincpu") |
| 28 | { } |
| 23 | 29 | |
| 24 | | const UINT8 *m_FNT; |
| 25 | | const UINT8 *m_videoram; |
| 30 | required_device<cpu_device> m_maincpu; |
| 31 | const UINT8 *m_p_chargen; |
| 32 | const UINT8 *m_p_videoram; |
| 33 | virtual void machine_reset(); |
| 34 | virtual void video_start(); |
| 35 | virtual bool screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect); |
| 26 | 36 | }; |
| 27 | 37 | |
| 28 | 38 | |
| 29 | 39 | |
| 30 | | static ADDRESS_MAP_START(beehive_mem, AS_PROGRAM, 8) |
| 40 | static ADDRESS_MAP_START(beehive_mem, AS_PROGRAM, 8, beehive_state) |
| 31 | 41 | ADDRESS_MAP_UNMAP_HIGH |
| 32 | 42 | AM_RANGE( 0x0000, 0x17ff ) AM_ROM |
| 33 | 43 | AM_RANGE( 0x1800, 0xffff ) AM_RAM AM_REGION("maincpu", 0x1800) |
| 34 | 44 | ADDRESS_MAP_END |
| 35 | 45 | |
| 36 | | static ADDRESS_MAP_START( beehive_io, AS_IO, 8) |
| 46 | static ADDRESS_MAP_START( beehive_io, AS_IO, 8, beehive_state) |
| 47 | ADDRESS_MAP_GLOBAL_MASK(0xff) |
| 37 | 48 | ADDRESS_MAP_UNMAP_HIGH |
| 38 | 49 | ADDRESS_MAP_END |
| 39 | 50 | |
| r11049 | r11050 | |
| 42 | 53 | INPUT_PORTS_END |
| 43 | 54 | |
| 44 | 55 | |
| 45 | | static MACHINE_RESET(beehive) |
| 56 | MACHINE_RESET_MEMBER(beehive_state) |
| 46 | 57 | { |
| 47 | 58 | } |
| 48 | 59 | |
| 49 | | static VIDEO_START( beehive ) |
| 60 | VIDEO_START_MEMBER( beehive_state ) |
| 50 | 61 | { |
| 51 | | beehive_state *state = machine.driver_data<beehive_state>(); |
| 52 | | state->m_FNT = machine.region("chargen")->base(); |
| 53 | | state->m_videoram = machine.region("maincpu")->base()+0x81fa; |
| 62 | m_p_chargen = m_machine.region("chargen")->base(); |
| 63 | m_p_videoram = m_machine.region("maincpu")->base()+0x81fa; |
| 54 | 64 | } |
| 55 | 65 | |
| 56 | 66 | /* This system appears to have inline attribute bytes of unknown meaning. |
| 57 | 67 | Currently they are ignored. */ |
| 58 | | static SCREEN_UPDATE( beehive ) |
| 68 | SCREEN_UPDATE_MEMBER( beehive_state ) |
| 59 | 69 | { |
| 60 | | beehive_state *state = screen->machine().driver_data<beehive_state>(); |
| 61 | 70 | //static UINT8 framecnt=0; |
| 62 | 71 | UINT8 y,ra,chr,gfx; |
| 63 | 72 | UINT16 sy=0,ma=0,x,xx; |
| r11049 | r11050 | |
| 68 | 77 | { |
| 69 | 78 | for (ra = 0; ra < 10; ra++) |
| 70 | 79 | { |
| 71 | | UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0); |
| 80 | UINT16 *p = BITMAP_ADDR16(&bitmap, sy++, 0); |
| 72 | 81 | |
| 73 | 82 | xx = ma; |
| 74 | 83 | for (x = ma; x < ma + 80; x++) |
| r11049 | r11050 | |
| 76 | 85 | gfx = 0; |
| 77 | 86 | if (ra < 9) |
| 78 | 87 | { |
| 79 | | chr = state->m_videoram[xx++]; |
| 88 | chr = m_p_videoram[xx++]; |
| 80 | 89 | |
| 81 | 90 | // /* Take care of flashing characters */ |
| 82 | 91 | // if ((chr < 0x80) && (framecnt & 0x08)) |
| r11049 | r11050 | |
| 86 | 95 | x--; |
| 87 | 96 | else |
| 88 | 97 | { |
| 89 | | gfx = state->m_FNT[(chr<<4) | ra ]; |
| 98 | gfx = m_p_chargen[(chr<<4) | ra ]; |
| 90 | 99 | |
| 91 | 100 | /* Display a scanline of a character */ |
| 92 | | *p++ = ( gfx & 0x80 ) ? 1 : 0; |
| 93 | | *p++ = ( gfx & 0x40 ) ? 1 : 0; |
| 94 | | *p++ = ( gfx & 0x20 ) ? 1 : 0; |
| 95 | | *p++ = ( gfx & 0x10 ) ? 1 : 0; |
| 96 | | *p++ = ( gfx & 0x08 ) ? 1 : 0; |
| 97 | | *p++ = ( gfx & 0x04 ) ? 1 : 0; |
| 98 | | *p++ = ( gfx & 0x02 ) ? 1 : 0; |
| 99 | | *p++ = ( gfx & 0x01 ) ? 1 : 0; |
| 101 | *p++ = BIT(gfx, 7); |
| 102 | *p++ = BIT(gfx, 6); |
| 103 | *p++ = BIT(gfx, 5); |
| 104 | *p++ = BIT(gfx, 4); |
| 105 | *p++ = BIT(gfx, 3); |
| 106 | *p++ = BIT(gfx, 2); |
| 107 | *p++ = BIT(gfx, 1); |
| 108 | *p++ = BIT(gfx, 0); |
| 100 | 109 | } |
| 101 | 110 | } |
| 102 | 111 | } |
| r11049 | r11050 | |
| 112 | 121 | MCFG_CPU_PROGRAM_MAP(beehive_mem) |
| 113 | 122 | MCFG_CPU_IO_MAP(beehive_io) |
| 114 | 123 | |
| 115 | | MCFG_MACHINE_RESET(beehive) |
| 116 | | |
| 117 | 124 | /* video hardware */ |
| 118 | 125 | MCFG_SCREEN_ADD("screen", RASTER) |
| 119 | 126 | MCFG_SCREEN_REFRESH_RATE(50) |
| r11049 | r11050 | |
| 121 | 128 | MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16) |
| 122 | 129 | MCFG_SCREEN_SIZE(640, 250) |
| 123 | 130 | MCFG_SCREEN_VISIBLE_AREA(0, 639, 0, 249) |
| 124 | | MCFG_SCREEN_UPDATE(beehive) |
| 125 | | |
| 126 | 131 | MCFG_PALETTE_LENGTH(2) |
| 127 | 132 | MCFG_PALETTE_INIT(black_and_white) |
| 128 | | |
| 129 | | MCFG_VIDEO_START(beehive) |
| 130 | 133 | MACHINE_CONFIG_END |
| 131 | 134 | |
| 132 | 135 | /* ROM definition */ |
| r11049 | r11050 | |
| 144 | 147 | /* Driver */ |
| 145 | 148 | |
| 146 | 149 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT COMPANY FULLNAME FLAGS */ |
| 147 | | COMP( 19??, beehive, 0, 0, beehive, beehive, 0, "BeeHive", "DM3270", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 150 | COMP( 19??, beehive, 0, 0, beehive, beehive, 0, "BeeHive", "DM3270", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 148 | 151 | |
src/mess/drivers/bcs3.c
| r11049 | r11050 | |
| 12 | 12 | Note: The $ key makes a square symbol. |
| 13 | 13 | |
| 14 | 14 | ****************************************************************************/ |
| 15 | #define ADDRESS_MAP_MODERN |
| 15 | 16 | |
| 16 | 17 | #include "emu.h" |
| 17 | 18 | #include "cpu/z80/z80.h" |
| 18 | 19 | |
| 20 | #define MACHINE_RESET_MEMBER(name) void name::machine_reset() |
| 21 | #define VIDEO_START_MEMBER(name) void name::video_start() |
| 22 | |
| 19 | 23 | class bcs3_state : public driver_device |
| 20 | 24 | { |
| 21 | 25 | public: |
| 22 | 26 | bcs3_state(running_machine &machine, const driver_device_config_base &config) |
| 23 | | : driver_device(machine, config) { } |
| 27 | : driver_device(machine, config), |
| 28 | m_maincpu(*this, "maincpu") |
| 29 | { } |
| 24 | 30 | |
| 25 | | const UINT8 *m_fnt; |
| 26 | | UINT8 *m_videoram; |
| 31 | required_device<cpu_device> m_maincpu; |
| 32 | const UINT8 *m_p_chargen; |
| 33 | const UINT8 *m_p_videoram; |
| 34 | DECLARE_READ8_MEMBER(bcs3_keyboard_r); |
| 35 | virtual void machine_reset(); |
| 36 | virtual void video_start(); |
| 27 | 37 | }; |
| 28 | 38 | |
| 29 | | static READ8_HANDLER( bcs3_videoram_r ) |
| 39 | READ8_MEMBER( bcs3_state::bcs3_keyboard_r ) |
| 30 | 40 | { |
| 31 | | bcs3_state *state = space->machine().driver_data<bcs3_state>(); |
| 32 | | |
| 33 | | return state->m_videoram[offset]; |
| 34 | | } |
| 35 | | |
| 36 | | static WRITE8_HANDLER( bcs3_videoram_w ) |
| 37 | | { |
| 38 | | bcs3_state *state = space->machine().driver_data<bcs3_state>(); |
| 39 | | |
| 40 | | state->m_videoram[offset] = data; |
| 41 | | } |
| 42 | | |
| 43 | | static READ8_HANDLER( bcs3_keyboard_r ) |
| 44 | | { |
| 45 | 41 | UINT8 data = 0; |
| 46 | 42 | |
| 47 | 43 | if (~offset & 0x01) |
| 48 | | data |= input_port_read(space->machine(), "LINE0"); |
| 44 | data |= input_port_read(machine(), "LINE0"); |
| 49 | 45 | if (~offset & 0x02) |
| 50 | | data |= input_port_read(space->machine(), "LINE1"); |
| 46 | data |= input_port_read(machine(), "LINE1"); |
| 51 | 47 | if (~offset & 0x04) |
| 52 | | data |= input_port_read(space->machine(), "LINE2"); |
| 48 | data |= input_port_read(machine(), "LINE2"); |
| 53 | 49 | if (~offset & 0x08) |
| 54 | | data |= input_port_read(space->machine(), "LINE3"); |
| 50 | data |= input_port_read(machine(), "LINE3"); |
| 55 | 51 | if (~offset & 0x10) |
| 56 | | data |= input_port_read(space->machine(), "LINE4"); |
| 52 | data |= input_port_read(machine(), "LINE4"); |
| 57 | 53 | if (~offset & 0x20) |
| 58 | | data |= input_port_read(space->machine(), "LINE5"); |
| 54 | data |= input_port_read(machine(), "LINE5"); |
| 59 | 55 | if (~offset & 0x40) |
| 60 | | data |= input_port_read(space->machine(), "LINE6"); |
| 56 | data |= input_port_read(machine(), "LINE6"); |
| 61 | 57 | if (~offset & 0x80) |
| 62 | | data |= input_port_read(space->machine(), "LINE7"); |
| 58 | data |= input_port_read(machine(), "LINE7"); |
| 63 | 59 | if (~offset & 0x100) |
| 64 | | data |= input_port_read(space->machine(), "LINE8"); |
| 60 | data |= input_port_read(machine(), "LINE8"); |
| 65 | 61 | |
| 66 | 62 | return data; |
| 67 | 63 | } |
| 68 | 64 | |
| 69 | | static ADDRESS_MAP_START(bcs3_mem, AS_PROGRAM, 8) |
| 65 | static ADDRESS_MAP_START(bcs3_mem, AS_PROGRAM, 8, bcs3_state) |
| 70 | 66 | ADDRESS_MAP_UNMAP_HIGH |
| 71 | 67 | AM_RANGE( 0x0000, 0x0fff ) AM_ROM |
| 72 | 68 | AM_RANGE( 0x1000, 0x11ff ) AM_READ_PORT("LINE9") |
| 73 | 69 | AM_RANGE( 0x1200, 0x13ff ) AM_READ(bcs3_keyboard_r) |
| 74 | 70 | AM_RANGE( 0x3c00, 0xffff ) AM_RAM |
| 75 | | AM_RANGE( 0x3c50, 0x3d9f ) AM_READWRITE(bcs3_videoram_r,bcs3_videoram_w) AM_BASE_MEMBER(bcs3_state,m_videoram) |
| 71 | AM_RANGE( 0x3c50, 0x3d9f ) AM_RAM AM_BASE(m_p_videoram) |
| 76 | 72 | ADDRESS_MAP_END |
| 77 | 73 | |
| 78 | | static ADDRESS_MAP_START(bcs3a_mem, AS_PROGRAM, 8) |
| 74 | static ADDRESS_MAP_START(bcs3a_mem, AS_PROGRAM, 8, bcs3_state) |
| 79 | 75 | ADDRESS_MAP_UNMAP_HIGH |
| 80 | 76 | AM_RANGE( 0x0000, 0x0fff ) AM_ROM |
| 81 | 77 | AM_RANGE( 0x1000, 0x11ff ) AM_READ_PORT("LINE9") |
| 82 | 78 | AM_RANGE( 0x1200, 0x13ff ) AM_READ(bcs3_keyboard_r) |
| 83 | 79 | AM_RANGE( 0x3c00, 0xefff ) AM_RAM |
| 84 | | AM_RANGE( 0x3c00, 0x5a7f ) AM_READWRITE(bcs3_videoram_r,bcs3_videoram_w) AM_BASE_MEMBER(bcs3_state,m_videoram) |
| 80 | AM_RANGE( 0x3c00, 0x5a7f ) AM_RAM AM_BASE(m_p_videoram) |
| 85 | 81 | AM_RANGE( 0xf000, 0xf3ff ) AM_ROM |
| 86 | 82 | ADDRESS_MAP_END |
| 87 | 83 | |
| 88 | | static ADDRESS_MAP_START(bcs3b_mem, AS_PROGRAM, 8) |
| 84 | static ADDRESS_MAP_START(bcs3b_mem, AS_PROGRAM, 8, bcs3_state) |
| 89 | 85 | ADDRESS_MAP_UNMAP_HIGH |
| 90 | 86 | AM_RANGE( 0x0000, 0x0fff ) AM_ROM |
| 91 | 87 | AM_RANGE( 0x1000, 0x11ff ) AM_READ_PORT("LINE9") |
| 92 | 88 | AM_RANGE( 0x1200, 0x13ff ) AM_READ(bcs3_keyboard_r) |
| 93 | 89 | AM_RANGE( 0x3c00, 0xefff ) AM_RAM |
| 94 | | AM_RANGE( 0x3c00, 0x657f ) AM_READWRITE(bcs3_videoram_r,bcs3_videoram_w) AM_BASE_MEMBER(bcs3_state,m_videoram) |
| 90 | AM_RANGE( 0x3c00, 0x657f ) AM_RAM AM_BASE(m_p_videoram) |
| 95 | 91 | AM_RANGE( 0xf000, 0xf3ff ) AM_ROM |
| 96 | 92 | ADDRESS_MAP_END |
| 97 | 93 | |
| 98 | | static ADDRESS_MAP_START(bcs3c_mem, AS_PROGRAM, 8) |
| 94 | static ADDRESS_MAP_START(bcs3c_mem, AS_PROGRAM, 8, bcs3_state) |
| 99 | 95 | ADDRESS_MAP_UNMAP_HIGH |
| 100 | 96 | AM_RANGE( 0x0000, 0x0fff ) AM_ROM |
| 101 | 97 | AM_RANGE( 0x1000, 0x11ff ) AM_READ_PORT("LINE9") |
| 102 | 98 | AM_RANGE( 0x1200, 0x13ff ) AM_READ(bcs3_keyboard_r) |
| 103 | 99 | AM_RANGE( 0x3c00, 0xffff ) AM_RAM |
| 104 | | AM_RANGE( 0x3c00, 0x5ab3 ) AM_READWRITE(bcs3_videoram_r,bcs3_videoram_w) AM_BASE_MEMBER(bcs3_state,m_videoram) |
| 100 | AM_RANGE( 0x3c00, 0x5ab3 ) AM_RAM AM_BASE(m_p_videoram) |
| 105 | 101 | ADDRESS_MAP_END |
| 106 | 102 | |
| 107 | | static ADDRESS_MAP_START( bcs3_io, AS_IO, 8) |
| 103 | static ADDRESS_MAP_START( bcs3_io, AS_IO, 8, bcs3_state) |
| 108 | 104 | ADDRESS_MAP_UNMAP_HIGH |
| 109 | 105 | ADDRESS_MAP_GLOBAL_MASK(0xff) |
| 110 | 106 | // AM_RANGE( 0xf8, 0xfb ) AM_DEVREADWRITE(Z80CTC,"z80ctc",z80ctc_r,z80ctc_w) |
| r11049 | r11050 | |
| 214 | 210 | INPUT_PORTS_END |
| 215 | 211 | |
| 216 | 212 | |
| 217 | | static MACHINE_RESET(bcs3) |
| 213 | MACHINE_RESET_MEMBER(bcs3_state) |
| 218 | 214 | { |
| 219 | 215 | } |
| 220 | 216 | |
| 221 | | static VIDEO_START( bcs3 ) |
| 217 | VIDEO_START_MEMBER( bcs3_state ) |
| 222 | 218 | { |
| 223 | | bcs3_state *state = machine.driver_data<bcs3_state>(); |
| 224 | | |
| 225 | | state->m_fnt = machine.region("gfx1")->base(); |
| 219 | m_p_chargen = m_machine.region("chargen")->base(); |
| 226 | 220 | } |
| 227 | 221 | |
| 228 | 222 | static SCREEN_UPDATE( bcs3 ) |
| r11049 | r11050 | |
| 235 | 229 | { |
| 236 | 230 | for (ra = 0; ra < 10; ra++) |
| 237 | 231 | { |
| 238 | | UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0); |
| 232 | UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0); |
| 239 | 233 | rat = (ra + 1) & 7; |
| 240 | 234 | |
| 241 | 235 | for (x = ma; x < ma + 28; x++) |
| 242 | 236 | { |
| 243 | 237 | if (ra < 8) |
| 244 | 238 | { |
| 245 | | chr = state->m_videoram[x] & 0x7f; |
| 239 | chr = state->m_p_videoram[x] & 0x7f; |
| 246 | 240 | |
| 247 | 241 | /* get pattern of pixels for that character scanline */ |
| 248 | | gfx = state->m_fnt[(chr<<3) | rat ]; |
| 242 | gfx = state->m_p_chargen[(chr<<3) | rat ] ^ 0xff; |
| 249 | 243 | } |
| 250 | 244 | else |
| 251 | | gfx = 0; |
| 245 | gfx = 0xff; |
| 252 | 246 | |
| 253 | 247 | /* Display a scanline of a character (8 pixels) */ |
| 254 | | *p++ = ( gfx & 0x80 ) ? 0 : 1; |
| 255 | | *p++ = ( gfx & 0x40 ) ? 0 : 1; |
| 256 | | *p++ = ( gfx & 0x20 ) ? 0 : 1; |
| 257 | | *p++ = ( gfx & 0x10 ) ? 0 : 1; |
| 258 | | *p++ = ( gfx & 0x08 ) ? 0 : 1; |
| 259 | | *p++ = ( gfx & 0x04 ) ? 0 : 1; |
| 260 | | *p++ = ( gfx & 0x02 ) ? 0 : 1; |
| 261 | | *p++ = ( gfx & 0x01 ) ? 0 : 1; |
| 248 | *p++ = BIT(gfx, 7); |
| 249 | *p++ = BIT(gfx, 6); |
| 250 | *p++ = BIT(gfx, 5); |
| 251 | *p++ = BIT(gfx, 4); |
| 252 | *p++ = BIT(gfx, 3); |
| 253 | *p++ = BIT(gfx, 2); |
| 254 | *p++ = BIT(gfx, 1); |
| 255 | *p++ = BIT(gfx, 0); |
| 262 | 256 | } |
| 263 | 257 | } |
| 264 | 258 | ma+=28; |
| r11049 | r11050 | |
| 273 | 267 | bcs3_state *state = screen->machine().driver_data<bcs3_state>(); |
| 274 | 268 | UINT8 y,ra,chr,gfx,rat; |
| 275 | 269 | UINT16 sy=0,ma=128,x; |
| 276 | | UINT16 cursor = (state->m_videoram[0x7a] | (state->m_videoram[0x7b] << 8)) - 0x3c80; // get cursor relative position |
| 270 | UINT16 cursor = (state->m_p_videoram[0x7a] | (state->m_p_videoram[0x7b] << 8)) - 0x3c80; // get cursor relative position |
| 277 | 271 | rat = cursor / 30; |
| 278 | 272 | if (rat > 11) ma = (rat-11) * 30 + 128; |
| 279 | 273 | |
| r11049 | r11050 | |
| 281 | 275 | { |
| 282 | 276 | for (ra = 0; ra < 10; ra++) |
| 283 | 277 | { |
| 284 | | UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0); |
| 278 | UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0); |
| 285 | 279 | rat = (ra + 1) & 7; |
| 286 | 280 | |
| 287 | 281 | for (x = ma; x < ma + 29; x++) |
| 288 | 282 | { |
| 289 | 283 | if (ra < 8) |
| 290 | 284 | { |
| 291 | | chr = state->m_videoram[x] & 0x7f; |
| 285 | chr = state->m_p_videoram[x] & 0x7f; |
| 292 | 286 | |
| 293 | 287 | /* get pattern of pixels for that character scanline */ |
| 294 | | gfx = state->m_fnt[(chr<<3) | rat ]; |
| 288 | gfx = state->m_p_chargen[(chr<<3) | rat ] ^ 0xff; |
| 295 | 289 | } |
| 296 | 290 | else |
| 297 | | gfx = 0; |
| 291 | gfx = 0xff; |
| 298 | 292 | |
| 299 | 293 | /* Display a scanline of a character (8 pixels) */ |
| 300 | | *p++ = ( gfx & 0x80 ) ? 0 : 1; |
| 301 | | *p++ = ( gfx & 0x40 ) ? 0 : 1; |
| 302 | | *p++ = ( gfx & 0x20 ) ? 0 : 1; |
| 303 | | *p++ = ( gfx & 0x10 ) ? 0 : 1; |
| 304 | | *p++ = ( gfx & 0x08 ) ? 0 : 1; |
| 305 | | *p++ = ( gfx & 0x04 ) ? 0 : 1; |
| 306 | | *p++ = ( gfx & 0x02 ) ? 0 : 1; |
| 307 | | *p++ = ( gfx & 0x01 ) ? 0 : 1; |
| 294 | *p++ = BIT(gfx, 7); |
| 295 | *p++ = BIT(gfx, 6); |
| 296 | *p++ = BIT(gfx, 5); |
| 297 | *p++ = BIT(gfx, 4); |
| 298 | *p++ = BIT(gfx, 3); |
| 299 | *p++ = BIT(gfx, 2); |
| 300 | *p++ = BIT(gfx, 1); |
| 301 | *p++ = BIT(gfx, 0); |
| 308 | 302 | } |
| 309 | 303 | } |
| 310 | 304 | ma+=30; |
| r11049 | r11050 | |
| 317 | 311 | bcs3_state *state = screen->machine().driver_data<bcs3_state>(); |
| 318 | 312 | UINT8 y,ra,chr,gfx,rat; |
| 319 | 313 | UINT16 sy=0,ma=128,x; |
| 320 | | UINT16 cursor = (state->m_videoram[0x7a] | (state->m_videoram[0x7b] << 8)) - 0x3c80; // get cursor relative position |
| 314 | UINT16 cursor = (state->m_p_videoram[0x7a] | (state->m_p_videoram[0x7b] << 8)) - 0x3c80; // get cursor relative position |
| 321 | 315 | rat = cursor / 41; |
| 322 | 316 | if (rat > 23) ma = (rat-23) * 41 + 128; |
| 323 | 317 | |
| r11049 | r11050 | |
| 325 | 319 | { |
| 326 | 320 | for (ra = 0; ra < 10; ra++) |
| 327 | 321 | { |
| 328 | | UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0); |
| 322 | UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0); |
| 329 | 323 | rat = (ra + 1) & 7; |
| 330 | 324 | |
| 331 | 325 | for (x = ma; x < ma + 40; x++) |
| 332 | 326 | { |
| 333 | 327 | if (ra < 8) |
| 334 | 328 | { |
| 335 | | chr = state->m_videoram[x] & 0x7f; |
| 329 | chr = state->m_p_videoram[x] & 0x7f; |
| 336 | 330 | |
| 337 | 331 | /* get pattern of pixels for that character scanline */ |
| 338 | | gfx = state->m_fnt[(chr<<3) | rat ]; |
| 332 | gfx = state->m_p_chargen[(chr<<3) | rat ] ^ 0xff; |
| 339 | 333 | } |
| 340 | 334 | else |
| 341 | | gfx = 0; |
| 335 | gfx = 0xff; |
| 342 | 336 | |
| 343 | 337 | /* Display a scanline of a character (8 pixels) */ |
| 344 | | *p++ = ( gfx & 0x80 ) ? 0 : 1; |
| 345 | | *p++ = ( gfx & 0x40 ) ? 0 : 1; |
| 346 | | *p++ = ( gfx & 0x20 ) ? 0 : 1; |
| 347 | | *p++ = ( gfx & 0x10 ) ? 0 : 1; |
| 348 | | *p++ = ( gfx & 0x08 ) ? 0 : 1; |
| 349 | | *p++ = ( gfx & 0x04 ) ? 0 : 1; |
| 350 | | *p++ = ( gfx & 0x02 ) ? 0 : 1; |
| 351 | | *p++ = ( gfx & 0x01 ) ? 0 : 1; |
| 338 | *p++ = BIT(gfx, 7); |
| 339 | *p++ = BIT(gfx, 6); |
| 340 | *p++ = BIT(gfx, 5); |
| 341 | *p++ = BIT(gfx, 4); |
| 342 | *p++ = BIT(gfx, 3); |
| 343 | *p++ = BIT(gfx, 2); |
| 344 | *p++ = BIT(gfx, 1); |
| 345 | *p++ = BIT(gfx, 0); |
| 352 | 346 | } |
| 353 | 347 | } |
| 354 | 348 | ma+=41; |
| r11049 | r11050 | |
| 361 | 355 | bcs3_state *state = screen->machine().driver_data<bcs3_state>(); |
| 362 | 356 | UINT8 y,ra,chr,gfx,rat; |
| 363 | 357 | UINT16 sy=0,ma=0xb4,x; |
| 364 | | UINT16 cursor = (state->m_videoram[0x08] | (state->m_videoram[0x09] << 8)) - 0x3c80; // get cursor relative position |
| 358 | UINT16 cursor = (state->m_p_videoram[0x08] | (state->m_p_videoram[0x09] << 8)) - 0x3c80; // get cursor relative position |
| 365 | 359 | rat = cursor / 30; |
| 366 | 360 | if (rat > 11) ma = (rat-11) * 30 + 0xb4; |
| 367 | 361 | |
| r11049 | r11050 | |
| 369 | 363 | { |
| 370 | 364 | for (ra = 0; ra < 10; ra++) |
| 371 | 365 | { |
| 372 | | UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0); |
| 366 | UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0); |
| 373 | 367 | rat = (ra + 1) & 7; |
| 374 | 368 | |
| 375 | 369 | for (x = ma; x < ma + 29; x++) |
| 376 | 370 | { |
| 377 | 371 | if (ra < 8) |
| 378 | 372 | { |
| 379 | | chr = state->m_videoram[x] & 0x7f; |
| 373 | chr = state->m_p_videoram[x] & 0x7f; |
| 380 | 374 | |
| 381 | 375 | /* get pattern of pixels for that character scanline */ |
| 382 | | gfx = state->m_fnt[(chr<<3) | rat ]; |
| 376 | gfx = state->m_p_chargen[(chr<<3) | rat ] ^ 0xff; |
| 383 | 377 | } |
| 384 | 378 | else |
| 385 | | gfx = 0; |
| 379 | gfx = 0xff; |
| 386 | 380 | |
| 387 | 381 | /* Display a scanline of a character (8 pixels) */ |
| 388 | | *p++ = ( gfx & 0x80 ) ? 0 : 1; |
| 389 | | *p++ = ( gfx & 0x40 ) ? 0 : 1; |
| 390 | | *p++ = ( gfx & 0x20 ) ? 0 : 1; |
| 391 | | *p++ = ( gfx & 0x10 ) ? 0 : 1; |
| 392 | | *p++ = ( gfx & 0x08 ) ? 0 : 1; |
| 393 | | *p++ = ( gfx & 0x04 ) ? 0 : 1; |
| 394 | | *p++ = ( gfx & 0x02 ) ? 0 : 1; |
| 395 | | *p++ = ( gfx & 0x01 ) ? 0 : 1; |
| 382 | *p++ = BIT(gfx, 7); |
| 383 | *p++ = BIT(gfx, 6); |
| 384 | *p++ = BIT(gfx, 5); |
| 385 | *p++ = BIT(gfx, 4); |
| 386 | *p++ = BIT(gfx, 3); |
| 387 | *p++ = BIT(gfx, 2); |
| 388 | *p++ = BIT(gfx, 1); |
| 389 | *p++ = BIT(gfx, 0); |
| 396 | 390 | } |
| 397 | 391 | } |
| 398 | 392 | ma+=30; |
| r11049 | r11050 | |
| 415 | 409 | }; |
| 416 | 410 | |
| 417 | 411 | static GFXDECODE_START( bcs3 ) |
| 418 | | GFXDECODE_ENTRY( "gfx1", 0x0000, bcs3_charlayout, 0, 1 ) |
| 412 | GFXDECODE_ENTRY( "chargen", 0x0000, bcs3_charlayout, 0, 1 ) |
| 419 | 413 | GFXDECODE_END |
| 420 | 414 | |
| 421 | 415 | |
| r11049 | r11050 | |
| 426 | 420 | MCFG_CPU_PROGRAM_MAP(bcs3_mem) |
| 427 | 421 | MCFG_CPU_IO_MAP(bcs3_io) |
| 428 | 422 | |
| 429 | | MCFG_MACHINE_RESET(bcs3) |
| 430 | | |
| 431 | 423 | /* video hardware */ |
| 432 | 424 | MCFG_SCREEN_ADD("screen", RASTER) |
| 433 | 425 | MCFG_SCREEN_REFRESH_RATE(50) |
| r11049 | r11050 | |
| 436 | 428 | MCFG_SCREEN_SIZE(28*8, 12*10) |
| 437 | 429 | MCFG_SCREEN_VISIBLE_AREA(0,28*8-1,0,12*10-1) |
| 438 | 430 | MCFG_SCREEN_UPDATE(bcs3) |
| 439 | | |
| 440 | 431 | MCFG_GFXDECODE(bcs3) |
| 441 | 432 | MCFG_PALETTE_LENGTH(2) |
| 442 | 433 | MCFG_PALETTE_INIT(black_and_white) |
| 443 | | |
| 444 | | MCFG_VIDEO_START(bcs3) |
| 445 | 434 | MACHINE_CONFIG_END |
| 446 | 435 | |
| 447 | 436 | static MACHINE_CONFIG_DERIVED( bcs3a, bcs3 ) |
| r11049 | r11050 | |
| 482 | 471 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASEFF ) |
| 483 | 472 | ROM_LOAD( "se24.bin", 0x0000, 0x0800, CRC(268de5ee) SHA1(78784945956c1b0282a4e82ad55e7c3a77389e50)) |
| 484 | 473 | |
| 485 | | ROM_REGION( 0x0400, "gfx1", 0 ) |
| 474 | ROM_REGION( 0x0400, "chargen", 0 ) |
| 486 | 475 | ROM_LOAD( "se24font.bin", 0x0000, 0x0400, CRC(eaed9d84) SHA1(7023a6187cd6bd0c6489d76ff662453f14e5b636)) |
| 487 | 476 | ROM_END |
| 488 | 477 | |
| r11049 | r11050 | |
| 491 | 480 | ROM_LOAD( "se31_29.bin", 0x0000, 0x1000, CRC(e9b55544) SHA1(82bae68c4bcaecf66632f5b43913b50a1acba316)) |
| 492 | 481 | ROM_LOAD( "se31mceditor.bin", 0xf000, 0x0400, CRC(8eac92ec) SHA1(8950a3ef05d02abf34269bfce002c46d273ce113)) |
| 493 | 482 | |
| 494 | | ROM_REGION( 0x0400, "gfx1", 0 ) |
| 483 | ROM_REGION( 0x0400, "chargen", 0 ) |
| 495 | 484 | ROM_LOAD( "se31font.bin", 0x0000, 0x0400, CRC(a20c93c9) SHA1(b2be1c0d98b7ac05713349b099b392975968be1d)) |
| 496 | 485 | ROM_END |
| 497 | 486 | |
| r11049 | r11050 | |
| 500 | 489 | ROM_LOAD( "se31_40.bin", 0x0000, 0x1000, CRC(4e993152) SHA1(6bb01ff5779627fa2eb2df432fffcfccc1e33231)) |
| 501 | 490 | ROM_LOAD( "se31mceditor.bin", 0xf000, 0x0400, CRC(8eac92ec) SHA1(8950a3ef05d02abf34269bfce002c46d273ce113)) |
| 502 | 491 | |
| 503 | | ROM_REGION( 0x0400, "gfx1", 0 ) |
| 492 | ROM_REGION( 0x0400, "chargen", 0 ) |
| 504 | 493 | ROM_LOAD( "se31font.bin", 0x0000, 0x0400, CRC(a20c93c9) SHA1(b2be1c0d98b7ac05713349b099b392975968be1d)) |
| 505 | 494 | ROM_END |
| 506 | 495 | |
| r11049 | r11050 | |
| 508 | 497 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASEFF ) |
| 509 | 498 | ROM_LOAD( "sp33_29.bin", 0x0000, 0x1000, CRC(1c851eb2) SHA1(4f8bb5274ea1861a35a840e8f3482bdc693047c4)) |
| 510 | 499 | |
| 511 | | ROM_REGION( 0x0400, "gfx1", 0 ) |
| 500 | ROM_REGION( 0x0400, "chargen", 0 ) |
| 512 | 501 | ROM_LOAD( "sp33font.bin", 0x0000, 0x0400, CRC(b27f1c07) SHA1(61c80c585f198370ba5e856839c12b15acdc58ee)) |
| 513 | 502 | ROM_END |
| 514 | 503 | |
src/mess/drivers/phunsy.c
| r11049 | r11050 | |
| 12 | 12 | #include "machine/terminal.h" |
| 13 | 13 | #include "sound/speaker.h" |
| 14 | 14 | |
| 15 | #define MACHINE_RESET_MEMBER(name) void name::machine_reset() |
| 16 | #define VIDEO_START_MEMBER(name) void name::video_start() |
| 17 | #define SCREEN_UPDATE_MEMBER(name) bool name::screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect) |
| 15 | 18 | |
| 16 | 19 | #define LOG 1 |
| 17 | 20 | |
| r11049 | r11050 | |
| 35 | 38 | DECLARE_WRITE8_MEMBER( phunsy_ctrl_w ); |
| 36 | 39 | DECLARE_WRITE8_MEMBER( phunsy_data_w ); |
| 37 | 40 | DECLARE_WRITE8_MEMBER( phunsy_kbd_put ); |
| 38 | | UINT8 *m_videoram; |
| 39 | | UINT8 *m_FNT; |
| 41 | const UINT8 *m_p_videoram; |
| 42 | const UINT8 *m_p_chargen; |
| 40 | 43 | UINT8 m_data_out; |
| 41 | 44 | UINT8 m_keyboard_input; |
| 42 | 45 | UINT8 m_q_bank; |
| 43 | 46 | UINT8 m_u_bank; |
| 44 | 47 | UINT8 m_ram_1800[0x800]; |
| 48 | virtual void machine_reset(); |
| 49 | virtual void video_start(); |
| 50 | virtual bool screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect); |
| 45 | 51 | }; |
| 46 | 52 | |
| 47 | 53 | |
| r11049 | r11050 | |
| 56 | 62 | ADDRESS_MAP_UNMAP_HIGH |
| 57 | 63 | AM_RANGE( 0x0000, 0x07ff) AM_ROM |
| 58 | 64 | AM_RANGE( 0x0800, 0x0fff) AM_RAM |
| 59 | | AM_RANGE( 0x1000, 0x17ff) AM_RAM AM_BASE( m_videoram ) // Video RAM |
| 65 | AM_RANGE( 0x1000, 0x17ff) AM_RAM AM_BASE( m_p_videoram ) // Video RAM |
| 60 | 66 | AM_RANGE( 0x1800, 0x1fff) AM_RAM_WRITE( phunsy_1800_w ) AM_ROMBANK("bank1") // Banked RAM/ROM |
| 61 | 67 | AM_RANGE( 0x4000, 0xffff) AM_RAMBANK("bank2") // Banked RAM |
| 62 | 68 | ADDRESS_MAP_END |
| r11049 | r11050 | |
| 176 | 182 | }; |
| 177 | 183 | |
| 178 | 184 | |
| 179 | | static DRIVER_INIT( phunsy ) |
| 185 | MACHINE_RESET_MEMBER(phunsy_state) |
| 180 | 186 | { |
| 181 | | } |
| 187 | memory_set_bankptr( m_machine, "bank1", m_ram_1800 ); |
| 188 | memory_set_bankptr( m_machine, "bank2", m_machine.region("ram_4000")->base() ); |
| 182 | 189 | |
| 183 | | |
| 184 | | static MACHINE_RESET(phunsy) |
| 185 | | { |
| 186 | | phunsy_state *state = machine.driver_data<phunsy_state>(); |
| 187 | | |
| 188 | | memory_set_bankptr( machine, "bank1", state->m_ram_1800 ); |
| 189 | | memory_set_bankptr( machine, "bank2", machine.region("ram_4000")->base() ); |
| 190 | | |
| 191 | | state->m_u_bank = 0; |
| 192 | | state->m_q_bank = 0; |
| 193 | | state->m_keyboard_input = 0xFF; |
| 190 | m_u_bank = 0; |
| 191 | m_q_bank = 0; |
| 192 | m_keyboard_input = 0xFF; |
| 194 | 193 | } |
| 195 | 194 | |
| 196 | 195 | |
| r11049 | r11050 | |
| 205 | 204 | } |
| 206 | 205 | |
| 207 | 206 | |
| 208 | | static VIDEO_START( phunsy ) |
| 207 | VIDEO_START_MEMBER( phunsy_state ) |
| 209 | 208 | { |
| 210 | | phunsy_state *state = machine.driver_data<phunsy_state>(); |
| 211 | | state->m_FNT = machine.region( "chargen" )->base(); |
| 209 | m_p_chargen = m_machine.region( "chargen" )->base(); |
| 212 | 210 | } |
| 213 | 211 | |
| 214 | 212 | |
| 215 | | static SCREEN_UPDATE( phunsy ) |
| 213 | SCREEN_UPDATE_MEMBER( phunsy_state ) |
| 216 | 214 | { |
| 217 | | phunsy_state *state = screen->machine().driver_data<phunsy_state>(); |
| 218 | 215 | UINT8 y,ra,chr,gfx,col; |
| 219 | 216 | UINT16 sy=0,ma=0,x; |
| 220 | 217 | |
| r11049 | r11050 | |
| 222 | 219 | { |
| 223 | 220 | for (ra = 0; ra < 8; ra++) |
| 224 | 221 | { |
| 225 | | UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0); |
| 222 | UINT16 *p = BITMAP_ADDR16(&bitmap, sy++, 0); |
| 226 | 223 | |
| 227 | 224 | for (x = ma; x < ma+64; x++) |
| 228 | 225 | { |
| 229 | | chr = state->m_videoram[x]; |
| 226 | chr = m_p_videoram[x]; |
| 230 | 227 | |
| 231 | 228 | if (BIT(chr, 7)) |
| 232 | 229 | { |
| r11049 | r11050 | |
| 241 | 238 | else |
| 242 | 239 | { |
| 243 | 240 | /* ASCII mode */ |
| 244 | | gfx = state->m_FNT[(chr<<3) | ra]; |
| 241 | gfx = m_p_chargen[(chr<<3) | ra]; |
| 245 | 242 | col = 7; |
| 246 | 243 | } |
| 247 | 244 | |
| 248 | 245 | /* Display a scanline of a character (6 pixels) */ |
| 249 | | *p++ = ( gfx & 0x20 ) ? col : 0; |
| 250 | | *p++ = ( gfx & 0x10 ) ? col : 0; |
| 251 | | *p++ = ( gfx & 0x08 ) ? col : 0; |
| 252 | | *p++ = ( gfx & 0x04 ) ? col : 0; |
| 253 | | *p++ = ( gfx & 0x02 ) ? col : 0; |
| 254 | | *p++ = ( gfx & 0x01 ) ? col : 0; |
| 246 | *p++ = BIT( gfx, 5 ) ? col : 0; |
| 247 | *p++ = BIT( gfx, 4 ) ? col : 0; |
| 248 | *p++ = BIT( gfx, 3 ) ? col : 0; |
| 249 | *p++ = BIT( gfx, 2 ) ? col : 0; |
| 250 | *p++ = BIT( gfx, 1 ) ? col : 0; |
| 251 | *p++ = BIT( gfx, 0 ) ? col : 0; |
| 255 | 252 | } |
| 256 | 253 | } |
| 257 | 254 | ma+=64; |
| r11049 | r11050 | |
| 284 | 281 | MCFG_CPU_PROGRAM_MAP(phunsy_mem) |
| 285 | 282 | MCFG_CPU_IO_MAP(phunsy_io) |
| 286 | 283 | |
| 287 | | MCFG_MACHINE_RESET(phunsy) |
| 288 | | |
| 289 | 284 | /* video hardware */ |
| 290 | 285 | MCFG_SCREEN_ADD("screen", RASTER) |
| 291 | 286 | /* Display (page 12 of pdf) |
| r11049 | r11050 | |
| 299 | 294 | MCFG_GFXDECODE(phunsy) |
| 300 | 295 | MCFG_PALETTE_LENGTH(8) |
| 301 | 296 | MCFG_PALETTE_INIT(phunsy) |
| 302 | | MCFG_SCREEN_UPDATE(phunsy) |
| 303 | 297 | |
| 304 | | MCFG_VIDEO_START(phunsy) |
| 305 | | |
| 306 | 298 | /* sound hardware */ |
| 307 | 299 | MCFG_SPEAKER_STANDARD_MONO("mono") |
| 308 | 300 | //MCFG_SOUND_WAVE_ADD("wave", "cassette") |
| r11049 | r11050 | |
| 310 | 302 | MCFG_SOUND_ADD("speaker", SPEAKER_SOUND, 0) |
| 311 | 303 | MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 312 | 304 | |
| 305 | /* Devices */ |
| 313 | 306 | MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG,phunsy_terminal_intf) |
| 314 | 307 | MACHINE_CONFIG_END |
| 315 | 308 | |
| r11049 | r11050 | |
| 335 | 328 | /* Driver */ |
| 336 | 329 | |
| 337 | 330 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT COMPANY FULLNAME FLAGS */ |
| 338 | | COMP( 1980, phunsy, 0, 0, phunsy, phunsy, phunsy, "J.F.P. Philipse", "PHUNSY", GAME_NOT_WORKING ) |
| 331 | COMP( 1980, phunsy, 0, 0, phunsy, phunsy, 0, "J.F.P. Philipse", "PHUNSY", GAME_NOT_WORKING ) |
| 339 | 332 | |
src/mess/drivers/mes.c
| r11049 | r11050 | |
| 5 | 5 | 30/08/2010 Skeleton driver |
| 6 | 6 | |
| 7 | 7 | ****************************************************************************/ |
| 8 | #define ADDRESS_MAP_MODERN |
| 8 | 9 | |
| 9 | 10 | #include "emu.h" |
| 10 | 11 | #include "cpu/z80/z80.h" |
| 11 | 12 | |
| 13 | #define MACHINE_RESET_MEMBER(name) void name::machine_reset() |
| 14 | #define VIDEO_START_MEMBER(name) void name::video_start() |
| 15 | #define SCREEN_UPDATE_MEMBER(name) bool name::screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect) |
| 12 | 16 | |
| 13 | 17 | class mes_state : public driver_device |
| 14 | 18 | { |
| 15 | 19 | public: |
| 16 | 20 | mes_state(running_machine &machine, const driver_device_config_base &config) |
| 17 | | : driver_device(machine, config) { } |
| 21 | : driver_device(machine, config), |
| 22 | m_maincpu(*this, "maincpu") |
| 23 | { } |
| 18 | 24 | |
| 19 | | const UINT8 *m_FNT; |
| 20 | | const UINT8 *m_videoram; |
| 25 | required_device<cpu_device> m_maincpu; |
| 26 | const UINT8 *m_p_chargen; |
| 27 | const UINT8 *m_p_videoram; |
| 28 | virtual void machine_reset(); |
| 29 | virtual void video_start(); |
| 30 | virtual bool screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect); |
| 21 | 31 | }; |
| 22 | 32 | |
| 23 | 33 | |
| 24 | 34 | |
| 25 | | static ADDRESS_MAP_START(mes_mem, AS_PROGRAM, 8) |
| 35 | static ADDRESS_MAP_START(mes_mem, AS_PROGRAM, 8, mes_state) |
| 26 | 36 | ADDRESS_MAP_UNMAP_HIGH |
| 27 | 37 | AM_RANGE(0x0000, 0x0fff) AM_ROM |
| 28 | | AM_RANGE(0x1000, 0xffff) AM_RAM AM_REGION("maincpu", 0x1000) |
| 38 | AM_RANGE(0x1000, 0xefff) AM_RAM |
| 39 | AM_RANGE(0xf000, 0xffff) AM_RAM AM_BASE(m_p_videoram) |
| 29 | 40 | ADDRESS_MAP_END |
| 30 | 41 | |
| 31 | | static ADDRESS_MAP_START( mes_io, AS_IO, 8 ) |
| 42 | static ADDRESS_MAP_START( mes_io, AS_IO, 8, mes_state) |
| 32 | 43 | ADDRESS_MAP_GLOBAL_MASK(0xff) |
| 33 | 44 | ADDRESS_MAP_END |
| 34 | 45 | |
| r11049 | r11050 | |
| 36 | 47 | static INPUT_PORTS_START( mes ) |
| 37 | 48 | INPUT_PORTS_END |
| 38 | 49 | |
| 39 | | static MACHINE_RESET(mes) |
| 50 | MACHINE_RESET_MEMBER(mes_state) |
| 40 | 51 | { |
| 41 | 52 | } |
| 42 | 53 | |
| 43 | | static VIDEO_START( mes ) |
| 54 | VIDEO_START_MEMBER( mes_state ) |
| 44 | 55 | { |
| 45 | | mes_state *state = machine.driver_data<mes_state>(); |
| 46 | | state->m_FNT = machine.region("chargen")->base(); |
| 47 | | state->m_videoram = machine.region("maincpu")->base()+0xf000; |
| 56 | m_p_chargen = m_machine.region("chargen")->base(); |
| 48 | 57 | } |
| 49 | 58 | |
| 50 | 59 | /* This system appears to have 2 screens. Not implemented. |
| 51 | 60 | Also the screen dimensions are a guess. */ |
| 52 | | static SCREEN_UPDATE( mes ) |
| 61 | SCREEN_UPDATE_MEMBER( mes_state ) |
| 53 | 62 | { |
| 54 | | mes_state *state = screen->machine().driver_data<mes_state>(); |
| 55 | 63 | //static UINT8 framecnt=0; |
| 56 | 64 | UINT8 y,ra,chr,gfx; |
| 57 | 65 | UINT16 sy=0,ma=0,x,xx; |
| r11049 | r11050 | |
| 62 | 70 | { |
| 63 | 71 | for (ra = 0; ra < 10; ra++) |
| 64 | 72 | { |
| 65 | | UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0); |
| 73 | UINT16 *p = BITMAP_ADDR16(&bitmap, sy++, 0); |
| 66 | 74 | |
| 67 | 75 | xx = ma; |
| 68 | 76 | for (x = ma; x < ma + 80; x++) |
| r11049 | r11050 | |
| 70 | 78 | gfx = 0; |
| 71 | 79 | if (ra < 9) |
| 72 | 80 | { |
| 73 | | chr = state->m_videoram[xx++]; |
| 81 | chr = m_p_videoram[xx++]; |
| 74 | 82 | |
| 75 | 83 | // /* Take care of flashing characters */ |
| 76 | 84 | // if ((chr < 0x80) && (framecnt & 0x08)) |
| r11049 | r11050 | |
| 80 | 88 | x--; |
| 81 | 89 | else |
| 82 | 90 | { |
| 83 | | gfx = state->m_FNT[(chr<<4) | ra ]; |
| 91 | gfx = m_p_chargen[(chr<<4) | ra ]; |
| 84 | 92 | |
| 85 | 93 | /* Display a scanline of a character */ |
| 86 | | *p++ = ( gfx & 0x80 ) ? 1 : 0; |
| 87 | | *p++ = ( gfx & 0x40 ) ? 1 : 0; |
| 88 | | *p++ = ( gfx & 0x20 ) ? 1 : 0; |
| 89 | | *p++ = ( gfx & 0x10 ) ? 1 : 0; |
| 90 | | *p++ = ( gfx & 0x08 ) ? 1 : 0; |
| 91 | | *p++ = ( gfx & 0x04 ) ? 1 : 0; |
| 92 | | *p++ = ( gfx & 0x02 ) ? 1 : 0; |
| 93 | | *p++ = ( gfx & 0x01 ) ? 1 : 0; |
| 94 | *p++ = BIT(gfx, 7); |
| 95 | *p++ = BIT(gfx, 6); |
| 96 | *p++ = BIT(gfx, 5); |
| 97 | *p++ = BIT(gfx, 4); |
| 98 | *p++ = BIT(gfx, 3); |
| 99 | *p++ = BIT(gfx, 2); |
| 100 | *p++ = BIT(gfx, 1); |
| 101 | *p++ = BIT(gfx, 0); |
| 94 | 102 | } |
| 95 | 103 | } |
| 96 | 104 | } |
| r11049 | r11050 | |
| 101 | 109 | } |
| 102 | 110 | |
| 103 | 111 | static MACHINE_CONFIG_START( mes, mes_state ) |
| 104 | | /* basic machine hardware */ |
| 105 | | MCFG_CPU_ADD("maincpu", Z80, XTAL_16MHz / 4) |
| 106 | | MCFG_CPU_PROGRAM_MAP(mes_mem) |
| 112 | /* basic machine hardware */ |
| 113 | MCFG_CPU_ADD("maincpu", Z80, XTAL_16MHz / 4) |
| 114 | MCFG_CPU_PROGRAM_MAP(mes_mem) |
| 107 | 115 | MCFG_CPU_IO_MAP(mes_io) |
| 108 | 116 | |
| 109 | | MCFG_MACHINE_RESET(mes) |
| 110 | | |
| 111 | | /* video hardware */ |
| 117 | /* video hardware */ |
| 112 | 118 | MCFG_SCREEN_ADD("screen", RASTER) |
| 113 | 119 | MCFG_SCREEN_REFRESH_RATE(60) |
| 114 | 120 | MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500)) /* not accurate */ |
| 115 | 121 | MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16) |
| 116 | 122 | MCFG_SCREEN_SIZE(640, 250) |
| 117 | 123 | MCFG_SCREEN_VISIBLE_AREA(0, 639, 0, 249) |
| 118 | | MCFG_SCREEN_UPDATE(mes) |
| 119 | | |
| 120 | | MCFG_PALETTE_LENGTH(2) |
| 121 | | MCFG_PALETTE_INIT(black_and_white) |
| 122 | | |
| 123 | | MCFG_VIDEO_START(mes) |
| 124 | MCFG_PALETTE_LENGTH(2) |
| 125 | MCFG_PALETTE_INIT(black_and_white) |
| 124 | 126 | MACHINE_CONFIG_END |
| 125 | 127 | |
| 126 | 128 | |
| 127 | 129 | /* ROM definition */ |
| 128 | 130 | ROM_START( mes ) |
| 129 | | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASEFF ) |
| 131 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASEFF ) |
| 130 | 132 | ROM_LOAD( "mescpu.bin", 0x0000, 0x1000, CRC(b6d90cf4) SHA1(19e608af5bdaabb00a134e1106b151b00e2a0b04)) |
| 131 | | ROM_REGION( 0x10000, "xebec", ROMREGION_ERASEFF ) |
| 133 | |
| 134 | ROM_REGION( 0x10000, "xebec", ROMREGION_ERASEFF ) |
| 132 | 135 | ROM_LOAD( "mesxebec.bin", 0x0000, 0x2000, CRC(061b7212) SHA1(c5d600116fb7563c69ebd909eb9613269b2ada0f)) |
| 133 | 136 | |
| 134 | 137 | /* character generator not dumped, using the one from 'c10' for now */ |
| r11049 | r11050 | |
| 139 | 142 | /* Driver */ |
| 140 | 143 | |
| 141 | 144 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT COMPANY FULLNAME FLAGS */ |
| 142 | | COMP( 198?, mes, 0, 0, mes, mes, 0, "Schleicher", "MES", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 145 | COMP( 198?, mes, 0, 0, mes, mes, 0, "Schleicher", "MES", GAME_NOT_WORKING | GAME_NO_SOUND) |
src/mess/drivers/dim68k.c
| r11049 | r11050 | |
| 37 | 37 | #include "sound/speaker.h" |
| 38 | 38 | #include "video/mc6845.h" |
| 39 | 39 | |
| 40 | #define MACHINE_RESET_MEMBER(name) void name::machine_reset() |
| 41 | #define VIDEO_START_MEMBER(name) void name::video_start() |
| 42 | #define SCREEN_UPDATE_MEMBER(name) bool name::screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect) |
| 43 | |
| 40 | 44 | class dim68k_state : public driver_device |
| 41 | 45 | { |
| 42 | 46 | public: |
| r11049 | r11050 | |
| 64 | 68 | DECLARE_WRITE16_MEMBER( dim68k_video_high_w ); |
| 65 | 69 | DECLARE_WRITE16_MEMBER( dim68k_video_reset_w ); |
| 66 | 70 | UINT16* m_ram; |
| 67 | | UINT8 *m_FNT; |
| 68 | | UINT8 m_speaker_bit; |
| 71 | const UINT8 *m_p_chargen; |
| 72 | bool m_speaker_bit; |
| 69 | 73 | UINT8 m_video_control; |
| 74 | virtual void machine_reset(); |
| 75 | virtual void video_start(); |
| 76 | virtual bool screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect); |
| 70 | 77 | }; |
| 71 | 78 | |
| 72 | 79 | READ16_MEMBER( dim68k_state::dim68k_duart_r ) |
| r11049 | r11050 | |
| 195 | 202 | INPUT_PORTS_END |
| 196 | 203 | |
| 197 | 204 | |
| 198 | | static MACHINE_RESET(dim68k) |
| 205 | MACHINE_RESET_MEMBER(dim68k_state) |
| 199 | 206 | { |
| 200 | | dim68k_state *state = machine.driver_data<dim68k_state>(); |
| 201 | | UINT8* ROM = machine.region("bootrom")->base(); |
| 207 | UINT8* ROM = m_machine.region("bootrom")->base(); |
| 202 | 208 | |
| 203 | | memcpy((UINT8*)state->m_ram, ROM, 0x2000); |
| 209 | memcpy((UINT8*)m_ram, ROM, 0x2000); |
| 204 | 210 | |
| 205 | | machine.device("maincpu")->reset(); |
| 211 | m_machine.device("maincpu")->reset(); |
| 206 | 212 | } |
| 207 | 213 | |
| 208 | | static VIDEO_START( dim68k ) |
| 214 | VIDEO_START_MEMBER( dim68k_state ) |
| 209 | 215 | { |
| 210 | | dim68k_state *state = machine.driver_data<dim68k_state>(); |
| 211 | | state->m_FNT = machine.region("chargen")->base(); |
| 216 | m_p_chargen = m_machine.region("chargen")->base(); |
| 212 | 217 | } |
| 213 | 218 | |
| 214 | | static SCREEN_UPDATE( dim68k ) |
| 219 | SCREEN_UPDATE_MEMBER( dim68k_state ) |
| 215 | 220 | { |
| 216 | | dim68k_state *state = screen->machine().driver_data<dim68k_state>(); |
| 217 | | mc6845_update(state->m_crtc, bitmap, cliprect); |
| 221 | mc6845_update(m_crtc, &bitmap, &cliprect); |
| 218 | 222 | return 0; |
| 219 | 223 | } |
| 220 | 224 | |
| r11049 | r11050 | |
| 243 | 247 | xx++; |
| 244 | 248 | |
| 245 | 249 | chr = chr16>>8; |
| 246 | | gfx = state->m_FNT[(chr<<4) | ra] ^ inv ^ ((chr & 0x80) ? 0xff : 0); |
| 247 | | *p++ = ( gfx & 0x80 ) ? 1 : 0; |
| 248 | | *p++ = ( gfx & 0x40 ) ? 1 : 0; |
| 249 | | *p++ = ( gfx & 0x20 ) ? 1 : 0; |
| 250 | | *p++ = ( gfx & 0x10 ) ? 1 : 0; |
| 251 | | *p++ = ( gfx & 0x08 ) ? 1 : 0; |
| 252 | | *p++ = ( gfx & 0x04 ) ? 1 : 0; |
| 253 | | *p++ = ( gfx & 0x02 ) ? 1 : 0; |
| 254 | | if (dot8) *p++ = ( gfx & 0x01 ) ? 1 : 0; |
| 250 | gfx = state->m_p_chargen[(chr<<4) | ra] ^ inv ^ ((chr & 0x80) ? 0xff : 0); |
| 251 | *p++ = BIT(gfx, 7); |
| 252 | *p++ = BIT(gfx, 6); |
| 253 | *p++ = BIT(gfx, 5); |
| 254 | *p++ = BIT(gfx, 4); |
| 255 | *p++ = BIT(gfx, 3); |
| 256 | *p++ = BIT(gfx, 2); |
| 257 | *p++ = BIT(gfx, 1); |
| 258 | if (dot8) *p++ = BIT(gfx, 1); |
| 255 | 259 | |
| 256 | 260 | inv = 0; |
| 257 | 261 | if (xx == cursor_x) inv=0xff; |
| 258 | 262 | xx++; |
| 259 | 263 | |
| 260 | 264 | chr = chr16; |
| 261 | | gfx = state->m_FNT[(chr<<4) | ra] ^ inv ^ ((chr & 0x80) ? 0xff : 0); |
| 262 | | *p++ = ( gfx & 0x80 ) ? 1 : 0; |
| 263 | | *p++ = ( gfx & 0x40 ) ? 1 : 0; |
| 264 | | *p++ = ( gfx & 0x20 ) ? 1 : 0; |
| 265 | | *p++ = ( gfx & 0x10 ) ? 1 : 0; |
| 266 | | *p++ = ( gfx & 0x08 ) ? 1 : 0; |
| 267 | | *p++ = ( gfx & 0x04 ) ? 1 : 0; |
| 268 | | *p++ = ( gfx & 0x02 ) ? 1 : 0; |
| 269 | | if (dot8) *p++ = ( gfx & 0x01 ) ? 1 : 0; |
| 265 | gfx = state->m_p_chargen[(chr<<4) | ra] ^ inv ^ ((chr & 0x80) ? 0xff : 0); |
| 266 | *p++ = BIT(gfx, 7); |
| 267 | *p++ = BIT(gfx, 6); |
| 268 | *p++ = BIT(gfx, 5); |
| 269 | *p++ = BIT(gfx, 4); |
| 270 | *p++ = BIT(gfx, 3); |
| 271 | *p++ = BIT(gfx, 2); |
| 272 | *p++ = BIT(gfx, 1); |
| 273 | if (dot8) *p++ = BIT(gfx, 1); |
| 270 | 274 | } |
| 271 | 275 | } |
| 272 | 276 | |
| r11049 | r11050 | |
| 306 | 310 | MCFG_CPU_ADD("maincpu", M68000, XTAL_10MHz) |
| 307 | 311 | MCFG_CPU_PROGRAM_MAP(dim68k_mem) |
| 308 | 312 | |
| 309 | | MCFG_MACHINE_RESET(dim68k) |
| 310 | | |
| 311 | 313 | /* video hardware */ |
| 312 | 314 | MCFG_SCREEN_ADD("screen", RASTER) |
| 313 | 315 | MCFG_SCREEN_REFRESH_RATE(50) |
| r11049 | r11050 | |
| 315 | 317 | MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16) |
| 316 | 318 | MCFG_SCREEN_SIZE(640, 480) |
| 317 | 319 | MCFG_SCREEN_VISIBLE_AREA(0, 640-1, 0, 250-1) |
| 318 | | MCFG_SCREEN_UPDATE(dim68k) |
| 319 | | |
| 320 | 320 | MCFG_PALETTE_LENGTH(2) |
| 321 | 321 | MCFG_PALETTE_INIT(black_and_white) |
| 322 | 322 | MCFG_GFXDECODE(dim68k) |
| 323 | 323 | |
| 324 | | MCFG_VIDEO_START(dim68k) |
| 325 | | MCFG_MC6845_ADD("crtc", MC6845, 1790000, dim68k_crtc) |
| 326 | | |
| 327 | 324 | /* sound hardware */ |
| 328 | 325 | MCFG_SPEAKER_STANDARD_MONO("mono") |
| 329 | 326 | MCFG_SOUND_ADD("speaker", SPEAKER_SOUND, 0) |
| 330 | 327 | MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 328 | |
| 329 | /* Devices */ |
| 330 | MCFG_MC6845_ADD("crtc", MC6845, 1790000, dim68k_crtc) |
| 331 | 331 | MACHINE_CONFIG_END |
| 332 | 332 | |
| 333 | 333 | /* |
src/mess/drivers/pegasus.c
| r11049 | r11050 | |
| 43 | 43 | #include "imagedev/cartslot.h" |
| 44 | 44 | #include "imagedev/cassette.h" |
| 45 | 45 | |
| 46 | #define MACHINE_RESET_MEMBER(name) void name::machine_reset() |
| 47 | #define MACHINE_START_MEMBER(name) void name::machine_start() |
| 48 | #define VIDEO_START_MEMBER(name) void name::video_start() |
| 49 | #define SCREEN_UPDATE_MEMBER(name) bool name::screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect) |
| 50 | |
| 46 | 51 | class pegasus_state : public driver_device |
| 47 | 52 | { |
| 48 | 53 | public: |
| r11049 | r11050 | |
| 69 | 74 | DECLARE_WRITE_LINE_MEMBER( pegasus_cassette_w ); |
| 70 | 75 | DECLARE_WRITE_LINE_MEMBER( pegasus_firq_clr ); |
| 71 | 76 | UINT8 m_kbd_row; |
| 72 | | UINT8 m_kbd_irq; |
| 73 | | UINT8 *m_pcgram; |
| 74 | | UINT8 *m_videoram; |
| 75 | | UINT8 *m_FNT; |
| 77 | bool m_kbd_irq; |
| 78 | UINT8 *m_p_pcgram; |
| 79 | const UINT8 *m_p_videoram; |
| 80 | const UINT8 *m_p_chargen; |
| 76 | 81 | UINT8 m_control_bits; |
| 82 | virtual void machine_reset(); |
| 83 | virtual void machine_start(); |
| 84 | virtual void video_start(); |
| 85 | virtual bool screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect); |
| 77 | 86 | }; |
| 78 | 87 | |
| 79 | 88 | static TIMER_DEVICE_CALLBACK( pegasus_firq ) |
| r11049 | r11050 | |
| 133 | 142 | |
| 134 | 143 | READ8_MEMBER( pegasus_state::pegasus_pcg_r ) |
| 135 | 144 | { |
| 136 | | UINT8 code = m_videoram[offset] & 0x7f; |
| 137 | | return m_pcgram[(code << 4) | (~m_kbd_row & 15)]; |
| 145 | UINT8 code = m_p_videoram[offset] & 0x7f; |
| 146 | return m_p_pcgram[(code << 4) | (~m_kbd_row & 15)]; |
| 138 | 147 | } |
| 139 | 148 | |
| 140 | 149 | WRITE8_MEMBER( pegasus_state::pegasus_pcg_w ) |
| 141 | 150 | { |
| 142 | | // if (state->m_control_bits & 2) |
| 151 | // if (m_control_bits & 2) |
| 143 | 152 | { |
| 144 | | UINT8 code = m_videoram[offset] & 0x7f; |
| 145 | | m_pcgram[(code << 4) | (~m_kbd_row & 15)] = data; |
| 153 | UINT8 code = m_p_videoram[offset] & 0x7f; |
| 154 | m_p_pcgram[(code << 4) | (~m_kbd_row & 15)] = data; |
| 146 | 155 | } |
| 147 | 156 | } |
| 148 | 157 | |
| r11049 | r11050 | |
| 158 | 167 | ADDRESS_MAP_UNMAP_HIGH |
| 159 | 168 | AM_RANGE(0x0000, 0x2fff) AM_ROM |
| 160 | 169 | AM_RANGE(0xb000, 0xbdff) AM_RAM |
| 161 | | AM_RANGE(0xbe00, 0xbfff) AM_RAM AM_BASE(m_videoram) |
| 170 | AM_RANGE(0xbe00, 0xbfff) AM_RAM AM_BASE(m_p_videoram) |
| 162 | 171 | AM_RANGE(0xc000, 0xdfff) AM_ROM AM_WRITENOP |
| 163 | 172 | AM_RANGE(0xe000, 0xe1ff) AM_READ(pegasus_protection_r) |
| 164 | 173 | AM_RANGE(0xe200, 0xe3ff) AM_READWRITE(pegasus_pcg_r,pegasus_pcg_w) |
| r11049 | r11050 | |
| 171 | 180 | ADDRESS_MAP_UNMAP_HIGH |
| 172 | 181 | AM_RANGE(0x0000, 0x2fff) AM_ROM |
| 173 | 182 | AM_RANGE(0x5000, 0xbdff) AM_RAM |
| 174 | | AM_RANGE(0xbe00, 0xbfff) AM_RAM AM_BASE(m_videoram) |
| 183 | AM_RANGE(0xbe00, 0xbfff) AM_RAM AM_BASE(m_p_videoram) |
| 175 | 184 | AM_RANGE(0xc000, 0xdfff) AM_ROM AM_WRITENOP |
| 176 | 185 | AM_RANGE(0xe000, 0xe1ff) AM_READ(pegasus_protection_r) |
| 177 | 186 | AM_RANGE(0xe200, 0xe3ff) AM_READWRITE(pegasus_pcg_r,pegasus_pcg_w) |
| r11049 | r11050 | |
| 306 | 315 | }; |
| 307 | 316 | |
| 308 | 317 | |
| 309 | | static VIDEO_START( pegasus ) |
| 318 | VIDEO_START_MEMBER( pegasus_state ) |
| 310 | 319 | { |
| 311 | | pegasus_state *state = machine.driver_data<pegasus_state>(); |
| 312 | | state->m_FNT = machine.region("chargen")->base(); |
| 320 | m_p_chargen = m_machine.region("chargen")->base(); |
| 313 | 321 | } |
| 314 | 322 | |
| 315 | 323 | static const UINT8 mcm6571a_shift[] = |
| r11049 | r11050 | |
| 325 | 333 | }; |
| 326 | 334 | |
| 327 | 335 | |
| 328 | | static SCREEN_UPDATE( pegasus ) |
| 336 | SCREEN_UPDATE_MEMBER( pegasus_state ) |
| 329 | 337 | { |
| 330 | | pegasus_state *state = screen->machine().driver_data<pegasus_state>(); |
| 331 | 338 | UINT8 y,ra,chr,gfx,inv; |
| 332 | 339 | UINT16 sy=0,ma=0,x; |
| 333 | | UINT8 pcg_mode = state->m_control_bits & 2; |
| 340 | UINT8 pcg_mode = m_control_bits & 2; |
| 334 | 341 | |
| 335 | 342 | for(y = 0; y < 16; y++ ) |
| 336 | 343 | { |
| 337 | 344 | for(ra = 0; ra < 16; ra++ ) |
| 338 | 345 | { |
| 339 | | UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0); |
| 346 | UINT16 *p = BITMAP_ADDR16(&bitmap, sy++, 0); |
| 340 | 347 | |
| 341 | 348 | for(x = ma; x < ma + 32; x++ ) |
| 342 | 349 | { |
| 343 | 350 | inv = 0xff; |
| 344 | 351 | gfx = 0; |
| 345 | | chr = state->m_videoram[x]; |
| 352 | chr = m_p_videoram[x]; |
| 346 | 353 | |
| 347 | 354 | if (BIT(chr, 7)) |
| 348 | 355 | { |
| r11049 | r11050 | |
| 352 | 359 | |
| 353 | 360 | if (pcg_mode) |
| 354 | 361 | { |
| 355 | | gfx = state->m_pcgram[(chr << 4) | ra] ^ inv; |
| 362 | gfx = m_p_pcgram[(chr << 4) | ra] ^ inv; |
| 356 | 363 | } |
| 357 | 364 | else |
| 358 | 365 | if (mcm6571a_shift[chr]) |
| r11049 | r11050 | |
| 360 | 367 | if (ra < 3) |
| 361 | 368 | gfx = inv; |
| 362 | 369 | else |
| 363 | | gfx = state->m_FNT[(chr<<4) | (ra-3) ] ^ inv; |
| 370 | gfx = m_p_chargen[(chr<<4) | (ra-3) ] ^ inv; |
| 364 | 371 | } |
| 365 | 372 | else |
| 366 | 373 | { |
| 367 | 374 | if (ra < 10) |
| 368 | | gfx = state->m_FNT[(chr<<4) | ra ] ^ inv; |
| 375 | gfx = m_p_chargen[(chr<<4) | ra ] ^ inv; |
| 369 | 376 | else |
| 370 | 377 | gfx = inv; |
| 371 | 378 | } |
| 372 | 379 | |
| 373 | 380 | /* Display a scanline of a character */ |
| 374 | | *p++ = BIT(gfx, 7) ? 1 : 0; |
| 375 | | *p++ = BIT(gfx, 6) ? 1 : 0; |
| 376 | | *p++ = BIT(gfx, 5) ? 1 : 0; |
| 377 | | *p++ = BIT(gfx, 4) ? 1 : 0; |
| 378 | | *p++ = BIT(gfx, 3) ? 1 : 0; |
| 379 | | *p++ = BIT(gfx, 2) ? 1 : 0; |
| 380 | | *p++ = BIT(gfx, 1) ? 1 : 0; |
| 381 | | *p++ = BIT(gfx, 0) ? 1 : 0; |
| 381 | *p++ = BIT(gfx, 7); |
| 382 | *p++ = BIT(gfx, 6); |
| 383 | *p++ = BIT(gfx, 5); |
| 384 | *p++ = BIT(gfx, 4); |
| 385 | *p++ = BIT(gfx, 3); |
| 386 | *p++ = BIT(gfx, 2); |
| 387 | *p++ = BIT(gfx, 1); |
| 388 | *p++ = BIT(gfx, 0); |
| 382 | 389 | } |
| 383 | 390 | } |
| 384 | 391 | ma+=32; |
| r11049 | r11050 | |
| 467 | 474 | return IMAGE_INIT_PASS; |
| 468 | 475 | } |
| 469 | 476 | |
| 470 | | static MACHINE_START( pegasus ) |
| 477 | MACHINE_START_MEMBER( pegasus_state ) |
| 471 | 478 | { |
| 472 | | pegasus_state *state = machine.driver_data<pegasus_state>(); |
| 473 | | state->m_pcgram = machine.region("pcg")->base(); |
| 479 | m_p_pcgram = m_machine.region("pcg")->base(); |
| 474 | 480 | } |
| 475 | 481 | |
| 476 | | static MACHINE_RESET( pegasus ) |
| 482 | MACHINE_RESET_MEMBER( pegasus_state ) |
| 477 | 483 | { |
| 478 | | pegasus_state *state = machine.driver_data<pegasus_state>(); |
| 479 | | state->m_kbd_row = 0; |
| 480 | | state->m_kbd_irq = 1; |
| 481 | | state->m_control_bits = 0; |
| 484 | m_kbd_row = 0; |
| 485 | m_kbd_irq = 1; |
| 486 | m_control_bits = 0; |
| 482 | 487 | } |
| 483 | 488 | |
| 484 | 489 | static DRIVER_INIT( pegasus ) |
| r11049 | r11050 | |
| 492 | 497 | MCFG_CPU_PROGRAM_MAP(pegasus_mem) |
| 493 | 498 | |
| 494 | 499 | MCFG_TIMER_ADD_PERIODIC("pegasus_firq", pegasus_firq, attotime::from_hz(400)) // controls accuracy of the clock (ctrl-P) |
| 495 | | MCFG_MACHINE_START(pegasus) |
| 496 | | MCFG_MACHINE_RESET(pegasus) |
| 500 | |
| 497 | 501 | /* video hardware */ |
| 498 | 502 | MCFG_SCREEN_ADD("screen", RASTER) |
| 499 | 503 | MCFG_SCREEN_REFRESH_RATE(50) |
| r11049 | r11050 | |
| 501 | 505 | MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16) |
| 502 | 506 | MCFG_SCREEN_SIZE(32*8, 16*16) |
| 503 | 507 | MCFG_SCREEN_VISIBLE_AREA(0, 32*8-1, 0, 16*16-1) |
| 504 | | MCFG_SCREEN_UPDATE(pegasus) |
| 505 | | |
| 506 | 508 | MCFG_GFXDECODE(pegasus) |
| 507 | 509 | MCFG_PALETTE_LENGTH(2) |
| 508 | 510 | MCFG_PALETTE_INIT(black_and_white) |
| 509 | | MCFG_VIDEO_START(pegasus) |
| 510 | 511 | |
| 511 | 512 | /* devices */ |
| 512 | 513 | MCFG_PIA6821_ADD( "pia_s", pegasus_pia_s_intf ) |
src/mess/drivers/zrt80.c
| r11049 | r11050 | |
| 22 | 22 | #include "machine/terminal.h" |
| 23 | 23 | #include "sound/beep.h" |
| 24 | 24 | |
| 25 | #define MACHINE_RESET_MEMBER(name) void name::machine_reset() |
| 26 | #define VIDEO_START_MEMBER(name) void name::video_start() |
| 27 | #define SCREEN_UPDATE_MEMBER(name) bool name::screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect) |
| 25 | 28 | |
| 26 | 29 | class zrt80_state : public driver_device |
| 27 | 30 | { |
| r11049 | r11050 | |
| 45 | 48 | DECLARE_WRITE8_MEMBER( zrt80_38_w ); |
| 46 | 49 | DECLARE_WRITE8_MEMBER( zrt80_kbd_put ); |
| 47 | 50 | UINT8 m_term_data; |
| 48 | | UINT8 *m_videoram; |
| 49 | | UINT8 *m_FNT; |
| 51 | const UINT8 *m_p_videoram; |
| 52 | const UINT8 *m_p_chargen; |
| 53 | virtual void machine_reset(); |
| 54 | virtual void video_start(); |
| 55 | virtual bool screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect); |
| 50 | 56 | }; |
| 51 | 57 | |
| 52 | 58 | READ8_MEMBER( zrt80_state::zrt80_10_r ) |
| r11049 | r11050 | |
| 80 | 86 | AM_RANGE(0x1000, 0x1fff) AM_ROM // Z24 - Expansion |
| 81 | 87 | AM_RANGE(0x4000, 0x43ff) AM_RAM // Board RAM |
| 82 | 88 | // Normally video RAM is 0x800 but could be expanded up to 8K |
| 83 | | AM_RANGE(0xc000, 0xdfff) AM_RAM AM_BASE(m_videoram) // Video RAM |
| 89 | AM_RANGE(0xc000, 0xdfff) AM_RAM AM_BASE(m_p_videoram) // Video RAM |
| 84 | 90 | |
| 85 | 91 | ADDRESS_MAP_END |
| 86 | 92 | |
| r11049 | r11050 | |
| 180 | 186 | INPUT_PORTS_END |
| 181 | 187 | |
| 182 | 188 | |
| 183 | | static MACHINE_RESET(zrt80) |
| 189 | MACHINE_RESET_MEMBER(zrt80_state) |
| 184 | 190 | { |
| 185 | | zrt80_state *state = machine.driver_data<zrt80_state>(); |
| 186 | | beep_set_frequency(state->m_beep, 800); |
| 191 | beep_set_frequency(m_beep, 800); |
| 187 | 192 | } |
| 188 | 193 | |
| 189 | | static VIDEO_START( zrt80 ) |
| 194 | VIDEO_START_MEMBER( zrt80_state ) |
| 190 | 195 | { |
| 191 | | zrt80_state *state = machine.driver_data<zrt80_state>(); |
| 192 | | state->m_FNT = machine.region("chargen")->base(); |
| 196 | m_p_chargen = m_machine.region("chargen")->base(); |
| 193 | 197 | } |
| 194 | 198 | |
| 195 | | static SCREEN_UPDATE( zrt80 ) |
| 199 | SCREEN_UPDATE_MEMBER( zrt80_state ) |
| 196 | 200 | { |
| 197 | | device_t *mc6845 = screen->machine().device("crtc"); |
| 198 | | mc6845_update(mc6845, bitmap, cliprect); |
| 201 | mc6845_update(m_crtc, &bitmap, &cliprect); |
| 199 | 202 | return 0; |
| 200 | 203 | } |
| 201 | 204 | |
| 202 | 205 | static MC6845_UPDATE_ROW( zrt80_update_row ) |
| 203 | 206 | { |
| 204 | 207 | zrt80_state *state = device->machine().driver_data<zrt80_state>(); |
| 205 | | UINT8 chr,gfx,inv,i; |
| 208 | UINT8 chr,gfx,inv; |
| 206 | 209 | UINT16 mem,x; |
| 207 | 210 | UINT16 *p = BITMAP_ADDR16(bitmap, y, 0); |
| 208 | 211 | UINT8 polarity = input_port_read(device->machine(), "DIPSW1") & 4 ? 0xff : 0; |
| r11049 | r11050 | |
| 212 | 215 | inv = polarity; |
| 213 | 216 | if (x == cursor_x) inv ^= 0xff; |
| 214 | 217 | mem = (ma + x) & 0x1fff; |
| 215 | | chr = state->m_videoram[mem]; |
| 218 | chr = state->m_p_videoram[mem]; |
| 216 | 219 | |
| 217 | 220 | if BIT(chr, 7) |
| 218 | 221 | { |
| r11049 | r11050 | |
| 220 | 223 | chr &= 0x7f; |
| 221 | 224 | } |
| 222 | 225 | |
| 223 | | gfx = state->m_FNT[(chr<<4) | ra] ^ inv; |
| 226 | gfx = state->m_p_chargen[(chr<<4) | ra] ^ inv; |
| 224 | 227 | |
| 225 | 228 | /* Display a scanline of a character */ |
| 226 | | for (i = 0; i < 8; i++) |
| 227 | | *p++ = BIT(gfx, 7-i); |
| 229 | *p++ = BIT(gfx, 7); |
| 230 | *p++ = BIT(gfx, 6); |
| 231 | *p++ = BIT(gfx, 5); |
| 232 | *p++ = BIT(gfx, 4); |
| 233 | *p++ = BIT(gfx, 3); |
| 234 | *p++ = BIT(gfx, 2); |
| 235 | *p++ = BIT(gfx, 1); |
| 236 | *p++ = BIT(gfx, 0); |
| 228 | 237 | } |
| 229 | 238 | } |
| 230 | 239 | |
| r11049 | r11050 | |
| 244 | 253 | |
| 245 | 254 | static INS8250_INTERRUPT( zrt80_com_interrupt ) |
| 246 | 255 | { |
| 247 | | logerror("com int\r\n"); |
| 248 | 256 | cputag_set_input_line(device->machine(), "maincpu", INPUT_LINE_IRQ0, state); |
| 249 | 257 | } |
| 250 | 258 | |
| r11049 | r11050 | |
| 293 | 301 | MCFG_CPU_PROGRAM_MAP(zrt80_mem) |
| 294 | 302 | MCFG_CPU_IO_MAP(zrt80_io) |
| 295 | 303 | |
| 296 | | MCFG_MACHINE_RESET(zrt80) |
| 297 | | |
| 298 | 304 | /* video hardware */ |
| 299 | 305 | MCFG_SCREEN_ADD("screen", RASTER) |
| 300 | 306 | MCFG_SCREEN_REFRESH_RATE(60) |
| r11049 | r11050 | |
| 302 | 308 | MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16) |
| 303 | 309 | MCFG_SCREEN_SIZE(640, 200) |
| 304 | 310 | MCFG_SCREEN_VISIBLE_AREA(0, 640 - 1, 0, 200 - 1) |
| 305 | | MCFG_SCREEN_UPDATE(zrt80) |
| 306 | | |
| 307 | 311 | MCFG_GFXDECODE(zrt80) |
| 308 | 312 | MCFG_PALETTE_LENGTH(2) |
| 309 | 313 | MCFG_PALETTE_INIT(black_and_white) |
| 310 | 314 | |
| 311 | | MCFG_MC6845_ADD("crtc", MC6845, XTAL_20MHz / 8, zrt80_crtc6845_interface) |
| 312 | | |
| 313 | | MCFG_VIDEO_START(zrt80) |
| 314 | | |
| 315 | | MCFG_INS8250_ADD( "ins8250", zrt80_com_interface ) |
| 316 | | MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, zrt80_terminal_intf) |
| 317 | | |
| 318 | 315 | /* sound hardware */ |
| 319 | 316 | MCFG_SPEAKER_STANDARD_MONO("mono") |
| 320 | 317 | MCFG_SOUND_ADD("beep", BEEP, 0) |
| 321 | 318 | MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50) |
| 319 | |
| 320 | /* Devices */ |
| 321 | MCFG_MC6845_ADD("crtc", MC6845, XTAL_20MHz / 8, zrt80_crtc6845_interface) |
| 322 | MCFG_INS8250_ADD( "ins8250", zrt80_com_interface ) |
| 323 | MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, zrt80_terminal_intf) |
| 322 | 324 | MACHINE_CONFIG_END |
| 323 | 325 | |
| 324 | 326 | /* ROM definition */ |
| 325 | 327 | ROM_START( zrt80 ) |
| 326 | 328 | ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASEFF ) |
| 327 | | ROM_LOAD( "zrt80mon.z25", 0x0000, 0x1000, CRC(e6ea96dc) SHA1(e3075e30bb2b85f9288d0b8b8cdf1d2b4f7586fd)) |
| 329 | ROM_LOAD("zrt80mon.z25", 0x0000, 0x1000, CRC(e6ea96dc) SHA1(e3075e30bb2b85f9288d0b8b8cdf1d2b4f7586fd) ) |
| 328 | 330 | //z24 is 2nd chip, used as expansion |
| 329 | 331 | |
| 330 | 332 | ROM_REGION( 0x0800, "chargen", 0 ) |
| 331 | | ROM_LOAD( "zrt80chr.z30", 0x0000, 0x0800, CRC(4dbdc60f) SHA1(20e393f7207a8440029c8290cdf2f121d317a37e)) |
| 333 | ROM_LOAD("zrt80chr.z30", 0x0000, 0x0800, CRC(4dbdc60f) SHA1(20e393f7207a8440029c8290cdf2f121d317a37e) ) |
| 332 | 334 | ROM_END |
| 333 | 335 | |
| 334 | 336 | /* Driver */ |
src/mess/drivers/vta2000.c
| r11049 | r11050 | |
| 9 | 9 | 29/11/2010 Skeleton driver. |
| 10 | 10 | |
| 11 | 11 | ****************************************************************************/ |
| 12 | #define ADDRESS_MAP_MODERN |
| 12 | 13 | |
| 13 | 14 | #include "emu.h" |
| 14 | 15 | #include "cpu/i8085/i8085.h" |
| r11049 | r11050 | |
| 17 | 18 | { |
| 18 | 19 | public: |
| 19 | 20 | vta2000_state(running_machine &machine, const driver_device_config_base &config) |
| 20 | | : driver_device(machine, config) { } |
| 21 | : driver_device(machine, config), |
| 22 | m_maincpu(*this, "maincpu") |
| 23 | { } |
| 21 | 24 | |
| 22 | | const UINT8 *m_FNT; |
| 23 | | const UINT8 *m_videoram; |
| 25 | required_device<cpu_device> m_maincpu; |
| 26 | const UINT8 *m_p_chargen; |
| 27 | const UINT8 *m_p_videoram; |
| 24 | 28 | }; |
| 25 | 29 | |
| 26 | | static ADDRESS_MAP_START(vta2000_mem, AS_PROGRAM, 8) |
| 30 | static ADDRESS_MAP_START(vta2000_mem, AS_PROGRAM, 8, vta2000_state) |
| 27 | 31 | ADDRESS_MAP_UNMAP_HIGH |
| 28 | 32 | AM_RANGE( 0x0000, 0x5fff ) AM_ROM |
| 29 | 33 | AM_RANGE( 0x8000, 0xffff ) AM_RAM AM_REGION("maincpu", 0x8000) |
| 30 | 34 | ADDRESS_MAP_END |
| 31 | 35 | |
| 32 | | static ADDRESS_MAP_START(vta2000_io, AS_IO, 8) |
| 36 | static ADDRESS_MAP_START(vta2000_io, AS_IO, 8, vta2000_state) |
| 37 | ADDRESS_MAP_GLOBAL_MASK(0xff) |
| 33 | 38 | ADDRESS_MAP_UNMAP_HIGH |
| 34 | 39 | ADDRESS_MAP_END |
| 35 | 40 | |
| r11049 | r11050 | |
| 45 | 50 | static VIDEO_START( vta2000 ) |
| 46 | 51 | { |
| 47 | 52 | vta2000_state *state = machine.driver_data<vta2000_state>(); |
| 48 | | state->m_FNT = machine.region("chargen")->base(); |
| 49 | | state->m_videoram = machine.region("maincpu")->base()+0x80a0; |
| 53 | state->m_p_chargen = machine.region("chargen")->base(); |
| 54 | state->m_p_videoram = machine.region("maincpu")->base()+0x80a0; |
| 50 | 55 | } |
| 51 | 56 | |
| 52 | 57 | static SCREEN_UPDATE( vta2000 ) |
| r11049 | r11050 | |
| 69 | 74 | { |
| 70 | 75 | for (ra = 0; ra < 12; ra++) |
| 71 | 76 | { |
| 72 | | UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0); |
| 77 | UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0); |
| 73 | 78 | |
| 74 | 79 | xx = ma << 1; |
| 75 | 80 | for (x = ma; x < ma + 80; x++) |
| 76 | 81 | { |
| 77 | | chr = state->m_videoram[xx++]; |
| 78 | | attr = state->m_videoram[xx++]; |
| 82 | chr = state->m_p_videoram[xx++]; |
| 83 | attr = state->m_p_videoram[xx++]; |
| 79 | 84 | |
| 80 | 85 | if ((chr & 0x60)==0x60) |
| 81 | 86 | chr+=256; |
| 82 | 87 | |
| 83 | | gfx = state->m_FNT[(chr<<4) | ra ]; |
| 88 | gfx = state->m_p_chargen[(chr<<4) | ra ]; |
| 84 | 89 | |
| 85 | 90 | /* Display a scanline of a character */ |
| 86 | | *p++ = ( gfx & 0x80 ) ? 1 : 0; |
| 87 | | *p++ = ( gfx & 0x40 ) ? 1 : 0; |
| 88 | | *p++ = ( gfx & 0x20 ) ? 1 : 0; |
| 89 | | *p++ = ( gfx & 0x10 ) ? 1 : 0; |
| 90 | | *p++ = ( gfx & 0x08 ) ? 1 : 0; |
| 91 | | *p++ = ( gfx & 0x04 ) ? 1 : 0; |
| 92 | | *p++ = ( gfx & 0x02 ) ? 1 : 0; |
| 93 | | *p++ = ( gfx & 0x01 ) ? 1 : 0; |
| 91 | *p++ = BIT(gfx, 7); |
| 92 | *p++ = BIT(gfx, 6); |
| 93 | *p++ = BIT(gfx, 5); |
| 94 | *p++ = BIT(gfx, 4); |
| 95 | *p++ = BIT(gfx, 3); |
| 96 | *p++ = BIT(gfx, 2); |
| 97 | *p++ = BIT(gfx, 1); |
| 98 | *p++ = BIT(gfx, 0); |
| 94 | 99 | } |
| 95 | 100 | } |
| 96 | 101 | ma+=132; |
| r11049 | r11050 | |
| 156 | 161 | /* Driver */ |
| 157 | 162 | |
| 158 | 163 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT COMPANY FULLNAME FLAGS */ |
| 159 | | COMP( ????, vta2000, 0, 0, vta2000, vta2000, 0, "<unknown>", "VTA-2000", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 164 | COMP( ????, vta2000, 0, 0, vta2000, vta2000, 0, "<unknown>", "VTA-2000", GAME_NOT_WORKING | GAME_NO_SOUND) |
| 160 | 165 | |
src/mess/drivers/ptcsol.c
| r11049 | r11050 | |
| 89 | 89 | #include "imagedev/cassette.h" |
| 90 | 90 | #include "machine/ay31015.h" |
| 91 | 91 | |
| 92 | #define MACHINE_RESET_MEMBER(name) void name::machine_reset() |
| 93 | #define MACHINE_START_MEMBER(name) void name::machine_start() |
| 94 | #define VIDEO_START_MEMBER(name) void name::video_start() |
| 95 | #define SCREEN_UPDATE_MEMBER(name) bool name::screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect) |
| 96 | |
| 92 | 97 | typedef struct { |
| 93 | 98 | struct { |
| 94 | 99 | int length; /* time cassette level is at input.level */ |
| r11049 | r11050 | |
| 137 | 142 | UINT8 m_sol20_fa; |
| 138 | 143 | UINT8 m_sol20_fc; |
| 139 | 144 | UINT8 m_sol20_fe; |
| 140 | | const UINT8 *m_FNT; |
| 141 | | const UINT8 *m_videoram; |
| 145 | const UINT8 *m_p_chargen; |
| 146 | const UINT8 *m_p_videoram; |
| 142 | 147 | UINT8 m_framecnt; |
| 143 | 148 | emu_timer *m_cassette_timer; |
| 144 | 149 | cass_data_t m_cass_data; |
| 150 | virtual void machine_reset(); |
| 151 | virtual void machine_start(); |
| 152 | virtual void video_start(); |
| 153 | virtual bool screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect); |
| 145 | 154 | }; |
| 146 | 155 | |
| 147 | 156 | |
| r11049 | r11050 | |
| 361 | 370 | AM_RANGE(0X0800, 0Xbfff) AM_RAM // optional s100 ram |
| 362 | 371 | AM_RANGE(0xc000, 0xc7ff) AM_ROM |
| 363 | 372 | AM_RANGE(0Xc800, 0Xcbff) AM_RAM // system ram |
| 364 | | AM_RANGE(0Xcc00, 0Xcfff) AM_RAM AM_BASE(m_videoram) |
| 373 | AM_RANGE(0Xcc00, 0Xcfff) AM_RAM AM_BASE(m_p_videoram) |
| 365 | 374 | AM_RANGE(0Xd000, 0Xffff) AM_RAM // optional s100 ram |
| 366 | 375 | ADDRESS_MAP_END |
| 367 | 376 | |
| r11049 | r11050 | |
| 489 | 498 | memory_set_bank(machine, "boot", 0); |
| 490 | 499 | } |
| 491 | 500 | |
| 492 | | static MACHINE_START( sol20 ) |
| 501 | MACHINE_START_MEMBER( sol20_state ) |
| 493 | 502 | { |
| 494 | | sol20_state *state = machine.driver_data<sol20_state>(); |
| 495 | | state->m_cassette_timer = machine.scheduler().timer_alloc(FUNC(sol20_cassette_tc)); |
| 503 | m_cassette_timer = m_machine.scheduler().timer_alloc(FUNC(sol20_cassette_tc)); |
| 496 | 504 | } |
| 497 | 505 | |
| 498 | | static MACHINE_RESET( sol20 ) |
| 506 | MACHINE_RESET_MEMBER( sol20_state ) |
| 499 | 507 | { |
| 500 | | sol20_state *state = machine.driver_data<sol20_state>(); |
| 501 | 508 | UINT8 data = 0, s_count = 0; |
| 502 | 509 | int s_clock; |
| 503 | 510 | const UINT16 s_bauds[8]={ 75, 110, 180, 300, 600, 1200, 2400, 4800 }; |
| 504 | | state->m_sol20_fe=0; |
| 505 | | state->m_sol20_fa=1; |
| 511 | m_sol20_fe=0; |
| 512 | m_sol20_fa=1; |
| 506 | 513 | |
| 507 | 514 | // set hard-wired uart pins |
| 508 | | ay31015_set_input_pin( state->m_uart, AY31015_CS, 0 ); |
| 509 | | ay31015_set_input_pin( state->m_uart, AY31015_NB1, 1); |
| 510 | | ay31015_set_input_pin( state->m_uart, AY31015_NB2, 1); |
| 511 | | ay31015_set_input_pin( state->m_uart, AY31015_TSB, 1); |
| 512 | | ay31015_set_input_pin( state->m_uart, AY31015_EPS, 1); |
| 513 | | ay31015_set_input_pin( state->m_uart, AY31015_NP, 1); |
| 514 | | ay31015_set_input_pin( state->m_uart, AY31015_CS, 1 ); |
| 515 | ay31015_set_input_pin( m_uart, AY31015_CS, 0 ); |
| 516 | ay31015_set_input_pin( m_uart, AY31015_NB1, 1); |
| 517 | ay31015_set_input_pin( m_uart, AY31015_NB2, 1); |
| 518 | ay31015_set_input_pin( m_uart, AY31015_TSB, 1); |
| 519 | ay31015_set_input_pin( m_uart, AY31015_EPS, 1); |
| 520 | ay31015_set_input_pin( m_uart, AY31015_NP, 1); |
| 521 | ay31015_set_input_pin( m_uart, AY31015_CS, 1 ); |
| 515 | 522 | |
| 516 | 523 | // set switched uart pins |
| 517 | | data = input_port_read(machine, "S4"); |
| 518 | | ay31015_set_input_pin( state->m_uart_s, AY31015_CS, 0 ); |
| 519 | | ay31015_set_input_pin( state->m_uart_s, AY31015_NB1, BIT(data, 1) ? 1 : 0); |
| 520 | | ay31015_set_input_pin( state->m_uart_s, AY31015_NB2, BIT(data, 2) ? 1 : 0); |
| 521 | | ay31015_set_input_pin( state->m_uart_s, AY31015_TSB, BIT(data, 3) ? 1 : 0); |
| 522 | | ay31015_set_input_pin( state->m_uart_s, AY31015_EPS, BIT(data, 0) ? 1 : 0); |
| 523 | | ay31015_set_input_pin( state->m_uart_s, AY31015_NP, BIT(data, 4) ? 1 : 0); |
| 524 | | ay31015_set_input_pin( state->m_uart_s, AY31015_CS, 1 ); |
| 524 | data = input_port_read(m_machine, "S4"); |
| 525 | ay31015_set_input_pin( m_uart_s, AY31015_CS, 0 ); |
| 526 | ay31015_set_input_pin( m_uart_s, AY31015_NB1, BIT(data, 1) ? 1 : 0); |
| 527 | ay31015_set_input_pin( m_uart_s, AY31015_NB2, BIT(data, 2) ? 1 : 0); |
| 528 | ay31015_set_input_pin( m_uart_s, AY31015_TSB, BIT(data, 3) ? 1 : 0); |
| 529 | ay31015_set_input_pin( m_uart_s, AY31015_EPS, BIT(data, 0) ? 1 : 0); |
| 530 | ay31015_set_input_pin( m_uart_s, AY31015_NP, BIT(data, 4) ? 1 : 0); |
| 531 | ay31015_set_input_pin( m_uart_s, AY31015_CS, 1 ); |
| 525 | 532 | |
| 526 | 533 | // set rs232 baud rate |
| 527 | | data = input_port_read(machine, "S3"); |
| 534 | data = input_port_read(m_machine, "S3"); |
| 528 | 535 | |
| 529 | 536 | if (data > 1) |
| 530 | 537 | do |
| r11049 | r11050 | |
| 534 | 541 | } |
| 535 | 542 | while (!(data & 1) && (s_count < 7)); // find which switch is used |
| 536 | 543 | |
| 537 | | if ((s_count == 7) && (input_port_read(machine, "CONFIG")&1)) // if highest, look at jumper |
| 544 | if ((s_count == 7) && (input_port_read(m_machine, "CONFIG")&1)) // if highest, look at jumper |
| 538 | 545 | s_clock = 9600 << 4; |
| 539 | 546 | else |
| 540 | 547 | s_clock = s_bauds[s_count] << 4; |
| 541 | 548 | |
| 542 | 549 | // these lines could be commented out for now if you want better performance |
| 543 | | ay31015_set_receiver_clock( state->m_uart_s, s_clock); |
| 544 | | ay31015_set_transmitter_clock( state->m_uart_s, s_clock); |
| 550 | ay31015_set_receiver_clock( m_uart_s, s_clock); |
| 551 | ay31015_set_transmitter_clock( m_uart_s, s_clock); |
| 545 | 552 | |
| 546 | 553 | // boot-bank |
| 547 | | memory_set_bank(machine, "boot", 1); |
| 548 | | machine.scheduler().timer_set(attotime::from_usec(9), FUNC(sol20_boot)); |
| 554 | memory_set_bank(m_machine, "boot", 1); |
| 555 | m_machine.scheduler().timer_set(attotime::from_usec(9), FUNC(sol20_boot)); |
| 549 | 556 | } |
| 550 | 557 | |
| 551 | 558 | static DRIVER_INIT( sol20 ) |
| r11049 | r11050 | |
| 554 | 561 | memory_configure_bank(machine, "boot", 0, 2, &RAM[0x0000], 0xc000); |
| 555 | 562 | } |
| 556 | 563 | |
| 557 | | static VIDEO_START( sol20 ) |
| 564 | VIDEO_START_MEMBER( sol20_state ) |
| 558 | 565 | { |
| 559 | | sol20_state *state = machine.driver_data<sol20_state>(); |
| 560 | | state->m_FNT = machine.region("chargen")->base(); |
| 566 | m_p_chargen = m_machine.region("chargen")->base(); |
| 561 | 567 | } |
| 562 | 568 | |
| 563 | | static SCREEN_UPDATE( sol20 ) |
| 569 | SCREEN_UPDATE_MEMBER( sol20_state ) |
| 564 | 570 | { |
| 565 | 571 | // Visible screen is 64 x 16, with start position controlled by scroll register. |
| 566 | 572 | // Each character is 9 pixels wide (blank ones at the right) and 13 lines deep. |
| 567 | 573 | // Note on blinking characters: |
| 568 | 574 | // any character with bit 7 set will blink. With DPMON, do DA C000 C2FF to see what happens |
| 569 | | UINT8 s1 = input_port_read(screen->machine(), "S1"); |
| 570 | | UINT16 which = (input_port_read(screen->machine(), "CONFIG") & 2) << 10; |
| 571 | | sol20_state *state = screen->machine().driver_data<sol20_state>(); |
| 575 | UINT8 s1 = input_port_read(machine(), "S1"); |
| 576 | UINT16 which = (input_port_read(machine(), "CONFIG") & 2) << 10; |
| 572 | 577 | UINT8 y,ra,chr,gfx; |
| 573 | 578 | UINT16 sy=0,ma,x,inv; |
| 574 | 579 | UINT8 polarity = (s1 & 8) ? 0xff : 0; |
| 575 | 580 | |
| 576 | 581 | UINT8 cursor_inv = FALSE; |
| 577 | | if (((s1 & 0x30) == 0x20) || (((s1 & 0x30) == 0x10) && (state->m_framecnt & 0x08))) |
| 582 | if (((s1 & 0x30) == 0x20) || (((s1 & 0x30) == 0x10) && (m_framecnt & 0x08))) |
| 578 | 583 | cursor_inv = TRUE; |
| 579 | 584 | |
| 580 | | state->m_framecnt++; |
| 585 | m_framecnt++; |
| 581 | 586 | |
| 582 | | ma = state->m_sol20_fe << 6; // scroll register |
| 587 | ma = m_sol20_fe << 6; // scroll register |
| 583 | 588 | |
| 584 | 589 | for (y = 0; y < 16; y++) |
| 585 | 590 | { |
| 586 | 591 | for (ra = 0; ra < 13; ra++) |
| 587 | 592 | { |
| 588 | | UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0); |
| 593 | UINT16 *p = BITMAP_ADDR16(&bitmap, sy++, 0); |
| 589 | 594 | |
| 590 | 595 | for (x = ma; x < ma + 64; x++) |
| 591 | 596 | { |
| 592 | 597 | inv = polarity; |
| 593 | | chr = state->m_videoram[x & 0x3ff]; |
| 598 | chr = m_p_videoram[x & 0x3ff]; |
| 594 | 599 | |
| 595 | 600 | // cursor |
| 596 | 601 | if (BIT(chr, 7) && cursor_inv) |
| r11049 | r11050 | |
| 606 | 611 | if (ra < 4) |
| 607 | 612 | gfx = inv; |
| 608 | 613 | else |
| 609 | | gfx = state->m_FNT[which | (chr<<4) | (ra-4) ] ^ inv; |
| 614 | gfx = m_p_chargen[which | (chr<<4) | (ra-4) ] ^ inv; |
| 610 | 615 | } |
| 611 | 616 | else |
| 612 | 617 | { |
| 613 | 618 | if (ra < 10) |
| 614 | | gfx = state->m_FNT[which | (chr<<4) | (ra-1) ] ^ inv; |
| 619 | gfx = m_p_chargen[which | (chr<<4) | (ra-1) ] ^ inv; |
| 615 | 620 | else |
| 616 | 621 | gfx = inv; |
| 617 | 622 | } |
| 618 | 623 | |
| 619 | 624 | /* Display a scanline of a character */ |
| 620 | | *p++ = ( gfx & 0x80 ) ? 1 : 0; |
| 621 | | *p++ = ( gfx & 0x40 ) ? 1 : 0; |
| 622 | | *p++ = ( gfx & 0x20 ) ? 1 : 0; |
| 623 | | *p++ = ( gfx & 0x10 ) ? 1 : 0; |
| 624 | | *p++ = ( gfx & 0x08 ) ? 1 : 0; |
| 625 | | *p++ = ( gfx & 0x04 ) ? 1 : 0; |
| 626 | | *p++ = ( gfx & 0x02 ) ? 1 : 0; |
| 627 | | *p++ = ( gfx & 0x01 ) ? 1 : 0; |
| 625 | *p++ = BIT(gfx, 7); |
| 626 | *p++ = BIT(gfx, 6); |
| 627 | *p++ = BIT(gfx, 5); |
| 628 | *p++ = BIT(gfx, 4); |
| 629 | *p++ = BIT(gfx, 3); |
| 630 | *p++ = BIT(gfx, 2); |
| 631 | *p++ = BIT(gfx, 1); |
| 632 | *p++ = BIT(gfx, 0); |
| 628 | 633 | *p++ = (inv) ? 1 : 0; |
| 629 | 634 | } |
| 630 | 635 | } |
| r11049 | r11050 | |
| 668 | 673 | MCFG_CPU_PROGRAM_MAP(sol20_mem) |
| 669 | 674 | MCFG_CPU_IO_MAP(sol20_io) |
| 670 | 675 | |
| 671 | | MCFG_MACHINE_START(sol20) |
| 672 | | MCFG_MACHINE_RESET(sol20) |
| 673 | | |
| 674 | 676 | /* video hardware */ |
| 675 | 677 | MCFG_SCREEN_ADD("screen", RASTER) |
| 676 | 678 | MCFG_SCREEN_REFRESH_RATE(50) |
| r11049 | r11050 | |
| 678 | 680 | MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16) |
| 679 | 681 | MCFG_SCREEN_SIZE(576, 208) |
| 680 | 682 | MCFG_SCREEN_VISIBLE_AREA(0, 575, 0, 207) |
| 681 | | MCFG_SCREEN_UPDATE(sol20) |
| 682 | | |
| 683 | 683 | MCFG_GFXDECODE(sol20) |
| 684 | 684 | MCFG_PALETTE_LENGTH(2) |
| 685 | 685 | MCFG_PALETTE_INIT(black_and_white) |
| 686 | 686 | |
| 687 | | MCFG_VIDEO_START(sol20) |
| 688 | | |
| 689 | 687 | /* sound hardware */ |
| 690 | 688 | MCFG_SPEAKER_STANDARD_MONO("mono") |
| 691 | 689 | MCFG_SOUND_WAVE_ADD("wave.1", "cassette1") |
src/mess/drivers/argo.c
| r11049 | r11050 | |
| 12 | 12 | #include "emu.h" |
| 13 | 13 | #include "cpu/z80/z80.h" |
| 14 | 14 | |
| 15 | #define MACHINE_RESET_MEMBER(name) void name::machine_reset() |
| 16 | #define VIDEO_START_MEMBER(name) void name::video_start() |
| 17 | #define SCREEN_UPDATE_MEMBER(name) bool name::screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect) |
| 15 | 18 | |
| 16 | 19 | class argo_state : public driver_device |
| 17 | 20 | { |
| r11049 | r11050 | |
| 22 | 25 | { } |
| 23 | 26 | |
| 24 | 27 | required_device<cpu_device> m_maincpu; |
| 25 | | UINT8* m_videoram; |
| 26 | | const UINT8 *m_FNT; |
| 28 | const UINT8 *m_p_videoram; |
| 29 | const UINT8 *m_p_chargen; |
| 27 | 30 | UINT8 m_framecnt; |
| 31 | virtual void machine_reset(); |
| 32 | virtual void video_start(); |
| 33 | virtual bool screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect); |
| 28 | 34 | }; |
| 29 | 35 | |
| 30 | 36 | |
| r11049 | r11050 | |
| 32 | 38 | ADDRESS_MAP_UNMAP_HIGH |
| 33 | 39 | AM_RANGE(0x0000, 0x07ff) AM_RAMBANK("boot") |
| 34 | 40 | AM_RANGE(0x0800, 0xf7af) AM_RAM |
| 35 | | AM_RANGE(0xf7b0, 0xf7ff) AM_RAM AM_BASE(m_videoram) |
| 41 | AM_RANGE(0xf7b0, 0xf7ff) AM_RAM AM_BASE(m_p_videoram) |
| 36 | 42 | AM_RANGE(0xf800, 0xffff) AM_ROM |
| 37 | 43 | ADDRESS_MAP_END |
| 38 | 44 | |
| r11049 | r11050 | |
| 52 | 58 | memory_set_bank(machine, "boot", 0); |
| 53 | 59 | } |
| 54 | 60 | |
| 55 | | static MACHINE_RESET(argo) |
| 61 | MACHINE_RESET_MEMBER(argo_state) |
| 56 | 62 | { |
| 57 | | memory_set_bank(machine, "boot", 1); |
| 58 | | machine.scheduler().timer_set(attotime::from_usec(5), FUNC(argo_boot)); |
| 63 | memory_set_bank(m_machine, "boot", 1); |
| 64 | m_machine.scheduler().timer_set(attotime::from_usec(5), FUNC(argo_boot)); |
| 59 | 65 | } |
| 60 | 66 | |
| 61 | 67 | DRIVER_INIT( argo ) |
| r11049 | r11050 | |
| 64 | 70 | memory_configure_bank(machine, "boot", 0, 2, &RAM[0x0000], 0xf800); |
| 65 | 71 | } |
| 66 | 72 | |
| 67 | | static VIDEO_START( argo ) |
| 73 | VIDEO_START_MEMBER( argo_state ) |
| 68 | 74 | { |
| 69 | | argo_state *state = machine.driver_data<argo_state>(); |
| 70 | | state->m_FNT = machine.region("chargen")->base(); |
| 75 | m_p_chargen = m_machine.region("chargen")->base(); |
| 71 | 76 | } |
| 72 | 77 | |
| 73 | | static SCREEN_UPDATE( argo ) |
| 78 | SCREEN_UPDATE_MEMBER( argo_state ) |
| 74 | 79 | { |
| 75 | | argo_state *state = screen->machine().driver_data<argo_state>(); |
| 76 | | UINT8 y,ra,chr,gfx,i; |
| 80 | UINT8 y,ra,chr,gfx; |
| 77 | 81 | UINT16 sy=0,ma=0,x; |
| 78 | 82 | |
| 79 | | state->m_framecnt++; |
| 83 | m_framecnt++; |
| 80 | 84 | |
| 81 | 85 | for (y = 0; y < 5; y++) |
| 82 | 86 | { |
| 83 | 87 | for (ra = 0; ra < 10; ra++) |
| 84 | 88 | { |
| 85 | | UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0); |
| 89 | UINT16 *p = BITMAP_ADDR16(&bitmap, sy++, 0); |
| 86 | 90 | |
| 87 | 91 | for (x = ma; x < ma + 16; x++) |
| 88 | 92 | { |
| r11049 | r11050 | |
| 90 | 94 | |
| 91 | 95 | if (ra < 9) |
| 92 | 96 | { |
| 93 | | chr = state->m_videoram[x]; |
| 97 | chr = m_p_videoram[x]; |
| 94 | 98 | |
| 95 | 99 | /* Take care of flashing characters */ |
| 96 | | if ((chr & 0x80) && (state->m_framecnt & 0x08)) |
| 100 | if ((chr & 0x80) && (m_framecnt & 0x08)) |
| 97 | 101 | chr = 0x20; |
| 98 | 102 | |
| 99 | 103 | chr &= 0x7f; |
| 100 | 104 | |
| 101 | | gfx = state->m_FNT[(chr<<4) | ra ]; |
| 105 | gfx = m_p_chargen[(chr<<4) | ra ]; |
| 102 | 106 | } |
| 103 | 107 | |
| 104 | 108 | /* Display a scanline of a character */ |
| 105 | | for (i = 0; i < 8; i++) |
| 106 | | *p++ = BIT(gfx, 7-i); |
| 109 | *p++ = BIT(gfx, 7); |
| 110 | *p++ = BIT(gfx, 6); |
| 111 | *p++ = BIT(gfx, 5); |
| 112 | *p++ = BIT(gfx, 4); |
| 113 | *p++ = BIT(gfx, 3); |
| 114 | *p++ = BIT(gfx, 2); |
| 115 | *p++ = BIT(gfx, 1); |
| 116 | *p++ = BIT(gfx, 0); |
| 107 | 117 | } |
| 108 | 118 | } |
| 109 | 119 | ma+=16; |
| r11049 | r11050 | |
| 117 | 127 | MCFG_CPU_PROGRAM_MAP(argo_mem) |
| 118 | 128 | MCFG_CPU_IO_MAP(argo_io) |
| 119 | 129 | |
| 120 | | MCFG_MACHINE_RESET(argo) |
| 121 | | |
| 122 | 130 | /* video hardware */ |
| 123 | 131 | MCFG_SCREEN_ADD("screen", RASTER) |
| 124 | 132 | MCFG_SCREEN_REFRESH_RATE(50) |
| r11049 | r11050 | |
| 126 | 134 | MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16) |
| 127 | 135 | MCFG_SCREEN_SIZE(128, 50) |
| 128 | 136 | MCFG_SCREEN_VISIBLE_AREA(0, 128-1, 0, 50-1) |
| 129 | | MCFG_SCREEN_UPDATE(argo) |
| 130 | | |
| 131 | 137 | MCFG_PALETTE_LENGTH(2) |
| 132 | 138 | MCFG_PALETTE_INIT(black_and_white) |
| 133 | | |
| 134 | | MCFG_VIDEO_START(argo) |
| 135 | 139 | MACHINE_CONFIG_END |
| 136 | 140 | |
| 137 | 141 | /* ROM definition */ |