config RISCV_SBI_V01    bool "SBI v0.1 support"    default y    depends on RISCV_SBI    help      This config allows kernel to use SBI v0.1 APIs. This will be      deprecated in future once legacy M-mode software are no longer in use.

# set if we are running in S-mode and can use SBI callsconfig RISCV_SBI    bool    depends on !RISCV_M_MODE    default y

# set if we run in machine mode, cleared if we run in supervisor modeconfig RISCV_M_MODE    bool    default !MMU

config MMU    bool "MMU-based Paged Memory Management Support"    default y    help      Select if you want MMU-based virtualised addressing space      support by paged memory management. If unsure, say 'Y'.

static int __init early_sbi_setup(struct earlycon_device *device,                  const char *opt){    device->con->write = sbi_console_write;    return 0;}

static void sbi_console_write(struct console *con,                  const char *s, unsigned n){    struct earlycon_device *dev = con->data;    uart_console_write(&dev->port, s, n, sbi_putc);}

static void sbi_putc(struct uart_port *port, int c){    sbi_console_putchar(c);}

#ifdef CONFIG_RISCV_SBI_V01/** * sbi_console_putchar() - Writes given character to the console device. * @ch: The data to be written to the console. * * Return: None */void sbi_console_putchar(int ch){    sbi_ecall(SBI_EXT_0_1_CONSOLE_PUTCHAR, 0, ch, 0, 0, 0, 0, 0);}EXPORT_SYMBOL(sbi_console_putchar);

struct sbiret sbi_ecall(int ext, int fid, unsigned long arg0,            unsigned long arg1, unsigned long arg2,            unsigned long arg3, unsigned long arg4,            unsigned long arg5){    struct sbiret ret;
    register uintptr_t a0 asm ("a0") = (uintptr_t)(arg0);    register uintptr_t a1 asm ("a1") = (uintptr_t)(arg1);    register uintptr_t a2 asm ("a2") = (uintptr_t)(arg2);    register uintptr_t a3 asm ("a3") = (uintptr_t)(arg3);    register uintptr_t a4 asm ("a4") = (uintptr_t)(arg4);    register uintptr_t a5 asm ("a5") = (uintptr_t)(arg5);    register uintptr_t a6 asm ("a6") = (uintptr_t)(fid);    register uintptr_t a7 asm ("a7") = (uintptr_t)(ext);    asm volatile ("ecall"              : "+r" (a0), "+r" (a1)              : "r" (a2), "r" (a3), "r" (a4), "r" (a5), "r" (a6), "r" (a7)              : "memory");    ret.error = a0;    ret.value = a1;    return ret;}

config CMDLINE    string "Built-in kernel command line"    help      For most platforms, the arguments for the kernel's command line      are provided at run-time, during boot. However, there are cases      where either no arguments are being provided or the provided      arguments are insufficient or even invalid.
      When that occurs, it is possible to define a built-in command      line here and choose how the kernel should use it later on.

#define early_param(str, fn)                        \    __setup_param(str, fn, fn, 1)
#define __setup_param(str, unique_id, fn, early)            \    static const char __setup_str_##unique_id[] __initconst     \        __aligned(1) = str;                     \    static struct obs_kernel_param __setup_##unique_id      \        __used __section(".init.setup")             \        __attribute__((aligned((sizeof(long)))))        \        = { __setup_str_##unique_id, fn, early }

struct obs_kernel_param {    const char *str;    int (*setup_func)(char *);    int early;};

#define INIT_SETUP(initsetup_align)                 \        . = ALIGN(initsetup_align);             \        __setup_start = .;                  \        KEEP(*(.init.setup))                    \        __setup_end = .;
#define INIT_DATA_SECTION(initsetup_align)              \    .init.data : AT(ADDR(.init.data) - LOAD_OFFSET) {       \        INIT_DATA                       \        INIT_SETUP(initsetup_align)             \        INIT_CALLS                      \        CON_INITCALL                        \        INIT_RAM_FS                     \    }

