trunk/src/mess/machine/galaxy.c
| r21158 | r21159 | |
| 46 | 46 | device.execute().set_input_line(0, HOLD_LINE); |
| 47 | 47 | } |
| 48 | 48 | |
| 49 | | static IRQ_CALLBACK ( galaxy_irq_callback ) |
| 49 | IRQ_CALLBACK_MEMBER(galaxy_state::galaxy_irq_callback) |
| 50 | 50 | { |
| 51 | | galaxy_state *state = device->machine().driver_data<galaxy_state>(); |
| 52 | | galaxy_set_timer(device->machine()); |
| 53 | | state->m_interrupts_enabled = TRUE; |
| 51 | galaxy_set_timer(); |
| 52 | m_interrupts_enabled = TRUE; |
| 54 | 53 | return 0xff; |
| 55 | 54 | } |
| 56 | 55 | |
| r21158 | r21159 | |
| 187 | 186 | if (ioport("ROM2")->read()) |
| 188 | 187 | membank("bank10")->set_base(memregion("maincpu")->base() + 0x1000); |
| 189 | 188 | |
| 190 | | m_maincpu->set_irq_acknowledge_callback(galaxy_irq_callback); |
| 189 | m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(galaxy_state::galaxy_irq_callback),this)); |
| 191 | 190 | m_interrupts_enabled = TRUE; |
| 192 | 191 | } |
| 193 | 192 | |
| r21158 | r21159 | |
| 201 | 200 | UINT8 *ROM = memregion("maincpu")->base(); |
| 202 | 201 | address_space &space = m_maincpu->space(AS_PROGRAM); |
| 203 | 202 | |
| 204 | | m_maincpu->set_irq_acknowledge_callback(galaxy_irq_callback); |
| 203 | m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(galaxy_state::galaxy_irq_callback),this)); |
| 205 | 204 | |
| 206 | 205 | ROM[0x0037] = 0x29; |
| 207 | 206 | ROM[0x03f9] = 0xcd; |
trunk/src/mess/machine/poly88.c
| r21158 | r21159 | |
| 130 | 130 | } |
| 131 | 131 | } |
| 132 | 132 | |
| 133 | | static IRQ_CALLBACK (poly88_irq_callback) |
| 133 | IRQ_CALLBACK_MEMBER(poly88_state::poly88_irq_callback) |
| 134 | 134 | { |
| 135 | | poly88_state *state = device->machine().driver_data<poly88_state>(); |
| 136 | | return state->m_int_vector; |
| 135 | return m_int_vector; |
| 137 | 136 | } |
| 138 | 137 | |
| 139 | 138 | TIMER_CALLBACK_MEMBER(poly88_state::poly88_cassette_timer_callback) |
| r21158 | r21159 | |
| 208 | 207 | |
| 209 | 208 | void poly88_state::machine_reset() |
| 210 | 209 | { |
| 211 | | m_maincpu->set_irq_acknowledge_callback(poly88_irq_callback); |
| 210 | m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(poly88_state::poly88_irq_callback),this)); |
| 212 | 211 | m_intr = 0; |
| 213 | 212 | m_last_code = 0; |
| 214 | 213 | |
trunk/src/mess/includes/galaxy.h
| r21158 | r21159 | |
| 41 | 41 | UINT32 screen_update_galaxy(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); |
| 42 | 42 | INTERRUPT_GEN_MEMBER(galaxy_interrupt); |
| 43 | 43 | TIMER_CALLBACK_MEMBER(gal_video); |
| 44 | | |
| 44 | IRQ_CALLBACK_MEMBER(galaxy_irq_callback); |
| 45 | void galaxy_set_timer(); |
| 45 | 46 | protected: |
| 46 | 47 | required_device<cpu_device> m_maincpu; |
| 47 | 48 | required_device<cassette_image_device> m_cassette; |
| r21158 | r21159 | |
| 54 | 55 | /*----------- defined in machine/galaxy.c -----------*/ |
| 55 | 56 | SNAPSHOT_LOAD( galaxy ); |
| 56 | 57 | |
| 57 | | /*----------- defined in video/galaxy.c -----------*/ |
| 58 | | void galaxy_set_timer(running_machine &machine); |
| 59 | | |
| 60 | 58 | #endif /* GALAXY_H_ */ |
trunk/src/mess/drivers/esq5505.c
| r21158 | r21159 | |
| 181 | 181 | DECLARE_DRIVER_INIT(sq1); |
| 182 | 182 | DECLARE_DRIVER_INIT(denib); |
| 183 | 183 | DECLARE_INPUT_CHANGED_MEMBER(key_stroke); |
| 184 | IRQ_CALLBACK_MEMBER(maincpu_irq_acknowledge_callback); |
| 184 | 185 | }; |
| 185 | 186 | |
| 186 | 187 | FLOPPY_FORMATS_MEMBER( esq5505_state::floppy_formats ) |
| r21158 | r21159 | |
| 191 | 192 | SLOT_INTERFACE( "35dd", FLOPPY_35_DD ) |
| 192 | 193 | SLOT_INTERFACE_END |
| 193 | 194 | |
| 194 | | static int maincpu_irq_acknowledge_callback(device_t *device, int irqnum) { |
| 195 | IRQ_CALLBACK_MEMBER(esq5505_state::maincpu_irq_acknowledge_callback) |
| 196 | { |
| 195 | 197 | // We immediately update the interrupt presented to the CPU, so that it doesn't |
| 196 | 198 | // end up retrying the same interrupt over and over. We then return the appropriate vector. |
| 197 | | esq5505_state *esq5505 = device->machine().driver_data<esq5505_state>(); |
| 198 | 199 | int vector = 0; |
| 199 | | switch(irqnum) { |
| 200 | switch(irqline) { |
| 200 | 201 | case 1: |
| 201 | | esq5505->otis_irq_state = 0; |
| 202 | otis_irq_state = 0; |
| 202 | 203 | vector = M68K_INT_ACK_AUTOVECTOR; |
| 203 | 204 | break; |
| 204 | 205 | case 2: |
| 205 | | esq5505->dmac_irq_state = 0; |
| 206 | | vector = esq5505->dmac_irq_vector; |
| 206 | dmac_irq_state = 0; |
| 207 | vector = dmac_irq_vector; |
| 207 | 208 | break; |
| 208 | 209 | case 3: |
| 209 | | esq5505->duart_irq_state = 0; |
| 210 | | vector = esq5505->duart_irq_vector; |
| 210 | duart_irq_state = 0; |
| 211 | vector = duart_irq_vector; |
| 211 | 212 | break; |
| 212 | 213 | default: |
| 213 | | printf("\nUnexpected IRQ ACK Callback: IRQ %d\n", irqnum); |
| 214 | printf("\nUnexpected IRQ ACK Callback: IRQ %d\n", irqline); |
| 214 | 215 | return 0; |
| 215 | 216 | } |
| 216 | | esq5505->update_irq_to_maincpu(); |
| 217 | update_irq_to_maincpu(); |
| 217 | 218 | return vector; |
| 218 | 219 | } |
| 219 | 220 | |
| r21158 | r21159 | |
| 221 | 222 | { |
| 222 | 223 | m_rom = (UINT16 *)(void *)machine().root_device().memregion("osrom")->base(); |
| 223 | 224 | m_ram = (UINT16 *)(void *)machine().root_device().memshare("osram")->ptr(); |
| 224 | | m_maincpu->set_irq_acknowledge_callback(maincpu_irq_acknowledge_callback); |
| 225 | m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(esq5505_state::maincpu_irq_acknowledge_callback),this)); |
| 225 | 226 | } |
| 226 | 227 | |
| 227 | 228 | void esq5505_state::update_irq_to_maincpu() { |
trunk/src/mess/drivers/fk1.c
| r21158 | r21159 | |
| 54 | 54 | UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); |
| 55 | 55 | TIMER_DEVICE_CALLBACK_MEMBER(keyboard_callback); |
| 56 | 56 | TIMER_DEVICE_CALLBACK_MEMBER(vsync_callback); |
| 57 | IRQ_CALLBACK_MEMBER(fk1_irq_callback); |
| 57 | 58 | }; |
| 58 | 59 | |
| 59 | 60 | |
| r21158 | r21159 | |
| 404 | 405 | 0 ? PRINTER |
| 405 | 406 | */ |
| 406 | 407 | |
| 407 | | static IRQ_CALLBACK (fk1_irq_callback) |
| 408 | IRQ_CALLBACK_MEMBER(fk1_state::fk1_irq_callback) |
| 408 | 409 | { |
| 409 | | fk1_state *state = device->machine().driver_data<fk1_state>(); |
| 410 | | |
| 411 | | logerror("IRQ %02x\n", state->m_int_vector*2); |
| 412 | | return state->m_int_vector * 2; |
| 410 | logerror("IRQ %02x\n", m_int_vector*2); |
| 411 | return m_int_vector * 2; |
| 413 | 412 | } |
| 414 | 413 | |
| 415 | 414 | TIMER_DEVICE_CALLBACK_MEMBER(fk1_state::vsync_callback) |
| r21158 | r21159 | |
| 430 | 429 | membank("bank3")->set_base(ram + 0x8000); |
| 431 | 430 | membank("bank4")->set_base(ram + 0xc000); |
| 432 | 431 | |
| 433 | | machine().device("maincpu")->execute().set_irq_acknowledge_callback(fk1_irq_callback); |
| 432 | machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(fk1_state::fk1_irq_callback),this)); |
| 434 | 433 | } |
| 435 | 434 | |
| 436 | 435 | UINT32 fk1_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) |
trunk/src/mess/drivers/pc6001.c
| r21158 | r21159 | |
| 266 | 266 | DECLARE_WRITE8_MEMBER(pc6001_8255_portc_w); |
| 267 | 267 | DECLARE_READ8_MEMBER(pc6001_8255_portc_r); |
| 268 | 268 | DECLARE_DEVICE_IMAGE_LOAD_MEMBER(pc6001_cass); |
| 269 | | |
| 269 | IRQ_CALLBACK_MEMBER(pc6001_irq_callback); |
| 270 | 270 | protected: |
| 271 | 271 | required_device<cpu_device> m_maincpu; |
| 272 | 272 | required_device<device_t> m_cassette; |
| r21158 | r21159 | |
| 1906 | 1906 | device.execute().set_input_line(0, ASSERT_LINE); |
| 1907 | 1907 | } |
| 1908 | 1908 | |
| 1909 | | static IRQ_CALLBACK ( pc6001_irq_callback ) |
| 1909 | IRQ_CALLBACK_MEMBER(pc6001_state::pc6001_irq_callback) |
| 1910 | 1910 | { |
| 1911 | | pc6001_state *state = device->machine().driver_data<pc6001_state>(); |
| 1912 | | device->execute().set_input_line(0, CLEAR_LINE); |
| 1913 | | return state->m_irq_vector; |
| 1911 | device.execute().set_input_line(0, CLEAR_LINE); |
| 1912 | return m_irq_vector; |
| 1914 | 1913 | } |
| 1915 | 1914 | |
| 1916 | 1915 | READ8_MEMBER(pc6001_state::pc6001_8255_porta_r) |
| r21158 | r21159 | |
| 2156 | 2155 | |
| 2157 | 2156 | m_port_c_8255=0; |
| 2158 | 2157 | |
| 2159 | | m_maincpu->set_irq_acknowledge_callback(pc6001_irq_callback); |
| 2158 | m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(pc6001_state::pc6001_irq_callback),this)); |
| 2160 | 2159 | m_cas_switch = 0; |
| 2161 | 2160 | m_cas_offset = 0; |
| 2162 | 2161 | m_timer_irq_mask = 1; |
| r21158 | r21159 | |
| 2173 | 2172 | |
| 2174 | 2173 | m_port_c_8255=0; |
| 2175 | 2174 | |
| 2176 | | m_maincpu->set_irq_acknowledge_callback(pc6001_irq_callback); |
| 2175 | m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(pc6001_state::pc6001_irq_callback),this)); |
| 2177 | 2176 | m_cas_switch = 0; |
| 2178 | 2177 | m_cas_offset = 0; |
| 2179 | 2178 | |
| r21158 | r21159 | |
| 2208 | 2207 | |
| 2209 | 2208 | m_port_c_8255=0; |
| 2210 | 2209 | |
| 2211 | | m_maincpu->set_irq_acknowledge_callback(pc6001_irq_callback); |
| 2210 | m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(pc6001_state::pc6001_irq_callback),this)); |
| 2212 | 2211 | m_cas_switch = 0; |
| 2213 | 2212 | m_cas_offset = 0; |
| 2214 | 2213 | |
trunk/src/mess/drivers/mod8.c
| r21158 | r21159 | |
| 36 | 36 | UINT8 m_tty_key_data; |
| 37 | 37 | int m_tty_cnt; |
| 38 | 38 | virtual void machine_reset(); |
| 39 | IRQ_CALLBACK_MEMBER(mod8_irq_callback); |
| 39 | 40 | }; |
| 40 | 41 | |
| 41 | 42 | WRITE8_MEMBER( mod8_state::out_w ) |
| r21158 | r21159 | |
| 82 | 83 | static INPUT_PORTS_START( mod8 ) |
| 83 | 84 | INPUT_PORTS_END |
| 84 | 85 | |
| 85 | | static IRQ_CALLBACK ( mod8_irq_callback ) |
| 86 | IRQ_CALLBACK_MEMBER(mod8_state::mod8_irq_callback) |
| 86 | 87 | { |
| 87 | 88 | return 0xC0; // LAA - NOP equivalent |
| 88 | 89 | } |
| 89 | 90 | |
| 90 | 91 | void mod8_state::machine_reset() |
| 91 | 92 | { |
| 92 | | machine().device("maincpu")->execute().set_irq_acknowledge_callback(mod8_irq_callback); |
| 93 | machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(mod8_state::mod8_irq_callback),this)); |
| 93 | 94 | } |
| 94 | 95 | |
| 95 | 96 | WRITE8_MEMBER( mod8_state::kbd_put ) |