vnode_t *
devfs_getroot(vfs_t *fs)
{
devfs_data_t *devfs = fs->vfs_private;
if(!devfs->rootvnode) {
_get_vnode(devfs_rootinode, &(devfs->rootvnode), fs);
} else vref(devfs->rootvnode);
return devfs->rootvnode;
}
void ladyfrog_state::ladyfrog(machine_config &config)
{
/* basic machine hardware */
Z80(config, m_maincpu, XTAL(8'000'000)/2);
m_maincpu->set_addrmap(AS_PROGRAM, &ladyfrog_state::ladyfrog_map);
m_maincpu->set_vblank_int("screen", FUNC(ladyfrog_state::irq0_line_hold));
Z80(config, m_audiocpu, XTAL(8'000'000)/2);
m_audiocpu->set_addrmap(AS_PROGRAM, &ladyfrog_state::ladyfrog_sound_map);
m_audiocpu->set_periodic_int(FUNC(ladyfrog_state::irq0_line_hold), attotime::from_hz(2*60));
config.m_minimum_quantum = attotime::from_hz(6000);
/* video hardware */
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
// screen.set_refresh_hz(60);
// screen.set_vblank_time(ATTOSECONDS_IN_USEC(0));
// screen.set_size(32*8, 32*8);
// screen.set_visarea(0*8, 32*8-1, 2*8, 30*8-1); // black borders in ladyfrog gameplay are correct
screen.set_raw(XTAL(8'000'000), 510, 0, 256, 262, 2*8, 30*8); // pixel clock appears to run at 8 MHz
screen.set_screen_update(FUNC(ladyfrog_state::screen_update_ladyfrog));
screen.set_palette(m_palette);
GFXDECODE(config, m_gfxdecode, m_palette, gfx_ladyfrog);
PALETTE(config, m_palette).set_format(palette_device::xBGR_444, 512);
/* sound hardware */
SPEAKER(config, "mono").front_center();
GENERIC_LATCH_8(config, m_soundlatch);
ay8910_device &aysnd(AY8910(config, "aysnd", XTAL(8'000'000)/4));
aysnd.port_a_write_callback().set(FUNC(ladyfrog_state::unk_w));
aysnd.port_b_write_callback().set(FUNC(ladyfrog_state::unk_w));
aysnd.add_route(ALL_OUTPUTS, "mono", 0.15);
MSM5232(config, m_msm, XTAL(8'000'000)/4);
m_msm->set_capacitors(0.65e-6, 0.65e-6, 0.65e-6, 0.65e-6, 0.65e-6, 0.65e-6, 0.65e-6, 0.65e-6);
m_msm->add_route(0, "mono", 1.0); // pin 28 2'-1
m_msm->add_route(1, "mono", 1.0); // pin 29 4'-1
m_msm->add_route(2, "mono", 1.0); // pin 30 8'-1
m_msm->add_route(3, "mono", 1.0); // pin 31 16'-1
m_msm->add_route(4, "mono", 1.0); // pin 36 2'-2
m_msm->add_route(5, "mono", 1.0); // pin 35 4'-2
m_msm->add_route(6, "mono", 1.0); // pin 34 8'-2
m_msm->add_route(7, "mono", 1.0); // pin 33 16'-2
// pin 1 SOLO 8' not mapped
// pin 2 SOLO 16' not mapped
// pin 22 Noise Output not mapped
DAC_8BIT_R2R(config, "dac", 0).add_route(ALL_OUTPUTS, "mono", 0.25); // unknown DAC
voltage_regulator_device &vref(VOLTAGE_REGULATOR(config, "vref", 0));
vref.add_route(0, "dac", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dac", -1.0, DAC_VREF_NEG_INPUT);
}
static int
p9fs_root(struct mount *mp, int lkflags, struct vnode **vpp)
{
struct p9fsmount *p9mp = VFSTOP9(mp);
struct p9fs_node *np = &p9mp->p9_session.p9s_rootnp;
*vpp = np->p9n_vnode;
vref(*vpp);
vn_lock(*vpp, lkflags);
return (0);
}
/*
* lookup. this is incredibly complicated in the
* general case, however for most pseudo-filesystems
* very little needs to be done.
*
* Locking isn't hard here, just poorly documented.
*
* If we're looking up ".", just vref the parent & return it.
*
* If we're looking up "..", unlock the parent, and lock "..". If everything
* went ok, try to re-lock the parent. We do this to prevent lock races.
*
* For anything else, get the needed node.
*
* We try to exit with the parent locked in error cases.
*/
int
ptyfs_lookup(void *v)
{
struct vop_lookup_v2_args /* {
struct vnode * a_dvp;
struct vnode ** a_vpp;
struct componentname * a_cnp;
} */ *ap = v;
struct componentname *cnp = ap->a_cnp;
struct vnode **vpp = ap->a_vpp;
struct vnode *dvp = ap->a_dvp;
const char *pname = cnp->cn_nameptr;
struct ptyfsnode *ptyfs;
int pty, error;
*vpp = NULL;
if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)
return EROFS;
if (cnp->cn_namelen == 1 && *pname == '.') {
*vpp = dvp;
vref(dvp);
return 0;
}
ptyfs = VTOPTYFS(dvp);
switch (ptyfs->ptyfs_type) {
case PTYFSroot:
/*
* Shouldn't get here with .. in the root node.
*/
if (cnp->cn_flags & ISDOTDOT)
return EIO;
pty = atoi(pname, cnp->cn_namelen);
if (pty < 0 || pty >= npty || pty_isfree(pty, 1))
break;
error = ptyfs_allocvp(dvp->v_mount, vpp, PTYFSpts, pty,
curlwp);
if (error)
return error;
VOP_UNLOCK(*vpp);
return 0;
default:
return ENOTDIR;
}
return cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS;
}
int
do_chdir(const char *path)
{
/* NOT_YET_IMPLEMENTED("VFS: do_chdir"); */
/*GS: path should point to something */
KASSERT(path);
dbg(DBG_PRINT, "(GRADING2C) (vfs_syscall.c) (do_chdir)\n");
/*GS: Check if a path too long. */
if(strlen(path) > MAXPATHLEN)
{
dbg(DBG_PRINT, "(GRADING2C 1.n) (vfs_syscall.c) (do_chdir) path too long, return -ENAMETOOLONG\n");
return -ENAMETOOLONG;
}
/*GS: This returns in newcwd the vnode requested by the other parameters.
* and ups the refcount to the new cwd*/
vnode_t *newcwd = NULL;
int retVal = open_namev(path, O_RDONLY, &newcwd, curproc->p_cwd);
/* GS: NOTE! - need to confirm open_namev error values after implemented */
if( retVal < 0 )
{
dbg(DBG_PRINT, "(GRADING2B) (vfs_syscall.c) (do_chdir) error open_namev, cannot open, return error\n");
return retVal;
}
/*GS: check if the path does not exist.*/
/*if( newcwd == NULL )
{
dbg(DBG_PRINT, "(GRADING2C) (vfs_syscall.c) (do_chdir) path does not exist, return -ENOENT\n");
return -ENOENT;
}*/
/*GS: Check if a component of path is not a directory.*/
if (!S_ISDIR(newcwd->vn_mode))
{
/*GS: need to down the count back*/
vput(newcwd);
dbg(DBG_PRINT, "(GRADING2B) component of path is not a directory, return -ENOTDIR\n");
return -ENOTDIR;
}
/*GS: Down the refcount to the old cwd - vput() */
vput(curproc->p_cwd);
/*GS: Make the named directory the current process's cwd */
curproc->p_cwd = newcwd;
vref(curproc->p_cwd);
vput(newcwd);
return 0;
}
/*
* Add a ref to a vnode's existing VM object, return the object or
* NULL if the vnode did not have one. This does not create the
* object (we can't since we don't know what the proper blocksize/boff
* is to match the VFS's use of the buffer cache).
*/
vm_object_t
vnode_pager_reference(struct vnode *vp)
{
vm_object_t object;
/*
* Prevent race condition when allocating the object. This
* can happen with NFS vnodes since the nfsnode isn't locked.
*
* Serialize potential vnode/object teardowns and interlocks
*/
lwkt_gettoken(&vp->v_token);
while (vp->v_flag & VOLOCK) {
vsetflags(vp, VOWANT);
tsleep(vp, 0, "vnpobj", 0);
}
vsetflags(vp, VOLOCK);
lwkt_reltoken(&vp->v_token);
/*
* Prevent race conditions against deallocation of the VM
* object.
*/
while ((object = vp->v_object) != NULL) {
vm_object_hold(object);
if ((object->flags & OBJ_DEAD) == 0)
break;
vm_object_dead_sleep(object, "vadead");
vm_object_drop(object);
}
/*
* The object is expected to exist, the caller will handle
* NULL returns if it does not.
*/
if (object) {
object->ref_count++;
vref(vp);
}
lwkt_gettoken(&vp->v_token);
vclrflags(vp, VOLOCK);
if (vp->v_flag & VOWANT) {
vclrflags(vp, VOWANT);
wakeup(vp);
}
lwkt_reltoken(&vp->v_token);
if (object)
vm_object_drop(object);
return (object);
}
static __inline
struct vnode *
union_lock_upper(struct union_node *un, struct thread *td)
{
struct vnode *uppervp;
if ((uppervp = un->un_uppervp) != NULL) {
vref(uppervp);
vn_lock(uppervp, LK_EXCLUSIVE | LK_CANRECURSE | LK_RETRY);
}
KASSERT((uppervp == NULL || uppervp->v_sysref.refcnt > 0), ("uppervp usecount is 0"));
return(uppervp);
}
static AST lval() {
Token *t = &tok;
AST a=0;
AST a1=0,a2=0;
a1 = vref();
if (t->sym == '[') {
a2 = exprs();
a = make_AST(nLVAL, a1, a2, 0, 0);
} else
a = a1;
return a;
}
void bally_cheap_squeak_device::device_add_mconfig(machine_config &config)
{
M6803(config, m_cpu, DERIVED_CLOCK(1, 1));
m_cpu->set_addrmap(AS_PROGRAM, &bally_cheap_squeak_device::cheap_squeak_map);
m_cpu->out_p1_cb().set(FUNC(bally_cheap_squeak_device::out_p1_cb));
m_cpu->in_p2_cb().set(FUNC(bally_cheap_squeak_device::in_p2_cb));
m_cpu->out_p2_cb().set(FUNC(bally_cheap_squeak_device::out_p2_cb));
ZN429E(config, "dac", 0).add_route(ALL_OUTPUTS, *this, 1.00, AUTO_ALLOC_INPUT, 0);
voltage_regulator_device &vref(VOLTAGE_REGULATOR(config, "vref"));
vref.add_route(0, "dac", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dac", -1.0, DAC_VREF_NEG_INPUT);
}
int
fdesc_root(struct mount *mp, struct vnode **vpp)
{
struct vnode *vp;
/*
* Return locked reference to root.
*/
vp = mp->mnt_data;
vref(vp);
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
*vpp = vp;
return (0);
}
static __inline
struct vnode *
union_lock_other(struct union_node *un, struct thread *td)
{
struct vnode *vp;
if (un->un_uppervp != NULL) {
vp = union_lock_upper(un, td);
} else if ((vp = un->un_lowervp) != NULL) {
vref(vp);
vn_lock(vp, LK_EXCLUSIVE | LK_CANRECURSE | LK_RETRY);
}
return(vp);
}
void wsf_80186_sound_device::device_add_mconfig(machine_config &config)
{
I80186(config, m_audiocpu, 16_MHz_XTAL);
m_audiocpu->set_addrmap(AS_PROGRAM, &wsf_80186_sound_device::leland_80186_map_program);
m_audiocpu->set_addrmap(AS_IO, &wsf_80186_sound_device::ataxx_80186_map_io);
m_audiocpu->chip_select_callback().set(FUNC(leland_80186_sound_device::peripheral_ctrl));
m_audiocpu->tmrout0_handler().set(FUNC(leland_80186_sound_device::i80186_tmr0_w));
m_audiocpu->tmrout1_handler().set(FUNC(leland_80186_sound_device::i80186_tmr1_w));
SPEAKER(config, "speaker").front_center();
for (int i = 0; i < 4; i++)
{
AD7524(config, m_dac[i], 0).add_route(ALL_OUTPUTS, "speaker", 0.2); // unknown DAC
DAC_8BIT_BINARY_WEIGHTED(config, m_dacvol[i], 0); // unknown DAC
}
AD7533(config, "dac9", 0).add_route(ALL_OUTPUTS, "speaker", 1.0); // unknown DAC
m_dacvol[0]->add_route(0, "dac1", 1.0, DAC_VREF_POS_INPUT);
m_dacvol[0]->add_route(0, "dac1", -1.0, DAC_VREF_NEG_INPUT); // unknown DAC
m_dacvol[1]->add_route(0, "dac2", 1.0, DAC_VREF_POS_INPUT);
m_dacvol[1]->add_route(0, "dac2", -1.0, DAC_VREF_NEG_INPUT); // unknown DAC
m_dacvol[2]->add_route(0, "dac3", 1.0, DAC_VREF_POS_INPUT);
m_dacvol[2]->add_route(0, "dac3", -1.0, DAC_VREF_NEG_INPUT); // unknown DAC
m_dacvol[3]->add_route(0, "dac4", 1.0, DAC_VREF_POS_INPUT);
m_dacvol[3]->add_route(0, "dac4", -1.0, DAC_VREF_NEG_INPUT); // unknown DAC
voltage_regulator_device &vref(VOLTAGE_REGULATOR(config, "vref", 0));
vref.set_output(5.0);
vref.add_route(0, "dac1vol", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dac2vol", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dac3vol", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dac4vol", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dac9", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dac9", -1.0, DAC_VREF_NEG_INPUT);
/* sound hardware */
YM2151(config, m_ymsnd, 4000000);
m_ymsnd->add_route(0, "speaker", 0.40);
m_ymsnd->add_route(1, "speaker", 0.40);
PIT8254(config, m_pit[0], 0);
m_pit[0]->set_clk<0>(4000000);
m_pit[0]->out_handler<0>().set(m_audiocpu, FUNC(i80186_cpu_device::drq0_w));
m_pit[0]->set_clk<1>(4000000);
m_pit[0]->out_handler<1>().set(m_audiocpu, FUNC(i80186_cpu_device::drq1_w));
m_pit[0]->set_clk<2>(4000000);
m_pit[0]->out_handler<2>().set(FUNC(leland_80186_sound_device::pit0_2_w));
GENERIC_LATCH_16(config, m_soundlatch);
}
static int
null_vptocnp(struct vop_vptocnp_args *ap)
{
struct vnode *vp = ap->a_vp;
struct vnode **dvp = ap->a_vpp;
struct vnode *lvp, *ldvp;
struct ucred *cred = ap->a_cred;
int error, locked;
if (vp->v_type == VDIR)
return (vop_stdvptocnp(ap));
locked = VOP_ISLOCKED(vp);
lvp = NULLVPTOLOWERVP(vp);
vhold(lvp);
VOP_UNLOCK(vp, 0); /* vp is held by vn_vptocnp_locked that called us */
ldvp = lvp;
error = vn_vptocnp(&ldvp, cred, ap->a_buf, ap->a_buflen);
vdrop(lvp);
if (error != 0) {
vn_lock(vp, locked | LK_RETRY);
return (ENOENT);
}
/*
* Exclusive lock is required by insmntque1 call in
* null_nodeget()
*/
error = vn_lock(ldvp, LK_EXCLUSIVE);
if (error != 0) {
vn_lock(vp, locked | LK_RETRY);
vdrop(ldvp);
return (ENOENT);
}
vref(ldvp);
vdrop(ldvp);
error = null_nodeget(vp->v_mount, ldvp, dvp);
if (error == 0) {
#ifdef DIAGNOSTIC
NULLVPTOLOWERVP(*dvp);
#endif
vhold(*dvp);
vput(*dvp);
} else
vput(ldvp);
vn_lock(vp, locked | LK_RETRY);
return (error);
}
void sbasketb_state::sbasketb(machine_config &config)
{
/* basic machine hardware */
KONAMI1(config, m_maincpu, 1400000); /* 1.400 MHz ??? */
m_maincpu->set_addrmap(AS_PROGRAM, &sbasketb_state::sbasketb_map);
Z80(config, m_audiocpu, XTAL(14'318'181) / 4); /* 3.5795 MHz */
m_audiocpu->set_addrmap(AS_PROGRAM, &sbasketb_state::sbasketb_sound_map);
ls259_device &mainlatch(LS259(config, "mainlatch")); // B3
mainlatch.q_out_cb<0>().set(FUNC(sbasketb_state::flipscreen_w)); // FLIP
mainlatch.q_out_cb<1>().set(FUNC(sbasketb_state::irq_mask_w)); // INTST
mainlatch.q_out_cb<2>().set_nop(); // MUT - not used?
mainlatch.q_out_cb<3>().set(FUNC(sbasketb_state::coin_counter_1_w)); // COIN 1
mainlatch.q_out_cb<4>().set(FUNC(sbasketb_state::coin_counter_2_w)); // COIN 2
mainlatch.q_out_cb<5>().set(FUNC(sbasketb_state::spriteram_select_w)); // OBJ CHE
mainlatch.q_out_cb<6>().set_nop(); // END - not used
WATCHDOG_TIMER(config, "watchdog");
/* video hardware */
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_refresh_hz(60);
m_screen->set_vblank_time(ATTOSECONDS_IN_USEC(0));
m_screen->set_size(32*8, 32*8);
m_screen->set_visarea(0*8, 32*8-1, 2*8, 30*8-1);
m_screen->set_screen_update(FUNC(sbasketb_state::screen_update_sbasketb));
m_screen->set_palette(m_palette);
m_screen->screen_vblank().set(FUNC(sbasketb_state::vblank_irq));
GFXDECODE(config, m_gfxdecode, m_palette, gfx_sbasketb);
PALETTE(config, m_palette, FUNC(sbasketb_state::sbasketb_palette), 16*16+16*16*16, 256);
/* sound hardware */
SPEAKER(config, "speaker").front_center();
GENERIC_LATCH_8(config, "soundlatch");
TRACKFLD_AUDIO(config, m_soundbrd, 0, m_audiocpu, m_vlm);
DAC_8BIT_R2R(config, m_dac, 0).add_route(ALL_OUTPUTS, "speaker", 0.4); // unknown DAC
voltage_regulator_device &vref(VOLTAGE_REGULATOR(config, "vref"));
vref.add_route(0, "dac", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dac", -1.0, DAC_VREF_NEG_INPUT);
SN76489(config, m_sn, XTAL(14'318'181) / 8).add_route(ALL_OUTPUTS, "speaker", 1.0);
VLM5030(config, m_vlm, XTAL(3'579'545)).add_route(ALL_OUTPUTS, "speaker", 1.0); /* Schematics say 3.58MHz, but board uses 3.579545MHz xtal */
}
static __inline
struct vnode *
union_ref_upper(struct union_node *un)
{
struct vnode *uppervp;
if ((uppervp = un->un_uppervp) != NULL) {
vref(uppervp);
if (uppervp->v_flag & VRECLAIMED) {
vrele(uppervp);
return (NULLVP);
}
}
return (uppervp);
}
GFXDECODE_END
/*************************************
*
* Machine driver
*
*************************************/
void matmania_state::matmania(machine_config &config)
{
/* basic machine hardware */
M6502(config, m_maincpu, 1500000); /* 1.5 MHz ???? */
m_maincpu->set_addrmap(AS_PROGRAM, &matmania_state::matmania_map);
m_maincpu->set_vblank_int("screen", FUNC(matmania_state::irq0_line_hold));
M6502(config, m_audiocpu, 1200000); /* 1.2 MHz ???? */
m_audiocpu->set_addrmap(AS_PROGRAM, &matmania_state::matmania_sound_map);
m_audiocpu->set_periodic_int(FUNC(matmania_state::nmi_line_pulse), attotime::from_hz(15*60)); /* ???? */
config.m_minimum_quantum = attotime::from_hz(6000);
/* video hardware */
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_refresh_hz(60);
m_screen->set_vblank_time(ATTOSECONDS_IN_USEC(2500)); /* not accurate */
m_screen->set_size(32*8, 32*8);
m_screen->set_visarea(0*8, 32*8-1, 1*8, 31*8-1);
m_screen->set_screen_update(FUNC(matmania_state::screen_update_matmania));
m_screen->set_palette(m_palette);
GFXDECODE(config, m_gfxdecode, m_palette, gfx_matmania);
PALETTE(config, m_palette, FUNC(matmania_state::matmania_palette), 64 + 16);
/* sound hardware */
SPEAKER(config, "speaker").front_center();
GENERIC_LATCH_8(config, m_soundlatch);
AY8910(config, "ay1", 1500000).add_route(ALL_OUTPUTS, "speaker", 0.3);
AY8910(config, "ay2", 1500000).add_route(ALL_OUTPUTS, "speaker", 0.3);
DAC_8BIT_R2R(config, "dac", 0).add_route(ALL_OUTPUTS, "speaker", 0.4); // unknown DAC
voltage_regulator_device &vref(VOLTAGE_REGULATOR(config, "vref", 0));
vref.add_route(0, "dac", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dac", -1.0, DAC_VREF_NEG_INPUT);
}
void midway_cheap_squeak_deluxe_device::device_add_mconfig(machine_config &config)
{
M68000(config, m_cpu, DERIVED_CLOCK(1, 2));
m_cpu->set_addrmap(AS_PROGRAM, &midway_cheap_squeak_deluxe_device::csdeluxe_map);
PIA6821(config, m_pia, 0);
m_pia->writepa_handler().set(FUNC(midway_cheap_squeak_deluxe_device::porta_w));
m_pia->writepb_handler().set(FUNC(midway_cheap_squeak_deluxe_device::portb_w));
m_pia->irqa_handler().set(FUNC(midway_cheap_squeak_deluxe_device::irq_w));
m_pia->irqb_handler().set(FUNC(midway_cheap_squeak_deluxe_device::irq_w));
AD7533(config, m_dac, 0).add_route(ALL_OUTPUTS, *this, 1.0);
voltage_regulator_device &vref(VOLTAGE_REGULATOR(config, "vref"));
vref.add_route(0, "dac", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dac", -1.0, DAC_VREF_NEG_INPUT);
}
void silent_load(NODE *arg, char *prefix)
{
FILE *tmp_stream;
NODE *tmp_line, *exec_list;
char load_path[200];
NODE *st = valnode__caseobj(Startup);
int sv_val_status = val_status;
/* This procedure is called three ways:
* silent_load(NIL,*argv) loads *argv
* silent_load(proc,logolib) loads logolib/proc
* silent_load(proc,NULL) loads proc.lg
* The "/" or ".lg" is supplied by this procedure as needed.
*/
if (prefix == NULL && arg == NIL) return;
strcpy(load_path, (prefix == NULL ? "" : prefix));
if (arg != NIL) {
arg = cnv_node_to_strnode(arg);
if (arg == UNBOUND) return;
#ifdef unix
if (prefix != NULL) strcat(load_path, "/");
#endif
noparitylow_strnzcpy(load_path + (int)strlen(load_path),
getstrptr(arg), getstrlen(arg));
if (prefix == NULL) strcat(load_path, ".lg");
gcref(arg);
}
tmp_stream = loadstream;
tmp_line = vref(current_line);
loadstream = fopen(load_path, "r");
if (loadstream != NULL) {
while (!feof(loadstream) && NOT_THROWING) {
current_line = reref(current_line, reader(loadstream, ""));
exec_list =parser(current_line, TRUE);
val_status = 0;
if (exec_list != NIL) eval_driver(exec_list);
}
fclose(loadstream);
runstartup(st);
val_status = sv_val_status;
} else if (arg == NIL) ndprintf(stdout,"File not found: %t\n", prefix);
loadstream = tmp_stream;
deref(current_line);
current_line = tmp_line;
}
void wpcsnd_device::device_add_mconfig(machine_config &config)
{
MC6809E(config, m_cpu, XTAL(8'000'000) / 4); // MC68B09E
m_cpu->set_addrmap(AS_PROGRAM, &wpcsnd_device::wpcsnd_map);
config.m_minimum_quantum = attotime::from_hz(50);
YM2151(config, m_ym2151, 3580000);
m_ym2151->irq_handler().set(FUNC(wpcsnd_device::ym2151_irq_w));
m_ym2151->add_route(ALL_OUTPUTS, *this, 0.25);
AD7524(config, "dac", 0).add_route(ALL_OUTPUTS, *this, 0.25);
voltage_regulator_device &vref(VOLTAGE_REGULATOR(config, "vref"));
vref.set_output(5.0);
vref.add_route(0, "dac", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dac", -1.0, DAC_VREF_NEG_INPUT);
HC55516(config, m_hc55516, 0).add_route(ALL_OUTPUTS, *this, 0.5);
}
int
layerfs_root(struct mount *mp, struct vnode **vpp)
{
struct vnode *vp;
vp = MOUNTTOLAYERMOUNT(mp)->layerm_rootvp;
if (vp == NULL) {
*vpp = NULL;
return EINVAL;
}
/*
* Return root vnode with locked and with a reference held.
*/
vref(vp);
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
*vpp = vp;
return 0;
}
void gottlieb_sound_r0_device::device_add_mconfig(machine_config &config)
{
// audio CPU
M6502(config, m_audiocpu, SOUND1_CLOCK/4); // M6503 - clock is a gate, a resistor and a capacitor. Freq unknown.
m_audiocpu->set_addrmap(AS_PROGRAM, &gottlieb_sound_r0_device::gottlieb_sound_r0_map);
// I/O configuration
MOS6530(config, m_r6530, SOUND1_CLOCK/4); // unknown - same as cpu
m_r6530->out_pa_callback().set("dac", FUNC(dac_byte_interface::data_w));
m_r6530->in_pb_callback().set(FUNC(gottlieb_sound_r0_device::r6530b_r));
// sound devices
DAC_8BIT_R2R(config, "dac", 0).add_route(ALL_OUTPUTS, *this, 0.25); // unknown DAC
voltage_regulator_device &vref(VOLTAGE_REGULATOR(config, "vref"));
vref.set_output(5.0);
vref.add_route(0, "dac", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dac", -1.0, DAC_VREF_NEG_INPUT);
}
void fileload(char *temp)
{
FILE *tmp;
NODE *tmp_line, *exec_list, *arg;
NODE *st = valnode__caseobj(Startup);
int sv_val_status = val_status;
int IsDirtySave;
int save_yield_flag;
arg = make_strnode(temp, NULL, strlen(temp), STRING, strnzcpy);
IsDirtySave = IsDirty;
tmp = loadstream;
tmp_line = vref(current_line);
loadstream = open_file(arg, "r");
if (loadstream != NULL)
{
save_yield_flag = yield_flag;
yield_flag = 0;
lsetcursorwait();
while (!feof(loadstream) && NOT_THROWING)
{
current_line = reref(current_line, reader(loadstream, ""));
exec_list = parser(current_line, TRUE);
val_status = 0;
if (exec_list != NIL) eval_driver(exec_list);
}
fclose(loadstream);
lsetcursorarrow();
yield_flag = save_yield_flag;
runstartup(st);
val_status = sv_val_status;
}
else
err_logo(FILE_ERROR, make_static_strnode("Could not open file"));
loadstream = tmp;
deref(current_line);
current_line = tmp_line;
IsDirty = IsDirtySave;
}
void
new_vmcmd(struct exec_vmcmd_set *evsp,
int (*proc)(struct proc *, struct exec_vmcmd *), u_long len, u_long addr,
struct vnode *vp, u_long offset, u_int prot, int flags)
{
struct exec_vmcmd *vcp;
if (evsp->evs_used >= evsp->evs_cnt)
vmcmdset_extend(evsp);
vcp = &evsp->evs_cmds[evsp->evs_used++];
vcp->ev_proc = proc;
vcp->ev_len = len;
vcp->ev_addr = addr;
if ((vcp->ev_vp = vp) != NULL)
vref(vp);
vcp->ev_offset = offset;
vcp->ev_prot = prot;
vcp->ev_flags = flags;
}
static int
nnpfs_dnlc_lock(struct vnode *dvp,
nnpfs_componentname *cnp,
struct vnode **res)
{
int error = 0;
/*
* Try to handle the (complex) BSD locking protocol.
*/
if (*res == dvp) { /* "." */
vref(dvp);
} else if (cnp->cn_flags & ISDOTDOT) { /* ".." */
u_long vpid = dvp->v_id;
#ifdef HAVE_FREEBSD_THREAD
nnpfs_vfs_unlock(dvp, nnpfs_cnp_to_thread(cnp));
error = nnpfs_do_vget(*res, LK_EXCLUSIVE, nnpfs_cnp_to_thread(cnp));
nnpfs_vfs_writelock(dvp, nnpfs_cnp_to_thread(cnp));
#else
nnpfs_vfs_unlock(dvp, nnpfs_cnp_to_proc(cnp));
error = nnpfs_do_vget(*res, LK_EXCLUSIVE, nnpfs_cnp_to_proc(cnp));
nnpfs_vfs_writelock(dvp, nnpfs_cnp_to_proc(cnp));
#endif
if (error == 0 && dvp->v_id != vpid) {
vput(*res);
return 0;
}
} else {
#ifdef HAVE_FREEBSD_THREAD
error = nnpfs_do_vget(*res, LK_EXCLUSIVE, nnpfs_cnp_to_thread(cnp));
#else
error = nnpfs_do_vget(*res, LK_EXCLUSIVE, nnpfs_cnp_to_proc(cnp));
#endif
}
if (error == 0)
return -1;
else
return 0;
}
/*
* Enable an EA using the passed file system, backing vnode, attribute name,
* namespace, and proc. Will perform a VOP_OPEN() on the vp, so expects vp
* to be locked when passed in. The vnode will be returned unlocked,
* regardless of success/failure of the function. As a result, the caller
* will always need to vrele(), but not vput().
*/
static int
ufs_extattr_enable_with_open(struct ufsmount *ump, struct vnode *vp,
int attrnamespace, const char *attrname, struct proc *p)
{
int error;
error = VOP_OPEN(vp, FREAD|FWRITE, p->p_ucred, p);
if (error) {
printf("ufs_extattr_enable_with_open.VOP_OPEN(): failed "
"with %d\n", error);
VOP_UNLOCK(vp, 0, p);
return (error);
}
#if 0
/* - XXX */
/*
* XXX: Note, should VOP_CLOSE() if vfs_object_create() fails, but due
* to a similar piece of code in vn_open(), we don't.
*/
if (vn_canvmio(vp) == TRUE)
if ((error = vfs_object_create(vp, p, p->p_ucred)) != 0) {
/*
* XXX: bug replicated from vn_open(): should
* VOP_CLOSE() here.
*/
VOP_UNLOCK(vp, 0, p);
return (error);
}
#endif
vp->v_writecount++;
vref(vp);
VOP_UNLOCK(vp, 0, p);
error = ufs_extattr_enable(ump, attrnamespace, attrname, vp, p);
if (error != 0)
vn_close(vp, FREAD|FWRITE, p->p_ucred, p);
return (error);
}
void mephisto_pinball_state::mephisto(machine_config &config)
{
/* basic machine hardware */
I8088(config, m_maincpu, XTAL(18'000'000)/3);
m_maincpu->set_addrmap(AS_PROGRAM, &mephisto_pinball_state::mephisto_map);
//m_maincpu->set_irq_acknowledge_callback("muart", FUNC(i8256_device::inta_cb));
NVRAM(config, "nvram", nvram_device::DEFAULT_ALL_0);
//i8256_device &muart(I8256(config, "muart", XTAL(18'000'000)/3));
//muart.irq_handler().set_inputline(m_maincpu, INPUT_LINE_IRQ0);
//muart.txd_handler().set_inputline("audiocpu", MCS51_RX_LINE);
I8155(config, "ic20", XTAL(18'000'000)/6);
//i8155_device &i8155_1(I8155(config, "ic20", XTAL(18'000'000)/6));
//i8155_1.out_to_callback().set("muart", FUNC(i8256_device::write_txc));
I8155(config, "ic9", XTAL(18'000'000)/6);
//i8155_device &i8155_2(I8155(config, "ic9", XTAL(18'000'000)/6));
//i8155_2.out_to_callback().set(FUNC(mephisto_pinball_state::clk_shift_w));
i8051_device &soundcpu(I8051(config, "soundcpu", XTAL(12'000'000)));
soundcpu.set_addrmap(AS_PROGRAM, &mephisto_pinball_state::mephisto_8051_map); // EA tied high for external program ROM
soundcpu.set_addrmap(AS_IO, &mephisto_pinball_state::mephisto_8051_io);
soundcpu.port_in_cb<1>().set(FUNC(mephisto_pinball_state::ay8910_read));
soundcpu.port_out_cb<1>().set(FUNC(mephisto_pinball_state::ay8910_write));
soundcpu.port_out_cb<3>().set(FUNC(mephisto_pinball_state::t0_t1_w));
soundcpu.serial_rx_cb().set_constant(0); // from MUART
SPEAKER(config, "mono").front_center();
AY8910(config, m_aysnd, XTAL(12'000'000)/8);
m_aysnd->port_a_write_callback().set(FUNC(mephisto_pinball_state::ay8910_columns_w));
m_aysnd->port_b_read_callback().set(FUNC(mephisto_pinball_state::ay8910_inputs_r));
m_aysnd->add_route(ALL_OUTPUTS, "mono", 0.5);
DAC08(config, "dac", 0).add_route(ALL_OUTPUTS, "mono", 0.5);
voltage_regulator_device &vref(VOLTAGE_REGULATOR(config, "vref"));
vref.set_output(5.0);
vref.add_route(0, "dac", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dac", -1.0, DAC_VREF_NEG_INPUT);
}
void s4_state::s4a(machine_config &config)
{
s4(config);
/* Add the soundcard */
M6808(config, m_audiocpu, 3580000);
m_audiocpu->set_addrmap(AS_PROGRAM, &s4_state::s4_audio_map);
MCFG_MACHINE_RESET_OVERRIDE(s4_state, s4a)
SPEAKER(config, "speaker").front_center();
MC1408(config, "dac", 0).add_route(ALL_OUTPUTS, "speaker", 0.5);
voltage_regulator_device &vref(VOLTAGE_REGULATOR(config, "vref"));
vref.add_route(0, "dac", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dac", -1.0, DAC_VREF_NEG_INPUT);
PIA6821(config, m_pias, 0);
m_pias->readpb_handler().set(FUNC(s4_state::sound_r));
m_pias->writepa_handler().set("dac", FUNC(dac_byte_interface::data_w));
m_pias->irqa_handler().set_inputline("audiocpu", M6808_IRQ_LINE);
m_pias->irqb_handler().set_inputline("audiocpu", M6808_IRQ_LINE);
}
static int
unionfs_root(struct mount *mp, int flags, struct vnode **vpp)
{
struct unionfs_mount *ump;
struct vnode *vp;
ump = MOUNTTOUNIONFSMOUNT(mp);
vp = ump->um_rootvp;
UNIONFSDEBUG("unionfs_root: rootvp=%p locked=%x\n",
vp, VOP_ISLOCKED(vp));
vref(vp);
if (flags & LK_TYPE_MASK)
vn_lock(vp, flags);
*vpp = vp;
return (0);
}
int
lookupnameat(char *dirname, enum uio_seg seg, enum symfollow follow,
vnode_t **dirvpp, vnode_t **compvpp, vnode_t *startvp)
{
struct nameidata nd;
int error, ltype;
ASSERT(dirvpp == NULL);
vref(startvp);
ltype = VOP_ISLOCKED(startvp);
VOP_UNLOCK(startvp, 0);
NDINIT_ATVP(&nd, LOOKUP, LOCKLEAF | MPSAFE | follow, seg, dirname,
startvp, curthread);
error = namei(&nd);
*compvpp = nd.ni_vp;
NDFREE(&nd, NDF_ONLY_PNBUF);
vn_lock(startvp, ltype | LK_RETRY);
return (error);
}
void wildpkr_state::tabpkr(machine_config &config)
{
/* basic machine hardware */
M68000(config, m_maincpu, XTAL(24'000'000) / 2);
m_maincpu->set_addrmap(AS_PROGRAM, &wildpkr_state::tabpkr_map);
m_maincpu->set_periodic_int(FUNC(wildpkr_state::irq3_line_assert), attotime::from_hz(60*256));
m_maincpu->set_addrmap(m68000_base_device::AS_CPU_SPACE, &wildpkr_state::cpu_space_map);
NVRAM(config, "nvram", nvram_device::DEFAULT_ALL_1); // DS1220Y
MC68681(config, m_duart, 3686400);
m_duart->irq_cb().set_inputline(m_maincpu, M68K_IRQ_2, ASSERT_LINE);
DS2401(config, m_id, 0);
CLOCK(config, m_dac_clock, 1500000); // base rate derived from program code
m_dac_clock->signal_handler().set_inputline(m_maincpu, M68K_IRQ_5, ASSERT_LINE);
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_refresh_hz(60);
screen.set_vblank_time(ATTOSECONDS_IN_USEC(2500));
screen.set_size(384, 280);
screen.set_visarea(0, 384-1, 0, 280-1);
screen.set_screen_update("acrtc", FUNC(hd63484_device::update_screen));
screen.set_palette("palette");
screen.screen_vblank().set_inputline(m_maincpu, M68K_IRQ_4, ASSERT_LINE);
HD63484(config, "acrtc", 0).set_addrmap(0, &wildpkr_state::hd63484_map);
ramdac_device &ramdac(RAMDAC(config, "ramdac", 0, "palette"));
ramdac.set_addrmap(0, &wildpkr_state::ramdac_map);
PALETTE(config, "palette", FUNC(wildpkr_state::wildpkr_palette), 256);
/* sound hardware */
SPEAKER(config, "mono").front_center();
AD557(config, m_dac, 0).add_route(ALL_OUTPUTS, "mono", 0.50);
voltage_regulator_device &vref(VOLTAGE_REGULATOR(config, "vref"));
vref.add_route(0, "dac", 1.0, DAC_VREF_POS_INPUT);
vref.add_route(0, "dac", -1.0, DAC_VREF_NEG_INPUT);
}
