Index: head/sys/conf/files.riscv =================================================================== --- head/sys/conf/files.riscv (revision 339329) +++ head/sys/conf/files.riscv (revision 339330) @@ -1,67 +1,68 @@ # $FreeBSD$ cddl/compat/opensolaris/kern/opensolaris_atomic.c optional zfs | dtrace compile-with "${CDDL_C}" cddl/dev/dtrace/riscv/dtrace_asm.S optional dtrace compile-with "${DTRACE_S}" cddl/dev/dtrace/riscv/dtrace_subr.c optional dtrace compile-with "${DTRACE_C}" cddl/dev/fbt/riscv/fbt_isa.c optional dtrace_fbt | dtraceall compile-with "${FBT_C}" crypto/blowfish/bf_enc.c optional crypto | ipsec | ipsec_support crypto/des/des_enc.c optional crypto | ipsec | ipsec_support | netsmb dev/ofw/ofw_cpu.c optional fdt dev/uart/uart_cpu_fdt.c optional uart fdt +dev/uart/uart_dev_lowrisc.c optional uart_lowrisc dev/xilinx/axi_quad_spi.c optional xilinx_spi kern/kern_clocksource.c standard kern/msi_if.m standard kern/pic_if.m standard kern/subr_devmap.c standard kern/subr_dummy_vdso_tc.c standard kern/subr_intr.c standard libkern/bcmp.c standard libkern/bcopy.c standard libkern/ffs.c standard libkern/ffsl.c standard libkern/ffsll.c standard libkern/fls.c standard libkern/flsl.c standard libkern/flsll.c standard libkern/memcmp.c standard libkern/memset.c standard riscv/riscv/autoconf.c standard riscv/riscv/bus_machdep.c standard riscv/riscv/bus_space_asm.S standard riscv/riscv/busdma_machdep.c standard riscv/riscv/clock.c standard riscv/riscv/copyinout.S standard riscv/riscv/copystr.c standard riscv/riscv/cpufunc_asm.S standard riscv/riscv/db_disasm.c optional ddb riscv/riscv/db_interface.c optional ddb riscv/riscv/db_trace.c optional ddb riscv/riscv/dump_machdep.c standard riscv/riscv/elf_machdep.c standard riscv/riscv/exception.S standard riscv/riscv/intr_machdep.c standard riscv/riscv/in_cksum.c optional inet | inet6 riscv/riscv/identcpu.c standard riscv/riscv/locore.S standard no-obj riscv/riscv/machdep.c standard riscv/riscv/minidump_machdep.c standard riscv/riscv/mp_machdep.c optional smp riscv/riscv/mem.c standard riscv/riscv/nexus.c standard riscv/riscv/ofw_machdep.c optional fdt riscv/riscv/plic.c standard riscv/riscv/pmap.c standard riscv/riscv/riscv_console.c optional rcons riscv/riscv/soc.c standard riscv/riscv/stack_machdep.c optional ddb | stack riscv/riscv/support.S standard riscv/riscv/swtch.S standard riscv/riscv/sys_machdep.c standard riscv/riscv/trap.c standard riscv/riscv/timer.c standard riscv/riscv/uio_machdep.c standard riscv/riscv/uma_machdep.c standard riscv/riscv/unwind.c optional ddb | kdtrace_hooks | stack riscv/riscv/vm_machdep.c standard # Zstd contrib/zstd/lib/freebsd/zstd_kfreebsd.c optional zstdio compile-with ${ZSTD_C} Index: head/sys/dev/uart/uart_dev_lowrisc.c =================================================================== --- head/sys/dev/uart/uart_dev_lowrisc.c (nonexistent) +++ head/sys/dev/uart/uart_dev_lowrisc.c (revision 339330) @@ -0,0 +1,393 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause + * + * Copyright (c) 2018 Ruslan Bukin + * All rights reserved. + * + * This software was developed by SRI International and the University of + * Cambridge Computer Laboratory (Department of Computer Science and + * Technology) under DARPA contract HR0011-18-C-0016 ("ECATS"), as part of the + * DARPA SSITH research programme. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include "opt_ddb.h" + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "uart_if.h" + +#define DEFAULT_BAUD_RATE 115200 + +/* + * Low-level UART interface. + */ +static int lowrisc_uart_probe(struct uart_bas *bas); +static void lowrisc_uart_init(struct uart_bas *bas, int, int, int, int); +static void lowrisc_uart_term(struct uart_bas *bas); +static void lowrisc_uart_putc(struct uart_bas *bas, int); +static int lowrisc_uart_rxready(struct uart_bas *bas); +static int lowrisc_uart_getc(struct uart_bas *bas, struct mtx *); + +static struct uart_ops uart_lowrisc_uart_ops = { + .probe = lowrisc_uart_probe, + .init = lowrisc_uart_init, + .term = lowrisc_uart_term, + .putc = lowrisc_uart_putc, + .rxready = lowrisc_uart_rxready, + .getc = lowrisc_uart_getc, +}; + +static int +lowrisc_uart_probe(struct uart_bas *bas) +{ + + return (0); +} + +static u_int +lowrisc_uart_getbaud(struct uart_bas *bas) +{ + + return (DEFAULT_BAUD_RATE); +} + +static void +lowrisc_uart_init(struct uart_bas *bas, int baudrate, int databits, + int stopbits, int parity) +{ + + /* TODO */ +} + +static void +lowrisc_uart_term(struct uart_bas *bas) +{ + + /* TODO */ +} + +static void +lowrisc_uart_putc(struct uart_bas *bas, int c) +{ + + while (GETREG(bas, UART_DR) & DR_TX_FIFO_FULL) + ; + + SETREG(bas, UART_DR, c); +} + +static int +lowrisc_uart_rxready(struct uart_bas *bas) +{ + + if (GETREG(bas, UART_DR) & DR_RX_FIFO_EMPTY) + return (0); + + return (1); +} + +static int +lowrisc_uart_getc(struct uart_bas *bas, struct mtx *hwmtx) +{ + uint32_t reg; + + uart_lock(hwmtx); + SETREG(bas, UART_INT_STATUS, INT_STATUS_ACK); + reg = GETREG(bas, UART_DR); + uart_unlock(hwmtx); + + return (reg & 0xff); +} + +/* + * High-level UART interface. + */ +struct lowrisc_uart_softc { + struct uart_softc base; +}; + +static int lowrisc_uart_bus_attach(struct uart_softc *); +static int lowrisc_uart_bus_detach(struct uart_softc *); +static int lowrisc_uart_bus_flush(struct uart_softc *, int); +static int lowrisc_uart_bus_getsig(struct uart_softc *); +static int lowrisc_uart_bus_ioctl(struct uart_softc *, int, intptr_t); +static int lowrisc_uart_bus_ipend(struct uart_softc *); +static int lowrisc_uart_bus_param(struct uart_softc *, int, int, int, int); +static int lowrisc_uart_bus_probe(struct uart_softc *); +static int lowrisc_uart_bus_receive(struct uart_softc *); +static int lowrisc_uart_bus_setsig(struct uart_softc *, int); +static int lowrisc_uart_bus_transmit(struct uart_softc *); +static void lowrisc_uart_bus_grab(struct uart_softc *); +static void lowrisc_uart_bus_ungrab(struct uart_softc *); + +static kobj_method_t lowrisc_uart_methods[] = { + KOBJMETHOD(uart_attach, lowrisc_uart_bus_attach), + KOBJMETHOD(uart_detach, lowrisc_uart_bus_detach), + KOBJMETHOD(uart_flush, lowrisc_uart_bus_flush), + KOBJMETHOD(uart_getsig, lowrisc_uart_bus_getsig), + KOBJMETHOD(uart_ioctl, lowrisc_uart_bus_ioctl), + KOBJMETHOD(uart_ipend, lowrisc_uart_bus_ipend), + KOBJMETHOD(uart_param, lowrisc_uart_bus_param), + KOBJMETHOD(uart_probe, lowrisc_uart_bus_probe), + KOBJMETHOD(uart_receive, lowrisc_uart_bus_receive), + KOBJMETHOD(uart_setsig, lowrisc_uart_bus_setsig), + KOBJMETHOD(uart_transmit, lowrisc_uart_bus_transmit), + KOBJMETHOD(uart_grab, lowrisc_uart_bus_grab), + KOBJMETHOD(uart_ungrab, lowrisc_uart_bus_ungrab), + { 0, 0 } +}; + +static struct uart_class uart_lowrisc_class = { + "lowrisc", + lowrisc_uart_methods, + sizeof(struct lowrisc_uart_softc), + .uc_ops = &uart_lowrisc_uart_ops, + .uc_range = 0x100, + .uc_rclk = 12500000, /* TODO: get value from clock manager */ + .uc_rshift = 0 +}; + +static struct ofw_compat_data compat_data[] = { + {"lowrisc-fake", (uintptr_t)&uart_lowrisc_class}, + {NULL, (uintptr_t)NULL}, +}; +UART_FDT_CLASS_AND_DEVICE(compat_data); + +static int +lowrisc_uart_bus_attach(struct uart_softc *sc) +{ + struct uart_bas *bas; + struct uart_devinfo *di; + + bas = &sc->sc_bas; + if (sc->sc_sysdev != NULL) { + di = sc->sc_sysdev; + lowrisc_uart_init(bas, di->baudrate, di->databits, di->stopbits, + di->parity); + } else + lowrisc_uart_init(bas, DEFAULT_BAUD_RATE, 8, 1, 0); + + (void)lowrisc_uart_bus_getsig(sc); + + /* TODO: clear all pending interrupts. */ + + return (0); +} + +static int +lowrisc_uart_bus_detach(struct uart_softc *sc) +{ + + /* TODO */ + + return (0); +} + +static int +lowrisc_uart_bus_flush(struct uart_softc *sc, int what) +{ + + /* TODO */ + + return (0); +} + +static int +lowrisc_uart_bus_getsig(struct uart_softc *sc) +{ + + /* TODO */ + + return (0); +} + +static int +lowrisc_uart_bus_ioctl(struct uart_softc *sc, int request, intptr_t data) +{ + struct uart_bas *bas; + int error; + + bas = &sc->sc_bas; + error = 0; + uart_lock(sc->sc_hwmtx); + switch (request) { + case UART_IOCTL_BREAK: + /* TODO */ + break; + case UART_IOCTL_BAUD: + *(u_int*)data = lowrisc_uart_getbaud(bas); + break; + default: + error = EINVAL; + break; + } + uart_unlock(sc->sc_hwmtx); + + return (error); +} + +static int +lowrisc_uart_bus_ipend(struct uart_softc *sc) +{ + struct uart_bas *bas; + int ipend; + + bas = &sc->sc_bas; + + ipend = 0; + + uart_lock(sc->sc_hwmtx); + if ((GETREG(bas, UART_DR) & DR_RX_FIFO_EMPTY) == 0) + ipend |= SER_INT_RXREADY; + SETREG(bas, UART_INT_STATUS, INT_STATUS_ACK); + uart_unlock(sc->sc_hwmtx); + + return (ipend); +} + +static int +lowrisc_uart_bus_param(struct uart_softc *sc, int baudrate, int databits, + int stopbits, int parity) +{ + + uart_lock(sc->sc_hwmtx); + lowrisc_uart_init(&sc->sc_bas, baudrate, databits, stopbits, parity); + uart_unlock(sc->sc_hwmtx); + + return (0); +} + +static int +lowrisc_uart_bus_probe(struct uart_softc *sc) +{ + int error; + + error = lowrisc_uart_probe(&sc->sc_bas); + if (error) + return (error); + + /* + * On input we can read up to the full fifo size at once. On output, we + * want to write only as much as the programmed tx low water level, + * because that's all we can be certain we have room for in the fifo + * when we get a tx-ready interrupt. + */ + sc->sc_rxfifosz = 2048; + sc->sc_txfifosz = 2048; + + device_set_desc(sc->sc_dev, "lowRISC UART"); + + return (0); +} + +static int +lowrisc_uart_bus_receive(struct uart_softc *sc) +{ + struct uart_bas *bas; + uint32_t reg; + + bas = &sc->sc_bas; + + uart_lock(sc->sc_hwmtx); + + do { + if (uart_rx_full(sc)) { + /* No space left in the input buffer */ + sc->sc_rxbuf[sc->sc_rxput] = UART_STAT_OVERRUN; + break; + } + reg = GETREG(bas, UART_DR); + SETREG(bas, UART_INT_STATUS, INT_STATUS_ACK); + uart_rx_put(sc, reg & 0xff); + } while ((reg & DR_RX_FIFO_EMPTY) == 0); + + uart_unlock(sc->sc_hwmtx); + + return (0); +} + +static int +lowrisc_uart_bus_setsig(struct uart_softc *sc, int sig) +{ + + return (0); +} + +static int +lowrisc_uart_bus_transmit(struct uart_softc *sc) +{ + struct uart_bas *bas; + int i; + + bas = &sc->sc_bas; + + uart_lock(sc->sc_hwmtx); + for (i = 0; i < sc->sc_txdatasz; i++) { + while (GETREG(bas, UART_DR) & DR_TX_FIFO_FULL) + ; + SETREG(bas, UART_DR, sc->sc_txbuf[i] & 0xff); + } + uart_unlock(sc->sc_hwmtx); + + return (0); +} + +static void +lowrisc_uart_bus_grab(struct uart_softc *sc) +{ + struct uart_bas *bas; + + bas = &sc->sc_bas; + + uart_lock(sc->sc_hwmtx); + /* TODO */ + uart_unlock(sc->sc_hwmtx); +} + +static void +lowrisc_uart_bus_ungrab(struct uart_softc *sc) +{ + struct uart_bas *bas; + + bas = &sc->sc_bas; + + uart_lock(sc->sc_hwmtx); + /* TODO */ + uart_unlock(sc->sc_hwmtx); +} Property changes on: head/sys/dev/uart/uart_dev_lowrisc.c ___________________________________________________________________ Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +FreeBSD=%H \ No newline at end of property Added: svn:mime-type ## -0,0 +1 ## +text/plain \ No newline at end of property Index: head/sys/dev/uart/uart_dev_lowrisc.h =================================================================== --- head/sys/dev/uart/uart_dev_lowrisc.h (nonexistent) +++ head/sys/dev/uart/uart_dev_lowrisc.h (revision 339330) @@ -0,0 +1,66 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause + * + * Copyright (c) 2018 Ruslan Bukin + * All rights reserved. + * + * This software was developed by SRI International and the University of + * Cambridge Computer Laboratory (Department of Computer Science and + * Technology) under DARPA contract HR0011-18-C-0016 ("ECATS"), as part of the + * DARPA SSITH research programme. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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. + * + * $FreeBSD$ + */ + +#ifndef _UART_DEV_LOWRISC_H_ +#define _UART_DEV_LOWRISC_H_ + +#define UART_DR 0x0000 +#define DR_DATA_S 0 +#define DR_DATA_M 0xff +#define DR_RX_ERR (1 << 8) +#define DR_RX_FIFO_EMPTY (1 << 9) +#define DR_TX_FIFO_FULL (1 << 10) +#define DR_RX_FIFO_FULL (1 << 11) +#define UART_INT_STATUS 0x1000 +#define INT_STATUS_ACK 1 +#define UART_BAUD 0x2000 /* write-only */ +#define BAUD_115200 108 +#define UART_STAT_RX 0x2000 /* read-only */ +#define STAT_RX_FIFO_RD_COUNT_S 0 +#define STAT_RX_FIFO_RD_COUNT_M (0xffff << STAT_RX_FIFO_RD_COUNT_S) +#define STAT_RX_FIFO_WR_COUNT_S 16 +#define STAT_RX_FIFO_WR_COUNT_M (0xffff << STAT_RX_FIFO_WR_COUNT_S) +#define UART_STAT_TX 0x2004 +#define STAT_TX_FIFO_RD_COUNT_S 0 +#define STAT_TX_FIFO_RD_COUNT_M (0xffff << STAT_TX_FIFO_RD_COUNT_S) +#define STAT_TX_FIFO_WR_COUNT_S 16 +#define STAT_TX_FIFO_WR_COUNT_M (0xffff << STAT_TX_FIFO_WR_COUNT_S) + +#define GETREG(bas, reg) \ + bus_space_read_2((bas)->bst, (bas)->bsh, (reg)) +#define SETREG(bas, reg, value) \ + bus_space_write_2((bas)->bst, (bas)->bsh, (reg), (value)) + +#endif /* _UART_DEV_LOWRISC_H_ */ Property changes on: head/sys/dev/uart/uart_dev_lowrisc.h ___________________________________________________________________ Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +FreeBSD=%H \ No newline at end of property Added: svn:mime-type ## -0,0 +1 ## +text/plain \ No newline at end of property Index: head/sys/riscv/conf/GENERIC =================================================================== --- head/sys/riscv/conf/GENERIC (revision 339329) +++ head/sys/riscv/conf/GENERIC (revision 339330) @@ -1,147 +1,148 @@ # # GENERIC -- Generic kernel configuration file for FreeBSD/RISC-V # # For more information on this file, please read the config(5) manual page, # and/or the handbook section on Kernel Configuration Files: # # https://www.FreeBSD.org/doc/en_US.ISO8859-1/books/handbook/kernelconfig-config.html # # The handbook is also available locally in /usr/share/doc/handbook # if you've installed the doc distribution, otherwise always see the # FreeBSD World Wide Web server (https://www.FreeBSD.org/) for the # latest information. # # An exhaustive list of options and more detailed explanations of the # device lines is also present in the ../../conf/NOTES and NOTES files. # If you are in doubt as to the purpose or necessity of a line, check first # in NOTES. # # $FreeBSD$ cpu RISCV ident GENERIC makeoptions DEBUG=-g # Build kernel with gdb(1) debug symbols # makeoptions WITH_CTF=1 # Run ctfconvert(1) for DTrace support # FIXME: linker error. "--relax and -r may not be used together" makeoptions WITHOUT_MODULES="usb otusfw mwlfw ispfw mwlfw ralfw rtwnfw" # makeoptions NO_MODULES options SCHED_ULE # ULE scheduler options PREEMPTION # Enable kernel thread preemption options VIMAGE # Subsystem virtualization, e.g. VNET options INET # InterNETworking options INET6 # IPv6 communications protocols options TCP_HHOOK # hhook(9) framework for TCP options IPSEC # IP (v4/v6) security options IPSEC_SUPPORT # Allow kldload of ipsec and tcpmd5 options TCP_OFFLOAD # TCP offload options SCTP # Stream Control Transmission Protocol options FFS # Berkeley Fast Filesystem options SOFTUPDATES # Enable FFS soft updates support options UFS_ACL # Support for access control lists options UFS_DIRHASH # Improve performance on big directories options UFS_GJOURNAL # Enable gjournal-based UFS journaling options QUOTA # Enable disk quotas for UFS options NFSCL # Network Filesystem Client options NFSD # Network Filesystem Server options NFSLOCKD # Network Lock Manager options NFS_ROOT # NFS usable as /, requires NFSCL options MSDOSFS # MSDOS Filesystem options CD9660 # ISO 9660 Filesystem options PROCFS # Process filesystem (requires PSEUDOFS) options PSEUDOFS # Pseudo-filesystem framework options GEOM_PART_GPT # GUID Partition Tables. # options GEOM_RAID # Soft RAID functionality. options GEOM_LABEL # Provides labelization options SCSI_DELAY=5000 # Delay (in ms) before probing SCSI options KTRACE # ktrace(1) support # options STACK # stack(9) support options SYSVSHM # SYSV-style shared memory options SYSVMSG # SYSV-style message queues options SYSVSEM # SYSV-style semaphores options _KPOSIX_PRIORITY_SCHEDULING # POSIX P1003_1B real-time extensions options PRINTF_BUFR_SIZE=128 # Prevent printf output being interspersed. options KBD_INSTALL_CDEV # install a CDEV entry in /dev # options HWPMC_HOOKS # Necessary kernel hooks for hwpmc(4) options AUDIT # Security event auditing options CAPABILITY_MODE # Capsicum capability mode options CAPABILITIES # Capsicum capabilities options MAC # TrustedBSD MAC Framework options KDTRACE_FRAME # Ensure frames are compiled in options KDTRACE_HOOKS # Kernel DTrace hooks options FPE # Floating-point extension support options RACCT # Resource accounting framework options RACCT_DEFAULT_TO_DISABLED # Set kern.racct.enable=0 by default options RCTL # Resource limits options SMP options INTRNG # RISC-V SBI console device rcons # VirtIO support device virtio # Generic VirtIO bus (required) device virtio_pci # VirtIO PCI device device vtnet # VirtIO Ethernet device device virtio_blk # VirtIO Block device device virtio_mmio # VirtIO MMIO bus # DTrace support # device dtrace # device dtrace_profile # device dtrace_sdt # device dtrace_fbt # device dtrace_systrace # device dtrace_prototype # device dtraceall # Serial (COM) ports device uart # Generic UART driver +device uart_lowrisc # lowRISC UART driver device uart_ns8250 # ns8250-type UART driver # Uncomment for memory disk # options MD_ROOT # options MD_ROOT_SIZE=32768 # 32MB ram disk # makeoptions MFS_IMAGE=/path/to/img # options ROOTDEVNAME=\"ufs:/dev/md0\" # Uncomment for virtio block device # options ROOTDEVNAME=\"ufs:/dev/vtbd0\" # Debugging support. Always need this: options KDB # Enable kernel debugger support. options KDB_TRACE # Print a stack trace for a panic. # For full debugger support use (turn off in stable branch): options DDB # Support DDB. # options GDB # Support remote GDB. options DEADLKRES # Enable the deadlock resolver options INVARIANTS # Enable calls of extra sanity checking options INVARIANT_SUPPORT # Extra sanity checks of internal structures, required by INVARIANTS # options WITNESS # Enable checks to detect deadlocks and cycles # options WITNESS_SKIPSPIN # Don't run witness on spinlocks for speed options MALLOC_DEBUG_MAXZONES=8 # Separate malloc(9) zones # options EARLY_PRINTF # options VERBOSE_SYSINIT # Kernel dump features. options ZSTDIO # zstd-compressed kernel and user dumps # Pseudo devices. device crypto # core crypto support device loop # Network loopback device random # Entropy device device ether # Ethernet support device vlan # 802.1Q VLAN support device tun # Packet tunnel. device md # Memory "disks" device gif # IPv6 and IPv4 tunneling device firmware # firmware assist module # The `bpf' device enables the Berkeley Packet Filter. # Be aware of the administrative consequences of enabling this! # Note that 'bpf' is required for DHCP. device bpf # Berkeley packet filter options FDT