src/mess/machine/advision.c
| r9652 | r9653 | |
| 25 | 25 | |
| 26 | 26 | /* Machine Initialization */ |
| 27 | 27 | |
| 28 | | MACHINE_START( advision ) |
| 28 | void advision_state::machine_start() |
| 29 | 29 | { |
| 30 | | advision_state *state = machine->driver_data<advision_state>(); |
| 31 | 30 | /* configure EA banking */ |
| 32 | 31 | memory_configure_bank(machine, "bank1", 0, 1, memory_region(machine, "bios"), 0); |
| 33 | 32 | memory_configure_bank(machine, "bank1", 1, 1, memory_region(machine, I8048_TAG), 0); |
| 34 | | memory_install_readwrite_bank(cputag_get_address_space(machine, I8048_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x03ff, 0, 0, "bank1"); |
| 33 | memory_install_readwrite_bank(cpu_get_address_space(m_maincpu, ADDRESS_SPACE_PROGRAM), 0x0000, 0x03ff, 0, 0, "bank1"); |
| 35 | 34 | memory_set_bank(machine, "bank1", 0); |
| 36 | 35 | |
| 37 | 36 | /* allocate external RAM */ |
| 38 | | state->extram = auto_alloc_array(machine, UINT8, 0x400); |
| 37 | m_ext_ram = auto_alloc_array(machine, UINT8, 0x400); |
| 39 | 38 | } |
| 40 | 39 | |
| 41 | | MACHINE_RESET( advision ) |
| 40 | void advision_state::machine_reset() |
| 42 | 41 | { |
| 43 | | advision_state *state = machine->driver_data<advision_state>(); |
| 44 | | |
| 45 | 42 | /* enable internal ROM */ |
| 46 | | cputag_set_input_line(machine, I8048_TAG, MCS48_INPUT_EA, CLEAR_LINE); |
| 43 | cpu_set_input_line(m_maincpu, MCS48_INPUT_EA, CLEAR_LINE); |
| 47 | 44 | memory_set_bank(machine, "bank1", 0); |
| 48 | 45 | |
| 49 | 46 | /* reset sound CPU */ |
| 50 | | cputag_set_input_line(machine, COP411_TAG, INPUT_LINE_RESET, ASSERT_LINE); |
| 47 | cpu_set_input_line(m_soundcpu, INPUT_LINE_RESET, ASSERT_LINE); |
| 51 | 48 | |
| 52 | | state->rambank = 0x300; |
| 53 | | state->frame_start = 0; |
| 54 | | state->video_enable = 0; |
| 55 | | state->sound_cmd = 0; |
| 49 | m_rambank = 0x300; |
| 50 | m_frame_start = 0; |
| 51 | m_video_enable = 0; |
| 52 | m_sound_cmd = 0; |
| 56 | 53 | } |
| 57 | 54 | |
| 58 | 55 | /* Bank Switching */ |
| 59 | 56 | |
| 60 | | WRITE8_HANDLER( advision_bankswitch_w ) |
| 57 | WRITE8_MEMBER( advision_state::bankswitch_w ) |
| 61 | 58 | { |
| 62 | | advision_state *state = space->machine->driver_data<advision_state>(); |
| 63 | | |
| 64 | 59 | int ea = BIT(data, 2); |
| 65 | 60 | |
| 66 | | cputag_set_input_line(space->machine, I8048_TAG, MCS48_INPUT_EA, ea ? ASSERT_LINE : CLEAR_LINE); |
| 61 | cpu_set_input_line(m_maincpu, MCS48_INPUT_EA, ea ? ASSERT_LINE : CLEAR_LINE); |
| 67 | 62 | |
| 68 | | memory_set_bank(space->machine, "bank1", ea); |
| 63 | memory_set_bank(machine, "bank1", ea); |
| 69 | 64 | |
| 70 | | state->rambank = (data & 0x03) << 8; |
| 65 | m_rambank = (data & 0x03) << 8; |
| 71 | 66 | } |
| 72 | 67 | |
| 73 | 68 | /* External RAM */ |
| 74 | 69 | |
| 75 | | READ8_HANDLER( advision_extram_r ) |
| 70 | READ8_MEMBER( advision_state::ext_ram_r ) |
| 76 | 71 | { |
| 77 | | advision_state *state = space->machine->driver_data<advision_state>(); |
| 72 | UINT8 data = m_ext_ram[m_rambank + offset]; |
| 78 | 73 | |
| 79 | | UINT8 data = state->extram[state->rambank + offset]; |
| 80 | | |
| 81 | | if (!state->video_enable) |
| 74 | if (!m_video_enable) |
| 82 | 75 | { |
| 83 | 76 | /* the video hardware interprets reads as writes */ |
| 84 | | advision_vh_write(space->machine, data); |
| 77 | vh_write(data); |
| 85 | 78 | } |
| 86 | 79 | |
| 87 | | if (state->video_bank == 0x06) |
| 80 | if (m_video_bank == 0x06) |
| 88 | 81 | { |
| 89 | | cputag_set_input_line(space->machine, COP411_TAG, INPUT_LINE_RESET, (data & 0x01) ? CLEAR_LINE : ASSERT_LINE); |
| 82 | cpu_set_input_line(m_soundcpu, INPUT_LINE_RESET, (data & 0x01) ? CLEAR_LINE : ASSERT_LINE); |
| 90 | 83 | } |
| 91 | 84 | |
| 92 | 85 | return data; |
| 93 | 86 | } |
| 94 | 87 | |
| 95 | | WRITE8_HANDLER( advision_extram_w ) |
| 88 | WRITE8_MEMBER( advision_state::ext_ram_w ) |
| 96 | 89 | { |
| 97 | | advision_state *state = space->machine->driver_data<advision_state>(); |
| 98 | | |
| 99 | | state->extram[state->rambank + offset] = data; |
| 90 | m_ext_ram[m_rambank + offset] = data; |
| 100 | 91 | } |
| 101 | 92 | |
| 102 | 93 | /* Sound */ |
| 103 | 94 | |
| 104 | | READ8_HANDLER( advision_sound_cmd_r ) |
| 95 | READ8_MEMBER( advision_state::sound_cmd_r ) |
| 105 | 96 | { |
| 106 | | advision_state *state = space->machine->driver_data<advision_state>(); |
| 107 | | |
| 108 | | return state->sound_cmd; |
| 97 | return m_sound_cmd; |
| 109 | 98 | } |
| 110 | 99 | |
| 111 | | static void update_dac(running_machine *machine) |
| 100 | void advision_state::update_dac() |
| 112 | 101 | { |
| 113 | | running_device *dac_device = machine->device("dac"); |
| 114 | | advision_state *state = machine->driver_data<advision_state>(); |
| 115 | | |
| 116 | | if (state->sound_g == 0 && state->sound_d == 0) |
| 117 | | dac_data_w(dac_device, 0xff); |
| 118 | | else if (state->sound_g == 1 && state->sound_d == 1) |
| 119 | | dac_data_w(dac_device, 0x80); |
| 102 | if (m_sound_g == 0 && m_sound_d == 0) |
| 103 | dac_data_w(m_dac, 0xff); |
| 104 | else if (m_sound_g == 1 && m_sound_d == 1) |
| 105 | dac_data_w(m_dac, 0x80); |
| 120 | 106 | else |
| 121 | | dac_data_w(dac_device, 0x00); |
| 107 | dac_data_w(m_dac, 0x00); |
| 122 | 108 | } |
| 123 | 109 | |
| 124 | | WRITE8_HANDLER( advision_sound_g_w ) |
| 110 | WRITE8_MEMBER( advision_state::sound_g_w ) |
| 125 | 111 | { |
| 126 | | advision_state *state = space->machine->driver_data<advision_state>(); |
| 127 | | state->sound_g = data & 0x01; |
| 128 | | update_dac(space->machine); |
| 112 | m_sound_g = data & 0x01; |
| 113 | |
| 114 | update_dac(); |
| 129 | 115 | } |
| 130 | 116 | |
| 131 | | |
| 132 | | WRITE8_HANDLER( advision_sound_d_w ) |
| 117 | WRITE8_MEMBER( advision_state::sound_d_w ) |
| 133 | 118 | { |
| 134 | | advision_state *state = space->machine->driver_data<advision_state>(); |
| 135 | | state->sound_d = data & 0x01; |
| 136 | | update_dac(space->machine); |
| 119 | m_sound_d = data & 0x01; |
| 120 | |
| 121 | update_dac(); |
| 137 | 122 | } |
| 138 | 123 | |
| 139 | 124 | /* Video */ |
| 140 | 125 | |
| 141 | | WRITE8_HANDLER( advision_av_control_w ) |
| 126 | WRITE8_MEMBER( advision_state::av_control_w ) |
| 142 | 127 | { |
| 143 | | advision_state *state = space->machine->driver_data<advision_state>(); |
| 128 | m_sound_cmd = data >> 4; |
| 144 | 129 | |
| 145 | | state->sound_cmd = data >> 4; |
| 146 | | |
| 147 | | if ((state->video_enable == 0x00) && (data & 0x10)) |
| 130 | if ((m_video_enable == 0x00) && (data & 0x10)) |
| 148 | 131 | { |
| 149 | | advision_vh_update(space->machine, state->video_hpos); |
| 132 | vh_update(m_video_hpos); |
| 150 | 133 | |
| 151 | | state->video_hpos++; |
| 134 | m_video_hpos++; |
| 152 | 135 | |
| 153 | | if (state->video_hpos > 255) |
| 136 | if (m_video_hpos > 255) |
| 154 | 137 | { |
| 155 | | state->video_hpos = 0; |
| 138 | m_video_hpos = 0; |
| 156 | 139 | logerror("HPOS OVERFLOW\n"); |
| 157 | 140 | } |
| 158 | 141 | } |
| 159 | 142 | |
| 160 | | state->video_enable = data & 0x10; |
| 161 | | state->video_bank = (data & 0xe0) >> 5; |
| 143 | m_video_enable = data & 0x10; |
| 144 | m_video_bank = (data & 0xe0) >> 5; |
| 162 | 145 | } |
| 163 | 146 | |
| 164 | | READ8_HANDLER( advision_vsync_r ) |
| 147 | READ8_MEMBER( advision_state::vsync_r ) |
| 165 | 148 | { |
| 166 | | advision_state *state = space->machine->driver_data<advision_state>(); |
| 167 | | |
| 168 | | if (state->frame_start) |
| 149 | if (m_frame_start) |
| 169 | 150 | { |
| 170 | | state->frame_start = 0; |
| 151 | m_frame_start = 0; |
| 171 | 152 | |
| 172 | 153 | return 0; |
| 173 | 154 | } |
| r9652 | r9653 | |
| 179 | 160 | |
| 180 | 161 | /* Input */ |
| 181 | 162 | |
| 182 | | READ8_HANDLER( advision_controller_r ) |
| 163 | READ8_MEMBER( advision_state::controller_r ) |
| 183 | 164 | { |
| 184 | 165 | // Get joystick switches |
| 185 | | UINT8 in = input_port_read(space->machine, "joystick"); |
| 166 | UINT8 in = input_port_read(machine, "joystick"); |
| 186 | 167 | UINT8 data = in | 0x0f; |
| 187 | 168 | |
| 188 | 169 | // Get buttons |
src/mess/video/advision.c
| r9652 | r9653 | |
| 17 | 17 | Start the video hardware emulation. |
| 18 | 18 | |
| 19 | 19 | ***************************************************************************/ |
| 20 | | VIDEO_START( advision ) |
| 21 | | { |
| 22 | | advision_state *state = machine->driver_data<advision_state>(); |
| 23 | 20 | |
| 24 | | state->video_hpos = 0; |
| 25 | | state->display = auto_alloc_array(machine, UINT8, 8 * 8 * 256); |
| 26 | | memset(state->display, 0, 8 * 8 * 256); |
| 21 | void advision_state::video_start() |
| 22 | { |
| 23 | m_video_hpos = 0; |
| 24 | m_display = auto_alloc_array(machine, UINT8, 8 * 8 * 256); |
| 25 | memset(m_display, 0, 8 * 8 * 256); |
| 27 | 26 | } |
| 28 | 27 | |
| 29 | 28 | /*************************************************************************** |
| r9652 | r9653 | |
| 49 | 48 | |
| 50 | 49 | ***************************************************************************/ |
| 51 | 50 | |
| 52 | | void advision_vh_write(running_machine *machine, int data) |
| 51 | void advision_state::vh_write(int data) |
| 53 | 52 | { |
| 54 | | advision_state *state = machine->driver_data<advision_state>(); |
| 55 | | |
| 56 | | if (state->video_bank >= 1 && state->video_bank <=5) |
| 53 | if (m_video_bank >= 1 && m_video_bank <=5) |
| 57 | 54 | { |
| 58 | | state->led_latch[state->video_bank] = data; |
| 55 | m_led_latch[m_video_bank] = data; |
| 59 | 56 | } |
| 60 | 57 | } |
| 61 | 58 | |
| 62 | | void advision_vh_update(running_machine *machine, int x) |
| 59 | void advision_state::vh_update(int x) |
| 63 | 60 | { |
| 64 | | advision_state *state = machine->driver_data<advision_state>(); |
| 65 | | |
| 66 | | UINT8 *dst = &state->display[x]; |
| 61 | UINT8 *dst = &m_display[x]; |
| 67 | 62 | int y; |
| 68 | 63 | |
| 69 | 64 | for( y = 0; y < 8; y++ ) |
| 70 | 65 | { |
| 71 | | UINT8 data = state->led_latch[7-y]; |
| 66 | UINT8 data = m_led_latch[7-y]; |
| 72 | 67 | |
| 73 | 68 | if( (data & 0x80) == 0 ) dst[0 * 256] = 8; |
| 74 | 69 | if( (data & 0x40) == 0 ) dst[1 * 256] = 8; |
| r9652 | r9653 | |
| 79 | 74 | if( (data & 0x02) == 0 ) dst[6 * 256] = 8; |
| 80 | 75 | if( (data & 0x01) == 0 ) dst[7 * 256] = 8; |
| 81 | 76 | |
| 82 | | state->led_latch[7-y] = 0xff; |
| 77 | m_led_latch[7-y] = 0xff; |
| 83 | 78 | |
| 84 | 79 | dst += 8 * 256; |
| 85 | 80 | } |
| r9652 | r9653 | |
| 92 | 87 | |
| 93 | 88 | ***************************************************************************/ |
| 94 | 89 | |
| 95 | | VIDEO_UPDATE( advision ) |
| 90 | bool advision_state::video_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect) |
| 96 | 91 | { |
| 97 | | advision_state *state = screen->machine->driver_data<advision_state>(); |
| 98 | | |
| 99 | 92 | int x, y; |
| 100 | 93 | |
| 101 | | static int framecount = 0; |
| 102 | | |
| 103 | | if( (framecount++ % 4) == 0 ) |
| 94 | if( (m_frame_count++ % 4) == 0 ) |
| 104 | 95 | { |
| 105 | | state->frame_start = 1; |
| 106 | | state->video_hpos = 0; |
| 96 | m_frame_start = 1; |
| 97 | m_video_hpos = 0; |
| 107 | 98 | } |
| 108 | 99 | |
| 109 | 100 | for (x = 0; x < 150; x++) |
| 110 | 101 | { |
| 111 | | UINT8 *led = &state->display[x]; |
| 102 | UINT8 *led = &m_display[x]; |
| 112 | 103 | |
| 113 | 104 | for( y = 0; y < 128; y+=2 ) |
| 114 | 105 | { |
| 115 | 106 | if( *led > 0 ) |
| 116 | | *BITMAP_ADDR16(bitmap, 30 + y, 85 + x) = --(*led); |
| 107 | *BITMAP_ADDR16(&bitmap, 30 + y, 85 + x) = --(*led); |
| 117 | 108 | else |
| 118 | | *BITMAP_ADDR16(bitmap, 30 + y, 85 + x) = 0; |
| 109 | *BITMAP_ADDR16(&bitmap, 30 + y, 85 + x) = 0; |
| 119 | 110 | |
| 120 | 111 | led += 256; |
| 121 | 112 | } |
| 122 | 113 | } |
| 123 | 114 | return 0; |
| 124 | 115 | } |
| 125 | | |
| 126 | | |
src/mess/includes/advision.h
| r9652 | r9653 | |
| 15 | 15 | { |
| 16 | 16 | public: |
| 17 | 17 | advision_state(running_machine &machine, const driver_device_config_base &config) |
| 18 | | : driver_device(machine, config) { } |
| 18 | : driver_device(machine, config), |
| 19 | m_maincpu(*this, I8048_TAG), |
| 20 | m_soundcpu(*this, COP411_TAG), |
| 21 | m_dac(*this, "dac") |
| 22 | { } |
| 19 | 23 | |
| 20 | | /* external RAM state */ |
| 21 | | UINT8 *extram; |
| 22 | | int rambank; |
| 24 | required_device<cpu_device> m_maincpu; |
| 25 | required_device<cpu_device> m_soundcpu; |
| 26 | required_device<running_device> m_dac; |
| 23 | 27 | |
| 24 | | /* video state */ |
| 25 | | int frame_start; |
| 26 | | int video_enable; |
| 27 | | int video_bank; |
| 28 | | int video_hpos; |
| 29 | | UINT8 led_latch[8]; |
| 30 | | UINT8 *display; |
| 28 | virtual void machine_start(); |
| 29 | virtual void machine_reset(); |
| 31 | 30 | |
| 32 | | /* sound state */ |
| 33 | | int sound_cmd; |
| 34 | | int sound_d; |
| 35 | | int sound_g; |
| 36 | | }; |
| 31 | virtual void video_start(); |
| 32 | virtual bool video_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect); |
| 37 | 33 | |
| 38 | | /*----------- defined in machine/advision.c -----------*/ |
| 34 | void update_dac(); |
| 35 | void vh_write(int data); |
| 36 | void vh_update(int x); |
| 39 | 37 | |
| 40 | | MACHINE_START( advision ); |
| 41 | | MACHINE_RESET( advision ); |
| 42 | | READ8_HANDLER( advision_extram_r ); |
| 43 | | WRITE8_HANDLER( advision_extram_w ); |
| 38 | DECLARE_READ8_MEMBER( ext_ram_r ); |
| 39 | DECLARE_WRITE8_MEMBER( ext_ram_w ); |
| 40 | DECLARE_READ8_MEMBER( controller_r ); |
| 41 | DECLARE_WRITE8_MEMBER( bankswitch_w ); |
| 42 | DECLARE_WRITE8_MEMBER( av_control_w ); |
| 43 | DECLARE_READ8_MEMBER( vsync_r ); |
| 44 | DECLARE_READ8_MEMBER( sound_cmd_r ); |
| 45 | DECLARE_WRITE8_MEMBER( sound_g_w ); |
| 46 | DECLARE_WRITE8_MEMBER( sound_d_w ); |
| 44 | 47 | |
| 45 | | /* Port P1 */ |
| 46 | | READ8_HANDLER( advision_controller_r ); |
| 47 | | WRITE8_HANDLER( advision_bankswitch_w ); |
| 48 | /* external RAM state */ |
| 49 | UINT8 *m_ext_ram; |
| 50 | int m_rambank; |
| 48 | 51 | |
| 49 | | /* Port P2 */ |
| 50 | | WRITE8_HANDLER( advision_av_control_w ); |
| 52 | /* video state */ |
| 53 | int m_frame_count; |
| 54 | int m_frame_start; |
| 55 | int m_video_enable; |
| 56 | int m_video_bank; |
| 57 | int m_video_hpos; |
| 58 | UINT8 m_led_latch[8]; |
| 59 | UINT8 *m_display; |
| 51 | 60 | |
| 52 | | READ8_HANDLER( advision_vsync_r ); |
| 53 | | READ8_HANDLER( advision_sound_cmd_r ); |
| 54 | | WRITE8_HANDLER( advision_sound_g_w ); |
| 55 | | WRITE8_HANDLER( advision_sound_d_w ); |
| 61 | /* sound state */ |
| 62 | int m_sound_cmd; |
| 63 | int m_sound_d; |
| 64 | int m_sound_g; |
| 65 | }; |
| 56 | 66 | |
| 57 | 67 | /*----------- defined in video/advision.c -----------*/ |
| 58 | 68 | |
| 59 | | VIDEO_START( advision ); |
| 60 | | VIDEO_UPDATE( advision ); |
| 61 | 69 | PALETTE_INIT( advision ); |
| 62 | | void advision_vh_write(running_machine *machine, int data); |
| 63 | | void advision_vh_update(running_machine *machine, int data); |
| 64 | 70 | |
| 65 | 71 | #endif |
src/mess/drivers/advision.c
| r9652 | r9653 | |
| 16 | 16 | |
| 17 | 17 | */ |
| 18 | 18 | |
| 19 | #define ADDRESS_MAP_MODERN |
| 20 | |
| 19 | 21 | #include "emu.h" |
| 20 | 22 | #include "includes/advision.h" |
| 21 | 23 | #include "cpu/mcs48/mcs48.h" |
| r9652 | r9653 | |
| 25 | 27 | |
| 26 | 28 | /* Memory Maps */ |
| 27 | 29 | |
| 28 | | static ADDRESS_MAP_START( program_map, ADDRESS_SPACE_PROGRAM, 8 ) |
| 30 | static ADDRESS_MAP_START( program_map, ADDRESS_SPACE_PROGRAM, 8, advision_state ) |
| 29 | 31 | AM_RANGE(0x0000, 0x03ff) AM_ROMBANK("bank1") |
| 30 | 32 | AM_RANGE(0x0400, 0x0fff) AM_ROM |
| 31 | 33 | ADDRESS_MAP_END |
| 32 | 34 | |
| 33 | | static ADDRESS_MAP_START( io_map, ADDRESS_SPACE_IO, 8 ) |
| 34 | | AM_RANGE(0x00, 0xff) AM_READWRITE(advision_extram_r, advision_extram_w) |
| 35 | | AM_RANGE(MCS48_PORT_P1, MCS48_PORT_P1) AM_READWRITE(advision_controller_r, advision_bankswitch_w) |
| 36 | | AM_RANGE(MCS48_PORT_P2, MCS48_PORT_P2) AM_WRITE(advision_av_control_w) |
| 37 | | AM_RANGE(MCS48_PORT_T1, MCS48_PORT_T1) AM_READ(advision_vsync_r) |
| 35 | static ADDRESS_MAP_START( io_map, ADDRESS_SPACE_IO, 8, advision_state ) |
| 36 | AM_RANGE(0x00, 0xff) AM_READWRITE(ext_ram_r, ext_ram_w) |
| 37 | AM_RANGE(MCS48_PORT_P1, MCS48_PORT_P1) AM_READWRITE(controller_r, bankswitch_w) |
| 38 | AM_RANGE(MCS48_PORT_P2, MCS48_PORT_P2) AM_WRITE(av_control_w) |
| 39 | AM_RANGE(MCS48_PORT_T1, MCS48_PORT_T1) AM_READ(vsync_r) |
| 38 | 40 | ADDRESS_MAP_END |
| 39 | 41 | |
| 40 | | static ADDRESS_MAP_START( sound_io_map, ADDRESS_SPACE_IO, 8 ) |
| 41 | | AM_RANGE(COP400_PORT_L, COP400_PORT_L) AM_READ(advision_sound_cmd_r) |
| 42 | | AM_RANGE(COP400_PORT_G, COP400_PORT_G) AM_WRITE(advision_sound_g_w) |
| 43 | | AM_RANGE(COP400_PORT_D, COP400_PORT_D) AM_WRITE(advision_sound_d_w) |
| 42 | static ADDRESS_MAP_START( sound_io_map, ADDRESS_SPACE_IO, 8, advision_state ) |
| 43 | AM_RANGE(COP400_PORT_L, COP400_PORT_L) AM_READ(sound_cmd_r) |
| 44 | AM_RANGE(COP400_PORT_G, COP400_PORT_G) AM_WRITE(sound_g_w) |
| 45 | AM_RANGE(COP400_PORT_D, COP400_PORT_D) AM_WRITE(sound_d_w) |
| 44 | 46 | AM_RANGE(COP400_PORT_SIO, COP400_PORT_SIO) AM_NOP |
| 45 | 47 | AM_RANGE(COP400_PORT_SK, COP400_PORT_SK) AM_NOP |
| 46 | 48 | ADDRESS_MAP_END |
| r9652 | r9653 | |
| 101 | 103 | }; |
| 102 | 104 | |
| 103 | 105 | static MACHINE_CONFIG_START( advision, advision_state ) |
| 104 | | |
| 105 | 106 | /* basic machine hardware */ |
| 106 | 107 | MDRV_CPU_ADD(I8048_TAG, I8048, XTAL_11MHz) |
| 107 | 108 | MDRV_CPU_PROGRAM_MAP(program_map) |
| r9652 | r9653 | |
| 111 | 112 | MDRV_CPU_CONFIG(advision_cop411_interface) |
| 112 | 113 | MDRV_CPU_IO_MAP(sound_io_map) |
| 113 | 114 | |
| 114 | | MDRV_MACHINE_START(advision) |
| 115 | | MDRV_MACHINE_RESET(advision) |
| 116 | | |
| 117 | 115 | /* video hardware */ |
| 118 | 116 | MDRV_SCREEN_ADD(SCREEN_TAG, RASTER) |
| 119 | 117 | MDRV_SCREEN_REFRESH_RATE(4*15) |
| r9652 | r9653 | |
| 124 | 122 | MDRV_PALETTE_LENGTH(8) |
| 125 | 123 | MDRV_PALETTE_INIT(advision) |
| 126 | 124 | |
| 127 | | MDRV_VIDEO_START(advision) |
| 128 | | MDRV_VIDEO_UPDATE(advision) |
| 129 | | |
| 130 | 125 | /* sound hardware */ |
| 131 | 126 | MDRV_SPEAKER_STANDARD_MONO("mono") |
| 132 | 127 | |
docs/messnew.txt
| r9652 | r9653 | |
| 25 | 25 | |
| 26 | 26 | System Driver Changes: |
| 27 | 27 | ---------------------- |
| 28 | | - [ABC80] Refactored driver to define ADDRESS_MAP_MODERN. [Curt Coder] |
| 29 | | |
| 30 | 28 | - [ABC80] Added graphics PROMs. [Ola Andersson] |
| 31 | 29 | |
| 32 | 30 | - [ABC80] Refactored video to work like real hardware. [Curt Coder] |
| 33 | 31 | |
| 34 | 32 | - [ABC800C] Added Color version ROMs. [Ola Andersson] |
| 35 | 33 | |
| 36 | | - [AMU880] Refactored driver to define ADDRESS_MAP_MODERN, and fixed |
| 37 | | keyboard. [Curt Coder] |
| 34 | - [AMU880] Fixed keyboard. [Curt Coder] |
| 38 | 35 | |
| 39 | 36 | - [C64] Added known good dumps softlist for cartridges. Not hooked up |
| 40 | 37 | to driver code yet. [Curt Coder] |
| 41 | 38 | |
| 42 | 39 | - [CHANNELF/LYNX/SPECIAL/SVISION/WSWAN] Tokenized audio state. [Atari Ace] |
| 43 | 40 | |
| 44 | | - [MM1M6] Refactored driver to define ADDRESS_MAP_MODERN. [Curt Coder] |
| 45 | | |
| 46 | | - [SG1000] Refactored driver to define ADDRESS_MAP_MODERN. [Curt Coder] |
| 47 | | |
| 48 | 41 | - [SMS] Improved Light Phaser emulation and converted it to use timers |
| 49 | 42 | that control when the beam will reach the aim area, to run the function |
| 50 | 43 | that checks if the pixel displayed is bright enough to activate the |
| r9652 | r9653 | |
| 58 | 51 | selecting the Segascope views from the Video Options menu). The option |
| 59 | 52 | is turned off by default, being inaccurate [Enik Land, Fabio Priuli] |
| 60 | 53 | |
| 61 | | - [TANDY2K] Refactored driver to define ADDRESS_MAP_MODERN. [Curt Coder] |
| 62 | 54 | |
| 63 | | - [V1050] Refactored driver to define ADDRESS_MAP_MODERN. [Curt Coder] |
| 64 | 55 | |
| 65 | | - [VICTOR9K] Refactored driver to define ADDRESS_MAP_MODERN. [Curt Coder] |
| 66 | | |
| 67 | | - [VIDBRAIN] Refactored driver to define ADDRESS_MAP_MODERN. [Curt Coder] |
| 68 | | |
| 69 | | - [XEROX820] Refactored driver to define ADDRESS_MAP_MODERN. [Curt Coder] |
| 70 | | |
| 71 | | - [XOR100] Refactored driver to define ADDRESS_MAP_MODERN. [Curt Coder] |
| 72 | | |
| 73 | | |
| 74 | | |
| 75 | 56 | Imgtool Changes: |
| 76 | 57 | ---------------- |
| 77 | 58 | (none) |
| r9652 | r9653 | |
| 98 | 79 | - Static/const changes, and added driver_device state to many drivers. |
| 99 | 80 | [Atari Ace] |
| 100 | 81 | |
| 82 | - Refactored the following drivers to define ADDRESS_MAP_MODERN: |
| 83 | abc80, advision, amu880, mm1m6, sg1000, tandy2k, v1050, victor9k, |
| 84 | vidbrain, xerox820, xor100. [Curt Coder] |
| 101 | 85 | |
| 102 | 86 | |
| 87 | |
| 103 | 88 | 0.140 |
| 104 | 89 | |
| 105 | 90 | New System Drivers Supported: |