OpenSBI debug console support

We add new sbi_ngets() which help us read characters into a physical memory location.

Signed-off-by Anup Patel <[email protected]>

---
 include/sbi/sbi_console.h |  2 ++
 lib/sbi/sbi_console.c     | 15 +++++++++++++++
 2 files changed, 17 insertions(+)

include/sbi/sbi_console.h +2 -0

index 1bdeeb9..660c239 100644
@@ -37,6 +37,8 @@ void sbi_nputs(const char *str, unsigned long len);
 
 void sbi_gets(char *s, int maxwidth, char endchar);
 
+unsigned long sbi_ngets(char *str, unsigned long len);
+
 int __printf(2, 3) sbi_sprintf(char *out, const char *format, ...);
 
 int __printf(3, 4) sbi_snprintf(char *out, u32 out_sz, const char *format, ...);

lib/sbi/sbi_console.c +15 -1

index a975708..3942320 100644
@@ -74,6 +74,21 @@ void sbi_gets(char *s, int maxwidth, char endchar)
        *retval = '\0';
 }
 
+unsigned long sbi_ngets(char *str, unsigned long len)
+{
+       int ch;
+       unsigned long i;
+
+       for (i = 0; i < len; i++) {
+               ch = sbi_getc();
+               if (ch < 0)
+                       break;
+               str[i] = ch;
+       }
+
+       return i;
+}
+
 #define PAD_RIGHT 1
 #define PAD_ZERO 2
 #define PAD_ALTERNATE 4
--

2.34.1

We add sbi_domain_check_addr_range() helper function to check whether a given address range is accessible under a particular domain.

Signed-off-by Anup Patel <[email protected]>

Reviewed-by Xiang W <[email protected]>

Reviewed-by Bin Meng <[email protected]>

---
 include/sbi/sbi_domain.h | 15 +++++++++
 lib/sbi/sbi_domain.c     | 69 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 84 insertions(+)

include/sbi/sbi_domain.h +15 -0

index 5553d21..4afcc37 100644
@@ -154,6 +154,21 @@ bool sbi_domain_check_addr(const struct sbi_domain *dom,
                           unsigned long addr, unsigned long mode,
                           unsigned long access_flags);
 
+/**
+ * Check whether we can access specified address range for given mode and
+ * memory region flags under a domain
+ * @param dom pointer to domain
+ * @param addr the start of the address range to be checked
+ * @param size the size of the address range to be checked
+ * @param mode the privilege mode of access
+ * @param access_flags bitmask of domain access types (enum sbi_domain_access)
+ * @return TRUE if access allowed otherwise FALSE
+ */
+bool sbi_domain_check_addr_range(const struct sbi_domain *dom,
+                                unsigned long addr, unsigned long size,
+                                unsigned long mode,
+                                unsigned long access_flags);
+
 /** Dump domain details on the console */
 void sbi_domain_dump(const struct sbi_domain *dom, const char *suffix);
 

lib/sbi/sbi_domain.c +69 -1

index 3205595..ab041b0 100644
@@ -198,6 +198,44 @@ static bool is_region_before(const struct sbi_domain_memregion *regA,
        return FALSE;
 }
 
