/*      $NetBSD: machdep.c,v 1.154 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
 *      from: @(#)machdep.c     8.10 (Berkeley) 4/20/94
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: machdep.c,v 1.154 2026/04/28 03:29:11 thorpej Exp $");

#include "opt_ddb.h"
#include "opt_kgdb.h"
#include "opt_modular.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/proc.h>
#include <sys/buf.h>
#include <sys/reboot.h>
#include <sys/conf.h>
#include <sys/file.h>
#include <sys/device.h>
#include <sys/mbuf.h>
#include <sys/msgbuf.h>
#include <sys/ioctl.h>
#include <sys/tty.h>
#include <sys/mount.h>
#include <sys/exec.h>
#include <sys/core.h>
#include <sys/kcore.h>
#include <sys/vnode.h>
#include <sys/syscallargs.h>
#include <sys/ksyms.h>
#include <sys/module.h>
#include <sys/cpu.h>
#ifdef  KGDB
#include <sys/kgdb.h>
#endif

#include <uvm/uvm_extern.h>

#include <sys/sysctl.h>

#include <dev/cons.h>
#include <dev/mm.h>

#include <machine/cpu.h>
#include <machine/dvma.h>
#include <machine/idprom.h>
#include <machine/kcore.h>
#include <machine/reg.h>
#include <machine/pcb.h>
#include <machine/psl.h>
#include <machine/pte.h>
#include <machine/mon.h>

#if defined(DDB)
#include <machine/db_machdep.h>
#include <ddb/db_sym.h>
#include <ddb/db_extern.h>
#endif

#include <sun3/sun3/machdep.h>

#include "ksyms.h"

/* Defined in locore.s */
extern char kernel_text[];
/* Defined by the linker */
extern char etext[];

/* kernel_arch specific values required by module(9) */
const vaddr_t kernbase = KERNBASE3X;
const vaddr_t kern_end = KERN_END3X;

extern void *msgbufaddr;

/* Virtual page frame for /dev/mem (see mem.c) */
vaddr_t vmmap;

u_char cpu_machine_id = 0;
const char *cpu_string = NULL;
int cpu_has_vme = 0;
int has_iocache = 0;

vaddr_t dumppage;

int     delay_divisor = delay_divisor_est(33); /* assume fastest 33Hz */
char    kernel_arch[16] = "sun3x";      /* XXX needs a sysctl node */

static void initcpu(void);

/*
 * Console initialization: called early on from main,
 * before vm init or cpu_startup.  This system is able
 * to use the console for output immediately (via PROM)
 * but can not use it for input until after this point.
 */
void
consinit(void)
{

        /*
         * Switch from the PROM console (output only)
         * to our own console driver.
         */
        cninit();

#if NKSYMS || defined(DDB) || defined(MODULAR)
        {
                extern int nsym;
                extern char *ssym, *esym;

                ksyms_addsyms_elf(nsym, ssym, esym);
        }
#endif  /* DDB */

        /*
         * Now that the console can do input as well as
         * output, consider stopping for a debugger.
         */
        if (boothowto & RB_KDB) {
#ifdef KGDB
                /* XXX - Ask on console for kgdb_dev? */
                /* Note: this will just return if kgdb_dev==NODEV */
                kgdb_connect(1);
#else   /* KGDB */
                /* Either DDB or no debugger (just PROM). */
                Debugger();
#endif  /* KGDB */
        }
}

/*
 * cpu_startup: allocate memory for variable-sized tables,
 * initialize CPU, and do autoconfiguration.
 *
 * This is called early in init_main.c:main(), after the
 * kernel memory allocator is ready for use, but before
 * the creation of processes 1,2, and mountroot, etc.
 */
void
cpu_startup(void)
{
        /* Set the FPU bit in the "system enable register" */
        enable_fpu(1);

        /*
         * Get scratch page for dumpsys().
         */
        dumppage = uvm_km_alloc(kernel_map, PAGE_SIZE, 0, UVM_KMF_WIRED);
        if (dumppage == 0)
                panic("startup: alloc dumppage");

        cpu_startup_common();

        /*
         * Allocate a virtual page (for use by /dev/mem)
         * This page is handed to pmap_enter() therefore
         * it has to be in the normal kernel VA range.
         */
        vmmap = uvm_km_alloc(kernel_map, PAGE_SIZE, 0,
            UVM_KMF_VAONLY | UVM_KMF_WAITVA);

        /*
         * Create the DVMA maps.
         */
        dvma_init();

        /*
         * Set up CPU-specific registers, cache, etc.
         */
        initcpu();

        if (fputype == FPU_NONE) {
                /* Might as well turn the enable bit back off. */
                enable_fpu(0);
        }
}

