From 1308a52debbcf8f967dfaec57f28a079261429e4 Mon Sep 17 00:00:00 2001 From: rwatson Date: Wed, 2 May 2012 08:10:15 +0000 Subject: Merge a rudimentary gxemul "oldtestmips" port. This consists almost entirely of one machdep file lifted from the MALTA port, as well as a low-level console and tty driver for the gxemul debugging console device (the emulators stdio). As with many low-level embedded and hypervisor console devices, it is polled only, so we drive TTY I/O from a callout; we are perhaps a bit too aware of the MIPS physical maps in order to attach the console before newbus comes to life. The sample kernel configuration depends on an MD-based root file system, which is not provided. However, any 64-bit, big-endian userspace image (such as one generated for MALTA) should work. This will hopefully be supplemented by additional device drivers for gxemul-specific hardware simulations from Juli Mallett. We have found oldtestmips quite useful for testing and improving aspects of the MIPS port, so it's worth supporting better in FreeBSD. Requested by: theraven, jmallett Sponsored by: DARPA, AFRL MFC after: 3 weeks --- sys/dev/gxemul/cons/gxemul_cons.c | 334 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 334 insertions(+) create mode 100644 sys/dev/gxemul/cons/gxemul_cons.c (limited to 'sys/dev/gxemul/cons') diff --git a/sys/dev/gxemul/cons/gxemul_cons.c b/sys/dev/gxemul/cons/gxemul_cons.c new file mode 100644 index 0000000..bb12058 --- /dev/null +++ b/sys/dev/gxemul/cons/gxemul_cons.c @@ -0,0 +1,334 @@ +/*- + * Copyright (c) 2011-2012 Robert N. M. Watson + * All rights reserved. + * + * This software was developed by SRI International and the University of + * Cambridge Computer Laboratory under DARPA/AFRL contract (FA8750-10-C-0237) + * ("CTSRD"), as part of the DARPA CRASH 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 +#include +#include +#include +#include +#include +#include + +#include + +#define GC_LOCK_INIT() mtx_init(&gc_lock, "gc_lock", NULL, MTX_SPIN) + +#define GC_LOCK() do { \ + if (!kdb_active) \ + mtx_lock_spin(&gc_lock); \ +} while (0) + +#define GC_LOCK_ASSERT() do { \ + if (!kdb_active) \ + mtx_assert(&gc_lock, MA_OWNED); \ +} while (0) + +#define GC_UNLOCK() do { \ + if (!kdb_active) \ + mtx_unlock_spin(&gc_lock); \ +} while (0) + + +static struct mtx gc_lock; + +/* + * Low-level console driver functions. + */ +static cn_probe_t gxemul_cons_cnprobe; +static cn_init_t gxemul_cons_cninit; +static cn_term_t gxemul_cons_cnterm; +static cn_getc_t gxemul_cons_cngetc; +static cn_putc_t gxemul_cons_cnputc; +static cn_grab_t gxemul_cons_cngrab; +static cn_ungrab_t gxemul_cons_cnungrab; + +/* + * TTY-level fields. + */ +static tsw_outwakeup_t gxemul_cons_outwakeup; + +static struct ttydevsw gxemul_cons_ttydevsw = { + .tsw_flags = TF_NOPREFIX, + .tsw_outwakeup = gxemul_cons_outwakeup, +}; + +static struct callout gxemul_cons_callout; +static u_int gxemul_cons_polltime = 10; +#ifdef KDB +static int gxemul_cons_alt_break_state; +#endif + +static void gxemul_cons_timeout(void *); + +/* + * I/O routines lifted from Deimos. + * + * XXXRW: Should be using FreeBSD's bus routines here, but they are not + * available until later in the boot. + */ +#define MIPS_XKPHYS_UNCACHED_BASE 0x9000000000000000 + +typedef uint64_t paddr_t; +typedef uint64_t vaddr_t; + +static inline vaddr_t +mips_phys_to_uncached(paddr_t phys) +{ + + return (phys | MIPS_XKPHYS_UNCACHED_BASE); +} + +static inline uint8_t +mips_ioread_uint8(vaddr_t vaddr) +{ + uint8_t v; + + __asm__ __volatile__ ("lbu %0, 0(%1)" : "=r" (v) : "r" (vaddr)); + return (v); +} + +static inline void +mips_iowrite_uint8(vaddr_t vaddr, uint8_t v) +{ + + __asm__ __volatile__ ("sb %0, 0(%1)" : : "r" (v), "r" (vaddr)); +} + +/* + * gxemul-specific constants. + */ +#define GXEMUL_CONS_BASE 0x10000000 /* gxemul console device. */ + +/* + * Routines for interacting with the gxemul test console. Programming details + * are a result of manually inspecting the source code for gxemul's + * dev_cons.cc and dev_cons.h. + * + * Offsets of I/O channels relative to the base. + */ +#define GXEMUL_PUTGETCHAR_OFF 0x00000000 +#define GXEMUL_CONS_HALT 0x00000010 + +/* + * One-byte buffer as we can't check whether the console is readable without + * actually reading from it. + */ +static char buffer_data; +static int buffer_valid; + +/* + * Low-level read and write routines. + */ +static inline uint8_t +gxemul_cons_data_read(void) +{ + + return (mips_ioread_uint8(mips_phys_to_uncached(GXEMUL_CONS_BASE + + GXEMUL_PUTGETCHAR_OFF))); +} + +static inline void +gxemul_cons_data_write(uint8_t v) +{ + + mips_iowrite_uint8(mips_phys_to_uncached(GXEMUL_CONS_BASE + + GXEMUL_PUTGETCHAR_OFF), v); +} + +static int +gxemul_cons_writable(void) +{ + + return (1); +} + +static int +gxemul_cons_readable(void) +{ + uint32_t v; + + GC_LOCK_ASSERT(); + + if (buffer_valid) + return (1); + v = gxemul_cons_data_read(); + if (v != 0) { + buffer_valid = 1; + buffer_data = v; + return (1); + } + return (0); +} + +static void +gxemul_cons_write(char ch) +{ + + GC_LOCK_ASSERT(); + + while (!gxemul_cons_writable()); + gxemul_cons_data_write(ch); +} + +static char +gxemul_cons_read(void) +{ + + GC_LOCK_ASSERT(); + + while (!gxemul_cons_readable()); + buffer_valid = 0; + return (buffer_data); +} + +/* + * Implementation of a FreeBSD low-level, polled console driver. + */ +static void +gxemul_cons_cnprobe(struct consdev *cp) +{ + + sprintf(cp->cn_name, "gxcons"); + cp->cn_pri = CN_NORMAL; +} + +static void +gxemul_cons_cninit(struct consdev *cp) +{ + + GC_LOCK_INIT(); +} + +static void +gxemul_cons_cnterm(struct consdev *cp) +{ + +} + +static int +gxemul_cons_cngetc(struct consdev *cp) +{ + int ret; + + GC_LOCK(); + ret = gxemul_cons_read(); + GC_UNLOCK(); + return (ret); +} + +static void +gxemul_cons_cnputc(struct consdev *cp, int c) +{ + + GC_LOCK(); + gxemul_cons_write(c); + GC_UNLOCK(); +} + +static void +gxemul_cons_cngrab(struct consdev *cp) +{ + +} + +static void +gxemul_cons_cnungrab(struct consdev *cp) +{ + +} + +CONSOLE_DRIVER(gxemul_cons); + +/* + * TTY-level functions for gxemul_cons. + */ +static void +gxemul_cons_ttyinit(void *unused) +{ + struct tty *tp; + + tp = tty_alloc(&gxemul_cons_ttydevsw, NULL); + tty_init_console(tp, 0); + tty_makedev(tp, NULL, "%s", "gxcons"); + callout_init(&gxemul_cons_callout, CALLOUT_MPSAFE); + callout_reset(&gxemul_cons_callout, gxemul_cons_polltime, + gxemul_cons_timeout, tp); + +} +SYSINIT(gxemul_cons_ttyinit, SI_SUB_CONFIGURE, SI_ORDER_MIDDLE, + gxemul_cons_ttyinit, NULL); + +static void +gxemul_cons_outwakeup(struct tty *tp) +{ + int len; + u_char ch; + + /* + * XXXRW: Would be nice not to do blocking writes to the console here, + * rescheduling on our timer tick if work remains to be done.. + */ + for (;;) { + len = ttydisc_getc(tp, &ch, sizeof(ch)); + if (len == 0) + break; + GC_LOCK(); + gxemul_cons_write(ch); + GC_UNLOCK(); + } +} + +static void +gxemul_cons_timeout(void *v) +{ + struct tty *tp; + int c; + + tp = v; + tty_lock(tp); + GC_LOCK(); + while (gxemul_cons_readable()) { + c = gxemul_cons_read(); + GC_UNLOCK(); +#ifdef KDB + kdb_alt_break(c, &gxemul_cons_alt_break_state); +#endif + ttydisc_rint(tp, c, 0); + GC_LOCK(); + } + GC_UNLOCK(); + ttydisc_rint_done(tp); + tty_unlock(tp); + callout_reset(&gxemul_cons_callout, gxemul_cons_polltime, + gxemul_cons_timeout, tp); +} -- cgit v1.1