1 /* 2 * Copyright (c) 2018, ARM Limited and Contributors. All rights reserved. 3 * 4 * SPDX-License-Identifier: BSD-3-Clause 5 */ 6 7 #include <stdbool.h> 8 9 #include <arch_helpers.h> 10 #include <bl31/ea_handle.h> 11 #include <bl31/ehf.h> 12 #include <common/debug.h> 13 #include <lib/extensions/ras.h> 14 #include <lib/extensions/ras_arch.h> 15 #include <plat/common/platform.h> 16 17 #ifndef PLAT_RAS_PRI 18 # error Platform must define RAS priority value 19 #endif 20 21 /* Handler that receives External Aborts on RAS-capable systems */ 22 int ras_ea_handler(unsigned int ea_reason, uint64_t syndrome, void *cookie, 23 void *handle, uint64_t flags) 24 { 25 unsigned int i, n_handled = 0; 26 int probe_data, ret; 27 struct err_record_info *info; 28 29 const struct err_handler_data err_data = { 30 .version = ERR_HANDLER_VERSION, 31 .ea_reason = ea_reason, 32 .interrupt = 0, 33 .syndrome = (uint32_t) syndrome, 34 .flags = flags, 35 .cookie = cookie, 36 .handle = handle 37 }; 38 39 for_each_err_record_info(i, info) { 40 assert(info->probe != NULL); 41 assert(info->handler != NULL); 42 43 /* Continue probing until the record group signals no error */ 44 while (true) { 45 if (info->probe(info, &probe_data) == 0) 46 break; 47 48 /* Handle error */ 49 ret = info->handler(info, probe_data, &err_data); 50 if (ret != 0) 51 return ret; 52 53 n_handled++; 54 } 55 } 56 57 return (n_handled != 0U) ? 1 : 0; 58 } 59 60 #if ENABLE_ASSERTIONS 61 static void assert_interrupts_sorted(void) 62 { 63 unsigned int i, last; 64 struct ras_interrupt *start = ras_interrupt_mappings.intrs; 65 66 if (ras_interrupt_mappings.num_intrs == 0UL) 67 return; 68 69 last = start[0].intr_number; 70 for (i = 1; i < ras_interrupt_mappings.num_intrs; i++) { 71 assert(start[i].intr_number > last); 72 last = start[i].intr_number; 73 } 74 } 75 #endif 76 77 /* 78 * Given an RAS interrupt number, locate the registered handler and call it. If 79 * no handler was found for the interrupt number, this function panics. 80 */ 81 static int ras_interrupt_handler(uint32_t intr_raw, uint32_t flags, 82 void *handle, void *cookie) 83 { 84 struct ras_interrupt *ras_inrs = ras_interrupt_mappings.intrs; 85 struct ras_interrupt *selected = NULL; 86 int start, end, mid, probe_data, ret __unused; 87 88 const struct err_handler_data err_data = { 89 .version = ERR_HANDLER_VERSION, 90 .interrupt = intr_raw, 91 .flags = flags, 92 .cookie = cookie, 93 .handle = handle 94 }; 95 96 assert(ras_interrupt_mappings.num_intrs > 0UL); 97 98 start = 0; 99 end = (int) ras_interrupt_mappings.num_intrs; 100 while (start <= end) { 101 mid = ((end + start) / 2); 102 if (intr_raw == ras_inrs[mid].intr_number) { 103 selected = &ras_inrs[mid]; 104 break; 105 } else if (intr_raw < ras_inrs[mid].intr_number) { 106 /* Move left */ 107 end = mid - 1; 108 } else { 109 /* Move right */ 110 start = mid + 1; 111 } 112 } 113 114 if (selected == NULL) { 115 ERROR("RAS interrupt %u has no handler!\n", intr_raw); 116 panic(); 117 } 118 119 if (selected->err_record->probe != NULL) { 120 ret = selected->err_record->probe(selected->err_record, &probe_data); 121 assert(ret != 0); 122 } 123 124 /* Call error handler for the record group */ 125 assert(selected->err_record->handler != NULL); 126 (void) selected->err_record->handler(selected->err_record, probe_data, 127 &err_data); 128 129 return 0; 130 } 131 132 void __init ras_init(void) 133 { 134 #if ENABLE_ASSERTIONS 135 /* Check RAS interrupts are sorted */ 136 assert_interrupts_sorted(); 137 #endif 138 139 /* Register RAS priority handler */ 140 ehf_register_priority_handler(PLAT_RAS_PRI, ras_interrupt_handler); 141 } 142