1/*	$NetBSD: machdep.c,v 1.122 2024/03/05 14:15:33 thorpej Exp $	*/
2
3/*
4 * Copyright (c) 1998 Darrin B. Jewell
5 * Copyright (c) 1988 University of Utah.
6 * Copyright (c) 1982, 1986, 1990, 1993
7 *	The Regents of the University of California.  All rights reserved.
8 *
9 * This code is derived from software contributed to Berkeley by
10 * the Systems Programming Group of the University of Utah Computer
11 * Science Department.
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
15 * are met:
16 * 1. Redistributions of source code must retain the above copyright
17 *    notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 *    notice, this list of conditions and the following disclaimer in the
20 *    documentation and/or other materials provided with the distribution.
21 * 3. Neither the name of the University nor the names of its contributors
22 *    may be used to endorse or promote products derived from this software
23 *    without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * SUCH DAMAGE.
36 *
37 * from: Utah $Hdr: machdep.c 1.74 92/12/20$
38 *
39 *	@(#)machdep.c	8.10 (Berkeley) 4/20/94
40 */
41
42#include <sys/cdefs.h>
43__KERNEL_RCSID(0, "$NetBSD: machdep.c,v 1.122 2024/03/05 14:15:33 thorpej Exp $");
44
45#include "opt_ddb.h"
46#include "opt_kgdb.h"
47#include "opt_modular.h"
48
49#include <sys/param.h>
50#include <sys/systm.h>
51#include <sys/signalvar.h>
52#include <sys/kernel.h>
53#include <sys/proc.h>
54#include <sys/buf.h>
55#include <sys/reboot.h>
56#include <sys/conf.h>
57#include <sys/file.h>
58#include <sys/device.h>
59#include <sys/mbuf.h>
60#include <sys/msgbuf.h>
61#include <sys/ioctl.h>
62#include <sys/tty.h>
63#include <sys/mount.h>
64#include <sys/exec.h>
65#include <sys/exec_aout.h>		/* for MID_* */
66#include <sys/core.h>
67#include <sys/kcore.h>
68#include <sys/vnode.h>
69#include <sys/syscallargs.h>
70#include <sys/ksyms.h>
71#include <sys/module.h>
72#ifdef KGDB
73#include <sys/kgdb.h>
74#endif
75#include <sys/boot_flag.h>
76#include <sys/cpu.h>
77
78#include <uvm/uvm_extern.h>
79
80#ifdef DDB
81#include <machine/db_machdep.h>
82#include <ddb/db_access.h>
83#include <ddb/db_sym.h>
84#include <ddb/db_extern.h>
85#endif
86
87#ifdef KGDB
88/* Is zs configured in? */
89#include "zsc.h"
90#if (NZSC > 0)
91#include <next68k/dev/zs_cons.h>
92#endif
93#endif
94
95#include <sys/sysctl.h>
96
97#include <machine/cpu.h>
98#include <machine/bus.h>
99#include <machine/reg.h>
100#include <machine/pcb.h>
101#include <machine/psl.h>
102#include <machine/pte.h>
103#include <machine/vmparam.h>
104#include <dev/cons.h>
105
106#include <machine/kcore.h>	/* XXX should be pulled in by sys/kcore.h */
107
108#include <next68k/next68k/isr.h>
109#include <next68k/next68k/nextrom.h>
110#include <next68k/next68k/rtc.h>
111#include <next68k/next68k/seglist.h>
112
113#include <dev/mm.h>
114
115#include "ksyms.h"
116
117int nsym;
118char *ssym;
119extern char *esym;
120
121#define	MAXMEM	64*1024	/* XXX - from cmap.h */
122
123/* the following is used externally (sysctl_hw) */
124char	machine[] = MACHINE;	/* from <machine/param.h> */
125
126/* Our exported CPU info; we can have only one. */
127struct cpu_info cpu_info_store;
128
129struct vm_map *phys_map = NULL;
130
131paddr_t msgbufpa;		/* PA of message buffer */
132
133int	maxmem;			/* max memory per process */
134
135extern	u_int lowram;
136extern	short exframesize[];
137
138/* prototypes for local functions */
139void	identifycpu(void);
140void	initcpu(void);
141void	dumpsys(void);
142
143int	cpu_dumpsize(void);
144int	cpu_dump(int (*)(dev_t, daddr_t, void *, size_t), daddr_t *);
145void	cpu_init_kcore_hdr(void);
146
147/* functions called from locore.s */
148void next68k_init(void);
149void straytrap(int, u_short);
150
151/*
152 * Machine-independent crash dump header info.
153 */
154cpu_kcore_hdr_t cpu_kcore_hdr;
155
156/*
157 * Memory segments initialized in locore, which are eventually loaded
158 * as managed VM pages.
159 */
160phys_seg_list_t phys_seg_list[VM_PHYSSEG_MAX];
161
162/*
163 * Memory segments to dump.  This is initialized from the phys_seg_list
164 * before pages are stolen from it for VM system overhead.  I.e. this
165 * covers the entire range of physical memory.
166 */
167phys_ram_seg_t mem_clusters[VM_PHYSSEG_MAX];
168int	mem_cluster_cnt;
169
170/*
171 * On the 68020/68030, the value of delay_divisor is roughly
172 * 2048 / cpuspeed (where cpuspeed is in MHz).
173 *
174 * On the 68040/68060(?), the value of delay_divisor is roughly
175 * 759 / cpuspeed (where cpuspeed is in MHz).
176 * XXX -- is the above formula correct?
177 */
178int	cpuspeed = 33;		  /* relative cpu speed; XXX skewed on 68040 */
179int	delay_divisor = 759 / 33;  /* delay constant; assume fastest 33 MHz */
180
181/****************************************************************/
182
183/*
184 * Early initialization, before main() is called.
185 */
186void
187next68k_init(void)
188{
189	int i;
190
191	/*
192	 * Tell the VM system about available physical memory.
193	 */
194	for (i = 0; i < mem_cluster_cnt; i++) {
195		if (phys_seg_list[i].ps_start == phys_seg_list[i].ps_end) {
196			/*
197			 * Segment has been completely gobbled up.
198			 */
199			continue;
200		}
201		/*
202		 * Note the index of the mem cluster is the free
203		 * list we want to put the memory on.
204		 */
205		uvm_page_physload(atop(phys_seg_list[i].ps_start),
206				  atop(phys_seg_list[i].ps_end),
207				  atop(phys_seg_list[i].ps_start),
208				  atop(phys_seg_list[i].ps_end),
209				  VM_FREELIST_DEFAULT);
210	}
211
212	{
213		char *p = rom_boot_arg;
214		boothowto = 0;
215		if (*p++ == '-') {
216			for (;*p;p++)
217				BOOT_FLAG(*p, boothowto);
218		}
219	}
220
221	/*
222	 * Initialize error message buffer (at end of core).
223	 */
224	for (i = 0; i < btoc(round_page(MSGBUFSIZE)); i++)
225		pmap_enter(pmap_kernel(), (vaddr_t)msgbufaddr + i * PAGE_SIZE,
226		    msgbufpa + i * PAGE_SIZE, VM_PROT_READ|VM_PROT_WRITE,
227		    VM_PROT_READ|VM_PROT_WRITE|PMAP_WIRED);
228	initmsgbuf(msgbufaddr, round_page(MSGBUFSIZE));
229	pmap_update(pmap_kernel());
230}
231
232/*
233 * Console initialization: called early on from main,
234 * before vm init or startup.  Do enough configuration
235 * to choose and initialize a console.
236 */
237void
238consinit(void)
239{
240	static int init = 0;
241
242	/*
243	 * Generic console: sys/dev/cons.c
244	 *	Initializes either ite or ser as console.
245	 *	Can be called from locore.s and init_main.c.
246	 */
247
248	if (!init) {
249		cninit();
250#if defined(KGDB) && (NZSC > 0)
251		zs_kgdb_init();
252#endif
253#if NKSYMS || defined(DDB) || defined(MODULAR)
254		/* Initialize kernel symbol table, if compiled in. */
255		ksyms_addsyms_elf(nsym, ssym, esym);
256#endif
257		if (boothowto & RB_KDB) {
258#if defined(KGDB)
259			kgdb_connect(1);
260#elif defined(DDB)
261			Debugger();
262#endif
263		}
264
265		init = 1;
266	}
267}
268
269/*
270 * cpu_startup: allocate memory for variable-sized tables,
271 * initialize CPU, and do autoconfiguration.
272 */
273void
274cpu_startup(void)
275{
276	vaddr_t minaddr, maxaddr;
277	char pbuf[9];
278#ifdef DEBUG
279	extern int pmapdebug;
280	int opmapdebug = pmapdebug;
281
282	pmapdebug = 0;
283#endif
284
285	if (fputype != FPU_NONE)
286		m68k_make_fpu_idle_frame();
287
288	/*
289	 * Initialize the kernel crash dump header.
290	 */
291	cpu_init_kcore_hdr();
292
293	/*
294	 * Good {morning,afternoon,evening,night}.
295	 */
296	printf("%s%s", copyright, version);
297	identifycpu();
298	format_bytes(pbuf, sizeof(pbuf), ctob(physmem));
299	printf("total memory = %s\n", pbuf);
300
301	minaddr = 0;
302	/*
303	 * Allocate a submap for physio
304	 */
305	phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
306				 VM_PHYS_SIZE, 0, false, NULL);
307
308#ifdef DEBUG
309	pmapdebug = opmapdebug;
310#endif
311	format_bytes(pbuf, sizeof(pbuf), ptoa(uvm_availmem(false)));
312	printf("avail memory = %s\n", pbuf);
313
314	/*
315	 * Set up CPU-specific registers, cache, etc.
316	 */
317	initcpu();
318}
319
320void
321identifycpu(void)
322{
323	const char *cpu_str, *mmu_str, *fpu_str, *cache_str;
324	extern int turbo;
325
326	/*
327	 * ...and the CPU type.
328	 */
329	switch (cputype) {
330	case CPU_68040:
331		cpu_str = "MC68040";
332		cpuspeed = turbo ? 33 : 25;
333		delay_divisor = 759 / cpuspeed;
334		break;
335	case CPU_68030:
336		cpu_str = "MC68030";
337		cpuspeed = 25;
338		delay_divisor = 2048 / cpuspeed;
339		break;
340#if 0
341	case CPU_68020:
342		cpu_str = "MC68020";
343		break;
344#endif
345	default:
346		printf("\nunknown cputype %d\n", cputype);
347		panic("startup");
348	}
349
350	/*
351	 * ...and the MMU type.
352	 */
353	switch (mmutype) {
354	case MMU_68040:
355	case MMU_68030:
356		mmu_str = "+MMU";
357		break;
358#if 0
359	case MMU_68851:
360		mmu_str = ", MC68851 MMU";
361		break;
362#endif
363	default:
364		printf("%s: unknown MMU type %d\n", cpu_str, mmutype);
365		panic("startup");
366	}
367
368	/*
369	 * ...and the FPU type.
370	 */
371	switch (fputype) {
372	case FPU_68040:
373		fpu_str = "+FPU";
374		break;
375	case FPU_68882:
376		fpu_str = ", MC68882 FPU";
377		break;
378	case FPU_68881:
379		fpu_str = ", MC68881 FPU";
380		break;
381	default:
382		fpu_str = ", unknown FPU";
383	}
384
385	/*
386	 * ...and finally, the cache type.
387	 */
388	if (cputype == CPU_68040)
389		cache_str = ", 4k on-chip physical I/D caches";
390	else
391		cache_str = "";
392
393	cpu_setmodel("NeXT/%s CPU%s%s%s", cpu_str, mmu_str, fpu_str, cache_str);
394	printf("%s\n", cpu_getmodel());
395}
396
397/*
398 * machine dependent system variables.
399 */
400SYSCTL_SETUP(sysctl_machdep_setup, "sysctl machdep subtree setup")
401{
402
403	sysctl_createv(clog, 0, NULL, NULL,
404		       CTLFLAG_PERMANENT,
405		       CTLTYPE_NODE, "machdep", NULL,
406		       NULL, 0, NULL, 0,
407		       CTL_MACHDEP, CTL_EOL);
408
409#if 0
410	sysctl_createv(clog, 0, NULL, NULL,
411		       CTLFLAG_PERMANENT,
412		       CTLTYPE_STRUCT, "console_device", NULL,
413		       sysctl_consdev, 0, NULL, sizeof(dev_t),
414		       CTL_MACHDEP, CPU_CONSDEV, CTL_EOL);
415#endif
416}
417
418/* See: sig_machdep.c */
419
420int	waittime = -1;
421
422void
423cpu_reboot(int howto, char *bootstr)
424{
425	struct pcb *pcb = lwp_getpcb(curlwp);
426
427	/* take a snap shot before clobbering any registers */
428	if (pcb != NULL)
429		savectx(pcb);
430
431	/* If system is cold, just halt. */
432	if (cold) {
433		howto |= RB_HALT;
434		goto haltsys;
435	}
436
437	boothowto = howto;
438	if ((howto & RB_NOSYNC) == 0 && waittime < 0) {
439		waittime = 0;
440		vfs_shutdown();
441	}
442
443	/* Disable interrupts. */
444	splhigh();
445
446	/* If rebooting and a dump is requested, do it. */
447	if (howto & RB_DUMP)
448		dumpsys();
449
450 haltsys:
451	/* Run any shutdown hooks. */
452	doshutdownhooks();
453
454	pmf_system_shutdown(boothowto);
455
456#if defined(PANICWAIT) && !defined(DDB)
457	if ((howto & RB_HALT) == 0 && panicstr) {
458		printf("hit any key to reboot...\n");
459		cnpollc(1);
460		(void)cngetc();
461		cnpollc(0);
462		printf("\n");
463	}
464#endif
465
466	if ((howto & RB_POWERDOWN) == RB_POWERDOWN) {
467		poweroff();
468	}
469
470	/* Finally, halt/reboot the system. */
471	if (howto & RB_HALT) {
472		monbootflag = 0x2d680000;				/* "-h" */
473	}
474
475	printf("rebooting...\n");
476	DELAY(1000000);
477	doboot();
478	/*NOTREACHED*/
479}
480
481/*
482 * Initialize the kernel crash dump header.
483 */
484void
485cpu_init_kcore_hdr(void)
486{
487	cpu_kcore_hdr_t *h = &cpu_kcore_hdr;
488	struct m68k_kcore_hdr *m = &h->un._m68k;
489	int i;
490	extern char end[];
491
492	memset(&cpu_kcore_hdr, 0, sizeof(cpu_kcore_hdr));
493
494	/*
495	 * Initialize the `dispatcher' portion of the header.
496	 */
497	strcpy(h->name, machine);
498	h->page_size = PAGE_SIZE;
499	h->kernbase = KERNBASE;
500
501	/*
502	 * Fill in information about our MMU configuration.
503	 */
504	m->mmutype	= mmutype;
505	m->sg_v		= SG_V;
506	m->sg_frame	= SG_FRAME;
507	m->sg_ishift	= SG_ISHIFT;
508	m->sg_pmask	= SG_PMASK;
509	m->sg40_shift1	= SG4_SHIFT1;
510	m->sg40_mask2	= SG4_MASK2;
511	m->sg40_shift2	= SG4_SHIFT2;
512	m->sg40_mask3	= SG4_MASK3;
513	m->sg40_shift3	= SG4_SHIFT3;
514	m->sg40_addr1	= SG4_ADDR1;
515	m->sg40_addr2	= SG4_ADDR2;
516	m->pg_v		= PG_V;
517	m->pg_frame	= PG_FRAME;
518
519	/*
520	 * Initialize pointer to kernel segment table.
521	 */
522	m->sysseg_pa = (uint32_t)(pmap_kernel()->pm_stpa);
523
524	/*
525	 * Initialize relocation value such that:
526	 *
527	 *	pa = (va - KERNBASE) + reloc
528	 */
529	m->reloc = lowram;
530
531	/*
532	 * Define the end of the relocatable range.
533	 */
534	m->relocend = (uint32_t)end;
535
536	/*
537	 * The next68k has multiple memory segments.
538	 */
539	for (i = 0; i < mem_cluster_cnt; i++) {
540		m->ram_segs[i].start = mem_clusters[i].start;
541		m->ram_segs[i].size  = mem_clusters[i].size;
542	}
543}
544
545/*
546 * Compute the size of the machine-dependent crash dump header.
547 * Returns size in disk blocks.
548 */
549
550#define CHDRSIZE (ALIGN(sizeof(kcore_seg_t)) + ALIGN(sizeof(cpu_kcore_hdr_t)))
551#define MDHDRSIZE roundup(CHDRSIZE, dbtob(1))
552
553int
554cpu_dumpsize(void)
555{
556
557	return btodb(MDHDRSIZE);
558}
559
560/*
561 * Called by dumpsys() to dump the machine-dependent header.
562 */
563int
564cpu_dump(int (*dump)(dev_t, daddr_t, void *, size_t), daddr_t *blknop)
565{
566	int buf[MDHDRSIZE / sizeof(int)];
567	cpu_kcore_hdr_t *chdr;
568	kcore_seg_t *kseg;
569	int error;
570
571	kseg = (kcore_seg_t *)buf;
572	chdr = (cpu_kcore_hdr_t *)&buf[ALIGN(sizeof(kcore_seg_t)) /
573	    sizeof(int)];
574
575	/* Create the segment header. */
576	CORE_SETMAGIC(*kseg, KCORE_MAGIC, MID_MACHINE, CORE_CPU);
577	kseg->c_size = MDHDRSIZE - ALIGN(sizeof(kcore_seg_t));
578
579	memcpy(chdr, &cpu_kcore_hdr, sizeof(cpu_kcore_hdr_t));
580	error = (*dump)(dumpdev, *blknop, (void *)buf, sizeof(buf));
581	*blknop += btodb(sizeof(buf));
582	return (error);
583}
584
585/*
586 * These variables are needed by /sbin/savecore
587 */
588uint32_t dumpmag = 0x8fca0101;	/* magic number */
589int	dumpsize = 0;		/* pages */
590long	dumplo = 0;		/* blocks */
591
592/*
593 * This is called by main to set dumplo and dumpsize.
594 * Dumps always skip the first PAGE_SIZE of disk space
595 * in case there might be a disk label stored there.
596 * If there is extra space, put dump at the end to
597 * reduce the chance that swapping trashes it.
598 */
599void
600cpu_dumpconf(void)
601{
602	int chdrsize;	/* size of dump header */
603	int nblks;	/* size of dump area */
604
605	if (dumpdev == NODEV)
606		return;
607	nblks = bdev_size(dumpdev);
608	chdrsize = cpu_dumpsize();
609
610	dumpsize = btoc(cpu_kcore_hdr.un._m68k.ram_segs[0].size);
611
612	/*
613	 * Check do see if we will fit.  Note we always skip the
614	 * first PAGE_SIZE in case there is a disk label there.
615	 */
616	if (nblks < (ctod(dumpsize) + chdrsize + ctod(1))) {
617		dumpsize = 0;
618		dumplo = -1;
619		return;
620	}
621
622	/*
623	 * Put dump at the end of the partition.
624	 */
625	dumplo = (nblks - 1) - ctod(dumpsize) - chdrsize;
626}
627
628/*
629 * Dump physical memory onto the dump device.  Called by cpu_reboot().
630 */
631void
632dumpsys(void)
633{
634	const struct bdevsw *bdev;
635	daddr_t blkno;		/* current block to write */
636				/* dump routine */
637	int (*dump)(dev_t, daddr_t, void *, size_t);
638	int pg;			/* page being dumped */
639	vm_offset_t maddr;	/* PA being dumped */
640	int error;		/* error code from (*dump)() */
641
642	/* XXX initialized here because of gcc lossage */
643	maddr = lowram;
644	pg = 0;
645
646	/* Don't put dump messages in msgbuf. */
647	msgbufmapped = 0;
648
649	/* Make sure dump device is valid. */
650	if (dumpdev == NODEV)
651		return;
652	bdev = bdevsw_lookup(dumpdev);
653	if (bdev == NULL)
654		return;
655	if (dumpsize == 0) {
656		cpu_dumpconf();
657		if (dumpsize == 0)
658			return;
659	}
660	if (dumplo < 0)
661		return;
662	dump = bdev->d_dump;
663	blkno = dumplo;
664
665	printf("\ndumping to dev 0x%"PRIx64", offset %ld\n", dumpdev, dumplo);
666
667	printf("dump ");
668
669	/* Write the dump header. */
670	error = cpu_dump(dump, &blkno);
671	if (error)
672		goto bad;
673
674	for (pg = 0; pg < dumpsize; pg++) {
675#define NPGMB	(1024*1024/PAGE_SIZE)
676		/* print out how many MBs we have dumped */
677		if (pg && (pg % NPGMB) == 0)
678			printf_nolog("%d ", pg / NPGMB);
679#undef NPGMB
680		pmap_enter(pmap_kernel(), (vm_offset_t)vmmap, maddr,
681		    VM_PROT_READ, VM_PROT_READ|PMAP_WIRED);
682		pmap_update(pmap_kernel());
683
684		error = (*dump)(dumpdev, blkno, vmmap, PAGE_SIZE);
685 bad:
686		switch (error) {
687		case 0:
688			maddr += PAGE_SIZE;
689			blkno += btodb(PAGE_SIZE);
690			break;
691
692		case ENXIO:
693			printf("device bad\n");
694			return;
695
696		case EFAULT:
697			printf("device not ready\n");
698			return;
699
700		case EINVAL:
701			printf("area improper\n");
702			return;
703
704		case EIO:
705			printf("i/o error\n");
706			return;
707
708		case EINTR:
709			printf("aborted from console\n");
710			return;
711
712		default:
713			printf("error %d\n", error);
714			return;
715		}
716	}
717	printf("succeeded\n");
718}
719
720void
721initcpu(void)
722{
723}
724
725void
726straytrap(int pc, u_short evec)
727{
728	printf("unexpected trap (vector offset %x) from %x\n",
729	       evec & 0xFFF, pc);
730
731	/* XXX kgdb/ddb entry? */
732}
733
734/* XXX should change the interface, and make one badaddr() function */
735
736int	*nofault;
737
738#if 0
739int
740badaddr(void *addr, int nbytes)
741{
742	int i;
743	label_t faultbuf;
744
745#ifdef lint
746	i = *addr; if (i) return (0);
747#endif
748
749	nofault = (int *) &faultbuf;
750	if (setjmp((label_t *)nofault)) {
751		nofault = (int *) 0;
752		return(1);
753	}
754
755	switch (nbytes) {
756	case 1:
757		i = *(volatile char *)addr;
758		break;
759
760	case 2:
761		i = *(volatile short *)addr;
762		break;
763
764	case 4:
765		i = *(volatile int *)addr;
766		break;
767
768	default:
769		panic("badaddr: bad request");
770	}
771	nofault = NULL;
772	return (0);
773}
774#endif
775
776/*
777 * Level 7 interrupts can be caused by the keyboard or parity errors.
778 */
779int
780nmihand(void *frame)
781{
782	static int innmihand;	/* simple mutex */
783
784	/* Prevent unwanted recursion. */
785	if (innmihand)
786		return 0;
787	innmihand = 1;
788
789	printf("Got a NMI");
790
791	if (!INTR_OCCURRED(NEXT_I_NMI)) {
792		printf("But NMI isn't set in intrstat!\n");
793	}
794	INTR_DISABLE(NEXT_I_NMI);
795
796#if defined(DDB)
797	printf(": entering debugger\n");
798	Debugger();
799	printf("continuing after NMI\n");
800#elif defined(KGDB)
801	kgdb_connect(1);
802#else
803	printf(": ignoring\n");
804#endif /* DDB */
805
806	INTR_ENABLE(NEXT_I_NMI);
807
808	innmihand = 0;
809
810	return 0;
811}
812
813
814/*
815 * cpu_exec_aout_makecmds():
816 *	CPU-dependent a.out format hook for execve().
817 *
818 * Determine of the given exec package refers to something which we
819 * understand and, if so, set up the vmcmds for it.
820 */
821int
822cpu_exec_aout_makecmds(struct lwp *l, struct exec_package *epp)
823{
824	return ENOEXEC;
825}
826
827int
828mm_md_physacc(paddr_t pa, vm_prot_t prot)
829{
830
831	return (pa < lowram || pa >= 0xfffffffc) ? EFAULT : 0;
832}
833
834#ifdef MODULAR
835/*
836 * Push any modules loaded by the bootloader etc.
837 */
838void
839module_init_md(void)
840{
841}
842#endif
843