static bool __init obsolete_checksetup(char *line){    const struct obs_kernel_param *p;    bool had_early_param = false;
    p = __setup_start;    do {        int n = strlen(p->str);        if (parameqn(line, p->str, n)) {            if (p->early) {                /* Already done in parse_early_param?                 * (Needs exact match on param part).                 * Keep iterating, as we can have early                 * params and __setups of same names 8( */                if (line[n] == '\0' || line[n] == '=')                    had_early_param = true;            } else if (!p->setup_func) {                pr_warn("Parameter %s is obsolete, ignored\n",                    p->str);                return true;            } else if (p->setup_func(line + n))                return true;        }        p++;    } while (p < __setup_end);    return had_early_param;}

#define _OF_EARLYCON_DECLARE(_name, compat, fn, unique_id)      \    static const struct earlycon_id unique_id           \         EARLYCON_USED_OR_UNUSED __initconst            \        = { .name = __stringify(_name),             \            .compatible = compat,               \            .setup = fn  };                 \    static const struct earlycon_id EARLYCON_USED_OR_UNUSED     \        __section("__earlycon_table")               \        * const __PASTE(__p, unique_id) = &unique_id
#define OF_EARLYCON_DECLARE(_name, compat, fn)              \    _OF_EARLYCON_DECLARE(_name, compat, fn,             \                 __UNIQUE_ID(__earlycon_##_name))#define EARLYCON_DECLARE(_name, fn) OF_EARLYCON_DECLARE(_name, "", fn)

struct earlycon_id {    char    name[15];    char    name_term;  /* In case compiler didn't '\0' term name */    char    compatible[128];    int (*setup)(struct earlycon_device *, const char *options);};

#ifdef CONFIG_SERIAL_EARLYCON#define EARLYCON_TABLE() . = ALIGN(8);              \             __earlycon_table = .;          \             KEEP(*(__earlycon_table))      \             __earlycon_table_end = .;#else#define EARLYCON_TABLE()#endif

int sbi_ecall_handler(struct sbi_trap_regs *regs){    int ret = 0;    struct sbi_ecall_extension *ext;    unsigned long extension_id = regs->a7;    unsigned long func_id = regs->a6;    struct sbi_trap_info trap = {0};    unsigned long out_val = 0;    bool is_0_1_spec = 0;
    ext = sbi_ecall_find_extension(extension_id);    if (ext && ext->handle) {        ret = ext->handle(extension_id, func_id,                  regs, &out_val, &trap);        if (extension_id >= SBI_EXT_0_1_SET_TIMER &&            extension_id <= SBI_EXT_0_1_SHUTDOWN)            is_0_1_spec = 1;    } else {        ret = SBI_ENOTSUPP;    }

int sbi_ecall_register_extension(struct sbi_ecall_extension *ext){    struct sbi_ecall_extension *t;
    if (!ext || (ext->extid_end < ext->extid_start) || !ext->handle)        return SBI_EINVAL;    sbi_list_for_each_entry(t, &ecall_exts_list, head) {        unsigned long start = t->extid_start;        unsigned long end = t->extid_end;        if (end < ext->extid_start || ext->extid_end < start)            /* no overlap */;        else            return SBI_EINVAL;    }    SBI_INIT_LIST_HEAD(&ext->head);    sbi_list_add_tail(&ext->head, &ecall_exts_list);    return 0;}

struct sbi_ecall_extension ecall_legacy = {    .extid_start = SBI_EXT_0_1_SET_TIMER,    .extid_end = SBI_EXT_0_1_SHUTDOWN,    .handle = sbi_ecall_legacy_handler,};

    case SBI_EXT_0_1_CONSOLE_PUTCHAR:        sbi_putc(regs->a0);        break;    case SBI_EXT_0_1_CONSOLE_GETCHAR:        ret = sbi_getc();        break;