Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * linux/arch/arm/vfp/vfpmodule.c
4 : : *
5 : : * Copyright (C) 2004 ARM Limited.
6 : : * Written by Deep Blue Solutions Limited.
7 : : */
8 : : #include <linux/types.h>
9 : : #include <linux/cpu.h>
10 : : #include <linux/cpu_pm.h>
11 : : #include <linux/hardirq.h>
12 : : #include <linux/kernel.h>
13 : : #include <linux/notifier.h>
14 : : #include <linux/signal.h>
15 : : #include <linux/sched/signal.h>
16 : : #include <linux/smp.h>
17 : : #include <linux/init.h>
18 : : #include <linux/uaccess.h>
19 : : #include <linux/user.h>
20 : : #include <linux/export.h>
21 : :
22 : : #include <asm/cp15.h>
23 : : #include <asm/cputype.h>
24 : : #include <asm/system_info.h>
25 : : #include <asm/thread_notify.h>
26 : : #include <asm/vfp.h>
27 : :
28 : : #include "vfpinstr.h"
29 : : #include "vfp.h"
30 : :
31 : : /*
32 : : * Our undef handlers (in entry.S)
33 : : */
34 : : asmlinkage void vfp_testing_entry(void);
35 : : asmlinkage void vfp_support_entry(void);
36 : : asmlinkage void vfp_null_entry(void);
37 : :
38 : : asmlinkage void (*vfp_vector)(void) = vfp_null_entry;
39 : :
40 : : /*
41 : : * Dual-use variable.
42 : : * Used in startup: set to non-zero if VFP checks fail
43 : : * After startup, holds VFP architecture
44 : : */
45 : : unsigned int VFP_arch;
46 : :
47 : : /*
48 : : * The pointer to the vfpstate structure of the thread which currently
49 : : * owns the context held in the VFP hardware, or NULL if the hardware
50 : : * context is invalid.
51 : : *
52 : : * For UP, this is sufficient to tell which thread owns the VFP context.
53 : : * However, for SMP, we also need to check the CPU number stored in the
54 : : * saved state too to catch migrations.
55 : : */
56 : : union vfp_state *vfp_current_hw_state[NR_CPUS];
57 : :
58 : : /*
59 : : * Is 'thread's most up to date state stored in this CPUs hardware?
60 : : * Must be called from non-preemptible context.
61 : : */
62 : : static bool vfp_state_in_hw(unsigned int cpu, struct thread_info *thread)
63 : : {
64 : : #ifdef CONFIG_SMP
65 [ # # + + : 2156967 : if (thread->vfpstate.hard.cpu != cpu)
+ + ]
66 : : return false;
67 : : #endif
68 : 1671966 : return vfp_current_hw_state[cpu] == &thread->vfpstate;
69 : : }
70 : :
71 : : /*
72 : : * Force a reload of the VFP context from the thread structure. We do
73 : : * this by ensuring that access to the VFP hardware is disabled, and
74 : : * clear vfp_current_hw_state. Must be called from non-preemptible context.
75 : : */
76 : : static void vfp_force_reload(unsigned int cpu, struct thread_info *thread)
77 : : {
78 [ + + ]: 864478 : if (vfp_state_in_hw(cpu, thread)) {
79 : 381231 : fmxr(FPEXC, fmrx(FPEXC) & ~FPEXC_EN);
80 : 381231 : vfp_current_hw_state[cpu] = NULL;
81 : : }
82 : : #ifdef CONFIG_SMP
83 : 864478 : thread->vfpstate.hard.cpu = NR_CPUS;
84 : : #endif
85 : : }
86 : :
87 : : /*
88 : : * Per-thread VFP initialization.
89 : : */
90 : 794491 : static void vfp_thread_flush(struct thread_info *thread)
91 : : {
92 : 794491 : union vfp_state *vfp = &thread->vfpstate;
93 : : unsigned int cpu;
94 : :
95 : : /*
96 : : * Disable VFP to ensure we initialize it first. We must ensure
97 : : * that the modification of vfp_current_hw_state[] and hardware
98 : : * disable are done for the same CPU and without preemption.
99 : : *
100 : : * Do this first to ensure that preemption won't overwrite our
101 : : * state saving should access to the VFP be enabled at this point.
102 : : */
103 : 1588983 : cpu = get_cpu();
104 [ + + ]: 794492 : if (vfp_current_hw_state[cpu] == vfp)
105 : 740697 : vfp_current_hw_state[cpu] = NULL;
106 : 794492 : fmxr(FPEXC, fmrx(FPEXC) & ~FPEXC_EN);
107 : 794473 : put_cpu();
108 : :
109 : 794495 : memset(vfp, 0, sizeof(union vfp_state));
110 : :
111 : 794495 : vfp->hard.fpexc = FPEXC_EN;
112 : 794495 : vfp->hard.fpscr = FPSCR_ROUND_NEAREST;
113 : : #ifdef CONFIG_SMP
114 : 794495 : vfp->hard.cpu = NR_CPUS;
115 : : #endif
116 : 794495 : }
117 : :
118 : : static void vfp_thread_exit(struct thread_info *thread)
119 : : {
120 : : /* release case: Per-thread VFP cleanup. */
121 : 828791 : union vfp_state *vfp = &thread->vfpstate;
122 : 1657596 : unsigned int cpu = get_cpu();
123 : :
124 [ + + ]: 828805 : if (vfp_current_hw_state[cpu] == vfp)
125 : 798809 : vfp_current_hw_state[cpu] = NULL;
126 : 828805 : put_cpu();
127 : : }
128 : :
129 : 860828 : static void vfp_thread_copy(struct thread_info *thread)
130 : : {
131 : : struct thread_info *parent = current_thread_info();
132 : :
133 : 860828 : vfp_sync_hwstate(parent);
134 : 860842 : thread->vfpstate = parent->vfpstate;
135 : : #ifdef CONFIG_SMP
136 : 860842 : thread->vfpstate.hard.cpu = NR_CPUS;
137 : : #endif
138 : 860842 : }
139 : :
140 : : /*
141 : : * When this function is called with the following 'cmd's, the following
142 : : * is true while this function is being run:
143 : : * THREAD_NOFTIFY_SWTICH:
144 : : * - the previously running thread will not be scheduled onto another CPU.
145 : : * - the next thread to be run (v) will not be running on another CPU.
146 : : * - thread->cpu is the local CPU number
147 : : * - not preemptible as we're called in the middle of a thread switch
148 : : * THREAD_NOTIFY_FLUSH:
149 : : * - the thread (v) will be running on the local CPU, so
150 : : * v === current_thread_info()
151 : : * - thread->cpu is the local CPU number at the time it is accessed,
152 : : * but may change at any time.
153 : : * - we could be preempted if tree preempt rcu is enabled, so
154 : : * it is unsafe to use thread->cpu.
155 : : * THREAD_NOTIFY_EXIT
156 : : * - we could be preempted if tree preempt rcu is enabled, so
157 : : * it is unsafe to use thread->cpu.
158 : : */
159 : 18647158 : static int vfp_notifier(struct notifier_block *self, unsigned long cmd, void *v)
160 : : {
161 : : struct thread_info *thread = v;
162 : : u32 fpexc;
163 : : #ifdef CONFIG_SMP
164 : : unsigned int cpu;
165 : : #endif
166 : :
167 [ + + + + : 18647158 : switch (cmd) {
+ ]
168 : : case THREAD_NOTIFY_SWITCH:
169 : 16104162 : fpexc = fmrx(FPEXC);
170 : :
171 : : #ifdef CONFIG_SMP
172 : 16104162 : cpu = thread->cpu;
173 : :
174 : : /*
175 : : * On SMP, if VFP is enabled, save the old state in
176 : : * case the thread migrates to a different CPU. The
177 : : * restoring is done lazily.
178 : : */
179 [ + + + + ]: 16104162 : if ((fpexc & FPEXC_EN) && vfp_current_hw_state[cpu]) {
180 : : /* vfp_save_state oopses on VFP11 if EX bit set */
181 : 3660273 : fmxr(FPEXC, fpexc & ~FPEXC_EX);
182 : 3657725 : vfp_save_state(vfp_current_hw_state[cpu], fpexc);
183 : : }
184 : : #endif
185 : :
186 : : /*
187 : : * Always disable VFP so we can lazily save/restore the
188 : : * old state.
189 : : */
190 : 16104904 : fmxr(FPEXC, fpexc & ~FPEXC_EN);
191 : 16166378 : break;
192 : :
193 : : case THREAD_NOTIFY_FLUSH:
194 : 794413 : vfp_thread_flush(thread);
195 : 794464 : break;
196 : :
197 : : case THREAD_NOTIFY_EXIT:
198 : : vfp_thread_exit(thread);
199 : : break;
200 : :
201 : : case THREAD_NOTIFY_COPY:
202 : 860774 : vfp_thread_copy(thread);
203 : 860831 : break;
204 : : }
205 : :
206 : 18709330 : return NOTIFY_DONE;
207 : : }
208 : :
209 : : static struct notifier_block vfp_notifier_block = {
210 : : .notifier_call = vfp_notifier,
211 : : };
212 : :
213 : : /*
214 : : * Raise a SIGFPE for the current process.
215 : : * sicode describes the signal being raised.
216 : : */
217 : 0 : static void vfp_raise_sigfpe(unsigned int sicode, struct pt_regs *regs)
218 : : {
219 : : /*
220 : : * This is the same as NWFPE, because it's not clear what
221 : : * this is used for
222 : : */
223 : 0 : current->thread.error_code = 0;
224 : 0 : current->thread.trap_no = 6;
225 : :
226 : 0 : send_sig_fault(SIGFPE, sicode,
227 : 0 : (void __user *)(instruction_pointer(regs) - 4),
228 : : current);
229 : 0 : }
230 : :
231 : 0 : static void vfp_panic(char *reason, u32 inst)
232 : : {
233 : : int i;
234 : :
235 : 0 : pr_err("VFP: Error: %s\n", reason);
236 : 0 : pr_err("VFP: EXC 0x%08x SCR 0x%08x INST 0x%08x\n",
237 : : fmrx(FPEXC), fmrx(FPSCR), inst);
238 [ # # ]: 0 : for (i = 0; i < 32; i += 2)
239 : 0 : pr_err("VFP: s%2u: 0x%08x s%2u: 0x%08x\n",
240 : : i, vfp_get_float(i), i+1, vfp_get_float(i+1));
241 : 0 : }
242 : :
243 : : /*
244 : : * Process bitmask of exception conditions.
245 : : */
246 : 0 : static void vfp_raise_exceptions(u32 exceptions, u32 inst, u32 fpscr, struct pt_regs *regs)
247 : : {
248 : : int si_code = 0;
249 : :
250 : : pr_debug("VFP: raising exceptions %08x\n", exceptions);
251 : :
252 [ # # ]: 0 : if (exceptions == VFP_EXCEPTION_ERROR) {
253 : 0 : vfp_panic("unhandled bounce", inst);
254 : 0 : vfp_raise_sigfpe(FPE_FLTINV, regs);
255 : 0 : return;
256 : : }
257 : :
258 : : /*
259 : : * If any of the status flags are set, update the FPSCR.
260 : : * Comparison instructions always return at least one of
261 : : * these flags set.
262 : : */
263 [ # # ]: 0 : if (exceptions & (FPSCR_N|FPSCR_Z|FPSCR_C|FPSCR_V))
264 : 0 : fpscr &= ~(FPSCR_N|FPSCR_Z|FPSCR_C|FPSCR_V);
265 : :
266 : 0 : fpscr |= exceptions;
267 : :
268 : 0 : fmxr(FPSCR, fpscr);
269 : :
270 : : #define RAISE(stat,en,sig) \
271 : : if (exceptions & stat && fpscr & en) \
272 : : si_code = sig;
273 : :
274 : : /*
275 : : * These are arranged in priority order, least to highest.
276 : : */
277 [ # # # # ]: 0 : RAISE(FPSCR_DZC, FPSCR_DZE, FPE_FLTDIV);
278 [ # # # # ]: 0 : RAISE(FPSCR_IXC, FPSCR_IXE, FPE_FLTRES);
279 [ # # # # ]: 0 : RAISE(FPSCR_UFC, FPSCR_UFE, FPE_FLTUND);
280 [ # # # # ]: 0 : RAISE(FPSCR_OFC, FPSCR_OFE, FPE_FLTOVF);
281 [ # # # # ]: 0 : RAISE(FPSCR_IOC, FPSCR_IOE, FPE_FLTINV);
282 : :
283 [ # # ]: 0 : if (si_code)
284 : 0 : vfp_raise_sigfpe(si_code, regs);
285 : : }
286 : :
287 : : /*
288 : : * Emulate a VFP instruction.
289 : : */
290 : 0 : static u32 vfp_emulate_instruction(u32 inst, u32 fpscr, struct pt_regs *regs)
291 : : {
292 : : u32 exceptions = VFP_EXCEPTION_ERROR;
293 : :
294 : : pr_debug("VFP: emulate: INST=0x%08x SCR=0x%08x\n", inst, fpscr);
295 : :
296 [ # # ]: 0 : if (INST_CPRTDO(inst)) {
297 [ # # ]: 0 : if (!INST_CPRT(inst)) {
298 : : /*
299 : : * CPDO
300 : : */
301 [ # # ]: 0 : if (vfp_single(inst)) {
302 : 0 : exceptions = vfp_single_cpdo(inst, fpscr);
303 : : } else {
304 : 0 : exceptions = vfp_double_cpdo(inst, fpscr);
305 : : }
306 : : } else {
307 : : /*
308 : : * A CPRT instruction can not appear in FPINST2, nor
309 : : * can it cause an exception. Therefore, we do not
310 : : * have to emulate it.
311 : : */
312 : : }
313 : : } else {
314 : : /*
315 : : * A CPDT instruction can not appear in FPINST2, nor can
316 : : * it cause an exception. Therefore, we do not have to
317 : : * emulate it.
318 : : */
319 : : }
320 : 0 : return exceptions & ~VFP_NAN_FLAG;
321 : : }
322 : :
323 : : /*
324 : : * Package up a bounce condition.
325 : : */
326 : 0 : void VFP_bounce(u32 trigger, u32 fpexc, struct pt_regs *regs)
327 : : {
328 : : u32 fpscr, orig_fpscr, fpsid, exceptions;
329 : :
330 : : pr_debug("VFP: bounce: trigger %08x fpexc %08x\n", trigger, fpexc);
331 : :
332 : : /*
333 : : * At this point, FPEXC can have the following configuration:
334 : : *
335 : : * EX DEX IXE
336 : : * 0 1 x - synchronous exception
337 : : * 1 x 0 - asynchronous exception
338 : : * 1 x 1 - sychronous on VFP subarch 1 and asynchronous on later
339 : : * 0 0 1 - synchronous on VFP9 (non-standard subarch 1
340 : : * implementation), undefined otherwise
341 : : *
342 : : * Clear various bits and enable access to the VFP so we can
343 : : * handle the bounce.
344 : : */
345 : 0 : fmxr(FPEXC, fpexc & ~(FPEXC_EX|FPEXC_DEX|FPEXC_FP2V|FPEXC_VV|FPEXC_TRAP_MASK));
346 : :
347 : 0 : fpsid = fmrx(FPSID);
348 : 0 : orig_fpscr = fpscr = fmrx(FPSCR);
349 : :
350 : : /*
351 : : * Check for the special VFP subarch 1 and FPSCR.IXE bit case
352 : : */
353 [ # # ]: 0 : if ((fpsid & FPSID_ARCH_MASK) == (1 << FPSID_ARCH_BIT)
354 [ # # ]: 0 : && (fpscr & FPSCR_IXE)) {
355 : : /*
356 : : * Synchronous exception, emulate the trigger instruction
357 : : */
358 : : goto emulate;
359 : : }
360 : :
361 [ # # ]: 0 : if (fpexc & FPEXC_EX) {
362 : : #ifndef CONFIG_CPU_FEROCEON
363 : : /*
364 : : * Asynchronous exception. The instruction is read from FPINST
365 : : * and the interrupted instruction has to be restarted.
366 : : */
367 : 0 : trigger = fmrx(FPINST);
368 : 0 : regs->ARM_pc -= 4;
369 : : #endif
370 [ # # ]: 0 : } else if (!(fpexc & FPEXC_DEX)) {
371 : : /*
372 : : * Illegal combination of bits. It can be caused by an
373 : : * unallocated VFP instruction but with FPSCR.IXE set and not
374 : : * on VFP subarch 1.
375 : : */
376 : 0 : vfp_raise_exceptions(VFP_EXCEPTION_ERROR, trigger, fpscr, regs);
377 : 0 : goto exit;
378 : : }
379 : :
380 : : /*
381 : : * Modify fpscr to indicate the number of iterations remaining.
382 : : * If FPEXC.EX is 0, FPEXC.DEX is 1 and the FPEXC.VV bit indicates
383 : : * whether FPEXC.VECITR or FPSCR.LEN is used.
384 : : */
385 [ # # ]: 0 : if (fpexc & (FPEXC_EX | FPEXC_VV)) {
386 : : u32 len;
387 : :
388 : 0 : len = fpexc + (1 << FPEXC_LENGTH_BIT);
389 : :
390 : 0 : fpscr &= ~FPSCR_LENGTH_MASK;
391 : 0 : fpscr |= (len & FPEXC_LENGTH_MASK) << (FPSCR_LENGTH_BIT - FPEXC_LENGTH_BIT);
392 : : }
393 : :
394 : : /*
395 : : * Handle the first FP instruction. We used to take note of the
396 : : * FPEXC bounce reason, but this appears to be unreliable.
397 : : * Emulate the bounced instruction instead.
398 : : */
399 : 0 : exceptions = vfp_emulate_instruction(trigger, fpscr, regs);
400 [ # # ]: 0 : if (exceptions)
401 : 0 : vfp_raise_exceptions(exceptions, trigger, orig_fpscr, regs);
402 : :
403 : : /*
404 : : * If there isn't a second FP instruction, exit now. Note that
405 : : * the FPEXC.FP2V bit is valid only if FPEXC.EX is 1.
406 : : */
407 [ # # ]: 0 : if ((fpexc & (FPEXC_EX | FPEXC_FP2V)) != (FPEXC_EX | FPEXC_FP2V))
408 : : goto exit;
409 : :
410 : : /*
411 : : * The barrier() here prevents fpinst2 being read
412 : : * before the condition above.
413 : : */
414 : 0 : barrier();
415 : 0 : trigger = fmrx(FPINST2);
416 : :
417 : : emulate:
418 : 0 : exceptions = vfp_emulate_instruction(trigger, orig_fpscr, regs);
419 [ # # ]: 0 : if (exceptions)
420 : 0 : vfp_raise_exceptions(exceptions, trigger, orig_fpscr, regs);
421 : : exit:
422 : 0 : preempt_enable();
423 : 0 : }
424 : :
425 : 693 : static void vfp_enable(void *unused)
426 : : {
427 : : u32 access;
428 : :
429 : : BUG_ON(preemptible());
430 : : access = get_copro_access();
431 : :
432 : : /*
433 : : * Enable full access to VFP (cp10 and cp11)
434 : : */
435 : 693 : set_copro_access(access | CPACC_FULL(10) | CPACC_FULL(11));
436 : 576 : }
437 : :
438 : : /* Called by platforms on which we want to disable VFP because it may not be
439 : : * present on all CPUs within a SMP complex. Needs to be called prior to
440 : : * vfp_init().
441 : : */
442 : 0 : void vfp_disable(void)
443 : : {
444 [ # # ]: 0 : if (VFP_arch) {
445 : : pr_debug("%s: should be called prior to vfp_init\n", __func__);
446 : 0 : return;
447 : : }
448 : 0 : VFP_arch = 1;
449 : : }
450 : :
451 : : #ifdef CONFIG_CPU_PM
452 : : static int vfp_pm_suspend(void)
453 : : {
454 : : struct thread_info *ti = current_thread_info();
455 : : u32 fpexc = fmrx(FPEXC);
456 : :
457 : : /* if vfp is on, then save state for resumption */
458 : : if (fpexc & FPEXC_EN) {
459 : : pr_debug("%s: saving vfp state\n", __func__);
460 : : /* vfp_save_state oopses on VFP11 if EX bit set */
461 : : fmxr(FPEXC, fpexc & ~FPEXC_EX);
462 : : vfp_save_state(&ti->vfpstate, fpexc);
463 : :
464 : : /* disable, just in case */
465 : : fmxr(FPEXC, fmrx(FPEXC) & ~FPEXC_EN);
466 : : } else if (vfp_current_hw_state[ti->cpu]) {
467 : : #ifndef CONFIG_SMP
468 : : /* vfp_save_state oopses on VFP11 if EX bit set */
469 : : fmxr(FPEXC, (fpexc & ~FPEXC_EX) | FPEXC_EN);
470 : : vfp_save_state(vfp_current_hw_state[ti->cpu], fpexc);
471 : : fmxr(FPEXC, fpexc);
472 : : #endif
473 : : }
474 : :
475 : : /* clear any information we had about last context state */
476 : : vfp_current_hw_state[ti->cpu] = NULL;
477 : :
478 : : return 0;
479 : : }
480 : :
481 : : static void vfp_pm_resume(void)
482 : : {
483 : : /* ensure we have access to the vfp */
484 : : vfp_enable(NULL);
485 : :
486 : : /* and disable it to ensure the next usage restores the state */
487 : : fmxr(FPEXC, fmrx(FPEXC) & ~FPEXC_EN);
488 : : }
489 : :
490 : : static int vfp_cpu_pm_notifier(struct notifier_block *self, unsigned long cmd,
491 : : void *v)
492 : : {
493 : : switch (cmd) {
494 : : case CPU_PM_ENTER:
495 : : vfp_pm_suspend();
496 : : break;
497 : : case CPU_PM_ENTER_FAILED:
498 : : case CPU_PM_EXIT:
499 : : vfp_pm_resume();
500 : : break;
501 : : }
502 : : return NOTIFY_OK;
503 : : }
504 : :
505 : : static struct notifier_block vfp_cpu_pm_notifier_block = {
506 : : .notifier_call = vfp_cpu_pm_notifier,
507 : : };
508 : :
509 : : static void vfp_pm_init(void)
510 : : {
511 : : cpu_pm_register_notifier(&vfp_cpu_pm_notifier_block);
512 : : }
513 : :
514 : : #else
515 : : static inline void vfp_pm_init(void) { }
516 : : #endif /* CONFIG_CPU_PM */
517 : :
518 : : /*
519 : : * Ensure that the VFP state stored in 'thread->vfpstate' is up to date
520 : : * with the hardware state.
521 : : */
522 : 1293297 : void vfp_sync_hwstate(struct thread_info *thread)
523 : : {
524 : 2585786 : unsigned int cpu = get_cpu();
525 : :
526 [ + + ]: 1292489 : if (vfp_state_in_hw(cpu, thread)) {
527 : 1211207 : u32 fpexc = fmrx(FPEXC);
528 : :
529 : : /*
530 : : * Save the last VFP state on this CPU.
531 : : */
532 : : /* vfp_save_state oopses on VFP11 if EX bit set */
533 : 1211207 : fmxr(FPEXC, (fpexc & ~FPEXC_EX) | FPEXC_EN);
534 : 1211214 : vfp_save_state(&thread->vfpstate, fpexc | FPEXC_EN);
535 : 1211221 : fmxr(FPEXC, fpexc);
536 : : }
537 : :
538 : 1292507 : put_cpu();
539 : 1293319 : }
540 : :
541 : : /* Ensure that the thread reloads the hardware VFP state on the next use. */
542 : 864709 : void vfp_flush_hwstate(struct thread_info *thread)
543 : : {
544 : 1729187 : unsigned int cpu = get_cpu();
545 : :
546 : : vfp_force_reload(cpu, thread);
547 : :
548 : 864478 : put_cpu();
549 : 864646 : }
550 : :
551 : : /*
552 : : * Save the current VFP state into the provided structures and prepare
553 : : * for entry into a new function (signal handler).
554 : : */
555 : 432500 : int vfp_preserve_user_clear_hwstate(struct user_vfp *ufp,
556 : : struct user_vfp_exc *ufp_exc)
557 : : {
558 : : struct thread_info *thread = current_thread_info();
559 : : struct vfp_hard_struct *hwstate = &thread->vfpstate.hard;
560 : :
561 : : /* Ensure that the saved hwstate is up-to-date. */
562 : 432500 : vfp_sync_hwstate(thread);
563 : :
564 : : /*
565 : : * Copy the floating point registers. There can be unused
566 : : * registers see asm/hwcap.h for details.
567 : : */
568 : 432203 : memcpy(&ufp->fpregs, &hwstate->fpregs, sizeof(hwstate->fpregs));
569 : :
570 : : /*
571 : : * Copy the status and control register.
572 : : */
573 : 432203 : ufp->fpscr = hwstate->fpscr;
574 : :
575 : : /*
576 : : * Copy the exception registers.
577 : : */
578 : 432203 : ufp_exc->fpexc = hwstate->fpexc;
579 : 432203 : ufp_exc->fpinst = hwstate->fpinst;
580 : 432203 : ufp_exc->fpinst2 = hwstate->fpinst2;
581 : :
582 : : /* Ensure that VFP is disabled. */
583 : 432203 : vfp_flush_hwstate(thread);
584 : :
585 : : /*
586 : : * As per the PCS, clear the length and stride bits for function
587 : : * entry.
588 : : */
589 : 432367 : hwstate->fpscr &= ~(FPSCR_LENGTH_MASK | FPSCR_STRIDE_MASK);
590 : 432367 : return 0;
591 : : }
592 : :
593 : : /* Sanitise and restore the current VFP state from the provided structures. */
594 : 432202 : int vfp_restore_user_hwstate(struct user_vfp *ufp, struct user_vfp_exc *ufp_exc)
595 : : {
596 : : struct thread_info *thread = current_thread_info();
597 : : struct vfp_hard_struct *hwstate = &thread->vfpstate.hard;
598 : : unsigned long fpexc;
599 : 432202 : u32 fpsid = fmrx(FPSID);
600 : :
601 : : /* Disable VFP to avoid corrupting the new thread state. */
602 : 432202 : vfp_flush_hwstate(thread);
603 : :
604 : : /*
605 : : * Copy the floating point registers. There can be unused
606 : : * registers see asm/hwcap.h for details.
607 : : */
608 : 432375 : memcpy(&hwstate->fpregs, &ufp->fpregs, sizeof(hwstate->fpregs));
609 : : /*
610 : : * Copy the status and control register.
611 : : */
612 : 432375 : hwstate->fpscr = ufp->fpscr;
613 : :
614 : : /*
615 : : * Sanitise and restore the exception registers.
616 : : */
617 : 432375 : fpexc = ufp_exc->fpexc;
618 : :
619 : : /* Ensure the VFP is enabled. */
620 : 432375 : fpexc |= FPEXC_EN;
621 : :
622 : : /* Mask FPXEC_EX and FPEXC_FP2V if not required by VFP arch */
623 [ + + ]: 432375 : if ((fpsid & FPSID_ARCH_MASK) != (1 << FPSID_ARCH_BIT)) {
624 : : /* Ensure FPINST2 is invalid and the exception flag is cleared. */
625 : 432393 : fpexc &= ~(FPEXC_EX | FPEXC_FP2V);
626 : : }
627 : :
628 : 432375 : hwstate->fpexc = fpexc;
629 : :
630 : 432375 : hwstate->fpinst = ufp_exc->fpinst;
631 : 432375 : hwstate->fpinst2 = ufp_exc->fpinst2;
632 : :
633 : 432375 : return 0;
634 : : }
635 : :
636 : : /*
637 : : * VFP hardware can lose all context when a CPU goes offline.
638 : : * As we will be running in SMP mode with CPU hotplug, we will save the
639 : : * hardware state at every thread switch. We clear our held state when
640 : : * a CPU has been killed, indicating that the VFP hardware doesn't contain
641 : : * a threads VFP state. When a CPU starts up, we re-enable access to the
642 : : * VFP hardware. The callbacks below are called on the CPU which
643 : : * is being offlined/onlined.
644 : : */
645 : 0 : static int vfp_dying_cpu(unsigned int cpu)
646 : : {
647 : 0 : vfp_current_hw_state[cpu] = NULL;
648 : 0 : return 0;
649 : : }
650 : :
651 : 0 : static int vfp_starting_cpu(unsigned int unused)
652 : : {
653 : : vfp_enable(NULL);
654 : 0 : return 0;
655 : : }
656 : :
657 : 0 : void vfp_kmode_exception(void)
658 : : {
659 : : /*
660 : : * If we reach this point, a floating point exception has been raised
661 : : * while running in kernel mode. If the NEON/VFP unit was enabled at the
662 : : * time, it means a VFP instruction has been issued that requires
663 : : * software assistance to complete, something which is not currently
664 : : * supported in kernel mode.
665 : : * If the NEON/VFP unit was disabled, and the location pointed to below
666 : : * is properly preceded by a call to kernel_neon_begin(), something has
667 : : * caused the task to be scheduled out and back in again. In this case,
668 : : * rebuilding and running with CONFIG_DEBUG_ATOMIC_SLEEP enabled should
669 : : * be helpful in localizing the problem.
670 : : */
671 [ # # ]: 0 : if (fmrx(FPEXC) & FPEXC_EN)
672 : 0 : pr_crit("BUG: unsupported FP instruction in kernel mode\n");
673 : : else
674 : 0 : pr_crit("BUG: FP instruction issued in kernel mode with FP unit disabled\n");
675 : 0 : }
676 : :
677 : : #ifdef CONFIG_KERNEL_MODE_NEON
678 : :
679 : : /*
680 : : * Kernel-side NEON support functions
681 : : */
682 : 0 : void kernel_neon_begin(void)
683 : : {
684 : : struct thread_info *thread = current_thread_info();
685 : : unsigned int cpu;
686 : : u32 fpexc;
687 : :
688 : : /*
689 : : * Kernel mode NEON is only allowed outside of interrupt context
690 : : * with preemption disabled. This will make sure that the kernel
691 : : * mode NEON register contents never need to be preserved.
692 : : */
693 [ # # ]: 0 : BUG_ON(in_interrupt());
694 : 0 : cpu = get_cpu();
695 : :
696 : 0 : fpexc = fmrx(FPEXC) | FPEXC_EN;
697 : : /* vfp_save_state oopses on VFP11 if EX bit set */
698 : 0 : fmxr(FPEXC, fpexc & ~FPEXC_EX);
699 : :
700 : : /*
701 : : * Save the userland NEON/VFP state. Under UP,
702 : : * the owner could be a task other than 'current'
703 : : */
704 [ # # ]: 0 : if (vfp_state_in_hw(cpu, thread))
705 : 0 : vfp_save_state(&thread->vfpstate, fpexc);
706 : : #ifndef CONFIG_SMP
707 : : else if (vfp_current_hw_state[cpu] != NULL)
708 : : vfp_save_state(vfp_current_hw_state[cpu], fpexc);
709 : : #endif
710 : 0 : vfp_current_hw_state[cpu] = NULL;
711 : 0 : }
712 : : EXPORT_SYMBOL(kernel_neon_begin);
713 : :
714 : 0 : void kernel_neon_end(void)
715 : : {
716 : : /* Disable the NEON/VFP unit. */
717 : 0 : fmxr(FPEXC, fmrx(FPEXC) & ~FPEXC_EN);
718 : 0 : put_cpu();
719 : 0 : }
720 : : EXPORT_SYMBOL(kernel_neon_end);
721 : :
722 : : #endif /* CONFIG_KERNEL_MODE_NEON */
723 : :
724 : : /*
725 : : * VFP support code initialisation.
726 : : */
727 : 207 : static int __init vfp_init(void)
728 : : {
729 : : unsigned int vfpsid;
730 : 207 : unsigned int cpu_arch = cpu_architecture();
731 : :
732 : : /*
733 : : * Enable the access to the VFP on all online CPUs so the
734 : : * following test on FPSID will succeed.
735 : : */
736 [ + - ]: 207 : if (cpu_arch >= CPU_ARCH_ARMv6)
737 : 207 : on_each_cpu(vfp_enable, NULL, 1);
738 : :
739 : : /*
740 : : * First check that there is a VFP that we can use.
741 : : * The handler is already setup to just log calls, so
742 : : * we just need to read the VFPSID register.
743 : : */
744 : 207 : vfp_vector = vfp_testing_entry;
745 : 207 : barrier();
746 : 207 : vfpsid = fmrx(FPSID);
747 : 207 : barrier();
748 : 207 : vfp_vector = vfp_null_entry;
749 : :
750 : 207 : pr_info("VFP support v0.3: ");
751 [ - + ]: 207 : if (VFP_arch) {
752 : 0 : pr_cont("not present\n");
753 : 0 : return 0;
754 : : /* Extract the architecture on CPUID scheme */
755 [ + - ]: 207 : } else if ((read_cpuid_id() & 0x000f0000) == 0x000f0000) {
756 : 207 : VFP_arch = vfpsid & FPSID_CPUID_ARCH_MASK;
757 : 207 : VFP_arch >>= FPSID_ARCH_BIT;
758 : : /*
759 : : * Check for the presence of the Advanced SIMD
760 : : * load/store instructions, integer and single
761 : : * precision floating point operations. Only check
762 : : * for NEON if the hardware has the MVFR registers.
763 : : */
764 [ + - ]: 207 : if (IS_ENABLED(CONFIG_NEON) &&
765 : 207 : (fmrx(MVFR1) & 0x000fff00) == 0x00011100)
766 : 207 : elf_hwcap |= HWCAP_NEON;
767 : :
768 : : if (IS_ENABLED(CONFIG_VFPv3)) {
769 : 207 : u32 mvfr0 = fmrx(MVFR0);
770 [ - + # # ]: 207 : if (((mvfr0 & MVFR0_DP_MASK) >> MVFR0_DP_BIT) == 0x2 ||
771 : 0 : ((mvfr0 & MVFR0_SP_MASK) >> MVFR0_SP_BIT) == 0x2) {
772 : 207 : elf_hwcap |= HWCAP_VFPv3;
773 : : /*
774 : : * Check for VFPv3 D16 and VFPv4 D16. CPUs in
775 : : * this configuration only have 16 x 64bit
776 : : * registers.
777 : : */
778 [ - + ]: 207 : if ((mvfr0 & MVFR0_A_SIMD_MASK) == 1)
779 : : /* also v4-D16 */
780 : 0 : elf_hwcap |= HWCAP_VFPv3D16;
781 : : else
782 : 207 : elf_hwcap |= HWCAP_VFPD32;
783 : : }
784 : :
785 [ + - ]: 207 : if ((fmrx(MVFR1) & 0xf0000000) == 0x10000000)
786 : 207 : elf_hwcap |= HWCAP_VFPv4;
787 : : }
788 : : /* Extract the architecture version on pre-cpuid scheme */
789 : : } else {
790 [ # # ]: 0 : if (vfpsid & FPSID_NODOUBLE) {
791 : 0 : pr_cont("no double precision support\n");
792 : 0 : return 0;
793 : : }
794 : :
795 : 0 : VFP_arch = (vfpsid & FPSID_ARCH_MASK) >> FPSID_ARCH_BIT;
796 : : }
797 : :
798 : : cpuhp_setup_state_nocalls(CPUHP_AP_ARM_VFP_STARTING,
799 : : "arm/vfp:starting", vfp_starting_cpu,
800 : : vfp_dying_cpu);
801 : :
802 : 207 : vfp_vector = vfp_support_entry;
803 : :
804 : : thread_register_notifier(&vfp_notifier_block);
805 : : vfp_pm_init();
806 : :
807 : : /*
808 : : * We detected VFP, and the support code is
809 : : * in place; report VFP support to userspace.
810 : : */
811 : 207 : elf_hwcap |= HWCAP_VFP;
812 : :
813 : 207 : pr_cont("implementor %02x architecture %d part %02x variant %x rev %x\n",
814 : : (vfpsid & FPSID_IMPLEMENTER_MASK) >> FPSID_IMPLEMENTER_BIT,
815 : : VFP_arch,
816 : : (vfpsid & FPSID_PART_MASK) >> FPSID_PART_BIT,
817 : : (vfpsid & FPSID_VARIANT_MASK) >> FPSID_VARIANT_BIT,
818 : : (vfpsid & FPSID_REV_MASK) >> FPSID_REV_BIT);
819 : :
820 : 207 : return 0;
821 : : }
822 : :
823 : : core_initcall(vfp_init);
|
