1 /* 2 * runtime-wrappers.c - Runtime Services function call wrappers 3 * 4 * Copyright (C) 2014 Linaro Ltd. <ard.biesheuvel@linaro.org> 5 * 6 * Split off from arch/x86/platform/efi/efi.c 7 * 8 * Copyright (C) 1999 VA Linux Systems 9 * Copyright (C) 1999 Walt Drummond <drummond@valinux.com> 10 * Copyright (C) 1999-2002 Hewlett-Packard Co. 11 * Copyright (C) 2005-2008 Intel Co. 12 * Copyright (C) 2013 SuSE Labs 13 * 14 * This file is released under the GPLv2. 15 */ 16 17 #define pr_fmt(fmt) "efi: " fmt 18 19 #include <linux/bug.h> 20 #include <linux/efi.h> 21 #include <linux/irqflags.h> 22 #include <linux/mutex.h> 23 #include <linux/semaphore.h> 24 #include <linux/stringify.h> 25 #include <asm/efi.h> 26 27 /* 28 * Wrap around the new efi_call_virt_generic() macros so that the 29 * code doesn't get too cluttered: 30 */ 31 #define efi_call_virt(f, args...) \ 32 efi_call_virt_pointer(efi.systab->runtime, f, args) 33 #define __efi_call_virt(f, args...) \ 34 __efi_call_virt_pointer(efi.systab->runtime, f, args) 35 36 void efi_call_virt_check_flags(unsigned long flags, const char *call) 37 { 38 unsigned long cur_flags, mismatch; 39 40 local_save_flags(cur_flags); 41 42 mismatch = flags ^ cur_flags; 43 if (!WARN_ON_ONCE(mismatch & ARCH_EFI_IRQ_FLAGS_MASK)) 44 return; 45 46 add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_NOW_UNRELIABLE); 47 pr_err_ratelimited(FW_BUG "IRQ flags corrupted (0x%08lx=>0x%08lx) by EFI %s\n", 48 flags, cur_flags, call); 49 local_irq_restore(flags); 50 } 51 52 /* 53 * According to section 7.1 of the UEFI spec, Runtime Services are not fully 54 * reentrant, and there are particular combinations of calls that need to be 55 * serialized. (source: UEFI Specification v2.4A) 56 * 57 * Table 31. Rules for Reentry Into Runtime Services 58 * +------------------------------------+-------------------------------+ 59 * | If previous call is busy in | Forbidden to call | 60 * +------------------------------------+-------------------------------+ 61 * | Any | SetVirtualAddressMap() | 62 * +------------------------------------+-------------------------------+ 63 * | ConvertPointer() | ConvertPointer() | 64 * +------------------------------------+-------------------------------+ 65 * | SetVariable() | ResetSystem() | 66 * | UpdateCapsule() | | 67 * | SetTime() | | 68 * | SetWakeupTime() | | 69 * | GetNextHighMonotonicCount() | | 70 * +------------------------------------+-------------------------------+ 71 * | GetVariable() | GetVariable() | 72 * | GetNextVariableName() | GetNextVariableName() | 73 * | SetVariable() | SetVariable() | 74 * | QueryVariableInfo() | QueryVariableInfo() | 75 * | UpdateCapsule() | UpdateCapsule() | 76 * | QueryCapsuleCapabilities() | QueryCapsuleCapabilities() | 77 * | GetNextHighMonotonicCount() | GetNextHighMonotonicCount() | 78 * +------------------------------------+-------------------------------+ 79 * | GetTime() | GetTime() | 80 * | SetTime() | SetTime() | 81 * | GetWakeupTime() | GetWakeupTime() | 82 * | SetWakeupTime() | SetWakeupTime() | 83 * +------------------------------------+-------------------------------+ 84 * 85 * Due to the fact that the EFI pstore may write to the variable store in 86 * interrupt context, we need to use a lock for at least the groups that 87 * contain SetVariable() and QueryVariableInfo(). That leaves little else, as 88 * none of the remaining functions are actually ever called at runtime. 89 * So let's just use a single lock to serialize all Runtime Services calls. 90 */ 91 static DEFINE_SEMAPHORE(efi_runtime_lock); 92 93 static efi_status_t virt_efi_get_time(efi_time_t *tm, efi_time_cap_t *tc) 94 { 95 efi_status_t status; 96 97 if (down_interruptible(&efi_runtime_lock)) 98 return EFI_ABORTED; 99 status = efi_call_virt(get_time, tm, tc); 100 up(&efi_runtime_lock); 101 return status; 102 } 103 104 static efi_status_t virt_efi_set_time(efi_time_t *tm) 105 { 106 efi_status_t status; 107 108 if (down_interruptible(&efi_runtime_lock)) 109 return EFI_ABORTED; 110 status = efi_call_virt(set_time, tm); 111 up(&efi_runtime_lock); 112 return status; 113 } 114 115 static efi_status_t virt_efi_get_wakeup_time(efi_bool_t *enabled, 116 efi_bool_t *pending, 117 efi_time_t *tm) 118 { 119 efi_status_t status; 120 121 if (down_interruptible(&efi_runtime_lock)) 122 return EFI_ABORTED; 123 status = efi_call_virt(get_wakeup_time, enabled, pending, tm); 124 up(&efi_runtime_lock); 125 return status; 126 } 127 128 static efi_status_t virt_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm) 129 { 130 efi_status_t status; 131 132 if (down_interruptible(&efi_runtime_lock)) 133 return EFI_ABORTED; 134 status = efi_call_virt(set_wakeup_time, enabled, tm); 135 up(&efi_runtime_lock); 136 return status; 137 } 138 139 static efi_status_t virt_efi_get_variable(efi_char16_t *name, 140 efi_guid_t *vendor, 141 u32 *attr, 142 unsigned long *data_size, 143 void *data) 144 { 145 efi_status_t status; 146 147 if (down_interruptible(&efi_runtime_lock)) 148 return EFI_ABORTED; 149 status = efi_call_virt(get_variable, name, vendor, attr, data_size, 150 data); 151 up(&efi_runtime_lock); 152 return status; 153 } 154 155 static efi_status_t virt_efi_get_next_variable(unsigned long *name_size, 156 efi_char16_t *name, 157 efi_guid_t *vendor) 158 { 159 efi_status_t status; 160 161 if (down_interruptible(&efi_runtime_lock)) 162 return EFI_ABORTED; 163 status = efi_call_virt(get_next_variable, name_size, name, vendor); 164 up(&efi_runtime_lock); 165 return status; 166 } 167 168 static efi_status_t virt_efi_set_variable(efi_char16_t *name, 169 efi_guid_t *vendor, 170 u32 attr, 171 unsigned long data_size, 172 void *data) 173 { 174 efi_status_t status; 175 176 if (down_interruptible(&efi_runtime_lock)) 177 return EFI_ABORTED; 178 status = efi_call_virt(set_variable, name, vendor, attr, data_size, 179 data); 180 up(&efi_runtime_lock); 181 return status; 182 } 183 184 static efi_status_t 185 virt_efi_set_variable_nonblocking(efi_char16_t *name, efi_guid_t *vendor, 186 u32 attr, unsigned long data_size, 187 void *data) 188 { 189 efi_status_t status; 190 191 if (down_trylock(&efi_runtime_lock)) 192 return EFI_NOT_READY; 193 194 status = efi_call_virt(set_variable, name, vendor, attr, data_size, 195 data); 196 up(&efi_runtime_lock); 197 return status; 198 } 199 200 201 static efi_status_t virt_efi_query_variable_info(u32 attr, 202 u64 *storage_space, 203 u64 *remaining_space, 204 u64 *max_variable_size) 205 { 206 efi_status_t status; 207 208 if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION) 209 return EFI_UNSUPPORTED; 210 211 if (down_interruptible(&efi_runtime_lock)) 212 return EFI_ABORTED; 213 status = efi_call_virt(query_variable_info, attr, storage_space, 214 remaining_space, max_variable_size); 215 up(&efi_runtime_lock); 216 return status; 217 } 218 219 static efi_status_t 220 virt_efi_query_variable_info_nonblocking(u32 attr, 221 u64 *storage_space, 222 u64 *remaining_space, 223 u64 *max_variable_size) 224 { 225 efi_status_t status; 226 227 if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION) 228 return EFI_UNSUPPORTED; 229 230 if (down_trylock(&efi_runtime_lock)) 231 return EFI_NOT_READY; 232 233 status = efi_call_virt(query_variable_info, attr, storage_space, 234 remaining_space, max_variable_size); 235 up(&efi_runtime_lock); 236 return status; 237 } 238 239 static efi_status_t virt_efi_get_next_high_mono_count(u32 *count) 240 { 241 efi_status_t status; 242 243 if (down_interruptible(&efi_runtime_lock)) 244 return EFI_ABORTED; 245 status = efi_call_virt(get_next_high_mono_count, count); 246 up(&efi_runtime_lock); 247 return status; 248 } 249 250 static void virt_efi_reset_system(int reset_type, 251 efi_status_t status, 252 unsigned long data_size, 253 efi_char16_t *data) 254 { 255 if (down_interruptible(&efi_runtime_lock)) { 256 pr_warn("failed to invoke the reset_system() runtime service:\n" 257 "could not get exclusive access to the firmware\n"); 258 return; 259 } 260 __efi_call_virt(reset_system, reset_type, status, data_size, data); 261 up(&efi_runtime_lock); 262 } 263 264 static efi_status_t virt_efi_update_capsule(efi_capsule_header_t **capsules, 265 unsigned long count, 266 unsigned long sg_list) 267 { 268 efi_status_t status; 269 270 if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION) 271 return EFI_UNSUPPORTED; 272 273 if (down_interruptible(&efi_runtime_lock)) 274 return EFI_ABORTED; 275 status = efi_call_virt(update_capsule, capsules, count, sg_list); 276 up(&efi_runtime_lock); 277 return status; 278 } 279 280 static efi_status_t virt_efi_query_capsule_caps(efi_capsule_header_t **capsules, 281 unsigned long count, 282 u64 *max_size, 283 int *reset_type) 284 { 285 efi_status_t status; 286 287 if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION) 288 return EFI_UNSUPPORTED; 289 290 if (down_interruptible(&efi_runtime_lock)) 291 return EFI_ABORTED; 292 status = efi_call_virt(query_capsule_caps, capsules, count, max_size, 293 reset_type); 294 up(&efi_runtime_lock); 295 return status; 296 } 297 298 void efi_native_runtime_setup(void) 299 { 300 efi.get_time = virt_efi_get_time; 301 efi.set_time = virt_efi_set_time; 302 efi.get_wakeup_time = virt_efi_get_wakeup_time; 303 efi.set_wakeup_time = virt_efi_set_wakeup_time; 304 efi.get_variable = virt_efi_get_variable; 305 efi.get_next_variable = virt_efi_get_next_variable; 306 efi.set_variable = virt_efi_set_variable; 307 efi.set_variable_nonblocking = virt_efi_set_variable_nonblocking; 308 efi.get_next_high_mono_count = virt_efi_get_next_high_mono_count; 309 efi.reset_system = virt_efi_reset_system; 310 efi.query_variable_info = virt_efi_query_variable_info; 311 efi.query_variable_info_nonblocking = virt_efi_query_variable_info_nonblocking; 312 efi.update_capsule = virt_efi_update_capsule; 313 efi.query_capsule_caps = virt_efi_query_capsule_caps; 314 } 315