Home | History | Annotate | Line # | Download | only in sparc
machdep.c revision 1.326
      1 /*	$NetBSD: machdep.c,v 1.325 2012/11/02 00:01:20 chs Exp $ */
      2 
      3 /*-
      4  * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
      9  * NASA Ames Research Center.
     10  *
     11  * Redistribution and use in source and binary forms, with or without
     12  * modification, are permitted provided that the following conditions
     13  * are met:
     14  * 1. Redistributions of source code must retain the above copyright
     15  *    notice, this list of conditions and the following disclaimer.
     16  * 2. Redistributions in binary form must reproduce the above copyright
     17  *    notice, this list of conditions and the following disclaimer in the
     18  *    documentation and/or other materials provided with the distribution.
     19  *
     20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     30  * POSSIBILITY OF SUCH DAMAGE.
     31  */
     32 
     33 /*
     34  * Copyright (c) 1992, 1993
     35  *	The Regents of the University of California.  All rights reserved.
     36  *
     37  * This software was developed by the Computer Systems Engineering group
     38  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
     39  * contributed to Berkeley.
     40  *
     41  * All advertising materials mentioning features or use of this software
     42  * must display the following acknowledgement:
     43  *	This product includes software developed by the University of
     44  *	California, Lawrence Berkeley Laboratory.
     45  *
     46  * Redistribution and use in source and binary forms, with or without
     47  * modification, are permitted provided that the following conditions
     48  * are met:
     49  * 1. Redistributions of source code must retain the above copyright
     50  *    notice, this list of conditions and the following disclaimer.
     51  * 2. Redistributions in binary form must reproduce the above copyright
     52  *    notice, this list of conditions and the following disclaimer in the
     53  *    documentation and/or other materials provided with the distribution.
     54  * 3. Neither the name of the University nor the names of its contributors
     55  *    may be used to endorse or promote products derived from this software
     56  *    without specific prior written permission.
     57  *
     58  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     59  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     60  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     61  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     62  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     63  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     64  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     65  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     66  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     67  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     68  * SUCH DAMAGE.
     69  *
     70  *	@(#)machdep.c	8.6 (Berkeley) 1/14/94
     71  */
     72 
     73 #include <sys/cdefs.h>
     74 __KERNEL_RCSID(0, "$NetBSD: machdep.c,v 1.325 2012/11/02 00:01:20 chs Exp $");
     75 
     76 #include "opt_compat_netbsd.h"
     77 #include "opt_compat_sunos.h"
     78 #include "opt_sparc_arch.h"
     79 #include "opt_modular.h"
     80 #include "opt_multiprocessor.h"
     81 
     82 #include <sys/param.h>
     83 #include <sys/signal.h>
     84 #include <sys/signalvar.h>
     85 #include <sys/proc.h>
     86 #include <sys/extent.h>
     87 #include <sys/cpu.h>
     88 #include <sys/buf.h>
     89 #include <sys/device.h>
     90 #include <sys/reboot.h>
     91 #include <sys/systm.h>
     92 #include <sys/kernel.h>
     93 #include <sys/conf.h>
     94 #include <sys/file.h>
     95 #include <sys/malloc.h>
     96 #include <sys/mbuf.h>
     97 #include <sys/mount.h>
     98 #include <sys/msgbuf.h>
     99 #include <sys/syscallargs.h>
    100 #include <sys/exec.h>
    101 #include <sys/exec_aout.h>
    102 #include <sys/ucontext.h>
    103 #include <sys/module.h>
    104 #include <sys/mutex.h>
    105 #include <sys/ras.h>
    106 
    107 #include <dev/mm.h>
    108 
    109 #include <uvm/uvm.h>		/* we use uvm.kernel_object */
    110 
    111 #include <sys/sysctl.h>
    112 
    113 #ifdef COMPAT_13
    114 #include <compat/sys/signal.h>
    115 #include <compat/sys/signalvar.h>
    116 #endif
    117 
    118 #define _SPARC_BUS_DMA_PRIVATE
    119 #include <machine/autoconf.h>
    120 #include <sys/bus.h>
    121 #include <machine/frame.h>
    122 #include <machine/cpu.h>
    123 #include <machine/pcb.h>
    124 #include <machine/pmap.h>
    125 #include <machine/oldmon.h>
    126 #include <machine/bsd_openprom.h>
    127 #include <machine/bootinfo.h>
    128 #include <machine/eeprom.h>
    129 
    130 #include <sparc/sparc/asm.h>
    131 #include <sparc/sparc/cache.h>
    132 #include <sparc/sparc/vaddrs.h>
    133 #include <sparc/sparc/cpuvar.h>
    134 
    135 #include "fb.h"
    136 #include "power.h"
    137 
    138 #if NPOWER > 0
    139 #include <sparc/dev/power.h>
    140 #endif
    141 
    142 extern paddr_t avail_end;
    143 
    144 kmutex_t fpu_mtx;
    145 
    146 /*
    147  * dvmamap24 is used to manage DVMA memory for devices that have the upper
    148  * eight address bits wired to all-ones (e.g. `le' and `ie')
    149  */
    150 struct extent *dvmamap24;
    151 
    152 void	dumpsys(void);
    153 void	stackdump(void);
    154 
    155 /*
    156  * Machine-dependent startup code
    157  */
    158 void
    159 cpu_startup(void)
    160 {
    161 #ifdef DEBUG
    162 	extern int pmapdebug;
    163 	int opmapdebug = pmapdebug;
    164 #endif
    165 	struct pcb *pcb;
    166 	vsize_t size;
    167 	paddr_t pa;
    168 	char pbuf[9];
    169 
    170 #ifdef DEBUG
    171 	pmapdebug = 0;
    172 #endif
    173 
    174 	/* XXX */
    175 	pcb = lwp_getpcb(&lwp0);
    176 	if (pcb && pcb->pcb_psr == 0)
    177 		pcb->pcb_psr = getpsr();
    178 
    179 	/*
    180 	 * Re-map the message buffer from its temporary address
    181 	 * at KERNBASE to MSGBUF_VA.
    182 	 */
    183 #if !defined(MSGBUFSIZE) || MSGBUFSIZE <= 8192
    184 	/*
    185 	 * We use the free page(s) in front of the kernel load address.
    186 	 */
    187 	size = 8192;
    188 
    189 	/* Get physical address of the message buffer */
    190 	pmap_extract(pmap_kernel(), (vaddr_t)KERNBASE, &pa);
    191 
    192 	/* Invalidate the current mapping at KERNBASE. */
    193 	pmap_kremove((vaddr_t)KERNBASE, size);
    194 	pmap_update(pmap_kernel());
    195 
    196 	/* Enter the new mapping */
    197 	pmap_map(MSGBUF_VA, pa, pa + size, VM_PROT_READ|VM_PROT_WRITE);
    198 
    199 	/*
    200 	 * Re-initialize the message buffer.
    201 	 */
    202 	initmsgbuf((void *)MSGBUF_VA, size);
    203 #else /* MSGBUFSIZE */
    204 	{
    205 	struct pglist mlist;
    206 	struct vm_page *m;
    207 	vaddr_t va0, va;
    208 
    209 	/*
    210 	 * We use the free page(s) in front of the kernel load address,
    211 	 * and then allocate some more.
    212 	 */
    213 	size = round_page(MSGBUFSIZE);
    214 
    215 	/* Get physical address of first 8192 chunk of the message buffer */
    216 	pmap_extract(pmap_kernel(), (vaddr_t)KERNBASE, &pa);
    217 
    218 	/* Allocate additional physical pages */
    219 	if (uvm_pglistalloc(size - 8192,
    220 			    vm_first_phys, vm_first_phys+vm_num_phys,
    221 			    0, 0, &mlist, 1, 0) != 0)
    222 		panic("cpu_start: no memory for message buffer");
    223 
    224 	/* Invalidate the current mapping at KERNBASE. */
    225 	pmap_kremove((vaddr_t)KERNBASE, 8192);
    226 	pmap_update(pmap_kernel());
    227 
    228 	/* Allocate virtual memory space */
    229 	va0 = va = uvm_km_alloc(kernel_map, size, 0, UVM_KMF_VAONLY);
    230 	if (va == 0)
    231 		panic("cpu_start: no virtual memory for message buffer");
    232 
    233 	/* Map first 8192 */
    234 	while (va < va0 + 8192) {
    235 		pmap_kenter_pa(va, pa, VM_PROT_READ | VM_PROT_WRITE, 0);
    236 		pa += PAGE_SIZE;
    237 		va += PAGE_SIZE;
    238 	}
    239 	pmap_update(pmap_kernel());
    240 
    241 	/* Map the rest of the pages */
    242 	TAILQ_FOREACH(m, &mlist ,pageq.queue) {
    243 		if (va >= va0 + size)
    244 			panic("cpu_start: memory buffer size botch");
    245 		pa = VM_PAGE_TO_PHYS(m);
    246 		pmap_kenter_pa(va, pa, VM_PROT_READ | VM_PROT_WRITE, 0);
    247 		va += PAGE_SIZE;
    248 	}
    249 	pmap_update(pmap_kernel());
    250 
    251 	/*
    252 	 * Re-initialize the message buffer.
    253 	 */
    254 	initmsgbuf((void *)va0, size);
    255 	}
    256 #endif /* MSGBUFSIZE */
    257 
    258 	/*
    259 	 * Good {morning,afternoon,evening,night}.
    260 	 */
    261 	printf("%s%s", copyright, version);
    262 	/*identifycpu();*/
    263 	format_bytes(pbuf, sizeof(pbuf), ctob(physmem));
    264 	printf("total memory = %s\n", pbuf);
    265 
    266 	/*
    267 	 * Tune buffer cache variables based on the capabilities of the MMU
    268 	 * to cut down on VM space allocated for the buffer caches that
    269 	 * would lead to MMU resource shortage.
    270 	 */
    271 	if (CPU_ISSUN4 || CPU_ISSUN4C) {
    272 		/* Clip UBC windows */
    273 		if (cpuinfo.mmu_nsegment <= 128) {
    274 			/*
    275 			 * ubc_nwins and ubc_winshift control the amount
    276 			 * of VM used by the UBC. Normally, this VM is
    277 			 * not wired in the kernel map, hence non-locked
    278 			 * `PMEGs' (see pmap.c) are used for this space.
    279 			 * We still limit possible fragmentation to prevent
    280 			 * the occasional wired UBC mappings from tying up
    281 			 * too many PMEGs.
    282 			 *
    283 			 * Set the upper limit to 9 segments (default
    284 			 * winshift = 13).
    285 			 */
    286 			ubc_nwins = 512;
    287 
    288 			/*
    289 			 * buf_setvalimit() allocates a submap for buffer
    290 			 * allocation. We use it to limit the number of locked
    291 			 * `PMEGs' (see pmap.c) dedicated to the buffer cache.
    292 			 *
    293 			 * Set the upper limit to 12 segments (3MB), which
    294 			 * corresponds approximately to the size of the
    295 			 * traditional 5% rule (assuming a maximum 64MB of
    296 			 * memory in small sun4c machines).
    297 			 */
    298 			buf_setvalimit(12 * 256*1024);
    299 		}
    300 
    301 		/* Clip max data & stack to avoid running into the MMU hole */
    302 #if MAXDSIZ > 256*1024*1024
    303 		maxdmap = 256*1024*1024;
    304 #endif
    305 #if MAXSSIZ > 256*1024*1024
    306 		maxsmap = 256*1024*1024;
    307 #endif
    308 	}
    309 
    310 	if (CPU_ISSUN4 || CPU_ISSUN4C) {
    311 		/*
    312 		 * Allocate DMA map for 24-bit devices (le, ie)
    313 		 * [dvma_base - dvma_end] is for VME devices..
    314 		 */
    315 		dvmamap24 = extent_create("dvmamap24",
    316 					  D24_DVMA_BASE, D24_DVMA_END,
    317 					  0, 0, EX_NOWAIT);
    318 		if (dvmamap24 == NULL)
    319 			panic("unable to allocate DVMA map");
    320 	}
    321 
    322 #ifdef DEBUG
    323 	pmapdebug = opmapdebug;
    324 #endif
    325 	format_bytes(pbuf, sizeof(pbuf), ptoa(uvmexp.free));
    326 	printf("avail memory = %s\n", pbuf);
    327 
    328 	pmap_redzone();
    329 
    330 	mutex_init(&fpu_mtx, MUTEX_DEFAULT, IPL_SCHED);
    331 }
    332 
    333 /*
    334  * Set up registers on exec.
    335  *
    336  * XXX this entire mess must be fixed
    337  */
    338 /* ARGSUSED */
    339 void
    340 setregs(struct lwp *l, struct exec_package *pack, vaddr_t stack)
    341 {
    342 	struct trapframe *tf = l->l_md.md_tf;
    343 	struct fpstate *fs;
    344 	int psr;
    345 
    346 	/* Don't allow unaligned data references by default */
    347 	l->l_proc->p_md.md_flags &= ~MDP_FIXALIGN;
    348 
    349 	/*
    350 	 * Set the registers to 0 except for:
    351 	 *	%o6: stack pointer, built in exec())
    352 	 *	%psr: (retain CWP and PSR_S bits)
    353 	 *	%g1: p->p_psstrp (used by crt0)
    354 	 *	%pc,%npc: entry point of program
    355 	 */
    356 	psr = tf->tf_psr & (PSR_S | PSR_CWP);
    357 	if ((fs = l->l_md.md_fpstate) != NULL) {
    358 		struct cpu_info *cpi;
    359 		int s;
    360 		/*
    361 		 * We hold an FPU state.  If we own *some* FPU chip state
    362 		 * we must get rid of it, and the only way to do that is
    363 		 * to save it.  In any case, get rid of our FPU state.
    364 		 */
    365 		FPU_LOCK(s);
    366 		if ((cpi = l->l_md.md_fpu) != NULL) {
    367 			if (cpi->fplwp != l)
    368 				panic("FPU(%d): fplwp %p",
    369 					cpi->ci_cpuid, cpi->fplwp);
    370 			if (l == cpuinfo.fplwp)
    371 				savefpstate(fs);
    372 #if defined(MULTIPROCESSOR)
    373 			else
    374 				XCALL1(ipi_savefpstate, fs, 1 << cpi->ci_cpuid);
    375 #endif
    376 			cpi->fplwp = NULL;
    377 		}
    378 		l->l_md.md_fpu = NULL;
    379 		FPU_UNLOCK(s);
    380 		kmem_free(fs, sizeof(struct fpstate));
    381 		l->l_md.md_fpstate = NULL;
    382 	}
    383 	memset((void *)tf, 0, sizeof *tf);
    384 	tf->tf_psr = psr;
    385 	tf->tf_global[1] = l->l_proc->p_psstrp;
    386 	tf->tf_pc = pack->ep_entry & ~3;
    387 	tf->tf_npc = tf->tf_pc + 4;
    388 	stack -= sizeof(struct rwindow);
    389 	tf->tf_out[6] = stack;
    390 }
    391 
    392 #ifdef DEBUG
    393 int sigdebug = 0;
    394 int sigpid = 0;
    395 #define SDB_FOLLOW	0x01
    396 #define SDB_KSTACK	0x02
    397 #define SDB_FPSTATE	0x04
    398 #endif
    399 
    400 /*
    401  * machine dependent system variables.
    402  */
    403 static int
    404 sysctl_machdep_boot(SYSCTLFN_ARGS)
    405 {
    406 	struct sysctlnode node = *rnode;
    407 	struct btinfo_kernelfile *bi_file;
    408 	const char *cp;
    409 
    410 
    411 	switch (node.sysctl_num) {
    412 	case CPU_BOOTED_KERNEL:
    413 		if ((bi_file = lookup_bootinfo(BTINFO_KERNELFILE)) != NULL)
    414 			cp = bi_file->name;
    415 		else
    416 			cp = prom_getbootfile();
    417 		if (cp != NULL && cp[0] == '\0')
    418 			cp = "netbsd";
    419 		break;
    420 	case CPU_BOOTED_DEVICE:
    421 		cp = prom_getbootpath();
    422 		break;
    423 	case CPU_BOOT_ARGS:
    424 		cp = prom_getbootargs();
    425 		break;
    426 	default:
    427 		return (EINVAL);
    428 	}
    429 
    430 	if (cp == NULL || cp[0] == '\0')
    431 		return (ENOENT);
    432 
    433 	node.sysctl_data = __UNCONST(cp);
    434 	node.sysctl_size = strlen(cp) + 1;
    435 	return (sysctl_lookup(SYSCTLFN_CALL(&node)));
    436 }
    437 
    438 SYSCTL_SETUP(sysctl_machdep_setup, "sysctl machdep subtree setup")
    439 {
    440 
    441 	sysctl_createv(clog, 0, NULL, NULL,
    442 		       CTLFLAG_PERMANENT,
    443 		       CTLTYPE_NODE, "machdep", NULL,
    444 		       NULL, 0, NULL, 0,
    445 		       CTL_MACHDEP, CTL_EOL);
    446 
    447 	sysctl_createv(clog, 0, NULL, NULL,
    448 		       CTLFLAG_PERMANENT,
    449 		       CTLTYPE_STRING, "booted_kernel", NULL,
    450 		       sysctl_machdep_boot, 0, NULL, 0,
    451 		       CTL_MACHDEP, CPU_BOOTED_KERNEL, CTL_EOL);
    452 	sysctl_createv(clog, 0, NULL, NULL,
    453 		       CTLFLAG_PERMANENT,
    454 		       CTLTYPE_STRING, "booted_device", NULL,
    455 		       sysctl_machdep_boot, 0, NULL, 0,
    456 		       CTL_MACHDEP, CPU_BOOTED_DEVICE, CTL_EOL);
    457 	sysctl_createv(clog, 0, NULL, NULL,
    458 		       CTLFLAG_PERMANENT,
    459 		       CTLTYPE_STRING, "boot_args", NULL,
    460 		       sysctl_machdep_boot, 0, NULL, 0,
    461 		       CTL_MACHDEP, CPU_BOOT_ARGS, CTL_EOL);
    462 	sysctl_createv(clog, 0, NULL, NULL,
    463 		       CTLFLAG_PERMANENT,
    464 		       CTLTYPE_INT, "cpu_arch", NULL,
    465 		       NULL, 0, &cpu_arch, 0,
    466 		       CTL_MACHDEP, CPU_ARCH, CTL_EOL);
    467 }
    468 
    469 /*
    470  * Send an interrupt to process.
    471  */
    472 struct sigframe {
    473 	siginfo_t sf_si;
    474 	ucontext_t sf_uc;
    475 };
    476 
    477 void
    478 sendsig_siginfo(const ksiginfo_t *ksi, const sigset_t *mask)
    479 {
    480 	struct lwp *l = curlwp;
    481 	struct proc *p = l->l_proc;
    482 	struct sigacts *ps = p->p_sigacts;
    483 	struct trapframe *tf;
    484 	ucontext_t uc;
    485 	struct sigframe *fp;
    486 	u_int onstack, oldsp, newsp;
    487 	u_int catcher;
    488 	int sig, error;
    489 	size_t ucsz;
    490 
    491 	sig = ksi->ksi_signo;
    492 
    493 	tf = l->l_md.md_tf;
    494 	oldsp = tf->tf_out[6];
    495 
    496 	/*
    497 	 * Compute new user stack addresses, subtract off
    498 	 * one signal frame, and align.
    499 	 */
    500 	onstack =
    501 	    (l->l_sigstk.ss_flags & (SS_DISABLE | SS_ONSTACK)) == 0 &&
    502 	    (SIGACTION(p, sig).sa_flags & SA_ONSTACK) != 0;
    503 
    504 	if (onstack)
    505 		fp = (struct sigframe *)
    506 			((char *)l->l_sigstk.ss_sp +
    507 				  l->l_sigstk.ss_size);
    508 	else
    509 		fp = (struct sigframe *)oldsp;
    510 
    511 	fp = (struct sigframe *)((int)(fp - 1) & ~7);
    512 
    513 #ifdef DEBUG
    514 	if ((sigdebug & SDB_KSTACK) && p->p_pid == sigpid)
    515 		printf("sendsig: %s[%d] sig %d newusp %p si %p uc %p\n",
    516 		    p->p_comm, p->p_pid, sig, fp, &fp->sf_si, &fp->sf_uc);
    517 #endif
    518 
    519 	/*
    520 	 * Build the signal context to be used by sigreturn.
    521 	 */
    522 	uc.uc_flags = _UC_SIGMASK |
    523 		((l->l_sigstk.ss_flags & SS_ONSTACK)
    524 			? _UC_SETSTACK : _UC_CLRSTACK);
    525 	uc.uc_sigmask = *mask;
    526 	uc.uc_link = l->l_ctxlink;
    527 	memset(&uc.uc_stack, 0, sizeof(uc.uc_stack));
    528 
    529 	/*
    530 	 * Now copy the stack contents out to user space.
    531 	 * We need to make sure that when we start the signal handler,
    532 	 * its %i6 (%fp), which is loaded from the newly allocated stack area,
    533 	 * joins seamlessly with the frame it was in when the signal occurred,
    534 	 * so that the debugger and _longjmp code can back up through it.
    535 	 * Since we're calling the handler directly, allocate a full size
    536 	 * C stack frame.
    537 	 */
    538 	sendsig_reset(l, sig);
    539 	mutex_exit(p->p_lock);
    540 	newsp = (int)fp - sizeof(struct frame);
    541 	cpu_getmcontext(l, &uc.uc_mcontext, &uc.uc_flags);
    542 	ucsz = (int)&uc.__uc_pad - (int)&uc;
    543 	error = (copyout(&ksi->ksi_info, &fp->sf_si, sizeof ksi->ksi_info) ||
    544 	    copyout(&uc, &fp->sf_uc, ucsz) ||
    545 	    suword(&((struct rwindow *)newsp)->rw_in[6], oldsp));
    546 	mutex_enter(p->p_lock);
    547 
    548 	if (error) {
    549 		/*
    550 		 * Process has trashed its stack; give it an illegal
    551 		 * instruction to halt it in its tracks.
    552 		 */
    553 #ifdef DEBUG
    554 		if ((sigdebug & SDB_KSTACK) && p->p_pid == sigpid)
    555 			printf("sendsig: window save or copyout error\n");
    556 #endif
    557 		sigexit(l, SIGILL);
    558 		/* NOTREACHED */
    559 	}
    560 
    561 	switch (ps->sa_sigdesc[sig].sd_vers) {
    562 	default:
    563 		/* Unsupported trampoline version; kill the process. */
    564 		sigexit(l, SIGILL);
    565 	case 2:
    566 		/*
    567 		 * Arrange to continue execution at the user's handler.
    568 		 * It needs a new stack pointer, a return address and
    569 		 * three arguments: (signo, siginfo *, ucontext *).
    570 		 */
    571 		catcher = (u_int)SIGACTION(p, sig).sa_handler;
    572 		tf->tf_pc = catcher;
    573 		tf->tf_npc = catcher + 4;
    574 		tf->tf_out[0] = sig;
    575 		tf->tf_out[1] = (int)&fp->sf_si;
    576 		tf->tf_out[2] = (int)&fp->sf_uc;
    577 		tf->tf_out[6] = newsp;
    578 		tf->tf_out[7] = (int)ps->sa_sigdesc[sig].sd_tramp - 8;
    579 		break;
    580 	}
    581 
    582 	/* Remember that we're now on the signal stack. */
    583 	if (onstack)
    584 		l->l_sigstk.ss_flags |= SS_ONSTACK;
    585 
    586 #ifdef DEBUG
    587 	if ((sigdebug & SDB_KSTACK) && p->p_pid == sigpid)
    588 		printf("sendsig: about to return to catcher\n");
    589 #endif
    590 }
    591 
    592 void
    593 cpu_getmcontext(struct lwp *l, mcontext_t *mcp, unsigned int *flags)
    594 {
    595 	struct trapframe *tf = (struct trapframe *)l->l_md.md_tf;
    596 	__greg_t *r = mcp->__gregs;
    597 	__greg_t ras_pc;
    598 #ifdef FPU_CONTEXT
    599 	__fpregset_t *f = &mcp->__fpregs;
    600 	struct fpstate *fps = l->l_md.md_fpstate;
    601 #endif
    602 
    603 	/*
    604 	 * Put the stack in a consistent state before we whack away
    605 	 * at it.  Note that write_user_windows may just dump the
    606 	 * registers into the pcb; we need them in the process's memory.
    607 	 */
    608 	write_user_windows();
    609 	if (rwindow_save(l)) {
    610 		mutex_enter(l->l_proc->p_lock);
    611 		sigexit(l, SIGILL);
    612 	}
    613 
    614 	/*
    615 	 * Get the general purpose registers
    616 	 */
    617 	r[_REG_PSR] = tf->tf_psr;
    618 	r[_REG_PC] = tf->tf_pc;
    619 	r[_REG_nPC] = tf->tf_npc;
    620 	r[_REG_Y] = tf->tf_y;
    621 	r[_REG_G1] = tf->tf_global[1];
    622 	r[_REG_G2] = tf->tf_global[2];
    623 	r[_REG_G3] = tf->tf_global[3];
    624 	r[_REG_G4] = tf->tf_global[4];
    625 	r[_REG_G5] = tf->tf_global[5];
    626 	r[_REG_G6] = tf->tf_global[6];
    627 	r[_REG_G7] = tf->tf_global[7];
    628 	r[_REG_O0] = tf->tf_out[0];
    629 	r[_REG_O1] = tf->tf_out[1];
    630 	r[_REG_O2] = tf->tf_out[2];
    631 	r[_REG_O3] = tf->tf_out[3];
    632 	r[_REG_O4] = tf->tf_out[4];
    633 	r[_REG_O5] = tf->tf_out[5];
    634 	r[_REG_O6] = tf->tf_out[6];
    635 	r[_REG_O7] = tf->tf_out[7];
    636 
    637 	if ((ras_pc = (__greg_t)ras_lookup(l->l_proc,
    638 	    (void *) r[_REG_PC])) != -1) {
    639 		r[_REG_PC] = ras_pc;
    640 		r[_REG_nPC] = ras_pc + 4;
    641 	}
    642 
    643 	*flags |= (_UC_CPU|_UC_TLSBASE);
    644 
    645 #ifdef FPU_CONTEXT
    646 	/*
    647 	 * Get the floating point registers
    648 	 */
    649 	memcpy(f->__fpu_regs, fps->fs_regs, sizeof(fps->fs_regs));
    650 	f->__fp_nqsize = sizeof(struct fp_qentry);
    651 	f->__fp_nqel = fps->fs_qsize;
    652 	f->__fp_fsr = fps->fs_fsr;
    653 	if (f->__fp_q != NULL) {
    654 		size_t sz = f->__fp_nqel * f->__fp_nqsize;
    655 		if (sz > sizeof(fps->fs_queue)) {
    656 #ifdef DIAGNOSTIC
    657 			printf("getcontext: fp_queue too large\n");
    658 #endif
    659 			return;
    660 		}
    661 		if (copyout(fps->fs_queue, f->__fp_q, sz) != 0) {
    662 #ifdef DIAGNOSTIC
    663 			printf("getcontext: copy of fp_queue failed %d\n",
    664 			    error);
    665 #endif
    666 			return;
    667 		}
    668 	}
    669 	f->fp_busy = 0;	/* XXX: How do we determine that? */
    670 	*flags |= _UC_FPU;
    671 #endif
    672 
    673 	return;
    674 }
    675 
    676 int
    677 cpu_mcontext_validate(struct lwp *l, const mcontext_t *mc)
    678 {
    679 	const __greg_t *gr = mc->__gregs;
    680 
    681 	/*
    682  	 * Only the icc bits in the psr are used, so it need not be
    683  	 * verified.  pc and npc must be multiples of 4.  This is all
    684  	 * that is required; if it holds, just do it.
    685 	 */
    686 	if (((gr[_REG_PC] | gr[_REG_nPC]) & 3) != 0 ||
    687 	    gr[_REG_PC] == 0 || gr[_REG_nPC] == 0)
    688 		return EINVAL;
    689 
    690 	return 0;
    691 }
    692 
    693 /*
    694  * Set to mcontext specified.
    695  * Return to previous pc and psl as specified by
    696  * context left by sendsig. Check carefully to
    697  * make sure that the user has not modified the
    698  * psl to gain improper privileges or to cause
    699  * a machine fault.
    700  * This is almost like sigreturn() and it shows.
    701  */
    702 int
    703 cpu_setmcontext(struct lwp *l, const mcontext_t *mcp, unsigned int flags)
    704 {
    705 	struct trapframe *tf;
    706 	const __greg_t *r = mcp->__gregs;
    707 	struct proc *p = l->l_proc;
    708 	int error;
    709 #ifdef FPU_CONTEXT
    710 	__fpregset_t *f = &mcp->__fpregs;
    711 	struct fpstate *fps = l->l_md.md_fpstate;
    712 #endif
    713 
    714 	write_user_windows();
    715 	if (rwindow_save(l)) {
    716 		mutex_enter(p->p_lock);
    717 		sigexit(l, SIGILL);
    718 	}
    719 
    720 #ifdef DEBUG
    721 	if (sigdebug & SDB_FOLLOW)
    722 		printf("__setmcontext: %s[%d], __mcontext %p\n",
    723 		    l->l_proc->p_comm, l->l_proc->p_pid, mcp);
    724 #endif
    725 
    726 	if (flags & _UC_CPU) {
    727 		/* Validate */
    728 		error = cpu_mcontext_validate(l, mcp);
    729 		if (error)
    730 			return error;
    731 
    732 		/* Restore register context. */
    733 		tf = (struct trapframe *)l->l_md.md_tf;
    734 
    735 		/* take only psr ICC field */
    736 		tf->tf_psr = (tf->tf_psr & ~PSR_ICC) |
    737 		    (r[_REG_PSR] & PSR_ICC);
    738 		tf->tf_pc = r[_REG_PC];
    739 		tf->tf_npc = r[_REG_nPC];
    740 		tf->tf_y = r[_REG_Y];
    741 
    742 		/* Restore everything */
    743 		tf->tf_global[1] = r[_REG_G1];
    744 		tf->tf_global[2] = r[_REG_G2];
    745 		tf->tf_global[3] = r[_REG_G3];
    746 		tf->tf_global[4] = r[_REG_G4];
    747 		tf->tf_global[5] = r[_REG_G5];
    748 		tf->tf_global[6] = r[_REG_G6];
    749 		/* done in lwp_setprivate */
    750 		/* tf->tf_global[7] = r[_REG_G7]; */
    751 
    752 		tf->tf_out[0] = r[_REG_O0];
    753 		tf->tf_out[1] = r[_REG_O1];
    754 		tf->tf_out[2] = r[_REG_O2];
    755 		tf->tf_out[3] = r[_REG_O3];
    756 		tf->tf_out[4] = r[_REG_O4];
    757 		tf->tf_out[5] = r[_REG_O5];
    758 		tf->tf_out[6] = r[_REG_O6];
    759 		tf->tf_out[7] = r[_REG_O7];
    760 
    761 		if (flags & _UC_TLSBASE)
    762 			lwp_setprivate(l, (void *)(uintptr_t)r[_REG_G7]);
    763 	}
    764 
    765 #ifdef FPU_CONTEXT
    766 	if (flags & _UC_FPU) {
    767 		/*
    768 		 * Set the floating point registers
    769 		 */
    770 		int error;
    771 		size_t sz = f->__fp_nqel * f->__fp_nqsize;
    772 		if (sz > sizeof(fps->fs_queue)) {
    773 #ifdef DIAGNOSTIC
    774 			printf("setmcontext: fp_queue too large\n");
    775 #endif
    776 			return (EINVAL);
    777 		}
    778 		memcpy(fps->fs_regs, f->__fpu_regs, sizeof(fps->fs_regs));
    779 		fps->fs_qsize = f->__fp_nqel;
    780 		fps->fs_fsr = f->__fp_fsr;
    781 		if (f->__fp_q != NULL) {
    782 			if ((error = copyin(f->__fp_q, fps->fs_queue, sz)) != 0) {
    783 #ifdef DIAGNOSTIC
    784 				printf("setmcontext: fp_queue copy failed\n");
    785 #endif
    786 				return (error);
    787 			}
    788 		}
    789 	}
    790 #endif
    791 
    792 	mutex_enter(p->p_lock);
    793 	if (flags & _UC_SETSTACK)
    794 		l->l_sigstk.ss_flags |= SS_ONSTACK;
    795 	if (flags & _UC_CLRSTACK)
    796 		l->l_sigstk.ss_flags &= ~SS_ONSTACK;
    797 	mutex_exit(p->p_lock);
    798 
    799 	return (0);
    800 }
    801 
    802 int	waittime = -1;
    803 
    804 void
    805 cpu_reboot(int howto, char *user_boot_string)
    806 {
    807 	int i;
    808 	char opts[4];
    809 	static char str[128];
    810 
    811 	/* If system is cold, just halt. */
    812 	if (cold) {
    813 		howto |= RB_HALT;
    814 		goto haltsys;
    815 	}
    816 
    817 #if NFB > 0
    818 	fb_unblank();
    819 #endif
    820 	boothowto = howto;
    821 	if ((howto & RB_NOSYNC) == 0 && waittime < 0) {
    822 		extern struct lwp lwp0;
    823 
    824 		/* XXX protect against curlwp->p_stats.foo refs in sync() */
    825 		if (curlwp == NULL)
    826 			curlwp = &lwp0;
    827 		waittime = 0;
    828 		vfs_shutdown();
    829 
    830 		/*
    831 		 * If we've been adjusting the clock, the todr
    832 		 * will be out of synch; adjust it now.
    833 		 * resettodr will only do this only if inittodr()
    834 		 * has already been called.
    835 		 */
    836 		resettodr();
    837 	}
    838 
    839 	/* Disable interrupts. But still allow IPI on MP systems */
    840 	if (sparc_ncpus > 1)
    841 		(void)splsched();
    842 	else
    843 		(void)splhigh();
    844 
    845 #if defined(MULTIPROCESSOR)
    846 	/* Direct system interrupts to this CPU, since dump uses polled I/O */
    847 	if (CPU_ISSUN4M)
    848 		*((u_int *)ICR_ITR) = cpuinfo.mid - 8;
    849 #endif
    850 
    851 	/* If rebooting and a dump is requested, do it. */
    852 #if 0
    853 	if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
    854 #else
    855 	if (howto & RB_DUMP)
    856 #endif
    857 		dumpsys();
    858 
    859  haltsys:
    860 
    861 	/* Run any shutdown hooks. */
    862 	doshutdownhooks();
    863 
    864 	pmf_system_shutdown(boothowto);
    865 
    866 	/* If powerdown was requested, do it. */
    867 	if ((howto & RB_POWERDOWN) == RB_POWERDOWN) {
    868 		prom_interpret("power-off");
    869 #if NPOWER > 0
    870 		/* Fall back on `power' device if the PROM can't do it */
    871 		powerdown();
    872 #endif
    873 		printf("WARNING: powerdown not supported\n");
    874 		/*
    875 		 * RB_POWERDOWN implies RB_HALT... fall into it...
    876 		 */
    877 	}
    878 
    879 	if (howto & RB_HALT) {
    880 #if defined(MULTIPROCESSOR)
    881 		mp_halt_cpus();
    882 		printf("cpu%d halted\n\n", cpu_number());
    883 #else
    884 		printf("halted\n\n");
    885 #endif
    886 		prom_halt();
    887 	}
    888 
    889 	printf("rebooting\n\n");
    890 
    891 	i = 1;
    892 	if (howto & RB_SINGLE)
    893 		opts[i++] = 's';
    894 	if (howto & RB_KDB)
    895 		opts[i++] = 'd';
    896 	opts[i] = '\0';
    897 	opts[0] = (i > 1) ? '-' : '\0';
    898 
    899 	if (user_boot_string && *user_boot_string) {
    900 		i = strlen(user_boot_string);
    901 		if (i > sizeof(str) - sizeof(opts) - 1)
    902 			prom_boot(user_boot_string);	/* XXX */
    903 		memcpy(str, user_boot_string, i);
    904 		if (opts[0] != '\0')
    905 			str[i] = ' ';
    906 	}
    907 	strcat(str, opts);
    908 	prom_boot(str);
    909 	/*NOTREACHED*/
    910 }
    911 
    912 uint32_t dumpmag = 0x8fca0101;	/* magic number for savecore */
    913 int	dumpsize = 0;		/* also for savecore */
    914 long	dumplo = 0;
    915 
    916 void
    917 cpu_dumpconf(void)
    918 {
    919 	int nblks, dumpblks;
    920 
    921 	if (dumpdev == NODEV)
    922 		return;
    923 	nblks = bdev_size(dumpdev);
    924 
    925 	dumpblks = ctod(physmem) + pmap_dumpsize();
    926 	if (dumpblks > (nblks - ctod(1)))
    927 		/*
    928 		 * dump size is too big for the partition.
    929 		 * Note, we safeguard a click at the front for a
    930 		 * possible disk label.
    931 		 */
    932 		return;
    933 
    934 	/* Put the dump at the end of the partition */
    935 	dumplo = nblks - dumpblks;
    936 
    937 	/*
    938 	 * savecore(8) expects dumpsize to be the number of pages
    939 	 * of actual core dumped (i.e. excluding the MMU stuff).
    940 	 */
    941 	dumpsize = physmem;
    942 }
    943 
    944 #define	BYTES_PER_DUMP	(32 * 1024)	/* must be a multiple of pagesize */
    945 static vaddr_t dumpspace;
    946 
    947 void *
    948 reserve_dumppages(void *p)
    949 {
    950 
    951 	dumpspace = (vaddr_t)p;
    952 	return ((char *)p + BYTES_PER_DUMP);
    953 }
    954 
    955 /*
    956  * Write a crash dump.
    957  */
    958 void
    959 dumpsys(void)
    960 {
    961 	const struct bdevsw *bdev;
    962 	int psize;
    963 	daddr_t blkno;
    964 	int (*dump)(dev_t, daddr_t, void *, size_t);
    965 	int error = 0;
    966 	struct memarr *mp;
    967 	int nmem;
    968 	extern struct memarr pmemarr[];
    969 	extern int npmemarr;
    970 
    971 	/* copy registers to memory */
    972 	snapshot(cpuinfo.curpcb);
    973 	stackdump();
    974 
    975 	if (dumpdev == NODEV)
    976 		return;
    977 	bdev = bdevsw_lookup(dumpdev);
    978 	if (bdev == NULL || bdev->d_psize == NULL)
    979 		return;
    980 
    981 	/*
    982 	 * For dumps during autoconfiguration,
    983 	 * if dump device has already configured...
    984 	 */
    985 	if (dumpsize == 0)
    986 		cpu_dumpconf();
    987 	if (dumplo <= 0) {
    988 		printf("\ndump to dev %u,%u not possible\n",
    989 		    major(dumpdev), minor(dumpdev));
    990 		return;
    991 	}
    992 	printf("\ndumping to dev %u,%u offset %ld\n",
    993 	    major(dumpdev), minor(dumpdev), dumplo);
    994 
    995 	psize = bdev_size(dumpdev);
    996 	printf("dump ");
    997 	if (psize == -1) {
    998 		printf("area unavailable\n");
    999 		return;
   1000 	}
   1001 	blkno = dumplo;
   1002 	dump = bdev->d_dump;
   1003 
   1004 	error = pmap_dumpmmu(dump, blkno);
   1005 	blkno += pmap_dumpsize();
   1006 
   1007 	for (mp = pmemarr, nmem = npmemarr; --nmem >= 0 && error == 0; mp++) {
   1008 		unsigned i = 0, n;
   1009 		int maddr = mp->addr;
   1010 
   1011 		if (maddr == 0) {
   1012 			/* Skip first page at physical address 0 */
   1013 			maddr += PAGE_SIZE;
   1014 			i += PAGE_SIZE;
   1015 			blkno += btodb(PAGE_SIZE);
   1016 		}
   1017 
   1018 		for (; i < mp->len; i += n) {
   1019 			n = mp->len - i;
   1020 			if (n > BYTES_PER_DUMP)
   1021 				 n = BYTES_PER_DUMP;
   1022 
   1023 			/* print out how many MBs we have dumped */
   1024 			if (i && (i % (1024*1024)) == 0)
   1025 				printf_nolog("%d ", i / (1024*1024));
   1026 
   1027 			(void) pmap_map(dumpspace, maddr, maddr + n,
   1028 					VM_PROT_READ);
   1029 			error = (*dump)(dumpdev, blkno,
   1030 					(void *)dumpspace, (int)n);
   1031 			pmap_kremove(dumpspace, n);
   1032 			pmap_update(pmap_kernel());
   1033 			if (error)
   1034 				break;
   1035 			maddr += n;
   1036 			blkno += btodb(n);
   1037 		}
   1038 	}
   1039 
   1040 	switch (error) {
   1041 
   1042 	case ENXIO:
   1043 		printf("device bad\n");
   1044 		break;
   1045 
   1046 	case EFAULT:
   1047 		printf("device not ready\n");
   1048 		break;
   1049 
   1050 	case EINVAL:
   1051 		printf("area improper\n");
   1052 		break;
   1053 
   1054 	case EIO:
   1055 		printf("i/o error\n");
   1056 		break;
   1057 
   1058 	case 0:
   1059 		printf("succeeded\n");
   1060 		break;
   1061 
   1062 	default:
   1063 		printf("error %d\n", error);
   1064 		break;
   1065 	}
   1066 }
   1067 
   1068 /*
   1069  * get the fp and dump the stack as best we can.  don't leave the
   1070  * current stack page
   1071  */
   1072 void
   1073 stackdump(void)
   1074 {
   1075 	struct frame *fp = getfp(), *sfp;
   1076 
   1077 	sfp = fp;
   1078 	printf("Frame pointer is at %p\n", fp);
   1079 	printf("Call traceback:\n");
   1080 	while (fp && ((u_long)fp >> PGSHIFT) == ((u_long)sfp >> PGSHIFT)) {
   1081 		printf("  pc = 0x%x  args = (0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x) fp = %p\n",
   1082 		    fp->fr_pc, fp->fr_arg[0], fp->fr_arg[1], fp->fr_arg[2],
   1083 		    fp->fr_arg[3], fp->fr_arg[4], fp->fr_arg[5], fp->fr_fp);
   1084 		fp = fp->fr_fp;
   1085 	}
   1086 }
   1087 
   1088 int
   1089 cpu_exec_aout_makecmds(struct lwp *l, struct exec_package *epp)
   1090 {
   1091 
   1092 	return (ENOEXEC);
   1093 }
   1094 
   1095 #if defined(SUN4)
   1096 void
   1097 oldmon_w_trace(u_long va)
   1098 {
   1099 	struct cpu_info * const ci = curcpu();
   1100 	u_long stop;
   1101 	struct frame *fp;
   1102 
   1103 	printf("curlwp = %p, pid %d\n", curlwp, curproc->p_pid);
   1104 
   1105 	printf("uvm: cpu%u: swtch %"PRIu64", trap %"PRIu64", sys %"PRIu64", "
   1106 	    "intr %"PRIu64", soft %"PRIu64", faults %"PRIu64"\n",
   1107 	    cpu_index(ci), ci->ci_data.cpu_nswtch, ci->ci_data.cpu_ntrap,
   1108 	    ci->ci_data.cpu_nsyscall, ci->ci_data.cpu_nintr,
   1109 	    ci->ci_data.cpu_nsoft, ci->ci_data.cpu_nfault);
   1110 	write_user_windows();
   1111 
   1112 #define round_up(x) (( (x) + (PAGE_SIZE-1) ) & (~(PAGE_SIZE-1)) )
   1113 
   1114 	printf("\nstack trace with sp = 0x%lx\n", va);
   1115 	stop = round_up(va);
   1116 	printf("stop at 0x%lx\n", stop);
   1117 	fp = (struct frame *) va;
   1118 	while (round_up((u_long) fp) == stop) {
   1119 		printf("  0x%x(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x) fp %p\n", fp->fr_pc,
   1120 		    fp->fr_arg[0], fp->fr_arg[1], fp->fr_arg[2], fp->fr_arg[3],
   1121 		    fp->fr_arg[4], fp->fr_arg[5], fp->fr_fp);
   1122 		fp = fp->fr_fp;
   1123 		if (fp == NULL)
   1124 			break;
   1125 	}
   1126 	printf("end of stack trace\n");
   1127 }
   1128 
   1129 void
   1130 oldmon_w_cmd(u_long va, char *ar)
   1131 {
   1132 	switch (*ar) {
   1133 	case '\0':
   1134 		switch (va) {
   1135 		case 0:
   1136 			panic("g0 panic");
   1137 		case 4:
   1138 			printf("w: case 4\n");
   1139 			break;
   1140 		default:
   1141 			printf("w: unknown case %ld\n", va);
   1142 			break;
   1143 		}
   1144 		break;
   1145 	case 't':
   1146 		oldmon_w_trace(va);
   1147 		break;
   1148 	default:
   1149 		printf("w: arg not allowed\n");
   1150 	}
   1151 }
   1152 
   1153 int
   1154 ldcontrolb(void *addr)
   1155 {
   1156 	struct pcb *xpcb;
   1157 	u_long saveonfault;
   1158 	int res;
   1159 	int s;
   1160 
   1161 	if (CPU_ISSUN4M || CPU_ISSUN4D) {
   1162 		printf("warning: ldcontrolb called on sun4m/sun4d\n");
   1163 		return 0;
   1164 	}
   1165 
   1166 	s = splhigh();
   1167 	xpcb = lwp_getpcb(curlwp);
   1168 
   1169 	saveonfault = (u_long)xpcb->pcb_onfault;
   1170         res = xldcontrolb(addr, xpcb);
   1171 	xpcb->pcb_onfault = (void *)saveonfault;
   1172 
   1173 	splx(s);
   1174 	return (res);
   1175 }
   1176 #endif /* SUN4 */
   1177 
   1178 void
   1179 wzero(void *vb, u_int l)
   1180 {
   1181 	u_char *b = vb;
   1182 	u_char *be = b + l;
   1183 	u_short *sp;
   1184 
   1185 	if (l == 0)
   1186 		return;
   1187 
   1188 	/* front, */
   1189 	if ((u_long)b & 1)
   1190 		*b++ = 0;
   1191 
   1192 	/* back, */
   1193 	if (b != be && ((u_long)be & 1) != 0) {
   1194 		be--;
   1195 		*be = 0;
   1196 	}
   1197 
   1198 	/* and middle. */
   1199 	sp = (u_short *)b;
   1200 	while (sp != (u_short *)be)
   1201 		*sp++ = 0;
   1202 }
   1203 
   1204 void
   1205 wcopy(const void *vb1, void *vb2, u_int l)
   1206 {
   1207 	const u_char *b1e, *b1 = vb1;
   1208 	u_char *b2 = vb2;
   1209 	const u_short *sp;
   1210 	int bstore = 0;
   1211 
   1212 	if (l == 0)
   1213 		return;
   1214 
   1215 	/* front, */
   1216 	if ((u_long)b1 & 1) {
   1217 		*b2++ = *b1++;
   1218 		l--;
   1219 	}
   1220 
   1221 	/* middle, */
   1222 	sp = (const u_short *)b1;
   1223 	b1e = b1 + l;
   1224 	if (l & 1)
   1225 		b1e--;
   1226 	bstore = (u_long)b2 & 1;
   1227 
   1228 	while (sp < (const u_short *)b1e) {
   1229 		if (bstore) {
   1230 			b2[1] = *sp & 0xff;
   1231 			b2[0] = *sp >> 8;
   1232 		} else
   1233 			*((short *)b2) = *sp;
   1234 		sp++;
   1235 		b2 += 2;
   1236 	}
   1237 
   1238 	/* and back. */
   1239 	if (l & 1)
   1240 		*b2 = *b1e;
   1241 }
   1242 
   1243 #ifdef MODULAR
   1244 void
   1245 module_init_md(void)
   1246 {
   1247 }
   1248 #endif
   1249 
   1250 /*
   1251  * Common function for DMA map creation.  May be called by bus-specific
   1252  * DMA map creation functions.
   1253  */
   1254 int
   1255 _bus_dmamap_create(bus_dma_tag_t t, bus_size_t size, int nsegments,
   1256 		   bus_size_t maxsegsz, bus_size_t boundary, int flags,
   1257 		   bus_dmamap_t *dmamp)
   1258 {
   1259 	struct sparc_bus_dmamap *map;
   1260 	void *mapstore;
   1261 	size_t mapsize;
   1262 
   1263 	/*
   1264 	 * Allocate and initialize the DMA map.  The end of the map
   1265 	 * is a variable-sized array of segments, so we allocate enough
   1266 	 * room for them in one shot.
   1267 	 *
   1268 	 * Note we don't preserve the WAITOK or NOWAIT flags.  Preservation
   1269 	 * of ALLOCNOW notifies others that we've reserved these resources,
   1270 	 * and they are not to be freed.
   1271 	 *
   1272 	 * The bus_dmamap_t includes one bus_dma_segment_t, hence
   1273 	 * the (nsegments - 1).
   1274 	 */
   1275 	mapsize = sizeof(struct sparc_bus_dmamap) +
   1276 	    (sizeof(bus_dma_segment_t) * (nsegments - 1));
   1277 	if ((mapstore = malloc(mapsize, M_DMAMAP,
   1278 	    (flags & BUS_DMA_NOWAIT) ? M_NOWAIT : M_WAITOK)) == NULL)
   1279 		return (ENOMEM);
   1280 
   1281 	memset(mapstore, 0, mapsize);
   1282 	map = (struct sparc_bus_dmamap *)mapstore;
   1283 	map->_dm_size = size;
   1284 	map->_dm_segcnt = nsegments;
   1285 	map->_dm_maxmaxsegsz = maxsegsz;
   1286 	map->_dm_boundary = boundary;
   1287 	map->_dm_align = PAGE_SIZE;
   1288 	map->_dm_flags = flags & ~(BUS_DMA_WAITOK|BUS_DMA_NOWAIT);
   1289 	map->dm_maxsegsz = maxsegsz;
   1290 	map->dm_mapsize = 0;		/* no valid mappings */
   1291 	map->dm_nsegs = 0;
   1292 
   1293 	*dmamp = map;
   1294 	return (0);
   1295 }
   1296 
   1297 /*
   1298  * Common function for DMA map destruction.  May be called by bus-specific
   1299  * DMA map destruction functions.
   1300  */
   1301 void
   1302 _bus_dmamap_destroy(bus_dma_tag_t t, bus_dmamap_t map)
   1303 {
   1304 
   1305 	free(map, M_DMAMAP);
   1306 }
   1307 
   1308 /*
   1309  * Like _bus_dmamap_load(), but for mbufs.
   1310  */
   1311 int
   1312 _bus_dmamap_load_mbuf(bus_dma_tag_t t, bus_dmamap_t map,
   1313 		      struct mbuf *m, int flags)
   1314 {
   1315 
   1316 	panic("_bus_dmamap_load_mbuf: not implemented");
   1317 }
   1318 
   1319 /*
   1320  * Like _bus_dmamap_load(), but for uios.
   1321  */
   1322 int
   1323 _bus_dmamap_load_uio(bus_dma_tag_t t, bus_dmamap_t map,
   1324 		     struct uio *uio, int flags)
   1325 {
   1326 
   1327 	panic("_bus_dmamap_load_uio: not implemented");
   1328 }
   1329 
   1330 /*
   1331  * Like _bus_dmamap_load(), but for raw memory allocated with
   1332  * bus_dmamem_alloc().
   1333  */
   1334 int
   1335 _bus_dmamap_load_raw(bus_dma_tag_t t, bus_dmamap_t map,
   1336 		     bus_dma_segment_t *segs, int nsegs, bus_size_t size,
   1337 		     int flags)
   1338 {
   1339 
   1340 	panic("_bus_dmamap_load_raw: not implemented");
   1341 }
   1342 
   1343 /*
   1344  * Common function for DMA map synchronization.  May be called
   1345  * by bus-specific DMA map synchronization functions.
   1346  */
   1347 void
   1348 _bus_dmamap_sync(bus_dma_tag_t t, bus_dmamap_t map,
   1349 		 bus_addr_t offset, bus_size_t len, int ops)
   1350 {
   1351 }
   1352 
   1353 /*
   1354  * Common function for DMA-safe memory allocation.  May be called
   1355  * by bus-specific DMA memory allocation functions.
   1356  */
   1357 int
   1358 _bus_dmamem_alloc(bus_dma_tag_t t, bus_size_t size,
   1359 		  bus_size_t alignment, bus_size_t boundary,
   1360 		  bus_dma_segment_t *segs, int nsegs, int *rsegs,
   1361 		  int flags)
   1362 {
   1363 	vaddr_t low, high;
   1364 	struct pglist *mlist;
   1365 	int error;
   1366 
   1367 	/* Always round the size. */
   1368 	size = round_page(size);
   1369 	low = vm_first_phys;
   1370 	high = vm_first_phys + vm_num_phys - PAGE_SIZE;
   1371 
   1372 	if ((mlist = malloc(sizeof(*mlist), M_DEVBUF,
   1373 	    (flags & BUS_DMA_NOWAIT) ? M_NOWAIT : M_WAITOK)) == NULL)
   1374 		return (ENOMEM);
   1375 
   1376 	/*
   1377 	 * Allocate pages from the VM system.
   1378 	 */
   1379 	error = uvm_pglistalloc(size, low, high, 0, 0,
   1380 				mlist, nsegs, (flags & BUS_DMA_NOWAIT) == 0);
   1381 	if (error)
   1382 		return (error);
   1383 
   1384 	/*
   1385 	 * Simply keep a pointer around to the linked list, so
   1386 	 * bus_dmamap_free() can return it.
   1387 	 *
   1388 	 * NOBODY SHOULD TOUCH THE pageq.queue FIELDS WHILE THESE PAGES
   1389 	 * ARE IN OUR CUSTODY.
   1390 	 */
   1391 	segs[0]._ds_mlist = mlist;
   1392 
   1393 	/*
   1394 	 * We now have physical pages, but no DVMA addresses yet. These
   1395 	 * will be allocated in bus_dmamap_load*() routines. Hence we
   1396 	 * save any alignment and boundary requirements in this DMA
   1397 	 * segment.
   1398 	 */
   1399 	segs[0].ds_addr = 0;
   1400 	segs[0].ds_len = 0;
   1401 	segs[0]._ds_va = 0;
   1402 	*rsegs = 1;
   1403 	return (0);
   1404 }
   1405 
   1406 /*
   1407  * Common function for freeing DMA-safe memory.  May be called by
   1408  * bus-specific DMA memory free functions.
   1409  */
   1410 void
   1411 _bus_dmamem_free(bus_dma_tag_t t, bus_dma_segment_t *segs, int nsegs)
   1412 {
   1413 
   1414 	if (nsegs != 1)
   1415 		panic("bus_dmamem_free: nsegs = %d", nsegs);
   1416 
   1417 	/*
   1418 	 * Return the list of pages back to the VM system.
   1419 	 */
   1420 	uvm_pglistfree(segs[0]._ds_mlist);
   1421 	free(segs[0]._ds_mlist, M_DEVBUF);
   1422 }
   1423 
   1424 /*
   1425  * Common function for unmapping DMA-safe memory.  May be called by
   1426  * bus-specific DMA memory unmapping functions.
   1427  */
   1428 void
   1429 _bus_dmamem_unmap(bus_dma_tag_t t, void *kva, size_t size)
   1430 {
   1431 
   1432 #ifdef DIAGNOSTIC
   1433 	if ((u_long)kva & PAGE_MASK)
   1434 		panic("_bus_dmamem_unmap");
   1435 #endif
   1436 
   1437 	size = round_page(size);
   1438 	pmap_kremove((vaddr_t)kva, size);
   1439 	pmap_update(pmap_kernel());
   1440 	uvm_km_free(kernel_map, (vaddr_t)kva, size, UVM_KMF_VAONLY);
   1441 }
   1442 
   1443 /*
   1444  * Common functin for mmap(2)'ing DMA-safe memory.  May be called by
   1445  * bus-specific DMA mmap(2)'ing functions.
   1446  */
   1447 paddr_t
   1448 _bus_dmamem_mmap(bus_dma_tag_t t, bus_dma_segment_t *segs, int nsegs,
   1449 		 off_t off, int prot, int flags)
   1450 {
   1451 
   1452 	panic("_bus_dmamem_mmap: not implemented");
   1453 }
   1454 
   1455 /*
   1456  * Utility to allocate an aligned kernel virtual address range
   1457  */
   1458 vaddr_t
   1459 _bus_dma_valloc_skewed(size_t size, u_long boundary, u_long align, u_long skew)
   1460 {
   1461 	size_t oversize;
   1462 	vaddr_t va, sva;
   1463 
   1464 	/*
   1465 	 * Find a region of kernel virtual addresses that is aligned
   1466 	 * to the given address modulo the requested alignment, i.e.
   1467 	 *
   1468 	 *	(va - skew) == 0 mod align
   1469 	 *
   1470 	 * The following conditions apply to the arguments:
   1471 	 *
   1472 	 *	- `size' must be a multiple of the VM page size
   1473 	 *	- `align' must be a power of two
   1474 	 *	   and greater than or equal to the VM page size
   1475 	 *	- `skew' must be smaller than `align'
   1476 	 *	- `size' must be smaller than `boundary'
   1477 	 */
   1478 
   1479 #ifdef DIAGNOSTIC
   1480 	if ((size & PAGE_MASK) != 0)
   1481 		panic("_bus_dma_valloc_skewed: invalid size %lx", size);
   1482 	if ((align & PAGE_MASK) != 0)
   1483 		panic("_bus_dma_valloc_skewed: invalid alignment %lx", align);
   1484 	if (align < skew)
   1485 		panic("_bus_dma_valloc_skewed: align %lx < skew %lx",
   1486 			align, skew);
   1487 #endif
   1488 
   1489 	/* XXX - Implement this! */
   1490 	if (boundary) {
   1491 		printf("_bus_dma_valloc_skewed: "
   1492 			"boundary check not implemented");
   1493 		return (0);
   1494 	}
   1495 
   1496 	/*
   1497 	 * First, find a region large enough to contain any aligned chunk
   1498 	 */
   1499 	oversize = size + align - PAGE_SIZE;
   1500 	sva = vm_map_min(kernel_map);
   1501 	if (uvm_map(kernel_map, &sva, oversize, NULL, UVM_UNKNOWN_OFFSET,
   1502 	    align, UVM_MAPFLAG(UVM_PROT_ALL, UVM_PROT_ALL, UVM_INH_NONE,
   1503 	    UVM_ADV_RANDOM, UVM_FLAG_NOWAIT)))
   1504 		return (0);
   1505 
   1506 	/*
   1507 	 * Compute start of aligned region
   1508 	 */
   1509 	va = sva;
   1510 	va += (skew + align - va) & (align - 1);
   1511 
   1512 	/*
   1513 	 * Return excess virtual addresses
   1514 	 */
   1515 	if (va != sva)
   1516 		(void)uvm_unmap(kernel_map, sva, va);
   1517 	if (va + size != sva + oversize)
   1518 		(void)uvm_unmap(kernel_map, va + size, sva + oversize);
   1519 
   1520 	return (va);
   1521 }
   1522 
   1523 /* sun4/sun4c DMA map functions */
   1524 int	sun4_dmamap_load(bus_dma_tag_t, bus_dmamap_t, void *,
   1525 				bus_size_t, struct proc *, int);
   1526 int	sun4_dmamap_load_raw(bus_dma_tag_t, bus_dmamap_t,
   1527 				bus_dma_segment_t *, int, bus_size_t, int);
   1528 void	sun4_dmamap_unload(bus_dma_tag_t, bus_dmamap_t);
   1529 int	sun4_dmamem_map(bus_dma_tag_t, bus_dma_segment_t *,
   1530 				int, size_t, void **, int);
   1531 
   1532 /*
   1533  * sun4/sun4c: load DMA map with a linear buffer.
   1534  */
   1535 int
   1536 sun4_dmamap_load(bus_dma_tag_t t, bus_dmamap_t map,
   1537 		 void *buf, bus_size_t buflen,
   1538 		 struct proc *p, int flags)
   1539 {
   1540 	bus_size_t sgsize;
   1541 	vaddr_t va = (vaddr_t)buf;
   1542 	int pagesz = PAGE_SIZE;
   1543 	vaddr_t dva;
   1544 	pmap_t pmap;
   1545 
   1546 	/*
   1547 	 * Make sure that on error condition we return "no valid mappings".
   1548 	 */
   1549 	map->dm_nsegs = 0;
   1550 
   1551 	if (buflen > map->_dm_size)
   1552 		return (EINVAL);
   1553 
   1554 	cache_flush(buf, buflen);
   1555 
   1556 	if ((map->_dm_flags & BUS_DMA_24BIT) == 0) {
   1557 		/*
   1558 		 * XXX Need to implement "don't DMA across this boundry".
   1559 		 */
   1560 		if (map->_dm_boundary != 0) {
   1561 			bus_addr_t baddr;
   1562 
   1563 			/* Calculate first boundary line after `buf' */
   1564 			baddr = ((bus_addr_t)va + map->_dm_boundary) &
   1565 					-map->_dm_boundary;
   1566 
   1567 			/*
   1568 			 * If the requested segment crosses the boundary,
   1569 			 * we can't grant a direct map. For now, steal some
   1570 			 * space from the `24BIT' map instead.
   1571 			 *
   1572 			 * (XXX - no overflow detection here)
   1573 			 */
   1574 			if (buflen > (baddr - (bus_addr_t)va))
   1575 				goto no_fit;
   1576 		}
   1577 		map->dm_mapsize = buflen;
   1578 		map->dm_nsegs = 1;
   1579 		map->dm_segs[0].ds_addr = (bus_addr_t)va;
   1580 		map->dm_segs[0].ds_len = buflen;
   1581 		map->_dm_flags |= _BUS_DMA_DIRECTMAP;
   1582 		return (0);
   1583 	}
   1584 
   1585 no_fit:
   1586 	sgsize = round_page(buflen + (va & (pagesz - 1)));
   1587 
   1588 	if (extent_alloc(dvmamap24, sgsize, pagesz, map->_dm_boundary,
   1589 			 (flags & BUS_DMA_NOWAIT) == 0 ? EX_WAITOK : EX_NOWAIT,
   1590 			 &dva) != 0) {
   1591 		return (ENOMEM);
   1592 	}
   1593 
   1594 	/*
   1595 	 * We always use just one segment.
   1596 	 */
   1597 	map->dm_mapsize = buflen;
   1598 	map->dm_segs[0].ds_addr = dva + (va & (pagesz - 1));
   1599 	map->dm_segs[0].ds_len = buflen;
   1600 	map->dm_segs[0]._ds_sgsize = sgsize;
   1601 
   1602 	if (p != NULL)
   1603 		pmap = p->p_vmspace->vm_map.pmap;
   1604 	else
   1605 		pmap = pmap_kernel();
   1606 
   1607 	for (; buflen > 0; ) {
   1608 		paddr_t pa;
   1609 
   1610 		/*
   1611 		 * Get the physical address for this page.
   1612 		 */
   1613 		(void) pmap_extract(pmap, va, &pa);
   1614 
   1615 		/*
   1616 		 * Compute the segment size, and adjust counts.
   1617 		 */
   1618 		sgsize = pagesz - (va & (pagesz - 1));
   1619 		if (buflen < sgsize)
   1620 			sgsize = buflen;
   1621 
   1622 #ifdef notyet
   1623 #if defined(SUN4)
   1624 		if (have_iocache)
   1625 			pa |= PG_IOC;
   1626 #endif
   1627 #endif
   1628 		pmap_kenter_pa(dva, (pa & -pagesz) | PMAP_NC,
   1629 		    VM_PROT_READ | VM_PROT_WRITE, 0);
   1630 
   1631 		dva += pagesz;
   1632 		va += sgsize;
   1633 		buflen -= sgsize;
   1634 	}
   1635 	pmap_update(pmap_kernel());
   1636 
   1637 	map->dm_nsegs = 1;
   1638 	return (0);
   1639 }
   1640 
   1641 /*
   1642  * Like _bus_dmamap_load(), but for raw memory allocated with
   1643  * bus_dmamem_alloc().
   1644  */
   1645 int
   1646 sun4_dmamap_load_raw(bus_dma_tag_t t, bus_dmamap_t map,
   1647 		     bus_dma_segment_t *segs, int nsegs, bus_size_t size,
   1648 		     int flags)
   1649 {
   1650 	struct vm_page *m;
   1651 	paddr_t pa;
   1652 	vaddr_t dva;
   1653 	bus_size_t sgsize;
   1654 	struct pglist *mlist;
   1655 	int pagesz = PAGE_SIZE;
   1656 	int error;
   1657 
   1658 	map->dm_nsegs = 0;
   1659 	sgsize = (size + pagesz - 1) & -pagesz;
   1660 
   1661 	/* Allocate DVMA addresses */
   1662 	if ((map->_dm_flags & BUS_DMA_24BIT) != 0) {
   1663 		error = extent_alloc(dvmamap24, sgsize, pagesz,
   1664 					map->_dm_boundary,
   1665 					(flags & BUS_DMA_NOWAIT) == 0
   1666 						? EX_WAITOK : EX_NOWAIT,
   1667 					&dva);
   1668 		if (error)
   1669 			return (error);
   1670 	} else {
   1671 		/* Any properly aligned virtual address will do */
   1672 		dva = _bus_dma_valloc_skewed(sgsize, map->_dm_boundary,
   1673 					     pagesz, 0);
   1674 		if (dva == 0)
   1675 			return (ENOMEM);
   1676 	}
   1677 
   1678 	map->dm_segs[0].ds_addr = dva;
   1679 	map->dm_segs[0].ds_len = size;
   1680 	map->dm_segs[0]._ds_sgsize = sgsize;
   1681 
   1682 	/* Map physical pages into IOMMU */
   1683 	mlist = segs[0]._ds_mlist;
   1684 	for (m = TAILQ_FIRST(mlist); m != NULL; m = TAILQ_NEXT(m,pageq.queue)) {
   1685 		if (sgsize == 0)
   1686 			panic("sun4_dmamap_load_raw: size botch");
   1687 		pa = VM_PAGE_TO_PHYS(m);
   1688 #ifdef notyet
   1689 #if defined(SUN4)
   1690 		if (have_iocache)
   1691 			pa |= PG_IOC;
   1692 #endif
   1693 #endif
   1694 		pmap_kenter_pa(dva, (pa & -pagesz) | PMAP_NC,
   1695 		    VM_PROT_READ | VM_PROT_WRITE, 0);
   1696 
   1697 		dva += pagesz;
   1698 		sgsize -= pagesz;
   1699 	}
   1700 	pmap_update(pmap_kernel());
   1701 
   1702 	map->dm_nsegs = 1;
   1703 	map->dm_mapsize = size;
   1704 
   1705 	return (0);
   1706 }
   1707 
   1708 /*
   1709  * sun4/sun4c function for unloading a DMA map.
   1710  */
   1711 void
   1712 sun4_dmamap_unload(bus_dma_tag_t t, bus_dmamap_t map)
   1713 {
   1714 	bus_dma_segment_t *segs = map->dm_segs;
   1715 	int nsegs = map->dm_nsegs;
   1716 	int flags = map->_dm_flags;
   1717 	vaddr_t dva;
   1718 	bus_size_t len;
   1719 	int i, s, error;
   1720 
   1721 	map->dm_maxsegsz = map->_dm_maxmaxsegsz;
   1722 
   1723 	if ((flags & _BUS_DMA_DIRECTMAP) != 0) {
   1724 		/* Nothing to release */
   1725 		map->dm_mapsize = 0;
   1726 		map->dm_nsegs = 0;
   1727 		map->_dm_flags &= ~_BUS_DMA_DIRECTMAP;
   1728 		return;
   1729 	}
   1730 
   1731 	for (i = 0; i < nsegs; i++) {
   1732 		dva = segs[i].ds_addr & -PAGE_SIZE;
   1733 		len = segs[i]._ds_sgsize;
   1734 
   1735 		pmap_kremove(dva, len);
   1736 
   1737 		if ((flags & BUS_DMA_24BIT) != 0) {
   1738 			s = splhigh();
   1739 			error = extent_free(dvmamap24, dva, len, EX_NOWAIT);
   1740 			splx(s);
   1741 			if (error != 0)
   1742 				printf("warning: %ld of DVMA space lost\n", len);
   1743 		} else {
   1744 			uvm_unmap(kernel_map, dva, dva + len);
   1745 		}
   1746 	}
   1747 	pmap_update(pmap_kernel());
   1748 
   1749 	/* Mark the mappings as invalid. */
   1750 	map->dm_mapsize = 0;
   1751 	map->dm_nsegs = 0;
   1752 }
   1753 
   1754 /*
   1755  * Common function for mapping DMA-safe memory.  May be called by
   1756  * bus-specific DMA memory map functions.
   1757  */
   1758 int
   1759 sun4_dmamem_map(bus_dma_tag_t t, bus_dma_segment_t *segs, int nsegs,
   1760 		size_t size, void **kvap, int flags)
   1761 {
   1762 	struct vm_page *m;
   1763 	vaddr_t va;
   1764 	struct pglist *mlist;
   1765 	const uvm_flag_t kmflags =
   1766 	    (flags & BUS_DMA_NOWAIT) != 0 ? UVM_KMF_NOWAIT : 0;
   1767 
   1768 	if (nsegs != 1)
   1769 		panic("sun4_dmamem_map: nsegs = %d", nsegs);
   1770 
   1771 	size = round_page(size);
   1772 
   1773 	va = uvm_km_alloc(kernel_map, size, 0, UVM_KMF_VAONLY | kmflags);
   1774 	if (va == 0)
   1775 		return (ENOMEM);
   1776 
   1777 	segs[0]._ds_va = va;
   1778 	*kvap = (void *)va;
   1779 
   1780 	mlist = segs[0]._ds_mlist;
   1781 	TAILQ_FOREACH(m, mlist, pageq.queue) {
   1782 		paddr_t pa;
   1783 
   1784 		if (size == 0)
   1785 			panic("sun4_dmamem_map: size botch");
   1786 
   1787 		pa = VM_PAGE_TO_PHYS(m);
   1788 		pmap_kenter_pa(va, pa | PMAP_NC,
   1789 		    VM_PROT_READ | VM_PROT_WRITE, 0);
   1790 
   1791 		va += PAGE_SIZE;
   1792 		size -= PAGE_SIZE;
   1793 	}
   1794 	pmap_update(pmap_kernel());
   1795 
   1796 	return (0);
   1797 }
   1798 
   1799 
   1800 struct sparc_bus_dma_tag mainbus_dma_tag = {
   1801 	NULL,
   1802 	_bus_dmamap_create,
   1803 	_bus_dmamap_destroy,
   1804 	sun4_dmamap_load,
   1805 	_bus_dmamap_load_mbuf,
   1806 	_bus_dmamap_load_uio,
   1807 	sun4_dmamap_load_raw,
   1808 	sun4_dmamap_unload,
   1809 	_bus_dmamap_sync,
   1810 
   1811 	_bus_dmamem_alloc,
   1812 	_bus_dmamem_free,
   1813 	sun4_dmamem_map,
   1814 	_bus_dmamem_unmap,
   1815 	_bus_dmamem_mmap
   1816 };
   1817 
   1818 
   1819 /*
   1820  * Base bus space handlers.
   1821  */
   1822 static int	sparc_bus_map(bus_space_tag_t, bus_addr_t,
   1823 				    bus_size_t, int, vaddr_t,
   1824 				    bus_space_handle_t *);
   1825 static int	sparc_bus_unmap(bus_space_tag_t, bus_space_handle_t,
   1826 				     bus_size_t);
   1827 static int	sparc_bus_subregion(bus_space_tag_t, bus_space_handle_t,
   1828 					 bus_size_t, bus_size_t,
   1829 					 bus_space_handle_t *);
   1830 static paddr_t	sparc_bus_mmap(bus_space_tag_t, bus_addr_t, off_t,
   1831 				    int, int);
   1832 static void	*sparc_mainbus_intr_establish(bus_space_tag_t, int, int,
   1833 						   int (*)(void *),
   1834 						   void *,
   1835 						   void (*)(void));
   1836 static void     sparc_bus_barrier(bus_space_tag_t, bus_space_handle_t,
   1837 					bus_size_t, bus_size_t, int);
   1838 
   1839 int
   1840 bus_space_map(
   1841 	bus_space_tag_t	t,
   1842 	bus_addr_t	a,
   1843 	bus_size_t	s,
   1844 	int		f,
   1845 	bus_space_handle_t *hp)
   1846 {
   1847 	return (*t->sparc_bus_map)(t, a, s, f, (vaddr_t)0, hp);
   1848 }
   1849 
   1850 int
   1851 bus_space_map2(
   1852 	bus_space_tag_t	t,
   1853 	bus_addr_t	a,
   1854 	bus_size_t	s,
   1855 	int		f,
   1856 	vaddr_t		v,
   1857 	bus_space_handle_t *hp)
   1858 {
   1859 	return (*t->sparc_bus_map)(t, a, s, f, v, hp);
   1860 }
   1861 
   1862 void
   1863 bus_space_unmap(
   1864 	bus_space_tag_t t,
   1865 	bus_space_handle_t h,
   1866 	bus_size_t	s)
   1867 {
   1868 	(*t->sparc_bus_unmap)(t, h, s);
   1869 }
   1870 
   1871 int
   1872 bus_space_subregion(
   1873 	bus_space_tag_t	t,
   1874 	bus_space_handle_t h,
   1875 	bus_size_t	o,
   1876 	bus_size_t	s,
   1877 	bus_space_handle_t *hp)
   1878 {
   1879 	return (*t->sparc_bus_subregion)(t, h, o, s, hp);
   1880 }
   1881 
   1882 paddr_t
   1883 bus_space_mmap(
   1884 	bus_space_tag_t	t,
   1885 	bus_addr_t	a,
   1886 	off_t		o,
   1887 	int		p,
   1888 	int		f)
   1889 {
   1890 	return (*t->sparc_bus_mmap)(t, a, o, p, f);
   1891 }
   1892 
   1893 void *
   1894 bus_intr_establish(
   1895 	bus_space_tag_t t,
   1896 	int	p,
   1897 	int	l,
   1898 	int	(*h)(void *),
   1899 	void	*a)
   1900 {
   1901 	return (*t->sparc_intr_establish)(t, p, l, h, a, NULL);
   1902 }
   1903 
   1904 void *
   1905 bus_intr_establish2(
   1906 	bus_space_tag_t t,
   1907 	int	p,
   1908 	int	l,
   1909 	int	(*h)(void *),
   1910 	void	*a,
   1911 	void	(*v)(void))
   1912 {
   1913 	return (*t->sparc_intr_establish)(t, p, l, h, a, v);
   1914 }
   1915 
   1916 void
   1917 bus_space_barrier(
   1918 	bus_space_tag_t t,
   1919 	bus_space_handle_t h,
   1920 	bus_size_t o,
   1921 	bus_size_t s,
   1922 	int f)
   1923 {
   1924 	(*t->sparc_bus_barrier)(t, h, o, s, f);
   1925 }
   1926 
   1927 void
   1928 bus_space_write_multi_stream_2(
   1929 	bus_space_tag_t		t,
   1930 	bus_space_handle_t	h,
   1931 	bus_size_t		o,
   1932 	const uint16_t		*a,
   1933 	bus_size_t		c)
   1934 {
   1935 	while (c-- > 0)
   1936 		bus_space_write_2_real(t, h, o, *a++);
   1937 }
   1938 
   1939 void
   1940 bus_space_write_multi_stream_4(
   1941 	bus_space_tag_t		t,
   1942 	bus_space_handle_t	h,
   1943 	bus_size_t		o,
   1944 	const uint32_t		*a,
   1945 	bus_size_t		c)
   1946 {
   1947 	while (c-- > 0)
   1948 		bus_space_write_4_real(t, h, o, *a++);
   1949 }
   1950 
   1951 void
   1952 bus_space_write_multi_stream_8(
   1953 	bus_space_tag_t		t,
   1954 	bus_space_handle_t	h,
   1955 	bus_size_t		o,
   1956 	const uint64_t		*a,
   1957 	bus_size_t		c)
   1958 {
   1959 	while (c-- > 0)
   1960 		bus_space_write_8_real(t, h, o, *a++);
   1961 }
   1962 
   1963 
   1964 /*
   1965  *	void bus_space_set_multi_N(bus_space_tag_t tag,
   1966  *	    bus_space_handle_t bsh, bus_size_t offset, u_intN_t val,
   1967  *	    bus_size_t count);
   1968  *
   1969  * Write the 1, 2, 4, or 8 byte value `val' to bus space described
   1970  * by tag/handle/offset `count' times.
   1971  */
   1972 void
   1973 bus_space_set_multi_1(
   1974 	bus_space_tag_t		t,
   1975 	bus_space_handle_t	h,
   1976 	bus_size_t		o,
   1977 	const uint8_t		v,
   1978 	bus_size_t		c)
   1979 {
   1980 	while (c-- > 0)
   1981 		bus_space_write_1(t, h, o, v);
   1982 }
   1983 
   1984 void
   1985 bus_space_set_multi_2(
   1986 	bus_space_tag_t		t,
   1987 	bus_space_handle_t	h,
   1988 	bus_size_t		o,
   1989 	const uint16_t		v,
   1990 	bus_size_t		c)
   1991 {
   1992 	while (c-- > 0)
   1993 		bus_space_write_2(t, h, o, v);
   1994 }
   1995 
   1996 void
   1997 bus_space_set_multi_4(
   1998 	bus_space_tag_t		t,
   1999 	bus_space_handle_t	h,
   2000 	bus_size_t		o,
   2001 	const uint32_t		v,
   2002 	bus_size_t		c)
   2003 {
   2004 	while (c-- > 0)
   2005 		bus_space_write_4(t, h, o, v);
   2006 }
   2007 
   2008 void
   2009 bus_space_set_multi_8(
   2010 	bus_space_tag_t		t,
   2011 	bus_space_handle_t	h,
   2012 	bus_size_t		o,
   2013 	const uint64_t		v,
   2014 	bus_size_t		c)
   2015 {
   2016 	while (c-- > 0)
   2017 		bus_space_write_8(t, h, o, v);
   2018 }
   2019 
   2020 
   2021 /*
   2022  *	void bus_space_read_region_N(bus_space_tag_t tag,
   2023  *	    bus_space_handle_t bsh, bus_size_t off,
   2024  *	    u_intN_t *addr, bus_size_t count);
   2025  *
   2026  */
   2027 void
   2028 bus_space_read_region_1(
   2029 	bus_space_tag_t		t,
   2030 	bus_space_handle_t	h,
   2031 	bus_size_t		o,
   2032 	uint8_t			*a,
   2033 	bus_size_t		c)
   2034 {
   2035 	for (; c; a++, c--, o++)
   2036 		*a = bus_space_read_1(t, h, o);
   2037 }
   2038 
   2039 void
   2040 bus_space_read_region_2(
   2041 	bus_space_tag_t		t,
   2042 	bus_space_handle_t	h,
   2043 	bus_size_t		o,
   2044 	uint16_t		*a,
   2045 	bus_size_t		c)
   2046 {
   2047 	for (; c; a++, c--, o+=2)
   2048 		*a = bus_space_read_2(t, h, o);
   2049 }
   2050 
   2051 void
   2052 bus_space_read_region_4(
   2053 	bus_space_tag_t		t,
   2054 	bus_space_handle_t	h,
   2055 	bus_size_t		o,
   2056 	uint32_t		*a,
   2057 	bus_size_t		c)
   2058 {
   2059 	for (; c; a++, c--, o+=4)
   2060 		*a = bus_space_read_4(t, h, o);
   2061 }
   2062 
   2063 void
   2064 bus_space_read_region_8(
   2065 	bus_space_tag_t		t,
   2066 	bus_space_handle_t	h,
   2067 	bus_size_t		o,
   2068 	uint64_t		*a,
   2069 	bus_size_t		c)
   2070 {
   2071 	for (; c; a++, c--, o+=8)
   2072 		*a = bus_space_read_8(t, h, o);
   2073 }
   2074 
   2075 /*
   2076  *	void bus_space_write_region_N(bus_space_tag_t tag,
   2077  *	    bus_space_handle_t bsh, bus_size_t off,
   2078  *	    u_intN_t *addr, bus_size_t count);
   2079  *
   2080  */
   2081 void
   2082 bus_space_write_region_1(
   2083 	bus_space_tag_t		t,
   2084 	bus_space_handle_t	h,
   2085 	bus_size_t		o,
   2086 	const uint8_t		*a,
   2087 	bus_size_t		c)
   2088 {
   2089 	for (; c; a++, c--, o++)
   2090 		bus_space_write_1(t, h, o, *a);
   2091 }
   2092 
   2093 void
   2094 bus_space_write_region_2(
   2095 	bus_space_tag_t		t,
   2096 	bus_space_handle_t	h,
   2097 	bus_size_t		o,
   2098 	const uint16_t		*a,
   2099 	bus_size_t		c)
   2100 {
   2101 	for (; c; a++, c--, o+=2)
   2102 		bus_space_write_2(t, h, o, *a);
   2103 }
   2104 
   2105 void
   2106 bus_space_write_region_4(
   2107 	bus_space_tag_t		t,
   2108 	bus_space_handle_t	h,
   2109 	bus_size_t		o,
   2110 	const uint32_t		*a,
   2111 	bus_size_t		c)
   2112 {
   2113 	for (; c; a++, c--, o+=4)
   2114 		bus_space_write_4(t, h, o, *a);
   2115 }
   2116 
   2117 void
   2118 bus_space_write_region_8(
   2119 	bus_space_tag_t		t,
   2120 	bus_space_handle_t	h,
   2121 	bus_size_t		o,
   2122 	const uint64_t		*a,
   2123 	bus_size_t		c)
   2124 {
   2125 	for (; c; a++, c--, o+=8)
   2126 		bus_space_write_8(t, h, o, *a);
   2127 }
   2128 
   2129 
   2130 /*
   2131  *	void bus_space_set_region_N(bus_space_tag_t tag,
   2132  *	    bus_space_handle_t bsh, bus_size_t off,
   2133  *	    u_intN_t *addr, bus_size_t count);
   2134  *
   2135  */
   2136 void
   2137 bus_space_set_region_1(
   2138 	bus_space_tag_t		t,
   2139 	bus_space_handle_t	h,
   2140 	bus_size_t		o,
   2141 	const uint8_t		v,
   2142 	bus_size_t		c)
   2143 {
   2144 	for (; c; c--, o++)
   2145 		bus_space_write_1(t, h, o, v);
   2146 }
   2147 
   2148 void
   2149 bus_space_set_region_2(
   2150 	bus_space_tag_t		t,
   2151 	bus_space_handle_t	h,
   2152 	bus_size_t		o,
   2153 	const uint16_t		v,
   2154 	bus_size_t		c)
   2155 {
   2156 	for (; c; c--, o+=2)
   2157 		bus_space_write_2(t, h, o, v);
   2158 }
   2159 
   2160 void
   2161 bus_space_set_region_4(
   2162 	bus_space_tag_t		t,
   2163 	bus_space_handle_t	h,
   2164 	bus_size_t		o,
   2165 	const uint32_t		v,
   2166 	bus_size_t		c)
   2167 {
   2168 	for (; c; c--, o+=4)
   2169 		bus_space_write_4(t, h, o, v);
   2170 }
   2171 
   2172 void
   2173 bus_space_set_region_8(
   2174 	bus_space_tag_t		t,
   2175 	bus_space_handle_t	h,
   2176 	bus_size_t		o,
   2177 	const uint64_t		v,
   2178 	bus_size_t		c)
   2179 {
   2180 	for (; c; c--, o+=8)
   2181 		bus_space_write_8(t, h, o, v);
   2182 }
   2183 
   2184 
   2185 /*
   2186  *	void bus_space_copy_region_N(bus_space_tag_t tag,
   2187  *	    bus_space_handle_t bsh1, bus_size_t off1,
   2188  *	    bus_space_handle_t bsh2, bus_size_t off2,
   2189  *	    bus_size_t count);
   2190  *
   2191  * Copy `count' 1, 2, 4, or 8 byte values from bus space starting
   2192  * at tag/bsh1/off1 to bus space starting at tag/bsh2/off2.
   2193  */
   2194 void
   2195 bus_space_copy_region_1(
   2196 	bus_space_tag_t		t,
   2197 	bus_space_handle_t	h1,
   2198 	bus_size_t		o1,
   2199 	bus_space_handle_t	h2,
   2200 	bus_size_t		o2,
   2201 	bus_size_t		c)
   2202 {
   2203 	for (; c; c--, o1++, o2++)
   2204 	    bus_space_write_1(t, h1, o1, bus_space_read_1(t, h2, o2));
   2205 }
   2206 
   2207 void
   2208 bus_space_copy_region_2(
   2209 	bus_space_tag_t		t,
   2210 	bus_space_handle_t	h1,
   2211 	bus_size_t		o1,
   2212 	bus_space_handle_t	h2,
   2213 	bus_size_t		o2,
   2214 	bus_size_t		c)
   2215 {
   2216 	for (; c; c--, o1+=2, o2+=2)
   2217 	    bus_space_write_2(t, h1, o1, bus_space_read_2(t, h2, o2));
   2218 }
   2219 
   2220 void
   2221 bus_space_copy_region_4(
   2222 	bus_space_tag_t		t,
   2223 	bus_space_handle_t	h1,
   2224 	bus_size_t		o1,
   2225 	bus_space_handle_t	h2,
   2226 	bus_size_t		o2,
   2227 	bus_size_t		c)
   2228 {
   2229 	for (; c; c--, o1+=4, o2+=4)
   2230 	    bus_space_write_4(t, h1, o1, bus_space_read_4(t, h2, o2));
   2231 }
   2232 
   2233 void
   2234 bus_space_copy_region_8(
   2235 	bus_space_tag_t		t,
   2236 	bus_space_handle_t	h1,
   2237 	bus_size_t		o1,
   2238 	bus_space_handle_t	h2,
   2239 	bus_size_t		o2,
   2240 	bus_size_t		c)
   2241 {
   2242 	for (; c; c--, o1+=8, o2+=8)
   2243 	    bus_space_write_8(t, h1, o1, bus_space_read_8(t, h2, o2));
   2244 }
   2245 
   2246 /*
   2247  *	void bus_space_read_region_stream_N(bus_space_tag_t tag,
   2248  *	    bus_space_handle_t bsh, bus_size_t off,
   2249  *	    u_intN_t *addr, bus_size_t count);
   2250  *
   2251  */
   2252 void
   2253 bus_space_read_region_stream_1(
   2254 	bus_space_tag_t		t,
   2255 	bus_space_handle_t	h,
   2256 	bus_size_t		o,
   2257 	uint8_t			*a,
   2258 	bus_size_t		c)
   2259 {
   2260 	for (; c; a++, c--, o++)
   2261 		*a = bus_space_read_stream_1(t, h, o);
   2262 }
   2263 void
   2264 bus_space_read_region_stream_2(
   2265 	bus_space_tag_t		t,
   2266 	bus_space_handle_t	h,
   2267 	bus_size_t		o,
   2268 	uint16_t		*a,
   2269 	bus_size_t		c)
   2270 {
   2271 	for (; c; a++, c--, o+=2)
   2272 		*a = bus_space_read_stream_2(t, h, o);
   2273  }
   2274 void
   2275 bus_space_read_region_stream_4(
   2276 	bus_space_tag_t		t,
   2277 	bus_space_handle_t	h,
   2278 	bus_size_t		o,
   2279 	uint32_t		*a,
   2280 	bus_size_t		c)
   2281 {
   2282 	for (; c; a++, c--, o+=4)
   2283 		*a = bus_space_read_stream_4(t, h, o);
   2284 }
   2285 void
   2286 bus_space_read_region_stream_8(
   2287 	bus_space_tag_t		t,
   2288 	bus_space_handle_t	h,
   2289 	bus_size_t		o,
   2290 	uint64_t		*a,
   2291 	bus_size_t		c)
   2292 {
   2293 	for (; c; a++, c--, o+=8)
   2294 		*a = bus_space_read_stream_8(t, h, o);
   2295 }
   2296 
   2297 /*
   2298  *	void bus_space_write_region_stream_N(bus_space_tag_t tag,
   2299  *	    bus_space_handle_t bsh, bus_size_t off,
   2300  *	    u_intN_t *addr, bus_size_t count);
   2301  *
   2302  */
   2303 void
   2304 bus_space_write_region_stream_1(
   2305 	bus_space_tag_t		t,
   2306 	bus_space_handle_t	h,
   2307 	bus_size_t		o,
   2308 	const uint8_t		*a,
   2309 	bus_size_t		c)
   2310 {
   2311 	for (; c; a++, c--, o++)
   2312 		bus_space_write_stream_1(t, h, o, *a);
   2313 }
   2314 
   2315 void
   2316 bus_space_write_region_stream_2(
   2317 	bus_space_tag_t		t,
   2318 	bus_space_handle_t	h,
   2319 	bus_size_t		o,
   2320 	const uint16_t		*a,
   2321 	bus_size_t		c)
   2322 {
   2323 	for (; c; a++, c--, o+=2)
   2324 		bus_space_write_stream_2(t, h, o, *a);
   2325 }
   2326 
   2327 void
   2328 bus_space_write_region_stream_4(
   2329 	bus_space_tag_t		t,
   2330 	bus_space_handle_t	h,
   2331 	bus_size_t		o,
   2332 	const uint32_t		*a,
   2333 	bus_size_t		c)
   2334 {
   2335 	for (; c; a++, c--, o+=4)
   2336 		bus_space_write_stream_4(t, h, o, *a);
   2337 }
   2338 
   2339 void
   2340 bus_space_write_region_stream_8(
   2341 	bus_space_tag_t		t,
   2342 	bus_space_handle_t	h,
   2343 	bus_size_t		o,
   2344 	const uint64_t		*a,
   2345 	bus_size_t		c)
   2346 {
   2347 	for (; c; a++, c--, o+=8)
   2348 		bus_space_write_stream_8(t, h, o, *a);
   2349 }
   2350 
   2351 
   2352 /*
   2353  *	void bus_space_set_region_stream_N(bus_space_tag_t tag,
   2354  *	    bus_space_handle_t bsh, bus_size_t off,
   2355  *	    u_intN_t *addr, bus_size_t count);
   2356  *
   2357  */
   2358 void
   2359 bus_space_set_region_stream_1(
   2360 	bus_space_tag_t		t,
   2361 	bus_space_handle_t	h,
   2362 	bus_size_t		o,
   2363 	const uint8_t		v,
   2364 	bus_size_t		c)
   2365 {
   2366 	for (; c; c--, o++)
   2367 		bus_space_write_stream_1(t, h, o, v);
   2368 }
   2369 
   2370 void
   2371 bus_space_set_region_stream_2(
   2372 	bus_space_tag_t		t,
   2373 	bus_space_handle_t	h,
   2374 	bus_size_t		o,
   2375 	const uint16_t		v,
   2376 	bus_size_t		c)
   2377 {
   2378 	for (; c; c--, o+=2)
   2379 		bus_space_write_stream_2(t, h, o, v);
   2380 }
   2381 
   2382 void
   2383 bus_space_set_region_stream_4(
   2384 	bus_space_tag_t		t,
   2385 	bus_space_handle_t	h,
   2386 	bus_size_t		o,
   2387 	const uint32_t		v,
   2388 	bus_size_t		c)
   2389 {
   2390 	for (; c; c--, o+=4)
   2391 		bus_space_write_stream_4(t, h, o, v);
   2392 }
   2393 
   2394 void
   2395 bus_space_set_region_stream_8(
   2396 	bus_space_tag_t		t,
   2397 	bus_space_handle_t	h,
   2398 	bus_size_t		o,
   2399 	const uint64_t		v,
   2400 	bus_size_t		c)
   2401 {
   2402 	for (; c; c--, o+=8)
   2403 		bus_space_write_stream_8(t, h, o, v);
   2404 }
   2405 
   2406 /*
   2407  *	void bus_space_copy_region_stream_N(bus_space_tag_t tag,
   2408  *	    bus_space_handle_t bsh1, bus_size_t off1,
   2409  *	    bus_space_handle_t bsh2, bus_size_t off2,
   2410  *	    bus_size_t count);
   2411  *
   2412  * Copy `count' 1, 2, 4, or 8 byte values from bus space starting
   2413  * at tag/bsh1/off1 to bus space starting at tag/bsh2/off2.
   2414  */
   2415 
   2416 void
   2417 bus_space_copy_region_stream_1(
   2418 	bus_space_tag_t		t,
   2419 	bus_space_handle_t	h1,
   2420 	bus_size_t		o1,
   2421 	bus_space_handle_t	h2,
   2422 	bus_size_t		o2,
   2423 	bus_size_t		c)
   2424 {
   2425 	for (; c; c--, o1++, o2++)
   2426 	    bus_space_write_stream_1(t, h1, o1, bus_space_read_stream_1(t, h2, o2));
   2427 }
   2428 
   2429 void
   2430 bus_space_copy_region_stream_2(
   2431 	bus_space_tag_t		t,
   2432 	bus_space_handle_t	h1,
   2433 	bus_size_t		o1,
   2434 	bus_space_handle_t	h2,
   2435 	bus_size_t		o2,
   2436 	bus_size_t		c)
   2437 {
   2438 	for (; c; c--, o1+=2, o2+=2)
   2439 	    bus_space_write_stream_2(t, h1, o1, bus_space_read_stream_2(t, h2, o2));
   2440 }
   2441 
   2442 void
   2443 bus_space_copy_region_stream_4(
   2444 	bus_space_tag_t		t,
   2445 	bus_space_handle_t	h1,
   2446 	bus_size_t		o1,
   2447 	bus_space_handle_t	h2,
   2448 	bus_size_t		o2,
   2449 	bus_size_t		c)
   2450 {
   2451 	for (; c; c--, o1+=4, o2+=4)
   2452 	    bus_space_write_stream_4(t, h1, o1, bus_space_read_stream_4(t, h2, o2));
   2453 }
   2454 
   2455 void
   2456 bus_space_copy_region_stream_8(
   2457 	bus_space_tag_t		t,
   2458 	bus_space_handle_t	h1,
   2459 	bus_size_t		o1,
   2460 	bus_space_handle_t	h2,
   2461 	bus_size_t		o2,
   2462 	bus_size_t		c)
   2463 {
   2464 	for (; c; c--, o1+=8, o2+=8)
   2465 	    bus_space_write_stream_8(t, h1, o1, bus_space_read_8(t, h2, o2));
   2466 }
   2467 
   2468 void
   2469 bus_space_write_1(
   2470 	bus_space_tag_t		t,
   2471 	bus_space_handle_t	h,
   2472 	bus_size_t		o,
   2473 	uint8_t			v)
   2474 {
   2475 	(*t->sparc_write_1)(t, h, o, v);
   2476 }
   2477 
   2478 void
   2479 bus_space_write_2(
   2480 	bus_space_tag_t		t,
   2481 	bus_space_handle_t	h,
   2482 	bus_size_t		o,
   2483 	uint16_t		v)
   2484 {
   2485 	(*t->sparc_write_2)(t, h, o, v);
   2486 }
   2487 
   2488 void
   2489 bus_space_write_4(
   2490 	bus_space_tag_t		t,
   2491 	bus_space_handle_t	h,
   2492 	bus_size_t		o,
   2493 	uint32_t		v)
   2494 {
   2495 	(*t->sparc_write_4)(t, h, o, v);
   2496 }
   2497 
   2498 void
   2499 bus_space_write_8(
   2500 	bus_space_tag_t		t,
   2501 	bus_space_handle_t	h,
   2502 	bus_size_t		o,
   2503 	uint64_t		v)
   2504 {
   2505 	(*t->sparc_write_8)(t, h, o, v);
   2506 }
   2507 
   2508 #if __SLIM_SPARC_BUS_SPACE
   2509 
   2510 void
   2511 bus_space_write_1(
   2512 	bus_space_tag_t		t,
   2513 	bus_space_handle_t	h,
   2514 	bus_size_t		o,
   2515 	uint8_t			v)
   2516 {
   2517 	__insn_barrier();
   2518 	bus_space_write_1_real(t, h, o, v);
   2519 }
   2520 
   2521 void
   2522 bus_space_write_2(
   2523 	bus_space_tag_t		t,
   2524 	bus_space_handle_t	h,
   2525 	bus_size_t		o,
   2526 	uint16_t		v)
   2527 {
   2528 	__insn_barrier();
   2529 	bus_space_write_2_real(t, h, o, v);
   2530 }
   2531 
   2532 void
   2533 bus_space_write_4(
   2534 	bus_space_tag_t		t,
   2535 	bus_space_handle_t	h,
   2536 	bus_size_t		o,
   2537 	uint32_t		v)
   2538 {
   2539 	__insn_barrier();
   2540 	bus_space_write_4_real(t, h, o, v);
   2541 }
   2542 
   2543 void
   2544 bus_space_write_8(
   2545 	bus_space_tag_t		t,
   2546 	bus_space_handle_t	h,
   2547 	bus_size_t		o,
   2548 	uint64_t		v)
   2549 {
   2550 	__insn_barrier();
   2551 	bus_space_write_8_real(t, h, o, v);
   2552 }
   2553 
   2554 #endif /* __SLIM_SPARC_BUS_SPACE */
   2555 
   2556 uint8_t
   2557 bus_space_read_1(
   2558 	bus_space_tag_t		t,
   2559 	bus_space_handle_t	h,
   2560 	bus_size_t		o)
   2561 {
   2562 	return (*t->sparc_read_1)(t, h, o);
   2563 }
   2564 
   2565 uint16_t
   2566 bus_space_read_2(
   2567 	bus_space_tag_t		t,
   2568 	bus_space_handle_t	h,
   2569 	bus_size_t		o)
   2570 {
   2571 	return (*t->sparc_read_2)(t, h, o);
   2572 }
   2573 
   2574 uint32_t
   2575 bus_space_read_4(
   2576 	bus_space_tag_t		t,
   2577 	bus_space_handle_t	h,
   2578 	bus_size_t		o)
   2579 {
   2580 	return (*t->sparc_read_4)(t, h, o);
   2581 }
   2582 
   2583 uint64_t
   2584 bus_space_read_8(
   2585 	bus_space_tag_t		t,
   2586 	bus_space_handle_t	h,
   2587 	bus_size_t		o)
   2588 {
   2589 	return (*t->sparc_read_8)(t, h, o);
   2590 }
   2591 
   2592 #if __SLIM_SPARC_BUS_SPACE
   2593 uint8_t
   2594 bus_space_read_1(
   2595 	bus_space_tag_t		t,
   2596 	bus_space_handle_t	h,
   2597 	bus_size_t		o)
   2598 {
   2599 	__insn_barrier();
   2600 	return bus_space_read_1_real(t, h, o);
   2601 }
   2602 
   2603 uint16_t
   2604 bus_space_read_2(
   2605 	bus_space_tag_t		t,
   2606 	bus_space_handle_t	h,
   2607 	bus_size_t		o)
   2608 {
   2609 	__insn_barrier();
   2610 	return bus_space_read_2_real(t, h, o);
   2611 }
   2612 
   2613 uint32_t
   2614 bus_space_read_4(
   2615 	bus_space_tag_t		t,
   2616 	bus_space_handle_t	h,
   2617 	bus_size_t		o)
   2618 {
   2619 	__insn_barrier();
   2620 	return bus_space_read_4_real(t, h, o);
   2621 }
   2622 
   2623 uint64_t
   2624 bus_space_read_8(
   2625 	bus_space_tag_t		t,
   2626 	bus_space_handle_t	h,
   2627 	bus_size_t		o)
   2628 {
   2629 	__insn_barrier();
   2630 	return bus_space_read_8_real(t, h, o);
   2631 }
   2632 
   2633 #endif /* __SLIM_SPARC_BUS_SPACE */
   2634 
   2635 void
   2636 bus_space_read_multi_1(
   2637 	bus_space_tag_t		t,
   2638 	bus_space_handle_t	h,
   2639 	bus_size_t		o,
   2640 	uint8_t			*a,
   2641 	bus_size_t		c)
   2642 {
   2643 	while (c-- > 0)
   2644 		*a++ = bus_space_read_1(t, h, o);
   2645 }
   2646 
   2647 void
   2648 bus_space_read_multi_2(
   2649 	bus_space_tag_t		t,
   2650 	bus_space_handle_t	h,
   2651 	bus_size_t		o,
   2652 	uint16_t		*a,
   2653 	bus_size_t		c)
   2654 {
   2655 	while (c-- > 0)
   2656 		*a++ = bus_space_read_2(t, h, o);
   2657 }
   2658 
   2659 void
   2660 bus_space_read_multi_4(
   2661 	bus_space_tag_t		t,
   2662 	bus_space_handle_t	h,
   2663 	bus_size_t		o,
   2664 	uint32_t		*a,
   2665 	bus_size_t		c)
   2666 {
   2667 	while (c-- > 0)
   2668 		*a++ = bus_space_read_4(t, h, o);
   2669 }
   2670 
   2671 void
   2672 bus_space_read_multi_8(
   2673 	bus_space_tag_t		t,
   2674 	bus_space_handle_t	h,
   2675 	bus_size_t		o,
   2676 	uint64_t		*a,
   2677 	bus_size_t		c)
   2678 {
   2679 	while (c-- > 0)
   2680 		*a++ = bus_space_read_8(t, h, o);
   2681 }
   2682 
   2683 /*
   2684  *	void bus_space_read_multi_N(bus_space_tag_t tag,
   2685  *	    bus_space_handle_t bsh, bus_size_t offset,
   2686  *	    u_intN_t *addr, bus_size_t count);
   2687  *
   2688  * Read `count' 1, 2, 4, or 8 byte quantities from bus space
   2689  * described by tag/handle/offset and copy into buffer provided.
   2690  */
   2691 void
   2692 bus_space_read_multi_stream_2(
   2693 	bus_space_tag_t		t,
   2694 	bus_space_handle_t	h,
   2695 	bus_size_t		o,
   2696 	uint16_t		*a,
   2697 	bus_size_t		c)
   2698 {
   2699 	while (c-- > 0)
   2700 		*a++ = bus_space_read_2_real(t, h, o);
   2701 }
   2702 
   2703 void
   2704 bus_space_read_multi_stream_4(
   2705 	bus_space_tag_t		t,
   2706 	bus_space_handle_t	h,
   2707 	bus_size_t		o,
   2708 	uint32_t		*a,
   2709 	bus_size_t		c)
   2710 {
   2711 	while (c-- > 0)
   2712 		*a++ = bus_space_read_4_real(t, h, o);
   2713 }
   2714 
   2715 void
   2716 bus_space_read_multi_stream_8(
   2717 	bus_space_tag_t		t,
   2718 	bus_space_handle_t	h,
   2719 	bus_size_t		o,
   2720 	uint64_t		*a,
   2721 	bus_size_t		c)
   2722 {
   2723 	while (c-- > 0)
   2724 		*a++ = bus_space_read_8_real(t, h, o);
   2725 }
   2726 
   2727 /*
   2728  *	void bus_space_write_multi_N(bus_space_tag_t tag,
   2729  *	    bus_space_handle_t bsh, bus_size_t offset,
   2730  *	    const u_intN_t *addr, bus_size_t count);
   2731  *
   2732  * Write `count' 1, 2, 4, or 8 byte quantities from the buffer
   2733  * provided to bus space described by tag/handle/offset.
   2734  */
   2735 void
   2736 bus_space_write_multi_1(
   2737 	bus_space_tag_t		t,
   2738 	bus_space_handle_t	h,
   2739 	bus_size_t		o,
   2740 	const uint8_t		*a,
   2741 	bus_size_t		c)
   2742 {
   2743 	while (c-- > 0)
   2744 		bus_space_write_1(t, h, o, *a++);
   2745 }
   2746 
   2747 void
   2748 bus_space_write_multi_2(
   2749 	bus_space_tag_t		t,
   2750 	bus_space_handle_t	h,
   2751 	bus_size_t		o,
   2752 	const uint16_t		*a,
   2753 	bus_size_t		c)
   2754 {
   2755 	while (c-- > 0)
   2756 		bus_space_write_2(t, h, o, *a++);
   2757 }
   2758 
   2759 void
   2760 bus_space_write_multi_4(
   2761 	bus_space_tag_t		t,
   2762 	bus_space_handle_t	h,
   2763 	bus_size_t		o,
   2764 	const uint32_t		*a,
   2765 	bus_size_t		c)
   2766 {
   2767 	while (c-- > 0)
   2768 		bus_space_write_4(t, h, o, *a++);
   2769 }
   2770 
   2771 void
   2772 bus_space_write_multi_8(
   2773 	bus_space_tag_t		t,
   2774 	bus_space_handle_t	h,
   2775 	bus_size_t		o,
   2776 	const uint64_t		*a,
   2777 	bus_size_t		c)
   2778 {
   2779 	while (c-- > 0)
   2780 		bus_space_write_8(t, h, o, *a++);
   2781 }
   2782 
   2783 /*
   2784  * Allocate a new bus tag and have it inherit the methods of the
   2785  * given parent.
   2786  */
   2787 bus_space_tag_t
   2788 bus_space_tag_alloc(bus_space_tag_t parent, void *cookie)
   2789 {
   2790 	struct sparc_bus_space_tag *sbt;
   2791 
   2792 	sbt = malloc(sizeof(struct sparc_bus_space_tag),
   2793 		     M_DEVBUF, M_NOWAIT|M_ZERO);
   2794 	if (sbt == NULL)
   2795 		return (NULL);
   2796 
   2797 	if (parent) {
   2798 		memcpy(sbt, parent, sizeof(*sbt));
   2799 		sbt->parent = parent;
   2800 		sbt->ranges = NULL;
   2801 		sbt->nranges = 0;
   2802 	}
   2803 
   2804 	sbt->cookie = cookie;
   2805 	return (sbt);
   2806 }
   2807 
   2808 /*
   2809  * Generic routine to translate an address using OpenPROM `ranges'.
   2810  */
   2811 int
   2812 bus_space_translate_address_generic(struct openprom_range *ranges, int nranges,
   2813     bus_addr_t *bap)
   2814 {
   2815 	int i, space = BUS_ADDR_IOSPACE(*bap);
   2816 
   2817 	for (i = 0; i < nranges; i++) {
   2818 		struct openprom_range *rp = &ranges[i];
   2819 
   2820 		if (rp->or_child_space != space)
   2821 			continue;
   2822 
   2823 		/* We've found the connection to the parent bus. */
   2824 		*bap = BUS_ADDR(rp->or_parent_space,
   2825 		    rp->or_parent_base + BUS_ADDR_PADDR(*bap));
   2826 		return (0);
   2827 	}
   2828 
   2829 	return (EINVAL);
   2830 }
   2831 
   2832 static int
   2833 sparc_bus_map_iodev(bus_space_tag_t t, bus_addr_t ba, bus_size_t size, int flags,
   2834 	      vaddr_t va, bus_space_handle_t *hp)
   2835 {
   2836 	vaddr_t v;
   2837 	paddr_t pa;
   2838 	unsigned int pmtype;
   2839 	bus_space_tag_t pt;
   2840 static	vaddr_t iobase;
   2841 
   2842 	/*
   2843 	 * This base class bus map function knows about address range
   2844 	 * translation so bus drivers that need no other special
   2845 	 * handling can just keep this method in their tags.
   2846 	 *
   2847 	 * We expect to resolve range translations iteratively, but allow
   2848 	 * for recursion just in case.
   2849 	 */
   2850 	while ((pt = t->parent) != NULL) {
   2851 		if (t->ranges != NULL) {
   2852 			int error;
   2853 
   2854 			if ((error = bus_space_translate_address_generic(
   2855 					t->ranges, t->nranges, &ba)) != 0)
   2856 				return (error);
   2857 		}
   2858 		if (pt->sparc_bus_map != sparc_bus_map)
   2859 			return (bus_space_map2(pt, ba, size, flags, va, hp));
   2860 		t = pt;
   2861 	}
   2862 
   2863 	if (iobase == 0)
   2864 		iobase = IODEV_BASE;
   2865 
   2866 	size = round_page(size);
   2867 	if (size == 0) {
   2868 		printf("sparc_bus_map: zero size\n");
   2869 		return (EINVAL);
   2870 	}
   2871 
   2872 	if (va)
   2873 		v = trunc_page(va);
   2874 	else {
   2875 		v = iobase;
   2876 		iobase += size;
   2877 		if (iobase > IODEV_END)	/* unlikely */
   2878 			panic("sparc_bus_map: iobase=0x%lx", iobase);
   2879 	}
   2880 
   2881 	pmtype = PMAP_IOENC(BUS_ADDR_IOSPACE(ba));
   2882 	pa = BUS_ADDR_PADDR(ba);
   2883 
   2884 	/* note: preserve page offset */
   2885 	*hp = (bus_space_handle_t)(v | ((u_long)pa & PGOFSET));
   2886 
   2887 	pa = trunc_page(pa);
   2888 	do {
   2889 		pmap_kenter_pa(v, pa | pmtype | PMAP_NC,
   2890 		    VM_PROT_READ | VM_PROT_WRITE, 0);
   2891 		v += PAGE_SIZE;
   2892 		pa += PAGE_SIZE;
   2893 	} while ((size -= PAGE_SIZE) > 0);
   2894 
   2895 	pmap_update(pmap_kernel());
   2896 	return (0);
   2897 }
   2898 
   2899 static int
   2900 sparc_bus_map_large(bus_space_tag_t t, bus_addr_t ba,
   2901 		    bus_size_t size, int flags, bus_space_handle_t *hp)
   2902 {
   2903 	vaddr_t v = 0;
   2904 
   2905 	if (uvm_map(kernel_map, &v, size, NULL, 0, PAGE_SIZE,
   2906 	    UVM_MAPFLAG(UVM_PROT_RW, UVM_PROT_RW, UVM_INH_SHARE, UVM_ADV_NORMAL,
   2907 			0)) == 0) {
   2908 		return sparc_bus_map_iodev(t, ba, size, flags, v, hp);
   2909 	}
   2910 	return -1;
   2911 }
   2912 
   2913 int
   2914 sparc_bus_map(bus_space_tag_t t, bus_addr_t ba,
   2915 		    bus_size_t size, int flags, vaddr_t va,
   2916 		    bus_space_handle_t *hp)
   2917 {
   2918 
   2919 	if (flags & BUS_SPACE_MAP_LARGE) {
   2920 		return sparc_bus_map_large(t, ba, size, flags, hp);
   2921 	} else
   2922 		return sparc_bus_map_iodev(t, ba, size, flags, va, hp);
   2923 
   2924 }
   2925 
   2926 int
   2927 sparc_bus_unmap(bus_space_tag_t t, bus_space_handle_t bh, bus_size_t size)
   2928 {
   2929 	vaddr_t va = trunc_page((vaddr_t)bh);
   2930 
   2931 	/*
   2932 	 * XXX
   2933 	 * mappings with BUS_SPACE_MAP_LARGE need additional care here
   2934 	 * we can just check if the VA is in the IODEV range
   2935 	 */
   2936 
   2937 	pmap_kremove(va, round_page(size));
   2938 	pmap_update(pmap_kernel());
   2939 	return (0);
   2940 }
   2941 
   2942 int
   2943 sparc_bus_subregion(bus_space_tag_t tag, bus_space_handle_t handle,
   2944 		    bus_size_t offset, bus_size_t size,
   2945 		    bus_space_handle_t *nhandlep)
   2946 {
   2947 
   2948 	*nhandlep = handle + offset;
   2949 	return (0);
   2950 }
   2951 
   2952 paddr_t
   2953 sparc_bus_mmap(bus_space_tag_t t, bus_addr_t ba, off_t off,
   2954 	       int prot, int flags)
   2955 {
   2956 	u_int pmtype;
   2957 	paddr_t pa;
   2958 	bus_space_tag_t pt;
   2959 
   2960 	/*
   2961 	 * Base class bus mmap function; see also sparc_bus_map
   2962 	 */
   2963 	while ((pt = t->parent) != NULL) {
   2964 		if (t->ranges != NULL) {
   2965 			int error;
   2966 
   2967 			if ((error = bus_space_translate_address_generic(
   2968 					t->ranges, t->nranges, &ba)) != 0)
   2969 				return (-1);
   2970 		}
   2971 		if (pt->sparc_bus_mmap != sparc_bus_mmap)
   2972 			return (bus_space_mmap(pt, ba, off, prot, flags));
   2973 		t = pt;
   2974 	}
   2975 
   2976 	pmtype = PMAP_IOENC(BUS_ADDR_IOSPACE(ba));
   2977 	pa = trunc_page(BUS_ADDR_PADDR(ba) + off);
   2978 
   2979 	return (paddr_t)(pa | pmtype | PMAP_NC);
   2980 }
   2981 
   2982 /*
   2983  * Establish a temporary bus mapping for device probing.
   2984  */
   2985 int
   2986 bus_space_probe(bus_space_tag_t tag, bus_addr_t paddr, bus_size_t size,
   2987 		size_t offset, int flags,
   2988 		int (*callback)(void *, void *), void *arg)
   2989 {
   2990 	bus_space_handle_t bh;
   2991 	void *tmp;
   2992 	int result;
   2993 
   2994 	if (bus_space_map2(tag, paddr, size, flags, TMPMAP_VA, &bh) != 0)
   2995 		return (0);
   2996 
   2997 	tmp = (void *)bh;
   2998 	result = (probeget((char *)tmp + offset, size) != -1);
   2999 	if (result && callback != NULL)
   3000 		result = (*callback)(tmp, arg);
   3001 	bus_space_unmap(tag, bh, size);
   3002 	return (result);
   3003 }
   3004 
   3005 
   3006 void *
   3007 sparc_mainbus_intr_establish(bus_space_tag_t t, int pil, int level,
   3008 			     int (*handler)(void *), void *arg,
   3009 			     void (*fastvec)(void))
   3010 {
   3011 	struct intrhand *ih;
   3012 
   3013 	ih = (struct intrhand *)
   3014 		malloc(sizeof(struct intrhand), M_DEVBUF, M_NOWAIT);
   3015 	if (ih == NULL)
   3016 		return (NULL);
   3017 
   3018 	ih->ih_fun = handler;
   3019 	ih->ih_arg = arg;
   3020 	intr_establish(pil, level, ih, fastvec, false);
   3021 	return (ih);
   3022 }
   3023 
   3024 void sparc_bus_barrier (bus_space_tag_t t, bus_space_handle_t h,
   3025 			bus_size_t offset, bus_size_t size, int flags)
   3026 {
   3027 
   3028 	/* No default barrier action defined */
   3029 	return;
   3030 }
   3031 
   3032 static uint8_t
   3033 sparc_bus_space_read_1(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o)
   3034 {
   3035 
   3036 	return bus_space_read_1_real(t, h, o);
   3037 }
   3038 
   3039 static uint16_t
   3040 sparc_bus_space_read_2(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o)
   3041 {
   3042 
   3043 	return bus_space_read_2_real(t, h, o);
   3044 }
   3045 
   3046 static uint32_t
   3047 sparc_bus_space_read_4(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o)
   3048 {
   3049 
   3050 	return bus_space_read_4_real(t, h, o);
   3051 }
   3052 
   3053 static uint64_t
   3054 sparc_bus_space_read_8(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o)
   3055 {
   3056 
   3057 	return bus_space_read_8_real(t, h, o);
   3058 }
   3059 
   3060 static void
   3061 sparc_bus_space_write_1(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o,
   3062 			uint8_t v)
   3063 {
   3064 
   3065 	bus_space_write_1_real(t, h, o, v);
   3066 }
   3067 
   3068 static void
   3069 sparc_bus_space_write_2(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o,
   3070 			uint16_t v)
   3071 {
   3072 
   3073 	bus_space_write_2_real(t, h, o, v);
   3074 }
   3075 
   3076 static void
   3077 sparc_bus_space_write_4(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o,
   3078 			uint32_t v)
   3079 {
   3080 
   3081 	bus_space_write_4_real(t, h, o, v);
   3082 }
   3083 
   3084 static void
   3085 sparc_bus_space_write_8(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o,
   3086 			uint64_t v)
   3087 {
   3088 
   3089 	bus_space_write_8_real(t, h, o, v);
   3090 }
   3091 
   3092 struct sparc_bus_space_tag mainbus_space_tag = {
   3093 	NULL,				/* cookie */
   3094 	NULL,				/* parent bus tag */
   3095 	NULL,				/* ranges */
   3096 	0,				/* nranges */
   3097 	sparc_bus_map,			/* bus_space_map */
   3098 	sparc_bus_unmap,		/* bus_space_unmap */
   3099 	sparc_bus_subregion,		/* bus_space_subregion */
   3100 	sparc_bus_barrier,		/* bus_space_barrier */
   3101 	sparc_bus_mmap,			/* bus_space_mmap */
   3102 	sparc_mainbus_intr_establish,	/* bus_intr_establish */
   3103 
   3104 	sparc_bus_space_read_1,		/* bus_space_read_1 */
   3105 	sparc_bus_space_read_2,		/* bus_space_read_2 */
   3106 	sparc_bus_space_read_4,		/* bus_space_read_4 */
   3107 	sparc_bus_space_read_8,		/* bus_space_read_8 */
   3108 	sparc_bus_space_write_1,	/* bus_space_write_1 */
   3109 	sparc_bus_space_write_2,	/* bus_space_write_2 */
   3110 	sparc_bus_space_write_4,	/* bus_space_write_4 */
   3111 	sparc_bus_space_write_8		/* bus_space_write_8 */
   3112 };
   3113 
   3114 int
   3115 mm_md_physacc(paddr_t pa, vm_prot_t prot)
   3116 {
   3117 
   3118 	return pmap_pa_exists(pa) ? 0 : EFAULT;
   3119 }
   3120 
   3121 int
   3122 mm_md_kernacc(void *ptr, vm_prot_t prot, bool *handled)
   3123 {
   3124 	extern vaddr_t prom_vstart;
   3125 	extern vaddr_t prom_vend;
   3126 	const vaddr_t v = (vaddr_t)ptr;
   3127 
   3128 	*handled = (v >= MSGBUF_VA && v < MSGBUF_VA + PAGE_SIZE) ||
   3129 	    (v >= prom_vstart && v < prom_vend && (prot & VM_PROT_WRITE) == 0);
   3130 	return 0;
   3131 }
   3132 
   3133 int
   3134 mm_md_readwrite(dev_t dev, struct uio *uio)
   3135 {
   3136 
   3137 	switch (minor(dev)) {
   3138 #if defined(SUN4)
   3139 	case DEV_EEPROM:
   3140 		if (cputyp == CPU_SUN4)
   3141 			return eeprom_uio(uio);
   3142 		else
   3143 #endif
   3144 		return ENXIO;
   3145 	default:
   3146 		return ENXIO;
   3147 	}
   3148 }
   3149