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