From 7ea6b903f5c8706379c962b6586ece3e6e917842 Mon Sep 17 00:00:00 2001 From: ragge Date: Tue, 19 Aug 2003 10:54:59 +0000 Subject: [PATCH] Basic machine-dependent code for pdp10. Lots of stuff here not yet finished. --- sys/arch/pdp10/pdp10/autoconf.c | 75 +++++ sys/arch/pdp10/pdp10/clock.c | 63 ++++ sys/arch/pdp10/pdp10/console.c | 103 ++++++ sys/arch/pdp10/pdp10/db_disasm.c | 44 +++ sys/arch/pdp10/pdp10/db_machdep.c | 128 +++++++ sys/arch/pdp10/pdp10/disksubr.c | 212 ++++++++++++ sys/arch/pdp10/pdp10/kl10.c | 61 ++++ sys/arch/pdp10/pdp10/locore.S | 532 ++++++++++++++++++++++++++++++ sys/arch/pdp10/pdp10/machdep.c | 283 ++++++++++++++++ sys/arch/pdp10/pdp10/mem.c | 162 +++++++++ sys/arch/pdp10/pdp10/pmap.c | 393 ++++++++++++++++++++++ sys/arch/pdp10/pdp10/trap.c | 74 +++++ sys/arch/pdp10/pdp10/vm_machdep.c | 89 +++++ 13 files changed, 2219 insertions(+) create mode 100644 sys/arch/pdp10/pdp10/autoconf.c create mode 100644 sys/arch/pdp10/pdp10/clock.c create mode 100644 sys/arch/pdp10/pdp10/console.c create mode 100644 sys/arch/pdp10/pdp10/db_disasm.c create mode 100644 sys/arch/pdp10/pdp10/db_machdep.c create mode 100644 sys/arch/pdp10/pdp10/disksubr.c create mode 100644 sys/arch/pdp10/pdp10/kl10.c create mode 100644 sys/arch/pdp10/pdp10/locore.S create mode 100644 sys/arch/pdp10/pdp10/machdep.c create mode 100644 sys/arch/pdp10/pdp10/mem.c create mode 100644 sys/arch/pdp10/pdp10/pmap.c create mode 100644 sys/arch/pdp10/pdp10/trap.c create mode 100644 sys/arch/pdp10/pdp10/vm_machdep.c diff --git a/sys/arch/pdp10/pdp10/autoconf.c b/sys/arch/pdp10/pdp10/autoconf.c new file mode 100644 index 000000000000..a4446c04ce51 --- /dev/null +++ b/sys/arch/pdp10/pdp10/autoconf.c @@ -0,0 +1,75 @@ +/* $NetBSD: autoconf.c,v 1.1 2003/08/19 10:54:59 ragge Exp $ */ +/* + * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se). + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include + +static struct device *booted_device; +static int booted_partition; + +void +cpu_rootconf(void) +{ + printf("boot device: %s\n", + booted_device ? booted_device->dv_xname : ""); + + setroot(booted_device, booted_partition); +} + +void +cpu_configure(void) +{ + + if (config_rootfound("mainbus", NULL) == NULL) + panic("mainbus not configured"); +} + +static int +mainbus_print(void *aux, const char *name) +{ + return (UNCONF); +} + +static int +mainbus_match(struct device *parent, struct cfdata *cf, void *aux) +{ + return 1; +} + +static void +mainbus_attach(struct device *parent, struct device *self, void *aux) +{ + printf("\n"); + config_found(self, NULL, mainbus_print); +} + +struct cfattach mainbus_ca = { + sizeof(struct device), mainbus_match, mainbus_attach +}; diff --git a/sys/arch/pdp10/pdp10/clock.c b/sys/arch/pdp10/pdp10/clock.c new file mode 100644 index 000000000000..e9504ebeec17 --- /dev/null +++ b/sys/arch/pdp10/pdp10/clock.c @@ -0,0 +1,63 @@ +/* $NetBSD: clock.c,v 1.1 2003/08/19 10:54:59 ragge Exp $ */ +/* + * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se). + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include + +#include +#include + +/* + * The clock counts up each 10 us. + */ +#define TBASE 1000 /* Interrupt each 10 ms */ + +void +cpu_initclocks() +{ + CONO(MTR, IPL_CLOCK); /* Interrupt level */ + CONO(TIM, TIM_CON_CLIC|TIM_CON_ICON|TIM_CON_CLIF|TBASE); +} + +void +microtime(struct timeval *tvp) +{ + panic("microtime"); +} + +void +resettodr() +{ + panic("resettodr"); +} + +void +inittodr(time_t base) +{ + panic("inittodr"); +} diff --git a/sys/arch/pdp10/pdp10/console.c b/sys/arch/pdp10/pdp10/console.c new file mode 100644 index 000000000000..6b0ed5946c9c --- /dev/null +++ b/sys/arch/pdp10/pdp10/console.c @@ -0,0 +1,103 @@ +/* $NetBSD: console.c,v 1.1 2003/08/19 10:54:59 ragge Exp $ */ +/* + * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se). + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include + +#include + +#include +#include + +cons_decl(dte); + +struct consdev dtetab = cons_init(dte); + +static volatile struct dte { + int flg; /* Operation complete flag. */ + int clk; /* Clock interrupt flag. */ + int ci; /* Clock interrupt instruction. */ + int t11; /* 10 to 11 argument. */ + int f11; /* 10 from 11 argument. */ + int cmd; /* To 11 command word. */ + int seq; /* Operation sequence number. */ + int opr; /* Operational DTE #. */ + int chr; /* Last typed character. */ + int mtd; /* Monitor TTY output complete flag. */ + int mti; /* Monitor TTY input flag. */ + int swr; /* 10 switch register. */ +} *dte; + +static int isinited; + +void +dtecninit(struct consdev *cn) +{ + extern struct ept *ept; + if (isinited) + return; + + dte = (struct dte *)((int *)ept + 0444); + cn_tab = &dtetab; + dte->flg = dte->clk = dte->ci = 0; + isinited++; +} + +void +dtecnpollc(dev_t dev, int onoff) +{ +} + +void +dtecnputc(dev_t dev, int ch) +{ + dte->cmd = ch & 0177; + dte->seq++; + CONO(DTE,020000); + while (dte->flg == 0) + ; + dte->flg = 0; +} + +int +dtecngetc(dev_t dev) +{ + int rch; + + while (dte->mti == 0) + ; + rch = dte->f11 & 0177; + dte->mti = 0; + return rch; +} + +void +dtecnprobe(struct consdev *cn) +{ +} diff --git a/sys/arch/pdp10/pdp10/db_disasm.c b/sys/arch/pdp10/pdp10/db_disasm.c new file mode 100644 index 000000000000..6dc6739a32b4 --- /dev/null +++ b/sys/arch/pdp10/pdp10/db_disasm.c @@ -0,0 +1,44 @@ +/* $NetBSD: db_disasm.c,v 1.1 2003/08/19 10:54:59 ragge Exp $ */ +/* + * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se). + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include + +#include +#include + +#include +#include +#include + +db_addr_t +db_disasm(db_addr_t loc, boolean_t altfmt) +{ + int foo = *(int *)loc; + db_printf("addr 0%o: 0%012o\n", loc, foo); + return loc+4; +} diff --git a/sys/arch/pdp10/pdp10/db_machdep.c b/sys/arch/pdp10/pdp10/db_machdep.c new file mode 100644 index 000000000000..455d436f0020 --- /dev/null +++ b/sys/arch/pdp10/pdp10/db_machdep.c @@ -0,0 +1,128 @@ +/* $NetBSD: db_machdep.c,v 1.1 2003/08/19 10:55:00 ragge Exp $ */ +/* + * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se). + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "opt_ddb.h" + +#include + +#include + +#include +#include +#include + +db_regs_t ddb_regs; + + +void +ddbintr() +{ + db_trap(0, 0); +} +/* + * Read bytes from kernel address space for debugger. + */ +void +db_read_bytes(vaddr_t addr, size_t size, char *data) +{ + char *faddr = (char *)addr; + + while (size--) + *data++ = *faddr++; +} + +/* + * Write bytes to kernel address space for debugger. + */ +void +db_write_bytes(vaddr_t addr, size_t size, char *data) +{ + char *faddr = (char *)addr; + + while (size--) + *faddr++ = *data++; +} + +/* + * Machine register set. + */ +const struct db_variable db_regs[] = { + {"0", &ddb_regs.regs[0], FCN_NULL}, + {"1", &ddb_regs.regs[1], FCN_NULL}, + {"2", &ddb_regs.regs[2], FCN_NULL}, + {"3", &ddb_regs.regs[3], FCN_NULL}, + {"4", &ddb_regs.regs[4], FCN_NULL}, + {"5", &ddb_regs.regs[5], FCN_NULL}, + {"6", &ddb_regs.regs[6], FCN_NULL}, + {"7", &ddb_regs.regs[7], FCN_NULL}, + {"10", &ddb_regs.regs[8], FCN_NULL}, + {"11", &ddb_regs.regs[9], FCN_NULL}, + {"12", &ddb_regs.regs[10], FCN_NULL}, + {"13", &ddb_regs.regs[11], FCN_NULL}, + {"14", &ddb_regs.regs[12], FCN_NULL}, + {"15", &ddb_regs.regs[13], FCN_NULL}, + {"16", &ddb_regs.regs[14], FCN_NULL}, + {"17", &ddb_regs.regs[15], FCN_NULL}, + {"pc", &ddb_regs.pc, FCN_NULL}, +}; +const struct db_variable * const db_eregs = db_regs + sizeof(db_regs)/sizeof(db_regs[0]); + +void +db_stack_trace_print(db_expr_t addr, boolean_t have_addr, db_expr_t count, + char *modif, void (*pr)(const char *, ...)) +{ + (*pr)("db_stack_trace_print\n"); +} + +/* + * XXX - must fix the sstep functions. + */ + +boolean_t +inst_branch(int inst) +{ + return TRUE; +} + +boolean_t +inst_unconditional_flow_transfer(int inst) +{ + return TRUE; +} + +db_addr_t +branch_taken(int inst, db_addr_t pc, db_regs_t *regs) +{ + return pc + 4; +} + +db_addr_t +next_instr_address(db_addr_t pc, boolean_t bd) +{ + return pc + 4; +} diff --git a/sys/arch/pdp10/pdp10/disksubr.c b/sys/arch/pdp10/pdp10/disksubr.c new file mode 100644 index 000000000000..49beeb16fd71 --- /dev/null +++ b/sys/arch/pdp10/pdp10/disksubr.c @@ -0,0 +1,212 @@ +/* $NetBSD: disksubr.c,v 1.1 2003/08/19 10:55:00 ragge Exp $ */ + +/* + * Copyright (c) 1982, 1986, 1988 Regents of the University of California. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)ufs_disksubr.c 7.16 (Berkeley) 5/4/91 + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +/* + * Determine the size of the transfer, and make sure it is + * within the boundaries of the partition. Adjust transfer + * if needed, and signal errors or early completion. + */ +int +bounds_check_with_label(struct disk *dk, struct buf *bp, int wlabel) +{ + struct disklabel *lp = dk->dk_label; + struct partition *p = lp->d_partitions + DISKPART(bp->b_dev); + int labelsect = lp->d_partitions[2].p_offset; + int maxsz = p->p_size, + sz = (bp->b_bcount + DEV_BSIZE - 1) >> DEV_BSHIFT; + /* overwriting disk label ? */ + if (bp->b_blkno + p->p_offset <= LABELSECTOR + labelsect && + (bp->b_flags & B_READ) == 0 && wlabel == 0) { + bp->b_error = EROFS; + goto bad; + } + + /* beyond partition? */ + if (bp->b_blkno < 0 || bp->b_blkno + sz > maxsz) { + /* if exactly at end of disk, return an EOF */ + if (bp->b_blkno == maxsz) { + bp->b_resid = bp->b_bcount; + return(0); + } + /* or truncate if part of it fits */ + sz = maxsz - bp->b_blkno; + if (sz <= 0) { + bp->b_error = EINVAL; + goto bad; + } + bp->b_bcount = sz << DEV_BSHIFT; + } + + /* calculate cylinder for disksort to order transfers with */ + bp->b_cylinder = (bp->b_blkno + p->p_offset) / lp->d_secpercyl; + return(1); + +bad: + bp->b_flags |= B_ERROR; + return(-1); +} + +/* + * Attempt to read a disk label from a device + * using the indicated strategy routine. + * The label must be partly set up before this: + * secpercyl and anything required in the strategy routine + * (e.g., sector size) must be filled in before calling us. + * Returns null on success and an error string on failure. + */ +char * +readdisklabel(dev_t dev, void (*strat)(struct buf *), + struct disklabel *lp, struct cpu_disklabel *osdep) +{ + struct buf *bp; + struct disklabel *dlp; + char *msg = NULL; + + if (lp->d_npartitions == 0) { /* Assume no label */ + lp->d_secperunit = 0x1fffffff; + lp->d_npartitions = 3; + lp->d_partitions[2].p_size = 0x1fffffff; + lp->d_partitions[2].p_offset = 0; + } + + bp = geteblk((int)lp->d_secsize); + bp->b_dev = dev; + bp->b_blkno = LABELSECTOR; + bp->b_bcount = lp->d_secsize; + bp->b_flags |= B_READ; + bp->b_cylinder = LABELSECTOR / lp->d_secpercyl; + (*strat)(bp); + if (biowait(bp)) { + msg = "I/O error"; + } else { + dlp = (struct disklabel *)(bp->b_data + LABELOFFSET); + if (dlp->d_magic != DISKMAGIC || dlp->d_magic2 != DISKMAGIC) { + msg = "no disk label"; + } else if (dlp->d_npartitions > MAXPARTITIONS || + dkcksum(dlp) != 0) + msg = "disk label corrupted"; + else { + *lp = *dlp; + } + } + brelse(bp); + return (msg); +} + +/* + * Check new disk label for sensibility + * before setting it. + */ +int +setdisklabel(struct disklabel *olp, struct disklabel *nlp, + u_long openmask, struct cpu_disklabel *osdep) +{ + int i; + struct partition *opp, *npp; + + if (nlp->d_magic != DISKMAGIC || nlp->d_magic2 != DISKMAGIC || + dkcksum(nlp) != 0) + return (EINVAL); + while ((i = ffs(openmask)) != 0) { + i--; + openmask &= ~(1 << i); + if (nlp->d_npartitions <= i) + return (EBUSY); + opp = &olp->d_partitions[i]; + npp = &nlp->d_partitions[i]; + if (npp->p_offset != opp->p_offset || npp->p_size < opp->p_size) + return (EBUSY); + /* + * Copy internally-set partition information + * if new label doesn't include it. XXX + */ + if (npp->p_fstype == FS_UNUSED && opp->p_fstype != FS_UNUSED) { + npp->p_fstype = opp->p_fstype; + npp->p_fsize = opp->p_fsize; + npp->p_frag = opp->p_frag; + npp->p_cpg = opp->p_cpg; + } + } + nlp->d_checksum = 0; + nlp->d_checksum = dkcksum(nlp); + *olp = *nlp; + return (0); +} + +/* + * Write disk label back to device after modification. + * Always allow writing of disk label; even if the disk is unlabeled. + */ +int +writedisklabel(dev_t dev, void (*strat)(struct buf *), + struct disklabel *lp, struct cpu_disklabel *osdep) +{ + struct buf *bp; + struct disklabel *dlp; + int error = 0; + + bp = geteblk((int)lp->d_secsize); + bp->b_dev = MAKEDISKDEV(major(dev), DISKUNIT(dev), RAW_PART); + bp->b_blkno = LABELSECTOR; + bp->b_bcount = lp->d_secsize; + bp->b_flags |= B_READ; + (*strat)(bp); + if ((error = biowait(bp))) + goto done; + dlp = (struct disklabel *)(bp->b_data + LABELOFFSET); + bcopy(lp, dlp, sizeof(struct disklabel)); + bp->b_flags &= ~(B_READ|B_DONE); + bp->b_flags |= B_WRITE; + (*strat)(bp); + error = biowait(bp); + +done: + brelse(bp); + return (error); +} diff --git a/sys/arch/pdp10/pdp10/kl10.c b/sys/arch/pdp10/pdp10/kl10.c new file mode 100644 index 000000000000..c8fd13bee7a7 --- /dev/null +++ b/sys/arch/pdp10/pdp10/kl10.c @@ -0,0 +1,61 @@ +/* $NetBSD: kl10.c,v 1.1 2003/08/19 10:55:00 ragge Exp $ */ +/* + * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se). + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include + +#include +#include + + +#define OPTSTR "\177\10b\43T20PAG\0b\42EXADDR\0b\41EXOTIC\0" \ + "b\21C50HZ\0b\20CACHE\0b\17CHANNEL\0b\16EXTCPU\0b\15MASTEROSC\0\0" + +void +kl10_conf() +{ + char buf[100]; + unsigned int cpup; + + /* + * Identify CPU type. + */ + BLKI(0, cpup); + strcpy(cpu_model, "KL10-"); + cpu_model[5] = (cpup & 040000 ? 'E' : 'A'); + printf("\ncpu: %s, serial number 0%o, microcode version 0%o\n", + cpu_model, cpup & 07777, (cpup >> 18) & 0777); + bitmask_snprintf((unsigned long long)cpup, OPTSTR, buf, sizeof(buf)); + printf("cpu options: %s\n", buf); + +#ifdef notyet + /* + * Turn on cache system. + */ +#endif +} diff --git a/sys/arch/pdp10/pdp10/locore.S b/sys/arch/pdp10/pdp10/locore.S new file mode 100644 index 000000000000..11db8227067a --- /dev/null +++ b/sys/arch/pdp10/pdp10/locore.S @@ -0,0 +1,532 @@ +/* $NetBSD: locore.S,v 1.1 2003/08/19 10:55:00 ragge Exp $ */ +/* + * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se). + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "opt_ddb.h" + +#include +#include +#include + +#define HALT(x) jrst %4,x + +#define PGSZ 01000 /* In words */ +#define PGMSK (PGSZ-1) +#define NPGMSK 0777000 /* (~PGMSK) */ +#define SP %17 +#define FP %16 + +#define PTOFF(off,arg) skipa %2,.+1 ; arg ; movem %2,off(%1) + +#define INTRDEF(eptoff, p0off, dst) \ + PTOFF(eptoff,xpcw p0off) ; xmovei %3,dst ; movem %3,@[.long p0off+3] +/* + * A bunch of instructions. These should be recognized by the assembler. + */ +#define xpcw jrst %7, +#define xjen jrst %6, + +/* + * Usage of page 0 for interrupt dispatchers. + */ +#define HIGHPOS 020 +#define DDBPOS 024 +#define CLKPOS 030 +#define NETPOS 034 +#define BIOPOS 040 +#define TTYPOS 044 +#define SNETPOS 050 +#define SCLKPOS 054 + + .data + .globl avail_start /* Physical memory availability */ + .globl avail_end + .globl proc0paddr,ept +avail_start: .long 0 +avail_end: .long 0 +proc0paddr: .long 0 +istack: .long 0 +ept: .long 0 +#ifdef DDB +ddbstack: .long 0 +#endif + +/* Longwords to switch between register blocks quick */ +moniw: .long 0400100000000 /* Current block 0, previous user */ +useriw: .long 0401100000000 /* Current user, previous user */ +intiw: .long 0402000000000 /* Current int, previous monitor */ +ddbiw: .long 0403000000000 /* Current ddb, previous monitor */ + +ENTRY(start) + + /* + * Set interrupt stack directly after end, + * and at least one page in size. + */ + xmovei %10,end + movem %10,istack + addi %10,2*PGSZ + trz %10,PGMSK # trunc to page boundary + datao %PAG,intiw # switch to interrupt block + move %17,istack # set interrupt stack + datao %PAG,moniw # back to monitor block + + /* + * Setup Executive Process Table as next. + */ + movem %10,ept + move %1,010 + skipa %2,.+1 + pushj %17,earov + movem %2,0421(%1) + PTOFF(0422,jrst esov) + PTOFF(0423,jrst etrap3) + + /* + * Interrupt setup. This is somewhat hairy, the interrupt protocol + * on KL10 is not simple. Page 0 in memory is used for xpcw. + */ + INTRDEF(0514,CLKPOS,_hardclock) + INTRDEF(040,HIGHPOS,panic) /* Yech! */ + INTRDEF(042,DDBPOS,_ddbintr) +/* INTRDEF(044,CLKPOS,_hardclock) separate vector */ + INTRDEF(046,NETPOS,_netintr) + INTRDEF(050,BIOPOS,_biointr) + INTRDEF(052,TTYPOS,_ttyintr) + INTRDEF(054,SNETPOS,_softnet) + INTRDEF(056,SCLKPOS,_softclock) + + addi %10,PGSZ + /* + * Process 0 user area (proc0paddr) located directly thereafter. + * Guard pages? + */ + movem %10,proc0paddr + addi %10,PGSZ /* Skip UPT */ + move %17,%10 /* Process 0 stackpointer XXX uarea */ + addi %10,PGSZ /* The rest of USPACE */ + move %1,proc0paddr + pushj %17,setup_upt /* Set trap addresses */ + +#ifdef DDB + movem %10,ddbstack # ddb has a private stack + addi %10,PGSZ # make it one page in size + movsi %1,0403000 # set ac block, current == 3 + datao %PAG,1 # doit! + move %17,ddbstack # put stack address in stack pointer + datao %PAG,moniw # back to monitor ac block, +#endif + + movem %10,avail_start /* available memory */ + + /* + * Setup memory management. + */ + pushj %17,pmap_bootstrap + + /* + * Done here, jump to main now. + */ + pushj %17,main + HALT(1) + +/* + * Check if this address is nonexisting. + */ +ENTRY(badaddr) + move %3,proc0paddr+0503 # save old trap pc + xmovei %4,bad1 # address if trapping + movem %4,proc0paddr+0503 # set new address + move %2,020(%1) # skip register block + movem %3,proc0paddr+0503 # restore trap handler + movei %1,0 # not a bad address + popj %17, + +bad1: movem %3,proc0paddr+0503 # restore trap handler + movei %1,1 # was bad address + popj %17, + +/* + * Copy routines. + */ + .data +reta: .long 0 # return address after fault +retv: .long 0 # return value + +ENTRY(copyin) HALT(017) +ENTRY(copyout) HALT(022) +ENTRY(copyinstr) HALT(023) +ENTRY(copyoutstr) HALT(024) + +/* + * Copy string in-kernel. + * Check for fault in trap routine, not here. + * XXX - *done length is wrong if it faults, is this OK? + */ +ENTRY(copystr) +jrst %4,0567 + xmovei %6,L_cps3 # r6 = &L_cps3; + movem %6,reta # reta = r6 + setzm retv # retv = 0; + move %6,%3 # olen = len + +L_cps2: subi %3,1 # len-- + camn %3,[.long -1] # if (len == -1) + jrst L_cps1 # goto L_cps1 + ldb %7,%1 # r7 = *from + dpb %7,%2 # *to = r7 + ibp %1 # from++; + ibp %2 # to++; + jumpn %7,L_cps2 # if (r7 != 0) goto L_cps2 + +L_cps1: jumpe %4,L_cps3 # if (done == 0) goto L_cps3 + sub %6,%3 # olen -= len; + addi %6,1 # olen++; + movem %6,(%4) # *done = olen; + +L_cps3: move %1,retv # r1 = retv + popj %17, # return r1; + + + +ENTRY(kcopy) HALT(026) + +ENTRY(suword) HALT(027) +ENTRY(subyte) HALT(030) +ENTRY(suswintr) HALT(031) +ENTRY(fuswintr) HALT(032) + +/* + * spl routines should be macron in the future. + */ +#define SVPRI coni PI,%1 ; andi %1,PI_ALL +#define ALTERSPL(val) SVPRI ; cono PI,(PI_LVLOFF|val) ; popj SP, + +ENTRY(splhigh) + ALTERSPL(PI_ALL) # Block all levels + +ENTRY(splclock) + ALTERSPL(PI_CLOCK) # Block hardclock + +ENTRY(splnet) + ALTERSPL(PI_NET) # Block network adapters + +ENTRY(splsched) + ALTERSPL(PI_ALL) # Block all levels XXX + +ENTRY(splvm) + ALTERSPL(PI_BIO|PI_TTY|PI_NET) # Block disks, ttys and network adapters + +ENTRY(spllock) + ALTERSPL(PI_ALL) # Block all levels XXX + +ENTRY(splbio) + ALTERSPL(PI_BIO) # Block disks + +ENTRY(splstatclock) + ALTERSPL(PI_CLOCK) # Block hardclock + +ENTRY(splsoftnet) + ALTERSPL(PI_SOFTCLOCK) # Block soft network protocols + +ENTRY(spltty) + ALTERSPL(PI_TTY) # Block ttys + +ENTRY(spl0) # Unblock everything + cono PI,PI_LVLON|PI_ON|PI_ALL + popj SP, + + +/* + * This routine is problematic. The only way to lower an interrupt is + * through xjen, which resets the interrupt level. For now we don't try + * to do anything clever; set CLKF_BASEPRI() to 0 and avoid this routine. + */ +ENTRY(spllowersoftclock) + HALT(044) + +/* + * Lower the current interrupt level. If softclock was blocked but is + * now unblocked, call for an interrupt. + */ +ENTRY(splx) + move %1,-1(SP) + iori %1,PI_LVLON + cono PI,(%1) + skipn %1,L_want_soft # Skip if any softbit is set + popj SP, + trne %1,PI_SOFTCLOCK # Skip if softclock not set. + pushj SP,setsoftclock # Try to send another + trne %1,PI_SOFTNET # Skip if softnet not set. + pushj SP,setsoftnet # Try to send another setsoftnet + popj SP, + + .data +L_want_soft: + .long 0 + +/* + * Ask for a softclock interrupt. If softclock is blocked, set a flag that + * posts a softclock interrupt when it is unblocked. + */ +ENTRY(setsoftclock) + coni PI,%1 # get current interrupt mask + trne %1,PI_SOFTCLOCK # skip if masked + cono PI,PI_INIT|PI_SOFTCLOCK # send interrupt request + movei %1,PI_SOFTCLOCK + iorm %1,L_want_soft # request soft intr + popj SP, + +ENTRY(setsoftnet) + coni PI,%1 # get current interrupt mask + trne %1,PI_SOFTNET # skip if masked + cono PI,PI_INIT|PI_SOFTNET # send interrupt request + movei %1,PI_SOFTNET + iorm %1,L_want_soft # request soft intr + popj SP, + +ENTRY(sigcode) + HALT(0) +ENTRY(esigcode) + +ENTRY(signotify) + popj %17, + +ENTRY(need_proftick) HALT(066) + +earov: + + HALT(067) +esov: HALT(070) +etrap3: HALT(071) + +/* + * Interrupt handling stuff + */ +#define INTR_SAVE(myword) \ + datai PAG,myword ; datao PAG,intiw ; \ + xmovei SP,011(SP) ; dmovem %0,-010(SP) ; dmovem %2,-6(SP) ; \ + dmovem %4,-4(SP) ; dmovem %6,-2(SP) ; move %1,myword ; movem %1,(SP) +#define INTR_RESTORE(myword) \ + move %1,(SP) ; tlz %1,0100000 ; movem %1,myword ; dmove %6,-2(SP) ; \ + dmove %4,-4(SP) ; dmove %2,-6(SP) ; dmove %0,-010(SP) ; \ + xmovei %17,-011(SP) ; datao %PAG,myword ; + + .data +L_hcpw: .long 0 /* Saved pager word at hardclock */ +L_scpw: .long 0 /* Saved pager word at softclock */ +L_biow: .long 0 /* Saved pager word at diskintr */ +L_ddbw: .long 0 /* Saved pager word at ddb */ + + .text + +#ifdef DDB +# Workaround for buggy assembler +xct1: blt %1,ddb_regs+15 +xct2: blt %1,015 +#endif + +/* + * Save a trapframe onto the interrupt stack with the current + * register contents. First set the previous context correct. + */ +_ddbintr: +#ifdef DDB + datai %PAG,L_ddbw ; datao %PAG,ddbiw + hllz %1,L_ddbw # fetch only left-half of pager word + tlz %1,0770777 # clear everything except "current" AC block + lsh %1,-3 # put ac block in previous position + ior %1,ddbiw # create pager word + datao %PAG,01 # set correct previous context + + movei %1,ddb_regs # only lower 18 bits please + xct %1,xct1 # pxct, fetch regs + move %2,@[ .long DDBPOS+1 ] # get pc + xmovei %1,ddb_regs + movem %2,020(%1) # store pc + + pushj %17,ddbintr + + movsi %1,ddb_regs + xct %4,xct2 # restore regs + xmovei %1,ddb_regs + move %2,020(%1) + movem %2,@[ .long DDBPOS+1 ] + +#endif + cono PI,020100 # clear ddb interrupt + xjen @[.long DDBPOS] + +_hardclock: + cono TIM,061750 # Clear timer interrupt + INTR_SAVE(L_hcpw) + xmovei %1,(SP) # Clock frame + pushj SP,hardclock + INTR_RESTORE(L_hcpw) + xjen @[.long CLKPOS] + +_netintr: + HALT(072) + +_biointr: +#if 1 + INTR_SAVE(L_biow) + pushj SP,rhintr + INTR_RESTORE(L_biow) + xjen @[.long BIOPOS] +#else + HALT(073) +#endif + +_ttyintr: + HALT(074) + +_softnet: + HALT(075) + +_softclock: + INTR_SAVE(L_scpw) + pushj SP,softclock + INTR_RESTORE(L_scpw) + cono PI,PI_DROP|PI_SOFTCLOCK # clear softclock interrupt + movei %1,2 + andi %1,L_want_soft # clear request word + xjen @[.long SCLKPOS] + + +ENTRY(pcb_ovtrap) HALT(0421) +ENTRY(pcb_ovstack) HALT(0422) +ENTRY(pcb_trap3) HALT(0423) +ENTRY(pcb_knotrap) HALT(0430) +ENTRY(pcb_ktrap) HALT(0431) +ENTRY(pcb_snotrap) HALT(0432) +ENTRY(pcb_strap) HALT(0433) +ENTRY(pcb_cnotrap) HALT(0434) +ENTRY(pcb_ctrap) HALT(0435) +ENTRY(pcb_pnotrap) HALT(0436) +ENTRY(pcb_ptrap) HALT(0437) + +ENTRY(pcb_pfnpc) + push SP,proc0paddr + pushj SP,pagefail + HALT(0503); + +/* + * Write the needed trap addresses into a new User Process Table. + * The UPT page must be zeroed before call. Pointer to it in reg 1. + */ +ENTRY(setup_upt) + PTOFF(0421, jrst pcb_ovtrap) + PTOFF(0422, jrst pcb_ovstack) + PTOFF(0423, jrst pcb_trap3) + PTOFF(0430, .long pcb_knotrap) + PTOFF(0431, .long pcb_ktrap) + PTOFF(0432, .long pcb_snotrap) + PTOFF(0433, .long pcb_strap) + PTOFF(0434, .long pcb_cnotrap) + PTOFF(0435, .long pcb_ctrap) + PTOFF(0436, .long pcb_pnotrap) + PTOFF(0437, .long pcb_ptrap) + PTOFF(0503, .long pcb_pfnpc) + popj SP, + +#ifdef __PCC__ +ENTRY(datao) + move %1,-1(%17) # get device + lsh %1,030 # shift left 24 step + ior %1,[.long 0700140000002 ] # create instruction + move %2,-2(%17) # get value + xct %1 # doit! + popj %17, + +ENTRY(datai) + move %1,-1(%17) # get device + lsh %1,030 # shift left 24 step + ior %1,[.long 0700040000001 ] # create instruction + xct %1 # doit! + popj %17, + +ENTRY(cono) + move %1,-1(%17) # get device + lsh %1,030 # shift left 24 step + tlo %1,0700200 # create instruction + hrr %1,-2(%17) # get value + xct %1 # doit! + popj %17, + +ENTRY(coni) + move %1,-1(%17) # get device + lsh %1,030 # shift left 24 step + ior %1,[.long 0700240000001 ] # create instruction + xct %1 # doit! + popj %17, + +ENTRY(blko) + HALT(0604); + +ENTRY(blki) + move %1,-1(%17) # get device + lsh %1,030 # shift left 24 step + ior %1,[.long 0700000000001 ] # create instruction + xct %1 + popj %17, + +ENTRY(clrpt) + HALT(0606); +#endif + +#ifdef DDB +ENTRY(setjmp) + move %1,-1(%17) # Get jmp_buf pointer + move %2,(%17) # Get return PC + movem %2,1(%1) # Save PC + move %2,%17 # Get SP + movem %2,2(%1) # Save SP + movem %16,3(%1) # Save FP + dmovem %10,010(%1) # Save reg 10+11 + dmovem %12,012(%1) # Save reg 12+13 + dmovem %14,014(%1) # Save reg 14+15 + setz %1, # Return 0 + popj %17, + +ENTRY(longjmp) + move %3,-1(%17) # Get jmp_buf pointer + move %1,-2(%17) # Get return value + dmove %14,014(%3) # Restore reg 14+15 + dmove %12,012(%3) # Restore reg 12+13 + dmove %10,010(%3) # Restore reg 10+11 + move %16,3(%3) # Restore FP + move %17,2(%3) # Restore SP + move %2,1(%3) # Get return PC + movem %2,(%17) # Save PC + popj %17, + +ENTRY(cpu_Debugger) + cono PI,06300 # debugger runs on IPL 1 +jrst %4,.+1 + popj %17, +#endif diff --git a/sys/arch/pdp10/pdp10/machdep.c b/sys/arch/pdp10/pdp10/machdep.c new file mode 100644 index 000000000000..58d70586a725 --- /dev/null +++ b/sys/arch/pdp10/pdp10/machdep.c @@ -0,0 +1,283 @@ +/* $NetBSD: machdep.c,v 1.1 2003/08/19 10:55:00 ragge Exp $ */ +/* + * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se). + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +int physmem; +struct cpu_info cpu_info_store; +struct vm_map *exec_map, *mb_map; +char machine[] = MACHINE; /* from */ +char machine_arch[] = MACHINE_ARCH; /* from */ +char cpu_model[100]; +caddr_t msgbufaddr; + +void +cpu_startup() +{ + extern int avail_end; + vaddr_t minaddr, maxaddr; + vsize_t size; + caddr_t v; + char pbuf[9]; + int sz, base, i, residual; + + spl0(); /* Enable interrupts */ + + /* + * Initialize error message buffer. + */ + initmsgbuf(msgbufaddr, round_page(MSGBUFSIZE)); + + /* + * Good {morning,afternoon,evening,night}. + */ + format_bytes(pbuf, sizeof(pbuf), avail_end); + pbuf[strlen(pbuf)-1] = 0; /* Remove 'B' */ + printf("total memory = %sW\n", pbuf); + /* + * Find out how much space we need, allocate it, and then give + * everything true virtual addresses. + */ + + sz = (int) allocsys(NULL, NULL); + if ((v = (caddr_t)uvm_km_zalloc(kernel_map, round_page(sz))) == 0) + panic("startup: no room for tables"); + if ((allocsys(v, NULL) - v) != sz) + panic("startup: table size inconsistency"); + /* + * Now allocate buffers proper. They are different than the above in + * that they usually occupy more virtual memory than physical. + */ + size = MAXBSIZE * nbuf; /* # bytes for buffers */ + + /* allocate VM for buffers... area is not managed by VM system */ + if (uvm_map(kernel_map, &minaddr, round_page(size), + NULL, UVM_UNKNOWN_OFFSET, 0, + UVM_MAPFLAG(UVM_PROT_NONE, UVM_PROT_NONE, UVM_INH_NONE, + UVM_ADV_NORMAL, 0)) != 0) + panic("cpu_startup: cannot allocate VM for buffers"); + + buffers = (char *)minaddr; + if ((bufpages / nbuf) >= btoc(MAXBSIZE)) { + /* don't want to alloc more physical mem than needed */ + bufpages = btoc(MAXBSIZE) * nbuf; + } + base = bufpages / nbuf; + residual = bufpages % nbuf; + /* now allocate RAM for buffers */ + for (i = 0 ; i < nbuf ; i++) { + vaddr_t curbuf; + vsize_t curbufsize; + struct vm_page *pg; + + /* + * First buffers get (base+1) physical pages + * allocated for them. The rest get (base) physical pages. + * + * The rest of each buffer occupies virtual space, but has no + * physical memory allocated for it. + */ + curbuf = (vaddr_t) buffers + i * MAXBSIZE; + curbufsize = NBPG * (i < residual ? base + 1 : base); + while (curbufsize) { + pg = uvm_pagealloc(NULL, 0, NULL, 0); + if (pg == NULL) + panic("cpu_startup: " + "not enough RAM for buffer cache"); + pmap_kenter_pa(curbuf, VM_PAGE_TO_PHYS(pg), + VM_PROT_READ | VM_PROT_WRITE); + curbuf += NBPG; + curbufsize -= NBPG; + } + } + + /* + * Allocate a submap for exec arguments. This map effectively limits + * the number of processes exec'ing at any time. + * At most one process with the full length is allowed. + */ + exec_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr, + NCARGS/4, VM_MAP_PAGEABLE, FALSE, NULL); + + /* + * allocate mbuf cluster submap. + */ + mb_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr, + nmbclusters * mclbytes, VM_MAP_INTRSAFE, FALSE, NULL); + + format_bytes(pbuf, sizeof(pbuf), ptoa(uvmexp.free)/4); + pbuf[strlen(pbuf)-1] = 0; /* Remove 'B' */ + printf("avail memory = %sW\n", pbuf); + + format_bytes(pbuf, sizeof(pbuf), bufpages * NBPG/4); + pbuf[strlen(pbuf)-1] = 0; /* Remove 'B' */ + printf("using %d buffers containing %sW of memory\n", nbuf, pbuf); + + /* + * Set up buffers, so they can be used to read disk labels. + */ + + bufinit(); +#ifdef DDB + if (boothowto & RB_KDB) + Debugger(); +#endif + + kl10_conf(); +} + +void +consinit() +{ + void dtecninit(struct consdev *); + dtecninit(NULL); +} + +int +process_read_regs(struct lwp *p, struct reg *regs) +{ + panic("process_read_regs"); + return 0; +} + +void +cpu_dumpconf() +{ + panic("cpu_dumpconf"); +} + +void +setstatclockrate(int hzrate) +{ +} + +int +sys___sigreturn14(struct lwp *p, void *v, register_t *retval) +{ + panic("sys___sigreturn14"); + return 0; +} + +void +sendsig(int sig, sigset_t *mask, u_long code) +{ + panic("sendsig"); +} + +void +cpu_wait(struct lwp *p) +{ + panic("cpu_wait"); +} + +void +cpu_exit(struct lwp *p, int a) +{ + panic("cpu_exit"); +} + +void +cpu_reboot(int howto, char *b) +{ + printf("cpu_reboot\n"); + asm("jrst 4,0765432"); + panic("foo"); +} + +int +cpu_sysctl(int *a, u_int b, void *c, size_t *d, void *e, + size_t f, struct proc *g) +{ + return (EOPNOTSUPP); +} + +int +process_set_pc(struct lwp *p, caddr_t addr) +{ + panic("process_set_pc"); +} + +int +process_sstep(struct lwp *p, int sstep) +{ + panic("process_sstep"); +} + +int +process_write_regs(struct lwp *p, struct reg *regs) +{ + panic("process_write_regs"); +} + +void +cpu_upcall(struct lwp *l, int type, int nevents, int ninterrupted, + void *sas, void *ap, void *sp, sa_upcall_t upcall) +{ + panic("cpu_upcall"); +} + +void +cpu_getmcontext(struct lwp *l, mcontext_t *mcp, unsigned int *flags) +{ + panic("cpu_getmcontext"); +} + +int +cpu_setmcontext(struct lwp *l, const mcontext_t *mcp, unsigned int flags) +{ + panic("cpu_setmcontext"); + return 0; +} + +int +cpu_switch (struct lwp *p, struct lwp *op) +{ + panic("cpu_switch"); +} + +void +cpu_switchto (struct lwp *p, struct lwp *op) +{ + panic("cpu_switchto"); +} + diff --git a/sys/arch/pdp10/pdp10/mem.c b/sys/arch/pdp10/pdp10/mem.c new file mode 100644 index 000000000000..7446d7f16ca2 --- /dev/null +++ b/sys/arch/pdp10/pdp10/mem.c @@ -0,0 +1,162 @@ +/* $NetBSD: mem.c,v 1.1 2003/08/19 10:55:00 ragge Exp $ */ + +/* + * Copyright (c) 1988 University of Utah. + * Copyright (c) 1982, 1986, 1990, 1993 + * The Regents of the University of California. All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * the Systems Programming Group of the University of Utah Computer + * Science Department. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * @(#)mem.c 8.3 (Berkeley) 1/12/94 + */ + +/* + * Memory special file + */ + +#include +__KERNEL_RCSID(0, "$NetBSD: mem.c,v 1.1 2003/08/19 10:55:00 ragge Exp $"); + +#include "opt_compat_netbsd.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +extern char *vmmap; /* poor name! */ +caddr_t zeropage; + +dev_type_read(mmrw); +dev_type_ioctl(mmioctl); + +const struct cdevsw mem_cdevsw = { + nullopen, nullclose, mmrw, mmrw, mmioctl, + nostop, notty, nopoll, nommap, nokqfilter, +}; + +/*ARGSUSED*/ +int +mmrw(dev, uio, flags) + dev_t dev; + struct uio *uio; + int flags; +{ + register vaddr_t o, v; + register int c; + register struct iovec *iov; + int error = 0; + static int physlock; + vm_prot_t prot; + + if (minor(dev) == DEV_MEM) { + /* lock against other uses of shared vmmap */ + while (physlock > 0) { + physlock++; + error = tsleep((caddr_t)&physlock, PZERO | PCATCH, + "mmrw", 0); + if (error) + return (error); + } + physlock = 1; + } + while (uio->uio_resid > 0 && !error) { + iov = uio->uio_iov; + if (iov->iov_len == 0) { + uio->uio_iov++; + uio->uio_iovcnt--; + if (uio->uio_iovcnt < 0) + panic("mmrw"); + continue; + } + switch (minor(dev)) { + case DEV_MEM: + v = uio->uio_offset; + prot = uio->uio_rw == UIO_READ ? VM_PROT_READ : + VM_PROT_WRITE; + pmap_enter(pmap_kernel(), (vaddr_t)vmmap, + trunc_page(v), prot, PMAP_WIRED|prot); + pmap_update(pmap_kernel()); + o = uio->uio_offset & PGOFSET; + c = min(uio->uio_resid, (int)(PAGE_SIZE - o)); + error = uiomove((caddr_t)vmmap + o, c, uio); + pmap_remove(pmap_kernel(), (vaddr_t)vmmap, + (vaddr_t)vmmap + PAGE_SIZE); + pmap_update(pmap_kernel()); + break; + + case DEV_KMEM: + v = uio->uio_offset; + c = min(iov->iov_len, MAXPHYS); + if (!uvm_kernacc((caddr_t)v, c, + uio->uio_rw == UIO_READ ? B_READ : B_WRITE)) + return (EFAULT); + error = uiomove((caddr_t)v, c, uio); + break; + + case DEV_NULL: + if (uio->uio_rw == UIO_WRITE) + uio->uio_resid = 0; + return (0); + + case DEV_ZERO: + if (uio->uio_rw == UIO_WRITE) { + uio->uio_resid = 0; + return (0); + } + if (zeropage == NULL) { + zeropage = (caddr_t) + malloc(PAGE_SIZE, M_TEMP, M_WAITOK); + memset(zeropage, 0, PAGE_SIZE); + } + c = min(iov->iov_len, PAGE_SIZE); + error = uiomove(zeropage, c, uio); + break; + + default: + return (ENXIO); + } + } + if (minor(dev) == DEV_MEM) { + if (physlock > 1) + wakeup((caddr_t)&physlock); + physlock = 0; + } + return (error); +} diff --git a/sys/arch/pdp10/pdp10/pmap.c b/sys/arch/pdp10/pdp10/pmap.c new file mode 100644 index 000000000000..d58fea2fb01b --- /dev/null +++ b/sys/arch/pdp10/pdp10/pmap.c @@ -0,0 +1,393 @@ +/* $NetBSD: pmap.c,v 1.1 2003/08/19 10:55:00 ragge Exp $ */ +/* + * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se). + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include + +#include +#include + +#include + +#include +#include + +#define PGSH 9 /* Page shift in words */ +#define PGSZ (1 << PGSH) /* Page size in words */ +#define SECTSZ (PGSZ << PGSH) /* Size of a section */ +#define NSECT 32 /* 32 sections */ +#define PTOV_COMP 2 /* Shift to compensate for word addresses */ + +#define SEGNO(addr) ((addr) >> 18) /* Get segment */ +#define PGINSEG(page) (((page) & 0777000) >> PGSH) +#define PGNO(page) ((page) >> PGSH) + +#define mk2word(x) ((x) /= 4) +#define word2byte(x) ((x) * 4) + +#define PMAPDEBUG +#ifdef PMAPDEBUG +int startpmapdebug = 0; +#define PMDEBUG(x) if (startpmapdebug)printf x +#else +#define PMDEBUG(x) +#endif + +#ifdef __GNUC__ +#define CLRPT(x) \ + asm("move 6,%0 \n .long 0701106000000" : : "r"(x) : "6"); +#endif +#ifdef __PCC__ +#define CLRPT(x) clrpt(x) +void clrpt(int); +#endif + +void pmap_bootstrap(void); +int badaddr(int addr); + +struct pmap kernel_pmap_store; +char *vmmap; +static int *mapaddr, *mappte; /* Used for pmap_{copy,zero}_page */ +extern int avail_start, avail_end; /* These are in words, not bytes */ +extern struct ept *ept; +extern int proc0paddr; + +void +pmap_bootstrap() +{ + int i, guardpage; + extern caddr_t msgbufaddr; + TUNION uu; + + /* + * Setup executive and user process table but do not enable paging. + */ + DATAO(PAG,proc0paddr >> PGSH | PAG_DATA_LUBA | PAG_DATA_DNUA); + CONO(PAG, TPTOINT(ept) >> PGSH); + +#ifdef notyet + /* Count up memory */ + for (i = 1*1024*1024; ; i += PGSZ) + if (badaddr(i)) + break; +#else + i = 4*1024*1024; +#endif + avail_end = i; + +#ifdef DEBUG + { + extern int end[]; + consinit(); + printf("Kernel end %o kstack end %o\n", end, avail_start); + printf("EPT %o UPT %o\n", ept, proc0paddr); + } +#endif + + /* + * Enter the following 32 pages as kernel page table pages. + * Skip section 0 page, and let it act as a guard page. + */ + guardpage = avail_start; + for (i = 0; i < NSECT; i++) { + ept->ept_section[i] = PG_IMM|PG_WRITE | PGNO(avail_start); + avail_start += PGSZ; + } + /* Map kernel memory 1:1 */ + for (i = KERNBASE; i < avail_start; i += PGSZ) + pmap_kenter_pa(i*4, i*4, VM_PROT_READ|VM_PROT_WRITE); + + /* Map in page 0 at page 0. It is used for interrupts */ + pmap_kenter_pa(0, 0, VM_PROT_READ|VM_PROT_WRITE); + + /* Remove section page for section 0. Used as a guard page */ + { /* XXX - use pmap_kremove */ + int *ptep = TINTTOP((ept->ept_section[1] & 07777777) << PGSH); + mappte = &ptep[PGINSEG(guardpage)]; + mapaddr = TINTTOP(guardpage); + ptep[PGINSEG(guardpage)] = 0; + } + + /* Set logical page size */ + uvmexp.pagesize = NBPG; + uvm_setpagesize(); + physmem = avail_end/PGSZ; + + /* Kernel message buffer */ + avail_end -= MSGBUFSIZE/4; + msgbufaddr = TINTTOCP(avail_start | 0700000000000); + for (i = 0; i < MSGBUFSIZE/4; i += PGSZ) + pmap_kenter_pa(word2byte(avail_start+i), + word2byte(avail_end+i), VM_PROT_READ|VM_PROT_WRITE); + avail_start += MSGBUFSIZE/4; + + /* + * Give away memory to UVM. + */ + uvm_page_physload(avail_start >> PGSH, avail_end >> PGSH, + avail_start >> PGSH, avail_end >> PGSH, VM_FREELIST_DEFAULT); +#ifdef notyet + /* Lost section zero pages */ + uvm_page_physload(0, PGSZ. 0, PGSZ, VM_FREELIST_DEFAULT); +#endif +#if 0 + kernel_pmap_store.pm_count = 1; + simple_lock_init(&kernel_pmap_store.pm_lock); +#endif + + /* + * Ready! Turn on paging. + */ + CONO(PAG,TPTOINT(ept) >> PGSH | PAG_CON_ENABLE | PAG_CON_T20); + DATAO(PAG,proc0paddr >> PGSH | PAG_DATA_LUBA | PAG_DATA_DNUA); + +#ifdef DEBUG + printf("section pages at %o\n", guardpage); + printf("\n"); +#endif +} + +void +pmap_virtual_space(vaddr_t *v1, vaddr_t *v2) +{ + *v1 = avail_start * sizeof(int); + *v2 = 0200000000; /* Max virtual memory address in bytes */ +} + +long +pmap_resident_count(pmap_t pmap) +{ + panic("pmap_resident_count"); +} + +void +pmap_update(pmap_t pmap) +{ +} + +void +pmap_kenter_pa(vaddr_t v, paddr_t p, vm_prot_t prot) +{ + int seg, off, pte, *ptep; + TUNION uu; + + seg = (v >> 20) & 0777; + off = (v >> 11) & 0777; + + PMDEBUG(("pmap_kenter_pa: va: %lo, pa %lo, prot %o\n", v/4, p/4, prot)); + + if (ept->ept_section[seg] == 0) + panic("pmap_kenter_pa: need to add section, va %o", v); + ptep = TINTTOP(((ept->ept_section[seg] & 07777777) << PGSH)); + pte = PG_IMM | (p >> 11); + if (prot & VM_PROT_WRITE) + pte |= PG_WRITE; + ptep[off] = pte; +} + +void +pmap_kremove(vaddr_t v, vsize_t size) +{ + panic("pmap_kremove"); +} + +boolean_t +pmap_clear_modify(struct vm_page *vm) +{ + panic("pmap_clear_modify"); +} + +void +pmap_page_protect(struct vm_page *vm, vm_prot_t prot) +{ + panic("pmap_page_protect"); +} + +boolean_t +pmap_clear_reference(struct vm_page *vm) +{ + panic("pmap_clear_reference"); +} + +void +pmap_remove(pmap_t pmap, vaddr_t v1, vaddr_t v2) +{ + panic("pmap_remove"); +} + +/* + * Get the physical page address for the virtual address v. + * Return FALSE if no mapping exists. + */ +boolean_t +pmap_extract(pmap_t pmap, vaddr_t v, paddr_t *pp) +{ + int nv = v >> PTOV_COMP; + int seg, pga, pg, *pgp, paddr; + + if (pmap != pmap_kernel()) + panic("pmap_extract"); + seg = SEGNO(nv); + if (((pga = ept->ept_section[seg]) & PG_IMM) == 0) + return FALSE; + pg = PGINSEG(nv); + pgp = (int *)(((pga << PGSH) & 017777777) << PTOV_COMP); + if (((paddr = pgp[pg]) & PG_IMM) == 0) + return FALSE; + *pp = (paddr << PGSH) & 037777777; + *pp <<= PTOV_COMP; + return TRUE; +} + +int +pmap_enter(pmap_t pmap, vaddr_t v, paddr_t p, vm_prot_t prot, int flags) +{ + PMDEBUG(("pmap_enter: pmap %o v %o p %o prot %o access %o\n", + pmap, v/4, p/4, prot, flags & VM_PROT_ALL)); + + if (pmap != pmap_kernel()) + panic("user mapping"); + pmap_kenter_pa(v, p, prot); /* XXX */ + return 0; +} + +paddr_t +pmap_phys_address(int a) +{ + panic("pmap_phys_address"); +} + +void +pmap_unwire(pmap_t pmap, vaddr_t v) +{ + panic("pmap_unwire"); +} + +void +pmap_collect(pmap_t pmap) +{ + panic("pmap_collect"); +} + +void +cpu_swapout(struct lwp *p) +{ + panic("cpu_swapout"); +} + +void +cpu_swapin(struct lwp *p) +{ + panic("cpu_swapin"); +} + +/* + * Increment the reference count. + */ +void +pmap_reference(pmap_t pmap) +{ +#ifdef notyet + pmap->pm_count++; +#endif +} + +void +pmap_protect(pmap_t pmap, vaddr_t v1, vaddr_t v2, vm_prot_t prot) +{ + panic("pmap_protect"); +} + +void +pmap_destroy(pmap_t pmap) +{ + panic("pmap_destroy"); +} + +void +pmap_activate(struct lwp *p) +{ + panic("pmap_activate"); +} + +void +pmap_deactivate(struct lwp *p) +{ + panic("pmap_deactivate"); +} + +struct pmap * +pmap_create() +{ + struct pmap *pmap; + + MALLOC(pmap, struct pmap *, sizeof(*pmap), M_VMPMAP, M_WAITOK); + memset(pmap, 0, sizeof(struct pmap)); + return (pmap); +} + +void +pmap_copy(pmap_t pm1, pmap_t pm2, vaddr_t v1, vsize_t ax, vaddr_t v2) +{ + panic("pmap_copy"); +} + +void +pmap_zero_page(paddr_t p) +{ + PMDEBUG(("pmap_zero_page: paddr %o\n", p >> 2)); + mk2word(p); + + *mappte = PG_IMM | PG_WRITE | PGNO(p); + memset(mapaddr, 0, PGSZ); + *mappte = 0; + CLRPT((int)mapaddr); +} + +void +pmap_copy_page(paddr_t p1, paddr_t p2) +{ + panic("pmap_copy_page"); +} + +/* + * Init VM pmap system. Nothing special to do. + */ +void +pmap_init() +{ +} + +/* + * Remove all mappings. + */ +void +pmap_remove_all(struct pmap *p) +{ +} diff --git a/sys/arch/pdp10/pdp10/trap.c b/sys/arch/pdp10/pdp10/trap.c new file mode 100644 index 000000000000..5b60e54d4f38 --- /dev/null +++ b/sys/arch/pdp10/pdp10/trap.c @@ -0,0 +1,74 @@ +/* $NetBSD: trap.c,v 1.1 2003/08/19 10:55:00 ragge Exp $ */ +/* + * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se). + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include + +#include + +void syscall(void); +void pagefail(struct pcb *pcb); + +void +pagefail(struct pcb *pcb) +{ + printf("pagefail at %o word %012o flags %012o\n", pcb->pcb_pfopc, + pcb->pcb_pfw, pcb->pcb_pff); + + panic("pagefail"); +} + + + +void +syscall(void) +{ + panic("syscall"); +} + +void +setregs(struct lwp *p, struct exec_package *epp, u_long stack) +{ + panic("setregs"); +} + +void +child_return(void *arg) +{ + panic("child_return"); +} + +void +upcallret(struct lwp *l) +{ + /* XXX - profiling */ + panic("upcallret"); +/* userret(l, l->l_addr->u_pcb.framep, l->l_proc->p_sticks); */ +} diff --git a/sys/arch/pdp10/pdp10/vm_machdep.c b/sys/arch/pdp10/pdp10/vm_machdep.c new file mode 100644 index 000000000000..64c5df33cf49 --- /dev/null +++ b/sys/arch/pdp10/pdp10/vm_machdep.c @@ -0,0 +1,89 @@ +/* $NetBSD: vm_machdep.c,v 1.1 2003/08/19 10:55:00 ragge Exp $ */ +/* + * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se). + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include + +#include + +void +pagemove(caddr_t from, caddr_t to, size_t size) +{ + panic("pagemove"); +} + +int +cpu_coredump(struct lwp *p, struct vnode *vp, + struct ucred *cred, struct core *chdr) +{ + return 0; +} + +int +sys_sysarch(struct lwp *p, void *v, register_t *retval) +{ + return (ENOSYS); +} + +void +vmapbuf(struct buf *bp, vsize_t len) +{ + panic("vmapbuf"); +} + +void +vunmapbuf(struct buf *bp, vsize_t len) +{ + panic("vunmapbuf"); +} + +void +cpu_lwp_fork(struct lwp *l1, struct lwp *l2, void *stack, size_t stacksize, + void (*func)(void *), void *arg) +{ + panic("cpu_lwp_fork"); +} + +void +cpu_setfunc(struct lwp *l, void (*func)(void *), void *arg) +{ + panic("cpu_setfunc"); +} + +/* + * Start a new LWP + */ +void +startlwp(void *arg) +{ + panic("startlwp"); +}