Previous

199869 Revisions

Next

r17815 Wednesday 12th September, 2012 at 06:07:51 UTC by Aaron Giles
Clear out remaining global inlines in diexec.h.

[src/emu]	diexec.c diexec.h
[src/emu/cpu/cp1610]	cp1610.c
[src/emu/cpu/i386]	i386.c x87ops.c
[src/emu/cpu/i86]	instr286.c
[src/emu/cpu/jaguar]	jaguar.c
[src/emu/cpu/m37710]	m37710.c
[src/emu/cpu/m6502]	m6502.h m6509.h
[src/emu/cpu/m68000]	m68kcpu.c
[src/emu/cpu/mips]	mips3com.c
[src/emu/cpu/sh4]	sh4comn.c
[src/emu/cpu/tms34010]	34010ops.c tms34010.c
[src/emu/cpu/tms7000]	tms7000.c
[src/emu/machine]	8042kbdc.c k056230.c tmp68301.c
[src/emu/sound]	scsp.c
[src/emu/video]	voodoo.c
[src/mame/audio]	aztarac.c beezer.c cage.c dcs.c decobsmt.c dsbz80.c exidy.c harddriv.c leland.c namco52.c namco54.c scramble.c segasnd.c seibu.c t5182.c taito_en.c taitosnd.c timeplt.c trackfld.c
[src/mame/drivers]	1942.c 20pacgal.c 2mindril.c 3do.c 40love.c 88games.c acefruit.c aces1.c actfancr.c adp.c aeroboto.c aerofgt.c airbustr.c aliens.c alpha68k.c amaticmg.c amspdwy.c angelkds.c appoooh.c aquarium.c ashnojoe.c asterix.c astinvad.c astrof.c asuka.c atarifb.c avt.c aztarac.c backfire.c bagman.c bankp.c battlane.c battlex.c battlnts.c bbusters.c beaminv.c beathead.c beezer.c bfcobra.c bfm_sc5.c bigevglf.c bingor.c bishi.c bking.c bladestl.c blktiger.c blockade.c blockhl.c blockout.c blueprnt.c bnstars.c bombjack.c boogwing.c bottom9.c boxer.c brkthru.c btime.c bublbobl.c buggychl.c bwing.c byvid.c bzone.c cabal.c cabaret.c calchase.c capbowl.c carjmbre.c cave.c cball.c cbuster.c ccastles.c cclimber.c cesclass.c champbas.c chanbara.c cheekyms.c chihiro.c chinagat.c chqflag.c circus.c circusc.c citycon.c cloud9.c cmmb.c cninja.c cntsteer.c cobra.c coinmvga.c combatsc.c commando.c contra.c coolpool.c coolridr.c cop01.c cps1.c cps2.c cps3.c crbaloon.c crgolf.c crimfght.c crospang.c crystal.c csplayh5.c cubeqst.c cultures.c cvs.c cyclemb.c dacholer.c darius.c dassault.c dblewing.c dbz.c dcheese.c ddayjlc.c ddealer.c ddenlovr.c ddragon.c ddragon3.c ddribble.c dec8.c deco156.c deco32.c deco_ld.c deco_mlc.c deniam.c deshoros.c destroyr.c dfruit.c dgpix.c dietgo.c discoboy.c diverboy.c djboy.c djmain.c dkong.c dogfgt.c drgnmst.c dribling.c drmicro.c dwarfd.c dynax.c dynduke.c egghunt.c enigma2.c eolithsp.c eprom.c equites.c esd16.c esh.c espial.c ettrivia.c exerion.c exprraid.c f1gp.c fantland.c fastfred.c fastlane.c fcombat.c fcrash.c fgoal.c finalizr.c firebeat.c firetrap.c firetrk.c fitfight.c flipjack.c flkatck.c flstory.c flyball.c freekick.c fromanc2.c fromance.c funkball.c funkyjet.c funybubl.c fuukifg2.c fuukifg3.c gaelco.c gaelco3d.c gaiden.c galaga.c galastrm.c galaxia.c galaxian.c galaxold.c galgame.c galpani2.c galpani3.c galspnbl.c gamecstl.c gameplan.c gbusters.c gcpinbal.c gei.c ghosteo.c gijoe.c ginganin.c glass.c go2000.c goal92.c goldstar.c goodejan.c gotcha.c gottlieb.c gpworld.c gradius3.c grchamp.c groundfx.c gsword.c gticlub.c gunbustr.c gunpey.c gyruss.c hcastle.c highvdeo.c himesiki.c hitpoker.c hng64.c homedata.c hotblock.c hvyunit.c hyperspt.c hyprduel.c igs009.c igs011.c igs017.c igspoker.c ikki.c imolagp.c inufuku.c iqblock.c ironhors.c istellar.c itech32.c jack.c jackal.c jackie.c jackpool.c jaguar.c jailbrek.c jangou.c jchan.c jclub2.c jollyjgr.c jrpacman.c jubilee.c junofrst.c kaneko16.c karnov.c kas89.c kchamp.c kingobox.c kingpin.c kinst.c kncljoe.c koftball.c konamigx.c konamim2.c kontest.c kopunch.c kungfur.c kyugo.c labyrunr.c ladybug.c ladyfrog.c laserbat.c lasso.c lastbank.c lastduel.c lastfght.c lazercmd.c lemmings.c lethal.c lgp.c liberate.c littlerb.c lkage.c lockon.c looping.c lsasquad.c lucky74.c lwings.c m10.c m14.c m63.c m72.c m79amb.c m90.c m92.c macrossp.c madmotor.c magicard.c magictg.c magtouch.c mainevt.c marineb.c mario.c mastboy.c matmania.c mayumi.c mazerbla.c mcatadv.c mcr68.c meadows.c mediagx.c megaplay.c megasys1.c megazone.c meijinsn.c mermaid.c metalmx.c metlclsh.c metro.c mexico86.c mgolf.c midqslvr.c midvunit.c midzeus.c mikie.c mirax.c missb2.c missile.c mitchell.c mjkjidai.c mjsister.c model1.c model2.c mogura.c moo.c mouser.c mrflea.c ms32.c msisaac.c mugsmash.c munchmo.c mustache.c mystwarr.c n8080.c namcofl.c namcona1.c namconb1.c namcos1.c namcos11.c namcos21.c namcos22.c namcos23.c nemesis.c neogeo.c nightgal.c ninjakd2.c ninjaw.c niyanpai.c nmg5.c nsmpoker.c nss.c nycaptor.c nyny.c ojankohs.c oneshot.c onetwo.c opwolf.c orbit.c othello.c othunder.c overdriv.c pacman.c pandoras.c pangofun.c parodius.c pasha2.c pastelg.c pbaction.c pcat_dyn.c pcat_nit.c pcxt.c pengo.c pgm.c photon.c photon2.c photoply.c pingpong.c pipedrm.c pitnrun.c pktgaldx.c playch10.c playmark.c plygonet.c pntnpuzl.c polepos.c policetr.c polyplay.c pooyan.c popeye.c popobear.c popper.c psikyo.c psikyo4.c psikyosh.c pturn.c punchout.c pushman.c qdrmfgp.c quakeat.c quasar.c queen.c r2dx_v33.c raiden.c raiden2.c rainbow.c rallyx.c rastan.c redalert.c redclash.c renegade.c retofinv.c rltennis.c rockrage.c rocnrope.c rohga.c rollerg.c rollrace.c rotaryf.c route16.c royalmah.c rungun.c sandscrp.c saturn.c sauro.c savquest.c sbasketb.c sbowling.c scotrsht.c scregg.c seattle.c seibuspi.c seicross.c sengokmj.c senjyo.c seta.c seta2.c sf.c sfcbox.c shanghai.c shaolins.c sigmab98.c silvmil.c simpl156.c simpsons.c skimaxx.c skyarmy.c skydiver.c skyfox.c skykid.c skylncr.c slapfght.c slapshot.c sliver.c snk6502.c snowbros.c solomon.c sonson.c spcforce.c splash.c spoker.c sprcros2.c sprint2.c spy.c srumbler.c ssfindo.c ssozumo.c ssv.c st0016.c stactics.c statriv2.c strnskil.c su2000.c subsino2.c suna16.c suna8.c supbtime.c superchs.c superdq.c superqix.c supertnk.c superwng.c suprloco.c suprnova.c suprridr.c suprslam.c surpratk.c system1.c system16.c tagteam.c tail2nos.c taito_b.c taito_f2.c taito_f3.c taito_h.c taito_l.c taito_o.c taito_z.c taitoair.c taitojc.c taitotz.c taitowlf.c tankbatt.c tankbust.c targeth.c tasman.c tatsumi.c tceptor.c tetrisp2.c thedeep.c thepit.c thief.c thunderx.c timelimt.c timeplt.c timetrv.c tmaster.c tmnt.c tmspoker.c tnzs.c toaplan2.c tomcat.c topspeed.c toratora.c toypop.c tp84.c trackfld.c trucocl.c trvquest.c tsamurai.c ttchamp.c tumbleb.c tumblep.c turbo.c tutankhm.c twin16.c twinkle.c tx1.c ultraman.c ultrsprt.c undrfire.c unkhorse.c vamphalf.c vaportra.c vastar.c vcombat.c vegas.c vendetta.c volfied.c voyager.c vulgus.c warpwarp.c warriorb.c wgp.c wheelfir.c whitestar.c wiping.c witch.c wiz.c xexex.c xmen.c xtom3d.c xxmissio.c yiear.c yunsun16.c yunsung8.c zac_1.c zaccaria.c zaxxon.c zerozone.c zn.c zodiack.c zr107.c
[src/mame/includes]	1942.h 20pacgal.h 40love.h 88games.h actfancr.h aerofgt.h airbustr.h ajax.h aliens.h alpha68k.h amspdwy.h angelkds.h aquarium.h ashnojoe.h asterix.h astrof.h asuka.h atarifb.h battlane.h battlnts.h beezer.h bigevglf.h bishi.h bking.h bladestl.h blktiger.h blockhl.h blockout.h blueprnt.h bottom9.h brkthru.h btime.h bublbobl.h buggychl.h bwing.h capbowl.h cave.h cbuster.h champbas.h cheekyms.h chqflag.h circus.h citycon.h commando.h contra.h coolpool.h cps1.h crgolf.h crimfght.h crospang.h cvs.h darius.h dbz.h dcheese.h ddragon.h ddragon3.h dec8.h dietgo.h djboy.h dogfgt.h dynax.h espial.h exerion.h exprraid.h f1gp.h fcombat.h fgoal.h firetrap.h flkatck.h flstory.h fromanc2.h fromance.h funkyjet.h funybubl.h fuukifg2.h fuukifg3.h gaelco.h gaiden.h galspnbl.h gameplan.h gbusters.h gijoe.h ginganin.h goal92.h gotcha.h gradius3.h hcastle.h himesiki.h homedata.h hyprduel.h inufuku.h ironhors.h jackal.h karnov.h kchamp.h kncljoe.h kopunch.h kyugo.h ladybug.h ladyfrog.h lasso.h lemmings.h lethal.h liberate.h lkage.h lockon.h lsasquad.h m10.h macrossp.h madmotor.h mainevt.h marineb.h matmania.h mcatadv.h mermaid.h metlclsh.h mexico86.h moo.h mouser.h mrflea.h msisaac.h mugsmash.h munchmo.h n8080.h neogeo.h ninjaw.h nitedrvr.h nycaptor.h ojankohs.h oneshot.h orbit.h othunder.h overdriv.h parodius.h pbaction.h pktgaldx.h popper.h psikyo.h psikyo4.h psikyosh.h pushman.h rainbow.h rastan.h rltennis.h rockrage.h rollerg.h rungun.h sf.h simpsons.h skyfox.h slapshot.h sonson.h spy.h supbtime.h suprslam.h surpratk.h system16.h tail2nos.h taito_b.h taito_f2.h taito_h.h taito_l.h taito_o.h taito_z.h taitoair.h thunderx.h tmnt.h tnzs.h topspeed.h tumbleb.h tumblep.h ultraman.h vaportra.h vendetta.h volfied.h warriorb.h wgp.h xexex.h xmen.h yunsun16.h yunsung8.h
[src/mame/machine]	ajax.c amiga.c asic65.c asteroid.c atarigen.c bigevglf.c bublbobl.c buggychl.c cdi070.c cdicdic.c cdislave.c dec0.c decocass.c decocass.h docastle.c fd1094.c flstory.c gaelco2.c galaxold.c harddriv.c konppc.c leland.c lkage.c lsasquad.c mega32x.c megacd.c megadriv.c megasvp.c megavdp.c mexico86.c midwunit.c model1.c mw8080bw.c n64.c namco06.c namco50.c namco53.c namcos2.c naomi.c nb1413m3.c nitedrvr.c nycaptor.c pgmprot2.c pgmprot3.c playch10.c scudsp.c simpsons.c slapfght.c smpc.c snes.c stfight.c subs.c tnzs.c toaplan1.c twincobr.c vsnes.c xevious.c
[src/mame/video]	1942.c antic.c arkanoid.c astrocde.c atari.c battlera.c beezer.c bfm_adr2.c bfm_dm01.c blktiger.c blockade.c capbowl.c circus.c commando.c dec8.c decocass.c exidy.c fromance.c gameplan.c ginganin.c gticlub.c homedata.c konicdev.c liberate.c lockon.c mcd212.c nemesis.c ppu2c0x.c rltennis.c spdodgeb.c system1.c taito_z.c tia.c tmnt.c williams.c zaxxon.c
[src/mess/drivers]	abc1600.c adam.c alphatro.c apollo.c apple2.c apple2gs.c apricot.c apricotp.c atarist.c avigo.c bml3.c bw2.c cat.c cxhumax.c d6800.c dc.c dmv.c eacc.c elwro800.c enterp.c esq5505.c exelv.c fidelz80.c fk1.c fm7.c fmtowns.c gba.c geneve.c gp32.c h8.c h89.c homelab.c homez80.c iq151.c jr200.c kyocera.c m20.c m5.c mac.c micronic.c mikromik.c mirage.c mk1.c mod8.c mstation.c multi16.c mz2500.c nakajies.c ng_aes.c ngp.c ondra.c osbexec.c paso1600.c pasogo.c pc100.c pc1512.c pc6001.c pc8801.c pc88va.c pc9801.c pce220.c pcfx.c pcw.c pdp1.c pegasus.c pk8000.c pockstat.c portfoli.c prestige.c pv1000.c pv2000.c pyl601.c ql.c qx10.c rainbow.c rex6000.c samcoupe.c sm1800.c smc777.c socrates.c spectrum.c supracan.c svision.c tandy2k.c tek405x.c ti99_2.c ti99_4p.c trs80m2.c tsispch.c tvc.c v1050.c vboy.c victor9k.c vidbrain.c vixen.c vk100.c vt100.c vt240.c wangpc.c x07.c x1.c x1twin.c x68k.c xerox820.c xor100.c z100.c
[src/mess/includes]	fmtowns.h nes.h pc.h
[src/mess/machine]	a2bus.c a2bus.h a2eauxslot.c a2eauxslot.h a2softcard.c a2themill.c abc77.c abc99.c advision.c amigacrt.c amstrad.c at.c b2m.c bbc.c bk.c c64_cpm.c compis.c cuda.c dec_lk201.c dgn_beta.c ecbbus.c ecbbus.h egret.c galaxy.c genpc.c hd63450.c i82371ab.c i82371sb.c intv.c isa.c isa.h kb_keytro.c kc_d004.c lisa.c mac.c macpci.c mbc55x.c mboard.c mc68328.c mc80.c mpc105.c mpc105.h msx.c nes.c nes_ines.c nes_pcb.c nubus.c nubus.h orion.c pc.c pc1512kb.c pet.c pk8020.c poly88.c primo.c rmnimbus.c s100.c s100.h sms.c southbridge.c svi318.c tf20.c ti85.c trs80.c vector06.c x68k_neptunex.c zx.c
[src/mess/machine/ti99]	spchsyn.c speech8.c
[src/mess/video]	a7800.c atarist.c mac.c mos6566.c v1050.c vic6567.c zx8301.c

trunk/src/mame/audio/cage.c

r17814	r17815
209	209	cage_t *sndstate = &cage;
210	210	if (state)
211	211	cage_control_w(space->machine(), 0);
212		device_set_input_line(sndstate->cpu, INPUT_LINE_RESET, state ? ASSERT_LINE : CLEAR_LINE);
	212	sndstate->cpu->set_input_line(INPUT_LINE_RESET, state ? ASSERT_LINE : CLEAR_LINE);
213	213	}
214	214
215	215
r17814	r17815
241	241	tms32031_io_regs[DMA_SOURCE_ADDR] = param;
242	242
243	243	/* set the interrupt */
244		device_set_input_line(state->cpu, TMS3203X_DINT, ASSERT_LINE);
	244	state->cpu->set_input_line(TMS3203X_DINT, ASSERT_LINE);
245	245	state->dma_enabled = 0;
246	246	}
247	247
r17814	r17815
314	314	int which = param;
315	315
316	316	/* set the interrupt */
317		device_set_input_line(state->cpu, TMS3203X_TINT0 + which, ASSERT_LINE);
	317	state->cpu->set_input_line(TMS3203X_TINT0 + which, ASSERT_LINE);
318	318	state->timer_enabled[which] = 0;
319	319	update_timer(which);
320	320	}
r17814	r17815
509	509	logerror("%06X:CAGE read command = %04X\n", space->device().safe_pc(), state->from_main);
510	510	state->cpu_to_cage_ready = 0;
511	511	update_control_lines(space->machine());
512		device_set_input_line(state->cpu, TMS3203X_IRQ0, CLEAR_LINE);
	512	state->cpu->set_input_line(TMS3203X_IRQ0, CLEAR_LINE);
513	513	return state->from_main;
514	514	}
515	515
r17814	r17815
566	566	state->from_main = param;
567	567	state->cpu_to_cage_ready = 1;
568	568	update_control_lines(machine);
569		device_set_input_line(state->cpu, TMS3203X_IRQ0, ASSERT_LINE);
	569	state->cpu->set_input_line(TMS3203X_IRQ0, ASSERT_LINE);
570	570	}
571	571
572	572
r17814	r17815
602	602	/* CPU is reset if both control lines are 0 */
603	603	if (!(state->control & 3))
604	604	{
605		device_set_input_line(state->cpu, INPUT_LINE_RESET, ASSERT_LINE);
	605	state->cpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
606	606
607	607	state->dma_enabled = 0;
608	608	state->dma_timer_enabled = 0;
r17814	r17815
619	619	state->cage_to_cpu_ready = 0;
620	620	}
621	621	else
622		device_set_input_line(state->cpu, INPUT_LINE_RESET, CLEAR_LINE);
	622	state->cpu->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
623	623
624	624	/* update the control state */
625	625	update_control_lines(machine);
r17814	r17815
637	637	{
638	638	cage_t *state = &cage;
639	639
640		device_eat_cycles(&space->device(), 100);
	640	space->device().execute().eat_cycles(100);
641	641	COMBINE_DATA(&state->speedup_ram[offset]);
642	642	}
643	643

trunk/src/mame/audio/namco52.c

r17814	r17815
135	135	static TIMER_CALLBACK( namco_52xx_irq_clear )
136	136	{
137	137	namco_52xx_state *state = get_safe_token((device_t *)ptr);
138		device_set_input_line(state->m_cpu, 0, CLEAR_LINE);
	138	state->m_cpu->execute().set_input_line(0, CLEAR_LINE);
139	139	}
140	140
141	141	WRITE8_DEVICE_HANDLER( namco_52xx_write )
r17814	r17815
144	144
145	145	device->machine().scheduler().synchronize(FUNC(namco_52xx_latch_callback), data, (void *)device);
146	146
147		device_set_input_line(state->m_cpu, 0, ASSERT_LINE);
	147	state->m_cpu->execute().set_input_line(0, ASSERT_LINE);
148	148
149	149	// The execution time of one instruction is ~4us, so we must make sure to
150	150	// give the cpu time to poll the /IRQ input before we clear it.

trunk/src/mame/audio/segasnd.c

r17814	r17815
447	447	usb_state *usb = get_safe_token(device);
448	448
449	449	/* halt the USB CPU at reset time */
450		device_set_input_line(usb->cpu, INPUT_LINE_RESET, ASSERT_LINE);
	450	usb->cpu->execute().set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
451	451
452	452	/* start the clock timer */
453	453	usb->t1_clock_mask = 0x10;
r17814	r17815
467	467
468	468	LOG(("%04X:usb_data_r = %02X\n", usb->maincpu->safe_pc(), (usb->out_latch & 0x81) | (usb->in_latch & 0x7e)));
469	469
470		device_adjust_icount(usb->maincpu, -200);
	470	usb->maincpu->execute().adjust_icount(-200);
471	471
472	472	/* only bits 0 and 7 are controlled by the I8035; the remaining */
473	473	/* bits 1-6 reflect the current input latch values */
r17814	r17815
481	481	int data = param;
482	482
483	483	/* look for rising/falling edges of bit 7 to control the RESET line */
484		device_set_input_line(usb->cpu, INPUT_LINE_RESET, (data & 0x80) ? ASSERT_LINE : CLEAR_LINE);
	484	usb->cpu->execute().set_input_line(INPUT_LINE_RESET, (data & 0x80) ? ASSERT_LINE : CLEAR_LINE);
485	485
486	486	/* if the CLEAR line is set, the low 7 bits of the input are ignored */
487	487	if ((usb->last_p2_value & 0x40) == 0)

trunk/src/mame/audio/taitosnd.c

r17814	r17815
59	59
60	60	if (tc0140syt->nmi_req && tc0140syt->nmi_enabled)
61	61	{
62		device_set_input_line(tc0140syt->slavecpu, INPUT_LINE_NMI, PULSE_LINE);
	62	tc0140syt->slavecpu->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
63	63	tc0140syt->nmi_req = 0;
64	64	}
65	65	}
r17814	r17815
113	113	//logerror("taitosnd: Master issued control value %02x (PC = %08x) \n",data, space->device().safe_pc() );
114	114	/* this does a hi-lo transition to reset the sound cpu */
115	115	if (data)
116		device_set_input_line(tc0140syt->slavecpu, INPUT_LINE_RESET, ASSERT_LINE);
	116	tc0140syt->slavecpu->execute().set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
117	117	else
118	118	{
119		device_set_input_line(tc0140syt->slavecpu, INPUT_LINE_RESET, CLEAR_LINE);
120		device_spin(tc0140syt->mastercpu); /* otherwise no sound in driftout */
	119	tc0140syt->slavecpu->execute().set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
	120	tc0140syt->mastercpu->execute().spin(); /* otherwise no sound in driftout */
121	121	}
122	122	break;
123	123
r17814	r17815
191	191	tc0140syt->masterdata[tc0140syt->submode ++] = data;
192	192	tc0140syt->status |= TC0140SYT_PORT01_FULL_MASTER;
193	193	//logerror("taitosnd: Slave cpu sends 0/1 : %01x%01x\n" , tc0140syt->masterdata[1] , tc0140syt->masterdata[0]);
194		device_spin(tc0140syt->slavecpu); /* writing should take longer than emulated, so spin */
	194	tc0140syt->slavecpu->execute().spin(); /* writing should take longer than emulated, so spin */
195	195	break;
196	196
197	197	case 0x02:      // mode #2
r17814	r17815
203	203	tc0140syt->masterdata[tc0140syt->submode ++] = data;
204	204	tc0140syt->status |= TC0140SYT_PORT23_FULL_MASTER;
205	205	//logerror("taitosnd: Slave cpu sends 2/3 : %01x%01x\n" , tc0140syt->masterdata[3] , tc0140syt->masterdata[2]);
206		device_spin(tc0140syt->slavecpu); /* writing should take longer than emulated, so spin */
	206	tc0140syt->slavecpu->execute().spin(); /* writing should take longer than emulated, so spin */
207	207	break;
208	208
209	209	case 0x04:      // port status

trunk/src/mame/audio/leland.c

r17814	r17815
778	778	if (LOG_INTERRUPTS) logerror("(%f) **** Acknowledged interrupt vector %02X\n", device->machine().time().as_double(), state->m_i80186.intr.poll_status & 0x1f);
779	779
780	780	/* clear the interrupt */
781		device_set_input_line(state->m_i80186.cpu, 0, CLEAR_LINE);
	781	state->m_i80186.cpu->execute().set_input_line(0, CLEAR_LINE);
782	782	state->m_i80186.intr.pending = 0;
783	783
784	784	/* clear the request and set the in-service bit */
r17814	r17815
1603	1603	/* we need to do this at a time when the 80186 context is swapped in */
1604	1604	/* this register is generally set once at startup and never again, so it's a good */
1605	1605	/* time to set it up */
1606		device_set_irq_callback(state->m_i80186.cpu, int_callback);
	1606	state->m_i80186.cpu->execute().set_irq_acknowledge_callback(int_callback);
1607	1607	break;
1608	1608
1609	1609	case 0xc0/2:

trunk/src/mame/audio/taito_en.c

r17814	r17815
267	267	{
268	268	if (state == ASSERT_LINE)
269	269	{
270		device_set_input_line_vector(device->machine().device("audiocpu"), M68K_IRQ_6, vector);
271		device_set_input_line(device->machine().device("audiocpu"), M68K_IRQ_6, ASSERT_LINE);
	270	device->machine().device("audiocpu")->execute().set_input_line_vector(M68K_IRQ_6, vector);
	271	device->machine().device("audiocpu")->execute().set_input_line(M68K_IRQ_6, ASSERT_LINE);
272	272	}
273	273	else
274	274	{
275		device_set_input_line(device->machine().device("audiocpu"), M68K_IRQ_6, CLEAR_LINE);
	275	device->machine().device("audiocpu")->execute().set_input_line(M68K_IRQ_6, CLEAR_LINE);
276	276	}
277	277	}
278	278

trunk/src/mame/audio/seibu.c

r17814	r17815
289	289	}
290	290
291	291	if ((irq1 & irq2) == 0xff)   /* no IRQs pending */
292		device_set_input_line(sound_cpu,0,CLEAR_LINE);
	292	sound_cpu->execute().set_input_line(0,CLEAR_LINE);
293	293	else   /* IRQ pending */
294		device_set_input_line_and_vector(sound_cpu,0,ASSERT_LINE,irq1 & irq2);
	294	sound_cpu->execute().set_input_line_and_vector(0,ASSERT_LINE,irq1 & irq2);
295	295	}
296	296
297	297	WRITE8_HANDLER( seibu_irq_clear_w )

trunk/src/mame/audio/scramble.c

r17814	r17815
163	163
164	164	void scramble_sh_init(running_machine &machine)
165	165	{
166		device_set_irq_callback(machine.device("audiocpu"), scramble_sh_irq_callback);
	166	machine.device("audiocpu")->execute().set_irq_acknowledge_callback(scramble_sh_irq_callback);
167	167
168	168	/* PR is always 0, D is always 1 */
169	169	machine.device<ttl7474_device>("konami_7474")->d_w(1);

trunk/src/mame/audio/dcs.c

r17814	r17815
796	796	/* rev 3/4: HALT the ADSP-2181 until program is downloaded via IDMA */
797	797	case 3:
798	798	case 4:
799		device_set_input_line(dcs.cpu, INPUT_LINE_HALT, ASSERT_LINE);
	799	dcs.cpu->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
800	800	dcs.dsio.start_on_next_write = 0;
801	801	break;
802	802	}
r17814	r17815
849	849	memset(dcs.control_regs, 0, sizeof(dcs.control_regs));
850	850
851	851	/* clear all interrupts */
852		device_set_input_line(dcs.cpu, ADSP2105_IRQ0, CLEAR_LINE);
853		device_set_input_line(dcs.cpu, ADSP2105_IRQ1, CLEAR_LINE);
854		device_set_input_line(dcs.cpu, ADSP2105_IRQ2, CLEAR_LINE);
	852	dcs.cpu->set_input_line(ADSP2105_IRQ0, CLEAR_LINE);
	853	dcs.cpu->set_input_line(ADSP2105_IRQ1, CLEAR_LINE);
	854	dcs.cpu->set_input_line(ADSP2105_IRQ2, CLEAR_LINE);
855	855
856	856	/* initialize the comm bits */
857	857	SET_INPUT_EMPTY();
r17814	r17815
1477	1477	if (dsio.start_on_next_write && --dsio.start_on_next_write == 0)
1478	1478	{
1479	1479	logerror("Starting DSIO CPU\n");
1480		device_set_input_line(dcs.cpu, INPUT_LINE_HALT, CLEAR_LINE);
	1480	dcs.cpu->set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
1481	1481	}
1482	1482	}
1483	1483
r17814	r17815
1529	1529
1530	1530	/* just run through the init code again */
1531	1531	machine.scheduler().synchronize(FUNC(dcs_reset));
1532		device_set_input_line(dcs.cpu, INPUT_LINE_RESET, ASSERT_LINE);
	1532	dcs.cpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
1533	1533	}
1534	1534
1535	1535	/* going low resets and reactivates the CPU */
1536	1536	else
1537		device_set_input_line(dcs.cpu, INPUT_LINE_RESET, CLEAR_LINE);
	1537	dcs.cpu->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
1538	1538	}
1539	1539
1540	1540
r17814	r17815
1576	1576	machine.scheduler().boost_interleave(attotime::from_nsec(500), attotime::from_usec(5));
1577	1577
1578	1578	/* set the IRQ line on the ADSP */
1579		device_set_input_line(dcs.cpu, ADSP2105_IRQ2, ASSERT_LINE);
	1579	dcs.cpu->set_input_line(ADSP2105_IRQ2, ASSERT_LINE);
1580	1580
1581	1581	/* indicate we are no longer empty */
1582	1582	if (dcs.last_input_empty && dcs.input_empty_cb)
r17814	r17815
1613	1613	if (!dcs.last_input_empty && dcs.input_empty_cb)
1614	1614	(*dcs.input_empty_cb)(space->machine(), dcs.last_input_empty = 1);
1615	1615	SET_INPUT_EMPTY();
1616		device_set_input_line(dcs.cpu, ADSP2105_IRQ2, CLEAR_LINE);
	1616	dcs.cpu->set_input_line(ADSP2105_IRQ2, CLEAR_LINE);
1617	1617	}
1618	1618
1619	1619
r17814	r17815
1767	1767	timer.adjust(dcs.cpu->cycles_to_attotime(target_cycles));
1768	1768
1769	1769	/* the IRQ line is edge triggered */
1770		device_set_input_line(dcs.cpu, ADSP2105_TIMER, ASSERT_LINE);
1771		device_set_input_line(dcs.cpu, ADSP2105_TIMER, CLEAR_LINE);
	1770	dcs.cpu->set_input_line(ADSP2105_TIMER, ASSERT_LINE);
	1771	dcs.cpu->set_input_line(ADSP2105_TIMER, CLEAR_LINE);
1772	1772	}
1773	1773
1774	1774
r17814	r17815
1885	1885	if (data & 0x0200)
1886	1886	{
1887	1887	logerror("%04X:Rebooting DCS due to SYSCONTROL write\n", space->device().safe_pc());
1888		device_set_input_line(dcs.cpu, INPUT_LINE_RESET, PULSE_LINE);
	1888	dcs.cpu->set_input_line(INPUT_LINE_RESET, PULSE_LINE);
1889	1889	dcs_boot(space->machine());
1890	1890	dcs.control_regs[SYSCONTROL_REG] = 0;
1891	1891	}
r17814	r17815
1993	1993	/* so we skip the SPORT interrupt if we read with output_control within the last 5 cycles */
1994	1994	if ((dcs.cpu->total_cycles() - dcs.output_control_cycles) > 5)
1995	1995	{
1996		device_set_input_line(dcs.cpu, ADSP2115_SPORT0_RX, ASSERT_LINE);
1997		device_set_input_line(dcs.cpu, ADSP2115_SPORT0_RX, CLEAR_LINE);
	1996	dcs.cpu->set_input_line(ADSP2115_SPORT0_RX, ASSERT_LINE);
	1997	dcs.cpu->set_input_line(ADSP2115_SPORT0_RX, CLEAR_LINE);
1998	1998	}
1999	1999	}
2000	2000
r17814	r17815
2080	2080	static READ16_HANDLER( dcs_polling_r )
2081	2081	{
2082	2082	if (dcs.polling_count++ > 5)
2083		device_eat_cycles(&space->device(), 10000);
	2083	space->device().execute().eat_cycles(10000);
2084	2084	return *dcs.polling_base;
2085	2085	}
2086	2086

trunk/src/mame/audio/dsbz80.c

r17814	r17815
94	94
95	95	WRITE8_MEMBER(dsbz80_device::latch_w)
96	96	{
97		device_set_input_line(m_ourcpu, INPUT_LINE_IRQ0, ASSERT_LINE);
	97	m_ourcpu->set_input_line(INPUT_LINE_IRQ0, ASSERT_LINE);
98	98	m_dsb_latch = data;
99	99	status |= 2;
100	100	//    printf("%02x to DSB latch\n", data);
r17814	r17815
102	102
103	103	READ8_MEMBER(dsbz80_device::latch_r)
104	104	{
105		device_set_input_line(m_ourcpu, INPUT_LINE_IRQ0, CLEAR_LINE);
	105	m_ourcpu->set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
106	106	//    printf("DSB Z80 read %02x\n", m_dsb_latch);
107	107	status &= ~2;
108	108	return m_dsb_latch;

trunk/src/mame/audio/exidy.c

r17814	r17815
76	76	typedef struct _exidy_sound_state exidy_sound_state;
77	77	struct _exidy_sound_state
78	78	{
79		device_t *m_maincpu;
	79	cpu_device *m_maincpu;
80	80
81	81	/* IRQ variable */
82	82	UINT8 m_riot_irq_state;
r17814	r17815
402	402
403	403	/* allocate the stream */
404	404	state->m_stream = device->machine().sound().stream_alloc(*device, 0, 1, sample_rate, NULL, exidy_stream_update);
405		state->m_maincpu = device->machine().device("maincpu");
	405	state->m_maincpu = device->machine().device<cpu_device>("maincpu");
406	406
407	407	sh6840_register_state_globals(device);
408	408	}
r17814	r17815
686	686	return 0;
687	687	/* offset 1 reads the status register: bits 2 1 0 correspond to ints on channels 2,1,0, and bit 7 is an 'OR' of bits 2,1,0 */
688	688	case 1:
689		logerror("%04X:exidy_sh6840_r - unexpected read, status register is TODO!\n", state->m_maincpu->safe_pc());
	689	logerror("%04X:exidy_sh6840_r - unexpected read, status register is TODO!\n", state->m_maincpu->pc());
690	690	return 0;
691	691	/* offsets 2,4,6 read channel 0,1,2 MSBs and latch the LSB*/
692	692	case 2: case 4: case 6:
r17814	r17815
1043	1043	exidy_sound_state *state = get_safe_token(device);
1044	1044	UINT8 ret = state->m_pia1->b_output();
1045	1045
1046		if (VICTORY_LOG_SOUND) logerror("%04X:!!!! Sound response read = %02X\n", state->m_maincpu->safe_pcbase(), ret);
	1046	if (VICTORY_LOG_SOUND) logerror("%04X:!!!! Sound response read = %02X\n", state->m_maincpu->pcbase(), ret);
1047	1047
1048	1048	state->m_pia1->cb1_w(0);
1049	1049
r17814	r17815
1056	1056	exidy_sound_state *state = get_safe_token(device);
1057	1057	UINT8 ret = (state->m_pia1->ca1_r() << 7) | (state->m_pia1->cb1_r() << 6);
1058	1058
1059		if (VICTORY_LOG_SOUND) logerror("%04X:!!!! Sound status read = %02X\n", state->m_maincpu->safe_pcbase(), ret);
	1059	if (VICTORY_LOG_SOUND) logerror("%04X:!!!! Sound status read = %02X\n", state->m_maincpu->pcbase(), ret);
1060	1060
1061	1061	return ret;
1062	1062	}
r17814	r17815
1073	1073	{
1074	1074	exidy_sound_state *state = get_safe_token(device);
1075	1075
1076		if (VICTORY_LOG_SOUND) logerror("%04X:!!!! Sound command = %02X\n", state->m_maincpu->safe_pcbase(), data);
	1076	if (VICTORY_LOG_SOUND) logerror("%04X:!!!! Sound command = %02X\n", state->m_maincpu->pcbase(), data);
1077	1077
1078	1078	device->machine().scheduler().synchronize(FUNC(delayed_command_w), data, state->m_pia1);
1079	1079	}

trunk/src/mame/audio/timeplt.c

r17814	r17815
151	151	if (state->m_last_irq_state == 0 && data)
152	152	{
153	153	/* setting bit 0 low then high triggers IRQ on the sound CPU */
154		device_set_input_line_and_vector(state->m_soundcpu, 0, HOLD_LINE, 0xff);
	154	state->m_soundcpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
155	155	}
156	156
157	157	state->m_last_irq_state = data;

trunk/src/mame/audio/trackfld.c

r17814	r17815
148	148	if (state->m_last_irq == 0 && data)
149	149	{
150	150	/* setting bit 0 low then high triggers IRQ on the sound CPU */
151		device_set_input_line_and_vector(state->m_audiocpu, 0, HOLD_LINE, 0xff);
	151	state->m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
152	152	}
153	153
154	154	state->m_last_irq = data;

trunk/src/mame/audio/decobsmt.c

r17814	r17815
29	29
30	30	static INTERRUPT_GEN( decobsmt_firq_interrupt )
31	31	{
32		device_set_input_line(device, M6809_FIRQ_LINE, HOLD_LINE);
	32	device->execute().set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
33	33	}
34	34
35	35	static void bsmt_ready_callback(bsmt2000_device &device)
36	36	{
37	37	decobsmt_device *decobsmt = device.machine().device<decobsmt_device>(DECOBSMT_TAG);
38		device_set_input_line(decobsmt->m_ourcpu, M6809_IRQ_LINE, ASSERT_LINE); /* BSMT is ready */
	38	decobsmt->m_ourcpu->set_input_line(M6809_IRQ_LINE, ASSERT_LINE); /* BSMT is ready */
39	39	}
40	40
41	41	MACHINE_CONFIG_FRAGMENT( decobsmt )
r17814	r17815
119	119	{
120	120	m_bsmt->write_reg(offset ^ 0xff);
121	121	m_bsmt->write_data((m_bsmt_latch << 8) | data);
122		device_set_input_line(m_ourcpu, M6809_IRQ_LINE, CLEAR_LINE); /* BSMT is not ready */
	122	m_ourcpu->set_input_line(M6809_IRQ_LINE, CLEAR_LINE); /* BSMT is not ready */
123	123	}
124	124
125	125	READ8_MEMBER(decobsmt_device::bsmt_status_r)
r17814	r17815
139	139
140	140	WRITE_LINE_MEMBER(decobsmt_device::bsmt_reset_line)
141	141	{
142		device_set_input_line(m_ourcpu, INPUT_LINE_RESET, state);
	142	m_ourcpu->set_input_line(INPUT_LINE_RESET, state);
143	143	}
144	144

trunk/src/mame/audio/namco54.c

r17814	r17815
113	113	static TIMER_CALLBACK( namco_54xx_irq_clear )
114	114	{
115	115	namco_54xx_state *state = get_safe_token((device_t *)ptr);
116		device_set_input_line(state->m_cpu, 0, CLEAR_LINE);
	116	state->m_cpu->execute().set_input_line(0, CLEAR_LINE);
117	117	}
118	118
119	119	WRITE8_DEVICE_HANDLER( namco_54xx_write )
r17814	r17815
122	122
123	123	device->machine().scheduler().synchronize(FUNC(namco_54xx_latch_callback), data, (void *)device);
124	124
125		device_set_input_line(state->m_cpu, 0, ASSERT_LINE);
	125	state->m_cpu->execute().set_input_line(0, ASSERT_LINE);
126	126
127	127	// The execution time of one instruction is ~4us, so we must make sure to
128	128	// give the cpu time to poll the /IRQ input before we clear it.

trunk/src/mame/audio/t5182.c

r17814	r17815
205	205	return;
206	206
207	207	if (irqstate == 0)   /* no IRQs pending */
208		device_set_input_line(cpu,0,CLEAR_LINE);
	208	cpu->execute().set_input_line(0,CLEAR_LINE);
209	209	else   /* IRQ pending */
210		device_set_input_line(cpu,0,ASSERT_LINE);
	210	cpu->execute().set_input_line(0,ASSERT_LINE);
211	211	}
212	212
213	213

trunk/src/mame/audio/aztarac.c

r17814	r17815
49	49	state->m_sound_status ^= 0x10;
50	50
51	51	if (state->m_sound_status & 0x10)
52		device_set_input_line(device,0,HOLD_LINE);
	52	device->execute().set_input_line(0,HOLD_LINE);
53	53	}

trunk/src/mame/audio/harddriv.c

r17814	r17815
39	39	static void update_68k_interrupts(running_machine &machine)
40	40	{
41	41	harddriv_state *state = machine.driver_data<harddriv_state>();
42		device_set_input_line(state->m_soundcpu, 1, state->m_mainflag ? ASSERT_LINE : CLEAR_LINE);
43		device_set_input_line(state->m_soundcpu, 3, state->m_irq68k   ? ASSERT_LINE : CLEAR_LINE);
	42	state->m_soundcpu->set_input_line(1, state->m_mainflag ? ASSERT_LINE : CLEAR_LINE);
	43	state->m_soundcpu->set_input_line(3, state->m_irq68k   ? ASSERT_LINE : CLEAR_LINE);
44	44	}
45	45
46	46
r17814	r17815
83	83
84	84	WRITE16_MEMBER(harddriv_state::hd68k_snd_reset_w)
85	85	{
86		device_set_input_line(m_soundcpu, INPUT_LINE_RESET, ASSERT_LINE);
87		device_set_input_line(m_soundcpu, INPUT_LINE_RESET, CLEAR_LINE);
	86	m_soundcpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
	87	m_soundcpu->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
88	88	m_mainflag = m_soundflag = 0;
89	89	update_68k_interrupts(machine());
90	90	logerror("%06X:Reset sound\n", space.device().safe_pcbase());
r17814	r17815
188	188	case 4:   /* RES320 */
189	189	logerror("%06X:RES320=%d\n", space.device().safe_pcbase(), data);
190	190	if (m_sounddsp != NULL)
191		device_set_input_line(m_sounddsp, INPUT_LINE_HALT, data ? CLEAR_LINE : ASSERT_LINE);
	191	m_sounddsp->set_input_line(INPUT_LINE_HALT, data ? CLEAR_LINE : ASSERT_LINE);
192	192	break;
193	193
194	194	case 7:   /* LED */
r17814	r17815
277	277	/* if we're not at the next BIO yet, advance us there */
278	278	if (cycles_until_bio > 0)
279	279	{
280		device_adjust_icount(&space.device(), -cycles_until_bio);
	280	space.device().execute().adjust_icount(-cycles_until_bio);
281	281	m_last_bio_cycles += CYCLES_PER_BIO;
282	282	}
283	283	else

trunk/src/mame/audio/beezer.c

r17814	r17815
95	95	typedef struct _beezer_sound_state beezer_sound_state;
96	96	struct _beezer_sound_state
97	97	{
98		device_t *m_maincpu;
	98	cpu_device *m_maincpu;
99	99
100	100	/* IRQ variable */
101	101	UINT8 m_ptm_irq_state;
r17814	r17815
384	384
385	385	/* allocate the stream */
386	386	state->m_stream = device->machine().sound().stream_alloc(*device, 0, 1, sample_rate, NULL, beezer_stream_update);
387		state->m_maincpu = device->machine().device("maincpu");
	387	state->m_maincpu = device->machine().device<cpu_device>("maincpu");
388	388
389	389	sh6840_register_state_globals(device);
390	390	}
r17814	r17815
499	499	return 0;
500	500	/* offset 1 reads the status register: bits 2 1 0 correspond to ints on channels 2,1,0, and bit 7 is an 'OR' of bits 2,1,0 */
501	501	case 1:
502		logerror("%04X:beezer_sh6840_r - unexpected read, status register is TODO!\n", state->m_maincpu->safe_pc());
	502	logerror("%04X:beezer_sh6840_r - unexpected read, status register is TODO!\n", state->m_maincpu->pc());
503	503	return 0;
504	504	/* offsets 2,4,6 read channel 0,1,2 MSBs and latch the LSB*/
505	505	case 2: case 4: case 6:

trunk/src/mame/machine/nycaptor.c

r17814	r17815
47	47	m_port_a_in = m_from_main;
48	48
49	49	if (m_main_sent)
50		device_set_input_line(m_mcu, 0, CLEAR_LINE);
	50	m_mcu->execute().set_input_line(0, CLEAR_LINE);
51	51	m_main_sent = 0;
52	52
53	53	}
r17814	r17815
94	94
95	95	m_from_main = data;
96	96	m_main_sent = 1;
97		device_set_input_line(m_mcu, 0, ASSERT_LINE);
	97	m_mcu->execute().set_input_line(0, ASSERT_LINE);
98	98	}
99	99
100	100	READ8_MEMBER(nycaptor_state::nycaptor_mcu_r)

trunk/src/mame/machine/scudsp.c

r17814	r17815
754	754	saturn_state *state = machine.driver_data<saturn_state>();
755	755
756	756	if(!(state->m_scu.ism & IRQ_DSP_END))
757		device_set_input_line_and_vector(state->m_maincpu, 0xa, HOLD_LINE, 0x45);
	757	state->m_maincpu->set_input_line_and_vector(0xa, HOLD_LINE, 0x45);
758	758	else
759	759	state->m_scu.ist |= (IRQ_DSP_END);
760	760

trunk/src/mame/machine/xevious.c

r17814	r17815
184	184
185	185	INTERRUPT_GEN( battles_interrupt_4 )
186	186	{
187		device_set_input_line(device, 0, HOLD_LINE);
	187	device->execute().set_input_line(0, HOLD_LINE);
188	188	}
189	189

trunk/src/mame/machine/bublbobl.c

r17814	r17815
21	21	/* bit 3 n.c. */
22	22
23	23	/* bit 4 resets second Z80 */
24		device_set_input_line(m_slave, INPUT_LINE_RESET, (data & 0x10) ? CLEAR_LINE : ASSERT_LINE);
	24	m_slave->execute().set_input_line(INPUT_LINE_RESET, (data & 0x10) ? CLEAR_LINE : ASSERT_LINE);
25	25
26	26	/* bit 5 resets mcu */
27	27	if (m_mcu != NULL) // only if we have a MCU
28		device_set_input_line(m_mcu, INPUT_LINE_RESET, (data & 0x20) ? CLEAR_LINE : ASSERT_LINE);
	28	m_mcu->execute().set_input_line(INPUT_LINE_RESET, (data & 0x20) ? CLEAR_LINE : ASSERT_LINE);
29	29
30	30	/* bit 6 enables display */
31	31	m_video_enable = data & 0x40;
r17814	r17815
52	52
53	53	WRITE8_MEMBER(bublbobl_state::bublbobl_nmitrigger_w)
54	54	{
55		device_set_input_line(m_slave, INPUT_LINE_NMI, PULSE_LINE);
	55	m_slave->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
56	56	}
57	57
58	58
r17814	r17815
91	91	bublbobl_state *state = machine.driver_data<bublbobl_state>();
92	92
93	93	if (state->m_sound_nmi_enable)
94		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	94	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
95	95	else
96	96	state->m_pending_nmi = 1;
97	97	}
r17814	r17815
113	113	m_sound_nmi_enable = 1;
114	114	if (m_pending_nmi)
115	115	{
116		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	116	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
117	117	m_pending_nmi = 0;
118	118	}
119	119	}
120	120
121	121	WRITE8_MEMBER(bublbobl_state::bublbobl_soundcpu_reset_w)
122	122	{
123		device_set_input_line(m_audiocpu, INPUT_LINE_RESET, data ? ASSERT_LINE : CLEAR_LINE);
	123	m_audiocpu->set_input_line(INPUT_LINE_RESET, data ? ASSERT_LINE : CLEAR_LINE);
124	124	}
125	125
126	126	READ8_MEMBER(bublbobl_state::bublbobl_sound_status_r)
r17814	r17815
203	203	if ((m_port1_out & 0x40) && (~data & 0x40))
204	204	{
205	205	// logerror("triggering IRQ on main CPU\n");
206		device_set_input_line_vector(m_maincpu, 0, m_mcu_sharedram[0]);
207		device_set_input_line(m_maincpu, 0, HOLD_LINE);
	206	m_maincpu->set_input_line_vector(0, m_mcu_sharedram[0]);
	207	m_maincpu->set_input_line(0, HOLD_LINE);
208	208	}
209	209
210	210	// bit 7: select read or write shared RAM
r17814	r17815
374	374
375	375	INTERRUPT_GEN( bublbobl_m68705_interrupt )
376	376	{
377		device_set_input_line(device, 0, ASSERT_LINE);
	377	device->execute().set_input_line(0, ASSERT_LINE);
378	378
379	379	device->machine().scheduler().timer_set(attotime::from_msec(1000/60), FUNC(bublbobl_m68705_irq_ack)); /* TODO: understand how this is ack'ed */
380	380	}
r17814	r17815
474	474	/* hack to get random EXTEND letters (who is supposed to do this? 68705? PAL?) */
475	475	m_mcu_sharedram[0x7c] = machine().rand() % 6;
476	476
477		device_set_input_line_vector(m_maincpu, 0, m_mcu_sharedram[0]);
478		device_set_input_line(m_maincpu, 0, HOLD_LINE);
	477	m_maincpu->set_input_line_vector(0, m_mcu_sharedram[0]);
	478	m_maincpu->set_input_line(0, HOLD_LINE);
479	479	}
480	480	if ((m_ddr_b & 0x40) && (~data & 0x40) && (m_port_b_out & 0x40))
481	481	{

trunk/src/mame/machine/asic65.c

r17814	r17815
142	142
143	143	/* rom-based means reset and clear states */
144	144	if (asic65.cpu != NULL)
145		device_set_input_line(asic65.cpu, INPUT_LINE_RESET, state ? ASSERT_LINE : CLEAR_LINE);
	145	asic65.cpu->execute().set_input_line(INPUT_LINE_RESET, state ? ASSERT_LINE : CLEAR_LINE);
146	146
147	147	/* otherwise, do it manually */
148	148	else
r17814	r17815
179	179	asic65.cmd = param >> 16;
180	180	asic65.tdata = param;
181	181	if (asic65.cpu != NULL)
182		device_set_input_line(asic65.cpu, 0, ASSERT_LINE);
	182	asic65.cpu->execute().set_input_line(0, ASSERT_LINE);
183	183	}
184	184
185	185
r17814	r17815
477	477	{
478	478	asic65.tfull = 0;
479	479	if (asic65.cpu != NULL)
480		device_set_input_line(asic65.cpu, 0, CLEAR_LINE);
	480	asic65.cpu->execute().set_input_line(0, CLEAR_LINE);
481	481	return asic65.tdata;
482	482	}
483	483
r17814	r17815
501	501	static READ16_HANDLER( asci65_get_bio )
502	502	{
503	503	if (!asic65.tfull)
504		device_spin_until_interrupt(&space->device());
	504	space->device().execute().spin_until_interrupt();
505	505	return asic65.tfull ? CLEAR_LINE : ASSERT_LINE;
506	506	}
507	507

trunk/src/mame/machine/tnzs.c

r17814	r17815
48	48	UINT8 data;
49	49
50	50	data = upi41_master_r(m_mcu, offset & 1);
51		device_yield(&space.device());
	51	space.device().execute().yield();
52	52
53	53	//  logerror("PC %04x: read %02x from mcu $c00%01x\n", space.device().safe_pcbase(), data, offset);
54	54
r17814	r17815
636	636	break;
637	637	}
638	638
639		device_set_input_line(device, 0, HOLD_LINE);
	639	device->execute().set_input_line(0, HOLD_LINE);
640	640	}
641	641
642	642	MACHINE_RESET( tnzs )
r17814	r17815
687	687	state->membank("subbank")->configure_entries(0, 4, &SUB[0x08000], 0x2000);
688	688	state->membank("subbank")->set_entry(state->m_bank2);
689	689
690		state->m_subcpu = machine.device("sub");
	690	state->m_subcpu = machine.device<cpu_device>("sub");
691	691	state->m_mcu = NULL;
692	692
693	693	state->m_bank1 = 2;
r17814	r17815
707	707
708	708	MACHINE_START_CALL( jpopnics );
709	709
710		state->m_audiocpu = machine.device("audiocpu");
	710	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
711	711	state->m_mcu = machine.device("mcu");
712	712
713	713	state->save_item(NAME(state->m_kageki_csport_sel));
r17814	r17815
733	733
734	734	/* bit 4 resets the second CPU */
735	735	if (data & 0x10)
736		device_set_input_line(m_subcpu, INPUT_LINE_RESET, CLEAR_LINE);
	736	m_subcpu->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
737	737	else
738		device_set_input_line(m_subcpu, INPUT_LINE_RESET, ASSERT_LINE);
	738	m_subcpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
739	739
740	740	/* bits 0-2 select RAM/ROM bank */
741	741	m_bank1 = data & 0x07;
r17814	r17815
753	753	if (data & 0x04)
754	754	{
755	755	if (m_mcu != NULL && m_mcu->type() == I8742)
756		device_set_input_line(m_mcu, INPUT_LINE_RESET, PULSE_LINE);
	756	m_mcu->execute().set_input_line(INPUT_LINE_RESET, PULSE_LINE);
757	757	}
758	758	/* Coin count and lockout is handled by the i8742 */
759	759	break;

trunk/src/mame/machine/docastle.c

r17814	r17815
68	68	data, (UINT32)m_maincpu->total_cycles());
69	69
70	70	/* freeze execution of the master CPU until the slave has used the shared memory */
71		device_spin_until_trigger(&space.device(), 500);
	71	space.device().execute().spin_until_trigger(500);
72	72	}
73	73	}
74	74
r17814	r17815
76	76
77	77	WRITE8_MEMBER(docastle_state::docastle_nmitrigger_w)
78	78	{
79		device_set_input_line(m_slave, INPUT_LINE_NMI, PULSE_LINE);
	79	m_slave->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
80	80	}

trunk/src/mame/machine/naomi.c

r17814	r17815
29	29	static READ64_HANDLER( naomi_biose_idle_skip_r )
30	30	{
31	31	if (space->device().safe_pc()==0xc04173c)
32		device_spin_until_time(&space->device(), attotime::from_usec(500));
33		//device_spin_until_interrupt(&space->device());
	32	space->device().execute().spin_until_time(attotime::from_usec(500));
	33	//space->device().execute().spin_until_interrupt();
34	34	//  else
35	35	//      printf("%08x\n", space->device().safe_pc());
36	36
r17814	r17815
40	40	static READ64_HANDLER( naomi_biosh_idle_skip_r )
41	41	{
42	42	if (space->device().safe_pc()==0xc045ffc)
43		device_spin_until_time(&space->device(), attotime::from_usec(500));
	43	space->device().execute().spin_until_time(attotime::from_usec(500));
44	44
45	45	//   printf("%08x\n", space->device().safe_pc());
46	46
r17814	r17815
50	50	static READ64_HANDLER( naomi2_biose_idle_skip_r )
51	51	{
52	52	if (space->device().safe_pc()==0xc04637c)
53		device_spin_until_time(&space->device(), attotime::from_usec(500));
54		//device_spin_until_interrupt(&space->device());
	53	space->device().execute().spin_until_time(attotime::from_usec(500));
	54	//space->device().execute().spin_until_interrupt();
55	55	//  else
56	56	//      printf("%08x\n", space->device().safe_pc());
57	57
r17814	r17815
244	244	static READ64_HANDLER( naomigd_ggxxsla_idle_skip_r )
245	245	{
246	246	if (space->device().safe_pc()==0x0c0c9adc)
247		device_spin_until_time(&space->device(), attotime::from_usec(500));
	247	space->device().execute().spin_until_time(attotime::from_usec(500));
248	248
249	249	return naomi_ram64[0x1aae18/8];
250	250	}
r17814	r17815
258	258	static READ64_HANDLER( naomigd_ggxx_idle_skip_r )
259	259	{
260	260	if (space->device().safe_pc()==0xc0b5c3c) // or 0xc0bab0c
261		device_spin_until_time(&space->device(), attotime::from_usec(500));
	261	space->device().execute().spin_until_time(attotime::from_usec(500));
262	262
263	263	return naomi_ram64[0x1837b8/8];
264	264	}
r17814	r17815
273	273	static READ64_HANDLER( naomigd_ggxxrl_idle_skip_r )
274	274	{
275	275	if (space->device().safe_pc()==0xc0b84bc) // or 0xc0bab0c
276		device_spin_until_time(&space->device(), attotime::from_usec(500));
	276	space->device().execute().spin_until_time(attotime::from_usec(500));
277	277
278	278	//printf("%08x\n", space->device().safe_pc());
279	279
r17814	r17815
290	290	static READ64_HANDLER( naomigd_sfz3ugd_idle_skip_r )
291	291	{
292	292	if (space->device().safe_pc()==0xc36a2dc)
293		device_spin_until_time(&space->device(), attotime::from_usec(500));
	293	space->device().execute().spin_until_time(attotime::from_usec(500));
294	294
295	295	return naomi_ram64[0x5dc900/8];
296	296	}
r17814	r17815
335	335	static READ64_HANDLER( hotd2_idle_skip_r )
336	336	{
337	337	if (space->device().safe_pc()==0xc0cfcbc)
338		device_spin_until_time(&space->device(), attotime::from_usec(500));
339		//device_spin_until_interrupt(&space->device());
	338	space->device().execute().spin_until_time(attotime::from_usec(500));
	339	//space->device().execute().spin_until_interrupt();
340	340	//  else
341	341	//  printf("%08x\n", space->device().safe_pc());
342	342

trunk/src/mame/machine/asteroid.c

r17814	r17815
17	17	{
18	18	/* Turn off interrupts if self-test is enabled */
19	19	if (!(device->machine().root_device().ioport("IN0")->read() & 0x80))
20		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	20	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
21	21	}
22	22
23	23	INTERRUPT_GEN( asterock_interrupt )
24	24	{
25	25	/* Turn off interrupts if self-test is enabled */
26	26	if ((device->machine().root_device().ioport("IN0")->read() & 0x80))
27		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	27	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
28	28	}
29	29
30	30	INTERRUPT_GEN( llander_interrupt )
31	31	{
32	32	/* Turn off interrupts if self-test is enabled */
33	33	if (device->machine().root_device().ioport("IN0")->read() & 0x02)
34		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	34	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
35	35	}
36	36
37	37	READ8_MEMBER(asteroid_state::asteroid_IN0_r)

trunk/src/mame/machine/twincobr.c

r17814	r17815
19	19	twincobr_state *state = device->machine().driver_data<twincobr_state>();
20	20	if (state->m_intenable) {
21	21	state->m_intenable = 0;
22		device_set_input_line(device, M68K_IRQ_4, HOLD_LINE);
	22	device->execute().set_input_line(M68K_IRQ_4, HOLD_LINE);
23	23	}
24	24	}
25	25
r17814	r17815
28	28	twincobr_state *state = device->machine().driver_data<twincobr_state>();
29	29	if (state->m_intenable) {
30	30	state->m_intenable = 0;
31		device_set_input_line(device, 0, HOLD_LINE);
	31	device->execute().set_input_line(0, HOLD_LINE);
32	32	}
33	33	}
34	34

trunk/src/mame/machine/megasvp.c

r17814	r17815
333	333
334	334	static READ16_HANDLER( svp_speedup_r )
335	335	{
336		device_spin_until_time(&space->device(), attotime::from_usec(100));
	336	space->device().execute().spin_until_time(attotime::from_usec(100));
337	337	return 0x0425;
338	338	}
339	339

trunk/src/mame/machine/namco06.c

r17814	r17815
123	123	{
124	124	LOG(("NMI cpu '%s'\n",state->m_nmicpu->tag()));
125	125
126		device_set_input_line(state->m_nmicpu, INPUT_LINE_NMI, PULSE_LINE);
	126	state->m_nmicpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
127	127	}
128	128	else
129	129	LOG(("NMI not generated because cpu '%s' is suspended\n",state->m_nmicpu->tag()));

trunk/src/mame/machine/mega32x.c

r17814	r17815
666	666
667	667	if (data & 0x02)
668	668	{
669		device_set_input_line(_32x_master_cpu, INPUT_LINE_RESET, CLEAR_LINE);
670		device_set_input_line(_32x_slave_cpu, INPUT_LINE_RESET, CLEAR_LINE);
	669	_32x_master_cpu->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
	670	_32x_slave_cpu->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
671	671	}
672	672
673	673	if (data & 0x01)
r17814	r17815
727	727
728	728	if (data&0x1)
729	729	{
730		if (m_sh2_master_cmdint_enable) device_set_input_line(_32x_master_cpu,SH2_CINT_IRQ_LEVEL,ASSERT_LINE);
	730	if (m_sh2_master_cmdint_enable) _32x_master_cpu->set_input_line(SH2_CINT_IRQ_LEVEL,ASSERT_LINE);
731	731	else printf("master cmdint when masked!\n");
732	732	}
733	733
734	734	if (data&0x2)
735	735	{
736		if (m_sh2_slave_cmdint_enable) device_set_input_line(_32x_slave_cpu,SH2_CINT_IRQ_LEVEL,ASSERT_LINE);
	736	if (m_sh2_slave_cmdint_enable) _32x_slave_cpu->set_input_line(SH2_CINT_IRQ_LEVEL,ASSERT_LINE);
737	737	else printf("slave cmdint when masked!\n");
738	738	}
739	739	}
r17814	r17815
859	859	if(m_pwm_timer_tick == m_pwm_tm_reg)
860	860	{
861	861	m_pwm_timer_tick = 0;
862		if(sh2_master_pwmint_enable) { device_set_input_line(_32x_master_cpu, SH2_PINT_IRQ_LEVEL,ASSERT_LINE); }
863		if(sh2_slave_pwmint_enable) { device_set_input_line(_32x_slave_cpu, SH2_PINT_IRQ_LEVEL,ASSERT_LINE); }
	862	if(sh2_master_pwmint_enable) { _32x_master_cpu->set_input_line(SH2_PINT_IRQ_LEVEL,ASSERT_LINE); }
	863	if(sh2_slave_pwmint_enable) { _32x_slave_cpu->set_input_line(SH2_PINT_IRQ_LEVEL,ASSERT_LINE); }
864	864	}
865	865
866	866	m_32x_pwm_timer->adjust(attotime::from_hz((PWM_CLOCK) / (m_pwm_cycle - 1)));
r17814	r17815
1322	1322	// VRES (md reset button interrupt) clear
1323	1323	/**********************************************************************************************/
1324	1324
1325		WRITE16_MEMBER( sega_32x_device::_32x_sh2_master_4014_w ){ device_set_input_line(_32x_master_cpu,SH2_VRES_IRQ_LEVEL,CLEAR_LINE);}
1326		WRITE16_MEMBER( sega_32x_device::_32x_sh2_slave_4014_w ) { device_set_input_line(_32x_slave_cpu, SH2_VRES_IRQ_LEVEL,CLEAR_LINE);}
	1325	WRITE16_MEMBER( sega_32x_device::_32x_sh2_master_4014_w ){ _32x_master_cpu->set_input_line(SH2_VRES_IRQ_LEVEL,CLEAR_LINE);}
	1326	WRITE16_MEMBER( sega_32x_device::_32x_sh2_slave_4014_w ) { _32x_slave_cpu->set_input_line(SH2_VRES_IRQ_LEVEL,CLEAR_LINE);}
1327	1327
1328	1328	/**********************************************************************************************/
1329	1329	// SH2 side 4016
r17814	r17815
1338	1338	// HINT (horizontal interrupt) clear
1339	1339	/**********************************************************************************************/
1340	1340
1341		WRITE16_MEMBER( sega_32x_device::_32x_sh2_master_4018_w ){ device_set_input_line(_32x_master_cpu,SH2_HINT_IRQ_LEVEL,CLEAR_LINE);}
1342		WRITE16_MEMBER( sega_32x_device::_32x_sh2_slave_4018_w ) { device_set_input_line(_32x_slave_cpu, SH2_HINT_IRQ_LEVEL,CLEAR_LINE);}
	1341	WRITE16_MEMBER( sega_32x_device::_32x_sh2_master_4018_w ){ _32x_master_cpu->set_input_line(SH2_HINT_IRQ_LEVEL,CLEAR_LINE);}
	1342	WRITE16_MEMBER( sega_32x_device::_32x_sh2_slave_4018_w ) { _32x_slave_cpu->set_input_line(SH2_HINT_IRQ_LEVEL,CLEAR_LINE);}
1343	1343
1344	1344	/**********************************************************************************************/
1345	1345	// SH2 side 401A
r17814	r17815
1347	1347	// Note: flag cleared here is a guess, according to After Burner behaviour
1348	1348	/**********************************************************************************************/
1349	1349
1350		WRITE16_MEMBER( sega_32x_device::_32x_sh2_master_401a_w ){ m_32x_68k_a15102_reg &= ~1; device_set_input_line(_32x_master_cpu,SH2_CINT_IRQ_LEVEL,CLEAR_LINE);}
1351		WRITE16_MEMBER( sega_32x_device::_32x_sh2_slave_401a_w ) { m_32x_68k_a15102_reg &= ~2; device_set_input_line(_32x_slave_cpu, SH2_CINT_IRQ_LEVEL,CLEAR_LINE);}
	1350	WRITE16_MEMBER( sega_32x_device::_32x_sh2_master_401a_w ){ m_32x_68k_a15102_reg &= ~1; _32x_master_cpu->set_input_line(SH2_CINT_IRQ_LEVEL,CLEAR_LINE);}
	1351	WRITE16_MEMBER( sega_32x_device::_32x_sh2_slave_401a_w ) { m_32x_68k_a15102_reg &= ~2; _32x_slave_cpu->set_input_line(SH2_CINT_IRQ_LEVEL,CLEAR_LINE);}
1352	1352
1353	1353	/**********************************************************************************************/
1354	1354	// SH2 side 401C
1355	1355	// PINT (PWM timer interrupt) clear
1356	1356	/**********************************************************************************************/
1357	1357
1358		WRITE16_MEMBER( sega_32x_device::_32x_sh2_master_401c_w ){ device_set_input_line(_32x_master_cpu,SH2_PINT_IRQ_LEVEL,CLEAR_LINE);}
1359		WRITE16_MEMBER( sega_32x_device::_32x_sh2_slave_401c_w ) { device_set_input_line(_32x_slave_cpu, SH2_PINT_IRQ_LEVEL,CLEAR_LINE);}
	1358	WRITE16_MEMBER( sega_32x_device::_32x_sh2_master_401c_w ){ _32x_master_cpu->set_input_line(SH2_PINT_IRQ_LEVEL,CLEAR_LINE);}
	1359	WRITE16_MEMBER( sega_32x_device::_32x_sh2_slave_401c_w ) { _32x_slave_cpu->set_input_line(SH2_PINT_IRQ_LEVEL,CLEAR_LINE);}
1360	1360
1361	1361	/**********************************************************************************************/
1362	1362	// SH2 side 401E
r17814	r17815
1569	1569	void sega_32x_device::_32x_check_irqs(running_machine& machine)
1570	1570	{
1571	1571
1572		if (m_sh2_master_vint_enable && m_sh2_master_vint_pending) device_set_input_line(_32x_master_cpu,SH2_VINT_IRQ_LEVEL,ASSERT_LINE);
1573		else device_set_input_line(_32x_master_cpu,SH2_VINT_IRQ_LEVEL,CLEAR_LINE);
	1572	if (m_sh2_master_vint_enable && m_sh2_master_vint_pending) _32x_master_cpu->set_input_line(SH2_VINT_IRQ_LEVEL,ASSERT_LINE);
	1573	else _32x_master_cpu->set_input_line(SH2_VINT_IRQ_LEVEL,CLEAR_LINE);
1574	1574
1575		if (m_sh2_slave_vint_enable && m_sh2_slave_vint_pending) device_set_input_line(_32x_slave_cpu,SH2_VINT_IRQ_LEVEL,ASSERT_LINE);
1576		else device_set_input_line(_32x_slave_cpu,SH2_VINT_IRQ_LEVEL,CLEAR_LINE);
	1575	if (m_sh2_slave_vint_enable && m_sh2_slave_vint_pending) _32x_slave_cpu->set_input_line(SH2_VINT_IRQ_LEVEL,ASSERT_LINE);
	1576	else _32x_slave_cpu->set_input_line(SH2_VINT_IRQ_LEVEL,CLEAR_LINE);
1577	1577	}
1578	1578
1579	1579	void sega_32x_device::_32x_scanline_cb0(running_machine& machine)
r17814	r17815
1594	1594
1595	1595	if(genesis_scanline_counter < 224 || m_sh2_hint_in_vbl)
1596	1596	{
1597		if(m_sh2_master_hint_enable) { device_set_input_line(_32x_master_cpu,SH2_HINT_IRQ_LEVEL,ASSERT_LINE); }
1598		if(m_sh2_slave_hint_enable) { device_set_input_line(_32x_slave_cpu,SH2_HINT_IRQ_LEVEL,ASSERT_LINE); }
	1597	if(m_sh2_master_hint_enable) { _32x_master_cpu->set_input_line(SH2_HINT_IRQ_LEVEL,ASSERT_LINE); }
	1598	if(m_sh2_slave_hint_enable) { _32x_slave_cpu->set_input_line(SH2_HINT_IRQ_LEVEL,ASSERT_LINE); }
1599	1599	}
1600	1600	}
1601	1601	}

trunk/src/mame/machine/cdicdic.c

r17814	r17815
553	553
554	554	// Set the CDIC interrupt line
555	555	verboselog(machine(), 0, "Setting CDIC interrupt line for soundmap decode\n" );
556		device_set_input_line_vector(machine().device("maincpu"), M68K_IRQ_4, 128);
	556	machine().device("maincpu")->execute().set_input_line_vector(M68K_IRQ_4, 128);
557	557	machine().device("maincpu")->execute().set_input_line(M68K_IRQ_4, ASSERT_LINE);
558	558	}
559	559	else
r17814	r17815
707	707
708	708	//printf( "Setting CDIC interrupt line\n" );
709	709	verboselog(machine(), 0, "Setting CDIC interrupt line for audio sector\n" );
710		device_set_input_line_vector(machine().device("maincpu"), M68K_IRQ_4, 128);
	710	machine().device("maincpu")->execute().set_input_line_vector(M68K_IRQ_4, 128);
711	711	machine().device("maincpu")->execute().set_input_line(M68K_IRQ_4, ASSERT_LINE);
712	712	}
713	713	else if((buffer[CDIC_SECTOR_SUBMODE2] & (CDIC_SUBMODE_DATA | CDIC_SUBMODE_AUDIO | CDIC_SUBMODE_VIDEO)) == 0x00)
r17814	r17815
726	726	{
727	727	//printf( "Setting CDIC interrupt line\n" );
728	728	verboselog(machine(), 0, "Setting CDIC interrupt line for message sector\n" );
729		device_set_input_line_vector(machine().device("maincpu"), M68K_IRQ_4, 128);
	729	machine().device("maincpu")->execute().set_input_line_vector(M68K_IRQ_4, 128);
730	730	machine().device("maincpu")->execute().set_input_line(M68K_IRQ_4, ASSERT_LINE);
731	731	}
732	732	else
r17814	r17815
746	746
747	747	//printf( "Setting CDIC interrupt line\n" );
748	748	verboselog(machine(), 0, "Setting CDIC interrupt line for data sector\n" );
749		device_set_input_line_vector(machine().device("maincpu"), M68K_IRQ_4, 128);
	749	machine().device("maincpu")->execute().set_input_line_vector(M68K_IRQ_4, 128);
750	750	machine().device("maincpu")->execute().set_input_line(M68K_IRQ_4, ASSERT_LINE);
751	751	}
752	752
r17814	r17815
841	841	}
842	842
843	843	verboselog(machine(), 0, "Setting CDIC interrupt line for CDDA sector\n" );
844		device_set_input_line_vector(machine().device("maincpu"), M68K_IRQ_4, 128);
	844	machine().device("maincpu")->execute().set_input_line_vector(M68K_IRQ_4, 128);
845	845	machine().device("maincpu")->execute().set_input_line(M68K_IRQ_4, ASSERT_LINE);
846	846	break;
847	847	}
r17814	r17815
892	892	m_time = next_msf << 8;
893	893
894	894	verboselog(machine(), 0, "Setting CDIC interrupt line for Seek sector\n" );
895		device_set_input_line_vector(machine().device("maincpu"), M68K_IRQ_4, 128);
	895	machine().device("maincpu")->execute().set_input_line_vector(M68K_IRQ_4, 128);
896	896	machine().device("maincpu")->execute().set_input_line(M68K_IRQ_4, ASSERT_LINE);
897	897	break;
898	898	}

trunk/src/mame/machine/megadriv.c

r17814	r17815
1019	1019	/* if any of these extra CPUs exist, pause them until we actually turn them on */
1020	1020	if (_32x_master_cpu != NULL)
1021	1021	{
1022		device_set_input_line(_32x_master_cpu, INPUT_LINE_RESET, ASSERT_LINE);
	1022	_32x_master_cpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
1023	1023	}
1024	1024
1025	1025	if (_32x_slave_cpu != NULL)
1026	1026	{
1027		device_set_input_line(_32x_slave_cpu, INPUT_LINE_RESET, ASSERT_LINE);
	1027	_32x_slave_cpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
1028	1028	}
1029	1029
1030	1030	if (_segacd_68k_cpu != NULL )
r17814	r17815
1427	1427	printf("SVP (cpu) found '%s'\n", _svp_cpu->tag() );
1428	1428	}
1429	1429
1430		device_set_irq_callback(machine.device("maincpu"), genesis_int_callback);
	1430	machine.device("maincpu")->execute().set_irq_acknowledge_callback(genesis_int_callback);
1431	1431	megadriv_backupram = NULL;
1432	1432	megadriv_backupram_length = 0;
1433	1433

trunk/src/mame/machine/vsnes.c

r17814	r17815
1002	1002	(&space.device() == machine().device("maincpu")) ? membank("bank2")->set_entry(BIT(data, 2)) : membank("bank3")->set_entry(BIT(data, 2));
1003	1003
1004	1004	/* bit 1 ( data & 2 ) triggers irq on the other cpu */
1005		device_set_input_line(other_cpu, 0, (data & 2) ? CLEAR_LINE : ASSERT_LINE);
	1005	other_cpu->execute().set_input_line(0, (data & 2) ? CLEAR_LINE : ASSERT_LINE);
1006	1006
1007	1007	/* move along */
1008	1008	if (&space.device() == machine().device("maincpu"))

trunk/src/mame/machine/mexico86.c

r17814	r17815
15	15	WRITE8_MEMBER(mexico86_state::mexico86_f008_w)
16	16	{
17	17
18		device_set_input_line(m_audiocpu, INPUT_LINE_RESET, (data & 4) ? CLEAR_LINE : ASSERT_LINE);
	18	m_audiocpu->set_input_line(INPUT_LINE_RESET, (data & 4) ? CLEAR_LINE : ASSERT_LINE);
19	19
20	20	if (m_mcu != NULL)
21	21	{
22	22	// mexico 86, knight boy
23		device_set_input_line(m_mcu, INPUT_LINE_RESET, (data & 2) ? CLEAR_LINE : ASSERT_LINE);
	23	m_mcu->execute().set_input_line(INPUT_LINE_RESET, (data & 2) ? CLEAR_LINE : ASSERT_LINE);
24	24	}
25	25	else
26	26	{
r17814	r17815
157	157	if (state->m_mcu_running)
158	158	mcu_simulate(device->machine());
159	159
160		device_set_input_line_vector(device, 0, state->m_protection_ram[0]);
161		device_set_input_line(device, 0, HOLD_LINE);
	160	device->execute().set_input_line_vector(0, state->m_protection_ram[0]);
	161	device->execute().set_input_line(0, HOLD_LINE);
162	162	}
163	163
164	164
r17814	r17815
220	220
221	221	INTERRUPT_GEN( mexico86_m68705_interrupt )
222	222	{
223		device_set_input_line(device, 0, ASSERT_LINE);
	223	device->execute().set_input_line(0, ASSERT_LINE);
224	224	}
225	225
226	226
r17814	r17815
305	305
306	306	if (BIT(m_ddr_b, 5) && BIT(data, 5) && BIT(~m_port_b_out, 5))
307	307	{
308		device_set_input_line_vector(m_maincpu, 0, m_protection_ram[0]);
309		device_set_input_line(m_maincpu, 0, HOLD_LINE);        // HOLD_LINE works better in Z80 interrupt mode 1.
310		device_set_input_line(m_mcu, 0, CLEAR_LINE);
	308	m_maincpu->set_input_line_vector(0, m_protection_ram[0]);
	309	m_maincpu->set_input_line(0, HOLD_LINE);        // HOLD_LINE works better in Z80 interrupt mode 1.
	310	m_mcu->execute().set_input_line(0, CLEAR_LINE);
311	311	}
312	312
313	313	if (BIT(m_ddr_b, 6) && BIT(~data, 6) && BIT(m_port_b_out, 6))

trunk/src/mame/machine/amiga.c

r17814	r17815
995	995	if ( CUSTOM_REG(REG_DMACON) & 0x0400 )
996	996	{
997	997	/* simulate the 68k not running while the blit is going */
998		device_adjust_icount( &space->device(), -(blittime/2) );
	998	space->device().execute().adjust_icount(-(blittime/2) );
999	999
1000	1000	blittime = BLITTER_NASTY_DELAY;
1001	1001	}

trunk/src/mame/machine/lkage.c

r17814	r17815
64	64	{
65	65	m_port_a_in = m_from_main;
66	66	if (m_main_sent)
67		device_set_input_line(m_mcu, 0, CLEAR_LINE);
	67	m_mcu->execute().set_input_line(0, CLEAR_LINE);
68	68
69	69	m_main_sent = 0;
70	70	logerror("read command %02x from main cpu\n", m_port_a_in);
r17814	r17815
119	119	logerror("%04x: mcu_w %02x\n", space.device().safe_pc(), data);
120	120	m_from_main = data;
121	121	m_main_sent = 1;
122		device_set_input_line(m_mcu, 0, ASSERT_LINE);
	122	m_mcu->execute().set_input_line(0, ASSERT_LINE);
123	123	}
124	124
125	125	READ8_MEMBER(lkage_state::lkage_mcu_r)

trunk/src/mame/machine/cdislave.c

r17814	r17815
59	59	void cdislave_device::readback_trigger()
60	60	{
61	61	verboselog(machine(), 0, "Asserting IRQ2\n" );
62		device_set_input_line_vector(machine().device("maincpu"), M68K_IRQ_2, 26);
	62	machine().device("maincpu")->execute().set_input_line_vector(M68K_IRQ_2, 26);
63	63	machine().device("maincpu")->execute().set_input_line(M68K_IRQ_2, ASSERT_LINE);
64	64	m_interrupt_timer->adjust(attotime::never);
65	65	}

trunk/src/mame/machine/midwunit.c

r17814	r17815
190	190	without significantly impacting the rest of the system.
191	191	*/
192	192	COMBINE_DATA(&m_umk3_palette[offset]);
193		device_adjust_icount(&space.device(), -100);
	193	space.device().execute().adjust_icount(-100);
194	194	/*  printf("in=%04X%04X  out=%04X%04X\n", m_umk3_palette[3], m_umk3_palette[2], m_umk3_palette[1], m_umk3_palette[0]); */
195	195	}
196	196

trunk/src/mame/machine/namco50.c

r17814	r17815
205	205	static TIMER_CALLBACK( namco_50xx_irq_clear )
206	206	{
207	207	namco_50xx_state *state = get_safe_token((device_t *)ptr);
208		device_set_input_line(state->m_cpu, 0, CLEAR_LINE);
	208	state->m_cpu->execute().set_input_line(0, CLEAR_LINE);
209	209	}
210	210
211	211	static void namco_50xx_irq_set(device_t *device)
212	212	{
213	213	namco_50xx_state *state = get_safe_token(device);
214	214
215		device_set_input_line(state->m_cpu, 0, ASSERT_LINE);
	215	state->m_cpu->execute().set_input_line(0, ASSERT_LINE);
216	216
217	217	// The execution time of one instruction is ~4us, so we must make sure to
218	218	// give the cpu time to poll the /IRQ input before we clear it.

trunk/src/mame/machine/namcos2.c

r17814	r17815
501	501	// If writing an IRQ priority register, clear any pending IRQs.
502	502	// Dirt Fox and Winning Run require this behaviour
503	503	if (reg < 8)
504		device_set_input_line(&space->device(), pC148Reg[reg], CLEAR_LINE);
	504	space->device().execute().set_input_line(pC148Reg[reg], CLEAR_LINE);
505	505
506	506	pC148Reg[reg] = data & 0x0007;
507	507	}
r17814	r17815
525	525	// mame_printf_debug( "cpu(%d) RAM[0x%06x] = 0x%x\n", cpu, addr, data );
526	526	/* Dubious to assert IRQ for other CPU here, but Starblade seems to rely on it.
527	527	It fails to show large polygons otherwise. */
528		device_set_input_line(altcpu, pC148RegAlt[NAMCOS2_C148_CPUIRQ], ASSERT_LINE);
	528	altcpu->execute().set_input_line(pC148RegAlt[NAMCOS2_C148_CPUIRQ], ASSERT_LINE);
529	529	}
530	530	break;
531	531
r17814	r17815
536	536	{
537	537	// mame_printf_debug( "cpu(%d) RAM[0x%06x] = 0x%x\n", cpu, addr, data );
538	538	/* Dubious to assert IRQ for other CPU here: Rolling Thunder 2 and Fine Hour break. */
539		// device_set_input_line(altcpu, pC148RegAlt[NAMCOS2_C148_CPUIRQ], ASSERT_LINE);
	539	// altcpu->execute().set_input_line(pC148RegAlt[NAMCOS2_C148_CPUIRQ], ASSERT_LINE);
540	540	}
541	541	break;
542	542
r17814	r17815
544	544	/* IRQ ack */
545	545	case 0x1d6000: /* NAMCOS2_C148_CPUIRQ */
546	546	// if( bWrite ) mame_printf_debug( "cpu(%d) RAM[0x%06x] = 0x%x\n", cpu, addr, data );
547		device_set_input_line(&space->device(), pC148Reg[NAMCOS2_C148_CPUIRQ], CLEAR_LINE);
	547	space->device().execute().set_input_line(pC148Reg[NAMCOS2_C148_CPUIRQ], CLEAR_LINE);
548	548	break;
549	549
550	550	case 0x1d8000: /* NAMCOS2_C148_EXIRQ */
551	551	// if( bWrite ) mame_printf_debug( "cpu(%d) RAM[0x%06x] = 0x%x\n", cpu, addr, data );
552		device_set_input_line(&space->device(), pC148Reg[NAMCOS2_C148_EXIRQ], CLEAR_LINE);
	552	space->device().execute().set_input_line(pC148Reg[NAMCOS2_C148_EXIRQ], CLEAR_LINE);
553	553	break;
554	554
555	555	case 0x1da000: /* NAMCOS2_C148_POSIRQ */
556	556	// if( bWrite ) mame_printf_debug( "cpu(%d) RAM[0x%06x] = 0x%x\n", cpu, addr, data );
557		device_set_input_line(&space->device(), pC148Reg[NAMCOS2_C148_POSIRQ], CLEAR_LINE);
	557	space->device().execute().set_input_line(pC148Reg[NAMCOS2_C148_POSIRQ], CLEAR_LINE);
558	558	break;
559	559
560	560	case 0x1dc000: /* NAMCOS2_C148_SERIRQ */
561	561	// if( bWrite ) mame_printf_debug( "cpu(%d) RAM[0x%06x] = 0x%x\n", cpu, addr, data );
562		device_set_input_line(&space->device(), pC148Reg[NAMCOS2_C148_SERIRQ], CLEAR_LINE);
	562	space->device().execute().set_input_line(pC148Reg[NAMCOS2_C148_SERIRQ], CLEAR_LINE);
563	563	break;
564	564
565	565	case 0x1de000: /* NAMCOS2_C148_VBLANKIRQ */
566		device_set_input_line(&space->device(), pC148Reg[NAMCOS2_C148_VBLANKIRQ], CLEAR_LINE);
	566	space->device().execute().set_input_line(pC148Reg[NAMCOS2_C148_VBLANKIRQ], CLEAR_LINE);
567	567	break;
568	568
569	569
r17814	r17815
578	578	{
579	579	/* Resume execution */
580	580	space->machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
581		device_yield(&space->device());
	581	space->device().execute().yield();
582	582	}
583	583	else
584	584	{
r17814	r17815
603	603	{ /* Resume execution */
604	604	ResetAllSubCPUs(space->machine(), CLEAR_LINE);
605	605	/* Give the new CPU an immediate slice of the action */
606		device_yield(&space->device());
	606	space->device().execute().yield();
607	607	}
608	608	else
609	609	{ /* Suspend execution */
r17814	r17815
687	687	{
688	688	namcos2_shared_state *state = device->machine().driver_data<namcos2_shared_state>();
689	689	if (!state->is_system21()) namcos2_adjust_posirq_timer(device->machine(), GetPosIRQScanline(device->machine()));
690		device_set_input_line(device, namcos2_68k_master_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
	690	device->execute().set_input_line(namcos2_68k_master_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
691	691	}
692	692
693	693	INTERRUPT_GEN( namcos2_68k_slave_vblank )
694	694	{
695	695	namcos2_shared_state *state = device->machine().driver_data<namcos2_shared_state>();
696	696	if (!state->is_system21()) namcos2_adjust_posirq_timer(device->machine(), GetPosIRQScanline(device->machine()));
697		device_set_input_line(device, namcos2_68k_slave_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
	697	device->execute().set_input_line(namcos2_68k_slave_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
698	698	}
699	699
700	700	INTERRUPT_GEN( namcos2_68k_gpu_vblank )
r17814	r17815
705	705
706	706	//printf( "namcos2_68k_gpu_vblank(%d)\n",namcos2_68k_gpu_C148[NAMCOS2_C148_POSIRQ] );
707	707	namcos2_adjust_posirq_timer(device->machine(), scanline);
708		device_set_input_line(device, namcos2_68k_gpu_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
	708	device->execute().set_input_line(namcos2_68k_gpu_C148[NAMCOS2_C148_VBLANKIRQ], HOLD_LINE);
709	709	}
710	710
711	711	/**************************************************************/

trunk/src/mame/machine/pgmprot2.c

r17814	r17815
37	37	{
38	38	pgm_arm_type2_state *state = space->machine().driver_data<pgm_arm_type2_state>();
39	39
40		device_set_input_line(state->m_prot, ARM7_FIRQ_LINE, CLEAR_LINE ); // guess
	40	state->m_prot->set_input_line(ARM7_FIRQ_LINE, CLEAR_LINE ); // guess
41	41
42	42	if (PGMARM7LOGERROR)
43	43	logerror("ARM7: Latch read: %08x (%08x) (%06x)\n", state->m_kov2_latchdata_68k_w, mem_mask, space->device().safe_pc());
r17814	r17815
89	89	logerror("M68K: Latch write: %04x (%04x) (%06x)\n", data & 0x0000ffff, mem_mask, space->device().safe_pc());
90	90	COMBINE_DATA(&state->m_kov2_latchdata_68k_w);
91	91
92		device_set_input_line(state->m_prot, ARM7_FIRQ_LINE, ASSERT_LINE ); // guess
	92	state->m_prot->set_input_line(ARM7_FIRQ_LINE, ASSERT_LINE ); // guess
93	93	}
94	94
95	95	static READ16_HANDLER( arm7_ram_r )
r17814	r17815
271	271	if (r4==0x18002f9e)
272	272	{
273	273	UINT32 data2 =  state->m_arm_ram[0x2F9C/4]&0xffff0000;
274		if ((data==0x00000000) && (data2==0x00000000)) device_spin_until_interrupt(&space->device());
	274	if ((data==0x00000000) && (data2==0x00000000)) space->device().execute().spin_until_interrupt();
275	275	}
276	276	}
277	277
r17814	r17815
284	284	UINT16 data = pgm_mainram[0x0ee54/2];
285	285	int pc = space->device().safe_pc();
286	286
287		if (pc == 0x149dce) device_spin_until_interrupt(&space->device());
288		if (pc == 0x149cfe) device_spin_until_interrupt(&space->device());
	287	if (pc == 0x149dce) space->device().execute().spin_until_interrupt();
	288	if (pc == 0x149cfe) space->device().execute().spin_until_interrupt();
289	289
290	290	return data;
291	291

trunk/src/mame/machine/harddriv.c

r17814	r17815
74	74	atarigen_interrupt_reset(state, hd68k_update_interrupts);
75	75
76	76	/* halt several of the DSPs to start */
77		if (state->m_adsp != NULL) device_set_input_line(state->m_adsp, INPUT_LINE_HALT, ASSERT_LINE);
78		if (state->m_dsp32 != NULL) device_set_input_line(state->m_dsp32, INPUT_LINE_HALT, ASSERT_LINE);
79		if (state->m_sounddsp != NULL) device_set_input_line(state->m_sounddsp, INPUT_LINE_HALT, ASSERT_LINE);
	77	if (state->m_adsp != NULL) state->m_adsp->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
	78	if (state->m_dsp32 != NULL) state->m_dsp32->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
	79	if (state->m_sounddsp != NULL) state->m_sounddsp->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
80	80
81	81	/* if we found a 6502, reset the JSA board */
82	82	if (state->m_jsacpu != NULL)
r17814	r17815
106	106	static void hd68k_update_interrupts(running_machine &machine)
107	107	{
108	108	harddriv_state *state = machine.driver_data<harddriv_state>();
109		device_set_input_line(state->m_maincpu, 1, state->m_msp_irq_state ? ASSERT_LINE : CLEAR_LINE);
110		device_set_input_line(state->m_maincpu, 2, state->m_adsp_irq_state ? ASSERT_LINE : CLEAR_LINE);
111		device_set_input_line(state->m_maincpu, 3, state->m_gsp_irq_state ? ASSERT_LINE : CLEAR_LINE);
112		device_set_input_line(state->m_maincpu, 4, state->m_sound_int_state ? ASSERT_LINE : CLEAR_LINE);   /* /LINKIRQ on STUN Runner */
113		device_set_input_line(state->m_maincpu, 5, state->m_irq_state ? ASSERT_LINE : CLEAR_LINE);
114		device_set_input_line(state->m_maincpu, 6, state->m_duart_irq_state ? ASSERT_LINE : CLEAR_LINE);
	109	state->m_maincpu->set_input_line(1, state->m_msp_irq_state ? ASSERT_LINE : CLEAR_LINE);
	110	state->m_maincpu->set_input_line(2, state->m_adsp_irq_state ? ASSERT_LINE : CLEAR_LINE);
	111	state->m_maincpu->set_input_line(3, state->m_gsp_irq_state ? ASSERT_LINE : CLEAR_LINE);
	112	state->m_maincpu->set_input_line(4, state->m_sound_int_state ? ASSERT_LINE : CLEAR_LINE);   /* /LINKIRQ on STUN Runner */
	113	state->m_maincpu->set_input_line(5, state->m_irq_state ? ASSERT_LINE : CLEAR_LINE);
	114	state->m_maincpu->set_input_line(6, state->m_duart_irq_state ? ASSERT_LINE : CLEAR_LINE);
115	115	}
116	116
117	117
r17814	r17815
428	428	case 6:   /* /GSPRES */
429	429	logerror("Write to /GSPRES(%d)\n", data);
430	430	if (state->m_gsp != NULL)
431		device_set_input_line(state->m_gsp, INPUT_LINE_RESET, data ? CLEAR_LINE : ASSERT_LINE);
	431	state->m_gsp->set_input_line(INPUT_LINE_RESET, data ? CLEAR_LINE : ASSERT_LINE);
432	432	break;
433	433	case 7:   /* /MSPRES */
434	434	logerror("Write to /MSPRES(%d)\n", data);
435	435	if (state->m_msp != NULL)
436		device_set_input_line(state->m_msp, INPUT_LINE_RESET, data ? CLEAR_LINE : ASSERT_LINE);
	436	state->m_msp->set_input_line(INPUT_LINE_RESET, data ? CLEAR_LINE : ASSERT_LINE);
437	437	break;
438	438	}
439	439	}
r17814	r17815
502	502	{
503	503	state->m_last_gsp_shiftreg = new_shiftreg;
504	504	if (new_shiftreg)
505		device_yield(&space->device());
	505	space->device().execute().yield();
506	506	}
507	507	}
508	508
r17814	r17815
599	599	{
600	600	logerror("%06X:ADSP sync address written (%04X)\n", space->device().safe_pcbase(), data);
601	601	space->machine().scheduler().synchronize();
602		device_triggerint(state->m_adsp);
	602	state->m_adsp->signal_interrupt_trigger();
603	603	}
604	604	else
605	605	logerror("%06X:ADSP W@%04X (%04X)\n", space->device().safe_pcbase(), offset, data);
r17814	r17815
714	714	state->m_adsp_br = !val;
715	715	logerror("ADSP /BR = %d\n", !state->m_adsp_br);
716	716	if (state->m_adsp_br || state->m_adsp_halt)
717		device_set_input_line(state->m_adsp, INPUT_LINE_HALT, ASSERT_LINE);
	717	state->m_adsp->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
718	718	else
719	719	{
720		device_set_input_line(state->m_adsp, INPUT_LINE_HALT, CLEAR_LINE);
	720	state->m_adsp->set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
721	721	/* a yield in this case is not enough */
722	722	/* we would need to increase the interleaving otherwise */
723	723	/* note that this only affects the test mode */
724		device_spin(&space->device());
	724	space->device().execute().spin();
725	725	}
726	726	break;
727	727
r17814	r17815
731	731	state->m_adsp_halt = !val;
732	732	logerror("ADSP /HALT = %d\n", !state->m_adsp_halt);
733	733	if (state->m_adsp_br || state->m_adsp_halt)
734		device_set_input_line(state->m_adsp, INPUT_LINE_HALT, ASSERT_LINE);
	734	state->m_adsp->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
735	735	else
736	736	{
737		device_set_input_line(state->m_adsp, INPUT_LINE_HALT, CLEAR_LINE);
	737	state->m_adsp->set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
738	738	/* a yield in this case is not enough */
739	739	/* we would need to increase the interleaving otherwise */
740	740	/* note that this only affects the test mode */
741		device_spin(&space->device());
	741	space->device().execute().spin();
742	742	}
743	743	break;
744	744
745	745	case 7:
746	746	logerror("ADSP reset = %d\n", val);
747		device_set_input_line(state->m_adsp, INPUT_LINE_RESET, val ? CLEAR_LINE : ASSERT_LINE);
748		device_yield(&space->device());
	747	state->m_adsp->set_input_line(INPUT_LINE_RESET, val ? CLEAR_LINE : ASSERT_LINE);
	748	space->device().execute().yield();
749	749	break;
750	750
751	751	default:
r17814	r17815
864	864	{
865	865	/* update the IRQ2 signal to the ADSP2101 */
866	866	if (!(!state->m_ds3_g68flag && state->m_ds3_g68irqs) && !(state->m_ds3_gflag && state->m_ds3_gfirqs))
867		device_set_input_line(state->m_adsp, ADSP2100_IRQ2, ASSERT_LINE);
	867	state->m_adsp->set_input_line(ADSP2100_IRQ2, ASSERT_LINE);
868	868	else
869		device_set_input_line(state->m_adsp, ADSP2100_IRQ2, CLEAR_LINE);
	869	state->m_adsp->set_input_line(ADSP2100_IRQ2, CLEAR_LINE);
870	870	}
871	871
872	872
r17814	r17815
890	890	/* the ADSP at the next instruction boundary */
891	891	state->m_adsp_br = !val;
892	892	if (state->m_adsp_br)
893		device_set_input_line(state->m_adsp, INPUT_LINE_HALT, ASSERT_LINE);
	893	state->m_adsp->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
894	894	else
895	895	{
896		device_set_input_line(state->m_adsp, INPUT_LINE_HALT, CLEAR_LINE);
	896	state->m_adsp->set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
897	897	/* a yield in this case is not enough */
898	898	/* we would need to increase the interleaving otherwise */
899	899	/* note that this only affects the test mode */
900		device_spin(&space->device());
	900	space->device().execute().spin();
901	901	}
902	902	break;
903	903
904	904	case 3:
905		device_set_input_line(state->m_adsp, INPUT_LINE_RESET, val ? CLEAR_LINE : ASSERT_LINE);
	905	state->m_adsp->set_input_line(INPUT_LINE_RESET, val ? CLEAR_LINE : ASSERT_LINE);
906	906	if (val && !state->m_ds3_reset)
907	907	{
908	908	state->m_ds3_gflag = 0;
r17814	r17815
913	913	update_ds3_irq(state);
914	914	}
915	915	state->m_ds3_reset = val;
916		device_yield(&space->device());
	916	space->device().execute().yield();
917	917	logerror("DS III reset = %d\n", val);
918	918	break;
919	919
r17814	r17815
988	988	/* if we just cleared the IRQ, we are going to do some VERY timing critical reads */
989	989	/* it is important that all the CPUs be in sync before we continue, so spin a little */
990	990	/* while to let everyone else catch up */
991		device_spin_until_trigger(&space->device(), DS3_TRIGGER);
	991	space->device().execute().spin_until_trigger(DS3_TRIGGER);
992	992	space->machine().scheduler().trigger(DS3_TRIGGER, attotime::from_usec(5));
993	993
994	994	return state->m_ds3_gdata;
r17814	r17815
1004	1004	COMBINE_DATA(&state->m_ds3_g68data);
1005	1005	state->m_ds3_g68flag = 1;
1006	1006	state->m_ds3_gcmd = offset & 1;
1007		device_triggerint(state->m_adsp);
	1007	state->m_adsp->signal_interrupt_trigger();
1008	1008	update_ds3_irq(state);
1009	1009	}
1010	1010
r17814	r17815
1202	1202	switch (offset & 7)
1203	1203	{
1204	1204	case 0:   /* DSPRESTN */
1205		device_set_input_line(state->m_dsp32, INPUT_LINE_RESET, val ? CLEAR_LINE : ASSERT_LINE);
	1205	state->m_dsp32->set_input_line(INPUT_LINE_RESET, val ? CLEAR_LINE : ASSERT_LINE);
1206	1206	break;
1207	1207
1208	1208	case 1:   /* DSPZN */
1209		device_set_input_line(state->m_dsp32, INPUT_LINE_HALT, val ? CLEAR_LINE : ASSERT_LINE);
	1209	state->m_dsp32->set_input_line(INPUT_LINE_HALT, val ? CLEAR_LINE : ASSERT_LINE);
1210	1210	break;
1211	1211
1212	1212	case 2:   /* ZW1 */
r17814	r17815
1549	1549	&space->device() == state->m_gsp && space->device().safe_pc() == state->m_gsp_speedup_pc)
1550	1550	{
1551	1551	state->m_gsp_speedup_count[0]++;
1552		device_spin_until_interrupt(&space->device());
	1552	space->device().execute().spin_until_interrupt();
1553	1553	}
1554	1554
1555	1555	return result;
r17814	r17815
1564	1564
1565	1565	/* if $ffff is written, send an "interrupt" trigger to break us out of the spin loop */
1566	1566	if (state->m_gsp_speedup_addr[0][offset] == 0xffff)
1567		device_triggerint(state->m_gsp);
	1567	state->m_gsp->signal_interrupt_trigger();
1568	1568	}
1569	1569
1570	1570
r17814	r17815
1576	1576
1577	1577	/* if $ffff is written, send an "interrupt" trigger to break us out of the spin loop */
1578	1578	if (state->m_gsp_speedup_addr[1][offset] == 0xffff)
1579		device_triggerint(state->m_gsp);
	1579	state->m_gsp->signal_interrupt_trigger();
1580	1580	}
1581	1581
1582	1582
r17814	r17815
1599	1599	(result & 0xff) < space->device().state().state_int(TMS34010_A1))
1600	1600	{
1601	1601	state->m_gsp_speedup_count[0]++;
1602		device_spin_until_interrupt(&space->device());
	1602	space->device().execute().spin_until_interrupt();
1603	1603	}
1604	1604
1605	1605	return result;
r17814	r17815
1611	1611	harddriv_state *state = space->machine().driver_data<harddriv_state>();
1612	1612	COMBINE_DATA(&state->m_gsp_speedup_addr[0][offset]);
1613	1613	if (&space->device() != state->m_gsp)
1614		device_triggerint(state->m_gsp);
	1614	state->m_gsp->signal_interrupt_trigger();
1615	1615	}
1616	1616
1617	1617
r17814	r17815
1635	1635	if (data == 0 && &space->device() == state->m_msp && space->device().safe_pc() == state->m_msp_speedup_pc)
1636	1636	{
1637	1637	state->m_msp_speedup_count[0]++;
1638		device_spin_until_interrupt(&space->device());
	1638	space->device().execute().spin_until_interrupt();
1639	1639	}
1640	1640
1641	1641	return data;
r17814	r17815
1647	1647	harddriv_state *state = space->machine().driver_data<harddriv_state>();
1648	1648	COMBINE_DATA(&state->m_msp_speedup_addr[offset]);
1649	1649	if (offset == 0 && state->m_msp_speedup_addr[offset] != 0)
1650		device_triggerint(state->m_msp);
	1650	state->m_msp->signal_interrupt_trigger();
1651	1651	}
1652	1652
1653	1653
r17814	r17815
1670	1670	if (data == 0xffff && &space->device() == state->m_adsp && space->device().safe_pc() <= 0x3b)
1671	1671	{
1672	1672	state->m_adsp_speedup_count[0]++;
1673		device_spin_until_interrupt(&space->device());
	1673	space->device().execute().spin_until_interrupt();
1674	1674	}
1675	1675
1676	1676	return data;
r17814	r17815
1685	1685	if (data != 0 && &space->device() == state->m_adsp && space->device().safe_pc() == state->m_ds3_speedup_pc)
1686	1686	{
1687	1687	state->m_adsp_speedup_count[2]++;
1688		device_spin_until_interrupt(&space->device());
	1688	space->device().execute().spin_until_interrupt();
1689	1689	}
1690	1690
1691	1691	return data;

trunk/src/mame/machine/megacd.c

r17814	r17815
2266	2266
2267	2267
2268	2268
2269		device_set_irq_callback(machine.device("segacd_68k"), segacd_sub_int_callback);
	2269	machine.device("segacd_68k")->execute().set_irq_acknowledge_callback(segacd_sub_int_callback);
2270	2270
2271	2271	space->install_legacy_read_handler (0x0000070, 0x0000073, FUNC(scd_hint_vector_r) );
2272	2272
r17814	r17815
2331	2331
2332	2332	MACHINE_RESET( segacd )
2333	2333	{
2334		device_set_input_line(_segacd_68k_cpu, INPUT_LINE_RESET, ASSERT_LINE);
2335		device_set_input_line(_segacd_68k_cpu, INPUT_LINE_HALT, ASSERT_LINE);
	2334	_segacd_68k_cpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
	2335	_segacd_68k_cpu->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
2336	2336
2337	2337	segacd_hint_register = 0xffff; // -1
2338	2338

trunk/src/mame/machine/simpsons.c

r17814	r17815
47	47
48	48	READ8_MEMBER(simpsons_state::simpsons_sound_interrupt_r)
49	49	{
50		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff );
	50	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff );
51	51	return 0x00;
52	52	}
53	53
r17814	r17815
83	83	state->m_xtraram = auto_alloc_array_clear(machine, UINT8, 0x1000);
84	84	state->m_spriteram = auto_alloc_array_clear(machine, UINT16, 0x1000 / 2);
85	85
86		state->m_maincpu = machine.device("maincpu");
87		state->m_audiocpu = machine.device("audiocpu");
	86	state->m_maincpu = machine.device<cpu_device>("maincpu");
	87	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
88	88	state->m_k053260 = machine.device("k053260");
89	89	state->m_k052109 = machine.device("k052109");
90	90	state->m_k053246 = machine.device("k053246");

trunk/src/mame/machine/pgmprot3.c

r17814	r17815
270	270	{
271	271	pgm_arm_type3_state *state = space->machine().driver_data<pgm_arm_type3_state>();
272	272	int pc = space->device().safe_pc();
273		if (pc == 0x8000fea) device_eat_cycles(&space->device(), 500);
	273	if (pc == 0x8000fea) space->device().execute().eat_cycles(500);
274	274	//  else printf("dmn_speedup_r %08x\n", pc);
275	275	return state->m_arm_ram[0x000444/4];
276	276	}
r17814	r17815
279	279	{
280	280	UINT16 data = pgm_mainram[0xa03c/2];
281	281	int pc = space->device().safe_pc();
282		if (pc == 0x10193a) device_spin_until_interrupt(&space->device());
283		else if (pc == 0x1019a4) device_spin_until_interrupt(&space->device());
	282	if (pc == 0x10193a) space->device().execute().spin_until_interrupt();
	283	else if (pc == 0x1019a4) space->device().execute().spin_until_interrupt();
284	284	return data;
285	285	}
286	286

trunk/src/mame/machine/model1.c

r17814	r17815
2152	2152	if ( m_ram_adr == 0 && m_copro_fifoin_num != 0 )
2153	2153	{
2154	2154	/* spin the main cpu and let the TGP catch up */
2155		device_spin_until_time(&space.device(), attotime::from_usec(100));
	2155	space.device().execute().spin_until_time(attotime::from_usec(100));
2156	2156	}
2157	2157
2158	2158	return m_ram_adr;
r17814	r17815
2178	2178	if ( m_ram_adr == 0 && r == 0xffff )
2179	2179	{
2180	2180	/* if the TGP is busy, spin some more */
2181		device_spin_until_time(&space.device(), attotime::from_usec(100));
	2181	space.device().execute().spin_until_time(attotime::from_usec(100));
2182	2182	}
2183	2183
2184	2184	if ( m_ram_adr & 0x8000 )

trunk/src/mame/machine/megavdp.c

r17814	r17815
570	570	if (length==0x00) length = 0xffff;
571	571
572	572	/* This is a hack until real DMA timings are implemented */
573		device_spin_until_time(m_cpu68k, attotime::from_nsec(length * 1000 / 3500));
	573	m_cpu68k->spin_until_time(attotime::from_nsec(length * 1000 / 3500));
574	574
575	575	for (count = 0;count<(length>>1);count++)
576	576	{

trunk/src/mame/machine/mw8080bw.c

r17814	r17815
53	53	int vpos = machine.primary_screen->vpos();
54	54	UINT8 counter = vpos_to_vysnc_chain_counter(vpos);
55	55	UINT8 vector = 0xc7 | ((counter & 0x40) >> 2) | ((~counter & 0x40) >> 3);
56		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, vector);
	56	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, vector);
57	57
58	58	/* set up for next interrupt */
59	59	if (counter == MW8080BW_INT_TRIGGER_COUNT_1)

trunk/src/mame/machine/playch10.c

r17814	r17815
843	843
844	844	if (state->m_IRQ_enable && !blanked && (state->m_IRQ_count == 0) && priorCount) // according to blargg the latter should be present as well, but it breaks Rampart and Joe & Mac US: they probably use the alt irq!
845	845	{
846		device_set_input_line(device->machine().device("cart"), 0, HOLD_LINE);
	846	device->machine().device("cart")->execute().set_input_line(0, HOLD_LINE);
847	847	}
848	848	}
849	849	}

trunk/src/mame/machine/flstory.c

r17814	r17815
63	63	{
64	64	m_port_a_in = m_from_main;
65	65	if (m_main_sent)
66		device_set_input_line(m_mcu, 0, CLEAR_LINE);
	66	m_mcu->execute().set_input_line(0, CLEAR_LINE);
67	67	m_main_sent = 0;
68	68	logerror("read command %02x from main cpu\n", m_port_a_in);
69	69	}
r17814	r17815
114	114	logerror("%04x: mcu_w %02x\n", space.device().safe_pc(), data);
115	115	m_from_main = data;
116	116	m_main_sent = 1;
117		device_set_input_line(m_mcu, 0, ASSERT_LINE);
	117	m_mcu->execute().set_input_line(0, ASSERT_LINE);
118	118	}
119	119
120	120	READ8_MEMBER(flstory_state::flstory_mcu_r)

trunk/src/mame/machine/smpc.c

r17814	r17815
215	215	{
216	216	saturn_state *state = machine.driver_data<saturn_state>();
217	217
218		device_set_input_line(state->m_maincpu, INPUT_LINE_RESET, CLEAR_LINE);
	218	state->m_maincpu->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
219	219	}
220	220
221	221	static TIMER_CALLBACK( smpc_slave_enable )
222	222	{
223	223	saturn_state *state = machine.driver_data<saturn_state>();
224	224
225		device_set_input_line(state->m_slave, INPUT_LINE_RESET, param ? ASSERT_LINE : CLEAR_LINE);
	225	state->m_slave->set_input_line(INPUT_LINE_RESET, param ? ASSERT_LINE : CLEAR_LINE);
226	226	state->m_smpc.OREG[31] = param + 0x02; //read-back for last command issued
227	227	state->m_smpc.SF = 0x00; //clear hand-shake flag
228	228	}
r17814	r17815
231	231	{
232	232	saturn_state *state = machine.driver_data<saturn_state>();
233	233
234		device_set_input_line(state->m_audiocpu, INPUT_LINE_RESET, param ? ASSERT_LINE : CLEAR_LINE);
	234	state->m_audiocpu->set_input_line(INPUT_LINE_RESET, param ? ASSERT_LINE : CLEAR_LINE);
235	235	state->m_en_68k = param ^ 1;
236	236	state->m_smpc.OREG[31] = param + 0x06; //read-back for last command issued
237	237	state->m_smpc.SF = 0x00; //clear hand-shake flag
r17814	r17815
253	253	memset(state->m_vdp1_vram,0x00,0x100000);
254	254	//A-Bus
255	255
256		device_set_input_line(state->m_maincpu, INPUT_LINE_RESET, PULSE_LINE);
	256	state->m_maincpu->set_input_line(INPUT_LINE_RESET, PULSE_LINE);
257	257	}
258	258
259	259	static TIMER_CALLBACK( smpc_change_clock )
r17814	r17815
272	272	stv_vdp2_dynamic_res_change(machine);
273	273
274	274	if(!state->m_NMI_reset)
275		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
276		device_set_input_line(state->m_slave, INPUT_LINE_RESET, ASSERT_LINE);
	275	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
	276	state->m_slave->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
277	277
278	278	/* put issued command in OREG31 */
279	279	state->m_smpc.OREG[31] = 0x0e + param;
r17814	r17815
316	316	//  /*This is for RTC,cartridge code and similar stuff...*/
317	317	//if(LOG_SMPC) printf ("Interrupt: System Manager (SMPC) at scanline %04x, Vector 0x47 Level 0x08\n",scanline);
318	318	if(!(state->m_scu.ism & IRQ_SMPC))
319		device_set_input_line_and_vector(state->m_maincpu, 8, HOLD_LINE, 0x47);
	319	state->m_maincpu->set_input_line_and_vector(8, HOLD_LINE, 0x47);
320	320	else
321	321	state->m_scu.ist |= (IRQ_SMPC);
322	322
r17814	r17815
515	515	}
516	516
517	517	if(!(state->m_scu.ism & IRQ_SMPC))
518		device_set_input_line_and_vector(state->m_maincpu, 8, HOLD_LINE, 0x47);
	518	state->m_maincpu->set_input_line_and_vector(8, HOLD_LINE, 0x47);
519	519	else
520	520	state->m_scu.ist |= (IRQ_SMPC);
521	521
r17814	r17815
563	563	state->m_smpc.pmode = state->m_smpc.IREG[0]>>4;
564	564
565	565	if(!(state->m_scu.ism & IRQ_SMPC))
566		device_set_input_line_and_vector(state->m_maincpu, 8, HOLD_LINE, 0x47);
	566	state->m_maincpu->set_input_line_and_vector(8, HOLD_LINE, 0x47);
567	567	else
568	568	state->m_scu.ist |= (IRQ_SMPC);
569	569
r17814	r17815
609	609	saturn_state *state = machine.driver_data<saturn_state>();
610	610
611	611	/*NMI is unconditionally requested */
612		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	612	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
613	613	}
614	614
615	615	static void smpc_nmi_set(running_machine &machine,UINT8 cmd)
r17814	r17815
810	810
811	811	if(LOG_SMPC) printf("SMPC: M68k %s\n",(data & 0x10) ? "off" : "on");
812	812	//space->machine().scheduler().timer_set(attotime::from_usec(100), FUNC(smpc_sound_enable),(state->m_smpc_ram[0x77] & 0x10) >> 4);
813		device_set_input_line(state->m_audiocpu, INPUT_LINE_RESET, (data & 0x10) ? ASSERT_LINE : CLEAR_LINE);
	813	state->m_audiocpu->set_input_line(INPUT_LINE_RESET, (data & 0x10) ? ASSERT_LINE : CLEAR_LINE);
814	814	state->m_en_68k = ((data & 0x10) >> 4) ^ 1;
815	815
816	816	//if(LOG_SMPC) printf("SMPC: ram [0x77] = %02x\n",data);

trunk/src/mame/machine/fd1094.c

r17814	r17815
721	721	// register for the state changing callbacks we need in the m68000
722	722	m68k_set_cmpild_callback(this, &fd1094_device::cmp_callback);
723	723	m68k_set_rte_callback(this, &fd1094_device::rte_callback);
724		device_set_irq_callback(this, &fd1094_device::irq_callback);
	724	set_irq_acknowledge_callback(&fd1094_device::irq_callback);
725	725
726	726	// save state
727	727	save_item(NAME(m_state));

trunk/src/mame/machine/slapfght.c

r17814	r17815
766	766	{
767	767	slapfght_state *state = device->machine().driver_data<slapfght_state>();
768	768	if (state->m_getstar_sh_intenabled)
769		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	769	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
770	770	}
771	771
772	772	#ifdef UNUSED_FUNCTION

trunk/src/mame/machine/decocass.c

r17814	r17815
65	65	state->m_sound_ack |= 0x80;
66	66	/* remove snd cpu data ack bit. i don't see it in the schems, but... */
67	67	state->m_sound_ack &= ~0x40;
68		device_set_input_line(state->m_audiocpu, M6502_IRQ_LINE, ASSERT_LINE);
	68	state->m_audiocpu->set_input_line(M6502_IRQ_LINE, ASSERT_LINE);
69	69	}
70	70
71	71	READ8_HANDLER( decocass_sound_data_r )
r17814	r17815
97	97	decocass_state *state = space->machine().driver_data<decocass_state>();
98	98	UINT8 data = state->soundlatch_byte_r(*space, 0);
99	99	LOG(4,("CPU %s sound command <- $%02x\n", space->device().tag(), data));
100		device_set_input_line(state->m_audiocpu, M6502_IRQ_LINE, CLEAR_LINE);
	100	state->m_audiocpu->set_input_line(M6502_IRQ_LINE, CLEAR_LINE);
101	101	state->m_sound_ack &= ~0x80;
102	102	return data;
103	103	}
r17814	r17815
107	107	decocass_state *state = timer.machine().driver_data<decocass_state>();
108	108	int scanline = param;
109	109	state->m_audio_nmi_state = scanline & 8;
110		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, (state->m_audio_nmi_enabled && state->m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
	110	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, (state->m_audio_nmi_enabled && state->m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
111	111	}
112	112
113	113	WRITE8_HANDLER( decocass_sound_nmi_enable_w )
114	114	{
115	115	decocass_state *state = space->machine().driver_data<decocass_state>();
116	116	state->m_audio_nmi_enabled = 1;
117		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, (state->m_audio_nmi_enabled && state->m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
	117	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, (state->m_audio_nmi_enabled && state->m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
118	118	}
119	119
120	120	READ8_HANDLER( decocass_sound_nmi_enable_r )
121	121	{
122	122	decocass_state *state = space->machine().driver_data<decocass_state>();
123	123	state->m_audio_nmi_enabled = 1;
124		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, (state->m_audio_nmi_enabled && state->m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
	124	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, (state->m_audio_nmi_enabled && state->m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
125	125	return 0xff;
126	126	}
127	127
r17814	r17815
144	144	WRITE8_HANDLER( decocass_nmi_reset_w )
145	145	{
146	146	decocass_state *state = space->machine().driver_data<decocass_state>();
147		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, CLEAR_LINE );
	147	state->m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE );
148	148	}
149	149
150	150	WRITE8_HANDLER( decocass_quadrature_decoder_reset_w )
r17814	r17815
214	214	state->m_decocass_reset = data;
215	215
216	216	/* CPU #1 active high reset */
217		device_set_input_line(state->m_audiocpu, INPUT_LINE_RESET, data & 0x01);
	217	state->m_audiocpu->set_input_line(INPUT_LINE_RESET, data & 0x01);
218	218
219	219	/* on reset also disable audio NMI */
220	220	if (data & 1)
221	221	{
222	222	state->m_audio_nmi_enabled = 0;
223		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, (state->m_audio_nmi_enabled && state->m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
	223	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, (state->m_audio_nmi_enabled && state->m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
224	224	}
225	225
226	226	/* 8041 active low reset */
227		device_set_input_line(state->m_mcu, INPUT_LINE_RESET, (data & 0x08) ? ASSERT_LINE : CLEAR_LINE);
	227	state->m_mcu->execute().set_input_line(INPUT_LINE_RESET, (data & 0x08) ? ASSERT_LINE : CLEAR_LINE);
228	228	}
229	229
230	230
r17814	r17815
1352	1352	{
1353	1353	decocass_state *state = machine.driver_data<decocass_state>();
1354	1354
1355		state->m_maincpu = machine.device("maincpu");
1356		state->m_audiocpu = machine.device("audiocpu");
	1355	state->m_maincpu = machine.device<cpu_device>("maincpu");
	1356	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
1357	1357	state->m_mcu = machine.device("mcu");
1358	1358	state->m_cassette = machine.device("cassette");
1359	1359	}

trunk/src/mame/machine/decocass.h

r17814	r17815
131	131	UINT8     m_mux_data;
132	132
133	133	/* devices */
134		device_t *m_maincpu;
135		device_t *m_audiocpu;
	134	cpu_device *m_maincpu;
	135	cpu_device *m_audiocpu;
136	136	device_t *m_mcu;
137	137	device_t *m_cassette;
138	138	DECLARE_DRIVER_INIT(decocass);

trunk/src/mame/machine/konppc.c

r17814	r17815
161	161	k033906_set_reg(k033906, (data & 0x20000000) ? 1 : 0);
162	162
163	163	if (data & 0x10000000)
164		device_set_input_line(dsp, INPUT_LINE_RESET, CLEAR_LINE);
	164	dsp->execute().set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
165	165	else
166		device_set_input_line(dsp, INPUT_LINE_RESET, ASSERT_LINE);
	166	dsp->execute().set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
167	167
168	168	if (data & 0x02000000)
169		device_set_input_line(dsp, INPUT_LINE_IRQ0, ASSERT_LINE);
	169	dsp->execute().set_input_line(INPUT_LINE_IRQ0, ASSERT_LINE);
170	170
171	171	if (data & 0x04000000)
172		device_set_input_line(dsp, INPUT_LINE_IRQ1, ASSERT_LINE);
	172	dsp->execute().set_input_line(INPUT_LINE_IRQ1, ASSERT_LINE);
173	173	}
174	174
175	175	if (ACCESSING_BITS_0_7)

trunk/src/mame/machine/leland.c

r17814	r17815
453	453	{
454	454	/* check for coins here */
455	455	if ((device->machine().root_device().ioport("IN1")->read() & 0x0e) != 0x0e)
456		device_set_input_line(device, INPUT_LINE_NMI, ASSERT_LINE);
	456	device->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
457	457	}
458	458
459	459

trunk/src/mame/machine/toaplan1.c

r17814	r17815
44	44	toaplan1_state *state = device->machine().driver_data<toaplan1_state>();
45	45
46	46	if (state->m_intenable)
47		device_set_input_line(device, 4, HOLD_LINE);
	47	device->execute().set_input_line(4, HOLD_LINE);
48	48	}
49	49
50	50	WRITE16_MEMBER(toaplan1_state::toaplan1_intenable_w)
r17814	r17815
317	317	devtag_reset(machine(), "ymsnd");
318	318	device_t *audiocpu = machine().device("audiocpu");
319	319	if (audiocpu != NULL && audiocpu->type() == Z80)
320		device_set_input_line(audiocpu, INPUT_LINE_RESET, PULSE_LINE);
	320	audiocpu->execute().set_input_line(INPUT_LINE_RESET, PULSE_LINE);
321	321	}
322	322	}
323	323

trunk/src/mame/machine/buggychl.c

r17814	r17815
94	94	{
95	95	state->m_port_a_in = state->m_from_main;
96	96	if (state->m_main_sent)
97		device_set_input_line(state->m_mcu, 0, CLEAR_LINE);
	97	state->m_mcu->execute().set_input_line(0, CLEAR_LINE);
98	98	state->m_main_sent = 0;
99	99	logerror("read command %02x from main cpu\n", state->m_port_a_in);
100	100	}
r17814	r17815
156	156	logerror("%04x: mcu_w %02x\n", state->m_mcu->safe_pc(), data);
157	157	state->m_from_main = data;
158	158	state->m_main_sent = 1;
159		device_set_input_line(state->m_mcu, 0, ASSERT_LINE);
	159	state->m_mcu->execute().set_input_line(0, ASSERT_LINE);
160	160	}
161	161
162	162	READ8_DEVICE_HANDLER( buggychl_mcu_r )

trunk/src/mame/machine/namco53.c

r17814	r17815
113	113	static TIMER_CALLBACK( namco_53xx_irq_clear )
114	114	{
115	115	namco_53xx_state *state = get_safe_token((device_t *)ptr);
116		device_set_input_line(state->m_cpu, 0, CLEAR_LINE);
	116	state->m_cpu->execute().set_input_line(0, CLEAR_LINE);
117	117	}
118	118
119	119	void namco_53xx_read_request(device_t *device)
120	120	{
121	121	namco_53xx_state *state = get_safe_token(device);
122		device_set_input_line(state->m_cpu, 0, ASSERT_LINE);
	122	state->m_cpu->execute().set_input_line(0, ASSERT_LINE);
123	123
124	124	// The execution time of one instruction is ~4us, so we must make sure to
125	125	// give the cpu time to poll the /IRQ input before we clear it.

trunk/src/mame/machine/n64.c

r17814	r17815
564	564	//printf("sp_set_status: %08x\n", status);
565	565	if (status & 0x1)
566	566	{
567		device_set_input_line(rspcpu, INPUT_LINE_HALT, ASSERT_LINE);
	567	rspcpu->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
568	568	rspcpu->state().set_state_int(RSP_SR, rspcpu->state().state_int(RSP_SR) | RSP_STATUS_HALT);
569	569	}
570	570
r17814	r17815
612	612
613	613	case 0x1c/4:      // SP_SEMAPHORE_REG
614	614	//machine().scheduler().boost_interleave(attotime::from_usec(1), attotime::from_usec(1));
615		device_yield(machine().device("maincpu"));
	615	machine().device("maincpu")->execute().yield();
616	616	if( sp_semaphore )
617	617	{
618	618	ret = 1;
r17814	r17815
724	724	// printf( "RSP_STATUS_REG Write; %08x\n", data );
725	725	if (data & 0x00000001)      // clear halt
726	726	{
727		device_set_input_line(rspcpu, INPUT_LINE_HALT, CLEAR_LINE);
	727	rspcpu->execute().set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
728	728	newstatus &= ~RSP_STATUS_HALT;
729	729	//printf("***SP HALT CLR***\n"); fflush(stdout);
730	730	}
731	731	if (data & 0x00000002)      // set halt
732	732	{
733		device_set_input_line(rspcpu, INPUT_LINE_HALT, ASSERT_LINE);
	733	rspcpu->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
734	734	newstatus |= RSP_STATUS_HALT;
735	735	//printf("***SP HALT SET***\n"); fflush(stdout);
736	736	}
r17814	r17815
761	761	if(!(oldstatus & (RSP_STATUS_BROKE | RSP_STATUS_HALT)))
762	762	{
763	763	rspcpu->state().set_state_int(RSP_STEPCNT, 1 );
764		device_yield(machine().device("rsp"));
	764	machine().device("rsp")->execute().yield();
765	765	}
766	766	}
767	767	if (data & 0x00000080)
r17814	r17815
1407	1407	static TIMER_CALLBACK(pi_dma_callback)
1408	1408	{
1409	1409	machine.device<n64_periphs>("rcp")->pi_dma_tick();
1410		device_yield(machine.device("rsp"));
	1410	machine.device("rsp")->execute().yield();
1411	1411	}
1412	1412
1413	1413	void n64_periphs::pi_dma_tick()

trunk/src/mame/machine/stfight.c

r17814	r17815
119	119	INTERRUPT_GEN( stfight_vb_interrupt )
120	120	{
121	121	// Do a RST10
122		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0xd7);
	122	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0xd7);
123	123	device->machine().scheduler().timer_set(attotime::from_hz(120), FUNC(stfight_interrupt_1));
124	124	}
125	125

trunk/src/mame/machine/snes.c

r17814	r17815
106	106	snes_state *state = machine.driver_data<snes_state>();
107	107
108	108	// pull NMI
109		device_set_input_line(state->m_maincpu, G65816_LINE_NMI, ASSERT_LINE);
	109	state->m_maincpu->set_input_line(G65816_LINE_NMI, ASSERT_LINE);
110	110
111	111	// don't happen again
112	112	state->m_nmi_timer->adjust(attotime::never);
r17814	r17815
120	120	// (don't need to switch to the 65816 context, we don't do anything dependant on it)
121	121	snes_latch_counters(machine);
122	122	snes_ram[TIMEUP] = 0x80;   /* Indicate that irq occurred */
123		device_set_input_line(state->m_maincpu, G65816_LINE_IRQ, ASSERT_LINE);
	123	state->m_maincpu->set_input_line(G65816_LINE_IRQ, ASSERT_LINE);
124	124
125	125	// don't happen again
126	126	state->m_hirq_timer->adjust(attotime::never);
r17814	r17815
180	180	snes_ram[TIMEUP] = 0x80;   /* Indicate that irq occurred */
181	181	// IRQ latches the counters, do it now
182	182	snes_latch_counters(machine);
183		device_set_input_line(state->m_maincpu, G65816_LINE_IRQ, ASSERT_LINE );
	183	state->m_maincpu->set_input_line(G65816_LINE_IRQ, ASSERT_LINE );
184	184	}
185	185	}
186	186	/* Horizontal IRQ timer */
r17814	r17815
244	244	snes_ram[STAT78] ^= 0x80;      /* Toggle field flag */
245	245	snes_ppu.stat77_flags &= 0x3f;   /* Clear Time Over and Range Over bits */
246	246
247		device_set_input_line(state->m_maincpu, G65816_LINE_NMI, CLEAR_LINE );
	247	state->m_maincpu->set_input_line(G65816_LINE_NMI, CLEAR_LINE );
248	248	}
249	249
250	250	state->m_scanline_timer->adjust(attotime::never);
r17814	r17815
511	511	return value | 2; //CPU version number
512	512	case TIMEUP:      /* IRQ flag by H/V count timer */
513	513	value = (snes_open_bus_r(space, 0) & 0x7f) | (snes_ram[TIMEUP] & 0x80);
514		device_set_input_line(state->m_maincpu, G65816_LINE_IRQ, CLEAR_LINE );
	514	state->m_maincpu->set_input_line(G65816_LINE_IRQ, CLEAR_LINE );
515	515	snes_ram[TIMEUP] = 0;   // flag is cleared on both read and write
516	516	return value;
517	517	case HVBJOY:      /* H/V blank and joypad controller enable */
r17814	r17815
688	688	case NMITIMEN:   /* Flag for v-blank, timer int. and joy read */
689	689	if((data & 0x30) == 0x00)
690	690	{
691		device_set_input_line(state->m_maincpu, G65816_LINE_IRQ, CLEAR_LINE );
	691	state->m_maincpu->set_input_line(G65816_LINE_IRQ, CLEAR_LINE );
692	692	snes_ram[TIMEUP] = 0;   // clear pending IRQ if irq is disabled here, 3x3 Eyes - Seima Korin Den behaves on this
693	693	}
694	694	break;
r17814	r17815
726	726	space->machine().scheduler().timer_set(space->machine().primary_screen->time_until_pos(snes_ppu.beam.current_vert + 1), FUNC(snes_reset_hdma));
727	727	break;
728	728	case TIMEUP:   // IRQ Flag is cleared on both read and write
729		device_set_input_line(state->m_maincpu, G65816_LINE_IRQ, CLEAR_LINE );
	729	state->m_maincpu->set_input_line(G65816_LINE_IRQ, CLEAR_LINE );
730	730	snes_ram[TIMEUP] = 0;
731	731	return;
732	732	/* Following are read-only */
r17814	r17815
759	759	WRITE_LINE_DEVICE_HANDLER( snes_extern_irq_w )
760	760	{
761	761	snes_state *driver_state = device->machine().driver_data<snes_state>();
762		device_set_input_line(driver_state->m_maincpu, G65816_LINE_IRQ, state);
	762	driver_state->m_maincpu->set_input_line(G65816_LINE_IRQ, state);
763	763	}
764	764
765	765	/*************************************

trunk/src/mame/machine/atarigen.c

r17814	r17815
734	734	{
735	735	atarigen_state *state = space->machine().driver_data<atarigen_state>();
736	736	state->m_cpu_to_sound_ready = 0;
737		device_set_input_line(state->m_sound_cpu, INPUT_LINE_NMI, CLEAR_LINE);
	737	state->m_sound_cpu->execute().set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
738	738	return state->m_cpu_to_sound;
739	739	}
740	740
r17814	r17815
750	750	{
751	751	atarigen_state *state = machine.driver_data<atarigen_state>();
752	752	if (state->m_timed_int || state->m_ym2151_int)
753		device_set_input_line(state->m_sound_cpu, M6502_IRQ_LINE, ASSERT_LINE);
	753	state->m_sound_cpu->execute().set_input_line(M6502_IRQ_LINE, ASSERT_LINE);
754	754	else
755		device_set_input_line(state->m_sound_cpu, M6502_IRQ_LINE, CLEAR_LINE);
	755	state->m_sound_cpu->execute().set_input_line(M6502_IRQ_LINE, CLEAR_LINE);
756	756	}
757	757
758	758
r17814	r17815
769	769	/* unhalt and reset the sound CPU */
770	770	if (param == 0)
771	771	{
772		device_set_input_line(state->m_sound_cpu, INPUT_LINE_HALT, CLEAR_LINE);
773		device_set_input_line(state->m_sound_cpu, INPUT_LINE_RESET, PULSE_LINE);
	772	state->m_sound_cpu->execute().set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
	773	state->m_sound_cpu->execute().set_input_line(INPUT_LINE_RESET, PULSE_LINE);
774	774	}
775	775
776	776	/* reset the sound write state */
r17814	r17815
799	799	/* set up the states and signal an NMI to the sound CPU */
800	800	state->m_cpu_to_sound = param;
801	801	state->m_cpu_to_sound_ready = 1;
802		device_set_input_line(state->m_sound_cpu, INPUT_LINE_NMI, ASSERT_LINE);
	802	state->m_sound_cpu->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
803	803
804	804	/* allocate a high frequency timer until a response is generated */
805	805	/* the main CPU is *very* sensistive to the timing of the response */
r17814	r17815
1385	1385
1386	1386	/* halt and set a timer to wake up */
1387	1387	screen.machine().scheduler().timer_set(screen.scan_period() * (hblank - hpos) / width, FUNC(unhalt_cpu), 0, (void *)cpu);
1388		device_set_input_line(cpu, INPUT_LINE_HALT, ASSERT_LINE);
	1388	cpu->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
1389	1389	}
1390	1390
1391	1391
r17814	r17815
1477	1477	static TIMER_CALLBACK( unhalt_cpu )
1478	1478	{
1479	1479	device_t *cpu = (device_t *)ptr;
1480		device_set_input_line(cpu, INPUT_LINE_HALT, CLEAR_LINE);
	1480	cpu->execute().set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
1481	1481	}
1482	1482
1483	1483

trunk/src/mame/machine/gaelco2.c

r17814	r17815
192	192	int scanline = param;
193	193
194	194	if (scanline == 256){
195		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	195	state->m_maincpu->set_input_line(2, HOLD_LINE);
196	196	state->m_clr_gun_int = 0;
197	197	}
198	198
199	199	if ((scanline % 64) == 0 && state->m_clr_gun_int)
200		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	200	state->m_maincpu->set_input_line(4, HOLD_LINE);
201	201	}
202	202
203	203	/***************************************************************************

trunk/src/mame/machine/galaxold.c

r17814	r17815
18	18	/* for some reason a call to cputag_set_input_line
19	19	* is significantly delayed ....
20	20	*
21		* device->machine().device("maincpu")->execute().set_input_line(0, CLEAR_LINE);
	21	* device->machine().device("maincpu")->set_input_line(0, CLEAR_LINE);
22	22	*
23	23	* Therefore we reset the line without any detour ....
24	24	*/
25		device_set_input_line(device->machine().firstcpu, 0, CLEAR_LINE);
	25	device->machine().firstcpu->set_input_line(0, CLEAR_LINE);
26	26	//cpu_set_info(device->machine().firstcpu, CPUINFO_INT_INPUT_STATE + state->m_irq_line, CLEAR_LINE);
27	27	return 0x03;
28	28	}
r17814	r17815
98	98	MACHINE_RESET( hunchbkg )
99	99	{
100	100	machine_reset_common(machine, 0);
101		device_set_irq_callback(machine.device("maincpu"), hunchbkg_irq_callback);
	101	machine.device("maincpu")->execute().set_irq_acknowledge_callback(hunchbkg_irq_callback);
102	102	}
103	103
104	104	WRITE8_MEMBER(galaxold_state::galaxold_coin_lockout_w)

trunk/src/mame/machine/dec0.c

r17814	r17815
118	118
119	119	READ16_MEMBER(dec0_state::hippodrm_68000_share_r)
120	120	{
121		if (offset==0) device_yield(&space.device()); /* A wee helper */
	121	if (offset==0) space.device().execute().yield(); /* A wee helper */
122	122	return m_share[offset]&0xff;
123	123	}
124	124

trunk/src/mame/machine/lsasquad.c

r17814	r17815
13	13	lsasquad_state *state = machine.driver_data<lsasquad_state>();
14	14
15	15	if (state->m_sound_nmi_enable)
16		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	16	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
17	17	else
18	18	state->m_pending_nmi = 1;
19	19	}
r17814	r17815
29	29	m_sound_nmi_enable = 1;
30	30	if (m_pending_nmi)
31	31	{
32		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	32	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
33	33	m_pending_nmi = 0;
34	34	}
35	35	}
r17814	r17815
142	142	{
143	143	m_port_a_in = m_from_main;
144	144	if (m_main_sent)
145		device_set_input_line(m_mcu, 0, CLEAR_LINE);
	145	m_mcu->execute().set_input_line(0, CLEAR_LINE);
146	146	m_main_sent = 0;
147	147	//logerror("read command %02x from main cpu\n", m_port_a_in);
148	148	}
r17814	r17815
168	168	//logerror("%04x: mcu_w %02x\n", space.device().safe_pc(), data);
169	169	m_from_main = data;
170	170	m_main_sent = 1;
171		device_set_input_line(m_mcu, 0, ASSERT_LINE);
	171	m_mcu->execute().set_input_line(0, ASSERT_LINE);
172	172	}
173	173
174	174	READ8_MEMBER(lsasquad_state::lsasquad_mcu_r)

trunk/src/mame/machine/nb1413m3.c

r17814	r17815
192	192	{
193	193	//  nb1413m3_busyflag = 1;
194	194	//  nb1413m3_busyctr = 0;
195		device_set_input_line(device, 0, HOLD_LINE);
	195	device->execute().set_input_line(0, HOLD_LINE);
196	196
197	197	#if NB1413M3_DEBUG
198	198	popmessage("NMI SW:%01X CLOCK:%02X COUNT:%02X", nb1413m3_nmi_enable, nb1413m3_nmi_clock, nb1413m3_nmi_count);

trunk/src/mame/machine/subs.c

r17814	r17815
27	27	{
28	28	/* only do NMI interrupt if not in TEST mode */
29	29	if ((device->machine().root_device().ioport("IN1")->read() & 0x40)==0x40)
30		device_set_input_line(device,INPUT_LINE_NMI,PULSE_LINE);
	30	device->execute().set_input_line(INPUT_LINE_NMI,PULSE_LINE);
31	31	}
32	32
33	33	/***************************************************************************

trunk/src/mame/machine/ajax.c

r17814	r17815
142	142	watchdog_reset_w(space, 0, data);
143	143	else{
144	144	if (m_firq_enable)   /* Cause interrupt on slave CPU */
145		device_set_input_line(m_subcpu, M6809_FIRQ_LINE, HOLD_LINE);
	145	m_subcpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
146	146	}
147	147	break;
148	148	case 0x01:   /* Cause interrupt on audio CPU */
149		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	149	m_audiocpu->set_input_line(0, HOLD_LINE);
150	150	break;
151	151	case 0x02:   /* Sound command number */
152	152	soundlatch_byte_w(space, offset, data);
r17814	r17815
206	206	state->membank("bank1")->set_entry(0);
207	207	state->membank("bank2")->set_entry(0);
208	208
209		state->m_maincpu = machine.device("maincpu");
210		state->m_audiocpu = machine.device("audiocpu");
211		state->m_subcpu = machine.device("sub");
	209	state->m_maincpu = machine.device<cpu_device>("maincpu");
	210	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
	211	state->m_subcpu = machine.device<cpu_device>("sub");
212	212	state->m_k007232_1 = machine.device("k007232_1");
213	213	state->m_k007232_2 = machine.device("k007232_2");
214	214	state->m_k052109 = machine.device("k052109");
r17814	r17815
232	232	ajax_state *state = device->machine().driver_data<ajax_state>();
233	233
234	234	if (k051960_is_irq_enabled(state->m_k051960))
235		device_set_input_line(device, KONAMI_IRQ_LINE, HOLD_LINE);
	235	device->execute().set_input_line(KONAMI_IRQ_LINE, HOLD_LINE);
236	236	}

trunk/src/mame/machine/bigevglf.c

r17814	r17815
36	36
37	37	if ((m_ddr_b & 0x02) && (~m_port_b_out & 0x02) && (data & 0x02)) /* positive going transition of the clock */
38	38	{
39		device_set_input_line(m_mcu, 0, CLEAR_LINE);
	39	m_mcu->execute().set_input_line(0, CLEAR_LINE);
40	40	m_main_sent = 0;
41	41
42	42	}
r17814	r17815
81	81
82	82	m_port_a_in = data;
83	83	m_main_sent = 1;
84		device_set_input_line(m_mcu, 0, ASSERT_LINE);
	84	m_mcu->execute().set_input_line(0, ASSERT_LINE);
85	85	}
86	86
87	87

trunk/src/mame/machine/cdi070.c

r17814	r17815
83	83	scc68070->timers.timer_status_register |= TSR_OV0;
84	84	if(interrupt)
85	85	{
86		device_set_input_line_vector(machine.device("maincpu"), M68K_IRQ_1 + (interrupt - 1), 56 + interrupt);
	86	machine.device("maincpu")->execute().set_input_line_vector(M68K_IRQ_1 + (interrupt - 1), 56 + interrupt);
87	87	machine.device("maincpu")->execute().set_input_line(M68K_IRQ_1 + (interrupt - 1), ASSERT_LINE);
88	88	}
89	89	}
r17814	r17815
170	170	UINT8 interrupt = (scc68070->picr2 >> 4) & 7;
171	171	if(interrupt)
172	172	{
173		device_set_input_line_vector(machine.device("maincpu"), M68K_IRQ_1 + (interrupt - 1), 56 + interrupt);
	173	machine.device("maincpu")->execute().set_input_line_vector(M68K_IRQ_1 + (interrupt - 1), 56 + interrupt);
174	174	machine.device("maincpu")->execute().set_input_line(M68K_IRQ_1 + (interrupt - 1), ASSERT_LINE);
175	175	}
176	176
r17814	r17815
381	381	UINT8 interrupt = scc68070->picr2 & 7;
382	382	if(interrupt)
383	383	{
384		device_set_input_line_vector(machine.device("maincpu"), M68K_IRQ_1 + (interrupt - 1), 56 + interrupt);
	384	machine.device("maincpu")->execute().set_input_line_vector(M68K_IRQ_1 + (interrupt - 1), 56 + interrupt);
385	385	machine.device("maincpu")->execute().set_input_line(M68K_IRQ_1 + (interrupt - 1), ASSERT_LINE);
386	386	}
387	387

trunk/src/mame/machine/nitedrvr.c

r17814	r17815
278	278	{
279	279	nitedrvr_state *state = machine.driver_data<nitedrvr_state>();
280	280
281		state->m_maincpu = machine.device("maincpu");
	281	state->m_maincpu = machine.device<cpu_device>("maincpu");
282	282	state->m_discrete = machine.device("discrete");
283	283
284	284	state->save_item(NAME(state->m_gear));

trunk/src/mame/video/antic.c

r17814	r17815
90	90	data = antic.r.antic09;
91	91	break;
92	92	case 10: /* WSYNC read */
93		device_spin_until_trigger(space->machine().device("maincpu"), TRIGGER_HSYNC);
	93	space->machine().device("maincpu")->execute().spin_until_trigger(TRIGGER_HSYNC);
94	94	antic.w.wsync = 1;
95	95	data = antic.r.antic0a;
96	96	break;
r17814	r17815
200	200	break;
201	201	case 10: /* WSYNC write */
202	202	LOG(("ANTIC 0A write WSYNC  $%02X\n", data));
203		device_spin_until_trigger(space->machine().device("maincpu"), TRIGGER_HSYNC);
	203	space->machine().device("maincpu")->execute().spin_until_trigger(TRIGGER_HSYNC);
204	204	antic.w.wsync = 1;
205	205	break;
206	206	case 11:

trunk/src/mame/video/blktiger.c

r17814	r17815
153	153	coin_counter_w(machine(), 1,data & 2);
154	154
155	155	/* bit 5 resets the sound CPU */
156		device_set_input_line(m_audiocpu, INPUT_LINE_RESET, (data & 0x20) ? ASSERT_LINE : CLEAR_LINE);
	156	m_audiocpu->set_input_line(INPUT_LINE_RESET, (data & 0x20) ? ASSERT_LINE : CLEAR_LINE);
157	157
158	158	/* bit 6 flips screen */
159	159	flip_screen_set(data & 0x40);

trunk/src/mame/video/mcd212.c

r17814	r17815
623	623	UINT8 interrupt = (state->m_scc68070_regs.lir >> 4) & 7;
624	624	if(interrupt)
625	625	{
626		device_set_input_line_vector(machine.device("maincpu"), M68K_IRQ_1 + (interrupt - 1), 56 + interrupt);
	626	machine.device("maincpu")->execute().set_input_line_vector(M68K_IRQ_1 + (interrupt - 1), 56 + interrupt);
627	627	machine.device("maincpu")->execute().set_input_line(M68K_IRQ_1 + (interrupt - 1), ASSERT_LINE);
628	628	}
629	629	}
r17814	r17815
633	633	UINT8 interrupt = state->m_scc68070_regs.lir & 7;
634	634	if(interrupt)
635	635	{
636		device_set_input_line_vector(machine.device("maincpu"), M68K_IRQ_1 + (interrupt - 1), 24 + interrupt);
	636	machine.device("maincpu")->execute().set_input_line_vector(M68K_IRQ_1 + (interrupt - 1), 24 + interrupt);
637	637	machine.device("maincpu")->execute().set_input_line(M68K_IRQ_1 + (interrupt - 1), ASSERT_LINE);
638	638	}
639	639	}
r17814	r17815
714	714	UINT8 interrupt = (state->m_scc68070_regs.lir >> 4) & 7;
715	715	if(interrupt)
716	716	{
717		device_set_input_line_vector(machine.device("maincpu"), M68K_IRQ_1 + (interrupt - 1), 56 + interrupt);
	717	machine.device("maincpu")->execute().set_input_line_vector(M68K_IRQ_1 + (interrupt - 1), 56 + interrupt);
718	718	machine.device("maincpu")->execute().set_input_line(M68K_IRQ_1 + (interrupt - 1), ASSERT_LINE);
719	719	}
720	720	}
r17814	r17815
724	724	UINT8 interrupt = state->m_scc68070_regs.lir & 7;
725	725	if(interrupt)
726	726	{
727		device_set_input_line_vector(machine.device("maincpu"), M68K_IRQ_1 + (interrupt - 1), 24 + interrupt);
	727	machine.device("maincpu")->execute().set_input_line_vector(M68K_IRQ_1 + (interrupt - 1), 24 + interrupt);
728	728	machine.device("maincpu")->execute().set_input_line(M68K_IRQ_1 + (interrupt - 1), ASSERT_LINE);
729	729	}
730	730	}

trunk/src/mame/video/system1.c

r17814	r17815
250	250	const UINT32 fixst_offset = 2 * 4;
251	251	UINT32 cycles_until_next_fixst = cpu_cycles_per_fixst - ((cpu->total_cycles() - fixst_offset) % cpu_cycles_per_fixst);
252	252
253		device_adjust_icount(cpu, -cycles_until_next_fixst);
	253	cpu->adjust_icount(-cycles_until_next_fixst);
254	254	}
255	255
256	256	READ8_MEMBER(system1_state::system1_videoram_r)

trunk/src/mame/video/zaxxon.c

r17814	r17815
288	288	int count = m_congo_custom[2];
289	289
290	290	/* count cycles (just a guess) */
291		device_adjust_icount(&space.device(), -count * 5);
	291	space.device().execute().adjust_icount(-count * 5);
292	292
293	293	/* this is just a guess; the chip is hardwired to the spriteram */
294	294	while (count-- >= 0)

trunk/src/mame/video/gticlub.c

r17814	r17815
449	449	if (space->device().safe_pc() == 0x201ee)
450	450	{
451	451	// This is used to make the SHARC timeout
452		device_spin_until_trigger(&space->device(), 10000);
	452	space->device().execute().spin_until_trigger(10000);
453	453	}
454	454	// !!! HACK to get past the FIFO B test (Winding Heat & Midnight Run) !!!
455	455	if (space->device().safe_pc() == 0x201e6)
456	456	{
457	457	// This is used to make the SHARC timeout
458		device_spin_until_trigger(&space->device(), 10000);
	458	space->device().execute().spin_until_trigger(10000);
459	459	}
460	460
461	461	break;

trunk/src/mame/video/beezer.c

r17814	r17815
13	13	via_0->write_ca2((scanline & 0x20) ? 1 : 0);
14	14	#if 0
15	15	if (scanline == 240) // actually unused by the game! (points to a tight loop)
16		device_set_input_line(state->m_maincpu, M6809_FIRQ_LINE, ASSERT_LINE);
	16	state->m_maincpu->set_input_line(M6809_FIRQ_LINE, ASSERT_LINE);
17	17	else
18		device_set_input_line(state->m_maincpu, M6809_FIRQ_LINE, CLEAR_LINE);
	18	state->m_maincpu->set_input_line(M6809_FIRQ_LINE, CLEAR_LINE);
19	19	#endif
20	20	}
21	21

trunk/src/mame/video/tia.c

r17814	r17815
798	798
799	799	if (cycles % 76)
800	800	{
801		device_adjust_icount(&space.device(), cycles % 76 - 76);
	801	space.device().execute().adjust_icount(cycles % 76 - 76);
802	802	}
803	803	}
804	804

trunk/src/mame/video/blockade.c

r17814	r17815
9	9	if (ioport("IN3")->read() & 0x80)
10	10	{
11	11	logerror("blockade_videoram_w: scanline %d\n", machine().primary_screen->vpos());
12		device_spin_until_interrupt(&space.device());
	12	space.device().execute().spin_until_interrupt();
13	13	}
14	14	}
15	15

trunk/src/mame/video/tmnt.c

r17814	r17815
334	334
335	335	/* bit 3 high then low triggers irq on sound CPU */
336	336	if (m_last == 0x08 && (data & 0x08) == 0)
337		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	337	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
338	338
339	339	m_last = data & 0x08;
340	340
r17814	r17815
358	358
359	359	/* bit 2 = trigger irq on sound CPU */
360	360	if (m_last == 0x04 && (data & 0x04) == 0)
361		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	361	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
362	362
363	363	m_last = data & 0x04;
364	364
r17814	r17815
378	378
379	379	/* bit 2 = trigger irq on sound CPU */
380	380	if (m_last == 0x00 && (data & 0x04) == 0x04)
381		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	381	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
382	382
383	383	m_last = data & 0x04;
384	384

trunk/src/mame/video/gameplan.c

r17814	r17815
214	214	static TIMER_CALLBACK( via_irq_delayed )
215	215	{
216	216	gameplan_state *state = machine.driver_data<gameplan_state>();
217		device_set_input_line(state->m_maincpu, 0, param);
	217	state->m_maincpu->set_input_line(0, param);
218	218	}
219	219
220	220

trunk/src/mame/video/capbowl.c

r17814	r17815
19	19	static void generate_interrupt( running_machine &machine, int state )
20	20	{
21	21	capbowl_state *driver = machine.driver_data<capbowl_state>();
22		device_set_input_line(driver->m_maincpu, M6809_FIRQ_LINE, state);
	22	driver->m_maincpu->set_input_line(M6809_FIRQ_LINE, state);
23	23	}
24	24
25	25	static const struct tms34061_interface tms34061intf =

trunk/src/mame/video/commando.c

r17814	r17815
60	60	coin_counter_w(machine(), 1, data & 0x02);
61	61
62	62	// bit 4 resets the sound CPU
63		device_set_input_line(m_audiocpu, INPUT_LINE_RESET, (data & 0x10) ? ASSERT_LINE : CLEAR_LINE);
	63	m_audiocpu->set_input_line(INPUT_LINE_RESET, (data & 0x10) ? ASSERT_LINE : CLEAR_LINE);
64	64
65	65	// bit 7 flips screen
66	66	flip_screen_set(data & 0x80);

trunk/src/mame/video/bfm_adr2.c

r17814	r17815
253	253	if ( adder2_c101 & 0x01 )
254	254	{
255	255	adder_vbl_triggered = 1;
256		device_set_input_line(device, M6809_IRQ_LINE, HOLD_LINE );
	256	device->execute().set_input_line(M6809_IRQ_LINE, HOLD_LINE );
257	257	}
258	258	}
259	259

trunk/src/mame/video/spdodgeb.c

r17814	r17815
90	90
91	91	if (scanline == 256)
92	92	{
93		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	93	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
94	94	timer.machine().primary_screen->update_partial(256);
95	95	}
96	96	else if ((scanline % 8) == 0)
97	97	{
98		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	98	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
99	99	timer.machine().primary_screen->update_partial(scanline+16); /* TODO: pretty off ... */
100	100	}
101	101	}

trunk/src/mame/video/liberate.c

r17814	r17815
120	120	/* Todo */
121	121	break;
122	122	case 8: /* Irq ack */
123		device_set_input_line(m_maincpu, DECO16_IRQ_LINE, CLEAR_LINE);
	123	m_maincpu->set_input_line(DECO16_IRQ_LINE, CLEAR_LINE);
124	124	break;
125	125	case 9: /* Sound */
126	126	soundlatch_byte_w(space, 0, data);
127		device_set_input_line(m_audiocpu, M6502_IRQ_LINE, HOLD_LINE);
	127	m_audiocpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
128	128	break;
129	129	}
130	130	}
r17814	r17815
148	148	/* x--- ---- used on the attract mode */
149	149	break;
150	150	case 8: /* Irq ack */
151		device_set_input_line(m_maincpu, DECO16_IRQ_LINE, CLEAR_LINE);
	151	m_maincpu->set_input_line(DECO16_IRQ_LINE, CLEAR_LINE);
152	152	break;
153	153	case 9: /* Sound */
154	154	soundlatch_byte_w(space, 0, data);
155		device_set_input_line(m_audiocpu, M6502_IRQ_LINE, HOLD_LINE);
	155	m_audiocpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
156	156	break;
157	157	}
158	158	}
r17814	r17815
171	171	break;
172	172	case 2: /* Sound */
173	173	soundlatch_byte_w(space, 0, data);
174		device_set_input_line(m_audiocpu, M6502_IRQ_LINE, HOLD_LINE);
	174	m_audiocpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
175	175	break;
176	176	case 4: /* Irq ack */
177		device_set_input_line(m_maincpu, DECO16_IRQ_LINE, CLEAR_LINE);
	177	m_maincpu->set_input_line(DECO16_IRQ_LINE, CLEAR_LINE);
178	178	break;
179	179	}
180	180	}

trunk/src/mame/video/nemesis.c

r17814	r17815
110	110	if (ACCESSING_BITS_8_15)
111	111	{
112	112	if (data & 0x0100)
113		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	113	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
114	114	}
115	115	}
116	116
r17814	r17815
162	162	coin_lockout_w(machine(), 1, data & 0x0400);
163	163
164	164	if (data & 0x0800)
165		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	165	m_audiocpu->set_input_line(0, HOLD_LINE);
166	166
167	167	m_selected_ip = (~data & 0x1000) >> 12;      /* citybomb steering & accel */
168	168	}

trunk/src/mame/video/1942.c

r17814	r17815
180	180
181	181	coin_counter_w(machine(), 0,data & 0x01);
182	182
183		device_set_input_line(m_audiocpu, INPUT_LINE_RESET, (data & 0x10) ? ASSERT_LINE : CLEAR_LINE);
	183	m_audiocpu->set_input_line(INPUT_LINE_RESET, (data & 0x10) ? ASSERT_LINE : CLEAR_LINE);
184	184
185	185	flip_screen_set(data & 0x80);
186	186	}

trunk/src/mame/video/battlera.c

r17814	r17815
371	371	/* If raster interrupt occurs, refresh screen _up_ to this point */
372	372	if (state->m_rcr_enable && (state->m_current_scanline+56)==state->m_HuC6270_registers[6]) {
373	373	timer.machine().primary_screen->update_partial(state->m_current_scanline);
374		device_set_input_line(state->m_maincpu, 0, HOLD_LINE); /* RCR interrupt */
	374	state->m_maincpu->set_input_line(0, HOLD_LINE); /* RCR interrupt */
375	375	}
376	376
377	377	/* Start of vblank */
r17814	r17815
379	379	state->m_bldwolf_vblank=1;
380	380	timer.machine().primary_screen->update_partial(240);
381	381	if (state->m_irq_enable)
382		device_set_input_line(state->m_maincpu, 0, HOLD_LINE); /* VBL */
	382	state->m_maincpu->set_input_line(0, HOLD_LINE); /* VBL */
383	383	}
384	384
385	385	/* End of vblank */

trunk/src/mame/video/astrocde.c

r17814	r17815
835	835	} while (state->m_pattern_height-- != 0);
836	836
837	837	/* count cycles we ran the bus */
838		device_adjust_icount(&space->device(), -cycles);
	838	space->device().execute().adjust_icount(-cycles);
839	839	}
840	840
841	841

trunk/src/mame/video/ginganin.c

r17814	r17815
175	175	break;
176	176	case 7:
177	177	soundlatch_byte_w(space, 0, data);
178		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	178	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
179	179	break;
180	180	default:
181	181	logerror("CPU #0 PC %06X : Warning, videoreg %04X <- %04X\n", space.device().safe_pc(), offset, data);

trunk/src/mame/video/taito_z.c

r17814	r17815
824	824	if (ACCESSING_BITS_0_7)
825	825	{
826	826	/* bit 0 = reset sub CPU */
827		device_set_input_line(m_audiocpu, INPUT_LINE_RESET, (data & 1) ? CLEAR_LINE : ASSERT_LINE);
	827	m_audiocpu->set_input_line(INPUT_LINE_RESET, (data & 1) ? CLEAR_LINE : ASSERT_LINE);
828	828
829	829	/* bits 1-3 n.c. */
830	830

trunk/src/mame/video/lockon.c

r17814	r17815
67	67	lockon_state *state = machine.driver_data<lockon_state>();
68	68
69	69	if (state->m_main_inten)
70		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0xff);
	70	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
71	71
72	72	state->m_cursor_timer->adjust(machine.primary_screen->time_until_pos(CURSOR_YPOS, CURSOR_XPOS));
73	73	}
r17814	r17815
284	284	static TIMER_CALLBACK( bufend_callback )
285	285	{
286	286	lockon_state *state = machine.driver_data<lockon_state>();
287		device_set_input_line_and_vector(state->m_ground, 0, HOLD_LINE, 0xff);
288		device_set_input_line(state->m_object, NEC_INPUT_LINE_POLL, ASSERT_LINE);
	287	state->m_ground->execute().set_input_line_and_vector(0, HOLD_LINE, 0xff);
	288	state->m_object->execute().set_input_line(NEC_INPUT_LINE_POLL, ASSERT_LINE);
289	289	}
290	290
291	291	/* Get data for a each 8x8x3 ground tile */
r17814	r17815
618	618	READ16_MEMBER(lockon_state::lockon_obj_4000_r)
619	619	{
620	620
621		device_set_input_line(m_object, NEC_INPUT_LINE_POLL, CLEAR_LINE);
	621	m_object->execute().set_input_line(NEC_INPUT_LINE_POLL, CLEAR_LINE);
622	622	return 0xffff;
623	623	}
624	624

trunk/src/mame/video/rltennis.c

r17814	r17815
133	133
134	134	if(offset == BLT_START && (((new_data ^ old_data ) & new_data) & BLTSTRT_TRIGGER))  /* blit strobe 0->1 */
135	135	{
136		device_set_input_line(m_maincpu, 1, HOLD_LINE);
	136	m_maincpu->set_input_line(1, HOLD_LINE);
137	137
138	138	int src_x0=(m_blitter[BLT_X_START]>>SRC_SHIFT)+((m_blitter[BLT_FLAGS] & BLTFLAG_SRC_LR)?256:0);
139	139	int src_y0=(m_blitter[BLT_Y_START]>>SRC_SHIFT)+((m_blitter[BLT_FLAGS]>>3)&0xff00)+(((m_blitter[BLT_START]) & BLTSTRT_ROM_MSB)?(1<<0xd):0);

trunk/src/mame/video/atari.c

r17814	r17815
1160	1160	LOG(("           @cycle #%3d steal %d cycles\n", cycle(machine), antic.steal_cycles));
1161	1161	after(machine, antic.steal_cycles, FUNC(antic_line_done));
1162	1162	antic.steal_cycles = 0;
1163		device_spin_until_trigger( machine.device("maincpu"), TRIGGER_STEAL );
	1163	machine.device("maincpu")->execute().spin_until_trigger(TRIGGER_STEAL );
1164	1164	}
1165	1165
1166	1166

trunk/src/mame/video/decocass.c

r17814	r17815
524	524	rectangle clip;
525	525
526	526	if (0xc0 != (screen.machine().root_device().ioport("IN2")->read() & 0xc0))  /* coin slots assert an NMI */
527		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, ASSERT_LINE);
	527	state->m_maincpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
528	528
529	529	if (0 == (state->m_watchdog_flip & 0x04))
530	530	screen.machine().watchdog_reset();

trunk/src/mame/video/bfm_dm01.c

r17814	r17815
238	238
239	239	INTERRUPT_GEN( bfm_dm01_vbl )
240	240	{
241		device_set_input_line(device, INPUT_LINE_NMI, ASSERT_LINE );
	241	device->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE );
242	242	}
243	243
244	244	///////////////////////////////////////////////////////////////////////////

trunk/src/mame/video/fromance.c

r17814	r17815
258	258	static TIMER_CALLBACK( crtc_interrupt_gen )
259	259	{
260	260	fromance_state *state = machine.driver_data<fromance_state>();
261		device_set_input_line(state->m_subcpu, 0, HOLD_LINE);
	261	state->m_subcpu->set_input_line(0, HOLD_LINE);
262	262	if (param != 0)
263	263	state->m_crtc_timer->adjust(machine.primary_screen->frame_period() / param, 0, machine.primary_screen->frame_period() / param);
264	264	}

trunk/src/mame/video/konicdev.c

r17814	r17815
9346	9346	{
9347	9347	if (k001005->fifo_read_ptr < 0x3ff)
9348	9348	{
9349		//device_set_input_line(k001005->dsp, SHARC_INPUT_FLAG1, CLEAR_LINE);
	9349	//k001005->dsp->execute().set_input_line(SHARC_INPUT_FLAG1, CLEAR_LINE);
9350	9350	sharc_set_flag_input(k001005->dsp, 1, CLEAR_LINE);
9351	9351	}
9352	9352	else
9353	9353	{
9354		//device_set_input_line(k001005->dsp, SHARC_INPUT_FLAG1, ASSERT_LINE);
	9354	//k001005->dsp->execute().set_input_line(SHARC_INPUT_FLAG1, ASSERT_LINE);
9355	9355	sharc_set_flag_input(k001005->dsp, 1, ASSERT_LINE);
9356	9356	}
9357	9357	}
9358	9358	else
9359	9359	{
9360		//device_set_input_line(k001005->dsp, SHARC_INPUT_FLAG1, ASSERT_LINE);
	9360	//k001005->dsp->execute().set_input_line(SHARC_INPUT_FLAG1, ASSERT_LINE);
9361	9361	sharc_set_flag_input(k001005->dsp, 1, ASSERT_LINE);
9362	9362	}
9363	9363
r17814	r17815
9401	9401	{
9402	9402	if (k001005->fifo_write_ptr < 0x400)
9403	9403	{
9404		//device_set_input_line(k001005->dsp, SHARC_INPUT_FLAG1, ASSERT_LINE);
	9404	//k001005->dsp->execute().set_input_line(SHARC_INPUT_FLAG1, ASSERT_LINE);
9405	9405	sharc_set_flag_input(k001005->dsp, 1, ASSERT_LINE);
9406	9406	}
9407	9407	else
9408	9408	{
9409		//device_set_input_line(k001005->dsp, SHARC_INPUT_FLAG1, CLEAR_LINE);
	9409	//k001005->dsp->execute().set_input_line(SHARC_INPUT_FLAG1, CLEAR_LINE);
9410	9410	sharc_set_flag_input(k001005->dsp, 1, CLEAR_LINE);
9411	9411	}
9412	9412	}
9413	9413	else
9414	9414	{
9415		//device_set_input_line(k001005->dsp, SHARC_INPUT_FLAG1, ASSERT_LINE);
	9415	//k001005->dsp->execute().set_input_line(SHARC_INPUT_FLAG1, ASSERT_LINE);
9416	9416	sharc_set_flag_input(k001005->dsp, 1, ASSERT_LINE);
9417	9417	}
9418	9418
r17814	r17815
9427	9427	if (k001005->cpu->safe_pc() == 0x201ee)
9428	9428	{
9429	9429	// This is used to make the SHARC timeout
9430		device_spin_until_trigger(k001005->cpu, 10000);
	9430	k001005->cpu->execute().spin_until_trigger(10000);
9431	9431	}
9432	9432	// !!! HACK to get past the FIFO B test (Winding Heat & Midnight Run) !!!
9433	9433	if (k001005->cpu->safe_pc() == 0x201e6)
9434	9434	{
9435	9435	// This is used to make the SHARC timeout
9436		device_spin_until_trigger(k001005->cpu, 10000);
	9436	k001005->cpu->execute().spin_until_trigger(10000);
9437	9437	}
9438	9438
9439	9439	break;

trunk/src/mame/video/ppu2c0x.c

r17814	r17815
1283	1283	}
1284	1284
1285	1285	// should last 513 CPU cycles.
1286		device_adjust_icount(&space->device(), -513);
	1286	space->device().execute().adjust_icount(-513);
1287	1287	}
1288	1288
1289	1289	/*************************************

trunk/src/mame/video/exidy.c

r17814	r17815
74	74	state->m_int_condition &= ~0x80;
75	75
76	76	/* set the IRQ line */
77		device_set_input_line(device, 0, ASSERT_LINE);
	77	device->execute().set_input_line(0, ASSERT_LINE);
78	78	}
79	79
80	80

trunk/src/mame/video/homedata.c

r17814	r17815
116	116	} /* for(;;) */
117	117
118	118	finish:
119		device_set_input_line(state->m_maincpu, M6809_FIRQ_LINE, HOLD_LINE);
	119	state->m_maincpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
120	120	}
121	121
122	122	static void reikaids_handleblit( address_space *space, int rom_base )
r17814	r17815
214	214	}
215	215
216	216	finish:
217		device_set_input_line(state->m_maincpu, M6809_FIRQ_LINE, HOLD_LINE);
	217	state->m_maincpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
218	218	}
219	219
220	220	static void pteacher_handleblit( address_space *space, int rom_base )
r17814	r17815
301	301	} /* for(;;) */
302	302
303	303	finish:
304		device_set_input_line(state->m_maincpu, M6809_FIRQ_LINE, HOLD_LINE);
	304	state->m_maincpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
305	305	}
306	306
307	307

trunk/src/mame/video/circus.c

r17814	r17815
90	90	}
91	91
92	92	if (collision)
93		device_set_input_line(state->m_maincpu, 0, ASSERT_LINE);
	93	state->m_maincpu->set_input_line(0, ASSERT_LINE);
94	94	}
95	95
96	96	static void circus_draw_fg( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )

trunk/src/mame/video/arkanoid.c

r17814	r17815
67	67	which resets itself).  This bit is the likely candidate as it is flipped
68	68	early in bootup just prior to accessing the MCU for the first time. */
69	69	if (m_mcu != NULL)   // Bootlegs don't have the MCU but still set this bit
70		device_set_input_line(m_mcu, INPUT_LINE_RESET, (data & 0x80) ? CLEAR_LINE : ASSERT_LINE);
	70	m_mcu->execute().set_input_line(INPUT_LINE_RESET, (data & 0x80) ? CLEAR_LINE : ASSERT_LINE);
71	71	}
72	72
73	73	/* different hook-up, everything except for bits 0-1 and 7 aren't tested afaik. */

trunk/src/mame/video/williams.c

r17814	r17815
539	539	/* based on the number of memory accesses needed to do the blit, compute how long the blit will take */
540	540	/* this is just a guess */
541	541	estimated_clocks_at_4MHz = 20 + ((data & 4) ? 4 : 2) * accesses;
542		device_adjust_icount(&space.device(), -((estimated_clocks_at_4MHz + 3) / 4));
	542	space.device().execute().adjust_icount(-((estimated_clocks_at_4MHz + 3) / 4));
543	543
544	544	/* Log blits */
545	545	logerror("%04X:Blit @ %3d : %02X%02X -> %02X%02X, %3dx%3d, mask=%02X, flags=%02X, icount=%d, win=%d\n",

trunk/src/mame/video/dec8.c

r17814	r17815
166	166	m_scroll2[2] = (data >> 6) & 1;
167	167
168	168	if (data & 0x80)
169		device_set_input_line(m_subcpu, INPUT_LINE_RESET, CLEAR_LINE);
	169	m_subcpu->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
170	170	else
171		device_set_input_line(m_subcpu, INPUT_LINE_RESET, ASSERT_LINE);
	171	m_subcpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
172	172	}
173	173
174	174	WRITE8_MEMBER(dec8_state::shackled_control_w)

trunk/src/mame/includes/m10.h

r17814	r17815
61	61	int                 m_last;
62	62
63	63	/* devices */
64		device_t *m_maincpu;
	64	cpu_device *m_maincpu;
65	65	device_t *m_ic8j1;
66	66	device_t *m_ic8j2;
67	67	samples_device *m_samples;

trunk/src/mame/includes/nitedrvr.h

r17814	r17815
42	42	INT32 m_last_steering_val;
43	43
44	44	/* devices */
45		device_t *m_maincpu;
	45	cpu_device *m_maincpu;
46	46	device_t *m_discrete;
47	47	DECLARE_READ8_MEMBER(nitedrvr_steering_reset_r);
48	48	DECLARE_WRITE8_MEMBER(nitedrvr_steering_reset_w);

trunk/src/mame/includes/nycaptor.h

r17814	r17815
46	46	int m_mask;
47	47
48	48	/* devices */
49		device_t *m_maincpu;
50		device_t *m_audiocpu;
51		device_t *m_subcpu;
	49	cpu_device *m_maincpu;
	50	cpu_device *m_audiocpu;
	51	cpu_device *m_subcpu;
52	52	device_t *m_mcu;
53	53	DECLARE_WRITE8_MEMBER(sub_cpu_halt_w);
54	54	DECLARE_READ8_MEMBER(from_snd_r);

trunk/src/mame/includes/rainbow.h

r17814	r17815
28	28	UINT8       m_current_bank;
29	29
30	30	/* devices */
31		device_t *m_maincpu;
32		device_t *m_audiocpu;
	31	cpu_device *m_maincpu;
	32	cpu_device *m_audiocpu;
33	33	device_t *m_pc080sn;
34	34	device_t *m_pc090oj;
35	35	DECLARE_WRITE16_MEMBER(jumping_sound_w);

trunk/src/mame/includes/galspnbl.h

r17814	r17815
25	25	//  UINT16 *    paletteram; // currently this uses generic palette handling
26	26
27	27	/* devices */
28		device_t *m_audiocpu;
	28	cpu_device *m_audiocpu;
29	29	DECLARE_WRITE16_MEMBER(soundcommand_w);
30	30	};
31	31

trunk/src/mame/includes/blktiger.h

r17814	r17815
39	39
40	40	/* devices */
41	41	device_t *m_mcu;
42		device_t *m_audiocpu;
	42	cpu_device *m_audiocpu;
43	43	DECLARE_READ8_MEMBER(blktiger_from_mcu_r);
44	44	DECLARE_WRITE8_MEMBER(blktiger_to_mcu_w);
45	45	DECLARE_READ8_MEMBER(blktiger_from_main_r);

trunk/src/mame/includes/rungun.h

r17814	r17815
29	29	int         m_sound_status;
30	30
31	31	/* devices */
32		device_t *m_maincpu;
33		device_t *m_audiocpu;
	32	cpu_device *m_maincpu;
	33	cpu_device *m_audiocpu;
34	34	device_t *m_k054539_1;
35	35	device_t *m_k054539_2;
36	36	device_t *m_k053936;

trunk/src/mame/includes/madmotor.h

r17814	r17815
19	19	int             m_flipscreen;
20	20
21	21	/* devices */
22		device_t *m_maincpu;
23		device_t *m_audiocpu;
	22	cpu_device *m_maincpu;
	23	cpu_device *m_audiocpu;
24	24	DECLARE_WRITE16_MEMBER(madmotor_sound_w);
25	25	DECLARE_DRIVER_INIT(madmotor);
26	26	};

trunk/src/mame/includes/bublbobl.h

r17814	r17815
52	52	int      m_ic43_b;
53	53
54	54	/* devices */
55		device_t *m_maincpu;
	55	cpu_device *m_maincpu;
56	56	device_t *m_mcu;
57		device_t *m_audiocpu;
	57	cpu_device *m_audiocpu;
58	58	device_t *m_slave;
59	59	DECLARE_WRITE8_MEMBER(bublbobl_bankswitch_w);
60	60	DECLARE_WRITE8_MEMBER(tokio_bankswitch_w);

trunk/src/mame/includes/skyfox.h

r17814	r17815
23	23	int        m_palette_selected;
24	24
25	25	/* devices */
26		device_t *m_maincpu;
	26	cpu_device *m_maincpu;
27	27	DECLARE_READ8_MEMBER(skyfox_vregs_r);
28	28	DECLARE_WRITE8_MEMBER(skyfox_vregs_w);
29	29	DECLARE_INPUT_CHANGED_MEMBER(coin_inserted);

trunk/src/mame/includes/aerofgt.h

r17814	r17815
43	43	int       m_pending_command;
44	44
45	45	/* devices */
46		device_t *m_audiocpu;
	46	cpu_device *m_audiocpu;
47	47	DECLARE_WRITE16_MEMBER(sound_command_w);
48	48	DECLARE_WRITE16_MEMBER(turbofrc_sound_command_w);
49	49	DECLARE_WRITE16_MEMBER(aerfboot_soundlatch_w);

trunk/src/mame/includes/fgoal.h

r17814	r17815
24	24	int        m_prev_coin;
25	25
26	26	/* devices */
27		device_t *m_maincpu;
	27	cpu_device *m_maincpu;
28	28	device_t *m_mb14241;
29	29	DECLARE_READ8_MEMBER(fgoal_analog_r);
30	30	DECLARE_READ8_MEMBER(fgoal_nmi_reset_r);

trunk/src/mame/includes/sonson.h

r17814	r17815
25	25	int        m_last_irq;
26	26
27	27	/* devices */
28		device_t *m_audiocpu;
	28	cpu_device *m_audiocpu;
29	29	DECLARE_WRITE8_MEMBER(sonson_sh_irqtrigger_w);
30	30	DECLARE_WRITE8_MEMBER(sonson_coin1_counter_w);
31	31	DECLARE_WRITE8_MEMBER(sonson_coin2_counter_w);

trunk/src/mame/includes/hcastle.h

r17814	r17815
34	34	int        m_gfx_bank;
35	35
36	36	/* devices */
37		device_t *m_audiocpu;
	37	cpu_device *m_audiocpu;
38	38	device_t *m_k007121_1;
39	39	device_t *m_k007121_2;
40	40

trunk/src/mame/includes/bking.h

r17814	r17815
37	37	int         m_addr_l;
38	38
39	39	/* devices */
40		device_t *m_audiocpu;
	40	cpu_device *m_audiocpu;
41	41
42	42	#if 0
43	43	/* 68705 */

trunk/src/mame/includes/battlnts.h

r17814	r17815
19	19
20	20
21	21	/* devices */
22		device_t *m_audiocpu;
	22	cpu_device *m_audiocpu;
23	23	device_t *m_k007342;
24	24	device_t *m_k007420;
25	25	DECLARE_WRITE8_MEMBER(battlnts_sh_irqtrigger_w);

trunk/src/mame/includes/taito_o.h

r17814	r17815
14	14	//  UINT16 *    paletteram;    // currently this uses generic palette handling
15	15
16	16	/* devices */
17		device_t *m_maincpu;
	17	cpu_device *m_maincpu;
18	18	device_t *m_tc0080vco;
19	19	DECLARE_WRITE16_MEMBER(io_w);
20	20	DECLARE_READ16_MEMBER(io_r);

trunk/src/mame/includes/ddragon3.h

r17814	r17815
34	34	UINT16          m_io_reg[8];
35	35
36	36	/* devices */
37		device_t *m_maincpu;
38		device_t *m_audiocpu;
	37	cpu_device *m_maincpu;
	38	cpu_device *m_audiocpu;
39	39	DECLARE_WRITE16_MEMBER(ddragon3_io_w);
40	40	DECLARE_WRITE16_MEMBER(ddragon3_scroll_w);
41	41	DECLARE_READ16_MEMBER(ddragon3_scroll_r);

trunk/src/mame/includes/orbit.h

r17814	r17815
35	35	UINT8      m_misc_flags;
36	36
37	37	/* devices */
38		device_t *m_maincpu;
	38	cpu_device *m_maincpu;
39	39	device_t *m_discrete;
40	40	DECLARE_WRITE8_MEMBER(orbit_misc_w);
41	41	DECLARE_WRITE8_MEMBER(orbit_playfield_w);

trunk/src/mame/includes/coolpool.h

r17814	r17815
26	26	UINT16 m_result;
27	27	UINT16 m_lastresult;
28	28
29		device_t *m_maincpu;
	29	cpu_device *m_maincpu;
30	30	device_t *m_dsp;
31	31	UINT16 m_nvram_write_seq[NVRAM_UNLOCK_SEQ_LEN];
32	32	UINT8 m_nvram_write_enable;

trunk/src/mame/includes/flkatck.h

r17814	r17815
24	24	int        m_multiply_reg[2];
25	25
26	26	/* devices */
27		device_t *m_audiocpu;
	27	cpu_device *m_audiocpu;
28	28	device_t *m_k007121;
29	29	DECLARE_WRITE8_MEMBER(flkatck_bankswitch_w);
30	30	DECLARE_READ8_MEMBER(flkatck_ls138_r);

trunk/src/mame/includes/dynax.h

r17814	r17815
154	154
155	155
156	156	/* devices */
157		device_t *m_maincpu;
158		device_t *m_soundcpu;
	157	cpu_device *m_maincpu;
	158	cpu_device *m_soundcpu;
159	159	device_t *m_rtc;
160	160	device_t *m_ymsnd;
161	161	okim6295_device *m_oki;

trunk/src/mame/includes/contra.h

r17814	r17815
39	39	rectangle m_tx_clip;
40	40
41	41	/* devices */
42		device_t *m_audiocpu;
	42	cpu_device *m_audiocpu;
43	43	device_t *m_k007121_1;
44	44	device_t *m_k007121_2;
45	45	DECLARE_WRITE8_MEMBER(contra_bankswitch_w);

trunk/src/mame/includes/volfied.h

r17814	r17815
26	26	UINT8       m_current_cmd;
27	27
28	28	/* devices */
29		device_t *m_maincpu;
30		device_t *m_audiocpu;
	29	cpu_device *m_maincpu;
	30	cpu_device *m_audiocpu;
31	31	device_t *m_pc090oj;
32	32	DECLARE_WRITE16_MEMBER(volfied_cchip_ctrl_w);
33	33	DECLARE_WRITE16_MEMBER(volfied_cchip_bank_w);

trunk/src/mame/includes/mexico86.h

r17814	r17815
32	32	int      m_coin_last;
33	33
34	34	/* devices */
35		device_t *m_maincpu;
36		device_t *m_audiocpu;
37		device_t *m_subcpu;
	35	cpu_device *m_maincpu;
	36	cpu_device *m_audiocpu;
	37	cpu_device *m_subcpu;
38	38	device_t *m_mcu;
39	39
40	40	/* queue */

trunk/src/mame/includes/ashnojoe.h

r17814	r17815
45	45	int         m_msm5205_vclk_toggle;
46	46
47	47	/* devices */
48		device_t *m_audiocpu;
	48	cpu_device *m_audiocpu;
49	49	DECLARE_READ16_MEMBER(fake_4a00a_r);
50	50	DECLARE_WRITE16_MEMBER(ashnojoe_soundlatch_w);
51	51	DECLARE_WRITE8_MEMBER(adpcm_w);

trunk/src/mame/includes/mouser.h

r17814	r17815
23	23	UINT8      m_nmi_enable;
24	24
25	25	/* devices */
26		device_t *m_maincpu;
27		device_t *m_audiocpu;
	26	cpu_device *m_maincpu;
	27	cpu_device *m_audiocpu;
28	28	DECLARE_WRITE8_MEMBER(mouser_nmi_enable_w);
29	29	DECLARE_WRITE8_MEMBER(mouser_sound_interrupt_w);
30	30	DECLARE_READ8_MEMBER(mouser_sound_byte_r);

trunk/src/mame/includes/lkage.h

r17814	r17815
49	49	int m_mcu_ready;   /* cpu data/mcu ready status */
50	50
51	51	/* devices */
52		device_t *m_maincpu;
53		device_t *m_audiocpu;
	52	cpu_device *m_maincpu;
	53	cpu_device *m_audiocpu;
54	54	device_t *m_mcu;
55	55	DECLARE_WRITE8_MEMBER(lkage_sound_command_w);
56	56	DECLARE_WRITE8_MEMBER(lkage_sh_nmi_disable_w);

trunk/src/mame/includes/gaiden.h

r17814	r17815
45	45	const int   *m_raiga_jumppoints;
46	46
47	47	/* devices */
48		device_t *m_audiocpu;
	48	cpu_device *m_audiocpu;
49	49	DECLARE_WRITE16_MEMBER(gaiden_sound_command_w);
50	50	DECLARE_WRITE16_MEMBER(drgnbowl_sound_command_w);
51	51	DECLARE_WRITE16_MEMBER(wildfang_protection_w);

trunk/src/mame/includes/astrof.h

r17814	r17815
36	36	UINT8      m_astrof_bosskill_playing;
37	37
38	38	/* devices */
39		device_t *m_maincpu;
	39	cpu_device *m_maincpu;
40	40	samples_device *m_samples;   // astrof & abattle
41	41	device_t *m_sn;   // tomahawk
42	42	DECLARE_READ8_MEMBER(irq_clear_r);

trunk/src/mame/includes/karnov.h

r17814	r17815
39	39	int         m_latch;
40	40
41	41	/* devices */
42		device_t *m_maincpu;
43		device_t *m_audiocpu;
	42	cpu_device *m_maincpu;
	43	cpu_device *m_audiocpu;
44	44	DECLARE_WRITE16_MEMBER(karnov_control_w);
45	45	DECLARE_READ16_MEMBER(karnov_control_r);
46	46	DECLARE_WRITE16_MEMBER(karnov_videoram_w);

trunk/src/mame/includes/kopunch.h

r17814	r17815
25	25	int        m_gfxbank;
26	26
27	27	/* devices */
28		device_t *m_maincpu;
	28	cpu_device *m_maincpu;
29	29	DECLARE_READ8_MEMBER(kopunch_in_r);
30	30	DECLARE_WRITE8_MEMBER(kopunch_lamp_w);
31	31	DECLARE_WRITE8_MEMBER(kopunch_coin_w);

trunk/src/mame/includes/aliens.h

r17814	r17815
23	23	int        m_palette_selected;
24	24
25	25	/* devices */
26		device_t *m_maincpu;
27		device_t *m_audiocpu;
	26	cpu_device *m_maincpu;
	27	cpu_device *m_audiocpu;
28	28	device_t *m_k007232;
29	29	device_t *m_k052109;
30	30	device_t *m_k051960;

trunk/src/mame/includes/metlclsh.h

r17814	r17815
30	30	UINT8          m_gfxbank;
31	31
32	32	/* devices */
33		device_t *m_maincpu;
34		device_t *m_subcpu;
	33	cpu_device *m_maincpu;
	34	cpu_device *m_subcpu;
35	35	DECLARE_WRITE8_MEMBER(metlclsh_cause_irq);
36	36	DECLARE_WRITE8_MEMBER(metlclsh_ack_nmi);
37	37	DECLARE_WRITE8_MEMBER(metlclsh_cause_nmi2);

trunk/src/mame/includes/beezer.h

r17814	r17815
11	11	int m_pbus;
12	12	int m_banklatch;
13	13
14		device_t *m_maincpu;
	14	cpu_device *m_maincpu;
15	15	DECLARE_WRITE8_MEMBER(beezer_bankswitch_w);
16	16	DECLARE_WRITE8_MEMBER(beezer_map_w);
17	17	DECLARE_READ8_MEMBER(beezer_line_r);

trunk/src/mame/includes/88games.h

r17814	r17815
30	30	int          m_speech_chip;
31	31
32	32	/* devices */
33		device_t *m_audiocpu;
	33	cpu_device *m_audiocpu;
34	34	device_t *m_k052109;
35	35	device_t *m_k051960;
36	36	device_t *m_k051316;

trunk/src/mame/includes/dbz.h

r17814	r17815
28	28	int           m_control;
29	29
30	30	/* devices */
31		device_t *m_maincpu;
32		device_t *m_audiocpu;
	31	cpu_device *m_maincpu;
	32	cpu_device *m_audiocpu;
33	33	device_t *m_k053246;
34	34	device_t *m_k053251;
35	35	device_t *m_k056832;

trunk/src/mame/includes/20pacgal.h

r17814	r17815
29	29	UINT8 m_game_selected;   /* 0 = Ms. Pac-Man, 1 = Galaga */
30	30
31	31	/* devices */
32		device_t *m_maincpu;
	32	cpu_device *m_maincpu;
33	33	device_t *m_eeprom;
34	34
35	35	/* memory */

trunk/src/mame/includes/system16.h

r17814	r17815
108	108	UINT8 *m_decrypted_region;   // goldnaxeb1 & bayrouteb1
109	109
110	110	/* devices */
111		device_t *m_maincpu;
112		device_t *m_soundcpu;
	111	cpu_device *m_maincpu;
	112	cpu_device *m_soundcpu;
113	113	DECLARE_WRITE16_MEMBER(sound_command_nmi_w);
114	114	DECLARE_WRITE16_MEMBER(sound_command_w);
115	115	DECLARE_WRITE16_MEMBER(sys16_coinctrl_w);

trunk/src/mame/includes/simpsons.h

r17814	r17815
22	22	//int        m_nmi_enabled;
23	23
24	24	/* devices */
25		device_t *m_maincpu;
26		device_t *m_audiocpu;
	25	cpu_device *m_maincpu;
	26	cpu_device *m_audiocpu;
27	27	device_t *m_k053260;
28	28	device_t *m_k052109;
29	29	device_t *m_k053246;

trunk/src/mame/includes/taito_b.h

r17814	r17815
30	30	UINT16        m_realpunc_video_ctrl;
31	31
32	32	/* devices */
33		device_t *m_maincpu;
34		device_t *m_audiocpu;
	33	cpu_device *m_maincpu;
	34	cpu_device *m_audiocpu;
35	35	device_t *m_mb87078;
36	36	device_t *m_ym;
37	37	device_t *m_tc0180vcu;

trunk/src/mame/includes/actfancr.h

r17814	r17815
22	22	int            m_trio_control_select;
23	23
24	24	/* devices */
25		device_t *m_maincpu;
26		device_t *m_audiocpu;
	25	cpu_device *m_maincpu;
	26	cpu_device *m_audiocpu;
27	27	DECLARE_WRITE8_MEMBER(triothep_control_select_w);
28	28	DECLARE_READ8_MEMBER(triothep_control_r);
29	29	DECLARE_WRITE8_MEMBER(actfancr_sound_w);

trunk/src/mame/includes/jackal.h

r17814	r17815
26	26	UINT8    *m_spritebank;
27	27
28	28	/* devices */
29		device_t *m_mastercpu;
30		device_t *m_slavecpu;
	29	cpu_device *m_mastercpu;
	30	cpu_device *m_slavecpu;
31	31	DECLARE_READ8_MEMBER(topgunbl_rotary_r);
32	32	DECLARE_WRITE8_MEMBER(jackal_flipscreen_w);
33	33	DECLARE_READ8_MEMBER(jackal_zram_r);

trunk/src/mame/includes/vaportra.h

r17814	r17815
23	23	UINT16    m_priority[2];
24	24
25	25	/* devices */
26		device_t *m_maincpu;
27		device_t *m_audiocpu;
	26	cpu_device *m_maincpu;
	27	cpu_device *m_audiocpu;
28	28	device_t *m_deco_tilegen1;
29	29	device_t *m_deco_tilegen2;
30	30	required_device<buffered_spriteram16_device> m_spriteram;

trunk/src/mame/includes/btime.h

r17814	r17815
52	52	int      m_protection_ret;
53	53
54	54	/* devices */
55		device_t *m_maincpu;
56		device_t *m_audiocpu;
	55	cpu_device *m_maincpu;
	56	cpu_device *m_audiocpu;
57	57
58	58	DECLARE_WRITE8_MEMBER(audio_nmi_enable_w);
59	59	DECLARE_WRITE8_MEMBER(lnc_w);

trunk/src/mame/includes/cps1.h

r17814	r17815
141	141	int          m_cps_version;
142	142
143	143	/* devices */
144		device_t *m_maincpu;
145		device_t *m_audiocpu;
	144	cpu_device *m_maincpu;
	145	cpu_device *m_audiocpu;
146	146	msm5205_device *m_msm_1;   // fcrash
147	147	msm5205_device *m_msm_2;   // fcrash
148	148	DECLARE_READ16_MEMBER(cps1_hack_dsw_r);

trunk/src/mame/includes/yunsun16.h

r17814	r17815
32	32	int         m_sprites_scrolldy;
33	33
34	34	/* devices */
35		device_t *m_audiocpu;
	35	cpu_device *m_audiocpu;
36	36	DECLARE_WRITE16_MEMBER(yunsun16_sound_bank_w);
37	37	DECLARE_WRITE16_MEMBER(magicbub_sound_command_w);
38	38	DECLARE_WRITE16_MEMBER(yunsun16_vram_0_w);

trunk/src/mame/includes/mermaid.h

r17814	r17815
49	49	UINT8    m_adpcm_play_reg;
50	50
51	51	/* devices */
52		device_t *m_maincpu;
	52	cpu_device *m_maincpu;
53	53	device_t *m_ay1;
54	54	device_t *m_ay2;
55	55

trunk/src/mame/includes/hyprduel.h

r17814	r17815
59	59	int       m_int_num;
60	60
61	61	/* devices */
62		device_t *m_maincpu;
63		device_t *m_subcpu;
	62	cpu_device *m_maincpu;
	63	cpu_device *m_subcpu;
64	64	DECLARE_READ16_MEMBER(hyprduel_irq_cause_r);
65	65	DECLARE_WRITE16_MEMBER(hyprduel_irq_cause_w);
66	66	DECLARE_WRITE16_MEMBER(hyprduel_subcpu_control_w);

trunk/src/mame/includes/flstory.h

r17814	r17815
52	52	int      m_mcu_select;
53	53
54	54	/* devices */
55		device_t *m_maincpu;
56		device_t *m_audiocpu;
	55	cpu_device *m_maincpu;
	56	cpu_device *m_audiocpu;
57	57	device_t *m_mcu;
58	58
59	59	/* mcu */

trunk/src/mame/includes/suprslam.h

r17814	r17815
35	35	int         m_pending_command;
36	36
37	37	/* devices */
38		device_t *m_audiocpu;
	38	cpu_device *m_audiocpu;
39	39	device_t *m_k053936;
40	40	DECLARE_WRITE16_MEMBER(sound_command_w);
41	41	DECLARE_READ16_MEMBER(pending_command_r);

trunk/src/mame/includes/kyugo.h

r17814	r17815
36	36	const UINT8 *m_color_codes;
37	37
38	38	/* devices */
39		device_t *m_maincpu;
40		device_t *m_subcpu;
	39	cpu_device *m_maincpu;
	40	cpu_device *m_subcpu;
41	41
42	42	UINT8       m_nmi_mask;
43	43	DECLARE_WRITE8_MEMBER(kyugo_nmi_mask_w);

trunk/src/mame/includes/lemmings.h

r17814	r17815
21	21	UINT16 m_sprite_triple_buffer_1[0x800];
22	22	UINT8 m_vram_buffer[2048 * 64];   // 64 bytes per VRAM character
23	23	/* devices */
24		device_t *m_audiocpu;
	24	cpu_device *m_audiocpu;
25	25	required_device<buffered_spriteram16_device> m_spriteram;
26	26	required_device<buffered_spriteram16_device> m_spriteram2;
27	27	/* memory pointers */

trunk/src/mame/includes/pushman.h

r17814	r17815
28	28	UINT16     m_new_latch;
29	29
30	30	/* devices */
31		device_t *m_maincpu;
32		device_t *m_audiocpu;
	31	cpu_device *m_maincpu;
	32	cpu_device *m_audiocpu;
33	33	device_t *m_mcu;
34	34	DECLARE_WRITE16_MEMBER(pushman_flipscreen_w);
35	35	DECLARE_WRITE16_MEMBER(pushman_control_w);

trunk/src/mame/includes/espial.h

r17814	r17815
35	35	UINT8     m_sound_nmi_enabled;
36	36
37	37	/* devices */
38		device_t *m_maincpu;
39		device_t *m_audiocpu;
	38	cpu_device *m_maincpu;
	39	cpu_device *m_audiocpu;
40	40	DECLARE_WRITE8_MEMBER(espial_master_interrupt_mask_w);
41	41	DECLARE_WRITE8_MEMBER(espial_master_soundlatch_w);
42	42	DECLARE_WRITE8_MEMBER(espial_sound_nmi_mask_w);

trunk/src/mame/includes/tmnt.h

r17814	r17815
47	47	UINT16      m_cuebrick_nvram[0x400 * 0x20];   // 32k paged in a 1k window
48	48
49	49	/* devices */
50		device_t *m_maincpu;
51		device_t *m_audiocpu;
	50	cpu_device *m_maincpu;
	51	cpu_device *m_audiocpu;
52	52	device_t *m_k007232;
53	53	device_t *m_k053260;
54	54	device_t *m_k054539;

trunk/src/mame/includes/citycon.h

r17814	r17815
27	27	int            m_bg_image;
28	28
29	29	/* devices */
30		device_t *m_maincpu;
	30	cpu_device *m_maincpu;
31	31	DECLARE_READ8_MEMBER(citycon_in_r);
32	32	DECLARE_READ8_MEMBER(citycon_irq_ack_r);
33	33	DECLARE_WRITE8_MEMBER(citycon_videoram_w);

trunk/src/mame/includes/spy.h

r17814	r17815
27	27	int        m_old_3f90;
28	28
29	29	/* devices */
30		device_t *m_maincpu;
31		device_t *m_audiocpu;
	30	cpu_device *m_maincpu;
	31	cpu_device *m_audiocpu;
32	32	device_t *m_k007232_1;
33	33	device_t *m_k007232_2;
34	34	device_t *m_k052109;

trunk/src/mame/includes/psikyo.h

r17814	r17815
44	44	int            m_mcu_status;
45	45
46	46	/* devices */
47		device_t *m_audiocpu;
	47	cpu_device *m_audiocpu;
48	48
49	49	/* game-specific */
50	50	// 1945 MCU

trunk/src/mame/includes/gameplan.h

r17814	r17815
45	45	emu_timer *m_via_0_ca1_timer;
46	46
47	47	/* devices */
48		device_t *m_maincpu;
49		device_t *m_audiocpu;
	48	cpu_device *m_maincpu;
	49	cpu_device *m_audiocpu;
50	50	device_t *m_riot;
51	51	required_device<via6522_device> m_via_0;
52	52	required_device<via6522_device> m_via_1;

trunk/src/mame/includes/darius.h

r17814	r17815
33	33	UINT8      m_pan[DARIUS_PAN_MAX];
34	34
35	35	/* devices */
36		device_t *m_maincpu;
37		device_t *m_audiocpu;
	36	cpu_device *m_maincpu;
	37	cpu_device *m_audiocpu;
38	38	device_t *m_cpub;
39	39	device_t *m_adpcm;
40	40	device_t *m_tc0140syt;

trunk/src/mame/includes/capbowl.h

r17814	r17815
25	25	UINT8 m_last_trackball_val[2];
26	26
27	27	/* devices */
28		device_t *m_maincpu;
29		device_t *m_audiocpu;
	28	cpu_device *m_maincpu;
	29	cpu_device *m_audiocpu;
30	30	DECLARE_WRITE8_MEMBER(capbowl_rom_select_w);
31	31	DECLARE_READ8_MEMBER(track_0_r);
32	32	DECLARE_READ8_MEMBER(track_1_r);

trunk/src/mame/includes/funkyjet.h

r17814	r17815
20	20	//  UINT16 *  paletteram;    // currently this uses generic palette handling (in decocomn.c)
21	21
22	22	/* devices */
23		device_t *m_maincpu;
24		device_t *m_audiocpu;
	23	cpu_device *m_maincpu;
	24	cpu_device *m_audiocpu;
25	25	device_t *m_deco_tilegen1;
26	26	DECLARE_DRIVER_INIT(funkyjet);
27	27	};

trunk/src/mame/includes/xexex.h

r17814	r17815
35	35	int        m_frame;
36	36
37	37	/* devices */
38		device_t *m_maincpu;
39		device_t *m_audiocpu;
	38	cpu_device *m_maincpu;
	39	cpu_device *m_audiocpu;
40	40	device_t *m_k054539;
41	41	device_t *m_filter1l;
42	42	device_t *m_filter1r;

trunk/src/mame/includes/himesiki.h

r17814	r17815
23	23	int        m_flipscreen;
24	24
25	25	/* devices */
26		device_t *m_subcpu;
	26	cpu_device *m_subcpu;
27	27	DECLARE_WRITE8_MEMBER(himesiki_rombank_w);
28	28	DECLARE_WRITE8_MEMBER(himesiki_sound_w);
29	29	DECLARE_WRITE8_MEMBER(himesiki_bg_ram_w);

trunk/src/mame/includes/ironhors.h

r17814	r17815
31	31	int        m_spriterambank;
32	32
33	33	/* devices */
34		device_t *m_maincpu;
35		device_t *m_soundcpu;
	34	cpu_device *m_maincpu;
	35	cpu_device *m_soundcpu;
36	36	DECLARE_WRITE8_MEMBER(ironhors_sh_irqtrigger_w);
37	37	DECLARE_WRITE8_MEMBER(ironhors_videoram_w);
38	38	DECLARE_WRITE8_MEMBER(ironhors_colorram_w);

trunk/src/mame/includes/mrflea.h

r17814	r17815
27	27	int m_select1;
28	28
29	29	/* devices */
30		device_t *m_maincpu;
31		device_t *m_subcpu;
	30	cpu_device *m_maincpu;
	31	cpu_device *m_subcpu;
32	32	DECLARE_WRITE8_MEMBER(mrflea_main_w);
33	33	DECLARE_WRITE8_MEMBER(mrflea_io_w);
34	34	DECLARE_READ8_MEMBER(mrflea_main_r);

trunk/src/mame/includes/mcatadv.h

r17814	r17815
29	29	int m_palette_bank2;
30	30
31	31	/* devices */
32		device_t *m_maincpu;
33		device_t *m_soundcpu;
	32	cpu_device *m_maincpu;
	33	cpu_device *m_soundcpu;
34	34	DECLARE_WRITE16_MEMBER(mcat_soundlatch_w);
35	35	DECLARE_WRITE16_MEMBER(mcat_coin_w);
36	36	DECLARE_READ16_MEMBER(mcat_wd_r);

trunk/src/mame/includes/gaelco.h

r17814	r17815
25	25	tilemap_t      *m_tilemap[2];
26	26
27	27	/* devices */
28		device_t *m_audiocpu;
	28	cpu_device *m_audiocpu;
29	29	DECLARE_WRITE16_MEMBER(bigkarnk_sound_command_w);
30	30	DECLARE_WRITE16_MEMBER(bigkarnk_coin_w);
31	31	DECLARE_WRITE16_MEMBER(OKIM6295_bankswitch_w);

trunk/src/mame/includes/munchmo.h

r17814	r17815
33	33	int          m_nmi_enable;
34	34
35	35	/* devices */
36		device_t *m_maincpu;
37		device_t *m_audiocpu;
	36	cpu_device *m_maincpu;
	37	cpu_device *m_audiocpu;
38	38	DECLARE_WRITE8_MEMBER(mnchmobl_nmi_enable_w);
39	39	DECLARE_WRITE8_MEMBER(mnchmobl_soundlatch_w);
40	40	DECLARE_WRITE8_MEMBER(sound_nmi_ack_w);

trunk/src/mame/includes/alpha68k.h

r17814	r17815
43	43	unsigned    m_game_id;   // see below
44	44
45	45	/* devices */
46		device_t *m_audiocpu;
	46	cpu_device *m_audiocpu;
47	47	UINT8       m_sound_nmi_mask;
48	48	UINT8       m_sound_pa_latch;
49	49	DECLARE_WRITE16_MEMBER(tnextspc_coin_counters_w);

trunk/src/mame/includes/wgp.h

r17814	r17815
40	40	INT32       m_banknum;
41	41
42	42	/* devices */
43		device_t *m_maincpu;
44		device_t *m_audiocpu;
45		device_t *m_subcpu;
	43	cpu_device *m_maincpu;
	44	cpu_device *m_audiocpu;
	45	cpu_device *m_subcpu;
46	46	device_t *m_tc0100scn;
47	47	device_t *m_tc0140syt;
48	48	DECLARE_READ16_MEMBER(sharedram_r);

trunk/src/mame/includes/taitoair.h

r17814	r17815
43	43	INT32         m_banknum;
44	44
45	45	/* devices */
46		device_t *m_audiocpu;
	46	cpu_device *m_audiocpu;
47	47	device_t *m_dsp;
48	48	device_t *m_tc0080vco;
49	49

trunk/src/mame/includes/aquarium.h

r17814	r17815
29	29	int m_aquarium_snd_ack;
30	30
31	31	/* devices */
32		device_t *m_audiocpu;
	32	cpu_device *m_audiocpu;
33	33	DECLARE_READ16_MEMBER(aquarium_coins_r);
34	34	DECLARE_WRITE8_MEMBER(aquarium_snd_ack_w);
35	35	DECLARE_WRITE16_MEMBER(aquarium_sound_w);

trunk/src/mame/includes/angelkds.h

r17814	r17815
34	34	UINT8      m_layer_ctrl;
35	35
36	36	/* devices */
37		device_t *m_subcpu;
	37	cpu_device *m_subcpu;
38	38	DECLARE_WRITE8_MEMBER(angelkds_cpu_bank_write);
39	39	DECLARE_READ8_MEMBER(angelkds_input_r);
40	40	DECLARE_WRITE8_MEMBER(angelkds_main_sound_w);

trunk/src/mame/includes/surpratk.h

r17814	r17815
24	24	int        m_videobank;
25	25
26	26	/* devices */
27		device_t *m_maincpu;
	27	cpu_device *m_maincpu;
28	28	device_t *m_k052109;
29	29	device_t *m_k053244;
30	30	device_t *m_k053251;

trunk/src/mame/includes/bigevglf.h

r17814	r17815
48	48	UINT8    m_port_select;     /* for muxed controls */
49	49
50	50	/* devices */
51		device_t *m_audiocpu;
	51	cpu_device *m_audiocpu;
52	52	device_t *m_mcu;
53	53	DECLARE_WRITE8_MEMBER(beg_banking_w);
54	54	DECLARE_WRITE8_MEMBER(beg_fromsound_w);

trunk/src/mame/includes/inufuku.h

r17814	r17815
33	33	UINT16    m_pending_command;
34	34
35	35	/* devices */
36		device_t *m_audiocpu;
	36	cpu_device *m_audiocpu;
37	37	DECLARE_WRITE16_MEMBER(inufuku_soundcommand_w);
38	38	DECLARE_WRITE8_MEMBER(pending_command_clear_w);
39	39	DECLARE_WRITE8_MEMBER(inufuku_soundrombank_w);

trunk/src/mame/includes/commando.h

r17814	r17815
31	31	UINT8 m_scroll_y[2];
32	32
33	33	/* devices */
34		device_t *m_audiocpu;
	34	cpu_device *m_audiocpu;
35	35	DECLARE_WRITE8_MEMBER(commando_videoram_w);
36	36	DECLARE_WRITE8_MEMBER(commando_colorram_w);
37	37	DECLARE_WRITE8_MEMBER(commando_videoram2_w);

trunk/src/mame/includes/yunsung8.h

r17814	r17815
23	23	int         m_toggle;
24	24
25	25	/* devices */
26		device_t *m_audiocpu;
	26	cpu_device *m_audiocpu;
27	27
28	28	/* memory */
29	29	UINT8      m_videoram[0x4000];

trunk/src/mame/includes/cbuster.h

r17814	r17815
30	30	int       m_pri;
31	31
32	32	/* devices */
33		device_t *m_maincpu;
34		device_t *m_audiocpu;
	33	cpu_device *m_maincpu;
	34	cpu_device *m_audiocpu;
35	35	device_t *m_deco_tilegen1;
36	36	device_t *m_deco_tilegen2;
37	37	DECLARE_WRITE16_MEMBER(twocrude_control_w);

trunk/src/mame/includes/ojankohs.h

r17814	r17815
35	35	int       m_vclk_left;
36	36
37	37	/* devices */
38		device_t *m_maincpu;
	38	cpu_device *m_maincpu;
39	39	device_t *m_msm;
40	40	DECLARE_WRITE8_MEMBER(ojankohs_rombank_w);
41	41	DECLARE_WRITE8_MEMBER(ojankoy_rombank_w);

trunk/src/mame/includes/n8080.h

r17814	r17815
39	39	int m_inte;
40	40
41	41	/* devices */
42		device_t *m_maincpu;
	42	cpu_device *m_maincpu;
43	43	DECLARE_WRITE8_MEMBER(n8080_shift_bits_w);
44	44	DECLARE_WRITE8_MEMBER(n8080_shift_data_w);
45	45	DECLARE_READ8_MEMBER(n8080_shift_r);

trunk/src/mame/includes/kncljoe.h

r17814	r17815
29	29	UINT8      m_port2;
30	30
31	31	/* devices */
32		device_t *m_soundcpu;
	32	cpu_device *m_soundcpu;
33	33	DECLARE_WRITE8_MEMBER(sound_cmd_w);
34	34	DECLARE_WRITE8_MEMBER(sound_irq_ack_w);
35	35	DECLARE_WRITE8_MEMBER(kncljoe_videoram_w);

trunk/src/mame/includes/liberate.h

r17814	r17815
29	29	tilemap_t *m_back_tilemap;
30	30	tilemap_t *m_fix_tilemap;
31	31
32		device_t *m_maincpu;
33		device_t *m_audiocpu;
	32	cpu_device *m_maincpu;
	33	cpu_device *m_audiocpu;
34	34	DECLARE_READ8_MEMBER(deco16_bank_r);
35	35	DECLARE_READ8_MEMBER(deco16_io_r);
36	36	DECLARE_WRITE8_MEMBER(deco16_bank_w);

trunk/src/mame/includes/cvs.h

r17814	r17815
55	55	UINT16     m_speech_rom_bit_address;
56	56
57	57	/* devices */
58		device_t *m_maincpu;
59		device_t *m_audiocpu;
	58	cpu_device *m_maincpu;
	59	cpu_device *m_audiocpu;
60	60	device_t *m_speech;
61	61	dac_device *m_dac3;
62	62	device_t *m_tms;

trunk/src/mame/includes/tnzs.h

r17814	r17815
52	52	UINT8*    m_ROM;
53	53
54	54	/* devices */
55		device_t *m_audiocpu;
56		device_t *m_subcpu;
	55	cpu_device *m_audiocpu;
	56	cpu_device *m_subcpu;
57	57	device_t *m_mcu;
58	58	DECLARE_WRITE8_MEMBER(tnzsb_sound_command_w);
59	59	DECLARE_WRITE8_MEMBER(jpopnics_palette_w);

trunk/src/mame/includes/cheekyms.h

r17814	r17815
24	24	bitmap_ind16       *m_bitmap_buffer;
25	25
26	26	/* devices */
27		device_t *m_maincpu;
	27	cpu_device *m_maincpu;
28	28	dac_device *m_dac;
29	29
30	30	UINT8          m_irq_mask;

trunk/src/mame/includes/warriorb.h

r17814	r17815
19	19	int        m_pandata[4];
20	20
21	21	/* devices */
22		device_t *m_maincpu;
23		device_t *m_audiocpu;
	22	cpu_device *m_maincpu;
	23	cpu_device *m_audiocpu;
24	24	device_t *m_tc0140syt;
25	25	device_t *m_tc0100scn_1;
26	26	device_t *m_tc0100scn_2;

trunk/src/mame/includes/goal92.h

r17814	r17815
35	35	int         m_adpcm_toggle;
36	36
37	37	/* devices */
38		device_t *m_audiocpu;
	38	cpu_device *m_audiocpu;
39	39	DECLARE_WRITE16_MEMBER(goal92_sound_command_w);
40	40	DECLARE_READ16_MEMBER(goal92_inputs_r);
41	41	DECLARE_WRITE8_MEMBER(adpcm_data_w);

trunk/src/mame/includes/bishi.h

r17814	r17815
25	25	UINT16     m_cur_control2;
26	26
27	27	/* devices */
28		device_t *m_maincpu;
29		device_t *m_audiocpu;
	28	cpu_device *m_maincpu;
	29	cpu_device *m_audiocpu;
30	30	device_t *m_k007232;
31	31	device_t *m_k056832;
32	32	device_t *m_k054338;

trunk/src/mame/includes/1942.h

r17814	r17815
25	25	UINT8 m_scroll[2];
26	26
27	27	/* devices */
28		device_t *m_audiocpu;
	28	cpu_device *m_audiocpu;
29	29	DECLARE_WRITE8_MEMBER(c1942_bankswitch_w);
30	30	DECLARE_WRITE8_MEMBER(c1942_fgvideoram_w);
31	31	DECLARE_WRITE8_MEMBER(c1942_bgvideoram_w);

trunk/src/mame/includes/fromanc2.h

r17814	r17815
25	25	UINT8    m_datalatch_2l;
26	26
27	27	/* devices */
28		device_t *m_audiocpu;
29		device_t *m_subcpu;
	28	cpu_device *m_audiocpu;
	29	cpu_device *m_subcpu;
30	30	device_t *m_eeprom;
31	31	device_t *m_left_screen;
32	32	device_t *m_right_screen;

trunk/src/mame/includes/blockhl.h

r17814	r17815
24	24	int        m_rombank;
25	25
26	26	/* devices */
27		device_t *m_maincpu;
28		device_t *m_audiocpu;
	27	cpu_device *m_maincpu;
	28	cpu_device *m_audiocpu;
29	29	device_t *m_k052109;
30	30	device_t *m_k051960;
31	31	DECLARE_READ8_MEMBER(bankedram_r);

trunk/src/mame/includes/bottom9.h

r17814	r17815
25	25	int        m_nmienable;
26	26
27	27	/* devices */
28		device_t *m_maincpu;
29		device_t *m_audiocpu;
	28	cpu_device *m_maincpu;
	29	cpu_device *m_audiocpu;
30	30	device_t *m_k007232_1;
31	31	device_t *m_k007232_2;
32	32	device_t *m_k052109;

trunk/src/mame/includes/mainevt.h

r17814	r17815
22	22	UINT8      m_sound_irq_mask;
23	23
24	24	/* devices */
25		device_t *m_maincpu;
26		device_t *m_audiocpu;
	25	cpu_device *m_maincpu;
	26	cpu_device *m_audiocpu;
27	27	device_t *m_upd;
28	28	device_t *m_k007232;
29	29	device_t *m_k052109;

trunk/src/mame/includes/40love.h

r17814	r17815
56	56	UINT8      m_snd_ctrl3;
57	57
58	58	/* devices */
59		device_t *m_audiocpu;
	59	cpu_device *m_audiocpu;
60	60	DECLARE_WRITE8_MEMBER(sound_command_w);
61	61	DECLARE_WRITE8_MEMBER(nmi_disable_w);
62	62	DECLARE_WRITE8_MEMBER(nmi_enable_w);

trunk/src/mame/includes/lasso.h

r17814	r17815
39	39	UINT8    m_track_enable;   /* used by wwjgtin */
40	40
41	41	/* devices */
42		device_t *m_maincpu;
43		device_t *m_audiocpu;
	42	cpu_device *m_maincpu;
	43	cpu_device *m_audiocpu;
44	44	optional_device<sn76489_new_device> m_sn_1;
45	45	optional_device<sn76489_new_device> m_sn_2;
46	46	DECLARE_WRITE8_MEMBER(sound_command_w);

trunk/src/mame/includes/taito_h.h

r17814	r17815
19	19	INT32       m_banknum;
20	20
21	21	/* devices */
22		device_t *m_maincpu;
23		device_t *m_audiocpu;
	22	cpu_device *m_maincpu;
	23	cpu_device *m_audiocpu;
24	24	device_t *m_tc0080vco;
25	25	device_t *m_tc0220ioc;
26	26	DECLARE_READ8_MEMBER(syvalion_input_bypass_r);

trunk/src/mame/includes/othunder.h

r17814	r17815
37	37	int        m_pan[4];
38	38
39	39	/* devices */
40		device_t *m_maincpu;
41		device_t *m_audiocpu;
	40	cpu_device *m_maincpu;
	41	cpu_device *m_audiocpu;
42	42	eeprom_device *m_eeprom;
43	43	device_t *m_tc0220ioc;
44	44	device_t *m_tc0100scn;

trunk/src/mame/includes/ginganin.h

r17814	r17815
33	33	#endif
34	34
35	35	/* devices */
36		device_t *m_audiocpu;
	36	cpu_device *m_audiocpu;
37	37	DECLARE_WRITE16_MEMBER(ginganin_fgram16_w);
38	38	DECLARE_WRITE16_MEMBER(ginganin_txtram16_w);
39	39	DECLARE_WRITE16_MEMBER(ginganin_vregs16_w);

trunk/src/mame/includes/tail2nos.h

r17814	r17815
25	25	int         m_video_enable;
26	26
27	27	/* devices */
28		device_t *m_maincpu;
29		device_t *m_audiocpu;
	28	cpu_device *m_maincpu;
	29	cpu_device *m_audiocpu;
30	30	device_t *m_k051316;
31	31	DECLARE_WRITE16_MEMBER(sound_command_w);
32	32	DECLARE_WRITE16_MEMBER(tail2nos_bgvideoram_w);

trunk/src/mame/includes/slapshot.h

r17814	r17815
47	47	INT32      m_banknum;
48	48
49	49	/* devices */
50		device_t *m_maincpu;
51		device_t *m_audiocpu;
	50	cpu_device *m_maincpu;
	51	cpu_device *m_audiocpu;
52	52	device_t *m_tc0140syt;
53	53	device_t *m_tc0480scp;
54	54	device_t *m_tc0360pri;

trunk/src/mame/includes/psikyo4.h

r17814	r17815
34	34	double         m_oldbrt2;
35	35
36	36	/* devices */
37		device_t *m_maincpu;
	37	cpu_device *m_maincpu;
38	38	DECLARE_WRITE32_MEMBER(ps4_paletteram32_RRRRRRRRGGGGGGGGBBBBBBBBxxxxxxxx_dword_w);
39	39	DECLARE_WRITE32_MEMBER(ps4_bgpen_1_dword_w);
40	40	DECLARE_WRITE32_MEMBER(ps4_bgpen_2_dword_w);

trunk/src/mame/includes/popper.h

r17814	r17815
33	33	rectangle m_tilemap_clip;
34	34
35	35	/* devices */
36		device_t *m_audiocpu;
	36	cpu_device *m_audiocpu;
37	37
38	38	UINT8 m_nmi_mask;
39	39	DECLARE_READ8_MEMBER(popper_input_ports_r);

trunk/src/mame/includes/ladyfrog.h

r17814	r17815
32	32	UINT8      m_snd_data;
33	33
34	34	/* devices */
35		device_t *m_audiocpu;
	35	cpu_device *m_audiocpu;
36	36	DECLARE_READ8_MEMBER(from_snd_r);
37	37	DECLARE_WRITE8_MEMBER(to_main_w);
38	38	DECLARE_WRITE8_MEMBER(sound_cpu_reset_w);

trunk/src/mame/includes/djboy.h

r17814	r17815
39	39	UINT8      m_beast_p3;
40	40
41	41	/* devices */
42		device_t *m_maincpu;
	42	cpu_device *m_maincpu;
43	43	device_t *m_cpu1;
44	44	device_t *m_cpu2;
45	45	device_t *m_pandora;

trunk/src/mame/includes/tumblep.h

r17814	r17815
20	20	//  UINT16 *  m_paletteram;    // currently this uses generic palette handling (in decocomn.c)
21	21
22	22	/* devices */
23		device_t *m_maincpu;
24		device_t *m_audiocpu;
	23	cpu_device *m_maincpu;
	24	cpu_device *m_audiocpu;
25	25	device_t *m_deco_tilegen1;
26	26	DECLARE_READ16_MEMBER(tumblep_prot_r);
27	27	DECLARE_WRITE16_MEMBER(tumblep_sound_w);

trunk/src/mame/includes/dogfgt.h

r17814	r17815
33	33	int       m_last_snd_ctrl;
34	34
35	35	/* devices */
36		device_t *m_subcpu;
	36	cpu_device *m_subcpu;
37	37	DECLARE_READ8_MEMBER(sharedram_r);
38	38	DECLARE_WRITE8_MEMBER(sharedram_w);
39	39	DECLARE_WRITE8_MEMBER(subirqtrigger_w);

trunk/src/mame/includes/dietgo.h

r17814	r17815
20	20	//  UINT16 *  m_paletteram;    // currently this uses generic palette handling (in decocomn.c)
21	21
22	22	/* devices */
23		device_t *m_maincpu;
24		device_t *m_audiocpu;
	23	cpu_device *m_maincpu;
	24	cpu_device *m_audiocpu;
25	25	device_t *m_deco_tilegen1;
26	26	DECLARE_DRIVER_INIT(dietgo);
27	27	};

trunk/src/mame/includes/blockout.h

r17814	r17815
23	23	UINT16   m_color;
24	24
25	25	/* devices */
26		device_t *m_maincpu;
27		device_t *m_audiocpu;
	26	cpu_device *m_maincpu;
	27	cpu_device *m_audiocpu;
28	28	DECLARE_WRITE16_MEMBER(blockout_sound_command_w);
29	29	DECLARE_WRITE16_MEMBER(blockout_irq6_ack_w);
30	30	DECLARE_WRITE16_MEMBER(blockout_irq5_ack_w);

trunk/src/mame/includes/f1gp.h

r17814	r17815
45	45	int       m_pending_command;
46	46
47	47	/* devices */
48		device_t *m_audiocpu;
	48	cpu_device *m_audiocpu;
49	49	device_t *m_k053936;
50	50	DECLARE_READ16_MEMBER(sharedram_r);
51	51	DECLARE_WRITE16_MEMBER(sharedram_w);

trunk/src/mame/includes/supbtime.h

r17814	r17815
22	22	/* video-related */
23	23
24	24	/* devices */
25		device_t *m_maincpu;
26		device_t *m_audiocpu;
	25	cpu_device *m_maincpu;
	26	cpu_device *m_audiocpu;
27	27	device_t *m_deco_tilegen1;
28	28	DECLARE_READ16_MEMBER(supbtime_controls_r);
29	29	DECLARE_WRITE16_MEMBER(sound_w);

trunk/src/mame/includes/gbusters.h

r17814	r17815
23	23	int        m_priority;
24	24
25	25	/* devices */
26		device_t *m_maincpu;
27		device_t *m_audiocpu;
	26	cpu_device *m_maincpu;
	27	cpu_device *m_audiocpu;
28	28	device_t *m_k007232;
29	29	device_t *m_k052109;
30	30	device_t *m_k051960;

trunk/src/mame/includes/firetrap.h

r17814	r17815
40	40	int           m_coin_command_pending;
41	41
42	42	/* devices */
43		device_t *m_maincpu;
44		device_t *m_audiocpu;
	43	cpu_device *m_maincpu;
	44	cpu_device *m_audiocpu;
45	45	device_t *m_msm;
46	46	DECLARE_WRITE8_MEMBER(firetrap_nmi_disable_w);
47	47	DECLARE_WRITE8_MEMBER(firetrap_bankselect_w);

trunk/src/mame/includes/crgolf.h

r17814	r17815
35	35	UINT8    m_sample_count;
36	36
37	37	/* devices */
38		device_t *m_maincpu;
39		device_t *m_audiocpu;
	38	cpu_device *m_maincpu;
	39	cpu_device *m_audiocpu;
40	40	DECLARE_WRITE8_MEMBER(rom_bank_select_w);
41	41	DECLARE_READ8_MEMBER(switch_input_r);
42	42	DECLARE_READ8_MEMBER(analog_input_r);

trunk/src/mame/includes/oneshot.h

r17814	r17815
32	32	int m_p2_wobble;
33	33
34	34	/* devices */
35		device_t *m_maincpu;
36		device_t *m_audiocpu;
	35	cpu_device *m_maincpu;
	36	cpu_device *m_audiocpu;
37	37	DECLARE_READ16_MEMBER(oneshot_in0_word_r);
38	38	DECLARE_READ16_MEMBER(oneshot_gun_x_p1_r);
39	39	DECLARE_READ16_MEMBER(oneshot_gun_y_p1_r);

trunk/src/mame/includes/topspeed.h

r17814	r17815
35	35	INT32      m_banknum;
36	36
37	37	/* devices */
38		device_t *m_maincpu;
39		device_t *m_audiocpu;
40		device_t *m_subcpu;
	38	cpu_device *m_maincpu;
	39	cpu_device *m_audiocpu;
	40	cpu_device *m_subcpu;
41	41	device_t *m_pc080sn_1;
42	42	device_t *m_pc080sn_2;
43	43	device_t *m_tc0220ioc;

trunk/src/mame/includes/amspdwy.h

r17814	r17815
28	28	UINT8      m_wheel_return[2];
29	29
30	30	/* devices */
31		device_t *m_audiocpu;
	31	cpu_device *m_audiocpu;
32	32	DECLARE_READ8_MEMBER(amspdwy_wheel_0_r);
33	33	DECLARE_READ8_MEMBER(amspdwy_wheel_1_r);
34	34	DECLARE_WRITE8_MEMBER(amspdwy_sound_w);

trunk/src/mame/includes/bladestl.h

r17814	r17815
22	22	int        m_last_track[4];
23	23
24	24	/* devices */
25		device_t *m_audiocpu;
	25	cpu_device *m_audiocpu;
26	26	device_t *m_k007342;
27	27	device_t *m_k007420;
28	28	DECLARE_READ8_MEMBER(trackball_r);

trunk/src/mame/includes/pbaction.h

r17814	r17815
31	31	int        m_scroll;
32	32
33	33	/* devices */
34		device_t *m_maincpu;
35		device_t *m_audiocpu;
	34	cpu_device *m_maincpu;
	35	cpu_device *m_audiocpu;
36	36
37	37	UINT8      m_nmi_mask;
38	38	DECLARE_WRITE8_MEMBER(pbaction_sh_command_w);

trunk/src/mame/includes/overdriv.h

r17814	r17815
22	22	UINT16     m_cpuB_ctrl;
23	23
24	24	/* devices */
25		device_t *m_maincpu;
26		device_t *m_subcpu;
27		device_t *m_audiocpu;
	25	cpu_device *m_maincpu;
	26	cpu_device *m_subcpu;
	27	cpu_device *m_audiocpu;
28	28	device_t *m_k053260_1;
29	29	device_t *m_k053260_2;
30	30	device_t *m_k051316_1;

trunk/src/mame/includes/thunderx.h

r17814	r17815
28	28	int        m_pmcbank;
29	29
30	30	/* devices */
31		device_t *m_maincpu;
32		device_t *m_audiocpu;
	31	cpu_device *m_maincpu;
	32	cpu_device *m_audiocpu;
33	33	device_t *m_k007232;
34	34	device_t *m_k052109;
35	35	device_t *m_k051960;

trunk/src/mame/includes/xmen.h

r17814	r17815
31	31	UINT8       m_vblank_irq_mask;
32	32
33	33	/* devices */
34		device_t *m_maincpu;
35		device_t *m_audiocpu;
	34	cpu_device *m_maincpu;
	35	cpu_device *m_audiocpu;
36	36	device_t *m_k054539;
37	37	device_t *m_k052109;
38	38	device_t *m_k053246;

trunk/src/mame/includes/atarifb.h

r17814	r17815
57	57	int m_counter_y_in2b;
58	58
59	59	/* devices */
60		device_t *m_maincpu;
	60	cpu_device *m_maincpu;
61	61	DECLARE_WRITE8_MEMBER(atarifb_out1_w);
62	62	DECLARE_WRITE8_MEMBER(atarifb4_out1_w);
63	63	DECLARE_WRITE8_MEMBER(abaseb_out1_w);

trunk/src/mame/includes/lethal.h

r17814	r17815
18	18	UINT8      m_cur_control2;
19	19
20	20	/* devices */
21		device_t *m_maincpu;
22		device_t *m_audiocpu;
	21	cpu_device *m_maincpu;
	22	cpu_device *m_audiocpu;
23	23	device_t *m_k054539;
24	24	device_t *m_k056832;
25	25	device_t *m_k053244;

trunk/src/mame/includes/exprraid.h

r17814	r17815
30	30	//int          m_coin;    // used in the commented out INTERRUPT_GEN - can this be removed?
31	31
32	32	/* devices */
33		device_t *m_maincpu;
	33	cpu_device *m_maincpu;
34	34	device_t *m_slave;
35	35	DECLARE_READ8_MEMBER(exprraid_protection_r);
36	36	DECLARE_WRITE8_MEMBER(sound_cpu_command_w);

trunk/src/mame/includes/tumbleb.h

r17814	r17815
33	33	UINT16      m_tilebank;
34	34
35	35	/* devices */
36		device_t *m_maincpu;
37		device_t *m_audiocpu;
	36	cpu_device *m_maincpu;
	37	cpu_device *m_audiocpu;
38	38	device_t *m_oki;
39	39	UINT8 m_semicom_prot_offset;
40	40	UINT16 m_protbase;

trunk/src/mame/includes/kchamp.h

r17814	r17815
29	29	int        m_counter;
30	30
31	31	/* devices */
32		device_t *m_audiocpu;
	32	cpu_device *m_audiocpu;
33	33	DECLARE_WRITE8_MEMBER(control_w);
34	34	DECLARE_WRITE8_MEMBER(sound_reset_w);
35	35	DECLARE_WRITE8_MEMBER(sound_command_w);

trunk/src/mame/includes/taito_z.h

r17814	r17815
30	30	UINT16      m_eep_latch;
31	31
32	32	/* devices */
33		device_t *m_maincpu;
34		device_t *m_audiocpu;
35		device_t *m_subcpu;
	33	cpu_device *m_maincpu;
	34	cpu_device *m_audiocpu;
	35	cpu_device *m_subcpu;
36	36	eeprom_device *m_eeprom;
37	37	device_t *m_tc0480scp;
38	38	device_t *m_tc0150rod;

trunk/src/mame/includes/msisaac.h

r17814	r17815
42	42	UINT8       m_snd_ctrl3;
43	43
44	44	/* devices */
45		device_t *m_audiocpu;
	45	cpu_device *m_audiocpu;
46	46	DECLARE_WRITE8_MEMBER(sound_command_w);
47	47	DECLARE_WRITE8_MEMBER(nmi_disable_w);
48	48	DECLARE_WRITE8_MEMBER(nmi_enable_w);

trunk/src/mame/includes/lockon.h

r17814	r17815
64	64	UINT32      m_main_inten;
65	65
66	66	/* devices */
67		device_t *m_maincpu;
68		device_t *m_audiocpu;
	67	cpu_device *m_maincpu;
	68	cpu_device *m_audiocpu;
69	69	device_t *m_ground;
70	70	device_t *m_object;
71	71	device_t *m_f2203_1l;

trunk/src/mame/includes/rastan.h

r17814	r17815
22	22	int         m_adpcm_data;
23	23
24	24	/* devices */
25		device_t *m_maincpu;
26		device_t *m_audiocpu;
	25	cpu_device *m_maincpu;
	26	cpu_device *m_audiocpu;
27	27	device_t *m_pc090oj;
28	28	device_t *m_pc080sn;
29	29	DECLARE_WRITE8_MEMBER(rastan_msm5205_address_w);

trunk/src/mame/includes/gijoe.h

r17814	r17815
30	30	emu_timer   *m_dmadelay_timer;
31	31
32	32	/* devices */
33		device_t *m_maincpu;
34		device_t *m_audiocpu;
	33	cpu_device *m_maincpu;
	34	cpu_device *m_audiocpu;
35	35	device_t *m_k054539;
36	36	device_t *m_k056832;
37	37	device_t *m_k053246;

trunk/src/mame/includes/rltennis.h

r17814	r17815
11	11	m_data760000(0), m_data740000(0), m_dac_counter(0), m_sample_rom_offset_1(0), m_sample_rom_offset_2(0),
12	12	m_offset_shift(0){ }
13	13
14		device_t *m_maincpu;
	14	cpu_device *m_maincpu;
15	15	device_t *m_screen;
16	16
17	17	UINT16 m_blitter[RLT_NUM_BLITTER_REGS];

trunk/src/mame/includes/psikyosh.h

r17814	r17815
45	45	UINT8          m_alphatable[256];
46	46
47	47	/* devices */
48		device_t *m_maincpu;
	48	cpu_device *m_maincpu;
49	49
50	50	DECLARE_WRITE32_MEMBER(psikyosh_irqctrl_w);
51	51	DECLARE_WRITE32_MEMBER(paletteram32_RRRRRRRRGGGGGGGGBBBBBBBBxxxxxxxx_dword_w);

trunk/src/mame/includes/gradius3.h

r17814	r17815
25	25	int         m_irqBmask;
26	26
27	27	/* devices */
28		device_t *m_maincpu;
29		device_t *m_audiocpu;
30		device_t *m_subcpu;
	28	cpu_device *m_maincpu;
	29	cpu_device *m_audiocpu;
	30	cpu_device *m_subcpu;
31	31	device_t *m_k007232;
32	32	device_t *m_k052109;
33	33	device_t *m_k051960;

trunk/src/mame/includes/fromance.h

r17814	r17815
50	50	UINT8    m_sound_command;
51	51
52	52	/* devices */
53		device_t *m_subcpu;
	53	cpu_device *m_subcpu;
54	54	DECLARE_READ8_MEMBER(fromance_commanddata_r);
55	55	DECLARE_WRITE8_MEMBER(fromance_commanddata_w);
56	56	DECLARE_READ8_MEMBER(fromance_busycheck_main_r);

trunk/src/mame/includes/neogeo.h

r17814	r17815
109	109	int        m_fixed_layer_bank_type;
110	110
111	111	/* devices */
112		device_t *m_maincpu;
113		device_t *m_audiocpu;
	112	cpu_device *m_maincpu;
	113	cpu_device *m_audiocpu;
114	114	device_t *m_upd4990a;
115	115	DECLARE_WRITE8_MEMBER(audio_cpu_clear_nmi_w);
116	116	DECLARE_WRITE16_MEMBER(io_control_w);

trunk/src/mame/includes/ultraman.h

r17814	r17815
21	21	int        m_bank2;
22	22
23	23	/* devices */
24		device_t *m_maincpu;
25		device_t *m_audiocpu;
	24	cpu_device *m_maincpu;
	25	cpu_device *m_audiocpu;
26	26	device_t *m_k051316_1;
27	27	device_t *m_k051316_2;
28	28	device_t *m_k051316_3;

trunk/src/mame/includes/parodius.h

r17814	r17815
25	25	//int        m_nmi_enabled;
26	26
27	27	/* devices */
28		device_t *m_maincpu;
29		device_t *m_audiocpu;
	28	cpu_device *m_maincpu;
	29	cpu_device *m_audiocpu;
30	30	device_t *m_k053260;
31	31	device_t *m_k052109;
32	32	device_t *m_k053245;

trunk/src/mame/includes/ladybug.h

r17814	r17815
43	43	UINT8      m_sraider_0x38;
44	44
45	45	/* devices */
46		device_t *m_maincpu;
	46	cpu_device *m_maincpu;
47	47	DECLARE_READ8_MEMBER(sraider_sound_low_r);
48	48	DECLARE_READ8_MEMBER(sraider_sound_high_r);
49	49	DECLARE_WRITE8_MEMBER(sraider_sound_low_w);

trunk/src/mame/includes/blueprnt.h

r17814	r17815
28	28	int     m_dipsw;
29	29
30	30	/* devices */
31		device_t *m_audiocpu;
	31	cpu_device *m_audiocpu;
32	32	DECLARE_READ8_MEMBER(blueprnt_sh_dipsw_r);
33	33	DECLARE_WRITE8_MEMBER(blueprnt_sound_command_w);
34	34	DECLARE_WRITE8_MEMBER(blueprnt_coin_counter_w);

trunk/src/mame/includes/rockrage.h

r17814	r17815
19	19	int        m_vreg;
20	20
21	21	/* devices */
22		device_t *m_audiocpu;
	22	cpu_device *m_audiocpu;
23	23	device_t *m_k007342;
24	24	device_t *m_k007420;
25	25	DECLARE_WRITE8_MEMBER(rockrage_bankswitch_w);

trunk/src/mame/includes/buggychl.h

r17814	r17815
36	36	int         m_pending_nmi;
37	37
38	38	/* devices */
39		device_t *m_audiocpu;
	39	cpu_device *m_audiocpu;
40	40	DECLARE_WRITE8_MEMBER(bankswitch_w);
41	41	DECLARE_WRITE8_MEMBER(sound_command_w);
42	42	DECLARE_WRITE8_MEMBER(nmi_disable_w);

trunk/src/mame/includes/gotcha.h

r17814	r17815
27	27	UINT16      m_scroll[4];
28	28
29	29	/* devices */
30		device_t *m_audiocpu;
	30	cpu_device *m_audiocpu;
31	31	DECLARE_WRITE16_MEMBER(gotcha_lamps_w);
32	32	DECLARE_WRITE16_MEMBER(gotcha_fgvideoram_w);
33	33	DECLARE_WRITE16_MEMBER(gotcha_bgvideoram_w);

trunk/src/mame/includes/taito_f2.h

r17814	r17815
71	71	INT32           m_oki_bank;
72	72
73	73	/* devices */
74		device_t *m_maincpu;
75		device_t *m_audiocpu;
	74	cpu_device *m_maincpu;
	75	cpu_device *m_audiocpu;
76	76	optional_device<okim6295_device> m_oki;
77	77	device_t *m_tc0100scn;
78	78	device_t *m_tc0100scn_1;

trunk/src/mame/includes/ddragon.h

r17814	r17815
59	59	#endif
60	60
61	61	/* devices */
62		device_t *m_maincpu;
	62	cpu_device *m_maincpu;
63	63	device_t *m_snd_cpu;
64	64	device_t *m_sub_cpu;
65	65	device_t *m_adpcm_1;

trunk/src/mame/includes/asterix.h

r17814	r17815
26	26	UINT16      m_prot[2];
27	27
28	28	/* devices */
29		device_t *m_maincpu;
30		device_t *m_audiocpu;
	29	cpu_device *m_maincpu;
	30	cpu_device *m_audiocpu;
31	31	device_t *m_k053260;
32	32	device_t *m_k056832;
33	33	device_t *m_k053244;

trunk/src/mame/includes/homedata.h

r17814	r17815
36	36	int      m_from_cpu;
37	37
38	38	/* device */
39		device_t *m_maincpu;
40		device_t *m_audiocpu;
	39	cpu_device *m_maincpu;
	40	cpu_device *m_audiocpu;
41	41	dac_device *m_dac;
42	42	device_t *m_ym;
43	43	sn76489a_new_device *m_sn;

trunk/src/mame/includes/mugsmash.h

r17814	r17815
19	19	tilemap_t *m_tilemap1;
20	20	tilemap_t *m_tilemap2;
21	21
22		device_t *m_maincpu;
23		device_t *m_audiocpu;
	22	cpu_device *m_maincpu;
	23	cpu_device *m_audiocpu;
24	24	DECLARE_WRITE16_MEMBER(mugsmash_reg2_w);
25	25	DECLARE_READ16_MEMBER(mugsmash_input_ports_r);
26	26	DECLARE_WRITE16_MEMBER(mugsmash_videoram1_w);

trunk/src/mame/includes/macrossp.h

r17814	r17815
49	49	INT32          m_old_fade;
50	50
51	51	/* devices */
52		device_t *m_maincpu;
53		device_t *m_audiocpu;
	52	cpu_device *m_maincpu;
	53	cpu_device *m_audiocpu;
54	54	DECLARE_WRITE32_MEMBER(paletteram32_macrossp_w);
55	55	DECLARE_READ32_MEMBER(macrossp_soundstatus_r);
56	56	DECLARE_WRITE32_MEMBER(macrossp_soundcmd_w);

trunk/src/mame/includes/moo.h

r17814	r17815
29	29	UINT16      m_cur_control2;
30	30
31	31	/* devices */
32		device_t *m_maincpu;
33		device_t *m_audiocpu;
	32	cpu_device *m_maincpu;
	33	cpu_device *m_audiocpu;
34	34	device_t *m_k054539;
35	35	device_t *m_k053246;
36	36	device_t *m_k053251;

trunk/src/mame/includes/taito_l.h

r17814	r17815
52	52	const char *m_portf1_tag;
53	53
54	54	/* devices */
55		device_t *m_maincpu;
56		device_t *m_audiocpu;
	55	cpu_device *m_maincpu;
	56	cpu_device *m_audiocpu;
57	57
58	58	/* memory buffers */
59	59	UINT8         m_rambanks[0x1000 * 12];

trunk/src/mame/includes/vendetta.h

r17814	r17815
24	24	offs_t     m_video_banking_base;
25	25
26	26	/* devices */
27		device_t *m_maincpu;
28		device_t *m_audiocpu;
	27	cpu_device *m_maincpu;
	28	cpu_device *m_audiocpu;
29	29	device_t *m_k053260;
30	30	device_t *m_k052109;
31	31	device_t *m_k053246;

trunk/src/mame/includes/fcombat.h

r17814	r17815
48	48	int        m_ty;
49	49
50	50	/* devices */
51		device_t *m_maincpu;
	51	cpu_device *m_maincpu;
52	52	DECLARE_READ8_MEMBER(fcombat_protection_r);
53	53	DECLARE_READ8_MEMBER(fcombat_port01_r);
54	54	DECLARE_WRITE8_MEMBER(e900_w);

trunk/src/mame/includes/marineb.h

r17814	r17815
21	21	UINT8     m_marineb_active_low_flipscreen;
22	22
23	23	/* devices */
24		device_t *m_maincpu;
25		device_t *m_audiocpu;
	24	cpu_device *m_maincpu;
	25	cpu_device *m_audiocpu;
26	26
27	27	UINT8     m_irq_mask;
28	28	DECLARE_WRITE8_MEMBER(irq_mask_w);

trunk/src/mame/includes/pktgaldx.h

r17814	r17815
25	25	optional_shared_ptr<UINT16> m_pktgaldb_sprites;
26	26
27	27	/* devices */
28		device_t *m_maincpu;
	28	cpu_device *m_maincpu;
29	29	device_t *m_deco_tilegen1;
30	30	DECLARE_READ16_MEMBER(pckgaldx_unknown_r);
31	31	DECLARE_READ16_MEMBER(pckgaldx_protection_r);

trunk/src/mame/includes/fuukifg2.h

r17814	r17815
26	26	emu_timer   *m_raster_interrupt_timer;
27	27
28	28	/* devices */
29		device_t *m_maincpu;
30		device_t *m_audiocpu;
	29	cpu_device *m_maincpu;
	30	cpu_device *m_audiocpu;
31	31	DECLARE_WRITE16_MEMBER(fuuki16_vregs_w);
32	32	DECLARE_WRITE16_MEMBER(fuuki16_sound_command_w);
33	33	DECLARE_WRITE8_MEMBER(fuuki16_sound_rombank_w);

trunk/src/mame/includes/circus.h

r17814	r17815
17	17	int m_clown_z;
18	18
19	19	/* devices */
20		device_t *m_maincpu;
	20	cpu_device *m_maincpu;
21	21	samples_device *m_samples;
22	22	device_t *m_discrete;
23	23

trunk/src/mame/includes/champbas.h

r17814	r17815
31	31	int            m_watchdog_count;
32	32
33	33	/* devices */
34		device_t *m_maincpu;
35		device_t *m_audiocpu;
	34	cpu_device *m_maincpu;
	35	cpu_device *m_audiocpu;
36	36	device_t *m_mcu;
37	37
38	38	UINT8          m_irq_mask;

trunk/src/mame/includes/ninjaw.h

r17814	r17815
20	20	int        m_pandata[4];
21	21
22	22	/* devices */
23		device_t *m_maincpu;
24		device_t *m_audiocpu;
25		device_t *m_subcpu;
	23	cpu_device *m_maincpu;
	24	cpu_device *m_audiocpu;
	25	cpu_device *m_subcpu;
26	26	device_t *m_tc0140syt;
27	27	device_t *m_tc0100scn_1;
28	28	device_t *m_tc0100scn_2;

trunk/src/mame/includes/matmania.h

r17814	r17815
48	48	int             m_main_sent;
49	49
50	50	/* devices */
51		device_t *m_maincpu;
52		device_t *m_audiocpu;
	51	cpu_device *m_maincpu;
	52	cpu_device *m_audiocpu;
53	53	device_t *m_mcu;
54	54	DECLARE_WRITE8_MEMBER(matmania_sh_command_w);
55	55	DECLARE_WRITE8_MEMBER(maniach_sh_command_w);

trunk/src/mame/includes/airbustr.h

r17814	r17815
41	41	/* devices */
42	42	device_t *m_master;
43	43	device_t *m_slave;
44		device_t *m_audiocpu;
	44	cpu_device *m_audiocpu;
45	45	device_t *m_pandora;
46	46	DECLARE_READ8_MEMBER(devram_r);
47	47	DECLARE_WRITE8_MEMBER(master_nmi_trigger_w);

trunk/src/mame/includes/dcheese.h

r17814	r17815
27	27	UINT8    m_sound_msb_latch;
28	28
29	29	/* devices */
30		device_t *m_maincpu;
31		device_t *m_audiocpu;
	30	cpu_device *m_maincpu;
	31	cpu_device *m_audiocpu;
32	32	device_t *m_bsmt;
33	33	DECLARE_WRITE16_MEMBER(eeprom_control_w);
34	34	DECLARE_WRITE16_MEMBER(sound_command_w);

trunk/src/mame/includes/chqflag.h

r17814	r17815
26	26	int        m_wheel;
27	27
28	28	/* devices */
29		device_t *m_maincpu;
30		device_t *m_audiocpu;
	29	cpu_device *m_maincpu;
	30	cpu_device *m_audiocpu;
31	31	device_t *m_k007232_1;
32	32	device_t *m_k007232_2;
33	33	device_t *m_k051960;

trunk/src/mame/includes/bwing.h

r17814	r17815
48	48	UINT8 *m_bwp123_membase[3];
49	49
50	50	/* device */
51		device_t *m_maincpu;
52		device_t *m_subcpu;
53		device_t *m_audiocpu;
	51	cpu_device *m_maincpu;
	52	cpu_device *m_subcpu;
	53	cpu_device *m_audiocpu;
54	54	DECLARE_WRITE8_MEMBER(bwp12_sharedram1_w);
55	55	DECLARE_WRITE8_MEMBER(bwp3_u8F_w);
56	56	DECLARE_WRITE8_MEMBER(bwp3_nmimask_w);

trunk/src/mame/includes/sf.h

r17814	r17815
26	26	UINT16      m_fgscroll;
27	27
28	28	/* devices */
29		device_t *m_maincpu;
30		device_t *m_audiocpu;
	29	cpu_device *m_maincpu;
	30	cpu_device *m_audiocpu;
31	31	DECLARE_READ16_MEMBER(dummy_r);
32	32	DECLARE_WRITE16_MEMBER(sf_coin_w);
33	33	DECLARE_WRITE16_MEMBER(soundcmd_w);

trunk/src/mame/includes/lsasquad.h

r17814	r17815
33	33	UINT8 m_ddr_b;
34	34
35	35	/* devices */
36		device_t *m_maincpu;
37		device_t *m_audiocpu;
	36	cpu_device *m_maincpu;
	37	cpu_device *m_audiocpu;
38	38	device_t *m_mcu;
39	39	DECLARE_WRITE8_MEMBER(lsasquad_bankswitch_w);
40	40	DECLARE_WRITE8_MEMBER(lsasquad_sh_nmi_disable_w);

trunk/src/mame/includes/cave.h

r17814	r17815
110	110	int          m_hopper;
111	111
112	112	/* devices */
113		device_t *m_maincpu;
114		device_t *m_audiocpu;
	113	cpu_device *m_maincpu;
	114	cpu_device *m_audiocpu;
115	115	required_device<timer_device> m_int_timer;
116	116	int m_rasflag;
117	117	int m_old_rasflag;

trunk/src/mame/includes/brkthru.h

r17814	r17815
27	27	//UINT8 *m_brkthru_nmi_enable; /* needs to be tracked down */
28	28
29	29	/* devices */
30		device_t *m_maincpu;
31		device_t *m_audiocpu;
	30	cpu_device *m_maincpu;
	31	cpu_device *m_audiocpu;
32	32
33	33	UINT8   m_nmi_mask;
34	34	DECLARE_WRITE8_MEMBER(brkthru_1803_w);

trunk/src/mame/includes/fuukifg3.h

r17814	r17815
40	40	UINT8       m_shared_ram[16];
41	41
42	42	/* devices */
43		device_t *m_maincpu;
44		device_t *m_audiocpu;
	43	cpu_device *m_maincpu;
	44	cpu_device *m_audiocpu;
45	45	DECLARE_WRITE32_MEMBER(paletteram32_xRRRRRGGGGGBBBBB_dword_w);
46	46	DECLARE_READ32_MEMBER(snd_020_r);
47	47	DECLARE_WRITE32_MEMBER(snd_020_w);

trunk/src/mame/includes/dec8.h

r17814	r17815
10	10	m_bg_data(*this, "bg_data"){ }
11	11
12	12	/* devices */
13		device_t *m_maincpu;
14		device_t *m_subcpu;
15		device_t *m_audiocpu;
	13	cpu_device *m_maincpu;
	14	cpu_device *m_subcpu;
	15	cpu_device *m_audiocpu;
16	16	device_t *m_mcu;
17	17	required_device<buffered_spriteram8_device> m_spriteram;
18	18

trunk/src/mame/includes/battlane.h

r17814	r17815
23	23	int         m_cpu_control;   /* CPU interrupt control register */
24	24
25	25	/* devices */
26		device_t *m_maincpu;
27		device_t *m_subcpu;
	26	cpu_device *m_maincpu;
	27	cpu_device *m_subcpu;
28	28	DECLARE_WRITE8_MEMBER(battlane_cpu_command_w);
29	29	DECLARE_WRITE8_MEMBER(battlane_palette_w);
30	30	DECLARE_WRITE8_MEMBER(battlane_scrollx_w);

trunk/src/mame/includes/crimfght.h

r17814	r17815
18	18	int        m_sprite_colorbase;
19	19
20	20	/* devices */
21		device_t *m_maincpu;
22		device_t *m_audiocpu;
	21	cpu_device *m_maincpu;
	22	cpu_device *m_audiocpu;
23	23	device_t *m_k007232;
24	24	device_t *m_k052109;
25	25	device_t *m_k051960;

trunk/src/mame/includes/asuka.h

r17814	r17815
30	30	int         m_adpcm_data;
31	31
32	32	/* devices */
33		device_t *m_maincpu;
34		device_t *m_audiocpu;
	33	cpu_device *m_maincpu;
	34	cpu_device *m_audiocpu;
35	35	device_t *m_pc090oj;
36	36	device_t *m_tc0100scn;
37	37	DECLARE_WRITE8_MEMBER(sound_bankswitch_w);

trunk/src/mame/includes/rollerg.h

r17814	r17815
21	21	int        m_readzoomroms;
22	22
23	23	/* devices */
24		device_t *m_maincpu;
25		device_t *m_audiocpu;
	24	cpu_device *m_maincpu;
	25	cpu_device *m_audiocpu;
26	26	device_t *m_k053260;
27	27	device_t *m_k053244;
28	28	device_t *m_k051316;

trunk/src/mame/includes/exerion.h

r17814	r17815
46	46	UINT8 m_portb;
47	47
48	48	/* devices */
49		device_t *m_maincpu;
	49	cpu_device *m_maincpu;
50	50	DECLARE_READ8_MEMBER(exerion_protection_r);
51	51	DECLARE_WRITE8_MEMBER(exerion_videoreg_w);
52	52	DECLARE_WRITE8_MEMBER(exerion_video_latch_w);

trunk/src/mame/includes/crospang.h

r17814	r17815
25	25	int       m_bestri_tilebank;
26	26
27	27	/* devices */
28		device_t *m_audiocpu;
	28	cpu_device *m_audiocpu;
29	29	DECLARE_WRITE16_MEMBER(crospang_soundlatch_w);
30	30	DECLARE_WRITE16_MEMBER(bestri_tilebank_w);
31	31	DECLARE_WRITE16_MEMBER(bestri_bg_scrolly_w);

trunk/src/mame/includes/ajax.h

r17814	r17815
18	18	int        m_firq_enable;
19	19
20	20	/* devices */
21		device_t *m_maincpu;
22		device_t *m_audiocpu;
23		device_t *m_subcpu;
	21	cpu_device *m_maincpu;
	22	cpu_device *m_audiocpu;
	23	cpu_device *m_subcpu;
24	24	device_t *m_k007232_1;
25	25	device_t *m_k007232_2;
26	26	device_t *m_k052109;

trunk/src/mame/includes/funybubl.h

r17814	r17815
11	11	required_shared_ptr<UINT8> m_paletteram;
12	12
13	13	/* devices */
14		device_t *m_audiocpu;
	14	cpu_device *m_audiocpu;
15	15
16	16	/* memory */
17	17	UINT8      m_banked_vram[0x2000];

trunk/src/mame/drivers/bfcobra.c

r17814	r17815
740	740	} while (blitter.command  & CMD_RUN);
741	741
742	742	/* Burn Z80 cycles while blitter is in operation */
743		device_spin_until_time(&space->device(),  attotime::from_nsec( (1000000000 / Z80_XTAL)*cycles_used * 2 ) );
	743	space->device().execute().spin_until_time(attotime::from_nsec( (1000000000 / Z80_XTAL)*cycles_used * 2 ) );
744	744	}
745	745
746	746

trunk/src/mame/drivers/nycaptor.c

r17814	r17815
202	202
203	203	WRITE8_MEMBER(nycaptor_state::sub_cpu_halt_w)
204	204	{
205		device_set_input_line(m_subcpu, INPUT_LINE_HALT, (data) ? ASSERT_LINE : CLEAR_LINE);
	205	m_subcpu->set_input_line(INPUT_LINE_HALT, (data) ? ASSERT_LINE : CLEAR_LINE);
206	206	}
207	207
208	208	READ8_MEMBER(nycaptor_state::from_snd_r)
r17814	r17815
249	249
250	250	WRITE8_MEMBER(nycaptor_state::sound_cpu_reset_w)
251	251	{
252		device_set_input_line(m_audiocpu, INPUT_LINE_RESET, (data&1 )? ASSERT_LINE : CLEAR_LINE);
	252	m_audiocpu->set_input_line(INPUT_LINE_RESET, (data&1 )? ASSERT_LINE : CLEAR_LINE);
253	253	}
254	254
255	255
r17814	r17815
275	275	{
276	276	nycaptor_state *state = machine.driver_data<nycaptor_state>();
277	277	if (state->m_sound_nmi_enable)
278		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	278	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
279	279	else
280	280	state->m_pending_nmi = 1;
281	281	}
r17814	r17815
297	297
298	298	if (m_pending_nmi)
299	299	{
300		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	300	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
301	301	m_pending_nmi = 0;
302	302	}
303	303	}
r17814	r17815
767	767	{
768	768	nycaptor_state *state = machine.driver_data<nycaptor_state>();
769	769
770		state->m_maincpu = machine.device("maincpu");
771		state->m_audiocpu = machine.device("audiocpu");
772		state->m_subcpu = machine.device("sub");
	770	state->m_maincpu = machine.device<cpu_device>("maincpu");
	771	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
	772	state->m_subcpu = machine.device<cpu_device>("sub");
773	773	state->m_mcu = machine.device("mcu");
774	774
775	775	state->save_item(NAME(state->m_generic_control_reg));

trunk/src/mame/drivers/mitchell.c

r17814	r17815
394	394	WRITE8_MEMBER(mitchell_state::mstworld_sound_w)
395	395	{
396	396	soundlatch_byte_w(space, 0, data);
397		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	397	m_audiocpu->set_input_line(0, HOLD_LINE);
398	398	}
399	399
400	400	static ADDRESS_MAP_START( mstworld_io_map, AS_IO, 8, mitchell_state )
r17814	r17815
1105	1105
1106	1106	if (scanline == 240 || scanline == 0)
1107	1107	{
1108		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	1108	state->m_maincpu->set_input_line(0, HOLD_LINE);
1109	1109
1110	1110	state->m_irq_source = (scanline == 240);
1111	1111	}
r17814	r17815
1211	1211	state->m_sample_buffer >>= 4;
1212	1212	state->m_sample_select ^= 1;
1213	1213	if(state->m_sample_select == 0)
1214		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	1214	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
1215	1215	}
1216	1216
1217	1217

trunk/src/mame/drivers/dynduke.c

r17814	r17815
265	265
266	266	static INTERRUPT_GEN( dynduke_interrupt )
267	267	{
268		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0xc8/4);   // VBL
	268	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0xc8/4);   // VBL
269	269	}
270	270
271	271	/* Machine Driver */

trunk/src/mame/drivers/blktiger.c

r17814	r17815
33	33
34	34	WRITE8_MEMBER(blktiger_state::blktiger_to_mcu_w)
35	35	{
36		device_set_input_line(m_mcu, MCS51_INT1_LINE, ASSERT_LINE);
	36	m_mcu->execute().set_input_line(MCS51_INT1_LINE, ASSERT_LINE);
37	37	m_z80_latch = data;
38	38	}
39	39
40	40	READ8_MEMBER(blktiger_state::blktiger_from_main_r)
41	41	{
42		device_set_input_line(m_mcu, MCS51_INT1_LINE, CLEAR_LINE);
	42	m_mcu->execute().set_input_line(MCS51_INT1_LINE, CLEAR_LINE);
43	43	//printf("%02x read\n",latch);
44	44	return m_z80_latch;
45	45	}
r17814	r17815
262	262	static void irqhandler( device_t *device, int irq )
263	263	{
264	264	blktiger_state *state = device->machine().driver_data<blktiger_state>();
265		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	265	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
266	266	}
267	267
268	268	static const ym2203_interface ym2203_config =
r17814	r17815
279	279	{
280	280	blktiger_state *state = machine.driver_data<blktiger_state>();
281	281
282		state->m_audiocpu = machine.device("audiocpu");
	282	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
283	283	state->m_mcu = machine.device("mcu");
284	284
285	285	/* configure bankswitching */

trunk/src/mame/drivers/mgolf.c

r17814	r17815
27	27	attotime m_time_released;
28	28
29	29	/* devices */
30		device_t *m_maincpu;
	30	cpu_device *m_maincpu;
31	31	DECLARE_WRITE8_MEMBER(mgolf_vram_w);
32	32	DECLARE_READ8_MEMBER(mgolf_wram_r);
33	33	DECLARE_READ8_MEMBER(mgolf_dial_r);
r17814	r17815
100	100	state->m_time_released = machine.time();
101	101
102	102	if (!state->m_mask)
103		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	103	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
104	104	}
105	105	else
106	106	state->m_time_pushed = machine.time();
r17814	r17815
306	306	{
307	307	mgolf_state *state = machine.driver_data<mgolf_state>();
308	308
309		state->m_maincpu = machine.device("maincpu");
	309	state->m_maincpu = machine.device<cpu_device>("maincpu");
310	310
311	311	state->save_item(NAME(state->m_prev));
312	312	state->save_item(NAME(state->m_mask));

trunk/src/mame/drivers/deco_mlc.c

r17814	r17815
724	724	UINT32 a=m_mlc_ram[0x89a0/4];
725	725	UINT32 p=space.device().safe_pc();
726	726
727		if ((p==0x3234 || p==0x32dc) && (a&1)) device_spin_until_interrupt(&space.device());
	727	if ((p==0x3234 || p==0x32dc) && (a&1)) space.device().execute().spin_until_interrupt();
728	728
729	729	return a;
730	730	}

trunk/src/mame/drivers/pasha2.c

r17814	r17815
477	477	{
478	478
479	479	if(space.device().safe_pc() == 0x8302)
480		device_spin_until_interrupt(&space.device());
	480	space.device().execute().spin_until_interrupt();
481	481
482	482	return m_wram[(0x95744 / 2) + offset];
483	483	}

trunk/src/mame/drivers/bublbobl.c

r17814	r17815
699	699	static void irqhandler(device_t *device, int irq)
700	700	{
701	701	bublbobl_state *state = device->machine().driver_data<bublbobl_state>();
702		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	702	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
703	703	}
704	704
705	705	static const ym2203_interface ym2203_config =
r17814	r17815
724	724	{
725	725	bublbobl_state *state = machine.driver_data<bublbobl_state>();
726	726
727		state->m_maincpu = machine.device("maincpu");
	727	state->m_maincpu = machine.device<cpu_device>("maincpu");
728	728	state->m_mcu = machine.device("mcu");
729		state->m_audiocpu = machine.device("audiocpu");
	729	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
730	730	state->m_slave = machine.device("slave");
731	731
732	732	state->save_item(NAME(state->m_sound_nmi_enable));

trunk/src/mame/drivers/skyfox.c

r17814	r17815
84	84
85	85	INPUT_CHANGED_MEMBER(skyfox_state::coin_inserted)
86	86	{
87		device_set_input_line(m_maincpu, INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
	87	m_maincpu->set_input_line(INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
88	88	}
89	89
90	90	static INPUT_PORTS_START( skyfox )
r17814	r17815
223	223	{
224	224	skyfox_state *state = machine.driver_data<skyfox_state>();
225	225
226		state->m_maincpu = machine.device("maincpu");
	226	state->m_maincpu = machine.device<cpu_device>("maincpu");
227	227
228	228	state->save_item(NAME(state->m_bg_pos));
229	229	state->save_item(NAME(state->m_bg_ctrl));

trunk/src/mame/drivers/fgoal.c

r17814	r17815
75	75	int scanline;
76	76	int coin = (state->ioport("IN1")->read() & 2);
77	77
78		device_set_input_line(state->m_maincpu, 0, ASSERT_LINE);
	78	state->m_maincpu->set_input_line(0, ASSERT_LINE);
79	79
80	80	if (!coin && state->m_prev_coin)
81		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, ASSERT_LINE);
	81	state->m_maincpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
82	82
83	83	state->m_prev_coin = coin;
84	84
r17814	r17815
113	113
114	114	READ8_MEMBER(fgoal_state::fgoal_nmi_reset_r)
115	115	{
116		device_set_input_line(m_maincpu, INPUT_LINE_NMI, CLEAR_LINE);
	116	m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
117	117
118	118	return 0;
119	119	}
r17814	r17815
121	121
122	122	READ8_MEMBER(fgoal_state::fgoal_irq_reset_r)
123	123	{
124		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	124	m_maincpu->set_input_line(0, CLEAR_LINE);
125	125
126	126	return 0;
127	127	}
r17814	r17815
332	332	{
333	333	fgoal_state *state = machine.driver_data<fgoal_state>();
334	334
335		state->m_maincpu = machine.device("maincpu");
	335	state->m_maincpu = machine.device<cpu_device>("maincpu");
336	336	state->m_mb14241 = machine.device("mb14241");
337	337
338	338	state->save_item(NAME(state->m_xpos));

trunk/src/mame/drivers/magicard.c

r17814	r17815
709	709	static INTERRUPT_GEN( magicard_irq )
710	710	{
711	711	if(device->machine().input().code_pressed(KEYCODE_Z)) //vblank?
712		device_set_input_line_and_vector(device, 1, HOLD_LINE,0xe4/4);
	712	device->execute().set_input_line_and_vector(1, HOLD_LINE,0xe4/4);
713	713	if(device->machine().input().code_pressed(KEYCODE_X)) //uart irq
714		device_set_input_line_and_vector(device, 1, HOLD_LINE,0xf0/4);
	714	device->execute().set_input_line_and_vector(1, HOLD_LINE,0xf0/4);
715	715	}
716	716
717	717	static MACHINE_CONFIG_START( magicard, magicard_state )

trunk/src/mame/drivers/yiear.c

r17814	r17815
126	126	yiear_state *state = device->machine().driver_data<yiear_state>();
127	127
128	128	if (state->m_yiear_irq_enable)
129		device_set_input_line(device, 0, HOLD_LINE);
	129	device->execute().set_input_line(0, HOLD_LINE);
130	130	}
131	131
132	132
r17814	r17815
135	135	yiear_state *state = device->machine().driver_data<yiear_state>();
136	136
137	137	if (state->m_yiear_nmi_enable)
138		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	138	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
139	139	}
140	140
141	141

trunk/src/mame/drivers/snowbros.c

r17814	r17815
126	126	int scanline = param;
127	127
128	128	if(scanline == 240)
129		device_set_input_line(state->m_maincpu, 2, ASSERT_LINE);
	129	state->m_maincpu->set_input_line(2, ASSERT_LINE);
130	130
131	131	if(scanline == 128)
132		device_set_input_line(state->m_maincpu, 3, ASSERT_LINE);
	132	state->m_maincpu->set_input_line(3, ASSERT_LINE);
133	133
134	134	if(scanline == 32)
135		device_set_input_line(state->m_maincpu, 4, ASSERT_LINE);
	135	state->m_maincpu->set_input_line(4, ASSERT_LINE);
136	136	}
137	137
138	138	static TIMER_DEVICE_CALLBACK( snowbros3_irq )
r17814	r17815
143	143	int scanline = param;
144	144
145	145	if(scanline == 240)
146		device_set_input_line(state->m_maincpu, 2, ASSERT_LINE);
	146	state->m_maincpu->set_input_line(2, ASSERT_LINE);
147	147
148	148	if(scanline == 128)
149		device_set_input_line(state->m_maincpu, 3, ASSERT_LINE);
	149	state->m_maincpu->set_input_line(3, ASSERT_LINE);
150	150
151	151	if(scanline == 32)
152		device_set_input_line(state->m_maincpu, 4, ASSERT_LINE);
	152	state->m_maincpu->set_input_line(4, ASSERT_LINE);
153	153
154	154	if (state->m_sb3_music_is_playing)
155	155	{

trunk/src/mame/drivers/sonson.c

r17814	r17815
61	61	if (m_last_irq == 0 && data == 1)
62	62	{
63	63	/* setting bit 0 low then high triggers IRQ on the sound CPU */
64		device_set_input_line(m_audiocpu, M6809_FIRQ_LINE, HOLD_LINE);
	64	m_audiocpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
65	65	}
66	66
67	67	m_last_irq = data;
r17814	r17815
229	229	{
230	230	sonson_state *state = machine.driver_data<sonson_state>();
231	231
232		state->m_audiocpu = machine.device("audiocpu");
	232	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
233	233
234	234	state->save_item(NAME(state->m_last_irq));
235	235	}

trunk/src/mame/drivers/hcastle.c

r17814	r17815
24	24
25	25	WRITE8_MEMBER(hcastle_state::hcastle_soundirq_w)
26	26	{
27		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	27	m_audiocpu->set_input_line(0, HOLD_LINE);
28	28	}
29	29
30	30	WRITE8_MEMBER(hcastle_state::hcastle_coin_w)
r17814	r17815
184	184
185	185	state->membank("bank1")->configure_entries(0, 16, &ROM[0x10000], 0x2000);
186	186
187		state->m_audiocpu = machine.device("audiocpu");
	187	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
188	188	state->m_k007121_1 = machine.device("k007121_1");
189	189	state->m_k007121_2 = machine.device("k007121_2");
190	190

trunk/src/mame/drivers/cntsteer.c

r17814	r17815
63	63	int      m_nmimask;   // zerotrgt only
64	64
65	65	/* devices */
66		device_t *m_maincpu;
67		device_t *m_audiocpu;
68		device_t *m_subcpu;
	66	cpu_device *m_maincpu;
	67	cpu_device *m_audiocpu;
	68	cpu_device *m_subcpu;
69	69	DECLARE_WRITE8_MEMBER(zerotrgt_vregs_w);
70	70	DECLARE_WRITE8_MEMBER(cntsteer_vregs_w);
71	71	DECLARE_WRITE8_MEMBER(cntsteer_foreground_vram_w);
r17814	r17815
460	460
461	461	WRITE8_MEMBER(cntsteer_state::gekitsui_sub_irq_ack)
462	462	{
463		device_set_input_line(m_subcpu, M6809_IRQ_LINE, CLEAR_LINE);
	463	m_subcpu->set_input_line(M6809_IRQ_LINE, CLEAR_LINE);
464	464	}
465	465
466	466	WRITE8_MEMBER(cntsteer_state::cntsteer_sound_w)
467	467	{
468	468	soundlatch_byte_w(space, 0, data);
469		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	469	m_audiocpu->set_input_line(0, HOLD_LINE);
470	470	}
471	471
472	472	WRITE8_MEMBER(cntsteer_state::zerotrgt_ctrl_w)
473	473	{
474	474	/*TODO: check this.*/
475	475	logerror("CTRL: %04x: %04x: %04x\n", space.device().safe_pc(), offset, data);
476		//  if (offset == 0) device_set_input_line(m_subcpu, INPUT_LINE_RESET, ASSERT_LINE);
	476	//  if (offset == 0) m_subcpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
477	477
478	478	// Wrong - bits 0 & 1 used on this
479		if (offset == 1) device_set_input_line(m_subcpu, M6809_IRQ_LINE, ASSERT_LINE);
480		//  if (offset == 2) device_set_input_line(m_subcpu, INPUT_LINE_RESET, CLEAR_LINE);
	479	if (offset == 1) m_subcpu->set_input_line(M6809_IRQ_LINE, ASSERT_LINE);
	480	//  if (offset == 2) m_subcpu->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
481	481	}
482	482
483	483	WRITE8_MEMBER(cntsteer_state::cntsteer_sub_irq_w)
484	484	{
485		device_set_input_line(m_subcpu, M6809_IRQ_LINE, ASSERT_LINE);
	485	m_subcpu->set_input_line(M6809_IRQ_LINE, ASSERT_LINE);
486	486	//  printf("%02x IRQ\n", data);
487	487	}
488	488
489	489	WRITE8_MEMBER(cntsteer_state::cntsteer_sub_nmi_w)
490	490	{
491	491	//  if (data)
492		//  device_set_input_line(m_subcpu, INPUT_LINE_NMI, PULSE_LINE);
	492	//  m_subcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
493	493	//  popmessage("%02x", data);
494	494	}
495	495
496	496	WRITE8_MEMBER(cntsteer_state::cntsteer_main_irq_w)
497	497	{
498		device_set_input_line(m_maincpu, M6809_IRQ_LINE, HOLD_LINE);
	498	m_maincpu->set_input_line(M6809_IRQ_LINE, HOLD_LINE);
499	499	}
500	500
501	501	/* Convert weird input handling with MAME standards.*/
r17814	r17815
594	594	{
595	595	cntsteer_state *state = device->machine().driver_data<cntsteer_state>();
596	596	if (!state->m_nmimask)
597		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	597	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
598	598	}
599	599
600	600	static ADDRESS_MAP_START( sound_map, AS_PROGRAM, 8, cntsteer_state )
r17814	r17815
681	681
682	682	INPUT_CHANGED_MEMBER(cntsteer_state::coin_inserted)
683	683	{
684		device_set_input_line(m_subcpu, INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
	684	m_subcpu->set_input_line(INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
685	685	}
686	686
687	687	static INPUT_PORTS_START( cntsteer )
r17814	r17815
815	815	{
816	816	cntsteer_state *state = machine.driver_data<cntsteer_state>();
817	817
818		state->m_maincpu = machine.device("maincpu");
819		state->m_audiocpu = machine.device("audiocpu");
820		state->m_subcpu = machine.device("subcpu");
	818	state->m_maincpu = machine.device<cpu_device>("maincpu");
	819	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
	820	state->m_subcpu = machine.device<cpu_device>("subcpu");
821	821
822	822	state->save_item(NAME(state->m_flipscreen));
823	823	state->save_item(NAME(state->m_bg_bank));

trunk/src/mame/drivers/csplayh5.c

r17814	r17815
602	602	int scanline = param;
603	603
604	604	if(scanline == 212*2)
605		device_set_input_line_and_vector(state->m_maincpu, 1, HOLD_LINE,0x100/4);
	605	state->m_maincpu->set_input_line_and_vector(1, HOLD_LINE,0x100/4);
606	606
607	607	if((scanline % 2) == 0)
608	608	{

trunk/src/mame/drivers/bking.c

r17814	r17815
44	44
45	45	soundlatch_byte_w(space, offset, code);
46	46	if (m_sound_nmi_enable)
47		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	47	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
48	48	}
49	49
50	50	WRITE8_MEMBER(bking_state::bking3_addr_l_w)
r17814	r17815
392	392	{
393	393	bking_state *state = machine.driver_data<bking_state>();
394	394
395		state->m_audiocpu = machine.device("audiocpu");
	395	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
396	396
397	397	/* video */
398	398	state->save_item(NAME(state->m_pc3259_output));

trunk/src/mame/drivers/dblewing.c

r17814	r17815
74	74	UINT8 m_sound_irq;
75	75
76	76	/* devices */
77		device_t *m_maincpu;
78		device_t *m_audiocpu;
	77	cpu_device *m_maincpu;
	78	cpu_device *m_audiocpu;
79	79	device_t *m_deco_tilegen1;
80	80	DECLARE_READ16_MEMBER(dblewing_prot_r);
81	81	DECLARE_WRITE16_MEMBER(dblewing_prot_w);
r17814	r17815
245	245	case 0x380: // sound write
246	246	soundlatch_byte_w(space, 0, data & 0xff);
247	247	m_sound_irq |= 0x02;
248		device_set_input_line(m_audiocpu, 0, (m_sound_irq != 0) ? ASSERT_LINE : CLEAR_LINE);
	248	m_audiocpu->set_input_line(0, (m_sound_irq != 0) ? ASSERT_LINE : CLEAR_LINE);
249	249	return;
250	250	case 0x384:
251	251	m_384_data = data;
r17814	r17815
341	341
342	342	/* bit 1 of dblewing_sound_irq specifies IRQ command writes */
343	343	m_sound_irq &= ~0x02;
344		device_set_input_line(m_audiocpu, 0, (m_sound_irq != 0) ? ASSERT_LINE : CLEAR_LINE);
	344	m_audiocpu->set_input_line(0, (m_sound_irq != 0) ? ASSERT_LINE : CLEAR_LINE);
345	345	return m_sound_irq;
346	346	}
347	347
r17814	r17815
536	536	driver_state->m_sound_irq |= 0x01;
537	537	else
538	538	driver_state->m_sound_irq &= ~0x01;
539		device_set_input_line(driver_state->m_audiocpu, 0, (driver_state->m_sound_irq != 0) ? ASSERT_LINE : CLEAR_LINE);
	539	driver_state->m_audiocpu->set_input_line(0, (driver_state->m_sound_irq != 0) ? ASSERT_LINE : CLEAR_LINE);
540	540	}
541	541
542	542	static const ym2151_interface ym2151_config =
r17814	r17815
565	565	{
566	566	dblewing_state *state = machine.driver_data<dblewing_state>();
567	567
568		state->m_maincpu = machine.device("maincpu");
569		state->m_audiocpu = machine.device("audiocpu");
	568	state->m_maincpu = machine.device<cpu_device>("maincpu");
	569	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
570	570	state->m_deco_tilegen1 = machine.device("tilegen1");
571	571
572	572	state->save_item(NAME(state->m_008_data));

trunk/src/mame/drivers/labyrunr.c

r17814	r17815
20	20	{
21	21	labyrunr_state *state = device->machine().driver_data<labyrunr_state>();
22	22	if (k007121_ctrlram_r(state->m_k007121, 7) & 0x02)
23		device_set_input_line(device, HD6309_IRQ_LINE, HOLD_LINE);
	23	device->execute().set_input_line(HD6309_IRQ_LINE, HOLD_LINE);
24	24	}
25	25
26	26	static INTERRUPT_GEN( labyrunr_timer_interrupt )
27	27	{
28	28	labyrunr_state *state = device->machine().driver_data<labyrunr_state>();
29	29	if (k007121_ctrlram_r(state->m_k007121, 7) & 0x01)
30		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	30	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
31	31	}
32	32
33	33

trunk/src/mame/drivers/taito_o.c

r17814	r17815
218	218	int scanline = param;
219	219
220	220	if(scanline == 448)
221		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	221	state->m_maincpu->set_input_line(4, HOLD_LINE);
222	222
223	223	if(scanline == 0)
224		device_set_input_line(state->m_maincpu, 5, HOLD_LINE);
	224	state->m_maincpu->set_input_line(5, HOLD_LINE);
225	225	}
226	226
227	227	static const ym2203_interface ym2203_config =
r17814	r17815
246	246	{
247	247	taitoo_state *state = machine.driver_data<taitoo_state>();
248	248
249		state->m_maincpu = machine.device("maincpu");
	249	state->m_maincpu = machine.device<cpu_device>("maincpu");
250	250	state->m_tc0080vco = machine.device("tc0080vco");
251	251	}
252	252

trunk/src/mame/drivers/thief.c

r17814	r17815
37	37	{
38	38	/* SLAM switch causes an NMI if it's pressed */
39	39	if( (device->machine().root_device().ioport("P2")->read() & 0x10) == 0 )
40		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	40	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
41	41	else
42		device_set_input_line(device, 0, HOLD_LINE);
	42	device->execute().set_input_line(0, HOLD_LINE);
43	43	}
44	44
45	45	/**********************************************************/

trunk/src/mame/drivers/pipedrm.c

r17814	r17815
219	219	/* sound commands. It's possible the NMI isn't really hooked up on the YM2608 */
220	220	/* sound board. */
221	221	if (param & 0x100)
222		device_set_input_line(state->m_subcpu, INPUT_LINE_NMI, ASSERT_LINE);
	222	state->m_subcpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
223	223	}
224	224
225	225
r17814	r17815
239	239	{
240	240	fromance_state *state = space->machine().driver_data<fromance_state>();
241	241	state->m_pending_command = 0;
242		device_set_input_line(state->m_subcpu, INPUT_LINE_NMI, CLEAR_LINE);
	242	state->m_subcpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
243	243	}
244	244
245	245
r17814	r17815
560	560	static void irqhandler( device_t *device, int irq )
561	561	{
562	562	fromance_state *state = device->machine().driver_data<fromance_state>();
563		device_set_input_line(state->m_subcpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	563	state->m_subcpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
564	564	}
565	565
566	566
r17814	r17815
592	592	{
593	593	fromance_state *state = machine.driver_data<fromance_state>();
594	594
595		state->m_subcpu = machine.device("sub");
	595	state->m_subcpu = machine.device<cpu_device>("sub");
596	596
597	597	/* initialize main Z80 bank */
598	598	state->membank("bank1")->configure_entries(0, 8, state->memregion("maincpu")->base() + 0x10000, 0x2000);

trunk/src/mame/drivers/ddragon3.c

r17814	r17815
174	174
175	175	case 1: /* soundlatch_byte_w */
176	176	soundlatch_byte_w(space, 1, m_io_reg[1] & 0xff);
177		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE );
	177	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE );
178	178	break;
179	179
180	180	case 2:
181	181	/*  this gets written to on startup and at the end of IRQ6
182	182	**  possibly trigger IRQ on sound CPU
183	183	*/
184		device_set_input_line(m_maincpu, 6, CLEAR_LINE);
	184	m_maincpu->set_input_line(6, CLEAR_LINE);
185	185	break;
186	186
187	187	case 3:
188	188	/*  this gets written to on startup,
189	189	**  and at the end of IRQ5 (input port read) */
190		device_set_input_line(m_maincpu, 5, CLEAR_LINE);
	190	m_maincpu->set_input_line(5, CLEAR_LINE);
191	191	break;
192	192
193	193	case 4:
194	194	/* this gets written to at the end of IRQ6 only */
195		device_set_input_line(m_maincpu, 6, CLEAR_LINE);
	195	m_maincpu->set_input_line(6, CLEAR_LINE);
196	196	break;
197	197
198	198	default:
r17814	r17815
517	517	static void dd3_ymirq_handler(device_t *device, int irq)
518	518	{
519	519	ddragon3_state *state = device->machine().driver_data<ddragon3_state>();
520		device_set_input_line(state->m_audiocpu, 0 , irq ? ASSERT_LINE : CLEAR_LINE );
	520	state->m_audiocpu->set_input_line(0 , irq ? ASSERT_LINE : CLEAR_LINE );
521	521	}
522	522
523	523	static const ym2151_interface ym2151_config =
r17814	r17815
541	541	{
542	542	if (scanline > 0)
543	543	timer.machine().primary_screen->update_partial(scanline - 1);
544		device_set_input_line(state->m_maincpu, 5, ASSERT_LINE);
	544	state->m_maincpu->set_input_line(5, ASSERT_LINE);
545	545	}
546	546
547	547	/* Vblank is raised on scanline 248 */
548	548	if (scanline == 248)
549	549	{
550	550	timer.machine().primary_screen->update_partial(scanline - 1);
551		device_set_input_line(state->m_maincpu, 6, ASSERT_LINE);
	551	state->m_maincpu->set_input_line(6, ASSERT_LINE);
552	552	}
553	553	}
554	554
r17814	r17815
562	562	{
563	563	ddragon3_state *state = machine.driver_data<ddragon3_state>();
564	564
565		state->m_maincpu = machine.device("maincpu");
566		state->m_audiocpu = machine.device("audiocpu");
	565	state->m_maincpu = machine.device<cpu_device>("maincpu");
	566	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
567	567
568	568	state->save_item(NAME(state->m_vreg));
569	569	state->save_item(NAME(state->m_bg_scrollx));

trunk/src/mame/drivers/ccastles.c

r17814	r17815
159	159	/* assert the IRQ if not already asserted */
160	160	if (!state->m_irq_state)
161	161	{
162		device_set_input_line(state->m_maincpu, 0, ASSERT_LINE);
	162	state->m_maincpu->set_input_line(0, ASSERT_LINE);
163	163	state->m_irq_state = 1;
164	164	}
165	165
r17814	r17815
245	245	{
246	246	if (m_irq_state)
247	247	{
248		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	248	m_maincpu->set_input_line(0, CLEAR_LINE);
249	249	m_irq_state = 0;
250	250	}
251	251	}

trunk/src/mame/drivers/discoboy.c

r17814	r17815
60	60	UINT8    m_toggle;
61	61
62	62	/* devices */
63		device_t *m_audiocpu;
	63	cpu_device *m_audiocpu;
64	64
65	65	/* memory */
66	66	UINT8    m_ram_1[0x800];
r17814	r17815
233	233	WRITE8_MEMBER(discoboy_state::discoboy_port_03_w)// sfx? (to sound cpu)
234	234	{
235	235	//  printf("unk discoboy_port_03_w %02x\n", data);
236		//  device_set_input_line(m_audiocpu, INPUT_LINE_NMI, HOLD_LINE);
	236	//  m_audiocpu->set_input_line(INPUT_LINE_NMI, HOLD_LINE);
237	237	soundlatch_byte_w(space, 0, data);
238		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	238	m_audiocpu->set_input_line(0, HOLD_LINE);
239	239	}
240	240
241	241	WRITE8_MEMBER(discoboy_state::discoboy_port_06_w)
r17814	r17815
455	455	{
456	456	discoboy_state *state = machine.driver_data<discoboy_state>();
457	457
458		state->m_audiocpu = machine.device("audiocpu");
	458	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
459	459
460	460	state->save_item(NAME(state->m_ram_bank));
461	461	state->save_item(NAME(state->m_port_00));

trunk/src/mame/drivers/mediagx.c

r17814	r17815
405	405
406	406	#if SPEEDUP_HACKS
407	407	// wait for vblank speedup
408		device_spin_until_interrupt(&space.device());
	408	space.device().execute().spin_until_interrupt();
409	409	#endif
410	410	break;
411	411	}
r17814	r17815
1069	1069	mediagx_state *state = machine.driver_data<mediagx_state>();
1070	1070	UINT8 *rom = state->memregion("bios")->base();
1071	1071
1072		device_set_irq_callback(machine.device("maincpu"), irq_callback);
	1072	machine.device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
1073	1073
1074	1074	memcpy(state->m_bios_ram, rom, 0x40000);
1075	1075	machine.device("maincpu")->reset();
r17814	r17815
1269	1269	if (space->device().safe_pc() == state->m_speedup_table[idx].pc)
1270	1270	{
1271	1271	state->m_speedup_hits[idx]++;
1272		device_spin_until_interrupt(&space->device());
	1272	space->device().execute().spin_until_interrupt();
1273	1273	}
1274	1274	return state->m_main_ram[state->m_speedup_table[idx].offset/4];
1275	1275	}

trunk/src/mame/drivers/orbit.c

r17814	r17815
36	36	orbit_state *state = timer.machine().driver_data<orbit_state>();
37	37	int scanline = param;
38	38	int nmistate = (scanline & 32) && (state->m_misc_flags & 4);
39		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, nmistate ? ASSERT_LINE : CLEAR_LINE);
	39	state->m_maincpu->set_input_line(INPUT_LINE_NMI, nmistate ? ASSERT_LINE : CLEAR_LINE);
40	40	}
41	41
42	42
43	43	static TIMER_CALLBACK( irq_off )
44	44	{
45	45	orbit_state *state = machine.driver_data<orbit_state>();
46		device_set_input_line(state->m_maincpu, 0, CLEAR_LINE);
	46	state->m_maincpu->set_input_line(0, CLEAR_LINE);
47	47	}
48	48
49	49
50	50	static INTERRUPT_GEN( orbit_interrupt )
51	51	{
52		device_set_input_line(device, 0, ASSERT_LINE);
	52	device->execute().set_input_line(0, ASSERT_LINE);
53	53	device->machine().scheduler().timer_set(device->machine().primary_screen->time_until_vblank_end(), FUNC(irq_off));
54	54	}
55	55
r17814	r17815
275	275	{
276	276	orbit_state *state = machine.driver_data<orbit_state>();
277	277
278		state->m_maincpu = machine.device("maincpu");
	278	state->m_maincpu = machine.device<cpu_device>("maincpu");
279	279	state->m_discrete = machine.device("discrete");
280	280
281	281	state->save_item(NAME(state->m_misc_flags));

trunk/src/mame/drivers/policetr.c

r17814	r17815
109	109
110	110	static INTERRUPT_GEN( irq4_gen )
111	111	{
112		device_set_input_line(device, R3000_IRQ4, ASSERT_LINE);
	112	device->execute().set_input_line(R3000_IRQ4, ASSERT_LINE);
113	113	device->machine().scheduler().timer_set(device->machine().primary_screen->time_until_pos(0), FUNC(irq5_gen));
114	114	}
115	115
r17814	r17815
214	214
215	215	/* more than 2 in a row and we spin */
216	216	if (m_loop_count > 2)
217		device_spin_until_interrupt(&space.device());
	217	space.device().execute().spin_until_interrupt();
218	218	}
219	219	else
220	220	m_loop_count = 0;

trunk/src/mame/drivers/skimaxx.c

r17814	r17815
292	292	{
293	293	device_t *subcpu = machine().device("subcpu");
294	294
295		device_set_input_line(subcpu, INPUT_LINE_RESET, (data & 0x01) ? CLEAR_LINE : ASSERT_LINE);
296		device_set_input_line(subcpu, INPUT_LINE_HALT,  (data & 0x40) ? CLEAR_LINE : ASSERT_LINE);
	295	subcpu->execute().set_input_line(INPUT_LINE_RESET, (data & 0x01) ? CLEAR_LINE : ASSERT_LINE);
	296	subcpu->execute().set_input_line(INPUT_LINE_HALT,  (data & 0x40) ? CLEAR_LINE : ASSERT_LINE);
297	297	}
298	298	}
299	299

trunk/src/mame/drivers/coinmvga.c

r17814	r17815
657	657	static INTERRUPT_GEN( vblank_irq )
658	658	{
659	659	//printf("1\n");
660		device_set_input_line(device, 2, HOLD_LINE);
	660	device->execute().set_input_line(2, HOLD_LINE);
661	661	}
662	662
663	663

trunk/src/mame/drivers/cultures.c

r17814	r17815
364	364	{
365	365	cultures_state *state = device->machine().driver_data<cultures_state>();
366	366	if (state->m_irq_enable)
367		device_set_input_line(device, 0, HOLD_LINE);
	367	device->execute().set_input_line(0, HOLD_LINE);
368	368	}
369	369
370	370	static MACHINE_START( cultures )

trunk/src/mame/drivers/seta2.c

r17814	r17815
2168	2168	int scanline = param;
2169	2169
2170	2170	if(scanline == 368)
2171		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	2171	state->m_maincpu->set_input_line(1, HOLD_LINE);
2172	2172
2173	2173	if(scanline == 0)
2174		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	2174	state->m_maincpu->set_input_line(2, HOLD_LINE);
2175	2175	}
2176	2176
2177	2177	static INTERRUPT_GEN( funcube_sub_timer_irq )
r17814	r17815
2180	2180
2181	2181	if ( state->m_funcube_serial_count )
2182	2182	{
2183		device_set_input_line(device, H8_SCI_1_RX, HOLD_LINE);
	2183	device->execute().set_input_line(H8_SCI_1_RX, HOLD_LINE);
2184	2184	}
2185	2185	else
2186	2186	{
r17814	r17815
2199	2199	state->m_funcube_press = press;
2200	2200	}
2201	2201
2202		device_set_input_line(device, H8_METRO_TIMER_HACK, HOLD_LINE);
	2202	device->execute().set_input_line(H8_METRO_TIMER_HACK, HOLD_LINE);
2203	2203	}
2204	2204
2205	2205	static MACHINE_RESET( funcube )

trunk/src/mame/drivers/flkatck.c

r17814	r17815
25	25	flkatck_state *state = device->machine().driver_data<flkatck_state>();
26	26
27	27	if (state->m_irq_enabled)
28		device_set_input_line(device, HD6309_IRQ_LINE, HOLD_LINE);
	28	device->execute().set_input_line(HD6309_IRQ_LINE, HOLD_LINE);
29	29	}
30	30
31	31	WRITE8_MEMBER(flkatck_state::flkatck_bankswitch_w)
r17814	r17815
72	72	soundlatch_byte_w(space, 0, data);
73	73	break;
74	74	case 0x06:   /* Cause interrupt on audio CPU */
75		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	75	m_audiocpu->set_input_line(0, HOLD_LINE);
76	76	break;
77	77	case 0x07:   /* watchdog reset */
78	78	watchdog_reset_w(space, 0, data);
r17814	r17815
199	199
200	200	state->membank("bank1")->configure_entries(0, 3, &ROM[0x10000], 0x2000);
201	201
202		state->m_audiocpu = machine.device("audiocpu");
	202	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
203	203	state->m_k007121 = machine.device("k007121");
204	204
205	205	state->save_item(NAME(state->m_irq_enabled));

trunk/src/mame/drivers/sfcbox.c

r17814	r17815
237	237
238	238	WRITE8_MEMBER( sfcbox_state::port_81_w )
239	239	{
240		device_set_input_line(m_maincpu, INPUT_LINE_RESET, (data & 1) ? CLEAR_LINE : ASSERT_LINE);
241		device_set_input_line(m_soundcpu, INPUT_LINE_RESET, (data & 1) ? CLEAR_LINE : ASSERT_LINE);
	240	m_maincpu->set_input_line(INPUT_LINE_RESET, (data & 1) ? CLEAR_LINE : ASSERT_LINE);
	241	m_soundcpu->set_input_line(INPUT_LINE_RESET, (data & 1) ? CLEAR_LINE : ASSERT_LINE);
242	242
243	243	ioport("OSD_CS")->write(data, 0xff);
244	244	}
r17814	r17815
478	478	MACHINE_RESET_CALL( snes );
479	479
480	480	/* start with both CPUs disabled */
481		device_set_input_line(state->m_maincpu, INPUT_LINE_RESET, ASSERT_LINE);
482		device_set_input_line(state->m_soundcpu, INPUT_LINE_RESET, ASSERT_LINE);
	481	state->m_maincpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
	482	state->m_soundcpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
483	483	}
484	484
485	485	static MACHINE_CONFIG_DERIVED( sfcbox, snes )

trunk/src/mame/drivers/contra.c

r17814	r17815
29	29	{
30	30	contra_state *state = device->machine().driver_data<contra_state>();
31	31	if (k007121_ctrlram_r(state->m_k007121_1, 7) & 0x02)
32		device_set_input_line(device, HD6309_IRQ_LINE, HOLD_LINE);
	32	device->execute().set_input_line(HD6309_IRQ_LINE, HOLD_LINE);
33	33	}
34	34
35	35	WRITE8_MEMBER(contra_state::contra_bankswitch_w)
r17814	r17815
39	39
40	40	WRITE8_MEMBER(contra_state::contra_sh_irqtrigger_w)
41	41	{
42		device_set_input_line(m_audiocpu, M6809_IRQ_LINE, HOLD_LINE);
	42	m_audiocpu->set_input_line(M6809_IRQ_LINE, HOLD_LINE);
43	43	}
44	44
45	45	WRITE8_MEMBER(contra_state::contra_coin_counter_w)
r17814	r17815
182	182
183	183	state->membank("bank1")->configure_entries(0, 16, &ROM[0x10000], 0x2000);
184	184
185		state->m_audiocpu = machine.device("audiocpu");
	185	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
186	186	state->m_k007121_1 = machine.device("k007121_1");
187	187	state->m_k007121_2 = machine.device("k007121_2");
188	188	}

trunk/src/mame/drivers/zn.c

r17814	r17815
710	710
711	711	static INTERRUPT_GEN( qsound_interrupt )
712	712	{
713		device_set_input_line(device, 0, HOLD_LINE);
	713	device->execute().set_input_line(0, HOLD_LINE);
714	714	}
715	715
716	716	WRITE32_MEMBER(zn_state::zn_qsound_w)

trunk/src/mame/drivers/galpani3.c

r17814	r17815
128	128	int scanline = param;
129	129
130	130	if(scanline == 240)
131		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	131	state->m_maincpu->set_input_line(2, HOLD_LINE);
132	132
133	133	if(scanline == 0)
134		device_set_input_line(state->m_maincpu, 3, HOLD_LINE);
	134	state->m_maincpu->set_input_line(3, HOLD_LINE);
135	135
136	136	if(scanline == 128)
137		device_set_input_line(state->m_maincpu, 5, HOLD_LINE); // timer, related to sound chip?
	137	state->m_maincpu->set_input_line(5, HOLD_LINE); // timer, related to sound chip?
138	138	}
139	139
140	140

trunk/src/mame/drivers/fitfight.c

r17814	r17815
259	259
260	260	static INTERRUPT_GEN( snd_irq )
261	261	{
262		device_set_input_line(device, UPD7810_INTF2, HOLD_LINE);
	262	device->execute().set_input_line(UPD7810_INTF2, HOLD_LINE);
263	263	}
264	264
265	265	static const UPD7810_CONFIG sound_cpu_config =

trunk/src/mame/drivers/ddribble.c

r17814	r17815
22	22	{
23	23	ddribble_state *state = device->machine().driver_data<ddribble_state>();
24	24	if (state->m_int_enable_0)
25		device_set_input_line(device, M6809_FIRQ_LINE, HOLD_LINE);
	25	device->execute().set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
26	26	}
27	27
28	28	static INTERRUPT_GEN( ddribble_interrupt_1 )
29	29	{
30	30	ddribble_state *state = device->machine().driver_data<ddribble_state>();
31	31	if (state->m_int_enable_1)
32		device_set_input_line(device, M6809_FIRQ_LINE, HOLD_LINE);
	32	device->execute().set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
33	33	}
34	34
35	35

trunk/src/mame/drivers/deco32.c

r17814	r17815
1673	1673
1674	1674	static INTERRUPT_GEN( deco32_vbl_interrupt )
1675	1675	{
1676		device_set_input_line(device, ARM_IRQ_LINE, HOLD_LINE);
	1676	device->execute().set_input_line(ARM_IRQ_LINE, HOLD_LINE);
1677	1677	}
1678	1678
1679	1679	UINT16 captaven_pri_callback(UINT16 x)
r17814	r17815
2000	2000	if(scanline == 31*8)
2001	2001	{
2002	2002	state->m_irq_source = 0;
2003		device_set_input_line(state->m_maincpu, ARM_IRQ_LINE, HOLD_LINE);
	2003	state->m_maincpu->set_input_line(ARM_IRQ_LINE, HOLD_LINE);
2004	2004	}
2005	2005
2006	2006	if(scanline == 0)
2007	2007	{
2008	2008	state->m_irq_source = 1;
2009		device_set_input_line(state->m_maincpu, ARM_IRQ_LINE, HOLD_LINE);
	2009	state->m_maincpu->set_input_line(ARM_IRQ_LINE, HOLD_LINE);
2010	2010	}
2011	2011	}
2012	2012

trunk/src/mame/drivers/midzeus.c

r17814	r17815
117	117
118	118	static INTERRUPT_GEN( display_irq )
119	119	{
120		device_set_input_line(device, 0, ASSERT_LINE);
	120	device->execute().set_input_line(0, ASSERT_LINE);
121	121	device->machine().scheduler().timer_set(attotime::from_hz(30000000), FUNC(display_irq_off));
122	122	}
123	123

trunk/src/mame/drivers/superdq.c

r17814	r17815
142	142	toggles (680usec after the vblank). We could set up a
143	143	timer to do that, but this works as well */
144	144	state->m_laserdisc->data_w(state->m_ld_out_latch);
145		device_set_input_line(device, 0, ASSERT_LINE);
	145	device->execute().set_input_line(0, ASSERT_LINE);
146	146	}
147	147
148	148	WRITE8_MEMBER(superdq_state::superdq_videoram_w)

trunk/src/mame/drivers/zaxxon.c

r17814	r17815
302	302	zaxxon_state *state = device->machine().driver_data<zaxxon_state>();
303	303
304	304	if (state->m_int_enabled)
305		device_set_input_line(device, 0, ASSERT_LINE);
	305	device->execute().set_input_line(0, ASSERT_LINE);
306	306	}
307	307
308	308

trunk/src/mame/drivers/tomcat.c

r17814	r17815
182	182	{
183	183	// 320 Reset Low         (Address Strobe)
184	184	// Reset TMS320
185		device_set_input_line(machine().device("dsp"), INPUT_LINE_RESET, ASSERT_LINE);
	185	machine().device("dsp")->execute().set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
186	186	}
187	187
188	188	WRITE16_MEMBER(tomcat_state::tomcat_mresh_w)
r17814	r17815
190	190	// 320 Reset high        (Address Strobe)
191	191	// Release reset of TMS320
192	192	m_dsp_BIO = 0;
193		device_set_input_line(machine().device("dsp"), INPUT_LINE_RESET, CLEAR_LINE);
	193	machine().device("dsp")->execute().set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
194	194	}
195	195
196	196	WRITE16_MEMBER(tomcat_state::tomcat_irqclr_w)

trunk/src/mame/drivers/fastfred.c

r17814	r17815
632	632	fastfred_state *state = device->machine().driver_data<fastfred_state>();
633	633
634	634	if(state->m_nmi_mask)
635		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	635	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
636	636	}
637	637
638	638	static INTERRUPT_GEN( sound_timer_irq )
r17814	r17815
640	640	fastfred_state *state = device->machine().driver_data<fastfred_state>();
641	641
642	642	if(state->m_sound_nmi_mask)
643		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	643	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
644	644	}
645	645
646	646	static MACHINE_CONFIG_START( fastfred, fastfred_state )

trunk/src/mame/drivers/karnov.c

r17814	r17815
126	126
127	127	//  if (!state->m_i8751_return && data != 0x300) logerror("%s - Unknown Write %02x intel\n", machine.describe_context(), data);
128	128
129		device_set_input_line(state->m_maincpu, 6, HOLD_LINE); /* Signal main cpu task is complete */
	129	state->m_maincpu->set_input_line(6, HOLD_LINE); /* Signal main cpu task is complete */
130	130	state->m_i8751_needs_ack = 1;
131	131	}
132	132
r17814	r17815
186	186	if (data == 0x501) state->m_i8751_return = 0x6bf8;
187	187	if (data == 0x500) state->m_i8751_return = 0x4e75;
188	188
189		device_set_input_line(state->m_maincpu, 6, HOLD_LINE); /* Signal main cpu task is complete */
	189	state->m_maincpu->set_input_line(6, HOLD_LINE); /* Signal main cpu task is complete */
190	190	state->m_i8751_needs_ack = 1;
191	191	}
192	192
r17814	r17815
318	318
319	319	//  logerror("%s - Unknown Write %02x intel\n", machine.describe_context(), data);
320	320
321		device_set_input_line(state->m_maincpu, 6, HOLD_LINE); /* Signal main cpu task is complete */
	321	state->m_maincpu->set_input_line(6, HOLD_LINE); /* Signal main cpu task is complete */
322	322	state->m_i8751_needs_ack = 1;
323	323	}
324	324
r17814	r17815
335	335	switch (offset << 1)
336	336	{
337	337	case 0: /* SECLR (Interrupt ack for Level 6 i8751 interrupt) */
338		device_set_input_line(m_maincpu, 6, CLEAR_LINE);
	338	m_maincpu->set_input_line(6, CLEAR_LINE);
339	339
340	340	if (m_i8751_needs_ack)
341	341	{
r17814	r17815
343	343	if (m_i8751_coin_pending)
344	344	{
345	345	m_i8751_return = m_i8751_coin_pending;
346		device_set_input_line(m_maincpu, 6, HOLD_LINE);
	346	m_maincpu->set_input_line(6, HOLD_LINE);
347	347	m_i8751_coin_pending = 0;
348	348	}
349	349	else if (m_i8751_command_queue)
r17814	r17815
362	362
363	363	case 2: /* SONREQ (Sound CPU byte) */
364	364	soundlatch_byte_w(space, 0, data & 0xff);
365		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	365	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
366	366	break;
367	367
368	368	case 4: /* DM (DMA to buffer spriteram) */
r17814	r17815
396	396	break;
397	397
398	398	case 0xe: /* INTCLR (Interrupt ack for Level 7 vbl interrupt) */
399		device_set_input_line(m_maincpu, 7, CLEAR_LINE);
	399	m_maincpu->set_input_line(7, CLEAR_LINE);
400	400	break;
401	401	}
402	402	}
r17814	r17815
744	744	else
745	745	{
746	746	state->m_i8751_return = port | 0x8000;
747		device_set_input_line(device, 6, HOLD_LINE);
	747	device->execute().set_input_line(6, HOLD_LINE);
748	748	state->m_i8751_needs_ack = 1;
749	749	}
750	750
751	751	state->m_latch = 0;
752	752	}
753	753
754		device_set_input_line(device, 7, HOLD_LINE);   /* VBL */
	754	device->execute().set_input_line(7, HOLD_LINE);   /* VBL */
755	755	}
756	756
757	757	static const ym3526_interface ym3526_config =
r17814	r17815
769	769	{
770	770	karnov_state *state = machine.driver_data<karnov_state>();
771	771
772		state->m_maincpu = machine.device("maincpu");
773		state->m_audiocpu = machine.device("audiocpu");
	772	state->m_maincpu = machine.device<cpu_device>("maincpu");
	773	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
774	774
775	775	state->save_item(NAME(state->m_flipscreen));
776	776	state->save_item(NAME(state->m_scroll));

trunk/src/mame/drivers/lwings.c

r17814	r17815
92	92	lwings_state *state = device->machine().driver_data<lwings_state>();
93	93
94	94	if(state->m_nmi_mask)
95		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0xd7); /* RST 10h */
	95	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0xd7); /* RST 10h */
96	96	}
97	97
98	98	static INTERRUPT_GEN( avengers_interrupt )
r17814	r17815
100	100	lwings_state *state = device->machine().driver_data<lwings_state>();
101	101
102	102	if(state->m_nmi_mask)
103		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	103	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
104	104	}
105	105
106	106

trunk/src/mame/drivers/punchout.c

r17814	r17815
934	934	punchout_state *state = device->machine().driver_data<punchout_state>();
935	935
936	936	if(state->m_nmi_mask)
937		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	937	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
938	938	}
939	939
940	940

trunk/src/mame/drivers/kopunch.c

r17814	r17815
10	10
11	11	static INTERRUPT_GEN( kopunch_interrupt )
12	12	{
13		device_set_input_line(device, I8085_RST75_LINE, ASSERT_LINE);
14		device_set_input_line(device, I8085_RST75_LINE, CLEAR_LINE);
	13	device->execute().set_input_line(I8085_RST75_LINE, ASSERT_LINE);
	14	device->execute().set_input_line(I8085_RST75_LINE, CLEAR_LINE);
15	15	}
16	16
17	17	READ8_MEMBER(kopunch_state::kopunch_in_r)
r17814	r17815
73	73
74	74	/* left coin insertion causes a rst6.5 (vector 0x34) */
75	75	if (newval)
76		device_set_input_line(m_maincpu, I8085_RST65_LINE, HOLD_LINE);
	76	m_maincpu->set_input_line(I8085_RST65_LINE, HOLD_LINE);
77	77	}
78	78
79	79	INPUT_CHANGED_MEMBER(kopunch_state::right_coin_inserted)
r17814	r17815
81	81
82	82	/* right coin insertion causes a rst5.5 (vector 0x2c) */
83	83	if (newval)
84		device_set_input_line(m_maincpu, I8085_RST55_LINE, HOLD_LINE);
	84	m_maincpu->set_input_line(I8085_RST55_LINE, HOLD_LINE);
85	85	}
86	86
87	87	static INPUT_PORTS_START( kopunch )
r17814	r17815
173	173	{
174	174	kopunch_state *state = machine.driver_data<kopunch_state>();
175	175
176		state->m_maincpu = machine.device("maincpu");
	176	state->m_maincpu = machine.device<cpu_device>("maincpu");
177	177
178	178	state->save_item(NAME(state->m_gfxbank));
179	179	}

trunk/src/mame/drivers/cclimber.c

r17814	r17815
979	979	cclimber_state *state = device->machine().driver_data<cclimber_state>();
980	980
981	981	if(state->m_nmi_mask)
982		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	982	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
983	983	}
984	984
985	985	static MACHINE_CONFIG_START( root, cclimber_state )

trunk/src/mame/drivers/cesclass.c

r17814	r17815
90	90
91	91	WRITE16_MEMBER( cesclassic_state::irq2_ack_w )
92	92	{
93		device_set_input_line(m_maincpu, 2, CLEAR_LINE);
	93	m_maincpu->set_input_line(2, CLEAR_LINE);
94	94	}
95	95
96	96	WRITE16_MEMBER( cesclassic_state::irq3_ack_w )
97	97	{
98		device_set_input_line(m_maincpu, 3, CLEAR_LINE);
	98	m_maincpu->set_input_line(3, CLEAR_LINE);
99	99	}
100	100
101	101	WRITE16_MEMBER( cesclassic_state::lamps_w )

trunk/src/mame/drivers/aliens.c

r17814	r17815
24	24	aliens_state *state = device->machine().driver_data<aliens_state>();
25	25
26	26	if (k051960_is_irq_enabled(state->m_k051960))
27		device_set_input_line(device, KONAMI_IRQ_LINE, HOLD_LINE);
	27	device->execute().set_input_line(KONAMI_IRQ_LINE, HOLD_LINE);
28	28	}
29	29
30	30	READ8_MEMBER(aliens_state::bankedram_r)
r17814	r17815
70	70	{
71	71
72	72	soundlatch_byte_w(space, offset, data);
73		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	73	m_audiocpu->set_input_line(0, HOLD_LINE);
74	74	}
75	75
76	76	WRITE8_MEMBER(aliens_state::aliens_snd_bankswitch_w)
r17814	r17815
234	234	state->membank("bank1")->configure_entries(0, 20, &ROM[0x10000], 0x2000);
235	235	state->membank("bank1")->set_entry(0);
236	236
237		state->m_maincpu = machine.device("maincpu");
238		state->m_audiocpu = machine.device("audiocpu");
	237	state->m_maincpu = machine.device<cpu_device>("maincpu");
	238	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
239	239	state->m_k007232 = machine.device("k007232");
240	240	state->m_k052109 = machine.device("k052109");
241	241	state->m_k051960 = machine.device("k051960");

trunk/src/mame/drivers/88games.c

r17814	r17815
70	70
71	71	WRITE8_MEMBER(_88games_state::k88games_sh_irqtrigger_w)
72	72	{
73		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	73	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
74	74	}
75	75
76	76
r17814	r17815
309	309	{
310	310	_88games_state *state = machine.driver_data<_88games_state>();
311	311
312		state->m_audiocpu = machine.device("audiocpu");
	312	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
313	313	state->m_k052109 = machine.device("k052109");
314	314	state->m_k051960 = machine.device("k051960");
315	315	state->m_k051316 = machine.device("k051316");

trunk/src/mame/drivers/beezer.c

r17814	r17815
81	81	{
82	82	beezer_state *state = machine.driver_data<beezer_state>();
83	83
84		state->m_maincpu = machine.device("maincpu");
	84	state->m_maincpu = machine.device<cpu_device>("maincpu");
85	85	}
86	86
87	87	static MACHINE_CONFIG_START( beezer, beezer_state )

trunk/src/mame/drivers/ddenlovr.c

r17814	r17815
830	830
831	831	if (irq_vector)
832	832	/* quizchq */
833		device_set_input_line_and_vector(&space->device(), 0, HOLD_LINE, irq_vector);
	833	space->device().execute().set_input_line_and_vector(0, HOLD_LINE, irq_vector);
834	834	else
835	835	{
836	836	/* ddenlovr */
837	837	if (state->m_ddenlovr_blitter_irq_enable)
838	838	{
839	839	state->m_ddenlovr_blitter_irq_flag = 1;
840		device_set_input_line(&space->device(), 1, HOLD_LINE);
	840	space->device().execute().set_input_line(1, HOLD_LINE);
841	841	}
842	842	}
843	843	break;
r17814	r17815
996	996	#endif
997	997	}
998	998
999		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, irq_vector);
	999	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, irq_vector);
1000	1000	break;
1001	1001
1002	1002	default:
r17814	r17815
2077	2077	WRITE8_MEMBER(dynax_state::mmpanic_soundlatch_w)
2078	2078	{
2079	2079	soundlatch_byte_w(space, 0, data);
2080		device_set_input_line(m_soundcpu, INPUT_LINE_NMI, PULSE_LINE);
	2080	m_soundcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
2081	2081	}
2082	2082
2083	2083	WRITE8_MEMBER(dynax_state::mmpanic_blitter_w)
r17814	r17815
8360	8360	{
8361	8361	dynax_state *state = machine.driver_data<dynax_state>();
8362	8362
8363		state->m_maincpu = machine.device("maincpu");
8364		state->m_soundcpu = machine.device("soundcpu");
	8363	state->m_maincpu = machine.device<cpu_device>("maincpu");
	8364	state->m_soundcpu = machine.device<cpu_device>("soundcpu");
8365	8365	state->m_oki = machine.device<okim6295_device>("oki");
8366	8366
8367	8367	state->save_item(NAME(state->m_input_sel));
r17814	r17815
8608	8608	//  if (downcast<cpu_device *>(state->m_maincpu)->input_state(0))
8609	8609	//      return;
8610	8610
8611		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0xee);
	8611	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xee);
8612	8612	}
8613	8613
8614	8614	static WRITE_LINE_DEVICE_HANDLER( quizchq_rtc_irq )
8615	8615	{
8616	8616	dynax_state *drvstate = device->machine().driver_data<dynax_state>();
8617	8617
8618		device_set_input_line_and_vector(drvstate->m_maincpu, 0, HOLD_LINE, 0xfc);
	8618	drvstate->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xfc);
8619	8619	}
8620	8620
8621	8621	static MSM6242_INTERFACE( quizchq_rtc_intf )
r17814	r17815
8692	8692	//if (downcast<cpu_device *>(state->m_maincpu)->input_state(0))
8693	8693	//  return;
8694	8694
8695		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0xcf); // RST 08, vblank
	8695	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xcf); // RST 08, vblank
8696	8696	}
8697	8697
8698	8698
r17814	r17815
8700	8700	{
8701	8701	dynax_state *drvstate = device->machine().driver_data<dynax_state>();
8702	8702
8703		device_set_input_line_and_vector(drvstate->m_maincpu, 0, HOLD_LINE, 0xdf); // RST 18, clock
	8703	drvstate->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xdf); // RST 18, clock
8704	8704	}
8705	8705
8706	8706	static MSM6242_INTERFACE( mmpanic_rtc_intf )
r17814	r17815
8777	8777	//if (downcast<cpu_device *>(state->m_maincpu)->input_state(0))
8778	8778	//  return;
8779	8779
8780		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0xe0);
	8780	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xe0);
8781	8781	}
8782	8782
8783	8783	static WRITE_LINE_DEVICE_HANDLER(hanakanz_rtc_irq)
r17814	r17815
8790	8790	//if (downcast<cpu_device *>(drvstate->m_maincpu)->input_state(0))
8791	8791	//  return;
8792	8792
8793		device_set_input_line_and_vector(drvstate->m_maincpu, 0, HOLD_LINE, 0xe2);
	8793	drvstate->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xe2);
8794	8794	}
8795	8795
8796	8796	static MSM6242_INTERFACE( hanakanz_rtc_intf )
r17814	r17815
8869	8869	//if (downcast<cpu_device *>(state->m_maincpu)->input_state(0))
8870	8870	//  return;
8871	8871
8872		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0xf8);
	8872	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xf8);
8873	8873	}
8874	8874
8875	8875	static WRITE_LINE_DEVICE_HANDLER(mjchuuka_rtc_irq)
r17814	r17815
8882	8882	//if (downcast<cpu_device *>(drvstate->m_maincpu)->input_state(0))
8883	8883	//  return;
8884	8884
8885		device_set_input_line_and_vector(drvstate->m_maincpu, 0, HOLD_LINE, 0xfa);
	8885	drvstate->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xfa);
8886	8886	}
8887	8887
8888	8888	static MSM6242_INTERFACE( mjchuuka_rtc_intf )
r17814	r17815
8953	8953	return;
8954	8954
8955	8955	if(scanline == 245)
8956		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0xf8);
	8956	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xf8);
8957	8957
8958	8958	if(scanline == 0)
8959		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0xfa);
	8959	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xfa);
8960	8960	}
8961	8961
8962	8962	static const ay8910_interface mjmyster_ay8910_interface =
r17814	r17815
8978	8978	//if (downcast<cpu_device *>(drvstate->m_maincpu)->input_state(0))
8979	8979	//  return;
8980	8980
8981		device_set_input_line(drvstate->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	8981	drvstate->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
8982	8982	}
8983	8983
8984	8984	static MSM6242_INTERFACE( mjmyster_rtc_intf )
r17814	r17815
9028	9028	//  if (downcast<cpu_device *>(state->m_maincpu)->input_state(0))
9029	9029	//      return;
9030	9030
9031		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0xf8);
	9031	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xf8);
9032	9032	}
9033	9033
9034	9034	static const ay8910_interface hginga_ay8910_interface =
r17814	r17815
9050	9050	//if (downcast<cpu_device *>(drvstate->m_maincpu)->input_state(0))
9051	9051	//  return;
9052	9052
9053		device_set_input_line_and_vector(drvstate->m_maincpu, 0, HOLD_LINE, 0xee);
	9053	drvstate->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xee);
9054	9054	}
9055	9055
9056	9056	static MSM6242_INTERFACE( hginga_rtc_intf )
r17814	r17815
9157	9157	dynax_state *state = device->machine().driver_data<dynax_state>();
9158	9158
9159	9159	state->m_mjflove_irq_cause = 1;
9160		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	9160	state->m_maincpu->set_input_line(0, HOLD_LINE);
9161	9161	}
9162	9162
9163	9163	static WRITE_LINE_DEVICE_HANDLER(mjflove_rtc_irq)
r17814	r17815
9165	9165	dynax_state *drvstate = device->machine().driver_data<dynax_state>();
9166	9166
9167	9167	drvstate->m_mjflove_irq_cause = 2;
9168		device_set_input_line(drvstate->m_maincpu, 0, HOLD_LINE);
	9168	drvstate->m_maincpu->set_input_line(0, HOLD_LINE);
9169	9169	}
9170	9170
9171	9171	static MSM6242_INTERFACE( mjflove_rtc_intf )
r17814	r17815
9198	9198	0xee is vblank  */
9199	9199	static INTERRUPT_GEN( hparadis_irq )
9200	9200	{
9201		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0xee);
	9201	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0xee);
9202	9202	}
9203	9203
9204	9204	static MACHINE_CONFIG_DERIVED( hparadis, quizchq )

trunk/src/mame/drivers/chinagat.c

r17814	r17815
122	122
123	123	/* on the rising edge of VBLK (vcount == F8), signal an NMI */
124	124	if (vcount == 0xf8)
125		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, ASSERT_LINE);
	125	state->m_maincpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
126	126
127	127	/* set 1ms signal on rising edge of vcount & 8 */
128	128	if (!(vcount_old & 8) && (vcount & 8))
129		device_set_input_line(state->m_maincpu, M6809_FIRQ_LINE, ASSERT_LINE);
	129	state->m_maincpu->set_input_line(M6809_FIRQ_LINE, ASSERT_LINE);
130	130
131	131	/* adjust for next scanline */
132	132	if (++scanline >= screen_height)
r17814	r17815
141	141	{
142	142	case 0: /* 3e00 - SND irq */
143	143	state->soundlatch_byte_w(*space, 0, data);
144		device_set_input_line(state->m_snd_cpu, state->m_sound_irq, (state->m_sound_irq == INPUT_LINE_NMI) ? PULSE_LINE : HOLD_LINE );
	144	state->m_snd_cpu->execute().set_input_line(state->m_sound_irq, (state->m_sound_irq == INPUT_LINE_NMI) ? PULSE_LINE : HOLD_LINE );
145	145	break;
146	146
147	147	case 1: /* 3e01 - NMI ack */
148		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, CLEAR_LINE);
	148	state->m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
149	149	break;
150	150
151	151	case 2: /* 3e02 - FIRQ ack */
152		device_set_input_line(state->m_maincpu, M6809_FIRQ_LINE, CLEAR_LINE);
	152	state->m_maincpu->set_input_line(M6809_FIRQ_LINE, CLEAR_LINE);
153	153	break;
154	154
155	155	case 3: /* 3e03 - IRQ ack */
156		device_set_input_line(state->m_maincpu, M6809_IRQ_LINE, CLEAR_LINE);
	156	state->m_maincpu->set_input_line(M6809_IRQ_LINE, CLEAR_LINE);
157	157	break;
158	158
159	159	case 4: /* 3e04 - sub CPU IRQ ack */
160		device_set_input_line(state->m_sub_cpu, state->m_sprite_irq, (state->m_sprite_irq == INPUT_LINE_NMI) ? PULSE_LINE : HOLD_LINE );
	160	state->m_sub_cpu->execute().set_input_line(state->m_sprite_irq, (state->m_sprite_irq == INPUT_LINE_NMI) ? PULSE_LINE : HOLD_LINE );
161	161	break;
162	162	}
163	163	}
r17814	r17815
495	495	static void chinagat_irq_handler( device_t *device, int irq )
496	496	{
497	497	ddragon_state *state = device->machine().driver_data<ddragon_state>();
498		device_set_input_line(state->m_snd_cpu, 0, irq ? ASSERT_LINE : CLEAR_LINE );
	498	state->m_snd_cpu->execute().set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE );
499	499	}
500	500
501	501	static const ym2151_interface ym2151_config =
r17814	r17815
526	526	{
527	527	ddragon_state *state = machine.driver_data<ddragon_state>();
528	528
529		state->m_maincpu = machine.device("maincpu");
	529	state->m_maincpu = machine.device<cpu_device>("maincpu");
530	530	state->m_sub_cpu = machine.device("sub");
531	531	state->m_snd_cpu = machine.device("audiocpu");
532	532

trunk/src/mame/drivers/kaneko16.c

r17814	r17815
1587	1587
1588	1588	// main vblank interrupt
1589	1589	if(scanline == 224)
1590		device_set_input_line(state->m_maincpu, 5, HOLD_LINE);
	1590	state->m_maincpu->set_input_line(5, HOLD_LINE);
1591	1591
1592	1592	// each of these 2 int are responsible of translating a part of sprite buffer
1593	1593	// from work ram to sprite ram. How these are scheduled is unknown.
1594	1594	if(scanline == 64)
1595		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	1595	state->m_maincpu->set_input_line(4, HOLD_LINE);
1596	1596
1597	1597	if(scanline == 144)
1598		device_set_input_line(state->m_maincpu, 3, HOLD_LINE);
	1598	state->m_maincpu->set_input_line(3, HOLD_LINE);
1599	1599	}
1600	1600
1601	1601	static const ay8910_interface ay8910_intf_dsw =
r17814	r17815
2019	2019	if(scanline == 224)
2020	2020	{
2021	2021	// the code for this interrupt is provided by the MCU..
2022		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	2022	state->m_maincpu->set_input_line(4, HOLD_LINE);
2023	2023	}
2024	2024
2025	2025	if(scanline == 64)
2026		device_set_input_line(state->m_maincpu, 3, HOLD_LINE);
	2026	state->m_maincpu->set_input_line(3, HOLD_LINE);
2027	2027
2028	2028	if(scanline == 144)
2029		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	2029	state->m_maincpu->set_input_line(2, HOLD_LINE);
2030	2030	}
2031	2031
2032	2032	/*

trunk/src/mame/drivers/ms32.c

r17814	r17815
223	223	machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
224	224
225	225	// give the Z80 time to respond
226		device_spin_until_time(&space.device(), attotime::from_usec(40));
	226	space.device().execute().spin_until_time(attotime::from_usec(40));
227	227	}
228	228
229	229	READ32_MEMBER(ms32_state::ms32_sound_r)
r17814	r17815
1284	1284	for(i=15; i>=0 && !(state->m_irqreq & (1<<i)); i--);
1285	1285	state->m_irqreq &= ~(1<<i);
1286	1286	if(!state->m_irqreq)
1287		device_set_input_line(device, 0, CLEAR_LINE);
	1287	device->execute().set_input_line(0, CLEAR_LINE);
1288	1288	return i;
1289	1289	}
1290	1290
r17814	r17815
1293	1293	ms32_state *state = machine.driver_data<ms32_state>();
1294	1294	state->m_irqreq = 0;
1295	1295	machine.device("maincpu")->execute().set_input_line(0, CLEAR_LINE);
1296		device_set_irq_callback(machine.device("maincpu"), irq_callback);
	1296	machine.device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
1297	1297	}
1298	1298
1299	1299	static void irq_raise(running_machine &machine, int level)

trunk/src/mame/drivers/deniam.c

r17814	r17815
53	53	if (ACCESSING_BITS_8_15)
54	54	{
55	55	soundlatch_byte_w(space,offset, (data >> 8) & 0xff);
56		device_set_input_line(m_audio_cpu, INPUT_LINE_NMI, PULSE_LINE);
	56	m_audio_cpu->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
57	57	}
58	58	}
59	59
r17814	r17815
228	228
229	229	/* system 16c doesn't have the sound CPU */
230	230	if (state->m_audio_cpu != NULL)
231		device_set_input_line(state->m_audio_cpu, 0, linestate);
	231	state->m_audio_cpu->execute().set_input_line(0, linestate);
232	232	}
233	233
234	234	static const ym3812_interface ym3812_config =

trunk/src/mame/drivers/redalert.c

r17814	r17815
111	111	{
112	112	if( device->machine().root_device().ioport("COIN")->read() )
113	113	/* the service coin as conntected to the CPU's RDY pin as well */
114		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	114	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
115	115
116		device_set_input_line(device, M6502_IRQ_LINE, ASSERT_LINE);
	116	device->execute().set_input_line(M6502_IRQ_LINE, ASSERT_LINE);
117	117	}
118	118
119	119

trunk/src/mame/drivers/kungfur.c

r17814	r17815
88	88	{
89	89	kungfur_state *state = device->machine().driver_data<kungfur_state>();
90	90	if (state->m_control & 0x10)
91		device_set_input_line(device, M6809_IRQ_LINE, ASSERT_LINE);
	91	device->execute().set_input_line(M6809_IRQ_LINE, ASSERT_LINE);
92	92	}
93	93
94	94

trunk/src/mame/drivers/taito_b.c

r17814	r17815
199	199	static TIMER_CALLBACK( rsaga2_interrupt2 )
200	200	{
201	201	taitob_state *state = machine.driver_data<taitob_state>();
202		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	202	state->m_maincpu->set_input_line(2, HOLD_LINE);
203	203	}
204	204
205	205	static INTERRUPT_GEN( rastansaga2_interrupt )
206	206	{
207	207	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(5000), FUNC(rsaga2_interrupt2));
208		device_set_input_line(device, 4, HOLD_LINE);
	208	device->execute().set_input_line(4, HOLD_LINE);
209	209	}
210	210
211	211
212	212	static TIMER_CALLBACK( crimec_interrupt3 )
213	213	{
214	214	taitob_state *state = machine.driver_data<taitob_state>();
215		device_set_input_line(state->m_maincpu, 3, HOLD_LINE);
	215	state->m_maincpu->set_input_line(3, HOLD_LINE);
216	216	}
217	217
218	218	static INTERRUPT_GEN( crimec_interrupt )
219	219	{
220	220	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(5000), FUNC(crimec_interrupt3));
221		device_set_input_line(device, 5, HOLD_LINE);
	221	device->execute().set_input_line(5, HOLD_LINE);
222	222	}
223	223
224	224
225	225	static TIMER_CALLBACK( hitice_interrupt6 )
226	226	{
227	227	taitob_state *state = machine.driver_data<taitob_state>();
228		device_set_input_line(state->m_maincpu, 6, HOLD_LINE);
	228	state->m_maincpu->set_input_line(6, HOLD_LINE);
229	229	}
230	230
231	231	static INTERRUPT_GEN( hitice_interrupt )
232	232	{
233	233	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(5000), FUNC(hitice_interrupt6));
234		device_set_input_line(device, 4, HOLD_LINE);
	234	device->execute().set_input_line(4, HOLD_LINE);
235	235	}
236	236
237	237
238	238	static TIMER_CALLBACK( rambo3_interrupt1 )
239	239	{
240	240	taitob_state *state = machine.driver_data<taitob_state>();
241		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	241	state->m_maincpu->set_input_line(1, HOLD_LINE);
242	242	}
243	243
244	244	static INTERRUPT_GEN( rambo3_interrupt )
245	245	{
246	246	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(5000), FUNC(rambo3_interrupt1));
247		device_set_input_line(device, 6, HOLD_LINE);
	247	device->execute().set_input_line(6, HOLD_LINE);
248	248	}
249	249
250	250
251	251	static TIMER_CALLBACK( pbobble_interrupt5 )
252	252	{
253	253	taitob_state *state = machine.driver_data<taitob_state>();
254		device_set_input_line(state->m_maincpu, 5, HOLD_LINE);
	254	state->m_maincpu->set_input_line(5, HOLD_LINE);
255	255	}
256	256
257	257	static INTERRUPT_GEN( pbobble_interrupt )
258	258	{
259	259	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(5000), FUNC(pbobble_interrupt5));
260		device_set_input_line(device, 3, HOLD_LINE);
	260	device->execute().set_input_line(3, HOLD_LINE);
261	261	}
262	262
263	263	static TIMER_CALLBACK( viofight_interrupt1 )
264	264	{
265	265	taitob_state *state = machine.driver_data<taitob_state>();
266		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	266	state->m_maincpu->set_input_line(1, HOLD_LINE);
267	267	}
268	268
269	269	static INTERRUPT_GEN( viofight_interrupt )
270	270	{
271	271	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(5000), FUNC(viofight_interrupt1));
272		device_set_input_line(device, 4, HOLD_LINE);
	272	device->execute().set_input_line(4, HOLD_LINE);
273	273	}
274	274
275	275	static TIMER_CALLBACK( masterw_interrupt4 )
276	276	{
277	277	taitob_state *state = machine.driver_data<taitob_state>();
278		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	278	state->m_maincpu->set_input_line(4, HOLD_LINE);
279	279	}
280	280
281	281	static INTERRUPT_GEN( masterw_interrupt )
282	282	{
283	283	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(5000), FUNC(masterw_interrupt4));
284		device_set_input_line(device, 5, HOLD_LINE);
	284	device->execute().set_input_line(5, HOLD_LINE);
285	285	}
286	286
287	287	static TIMER_CALLBACK( silentd_interrupt4 )
288	288	{
289	289	taitob_state *state = machine.driver_data<taitob_state>();
290		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	290	state->m_maincpu->set_input_line(4, HOLD_LINE);
291	291	}
292	292
293	293	static INTERRUPT_GEN( silentd_interrupt )
294	294	{
295	295	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(5000), FUNC(silentd_interrupt4));
296		device_set_input_line(device, 6, HOLD_LINE);
	296	device->execute().set_input_line(6, HOLD_LINE);
297	297	}
298	298
299	299	static TIMER_CALLBACK( selfeena_interrupt4 )
300	300	{
301	301	taitob_state *state = machine.driver_data<taitob_state>();
302		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	302	state->m_maincpu->set_input_line(4, HOLD_LINE);
303	303	}
304	304
305	305	static INTERRUPT_GEN( selfeena_interrupt )
306	306	{
307	307	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(5000), FUNC(selfeena_interrupt4));
308		device_set_input_line(device, 6, HOLD_LINE);
	308	device->execute().set_input_line(6, HOLD_LINE);
309	309	}
310	310
311	311	static TIMER_CALLBACK( sbm_interrupt5 )//4
312	312	{
313	313	taitob_state *state = machine.driver_data<taitob_state>();
314		device_set_input_line(state->m_maincpu, 5, HOLD_LINE);
	314	state->m_maincpu->set_input_line(5, HOLD_LINE);
315	315	}
316	316
317	317	static INTERRUPT_GEN( sbm_interrupt )//5
318	318	{
319	319	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(10000), FUNC(sbm_interrupt5));
320		device_set_input_line(device, 4, HOLD_LINE);
	320	device->execute().set_input_line(4, HOLD_LINE);
321	321	}
322	322
323	323	static TIMER_CALLBACK( realpunc_interrupt3 )//3
324	324	{
325	325	taitob_state *state = machine.driver_data<taitob_state>();
326		device_set_input_line(state->m_maincpu, 3, HOLD_LINE);
	326	state->m_maincpu->set_input_line(3, HOLD_LINE);
327	327	}
328	328
329	329	static INTERRUPT_GEN( realpunc_interrupt )//2
330	330	{
331	331	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(10000), FUNC(realpunc_interrupt3));
332		device_set_input_line(device, 2, HOLD_LINE);
	332	device->execute().set_input_line(2, HOLD_LINE);
333	333	}
334	334
335	335
r17814	r17815
394	394
395	395	INPUT_CHANGED_MEMBER(taitob_state::realpunc_sensor)
396	396	{
397		device_set_input_line(m_maincpu, 4, HOLD_LINE);
	397	m_maincpu->set_input_line(4, HOLD_LINE);
398	398	}
399	399
400	400	/***************************************************************************
r17814	r17815
1906	1906	static void irqhandler( device_t *device, int irq )
1907	1907	{
1908	1908	taitob_state *state = device->machine().driver_data<taitob_state>();
1909		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	1909	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
1910	1910	}
1911	1911
1912	1912	static const ym2610_interface ym2610_config =
r17814	r17815
2017	2017	{
2018	2018	taitob_state *state = machine.driver_data<taitob_state>();
2019	2019
2020		state->m_maincpu = machine.device("maincpu");
2021		state->m_audiocpu = machine.device("audiocpu");
	2020	state->m_maincpu = machine.device<cpu_device>("maincpu");
	2021	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
2022	2022	state->m_mb87078 = machine.device("mb87078");
2023	2023	state->m_ym = machine.device("ymsnd");
2024	2024	state->m_tc0180vcu = machine.device("tc0180vcu");

trunk/src/mame/drivers/jackal.c

r17814	r17815
313	313
314	314	if (state->m_irq_enable)
315	315	{
316		device_set_input_line(device, 0, HOLD_LINE);
317		device_set_input_line(state->m_slavecpu, INPUT_LINE_NMI, PULSE_LINE);
	316	device->execute().set_input_line(0, HOLD_LINE);
	317	state->m_slavecpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
318	318	}
319	319	}
320	320
r17814	r17815
334	334	state->membank("bank1")->configure_entry(1, &ROM[0x14000]);
335	335	state->membank("bank1")->set_entry(0);
336	336
337		state->m_mastercpu = machine.device("master");
338		state->m_slavecpu = machine.device("slave");
	337	state->m_mastercpu = machine.device<cpu_device>("master");
	338	state->m_slavecpu = machine.device<cpu_device>("slave");
339	339
340	340	state->save_item(NAME(state->m_irq_enable));
341	341	}

trunk/src/mame/drivers/vaportra.c

r17814	r17815
26	26	/* Force synchronisation between CPUs with fake timer */
27	27	machine().scheduler().synchronize();
28	28	soundlatch_byte_w(space, 0, data & 0xff);
29		device_set_input_line(m_audiocpu, 0, ASSERT_LINE);
	29	m_audiocpu->set_input_line(0, ASSERT_LINE);
30	30	}
31	31
32	32	READ16_MEMBER(vaportra_state::vaportra_control_r)
r17814	r17815
71	71
72	72	READ8_MEMBER(vaportra_state::vaportra_soundlatch_r)
73	73	{
74		device_set_input_line(m_audiocpu, 0, CLEAR_LINE);
	74	m_audiocpu->set_input_line(0, CLEAR_LINE);
75	75	return soundlatch_byte_r(space, offset);
76	76	}
77	77
r17814	r17815
202	202	static void sound_irq( device_t *device, int state )
203	203	{
204	204	vaportra_state *driver_state = device->machine().driver_data<vaportra_state>();
205		device_set_input_line(driver_state->m_audiocpu, 1, state); /* IRQ 2 */
	205	driver_state->m_audiocpu->set_input_line(1, state); /* IRQ 2 */
206	206	}
207	207
208	208	static const ym2151_interface ym2151_config =
r17814	r17815
245	245	{
246	246	vaportra_state *state = machine.driver_data<vaportra_state>();
247	247
248		state->m_maincpu = machine.device("maincpu");
249		state->m_audiocpu = machine.device("audiocpu");
	248	state->m_maincpu = machine.device<cpu_device>("maincpu");
	249	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
250	250	state->m_deco_tilegen1 = machine.device("tilegen1");
251	251	state->m_deco_tilegen2 = machine.device("tilegen2");
252	252

trunk/src/mame/drivers/suna8.c

r17814	r17815
1743	1743	int scanline = param;
1744	1744
1745	1745	if(scanline == 240)
1746		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	1746	state->m_maincpu->set_input_line(0, HOLD_LINE);
1747	1747	if(scanline == 112)
1748		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	1748	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
1749	1749
1750	1750	// TODO: NMI enable
1751	1751	}
r17814	r17815
1826	1826	int scanline = param;
1827	1827
1828	1828	if(scanline == 240)
1829		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	1829	state->m_maincpu->set_input_line(0, HOLD_LINE);
1830	1830	if(scanline == 112)
1831		if (state->m_nmi_enable)   device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	1831	if (state->m_nmi_enable)   state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
1832	1832	}
1833	1833
1834	1834	static MACHINE_RESET( hardhea2 )

trunk/src/mame/drivers/chanbara.c

r17814	r17815
78	78	UINT8    m_scrollhi;
79	79
80	80	/* devices */
81		device_t *m_maincpu;
	81	cpu_device *m_maincpu;
82	82	DECLARE_WRITE8_MEMBER(chanbara_videoram_w);
83	83	DECLARE_WRITE8_MEMBER(chanbara_colorram_w);
84	84	DECLARE_WRITE8_MEMBER(chanbara_videoram2_w);
r17814	r17815
366	366	static void sound_irq( device_t *device, int linestate )
367	367	{
368	368	chanbara_state *state = device->machine().driver_data<chanbara_state>();
369		device_set_input_line(state->m_maincpu, 0, linestate);
	369	state->m_maincpu->set_input_line(0, linestate);
370	370	}
371	371
372	372
r17814	r17815
388	388	{
389	389	chanbara_state *state = machine.driver_data<chanbara_state>();
390	390
391		state->m_maincpu = machine.device("maincpu");
	391	state->m_maincpu = machine.device<cpu_device>("maincpu");
392	392
393	393	state->save_item(NAME(state->m_scroll));
394	394	state->save_item(NAME(state->m_scrollhi));

trunk/src/mame/drivers/btime.c

r17814	r17815
169	169	if (m_audio_nmi_enable_type == AUDIO_ENABLE_DIRECT)
170	170	{
171	171	m_audio_nmi_enabled = data & 1;
172		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, (m_audio_nmi_enabled && m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
	172	m_audiocpu->set_input_line(INPUT_LINE_NMI, (m_audio_nmi_enabled && m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
173	173	}
174	174	}
175	175
r17814	r17815
179	179	if (m_audio_nmi_enable_type == AUDIO_ENABLE_AY8910)
180	180	{
181	181	m_audio_nmi_enabled = ~data & 1;
182		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, (m_audio_nmi_enabled && m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
	182	m_audiocpu->set_input_line(INPUT_LINE_NMI, (m_audio_nmi_enabled && m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
183	183	}
184	184	}
185	185
r17814	r17815
188	188	btime_state *state = timer.machine().driver_data<btime_state>();
189	189	int scanline = param;
190	190	state->m_audio_nmi_state = scanline & 8;
191		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, (state->m_audio_nmi_enabled && state->m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
	191	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, (state->m_audio_nmi_enabled && state->m_audio_nmi_state) ? ASSERT_LINE : CLEAR_LINE);
192	192	}
193	193
194	194
r17814	r17815
506	506	INPUT_CHANGED_MEMBER(btime_state::coin_inserted_irq_hi)
507	507	{
508	508	if (newval)
509		device_set_input_line(m_maincpu, 0, HOLD_LINE);
	509	m_maincpu->set_input_line(0, HOLD_LINE);
510	510	}
511	511
512	512	INPUT_CHANGED_MEMBER(btime_state::coin_inserted_irq_lo)
513	513	{
514	514	if (!newval)
515		device_set_input_line(m_maincpu, 0, HOLD_LINE);
	515	m_maincpu->set_input_line(0, HOLD_LINE);
516	516	}
517	517
518	518	INPUT_CHANGED_MEMBER(btime_state::coin_inserted_nmi_lo)
519	519	{
520		device_set_input_line(m_maincpu, INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
	520	m_maincpu->set_input_line(INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
521	521	}
522	522
523	523
524	524	WRITE8_MEMBER(btime_state::audio_command_w)
525	525	{
526	526	soundlatch_byte_w(space, offset, data);
527		device_set_input_line(m_audiocpu, 0, ASSERT_LINE);
	527	m_audiocpu->set_input_line(0, ASSERT_LINE);
528	528	}
529	529
530	530	READ8_MEMBER(btime_state::audio_command_r)
531	531	{
532		device_set_input_line(m_audiocpu, 0, CLEAR_LINE);
	532	m_audiocpu->set_input_line(0, CLEAR_LINE);
533	533	return soundlatch_byte_r(space, offset);
534	534	}
535	535
r17814	r17815
1400	1400	{
1401	1401	btime_state *state = machine.driver_data<btime_state>();
1402	1402
1403		state->m_maincpu = machine.device("maincpu");
1404		state->m_audiocpu = machine.device("audiocpu");
	1403	state->m_maincpu = machine.device<cpu_device>("maincpu");
	1404	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
1405	1405
1406	1406	state->save_item(NAME(state->m_btime_palette));
1407	1407	state->save_item(NAME(state->m_bnj_scroll1));

trunk/src/mame/drivers/m14.c

r17814	r17815
71	71	UINT8 m_hop_mux;
72	72
73	73	/* devices */
74		device_t *m_maincpu;
	74	cpu_device *m_maincpu;
75	75	DECLARE_WRITE8_MEMBER(m14_vram_w);
76	76	DECLARE_WRITE8_MEMBER(m14_cram_w);
77	77	DECLARE_READ8_MEMBER(m14_rng_r);
r17814	r17815
230	230	{
231	231	/* left coin insertion causes a rst6.5 (vector 0x34) */
232	232	if (newval)
233		device_set_input_line(m_maincpu, I8085_RST65_LINE, HOLD_LINE);
	233	m_maincpu->set_input_line(I8085_RST65_LINE, HOLD_LINE);
234	234	}
235	235
236	236	INPUT_CHANGED_MEMBER(m14_state::right_coin_inserted)
237	237	{
238	238	/* right coin insertion causes a rst5.5 (vector 0x2c) */
239	239	if (newval)
240		device_set_input_line(m_maincpu, I8085_RST55_LINE, HOLD_LINE);
	240	m_maincpu->set_input_line(I8085_RST55_LINE, HOLD_LINE);
241	241	}
242	242
243	243	static INPUT_PORTS_START( m14 )
r17814	r17815
312	312
313	313	static INTERRUPT_GEN( m14_irq )
314	314	{
315		device_set_input_line(device, I8085_RST75_LINE, ASSERT_LINE);
316		device_set_input_line(device, I8085_RST75_LINE, CLEAR_LINE);
	315	device->execute().set_input_line(I8085_RST75_LINE, ASSERT_LINE);
	316	device->execute().set_input_line(I8085_RST75_LINE, CLEAR_LINE);
317	317	}
318	318
319	319	static MACHINE_START( m14 )
320	320	{
321	321	m14_state *state = machine.driver_data<m14_state>();
322	322
323		state->m_maincpu = machine.device("maincpu");
	323	state->m_maincpu = machine.device<cpu_device>("maincpu");
324	324
325	325	state->save_item(NAME(state->m_hop_mux));
326	326	}

trunk/src/mame/drivers/mermaid.c

r17814	r17815
366	366	{
367	367	mermaid_state *state = machine.driver_data<mermaid_state>();
368	368
369		state->m_maincpu = machine.device("maincpu");
	369	state->m_maincpu = machine.device<cpu_device>("maincpu");
370	370	state->m_ay1 = machine.device("ay1");
371	371	state->m_ay2 = machine.device("ay2");
372	372
r17814	r17815
446	446	mermaid_state *state = device->machine().driver_data<mermaid_state>();
447	447
448	448	if(state->m_nmi_mask)
449		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	449	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
450	450	}
451	451
452	452	static MACHINE_CONFIG_START( mermaid, mermaid_state )

trunk/src/mame/drivers/gaelco3d.c

r17814	r17815
257	257	static INTERRUPT_GEN( vblank_gen )
258	258	{
259	259	gaelco3d_render(*device->machine().primary_screen);
260		device_set_input_line(device, 2, ASSERT_LINE);
	260	device->execute().set_input_line(2, ASSERT_LINE);
261	261	}
262	262
263	263

trunk/src/mame/drivers/photon2.c

r17814	r17815
299	299
300	300	if (scanline == SPEC_SCREEN_HEIGHT/2)
301	301	{
302		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	302	state->m_maincpu->set_input_line(0, HOLD_LINE);
303	303	}
304	304	else if(scanline == 0)
305	305	{
306	306	if ( state->m_nmi_enable )
307	307	{
308		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	308	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
309	309	}
310	310	}
311	311	}

trunk/src/mame/drivers/highvdeo.c

r17814	r17815
921	921
922	922	static INTERRUPT_GEN( vblank_irq )
923	923	{
924		device_set_input_line_and_vector(device,0,HOLD_LINE,0x08/4);
	924	device->execute().set_input_line_and_vector(0,HOLD_LINE,0x08/4);
925	925	}
926	926
927	927	static MACHINE_CONFIG_START( tv_vcf, highvdeo_state )

trunk/src/mame/drivers/namconb1.c

r17814	r17815
347	347	int scanline = (state->m_generic_paletteram_32[0x1808/4]&0xffff)-32;
348	348
349	349	if((!state->m_vblank_irq_active) && (state->m_namconb_cpureg[0x04] & 0xf0)) {
350		device_set_input_line(device, state->m_namconb_cpureg[0x04] & 0xf, ASSERT_LINE);
	350	device->execute().set_input_line(state->m_namconb_cpureg[0x04] & 0xf, ASSERT_LINE);
351	351	state->m_vblank_irq_active = 1;
352	352	}
353	353
r17814	r17815
405	405	int scanline = (state->m_generic_paletteram_32[0x1808/4]&0xffff)-32;
406	406
407	407	if((!state->m_vblank_irq_active) && state->m_namconb_cpureg[0x00]) {
408		device_set_input_line(device, state->m_namconb_cpureg[0x00], ASSERT_LINE);
	408	device->execute().set_input_line(state->m_namconb_cpureg[0x00], ASSERT_LINE);
409	409	state->m_vblank_irq_active = 1;
410	410	}
411	411
r17814	r17815
904	904	// C74 BIOS has a very short window on the CPU sync signal, so immediately let the '020 at it
905	905	if ((offset == 0x6000/2) && (data & 0x80))
906	906	{
907		device_spin_until_time(&space.device(), downcast<cpu_device *>(&space.device())->cycles_to_attotime(300));   // was 300
	907	space.device().execute().spin_until_time(downcast<cpu_device *>(&space.device())->cycles_to_attotime(300));   // was 300
908	908	}
909	909	}
910	910

trunk/src/mame/drivers/nsmpoker.c

r17814	r17815
146	146
147	147	static INTERRUPT_GEN( nsmpoker_interrupt )
148	148	{
149		device_set_input_line_and_vector(device, 0, ASSERT_LINE, 3);//2=nmi  3,4,5,6
	149	device->execute().set_input_line_and_vector(0, ASSERT_LINE, 3);//2=nmi  3,4,5,6
150	150	}
151	151
152	152	//WRITE8_MEMBER(nsmpoker_state::debug_w)

trunk/src/mame/drivers/othello.c

r17814	r17815
69	69	int m_n7751_busy;
70	70
71	71	/* devices */
72		device_t *m_maincpu;
	72	cpu_device *m_maincpu;
73	73	mc6845_device *m_mc6845;
74	74	device_t *m_n7751;
75	75	device_t *m_ay1;
r17814	r17815
153	153
154	154
155	155	m_n7751_command = (data & 0x07);
156		device_set_input_line(m_n7751, 0, ((data & 0x08) == 0) ? ASSERT_LINE : CLEAR_LINE);
157		//device_set_input_line(m_n7751, 0, (data & 0x02) ? CLEAR_LINE : ASSERT_LINE);
	156	m_n7751->execute().set_input_line(0, ((data & 0x08) == 0) ? ASSERT_LINE : CLEAR_LINE);
	157	//m_n7751->execute().set_input_line(0, (data & 0x02) ? CLEAR_LINE : ASSERT_LINE);
158	158	machine().scheduler().boost_interleave(attotime::zero, attotime::from_usec(100));
159	159	*/
160	160
r17814	r17815
384	384	{
385	385	othello_state *state = machine.driver_data<othello_state>();
386	386
387		state->m_maincpu = machine.device("maincpu");
	387	state->m_maincpu = machine.device<cpu_device>("maincpu");
388	388	state->m_mc6845 = machine.device<mc6845_device>("crtc");
389	389	state->m_n7751 = machine.device("n7751");
390	390	state->m_ay1 = machine.device("ay1");

trunk/src/mame/drivers/fcrash.c

r17814	r17815
47	47	if (ACCESSING_BITS_0_7)
48	48	{
49	49	state->soundlatch_byte_w(*space, 0, data & 0xff);
50		device_set_input_line(state->m_audiocpu, 0, HOLD_LINE);
	50	state->m_audiocpu->set_input_line(0, HOLD_LINE);
51	51	}
52	52	}
53	53
r17814	r17815
69	69	state->m_sample_buffer1 >>= 4;
70	70	state->m_sample_select1 ^= 1;
71	71	if (state->m_sample_select1 == 0)
72		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	72	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
73	73	}
74	74
75	75	static void m5205_int2( device_t *device )
r17814	r17815
697	697
698	698	state->membank("bank1")->configure_entries(0, 8, &ROM[0x10000], 0x4000);
699	699
700		state->m_maincpu = machine.device("maincpu");
701		state->m_audiocpu = machine.device("soundcpu");
	700	state->m_maincpu = machine.device<cpu_device>("maincpu");
	701	state->m_audiocpu = machine.device<cpu_device>("soundcpu");
702	702	state->m_msm_1 = machine.device<msm5205_device>("msm1");
703	703	state->m_msm_2 = machine.device<msm5205_device>("msm2");
704	704
r17814	r17815
712	712	{
713	713	cps_state *state = machine.driver_data<cps_state>();
714	714
715		state->m_maincpu = machine.device("maincpu");
716		state->m_audiocpu = machine.device("soundcpu");
	715	state->m_maincpu = machine.device<cpu_device>("maincpu");
	716	state->m_audiocpu = machine.device<cpu_device>("soundcpu");
717	717	}
718	718
719	719	static MACHINE_RESET( fcrash )

trunk/src/mame/drivers/strnskil.c

r17814	r17815
324	324
325	325	if(scanline == 240 || scanline == 96)
326	326	{
327		device_set_input_line(state->m_maincpu,0,HOLD_LINE);
	327	state->m_maincpu->set_input_line(0,HOLD_LINE);
328	328
329	329	state->m_irq_source = (scanline != 240);
330	330	}

trunk/src/mame/drivers/bfm_sc5.c

r17814	r17815
48	48	static INTERRUPT_GEN( sc5_fake_timer_int )
49	49	{
50	50	// this should be coming from the Timer / SIM modules of the Coldfire
51		device_set_input_line_and_vector((legacy_cpu_device*)device->machine().device("maincpu"), 5, HOLD_LINE, 0x8c);
	51	device->machine().device("maincpu")->execute().set_input_line_and_vector(5, HOLD_LINE, 0x8c);
52	52	}
53	53
54	54	static MACHINE_CONFIG_START( sc5, sc5_state )

trunk/src/mame/drivers/model2.c

r17814	r17815
187	187	i960_stall(&space->device());
188	188
189	189	/* spin the main cpu and let the TGP catch up */
190		device_spin_until_time(&space->device(), attotime::from_usec(100));
	190	space->device().execute().spin_until_time(attotime::from_usec(100));
191	191
192	192	return 0;
193	193	}
r17814	r17815
246	246	{
247	247	sharc_set_flag_input(device, 1, ASSERT_LINE);
248	248
249		//device_set_input_line(device, SHARC_INPUT_FLAG1, ASSERT_LINE);
	249	//device->execute().set_input_line(SHARC_INPUT_FLAG1, ASSERT_LINE);
250	250	}
251	251	else
252	252	{
253	253	sharc_set_flag_input(device, 1, CLEAR_LINE);
254	254
255		//device_set_input_line(device, SHARC_INPUT_FLAG1, CLEAR_LINE);
	255	//device->execute().set_input_line(SHARC_INPUT_FLAG1, CLEAR_LINE);
256	256	}
257	257	}
258	258	}
r17814	r17815
747	747	{
748	748	logerror("Boot geo, %d dwords\n", m_geocnt);
749	749	machine().device("dsp2")->execute().set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
750		//device_spin_until_time(&space.device(), attotime::from_usec(1000));       // Give the SHARC enough time to boot itself
	750	//space.device().execute().spin_until_time(attotime::from_usec(1000));       // Give the SHARC enough time to boot itself
751	751	}
752	752	}
753	753
r17814	r17815
976	976
977	977	if ((sr & 0x0700) > 0x0100)
978	978	{
979		device_spin_until_time(&space->device(), attotime::from_usec(40));
	979	space->device().execute().spin_until_time(attotime::from_usec(40));
980	980	return 0;   // not ready yet, interrupts disabled
981	981	}
982	982
r17814	r17815
988	988	model2_state *state = space->machine().driver_data<model2_state>();
989	989	if (!snd_68k_ready_r(space))
990	990	{
991		device_spin_until_time(&space->device(), attotime::from_usec(40));
	991	space->device().execute().spin_until_time(attotime::from_usec(40));
992	992	}
993	993
994	994	state->m_to_68k = data;
r17814	r17815
996	996	space->machine().device("audiocpu")->execute().set_input_line(2, HOLD_LINE);
997	997
998	998	// give the 68k time to notice
999		device_spin_until_time(&space->device(), attotime::from_usec(40));
	999	space->device().execute().spin_until_time(attotime::from_usec(40));
1000	1000	}
1001	1001
1002	1002	READ32_MEMBER(model2_state::model2_serial_r)
r17814	r17815
1024	1024	scsp_midi_in(machine().device("scsp"), 0, data&0xff, 0);
1025	1025
1026	1026	// give the 68k time to notice
1027		device_spin_until_time(&space.device(), attotime::from_usec(40));
	1027	space.device().execute().spin_until_time(attotime::from_usec(40));
1028	1028	}
1029	1029	}
1030	1030
r17814	r17815
1762	1762	{
1763	1763	state->m_intreq |= (1<<10);
1764	1764	if (state->m_intena & (1<<10))
1765		device_set_input_line(state->m_maincpu, I960_IRQ3, ASSERT_LINE);
	1765	state->m_maincpu->set_input_line(I960_IRQ3, ASSERT_LINE);
1766	1766	}
1767	1767
1768	1768	if(scanline == 384/2)
1769	1769	{
1770	1770	state->m_intreq |= (1<<0);
1771	1771	if (state->m_intena & (1<<0))
1772		device_set_input_line(state->m_maincpu, I960_IRQ0, ASSERT_LINE);
	1772	state->m_maincpu->set_input_line(I960_IRQ0, ASSERT_LINE);
1773	1773	}
1774	1774	}
1775	1775
r17814	r17815
1782	1782	{
1783	1783	state->m_intreq |= (1<<10);
1784	1784	if (state->m_intena & (1<<10))
1785		device_set_input_line(state->m_maincpu, I960_IRQ3, ASSERT_LINE);
	1785	state->m_maincpu->set_input_line(I960_IRQ3, ASSERT_LINE);
1786	1786	}
1787	1787
1788	1788	if(scanline == 256)
1789	1789	{
1790	1790	state->m_intreq |= (1<<2);
1791	1791	if (state->m_intena & (1<<2))
1792		device_set_input_line(state->m_maincpu, I960_IRQ2, ASSERT_LINE);
	1792	state->m_maincpu->set_input_line(I960_IRQ2, ASSERT_LINE);
1793	1793	}
1794	1794
1795	1795	if(scanline == 128)
1796	1796	{
1797	1797	state->m_intreq |= (1<<0);
1798	1798	if (state->m_intena & (1<<0))
1799		device_set_input_line(state->m_maincpu, I960_IRQ0, ASSERT_LINE);
	1799	state->m_maincpu->set_input_line(I960_IRQ0, ASSERT_LINE);
1800	1800	}
1801	1801	}
1802	1802

trunk/src/mame/drivers/wiping.c

r17814	r17815
267	267	wiping_state *state = device->machine().driver_data<wiping_state>();
268	268
269	269	if(state->m_main_irq_mask)
270		device_set_input_line(device, 0, HOLD_LINE);
	270	device->execute().set_input_line(0, HOLD_LINE);
271	271	}
272	272
273	273	static INTERRUPT_GEN( sound_timer_irq )
r17814	r17815
275	275	wiping_state *state = device->machine().driver_data<wiping_state>();
276	276
277	277	if(state->m_sound_irq_mask)
278		device_set_input_line(device, 0, HOLD_LINE);
	278	device->execute().set_input_line(0, HOLD_LINE);
279	279	}
280	280
281	281

trunk/src/mame/drivers/popeye.c

r17814	r17815
25	25	{
26	26	/* NMIs are enabled by the I register?? How can that be? */
27	27	if (device->state().state_int(Z80_I) & 1)   /* skyskipr: 0/1, popeye: 2/3 but also 0/1 */
28		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	28	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
29	29	}
30	30
31	31

trunk/src/mame/drivers/cps2.c

r17814	r17815
641	641	if (state->m_scanline1 == param || (state->m_scanline1 < param && !state->m_scancalls))
642	642	{
643	643	state->m_cps_b_regs[0x10/2] = 0;
644		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	644	state->m_maincpu->set_input_line(4, HOLD_LINE);
645	645	cps2_set_sprite_priorities(timer.machine());
646	646	timer.machine().primary_screen->update_partial(param);
647	647	state->m_scancalls++;
r17814	r17815
652	652	if(state->m_scanline2 == param || (state->m_scanline2 < param && !state->m_scancalls))
653	653	{
654	654	state->m_cps_b_regs[0x12 / 2] = 0;
655		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	655	state->m_maincpu->set_input_line(4, HOLD_LINE);
656	656	cps2_set_sprite_priorities(timer.machine());
657	657	timer.machine().primary_screen->update_partial(param);
658	658	state->m_scancalls++;
r17814	r17815
663	663	{
664	664	state->m_cps_b_regs[0x10 / 2] = state->m_scanline1;
665	665	state->m_cps_b_regs[0x12 / 2] = state->m_scanline2;
666		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	666	state->m_maincpu->set_input_line(2, HOLD_LINE);
667	667	if(state->m_scancalls)
668	668	{
669	669	cps2_set_sprite_priorities(timer.machine());
r17814	r17815
722	722
723	723	/* Z80 Reset */
724	724	if (state->m_audiocpu != NULL)
725		device_set_input_line(state->m_audiocpu, INPUT_LINE_RESET, (data & 0x0008) ? CLEAR_LINE : ASSERT_LINE);
	725	state->m_audiocpu->set_input_line(INPUT_LINE_RESET, (data & 0x0008) ? CLEAR_LINE : ASSERT_LINE);
726	726
727	727	coin_counter_w(space->machine(), 0, data & 0x0001);
728	728	if ((strncmp(space->machine().system().name, "pzloop2", 8) == 0) ||
r17814	r17815
1214	1214	{
1215	1215	cps_state *state = machine.driver_data<cps_state>();
1216	1216
1217		state->m_maincpu = machine.device("maincpu");
1218		state->m_audiocpu = machine.device("audiocpu");
	1217	state->m_maincpu = machine.device<cpu_device>("maincpu");
	1218	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
1219	1219
1220	1220	if (state->m_audiocpu != NULL)   // gigaman2 has no audiocpu
1221	1221	state->membank("bank1")->configure_entries(0, (QSOUND_SIZE - 0x10000) / 0x4000, state->memregion("audiocpu")->base() + 0x10000, 0x4000);

trunk/src/mame/drivers/igs017.c

r17814	r17815
3224	3224	int scanline = param;
3225	3225
3226	3226	if(scanline == 240 && state->m_irq_enable)
3227		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	3227	state->m_maincpu->set_input_line(0, HOLD_LINE);
3228	3228
3229	3229	if(scanline == 0 && state->m_nmi_enable)
3230		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	3230	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
3231	3231	}
3232	3232
3233	3233
r17814	r17815
3294	3294	int scanline = param;
3295	3295
3296	3296	if(scanline == 240 && state->m_irq1_enable)
3297		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	3297	state->m_maincpu->set_input_line(1, HOLD_LINE);
3298	3298
3299	3299	if(scanline == 0 && state->m_irq2_enable)
3300		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	3300	state->m_maincpu->set_input_line(2, HOLD_LINE);
3301	3301	}
3302	3302
3303	3303	static MACHINE_RESET( mgcs )
r17814	r17815
3515	3515	int scanline = param;
3516	3516
3517	3517	if(scanline == 240 && state->m_irq1_enable)
3518		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	3518	state->m_maincpu->set_input_line(1, HOLD_LINE);
3519	3519
3520	3520	if(scanline == 0 && state->m_irq2_enable)
3521		device_set_input_line(state->m_maincpu, 3, HOLD_LINE); // lev 3 instead of 2
	3521	state->m_maincpu->set_input_line(3, HOLD_LINE); // lev 3 instead of 2
3522	3522	}
3523	3523
3524	3524	static I8255A_INTERFACE( mgdh_ppi8255_intf )

trunk/src/mame/drivers/pushman.c

r17814	r17815
74	74
75	75	if (offset == 1)
76	76	{
77		device_set_input_line(m_mcu, M68705_IRQ_LINE, HOLD_LINE);
78		device_spin(&space.device());
	77	m_mcu->execute().set_input_line(M68705_IRQ_LINE, HOLD_LINE);
	78	space.device().execute().spin();
79	79	m_new_latch = 0;
80	80	}
81	81	}
r17814	r17815
386	386	static void irqhandler(device_t *device, int irq)
387	387	{
388	388	pushman_state *state = device->machine().driver_data<pushman_state>();
389		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	389	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
390	390	}
391	391
392	392	static const ym2203_interface ym2203_config =
r17814	r17815
404	404	{
405	405	pushman_state *state = machine.driver_data<pushman_state>();
406	406
407		state->m_maincpu = machine.device("maincpu");
408		state->m_audiocpu = machine.device("audiocpu");
	407	state->m_maincpu = machine.device<cpu_device>("maincpu");
	408	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
409	409	state->m_mcu = machine.device("mcu");
410	410
411	411	state->save_item(NAME(state->m_control));

trunk/src/mame/drivers/hyperspt.c

r17814	r17815
277	277	hyperspt_state *state = device->machine().driver_data<hyperspt_state>();
278	278
279	279	if(state->m_irq_mask)
280		device_set_input_line(device, 0, HOLD_LINE);
	280	device->execute().set_input_line(0, HOLD_LINE);
281	281	}
282	282
283	283	//-------------------------------------------------

trunk/src/mame/drivers/amaticmg.c

r17814	r17815
908	908	amaticmg_state *state = device->machine().driver_data<amaticmg_state>();
909	909
910	910	if(state->m_nmi_mask)
911		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	911	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
912	912	}
913	913
914	914

trunk/src/mame/drivers/shanghai.c

r17814	r17815
122	122
123	123	static INTERRUPT_GEN( shanghai_interrupt )
124	124	{
125		device_set_input_line_and_vector(device,0,HOLD_LINE,0x80);
	125	device->execute().set_input_line_and_vector(0,HOLD_LINE,0x80);
126	126	}
127	127
128	128	WRITE16_MEMBER(shanghai_state::shanghai_coin_w)

trunk/src/mame/drivers/avt.c

r17814	r17815
884	884	{
885	885	avt_state *state = device->machine().driver_data<avt_state>();
886	886
887		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0x06);
	887	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0x06);
888	888	}
889	889
890	890	static MACHINE_CONFIG_START( avt, avt_state )

trunk/src/mame/drivers/missb2.c

r17814	r17815
428	428
429	429	static INTERRUPT_GEN( missb2_interrupt )
430	430	{
431		device_set_input_line(device, 0, HOLD_LINE);
	431	device->execute().set_input_line(0, HOLD_LINE);
432	432	}
433	433
434	434	/* Machine Driver */
r17814	r17815
437	437	{
438	438	missb2_state *state = machine.driver_data<missb2_state>();
439	439
440		state->m_maincpu = machine.device("maincpu");
441		state->m_audiocpu = machine.device("audiocpu");
	440	state->m_maincpu = machine.device<cpu_device>("maincpu");
	441	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
442	442	state->m_slave = machine.device("slave");
443	443	state->m_mcu = NULL;
444	444

trunk/src/mame/drivers/pitnrun.c

r17814	r17815
73	73	static INTERRUPT_GEN( pitnrun_nmi_source )
74	74	{
75	75	pitnrun_state *state = device->machine().driver_data<pitnrun_state>();
76		if(state->m_nmi) device_set_input_line(device,INPUT_LINE_NMI, PULSE_LINE);
	76	if(state->m_nmi) device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
77	77	}
78	78
79	79	WRITE8_MEMBER(pitnrun_state::nmi_enable_w)

trunk/src/mame/drivers/photon.c

r17814	r17815
184	184
185	185	static INTERRUPT_GEN( pk8000_interrupt )
186	186	{
187		device_set_input_line(device, 0, HOLD_LINE);
	187	device->execute().set_input_line(0, HOLD_LINE);
188	188	}
189	189
190	190	static IRQ_CALLBACK(pk8000_irq_callback)
r17814	r17815
196	196	static MACHINE_RESET(pk8000)
197	197	{
198	198	pk8000_set_bank(machine,0);
199		device_set_irq_callback(machine.device("maincpu"), pk8000_irq_callback);
	199	machine.device("maincpu")->execute().set_irq_acknowledge_callback(pk8000_irq_callback);
200	200	}
201	201
202	202	static VIDEO_START( photon )

trunk/src/mame/drivers/citycon.c

r17814	r17815
21	21
22	22	READ8_MEMBER(citycon_state::citycon_irq_ack_r)
23	23	{
24		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	24	m_maincpu->set_input_line(0, CLEAR_LINE);
25	25
26	26	return 0;
27	27	}
r17814	r17815
190	190	{
191	191	citycon_state *state = machine.driver_data<citycon_state>();
192	192
193		state->m_maincpu = machine.device("maincpu");
	193	state->m_maincpu = machine.device<cpu_device>("maincpu");
194	194
195	195	state->save_item(NAME(state->m_bg_image));
196	196	}

trunk/src/mame/drivers/playmark.c

r17814	r17815
124	124	{
125	125	m_snd_command = (data & 0xff);
126	126	m_snd_flag = 1;
127		device_yield(&space.device());
	127	space.device().execute().yield();
128	128	}
129	129	}
130	130

trunk/src/mame/drivers/pgm.c

r17814	r17815
245	245	if (data == 0x5050)
246	246	{
247	247	m_ics->reset();
248		device_set_input_line(m_soundcpu, INPUT_LINE_HALT, CLEAR_LINE);
249		device_set_input_line(m_soundcpu, INPUT_LINE_RESET, PULSE_LINE);
	248	m_soundcpu->set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
	249	m_soundcpu->set_input_line(INPUT_LINE_RESET, PULSE_LINE);
250	250	if(0)
251	251	{
252	252	FILE *out;
r17814	r17815
259	259	{
260	260	/* this might not be 100% correct, but several of the games (ddp2, puzzli2 etc. expect the z80 to be turned
261	261	off during data uploads, they write here before the upload */
262		device_set_input_line(m_soundcpu, INPUT_LINE_HALT, ASSERT_LINE);
	262	m_soundcpu->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
263	263	}
264	264	}
265	265
r17814	r17815
277	277	if (PGMLOGERROR)
278	278	logerror("SL 1 m68.w %02x (%06x) IRQ\n", data & 0xff, space.device().safe_pc());
279	279	soundlatch_byte_w(space, 0, data);
280		device_set_input_line(m_soundcpu, INPUT_LINE_NMI, PULSE_LINE );
	280	m_soundcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE );
281	281	}
282	282	}
283	283
r17814	r17815
291	291	void pgm_sound_irq( device_t *device, int level )
292	292	{
293	293	pgm_state *state = device->machine().driver_data<pgm_state>();
294		device_set_input_line(state->m_soundcpu, 0, level);
	294	state->m_soundcpu->set_input_line(0, level);
295	295	}
296	296
297	297	/*static const ics2115_interface pgm_ics2115_interface =
r17814	r17815
497	497	int scanline = param;
498	498
499	499	if(scanline == 224)
500		device_set_input_line(state->m_maincpu, 6, HOLD_LINE);
	500	state->m_maincpu->set_input_line(6, HOLD_LINE);
501	501
502	502	if(scanline == 0)
503		if (!state->m_irq4_disabled) device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	503	if (!state->m_irq4_disabled) state->m_maincpu->set_input_line(4, HOLD_LINE);
504	504	}
505	505
506	506	MACHINE_START( pgm )

trunk/src/mame/drivers/namcos21.c

r17814	r17815
578	578	offset == 0x103 &&
579	579	&space.device() == machine().device("maincpu"))
580	580	{ /* hack; synchronization for solvalou */
581		device_yield(&space.device());
	581	space.device().execute().yield();
582	582	}
583	583	}
584	584	} /* dspram16_w */

trunk/src/mame/drivers/jangou.c

r17814	r17815
306	306	WRITE8_MEMBER(jangou_state::sound_latch_w)
307	307	{
308	308	soundlatch_byte_w(space, 0, data & 0xff);
309		device_set_input_line(m_cpu_1, INPUT_LINE_NMI, ASSERT_LINE);
	309	m_cpu_1->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
310	310	}
311	311
312	312	READ8_MEMBER(jangou_state::sound_latch_r)
313	313	{
314		device_set_input_line(m_cpu_1, INPUT_LINE_NMI, CLEAR_LINE);
	314	m_cpu_1->execute().set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
315	315	return soundlatch_byte_r(space, 0);
316	316	}
317	317
r17814	r17815
331	331
332	332	/* Trigger an IRQ for every 8 shifted bits */
333	333	if ((++state->m_cvsd_shift_cnt & 7) == 0)
334		device_set_input_line(state->m_cpu_1, 0, HOLD_LINE);
	334	state->m_cpu_1->execute().set_input_line(0, HOLD_LINE);
335	335	}
336	336
337	337
r17814	r17815
350	350	else
351	351	{
352	352	msm5205_data_w(device, state->m_adpcm_byte & 0xf);
353		device_set_input_line(state->m_cpu_1, 0, HOLD_LINE);
	353	state->m_cpu_1->execute().set_input_line(0, HOLD_LINE);
354	354	}
355	355
356	356	state->m_msm5205_vclk_toggle ^= 1;
r17814	r17815
371	371	WRITE8_MEMBER(jangou_state::master_com_w)
372	372	{
373	373
374		device_set_input_line(m_nsc, 0, HOLD_LINE);
	374	m_nsc->execute().set_input_line(0, HOLD_LINE);
375	375	m_nsc_latch = data;
376	376	}
377	377

trunk/src/mame/drivers/gameplan.c

r17814	r17815
138	138	WRITE8_MEMBER(gameplan_state::audio_reset_w)
139	139	{
140	140
141		device_set_input_line(m_audiocpu, INPUT_LINE_RESET, data ? CLEAR_LINE : ASSERT_LINE);
	141	m_audiocpu->set_input_line(INPUT_LINE_RESET, data ? CLEAR_LINE : ASSERT_LINE);
142	142
143	143	if (data == 0)
144	144	{
r17814	r17815
179	179
180	180	WRITE_LINE_MEMBER(gameplan_state::r6532_irq)
181	181	{
182		device_set_input_line(m_audiocpu, 0, state);
	182	m_audiocpu->set_input_line(0, state);
183	183	if (state == ASSERT_LINE)
184	184	machine().scheduler().boost_interleave(attotime::zero, attotime::from_usec(10));
185	185	}
r17814	r17815
977	977	{
978	978	gameplan_state *state = machine.driver_data<gameplan_state>();
979	979
980		state->m_maincpu = machine.device("maincpu");
981		state->m_audiocpu = machine.device("audiocpu");
	980	state->m_maincpu = machine.device<cpu_device>("maincpu");
	981	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
982	982	state->m_riot = machine.device("riot");
983	983
984	984	/* register for save states */

trunk/src/mame/drivers/darius.c

r17814	r17815
145	145	/* however this fails when recovering from a save state
146	146	if cpu B is disabled !! */
147	147	darius_state *state = machine.driver_data<darius_state>();
148		device_set_input_line(state->m_cpub, INPUT_LINE_RESET, (state->m_cpua_ctrl & 0x01) ? CLEAR_LINE : ASSERT_LINE);
	148	state->m_cpub->execute().set_input_line(INPUT_LINE_RESET, (state->m_cpua_ctrl & 0x01) ? CLEAR_LINE : ASSERT_LINE);
149	149	}
150	150
151	151	WRITE16_MEMBER(darius_state::cpua_ctrl_w)
r17814	r17815
504	504	darius_state *state = device->machine().driver_data<darius_state>();
505	505
506	506	if (state->m_nmi_enable)
507		device_set_input_line(state->m_adpcm, INPUT_LINE_NMI, PULSE_LINE);
	507	state->m_adpcm->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
508	508	}
509	509
510	510	static const msm5205_interface msm5205_config =
r17814	r17815
785	785	static void irqhandler( device_t *device, int irq )   /* assumes Z80 sandwiched between 68Ks */
786	786	{
787	787	darius_state *state = device->machine().driver_data<darius_state>();
788		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	788	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
789	789	}
790	790
791	791	static const ym2203_interface ym2203_interface_1 =
r17814	r17815
844	844	state->membank("bank1")->configure_entry(4, state->memregion("audiocpu")->base());
845	845	state->membank("bank1")->set_entry(4);
846	846
847		state->m_maincpu = machine.device("maincpu");
848		state->m_audiocpu = machine.device("audiocpu");
	847	state->m_maincpu = machine.device<cpu_device>("maincpu");
	848	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
849	849	state->m_cpub = machine.device("cpub");
850	850	state->m_adpcm = machine.device("adpcm");
851	851	state->m_pc080sn = machine.device("pc080sn");

trunk/src/mame/drivers/capbowl.c

r17814	r17815
108	108	static INTERRUPT_GEN( capbowl_interrupt )
109	109	{
110	110	if (device->machine().root_device().ioport("SERVICE")->read() & 1)                  /* get status of the F2 key */
111		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);   /* trigger self test */
	111	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);   /* trigger self test */
112	112	}
113	113
114	114
r17814	r17815
182	182
183	183	WRITE8_MEMBER(capbowl_state::capbowl_sndcmd_w)
184	184	{
185		device_set_input_line(m_audiocpu, M6809_IRQ_LINE, HOLD_LINE);
	185	m_audiocpu->set_input_line(M6809_IRQ_LINE, HOLD_LINE);
186	186	soundlatch_byte_w(space, offset, data);
187	187	}
188	188
r17814	r17815
198	198	static void firqhandler( device_t *device, int irq )
199	199	{
200	200	capbowl_state *state = device->machine().driver_data<capbowl_state>();
201		device_set_input_line(state->m_audiocpu, 1, irq ? ASSERT_LINE : CLEAR_LINE);
	201	state->m_audiocpu->set_input_line(1, irq ? ASSERT_LINE : CLEAR_LINE);
202	202	}
203	203
204	204
r17814	r17815
338	338	{
339	339	capbowl_state *state = machine.driver_data<capbowl_state>();
340	340
341		state->m_maincpu = machine.device("maincpu");
342		state->m_audiocpu = machine.device("audiocpu");
	341	state->m_maincpu = machine.device<cpu_device>("maincpu");
	342	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
343	343
344	344	state->save_item(NAME(state->m_blitter_addr));
345	345	state->save_item(NAME(state->m_last_trackball_val[0]));

trunk/src/mame/drivers/ikki.c

r17814	r17815
248	248
249	249	if(scanline == 240 || scanline == 120) // TODO: where non-timer IRQ happens?
250	250	{
251		device_set_input_line(state->m_maincpu,0,HOLD_LINE);
	251	state->m_maincpu->set_input_line(0,HOLD_LINE);
252	252
253	253	state->m_irq_source = (scanline != 240);
254	254	}

trunk/src/mame/drivers/kinst.c

r17814	r17815
283	283
284	284	static INTERRUPT_GEN( irq0_start )
285	285	{
286		device_set_input_line(device, 0, ASSERT_LINE);
	286	device->execute().set_input_line(0, ASSERT_LINE);
287	287	device->machine().scheduler().timer_set(attotime::from_usec(50), FUNC(irq0_stop));
288	288	}
289	289
r17814	r17815
363	363	case 4:      /* $a0 */
364	364	result = ioport(portnames[offset])->read();
365	365	if (space.device().safe_pc() == 0x802d428)
366		device_spin_until_interrupt(&space.device());
	366	space.device().execute().spin_until_interrupt();
367	367	break;
368	368	}
369	369

trunk/src/mame/drivers/st0016.c

r17814	r17815
423	423	int scanline = param;
424	424
425	425	if(scanline == 240)
426		device_set_input_line(state->m_maincpu,0,HOLD_LINE);
	426	state->m_maincpu->set_input_line(0,HOLD_LINE);
427	427	else if((scanline % 64) == 0)
428	428	if(state->m_maincpu->state_int(Z80_IFF1)) /* dirty hack ... */
429		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE );
	429	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE );
430	430	}
431	431
432	432	static const st0016_interface st0016_config =

trunk/src/mame/drivers/beathead.c

r17814	r17815
499	499	{
500	500	int result = *m_speedup_data;
501	501	if ((space.device().safe_pcbase() & 0xfffff) == 0x006f0 && result == space.device().state().state_int(ASAP_R3))
502		device_spin_until_interrupt(&space.device());
	502	space.device().execute().spin_until_interrupt();
503	503	return result;
504	504	}
505	505
r17814	r17815
512	512	{
513	513	UINT32 temp = (INT16)result + m_movie_speedup_data[4] * 262;
514	514	if (temp - (UINT32)space.device().state().state_int(ASAP_R15) < (UINT32)space.device().state().state_int(ASAP_R23))
515		device_spin_until_interrupt(&space.device());
	515	space.device().execute().spin_until_interrupt();
516	516	}
517	517	return result;
518	518	}

trunk/src/mame/drivers/sbasketb.c

r17814	r17815
52	52
53	53	WRITE8_MEMBER(sbasketb_state::sbasketb_sh_irqtrigger_w)
54	54	{
55		device_set_input_line_and_vector(machine().device<cpu_device>("audiocpu"), 0, HOLD_LINE, 0xff);
	55	machine().device<cpu_device>("audiocpu")->set_input_line_and_vector(0, HOLD_LINE, 0xff);
56	56	}
57	57
58	58	WRITE8_MEMBER(sbasketb_state::sbasketb_coin_counter_w)
r17814	r17815
181	181	sbasketb_state *state = device->machine().driver_data<sbasketb_state>();
182	182
183	183	if(state->m_irq_mask)
184		device_set_input_line(device, 0, HOLD_LINE);
	184	device->execute().set_input_line(0, HOLD_LINE);
185	185	}
186	186
187	187	//-------------------------------------------------

trunk/src/mame/drivers/lastbank.c

r17814	r17815
440	440
441	441	if (scanline == 240 && (state->m_irq_enable & 4))
442	442	{
443		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, state->m_irq_vector[2]);
	443	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, state->m_irq_vector[2]);
444	444	}
445	445
446	446	if (scanline == 0 && (state->m_irq_enable & 2))
447	447	{
448		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, state->m_irq_vector[1]);
	448	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, state->m_irq_vector[1]);
449	449	}
450	450	}
451	451

trunk/src/mame/drivers/skyarmy.c

r17814	r17815
158	158	{
159	159	skyarmy_state *state = device->machine().driver_data<skyarmy_state>();
160	160
161		if(state->m_nmi) device_set_input_line(device,INPUT_LINE_NMI, PULSE_LINE);
	161	if(state->m_nmi) device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
162	162	}
163	163
164	164

trunk/src/mame/drivers/himesiki.c

r17814	r17815
100	100	WRITE8_MEMBER(himesiki_state::himesiki_sound_w)
101	101	{
102	102	soundlatch_byte_w(space, offset, data);
103		device_set_input_line(m_subcpu, INPUT_LINE_NMI, PULSE_LINE);
	103	m_subcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
104	104	}
105	105
106	106	/****************************************************************************/
r17814	r17815
273	273
274	274	state->membank("bank1")->configure_entries(0, 2, &ROM[0x10000], 0x4000);
275	275
276		state->m_subcpu = machine.device("sub");
	276	state->m_subcpu = machine.device<cpu_device>("sub");
277	277
278	278	state->save_item(NAME(state->m_scrollx));
279	279	state->save_item(NAME(state->m_flipscreen));

trunk/src/mame/drivers/battlex.c

r17814	r17815
52	52	{
53	53	battlex_state *state = device->machine().driver_data<battlex_state>();
54	54	state->m_in0_b4 = 1;
55		device_set_input_line(device, 0, ASSERT_LINE);
	55	device->execute().set_input_line(0, ASSERT_LINE);
56	56	}
57	57
58	58	CUSTOM_INPUT_MEMBER(battlex_state::battlex_in0_b4_r)

trunk/src/mame/drivers/adp.c

r17814	r17815
173	173	struct { int r,g,b,offs,offs_internal; } m_pal;
174	174
175	175	/* devices */
176		device_t *m_maincpu;
	176	cpu_device *m_maincpu;
177	177	device_t *m_duart;
178	178	DECLARE_READ16_MEMBER(test_r);
179	179	DECLARE_WRITE16_MEMBER(wh2_w);
r17814	r17815
269	269	static void duart_irq_handler( device_t *device, int state, UINT8 vector )
270	270	{
271	271	adp_state *adp = device->machine().driver_data<adp_state>();
272		device_set_input_line_and_vector(adp->m_maincpu, 4, state, vector);
	272	adp->m_maincpu->set_input_line_and_vector(4, state, vector);
273	273	}
274	274
275	275	static void duart_tx( device_t *device, int channel, UINT8 data )
r17814	r17815
301	301	{
302	302	adp_state *state = machine.driver_data<adp_state>();
303	303
304		state->m_maincpu = machine.device("maincpu");
	304	state->m_maincpu = machine.device<cpu_device>("maincpu");
305	305	state->m_duart = machine.device("duart68681");
306	306	//state->m_h63484 = machine.device("h63484");
307	307
r17814	r17815
623	623	/*
624	624	static INTERRUPT_GEN( adp_int )
625	625	{
626		device_set_input_line(device, 1, HOLD_LINE); // ??? All irqs have the same vector, and the mask used is 0 or 7
	626	device->execute().set_input_line(1, HOLD_LINE); // ??? All irqs have the same vector, and the mask used is 0 or 7
627	627	}
628	628	*/
629	629	static const ay8910_interface ay8910_config =

trunk/src/mame/drivers/pcxt.c

r17814	r17815
719	719	device_t *speaker = machine.device("speaker");
720	720	state->m_bank = -1;
721	721	state->m_lastvalue = -1;
722		device_set_irq_callback(machine.device("maincpu"), irq_callback);
	722	machine.device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
723	723
724	724	state->m_pc_spkrdata = 0;
725	725	state->m_pc_input = 0;

trunk/src/mame/drivers/mcatadv.c

r17814	r17815
148	148	{
149	149
150	150	soundlatch_byte_w(space, 0, data);
151		device_set_input_line(m_soundcpu, INPUT_LINE_NMI, PULSE_LINE);
	151	m_soundcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
152	152	}
153	153
154	154	#if 0 // mcat only.. install read handler?
r17814	r17815
416	416	static void sound_irq( device_t *device, int irq )
417	417	{
418	418	mcatadv_state *state = device->machine().driver_data<mcatadv_state>();
419		device_set_input_line(state->m_soundcpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	419	state->m_soundcpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
420	420	}
421	421
422	422	static const ym2610_interface mcatadv_ym2610_interface =
r17814	r17815
433	433	state->membank("bank1")->configure_entries(0, 8, &ROM[0x10000], 0x4000);
434	434	state->membank("bank1")->set_entry(1);
435	435
436		state->m_maincpu = machine.device("maincpu");
437		state->m_soundcpu = machine.device("soundcpu");
	436	state->m_maincpu = machine.device<cpu_device>("maincpu");
	437	state->m_soundcpu = machine.device<cpu_device>("soundcpu");
438	438
439	439	state->save_item(NAME(state->m_palette_bank1));
440	440	state->save_item(NAME(state->m_palette_bank2));

trunk/src/mame/drivers/toaplan2.c

r17814	r17815
387	387	toaplan2_state *state = device->machine().driver_data<toaplan2_state>();
388	388
389	389	if (state->m_sub_cpu != NULL)
390		device_set_input_line(state->m_sub_cpu, INPUT_LINE_RESET, PULSE_LINE);
	390	state->m_sub_cpu->execute().set_input_line(INPUT_LINE_RESET, PULSE_LINE);
391	391	}
392	392
393	393
r17814	r17815
491	491	{
492	492	toaplan2_state *state = machine.driver_data<toaplan2_state>();
493	493
494		device_set_input_line(state->m_main_cpu, param, HOLD_LINE);
	494	state->m_main_cpu->execute().set_input_line(param, HOLD_LINE);
495	495	}
496	496
497	497	static void toaplan2_vblank_irq(running_machine &machine, int irq_line)
r17814	r17815
588	588
589	589	toaplan2_coin_w(space, offset, data & 0x0f);
590	590
591		device_set_input_line(m_sub_cpu, INPUT_LINE_RESET,  (data & m_v25_reset_line) ? CLEAR_LINE : ASSERT_LINE);
	591	m_sub_cpu->execute().set_input_line(INPUT_LINE_RESET,  (data & m_v25_reset_line) ? CLEAR_LINE : ASSERT_LINE);
592	592	}
593	593	if (ACCESSING_BITS_8_15 && (data & 0xff00) )
594	594	{
r17814	r17815
759	759	WRITE16_MEMBER(toaplan2_state::fixeight_subcpu_ctrl_w)
760	760	{
761	761
762		device_set_input_line(m_sub_cpu, INPUT_LINE_RESET, (data & m_v25_reset_line) ? CLEAR_LINE : ASSERT_LINE);
	762	m_sub_cpu->execute().set_input_line(INPUT_LINE_RESET, (data & m_v25_reset_line) ? CLEAR_LINE : ASSERT_LINE);
763	763	}
764	764
765	765
r17814	r17815
869	869	{
870	870
871	871	soundlatch_byte_w(space, offset, data & 0xff);
872		device_set_input_line(m_sub_cpu, 0, HOLD_LINE);
	872	m_sub_cpu->execute().set_input_line(0, HOLD_LINE);
873	873	}
874	874	}
875	875
r17814	r17815
927	927	{
928	928
929	929	soundlatch_byte_w(space, offset, data & 0xff);
930		device_set_input_line(m_sub_cpu, INPUT_LINE_NMI, ASSERT_LINE);
	930	m_sub_cpu->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
931	931	}
932	932	}
933	933
r17814	r17815
938	938	{
939	939
940	940	soundlatch2_byte_w(space, offset, data & 0xff);
941		device_set_input_line(m_sub_cpu, INPUT_LINE_NMI, ASSERT_LINE);
	941	m_sub_cpu->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
942	942	}
943	943	}
944	944
r17814	r17815
955	955
956	956	// not sure whether this is correct
957	957	// the 68K writes here during the sound IRQ handler, and nowhere else...
958		device_set_input_line(m_main_cpu, m_sndirq_line, CLEAR_LINE);
	958	m_main_cpu->execute().set_input_line(m_sndirq_line, CLEAR_LINE);
959	959	}
960	960
961	961
r17814	r17815
963	963	{
964	964
965	965	// if batrider_clear_sndirq_w() is correct, should this be ASSERT_LINE?
966		device_set_input_line(m_main_cpu, m_sndirq_line, HOLD_LINE);
	966	m_main_cpu->execute().set_input_line(m_sndirq_line, HOLD_LINE);
967	967	}
968	968
969	969
970	970	WRITE8_MEMBER(toaplan2_state::batrider_clear_nmi_w)
971	971	{
972	972
973		device_set_input_line(m_sub_cpu, INPUT_LINE_NMI, CLEAR_LINE);
	973	m_sub_cpu->execute().set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
974	974	}
975	975
976	976
r17814	r17815
1023	1023
1024	1024	static INTERRUPT_GEN( bbakraid_snd_interrupt )
1025	1025	{
1026		device_set_input_line(device, 0, HOLD_LINE);
	1026	device->execute().set_input_line(0, HOLD_LINE);
1027	1027	}
1028	1028
1029	1029
r17814	r17815
3005	3005	toaplan2_state *state = device->machine().driver_data<toaplan2_state>();
3006	3006
3007	3007	if (state->m_sub_cpu != NULL)      // wouldn't tekipaki have problem without this? "mcu" is not generally added
3008		device_set_input_line(state->m_sub_cpu, 0, linestate);
	3008	state->m_sub_cpu->execute().set_input_line(0, linestate);
3009	3009	}
3010	3010
3011	3011	static const ym3812_interface ym3812_config =

trunk/src/mame/drivers/mjkjidai.c

r17814	r17815
420	420	mjkjidai_state *state = device->machine().driver_data<mjkjidai_state>();
421	421
422	422	if(state->m_nmi_mask)
423		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	423	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
424	424	}
425	425
426	426

trunk/src/mame/drivers/jailbrek.c

r17814	r17815
105	105	jailbrek_state *state = device->machine().driver_data<jailbrek_state>();
106	106
107	107	if (state->m_irq_enable)
108		device_set_input_line(device, 0, HOLD_LINE);
	108	device->execute().set_input_line(0, HOLD_LINE);
109	109	}
110	110
111	111	static INTERRUPT_GEN( jb_interrupt_nmi )
r17814	r17815
113	113	jailbrek_state *state = device->machine().driver_data<jailbrek_state>();
114	114
115	115	if (state->m_nmi_enable)
116		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	116	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
117	117	}
118	118
119	119

trunk/src/mame/drivers/su2000.c

r17814	r17815
279	279	space->install_write_bank(0x100000, ram_limit - 1, "hma_bank");
280	280	state->membank("hma_bank")->set_base(state->m_pc_ram + 0xa0000);
281	281
282		device_set_irq_callback(machine.device("maincpu"), pc_irq_callback);
	282	machine.device("maincpu")->execute().set_irq_acknowledge_callback(pc_irq_callback);
283	283
284	284	init_pc_common(machine, PCCOMMON_KEYBOARD_AT, su2000_set_keyb_int);
285	285

trunk/src/mame/drivers/gaelco.c

r17814	r17815
37	37	if (ACCESSING_BITS_0_7)
38	38	{
39	39	soundlatch_byte_w(space, 0, data & 0xff);
40		device_set_input_line(m_audiocpu, M6809_FIRQ_LINE, HOLD_LINE);
	40	m_audiocpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
41	41	}
42	42	}
43	43
r17814	r17815
499	499	{
500	500	gaelco_state *state = machine.driver_data<gaelco_state>();
501	501
502		state->m_audiocpu = machine.device("audiocpu");
	502	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
503	503	}
504	504
505	505	static MACHINE_CONFIG_START( bigkarnk, gaelco_state )

trunk/src/mame/drivers/zac_1.c

r17814	r17815
163	163
164	164	WRITE8_MEMBER( zac_1_state::reset_int_w )
165	165	{
166		device_set_input_line(m_maincpu, INPUT_LINE_IRQ0, CLEAR_LINE);
	166	m_maincpu->set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
167	167	}
168	168
169	169	READ8_MEMBER( zac_1_state::serial_r )
r17814	r17815
199	199	if (state->m_t_c > 0x40)
200	200	{
201	201	UINT8 vector = (state->ioport("TEST")->read() ) ? 0x10 : 0x18;
202		device_set_input_line_and_vector(state->m_maincpu, INPUT_LINE_IRQ0, ASSERT_LINE, vector);
	202	state->m_maincpu->set_input_line_and_vector(INPUT_LINE_IRQ0, ASSERT_LINE, vector);
203	203	}
204	204	else
205	205	state->m_t_c++;
r17814	r17815
253	253
254	254	READ8_MEMBER( zac_1_state::reset_int_r )
255	255	{
256		device_set_input_line(m_maincpu, INPUT_LINE_IRQ0, CLEAR_LINE);
	256	m_maincpu->set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
257	257	return 0;
258	258	}
259	259

trunk/src/mame/drivers/crbaloon.c

r17814	r17815
361	361	crbaloon_state *state = device->machine().driver_data<crbaloon_state>();
362	362
363	363	if(state->m_irq_mask)
364		device_set_input_line(device, 0, HOLD_LINE);
	364	device->execute().set_input_line(0, HOLD_LINE);
365	365	}
366	366
367	367

trunk/src/mame/drivers/kas89.c

r17814	r17815
214	214	UINT8 m_leds_mux_data;
215	215	UINT8 m_outdata;         /* Muxed with the sound latch. Output to a sign? */
216	216
217		device_t *m_maincpu;
218		device_t *m_audiocpu;
	217	cpu_device *m_maincpu;
	218	cpu_device *m_audiocpu;
219	219
220	220	required_device<v9938_device> m_v9938;
221	221	DECLARE_WRITE8_MEMBER(mux_w);
r17814	r17815
257	257	static MACHINE_START( kas89 )
258	258	{
259	259	kas89_state *state = machine.driver_data<kas89_state>();
260		state->m_maincpu = machine.device("maincpu");
261		state->m_audiocpu = machine.device("audiocpu");
	260	state->m_maincpu = machine.device<cpu_device>("maincpu");
	261	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
262	262
263	263	output_set_lamp_value(37, 0);   /* turning off the operator led */
264	264	}
r17814	r17815
315	315	kas89_state *state = timer.machine().driver_data<kas89_state>();
316	316
317	317	if (state->m_main_nmi_enable)
318		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	318	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
319	319	}
320	320
321	321	static TIMER_DEVICE_CALLBACK ( kas89_sound_nmi_cb )
322	322	{
323	323	kas89_state *state = timer.machine().driver_data<kas89_state>();
324	324
325		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	325	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
326	326	}
327	327
328	328
r17814	r17815
379	379	else
380	380	{
381	381	soundlatch_byte_w(space, 0, data);
382		device_set_input_line(m_audiocpu, 0, ASSERT_LINE );
	382	m_audiocpu->set_input_line(0, ASSERT_LINE );
383	383	}
384	384	}
385	385
386	386	WRITE8_MEMBER(kas89_state::int_ack_w)
387	387	{
388		device_set_input_line(m_audiocpu, 0, CLEAR_LINE );
	388	m_audiocpu->set_input_line(0, CLEAR_LINE );
389	389	}
390	390
391	391

trunk/src/mame/drivers/munchmo.c

r17814	r17815
46	46	munchmo_state *state = device->machine().driver_data<munchmo_state>();
47	47
48	48	if (state->m_nmi_enable)
49		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	49	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
50	50
51		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	51	state->m_maincpu->set_input_line(0, HOLD_LINE);
52	52	}
53	53
54	54	static INTERRUPT_GEN( mnchmobl_sound_irq )
55	55	{
56	56	//munchmo_state *state = device->machine().driver_data<munchmo_state>();
57	57
58		device_set_input_line(device, INPUT_LINE_NMI, ASSERT_LINE);
	58	device->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
59	59	}
60	60
61	61	WRITE8_MEMBER(munchmo_state::mnchmobl_soundlatch_w)
62	62	{
63	63
64	64	soundlatch_byte_w(space, 0, data);
65		device_set_input_line(m_audiocpu, 0, HOLD_LINE );
	65	m_audiocpu->set_input_line(0, HOLD_LINE );
66	66	}
67	67
68	68
69	69	WRITE8_MEMBER(munchmo_state::sound_nmi_ack_w)
70	70	{
71		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, CLEAR_LINE);
	71	m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
72	72	}
73	73
74	74	READ8_MEMBER(munchmo_state::munchmo_ay1reset_r)
r17814	r17815
310	310	{
311	311	munchmo_state *state = machine.driver_data<munchmo_state>();
312	312
313		state->m_maincpu = machine.device("maincpu");
314		state->m_audiocpu = machine.device("audiocpu");
	313	state->m_maincpu = machine.device<cpu_device>("maincpu");
	314	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
315	315
316	316	state->save_item(NAME(state->m_palette_bank));
317	317	state->save_item(NAME(state->m_flipscreen));

trunk/src/mame/drivers/voyager.c

r17814	r17815
653	653	static MACHINE_START(voyager)
654	654	{
655	655	voyager_state *state = machine.driver_data<voyager_state>();
656		device_set_irq_callback(machine.device("maincpu"), irq_callback);
	656	machine.device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
657	657
658	658	state->m_pit8254 = machine.device( "pit8254" );
659	659	state->m_pic8259_1 = machine.device( "pic8259_1" );

trunk/src/mame/drivers/lastduel.c

r17814	r17815
442	442	static void irqhandler( device_t *device, int irq )
443	443	{
444	444	lastduel_state *state = device->machine().driver_data<lastduel_state>();
445		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	445	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
446	446	}
447	447
448	448	static const ym2203_interface ym2203_config =
r17814	r17815
459	459	{
460	460	lastduel_state *state = timer.machine().driver_data<lastduel_state>();
461	461
462		device_set_input_line(state->m_maincpu, 4, HOLD_LINE); /* Controls */
	462	state->m_maincpu->set_input_line(4, HOLD_LINE); /* Controls */
463	463	}
464	464
465	465	static TIMER_DEVICE_CALLBACK( madgear_timer_cb )
466	466	{
467	467	lastduel_state *state = timer.machine().driver_data<lastduel_state>();
468	468
469		device_set_input_line(state->m_maincpu, 6, HOLD_LINE); /* Controls */
	469	state->m_maincpu->set_input_line(6, HOLD_LINE); /* Controls */
470	470	}
471	471
472	472	static MACHINE_START( lastduel )

trunk/src/mame/drivers/drgnmst.c

r17814	r17815
54	54	if (ACCESSING_BITS_0_7)
55	55	{
56	56	m_snd_command = (data & 0xff);
57		device_yield(&space.device());
	57	space.device().execute().yield();
58	58	}
59	59	}
60	60

trunk/src/mame/drivers/cmmb.c

r17814	r17815
303	303	{
304	304	//if(device->machine().input().code_pressed_once(KEYCODE_Z))
305	305	//if(device->machine().input().code_pressed(KEYCODE_Z))
306		//      device_set_input_line(device, 0, HOLD_LINE);
	306	//      device->execute().set_input_line(0, HOLD_LINE);
307	307	}
308	308
309	309	static MACHINE_RESET( cmmb )

trunk/src/mame/drivers/boxer.c

r17814	r17815
37	37	UINT8 m_pot_latch;
38	38
39	39	/* devices */
40		device_t *m_maincpu;
	40	cpu_device *m_maincpu;
41	41	DECLARE_READ8_MEMBER(boxer_input_r);
42	42	DECLARE_READ8_MEMBER(boxer_misc_r);
43	43	DECLARE_WRITE8_MEMBER(boxer_bell_w);
r17814	r17815
60	60	int mask = param;
61	61
62	62	if (state->m_pot_latch & mask)
63		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, ASSERT_LINE);
	63	state->m_maincpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
64	64
65	65	state->m_pot_state |= mask;
66	66	}
r17814	r17815
71	71	boxer_state *state = machine.driver_data<boxer_state>();
72	72	int scanline = param;
73	73
74		device_set_input_line(state->m_maincpu, 0, ASSERT_LINE);
	74	state->m_maincpu->set_input_line(0, ASSERT_LINE);
75	75
76	76	if (scanline == 0)
77	77	{
r17814	r17815
262	262
263	263	m_pot_latch = data & 0x3f;
264	264
265		device_set_input_line(m_maincpu, INPUT_LINE_NMI, CLEAR_LINE);
	265	m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
266	266	}
267	267
268	268
269	269	WRITE8_MEMBER(boxer_state::boxer_irq_reset_w)
270	270	{
271		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	271	m_maincpu->set_input_line(0, CLEAR_LINE);
272	272	}
273	273
274	274
r17814	r17815
426	426	{
427	427	boxer_state *state = machine.driver_data<boxer_state>();
428	428
429		state->m_maincpu = machine.device("maincpu");
	429	state->m_maincpu = machine.device<cpu_device>("maincpu");
430	430
431	431	state->save_item(NAME(state->m_pot_state));
432	432	state->save_item(NAME(state->m_pot_latch));

trunk/src/mame/drivers/freekick.c

r17814	r17815
80	80	{
81	81	freekick_state *state = device->machine().driver_data<freekick_state>();
82	82	if (state->m_nmi_en)
83		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	83	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
84	84	}
85	85
86	86	WRITE8_MEMBER(freekick_state::oigas_5_w)

trunk/src/mame/drivers/redclash.c

r17814	r17815
28	28	static WRITE8_HANDLER( irqack_w )
29	29	{
30	30	ladybug_state *state = space->machine().driver_data<ladybug_state>();
31		device_set_input_line(state->m_maincpu, 0, CLEAR_LINE);
	31	state->m_maincpu->set_input_line(0, CLEAR_LINE);
32	32	}
33	33
34	34	static ADDRESS_MAP_START( zerohour_map, AS_PROGRAM, 8, ladybug_state )
r17814	r17815
79	79	INPUT_CHANGED_MEMBER( ladybug_state::left_coin_inserted )
80	80	{
81	81	if(newval)
82		device_set_input_line(m_maincpu, 0, ASSERT_LINE);
	82	m_maincpu->set_input_line(0, ASSERT_LINE);
83	83	}
84	84
85	85	INPUT_CHANGED_MEMBER( ladybug_state::right_coin_inserted )
86	86	{
87	87	if(newval)
88		device_set_input_line(m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	88	m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
89	89	}
90	90
91	91	static INPUT_PORTS_START( redclash )
r17814	r17815
328	328	{
329	329	ladybug_state *state = machine.driver_data<ladybug_state>();
330	330
331		state->m_maincpu = machine.device("maincpu");
	331	state->m_maincpu = machine.device<cpu_device>("maincpu");
332	332
333	333	state->save_item(NAME(state->m_star_speed));
334	334	state->save_item(NAME(state->m_gfxbank));

trunk/src/mame/drivers/wgp.c

r17814	r17815
419	419	/* however this fails when recovering from a save state
420	420	if cpu B is disabled !! */
421	421	wgp_state *state = machine.driver_data<wgp_state>();
422		device_set_input_line(state->m_subcpu, INPUT_LINE_RESET, (state->m_cpua_ctrl & 0x1) ? CLEAR_LINE : ASSERT_LINE);
	422	state->m_subcpu->set_input_line(INPUT_LINE_RESET, (state->m_cpua_ctrl & 0x1) ? CLEAR_LINE : ASSERT_LINE);
423	423
424	424	/* bit 1 is "vibration" acc. to test mode */
425	425	}
r17814	r17815
447	447	static TIMER_CALLBACK( wgp_interrupt4 )
448	448	{
449	449	wgp_state *state = machine.driver_data<wgp_state>();
450		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	450	state->m_maincpu->set_input_line(4, HOLD_LINE);
451	451	}
452	452	#endif
453	453
454	454	static TIMER_CALLBACK( wgp_interrupt6 )
455	455	{
456	456	wgp_state *state = machine.driver_data<wgp_state>();
457		device_set_input_line(state->m_maincpu, 6, HOLD_LINE);
	457	state->m_maincpu->set_input_line(6, HOLD_LINE);
458	458	}
459	459
460	460	/* 68000 B */
r17814	r17815
462	462	static TIMER_CALLBACK( wgp_cpub_interrupt6 )
463	463	{
464	464	wgp_state *state = machine.driver_data<wgp_state>();
465		device_set_input_line(state->m_subcpu, 6, HOLD_LINE);   /* assumes Z80 sandwiched between the 68Ks */
	465	state->m_subcpu->set_input_line(6, HOLD_LINE);   /* assumes Z80 sandwiched between the 68Ks */
466	466	}
467	467
468	468
r17814	r17815
475	475	static INTERRUPT_GEN( wgp_cpub_interrupt )
476	476	{
477	477	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(200000-500), FUNC(wgp_cpub_interrupt6));
478		device_set_input_line(device, 4, HOLD_LINE);
	478	device->execute().set_input_line(4, HOLD_LINE);
479	479	}
480	480
481	481
r17814	r17815
899	899	static void irqhandler( device_t *device, int irq )   // assumes Z80 sandwiched between 68Ks
900	900	{
901	901	wgp_state *state = device->machine().driver_data<wgp_state>();
902		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	902	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
903	903	}
904	904
905	905	static const ym2610_interface ym2610_config =
r17814	r17815
948	948
949	949	state->membank("bank10")->configure_entries(0, 4, state->memregion("audiocpu")->base() + 0xc000, 0x4000);
950	950
951		state->m_maincpu = machine.device("maincpu");
952		state->m_audiocpu = machine.device("audiocpu");
953		state->m_subcpu = machine.device("sub");
	951	state->m_maincpu = machine.device<cpu_device>("maincpu");
	952	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
	953	state->m_subcpu = machine.device<cpu_device>("sub");
954	954	state->m_tc0140syt = machine.device("tc0140syt");
955	955	state->m_tc0100scn = machine.device("tc0100scn");
956	956

trunk/src/mame/drivers/scregg.c

r17814	r17815
72	72	{
73	73	// assume that the irq generator is similar to burgertime hw
74	74	scregg_state *state = timer.machine().driver_data<scregg_state>();
75		device_set_input_line(state->m_maincpu, 0, (param & 8) ? ASSERT_LINE : CLEAR_LINE);
	75	state->m_maincpu->set_input_line(0, (param & 8) ? ASSERT_LINE : CLEAR_LINE);
76	76	}
77	77
78	78	WRITE8_MEMBER(scregg_state::scregg_irqack_w)
79	79	{
80		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	80	m_maincpu->set_input_line(0, CLEAR_LINE);
81	81	}
82	82
83	83	READ8_MEMBER(scregg_state::scregg_irqack_r)
84	84	{
85		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	85	m_maincpu->set_input_line(0, CLEAR_LINE);
86	86	return 0;
87	87	}
88	88
r17814	r17815
235	235	{
236	236	scregg_state *state = machine.driver_data<scregg_state>();
237	237
238		state->m_maincpu = machine.device("maincpu");
	238	state->m_maincpu = machine.device<cpu_device>("maincpu");
239	239	state->m_audiocpu = NULL;
240	240
241	241	state->save_item(NAME(state->m_btime_palette));

trunk/src/mame/drivers/taitoair.c

r17814	r17815
238	238
239	239	m_dsp_hold_signal = (data & 4) ? CLEAR_LINE : ASSERT_LINE;
240	240
241		device_set_input_line(m_dsp, INPUT_LINE_RESET, (data & 1) ? CLEAR_LINE : ASSERT_LINE);
	241	m_dsp->execute().set_input_line(INPUT_LINE_RESET, (data & 1) ? CLEAR_LINE : ASSERT_LINE);
242	242
243	243	logerror("68K:%06x writing %04x to TMS32025.  %s HOLD , %s RESET\n", space.device().safe_pcbase(), data, ((data & 4) ? "Clear" : "Assert"), ((data & 1) ? "Clear" : "Assert"));
244	244	}
r17814	r17815
635	635	static void irqhandler( device_t *device, int irq )
636	636	{
637	637	taitoair_state *state = device->machine().driver_data<taitoair_state>();
638		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	638	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
639	639	}
640	640
641	641	static const ym2610_interface airsys_ym2610_interface =
r17814	r17815
674	674
675	675	state->membank("bank1")->configure_entries(0, 4, &ROM[0xc000], 0x4000);
676	676
677		state->m_audiocpu = machine.device("audiocpu");
	677	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
678	678	state->m_dsp = machine.device("dsp");
679	679	state->m_tc0080vco = machine.device("tc0080vco");
680	680

trunk/src/mame/drivers/tceptor.c

r17814	r17815
41	41	{
42	42	tceptor_state *state = device->machine().driver_data<tceptor_state>();
43	43	if (state->m_m6809_irq_enable)
44		device_set_input_line(device, 0, HOLD_LINE);
	44	device->execute().set_input_line(0, HOLD_LINE);
45	45	else
46	46	state->m_m6809_irq_enable = 1;
47	47	}
r17814	r17815
61	61	{
62	62	tceptor_state *state = device->machine().driver_data<tceptor_state>();
63	63	if (state->m_m68k_irq_enable)
64		device_set_input_line(device, M68K_IRQ_1, HOLD_LINE);
	64	device->execute().set_input_line(M68K_IRQ_1, HOLD_LINE);
65	65	}
66	66
67	67	WRITE16_MEMBER(tceptor_state::m68k_irq_enable_w)
r17814	r17815
74	74	{
75	75	tceptor_state *state = device->machine().driver_data<tceptor_state>();
76	76	if (state->m_mcu_irq_enable)
77		device_set_input_line(device, 0, HOLD_LINE);
	77	device->execute().set_input_line(0, HOLD_LINE);
78	78	else
79	79	state->m_mcu_irq_enable = 1;
80	80	}

trunk/src/mame/drivers/aquarium.c

r17814	r17815
63	63	//  popmessage("sound write %04x",data);
64	64
65	65	soundlatch_byte_w(space, 1, data & 0xff);
66		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE );
	66	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE );
67	67	}
68	68
69	69	WRITE8_MEMBER(aquarium_state::aquarium_z80_bank_w)
r17814	r17815
291	291	static void irq_handler( device_t *device, int irq )
292	292	{
293	293	aquarium_state *state = device->machine().driver_data<aquarium_state>();
294		device_set_input_line(state->m_audiocpu, 0 , irq ? ASSERT_LINE : CLEAR_LINE);
	294	state->m_audiocpu->set_input_line(0 , irq ? ASSERT_LINE : CLEAR_LINE);
295	295	}
296	296
297	297	static const ym2151_interface ym2151_config =
r17814	r17815
304	304	{
305	305	aquarium_state *state = machine.driver_data<aquarium_state>();
306	306
307		state->m_audiocpu = machine.device("audiocpu");
	307	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
308	308
309	309	state->save_item(NAME(state->m_aquarium_snd_ack));
310	310	}

trunk/src/mame/drivers/metro.c

r17814	r17815
149	149	irq_level[state->m_irq_levels[i] & 7] = 1;
150	150
151	151	for (i = 0; i < 8; i++)
152		device_set_input_line(state->m_maincpu, i, irq_level[i] ? ASSERT_LINE : CLEAR_LINE);
	152	state->m_maincpu->set_input_line(i, irq_level[i] ? ASSERT_LINE : CLEAR_LINE);
153	153	}
154	154	else
155	155	{
r17814	r17815
157	157	then reads the actual source by peeking a register (metro_irq_cause_r) */
158	158
159	159	int irq_state = (irq ? ASSERT_LINE : CLEAR_LINE);
160		device_set_input_line(state->m_maincpu, state->m_irq_line, irq_state);
	160	state->m_maincpu->set_input_line(state->m_irq_line, irq_state);
161	161	}
162	162	}
163	163
r17814	r17815
245	245	state->m_requested_int[state->m_vblank_bit] = 1;
246	246	update_irq_state(device->machine());
247	247
248		device_set_input_line(state->m_maincpu, H8_METRO_TIMER_HACK, HOLD_LINE);
	248	state->m_maincpu->set_input_line(H8_METRO_TIMER_HACK, HOLD_LINE);
249	249	}
250	250
251	251	static void ymf278b_interrupt( device_t *device, int active )
252	252	{
253	253	metro_state *state = device->machine().driver_data<metro_state>();
254		device_set_input_line(state->m_maincpu, 2, active);
	254	state->m_maincpu->set_input_line(2, active);
255	255	}
256	256
257	257
r17814	r17815
288	288	if (ACCESSING_BITS_0_7)
289	289	{
290	290	soundlatch_byte_w(space, 0, data & 0xff);
291		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
292		device_spin_until_interrupt(&space.device());
	291	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
	292	space.device().execute().spin_until_interrupt();
293	293	m_busy_sndcpu = 1;
294	294	}
295	295	}
r17814	r17815
445	445	static void metro_sound_irq_handler( device_t *device, int state )
446	446	{
447	447	metro_state *driver_state = device->machine().driver_data<metro_state>();
448		device_set_input_line(driver_state->m_audiocpu, UPD7810_INTF2, state ? ASSERT_LINE : CLEAR_LINE);
	448	driver_state->m_audiocpu->set_input_line(UPD7810_INTF2, state ? ASSERT_LINE : CLEAR_LINE);
449	449	}
450	450
451	451	static const ym2151_interface ym2151_config =
r17814	r17815
1610	1610	{
1611	1611
1612	1612	soundlatch_byte_w(space, offset, data >> 8);
1613		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	1613	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
1614	1614	}
1615	1615
1616	1616	WRITE8_MEMBER(metro_state::blzntrnd_sh_bankswitch_w)
r17814	r17815
1625	1625	static void blzntrnd_irqhandler(device_t *device, int irq)
1626	1626	{
1627	1627	metro_state *state = device->machine().driver_data<metro_state>();
1628		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	1628	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
1629	1629	}
1630	1630
1631	1631	static const ym2610_interface blzntrnd_ym2610_interface =
r17814	r17815
3408	3408	metro_state *state = machine.driver_data<metro_state>();
3409	3409
3410	3410	if (state->m_irq_line == -1)
3411		device_set_irq_callback(machine.device("maincpu"), metro_irq_callback);
	3411	machine.device("maincpu")->execute().set_irq_acknowledge_callback(metro_irq_callback);
3412	3412	}
3413	3413
3414	3414

trunk/src/mame/drivers/angelkds.c

r17814	r17815
510	510	static void irqhandler( device_t *device, int irq )
511	511	{
512	512	angelkds_state *state = device->machine().driver_data<angelkds_state>();
513		device_set_input_line(state->m_subcpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	513	state->m_subcpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
514	514	}
515	515
516	516	static const ym2203_interface ym2203_config =
r17814	r17815
572	572	{
573	573	angelkds_state *state = machine.driver_data<angelkds_state>();
574	574
575		state->m_subcpu = machine.device("sub");
	575	state->m_subcpu = machine.device<cpu_device>("sub");
576	576
577	577	state->save_item(NAME(state->m_layer_ctrl));
578	578	state->save_item(NAME(state->m_txbank));

trunk/src/mame/drivers/jrpacman.c

r17814	r17815
118	118
119	119	WRITE8_MEMBER(jrpacman_state::jrpacman_interrupt_vector_w)
120	120	{
121		device_set_input_line_vector(machine().device("maincpu"), 0, data);
	121	machine().device("maincpu")->execute().set_input_line_vector(0, data);
122	122	machine().device("maincpu")->execute().set_input_line(0, CLEAR_LINE);
123	123	}
124	124
r17814	r17815
285	285	jrpacman_state *state = device->machine().driver_data<jrpacman_state>();
286	286
287	287	if(state->m_irq_mask)
288		device_set_input_line(device, 0, HOLD_LINE);
	288	device->execute().set_input_line(0, HOLD_LINE);
289	289	}
290	290
291	291	static MACHINE_CONFIG_START( jrpacman, jrpacman_state )

trunk/src/mame/drivers/nightgal.c

r17814	r17815
48	48	required_shared_ptr<UINT8> m_comms_ram;
49	49
50	50	/* devices */
51		device_t *m_maincpu;
52		device_t *m_subcpu;
	51	cpu_device *m_maincpu;
	52	cpu_device *m_subcpu;
53	53
54	54	/* memory */
55	55	UINT8      m_blit_buffer[256*256];
r17814	r17815
246	246	count++;
247	247	}
248	248	}
249		//device_set_input_line(m_maincpu, INPUT_LINE_NMI, PULSE_LINE );
	249	//m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE );
250	250	}
251	251	}
252	252	}
r17814	r17815
322	322	#ifdef UNUSED_CODE
323	323	WRITE8_MEMBER(nightgal_state::nsc_latch_w)
324	324	{
325		device_set_input_line(m_subcpu, 0, HOLD_LINE );
	325	m_subcpu->set_input_line(0, HOLD_LINE );
326	326	}
327	327
328	328	READ8_MEMBER(nightgal_state::nsc_latch_r)
r17814	r17815
369	369	WRITE8_MEMBER(nightgal_state::royalqn_blitter_2_w)
370	370	{
371	371	m_blit_raw_data[2] = data;
372		device_set_input_line(m_subcpu, 0, ASSERT_LINE );
	372	m_subcpu->set_input_line(0, ASSERT_LINE );
373	373	}
374	374
375	375	READ8_MEMBER(nightgal_state::royalqn_nsc_blit_r)
376	376	{
377	377
378	378	if(offset == 2)
379		device_set_input_line(m_subcpu, 0, CLEAR_LINE );
	379	m_subcpu->set_input_line(0, CLEAR_LINE );
380	380
381	381	return m_blit_raw_data[offset];
382	382	}
r17814	r17815
834	834	{
835	835	nightgal_state *state = machine.driver_data<nightgal_state>();
836	836
837		state->m_maincpu = machine.device("maincpu");
838		state->m_subcpu = machine.device("sub");
	837	state->m_maincpu = machine.device<cpu_device>("maincpu");
	838	state->m_subcpu = machine.device<cpu_device>("sub");
839	839
840	840	state->save_item(NAME(state->m_nsc_latch));
841	841	state->save_item(NAME(state->m_z80_latch));

trunk/src/mame/drivers/surpratk.c

r17814	r17815
22	22	{
23	23	surpratk_state *state = device->machine().driver_data<surpratk_state>();
24	24	if (k052109_is_irq_enabled(state->m_k052109))
25		device_set_input_line(device, 0, HOLD_LINE);
	25	device->execute().set_input_line(0, HOLD_LINE);
26	26	}
27	27
28	28	READ8_MEMBER(surpratk_state::bankedram_r)
r17814	r17815
161	161	static void irqhandler( device_t *device, int linestate )
162	162	{
163	163	surpratk_state *state = device->machine().driver_data<surpratk_state>();
164		device_set_input_line(state->m_maincpu, KONAMI_FIRQ_LINE, linestate);
	164	state->m_maincpu->set_input_line(KONAMI_FIRQ_LINE, linestate);
165	165	}
166	166
167	167	static const ym2151_interface ym2151_config =
r17814	r17815
199	199
200	200	state->m_generic_paletteram_8.allocate(0x1000);
201	201
202		state->m_maincpu = machine.device("maincpu");
	202	state->m_maincpu = machine.device<cpu_device>("maincpu");
203	203	state->m_k053244 = machine.device("k053244");
204	204	state->m_k053251 = machine.device("k053251");
205	205	state->m_k052109 = machine.device("k052109");

trunk/src/mame/drivers/zaccaria.c

r17814	r17815
575	575	zaccaria_state *state = device->machine().driver_data<zaccaria_state>();
576	576
577	577	if(state->m_nmi_mask)
578		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	578	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
579	579	}
580	580
581	581

trunk/src/mame/drivers/littlerb.c

r17814	r17815
587	587	//  logerror("IRQ\n");
588	588	if(scanline == 288)
589	589	{
590		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	590	state->m_maincpu->set_input_line(4, HOLD_LINE);
591	591	}
592	592	}
593	593

trunk/src/mame/drivers/tagteam.c

r17814	r17815
200	200	tagteam_state *state = device->machine().driver_data<tagteam_state>();
201	201
202	202	if(state->m_sound_nmi_mask)
203		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	203	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
204	204	}
205	205
206	206

trunk/src/mame/drivers/chihiro.c

r17814	r17815
1810	1810	chst->smbus_register_device(0x10,smbus_callback_pic16lc);
1811	1811	chst->smbus_register_device(0x45,smbus_callback_cx25871);
1812	1812	chst->smbus_register_device(0x54,smbus_callback_eeprom);
1813		device_set_irq_callback(machine.device("maincpu"), irq_callback);
	1813	machine.device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
1814	1814	chst->chihiro_devs.pic8259_1 = machine.device( "pic8259_1" );
1815	1815	chst->chihiro_devs.pic8259_2 = machine.device( "pic8259_2" );
1816	1816	chst->chihiro_devs.ide = machine.device( "ide" );

trunk/src/mame/drivers/namcos23.c

r17814	r17815
1711	1711	case 5:
1712	1712	if(m_ctl_vbl_active) {
1713	1713	m_ctl_vbl_active = false;
1714		device_set_input_line(&space.device(), MIPS3_IRQ0, CLEAR_LINE);
	1714	space.device().execute().set_input_line(MIPS3_IRQ0, CLEAR_LINE);
1715	1715	}
1716	1716	break;
1717	1717
r17814	r17815
2437	2437
2438	2438	if(!state->m_ctl_vbl_active) {
2439	2439	state->m_ctl_vbl_active = true;
2440		device_set_input_line(device, MIPS3_IRQ0, ASSERT_LINE);
	2440	device->execute().set_input_line(MIPS3_IRQ0, ASSERT_LINE);
2441	2441	}
2442	2442
2443	2443	render.cur = !render.cur;

trunk/src/mame/drivers/commando.c

r17814	r17815
218	218
219	219	static INTERRUPT_GEN( commando_interrupt )
220	220	{
221		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0xd7);   // RST 10h - VBLANK
	221	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0xd7);   // RST 10h - VBLANK
222	222	}
223	223
224	224	/* Machine Driver */
r17814	r17815
227	227	{
228	228	commando_state *state = machine.driver_data<commando_state>();
229	229
230		state->m_audiocpu = machine.device("audiocpu");
	230	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
231	231
232	232	state->save_item(NAME(state->m_scroll_x));
233	233	state->save_item(NAME(state->m_scroll_y));

trunk/src/mame/drivers/skydiver.c

r17814	r17815
156	156	discrete_sound_w(discrete, SKYDIVER_NOISE_DATA,  state->m_videoram[0x396] & 0x0f);   // NAM - Noise Amplitude
157	157
158	158	if (state->m_nmion)
159		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	159	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
160	160	}
161	161
162	162

trunk/src/mame/drivers/ninjakd2.c

r17814	r17815
168	168
169	169	static INTERRUPT_GEN( ninjakd2_interrupt )
170	170	{
171		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0xd7);   /* RST 10h */
	171	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0xd7);   /* RST 10h */
172	172	}
173	173
174	174

trunk/src/mame/drivers/mjsister.c

r17814	r17815
43	43	UINT32 m_dac_busy;
44	44
45	45	/* devices */
46		device_t *m_maincpu;
	46	cpu_device *m_maincpu;
47	47	dac_device *m_dac;
48	48
49	49	/* memory */
r17814	r17815
453	453
454	454	state->membank("bank1")->configure_entries(0, 4, &ROM[0x10000], 0x8000);
455	455
456		state->m_maincpu = machine.device("maincpu");
	456	state->m_maincpu = machine.device<cpu_device>("maincpu");
457	457	state->m_dac = machine.device<dac_device>("dac");
458	458
459	459	state->save_item(NAME(state->m_dac_busy));

trunk/src/mame/drivers/yunsung8.c

r17814	r17815
454	454
455	455	state->m_toggle ^= 1;
456	456	if (state->m_toggle)
457		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	457	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
458	458	}
459	459
460	460	static const msm5205_interface yunsung8_msm5205_interface =
r17814	r17815
478	478	state->membank("bank2")->configure_entries(0, 3, &AUDIO[0x00000], 0x4000);
479	479	state->membank("bank2")->configure_entries(3, 5, &AUDIO[0x10000], 0x4000);
480	480
481		state->m_audiocpu = machine.device("audiocpu");
	481	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
482	482
483	483	state->save_item(NAME(state->m_videoram));
484	484	state->save_item(NAME(state->m_layers_ctrl));

trunk/src/mame/drivers/warpwarp.c

r17814	r17815
144	144	warpwarp_state *state = device->machine().driver_data<warpwarp_state>();
145	145
146	146	if(state->m_ball_on)
147		device_set_input_line(device, 0, ASSERT_LINE);
	147	device->execute().set_input_line(0, ASSERT_LINE);
148	148	}
149	149
150	150

trunk/src/mame/drivers/wheelfir.c

r17814	r17815
231	231	wheelfir_state(const machine_config &mconfig, device_type type, const char *tag)
232	232	: driver_device(mconfig, type, tag) { }
233	233
234		device_t *m_maincpu;
235		device_t *m_subcpu;
	234	cpu_device *m_maincpu;
	235	cpu_device *m_subcpu;
236	236	device_t *m_screen;
237	237	device_t *m_eeprom;
238	238
r17814	r17815
772	772	{
773	773	wheelfir_state *state = machine.driver_data<wheelfir_state>();
774	774
775		state->m_maincpu = machine.device( "maincpu");
776		state->m_subcpu = machine.device(  "subcpu");
	775	state->m_maincpu = machine.device<cpu_device>( "maincpu");
	776	state->m_subcpu = machine.device<cpu_device>(  "subcpu");
777	777	state->m_screen = machine.device(  "screen");
778	778	state->m_eeprom = machine.device(  "eeprom");
779	779

trunk/src/mame/drivers/jaguar.c

r17814	r17815
895	895	/* increment the count; if we hit 5, we can spin until an interrupt comes */
896	896	if (m_main_speedup_hits++ > 5)
897	897	{
898		device_spin_until_interrupt(&space.device());
	898	space.device().execute().spin_until_interrupt();
899	899	m_main_speedup_hits = 0;
900	900	}
901	901	}
r17814	r17815
936	936	READ32_MEMBER(jaguar_state::main_gpu_wait_r)
937	937	{
938	938	if (m_gpu_command_pending)
939		device_spin_until_interrupt(&space.device());
	939	space.device().execute().spin_until_interrupt();
940	940	return *m_main_gpu_wait;
941	941	}
942	942
r17814	r17815
972	972	/* increment the count; if we hit 5, we can spin until an interrupt comes */
973	973	if (m_main_speedup_hits++ > 5)
974	974	{
975		device_spin_until_interrupt(&space.device());
	975	space.device().execute().spin_until_interrupt();
976	976	m_main_speedup_hits = 0;
977	977	}
978	978	}
r17814	r17815
1006	1006	/* increment the count; if we hit 5, we can spin until an interrupt comes */
1007	1007	if (m_main_speedup_hits++ > 10)
1008	1008	{
1009		device_spin_until_interrupt(&space.device());
	1009	space.device().execute().spin_until_interrupt();
1010	1010	m_main_speedup_hits = 0;
1011	1011	}
1012	1012	}

trunk/src/mame/drivers/onetwo.c

r17814	r17815
64	64	tilemap_t *m_fg_tilemap;
65	65
66	66	/* devices */
67		device_t *m_maincpu;
68		device_t *m_audiocpu;
	67	cpu_device *m_maincpu;
	68	cpu_device *m_audiocpu;
69	69	DECLARE_WRITE8_MEMBER(onetwo_fgram_w);
70	70	DECLARE_WRITE8_MEMBER(onetwo_cpubank_w);
71	71	DECLARE_WRITE8_MEMBER(onetwo_coin_counters_w);
r17814	r17815
133	133	WRITE8_MEMBER(onetwo_state::onetwo_soundlatch_w)
134	134	{
135	135	soundlatch_byte_w(space, 0, data);
136		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	136	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
137	137	}
138	138
139	139	static void set_color(running_machine &machine, int offset)
r17814	r17815
331	331	static void irqhandler(device_t *device, int linestate)
332	332	{
333	333	onetwo_state *state = device->machine().driver_data<onetwo_state>();
334		device_set_input_line(state->m_audiocpu, 0, linestate);
	334	state->m_audiocpu->set_input_line(0, linestate);
335	335	}
336	336
337	337	static const ym3812_interface ym3812_config =
r17814	r17815
352	352
353	353	state->membank("bank1")->configure_entries(0, 8, &ROM[0x10000], 0x4000);
354	354
355		state->m_maincpu = machine.device("maincpu");
356		state->m_audiocpu = machine.device("audiocpu");
	355	state->m_maincpu = machine.device<cpu_device>("maincpu");
	356	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
357	357	}
358	358
359	359	static MACHINE_CONFIG_START( onetwo, onetwo_state )

trunk/src/mame/drivers/liberate.c

r17814	r17815
69	69	m_bank = data;
70	70
71	71	if (m_bank)
72		m_maincpu->memory().space(AS_PROGRAM)->install_read_handler(0x8000, 0x800f, read8_delegate(FUNC(liberate_state::deco16_io_r),this));
	72	m_maincpu->space(AS_PROGRAM)->install_read_handler(0x8000, 0x800f, read8_delegate(FUNC(liberate_state::deco16_io_r),this));
73	73	else
74		m_maincpu->memory().space(AS_PROGRAM)->install_read_bank(0x8000, 0x800f, "bank1");
	74	m_maincpu->space(AS_PROGRAM)->install_read_bank(0x8000, 0x800f, "bank1");
75	75	}
76	76
77	77	READ8_MEMBER(liberate_state::prosoccr_bank_r)
r17814	r17815
174	174	m_bank = data & 1;
175	175
176	176	if (m_bank)
177		m_maincpu->memory().space(AS_PROGRAM)->install_read_handler(0x8000, 0x800f, read8_delegate(FUNC(liberate_state::deco16_io_r),this));
	177	m_maincpu->space(AS_PROGRAM)->install_read_handler(0x8000, 0x800f, read8_delegate(FUNC(liberate_state::deco16_io_r),this));
178	178	else
179		m_maincpu->memory().space(AS_PROGRAM)->install_read_handler(0x8000, 0x800f, read8_delegate(FUNC(liberate_state::prosoccr_charram_r),this));
	179	m_maincpu->space(AS_PROGRAM)->install_read_handler(0x8000, 0x800f, read8_delegate(FUNC(liberate_state::prosoccr_charram_r),this));
180	180
181	181	}
182	182
r17814	r17815
766	766	int p = ~state->ioport("IN3")->read();
767	767	if ((p & 0x43) && !state->m_latch)
768	768	{
769		device_set_input_line(device, DECO16_IRQ_LINE, ASSERT_LINE);
	769	device->execute().set_input_line(DECO16_IRQ_LINE, ASSERT_LINE);
770	770	state->m_latch = 1;
771	771	}
772	772	else
r17814	r17815
780	780	static INTERRUPT_GEN( prosport_interrupt )
781	781	{
782	782	/* ??? */
783		device_set_input_line(device, DECO16_IRQ_LINE, ASSERT_LINE);
	783	device->execute().set_input_line(DECO16_IRQ_LINE, ASSERT_LINE);
784	784	}
785	785	#endif
786	786
r17814	r17815
794	794	{
795	795	liberate_state *state = machine.driver_data<liberate_state>();
796	796
797		state->m_maincpu = machine.device("maincpu");
798		state->m_audiocpu = machine.device("audiocpu");
	797	state->m_maincpu = machine.device<cpu_device>("maincpu");
	798	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
799	799
800	800	state->save_item(NAME(state->m_background_disable));
801	801	state->save_item(NAME(state->m_background_color));

trunk/src/mame/drivers/seta.c

r17814	r17815
1709	1709	{
1710	1710	soundlatch_word_w(space, 0, data, mem_mask);
1711	1711	machine().device("sub")->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
1712		device_spin_until_time(&space.device(), attotime::from_usec(50));   // Allow the other cpu to reply
	1712	space.device().execute().spin_until_time(attotime::from_usec(50));   // Allow the other cpu to reply
1713	1713	}
1714	1714	}
1715	1715
r17814	r17815
3186	3186	WRITE8_MEMBER(seta_state::calibr50_soundlatch2_w)
3187	3187	{
3188	3188	soundlatch2_byte_w(space,0,data);
3189		device_spin_until_time(&space.device(), attotime::from_usec(50));   // Allow the other cpu to reply
	3189	space.device().execute().spin_until_time(attotime::from_usec(50));   // Allow the other cpu to reply
3190	3190	}
3191	3191
3192	3192	static ADDRESS_MAP_START( calibr50_sub_map, AS_PROGRAM, 8, seta_state )
r17814	r17815
7420	7420	int scanline = param;
7421	7421
7422	7422	if(scanline == 240)
7423		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	7423	state->m_maincpu->set_input_line(1, HOLD_LINE);
7424	7424
7425	7425	if(scanline == 112)
7426		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	7426	state->m_maincpu->set_input_line(2, HOLD_LINE);
7427	7427	}
7428	7428
7429	7429	static TIMER_DEVICE_CALLBACK( seta_interrupt_2_and_4 )
r17814	r17815
7432	7432	int scanline = param;
7433	7433
7434	7434	if(scanline == 240)
7435		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	7435	state->m_maincpu->set_input_line(2, HOLD_LINE);
7436	7436
7437	7437	if(scanline == 112)
7438		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	7438	state->m_maincpu->set_input_line(4, HOLD_LINE);
7439	7439	}
7440	7440
7441	7441
r17814	r17815
7445	7445	int scanline = param;
7446	7446
7447	7447	if(scanline == 240)
7448		device_set_input_line(state->m_subcpu, INPUT_LINE_NMI, PULSE_LINE);
	7448	state->m_subcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
7449	7449
7450	7450	if(scanline == 112)
7451		device_set_input_line(state->m_subcpu, 0, HOLD_LINE);
	7451	state->m_subcpu->set_input_line(0, HOLD_LINE);
7452	7452	}
7453	7453
7454	7454
r17814	r17815
7476	7476	int scanline = param;
7477	7477
7478	7478	if(scanline == 240)
7479		device_set_input_line(state->m_subcpu, INPUT_LINE_NMI, PULSE_LINE);
	7479	state->m_subcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
7480	7480
7481	7481	if((scanline % 16) == 0)
7482		device_set_input_line(state->m_subcpu, 0, HOLD_LINE);
	7482	state->m_subcpu->set_input_line(0, HOLD_LINE);
7483	7483	}
7484	7484
7485	7485	static MACHINE_CONFIG_START( tndrcade, seta_state )
r17814	r17815
7624	7624	int scanline = param;
7625	7625
7626	7626	if((scanline % 64) == 0)
7627		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	7627	state->m_maincpu->set_input_line(4, HOLD_LINE);
7628	7628
7629	7629	if(scanline == 248)
7630		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	7630	state->m_maincpu->set_input_line(2, HOLD_LINE);
7631	7631	}
7632	7632
7633	7633
r17814	r17815
8029	8029	int scanline = param;
8030	8030
8031	8031	if(scanline == 248)
8032		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	8032	state->m_maincpu->set_input_line(4, HOLD_LINE);
8033	8033
8034	8034	if(scanline == 112)
8035		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	8035	state->m_maincpu->set_input_line(2, HOLD_LINE);
8036	8036	}
8037	8037
8038	8038
r17814	r17815
8156	8156	#if __uPD71054_TIMER
8157	8157	static INTERRUPT_GEN( wrofaero_interrupt )
8158	8158	{
8159		device_set_input_line(device, 2, HOLD_LINE );
	8159	device->execute().set_input_line(2, HOLD_LINE );
8160	8160	}
8161	8161
8162	8162	static MACHINE_START( wrofaero ) { uPD71054_timer_init(machine); }
r17814	r17815
9088	9088	int scanline = param;
9089	9089
9090	9090	if((scanline % 48) == 0)
9091		device_set_input_line(state->m_maincpu, 2, HOLD_LINE); // should this be triggered by the 3812?
	9091	state->m_maincpu->set_input_line(2, HOLD_LINE); // should this be triggered by the 3812?
9092	9092
9093	9093	if(scanline == 240)
9094		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	9094	state->m_maincpu->set_input_line(1, HOLD_LINE);
9095	9095	}
9096	9096
9097	9097	static MACHINE_CONFIG_START( crazyfgt, seta_state )
r17814	r17815
9139	9139
9140	9140	/* ACIA irq */
9141	9141	if(scanline == 15)
9142		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	9142	state->m_maincpu->set_input_line(4, HOLD_LINE);
9143	9143
9144	9144	if(scanline == 38)
9145		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	9145	state->m_maincpu->set_input_line(1, HOLD_LINE);
9146	9146
9147	9147	if(scanline == 61)
9148		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	9148	state->m_maincpu->set_input_line(2, HOLD_LINE);
9149	9149
9150	9150	if(scanline >= 85 && (scanline % 23) == 0)
9151		device_set_input_line(state->m_maincpu, 6, HOLD_LINE);
	9151	state->m_maincpu->set_input_line(6, HOLD_LINE);
9152	9152	}
9153	9153
9154	9154	static const pia6821_interface inttoote_pia0_intf =

trunk/src/mame/drivers/laserbat.c

r17814	r17815
572	572
573	573	WRITE_LINE_MEMBER(laserbat_state::zaccaria_irq0a)
574	574	{
575		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, state ? ASSERT_LINE : CLEAR_LINE);
	575	m_audiocpu->set_input_line(INPUT_LINE_NMI, state ? ASSERT_LINE : CLEAR_LINE);
576	576	}
577	577
578	578	WRITE_LINE_MEMBER(laserbat_state::zaccaria_irq0b)
579	579	{
580		device_set_input_line(m_audiocpu, 0, state ? ASSERT_LINE : CLEAR_LINE);
	580	m_audiocpu->set_input_line(0, state ? ASSERT_LINE : CLEAR_LINE);
581	581	}
582	582
583	583	READ8_MEMBER(laserbat_state::zaccaria_port0a_r)
r17814	r17815
650	650
651	651	static INTERRUPT_GEN( laserbat_interrupt )
652	652	{
653		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0x0a);
	653	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0x0a);
654	654	}
655	655
656	656	static INTERRUPT_GEN( zaccaria_cb1_toggle )

trunk/src/mame/drivers/tp84.c

r17814	r17815
284	284	tp84_state *state = device->machine().driver_data<tp84_state>();
285	285
286	286	if(state->m_sub_irq_mask)
287		device_set_input_line(device, 0, HOLD_LINE);
	287	device->execute().set_input_line(0, HOLD_LINE);
288	288	}
289	289
290	290

trunk/src/mame/drivers/cheekyms.c

r17814	r17815
17	17
18	18	/* this starts a 556 one-shot timer (and triggers a sound effect) */
19	19	if (newval)
20		device_set_input_line(m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	20	m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
21	21	}
22	22
23	23
r17814	r17815
112	112	{
113	113	cheekyms_state *state = machine.driver_data<cheekyms_state>();
114	114
115		state->m_maincpu = machine.device("maincpu");
	115	state->m_maincpu = machine.device<cpu_device>("maincpu");
116	116	state->m_dac = machine.device<dac_device>("dac");
117	117	}
118	118
r17814	r17815
121	121	cheekyms_state *state = device->machine().driver_data<cheekyms_state>();
122	122
123	123	if(state->m_irq_mask)
124		device_set_input_line(device, 0, HOLD_LINE);
	124	device->execute().set_input_line(0, HOLD_LINE);
125	125	}
126	126
127	127

trunk/src/mame/drivers/queen.c

r17814	r17815
566	566
567	567	WRITE_LINE_MEMBER(queen_state::queen_pic8259_1_set_int_line)
568	568	{
569		device_set_input_line(m_maincpu, 0, state ? HOLD_LINE : CLEAR_LINE);
	569	m_maincpu->set_input_line(0, state ? HOLD_LINE : CLEAR_LINE);
570	570	}
571	571
572	572	READ8_MEMBER( queen_state::get_slave_ack )
r17814	r17815
596	596	{
597	597	queen_state *state = machine.driver_data<queen_state>();
598	598
599		device_set_input_line(state->m_maincpu, INPUT_LINE_A20, a20);
	599	state->m_maincpu->set_input_line(INPUT_LINE_A20, a20);
600	600	}
601	601
602	602	static void keyboard_interrupt(running_machine &machine, int state)
r17814	r17815
650	650
651	651	init_pc_common(machine, PCCOMMON_KEYBOARD_AT, queen_set_keyb_int);
652	652
653		device_set_irq_callback(state->m_maincpu, irq_callback);
	653	state->m_maincpu->set_irq_acknowledge_callback(irq_callback);
654	654	intel82439tx_init(machine);
655	655
656	656	kbdc8042_init(machine, &at8042);

trunk/src/mame/drivers/timelimt.c

r17814	r17815
220	220	{
221	221	timelimt_state *state = device->machine().driver_data<timelimt_state>();
222	222	if ( state->m_nmi_enabled )
223		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	223	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
224	224	}
225	225
226	226	/***************************************************************************/

trunk/src/mame/drivers/vamphalf.c

r17814	r17815
2221	2221	if(space.device().safe_pc() == 0x82de)
2222	2222	{
2223	2223	if(irq_active(&space))
2224		device_spin_until_interrupt(&space.device());
	2224	space.device().execute().spin_until_interrupt();
2225	2225	else
2226		device_eat_cycles(&space.device(), 50);
	2226	space.device().execute().eat_cycles(50);
2227	2227	}
2228	2228
2229	2229	return m_wram[(0x4a840/2)+offset];
r17814	r17815
2234	2234	if(space.device().safe_pc() == 0x82de)
2235	2235	{
2236	2236	if(irq_active(&space))
2237		device_spin_until_interrupt(&space.device());
	2237	space.device().execute().spin_until_interrupt();
2238	2238	else
2239		device_eat_cycles(&space.device(), 50);
	2239	space.device().execute().eat_cycles(50);
2240	2240	}
2241	2241
2242	2242	return m_wram[(0x4a6d0/2)+offset];
r17814	r17815
2247	2247	if(space.device().safe_pc() == 0xecc8)
2248	2248	{
2249	2249	if(irq_active(&space))
2250		device_spin_until_interrupt(&space.device());
	2250	space.device().execute().spin_until_interrupt();
2251	2251	else
2252		device_eat_cycles(&space.device(), 50);
	2252	space.device().execute().eat_cycles(50);
2253	2253	}
2254	2254
2255	2255	return m_wram[(0x72eb4/2)+offset];
r17814	r17815
2260	2260	if(space.device().safe_pc() == 0x75f7a)
2261	2261	{
2262	2262	if(irq_active(&space))
2263		device_spin_until_interrupt(&space.device());
	2263	space.device().execute().spin_until_interrupt();
2264	2264	else
2265		device_eat_cycles(&space.device(), 50);
	2265	space.device().execute().eat_cycles(50);
2266	2266	}
2267	2267
2268	2268	return m_wram[(0xd2e80/2)+offset];
r17814	r17815
2273	2273	if(space.device().safe_pc() == 0xaf18a )
2274	2274	{
2275	2275	if(irq_active(&space))
2276		device_spin_until_interrupt(&space.device());
	2276	space.device().execute().spin_until_interrupt();
2277	2277	else
2278		device_eat_cycles(&space.device(), 50);
	2278	space.device().execute().eat_cycles(50);
2279	2279	}
2280	2280
2281	2281	return m_wram[(0x11605c/2)+offset];
r17814	r17815
2286	2286	if(space.device().safe_pc() == 0xaefac )
2287	2287	{
2288	2288	if(irq_active(&space))
2289		device_spin_until_interrupt(&space.device());
	2289	space.device().execute().spin_until_interrupt();
2290	2290	else
2291		device_eat_cycles(&space.device(), 50);
	2291	space.device().execute().eat_cycles(50);
2292	2292	}
2293	2293
2294	2294	return m_wram[(0x115e84/2)+offset];
r17814	r17815
2299	2299	if(space.device().safe_pc() == 0xae6c0 )
2300	2300	{
2301	2301	if(irq_active(&space))
2302		device_spin_until_interrupt(&space.device());
	2302	space.device().execute().spin_until_interrupt();
2303	2303	else
2304		device_eat_cycles(&space.device(), 50);
	2304	space.device().execute().eat_cycles(50);
2305	2305	}
2306	2306
2307	2307	return m_wram[(0x113f08/2)+offset];
r17814	r17815
2312	2312	if(space.device().safe_pc() == 0xae6d2 )
2313	2313	{
2314	2314	if(irq_active(&space))
2315		device_spin_until_interrupt(&space.device());
	2315	space.device().execute().spin_until_interrupt();
2316	2316	else
2317		device_eat_cycles(&space.device(), 50);
	2317	space.device().execute().eat_cycles(50);
2318	2318	}
2319	2319
2320	2320	return m_wram[(0x113ecc/2)+offset];
r17814	r17815
2327	2327	if(pc == 0x10758)
2328	2328	{
2329	2329	if(irq_active(&space))
2330		device_spin_until_interrupt(&space.device());
	2330	space.device().execute().spin_until_interrupt();
2331	2331	else
2332		device_eat_cycles(&space.device(), 50);
	2332	space.device().execute().eat_cycles(50);
2333	2333	}
2334	2334
2335	2335	return m_wram32[0x00b56fc/4];
r17814	r17815
2342	2342	if(pc == 0x10758)
2343	2343	{
2344	2344	if(irq_active(&space))
2345		device_spin_until_interrupt(&space.device());
	2345	space.device().execute().spin_until_interrupt();
2346	2346	else
2347		device_eat_cycles(&space.device(), 50);
	2347	space.device().execute().eat_cycles(50);
2348	2348	}
2349	2349
2350	2350	return m_wram32[0x00b74f8/4];
r17814	r17815
2357	2357	if(space.device().safe_pc() == 0x1c212)
2358	2358	{
2359	2359	if(irq_active(&space))
2360		device_spin_until_interrupt(&space.device());
	2360	space.device().execute().spin_until_interrupt();
2361	2361	else
2362		device_eat_cycles(&space.device(), 50);
	2362	space.device().execute().eat_cycles(50);
2363	2363	}
2364	2364
2365	2365	return m_wram32[0x005e874/4];
r17814	r17815
2371	2371	if(pc == 0x469de || pc == 0x46a36)
2372	2372	{
2373	2373	//      if(irq_active(&space))
2374		//          device_spin_until_interrupt(&space.device());
	2374	//          space.device().execute().spin_until_interrupt();
2375	2375	//      else
2376		device_eat_cycles(&space.device(), 50);
	2376	space.device().execute().eat_cycles(50);
2377	2377	}
2378	2378
2379	2379	return m_wram32[0x00701a4/4];
r17814	r17815
2385	2385	if(space.device().safe_pc() == 0xaa622)
2386	2386	{
2387	2387	if(irq_active(&space))
2388		device_spin_until_interrupt(&space.device());
	2388	space.device().execute().spin_until_interrupt();
2389	2389	else
2390		device_eat_cycles(&space.device(), 50);
	2390	space.device().execute().eat_cycles(50);
2391	2391	}
2392	2392
2393	2393	return m_wram[(0xcde70/2)+offset];
r17814	r17815
2397	2397	{
2398	2398	if(space.device().safe_pc() == 0xb994 )
2399	2399	{
2400		device_eat_cycles(&space.device(), 500);
	2400	space.device().execute().eat_cycles(500);
2401	2401	}
2402	2402	else if (space.device().safe_pc() == 0xba40 )
2403	2403	{
2404		device_eat_cycles(&space.device(), 500);
	2404	space.device().execute().eat_cycles(500);
2405	2405	}
2406	2406
2407	2407
r17814	r17815
2413	2413	if(space.device().safe_pc() == 0x983c)
2414	2414	{
2415	2415	if(irq_active(&space))
2416		device_spin_until_interrupt(&space.device());
	2416	space.device().execute().spin_until_interrupt();
2417	2417	else
2418		device_eat_cycles(&space.device(), 50);
	2418	space.device().execute().eat_cycles(50);
2419	2419	}
2420	2420
2421	2421	return m_wram[(0x00906fc / 2)+offset];
r17814	r17815
2426	2426	if(space.device().safe_pc() == 0x1710)
2427	2427	{
2428	2428	if(irq_active(&space))
2429		device_spin_until_interrupt(&space.device());
	2429	space.device().execute().spin_until_interrupt();
2430	2430	else
2431		device_eat_cycles(&space.device(), 50);
	2431	space.device().execute().eat_cycles(50);
2432	2432	}
2433	2433
2434	2434	return m_wram[(0x00a99c / 2)+offset];
r17814	r17815
2440	2440	int pc = space.device().safe_pc();
2441	2441
2442	2442	if (pc == 0x12fa6)
2443		device_spin_until_interrupt(&space.device());
	2443	space.device().execute().spin_until_interrupt();
2444	2444
2445	2445	return m_wram[0xcc2a8 / 2];
2446	2446
r17814	r17815
2450	2450	{
2451	2451
2452	2452	if (space.device().safe_pc() == 0x130c2)
2453		device_spin_until_interrupt(&space.device());
	2453	space.device().execute().spin_until_interrupt();
2454	2454
2455	2455	return m_wram[0x780d8 / 2];
2456	2456
r17814	r17815
2461	2461	if(space.device().safe_pc() == 0x13198)
2462	2462	{
2463	2463	if(irq_active(&space))
2464		device_spin_until_interrupt(&space.device());
	2464	space.device().execute().spin_until_interrupt();
2465	2465	}
2466	2466
2467	2467	return m_wram[(0xf1b7c / 2)+offset];

trunk/src/mame/drivers/bishi.c

r17814	r17815
363	363	{
364	364	bishi_state *bishi = device->machine().driver_data<bishi_state>();
365	365
366		device_set_input_line(bishi->m_maincpu, M68K_IRQ_1, (state) ? ASSERT_LINE : CLEAR_LINE);
	366	bishi->m_maincpu->set_input_line(M68K_IRQ_1, (state) ? ASSERT_LINE : CLEAR_LINE);
367	367	}
368	368
369	369	static const ymz280b_interface ymz280b_intf =
r17814	r17815
392	392	{
393	393	bishi_state *state = machine.driver_data<bishi_state>();
394	394
395		state->m_maincpu = machine.device("maincpu");
	395	state->m_maincpu = machine.device<cpu_device>("maincpu");
396	396	state->m_k056832 = machine.device("k056832");
397	397	state->m_k054338 = machine.device("k054338");
398	398	state->m_k055555 = machine.device("k055555");

trunk/src/mame/drivers/1942.c

r17814	r17815
240	240	{
241	241	_1942_state *state = machine.driver_data<_1942_state>();
242	242
243		state->m_audiocpu = machine.device("audiocpu");
	243	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
244	244
245	245	state->save_item(NAME(state->m_palette_bank));
246	246	state->save_item(NAME(state->m_scroll));

trunk/src/mame/drivers/mayumi.c

r17814	r17815
89	89	mayumi_state *state = device->machine().driver_data<mayumi_state>();
90	90
91	91	if (state->m_int_enable)
92		device_set_input_line(device, 0, HOLD_LINE);
	92	device->execute().set_input_line(0, HOLD_LINE);
93	93	}
94	94
95	95	/*************************************

trunk/src/mame/drivers/raiden.c

r17814	r17815
239	239
240	240	static INTERRUPT_GEN( raiden_interrupt )
241	241	{
242		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0xc8/4);   /* VBL */
	242	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0xc8/4);   /* VBL */
243	243	}
244	244
245	245	static MACHINE_CONFIG_START( raiden, raiden_state )
r17814	r17815
560	560
561	561	// main set
562	562	if (pc==0xfcde6 && ret!=0x40)
563		device_spin(&space.device());
	563	space.device().execute().spin();
564	564
565	565	// alt sets
566	566	if (pc==0xfcde8 && ret!=0x40)
567		device_spin(&space.device());
	567	space.device().execute().spin();
568	568
569	569	return ret;
570	570	}

trunk/src/mame/drivers/galaxia.c

r17814	r17815
69	69
70	70	static INTERRUPT_GEN( galaxia_interrupt )
71	71	{
72		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0x03);
	72	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0x03);
73	73	cvs_scroll_stars(device->machine());
74	74	}
75	75

trunk/src/mame/drivers/fromanc2.c

r17814	r17815
33	33
34	34	static INTERRUPT_GEN( fromanc2_interrupt )
35	35	{
36		device_set_input_line(device, 1, HOLD_LINE);
	36	device->execute().set_input_line(1, HOLD_LINE);
37	37	}
38	38
39	39
r17814	r17815
43	43	soundlatch_byte_w(space, offset, (data >> 8) & 0xff);   // 1P (LEFT)
44	44	soundlatch2_byte_w(space, offset, data & 0xff);         // 2P (RIGHT)
45	45
46		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	46	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
47	47	m_sndcpu_nmi_flag = 0;
48	48	}
49	49
r17814	r17815
110	110	{
111	111	m_datalatch1 = data;
112	112
113		device_set_input_line(m_subcpu, 0, HOLD_LINE);
	113	m_subcpu->set_input_line(0, HOLD_LINE);
114	114	m_subcpu_int_flag = 0;
115	115	}
116	116
117	117	READ16_MEMBER(fromanc2_state::fromanc2_subcpu_r)
118	118	{
119		device_set_input_line(m_subcpu, INPUT_LINE_NMI, PULSE_LINE);
	119	m_subcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
120	120	m_subcpu_nmi_flag = 0;
121	121
122	122	return (m_datalatch_2h << 8) | m_datalatch_2l;
r17814	r17815
486	486	static void irqhandler(device_t *device, int irq)
487	487	{
488	488	fromanc2_state *state = device->machine().driver_data<fromanc2_state>();
489		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	489	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
490	490	}
491	491
492	492	static const ym2610_interface ym2610_config =
r17814	r17815
505	505	{
506	506	fromanc2_state *state = machine.driver_data<fromanc2_state>();
507	507
508		state->m_audiocpu = machine.device("audiocpu");
509		state->m_subcpu = machine.device("sub");
	508	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
	509	state->m_subcpu = machine.device<cpu_device>("sub");
510	510	state->m_eeprom = machine.device("eeprom");
511	511	state->m_left_screen = machine.device("lscreen");
512	512	state->m_right_screen = machine.device("rscreen");

trunk/src/mame/drivers/rallyx.c

r17814	r17815
207	207	WRITE8_MEMBER(rallyx_state::rallyx_interrupt_vector_w)
208	208	{
209	209
210		device_set_input_line_vector(m_maincpu, 0, data);
211		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	210	m_maincpu->set_input_line_vector(0, data);
	211	m_maincpu->set_input_line(0, CLEAR_LINE);
212	212	}
213	213
214	214
r17814	r17815
234	234	case 0x01:   /* INT ON */
235	235	m_main_irq_mask = bit;
236	236	if (!bit)
237		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	237	m_maincpu->set_input_line(0, CLEAR_LINE);
238	238	break;
239	239
240	240	case 0x02:   /* SOUND ON */
r17814	r17815
895	895	rallyx_state *state = device->machine().driver_data<rallyx_state>();
896	896
897	897	if(state->m_main_irq_mask)
898		device_set_input_line(device, 0, ASSERT_LINE);
	898	device->execute().set_input_line(0, ASSERT_LINE);
899	899	}
900	900
901	901	static INTERRUPT_GEN( jungler_vblank_irq )
r17814	r17815
903	903	rallyx_state *state = device->machine().driver_data<rallyx_state>();
904	904
905	905	if(state->m_main_irq_mask)
906		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	906	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
907	907	}
908	908
909	909	static MACHINE_CONFIG_START( rallyx, rallyx_state )

trunk/src/mame/drivers/bnstars.c

r17814	r17815
1330	1330	for(i=15; i>=0 && !(state->m_irqreq & (1<<i)); i--);
1331	1331	state->m_irqreq &= ~(1<<i);
1332	1332	if(!state->m_irqreq)
1333		device_set_input_line(device, 0, CLEAR_LINE);
	1333	device->execute().set_input_line(0, CLEAR_LINE);
1334	1334	return i;
1335	1335	}
1336	1336
r17814	r17815
1339	1339	bnstars_state *state = machine.driver_data<bnstars_state>();
1340	1340	state->m_irqreq = 0;
1341	1341	machine.device("maincpu")->execute().set_input_line(0, CLEAR_LINE);
1342		device_set_irq_callback(machine.device("maincpu"), irq_callback);
	1342	machine.device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
1343	1343	}
1344	1344
1345	1345	static void irq_raise(running_machine &machine, int level)

trunk/src/mame/drivers/diverboy.c

r17814	r17815
65	65	//  UINT16 *  m_paletteram;   // currently this uses generic palette handling
66	66
67	67	/* devices */
68		device_t *m_audiocpu;
	68	cpu_device *m_audiocpu;
69	69	DECLARE_WRITE16_MEMBER(soundcmd_w);
70	70	DECLARE_WRITE8_MEMBER(okibank_w);
71	71	};
r17814	r17815
125	125	if (ACCESSING_BITS_0_7)
126	126	{
127	127	soundlatch_byte_w(space, 0, data & 0xff);
128		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	128	m_audiocpu->set_input_line(0, HOLD_LINE);
129	129	}
130	130	}
131	131
r17814	r17815
248	248	{
249	249	diverboy_state *state = machine.driver_data<diverboy_state>();
250	250
251		state->m_audiocpu = machine.device("audiocpu");
	251	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
252	252	}
253	253
254	254	static MACHINE_CONFIG_START( diverboy, diverboy_state )

trunk/src/mame/drivers/carjmbre.c

r17814	r17815
196	196	carjmbre_state *state = device->machine().driver_data<carjmbre_state>();
197	197
198	198	if(state->m_nmi_mask)
199		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	199	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
200	200	}
201	201
202	202	static MACHINE_CONFIG_START( carjmbre, carjmbre_state )

trunk/src/mame/drivers/superchs.c

r17814	r17815
438	438	READ32_MEMBER(superchs_state::main_cycle_r)
439	439	{
440	440	if (space.device().safe_pc()==0x702)
441		device_spin_until_interrupt(&space.device());
	441	space.device().execute().spin_until_interrupt();
442	442
443	443	return m_ram[0];
444	444	}
r17814	r17815
446	446	READ16_MEMBER(superchs_state::sub_cycle_r)
447	447	{
448	448	if (space.device().safe_pc()==0x454)
449		device_spin_until_interrupt(&space.device());
	449	space.device().execute().spin_until_interrupt();
450	450
451	451	return m_ram[2]&0xffff;
452	452	}

trunk/src/mame/drivers/namcos1.c

r17814	r17815
357	357
358	358	WRITE8_MEMBER(namcos1_state::irq_ack_w)
359	359	{
360		device_set_input_line(&space.device(), 0, CLEAR_LINE);
	360	space.device().execute().set_input_line(0, CLEAR_LINE);
361	361	}
362	362
363	363	WRITE8_MEMBER(namcos1_state::firq_ack_w)
364	364	{
365		device_set_input_line(&space.device(), M6809_FIRQ_LINE, CLEAR_LINE);
	365	space.device().execute().set_input_line(M6809_FIRQ_LINE, CLEAR_LINE);
366	366	}
367	367
368	368

trunk/src/mame/drivers/mainevt.c

r17814	r17815
82	82
83	83	WRITE8_MEMBER(mainevt_state::mainevt_sh_irqtrigger_w)
84	84	{
85		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	85	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
86	86	}
87	87
88	88	READ8_MEMBER(mainevt_state::mainevt_sh_busy_r)
r17814	r17815
418	418
419	419	state->membank("bank1")->configure_entries(0, 4, &ROM[0x10000], 0x2000);
420	420
421		state->m_maincpu = machine.device("maincpu");
422		state->m_audiocpu = machine.device("audiocpu");
	421	state->m_maincpu = machine.device<cpu_device>("maincpu");
	422	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
423	423	state->m_upd = machine.device("upd");
424	424	state->m_k007232 = machine.device("k007232");
425	425	state->m_k052109 = machine.device("k052109");
r17814	r17815
440	440	mainevt_state *state = device->machine().driver_data<mainevt_state>();
441	441
442	442	if(state->m_sound_irq_mask)
443		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	443	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
444	444	}
445	445
446	446	static INTERRUPT_GEN( devstors_sound_timer_irq )
r17814	r17815
448	448	mainevt_state *state = device->machine().driver_data<mainevt_state>();
449	449
450	450	if(state->m_sound_irq_mask)
451		device_set_input_line(device, 0, HOLD_LINE);
	451	device->execute().set_input_line(0, HOLD_LINE);
452	452	}
453	453
454	454	static MACHINE_CONFIG_START( mainevt, mainevt_state )

trunk/src/mame/drivers/deco156.c

r17814	r17815
315	315
316	316	static INTERRUPT_GEN( deco32_vbl_interrupt )
317	317	{
318		device_set_input_line(device, ARM_IRQ_LINE, HOLD_LINE);
	318	device->execute().set_input_line(ARM_IRQ_LINE, HOLD_LINE);
319	319	}
320	320
321	321	static int deco156_bank_callback(const int bank)

trunk/src/mame/drivers/dwarfd.c

r17814	r17815
875	875
876	876	if (scanline < 25*8)
877	877	{
878		device_set_input_line(state->m_maincpu, I8085_RST65_LINE, HOLD_LINE); // 34 - every 8th line
	878	state->m_maincpu->set_input_line(I8085_RST65_LINE, HOLD_LINE); // 34 - every 8th line
879	879	state->m_line = scanline/8;
880	880	state->m_idx = 0;
881	881	}
r17814	r17815
883	883	{
884	884	if (scanline == 25*8)
885	885	{
886		device_set_input_line(state->m_maincpu, I8085_RST55_LINE, HOLD_LINE);//2c - generated by  crt - end of frame
	886	state->m_maincpu->set_input_line(I8085_RST55_LINE, HOLD_LINE);//2c - generated by  crt - end of frame
887	887	}
888	888	}
889	889	}

trunk/src/mame/drivers/renegade.c

r17814	r17815
672	672	int scanline = param;
673	673
674	674	if (scanline == 112) // ???
675		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	675	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
676	676	else if(scanline == 240)
677		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	677	state->m_maincpu->set_input_line(0, HOLD_LINE);
678	678	}
679	679
680	680	WRITE8_MEMBER(renegade_state::renegade_coin_counter_w)

trunk/src/mame/drivers/junofrst.c

r17814	r17815
240	240	if (m_last_irq == 0 && data == 1)
241	241	{
242	242	/* setting bit 0 low then high triggers IRQ on the sound CPU */
243		device_set_input_line_and_vector(m_soundcpu, 0, HOLD_LINE, 0xff);
	243	m_soundcpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
244	244	}
245	245
246	246	m_last_irq = data;
r17814	r17815
250	250	WRITE8_MEMBER(junofrst_state::junofrst_i8039_irq_w)
251	251	{
252	252
253		device_set_input_line(m_i8039, 0, ASSERT_LINE);
	253	m_i8039->execute().set_input_line(0, ASSERT_LINE);
254	254	}
255	255
256	256
r17814	r17815
259	259
260	260
261	261	if ((data & 0x80) == 0)
262		device_set_input_line(m_i8039, 0, CLEAR_LINE);
	262	m_i8039->execute().set_input_line(0, CLEAR_LINE);
263	263	m_i8039_status = (data & 0x70) >> 4;
264	264	}
265	265
r17814	r17815
283	283
284	284	m_irq_enable = data & 1;
285	285	if (!m_irq_enable)
286		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	286	m_maincpu->set_input_line(0, CLEAR_LINE);
287	287	}
288	288
289	289	static ADDRESS_MAP_START( main_map, AS_PROGRAM, 8, junofrst_state )
r17814	r17815
425	425	/* flip flops cause the interrupt to be signalled every other frame */
426	426	state->m_irq_toggle ^= 1;
427	427	if (state->m_irq_toggle && state->m_irq_enable)
428		device_set_input_line(device, 0, ASSERT_LINE);
	428	device->execute().set_input_line(0, ASSERT_LINE);
429	429	}
430	430
431	431	static MACHINE_CONFIG_START( junofrst, junofrst_state )

trunk/src/mame/drivers/hitpoker.c

r17814	r17815
487	487
488	488	static INTERRUPT_GEN( hitpoker_irq )
489	489	{
490		device_set_input_line(device, MC68HC11_IRQ_LINE, HOLD_LINE);
	490	device->execute().set_input_line(MC68HC11_IRQ_LINE, HOLD_LINE);
491	491	}
492	492
493	493	static MACHINE_CONFIG_START( hitpoker, hitpoker_state )

trunk/src/mame/drivers/taito_h.c

r17814	r17815
159	159	static void irqhandler( device_t *device, int irq )
160	160	{
161	161	taitoh_state *state = device->machine().driver_data<taitoh_state>();
162		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	162	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
163	163	}
164	164
165	165	static const ym2610_interface ym2610_config =
r17814	r17815
529	529
530	530	state->membank("bank1")->configure_entries(0, 4, &ROM[0xc000], 0x4000);
531	531
532		state->m_audiocpu = machine.device("audiocpu");
	532	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
533	533	state->m_tc0220ioc = machine.device("tc0220ioc");
534	534	state->m_tc0080vco = machine.device("tc0080vco");
535	535

trunk/src/mame/drivers/ginganin.c

r17814	r17815
230	230	{
231	231	ginganin_state *state = machine.driver_data<ginganin_state>();
232	232
233		state->m_audiocpu = machine.device("audiocpu");
	233	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
234	234
235	235	state->save_item(NAME(state->m_layers_ctrl));
236	236	state->save_item(NAME(state->m_flipscreen));

trunk/src/mame/drivers/tail2nos.c

r17814	r17815
23	23	if (ACCESSING_BITS_0_7)
24	24	{
25	25	soundlatch_byte_w(space, offset, data & 0xff);
26		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	26	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
27	27	}
28	28	}
29	29
r17814	r17815
180	180	static void irqhandler( device_t *device, int irq )
181	181	{
182	182	tail2nos_state *state = device->machine().driver_data<tail2nos_state>();
183		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	183	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
184	184	}
185	185
186	186	static const ym2608_interface ym2608_config =
r17814	r17815
213	213	state->membank("bank3")->configure_entries(0, 2, &ROM[0x10000], 0x8000);
214	214	state->membank("bank3")->set_entry(0);
215	215
216		state->m_maincpu = machine.device("maincpu");
217		state->m_audiocpu = machine.device("audiocpu");
	216	state->m_maincpu = machine.device<cpu_device>("maincpu");
	217	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
218	218	state->m_k051316 = machine.device("k051316");
219	219
220	220	state->save_item(NAME(state->m_charbank));

trunk/src/mame/drivers/m79amb.c

r17814	r17815
204	204
205	205	static INTERRUPT_GEN( m79amb_interrupt )
206	206	{
207		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0xcf);  /* RST 08h */
	207	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0xcf);  /* RST 08h */
208	208	}
209	209
210	210	static MACHINE_CONFIG_START( m79amb, m79amb_state )

trunk/src/mame/drivers/slapshot.c

r17814	r17815
174	174	static TIMER_CALLBACK( slapshot_interrupt6 )
175	175	{
176	176	slapshot_state *state = machine.driver_data<slapshot_state>();
177		device_set_input_line(state->m_maincpu, 6, HOLD_LINE);
	177	state->m_maincpu->set_input_line(6, HOLD_LINE);
178	178	}
179	179
180	180
181	181	static INTERRUPT_GEN( slapshot_interrupt )
182	182	{
183	183	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(200000 - 500), FUNC(slapshot_interrupt6));
184		device_set_input_line(device, 5, HOLD_LINE);
	184	device->execute().set_input_line(5, HOLD_LINE);
185	185	}
186	186
187	187
r17814	r17815
232	232	}
233	233
234	234	/* 4 writes a frame - one for each analogue port */
235		device_set_input_line(m_maincpu, 3, HOLD_LINE);
	235	m_maincpu->set_input_line(3, HOLD_LINE);
236	236	}
237	237
238	238	/*****************************************************
r17814	r17815
486	486	static void irqhandler( device_t *device, int irq )
487	487	{
488	488	slapshot_state *state = device->machine().driver_data<slapshot_state>();
489		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	489	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
490	490	}
491	491
492	492	static const ym2610_interface ym2610_config =
r17814	r17815
526	526
527	527	state->membank("bank10")->configure_entries(0, 4, state->memregion("audiocpu")->base() + 0xc000, 0x4000);
528	528
529		state->m_maincpu = machine.device("maincpu");
530		state->m_audiocpu = machine.device("audiocpu");
	529	state->m_maincpu = machine.device<cpu_device>("maincpu");
	530	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
531	531	state->m_tc0140syt = machine.device("tc0140syt");
532	532	state->m_tc0480scp = machine.device("tc0480scp");
533	533	state->m_tc0360pri = machine.device("tc0360pri");

trunk/src/mame/drivers/koftball.c

r17814	r17815
215	215	int scanline = param;
216	216
217	217	if(scanline == 240)
218		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	218	state->m_maincpu->set_input_line(2, HOLD_LINE);
219	219
220	220	if(scanline == 128)
221		device_set_input_line(state->m_maincpu, 3, HOLD_LINE);
	221	state->m_maincpu->set_input_line(3, HOLD_LINE);
222	222
223	223	if(scanline == 64)
224		device_set_input_line(state->m_maincpu, 6, HOLD_LINE);
	224	state->m_maincpu->set_input_line(6, HOLD_LINE);
225	225	}
226	226
227	227	static const gfx_layout tilelayout =

trunk/src/mame/drivers/lucky74.c

r17814	r17815
906	906	lucky74_state *state = device->machine().driver_data<lucky74_state>();
907	907	if ((state->m_ym2149_portb & 0x10) == 0)   /* ym2149 portB bit 4 trigger the NMI */
908	908	{
909		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	909	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
910	910	}
911	911	}
912	912

trunk/src/mame/drivers/cninja.c

r17814	r17815
58	58	{
59	59
60	60	soundlatch_byte_w(space, 0, data & 0xff);
61		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	61	m_audiocpu->set_input_line(0, HOLD_LINE);
62	62	}
63	63
64	64	WRITE16_MEMBER(cninja_state::stoneage_sound_w)
65	65	{
66	66
67	67	soundlatch_byte_w(space, 0, data & 0xff);
68		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	68	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
69	69	}
70	70
71	71	static TIMER_DEVICE_CALLBACK( interrupt_gen )
72	72	{
73	73	cninja_state *state = timer.machine().driver_data<cninja_state>();
74	74
75		device_set_input_line(state->m_maincpu, (state->m_irq_mask & 0x10) ? 3 : 4, ASSERT_LINE);
	75	state->m_maincpu->set_input_line((state->m_irq_mask & 0x10) ? 3 : 4, ASSERT_LINE);
76	76	state->m_raster_irq_timer->reset();
77	77	}
78	78
r17814	r17815
86	86	return m_scanline;
87	87
88	88	case 2: /* Raster IRQ ACK - value read is not used */
89		device_set_input_line(m_maincpu, 3, CLEAR_LINE);
90		device_set_input_line(m_maincpu, 4, CLEAR_LINE);
	89	m_maincpu->set_input_line(3, CLEAR_LINE);
	90	m_maincpu->set_input_line(4, CLEAR_LINE);
91	91	return 0;
92	92	}
93	93
r17814	r17815
712	712	static void sound_irq(device_t *device, int state)
713	713	{
714	714	cninja_state *driver_state = device->machine().driver_data<cninja_state>();
715		device_set_input_line(driver_state->m_audiocpu, 1, state); /* IRQ 2 */
	715	driver_state->m_audiocpu->set_input_line(1, state); /* IRQ 2 */
716	716	}
717	717
718	718	static void sound_irq2(device_t *device, int state)
719	719	{
720	720	cninja_state *driver_state = device->machine().driver_data<cninja_state>();
721		device_set_input_line(driver_state->m_audiocpu, 0, state);
	721	driver_state->m_audiocpu->set_input_line(0, state);
722	722	}
723	723
724	724	WRITE8_MEMBER(cninja_state::sound_bankswitch_w)

trunk/src/mame/drivers/missile.c

r17814	r17815
440	440
441	441	/* assert the IRQ if not already asserted */
442	442	state->m_irq_state = (~curv >> 5) & 1;
443		device_set_input_line(state->m_maincpu, 0, state->m_irq_state ? ASSERT_LINE : CLEAR_LINE);
	443	state->m_maincpu->set_input_line(0, state->m_irq_state ? ASSERT_LINE : CLEAR_LINE);
444	444
445	445	/* force an update while we're here */
446	446	machine.primary_screen->update_partial(v_to_scanline(state, curv));
r17814	r17815
540	540	static MACHINE_RESET( missile )
541	541	{
542	542	missile_state *state = machine.driver_data<missile_state>();
543		device_set_input_line(state->m_maincpu, 0, CLEAR_LINE);
	543	state->m_maincpu->set_input_line(0, CLEAR_LINE);
544	544	state->m_irq_state = 0;
545	545	}
546	546
r17814	r17815
617	617	videoram[vramaddr] = (videoram[vramaddr] & vrammask) | (vramdata & ~vrammask);
618	618
619	619	/* account for the extra clock cycle */
620		device_adjust_icount(&space->device(), -1);
	620	space->device().execute().adjust_icount(-1);
621	621	}
622	622	}
623	623
r17814	r17815
653	653	result &= ~0x20;
654	654
655	655	/* account for the extra clock cycle */
656		device_adjust_icount(&space->device(), -1);
	656	space->device().execute().adjust_icount(-1);
657	657	}
658	658	return result;
659	659	}
r17814	r17815
759	759	{
760	760	if (m_irq_state)
761	761	{
762		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	762	m_maincpu->set_input_line(0, CLEAR_LINE);
763	763	m_irq_state = 0;
764	764	}
765	765	}

trunk/src/mame/drivers/go2000.c

r17814	r17815
48	48	//  UINT16 *  m_paletteram;   // currently this uses generic palette handling
49	49
50	50	/* devices */
51		device_t *m_soundcpu;
	51	cpu_device *m_soundcpu;
52	52	DECLARE_WRITE16_MEMBER(sound_cmd_w);
53	53	DECLARE_WRITE8_MEMBER(go2000_pcm_1_bankswitch_w);
54	54	};
r17814	r17815
57	57	WRITE16_MEMBER(go2000_state::sound_cmd_w)
58	58	{
59	59	soundlatch_byte_w(space, offset, data & 0xff);
60		device_set_input_line(m_soundcpu, 0, HOLD_LINE);
	60	m_soundcpu->set_input_line(0, HOLD_LINE);
61	61	}
62	62
63	63	static ADDRESS_MAP_START( go2000_map, AS_PROGRAM, 16, go2000_state )
r17814	r17815
318	318
319	319	state->membank("bank1")->set_entry(0);
320	320
321		state->m_soundcpu = machine.device("soundcpu");
	321	state->m_soundcpu = machine.device<cpu_device>("soundcpu");
322	322	}
323	323
324	324	static MACHINE_CONFIG_START( go2000, go2000_state )

trunk/src/mame/drivers/jack.c

r17814	r17815
64	64	WRITE8_MEMBER(jack_state::jack_sh_command_w)
65	65	{
66	66	soundlatch_byte_w(space, 0, data);
67		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	67	m_audiocpu->set_input_line(0, HOLD_LINE);
68	68	}
69	69
70	70
r17814	r17815
856	856	{
857	857	/* TODO: looks hackish to me ... */
858	858	if (!(device->machine().root_device().ioport("IN2")->read() & 0x80))
859		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	859	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
860	860	}
861	861
862	862	static MACHINE_CONFIG_DERIVED( joinem, jack )

trunk/src/mame/drivers/dogfgt.c

r17814	r17815
28	28	{
29	29	/* bit 0 used but unknown */
30	30	if (data & 0x04)
31		device_set_input_line(m_subcpu, 0, ASSERT_LINE);
	31	m_subcpu->set_input_line(0, ASSERT_LINE);
32	32	}
33	33
34	34	WRITE8_MEMBER(dogfgt_state::sub_irqack_w)
35	35	{
36		device_set_input_line(m_subcpu, 0, CLEAR_LINE);
	36	m_subcpu->set_input_line(0, CLEAR_LINE);
37	37	}
38	38
39	39	WRITE8_MEMBER(dogfgt_state::dogfgt_soundlatch_w)
r17814	r17815
210	210	{
211	211	dogfgt_state *state = machine.driver_data<dogfgt_state>();
212	212
213		state->m_subcpu = machine.device("sub");
	213	state->m_subcpu = machine.device<cpu_device>("sub");
214	214
215	215	state->save_item(NAME(state->m_bm_plane));
216	216	state->save_item(NAME(state->m_lastflip));

trunk/src/mame/drivers/deshoros.c

r17814	r17815
89	89
90	90	WRITE8_MEMBER(destiny_state::firq_ack_w)
91	91	{
92		device_set_input_line(m_maincpu, M6809_FIRQ_LINE, CLEAR_LINE);
	92	m_maincpu->set_input_line(M6809_FIRQ_LINE, CLEAR_LINE);
93	93	}
94	94
95	95	WRITE8_MEMBER(destiny_state::nmi_ack_w)
96	96	{
97		device_set_input_line(m_maincpu, INPUT_LINE_NMI, CLEAR_LINE);
	97	m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
98	98	}
99	99
100	100	READ8_MEMBER(destiny_state::printer_status_r)
r17814	r17815
147	147	{
148	148	// NMI on Coin SW or Service SW
149	149	if (oldval)
150		device_set_input_line(m_maincpu, INPUT_LINE_NMI, ASSERT_LINE);
	150	m_maincpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
151	151
152	152	// coincounter on coin insert
153	153	if (((int)(FPTR)param) == 0)

trunk/src/mame/drivers/splash.c

r17814	r17815
67	67	}
68	68
69	69	// give the z80 time to see it
70		device_spin_until_time(&space.device(), attotime::from_usec(40));
	70	space.device().execute().spin_until_time(attotime::from_usec(40));
71	71	}
72	72
73	73	WRITE16_MEMBER(splash_state::splash_coin_w)
r17814	r17815
148	148	{
149	149	splash_state * state = machine.driver_data<splash_state>();
150	150	int irq = (state->m_sound_irq ? 0x08 : 0) | ((state->m_vblank_irq) ? 0x18 : 0);
151		device_set_input_line_and_vector(machine.device("audiocpu"), 0, irq ? ASSERT_LINE : CLEAR_LINE, 0xc7 | irq);
	151	machine.device("audiocpu")->execute().set_input_line_and_vector(0, irq ? ASSERT_LINE : CLEAR_LINE, 0xc7 | irq);
152	152	}
153	153
154	154	WRITE8_MEMBER(splash_state::roldfrog_vblank_ack_w)
r17814	r17815
600	600	if (state->m_msm_toggle1 == 0)
601	601	{
602	602	state->m_msm_source|=1;
603		device_set_input_line_and_vector(device->machine().device("audiocpu"), 0, HOLD_LINE, 0x38);
	603	device->machine().device("audiocpu")->execute().set_input_line_and_vector(0, HOLD_LINE, 0x38);
604	604	}
605	605	}
606	606	}
r17814	r17815
616	616	if (state->m_msm_toggle2 == 0)
617	617	{
618	618	state->m_msm_source|=2;
619		device_set_input_line_and_vector(device->machine().device("audiocpu"), 0, HOLD_LINE, 0x38);
	619	device->machine().device("audiocpu")->execute().set_input_line_and_vector(0, HOLD_LINE, 0x38);
620	620	}
621	621	}
622	622	}

trunk/src/mame/drivers/subsino2.c

r17814	r17815
866	866	subsino2_state *state = device->machine().driver_data<subsino2_state>();
867	867	if ( ((state->m_am188em_regs[AM188EM_IMASK+0] & 0x10) == 0) ||   // IMASK.I0 mask
868	868	((state->m_am188em_regs[AM188EM_I0CON+0] & 0x08) == 0) )   // I0CON.MSK mask
869		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0x0c);   // INT0 (background scrolling in xplan)
	869	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0x0c);   // INT0 (background scrolling in xplan)
870	870	}
871	871
872	872	static TIMER_DEVICE_CALLBACK( am188em_timer2_irq )

trunk/src/mame/drivers/m63.c

r17814	r17815
155	155	INT16    *m_samplebuf;
156	156
157	157	/* sound devices */
158		device_t *m_soundcpu;
	158	cpu_device *m_soundcpu;
159	159	device_t *m_ay1;
160	160	device_t *m_ay2;
161	161	samples_device *m_samples;
r17814	r17815
379	379
380	380	WRITE8_MEMBER(m63_state::snd_irq_w)
381	381	{
382		device_set_input_line(m_soundcpu, 0, ASSERT_LINE);
	382	m_soundcpu->set_input_line(0, ASSERT_LINE);
383	383	machine().scheduler().synchronize();
384	384	}
385	385
r17814	r17815
409	409	m_p2 = data;
410	410	if((m_p2 & 0xf0) == 0x50)
411	411	{
412		device_set_input_line(m_soundcpu, 0, CLEAR_LINE);
	412	m_soundcpu->set_input_line(0, CLEAR_LINE);
413	413	}
414	414	}
415	415
r17814	r17815
725	725	{
726	726	m63_state *state = machine.driver_data<m63_state>();
727	727
728		state->m_soundcpu = machine.device("soundcpu");
	728	state->m_soundcpu = machine.device<cpu_device>("soundcpu");
729	729	state->m_ay1 = machine.device("ay1");
730	730	state->m_ay2 = machine.device("ay2");
731	731	state->m_samples = machine.device<samples_device>("samples");
r17814	r17815
759	759	m63_state *state = device->machine().driver_data<m63_state>();
760	760
761	761	if(state->m_nmi_mask)
762		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	762	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
763	763	}
764	764
765	765	static MACHINE_CONFIG_START( m63, m63_state )

trunk/src/mame/drivers/route16.c

r17814	r17815
107	107	if (offset >= 0x0313 && offset <= 0x0319 && data == 0xff)
108	108	{
109	109	// Let the other CPU run
110		device_yield(&space.device());
	110	space.device().execute().yield();
111	111	}
112	112	}
113	113

trunk/src/mame/drivers/snk6502.c

r17814	r17815
745	745	snk6502_state *state = device->machine().driver_data<snk6502_state>();
746	746
747	747	if(state->m_irq_mask)
748		device_set_input_line(device, M6502_IRQ_LINE, HOLD_LINE);   /* one IRQ per frame */
	748	device->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);   /* one IRQ per frame */
749	749	}
750	750
751	751	static INTERRUPT_GEN( snk6502_interrupt )
752	752	{
753		device_set_input_line(device, M6502_IRQ_LINE, HOLD_LINE);   /* one IRQ per frame */
	753	device->execute().set_input_line(M6502_IRQ_LINE, HOLD_LINE);   /* one IRQ per frame */
754	754	}
755	755
756	756

trunk/src/mame/drivers/polyplay.c

r17814	r17815
121	121
122	122	static INTERRUPT_GEN( periodic_interrupt )
123	123	{
124		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0x4e);
	124	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0x4e);
125	125	}
126	126
127	127
r17814	r17815
134	134	else
135	135	{
136	136	if (state->m_last == 0)    /* coin inserted */
137		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0x50);
	137	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0x50);
138	138
139	139	state->m_last = 1;
140	140	}

trunk/src/mame/drivers/dassault.c

r17814	r17815
178	178	WRITE16_MEMBER(dassault_state::dassault_sound_w)
179	179	{
180	180	soundlatch_byte_w(space, 0, data & 0xff);
181		device_set_input_line(m_audiocpu, 0, HOLD_LINE); /* IRQ1 */
	181	m_audiocpu->set_input_line(0, HOLD_LINE); /* IRQ1 */
182	182	}
183	183
184	184	/* The CPU-CPU irq controller is overlaid onto the end of the shared memory */
r17814	r17815
186	186	{
187	187	switch (offset)
188	188	{
189		case 0: device_set_input_line(m_maincpu, 5, CLEAR_LINE); break;
190		case 1: device_set_input_line(m_subcpu, 6, CLEAR_LINE); break;
	189	case 0: m_maincpu->set_input_line(5, CLEAR_LINE); break;
	190	case 1: m_subcpu->set_input_line(6, CLEAR_LINE); break;
191	191	}
192	192	return m_shared_ram[(0xffc / 2) + offset]; /* The values probably don't matter */
193	193	}
r17814	r17815
196	196	{
197	197	switch (offset)
198	198	{
199		case 0: device_set_input_line(m_maincpu, 5, ASSERT_LINE); break;
200		case 1: device_set_input_line(m_subcpu, 6, ASSERT_LINE); break;
	199	case 0: m_maincpu->set_input_line(5, ASSERT_LINE); break;
	200	case 1: m_subcpu->set_input_line(6, ASSERT_LINE); break;
201	201	}
202	202
203	203	COMBINE_DATA(&m_shared_ram[(0xffc / 2) + offset]); /* The values probably don't matter */
r17814	r17815
448	448	static void sound_irq(device_t *device, int state)
449	449	{
450	450	dassault_state *driver_state = device->machine().driver_data<dassault_state>();
451		device_set_input_line(driver_state->m_audiocpu, 1, state);
	451	driver_state->m_audiocpu->set_input_line(1, state);
452	452	}
453	453
454	454	WRITE8_MEMBER(dassault_state::sound_bankswitch_w)

trunk/src/mame/drivers/tatsumi.c

r17814	r17815
851	851
852	852	static INTERRUPT_GEN( roundup5_interrupt )
853	853	{
854		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0xc8/4);   /* VBL */
	854	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0xc8/4);   /* VBL */
855	855	}
856	856
857	857	static void apache3_68000_reset(device_t *device)

trunk/src/mame/drivers/supbtime.c

r17814	r17815
53	53	WRITE16_MEMBER(supbtime_state::sound_w)
54	54	{
55	55	soundlatch_byte_w(space, 0, data & 0xff);
56		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	56	m_audiocpu->set_input_line(0, HOLD_LINE);
57	57	}
58	58
59	59	/******************************************************************************/
r17814	r17815
311	311	static void sound_irq(device_t *device, int state)
312	312	{
313	313	supbtime_state *driver_state = device->machine().driver_data<supbtime_state>();
314		device_set_input_line(driver_state->m_audiocpu, 1, state); /* IRQ 2 */
	314	driver_state->m_audiocpu->set_input_line(1, state); /* IRQ 2 */
315	315	}
316	316
317	317	static const ym2151_interface ym2151_config =
r17814	r17815
334	334	{
335	335	supbtime_state *state = machine.driver_data<supbtime_state>();
336	336
337		state->m_maincpu = machine.device("maincpu");
338		state->m_audiocpu = machine.device("audiocpu");
	337	state->m_maincpu = machine.device<cpu_device>("maincpu");
	338	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
339	339	state->m_deco_tilegen1 = machine.device("tilegen1");
340	340	}
341	341

trunk/src/mame/drivers/toratora.c

r17814	r17815
39	39	UINT8      m_clear_tv;
40	40
41	41	/* devices */
42		device_t *m_maincpu;
	42	cpu_device *m_maincpu;
43	43	pia6821_device *m_pia_u1;
44	44	pia6821_device *m_pia_u2;
45	45	pia6821_device *m_pia_u3;
r17814	r17815
144	144	int combined_state = pia->irq_a_state() | pia->irq_b_state();
145	145
146	146	logerror("GEN IRQ: %x\n", combined_state);
147		device_set_input_line(m_maincpu, 0, combined_state ? ASSERT_LINE : CLEAR_LINE);
	147	m_maincpu->set_input_line(0, combined_state ? ASSERT_LINE : CLEAR_LINE);
148	148	}
149	149
150	150
r17814	r17815
425	425	{
426	426	toratora_state *state = machine.driver_data<toratora_state>();
427	427
428		state->m_maincpu = machine.device("maincpu");
	428	state->m_maincpu = machine.device<cpu_device>("maincpu");
429	429	state->m_pia_u1 = machine.device<pia6821_device>("pia_u1");
430	430	state->m_pia_u2 = machine.device<pia6821_device>("pia_u2");
431	431	state->m_pia_u3 = machine.device<pia6821_device>("pia_u3");

trunk/src/mame/drivers/gbusters.c

r17814	r17815
24	24	gbusters_state *state = device->machine().driver_data<gbusters_state>();
25	25
26	26	if (k052109_is_irq_enabled(state->m_k052109))
27		device_set_input_line(device, KONAMI_IRQ_LINE, HOLD_LINE);
	27	device->execute().set_input_line(KONAMI_IRQ_LINE, HOLD_LINE);
28	28	}
29	29
30	30	READ8_MEMBER(gbusters_state::bankedram_r)
r17814	r17815
101	101
102	102	WRITE8_MEMBER(gbusters_state::gbusters_sh_irqtrigger_w)
103	103	{
104		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	104	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
105	105	}
106	106
107	107	WRITE8_MEMBER(gbusters_state::gbusters_snd_bankswitch_w)
r17814	r17815
276	276
277	277	state->m_generic_paletteram_8.allocate(0x800);
278	278
279		state->m_maincpu = machine.device("maincpu");
280		state->m_audiocpu = machine.device("audiocpu");
	279	state->m_maincpu = machine.device<cpu_device>("maincpu");
	280	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
281	281	state->m_k052109 = machine.device("k052109");
282	282	state->m_k051960 = machine.device("k051960");
283	283	state->m_k007232 = machine.device("k007232");

trunk/src/mame/drivers/megaplay.c

r17814	r17815
87	87	segae_hintpending = 1;
88	88
89	89	if  ((segae_vdp_regs[0][0] & 0x10)) {
90		device_set_input_line(device, 0, HOLD_LINE);
	90	device->execute().set_input_line(0, HOLD_LINE);
91	91	return;
92	92	}
93	93
r17814	r17815
100	100	hintcount = segae_vdp_regs[0][10];
101	101
102	102	if ( (sline<0xe0) && (segae_vintpending) ) {
103		device_set_input_line(device, 0, HOLD_LINE);
	103	device->execute().set_input_line(0, HOLD_LINE);
104	104	}
105	105	}
106	106

trunk/src/mame/drivers/m72.c

r17814	r17815
293	293	m72_state *state = device->machine().driver_data<m72_state>();
294	294	//state->m_mcu_snd_cmd_latch |= 0x11; /* 0x10 is special as well - FIXME */
295	295	state->m_mcu_snd_cmd_latch = 0x11;// | (machine.rand() & 1); /* 0x10 is special as well - FIXME */
296		device_set_input_line(device, 1, ASSERT_LINE);
	296	device->execute().set_input_line(1, ASSERT_LINE);
297	297	}
298	298
299	299	READ8_MEMBER(m72_state::m72_mcu_sample_r)

trunk/src/mame/drivers/crgolf.c

r17814	r17815
75	75	{
76	76	crgolf_state *state = machine.driver_data<crgolf_state>();
77	77
78		state->m_maincpu = machine.device("maincpu");
79		state->m_audiocpu = machine.device("audiocpu");
	78	state->m_maincpu = machine.device<cpu_device>("maincpu");
	79	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
80	80
81	81	/* configure the banking */
82	82	state->membank("bank1")->configure_entries(0, 16, state->memregion("maincpu")->base() + 0x10000, 0x2000);
r17814	r17815
153	153	{
154	154	crgolf_state *state = machine.driver_data<crgolf_state>();
155	155
156		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, ASSERT_LINE);
	156	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
157	157	state->m_main_to_sound_data = param;
158	158	}
159	159
r17814	r17815
167	167	READ8_MEMBER(crgolf_state::main_to_sound_r)
168	168	{
169	169
170		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, CLEAR_LINE);
	170	m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
171	171	return m_main_to_sound_data;
172	172	}
173	173
r17814	r17815
183	183	{
184	184	crgolf_state *state = machine.driver_data<crgolf_state>();
185	185
186		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, ASSERT_LINE);
	186	state->m_maincpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
187	187	state->m_sound_to_main_data = param;
188	188	}
189	189
r17814	r17815
197	197	READ8_MEMBER(crgolf_state::sound_to_main_r)
198	198	{
199	199
200		device_set_input_line(m_maincpu, INPUT_LINE_NMI, CLEAR_LINE);
	200	m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
201	201	return m_sound_to_main_data;
202	202	}
203	203

trunk/src/mame/drivers/mastboy.c

r17814	r17815
697	697	mastboy_state *state = device->machine().driver_data<mastboy_state>();
698	698	if ((state->m_irq0_ack & 1) == 1)
699	699	{
700		device_set_input_line(device, 0, ASSERT_LINE);
	700	device->execute().set_input_line(0, ASSERT_LINE);
701	701	}
702	702	}
703	703

trunk/src/mame/drivers/jclub2.c

r17814	r17815
674	674	int scanline = param;
675	675
676	676	if(scanline == 248)
677		device_set_input_line(state->m_maincpu, 5, HOLD_LINE);
	677	state->m_maincpu->set_input_line(5, HOLD_LINE);
678	678
679	679	if(scanline == 0)
680		device_set_input_line(state->m_maincpu, 3, HOLD_LINE);
	680	state->m_maincpu->set_input_line(3, HOLD_LINE);
681	681
682	682	if(scanline == 128)
683		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	683	state->m_maincpu->set_input_line(4, HOLD_LINE);
684	684	}
685	685
686	686	static MACHINE_CONFIG_START( darkhors, darkhors_state )

trunk/src/mame/drivers/topspeed.c

r17814	r17815
300	300	/* however this fails when recovering from a save state
301	301	if cpu B is disabled !! */
302	302	topspeed_state *state = machine.driver_data<topspeed_state>();
303		device_set_input_line(state->m_subcpu, INPUT_LINE_RESET, (state->m_cpua_ctrl &0x1) ? CLEAR_LINE : ASSERT_LINE);
	303	state->m_subcpu->set_input_line(INPUT_LINE_RESET, (state->m_cpua_ctrl &0x1) ? CLEAR_LINE : ASSERT_LINE);
304	304	}
305	305
306	306	WRITE16_MEMBER(topspeed_state::cpua_ctrl_w)
r17814	r17815
325	325	static TIMER_CALLBACK( topspeed_interrupt6  )
326	326	{
327	327	topspeed_state *state = machine.driver_data<topspeed_state>();
328		device_set_input_line(state->m_maincpu, 6, HOLD_LINE);
	328	state->m_maincpu->set_input_line(6, HOLD_LINE);
329	329	}
330	330
331	331	/* 68000 B */
r17814	r17815
333	333	static TIMER_CALLBACK( topspeed_cpub_interrupt6 )
334	334	{
335	335	topspeed_state *state = machine.driver_data<topspeed_state>();
336		device_set_input_line(state->m_subcpu, 6, HOLD_LINE);   /* assumes Z80 sandwiched between the 68Ks */
	336	state->m_subcpu->set_input_line(6, HOLD_LINE);   /* assumes Z80 sandwiched between the 68Ks */
337	337	}
338	338
339	339
r17814	r17815
341	341	{
342	342	/* Unsure how many int6's per frame */
343	343	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(200000 - 500), FUNC(topspeed_interrupt6));
344		device_set_input_line(device, 5, HOLD_LINE);
	344	device->execute().set_input_line(5, HOLD_LINE);
345	345	}
346	346
347	347	static INTERRUPT_GEN( topspeed_cpub_interrupt )
348	348	{
349	349	/* Unsure how many int6's per frame */
350	350	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(200000 - 500), FUNC(topspeed_cpub_interrupt6));
351		device_set_input_line(device, 5, HOLD_LINE);
	351	device->execute().set_input_line(5, HOLD_LINE);
352	352	}
353	353
354	354
r17814	r17815
661	661	static void irq_handler( device_t *device, int irq )   /* assumes Z80 sandwiched between 68Ks */
662	662	{
663	663	topspeed_state *state = device->machine().driver_data<topspeed_state>();
664		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	664	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
665	665	}
666	666
667	667	static const ym2151_interface ym2151_config =
r17814	r17815
699	699
700	700	state->membank("bank10")->configure_entries(0, 4, state->memregion("audiocpu")->base() + 0xc000, 0x4000);
701	701
702		state->m_maincpu = machine.device("maincpu");
703		state->m_subcpu = machine.device("subcpu");
704		state->m_audiocpu = machine.device("audiocpu");
	702	state->m_maincpu = machine.device<cpu_device>("maincpu");
	703	state->m_subcpu = machine.device<cpu_device>("subcpu");
	704	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
705	705	state->m_tc0220ioc = machine.device("tc0220ioc");
706	706	state->m_pc080sn_1 = machine.device("pc080sn_1");
707	707	state->m_pc080sn_2 = machine.device("pc080sn_2");

trunk/src/mame/drivers/amspdwy.c

r17814	r17815
71	71	WRITE8_MEMBER(amspdwy_state::amspdwy_sound_w)
72	72	{
73	73	soundlatch_byte_w(space, 0, data);
74		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	74	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
75	75	}
76	76
77	77	static ADDRESS_MAP_START( amspdwy_map, AS_PROGRAM, 8, amspdwy_state )
r17814	r17815
242	242	static void irq_handler( device_t *device, int irq )
243	243	{
244	244	amspdwy_state *state = device->machine().driver_data<amspdwy_state>();
245		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	245	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
246	246	}
247	247
248	248	static const ym2151_interface amspdwy_ym2151_interface =
r17814	r17815
254	254	{
255	255	amspdwy_state *state = machine.driver_data<amspdwy_state>();
256	256
257		state->m_audiocpu = machine.device("audiocpu");
	257	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
258	258
259	259	state->save_item(NAME(state->m_flipscreen));
260	260	state->save_item(NAME(state->m_wheel_old));

trunk/src/mame/drivers/fantland.c

r17814	r17815
76	76	WRITE8_MEMBER(fantland_state::fantland_soundlatch_w)
77	77	{
78	78	soundlatch_byte_w(space, 0, data);
79		device_set_input_line(m_audio_cpu, INPUT_LINE_NMI, PULSE_LINE);
	79	m_audio_cpu->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
80	80	}
81	81
82	82	WRITE16_MEMBER(fantland_state::fantland_soundlatch_16_w)
r17814	r17815
835	835	{
836	836	fantland_state *state = device->machine().driver_data<fantland_state>();
837	837	if (state->m_nmi_enable & 8)
838		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	838	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
839	839	}
840	840
841	841	static INTERRUPT_GEN( fantland_sound_irq )
842	842	{
843		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0x80 / 4);
	843	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0x80 / 4);
844	844	}
845	845
846	846	static MACHINE_CONFIG_START( fantland, fantland_state )
r17814	r17815
888	888	static void galaxygn_sound_irq( device_t *device, int line )
889	889	{
890	890	fantland_state *state = device->machine().driver_data<fantland_state>();
891		device_set_input_line_and_vector(state->m_audio_cpu, 0, line ? ASSERT_LINE : CLEAR_LINE, 0x80/4);
	891	state->m_audio_cpu->execute().set_input_line_and_vector(0, line ? ASSERT_LINE : CLEAR_LINE, 0x80/4);
892	892	}
893	893
894	894	static const ym2151_interface galaxygn_ym2151_interface =

trunk/src/mame/drivers/thunderx.c

r17814	r17815
26	26	thunderx_state *state = device->machine().driver_data<thunderx_state>();
27	27
28	28	if (k052109_is_irq_enabled(state->m_k052109))
29		device_set_input_line(device, KONAMI_IRQ_LINE, HOLD_LINE);
	29	device->execute().set_input_line(KONAMI_IRQ_LINE, HOLD_LINE);
30	30	}
31	31
32	32	static TIMER_CALLBACK( thunderx_firq_callback )
33	33	{
34	34	thunderx_state *state = machine.driver_data<thunderx_state>();
35		device_set_input_line(state->m_maincpu, KONAMI_FIRQ_LINE, HOLD_LINE);
	35	state->m_maincpu->set_input_line(KONAMI_FIRQ_LINE, HOLD_LINE);
36	36	}
37	37
38	38	READ8_MEMBER(thunderx_state::scontra_bankedram_r)
r17814	r17815
353	353
354	354	WRITE8_MEMBER(thunderx_state::thunderx_sh_irqtrigger_w)
355	355	{
356		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	356	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
357	357	}
358	358
359	359	WRITE8_MEMBER(thunderx_state::scontra_snd_bankswitch_w)
r17814	r17815
609	609
610	610	state->m_generic_paletteram_8.allocate(0x800);
611	611
612		state->m_maincpu = machine.device("maincpu");
613		state->m_audiocpu = machine.device("audiocpu");
	612	state->m_maincpu = machine.device<cpu_device>("maincpu");
	613	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
614	614	state->m_k007232 = machine.device("k007232");
615	615	state->m_k052109 = machine.device("k052109");
616	616	state->m_k051960 = machine.device("k051960");

trunk/src/mame/drivers/toypop.c

r17814	r17815
107	107	device_t *namcoio_2 = device->machine().device("56xx_2");
108	108
109	109	if(state->m_main_irq_mask)
110		device_set_input_line(device, 0, HOLD_LINE);
	110	device->execute().set_input_line(0, HOLD_LINE);
111	111
112	112	if (!namcoio_read_reset_line(namcoio_0))      /* give the cpu a tiny bit of time to write the command before processing it */
113	113	device->machine().scheduler().timer_set(attotime::from_usec(50), FUNC(namcoio_run));
r17814	r17815
125	125	toypop_state *state = device->machine().driver_data<toypop_state>();
126	126
127	127	if(state->m_sound_irq_mask)
128		device_set_input_line(device, 0, HOLD_LINE);
	128	device->execute().set_input_line(0, HOLD_LINE);
129	129	}
130	130
131	131	WRITE8_MEMBER(toypop_state::toypop_sound_clear_w)
r17814	r17815
165	165	{
166	166	toypop_state *state = device->machine().driver_data<toypop_state>();
167	167	if (state->m_interrupt_enable_68k)
168		device_set_input_line(device, 6, HOLD_LINE);
	168	device->execute().set_input_line(6, HOLD_LINE);
169	169	}
170	170
171	171	WRITE16_MEMBER(toypop_state::toypop_m68000_interrupt_enable_w)

trunk/src/mame/drivers/tumbleb.c

r17814	r17815
441	441	static INTERRUPT_GEN( tumbleb2_interrupt )
442	442	{
443	443	tumbleb_state *state = device->machine().driver_data<tumbleb_state>();
444		device_set_input_line(device, 6, HOLD_LINE);
	444	device->execute().set_input_line(6, HOLD_LINE);
445	445	tumbleb2_playmusic(state->m_oki);
446	446	}
447	447
r17814	r17815
701	701	WRITE16_MEMBER(tumbleb_state::jumpkids_sound_w)
702	702	{
703	703	soundlatch_byte_w(space, 0, data & 0xff);
704		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	704	m_audiocpu->set_input_line(0, HOLD_LINE);
705	705	}
706	706
707	707	static ADDRESS_MAP_START( suprtrio_main_map, AS_PROGRAM, 16, tumbleb_state )
r17814	r17815
740	740	{
741	741	soundlatch_byte_w(space, 0, data & 0xff);
742	742	// needed for Super Trio which reads the sound with polling
743		// device_spin_until_time(&space.device(), attotime::from_usec(100));
	743	// space.device().execute().spin_until_time(attotime::from_usec(100));
744	744	machine().scheduler().boost_interleave(attotime::zero, attotime::from_usec(20));
745	745
746	746	}
r17814	r17815
1867	1867	{
1868	1868	tumbleb_state *state = machine.driver_data<tumbleb_state>();
1869	1869
1870		state->m_maincpu = machine.device("maincpu");
1871		state->m_audiocpu = machine.device("audiocpu");
	1870	state->m_maincpu = machine.device<cpu_device>("maincpu");
	1871	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
1872	1872	state->m_oki = machine.device("oki");
1873	1873
1874	1874	state->save_item(NAME(state->m_music_command));
r17814	r17815
2044	2044	static void semicom_irqhandler( device_t *device, int irq )
2045	2045	{
2046	2046	tumbleb_state *state = device->machine().driver_data<tumbleb_state>();
2047		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	2047	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
2048	2048	}
2049	2049
2050	2050

trunk/src/mame/drivers/taitotz.c

r17814	r17815
1845	1845	if (m_io_share_ram[0xfff] == 0x1010 || m_io_share_ram[0xfff] == 0x1020 ||
1846	1846	m_io_share_ram[0xfff] == 0x6000 || m_io_share_ram[0xfff] == 0x6010)
1847	1847	{
1848		//device_spin_until_trigger(machine().device("maincpu"), PPC_TLCS_COMM_TRIGGER);
1849		device_spin_until_interrupt(machine().device("maincpu"));
	1848	//machine().device("maincpu")->execute().spin_until_trigger(PPC_TLCS_COMM_TRIGGER);
	1849	machine().device("maincpu")->execute().spin_until_interrupt();
1850	1850	}
1851	1851
1852	1852	// pwrshovl sometimes writes commands during command handling... make sure that doesn't happen
1853	1853	if (m_io_share_ram[0xfff] == 0x0000)
1854	1854	{
1855		device_spin_until_time(machine().device("maincpu"), attotime::from_usec(50));
	1855	machine().device("maincpu")->execute().spin_until_time(attotime::from_usec(50));
1856	1856	}
1857	1857
1858	1858	machine().scheduler().trigger(TLCS_PPC_COMM_TRIGGER);
r17814	r17815
1931	1931
1932	1932	// The PPC is now free to continue running
1933	1933	//machine().scheduler().trigger(PPC_TLCS_COMM_TRIGGER);
1934		//device_yield(machine().device("iocpu"));
	1934	//machine().device("iocpu")->execute().yield();
1935	1935	}
1936	1936
1937	1937	if (offset == 0x1ffe)
1938	1938	{
1939	1939	if (m_io_share_ram[0xfff] == 0 && m_io_share_ram[0xffe] == 0x1012)
1940	1940	{
1941		//device_spin_until_trigger(machine().device("iocpu"), TLCS_PPC_COMM_TRIGGER);
1942		device_yield(machine().device("iocpu"));
	1941	//machine().device("iocpu")->execute().spin_until_trigger(TLCS_PPC_COMM_TRIGGER);
	1942	machine().device("iocpu")->execute().yield();
1943	1943	machine().scheduler().trigger(PPC_TLCS_COMM_TRIGGER);
1944	1944	}
1945	1945	}

trunk/src/mame/drivers/cabaret.c

r17814	r17815
328	328	{
329	329	cabaret_state *state = device->machine().driver_data<cabaret_state>();
330	330	if (state->m_nmi_enable & 0x80)
331		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	331	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
332	332	}
333	333
334	334	static MACHINE_CONFIG_START( cabaret, cabaret_state )

trunk/src/mame/drivers/kchamp.c

r17814	r17815
82	82	WRITE8_MEMBER(kchamp_state::sound_reset_w)
83	83	{
84	84	if (!(data & 1))
85		device_set_input_line(m_audiocpu, INPUT_LINE_RESET, PULSE_LINE);
	85	m_audiocpu->set_input_line(INPUT_LINE_RESET, PULSE_LINE);
86	86	}
87	87
88	88	WRITE8_MEMBER(kchamp_state::sound_control_w)
r17814	r17815
95	95	WRITE8_MEMBER(kchamp_state::sound_command_w)
96	96	{
97	97	soundlatch_byte_w(space, 0, data);
98		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	98	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
99	99	}
100	100
101	101	WRITE8_MEMBER(kchamp_state::sound_msm_w)
r17814	r17815
144	144	********************/
145	145	READ8_MEMBER(kchamp_state::sound_reset_r)
146	146	{
147		device_set_input_line(m_audiocpu, INPUT_LINE_RESET, PULSE_LINE);
	147	m_audiocpu->set_input_line(INPUT_LINE_RESET, PULSE_LINE);
148	148	return 0;
149	149	}
150	150
r17814	r17815
344	344	{
345	345	kchamp_state *state = device->machine().driver_data<kchamp_state>();
346	346	if (state->m_nmi_enable)
347		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	347	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
348	348	}
349	349
350	350	static void msmint( device_t *device )
r17814	r17815
361	361	if (!(state->m_counter ^= 1))
362	362	{
363	363	if (state->m_sound_nmi_enable)
364		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	364	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
365	365	}
366	366	}
367	367
r17814	r17815
379	379	{
380	380	kchamp_state *state = device->machine().driver_data<kchamp_state>();
381	381	if (state->m_sound_nmi_enable)
382		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	382	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
383	383	}
384	384
385	385
r17814	r17815
387	387	{
388	388	kchamp_state *state = machine.driver_data<kchamp_state>();
389	389
390		state->m_audiocpu = machine.device("audiocpu");
	390	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
391	391
392	392	state->save_item(NAME(state->m_nmi_enable));
393	393	state->save_item(NAME(state->m_sound_nmi_enable));

trunk/src/mame/drivers/m90.c

r17814	r17815
701	701
702	702	static INTERRUPT_GEN( dynablsb_interrupt )
703	703	{
704		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0x60/4);
	704	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0x60/4);
705	705	}
706	706
707	707	static INTERRUPT_GEN( bomblord_interrupt )
708	708	{
709		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0x50/4);
	709	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0x50/4);
710	710	}
711	711
712	712

trunk/src/mame/drivers/r2dx_v33.c

r17814	r17815
500	500
501	501	static INTERRUPT_GEN( rdx_v33_interrupt )
502	502	{
503		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0xc0/4);   /* VBL */
	503	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0xc0/4);   /* VBL */
504	504	}
505	505
506	506	static const gfx_layout rdx_v33_charlayout =

trunk/src/mame/drivers/lastfght.c

r17814	r17815
529	529	{
530	530	lastfght_state *state = device->machine().driver_data<lastfght_state>();
531	531
532		device_set_input_line(state->m_maincpu, H8_METRO_TIMER_HACK, HOLD_LINE);
	532	state->m_maincpu->set_input_line(H8_METRO_TIMER_HACK, HOLD_LINE);
533	533	}
534	534
535	535	static MACHINE_START( lastfght )

trunk/src/mame/drivers/superqix.c

r17814	r17815
987	987	superqix_state *state = device->machine().driver_data<superqix_state>();
988	988
989	989	if(state->m_nmi_mask)
990		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	990	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
991	991	}
992	992
993	993	static INTERRUPT_GEN( sqix_timer_irq )
r17814	r17815
995	995	superqix_state *state = device->machine().driver_data<superqix_state>();
996	996
997	997	if (state->m_nmi_mask)
998		device_set_input_line(device, INPUT_LINE_NMI, ASSERT_LINE);
	998	device->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
999	999	}
1000	1000
1001	1001

trunk/src/mame/drivers/lockon.c

r17814	r17815
56	56	m_ctrl_reg = data & 0xff;
57	57
58	58	/* Bus mastering for shared access */
59		device_set_input_line(m_ground, INPUT_LINE_HALT, data & 0x04 ? ASSERT_LINE : CLEAR_LINE);
60		device_set_input_line(m_object, INPUT_LINE_HALT, data & 0x20 ? ASSERT_LINE : CLEAR_LINE);
61		device_set_input_line(m_audiocpu, INPUT_LINE_HALT, data & 0x40 ? CLEAR_LINE : ASSERT_LINE);
	59	m_ground->execute().set_input_line(INPUT_LINE_HALT, data & 0x04 ? ASSERT_LINE : CLEAR_LINE);
	60	m_object->execute().set_input_line(INPUT_LINE_HALT, data & 0x20 ? ASSERT_LINE : CLEAR_LINE);
	61	m_audiocpu->set_input_line(INPUT_LINE_HALT, data & 0x40 ? CLEAR_LINE : ASSERT_LINE);
62	62	}
63	63
64	64	READ16_MEMBER(lockon_state::main_gnd_r)
r17814	r17815
115	115
116	116	READ16_MEMBER(lockon_state::main_z80_r)
117	117	{
118		address_space *sndspace = m_audiocpu->memory().space(AS_PROGRAM);
	118	address_space *sndspace = m_audiocpu->space(AS_PROGRAM);
119	119	return 0xff00 | sndspace->read_byte(offset);
120	120	}
121	121
122	122	WRITE16_MEMBER(lockon_state::main_z80_w)
123	123	{
124		address_space *sndspace = m_audiocpu->memory().space(AS_PROGRAM);
	124	address_space *sndspace = m_audiocpu->space(AS_PROGRAM);
125	125	sndspace->write_byte(offset, data);
126	126	}
127	127
r17814	r17815
418	418	static void ym2203_irq(device_t *device, int irq)
419	419	{
420	420	lockon_state *state = device->machine().driver_data<lockon_state>();
421		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE );
	421	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE );
422	422	}
423	423
424	424	WRITE8_MEMBER(lockon_state::ym2203_out_b)
r17814	r17815
455	455	{
456	456	lockon_state *state = machine.driver_data<lockon_state>();
457	457
458		state->m_maincpu = machine.device("maincpu");
459		state->m_audiocpu = machine.device("audiocpu");
	458	state->m_maincpu = machine.device<cpu_device>("maincpu");
	459	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
460	460	state->m_ground = machine.device("ground");
461	461	state->m_object = machine.device("object");
462	462	state->m_f2203_1l = machine.device("f2203.1l");

trunk/src/mame/drivers/kontest.c

r17814	r17815
154	154	// other bits: ?
155	155	m_control = data;
156	156
157		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	157	m_maincpu->set_input_line(0, CLEAR_LINE);
158	158	}
159	159
160	160	static ADDRESS_MAP_START( kontest_map, AS_PROGRAM, 8, kontest_state )
r17814	r17815
243	243	{
244	244	kontest_state *state = device->machine().driver_data<kontest_state>();
245	245	if (state->m_control & 8)
246		device_set_input_line(device, 0, ASSERT_LINE);
	246	device->execute().set_input_line(0, ASSERT_LINE);
247	247	}
248	248
249	249	void kontest_state::machine_start()

trunk/src/mame/drivers/gijoe.c

r17814	r17815
113	113	gijoe_state *state = machine.driver_data<gijoe_state>();
114	114
115	115	if (state->m_cur_control2 & 0x0020)
116		device_set_input_line(state->m_maincpu, 6, HOLD_LINE);
	116	state->m_maincpu->set_input_line(6, HOLD_LINE);
117	117	}
118	118
119	119	static INTERRUPT_GEN( gijoe_interrupt )
r17814	r17815
134	134
135	135	// trigger V-blank interrupt
136	136	if (state->m_cur_control2 & 0x0080)
137		device_set_input_line(device, 5, HOLD_LINE);
	137	device->execute().set_input_line(5, HOLD_LINE);
138	138	}
139	139
140	140	WRITE16_MEMBER(gijoe_state::sound_cmd_w)
r17814	r17815
148	148
149	149	WRITE16_MEMBER(gijoe_state::sound_irq_w)
150	150	{
151		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	151	m_audiocpu->set_input_line(0, HOLD_LINE);
152	152	}
153	153
154	154	READ16_MEMBER(gijoe_state::sound_status_r)
r17814	r17815
159	159	static void sound_nmi( device_t *device )
160	160	{
161	161	gijoe_state *state = device->machine().driver_data<gijoe_state>();
162		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	162	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
163	163	}
164	164
165	165	static ADDRESS_MAP_START( gijoe_map, AS_PROGRAM, 16, gijoe_state )
r17814	r17815
275	275	{
276	276	gijoe_state *state = machine.driver_data<gijoe_state>();
277	277
278		state->m_maincpu = machine.device("maincpu");
279		state->m_audiocpu = machine.device("audiocpu");
	278	state->m_maincpu = machine.device<cpu_device>("maincpu");
	279	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
280	280	state->m_k054539 = machine.device("k054539");
281	281	state->m_k056832 = machine.device("k056832");
282	282	state->m_k053246 = machine.device("k053246");

trunk/src/mame/drivers/rltennis.c

r17814	r17815
151	151	{
152	152	rltennis_state *state = device->machine().driver_data<rltennis_state>();
153	153	++state->m_unk_counter; /* frame counter? verify */
154		device_set_input_line(device, 4, HOLD_LINE);
155		device_set_input_line(device, 1, HOLD_LINE); /* hack, to avoid dead loop */
	154	device->execute().set_input_line(4, HOLD_LINE);
	155	device->execute().set_input_line(1, HOLD_LINE); /* hack, to avoid dead loop */
156	156	}
157	157
158	158	static MACHINE_START( rltennis )
159	159	{
160	160	rltennis_state *state = machine.driver_data<rltennis_state>();
161		state->m_maincpu = machine.device( "maincpu");
	161	state->m_maincpu = machine.device<cpu_device>( "maincpu");
162	162	state->m_screen = machine.device(  "screen");
163	163	state->m_dac_1 = machine.device<dac_device>("dac1");
164	164	state->m_dac_2 = machine.device<dac_device>("dac2");

trunk/src/mame/drivers/gei.c

r17814	r17815
1108	1108	gei_state *state = device->machine().driver_data<gei_state>();
1109	1109
1110	1110	if(state->m_nmi_mask)
1111		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	1111	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
1112	1112	}
1113	1113
1114	1114

trunk/src/mame/drivers/looping.c

r17814	r17815
334	334
335	335	static INTERRUPT_GEN( looping_interrupt )
336	336	{
337		device_set_input_line_and_vector(device, 0, ASSERT_LINE, 4);
	337	device->execute().set_input_line_and_vector(0, ASSERT_LINE, 4);
338	338	}
339	339
340	340

trunk/src/mame/drivers/slapfght.c

r17814	r17815
739	739	slapfght_state *state = device->machine().driver_data<slapfght_state>();
740	740
741	741	if(state->m_irq_mask)
742		device_set_input_line(device, 0, HOLD_LINE);
	742	device->execute().set_input_line(0, HOLD_LINE);
743	743	}
744	744
745	745

trunk/src/mame/drivers/psikyosh.c

r17814	r17815
349	349
350	350	static INTERRUPT_GEN(psikyosh_interrupt)
351	351	{
352		device_set_input_line(device, 4, ASSERT_LINE);
	352	device->execute().set_input_line(4, ASSERT_LINE);
353	353	}
354	354
355	355	// VBL handler writes 0x00 on entry, 0xc0 on exit
r17814	r17815
358	358	{
359	359	if (!(data & 0x00c00000))
360	360	{
361		device_set_input_line(m_maincpu, 4, CLEAR_LINE);
	361	m_maincpu->set_input_line(4, CLEAR_LINE);
362	362	}
363	363	}
364	364
r17814	r17815
785	785	static void irqhandler(device_t *device, int linestate)
786	786	{
787	787	psikyosh_state *state = device->machine().driver_data<psikyosh_state>();
788		device_set_input_line(state->m_maincpu, 12, linestate ? ASSERT_LINE : CLEAR_LINE);
	788	state->m_maincpu->set_input_line(12, linestate ? ASSERT_LINE : CLEAR_LINE);
789	789	}
790	790
791	791	static const ymf278b_interface ymf278b_config =
r17814	r17815
798	798	{
799	799	psikyosh_state *state = machine.driver_data<psikyosh_state>();
800	800
801		state->m_maincpu = machine.device("maincpu");
	801	state->m_maincpu = machine.device<cpu_device>("maincpu");
802	802
803	803	state->membank("bank2")->configure_entries(0, 0x1000, state->memregion("gfx1")->base(), 0x20000);
804	804	}

trunk/src/mame/drivers/astinvad.c

r17814	r17815
218	218	static TIMER_CALLBACK( kamikaze_int_off )
219	219	{
220	220	astinvad_state *state = machine.driver_data<astinvad_state>();
221		device_set_input_line(state->m_maincpu, 0, CLEAR_LINE);
	221	state->m_maincpu->set_input_line(0, CLEAR_LINE);
222	222	}
223	223
224	224
r17814	r17815
226	226	{
227	227	astinvad_state *state = machine.driver_data<astinvad_state>();
228	228	/* interrupts are asserted on every state change of the 128V line */
229		device_set_input_line(state->m_maincpu, 0, ASSERT_LINE);
	229	state->m_maincpu->set_input_line(0, ASSERT_LINE);
230	230	param ^= 128;
231	231	state->m_int_timer->adjust(machine.primary_screen->time_until_pos(param), param);
232	232
r17814	r17815
284	284	INPUT_CHANGED_MEMBER(astinvad_state::spaceint_coin_inserted)
285	285	{
286	286	/* coin insertion causes an NMI */
287		device_set_input_line(m_maincpu, INPUT_LINE_NMI, newval ? ASSERT_LINE : CLEAR_LINE);
	287	m_maincpu->set_input_line(INPUT_LINE_NMI, newval ? ASSERT_LINE : CLEAR_LINE);
288	288	}
289	289
290	290

trunk/src/mame/drivers/supertnk.c

r17814	r17815
167	167	static INTERRUPT_GEN( supertnk_interrupt )
168	168	{
169	169	/* On a TMS9980, a 6 on the interrupt bus means a level 4 interrupt */
170		device_set_input_line_and_vector(device, 0, ASSERT_LINE, 6);
	170	device->execute().set_input_line_and_vector(0, ASSERT_LINE, 6);
171	171	}
172	172
173	173

trunk/src/mame/drivers/boogwing.c

r17814	r17815
278	278	static void sound_irq(device_t *device, int state)
279	279	{
280	280	boogwing_state *driver_state = device->machine().driver_data<boogwing_state>();
281		device_set_input_line(driver_state->m_audiocpu, 1, state); /* IRQ 2 */
	281	driver_state->m_audiocpu->set_input_line(1, state); /* IRQ 2 */
282	282	}
283	283
284	284	WRITE8_MEMBER(boogwing_state::sound_bankswitch_w)

trunk/src/mame/drivers/esh.c

r17814	r17815
284	284	static INTERRUPT_GEN( vblank_callback_esh )
285	285	{
286	286	// IRQ
287		device_set_input_line(device, 0, ASSERT_LINE);
	287	device->execute().set_input_line(0, ASSERT_LINE);
288	288	device->machine().scheduler().timer_set(attotime::from_usec(50), FUNC(irq_stop));
289	289	}
290	290

trunk/src/mame/drivers/eolithsp.c

r17814	r17815
30	30
31	31	if ((pc==eolith_speedup_address) || (pc==eolith_speedup_address2))
32	32	{
33		device_spin_until_trigger(&space->device(), 1000);
	33	space->device().execute().spin_until_trigger(1000);
34	34	}
35	35	}
36	36	}
r17814	r17815
121	121
122	122	if (pc==0x400081ec)
123	123	if(!eolith_vblank)
124		device_eat_cycles(m_maincpu, 500);
	124	m_maincpu->eat_cycles(500);
125	125
126	126	return (machine().primary_screen->vpos() >= 240);
127	127	}

trunk/src/mame/drivers/fromance.c

r17814	r17815
158	158
159	159	/* generate an NMI if we're out of data */
160	160	if (!state->m_vclk_left)
161		device_set_input_line(state->m_subcpu, INPUT_LINE_NMI, PULSE_LINE);
	161	state->m_subcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
162	162	}
163	163
164	164
r17814	r17815
958	958
959	959	state->membank("bank1")->configure_entries(0, 0x100, &ROM[0x10000], 0x4000);
960	960
961		state->m_subcpu = machine.device("sub");
	961	state->m_subcpu = machine.device<cpu_device>("sub");
962	962
963	963	state->save_item(NAME(state->m_directionflag));
964	964	state->save_item(NAME(state->m_commanddata));

trunk/src/mame/drivers/skykid.c

r17814	r17815
428	428	skykid_state *state = device->machine().driver_data<skykid_state>();
429	429
430	430	if(state->m_main_irq_mask)
431		device_set_input_line(device, 0, ASSERT_LINE);
	431	device->execute().set_input_line(0, ASSERT_LINE);
432	432	}
433	433
434	434
r17814	r17815
437	437	skykid_state *state = device->machine().driver_data<skykid_state>();
438	438
439	439	if(state->m_mcu_irq_mask)
440		device_set_input_line(device, 0, ASSERT_LINE);
	440	device->execute().set_input_line(0, ASSERT_LINE);
441	441	}
442	442
443	443

trunk/src/mame/drivers/djmain.c

r17814	r17815
408	408	}
409	409
410	410	//logerror("V-Blank interrupt\n");
411		device_set_input_line(device, M68K_IRQ_4, HOLD_LINE);
	411	device->execute().set_input_line(M68K_IRQ_4, HOLD_LINE);
412	412	}
413	413
414	414

trunk/src/mame/drivers/mustache.c

r17814	r17815
165	165	static INTERRUPT_GEN( assert_irq )
166	166	{
167	167	mustache_state *state = device->machine().driver_data<mustache_state>();
168		device_set_input_line(device, 0, ASSERT_LINE);
	168	device->execute().set_input_line(0, ASSERT_LINE);
169	169	state->m_clear_irq_timer->adjust(downcast<cpu_device *>(device)->cycles_to_attotime(14288));
170	170	/* Timing here is an educated GUESS, Z80 /INT must stay high so the irq
171	171	fires no less than TWICE per frame, else game doesn't work right.

trunk/src/mame/drivers/neogeo.c

r17814	r17815
351	351	static void audio_cpu_irq(device_t *device, int assert)
352	352	{
353	353	neogeo_state *state = device->machine().driver_data<neogeo_state>();
354		device_set_input_line(state->m_audiocpu, 0, assert ? ASSERT_LINE : CLEAR_LINE);
	354	state->m_audiocpu->set_input_line(0, assert ? ASSERT_LINE : CLEAR_LINE);
355	355	}
356	356
357	357
358	358	static void audio_cpu_assert_nmi(running_machine &machine)
359	359	{
360	360	neogeo_state *state = machine.driver_data<neogeo_state>();
361		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, ASSERT_LINE);
	361	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
362	362	}
363	363
364	364
365	365	WRITE8_MEMBER(neogeo_state::audio_cpu_clear_nmi_w)
366	366	{
367		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, CLEAR_LINE);
	367	m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
368	368	}
369	369
370	370
r17814	r17815
1012	1012	state->m_irq3_pending = 1;
1013	1013
1014	1014	/* get devices */
1015		state->m_maincpu = machine.device("maincpu");
1016		state->m_audiocpu = machine.device("audiocpu");
	1015	state->m_maincpu = machine.device<cpu_device>("maincpu");
	1016	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
1017	1017	state->m_upd4990a = machine.device("upd4990a");
1018	1018
1019	1019	/* register state save */

trunk/src/mame/drivers/statriv2.c

r17814	r17815
217	217	state->m_latched_coin |= new_coin & (new_coin ^ state->m_last_coin);
218	218	state->m_last_coin = new_coin;
219	219
220		device_set_input_line(device, I8085_RST75_LINE, ASSERT_LINE);
221		device_set_input_line(device, I8085_RST75_LINE, CLEAR_LINE);
	220	device->execute().set_input_line(I8085_RST75_LINE, ASSERT_LINE);
	221	device->execute().set_input_line(I8085_RST75_LINE, CLEAR_LINE);
222	222	}
223	223
224	224

trunk/src/mame/drivers/ultraman.c

r17814	r17815
27	27	{
28	28
29	29	if (ACCESSING_BITS_0_7)
30		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	30	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
31	31	}
32	32
33	33
r17814	r17815
194	194	{
195	195	ultraman_state *state = machine.driver_data<ultraman_state>();
196	196
197		state->m_maincpu = machine.device("maincpu");
198		state->m_audiocpu = machine.device("audiocpu");
	197	state->m_maincpu = machine.device<cpu_device>("maincpu");
	198	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
199	199	state->m_k051960 = machine.device("k051960");
200	200	state->m_k051316_1 = machine.device("k051316_1");
201	201	state->m_k051316_2 = machine.device("k051316_2");

trunk/src/mame/drivers/ladybug.c

r17814	r17815
186	186	{
187	187
188	188	/* left coin insertion causes an NMI */
189		device_set_input_line(m_maincpu, INPUT_LINE_NMI, newval ? ASSERT_LINE : CLEAR_LINE);
	189	m_maincpu->set_input_line(INPUT_LINE_NMI, newval ? ASSERT_LINE : CLEAR_LINE);
190	190	}
191	191
192	192	INPUT_CHANGED_MEMBER(ladybug_state::coin2_inserted)
r17814	r17815
194	194
195	195	/* right coin insertion causes an IRQ */
196	196	if (newval)
197		device_set_input_line(m_maincpu, 0, HOLD_LINE);
	197	m_maincpu->set_input_line(0, HOLD_LINE);
198	198	}
199	199
200	200
r17814	r17815
729	729	static MACHINE_START( ladybug )
730	730	{
731	731	ladybug_state *state = machine.driver_data<ladybug_state>();
732		state->m_maincpu = machine.device("maincpu");
	732	state->m_maincpu = machine.device<cpu_device>("maincpu");
733	733	}
734	734
735	735	static MACHINE_START( sraider )
736	736	{
737	737	ladybug_state *state = machine.driver_data<ladybug_state>();
738	738
739		state->m_maincpu = machine.device("maincpu");
	739	state->m_maincpu = machine.device<cpu_device>("maincpu");
740	740
741	741	state->save_item(NAME(state->m_grid_color));
742	742	state->save_item(NAME(state->m_sound_low));

trunk/src/mame/drivers/blueprnt.c

r17814	r17815
70	70	WRITE8_MEMBER(blueprnt_state::blueprnt_sound_command_w)
71	71	{
72	72	soundlatch_byte_w(space, offset, data);
73		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	73	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
74	74	}
75	75
76	76	WRITE8_MEMBER(blueprnt_state::blueprnt_coin_counter_w)
r17814	r17815
279	279	{
280	280	blueprnt_state *state = machine.driver_data<blueprnt_state>();
281	281
282		state->m_audiocpu = machine.device("audiocpu");
	282	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
283	283
284	284	state->save_item(NAME(state->m_dipsw));
285	285	}

trunk/src/mame/drivers/ttchamp.c

r17814	r17815
271	271
272	272	static INTERRUPT_GEN( ttchamp_irq ) /* right? */
273	273	{
274		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	274	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
275	275	}
276	276
277	277	static MACHINE_CONFIG_START( ttchamp, ttchamp_state )

trunk/src/mame/drivers/buggychl.c

r17814	r17815
96	96	buggychl_state *state = machine.driver_data<buggychl_state>();
97	97
98	98	if (state->m_sound_nmi_enable)
99		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	99	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
100	100	else
101	101	state->m_pending_nmi = 1;
102	102	}
r17814	r17815
117	117	m_sound_nmi_enable = 1;
118	118	if (m_pending_nmi)
119	119	{
120		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	120	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
121	121	m_pending_nmi = 0;
122	122	}
123	123	}
r17814	r17815
363	363
364	364	state->membank("bank1")->configure_entries(0, 6, &ROM[0x10000], 0x2000);
365	365
366		state->m_audiocpu = machine.device("audiocpu");
	366	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
367	367
368	368	state->save_item(NAME(state->m_sound_nmi_enable));
369	369	state->save_item(NAME(state->m_pending_nmi));

trunk/src/mame/drivers/gotcha.c

r17814	r17815
241	241	static void irqhandler( device_t *device, int linestate )
242	242	{
243	243	gotcha_state *state = device->machine().driver_data<gotcha_state>();
244		device_set_input_line(state->m_audiocpu, 0, linestate);
	244	state->m_audiocpu->set_input_line(0, linestate);
245	245	}
246	246
247	247	static const ym2151_interface ym2151_config =
r17814	r17815
254	254	{
255	255	gotcha_state *state = machine.driver_data<gotcha_state>();
256	256
257		state->m_audiocpu = machine.device("audiocpu");
	257	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
258	258
259	259	state->save_item(NAME(state->m_banksel));
260	260	state->save_item(NAME(state->m_gfxbank));

trunk/src/mame/drivers/taito_f2.c

r17814	r17815
575	575	static TIMER_CALLBACK( taitof2_interrupt6 )
576	576	{
577	577	taitof2_state *state = machine.driver_data<taitof2_state>();
578		device_set_input_line(state->m_maincpu, 6, HOLD_LINE);
	578	state->m_maincpu->set_input_line(6, HOLD_LINE);
579	579	}
580	580
581	581	static INTERRUPT_GEN( taitof2_interrupt )
582	582	{
583	583	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(500), FUNC(taitof2_interrupt6));
584		device_set_input_line(device, 5, HOLD_LINE);
	584	device->execute().set_input_line(5, HOLD_LINE);
585	585	}
586	586
587	587
r17814	r17815
603	603	READ8_MEMBER(taitof2_state::driveout_sound_command_r)
604	604	{
605	605
606		device_set_input_line(m_audiocpu, 0, CLEAR_LINE);
	606	m_audiocpu->set_input_line(0, CLEAR_LINE);
607	607	//  logerror("sound IRQ OFF (sound command=%02x)\n", m_driveout_sound_latch);
608	608	return m_driveout_sound_latch;
609	609	}
r17814	r17815
644	644	else
645	645	{
646	646	m_driveout_sound_latch = ((data << 4) & 0xf0) | (m_driveout_sound_latch & 0x0f);
647		device_set_input_line(m_audiocpu, 0, ASSERT_LINE);
	647	m_audiocpu->set_input_line(0, ASSERT_LINE);
648	648	}
649	649	}
650	650	}
r17814	r17815
2811	2811	static void irq_handler( device_t *device, int irq )
2812	2812	{
2813	2813	taitof2_state *state = device->machine().driver_data<taitof2_state>();
2814		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	2814	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
2815	2815	}
2816	2816
2817	2817	static const ym2610_interface ym2610_config =
r17814	r17815
3020	3020	{
3021	3021	taitof2_state *state = machine.driver_data<taitof2_state>();
3022	3022
3023		state->m_maincpu = machine.device("maincpu");
3024		state->m_audiocpu = machine.device("audiocpu");;
	3023	state->m_maincpu = machine.device<cpu_device>("maincpu");
	3024	state->m_audiocpu = machine.device<cpu_device>("audiocpu");;
3025	3025	state->m_tc0100scn = machine.device("tc0100scn");;
3026	3026	state->m_tc0100scn_1 = machine.device("tc0100scn_1");;
3027	3027	state->m_tc0100scn_2 = machine.device("tc0100scn_2");;

trunk/src/mame/drivers/pandoras.c

r17814	r17815
40	40	pandoras_state *state = device->machine().driver_data<pandoras_state>();
41	41
42	42	if (state->m_irq_enable_a)
43		device_set_input_line(device, M6809_IRQ_LINE, HOLD_LINE);
	43	device->execute().set_input_line(M6809_IRQ_LINE, HOLD_LINE);
44	44	}
45	45
46	46	static INTERRUPT_GEN( pandoras_slave_interrupt )
r17814	r17815
48	48	pandoras_state *state = device->machine().driver_data<pandoras_state>();
49	49
50	50	if (state->m_irq_enable_b)
51		device_set_input_line(device, M6809_IRQ_LINE, HOLD_LINE);
	51	device->execute().set_input_line(M6809_IRQ_LINE, HOLD_LINE);
52	52	}
53	53
54	54	WRITE8_MEMBER(pandoras_state::pandoras_int_control_w)
r17814	r17815
66	66	switch (offset)
67	67	{
68	68	case 0x00:   if (!data)
69		device_set_input_line(m_maincpu, M6809_IRQ_LINE, CLEAR_LINE);
	69	m_maincpu->set_input_line(M6809_IRQ_LINE, CLEAR_LINE);
70	70	m_irq_enable_a = data;
71	71	break;
72	72	case 0x02:   coin_counter_w(machine(), 0,data & 0x01);
r17814	r17815
76	76	case 0x05:   pandoras_flipscreen_w(space, 0, data);
77	77	break;
78	78	case 0x06:   if (!data)
79		device_set_input_line(m_subcpu, M6809_IRQ_LINE, CLEAR_LINE);
	79	m_subcpu->set_input_line(M6809_IRQ_LINE, CLEAR_LINE);
80	80	m_irq_enable_b = data;
81	81	break;
82		case 0x07:   device_set_input_line(m_subcpu, INPUT_LINE_NMI, PULSE_LINE);
	82	case 0x07:   m_subcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
83	83	break;
84	84
85	85	default:   logerror("%04x: (irq_ctrl) write %02x to %02x\n",space.device().safe_pc(), data, offset);
r17814	r17815
91	91	{
92	92
93	93	if (!m_firq_old_data_a && data)
94		device_set_input_line(m_maincpu, M6809_FIRQ_LINE, HOLD_LINE);
	94	m_maincpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
95	95
96	96	m_firq_old_data_a = data;
97	97	}
r17814	r17815
100	100	{
101	101
102	102	if (!m_firq_old_data_b && data)
103		device_set_input_line(m_subcpu, M6809_FIRQ_LINE, HOLD_LINE);
	103	m_subcpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
104	104
105	105	m_firq_old_data_b = data;
106	106	}
107	107
108	108	WRITE8_MEMBER(pandoras_state::pandoras_i8039_irqtrigger_w)
109	109	{
110		device_set_input_line(m_mcu, 0, ASSERT_LINE);
	110	m_mcu->set_input_line(0, ASSERT_LINE);
111	111	}
112	112
113	113	WRITE8_MEMBER(pandoras_state::i8039_irqen_and_status_w)
r17814	r17815
115	115
116	116	/* bit 7 enables IRQ */
117	117	if ((data & 0x80) == 0)
118		device_set_input_line(m_mcu, 0, CLEAR_LINE);
	118	m_mcu->set_input_line(0, CLEAR_LINE);
119	119
120	120	/* bit 5 goes to 8910 port A */
121	121	m_i8039_status = (data & 0x20) >> 5;
r17814	r17815
123	123
124	124	WRITE8_MEMBER(pandoras_state::pandoras_z80_irqtrigger_w)
125	125	{
126		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	126	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
127	127	}
128	128
129	129

trunk/src/mame/drivers/gottlieb.c

r17814	r17815
663	663	{
664	664	gottlieb_state *state = device->machine().driver_data<gottlieb_state>();
665	665	/* assert the NMI and set a timer to clear it at the first visible line */
666		device_set_input_line(device, INPUT_LINE_NMI, ASSERT_LINE);
	666	device->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
667	667	device->machine().scheduler().timer_set(device->machine().primary_screen->time_until_pos(0), FUNC(nmi_clear));
668	668
669	669	/* if we have a laserdisc, update it */

trunk/src/mame/drivers/ddragon.c

r17814	r17815
130	130
131	131	/* on the rising edge of VBLK (vcount == F8), signal an NMI */
132	132	if (vcount == 0xf8)
133		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, ASSERT_LINE);
	133	state->m_maincpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
134	134
135	135	/* set 1ms signal on rising edge of vcount & 8 */
136	136	if (!(vcount_old & 8) && (vcount & 8))
137		device_set_input_line(state->m_maincpu, M6809_FIRQ_LINE, ASSERT_LINE);
	137	state->m_maincpu->set_input_line(M6809_FIRQ_LINE, ASSERT_LINE);
138	138	}
139	139
140	140
r17814	r17815
152	152	/* configure banks */
153	153	state->membank("bank1")->configure_entries(0, 8, state->memregion("maincpu")->base() + 0x10000, 0x4000);
154	154
155		state->m_maincpu = machine.device("maincpu");
	155	state->m_maincpu = machine.device<cpu_device>("maincpu");
156	156	state->m_sub_cpu = machine.device("sub");
157	157	state->m_snd_cpu = machine.device("soundcpu");
158	158	state->m_adpcm_1 = machine.device("adpcm1");
r17814	r17815
201	201	if (data & 0x10)
202	202	m_dd_sub_cpu_busy = 0;
203	203	else if (m_dd_sub_cpu_busy == 0)
204		device_set_input_line(m_sub_cpu, m_sprite_irq, (m_sprite_irq == INPUT_LINE_NMI) ? PULSE_LINE : HOLD_LINE);
	204	m_sub_cpu->execute().set_input_line(m_sprite_irq, (m_sprite_irq == INPUT_LINE_NMI) ? PULSE_LINE : HOLD_LINE);
205	205
206	206	membank("bank1")->set_entry((data & 0xe0) >> 5);
207	207	}
r17814	r17815
276	276	if (data & 0x10)
277	277	m_dd_sub_cpu_busy = 0;
278	278	else if (m_dd_sub_cpu_busy == 0)
279		device_set_input_line(m_sub_cpu, m_sprite_irq, (m_sprite_irq == INPUT_LINE_NMI) ? PULSE_LINE : HOLD_LINE);
	279	m_sub_cpu->execute().set_input_line(m_sprite_irq, (m_sprite_irq == INPUT_LINE_NMI) ? PULSE_LINE : HOLD_LINE);
280	280
281	281	membank("bank1")->set_entry(newbank);
282	282	if (newbank == 4 && oldbank != 4)
r17814	r17815
298	298	switch (offset)
299	299	{
300	300	case 0: /* 380b - NMI ack */
301		device_set_input_line(m_maincpu, INPUT_LINE_NMI, CLEAR_LINE);
	301	m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
302	302	break;
303	303
304	304	case 1: /* 380c - FIRQ ack */
305		device_set_input_line(m_maincpu, M6809_FIRQ_LINE, CLEAR_LINE);
	305	m_maincpu->set_input_line(M6809_FIRQ_LINE, CLEAR_LINE);
306	306	break;
307	307
308	308	case 2: /* 380d - IRQ ack */
309		device_set_input_line(m_maincpu, M6809_IRQ_LINE, CLEAR_LINE);
	309	m_maincpu->set_input_line(M6809_IRQ_LINE, CLEAR_LINE);
310	310	break;
311	311
312	312	case 3: /* 380e - SND irq */
313	313	soundlatch_byte_w(space, 0, data);
314		device_set_input_line(m_snd_cpu, m_sound_irq, (m_sound_irq == INPUT_LINE_NMI) ? PULSE_LINE : HOLD_LINE);
	314	m_snd_cpu->execute().set_input_line(m_sound_irq, (m_sound_irq == INPUT_LINE_NMI) ? PULSE_LINE : HOLD_LINE);
315	315	break;
316	316
317	317	case 4: /* 380f - ? */
r17814	r17815
323	323
324	324	WRITE8_MEMBER(ddragon_state::ddragon2_sub_irq_ack_w)
325	325	{
326		device_set_input_line(m_sub_cpu, m_sprite_irq, CLEAR_LINE );
	326	m_sub_cpu->execute().set_input_line(m_sprite_irq, CLEAR_LINE );
327	327	}
328	328
329	329
330	330	WRITE8_MEMBER(ddragon_state::ddragon2_sub_irq_w)
331	331	{
332		device_set_input_line(m_maincpu, M6809_IRQ_LINE, ASSERT_LINE);
	332	m_maincpu->set_input_line(M6809_IRQ_LINE, ASSERT_LINE);
333	333	}
334	334
335	335
336	336	static void irq_handler( device_t *device, int irq )
337	337	{
338	338	ddragon_state *state = device->machine().driver_data<ddragon_state>();
339		device_set_input_line(state->m_snd_cpu, state->m_ym_irq , irq ? ASSERT_LINE : CLEAR_LINE );
	339	state->m_snd_cpu->execute().set_input_line(state->m_ym_irq , irq ? ASSERT_LINE : CLEAR_LINE );
340	340	}
341	341
342	342
r17814	r17815
378	378	it's quite obvious from the Double Dragon 2 code, below). */
379	379	if (data & 3)
380	380	{
381		device_set_input_line(m_maincpu, M6809_IRQ_LINE, ASSERT_LINE);
382		device_set_input_line(m_sub_cpu, m_sprite_irq, CLEAR_LINE);
	381	m_maincpu->set_input_line(M6809_IRQ_LINE, ASSERT_LINE);
	382	m_sub_cpu->execute().set_input_line(m_sprite_irq, CLEAR_LINE);
383	383	}
384	384	}
385	385	}
r17814	r17815
561	561	/* might not be 100% accurate, check bits written */
562	562	WRITE8_MEMBER(ddragon_state::ddragonba_port_w)
563	563	{
564		device_set_input_line(m_maincpu, M6809_IRQ_LINE, ASSERT_LINE);
565		device_set_input_line(m_sub_cpu, m_sprite_irq, CLEAR_LINE );
	564	m_maincpu->set_input_line(M6809_IRQ_LINE, ASSERT_LINE);
	565	m_sub_cpu->execute().set_input_line(m_sprite_irq, CLEAR_LINE );
566	566	}
567	567
568	568	static ADDRESS_MAP_START( ddragonba_sub_portmap, AS_IO, 8, ddragon_state )

trunk/src/mame/drivers/asterix.c

r17814	r17815
61	61	if (!k056832_is_irq_enabled(state->m_k056832, 0))
62	62	return;
63	63
64		device_set_input_line(device, 5, HOLD_LINE); /* ??? All irqs have the same vector, and the mask used is 0 or 7 */
	64	device->execute().set_input_line(5, HOLD_LINE); /* ??? All irqs have the same vector, and the mask used is 0 or 7 */
65	65	}
66	66
67	67	READ8_MEMBER(asterix_state::asterix_sound_r)
r17814	r17815
73	73	static TIMER_CALLBACK( nmi_callback )
74	74	{
75	75	asterix_state *state = machine.driver_data<asterix_state>();
76		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, ASSERT_LINE);
	76	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
77	77	}
78	78
79	79	WRITE8_MEMBER(asterix_state::sound_arm_nmi_w)
80	80	{
81	81
82		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, CLEAR_LINE);
	82	m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
83	83	machine().scheduler().timer_set(attotime::from_usec(5), FUNC(nmi_callback));
84	84	}
85	85
86	86	WRITE16_MEMBER(asterix_state::sound_irq_w)
87	87	{
88		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	88	m_audiocpu->set_input_line(0, HOLD_LINE);
89	89	}
90	90
91	91	// Check the routine at 7f30 in the ead version.
r17814	r17815
247	247	{
248	248	asterix_state *state = machine.driver_data<asterix_state>();
249	249
250		state->m_maincpu = machine.device("maincpu");
251		state->m_audiocpu = machine.device("audiocpu");
	250	state->m_maincpu = machine.device<cpu_device>("maincpu");
	251	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
252	252	state->m_k053260 = machine.device("k053260");
253	253	state->m_k056832 = machine.device("k056832");
254	254	state->m_k053244 = machine.device("k053244");

trunk/src/mame/drivers/xxmissio.c

r17814	r17815
67	67	{
68	68	xxmissio_state *state = device->machine().driver_data<xxmissio_state>();
69	69	state->m_status &= ~0x20;
70		device_set_input_line(device, 0, HOLD_LINE);
	70	device->execute().set_input_line(0, HOLD_LINE);
71	71	}
72	72
73	73	static INTERRUPT_GEN( xxmissio_interrupt_s )
74	74	{
75	75	xxmissio_state *state = device->machine().driver_data<xxmissio_state>();
76	76	state->m_status &= ~0x10;
77		device_set_input_line(device, 0, HOLD_LINE);
	77	device->execute().set_input_line(0, HOLD_LINE);
78	78	}
79	79
80	80	static MACHINE_START( xxmissio )

trunk/src/mame/drivers/moo.c

r17814	r17815
122	122	{
123	123	moo_state *state = machine.driver_data<moo_state>();
124	124	if (state->m_cur_control2 & 0x800)
125		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	125	state->m_maincpu->set_input_line(4, HOLD_LINE);
126	126	}
127	127
128	128	static INTERRUPT_GEN( moo_interrupt )
r17814	r17815
138	138
139	139	// trigger V-blank interrupt
140	140	if (state->m_cur_control2 & 0x20)
141		device_set_input_line(device, 5, HOLD_LINE);
	141	device->execute().set_input_line(5, HOLD_LINE);
142	142	}
143	143
144	144	static INTERRUPT_GEN( moobl_interrupt )
r17814	r17815
150	150	state->m_dmaend_timer->adjust(attotime::from_usec(MOO_DMADELAY));
151	151
152	152	// trigger V-blank interrupt
153		device_set_input_line(device, 5, HOLD_LINE);
	153	device->execute().set_input_line(5, HOLD_LINE);
154	154	}
155	155
156	156	WRITE16_MEMBER(moo_state::sound_cmd1_w)
r17814	r17815
170	170
171	171	WRITE16_MEMBER(moo_state::sound_irq_w)
172	172	{
173		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	173	m_audiocpu->set_input_line(0, HOLD_LINE);
174	174	}
175	175
176	176	READ16_MEMBER(moo_state::sound_status_r)
r17814	r17815
427	427	{
428	428	moo_state *state = machine.driver_data<moo_state>();
429	429
430		state->m_maincpu = machine.device("maincpu");
431		state->m_audiocpu = machine.device("soundcpu");
	430	state->m_maincpu = machine.device<cpu_device>("maincpu");
	431	state->m_audiocpu = machine.device<cpu_device>("soundcpu");
432	432	state->m_k054539 = machine.device("k054539");
433	433	state->m_k053246 = machine.device("k053246");
434	434	state->m_k053251 = machine.device("k053251");

trunk/src/mame/drivers/taito_l.c

r17814	r17815
144	144	{
145	145	taitol_state *state = machine.driver_data<taitol_state>();
146	146
147		state->m_maincpu = machine.device("maincpu");
148		state->m_audiocpu = machine.device("audiocpu");
	147	state->m_maincpu = machine.device<cpu_device>("maincpu");
	148	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
149	149
150	150	state->save_item(NAME(state->m_rambanks));
151	151	state->save_item(NAME(state->m_palette_ram));
r17814	r17815
312	312	{
313	313	taitol_state *state = timer.machine().driver_data<taitol_state>();
314	314	int scanline = param;
315		device_set_irq_callback(state->m_maincpu, irq_callback);
	315	state->m_maincpu->set_irq_acknowledge_callback(irq_callback);
316	316
317	317	/* kludge to make plgirls boot */
318		if (state->m_maincpu->state().state_int(Z80_IM) != 2)
	318	if (state->m_maincpu->state_int(Z80_IM) != 2)
319	319	return;
320	320
321	321	// What is really generating interrupts 0 and 1 is still to be found
r17814	r17815
323	323	if (scanline == 120 && (state->m_irq_enable & 1))
324	324	{
325	325	state->m_last_irq_level = 0;
326		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	326	state->m_maincpu->set_input_line(0, HOLD_LINE);
327	327	}
328	328	else if (scanline == 0 && (state->m_irq_enable & 2))
329	329	{
330	330	state->m_last_irq_level = 1;
331		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	331	state->m_maincpu->set_input_line(0, HOLD_LINE);
332	332	}
333	333	else if (scanline == 240 && (state->m_irq_enable & 4))
334	334	{
335	335	state->m_last_irq_level = 2;
336		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	336	state->m_maincpu->set_input_line(0, HOLD_LINE);
337	337	}
338	338	}
339	339
r17814	r17815
355	355
356	356	// fix Plotting test mode
357	357	if ((m_irq_enable & (1 << m_last_irq_level)) == 0)
358		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	358	m_maincpu->set_input_line(0, CLEAR_LINE);
359	359	}
360	360
361	361	READ8_MEMBER(taitol_state::irq_enable_r)
r17814	r17815
1774	1774	static void irqhandler( device_t *device, int irq )
1775	1775	{
1776	1776	taitol_state *state = device->machine().driver_data<taitol_state>();
1777		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	1777	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
1778	1778	}
1779	1779
1780	1780	WRITE8_MEMBER(taitol_state::portA_w)

trunk/src/mame/drivers/groundfx.c

r17814	r17815
358	358	{
359	359	groundfx_state *state = device->machine().driver_data<groundfx_state>();
360	360	state->m_frame_counter^=1;
361		device_set_input_line(device, 4, HOLD_LINE);
	361	device->execute().set_input_line(4, HOLD_LINE);
362	362	}
363	363
364	364	static MACHINE_CONFIG_START( groundfx, groundfx_state )

trunk/src/mame/drivers/suprloco.c

r17814	r17815
22	22	soundlatch_byte_w(space, 0, data);
23	23	machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
24	24	/* spin for a while to let the Z80 read the command (fixes hanging sound in Regulus) */
25		device_spin_until_time(&space.device(), attotime::from_usec(50));
	25	space.device().execute().spin_until_time(attotime::from_usec(50));
26	26	}
27	27
28	28	static ADDRESS_MAP_START( main_map, AS_PROGRAM, 8, suprloco_state )

trunk/src/mame/drivers/m92.c

r17814	r17815
237	237	if (scanline == state->m_raster_irq_position)
238	238	{
239	239	machine.primary_screen->update_partial(scanline);
240		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, M92_IRQ_2);
	240	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, M92_IRQ_2);
241	241	}
242	242
243	243	/* VBLANK interrupt */
244	244	else if (scanline == machine.primary_screen->visible_area().max_y + 1)
245	245	{
246	246	machine.primary_screen->update_partial(scanline);
247		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, M92_IRQ_0);
	247	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, M92_IRQ_0);
248	248	}
249	249	}
250	250
r17814	r17815
297	297	WRITE16_MEMBER(m92_state::m92_soundlatch_w)
298	298	{
299	299	if (m_soundcpu)
300		device_set_input_line(m_soundcpu, NEC_INPUT_LINE_INTP1, ASSERT_LINE);
	300	m_soundcpu->set_input_line(NEC_INPUT_LINE_INTP1, ASSERT_LINE);
301	301
302	302	soundlatch_byte_w(space, 0, data & 0xff);
303	303	}
r17814	r17815
311	311	READ16_MEMBER(m92_state::m92_soundlatch_r)
312	312	{
313	313	if (m_soundcpu)
314		device_set_input_line(m_soundcpu, NEC_INPUT_LINE_INTP1, CLEAR_LINE);
	314	m_soundcpu->set_input_line(NEC_INPUT_LINE_INTP1, CLEAR_LINE);
315	315
316	316	return soundlatch_byte_r(space, offset) | 0xff00;
317	317	}
r17814	r17815
319	319	WRITE16_MEMBER(m92_state::m92_sound_irq_ack_w)
320	320	{
321	321	if (m_soundcpu)
322		device_set_input_line(m_soundcpu, NEC_INPUT_LINE_INTP1, CLEAR_LINE);
	322	m_soundcpu->set_input_line(NEC_INPUT_LINE_INTP1, CLEAR_LINE);
323	323	}
324	324
325	325	WRITE16_MEMBER(m92_state::m92_sound_status_w)
326	326	{
327	327	COMBINE_DATA(&m_sound_status);
328		device_set_input_line_and_vector(m_maincpu, 0, HOLD_LINE, M92_IRQ_3);
	328	m_maincpu->set_input_line_and_vector(0, HOLD_LINE, M92_IRQ_3);
329	329
330	330	}
331	331
332	332	WRITE16_MEMBER(m92_state::m92_sound_reset_w)
333	333	{
334	334	if (m_soundcpu)
335		device_set_input_line(m_soundcpu, INPUT_LINE_RESET, (data) ? CLEAR_LINE : ASSERT_LINE);
	335	m_soundcpu->set_input_line(INPUT_LINE_RESET, (data) ? CLEAR_LINE : ASSERT_LINE);
336	336	}
337	337
338	338	/*****************************************************************************/
r17814	r17815
916	916	{
917	917	m92_state *state = device->machine().driver_data<m92_state>();
918	918
919		device_set_input_line(state->m_soundcpu, NEC_INPUT_LINE_INTP0, pinstate ? ASSERT_LINE : CLEAR_LINE);
	919	state->m_soundcpu->set_input_line(NEC_INPUT_LINE_INTP0, pinstate ? ASSERT_LINE : CLEAR_LINE);
920	920	}
921	921
922	922	static const ym2151_interface ym2151_config =
r17814	r17815
930	930	{
931	931	m92_state *state = machine.driver_data<m92_state>();
932	932
933		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, M92_IRQ_1);
	933	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, M92_IRQ_1);
934	934	}
935	935
936	936	static MACHINE_CONFIG_START( m92, m92_state )

trunk/src/mame/drivers/fcombat.c

r17814	r17815
38	38	{
39	39
40	40	/* coin insertion causes an NMI */
41		device_set_input_line(m_maincpu, INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
	41	m_maincpu->set_input_line(INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
42	42	}
43	43
44	44
r17814	r17815
261	261	{
262	262	fcombat_state *state = machine.driver_data<fcombat_state>();
263	263
264		state->m_maincpu = machine.device("maincpu");
	264	state->m_maincpu = machine.device<cpu_device>("maincpu");
265	265
266	266	state->save_item(NAME(state->m_cocktail_flip));
267	267	state->save_item(NAME(state->m_char_palette));

trunk/src/mame/drivers/destroyr.c

r17814	r17815
41	41	int            m_noise;
42	42
43	43	/* devices */
44		device_t *m_maincpu;
	44	cpu_device *m_maincpu;
45	45	DECLARE_WRITE8_MEMBER(destroyr_misc_w);
46	46	DECLARE_WRITE8_MEMBER(destroyr_cursor_load_w);
47	47	DECLARE_WRITE8_MEMBER(destroyr_interrupt_ack_w);
r17814	r17815
134	134
135	135	if (state->m_potmask[dial])
136	136	{
137		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	137	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
138	138	}
139	139	}
140	140
r17814	r17815
194	194
195	195	WRITE8_MEMBER(destroyr_state::destroyr_interrupt_ack_w)
196	196	{
197		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	197	m_maincpu->set_input_line(0, CLEAR_LINE);
198	198	}
199	199
200	200
r17814	r17815
435	435	{
436	436	destroyr_state *state = machine.driver_data<destroyr_state>();
437	437
438		state->m_maincpu = machine.device("maincpu");
	438	state->m_maincpu = machine.device<cpu_device>("maincpu");
439	439
440	440	state->save_item(NAME(state->m_cursor));
441	441	state->save_item(NAME(state->m_wavemod));

trunk/src/mame/drivers/fuukifg2.c

r17814	r17815
79	79	if (ACCESSING_BITS_0_7)
80	80	{
81	81	soundlatch_byte_w(space,0,data & 0xff);
82		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
83		//      device_spin_until_time(&space.device(), attotime::from_usec(50));   // Allow the other CPU to reply
	82	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
	83	//      space.device().execute().spin_until_time(attotime::from_usec(50));   // Allow the other CPU to reply
84	84	machine().scheduler().boost_interleave(attotime::zero, attotime::from_usec(50)); // Fixes glitching in rasters
85	85	}
86	86	}
r17814	r17815
394	394	static void soundirq( device_t *device, int state )
395	395	{
396	396	fuuki16_state *fuuki16 = device->machine().driver_data<fuuki16_state>();
397		device_set_input_line(fuuki16->m_audiocpu, 0, state);
	397	fuuki16->m_audiocpu->set_input_line(0, state);
398	398	}
399	399
400	400	static const ym3812_interface fuuki16_ym3812_intf =
r17814	r17815
417	417	static TIMER_CALLBACK( level_1_interrupt_callback )
418	418	{
419	419	fuuki16_state *state = machine.driver_data<fuuki16_state>();
420		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	420	state->m_maincpu->set_input_line(1, HOLD_LINE);
421	421	machine.scheduler().timer_set(machine.primary_screen->time_until_pos(248), FUNC(level_1_interrupt_callback));
422	422	}
423	423
r17814	r17815
425	425	static TIMER_CALLBACK( vblank_interrupt_callback )
426	426	{
427	427	fuuki16_state *state = machine.driver_data<fuuki16_state>();
428		device_set_input_line(state->m_maincpu, 3, HOLD_LINE);   // VBlank IRQ
	428	state->m_maincpu->set_input_line(3, HOLD_LINE);   // VBlank IRQ
429	429	machine.scheduler().timer_set(machine.primary_screen->time_until_vblank_start(), FUNC(vblank_interrupt_callback));
430	430	}
431	431
r17814	r17815
433	433	static TIMER_CALLBACK( raster_interrupt_callback )
434	434	{
435	435	fuuki16_state *state = machine.driver_data<fuuki16_state>();
436		device_set_input_line(state->m_maincpu, 5, HOLD_LINE);   // Raster Line IRQ
	436	state->m_maincpu->set_input_line(5, HOLD_LINE);   // Raster Line IRQ
437	437	machine.primary_screen->update_partial(machine.primary_screen->vpos());
438	438	state->m_raster_interrupt_timer->adjust(machine.primary_screen->frame_period());
439	439	}
r17814	r17815
446	446
447	447	state->membank("bank1")->configure_entries(0, 3, &ROM[0x10000], 0x8000);
448	448
449		state->m_maincpu = machine.device("maincpu");
450		state->m_audiocpu = machine.device("audiocpu");
	449	state->m_maincpu = machine.device<cpu_device>("maincpu");
	450	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
451	451
452	452	state->m_raster_interrupt_timer = machine.scheduler().timer_alloc(FUNC(raster_interrupt_callback));
453	453	}

trunk/src/mame/drivers/vulgus.c

r17814	r17815
49	49
50	50	static INTERRUPT_GEN( vulgus_vblank_irq )
51	51	{
52		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0xd7);   /* RST 10h - vblank */
	52	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0xd7);   /* RST 10h - vblank */
53	53	}
54	54
55	55	static ADDRESS_MAP_START( main_map, AS_PROGRAM, 8, vulgus_state )

trunk/src/mame/drivers/vcombat.c

r17814	r17815
256	256	READ16_MEMBER(vcombat_state::main_irqiack_r)
257	257	{
258	258	//fprintf(stderr, "M0: irq iack\n");
259		device_set_input_line(machine().device("maincpu"), M68K_IRQ_1, CLEAR_LINE);
260		//device_set_input_line(machine().device("maincpu"), INPUT_LINE_RESET, CLEAR_LINE);
	259	machine().device("maincpu")->execute().set_input_line(M68K_IRQ_1, CLEAR_LINE);
	260	//machine().device("maincpu")->execute().set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
261	261	return 0;
262	262	}
263	263
264	264	READ16_MEMBER(vcombat_state::sound_resetmain_r)
265	265	{
266	266	//fprintf(stderr, "M1: reset line to M0\n");
267		//device_set_input_line(machine().device("maincpu"), INPUT_LINE_RESET, PULSE_LINE);
	267	//machine().device("maincpu")->execute().set_input_line(INPUT_LINE_RESET, PULSE_LINE);
268	268	return 0;
269	269	}
270	270
r17814	r17815
559	559	WRITE_LINE_MEMBER(vcombat_state::sound_update)
560	560	{
561	561	/* Seems reasonable */
562		device_set_input_line(machine().device("soundcpu"), M68K_IRQ_1, state ? ASSERT_LINE : CLEAR_LINE);
	562	machine().device("soundcpu")->execute().set_input_line(M68K_IRQ_1, state ? ASSERT_LINE : CLEAR_LINE);
563	563	}
564	564
565	565	static const mc6845_interface mc6845_intf =

trunk/src/mame/drivers/vastar.c

r17814	r17815
294	294	vastar_state *state = device->machine().driver_data<vastar_state>();
295	295
296	296	if(state->m_nmi_mask)
297		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	297	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
298	298	}
299	299
300	300	static MACHINE_CONFIG_START( vastar, vastar_state )

trunk/src/mame/drivers/gunpey.c

r17814	r17815
356	356
357	357	static INTERRUPT_GEN( gunpey_interrupt )
358	358	{
359		device_set_input_line_and_vector(device,0,HOLD_LINE,0x200/4);
	359	device->execute().set_input_line_and_vector(0,HOLD_LINE,0x200/4);
360	360	}
361	361
362	362	/***************************************************************************************/

trunk/src/mame/drivers/superwng.c

r17814	r17815
212	212	WRITE8_MEMBER(superwng_state::superwng_sound_interrupt_w)
213	213	{
214	214	m_sound_byte = data;
215		device_set_input_line(m_audiocpu, 0, ASSERT_LINE);
	215	m_audiocpu->set_input_line(0, ASSERT_LINE);
216	216	}
217	217
218	218	READ8_MEMBER(superwng_state::superwng_sound_byte_r)
219	219	{
220		device_set_input_line(m_audiocpu, 0, CLEAR_LINE);
	220	m_audiocpu->set_input_line(0, CLEAR_LINE);
221	221	return m_sound_byte;
222	222	}
223	223
224	224	WRITE8_MEMBER(superwng_state::superwng_sound_nmi_clear_w)
225	225	{
226		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, CLEAR_LINE);
	226	m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
227	227	}
228	228
229	229	static INTERRUPT_GEN( superwng_sound_nmi_assert )
230	230	{
231	231	superwng_state *state = device->machine().driver_data<superwng_state>();
232	232	if (BIT(state->m_nmi_enable, 0))
233		device_set_input_line(device, INPUT_LINE_NMI, ASSERT_LINE);
	233	device->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
234	234	}
235	235
236	236	WRITE8_MEMBER(superwng_state::superwng_bg_vram_w)

trunk/src/mame/drivers/cyclemb.c

r17814	r17815
379	379	WRITE8_MEMBER(cyclemb_state::sound_cmd_w)
380	380	{
381	381	soundlatch_byte_w(space, 0, data & 0xff);
382		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	382	m_audiocpu->set_input_line(0, HOLD_LINE);
383	383	}
384	384	#endif
385	385
r17814	r17815
393	393	WRITE8_MEMBER(cyclemb_state::sound_cmd_w)//actually ciom
394	394	{
395	395	soundlatch_byte_w(space, 0, data & 0xff);
396		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	396	m_audiocpu->set_input_line(0, HOLD_LINE);
397	397	}
398	398	#endif
399	399
r17814	r17815
419	419	{
420	420	if(offset == 1) //status port
421	421	{
422		//printf("STATUS PC=%04x\n",m_maincpu->safe_pc());
	422	//printf("STATUS PC=%04x\n",m_maincpu->pc());
423	423
424	424	return 1;
425	425	}
r17814	r17815
427	427	{
428	428	UINT8 i,pt;
429	429
430		//printf("%04x\n",m_maincpu->safe_pc());
	430	//printf("%04x\n",m_maincpu->pc());
431	431
432	432	/* TODO: internal state of this */
433	433	if(m_maincpu->pc() == m_dsw_pc_hack)
434	434	m_mcu[0].rxd = (ioport("DSW1")->read() & 0x1f) << 2;
435	435	else if(m_mcu[0].rst)
436	436	{
437		//printf("READ PC=%04x\n",m_maincpu->safe_pc());
	437	//printf("READ PC=%04x\n",m_maincpu->pc());
438	438	{
439	439
440	440	switch(m_mcu[0].state)
r17814	r17815
500	500	{
501	501	if(offset == 1) //command port
502	502	{
503		//printf("%02x CMD PC=%04x\n",data,m_maincpu->safe_pc());
	503	//printf("%02x CMD PC=%04x\n",data,m_maincpu->pc());
504	504	switch(data)
505	505	{
506	506	case 0:
r17814	r17815
535	535	}
536	536	else
537	537	{
538		//printf("%02x DATA PC=%04x\n",data,m_maincpu->safe_pc());
	538	//printf("%02x DATA PC=%04x\n",data,m_maincpu->pc());
539	539
540	540	m_mcu[0].txd = data;
541	541

trunk/src/mame/drivers/bingor.c

r17814	r17815
588	588
589	589	static INTERRUPT_GEN( vblank_irq )
590	590	{
591		//  device_set_input_line_and_vector(device,0,HOLD_LINE,0x08/4); // reads i/o 0x200 and puts the result in ram, pic irq?
592		device_set_input_line_and_vector(device,0,HOLD_LINE,0x4c/4); // ?
	591	//  device->execute().set_input_line_and_vector(0,HOLD_LINE,0x08/4); // reads i/o 0x200 and puts the result in ram, pic irq?
	592	device->execute().set_input_line_and_vector(0,HOLD_LINE,0x4c/4); // ?
593	593	}
594	594
595	595	static INTERRUPT_GEN( unk_irq )
596	596	{
597		device_set_input_line_and_vector(device,0,HOLD_LINE,0x48/4); // ?
	597	device->execute().set_input_line_and_vector(0,HOLD_LINE,0x48/4); // ?
598	598	}
599	599
600	600

trunk/src/mame/drivers/beaminv.c

r17814	r17815
73	73	UINT8      m_controller_select;
74	74
75	75	/* devices */
76		device_t *m_maincpu;
	76	cpu_device *m_maincpu;
77	77	DECLARE_READ8_MEMBER(v128_r);
78	78	DECLARE_WRITE8_MEMBER(controller_select_w);
79	79	DECLARE_READ8_MEMBER(controller_r);
r17814	r17815
101	101	int next_interrupt_number;
102	102	int next_vpos;
103	103
104		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	104	state->m_maincpu->set_input_line(0, HOLD_LINE);
105	105
106	106	/* set up for next interrupt */
107	107	next_interrupt_number = (interrupt_number + 1) % INTERRUPTS_PER_FRAME;
r17814	r17815
138	138	beaminv_state *state = machine.driver_data<beaminv_state>();
139	139	create_interrupt_timer(machine);
140	140
141		state->m_maincpu = machine.device("maincpu");
	141	state->m_maincpu = machine.device<cpu_device>("maincpu");
142	142
143	143	/* setup for save states */
144	144	state->save_item(NAME(state->m_controller_select));

trunk/src/mame/drivers/matmania.c

r17814	r17815
47	47	WRITE8_MEMBER(matmania_state::matmania_sh_command_w)
48	48	{
49	49	soundlatch_byte_w(space, offset, data);
50		device_set_input_line(m_audiocpu, M6502_IRQ_LINE, HOLD_LINE);
	50	m_audiocpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
51	51	}
52	52
53	53	WRITE8_MEMBER(matmania_state::maniach_sh_command_w)
54	54	{
55	55	soundlatch_byte_w(space, offset, data);
56		device_set_input_line(m_audiocpu, M6809_IRQ_LINE, HOLD_LINE);
	56	m_audiocpu->set_input_line(M6809_IRQ_LINE, HOLD_LINE);
57	57	}
58	58
59	59
r17814	r17815
300	300	{
301	301	matmania_state *state = machine.driver_data<matmania_state>();
302	302
303		state->m_maincpu = machine.device("maincpu");
304		state->m_audiocpu = machine.device("audiocpu");
	303	state->m_maincpu = machine.device<cpu_device>("maincpu");
	304	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
305	305	state->m_mcu = machine.device("mcu");
306	306	}
307	307

trunk/src/mame/drivers/dcheese.c

r17814	r17815
53	53
54	54	int i;
55	55	for (i = 1; i < 5; i++)
56		device_set_input_line(cpu, i, state->m_irq_state[i] ? ASSERT_LINE : CLEAR_LINE);
	56	cpu->execute().set_input_line(i, state->m_irq_state[i] ? ASSERT_LINE : CLEAR_LINE);
57	57	}
58	58
59	59
r17814	r17815
97	97	{
98	98	dcheese_state *state = machine.driver_data<dcheese_state>();
99	99
100		state->m_maincpu = machine.device("maincpu");
101		state->m_audiocpu = machine.device("audiocpu");
	100	state->m_maincpu = machine.device<cpu_device>("maincpu");
	101	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
102	102	state->m_bsmt = machine.device("bsmt");
103	103
104		device_set_irq_callback(state->m_maincpu, irq_callback);
	104	state->m_maincpu->set_irq_acknowledge_callback(irq_callback);
105	105
106	106	state->save_item(NAME(state->m_irq_state));
107	107	state->save_item(NAME(state->m_soundlatch_full));
r17814	r17815
142	142	{
143	143	/* write the latch and set the IRQ */
144	144	m_soundlatch_full = 1;
145		device_set_input_line(m_audiocpu, 0, ASSERT_LINE);
	145	m_audiocpu->set_input_line(0, ASSERT_LINE);
146	146	soundlatch_byte_w(space, 0, data & 0xff);
147	147	}
148	148	}
r17814	r17815
160	160
161	161	/* read the latch and clear the IRQ */
162	162	m_soundlatch_full = 0;
163		device_set_input_line(m_audiocpu, 0, CLEAR_LINE);
	163	m_audiocpu->set_input_line(0, CLEAR_LINE);
164	164	return soundlatch_byte_r(space, 0);
165	165	}
166	166

trunk/src/mame/drivers/chqflag.c

r17814	r17815
132	132	WRITE8_MEMBER(chqflag_state::chqflag_sh_irqtrigger_w)
133	133	{
134	134	soundlatch2_byte_w(space, 0, data);
135		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	135	m_audiocpu->set_input_line(0, HOLD_LINE);
136	136	}
137	137
138	138
r17814	r17815
260	260	static void chqflag_ym2151_irq_w( device_t *device, int data )
261	261	{
262	262	chqflag_state *state = device->machine().driver_data<chqflag_state>();
263		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, data ? ASSERT_LINE : CLEAR_LINE);
	263	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, data ? ASSERT_LINE : CLEAR_LINE);
264	264	}
265	265
266	266
r17814	r17815
327	327
328	328	state->membank("bank1")->configure_entries(0, 4, &ROM[0x10000], 0x2000);
329	329
330		state->m_maincpu = machine.device("maincpu");
331		state->m_audiocpu = machine.device("audiocpu");
	330	state->m_maincpu = machine.device<cpu_device>("maincpu");
	331	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
332	332	state->m_k051316_1 = machine.device("k051316_1");
333	333	state->m_k051316_2 = machine.device("k051316_2");
334	334	state->m_k051960 = machine.device("k051960");

trunk/src/mame/drivers/lsasquad.c

r17814	r17815
541	541	static void irqhandler(device_t *device, int irq)
542	542	{
543	543	lsasquad_state *state = device->machine().driver_data<lsasquad_state>();
544		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	544	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
545	545	}
546	546
547	547	WRITE8_MEMBER(lsasquad_state::unk)
r17814	r17815
571	571
572	572	state->membank("bank1")->configure_entries(0, 8, &ROM[0x10000], 0x2000);
573	573
574		state->m_maincpu = machine.device("maincpu");
575		state->m_audiocpu = machine.device("audiocpu");
	574	state->m_maincpu = machine.device<cpu_device>("maincpu");
	575	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
576	576	state->m_mcu = machine.device("mcu");
577	577
578	578	state->save_item(NAME(state->m_port_a_in));

trunk/src/mame/drivers/sengokmj.c

r17814	r17815
287	287
288	288	static INTERRUPT_GEN( sengokmj_interrupt )
289	289	{
290		device_set_input_line_and_vector(device,0,HOLD_LINE,0xc8/4);
	290	device->execute().set_input_line_and_vector(0,HOLD_LINE,0xc8/4);
291	291	}
292	292
293	293	static MACHINE_CONFIG_START( sengokmj, sengokmj_state )

trunk/src/mame/drivers/silvmil.c

r17814	r17815
302	302
303	303	static void silvmil_irqhandler( device_t *device, int irq )
304	304	{
305		device_set_input_line(device->machine().device("audiocpu"), 0, irq ? ASSERT_LINE : CLEAR_LINE);
	305	device->machine().device("audiocpu")->execute().set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
306	306	}
307	307
308	308

trunk/src/mame/drivers/brkthru.c

r17814	r17815
72	72	m_nmi_mask = ~data & 1;
73	73
74	74	if(data & 2)
75		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	75	m_maincpu->set_input_line(0, CLEAR_LINE);
76	76
77	77	/* bit 1 = ? maybe IRQ acknowledge */
78	78	}
r17814	r17815
84	84	logerror("0803 %02X\n",data);
85	85
86	86	if(data & 2)
87		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	87	m_maincpu->set_input_line(0, CLEAR_LINE);
88	88
89	89
90	90	/* bit 1 = ? maybe IRQ acknowledge */
r17814	r17815
93	93	WRITE8_MEMBER(brkthru_state::brkthru_soundlatch_w)
94	94	{
95	95	soundlatch_byte_w(space, offset, data);
96		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	96	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
97	97	}
98	98
99	99	INPUT_CHANGED_MEMBER(brkthru_state::coin_inserted)
100	100	{
101	101	/* coin insertion causes an IRQ */
102	102	if (oldval)
103		device_set_input_line(m_maincpu, 0, ASSERT_LINE);
	103	m_maincpu->set_input_line(0, ASSERT_LINE);
104	104	}
105	105
106	106
r17814	r17815
366	366	{
367	367	brkthru_state *state = machine.driver_data<brkthru_state>();
368	368
369		state->m_maincpu = machine.device("maincpu");
370		state->m_audiocpu = machine.device("audiocpu");
	369	state->m_maincpu = machine.device<cpu_device>("maincpu");
	370	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
371	371
372	372	state->save_item(NAME(state->m_bgscroll));
373	373	state->save_item(NAME(state->m_bgbasecolor));
r17814	r17815
388	388	brkthru_state *state = device->machine().driver_data<brkthru_state>();
389	389
390	390	if(state->m_nmi_mask)
391		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	391	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
392	392	}
393	393
394	394	static MACHINE_CONFIG_START( brkthru, brkthru_state )

trunk/src/mame/drivers/thepit.c

r17814	r17815
640	640	thepit_state *state = device->machine().driver_data<thepit_state>();
641	641
642	642	if(state->m_nmi_mask)
643		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	643	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
644	644	}
645	645
646	646	static MACHINE_CONFIG_START( thepit, thepit_state )

trunk/src/mame/drivers/cloud9.c

r17814	r17815
128	128	/* assert the IRQ if not already asserted */
129	129	if (!state->m_irq_state)
130	130	{
131		device_set_input_line(state->m_maincpu, 0, ASSERT_LINE);
	131	state->m_maincpu->set_input_line(0, ASSERT_LINE);
132	132	state->m_irq_state = 1;
133	133	}
134	134
r17814	r17815
210	210	{
211	211	if (m_irq_state)
212	212	{
213		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	213	m_maincpu->set_input_line(0, CLEAR_LINE);
214	214	m_irq_state = 0;
215	215	}
216	216	}

trunk/src/mame/drivers/backfire.c

r17814	r17815
42	42	bitmap_ind16  *m_right;
43	43
44	44	/* devices */
45		device_t *m_maincpu;
	45	cpu_device *m_maincpu;
46	46	device_t *m_deco_tilegen1;
47	47	device_t *m_deco_tilegen2;
48	48
r17814	r17815
433	433
434	434	static INTERRUPT_GEN( deco32_vbl_interrupt )
435	435	{
436		device_set_input_line(device, ARM_IRQ_LINE, HOLD_LINE);
	436	device->execute().set_input_line(ARM_IRQ_LINE, HOLD_LINE);
437	437	}
438	438
439	439
r17814	r17815
475	475	{
476	476	backfire_state *state = machine.driver_data<backfire_state>();
477	477
478		state->m_maincpu = machine.device("maincpu");
	478	state->m_maincpu = machine.device<cpu_device>("maincpu");
479	479	state->m_deco_tilegen1 = machine.device("tilegen1");
480	480	state->m_deco_tilegen2 = machine.device("tilegen2");
481	481	state->m_lscreen = machine.device("lscreen");
r17814	r17815
701	701
702	702	//mame_printf_debug( "%08x\n",space.device().safe_pc());
703	703
704		if (space.device() .safe_pc()== 0xce44)  device_spin_until_time(&space.device(), attotime::from_usec(400)); // backfire
705		if (space.device().safe_pc() == 0xcee4)  device_spin_until_time(&space.device(), attotime::from_usec(400)); // backfirea
	704	if (space.device() .safe_pc()== 0xce44)  space.device().execute().spin_until_time(attotime::from_usec(400)); // backfire
	705	if (space.device().safe_pc() == 0xcee4)  space.device().execute().spin_until_time(attotime::from_usec(400)); // backfirea
706	706
707	707	return m_mainram[0x18/4];
708	708	}

trunk/src/mame/drivers/cubeqst.c

r17814	r17815
195	195	cubeqst_state *state = device->machine().driver_data<cubeqst_state>();
196	196	int int_level = state->m_video_field == 0 ? 5 : 6;
197	197
198		device_set_input_line(device, int_level, HOLD_LINE);
	198	device->execute().set_input_line(int_level, HOLD_LINE);
199	199
200	200	/* Update the laserdisc */
201	201	state->m_video_field ^= 1;

trunk/src/mame/drivers/exerion.c

r17814	r17815
140	140	INPUT_CHANGED_MEMBER(exerion_state::coin_inserted)
141	141	{
142	142	/* coin insertion causes an NMI */
143		device_set_input_line(m_maincpu, INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
	143	m_maincpu->set_input_line(INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
144	144	}
145	145
146	146
r17814	r17815
381	381	{
382	382	exerion_state *state = machine.driver_data<exerion_state>();
383	383
384		state->m_maincpu = machine.device("maincpu");
	384	state->m_maincpu = machine.device<cpu_device>("maincpu");
385	385
386	386	state->save_item(NAME(state->m_porta));
387	387	state->save_item(NAME(state->m_portb));

trunk/src/mame/drivers/savquest.c

r17814	r17815
446	446
447	447	WRITE_LINE_MEMBER(savquest_state::savquest_pic8259_1_set_int_line)
448	448	{
449		device_set_input_line(m_maincpu, 0, state ? HOLD_LINE : CLEAR_LINE);
	449	m_maincpu->set_input_line(0, state ? HOLD_LINE : CLEAR_LINE);
450	450	}
451	451
452	452	READ8_MEMBER( savquest_state::get_slave_ack )
r17814	r17815
476	476	{
477	477	savquest_state *state = machine.driver_data<savquest_state>();
478	478
479		device_set_input_line(state->m_maincpu, INPUT_LINE_A20, a20);
	479	state->m_maincpu->set_input_line(INPUT_LINE_A20, a20);
480	480	}
481	481
482	482	static void keyboard_interrupt(running_machine &machine, int state)
r17814	r17815
523	523
524	524	init_pc_common(machine, PCCOMMON_KEYBOARD_AT, savquest_set_keyb_int);
525	525
526		device_set_irq_callback(state->m_maincpu, irq_callback);
	526	state->m_maincpu->set_irq_acknowledge_callback(irq_callback);
527	527	intel82439tx_init(machine);
528	528
529	529	kbdc8042_init(machine, &at8042);

trunk/src/mame/drivers/meijinsn.c

r17814	r17815
318	318	int scanline = param;
319	319
320	320	if(scanline == 240)
321		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	321	state->m_maincpu->set_input_line(1, HOLD_LINE);
322	322
323	323	if(scanline == 0)
324		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	324	state->m_maincpu->set_input_line(2, HOLD_LINE);
325	325	}
326	326
327	327	static const ay8910_interface ay8910_config =

trunk/src/mame/drivers/coolridr.c

r17814	r17815
1138	1138	// IRQs 4, 6 (& 8?) are valid on SH-2
1139	1139	static INTERRUPT_GEN( system_h1 )
1140	1140	{
1141		device_set_input_line(device, 4, HOLD_LINE);
	1141	device->execute().set_input_line(4, HOLD_LINE);
1142	1142	}
1143	1143
1144	1144	//IRQs 10,12 and 14 are valid on SH-1 instead
r17814	r17815
1149	1149
1150	1150	switch(scanline)
1151	1151	{
1152		case 512:device_set_input_line(state->m_subcpu, 0xa, HOLD_LINE); break;
1153		case 256:device_set_input_line(state->m_subcpu, 0xc, HOLD_LINE); break;
1154		case 0:device_set_input_line(state->m_subcpu, 0xe, HOLD_LINE); break;
	1152	case 512:state->m_subcpu->set_input_line(0xa, HOLD_LINE); break;
	1153	case 256:state->m_subcpu->set_input_line(0xc, HOLD_LINE); break;
	1154	case 0:state->m_subcpu->set_input_line(0xe, HOLD_LINE); break;
1155	1155	}
1156	1156	}
1157	1157

trunk/src/mame/drivers/cobra.c

r17814	r17815
1234	1234	machine().device("subcpu")->execute().set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
1235	1235
1236	1236	// give sub cpu a bit more time to stabilize on the current fifo status
1237		device_spin_until_time(machine().device("maincpu"), attotime::from_usec(1));
	1237	machine().device("maincpu")->execute().spin_until_time(attotime::from_usec(1));
1238	1238
1239	1239	if (m_m2s_int_enable & 0x80)
1240	1240	{
r17814	r17815
1601	1601	if ((address & 0xf0000000) == 0xc0000000)
1602	1602	{
1603	1603	// force sync when writing to GFX board main ram
1604		device_spin_until_time(cobra->m_maincpu, attotime::from_usec(80));
	1604	cobra->m_maincpu->spin_until_time(attotime::from_usec(80));
1605	1605	}
1606	1606	}
1607	1607

trunk/src/mame/drivers/tutankhm.c

r17814	r17815
68	68	/* flip flops cause the interrupt to be signalled every other frame */
69	69	state->m_irq_toggle ^= 1;
70	70	if (state->m_irq_toggle && state->m_irq_enable)
71		device_set_input_line(device, 0, ASSERT_LINE);
	71	device->execute().set_input_line(0, ASSERT_LINE);
72	72	}
73	73
74	74
r17814	r17815
77	77
78	78	m_irq_enable = data & 1;
79	79	if (!m_irq_enable)
80		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	80	m_maincpu->set_input_line(0, CLEAR_LINE);
81	81	}
82	82
83	83

trunk/src/mame/drivers/targeth.c

r17814	r17815
37	37	if(scanline == 240)
38	38	{
39	39	/* IRQ 2: drives the game */
40		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	40	state->m_maincpu->set_input_line(2, HOLD_LINE);
41	41	}
42	42
43	43	if(scanline == 0)
44	44	{
45	45	/* IRQ 4: Read 1P Gun */
46		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	46	state->m_maincpu->set_input_line(4, HOLD_LINE);
47	47	/* IRQ 6: Read 2P Gun */
48		device_set_input_line(state->m_maincpu, 6, HOLD_LINE);
	48	state->m_maincpu->set_input_line(6, HOLD_LINE);
49	49	}
50	50	}
51	51

trunk/src/mame/drivers/rainbow.c

r17814	r17815
335	335	if (ACCESSING_BITS_0_7)
336	336	{
337	337	m_jumping_latch = data & 0xff; /*M68000 writes .b to $400007*/
338		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	338	m_audiocpu->set_input_line(0, HOLD_LINE);
339	339	}
340	340	}
341	341
r17814	r17815
626	626	static void irqhandler( device_t *device, int irq )
627	627	{
628	628	rbisland_state *state = device->machine().driver_data<rbisland_state>();
629		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	629	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
630	630	}
631	631
632	632	static const ym2151_interface ym2151_config =
r17814	r17815
666	666	{
667	667	rbisland_state *state = machine.driver_data<rbisland_state>();
668	668
669		state->m_maincpu = machine.device("maincpu");
670		state->m_audiocpu = machine.device("audiocpu");
	669	state->m_maincpu = machine.device<cpu_device>("maincpu");
	670	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
671	671	state->m_pc080sn = machine.device("pc080sn");
672	672	state->m_pc090oj = machine.device("pc090oj");
673	673	}

trunk/src/mame/drivers/galspnbl.c

r17814	r17815
49	49	if (ACCESSING_BITS_0_7)
50	50	{
51	51	soundlatch_byte_w(space,offset,data & 0xff);
52		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	52	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
53	53	}
54	54	}
55	55
r17814	r17815
209	209	static void irqhandler( device_t *device, int linestate )
210	210	{
211	211	galspnbl_state *state = device->machine().driver_data<galspnbl_state>();
212		device_set_input_line(state->m_audiocpu, 0, linestate);
	212	state->m_audiocpu->set_input_line(0, linestate);
213	213	}
214	214
215	215	static const ym3812_interface ym3812_config =
r17814	r17815
222	222	{
223	223	galspnbl_state *state = machine.driver_data<galspnbl_state>();
224	224
225		state->m_audiocpu = machine.device("audiocpu");
	225	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
226	226	}
227	227
228	228	static MACHINE_CONFIG_START( galspnbl, galspnbl_state )

trunk/src/mame/drivers/photoply.c

r17814	r17815
309	309	static MACHINE_START( photoply )
310	310	{
311	311	photoply_state *state = machine.driver_data<photoply_state>();
312		device_set_irq_callback(machine.device("maincpu"), irq_callback);
	312	machine.device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
313	313	state->m_pit8253 = machine.device( "pit8254" );
314	314	state->m_pic8259_1 = machine.device( "pic8259_1" );
315	315	state->m_pic8259_2 = machine.device( "pic8259_2" );

trunk/src/mame/drivers/rungun.c

r17814	r17815
128	128	ioport("EEPROMOUT")->write(data, 0xff);
129	129
130	130	if (!(data & 0x40))
131		device_set_input_line(m_maincpu, M68K_IRQ_5, CLEAR_LINE);
	131	m_maincpu->set_input_line(M68K_IRQ_5, CLEAR_LINE);
132	132	break;
133	133
134	134	case 0x0c/2:
r17814	r17815
159	159	{
160	160
161	161	if (ACCESSING_BITS_8_15)
162		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	162	m_audiocpu->set_input_line(0, HOLD_LINE);
163	163	}
164	164
165	165	READ16_MEMBER(rungun_state::sound_status_msb_r)
r17814	r17815
176	176	rungun_state *state = device->machine().driver_data<rungun_state>();
177	177
178	178	if (state->m_sysreg[0x0c / 2] & 0x09)
179		device_set_input_line(device, M68K_IRQ_5, ASSERT_LINE);
	179	device->execute().set_input_line(M68K_IRQ_5, ASSERT_LINE);
180	180	}
181	181
182	182	static ADDRESS_MAP_START( rungun_map, AS_PROGRAM, 16, rungun_state )
r17814	r17815
223	223	membank("bank2")->set_entry(data & 0x07);
224	224
225	225	if (data & 0x10)
226		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, CLEAR_LINE);
	226	m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
227	227	}
228	228
229	229	static INTERRUPT_GEN(audio_interrupt)
r17814	r17815
233	233	if (state->m_z80_control & 0x80)
234	234	return;
235	235
236		device_set_input_line(device, INPUT_LINE_NMI, ASSERT_LINE);
	236	device->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
237	237	}
238	238
239	239	/* sound (this should be split into audio/xexex.c or pregx.c or so someday) */
r17814	r17815
370	370
371	371	state->membank("bank2")->configure_entries(0, 8, &ROM[0x10000], 0x4000);
372	372
373		state->m_maincpu = machine.device("maincpu");
374		state->m_audiocpu = machine.device("soundcpu");
	373	state->m_maincpu = machine.device<cpu_device>("maincpu");
	374	state->m_audiocpu = machine.device<cpu_device>("soundcpu");
375	375	state->m_k053936 = machine.device("k053936");
376	376	state->m_k055673 = machine.device("k055673");
377	377	state->m_k053252 = machine.device("k053252");

trunk/src/mame/drivers/crystal.c

r17814	r17815
160	160	UINT32    m_DMActrl[2];
161	161	UINT8     m_OldPort4;
162	162
163		device_t *m_maincpu;
	163	cpu_device *m_maincpu;
164	164	ds1302_device *m_ds1302;
165	165	device_t *m_vr0video;
166	166	DECLARE_READ32_MEMBER(FlipCount_r);
r17814	r17815
193	193	static void IntReq( running_machine &machine, int num )
194	194	{
195	195	crystal_state *state = machine.driver_data<crystal_state>();
196		address_space *space = state->m_maincpu->memory().space(AS_PROGRAM);
	196	address_space *space = state->m_maincpu->space(AS_PROGRAM);
197	197	UINT32 IntEn = space->read_dword(0x01800c08);
198	198	UINT32 IntPend = space->read_dword(0x01800c0c);
199	199	if (IntEn & (1 << num))
200	200	{
201	201	IntPend |= (1 << num);
202	202	space->write_dword(0x01800c0c, IntPend);
203		device_set_input_line(state->m_maincpu, SE3208_INT, ASSERT_LINE);
	203	state->m_maincpu->set_input_line(SE3208_INT, ASSERT_LINE);
204	204	}
205	205	#ifdef IDLE_LOOP_SPEEDUP
206	206	state->m_FlipCntRead = 0;
207		device_resume(state->m_maincpu, SUSPEND_REASON_SPIN);
	207	state->m_maincpu->resume(SUSPEND_REASON_SPIN);
208	208	#endif
209	209	}
210	210
r17814	r17815
215	215	UINT32 IntPend = space.read_dword(0x01800c0c);
216	216	m_FlipCntRead++;
217	217	if (m_FlipCntRead >= 16 && !IntPend && m_FlipCount != 0)
218		device_suspend(m_maincpu, SUSPEND_REASON_SPIN, 1);
	218	m_maincpu->suspend(SUSPEND_REASON_SPIN, 1);
219	219	#endif
220	220	return ((UINT32) m_FlipCount) << 16;
221	221	}
r17814	r17815
262	262	IntPend &= ~(1 << (data & 0x1f));
263	263	space.write_dword(0x01800c0c, IntPend);
264	264	if (!IntPend)
265		device_set_input_line(m_maincpu, SE3208_INT, CLEAR_LINE);
	265	m_maincpu->set_input_line(SE3208_INT, CLEAR_LINE);
266	266	}
267	267	if (mem_mask & 0xff00)
268	268	m_IntHigh = (data >> 8) & 7;
r17814	r17815
579	579	crystal_state *state = machine.driver_data<crystal_state>();
580	580	int i;
581	581
582		state->m_maincpu = machine.device("maincpu");
	582	state->m_maincpu = machine.device<cpu_device>("maincpu");
583	583	state->m_ds1302 = machine.device<ds1302_device>("rtc");
584	584	state->m_vr0video = machine.device("vr0");
585	585
586		device_set_irq_callback(machine.device("maincpu"), icallback);
	586	machine.device("maincpu")->execute().set_irq_acknowledge_callback(icallback);
587	587	for (i = 0; i < 4; i++)
588	588	state->m_Timer[i] = machine.scheduler().timer_alloc(FUNC(Timercb), (void*)(FPTR)i);
589	589
r17814	r17815
613	613	memset(state->m_vidregs, 0, 0x10000);
614	614	state->m_FlipCount = 0;
615	615	state->m_IntHigh = 0;
616		device_set_irq_callback(machine.device("maincpu"), icallback);
	616	machine.device("maincpu")->execute().set_irq_acknowledge_callback(icallback);
617	617	state->m_Bank = 0;
618	618	state->membank("bank1")->set_base(state->memregion("user1")->base() + 0);
619	619	state->m_FlashCmd = 0xff;

trunk/src/mame/drivers/eprom.c

r17814	r17815
144	144
145	145	m_sync_data[offset] = newword;
146	146	if ((oldword & 0xff00) != (newword & 0xff00))
147		device_yield(&space.device());
	147	space.device().execute().yield();
148	148	}
149	149
150	150

trunk/src/mame/drivers/madmotor.c

r17814	r17815
30	30	if (ACCESSING_BITS_0_7)
31	31	{
32	32	soundlatch_byte_w(space, 0, data & 0xff);
33		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	33	m_audiocpu->set_input_line(0, HOLD_LINE);
34	34	}
35	35	}
36	36
r17814	r17815
222	222	static void sound_irq(device_t *device, int state)
223	223	{
224	224	madmotor_state *driver_state = device->machine().driver_data<madmotor_state>();
225		device_set_input_line(driver_state->m_audiocpu, 1, state); /* IRQ 2 */
	225	driver_state->m_audiocpu->set_input_line(1, state); /* IRQ 2 */
226	226	}
227	227
228	228	static const ym2151_interface ym2151_config =
r17814	r17815
234	234	{
235	235	madmotor_state *state = machine.driver_data<madmotor_state>();
236	236
237		state->m_maincpu = machine.device("maincpu");
238		state->m_audiocpu = machine.device("audiocpu");
	237	state->m_maincpu = machine.device<cpu_device>("maincpu");
	238	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
239	239
240	240	state->save_item(NAME(state->m_flipscreen));
241	241	}

trunk/src/mame/drivers/rocnrope.c

r17814	r17815
191	191	rocnrope_state *state = device->machine().driver_data<rocnrope_state>();
192	192
193	193	if(state->m_irq_mask)
194		device_set_input_line(device, 0, HOLD_LINE);
	194	device->execute().set_input_line(0, HOLD_LINE);
195	195	}
196	196
197	197

trunk/src/mame/drivers/aerofgt.c

r17814	r17815
72	72	{
73	73	m_pending_command = 1;
74	74	soundlatch_byte_w(space, offset, data & 0xff);
75		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	75	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
76	76	}
77	77	}
78	78
r17814	r17815
82	82	{
83	83	m_pending_command = 1;
84	84	soundlatch_byte_w(space, offset, (data >> 8) & 0xff);
85		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	85	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
86	86	}
87	87	}
88	88
r17814	r17815
91	91	if(ACCESSING_BITS_8_15)
92	92	{
93	93	soundlatch_byte_w(space, 0, (data >> 8) & 0xff);
94		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	94	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
95	95	}
96	96	}
97	97
r17814	r17815
1280	1280	static void irqhandler( device_t *device, int irq )
1281	1281	{
1282	1282	aerofgt_state *state = device->machine().driver_data<aerofgt_state>();
1283		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	1283	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
1284	1284	}
1285	1285
1286	1286	static const ym2610_interface ym2610_config =
r17814	r17815
1298	1298	{
1299	1299	aerofgt_state *state = machine.driver_data<aerofgt_state>();
1300	1300
1301		state->m_audiocpu = machine.device("audiocpu");
	1301	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
1302	1302	state->save_item(NAME(state->m_pending_command));
1303	1303	}
1304	1304

trunk/src/mame/drivers/quakeat.c

r17814	r17815
158	158	static MACHINE_START(quakeat)
159	159	{
160	160	quakeat_state *state = machine.driver_data<quakeat_state>();
161		device_set_irq_callback(machine.device("maincpu"), irq_callback);
	161	machine.device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
162	162
163	163	state->m_pic8259_1 = machine.device( "pic8259_1" );
164	164	state->m_pic8259_2 = machine.device( "pic8259_2" );

trunk/src/mame/drivers/ultrsprt.c

r17814	r17815
205	205
206	206	static INTERRUPT_GEN( ultrsprt_vblank )
207	207	{
208		device_set_input_line(device, INPUT_LINE_IRQ1, ASSERT_LINE);
	208	device->execute().set_input_line(INPUT_LINE_IRQ1, ASSERT_LINE);
209	209	}
210	210
211	211	static void sound_irq_callback(running_machine &machine, int irq)

trunk/src/mame/drivers/senjyo.c

r17814	r17815
93	93	{
94	94	senjyo_state *state = device->machine().driver_data<senjyo_state>();
95	95
96		if (state->m_int_delay_kludge == 0) device_set_input_line(device, 0, HOLD_LINE);
	96	if (state->m_int_delay_kludge == 0) device->execute().set_input_line(0, HOLD_LINE);
97	97	else state->m_int_delay_kludge--;
98	98	}
99	99

trunk/src/mame/drivers/twinkle.c

r17814	r17815
702	702
703	703	if ((!(data & 0x0080)) && (m_spu_ctrl & 0x0080))
704	704	{
705		device_set_input_line(&space.device(), M68K_IRQ_1, CLEAR_LINE);
	705	space.device().execute().set_input_line(M68K_IRQ_1, CLEAR_LINE);
706	706	}
707	707	else if ((!(data & 0x0100)) && (m_spu_ctrl & 0x0100))
708	708	{
709		device_set_input_line(&space.device(), M68K_IRQ_2, CLEAR_LINE);
	709	space.device().execute().set_input_line(M68K_IRQ_2, CLEAR_LINE);
710	710	}
711	711	else if ((!(data & 0x0200)) && (m_spu_ctrl & 0x0200))
712	712	{
713		device_set_input_line(&space.device(), M68K_IRQ_4, CLEAR_LINE);
	713	space.device().execute().set_input_line(M68K_IRQ_4, CLEAR_LINE);
714	714	}
715	715	else if ((!(data & 0x0400)) && (m_spu_ctrl & 0x0400))
716	716	{
717		device_set_input_line(&space.device(), M68K_IRQ_6, CLEAR_LINE);
	717	space.device().execute().set_input_line(M68K_IRQ_6, CLEAR_LINE);
718	718	}
719	719
720	720	m_spu_ctrl = data;

trunk/src/mame/drivers/bzone.c

r17814	r17815
249	249	static INTERRUPT_GEN( bzone_interrupt )
250	250	{
251	251	if (device->machine().root_device().ioport("IN0")->read() & 0x10)
252		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	252	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
253	253	}
254	254
255	255

trunk/src/mame/drivers/simpl156.c

r17814	r17815
385	385
386	386	static INTERRUPT_GEN( simpl156_vbl_interrupt )
387	387	{
388		device_set_input_line(device, ARM_IRQ_LINE, HOLD_LINE);
	388	device->execute().set_input_line(ARM_IRQ_LINE, HOLD_LINE);
389	389	}
390	390
391	391
r17814	r17815
1055	1055	READ32_MEMBER(simpl156_state::joemacr_speedup_r)
1056	1056	{
1057	1057	if (space.device().safe_pc() == 0x284)
1058		device_spin_until_time(&space.device(), attotime::from_usec(400));
	1058	space.device().execute().spin_until_time(attotime::from_usec(400));
1059	1059	return m_systemram[0x18/4];
1060	1060	}
1061	1061
r17814	r17815
1069	1069	READ32_MEMBER(simpl156_state::chainrec_speedup_r)
1070	1070	{
1071	1071	if (space.device().safe_pc() == 0x2d4)
1072		device_spin_until_time(&space.device(), attotime::from_usec(400));
	1072	space.device().execute().spin_until_time(attotime::from_usec(400));
1073	1073	return m_systemram[0x18/4];
1074	1074	}
1075	1075
r17814	r17815
1082	1082	READ32_MEMBER(simpl156_state::prtytime_speedup_r)
1083	1083	{
1084	1084	if (space.device().safe_pc() == 0x4f0)
1085		device_spin_until_time(&space.device(), attotime::from_usec(400));
	1085	space.device().execute().spin_until_time(attotime::from_usec(400));
1086	1086	return m_systemram[0xae0/4];
1087	1087	}
1088	1088
r17814	r17815
1096	1096	READ32_MEMBER(simpl156_state::charlien_speedup_r)
1097	1097	{
1098	1098	if (space.device().safe_pc() == 0xc8c8)
1099		device_spin_until_time(&space.device(), attotime::from_usec(400));
	1099	space.device().execute().spin_until_time(attotime::from_usec(400));
1100	1100	return m_systemram[0x10/4];
1101	1101	}
1102	1102
r17814	r17815
1109	1109	READ32_MEMBER(simpl156_state::osman_speedup_r)
1110	1110	{
1111	1111	if (space.device().safe_pc() == 0x5974)
1112		device_spin_until_time(&space.device(), attotime::from_usec(400));
	1112	space.device().execute().spin_until_time(attotime::from_usec(400));
1113	1113	return m_systemram[0x10/4];
1114	1114	}
1115	1115

trunk/src/mame/drivers/lgp.c

r17814	r17815
339	339	{
340	340	lgp_state *state = device->machine().driver_data<lgp_state>();
341	341	// NMI
342		//device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	342	//device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
343	343
344	344	// IRQ
345		device_set_input_line(device, 0, ASSERT_LINE);
	345	device->execute().set_input_line(0, ASSERT_LINE);
346	346	state->m_irq_timer->adjust(attotime::from_usec(50));
347	347	}
348	348

trunk/src/mame/drivers/battlnts.c

r17814	r17815
29	29	{
30	30	battlnts_state *state = device->machine().driver_data<battlnts_state>();
31	31	if (k007342_is_int_enabled(state->m_k007342))
32		device_set_input_line(device, HD6309_IRQ_LINE, HOLD_LINE);
	32	device->execute().set_input_line(HD6309_IRQ_LINE, HOLD_LINE);
33	33	}
34	34
35	35	WRITE8_MEMBER(battlnts_state::battlnts_sh_irqtrigger_w)
36	36	{
37		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	37	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
38	38	}
39	39
40	40	WRITE8_MEMBER(battlnts_state::battlnts_bankswitch_w)
r17814	r17815
228	228
229	229	state->membank("bank1")->configure_entries(0, 4, &ROM[0x10000], 0x4000);
230	230
231		state->m_audiocpu = machine.device("audiocpu");
	231	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
232	232	state->m_k007342 = machine.device("k007342");
233	233	state->m_k007420 = machine.device("k007420");
234	234

trunk/src/mame/drivers/galpani2.c

r17814	r17815
548	548	int scanline = param;
549	549
550	550	if(scanline == 240)
551		device_set_input_line(state->m_maincpu, 5, HOLD_LINE);
	551	state->m_maincpu->set_input_line(5, HOLD_LINE);
552	552
553	553	/* MCU related? */
554	554	if(scanline == 128)
555	555	{
556		device_set_input_line(state->m_maincpu, 3, HOLD_LINE);
557		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	556	state->m_maincpu->set_input_line(3, HOLD_LINE);
	557	state->m_maincpu->set_input_line(4, HOLD_LINE);
558	558	}
559	559
560	560	if(scanline == 0)
561		device_set_input_line(state->m_maincpu, 6, HOLD_LINE); // hblank?
	561	state->m_maincpu->set_input_line(6, HOLD_LINE); // hblank?
562	562	}
563	563
564	564	/* CPU#2 interrupts, lev 3,4 & 5 are tested on power up. The rest is rte, but lev 7 */
r17814	r17815
568	568	int scanline = param;
569	569
570	570	if(scanline == 240)
571		device_set_input_line(state->m_subcpu, 5, HOLD_LINE);
	571	state->m_subcpu->set_input_line(5, HOLD_LINE);
572	572
573	573	if(scanline == 128)
574		device_set_input_line(state->m_subcpu, 4, HOLD_LINE);
	574	state->m_subcpu->set_input_line(4, HOLD_LINE);
575	575
576	576	if(scanline == 0)
577		device_set_input_line(state->m_subcpu, 3, HOLD_LINE);
	577	state->m_subcpu->set_input_line(3, HOLD_LINE);
578	578	}
579	579
580	580	static MACHINE_CONFIG_START( galpani2, galpani2_state )

trunk/src/mame/drivers/sprint2.c

r17814	r17815
111	111	device->machine().watchdog_enable(!service_mode(device->machine()));
112	112
113	113	if (!service_mode(device->machine()))
114		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	114	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
115	115	}
116	116
117	117

trunk/src/mame/drivers/midqslvr.c

r17814	r17815
582	582
583	583	WRITE_LINE_MEMBER(midqslvr_state::midqslvr_pic8259_1_set_int_line)
584	584	{
585		device_set_input_line(m_maincpu, 0, state ? HOLD_LINE : CLEAR_LINE);
	585	m_maincpu->set_input_line(0, state ? HOLD_LINE : CLEAR_LINE);
586	586	}
587	587
588	588	READ8_MEMBER( midqslvr_state::get_slave_ack )
r17814	r17815
612	612	{
613	613	midqslvr_state *state = machine.driver_data<midqslvr_state>();
614	614
615		device_set_input_line(state->m_maincpu, INPUT_LINE_A20, a20);
	615	state->m_maincpu->set_input_line(INPUT_LINE_A20, a20);
616	616	}
617	617
618	618	static void keyboard_interrupt(running_machine &machine, int state)
r17814	r17815
666	666
667	667	init_pc_common(machine, PCCOMMON_KEYBOARD_AT, midqslvr_set_keyb_int);
668	668
669		device_set_irq_callback(state->m_maincpu, irq_callback);
	669	state->m_maincpu->set_irq_acknowledge_callback(irq_callback);
670	670	intel82439tx_init(machine);
671	671
672	672	kbdc8042_init(machine, &at8042);

trunk/src/mame/drivers/seibuspi.c

r17814	r17815
1791	1791
1792	1792	static INTERRUPT_GEN( spi_interrupt )
1793	1793	{
1794		device_set_input_line(device, 0, ASSERT_LINE );
	1794	device->execute().set_input_line(0, ASSERT_LINE );
1795	1795	}
1796	1796
1797	1797	static IRQ_CALLBACK(spi_irq_callback)
r17814	r17815
1817	1817	UINT8 flash_data = rombase[0x1ffffc];
1818	1818
1819	1819	machine.device("soundcpu")->execute().set_input_line(INPUT_LINE_RESET, ASSERT_LINE );
1820		device_set_irq_callback(machine.device("maincpu"), spi_irq_callback);
	1820	machine.device("maincpu")->execute().set_irq_acknowledge_callback(spi_irq_callback);
1821	1821
1822	1822	machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x00000680, 0x00000683, read32_delegate(FUNC(seibuspi_state::sound_fifo_r),state));
1823	1823	machine.device("maincpu")->memory().space(AS_PROGRAM)->install_write_handler(0x00000688, 0x0000068b, write32_delegate(FUNC(seibuspi_state::z80_prg_fifo_w),state));
r17814	r17815
1906	1906	machine.device("maincpu")->memory().space(AS_PROGRAM)->install_write_handler(0x0000068c, 0x0000068f, write32_delegate(FUNC(seibuspi_state::eeprom_w),state));
1907	1907	machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler(0x00000680, 0x00000683, read32_delegate(FUNC(seibuspi_state::sb_coin_r),state));
1908	1908
1909		device_set_irq_callback(machine.device("maincpu"), spi_irq_callback);
	1909	machine.device("maincpu")->execute().set_irq_acknowledge_callback(spi_irq_callback);
1910	1910
1911	1911	state->m_sb_coin_latch = 0;
1912	1912	}
r17814	r17815
1945	1945
1946	1946	READ32_MEMBER(seibuspi_state::senkyu_speedup_r)
1947	1947	{
1948		if (space.device().safe_pc()==0x00305bb2) device_spin_until_interrupt(&space.device()); // idle
	1948	if (space.device().safe_pc()==0x00305bb2) space.device().execute().spin_until_interrupt(); // idle
1949	1949	return m_spimainram[(0x0018cb4-0x800)/4];
1950	1950	}
1951	1951
1952	1952	READ32_MEMBER(seibuspi_state::senkyua_speedup_r)
1953	1953	{
1954		if (space.device().safe_pc()== 0x30582e) device_spin_until_interrupt(&space.device()); // idle
	1954	if (space.device().safe_pc()== 0x30582e) space.device().execute().spin_until_interrupt(); // idle
1955	1955	return m_spimainram[(0x0018c9c-0x800)/4];
1956	1956	}
1957	1957
r17814	r17815
1960	1960	//  printf("space.device().safe_pc() %06x\n", space.device().safe_pc());
1961	1961
1962	1962	/* batlbalu */
1963		if (space.device().safe_pc()==0x00305996) device_spin_until_interrupt(&space.device()); // idle
	1963	if (space.device().safe_pc()==0x00305996) space.device().execute().spin_until_interrupt(); // idle
1964	1964
1965	1965	/* batlball */
1966		if (space.device().safe_pc()==0x003058aa) device_spin_until_interrupt(&space.device()); // idle
	1966	if (space.device().safe_pc()==0x003058aa) space.device().execute().spin_until_interrupt(); // idle
1967	1967
1968	1968	return m_spimainram[(0x0018db4-0x800)/4];
1969	1969	}
r17814	r17815
1971	1971	READ32_MEMBER(seibuspi_state::rdft_speedup_r)
1972	1972	{
1973	1973	/* rdft */
1974		if (space.device().safe_pc()==0x0203f0a) device_spin_until_interrupt(&space.device()); // idle
	1974	if (space.device().safe_pc()==0x0203f0a) space.device().execute().spin_until_interrupt(); // idle
1975	1975
1976	1976	/* rdftau */
1977		if (space.device().safe_pc()==0x0203f16) device_spin_until_interrupt(&space.device()); // idle
	1977	if (space.device().safe_pc()==0x0203f16) space.device().execute().spin_until_interrupt(); // idle
1978	1978
1979	1979	/* rdftj */
1980		if (space.device().safe_pc()==0x0203f22) device_spin_until_interrupt(&space.device()); // idle
	1980	if (space.device().safe_pc()==0x0203f22) space.device().execute().spin_until_interrupt(); // idle
1981	1981
1982	1982	/* rdftdi */
1983		if (space.device().safe_pc()==0x0203f46) device_spin_until_interrupt(&space.device()); // idle
	1983	if (space.device().safe_pc()==0x0203f46) space.device().execute().spin_until_interrupt(); // idle
1984	1984
1985	1985	/* rdftu */
1986		if (space.device().safe_pc()==0x0203f3a) device_spin_until_interrupt(&space.device()); // idle
	1986	if (space.device().safe_pc()==0x0203f3a) space.device().execute().spin_until_interrupt(); // idle
1987	1987
1988	1988	//  mame_printf_debug("%08x\n",space.device().safe_pc());
1989	1989
r17814	r17815
1993	1993	READ32_MEMBER(seibuspi_state::viprp1_speedup_r)
1994	1994	{
1995	1995	/* viprp1 */
1996		if (space.device().safe_pc()==0x0202769) device_spin_until_interrupt(&space.device()); // idle
	1996	if (space.device().safe_pc()==0x0202769) space.device().execute().spin_until_interrupt(); // idle
1997	1997
1998	1998	/* viprp1s */
1999		if (space.device().safe_pc()==0x02027e9) device_spin_until_interrupt(&space.device()); // idle
	1999	if (space.device().safe_pc()==0x02027e9) space.device().execute().spin_until_interrupt(); // idle
2000	2000
2001	2001	/* viprp1ot */
2002		if (space.device().safe_pc()==0x02026bd) device_spin_until_interrupt(&space.device()); // idle
	2002	if (space.device().safe_pc()==0x02026bd) space.device().execute().spin_until_interrupt(); // idle
2003	2003
2004	2004	//  mame_printf_debug("%08x\n",space.device().safe_pc());
2005	2005
r17814	r17815
2009	2009	READ32_MEMBER(seibuspi_state::viprp1o_speedup_r)
2010	2010	{
2011	2011	/* viperp1o */
2012		if (space.device().safe_pc()==0x0201f99) device_spin_until_interrupt(&space.device()); // idle
	2012	if (space.device().safe_pc()==0x0201f99) space.device().execute().spin_until_interrupt(); // idle
2013	2013	//  mame_printf_debug("%08x\n",space.device().safe_pc());
2014	2014	return m_spimainram[(0x001d49c-0x800)/4];
2015	2015	}
r17814	r17815
2019	2019	READ32_MEMBER(seibuspi_state::ejanhs_speedup_r)
2020	2020	{
2021	2021	// mame_printf_debug("%08x\n",space.device().safe_pc());
2022		if (space.device().safe_pc()==0x03032c7) device_spin_until_interrupt(&space.device()); // idle
	2022	if (space.device().safe_pc()==0x03032c7) space.device().execute().spin_until_interrupt(); // idle
2023	2023	return m_spimainram[(0x002d224-0x800)/4];
2024	2024	}
2025	2025	#endif
r17814	r17815
2028	2028	{
2029	2029
2030	2030	/* rdft22kc */
2031		if (space.device().safe_pc()==0x0203926) device_spin_until_interrupt(&space.device()); // idle
	2031	if (space.device().safe_pc()==0x0203926) space.device().execute().spin_until_interrupt(); // idle
2032	2032
2033	2033	/* rdft2, rdft2j */
2034		if (space.device().safe_pc()==0x0204372) device_spin_until_interrupt(&space.device()); // idle
	2034	if (space.device().safe_pc()==0x0204372) space.device().execute().spin_until_interrupt(); // idle
2035	2035
2036	2036	/* rdft2us */
2037		if (space.device().safe_pc()==0x020420e) device_spin_until_interrupt(&space.device()); // idle
	2037	if (space.device().safe_pc()==0x020420e) space.device().execute().spin_until_interrupt(); // idle
2038	2038
2039	2039	/* rdft2a */
2040		if (space.device().safe_pc()==0x0204366) device_spin_until_interrupt(&space.device()); // idle
	2040	if (space.device().safe_pc()==0x0204366) space.device().execute().spin_until_interrupt(); // idle
2041	2041
2042	2042	//  mame_printf_debug("%08x\n",space.device().safe_pc());
2043	2043
r17814	r17815
2047	2047	READ32_MEMBER(seibuspi_state::rfjet_speedup_r)
2048	2048	{
2049	2049	/* rfjet, rfjetu, rfjeta */
2050		if (space.device().safe_pc()==0x0206082) device_spin_until_interrupt(&space.device()); // idle
	2050	if (space.device().safe_pc()==0x0206082) space.device().execute().spin_until_interrupt(); // idle
2051	2051
2052	2052	/* rfjetus */
2053	2053	if (space.device().safe_pc()==0x0205b39)
2054	2054	{
2055	2055	UINT32 r;
2056		device_spin_until_interrupt(&space.device()); // idle
	2056	space.device().execute().spin_until_interrupt(); // idle
2057	2057	// Hack to enter test mode
2058	2058	r = m_spimainram[(0x002894c-0x800)/4] & (~0x400);
2059	2059	return r | (((ioport("SYSTEM")->read() ^ 0xff)<<8) & 0x400);
2060	2060	}
2061	2061
2062	2062	/* rfjetj */
2063		if (space.device().safe_pc()==0x0205f2e) device_spin_until_interrupt(&space.device()); // idle
	2063	if (space.device().safe_pc()==0x0205f2e) space.device().execute().spin_until_interrupt(); // idle
2064	2064
2065	2065	//  mame_printf_debug("%08x\n",space.device().safe_pc());
2066	2066
r17814	r17815
2189	2189
2190	2190	static MACHINE_RESET( seibu386 )
2191	2191	{
2192		device_set_irq_callback(machine.device("maincpu"), spi_irq_callback);
	2192	machine.device("maincpu")->execute().set_irq_acknowledge_callback(spi_irq_callback);
2193	2193	}
2194	2194
2195	2195	static MACHINE_CONFIG_START( seibu386, seibuspi_state )

trunk/src/mame/drivers/coolpool.c

r17814	r17815
136	136	{
137	137	coolpool_state *state = machine.driver_data<coolpool_state>();
138	138
139		state->m_maincpu = machine.device("maincpu");
	139	state->m_maincpu = machine.device<cpu_device>("maincpu");
140	140	state->m_dsp = machine.device("dsp");
141	141
142	142	state->m_nvram_write_enable = 0;
r17814	r17815
211	211	{
212	212	coolpool_state *state = timer.machine().driver_data<coolpool_state>();
213	213
214		device_set_input_line(state->m_dsp, 0, ASSERT_LINE);
215		device_set_input_line(state->m_dsp, 0, CLEAR_LINE);
	214	state->m_dsp->execute().set_input_line(0, ASSERT_LINE);
	215	state->m_dsp->execute().set_input_line(0, CLEAR_LINE);
216	216	}
217	217
218	218
r17814	r17815
240	240	if (m_same_cmd_count >= 5)
241	241	{
242	242	m_same_cmd_count = 5;
243		device_spin(&space.device());
	243	space.device().execute().spin();
244	244	}
245	245	m_old_cmd = m_cmd_pending;
246	246

trunk/src/mame/drivers/sauro.c

r17814	r17815
369	369
370	370	static INTERRUPT_GEN( sauro_interrupt )
371	371	{
372		device_set_input_line(device, 0, HOLD_LINE);
	372	device->execute().set_input_line(0, HOLD_LINE);
373	373	}
374	374
375	375	static MACHINE_CONFIG_START( tecfri, sauro_state )

trunk/src/mame/drivers/timetrv.c

r17814	r17815
135	135
136	136	static INTERRUPT_GEN( vblank_irq )
137	137	{
138		device_set_input_line_and_vector(device,0,HOLD_LINE,0x20/4); //vblank bit flag clear
	138	device->execute().set_input_line_and_vector(0,HOLD_LINE,0x20/4); //vblank bit flag clear
139	139	}
140	140
141	141	static INTERRUPT_GEN( ld_irq )
142	142	{
143		device_set_input_line_and_vector(device,0,HOLD_LINE,0x48/4); //ld irq
	143	device->execute().set_input_line_and_vector(0,HOLD_LINE,0x48/4); //ld irq
144	144	}
145	145
146	146	static MACHINE_CONFIG_START( timetrv, timetrv_state )

trunk/src/mame/drivers/drmicro.c

r17814	r17815
28	28	drmicro_state *state = device->machine().driver_data<drmicro_state>();
29	29
30	30	if (state->m_nmi_enable)
31		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	31	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
32	32	}
33	33
34	34	WRITE8_MEMBER(drmicro_state::nmi_enable_w)

trunk/src/mame/drivers/system1.c

r17814	r17815
417	417
418	418	/* bit 6 is connected to the 8751 IRQ */
419	419	if (i8751 != NULL)
420		device_set_input_line(i8751, MCS51_INT1_LINE, (data & 0x40) ? CLEAR_LINE : ASSERT_LINE);
	420	i8751->execute().set_input_line(MCS51_INT1_LINE, (data & 0x40) ? CLEAR_LINE : ASSERT_LINE);
421	421
422	422	/* handle any custom banking or other stuff */
423	423	if (m_videomode_custom != NULL)
r17814	r17815
597	597	static INTERRUPT_GEN( mcu_irq_assert )
598	598	{
599	599	/* toggle the INT0 line on the MCU */
600		device_set_input_line(device, MCS51_INT0_LINE, ASSERT_LINE);
601		device_set_input_line(device, MCS51_INT0_LINE, CLEAR_LINE);
	600	device->execute().set_input_line(MCS51_INT0_LINE, ASSERT_LINE);
	601	device->execute().set_input_line(MCS51_INT0_LINE, CLEAR_LINE);
602	602
603	603	/* boost interleave to ensure that the MCU can break the Z80 out of a HALT */
604	604	device->machine().scheduler().boost_interleave(attotime::zero, attotime::from_usec(10));
r17814	r17815
614	614	*/
615	615
616	616	device_t *mcu = timer.machine().device("mcu");
617		device_set_input_line(mcu, MCS51_T0_LINE, ASSERT_LINE);
618		device_set_input_line(mcu, MCS51_T0_LINE, CLEAR_LINE);
	617	mcu->execute().set_input_line(MCS51_T0_LINE, ASSERT_LINE);
	618	mcu->execute().set_input_line(MCS51_T0_LINE, CLEAR_LINE);
619	619	}
620	620
621	621
r17814	r17815
638	638
639	639	/* bit 2 is toggled once near the end of an IRQ */
640	640	if (((m_mcu_control ^ data) & 0x04) && !(data & 0x04))
641		device_set_input_line(&space.device(), MCS51_INT0_LINE, CLEAR_LINE);
	641	space.device().execute().set_input_line(MCS51_INT0_LINE, CLEAR_LINE);
642	642
643	643	/* bit 3 is toggled once at the start of an IRQ, and again at the end */
644	644	if (((m_mcu_control ^ data) & 0x08) && !(data & 0x08))

trunk/src/mame/drivers/niyanpai.c

r17814	r17815
929	929
930	930	static INTERRUPT_GEN( niyanpai_interrupt )
931	931	{
932		device_set_input_line_and_vector(device, 1, HOLD_LINE,0x100/4);
	932	device->execute().set_input_line_and_vector(1, HOLD_LINE,0x100/4);
933	933	}
934	934
935	935	static const z80_daisy_config daisy_chain_sound[] =

trunk/src/mame/drivers/suprnova.c

r17814	r17815
441	441	int scanline = param;
442	442
443	443	if(scanline == 240)
444		device_set_input_line(state->m_maincpu,5,HOLD_LINE); //vblank
	444	state->m_maincpu->set_input_line(5,HOLD_LINE); //vblank
445	445	else if(scanline == 0)
446		device_set_input_line(state->m_maincpu,1,HOLD_LINE); // spc
	446	state->m_maincpu->set_input_line(1,HOLD_LINE); // spc
447	447	}
448	448
449	449	/**********************************************************************************
r17814	r17815
646	646	{
647	647	if (!strcmp(machine().system().name,"vblokbrk") ||
648	648	!strcmp(machine().system().name,"sarukani"))
649		device_spin_until_interrupt(&space.device());
	649	space.device().execute().spin_until_interrupt();
650	650	}
651	651
652	652	}
r17814	r17815
870	870	if (space.device().safe_pc()==0x402206e)
871	871	{
872	872	if(m_main_ram[0x00078/4] == m_main_ram[0x0c780/4])
873		device_spin_until_interrupt(&space.device());
	873	space.device().execute().spin_until_interrupt();
874	874	}
875	875	return m_main_ram[0x0c780/4];
876	876	}
877	877
878	878	READ32_MEMBER(skns_state::cyvern_speedup_r)
879	879	{
880		if (space.device().safe_pc()==0x402ebd2) device_spin_until_interrupt(&space.device());
	880	if (space.device().safe_pc()==0x402ebd2) space.device().execute().spin_until_interrupt();
881	881	return m_main_ram[0x4d3c8/4];
882	882	}
883	883
884	884	READ32_MEMBER(skns_state::puzzloopj_speedup_r)
885	885	{
886		if (space.device().safe_pc()==0x401dca0) device_spin_until_interrupt(&space.device());
	886	if (space.device().safe_pc()==0x401dca0) space.device().execute().spin_until_interrupt();
887	887	return m_main_ram[0x86714/4];
888	888	}
889	889
890	890	READ32_MEMBER(skns_state::puzzloopa_speedup_r)
891	891	{
892		if (space.device().safe_pc()==0x401d9d4) device_spin_until_interrupt(&space.device());
	892	if (space.device().safe_pc()==0x401d9d4) space.device().execute().spin_until_interrupt();
893	893	return m_main_ram[0x85bcc/4];
894	894	}
895	895
896	896	READ32_MEMBER(skns_state::puzzloopu_speedup_r)
897	897	{
898		if (space.device().safe_pc()==0x401dab0) device_spin_until_interrupt(&space.device());
	898	if (space.device().safe_pc()==0x401dab0) space.device().execute().spin_until_interrupt();
899	899	return m_main_ram[0x85cec/4];
900	900	}
901	901
r17814	r17815
908	908	0401DA18: BF      $0401DA26
909	909	0401DA26: BRA     $0401DA12
910	910	*/
911		if (space.device().safe_pc()==0x401da14) device_spin_until_interrupt(&space.device());
	911	if (space.device().safe_pc()==0x401da14) space.device().execute().spin_until_interrupt();
912	912	return m_main_ram[0x81d38/4];
913	913	}
914	914
915	915	READ32_MEMBER(skns_state::senknow_speedup_r)
916	916	{
917		if (space.device().safe_pc()==0x4017dce) device_spin_until_interrupt(&space.device());
	917	if (space.device().safe_pc()==0x4017dce) space.device().execute().spin_until_interrupt();
918	918	return m_main_ram[0x0000dc/4];
919	919	}
920	920
921	921	READ32_MEMBER(skns_state::teljan_speedup_r)
922	922	{
923		if (space.device().safe_pc()==0x401ba32) device_spin_until_interrupt(&space.device());
	923	if (space.device().safe_pc()==0x401ba32) space.device().execute().spin_until_interrupt();
924	924	return m_main_ram[0x002fb4/4];
925	925	}
926	926
927	927	READ32_MEMBER(skns_state::jjparads_speedup_r)
928	928	{
929		if (space.device().safe_pc()==0x4015e84) device_spin_until_interrupt(&space.device());
	929	if (space.device().safe_pc()==0x4015e84) space.device().execute().spin_until_interrupt();
930	930	return m_main_ram[0x000994/4];
931	931	}
932	932
933	933	READ32_MEMBER(skns_state::jjparad2_speedup_r)
934	934	{
935		if (space.device().safe_pc()==0x401620a) device_spin_until_interrupt(&space.device());
	935	if (space.device().safe_pc()==0x401620a) space.device().execute().spin_until_interrupt();
936	936	return m_main_ram[0x000984/4];
937	937	}
938	938
939	939	READ32_MEMBER(skns_state::ryouran_speedup_r)
940	940	{
941		if (space.device().safe_pc()==0x40182ce) device_spin_until_interrupt(&space.device());
	941	if (space.device().safe_pc()==0x40182ce) space.device().execute().spin_until_interrupt();
942	942	return m_main_ram[0x000a14/4];
943	943	}
944	944
945	945	READ32_MEMBER(skns_state::galpans2_speedup_r)
946	946	{
947		if (space.device().safe_pc()==0x4049ae2) device_spin_until_interrupt(&space.device());
	947	if (space.device().safe_pc()==0x4049ae2) space.device().execute().spin_until_interrupt();
948	948	return m_main_ram[0x0fb6bc/4];
949	949	}
950	950
951	951	READ32_MEMBER(skns_state::panicstr_speedup_r)
952	952	{
953		if (space.device().safe_pc()==0x404e68a) device_spin_until_interrupt(&space.device());
	953	if (space.device().safe_pc()==0x404e68a) space.device().execute().spin_until_interrupt();
954	954	return m_main_ram[0x0f19e4/4];
955	955	}
956	956
957	957	READ32_MEMBER(skns_state::sengekis_speedup_r)// 60006ee  600308e
958	958	{
959		if (space.device().safe_pc()==0x60006ec) device_spin_until_interrupt(&space.device());
	959	if (space.device().safe_pc()==0x60006ec) space.device().execute().spin_until_interrupt();
960	960	return m_main_ram[0xb74bc/4];
961	961	}
962	962
963	963	READ32_MEMBER(skns_state::sengekij_speedup_r)// 60006ee  600308e
964	964	{
965		if (space.device().safe_pc()==0x60006ec) device_spin_until_interrupt(&space.device());
	965	if (space.device().safe_pc()==0x60006ec) space.device().execute().spin_until_interrupt();
966	966	return m_main_ram[0xb7380/4];
967	967	}
968	968

trunk/src/mame/drivers/witch.c

r17814	r17815
396	396	break;
397	397
398	398	case 0x08: //A008
399		device_set_input_line(&space.device(),0,CLEAR_LINE);
	399	space.device().execute().set_input_line(0,CLEAR_LINE);
400	400	break;
401	401	}
402	402	}
r17814	r17815
781	781
782	782	static INTERRUPT_GEN( witch_main_interrupt )
783	783	{
784		device_set_input_line(device,0,ASSERT_LINE);
	784	device->execute().set_input_line(0,ASSERT_LINE);
785	785	}
786	786
787	787	static INTERRUPT_GEN( witch_sub_interrupt )
788	788	{
789		device_set_input_line(device,0,ASSERT_LINE);
	789	device->execute().set_input_line(0,ASSERT_LINE);
790	790	}
791	791
792	792	static MACHINE_CONFIG_START( witch, witch_state )

trunk/src/mame/drivers/namcofl.c

r17814	r17815
261	261	// C75 BIOS has a very short window on the CPU sync signal, so immediately let the i960 at it
262	262	if ((offset == 0x6000/2) && (data & 0x80))
263	263	{
264		device_yield(&space.device());
	264	space.device().execute().yield();
265	265	}
266	266	}
267	267
r17814	r17815
548	548	{
549	549	namcofl_state *state = timer.machine().driver_data<namcofl_state>();
550	550
551		device_set_input_line(state->m_mcu, M37710_LINE_IRQ0, HOLD_LINE);
	551	state->m_mcu->set_input_line(M37710_LINE_IRQ0, HOLD_LINE);
552	552	}
553	553
554	554	static TIMER_DEVICE_CALLBACK( mcu_irq2_cb )
555	555	{
556	556	namcofl_state *state = timer.machine().driver_data<namcofl_state>();
557	557
558		device_set_input_line(state->m_mcu, M37710_LINE_IRQ2, HOLD_LINE);
	558	state->m_mcu->set_input_line(M37710_LINE_IRQ2, HOLD_LINE);
559	559	}
560	560
561	561	static TIMER_DEVICE_CALLBACK( mcu_adc_cb )
562	562	{
563	563	namcofl_state *state = timer.machine().driver_data<namcofl_state>();
564	564
565		device_set_input_line(state->m_mcu, M37710_LINE_ADC, HOLD_LINE);
	565	state->m_mcu->set_input_line(M37710_LINE_ADC, HOLD_LINE);
566	566	}
567	567
568	568

trunk/src/mame/drivers/sigmab98.c

r17814	r17815
1690	1690
1691	1691	static INTERRUPT_GEN( gegege_vblank_interrupt )
1692	1692	{
1693		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0x5a);
	1693	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0x5a);
1694	1694	}
1695	1695
1696	1696	static MACHINE_CONFIG_START( gegege, sigmab98_state )
r17814	r17815
1788	1788	int scanline = param;
1789	1789
1790	1790	if(scanline == 240)
1791		device_set_input_line_and_vector(state->m_maincpu,0,HOLD_LINE, state->m_vblank_vector);
	1791	state->m_maincpu->set_input_line_and_vector(0,HOLD_LINE, state->m_vblank_vector);
1792	1792
1793	1793	if(scanline == 128)
1794		device_set_input_line_and_vector(state->m_maincpu,0,HOLD_LINE, state->m_timer0_vector);
	1794	state->m_maincpu->set_input_line_and_vector(0,HOLD_LINE, state->m_timer0_vector);
1795	1795
1796	1796	if(scanline == 32)
1797		device_set_input_line_and_vector(state->m_maincpu,0,HOLD_LINE, state->m_timer1_vector);
	1797	state->m_maincpu->set_input_line_and_vector(0,HOLD_LINE, state->m_timer1_vector);
1798	1798	}
1799	1799
1800	1800	static MACHINE_CONFIG_DERIVED( animalc, sammymdl )

trunk/src/mame/drivers/dynax.c

r17814	r17815
102	102	{
103	103	dynax_state *state = machine.driver_data<dynax_state>();
104	104	int irq = (state->m_sound_irq ? 0x08 : 0) | ((state->m_vblank_irq) ? 0x10 : 0) | ((state->m_blitter_irq) ? 0x20 : 0) ;
105		device_set_input_line_and_vector(state->m_maincpu, 0, irq ? ASSERT_LINE : CLEAR_LINE, 0xc7 | irq); /* rst $xx */
	105	state->m_maincpu->set_input_line_and_vector(0, irq ? ASSERT_LINE : CLEAR_LINE, 0xc7 | irq); /* rst $xx */
106	106	}
107	107
108	108	WRITE8_MEMBER(dynax_state::dynax_vblank_ack_w)
r17814	r17815
141	141	{
142	142	dynax_state *state = machine.driver_data<dynax_state>();
143	143	int irq = ((state->m_blitter_irq) ? 0x08 : 0) | ((state->m_blitter2_irq) ? 0x10 : 0) | ((state->m_vblank_irq) ? 0x20 : 0) ;
144		device_set_input_line_and_vector(state->m_maincpu, 0, irq ? ASSERT_LINE : CLEAR_LINE, 0xc7 | irq); /* rst $xx */
	144	state->m_maincpu->set_input_line_and_vector(0, irq ? ASSERT_LINE : CLEAR_LINE, 0xc7 | irq); /* rst $xx */
145	145	}
146	146
147	147	WRITE8_MEMBER(dynax_state::jantouki_vblank_ack_w)
r17814	r17815
178	178	{
179	179	dynax_state *state = machine.driver_data<dynax_state>();
180	180	int irq = ((state->m_sound_irq) ? 0x08 : 0) | ((state->m_soundlatch_irq) ? 0x10 : 0) | ((state->m_sound_vblank_irq) ? 0x20 : 0) ;
181		device_set_input_line_and_vector(state->m_soundcpu, 0, irq ? ASSERT_LINE : CLEAR_LINE, 0xc7 | irq); /* rst $xx */
	181	state->m_soundcpu->set_input_line_and_vector(0, irq ? ASSERT_LINE : CLEAR_LINE, 0xc7 | irq); /* rst $xx */
182	182	}
183	183
184	184	static INTERRUPT_GEN( jantouki_sound_vblank_interrupt )
r17814	r17815
407	407	if (state->m_toggle)
408	408	{
409	409	if (state->m_resetkludge)   // don't know what's wrong, but NMIs when the 5205 is reset make the game crash
410		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	410	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
411	411	}
412	412	}
413	413
r17814	r17815
421	421	if (state->m_toggle_cpu1)
422	422	{
423	423	if (state->m_resetkludge)   // don't know what's wrong, but NMIs when the 5205 is reset make the game crash
424		device_set_input_line(state->m_soundcpu, INPUT_LINE_NMI, PULSE_LINE);   // cpu1
	424	state->m_soundcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);   // cpu1
425	425	}
426	426	}
427	427
r17814	r17815
4157	4157	{
4158	4158	dynax_state *state = machine.driver_data<dynax_state>();
4159	4159
4160		state->m_maincpu = machine.device("maincpu");
4161		state->m_soundcpu = machine.device("soundcpu");
	4160	state->m_maincpu = machine.device<cpu_device>("maincpu");
	4161	state->m_soundcpu = machine.device<cpu_device>("soundcpu");
4162	4162	state->m_rtc = machine.device("rtc");
4163	4163	state->m_ymsnd = machine.device("ymsnd");
4164	4164
r17814	r17815
4716	4716	{
4717	4717	dynax_state *state = machine.driver_data<dynax_state>();
4718	4718	state->m_blitter_irq = 1;
4719		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0xfa);
	4719	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xfa);
4720	4720	}
4721	4721
4722	4722	static INTERRUPT_GEN( mjelctrn_vblank_interrupt )
r17814	r17815
4726	4726	// This is a kludge to avoid losing blitter interrupts
4727	4727	// there should be a vblank ack mechanism
4728	4728	if (!state->m_blitter_irq)
4729		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0xf8);
	4729	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0xf8);
4730	4730	}
4731	4731
4732	4732	static MACHINE_CONFIG_DERIVED( mjelctrn, hnoridur )
r17814	r17815
4751	4751	{
4752	4752	dynax_state *state = machine.driver_data<dynax_state>();
4753	4753	state->m_blitter_irq = 1;
4754		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0x42);
	4754	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0x42);
4755	4755	}
4756	4756
4757	4757	static TIMER_DEVICE_CALLBACK( neruton_irq_scanline )
r17814	r17815
4764	4764	if (state->m_blitter_irq)   return;
4765	4765
4766	4766	if(scanline == 256)
4767		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0x40);
	4767	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0x40);
4768	4768	else if((scanline % 32) == 0)
4769		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0x46);
	4769	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0x46);
4770	4770	}
4771	4771
4772	4772	static MACHINE_CONFIG_DERIVED( neruton, mjelctrn )
r17814	r17815
4794	4794	if (state->m_blitter_irq)   return;
4795	4795
4796	4796	if(scanline == 256)
4797		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0x40);
	4797	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0x40);
4798	4798	else if((scanline % 32) == 0)
4799		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0x44); // temp kludge
	4799	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0x44); // temp kludge
4800	4800	}
4801	4801
4802	4802	static MACHINE_CONFIG_DERIVED( majxtal7, neruton )
r17814	r17815
4876	4876	int scanline = param;
4877	4877
4878	4878	if(scanline == 256)
4879		device_set_input_line(state->m_maincpu, INPUT_LINE_IRQ0, HOLD_LINE);
	4879	state->m_maincpu->set_input_line(INPUT_LINE_IRQ0, HOLD_LINE);
4880	4880
4881	4881	if(scanline == 0)
4882		device_set_input_line(state->m_maincpu, INPUT_LINE_IRQ1, HOLD_LINE);
	4882	state->m_maincpu->set_input_line(INPUT_LINE_IRQ1, HOLD_LINE);
4883	4883	}
4884	4884
4885	4885	static const ay8910_interface tenkai_ay8910_interface =
r17814	r17815
4900	4900
4901	4901	WRITE_LINE_MEMBER(dynax_state::tenkai_rtc_irq)
4902	4902	{
4903		device_set_input_line(m_maincpu, INPUT_LINE_IRQ2, HOLD_LINE);
	4903	m_maincpu->set_input_line(INPUT_LINE_IRQ2, HOLD_LINE);
4904	4904	}
4905	4905
4906	4906	static MSM6242_INTERFACE( tenkai_rtc_intf )

trunk/src/mame/drivers/volfied.c

r17814	r17815
210	210	static void irqhandler( device_t *device, int irq )
211	211	{
212	212	volfied_state *state = device->machine().driver_data<volfied_state>();
213		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	213	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
214	214	}
215	215
216	216	static const ym2203_interface ym2203_config =
r17814	r17815
237	237
238	238	volfied_cchip_init(machine);
239	239
240		state->m_maincpu = machine.device("maincpu");
241		state->m_audiocpu = machine.device("audiocpu");
	240	state->m_maincpu = machine.device<cpu_device>("maincpu");
	241	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
242	242	state->m_pc090oj = machine.device("pc090oj");
243	243	}
244	244

trunk/src/mame/drivers/dribling.c

r17814	r17815
42	42	{
43	43	dribling_state *state = device->machine().driver_data<dribling_state>();
44	44	if (state->m_di)
45		device_set_input_line(device, 0, ASSERT_LINE);
	45	device->execute().set_input_line(0, ASSERT_LINE);
46	46	}
47	47
48	48
r17814	r17815
88	88	/* bit 7 = di */
89	89	m_di = (data >> 7) & 1;
90	90	if (!m_di)
91		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	91	m_maincpu->set_input_line(0, CLEAR_LINE);
92	92
93	93	/* bit 6 = parata */
94	94

trunk/src/mame/drivers/itech32.c

r17814	r17815
363	363
364	364
365	365
366		#define START_TMS_SPINNING(n)         do { device_spin_until_trigger(&space.device(), 7351 + n); m_tms_spinning[n] = 1; } while (0)
	366	#define START_TMS_SPINNING(n)         do { space.device().execute().spin_until_trigger(7351 + n); m_tms_spinning[n] = 1; } while (0)
367	367	#define STOP_TMS_SPINNING(machine, n)   do { (machine).scheduler().trigger(7351 + n); (machine).driver_data<itech32_state>()->m_tms_spinning[n] = 0; } while (0)
368	368
369	369

trunk/src/mame/drivers/mexico86.c

r17814	r17815
426	426
427	427	state->membank("bank1")->configure_entries(0, 6, &ROM[0x10000], 0x4000);
428	428
429		state->m_maincpu = machine.device("maincpu");
430		state->m_audiocpu = machine.device("audiocpu");
431		state->m_subcpu = machine.device("sub");
	429	state->m_maincpu = machine.device<cpu_device>("maincpu");
	430	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
	431	state->m_subcpu = machine.device<cpu_device>("sub");
432	432	state->m_mcu = machine.device("mcu");
433	433
434	434	state->save_item(NAME(state->m_port_a_in));

trunk/src/mame/drivers/calchase.c

r17814	r17815
807	807	static MACHINE_START(calchase)
808	808	{
809	809	calchase_state *state = machine.driver_data<calchase_state>();
810		device_set_irq_callback(machine.device("maincpu"), irq_callback);
	810	machine.device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
811	811
812	812	state->m_pit8254 = machine.device( "pit8254" );
813	813	state->m_pic8259_1 = machine.device( "pic8259_1" );
r17814	r17815
962	962	{
963	963
964	964	if(space.device().safe_pc()==0x1406f48)
965		device_spin_until_interrupt(m_maincpu);
	965	m_maincpu->spin_until_interrupt();
966	966
967	967	return m_idle_skip_ram;
968	968	}

trunk/src/mame/drivers/ashnojoe.c

r17814	r17815
273	273	static void ym2203_irq_handler( device_t *device, int irq )
274	274	{
275	275	ashnojoe_state *state = device->machine().driver_data<ashnojoe_state>();
276		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	276	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
277	277	}
278	278
279	279	WRITE8_MEMBER(ashnojoe_state::ym2203_write_a)
r17814	r17815
314	314	else
315	315	{
316	316	msm5205_data_w(device, state->m_adpcm_byte & 0xf);
317		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	317	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
318	318	}
319	319
320	320	state->m_msm5205_vclk_toggle ^= 1;
r17814	r17815
331	331	{
332	332	ashnojoe_state *state = machine.driver_data<ashnojoe_state>();
333	333
334		state->m_audiocpu = machine.device("audiocpu");
	334	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
335	335
336	336	state->save_item(NAME(state->m_adpcm_byte));
337	337	state->save_item(NAME(state->m_soundlatch_status));

trunk/src/mame/drivers/popobear.c

r17814	r17815
285	285	for(i=0;i<8;i++)
286	286	{
287	287	if(data & 1 << i)
288		device_set_input_line(m_maincpu, i, CLEAR_LINE);
	288	m_maincpu->set_input_line(i, CLEAR_LINE);
289	289	}
290	290	}
291	291
r17814	r17815
443	443
444	444	/* Order is trusted (5 as vblank-out makes the title screen logo spinning to behave wrongly) */
445	445	if(scanline == 240)
446		device_set_input_line(state->m_maincpu, 3, ASSERT_LINE);
	446	state->m_maincpu->set_input_line(3, ASSERT_LINE);
447	447
448	448	if(scanline == 0)
449		device_set_input_line(state->m_maincpu, 5, ASSERT_LINE);
	449	state->m_maincpu->set_input_line(5, ASSERT_LINE);
450	450
451	451	/* TODO: actually a timer irq, tied with YM2413 sound chip (controls BGM tempo) */
452	452	if(scanline == 64 || scanline == 192)
453		device_set_input_line(state->m_maincpu, 2, ASSERT_LINE);
	453	state->m_maincpu->set_input_line(2, ASSERT_LINE);
454	454	}
455	455
456	456	static MACHINE_CONFIG_START( popobear, popobear_state )

trunk/src/mame/drivers/mouser.c

r17814	r17815
39	39	{
40	40	//logerror("int %02x\n", data);
41	41	m_sound_byte = data;
42		device_set_input_line(m_audiocpu, 0, ASSERT_LINE);
	42	m_audiocpu->set_input_line(0, ASSERT_LINE);
43	43	}
44	44
45	45	READ8_MEMBER(mouser_state::mouser_sound_byte_r)
46	46	{
47	47	//logerror("sound r\n");
48		device_set_input_line(m_audiocpu, 0, CLEAR_LINE);
	48	m_audiocpu->set_input_line(0, CLEAR_LINE);
49	49	return m_sound_byte;
50	50	}
51	51
52	52	WRITE8_MEMBER(mouser_state::mouser_sound_nmi_clear_w)
53	53	{
54		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, CLEAR_LINE);
	54	m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
55	55	}
56	56
57	57	static INTERRUPT_GEN( mouser_sound_nmi_assert )
58	58	{
59	59	mouser_state *state = device->machine().driver_data<mouser_state>();
60	60	if (BIT(state->m_nmi_enable, 0))
61		device_set_input_line(device, INPUT_LINE_NMI, ASSERT_LINE);
	61	device->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
62	62	}
63	63
64	64	static ADDRESS_MAP_START( mouser_map, AS_PROGRAM, 8, mouser_state )
r17814	r17815
187	187	{
188	188	mouser_state *state = machine.driver_data<mouser_state>();
189	189
190		state->m_maincpu = machine.device("maincpu");
191		state->m_audiocpu = machine.device("audiocpu");
	190	state->m_maincpu = machine.device<cpu_device>("maincpu");
	191	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
192	192
193	193	state->save_item(NAME(state->m_sound_byte));
194	194	state->save_item(NAME(state->m_nmi_enable));

trunk/src/mame/drivers/undrfire.c

r17814	r17815
701	701	{
702	702	undrfire_state *state = device->machine().driver_data<undrfire_state>();
703	703	state->m_frame_counter ^= 1;
704		device_set_input_line(device, 4, HOLD_LINE);
	704	device->execute().set_input_line(4, HOLD_LINE);
705	705	}
706	706
707	707	static const tc0100scn_interface undrfire_tc0100scn_intf =

trunk/src/mame/drivers/grchamp.c

r17814	r17815
95	95	grchamp_state *state = device->machine().driver_data<grchamp_state>();
96	96
97	97	if (state->m_cpu0_out[0] & 0x01)
98		device_set_input_line(device, 0, ASSERT_LINE);
	98	device->execute().set_input_line(0, ASSERT_LINE);
99	99	}
100	100
101	101
r17814	r17815
104	104	grchamp_state *state = device->machine().driver_data<grchamp_state>();
105	105
106	106	if (state->m_cpu1_out[4] & 0x01)
107		device_set_input_line(device, 0, ASSERT_LINE);
	107	device->execute().set_input_line(0, ASSERT_LINE);
108	108	}
109	109
110	110

trunk/src/mame/drivers/lkage.c

r17814	r17815
99	99	{
100	100	lkage_state *state = machine.driver_data<lkage_state>();
101	101	if (state->m_sound_nmi_enable)
102		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	102	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
103	103	else
104	104	state->m_pending_nmi = 1;
105	105	}
r17814	r17815
122	122	if (m_pending_nmi)
123	123	{
124	124	/* probably wrong but commands may go lost otherwise */
125		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	125	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
126	126	m_pending_nmi = 0;
127	127	}
128	128	}
r17814	r17815
479	479	static void irqhandler(device_t *device, int irq)
480	480	{
481	481	lkage_state *state = device->machine().driver_data<lkage_state>();
482		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	482	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
483	483	}
484	484
485	485	static const ym2203_interface ym2203_config =
r17814	r17815
496	496	{
497	497	lkage_state *state = machine.driver_data<lkage_state>();
498	498
499		state->m_maincpu = machine.device("maincpu");
500		state->m_audiocpu = machine.device("audiocpu");
	499	state->m_maincpu = machine.device<cpu_device>("maincpu");
	500	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
501	501	state->m_mcu = machine.device("mcu");
502	502
503	503	state->save_item(NAME(state->m_bg_tile_bank));

trunk/src/mame/drivers/goodejan.c

r17814	r17815
331	331
332	332	static INTERRUPT_GEN( goodejan_irq )
333	333	{
334		device_set_input_line_and_vector(device,0,HOLD_LINE,0x208/4);
	334	device->execute().set_input_line_and_vector(0,HOLD_LINE,0x208/4);
335	335	/* vector 0x00c is just a reti */
336	336	}
337	337

trunk/src/mame/drivers/gaiden.c

r17814	r17815
143	143	soundlatch_byte_w(space, 0, data & 0xff);   /* Ninja Gaiden */
144	144	if (ACCESSING_BITS_8_15)
145	145	soundlatch_byte_w(space, 0, data >> 8);   /* Tecmo Knight */
146		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	146	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
147	147	}
148	148
149	149	WRITE16_MEMBER(gaiden_state::drgnbowl_sound_command_w)
r17814	r17815
152	152	if (ACCESSING_BITS_8_15)
153	153	{
154	154	soundlatch_byte_w(space, 0, data >> 8);
155		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	155	m_audiocpu->set_input_line(0, HOLD_LINE);
156	156	}
157	157	}
158	158
r17814	r17815
312	312	static MACHINE_START( raiga )
313	313	{
314	314	gaiden_state *state = machine.driver_data<gaiden_state>();
315		state->m_audiocpu = machine.device("audiocpu");
	315	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
316	316
317	317	state->save_item(NAME(state->m_prot));
318	318	state->save_item(NAME(state->m_jumpcode));
r17814	r17815
748	748	static void irqhandler( device_t *device, int irq )
749	749	{
750	750	gaiden_state *state = device->machine().driver_data<gaiden_state>();
751		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	751	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
752	752	}
753	753
754	754	static const ym2203_interface ym2203_config =

trunk/src/mame/drivers/trackfld.c

r17814	r17815
890	890	trackfld_state *state = device->machine().driver_data<trackfld_state>();
891	891
892	892	if(state->m_irq_mask)
893		device_set_input_line(device, 0, HOLD_LINE);
	893	device->execute().set_input_line(0, HOLD_LINE);
894	894	}
895	895
896	896	static INTERRUPT_GEN( vblank_nmi )
r17814	r17815
898	898	trackfld_state *state = device->machine().driver_data<trackfld_state>();
899	899
900	900	if(state->m_irq_mask)
901		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	901	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
902	902	}
903	903
904	904	//-------------------------------------------------
r17814	r17815
960	960	trackfld_state *state = device->machine().driver_data<trackfld_state>();
961	961
962	962	if (state->m_yieartf_nmi_mask)
963		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	963	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
964	964	}
965	965
966	966	static MACHINE_CONFIG_START( yieartf, trackfld_state )

trunk/src/mame/drivers/aces1.c

r17814	r17815
154	154	{
155	155	aces1_state *state = machine.driver_data<aces1_state>();
156	156	//  printf("irq\n");
157		device_set_input_line(state->m_maincpu, INPUT_LINE_IRQ0, HOLD_LINE);
	157	state->m_maincpu->set_input_line(INPUT_LINE_IRQ0, HOLD_LINE);
158	158	state->aces1_reset_irq_timer();
159	159	}
160	160
r17814	r17815
162	162	{
163	163	aces1_state *state = machine.driver_data<aces1_state>();
164	164	//  printf("nmi\n");
165		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	165	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
166	166	state->aces1_reset_nmi_timer();
167	167	}
168	168

trunk/src/mame/drivers/astrof.c

r17814	r17815
81	81
82	82	READ8_MEMBER(astrof_state::irq_clear_r)
83	83	{
84		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	84	m_maincpu->set_input_line(0, CLEAR_LINE);
85	85
86	86	return 0;
87	87	}
r17814	r17815
90	90	static TIMER_DEVICE_CALLBACK( irq_callback )
91	91	{
92	92	astrof_state *state = timer.machine().driver_data<astrof_state>();
93		device_set_input_line(state->m_maincpu, 0, ASSERT_LINE);
	93	state->m_maincpu->set_input_line(0, ASSERT_LINE);
94	94	}
95	95
96	96
r17814	r17815
105	105	{
106	106
107	107	/* coin insertion causes an NMI */
108		device_set_input_line(m_maincpu, INPUT_LINE_NMI, newval ? ASSERT_LINE : CLEAR_LINE);
	108	m_maincpu->set_input_line(INPUT_LINE_NMI, newval ? ASSERT_LINE : CLEAR_LINE);
109	109	coin_counter_w(machine(), 0, newval);
110	110	}
111	111
r17814	r17815
114	114	{
115	115
116	116	/* service coin insertion causes an NMI */
117		device_set_input_line(m_maincpu, INPUT_LINE_NMI, newval ? ASSERT_LINE : CLEAR_LINE);
	117	m_maincpu->set_input_line(INPUT_LINE_NMI, newval ? ASSERT_LINE : CLEAR_LINE);
118	118	}
119	119
120	120
r17814	r17815
490	490	/* the 74175 outputs all HI's if not otherwise set */
491	491	astrof_set_video_control_2(machine, 0xff);
492	492
493		state->m_maincpu = machine.device("maincpu");
	493	state->m_maincpu = machine.device<cpu_device>("maincpu");
494	494	state->m_samples = machine.device<samples_device>("samples");
495	495
496	496	/* register for state saving */
r17814	r17815
524	524	/* the 74175 outputs all HI's if not otherwise set */
525	525	spfghmk2_set_video_control_2(machine, 0xff);
526	526
527		state->m_maincpu = machine.device("maincpu");
	527	state->m_maincpu = machine.device<cpu_device>("maincpu");
528	528
529	529	/* the red background circuit is disabled */
530	530	state->m_red_on = FALSE;
r17814	r17815
543	543	/* the 74175 outputs all HI's if not otherwise set */
544	544	tomahawk_set_video_control_2(machine, 0xff);
545	545
546		state->m_maincpu = machine.device("maincpu");
	546	state->m_maincpu = machine.device<cpu_device>("maincpu");
547	547	state->m_sn = machine.device("snsnd");
548	548
549	549	/* register for state saving */

trunk/src/mame/drivers/vegas.c

r17814	r17815
1452	1452
1453	1453	static WRITE32_HANDLER( vegas_watchdog_w )
1454	1454	{
1455		device_eat_cycles(&space->device(), 100);
	1455	space->device().execute().eat_cycles(100);
1456	1456	}
1457	1457
1458	1458

trunk/src/mame/drivers/magictg.c

r17814	r17815
804	804	m_adsp_regs.bdma_control |= ((src_addr >> 14) & 0xff) << 8;
805	805
806	806	if (m_adsp_regs.bdma_control & 8)
807		device_set_input_line(m_adsp, INPUT_LINE_RESET, PULSE_LINE);
	807	m_adsp->set_input_line(INPUT_LINE_RESET, PULSE_LINE);
808	808	}
809	809	break;
810	810	}

trunk/src/mame/drivers/finalizr.c

r17814	r17815
50	50
51	51	WRITE8_MEMBER(finalizr_state::finalizr_i8039_irq_w)
52	52	{
53		device_set_input_line(m_audio_cpu, 0, ASSERT_LINE);
	53	m_audio_cpu->execute().set_input_line(0, ASSERT_LINE);
54	54	}
55	55
56	56	WRITE8_MEMBER(finalizr_state::i8039_irqen_w)
r17814	r17815
62	62	*/
63	63
64	64	if ((data & 0x80) == 0)
65		device_set_input_line(m_audio_cpu, 0, CLEAR_LINE);
	65	m_audio_cpu->execute().set_input_line(0, CLEAR_LINE);
66	66	}
67	67
68	68	READ8_MEMBER(finalizr_state::i8039_T1_r)

trunk/src/mame/drivers/xtom3d.c

r17814	r17815
574	574
575	575	WRITE_LINE_MEMBER(xtom3d_state::xtom3d_pic8259_1_set_int_line)
576	576	{
577		device_set_input_line(m_maincpu, 0, state ? HOLD_LINE : CLEAR_LINE);
	577	m_maincpu->set_input_line(0, state ? HOLD_LINE : CLEAR_LINE);
578	578	}
579	579
580	580	READ8_MEMBER( xtom3d_state::get_slave_ack )
r17814	r17815
604	604	{
605	605	xtom3d_state *state = machine.driver_data<xtom3d_state>();
606	606
607		device_set_input_line(state->m_maincpu, INPUT_LINE_A20, a20);
	607	state->m_maincpu->set_input_line(INPUT_LINE_A20, a20);
608	608	}
609	609
610	610	static void keyboard_interrupt(running_machine &machine, int state)
r17814	r17815
658	658
659	659	init_pc_common(machine, PCCOMMON_KEYBOARD_AT, xtom3d_set_keyb_int);
660	660
661		device_set_irq_callback(state->m_maincpu, irq_callback);
	661	state->m_maincpu->set_irq_acknowledge_callback(irq_callback);
662	662	intel82439tx_init(machine);
663	663
664	664	kbdc8042_init(machine, &at8042);

trunk/src/mame/drivers/enigma2.c

r17814	r17815
77	77	emu_timer *m_interrupt_assert_timer;
78	78
79	79	/* devices */
80		device_t *m_maincpu;
81		device_t *m_audiocpu;
	80	cpu_device *m_maincpu;
	81	cpu_device *m_audiocpu;
82	82	DECLARE_READ8_MEMBER(dip_switch_r);
83	83	DECLARE_WRITE8_MEMBER(sound_data_w);
84	84	DECLARE_WRITE8_MEMBER(enigma2_flip_screen_w);
r17814	r17815
112	112	static TIMER_CALLBACK( interrupt_clear_callback )
113	113	{
114	114	enigma2_state *state = machine.driver_data<enigma2_state>();
115		device_set_input_line(state->m_maincpu, 0, CLEAR_LINE);
	115	state->m_maincpu->set_input_line(0, CLEAR_LINE);
116	116	}
117	117
118	118
r17814	r17815
126	126	int vpos = machine.primary_screen->vpos();
127	127	UINT16 counter = vpos_to_vysnc_chain_counter(vpos);
128	128	UINT8 vector = 0xc7 | ((counter & 0x80) >> 3) | ((~counter & 0x80) >> 4);
129		device_set_input_line_and_vector(state->m_maincpu, 0, ASSERT_LINE, vector);
	129	state->m_maincpu->set_input_line_and_vector(0, ASSERT_LINE, vector);
130	130
131	131	/* set up for next interrupt */
132	132	if (counter == INT_TRIGGER_COUNT_1)
r17814	r17815
162	162	enigma2_state *state = machine.driver_data<enigma2_state>();
163	163	create_interrupt_timers(machine);
164	164
165		state->m_maincpu = machine.device("maincpu");
166		state->m_audiocpu = machine.device("audiocpu");
	165	state->m_maincpu = machine.device<cpu_device>("maincpu");
	166	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
167	167
168	168	state->save_item(NAME(state->m_blink_count));
169	169	state->save_item(NAME(state->m_sound_latch));
r17814	r17815
393	393	if (!(data & 0x04) && (m_last_sound_data & 0x04))
394	394	m_sound_latch = (m_sound_latch << 1) | (~data & 0x01);
395	395
396		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, (data & 0x02) ? ASSERT_LINE : CLEAR_LINE);
	396	m_audiocpu->set_input_line(INPUT_LINE_NMI, (data & 0x02) ? ASSERT_LINE : CLEAR_LINE);
397	397
398	398	m_last_sound_data = data;
399	399	}

trunk/src/mame/drivers/igspoker.c

r17814	r17815
137	137	return;
138	138
139	139	if((scanline % 64) == 32)
140		device_set_input_line(state->m_maincpu, 0, ASSERT_LINE);
	140	state->m_maincpu->set_input_line(0, ASSERT_LINE);
141	141
142	142	if((scanline % 64) == 0 && state->m_nmi_enable)
143		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	143	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
144	144	}
145	145
146	146
147	147	READ8_MEMBER(igspoker_state::igs_irqack_r)
148	148	{
149		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	149	m_maincpu->set_input_line(0, CLEAR_LINE);
150	150	return 0;
151	151	}
152	152

trunk/src/mame/drivers/gticlub.c

r17814	r17815
695	695	*/
696	696	static INTERRUPT_GEN( gticlub_vblank )
697	697	{
698		device_set_input_line(device, INPUT_LINE_IRQ0, ASSERT_LINE);
	698	device->execute().set_input_line(INPUT_LINE_IRQ0, ASSERT_LINE);
699	699	}
700	700
701	701

trunk/src/mame/drivers/namcona1.c

r17814	r17815
968	968	{
969	969	simulate_mcu( timer.machine() );
970	970	if (enabled & 8)
971		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	971	state->m_maincpu->set_input_line(4, HOLD_LINE);
972	972	}
973	973
974	974	// posirq, used with dolphin in Emeraldia's "how to play" attract mode
r17814	r17815
978	978	if (posirq_scanline)
979	979	timer.machine().primary_screen->update_partial(posirq_scanline);
980	980
981		device_set_input_line(state->m_maincpu, 3, HOLD_LINE);
	981	state->m_maincpu->set_input_line(3, HOLD_LINE);
982	982	}
983	983	}
984	984
r17814	r17815
993	993
994	994	// vblank
995	995	if (scanline == 224)
996		device_set_input_line(state->m_mcu, M37710_LINE_IRQ1, HOLD_LINE);
	996	state->m_mcu->set_input_line(M37710_LINE_IRQ1, HOLD_LINE);
997	997
998	998	// adc (timing guessed, when does this trigger?)
999	999	if (scanline == 0)
1000		device_set_input_line(state->m_mcu, M37710_LINE_ADC, HOLD_LINE);
	1000	state->m_mcu->set_input_line(M37710_LINE_ADC, HOLD_LINE);
1001	1001	}
1002	1002
1003	1003	static const c140_interface C140_interface_typeA =

trunk/src/mame/drivers/mazerbla.c

r17814	r17815
98	98	UINT8 m_soundlatch;
99	99
100	100	/* devices */
101		device_t *m_maincpu;
102		device_t *m_subcpu;
	101	cpu_device *m_maincpu;
	102	cpu_device *m_subcpu;
103	103
104	104	#if 0
105	105	int m_dbg_info;
r17814	r17815
763	763
764	764	m_zpu_int_vector &= ~2;   /* clear D1 on INTA (interrupt acknowledge) */
765	765
766		device_set_input_line(m_maincpu, 0, ASSERT_LINE);   /* main cpu interrupt (comes from CFB (generated at the start of INT routine on CFB) - vblank?) */
	766	m_maincpu->set_input_line(0, ASSERT_LINE);   /* main cpu interrupt (comes from CFB (generated at the start of INT routine on CFB) - vblank?) */
767	767	}
768	768
769	769	READ8_MEMBER(mazerbla_state::cfb_zpu_int_req_clr)
r17814	r17815
773	773
774	774	/* clear the INT line when there are no more interrupt requests */
775	775	if (m_zpu_int_vector == 0xff)
776		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	776	m_maincpu->set_input_line(0, CLEAR_LINE);
777	777
778	778	return 0;
779	779	}
r17814	r17815
958	958	state->m_soundlatch = param;
959	959
960	960	/* cause NMI on sound CPU */
961		device_set_input_line(state->m_subcpu, INPUT_LINE_NMI, ASSERT_LINE);
	961	state->m_subcpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
962	962	}
963	963
964	964	WRITE8_MEMBER(mazerbla_state::main_sound_w)
r17814	r17815
968	968
969	969	WRITE8_MEMBER(mazerbla_state::sound_int_clear_w)
970	970	{
971		device_set_input_line(m_subcpu, 0, CLEAR_LINE);
	971	m_subcpu->set_input_line(0, CLEAR_LINE);
972	972	}
973	973
974	974	WRITE8_MEMBER(mazerbla_state::sound_nmi_clear_w)
975	975	{
976		device_set_input_line(m_subcpu, INPUT_LINE_NMI, CLEAR_LINE);
	976	m_subcpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
977	977	}
978	978
979	979
r17814	r17815
1421	1421	/* frequency is 14.318 MHz/16/16/16/16 */
1422	1422	static INTERRUPT_GEN( sound_interrupt )
1423	1423	{
1424		device_set_input_line(device, 0, ASSERT_LINE);
	1424	device->execute().set_input_line(0, ASSERT_LINE);
1425	1425	}
1426	1426
1427	1427
r17814	r17815
1435	1435	{
1436	1436	mazerbla_state *state = machine.driver_data<mazerbla_state>();
1437	1437
1438		state->m_maincpu = machine.device("maincpu");
1439		state->m_subcpu = machine.device("sub");
	1438	state->m_maincpu = machine.device<cpu_device>("maincpu");
	1439	state->m_subcpu = machine.device<cpu_device>("sub");
1440	1440
1441	1441	state->save_item(NAME(state->m_vcu_video_reg));
1442	1442	state->save_item(NAME(state->m_vcu_gfx_addr));
r17814	r17815
1502	1502
1503	1503	memset(state->m_lookup_ram, 0, ARRAY_LENGTH(state->m_lookup_ram));
1504	1504
1505		device_set_irq_callback(machine.device("maincpu"), irq_callback);
	1505	machine.device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
1506	1506	}
1507	1507
1508	1508

trunk/src/mame/drivers/pcat_dyn.c

r17814	r17815
133	133	static MACHINE_START( pcat_dyn )
134	134	{
135	135
136		device_set_irq_callback(machine.device("maincpu"), pcat_irq_callback);
	136	machine.device("maincpu")->execute().set_irq_acknowledge_callback(pcat_irq_callback);
137	137	init_pc_common(machine, PCCOMMON_KEYBOARD_AT, pcat_dyn_set_keyb_int);
138	138	kbdc8042_init(machine, &at8042);
139	139	}

trunk/src/mame/drivers/acefruit.c

r17814	r17815
84	84	static INTERRUPT_GEN( acefruit_vblank )
85	85	{
86	86	acefruit_state *state = device->machine().driver_data<acefruit_state>();
87		device_set_input_line(device, 0, HOLD_LINE );
	87	device->execute().set_input_line(0, HOLD_LINE );
88	88	state->m_refresh_timer->adjust( attotime::zero );
89	89	}
90	90

trunk/src/mame/drivers/dkong.c

r17814	r17815
391	391
392	392	static INTERRUPT_GEN( s2650_interrupt )
393	393	{
394		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0x03);
	394	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0x03);
395	395	}
396	396
397	397	/*************************************
r17814	r17815
711	711
712	712	if (data & 1)
713	713	{
714		device_set_input_line(m_dev_n2a03a, INPUT_LINE_RESET, CLEAR_LINE);
715		device_set_input_line(m_dev_n2a03b, INPUT_LINE_RESET, CLEAR_LINE);
	714	m_dev_n2a03a->execute().set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
	715	m_dev_n2a03b->execute().set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
716	716	}
717	717	else
718	718	{
719		device_set_input_line(m_dev_n2a03a, INPUT_LINE_RESET, ASSERT_LINE);
720		device_set_input_line(m_dev_n2a03b, INPUT_LINE_RESET, ASSERT_LINE);
	719	m_dev_n2a03a->execute().set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
	720	m_dev_n2a03b->execute().set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
721	721	}
722	722	}
723	723
r17814	r17815
1650	1650	dkong_state *state = device->machine().driver_data<dkong_state>();
1651	1651
1652	1652	if(state->m_nmi_mask)
1653		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	1653	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
1654	1654	}
1655	1655
1656	1656	static MACHINE_CONFIG_START( dkong_base, dkong_state )

trunk/src/mame/drivers/appoooh.c

r17814	r17815
436	436	appoooh_state *state = device->machine().driver_data<appoooh_state>();
437	437
438	438	if(state->m_nmi_mask)
439		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	439	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
440	440	}
441	441
442	442	static MACHINE_CONFIG_START( appoooh_common, appoooh_state )

trunk/src/mame/drivers/metlclsh.c

r17814	r17815
46	46
47	47	WRITE8_MEMBER(metlclsh_state::metlclsh_cause_irq)
48	48	{
49		device_set_input_line(m_subcpu, M6809_IRQ_LINE, ASSERT_LINE);
	49	m_subcpu->set_input_line(M6809_IRQ_LINE, ASSERT_LINE);
50	50	}
51	51
52	52	WRITE8_MEMBER(metlclsh_state::metlclsh_ack_nmi)
53	53	{
54		device_set_input_line(m_maincpu, INPUT_LINE_NMI, CLEAR_LINE);
	54	m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
55	55	}
56	56
57	57	static ADDRESS_MAP_START( metlclsh_master_map, AS_PROGRAM, 8, metlclsh_state )
r17814	r17815
83	83
84	84	WRITE8_MEMBER(metlclsh_state::metlclsh_cause_nmi2)
85	85	{
86		device_set_input_line(m_maincpu, INPUT_LINE_NMI, ASSERT_LINE);
	86	m_maincpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
87	87	}
88	88
89	89	WRITE8_MEMBER(metlclsh_state::metlclsh_ack_irq2)
90	90	{
91		device_set_input_line(m_subcpu, M6809_IRQ_LINE, CLEAR_LINE);
	91	m_subcpu->set_input_line(M6809_IRQ_LINE, CLEAR_LINE);
92	92	}
93	93
94	94	WRITE8_MEMBER(metlclsh_state::metlclsh_ack_nmi2)
95	95	{
96		device_set_input_line(m_subcpu, INPUT_LINE_NMI, CLEAR_LINE);
	96	m_subcpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
97	97	}
98	98
99	99	WRITE8_MEMBER(metlclsh_state::metlclsh_flipscreen_w)
r17814	r17815
264	264	{
265	265	metlclsh_state *state = machine.driver_data<metlclsh_state>();
266	266
267		state->m_maincpu = machine.device("maincpu");
268		state->m_subcpu = machine.device("sub");
	267	state->m_maincpu = machine.device<cpu_device>("maincpu");
	268	state->m_subcpu = machine.device<cpu_device>("sub");
269	269
270	270	state->save_item(NAME(state->m_write_mask));
271	271	state->save_item(NAME(state->m_gfxbank));

trunk/src/mame/drivers/dbz.c

r17814	r17815
102	102
103	103	WRITE16_MEMBER(dbz_state::dbz_sound_cause_nmi)
104	104	{
105		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	105	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
106	106	}
107	107
108	108	static void dbz_sound_irq( device_t *device, int irq )
109	109	{
110	110	dbz_state *state = device->machine().driver_data<dbz_state>();
111	111
112		device_set_input_line(state->m_audiocpu, 0, (irq) ? ASSERT_LINE : CLEAR_LINE);
	112	state->m_audiocpu->set_input_line(0, (irq) ? ASSERT_LINE : CLEAR_LINE);
113	113	}
114	114
115	115	static ADDRESS_MAP_START( dbz_map, AS_PROGRAM, 16, dbz_state )
r17814	r17815
351	351	{
352	352	dbz_state *state = machine.driver_data<dbz_state>();
353	353
354		state->m_maincpu = machine.device("maincpu");
355		state->m_audiocpu = machine.device("audiocpu");
	354	state->m_maincpu = machine.device<cpu_device>("maincpu");
	355	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
356	356	state->m_k053936_1 = machine.device("k053936_1");
357	357	state->m_k053936_2 = machine.device("k053936_2");
358	358	state->m_k056832 = machine.device("k056832");

trunk/src/mame/drivers/goldstar.c

r17814	r17815
6251	6251	goldstar_state *state = device->machine().driver_data<goldstar_state>();
6252	6252
6253	6253	if(state->m_lucky8_nmi_enable)
6254		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	6254	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
6255	6255	}
6256	6256
6257	6257	static MACHINE_CONFIG_START( lucky8, goldstar_state )

trunk/src/mame/drivers/skylncr.c

r17814	r17815
698	698	static INTERRUPT_GEN( skylncr_vblank_interrupt )
699	699	{
700	700	skylncr_state *state = device->machine().driver_data<skylncr_state>();
701		if (state->m_nmi_enable) device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	701	if (state->m_nmi_enable) device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
702	702	}
703	703
704	704

trunk/src/mame/drivers/20pacgal.c

r17814	r17815
113	113	m_irq_mask = data & 1;
114	114
115	115	if (!m_irq_mask)
116		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	116	m_maincpu->set_input_line(0, CLEAR_LINE);
117	117	}
118	118
119	119	WRITE8_MEMBER(_20pacgal_state::timer_pulse_w)
r17814	r17815
345	345	{
346	346	_20pacgal_state *state = machine.driver_data<_20pacgal_state>();
347	347
348		state->m_maincpu = machine.device("maincpu");
	348	state->m_maincpu = machine.device<cpu_device>("maincpu");
349	349	state->m_eeprom = machine.device("eeprom");
350	350
351	351	state->save_item(NAME(state->m_game_selected));
r17814	r17815
367	367	_20pacgal_state *state = device->machine().driver_data<_20pacgal_state>();
368	368
369	369	if(state->m_irq_mask)
370		device_set_input_line(device, 0, HOLD_LINE); // TODO: assert breaks the inputs in 25pacman test mode
	370	device->execute().set_input_line(0, HOLD_LINE); // TODO: assert breaks the inputs in 25pacman test mode
371	371	}
372	372
373	373	static MACHINE_CONFIG_START( 20pacgal, _20pacgal_state )

trunk/src/mame/drivers/seicross.c

r17814	r17815
393	393	seicross_state *state = device->machine().driver_data<seicross_state>();
394	394
395	395	if(state->m_irq_mask)
396		device_set_input_line(device, 0, HOLD_LINE);
	396	device->execute().set_input_line(0, HOLD_LINE);
397	397
398	398	}
399	399

trunk/src/mame/drivers/system16.c

r17814	r17815
102	102
103	103	static INTERRUPT_GEN( sys16_interrupt )
104	104	{
105		device_set_input_line(device, 4, HOLD_LINE); /* Interrupt vector 4, used by VBlank */
	105	device->execute().set_input_line(4, HOLD_LINE); /* Interrupt vector 4, used by VBlank */
106	106	}
107	107
108	108
r17814	r17815
114	114	if (ACCESSING_BITS_0_7)
115	115	{
116	116	soundlatch_byte_w(space, 0, data & 0xff);
117		device_set_input_line(m_soundcpu, INPUT_LINE_NMI, PULSE_LINE);
	117	m_soundcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
118	118	}
119	119	}
120	120
r17814	r17815
152	152	if (ACCESSING_BITS_0_7)
153	153	{
154	154	soundlatch_byte_w(space, 0, data & 0xff);
155		device_set_input_line(m_soundcpu, 0, HOLD_LINE);
	155	m_soundcpu->set_input_line(0, HOLD_LINE);
156	156	}
157	157	}
158	158
r17814	r17815
369	369	state->m_sample_buffer <<=  4;
370	370	state->m_sample_select ^=  1;
371	371	if(state->m_sample_select == 0)
372		device_set_input_line(state->m_soundcpu, INPUT_LINE_NMI, PULSE_LINE);
	372	state->m_soundcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
373	373	}
374	374
375	375	static const msm5205_interface tturfbl_msm5205_interface  =
r17814	r17815
1109	1109	if (ACCESSING_BITS_0_7)
1110	1110	{
1111	1111	soundlatch_byte_w(space, 0, data & 0xff);
1112		device_set_input_line(m_soundcpu, 0, HOLD_LINE);
	1112	m_soundcpu->set_input_line(0, HOLD_LINE);
1113	1113	}
1114	1114	}
1115	1115
r17814	r17815
1185	1185	state->m_sample_buffer >>=  4;
1186	1186	state->m_sample_select ^=  1;
1187	1187	if (state->m_sample_select == 0)
1188		device_set_input_line(state->m_soundcpu, INPUT_LINE_NMI, PULSE_LINE);
	1188	state->m_soundcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
1189	1189	}
1190	1190
1191	1191	static const msm5205_interface shdancbl_msm5205_interface  =
r17814	r17815
2048	2048	segas1x_bootleg_state *state = device->machine().driver_data<segas1x_bootleg_state>();
2049	2049
2050	2050	/* upd7759 callback */
2051		device_set_input_line(state->m_soundcpu, INPUT_LINE_NMI, PULSE_LINE);
	2051	state->m_soundcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
2052	2052	}
2053	2053
2054	2054
r17814	r17815
3255	3255
3256	3256	m_beautyb_unkx = 0;
3257	3257
3258		m_maincpu = machine().device("maincpu");
3259		m_soundcpu = machine().device("soundcpu");
	3258	m_maincpu = machine().device<cpu_device>("maincpu");
	3259	m_soundcpu = machine().device<cpu_device>("soundcpu");
3260	3260	}
3261	3261
3262	3262	/* Sys16A */

trunk/src/mame/drivers/nyny.c

r17814	r17815
107	107	UINT16   m_star_shift_reg;
108	108
109	109	/* devices */
110		device_t *m_maincpu;
111		device_t *m_audiocpu;
	110	cpu_device *m_maincpu;
	111	cpu_device *m_audiocpu;
112	112	device_t *m_audiocpu2;
113	113	device_t *m_ic48_1;
114	114	mc6845_device *m_mc6845;
r17814	r17815
150	150	{
151	151	int combined_state = m_pia1->irq_a_state() | m_pia1->irq_b_state() | m_pia2->irq_b_state();
152	152
153		device_set_input_line(m_maincpu, M6809_IRQ_LINE, combined_state ? ASSERT_LINE : CLEAR_LINE);
	153	m_maincpu->set_input_line(M6809_IRQ_LINE, combined_state ? ASSERT_LINE : CLEAR_LINE);
154	154	}
155	155
156	156
157	157	WRITE_LINE_MEMBER(nyny_state::main_cpu_firq)
158	158	{
159		device_set_input_line(m_maincpu, M6809_FIRQ_LINE, state ? ASSERT_LINE : CLEAR_LINE);
	159	m_maincpu->set_input_line(M6809_FIRQ_LINE, state ? ASSERT_LINE : CLEAR_LINE);
160	160	}
161	161
162	162
r17814	r17815
226	226	m_star_enable = data & 0x10;
227	227
228	228	/* bits 5-7 go to the music board connector */
229		audio_2_command_w(*m_maincpu->memory().space(AS_PROGRAM), 0, data & 0xe0);
	229	audio_2_command_w(*m_maincpu->space(AS_PROGRAM), 0, data & 0xe0);
230	230	}
231	231
232	232
r17814	r17815
448	448	{
449	449
450	450	soundlatch_byte_w(space, 0, data);
451		device_set_input_line(m_audiocpu, M6800_IRQ_LINE, HOLD_LINE);
	451	m_audiocpu->set_input_line(M6800_IRQ_LINE, HOLD_LINE);
452	452	}
453	453
454	454
r17814	r17815
456	456	{
457	457
458	458	soundlatch3_byte_w(space, 0, data);
459		device_set_input_line(m_maincpu, M6809_IRQ_LINE, HOLD_LINE);
	459	m_maincpu->set_input_line(M6809_IRQ_LINE, HOLD_LINE);
460	460	}
461	461
462	462
r17814	r17815
501	501	{
502	502
503	503	soundlatch2_byte_w(space, 0, (data & 0x60) >> 5);
504		device_set_input_line(m_audiocpu2, M6800_IRQ_LINE, BIT(data, 7) ? CLEAR_LINE : ASSERT_LINE);
	504	m_audiocpu2->execute().set_input_line(M6800_IRQ_LINE, BIT(data, 7) ? CLEAR_LINE : ASSERT_LINE);
505	505	}
506	506
507	507
r17814	r17815
677	677	{
678	678	nyny_state *state = machine.driver_data<nyny_state>();
679	679
680		state->m_maincpu = machine.device("maincpu");
681		state->m_audiocpu = machine.device("audiocpu");
	680	state->m_maincpu = machine.device<cpu_device>("maincpu");
	681	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
682	682	state->m_audiocpu2 = machine.device("audio2");
683	683	state->m_ic48_1 = machine.device("ic48_1");
684	684	state->m_mc6845 = machine.device<mc6845_device>("crtc");

trunk/src/mame/drivers/pengo.c

r17814	r17815
374	374	pengo_state *state = device->machine().driver_data<pengo_state>();
375	375
376	376	if(state->m_irq_mask)
377		device_set_input_line(device, 0, HOLD_LINE);
	377	device->execute().set_input_line(0, HOLD_LINE);
378	378	}
379	379
380	380

trunk/src/mame/drivers/whitestar.c

r17814	r17815
110	110	READ8_MEMBER(whitestar_state::dmd_latch_r)
111	111	{
112	112	m_dmd_busy = 0;
113		device_set_input_line(m_dmdcpu, M6809_IRQ_LINE, CLEAR_LINE);
	113	m_dmdcpu->set_input_line(M6809_IRQ_LINE, CLEAR_LINE);
114	114	return m_dmd_latch;
115	115	}
116	116
r17814	r17815
118	118	{
119	119	m_dmd_latch = data;
120	120	m_dmd_busy = 1;
121		device_set_input_line(m_dmdcpu, M6809_IRQ_LINE, CLEAR_LINE);
122		device_set_input_line(m_dmdcpu, M6809_IRQ_LINE, ASSERT_LINE);
	121	m_dmdcpu->set_input_line(M6809_IRQ_LINE, CLEAR_LINE);
	122	m_dmdcpu->set_input_line(M6809_IRQ_LINE, ASSERT_LINE);
123	123	}
124	124
125	125	READ8_MEMBER(whitestar_state::dmd_ctrl_r)
r17814	r17815
130	130	WRITE8_MEMBER(whitestar_state::dmd_ctrl_w)
131	131	{
132	132	m_dmd_ctrl = data;
133		device_set_input_line(m_dmdcpu, M6809_IRQ_LINE, CLEAR_LINE);
	133	m_dmdcpu->set_input_line(M6809_IRQ_LINE, CLEAR_LINE);
134	134	if (data!=0) {
135	135	bank_w(space,0,0);
136	136	m_dmdcpu->reset();
r17814	r17815
182	182	// the appropriate device is passed in, so we can share this routine
183	183	static INTERRUPT_GEN( whitestar_firq_interrupt )
184	184	{
185		device_set_input_line(device, M6809_FIRQ_LINE, HOLD_LINE);
	185	device->execute().set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
186	186	}
187	187
188	188	#define DMD_CHUNK_SIZE 10

trunk/src/mame/drivers/simpsons.c

r17814	r17815
115	115	static void sound_nmi_callback( running_machine &machine, int param )
116	116	{
117	117	simpsons_state *state = machine.driver_data<simpsons_state>();
118		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, (state->m_nmi_enabled) ? CLEAR_LINE : ASSERT_LINE );
	118	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, (state->m_nmi_enabled) ? CLEAR_LINE : ASSERT_LINE );
119	119	state->m_nmi_enabled = 0;
120	120	}
121	121	#endif
r17814	r17815
123	123	static TIMER_CALLBACK( nmi_callback )
124	124	{
125	125	simpsons_state *state = machine.driver_data<simpsons_state>();
126		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, ASSERT_LINE);
	126	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
127	127	}
128	128
129	129	WRITE8_MEMBER(simpsons_state::z80_arm_nmi_w)
130	130	{
131		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, CLEAR_LINE);
	131	m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
132	132	machine().scheduler().timer_set(attotime::from_usec(25), FUNC(nmi_callback));   /* kludge until the K053260 is emulated correctly */
133	133	}
134	134
r17814	r17815
256	256	{
257	257	simpsons_state *state = machine.driver_data<simpsons_state>();
258	258	if (state->m_firq_enabled)
259		device_set_input_line(state->m_maincpu, KONAMI_FIRQ_LINE, HOLD_LINE);
	259	state->m_maincpu->set_input_line(KONAMI_FIRQ_LINE, HOLD_LINE);
260	260	}
261	261
262	262
r17814	r17815
272	272	}
273	273
274	274	if (k052109_is_irq_enabled(state->m_k052109))
275		device_set_input_line(device, KONAMI_IRQ_LINE, HOLD_LINE);
	275	device->execute().set_input_line(KONAMI_IRQ_LINE, HOLD_LINE);
276	276	}
277	277
278	278	static const k052109_interface simpsons_k052109_intf =

trunk/src/mame/drivers/byvid.c

r17814	r17815
84	84	INPUT_CHANGED_MEMBER(by133_state::video_test)
85	85	{
86	86	if(newval)
87		device_set_input_line(m_videocpu, INPUT_LINE_NMI, PULSE_LINE);
	87	m_videocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
88	88	}
89	89
90	90	INPUT_CHANGED_MEMBER(by133_state::sound_test)
91	91	{
92	92	if(newval)
93		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	93	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
94	94	}
95	95
96	96	static INPUT_PORTS_START( by133 )
r17814	r17815
115	115
116	116	WRITE_LINE_MEMBER(by133_state::by133_firq)
117	117	{
118		device_set_input_line(m_videocpu, M6809_FIRQ_LINE, (m_videopia->irq_a_state() || m_videopia->irq_b_state()) ? ASSERT_LINE : CLEAR_LINE);
	118	m_videocpu->set_input_line(M6809_FIRQ_LINE, (m_videopia->irq_a_state() || m_videopia->irq_b_state()) ? ASSERT_LINE : CLEAR_LINE);
119	119	}
120	120
121	121	WRITE_LINE_MEMBER(by133_state::by133_cb2)
122	122	{
123	123	// to M6803 port 2 d0?
124		//  device_set_input_line(m_audiocpu, M6801_TIN_LINE, state ? ASSERT_LINE : CLEAR_LINE);
	124	//  m_audiocpu->set_input_line(M6801_TIN_LINE, state ? ASSERT_LINE : CLEAR_LINE);
125	125	}
126	126
127	127	READ8_MEMBER(by133_state::by133_portb_r)

trunk/src/mame/drivers/model1.c

r17814	r17815
722	722	static void irq_init(running_machine &machine)
723	723	{
724	724	machine.device("maincpu")->execute().set_input_line(0, CLEAR_LINE);
725		device_set_irq_callback(machine.device("maincpu"), irq_callback);
	725	machine.device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
726	726	}
727	727
728	728	static TIMER_DEVICE_CALLBACK( model1_interrupt )
r17814	r17815
854	854
855	855	if ((sr & 0x0700) > 0x0100)
856	856	{
857		device_spin_until_time(&space.device(), attotime::from_usec(40));
	857	space.device().execute().spin_until_time(attotime::from_usec(40));
858	858	return 0;   // not ready yet, interrupts disabled
859	859	}
860	860
r17814	r17815
875	875	// signal the 68000 that there's data waiting
876	876	machine().device("audiocpu")->execute().set_input_line(2, HOLD_LINE);
877	877	// give the 68k time to reply
878		device_spin_until_time(&space.device(), attotime::from_usec(40));
	878	space.device().execute().spin_until_time(attotime::from_usec(40));
879	879	}
880	880
881	881	static ADDRESS_MAP_START( model1_mem, AS_PROGRAM, 16, model1_state )

trunk/src/mame/drivers/polepos.c

r17814	r17815
336	336
337	337	m_sub_irq_mask = data;
338	338	if (!data)
339		device_set_input_line(&space.device(), 0, CLEAR_LINE);
	339	space.device().execute().set_input_line(0, CLEAR_LINE);
340	340	}
341	341
342	342
r17814	r17815
472	472	state->polepos_latch_w(*space, i, 0);
473	473
474	474	/* set the interrupt vectors (this shouldn't be needed) */
475		device_set_input_line_vector(machine.device("sub"), 0, Z8000_NVI);
476		device_set_input_line_vector(machine.device("sub2"), 0, Z8000_NVI);
	475	machine.device("sub")->execute().set_input_line_vector(0, Z8000_NVI);
	476	machine.device("sub2")->execute().set_input_line_vector(0, Z8000_NVI);
477	477	}
478	478
479	479

trunk/src/mame/drivers/actfancr.c

r17814	r17815
56	56	WRITE8_MEMBER(actfancr_state::actfancr_sound_w)
57	57	{
58	58	soundlatch_byte_w(space, 0, data & 0xff);
59		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	59	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
60	60	}
61	61
62	62	/******************************************************************************/
r17814	r17815
279	279	static void sound_irq(device_t *device, int linestate)
280	280	{
281	281	actfancr_state *state = device->machine().driver_data<actfancr_state>();
282		device_set_input_line(state->m_audiocpu, 0, linestate); /* IRQ */
	282	state->m_audiocpu->set_input_line(0, linestate); /* IRQ */
283	283	}
284	284
285	285	static const ym3812_interface ym3812_config =
r17814	r17815
293	293	{
294	294	actfancr_state *state = machine.driver_data<actfancr_state>();
295	295
296		state->m_maincpu = machine.device("maincpu");
297		state->m_audiocpu = machine.device("audiocpu");
	296	state->m_maincpu = machine.device<cpu_device>("maincpu");
	297	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
298	298	}
299	299
300	300	static MACHINE_START( triothep )

trunk/src/mame/drivers/galgame.c

r17814	r17815
295	295
296	296	static IRQ_CALLBACK(galaxygame_irq_callback)
297	297	{
298		device_set_input_line(device, 0, CLEAR_LINE);
	298	device->execute().set_input_line(0, CLEAR_LINE);
299	299	return 0x40;
300	300	}
301	301
r17814	r17815
304	304	galaxygame_state *state = device->machine().driver_data<galaxygame_state>();
305	305	if ( state->m_clk & 0x40 )
306	306	{
307		device_set_input_line(device, 0, ASSERT_LINE);
	307	device->execute().set_input_line(0, ASSERT_LINE);
308	308	state->m_interrupt = 1;
309	309	}
310	310	}
r17814	r17815
317	317	state->m_point_display_list_index = 0;
318	318	state->m_interrupt = 0;
319	319
320		device_set_irq_callback(machine.device("maincpu"), galaxygame_irq_callback);
	320	machine.device("maincpu")->execute().set_irq_acknowledge_callback(galaxygame_irq_callback);
321	321	}
322	322
323	323	static const struct t11_setup t11_data =

trunk/src/mame/drivers/qdrmfgp.c

r17814	r17815
271	271
272	272	if(scanline == 0)
273	273	if (state->m_control & 0x0001)
274		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	274	state->m_maincpu->set_input_line(1, HOLD_LINE);
275	275
276	276	/* trigger V-blank interrupt */
277	277	if(scanline == 240)
278	278	if (state->m_control & 0x0004)
279		device_set_input_line(state->m_maincpu, 3, HOLD_LINE);
	279	state->m_maincpu->set_input_line(3, HOLD_LINE);
280	280	}
281	281
282	282	static void ide_interrupt(device_t *device, int state)
r17814	r17815
305	305	qdrmfgp_state *state = device->machine().driver_data<qdrmfgp_state>();
306	306	/* trigger V-blank interrupt */
307	307	if (state->m_control & 0x0008)
308		device_set_input_line(device, 4, HOLD_LINE);
	308	device->execute().set_input_line(4, HOLD_LINE);
309	309	}
310	310
311	311	static void gp2_ide_interrupt(device_t *device, int state)

trunk/src/mame/drivers/cps1.c

r17814	r17815
330	330	{
331	331	/* Strider also has a IRQ4 handler. It is input port related, but the game */
332	332	/* works without it. It is the *only* CPS1 game to have that. */
333		device_set_input_line(device, 2, HOLD_LINE);
	333	device->execute().set_input_line(2, HOLD_LINE);
334	334	}
335	335
336	336	/********************************************************************
r17814	r17815
343	343
344	344	static INTERRUPT_GEN( cps1_qsound_interrupt )
345	345	{
346		device_set_input_line(device, 2, HOLD_LINE);
	346	device->execute().set_input_line(2, HOLD_LINE);
347	347	}
348	348
349	349
r17814	r17815
3011	3011	static void cps1_irq_handler_mus(device_t *device, int irq)
3012	3012	{
3013	3013	cps_state *state = device->machine().driver_data<cps_state>();
3014		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	3014	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
3015	3015	}
3016	3016
3017	3017	static const ym2151_interface ym2151_config =
r17814	r17815
3034	3034	{
3035	3035	cps_state *state = machine.driver_data<cps_state>();
3036	3036
3037		state->m_maincpu = machine.device("maincpu");
3038		state->m_audiocpu = machine.device("audiocpu");
	3037	state->m_maincpu = machine.device<cpu_device>("maincpu");
	3038	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
3039	3039	}
3040	3040
3041	3041	static MACHINE_START( cps1 )

trunk/src/mame/drivers/yunsun16.c

r17814	r17815
148	148	if ((data & 0xff) != 0x3a)
149	149	{
150	150	soundlatch_byte_w(space, 0, data & 0xff);
151		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	151	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
152	152	}
153	153	}
154	154	}
r17814	r17815
558	558	{
559	559	yunsun16_state *state = machine.driver_data<yunsun16_state>();
560	560
561		state->m_audiocpu = machine.device("audiocpu");
	561	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
562	562
563	563	state->save_item(NAME(state->m_sprites_scrolldx));
564	564	state->save_item(NAME(state->m_sprites_scrolldy));
r17814	r17815
579	579	static void soundirq(device_t *device, int state)
580	580	{
581	581	yunsun16_state *yunsun16 = device->machine().driver_data<yunsun16_state>();
582		device_set_input_line(yunsun16->m_audiocpu, 0, state);
	582	yunsun16->m_audiocpu->set_input_line(0, state);
583	583	}
584	584
585	585	static const ym3812_interface magicbub_ym3812_intf =

trunk/src/mame/drivers/wiz.c

r17814	r17815
706	706	wiz_state *state = device->machine().driver_data<wiz_state>();
707	707
708	708	if(state->m_main_nmi_mask & 1)
709		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	709	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
710	710	}
711	711
712	712	static INTERRUPT_GEN( wiz_sound_interrupt )
r17814	r17815
714	714	wiz_state *state = device->machine().driver_data<wiz_state>();
715	715
716	716	if(state->m_sound_nmi_mask & 1)
717		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	717	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
718	718	}
719	719
720	720

trunk/src/mame/drivers/stactics.c

r17814	r17815
157	157
158	158	move_motor(device->machine(), state);
159	159
160		device_set_input_line(device, 0, HOLD_LINE);
	160	device->execute().set_input_line(0, HOLD_LINE);
161	161	}
162	162
163	163

trunk/src/mame/drivers/namcos11.c

r17814	r17815
857	857
858	858	if ((space.device().safe_pc() == 0xc153) && (!(m_su_83 & 0xff00)))
859	859	{
860		device_spin_until_interrupt(&space.device());
	860	space.device().execute().spin_until_interrupt();
861	861	}
862	862
863	863	return m_su_83;
r17814	r17815
1004	1004	{
1005	1005	namcos11_state *state = timer.machine().driver_data<namcos11_state>();
1006	1006
1007		device_set_input_line(state->m_mcu, M37710_LINE_IRQ0, HOLD_LINE);
	1007	state->m_mcu->set_input_line(M37710_LINE_IRQ0, HOLD_LINE);
1008	1008	}
1009	1009
1010	1010	static TIMER_DEVICE_CALLBACK( mcu_irq2_cb )
1011	1011	{
1012	1012	namcos11_state *state = timer.machine().driver_data<namcos11_state>();
1013	1013
1014		device_set_input_line(state->m_mcu, M37710_LINE_IRQ2, HOLD_LINE);
	1014	state->m_mcu->set_input_line(M37710_LINE_IRQ2, HOLD_LINE);
1015	1015	}
1016	1016
1017	1017	static TIMER_DEVICE_CALLBACK( mcu_adc_cb )
1018	1018	{
1019	1019	namcos11_state *state = timer.machine().driver_data<namcos11_state>();
1020	1020
1021		device_set_input_line(state->m_mcu, M37710_LINE_ADC, HOLD_LINE);
	1021	state->m_mcu->set_input_line(M37710_LINE_ADC, HOLD_LINE);
1022	1022	}
1023	1023
1024	1024	static MACHINE_CONFIG_START( coh100, namcos11_state )

trunk/src/mame/drivers/galaxian.c

r17814	r17815
444	444	/* interrupt line is clocked at VBLANK */
445	445	/* a flip-flop at 6F is held in the preset state based on the NMI ON signal */
446	446	if (state->m_irq_enabled)
447		device_set_input_line(device, state->m_irq_line, ASSERT_LINE);
	447	device->execute().set_input_line(state->m_irq_line, ASSERT_LINE);
448	448	}
449	449
450	450	static INTERRUPT_GEN( fakechange_interrupt_gen )
r17814	r17815
468	468
469	469	/* if CLEAR is held low, we must make sure the interrupt signal is clear */
470	470	if (!m_irq_enabled)
471		device_set_input_line(&space.device(), m_irq_line, CLEAR_LINE);
	471	space.device().execute().set_input_line(m_irq_line, CLEAR_LINE);
472	472	}
473	473
474	474	/*************************************

trunk/src/mame/drivers/bbusters.c

r17814	r17815
281	281
282	282	logerror("%08x: gun r\n",space.device().safe_pc());
283	283
284		device_set_input_line(&space.device(), 2, HOLD_LINE);
	284	space.device().execute().set_input_line(2, HOLD_LINE);
285	285
286	286	m_gun_select = data & 0xff;
287	287	}

trunk/src/mame/drivers/hyprduel.c

r17814	r17815
50	50	hyprduel_state *state = machine.driver_data<hyprduel_state>();
51	51	int irq = state->m_requested_int & ~*state->m_irq_enable;
52	52
53		device_set_input_line(state->m_maincpu, 3, (irq & state->m_int_num) ? ASSERT_LINE : CLEAR_LINE);
	53	state->m_maincpu->set_input_line(3, (irq & state->m_int_num) ? ASSERT_LINE : CLEAR_LINE);
54	54	}
55	55
56	56	static TIMER_CALLBACK( vblank_end_callback )
r17814	r17815
68	68	{
69	69	state->m_requested_int |= 0x01;      /* vblank */
70	70	state->m_requested_int |= 0x20;
71		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	71	state->m_maincpu->set_input_line(2, HOLD_LINE);
72	72	/* the duration is a guess */
73	73	timer.machine().scheduler().timer_set(attotime::from_usec(2500), FUNC(vblank_end_callback), 0x20);
74	74	}
r17814	r17815
107	107	case 0x01:
108	108	if (!m_subcpu_resetline)
109	109	{
110		device_set_input_line(m_subcpu, INPUT_LINE_RESET, ASSERT_LINE);
	110	m_subcpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
111	111	m_subcpu_resetline = 1;
112	112	}
113	113	break;
r17814	r17815
115	115	case 0x00:
116	116	if (m_subcpu_resetline)
117	117	{
118		device_set_input_line(m_subcpu, INPUT_LINE_RESET, CLEAR_LINE);
	118	m_subcpu->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
119	119	m_subcpu_resetline = 0;
120	120	}
121		device_spin_until_interrupt(&space.device());
	121	space.device().execute().spin_until_interrupt();
122	122	break;
123	123
124	124	case 0x0c:
125	125	case 0x80:
126		device_set_input_line(m_subcpu, 2, HOLD_LINE);
	126	m_subcpu->set_input_line(2, HOLD_LINE);
127	127	break;
128	128	}
129	129	}
r17814	r17815
148	148	{
149	149	if (!m_cpu_trigger && !m_subcpu_resetline)
150	150	{
151		device_spin_until_trigger(&space.device(), 1001);
	151	space.device().execute().spin_until_trigger(1001);
152	152	m_cpu_trigger = 1001;
153	153	}
154	154	}
r17814	r17815
174	174	{
175	175	if (!m_cpu_trigger && !m_subcpu_resetline)
176	176	{
177		device_spin_until_trigger(&space.device(), 1002);
	177	space.device().execute().spin_until_trigger(1002);
178	178	m_cpu_trigger = 1002;
179	179	}
180	180	}
r17814	r17815
184	184	static TIMER_CALLBACK( magerror_irq_callback )
185	185	{
186	186	hyprduel_state *state = machine.driver_data<hyprduel_state>();
187		device_set_input_line(state->m_subcpu, 1, HOLD_LINE);
	187	state->m_subcpu->set_input_line(1, HOLD_LINE);
188	188	}
189	189
190	190	/***************************************************************************
r17814	r17815
623	623	static void sound_irq( device_t *device, int state )
624	624	{
625	625	hyprduel_state *hyprduel = device->machine().driver_data<hyprduel_state>();
626		device_set_input_line(hyprduel->m_subcpu, 1, HOLD_LINE);
	626	hyprduel->m_subcpu->set_input_line(1, HOLD_LINE);
627	627	}
628	628
629	629	static const ym2151_interface ym2151_config =
r17814	r17815
653	653	{
654	654	hyprduel_state *state = machine.driver_data<hyprduel_state>();
655	655
656		state->m_maincpu = machine.device("maincpu");
657		state->m_subcpu = machine.device("sub");
	656	state->m_maincpu = machine.device<cpu_device>("maincpu");
	657	state->m_subcpu = machine.device<cpu_device>("sub");
658	658
659	659	state->save_item(NAME(state->m_blitter_bit));
660	660	state->save_item(NAME(state->m_requested_int));

trunk/src/mame/drivers/flstory.c

r17814	r17815
38	38	{
39	39	flstory_state *state = machine.driver_data<flstory_state>();
40	40	if (state->m_sound_nmi_enable)
41		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	41	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
42	42	else
43	43	state->m_pending_nmi = 1;
44	44	}
r17814	r17815
60	60	m_sound_nmi_enable = 1;
61	61	if (m_pending_nmi)
62	62	{
63		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	63	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
64	64	m_pending_nmi = 0;
65	65	}
66	66	}
r17814	r17815
119	119
120	120	CUSTOM_INPUT_MEMBER(flstory_state::victnine_mcu_status_bit01_r)
121	121	{
122		address_space *space = m_maincpu->memory().space(AS_PROGRAM);
	122	address_space *space = m_maincpu->space(AS_PROGRAM);
123	123
124	124	return (victnine_mcu_status_r(*space, 0) & 3);
125	125	}
r17814	r17815
1006	1006	{
1007	1007	flstory_state *state = machine.driver_data<flstory_state>();
1008	1008
1009		state->m_maincpu = machine.device("maincpu");
1010		state->m_audiocpu = machine.device("audiocpu");
	1009	state->m_maincpu = machine.device<cpu_device>("maincpu");
	1010	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
1011	1011	state->m_mcu = machine.device("mcu");
1012	1012
1013	1013	/* video */

trunk/src/mame/drivers/suprslam.c

r17814	r17815
96	96	{
97	97	m_pending_command = 1;
98	98	soundlatch_byte_w(space, offset, data & 0xff);
99		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	99	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
100	100	}
101	101	}
102	102
r17814	r17815
278	278	static void irqhandler(device_t *device, int irq)
279	279	{
280	280	suprslam_state *state = device->machine().driver_data<suprslam_state>();
281		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	281	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
282	282	}
283	283
284	284	static const ym2610_interface ym2610_config =
r17814	r17815
297	297	{
298	298	suprslam_state *state = machine.driver_data<suprslam_state>();
299	299
300		state->m_audiocpu = machine.device("audiocpu");
	300	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
301	301	state->m_k053936 = machine.device("k053936");
302	302
303	303	state->save_item(NAME(state->m_screen_bank));

trunk/src/mame/drivers/dgpix.c

r17814	r17815
197	197	READ32_MEMBER(dgpix_state::vblank_r)
198	198	{
199	199	/* burn a bunch of cycles because this is polled frequently during busy loops */
200		device_eat_cycles(&space.device(), 100);
	200	space.device().execute().eat_cycles(100);
201	201	return ioport("VBLANK")->read();
202	202	}
203	203

trunk/src/mame/drivers/shaolins.c

r17814	r17815
19	19	int scanline = param;
20	20
21	21	if(scanline == 240)
22		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	22	state->m_maincpu->set_input_line(0, HOLD_LINE);
23	23	else if((scanline % 32) == 0)
24		if (state->m_nmi_enable & 0x02) device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	24	if (state->m_nmi_enable & 0x02) state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
25	25	}
26	26
27	27

trunk/src/mame/drivers/kyugo.c

r17814	r17815
62	62
63	63	WRITE8_MEMBER(kyugo_state::kyugo_sub_cpu_control_w)
64	64	{
65		device_set_input_line(m_subcpu, INPUT_LINE_HALT, data ? CLEAR_LINE : ASSERT_LINE);
	65	m_subcpu->set_input_line(INPUT_LINE_HALT, data ? CLEAR_LINE : ASSERT_LINE);
66	66	}
67	67
68	68	static ADDRESS_MAP_START( kyugo_main_portmap, AS_IO, 8, kyugo_state )
r17814	r17815
498	498	{
499	499	kyugo_state *state = machine.driver_data<kyugo_state>();
500	500
501		state->m_maincpu = machine.device("maincpu");
502		state->m_subcpu = machine.device("sub");
	501	state->m_maincpu = machine.device<cpu_device>("maincpu");
	502	state->m_subcpu = machine.device<cpu_device>("sub");
503	503
504	504	state->save_item(NAME(state->m_scroll_x_lo));
505	505	state->save_item(NAME(state->m_scroll_x_hi));
r17814	r17815
530	530	kyugo_state *state = device->machine().driver_data<kyugo_state>();
531	531
532	532	if(state->m_nmi_mask)
533		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	533	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
534	534	}
535	535
536	536

trunk/src/mame/drivers/pcat_nit.c

r17814	r17815
230	230
231	231	static MACHINE_START( streetg2 )
232	232	{
233		device_set_irq_callback(machine.device("maincpu"), pcat_irq_callback);
	233	machine.device("maincpu")->execute().set_irq_acknowledge_callback(pcat_irq_callback);
234	234
235	235	init_pc_common(machine, PCCOMMON_KEYBOARD_AT, streetg2_set_keyb_int);
236	236

trunk/src/mame/drivers/lazercmd.c

r17814	r17815
248	248	{
249	249	state->m_timer_count = 0;
250	250	state->m_sense_state ^= 1;
251		device_set_input_line(state->m_maincpu, 1, (state->m_sense_state) ? ASSERT_LINE : CLEAR_LINE);
	251	state->m_maincpu->set_input_line(1, (state->m_sense_state) ? ASSERT_LINE : CLEAR_LINE);
252	252	}
253	253	}
254	254

trunk/src/mame/drivers/blockade.c

r17814	r17815
61	61	static INTERRUPT_GEN( blockade_interrupt )
62	62	{
63	63	blockade_state *state = device->machine().driver_data<blockade_state>();
64		device_resume(device, SUSPEND_ANY_REASON);
	64	device->execute().resume(SUSPEND_ANY_REASON);
65	65
66	66	if ((state->ioport("IN0")->read() & 0x80) == 0)
67	67	{
68	68	state->m_just_been_reset = 1;
69		device_set_input_line(device, INPUT_LINE_RESET, PULSE_LINE);
	69	device->execute().set_input_line(INPUT_LINE_RESET, PULSE_LINE);
70	70	}
71	71	}
72	72

trunk/src/mame/drivers/zerozone.c

r17814	r17815
40	40	if (ACCESSING_BITS_8_15)
41	41	{
42	42	soundlatch_byte_w(space, offset, data >> 8);
43		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	43	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
44	44	}
45	45	}
46	46

trunk/src/mame/drivers/lemmings.c

r17814	r17815
80	80	WRITE16_MEMBER(lemmings_state::lemmings_sound_w)
81	81	{
82	82	soundlatch_byte_w(space, 0, data & 0xff);
83		device_set_input_line(m_audiocpu, 1, HOLD_LINE);
	83	m_audiocpu->set_input_line(1, HOLD_LINE);
84	84	}
85	85
86	86	WRITE8_MEMBER(lemmings_state::lemmings_sound_ack_w)
87	87	{
88		device_set_input_line(m_audiocpu, 1, CLEAR_LINE);
	88	m_audiocpu->set_input_line(1, CLEAR_LINE);
89	89	}
90	90
91	91	/******************************************************************************/
r17814	r17815
244	244	static void sound_irq( device_t *device, int state )
245	245	{
246	246	lemmings_state *lemmings = device->machine().driver_data<lemmings_state>();
247		device_set_input_line(lemmings->m_audiocpu, 0, state);
	247	lemmings->m_audiocpu->set_input_line(0, state);
248	248	}
249	249
250	250	static const ym2151_interface ym2151_config =
r17814	r17815
256	256	{
257	257	lemmings_state *state = machine.driver_data<lemmings_state>();
258	258
259		state->m_audiocpu = machine.device("audiocpu");
	259	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
260	260	}
261	261
262	262	static MACHINE_CONFIG_START( lemmings, lemmings_state )

trunk/src/mame/drivers/espial.c

r17814	r17815
58	58	{
59	59	espial_state *state = machine.driver_data<espial_state>();
60	60
61		state->m_maincpu = machine.device("maincpu");
62		state->m_audiocpu = machine.device("audiocpu");
	61	state->m_maincpu = machine.device<cpu_device>("maincpu");
	62	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
63	63
64	64	//state_save_register_global_array(machine, mcu_out[1]);
65	65	state->save_item(NAME(state->m_sound_nmi_enabled));
r17814	r17815
102	102	WRITE8_MEMBER(espial_state::espial_master_soundlatch_w)
103	103	{
104	104	soundlatch_byte_w(space, offset, data);
105		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	105	m_audiocpu->set_input_line(0, HOLD_LINE);
106	106	}
107	107
108	108

trunk/src/mame/drivers/tmnt.c

r17814	r17815
169	169	tmnt_state *state = device->machine().driver_data<tmnt_state>();
170	170
171	171	if (state->m_irq5_mask)
172		device_set_input_line(device, M68K_IRQ_5, HOLD_LINE);
	172	device->execute().set_input_line(M68K_IRQ_5, HOLD_LINE);
173	173	}
174	174
175	175	static INTERRUPT_GEN( punkshot_interrupt )
r17814	r17815
210	210	k053260_w(device, offset, data);
211	211
212	212	if (offset)
213		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	213	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
214	214	}
215	215
216	216	READ16_MEMBER(tmnt_state::prmrsocr_sound_r)
r17814	r17815
232	232
233	233	WRITE16_MEMBER(tmnt_state::prmrsocr_sound_irq_w)
234	234	{
235		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	235	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
236	236	}
237	237
238	238	WRITE8_MEMBER(tmnt_state::prmrsocr_audio_bankswitch_w)
r17814	r17815
321	321	static TIMER_CALLBACK( nmi_callback )
322	322	{
323	323	tmnt_state *state = machine.driver_data<tmnt_state>();
324		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, ASSERT_LINE);
	324	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
325	325	}
326	326
327	327	WRITE8_MEMBER(tmnt_state::sound_arm_nmi_w)
328	328	{
329	329	//  sound_nmi_enabled = 1;
330		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, CLEAR_LINE);
	330	m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
331	331	machine().scheduler().timer_set(attotime::from_usec(50), FUNC(nmi_callback));   /* kludge until the K053260 is emulated correctly */
332	332	}
333	333
r17814	r17815
518	518
519	519	/* bit 5 triggers IRQ on sound cpu */
520	520	if (m_last == 0 && (data & 0x20) != 0)
521		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	521	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
522	522	m_last = data & 0x20;
523	523
524	524	/* bit 6 = enable char ROM reading through the video RAM */
r17814	r17815
666	666	{
667	667
668	668	/* I think this is more than just a trigger */
669		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	669	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
670	670	}
671	671
672	672	static ADDRESS_MAP_START( blswhstl_main_map, AS_PROGRAM, 16, tmnt_state )
r17814	r17815
2036	2036	{
2037	2037	tmnt_state *tmnt = device->machine().driver_data<tmnt_state>();
2038	2038
2039		device_set_input_line(tmnt->m_maincpu, M68K_IRQ_6, (state) ? ASSERT_LINE : CLEAR_LINE);
	2039	tmnt->m_maincpu->set_input_line(M68K_IRQ_6, (state) ? ASSERT_LINE : CLEAR_LINE);
2040	2040	}
2041	2041
2042	2042	static const ym2151_interface ym2151_interface_cbj =
r17814	r17815
2207	2207	{
2208	2208	tmnt_state *state = machine.driver_data<tmnt_state>();
2209	2209
2210		state->m_maincpu = machine.device("maincpu");
2211		state->m_audiocpu = machine.device("audiocpu");
	2210	state->m_maincpu = machine.device<cpu_device>("maincpu");
	2211	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
2212	2212	state->m_k007232 = machine.device("k007232");
2213	2213	state->m_k053260 = machine.device("k053260");
2214	2214	state->m_k054539 = machine.device("k054539");
r17814	r17815
2249	2249	tmnt_state *state = device->machine().driver_data<tmnt_state>();
2250	2250
2251	2251	if(state->m_irq5_mask)
2252		device_set_input_line(device, 5, HOLD_LINE);
	2252	device->execute().set_input_line(5, HOLD_LINE);
2253	2253	}
2254	2254
2255	2255
r17814	r17815
2594	2594	static void sound_nmi( device_t *device )
2595	2595	{
2596	2596	tmnt_state *state = device->machine().driver_data<tmnt_state>();
2597		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	2597	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
2598	2598	}
2599	2599
2600	2600	static const k054539_interface k054539_config =

trunk/src/mame/drivers/tasman.c

r17814	r17815
584	584	int scanline = param;
585	585
586	586	if(scanline == 512)
587		device_set_input_line(state->m_maincpu, 1, HOLD_LINE); // vblank?
	587	state->m_maincpu->set_input_line(1, HOLD_LINE); // vblank?
588	588
589	589	if(scanline == 0)
590		device_set_input_line(state->m_maincpu, 3, HOLD_LINE); // sprite irq?
	590	state->m_maincpu->set_input_line(3, HOLD_LINE); // sprite irq?
591	591	}
592	592
593	593	static MACHINE_CONFIG_START( kongambl, kongambl_state )

trunk/src/mame/drivers/zodiack.c

r17814	r17815
127	127	WRITE8_MEMBER( zodiack_state::master_soundlatch_w )
128	128	{
129	129	soundlatch_byte_w(space, offset, data);
130		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	130	m_audiocpu->set_input_line(0, HOLD_LINE);
131	131	}
132	132
133	133	WRITE8_MEMBER( zodiack_state::control_w )

trunk/src/mame/drivers/raiden2.c

r17814	r17815
975	975
976	976	static INTERRUPT_GEN( raiden2_interrupt )
977	977	{
978		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0xc0/4);   /* VBL */
	978	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0xc0/4);   /* VBL */
979	979	}
980	980
981	981

trunk/src/mame/drivers/mogura.c

r17814	r17815
21	21	tilemap_t *m_tilemap;
22	22
23	23	/* devices */
24		device_t *m_maincpu;
	24	cpu_device *m_maincpu;
25	25	dac_device *m_dac1;
26	26	dac_device *m_dac2;
27	27	DECLARE_WRITE8_MEMBER(mogura_tileram_w);
r17814	r17815
192	192	{
193	193	mogura_state *state = machine.driver_data<mogura_state>();
194	194
195		state->m_maincpu = machine.device("maincpu");
	195	state->m_maincpu = machine.device<cpu_device>("maincpu");
196	196	state->m_dac1 = machine.device<dac_device>("dac1");
197	197	state->m_dac2 = machine.device<dac_device>("dac2");
198	198	}

trunk/src/mame/drivers/taitojc.c

r17814	r17815
538	538	#endif
539	539
540	540	if (offset == 0x1ff8/4)
541		device_set_input_line(m_maincpu, 6, CLEAR_LINE);
	541	m_maincpu->set_input_line(6, CLEAR_LINE);
542	542
543	543	if (offset == 0x1ffc/4)
544	544	{
r17814	r17815
556	556	*/
557	557	if (!m_first_dsp_reset || !m_has_dsp_hack)
558	558	{
559		device_set_input_line(m_dsp, INPUT_LINE_RESET, CLEAR_LINE);
	559	m_dsp->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
560	560	}
561	561	m_first_dsp_reset = 0;
562	562	}
563	563	else
564	564	{
565		device_set_input_line(m_dsp, INPUT_LINE_RESET, ASSERT_LINE);
	565	m_dsp->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
566	566	}
567	567	}
568	568	}
r17814	r17815
1010	1010
1011	1011	WRITE16_MEMBER(taitojc_state::dsp_to_main_w)
1012	1012	{
1013		device_set_input_line(m_maincpu, 6, ASSERT_LINE);
	1013	m_maincpu->set_input_line(6, ASSERT_LINE);
1014	1014
1015	1015	COMBINE_DATA(&m_dsp_shared_ram[0x7fe]);
1016	1016	}
r17814	r17815
1215	1215	memset(state->m_intersection_data, 0, sizeof(state->m_intersection_data));
1216	1216
1217	1217	// hold the TMS in reset until we have code
1218		device_set_input_line(state->m_dsp, INPUT_LINE_RESET, ASSERT_LINE);
	1218	state->m_dsp->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
1219	1219	}
1220	1220
1221	1221	static INTERRUPT_GEN( taitojc_vblank )
1222	1222	{
1223		device_set_input_line_and_vector(device, 2, HOLD_LINE, 130);
	1223	device->execute().set_input_line_and_vector(2, HOLD_LINE, 130);
1224	1224	}
1225	1225
1226	1226	static const tc0640fio_interface taitojc_io_intf =
r17814	r17815
1302	1302	READ16_MEMBER(taitojc_state::taitojc_dsp_idle_skip_r)
1303	1303	{
1304	1304	if(space.device().safe_pc()==0x404c)
1305		device_spin_until_time(&space.device(), attotime::from_usec(500));
	1305	space.device().execute().spin_until_time(attotime::from_usec(500));
1306	1306
1307	1307	return m_dsp_shared_ram[0x7f0];
1308	1308	}
r17814	r17815
1310	1310	READ16_MEMBER(taitojc_state::dendego2_dsp_idle_skip_r)
1311	1311	{
1312	1312	if(space.device().safe_pc()==0x402e)
1313		device_spin_until_time(&space.device(), attotime::from_usec(500));
	1313	space.device().execute().spin_until_time(attotime::from_usec(500));
1314	1314
1315	1315	return m_dsp_shared_ram[0x7f0];
1316	1316	}

trunk/src/mame/drivers/ddealer.c

r17814	r17815
620	620
621	621	static INTERRUPT_GEN( ddealer_interrupt )
622	622	{
623		device_set_input_line(device, 4, HOLD_LINE);
	623	device->execute().set_input_line(4, HOLD_LINE);
624	624	}
625	625
626	626	static MACHINE_CONFIG_START( ddealer, ddealer_state )

trunk/src/mame/drivers/magtouch.c

r17814	r17815
199	199
200	200	static MACHINE_START( magtouch )
201	201	{
202		device_set_irq_callback(machine.device("maincpu"), pcat_irq_callback);
	202	machine.device("maincpu")->execute().set_irq_acknowledge_callback(pcat_irq_callback);
203	203
204	204	init_pc_common(machine, PCCOMMON_KEYBOARD_AT, magtouch_set_keyb_int);
205	205

trunk/src/mame/drivers/suprridr.c

r17814	r17815
103	103	{
104	104	suprridr_state *state = device->machine().driver_data<suprridr_state>();
105	105	if (state->m_nmi_enable)
106		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	106	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
107	107	}
108	108
109	109

trunk/src/mame/drivers/igs009.c

r17814	r17815
737	737	{
738	738	igs009_state *state = device->machine().driver_data<igs009_state>();
739	739	if (state->m_nmi_enable & 0x80)
740		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	740	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
741	741	}
742	742
743	743	static MACHINE_CONFIG_START( jingbell, igs009_state )

trunk/src/mame/drivers/spy.c

r17814	r17815
31	31	spy_state *state = device->machine().driver_data<spy_state>();
32	32
33	33	if (k052109_is_irq_enabled(state->m_k052109))
34		device_set_input_line(device, 0, HOLD_LINE);
	34	device->execute().set_input_line(0, HOLD_LINE);
35	35	}
36	36
37	37	READ8_MEMBER(spy_state::spy_bankedram1_r)
r17814	r17815
324	324	}
325	325	spy_collision(machine());
326	326	//ZT
327		device_set_input_line(m_maincpu, M6809_FIRQ_LINE, HOLD_LINE);
	327	m_maincpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
328	328	}
329	329
330	330	m_old_3f90 = data;
r17814	r17815
333	333
334	334	WRITE8_MEMBER(spy_state::spy_sh_irqtrigger_w)
335	335	{
336		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	336	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
337	337	}
338	338
339	339	WRITE8_MEMBER(spy_state::sound_bank_w)
r17814	r17815
470	470	static void irqhandler( device_t *device, int linestate )
471	471	{
472	472	spy_state *state = device->machine().driver_data<spy_state>();
473		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, linestate);
	473	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, linestate);
474	474	}
475	475
476	476	static const ym3812_interface ym3812_config =
r17814	r17815
505	505	state->m_generic_paletteram_8.allocate(0x800);
506	506	memset(state->m_pmcram, 0, sizeof(state->m_pmcram));
507	507
508		state->m_maincpu = machine.device("maincpu");
509		state->m_audiocpu = machine.device("audiocpu");
	508	state->m_maincpu = machine.device<cpu_device>("maincpu");
	509	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
510	510	state->m_k052109 = machine.device("k052109");
511	511	state->m_k051960 = machine.device("k051960");
512	512	state->m_k007232_1 = machine.device("k007232_1");

trunk/src/mame/drivers/psikyo.c

r17814	r17815
148	148	{
149	149	psikyo_state *state = machine.driver_data<psikyo_state>();
150	150	state->m_soundlatch = param;
151		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, ASSERT_LINE);
	151	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
152	152	state->m_z80_nmi = 1;
153	153	}
154	154
r17814	r17815
382	382	static void sound_irq( device_t *device, int irq )
383	383	{
384	384	psikyo_state *state = device->machine().driver_data<psikyo_state>();
385		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	385	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
386	386	}
387	387
388	388	READ8_MEMBER(psikyo_state::psikyo_soundlatch_r)
r17814	r17815
392	392
393	393	WRITE8_MEMBER(psikyo_state::psikyo_clear_nmi_w)
394	394	{
395		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, CLEAR_LINE);
	395	m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
396	396	m_z80_nmi = 0;
397	397	}
398	398
r17814	r17815
1017	1017	{
1018	1018	psikyo_state *state = machine.driver_data<psikyo_state>();
1019	1019
1020		state->m_audiocpu = machine.device("audiocpu");
	1020	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
1021	1021
1022	1022	state->save_item(NAME(state->m_soundlatch));
1023	1023	state->save_item(NAME(state->m_z80_nmi));
r17814	r17815
1178	1178	static void irqhandler( device_t *device, int linestate )
1179	1179	{
1180	1180	psikyo_state *state = device->machine().driver_data<psikyo_state>();
1181		device_set_input_line(state->m_audiocpu, 0, linestate ? ASSERT_LINE : CLEAR_LINE);
	1181	state->m_audiocpu->set_input_line(0, linestate ? ASSERT_LINE : CLEAR_LINE);
1182	1182	}
1183	1183
1184	1184	static const ymf278b_interface ymf278b_config =

trunk/src/mame/drivers/dacholer.c

r17814	r17815
205	205	WRITE8_MEMBER(dacholer_state::snd_w)
206	206	{
207	207	soundlatch_byte_w(space, offset, data);
208		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	208	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
209	209	}
210	210
211	211	WRITE8_MEMBER(dacholer_state::main_irq_ack_w)
212	212	{
213		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	213	m_maincpu->set_input_line(0, CLEAR_LINE);
214	214	}
215	215
216	216
r17814	r17815
551	551	dacholer_state *state = device->machine().driver_data<dacholer_state>();
552	552	if (state->m_music_interrupt_enable == 1)
553	553	{
554		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0x30);
	554	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0x30);
555	555	}
556	556	}
557	557
r17814	r17815
565	565	state->m_msm_toggle ^= 1;
566	566	if (state->m_msm_toggle == 0)
567	567	{
568		device_set_input_line_and_vector(state->m_audiocpu, 0, HOLD_LINE, 0x38);
	568	state->m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0x38);
569	569	}
570	570	}
571	571	}

trunk/src/mame/drivers/esd16.c

r17814	r17815
86	86	if (ACCESSING_BITS_0_7)
87	87	{
88	88	soundlatch_byte_w(space, 0, data & 0xff);
89		device_set_input_line(m_audio_cpu, 0, ASSERT_LINE);      // Generate an IRQ
90		device_spin_until_time(&space.device(), attotime::from_usec(50));   // Allow the other CPU to reply
	89	m_audio_cpu->execute().set_input_line(0, ASSERT_LINE);      // Generate an IRQ
	90	space.device().execute().spin_until_time(attotime::from_usec(50));   // Allow the other CPU to reply
91	91	}
92	92	}
93	93
r17814	r17815
254	254	{
255	255
256	256	/* Clear IRQ only after reading the command, or some get lost */
257		device_set_input_line(m_audio_cpu, 0, CLEAR_LINE);
	257	m_audio_cpu->execute().set_input_line(0, CLEAR_LINE);
258	258	return soundlatch_byte_r(space, 0);
259	259	}
260	260

trunk/src/mame/drivers/iqblock.c

r17814	r17815
82	82	return;
83	83
84	84	if((scanline % 32) == 16)
85		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	85	state->m_maincpu->set_input_line(0, HOLD_LINE);
86	86	else if   ((scanline % 32) == 0)
87		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	87	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
88	88	}
89	89
90	90

trunk/src/mame/drivers/funkyjet.c

r17814	r17815
278	278	static void sound_irq( device_t *device, int state )
279	279	{
280	280	funkyjet_state *driver_state = device->machine().driver_data<funkyjet_state>();
281		device_set_input_line(driver_state->m_audiocpu, 1, state); /* IRQ 2 */
	281	driver_state->m_audiocpu->set_input_line(1, state); /* IRQ 2 */
282	282	}
283	283
284	284	static const ym2151_interface ym2151_config =
r17814	r17815
301	301	{
302	302	funkyjet_state *state = machine.driver_data<funkyjet_state>();
303	303
304		state->m_maincpu = machine.device("maincpu");
305		state->m_audiocpu = machine.device("audiocpu");
	304	state->m_maincpu = machine.device<cpu_device>("maincpu");
	305	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
306	306	state->m_deco_tilegen1 = machine.device("tilegen1");
307	307	}
308	308

trunk/src/mame/drivers/xexex.c

r17814	r17815
165	165
166	166	if (space.device().safe_pc() == 0x1158)
167	167	{
168		device_spin_until_trigger(&space.device(), m_resume_trigger);
	168	space.device().execute().spin_until_trigger(m_resume_trigger);
169	169	m_suspension_active = 1;
170	170	}
171	171
r17814	r17815
226	226
227	227	WRITE16_MEMBER(xexex_state::sound_irq_w)
228	228	{
229		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	229	m_audiocpu->set_input_line(0, HOLD_LINE);
230	230	}
231	231
232	232	READ16_MEMBER(xexex_state::sound_status_r)
r17814	r17815
270	270
271	271	// IRQ 5 is the "object DMA end interrupt" and shouldn't be triggered
272	272	// if object data isn't ready for DMA within the frame.
273		device_set_input_line(state->m_maincpu, 5, HOLD_LINE);
	273	state->m_maincpu->set_input_line(5, HOLD_LINE);
274	274	}
275	275	}
276	276
r17814	r17815
289	289	{
290	290	// IRQ 6 is for test mode only
291	291	if (state->m_cur_control2 & 0x0020)
292		device_set_input_line(state->m_maincpu, 6, HOLD_LINE);
	292	state->m_maincpu->set_input_line(6, HOLD_LINE);
293	293	}
294	294
295	295	/* TODO: vblank is at 256! (enable CCU then have fun in fixing offsetted layers) */
r17814	r17815
307	307	// IRQ 4 is the V-blank interrupt. It controls color, sound and
308	308	// vital game logics that shouldn't be interfered by frame-drop.
309	309	if (state->m_cur_control2 & 0x0800)
310		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	310	state->m_maincpu->set_input_line(4, HOLD_LINE);
311	311	}
312	312	}
313	313
r17814	r17815
461	461	state->membank("bank2")->configure_entries(0, 8, &ROM[0x10000], 0x4000);
462	462	state->membank("bank2")->set_entry(0);
463	463
464		state->m_maincpu = machine.device("maincpu");
465		state->m_audiocpu = machine.device("audiocpu");
	464	state->m_maincpu = machine.device<cpu_device>("maincpu");
	465	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
466	466	state->m_k053246 = machine.device("k053246");
467	467	state->m_k053250 = machine.device<k053250_t>("k053250");
468	468	state->m_k053251 = machine.device("k053251");

trunk/src/mame/drivers/ironhors.c

r17814	r17815
28	28	if (scanline == 240)
29	29	{
30	30	if (*state->m_interrupt_enable & 4)
31		device_set_input_line(state->m_maincpu, M6809_FIRQ_LINE, HOLD_LINE);
	31	state->m_maincpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
32	32	}
33	33	else if (((scanline+16) % 64) == 0)
34	34	{
35	35	if (*state->m_interrupt_enable & 1)
36		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	36	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
37	37	}
38	38	}
39	39
40	40	WRITE8_MEMBER(ironhors_state::ironhors_sh_irqtrigger_w)
41	41	{
42	42
43		device_set_input_line_and_vector(m_soundcpu, 0, HOLD_LINE, 0xff);
	43	m_soundcpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
44	44	}
45	45
46	46	WRITE8_MEMBER(ironhors_state::ironhors_filter_w)
r17814	r17815
360	360	{
361	361	ironhors_state *state = machine.driver_data<ironhors_state>();
362	362
363		state->m_maincpu = machine.device("maincpu");
364		state->m_soundcpu = machine.device("soundcpu");
	363	state->m_maincpu = machine.device<cpu_device>("maincpu");
	364	state->m_soundcpu = machine.device<cpu_device>("soundcpu");
365	365
366	366	state->save_item(NAME(state->m_palettebank));
367	367	state->save_item(NAME(state->m_charbank));
r17814	r17815
430	430	if ((scanline % 2) == 1)
431	431	{
432	432	if (*state->m_interrupt_enable & 4)
433		device_set_input_line(state->m_maincpu, M6809_FIRQ_LINE, HOLD_LINE);
	433	state->m_maincpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
434	434	}
435	435	else if ((scanline % 2) == 0)
436	436	{
437	437	if (*state->m_interrupt_enable & 1)
438		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	438	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
439	439	}
440	440	}
441	441
442	442	READ8_MEMBER(ironhors_state::farwest_soundlatch_r)
443	443	{
444	444
445		return soundlatch_byte_r(*m_soundcpu->memory().space(AS_PROGRAM), 0);
	445	return soundlatch_byte_r(*m_soundcpu->space(AS_PROGRAM), 0);
446	446	}
447	447
448	448	static const ym2203_interface farwest_ym2203_config =

trunk/src/mame/drivers/sliver.c

r17814	r17815
467	467	{
468	468	sliver_state *state = timer.machine().driver_data<sliver_state>();
469	469
470		device_set_input_line(state->m_maincpu, 3, HOLD_LINE);
	470	state->m_maincpu->set_input_line(3, HOLD_LINE);
471	471	}
472	472
473	473	static MACHINE_CONFIG_START( sliver, sliver_state )

trunk/src/mame/drivers/mrflea.c

r17814	r17815
85	85	{
86	86	m_status |= 0x08; // pending command to IO CPU
87	87	m_io = data;
88		device_set_input_line(m_subcpu, 0, HOLD_LINE );
	88	m_subcpu->set_input_line(0, HOLD_LINE );
89	89	}
90	90
91	91	READ8_MEMBER(mrflea_state::mrflea_main_r)
r17814	r17815
122	122	int scanline = param;
123	123
124	124	if ((scanline == 248) || (scanline == 248/2 && (state->m_status & 0x08)))
125		device_set_input_line(state->m_subcpu, 0, HOLD_LINE);
	125	state->m_subcpu->set_input_line(0, HOLD_LINE);
126	126	}
127	127
128	128	READ8_MEMBER(mrflea_state::mrflea_interrupt_type_r)
r17814	r17815
332	332	{
333	333	mrflea_state *state = machine.driver_data<mrflea_state>();
334	334
335		state->m_maincpu = machine.device("maincpu");
336		state->m_subcpu = machine.device("sub");
	335	state->m_maincpu = machine.device<cpu_device>("maincpu");
	336	state->m_subcpu = machine.device<cpu_device>("sub");
337	337
338	338	state->save_item(NAME(state->m_gfx_bank));
339	339	state->save_item(NAME(state->m_io));

trunk/src/mame/drivers/cps3.c

r17814	r17815
2247	2247
2248	2248	static INTERRUPT_GEN(cps3_vbl_interrupt)
2249	2249	{
2250		device_set_input_line(device,12, ASSERT_LINE);
	2250	device->execute().set_input_line(12, ASSERT_LINE);
2251	2251	}
2252	2252
2253	2253	static INTERRUPT_GEN(cps3_other_interrupt)
r17814	r17815
2255	2255	// this seems to need to be periodic (see the life bar portraits in sfiii2
2256	2256	// but also triggered on certain dma events (or warzard locks up in attract)
2257	2257	// what is the REAL source of IRQ10??
2258		device_set_input_line(device,10, ASSERT_LINE);
	2258	device->execute().set_input_line(10, ASSERT_LINE);
2259	2259	}
2260	2260
2261	2261

trunk/src/mame/drivers/glass.c

r17814	r17815
24	24
25	25	if (state->m_cause_interrupt)
26	26	{
27		device_set_input_line(device, 6, HOLD_LINE);
	27	device->execute().set_input_line(6, HOLD_LINE);
28	28	state->m_cause_interrupt = 0;
29	29	}
30	30	}

trunk/src/mame/drivers/jchan.c

r17814	r17815
247	247	int scanline = param;
248	248
249	249	if(scanline == 240)
250		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	250	state->m_maincpu->set_input_line(1, HOLD_LINE);
251	251
252	252	if(scanline == 11)
253		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	253	state->m_maincpu->set_input_line(2, HOLD_LINE);
254	254
255	255	if (state->m_irq_sub_enable)
256	256	{
257	257	if(scanline == 240)
258		device_set_input_line(state->m_subcpu, 1, HOLD_LINE);
	258	state->m_subcpu->set_input_line(1, HOLD_LINE);
259	259
260	260	if(scanline == 249)
261		device_set_input_line(state->m_subcpu, 2, HOLD_LINE);
	261	state->m_subcpu->set_input_line(2, HOLD_LINE);
262	262
263	263	if(scanline == 11)
264		device_set_input_line(state->m_subcpu, 3, HOLD_LINE);
	264	state->m_subcpu->set_input_line(3, HOLD_LINE);
265	265	}
266	266	}
267	267

trunk/src/mame/drivers/bankp.c

r17814	r17815
295	295	bankp_state *state = device->machine().driver_data<bankp_state>();
296	296
297	297	if(state->m_nmi_mask)
298		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	298	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
299	299	}
300	300
301	301	static MACHINE_CONFIG_START( bankp, bankp_state )

trunk/src/mame/drivers/tankbust.c

r17814	r17815
323	323	tankbust_state *state = device->machine().driver_data<tankbust_state>();
324	324
325	325	if(state->m_irq_mask)
326		device_set_input_line(device, 0, HOLD_LINE);
	326	device->execute().set_input_line(0, HOLD_LINE);
327	327	}
328	328
329	329	static MACHINE_CONFIG_START( tankbust, tankbust_state )

trunk/src/mame/drivers/pastelg.c

r17814	r17815
57	57
58	58	READ8_MEMBER(pastelg_state::pastelg_irq_ack_r)
59	59	{
60		device_set_input_line(&space.device(), 0, CLEAR_LINE);
	60	space.device().execute().set_input_line(0, CLEAR_LINE);
61	61	return 0;
62	62	}
63	63

trunk/src/mame/drivers/seattle.c

r17814	r17815
1150	1150	}
1151	1151
1152	1152	/* eat some time for those which poll this register */
1153		device_eat_cycles(&space.device(), 100);
	1153	space.device().execute().eat_cycles(100);
1154	1154
1155	1155	if (LOG_TIMERS)
1156	1156	logerror("%08X:hires_timer_r = %08X\n", space.device().safe_pc(), result);
r17814	r17815
1371	1371	m_cpu_stalled_mem_mask = mem_mask;
1372	1372
1373	1373	/* spin until we send the magic trigger */
1374		device_spin_until_trigger(&space.device(), 45678);
	1374	space.device().execute().spin_until_trigger(45678);
1375	1375	if (LOG_DMA) logerror("%08X:Stalling CPU on voodoo (already stalled)\n", space.device().safe_pc());
1376	1376	}
1377	1377
r17814	r17815
1393	1393	else
1394	1394	{
1395	1395	if (LOG_DMA) logerror("%08X:Stalling CPU on voodoo\n", device->machine().device("maincpu")->safe_pc());
1396		device_spin_until_trigger(device->machine().device("maincpu"), 45678);
	1396	device->machine().device("maincpu")->execute().spin_until_trigger(45678);
1397	1397	}
1398	1398	}
1399	1399
r17814	r17815
1672	1672
1673	1673	WRITE32_MEMBER(seattle_state::seattle_watchdog_w)
1674	1674	{
1675		device_eat_cycles(&space.device(), 100);
	1675	space.device().execute().eat_cycles(100);
1676	1676	}
1677	1677
1678	1678
r17814	r17815
1786	1786	device_t *device = machine().device("ide");
1787	1787	/* note that blitz times out if we don't have this cycle stealing */
1788	1788	if (offset == 0x3f6/4)
1789		device_eat_cycles(machine().device("maincpu"), 100);
	1789	machine().device("maincpu")->execute().eat_cycles(100);
1790	1790	return ide_controller32_r(device, offset, mem_mask);
1791	1791	}
1792	1792

trunk/src/mame/drivers/galastrm.c

r17814	r17815
52	52	{
53	53	galastrm_state *state = device->machine().driver_data<galastrm_state>();
54	54	state->m_frame_counter ^= 1;
55		device_set_input_line(device, 5, HOLD_LINE);
	55	device->execute().set_input_line(5, HOLD_LINE);
56	56	}
57	57
58	58	static TIMER_CALLBACK( galastrm_interrupt6 )

trunk/src/mame/drivers/tetrisp2.c

r17814	r17815
566	566
567	567	state->soundlatch_word_w(space, offset, data, mem_mask);
568	568
569		device_set_input_line(machine().device("sub"), M68K_IRQ_6, HOLD_LINE);
	569	machine().device("sub")->execute().set_input_line(M68K_IRQ_6, HOLD_LINE);
570	570
571	571	machine().scheduler().boost_interleave(attotime::zero, attotime::from_usec(100));
572	572	}

trunk/src/mame/drivers/alpha68k.c

r17814	r17815
315	315	if (ACCESSING_BITS_0_7)
316	316	{
317	317	soundlatch_byte_w(space, 0, data);
318		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	318	m_audiocpu->set_input_line(0, HOLD_LINE);
319	319	}
320	320	}
321	321
r17814	r17815
324	324	if (ACCESSING_BITS_0_7)
325	325	{
326	326	soundlatch_byte_w(space, 0, data);
327		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	327	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
328	328	}
329	329	}
330	330	//ZT
r17814	r17815
1851	1851	static void YM3812_irq( device_t *device, int param )
1852	1852	{
1853	1853	alpha68k_state *state = device->machine().driver_data<alpha68k_state>();
1854		device_set_input_line(state->m_audiocpu, 0, (param) ? HOLD_LINE : CLEAR_LINE);
	1854	state->m_audiocpu->set_input_line(0, (param) ? HOLD_LINE : CLEAR_LINE);
1855	1855	}
1856	1856
1857	1857	static const ym3812_interface ym3812_config =
r17814	r17815
1867	1867	{
1868	1868	alpha68k_state *state = machine.driver_data<alpha68k_state>();
1869	1869
1870		state->m_audiocpu = machine.device("audiocpu");
	1870	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
1871	1871
1872	1872	state->save_item(NAME(state->m_trigstate));
1873	1873	state->save_item(NAME(state->m_deposits1));
r17814	r17815
2128	2128	alpha68k_state *state = device->machine().driver_data<alpha68k_state>();
2129	2129
2130	2130	if(state->m_sound_nmi_mask)
2131		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	2131	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
2132	2132	}
2133	2133
2134	2134	static MACHINE_CONFIG_START( alpha68k_II, alpha68k_state )

trunk/src/mame/drivers/tmaster.c

r17814	r17815
907	907	int scanline = param;
908	908
909	909	if(scanline == 0) // vblank, FIXME
910		device_set_input_line(state->m_maincpu, 3, HOLD_LINE);
	910	state->m_maincpu->set_input_line(3, HOLD_LINE);
911	911	else if((scanline % 16) == 0)
912		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	912	state->m_maincpu->set_input_line(1, HOLD_LINE);
913	913
914	914	// lev 2 triggered at the end of the blit
915	915	}

trunk/src/mame/drivers/namcos22.c

r17814	r17815
1356	1356	InitDSP( running_machine &machine )
1357	1357	{
1358	1358	namcos22_state *state = machine.driver_data<namcos22_state>();
1359		device_set_input_line(state->m_master, INPUT_LINE_RESET, ASSERT_LINE); /* master DSP */
1360		device_set_input_line(state->m_slave, INPUT_LINE_RESET, ASSERT_LINE); /* slave DSP */
1361		device_set_input_line(state->m_mcu, INPUT_LINE_RESET, ASSERT_LINE); /* MCU */
	1359	state->m_master->set_input_line(INPUT_LINE_RESET, ASSERT_LINE); /* master DSP */
	1360	state->m_slave->set_input_line(INPUT_LINE_RESET, ASSERT_LINE); /* slave DSP */
	1361	state->m_mcu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE); /* MCU */
1362	1362	} /* InitDSP */
1363	1363
1364	1364	READ16_MEMBER(namcos22_state::pdp_status_r)
r17814	r17815
1513	1513	static void HaltSlaveDSP( running_machine &machine )
1514	1514	{
1515	1515	namcos22_state *state = machine.driver_data<namcos22_state>();
1516		device_set_input_line(state->m_slave, INPUT_LINE_RESET, ASSERT_LINE);
	1516	state->m_slave->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
1517	1517	namcos22_enable_slave_simulation(machine, 0);
1518	1518	}
1519	1519
1520	1520	static void EnableSlaveDSP( running_machine &machine )
1521	1521	{
1522	1522	//  namcos22_state *state = machine.driver_data<namcos22_state>();
1523		//  device_set_input_line(state->m_slave, INPUT_LINE_RESET, CLEAR_LINE);
	1523	//  state->m_slave->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
1524	1524	namcos22_enable_slave_simulation(machine, 1);
1525	1525	}
1526	1526
r17814	r17815
1693	1693	state->m_mSerialDataSlaveToMasterCurrent = state->m_mSerialDataSlaveToMasterNext;
1694	1694
1695	1695	if(scanline == 480)
1696		device_set_input_line(state->m_master, TMS32025_INT0, HOLD_LINE);
	1696	state->m_master->set_input_line(TMS32025_INT0, HOLD_LINE);
1697	1697	else if((scanline % 2) == 0)
1698	1698	{
1699		device_set_input_line(state->m_master, TMS32025_RINT, HOLD_LINE);
1700		device_set_input_line(state->m_master, TMS32025_XINT, HOLD_LINE);
	1699	state->m_master->set_input_line(TMS32025_RINT, HOLD_LINE);
	1700	state->m_master->set_input_line(TMS32025_XINT, HOLD_LINE);
1701	1701	}
1702	1702	}
1703	1703	}
r17814	r17815
1711	1711	{
1712	1712	if((scanline % 2) == 0)
1713	1713	{
1714		device_set_input_line(state->m_slave, TMS32025_RINT, HOLD_LINE);
1715		device_set_input_line(state->m_slave, TMS32025_XINT, HOLD_LINE);
	1714	state->m_slave->set_input_line(TMS32025_RINT, HOLD_LINE);
	1715	state->m_slave->set_input_line(TMS32025_XINT, HOLD_LINE);
1716	1716	}
1717	1717	}
1718	1718	}
r17814	r17815
2109	2109	{
2110	2110	// vblank
2111	2111	m_irq_state &= ~1;
2112		device_set_input_line(m_maincpu, nthbyte(m_system_controller, 0x00) & 7, CLEAR_LINE);
	2112	m_maincpu->set_input_line(nthbyte(m_system_controller, 0x00) & 7, CLEAR_LINE);
2113	2113	}
2114	2114
2115	2115	// irq level / enable irqs
r17814	r17815
2120	2120	newreg = data >> 24 & 7;
2121	2121	if (m_irq_state & 1 && oldreg != newreg)
2122	2122	{
2123		device_set_input_line(m_maincpu, oldreg, CLEAR_LINE);
	2123	m_maincpu->set_input_line(oldreg, CLEAR_LINE);
2124	2124	if (newreg)
2125		device_set_input_line(m_maincpu, newreg, ASSERT_LINE);
	2125	m_maincpu->set_input_line(newreg, ASSERT_LINE);
2126	2126	else
2127	2127	m_irq_state &= ~1;
2128	2128	}
r17814	r17815
2132	2132	if (offset == 0x16/4 && mem_mask & 0x0000ff00)
2133	2133	{
2134	2134	if (data & 0x0000ff00)
2135		device_set_input_line(m_mcu, INPUT_LINE_RESET, CLEAR_LINE);
	2135	m_mcu->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
2136	2136	else
2137		device_set_input_line(m_mcu, INPUT_LINE_RESET, ASSERT_LINE);
	2137	m_mcu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
2138	2138	}
2139	2139
2140	2140	// dsp control
r17814	r17815
2146	2146	{
2147	2147	if( newreg == 0 )
2148	2148	{ /* disable DSPs */
2149		device_set_input_line(m_master, INPUT_LINE_RESET, ASSERT_LINE); /* master DSP */
2150		device_set_input_line(m_slave, INPUT_LINE_RESET, ASSERT_LINE); /* slave DSP */
	2149	m_master->set_input_line(INPUT_LINE_RESET, ASSERT_LINE); /* master DSP */
	2150	m_slave->set_input_line(INPUT_LINE_RESET, ASSERT_LINE); /* slave DSP */
2151	2151	namcos22_enable_slave_simulation(machine(), 0);
2152	2152	m_mbEnableDspIrqs = 0;
2153	2153	}
2154	2154	else if( newreg == 1 )
2155	2155	{ /* enable dsp and rendering subsystem */
2156		device_set_input_line(m_master, INPUT_LINE_RESET, CLEAR_LINE);
	2156	m_master->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
2157	2157	namcos22_enable_slave_simulation(machine(), 1);
2158	2158	m_mbEnableDspIrqs = 1;
2159	2159	}
2160	2160	else if( newreg == 0xff )
2161	2161	{ /* used to upload game-specific code to master/slave dsps */
2162		device_set_input_line(m_master, INPUT_LINE_RESET, CLEAR_LINE);
	2162	m_master->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
2163	2163	m_mbEnableDspIrqs = 0;
2164	2164	}
2165	2165	}
r17814	r17815
2189	2189	{
2190	2190	// vblank irq
2191	2191	state->m_irq_state |= 1;
2192		device_set_input_line(device, nthbyte(state->m_system_controller, 0x00) & 7, ASSERT_LINE);
	2192	device->execute().set_input_line(nthbyte(state->m_system_controller, 0x00) & 7, ASSERT_LINE);
2193	2193	}
2194	2194	}
2195	2195
r17814	r17815
2239	2239	{
2240	2240	// vblank
2241	2241	m_irq_state &= ~1;
2242		device_set_input_line(m_maincpu, nthbyte(m_system_controller, 0x04) & 7, CLEAR_LINE);
	2242	m_maincpu->set_input_line(nthbyte(m_system_controller, 0x04) & 7, CLEAR_LINE);
2243	2243	}
2244	2244
2245	2245	// irq level / enable irqs
r17814	r17815
2250	2250	newreg = data >> 24 & 7;
2251	2251	if (m_irq_state & 1 && oldreg != newreg)
2252	2252	{
2253		device_set_input_line(m_maincpu, oldreg, CLEAR_LINE);
	2253	m_maincpu->set_input_line(oldreg, CLEAR_LINE);
2254	2254	if (newreg)
2255		device_set_input_line(m_maincpu, newreg, ASSERT_LINE);
	2255	m_maincpu->set_input_line(newreg, ASSERT_LINE);
2256	2256	else
2257	2257	m_irq_state &= ~1;
2258	2258	}
r17814	r17815
2262	2262	if (offset == 0x1a/4 && mem_mask & 0xff000000)
2263	2263	{
2264	2264	if (data & 0xff000000)
2265		device_set_input_line(m_mcu, INPUT_LINE_RESET, CLEAR_LINE);
	2265	m_mcu->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
2266	2266	else
2267		device_set_input_line(m_mcu, INPUT_LINE_RESET, ASSERT_LINE);
	2267	m_mcu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
2268	2268	}
2269	2269
2270	2270	// dsp control
r17814	r17815
2276	2276	{
2277	2277	if( newreg == 0 )
2278	2278	{ /* disable DSPs */
2279		device_set_input_line(m_master, INPUT_LINE_RESET, ASSERT_LINE); /* master DSP */
2280		device_set_input_line(m_slave, INPUT_LINE_RESET, ASSERT_LINE); /* slave DSP */
	2279	m_master->set_input_line(INPUT_LINE_RESET, ASSERT_LINE); /* master DSP */
	2280	m_slave->set_input_line(INPUT_LINE_RESET, ASSERT_LINE); /* slave DSP */
2281	2281	namcos22_enable_slave_simulation(machine(), 0);
2282	2282	m_mbEnableDspIrqs = 0;
2283	2283	}
2284	2284	else if( newreg == 1 )
2285	2285	{ /* enable dsp and rendering subsystem */
2286		device_set_input_line(m_master, INPUT_LINE_RESET, CLEAR_LINE);
	2286	m_master->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
2287	2287	namcos22_enable_slave_simulation(machine(), 1);
2288	2288	m_mbEnableDspIrqs = 1;
2289	2289	}
2290	2290	else if( newreg == 0xff )
2291	2291	{ /* used to upload game-specific code to master/slave dsps */
2292		device_set_input_line(m_master, INPUT_LINE_RESET, CLEAR_LINE);
	2292	m_master->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
2293	2293	m_mbEnableDspIrqs = 0;
2294	2294	}
2295	2295	}
r17814	r17815
2369	2369	{
2370	2370	// vblank irq
2371	2371	state->m_irq_state |= 1;
2372		device_set_input_line(device, nthbyte(state->m_system_controller, 0x04) & 7, ASSERT_LINE);
	2372	device->execute().set_input_line(nthbyte(state->m_system_controller, 0x04) & 7, ASSERT_LINE);
2373	2373	}
2374	2374	}
2375	2375
r17814	r17815
2930	2930
2931	2931	/* TODO: real sources of these */
2932	2932	if(scanline == 480)
2933		device_set_input_line(state->m_mcu, M37710_LINE_IRQ0, HOLD_LINE);
	2933	state->m_mcu->set_input_line(M37710_LINE_IRQ0, HOLD_LINE);
2934	2934	else if(scanline == 500)
2935		device_set_input_line(state->m_mcu, M37710_LINE_ADC, HOLD_LINE);
	2935	state->m_mcu->set_input_line(M37710_LINE_ADC, HOLD_LINE);
2936	2936	else if(scanline == 0)
2937		device_set_input_line(state->m_mcu, M37710_LINE_IRQ2, HOLD_LINE);
	2937	state->m_mcu->set_input_line(M37710_LINE_IRQ2, HOLD_LINE);
2938	2938	}
2939	2939
2940	2940	static MACHINE_RESET(namcos22)
r17814	r17815
5411	5411	{
5412	5412	if ((space.device().safe_pc() == 0xc12d) && (!(m_su_82 & 0xff00)))
5413	5413	{
5414		device_spin_until_interrupt(&space.device());
	5414	space.device().execute().spin_until_interrupt();
5415	5415	}
5416	5416
5417	5417	return m_su_82;
r17814	r17815
5427	5427	{
5428	5428	if ((space.device().safe_pc() == 0xc12a) && (!(m_su_82 & 0xff00)))
5429	5429	{
5430		device_spin_until_interrupt(&space.device());
	5430	space.device().execute().spin_until_interrupt();
5431	5431	}
5432	5432
5433	5433	return m_su_82;
r17814	r17815
5438	5438	{
5439	5439	if (((space.device().safe_pc() == 0xc0df) || (space.device().safe_pc() == 0xc101)) && (!(m_su_82 & 0xff00)))
5440	5440	{
5441		device_spin_until_interrupt(&space.device());
	5441	space.device().execute().spin_until_interrupt();
5442	5442	}
5443	5443
5444	5444	return m_su_82;

trunk/src/mame/drivers/flyball.c

r17814	r17815
43	43	UINT8    m_potsense;
44	44
45	45	/* devices */
46		device_t *m_maincpu;
	46	cpu_device *m_maincpu;
47	47	DECLARE_READ8_MEMBER(flyball_input_r);
48	48	DECLARE_READ8_MEMBER(flyball_scanline_r);
49	49	DECLARE_READ8_MEMBER(flyball_potsense_r);
r17814	r17815
373	373	{
374	374	flyball_state *state = machine.driver_data<flyball_state>();
375	375
376		state->m_maincpu = machine.device("maincpu");
	376	state->m_maincpu = machine.device<cpu_device>("maincpu");
377	377
378	378	state->save_item(NAME(state->m_pitcher_vert));
379	379	state->save_item(NAME(state->m_pitcher_horz));

trunk/src/mame/drivers/galaxold.c

r17814	r17815
2389	2389	galaxold_state *state = device->machine().driver_data<galaxold_state>();
2390	2390
2391	2391	if(state->m_nmi_mask)
2392		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	2392	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
2393	2393	}
2394	2394
2395	2395	static MACHINE_CONFIG_DERIVED( harem, galaxold_base )

trunk/src/mame/drivers/unkhorse.c

r17814	r17815
192	192
193	193	static INTERRUPT_GEN( horse_interrupt )
194	194	{
195		device_set_input_line(device, I8085_RST75_LINE, ASSERT_LINE);
196		device_set_input_line(device, I8085_RST75_LINE, CLEAR_LINE);
	195	device->execute().set_input_line(I8085_RST75_LINE, ASSERT_LINE);
	196	device->execute().set_input_line(I8085_RST75_LINE, CLEAR_LINE);
197	197	}
198	198
199	199	static MACHINE_CONFIG_START( horse, horse_state )

trunk/src/mame/drivers/pturn.c

r17814	r17815
463	463	pturn_state *state = device->machine().driver_data<pturn_state>();
464	464	if(state->m_nmi_sub)
465	465	{
466		device_set_input_line(device,INPUT_LINE_NMI,PULSE_LINE);
	466	device->execute().set_input_line(INPUT_LINE_NMI,PULSE_LINE);
467	467	}
468	468	}
469	469
r17814	r17815
472	472	pturn_state *state = device->machine().driver_data<pturn_state>();
473	473	if (state->m_nmi_main)
474	474	{
475		device_set_input_line(device,INPUT_LINE_NMI,PULSE_LINE);
	475	device->execute().set_input_line(INPUT_LINE_NMI,PULSE_LINE);
476	476	}
477	477	}
478	478

trunk/src/mame/drivers/ssv.c

r17814	r17815
325	325	{
326	326	ssv_state *state = machine.driver_data<ssv_state>();
327	327	state->m_requested_int = 0;
328		device_set_irq_callback(machine.device("maincpu"), ssv_irq_callback);
	328	machine.device("maincpu")->execute().set_irq_acknowledge_callback(ssv_irq_callback);
329	329	state->membank("bank1")->set_base(state->memregion("user1")->base());
330	330	}
331	331

trunk/src/mame/drivers/jubilee.c

r17814	r17815
154	154	static INTERRUPT_GEN( jubileep_interrupt )
155	155	{
156	156	/* doesn't seems to work properly. need to set level1 interrupts */
157		device_set_input_line_and_vector(device, 0, ASSERT_LINE, 3);//2=nmi  3,4,5,6
	157	device->execute().set_input_line_and_vector(0, ASSERT_LINE, 3);//2=nmi  3,4,5,6
158	158	}
159	159
160	160

trunk/src/mame/drivers/cop01.c

r17814	r17815
73	73	WRITE8_MEMBER(cop01_state::cop01_sound_command_w)
74	74	{
75	75	soundlatch_byte_w(space, offset, data);
76		device_set_input_line(m_audiocpu, 0, ASSERT_LINE );
	76	m_audiocpu->set_input_line(0, ASSERT_LINE );
77	77	}
78	78
79	79	READ8_MEMBER(cop01_state::cop01_sound_command_r)
r17814	r17815
104	104	WRITE8_MEMBER(cop01_state::cop01_irq_ack_w)
105	105	{
106	106
107		device_set_input_line(m_maincpu, 0, CLEAR_LINE );
	107	m_maincpu->set_input_line(0, CLEAR_LINE );
108	108	}
109	109
110	110	READ8_MEMBER(cop01_state::cop01_sound_irq_ack_w)
111	111	{
112	112
113		device_set_input_line(m_audiocpu, 0, CLEAR_LINE );
	113	m_audiocpu->set_input_line(0, CLEAR_LINE );
114	114	return 0;
115	115	}
116	116

trunk/src/mame/drivers/circusc.c

r17814	r17815
95	95
96	96	WRITE8_MEMBER(circusc_state::circusc_sh_irqtrigger_w)
97	97	{
98		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	98	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
99	99	}
100	100
101	101	WRITE8_MEMBER(circusc_state::circusc_coin_counter_w)
r17814	r17815
352	352	circusc_state *state = device->machine().driver_data<circusc_state>();
353	353
354	354	if(state->m_irq_mask)
355		device_set_input_line(device, 0, HOLD_LINE);
	355	device->execute().set_input_line(0, HOLD_LINE);
356	356	}
357	357
358	358	static MACHINE_CONFIG_START( circusc, circusc_state )

trunk/src/mame/drivers/mikie.c

r17814	r17815
70	70	if (m_last_irq == 0 && data == 1)
71	71	{
72	72	// setting bit 0 low then high triggers IRQ on the sound CPU
73		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	73	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
74	74	}
75	75
76	76	m_last_irq = data;
r17814	r17815
271	271	mikie_state *state = device->machine().driver_data<mikie_state>();
272	272
273	273	if(state->m_irq_mask)
274		device_set_input_line(device, 0, HOLD_LINE);
	274	device->execute().set_input_line(0, HOLD_LINE);
275	275	}
276	276
277	277	static MACHINE_CONFIG_START( mikie, mikie_state )

trunk/src/mame/drivers/midvunit.c

r17814	r17815
1720	1720
1721	1721	READ32_MEMBER(midvunit_state::generic_speedup_r)
1722	1722	{
1723		device_eat_cycles(&space.device(), 100);
	1723	space.device().execute().eat_cycles(100);
1724	1724	return m_generic_speedup[offset];
1725	1725	}
1726	1726

trunk/src/mame/drivers/kingpin.c

r17814	r17815
56	56	WRITE8_MEMBER(kingpin_state::sound_nmi_w)
57	57	{
58	58	soundlatch_byte_w(space, 0, data);
59		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	59	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
60	60	}
61	61
62	62	static ADDRESS_MAP_START( kingpin_program_map, AS_PROGRAM, 8, kingpin_state )
r17814	r17815
144	144
145	145	WRITE_LINE_MEMBER(kingpin_state::vdp_interrupt)
146	146	{
147		device_set_input_line(m_maincpu, 0, state ? ASSERT_LINE : CLEAR_LINE);
	147	m_maincpu->set_input_line(0, state ? ASSERT_LINE : CLEAR_LINE);
148	148	}
149	149
150	150	static TMS9928A_INTERFACE(kingpin_tms9928a_interface)

trunk/src/mame/drivers/opwolf.c

r17814	r17815
693	693	static void irq_handler( device_t *device, int irq )
694	694	{
695	695	opwolf_state *state = device->machine().driver_data<opwolf_state>();
696		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	696	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
697	697	}
698	698
699	699

trunk/src/mame/drivers/pangofun.c

r17814	r17815
187	187
188	188	static MACHINE_START( pangofun )
189	189	{
190		device_set_irq_callback(machine.device("maincpu"), pcat_irq_callback);
	190	machine.device("maincpu")->execute().set_irq_acknowledge_callback(pcat_irq_callback);
191	191	init_pc_common(machine, PCCOMMON_KEYBOARD_AT, pangofun_set_keyb_int);
192	192	kbdc8042_init(machine, &at8042);
193	193	}

trunk/src/mame/drivers/suna16.c

r17814	r17815
760	760	int scanline = param;
761	761
762	762	if(scanline == 240)
763		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	763	state->m_maincpu->set_input_line(1, HOLD_LINE);
764	764
765	765	if(scanline == 0)
766		device_set_input_line(state->m_maincpu, 2, HOLD_LINE); // does RAM to sprite buffer copy here
	766	state->m_maincpu->set_input_line(2, HOLD_LINE); // does RAM to sprite buffer copy here
767	767	}
768	768
769	769	static MACHINE_CONFIG_START( bssoccer, suna16_state )

trunk/src/mame/drivers/firebeat.c

r17814	r17815
1941	1941	// IRQ 2: Main board UART
1942	1942	// IRQ 4: ATAPI
1943	1943
1944		device_set_input_line(device, INPUT_LINE_IRQ0, ASSERT_LINE);
	1944	device->execute().set_input_line(INPUT_LINE_IRQ0, ASSERT_LINE);
1945	1945	}
1946	1946
1947	1947	static MACHINE_RESET( firebeat )

trunk/src/mame/drivers/bigevglf.c

r17814	r17815
112	112	bigevglf_state *state = machine.driver_data<bigevglf_state>();
113	113
114	114	if (state->m_sound_nmi_enable)
115		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	115	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
116	116	else
117	117	state->m_pending_nmi = 1;
118	118	state->m_sound_state &= ~1;
r17814	r17815
140	140	m_sound_nmi_enable = 1;
141	141	if (m_pending_nmi)
142	142	{
143		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	143	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
144	144	m_pending_nmi = 0;
145	145	}
146	146	}
r17814	r17815
420	420	{
421	421	bigevglf_state *state = machine.driver_data<bigevglf_state>();
422	422
423		state->m_audiocpu = machine.device("audiocpu");
	423	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
424	424	state->m_mcu = machine.device("mcu");
425	425
426	426	state->save_item(NAME(state->m_vidram_bank));

trunk/src/mame/drivers/bagman.c

r17814	r17815
467	467	bagman_state *state = device->machine().driver_data<bagman_state>();
468	468
469	469	if(state->m_irq_mask)
470		device_set_input_line(device, 0, HOLD_LINE);
	470	device->execute().set_input_line(0, HOLD_LINE);
471	471	}
472	472
473	473

trunk/src/mame/drivers/inufuku.c

r17814	r17815
91	91
92	92	m_pending_command = 1;
93	93	soundlatch_byte_w(space, 0, data & 0xff);
94		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	94	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
95	95	}
96	96	}
97	97
r17814	r17815
296	296	static void irqhandler( device_t *device, int irq )
297	297	{
298	298	inufuku_state *state = device->machine().driver_data<inufuku_state>();
299		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	299	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
300	300	}
301	301
302	302	static const ym2610_interface ym2610_config =
r17814	r17815
319	319	state->membank("bank1")->configure_entries(0, 4, &ROM[0x10000], 0x8000);
320	320	state->membank("bank1")->set_entry(0);
321	321
322		state->m_audiocpu = machine.device("audiocpu");
	322	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
323	323
324	324	state->save_item(NAME(state->m_pending_command));
325	325	state->save_item(NAME(state->m_bg_scrollx));

trunk/src/mame/drivers/cbuster.c

r17814	r17815
40	40
41	41	case 2: /* Sound CPU write */
42	42	soundlatch_byte_w(space, 0, data & 0xff);
43		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	43	m_audiocpu->set_input_line(0, HOLD_LINE);
44	44	return;
45	45
46	46	case 4: /* Protection, maybe this is a PAL on the board?
r17814	r17815
265	265	static void sound_irq(device_t *device, int state)
266	266	{
267	267	cbuster_state *driver_state = device->machine().driver_data<cbuster_state>();
268		device_set_input_line(driver_state->m_audiocpu, 1, state); /* IRQ 2 */
	268	driver_state->m_audiocpu->set_input_line(1, state); /* IRQ 2 */
269	269	}
270	270
271	271	static const ym2151_interface ym2151_config =
r17814	r17815
306	306	{
307	307	cbuster_state *state = machine.driver_data<cbuster_state>();
308	308
309		state->m_maincpu = machine.device("maincpu");
310		state->m_audiocpu = machine.device("audiocpu");
	309	state->m_maincpu = machine.device<cpu_device>("maincpu");
	310	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
311	311	state->m_deco_tilegen1 = machine.device("tilegen1");
312	312	state->m_deco_tilegen2 = machine.device("tilegen2");
313	313

trunk/src/mame/drivers/ghosteo.c

r17814	r17815
565	565	if (pc == 0x3001c0e4 || pc == 0x3001c0d8)
566	566	{
567	567	// BnB Arcade
568		device_spin_until_time(&space.device(), attotime::from_usec(20));
	568	space.device().execute().spin_until_time(attotime::from_usec(20));
569	569	}
570	570	else if (pc == 0x3002b580 || pc == 0x3002b550)
571	571	{
572	572	// Happy Tour
573		device_spin_until_time(&space.device(), attotime::from_usec(20));
	573	space.device().execute().spin_until_time(attotime::from_usec(20));
574	574	}
575	575	//else
576	576	//  printf("speedup %08x %08x\n", pc, ret);

trunk/src/mame/drivers/ojankohs.c

r17814	r17815
89	89
90	90	/* generate an NMI if we're out of data */
91	91	if (!state->m_vclk_left)
92		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	92	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
93	93	}
94	94
95	95	WRITE8_MEMBER(ojankohs_state::ojankoc_ctrl_w)
r17814	r17815
793	793	{
794	794	ojankohs_state *state = machine.driver_data<ojankohs_state>();
795	795
796		state->m_maincpu = machine.device("maincpu");
	796	state->m_maincpu = machine.device<cpu_device>("maincpu");
797	797	state->m_msm = machine.device("msm");
798	798
799	799	state->save_item(NAME(state->m_gfxreg));

trunk/src/mame/drivers/n8080.c

r17814	r17815
434	434	int state = n8080->m_inte ? ASSERT_LINE : CLEAR_LINE;
435	435
436	436	/* V7 = 1, V6 = 0 */
437		device_set_input_line_and_vector(n8080->m_maincpu, INPUT_LINE_IRQ0, state, 0xcf);
	437	n8080->m_maincpu->set_input_line_and_vector(INPUT_LINE_IRQ0, state, 0xcf);
438	438	}
439	439
440	440	static TIMER_DEVICE_CALLBACK( rst2_tick )
r17814	r17815
443	443	int state = n8080->m_inte ? ASSERT_LINE : CLEAR_LINE;
444	444
445	445	/* vblank */
446		device_set_input_line_and_vector(n8080->m_maincpu, INPUT_LINE_IRQ0, state, 0xd7);
	446	n8080->m_maincpu->set_input_line_and_vector(INPUT_LINE_IRQ0, state, 0xd7);
447	447	}
448	448
449	449	WRITE_LINE_MEMBER(n8080_state::n8080_inte_callback)
r17814	r17815
457	457	if (data & I8085_STATUS_INTA)
458	458	{
459	459	/* interrupt acknowledge */
460		device_set_input_line(device, INPUT_LINE_IRQ0, CLEAR_LINE);
	460	device->execute().set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
461	461	}
462	462	}
463	463
r17814	r17815
473	473	{
474	474	n8080_state *state = machine.driver_data<n8080_state>();
475	475
476		state->m_maincpu = machine.device("maincpu");
	476	state->m_maincpu = machine.device<cpu_device>("maincpu");
477	477
478	478	state->save_item(NAME(state->m_shift_data));
479	479	state->save_item(NAME(state->m_shift_bits));

trunk/src/mame/drivers/kncljoe.c

r17814	r17815
39	39	if ((data & 0x80) == 0)
40	40	soundlatch_byte_w(space, 0, data & 0x7f);
41	41	else
42		device_set_input_line(m_soundcpu, 0, ASSERT_LINE);
	42	m_soundcpu->set_input_line(0, ASSERT_LINE);
43	43	}
44	44
45	45
r17814	r17815
97	97
98	98	WRITE8_MEMBER(kncljoe_state::sound_irq_ack_w)
99	99	{
100		device_set_input_line(m_soundcpu, 0, CLEAR_LINE);
	100	m_soundcpu->set_input_line(0, CLEAR_LINE);
101	101	}
102	102
103	103	WRITE8_MEMBER(kncljoe_state::unused_w)
r17814	r17815
259	259
260	260	static INTERRUPT_GEN (sound_nmi)
261	261	{
262		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	262	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
263	263	}
264	264
265	265	static MACHINE_START( kncljoe )
266	266	{
267	267	kncljoe_state *state = machine.driver_data<kncljoe_state>();
268	268
269		state->m_soundcpu = machine.device("soundcpu");
	269	state->m_soundcpu = machine.device<cpu_device>("soundcpu");
270	270
271	271	state->save_item(NAME(state->m_port1));
272	272	state->save_item(NAME(state->m_port2));

trunk/src/mame/drivers/3do.c

r17814	r17815
133	133	{
134	134	_3do_state *state = machine.driver_data<_3do_state>();
135	135
136		state->m_maincpu = downcast<legacy_cpu_device*>( machine.device("maincpu") );
	136	state->m_maincpu = downcast<legacy_cpu_device*>( machine.device<cpu_device>("maincpu") );
137	137
138	138	state->membank("bank2")->set_base(state->memregion("user1")->base());
139	139

trunk/src/mame/drivers/deco_ld.c

r17814	r17815
249	249	WRITE8_MEMBER(deco_ld_state::decold_sound_cmd_w)
250	250	{
251	251	soundlatch_byte_w(space, 0, data);
252		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	252	m_audiocpu->set_input_line(0, HOLD_LINE);
253	253	}
254	254
255	255	/* same as Burger Time HW */
r17814	r17815
297	297	static INTERRUPT_GEN ( sound_interrupt )
298	298	{
299	299	deco_ld_state *state = device->machine().driver_data<deco_ld_state>();
300		if (!state->m_nmimask) device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	300	if (!state->m_nmimask) device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
301	301	}
302	302
303	303
r17814	r17815
318	318
319	319	INPUT_CHANGED_MEMBER(deco_ld_state::coin_inserted)
320	320	{
321		device_set_input_line(m_maincpu, INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
	321	m_maincpu->set_input_line(INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
322	322	}
323	323
324	324	static INPUT_PORTS_START( begas )

trunk/src/mame/drivers/turbo.c

r17814	r17815
393	393	/* bit   6 = /IOREQ on the 2nd CPU */
394	394	/* bit   7 = /INT on the 2nd CPU */
395	395	m_buckrog_fchg = data & 0x07;
396		device_set_input_line(m_subcpu, 0, (data & 0x80) ? CLEAR_LINE : ASSERT_LINE);
	396	m_subcpu->set_input_line(0, (data & 0x80) ? CLEAR_LINE : ASSERT_LINE);
397	397	}
398	398
399	399

trunk/src/mame/drivers/cvs.c

r17814	r17815
228	228
229	229	static INTERRUPT_GEN( cvs_main_cpu_interrupt )
230	230	{
231		device_set_input_line_vector(device, 0, 0x03);
	231	device->execute().set_input_line_vector(0, 0x03);
232	232	generic_pulse_irq_line(device, 0, 1);
233	233
234	234	cvs_scroll_stars(device->machine());
r17814	r17815
237	237
238	238	static void cvs_slave_cpu_interrupt( device_t *cpu, int state )
239	239	{
240		device_set_input_line_vector(cpu, 0, 0x03);
241		//device_set_input_line(cpu, 0, state ? ASSERT_LINE : CLEAR_LINE);
242		device_set_input_line(cpu, 0, state ? HOLD_LINE : CLEAR_LINE);
	240	cpu->execute().set_input_line_vector(0, 0x03);
	241	//cpu->execute().set_input_line(0, state ? ASSERT_LINE : CLEAR_LINE);
	242	cpu->execute().set_input_line(0, state ? HOLD_LINE : CLEAR_LINE);
243	243	}
244	244
245	245
r17814	r17815
999	999	start_393hz_timer(machine);
1000	1000
1001	1001	/* set devices */
1002		state->m_maincpu = machine.device("maincpu");
1003		state->m_audiocpu = machine.device("audiocpu");
	1002	state->m_maincpu = machine.device<cpu_device>("maincpu");
	1003	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
1004	1004	state->m_speech = machine.device("speech");
1005	1005	state->m_dac3 = machine.device<dac_device>("dac3");
1006	1006	state->m_tms = machine.device("tms");

trunk/src/mame/drivers/trvquest.c

r17814	r17815
150	150	static TIMER_CALLBACK( via_irq_delayed )
151	151	{
152	152	gameplan_state *state = machine.driver_data<gameplan_state>();
153		device_set_input_line(state->m_maincpu, 0, param);
	153	state->m_maincpu->set_input_line(0, param);
154	154	}
155	155
156	156	static void via_irq( device_t *device, int state )
r17814	r17815
187	187	{
188	188	gameplan_state *state = machine.driver_data<gameplan_state>();
189	189
190		state->m_maincpu = machine.device("maincpu");
	190	state->m_maincpu = machine.device<cpu_device>("maincpu");
191	191
192	192	/* register for save states */
193	193	state->save_item(NAME(state->m_video_x));

trunk/src/mame/drivers/tnzs.c

r17814	r17815
808	808	WRITE8_MEMBER(tnzs_state::tnzsb_sound_command_w)
809	809	{
810	810	soundlatch_byte_w(space, offset, data);
811		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	811	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
812	812	}
813	813
814	814	static ADDRESS_MAP_START( tnzsb_cpu1_map, AS_PROGRAM, 8, tnzs_state )
r17814	r17815
1569	1569	static void irqhandler( device_t *device, int irq )
1570	1570	{
1571	1571	tnzs_state *state = device->machine().driver_data<tnzs_state>();
1572		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, irq ? ASSERT_LINE : CLEAR_LINE);
	1572	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, irq ? ASSERT_LINE : CLEAR_LINE);
1573	1573	}
1574	1574
1575	1575	static const ym2203_interface kageki_ym2203_interface =

trunk/src/mame/drivers/rohga.c

r17814	r17815
118	118	READ16_MEMBER(rohga_state::rohga_irq_ack_r)
119	119	{
120	120
121		device_set_input_line(m_maincpu, 6, CLEAR_LINE);
	121	m_maincpu->set_input_line(6, CLEAR_LINE);
122	122	return 0;
123	123	}
124	124
r17814	r17815
127	127	/* This might actually do more, nitrobal for example sets 0xca->0xffff->0x80 at startup then writes 7 all the time
128	128	except when a credit is inserted (writes 6 twice).
129	129	Wizard Fire / Dark Seal 2 just writes 1 all the time, so I just don't trust it much for now... -AS */
130		device_set_input_line(m_maincpu, 6, CLEAR_LINE);
	130	m_maincpu->set_input_line(6, CLEAR_LINE);
131	131	}
132	132
133	133	/**********************************************************************************/
r17814	r17815
720	720	static void sound_irq(device_t *device, int state)
721	721	{
722	722	rohga_state *driver_state = device->machine().driver_data<rohga_state>();
723		device_set_input_line(driver_state->m_audiocpu, 1, state); /* IRQ 2 */
	723	driver_state->m_audiocpu->set_input_line(1, state); /* IRQ 2 */
724	724	}
725	725
726	726	WRITE8_MEMBER(rohga_state::sound_bankswitch_w)

trunk/src/mame/drivers/plygonet.c

r17814	r17815
156	156	/* irq 7 does nothing (it jsrs to a rts and then rte) */
157	157	static INTERRUPT_GEN(polygonet_interrupt)
158	158	{
159		device_set_input_line(device, M68K_IRQ_5, HOLD_LINE);
	159	device->execute().set_input_line(M68K_IRQ_5, HOLD_LINE);
160	160	}
161	161
162	162	/* sound CPU communications */
r17814	r17815
557	557
558	558	static INTERRUPT_GEN(audio_interrupt)
559	559	{
560		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	560	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
561	561	}
562	562
563	563	static ADDRESS_MAP_START( sound_map, AS_PROGRAM, 8, polygonet_state )

trunk/src/mame/drivers/nemesis.c

r17814	r17815
61	61	nemesis_state *state = device->machine().driver_data<nemesis_state>();
62	62
63	63	if (state->m_irq_on)
64		device_set_input_line(device, 1, HOLD_LINE);
	64	device->execute().set_input_line(1, HOLD_LINE);
65	65	}
66	66
67	67	static INTERRUPT_GEN( blkpnthr_interrupt )
r17814	r17815
69	69	nemesis_state *state = device->machine().driver_data<nemesis_state>();
70	70
71	71	if (state->m_irq_on)
72		device_set_input_line(device, 2, HOLD_LINE);
	72	device->execute().set_input_line(2, HOLD_LINE);
73	73	}
74	74
75	75	static TIMER_DEVICE_CALLBACK( konamigt_interrupt )
r17814	r17815
78	78	int scanline = param;
79	79
80	80	if (scanline == 240 && state->m_irq_on && (timer.machine().primary_screen->frame_number() & 1) == 0)
81		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	81	state->m_maincpu->set_input_line(1, HOLD_LINE);
82	82
83	83	if (scanline == 0 && state->m_irq2_on)
84		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	84	state->m_maincpu->set_input_line(2, HOLD_LINE);
85	85	}
86	86
87	87	static TIMER_DEVICE_CALLBACK( gx400_interrupt )
r17814	r17815
90	90	int scanline = param;
91	91
92	92	if (scanline == 240 && state->m_irq1_on && (timer.machine().primary_screen->frame_number() & 1) == 0)
93		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	93	state->m_maincpu->set_input_line(1, HOLD_LINE);
94	94
95	95	if (scanline == 0 && state->m_irq2_on)
96		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	96	state->m_maincpu->set_input_line(2, HOLD_LINE);
97	97
98	98	if (scanline == 120 && state->m_irq4_on)
99		device_set_input_line(state->m_maincpu, 4, HOLD_LINE);
	99	state->m_maincpu->set_input_line(4, HOLD_LINE);
100	100	}
101	101
102	102
r17814	r17815
1490	1490	{
1491	1491	/* Interrupts _are_ generated, I wonder where they go.. */
1492	1492	// nemesis_state *driver_state = device->machine().driver_data<nemesis_state>();
1493		// device_set_input_line(driver_state->audiocpu, 0, HOLD_LINE);
	1493	// driver_state->audiocpu->set_input_line(0, HOLD_LINE);
1494	1494	}
1495	1495
1496	1496	static const ym2151_interface ym2151_config =

trunk/src/mame/drivers/jackie.c

r17814	r17815
566	566	return;
567	567
568	568	if((scanline % 64) == 32 && state->m_irq_enable)
569		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	569	state->m_maincpu->set_input_line(0, HOLD_LINE);
570	570	else if   ((scanline % 64) == 0 && state->m_nmi_enable)
571		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	571	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
572	572	}
573	573
574	574	static MACHINE_CONFIG_START( jackie, jackie_state )

trunk/src/mame/drivers/warriorb.c

r17814	r17815
427	427	static void irqhandler( device_t *device, int irq )
428	428	{
429	429	warriorb_state *state = device->machine().driver_data<warriorb_state>();
430		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	430	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
431	431	}
432	432
433	433	static const ym2610_interface ym2610_config =
r17814	r17815
514	514
515	515	state->membank("bank10")->configure_entries(0, 8, state->memregion("audiocpu")->base() + 0xc000, 0x4000);
516	516
517		state->m_maincpu = machine.device("maincpu");
518		state->m_audiocpu = machine.device("audiocpu");
	517	state->m_maincpu = machine.device<cpu_device>("maincpu");
	518	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
519	519	state->m_tc0140syt = machine.device("tc0140syt");
520	520	state->m_tc0100scn_1 = machine.device("tc0100scn_1");
521	521	state->m_tc0100scn_2 = machine.device("tc0100scn_2");

trunk/src/mame/drivers/goal92.c

r17814	r17815
20	20	if (ACCESSING_BITS_8_15)
21	21	{
22	22	soundlatch_byte_w(space, 0, (data >> 8) & 0xff);
23		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	23	m_audiocpu->set_input_line(0, HOLD_LINE);
24	24	}
25	25	}
26	26
r17814	r17815
213	213	{
214	214	/* NMI writes to MSM ports *only*! -AS */
215	215	//goal92_state *state = device->machine().driver_data<goal92_state>();
216		//device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, irq ? ASSERT_LINE : CLEAR_LINE);
	216	//state->m_audiocpu->set_input_line(INPUT_LINE_NMI, irq ? ASSERT_LINE : CLEAR_LINE);
217	217	}
218	218
219	219	static const ym2203_interface ym2203_config =
r17814	r17815
234	234	state->m_adpcm_toggle^= 1;
235	235
236	236	if (state->m_adpcm_toggle)
237		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	237	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
238	238	}
239	239
240	240	static const msm5205_interface msm5205_config =
r17814	r17815
296	296
297	297	state->membank("bank1")->configure_entries(0, 2, &ROM[0x10000], 0x4000);
298	298
299		state->m_audiocpu = machine.device("audiocpu");
	299	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
300	300
301	301	state->save_item(NAME(state->m_fg_bank));
302	302	state->save_item(NAME(state->m_msm5205next));

trunk/src/mame/drivers/bombjack.c

r17814	r17815
354	354	bombjack_state *state = device->machine().driver_data<bombjack_state>();
355	355
356	356	if(state->m_nmi_mask)
357		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	357	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
358	358	}
359	359
360	360	static MACHINE_CONFIG_START( bombjack, bombjack_state )

trunk/src/mame/drivers/trucocl.c

r17814	r17815
127	127	trucocl_state *state = device->machine().driver_data<trucocl_state>();
128	128
129	129	if(state->m_irq_mask)
130		device_set_input_line(device, 0, HOLD_LINE);
	130	device->execute().set_input_line(0, HOLD_LINE);
131	131
132	132	}
133	133

trunk/src/mame/drivers/blockhl.c

r17814	r17815
35	35	blockhl_state *state = device->machine().driver_data<blockhl_state>();
36	36
37	37	if (k052109_is_irq_enabled(state->m_k052109) && state->m_rombank == 0)   /* kludge to prevent crashes */
38		device_set_input_line(device, KONAMI_IRQ_LINE, HOLD_LINE);
	38	device->execute().set_input_line(KONAMI_IRQ_LINE, HOLD_LINE);
39	39	}
40	40
41	41	READ8_MEMBER(blockhl_state::bankedram_r)
r17814	r17815
58	58
59	59	WRITE8_MEMBER(blockhl_state::blockhl_sh_irqtrigger_w)
60	60	{
61		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	61	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
62	62	}
63	63
64	64
r17814	r17815
193	193
194	194	state->membank("bank1")->configure_entries(0, 4, &ROM[0x10000], 0x2000);
195	195
196		state->m_maincpu = machine.device("maincpu");
197		state->m_audiocpu = machine.device("audiocpu");
	196	state->m_maincpu = machine.device<cpu_device>("maincpu");
	197	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
198	198	state->m_k052109 = machine.device("k052109");
199	199	state->m_k051960 = machine.device("k051960");
200	200

trunk/src/mame/drivers/gcpinbal.c

r17814	r17815
50	50	static TIMER_CALLBACK( gcpinbal_interrupt1 )
51	51	{
52	52	gcpinbal_state *state = machine.driver_data<gcpinbal_state>();
53		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	53	state->m_maincpu->set_input_line(1, HOLD_LINE);
54	54	}
55	55
56	56	#ifdef UNUSED_FUNCTION
r17814	r17815
60	60	// IRQ3 is from the M6585
61	61	//  if (!ADPCM_playing(0))
62	62	{
63		device_set_input_line(state->m_maincpu, 3, HOLD_LINE);
	63	state->m_maincpu->set_input_line(3, HOLD_LINE);
64	64	}
65	65	}
66	66	#endif
r17814	r17815
71	71
72	72	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(500), FUNC(gcpinbal_interrupt1));
73	73	//  device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(1000), FUNC(gcpinbal_interrupt3));
74		device_set_input_line(device, 4, HOLD_LINE);
	74	device->execute().set_input_line(4, HOLD_LINE);
75	75	}
76	76
77	77

trunk/src/mame/drivers/bottom9.c

r17814	r17815
25	25	bottom9_state *state = device->machine().driver_data<bottom9_state>();
26	26
27	27	if (k052109_is_irq_enabled(state->m_k052109))
28		device_set_input_line(device, 0, HOLD_LINE);
	28	device->execute().set_input_line(0, HOLD_LINE);
29	29	}
30	30
31	31	READ8_MEMBER(bottom9_state::k052109_051960_r)
r17814	r17815
135	135
136	136	WRITE8_MEMBER(bottom9_state::bottom9_sh_irqtrigger_w)
137	137	{
138		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	138	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
139	139	}
140	140
141	141	static INTERRUPT_GEN( bottom9_sound_interrupt )
142	142	{
143	143	bottom9_state *state = device->machine().driver_data<bottom9_state>();
144	144	if (state->m_nmienable)
145		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	145	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
146	146	}
147	147
148	148	WRITE8_MEMBER(bottom9_state::nmi_enable_w)
r17814	r17815
326	326
327	327	state->membank("bank1")->configure_entries(0, 12, &ROM[0x10000], 0x2000);
328	328
329		state->m_maincpu = machine.device("maincpu");
330		state->m_audiocpu = machine.device("audiocpu");
	329	state->m_maincpu = machine.device<cpu_device>("maincpu");
	330	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
331	331	state->m_k052109 = machine.device("k052109");
332	332	state->m_k051960 = machine.device("k051960");
333	333	state->m_k051316 = machine.device("k051316");

trunk/src/mame/drivers/megazone.c

r17814	r17815
57	57
58	58	WRITE8_MEMBER(megazone_state::megazone_i8039_irq_w)
59	59	{
60		device_set_input_line(m_daccpu, 0, ASSERT_LINE);
	60	m_daccpu->set_input_line(0, ASSERT_LINE);
61	61	}
62	62
63	63	WRITE8_MEMBER(megazone_state::i8039_irqen_and_status_w)
64	64	{
65	65
66	66	if ((data & 0x80) == 0)
67		device_set_input_line(m_daccpu, 0, CLEAR_LINE);
	67	m_daccpu->set_input_line(0, CLEAR_LINE);
68	68	m_i8039_status = (data & 0x70) >> 4;
69	69	}
70	70
r17814	r17815
251	251	megazone_state *state = device->machine().driver_data<megazone_state>();
252	252
253	253	if(state->m_irq_mask)
254		device_set_input_line(device, 0, HOLD_LINE);
	254	device->execute().set_input_line(0, HOLD_LINE);
255	255	}
256	256
257	257

trunk/src/mame/drivers/40love.c

r17814	r17815
235	235	{
236	236	fortyl_state *state = machine.driver_data<fortyl_state>();
237	237	if (state->m_sound_nmi_enable)
238		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	238	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
239	239	else
240	240	state->m_pending_nmi = 1;
241	241	}
r17814	r17815
256	256	m_sound_nmi_enable = 1;
257	257	if (m_pending_nmi)
258	258	{
259		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	259	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
260	260	m_pending_nmi = 0;
261	261	}
262	262	}
r17814	r17815
978	978	{
979	979	fortyl_state *state = machine.driver_data<fortyl_state>();
980	980
981		state->m_audiocpu = machine.device("audiocpu");
	981	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
982	982
983	983	/* video */
984	984	state->save_item(NAME(state->m_pix1));

trunk/src/mame/drivers/galaga.c

r17814	r17815
1644	1644	galaga_state *state = device->machine().driver_data<galaga_state>();
1645	1645
1646	1646	if(state->m_main_irq_mask)
1647		device_set_input_line(device, 0, ASSERT_LINE);
	1647	device->execute().set_input_line(0, ASSERT_LINE);
1648	1648	}
1649	1649
1650	1650	static INTERRUPT_GEN( sub_vblank_irq )
r17814	r17815
1652	1652	galaga_state *state = device->machine().driver_data<galaga_state>();
1653	1653
1654	1654	if(state->m_sub_irq_mask)
1655		device_set_input_line(device, 0, ASSERT_LINE);
	1655	device->execute().set_input_line(0, ASSERT_LINE);
1656	1656	}
1657	1657
1658	1658	const namco_06xx_config bosco_namco_06xx_0_intf =

trunk/src/mame/drivers/istellar.c

r17814	r17815
317	317	static INTERRUPT_GEN( vblank_callback_istellar )
318	318	{
319	319	/* Interrupt presumably comes from VBlank */
320		device_set_input_line(device, 0, HOLD_LINE);
	320	device->execute().set_input_line(0, HOLD_LINE);
321	321
322	322	/* Interrupt presumably comes from the LDP's status strobe */
323	323	device->machine().device("sub")->execute().set_input_line(0, ASSERT_LINE);

trunk/src/mame/drivers/lasso.c

r17814	r17815
40	40	{
41	41
42	42	/* coin insertion causes an NMI */
43		device_set_input_line(m_maincpu, INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
	43	m_maincpu->set_input_line(INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
44	44	}
45	45
46	46
r17814	r17815
48	48	WRITE8_MEMBER(lasso_state::sound_command_w)
49	49	{
50	50	soundlatch_byte_w(space, offset, data);
51		generic_pulse_irq_line(m_audiocpu->execute(), 0, 1);
	51	generic_pulse_irq_line(*m_audiocpu, 0, 1);
52	52	}
53	53
54	54	WRITE8_MEMBER(lasso_state::pinbo_sound_command_w)
55	55	{
56	56	soundlatch_byte_w(space, offset, data);
57		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	57	m_audiocpu->set_input_line(0, HOLD_LINE);
58	58	}
59	59
60	60	READ8_MEMBER(lasso_state::sound_status_r)
r17814	r17815
479	479	{
480	480	lasso_state *state = machine.driver_data<lasso_state>();
481	481
482		state->m_maincpu = machine.device("maincpu");
483		state->m_audiocpu = machine.device("audiocpu");
	482	state->m_maincpu = machine.device<cpu_device>("maincpu");
	483	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
484	484
485	485	state->save_item(NAME(state->m_gfxbank));
486	486	}

trunk/src/mame/drivers/sbowling.c

r17814	r17815
165	165	int scanline = param;
166	166
167	167	if(scanline == 256)
168		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0xcf); /* RST 08h */
	168	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xcf); /* RST 08h */
169	169
170	170	if(scanline == 128)
171		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0xd7); /* RST 10h */
	171	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xd7); /* RST 10h */
172	172
173	173	}
174	174

trunk/src/mame/drivers/othunder.c

r17814	r17815
252	252	static void update_irq( running_machine &machine )
253	253	{
254	254	othunder_state *state = machine.driver_data<othunder_state>();
255		device_set_input_line(state->m_maincpu, 6, state->m_ad_irq ? ASSERT_LINE : CLEAR_LINE);
256		device_set_input_line(state->m_maincpu, 5, state->m_vblank_irq ? ASSERT_LINE : CLEAR_LINE);
	255	state->m_maincpu->set_input_line(6, state->m_ad_irq ? ASSERT_LINE : CLEAR_LINE);
	256	state->m_maincpu->set_input_line(5, state->m_vblank_irq ? ASSERT_LINE : CLEAR_LINE);
257	257	}
258	258
259	259	WRITE16_MEMBER(othunder_state::irq_ack_w)
r17814	r17815
630	630	static void irqhandler( device_t *device, int irq )
631	631	{
632	632	othunder_state *state = device->machine().driver_data<othunder_state>();
633		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	633	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
634	634	}
635	635
636	636	static const ym2610_interface ym2610_config =
r17814	r17815
676	676
677	677	state->membank("bank10")->configure_entries(0, 4, state->memregion("audiocpu")->base() + 0xc000, 0x4000);
678	678
679		state->m_maincpu = machine.device("maincpu");
680		state->m_audiocpu = machine.device("audiocpu");
	679	state->m_maincpu = machine.device<cpu_device>("maincpu");
	680	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
681	681	state->m_eeprom = machine.device<eeprom_device>("eeprom");
682	682	state->m_tc0220ioc = machine.device("tc0220ioc");
683	683	state->m_tc0100scn = machine.device("tc0100scn");

trunk/src/mame/drivers/quasar.c

r17814	r17815
270	270
271	271	static INTERRUPT_GEN( quasar_interrupt )
272	272	{
273		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0x03);
	273	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0x03);
274	274	}
275	275
276	276	static const s2636_interface s2636_0_config =

trunk/src/mame/drivers/psikyo4.c

r17814	r17815
193	193
194	194	static INTERRUPT_GEN(psikyosh_interrupt)
195	195	{
196		device_set_input_line(device, 4, HOLD_LINE);
	196	device->execute().set_input_line(4, HOLD_LINE);
197	197	}
198	198
199	199	CUSTOM_INPUT_MEMBER(psikyo4_state::system_port_r)
r17814	r17815
651	651	static void irqhandler( device_t *device, int linestate )
652	652	{
653	653	psikyo4_state *state = device->machine().driver_data<psikyo4_state>();
654		device_set_input_line(state->m_maincpu, 12, linestate ? ASSERT_LINE : CLEAR_LINE);
	654	state->m_maincpu->set_input_line(12, linestate ? ASSERT_LINE : CLEAR_LINE);
655	655	}
656	656
657	657	static const ymf278b_interface ymf278b_config =
r17814	r17815
664	664	{
665	665	psikyo4_state *state = machine.driver_data<psikyo4_state>();
666	666
667		state->m_maincpu = machine.device("maincpu");
	667	state->m_maincpu = machine.device<cpu_device>("maincpu");
668	668
669	669	state->save_item(NAME(state->m_oldbrt1));
670	670	state->save_item(NAME(state->m_oldbrt2));

trunk/src/mame/drivers/nss.c

r17814	r17815
556	556
557	557	m_cart_sel = (data & 0xc) >> 2;
558	558
559		device_set_input_line(m_maincpu, INPUT_LINE_HALT, (data & 2) ? CLEAR_LINE : ASSERT_LINE);
560		device_set_input_line(m_soundcpu, INPUT_LINE_HALT, (data & 2) ? CLEAR_LINE : ASSERT_LINE);
561		device_set_input_line(m_maincpu, INPUT_LINE_RESET, (data & 1) ? CLEAR_LINE : ASSERT_LINE);
562		device_set_input_line(m_soundcpu, INPUT_LINE_RESET, (data & 1) ? CLEAR_LINE : ASSERT_LINE);
	559	m_maincpu->set_input_line(INPUT_LINE_HALT, (data & 2) ? CLEAR_LINE : ASSERT_LINE);
	560	m_soundcpu->set_input_line(INPUT_LINE_HALT, (data & 2) ? CLEAR_LINE : ASSERT_LINE);
	561	m_maincpu->set_input_line(INPUT_LINE_RESET, (data & 1) ? CLEAR_LINE : ASSERT_LINE);
	562	m_soundcpu->set_input_line(INPUT_LINE_RESET, (data & 1) ? CLEAR_LINE : ASSERT_LINE);
563	563	/* also reset the device */
564	564	if((data & 1) == 0)
565	565	spc700_reset(machine().device("spc700"));
r17814	r17815
821	821	nss_state *state = device->machine().driver_data<nss_state>();
822	822
823	823	if(state->m_nmi_enable)
824		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	824	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
825	825	}
826	826
827	827	static MACHINE_RESET( nss )
r17814	r17815
831	831	MACHINE_RESET_CALL( snes );
832	832
833	833	/* start with both CPUs disabled */
834		device_set_input_line(state->m_maincpu, INPUT_LINE_RESET, ASSERT_LINE);
835		device_set_input_line(state->m_soundcpu, INPUT_LINE_RESET, ASSERT_LINE);
	834	state->m_maincpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
	835	state->m_soundcpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
836	836
837	837	state->m_game_over_flag = 1;
838	838	state->m_joy_flag = 1;

trunk/src/mame/drivers/rollrace.c

r17814	r17815
213	213	rollrace_state *state = device->machine().driver_data<rollrace_state>();
214	214
215	215	if(state->m_nmi_mask)
216		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	216	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
217	217	}
218	218
219	219	static INTERRUPT_GEN( sound_timer_irq )
r17814	r17815
221	221	rollrace_state *state = device->machine().driver_data<rollrace_state>();
222	222
223	223	if(state->m_sound_nmi_mask)
224		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	224	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
225	225	}
226	226
227	227	static MACHINE_CONFIG_START( rollrace, rollrace_state )

trunk/src/mame/drivers/popper.c

r17814	r17815
140	140
141	141	READ8_MEMBER(popper_state::popper_soundcpu_nmi_r)
142	142	{
143		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	143	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
144	144	return 0;
145	145	}
146	146
r17814	r17815
314	314	{
315	315	popper_state *state = machine.driver_data<popper_state>();
316	316
317		state->m_audiocpu = machine.device("audiocpu");
	317	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
318	318
319	319	state->save_item(NAME(state->m_flipscreen));
320	320	state->save_item(NAME(state->m_e002));
r17814	r17815
335	335	popper_state *state = device->machine().driver_data<popper_state>();
336	336
337	337	if(state->m_nmi_mask)
338		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	338	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
339	339	}
340	340
341	341

trunk/src/mame/drivers/ladyfrog.c

r17814	r17815
67	67
68	68	WRITE8_MEMBER(ladyfrog_state::sound_cpu_reset_w)
69	69	{
70		device_set_input_line(m_audiocpu, INPUT_LINE_RESET, (data & 1 ) ? ASSERT_LINE : CLEAR_LINE);
	70	m_audiocpu->set_input_line(INPUT_LINE_RESET, (data & 1 ) ? ASSERT_LINE : CLEAR_LINE);
71	71	}
72	72
73	73	static TIMER_CALLBACK( nmi_callback )
r17814	r17815
75	75	ladyfrog_state *state = machine.driver_data<ladyfrog_state>();
76	76
77	77	if (state->m_sound_nmi_enable)
78		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	78	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
79	79	else
80	80	state->m_pending_nmi = 1;
81	81	}
r17814	r17815
97	97	m_sound_nmi_enable = 1;
98	98	if (m_pending_nmi)
99	99	{
100		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	100	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
101	101	m_pending_nmi = 0;
102	102	}
103	103	}
r17814	r17815
280	280	{
281	281	ladyfrog_state *state = machine.driver_data<ladyfrog_state>();
282	282
283		state->m_audiocpu = machine.device("audiocpu");
	283	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
284	284
285	285	state->save_item(NAME(state->m_tilebank));
286	286	state->save_item(NAME(state->m_palette_bank));

trunk/src/mame/drivers/djboy.c

r17814	r17815
153	153	m_data_to_beast = data;
154	154	m_z80_to_beast_full = 1;
155	155	m_beast_int0_l = 0;
156		device_set_input_line(m_beast, INPUT_LINE_IRQ0, ASSERT_LINE);
	156	m_beast->execute().set_input_line(INPUT_LINE_IRQ0, ASSERT_LINE);
157	157	}
158	158
159	159	READ8_MEMBER(djboy_state::beast_data_r)
r17814	r17815
172	172
173	173	WRITE8_MEMBER(djboy_state::trigger_nmi_on_cpu0)
174	174	{
175		device_set_input_line(m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	175	m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
176	176	}
177	177
178	178	WRITE8_MEMBER(djboy_state::cpu0_bankswitch_w)
r17814	r17815
233	233	WRITE8_MEMBER(djboy_state::trigger_nmi_on_sound_cpu2)
234	234	{
235	235	soundlatch_byte_w(space, 0, data);
236		device_set_input_line(m_cpu2, INPUT_LINE_NMI, PULSE_LINE);
	236	m_cpu2->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
237	237	} /* trigger_nmi_on_sound_cpu2 */
238	238
239	239	WRITE8_MEMBER(djboy_state::cpu2_bankswitch_w)
r17814	r17815
336	336	if (data == 0xff)
337	337	{
338	338	m_beast_int0_l = 1;
339		device_set_input_line(m_beast, INPUT_LINE_IRQ0, CLEAR_LINE);
	339	m_beast->execute().set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
340	340	}
341	341
342	342	m_beast_p1 = data;
r17814	r17815
380	380	{
381	381
382	382	m_beast_p3 = data;
383		device_set_input_line(m_cpu1, INPUT_LINE_RESET, data & 2 ? CLEAR_LINE : ASSERT_LINE);
	383	m_cpu1->execute().set_input_line(INPUT_LINE_RESET, data & 2 ? CLEAR_LINE : ASSERT_LINE);
384	384	}
385	385	/* Program/data maps are defined in the 8051 core */
386	386
r17814	r17815
534	534	state->membank("bank3")->configure_entries(3, 5,  &CPU2[0x10000], 0x4000);
535	535	state->membank("bank4")->configure_entry(0, &MAIN[0x10000]); /* unsure if/how this area is banked */
536	536
537		state->m_maincpu = machine.device("maincpu");
	537	state->m_maincpu = machine.device<cpu_device>("maincpu");
538	538	state->m_cpu1 = machine.device("cpu1");
539	539	state->m_cpu2 = machine.device("cpu2");
540	540	state->m_beast = machine.device("beast");

trunk/src/mame/drivers/tumblep.c

r17814	r17815
71	71	WRITE16_MEMBER(tumblep_state::tumblep_sound_w)
72	72	{
73	73	soundlatch_byte_w(space, 0, data & 0xff);
74		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	74	m_audiocpu->set_input_line(0, HOLD_LINE);
75	75	}
76	76
77	77	#ifdef UNUSED_FUNCTION
r17814	r17815
275	275	static void sound_irq(device_t *device, int state)
276	276	{
277	277	tumblep_state *driver_state = device->machine().driver_data<tumblep_state>();
278		device_set_input_line(driver_state->m_audiocpu, 1, state); /* IRQ 2 */
	278	driver_state->m_audiocpu->set_input_line(1, state); /* IRQ 2 */
279	279	}
280	280
281	281	static const ym2151_interface ym2151_config =
r17814	r17815
298	298	{
299	299	tumblep_state *state = machine.driver_data<tumblep_state>();
300	300
301		state->m_maincpu = machine.device("maincpu");
302		state->m_audiocpu = machine.device("audiocpu");
	301	state->m_maincpu = machine.device<cpu_device>("maincpu");
	302	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
303	303	state->m_deco_tilegen1 = machine.device("tilegen1");
304	304	}
305	305

trunk/src/mame/drivers/dietgo.c

r17814	r17815
163	163	static void sound_irq(device_t *device, int state)
164	164	{
165	165	dietgo_state *driver_state = device->machine().driver_data<dietgo_state>();
166		device_set_input_line(driver_state->m_audiocpu, 1, state); /* IRQ 2 */
	166	driver_state->m_audiocpu->set_input_line(1, state); /* IRQ 2 */
167	167	}
168	168
169	169	static const ym2151_interface ym2151_config =
r17814	r17815
199	199	{
200	200	dietgo_state *state = machine.driver_data<dietgo_state>();
201	201
202		state->m_maincpu = machine.device("maincpu");
203		state->m_audiocpu = machine.device("audiocpu");
	202	state->m_maincpu = machine.device<cpu_device>("maincpu");
	203	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
204	204	state->m_deco_tilegen1 = machine.device("tilegen1");
205	205	}
206	206

trunk/src/mame/drivers/kingobox.c

r17814	r17815
23	23
24	24	WRITE8_MEMBER(kingofb_state::video_interrupt_w)
25	25	{
26		device_set_input_line_and_vector(m_video_cpu, 0, HOLD_LINE, 0xff);
	26	m_video_cpu->execute().set_input_line_and_vector(0, HOLD_LINE, 0xff);
27	27	}
28	28
29	29	WRITE8_MEMBER(kingofb_state::sprite_interrupt_w)
30	30	{
31		device_set_input_line_and_vector(m_sprite_cpu, 0, HOLD_LINE, 0xff);
	31	m_sprite_cpu->execute().set_input_line_and_vector(0, HOLD_LINE, 0xff);
32	32	}
33	33
34	34	WRITE8_MEMBER(kingofb_state::scroll_interrupt_w)
r17814	r17815
40	40	WRITE8_MEMBER(kingofb_state::sound_command_w)
41	41	{
42	42	soundlatch_byte_w(space, 0, data);
43		device_set_input_line_and_vector(m_audio_cpu, 0, HOLD_LINE, 0xff);
	43	m_audio_cpu->execute().set_input_line_and_vector(0, HOLD_LINE, 0xff);
44	44	}
45	45
46	46
r17814	r17815
447	447	kingofb_state *state = device->machine().driver_data<kingofb_state>();
448	448
449	449	if (state->m_nmi_enable)
450		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	450	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
451	451	}
452	452
453	453	static MACHINE_START( kingofb )

trunk/src/mame/drivers/blockout.c

r17814	r17815
80	80	if (ACCESSING_BITS_0_7)
81	81	{
82	82	soundlatch_byte_w(space, offset, data & 0xff);
83		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	83	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
84	84	}
85	85	}
86	86
87	87	WRITE16_MEMBER(blockout_state::blockout_irq6_ack_w)
88	88	{
89	89
90		device_set_input_line(m_maincpu, 6, CLEAR_LINE);
	90	m_maincpu->set_input_line(6, CLEAR_LINE);
91	91	}
92	92
93	93	WRITE16_MEMBER(blockout_state::blockout_irq5_ack_w)
94	94	{
95	95
96		device_set_input_line(m_maincpu, 5, CLEAR_LINE);
	96	m_maincpu->set_input_line(5, CLEAR_LINE);
97	97	}
98	98
99	99	/*************************************
r17814	r17815
263	263	static void blockout_irq_handler(device_t *device, int irq)
264	264	{
265	265	blockout_state *state = device->machine().driver_data<blockout_state>();
266		device_set_input_line_and_vector(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE, 0xff);
	266	state->m_audiocpu->set_input_line_and_vector(0, irq ? ASSERT_LINE : CLEAR_LINE, 0xff);
267	267	}
268	268
269	269	static const ym2151_interface ym2151_config =
r17814	r17815
282	282	{
283	283	blockout_state *state = machine.driver_data<blockout_state>();
284	284
285		state->m_maincpu = machine.device("maincpu");
286		state->m_audiocpu = machine.device("audiocpu");
	285	state->m_maincpu = machine.device<cpu_device>("maincpu");
	286	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
287	287
288	288	state->save_item(NAME(state->m_color));
289	289	}
r17814	r17815
301	301	int scanline = param;
302	302
303	303	if(scanline == 248) // vblank-out irq
304		device_set_input_line(state->m_maincpu, 6, ASSERT_LINE);
	304	state->m_maincpu->set_input_line(6, ASSERT_LINE);
305	305
306	306	if(scanline == 0) // vblank-in irq or directly tied to coin inputs (TODO: check)
307		device_set_input_line(state->m_maincpu, 5, ASSERT_LINE);
	307	state->m_maincpu->set_input_line(5, ASSERT_LINE);
308	308	}
309	309
310	310	static MACHINE_CONFIG_START( blockout, blockout_state )

trunk/src/mame/drivers/tsamurai.c

r17814	r17815
49	49	static INTERRUPT_GEN( samurai_interrupt )
50	50	{
51	51	tsamurai_state *state = device->machine().driver_data<tsamurai_state>();
52		if (state->m_nmi_enabled) device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	52	if (state->m_nmi_enabled) device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
53	53	}
54	54
55	55	READ8_MEMBER(tsamurai_state::unknown_d803_r)
r17814	r17815
270	270	static INTERRUPT_GEN( vsgongf_sound_interrupt )
271	271	{
272	272	tsamurai_state *state = device->machine().driver_data<tsamurai_state>();
273		if (state->m_vsgongf_sound_nmi_enabled) device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	273	if (state->m_vsgongf_sound_nmi_enabled) device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
274	274	}
275	275
276	276	/* what are these, protection of some kind? */

trunk/src/mame/drivers/ettrivia.c

r17814	r17815
291	291	static INTERRUPT_GEN( ettrivia_interrupt )
292	292	{
293	293	if( device->machine().root_device().ioport("COIN")->read() & 0x01 )
294		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	294	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
295	295	else
296		device_set_input_line(device, 0, HOLD_LINE);
	296	device->execute().set_input_line(0, HOLD_LINE);
297	297	}
298	298
299	299	static MACHINE_CONFIG_START( ettrivia, ettrivia_state )

trunk/src/mame/drivers/f1gp.c

r17814	r17815
72	72	{
73	73	m_pending_command = 1;
74	74	soundlatch_byte_w(space, offset, data & 0xff);
75		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	75	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
76	76	}
77	77	}
78	78
r17814	r17815
394	394	static void irqhandler( device_t *device, int irq )
395	395	{
396	396	f1gp_state *state = device->machine().driver_data<f1gp_state>();
397		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	397	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
398	398	}
399	399
400	400	static const ym2610_interface ym2610_config =
r17814	r17815
431	431
432	432	state->membank("bank1")->configure_entries(0, 2, &ROM[0x10000], 0x8000);
433	433
434		state->m_audiocpu = machine.device("audiocpu");
	434	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
435	435	state->m_k053936 = machine.device("k053936");
436	436
437	437	MACHINE_START_CALL(f1gpb);

trunk/src/mame/drivers/tx1.c

r17814	r17815
83	83	/* Periodic Z80 interrupt */
84	84	static INTERRUPT_GEN( z80_irq )
85	85	{
86		device_set_input_line(device, 0, HOLD_LINE);
	86	device->execute().set_input_line(0, HOLD_LINE);
87	87	}
88	88
89	89	READ16_MEMBER(tx1_state::z80_shared_r)

trunk/src/mame/drivers/pingpong.c

r17814	r17815
62	62
63	63	if (scanline == 240)
64	64	{
65		if (state->m_intenable & 0x04) device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	65	if (state->m_intenable & 0x04) state->m_maincpu->set_input_line(0, HOLD_LINE);
66	66	}
67	67	else if ((scanline % 32) == 0)
68	68	{
69		if (state->m_intenable & 0x08) device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	69	if (state->m_intenable & 0x08) state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
70	70	}
71	71	}
72	72
r17814	r17815
77	77
78	78	if (scanline == 240)
79	79	{
80		if (state->m_intenable & 0x04) device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	80	if (state->m_intenable & 0x04) state->m_maincpu->set_input_line(0, HOLD_LINE);
81	81	}
82	82	else if (scanline == 0)
83	83	{
84		if (state->m_intenable & 0x08) device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	84	if (state->m_intenable & 0x08) state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
85	85	}
86	86	}
87	87

trunk/src/mame/drivers/aztarac.c

r17814	r17815
37	37
38	38	static MACHINE_RESET( aztarac )
39	39	{
40		device_set_irq_callback(machine.device("maincpu"), aztarac_irq_callback);
	40	machine.device("maincpu")->execute().set_irq_acknowledge_callback(aztarac_irq_callback);
41	41	}
42	42
43	43

trunk/src/mame/drivers/retofinv.c

r17814	r17815
333	333	retofinv_state *state = device->machine().driver_data<retofinv_state>();
334	334
335	335	if(state->m_main_irq_mask)
336		device_set_input_line(device, 0, ASSERT_LINE);
	336	device->execute().set_input_line(0, ASSERT_LINE);
337	337	}
338	338
339	339	static INTERRUPT_GEN( sub_vblank_irq )
r17814	r17815
341	341	retofinv_state *state = device->machine().driver_data<retofinv_state>();
342	342
343	343	if(state->m_sub_irq_mask)
344		device_set_input_line(device, 0, ASSERT_LINE);
	344	device->execute().set_input_line(0, ASSERT_LINE);
345	345	}
346	346
347	347

trunk/src/mame/drivers/meadows.c

r17814	r17815
214	214	meadows_state *state = device->machine().driver_data<meadows_state>();
215	215	/* fake something toggling the sense input line of the S2650 */
216	216	state->m_main_sense_state ^= 1;
217		device_set_input_line(device, 1, state->m_main_sense_state ? ASSERT_LINE : CLEAR_LINE);
	217	device->execute().set_input_line(1, state->m_main_sense_state ? ASSERT_LINE : CLEAR_LINE);
218	218	}
219	219
220	220
r17814	r17815
229	229	{
230	230	meadows_state *state = device->machine().driver_data<meadows_state>();
231	231	state->m_main_sense_state++;
232		device_set_input_line(device, 1, (state->m_main_sense_state & 0x40) ? ASSERT_LINE : CLEAR_LINE );
	232	device->execute().set_input_line(1, (state->m_main_sense_state & 0x40) ? ASSERT_LINE : CLEAR_LINE );
233	233	}
234	234
235	235
r17814	r17815
312	312	meadows_state *state = device->machine().driver_data<meadows_state>();
313	313	/* fake something toggling the sense input line of the S2650 */
314	314	state->m_audio_sense_state ^= 1;
315		device_set_input_line(device, 1, state->m_audio_sense_state ? ASSERT_LINE : CLEAR_LINE);
	315	device->execute().set_input_line(1, state->m_audio_sense_state ? ASSERT_LINE : CLEAR_LINE);
316	316	}
317	317
318	318

trunk/src/mame/drivers/spoker.c

r17814	r17815
523	523	{
524	524	//  spoker_state *state = device->machine().driver_data<spoker_state>();
525	525
526		device_set_input_line(device, INPUT_LINE_NMI, ASSERT_LINE);
	526	device->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
527	527	}
528	528
529	529	static MACHINE_CONFIG_START( spoker, spoker_state )

trunk/src/mame/drivers/aeroboto.c

r17814	r17815
44	44	aeroboto_state *state = device->machine().driver_data<aeroboto_state>();
45	45
46	46	if (!state->m_disable_irq)
47		device_set_input_line(device, 0, ASSERT_LINE);
	47	device->execute().set_input_line(0, ASSERT_LINE);
48	48	else
49	49	state->m_disable_irq--;
50	50	}

trunk/src/mame/drivers/firetrap.c

r17814	r17815
246	246	{
247	247	m_i8751_current_command = 0;
248	248	m_i8751_return = 0xff; /* This value is XOR'd and must equal 0 */
249		device_set_input_line_and_vector(m_maincpu, 0, HOLD_LINE, 0xff);
	249	m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
250	250	return;
251	251	}
252	252
r17814	r17815
297	297	}
298	298
299	299	/* Signal main cpu task is complete */
300		device_set_input_line_and_vector(m_maincpu, 0, HOLD_LINE, 0xff);
	300	m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
301	301	m_i8751_current_command=data;
302	302	}
303	303
304	304	WRITE8_MEMBER(firetrap_state::firetrap_sound_command_w)
305	305	{
306	306	soundlatch_byte_w(space, offset, data);
307		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	307	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
308	308	}
309	309
310	310	WRITE8_MEMBER(firetrap_state::firetrap_sound_2400_w)
r17814	r17815
327	327
328	328	state->m_adpcm_toggle ^= 1;
329	329	if (state->m_sound_irq_enable && state->m_adpcm_toggle)
330		device_set_input_line(state->m_audiocpu, M6502_IRQ_LINE, HOLD_LINE);
	330	state->m_audiocpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
331	331	}
332	332
333	333	WRITE8_MEMBER(firetrap_state::firetrap_adpcm_data_w)
r17814	r17815
418	418	if (m_coin_command_pending && !m_i8751_current_command)
419	419	{
420	420	m_i8751_return = m_coin_command_pending;
421		device_set_input_line_and_vector(m_maincpu, 0, HOLD_LINE, 0xff);
	421	m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
422	422	m_coin_command_pending = 0;
423	423	}
424	424	}
r17814	r17815
586	586	firetrap_state *state = device->machine().driver_data<firetrap_state>();
587	587
588	588	if (state->m_nmi_enable)
589		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	589	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
590	590	}
591	591
592	592
r17814	r17815
596	596	UINT8 *MAIN = state->memregion("maincpu")->base();
597	597	UINT8 *SOUND = state->memregion("audiocpu")->base();
598	598
599		state->m_maincpu = machine.device("maincpu");
600		state->m_audiocpu = machine.device("audiocpu");
	599	state->m_maincpu = machine.device<cpu_device>("maincpu");
	600	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
601	601	state->m_msm = machine.device("msm");
602	602
603	603	state->membank("bank1")->configure_entries(0, 4, &MAIN[0x10000], 0x4000);

trunk/src/mame/drivers/thedeep.c

r17814	r17815
232	232
233	233	/* bit 0 0->1 transition IRQ0 to main */
234	234	if((!(m_mcu_p3_reg & 0x01)) && data & 0x01)
235		device_set_input_line(m_maincpu, 0, HOLD_LINE);
	235	m_maincpu->set_input_line(0, HOLD_LINE);
236	236
237	237	/* bit 6 0->1 transition INT1 IRQ ACK */
238	238	if((!(m_mcu_p3_reg & 0x40)) && data & 0x40)
239		device_set_input_line(m_mcu, MCS51_INT1_LINE, CLEAR_LINE);
	239	m_mcu->set_input_line(MCS51_INT1_LINE, CLEAR_LINE);
240	240
241	241	/* bit 7 0->1 transition INT0 IRQ ACK */
242	242	if((!(m_mcu_p3_reg & 0x80)) && data & 0x80)
243		device_set_input_line(m_mcu, MCS51_INT0_LINE, CLEAR_LINE);
	243	m_mcu->set_input_line(MCS51_INT0_LINE, CLEAR_LINE);
244	244
245	245	m_mcu_p3_reg = data;
246	246	logerror("P3 %02x\n",data);
r17814	r17815
426	426	state->m_protection_irq = 1;
427	427	}
428	428	if (state->m_protection_irq)
429		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	429	state->m_maincpu->set_input_line(0, HOLD_LINE);
430	430	}
431	431	else if(scanline == 0)
432	432	{
433	433	if (state->m_nmi_enable)
434	434	{
435		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, ASSERT_LINE);
436		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, CLEAR_LINE);
	435	state->m_maincpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
	436	state->m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
437	437	}
438	438	}
439	439	}
r17814	r17815
442	442	{
443	443	thedeep_state *state = device->machine().driver_data<thedeep_state>();
444	444
445		device_set_input_line(state->m_mcu, MCS51_INT1_LINE, ASSERT_LINE);
	445	state->m_mcu->set_input_line(MCS51_INT1_LINE, ASSERT_LINE);
446	446	}
447	447
448	448	static MACHINE_CONFIG_START( thedeep, thedeep_state )

trunk/src/mame/drivers/oneshot.c

r17814	r17815
332	332	static void irq_handler(device_t *device, int irq)
333	333	{
334	334	oneshot_state *state = device->machine().driver_data<oneshot_state>();
335		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	335	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
336	336	}
337	337
338	338	static const ym3812_interface ym3812_config =
r17814	r17815
344	344	{
345	345	oneshot_state *state = machine.driver_data<oneshot_state>();
346	346
347		state->m_maincpu = machine.device("maincpu");
348		state->m_audiocpu = machine.device("audiocpu");
	347	state->m_maincpu = machine.device<cpu_device>("maincpu");
	348	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
349	349
350	350	state->save_item(NAME(state->m_gun_x_p1));
351	351	state->save_item(NAME(state->m_gun_y_p1));

trunk/src/mame/drivers/zr107.c

r17814	r17815
715	715	*/
716	716	static INTERRUPT_GEN( zr107_vblank )
717	717	{
718		device_set_input_line(device, INPUT_LINE_IRQ0, ASSERT_LINE);
	718	device->execute().set_input_line(INPUT_LINE_IRQ0, ASSERT_LINE);
719	719	}
720	720
721	721	static MACHINE_RESET( zr107 )

trunk/src/mame/drivers/flipjack.c

r17814	r17815
261	261
262	262	READ8_MEMBER(flipjack_state::flipjack_soundlatch_r)
263	263	{
264		device_set_input_line(m_audiocpu, 0, CLEAR_LINE);
	264	m_audiocpu->set_input_line(0, CLEAR_LINE);
265	265	return m_soundlatch;
266	266	}
267	267
268	268	WRITE8_MEMBER(flipjack_state::flipjack_soundlatch_w)
269	269	{
270	270	m_soundlatch = data;
271		device_set_input_line(m_audiocpu, 0, ASSERT_LINE);
	271	m_audiocpu->set_input_line(0, ASSERT_LINE);
272	272	}
273	273
274	274	WRITE8_MEMBER(flipjack_state::flipjack_sound_nmi_ack_w)
275	275	{
276		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, CLEAR_LINE);
	276	m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
277	277	}
278	278
279	279	WRITE8_MEMBER(flipjack_state::flipjack_portc_w)
r17814	r17815
284	284	INPUT_CHANGED_MEMBER(flipjack_state::flipjack_coin)
285	285	{
286	286	if (newval)
287		device_set_input_line(m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	287	m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
288	288	}
289	289
290	290

trunk/src/mame/drivers/bladestl.c

r17814	r17815
91	91	{
92	92
93	93	soundlatch_byte_w(space, offset, data);
94		device_set_input_line(m_audiocpu, M6809_IRQ_LINE, HOLD_LINE);
	94	m_audiocpu->set_input_line(M6809_IRQ_LINE, HOLD_LINE);
95	95	//logerror("(sound) write %02x\n", data);
96	96	}
97	97
r17814	r17815
308	308
309	309	state->membank("bank1")->configure_entries(0, 4, &ROM[0x10000], 0x2000);
310	310
311		state->m_audiocpu = machine.device("audiocpu");
	311	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
312	312	state->m_k007342 = machine.device("k007342");
313	313	state->m_k007420 = machine.device("k007420");
314	314

trunk/src/mame/drivers/srumbler.c

r17814	r17815
57	57	int scanline = param;
58	58
59	59	if (scanline == 248)
60		device_set_input_line(state->m_maincpu,0,HOLD_LINE);
	60	state->m_maincpu->set_input_line(0,HOLD_LINE);
61	61
62	62	if (scanline == 0)
63		device_set_input_line(state->m_maincpu,M6809_FIRQ_LINE,HOLD_LINE);
	63	state->m_maincpu->set_input_line(M6809_FIRQ_LINE,HOLD_LINE);
64	64	}
65	65
66	66	/*

trunk/src/mame/drivers/mcr68.c

r17814	r17815
86	86	/* It expects D1 to end up between 0 and 5; in order to */
87	87	/* make this happen, we must assume that reads from the */
88	88	/* 6840 take 14 additional cycles                       */
89		device_adjust_icount(&space.device(), -14);
	89	space.device().execute().adjust_icount(-14);
90	90	return mcr68_6840_upper_r(space,offset,0xffff);
91	91	}
92	92

trunk/src/mame/drivers/pbaction.c

r17814	r17815
73	73	WRITE8_MEMBER(pbaction_state::pbaction_sh_command_w)
74	74	{
75	75	soundlatch_byte_w(space, offset, data);
76		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0x00);
	76	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0x00);
77	77	}
78	78
79	79	WRITE8_MEMBER(pbaction_state::nmi_mask_w)
r17814	r17815
251	251
252	252	static INTERRUPT_GEN( pbaction_interrupt )
253	253	{
254		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0x02);   /* the CPU is in Interrupt Mode 2 */
	254	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0x02);   /* the CPU is in Interrupt Mode 2 */
255	255	}
256	256
257	257
r17814	r17815
259	259	{
260	260	pbaction_state *state = machine.driver_data<pbaction_state>();
261	261
262		state->m_maincpu = machine.device("maincpu");
263		state->m_audiocpu = machine.device("audiocpu");
	262	state->m_maincpu = machine.device<cpu_device>("maincpu");
	263	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
264	264
265	265	state->save_item(NAME(state->m_scroll));
266	266	}
r17814	r17815
277	277	pbaction_state *state = device->machine().driver_data<pbaction_state>();
278	278
279	279	if(state->m_nmi_mask)
280		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	280	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
281	281	}
282	282
283	283	static MACHINE_CONFIG_START( pbaction, pbaction_state )

trunk/src/mame/drivers/overdriv.c

r17814	r17815
91	91	overdriv_state *state = device->machine().driver_data<overdriv_state>();
92	92
93	93	if (k053246_is_irq_enabled(state->m_k053246))
94		device_set_input_line(device, 4, HOLD_LINE);
	94	device->execute().set_input_line(4, HOLD_LINE);
95	95	}
96	96
97	97
r17814	r17815
101	101	if (ACCESSING_BITS_0_7)
102	102	{
103	103	/* bit 0 probably enables the second 68000 */
104		device_set_input_line(m_subcpu, INPUT_LINE_RESET, (data & 0x01) ? CLEAR_LINE : ASSERT_LINE);
	104	m_subcpu->set_input_line(INPUT_LINE_RESET, (data & 0x01) ? CLEAR_LINE : ASSERT_LINE);
105	105
106	106	/* bit 1 is clear during service mode - function unknown */
107	107
r17814	r17815
148	148
149	149	WRITE16_MEMBER(overdriv_state::overdriv_soundirq_w)
150	150	{
151		device_set_input_line(m_audiocpu, M6809_IRQ_LINE, HOLD_LINE);
	151	m_audiocpu->set_input_line(M6809_IRQ_LINE, HOLD_LINE);
152	152	}
153	153
154	154	WRITE16_MEMBER(overdriv_state::overdriv_cpuB_irq5_w)
155	155	{
156		device_set_input_line(m_subcpu, 5, HOLD_LINE);
	156	m_subcpu->set_input_line(5, HOLD_LINE);
157	157	}
158	158
159	159	WRITE16_MEMBER(overdriv_state::overdriv_cpuB_irq6_w)
160	160	{
161		device_set_input_line(m_subcpu, 6, HOLD_LINE);
	161	m_subcpu->set_input_line(6, HOLD_LINE);
162	162	}
163	163
164	164	static ADDRESS_MAP_START( overdriv_master_map, AS_PROGRAM, 16, overdriv_state )
r17814	r17815
284	284	{
285	285	overdriv_state *state = machine.driver_data<overdriv_state>();
286	286
287		state->m_maincpu = machine.device("maincpu");
288		state->m_audiocpu = machine.device("audiocpu");
289		state->m_subcpu = machine.device("sub");
	287	state->m_maincpu = machine.device<cpu_device>("maincpu");
	288	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
	289	state->m_subcpu = machine.device<cpu_device>("sub");
290	290	state->m_k051316_1 = machine.device("k051316_1");
291	291	state->m_k051316_2 = machine.device("k051316_2");
292	292	state->m_k053260_1 = machine.device("k053260_1");

trunk/src/mame/drivers/jackpool.c

r17814	r17815
249	249	/*irq 2 used for communication stuff.3 is just a rte*/
250	250	static INTERRUPT_GEN( jackpool_interrupt )
251	251	{
252		device_set_input_line(device, 1, HOLD_LINE);
	252	device->execute().set_input_line(1, HOLD_LINE);
253	253	}
254	254
255	255

trunk/src/mame/drivers/spcforce.c

r17814	r17815
258	258	spcforce_state *state = device->machine().driver_data<spcforce_state>();
259	259
260	260	if(state->m_irq_mask)
261		device_set_input_line(device, 3, HOLD_LINE);
	261	device->execute().set_input_line(3, HOLD_LINE);
262	262	}
263	263
264	264	static MACHINE_CONFIG_START( spcforce, spcforce_state )

trunk/src/mame/drivers/gsword.c

r17814	r17815
253	253	gsword_state *state = device->machine().driver_data<gsword_state>();
254	254
255	255	if(state->m_nmi_enable)
256		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	256	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
257	257	}
258	258
259	259	WRITE8_MEMBER(gsword_state::gsword_nmi_set_w)

trunk/src/mame/drivers/nmg5.c

r17814	r17815
256	256	UINT8 m_gfx_bank;
257	257
258	258	/* devices */
259		device_t *m_maincpu;
260		device_t *m_soundcpu;
	259	cpu_device *m_maincpu;
	260	cpu_device *m_soundcpu;
261	261	DECLARE_WRITE16_MEMBER(fg_videoram_w);
262	262	DECLARE_WRITE16_MEMBER(bg_videoram_w);
263	263	DECLARE_WRITE16_MEMBER(nmg5_soundlatch_w);
r17814	r17815
294	294	if (ACCESSING_BITS_0_7)
295	295	{
296	296	soundlatch_byte_w(space, 0, data & 0xff);
297		device_set_input_line(m_soundcpu, INPUT_LINE_NMI, PULSE_LINE);
	297	m_soundcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
298	298	}
299	299	}
300	300
r17814	r17815
974	974	static void soundirq( device_t *device, int state )
975	975	{
976	976	nmg5_state *driver_state = device->machine().driver_data<nmg5_state>();
977		device_set_input_line(driver_state->m_soundcpu, 0, state);
	977	driver_state->m_soundcpu->set_input_line(0, state);
978	978	}
979	979
980	980	static const ym3812_interface ym3812_intf =
r17814	r17815
986	986	{
987	987	nmg5_state *state = machine.driver_data<nmg5_state>();
988	988
989		state->m_maincpu = machine.device("maincpu");
990		state->m_soundcpu = machine.device("soundcpu");
	989	state->m_maincpu = machine.device<cpu_device>("maincpu");
	990	state->m_soundcpu = machine.device<cpu_device>("soundcpu");
991	991
992	992	state->save_item(NAME(state->m_gfx_bank));
993	993	state->save_item(NAME(state->m_priority_reg));

trunk/src/mame/drivers/xmen.c

r17814	r17815
81	81
82	82	WRITE16_MEMBER(xmen_state::sound_irq_w)
83	83	{
84		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	84	m_audiocpu->set_input_line(0, HOLD_LINE);
85	85	}
86	86
87	87	WRITE16_MEMBER(xmen_state::xmen_18fa00_w)
r17814	r17815
300	300	state->membank("bank4")->configure_entries(0, 8, &ROM[0x10000], 0x4000);
301	301	state->membank("bank4")->set_entry(0);
302	302
303		state->m_maincpu = machine.device("maincpu");
304		state->m_audiocpu = machine.device("audiocpu");
	303	state->m_maincpu = machine.device<cpu_device>("maincpu");
	304	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
305	305	state->m_k053246 = machine.device("k053246");
306	306	state->m_k053251 = machine.device("k053251");
307	307	state->m_k052109 = machine.device("k052109");

trunk/src/mame/drivers/mario.c

r17814	r17815
328	328	mario_state *state = device->machine().driver_data<mario_state>();
329	329
330	330	if(state->m_nmi_mask)
331		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	331	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
332	332	}
333	333
334	334	static MACHINE_CONFIG_START( mario_base, mario_state )

trunk/src/mame/drivers/atarifb.c

r17814	r17815
508	508	{
509	509	atarifb_state *state = machine.driver_data<atarifb_state>();
510	510
511		state->m_maincpu = machine.device("maincpu");
	511	state->m_maincpu = machine.device<cpu_device>("maincpu");
512	512
513	513	state->save_item(NAME(state->m_CTRLD));
514	514	state->save_item(NAME(state->m_sign_x_1));

trunk/src/mame/drivers/lethal.c

r17814	r17815
208	208	lethal_state *state = device->machine().driver_data<lethal_state>();
209	209
210	210	if (k056832_is_irq_enabled(state->m_k056832, 0))
211		device_set_input_line(device, HD6309_IRQ_LINE, HOLD_LINE);
	211	device->execute().set_input_line(HD6309_IRQ_LINE, HOLD_LINE);
212	212	}
213	213
214	214	WRITE8_MEMBER(lethal_state::sound_cmd_w)
r17814	r17815
218	218
219	219	WRITE8_MEMBER(lethal_state::sound_irq_w)
220	220	{
221		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	221	m_audiocpu->set_input_line(0, HOLD_LINE);
222	222	}
223	223
224	224	READ8_MEMBER(lethal_state::sound_status_r)
r17814	r17815
229	229	static void sound_nmi( device_t *device )
230	230	{
231	231	lethal_state *state = device->machine().driver_data<lethal_state>();
232		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	232	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
233	233	}
234	234
235	235	WRITE8_MEMBER(lethal_state::le_bankswitch_w)
r17814	r17815
586	586
587	587	state->m_generic_paletteram_8.allocate(0x3800 + 0x02);
588	588
589		state->m_maincpu = machine.device("maincpu");
590		state->m_audiocpu = machine.device("soundcpu");
	589	state->m_maincpu = machine.device<cpu_device>("maincpu");
	590	state->m_audiocpu = machine.device<cpu_device>("soundcpu");
591	591	state->m_k054539 = machine.device("k054539");
592	592	state->m_k053244 = machine.device("k053244");
593	593	state->m_k056832 = machine.device("k056832");

trunk/src/mame/drivers/exprraid.c

r17814	r17815
233	233	WRITE8_MEMBER(exprraid_state::sound_cpu_command_w)
234	234	{
235	235	soundlatch_byte_w(space, 0, data);
236		device_set_input_line(m_slave, INPUT_LINE_NMI, PULSE_LINE);
	236	m_slave->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
237	237	}
238	238
239	239	READ8_MEMBER(exprraid_state::vblank_r)
r17814	r17815
278	278
279	279	INPUT_CHANGED_MEMBER(exprraid_state::coin_inserted_deco16)
280	280	{
281		device_set_input_line(m_maincpu, DECO16_IRQ_LINE, oldval ? ASSERT_LINE : CLEAR_LINE);
	281	m_maincpu->set_input_line(DECO16_IRQ_LINE, oldval ? ASSERT_LINE : CLEAR_LINE);
282	282	}
283	283
284	284	INPUT_CHANGED_MEMBER(exprraid_state::coin_inserted_nmi)
285	285	{
286		device_set_input_line(m_maincpu, INPUT_LINE_NMI, oldval ? ASSERT_LINE : CLEAR_LINE);
	286	m_maincpu->set_input_line(INPUT_LINE_NMI, oldval ? ASSERT_LINE : CLEAR_LINE);
287	287	}
288	288
289	289	static INPUT_PORTS_START( exprraid )
r17814	r17815
437	437	/* handler called by the 3812 emulator when the internal timers cause an IRQ */
438	438	WRITE_LINE_MEMBER(exprraid_state::irqhandler)
439	439	{
440		device_set_input_line_and_vector(m_slave, 0, state, 0xff);
	440	m_slave->execute().set_input_line_and_vector(0, state, 0xff);
441	441	}
442	442
443	443	static const ym3526_interface ym3526_config =
r17814	r17815
455	455	if (state->m_coin == 0)
456	456	{
457	457	state->m_coin = 1;
458		//device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
459		device_set_input_line(device, DECO16_IRQ_LINE, ASSERT_LINE);
	458	//device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
	459	device->execute().set_input_line(DECO16_IRQ_LINE, ASSERT_LINE);
460	460	}
461	461	}
462	462	else
463	463	{
464		device_set_input_line(device, DECO16_IRQ_LINE, CLEAR_LINE);
	464	device->execute().set_input_line(DECO16_IRQ_LINE, CLEAR_LINE);
465	465	state->m_coin = 0;
466	466	}
467	467	}
r17814	r17815
472	472	{
473	473	exprraid_state *state = machine.driver_data<exprraid_state>();
474	474
475		state->m_maincpu = machine.device("maincpu");
	475	state->m_maincpu = machine.device<cpu_device>("maincpu");
476	476	state->m_slave = machine.device("slave");
477	477
478	478	state->save_item(NAME(state->m_bg_index));

trunk/src/mame/drivers/2mindril.c

r17814	r17815
54	54	UINT16        irq_reg;
55	55
56	56	/* devices */
57		device_t *m_maincpu;
	57	cpu_device *m_maincpu;
58	58	DECLARE_READ16_MEMBER(drill_io_r);
59	59	DECLARE_WRITE16_MEMBER(drill_io_w);
60	60	DECLARE_WRITE16_MEMBER(sensors_w);
r17814	r17815
399	399
400	400	static INTERRUPT_GEN( drill_vblank_irq )
401	401	{
402		device_set_input_line(device, 4, ASSERT_LINE);
	402	device->execute().set_input_line(4, ASSERT_LINE);
403	403	}
404	404
405	405	#if 0
406	406	static INTERRUPT_GEN( drill_device_irq )
407	407	{
408		device_set_input_line(device, 5, ASSERT_LINE);
	408	device->execute().set_input_line(5, ASSERT_LINE);
409	409	}
410	410	#endif
411	411
r17814	r17815
413	413	static void irqhandler(device_t *device, int irq)
414	414	{
415	415	//  _2mindril_state *state = machine.driver_data<_2mindril_state>();
416		//  device_set_input_line(state->m_maincpu, 5, irq ? ASSERT_LINE : CLEAR_LINE);
	416	//  state->m_maincpu->set_input_line(5, irq ? ASSERT_LINE : CLEAR_LINE);
417	417	}
418	418
419	419	static const ym2610_interface ym2610_config =
r17814	r17815
426	426	{
427	427	_2mindril_state *state = machine.driver_data<_2mindril_state>();
428	428
429		state->m_maincpu = machine.device("maincpu");
	429	state->m_maincpu = machine.device<cpu_device>("maincpu");
430	430
431	431	state->save_item(NAME(state->m_defender_sensor));
432	432	state->save_item(NAME(state->m_shutter_sensor));

trunk/src/mame/drivers/taitowlf.c

r17814	r17815
530	530	static MACHINE_START(taitowlf)
531	531	{
532	532	taitowlf_state *state = machine.driver_data<taitowlf_state>();
533		device_set_irq_callback(machine.device("maincpu"), irq_callback);
	533	machine.device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
534	534
535	535	state->m_pit8254 = machine.device( "pit8254" );
536	536	state->m_pic8259_1 = machine.device( "pic8259_1" );

trunk/src/mame/drivers/dfruit.c

r17814	r17815
354	354
355	355	if (scanline == 240 && (state->m_irq_enable & 4))
356	356	{
357		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, state->m_irq_vector[2]);
	357	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, state->m_irq_vector[2]);
358	358	}
359	359
360	360	if (scanline == 0 && (state->m_irq_enable & 2))
361	361	{
362		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, state->m_irq_vector[1]);
	362	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, state->m_irq_vector[1]);
363	363	}
364	364
365	365	if (scanline == 196 && (state->m_irq_enable & 1))
366	366	{
367		//device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, state->m_irq_vector[0]);
	367	//state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, state->m_irq_vector[0]);
368	368	}
369	369	}
370	370

trunk/src/mame/drivers/taito_z.c

r17814	r17815
983	983	{
984	984	/* bit 0 enables cpu B */
985	985	taitoz_state *state = machine.driver_data<taitoz_state>();
986		device_set_input_line(state->m_subcpu, INPUT_LINE_RESET, (state->m_cpua_ctrl & 0x1) ? CLEAR_LINE : ASSERT_LINE);
	986	state->m_subcpu->set_input_line(INPUT_LINE_RESET, (state->m_cpua_ctrl & 0x1) ? CLEAR_LINE : ASSERT_LINE);
987	987	}
988	988
989	989	WRITE16_MEMBER(taitoz_state::cpua_ctrl_w)
r17814	r17815
1022	1022	static TIMER_CALLBACK( taitoz_interrupt6 )
1023	1023	{
1024	1024	taitoz_state *state = machine.driver_data<taitoz_state>();
1025		device_set_input_line(state->m_maincpu, 6, HOLD_LINE);
	1025	state->m_maincpu->set_input_line(6, HOLD_LINE);
1026	1026	}
1027	1027
1028	1028	/* 68000 B */
r17814	r17815
1030	1030	static TIMER_CALLBACK( taitoz_cpub_interrupt5 )
1031	1031	{
1032	1032	taitoz_state *state = machine.driver_data<taitoz_state>();
1033		device_set_input_line(state->m_subcpu, 5, HOLD_LINE);
	1033	state->m_subcpu->set_input_line(5, HOLD_LINE);
1034	1034	}
1035	1035
1036	1036
r17814	r17815
1048	1048	if (state->m_sci_int6)
1049	1049	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(200000 - 500), FUNC(taitoz_interrupt6));
1050	1050
1051		device_set_input_line(device, 4, HOLD_LINE);
	1051	device->execute().set_input_line(4, HOLD_LINE);
1052	1052	}
1053	1053
1054	1054
r17814	r17815
2900	2900	static void irqhandler(device_t *device, int irq)
2901	2901	{
2902	2902	taitoz_state *state = device->machine().driver_data<taitoz_state>();
2903		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	2903	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
2904	2904	}
2905	2905
2906	2906	/* handler called by the YM2610 emulator when the internal timers cause an IRQ */
r17814	r17815
2908	2908	{
2909	2909	// DG: this is probably specific to Z80 and wrong?
2910	2910	//  taitoz_state *state = device->machine().driver_data<taitoz_state>();
2911		//  device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	2911	//  state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
2912	2912	}
2913	2913
2914	2914	static const ym2610_interface ym2610_config =
r17814	r17815
3031	3031	{
3032	3032	taitoz_state *state = machine.driver_data<taitoz_state>();
3033	3033
3034		state->m_maincpu = machine.device("maincpu");
3035		state->m_subcpu = machine.device("sub");
3036		state->m_audiocpu = machine.device("audiocpu");
	3034	state->m_maincpu = machine.device<cpu_device>("maincpu");
	3035	state->m_subcpu = machine.device<cpu_device>("sub");
	3036	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
3037	3037	state->m_eeprom = machine.device<eeprom_device>("eeprom");
3038	3038	state->m_tc0100scn = machine.device("tc0100scn");
3039	3039	state->m_tc0150rod = machine.device("tc0150rod");

trunk/src/mame/drivers/scotrsht.c

r17814	r17815
51	51	scotrsht_state *state = device->machine().driver_data<scotrsht_state>();
52	52
53	53	if (state->m_irq_enable)
54		device_set_input_line(device, 0, HOLD_LINE);
	54	device->execute().set_input_line(0, HOLD_LINE);
55	55	}
56	56
57	57	WRITE8_MEMBER(scotrsht_state::scotrsht_soundlatch_w)

trunk/src/mame/drivers/gunbustr.c

r17814	r17815
60	60	static INTERRUPT_GEN( gunbustr_interrupt )
61	61	{
62	62	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(200000-500), FUNC(gunbustr_interrupt5));
63		device_set_input_line(device, 4, HOLD_LINE);
	63	device->execute().set_input_line(4, HOLD_LINE);
64	64	}
65	65
66	66	WRITE32_MEMBER(gunbustr_state::gunbustr_palette_w)
r17814	r17815
435	435	READ32_MEMBER(gunbustr_state::main_cycle_r)
436	436	{
437	437	if (space.device().safe_pc()==0x55a && (m_ram[0x3acc/4]&0xff000000)==0)
438		device_spin_until_interrupt(&space.device());
	438	space.device().execute().spin_until_interrupt();
439	439
440	440	return m_ram[0x3acc/4];
441	441	}

trunk/src/mame/drivers/msisaac.c

r17814	r17815
26	26	{
27	27	msisaac_state *state = machine.driver_data<msisaac_state>();
28	28	if (state->m_sound_nmi_enable)
29		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	29	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
30	30	else
31	31	state->m_pending_nmi = 1;
32	32	}
r17814	r17815
47	47	m_sound_nmi_enable = 1;
48	48	if (m_pending_nmi)
49	49	{
50		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	50	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
51	51	m_pending_nmi = 0;
52	52	}
53	53	}
r17814	r17815
435	435	{
436	436	msisaac_state *state = machine.driver_data<msisaac_state>();
437	437
438		state->m_audiocpu = machine.device("audiocpu");
	438	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
439	439
440	440	/* video */
441	441	state->save_item(NAME(state->m_bg2_textbank));

trunk/src/mame/drivers/playch10.c

r17814	r17815
661	661
662	662	/* LS161A, Sheet 1 - bottom left of Z80 */
663	663	if ( !state->m_pc10_dog_di && !state->m_pc10_nmi_enable ) {
664		device_set_input_line(device, INPUT_LINE_RESET, PULSE_LINE );
	664	device->execute().set_input_line(INPUT_LINE_RESET, PULSE_LINE );
665	665	}
666	666
667	667	else if ( state->m_pc10_nmi_enable )
668		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	668	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
669	669	}
670	670
671	671	static const nes_interface nes_config =

trunk/src/mame/drivers/rastan.c

r17814	r17815
342	342	static void irqhandler( device_t *device, int irq )
343	343	{
344	344	rastan_state *state = device->machine().driver_data<rastan_state>();
345		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	345	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
346	346	}
347	347
348	348	static const ym2151_interface ym2151_config =
r17814	r17815
365	365	state->membank("bank1")->configure_entry(0, &ROM[0x00000]);
366	366	state->membank("bank1")->configure_entries(1, 3, &ROM[0x10000], 0x4000);
367	367
368		state->m_maincpu = machine.device("maincpu");
369		state->m_audiocpu = machine.device("audiocpu");
	368	state->m_maincpu = machine.device<cpu_device>("maincpu");
	369	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
370	370	state->m_pc080sn = machine.device("pc080sn");
371	371	state->m_pc090oj = machine.device("pc090oj");
372	372

trunk/src/mame/drivers/pntnpuzl.c

r17814	r17815
274	274
275	275	READ16_MEMBER(pntnpuzl_state::irq1_ack_r)
276	276	{
277		//  device_set_input_line(m_maincpu, 1, CLEAR_LINE);
	277	//  m_maincpu->set_input_line(1, CLEAR_LINE);
278	278	return 0;
279	279	}
280	280
281	281	READ16_MEMBER(pntnpuzl_state::irq2_ack_r)
282	282	{
283		//  device_set_input_line(m_maincpu, 2, CLEAR_LINE);
	283	//  m_maincpu->set_input_line(2, CLEAR_LINE);
284	284	return 0;
285	285	}
286	286
287	287	READ16_MEMBER(pntnpuzl_state::irq4_ack_r)
288	288	{
289		//  device_set_input_line(m_maincpu, 4, CLEAR_LINE);
	289	//  m_maincpu->set_input_line(4, CLEAR_LINE);
290	290	return 0;
291	291	}
292	292

trunk/src/mame/drivers/funkball.c

r17814	r17815
1035	1035
1036	1036	WRITE_LINE_MEMBER(funkball_state::funkball_pic8259_1_set_int_line)
1037	1037	{
1038		device_set_input_line(m_maincpu, 0, state ? HOLD_LINE : CLEAR_LINE);
	1038	m_maincpu->set_input_line(0, state ? HOLD_LINE : CLEAR_LINE);
1039	1039	}
1040	1040
1041	1041	READ8_MEMBER( funkball_state::get_slave_ack )
r17814	r17815
1065	1065	{
1066	1066	funkball_state *state = machine.driver_data<funkball_state>();
1067	1067
1068		device_set_input_line(state->m_maincpu, INPUT_LINE_A20, a20);
	1068	state->m_maincpu->set_input_line(INPUT_LINE_A20, a20);
1069	1069	}
1070	1070
1071	1071	static void keyboard_interrupt(running_machine &machine, int state)
r17814	r17815
1111	1111
1112	1112	init_pc_common(machine, PCCOMMON_KEYBOARD_AT, funkball_set_keyb_int);
1113	1113
1114		device_set_irq_callback(state->m_maincpu, irq_callback);
	1114	state->m_maincpu->set_irq_acknowledge_callback(irq_callback);
1115	1115
1116	1116	kbdc8042_init(machine, &at8042);
1117	1117

trunk/src/mame/drivers/tmspoker.c

r17814	r17815
284	284
285	285	static INTERRUPT_GEN( tmspoker_interrupt )
286	286	{
287		device_set_input_line_and_vector(device, 0, ASSERT_LINE, 3);//2=nmi  3,4,5,6
	287	device->execute().set_input_line_and_vector(0, ASSERT_LINE, 3);//2=nmi  3,4,5,6
288	288	}
289	289
290	290

trunk/src/mame/drivers/metalmx.c

r17814	r17815
333	333	if (ACCESSING_BITS_16_31)
334	334	{
335	335	data >>= 16;
336		device_set_input_line(m_dsp32c_1, INPUT_LINE_RESET, data & 2 ? CLEAR_LINE : ASSERT_LINE);
337		device_set_input_line(m_dsp32c_2, INPUT_LINE_RESET, data & 1 ? CLEAR_LINE : ASSERT_LINE);
	336	m_dsp32c_1->set_input_line(INPUT_LINE_RESET, data & 2 ? CLEAR_LINE : ASSERT_LINE);
	337	m_dsp32c_2->set_input_line(INPUT_LINE_RESET, data & 1 ? CLEAR_LINE : ASSERT_LINE);
338	338	}
339	339	}
340	340
r17814	r17815
782	782	{
783	783	metalmx_state *state = machine.driver_data<metalmx_state>();
784	784
785		device_set_input_line(state->m_dsp32c_1, INPUT_LINE_RESET, ASSERT_LINE);
786		device_set_input_line(state->m_dsp32c_2, INPUT_LINE_RESET, ASSERT_LINE);
	785	state->m_dsp32c_1->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
	786	state->m_dsp32c_2->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
787	787	}
788	788
789	789

trunk/src/mame/drivers/equites.c

r17814	r17815
398	398	static TIMER_CALLBACK( equites_nmi_callback )
399	399	{
400	400	equites_state *state = machine.driver_data<equites_state>();
401		device_set_input_line(state->m_audio_cpu, INPUT_LINE_NMI, ASSERT_LINE);
	401	state->m_audio_cpu->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
402	402	}
403	403
404	404	static TIMER_CALLBACK( equites_frq_adjuster_callback )
r17814	r17815
430	430	switch (offset)
431	431	{
432	432	case 0:   // c0f8: NMI ack (written by NMI handler)
433		device_set_input_line(m_audio_cpu, INPUT_LINE_NMI, CLEAR_LINE);
	433	m_audio_cpu->execute().set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
434	434	break;
435	435
436	436	case 1: // c0f9: RST75 trigger (written by NMI handler)
r17814	r17815
440	440
441	441	case 2: // c0fa: INTR trigger (written by NMI handler)
442	442	// verified on PCB:
443		device_set_input_line(m_audio_cpu, I8085_INTR_LINE, HOLD_LINE);
	443	m_audio_cpu->execute().set_input_line(I8085_INTR_LINE, HOLD_LINE);
444	444	break;
445	445
446	446	case 3: // c0fb: n.c.
r17814	r17815
692	692
693	693	WRITE16_MEMBER(equites_state::mcu_halt_assert_w)
694	694	{
695		device_set_input_line(m_mcu, INPUT_LINE_HALT, ASSERT_LINE);
	695	m_mcu->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
696	696	}
697	697
698	698	WRITE16_MEMBER(equites_state::mcu_halt_clear_w)
699	699	{
700		device_set_input_line(m_mcu, INPUT_LINE_HALT, CLEAR_LINE);
	700	m_mcu->execute().set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
701	701	}
702	702
703	703

trunk/src/mame/drivers/mirax.c

r17814	r17815
446	446	{
447	447	mirax_state *state = device->machine().driver_data<mirax_state>();
448	448	if(state->m_nmi_mask)
449		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	449	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
450	450	}
451	451
452	452	static MACHINE_CONFIG_START( mirax, mirax_state )

trunk/src/mame/drivers/gradius3.c

r17814	r17815
82	82	m_priority = data & 0x04;
83	83
84	84	/* bit 3 enables cpu B */
85		device_set_input_line(m_subcpu, INPUT_LINE_RESET, (data & 0x08) ? CLEAR_LINE : ASSERT_LINE);
	85	m_subcpu->set_input_line(INPUT_LINE_RESET, (data & 0x08) ? CLEAR_LINE : ASSERT_LINE);
86	86
87	87	/* bit 5 enables irq */
88	88	m_irqAen = data & 0x20;
r17814	r17815
103	103	{
104	104	gradius3_state *state = device->machine().driver_data<gradius3_state>();
105	105	if (state->m_irqAen)
106		device_set_input_line(device, 2, HOLD_LINE);
	106	device->execute().set_input_line(2, HOLD_LINE);
107	107	}
108	108
109	109
r17814	r17815
125	125	if (m_irqBmask & 4)
126	126	{
127	127	logerror("%04x trigger cpu B irq 4 %02x\n",space.device().safe_pc(),data);
128		device_set_input_line(m_subcpu, 4, HOLD_LINE);
	128	m_subcpu->set_input_line(4, HOLD_LINE);
129	129	}
130	130	else
131	131	logerror("%04x MISSED cpu B irq 4 %02x\n",space.device().safe_pc(),data);
r17814	r17815
139	139
140	140	WRITE16_MEMBER(gradius3_state::sound_irq_w)
141	141	{
142		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	142	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
143	143	}
144	144
145	145	WRITE8_MEMBER(gradius3_state::sound_bank_w)
r17814	r17815
290	290	{
291	291	gradius3_state *state = machine.driver_data<gradius3_state>();
292	292
293		state->m_maincpu = machine.device("maincpu");
294		state->m_audiocpu = machine.device("audiocpu");
295		state->m_subcpu = machine.device("sub");
	293	state->m_maincpu = machine.device<cpu_device>("maincpu");
	294	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
	295	state->m_subcpu = machine.device<cpu_device>("sub");
296	296	state->m_k007232 = machine.device("k007232");
297	297	state->m_k052109 = machine.device("k052109");
298	298	state->m_k051960 = machine.device("k051960");

trunk/src/mame/drivers/mystwarr.c

r17814	r17815
112	112	if (!(state->m_mw_irq_control & 0x01)) return;
113	113
114	114	if(scanline == 240)
115		device_set_input_line(state->m_maincpu, M68K_IRQ_2, HOLD_LINE);
	115	state->m_maincpu->set_input_line(M68K_IRQ_2, HOLD_LINE);
116	116
117	117	if(scanline == 0)
118		device_set_input_line(state->m_maincpu, M68K_IRQ_4, HOLD_LINE);
	118	state->m_maincpu->set_input_line(M68K_IRQ_4, HOLD_LINE);
119	119
120	120	/* writes to LSB of 0x410000 port and clears a work RAM flag, almost likely not really necessary. */
121		//  device_set_input_line(state->m_maincpu, M68K_IRQ_6, HOLD_LINE);
	121	//  state->m_maincpu->set_input_line(M68K_IRQ_6, HOLD_LINE);
122	122	}
123	123
124	124	static TIMER_DEVICE_CALLBACK(metamrph_interrupt)
r17814	r17815
127	127	int scanline = param;
128	128
129	129	/* irq 4 has an irq routine in metamrph, but it's not really called */
130		//  device_set_input_line(state->m_maincpu, M68K_IRQ_4, HOLD_LINE);
	130	//  state->m_maincpu->set_input_line(M68K_IRQ_4, HOLD_LINE);
131	131
132	132	if(scanline == 24)
133		device_set_input_line(state->m_maincpu, M68K_IRQ_6, HOLD_LINE);
	133	state->m_maincpu->set_input_line(M68K_IRQ_6, HOLD_LINE);
134	134
135	135	if(scanline == 248)
136		if (K053246_is_IRQ_enabled()) device_set_input_line(state->m_maincpu, M68K_IRQ_5, HOLD_LINE);
	136	if (K053246_is_IRQ_enabled()) state->m_maincpu->set_input_line(M68K_IRQ_5, HOLD_LINE);
137	137	}
138	138
139	139	static TIMER_DEVICE_CALLBACK(mchamp_interrupt)
r17814	r17815
145	145
146	146	if(scanline == 247)
147	147	{
148		if (K053246_is_IRQ_enabled()) device_set_input_line(state->m_maincpu, M68K_IRQ_6, HOLD_LINE);
	148	if (K053246_is_IRQ_enabled()) state->m_maincpu->set_input_line(M68K_IRQ_6, HOLD_LINE);
149	149	}
150	150
151	151	if(scanline == 23)
152		device_set_input_line(state->m_maincpu, M68K_IRQ_2, HOLD_LINE);
	152	state->m_maincpu->set_input_line(M68K_IRQ_2, HOLD_LINE);
153	153	}
154	154
155	155	static INTERRUPT_GEN(ddd_interrupt)
156	156	{
157		device_set_input_line(device, M68K_IRQ_5, HOLD_LINE);
	157	device->execute().set_input_line(M68K_IRQ_5, HOLD_LINE);
158	158	}
159	159
160	160

trunk/src/mame/drivers/jollyjgr.c

r17814	r17815
622	622	{
623	623	jollyjgr_state *state = device->machine().driver_data<jollyjgr_state>();
624	624	if(state->m_nmi_enable)
625		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	625	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
626	626	}
627	627
628	628

trunk/src/mame/drivers/ssfindo.c

r17814	r17815
355	355	static void ssfindo_speedups(address_space* space)
356	356	{
357	357	if (space->device().safe_pc()==0x2d6c8) // ssfindo
358		device_spin_until_time(&space->device(), attotime::from_usec(20));
	358	space->device().execute().spin_until_time(attotime::from_usec(20));
359	359	else if (space->device().safe_pc()==0x2d6bc) // ssfindo
360		device_spin_until_time(&space->device(), attotime::from_usec(20));
	360	space->device().execute().spin_until_time(attotime::from_usec(20));
361	361	}
362	362
363	363	static void ppcar_speedups(address_space* space)
364	364	{
365	365	if (space->device().safe_pc()==0x000bc8) // ppcar
366		device_spin_until_time(&space->device(), attotime::from_usec(20));
	366	space->device().execute().spin_until_time(attotime::from_usec(20));
367	367	else if (space->device().safe_pc()==0x000bbc) // ppcar
368		device_spin_until_time(&space->device(), attotime::from_usec(20));
	368	space->device().execute().spin_until_time(attotime::from_usec(20));
369	369	}
370	370
371	371

trunk/src/mame/drivers/firetrk.c

r17814	r17815
53	53
54	54	/* NMI interrupts are disabled during service mode in firetrk and montecar */
55	55	if (!state->m_in_service_mode)
56		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	56	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
57	57	}
58	58
59	59

trunk/src/mame/drivers/ddayjlc.c

r17814	r17815
85	85	UINT8    m_prot_addr;
86	86
87	87	/* devices */
88		device_t *m_audiocpu;
	88	cpu_device *m_audiocpu;
89	89	DECLARE_WRITE8_MEMBER(prot_w);
90	90	DECLARE_WRITE8_MEMBER(char_bank_w);
91	91	DECLARE_WRITE8_MEMBER(ddayjlc_bgram_w);
r17814	r17815
212	212	{
213	213
214	214	soundlatch_byte_w(space, offset, data);
215		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	215	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
216	216	}
217	217
218	218	WRITE8_MEMBER(ddayjlc_state::i8257_CH0_w)
r17814	r17815
436	436	{
437	437	ddayjlc_state *state = device->machine().driver_data<ddayjlc_state>();
438	438	if(state->m_main_nmi_enable)
439		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	439	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
440	440	}
441	441
442	442	static INTERRUPT_GEN( ddayjlc_snd_interrupt )
443	443	{
444	444	ddayjlc_state *state = device->machine().driver_data<ddayjlc_state>();
445	445	if(state->m_sound_nmi_enable)
446		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	446	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
447	447	}
448	448
449	449
r17814	r17815
451	451	{
452	452	ddayjlc_state *state = machine.driver_data<ddayjlc_state>();
453	453
454		state->m_audiocpu = machine.device("audiocpu");
	454	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
455	455
456	456	state->save_item(NAME(state->m_char_bank));
457	457	state->save_item(NAME(state->m_bgadr));

trunk/src/mame/drivers/sprcros2.c

r17814	r17815
253	253	if (scanline == 240)
254	254	{
255	255	if(state->m_port7&0x01)
256		device_set_input_line(state->m_master, INPUT_LINE_NMI, PULSE_LINE);
	256	state->m_master->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
257	257	}
258	258	else if(scanline == 0)
259	259	{
260	260	if(state->m_port7&0x08)
261		device_set_input_line(state->m_master, 0, HOLD_LINE);
	261	state->m_master->set_input_line(0, HOLD_LINE);
262	262	}
263	263	}
264	264
r17814	r17815
267	267	sprcros2_state *state = device->machine().driver_data<sprcros2_state>();
268	268
269	269	if(state->m_s_port3&0x01)
270		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	270	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
271	271	}
272	272
273	273	static MACHINE_START( sprcros2 )

trunk/src/mame/drivers/konamigx.c

r17814	r17815
548	548
549	549	if (space.device().safe_pc() == waitskip.pc && (data & mem_mask) == (waitskip.data & mem_mask))
550	550	{
551		device_spin_until_trigger(&space.device(), resume_trigger);
	551	space.device().execute().spin_until_trigger(resume_trigger);
552	552	suspension_active = 1;
553	553	}
554	554
r17814	r17815
650	650	if ((konamigx_wrport1_1 & 0x81) == 0x81 || (gx_syncen & 1))
651	651	{
652	652	gx_syncen &= ~1;
653		device_set_input_line(device, 1, HOLD_LINE);
	653	device->execute().set_input_line(1, HOLD_LINE);
654	654	}
655	655	}
656	656
r17814	r17815
681	681	if ((konamigx_wrport1_1 & 0x81) == 0x81 || (gx_syncen & 1))
682	682	{
683	683	gx_syncen &= ~1;
684		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	684	state->m_maincpu->set_input_line(1, HOLD_LINE);
685	685
686	686	}
687	687	}
r17814	r17815
698	698	if ((konamigx_wrport1_1 & 0x82) == 0x82 || (gx_syncen & 2))
699	699	{
700	700	gx_syncen &= ~2;
701		device_set_input_line(state->m_maincpu, 2, HOLD_LINE);
	701	state->m_maincpu->set_input_line(2, HOLD_LINE);
702	702	}
703	703	}
704	704	}

trunk/src/mame/drivers/parodius.c

r17814	r17815
23	23	{
24	24	parodius_state *state = device->machine().driver_data<parodius_state>();
25	25	if (k052109_is_irq_enabled(state->m_k052109))
26		device_set_input_line(device, 0, HOLD_LINE);
	26	device->execute().set_input_line(0, HOLD_LINE);
27	27	}
28	28
29	29	READ8_MEMBER(parodius_state::bankedram_r)
r17814	r17815
108	108
109	109	WRITE8_MEMBER(parodius_state::parodius_sh_irqtrigger_w)
110	110	{
111		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	111	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
112	112	}
113	113
114	114	#if 0
r17814	r17815
116	116	static void sound_nmi_callback( running_machine &machine, int param )
117	117	{
118	118	parodius_state *state = machine.driver_data<parodius_state>();
119		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, ( state->m_nmi_enabled ) ? CLEAR_LINE : ASSERT_LINE );
	119	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, ( state->m_nmi_enabled ) ? CLEAR_LINE : ASSERT_LINE );
120	120
121	121	nmi_enabled = 0;
122	122	}
r17814	r17815
125	125	static TIMER_CALLBACK( nmi_callback )
126	126	{
127	127	parodius_state *state = machine.driver_data<parodius_state>();
128		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, ASSERT_LINE);
	128	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
129	129	}
130	130
131	131	WRITE8_MEMBER(parodius_state::sound_arm_nmi_w)
132	132	{
133	133
134		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, CLEAR_LINE);
	134	m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
135	135	machine().scheduler().timer_set(attotime::from_usec(50), FUNC(nmi_callback));   /* kludge until the K053260 is emulated correctly */
136	136	}
137	137
r17814	r17815
257	257
258	258	state->m_generic_paletteram_8.allocate(0x1000);
259	259
260		state->m_maincpu = machine.device("maincpu");
261		state->m_audiocpu = machine.device("audiocpu");
	260	state->m_maincpu = machine.device<cpu_device>("maincpu");
	261	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
262	262	state->m_k053260 = machine.device("k053260");
263	263	state->m_k053245 = machine.device("k053245");
264	264	state->m_k053251 = machine.device("k053251");

trunk/src/mame/drivers/combatsc.c

r17814	r17815
151	151	WRITE8_MEMBER(combatsc_state::combatscb_sh_irqtrigger_w)
152	152	{
153	153	soundlatch_byte_w(space, offset, data);
154		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	154	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
155	155	}
156	156
157	157	READ8_MEMBER(combatsc_state::combatscb_io_r)
r17814	r17815
322	322
323	323	WRITE8_MEMBER(combatsc_state::combatsc_sh_irqtrigger_w)
324	324	{
325		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	325	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
326	326	}
327	327
328	328	READ8_MEMBER(combatsc_state::combatsc_busy_r)

trunk/src/mame/drivers/rockrage.c

r17814	r17815
61	61	{
62	62	rockrage_state *state = device->machine().driver_data<rockrage_state>();
63	63	if (k007342_is_int_enabled(state->m_k007342))
64		device_set_input_line(device, HD6309_IRQ_LINE, HOLD_LINE);
	64	device->execute().set_input_line(HD6309_IRQ_LINE, HOLD_LINE);
65	65	}
66	66
67	67	WRITE8_MEMBER(rockrage_state::rockrage_bankswitch_w)
r17814	r17815
79	79	WRITE8_MEMBER(rockrage_state::rockrage_sh_irqtrigger_w)
80	80	{
81	81	soundlatch_byte_w(space, offset, data);
82		device_set_input_line(m_audiocpu, M6809_IRQ_LINE, HOLD_LINE);
	82	m_audiocpu->set_input_line(M6809_IRQ_LINE, HOLD_LINE);
83	83	}
84	84
85	85	READ8_MEMBER(rockrage_state::rockrage_VLM5030_busy_r)
r17814	r17815
243	243
244	244	state->membank("bank1")->configure_entries(0, 8, &ROM[0x10000], 0x2000);
245	245
246		state->m_audiocpu = machine.device("audiocpu");
	246	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
247	247	state->m_k007342 = machine.device("k007342");
248	248	state->m_k007420 = machine.device("k007420");
249	249

trunk/src/mame/drivers/egghunt.c

r17814	r17815
61	61	UINT8     m_gfx_banking;
62	62
63	63	/* devices */
64		device_t *m_audiocpu;
	64	cpu_device *m_audiocpu;
65	65
66	66	/* memory */
67	67	required_shared_ptr<UINT8> m_atram;
r17814	r17815
203	203	WRITE8_MEMBER(egghunt_state::egghunt_soundlatch_w)
204	204	{
205	205	soundlatch_byte_w(space, 0, data);
206		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	206	m_audiocpu->set_input_line(0, HOLD_LINE);
207	207	}
208	208
209	209	READ8_MEMBER(egghunt_state::egghunt_okibanking_r)
r17814	r17815
391	391	{
392	392	egghunt_state *state = machine.driver_data<egghunt_state>();
393	393
394		state->m_audiocpu = machine.device("audiocpu");
	394	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
395	395
396	396	state->save_item(NAME(state->m_gfx_banking));
397	397	state->save_item(NAME(state->m_okibanking));

trunk/src/mame/drivers/sandscrp.c

r17814	r17815
255	255	m_latch1_full = 1;
256	256	soundlatch_byte_w(space, 0, data & 0xff);
257	257	machine().device("audiocpu")->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
258		device_spin_until_time(&space.device(), attotime::from_usec(100));   // Allow the other cpu to reply
	258	space.device().execute().spin_until_time(attotime::from_usec(100));   // Allow the other cpu to reply
259	259	}
260	260	}
261	261

trunk/src/mame/drivers/gpworld.c

r17814	r17815
435	435	{
436	436	state->m_laserdisc->data_w(state->m_ldp_write_latch);
437	437	state->m_ldp_read_latch = state->m_laserdisc->status_r();
438		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	438	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
439	439	}
440	440
441	441	/* The time the IRQ line stays high is set just long enough to happen after the NMI - hacky? */
442		device_set_input_line(device, 0, ASSERT_LINE);
	442	device->execute().set_input_line(0, ASSERT_LINE);
443	443	device->machine().scheduler().timer_set(attotime::from_usec(100), FUNC(irq_stop));
444	444	}
445	445

trunk/src/mame/drivers/homedata.c

r17814	r17815
227	227	{
228	228	homedata_state *state = device->machine().driver_data<homedata_state>();
229	229	state->m_vblank = 1;
230		device_set_input_line(device, M6809_FIRQ_LINE, HOLD_LINE);
	230	device->execute().set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
231	231	}
232	232
233	233	static INTERRUPT_GEN( upd7807_irq )
234	234	{
235		device_set_input_line(device, UPD7810_INTF1, HOLD_LINE);
	235	device->execute().set_input_line(UPD7810_INTF1, HOLD_LINE);
236	236	}
237	237
238	238
r17814	r17815
317	317	WRITE8_MEMBER(homedata_state::mrokumei_sound_cmd_w)
318	318	{
319	319	soundlatch_byte_w(space, offset, data);
320		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	320	m_audiocpu->set_input_line(0, HOLD_LINE);
321	321	}
322	322
323	323
r17814	r17815
1144	1144	{
1145	1145	homedata_state *state = machine.driver_data<homedata_state>();
1146	1146
1147		state->m_maincpu = machine.device("maincpu");
1148		state->m_audiocpu = machine.device("audiocpu");
	1147	state->m_maincpu = machine.device<cpu_device>("maincpu");
	1148	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
1149	1149	state->m_ym = machine.device("ymsnd");
1150	1150	state->m_sn = machine.device<sn76489a_new_device>("snsnd");
1151	1151	state->m_dac = machine.device<dac_device>("dac");

trunk/src/mame/drivers/mugsmash.c

r17814	r17815
56	56	{
57	57	case 1:
58	58	soundlatch_byte_w(space, 1, data & 0xff);
59		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE );
	59	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE );
60	60	break;
61	61
62	62	default:
r17814	r17815
391	391	static void irq_handler(device_t *device, int irq)
392	392	{
393	393	mugsmash_state *state = device->machine().driver_data<mugsmash_state>();
394		device_set_input_line(state->m_audiocpu, 0 , irq ? ASSERT_LINE : CLEAR_LINE );
	394	state->m_audiocpu->set_input_line(0 , irq ? ASSERT_LINE : CLEAR_LINE );
395	395	}
396	396
397	397	static const ym2151_interface ym2151_config =
r17814	r17815
403	403	{
404	404	mugsmash_state *state = machine.driver_data<mugsmash_state>();
405	405
406		state->m_maincpu = machine.device("maincpu");
407		state->m_audiocpu = machine.device("audiocpu");
	406	state->m_maincpu = machine.device<cpu_device>("maincpu");
	407	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
408	408	}
409	409
410	410	static MACHINE_CONFIG_START( mugsmash, mugsmash_state )

trunk/src/mame/drivers/hng64.c

r17814	r17815
1751	1751	}
1752	1752	}
1753	1753
1754		device_set_input_line(m_maincpu, 0, ASSERT_LINE);
	1754	m_maincpu->set_input_line(0, ASSERT_LINE);
1755	1755	}
1756	1756	else
1757		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	1757	m_maincpu->set_input_line(0, CLEAR_LINE);
1758	1758	}
1759	1759
1760	1760	static TIMER_DEVICE_CALLBACK( hng64_irq )

trunk/src/mame/drivers/solomon.c

r17814	r17815
198	198	solomon_state *state = device->machine().driver_data<solomon_state>();
199	199
200	200	if(state->m_nmi_mask)
201		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	201	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
202	202	}
203	203
204	204

trunk/src/mame/drivers/macrossp.c

r17814	r17815
338	338	//logerror("%08x write soundcmd %08x (%08x)\n",space.device().safe_pc(),data,mem_mask);
339	339	soundlatch_word_w(space, 0, data >> 16, 0xffff);
340	340	m_sndpending = 1;
341		device_set_input_line(m_audiocpu, 2, HOLD_LINE);
	341	m_audiocpu->set_input_line(2, HOLD_LINE);
342	342	/* spin for a while to let the sound CPU read the command */
343		device_spin_until_time(&space.device(), attotime::from_usec(50));
	343	space.device().execute().spin_until_time(attotime::from_usec(50));
344	344	}
345	345	}
346	346
r17814	r17815
584	584
585	585	/* IRQ lines 1 & 4 on the sound 68000 are definitely triggered by the ES5506,
586	586	but I haven't noticed the ES5506 ever assert the line - maybe only used when developing the game? */
587		//  device_set_input_line(state->m_audiocpu, 1, irq ? ASSERT_LINE : CLEAR_LINE);
	587	//  state->m_audiocpu->set_input_line(1, irq ? ASSERT_LINE : CLEAR_LINE);
588	588	}
589	589
590	590	static const es5506_interface es5506_config =
r17814	r17815
601	601	{
602	602	macrossp_state *state = machine.driver_data<macrossp_state>();
603	603
604		state->m_maincpu = machine.device("maincpu");
605		state->m_audiocpu = machine.device("audiocpu");
	604	state->m_maincpu = machine.device<cpu_device>("maincpu");
	605	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
606	606
607	607	state->save_item(NAME(state->m_sndpending));
608	608	state->save_item(NAME(state->m_snd_toggle));
r17814	r17815
770	770	*/
771	771
772	772	COMBINE_DATA(&m_mainram[0x10158 / 4]);
773		if (space.device().safe_pc() == 0x001810A) device_spin_until_interrupt(&space.device());
	773	if (space.device().safe_pc() == 0x001810A) space.device().execute().spin_until_interrupt();
774	774	}
775	775
776	776	#ifdef UNUSED_FUNCTION
r17814	r17815
778	778	{
779	779
780	780	COMBINE_DATA(&m_mainram[0x00020 / 4]);
781		if (space.device().safe_pc() == 0x1cc) device_spin_until_interrupt(&space.device());
	781	if (space.device().safe_pc() == 0x1cc) space.device().execute().spin_until_interrupt();
782	782	}
783	783	#endif
784	784

trunk/src/mame/drivers/imolagp.c

r17814	r17815
108	108	int   m_oldsteer;
109	109
110	110	/* devices */
111		device_t *m_slavecpu;
	111	cpu_device *m_slavecpu;
112	112
113	113	/* memory */
114	114	UINT8  m_videoram[3][0x4000];
r17814	r17815
155	155	}
156	156	READ8_MEMBER(imolagp_state::trigger_slave_nmi_r)
157	157	{
158		device_set_input_line(m_slave, INPUT_LINE_NMI, PULSE_LINE);
	158	m_slave->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
159	159	return 0;
160	160	}
161	161
r17814	r17815
486	486	{
487	487	state->m_oldsteer = (state->m_oldsteer + 1) & 0xf;
488	488	}
489		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	489	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
490	490	}
491	491	}
492	492	}
r17814	r17815
499	499	memcpy(&state->m_slave_workram[0x80], state->m_mComData, state->m_mComCount);
500	500	state->m_mComCount = 0;
501	501	#endif
502		device_set_input_line(device, 0, HOLD_LINE);
	502	device->execute().set_input_line(0, HOLD_LINE);
503	503	} /* master_interrupt */
504	504
505	505
r17814	r17815
518	518	{
519	519	imolagp_state *state = machine.driver_data<imolagp_state>();
520	520
521		state->m_slavecpu = machine.device("slave");
	521	state->m_slavecpu = machine.device<cpu_device>("slave");
522	522
523	523	state->save_item(NAME(state->m_control));
524	524	state->save_item(NAME(state->m_scroll));

trunk/src/mame/drivers/gyruss.c

r17814	r17815
118	118
119	119	WRITE8_MEMBER(gyruss_state::gyruss_irq_clear_w)
120	120	{
121		device_set_input_line(m_audiocpu_2, 0, CLEAR_LINE);
	121	m_audiocpu_2->set_input_line(0, CLEAR_LINE);
122	122	}
123	123
124	124	static void filter_w( device_t *device, int chip, int data )
r17814	r17815
149	149	WRITE8_MEMBER(gyruss_state::gyruss_sh_irqtrigger_w)
150	150	{
151	151	/* writing to this register triggers IRQ on the sound CPU */
152		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	152	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
153	153	}
154	154
155	155	WRITE8_MEMBER(gyruss_state::gyruss_i8039_irq_w)
156	156	{
157		device_set_input_line(m_audiocpu_2, 0, ASSERT_LINE);
	157	m_audiocpu_2->set_input_line(0, ASSERT_LINE);
158	158	}
159	159
160	160	WRITE8_MEMBER(gyruss_state::master_nmi_mask_w)
r17814	r17815
501	501	gyruss_state *state = device->machine().driver_data<gyruss_state>();
502	502
503	503	if (state->m_master_nmi_mask)
504		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	504	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
505	505	}
506	506
507	507	static INTERRUPT_GEN( slave_vblank_irq )
r17814	r17815
509	509	gyruss_state *state = device->machine().driver_data<gyruss_state>();
510	510
511	511	if (state->m_slave_irq_mask)
512		device_set_input_line(device, 0, HOLD_LINE);
	512	device->execute().set_input_line(0, HOLD_LINE);
513	513	}
514	514
515	515	static MACHINE_CONFIG_START( gyruss, gyruss_state )

trunk/src/mame/drivers/fastlane.c

r17814	r17815
22	22	int scanline = param;
23	23
24	24	if(scanline == 240 && k007121_ctrlram_r(state->m_k007121, 7) & 0x02) // vblank irq
25		device_set_input_line(state->m_maincpu, HD6309_IRQ_LINE, HOLD_LINE);
	25	state->m_maincpu->set_input_line(HD6309_IRQ_LINE, HOLD_LINE);
26	26	else if(((scanline % 32) == 0) && k007121_ctrlram_r(state->m_k007121, 7) & 0x01) // timer irq
27		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	27	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
28	28	}
29	29
30	30

trunk/src/mame/drivers/gamecstl.c

r17814	r17815
622	622	{
623	623	machine.root_device().membank("bank1")->set_base(machine.root_device().memregion("bios")->base() + 0x30000);
624	624
625		device_set_irq_callback(machine.device("maincpu"), irq_callback);
	625	machine.device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
626	626	}
627	627
628	628

trunk/src/mame/drivers/cabal.c

r17814	r17815
106	106	seibu_main_word_w(&space,4,data,mem_mask);
107	107
108	108	/* spin for a while to let the Z80 read the command, otherwise coins "stick" */
109		device_spin_until_time(&space.device(), attotime::from_usec(50));
	109	space.device().execute().spin_until_time(attotime::from_usec(50));
110	110	}
111	111
112	112	WRITE16_MEMBER(cabal_state::cabalbl_sound_irq_trigger_word_w)

trunk/src/mame/drivers/hotblock.c

r17814	r17815
197	197
198	198	static INTERRUPT_GEN( hotblocks_irq ) /* right? */
199	199	{
200		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	200	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
201	201	}
202	202
203	203	static const ay8910_interface ay8910_config =

trunk/src/mame/drivers/vendetta.c

r17814	r17815
201	201	static TIMER_CALLBACK( z80_nmi_callback )
202	202	{
203	203	vendetta_state *state = machine.driver_data<vendetta_state>();
204		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, ASSERT_LINE);
	204	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
205	205	}
206	206
207	207	WRITE8_MEMBER(vendetta_state::z80_arm_nmi_w)
208	208	{
209		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, CLEAR_LINE);
	209	m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
210	210
211	211	machine().scheduler().timer_set(attotime::from_usec(25), FUNC(z80_nmi_callback));
212	212	}
213	213
214	214	WRITE8_MEMBER(vendetta_state::z80_irq_w)
215	215	{
216		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	216	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
217	217	}
218	218
219	219	READ8_MEMBER(vendetta_state::vendetta_sound_interrupt_r)
220	220	{
221		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	221	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
222	222	return 0x00;
223	223	}
224	224
r17814	r17815
408	408	{
409	409	vendetta_state *state = device->machine().driver_data<vendetta_state>();
410	410	if (state->m_irq_enabled)
411		device_set_input_line(device, KONAMI_IRQ_LINE, HOLD_LINE);
	411	device->execute().set_input_line(KONAMI_IRQ_LINE, HOLD_LINE);
412	412	}
413	413
414	414	static const k052109_interface vendetta_k052109_intf =
r17814	r17815
467	467
468	468	state->m_generic_paletteram_8.allocate(0x1000);
469	469
470		state->m_maincpu = machine.device("maincpu");
471		state->m_audiocpu = machine.device("audiocpu");
	470	state->m_maincpu = machine.device<cpu_device>("maincpu");
	471	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
472	472	state->m_k053246 = machine.device("k053246");
473	473	state->m_k053251 = machine.device("k053251");
474	474	state->m_k052109 = machine.device("k052109");

trunk/src/mame/drivers/saturn.c

r17814	r17815
272	272	{
273	273	if(irq_level[i] != -1) /* TODO: cheap check for undefined irqs */
274	274	{
275		device_set_input_line_and_vector(state->m_maincpu, irq_level[i], HOLD_LINE, 0x40 + i);
	275	state->m_maincpu->set_input_line_and_vector(irq_level[i], HOLD_LINE, 0x40 + i);
276	276	state->m_scu.ist &= ~(1 << i);
277	277	return; /* avoid spurious irqs, correct? */
278	278	}
r17814	r17815
408	408	saturn_state *state = machine.driver_data<saturn_state>();
409	409
410	410	if(!(state->m_scu.ism & IRQ_DMALV0))
411		device_set_input_line_and_vector(state->m_maincpu, 5, HOLD_LINE, 0x4b);
	411	state->m_maincpu->set_input_line_and_vector(5, HOLD_LINE, 0x4b);
412	412	else
413	413	state->m_scu.ist |= (IRQ_DMALV0);
414	414
r17814	r17815
421	421	saturn_state *state = machine.driver_data<saturn_state>();
422	422
423	423	if(!(state->m_scu.ism & IRQ_DMALV1))
424		device_set_input_line_and_vector(state->m_maincpu, 6, HOLD_LINE, 0x4a);
	424	state->m_maincpu->set_input_line_and_vector(6, HOLD_LINE, 0x4a);
425	425	else
426	426	state->m_scu.ist |= (IRQ_DMALV1);
427	427
r17814	r17815
434	434	saturn_state *state = machine.driver_data<saturn_state>();
435	435
436	436	if(!(state->m_scu.ism & IRQ_DMALV2))
437		device_set_input_line_and_vector(state->m_maincpu, 6, HOLD_LINE, 0x49);
	437	state->m_maincpu->set_input_line_and_vector(6, HOLD_LINE, 0x49);
438	438	else
439	439	state->m_scu.ist |= (IRQ_DMALV2);
440	440
r17814	r17815
901	901
902	902	/* TODO: NMI doesn't stay held on SH-2 core so we can't use ASSERT_LINE/CLEAR_LINE with that yet */
903	903	if(newval)
904		device_set_input_line(m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	904	m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
905	905	}
906	906
907	907	INPUT_CHANGED_MEMBER(saturn_state::tray_open)
r17814	r17815
1661	1661
1662	1662	if(!(drvstate->m_scu.ism & IRQ_SOUND_REQ))
1663	1663	{
1664		device_set_input_line_and_vector(drvstate->m_maincpu, 9, HOLD_LINE, 0x46);
	1664	drvstate->m_maincpu->set_input_line_and_vector(9, HOLD_LINE, 0x46);
1665	1665	scu_do_transfer(device->machine(),5);
1666	1666	}
1667	1667	else
r17814	r17815
1751	1751	system_time systime;
1752	1752	machine.base_datetime(systime);
1753	1753
1754		state->m_maincpu = downcast<legacy_cpu_device*>( machine.device("maincpu") );
	1754	state->m_maincpu = downcast<legacy_cpu_device*>( machine.device<cpu_device>("maincpu") );
1755	1755	state->m_slave = downcast<legacy_cpu_device*>( machine.device("slave") );
1756		state->m_audiocpu = downcast<legacy_cpu_device*>( machine.device("audiocpu") );
	1756	state->m_audiocpu = downcast<legacy_cpu_device*>( machine.device<cpu_device>("audiocpu") );
1757	1757
1758	1758	scsp_set_ram_base(machine.device("scsp"), state->m_sound_ram);
1759	1759
r17814	r17815
1795	1795	system_time systime;
1796	1796	machine.base_datetime(systime);
1797	1797
1798		state->m_maincpu = downcast<legacy_cpu_device*>( machine.device("maincpu") );
	1798	state->m_maincpu = downcast<legacy_cpu_device*>( machine.device<cpu_device>("maincpu") );
1799	1799	state->m_slave = downcast<legacy_cpu_device*>( machine.device("slave") );
1800		state->m_audiocpu = downcast<legacy_cpu_device*>( machine.device("audiocpu") );
	1800	state->m_audiocpu = downcast<legacy_cpu_device*>( machine.device<cpu_device>("audiocpu") );
1801	1801
1802	1802	scsp_set_ram_base(machine.device("scsp"), state->m_sound_ram);
1803	1803
r17814	r17815
1883	1883
1884	1884	if(!(state->m_scu.ism & IRQ_VDP1_END))
1885	1885	{
1886		device_set_input_line_and_vector(state->m_maincpu, 0x2, HOLD_LINE, 0x4d);
	1886	state->m_maincpu->set_input_line_and_vector(0x2, HOLD_LINE, 0x4d);
1887	1887	scu_do_transfer(timer.machine(),6);
1888	1888	}
1889	1889	else
r17814	r17815
1894	1894	{
1895	1895	if(!(state->m_scu.ism & IRQ_VBLANK_OUT))
1896	1896	{
1897		device_set_input_line_and_vector(state->m_maincpu, 0xe, HOLD_LINE, 0x41);
	1897	state->m_maincpu->set_input_line_and_vector(0xe, HOLD_LINE, 0x41);
1898	1898	scu_do_transfer(timer.machine(),1);
1899	1899	}
1900	1900	else
r17814	r17815
1905	1905	{
1906	1906	if(!(state->m_scu.ism & IRQ_VBLANK_IN))
1907	1907	{
1908		device_set_input_line_and_vector(state->m_maincpu, 0xf, HOLD_LINE ,0x40);
	1908	state->m_maincpu->set_input_line_and_vector(0xf, HOLD_LINE ,0x40);
1909	1909	scu_do_transfer(timer.machine(),0);
1910	1910	}
1911	1911	else
r17814	r17815
1915	1915	{
1916	1916	if(!(state->m_scu.ism & IRQ_HBLANK_IN))
1917	1917	{
1918		device_set_input_line_and_vector(state->m_maincpu, 0xd, HOLD_LINE, 0x42);
	1918	state->m_maincpu->set_input_line_and_vector(0xd, HOLD_LINE, 0x42);
1919	1919	scu_do_transfer(timer.machine(),2);
1920	1920	}
1921	1921	else
r17814	r17815
1926	1926	{
1927	1927	if(!(state->m_scu.ism & IRQ_TIMER_0))
1928	1928	{
1929		device_set_input_line_and_vector(state->m_maincpu, 0xc, HOLD_LINE, 0x43 );
	1929	state->m_maincpu->set_input_line_and_vector(0xc, HOLD_LINE, 0x43 );
1930	1930	scu_do_transfer(timer.machine(),3);
1931	1931	}
1932	1932	else
r17814	r17815
1941	1941	{
1942	1942	if(!(state->m_scu.ism & IRQ_TIMER_1))
1943	1943	{
1944		device_set_input_line_and_vector(state->m_maincpu, 0xb, HOLD_LINE, 0x44 );
	1944	state->m_maincpu->set_input_line_and_vector(0xb, HOLD_LINE, 0x44 );
1945	1945	scu_do_transfer(timer.machine(),4);
1946	1946	}
1947	1947	else
r17814	r17815
1965	1965	vblank_line = (state->m_vdp2.pal) ? 288 : 240;
1966	1966
1967	1967	if(scanline == vblank_line*y_step)
1968		device_set_input_line_and_vector(state->m_slave, 0x6, HOLD_LINE, 0x43);
	1968	state->m_slave->set_input_line_and_vector(0x6, HOLD_LINE, 0x43);
1969	1969	else if((scanline % y_step) == 0 && scanline < vblank_line*y_step)
1970		device_set_input_line_and_vector(state->m_slave, 0x2, HOLD_LINE, 0x41);
	1970	state->m_slave->set_input_line_and_vector(0x2, HOLD_LINE, 0x41);
1971	1971	}
1972	1972
1973	1973	/* Die Hard Trilogy tests RAM address 0x25e7ffe bit 2 with Slave during FRT minit irq, in-development tool for breaking execution of it? */

trunk/src/mame/drivers/marineb.c

r17814	r17815
65	65	{
66	66	marineb_state *state = machine.driver_data<marineb_state>();
67	67
68		state->m_maincpu = machine.device("maincpu");
	68	state->m_maincpu = machine.device<cpu_device>("maincpu");
69	69	state->m_audiocpu = NULL;
70	70
71	71	state->save_item(NAME(state->m_marineb_active_low_flipscreen));
r17814	r17815
531	531	marineb_state *state = device->machine().driver_data<marineb_state>();
532	532
533	533	if(state->m_irq_mask)
534		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	534	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
535	535	}
536	536
537	537	static INTERRUPT_GEN( wanted_vblank_irq )
r17814	r17815
539	539	marineb_state *state = device->machine().driver_data<marineb_state>();
540	540
541	541	if(state->m_irq_mask)
542		device_set_input_line(device, 0, HOLD_LINE);
	542	device->execute().set_input_line(0, HOLD_LINE);
543	543	}
544	544
545	545

trunk/src/mame/drivers/pktgaldx.c

r17814	r17815
318	318	{
319	319	pktgaldx_state *state = machine.driver_data<pktgaldx_state>();
320	320
321		state->m_maincpu = machine.device("maincpu");
	321	state->m_maincpu = machine.device<cpu_device>("maincpu");
322	322	state->m_deco_tilegen1 = machine.device("tilegen1");
323	323	}
324	324

trunk/src/mame/drivers/timeplt.c

r17814	r17815
64	64	timeplt_state *state = device->machine().driver_data<timeplt_state>();
65	65
66	66	if (state->m_nmi_enable)
67		device_set_input_line(device, INPUT_LINE_NMI, ASSERT_LINE);
	67	device->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
68	68	}
69	69
70	70
r17814	r17815
72	72	{
73	73	m_nmi_enable = data & 1;
74	74	if (!m_nmi_enable)
75		device_set_input_line(m_maincpu, INPUT_LINE_NMI, CLEAR_LINE);
	75	m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
76	76	}
77	77
78	78

trunk/src/mame/drivers/circus.c

r17814	r17815
265	265	{
266	266	circus_state *state = machine.driver_data<circus_state>();
267	267
268		state->m_maincpu = machine.device("maincpu");
	268	state->m_maincpu = machine.device<cpu_device>("maincpu");
269	269	state->m_samples = machine.device<samples_device>("samples");
270	270	state->m_discrete = machine.device("discrete");
271	271

trunk/src/mame/drivers/taito_f3.c

r17814	r17815
397	397
398	398	static INTERRUPT_GEN( f3_interrupt2 )
399	399	{
400		device_set_input_line(device, 2, HOLD_LINE);   // vblank
	400	device->execute().set_input_line(2, HOLD_LINE);   // vblank
401	401	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(10000), FUNC(f3_interrupt3));
402	402	}
403	403

trunk/src/mame/drivers/champbas.c

r17814	r17815
132	132	m_irq_mask = data & 1;
133	133
134	134	if (!m_irq_mask)
135		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	135	m_maincpu->set_input_line(0, CLEAR_LINE);
136	136	}
137	137
138	138	static TIMER_CALLBACK( exctsccr_fm_callback )
139	139	{
140	140	champbas_state *state = machine.driver_data<champbas_state>();
141		device_set_input_line_and_vector(state->m_audiocpu, 0, HOLD_LINE, 0xff);
	141	state->m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
142	142	}
143	143
144	144	// Champion Baseball has only one DAC
r17814	r17815
180	180	return;
181	181
182	182	data &= 1;
183		device_set_input_line(m_mcu, INPUT_LINE_HALT, data ? ASSERT_LINE : CLEAR_LINE);
	183	m_mcu->execute().set_input_line(INPUT_LINE_HALT, data ? ASSERT_LINE : CLEAR_LINE);
184	184	}
185	185
186	186
r17814	r17815
580	580	{
581	581	champbas_state *state = machine.driver_data<champbas_state>();
582	582
583		state->m_maincpu = machine.device("maincpu");
	583	state->m_maincpu = machine.device<cpu_device>("maincpu");
584	584	state->m_mcu = machine.device(CPUTAG_MCU);
585	585
586	586	state->save_item(NAME(state->m_watchdog_count));
r17814	r17815
591	591	static MACHINE_START( exctsccr )
592	592	{
593	593	champbas_state *state = machine.driver_data<champbas_state>();
594		state->m_audiocpu = machine.device("audiocpu");
	594	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
595	595
596	596	// FIXME
597	597	machine.scheduler().timer_pulse(attotime::from_hz(75), FUNC(exctsccr_fm_callback)); /* updates fm */
r17814	r17815
613	613	champbas_state *state = device->machine().driver_data<champbas_state>();
614	614
615	615	if(state->m_irq_mask)
616		device_set_input_line(device, 0, ASSERT_LINE);
	616	device->execute().set_input_line(0, ASSERT_LINE);
617	617	}
618	618
619	619

trunk/src/mame/drivers/ssozumo.c

r17814	r17815
185	185	ssozumo_state *state = device->machine().driver_data<ssozumo_state>();
186	186
187	187	if(state->m_sound_nmi_mask)
188		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	188	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
189	189	}
190	190
191	191	static MACHINE_CONFIG_START( ssozumo, ssozumo_state )

trunk/src/mame/drivers/ninjaw.c

r17814	r17815
331	331	/* however this fails when recovering from a save state
332	332	if cpu B is disabled !! */
333	333	ninjaw_state *state = machine.driver_data<ninjaw_state>();
334		device_set_input_line(state->m_subcpu, INPUT_LINE_RESET, (state->m_cpua_ctrl & 0x1) ? CLEAR_LINE : ASSERT_LINE);
	334	state->m_subcpu->set_input_line(INPUT_LINE_RESET, (state->m_cpua_ctrl & 0x1) ? CLEAR_LINE : ASSERT_LINE);
335	335
336	336	}
337	337
r17814	r17815
645	645	static void irqhandler( device_t *device, int irq )
646	646	{
647	647	ninjaw_state *state = device->machine().driver_data<ninjaw_state>();
648		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	648	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
649	649	}
650	650
651	651	static const ym2610_interface ym2610_config =
r17814	r17815
806	806
807	807	state->membank("bank10")->configure_entries(0, 8, state->memregion("audiocpu")->base() + 0xc000, 0x4000);
808	808
809		state->m_maincpu = machine.device("maincpu");
810		state->m_audiocpu = machine.device("audiocpu");
811		state->m_subcpu = machine.device("sub");
	809	state->m_maincpu = machine.device<cpu_device>("maincpu");
	810	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
	811	state->m_subcpu = machine.device<cpu_device>("sub");
812	812	state->m_tc0140syt = machine.device("tc0140syt");
813	813	state->m_tc0100scn_1 = machine.device("tc0100scn_1");
814	814	state->m_tc0100scn_2 = machine.device("tc0100scn_2");

trunk/src/mame/drivers/twin16.c

r17814	r17815
688	688	static INTERRUPT_GEN( CPUA_interrupt )
689	689	{
690	690	twin16_state *state = device->machine().driver_data<twin16_state>();
691		if (CPUA_IRQ_ENABLE) device_set_input_line(device, 5, HOLD_LINE);
	691	if (CPUA_IRQ_ENABLE) device->execute().set_input_line(5, HOLD_LINE);
692	692	}
693	693
694	694	static INTERRUPT_GEN( CPUB_interrupt )
695	695	{
696	696	twin16_state *state = device->machine().driver_data<twin16_state>();
697		if (CPUB_IRQ_ENABLE) device_set_input_line(device, 5, HOLD_LINE);
	697	if (CPUB_IRQ_ENABLE) device->execute().set_input_line(5, HOLD_LINE);
698	698	}
699	699
700	700	/* Machine Drivers */

trunk/src/mame/drivers/megasys1.c

r17814	r17815
296	296
297	297	static INTERRUPT_GEN( megasys1D_irq )
298	298	{
299		device_set_input_line(device, 2, HOLD_LINE);
	299	device->execute().set_input_line(2, HOLD_LINE);
300	300	}
301	301
302	302	static ADDRESS_MAP_START( megasys1D_map, AS_PROGRAM, 16, megasys1_state )

trunk/src/mame/drivers/airbustr.c

r17814	r17815
261	261
262	262	WRITE8_MEMBER(airbustr_state::master_nmi_trigger_w)
263	263	{
264		device_set_input_line(m_slave, INPUT_LINE_NMI, PULSE_LINE);
	264	m_slave->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
265	265	}
266	266
267	267	WRITE8_MEMBER(airbustr_state::master_bankswitch_w)
r17814	r17815
308	308	{
309	309	soundlatch_byte_w(space, 0, data);
310	310	m_soundlatch_status = 1;   // soundlatch has been written
311		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);   // cause a nmi to sub cpu
	311	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);   // cause a nmi to sub cpu
312	312	}
313	313
314	314	WRITE8_MEMBER(airbustr_state::soundcommand2_w)
r17814	r17815
563	563	/* Sub Z80 uses IM2 too, but 0xff irq routine just contains an irq ack in it */
564	564	static INTERRUPT_GEN( slave_interrupt )
565	565	{
566		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0xfd);
	566	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0xfd);
567	567	}
568	568
569	569	/* Machine Initialization */
r17814	r17815
584	584
585	585	state->m_master = machine.device("master");
586	586	state->m_slave = machine.device("slave");
587		state->m_audiocpu = machine.device("audiocpu");
	587	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
588	588	state->m_pandora = machine.device("pandora");
589	589
590	590	state->save_item(NAME(state->m_soundlatch_status));

trunk/src/mame/drivers/pacman.c

r17814	r17815
405	405	pacman_state *state = device->machine().driver_data<pacman_state>();
406	406
407	407	if(state->m_irq_mask)
408		device_set_input_line(device, 0, HOLD_LINE);
	408	device->execute().set_input_line(0, HOLD_LINE);
409	409	}
410	410
411	411	static INTERRUPT_GEN( vblank_nmi )
r17814	r17815
413	413	pacman_state *state = device->machine().driver_data<pacman_state>();
414	414
415	415	if(state->m_irq_mask)
416		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	416	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
417	417	}
418	418
419	419	WRITE8_MEMBER(pacman_state::irq_mask_w)
r17814	r17815
423	423
424	424	WRITE8_MEMBER(pacman_state::pacman_interrupt_vector_w)
425	425	{
426		device_set_input_line_vector(m_maincpu, 0, data);
427		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	426	m_maincpu->set_input_line_vector(0, data);
	427	m_maincpu->set_input_line(0, CLEAR_LINE);
428	428	}
429	429
430	430
r17814	r17815
488	488	{
489	489	if (data == 0xfa) data = 0x78;
490	490	if (data == 0xfc) data = 0xfc;
491		device_set_input_line_vector(m_maincpu, 0, data );
	491	m_maincpu->set_input_line_vector(0, data );
492	492	}
493	493
494	494
r17814	r17815
497	497	if (data == 0xbf) data = 0x3c;
498	498	if (data == 0xc6) data = 0x40;
499	499	if (data == 0xfc) data = 0xfc;
500		device_set_input_line_vector(m_maincpu, 0, data );
	500	m_maincpu->set_input_line_vector(0, data );
501	501	}
502	502
503	503
r17814	r17815
697	697
698	698	static INTERRUPT_GEN( s2650_interrupt )
699	699	{
700		device_set_input_line_and_vector(device, 0, HOLD_LINE, 0x03);
	700	device->execute().set_input_line_and_vector(0, HOLD_LINE, 0x03);
701	701	}
702	702
703	703	WRITE8_MEMBER(pacman_state::porky_banking_w)

trunk/src/mame/drivers/igs011.c

r17814	r17815
3827	3827	{
3828	3828	igs011_state *state = timer.machine().driver_data<igs011_state>();
3829	3829
3830		device_set_input_line(state->m_maincpu, 5, HOLD_LINE);
	3830	state->m_maincpu->set_input_line(5, HOLD_LINE);
3831	3831	}
3832	3832
3833	3833	static MACHINE_CONFIG_DERIVED( drgnwrld, igs011_base )
r17814	r17815
3853	3853	if (!state->m_lhb_irq_enable)
3854	3854	return;
3855	3855
3856		device_set_input_line(state->m_maincpu, 6, HOLD_LINE);
	3856	state->m_maincpu->set_input_line(6, HOLD_LINE);
3857	3857	}
3858	3858
3859	3859	static TIMER_DEVICE_CALLBACK ( lhb_timer_irq_cb )
r17814	r17815
3862	3862	if (!state->m_lhb_irq_enable)
3863	3863	return;
3864	3864
3865		device_set_input_line(state->m_maincpu, 5, HOLD_LINE);
	3865	state->m_maincpu->set_input_line(5, HOLD_LINE);
3866	3866	}
3867	3867
3868	3868	static MACHINE_CONFIG_DERIVED( lhb, igs011_base )
r17814	r17815
3879	3879	{
3880	3880	igs011_state *state = timer.machine().driver_data<igs011_state>();
3881	3881
3882		device_set_input_line(state->m_maincpu, 3, HOLD_LINE);
	3882	state->m_maincpu->set_input_line(3, HOLD_LINE);
3883	3883	}
3884	3884
3885	3885

trunk/src/mame/drivers/bwing.c

r17814	r17815
37	37	bwing_state *state = device->machine().driver_data<bwing_state>();
38	38
39	39	if (!state->m_bwp3_nmimask)
40		device_set_input_line(device, INPUT_LINE_NMI, ASSERT_LINE);
	40	device->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
41	41	}
42	42
43	43	//****************************************************************************
r17814	r17815
60	60
61	61	WRITE8_MEMBER(bwing_state::bwp3_nmiack_w)
62	62	{
63		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, CLEAR_LINE);
	63	m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
64	64	}
65	65
66	66
r17814	r17815
83	83	switch (offset)
84	84	{
85	85	// MSSTB
86		case 0: device_set_input_line(m_subcpu, M6809_IRQ_LINE, ASSERT_LINE); break;
	86	case 0: m_subcpu->set_input_line(M6809_IRQ_LINE, ASSERT_LINE); break;
87	87
88	88	// IRQACK
89		case 1: device_set_input_line(m_maincpu, M6809_IRQ_LINE, CLEAR_LINE); break;
	89	case 1: m_maincpu->set_input_line(M6809_IRQ_LINE, CLEAR_LINE); break;
90	90
91	91	// FIRQACK
92		case 2: device_set_input_line(m_maincpu, M6809_FIRQ_LINE, CLEAR_LINE); break;
	92	case 2: m_maincpu->set_input_line(M6809_FIRQ_LINE, CLEAR_LINE); break;
93	93
94	94	// NMIACK
95		case 3: device_set_input_line(m_maincpu, INPUT_LINE_NMI, CLEAR_LINE); break;
	95	case 3: m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE); break;
96	96
97	97	// SWAP(bank-swaps sprite RAM between 1800 & 1900; ignored bc. they're treated as a single chunk.)
98	98	case 4: break;
r17814	r17815
100	100	// SNDREQ
101	101	case 5:
102	102	if (data == 0x80) // protection trick to screw CPU1 & 3
103		device_set_input_line(m_subcpu, INPUT_LINE_NMI, ASSERT_LINE); // SNMI
	103	m_subcpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE); // SNMI
104	104	else
105	105	{
106	106	soundlatch_byte_w(space, 0, data);
107		device_set_input_line(m_audiocpu, DECO16_IRQ_LINE, HOLD_LINE); // SNDREQ
	107	m_audiocpu->set_input_line(DECO16_IRQ_LINE, HOLD_LINE); // SNDREQ
108	108	}
109	109	break;
110	110
r17814	r17815
125	125	{
126	126	switch (offset)
127	127	{
128		case 0: device_set_input_line(m_maincpu, M6809_IRQ_LINE, ASSERT_LINE); break; // SMSTB
	128	case 0: m_maincpu->set_input_line(M6809_IRQ_LINE, ASSERT_LINE); break; // SMSTB
129	129
130		case 1: device_set_input_line(m_subcpu, M6809_FIRQ_LINE, CLEAR_LINE); break;
	130	case 1: m_subcpu->set_input_line(M6809_FIRQ_LINE, CLEAR_LINE); break;
131	131
132		case 2: device_set_input_line(m_subcpu, M6809_IRQ_LINE, CLEAR_LINE); break;
	132	case 2: m_subcpu->set_input_line(M6809_IRQ_LINE, CLEAR_LINE); break;
133	133
134		case 3: device_set_input_line(m_subcpu, INPUT_LINE_NMI, CLEAR_LINE); break;
	134	case 3: m_subcpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE); break;
135	135	}
136	136
137	137	#if BW_DEBUG
r17814	r17815
337	337	{
338	338	bwing_state *state = machine.driver_data<bwing_state>();
339	339
340		state->m_maincpu = machine.device("maincpu");
341		state->m_subcpu = machine.device("sub");
342		state->m_audiocpu = machine.device("audiocpu");
	340	state->m_maincpu = machine.device<cpu_device>("maincpu");
	341	state->m_subcpu = machine.device<cpu_device>("sub");
	342	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
343	343
344	344	state->save_item(NAME(state->m_palatch));
345	345	state->save_item(NAME(state->m_srbank));

trunk/src/mame/drivers/sf.c

r17814	r17815
45	45	if (ACCESSING_BITS_0_7)
46	46	{
47	47	soundlatch_byte_w(space, offset, data & 0xff);
48		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	48	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
49	49	}
50	50	}
51	51
r17814	r17815
799	799	static void irq_handler( device_t *device, int irq )
800	800	{
801	801	sf_state *state = device->machine().driver_data<sf_state>();
802		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	802	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
803	803	}
804	804
805	805	static const ym2151_interface ym2151_config =
r17814	r17815
818	818	sf_state *state = machine.driver_data<sf_state>();
819	819
820	820	/* devices */
821		state->m_maincpu = machine.device("maincpu");
822		state->m_audiocpu = machine.device("audiocpu");
	821	state->m_maincpu = machine.device<cpu_device>("maincpu");
	822	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
823	823
824	824	state->save_item(NAME(state->m_sf_active));
825	825	state->save_item(NAME(state->m_bgscroll));

trunk/src/mame/drivers/cball.c

r17814	r17815
23	23	tilemap_t* m_bg_tilemap;
24	24
25	25	/* devices */
26		device_t *m_maincpu;
	26	cpu_device *m_maincpu;
27	27	DECLARE_WRITE8_MEMBER(cball_vram_w);
28	28	DECLARE_READ8_MEMBER(cball_wram_r);
29	29	DECLARE_WRITE8_MEMBER(cball_wram_w);
r17814	r17815
90	90	static MACHINE_START( cball )
91	91	{
92	92	cball_state *state = machine.driver_data<cball_state>();
93		state->m_maincpu = machine.device("maincpu");
	93	state->m_maincpu = machine.device<cpu_device>("maincpu");
94	94	}
95	95
96	96	static MACHINE_RESET( cball )

trunk/src/mame/drivers/konamim2.c

r17814	r17815
1162	1162	state->m_irq_active |= 0x8;
1163	1163	}*/
1164	1164
1165		device_set_input_line(device, INPUT_LINE_IRQ0, ASSERT_LINE);
	1165	device->execute().set_input_line(INPUT_LINE_IRQ0, ASSERT_LINE);
1166	1166	}
1167	1167
1168	1168	static MACHINE_CONFIG_START( m2, konamim2_state )

trunk/src/mame/drivers/cave.c

r17814	r17815
108	108	{
109	109	cave_state *state = machine.driver_data<cave_state>();
110	110	if (state->m_vblank_irq || state->m_sound_irq || state->m_unknown_irq)
111		device_set_input_line(state->m_maincpu, state->m_irq_level, ASSERT_LINE);
	111	state->m_maincpu->set_input_line(state->m_irq_level, ASSERT_LINE);
112	112	else
113		device_set_input_line(state->m_maincpu, state->m_irq_level, CLEAR_LINE);
	113	state->m_maincpu->set_input_line(state->m_irq_level, CLEAR_LINE);
114	114	}
115	115
116	116	static TIMER_CALLBACK( cave_vblank_end )
r17814	r17815
233	233	//  m_sound_flag1 = 1;
234	234	//  m_sound_flag2 = 1;
235	235	soundlatch_word_w(space, offset, data, mem_mask);
236		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
237		device_spin_until_time(&space.device(), attotime::from_usec(50));   // Allow the other cpu to reply
	236	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
	237	space.device().execute().spin_until_time(attotime::from_usec(50));   // Allow the other cpu to reply
238	238	}
239	239
240	240	/* Sound CPU: read the low 8 bits of the 16 bit sound latch */
r17814	r17815
1797	1797	{
1798	1798	cave_state *state = machine.driver_data<cave_state>();
1799	1799
1800		state->m_maincpu = machine.device("maincpu");
1801		state->m_audiocpu = machine.device("audiocpu");
	1800	state->m_maincpu = machine.device<cpu_device>("maincpu");
	1801	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
1802	1802
1803	1803	state->save_item(NAME(state->m_soundbuf_len));
1804	1804	state->save_item(NAME(state->m_soundbuf_data));

trunk/src/mame/drivers/dec8.c

r17814	r17815
135	135	// The schematics show a clocked LS194 shift register (3A) is used to automatically
136	136	// clear the IRQ request.  The MCU does not clear it itself.
137	137	dec8_state *state = machine.driver_data<dec8_state>();
138		device_set_input_line(state->m_mcu, MCS51_INT1_LINE, CLEAR_LINE);
	138	state->m_mcu->execute().set_input_line(MCS51_INT1_LINE, CLEAR_LINE);
139	139	}
140	140
141	141	WRITE8_MEMBER(dec8_state::dec8_i8751_w)
r17814	r17815
145	145	{
146	146	case 0: /* High byte - SECIRQ is trigged on activating this latch */
147	147	m_i8751_value = (m_i8751_value & 0xff) | (data << 8);
148		device_set_input_line(m_mcu, MCS51_INT1_LINE, ASSERT_LINE);
	148	m_mcu->execute().set_input_line(MCS51_INT1_LINE, ASSERT_LINE);
149	149	machine().scheduler().timer_set(m_mcu->clocks_to_attotime(64), FUNC(dec8_i8751_timer_callback)); // 64 clocks not confirmed
150	150	break;
151	151	case 1: /* Low byte */
r17814	r17815
175	175	{
176	176	case 0: /* High byte */
177	177	m_i8751_value = (m_i8751_value & 0xff) | (data << 8);
178		device_set_input_line(m_maincpu, M6809_FIRQ_LINE, HOLD_LINE); /* Signal main cpu */
	178	m_maincpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE); /* Signal main cpu */
179	179	break;
180	180	case 1: /* Low byte */
181	181	m_i8751_value = (m_i8751_value & 0xff00) | data;
r17814	r17815
238	238	{
239	239	case 0: /* High byte */
240	240	m_i8751_value = (m_i8751_value & 0xff) | (data << 8);
241		device_set_input_line(m_subcpu, M6809_FIRQ_LINE, HOLD_LINE); /* Signal sub cpu */
	241	m_subcpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE); /* Signal sub cpu */
242	242	break;
243	243	case 1: /* Low byte */
244	244	m_i8751_value = (m_i8751_value & 0xff00) | data;
r17814	r17815
276	276	{
277	277	case 0: /* High byte */
278	278	m_i8751_value = (m_i8751_value & 0xff) | (data << 8);
279		device_set_input_line(m_maincpu, M6809_FIRQ_LINE, HOLD_LINE); /* Signal main cpu */
	279	m_maincpu->set_input_line(M6809_FIRQ_LINE, HOLD_LINE); /* Signal main cpu */
280	280	break;
281	281	case 1: /* Low byte */
282	282	m_i8751_value = (m_i8751_value & 0xff00) | data;
r17814	r17815
459	459
460	460	membank("bank1")->set_entry(data >> 4);
461	461
462		if ((data&1)==0) device_set_input_line(m_maincpu, M6809_IRQ_LINE, CLEAR_LINE);
	462	if ((data&1)==0) m_maincpu->set_input_line(M6809_IRQ_LINE, CLEAR_LINE);
463	463	if (data & 2) m_nmi_enable =1; else m_nmi_enable = 0;
464	464	flip_screen_set(data & 0x08);
465	465	}
r17814	r17815
479	479	WRITE8_MEMBER(dec8_state::dec8_sound_w)
480	480	{
481	481	soundlatch_byte_w(space, 0, data);
482		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, PULSE_LINE);
	482	m_audiocpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
483	483	}
484	484
485	485	static void csilver_adpcm_int( device_t *device )
r17814	r17815
487	487	dec8_state *state = device->machine().driver_data<dec8_state>();
488	488	state->m_toggle ^= 1;
489	489	if (state->m_toggle)
490		device_set_input_line(state->m_audiocpu, M6502_IRQ_LINE, HOLD_LINE);
	490	state->m_audiocpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
491	491
492	492	msm5205_data_w(device, state->m_msm5205next >> 4);
493	493	state->m_msm5205next <<= 4;
r17814	r17815
518	518	switch (offset)
519	519	{
520	520	case 0: /* IRQ2 */
521		device_set_input_line(m_subcpu, M6809_IRQ_LINE, ASSERT_LINE);
	521	m_subcpu->set_input_line(M6809_IRQ_LINE, ASSERT_LINE);
522	522	return;
523	523	case 1: /* IRC 1 */
524		device_set_input_line(m_maincpu, M6809_IRQ_LINE, CLEAR_LINE);
	524	m_maincpu->set_input_line(M6809_IRQ_LINE, CLEAR_LINE);
525	525	return;
526	526	case 2: /* IRQ 1 */
527		device_set_input_line(m_maincpu, M6809_IRQ_LINE, ASSERT_LINE);
	527	m_maincpu->set_input_line(M6809_IRQ_LINE, ASSERT_LINE);
528	528	return;
529	529	case 3: /* IRC 2 */
530		device_set_input_line(m_subcpu, M6809_IRQ_LINE, CLEAR_LINE);
	530	m_subcpu->set_input_line(M6809_IRQ_LINE, CLEAR_LINE);
531	531	return;
532	532	}
533	533	}
r17814	r17815
542	542	switch (offset)
543	543	{
544	544	case 0: /* CPU 2 - IRQ acknowledge */
545		device_set_input_line(m_subcpu, M6809_IRQ_LINE, CLEAR_LINE);
	545	m_subcpu->set_input_line(M6809_IRQ_LINE, CLEAR_LINE);
546	546	return;
547	547	case 1: /* CPU 1 - IRQ acknowledge */
548		device_set_input_line(m_maincpu, M6809_IRQ_LINE, CLEAR_LINE);
	548	m_maincpu->set_input_line(M6809_IRQ_LINE, CLEAR_LINE);
549	549	return;
550	550	case 2: /* i8751 - FIRQ acknowledge */
551	551	return;
552	552	case 3: /* IRQ 1 */
553		device_set_input_line(m_maincpu, M6809_IRQ_LINE, ASSERT_LINE);
	553	m_maincpu->set_input_line(M6809_IRQ_LINE, ASSERT_LINE);
554	554	return;
555	555	case 4: /* IRQ 2 */
556		device_set_input_line(m_subcpu, M6809_IRQ_LINE, ASSERT_LINE);
	556	m_subcpu->set_input_line(M6809_IRQ_LINE, ASSERT_LINE);
557	557	return;
558	558	}
559	559	#endif
r17814	r17815
567	567	case 2: /* i8751 - FIRQ acknowledge */
568	568	return;
569	569	case 3: /* IRQ 1 */
570		device_set_input_line(m_maincpu, M6809_IRQ_LINE, HOLD_LINE);
	570	m_maincpu->set_input_line(M6809_IRQ_LINE, HOLD_LINE);
571	571	return;
572	572	case 4: /* IRQ 2 */
573		device_set_input_line(m_subcpu, M6809_IRQ_LINE, HOLD_LINE);
	573	m_subcpu->set_input_line(M6809_IRQ_LINE, HOLD_LINE);
574	574	return;
575	575	}
576	576	}
r17814	r17815
960	960
961	961	// P2 - IRQ to main CPU
962	962	if (offset==2 && (data&4)==0)
963		device_set_input_line(m_maincpu, M6809_IRQ_LINE, ASSERT_LINE);
	963	m_maincpu->set_input_line(M6809_IRQ_LINE, ASSERT_LINE);
964	964	}
965	965
966	966	static ADDRESS_MAP_START( dec8_mcu_io_map, AS_IO, 8, dec8_state )
r17814	r17815
1935	1935	static void irqhandler( device_t *device, int linestate )
1936	1936	{
1937	1937	dec8_state *state = device->machine().driver_data<dec8_state>();
1938		device_set_input_line(state->m_audiocpu, 0, linestate); /* M6502_IRQ_LINE */
	1938	state->m_audiocpu->set_input_line(0, linestate); /* M6502_IRQ_LINE */
1939	1939	}
1940	1940
1941	1941	static const ym3526_interface ym3526_config =
r17814	r17815
1960	1960	{
1961	1961	dec8_state *state = device->machine().driver_data<dec8_state>();
1962	1962	if (state->m_nmi_enable)
1963		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE); /* VBL */
	1963	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE); /* VBL */
1964	1964	}
1965	1965
1966	1966	/* Coins generate NMI's */
r17814	r17815
1971	1971	if (state->m_latch && (state->ioport("IN2")->read() & 0x7) != 0x7)
1972	1972	{
1973	1973	state->m_latch = 0;
1974		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	1974	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
1975	1975	}
1976	1976	}
1977	1977
r17814	r17815
1982	1982	{
1983	1983	dec8_state *state = machine.driver_data<dec8_state>();
1984	1984
1985		state->m_maincpu = machine.device("maincpu");
1986		state->m_subcpu = machine.device("sub");
1987		state->m_audiocpu = machine.device("audiocpu");
	1985	state->m_maincpu = machine.device<cpu_device>("maincpu");
	1986	state->m_subcpu = machine.device<cpu_device>("sub");
	1987	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
1988	1988	state->m_mcu = machine.device("mcu");
1989	1989
1990	1990	state->save_item(NAME(state->m_latch));

trunk/src/mame/drivers/fuukifg3.c

r17814	r17815
525	525	static TIMER_CALLBACK( level_1_interrupt_callback )
526	526	{
527	527	fuuki32_state *state = machine.driver_data<fuuki32_state>();
528		device_set_input_line(state->m_maincpu, 1, HOLD_LINE);
	528	state->m_maincpu->set_input_line(1, HOLD_LINE);
529	529	machine.scheduler().timer_set(machine.primary_screen->time_until_pos(248), FUNC(level_1_interrupt_callback));
530	530	}
531	531
r17814	r17815
533	533	static TIMER_CALLBACK( vblank_interrupt_callback )
534	534	{
535	535	fuuki32_state *state = machine.driver_data<fuuki32_state>();
536		device_set_input_line(state->m_maincpu, 3, HOLD_LINE);   // VBlank IRQ
	536	state->m_maincpu->set_input_line(3, HOLD_LINE);   // VBlank IRQ
537	537	machine.scheduler().timer_set(machine.primary_screen->time_until_vblank_start(), FUNC(vblank_interrupt_callback));
538	538	}
539	539
r17814	r17815
541	541	static TIMER_CALLBACK( raster_interrupt_callback )
542	542	{
543	543	fuuki32_state *state = machine.driver_data<fuuki32_state>();
544		device_set_input_line(state->m_maincpu, 5, HOLD_LINE);   // Raster Line IRQ
	544	state->m_maincpu->set_input_line(5, HOLD_LINE);   // Raster Line IRQ
545	545	machine.primary_screen->update_partial(machine.primary_screen->vpos());
546	546	state->m_raster_interrupt_timer->adjust(machine.primary_screen->frame_period());
547	547	}
r17814	r17815
554	554
555	555	state->membank("bank1")->configure_entries(0, 0x10, &ROM[0x10000], 0x8000);
556	556
557		state->m_maincpu = machine.device("maincpu");
558		state->m_audiocpu = machine.device("soundcpu");
	557	state->m_maincpu = machine.device<cpu_device>("maincpu");
	558	state->m_audiocpu = machine.device<cpu_device>("soundcpu");
559	559
560	560	state->m_raster_interrupt_timer = machine.scheduler().timer_alloc(FUNC(raster_interrupt_callback));
561	561
r17814	r17815
578	578	static void irqhandler( device_t *device, int irq )
579	579	{
580	580	fuuki32_state *state = device->machine().driver_data<fuuki32_state>();
581		device_set_input_line(state->m_audiocpu, 0, irq ? ASSERT_LINE : CLEAR_LINE);
	581	state->m_audiocpu->set_input_line(0, irq ? ASSERT_LINE : CLEAR_LINE);
582	582	}
583	583
584	584	static const ymf278b_interface fuuki32_ymf278b_interface =

trunk/src/mame/drivers/battlane.c

r17814	r17815
48	48	/*
49	49	if (~m_cpu_control & 0x08)
50	50	{
51		device_set_input_line(m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
52		device_set_input_line(m_subcpu, INPUT_LINE_NMI, PULSE_LINE);
	51	m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
	52	m_subcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
53	53	}
54	54	*/
55	55
r17814	r17815
57	57	CPU2's SWI will trigger an 6809 IRQ on the master by resetting 0x04
58	58	Master will respond by setting the bit back again
59	59	*/
60		device_set_input_line(m_maincpu, M6809_IRQ_LINE,  data & 0x04 ? CLEAR_LINE : HOLD_LINE);
	60	m_maincpu->set_input_line(M6809_IRQ_LINE,  data & 0x04 ? CLEAR_LINE : HOLD_LINE);
61	61
62	62	/*
63	63	Slave function call (e.g. ROM test):
r17814	r17815
75	75	FA96: 27 FA       BEQ   $FA92   ; Wait for bit to be set
76	76	*/
77	77
78		device_set_input_line(m_subcpu, M6809_IRQ_LINE, data & 0x02 ? CLEAR_LINE : HOLD_LINE);
	78	m_subcpu->set_input_line(M6809_IRQ_LINE, data & 0x02 ? CLEAR_LINE : HOLD_LINE);
79	79	}
80	80
81	81	static INTERRUPT_GEN( battlane_cpu1_interrupt )
r17814	r17815
85	85	/* See note in battlane_cpu_command_w */
86	86	if (~state->m_cpu_control & 0x08)
87	87	{
88		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
89		device_set_input_line(state->m_subcpu, INPUT_LINE_NMI, PULSE_LINE);
	88	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
	89	state->m_subcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
90	90	}
91	91	}
92	92
r17814	r17815
271	271	{
272	272	battlane_state *state = machine.driver_data<battlane_state>();
273	273
274		state->m_maincpu = machine.device("maincpu");
275		state->m_subcpu = machine.device("sub");
	274	state->m_maincpu = machine.device<cpu_device>("maincpu");
	275	state->m_subcpu = machine.device<cpu_device>("sub");
276	276
277	277	state->save_item(NAME(state->m_video_ctrl));
278	278	state->save_item(NAME(state->m_cpu_control));

trunk/src/mame/drivers/crimfght.c

r17814	r17815
28	28	crimfght_state *state = device->machine().driver_data<crimfght_state>();
29	29
30	30	if (k051960_is_irq_enabled(state->m_k051960))
31		device_set_input_line(device, KONAMI_IRQ_LINE, HOLD_LINE);
	31	device->execute().set_input_line(KONAMI_IRQ_LINE, HOLD_LINE);
32	32	}
33	33
34	34	WRITE8_MEMBER(crimfght_state::crimfght_coin_w)
r17814	r17815
40	40	WRITE8_MEMBER(crimfght_state::crimfght_sh_irqtrigger_w)
41	41	{
42	42	soundlatch_byte_w(space, offset, data);
43		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	43	m_audiocpu->set_input_line(0, HOLD_LINE);
44	44	}
45	45
46	46	WRITE8_MEMBER(crimfght_state::crimfght_snd_bankswitch_w)
r17814	r17815
266	266	state->membank("bank2")->configure_entries(0, 12, &ROM[0x10000], 0x2000);
267	267	state->membank("bank2")->set_entry(0);
268	268
269		state->m_maincpu = machine.device("maincpu");
270		state->m_audiocpu = machine.device("audiocpu");
	269	state->m_maincpu = machine.device<cpu_device>("maincpu");
	270	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
271	271	state->m_k052109 = machine.device("k052109");
272	272	state->m_k051960 = machine.device("k051960");
273	273	state->m_k007232 = machine.device("k007232");

trunk/src/mame/drivers/asuka.c

r17814	r17815
233	233	static TIMER_CALLBACK( cadash_interrupt5 )
234	234	{
235	235	asuka_state *state = machine.driver_data<asuka_state>();
236		device_set_input_line(state->m_maincpu, 5, HOLD_LINE);
	236	state->m_maincpu->set_input_line(5, HOLD_LINE);
237	237	}
238	238
239	239	static INTERRUPT_GEN( cadash_interrupt )
240	240	{
241	241	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(500), FUNC(cadash_interrupt5));
242		device_set_input_line(device, 4, HOLD_LINE);  /* interrupt vector 4 */
	242	device->execute().set_input_line(4, HOLD_LINE);  /* interrupt vector 4 */
243	243	}
244	244
245	245
r17814	r17815
837	837	{
838	838	asuka_state *state = machine.driver_data<asuka_state>();
839	839
840		state->m_maincpu = machine.device("maincpu");
841		state->m_audiocpu = machine.device("audiocpu");
	840	state->m_maincpu = machine.device<cpu_device>("maincpu");
	841	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
842	842	state->m_pc090oj = machine.device("pc090oj");
843	843	state->m_tc0100scn = machine.device("tc0100scn");
844	844

trunk/src/mame/drivers/pooyan.c

r17814	r17815
29	29	pooyan_state *state = device->machine().driver_data<pooyan_state>();
30	30
31	31	if (state->m_irq_enable)
32		device_set_input_line(device, INPUT_LINE_NMI, ASSERT_LINE);
	32	device->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
33	33	}
34	34
35	35
r17814	r17815
38	38
39	39	m_irq_enable = data & 1;
40	40	if (!m_irq_enable)
41		device_set_input_line(m_maincpu, INPUT_LINE_NMI, CLEAR_LINE);
	41	m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
42	42	}
43	43
44	44

trunk/src/mame/drivers/rollerg.c

r17814	r17815
58	58
59	59	WRITE8_MEMBER(rollerg_state::soundirq_w)
60	60	{
61		device_set_input_line_and_vector(m_audiocpu, 0, HOLD_LINE, 0xff);
	61	m_audiocpu->set_input_line_and_vector(0, HOLD_LINE, 0xff);
62	62	}
63	63
64	64	static TIMER_CALLBACK( nmi_callback )
65	65	{
66	66	rollerg_state *state = machine.driver_data<rollerg_state>();
67		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, ASSERT_LINE);
	67	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
68	68	}
69	69
70	70	WRITE8_MEMBER(rollerg_state::sound_arm_nmi_w)
71	71	{
72		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, CLEAR_LINE);
	72	m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
73	73	machine().scheduler().timer_set(attotime::from_usec(50), FUNC(nmi_callback));   /* kludge until the K053260 is emulated correctly */
74	74	}
75	75
r17814	r17815
256	256	state->membank("bank1")->configure_entries(6, 2, &ROM[0x10000], 0x4000);
257	257	state->membank("bank1")->set_entry(0);
258	258
259		state->m_maincpu = machine.device("maincpu");
260		state->m_audiocpu = machine.device("audiocpu");
	259	state->m_maincpu = machine.device<cpu_device>("maincpu");
	260	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
261	261	state->m_k053244 = machine.device("k053244");
262	262	state->m_k051316 = machine.device("k051316");
263	263	state->m_k053260 = machine.device("k053260");

trunk/src/mame/drivers/hvyunit.c

r17814	r17815
211	211
212	212	WRITE8_MEMBER(hvyunit_state::trigger_nmi_on_slave_cpu)
213	213	{
214		device_set_input_line(m_slave_cpu, INPUT_LINE_NMI, PULSE_LINE);
	214	m_slave_cpu->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
215	215	}
216	216
217	217	WRITE8_MEMBER(hvyunit_state::master_bankswitch_w)
r17814	r17815
228	228	m_data_to_mermaid = data;
229	229	m_z80_to_mermaid_full = 1;
230	230	m_mermaid_int0_l = 0;
231		device_set_input_line(m_mermaid, INPUT_LINE_IRQ0, ASSERT_LINE);
	231	m_mermaid->execute().set_input_line(INPUT_LINE_IRQ0, ASSERT_LINE);
232	232	}
233	233
234	234	READ8_MEMBER(hvyunit_state::mermaid_data_r)
r17814	r17815
255	255	{
256	256
257	257	soundlatch_byte_w(space, 0, data);
258		device_set_input_line(m_sound_cpu, INPUT_LINE_NMI, PULSE_LINE);
	258	m_sound_cpu->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
259	259	}
260	260
261	261	WRITE8_MEMBER(hvyunit_state::hu_videoram_w)
r17814	r17815
358	358	if (data == 0xff)
359	359	{
360	360	m_mermaid_int0_l = 1;
361		device_set_input_line(m_mermaid, INPUT_LINE_IRQ0, CLEAR_LINE);
	361	m_mermaid->execute().set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
362	362	}
363	363
364	364	m_mermaid_p[1] = data;
r17814	r17815
404	404	{
405	405
406	406	m_mermaid_p[3] = data;
407		device_set_input_line(m_slave_cpu, INPUT_LINE_RESET, data & 2 ? CLEAR_LINE : ASSERT_LINE);
	407	m_slave_cpu->execute().set_input_line(INPUT_LINE_RESET, data & 2 ? CLEAR_LINE : ASSERT_LINE);
408	408	}
409	409
410	410
r17814	r17815
630	630	int scanline = param;
631	631
632	632	if(scanline == 240) // vblank-out irq
633		device_set_input_line_and_vector(state->m_master_cpu, 0, HOLD_LINE, 0xfd);
	633	state->m_master_cpu->execute().set_input_line_and_vector(0, HOLD_LINE, 0xfd);
634	634
635	635	/* Pandora "sprite end dma" irq? TODO: timing is likely off */
636	636	if(scanline == 64)
637		device_set_input_line_and_vector(state->m_master_cpu, 0, HOLD_LINE, 0xff);
	637	state->m_master_cpu->execute().set_input_line_and_vector(0, HOLD_LINE, 0xff);
638	638	}
639	639
640	640	static const kaneko_pandora_interface hvyunit_pandora_config =

trunk/src/mame/drivers/tankbatt.c

r17814	r17815
182	182	static INTERRUPT_GEN( tankbatt_interrupt )
183	183	{
184	184	tankbatt_state *state = device->machine().driver_data<tankbatt_state>();
185		if (state->m_nmi_enable) device_set_input_line(device,INPUT_LINE_NMI,PULSE_LINE);
	185	if (state->m_nmi_enable) device->execute().set_input_line(INPUT_LINE_NMI,PULSE_LINE);
186	186	}
187	187
188	188	INPUT_CHANGED_MEMBER(tankbatt_state::coin_inserted)

trunk/src/mame/drivers/royalmah.c

r17814	r17815
3249	3249	{
3250	3250	royalmah_state *state = device->machine().driver_data<royalmah_state>();
3251	3251	if ( state->m_suzume_bank & 0x40 )
3252		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	3252	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
3253	3253	}
3254	3254
3255	3255	static MACHINE_CONFIG_DERIVED( suzume, dondenmj )
r17814	r17815
3295	3295	int scanline = param;
3296	3296
3297	3297	if(scanline == 248)
3298		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0x80);   // vblank
	3298	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0x80);   // vblank
3299	3299
3300	3300	if(scanline == 0)
3301		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0x84);   // demo
	3301	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0x84);   // demo
3302	3302	}
3303	3303
3304	3304	WRITE_LINE_MEMBER(royalmah_state::janptr96_rtc_irq)
3305	3305	{
3306		device_set_input_line_and_vector(m_maincpu, 0, HOLD_LINE, 0x82);   // rtc
	3306	m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0x82);   // rtc
3307	3307	}
3308	3308
3309	3309	static MSM6242_INTERFACE( janptr96_rtc_intf )
r17814	r17815
3353	3353	{
3354	3354	royalmah_state *state = device->machine().driver_data<royalmah_state>();
3355	3355
3356		device_set_input_line(state->m_maincpu, INPUT_LINE_IRQ0, HOLD_LINE);   // vblank
	3356	state->m_maincpu->set_input_line(INPUT_LINE_IRQ0, HOLD_LINE);   // vblank
3357	3357	}
3358	3358
3359	3359	WRITE_LINE_MEMBER(royalmah_state::mjtensin_rtc_irq)
3360	3360	{
3361		device_set_input_line(m_maincpu, INPUT_LINE_IRQ1, HOLD_LINE);   // rtc
	3361	m_maincpu->set_input_line(INPUT_LINE_IRQ1, HOLD_LINE);   // rtc
3362	3362	}
3363	3363
3364	3364

trunk/src/mame/drivers/crospang.c

r17814	r17815
318	318	static void irqhandler( device_t *device, int linestate )
319	319	{
320	320	crospang_state *state = device->machine().driver_data<crospang_state>();
321		device_set_input_line(state->m_audiocpu, 0, linestate);
	321	state->m_audiocpu->set_input_line(0, linestate);
322	322	}
323	323
324	324	static const ym3812_interface ym3812_config =
r17814	r17815
331	331	{
332	332	crospang_state *state = machine.driver_data<crospang_state>();
333	333
334		state->m_audiocpu = machine.device("audiocpu");
	334	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
335	335
336	336	state->save_item(NAME(state->m_bestri_tilebank));
337	337

trunk/src/mame/drivers/funybubl.c

r17814	r17815
68	68	WRITE8_MEMBER(funybubl_state::funybubl_soundcommand_w)
69	69	{
70	70	soundlatch_byte_w(space, 0, data);
71		device_set_input_line(m_audiocpu, 0, HOLD_LINE);
	71	m_audiocpu->set_input_line(0, HOLD_LINE);
72	72	}
73	73
74	74	WRITE8_MEMBER(funybubl_state::funybubl_oki_bank_sw)
r17814	r17815
205	205	funybubl_state *state = machine.driver_data<funybubl_state>();
206	206	UINT8 *ROM = state->memregion("maincpu")->base();
207	207
208		state->m_audiocpu = machine.device("audiocpu");
	208	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
209	209
210	210	state->save_item(NAME(state->m_banked_vram));
211	211

trunk/src/mame/drivers/rotaryf.c

r17814	r17815
45	45	int scanline = param;
46	46
47	47	if (scanline == 256)
48		device_set_input_line(state->m_maincpu, I8085_RST55_LINE, HOLD_LINE);
	48	state->m_maincpu->set_input_line(I8085_RST55_LINE, HOLD_LINE);
49	49	else if((scanline % 64) == 0)
50	50	{
51		device_set_input_line(state->m_maincpu, I8085_RST75_LINE, ASSERT_LINE);
52		device_set_input_line(state->m_maincpu, I8085_RST75_LINE, CLEAR_LINE);
	51	state->m_maincpu->set_input_line(I8085_RST75_LINE, ASSERT_LINE);
	52	state->m_maincpu->set_input_line(I8085_RST75_LINE, CLEAR_LINE);
53	53	}
54	54	}
55	55

trunk/src/mame/drivers/m10.c

r17814	r17815
132	132	{
133	133	m10_state *state = device->machine().driver_data<m10_state>();
134	134	LOG(("ic8j1: %d %d\n", data, device->machine().primary_screen->vpos()));
135		device_set_input_line(state->m_maincpu, 0, !data ? CLEAR_LINE : ASSERT_LINE);
	135	state->m_maincpu->set_input_line(0, !data ? CLEAR_LINE : ASSERT_LINE);
136	136	}
137	137
138	138	static WRITE8_DEVICE_HANDLER( ic8j2_output_changed )
r17814	r17815
196	196	{
197	197	m10_state *state = machine.driver_data<m10_state>();
198	198
199		state->m_maincpu = machine.device("maincpu");
	199	state->m_maincpu = machine.device<cpu_device>("maincpu");
200	200	state->m_ic8j1 = machine.device("ic8j1");
201	201	state->m_ic8j2 = machine.device("ic8j2");
202	202	state->m_samples = machine.device<samples_device>("samples");
r17814	r17815
486	486	READ8_MEMBER(m10_state::m11_a700_r)
487	487	{
488	488	//LOG(("rd:%d\n",machine().primary_screen->vpos()));
489		//device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	489	//m_maincpu->set_input_line(0, CLEAR_LINE);
490	490	LOG(("clear\n"));
491	491	ttl74123_clear_w(m_ic8j1, 0, 0);
492	492	ttl74123_clear_w(m_ic8j1, 0, 1);
r17814	r17815
502	502	INPUT_CHANGED_MEMBER(m10_state::coin_inserted)
503	503	{
504	504	/* coin insertion causes an NMI */
505		device_set_input_line(m_maincpu, INPUT_LINE_NMI, newval ? ASSERT_LINE : CLEAR_LINE);
	505	m_maincpu->set_input_line(INPUT_LINE_NMI, newval ? ASSERT_LINE : CLEAR_LINE);
506	506	}
507	507
508	508
r17814	r17815
511	511	m10_state *state = machine.driver_data<m10_state>();
512	512	if (param == 0)
513	513	{
514		device_set_input_line(state->m_maincpu, 0, ASSERT_LINE);
	514	state->m_maincpu->set_input_line(0, ASSERT_LINE);
515	515	machine.scheduler().timer_set(machine.primary_screen->time_until_pos(IREMM10_VBSTART + 16), FUNC(interrupt_callback), 1);
516	516	}
517	517	if (param == 1)
518	518	{
519		device_set_input_line(state->m_maincpu, 0, ASSERT_LINE);
	519	state->m_maincpu->set_input_line(0, ASSERT_LINE);
520	520	machine.scheduler().timer_set(machine.primary_screen->time_until_pos(IREMM10_VBSTART + 24), FUNC(interrupt_callback), 2);
521	521	}
522	522	if (param == -1)
523		device_set_input_line(state->m_maincpu, 0, CLEAR_LINE);
	523	state->m_maincpu->set_input_line(0, CLEAR_LINE);
524	524
525	525	}
526	526
527	527	#if 0
528	528	static INTERRUPT_GEN( m11_interrupt )
529	529	{
530		device_set_input_line(device, 0, ASSERT_LINE);
	530	device->execute().set_input_line(0, ASSERT_LINE);
531	531	//device->machine().scheduler().timer_set(machine.primary_screen->time_until_pos(IREMM10_VBEND), FUNC(interrupt_callback), -1);
532	532	}
533	533
534	534	static INTERRUPT_GEN( m10_interrupt )
535	535	{
536		device_set_input_line(device, 0, ASSERT_LINE);
	536	device->execute().set_input_line(0, ASSERT_LINE);
537	537	}
538	538	#endif
539	539
540	540	static INTERRUPT_GEN( m15_interrupt )
541	541	{
542		device_set_input_line(device, 0, ASSERT_LINE);
	542	device->execute().set_input_line(0, ASSERT_LINE);
543	543	device->machine().scheduler().timer_set(device->machine().primary_screen->time_until_pos(IREMM10_VBSTART + 1, 80), FUNC(interrupt_callback), -1);
544	544	}
545	545

trunk/src/emu/cpu/m68000/m68kcpu.c

r17814	r17815
1994	1994
1995	1995	void m68307_set_interrupt(device_t *device, int level, int vector)
1996	1996	{
1997		device_set_input_line_and_vector(device, level, HOLD_LINE, vector);
	1997	device->execute().set_input_line_and_vector(level, HOLD_LINE, vector);
1998	1998	}
1999	1999
2000	2000	void m68307_timer0_interrupt(legacy_cpu_device *cpudev)

trunk/src/emu/cpu/tms34010/34010ops.c

r17814	r17815
96	96	/* extra check to prevent bad things */
97	97	if (tms->pc == 0 || opcode_table[tms->direct->read_decrypted_word(TOBYTE(tms->pc)) >> 4] == unimpl)
98	98	{
99		device_set_input_line(tms->device, INPUT_LINE_HALT, ASSERT_LINE);
	99	tms->device->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
100	100	debugger_break(tms->device->machine());
101	101	}
102	102	}

trunk/src/emu/cpu/tms34010/tms34010.c

r17814	r17815
769	769	LOG(("TMS34010 '%s' set internal interrupt $%04x\n", tms->device->tag(), type));
770	770
771	771	/* generate triggers so that spin loops can key off them */
772		device_triggerint(tms->device);
	772	tms->device->signal_interrupt_trigger();
773	773	}
774	774
775	775
r17814	r17815
1235	1235	/* if the CPU is halting itself, stop execution right away */
1236	1236	if ((data & 0x8000) && !tms->external_host_access)
1237	1237	tms->icount = 0;
1238		device_set_input_line(tms->device, INPUT_LINE_HALT, (data & 0x8000) ? ASSERT_LINE : CLEAR_LINE);
	1238	tms->device->set_input_line(INPUT_LINE_HALT, (data & 0x8000) ? ASSERT_LINE : CLEAR_LINE);
1239	1239
1240	1240	/* NMI issued? */
1241	1241	if (data & 0x0100)
r17814	r17815
1386	1386	/* if the CPU is halting itself, stop execution right away */
1387	1387	if ((data & 0x8000) && !tms->external_host_access)
1388	1388	tms->icount = 0;
1389		device_set_input_line(tms->device, INPUT_LINE_HALT, (data & 0x8000) ? ASSERT_LINE : CLEAR_LINE);
	1389	tms->device->set_input_line(INPUT_LINE_HALT, (data & 0x8000) ? ASSERT_LINE : CLEAR_LINE);
1390	1390
1391	1391	/* NMI issued? */
1392	1392	if (data & 0x0100)

trunk/src/emu/cpu/m37710/m37710.c

r17814	r17815
269	269	cpustate->timers[which]->adjust(cpustate->reload[which], param);
270	270
271	271	m37710_set_irq_line(cpustate, curirq, HOLD_LINE);
272		device_triggerint(cpustate->device);
	272	cpustate->device->signal_interrupt_trigger();
273	273	}
274	274
275	275	static void m37710_external_tick(m37710i_cpu_struct *cpustate, int timer, int state)

trunk/src/emu/cpu/i86/instr286.c

r17814	r17815
111	111	// this is supposed to triggered by support hardware
112	112	// create a shutdown output line that causes a reset
113	113	// NMI can wake processor without reset
114		device_set_input_line(cpustate->device, INPUT_LINE_RESET, PULSE_LINE);
	114	cpustate->device->set_input_line(INPUT_LINE_RESET, PULSE_LINE);
115	115	cpustate->trap_level = 0;
116	116	}
117	117

trunk/src/emu/cpu/i386/x87ops.c

r17814	r17815
292	292
293	293	if ((cpustate->x87_sw & ~cpustate->x87_cw) & 0x3f)
294	294	{
295		// device_set_input_line(cpustate->device, INPUT_LINE_FERR, RAISE_LINE);
	295	// cpustate->device->execute().set_input_line(INPUT_LINE_FERR, RAISE_LINE);
296	296	logerror("Unmasked x87 exception (CW:%.4x, SW:%.4x)\n", cpustate->x87_cw, cpustate->x87_sw);
297	297	if (cpustate->cr[0] & 0x20) // FIXME: 486 and up only
298	298	{

trunk/src/emu/cpu/i386/i386.c

r17814	r17815
646	646	if(trap_level >= 3)
647	647	{
648	648	logerror("IRQ: Triple fault. CPU reset.\n");
649		device_set_input_line(cpustate->device, INPUT_LINE_RESET, PULSE_LINE);
	649	cpustate->device->set_input_line(INPUT_LINE_RESET, PULSE_LINE);
650	650	return;
651	651	}
652	652

trunk/src/emu/cpu/m6502/m6502.h

r17814	r17815
46	46	};
47	47
48	48	#define M6502_IRQ_LINE      0
49		/* use device_set_input_line(cpudevice, M6502_SET_OVERFLOW, level)
	49	/* use cpudevice->execute().set_input_line(M6502_SET_OVERFLOW, level)
50	50	to change level of the so input line
51	51	positiv edge sets overflow flag */
52	52	#define M6502_SET_OVERFLOW   1

trunk/src/emu/cpu/m6502/m6509.h

r17814	r17815
34	34	};
35	35
36	36	#define M6509_IRQ_LINE               M6502_IRQ_LINE
37		/* use device_set_input_line(cpudevice, M6509_SET_OVERFLOW, level)
	37	/* use cpudevice->execute().set_input_line(M6509_SET_OVERFLOW, level)
38	38	to change level of the so input line
39	39	positiv edge sets overflow flag */
40	40	#define M6509_SET_OVERFLOW 3

trunk/src/emu/cpu/jaguar/jaguar.c

r17814	r17815
479	479	/* if we're halted, we shouldn't be here */
480	480	if (!(jaguar->ctrl[G_CTRL] & 1))
481	481	{
482		//device_set_input_line(device, INPUT_LINE_HALT, ASSERT_LINE);
	482	//device->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
483	483	jaguar->icount = 0;
484	484	return;
485	485	}
r17814	r17815
518	518	/* if we're halted, we shouldn't be here */
519	519	if (!(jaguar->ctrl[G_CTRL] & 1))
520	520	{
521		//device_set_input_line(device, INPUT_LINE_HALT, ASSERT_LINE);
	521	//device->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
522	522	jaguar->icount = 0;
523	523	return;
524	524	}
r17814	r17815
1296	1296	jaguar->ctrl[offset] = newval;
1297	1297	if ((oldval ^ newval) & 0x01)
1298	1298	{
1299		device_set_input_line(device, INPUT_LINE_HALT, (newval & 1) ? CLEAR_LINE : ASSERT_LINE);
1300		device_yield(device);
	1299	device->execute().set_input_line(INPUT_LINE_HALT, (newval & 1) ? CLEAR_LINE : ASSERT_LINE);
	1300	device->execute().yield();
1301	1301	}
1302	1302	if (newval & 0x02)
1303	1303	{
r17814	r17815
1395	1395	jaguar->ctrl[offset] = newval;
1396	1396	if ((oldval ^ newval) & 0x01)
1397	1397	{
1398		device_set_input_line(device, INPUT_LINE_HALT, (newval & 1) ? CLEAR_LINE : ASSERT_LINE);
1399		device_yield(device);
	1398	device->execute().set_input_line(INPUT_LINE_HALT, (newval & 1) ? CLEAR_LINE : ASSERT_LINE);
	1399	device->execute().yield();
1400	1400	}
1401	1401	if (newval & 0x02)
1402	1402	{

trunk/src/emu/cpu/sh4/sh4comn.c

r17814	r17815
1041	1041	if (sh4->irln == value)
1042	1042	return;
1043	1043	sh4->irln = value;
1044		device_set_input_line(device, SH4_IRLn, ASSERT_LINE);
1045		device_set_input_line(device, SH4_IRLn, CLEAR_LINE);
	1044	device->execute().set_input_line(SH4_IRLn, ASSERT_LINE);
	1045	device->execute().set_input_line(SH4_IRLn, CLEAR_LINE);
1046	1046	}
1047	1047
1048	1048	void sh4_set_irq_line(sh4_state *sh4, int irqline, int state) // set state of external interrupt line

trunk/src/emu/cpu/mips/mips3com.c

r17814	r17815
753	753	static TIMER_CALLBACK( compare_int_callback )
754	754	{
755	755	legacy_cpu_device *device = (legacy_cpu_device *)ptr;
756		device_set_input_line(device, MIPS3_IRQ5, ASSERT_LINE);
	756	device->set_input_line(MIPS3_IRQ5, ASSERT_LINE);
757	757	}
758	758
759	759

trunk/src/emu/cpu/tms7000/tms7000.c

r17814	r17815
545	545	if( --cpustate->t1_decrementer < 0 ) /* Decrement timer1 register and check for underflow */
546	546	{
547	547	cpustate->t1_decrementer = cpustate->pf[2]; /* Reload decrementer (8 bit) */
548		device_set_input_line(device, TMS7000_IRQ2_LINE, HOLD_LINE);
	548	device->execute().set_input_line(TMS7000_IRQ2_LINE, HOLD_LINE);
549	549	//LOG( ("tms7000: trigger int2 (cycles: %d)\t%d\tdelta %d\n", cpustate->device->total_cycles(), cpustate->device->total_cycles() - tick, cpustate->cycles_per_INT2-(cpustate->device->total_cycles() - tick) );
550	550	//tick = cpustate->device->total_cycles() );
551	551	/* Also, cascade out to timer 2 - timer 2 unimplemented */

trunk/src/emu/cpu/cp1610/cp1610.c

r17814	r17815
1561	1561	static CPU_RESET( cp1610 )
1562	1562	{
1563	1563	/* This is how we set the reset vector */
1564		device_set_input_line(device, CP1610_RESET, PULSE_LINE);
	1564	device->set_input_line(CP1610_RESET, PULSE_LINE);
1565	1565	}
1566	1566
1567	1567	/***************************************************

trunk/src/emu/video/voodoo.c

r17814	r17815
2159	2159	if (v->pci.stall_callback)
2160	2160	(*v->pci.stall_callback)(v->device, TRUE);
2161	2161	else
2162		device_spin_until_trigger(v->cpu, v->trigger);
	2162	v->cpu->execute().spin_until_trigger(v->trigger);
2163	2163
2164	2164	/* set a timer to clear the stall */
2165	2165	v->pci.continue_timer->adjust(v->pci.op_end_time - current_time);
r17814	r17815
3800	3800	/* bit 31 is not used */
3801	3801
3802	3802	/* eat some cycles since people like polling here */
3803		device_eat_cycles(v->cpu, 1000);
	3803	v->cpu->execute().eat_cycles(1000);
3804	3804	break;
3805	3805
3806	3806	/* bit 2 of the initEnable register maps this to dacRead */
r17814	r17815
3813	3813	case vRetrace:
3814	3814
3815	3815	/* eat some cycles since people like polling here */
3816		device_eat_cycles(v->cpu, 10);
	3816	v->cpu->execute().eat_cycles(10);
3817	3817	result = v->screen->vpos();
3818	3818	break;
3819	3819
r17814	r17815
3828	3828	result = v->fbi.cmdfifo[0].rdptr;
3829	3829
3830	3830	/* eat some cycles since people like polling here */
3831		device_eat_cycles(v->cpu, 1000);
	3831	v->cpu->execute().eat_cycles(1000);
3832	3832	break;
3833	3833
3834	3834	case cmdFifoAMin:

trunk/src/emu/sound/scsp.c

r17814	r17815
1241	1241	if(scsp->udata.data[0x1e/2] & 0x10)
1242	1242	{
1243	1243	popmessage("SCSP DMA IRQ triggered, contact MAMEdev");
1244		device_set_input_line(space->machine().device("audiocpu"),DecodeSCI(scsp,SCIDMA),HOLD_LINE);
	1244	space->machine().device("audiocpu")->execute().set_input_line(DecodeSCI(scsp,SCIDMA),HOLD_LINE);
1245	1245	}
1246	1246	}
1247	1247

trunk/src/emu/machine/k056230.c

r17814	r17815
96	96	{
97	97	if(m_cpu)
98	98	{
99		device_set_input_line(m_cpu, INPUT_LINE_IRQ2, CLEAR_LINE);
	99	m_cpu->execute().set_input_line(INPUT_LINE_IRQ2, CLEAR_LINE);
100	100	}
101	101	}
102	102
r17814	r17815
118	118	{
119	119	if(m_cpu)
120	120	{
121		device_set_input_line(m_cpu, INPUT_LINE_IRQ2, ASSERT_LINE);
	121	m_cpu->execute().set_input_line(INPUT_LINE_IRQ2, ASSERT_LINE);
122	122	}
123	123	machine().scheduler().timer_set(attotime::from_usec(10), FUNC(network_irq_clear_callback), 0, (void*)this);
124	124	}
125	125	}
126	126	//          else
127		//              device_set_input_line(k056230->cpu, INPUT_LINE_IRQ2, CLEAR_LINE);
	127	//              k056230->cpu->execute().set_input_line(INPUT_LINE_IRQ2, CLEAR_LINE);
128	128	break;
129	129	}
130	130	case 2:      // Sub ID register

trunk/src/emu/machine/8042kbdc.c

r17814	r17815
597	597	* the bits low set in the command byte.  The only pulse that has
598	598	* an effect currently is bit 0, which pulses the CPU's reset line
599	599	*/
600		device_set_input_line(space->machine().firstcpu, INPUT_LINE_RESET, PULSE_LINE);
	600	space->machine().firstcpu->set_input_line(INPUT_LINE_RESET, PULSE_LINE);
601	601	at_8042_set_outport(space->machine(), kbdc8042.outport | 0x02, 0);
602	602	break;
603	603	}

trunk/src/emu/machine/tmp68301.c

r17814	r17815
47	47	tmp68301_irq_vector[level]   =   IVNR & 0x00e0;
48	48	tmp68301_irq_vector[level]   +=   4+i;
49	49
50		device_set_input_line(machine.firstcpu,level,HOLD_LINE);
	50	machine.firstcpu->set_input_line(level,HOLD_LINE);
51	51	}
52	52
53	53	if (TCR & 0x0080)   // N/1
r17814	r17815
120	120	for (i = 0; i < 3; i++)
121	121	tmp68301_IE[i] = 0;
122	122
123		device_set_irq_callback(machine.firstcpu, tmp68301_irq_callback);
	123	machine.firstcpu->set_irq_acknowledge_callback(tmp68301_irq_callback);
124	124	}
125	125
126	126	/* Update the IRQ state based on all possible causes */
r17814	r17815
150	150
151	151	tmp68301_IE[i] = 0;      // Interrupts are edge triggerred
152	152
153		device_set_input_line(machine.firstcpu,level,HOLD_LINE);
	153	machine.firstcpu->set_input_line(level,HOLD_LINE);
154	154	}
155	155	}
156	156	}

trunk/src/emu/diexec.c

r17814	r17815
643	643
644	644	IRQ_CALLBACK( device_execute_interface::static_standard_irq_callback )
645	645	{
646		return device_execute(device)->standard_irq_callback(irqline);
	646	return device->execute().standard_irq_callback(irqline);
647	647	}
648	648
649	649	int device_execute_interface::standard_irq_callback(int irqline)

trunk/src/emu/diexec.h

r17814	r17815
341	341	typedef device_interface_iterator<device_execute_interface> execute_interface_iterator;
342	342
343	343
344
345		//**************************************************************************
346		//  INLINE HELPERS
347		//**************************************************************************
348
349		//-------------------------------------------------
350		//  device_execute - return a pointer to the device
351		//  execute interface for this device
352		//-------------------------------------------------
353
354		inline device_execute_interface *device_execute(device_t *device)
355		{
356		device_execute_interface *intf;
357		if (!device->interface(intf))
358		throw emu_fatalerror("Device '%s' does not have execute interface", device->tag());
359		return intf;
360		}
361
362
363
364		// ======================> device scheduling
365
366		// suspend the given device for a specific reason
367		inline void device_suspend(device_t *device, int reason, bool eatcycles)
368		{
369		device_execute(device)->suspend(reason, eatcycles);
370		}
371
372		// resume the given device for a specific reason
373		inline void device_resume(device_t *device, int reason)
374		{
375		device_execute(device)->resume(reason);
376		}
377
378
379
380		// ======================> synchronization helpers
381
382		// yield the given device until the end of the current timeslice
383		inline void device_yield(device_t *device)
384		{
385		device_execute(device)->yield();
386		}
387
388		// burn device cycles until the end of the current timeslice
389		inline void device_spin(device_t *device)
390		{
391		device_execute(device)->spin();
392		}
393
394		// burn specified device cycles until a trigger
395		inline void device_spin_until_trigger(device_t *device, int trigger)
396		{
397		device_execute(device)->spin_until_trigger(trigger);
398		}
399
400		// burn device cycles for a specific period of time
401		inline void device_spin_until_time(device_t *device, attotime duration)
402		{
403		device_execute(device)->spin_until_time(duration);
404		}
405
406
407
408		// ======================> device timing
409
410		// returns the current local time for a device
411		inline attotime device_get_local_time(device_t *device)
412		{
413		return device_execute(device)->local_time();
414		}
415
416		// safely eats cycles so we don't cross a timeslice boundary
417		inline void device_eat_cycles(device_t *device, int cycles)
418		{
419		device_execute(device)->eat_cycles(cycles);
420		}
421
422		// apply a +/- to the current icount
423		inline void device_adjust_icount(device_t *device, int delta)
424		{
425		device_execute(device)->adjust_icount(delta);
426		}
427
428		// abort execution for the current timeslice, allowing other devices to run before we run again
429		inline void device_abort_timeslice(device_t *device)
430		{
431		device_execute(device)->abort_timeslice();
432		}
433
434
435
436		// ======================> triggers
437
438		// generate a trigger corresponding to an interrupt on the given device
439		inline void device_triggerint(device_t *device)
440		{
441		device_execute(device)->signal_interrupt_trigger();
442		}
443
444
445
446		// ======================> interrupts
447
448		// set the logical state (ASSERT_LINE/CLEAR_LINE) of the an input line on a device
449		inline void device_set_input_line(device_t *device, int line, int state)
450		{
451		device_execute(device)->set_input_line(line, state);
452		}
453
454		// set the vector to be returned during a device's interrupt acknowledge cycle
455		inline void device_set_input_line_vector(device_t *device, int line, int vector)
456		{
457		device_execute(device)->set_input_line_vector(line, vector);
458		}
459
460		// set the logical state (ASSERT_LINE/CLEAR_LINE) of the an input line on a device and its associated vector
461		inline void device_set_input_line_and_vector(device_t *device, int line, int state, int vector)
462		{
463		device_execute(device)->set_input_line_and_vector(line, state, vector);
464		}
465
466		// install a driver-specific callback for IRQ acknowledge
467		inline void device_set_irq_callback(device_t *device, device_irq_acknowledge_callback callback)
468		{
469		device_execute(device)->set_irq_acknowledge_callback(callback);
470		}
471
472
473
474		// ======================> additional helpers
475
476		// burn device cycles until the next interrupt
477		inline void device_spin_until_interrupt(device_t *device)
478		{
479		device_execute(device)->spin_until_interrupt();
480		}
481
482
483
484	344	#endif   /* __DIEXEC_H__ */

trunk/src/mess/machine/dgn_beta.c

r17814	r17815
702	702
703	703	/* CPU un-halted let it run ! */
704	704	if (HALT_DMA == CLEAR_LINE)
705		device_yield(device->machine().device(MAINCPU_TAG));
	705	device->machine().device(MAINCPU_TAG)->execute().yield();
706	706
707	707	state->m_d_pia1_pa_last = data & 0x80;
708	708	}
r17814	r17815
741	741
742	742	/* CPU un-halted let it run ! */
743	743	if (HALT_CPU == CLEAR_LINE)
744		device_yield(device->machine().device(DMACPU_TAG));
	744	device->machine().device(DMACPU_TAG)->execute().yield();
745	745	}
746	746	}
747	747
r17814	r17815
789	789	{
790	790	device->machine().device(DMACPU_TAG)->execute().set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
791	791	logerror("device_yield()\n");
792		device_yield(device->machine().device(DMACPU_TAG));   /* Let DMA CPU run */
	792	device->machine().device(DMACPU_TAG)->execute().yield();   /* Let DMA CPU run */
793	793	}
794	794	else
795	795	{

trunk/src/mess/machine/c64_cpm.c

r17814	r17815
89	89	{
90	90	if (m_enabled)
91	91	{
92		device_set_input_line(m_maincpu, INPUT_LINE_HALT, CLEAR_LINE);
93		device_set_input_line(machine().firstcpu, INPUT_LINE_HALT, ASSERT_LINE);
	92	m_maincpu->set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
	93	machine().firstcpu->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
94	94
95	95	if (m_reset)
96	96	{
r17814	r17815
101	101	}
102	102	else
103	103	{
104		device_set_input_line(m_maincpu, INPUT_LINE_HALT, ASSERT_LINE);
105		device_set_input_line(machine().firstcpu, INPUT_LINE_HALT, CLEAR_LINE);
	104	m_maincpu->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
	105	machine().firstcpu->set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
106	106	}
107	107
108	108	/*

trunk/src/mess/machine/i82371ab.c

r17814	r17815
224	224	/* setup save states */
225	225	save_item(NAME(m_regs));
226	226
227		device_set_irq_callback(machine().device(":maincpu"), at_irq_callback);
	227	machine().device(":maincpu")->execute().set_irq_acknowledge_callback(at_irq_callback);
228	228	}
229	229
230	230	//-------------------------------------------------

trunk/src/mess/machine/egret.c

r17814	r17815
137	137	if (xcvr_session != ((data>>1)&1))
138	138	{
139	139	#ifdef EGRET_SUPER_VERBOSE
140		printf("EG-> XCVR_SESSION: %d (PC=%x)\n", (data>>1)&1, m_maincpu->safe_pc());
	140	printf("EG-> XCVR_SESSION: %d (PC=%x)\n", (data>>1)&1, m_maincpu->pc());
141	141	#endif
142	142	xcvr_session = (data>>1) & 1;
143	143	}
144	144	if (via_data != ((data>>5)&1))
145	145	{
146	146	#ifdef EGRET_SUPER_VERBOSE
147		printf("EG-> VIA_DATA: %d (PC=%x)\n", (data>>5)&1, m_maincpu->safe_pc());
	147	printf("EG-> VIA_DATA: %d (PC=%x)\n", (data>>5)&1, m_maincpu->pc());
148	148	#endif
149	149	via_data = (data>>5) & 1;
150	150	}
151	151	if (via_clock != ((data>>4)&1))
152	152	{
153	153	#ifdef EGRET_SUPER_VERBOSE
154		printf("EG-> VIA_CLOCK: %d (PC=%x)\n", ((data>>4)&1)^1, m_maincpu->safe_pc());
	154	printf("EG-> VIA_CLOCK: %d (PC=%x)\n", ((data>>4)&1)^1, m_maincpu->pc());
155	155	#endif
156	156	via_clock = (data>>4) & 1;
157	157	via6522_device *via1 = machine().device<via6522_device>("via6522_0");
r17814	r17815
312	312
313	313	if ((onesec & 0x40) && !(data & 0x40))
314	314	{
315		device_set_input_line(m_maincpu, M68HC05EG_INT_CPI, CLEAR_LINE);
	315	m_maincpu->set_input_line(M68HC05EG_INT_CPI, CLEAR_LINE);
316	316	}
317	317
318	318	onesec = data;
r17814	r17815
419	419
420	420	if (onesec & 0x10)
421	421	{
422		device_set_input_line(m_maincpu, M68HC05EG_INT_CPI, ASSERT_LINE);
	422	m_maincpu->set_input_line(M68HC05EG_INT_CPI, ASSERT_LINE);
423	423	}
424	424	}
425	425

trunk/src/mess/machine/at.c

r17814	r17815
155	155
156	156	WRITE_LINE_MEMBER( at_state::pc_dma_hrq_changed )
157	157	{
158		device_set_input_line(m_maincpu, INPUT_LINE_HALT, state ? ASSERT_LINE : CLEAR_LINE);
	158	m_maincpu->set_input_line(INPUT_LINE_HALT, state ? ASSERT_LINE : CLEAR_LINE);
159	159
160	160	/* Assert HLDA */
161	161	m_dma8237_2->hack_w(state);
r17814	r17815
354	354
355	355	MACHINE_START( at )
356	356	{
357		device_set_irq_callback(machine.device("maincpu"), at_irq_callback);
	357	machine.device("maincpu")->execute().set_irq_acknowledge_callback(at_irq_callback);
358	358	}
359	359
360	360	MACHINE_RESET( at )

trunk/src/mess/machine/orion.c

r17814	r17815
374	374	orion_state *state = device->machine().driver_data<orion_state>();
375	375	if ((state->m_orionz80_dispatcher & 0x40)==0x40)
376	376	{
377		device_set_input_line(device, 0, HOLD_LINE);
	377	device->execute().set_input_line(0, HOLD_LINE);
378	378	}
379	379	}
380	380

trunk/src/mess/machine/pc1512kb.c

r17814	r17815
299	299
300	300	void pc1512_keyboard_device::device_reset()
301	301	{
302		device_set_input_line(m_maincpu, MCS48_INPUT_EA, CLEAR_LINE);
	302	m_maincpu->set_input_line(MCS48_INPUT_EA, CLEAR_LINE);
303	303	}
304	304
305	305
r17814	r17815
311	311	{
312	312	if (!m_clock_in)
313	313	{
314		device_set_input_line(m_maincpu, INPUT_LINE_RESET, ASSERT_LINE);
	314	m_maincpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
315	315	}
316	316	}
317	317
r17814	r17815
340	340	}
341	341	else
342	342	{
343		device_set_input_line(m_maincpu, INPUT_LINE_RESET, CLEAR_LINE);
	343	m_maincpu->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
344	344	}
345	345	}
346	346

trunk/src/mess/machine/poly88.c

r17814	r17815
16	16	{
17	17	poly88_state *state = machine.driver_data<poly88_state>();
18	18	state->m_int_vector = 0xe7;
19		device_set_input_line(machine.device("maincpu"), 0, HOLD_LINE);
	19	machine.device("maincpu")->execute().set_input_line(0, HOLD_LINE);
20	20	}
21	21
22	22	WRITE8_MEMBER(poly88_state::poly88_baud_rate_w)
r17814	r17815
210	210	MACHINE_RESET(poly88)
211	211	{
212	212	poly88_state *state = machine.driver_data<poly88_state>();
213		device_set_irq_callback(machine.device("maincpu"), poly88_irq_callback);
	213	machine.device("maincpu")->execute().set_irq_acknowledge_callback(poly88_irq_callback);
214	214	state->m_intr = 0;
215	215	state->m_last_code = 0;
216	216
r17814	r17815
221	221	{
222	222	poly88_state *state = device->machine().driver_data<poly88_state>();
223	223	state->m_int_vector = 0xf7;
224		device_set_input_line(device, 0, HOLD_LINE);
	224	device->execute().set_input_line(0, HOLD_LINE);
225	225	}
226	226
227	227	static WRITE_LINE_DEVICE_HANDLER( poly88_usart_rxready )
228	228	{
229	229	//poly88_state *drvstate = device->machine().driver_data<poly88_state>();
230	230	//drvstate->m_int_vector = 0xe7;
231		//device_set_input_line(device, 0, HOLD_LINE);
	231	//device->execute().set_input_line(0, HOLD_LINE);
232	232	}
233	233
234	234	const i8251_interface poly88_usart_interface=

trunk/src/mess/machine/trs80.c

r17814	r17815
636	636	if (state->m_mask & IRQ_M4_RTC)
637	637	{
638	638	state->m_irq |= IRQ_M4_RTC;
639		device_set_input_line(device, 0, HOLD_LINE);
	639	device->execute().set_input_line(0, HOLD_LINE);
640	640	}
641	641	}
642	642	else      // Model 1
643	643	{
644	644	state->m_irq |= IRQ_M1_RTC;
645		device_set_input_line(device, 0, HOLD_LINE);
	645	device->execute().set_input_line(0, HOLD_LINE);
646	646	}
647	647	}
648	648

trunk/src/mess/machine/primo.c

r17814	r17815
35	35	{
36	36	primo_state *state = device->machine().driver_data<primo_state>();
37	37	if (state->m_nmi)
38		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	38	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
39	39	}
40	40
41	41	/*******************************************************************************

trunk/src/mess/machine/x68k_neptunex.c

r17814	r17815
146	146
147	147	WRITE_LINE_MEMBER(x68k_neptune_device::x68k_neptune_irq_w)
148	148	{
149		device_set_input_line_vector(machine().device("maincpu"),2, NEPTUNE_IRQ_VECTOR);
	149	machine().device("maincpu")->execute().set_input_line_vector(2, NEPTUNE_IRQ_VECTOR);
150	150	m_slot->irq2_w(state);
151	151	logerror("Neptune: IRQ2 set to %i\n",state);
152	152	}

trunk/src/mess/machine/a2softcard.c

r17814	r17815
85	85	m_bEnabled = false;
86	86	m_6502space = NULL;
87	87	m_FirstZ80Boot = true;
88		device_set_input_line(m_z80, INPUT_LINE_HALT, ASSERT_LINE);
	88	m_z80->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
89	89	}
90	90
91	91	void a2bus_softcard_device::write_cnxx(address_space &space, UINT8 offset, UINT8 data)
r17814	r17815
97	97	// steal the 6502's address space
98	98	m_6502space = &space;
99	99
100		device_set_input_line(m_z80, INPUT_LINE_HALT, CLEAR_LINE);
101		device_set_input_line(state->m_maincpu, INPUT_LINE_HALT, ASSERT_LINE);
	100	m_z80->set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
	101	state->m_maincpu->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
102	102
103	103	if (m_FirstZ80Boot)
104	104	{
r17814	r17815
110	110	}
111	111	else
112	112	{
113		device_set_input_line(m_z80, INPUT_LINE_HALT, ASSERT_LINE);
114		device_set_input_line(state->m_maincpu, INPUT_LINE_HALT, CLEAR_LINE);
	113	m_z80->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
	114	state->m_maincpu->set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
115	115	m_bEnabled = false;
116	116	}
117	117	}

trunk/src/mess/machine/svi318.c

r17814	r17815
540	540	m_svi.svi318 = 1;
541	541	}
542	542
543		device_set_input_line_vector(machine().device("maincpu"), 0, 0xff);
	543	machine().device("maincpu")->execute().set_input_line_vector(0, 0xff);
544	544
545	545	/* memory */
546	546	m_svi.empty_bank = auto_alloc_array(machine(), UINT8, 0x8000);

trunk/src/mess/machine/dec_lk201.c

r17814	r17815
107	107
108	108	WRITE8_MEMBER( lk201_device::ddr_w )
109	109	{
110		//    printf("%02x to PORT %c DDR (PC=%x)\n", data, 'A' + offset, m_maincpu->safe_pc());
	110	//    printf("%02x to PORT %c DDR (PC=%x)\n", data, 'A' + offset, m_maincpu->pc());
111	111
112	112	send_port(space, offset, ports[offset] & data);
113	113
r17814	r17815
135	135	// add in ddr-masked version of port writes
136	136	incoming |= (ports[offset] & ddrs[offset]);
137	137
138		//    printf("PORT %c read = %02x (DDR = %02x latch = %02x) (PC=%x)\n", 'A' + offset, ports[offset], ddrs[offset], ports[offset], m_maincpu->safe_pc());
	138	//    printf("PORT %c read = %02x (DDR = %02x latch = %02x) (PC=%x)\n", 'A' + offset, ports[offset], ddrs[offset], ports[offset], m_maincpu->pc());
139	139
140	140	return incoming;
141	141	}
r17814	r17815
149	149
150	150	void lk201_device::send_port(address_space &space, UINT8 offset, UINT8 data)
151	151	{
152		//    printf("PORT %c write %02x (DDR = %02x) (PC=%x)\n", 'A' + offset, data, ddrs[offset], m_maincpu->safe_pc());
	152	//    printf("PORT %c write %02x (DDR = %02x) (PC=%x)\n", 'A' + offset, data, ddrs[offset], m_maincpu->pc());
153	153
154	154	switch (offset)
155	155	{
r17814	r17815
187	187	break;
188	188	}
189	189
190		//    printf("SCI read @ %x = %02x (PC=%x)\n", offset, incoming, m_maincpu->safe_pc());
	190	//    printf("SCI read @ %x = %02x (PC=%x)\n", offset, incoming, m_maincpu->pc());
191	191
192	192	return incoming;
193	193	}
r17814	r17815
212	212	break;
213	213	}
214	214
215		//    printf("SCI %02x to %x (PC=%x)\n", data, offset, m_maincpu->safe_pc());
	215	//    printf("SCI %02x to %x (PC=%x)\n", data, offset, m_maincpu->pc());
216	216	}
217	217
218	218	READ8_MEMBER( lk201_device::spi_r )
r17814	r17815
232	232	break;
233	233	}
234	234
235		//    printf("SPI read @ %x = %02x (PC=%x)\n", offset, incoming, m_maincpu->safe_pc());
	235	//    printf("SPI read @ %x = %02x (PC=%x)\n", offset, incoming, m_maincpu->pc());
236	236
237	237	return incoming;
238	238	}
r17814	r17815
251	251	break;
252	252	}
253	253
254		//    printf("SPI %02x to %x (PC=%x)\n", data, offset, m_maincpu->safe_pc());
	254	//    printf("SPI %02x to %x (PC=%x)\n", data, offset, m_maincpu->pc());
255	255	}
256	256
257	257	/*

trunk/src/mess/machine/mpc105.c

r17814	r17815
40	40
41	41	void mpc105_device::device_start()
42	42	{
43		m_maincpu = machine().device(m_cputag);
	43	m_maincpu = machine().device<cpu_device>(m_cputag);
44	44	}
45	45
46	46	//-------------------------------------------------
r17814	r17815
94	94
95	95	if (m_bank_base > 0)
96	96	{
97		address_space *space = m_maincpu->memory().space(AS_PROGRAM);
	97	address_space *space = m_maincpu->space(AS_PROGRAM);
98	98
99	99	/* first clear everything out */
100	100	space->nop_read(0x00000000, 0x3FFFFFFF);

trunk/src/mess/machine/mpc105.h

r17814	r17815
47	47	UINT8 m_bank_enable;
48	48	UINT32 m_bank_registers[8];
49	49
50		device_t*   m_maincpu;
	50	cpu_device*   m_maincpu;
51	51	};
52	52
53	53

trunk/src/mess/machine/nes.c

r17814	r17815
222	222	static TIMER_CALLBACK( nes_irq_callback )
223	223	{
224	224	nes_state *state = machine.driver_data<nes_state>();
225		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	225	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
226	226	state->m_irq_timer->adjust(attotime::never);
227	227	}
228	228
r17814	r17815
296	296	init_nes_core(machine);
297	297	machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(nes_machine_stop),&machine));
298	298
299		state->m_maincpu = machine.device("maincpu");
	299	state->m_maincpu = machine.device<cpu_device>("maincpu");
300	300	state->m_sound = machine.device("nessound");
301	301	state->m_cart = machine.device("cart");
302	302
r17814	r17815
1538	1538	nes_state *state = device->machine().driver_data<nes_state>();
1539	1539
1540	1540	if (state->m_IRQ_enable_latch)
1541		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	1541	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
1542	1542
1543	1543	if (state->m_IRQ_enable)
1544	1544	{
1545	1545	if (state->m_IRQ_count <= 114)
1546	1546	{
1547		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	1547	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
1548	1548	state->m_IRQ_enable = 0;
1549	1549	state->m_fds_status0 |= 0x01;
1550	1550	}

trunk/src/mess/machine/nes_ines.c

r17814	r17815
38	38	{
39	39	if ((0xffff - state->m_IRQ_count) < 114)
40	40	{
41		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	41	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
42	42	state->m_IRQ_count = 0xffff;
43	43	state->m_IRQ_enable = 0;
44	44	}

trunk/src/mess/machine/mc68328.c

r17814	r17815
42	42
43	43	if(mc68328->regs.isr & INT_M68K_LINE7)
44	44	{
45		device_set_input_line_and_vector(cpu, M68K_IRQ_7, ASSERT_LINE, mc68328->regs.ivr | 0x07);
	45	cpu->execute().set_input_line_and_vector(M68K_IRQ_7, ASSERT_LINE, mc68328->regs.ivr | 0x07);
46	46	}
47	47	else if(mc68328->regs.isr & INT_M68K_LINE6)
48	48	{
49		device_set_input_line_and_vector(cpu, M68K_IRQ_6, ASSERT_LINE, mc68328->regs.ivr | 0x06);
	49	cpu->execute().set_input_line_and_vector(M68K_IRQ_6, ASSERT_LINE, mc68328->regs.ivr | 0x06);
50	50	}
51	51	else if(mc68328->regs.isr & INT_M68K_LINE5)
52	52	{
53		device_set_input_line_and_vector(cpu, M68K_IRQ_5, ASSERT_LINE, mc68328->regs.ivr | 0x05);
	53	cpu->execute().set_input_line_and_vector(M68K_IRQ_5, ASSERT_LINE, mc68328->regs.ivr | 0x05);
54	54	}
55	55	else if(mc68328->regs.isr & INT_M68K_LINE4)
56	56	{
57		device_set_input_line_and_vector(cpu, M68K_IRQ_4, ASSERT_LINE, mc68328->regs.ivr | 0x04);
	57	cpu->execute().set_input_line_and_vector(M68K_IRQ_4, ASSERT_LINE, mc68328->regs.ivr | 0x04);
58	58	}
59	59	else if(mc68328->regs.isr & INT_M68K_LINE3)
60	60	{
61		device_set_input_line_and_vector(cpu, M68K_IRQ_3, ASSERT_LINE, mc68328->regs.ivr | 0x03);
	61	cpu->execute().set_input_line_and_vector(M68K_IRQ_3, ASSERT_LINE, mc68328->regs.ivr | 0x03);
62	62	}
63	63	else if(mc68328->regs.isr & INT_M68K_LINE2)
64	64	{
65		device_set_input_line_and_vector(cpu, M68K_IRQ_2, ASSERT_LINE, mc68328->regs.ivr | 0x02);
	65	cpu->execute().set_input_line_and_vector(M68K_IRQ_2, ASSERT_LINE, mc68328->regs.ivr | 0x02);
66	66	}
67	67	else if(mc68328->regs.isr & INT_M68K_LINE1)
68	68	{
69		device_set_input_line_and_vector(cpu, M68K_IRQ_1, ASSERT_LINE, mc68328->regs.ivr | 0x01);
	69	cpu->execute().set_input_line_and_vector(M68K_IRQ_1, ASSERT_LINE, mc68328->regs.ivr | 0x01);
70	70	}
71	71	}
72	72	}
r17814	r17815
76	76
77	77	if((line & INT_M68K_LINE7) && !(mc68328->regs.isr & INT_M68K_LINE7))
78	78	{
79		device_set_input_line(cpu, M68K_IRQ_7, CLEAR_LINE);
	79	cpu->execute().set_input_line(M68K_IRQ_7, CLEAR_LINE);
80	80	}
81	81	if((line & INT_M68K_LINE6) && !(mc68328->regs.isr & INT_M68K_LINE6))
82	82	{
83		device_set_input_line(cpu, M68K_IRQ_6, CLEAR_LINE);
	83	cpu->execute().set_input_line(M68K_IRQ_6, CLEAR_LINE);
84	84	}
85	85	if((line & INT_M68K_LINE5) && !(mc68328->regs.isr & INT_M68K_LINE5))
86	86	{
87		device_set_input_line(cpu, M68K_IRQ_5, CLEAR_LINE);
	87	cpu->execute().set_input_line(M68K_IRQ_5, CLEAR_LINE);
88	88	}
89	89	if((line & INT_M68K_LINE4) && !(mc68328->regs.isr & INT_M68K_LINE4))
90	90	{
91		device_set_input_line(cpu, M68K_IRQ_4, CLEAR_LINE);
	91	cpu->execute().set_input_line(M68K_IRQ_4, CLEAR_LINE);
92	92	}
93	93	if((line & INT_M68K_LINE3) && !(mc68328->regs.isr & INT_M68K_LINE3))
94	94	{
95		device_set_input_line(cpu, M68K_IRQ_3, CLEAR_LINE);
	95	cpu->execute().set_input_line(M68K_IRQ_3, CLEAR_LINE);
96	96	}
97	97	if((line & INT_M68K_LINE2) && !(mc68328->regs.isr & INT_M68K_LINE2))
98	98	{
99		device_set_input_line(cpu, M68K_IRQ_2, CLEAR_LINE);
	99	cpu->execute().set_input_line(M68K_IRQ_2, CLEAR_LINE);
100	100	}
101	101	if((line & INT_M68K_LINE1) && !(mc68328->regs.isr & INT_M68K_LINE1))
102	102	{
103		device_set_input_line(cpu, M68K_IRQ_1, CLEAR_LINE);
	103	cpu->execute().set_input_line(M68K_IRQ_1, CLEAR_LINE);
104	104	}
105	105	}
106	106	}

trunk/src/mess/machine/intv.c

r17814	r17815
618	618	/* Set Reset and INTR/INTRM Vector */
619	619	MACHINE_RESET( intv )
620	620	{
621		device_set_input_line_vector(machine.device("maincpu"), CP1610_RESET, 0x1000);
	621	machine.device("maincpu")->execute().set_input_line_vector(CP1610_RESET, 0x1000);
622	622
623	623	/* These are actually the same vector, and INTR is unused */
624		device_set_input_line_vector(machine.device("maincpu"), CP1610_INT_INTRM, 0x1004);
625		device_set_input_line_vector(machine.device("maincpu"), CP1610_INT_INTR,  0x1004);
	624	machine.device("maincpu")->execute().set_input_line_vector(CP1610_INT_INTRM, 0x1004);
	625	machine.device("maincpu")->execute().set_input_line_vector(CP1610_INT_INTR,  0x1004);
626	626
627	627	/* Set initial PC */
628	628	machine.device("maincpu")->state().set_state_int(CP1610_R7, 0x1000);
r17814	r17815
638	638	state->membank("bank3")->set_base(machine.root_device().memregion("maincpu")->base() + (0xE000 << 1));
639	639	state->membank("bank4")->set_base(machine.root_device().memregion("maincpu")->base() + (0xF000 << 1));
640	640
641		device_set_input_line_vector(machine.device("maincpu"), CP1610_RESET, 0x1000);
	641	machine.device("maincpu")->execute().set_input_line_vector(CP1610_RESET, 0x1000);
642	642
643	643	/* These are actually the same vector, and INTR is unused */
644		device_set_input_line_vector(machine.device("maincpu"), CP1610_INT_INTRM, 0x1004);
645		device_set_input_line_vector(machine.device("maincpu"), CP1610_INT_INTR,  0x1004);
	644	machine.device("maincpu")->execute().set_input_line_vector(CP1610_INT_INTRM, 0x1004);
	645	machine.device("maincpu")->execute().set_input_line_vector(CP1610_INT_INTR,  0x1004);
646	646
647	647	/* Set initial PC */
648	648	machine.device("maincpu")->state().set_state_int(CP1610_R7, 0x1000);
r17814	r17815
663	663	intv_state *state = machine.driver_data<intv_state>();
664	664	UINT8 column;
665	665	UINT8 row = state->m_backtab_row;
666		//device_adjust_icount(machine.device("maincpu"), -STIC_ROW_FETCH);
	666	//machine.device("maincpu")->execute().adjust_icount(-STIC_ROW_FETCH);
667	667	for(column=0; column < STIC_BACKTAB_WIDTH; column++)
668	668	{
669	669	state->m_backtab_buffer[row][column] = state->m_ram16[column + row * STIC_BACKTAB_WIDTH];
r17814	r17815
680	680	state->m_bus_copy_mode = 1;
681	681	state->m_backtab_row = 0;
682	682	UINT8 row;
683		device_adjust_icount(device->machine().device("maincpu"), -(12*STIC_ROW_BUSRQ+STIC_FRAME_BUSRQ)); // Account for stic cycle stealing
	683	device->machine().device("maincpu")->execute().adjust_icount(-(12*STIC_ROW_BUSRQ+STIC_FRAME_BUSRQ)); // Account for stic cycle stealing
684	684	device->machine().scheduler().timer_set(device->machine().device<cpu_device>("maincpu")
685	685	->cycles_to_attotime(STIC_VBLANK_END), FUNC(intv_interrupt_complete));
686	686	for (row=0; row < STIC_BACKTAB_HEIGHT; row++)
r17814	r17815
691	691
692	692	if (state->m_row_delay == 0)
693	693	{
694		device_adjust_icount(device->machine().device("maincpu"), -STIC_ROW_BUSRQ); // extra row fetch occurs if vertical delay == 0
	694	device->machine().device("maincpu")->execute().adjust_icount(-STIC_ROW_BUSRQ); // extra row fetch occurs if vertical delay == 0
695	695	}
696	696
697	697	intv_stic_screenrefresh(device->machine());

trunk/src/mess/machine/s100.c

r17814	r17815
126	126
127	127	void s100_device::device_start()
128	128	{
129		m_maincpu = machine().device(m_cputag);
	129	m_maincpu = machine().device<cpu_device>(m_cputag);
130	130
131	131	// resolve callbacks
132	132	m_out_int_func.resolve(m_out_int_cb, *this);

trunk/src/mess/machine/a2eauxslot.c

r17814	r17815
112	112
113	113	void a2eauxslot_device::device_start()
114	114	{
115		m_maincpu = machine().device(m_cputag);
	115	m_maincpu = machine().device<cpu_device>(m_cputag);
116	116
117	117	// resolve callbacks
118	118	m_out_irq_func.resolve(m_out_irq_cb, *this);

trunk/src/mess/machine/s100.h

r17814	r17815
206	206
207	207	private:
208	208	// internal state
209		device_t   *m_maincpu;
	209	cpu_device   *m_maincpu;
210	210
211	211	devcb_resolved_write_line   m_out_int_func;
212	212	devcb_resolved_write_line   m_out_nmi_func;

trunk/src/mess/machine/nubus.c

r17814	r17815
116	116
117	117	void nubus_device::device_start()
118	118	{
119		m_maincpu = machine().device(m_cputag);
	119	m_maincpu = machine().device<cpu_device>(m_cputag);
120	120	// resolve callbacks
121	121	m_out_irq9_func.resolve(m_out_irq9_cb, *this);
122	122	m_out_irqa_func.resolve(m_out_irqa_cb, *this);
r17814	r17815
141	141
142	142	void nubus_device::install_device(offs_t start, offs_t end, read8_delegate rhandler, write8_delegate whandler, UINT32 mask)
143	143	{
144		m_maincpu = machine().device(m_cputag);
145		int buswidth = m_maincpu->memory().space_config(AS_PROGRAM)->m_databus_width;
	144	m_maincpu = machine().device<cpu_device>(m_cputag);
	145	int buswidth = m_maincpu->space_config(AS_PROGRAM)->m_databus_width;
146	146	switch(buswidth)
147	147	{
148	148	case 32:
149		m_maincpu->memory().space(AS_PROGRAM)->install_readwrite_handler(start, end, rhandler, whandler, mask);
	149	m_maincpu->space(AS_PROGRAM)->install_readwrite_handler(start, end, rhandler, whandler, mask);
150	150	break;
151	151	case 64:
152		m_maincpu->memory().space(AS_PROGRAM)->install_readwrite_handler(start, end, rhandler, whandler, ((UINT64)mask<<32)|mask);
	152	m_maincpu->space(AS_PROGRAM)->install_readwrite_handler(start, end, rhandler, whandler, ((UINT64)mask<<32)|mask);
153	153	break;
154	154	default:
155	155	fatalerror("NUBUS: Bus width %d not supported\n", buswidth);
r17814	r17815
159	159
160	160	void nubus_device::install_device(offs_t start, offs_t end, read16_delegate rhandler, write16_delegate whandler, UINT32 mask)
161	161	{
162		m_maincpu = machine().device(m_cputag);
163		int buswidth = m_maincpu->memory().space_config(AS_PROGRAM)->m_databus_width;
	162	m_maincpu = machine().device<cpu_device>(m_cputag);
	163	int buswidth = m_maincpu->space_config(AS_PROGRAM)->m_databus_width;
164	164	switch(buswidth)
165	165	{
166	166	case 32:
167		m_maincpu->memory().space(AS_PROGRAM)->install_readwrite_handler(start, end, rhandler, whandler, mask);
	167	m_maincpu->space(AS_PROGRAM)->install_readwrite_handler(start, end, rhandler, whandler, mask);
168	168	break;
169	169	case 64:
170		m_maincpu->memory().space(AS_PROGRAM)->install_readwrite_handler(start, end, rhandler, whandler, ((UINT64)mask<<32)|mask);
	170	m_maincpu->space(AS_PROGRAM)->install_readwrite_handler(start, end, rhandler, whandler, ((UINT64)mask<<32)|mask);
171	171	break;
172	172	default:
173	173	fatalerror("NUBUS: Bus width %d not supported\n", buswidth);
r17814	r17815
177	177
178	178	void nubus_device::install_device(offs_t start, offs_t end, read32_delegate rhandler, write32_delegate whandler, UINT32 mask)
179	179	{
180		m_maincpu = machine().device(m_cputag);
181		int buswidth = m_maincpu->memory().space_config(AS_PROGRAM)->m_databus_width;
	180	m_maincpu = machine().device<cpu_device>(m_cputag);
	181	int buswidth = m_maincpu->space_config(AS_PROGRAM)->m_databus_width;
182	182	switch(buswidth)
183	183	{
184	184	case 32:
185		m_maincpu->memory().space(AS_PROGRAM)->install_readwrite_handler(start, end, rhandler, whandler, mask);
	185	m_maincpu->space(AS_PROGRAM)->install_readwrite_handler(start, end, rhandler, whandler, mask);
186	186	break;
187	187	case 64:
188		m_maincpu->memory().space(AS_PROGRAM)->install_readwrite_handler(start, end, rhandler, whandler, ((UINT64)mask<<32)|mask);
	188	m_maincpu->space(AS_PROGRAM)->install_readwrite_handler(start, end, rhandler, whandler, ((UINT64)mask<<32)|mask);
189	189	break;
190	190	default:
191	191	fatalerror("NUBUS: Bus width %d not supported\n", buswidth);
r17814	r17815
195	195
196	196	void nubus_device::install_readonly_device(offs_t start, offs_t end, read32_delegate rhandler, UINT32 mask)
197	197	{
198		m_maincpu = machine().device(m_cputag);
199		int buswidth = m_maincpu->memory().space_config(AS_PROGRAM)->m_databus_width;
	198	m_maincpu = machine().device<cpu_device>(m_cputag);
	199	int buswidth = m_maincpu->space_config(AS_PROGRAM)->m_databus_width;
200	200	switch(buswidth)
201	201	{
202	202	case 32:
203		m_maincpu->memory().space(AS_PROGRAM)->install_read_handler(start, end, rhandler, mask);
	203	m_maincpu->space(AS_PROGRAM)->install_read_handler(start, end, rhandler, mask);
204	204	break;
205	205	case 64:
206		m_maincpu->memory().space(AS_PROGRAM)->install_read_handler(start, end, rhandler, ((UINT64)mask<<32)|mask);
	206	m_maincpu->space(AS_PROGRAM)->install_read_handler(start, end, rhandler, ((UINT64)mask<<32)|mask);
207	207	break;
208	208	default:
209	209	fatalerror("NUBUS: Bus width %d not supported\n", buswidth);
r17814	r17815
213	213
214	214	void nubus_device::install_writeonly_device(offs_t start, offs_t end, write32_delegate whandler, UINT32 mask)
215	215	{
216		m_maincpu = machine().device(m_cputag);
217		int buswidth = m_maincpu->memory().space_config(AS_PROGRAM)->m_databus_width;
	216	m_maincpu = machine().device<cpu_device>(m_cputag);
	217	int buswidth = m_maincpu->space_config(AS_PROGRAM)->m_databus_width;
218	218	switch(buswidth)
219	219	{
220	220	case 32:
221		m_maincpu->memory().space(AS_PROGRAM)->install_write_handler(start, end, whandler, mask);
	221	m_maincpu->space(AS_PROGRAM)->install_write_handler(start, end, whandler, mask);
222	222	break;
223	223	case 64:
224		m_maincpu->memory().space(AS_PROGRAM)->install_write_handler(start, end, whandler, ((UINT64)mask<<32)|mask);
	224	m_maincpu->space(AS_PROGRAM)->install_write_handler(start, end, whandler, ((UINT64)mask<<32)|mask);
225	225	break;
226	226	default:
227	227	fatalerror("NUBUS: Bus width %d not supported\n", buswidth);
r17814	r17815
232	232	void nubus_device::install_bank(offs_t start, offs_t end, offs_t mask, offs_t mirror, const char *tag, UINT8 *data)
233	233	{
234	234	//  printf("install_bank: %s @ %x->%x mask %x mirror %x\n", tag, start, end, mask, mirror);
235		m_maincpu = machine().device(m_cputag);
236		address_space *space = m_maincpu->memory().space(AS_PROGRAM);
	235	m_maincpu = machine().device<cpu_device>(m_cputag);
	236	address_space *space = m_maincpu->space(AS_PROGRAM);
237	237	space->install_readwrite_bank(start, end, mask, mirror, tag );
238	238	machine().root_device().membank(tag)->set_base(data);
239	239	}

trunk/src/mess/machine/a2eauxslot.h

r17814	r17815
97	97	virtual void device_config_complete();
98	98
99	99	// internal state
100		device_t   *m_maincpu;
	100	cpu_device   *m_maincpu;
101	101
102	102	devcb_resolved_write_line   m_out_irq_func;
103	103	devcb_resolved_write_line   m_out_nmi_func;

trunk/src/mess/machine/nubus.h

r17814	r17815
113	113	virtual void device_config_complete();
114	114
115	115	// internal state
116		device_t   *m_maincpu;
	116	cpu_device   *m_maincpu;
117	117
118	118	devcb_resolved_write_line   m_out_irq9_func;
119	119	devcb_resolved_write_line   m_out_irqa_func;

trunk/src/mess/machine/abc77.c

r17814	r17815
498	498	int ea = BIT(ioport("DSW")->read(), 7);
499	499
500	500	// trigger reset
501		device_set_input_line(m_maincpu, INPUT_LINE_RESET, ASSERT_LINE);
	501	m_maincpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
502	502	m_reset_timer->adjust(attotime::from_msec(t));
503	503
504		device_set_input_line(m_maincpu, MCS48_INPUT_EA, ea ? CLEAR_LINE : ASSERT_LINE);
	504	m_maincpu->set_input_line(MCS48_INPUT_EA, ea ? CLEAR_LINE : ASSERT_LINE);
505	505	}
506	506
507	507
r17814	r17815
518	518	break;
519	519
520	520	case TIMER_RESET:
521		device_set_input_line(m_maincpu, INPUT_LINE_RESET, CLEAR_LINE);
	521	m_maincpu->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
522	522	break;
523	523	}
524	524	}
r17814	r17815
638	638
639	639	WRITE_LINE_MEMBER( abc77_device::rxd_w )
640	640	{
641		device_set_input_line(m_maincpu, MCS48_INPUT_IRQ, state ? CLEAR_LINE : ASSERT_LINE);
	641	m_maincpu->set_input_line(MCS48_INPUT_IRQ, state ? CLEAR_LINE : ASSERT_LINE);
642	642	}
643	643
644	644

trunk/src/mess/machine/tf20.c

r17814	r17815
330	330	device_t *cpu = device->subdevice("tf20");
331	331	address_space *prg = cpu->memory().space(AS_PROGRAM);
332	332
333		device_set_irq_callback(cpu, tf20_irq_ack);
	333	cpu->execute().set_irq_acknowledge_callback(tf20_irq_ack);
334	334
335	335	/* ram device */
336	336	tf20->ram = device->subdevice<ram_device>("ram");

trunk/src/mess/machine/a2bus.c

r17814	r17815
175	175
176	176	void a2bus_device::device_start()
177	177	{
178		m_maincpu = machine().device(m_cputag);
	178	m_maincpu = machine().device<cpu_device>(m_cputag);
179	179
180	180	// resolve callbacks
181	181	m_out_irq_func.resolve(m_out_irq_cb, *this);

trunk/src/mess/machine/a2bus.h

r17814	r17815
105	105	virtual void device_config_complete();
106	106
107	107	// internal state
108		device_t   *m_maincpu;
	108	cpu_device   *m_maincpu;
109	109
110	110	devcb_resolved_write_line   m_out_irq_func;
111	111	devcb_resolved_write_line   m_out_nmi_func;

trunk/src/mess/machine/hd63450.c

r17814	r17815
258	258	if((dmac->reg[channel].dcr & 0xc0) == 0x00)  // Burst transfer
259	259	{
260	260	device_t *cpu = device->machine().device(dmac->intf->cpu_tag);
261		device_set_input_line(cpu, INPUT_LINE_HALT, ASSERT_LINE);
	261	cpu->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
262	262	dmac->timer[channel]->adjust(attotime::zero, channel, dmac->burst_clock[channel]);
263	263	}
264	264	else
r17814	r17815
440	440	if((dmac->reg[x].dcr & 0xc0) == 0x00)
441	441	{
442	442	device_t *cpu = device->machine().device(dmac->intf->cpu_tag);
443		device_set_input_line(cpu, INPUT_LINE_HALT, CLEAR_LINE);
	443	cpu->execute().set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
444	444	}
445	445
446	446	if(dmac->intf->dma_end)

trunk/src/mess/machine/pc.c

r17814	r17815
171	171	static WRITE_LINE_DEVICE_HANDLER( pc_dma_hrq_changed )
172	172	{
173	173	pc_state *st = device->machine().driver_data<pc_state>();
174		device_set_input_line(st->m_maincpu, INPUT_LINE_HALT, state ? ASSERT_LINE : CLEAR_LINE);
	174	st->m_maincpu->set_input_line(INPUT_LINE_HALT, state ? ASSERT_LINE : CLEAR_LINE);
175	175
176	176	/* Assert HLDA */
177	177	i8237_hlda_w( device, state );
r17814	r17815
291	291
292	292	static TIMER_CALLBACK( pcjr_delayed_pic8259_irq )
293	293	{
294		device_set_input_line(machine.firstcpu, 0, param ? ASSERT_LINE : CLEAR_LINE);
	294	machine.firstcpu->set_input_line(0, param ? ASSERT_LINE : CLEAR_LINE);
295	295	}
296	296
297	297	static WRITE_LINE_DEVICE_HANDLER( pcjr_pic8259_set_int_line )
r17814	r17815
302	302	}
303	303	else
304	304	{
305		device_set_input_line(device->machine().firstcpu, 0, state ? ASSERT_LINE : CLEAR_LINE);
	305	device->machine().firstcpu->set_input_line(0, state ? ASSERT_LINE : CLEAR_LINE);
306	306	}
307	307	}
308	308
r17814	r17815
645	645	pcjr_keyb.latch = 1;
646	646	if ( nmi_enabled & 0x80 )
647	647	{
648		device_set_input_line( st->m_pit8253->machine().firstcpu, INPUT_LINE_NMI, PULSE_LINE );
	648	st->m_pit8253->machine().firstcpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE );
649	649	}
650	650	}
651	651	}
r17814	r17815
1447	1447	{
1448	1448	device_t *speaker = machine.device(SPEAKER_TAG);
1449	1449	pc_state *st = machine.driver_data<pc_state>();
1450		st->m_maincpu = machine.device("maincpu" );
1451		device_set_irq_callback(st->m_maincpu, pc_irq_callback);
	1450	st->m_maincpu = machine.device<cpu_device>("maincpu" );
	1451	st->m_maincpu->set_irq_acknowledge_callback(pc_irq_callback);
1452	1452
1453	1453	st->m_u73_q2 = 0;
1454	1454	st->m_out1 = 0;
r17814	r17815
1473	1473	MACHINE_START( mc1502 )
1474	1474	{
1475	1475	pc_state *st = machine.driver_data<pc_state>();
1476		st->m_maincpu = machine.device("maincpu" );
1477		device_set_irq_callback(st->m_maincpu, pc_irq_callback);
	1476	st->m_maincpu = machine.device<cpu_device>("maincpu" );
	1477	st->m_maincpu->set_irq_acknowledge_callback(pc_irq_callback);
1478	1478
1479	1479	st->m_pic8259 = machine.device("pic8259");
1480	1480	st->m_dma8237 = NULL;
r17814	r17815
1499	1499	pc_fdc_init( machine, &pcjr_fdc_interface_nc );
1500	1500	pcjr_keyb.keyb_signal_timer = machine.scheduler().timer_alloc(FUNC(pcjr_keyb_signal_callback));
1501	1501	pc_int_delay_timer = machine.scheduler().timer_alloc(FUNC(pcjr_delayed_pic8259_irq));
1502		st->m_maincpu = machine.device("maincpu" );
1503		device_set_irq_callback(st->m_maincpu, pc_irq_callback);
	1502	st->m_maincpu = machine.device<cpu_device>("maincpu" );
	1503	st->m_maincpu->set_irq_acknowledge_callback(pc_irq_callback);
1504	1504
1505	1505	st->m_pic8259 = machine.device("pic8259");
1506	1506	st->m_dma8237 = NULL;

trunk/src/mess/machine/bbc.c

r17814	r17815
1425	1425	{
1426	1426	/* I'll pulse it because if I used hold-line I'm not sure
1427	1427	it would clear - to be checked */
1428		device_set_input_line(device->machine().device("maincpu"), INPUT_LINE_NMI,PULSE_LINE);
	1428	device->machine().device("maincpu")->execute().set_input_line(INPUT_LINE_NMI,PULSE_LINE);
1429	1429	}
1430	1430	}
1431	1431

trunk/src/mess/machine/cuda.c

r17814	r17815
108	108
109	109	void cuda_device::send_port(address_space &space, UINT8 offset, UINT8 data)
110	110	{
111		//    printf("PORT %c write %02x (DDR = %02x) (PC=%x)\n", 'A' + offset, data, ddrs[offset], m_maincpu->safe_pc());
	111	//    printf("PORT %c write %02x (DDR = %02x) (PC=%x)\n", 'A' + offset, data, ddrs[offset], m_maincpu->pc());
112	112
113	113	switch (offset)
114	114	{
r17814	r17815
138	138	if (treq != ((data>>1)&1))
139	139	{
140	140	#ifdef CUDA_SUPER_VERBOSE
141		printf("CU-> TREQ: %d (PC=%x)\n", (data>>1)&1, m_maincpu->safe_pc());
	141	printf("CU-> TREQ: %d (PC=%x)\n", (data>>1)&1, m_maincpu->pc());
142	142	#endif
143	143	treq = (data>>1) & 1;
144	144	}
145	145	if (via_data != ((data>>5)&1))
146	146	{
147	147	#ifdef CUDA_SUPER_VERBOSE
148		printf("CU-> VIA_DATA: %d (PC=%x)\n", (data>>5)&1, m_maincpu->safe_pc());
	148	printf("CU-> VIA_DATA: %d (PC=%x)\n", (data>>5)&1, m_maincpu->pc());
149	149	#endif
150	150	via_data = (data>>5) & 1;
151	151	}
152	152	if (via_clock != ((data>>4)&1))
153	153	{
154	154	#ifdef CUDA_SUPER_VERBOSE
155		printf("CU-> VIA_CLOCK: %d (PC=%x)\n", ((data>>4)&1)^1, m_maincpu->safe_pc());
	155	printf("CU-> VIA_CLOCK: %d (PC=%x)\n", ((data>>4)&1)^1, m_maincpu->pc());
156	156	#endif
157	157	via_clock = (data>>4) & 1;
158	158	via6522_device *via1 = machine().device<via6522_device>("via6522_0");
r17814	r17815
165	165	if ((data & 8) != reset_line)
166	166	{
167	167	#ifdef CUDA_SUPER_VERBOSE
168		printf("680x0 reset: %d -> %d (PC=%x)\n", (ports[2] & 8)>>3, (data & 8)>>3, m_maincpu->safe_pc());
	168	printf("680x0 reset: %d -> %d (PC=%x)\n", (ports[2] & 8)>>3, (data & 8)>>3, m_maincpu->pc());
169	169	#endif
170	170	reset_line = (data & 8);
171	171	// falling edge, should reset the machine too
r17814	r17815
193	193
194	194	WRITE8_MEMBER( cuda_device::ddr_w )
195	195	{
196		//    printf("%02x to PORT %c DDR (PC=%x)\n", data, 'A' + offset, m_maincpu->safe_pc());
	196	//    printf("%02x to PORT %c DDR (PC=%x)\n", data, 'A' + offset, m_maincpu->pc());
197	197
198	198	send_port(space, offset, ports[offset] & data);
199	199
r17814	r17815
251	251	incoming |= 0x01;
252	252	}
253	253
254		//    printf("PORT %c read = %02x (DDR = %02x latch = %02x) (PC=%x)\n", 'A' + offset, ports[offset], ddrs[offset], ports[offset], m_maincpu->safe_pc());
	254	//    printf("PORT %c read = %02x (DDR = %02x latch = %02x) (PC=%x)\n", 'A' + offset, ports[offset], ddrs[offset], ports[offset], m_maincpu->pc());
255	255
256	256	return incoming;
257	257	}
r17814	r17815
279	279	(data & 0x40) ? 1 : 0,
280	280	(data & 0x20) ? 1 : 0,
281	281	(data & 0x10) ? 1 : 0,
282		(data & 0x08) ? 1 : 0, m_maincpu->safe_pc());
	282	(data & 0x08) ? 1 : 0, m_maincpu->pc());
283	283	}
284	284	#endif
285	285	pll_ctrl = data;
r17814	r17815
300	300	{ attotime::from_seconds(8), attotime::from_msec(250.0f), attotime::from_msec(125.1f), attotime::from_msec(62.5f), attotime::from_msec(31.3f) },
301	301	};
302	302
303		//    printf("%02x to timer control (PC=%x)\n", data, m_maincpu->safe_pc());
	303	//    printf("%02x to timer control (PC=%x)\n", data, m_maincpu->pc());
304	304
305	305	if (data & 0x50)
306	306	{
r17814	r17815
314	314
315	315	if ((timer_ctrl & 0x80) && !(data & 0x80))
316	316	{
317		device_set_input_line(m_maincpu, M68HC05EG_INT_TIMER, CLEAR_LINE);
	317	m_maincpu->set_input_line(M68HC05EG_INT_TIMER, CLEAR_LINE);
318	318	timer_ctrl &= ~0x80;
319	319	}
320	320	else if ((timer_ctrl & 0x40) && !(data & 0x40))
321	321	{
322		device_set_input_line(m_maincpu, M68HC05EG_INT_TIMER, CLEAR_LINE);
	322	m_maincpu->set_input_line(M68HC05EG_INT_TIMER, CLEAR_LINE);
323	323	timer_ctrl &= ~0x40;
324	324	}
325	325
r17814	r17815
334	334
335	335	WRITE8_MEMBER( cuda_device::timer_counter_w )
336	336	{
337		//    printf("%02x to timer counter (PC=%x)\n", data, m_maincpu->safe_pc());
	337	//    printf("%02x to timer counter (PC=%x)\n", data, m_maincpu->pc());
338	338	timer_counter = data;
339	339	ripple_counter = timer_counter;
340	340	}
r17814	r17815
350	350
351	351	if ((onesec & 0x40) && !(data & 0x40))
352	352	{
353		device_set_input_line(m_maincpu, M68HC05EG_INT_CPI, CLEAR_LINE);
	353	m_maincpu->set_input_line(M68HC05EG_INT_CPI, CLEAR_LINE);
354	354	}
355	355
356	356	onesec = data;
r17814	r17815
464	464
465	465	if (onesec & 0x10)
466	466	{
467		device_set_input_line(m_maincpu, M68HC05EG_INT_CPI, ASSERT_LINE);
	467	m_maincpu->set_input_line(M68HC05EG_INT_CPI, ASSERT_LINE);
468	468	}
469	469	}
470	470	else
r17814	r17815
473	473
474	474	if (timer_ctrl & 0x20)
475	475	{
476		device_set_input_line(m_maincpu, M68HC05EG_INT_TIMER, ASSERT_LINE);
	476	m_maincpu->set_input_line(M68HC05EG_INT_TIMER, ASSERT_LINE);
477	477	}
478	478
479	479	ripple_counter--;
r17814	r17815
485	485
486	486	if (timer_ctrl & 0x10)
487	487	{
488		device_set_input_line(m_maincpu, M68HC05EG_INT_TIMER, ASSERT_LINE);
	488	m_maincpu->set_input_line(M68HC05EG_INT_TIMER, ASSERT_LINE);
489	489	}
490	490	}
491	491	}

trunk/src/mess/machine/macpci.c

r17814	r17815
101	101	printf("mac_via_r: offset=0x%02x (PC=%x)\n", offset, m_maincpu->pc());
102	102	data = m_via1->read(space, offset);
103	103
104		device_adjust_icount(m_maincpu, m_via_cycles);
	104	m_maincpu->adjust_icount(m_via_cycles);
105	105
106	106	return data | (data<<8);
107	107	}
r17814	r17815
119	119	if (ACCESSING_BITS_8_15)
120	120	m_via1->write(space, offset, (data >> 8) & 0xff);
121	121
122		device_adjust_icount(m_maincpu, m_via_cycles);
	122	m_maincpu->adjust_icount(m_via_cycles);
123	123	}
124	124
125	125	static READ8_DEVICE_HANDLER(mac_adb_via_in_cb2)

trunk/src/mess/machine/mc80.c

r17814	r17815
20	20
21	21	MACHINE_RESET( mc8020 )
22	22	{
23		device_set_irq_callback(machine.device("maincpu"), mc8020_irq_callback);
	23	machine.device("maincpu")->execute().set_irq_acknowledge_callback(mc8020_irq_callback);
24	24	}
25	25
26	26	WRITE_LINE_MEMBER( mc80_state::ctc_z0_w )
r17814	r17815
114	114
115	115	MACHINE_RESET( mc8030 )
116	116	{
117		device_set_irq_callback(machine.device("maincpu"), mc8030_irq_callback);
	117	machine.device("maincpu")->execute().set_irq_acknowledge_callback(mc8030_irq_callback);
118	118	}
119	119
120	120	READ8_MEMBER( mc80_state::zve_port_a_r )

trunk/src/mess/machine/ti99/speech8.c

r17814	r17815
72	72	{
73	73	if ((offset & m_select_mask)==m_select_value)
74	74	{
75		device_adjust_icount(machine().device("maincpu"),-(18+3));      /* this is just a minimum, it can be more */
	75	machine().device("maincpu")->execute().adjust_icount(-(18+3));      /* this is just a minimum, it can be more */
76	76	*value = m_vsp->read(space, offset, 0xff) & 0xff;
77	77	if (VERBOSE>4) LOG("speech8: read value = %02x\n", *value);
78	78	}
r17814	r17815
85	85	{
86	86	if ((offset & m_select_mask)==(m_select_value | 0x0400))
87	87	{
88		device_adjust_icount(machine().device("maincpu"),-(54+3));      /* this is just an approx. minimum, it can be much more */
	88	machine().device("maincpu")->execute().adjust_icount(-(54+3));      /* this is just an approx. minimum, it can be much more */
89	89
90	90	/* RN: the stupid design of the tms5220 core means that ready is cleared */
91	91	/* when there are 15 bytes in FIFO.  It should be 16.  Of course, if */
r17814	r17815
97	97	int cycles_to_ready = machine().device<cpu_device>("maincpu")->attotime_to_cycles(time_to_ready);
98	98	if (VERBOSE>8) LOG("speech8: time to ready: %f -> %d\n", time_to_ready.as_double(), (int) cycles_to_ready);
99	99
100		device_adjust_icount(machine().device("maincpu"),-cycles_to_ready);
	100	machine().device("maincpu")->execute().adjust_icount(-cycles_to_ready);
101	101	machine().scheduler().timer_set(attotime::zero, FUNC_NULL);
102	102	}
103	103	if (VERBOSE>4) LOG("speech8: write value = %02x\n", data);

trunk/src/mess/machine/ti99/spchsyn.c

r17814	r17815
108	108	{
109	109	if ((offset & m_select_mask)==m_select_value)
110	110	{
111		device_adjust_icount(machine().device("maincpu"),-(18+3));      /* this is just a minimum, it can be more */
	111	machine().device("maincpu")->execute().adjust_icount(-(18+3));      /* this is just a minimum, it can be more */
112	112	*value = m_vsp->read(space, offset, 0xff) & 0xff;
113	113	if (VERBOSE>4) LOG("spchsyn: read value = %02x\n", *value);
114	114	}
r17814	r17815
121	121	{
122	122	if ((offset & m_select_mask)==(m_select_value | 0x0400))
123	123	{
124		device_adjust_icount(machine().device("maincpu"),-(54+3));      /* this is just an approx. minimum, it can be much more */
	124	machine().device("maincpu")->execute().adjust_icount(-(54+3));      /* this is just an approx. minimum, it can be much more */
125	125
126	126	/* RN: the stupid design of the tms5220 core means that ready is cleared */
127	127	/* when there are 15 bytes in FIFO.  It should be 16.  Of course, if */
r17814	r17815
133	133	int cycles_to_ready = machine().device<cpu_device>("maincpu")->attotime_to_cycles(time_to_ready);
134	134	if (VERBOSE>8) LOG("spchsyn: time to ready: %f -> %d\n", time_to_ready.as_double(), (int) cycles_to_ready);
135	135
136		device_adjust_icount(machine().device("maincpu"),-cycles_to_ready);
	136	machine().device("maincpu")->execute().adjust_icount(-cycles_to_ready);
137	137	machine().scheduler().timer_set(attotime::zero, FUNC_NULL);
138	138	}
139	139	if (VERBOSE>4) LOG("spchsyn: write value = %02x\n", data);

trunk/src/mess/machine/a2themill.c

r17814	r17815
108	108	m_flipAddrSpace = false;
109	109	m_6809Mode = false;
110	110	m_status = 0xc0;    // OS9 loader relies on this
111		device_set_input_line(m_6809, INPUT_LINE_HALT, ASSERT_LINE);
112		device_set_input_line(m_6809, INPUT_LINE_RESET, ASSERT_LINE);
	111	m_6809->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
	112	m_6809->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
113	113	}
114	114
115	115	UINT8 a2bus_themill_device::read_c0nx(address_space &space, UINT8 offset)
r17814	r17815
141	141	m_6502space = &space;
142	142	m_6809->reset();
143	143
144		device_set_input_line(m_6809, INPUT_LINE_HALT, CLEAR_LINE);
145		device_set_input_line(m_6809, INPUT_LINE_RESET, CLEAR_LINE);
	144	m_6809->set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
	145	m_6809->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
146	146
147	147	m_bEnabled = true;
148	148	m_status &= ~0x04;
149	149	}
150	150	else
151	151	{
152		device_set_input_line(m_6809, INPUT_LINE_HALT, ASSERT_LINE);
	152	m_6809->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
153	153	m_bEnabled = false;
154	154	m_status |= 0x04;
155	155	}
r17814	r17815
170	170	case 3: // 6809 NMI
171	171	if (data & 0x80)
172	172	{
173		device_set_input_line(m_6809, INPUT_LINE_NMI, CLEAR_LINE);
	173	m_6809->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
174	174	m_status |= 0x08;
175	175	}
176	176	else
177	177	{
178		device_set_input_line(m_6809, INPUT_LINE_NMI, ASSERT_LINE);
	178	m_6809->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
179	179	m_status &= ~0x08;
180	180	}
181	181	break;
r17814	r17815
183	183	case 4: // 6809 FIRQ
184	184	if (data & 0x80)
185	185	{
186		device_set_input_line(m_6809, M6809_FIRQ_LINE, CLEAR_LINE);
	186	m_6809->set_input_line(M6809_FIRQ_LINE, CLEAR_LINE);
187	187	m_status |= 0x10;
188	188	}
189	189	else
190	190	{
191		device_set_input_line(m_6809, M6809_FIRQ_LINE, ASSERT_LINE);
	191	m_6809->set_input_line(M6809_FIRQ_LINE, ASSERT_LINE);
192	192	m_status &= ~0x10;
193	193	}
194	194	break;
r17814	r17815
196	196	case 5: // 6809 IRQ
197	197	if (data & 0x80)
198	198	{
199		device_set_input_line(m_6809, M6809_IRQ_LINE, CLEAR_LINE);
	199	m_6809->set_input_line(M6809_IRQ_LINE, CLEAR_LINE);
200	200	m_status |= 0x20;
201	201	}
202	202	else
203	203	{
204		device_set_input_line(m_6809, M6809_IRQ_LINE, ASSERT_LINE);
	204	m_6809->set_input_line(M6809_IRQ_LINE, ASSERT_LINE);
205	205	m_status &= ~0x20;
206	206	}
207	207	break;

trunk/src/mess/machine/ecbbus.c

r17814	r17815
144	144
145	145	void ecbbus_device::device_start()
146	146	{
147		m_maincpu = machine().device(m_cputag);
	147	m_maincpu = machine().device<cpu_device>(m_cputag);
148	148
149	149	// resolve callbacks
150	150	m_out_int_func.resolve(m_out_int_cb, *this);

trunk/src/mess/machine/ecbbus.h

r17814	r17815
123	123
124	124	private:
125	125	// internal state
126		device_t   *m_maincpu;
	126	cpu_device   *m_maincpu;
127	127
128	128	devcb_resolved_write_line   m_out_int_func;
129	129	devcb_resolved_write_line   m_out_nmi_func;

trunk/src/mess/machine/advision.c

r17814	r17815
40	40	void advision_state::machine_reset()
41	41	{
42	42	/* enable internal ROM */
43		device_set_input_line(m_maincpu, MCS48_INPUT_EA, CLEAR_LINE);
	43	m_maincpu->set_input_line(MCS48_INPUT_EA, CLEAR_LINE);
44	44	membank("bank1")->set_entry(0);
45	45
46	46	/* reset sound CPU */
47		device_set_input_line(m_soundcpu, INPUT_LINE_RESET, ASSERT_LINE);
	47	m_soundcpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
48	48
49	49	m_rambank = 0x300;
50	50	m_frame_start = 0;
r17814	r17815
58	58	{
59	59	int ea = BIT(data, 2);
60	60
61		device_set_input_line(m_maincpu, MCS48_INPUT_EA, ea ? ASSERT_LINE : CLEAR_LINE);
	61	m_maincpu->set_input_line(MCS48_INPUT_EA, ea ? ASSERT_LINE : CLEAR_LINE);
62	62
63	63	membank("bank1")->set_entry(ea);
64	64
r17814	r17815
79	79
80	80	if (m_video_bank == 0x06)
81	81	{
82		device_set_input_line(m_soundcpu, INPUT_LINE_RESET, (data & 0x01) ? CLEAR_LINE : ASSERT_LINE);
	82	m_soundcpu->set_input_line(INPUT_LINE_RESET, (data & 0x01) ? CLEAR_LINE : ASSERT_LINE);
83	83	}
84	84
85	85	return data;

trunk/src/mess/machine/b2m.c

r17814	r17815
372	372	state->m_b2m_side = 0;
373	373	state->m_b2m_drive = 0;
374	374
375		device_set_irq_callback(machine.device("maincpu"), b2m_irq_callback);
	375	machine.device("maincpu")->execute().set_irq_acknowledge_callback(b2m_irq_callback);
376	376	b2m_set_bank(machine, 7);
377	377	}

trunk/src/mess/machine/pet.c

r17814	r17815
198	198	driver_state->m_pia0_irq = state;
199	199	int level = (driver_state->m_pia0_irq | driver_state->m_pia1_irq | driver_state->m_via_irq) ? ASSERT_LINE : CLEAR_LINE;
200	200
201		device_set_input_line(device->machine().firstcpu, INPUT_LINE_IRQ0, level);
	201	device->machine().firstcpu->set_input_line(INPUT_LINE_IRQ0, level);
202	202	}
203	203
204	204	const pia6821_interface pet_pia0 =
r17814	r17815
249	249	driver_state->m_pia1_irq = state;
250	250	int level = (driver_state->m_pia0_irq | driver_state->m_pia1_irq | driver_state->m_via_irq) ? ASSERT_LINE : CLEAR_LINE;
251	251
252		device_set_input_line(device->machine().firstcpu, INPUT_LINE_IRQ0, level);
	252	device->machine().firstcpu->set_input_line(INPUT_LINE_IRQ0, level);
253	253	}
254	254
255	255	const pia6821_interface pet_pia1 =
r17814	r17815
382	382	driver_state->m_via_irq = state;
383	383	int level = (driver_state->m_pia0_irq | driver_state->m_pia1_irq | driver_state->m_via_irq) ? ASSERT_LINE : CLEAR_LINE;
384	384
385		device_set_input_line(device->machine().firstcpu, INPUT_LINE_IRQ0, level);
	385	device->machine().firstcpu->set_input_line(INPUT_LINE_IRQ0, level);
386	386	}
387	387
388	388	const via6522_interface pet_via =
r17814	r17815
770	770	{
771	771	if (state->ioport("CFG")->read() & 0x04)
772	772	{
773		device_set_input_line(device, INPUT_LINE_HALT, 1);
774		device_set_input_line(device, INPUT_LINE_HALT, 0);
	773	device->execute().set_input_line(INPUT_LINE_HALT, 1);
	774	device->execute().set_input_line(INPUT_LINE_HALT, 0);
775	775	state->m_font |= 2;
776	776	}
777	777	else
778	778	{
779		device_set_input_line(device, INPUT_LINE_HALT, 0);
780		device_set_input_line(device, INPUT_LINE_HALT, 1);
	779	device->execute().set_input_line(INPUT_LINE_HALT, 0);
	780	device->execute().set_input_line(INPUT_LINE_HALT, 1);
781	781	state->m_font &= ~2;
782	782	}
783	783	}

trunk/src/mess/machine/genpc.c

r17814	r17815
60	60
61	61	WRITE_LINE_MEMBER( ibm5160_mb_device::pc_dma_hrq_changed )
62	62	{
63		device_set_input_line(m_maincpu, INPUT_LINE_HALT, state ? ASSERT_LINE : CLEAR_LINE);
	63	m_maincpu->set_input_line(INPUT_LINE_HALT, state ? ASSERT_LINE : CLEAR_LINE);
64	64
65	65	/* Assert HLDA */
66	66	m_dma8237->hack_w(state);
r17814	r17815
665	665
666	666	void ibm5160_mb_device::device_reset()
667	667	{
668		device_set_irq_callback(m_maincpu, pc_irq_callback);
	668	m_maincpu->set_irq_acknowledge_callback(pc_irq_callback);
669	669
670	670	m_u73_q2 = 0;
671	671	m_out1 = 2; // initial state of pit output is undefined

trunk/src/mess/machine/vector06.c

r17814	r17815
127	127	vector06_state *state = device->machine().driver_data<vector06_state>();
128	128	state->m_vblank_state++;
129	129	if (state->m_vblank_state>1) state->m_vblank_state=0;
130		device_set_input_line(device,0,state->m_vblank_state ? HOLD_LINE : CLEAR_LINE);
	130	device->execute().set_input_line(0,state->m_vblank_state ? HOLD_LINE : CLEAR_LINE);
131	131
132	132	}
133	133
r17814	r17815
173	173	vector06_state *state = machine.driver_data<vector06_state>();
174	174	address_space *space = machine.device("maincpu")->memory().space(AS_PROGRAM);
175	175
176		device_set_irq_callback(machine.device("maincpu"), vector06_irq_callback);
	176	machine.device("maincpu")->execute().set_irq_acknowledge_callback(vector06_irq_callback);
177	177	space->install_read_bank (0x0000, 0x7fff, "bank1");
178	178	space->install_write_bank(0x0000, 0x7fff, "bank2");
179	179	space->install_read_bank (0x8000, 0xffff, "bank3");

trunk/src/mess/machine/kb_keytro.c

r17814	r17815
468	468
469	469	WRITE_LINE_MEMBER( pc_kbd_keytronic_pc3270_device::clock_write )
470	470	{
471		device_set_input_line( m_cpu, MCS51_INT0_LINE, state );
	471	m_cpu->set_input_line(MCS51_INT0_LINE, state );
472	472	}
473	473
474	474
475	475	WRITE_LINE_MEMBER( pc_kbd_keytronic_pc3270_device::data_write )
476	476	{
477		device_set_input_line( m_cpu, MCS51_T0_LINE, state);
	477	m_cpu->set_input_line(MCS51_T0_LINE, state);
478	478	}
479	479
480	480

trunk/src/mess/machine/bk.c

r17814	r17815
74	74	static IRQ_CALLBACK(bk0010_irq_callback)
75	75	{
76	76	bk_state *state = device->machine().driver_data<bk_state>();
77		device_set_input_line(device, 0, CLEAR_LINE);
	77	device->execute().set_input_line(0, CLEAR_LINE);
78	78	return state->m_key_irq_vector;
79	79	}
80	80
81	81	MACHINE_RESET( bk0010 )
82	82	{
83	83	bk_state *state = machine.driver_data<bk_state>();
84		device_set_irq_callback(machine.device("maincpu"), bk0010_irq_callback);
	84	machine.device("maincpu")->execute().set_irq_acknowledge_callback(bk0010_irq_callback);
85	85
86	86	state->m_kbd_state = 0;
87	87	state->m_scrool = 01330;

trunk/src/mess/machine/amigacrt.c

r17814	r17815
166	166	amigacrt.ar1_spurious = 0;
167	167
168	168	/* Install IRQ ACK callback */
169		device_set_irq_callback(machine.device("maincpu"), amiga_ar1_irqack);
	169	machine.device("maincpu")->execute().set_irq_acknowledge_callback(amiga_ar1_irqack);
170	170	}
171	171
172	172	/***************************************************************************

trunk/src/mess/machine/amstrad.c

r17814	r17815
1446	1446	if ( m_asic.enabled )
1447	1447	{
1448	1448	vector = (data & 0xf8) + (m_plus_irq_cause);
1449		device_set_input_line_vector(m_maincpu, 0, vector);
	1449	m_maincpu->set_input_line_vector(0, vector);
1450	1450	logerror("ASIC: IM 2 vector write %02x, data = &%02x\n",vector,data);
1451	1451	}
1452	1452	m_asic.dma_clear = data & 0x01;
r17814	r17815
2888	2888
2889	2889	state->m_maincpu->reset();
2890	2890	if ( state->m_system_type == SYSTEM_CPC || state->m_system_type == SYSTEM_ALESTE )
2891		device_set_input_line_vector(state->m_maincpu, 0, 0xff);
	2891	state->m_maincpu->set_input_line_vector(0, 0xff);
2892	2892	else
2893		device_set_input_line_vector(state->m_maincpu, 0, 0x00);
	2893	state->m_maincpu->set_input_line_vector(0, 0x00);
2894	2894
2895	2895	/* The opcode timing in the Amstrad is different to the opcode
2896	2896	timing in the core for the Z80 CPU.
r17814	r17815
2911	2911	(const UINT8*)amstrad_cycle_table_ex);
2912	2912
2913	2913	/* Juergen is a cool dude! */
2914		device_set_irq_callback(state->m_maincpu, amstrad_cpu_acknowledge_int);
	2914	state->m_maincpu->set_irq_acknowledge_callback(amstrad_cpu_acknowledge_int);
2915	2915	}
2916	2916
2917	2917	static TIMER_CALLBACK( cb_set_resolution )

trunk/src/mess/machine/sms.c

r17814	r17815
2104	2104	WRITE_LINE_DEVICE_HANDLER( sms_store_int_callback )
2105	2105	{
2106	2106	sms_state *driver_state = device->machine().driver_data<sms_state>();
2107		device_set_input_line(driver_state->m_store_control & 0x01 ? driver_state->m_control_cpu : driver_state->m_main_cpu, 0, state);
	2107	(driver_state->m_store_control & 0x01 ? driver_state->m_control_cpu : driver_state->m_main_cpu)->execute().set_input_line(0, state);
2108	2108	}
2109	2109
2110	2110

trunk/src/mess/machine/nes_pcb.c

r17814	r17815
1292	1292	{
1293	1293	LOG_MMC(("irq fired, scanline: %d (MAME %d, beam pos: %d)\n", scanline,
1294	1294	device->machine().primary_screen->vpos(), device->machine().primary_screen->hpos()));
1295		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	1295	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
1296	1296	}
1297	1297	}
1298	1298	state->m_IRQ_clear = 0;
r17814	r17815
1822	1822	if (scanline == state->m_IRQ_count)
1823	1823	{
1824	1824	if (state->m_IRQ_enable)
1825		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	1825	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
1826	1826
1827	1827	state->m_IRQ_status = 0xff;
1828	1828	}
r17814	r17815
2461	2461	if (state->m_IRQ_count <= 114)
2462	2462	{
2463	2463	state->m_IRQ_count = 0xffff;
2464		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	2464	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
2465	2465	}
2466	2466	else
2467	2467	state->m_IRQ_count -= 114;
r17814	r17815
2834	2834	{
2835	2835	if (state->m_IRQ_count <= 114)
2836	2836	{
2837		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	2837	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
2838	2838	state->m_IRQ_count = (0xffff - 114 + state->m_IRQ_count);   // wrap around the 16 bits counter
2839	2839	}
2840	2840	state->m_IRQ_count -= 114;
r17814	r17815
3092	3092	if (state->m_IRQ_count <= 114)
3093	3093	{
3094	3094	state->m_IRQ_enable = 0;
3095		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	3095	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
3096	3096	}
3097	3097	}
3098	3098	}
r17814	r17815
3175	3175	{
3176	3176	if ((state->m_IRQ_count & 0x000f) < 114)   // always true, but we only update the IRQ once per scanlines so we cannot be more precise :(
3177	3177	{
3178		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	3178	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
3179	3179	state->m_IRQ_count = (state->m_IRQ_count & ~0x000f) | (0x0f - (114 & 0x0f) + (state->m_IRQ_count & 0x000f)); // sort of wrap around the counter
3180	3180	}
3181	3181	// decrements should not affect upper bits, so we don't do anything here (114 > 0x0f)
r17814	r17815
3184	3184	{
3185	3185	if ((state->m_IRQ_count & 0x00ff) < 114)
3186	3186	{
3187		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	3187	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
3188	3188	state->m_IRQ_count = (state->m_IRQ_count & ~0x00ff) | (0xff - 114 + (state->m_IRQ_count & 0x00ff));   // wrap around the 8 bits counter
3189	3189	}
3190	3190	else
r17814	r17815
3194	3194	{
3195	3195	if ((state->m_IRQ_count & 0x0fff)  < 114)
3196	3196	{
3197		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	3197	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
3198	3198	state->m_IRQ_count = (state->m_IRQ_count & ~0x0fff) | (0xfff - 114 + (state->m_IRQ_count & 0x0fff));   // wrap around the 12 bits counter
3199	3199	}
3200	3200	else
r17814	r17815
3202	3202	}
3203	3203	else if (state->m_IRQ_count < 114)
3204	3204	{
3205		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	3205	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
3206	3206	state->m_IRQ_count = (0xffff - 114 + state->m_IRQ_count);   // wrap around the 16 bits counter
3207	3207	}
3208	3208	else
r17814	r17815
3586	3586	{
3587	3587	state->m_IRQ_count = state->m_IRQ_count_latch;
3588	3588	state->m_IRQ_enable = state->m_IRQ_enable_latch;
3589		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	3589	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
3590	3590	}
3591	3591	}
3592	3592
r17814	r17815
3855	3855	{
3856	3856	if (state->m_IRQ_count >= (0x7fff - 114))
3857	3857	{
3858		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	3858	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
3859	3859	state->m_IRQ_count = 0;
3860	3860	}
3861	3861	else
r17814	r17815
4028	4028	{
4029	4029	state->m_IRQ_enable = 0;
4030	4030	state->m_IRQ_count = 0xffff;
4031		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	4031	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
4032	4032	}
4033	4033	else
4034	4034	state->m_IRQ_count -= 114;
r17814	r17815
5100	5100	{
5101	5101	state->m_IRQ_count--;
5102	5102	if (!state->m_IRQ_count)
5103		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	5103	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
5104	5104	}
5105	5105	}
5106	5106	}
r17814	r17815
5481	5481	{
5482	5482	state->m_IRQ_enable = 0;
5483	5483	state->m_IRQ_count = state->m_IRQ_count_latch;
5484		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	5484	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
5485	5485	}
5486	5486	else
5487	5487	state->m_IRQ_count += 114;
r17814	r17815
5594	5594	{
5595	5595	if (state->m_IRQ_count <= 114)
5596	5596	{
5597		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	5597	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
5598	5598	state->m_IRQ_enable = 0;
5599	5599	state->m_IRQ_status |= 0x01;
5600	5600	}
r17814	r17815
7226	7226	{
7227	7227	LOG_MMC(("irq fired, scanline: %d (MAME %d, beam pos: %d)\n", scanline,
7228	7228	device->machine().primary_screen->vpos(), device->machine().primary_screen->hpos()));
7229		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	7229	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
7230	7230	}
7231	7231	}
7232	7232	}
r17814	r17815
7253	7253	{
7254	7254	LOG_MMC(("irq fired, scanline: %d (MAME %d, beam pos: %d)\n", scanline,
7255	7255	device->machine().primary_screen->vpos(), device->machine().primary_screen->hpos()));
7256		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	7256	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
7257	7257	}
7258	7258	}
7259	7259	}
r17814	r17815
8936	8936	{
8937	8937	LOG_MMC(("irq fired, scanline: %d (MAME %d, beam pos: %d)\n", scanline,
8938	8938	device->machine().primary_screen->vpos(), device->machine().primary_screen->hpos()));
8939		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	8939	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
8940	8940	state->m_IRQ_enable = 0;
8941	8941	}
8942	8942	}
r17814	r17815
9075	9075	if (state->m_IRQ_count < 0x1000)
9076	9076	{
9077	9077	if ((0x1000 - state->m_IRQ_count) <= 114)
9078		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	9078	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
9079	9079	else
9080	9080	state->m_IRQ_count += 114;
9081	9081	}
r17814	r17815
9361	9361	{
9362	9362	state->m_IRQ_count = (state->m_IRQ_count + 1) & 0xfff;
9363	9363	state->m_IRQ_enable = 0;
9364		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	9364	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
9365	9365	}
9366	9366	else
9367	9367	state->m_IRQ_count += 114;
r17814	r17815
9447	9447	{
9448	9448	if ((0xffff - state->m_IRQ_count) < 114)
9449	9449	{
9450		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	9450	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
9451	9451	state->m_IRQ_enable = 0;
9452	9452	}
9453	9453
r17814	r17815
9526	9526	state->m_IRQ_count = 0;
9527	9527	LOG_MMC(("irq fired, scanline: %d (MAME %d, beam pos: %d)\n", scanline,
9528	9528	device->machine().primary_screen->vpos(), device->machine().primary_screen->hpos()));
9529		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	9529	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
9530	9530	}
9531	9531	}
9532	9532
r17814	r17815
11408	11408	{
11409	11409	state->m_IRQ_count = state->m_IRQ_count_latch;
11410	11410	state->m_IRQ_enable = state->m_IRQ_enable | ((state->m_IRQ_enable & 0x01) << 1);
11411		device_set_input_line(state->m_maincpu, M6502_IRQ_LINE, HOLD_LINE);
	11411	state->m_maincpu->set_input_line(M6502_IRQ_LINE, HOLD_LINE);
11412	11412	}
11413	11413	else
11414	11414	state->m_IRQ_count++;

trunk/src/mess/machine/kc_d004.c

r17814	r17815
245	245	switch(id)
246	246	{
247	247	case TIMER_RESET:
248		device_set_input_line(m_cpu, INPUT_LINE_RESET, ASSERT_LINE);
	248	m_cpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
249	249	break;
250	250	case TIMER_TC_CLEAR:
251	251	upd765_tc_w(m_fdc, 0x00);
r17814	r17815
331	331	break;
332	332	case 0xf4:
333	333	if (data & 0x01)
334		device_set_input_line(m_cpu, INPUT_LINE_RESET, CLEAR_LINE);
	334	m_cpu->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
335	335
336	336	if (data & 0x02)
337	337	{
338	338	for (int i=0; i<0xfc00; i++)
339	339	m_cpu->space(AS_PROGRAM)->write_byte(i, 0);
340	340
341		device_set_input_line(m_cpu, INPUT_LINE_RESET, ASSERT_LINE);
	341	m_cpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
342	342	}
343	343
344	344	if (data & 0x04)
345		device_set_input_line(m_cpu, INPUT_LINE_RESET, HOLD_LINE);
	345	m_cpu->set_input_line(INPUT_LINE_RESET, HOLD_LINE);
346	346
347	347	if (data & 0x08)
348		device_set_input_line(m_cpu, INPUT_LINE_NMI, HOLD_LINE);
	348	m_cpu->set_input_line(INPUT_LINE_NMI, HOLD_LINE);
349	349
350	350	//printf("D004 CPU state: %x\n", data & 0x0f);
351	351	break;

trunk/src/mess/machine/ti85.c

r17814	r17815
22	22	{
23	23	if (state->m_ON_interrupt_mask && !state->m_ON_pressed)
24	24	{
25		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	25	state->m_maincpu->set_input_line(0, HOLD_LINE);
26	26	state->m_ON_interrupt_status = 1;
27	27	if (!state->m_timer_interrupt_mask) state->m_timer_interrupt_mask = 1;
28	28	}
r17814	r17815
33	33	state->m_ON_pressed = 0;
34	34	if (state->m_timer_interrupt_mask)
35	35	{
36		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	36	state->m_maincpu->set_input_line(0, HOLD_LINE);
37	37	state->m_timer_interrupt_status = 1;
38	38	}
39	39	}
r17814	r17815
604	604
605	605	state->m_maincpu->set_state_int(Z80_R, (reg[0x44]&0x7f) | (reg[0x48]&0x80));
606	606
607		device_set_input_line(state->m_maincpu, 0, 0);
608		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, 0);
609		device_set_input_line(state->m_maincpu, INPUT_LINE_HALT, 0);
	607	state->m_maincpu->set_input_line(0, 0);
	608	state->m_maincpu->set_input_line(INPUT_LINE_NMI, 0);
	609	state->m_maincpu->set_input_line(INPUT_LINE_HALT, 0);
610	610	}
611	611
612	612	static void ti85_setup_snapshot (running_machine &machine, UINT8 * data)

trunk/src/mess/machine/galaxy.c

r17814	r17815
47	47
48	48	INTERRUPT_GEN( galaxy_interrupt )
49	49	{
50		device_set_input_line(device, 0, HOLD_LINE);
	50	device->execute().set_input_line(0, HOLD_LINE);
51	51	}
52	52
53	53	static IRQ_CALLBACK ( galaxy_irq_callback )
r17814	r17815
123	123	break;
124	124	}
125	125
126		device_set_input_line(cpu, INPUT_LINE_NMI, CLEAR_LINE);
127		device_set_input_line(cpu, INPUT_LINE_IRQ0, CLEAR_LINE);
	126	cpu->execute().set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
	127	cpu->execute().set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
128	128	}
129	129
130	130	SNAPSHOT_LOAD( galaxy )
r17814	r17815
185	185	if (machine.root_device().ioport("ROM2")->read())
186	186	state->membank("bank10")->set_base(machine.root_device().memregion("maincpu")->base() + 0x1000);
187	187
188		device_set_irq_callback(machine.device("maincpu"), galaxy_irq_callback);
	188	machine.device("maincpu")->execute().set_irq_acknowledge_callback(galaxy_irq_callback);
189	189	state->m_interrupts_enabled = TRUE;
190	190	}
191	191
r17814	r17815
200	200	UINT8 *ROM = machine.root_device().memregion("maincpu")->base();
201	201	address_space *space = machine.device("maincpu")->memory().space(AS_PROGRAM);
202	202
203		device_set_irq_callback(machine.device("maincpu"), galaxy_irq_callback);
	203	machine.device("maincpu")->execute().set_irq_acknowledge_callback(galaxy_irq_callback);
204	204
205	205	ROM[0x0037] = 0x29;
206	206	ROM[0x03f9] = 0xcd;

trunk/src/mess/machine/compis.c

r17814	r17815
414	414	logerror("(%f) **** Acknowledged interrupt vector %02X\n", device->machine().time().as_double(), state->m_i186.intr.poll_status & 0x1f);
415	415
416	416	/* clear the interrupt */
417		device_set_input_line(device, 0, CLEAR_LINE);
	417	device->execute().set_input_line(0, CLEAR_LINE);
418	418	state->m_i186.intr.pending = 0;
419	419
420	420	/* clear the request and set the in-service bit */
r17814	r17815
1216	1216	/* we need to do this at a time when the I86 context is swapped in */
1217	1217	/* this register is generally set once at startup and never again, so it's a good */
1218	1218	/* time to set it up */
1219		device_set_irq_callback(m_maincpu, int_callback);
	1219	m_maincpu->set_irq_acknowledge_callback(int_callback);
1220	1220	break;
1221	1221
1222	1222	case 0x60:
r17814	r17815
1367	1367	DRIVER_INIT_MEMBER(compis_state,compis)
1368	1368	{
1369	1369
1370		device_set_irq_callback(machine().device("maincpu"), compis_irq_callback);
	1370	machine().device("maincpu")->execute().set_irq_acknowledge_callback(compis_irq_callback);
1371	1371	memset (&m_compis, 0, sizeof (m_compis) );
1372	1372	}
1373	1373
r17814	r17815
1390	1390	compis_keyb_init(state);
1391	1391
1392	1392	/* OSP PIC 8259 */
1393		device_set_irq_callback(state->m_maincpu, compis_irq_callback);
	1393	state->m_maincpu->set_irq_acknowledge_callback(compis_irq_callback);
1394	1394	}
1395	1395
1396	1396	/*-------------------------------------------------------------------------*/

trunk/src/mess/machine/zx.c

r17814	r17815
388	388	zx_ula_bkgnd(1);
389	389	if (m_ula_frame_vsync == 2)
390	390	{
391		device_spin_until_time(&mem->device(),machine().primary_screen->time_until_pos(height - 1, 0));
	391	mem->device().execute().spin_until_time(machine().primary_screen->time_until_pos(height - 1, 0));
392	392	m_ula_scanline_count = height - 1;
393	393	logerror ("S: %d B: %d\n", machine().primary_screen->vpos(), machine().primary_screen->hpos());
394	394	}

trunk/src/mess/machine/abc99.c

r17814	r17815
239	239
240	240	INPUT_CHANGED_MEMBER( abc99_device::keyboard_reset )
241	241	{
242		device_set_input_line(m_mousecpu, INPUT_LINE_RESET, newval ? CLEAR_LINE : ASSERT_LINE);
	242	m_mousecpu->set_input_line(INPUT_LINE_RESET, newval ? CLEAR_LINE : ASSERT_LINE);
243	243	}
244	244
245	245
r17814	r17815
459	459
460	460	inline void abc99_device::serial_input()
461	461	{
462		device_set_input_line(m_maincpu, MCS48_INPUT_IRQ, (m_si | m_si_en) ? CLEAR_LINE : ASSERT_LINE);
463		device_set_input_line(m_mousecpu, MCS48_INPUT_IRQ, m_si ? CLEAR_LINE : ASSERT_LINE);
	462	m_maincpu->set_input_line(MCS48_INPUT_IRQ, (m_si | m_si_en) ? CLEAR_LINE : ASSERT_LINE);
	463	m_mousecpu->set_input_line(MCS48_INPUT_IRQ, m_si ? CLEAR_LINE : ASSERT_LINE);
464	464	}
465	465
466	466
r17814	r17815
578	578	void abc99_device::device_reset()
579	579	{
580	580	// set EA lines
581		device_set_input_line(m_maincpu, MCS48_INPUT_EA, ASSERT_LINE);
582		device_set_input_line(m_mousecpu, MCS48_INPUT_EA, ASSERT_LINE);
	581	m_maincpu->set_input_line(MCS48_INPUT_EA, ASSERT_LINE);
	582	m_mousecpu->set_input_line(MCS48_INPUT_EA, ASSERT_LINE);
583	583	}
584	584
585	585
r17814	r17815
786	786	if (m_reset != reset)
787	787	{
788	788	m_reset = reset;
789		device_set_input_line(m_maincpu, INPUT_LINE_RESET, m_reset ? CLEAR_LINE : ASSERT_LINE);
	789	m_maincpu->set_input_line(INPUT_LINE_RESET, m_reset ? CLEAR_LINE : ASSERT_LINE);
790	790	}
791	791
792	792	// serial output
r17814	r17815
854	854
855	855	WRITE_LINE_MEMBER( abc99_device::reset_w )
856	856	{
857		device_set_input_line(m_mousecpu, INPUT_LINE_RESET, state ? CLEAR_LINE : ASSERT_LINE);
	857	m_mousecpu->set_input_line(INPUT_LINE_RESET, state ? CLEAR_LINE : ASSERT_LINE);
858	858	}

trunk/src/mess/machine/mac.c

r17814	r17815
1568	1568	logerror("mac_via_r: offset=0x%02x\n", offset);
1569	1569	data = m_via1->read(space, offset);
1570	1570
1571		device_adjust_icount(m_maincpu, m_via_cycles);
	1571	m_maincpu->adjust_icount(m_via_cycles);
1572	1572
1573	1573	return (data & 0xff) | (data << 8);
1574	1574	}
r17814	r17815
1586	1586	if (ACCESSING_BITS_8_15)
1587	1587	m_via1->write(space, offset, (data >> 8) & 0xff);
1588	1588
1589		device_adjust_icount(m_maincpu, m_via_cycles);
	1589	m_maincpu->adjust_icount(m_via_cycles);
1590	1590	}
1591	1591
1592	1592	/* *************************************************************************

trunk/src/mess/machine/i82371sb.c

r17814	r17815
154	154	/* setup save states */
155	155	save_item(NAME(m_regs));
156	156
157		device_set_irq_callback(machine().device(":maincpu"), at_irq_callback);
	157	machine().device(":maincpu")->execute().set_irq_acknowledge_callback(at_irq_callback);
158	158	}
159	159
160	160	//-------------------------------------------------

trunk/src/mess/machine/mboard.c

r17814	r17815
219	219	WRITE8_HANDLER( mboard_write_LED_8 )
220	220	{
221	221	write_LED(data);
222		device_spin_until_time(&space->device(), attotime::from_usec(7));
	222	space->device().execute().spin_until_time(attotime::from_usec(7));
223	223	}
224	224
225	225	WRITE16_HANDLER( mboard_write_LED_16 )
226	226	{
227	227	write_LED(data >> 8);
228		device_spin_until_time(&space->device(), attotime::from_usec(9));
	228	space->device().execute().spin_until_time(attotime::from_usec(9));
229	229	}
230	230
231	231	WRITE32_HANDLER( mboard_write_LED_32 )
r17814	r17815
235	235	if (offset) write_LED(data);
236	236	else write_LED(data >> 24);
237	237	logerror("write LED   32 o: %08x d: %08x\n",offset,data);
238		//  device_spin_until_time(&space->device(), ATTOTIME_IN_USEC(20));
	238	//  space->device().execute().spin_until_time(ATTOTIME_IN_USEC(20));
239	239	}
240	240
241	241

trunk/src/mess/machine/msx.c

r17814	r17815
520	520
521	521	DRIVER_INIT_MEMBER(msx_state,msx)
522	522	{
523		device_set_input_line_vector (machine().device("maincpu"), 0, 0xff);
	523	machine().device("maincpu")->execute().set_input_line_vector(0, 0xff);
524	524
525	525	msx_memory_init (machine());
526	526

trunk/src/mess/machine/lisa.c

r17814	r17815
328	328	if (keycode == state->m_NMIcode)
329	329	{   /* generate NMI interrupt */
330	330	machine.device("maincpu")->execute().set_input_line(M68K_IRQ_7, PULSE_LINE);
331		device_set_input_line_vector(machine.device("maincpu"), M68K_IRQ_7, M68K_INT_ACK_AUTOVECTOR);
	331	machine.device("maincpu")->execute().set_input_line_vector(M68K_IRQ_7, M68K_INT_ACK_AUTOVECTOR);
332	332	}
333	333	#endif
334	334	COPS_queue_data(machine, & keycode, 1);

trunk/src/mess/machine/isa.c

r17814	r17815
133	133	memset(&m_out_drq2_cb, 0, sizeof(m_out_drq2_cb));
134	134	memset(&m_out_drq3_cb, 0, sizeof(m_out_drq3_cb));
135	135	}
136		m_maincpu = mconfig().device(m_cputag);
	136	m_maincpu = mconfig().device<cpu_device>(m_cputag);
137	137	}
138	138
139	139	//**************************************************************************
r17814	r17815
201	201
202	202	void isa8_device::install_space(address_spacenum spacenum, offs_t start, offs_t end, offs_t mask, offs_t mirror, read8_space_func rhandler, const char* rhandler_name, write8_space_func whandler, const char *whandler_name)
203	203	{
204		int buswidth = m_maincpu->memory().space_config(spacenum)->m_databus_width;
	204	int buswidth = m_maincpu->space_config(spacenum)->m_databus_width;
205	205	switch(buswidth)
206	206	{
207	207	case 8:
208		m_maincpu->memory().space(spacenum)->install_legacy_readwrite_handler(start, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0);
	208	m_maincpu->space(spacenum)->install_legacy_readwrite_handler(start, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0);
209	209	break;
210	210	case 16:
211		m_maincpu->memory().space(spacenum)->install_legacy_readwrite_handler(start, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0xffff);
	211	m_maincpu->space(spacenum)->install_legacy_readwrite_handler(start, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0xffff);
212	212	break;
213	213	case 32:
214	214	if ((start % 4) == 0) {
215	215	if ((end-start)==1) {
216		m_maincpu->memory().space(spacenum)->install_legacy_readwrite_handler(start, end+2, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0x0000ffff);
	216	m_maincpu->space(spacenum)->install_legacy_readwrite_handler(start, end+2, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0x0000ffff);
217	217	} else {
218		m_maincpu->memory().space(spacenum)->install_legacy_readwrite_handler(start, end,   mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0xffffffff);
	218	m_maincpu->space(spacenum)->install_legacy_readwrite_handler(start, end,   mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0xffffffff);
219	219	}
220	220	} else {
221	221	// we handle just misalligned by 2
222		m_maincpu->memory().space(spacenum)->install_legacy_readwrite_handler(start-2, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0xffff0000);
	222	m_maincpu->space(spacenum)->install_legacy_readwrite_handler(start-2, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0xffff0000);
223	223	}
224	224	break;
225	225	default:
r17814	r17815
231	231
232	232	void isa8_device::install_space(address_spacenum spacenum, offs_t start, offs_t end, offs_t mask, offs_t mirror, read8_delegate rhandler, write8_delegate whandler)
233	233	{
234		int buswidth = m_maincpu->memory().space_config(spacenum)->m_databus_width;
	234	int buswidth = m_maincpu->space_config(spacenum)->m_databus_width;
235	235	switch(buswidth)
236	236	{
237	237	case 8:
238		m_maincpu->memory().space(spacenum)->install_readwrite_handler(start, end, mask, mirror, rhandler, whandler, 0);
	238	m_maincpu->space(spacenum)->install_readwrite_handler(start, end, mask, mirror, rhandler, whandler, 0);
239	239	break;
240	240	case 16:
241		m_maincpu->memory().space(spacenum)->install_readwrite_handler(start, end, mask, mirror, rhandler, whandler, 0xffff);
	241	m_maincpu->space(spacenum)->install_readwrite_handler(start, end, mask, mirror, rhandler, whandler, 0xffff);
242	242	break;
243	243	case 32:
244	244	if ((start % 4) == 0) {
245	245	if ((end-start)==1) {
246		m_maincpu->memory().space(spacenum)->install_readwrite_handler(start, end+2, mask, mirror, rhandler, whandler, 0x0000ffff);
	246	m_maincpu->space(spacenum)->install_readwrite_handler(start, end+2, mask, mirror, rhandler, whandler, 0x0000ffff);
247	247	} else {
248		m_maincpu->memory().space(spacenum)->install_readwrite_handler(start, end,   mask, mirror, rhandler, whandler, 0xffffffff);
	248	m_maincpu->space(spacenum)->install_readwrite_handler(start, end,   mask, mirror, rhandler, whandler, 0xffffffff);
249	249	}
250	250	} else {
251	251	// we handle just misalligned by 2
252		m_maincpu->memory().space(spacenum)->install_readwrite_handler(start-2, end, mask, mirror, rhandler, whandler, 0xffff0000);
	252	m_maincpu->space(spacenum)->install_readwrite_handler(start-2, end, mask, mirror, rhandler, whandler, 0xffff0000);
253	253	}
254	254	break;
255	255	default:
r17814	r17815
261	261
262	262	void isa8_device::install_space(address_spacenum spacenum, device_t *dev, offs_t start, offs_t end, offs_t mask, offs_t mirror, read8_device_func rhandler, const char* rhandler_name, write8_device_func whandler, const char *whandler_name)
263	263	{
264		int buswidth = m_maincpu->memory().space_config(spacenum)->m_databus_width;
	264	int buswidth = m_maincpu->space_config(spacenum)->m_databus_width;
265	265	switch(buswidth)
266	266	{
267	267	case 8:
268		m_maincpu->memory().space(spacenum)->install_legacy_readwrite_handler(*dev, start, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0);
	268	m_maincpu->space(spacenum)->install_legacy_readwrite_handler(*dev, start, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0);
269	269	break;
270	270	case 16:
271		m_maincpu->memory().space(spacenum)->install_legacy_readwrite_handler(*dev, start, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0xffff);
	271	m_maincpu->space(spacenum)->install_legacy_readwrite_handler(*dev, start, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0xffff);
272	272	break;
273	273	case 32:
274	274	if ((start % 4) == 0) {
275	275	if ((end-start)==1) {
276		m_maincpu->memory().space(spacenum)->install_legacy_readwrite_handler(*dev, start, end+2, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0x0000ffff);
	276	m_maincpu->space(spacenum)->install_legacy_readwrite_handler(*dev, start, end+2, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0x0000ffff);
277	277	} else {
278		m_maincpu->memory().space(spacenum)->install_legacy_readwrite_handler(*dev, start, end,   mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0xffffffff);
	278	m_maincpu->space(spacenum)->install_legacy_readwrite_handler(*dev, start, end,   mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0xffffffff);
279	279	}
280	280	} else {
281	281	// we handle just misalligned by 2
282		m_maincpu->memory().space(spacenum)->install_legacy_readwrite_handler(*dev, start-2, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0xffff0000);
	282	m_maincpu->space(spacenum)->install_legacy_readwrite_handler(*dev, start-2, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0xffff0000);
283	283	}
284	284	break;
285	285	default:
r17814	r17815
327	327
328	328	void isa8_device::install_bank(offs_t start, offs_t end, offs_t mask, offs_t mirror, const char *tag, UINT8 *data)
329	329	{
330		address_space *space = m_maincpu->memory().space(AS_PROGRAM);
	330	address_space *space = m_maincpu->space(AS_PROGRAM);
331	331	space->install_readwrite_bank(start, end, mask, mirror, tag );
332	332	machine().root_device().membank(tag)->set_base(data);
333	333	}
334	334
335	335	void isa8_device::unmap_bank(offs_t start, offs_t end, offs_t mask, offs_t mirror)
336	336	{
337		address_space *space = m_maincpu->memory().space(AS_PROGRAM);
	337	address_space *space = m_maincpu->space(AS_PROGRAM);
338	338	space->unmap_readwrite(start, end, mask, mirror);
339	339	}
340	340
r17814	r17815
346	346	UINT8 *dest = machine().root_device().memregion("isa")->base() + start - 0xc0000;
347	347	memcpy(dest,src, end - start + 1);
348	348	} else {
349		address_space *space = m_maincpu->memory().space(AS_PROGRAM);
	349	address_space *space = m_maincpu->space(AS_PROGRAM);
350	350	space->install_read_bank(start, end, mask, mirror, tag);
351	351	space->unmap_write(start, end, mask, mirror);
352	352	machine().root_device().membank(tag)->set_base(machine().root_device().memregion(dev->subtag(tempstring, region))->base());
r17814	r17815
355	355
356	356	void isa8_device::unmap_rom(offs_t start, offs_t end, offs_t mask, offs_t mirror)
357	357	{
358		address_space *space = m_maincpu->memory().space(AS_PROGRAM);
	358	address_space *space = m_maincpu->space(AS_PROGRAM);
359	359	space->unmap_read(start, end, mask, mirror);
360	360	}
361	361
362	362	bool isa8_device::is_option_rom_space_available(offs_t start, int size)
363	363	{
364		m_maincpu = machine().device(m_cputag);
365		address_space *space = m_maincpu->memory().space(AS_PROGRAM);
	364	m_maincpu = machine().device<cpu_device>(m_cputag);
	365	address_space *space = m_maincpu->space(AS_PROGRAM);
366	366	for(int i = 0; i < size; i += 4096) // 4KB granularity should be enough
367	367	if(space->get_read_ptr(start + i)) return false;
368	368	return true;
r17814	r17815
404	404	{
405	405	if (m_nmi_enabled)
406	406	{
407		device_set_input_line( m_maincpu, INPUT_LINE_NMI, PULSE_LINE );
	407	m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE );
408	408	}
409	409	}
410	410	//**************************************************************************
r17814	r17815
518	518	memset(&m_out_drq6_cb, 0, sizeof(m_out_drq6_cb));
519	519	memset(&m_out_drq7_cb, 0, sizeof(m_out_drq7_cb));
520	520	}
521		m_maincpu = mconfig().device(m_cputag);
	521	m_maincpu = mconfig().device<cpu_device>(m_cputag);
522	522	}
523	523
524	524	//-------------------------------------------------
r17814	r17815
544	544
545	545	void isa16_device::install16_device(device_t *dev, offs_t start, offs_t end, offs_t mask, offs_t mirror, read16_device_func rhandler, const char* rhandler_name, write16_device_func whandler, const char *whandler_name)
546	546	{
547		int buswidth = m_maincpu->memory().space_config(AS_PROGRAM)->m_databus_width;
	547	int buswidth = m_maincpu->space_config(AS_PROGRAM)->m_databus_width;
548	548	switch(buswidth)
549	549	{
550	550	case 16:
551		m_maincpu->memory().space(AS_IO)->install_legacy_readwrite_handler(*dev, start, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0);
	551	m_maincpu->space(AS_IO)->install_legacy_readwrite_handler(*dev, start, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0);
552	552	break;
553	553	case 32:
554	554	if ((start % 4) == 0) {
555	555	if ((end-start)==1) {
556		m_maincpu->memory().space(AS_IO)->install_legacy_readwrite_handler(*dev, start, end+2, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0x0000ffff);
	556	m_maincpu->space(AS_IO)->install_legacy_readwrite_handler(*dev, start, end+2, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0x0000ffff);
557	557	} else {
558		m_maincpu->memory().space(AS_IO)->install_legacy_readwrite_handler(*dev, start, end,   mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0xffffffff);
	558	m_maincpu->space(AS_IO)->install_legacy_readwrite_handler(*dev, start, end,   mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0xffffffff);
559	559	}
560	560	} else {
561	561	// we handle just misalligned by 2
562		m_maincpu->memory().space(AS_IO)->install_legacy_readwrite_handler(*dev, start-2, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0xffff0000);
	562	m_maincpu->space(AS_IO)->install_legacy_readwrite_handler(*dev, start-2, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name,0xffff0000);
563	563	}
564	564
565	565	break;
r17814	r17815
571	571
572	572	void isa16_device::install16_device(offs_t start, offs_t end, offs_t mask, offs_t mirror, read16_delegate rhandler, write16_delegate whandler)
573	573	{
574		int buswidth = m_maincpu->memory().space_config(AS_PROGRAM)->m_databus_width;
	574	int buswidth = m_maincpu->space_config(AS_PROGRAM)->m_databus_width;
575	575	switch(buswidth)
576	576	{
577	577	case 16:
578		m_maincpu->memory().space(AS_IO)->install_readwrite_handler(start, end, mask, mirror, rhandler, whandler, 0);
	578	m_maincpu->space(AS_IO)->install_readwrite_handler(start, end, mask, mirror, rhandler, whandler, 0);
579	579	break;
580	580	case 32:
581		m_maincpu->memory().space(AS_IO)->install_readwrite_handler(start, end, mask, mirror, rhandler, whandler, 0xffffffff);
	581	m_maincpu->space(AS_IO)->install_readwrite_handler(start, end, mask, mirror, rhandler, whandler, 0xffffffff);
582	582	if ((start % 4) == 0) {
583	583	if ((end-start)==1) {
584		m_maincpu->memory().space(AS_IO)->install_readwrite_handler(start, end+2, mask, mirror, rhandler, whandler, 0x0000ffff);
	584	m_maincpu->space(AS_IO)->install_readwrite_handler(start, end+2, mask, mirror, rhandler, whandler, 0x0000ffff);
585	585	} else {
586		m_maincpu->memory().space(AS_IO)->install_readwrite_handler(start, end,   mask, mirror, rhandler, whandler, 0xffffffff);
	586	m_maincpu->space(AS_IO)->install_readwrite_handler(start, end,   mask, mirror, rhandler, whandler, 0xffffffff);
587	587	}
588	588	} else {
589	589	// we handle just misalligned by 2
590		m_maincpu->memory().space(AS_IO)->install_readwrite_handler(start-2, end, mask, mirror, rhandler, whandler, 0xffff0000);
	590	m_maincpu->space(AS_IO)->install_readwrite_handler(start-2, end, mask, mirror, rhandler, whandler, 0xffff0000);
591	591	}
592	592
593	593	break;
r17814	r17815
599	599
600	600	void isa16_device::install16_device(offs_t start, offs_t end, offs_t mask, offs_t mirror, read16_space_func rhandler, const char* rhandler_name, write16_space_func whandler, const char *whandler_name)
601	601	{
602		int buswidth = m_maincpu->memory().space_config(AS_PROGRAM)->m_databus_width;
	602	int buswidth = m_maincpu->space_config(AS_PROGRAM)->m_databus_width;
603	603	switch(buswidth)
604	604	{
605	605	case 16:
606		m_maincpu->memory().space(AS_IO)->install_legacy_readwrite_handler(start, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name, 0);
	606	m_maincpu->space(AS_IO)->install_legacy_readwrite_handler(start, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name, 0);
607	607	break;
608	608	case 32:
609		m_maincpu->memory().space(AS_IO)->install_legacy_readwrite_handler(start, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name, 0xffffffff);
	609	m_maincpu->space(AS_IO)->install_legacy_readwrite_handler(start, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name, 0xffffffff);
610	610	if ((start % 4) == 0) {
611	611	if ((end-start)==1) {
612		m_maincpu->memory().space(AS_IO)->install_legacy_readwrite_handler(start, end+2, mask, mirror, rhandler, rhandler_name, whandler, whandler_name, 0x0000ffff);
	612	m_maincpu->space(AS_IO)->install_legacy_readwrite_handler(start, end+2, mask, mirror, rhandler, rhandler_name, whandler, whandler_name, 0x0000ffff);
613	613	} else {
614		m_maincpu->memory().space(AS_IO)->install_legacy_readwrite_handler(start, end,   mask, mirror, rhandler, rhandler_name, whandler, whandler_name, 0xffffffff);
	614	m_maincpu->space(AS_IO)->install_legacy_readwrite_handler(start, end,   mask, mirror, rhandler, rhandler_name, whandler, whandler_name, 0xffffffff);
615	615	}
616	616	} else {
617	617	// we handle just misalligned by 2
618		m_maincpu->memory().space(AS_IO)->install_legacy_readwrite_handler(start-2, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name, 0xffff0000);
	618	m_maincpu->space(AS_IO)->install_legacy_readwrite_handler(start-2, end, mask, mirror, rhandler, rhandler_name, whandler, whandler_name, 0xffff0000);
619	619	}
620	620
621	621	break;

trunk/src/mess/machine/isa.h

r17814	r17815
190	190	virtual void device_config_complete();
191	191
192	192	// internal state
193		device_t   *m_maincpu;
	193	cpu_device   *m_maincpu;
194	194
195	195	devcb_resolved_write_line   m_out_irq2_func;
196	196	devcb_resolved_write_line   m_out_irq3_func;

trunk/src/mess/machine/mbc55x.c

r17814	r17815
388	388	{
389	389	set_ram_size(machine);
390	390	keyboard_reset(machine);
391		device_set_irq_callback(machine.device(MAINCPU_TAG), mbc55x_irq_callback);
	391	machine.device(MAINCPU_TAG)->execute().set_irq_acknowledge_callback(mbc55x_irq_callback);
392	392	}
393	393
394	394	MACHINE_START( mbc55x )

trunk/src/mess/machine/southbridge.c

r17814	r17815
209	209
210	210
211	211	m_at_offset1 = 0xff;
212		//device_set_irq_callback(machine().device(":maincpu"), at_irq_callback);
	212	//machine().device(":maincpu")->execute().set_irq_acknowledge_callback(at_irq_callback);
213	213	}
214	214
215	215	//-------------------------------------------------
r17814	r17815
330	330
331	331	WRITE_LINE_MEMBER( southbridge_device::pc_dma_hrq_changed )
332	332	{
333		device_set_input_line(m_maincpu, INPUT_LINE_HALT, state ? ASSERT_LINE : CLEAR_LINE);
	333	m_maincpu->set_input_line(INPUT_LINE_HALT, state ? ASSERT_LINE : CLEAR_LINE);
334	334
335	335	/* Assert HLDA */
336	336	i8237_hlda_w( m_dma8237_2, state );

trunk/src/mess/machine/rmnimbus.c

r17814	r17815
203	203	logerror("(%f) **** Acknowledged interrupt vector %02X\n", device->machine().time().as_double(), state->m_i186.intr.poll_status & 0x1f);
204	204
205	205	/* clear the interrupt */
206		device_set_input_line(device, 0, CLEAR_LINE);
	206	device->execute().set_input_line(0, CLEAR_LINE);
207	207	state->m_i186.intr.pending = 0;
208	208
209	209	oldreq=state->m_i186.intr.request;
r17814	r17815
1178	1178	/* we need to do this at a time when the I86 context is swapped in */
1179	1179	/* this register is generally set once at startup and never again, so it's a good */
1180	1180	/* time to set it up */
1181		device_set_irq_callback(&space.device(), int_callback);
	1181	space.device().execute().set_irq_acknowledge_callback(int_callback);
1182	1182	break;
1183	1183
1184	1184	case 0x60:

trunk/src/mess/machine/pk8020.c

r17814	r17815
998	998	{
999	999	pk8020_state *state = machine.driver_data<pk8020_state>();
1000	1000	pk8020_set_bank(machine,0);
1001		device_set_irq_callback(machine.device("maincpu"), pk8020_irq_callback);
	1001	machine.device("maincpu")->execute().set_irq_acknowledge_callback(pk8020_irq_callback);
1002	1002
1003	1003	state->m_sound_gate = 0;
1004	1004	state->m_sound_level = 0;

trunk/src/mess/includes/nes.h

r17814	r17815
126	126	nes_chr_callback    m_mmc3_chr_cb;
127	127
128	128	/* devices */
129		device_t      *m_maincpu;
	129	cpu_device      *m_maincpu;
130	130	ppu2c0x_device      *m_ppu;
131	131	device_t      *m_sound;
132	132	device_t      *m_cart;

trunk/src/mess/includes/fmtowns.h

r17814	r17815
103	103	{ }
104	104
105	105	/* devices */
106		device_t* m_maincpu;
	106	cpu_device* m_maincpu;
107	107	device_t* m_dma_1;
108	108	device_t* m_dma_2;
109	109	device_t* m_fdc;

trunk/src/mess/includes/pc.h

r17814	r17815
23	23	{
24	24	}
25	25
26		device_t *m_maincpu;
	26	cpu_device *m_maincpu;
27	27	device_t *m_pic8259;
28	28	device_t *m_dma8237;
29	29	device_t *m_pit8253;

trunk/src/mess/video/mac.c

r17814	r17815
714	714
715	715	READ32_MEMBER(mac_state::dafb_r)
716	716	{
717		//  if (offset != 0x108/4) printf("DAFB: Read @ %x (mask %x PC=%x)\n", offset*4, mem_mask, m_maincpu->safe_pc());
	717	//  if (offset != 0x108/4) printf("DAFB: Read @ %x (mask %x PC=%x)\n", offset*4, mem_mask, m_maincpu->pc());
718	718
719	719	switch (offset<<2)
720	720	{
r17814	r17815
745	745
746	746	WRITE32_MEMBER(mac_state::dafb_w)
747	747	{
748		//  if (offset != 0x10c/4) printf("DAFB: Write %08x @ %x (mask %x PC=%x)\n", data, offset*4, mem_mask, m_maincpu->safe_pc());
	748	//  if (offset != 0x10c/4) printf("DAFB: Write %08x @ %x (mask %x PC=%x)\n", data, offset*4, mem_mask, m_maincpu->pc());
749	749
750	750	switch (offset<<2)
751	751	{
r17814	r17815
809	809
810	810	READ32_MEMBER(mac_state::dafb_dac_r)
811	811	{
812		//  printf("DAFB: Read DAC @ %x (mask %x PC=%x)\n", offset*4, mem_mask, m_maincpu->safe_pc());
	812	//  printf("DAFB: Read DAC @ %x (mask %x PC=%x)\n", offset*4, mem_mask, m_maincpu->pc());
813	813
814	814	return 0;
815	815	}
816	816
817	817	WRITE32_MEMBER(mac_state::dafb_dac_w)
818	818	{
819		//  if ((offset > 0) && (offset != 0x10/4)) printf("DAFB: Write %08x to DAC @ %x (mask %x PC=%x)\n", data, offset*4, mem_mask, m_maincpu->safe_pc());
	819	//  if ((offset > 0) && (offset != 0x10/4)) printf("DAFB: Write %08x to DAC @ %x (mask %x PC=%x)\n", data, offset*4, mem_mask, m_maincpu->pc());
820	820
821	821	switch (offset<<2)
822	822	{
r17814	r17815
1018	1018	break;
1019	1019
1020	1020	default:
1021		//            printf("macwd_r: @ %x, mask %08x (PC=%x)\n", offset, mem_mask, m_maincpu->safe_pc());
	1021	//            printf("macwd_r: @ %x, mask %08x (PC=%x)\n", offset, mem_mask, m_maincpu->pc());
1022	1022	break;
1023	1023	}
1024	1024	return 0;
r17814	r17815
1052	1052	break;
1053	1053
1054	1054	default:
1055		//            printf("macwd_w: %x @ %x, mask %08x (PC=%x)\n", data, offset, mem_mask, m_maincpu->safe_pc());
	1055	//            printf("macwd_w: %x @ %x, mask %08x (PC=%x)\n", data, offset, mem_mask, m_maincpu->pc());
1056	1056	break;
1057	1057	}
1058	1058	}

trunk/src/mess/video/atarist.c

r17814	r17815
235	235
236	236	if ((y == m_shifter_vblank_start) && (x == 0))
237	237	{
238		device_set_input_line(m_maincpu, M68K_IRQ_4, HOLD_LINE);
	238	m_maincpu->set_input_line(M68K_IRQ_4, HOLD_LINE);
239	239	m_shifter_ofs = m_shifter_base;
240	240	}
241	241
242	242	if (x == m_shifter_hblank_start)
243	243	{
244		device_set_input_line(m_maincpu, M68K_IRQ_2, HOLD_LINE);
	244	m_maincpu->set_input_line(M68K_IRQ_2, HOLD_LINE);
245	245	//      m_shifter_ofs += (m_shifter_lineofs * 2); // STe
246	246	}
247	247

trunk/src/mess/video/v1050.c

r17814	r17815
89	89
90	90	WRITE_LINE_MEMBER( v1050_state::crtc_vs_w )
91	91	{
92		device_set_input_line(m_subcpu, INPUT_LINE_IRQ0, state ? ASSERT_LINE : CLEAR_LINE);
	92	m_subcpu->set_input_line(INPUT_LINE_IRQ0, state ? ASSERT_LINE : CLEAR_LINE);
93	93
94	94	set_interrupt(INT_VSYNC, state);
95	95	}

trunk/src/mess/video/zx8301.c

r17814	r17815
226	226
227	227	if (m_vda)
228	228	{
229		device_spin_until_time(m_cpu, m_screen->time_until_pos(256, 0));
	229	m_cpu->spin_until_time(m_screen->time_until_pos(256, 0));
230	230	}
231	231
232	232	return readbyte(offset);
r17814	r17815
243	243
244	244	if (m_vda)
245	245	{
246		device_spin_until_time(m_cpu, m_screen->time_until_pos(256, 0));
	246	m_cpu->spin_until_time(m_screen->time_until_pos(256, 0));
247	247	}
248	248
249	249	writebyte(offset, data);

trunk/src/mess/video/a7800.c

r17814	r17815
418	418	if( state->m_maria_dli )
419	419	{
420	420	state->m_maria_dli = 0;
421		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, PULSE_LINE);
	421	state->m_maincpu->set_input_line(INPUT_LINE_NMI, PULSE_LINE);
422	422	}
423	423
424	424	}
r17814	r17815
481	481	m_maria_palette[0][3] = data;
482	482	break;
483	483	case 0x04:
484		device_spin_until_trigger(machine().device("maincpu"), TRIGGER_HSYNC);
	484	machine().device("maincpu")->execute().spin_until_trigger(TRIGGER_HSYNC);
485	485	m_maria_wsync=1;
486	486	break;
487	487

trunk/src/mess/video/vic6567.c

r17814	r17815
377	377	vic2->first_ba_cycle = vic2->cycles_counter;
378	378	if (vic2->in_rdy_workaround_func(0) != 7 )
379	379	{
380		//          device_suspend(machine.firstcpu, SUSPEND_REASON_SPIN, 0);
	380	//          machine.firstcpu->suspend(SUSPEND_REASON_SPIN, 0);
381	381	}
382	382	vic2->device_suspended = 1;
383	383	}
r17814	r17815
388	388	{
389	389	if (vic2->device_suspended == 1)
390	390	{
391		//  device_resume(machine.firstcpu, SUSPEND_REASON_SPIN);
	391	//  machine.firstcpu->resume(SUSPEND_REASON_SPIN);
392	392	vic2->device_suspended = 0;
393	393	}
394	394	}
r17814	r17815
1607	1607
1608	1608	if ((cpu_cycles == vic_cycles) && (vic2->rdy_cycles > 0))
1609	1609	{
1610		device_spin_until_time (machine.firstcpu, vic2->cpu->cycles_to_attotime(vic2->rdy_cycles));
	1610	machine.firstcpu->spin_until_time(vic2->cpu->cycles_to_attotime(vic2->rdy_cycles));
1611	1611	vic2->rdy_cycles = 0;
1612	1612	}
1613	1613

trunk/src/mess/video/mos6566.c

r17814	r17815
330	330	m_first_ba_cycle = m_cycles_counter;
331	331	if (m_in_rdy_workaround_func(0) != 7 )
332	332	{
333		//          device_suspend(machine.firstcpu, SUSPEND_REASON_SPIN, 0);
	333	//          machine.firstcpu->suspend(SUSPEND_REASON_SPIN, 0);
334	334	}
335	335	m_device_suspended = 1;
336	336	}
r17814	r17815
341	341	{
342	342	if (m_device_suspended == 1)
343	343	{
344		//  device_resume(machine.firstcpu, SUSPEND_REASON_SPIN);
	344	//  machine.firstcpu->resume(SUSPEND_REASON_SPIN);
345	345	m_device_suspended = 0;
346	346	}
347	347	}
r17814	r17815
2025	2025
2026	2026	if ((cpu_cycles == vic_cycles) && (m_rdy_cycles > 0))
2027	2027	{
2028		device_spin_until_time (m_cpu, m_cpu->cycles_to_attotime(m_rdy_cycles));
	2028	m_cpu->spin_until_time(m_cpu->cycles_to_attotime(m_rdy_cycles));
2029	2029	m_rdy_cycles = 0;
2030	2030	}
2031	2031

trunk/src/mess/drivers/rainbow.c

r17814	r17815
194	194	{
195	195	rainbow_state *state = machine.driver_data<rainbow_state>();
196	196
197		device_set_input_line(state->m_z80, INPUT_LINE_HALT, ASSERT_LINE);
	197	state->m_z80->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
198	198
199	199	state->m_zflip = true;
200	200	state->m_z80_halted = true;
r17814	r17815
274	274	READ8_MEMBER(rainbow_state::i8088_latch_r)
275	275	{
276	276	//    printf("Read %02x from 8088 mailbox\n", m_8088_mailbox);
277		device_set_input_line(m_i8088, INPUT_LINE_INT1, CLEAR_LINE);
	277	m_i8088->execute().set_input_line(INPUT_LINE_INT1, CLEAR_LINE);
278	278	return m_8088_mailbox;
279	279	}
280	280
281	281	WRITE8_MEMBER(rainbow_state::i8088_latch_w)
282	282	{
283	283	//    printf("%02x to Z80 mailbox\n", data);
284		device_set_input_line_and_vector(m_z80, 0, ASSERT_LINE, 0xf7);
	284	m_z80->execute().set_input_line_and_vector(0, ASSERT_LINE, 0xf7);
285	285	m_z80_mailbox = data;
286	286	}
287	287
288	288	READ8_MEMBER(rainbow_state::z80_latch_r)
289	289	{
290	290	//    printf("Read %02x from Z80 mailbox\n", m_z80_mailbox);
291		device_set_input_line(m_z80, 0, CLEAR_LINE);
	291	m_z80->execute().set_input_line(0, CLEAR_LINE);
292	292	return m_z80_mailbox;
293	293	}
294	294
295	295	WRITE8_MEMBER(rainbow_state::z80_latch_w)
296	296	{
297	297	//    printf("%02x to 8088 mailbox\n", data);
298		device_set_input_line_and_vector(m_i8088, INPUT_LINE_INT1, ASSERT_LINE, 0x27);
	298	m_i8088->execute().set_input_line_and_vector(INPUT_LINE_INT1, ASSERT_LINE, 0x27);
299	299	m_8088_mailbox = data;
300	300	}
301	301
r17814	r17815
316	316
317	317	static INTERRUPT_GEN( vblank_irq )
318	318	{
319		device_set_input_line_and_vector(device, INPUT_LINE_INT0, ASSERT_LINE, 0x20);
	319	device->execute().set_input_line_and_vector(INPUT_LINE_INT0, ASSERT_LINE, 0x20);
320	320	}
321	321
322	322	WRITE8_MEMBER( rainbow_state::clear_video_interrupt )
323	323	{
324		device_set_input_line(m_i8088, INPUT_LINE_INT0, CLEAR_LINE);
	324	m_i8088->execute().set_input_line(INPUT_LINE_INT0, CLEAR_LINE);
325	325	}
326	326
327	327	READ8_MEMBER( rainbow_state::diagnostic_r )
r17814	r17815
335	335
336	336	if (!(data & 1))
337	337	{
338		device_set_input_line(m_z80, INPUT_LINE_HALT, ASSERT_LINE);
	338	m_z80->execute().set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
339	339	m_z80_halted = true;
340	340	}
341	341
r17814	r17815
343	343	{
344	344	m_zflip = true;
345	345	m_z80_halted = false;
346		device_set_input_line(m_z80, INPUT_LINE_HALT, CLEAR_LINE);
	346	m_z80->execute().set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
347	347	m_z80->reset();
348	348	}
349	349
r17814	r17815
354	354	{
355	355	if ((m_kbd_rx_ready) || (m_kbd_tx_ready))
356	356	{
357		device_set_input_line_and_vector(m_i8088, INPUT_LINE_INT2, ASSERT_LINE, 0x26);
	357	m_i8088->execute().set_input_line_and_vector(INPUT_LINE_INT2, ASSERT_LINE, 0x26);
358	358	}
359	359	else
360	360	{
361		device_set_input_line(m_i8088, INPUT_LINE_INT2, CLEAR_LINE);
	361	m_i8088->execute().set_input_line(INPUT_LINE_INT2, CLEAR_LINE);
362	362	}
363	363	}
364	364

trunk/src/mess/drivers/pdp1.c

r17814	r17815
1604	1604	if (state->m_parallel_drum.wc)
1605	1605	delay = delay + PARALLEL_DRUM_WORD_TIME;
1606	1606	} while (state->m_parallel_drum.wc);
1607		device_adjust_icount(device->machine().device("maincpu"),-device->machine().device<cpu_device>("maincpu")->attotime_to_cycles(delay));
	1607	device->machine().device("maincpu")->execute().adjust_icount(-device->machine().device<cpu_device>("maincpu")->attotime_to_cycles(delay));
1608	1608	/* if no error, skip */
1609	1609	device->machine().device("maincpu")->state().set_state_int(PDP1_PC, device->machine().device("maincpu")->state().state_int(PDP1_PC)+1);
1610	1610	}

trunk/src/mess/drivers/homelab.c

r17814	r17815
72	72	{
73	73	homelab_state *state = device->machine().driver_data<homelab_state>();
74	74	if (state->m_nmi)
75		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, ASSERT_LINE);
	75	state->m_maincpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
76	76	}
77	77
78	78	READ8_MEMBER( homelab_state::key_r ) // offset 27F-2FE
79	79	{
80	80	if (offset == 0x38) // 0x3838
81	81	{
82		device_set_input_line(m_maincpu, INPUT_LINE_NMI, CLEAR_LINE);
	82	m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
83	83	return 0;
84	84	}
85	85

trunk/src/mess/drivers/pc100.c

r17814	r17815
331	331	{
332	332	pc100_state *state = machine.driver_data<pc100_state>();
333	333
334		device_set_irq_callback(machine.device("maincpu"), pc100_irq_callback);
	334	machine.device("maincpu")->execute().set_irq_acknowledge_callback(pc100_irq_callback);
335	335	state->m_kanji_rom = (UINT16 *)(*machine.root_device().memregion("kanji"));
336	336	state->m_vram = (UINT16 *)(*state->memregion("vram"));
337	337	}

trunk/src/mess/drivers/pc9801.c

r17814	r17815
719	719	printf("Read to undefined port [%02x]\n",offset+0x40);
720	720	else
721	721	{
722		//printf("Read to 8251 kbd port [%02x] %08x\n",offset+0x40,m_maincpu->safe_pc());
	722	//printf("Read to 8251 kbd port [%02x] %08x\n",offset+0x40,m_maincpu->pc());
723	723	if(offset == 1)
724	724	{
725	725	UINT8 res;
r17814	r17815
2525	2525	{
2526	2526	pc9801_state *state = machine.driver_data<pc9801_state>();
2527	2527
2528		device_set_irq_callback(machine.device("maincpu"), irq_callback);
	2528	machine.device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
2529	2529
2530	2530	state->m_rtc->cs_w(1);
2531	2531	state->m_rtc->oe_w(1);

trunk/src/mess/drivers/nakajies.c

r17814	r17815
419	419
420	420	if ( vector >= 0xf8 )
421	421	{
422		device_set_input_line_and_vector( m_maincpu, 0, ASSERT_LINE, vector );
	422	m_maincpu->set_input_line_and_vector(0, ASSERT_LINE, vector );
423	423	}
424	424	else
425	425	{
426		device_set_input_line( m_maincpu, 0, CLEAR_LINE );
	426	m_maincpu->set_input_line(0, CLEAR_LINE );
427	427	}
428	428	}
429	429

trunk/src/mess/drivers/osbexec.c

r17814	r17815
98	98	void update_irq_state(running_machine &machine)
99	99	{
100	100	if ( m_pia0_irq_state || m_pia1_irq_state )
101		device_set_input_line( m_maincpu, 0, ASSERT_LINE );
	101	m_maincpu->set_input_line(0, ASSERT_LINE );
102	102	else
103		device_set_input_line( m_maincpu, 0, CLEAR_LINE );
	103	m_maincpu->set_input_line(0, CLEAR_LINE );
104	104	}
105	105	DECLARE_WRITE8_MEMBER(osbexec_0000_w);
106	106	DECLARE_READ8_MEMBER(osbexec_c000_r);

trunk/src/mess/drivers/z100.c

r17814	r17815
750	750	{
751	751	z100_state *state = machine.driver_data<z100_state>();
752	752
753		device_set_irq_callback(machine.device("maincpu"), z100_irq_callback);
	753	machine.device("maincpu")->execute().set_irq_acknowledge_callback(z100_irq_callback);
754	754	state->m_mc6845 = machine.device<mc6845_device>("crtc");
755	755	}
756	756

trunk/src/mess/drivers/multi16.c

r17814	r17815
133	133
134	134	static MACHINE_START(multi16)
135	135	{
136		device_set_irq_callback(machine.device("maincpu"), multi16_irq_callback);
	136	machine.device("maincpu")->execute().set_irq_acknowledge_callback(multi16_irq_callback);
137	137	}
138	138
139	139

trunk/src/mess/drivers/adam.c

r17814	r17815
1171	1171
1172	1172	// TODO: improve irq behaviour (see drivers/coleco.c)
1173	1173	if (coleco_scan_paddles(timer.machine(), &state->m_joy_status0, &state->m_joy_status1))
1174		device_set_input_line(state->m_maincpu, INPUT_LINE_IRQ0, HOLD_LINE);
	1174	state->m_maincpu->set_input_line(INPUT_LINE_IRQ0, HOLD_LINE);
1175	1175	}
1176	1176
1177	1177
r17814	r17815
1606	1606
1607	1607	//logerror("Master 6801 read from %04x data %02x\n", m_ba, m_data_out);
1608	1608
1609		device_set_input_line(m_netcpu, M6801_SC1_LINE, ASSERT_LINE);
1610		device_set_input_line(m_netcpu, M6801_SC1_LINE, CLEAR_LINE);
	1609	m_netcpu->set_input_line(M6801_SC1_LINE, ASSERT_LINE);
	1610	m_netcpu->set_input_line(M6801_SC1_LINE, CLEAR_LINE);
1611	1611	}
1612	1612	}
1613	1613	}

trunk/src/mess/drivers/pc88va.c

r17814	r17815
1528	1528	static MACHINE_START( pc88va )
1529	1529	{
1530	1530	pc88va_state *state = machine.driver_data<pc88va_state>();
1531		device_set_irq_callback(machine.device("maincpu"), pc88va_irq_callback);
	1531	machine.device("maincpu")->execute().set_irq_acknowledge_callback(pc88va_irq_callback);
1532	1532
1533	1533	state->m_t3_mouse_timer = machine.scheduler().timer_alloc(FUNC(t3_mouse_callback));
1534	1534	state->m_t3_mouse_timer->adjust(attotime::never);
r17814	r17815
1558	1558	state->m_fdc_mode = 0;
1559	1559	state->m_fdc_irq_opcode = 0x00; //0x7f ld a,a !
1560	1560
1561		device_set_input_line_vector(machine.device("fdccpu"), 0, 0);
	1561	machine.device("fdccpu")->execute().set_input_line_vector(0, 0);
1562	1562	}
1563	1563
1564	1564	static INTERRUPT_GEN( pc88va_vrtc_irq )

trunk/src/mess/drivers/pc6001.c

r17814	r17815
1845	1845	state->m_cur_keycode = check_joy_press(device->machine());
1846	1846	if(IRQ_LOG) printf("Stick IRQ called 0x16\n");
1847	1847	state->m_irq_vector = 0x16;
1848		device_set_input_line(device, 0, ASSERT_LINE);
	1848	device->execute().set_input_line(0, ASSERT_LINE);
1849	1849	}
1850	1850
1851	1851	static INTERRUPT_GEN( pc6001sr_interrupt )
r17814	r17815
1856	1856	state->m_cur_keycode = check_joy_press(device->machine());
1857	1857	if(IRQ_LOG) printf("VRTC IRQ called 0x16\n");
1858	1858	state->m_irq_vector = (state->m_kludge) ? 0x22 : 0x16;
1859		device_set_input_line(device, 0, ASSERT_LINE);
	1859	device->execute().set_input_line(0, ASSERT_LINE);
1860	1860	}
1861	1861
1862	1862	static IRQ_CALLBACK ( pc6001_irq_callback )
1863	1863	{
1864	1864	pc6001_state *state = device->machine().driver_data<pc6001_state>();
1865		device_set_input_line(device, 0, CLEAR_LINE);
	1865	device->execute().set_input_line(0, CLEAR_LINE);
1866	1866	return state->m_irq_vector;
1867	1867	}
1868	1868
r17814	r17815
2114	2114
2115	2115	state->m_port_c_8255=0;
2116	2116
2117		device_set_irq_callback(machine.device("maincpu"),pc6001_irq_callback);
	2117	machine.device("maincpu")->execute().set_irq_acknowledge_callback(pc6001_irq_callback);
2118	2118	state->m_cas_switch = 0;
2119	2119	state->m_cas_offset = 0;
2120	2120	state->m_timer_irq_mask = 1;
r17814	r17815
2132	2132
2133	2133	state->m_port_c_8255=0;
2134	2134
2135		device_set_irq_callback(machine.device("maincpu"),pc6001_irq_callback);
	2135	machine.device("maincpu")->execute().set_irq_acknowledge_callback(pc6001_irq_callback);
2136	2136	state->m_cas_switch = 0;
2137	2137	state->m_cas_offset = 0;
2138	2138
r17814	r17815
2168	2168
2169	2169	state->m_port_c_8255=0;
2170	2170
2171		device_set_irq_callback(machine.device("maincpu"),pc6001_irq_callback);
	2171	machine.device("maincpu")->execute().set_irq_acknowledge_callback(pc6001_irq_callback);
2172	2172	state->m_cas_switch = 0;
2173	2173	state->m_cas_offset = 0;
2174	2174

trunk/src/mess/drivers/pc1512.c

r17814	r17815
1203	1203	void pc1512_state::machine_start()
1204	1204	{
1205	1205	// register CPU IRQ callback
1206		device_set_irq_callback(m_maincpu, pc1512_irq_callback);
	1206	m_maincpu->set_irq_acknowledge_callback(pc1512_irq_callback);
1207	1207
1208	1208	// set RAM size
1209	1209	size_t ram_size = m_ram->size();
r17814	r17815
1286	1286	void pc1640_state::machine_start()
1287	1287	{
1288	1288	// register CPU IRQ callback
1289		device_set_irq_callback(m_maincpu, pc1512_irq_callback);
	1289	m_maincpu->set_irq_acknowledge_callback(pc1512_irq_callback);
1290	1290
1291	1291	// state saving
1292	1292	save_item(NAME(m_pit1));

trunk/src/mess/drivers/apricotp.c

r17814	r17815
557	557	void fp_state::machine_start()
558	558	{
559	559	// register CPU IRQ callback
560		device_set_irq_callback(m_maincpu, fp_irq_callback);
	560	m_maincpu->set_irq_acknowledge_callback(fp_irq_callback);
561	561
562	562	// allocate memory
563	563	m_work_ram = auto_alloc_array(machine(), UINT16, m_ram->size() / 2);

trunk/src/mess/drivers/mk1.c

r17814	r17815
166	166
167	167	static void mk1_interrupt( device_t *device, UINT16 addr, int level )
168	168	{
169		device_set_input_line_vector(device->machine().device("maincpu"), F8_INPUT_LINE_INT_REQ, addr );
	169	device->machine().device("maincpu")->execute().set_input_line_vector(F8_INPUT_LINE_INT_REQ, addr );
170	170
171	171	device->machine().device("maincpu")->execute().set_input_line(F8_INPUT_LINE_INT_REQ, level ? ASSERT_LINE : CLEAR_LINE );
172	172	}

trunk/src/mess/drivers/x1.c

r17814	r17815
1942	1942	//address_space *space = field.machine().device("x1_cpu")->memory().space(AS_PROGRAM);
1943	1943	x1_state *state = field.machine().driver_data<x1_state>();
1944	1944
1945		device_set_input_line(state->m_x1_cpu, INPUT_LINE_RESET, newval ? CLEAR_LINE : ASSERT_LINE);
	1945	state->m_x1_cpu->set_input_line(INPUT_LINE_RESET, newval ? CLEAR_LINE : ASSERT_LINE);
1946	1946
1947	1947	state->m_ram_bank = 0x00;
1948	1948	if(state->m_is_turbo) { state->m_ex_bank = 0x10; }
r17814	r17815
1954	1954	{
1955	1955	x1_state *state = field.machine().driver_data<x1_state>();
1956	1956
1957		device_set_input_line(state->m_x1_cpu, INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
	1957	state->m_x1_cpu->set_input_line(INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
1958	1958	}
1959	1959
1960	1960	INPUT_PORTS_START( x1 )
r17814	r17815
2391	2391	{
2392	2392	state->m_ctc_irq_flag = 0;
2393	2393	if(state->m_key_irq_flag == 0)  // if no other devices are pulling the IRQ line high
2394		device_set_input_line(device, 0, CLEAR_LINE);
	2394	device->execute().set_input_line(0, CLEAR_LINE);
2395	2395	return state->m_irq_vector;
2396	2396	}
2397	2397	if(state->m_key_irq_flag != 0)
2398	2398	{
2399	2399	state->m_key_irq_flag = 0;
2400	2400	if(state->m_ctc_irq_flag == 0)  // if no other devices are pulling the IRQ line high
2401		device_set_input_line(device, 0, CLEAR_LINE);
	2401	device->execute().set_input_line(0, CLEAR_LINE);
2402	2402	return state->m_key_irq_vector;
2403	2403	}
2404	2404	return state->m_irq_vector;
r17814	r17815
2483	2483
2484	2484	state->m_io_bank_mode = 0;
2485	2485
2486		//device_set_irq_callback(machine.device("x1_cpu"), x1_irq_callback);
	2486	//machine.device("x1_cpu")->execute().set_irq_acknowledge_callback(x1_irq_callback);
2487	2487
2488	2488	state->m_cmt_current_cmd = 0;
2489	2489	state->m_cmt_test = 0;

trunk/src/mess/drivers/xor100.c

r17814	r17815
191	191	if (!m_fdc_irq && !m_fdc_drq)
192	192	{
193	193	/* TODO: this is really connected to the Z80 _RDY line */
194		device_set_input_line(m_maincpu, INPUT_LINE_HALT, ASSERT_LINE);
	194	m_maincpu->set_input_line(INPUT_LINE_HALT, ASSERT_LINE);
195	195	}
196	196
197	197	return !m_fdc_irq << 7;
r17814	r17815
493	493	if (state)
494	494	{
495	495	/* TODO: this is really connected to the Z80 _RDY line */
496		device_set_input_line(m_maincpu, INPUT_LINE_HALT, CLEAR_LINE);
	496	m_maincpu->set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
497	497	}
498	498	}
499	499
r17814	r17815
504	504	if (state)
505	505	{
506	506	/* TODO: this is really connected to the Z80 _RDY line */
507		device_set_input_line(m_maincpu, INPUT_LINE_HALT, CLEAR_LINE);
	507	m_maincpu->set_input_line(INPUT_LINE_HALT, CLEAR_LINE);
508	508	}
509	509	}
510	510

trunk/src/mess/drivers/d6800.c

r17814	r17815
183	183	{
184	184	d6800_state *state = timer.machine().driver_data<d6800_state>();
185	185	state->m_rtc++;
186		device_set_input_line(state->m_maincpu, M6800_IRQ_LINE, (state->m_rtc > 0xf8) ? ASSERT_LINE : CLEAR_LINE);
	186	state->m_maincpu->set_input_line(M6800_IRQ_LINE, (state->m_rtc > 0xf8) ? ASSERT_LINE : CLEAR_LINE);
187	187	}
188	188
189	189

trunk/src/mess/drivers/smc777.c

r17814	r17815
1049	1049	smc777_state *state = device->machine().driver_data<smc777_state>();
1050	1050
1051	1051	if(state->m_irq_mask)
1052		device_set_input_line(device,0,HOLD_LINE);
	1052	device->execute().set_input_line(0,HOLD_LINE);
1053	1053	}
1054	1054
1055	1055

trunk/src/mess/drivers/m20.c

r17814	r17815
61	61	m_wd177x(*this, "fd1797"),
62	62	m_p_videoram(*this, "p_videoram"){ }
63	63
64		required_device<device_t> m_maincpu;
	64	required_device<z8001_device> m_maincpu;
65	65	required_device<i8251_device> m_kbdi8251;
66	66	required_device<i8251_device> m_ttyi8251;
67	67	required_device<i8255_device> m_i8255;
r17814	r17815
243	243	if (state)
244	244	{
245	245	//printf ("PIC raised VI\n");
246		device_set_input_line(m_maincpu, 1, ASSERT_LINE);
	246	m_maincpu->set_input_line(1, ASSERT_LINE);
247	247	}
248	248	else
249	249	{
250	250	//printf ("PIC lowered VI\n");
251		device_set_input_line(m_maincpu, 1, CLEAR_LINE);
	251	m_maincpu->set_input_line(1, CLEAR_LINE);
252	252	}
253	253	}
254	254
r17814	r17815
274	274	* 8253 is programmed in square wave mode, not rate
275	275	* generator mode.
276	276	*/
277		device_set_input_line(m_maincpu, 0, state ? HOLD_LINE /*ASSERT_LINE*/ : CLEAR_LINE);
	277	m_maincpu->set_input_line(0, state ? HOLD_LINE /*ASSERT_LINE*/ : CLEAR_LINE);
278	278	}
279	279
280	280	/* from the M20 hardware reference manual:
r17814	r17815
376	376	m_port21 = 0xff;
377	377	m_port21_sd = 1;
378	378
379		device_set_irq_callback(m_maincpu, m20_irq_callback);
	379	m_maincpu->set_irq_acknowledge_callback(m20_irq_callback);
380	380
381	381	wd17xx_mr_w(m_wd177x, 0);
382	382	//wd17xx_mr_w(m_wd177x, 1);

trunk/src/mess/drivers/spectrum.c

r17814	r17815
663	663
664	664	static INTERRUPT_GEN( spec_interrupt )
665	665	{
666		device_set_input_line(device, 0, HOLD_LINE);
	666	device->execute().set_input_line(0, HOLD_LINE);
667	667	}
668	668
669	669	static const cassette_interface spectrum_cassette_interface =

trunk/src/mess/drivers/cat.c

r17814	r17815
312	312	static MACHINE_RESET(cat)
313	313	{
314	314	cat_state *state = machine.driver_data<cat_state>();
315		device_set_irq_callback(machine.device("maincpu"), cat_int_ack);
	315	machine.device("maincpu")->execute().set_irq_acknowledge_callback(cat_int_ack);
316	316	state->m_keyboard_timer->adjust(attotime::zero, 0, attotime::from_hz(120));
317	317	}
318	318

trunk/src/mess/drivers/atarist.c

r17814	r17815
2205	2205	configure_memory();
2206	2206
2207	2207	// set CPU interrupt callback
2208		device_set_irq_callback(m_maincpu, atarist_int_ack);
	2208	m_maincpu->set_irq_acknowledge_callback(atarist_int_ack);
2209	2209
2210	2210	// allocate timers
2211	2211	m_mouse_timer = machine().scheduler().timer_alloc(FUNC(st_mouse_tick));
r17814	r17815
2262	2262	configure_memory();
2263	2263
2264	2264	/* set CPU interrupt callback */
2265		device_set_irq_callback(m_maincpu, atarist_int_ack);
	2265	m_maincpu->set_irq_acknowledge_callback(atarist_int_ack);
2266	2266
2267	2267	/* allocate timers */
2268	2268	m_dmasound_timer = machine().scheduler().timer_alloc(FUNC(atariste_dmasound_tick));
r17814	r17815
2302	2302	}
2303	2303
2304	2304	/* set CPU interrupt callback */
2305		device_set_irq_callback(m_maincpu, atarist_int_ack);
	2305	m_maincpu->set_irq_acknowledge_callback(atarist_int_ack);
2306	2306
2307	2307	/* register for state saving */
2308	2308	ste_state::state_save();

trunk/src/mess/drivers/h89.c

r17814	r17815
101	101	h89_state *state = timer.machine().driver_data<h89_state>();
102	102
103	103	if (state->m_port_f2 & 0x02)
104		device_set_input_line_and_vector(state->m_maincpu, 0, HOLD_LINE, 0xcf);
	104	state->m_maincpu->set_input_line_and_vector(0, HOLD_LINE, 0xcf);
105	105	}
106	106
107	107	WRITE8_MEMBER( h89_state::port_f2_w )

trunk/src/mess/drivers/mikromik.c

r17814	r17815
491	491
492	492	WRITE_LINE_MEMBER( mm1_state::dma_hrq_changed )
493	493	{
494		device_set_input_line(m_maincpu, INPUT_LINE_HALT, state ? ASSERT_LINE : CLEAR_LINE);
	494	m_maincpu->set_input_line(INPUT_LINE_HALT, state ? ASSERT_LINE : CLEAR_LINE);
495	495
496	496	// Assert HLDA
497	497	m_dmac->hack_w(state);

trunk/src/mess/drivers/pcw.c

r17814	r17815
1087	1087
1088	1088	DRIVER_INIT_MEMBER(pcw_state,pcw)
1089	1089	{
1090		device_set_input_line_vector(machine().device("maincpu"), 0, 0x0ff);
	1090	machine().device("maincpu")->execute().set_input_line_vector(0, 0x0ff);
1091	1091
1092	1092	/* lower 4 bits are interrupt counter */
1093	1093	m_system_status = 0x000;

trunk/src/mess/drivers/rex6000.c

r17814	r17815
141	141	}
142	142	else
143	143	{
144		//logerror("%04x: unkonwn memory bank %x\n", m_maincpu->safe_pc(), bank);
	144	//logerror("%04x: unkonwn memory bank %x\n", m_maincpu->pc(), bank);
145	145	return BANK_UNKNOWN;
146	146	}
147	147	}
r17814	r17815
413	413	{
414	414	state->m_irq_flag |= IRQ_FLAG_KEYCHANGE;
415	415
416		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	416	state->m_maincpu->set_input_line(0, HOLD_LINE);
417	417	}
418	418	}
419	419
r17814	r17815
519	519	{
520	520	state->m_irq_flag |= IRQ_FLAG_IRQ2;
521	521
522		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	522	state->m_maincpu->set_input_line(0, HOLD_LINE);
523	523	}
524	524
525	525	}
r17814	r17815
532	532	{
533	533	state->m_irq_flag |= IRQ_FLAG_IRQ1;
534	534
535		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	535	state->m_maincpu->set_input_line(0, HOLD_LINE);
536	536	}
537	537	}
538	538
r17814	r17815
544	544	{
545	545	state->m_irq_flag |= IRQ_FLAG_1HZ;
546	546
547		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	547	state->m_maincpu->set_input_line(0, HOLD_LINE);
548	548	}
549	549	}
550	550
r17814	r17815
553	553	if (!(m_irq_mask & IRQ_FLAG_ALARM) && state)
554	554	{
555	555	m_irq_flag |= IRQ_FLAG_ALARM;
556		device_set_input_line(m_maincpu, 0, HOLD_LINE);
	556	m_maincpu->set_input_line(0, HOLD_LINE);
557	557	}
558	558	}
559	559

trunk/src/mess/drivers/mirage.c

r17814	r17815
83	83	m_fdc(*this, "wd1772")
84	84	{ }
85	85
86		required_device<device_t> m_maincpu;
	86	required_device<m6809e_device> m_maincpu;
87	87	required_device<wd1772_t> m_fdc;
88	88
89	89	virtual void machine_reset();
r17814	r17815
107	107
108	108	void mirage_state::fdc_intrq_w(bool state)
109	109	{
110		device_set_input_line(m_maincpu, INPUT_LINE_NMI, state);
	110	m_maincpu->set_input_line(INPUT_LINE_NMI, state);
111	111	}
112	112
113	113	static void mirage_doc_irq(device_t *device, int state)

trunk/src/mess/drivers/v1050.c

r17814	r17815
343	343
344	344	WRITE8_MEMBER( v1050_state::dvint_clr_w )
345	345	{
346		device_set_input_line(m_subcpu, INPUT_LINE_IRQ0, CLEAR_LINE);
	346	m_subcpu->set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
347	347	}
348	348
349	349	READ8_MEMBER( v1050_state::sasi_status_r )
r17814	r17815
604	604	{
605	605	if (state == ASSERT_LINE)
606	606	{
607		device_set_input_line(device, INPUT_LINE_IRQ0, ASSERT_LINE);
	607	device->execute().set_input_line(INPUT_LINE_IRQ0, ASSERT_LINE);
608	608	}
609	609	}
610	610
r17814	r17815
756	756	if (!m_f_int_enb)
757	757	{
758	758	set_interrupt(INT_FLOPPY, 0);
759		device_set_input_line(m_maincpu, INPUT_LINE_NMI, CLEAR_LINE);
	759	m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
760	760	}
761	761
762	762	// baud select
r17814	r17815
948	948	{
949	949	if (m_f_int_enb)
950	950	{
951		device_set_input_line(m_maincpu, INPUT_LINE_NMI, state);
	951	m_maincpu->set_input_line(INPUT_LINE_NMI, state);
952	952	}
953	953	else
954	954	{
955		device_set_input_line(m_maincpu, INPUT_LINE_NMI, CLEAR_LINE);
	955	m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
956	956	}
957	957	}
958	958
r17814	r17815
1013	1013
1014	1014	//logerror("Interrupt Acknowledge Vector: %02x\n", vector);
1015	1015
1016		device_set_input_line(state->m_maincpu, INPUT_LINE_IRQ0, CLEAR_LINE);
	1016	state->m_maincpu->set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
1017	1017
1018	1018	return vector;
1019	1019	}
r17814	r17815
1033	1033	m_rtc->cs1_w(1);
1034	1034
1035	1035	// set CPU interrupt callback
1036		device_set_irq_callback(m_maincpu, v1050_int_ack);
	1036	m_maincpu->set_irq_acknowledge_callback(v1050_int_ack);
1037	1037
1038	1038	// setup memory banking
1039	1039	UINT8 *ram = machine().device<ram_device>(RAM_TAG)->pointer();

trunk/src/mess/drivers/ql.c

r17814	r17815
163	163	{
164	164	switch (ipl)
165	165	{
166		case 0:   device_set_input_line(m_maincpu, M68K_IRQ_7, ASSERT_LINE);   break;
167		case 1:   device_set_input_line(m_maincpu, M68K_IRQ_5, ASSERT_LINE);   break; // CTRL-ALT-7 pressed
168		case 2:   device_set_input_line(m_maincpu, M68K_IRQ_2, ASSERT_LINE);   break;
169		case 3:   device_set_input_line(m_maincpu, M68K_IRQ_7, CLEAR_LINE);   break;
	166	case 0:   m_maincpu->set_input_line(M68K_IRQ_7, ASSERT_LINE);   break;
	167	case 1:   m_maincpu->set_input_line(M68K_IRQ_5, ASSERT_LINE);   break; // CTRL-ALT-7 pressed
	168	case 2:   m_maincpu->set_input_line(M68K_IRQ_2, ASSERT_LINE);   break;
	169	case 3:   m_maincpu->set_input_line(M68K_IRQ_7, CLEAR_LINE);   break;
170	170	}
171	171
172	172	m_ipl = ipl;
r17814	r17815
208	208
209	209	//  int irq = (m_ser2_rxd | m_ser1_txd);
210	210
211		//  device_set_input_line(m_ipc, INPUT_LINE_IRQ0, irq);
	211	//  m_ipc->execute().set_input_line(INPUT_LINE_IRQ0, irq);
212	212
213	213	return (m_comdata << 7);
214	214	}

trunk/src/mess/drivers/qx10.c

r17814	r17815
899	899
900	900	void qx10_state::machine_start()
901	901	{
902		device_set_irq_callback(machine().device("maincpu"), irq_callback);
	902	machine().device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
903	903	}
904	904
905	905	void qx10_state::machine_reset()

trunk/src/mess/drivers/tvc.c

r17814	r17815
193	193	{
194	194	// every write here clears the vblank flipflop
195	195	m_int_flipflop = 1;
196		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	196	m_maincpu->set_input_line(0, CLEAR_LINE);
197	197	}
198	198
199	199	READ8_MEMBER(tvc_state::tvc_exp_id_r)
r17814	r17815
605	605	if (state)
606	606	{
607	607	m_int_flipflop = 0;
608		device_set_input_line(m_maincpu, 0, ASSERT_LINE);
	608	m_maincpu->set_input_line(0, ASSERT_LINE);
609	609	}
610	610	}
611	611

trunk/src/mess/drivers/mz2500.c

r17814	r17815
1823	1823	{
1824	1824	mz2500_state *state = device->machine().driver_data<mz2500_state>();
1825	1825	if(state->m_irq_mask[0])
1826		device_set_input_line_and_vector(device, 0, HOLD_LINE, state->m_irq_vector[0]);
	1826	device->execute().set_input_line_and_vector(0, HOLD_LINE, state->m_irq_vector[0]);
1827	1827
1828	1828	state->m_cg_clear_flag = 0;
1829	1829	}

trunk/src/mess/drivers/fmtowns.c

r17814	r17815
374	374
375	375	void towns_state::wait_end()
376	376	{
377		device_set_input_line(m_maincpu,INPUT_LINE_HALT,CLEAR_LINE);
	377	m_maincpu->set_input_line(INPUT_LINE_HALT,CLEAR_LINE);
378	378	}
379	379
380	380	READ8_MEMBER(towns_state::towns_sys6c_r)
r17814	r17815
386	386	WRITE8_MEMBER(towns_state::towns_sys6c_w)
387	387	{
388	388	// halts the CPU for 1 microsecond
389		device_set_input_line(m_maincpu,INPUT_LINE_HALT,ASSERT_LINE);
	389	m_maincpu->set_input_line(INPUT_LINE_HALT,ASSERT_LINE);
390	390	m_towns_wait_timer->adjust(attotime::from_usec(1),0,attotime::never);
391	391	}
392	392
r17814	r17815
2458	2458	// CD-ROM init
2459	2459	m_towns_cd.read_timer = machine().scheduler().timer_alloc(FUNC(towns_cdrom_read_byte), (void*)machine().device("dma_1"));
2460	2460
2461		device_set_irq_callback(machine().device("maincpu"), towns_irq_callback);
	2461	machine().device("maincpu")->execute().set_irq_acknowledge_callback(towns_irq_callback);
2462	2462	machine().device("maincpu")->memory().space(AS_PROGRAM)->install_ram(0x100000,machine().device<ram_device>(RAM_TAG)->size()-1,0xffffffff,0,NULL);
2463	2463
2464	2464	}
r17814	r17815
2474	2474	{
2475	2475	address_space *program;
2476	2476
2477		m_maincpu = machine().device("maincpu");
2478		program = m_maincpu->memory().space(AS_PROGRAM);
	2477	m_maincpu = machine().device<cpu_device>("maincpu");
	2478	program = m_maincpu->space(AS_PROGRAM);
2479	2479	m_dma_1 = machine().device("dma_1");
2480	2480	m_dma_2 = machine().device("dma_2");
2481	2481	m_fdc = machine().device("fdc");

trunk/src/mess/drivers/wangpc.c

r17814	r17815
1165	1165	void wangpc_state::machine_start()
1166	1166	{
1167	1167	// register CPU IRQ callback
1168		device_set_irq_callback(m_maincpu, wangpc_irq_callback);
	1168	m_maincpu->set_irq_acknowledge_callback(wangpc_irq_callback);
1169	1169
1170	1170	// connect serial keyboard
1171	1171	m_uart->connect(m_kb);

trunk/src/mess/drivers/vboy.c

r17814	r17815
616	616	*/
617	617	if (!(data & 0x08))
618	618	{
619		device_set_input_line(m_maincpu, 1, CLEAR_LINE);
	619	m_maincpu->set_input_line(1, CLEAR_LINE);
620	620	}
621	621
622	622	if (data & 1)
r17814	r17815
1201	1201	m_vboy_regs.tcr |= 0x02;
1202	1202	if(m_vboy_regs.tcr & 8)
1203	1203	{
1204		device_set_input_line(m_maincpu, 1, ASSERT_LINE);
	1204	m_maincpu->set_input_line(1, ASSERT_LINE);
1205	1205	}
1206	1206	}
1207	1207
r17814	r17815
1227	1227	vboy_state *state = timer.machine().driver_data<vboy_state>();
1228	1228
1229	1229	if((state->m_vboy_regs.kcr & 0x80) == 0)
1230		device_set_input_line(state->m_maincpu, 0, HOLD_LINE);
	1230	state->m_maincpu->set_input_line(0, HOLD_LINE);
1231	1231	}
1232	1232
1233	1233	static PALETTE_INIT( vboy )
r17814	r17815
1243	1243	m_vip_regs.INTPND |= irq_vector;
1244	1244
1245	1245	if(m_vip_regs.INTENB & m_vip_regs.INTPND)
1246		device_set_input_line(m_maincpu, 4, ASSERT_LINE);
	1246	m_maincpu->set_input_line(4, ASSERT_LINE);
1247	1247
1248	1248	if((m_vip_regs.INTENB & m_vip_regs.INTPND) == 0)
1249		device_set_input_line(m_maincpu, 4, CLEAR_LINE);
	1249	m_maincpu->set_input_line(4, CLEAR_LINE);
1250	1250	}
1251	1251
1252	1252	/* TODO: obviously all of this needs clean-ups and better implementation ... */

trunk/src/mess/drivers/ti99_2.c

r17814	r17815
131	131	static INTERRUPT_GEN( ti99_2_vblank_interrupt )
132	132	{
133	133	ti99_2_state *state = device->machine().driver_data<ti99_2_state>();
134		device_set_input_line(device, 1, state->m_irq_state);
	134	device->execute().set_input_line(1, state->m_irq_state);
135	135	state->m_irq_state = (state->m_irq_state == ASSERT_LINE) ? CLEAR_LINE : ASSERT_LINE;
136	136	}
137	137

trunk/src/mess/drivers/fk1.c

r17814	r17815
434	434	membank("bank3")->set_base(ram + 0x8000);
435	435	membank("bank4")->set_base(ram + 0xc000);
436	436
437		device_set_irq_callback(machine().device("maincpu"), fk1_irq_callback);
	437	machine().device("maincpu")->execute().set_irq_acknowledge_callback(fk1_irq_callback);
438	438	}
439	439
440	440	SCREEN_UPDATE16_MEMBER( fk1_state )

trunk/src/mess/drivers/ng_aes.c

r17814	r17815
248	248	static void audio_cpu_irq(device_t *device, int assert)
249	249	{
250	250	neogeo_state *state = device->machine().driver_data<neogeo_state>();
251		device_set_input_line(state->m_audiocpu, 0, assert ? ASSERT_LINE : CLEAR_LINE);
	251	state->m_audiocpu->set_input_line(0, assert ? ASSERT_LINE : CLEAR_LINE);
252	252	}
253	253
254	254
255	255	static void audio_cpu_assert_nmi(running_machine &machine)
256	256	{
257	257	neogeo_state *state = machine.driver_data<neogeo_state>();
258		device_set_input_line(state->m_audiocpu, INPUT_LINE_NMI, ASSERT_LINE);
	258	state->m_audiocpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
259	259	}
260	260
261	261
262	262	WRITE8_MEMBER(ng_aes_state::audio_cpu_clear_nmi_w)
263	263	{
264		device_set_input_line(m_audiocpu, INPUT_LINE_NMI, CLEAR_LINE);
	264	m_audiocpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
265	265	}
266	266
267	267
r17814	r17815
1166	1166	state->m_irq3_pending = 1;
1167	1167
1168	1168	/* get devices */
1169		state->m_maincpu = machine.device("maincpu");
1170		state->m_audiocpu = machine.device("audiocpu");
	1169	state->m_maincpu = machine.device<cpu_device>("maincpu");
	1170	state->m_audiocpu = machine.device<cpu_device>("audiocpu");
1171	1171	state->m_upd4990a = machine.device("upd4990a");
1172	1172
1173	1173	/* register state save */

trunk/src/mess/drivers/kyocera.c

r17814	r17815
1291	1291	{
1292	1292	tandy200_state *state = timer.machine().driver_data<tandy200_state>();
1293	1293
1294		device_set_input_line(state->m_maincpu, I8085_RST75_LINE, state->m_tp);
	1294	state->m_maincpu->set_input_line(I8085_RST75_LINE, state->m_tp);
1295	1295
1296	1296	state->m_tp = !state->m_tp;
1297	1297	}

trunk/src/mess/drivers/bml3.c

r17814	r17815
381	381	if(m_firq_mask)
382	382	{
383	383	m_firq_status = 0; // clear pending firq
384		device_set_input_line(m_maincpu, M6809_FIRQ_LINE, CLEAR_LINE);
	384	m_maincpu->set_input_line(M6809_FIRQ_LINE, CLEAR_LINE);
385	385	}
386	386	}
387	387
r17814	r17815
389	389	{
390	390	UINT8 res = m_firq_status << 7;
391	391	m_firq_status = 0;
392		device_set_input_line(m_maincpu, M6809_FIRQ_LINE, CLEAR_LINE);
	392	m_maincpu->set_input_line(M6809_FIRQ_LINE, CLEAR_LINE);
393	393	return res;
394	394	}
395	395
r17814	r17815
610	610
611	611	if(!state->m_firq_mask)
612	612	{
613		device_set_input_line(state->m_maincpu, M6809_FIRQ_LINE, ASSERT_LINE);
	613	state->m_maincpu->set_input_line(M6809_FIRQ_LINE, ASSERT_LINE);
614	614	state->m_firq_status = 1;
615	615	}
616	616	}

trunk/src/mess/drivers/samcoupe.c

r17814	r17815
342	342	samcoupe_state *state = device->machine().driver_data<samcoupe_state>();
343	343
344	344	/* assert irq and a timer to set it off again */
345		device_set_input_line(device, 0, ASSERT_LINE);
	345	device->execute().set_input_line(0, ASSERT_LINE);
346	346	device->machine().scheduler().timer_set(attotime::from_usec(20), FUNC(irq_off), src);
347	347
348	348	/* adjust STATUS register */

trunk/src/mess/drivers/pockstat.c

r17814	r17815
337	337	}
338	338	if(drvstate->m_intc_regs.hold & drvstate->m_intc_regs.enable & PS_INT_IRQ_MASK)
339	339	{
340		device_set_input_line(machine.device("maincpu"), ARM7_IRQ_LINE, ASSERT_LINE);
	340	machine.device("maincpu")->execute().set_input_line(ARM7_IRQ_LINE, ASSERT_LINE);
341	341	}
342	342	else
343	343	{
344		device_set_input_line(machine.device("maincpu"), ARM7_IRQ_LINE, CLEAR_LINE);
	344	machine.device("maincpu")->execute().set_input_line(ARM7_IRQ_LINE, CLEAR_LINE);
345	345	}
346	346	if(drvstate->m_intc_regs.hold & drvstate->m_intc_regs.enable & PS_INT_FIQ_MASK)
347	347	{
348		device_set_input_line(machine.device("maincpu"), ARM7_FIRQ_LINE, ASSERT_LINE);
	348	machine.device("maincpu")->execute().set_input_line(ARM7_FIRQ_LINE, ASSERT_LINE);
349	349	}
350	350	else
351	351	{
352		device_set_input_line(machine.device("maincpu"), ARM7_FIRQ_LINE, CLEAR_LINE);
	352	machine.device("maincpu")->execute().set_input_line(ARM7_FIRQ_LINE, CLEAR_LINE);
353	353	}
354	354	}
355	355

trunk/src/mess/drivers/homez80.c

r17814	r17815
277	277	static INTERRUPT_GEN( homez80_interrupt )
278	278	{
279	279	homez80_state *state = device->machine().driver_data<homez80_state>();
280		device_set_input_line(device, 0, (state->m_irq) ? HOLD_LINE : CLEAR_LINE);
	280	device->execute().set_input_line(0, (state->m_irq) ? HOLD_LINE : CLEAR_LINE);
281	281	state->m_irq ^= 1;
282	282	}
283	283

trunk/src/mess/drivers/abc1600.c

r17814	r17815
1849	1849	void abc1600_state::machine_start()
1850	1850	{
1851	1851	// interrupt callback
1852		device_set_irq_callback(m_maincpu, abc1600_int_ack);
	1852	m_maincpu->set_irq_acknowledge_callback(abc1600_int_ack);
1853	1853
1854	1854	// HACK fill segment RAM with non-zero values or no boot
1855	1855	memset(m_segment_ram, 0xcd, 0x400);

trunk/src/mess/drivers/mod8.c

r17814	r17815
88	88
89	89	static MACHINE_RESET(mod8)
90	90	{
91		device_set_irq_callback(machine.device("maincpu"), mod8_irq_callback);
	91	machine.device("maincpu")->execute().set_irq_acknowledge_callback(mod8_irq_callback);
92	92	}
93	93
94	94	WRITE8_MEMBER( mod8_state::kbd_put )

trunk/src/mess/drivers/tandy2k.c

r17814	r17815
121	121	upd765_reset_w(m_fdc, BIT(data, 5));
122	122
123	123	// timer 0 enable
124		device_set_input_line(m_maincpu, INPUT_LINE_TMRIN0, BIT(data, 6));
	124	m_maincpu->set_input_line(INPUT_LINE_TMRIN0, BIT(data, 6));
125	125
126	126	// timer 1 enable
127		device_set_input_line(m_maincpu, INPUT_LINE_TMRIN1, BIT(data, 7));
	127	m_maincpu->set_input_line(INPUT_LINE_TMRIN1, BIT(data, 7));
128	128	}
129	129
130	130	WRITE8_MEMBER( tandy2k_state::dma_mux_w )

trunk/src/mess/drivers/x07.c

r17814	r17815
579	579	m_regs_r[0]  = 0x40;
580	580	m_regs_r[1] = m_out.data[m_out.read];
581	581	m_regs_r[2] |= 0x01;
582		device_set_input_line(m_maincpu, NSC800_RSTA, ASSERT_LINE);
	582	m_maincpu->set_input_line(NSC800_RSTA, ASSERT_LINE);
583	583	m_rsta_clear->adjust(attotime::from_msec(50));
584	584	}
585	585	}
r17814	r17815
648	648	m_regs_r[0]  = 0x40;
649	649	m_regs_r[1] = m_out.data[m_out.read];
650	650	m_regs_r[2] |= 0x01;
651		device_set_input_line(m_maincpu, NSC800_RSTA, ASSERT_LINE);
	651	m_maincpu->set_input_line(NSC800_RSTA, ASSERT_LINE);
652	652	m_rsta_clear->adjust(attotime::from_msec(50));
653	653	}
654	654	}
r17814	r17815
805	805	m_cass_data = 0;
806	806	m_bit_count = 0;
807	807
808		device_set_input_line(m_maincpu, NSC800_RSTB, ASSERT_LINE);
	808	m_maincpu->set_input_line(NSC800_RSTB, ASSERT_LINE);
809	809	m_rstb_clear->adjust(attotime::from_usec(200));
810	810
811	811	}
r17814	r17815
982	982	m_regs_r[0] = 0x80;
983	983	m_regs_r[1] = 0x05;
984	984	m_regs_r[2] |= 0x01;
985		device_set_input_line(m_maincpu, NSC800_RSTA, ASSERT_LINE );
	985	m_maincpu->set_input_line(NSC800_RSTA, ASSERT_LINE );
986	986	m_rsta_clear->adjust(attotime::from_msec(50));
987	987	}
988	988	}
r17814	r17815
998	998	memcpy(m_t6834_ram + 0x400, m_t6834_ram + 0x401, 0xff);
999	999	m_kb_size--;
1000	1000	m_regs_r[2] |= 0x01;
1001		device_set_input_line(m_maincpu, NSC800_RSTA, ASSERT_LINE);
	1001	m_maincpu->set_input_line(NSC800_RSTA, ASSERT_LINE);
1002	1002	m_rsta_clear->adjust(attotime::from_msec(50));
1003	1003	}
1004	1004	}
r17814	r17815
1370	1370	static TIMER_CALLBACK( rsta_clear )
1371	1371	{
1372	1372	x07_state *state = machine.driver_data<x07_state>();
1373		device_set_input_line(state->m_maincpu, NSC800_RSTA, CLEAR_LINE);
	1373	state->m_maincpu->set_input_line(NSC800_RSTA, CLEAR_LINE);
1374	1374
1375	1375	if (state->m_kb_size)
1376	1376	state->kb_irq();
r17814	r17815
1379	1379	static TIMER_CALLBACK( rstb_clear )
1380	1380	{
1381	1381	x07_state *state = machine.driver_data<x07_state>();
1382		device_set_input_line(state->m_maincpu, NSC800_RSTB, CLEAR_LINE);
	1382	state->m_maincpu->set_input_line(NSC800_RSTB, CLEAR_LINE);
1383	1383	}
1384	1384
1385	1385	static TIMER_CALLBACK( beep_stop )

trunk/src/mess/drivers/sm1800.c

r17814	r17815
74	74
75	75	MACHINE_RESET_MEMBER(sm1800_state)
76	76	{
77		device_set_irq_callback(m_maincpu, sm1800_irq_callback);
	77	m_maincpu->set_irq_acknowledge_callback(sm1800_irq_callback);
78	78	}
79	79
80	80	void sm1800_state::video_start()

trunk/src/mess/drivers/fm7.c

r17814	r17815
1838	1838	m_subtimer = machine().scheduler().timer_alloc(FUNC(fm7_subtimer_irq));
1839	1839	m_keyboard_timer = machine().scheduler().timer_alloc(FUNC(fm7_keyboard_poll));
1840	1840	m_fm77av_vsync_timer = machine().scheduler().timer_alloc(FUNC(fm77av_vsync));
1841		device_set_irq_callback(machine().device("maincpu"),fm7_irq_ack);
1842		device_set_irq_callback(machine().device("sub"),fm7_sub_irq_ack);
	1841	machine().device("maincpu")->execute().set_irq_acknowledge_callback(fm7_irq_ack);
	1842	machine().device("sub")->execute().set_irq_acknowledge_callback(fm7_sub_irq_ack);
1843	1843	}
1844	1844
1845	1845	static MACHINE_START(fm7)

trunk/src/mess/drivers/vidbrain.c

r17814	r17815
530	530	void vidbrain_state::machine_start()
531	531	{
532	532	// register IRQ callback
533		device_set_irq_callback(m_maincpu, vidbrain_int_ack);
	533	m_maincpu->set_irq_acknowledge_callback(vidbrain_int_ack);
534	534
535	535	// allocate timers
536	536	m_timer_ne555 = timer_alloc(TIMER_JOYSTICK);

trunk/src/mess/drivers/apple2gs.c

r17814	r17815
198	198	{
199	199	apple2gs_state *a2 = device->machine().driver_data<apple2gs_state>();
200	200
201		device_set_input_line(a2->m_maincpu, INPUT_LINE_NMI, data);
	201	a2->m_maincpu->set_input_line(INPUT_LINE_NMI, data);
202	202	}
203	203
204	204	static WRITE8_DEVICE_HANDLER(a2bus_inh_w)

trunk/src/mess/drivers/trs80m2.c

r17814	r17815
956	956	trs80m2_state::machine_start();
957	957
958	958	// register CPU IRQ callback
959		device_set_irq_callback(m_maincpu, trs80m16_irq_callback);
	959	m_maincpu->set_irq_acknowledge_callback(trs80m16_irq_callback);
960	960
961	961	// register for state saving
962	962	save_item(NAME(m_ual));

trunk/src/mess/drivers/m5.c

r17814	r17815
521	521
522	522	if (data == 0xf0)
523	523	{
524		device_set_input_line(m_fd5cpu, INPUT_LINE_RESET, ASSERT_LINE);
525		device_set_input_line(m_fd5cpu, INPUT_LINE_RESET, CLEAR_LINE);
	524	m_fd5cpu->set_input_line(INPUT_LINE_RESET, ASSERT_LINE);
	525	m_fd5cpu->set_input_line(INPUT_LINE_RESET, CLEAR_LINE);
526	526	}
527	527	}
528	528

trunk/src/mess/drivers/pv1000.c

r17814	r17815
349	349	int next_vpos = vpos + 12;
350	350
351	351	/* Set IRQ line and schedule release of IRQ line */
352		device_set_input_line( state->m_maincpu, 0, ASSERT_LINE );
	352	state->m_maincpu->set_input_line(0, ASSERT_LINE );
353	353	state->m_irq_off_timer->adjust( state->m_screen->time_until_pos(vpos, 380/2 ) );
354	354
355	355	/* Schedule next IRQ trigger */
r17814	r17815
365	365	{
366	366	pv1000_state *state = machine.driver_data<pv1000_state>();
367	367
368		device_set_input_line( state->m_maincpu, 0, CLEAR_LINE );
	368	state->m_maincpu->set_input_line(0, CLEAR_LINE );
369	369	}
370	370
371	371

trunk/src/mess/drivers/mac.c

r17814	r17815
182	182	{
183	183	if (offset == 2)
184	184	{
185		//        printf("Sonora: read monitor ID at PC=%x\n", m_maincpu->safe_pc());
	185	//        printf("Sonora: read monitor ID at PC=%x\n", m_maincpu->pc());
186	186	return (6 << 4);   // 640x480 RGB monitor
187	187	}
188	188
r17814	r17815
256	256	switch (offset)
257	257	{
258	258	case 13:   // IFR
259		//              printf("Read IER = %02x (PC=%x) 2=%02x\n", m_rbv_ier, m_maincpu->safe_pc(), m_rbv_regs[2]);
	259	//              printf("Read IER = %02x (PC=%x) 2=%02x\n", m_rbv_ier, m_maincpu->pc(), m_rbv_regs[2]);
260	260	data = m_rbv_ifr;
261	261	break;
262	262
263	263	case 14:   // IER
264		//              printf("Read IFR = %02x (PC=%x) 2=%02x\n", m_rbv_ifr, m_maincpu->safe_pc(), m_rbv_regs[2]);
	264	//              printf("Read IFR = %02x (PC=%x) 2=%02x\n", m_rbv_ifr, m_maincpu->pc(), m_rbv_regs[2]);
265	265	data = m_rbv_ier;
266	266	break;
267	267
r17814	r17815
271	271	}
272	272	}
273	273
274		//  printf("rbv_r: %x = %02x (PC=%x)\n", offset, data, m_maincpu->safe_pc());
	274	//  printf("rbv_r: %x = %02x (PC=%x)\n", offset, data, m_maincpu->pc());
275	275
276	276	return data;
277	277	}
r17814	r17815
281	281	if (offset < 0x100)
282	282	{
283	283	//      if (offset == 0x10)
284		//      printf("rbv_w: %02x to offset %x (PC=%x)\n", data, offset, m_maincpu->safe_pc());
	284	//      printf("rbv_w: %02x to offset %x (PC=%x)\n", data, offset, m_maincpu->pc());
285	285	switch (offset)
286	286	{
287	287	case 0x00:
r17814	r17815
364	364	switch (offset)
365	365	{
366	366	case 13:   // IFR
367		//              printf("%02x to IFR (PC=%x)\n", data, m_maincpu->safe_pc());
	367	//              printf("%02x to IFR (PC=%x)\n", data, m_maincpu->pc());
368	368	if (data & 0x80)
369	369	{
370	370	data = 0x7f;
r17814	r17815
373	373	break;
374	374
375	375	case 14:   // IER
376		//              printf("%02x to IER (PC=%x)\n", data, m_maincpu->safe_pc());
	376	//              printf("%02x to IER (PC=%x)\n", data, m_maincpu->pc());
377	377	if (data & 0x80)   // 1 bits write 1s
378	378	{
379	379	m_rbv_ier |= data & 0x7f;
r17814	r17815
440	440
441	441	READ8_MEMBER(mac_state::scciop_r)
442	442	{
443		//  printf("scciop_r @ %x (PC=%x)\n", offset, m_maincpu->safe_pc());
	443	//  printf("scciop_r @ %x (PC=%x)\n", offset, m_maincpu->pc());
444	444	return 0;
445	445	}
446	446
447	447	WRITE8_MEMBER(mac_state::scciop_w)
448	448	{
449		//  printf("scciop_w %x @ %x (PC=%x)\n", data, offset, m_maincpu->safe_pc());
	449	//  printf("scciop_w %x @ %x (PC=%x)\n", data, offset, m_maincpu->pc());
450	450	}
451	451
452	452	READ8_MEMBER(mac_state::swimiop_r)
453	453	{
454		//  printf("swimiop_r @ %x (PC=%x)\n", offset, m_maincpu->safe_pc());
	454	//  printf("swimiop_r @ %x (PC=%x)\n", offset, m_maincpu->pc());
455	455	return 0;
456	456	}
457	457
458	458	WRITE8_MEMBER(mac_state::swimiop_w)
459	459	{
460		//  printf("swimiop_w %x @ %x (PC=%x)\n", data, offset, m_maincpu->safe_pc());
	460	//  printf("swimiop_w %x @ %x (PC=%x)\n", data, offset, m_maincpu->pc());
461	461	}
462	462
463	463	READ8_MEMBER(mac_state::pmac_diag_r)
r17814	r17815
478	478
479	479	WRITE8_MEMBER(mac_state::amic_dma_w)
480	480	{
481		//  printf("amic_dma_w: %02x at %x (PC=%x)\n", data, offset+0x1000, m_maincpu->safe_pc());
	481	//  printf("amic_dma_w: %02x at %x (PC=%x)\n", data, offset+0x1000, m_maincpu->pc());
482	482	}
483	483
484	484	// HMC has one register: a 35-bit shift register which is accessed one bit at a time (see pmac6100 code at 4030383c which makes this obvious)

trunk/src/mess/drivers/pk8000.c

r17814	r17815
307	307
308	308	static INTERRUPT_GEN( pk8000_interrupt )
309	309	{
310		device_set_input_line(device, 0, HOLD_LINE);
	310	device->execute().set_input_line(0, HOLD_LINE);
311	311	}
312	312
313	313	static IRQ_CALLBACK(pk8000_irq_callback)
r17814	r17815
319	319	static MACHINE_RESET(pk8000)
320	320	{
321	321	pk8000_set_bank(machine,0);
322		device_set_irq_callback(machine.device("maincpu"), pk8000_irq_callback);
	322	machine.device("maincpu")->execute().set_irq_acknowledge_callback(pk8000_irq_callback);
323	323	}
324	324
325	325	static VIDEO_START( pk8000 )

trunk/src/mess/drivers/prestige.c

r17814	r17815
396	396	UINT32 vector;
397	397	prestige_state *state = device->machine().driver_data<prestige_state>();
398	398
399		device_set_input_line(state->m_maincpu, 0, CLEAR_LINE);
	399	state->m_maincpu->set_input_line(0, CLEAR_LINE);
400	400
401	401	if (state->m_irq_counter == 0x02)
402	402	{
r17814	r17815
417	417	UINT8 *ram = m_ram->pointer();
418	418	memset(ram, 0x00, m_ram->size());
419	419
420		device_set_irq_callback(m_maincpu, prestige_int_ack);
	420	m_maincpu->set_irq_acknowledge_callback(prestige_int_ack);
421	421
422	422	membank("bank1")->configure_entries(0, 64, memregion("maincpu")->base(), 0x4000);
423	423	membank("bank2")->configure_entries(0, 64, memregion("maincpu")->base(), 0x4000);

trunk/src/mess/drivers/ngp.c

r17814	r17815
258	258	switch( data )
259	259	{
260	260	case 0x55:      /* Enable Z80 */
261		device_resume( m_z80, SUSPEND_REASON_HALT );
	261	m_z80->execute().resume(SUSPEND_REASON_HALT );
262	262	m_z80->reset();
263		device_set_input_line( m_z80, 0, CLEAR_LINE );
	263	m_z80->execute().set_input_line(0, CLEAR_LINE );
264	264	break;
265	265	case 0xAA:      /* Disable Z80 */
266		device_suspend( m_z80, SUSPEND_REASON_HALT, 1 );
	266	m_z80->execute().suspend(SUSPEND_REASON_HALT, 1 );
267	267	break;
268	268	}
269	269	break;
270	270
271	271	case 0x3a:   /* Trigger Z80 NMI */
272		device_set_input_line( m_z80, INPUT_LINE_NMI, PULSE_LINE );
	272	m_z80->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE );
273	273	break;
274	274	}
275	275	m_io_reg[offset] = data;
r17814	r17815
525	525
526	526	WRITE8_MEMBER( ngp_state::ngp_z80_signal_main_w )
527	527	{
528		device_set_input_line( m_tlcs900, TLCS900_INT5, ASSERT_LINE );
	528	m_tlcs900->execute().set_input_line(TLCS900_INT5, ASSERT_LINE );
529	529	}
530	530
531	531
r17814	r17815
539	539
540	540	WRITE8_MEMBER( ngp_state::ngp_z80_clear_irq )
541	541	{
542		device_set_input_line( m_z80, 0, CLEAR_LINE );
	542	m_z80->execute().set_input_line(0, CLEAR_LINE );
543	543
544	544	/* I am not exactly sure what causes the maincpu INT5 signal to be cleared. This will do for now. */
545		device_set_input_line( m_tlcs900, TLCS900_INT5, CLEAR_LINE );
	545	m_tlcs900->execute().set_input_line(TLCS900_INT5, CLEAR_LINE );
546	546	}
547	547
548	548
r17814	r17815
557	557
558	558	if ( state->m_io_reg[0x33] & 0x04 )
559	559	{
560		device_set_input_line( state->m_tlcs900, TLCS900_NMI,
	560	state->m_tlcs900->execute().set_input_line(TLCS900_NMI,
561	561	(field.machine().root_device().ioport("Power")->read() & 0x01 ) ? CLEAR_LINE : ASSERT_LINE );
562	562	}
563	563	}
r17814	r17815
581	581
582	582	WRITE8_MEMBER( ngp_state::ngp_vblank_pin_w )
583	583	{
584		device_set_input_line( m_tlcs900, TLCS900_INT4, data ? ASSERT_LINE : CLEAR_LINE );
	584	m_tlcs900->execute().set_input_line(TLCS900_INT4, data ? ASSERT_LINE : CLEAR_LINE );
585	585	}
586	586
587	587
588	588	WRITE8_MEMBER( ngp_state::ngp_hblank_pin_w )
589	589	{
590		device_set_input_line( m_tlcs900, TLCS900_TIO, data ? ASSERT_LINE : CLEAR_LINE );
	590	m_tlcs900->execute().set_input_line(TLCS900_TIO, data ? ASSERT_LINE : CLEAR_LINE );
591	591	}
592	592
593	593
594	594	WRITE8_MEMBER( ngp_state::ngp_tlcs900_to3 )
595	595	{
596	596	if ( data && ! m_old_to3 )
597		device_set_input_line( m_z80, 0, ASSERT_LINE );
	597	m_z80->execute().set_input_line(0, ASSERT_LINE );
598	598
599	599	m_old_to3 = data;
600	600	}
r17814	r17815
617	617	m_dac_r = machine().device<dac_device>( "dac_r" );
618	618	m_k1ge = machine().device( "k1ge" );
619	619
620		device_suspend( m_z80, SUSPEND_REASON_HALT, 1 );
621		device_set_input_line( m_z80, 0, CLEAR_LINE );
	620	m_z80->execute().suspend(SUSPEND_REASON_HALT, 1 );
	621	m_z80->execute().set_input_line(0, CLEAR_LINE );
622	622	}
623	623
624	624

trunk/src/mess/drivers/pce220.c

r17814	r17815
618	618
619	619	if (state->m_irq_mask & IRQ_FLAG_KEY)
620	620	{
621		device_set_input_line( state->m_maincpu, 0, newval ? ASSERT_LINE : CLEAR_LINE );
	621	state->m_maincpu->set_input_line(0, newval ? ASSERT_LINE : CLEAR_LINE );
622	622
623	623	state->m_irq_flag = (state->m_irq_flag & 0xfe) | (newval & 0x01);
624	624	}
r17814	r17815
630	630
631	631	if (state->m_irq_mask & IRQ_FLAG_ON)
632	632	{
633		device_set_input_line( state->m_maincpu, 0, newval ? ASSERT_LINE : CLEAR_LINE );
	633	state->m_maincpu->set_input_line(0, newval ? ASSERT_LINE : CLEAR_LINE );
634	634
635	635	state->m_irq_flag = (state->m_irq_flag & 0xfd) | ((newval & 0x01)<<1);
636	636	}
r17814	r17815
907	907
908	908	if (state->m_irq_mask & IRQ_FLAG_TIMER)
909	909	{
910		device_set_input_line( state->m_maincpu, 0, HOLD_LINE );
	910	state->m_maincpu->set_input_line(0, HOLD_LINE );
911	911
912	912	state->m_irq_flag = (state->m_irq_flag & 0xfb) | (state->m_timer_status<<2);
913	913	}

trunk/src/mess/drivers/paso1600.c

r17814	r17815
292	292	static MACHINE_START(paso1600)
293	293	{
294	294	paso1600_state *state = machine.driver_data<paso1600_state>();
295		device_set_irq_callback(state->m_maincpu, paso1600_irq_callback);
	295	state->m_maincpu->set_irq_acknowledge_callback(paso1600_irq_callback);
296	296	}
297	297
298	298

trunk/src/mess/drivers/vt100.c

r17814	r17815
356	356
357	357	state->m_key_scan = 0;
358	358
359		device_set_irq_callback(machine.device("maincpu"), vt100_irq_callback);
	359	machine.device("maincpu")->execute().set_irq_acknowledge_callback(vt100_irq_callback);
360	360	}
361	361
362	362	READ8_MEMBER( vt100_state::vt100_read_video_ram_r )
r17814	r17815
381	381	{
382	382	vt100_state *state = device->machine().driver_data<vt100_state>();
383	383	state->m_vertical_int = 1;
384		device_set_input_line(device, 0, HOLD_LINE);
	384	device->execute().set_input_line(0, HOLD_LINE);
385	385	}
386	386
387	387	/* F4 Character Displayer */

trunk/src/mess/drivers/cxhumax.c

r17814	r17815
101	101
102	102	if((m_intctrl_regs[INTREG(INTGROUP2, INTIRQ)] & m_intctrl_regs[INTREG(INTGROUP2, INTENABLE)])
103	103	|| (m_intctrl_regs[INTREG(INTGROUP1, INTIRQ)] & m_intctrl_regs[INTREG(INTGROUP1, INTENABLE)]))
104		device_set_input_line(machine().device("maincpu"), ARM7_IRQ_LINE, ASSERT_LINE);
	104	machine().device("maincpu")->execute().set_input_line(ARM7_IRQ_LINE, ASSERT_LINE);
105	105
106	106	break;
107	107	default:
r17814	r17815
322	322
323	323	/* Interrupt if Timer interrupt is not masked in ITC_INTENABLE_REG */
324	324	if (state->m_intctrl_regs[INTREG(INTGROUP2, INTENABLE)] & INT_TIMER_BIT)
325		device_set_input_line(machine.device("maincpu"), ARM7_IRQ_LINE, ASSERT_LINE);
	325	machine.device("maincpu")->execute().set_input_line(ARM7_IRQ_LINE, ASSERT_LINE);
326	326	}
327	327	}
328	328	attotime period = attotime::from_hz(XTAL_54MHz)*state->m_timer_regs.timer[param].timebase;
r17814	r17815
418	418
419	419	/* If INT is enabled at INT Ctrl raise it */
420	420	if(m_intctrl_regs[INTREG(INTGROUP1, INTENABLE)]&INT_UART2_BIT) {
421		device_set_input_line(machine().device("maincpu"), ARM7_IRQ_LINE, ASSERT_LINE);
	421	machine().device("maincpu")->execute().set_input_line(ARM7_IRQ_LINE, ASSERT_LINE);
422	422	}
423	423	}
424	424	}
r17814	r17815
548	548	/* check if */
549	549	if((m_intctrl_regs[INTREG(INTGROUP2, INTIRQ)] & m_intctrl_regs[INTREG(INTGROUP2, INTENABLE)])
550	550	|| (m_intctrl_regs[INTREG(INTGROUP1, INTIRQ)] & m_intctrl_regs[INTREG(INTGROUP1, INTENABLE)]))
551		device_set_input_line(machine().device("maincpu"), ARM7_IRQ_LINE, ASSERT_LINE);
	551	machine().device("maincpu")->execute().set_input_line(ARM7_IRQ_LINE, ASSERT_LINE);
552	552	else
553		device_set_input_line(machine().device("maincpu"), ARM7_IRQ_LINE, CLEAR_LINE);
	553	machine().device("maincpu")->execute().set_input_line(ARM7_IRQ_LINE, CLEAR_LINE);
554	554
555	555	}
556	556
r17814	r17815
734	734	m_intctrl_regs[INTREG(INTGROUP1, INTSTATSET)] |= 1<<7;
735	735	if (m_intctrl_regs[INTREG(INTGROUP1, INTENABLE)] & (1<<7)) {
736	736	verboselog( machine(), 9, "(I2C1) Int\n" );
737		device_set_input_line(machine().device("maincpu"), ARM7_IRQ_LINE, ASSERT_LINE);
	737	machine().device("maincpu")->execute().set_input_line(ARM7_IRQ_LINE, ASSERT_LINE);
738	738	}
739	739	break;
740	740	case I2C_STAT_REG:

trunk/src/mess/drivers/vt240.c

r17814	r17815
142	142
143	143	static INTERRUPT_GEN( vt240_irq )
144	144	{
145		//device_set_input_line(device, I8085_RST65_LINE, ASSERT_LINE);
	145	//device->execute().set_input_line(I8085_RST65_LINE, ASSERT_LINE);
146	146	}
147	147
148	148	static const gfx_layout vt240_chars_8x8 =

trunk/src/mess/drivers/apollo.c

r17814	r17815
1080	1080	{
1081	1081	//  MLOG1(("driver_init_dn3500"));
1082	1082
1083		device_set_irq_callback(machine().device(MAINCPU), apollo_irq_acknowledge);
	1083	machine().device(MAINCPU)->execute().set_irq_acknowledge_callback(apollo_irq_acknowledge);
1084	1084
1085	1085	/* hook the RESET line, which resets a slew of other components */
1086	1086	m68k_set_reset_callback(machine().device(MAINCPU), apollo_reset_instr_callback);

trunk/src/mess/drivers/dc.c

r17814	r17815
45	45	static READ64_HANDLER( dcus_idle_skip_r )
46	46	{
47	47	if (space->device().safe_pc()==0xc0ba52a)
48		device_spin_until_time(&space->device(), attotime::from_usec(2500));
	48	space->device().execute().spin_until_time(attotime::from_usec(2500));
49	49	//  device_spinuntil_int(&space->device());
50	50
51	51	return dc_ram[0x2303b0/8];
r17814	r17815
54	54	static READ64_HANDLER( dcjp_idle_skip_r )
55	55	{
56	56	if (space->device().safe_pc()==0xc0bac62)
57		device_spin_until_time(&space->device(), attotime::from_usec(2500));
	57	space->device().execute().spin_until_time(attotime::from_usec(2500));
58	58	//  device_spinuntil_int(&space->device());
59	59
60	60	return dc_ram[0x2302f8/8];

trunk/src/mess/drivers/pasogo.c

r17814	r17815
460	460
461	461	static MACHINE_RESET( pasogo )
462	462	{
463		device_set_irq_callback(machine.device("maincpu"), pasogo_irq_callback);
	463	machine.device("maincpu")->execute().set_irq_acknowledge_callback(pasogo_irq_callback);
464	464	}
465	465
466	466	//static const unsigned i86_address_mask = 0x000fffff;

trunk/src/mess/drivers/x1twin.c

r17814	r17815
110	110	//address_space *space = field.machine().device("x1_cpu")->memory().space(AS_PROGRAM);
111	111	x1twin_state *state = field.machine().driver_data<x1twin_state>();
112	112
113		device_set_input_line(state->m_x1_cpu, INPUT_LINE_RESET, newval ? CLEAR_LINE : ASSERT_LINE);
	113	state->m_x1_cpu->set_input_line(INPUT_LINE_RESET, newval ? CLEAR_LINE : ASSERT_LINE);
114	114
115	115	state->m_ram_bank = 0x00;
116	116	if(state->m_is_turbo) { state->m_ex_bank = 0x10; }
r17814	r17815
122	122	{
123	123	x1twin_state *state = field.machine().driver_data<x1twin_state>();
124	124
125		device_set_input_line(state->m_x1_cpu, INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
	125	state->m_x1_cpu->set_input_line(INPUT_LINE_NMI, newval ? CLEAR_LINE : ASSERT_LINE);
126	126	}
127	127
128	128	INPUT_PORTS_START( x1twin )

trunk/src/mess/drivers/eacc.c

r17814	r17815
138	138	eacc_state *state = timer.machine().driver_data<eacc_state>();
139	139	state->m_cb1 ^= 1; // 15hz
140	140	if (state->m_cb2)
141		device_set_input_line(state->m_maincpu, M6800_IRQ_LINE, ASSERT_LINE);
	141	state->m_maincpu->set_input_line(M6800_IRQ_LINE, ASSERT_LINE);
142	142	}
143	143
144	144	static TIMER_DEVICE_CALLBACK( eacc_nmi )
r17814	r17815
148	148	if (state->m_cb2)
149	149	{
150	150	state->m_nmi = true;
151		device_set_input_line(state->m_maincpu, INPUT_LINE_NMI, ASSERT_LINE);
	151	state->m_maincpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
152	152	}
153	153	}
154	154
r17814	r17815
226	226	{
227	227	if (m_nmi)
228	228	{
229		device_set_input_line(m_maincpu, INPUT_LINE_NMI, CLEAR_LINE);
	229	m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
230	230	m_nmi = false;
231	231	}
232	232	m_digit = data & 0xf8;

trunk/src/mess/drivers/x68k.c

r17814	r17815
2706	2706
2707	2707	mfp_init(machine());
2708	2708
2709		device_set_irq_callback(machine().device("maincpu"), x68k_int_ack);
	2709	machine().device("maincpu")->execute().set_irq_acknowledge_callback(x68k_int_ack);
2710	2710
2711	2711	// init keyboard
2712	2712	m_keyboard.delay = 500;  // 3*100+200

trunk/src/mess/drivers/ondra.c

r17814	r17815
107	107
108	108	static INTERRUPT_GEN( ondra_interrupt )
109	109	{
110		device_set_input_line(device, 0, HOLD_LINE);
	110	device->execute().set_input_line(0, HOLD_LINE);
111	111	}
112	112
113	113	static const cassette_interface ondra_cassette_interface =

trunk/src/mess/drivers/geneve.c

r17814	r17815
541	541	WRITE8_MEMBER( geneve::tms9901_interrupt )
542	542	{
543	543	/* INTREQ is connected to INT1. */
544		device_execute(m_cpu)->set_input_line(INPUT_LINE_99XX_INT1, data);
	544	m_cpu->set_input_line(INPUT_LINE_99XX_INT1, data);
545	545	}
546	546
547	547	/* tms9901 setup */
r17814	r17815
585	585	{
586	586	m_inta = (state!=0)? ASSERT_LINE : CLEAR_LINE;
587	587	m_tms9901->set_single_int(1, state);
588		device_execute(m_cpu)->set_input_line(INPUT_LINE_99XX_INT4, state);
	588	m_cpu->set_input_line(INPUT_LINE_99XX_INT4, state);
589	589	}
590	590
591	591	/*

trunk/src/mess/drivers/victor9k.c

r17814	r17815
825	825	*/
826	826
827	827	// motor speed controller reset
828		device_set_input_line(m_fdc_cpu, INPUT_LINE_RESET, BIT(data, 2));
	828	m_fdc_cpu->set_input_line(INPUT_LINE_RESET, BIT(data, 2));
829	829
830	830	// stepper enable A
831	831	m_se[0] = BIT(data, 6);
r17814	r17815
923	923	void victor9k_state::machine_start()
924	924	{
925	925	// set interrupt callback
926		device_set_irq_callback(m_maincpu, victor9k_irq_callback);
	926	m_maincpu->set_irq_acknowledge_callback(victor9k_irq_callback);
927	927
928	928	// memory banking
929	929	address_space *program = m_maincpu->space(AS_PROGRAM);

trunk/src/mess/drivers/socrates.c

r17814	r17815
268	268
269	269	WRITE8_MEMBER(socrates_state::kbmcu_strobe) // strobe the keyboard MCU
270	270	{
271		//logerror("0x%04X: kbmcu written with %02X!\n", m_maincpu->safe_pc(), data); //if (m_maincpu->safe_pc() != 0x31D)
	271	//logerror("0x%04X: kbmcu written with %02X!\n", m_maincpu->pc(), data); //if (m_maincpu->pc() != 0x31D)
272	272	// if two writes happen within one frame, reset the keyboard latches
273	273	m_kbmcu_rscount++;
274	274	if (m_kbmcu_rscount > 1)
r17814	r17815
912	912	static INTERRUPT_GEN( assert_irq )
913	913	{
914	914	socrates_state *state = device->machine().driver_data<socrates_state>();
915		device_set_input_line(device, 0, ASSERT_LINE);
	915	device->execute().set_input_line(0, ASSERT_LINE);
916	916	device->machine().scheduler().timer_set(downcast<cpu_device *>(device)->cycles_to_attotime(44), FUNC(clear_irq_cb));
917	917	// 44 is a complete and total guess, need to properly measure how many clocks/microseconds the int line is high for.
918	918	state->m_vblankstate = 1;

trunk/src/mess/drivers/pc8801.c

r17814	r17815
1887	1887
1888	1888	READ8_MEMBER(pc8801_state::upd765_tc_r)
1889	1889	{
1890		//printf("%04x 1\n",m_fdccpu->safe_pc());
	1890	//printf("%04x 1\n",m_fdccpu->pc());
1891	1891
1892	1892	upd765_tc_w(machine().device("upd765"), 1);
1893	1893	//TODO: I'm not convinced that this works correctly with current hook-up ... 1000 usec is needed by Aploon, a bigger value breaks Alpha.
r17814	r17815
2411	2411	{
2412	2412	state->m_vrtc_irq_latch = 1;
2413	2413	//IRQ_LOG(("vrtc\n"));
2414		device_set_input_line(device,0,HOLD_LINE);
	2414	device->execute().set_input_line(0,HOLD_LINE);
2415	2415	}
2416	2416	}
2417	2417	#endif
r17814	r17815
2420	2420	{
2421	2421	pc8801_state *state = machine.driver_data<pc8801_state>();
2422	2422
2423		device_set_irq_callback(machine.device("maincpu"), pc8801_irq_callback);
	2423	machine.device("maincpu")->execute().set_irq_acknowledge_callback(pc8801_irq_callback);
2424	2424
2425	2425	state->m_rtc->cs_w(1);
2426	2426	state->m_rtc->oe_w(1);
r17814	r17815
2447	2447	state->m_fdc_irq_opcode = 0; //TODO: copied from PC-88VA, could be wrong here ... should be 0x7f ld a,a in the latter case
2448	2448	state->m_mouse.phase = 0;
2449	2449
2450		device_set_input_line_vector(machine.device("fdccpu"), 0, 0);
	2450	machine.device("fdccpu")->execute().set_input_line_vector(0, 0);
2451	2451
2452	2452	{
2453	2453	state->m_txt_color = 2;

trunk/src/mess/drivers/bw2.c

r17814	r17815
226	226	{
227	227	if (m_maincpu->state_int(Z80_HALT))
228	228	{
229		device_set_input_line(m_maincpu, INPUT_LINE_NMI, HOLD_LINE);
	229	m_maincpu->set_input_line(INPUT_LINE_NMI, HOLD_LINE);
230	230	}
231	231	}
232	232	else
233	233	{
234		device_set_input_line(m_maincpu, INPUT_LINE_NMI, CLEAR_LINE);
	234	m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
235	235	}
236	236	}
237	237

trunk/src/mess/drivers/enterp.c

r17814	r17815
172	172
173	173	static MACHINE_RESET( enterprise )
174	174	{
175		device_set_input_line_vector(machine.device("maincpu"), 0, 0xff);
	175	machine.device("maincpu")->execute().set_input_line_vector(0, 0xff);
176	176	}
177	177
178	178

trunk/src/mess/drivers/jr200.c

r17814	r17815
281	281
282	282	static TIMER_CALLBACK(timer_d_callback)
283	283	{
284		device_set_input_line(machine.firstcpu, 0, HOLD_LINE);
	284	machine.firstcpu->set_input_line(0, HOLD_LINE);
285	285	}
286	286
287	287	READ8_MEMBER(jr200_state::mn1271_io_r)

trunk/src/mess/drivers/portfoli.c

r17814	r17815
114	114	{
115	115	int level = (m_ip & m_ie) ? ASSERT_LINE : CLEAR_LINE;
116	116
117		device_set_input_line(m_maincpu, INPUT_LINE_INT0, level);
	117	m_maincpu->set_input_line(INPUT_LINE_INT0, level);
118	118	}
119	119
120	120	//-------------------------------------------------
r17814	r17815
766	766	address_space *program = m_maincpu->space(AS_PROGRAM);
767	767
768	768	/* set CPU interrupt vector callback */
769		device_set_irq_callback(m_maincpu, portfolio_int_ack);
	769	m_maincpu->set_irq_acknowledge_callback(portfolio_int_ack);
770	770
771	771	/* memory expansions */
772	772	switch (machine().device<ram_device>(RAM_TAG)->size())

trunk/src/mess/drivers/apricot.c

r17814	r17815
264	264	prg->unmap_readwrite(0x40000, 0xeffff);
265	265	prg->install_ram(0x00000, ram_size - 1, ram);
266	266
267		device_set_irq_callback(m_maincpu, apricot_irq_ack);
	267	m_maincpu->set_irq_acknowledge_callback(apricot_irq_ack);
268	268
269	269	m_video_mode = 0;
270	270	m_display_on = 1;

trunk/src/mess/drivers/gp32.c

r17814	r17815
492	492	}
493	493	state->m_s3c240x_irq_regs[4] |= (1 << int_type); // INTPND
494	494	state->m_s3c240x_irq_regs[5] = int_type; // INTOFFSET
495		device_set_input_line( machine.device( "maincpu"), ARM7_IRQ_LINE, ASSERT_LINE);
	495	machine.device( "maincpu")->execute().set_input_line(ARM7_IRQ_LINE, ASSERT_LINE);
496	496	}
497	497	else
498	498	{
499		device_set_input_line( machine.device( "maincpu"), ARM7_IRQ_LINE, CLEAR_LINE);
	499	machine.device( "maincpu")->execute().set_input_line(ARM7_IRQ_LINE, CLEAR_LINE);
500	500	}
501	501	}
502	502
r17814	r17815
509	509	state->m_s3c240x_irq_regs[0] |= (1 << int_type); // SRCPND
510	510	state->m_s3c240x_irq_regs[4] |= (1 << int_type); // INTPND
511	511	state->m_s3c240x_irq_regs[5] = int_type; // INTOFFSET
512		device_set_input_line( machine.device( "maincpu"), ARM7_IRQ_LINE, ASSERT_LINE);
	512	machine.device( "maincpu")->execute().set_input_line(ARM7_IRQ_LINE, ASSERT_LINE);
513	513	}
514	514	else
515	515	{

trunk/src/mess/drivers/supracan.c

r17814	r17815
1142	1142	{
1143	1143	if(m_sound_irq_enable_reg & m_sound_irq_source_reg)
1144	1144	{
1145		device_set_input_line(machine().device("soundcpu"), 0, ASSERT_LINE);
	1145	machine().device("soundcpu")->execute().set_input_line(0, ASSERT_LINE);
1146	1146	}
1147	1147	else
1148	1148	{
1149		device_set_input_line(machine().device("soundcpu"), 0, CLEAR_LINE);
	1149	machine().device("soundcpu")->execute().set_input_line(0, CLEAR_LINE);
1150	1150	}
1151	1151	}
1152	1152	break;
r17814	r17815
1156	1156	if(!mem->debugger_access()) verboselog(m_hack_68k_to_6502_access ? "maincpu" : "soundcpu", machine(), 3, "supracan_soundreg_r: IRQ source: %04x\n", data);
1157	1157	if(!mem->debugger_access())
1158	1158	{
1159		device_set_input_line(machine().device("soundcpu"), 0, CLEAR_LINE);
	1159	machine().device("soundcpu")->execute().set_input_line(0, CLEAR_LINE);
1160	1160	}
1161	1161	break;
1162	1162	case 0x420:
r17814	r17815
1190	1190	if(m_sound_cpu_68k_irq_reg &~ data)
1191	1191	{
1192	1192	verboselog(m_hack_68k_to_6502_access ? "maincpu" : "soundcpu", machine(), 0, "supracan_soundreg_w: sound_cpu_68k_irq_reg: %04x: Triggering M68k IRQ\n", data);
1193		device_set_input_line(m_maincpu, 7, HOLD_LINE);
	1193	m_maincpu->set_input_line(7, HOLD_LINE);
1194	1194	}
1195	1195	else
1196	1196	{
r17814	r17815
1420	1420	switch ( offset )
1421	1421	{
1422	1422	case 0x000a/2:  /* Sound cpu IRQ request. */
1423		device_set_input_line(machine().device("soundcpu"), 0, ASSERT_LINE);
	1423	machine().device("soundcpu")->execute().set_input_line(0, ASSERT_LINE);
1424	1424	break;
1425	1425	case 0x001c/2:   /* Sound cpu control. Bit 0 tied to sound cpu RESET line */
1426	1426	if(data & 0x01)
r17814	r17815
1460	1460	if(!mem->debugger_access())
1461	1461	{
1462	1462	//verboselog("maincpu", machine(), 0, "read video IRQ flags (%04x)\n", data);
1463		device_set_input_line(m_maincpu, 7, CLEAR_LINE);
	1463	m_maincpu->set_input_line(7, CLEAR_LINE);
1464	1464	}
1465	1465	break;
1466	1466	case 0x02/2: // Current scanline
r17814	r17815
1489	1489	{
1490	1490	supracan_state *state = machine.driver_data<supracan_state>();
1491	1491
1492		device_set_input_line(state->m_maincpu, 3, HOLD_LINE);
	1492	state->m_maincpu->set_input_line(3, HOLD_LINE);
1493	1493
1494	1494	state->m_hbl_timer->adjust(attotime::never);
1495	1495	}
r17814	r17815
1498	1498	{
1499	1499	supracan_state *state = machine.driver_data<supracan_state>();
1500	1500
1501		device_set_input_line(state->m_maincpu, 5, HOLD_LINE);
	1501	state->m_maincpu->set_input_line(5, HOLD_LINE);
1502	1502
1503	1503	state->m_line_on_timer->adjust(attotime::never);
1504	1504	}
r17814	r17815
1507	1507	{
1508	1508	supracan_state *state = machine.driver_data<supracan_state>();
1509	1509
1510		device_set_input_line(state->m_maincpu, 5, CLEAR_LINE);
	1510	state->m_maincpu->set_input_line(5, CLEAR_LINE);
1511	1511
1512	1512	state->m_line_on_timer->adjust(attotime::never);
1513	1513	}
r17814	r17815
1541	1541	if(state->m_irq_mask & 1)
1542	1542	{
1543	1543	verboselog("maincpu", machine, 0, "Triggering VBL IRQ\n\n");
1544		device_set_input_line(state->m_maincpu, 7, HOLD_LINE);
	1544	state->m_maincpu->set_input_line(7, HOLD_LINE);
1545	1545	}
1546	1546	break;
1547	1547	}
r17814	r17815
1724	1724	#if 0
1725	1725	if(!m_irq_mask && !m_hbl_mask)
1726	1726	{
1727		device_set_input_line(m_maincpu, 7, CLEAR_LINE);
	1727	m_maincpu->set_input_line(7, CLEAR_LINE);
1728	1728	}
1729	1729	#endif
1730	1730	verboselog("maincpu", machine(), 3, "irq_mask = %04x\n", data);
r17814	r17815
1878	1878
1879	1879	if(state->m_irq_mask)
1880	1880	{
1881		device_set_input_line(device, 7, HOLD_LINE);
	1881	device->execute().set_input_line(7, HOLD_LINE);
1882	1882	}
1883	1883	#endif
1884	1884	}
r17814	r17815
1891	1891
1892	1892	if(state->m_sound_irq_enable_reg & state->m_sound_irq_source_reg)
1893	1893	{
1894		device_set_input_line(device->machine().device("soundcpu"), 0, ASSERT_LINE);
	1894	device->machine().device("soundcpu")->execute().set_input_line(0, ASSERT_LINE);
1895	1895	}
1896	1896	else
1897	1897	{
1898		device_set_input_line(device->machine().device("soundcpu"), 0, CLEAR_LINE);
	1898	device->machine().device("soundcpu")->execute().set_input_line(0, CLEAR_LINE);
1899	1899	}
1900	1900	}
1901	1901

trunk/src/mess/drivers/vk100.c

r17814	r17815
561	561	{
562	562	UINT8 dipswitchLUT[8] = { 1,3,5,7,6,4,2,0 }; // the dipswitches map in a weird order to offsets
563	563	#ifdef SYSTAT_A_VERBOSE
564		if (m_maincpu->safe_pc() != 0x31D) logerror("0x%04X: SYSTAT_A Read!\n", m_maincpu->safe_pc());
	564	if (m_maincpu->pc() != 0x31D) logerror("0x%04X: SYSTAT_A Read!\n", m_maincpu->pc());
565	565	#endif
566	566	return ((m_vgGO?0:1)<<7)|(vram_read(machine())<<3)|(((ioport("SWITCHES")->read()>>dipswitchLUT[offset])&1)?0x4:0)|(m_vsync?0x2:0);
567	567	}
r17814	r17815
585	585	READ8_MEMBER(vk100_state::SYSTAT_B)
586	586	{
587	587	#ifdef SYSTAT_B_VERBOSE
588		logerror("0x%04X: SYSTAT_B Read!\n", m_maincpu->safe_pc());
	588	logerror("0x%04X: SYSTAT_B Read!\n", m_maincpu->pc());
589	589	#endif
590	590	return (m_ACTS<<7)|0x7F;
591	591	}
r17814	r17815
875	875	static WRITE_LINE_DEVICE_HANDLER(crtc_vsync)
876	876	{
877	877	vk100_state *m_state = device->machine().driver_data<vk100_state>();
878		device_set_input_line(m_state->m_maincpu, I8085_RST75_LINE, state? ASSERT_LINE : CLEAR_LINE);
	878	m_state->m_maincpu->set_input_line(I8085_RST75_LINE, state? ASSERT_LINE : CLEAR_LINE);
879	879	m_state->m_vsync = state;
880	880	}
881	881
882	882	static WRITE_LINE_DEVICE_HANDLER(i8251_rxrdy_int)
883	883	{
884	884	vk100_state *m_state = device->machine().driver_data<vk100_state>();
885		device_set_input_line(m_state->m_maincpu, I8085_RST65_LINE, state?ASSERT_LINE:CLEAR_LINE);
	885	m_state->m_maincpu->set_input_line(I8085_RST65_LINE, state?ASSERT_LINE:CLEAR_LINE);
886	886	}
887	887
888	888	static WRITE_LINE_DEVICE_HANDLER(i8251_txrdy_int)
889	889	{
890	890	vk100_state *m_state = device->machine().driver_data<vk100_state>();
891		device_set_input_line(m_state->m_maincpu, I8085_RST55_LINE, state?ASSERT_LINE:CLEAR_LINE);
	891	m_state->m_maincpu->set_input_line(I8085_RST55_LINE, state?ASSERT_LINE:CLEAR_LINE);
892	892	}
893	893
894	894	static WRITE_LINE_DEVICE_HANDLER(i8251_rts)

trunk/src/mess/drivers/tek405x.c

r17814	r17815
64	64	{
65	65	int state = m_kb_pia_irqa | m_kb_pia_irqb | m_x_pia_irqa | m_x_pia_irqb | m_gpib_pia_irqa | m_gpib_pia_irqb | m_com_pia_irqa | m_com_pia_irqb | m_acia_irq;
66	66
67		device_set_input_line(m_maincpu, INPUT_LINE_IRQ0, state);
	67	m_maincpu->set_input_line(INPUT_LINE_IRQ0, state);
68	68	}
69	69
70	70
r17814	r17815
76	76	{
77	77	int state = m_y_pia_irqa | m_y_pia_irqb | m_tape_pia_irqa | m_tape_pia_irqb;
78	78
79		device_set_input_line(m_maincpu, INPUT_LINE_NMI, state);
	79	m_maincpu->set_input_line(INPUT_LINE_NMI, state);
80	80	}
81	81
82	82

trunk/src/mess/drivers/esq5505.c

r17814	r17815
76	76	m_dmac(*this, "mc68450")
77	77	{ }
78	78
79		required_device<device_t> m_maincpu;
	79	required_device<m68000_device> m_maincpu;
80	80	required_device<device_t> m_duart;
81	81	optional_device<wd1772_t> m_fdc;
82	82	optional_device<esq1x22_t> m_epsvfd;
r17814	r17815
270	270	//    printf("\nDUART IRQ: state %d vector %d\n", state, vector);
271	271	if (state == ASSERT_LINE)
272	272	{
273		device_set_input_line_vector(esq5505->m_maincpu, 1, vector);
274		device_set_input_line(esq5505->m_maincpu, 1, ASSERT_LINE);
	273	esq5505->m_maincpu->set_input_line_vector(1, vector);
	274	esq5505->m_maincpu->set_input_line(1, ASSERT_LINE);
275	275	}
276	276	else
277	277	{
278		device_set_input_line(esq5505->m_maincpu, 1, CLEAR_LINE);
	278	esq5505->m_maincpu->set_input_line(1, CLEAR_LINE);
279	279	}
280	280	};
281	281
r17814	r17815
299	299	floppy->ss_w((data & 2)>>1);
300	300	}
301	301
302		//    printf("DUART output: %02x (PC=%x)\n", data, state->m_maincpu->safe_pc());
	302	//    printf("DUART output: %02x (PC=%x)\n", data, state->m_maincpu->pc());
303	303	}
304	304
305	305	static void duart_tx(device_t *device, int channel, UINT8 data)
r17814	r17815
308	308
309	309	if (channel == 1)
310	310	{
311		//        printf("ch %d: [%02x] (PC=%x)\n", channel, data, state->m_maincpu->safe_pc());
	311	//        printf("ch %d: [%02x] (PC=%x)\n", channel, data, state->m_maincpu->pc());
312	312	switch (state->m_system_type)
313	313	{
314	314	case GENERIC:

trunk/src/mess/drivers/pegasus.c

r17814	r17815
90	90	static TIMER_DEVICE_CALLBACK( pegasus_firq )
91	91	{
92	92	device_t *cpu = timer.machine().device( "maincpu" );
93		device_set_input_line(cpu, M6809_FIRQ_LINE, HOLD_LINE);
	93	cpu->execute().set_input_line(M6809_FIRQ_LINE, HOLD_LINE);
94	94	}
95	95
96	96	WRITE_LINE_MEMBER( pegasus_state::pegasus_firq_clr )

trunk/src/mess/drivers/tsispch.c

r17814	r17815
272	272	int i;
273	273	for (i=0; i<32; i++) m_infifo[i] = 0;
274	274	m_infifo_tail_ptr = m_infifo_head_ptr = 0;
275		device_set_irq_callback(machine().device("maincpu"), irq_callback);
	275	machine().device("maincpu")->execute().set_irq_acknowledge_callback(irq_callback);
276	276	fprintf(stderr,"machine reset\n");
277	277	}
278	278

trunk/src/mess/drivers/elwro800.c

r17814	r17815
537	537
538	538	static INTERRUPT_GEN( elwro800jr_interrupt )
539	539	{
540		device_set_input_line(device, 0, HOLD_LINE);
	540	device->execute().set_input_line(0, HOLD_LINE);
541	541	}
542	542
543	543	static const floppy_interface elwro800jr_floppy_interface =

trunk/src/mess/drivers/exelv.c

r17814	r17815
321	321	tms5220_wsq_w(m_tms5220c, (data & 0x01) ? 1 : 0);
322	322	tms5220_rsq_w(m_tms5220c, (data & 0x02) ? 1 : 0);
323	323
324		device_set_input_line(m_maincpu, TMS7000_IRQ1_LINE, (data & 0x04) ? CLEAR_LINE : ASSERT_LINE);
	324	m_maincpu->set_input_line(TMS7000_IRQ1_LINE, (data & 0x04) ? CLEAR_LINE : ASSERT_LINE);
325	325
326	326	/* Check for low->high transition on B6 */
327	327	if (!(m_tms7041_portb & 0x40) && (data & 0x40))

trunk/src/mess/drivers/fidelz80.c

r17814	r17815
1087	1087	{
1088	1088	fidelz80_state *state = field.machine().driver_data<fidelz80_state>();
1089	1089
1090		device_set_input_line(state->m_maincpu, INPUT_LINE_RESET, newval ? CLEAR_LINE : ASSERT_LINE);
	1090	state->m_maincpu->set_input_line(INPUT_LINE_RESET, newval ? CLEAR_LINE : ASSERT_LINE);
1091	1091	}
1092	1092
1093	1093	static INPUT_CHANGED( abc_trigger_reset )
1094	1094	{
1095	1095	fidelz80_state *state = field.machine().driver_data<fidelz80_state>();
1096	1096
1097		device_set_input_line(state->m_maincpu, INPUT_LINE_RESET, newval ? CLEAR_LINE : ASSERT_LINE);
1098		device_set_input_line(state->m_i8041, INPUT_LINE_RESET, newval ? CLEAR_LINE : ASSERT_LINE);
	1097	state->m_maincpu->set_input_line(INPUT_LINE_RESET, newval ? CLEAR_LINE : ASSERT_LINE);
	1098	state->m_i8041->set_input_line(INPUT_LINE_RESET, newval ? CLEAR_LINE : ASSERT_LINE);
1099	1099	}
1100	1100
1101	1101	static INPUT_PORTS_START( fidelz80 )

trunk/src/mess/drivers/pv2000.c

r17814	r17815
373	373	state->m_key_pressed = 0;
374	374	state->m_keyb_column = 0;
375	375
376		device_set_input_line_vector(machine.device("maincpu"), INPUT_LINE_IRQ0, 0xff);
	376	machine.device("maincpu")->execute().set_input_line_vector(INPUT_LINE_IRQ0, 0xff);
377	377	memset(&state->memregion("maincpu")->base()[0x7000], 0xff, 0x1000);   // initialize RAM
378	378	}
379	379

trunk/src/mess/drivers/pyl601.c

r17814	r17815
518	518	{
519	519	pyl601_state *state = device->machine().driver_data<pyl601_state>();
520	520	state->m_tick50_mark = 0x80;
521		device_set_input_line(device, 0, HOLD_LINE);
	521	device->execute().set_input_line(0, HOLD_LINE);
522	522	}
523	523
524	524	static LEGACY_FLOPPY_OPTIONS_START(pyldin)

trunk/src/mess/drivers/mstation.c

r17814	r17815
262	262	void mstation_state::refresh_ints()
263	263	{
264	264	if (m_irq != 0)
265		device_set_input_line(m_maincpu, 0, HOLD_LINE);
	265	m_maincpu->set_input_line(0, HOLD_LINE);
266	266	else
267		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	267	m_maincpu->set_input_line(0, CLEAR_LINE);
268	268	}
269	269
270	270	READ8_MEMBER( mstation_state::irq_r )

trunk/src/mess/drivers/iq151.c

r17814	r17815
318	318
319	319	WRITE_LINE_MEMBER( iq151_state::pic_set_int_line )
320	320	{
321		device_set_input_line(m_maincpu, 0, state ?  HOLD_LINE : CLEAR_LINE);
	321	m_maincpu->set_input_line(0, state ?  HOLD_LINE : CLEAR_LINE);
322	322	}
323	323
324	324	static INTERRUPT_GEN( iq151_vblank_interrupt )
r17814	r17815
352	352	membank("boot")->configure_entry(0, RAM + 0xf800);
353	353	membank("boot")->configure_entry(1, RAM + 0x0000);
354	354
355		device_set_irq_callback(m_maincpu, iq151_irq_callback);
	355	m_maincpu->set_irq_acknowledge_callback(iq151_irq_callback);
356	356
357	357	// keep machine pointers to slots
358	358	m_carts[0] = machine().device<iq151cart_slot_device>("slot1");

trunk/src/mess/drivers/pcfx.c

r17814	r17815
375	375
376	376	if ( highest_prio >= 0 )
377	377	{
378		device_set_input_line( m_maincpu, 8 + highest_prio, ASSERT_LINE );
	378	m_maincpu->set_input_line(8 + highest_prio, ASSERT_LINE );
379	379	}
380	380	else
381	381	{
382		device_set_input_line( m_maincpu, 0, CLEAR_LINE );
	382	m_maincpu->set_input_line(0, CLEAR_LINE );
383	383	}
384	384	}
385	385

trunk/src/mess/drivers/avigo.c

r17814	r17815
129	129	void avigo_state::refresh_ints()
130	130	{
131	131	if (m_irq!=0)
132		device_set_input_line(m_maincpu, 0, HOLD_LINE);
	132	m_maincpu->set_input_line(0, HOLD_LINE);
133	133	else
134		device_set_input_line(m_maincpu, 0, CLEAR_LINE);
	134	m_maincpu->set_input_line(0, CLEAR_LINE);
135	135	}
136	136
137	137	/* does not do anything yet */

trunk/src/mess/drivers/apple2.c

r17814	r17815
225	225	{
226	226	apple2_state *a2 = device->machine().driver_data<apple2_state>();
227	227
228		device_set_input_line(a2->m_maincpu, M6502_IRQ_LINE, data);
	228	a2->m_maincpu->set_input_line(M6502_IRQ_LINE, data);
229	229	}
230	230
231	231	static WRITE8_DEVICE_HANDLER(a2bus_nmi_w)
232	232	{
233	233	apple2_state *a2 = device->machine().driver_data<apple2_state>();
234	234
235		device_set_input_line(a2->m_maincpu, INPUT_LINE_NMI, data);
	235	a2->m_maincpu->set_input_line(INPUT_LINE_NMI, data);
236	236	}
237	237
238	238	static WRITE8_DEVICE_HANDLER(a2bus_inh_w)

trunk/src/mess/drivers/svision.c

r17814	r17815
418	418	{
419	419	svision_state *state = device->machine().driver_data<svision_state>();
420	420	if (state->BANK&1)
421		device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE);
	421	device->execute().set_input_line(INPUT_LINE_NMI, PULSE_LINE);
422	422
423	423	svision_sound_decrement(state->m_sound);
424	424	}

trunk/src/mess/drivers/xerox820.c

r17814	r17815
599	599	m_fdc_irq = state;
600	600
601	601	if (halt && state)
602		device_set_input_line(m_maincpu, INPUT_LINE_NMI, ASSERT_LINE);
	602	m_maincpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
603	603	else
604		device_set_input_line(m_maincpu, INPUT_LINE_NMI, CLEAR_LINE);
	604	m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
605	605	}
606	606
607	607	WRITE_LINE_MEMBER( xerox820_state::drq_w )
r17814	r17815
611	611	m_fdc_drq = state;
612	612
613	613	if (halt && state)
614		device_set_input_line(m_maincpu, INPUT_LINE_NMI, ASSERT_LINE);
	614	m_maincpu->set_input_line(INPUT_LINE_NMI, ASSERT_LINE);
615	615	else
616		device_set_input_line(m_maincpu, INPUT_LINE_NMI, CLEAR_LINE);
	616	m_maincpu->set_input_line(INPUT_LINE_NMI, CLEAR_LINE);
617	617	}
618	618
619	619	static const wd17xx_interface fdc_intf =

trunk/src/mess/drivers/ti99_4p.c

r17814	r17815
335	335
336	336	WRITE16_MEMBER( ti99_4p::memwrite )
337	337	{
338		//  device_adjust_icount(m_cpu, -4);
	338	//  m_cpu->execute().adjust_icount(-4);
339	339
340	340	int addroff = offset << 1;
341	341	UINT16 zone = addroff & 0xe000;

trunk/src/mess/drivers/micronic.c

r17814	r17815
348	348
349	349	WRITE_LINE_MEMBER( micronic_state::mc146818_irq )
350	350	{
351		device_set_input_line(m_maincpu, 0, !state ? HOLD_LINE : CLEAR_LINE);
	351	m_maincpu->set_input_line(0, !state ? HOLD_LINE : CLEAR_LINE);
352	352	}
353	353
354	354	const struct mc146818_interface micronic_mc146818_config =

trunk/src/mess/drivers/alphatro.c

r17814	r17815
178	178
179	179	INPUT_CHANGED_MEMBER( alphatro_state::alphatro_break )
180	180	{
181		device_set_input_line(m_maincpu, INPUT_LINE_IRQ0, HOLD_LINE);
	181	m_maincpu->set_input_line(INPUT_LINE_IRQ0, HOLD_LINE);
182	182	}
183	183
184	184	static ADDRESS_MAP_START( alphatro_map, AS_PROGRAM, 8, alphatro_state )

trunk/src/mess/drivers/h8.c

r17814	r17815
57	57	{
58	58	h8_state *state = timer.machine().driver_data<h8_state>();
59	59	if (state->m_irq_ctl & 1)
60		device_set_input_line_and_vector(timer.machine().device("maincpu"), INPUT_LINE_IRQ0, ASSERT_LINE, 0xcf);
	60	timer.machine().device("maincpu")->execute().set_input_line_and_vector(INPUT_LINE_IRQ0, ASSERT_LINE, 0xcf);
61	61	}
62	62
63	63	READ8_MEMBER( h8_state::h8_f0_r )
r17814	r17815
105	105	output_set_value("mon_led",(data & 0x20) ? 0 : 1);
106	106	beep_set_state(m_beep, (data & 0x80) ? 0 : 1);
107	107
108		device_set_input_line(machine().device("maincpu"), INPUT_LINE_IRQ0, CLEAR_LINE);
	108	machine().device("maincpu")->execute().set_input_line(INPUT_LINE_IRQ0, CLEAR_LINE);
109	109	m_irq_ctl &= 0xf0;
110	110	if (data & 0x40) m_irq_ctl |= 1;
111	111	if (~data & 0x10) m_irq_ctl |= 2;
r17814	r17815
197	197	c=m_ff_b^1; // from /Q of 2nd flipflop
198	198	m_ff_b=a; // from Q of 1st flipflop
199	199	if (c)
200		device_set_input_line_and_vector(machine().device("maincpu"), INPUT_LINE_IRQ0, ASSERT_LINE, 0xd7);
	200	machine().device("maincpu")->execute().set_input_line_and_vector(INPUT_LINE_IRQ0, ASSERT_LINE, 0xd7);
201	201	}
202	202	}
203	203	else

trunk/src/mess/drivers/dmv.c

r17814	r17815
271	271
272	272	WRITE_LINE_MEMBER( dmv_state::dma_hrq_changed )
273	273	{
274		device_set_input_line(m_maincpu, INPUT_LINE_HALT, state ? ASSERT_LINE : CLEAR_LINE);
	274	m_maincpu->set_input_line(INPUT_LINE_HALT, state ? ASSERT_LINE : CLEAR_LINE);
275	275
276	276	// Assert HLDA
277	277	i8237_hlda_w(m_dmac, state);

trunk/src/mess/drivers/gba.c

r17814	r17815
98	98	// master enable?
99	99	if (state->m_IME & 1)
100	100	{
101		device_set_input_line(machine.device("maincpu"), ARM7_IRQ_LINE, ASSERT_LINE);
102		device_set_input_line(machine.device("maincpu"), ARM7_IRQ_LINE, CLEAR_LINE);
	101	machine.device("maincpu")->execute().set_input_line(ARM7_IRQ_LINE, ASSERT_LINE);
	102	machine.device("maincpu")->execute().set_input_line(ARM7_IRQ_LINE, CLEAR_LINE);
103	103	}
104	104	}
105	105	}
r17814	r17815
1889	1889	m_HALTCNT = data & 0x000000ff;
1890	1890
1891	1891	// either way, wait for an IRQ
1892		device_spin_until_interrupt(machine().device("maincpu"));
	1892	machine().device("maincpu")->execute().spin_until_interrupt();
1893	1893	}
1894	1894	}
1895	1895	if( (mem_mask) & 0xffff0000 )

trunk/src/mess/drivers/vixen.c

r17814	r17815
79	79	{
80	80	int state = (m_cmd_d1 && m_fdint) || m_vsync || (!m_enb_srq_int && !m_srq) || (!m_enb_atn_int && !m_atn) || (!m_enb_xmt_int && m_txrdy) || (!m_enb_rcv_int && m_rxrdy);
81	81
82		device_set_input_line(m_maincpu, INPUT_LINE_IRQ0, state ? ASSERT_LINE : CLEAR_LINE);
	82	m_maincpu->set_input_line(INPUT_LINE_IRQ0, state ? ASSERT_LINE : CLEAR_LINE);
83	83	}
84	84
85	85
r17814	r17815
778	778	void vixen_state::machine_start()
779	779	{
780	780	// interrupt callback
781		device_set_irq_callback(m_maincpu, vixen_int_ack);
	781	m_maincpu->set_irq_acknowledge_callback(vixen_int_ack);
782	782
783	783	// configure memory banking
784	784	UINT8 *ram = m_ram->pointer();

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team