Merge branch 'efi-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[muen/linux.git] / drivers / firmware / efi / runtime-wrappers.c
1 /*
2  * runtime-wrappers.c - Runtime Services function call wrappers
3  *
4  * Implementation summary:
5  * -----------------------
6  * 1. When user/kernel thread requests to execute efi_runtime_service(),
7  * enqueue work to efi_rts_wq.
8  * 2. Caller thread waits for completion until the work is finished
9  * because it's dependent on the return status and execution of
10  * efi_runtime_service().
11  * For instance, get_variable() and get_next_variable().
12  *
13  * Copyright (C) 2014 Linaro Ltd. <ard.biesheuvel@linaro.org>
14  *
15  * Split off from arch/x86/platform/efi/efi.c
16  *
17  * Copyright (C) 1999 VA Linux Systems
18  * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
19  * Copyright (C) 1999-2002 Hewlett-Packard Co.
20  * Copyright (C) 2005-2008 Intel Co.
21  * Copyright (C) 2013 SuSE Labs
22  *
23  * This file is released under the GPLv2.
24  */
25
26 #define pr_fmt(fmt)     "efi: " fmt
27
28 #include <linux/bug.h>
29 #include <linux/efi.h>
30 #include <linux/irqflags.h>
31 #include <linux/mutex.h>
32 #include <linux/semaphore.h>
33 #include <linux/stringify.h>
34 #include <linux/workqueue.h>
35 #include <linux/completion.h>
36
37 #include <asm/efi.h>
38
39 /*
40  * Wrap around the new efi_call_virt_generic() macros so that the
41  * code doesn't get too cluttered:
42  */
43 #define efi_call_virt(f, args...)   \
44         efi_call_virt_pointer(efi.systab->runtime, f, args)
45 #define __efi_call_virt(f, args...) \
46         __efi_call_virt_pointer(efi.systab->runtime, f, args)
47
48 struct efi_runtime_work efi_rts_work;
49
50 /*
51  * efi_queue_work:      Queue efi_runtime_service() and wait until it's done
52  * @rts:                efi_runtime_service() function identifier
53  * @rts_arg<1-5>:       efi_runtime_service() function arguments
54  *
55  * Accesses to efi_runtime_services() are serialized by a binary
56  * semaphore (efi_runtime_lock) and caller waits until the work is
57  * finished, hence _only_ one work is queued at a time and the caller
58  * thread waits for completion.
59  */
60 #define efi_queue_work(_rts, _arg1, _arg2, _arg3, _arg4, _arg5)         \
61 ({                                                                      \
62         efi_rts_work.status = EFI_ABORTED;                              \
63                                                                         \
64         if (!efi_enabled(EFI_RUNTIME_SERVICES)) {                       \
65                 pr_warn_once("EFI Runtime Services are disabled!\n");   \
66                 goto exit;                                              \
67         }                                                               \
68                                                                         \
69         init_completion(&efi_rts_work.efi_rts_comp);                    \
70         INIT_WORK(&efi_rts_work.work, efi_call_rts);                    \
71         efi_rts_work.arg1 = _arg1;                                      \
72         efi_rts_work.arg2 = _arg2;                                      \
73         efi_rts_work.arg3 = _arg3;                                      \
74         efi_rts_work.arg4 = _arg4;                                      \
75         efi_rts_work.arg5 = _arg5;                                      \
76         efi_rts_work.efi_rts_id = _rts;                                 \
77                                                                         \
78         /*                                                              \
79          * queue_work() returns 0 if work was already on queue,         \
80          * _ideally_ this should never happen.                          \
81          */                                                             \
82         if (queue_work(efi_rts_wq, &efi_rts_work.work))                 \
83                 wait_for_completion(&efi_rts_work.efi_rts_comp);        \
84         else                                                            \
85                 pr_err("Failed to queue work to efi_rts_wq.\n");        \
86                                                                         \
87 exit:                                                                   \
88         efi_rts_work.efi_rts_id = EFI_NONE;                             \
89         efi_rts_work.status;                                            \
90 })
91
92 void efi_call_virt_check_flags(unsigned long flags, const char *call)
93 {
94         unsigned long cur_flags, mismatch;
95
96         local_save_flags(cur_flags);
97
98         mismatch = flags ^ cur_flags;
99         if (!WARN_ON_ONCE(mismatch & ARCH_EFI_IRQ_FLAGS_MASK))
100                 return;
101
102         add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_NOW_UNRELIABLE);
103         pr_err_ratelimited(FW_BUG "IRQ flags corrupted (0x%08lx=>0x%08lx) by EFI %s\n",
104                            flags, cur_flags, call);
105         local_irq_restore(flags);
106 }
107
108 /*
109  * According to section 7.1 of the UEFI spec, Runtime Services are not fully
110  * reentrant, and there are particular combinations of calls that need to be
111  * serialized. (source: UEFI Specification v2.4A)
112  *
113  * Table 31. Rules for Reentry Into Runtime Services
114  * +------------------------------------+-------------------------------+
115  * | If previous call is busy in        | Forbidden to call             |
116  * +------------------------------------+-------------------------------+
117  * | Any                                | SetVirtualAddressMap()        |
118  * +------------------------------------+-------------------------------+
119  * | ConvertPointer()                   | ConvertPointer()              |
120  * +------------------------------------+-------------------------------+
121  * | SetVariable()                      | ResetSystem()                 |
122  * | UpdateCapsule()                    |                               |
123  * | SetTime()                          |                               |
124  * | SetWakeupTime()                    |                               |
125  * | GetNextHighMonotonicCount()        |                               |
126  * +------------------------------------+-------------------------------+
127  * | GetVariable()                      | GetVariable()                 |
128  * | GetNextVariableName()              | GetNextVariableName()         |
129  * | SetVariable()                      | SetVariable()                 |
130  * | QueryVariableInfo()                | QueryVariableInfo()           |
131  * | UpdateCapsule()                    | UpdateCapsule()               |
132  * | QueryCapsuleCapabilities()         | QueryCapsuleCapabilities()    |
133  * | GetNextHighMonotonicCount()        | GetNextHighMonotonicCount()   |
134  * +------------------------------------+-------------------------------+
135  * | GetTime()                          | GetTime()                     |
136  * | SetTime()                          | SetTime()                     |
137  * | GetWakeupTime()                    | GetWakeupTime()               |
138  * | SetWakeupTime()                    | SetWakeupTime()               |
139  * +------------------------------------+-------------------------------+
140  *
141  * Due to the fact that the EFI pstore may write to the variable store in
142  * interrupt context, we need to use a lock for at least the groups that
143  * contain SetVariable() and QueryVariableInfo(). That leaves little else, as
144  * none of the remaining functions are actually ever called at runtime.
145  * So let's just use a single lock to serialize all Runtime Services calls.
146  */
147 static DEFINE_SEMAPHORE(efi_runtime_lock);
148
149 /*
150  * Expose the EFI runtime lock to the UV platform
151  */
152 #ifdef CONFIG_X86_UV
153 extern struct semaphore __efi_uv_runtime_lock __alias(efi_runtime_lock);
154 #endif
155
156 /*
157  * Calls the appropriate efi_runtime_service() with the appropriate
158  * arguments.
159  *
160  * Semantics followed by efi_call_rts() to understand efi_runtime_work:
161  * 1. If argument was a pointer, recast it from void pointer to original
162  * pointer type.
163  * 2. If argument was a value, recast it from void pointer to original
164  * pointer type and dereference it.
165  */
166 static void efi_call_rts(struct work_struct *work)
167 {
168         void *arg1, *arg2, *arg3, *arg4, *arg5;
169         efi_status_t status = EFI_NOT_FOUND;
170
171         arg1 = efi_rts_work.arg1;
172         arg2 = efi_rts_work.arg2;
173         arg3 = efi_rts_work.arg3;
174         arg4 = efi_rts_work.arg4;
175         arg5 = efi_rts_work.arg5;
176
177         switch (efi_rts_work.efi_rts_id) {
178         case EFI_GET_TIME:
179                 status = efi_call_virt(get_time, (efi_time_t *)arg1,
180                                        (efi_time_cap_t *)arg2);
181                 break;
182         case EFI_SET_TIME:
183                 status = efi_call_virt(set_time, (efi_time_t *)arg1);
184                 break;
185         case EFI_GET_WAKEUP_TIME:
186                 status = efi_call_virt(get_wakeup_time, (efi_bool_t *)arg1,
187                                        (efi_bool_t *)arg2, (efi_time_t *)arg3);
188                 break;
189         case EFI_SET_WAKEUP_TIME:
190                 status = efi_call_virt(set_wakeup_time, *(efi_bool_t *)arg1,
191                                        (efi_time_t *)arg2);
192                 break;
193         case EFI_GET_VARIABLE:
194                 status = efi_call_virt(get_variable, (efi_char16_t *)arg1,
195                                        (efi_guid_t *)arg2, (u32 *)arg3,
196                                        (unsigned long *)arg4, (void *)arg5);
197                 break;
198         case EFI_GET_NEXT_VARIABLE:
199                 status = efi_call_virt(get_next_variable, (unsigned long *)arg1,
200                                        (efi_char16_t *)arg2,
201                                        (efi_guid_t *)arg3);
202                 break;
203         case EFI_SET_VARIABLE:
204                 status = efi_call_virt(set_variable, (efi_char16_t *)arg1,
205                                        (efi_guid_t *)arg2, *(u32 *)arg3,
206                                        *(unsigned long *)arg4, (void *)arg5);
207                 break;
208         case EFI_QUERY_VARIABLE_INFO:
209                 status = efi_call_virt(query_variable_info, *(u32 *)arg1,
210                                        (u64 *)arg2, (u64 *)arg3, (u64 *)arg4);
211                 break;
212         case EFI_GET_NEXT_HIGH_MONO_COUNT:
213                 status = efi_call_virt(get_next_high_mono_count, (u32 *)arg1);
214                 break;
215         case EFI_UPDATE_CAPSULE:
216                 status = efi_call_virt(update_capsule,
217                                        (efi_capsule_header_t **)arg1,
218                                        *(unsigned long *)arg2,
219                                        *(unsigned long *)arg3);
220                 break;
221         case EFI_QUERY_CAPSULE_CAPS:
222                 status = efi_call_virt(query_capsule_caps,
223                                        (efi_capsule_header_t **)arg1,
224                                        *(unsigned long *)arg2, (u64 *)arg3,
225                                        (int *)arg4);
226                 break;
227         default:
228                 /*
229                  * Ideally, we should never reach here because a caller of this
230                  * function should have put the right efi_runtime_service()
231                  * function identifier into efi_rts_work->efi_rts_id
232                  */
233                 pr_err("Requested executing invalid EFI Runtime Service.\n");
234         }
235         efi_rts_work.status = status;
236         complete(&efi_rts_work.efi_rts_comp);
237 }
238
239 static efi_status_t virt_efi_get_time(efi_time_t *tm, efi_time_cap_t *tc)
240 {
241         efi_status_t status;
242
243         if (down_interruptible(&efi_runtime_lock))
244                 return EFI_ABORTED;
245         status = efi_queue_work(EFI_GET_TIME, tm, tc, NULL, NULL, NULL);
246         up(&efi_runtime_lock);
247         return status;
248 }
249
250 static efi_status_t virt_efi_set_time(efi_time_t *tm)
251 {
252         efi_status_t status;
253
254         if (down_interruptible(&efi_runtime_lock))
255                 return EFI_ABORTED;
256         status = efi_queue_work(EFI_SET_TIME, tm, NULL, NULL, NULL, NULL);
257         up(&efi_runtime_lock);
258         return status;
259 }
260
261 static efi_status_t virt_efi_get_wakeup_time(efi_bool_t *enabled,
262                                              efi_bool_t *pending,
263                                              efi_time_t *tm)
264 {
265         efi_status_t status;
266
267         if (down_interruptible(&efi_runtime_lock))
268                 return EFI_ABORTED;
269         status = efi_queue_work(EFI_GET_WAKEUP_TIME, enabled, pending, tm, NULL,
270                                 NULL);
271         up(&efi_runtime_lock);
272         return status;
273 }
274
275 static efi_status_t virt_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm)
276 {
277         efi_status_t status;
278
279         if (down_interruptible(&efi_runtime_lock))
280                 return EFI_ABORTED;
281         status = efi_queue_work(EFI_SET_WAKEUP_TIME, &enabled, tm, NULL, NULL,
282                                 NULL);
283         up(&efi_runtime_lock);
284         return status;
285 }
286
287 static efi_status_t virt_efi_get_variable(efi_char16_t *name,
288                                           efi_guid_t *vendor,
289                                           u32 *attr,
290                                           unsigned long *data_size,
291                                           void *data)
292 {
293         efi_status_t status;
294
295         if (down_interruptible(&efi_runtime_lock))
296                 return EFI_ABORTED;
297         status = efi_queue_work(EFI_GET_VARIABLE, name, vendor, attr, data_size,
298                                 data);
299         up(&efi_runtime_lock);
300         return status;
301 }
302
303 static efi_status_t virt_efi_get_next_variable(unsigned long *name_size,
304                                                efi_char16_t *name,
305                                                efi_guid_t *vendor)
306 {
307         efi_status_t status;
308
309         if (down_interruptible(&efi_runtime_lock))
310                 return EFI_ABORTED;
311         status = efi_queue_work(EFI_GET_NEXT_VARIABLE, name_size, name, vendor,
312                                 NULL, NULL);
313         up(&efi_runtime_lock);
314         return status;
315 }
316
317 static efi_status_t virt_efi_set_variable(efi_char16_t *name,
318                                           efi_guid_t *vendor,
319                                           u32 attr,
320                                           unsigned long data_size,
321                                           void *data)
322 {
323         efi_status_t status;
324
325         if (down_interruptible(&efi_runtime_lock))
326                 return EFI_ABORTED;
327         status = efi_queue_work(EFI_SET_VARIABLE, name, vendor, &attr, &data_size,
328                                 data);
329         up(&efi_runtime_lock);
330         return status;
331 }
332
333 static efi_status_t
334 virt_efi_set_variable_nonblocking(efi_char16_t *name, efi_guid_t *vendor,
335                                   u32 attr, unsigned long data_size,
336                                   void *data)
337 {
338         efi_status_t status;
339
340         if (down_trylock(&efi_runtime_lock))
341                 return EFI_NOT_READY;
342
343         status = efi_call_virt(set_variable, name, vendor, attr, data_size,
344                                data);
345         up(&efi_runtime_lock);
346         return status;
347 }
348
349
350 static efi_status_t virt_efi_query_variable_info(u32 attr,
351                                                  u64 *storage_space,
352                                                  u64 *remaining_space,
353                                                  u64 *max_variable_size)
354 {
355         efi_status_t status;
356
357         if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
358                 return EFI_UNSUPPORTED;
359
360         if (down_interruptible(&efi_runtime_lock))
361                 return EFI_ABORTED;
362         status = efi_queue_work(EFI_QUERY_VARIABLE_INFO, &attr, storage_space,
363                                 remaining_space, max_variable_size, NULL);
364         up(&efi_runtime_lock);
365         return status;
366 }
367
368 static efi_status_t
369 virt_efi_query_variable_info_nonblocking(u32 attr,
370                                          u64 *storage_space,
371                                          u64 *remaining_space,
372                                          u64 *max_variable_size)
373 {
374         efi_status_t status;
375
376         if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
377                 return EFI_UNSUPPORTED;
378
379         if (down_trylock(&efi_runtime_lock))
380                 return EFI_NOT_READY;
381
382         status = efi_call_virt(query_variable_info, attr, storage_space,
383                                remaining_space, max_variable_size);
384         up(&efi_runtime_lock);
385         return status;
386 }
387
388 static efi_status_t virt_efi_get_next_high_mono_count(u32 *count)
389 {
390         efi_status_t status;
391
392         if (down_interruptible(&efi_runtime_lock))
393                 return EFI_ABORTED;
394         status = efi_queue_work(EFI_GET_NEXT_HIGH_MONO_COUNT, count, NULL, NULL,
395                                 NULL, NULL);
396         up(&efi_runtime_lock);
397         return status;
398 }
399
400 static void virt_efi_reset_system(int reset_type,
401                                   efi_status_t status,
402                                   unsigned long data_size,
403                                   efi_char16_t *data)
404 {
405         if (down_interruptible(&efi_runtime_lock)) {
406                 pr_warn("failed to invoke the reset_system() runtime service:\n"
407                         "could not get exclusive access to the firmware\n");
408                 return;
409         }
410         efi_rts_work.efi_rts_id = EFI_RESET_SYSTEM;
411         __efi_call_virt(reset_system, reset_type, status, data_size, data);
412         up(&efi_runtime_lock);
413 }
414
415 static efi_status_t virt_efi_update_capsule(efi_capsule_header_t **capsules,
416                                             unsigned long count,
417                                             unsigned long sg_list)
418 {
419         efi_status_t status;
420
421         if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
422                 return EFI_UNSUPPORTED;
423
424         if (down_interruptible(&efi_runtime_lock))
425                 return EFI_ABORTED;
426         status = efi_queue_work(EFI_UPDATE_CAPSULE, capsules, &count, &sg_list,
427                                 NULL, NULL);
428         up(&efi_runtime_lock);
429         return status;
430 }
431
432 static efi_status_t virt_efi_query_capsule_caps(efi_capsule_header_t **capsules,
433                                                 unsigned long count,
434                                                 u64 *max_size,
435                                                 int *reset_type)
436 {
437         efi_status_t status;
438
439         if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
440                 return EFI_UNSUPPORTED;
441
442         if (down_interruptible(&efi_runtime_lock))
443                 return EFI_ABORTED;
444         status = efi_queue_work(EFI_QUERY_CAPSULE_CAPS, capsules, &count,
445                                 max_size, reset_type, NULL);
446         up(&efi_runtime_lock);
447         return status;
448 }
449
450 void efi_native_runtime_setup(void)
451 {
452         efi.get_time = virt_efi_get_time;
453         efi.set_time = virt_efi_set_time;
454         efi.get_wakeup_time = virt_efi_get_wakeup_time;
455         efi.set_wakeup_time = virt_efi_set_wakeup_time;
456         efi.get_variable = virt_efi_get_variable;
457         efi.get_next_variable = virt_efi_get_next_variable;
458         efi.set_variable = virt_efi_set_variable;
459         efi.set_variable_nonblocking = virt_efi_set_variable_nonblocking;
460         efi.get_next_high_mono_count = virt_efi_get_next_high_mono_count;
461         efi.reset_system = virt_efi_reset_system;
462         efi.query_variable_info = virt_efi_query_variable_info;
463         efi.query_variable_info_nonblocking = virt_efi_query_variable_info_nonblocking;
464         efi.update_capsule = virt_efi_update_capsule;
465         efi.query_capsule_caps = virt_efi_query_capsule_caps;
466 }