/* $NetBSD: machdep.c,v 1.233 2026/04/28 03:29:11 thorpej Exp $ */ /* * Copyright (c) 1988 University of Utah. * Copyright (c) 1982, 1986, 1990, 1993 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * the Systems Programming Group of the University of Utah Computer * Science Department. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * from: Utah $Hdr: machdep.c 1.74 92/12/20$ * * @(#)machdep.c 8.10 (Berkeley) 4/20/94 */ #include __KERNEL_RCSID(0, "$NetBSD: machdep.c,v 1.233 2026/04/28 03:29:11 thorpej Exp $"); #include "opt_ddb.h" #include "opt_kgdb.h" #include "opt_fpu_emulate.h" #include "opt_m060sp.h" #include "opt_modular.h" #include "opt_panicbutton.h" #include "opt_extmem.h" #include "opt_m68k_arch.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "ksyms.h" #if NKSYMS || defined(DDB) || defined(MODULAR) #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #define MAXMEM 64*1024 /* XXX - from cmap.h */ #include #include #include #include #include #include extern void doboot(void) __attribute__((__noreturn__)); extern paddr_t avail_start, avail_end; extern u_int lowram; extern int end, *esym; int maxmem; /* max memory per process */ /* prototypes for local functions */ static int check_emulator(char *, int); /* functions called from locore.s */ void machine_init(paddr_t); void nmihand(struct frame); void intrhand(int); /* memory probe function called from locore.s */ void setmemrange(void); #ifdef EXTENDED_MEMORY static bool mem_exists(paddr_t, paddr_t); #endif static int basemem; /* * Assume a standard X68030 with 25MHz CPU. The delay_divisor will * be calibrated later. */ int delay_divisor = delay_divisor_est(25); /* * machine_bootmap[] is checked in pmap_bootstrap1() of the new m68k pmap * and it allocates kernel address space for intio devices. */ static vaddr_t intiova; #define PMBM_INTIO 0 struct pmap_bootmap machine_bootmap[] = { { .pmbm_vaddr_ptr = &intiova, .pmbm_paddr = INTIOBASE, .pmbm_size = INTIOSIZE, .pmbm_flags = PMBM_F_CI }, { .pmbm_vaddr = -1 }, }; static callout_t candbtimer_ch; void machine_init(paddr_t nextpa) { extern paddr_t msgbufpa; #ifdef __HAVE_NEW_PMAP_68K /* load the internal IO space region */ intiobase = (uint8_t *)intiova; #endif /* * Most m68k ports allocate msgbuf at the end of available memory * (i.e. just after avail_end), but on x68k we allocate msgbuf * at the end of main memory for compatibility. * * (This means we have to fully initialize the first phys seg * entry.) */ phys_seg_list[0].ps_start = phys_seg_list[0].ps_avail_start = m68k_round_page(phys_seg_list[0].ps_start); phys_seg_list[0].ps_end = phys_seg_list[0].ps_avail_end = m68k_trunc_page(phys_seg_list[0].ps_end); phys_seg_list[0].ps_avail_end -= m68k_round_page(MSGBUFSIZE); msgbufpa = phys_seg_list[0].ps_avail_end; machine_init_common(nextpa); } /* * Console initialization: called early on from main, * before vm init or startup. Do enough configuration * to choose and initialize a console. */ void consinit(void) { /* * bring graphics layer up. */ config_console(); /* * Initialize the console before we print anything out. */ cninit(); #ifdef KGDB zs_kgdb_init(); /* XXX */ #endif #if NKSYMS || defined(DDB) || defined(MODULAR) ksyms_addsyms_elf((int)esym - (int)&end - sizeof(Elf32_Ehdr), (void *)&end, esym); #endif #ifdef DDB if (boothowto & RB_KDB) Debugger(); #endif } /* * cpu_startup: allocate memory for variable-sized tables, * initialize cpu, and do autoconfiguration. */ void cpu_startup(void) { cpu_startup_common(); callout_init(&candbtimer_ch, 0); } void machine_set_model(void) { /* there's alot of XXX in here... */ const char *mach; char emubuf[20]; /* * check machine type constant */ switch (intio_get_sysport_mpustat()) { case 0xdc: /* * CPU Type == 68030, Clock == 25MHz */ mach = "030"; break; case 0xfe: /* * CPU Type == 68000, Clock == 16MHz */ mach = "000XVI"; break; case 0xff: /* * CPU Type == 68000, Clock == 10MHz */ mach = "000/ACE/PRO/EXPERT/SUPER"; break; default: /* * unknown type */ mach = "000?(unknown model)"; break; } emubuf[0] = '\0'; check_emulator(emubuf, sizeof(emubuf)); switch (cputype) { case CPU_68060: /* * This delay_divisor method cannot get accurate cpuspeed * for 68060. */ /* XXX really? */ break; case CPU_68040: cpuspeed_khz = delay_divisor_est40(delay_divisor) * 1000; break; case CPU_68030: cpuspeed_khz = delay_divisor_est(delay_divisor) * 1000; break; case CPU_68020: cpuspeed_khz = delay_divisor_est(delay_divisor) * 1000; break; default: panic("impossible cpu"); } cpu_setmodel("X68%s %s%s", mach, emubuf[0] ? " on " : "", emubuf); } /* * If it is an emulator, store the name in buf and return 1. * Otherwise return 0. */ static int check_emulator(char *buf, int bufsize) { int xm6major; int xm6minor; int xm6imark; int xm6imajor; int xm6iminor; /* XM6 and its family */ intio_set_sysport_sramwp('X'); if (intio_get_sysport_sramwp() == '6') { xm6major = intio_get_sysport_sramwp(); xm6minor = intio_get_sysport_sramwp(); xm6imark = intio_get_sysport_sramwp(); switch (xm6imark) { case 0xff: /* Original XM6 or unknown compatibles */ snprintf(buf, bufsize, "XM6 v%x.%02x", xm6major, xm6minor); break; case 'i': /* XM6i */ xm6imajor = intio_get_sysport_sramwp(); xm6iminor = intio_get_sysport_sramwp(); snprintf(buf, bufsize, "XM6i v%d.%02d", xm6imajor, xm6iminor); break; case 'g': /* XM6 TypeG */ snprintf(buf, bufsize, "XM6 TypeG v%x.%02x", xm6major, xm6minor); break; default: /* Other XM6 compatibles? */ /* XXX what should I do? */ return 0; } return 1; } return 0; } /* * machine dependent system variables. */ SYSCTL_SETUP(sysctl_machdep_setup, "sysctl machdep subtree setup") { sysctl_createv(clog, 0, NULL, NULL, CTLFLAG_PERMANENT, CTLTYPE_NODE, "machdep", NULL, NULL, 0, NULL, 0, CTL_MACHDEP, CTL_EOL); sysctl_createv(clog, 0, NULL, NULL, CTLFLAG_PERMANENT, CTLTYPE_STRUCT, "console_device", NULL, sysctl_consdev, 0, NULL, sizeof(dev_t), CTL_MACHDEP, CPU_CONSDEV, CTL_EOL); } void machine_powerdown(void) { printf("powering off...\n"); delay(1000000); /* Turn off the alarm signal of RTC */ IODEVbase->io_rtc.bank0.reset = 0x0c; intio_set_sysport_powoff(0x00); intio_set_sysport_powoff(0x0f); intio_set_sysport_powoff(0x0f); delay(1000000); } void intrhand(int sr) { printf("intrhand: unexpected sr 0x%x\n", sr); } const uint16_t ipl2psl_table[NIPL] = { [IPL_NONE] = PSL_S | PSL_IPL0, [IPL_SOFTCLOCK] = PSL_S | PSL_IPL1, [IPL_SOFTBIO] = PSL_S | PSL_IPL1, [IPL_SOFTNET] = PSL_S | PSL_IPL1, [IPL_SOFTSERIAL] = PSL_S | PSL_IPL1, [IPL_VM] = PSL_S | PSL_IPL5, [IPL_SCHED] = PSL_S | PSL_IPL7, [IPL_HIGH] = PSL_S | PSL_IPL7, }; #if (defined(DDB) || defined(DEBUG)) && !defined(PANICBUTTON) #define PANICBUTTON #endif #ifdef PANICBUTTON int panicbutton = 1; /* non-zero if panic buttons are enabled */ int crashandburn = 0; int candbdelay = 50; /* give em half a second */ void candbtimer(void *); void candbtimer(void *arg) { crashandburn = 0; } #endif /* * Level 7 interrupts can be caused by the NMI button. */ void nmihand(struct frame frame) { intio_set_sysport_keyctrl(intio_get_sysport_keyctrl() | 0x04); if (1) { #ifdef PANICBUTTON static int innmihand = 0; /* * Attempt to reduce the window of vulnerability for recursive * NMIs (e.g. someone holding down the keyboard reset button). */ if (innmihand == 0) { innmihand = 1; printf("NMI button pressed\n"); innmihand = 0; } #ifdef DDB Debugger(); #else if (panicbutton) { if (crashandburn) { crashandburn = 0; panic(panicstr ? "forced crash, nosync" : "forced crash"); } crashandburn++; callout_reset(&candbtimer_ch, candbdelay, candbtimer, NULL); } #endif /* DDB */ #endif /* PANICBUTTON */ return; } /* panic?? */ printf("unexpected level 7 interrupt ignored\n"); } #ifdef EXTENDED_MEMORY static const struct memlist { paddr_t exstart; psize_t minsize; psize_t maxsize; } memlist[] = { /* We define two extended memory regions for all possible settings. */ /* * The first region is at 0x01000000: * * TS-6BE16: 16MB at 0x01000000 (to 0x01FFFFFF) * XM6i: 4MB - 240MB at 0x01000000 (upto 0x0FFFFFFF) */ { 0x01000000, 0x00400000, 0x0f000000 }, /* * The second region is at 0x10000000: * * 060turbo: 4MB - 128MB at 0x10000000 (upto 0x17FFFFFF) * XM6i: 4MB - 768MB at 0x10000000 (upto 0x3FFFFFFF) */ { 0x10000000, 0x00400000, 0x30000000 }, }; /* check each 4MB region */ #define EXTMEM_RANGE (4 * 1024 * 1024) __CTASSERT(__arraycount(memlist) + 1 <= VM_PHYSSEG_MAX); /* * check memory existency */ static bool mem_exists(paddr_t mem, paddr_t basemax) { /* most variables must be register! */ volatile unsigned char *m, *b; unsigned char save_m, save_b=0; /* XXX: shutup gcc */ bool baseismem; bool exists = false; void *base; void *begin_check, *end_check; label_t faultbuf; /* * In this function we assume: * - MMU is not enabled yet but PA == VA * (i.e. no RELOC() macro to convert PA to VA) * - bus error can be caught by setjmp() * (i.e. %vbr register is initialized properly) * - all memory cache is not enabled */ /* only 24bits are significant on normal X680x0 systems */ base = (void *)(mem & 0x00FFFFFF); m = (void *)mem; b = (void *)base; /* This is somewhat paranoid -- avoid overwriting myself */ __asm("lea %%pc@(begin_check_mem),%0" : "=a"(begin_check)); __asm("lea %%pc@(end_check_mem),%0" : "=a"(end_check)); if (base >= begin_check && base < end_check) { size_t off = (char *)end_check - (char *)begin_check; m -= off; b -= off; } nofault = &faultbuf; if (setjmp(nofault)) { nofault = NULL; return false; } (void)*m; /* * Can't check by writing if the corresponding * base address isn't memory. * * I hope this would be no harm.... */ baseismem = base < (void *)basemax; __asm("begin_check_mem:"); /* save original value (base must be saved first) */ if (baseismem) save_b = *b; save_m = *m; /* * stack and other data segment variables are unusable * til end_check_mem, because they may be clobbered. */ /* * check memory by writing/reading */ if (baseismem) *b = 0x55; *m = 0xAA; if ((baseismem && *b != 0x55) || *m != 0xAA) goto out; *m = 0x55; if (baseismem) *b = 0xAA; if (*m != 0x55 || (baseismem && *b != 0xAA)) goto out; exists = true; out: *m = save_m; if (baseismem) *b = save_b; __asm("end_check_mem:"); nofault = NULL; return exists; } #endif void setmemrange(void) { #ifdef EXTENDED_MEMORY int i; paddr_t exstart, exend; psize_t size, minsize, maxsize; const struct memlist *mlist = memlist; paddr_t basemax = m68k_ptob(physmem); #endif /* * VM system is not started yet, and even MMU is not enabled here. * We assume VA == PA and don't bother to use RELOC() macro * as pmap_bootstrap() does. */ /* save the original base memory range */ basemem = physmem; /* * XXX * Probably we should also probe the main memory region * for machines which might have a wrong value in a dead SRAM. */ phys_seg_list[0].ps_start = lowram; phys_seg_list[0].ps_end = lowram + m68k_ptob(basemem); #ifdef EXTENDED_MEMORY /* discover extended memory */ for (i = 0; i < __arraycount(memlist); i++) { exstart = mlist[i].exstart; minsize = mlist[i].minsize; maxsize = mlist[i].maxsize; /* * Normally, x68k hardware is NOT 32bit-clean. * But some type of extended memory is in 32bit address space. * Check whether. */ if (!mem_exists(exstart, basemax)) continue; exend = 0; /* range check */ for (size = minsize; size <= maxsize; size += EXTMEM_RANGE) { if (!mem_exists(exstart + size - 4, basemax)) break; exend = exstart + size; } if (exstart < exend) { phys_seg_list[i + 1].ps_start = exstart; phys_seg_list[i + 1].ps_end = exend; physmem += m68k_btop(exend - exstart); if (maxmem < m68k_btop(exend)) maxmem = m68k_btop(exend); } } #endif } volatile unsigned int intr_depth; bool cpu_intr_p(void) { return intr_depth != 0; } int mm_md_physacc(paddr_t pa, vm_prot_t prot) { int rv = mm_md_physacc_regular(pa, prot); if (rv != 0) { /* I/O space */ if (INTIOBASE <= pa && pa < INTIOTOP) { rv = kauth_authorize_machdep(kauth_cred_get(), KAUTH_MACHDEP_UNMANAGEDMEM, NULL, NULL, NULL, NULL); } } return rv; }