Previous 199869 Revisions Next

r20632 Thursday 31st January, 2013 at 13:58:02 UTC by Miodrag Milanović
IRQ_CALLBACK modernization part 3 (no whatsnew)
[src/mame/drivers]bnstars.c calchase.c chihiro.c crystal.c funkball.c galgame.c gamecstl.c gammagic.c jaguar.c mediagx.c midqslvr.c model1.c photon.c photoply.c queen.c rastersp.c savquest.c su2000.c taito_l.c taitowlf.c voyager.c xtom3d.c
[src/mame/includes]jaguar.h megadriv.h model1.h taito_l.h
[src/mame/machine]megadriv.c
[src/mess/drivers]abc1600.c apricot.c apricotp.c atarist.c cbm2.c m20.c multi16.c paso1600.c pc1512.c pc8801.c portfoli.c trs80m2.c v1050.c victor9k.c vidbrain.c vixen.c wangpc.c x1.c z100.c
[src/mess/includes]abc1600.h amstrad.h apricotp.h atarist.h bk.h cbm2.h compis.h mc80.h pc1512.h portfoli.h rmnimbus.h trs80m2.h v1050.h victor9k.h vidbrain.h vixen.h wangpc.h
[src/mess/machine]amstrad.c bk.c compis.c mc80.c rmnimbus.c tf20.c tf20.h