+static const struct sbi_domain_memregion *find_region(
+                                               const struct sbi_domain *dom,
+                                               unsigned long addr)
+{
+       unsigned long rstart, rend;
+       struct sbi_domain_memregion *reg;
+
+       sbi_domain_for_each_memregion(dom, reg) {
+               rstart = reg->base;
+               rend = (reg->order < __riscv_xlen) ?
+                       rstart + ((1UL << reg->order) - 1) : -1UL;
+               if (rstart <= addr && addr <= rend)
+                       return reg;
+       }
+
+       return NULL;
+}
+
+static const struct sbi_domain_memregion *find_next_subset_region(
+                               const struct sbi_domain *dom,
+                               const struct sbi_domain_memregion *reg,
+                               unsigned long addr)
+{
+       struct sbi_domain_memregion *sreg, *ret = NULL;
+
+       sbi_domain_for_each_memregion(dom, sreg) {
+               if (sreg == reg || (sreg->base <= addr) ||
+                   !is_region_subset(sreg, reg))
+                       continue;
+
+               if (!ret || (sreg->base < ret->base) ||
+                   ((sreg->base == ret->base) && (sreg->order < ret->order)))
+                       ret = sreg;
+       }
+
+       return ret;
+}
+
 static int sanitize_domain(const struct sbi_platform *plat,
                           struct sbi_domain *dom)
 {

@@ -306,6 +344,37 @@ static int sanitize_domain(const struct sbi_platform *plat,
        return 0;
 }
 
+bool sbi_domain_check_addr_range(const struct sbi_domain *dom,
+                                unsigned long addr, unsigned long size,
+                                unsigned long mode,
+                                unsigned long access_flags)
+{
+       unsigned long max = addr + size;
+       const struct sbi_domain_memregion *reg, *sreg;
+
+       if (!dom)
+               return FALSE;
+
+       while (addr < max) {
+               reg = find_region(dom, addr);
+               if (!reg)
+                       return FALSE;
+
+               if (!sbi_domain_check_addr(dom, addr, mode, access_flags))
+                       return FALSE;
+
+               sreg = find_next_subset_region(dom, reg, addr);
+               if (sreg)
+                       addr = sreg->base;
+               else if (reg->order < __riscv_xlen)
+                       addr = reg->base + (1UL << reg->order);
+               else
+                       break;
+       }
+
+       return TRUE;
+}
+
 void sbi_domain_dump(const struct sbi_domain *dom, const char *suffix)
 {
        u32 i, k;
--

2.34.1

We implement SBI debug console extension as one of the replacement SBI extensions. This extension is only available when OpenSBI platform provides a console device to generic library.

Signed-off-by Anup Patel <[email protected]>

Reviewed-by Xiang W <[email protected]>

Reviewed-by Bin Meng <[email protected]>

---
 lib/sbi/Kconfig          |  4 +++
 lib/sbi/objects.mk       |  3 ++
 lib/sbi/sbi_ecall_dbcn.c | 69 ++++++++++++++++++++++++++++++++++++++++
 3 files changed, 76 insertions(+)
 create mode 100644 lib/sbi/sbi_ecall_dbcn.c

lib/sbi/Kconfig +4 -0

index df74bba..ef6728b 100644
@@ -26,6 +26,10 @@ config SBI_ECALL_PMU
        bool "Performance Monitoring Unit extension"
        default y
 
+config SBI_ECALL_DBCN
+       bool "Debug Console extension"
+       default y
+
 config SBI_ECALL_LEGACY
        bool "SBI v0.1 legacy extensions"
        default y

lib/sbi/objects.mk +3 -0

index c774ebb..319f38d 100644
@@ -37,6 +37,9 @@ libsbi-objs-$(CONFIG_SBI_ECALL_SRST) += sbi_ecall_srst.o
 carray-sbi_ecall_exts-$(CONFIG_SBI_ECALL_PMU) += ecall_pmu
 libsbi-objs-$(CONFIG_SBI_ECALL_PMU) += sbi_ecall_pmu.o
 
+carray-sbi_ecall_exts-$(CONFIG_SBI_ECALL_DBCN) += ecall_dbcn
+libsbi-objs-$(CONFIG_SBI_ECALL_DBCN) += sbi_ecall_dbcn.o
+
 carray-sbi_ecall_exts-$(CONFIG_SBI_ECALL_LEGACY) += ecall_legacy
 libsbi-objs-$(CONFIG_SBI_ECALL_LEGACY) += sbi_ecall_legacy.o
 

lib/sbi/sbi_ecall_dbcn.c new file +69 -1

new file mode 100644
index 0000000..8c6a728
@@ -0,0 +1,69 @@
+/*
+ * SPDX-License-Identifier: BSD-2-Clause
+ *
+ * Copyright (c) 2022 Ventana Micro Systems Inc.
+ *
+ * Authors:
+ *   Anup Patel <[email protected]>
+ */
+
+#include <sbi/sbi_console.h>
+#include <sbi/sbi_domain.h>
+#include <sbi/sbi_error.h>
+#include <sbi/sbi_ecall.h>
+#include <sbi/sbi_ecall_interface.h>
+#include <sbi/sbi_trap.h>
+#include <sbi/riscv_asm.h>
+
+static int sbi_ecall_dbcn_handler(unsigned long extid, unsigned long funcid,
+                                 const struct sbi_trap_regs *regs,
+                                 unsigned long *out_val,
+                                 struct sbi_trap_info *out_trap)
+{
+       ulong smode = (csr_read(CSR_MSTATUS) & MSTATUS_MPP) >>
+                       MSTATUS_MPP_SHIFT;
+
+       switch (funcid) {
+       case SBI_EXT_DBCN_CONSOLE_WRITE:
+       case SBI_EXT_DBCN_CONSOLE_READ:
+               /*
+                * On RV32, the M-mode can only access the first 4GB of
+                * the physical address space because M-mode does not have
+                * MMU to access full 34-bit physical address space.
+                *
+                * Based on above, we simply fail if the upper 32bits of
+                * the physical address (i.e. a2 register) is non-zero on
+                * RV32.
+                */
+#if __riscv_xlen == 32
+               if (regs->a2)
+                       return SBI_ERR_FAILED;
+#endif
+               if (!sbi_domain_check_addr_range(sbi_domain_thishart_ptr(),
+                                       regs->a1, regs->a0, smode,
+                                       SBI_DOMAIN_READ|SBI_DOMAIN_WRITE))
+                       return SBI_EINVALID_ADDR;
+               if (funcid == SBI_EXT_DBCN_CONSOLE_WRITE)
+                       sbi_nputs((const char *)regs->a1, regs->a0);
+               else
+                       *out_val = sbi_ngets((char *)regs->a1, regs->a0);
+               return 0;
+       default:
+               break;
+       }
+
+       return SBI_ENOTSUPP;
+}
+
+static int sbi_ecall_dbcn_probe(unsigned long extid, unsigned long *out_val)
+{
+       *out_val = (sbi_console_get_device()) ? 1 : 0;
+       return 0;
+}
+
+struct sbi_ecall_extension ecall_dbcn = {
+       .extid_start = SBI_EXT_DBCN,
+       .extid_end = SBI_EXT_DBCN,
+       .handle = sbi_ecall_dbcn_handler,
+       .probe = sbi_ecall_dbcn_probe,
+};
--

2.34.1

We add console_puts() callback in the console device which allows console drivers (such as semihosting) to implement a specialized way to output character string.

Signed-off-by Anup Patel <[email protected]>

Reviewed-by Xiang W <[email protected]>

Reviewed-by Bin Meng <[email protected]>

---
 include/sbi/sbi_console.h |  3 +++
 lib/sbi/sbi_console.c     | 19 ++++++++++++++-----
 2 files changed, 17 insertions(+), 5 deletions(-)

include/sbi/sbi_console.h +3 -0

index 660c239..8e95b9d 100644
@@ -19,6 +19,9 @@ struct sbi_console_device {
        /** Write a character to the console output */
        void (*console_putc)(char ch);
 
+       /** Write a character string to the console output */
+       void (*console_puts)(const char *str, unsigned long len);
+
        /** Read a character from the console input */
        int (*console_getc)(void);
 };

lib/sbi/sbi_console.c +14 -6

index 3942320..bf7c071 100644
@@ -12,6 +12,7 @@
 #include <sbi/sbi_hart.h>
 #include <sbi/sbi_platform.h>
 #include <sbi/sbi_scratch.h>
+#include <sbi/sbi_string.h>
 
 static const struct sbi_console_device *console_dev = NULL;
 static spinlock_t console_out_lock            = SPIN_LOCK_INITIALIZER;

@@ -44,9 +45,13 @@ void sbi_putc(char ch)
 void sbi_puts(const char *str)
 {
        spin_lock(&console_out_lock);
-       while (*str) {
-               sbi_putc(*str);
-               str++;
+       if (console_dev && console_dev->console_puts) {
+               console_dev->console_puts(str, sbi_strlen(str));
+       } else {
+               while (*str) {
+                       sbi_putc(*str);
+                       str++;
+               }
        }
        spin_unlock(&console_out_lock);
 }

@@ -56,8 +61,12 @@ void sbi_nputs(const char *str, unsigned long len)
        unsigned long i;
 
        spin_lock(&console_out_lock);
-       for (i = 0; i < len; i++)
-               sbi_putc(str[i]);
+       if (console_dev && console_dev->console_puts) {
+               console_dev->console_puts(str, len);
+       } else {
+               for (i = 0; i < len; i++)
+                       sbi_putc(str[i]);
+       }
        spin_unlock(&console_out_lock);
 }
 
--

2.34.1

We implement console_puts() for semihosting serial driver to speed-up semihosting based prints.

Signed-off-by Anup Patel <[email protected]>

Reviewed-by Xiang W <[email protected]>

Reviewed-by Bin Meng <[email protected]>

---
 lib/utils/serial/semihosting.c | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

lib/utils/serial/semihosting.c +33 -1

index 86fa296..773b75e 100644
@@ -15,6 +15,7 @@
 
 #define SYSOPEN     0x01
 #define SYSWRITEC   0x03
+#define SYSWRITE    0x05
 #define SYSREAD     0x06
 #define SYSREADC    0x07
 #define SYSERRNO       0x13

@@ -93,6 +94,7 @@ static int semihosting_errno(void)
 }
 
 static int semihosting_infd = SBI_ENODEV;
+static int semihosting_outfd = SBI_ENODEV;
 
 static long semihosting_open(const char *fname, enum semihosting_open_mode mode)
 {

@@ -141,6 +143,21 @@ static long semihosting_read(long fd, void *memp, size_t len)
        return len - ret;
 }
 
+static long semihosting_write(long fd, const void *memp, size_t len)
+{
+       long ret;
+       struct semihosting_rdwr_s write;
+
+       write.fd = fd;
+       write.memp = (void *)memp;
+       write.len = len;
+
+       ret = semihosting_trap(SYSWRITE, &write);
+       if (ret < 0)
+               return semihosting_errno();
+       return len - ret;
+}
+
 /* clang-format on */
 
 static void semihosting_putc(char ch)

@@ -148,6 +165,20 @@ static void semihosting_putc(char ch)
        semihosting_trap(SYSWRITEC, &ch);
 }
 
+static void semihosting_puts(const char *str, unsigned long len)
+{
+       char ch;
+       unsigned long i;
+
+       if (semihosting_outfd < 0) {
+               for (i = 0; i < len; i++) {
+                       ch = str[i];
+                       semihosting_trap(SYSWRITEC, &ch);
+               }
+       } else
+               semihosting_write(semihosting_outfd, str, len);
+}
+
 static int semihosting_getc(void)
 {
        char ch = 0;

@@ -165,12 +196,14 @@ static int semihosting_getc(void)
 static struct sbi_console_device semihosting_console = {
        .name = "semihosting",
        .console_putc = semihosting_putc,
+       .console_puts = semihosting_puts,
        .console_getc = semihosting_getc
 };
 
 int semihosting_init(void)
 {
        semihosting_infd = semihosting_open(":tt", MODE_READ);
+       semihosting_outfd = semihosting_open(":tt", MODE_WRITE);
 
        sbi_console_set_device(&semihosting_console);
 
--

2.34.1