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 ) |