524 lines
14 KiB
C
524 lines
14 KiB
C
/* $NetBSD: shark_machdep.c,v 1.3 1998/05/01 21:18:41 cgd Exp $ */
|
|
|
|
/*
|
|
* Copyright 1997
|
|
* Digital Equipment Corporation. All rights reserved.
|
|
*
|
|
* This software is furnished under license and may be used and
|
|
* copied only in accordance with the following terms and conditions.
|
|
* Subject to these conditions, you may download, copy, install,
|
|
* use, modify and distribute this software in source and/or binary
|
|
* form. No title or ownership is transferred hereby.
|
|
*
|
|
* 1) Any source code used, modified or distributed must reproduce
|
|
* and retain this copyright notice and list of conditions as
|
|
* they appear in the source file.
|
|
*
|
|
* 2) No right is granted to use any trade name, trademark, or logo of
|
|
* Digital Equipment Corporation. Neither the "Digital Equipment
|
|
* Corporation" name nor any trademark or logo of Digital Equipment
|
|
* Corporation may be used to endorse or promote products derived
|
|
* from this software without the prior written permission of
|
|
* Digital Equipment Corporation.
|
|
*
|
|
* 3) This software is provided "AS-IS" and any express or implied
|
|
* warranties, including but not limited to, any implied warranties
|
|
* of merchantability, fitness for a particular purpose, or
|
|
* non-infringement are disclaimed. In no event shall DIGITAL be
|
|
* liable for any damages whatsoever, and in particular, DIGITAL
|
|
* shall not be liable for special, indirect, consequential, or
|
|
* incidental damages or damages for lost profits, loss of
|
|
* revenue or loss of use, whether such damages arise in contract,
|
|
* negligence, tort, under statute, in equity, at law or otherwise,
|
|
* even if advised of the possibility of such damage.
|
|
*/
|
|
|
|
/*
|
|
* Kernel setup for the SHARK Configuration
|
|
*/
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/reboot.h>
|
|
#include <sys/callout.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/user.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/mbuf.h>
|
|
#include <sys/msgbuf.h>
|
|
#include <sys/buf.h>
|
|
#include <sys/map.h>
|
|
#include <sys/exec.h>
|
|
#include <sys/mount.h>
|
|
#include <sys/vnode.h>
|
|
#include <sys/device.h>
|
|
#include <vm/vm.h>
|
|
#include <sys/sysctl.h>
|
|
#include <sys/syscallargs.h>
|
|
|
|
#ifdef SYSVMSG
|
|
#include <sys/msg.h>
|
|
#endif
|
|
#ifdef SYSVSEM
|
|
#include <sys/sem.h>
|
|
#endif
|
|
#ifdef SYSVSHM
|
|
#include <sys/shm.h>
|
|
#endif
|
|
|
|
#include <dev/cons.h>
|
|
|
|
#include <machine/db_machdep.h>
|
|
#include <ddb/db_sym.h>
|
|
#include <ddb/db_extern.h>
|
|
|
|
#include <vm/vm_kern.h>
|
|
|
|
#include <machine/signal.h>
|
|
#include <machine/frame.h>
|
|
#include <machine/bootconfig.h>
|
|
#include <machine/cpu.h>
|
|
#include <machine/irqhandler.h>
|
|
#include <machine/pio.h>
|
|
#include <machine/pte.h>
|
|
#include <machine/undefined.h>
|
|
#include <machine/rtc.h>
|
|
|
|
#include "ipkdb.h"
|
|
#include "md.h"
|
|
|
|
#include <dev/ofw/openfirm.h>
|
|
#include <machine/ofw.h>
|
|
#include <arm32/isa/isa_machdep.h>
|
|
#include <arm32/shark/sequoia.h>
|
|
|
|
/*
|
|
* Imported types
|
|
*/
|
|
typedef struct {
|
|
vm_offset_t physical;
|
|
vm_offset_t virtual;
|
|
} pv_addr_t;
|
|
|
|
|
|
/*
|
|
* Imported variables
|
|
*/
|
|
extern pv_addr_t irqstack;
|
|
extern pv_addr_t undstack;
|
|
extern pv_addr_t abtstack;
|
|
extern pv_addr_t kernelstack;
|
|
extern u_int data_abort_handler_address;
|
|
extern u_int prefetch_abort_handler_address;
|
|
extern u_int undefined_handler_address;
|
|
#ifdef PMAP_DEBUG
|
|
extern int pmap_debug_level;
|
|
#endif
|
|
extern int bufpages;
|
|
|
|
/*
|
|
* Imported routines
|
|
*/
|
|
extern void data_abort_handler __P((trapframe_t *frame));
|
|
extern void prefetch_abort_handler __P((trapframe_t *frame));
|
|
extern void undefinedinstruction_bounce __P((trapframe_t *frame));
|
|
#ifdef PMAP_DEBUG
|
|
extern void pmap_debug __P((int level));
|
|
#endif
|
|
#ifdef DDB
|
|
extern void db_machine_init __P((void));
|
|
#endif
|
|
extern u_long strtoul __P((const char *s, char **ptr, int base));
|
|
int ofbus_match __P((struct device *, struct cfdata *, void *));
|
|
void ofbus_attach __P((struct device *, struct device *, void *));
|
|
|
|
|
|
/*
|
|
* Exported variables
|
|
*/
|
|
BootConfig bootconfig;
|
|
char *boot_path;
|
|
char *boot_args;
|
|
int debug_flags;
|
|
int max_processes;
|
|
int cpu_cache;
|
|
#if NMD > 0
|
|
u_int memory_disc_size;
|
|
#endif
|
|
|
|
vm_offset_t cache_clean_vms[2] = {0, 0}; /* vms = plural of vm, not VMS! :-) */
|
|
|
|
int ofw_handleticks = 0; /* set to TRUE by cpu_initclocks */
|
|
|
|
/*
|
|
* Address to call from cpu_reset() to reset the machine.
|
|
* This is machine architecture dependant as it varies depending
|
|
* on where the ROM appears when you turn the MMU off.
|
|
*
|
|
* XXX not actually _used_ on shark!
|
|
*/
|
|
|
|
u_int cpu_reset_address = 0;
|
|
|
|
struct cfattach ofbus_root_ca = {
|
|
sizeof(struct device), ofbus_match, ofbus_attach
|
|
};
|
|
|
|
|
|
/*
|
|
* Exported routines
|
|
*/
|
|
/* Move to header file? */
|
|
extern void boot __P((int, char *));
|
|
extern vm_offset_t initarm __P((ofw_handle_t));
|
|
extern void consinit __P((void));
|
|
extern void process_kernel_args __P((void));
|
|
extern void ofrootfound __P((void));
|
|
|
|
|
|
/**************************************************************/
|
|
|
|
|
|
/*
|
|
* void boot(int howto, char *bootstr)
|
|
*
|
|
* Reboots the system, in evsent of:
|
|
* - reboot system call
|
|
* - panic
|
|
*/
|
|
|
|
void
|
|
cpu_reboot(howto, bootstr)
|
|
int howto;
|
|
char *bootstr;
|
|
{
|
|
/* Just call OFW common routine. */
|
|
ofw_boot(howto, bootstr);
|
|
|
|
OF_boot("not reached -- stupid compiler");
|
|
}
|
|
|
|
/*
|
|
* vm_offset_t initarm(ofw_handle_t handle)
|
|
*
|
|
* Initial entry point on startup for a GENERIC OFW
|
|
* system. Called with MMU on, running in the OFW
|
|
* client environment.
|
|
*
|
|
* Major tasks are:
|
|
* - read the bootargs out of OFW;
|
|
* - take over memory management from OFW;
|
|
* - set-up the stacks
|
|
* - set-up the exception handlers
|
|
*
|
|
* Return the new stackptr (va) for the SVC frame.
|
|
*
|
|
*/
|
|
vm_offset_t
|
|
initarm(ofw_handle)
|
|
ofw_handle_t ofw_handle;
|
|
{
|
|
vm_offset_t pclean, clean0, clean1;
|
|
vm_offset_t isa_io_physaddr, isa_mem_physaddr;
|
|
vm_offset_t isa_io_virtaddr, isa_mem_virtaddr;
|
|
vm_offset_t isadmaphysbufs;
|
|
fiqhandler_t fiqhandler;
|
|
extern void shark_fiq __P((void));
|
|
extern void shark_fiq_end __P((void));
|
|
|
|
/* Don't want to get hit with interrupts 'til we're ready. */
|
|
(void)disable_interrupts(I32_bit | F32_bit);
|
|
|
|
set_cpufuncs();
|
|
|
|
/* XXX - set these somewhere else? -JJK */
|
|
max_processes = 64;
|
|
debug_flags = 0;
|
|
boothowto = 0;
|
|
cpu_cache = 0x3; /* IC_ENABLE | DC_ENABLE | WBUF_ENABLE */
|
|
|
|
/* Init the OFW interface. */
|
|
/* MUST do this before invoking any OFW client services! */
|
|
ofw_init(ofw_handle);
|
|
|
|
/* Configure ISA stuff: must be done before consinit */
|
|
ofw_configisa(&isa_io_physaddr, &isa_mem_physaddr);
|
|
|
|
/* Map-in ISA I/O and memory space. */
|
|
/* XXX - this should be done in the isa-bus attach routine! -JJK */
|
|
isa_mem_virtaddr = ofw_map(isa_mem_physaddr, NBPD, 0);
|
|
isa_io_virtaddr = ofw_map(isa_io_physaddr, NBPD, 0);
|
|
|
|
/* Set-up the ISA system: must be done before consinit */
|
|
isa_init(isa_io_virtaddr, isa_mem_virtaddr);
|
|
|
|
/* Initialize the console (which will call into OFW). */
|
|
/* This will allow us to see panic messages and other printf output. */
|
|
consinit();
|
|
|
|
/* Get boot info and process it. */
|
|
ofw_getbootinfo(&boot_path, &boot_args);
|
|
process_kernel_args();
|
|
|
|
ofw_configisadma(&isadmaphysbufs);
|
|
isaphysmem = ofw_map(isadmaphysbufs,
|
|
(DMA_BOUNCE * NBPG + DMA_LARGE_BUFFER_SIZE), 0);
|
|
|
|
/* allocate a cache clean space */
|
|
if ((pclean = ofw_getcleaninfo()) != -1) {
|
|
clean0 = ofw_map(pclean, NBPD, PT_B | PT_C);
|
|
/* ...and another one: see the comment in the cache flush code =
|
|
arm32/arm32/cpufunc_asm.S */
|
|
clean1 = ofw_map(pclean, NBPD, PT_B | PT_C);
|
|
/* don't set cache_clean_vm until after it is mapped */
|
|
cache_clean_vms[0] = clean0;
|
|
cache_clean_vms[1] = clean1;
|
|
}
|
|
|
|
/* Configure memory. */
|
|
ofw_configmem();
|
|
|
|
/* Set-up stacks. */
|
|
{
|
|
/* The kernel stack for SVC mode will be updated on return from this routine. */
|
|
set_stackptr(PSR_IRQ32_MODE, irqstack.virtual + NBPG);
|
|
set_stackptr(PSR_UND32_MODE, undstack.virtual + NBPG);
|
|
set_stackptr(PSR_ABT32_MODE, abtstack.virtual + NBPG);
|
|
}
|
|
|
|
/* Set-up exception handlers. */
|
|
{
|
|
/* Take control of selected vectors from OFW. */
|
|
/* We take: undefined, swi, pre-fetch abort, data abort, addrexc,
|
|
irq, fiq
|
|
OFW retains: reset
|
|
*/
|
|
{
|
|
int our_vecnums[] = {1, 2, 3, 4, 5, 6, 7};
|
|
unsigned int *vectors = (unsigned int *)0;
|
|
extern unsigned int page0[];
|
|
int i;
|
|
|
|
for (i = 0; i < (sizeof(our_vecnums) / sizeof(int)); i++) {
|
|
int vecnum = our_vecnums[i];
|
|
|
|
/* Copy both the instruction and the data word for the vector. */
|
|
/* The latter is needed to support branching arbitrarily far. */
|
|
vectors[vecnum] = page0[vecnum];
|
|
vectors[vecnum+8] = page0[vecnum+8];
|
|
}
|
|
|
|
cpu_cache_syncI();
|
|
}
|
|
|
|
data_abort_handler_address = (u_int)data_abort_handler;
|
|
prefetch_abort_handler_address = (u_int)prefetch_abort_handler;
|
|
undefined_handler_address =
|
|
(u_int)undefinedinstruction_bounce; /* why is this needed? -JJK */
|
|
cpu_cache_syncI(); /* XXX - Is this really needed */
|
|
|
|
/* Initialise the undefined instruction handlers. */
|
|
undefined_init();
|
|
cpu_cache_syncI(); /* XXX - Is this really needed */
|
|
|
|
/* Now for the SHARK-specific part of the FIQ set-up */
|
|
fiqhandler.fh_func = shark_fiq;
|
|
fiqhandler.fh_size = shark_fiq_end - shark_fiq;
|
|
fiqhandler.fh_mask = 0x01; /* XXX ??? */
|
|
fiqhandler.fh_r8 = isa_io_virtaddr;
|
|
fiqhandler.fh_r9 = 0; /* no routine right now */
|
|
fiqhandler.fh_r10 = 0; /* no arg right now */
|
|
fiqhandler.fh_r11 = 0; /* scratch */
|
|
fiqhandler.fh_r12 = 0; /* scratch */
|
|
fiqhandler.fh_r13 = 0; /* must set a stack when r9 is set! */
|
|
|
|
if (fiq_claim(&fiqhandler)) panic("Cannot claim FIQ vector.\n");
|
|
|
|
}
|
|
|
|
#ifdef DDB
|
|
printf("ddb: ");
|
|
db_machine_init();
|
|
{
|
|
struct exec *kernexec = (struct exec *)KERNEL_BASE;
|
|
extern int end;
|
|
extern char *esym;
|
|
|
|
ddb_init(kernexec->a_syms, &end, esym);
|
|
}
|
|
if (boothowto & RB_KDB)
|
|
Debugger();
|
|
#endif
|
|
|
|
/* Return the new stackbase. */
|
|
return(kernelstack.virtual + USPACE_SVC_STACK_TOP);
|
|
}
|
|
|
|
|
|
/*
|
|
* Set various globals based on contents of boot_args
|
|
*
|
|
* Note that this routine must NOT trash boot_args, as
|
|
* it is scanned by later routines.
|
|
*
|
|
* There ought to be a routine in machdep.c that does
|
|
* the generic bits of this. -JJK
|
|
*/
|
|
void
|
|
process_kernel_args(void)
|
|
{
|
|
|
|
#if defined(RB_QUIET) && defined(BOOT_QUIETLY)
|
|
boothowto |= RB_QUIET;
|
|
#endif
|
|
|
|
/* Check for MI args. */
|
|
{
|
|
char *p, *q;
|
|
|
|
for (q = boot_args; *q && (p = strstr(q, "-")) != NULL; q = p) {
|
|
/*
|
|
* Be sure the arguments are surrounded by space or NUL
|
|
*/
|
|
if(p > boot_args && p[-1] != ' ') {
|
|
p++;
|
|
continue;
|
|
}
|
|
if(*++p == '\0')
|
|
break;
|
|
if(p[1] == ' ' || p[1] == '\0') {
|
|
switch (*p) {
|
|
case 's':
|
|
boothowto |= RB_SINGLE;
|
|
break;
|
|
case 'a':
|
|
boothowto |= RB_ASKNAME;
|
|
break;
|
|
case 'k':
|
|
boothowto |= RB_KDB;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Check for arm-specific args. */
|
|
{
|
|
char *args = boot_args, *ptr;
|
|
|
|
if ((ptr = strstr(args, "nocache")) != NULL) {
|
|
if((ptr > boot_args || ptr[-1] == ' ') &&
|
|
(ptr[7] == ' ' || ptr[7] == '\0'))
|
|
cpu_cache &= ~1;
|
|
}
|
|
|
|
if ((ptr = strstr(args, "nowritebuf")) != NULL) {
|
|
if((ptr > boot_args || ptr[-1] == ' ') &&
|
|
(ptr[10] == ' ' || ptr[10] == '\0'))
|
|
cpu_cache &= ~2;
|
|
}
|
|
|
|
if ((ptr = strstr(args, "fpaclk2")) != NULL) {
|
|
if((ptr > boot_args || ptr[-1] == ' ') &&
|
|
(ptr[7] == ' ' || ptr[7] == '\0'))
|
|
cpu_cache |= 4;
|
|
}
|
|
|
|
if ((ptr = strstr(args, "icache")) != NULL) {
|
|
if((ptr > boot_args || ptr[-1] == ' ') &&
|
|
(ptr[6] == ' ' || ptr[6] == '\0'))
|
|
cpu_cache |= 8;
|
|
}
|
|
|
|
if ((ptr = strstr(args, "dcache")) != NULL) {
|
|
if((ptr > boot_args || ptr[-1] == ' ') &&
|
|
(ptr[6] == ' ' || ptr[6] == '\0'))
|
|
cpu_cache |= 16;
|
|
}
|
|
|
|
ptr = strstr(args, "maxproc=");
|
|
if (ptr && (ptr > boot_args || ptr[-1] == ' ')) {
|
|
max_processes = (int)strtoul(ptr + 8, NULL, 10);
|
|
if (max_processes < 16)
|
|
max_processes = 16;
|
|
/* Limit is PDSIZE * (maxprocess+1) <= 4MB */
|
|
if (max_processes > 255)
|
|
max_processes = 255;
|
|
}
|
|
|
|
#if NMD > 0
|
|
ptr = strstr(args, "memorydisc=");
|
|
if (!ptr)
|
|
ptr = strstr(args, "memorydisk=");
|
|
if (ptr && (ptr > boot_args || ptr[-1] == ' ')) {
|
|
memory_disc_size = (u_int)strtoul(ptr + 11, NULL, 10);
|
|
memory_disc_size *= 1024;
|
|
if (memory_disc_size < 32*1024)
|
|
memory_disc_size = 32*1024;
|
|
if (memory_disc_size > 2048*1024)
|
|
memory_disc_size = 2048*1024;
|
|
}
|
|
#endif
|
|
|
|
if ((ptr = strstr(args, "single")) != NULL) {
|
|
if((ptr > boot_args || ptr[-1] == ' ') &&
|
|
(ptr[6] == ' ' || ptr[6] == '\0'))
|
|
boothowto |= RB_SINGLE;
|
|
}
|
|
|
|
if ((ptr = strstr(args, "kdb")) != NULL) {
|
|
if((ptr > boot_args || ptr[-1] == ' ') &&
|
|
(ptr[3] == ' ' || ptr[3] == '\0'))
|
|
boothowto |= RB_KDB;
|
|
}
|
|
|
|
#ifdef PMAP_DEBUG
|
|
ptr = strstr(args, "pmapdebug=");
|
|
if (ptr && (ptr > boot_args || ptr[-1] == ' ')) {
|
|
pmap_debug_level = (int)strtoul(ptr + 10, NULL, 10);
|
|
pmap_debug(pmap_debug_level);
|
|
debug_flags |= 0x01;
|
|
}
|
|
#endif
|
|
|
|
ptr = strstr(args, "nbuf=");
|
|
if (ptr && (ptr > boot_args || ptr[-1] == ' '))
|
|
bufpages = (int)strtoul(ptr + 5, NULL, 10);
|
|
|
|
#ifdef RB_QUIET
|
|
if (strstr(args, "noquiet"))
|
|
boothowto &= ~RB_QUIET;
|
|
else if (strstr(args, "quiet"))
|
|
boothowto |= RB_QUIET;
|
|
#endif
|
|
}
|
|
|
|
/* Check for ofwgencfg-specific args. */
|
|
{
|
|
/* None at the moment. */
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Walk the OFW device tree and configure found devices.
|
|
*
|
|
* Move this into common OFW module? -JJK
|
|
*/
|
|
void
|
|
ofrootfound(void)
|
|
{
|
|
int node;
|
|
struct ofbus_attach_args aa;
|
|
|
|
if (!(node = OF_peer(0)))
|
|
panic("No OFW root");
|
|
aa.oba_busname = "ofw";
|
|
aa.oba_phandle = node;
|
|
if (!config_rootfound("ofbus", &aa))
|
|
panic("ofw root ofbus not configured");
|
|
}
|