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 <errno.h>
11 #include <asm/encoding.h>
12 #include <asm/sbi.h>
13
sbi_ecall(int ext,int fid,unsigned long arg0,unsigned long arg1,unsigned long arg2,unsigned long arg3,unsigned long arg4,unsigned long arg5)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 */
sbi_set_timer(uint64_t stime_value)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 */
sbi_get_spec_version(void)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 */
sbi_get_impl_id(void)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_get_impl_version() - get SBI implementation version
94 *
95 * @version: pointer to receive version
96 * Return: 0 on success, -ENOTSUPP otherwise
97 */
sbi_get_impl_version(long * version)98 int sbi_get_impl_version(long *version)
99 {
100 struct sbiret ret;
101
102 ret = sbi_ecall(SBI_EXT_BASE, SBI_EXT_BASE_GET_IMP_VERSION,
103 0, 0, 0, 0, 0, 0);
104 if (ret.error)
105 return -ENOTSUPP;
106 if (version)
107 *version = ret.value;
108 return 0;
109 }
110
111 /**
112 * sbi_probe_extension() - Check if an SBI extension ID is supported or not.
113 * @extid: The extension ID to be probed.
114 *
115 * Return: Extension specific nonzero value f yes, -ENOTSUPP otherwise.
116 */
sbi_probe_extension(int extid)117 int sbi_probe_extension(int extid)
118 {
119 struct sbiret ret;
120
121 ret = sbi_ecall(SBI_EXT_BASE, SBI_EXT_BASE_PROBE_EXT, extid,
122 0, 0, 0, 0, 0);
123 if (!ret.error)
124 if (ret.value)
125 return ret.value;
126
127 return -ENOTSUPP;
128 }
129
130 /**
131 * sbi_get_mvendorid() - get machine vendor ID
132 *
133 * @mimpid: on return machine vendor ID
134 * Return: 0 on success
135 */
sbi_get_mvendorid(long * mvendorid)136 int sbi_get_mvendorid(long *mvendorid)
137 {
138 struct sbiret ret;
139
140 ret = sbi_ecall(SBI_EXT_BASE, SBI_EXT_BASE_GET_MVENDORID,
141 0, 0, 0, 0, 0, 0);
142 if (ret.error)
143 return -ENOTSUPP;
144
145 if (mvendorid)
146 *mvendorid = ret.value;
147
148 return 0;
149 }
150
151 /**
152 * sbi_get_marchid() - get machine architecture ID
153 *
154 * @mimpid: on return machine architecture ID
155 * Return: 0 on success
156 */
sbi_get_marchid(long * marchid)157 int sbi_get_marchid(long *marchid)
158 {
159 struct sbiret ret;
160
161 ret = sbi_ecall(SBI_EXT_BASE, SBI_EXT_BASE_GET_MARCHID,
162 0, 0, 0, 0, 0, 0);
163
164 if (ret.error)
165 return -ENOTSUPP;
166
167 if (marchid)
168 *marchid = ret.value;
169
170 return 0;
171 }
172
173 /**
174 * sbi_get_mimpid() - get machine implementation ID
175 *
176 * @mimpid: on return machine implementation ID
177 * Return: 0 on success
178 */
sbi_get_mimpid(long * mimpid)179 int sbi_get_mimpid(long *mimpid)
180 {
181 struct sbiret ret;
182
183 ret = sbi_ecall(SBI_EXT_BASE, SBI_EXT_BASE_GET_MIMPID,
184 0, 0, 0, 0, 0, 0);
185
186 if (ret.error)
187 return -ENOTSUPP;
188
189 if (mimpid)
190 *mimpid = ret.value;
191
192 return 0;
193 }
194
195 /**
196 * sbi_srst_reset() - invoke system reset extension
197 *
198 * @type: type of reset
199 * @reason: reason for reset
200 */
sbi_srst_reset(unsigned long type,unsigned long reason)201 void sbi_srst_reset(unsigned long type, unsigned long reason)
202 {
203 sbi_ecall(SBI_EXT_SRST, SBI_EXT_SRST_RESET, type, reason,
204 0, 0, 0, 0);
205 }
206
207 /**
208 * sbi_dbcn_write_byte() - write byte to debug console
209 *
210 * @ch: byte to be written
211 * Return: SBI error code (SBI_SUCCESS = 0 on success)
212 */
sbi_dbcn_write_byte(unsigned char ch)213 int sbi_dbcn_write_byte(unsigned char ch)
214 {
215 struct sbiret ret;
216
217 ret = sbi_ecall(SBI_EXT_DBCN,
218 SBI_EXT_DBCN_CONSOLE_WRITE_BYTE,
219 ch, 0, 0, 0, 0, 0);
220 return ret.error;
221 }
222
223 #ifdef CONFIG_SBI_V01
224
225 /**
226 * sbi_console_putchar() - Writes given character to the console device.
227 * @ch: The data to be written to the console.
228 *
229 * Return: None
230 */
sbi_console_putchar(int ch)231 void sbi_console_putchar(int ch)
232 {
233 sbi_ecall(SBI_EXT_0_1_CONSOLE_PUTCHAR, 0, ch, 0, 0, 0, 0, 0);
234 }
235
236 /**
237 * sbi_console_getchar() - Reads a byte from console device.
238 *
239 * Returns the value read from console.
240 */
sbi_console_getchar(void)241 int sbi_console_getchar(void)
242 {
243 struct sbiret ret;
244
245 ret = sbi_ecall(SBI_EXT_0_1_CONSOLE_GETCHAR, 0, 0, 0, 0, 0, 0, 0);
246
247 return ret.error;
248 }
249
250 /**
251 * sbi_clear_ipi() - Clear any pending IPIs for the calling hart.
252 *
253 * Return: None
254 */
sbi_clear_ipi(void)255 void sbi_clear_ipi(void)
256 {
257 sbi_ecall(SBI_EXT_0_1_CLEAR_IPI, 0, 0, 0, 0, 0, 0, 0);
258 }
259
260 /**
261 * sbi_shutdown() - Remove all the harts from executing supervisor code.
262 *
263 * Return: None
264 */
sbi_shutdown(void)265 void sbi_shutdown(void)
266 {
267 sbi_ecall(SBI_EXT_0_1_SHUTDOWN, 0, 0, 0, 0, 0, 0, 0);
268 }
269
270 /**
271 * sbi_send_ipi() - Send an IPI to any hart.
272 * @hart_mask: A cpu mask containing all the target harts.
273 *
274 * Return: None
275 */
sbi_send_ipi(const unsigned long * hart_mask)276 void sbi_send_ipi(const unsigned long *hart_mask)
277 {
278 sbi_ecall(SBI_EXT_SEND_IPI, SBI_FID_SEND_IPI, (unsigned long)hart_mask,
279 0, 0, 0, 0, 0);
280 }
281
282 /**
283 * sbi_remote_fence_i() - Execute FENCE.I instruction on given remote harts.
284 * @hart_mask: A cpu mask containing all the target harts.
285 *
286 * Return: None
287 */
sbi_remote_fence_i(const unsigned long * hart_mask)288 void sbi_remote_fence_i(const unsigned long *hart_mask)
289 {
290 sbi_ecall(SBI_EXT_REMOTE_FENCE_I, SBI_FID_REMOTE_FENCE_I,
291 (unsigned long)hart_mask, 0, 0, 0, 0, 0);
292 }
293
294 /**
295 * sbi_remote_sfence_vma() - Execute SFENCE.VMA instructions on given remote
296 * harts for the specified virtual address range.
297 * @hart_mask: A cpu mask containing all the target harts.
298 * @start: Start of the virtual address
299 * @size: Total size of the virtual address range.
300 *
301 * Return: None
302 */
sbi_remote_sfence_vma(const unsigned long * hart_mask,unsigned long start,unsigned long size)303 void sbi_remote_sfence_vma(const unsigned long *hart_mask,
304 unsigned long start,
305 unsigned long size)
306 {
307 sbi_ecall(SBI_EXT_REMOTE_SFENCE_VMA, SBI_FID_REMOTE_SFENCE_VMA,
308 (unsigned long)hart_mask, start, size, 0, 0, 0);
309 }
310
311 /**
312 * sbi_remote_sfence_vma_asid() - Execute SFENCE.VMA instructions on given
313 * remote harts for a virtual address range belonging to a specific ASID.
314 *
315 * @hart_mask: A cpu mask containing all the target harts.
316 * @start: Start of the virtual address
317 * @size: Total size of the virtual address range.
318 * @asid: The value of address space identifier (ASID).
319 *
320 * Return: None
321 */
sbi_remote_sfence_vma_asid(const unsigned long * hart_mask,unsigned long start,unsigned long size,unsigned long asid)322 void sbi_remote_sfence_vma_asid(const unsigned long *hart_mask,
323 unsigned long start,
324 unsigned long size,
325 unsigned long asid)
326 {
327 sbi_ecall(SBI_EXT_REMOTE_SFENCE_VMA_ASID,
328 SBI_FID_REMOTE_SFENCE_VMA_ASID,
329 (unsigned long)hart_mask, start, size, asid, 0, 0);
330 }
331
332 #endif /* CONFIG_SBI_V01 */
333