arch/riscv/lib/sbi.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * SBI initialilization and all extension implementation.
   4  *
   5  * Copyright (c) 2020 Western Digital Corporation or its affiliates.
   6  *
   7  * Taken from Linux arch/riscv/kernel/sbi.c
   8  */
   9
  10 #include <common.h>
  11 #include <asm/encoding.h>
  12 #include <asm/sbi.h>
  13
  14 /* default SBI version is 0.1 */
  15 unsigned long sbi_spec_version = SBI_SPEC_VERSION_DEFAULT;
  16
  17 struct sbiret sbi_ecall(int ext, int fid, unsigned long arg0,
  18                         unsigned long arg1, unsigned long arg2,
  19                         unsigned long arg3, unsigned long arg4,
  20                         unsigned long arg5)
  21 {
  22         struct sbiret ret;
  23
  24         register uintptr_t a0 asm ("a0") = (uintptr_t)(arg0);
  25         register uintptr_t a1 asm ("a1") = (uintptr_t)(arg1);
  26         register uintptr_t a2 asm ("a2") = (uintptr_t)(arg2);
  27         register uintptr_t a3 asm ("a3") = (uintptr_t)(arg3);
  28         register uintptr_t a4 asm ("a4") = (uintptr_t)(arg4);
  29         register uintptr_t a5 asm ("a5") = (uintptr_t)(arg5);
  30         register uintptr_t a6 asm ("a6") = (uintptr_t)(fid);
  31         register uintptr_t a7 asm ("a7") = (uintptr_t)(ext);
  32         asm volatile ("ecall"
  33                       : "+r" (a0), "+r" (a1)
  34                       : "r" (a2), "r" (a3), "r" (a4), "r" (a5), "r" (a6), "r" (a7)
  35                       : "memory");
  36         ret.error = a0;
  37         ret.value = a1;
  38
  39         return ret;
  40 }
  41
  42 #ifdef CONFIG_SBI_V01
  43
  44 /**
  45  * sbi_console_putchar() - Writes given character to the console device.
  46  * @ch: The data to be written to the console.
  47  *
  48  * Return: None
  49  */
  50 void sbi_console_putchar(int ch)
  51 {
  52         sbi_ecall(SBI_EXT_0_1_CONSOLE_PUTCHAR, 0, ch, 0, 0, 0, 0, 0);
  53 }
  54
  55 /**
  56  * sbi_console_getchar() - Reads a byte from console device.
  57  *
  58  * Returns the value read from console.
  59  */
  60 int sbi_console_getchar(void)
  61 {
  62         struct sbiret ret;
  63
  64         ret = sbi_ecall(SBI_EXT_0_1_CONSOLE_GETCHAR, 0, 0, 0, 0, 0, 0, 0);
  65
  66         return ret.error;
  67 }
  68
  69 /**
  70  * sbi_clear_ipi() - Clear any pending IPIs for the calling hart.
  71  *
  72  * Return: None
  73  */
  74 void sbi_clear_ipi(void)
  75 {
  76         sbi_ecall(SBI_EXT_0_1_CLEAR_IPI, 0, 0, 0, 0, 0, 0, 0);
  77 }
  78
  79 /**
  80  * sbi_shutdown() - Remove all the harts from executing supervisor code.
  81  *
  82  * Return: None
  83  */
  84 void sbi_shutdown(void)
  85 {
  86         sbi_ecall(SBI_EXT_0_1_SHUTDOWN, 0, 0, 0, 0, 0, 0, 0);
  87 }
  88
  89 #endif /* CONFIG_SBI_V01 */
  90
  91 /**
  92  * sbi_set_timer() - Program the timer for next timer event.
  93  * @stime_value: The value after which next timer event should fire.
  94  *
  95  * Return: None
  96  */
  97 void sbi_set_timer(uint64_t stime_value)
  98 {
  99 #if __riscv_xlen == 32
 100         sbi_ecall(SBI_EXT_SET_TIMER, SBI_FID_SET_TIMER, stime_value,
 101                   stime_value >> 32, 0, 0, 0, 0);
 102 #else
 103         sbi_ecall(SBI_EXT_SET_TIMER, SBI_FID_SET_TIMER, stime_value,
 104                   0, 0, 0, 0, 0);
 105 #endif
 106 }
 107
 108 /**
 109  * sbi_send_ipi() - Send an IPI to any hart.
 110  * @hart_mask: A cpu mask containing all the target harts.
 111  *
 112  * Return: None
 113  */
 114 void sbi_send_ipi(const unsigned long *hart_mask)
 115 {
 116         sbi_ecall(SBI_EXT_SEND_IPI, SBI_FID_SEND_IPI, (unsigned long)hart_mask,
 117                   0, 0, 0, 0, 0);
 118 }
 119
 120 /**
 121  * sbi_remote_fence_i() - Execute FENCE.I instruction on given remote harts.
 122  * @hart_mask: A cpu mask containing all the target harts.
 123  *
 124  * Return: None
 125  */
 126 void sbi_remote_fence_i(const unsigned long *hart_mask)
 127 {
 128         sbi_ecall(SBI_EXT_REMOTE_FENCE_I, SBI_FID_REMOTE_FENCE_I,
 129                   (unsigned long)hart_mask, 0, 0, 0, 0, 0);
 130 }
 131
 132 /**
 133  * sbi_remote_sfence_vma() - Execute SFENCE.VMA instructions on given remote
 134  *                           harts for the specified virtual address range.
 135  * @hart_mask: A cpu mask containing all the target harts.
 136  * @start: Start of the virtual address
 137  * @size: Total size of the virtual address range.
 138  *
 139  * Return: None
 140  */
 141 void sbi_remote_sfence_vma(const unsigned long *hart_mask,
 142                            unsigned long start,
 143                            unsigned long size)
 144 {
 145         sbi_ecall(SBI_EXT_REMOTE_SFENCE_VMA, SBI_FID_REMOTE_SFENCE_VMA,
 146                   (unsigned long)hart_mask, start, size, 0, 0, 0);
 147 }
 148
 149 /**
 150  * sbi_remote_sfence_vma_asid() - Execute SFENCE.VMA instructions on given
 151  * remote harts for a virtual address range belonging to a specific ASID.
 152  *
 153  * @hart_mask: A cpu mask containing all the target harts.
 154  * @start: Start of the virtual address
 155  * @size: Total size of the virtual address range.
 156  * @asid: The value of address space identifier (ASID).
 157  *
 158  * Return: None
 159  */
 160 void sbi_remote_sfence_vma_asid(const unsigned long *hart_mask,
 161                                 unsigned long start,
 162                                 unsigned long size,
 163                                 unsigned long asid)
 164 {
 165         sbi_ecall(SBI_EXT_REMOTE_SFENCE_VMA_ASID,
 166                   SBI_FID_REMOTE_SFENCE_VMA_ASID,
 167                   (unsigned long)hart_mask, start, size, asid, 0, 0);
 168 }
 169
 170 /**
 171  * sbi_probe_extension() - Check if an SBI extension ID is supported or not.
 172  * @extid: The extension ID to be probed.
 173  *
 174  * Return: Extension specific nonzero value f yes, -ENOTSUPP otherwise.
 175  */
 176 int sbi_probe_extension(int extid)
 177 {
 178         struct sbiret ret;
 179
 180         ret = sbi_ecall(SBI_EXT_BASE, SBI_EXT_BASE_PROBE_EXT, extid,
 181                         0, 0, 0, 0, 0);
 182         if (!ret.error)
 183                 if (ret.value)
 184                         return ret.value;
 185
 186         return -ENOTSUPP;
 187 }