trunk/src/mame/drivers/chihiro.c
r20631r20632
418418   DECLARE_READ8_MEMBER(get_slave_ack);
419419   DECLARE_WRITE_LINE_MEMBER(chihiro_pit8254_out0_changed);
420420   DECLARE_WRITE_LINE_MEMBER(chihiro_pit8254_out2_changed);
421   IRQ_CALLBACK_MEMBER(irq_callback);
421422};
422423
423424/*
r20631r20632
15751576   DEVCB_NULL
15761577};
15771578
1578static IRQ_CALLBACK(irq_callback)
1579IRQ_CALLBACK_MEMBER(chihiro_state::irq_callback)
15791580{
1580   chihiro_state *chst=device->machine().driver_data<chihiro_state>();
15811581   int r = 0;
1582   r = pic8259_acknowledge(chst->chihiro_devs.pic8259_2);
1582   r = pic8259_acknowledge(chihiro_devs.pic8259_2);
15831583   if (r==0)
15841584   {
1585      r = pic8259_acknowledge(chst->chihiro_devs.pic8259_1);
1585      r = pic8259_acknowledge(chihiro_devs.pic8259_1);
15861586   }
15871587   return r;
15881588}
r20631r20632
18051805   smbus_register_device(0x10,smbus_callback_pic16lc);
18061806   smbus_register_device(0x45,smbus_callback_cx25871);
18071807   smbus_register_device(0x54,smbus_callback_eeprom);
1808   machine().device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
1808   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(chihiro_state::irq_callback),this));
18091809   chihiro_devs.pic8259_1 = machine().device( "pic8259_1" );
18101810   chihiro_devs.pic8259_2 = machine().device( "pic8259_2" );
18111811   chihiro_devs.ide = machine().device( "ide" );
trunk/src/mame/drivers/bnstars.c
r20631r20632
163163   void draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect, UINT32 *sprram_top, size_t sprram_size, int region);
164164   void irq_init();
165165   void irq_raise(int level);
166   IRQ_CALLBACK_MEMBER(irq_callback);
166167};
167168
168169
r20631r20632
13251326#endif
13261327
13271328
1328static IRQ_CALLBACK(irq_callback)
1329IRQ_CALLBACK_MEMBER(bnstars_state::irq_callback)
13291330{
1330   bnstars_state *state = device->machine().driver_data<bnstars_state>();
13311331   int i;
1332   for(i=15; i>=0 && !(state->m_irqreq & (1<<i)); i--);
1333   state->m_irqreq &= ~(1<<i);
1334   if(!state->m_irqreq)
1335      device->execute().set_input_line(0, CLEAR_LINE);
1332   for(i=15; i>=0 && !(m_irqreq & (1<<i)); i--);
1333   m_irqreq &= ~(1<<i);
1334   if(!m_irqreq)
1335      device.execute().set_input_line(0, CLEAR_LINE);
13361336   return i;
13371337}
13381338
r20631r20632
13401340{
13411341   m_irqreq = 0;
13421342   machine().device("maincpu")->execute().set_input_line(0, CLEAR_LINE);
1343   machine().device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
1343   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(bnstars_state::irq_callback),this));
13441344}
13451345
13461346void bnstars_state::irq_raise(int level)
trunk/src/mame/drivers/savquest.c
r20631r20632
102102   DECLARE_WRITE_LINE_MEMBER(savquest_pic8259_1_set_int_line);
103103   virtual void machine_start();
104104   virtual void machine_reset();
105   IRQ_CALLBACK_MEMBER(irq_callback);
105106};
106107
107108// Intel 82439TX System Controller (MXTC)
r20631r20632
606607   pic8259_ir1_w(drvstate->m_pic8259_1, state);
607608}
608609
609static IRQ_CALLBACK(irq_callback)
610IRQ_CALLBACK_MEMBER(savquest_state::irq_callback)
610611{
611   savquest_state *state = device->machine().driver_data<savquest_state>();
612   return pic8259_acknowledge( state->m_pic8259_1);
612   return pic8259_acknowledge(m_pic8259_1);
613613}
614614
615615void savquest_state::machine_start()
r20631r20632
622622
623623   init_pc_common(machine(), PCCOMMON_KEYBOARD_AT, savquest_set_keyb_int);
624624
625   m_maincpu->set_irq_acknowledge_callback(irq_callback);
625   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(savquest_state::irq_callback),this));
626626   intel82439tx_init(machine());
627627
628628   kbdc8042_init(machine(), &at8042);
trunk/src/mame/drivers/photoply.c
r20631r20632
5757   DECLARE_WRITE_LINE_MEMBER(at_pit8254_out2_changed);
5858   DECLARE_DRIVER_INIT(photoply);
5959   virtual void machine_start();
60   IRQ_CALLBACK_MEMBER(irq_callback);
6061};
6162
6263
r20631r20632
226227   DEVCB_NULL
227228};
228229
229static IRQ_CALLBACK(irq_callback)
230IRQ_CALLBACK_MEMBER(photoply_state::irq_callback)
230231{
231   photoply_state *state = device->machine().driver_data<photoply_state>();
232   return pic8259_acknowledge(state->m_pic8259_1);
232   return pic8259_acknowledge(m_pic8259_1);
233233}
234234
235235WRITE_LINE_MEMBER(photoply_state::at_pit8254_out0_changed)
r20631r20632
342342
343343void photoply_state::machine_start()
344344{
345   machine().device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
345   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(photoply_state::irq_callback),this));
346346   m_pit8253 = machine().device( "pit8254" );
347347   m_pic8259_1 = machine().device( "pic8259_1" );
348348   m_pic8259_2 = machine().device( "pic8259_2" );
trunk/src/mame/drivers/taito_l.c
r20631r20632
290290}
291291
292292
293static IRQ_CALLBACK( irq_callback )
293IRQ_CALLBACK_MEMBER(taitol_state::irq_callback)
294294{
295   taitol_state *state = device->machine().driver_data<taitol_state>();
296   return state->m_irq_adr_table[state->m_last_irq_level];
295   return m_irq_adr_table[m_last_irq_level];
297296}
298297
299298TIMER_DEVICE_CALLBACK_MEMBER(taitol_state::vbl_interrupt)
300299{
301300   int scanline = param;
302   m_maincpu->set_irq_acknowledge_callback(irq_callback);
301   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(taitol_state::irq_callback),this));
303302
304303   /* kludge to make plgirls boot */
305304   if (m_maincpu->state_int(Z80_IM) != 2)
trunk/src/mame/drivers/midqslvr.c
r20631r20632
9898   DECLARE_WRITE_LINE_MEMBER(midqslvr_pic8259_1_set_int_line);
9999   virtual void machine_start();
100100   virtual void machine_reset();
101   IRQ_CALLBACK_MEMBER(irq_callback);
101102};
102103
103104
r20631r20632
643644   pic8259_ir1_w(drvstate->m_pic8259_1, state);
644645}
645646
646static IRQ_CALLBACK(irq_callback)
647IRQ_CALLBACK_MEMBER(midqslvr_state::irq_callback)
647648{
648   midqslvr_state *state = device->machine().driver_data<midqslvr_state>();
649   return pic8259_acknowledge( state->m_pic8259_1);
649   return pic8259_acknowledge(m_pic8259_1);
650650}
651651
652652void midqslvr_state::machine_start()
r20631r20632
661661
662662   init_pc_common(machine(), PCCOMMON_KEYBOARD_AT, midqslvr_set_keyb_int);
663663
664   m_maincpu->set_irq_acknowledge_callback(irq_callback);
664   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(midqslvr_state::irq_callback),this));
665665   intel82439tx_init(machine());
666666
667667   kbdc8042_init(machine(), &at8042);
trunk/src/mame/drivers/calchase.c
r20631r20632
181181   DECLARE_DRIVER_INIT(calchase);
182182   virtual void machine_start();
183183   virtual void machine_reset();
184   IRQ_CALLBACK_MEMBER(irq_callback);
184185};
185186
186187
r20631r20632
803804INPUT_PORTS_END
804805#endif
805806
806static IRQ_CALLBACK(irq_callback)
807IRQ_CALLBACK_MEMBER(calchase_state::irq_callback)
807808{
808   calchase_state *state = device->machine().driver_data<calchase_state>();
809   return pic8259_acknowledge( state->m_pic8259_1);
809   return pic8259_acknowledge(m_pic8259_1);
810810}
811811
812812void calchase_state::machine_start()
r20631r20632
814814   m_bios_ram = auto_alloc_array(machine(), UINT32, 0x10000/4);
815815   m_bios_ext_ram = auto_alloc_array(machine(), UINT32, 0x10000/4);
816816
817   machine().device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
817   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(calchase_state::irq_callback),this));
818818
819819   m_pit8254 = machine().device( "pit8254" );
820820   m_pic8259_1 = machine().device( "pic8259_1" );
trunk/src/mame/drivers/crystal.c
r20631r20632
194194   void screen_eof_crystal(screen_device &screen, bool state);
195195   INTERRUPT_GEN_MEMBER(crystal_interrupt);
196196   TIMER_CALLBACK_MEMBER(Timercb);
197   IRQ_CALLBACK_MEMBER(icallback);
197198};
198199
199200static void IntReq( running_machine &machine, int num )
r20631r20632
271272      m_IntHigh = (data >> 8) & 7;
272273}
273274
274static IRQ_CALLBACK( icallback )
275IRQ_CALLBACK_MEMBER(crystal_state::icallback)
275276{
276   crystal_state *state = device->machine().driver_data<crystal_state>();
277   address_space &space = device->memory().space(AS_PROGRAM);
277   address_space &space = device.memory().space(AS_PROGRAM);
278278   UINT32 IntPend = space.read_dword(0x01800c0c);
279279   int i;
280280
r20631r20632
282282   {
283283      if (BIT(IntPend, i))
284284      {
285         return (state->m_IntHigh << 5) | i;
285         return (m_IntHigh << 5) | i;
286286      }
287287   }
288288   return 0;       //This should never happen
r20631r20632
582582   m_ds1302 = machine().device<ds1302_device>("rtc");
583583   m_vr0video = machine().device("vr0");
584584
585   machine().device("maincpu")->execute().set_irq_acknowledge_callback(icallback);
585   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(crystal_state::icallback),this));
586586   for (i = 0; i < 4; i++)
587587      m_Timer[i] = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(crystal_state::Timercb),this), (void*)(FPTR)i);
588588
r20631r20632
611611   memset(m_vidregs, 0, 0x10000);
612612   m_FlipCount = 0;
613613   m_IntHigh = 0;
614   machine().device("maincpu")->execute().set_irq_acknowledge_callback(icallback);
614   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(crystal_state::icallback),this));
615615   m_Bank = 0;
616616   membank("bank1")->set_base(memregion("user1")->base() + 0);
617617   m_FlashCmd = 0xff;
trunk/src/mame/drivers/galgame.c
r20631r20632
4949   virtual void palette_init();
5050   UINT32 screen_update_galaxygame(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
5151   INTERRUPT_GEN_MEMBER(galaxygame_irq);
52   IRQ_CALLBACK_MEMBER(galaxygame_irq_callback);
5253};
5354
5455/*************************************
r20631r20632
294295   palette_set_color(machine(),1,RGB_WHITE); /* white */
295296}
296297
297static IRQ_CALLBACK(galaxygame_irq_callback)
298IRQ_CALLBACK_MEMBER(galaxygame_state::galaxygame_irq_callback)
298299{
299   device->execute().set_input_line(0, CLEAR_LINE);
300   device.execute().set_input_line(0, CLEAR_LINE);
300301   return 0x40;
301302}
302303
r20631r20632
316317   m_point_display_list_index = 0;
317318   m_interrupt = 0;
318319
319   machine().device("maincpu")->execute().set_irq_acknowledge_callback(galaxygame_irq_callback);
320   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(galaxygame_state::galaxygame_irq_callback),this));
320321}
321322
322323static const struct t11_setup t11_data =
trunk/src/mame/drivers/rastersp.c
r20631r20632
4141 *
4242 *************************************/
4343
44static IRQ_CALLBACK( irq_callback );
45
4644class rastersp_state : public driver_device
4745{
4846public:
r20631r20632
133131   UINT32  screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
134132   void    update_irq(UINT32 which, UINT32 state);
135133   void    upload_palette(UINT32 word1, UINT32 word2);
136
134   IRQ_CALLBACK_MEMBER(irq_callback);
137135protected:
138136   // driver_device overrides
139137   virtual void machine_reset();
r20631r20632
151149
152150void rastersp_state::machine_start()
153151{
154   machine().device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
152   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(rastersp_state::irq_callback),this));
155153
156154   m_nvram8 = auto_alloc_array(machine(), UINT8, NVRAM_SIZE);
157155
r20631r20632
358356 *
359357 *************************************/
360358
361static IRQ_CALLBACK( irq_callback )
359IRQ_CALLBACK_MEMBER(rastersp_state::irq_callback)
362360{
363   rastersp_state *state = device->machine().driver_data<rastersp_state>();
364
365361   UINT8 vector = 0;
366362
367   if (state->m_irq_status & (1 << rastersp_state::IRQ_SCSI))
363   if (m_irq_status & (1 << IRQ_SCSI))
368364   {
369365      vector = 11;
370366   }
371   else if (state->m_irq_status & (1 << rastersp_state::IRQ_DSP))
367   else if (m_irq_status & (1 << IRQ_DSP))
372368   {
373      state->update_irq(rastersp_state::IRQ_DSP, CLEAR_LINE);
369      update_irq(IRQ_DSP, CLEAR_LINE);
374370      vector = 12;
375371   }
376   else if (state->m_irq_status & (1 << rastersp_state::IRQ_VBLANK))
372   else if (m_irq_status & (1 << IRQ_VBLANK))
377373   {
378      state->update_irq(rastersp_state::IRQ_VBLANK, CLEAR_LINE);
374      update_irq(IRQ_VBLANK, CLEAR_LINE);
379375      vector = 13;
380376   }
381377   else
382378   {
383      fatalerror("Unknown x86 IRQ (m_irq_status = %x)", state->m_irq_status);
379      fatalerror("Unknown x86 IRQ (m_irq_status = %x)", m_irq_status);
384380   }
385381
386382   return vector;
trunk/src/mame/drivers/photon.c
r20631r20632
3838   virtual void video_start();
3939   UINT32 screen_update_photon(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
4040   INTERRUPT_GEN_MEMBER(pk8000_interrupt);
41   IRQ_CALLBACK_MEMBER(pk8000_irq_callback);
4142};
4243
4344
r20631r20632
191192   device.execute().set_input_line(0, HOLD_LINE);
192193}
193194
194static IRQ_CALLBACK(pk8000_irq_callback)
195IRQ_CALLBACK_MEMBER(photon_state::pk8000_irq_callback)
195196{
196197   return 0xff;
197198}
r20631r20632
200201void photon_state::machine_reset()
201202{
202203   pk8000_set_bank(machine(),0);
203   machine().device("maincpu")->execute().set_irq_acknowledge_callback(pk8000_irq_callback);
204   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(photon_state::pk8000_irq_callback),this));
204205}
205206
206207void photon_state::video_start()
trunk/src/mame/drivers/su2000.c
r20631r20632
8181   DECLARE_READ8_MEMBER(get_slave_ack);
8282   virtual void machine_start();
8383   virtual void machine_reset();
84   IRQ_CALLBACK_MEMBER(irq_callback);
8485};
8586
8687
r20631r20632
236237 *
237238 *************************************/
238239
239static IRQ_CALLBACK( pc_irq_callback )
240IRQ_CALLBACK_MEMBER(su2000_state::irq_callback)
240241{
241   su2000_state *state = device->machine().driver_data<su2000_state>();
242   return pic8259_acknowledge(state->m_pic8259_1);
242   return pic8259_acknowledge(m_pic8259_1);
243243}
244244
245245
r20631r20632
271271   space.install_write_bank(0x100000, ram_limit - 1, "hma_bank");
272272   membank("hma_bank")->set_base(m_pc_ram + 0xa0000);
273273
274   machine().device("maincpu")->execute().set_irq_acknowledge_callback(pc_irq_callback);
274   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(su2000_state::irq_callback),this));
275275
276276   init_pc_common(machine(), PCCOMMON_KEYBOARD_AT, su2000_set_keyb_int);
277277
trunk/src/mame/drivers/taitowlf.c
r20631r20632
8383   virtual void machine_reset();
8484   virtual void palette_init();
8585   UINT32 screen_update_taitowlf(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
86   IRQ_CALLBACK_MEMBER(irq_callback);
8687};
8788
8889#if !ENABLE_VGA
r20631r20632
532533INPUT_PORTS_END
533534#endif
534535
535static IRQ_CALLBACK(irq_callback)
536IRQ_CALLBACK_MEMBER(taitowlf_state::irq_callback)
536537{
537   taitowlf_state *state = device->machine().driver_data<taitowlf_state>();
538   return pic8259_acknowledge( state->m_pic8259_1);
538   return pic8259_acknowledge(m_pic8259_1);
539539}
540540
541541void taitowlf_state::machine_start()
542542{
543   machine().device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
543   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(taitowlf_state::irq_callback),this));
544544
545545   m_pit8254 = machine().device( "pit8254" );
546546   m_pic8259_1 = machine().device( "pic8259_1" );
trunk/src/mame/drivers/funkball.c
r20631r20632
165165   virtual void machine_start();
166166   virtual void machine_reset();
167167   UINT32 screen_update_funkball(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
168   IRQ_CALLBACK_MEMBER(irq_callback);
168169};
169170
170171void funkball_state::video_start()
r20631r20632
10901091   pic8259_ir1_w(drvstate->m_pic8259_1, state);
10911092}
10921093
1093static IRQ_CALLBACK(irq_callback)
1094IRQ_CALLBACK_MEMBER(funkball_state::irq_callback)
10941095{
1095   funkball_state *state = device->machine().driver_data<funkball_state>();
1096   return pic8259_acknowledge( state->m_pic8259_1);
1096   return pic8259_acknowledge(m_pic8259_1);
10971097}
10981098
10991099void funkball_state::machine_start()
r20631r20632
11021102
11031103   init_pc_common(machine(), PCCOMMON_KEYBOARD_AT, funkball_set_keyb_int);
11041104
1105   m_maincpu->set_irq_acknowledge_callback(irq_callback);
1105   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(funkball_state::irq_callback),this));
11061106
11071107   kbdc8042_init(machine(), &at8042);
11081108
trunk/src/mame/drivers/jaguar.c
r20631r20632
359359 *
360360 *************************************/
361361
362static IRQ_CALLBACK(jaguar_irq_callback)
362IRQ_CALLBACK_MEMBER(jaguar_state::jaguar_irq_callback)
363363{
364364   return (irqline == 6) ? 0x40 : -1;
365365}
r20631r20632
375375void jaguar_state::machine_reset()
376376{
377377   if (!m_is_cojag)
378      m_main_cpu->set_irq_acknowledge_callback(jaguar_irq_callback);
378      m_main_cpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(jaguar_state::jaguar_irq_callback),this));
379379
380380   m_protection_check = 0;
381381
trunk/src/mame/drivers/gamecstl.c
r20631r20632
120120   virtual void machine_reset();
121121   virtual void video_start();
122122   UINT32 screen_update_gamecstl(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
123   IRQ_CALLBACK_MEMBER(irq_callback);
123124};
124125
125126
r20631r20632
602603   PORT_START("pc_keyboard_7")
603604INPUT_PORTS_END
604605
605static IRQ_CALLBACK(irq_callback)
606IRQ_CALLBACK_MEMBER(gamecstl_state::irq_callback)
606607{
607   gamecstl_state *state = device->machine().driver_data<gamecstl_state>();
608   return pic8259_acknowledge(state->m_pic8259_1);
608   return pic8259_acknowledge(m_pic8259_1);
609609}
610610
611611void gamecstl_state::machine_start()
r20631r20632
621621{
622622   machine().root_device().membank("bank1")->set_base(machine().root_device().memregion("bios")->base() + 0x30000);
623623
624   machine().device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
624   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(gamecstl_state::irq_callback),this));
625625}
626626
627627
trunk/src/mame/drivers/gammagic.c
r20631r20632
103103   UINT8 m_atapi_data[ATAPI_DATA_SIZE];
104104
105105   DECLARE_DRIVER_INIT(gammagic);
106   IRQ_CALLBACK_MEMBER(irq_callback);
106107};
107108
108109//static void atapi_irq(running_machine &machine, int state);
r20631r20632
622623INPUT_PORTS_END
623624#endif
624625
625static IRQ_CALLBACK(irq_callback)
626IRQ_CALLBACK_MEMBER(gammagic_state::irq_callback)
626627{
627   gammagic_state *state = device->machine().driver_data<gammagic_state>();
628   return pic8259_acknowledge( state->m_pic8259_1);
628   return pic8259_acknowledge(m_pic8259_1);
629629}
630630
631631static MACHINE_START(gammagic)
632632{
633633   gammagic_state *state = machine.driver_data<gammagic_state>();
634   machine.device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
634   machine.device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(gammagic_state::irq_callback),state));
635635
636636   state->m_pit8254 = machine.device( "pit8254" );
637637   state->m_pic8259_1 = machine.device( "pic8259_1" );
trunk/src/mame/drivers/queen.c
r20631r20632
9090   DECLARE_WRITE_LINE_MEMBER(queen_pic8259_1_set_int_line);
9191   virtual void machine_start();
9292   virtual void machine_reset();
93   IRQ_CALLBACK_MEMBER(irq_callback);
9394};
9495
9596
r20631r20632
507508   pic8259_ir1_w(drvstate->m_pic8259_1, state);
508509}
509510
510static IRQ_CALLBACK(irq_callback)
511IRQ_CALLBACK_MEMBER(queen_state::irq_callback)
511512{
512   queen_state *state = device->machine().driver_data<queen_state>();
513   return pic8259_acknowledge( state->m_pic8259_1);
513   return pic8259_acknowledge(m_pic8259_1);
514514}
515515
516516void queen_state::machine_start()
r20631r20632
520520
521521   init_pc_common(machine(), PCCOMMON_KEYBOARD_AT, queen_set_keyb_int);
522522
523   m_maincpu->set_irq_acknowledge_callback(irq_callback);
523   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(queen_state::irq_callback),this));
524524   intel82439tx_init(machine());
525525
526526   kbdc8042_init(machine(), &at8042);
trunk/src/mame/drivers/mediagx.c
r20631r20632
199199   DECLARE_READ32_MEMBER(speedup10_r);
200200   DECLARE_READ32_MEMBER(speedup11_r);
201201   TIMER_DEVICE_CALLBACK_MEMBER(sound_timer_callback);
202   IRQ_CALLBACK_MEMBER(irq_callback);
202203};
203204
204205// Display controller registers
r20631r20632
10471048   PORT_BIT( 0xf00, IP_ACTIVE_HIGH, IPT_JOYSTICK_LEFT ) PORT_PLAYER(3)
10481049INPUT_PORTS_END
10491050
1050static IRQ_CALLBACK(irq_callback)
1051IRQ_CALLBACK_MEMBER(mediagx_state::irq_callback)
10511052{
1052   mediagx_state *state = device->machine().driver_data<mediagx_state>();
1053   return pic8259_acknowledge( state->m_pic8259_1);
1053   return pic8259_acknowledge(m_pic8259_1);
10541054}
10551055
10561056void mediagx_state::machine_start()
r20631r20632
10691069{
10701070   UINT8 *rom = memregion("bios")->base();
10711071
1072   machine().device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
1072   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(mediagx_state::irq_callback),this));
10731073
10741074   memcpy(m_bios_ram, rom, 0x40000);
10751075   machine().device("maincpu")->reset();
trunk/src/mame/drivers/xtom3d.c
r20631r20632
115115   DECLARE_WRITE_LINE_MEMBER(xtom3d_pic8259_1_set_int_line);
116116   virtual void machine_start();
117117   virtual void machine_reset();
118   IRQ_CALLBACK_MEMBER(irq_callback);
118119};
119120
120121// Intel 82439TX System Controller (MXTC)
r20631r20632
635636   pic8259_ir1_w(drvstate->m_pic8259_1, state);
636637}
637638
638static IRQ_CALLBACK(irq_callback)
639IRQ_CALLBACK_MEMBER(xtom3d_state::irq_callback)
639640{
640   xtom3d_state *state = device->machine().driver_data<xtom3d_state>();
641   return pic8259_acknowledge( state->m_pic8259_1);
641   return pic8259_acknowledge(m_pic8259_1);
642642}
643643
644644void xtom3d_state::machine_start()
r20631r20632
653653
654654   init_pc_common(machine(), PCCOMMON_KEYBOARD_AT, xtom3d_set_keyb_int);
655655
656   m_maincpu->set_irq_acknowledge_callback(irq_callback);
656   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(xtom3d_state::irq_callback),this));
657657   intel82439tx_init(machine());
658658
659659   kbdc8042_init(machine(), &at8042);
trunk/src/mame/drivers/model1.c
r20631r20632
699699
700700
701701
702static void irq_raise(running_machine &machine, int level)
702void model1_state::irq_raise(int level)
703703{
704   model1_state *state = machine.driver_data<model1_state>();
705704   //  logerror("irq: raising %d\n", level);
706705   //  irq_status |= (1 << level);
707   state->m_last_irq = level;
708   machine.device("maincpu")->execute().set_input_line(0, HOLD_LINE);
706   m_last_irq = level;
707   machine().device("maincpu")->execute().set_input_line(0, HOLD_LINE);
709708}
710709
711static IRQ_CALLBACK(irq_callback)
710IRQ_CALLBACK_MEMBER(model1_state::irq_callback)
712711{
713   model1_state *state = device->machine().driver_data<model1_state>();
714   return state->m_last_irq;
712   return m_last_irq;
715713}
716714// vf
717715// 1 = fe3ed4
r20631r20632
727725// 3 = ff54c
728726// other = ff568/ff574
729727
730static void irq_init(running_machine &machine)
728void model1_state::irq_init()
731729{
732   machine.device("maincpu")->execute().set_input_line(0, CLEAR_LINE);
733   machine.device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
730   machine().device("maincpu")->execute().set_input_line(0, CLEAR_LINE);
731   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(model1_state::irq_callback),this));
734732}
735733
736734TIMER_DEVICE_CALLBACK_MEMBER(model1_state::model1_interrupt)
r20631r20632
739737
740738   if (scanline == 384)
741739   {
742      irq_raise(machine(), 1);
740      irq_raise(1);
743741   }
744742   else if(scanline == 384/2)
745743   {
746      irq_raise(machine(), m_sound_irq);
744      irq_raise(m_sound_irq);
747745
748746      // if the FIFO has something in it, signal the 68k too
749747      if (m_fifo_rptr != m_fifo_wptr)
r20631r20632
756754MACHINE_RESET_MEMBER(model1_state,model1)
757755{
758756   membank("bank1")->set_base(memregion("maincpu")->base() + 0x1000000);
759   irq_init(machine());
757   irq_init();
760758   model1_tgp_reset(machine(), !strcmp(machine().system().name, "swa") || !strcmp(machine().system().name, "wingwar") || !strcmp(machine().system().name, "wingwaru") || !strcmp(machine().system().name, "wingwarj"));
761759   if (!strcmp(machine().system().name, "swa"))
762760   {
r20631r20632
775773MACHINE_RESET_MEMBER(model1_state,model1_vr)
776774{
777775   membank("bank1")->set_base(memregion("maincpu")->base() + 0x1000000);
778   irq_init(machine());
776   irq_init();
779777   model1_vr_tgp_reset(machine());
780778   m_sound_irq = 3;
781779
trunk/src/mame/drivers/voyager.c
r20631r20632
6969   DECLARE_DRIVER_INIT(voyager);
7070   virtual void machine_start();
7171   virtual void machine_reset();
72   IRQ_CALLBACK_MEMBER(irq_callback);
7273};
7374
7475
r20631r20632
644645INPUT_PORTS_END
645646#endif
646647
647static IRQ_CALLBACK(irq_callback)
648IRQ_CALLBACK_MEMBER(voyager_state::irq_callback)
648649{
649   voyager_state *state = device->machine().driver_data<voyager_state>();
650   return pic8259_acknowledge( state->m_pic8259_1);
650   return pic8259_acknowledge(m_pic8259_1);
651651}
652652
653653void voyager_state::machine_start()
654654{
655   machine().device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
655   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(voyager_state::irq_callback),this));
656656
657657   m_pit8254 = machine().device( "pit8254" );
658658   m_pic8259_1 = machine().device( "pic8259_1" );
trunk/src/mame/machine/megadriv.c
r20631r20632
10911091}
10921092
10931093/* Callback when the 68k takes an IRQ */
1094static IRQ_CALLBACK(genesis_int_callback)
1094IRQ_CALLBACK_MEMBER(md_base_state::genesis_int_callback)
10951095{
1096   md_base_state *state = device->machine().driver_data<md_base_state>();
1097
10981096   if (irqline==4)
10991097   {
1100      state->m_vdp->vdp_clear_irq4_pending();
1098      m_vdp->vdp_clear_irq4_pending();
11011099   }
11021100
11031101   if (irqline==6)
11041102   {
1105      state->m_vdp->vdp_clear_irq6_pending();
1103      m_vdp->vdp_clear_irq6_pending();
11061104   }
11071105
11081106   return (0x60+irqline*4)/4; // vector address
r20631r20632
13351333   return 0; // writeback not allowed
13361334}
13371335
1338static void megadriv_init_common(running_machine &machine)
1336void md_base_state::megadriv_init_common()
13391337{
13401338   /* Look to see if this system has the standard Sound Z80 */
1341   _genesis_snd_z80_cpu = machine.device<cpu_device>("genesis_snd_z80");
1339   _genesis_snd_z80_cpu = machine().device<cpu_device>("genesis_snd_z80");
13421340   if (_genesis_snd_z80_cpu != NULL)
13431341   {
13441342      //printf("GENESIS Sound Z80 cpu found '%s'\n", _genesis_snd_z80_cpu->tag() );
13451343
1346      genz80.z80_prgram = auto_alloc_array(machine, UINT8, 0x2000);
1347      machine.root_device().membank("bank1")->set_base(genz80.z80_prgram );
1344      genz80.z80_prgram = auto_alloc_array(machine(), UINT8, 0x2000);
1345      machine().root_device().membank("bank1")->set_base(genz80.z80_prgram );
13481346   }
13491347
13501348   /* Look to see if this system has the 32x Master SH2 */
1351   _32x_master_cpu = machine.device<cpu_device>(_32X_MASTER_TAG);
1349   _32x_master_cpu = machine().device<cpu_device>(_32X_MASTER_TAG);
13521350   if (_32x_master_cpu != NULL)
13531351   {
13541352      printf("32x MASTER SH2 cpu found '%s'\n", _32x_master_cpu->tag() );
13551353   }
13561354
13571355   /* Look to see if this system has the 32x Slave SH2 */
1358   _32x_slave_cpu = machine.device<cpu_device>(_32X_SLAVE_TAG);
1356   _32x_slave_cpu = machine().device<cpu_device>(_32X_SLAVE_TAG);
13591357   if (_32x_slave_cpu != NULL)
13601358   {
13611359      printf("32x SLAVE SH2 cpu found '%s'\n", _32x_slave_cpu->tag() );
13621360   }
13631361
1364   _svp_cpu = machine.device<cpu_device>("svp");
1362   _svp_cpu = machine().device<cpu_device>("svp");
13651363   if (_svp_cpu != NULL)
13661364   {
13671365      printf("SVP (cpu) found '%s'\n", _svp_cpu->tag() );
13681366   }
13691367
1370   machine.device("maincpu")->execute().set_irq_acknowledge_callback(genesis_int_callback);
1368   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(md_base_state::genesis_int_callback),this));
13711369   megadriv_backupram = NULL;
13721370   megadriv_backupram_length = 0;
13731371
13741372   vdp_get_word_from_68k_mem = vdp_get_word_from_68k_mem_default;
13751373
1376   m68k_set_tas_callback(machine.device("maincpu"), megadriv_tas_callback);
1374   m68k_set_tas_callback(machine().device("maincpu"), megadriv_tas_callback);
13771375
13781376   // the drivers which need 6 buttons pad set this to 1 in their init befare calling the megadrive init
13791377   if (megadrive_6buttons_pad)
r20631r20632
13941392        some games specify a single address, (start 200001, end 200001)
13951393        this usually means there is serial eeprom instead */
13961394      int i;
1397      UINT16 *rom = (UINT16*)machine.root_device().memregion("maincpu")->base();
1395      UINT16 *rom = (UINT16*)machine().root_device().memregion("maincpu")->base();
13981396
13991397      mame_printf_debug("DEBUG:: Header: Backup RAM string (ignore for games without)\n");
14001398      for (i=0;i<12;i++)
r20631r20632
14111409   /* if we have an SVP cpu then do some extra initilization for it */
14121410   if (_svp_cpu != NULL)
14131411   {
1414      svp_init(machine);
1412      svp_init(machine());
14151413   }
14161414
14171415
r20631r20632
14221420   genvdp_use_cram = 0;
14231421   genesis_other_hacks = 0;
14241422
1425   megadriv_init_common(machine());
1423   megadriv_init_common();
14261424   megadriv_framerate = 60;
14271425}
14281426
r20631r20632
14331431   genvdp_use_cram = 1;
14341432   genesis_other_hacks = 1;
14351433
1436   megadriv_init_common(machine());
1434   megadriv_init_common();
14371435   megadriv_framerate = 60;
14381436}
14391437
r20631r20632
14421440   genvdp_use_cram = 1;
14431441   genesis_other_hacks = 1;
14441442
1445   megadriv_init_common(machine());
1443   megadriv_init_common();
14461444   megadriv_framerate = 60;
14471445}
14481446
r20631r20632
14511449   genvdp_use_cram = 1;
14521450   genesis_other_hacks = 1;
14531451
1454   megadriv_init_common(machine());
1452   megadriv_init_common();
14551453   megadriv_framerate = 50;
14561454}
14571455
trunk/src/mame/includes/jaguar.h
r20631r20632
214214   int quickload(device_image_interface &image, const char *file_type, int quickload_size);
215215   void cart_start();
216216   int cart_load(device_image_interface &image);
217
217   IRQ_CALLBACK_MEMBER(jaguar_irq_callback);
218218protected:
219219   // timer IDs
220220   enum
trunk/src/mame/includes/taito_l.h
r20631r20632
122122   UINT32 screen_update_taitol(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
123123   void screen_eof_taitol(screen_device &screen, bool state);
124124   TIMER_DEVICE_CALLBACK_MEMBER(vbl_interrupt);
125   IRQ_CALLBACK_MEMBER(irq_callback);
125126};
126127
127128/*----------- defined in video/taito_l.c -----------*/
trunk/src/mame/includes/model1.h
r20631r20632
140140   UINT32 screen_update_model1(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
141141   void screen_eof_model1(screen_device &screen, bool state);
142142   TIMER_DEVICE_CALLBACK_MEMBER(model1_interrupt);
143   void irq_raise(int level);
144   void irq_init();
145   IRQ_CALLBACK_MEMBER(irq_callback);
143146};
144147
145148
trunk/src/mame/includes/megadriv.h
r20631r20632
121121
122122   DECLARE_READ8_MEMBER(megadriv_68k_YM2612_read);
123123   DECLARE_WRITE8_MEMBER(megadriv_68k_YM2612_write);
124   IRQ_CALLBACK_MEMBER(genesis_int_callback);
125   void megadriv_init_common();
124126};
125127
126128class md_boot_state : public md_base_state
trunk/src/mess/drivers/paso1600.c
r20631r20632
5656   virtual void machine_reset();
5757   virtual void video_start();
5858   UINT32 screen_update_paso1600(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
59   IRQ_CALLBACK_MEMBER(paso1600_irq_callback);
5960};
6061
6162#define mc6845_h_char_total     (m_crtc_vreg[0])
r20631r20632
274275   NULL        /* update address callback */
275276};
276277
277static IRQ_CALLBACK(paso1600_irq_callback)
278IRQ_CALLBACK_MEMBER(paso1600_state::paso1600_irq_callback)
278279{
279   return pic8259_acknowledge( device->machine().device( "pic8259" ) );
280   return pic8259_acknowledge( machine().device( "pic8259" ) );
280281}
281282
282283WRITE_LINE_MEMBER( paso1600_state::paso1600_set_int_line )
r20631r20632
294295
295296void paso1600_state::machine_start()
296297{
297   m_maincpu->set_irq_acknowledge_callback(paso1600_irq_callback);
298   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(paso1600_state::paso1600_irq_callback),this));
298299}
299300
300301
trunk/src/mess/drivers/apricot.c
r20631r20632
6666   virtual void palette_init();
6767   UINT32 screen_update_apricot(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
6868   DECLARE_WRITE_LINE_MEMBER(apricot_sio_irq_w);
69   IRQ_CALLBACK_MEMBER(apricot_irq_ack);
6970};
7071
7172
r20631r20632
142143    INTERRUPTS
143144***************************************************************************/
144145
145static IRQ_CALLBACK( apricot_irq_ack )
146IRQ_CALLBACK_MEMBER(apricot_state::apricot_irq_ack)
146147{
147   apricot_state *state = device->machine().driver_data<apricot_state>();
148   return pic8259_acknowledge(state->m_pic);
148   return pic8259_acknowledge(m_pic);
149149}
150150
151151static const struct pic8259_interface apricot_pic8259_intf =
r20631r20632
266266   prg.unmap_readwrite(0x40000, 0xeffff);
267267   prg.install_ram(0x00000, ram_size - 1, ram);
268268
269   m_maincpu->set_irq_acknowledge_callback(apricot_irq_ack);
269   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(apricot_state::apricot_irq_ack),this));
270270
271271   m_video_mode = 0;
272272   m_display_on = 1;
trunk/src/mess/drivers/victor9k.c
r20631r20632
915915
916916// Machine Initialization
917917
918static IRQ_CALLBACK( victor9k_irq_callback )
918IRQ_CALLBACK_MEMBER(victor9k_state::victor9k_irq_callback)
919919{
920   victor9k_state *state = device->machine().driver_data<victor9k_state>();
921
922   return pic8259_acknowledge(state->m_pic);
920   return pic8259_acknowledge(m_pic);
923921}
924922
925923void victor9k_state::machine_start()
926924{
927925   // set interrupt callback
928   m_maincpu->set_irq_acknowledge_callback(victor9k_irq_callback);
926   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(victor9k_state::victor9k_irq_callback),this));
929927
930928   // memory banking
931929   address_space &program = m_maincpu->space(AS_PROGRAM);
trunk/src/mess/drivers/cbm2.c
r20631r20632
17251725//  pic8259_interface ext_pic_intf
17261726//-------------------------------------------------
17271727
1728static IRQ_CALLBACK( pic_irq_callback )
1728IRQ_CALLBACK_MEMBER(cbm2_state::pic_irq_callback)
17291729{
1730   cbm2_state *state = device->machine().driver_data<cbm2_state>();
1731
1732   return pic8259_acknowledge(state->m_ext_pic);
1730   return pic8259_acknowledge(m_ext_pic);
17331731}
17341732
17351733static pic8259_interface ext_pic_intf =
r20631r20632
20022000MACHINE_START_MEMBER( cbm2_state, cbm2x_ntsc )
20032001{
20042002   // register CPU IRQ callback
2005   m_ext_cpu->set_irq_acknowledge_callback(pic_irq_callback);
2003   m_ext_cpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(cbm2_state::pic_irq_callback),this));
20062004
20072005   // allocate memory
20082006   m_extbuf_ram.allocate(0x800);
r20631r20632
20182016MACHINE_START_MEMBER( cbm2_state, cbm2x_pal )
20192017{
20202018   // register CPU IRQ callback
2021   m_ext_cpu->set_irq_acknowledge_callback(pic_irq_callback);
2019   m_ext_cpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(cbm2_state::pic_irq_callback),this));
20222020
20232021   // allocate memory
20242022   m_extbuf_ram.allocate(0x800);
trunk/src/mess/drivers/x1.c
r20631r20632
23472347 *************************************/
23482348
23492349#ifdef UNUSED_FUNCTION
2350static IRQ_CALLBACK(x1_irq_callback)
2350IRQ_CALLBACK_MEMBER(x1_state::x1_irq_callback)
23512351{
2352   x1_state *state = device->machine().driver_data<x1_state>();
2353   if(state->m_ctc_irq_flag != 0)
2352   if(m_ctc_irq_flag != 0)
23542353   {
2355      state->m_ctc_irq_flag = 0;
2356      if(state->m_key_irq_flag == 0)  // if no other devices are pulling the IRQ line high
2357         device->execute().set_input_line(0, CLEAR_LINE);
2358      return state->m_irq_vector;
2354      m_ctc_irq_flag = 0;
2355      if(m_key_irq_flag == 0)  // if no other devices are pulling the IRQ line high
2356         device.execute().set_input_line(0, CLEAR_LINE);
2357      return m_irq_vector;
23592358   }
2360   if(state->m_key_irq_flag != 0)
2359   if(m_key_irq_flag != 0)
23612360   {
2362      state->m_key_irq_flag = 0;
2363      if(state->m_ctc_irq_flag == 0)  // if no other devices are pulling the IRQ line high
2364         device->execute().set_input_line(0, CLEAR_LINE);
2365      return state->m_key_irq_vector;
2361      m_key_irq_flag = 0;
2362      if(m_ctc_irq_flag == 0)  // if no other devices are pulling the IRQ line high
2363         device.execute().set_input_line(0, CLEAR_LINE);
2364      return m_key_irq_vector;
23662365   }
2367   return state->m_irq_vector;
2366   return m_irq_vector;
23682367}
23692368#endif
23702369
r20631r20632
24422441
24432442   m_io_bank_mode = 0;
24442443
2445   //machine().device("x1_cpu")->execute().set_irq_acknowledge_callback(x1_irq_callback);
2444   //machine().device("x1_cpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(x1_state::x1_irq_callback),this));
24462445
24472446   m_cmt_current_cmd = 0;
24482447   m_cmt_test = 0;
trunk/src/mess/drivers/portfoli.c
r20631r20632
161161}
162162
163163//-------------------------------------------------
164//  IRQ_CALLBACK( portfolio_int_ack )
164//  IRQ_CALLBACK_MEMBER( portfolio_int_ack )
165165//-------------------------------------------------
166166
167static IRQ_CALLBACK( portfolio_int_ack )
167IRQ_CALLBACK_MEMBER(portfolio_state::portfolio_int_ack)
168168{
169   portfolio_state *state = device->machine().driver_data<portfolio_state>();
169   UINT8 vector = m_sivr;
170170
171   UINT8 vector = state->m_sivr;
172
173171   for (int i = 0; i < 4; i++)
174172   {
175      if (BIT(state->m_ip, i))
173      if (BIT(m_ip, i))
176174      {
177175         // clear interrupt pending bit
178         state->m_ip &= ~(1 << i);
176         m_ip &= ~(1 << i);
179177
180178         if (i == 3)
181            vector = state->m_sivr;
179            vector = m_sivr;
182180         else
183181            vector = INTERRUPT_VECTOR[i];
184182
r20631r20632
186184      }
187185   }
188186
189   state->check_interrupt();
187   check_interrupt();
190188
191189   return vector;
192190}
r20631r20632
761759   address_space &program = m_maincpu->space(AS_PROGRAM);
762760
763761   /* set CPU interrupt vector callback */
764   m_maincpu->set_irq_acknowledge_callback(portfolio_int_ack);
762   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(portfolio_state::portfolio_int_ack),this));
765763
766764   /* memory expansions */
767765   switch (machine().device<ram_device>(RAM_TAG)->size())
trunk/src/mess/drivers/vixen.c
r20631r20632
727727//**************************************************************************
728728
729729//-------------------------------------------------
730//  IRQ_CALLBACK( vixen )
730//  IRQ_CALLBACK_MEMBER( vixen_int_ack )
731731//-------------------------------------------------
732732
733static IRQ_CALLBACK( vixen_int_ack )
733IRQ_CALLBACK_MEMBER(vixen_state::vixen_int_ack)
734734{
735735   // D0 is pulled low
736736   return 0xfe;
r20631r20632
744744void vixen_state::machine_start()
745745{
746746   // interrupt callback
747   m_maincpu->set_irq_acknowledge_callback(vixen_int_ack);
747   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(vixen_state::vixen_int_ack),this));
748748
749749   // configure memory banking
750750   UINT8 *ram = m_ram->pointer();
trunk/src/mess/drivers/m20.c
r20631r20632
108108   DECLARE_FLOPPY_FORMATS( floppy_formats );
109109
110110   void fdc_intrq_w(bool state);
111   IRQ_CALLBACK_MEMBER(m20_irq_callback);
111112};
112113
113114
r20631r20632
798799{
799800}
800801
801static IRQ_CALLBACK( m20_irq_callback )
802IRQ_CALLBACK_MEMBER(m20_state::m20_irq_callback)
802803{
803804   if (! irqline)
804805      return 0xff; // NVI, value ignored
805806   else
806      return pic8259_acknowledge(device->machine().device("i8259"));
807      return pic8259_acknowledge(machine().device("i8259"));
807808}
808809
809810void m20_state::machine_start()
r20631r20632
823824   else
824825      m_port21 = 0xff;
825826
826   m_maincpu->set_irq_acknowledge_callback(m20_irq_callback);
827   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(m20_state::m20_irq_callback),this));
827828
828829   m_fd1797->reset();
829830
trunk/src/mess/drivers/pc1512.c
r20631r20632
911911//  pic8259_interface pic_intf
912912//-------------------------------------------------
913913
914static IRQ_CALLBACK( pc1512_irq_callback )
914IRQ_CALLBACK_MEMBER(pc1512_state::pc1512_irq_callback)
915915{
916   pc1512_state *state = device->machine().driver_data<pc1512_state>();
917
918   return pic8259_acknowledge(state->m_pic);
916   return pic8259_acknowledge(m_pic);
919917}
920918
921919static const struct pic8259_interface pic_intf =
r20631r20632
10991097void pc1512_state::machine_start()
11001098{
11011099   // register CPU IRQ callback
1102   m_maincpu->set_irq_acknowledge_callback(pc1512_irq_callback);
1100   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(pc1512_state::pc1512_irq_callback),this));
11031101
11041102   // set RAM size
11051103   size_t ram_size = m_ram->size();
r20631r20632
11791177void pc1640_state::machine_start()
11801178{
11811179   // register CPU IRQ callback
1182   m_maincpu->set_irq_acknowledge_callback(pc1512_irq_callback);
1180   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(pc1512_state::pc1512_irq_callback),this));
11831181
11841182   // state saving
11851183   save_item(NAME(m_pit1));
trunk/src/mess/drivers/atarist.c
r20631r20632
21142114//**************************************************************************
21152115
21162116//-------------------------------------------------
2117//  IRQ_CALLBACK( atarist_int_ack )
2117//  IRQ_CALLBACK_MEMBER( atarist_int_ack )
21182118//-------------------------------------------------
21192119
2120static IRQ_CALLBACK( atarist_int_ack )
2120IRQ_CALLBACK_MEMBER(st_state::atarist_int_ack)
21212121{
2122   st_state *state = device->machine().driver_data<st_state>();
2123
21242122   if (irqline == M68K_IRQ_6)
21252123   {
2126      return state->m_mfp->get_vector();
2124      return m_mfp->get_vector();
21272125   }
21282126
21292127   return M68K_INT_ACK_AUTOVECTOR;
r20631r20632
21992197   configure_memory();
22002198
22012199   // set CPU interrupt callback
2202   m_maincpu->set_irq_acknowledge_callback(atarist_int_ack);
2200   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(st_state::atarist_int_ack),this));
22032201
22042202   // allocate timers
22052203   m_mouse_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(st_state::st_mouse_tick),this));
r20631r20632
22562254   configure_memory();
22572255
22582256   /* set CPU interrupt callback */
2259   m_maincpu->set_irq_acknowledge_callback(atarist_int_ack);
2257   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(st_state::atarist_int_ack),this));
22602258
22612259   /* allocate timers */
22622260   m_dmasound_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(ste_state::atariste_dmasound_tick),this));
r20631r20632
22962294   }
22972295
22982296   /* set CPU interrupt callback */
2299   m_maincpu->set_irq_acknowledge_callback(atarist_int_ack);
2297   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(st_state::atarist_int_ack),this));
23002298
23012299   /* register for state saving */
23022300   ste_state::state_save();
trunk/src/mess/drivers/wangpc.c
r20631r20632
743743   pic8259_ir2_w(m_pic, state);
744744}
745745
746static IRQ_CALLBACK( wangpc_irq_callback )
746IRQ_CALLBACK_MEMBER(wangpc_state::wangpc_irq_callback)
747747{
748   wangpc_state *state = device->machine().driver_data<wangpc_state>();
749
750   return pic8259_acknowledge(state->m_pic);
748   return pic8259_acknowledge(m_pic);
751749}
752750
753751static const struct pic8259_interface pic_intf =
r20631r20632
10991097void wangpc_state::machine_start()
11001098{
11011099   // register CPU IRQ callback
1102   m_maincpu->set_irq_acknowledge_callback(wangpc_irq_callback);
1100   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(wangpc_state::wangpc_irq_callback),this));
11031101
11041102   // connect serial keyboard
11051103   m_uart->connect(m_kb);
trunk/src/mess/drivers/abc1600.c
r20631r20632
17981798//**************************************************************************
17991799
18001800//-------------------------------------------------
1801//  IRQ_CALLBACK( abc1600_int_ack )
1801//  IRQ_CALLBACK_MEMBER( abc1600_int_ack )
18021802//-------------------------------------------------
18031803
1804static IRQ_CALLBACK( abc1600_int_ack )
1804IRQ_CALLBACK_MEMBER( abc1600_state::abc1600_int_ack )
18051805{
1806   abc1600_state *state = device->machine().driver_data<abc1600_state>();
18071806   int data = 0;
18081807
18091808   switch (irqline)
18101809   {
18111810   case M68K_IRQ_2:
1812      data = state->m_cio->intack_r();
1811      data = m_cio->intack_r();
18131812      break;
18141813
18151814   case M68K_IRQ_5:
1816      data = state->m_dart->m1_r();
1815      data = m_dart->m1_r();
18171816      break;
18181817
18191818   case M68K_IRQ_7:
1820      state->m_maincpu->set_input_line(M68K_IRQ_7, CLEAR_LINE);
1819      m_maincpu->set_input_line(M68K_IRQ_7, CLEAR_LINE);
18211820
18221821      data = M68K_INT_ACK_AUTOVECTOR;
18231822      break;
r20631r20632
18341833void abc1600_state::machine_start()
18351834{
18361835   // interrupt callback
1837   m_maincpu->set_irq_acknowledge_callback(abc1600_int_ack);
1836   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(abc1600_state::abc1600_int_ack),this));
18381837
18391838   // floppy callbacks
18401839   m_fdc->setup_intrq_cb(wd_fdc_t::line_cb(FUNC(abc1600_state::fdc_intrq_w), this));
trunk/src/mess/drivers/pc8801.c
r20631r20632
483483   DECLARE_WRITE_LINE_MEMBER(pic_enlg_w);
484484   DECLARE_READ8_MEMBER(opn_porta_r);
485485   DECLARE_READ8_MEMBER(opn_portb_r);
486   IRQ_CALLBACK_MEMBER(pc8801_irq_callback);
486487};
487488
488489
r20631r20632
23082309   DEVCB_DRIVER_LINE_MEMBER(pc8801_state,pic_enlg_w)
23092310};
23102311
2311static IRQ_CALLBACK( pc8801_irq_callback )
2312IRQ_CALLBACK_MEMBER(pc8801_state::pc8801_irq_callback)
23122313{
2313   pc8801_state *state = device->machine().driver_data<pc8801_state>();
2314   UINT8 vector = (7 - state->m_pic->a_r());
2314   UINT8 vector = (7 - m_pic->a_r());
23152315
2316   state->m_int_state &= ~(1<<vector);
2316   m_int_state &= ~(1<<vector);
23172317   m_maincpu->set_input_line(0,CLEAR_LINE);
23182318
23192319   return vector << 1;
r20631r20632
23442344
23452345#include "debugger.h"
23462346
2347static IRQ_CALLBACK( pc8801_irq_callback )
2347IRQ_CALLBACK_MEMBER(pc8801_state::pc8801_irq_callback)
23482348{
2349   pc8801_state *state = device->machine().driver_data<pc8801_state>();
2350   if(state->m_sound_irq_latch)
2349   if(m_sound_irq_latch)
23512350   {
2352      state->m_sound_irq_latch = 0;
2351      m_sound_irq_latch = 0;
23532352      return 4*2;
23542353   }
2355   else if(state->m_vrtc_irq_latch)
2354   else if(m_vrtc_irq_latch)
23562355   {
2357      state->m_vrtc_irq_latch = 0;
2356      m_vrtc_irq_latch = 0;
23582357      return 1*2;
23592358   }
2360   else if(state->m_timer_irq_latch)
2359   else if(m_timer_irq_latch)
23612360   {
2362      state->m_timer_irq_latch = 0;
2361      m_timer_irq_latch = 0;
23632362      return 2*2;
23642363   }
23652364
2366   printf("IRQ triggered but no vector on the bus! %02x %02x %02x %02x\n",state->m_i8214_irq_level,state->m_sound_irq_latch,state->m_vrtc_irq_latch,state->m_timer_irq_latch);
2367   debugger_break(device->machine());
2365   printf("IRQ triggered but no vector on the bus! %02x %02x %02x %02x\n",m_i8214_irq_level,m_sound_irq_latch,m_vrtc_irq_latch,m_timer_irq_latch);
2366   debugger_break(machine());
23682367
23692368   return 4*2; //TODO: mustn't happen
23702369}
r20631r20632
24122411
24132412void pc8801_state::machine_start()
24142413{
2415   m_maincpu->set_irq_acknowledge_callback(pc8801_irq_callback);
2414   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(pc8801_state::pc8801_irq_callback),this));
24162415   machine().device<upd765a_device>("upd765")->setup_intrq_cb(upd765a_device::line_cb(FUNC(pc8801_state::fdc_irq_w), this));
24172416
24182417   machine().device<floppy_connector>("upd765:0")->get_device()->set_rpm(300);
trunk/src/mess/drivers/z100.c
r20631r20632
206206   virtual void palette_init();
207207   UINT32 screen_update_z100(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
208208   DECLARE_INPUT_CHANGED_MEMBER(key_stroke);
209   IRQ_CALLBACK_MEMBER(z100_irq_callback);
209210};
210211
211212#define mc6845_h_char_total     (m_crtc_vreg[0])
r20631r20632
594595   PORT_CONFSETTING( 0x01, "Color" )
595596INPUT_PORTS_END
596597
597static IRQ_CALLBACK(z100_irq_callback)
598IRQ_CALLBACK_MEMBER(z100_state::z100_irq_callback)
598599{
599   return pic8259_acknowledge( device->machine().device( "pic8259_master" ) );
600   return pic8259_acknowledge( machine().device( "pic8259_master" ) );
600601}
601602
602603WRITE_LINE_MEMBER( z100_state::z100_pic_irq )
r20631r20632
751752
752753void z100_state::machine_start()
753754{
754   machine().device("maincpu")->execute().set_irq_acknowledge_callback(z100_irq_callback);
755   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(z100_state::z100_irq_callback),this));
755756   m_mc6845 = machine().device<mc6845_device>("crtc");
756757}
757758
trunk/src/mess/drivers/multi16.c
r20631r20632
3333   virtual void machine_reset();
3434   virtual void video_start();
3535   UINT32 screen_update_multi16(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
36   IRQ_CALLBACK_MEMBER(multi16_irq_callback);
3637};
3738
3839
r20631r20632
116117static INPUT_PORTS_START( multi16 )
117118INPUT_PORTS_END
118119
119static IRQ_CALLBACK(multi16_irq_callback)
120IRQ_CALLBACK_MEMBER(multi16_state::multi16_irq_callback)
120121{
121   return pic8259_acknowledge( device->machine().device("pic8259") );
122   return pic8259_acknowledge( machine().device("pic8259") );
122123}
123124
124125WRITE_LINE_MEMBER( multi16_state::multi16_set_int_line )
r20631r20632
136137
137138void multi16_state::machine_start()
138139{
139   machine().device("maincpu")->execute().set_irq_acknowledge_callback(multi16_irq_callback);
140   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(multi16_state::multi16_irq_callback),this));
140141}
141142
142143
trunk/src/mess/drivers/v1050.c
r20631r20632
982982
983983// Machine Initialization
984984
985static IRQ_CALLBACK( v1050_int_ack )
985IRQ_CALLBACK_MEMBER(v1050_state::v1050_int_ack)
986986{
987   v1050_state *state = device->machine().driver_data<v1050_state>();
987   UINT8 vector = 0xf0 | (m_pic->a_r() << 1);
988988
989   UINT8 vector = 0xf0 | (state->m_pic->a_r() << 1);
990
991989   //logerror("Interrupt Acknowledge Vector: %02x\n", vector);
992990
993   state->m_maincpu->set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
991   m_maincpu->set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
994992
995993   return vector;
996994}
r20631r20632
10111009   m_rtc->cs1_w(1);
10121010
10131011   // set CPU interrupt callback
1014   m_maincpu->set_irq_acknowledge_callback(v1050_int_ack);
1012   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(v1050_state::v1050_int_ack),this));
10151013
10161014   // setup memory banking
10171015   UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();
trunk/src/mess/drivers/apricotp.c
r20631r20632
416416//  pic8259_interface pic_intf
417417//-------------------------------------------------
418418
419static IRQ_CALLBACK( fp_irq_callback )
419 IRQ_CALLBACK_MEMBER(fp_state::fp_irq_callback)
420420{
421   fp_state *state = device->machine().driver_data<fp_state>();
422
423   return pic8259_acknowledge(state->m_pic);
421   return pic8259_acknowledge(m_pic);
424422}
425423
426424/*
r20631r20632
588586   m_fdc->setup_drq_cb(wd_fdc_t::line_cb(FUNC(fp_state::fdc_drq_w), this));
589587
590588   // register CPU IRQ callback
591   m_maincpu->set_irq_acknowledge_callback(fp_irq_callback);
589   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(fp_state::fp_irq_callback),this));
592590
593591   // allocate memory
594592   m_work_ram.allocate(m_ram->size() / 2);
trunk/src/mess/drivers/trs80m2.c
r20631r20632
723723//  pic8259_interface pic_intf
724724//-------------------------------------------------
725725
726static IRQ_CALLBACK( trs80m16_irq_callback )
726IRQ_CALLBACK_MEMBER(trs80m16_state::trs80m16_irq_callback)
727727{
728   trs80m16_state *state = device->machine().driver_data<trs80m16_state>();
729
730   return pic8259_acknowledge(state->m_pic);
728   return pic8259_acknowledge(m_pic);
731729}
732730
733731static const struct pic8259_interface pic_intf =
r20631r20632
775773   trs80m2_state::machine_start();
776774
777775   // register CPU IRQ callback
778   m_maincpu->set_irq_acknowledge_callback(trs80m16_irq_callback);
776   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(trs80m16_state::trs80m16_irq_callback),this));
779777
780778   // register for state saving
781779   save_item(NAME(m_ual));
trunk/src/mess/drivers/vidbrain.c
r20631r20632
482482//**************************************************************************
483483
484484//-------------------------------------------------
485//  IRQ_CALLBACK( vidbrain_int_ack )
485//     IRQ_CALLBACK_MEMBER(vidbrain_int_ack)
486486//-------------------------------------------------
487487
488static IRQ_CALLBACK( vidbrain_int_ack )
488IRQ_CALLBACK_MEMBER(vidbrain_state::vidbrain_int_ack)
489489{
490   vidbrain_state *state = device->machine().driver_data<vidbrain_state>();
490   UINT16 vector = m_vector;
491491
492   UINT16 vector = state->m_vector;
493
494   switch (state->m_int_enable)
492   switch (m_int_enable)
495493   {
496494   case 1:
497495      vector |= 0x80;
498      state->m_ext_int_latch = 0;
496      m_ext_int_latch = 0;
499497      break;
500498
501499   case 3:
502500      vector &= ~0x80;
503      state->m_timer_int_latch = 0;
501      m_timer_int_latch = 0;
504502      break;
505503   }
506504
507   state->interrupt_check();
505   interrupt_check();
508506
509507   return vector;
510508}
r20631r20632
530528void vidbrain_state::machine_start()
531529{
532530   // register IRQ callback
533   m_maincpu->set_irq_acknowledge_callback(vidbrain_int_ack);
531   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(vidbrain_state::vidbrain_int_ack),this));
534532
535533   // allocate timers
536534   m_timer_ne555 = timer_alloc(TIMER_JOYSTICK);
trunk/src/mess/machine/rmnimbus.c
r20631r20632
194194 *  80186 interrupt controller
195195 *
196196 *************************************/
197static IRQ_CALLBACK(int_callback)
197IRQ_CALLBACK_MEMBER(rmnimbus_state::int_callback)
198198{
199   rmnimbus_state *state = device->machine().driver_data<rmnimbus_state>();
200199   UINT8   vector;
201200   UINT16  old;
202201   UINT16  oldreq;
203202
204203   if (LOG_INTERRUPTS)
205      logerror("(%f) **** Acknowledged interrupt vector %02X\n", device->machine().time().as_double(), state->m_i186.intr.poll_status & 0x1f);
204      logerror("(%f) **** Acknowledged interrupt vector %02X\n", machine().time().as_double(), m_i186.intr.poll_status & 0x1f);
206205
207206   /* clear the interrupt */
208   device->execute().set_input_line(0, CLEAR_LINE);
209   state->m_i186.intr.pending = 0;
207   device.execute().set_input_line(0, CLEAR_LINE);
208   m_i186.intr.pending = 0;
210209
211   oldreq=state->m_i186.intr.request;
210   oldreq=m_i186.intr.request;
212211
213212   /* clear the request and set the in-service bit */
214213#if LATCH_INTS
215   state->m_i186.intr.request &= ~state->m_i186.intr.ack_mask;
214   m_i186.intr.request &= ~m_i186.intr.ack_mask;
216215#else
217   state->m_i186.intr.request &= ~(state->m_i186.intr.ack_mask & 0x0f);
216   m_i186.intr.request &= ~(m_i186.intr.ack_mask & 0x0f);
218217#endif
219218
220   if((LOG_INTERRUPTS) && (state->m_i186.intr.request!=oldreq))
221      logerror("i186.intr.request changed from %02X to %02X\n",oldreq,state->m_i186.intr.request);
219   if((LOG_INTERRUPTS) && (m_i186.intr.request!=oldreq))
220      logerror("i186.intr.request changed from %02X to %02X\n",oldreq,m_i186.intr.request);
222221
223   old=state->m_i186.intr.in_service;
222   old=m_i186.intr.in_service;
224223
225   state->m_i186.intr.in_service |= state->m_i186.intr.ack_mask;
224   m_i186.intr.in_service |= m_i186.intr.ack_mask;
226225
227   if((LOG_INTERRUPTS) && (state->m_i186.intr.in_service!=old))
228      logerror("i186.intr.in_service changed from %02X to %02X\n",old,state->m_i186.intr.in_service);
226   if((LOG_INTERRUPTS) && (m_i186.intr.in_service!=old))
227      logerror("i186.intr.in_service changed from %02X to %02X\n",old,m_i186.intr.in_service);
229228
230   if (state->m_i186.intr.ack_mask == 0x0001)
229   if (m_i186.intr.ack_mask == 0x0001)
231230   {
232      switch (state->m_i186.intr.poll_status & 0x1f)
231      switch (m_i186.intr.poll_status & 0x1f)
233232      {
234         case 0x08:  state->m_i186.intr.status &= ~0x01; break;
235         case 0x12:  state->m_i186.intr.status &= ~0x02; break;
236         case 0x13:  state->m_i186.intr.status &= ~0x04; break;
233         case 0x08:  m_i186.intr.status &= ~0x01; break;
234         case 0x12:  m_i186.intr.status &= ~0x02; break;
235         case 0x13:  m_i186.intr.status &= ~0x04; break;
237236      }
238237   }
239   state->m_i186.intr.ack_mask = 0;
238   m_i186.intr.ack_mask = 0;
240239
241240   /* a request no longer pending */
242   state->m_i186.intr.poll_status &= ~0x8000;
241   m_i186.intr.poll_status &= ~0x8000;
243242
244243   /* return the vector */
245   switch(state->m_i186.intr.poll_status & 0x1F)
244   switch(m_i186.intr.poll_status & 0x1F)
246245   {
247      case 0x0C   : vector=(state->m_i186.intr.ext[0] & EXTINT_CTRL_CASCADE) ? state->m_i186.intr.ext_vector[0] : (state->m_i186.intr.poll_status & 0x1f); break;
248      case 0x0D   : vector=(state->m_i186.intr.ext[1] & EXTINT_CTRL_CASCADE) ? state->m_i186.intr.ext_vector[1] : (state->m_i186.intr.poll_status & 0x1f); break;
246      case 0x0C   : vector=(m_i186.intr.ext[0] & EXTINT_CTRL_CASCADE) ? m_i186.intr.ext_vector[0] : (m_i186.intr.poll_status & 0x1f); break;
247      case 0x0D   : vector=(m_i186.intr.ext[1] & EXTINT_CTRL_CASCADE) ? m_i186.intr.ext_vector[1] : (m_i186.intr.poll_status & 0x1f); break;
249248      default :
250         vector=state->m_i186.intr.poll_status & 0x1f; break;
249         vector=m_i186.intr.poll_status & 0x1f; break;
251250   }
252251
253252   if (LOG_INTERRUPTS)
254253   {
255      logerror("i186.intr.ext[0]=%04X i186.intr.ext[1]=%04X\n",state->m_i186.intr.ext[0],state->m_i186.intr.ext[1]);
256      logerror("Ext vectors : %02X %02X\n",state->m_i186.intr.ext_vector[0],state->m_i186.intr.ext_vector[1]);
257      logerror("Int %02X Calling vector %02X\n",state->m_i186.intr.poll_status,vector);
254      logerror("i186.intr.ext[0]=%04X i186.intr.ext[1]=%04X\n",m_i186.intr.ext[0],m_i186.intr.ext[1]);
255      logerror("Ext vectors : %02X %02X\n",m_i186.intr.ext_vector[0],m_i186.intr.ext_vector[1]);
256      logerror("Int %02X Calling vector %02X\n",m_i186.intr.poll_status,vector);
258257   }
259258
260259   return vector;
r20631r20632
855854      case 0x12:
856855         if (LOG_PORTS) logerror("%05X:read 80186 interrupt poll\n", space.device().safe_pc());
857856         if (m_i186.intr.poll_status & 0x8000)
858            int_callback(machine().device(MAINCPU_TAG), 0);
857            int_callback(*machine().device(MAINCPU_TAG), 0);
859858         return m_i186.intr.poll_status;
860859
861860      case 0x13:
r20631r20632
11671166         /* we need to do this at a time when the I86 context is swapped in */
11681167         /* this register is generally set once at startup and never again, so it's a good */
11691168         /* time to set it up */
1170         space.device().execute().set_irq_acknowledge_callback(int_callback);
1169         space.device().execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(rmnimbus_state::int_callback),this));
11711170         break;
11721171
11731172      case 0x60:
trunk/src/mess/machine/compis.c
r20631r20632
345345 *  80186 interrupt controller
346346 *
347347 *************************************/
348static IRQ_CALLBACK(int_callback)
348IRQ_CALLBACK_MEMBER(compis_state::int_callback)
349349{
350   compis_state *state = device->machine().driver_data<compis_state>();
351350   if (LOG_INTERRUPTS)
352      logerror("(%f) **** Acknowledged interrupt vector %02X\n", device->machine().time().as_double(), state->m_i186.intr.poll_status & 0x1f);
351      logerror("(%f) **** Acknowledged interrupt vector %02X\n", machine().time().as_double(), m_i186.intr.poll_status & 0x1f);
353352
354353   /* clear the interrupt */
355   device->execute().set_input_line(0, CLEAR_LINE);
356   state->m_i186.intr.pending = 0;
354   device.execute().set_input_line(0, CLEAR_LINE);
355   m_i186.intr.pending = 0;
357356
358357   /* clear the request and set the in-service bit */
359358#if LATCH_INTS
360   state->m_i186.intr.request &= ~state->m_i186.intr.ack_mask;
359   m_i186.intr.request &= ~m_i186.intr.ack_mask;
361360#else
362   state->m_i186.intr.request &= ~(state->m_i186.intr.ack_mask & 0x0f);
361   m_i186.intr.request &= ~(m_i186.intr.ack_mask & 0x0f);
363362#endif
364   state->m_i186.intr.in_service |= state->m_i186.intr.ack_mask;
365   if (state->m_i186.intr.ack_mask == 0x0001)
363   m_i186.intr.in_service |= m_i186.intr.ack_mask;
364   if (m_i186.intr.ack_mask == 0x0001)
366365   {
367      switch (state->m_i186.intr.poll_status & 0x1f)
366      switch (m_i186.intr.poll_status & 0x1f)
368367      {
369         case 0x08:  state->m_i186.intr.status &= ~0x01; break;
370         case 0x12:  state->m_i186.intr.status &= ~0x02; break;
371         case 0x13:  state->m_i186.intr.status &= ~0x04; break;
368         case 0x08:  m_i186.intr.status &= ~0x01; break;
369         case 0x12:  m_i186.intr.status &= ~0x02; break;
370         case 0x13:  m_i186.intr.status &= ~0x04; break;
372371      }
373372   }
374   state->m_i186.intr.ack_mask = 0;
373   m_i186.intr.ack_mask = 0;
375374
376375   /* a request no longer pending */
377   state->m_i186.intr.poll_status &= ~0x8000;
376   m_i186.intr.poll_status &= ~0x8000;
378377
379378   /* return the vector */
380   return state->m_i186.intr.poll_status & 0x1f;
379   return m_i186.intr.poll_status & 0x1f;
381380}
382381
383382
r20631r20632
819818      case 0x12:
820819         if (LOG_PORTS) logerror("%05X:read 80186 interrupt poll\n", m_maincpu->pc());
821820         if (m_i186.intr.poll_status & 0x8000)
822            int_callback(machine().device("maincpu"), 0);
821            int_callback(*machine().device("maincpu"), 0);
823822         return m_i186.intr.poll_status;
824823
825824      case 0x13:
r20631r20632
11521151         /* we need to do this at a time when the I86 context is swapped in */
11531152         /* this register is generally set once at startup and never again, so it's a good */
11541153         /* time to set it up */
1155         m_maincpu->set_irq_acknowledge_callback(int_callback);
1154         m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(compis_state::int_callback),this));
11561155         break;
11571156
11581157      case 0x60:
r20631r20632
12931292};
12941293
12951294
1296static IRQ_CALLBACK( compis_irq_callback )
1295IRQ_CALLBACK_MEMBER(compis_state::compis_irq_callback)
12971296{
1298   compis_state *state = device->machine().driver_data<compis_state>();
1299   return pic8259_acknowledge(state->m_8259m);
1297   return pic8259_acknowledge(m_8259m);
13001298}
13011299
13021300
13031301DRIVER_INIT_MEMBER(compis_state,compis)
13041302{
1305   machine().device("maincpu")->execute().set_irq_acknowledge_callback(compis_irq_callback);
1303   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(compis_state::compis_irq_callback),this));
13061304   memset (&m_compis, 0, sizeof (m_compis) );
13071305}
13081306
r20631r20632
13241322   compis_keyb_init(this);
13251323
13261324   /* OSP PIC 8259 */
1327   m_maincpu->set_irq_acknowledge_callback(compis_irq_callback);
1325   m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(compis_state::compis_irq_callback),this));
13281326}
13291327
13301328/*-------------------------------------------------------------------------*/
trunk/src/mess/machine/amstrad.c
r20631r20632
26702670/* called when cpu acknowledges int */
26712671/* reset top bit of interrupt line counter */
26722672/* this ensures that the next interrupt is no closer than 32 lines */
2673static IRQ_CALLBACK(amstrad_cpu_acknowledge_int)
2673IRQ_CALLBACK_MEMBER(amstrad_state::amstrad_cpu_acknowledge_int)
26742674{
2675   amstrad_state *state = device->machine().driver_data<amstrad_state>();
26762675   // DMA interrupts can be automatically cleared if bit 0 of &6805 is set to 0
2677   if( state->m_asic.enabled && state->m_plus_irq_cause != 0x06 && state->m_asic.dma_clear & 0x01)
2676   if( m_asic.enabled && m_plus_irq_cause != 0x06 && m_asic.dma_clear & 0x01)
26782677   {
2679      logerror("IRQ: Not cleared, IRQ was called by DMA [%i]\n",state->m_plus_irq_cause);
2680      state->m_asic.ram[0x2c0f] &= ~0x80;  // not a raster interrupt, so this bit is reset
2681      return (state->m_asic.ram[0x2805] & 0xf8) | state->m_plus_irq_cause;
2678      logerror("IRQ: Not cleared, IRQ was called by DMA [%i]\n",m_plus_irq_cause);
2679      m_asic.ram[0x2c0f] &= ~0x80;  // not a raster interrupt, so this bit is reset
2680      return (m_asic.ram[0x2805] & 0xf8) | m_plus_irq_cause;
26822681   }
2683   device->machine().device("maincpu")->execute().set_input_line(0, CLEAR_LINE);
2684   state->m_gate_array.hsync_counter &= 0x1F;
2685   if ( state->m_asic.enabled )
2682   machine().device("maincpu")->execute().set_input_line(0, CLEAR_LINE);
2683   m_gate_array.hsync_counter &= 0x1F;
2684   if ( m_asic.enabled )
26862685   {
2687      if(state->m_plus_irq_cause == 6)  // bit 7 is set "if last interrupt acknowledge cycle was caused by a raster interrupt"
2688         state->m_asic.ram[0x2c0f] |= 0x80;
2686      if(m_plus_irq_cause == 6)  // bit 7 is set "if last interrupt acknowledge cycle was caused by a raster interrupt"
2687         m_asic.ram[0x2c0f] |= 0x80;
26892688      else
26902689      {
2691         state->m_asic.ram[0x2c0f] &= ~0x80;
2692         state->m_asic.ram[0x2c0f] &= (0x40 >> state->m_plus_irq_cause/2);
2690         m_asic.ram[0x2c0f] &= ~0x80;
2691         m_asic.ram[0x2c0f] &= (0x40 >> m_plus_irq_cause/2);
26932692      }
2694      return (state->m_asic.ram[0x2805] & 0xf8) | state->m_plus_irq_cause;
2693      return (m_asic.ram[0x2805] & 0xf8) | m_plus_irq_cause;
26952694   }
26962695   return 0xFF;
26972696}
r20631r20632
28982897      (const UINT8*)amstrad_cycle_table_ex);
28992898
29002899   /* Juergen is a cool dude! */
2901   state->m_maincpu->set_irq_acknowledge_callback(amstrad_cpu_acknowledge_int);
2900   state->m_maincpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(amstrad_state::amstrad_cpu_acknowledge_int),state));
29022901}
29032902
29042903TIMER_CALLBACK_MEMBER(amstrad_state::cb_set_resolution)
trunk/src/mess/machine/bk.c
r20631r20632
7070   machine().scheduler().timer_pulse(attotime::from_hz(2400), timer_expired_delegate(FUNC(bk_state::keyboard_callback),this));
7171}
7272
73static IRQ_CALLBACK(bk0010_irq_callback)
73IRQ_CALLBACK_MEMBER(bk_state::bk0010_irq_callback)
7474{
75   bk_state *state = device->machine().driver_data<bk_state>();
76   device->execute().set_input_line(0, CLEAR_LINE);
77   return state->m_key_irq_vector;
75   device.execute().set_input_line(0, CLEAR_LINE);
76   return m_key_irq_vector;
7877}
7978
8079void bk_state::machine_reset()
8180{
82   machine().device("maincpu")->execute().set_irq_acknowledge_callback(bk0010_irq_callback);
81   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(bk_state::bk0010_irq_callback),this));
8382
8483   m_kbd_state = 0;
8584   m_scrool = 01330;
trunk/src/mess/machine/tf20.c
r20631r20632
182182   m_timer_serial = timer_alloc(0, NULL);
183183   m_timer_tc = timer_alloc(1, NULL);
184184
185   m_cpu->set_irq_acknowledge_callback(irq_callback);
185   m_cpu->set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(epson_tf20_device::irq_callback),this));
186186
187187   m_fd0 = subdevice<floppy_connector>("5a:0")->get_device();
188188   m_fd1 = subdevice<floppy_connector>("5a:1")->get_device();
r20631r20632
237237//  irq vector callback
238238//-------------------------------------------------
239239
240IRQ_CALLBACK( epson_tf20_device::irq_callback )
240IRQ_CALLBACK_MEMBER( epson_tf20_device::irq_callback )
241241{
242242   return 0x00;
243243}
trunk/src/mess/machine/tf20.h
r20631r20632
4242   DECLARE_READ8_MEMBER( rom_disable_r );
4343   DECLARE_READ8_MEMBER( upd765_tc_r );
4444   DECLARE_WRITE8_MEMBER( fdc_control_w );
45   static IRQ_CALLBACK( irq_callback );
45   IRQ_CALLBACK_MEMBER( irq_callback );
4646
4747   void fdc_irq(bool state);
4848
trunk/src/mess/machine/mc80.c
r20631r20632
1313/*                            Implementation for MC80.2x                     */
1414/*****************************************************************************/
1515
16static IRQ_CALLBACK( mc8020_irq_callback )
16IRQ_CALLBACK_MEMBER(mc80_state::mc8020_irq_callback)
1717{
1818   return 0x00;
1919}
2020
2121MACHINE_RESET_MEMBER(mc80_state,mc8020)
2222{
23   machine().device("maincpu")->execute().set_irq_acknowledge_callback(mc8020_irq_callback);
23   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(mc80_state::mc8020_irq_callback),this));
2424}
2525
2626WRITE_LINE_MEMBER( mc80_state::ctc_z0_w )
r20631r20632
107107{
108108}
109109
110static IRQ_CALLBACK( mc8030_irq_callback )
110IRQ_CALLBACK_MEMBER(mc80_state::mc8030_irq_callback )
111111{
112112   return 0x20;
113113}
114114
115115MACHINE_RESET_MEMBER(mc80_state,mc8030)
116116{
117   machine().device("maincpu")->execute().set_irq_acknowledge_callback(mc8030_irq_callback);
117   machine().device("maincpu")->execute().set_irq_acknowledge_callback(device_irq_acknowledge_delegate(FUNC(mc80_state::mc8030_irq_callback),this));
118118}
119119
120120READ8_MEMBER( mc80_state::zve_port_a_r )
trunk/src/mess/includes/cbm2.h
r20631r20632
206206   DECLARE_READ8_MEMBER( ext_cia_pb_r );
207207   DECLARE_WRITE8_MEMBER( ext_cia_pb_w );
208208
209   IRQ_CALLBACK_MEMBER(pic_irq_callback);
210
209211   // memory state
210212   int m_dramon;
211213   int m_busen1;
trunk/src/mess/includes/vidbrain.h
r20631r20632
9797   DECLARE_WRITE_LINE_MEMBER( ext_int_w );
9898   DECLARE_WRITE_LINE_MEMBER( hblank_w );
9999
100   IRQ_CALLBACK_MEMBER(vidbrain_int_ack);
101
100102   void interrupt_check();
101103
102104   // F3853 SMI state
trunk/src/mess/includes/bk.h
r20631r20632
3838   virtual void video_start();
3939   UINT32 screen_update_bk0010(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
4040   TIMER_CALLBACK_MEMBER(keyboard_callback);
41   IRQ_CALLBACK_MEMBER(bk0010_irq_callback);
4142};
4243
4344#endif /* BK_H_ */
trunk/src/mess/includes/mc80.h
r20631r20632
4646   UINT32 screen_update_mc8030(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
4747   TIMER_DEVICE_CALLBACK_MEMBER(mc8020_kbd);
4848   DECLARE_WRITE_LINE_MEMBER(ctc_z2_w);
49   IRQ_CALLBACK_MEMBER(mc8020_irq_callback);
50   IRQ_CALLBACK_MEMBER(mc8030_irq_callback);
4951};
5052
5153
trunk/src/mess/includes/atarist.h
r20631r20632
315315   TIMER_CALLBACK_MEMBER(atarist_shifter_tick);
316316   TIMER_CALLBACK_MEMBER(atarist_glue_tick);
317317   TIMER_CALLBACK_MEMBER(atarist_blitter_tick);
318   IRQ_CALLBACK_MEMBER(atarist_int_ack);   
318319};
319320
320321class megast_state : public st_state
r20631r20632
370371
371372   TIMER_CALLBACK_MEMBER(atariste_dmasound_tick);
372373   TIMER_CALLBACK_MEMBER(atariste_microwire_tick);
373
374   
374375   void dmasound_set_state(int level);
375376   void dmasound_tick();
376377   void microwire_shift();
trunk/src/mess/includes/wangpc.h
r20631r20632
165165   DECLARE_WRITE_LINE_MEMBER( bus_irq2_w );
166166
167167   DECLARE_FLOPPY_FORMATS( floppy_formats );
168   
169   IRQ_CALLBACK_MEMBER(wangpc_irq_callback);
168170
169171   void fdc_irq(bool state);
170172   void fdc_drq(bool state);
trunk/src/mess/includes/apricotp.h
r20631r20632
112112   // video state
113113   optional_shared_ptr<UINT16> m_video_ram;
114114   UINT8 m_video;
115   IRQ_CALLBACK_MEMBER(fp_irq_callback);
115116};
116117
117118
trunk/src/mess/includes/vixen.h
r20631r20632
133133
134134   DECLARE_DRIVER_INIT(vixen);
135135   TIMER_DEVICE_CALLBACK_MEMBER(vsync_tick);
136   IRQ_CALLBACK_MEMBER(vixen_int_ack);
136137};
137138
138139#endif
trunk/src/mess/includes/victor9k.h
r20631r20632
127127   int m_side;                         /* selected side */
128128   DECLARE_WRITE_LINE_MEMBER(mux_serial_b_w);
129129   DECLARE_WRITE_LINE_MEMBER(mux_serial_a_w);
130   IRQ_CALLBACK_MEMBER(victor9k_irq_callback);
130131};
131132
132133#endif
trunk/src/mess/includes/compis.h
r20631r20632
187187   INTERRUPT_GEN_MEMBER(compis_vblank_int);
188188   TIMER_CALLBACK_MEMBER(internal_timer_int);
189189   TIMER_CALLBACK_MEMBER(dma_timer_callback);
190   IRQ_CALLBACK_MEMBER(int_callback);
191   IRQ_CALLBACK_MEMBER(compis_irq_callback);
190192};
191193
192194
trunk/src/mess/includes/amstrad.h
r20631r20632
189189   void aleste_interrupt(bool state);
190190
191191   DECLARE_FLOPPY_FORMATS( floppy_formats );
192   
193   IRQ_CALLBACK_MEMBER(amstrad_cpu_acknowledge_int);
192194};
193195
194196
trunk/src/mess/includes/portfoli.h
r20631r20632
111111   TIMER_DEVICE_CALLBACK_MEMBER(system_tick);
112112   TIMER_DEVICE_CALLBACK_MEMBER(counter_tick);
113113   DECLARE_READ8_MEMBER(hd61830_rd_r);
114   IRQ_CALLBACK_MEMBER(portfolio_int_ack);
114115};
115116
116117#endif
trunk/src/mess/includes/abc1600.h
r20631r20632
157157   DECLARE_WRITE8_MEMBER( cio_pc_w );
158158
159159   DECLARE_WRITE_LINE_MEMBER( nmi_w );
160   
161   IRQ_CALLBACK_MEMBER( abc1600_int_ack );
160162
161163   void fdc_intrq_w(bool state);
162164   void fdc_drq_w(bool state);
trunk/src/mess/includes/pc1512.h
r20631r20632
160160   DECLARE_INPUT_CHANGED_MEMBER( mouse_x_changed );
161161   DECLARE_INPUT_CHANGED_MEMBER( mouse_y_changed );
162162   DECLARE_FLOPPY_FORMATS( floppy_formats );
163   IRQ_CALLBACK_MEMBER(pc1512_irq_callback);
163164
164165   // system status register
165166   int m_pit1;
trunk/src/mess/includes/rmnimbus.h
r20631r20632
467467   DECLARE_WRITE_LINE_MEMBER(nimbus_scsi_msg_w);
468468   DECLARE_WRITE_LINE_MEMBER(nimbus_scsi_req_w);
469469   void nimbus_scsi_linechange( UINT8 mask, UINT8 state );
470   IRQ_CALLBACK_MEMBER(int_callback);
470471};
trunk/src/mess/includes/v1050.h
r20631r20632
184184   DECLARE_WRITE8_MEMBER(m6502_ppi_pc_w);
185185   DECLARE_WRITE8_MEMBER(misc_ppi_pb_w);
186186   DECLARE_READ8_MEMBER(misc_ppi_pc_r);
187   IRQ_CALLBACK_MEMBER(v1050_int_ack);
187188};
188189
189190//----------- defined in video/v1050.c -----------
trunk/src/mess/includes/trs80m2.h
r20631r20632
125125   int m_rtc_int;
126126   int m_enable_rtc_int;
127127
128   TIMER_DEVICE_CALLBACK_MEMBER(ctc_tick);
128   TIMER_DEVICE_CALLBACK_MEMBER(ctc_tick);   
129129};
130130
131131class trs80m16_state : public trs80m2_state
r20631r20632
144144
145145   DECLARE_WRITE8_MEMBER( ual_w );
146146   DECLARE_WRITE8_MEMBER( tcl_w );
147   
148   IRQ_CALLBACK_MEMBER(trs80m16_irq_callback);
147149
148150   UINT16 m_ual;
149151   UINT8 m_limit[2];

Previous 199869 Revisions Next

© 1997-2024 The MAME Team