source: mainline/kernel/arch/arm32/src/fpu_context.c@ 9eec7bc

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 9eec7bc was 5fcd537, checked in by Jan Vesely <jano.vesely@…>, 13 years ago

Merge mainline changes.

Includes bbxm fpu fix and other arm changes.
Merge fix: arch defines in fpu_context.c
  • Property mode set to 100644
File size: 8.2 KB
Line 
1/*
2 * Copyright (c) 2012 Jan Vesely
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup arm32
30 * @{
31 */
32/** @file
33 * @brief arm32 FPU context
34 */
35
36#include <fpu_context.h>
37#include <arch.h>
38#include <arch/types.h>
39#include <arch/security_ext.h>
40#include <arch/cp15.h>
41#include <cpu.h>
42
43#define FPSID_IMPLEMENTER(r) ((r) >> 24)
44#define FPSID_SW_ONLY_FLAG (1 << 23)
45#define FPSID_SUBACHITECTURE(r) (((r) >> 16) & 0x7f)
46#define FPSID_PART_NUMBER(r) (((r) >> 8) & 0xff)
47#define FPSID_VARIANT(r) (((r) >> 4) 0xf)
48#define FPSID_REVISION(r) (((r) >> 0) 0xf)
49
50
51enum {
52 FPU_VFPv1 = 0x00,
53 FPU_VFPv2_COMMONv1 = 0x01,
54 FPU_VFPv3_COMMONv2 = 0x02,
55 FPU_VFPv3_NO_COMMON = 0x3, /* Does not support fpu exc. traps */
56 FPU_VFPv3_COMMONv3 = 0x4,
57};
58
59extern uint32_t fpsid_read(void);
60extern uint32_t mvfr0_read(void);
61
62enum {
63 FPEXC_EX_FLAG = (1 << 31),
64 FPEXC_ENABLED_FLAG = (1 << 30),
65};
66extern uint32_t fpexc_read(void);
67extern void fpexc_write(uint32_t);
68
69/** ARM Architecture Reference Manual ch. B4.1.58, p. B$-1551 */
70enum {
71 FPSCR_N_FLAG = (1 << 31),
72 FPSCR_Z_FLAG = (1 << 30),
73 FPSCR_C_FLAG = (1 << 29),
74 FPSCR_V_FLAG = (1 << 28),
75 FPSCR_QC_FLAG = (1 << 27),
76 FPSCR_AHP_FLAG = (1 << 26),
77 FPSCR_DN_FLAG = (1 << 25),
78 FPSCR_FZ_FLAG = (1 << 24),
79 FPSCR_ROUND_MODE_MASK = (0x3 << 22),
80 FPSCR_ROUND_TO_NEAREST = (0x0 << 22),
81 FPSCR_ROUND_TO_POS_INF = (0x1 << 22),
82 FPSCR_ROUND_TO_NEG_INF = (0x2 << 22),
83 FPSCR_ROUND_TO_ZERO = (0x3 << 22),
84 FPSCR_STRIDE_MASK = (0x3 << 20),
85 FPSCR_STRIDE_SHIFT = 20,
86 FPSCR_LEN_MASK = (0x7 << 16),
87 FPSCR_LEN_SHIFT = 16,
88 FPSCR_DENORMAL_EN_FLAG = (1 << 15),
89 FPSCR_INEXACT_EN_FLAG = (1 << 12),
90 FPSCR_UNDERFLOW_EN_FLAG = (1 << 11),
91 FPSCR_OVERFLOW_EN_FLAG = (1 << 10),
92 FPSCR_ZERO_DIV_EN_FLAG = (1 << 9),
93 FPSCR_INVALID_OP_EN_FLAG = (1 << 8),
94 FPSCR_DENORMAL_FLAG = (1 << 7),
95 FPSCR_INEXACT_FLAG = (1 << 4),
96 FPSCR_UNDERFLOW_FLAG = (1 << 3),
97 FPSCR_OVERLOW_FLAG = (1 << 2),
98 FPSCR_DIV_ZERO_FLAG = (1 << 1),
99 FPSCR_INVALID_OP_FLAG = (1 << 0),
100
101 FPSCR_EN_ALL = FPSCR_DENORMAL_EN_FLAG | FPSCR_INEXACT_EN_FLAG | FPSCR_UNDERFLOW_EN_FLAG | FPSCR_OVERFLOW_EN_FLAG | FPSCR_ZERO_DIV_EN_FLAG | FPSCR_INVALID_OP_EN_FLAG,
102};
103extern uint32_t fpscr_read(void);
104extern void fpscr_write(uint32_t);
105
106extern void fpu_context_save_s32(fpu_context_t *);
107extern void fpu_context_restore_s32(fpu_context_t *);
108extern void fpu_context_save_d16(fpu_context_t *);
109extern void fpu_context_restore_d16(fpu_context_t *);
110extern void fpu_context_save_d32(fpu_context_t *);
111extern void fpu_context_restore_d32(fpu_context_t *);
112
113static void (*save_context)(fpu_context_t *ctx);
114static void (*restore_context)(fpu_context_t *ctx);
115
116static int fpu_have_coprocessor_access()
117{
118/* The register containing the information (CPACR) is not available on armv6-
119 * rely on user decision to use CONFIG_FPU.
120 */
121#ifdef PROCESSOR_ARC_armv7_a
122 const uint32_t cpacr = CPACR_read();
123 /* FPU needs access to coprocessor 10 and 11.
124 * Moreover they need to have same access enabledd */
125 if (((cpacr & CPACR_CP_MASK(10)) != CPACR_CP_FULL_ACCESS(10)) &&
126 ((cpacr & CPACR_CP_MASK(11)) != CPACR_CP_FULL_ACCESS(11))) {
127 printf("No access to CP10 and CP11: %" PRIx32 "\n", cpacr);
128 return 0;
129 }
130#endif
131 return 1;
132}
133
134/** Enable coprocessor access. Turn both non-secure mode bit and generic access.
135 * Cortex A8 Manual says:
136 * "You must execute an Instruction Memory Barrier (IMB) sequence immediately
137 * after an update of the Coprocessor Access Control Register, see Memory
138 * Barriers in the ARM Architecture Reference Manual. You must not attempt to
139 * execute any instructions that are affected by the change of access rights
140 * between the IMB sequence and the register update."
141 * Cortex a8 TRM ch. 3.2.27. c1, Coprocessor Access Control Register
142 *
143 * @note do we need to call secure monitor here?
144 */
145static void fpu_enable_coprocessor_access()
146{
147/* The register containing the information (CPACR) is not available on armv6-
148 * rely on user decision to use CONFIG_FPU.
149 */
150#ifndef PROCESSOR_ARCH_armv7_a
151 return;
152#endif
153
154 /* Allow coprocessor access */
155 uint32_t cpacr = CPACR_read();
156 /* FPU needs access to coprocessor 10 and 11.
157 * Moreover, they need to have same access enabled */
158 cpacr &= ~(CPACR_CP_MASK(10) | CPACR_CP_MASK(11));
159 cpacr |= (CPACR_CP_FULL_ACCESS(10) | CPACR_CP_FULL_ACCESS(11));
160 CPACR_write(cpacr);
161
162 smc_coherence(0);
163}
164
165
166void fpu_init(void)
167{
168 /* Check if we have access */
169 if (!fpu_have_coprocessor_access())
170 return;
171
172 /* Clear all fpu flags */
173 fpexc_write(0);
174 fpu_enable();
175 /* Mask all exception traps,
176 * The bits are RAZ/WI on archs that don't support fpu exc traps.
177 */
178 fpscr_write(fpscr_read() & ~FPSCR_EN_ALL);
179}
180
181void fpu_setup(void)
182{
183 /* Enable coprocessor access*/
184 fpu_enable_coprocessor_access();
185
186 /* Check if we succeeded */
187 if (!fpu_have_coprocessor_access())
188 return;
189
190 const uint32_t fpsid = fpsid_read();
191 if (fpsid & FPSID_SW_ONLY_FLAG) {
192 printf("No FPU avaiable\n");
193 return;
194 }
195 switch (FPSID_SUBACHITECTURE(fpsid))
196 {
197 case FPU_VFPv1:
198 printf("Detected VFPv1\n");
199 save_context = fpu_context_save_s32;
200 restore_context = fpu_context_restore_s32;
201 break;
202 case FPU_VFPv2_COMMONv1:
203 printf("Detected VFPv2\n");
204 save_context = fpu_context_save_d16;
205 restore_context = fpu_context_restore_d16;
206 break;
207 case FPU_VFPv3_COMMONv2:
208 case FPU_VFPv3_NO_COMMON:
209 case FPU_VFPv3_COMMONv3: {
210 const uint32_t mvfr0 = mvfr0_read();
211 /* See page B4-1637 */
212 if ((mvfr0 & 0xf) == 0x1) {
213 printf("Detected VFPv3+ with 16 regs\n");
214 save_context = fpu_context_save_d16;
215 restore_context = fpu_context_restore_d16;
216 } else {
217 printf("Detected VFPv3+ with 32 regs\n");
218 save_context = fpu_context_save_d32;
219 restore_context = fpu_context_restore_d32;
220 }
221 break;
222 }
223
224 }
225}
226
227bool handle_if_fpu_exception(void)
228{
229 /* Check if we have access */
230 if (!fpu_have_coprocessor_access())
231 return false;
232
233 const uint32_t fpexc = fpexc_read();
234 if (fpexc & FPEXC_ENABLED_FLAG) {
235 const uint32_t fpscr = fpscr_read();
236 printf("FPU exception\n"
237 "\tFPEXC: %" PRIx32 " FPSCR: %" PRIx32 "\n", fpexc, fpscr);
238 return false;
239 }
240#ifdef CONFIG_FPU_LAZY
241 scheduler_fpu_lazy_request();
242 return true;
243#else
244 return false;
245#endif
246}
247
248void fpu_enable(void)
249{
250 /* Check if we have access */
251 if (!fpu_have_coprocessor_access())
252 return;
253 /* Enable FPU instructions */
254 fpexc_write(fpexc_read() | FPEXC_ENABLED_FLAG);
255}
256
257void fpu_disable(void)
258{
259 /* Check if we have access */
260 if (!fpu_have_coprocessor_access())
261 return;
262 /* Disable FPU instructions */
263 fpexc_write(fpexc_read() & ~FPEXC_ENABLED_FLAG);
264}
265
266void fpu_context_save(fpu_context_t *ctx)
267{
268 /* This is only necessary if we enable fpu exceptions. */
269#if 0
270 const uint32_t fpexc = fpexc_read();
271
272 if (fpexc & FPEXC_EX_FLAG) {
273 printf("EX FPU flag is on, things will fail\n");
274 //TODO implement common subarch context saving
275 }
276#endif
277 if (save_context)
278 save_context(ctx);
279}
280
281void fpu_context_restore(fpu_context_t *ctx)
282{
283 if (restore_context)
284 restore_context(ctx);
285}
Note: See TracBrowser for help on using the repository browser.