1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * SBI verification 4 * 5 * Copyright (C) 2023, Ventana Micro Systems Inc., Andrew Jones <ajones@ventanamicro.com> 6 */ 7 #include <libcflat.h> 8 #include <alloc_page.h> 9 #include <stdlib.h> 10 #include <string.h> 11 #include <limits.h> 12 #include <vmalloc.h> 13 #include <memregions.h> 14 #include <asm/barrier.h> 15 #include <asm/csr.h> 16 #include <asm/delay.h> 17 #include <asm/io.h> 18 #include <asm/mmu.h> 19 #include <asm/processor.h> 20 #include <asm/sbi.h> 21 #include <asm/smp.h> 22 #include <asm/timer.h> 23 24 #define HIGH_ADDR_BOUNDARY ((phys_addr_t)1 << 32) 25 26 static void help(void) 27 { 28 puts("Test SBI\n"); 29 puts("An environ must be provided where expected values are given.\n"); 30 } 31 32 static struct sbiret sbi_base(int fid, unsigned long arg0) 33 { 34 return sbi_ecall(SBI_EXT_BASE, fid, arg0, 0, 0, 0, 0, 0); 35 } 36 37 static struct sbiret sbi_dbcn_write(unsigned long num_bytes, unsigned long base_addr_lo, 38 unsigned long base_addr_hi) 39 { 40 return sbi_ecall(SBI_EXT_DBCN, SBI_EXT_DBCN_CONSOLE_WRITE, 41 num_bytes, base_addr_lo, base_addr_hi, 0, 0, 0); 42 } 43 44 static struct sbiret sbi_dbcn_write_byte(uint8_t byte) 45 { 46 return sbi_ecall(SBI_EXT_DBCN, SBI_EXT_DBCN_CONSOLE_WRITE_BYTE, byte, 0, 0, 0, 0, 0); 47 } 48 49 static void split_phys_addr(phys_addr_t paddr, unsigned long *hi, unsigned long *lo) 50 { 51 *lo = (unsigned long)paddr; 52 *hi = 0; 53 if (__riscv_xlen == 32) 54 *hi = (unsigned long)(paddr >> 32); 55 } 56 57 static bool check_addr(phys_addr_t start, phys_addr_t size) 58 { 59 struct mem_region *r = memregions_find(start); 60 return r && r->end - start >= size && r->flags == MR_F_UNUSED; 61 } 62 63 static phys_addr_t get_highest_addr(void) 64 { 65 phys_addr_t highest_end = 0; 66 struct mem_region *r; 67 68 for (r = mem_regions; r->end; ++r) { 69 if (r->end > highest_end) 70 highest_end = r->end; 71 } 72 73 return highest_end - 1; 74 } 75 76 static bool env_or_skip(const char *env) 77 { 78 if (!getenv(env)) { 79 report_skip("missing %s environment variable", env); 80 return false; 81 } 82 83 return true; 84 } 85 86 static void gen_report(struct sbiret *ret, 87 long expected_error, long expected_value) 88 { 89 bool check_error = ret->error == expected_error; 90 bool check_value = ret->value == expected_value; 91 92 if (!check_error || !check_value) 93 report_info("expected (error: %ld, value: %ld), received: (error: %ld, value %ld)", 94 expected_error, expected_value, ret->error, ret->value); 95 96 report(check_error, "expected sbi.error"); 97 report(check_value, "expected sbi.value"); 98 } 99 100 static void check_base(void) 101 { 102 struct sbiret ret; 103 long expected; 104 105 report_prefix_push("base"); 106 107 ret = sbi_base(SBI_EXT_BASE_GET_SPEC_VERSION, 0); 108 if (ret.error || ret.value < 2) { 109 report_skip("SBI spec version 0.2 or higher required"); 110 return; 111 } 112 113 report_prefix_push("spec_version"); 114 if (env_or_skip("SBI_SPEC_VERSION")) { 115 expected = (long)strtoul(getenv("SBI_SPEC_VERSION"), NULL, 0); 116 gen_report(&ret, 0, expected); 117 } 118 report_prefix_pop(); 119 120 report_prefix_push("impl_id"); 121 if (env_or_skip("SBI_IMPL_ID")) { 122 expected = (long)strtoul(getenv("SBI_IMPL_ID"), NULL, 0); 123 ret = sbi_base(SBI_EXT_BASE_GET_IMP_ID, 0); 124 gen_report(&ret, 0, expected); 125 } 126 report_prefix_pop(); 127 128 report_prefix_push("impl_version"); 129 if (env_or_skip("SBI_IMPL_VERSION")) { 130 expected = (long)strtoul(getenv("SBI_IMPL_VERSION"), NULL, 0); 131 ret = sbi_base(SBI_EXT_BASE_GET_IMP_VERSION, 0); 132 gen_report(&ret, 0, expected); 133 } 134 report_prefix_pop(); 135 136 report_prefix_push("probe_ext"); 137 expected = getenv("SBI_PROBE_EXT") ? (long)strtoul(getenv("SBI_PROBE_EXT"), NULL, 0) : 1; 138 ret = sbi_base(SBI_EXT_BASE_PROBE_EXT, SBI_EXT_BASE); 139 gen_report(&ret, 0, expected); 140 report_prefix_push("unavailable"); 141 ret = sbi_base(SBI_EXT_BASE_PROBE_EXT, 0xb000000); 142 gen_report(&ret, 0, 0); 143 report_prefix_popn(2); 144 145 report_prefix_push("mvendorid"); 146 if (env_or_skip("MVENDORID")) { 147 expected = (long)strtoul(getenv("MVENDORID"), NULL, 0); 148 assert(__riscv_xlen == 32 || !(expected >> 32)); 149 ret = sbi_base(SBI_EXT_BASE_GET_MVENDORID, 0); 150 gen_report(&ret, 0, expected); 151 } 152 report_prefix_pop(); 153 154 report_prefix_push("marchid"); 155 if (env_or_skip("MARCHID")) { 156 expected = (long)strtoul(getenv("MARCHID"), NULL, 0); 157 ret = sbi_base(SBI_EXT_BASE_GET_MARCHID, 0); 158 gen_report(&ret, 0, expected); 159 } 160 report_prefix_pop(); 161 162 report_prefix_push("mimpid"); 163 if (env_or_skip("MIMPID")) { 164 expected = (long)strtoul(getenv("MIMPID"), NULL, 0); 165 ret = sbi_base(SBI_EXT_BASE_GET_MIMPID, 0); 166 gen_report(&ret, 0, expected); 167 } 168 report_prefix_popn(2); 169 } 170 171 struct timer_info { 172 bool timer_works; 173 bool mask_timer_irq; 174 bool timer_irq_set; 175 bool timer_irq_cleared; 176 unsigned long timer_irq_count; 177 }; 178 179 static struct timer_info timer_info; 180 181 static bool timer_irq_pending(void) 182 { 183 return csr_read(CSR_SIP) & IP_TIP; 184 } 185 186 static void timer_irq_handler(struct pt_regs *regs) 187 { 188 timer_info.timer_works = true; 189 190 if (timer_info.timer_irq_count < ULONG_MAX) 191 ++timer_info.timer_irq_count; 192 193 if (timer_irq_pending()) 194 timer_info.timer_irq_set = true; 195 196 if (timer_info.mask_timer_irq) 197 timer_irq_disable(); 198 else 199 sbi_set_timer(ULONG_MAX); 200 201 if (!timer_irq_pending()) 202 timer_info.timer_irq_cleared = true; 203 } 204 205 static void timer_check_set_timer(bool mask_timer_irq) 206 { 207 struct sbiret ret; 208 unsigned long begin, end, duration; 209 const char *mask_test_str = mask_timer_irq ? " for mask irq test" : ""; 210 unsigned long d = getenv("SBI_TIMER_DELAY") ? strtol(getenv("SBI_TIMER_DELAY"), NULL, 0) : 200000; 211 unsigned long margin = getenv("SBI_TIMER_MARGIN") ? strtol(getenv("SBI_TIMER_MARGIN"), NULL, 0) : 200000; 212 213 d = usec_to_cycles(d); 214 margin = usec_to_cycles(margin); 215 216 timer_info = (struct timer_info){ .mask_timer_irq = mask_timer_irq }; 217 begin = timer_get_cycles(); 218 ret = sbi_set_timer(begin + d); 219 220 report(!ret.error, "set timer%s", mask_test_str); 221 if (ret.error) 222 report_info("set timer%s failed with %ld\n", mask_test_str, ret.error); 223 224 while ((end = timer_get_cycles()) <= (begin + d + margin) && !timer_info.timer_works) 225 cpu_relax(); 226 227 report(timer_info.timer_works, "timer interrupt received%s", mask_test_str); 228 report(timer_info.timer_irq_set, "pending timer interrupt bit set in irq handler%s", mask_test_str); 229 230 if (!mask_timer_irq) { 231 report(timer_info.timer_irq_set && timer_info.timer_irq_cleared, 232 "pending timer interrupt bit cleared by setting timer to -1"); 233 } 234 235 if (timer_info.timer_works) { 236 duration = end - begin; 237 report(duration >= d && duration <= (d + margin), "timer delay honored%s", mask_test_str); 238 } 239 240 report(timer_info.timer_irq_count == 1, "timer interrupt received exactly once%s", mask_test_str); 241 } 242 243 static void check_time(void) 244 { 245 bool pending; 246 247 report_prefix_push("time"); 248 249 if (!sbi_probe(SBI_EXT_TIME)) { 250 report_skip("time extension not available"); 251 report_prefix_pop(); 252 return; 253 } 254 255 report_prefix_push("set_timer"); 256 257 install_irq_handler(IRQ_S_TIMER, timer_irq_handler); 258 local_irq_enable(); 259 timer_irq_enable(); 260 261 timer_check_set_timer(false); 262 263 if (csr_read(CSR_SIE) & IE_TIE) 264 timer_check_set_timer(true); 265 else 266 report_skip("timer irq enable bit is not writable, skipping mask irq test"); 267 268 timer_irq_disable(); 269 sbi_set_timer(0); 270 pending = timer_irq_pending(); 271 report(pending, "timer immediately pending by setting timer to 0"); 272 sbi_set_timer(ULONG_MAX); 273 if (pending) 274 report(!timer_irq_pending(), "pending timer cleared while masked"); 275 else 276 report_skip("timer is not pending, skipping timer cleared while masked test"); 277 278 local_irq_disable(); 279 install_irq_handler(IRQ_S_TIMER, NULL); 280 281 report_prefix_popn(2); 282 } 283 284 #define DBCN_WRITE_TEST_STRING "DBCN_WRITE_TEST_STRING\n" 285 #define DBCN_WRITE_BYTE_TEST_BYTE ((u8)'a') 286 287 static void dbcn_write_test(const char *s, unsigned long num_bytes, bool xfail) 288 { 289 unsigned long base_addr_lo, base_addr_hi; 290 phys_addr_t paddr = virt_to_phys((void *)s); 291 int num_calls = 0; 292 struct sbiret ret; 293 294 split_phys_addr(paddr, &base_addr_hi, &base_addr_lo); 295 296 do { 297 ret = sbi_dbcn_write(num_bytes, base_addr_lo, base_addr_hi); 298 num_bytes -= ret.value; 299 paddr += ret.value; 300 split_phys_addr(paddr, &base_addr_hi, &base_addr_lo); 301 num_calls++; 302 } while (num_bytes != 0 && ret.error == SBI_SUCCESS); 303 304 report_xfail(xfail, ret.error == SBI_SUCCESS, "write success (error=%ld)", ret.error); 305 report_info("%d sbi calls made", num_calls); 306 } 307 308 static void dbcn_high_write_test(const char *s, unsigned long num_bytes, 309 phys_addr_t page_addr, size_t page_offset, 310 bool highmem_supported) 311 { 312 int nr_pages = page_offset ? 2 : 1; 313 void *vaddr; 314 315 if (page_addr != PAGE_ALIGN(page_addr) || page_addr + PAGE_SIZE < HIGH_ADDR_BOUNDARY || 316 !check_addr(page_addr, nr_pages * PAGE_SIZE)) { 317 report_skip("Memory above 4G required"); 318 return; 319 } 320 321 vaddr = alloc_vpages(nr_pages); 322 323 for (int i = 0; i < nr_pages; ++i) 324 install_page(current_pgtable(), page_addr + i * PAGE_SIZE, vaddr + i * PAGE_SIZE); 325 memcpy(vaddr + page_offset, DBCN_WRITE_TEST_STRING, num_bytes); 326 dbcn_write_test(vaddr + page_offset, num_bytes, !highmem_supported); 327 } 328 329 /* 330 * Only the write functionality is tested here. There's no easy way to 331 * non-interactively test SBI_EXT_DBCN_CONSOLE_READ. 332 */ 333 static void check_dbcn(void) 334 { 335 unsigned long num_bytes = strlen(DBCN_WRITE_TEST_STRING); 336 unsigned long base_addr_lo, base_addr_hi; 337 bool do_invalid_addr = false; 338 bool highmem_supported = true; 339 phys_addr_t paddr; 340 struct sbiret ret; 341 const char *tmp; 342 char *buf; 343 344 report_prefix_push("dbcn"); 345 346 if (!sbi_probe(SBI_EXT_DBCN)) { 347 report_skip("DBCN extension unavailable"); 348 report_prefix_pop(); 349 return; 350 } 351 352 report_prefix_push("write"); 353 354 dbcn_write_test(DBCN_WRITE_TEST_STRING, num_bytes, false); 355 356 assert(num_bytes < PAGE_SIZE); 357 358 report_prefix_push("page boundary"); 359 buf = alloc_pages(1); 360 memcpy(&buf[PAGE_SIZE - num_bytes / 2], DBCN_WRITE_TEST_STRING, num_bytes); 361 dbcn_write_test(&buf[PAGE_SIZE - num_bytes / 2], num_bytes, false); 362 report_prefix_pop(); 363 364 tmp = getenv("SBI_HIGHMEM_NOT_SUPPORTED"); 365 if (tmp && atol(tmp) != 0) 366 highmem_supported = false; 367 368 report_prefix_push("high boundary"); 369 tmp = getenv("SBI_DBCN_SKIP_HIGH_BOUNDARY"); 370 if (!tmp || atol(tmp) == 0) 371 dbcn_high_write_test(DBCN_WRITE_TEST_STRING, num_bytes, 372 HIGH_ADDR_BOUNDARY - PAGE_SIZE, PAGE_SIZE - num_bytes / 2, 373 highmem_supported); 374 else 375 report_skip("user disabled"); 376 report_prefix_pop(); 377 378 report_prefix_push("high page"); 379 tmp = getenv("SBI_DBCN_SKIP_HIGH_PAGE"); 380 if (!tmp || atol(tmp) == 0) { 381 paddr = HIGH_ADDR_BOUNDARY; 382 tmp = getenv("HIGH_PAGE"); 383 if (tmp) 384 paddr = strtoull(tmp, NULL, 0); 385 dbcn_high_write_test(DBCN_WRITE_TEST_STRING, num_bytes, paddr, 0, highmem_supported); 386 } else { 387 report_skip("user disabled"); 388 } 389 report_prefix_pop(); 390 391 /* Bytes are read from memory and written to the console */ 392 report_prefix_push("invalid parameter"); 393 tmp = getenv("INVALID_ADDR_AUTO"); 394 if (tmp && atol(tmp) == 1) { 395 paddr = get_highest_addr() + 1; 396 do_invalid_addr = true; 397 } else if (env_or_skip("INVALID_ADDR")) { 398 paddr = strtoull(getenv("INVALID_ADDR"), NULL, 0); 399 do_invalid_addr = true; 400 } 401 402 if (do_invalid_addr) { 403 split_phys_addr(paddr, &base_addr_hi, &base_addr_lo); 404 ret = sbi_dbcn_write(1, base_addr_lo, base_addr_hi); 405 report(ret.error == SBI_ERR_INVALID_PARAM, "address (error=%ld)", ret.error); 406 } 407 report_prefix_popn(2); 408 report_prefix_push("write_byte"); 409 410 puts("DBCN_WRITE_BYTE TEST BYTE: "); 411 ret = sbi_dbcn_write_byte(DBCN_WRITE_BYTE_TEST_BYTE); 412 puts("\n"); 413 report(ret.error == SBI_SUCCESS, "write success (error=%ld)", ret.error); 414 report(ret.value == 0, "expected ret.value (%ld)", ret.value); 415 416 puts("DBCN_WRITE_BYTE TEST WORD: "); /* still expect 'a' in the output */ 417 ret = sbi_ecall(SBI_EXT_DBCN, SBI_EXT_DBCN_CONSOLE_WRITE_BYTE, 0x64636261, 0, 0, 0, 0, 0); 418 puts("\n"); 419 report(ret.error == SBI_SUCCESS, "write success (error=%ld)", ret.error); 420 report(ret.value == 0, "expected ret.value (%ld)", ret.value); 421 422 report_prefix_popn(2); 423 } 424 425 int main(int argc, char **argv) 426 { 427 if (argc > 1 && !strcmp(argv[1], "-h")) { 428 help(); 429 exit(0); 430 } 431 432 report_prefix_push("sbi"); 433 check_base(); 434 check_time(); 435 check_dbcn(); 436 437 return report_summary(); 438 } 439