void
machine_set_model(void)
{
        u_char machtype = identity_prom.idp_machtype;
        if ((machtype & IDM_ARCH_MASK) != IDM_ARCH_SUN3X) {
                printf("Bad IDPROM arch!\n");
                sunmon_abort();
        }

        cpu_machine_id = machtype;
        switch (cpu_machine_id) {

        case ID_SUN3X_80:
                cpu_string = "80";      /* Hydra */
                cpuspeed_khz = 20000;
                delay_divisor = delay_divisor_est(20);
                cpu_has_vme = false;
                break;

        case ID_SUN3X_470:
                cpu_string = "470";     /* Pegasus */
                cpuspeed_khz = 33000;
                delay_divisor = delay_divisor_est(33);
                cpu_has_vme = true;
                break;

        default:
                printf("unknown sun3x model\n");
                sunmon_abort();
        }

        sun68k_set_model();
}

/*
 * machine dependent system variables.
 */
#if 0   /* XXX - Not yet... */
static int
sysctl_machdep_root_device(SYSCTLFN_ARGS)
{
        struct sysctlnode node = *rnode;

        node.sysctl_data = some permutation on root_device;
        node.sysctl_size = strlen(root_device) + 1;
        return (sysctl_lookup(SYSCTLFN_CALL(&node)));
}

static int
sysctl_machdep_booted_kernel(SYSCTLFN_ARGS)
{
        struct sysctlnode node = *rnode;

        node.sysctl_data = some permutation on booted_kernel;
        node.sysctl_size = strlen(booted_kernel) + 1;
        return (sysctl_lookup(SYSCTLFN_CALL(&node)));
}
#endif

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);
#if 0 /* XXX - Not yet... */
        sysctl_createv(clog, 0, NULL, NULL,
                       CTLFLAG_PERMANENT,
                       CTLTYPE_STRING, "root_device", NULL,
                       sysctl_machdep_root_device, 0, NULL, 0,
                       CTL_MACHDEP, CPU_ROOT_DEVICE, CTL_EOL);
        sysctl_createv(clog, 0, NULL, NULL,
                       CTLFLAG_PERMANENT,
                       CTLTYPE_STRING, "booted_kernel", NULL,
                       sysctl_machdep_booted_kernel, 0, NULL, 0,
                       CTL_MACHDEP, CPU_BOOTED_KERNEL, CTL_EOL);
#endif
}

void
machine_halt(void)
{
        sunmon_halt();
}

void
machine_reboot(int howto, char *user_bootstr)
{
        static char bootstr[128];       /* N.B. MUST BE STATIC */
        char *p;

        if (user_bootstr != NULL) {
                strlcpy(bootstr, user_bootstr, sizeof(bootstr));
        } else {
                /*
                 * Build our own boot string with an empty
                 * boot device/file and (maybe) some flags.
                 * The PROM will supply the device/file name.
                 */
                p = bootstr;
                *p = '\0';

                if (howto & (RB_KDB|RB_ASKNAME|RB_SINGLE)) {
                        /* Append the boot flags. */
                        *p++ = ' ';
                        *p++ = '-';
                        if (howto & RB_KDB)
                                *p++ = 'd';
                        if (howto & RB_ASKNAME)
                                *p++ = 'a';
                        if (howto & RB_SINGLE)
                                *p++ = 's';
                        *p = '\0';
                }
        }
        sunmon_reboot(bootstr);
}

/*
 * These variables are needed by /sbin/savecore
 */
uint32_t dumpmag = 0x8fca0101;  /* magic number */
int     dumpsize = 0;           /* pages */
long    dumplo = 0;             /* blocks */

#define DUMP_EXTRA      1       /* CPU-dependent extra pages */

/*
 * This is called by main to set dumplo, dumpsize.
 * Dumps always skip the first PAGE_SIZE of disk space
 * in case there might be a disk label stored there.
 * If there is extra space, put dump at the end to
 * reduce the chance that swapping trashes it.
 */
void
cpu_dumpconf(void)
{
        int devblks;    /* size of dump device in blocks */
        int dumpblks;   /* size of dump image in blocks */

        if (dumpdev == NODEV)
                return;

        devblks = bdev_size(dumpdev);
        if (devblks <= ctod(1))
                return;
        devblks &= ~(ctod(1) - 1);

        /*
         * Note: savecore expects dumpsize to be the
         * number of pages AFTER the dump header.
         */
        dumpsize = physmem;     /* pages */

        /* Position dump image near end of space, page aligned. */
        dumpblks = ctod(physmem + DUMP_EXTRA);
        dumplo = devblks - dumpblks;

        /* If it does not fit, truncate it by moving dumplo. */
        /* Note: Must force signed comparison. */
        if (dumplo < ((long)ctod(1))) {
                dumplo = ctod(1);
                dumpsize = dtoc(devblks - dumplo) - DUMP_EXTRA;
        }
}

/* Note: gdb looks for "dumppcb" in a kernel crash dump. */
struct pcb dumppcb;

/*
 * Write a crash dump.  The format while in swap is:
 *   kcore_seg_t cpu_hdr;
 *   cpu_kcore_hdr_t cpu_data;
 *   padding (PAGE_SIZE-sizeof(kcore_seg_t))
 *   pagemap (2*PAGE_SIZE)
 *   physical memory...
 */
