1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
29
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
36void 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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91static DEFINE_SEMAPHORE(efi_runtime_lock);
92
93static 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
104static 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
115static 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
128static 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
139static 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
155static 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
168static 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
184static efi_status_t
185virt_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
201static 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
219static efi_status_t
220virt_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
239static 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
250static 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
264static 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
280static 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
298void 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