void
dumpsys(void)
{
        const struct bdevsw *dsw;
        kcore_seg_t *kseg_p;
        cpu_kcore_hdr_t *chdr_p;
        struct sun3x_kcore_hdr *sh;
        phys_ram_seg_t *crs_p;
        char *vaddr;
        paddr_t paddr;
        int psize, todo, seg, segsz;
        daddr_t blkno;
        int error = 0;

        if (dumpdev == NODEV)
                return;
        dsw = bdevsw_lookup(dumpdev);
        if (dsw == NULL || dsw->d_psize == NULL)
                return;

        /*
         * For dumps during autoconfiguration,
         * if dump device has already configured...
         */
        if (dumpsize == 0)
                cpu_dumpconf();
        if (dumplo <= 0) {
                printf("\ndump to dev %u,%u not possible\n",
                    major(dumpdev), minor(dumpdev));
                return;
        }
        savectx(&dumppcb);

        psize = bdev_size(dumpdev);
        if (psize == -1) {
                printf("dump area unavailable\n");
                return;
        }

        printf("\ndumping to dev %u,%u offset %ld\n",
            major(dumpdev), minor(dumpdev), dumplo);

        /*
         * Prepare the dump header
         */
        blkno = dumplo;
        todo = dumpsize;        /* pages */
        vaddr = (char *)dumppage;
        memset(vaddr, 0, PAGE_SIZE);

        /* Set pointers to all three parts. */
        kseg_p = (kcore_seg_t *)vaddr;
        chdr_p = (cpu_kcore_hdr_t *)(kseg_p + 1);
        sh = &chdr_p->un._sun3x;

        /* Fill in kcore_seg_t part. */
        CORE_SETMAGIC(*kseg_p, KCORE_MAGIC, MID_MACHINE, CORE_CPU);
        kseg_p->c_size = (ctob(DUMP_EXTRA) - sizeof(*kseg_p));

        /* Fill in cpu_kcore_hdr_t part. */
        strncpy(chdr_p->name, kernel_arch, sizeof(chdr_p->name));
        chdr_p->page_size = PAGE_SIZE;
        chdr_p->kernbase = KERNBASE3X;

        /* Fill in the sun3x_kcore_hdr part. */
        pmap_kcore_hdr(sh);

        /* Write out the dump header. */
        error = (*dsw->d_dump)(dumpdev, blkno, vaddr, PAGE_SIZE);
        if (error)
                goto fail;
        blkno += btodb(PAGE_SIZE);

        /*
         * Now dump physical memory.  Note that physical memory
         * might NOT be contiguous, so do it by segments.
         */

        vaddr = (char *)vmmap;  /* Borrow /dev/mem VA */

        for (seg = 0; seg < SUN3X_NPHYS_RAM_SEGS; seg++) {
                crs_p = &sh->ram_segs[seg];
                paddr = crs_p->start;
                segsz = crs_p->size;

                while (todo && (segsz > 0)) {

                        /* Print pages left after every 16. */
                        if ((todo & 0xf) == 0)
                                printf_nolog("\r%4d", todo);

                        /* Make a temporary mapping for the page. */
                        pmap_kenter_pa(vmmap, paddr | PMAP_NC, VM_PROT_READ, 0);
                        pmap_update(pmap_kernel());
                        error = (*dsw->d_dump)(dumpdev, blkno, vaddr,
                                               PAGE_SIZE);
                        pmap_kremove(vmmap, PAGE_SIZE);
                        pmap_update(pmap_kernel());
                        if (error)
                                goto fail;
                        paddr += PAGE_SIZE;
                        segsz -= PAGE_SIZE;
                        blkno += btodb(PAGE_SIZE);
                        todo--;
                }
        }
        printf("\rdump succeeded\n");
        return;
fail:
        printf(" dump error=%d\n", error);
}

static void
initcpu(void)
{
        /* XXX: Enable RAM parity/ECC checking? */
        /* XXX: parityenable(); */

#ifdef  HAVECACHE
        cache_enable();
#endif
}

/* straptrap() in trap.c */

/* from hp300: badaddr() */
/* peek_byte(), peek_word() moved to bus_subr.c */

/* XXX: parityenable() ? */
/* regdump() moved to regdump.c */

bool
mm_md_direct_mapped_phys(paddr_t paddr, vaddr_t *vaddr)
{
        extern paddr_t avail_start;

        if (paddr >= avail_start)
                return false;
        *vaddr = KERNBASE3X + paddr;
        return true;
}

/*
 * Allow access to the PROM mapping similar to uvm_kernacc().
 */
int
mm_md_kernacc(void *ptr, vm_prot_t prot, bool *handled)
{

        if ((vaddr_t)ptr < SUN3X_PROM_BASE || (vaddr_t)ptr > SUN3X_MONEND) {
                *handled = false;
                return 0;
        }

        *handled = true;
        /* Read in the PROM itself is OK. */
        if ((prot & VM_PROT_WRITE) == 0)
                return 0;

        /* PROM data page is OK for read/write. */
        if ((vaddr_t)ptr >= SUN3X_MONDATA &&
            (vaddr_t)ptr < SUN3X_MONDATA + PAGE_SIZE)
                return 0;
        return EFAULT;
}