K64F vMPU: Use the MPU fault address

When recovering from an MPU fault on K64F, we were using the bus fault
syndrome register. This register does not contain a valid address when
the bus fault is imprecise.

On the other hand, the syndrome register for the MPU module always
contains a valid register when an MPU fault occur.

This commit introduces 2 `inline` APIs to fetch and clear the fault
status for a given slave port, and uses them to recover from a potential
MPU fault.

This fixes a bug found in release builds of our `blinky` example, where
some faults were imprecise.

Fixes:
* 2c565f8 Implement recovering from page heap faults

Author: AlessandroA

core/system/inc/mpu/vmpu_freescale_k64.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2016, ARM Limited, All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef __VMPU_FREESCALE_K64_H__
+#define __VMPU_FREESCALE_K64_H__
+
+/* MPU fault status codes */
+#define VMPU_FAULT_NONE     (-1)
+#define VMPU_FAULT_MULTIPLE (-2)
+
+/** Get the slave port number from the MPU->CESR SPERR field.
+ * @returns The slave port number, or a negative value to signal an error
+ * @retval \ref VMPU_FAULT_NONE     No MPU violation found
+ * @retval \ref VMPU_FAULT_MULTIPLE Multiple MPU violations found
+ */
+UVISOR_FORCEINLINE int vmpu_fault_get_slave_port(void)
+{
+    uint32_t mpu_cesr_sperr = (MPU->CESR & MPU_CESR_SPERR_MASK) >> MPU_CESR_SPERR_SHIFT;
+    switch (mpu_cesr_sperr) {
+        case 0x00:
+            return VMPU_FAULT_NONE;
+        case 0x01:
+            return 4;
+        case 0x02:
+            return 3;
+        case 0x04:
+            return 2;
+        case 0x08:
+            return 1;
+        case 0x10:
+            return 0;
+        default:
+            return VMPU_FAULT_MULTIPLE;
+    }
+}
+
+/** Clear the fault bits in the MPU->CESR SPERR field.
+ * @note We only clear the fault required by the input argument. If there are
+ * multiple faults only one will be cleared.
+ * @param slave_port[in]    Slave port number for which the fault must be
+ *                          cleared
+ */
+UVISOR_FORCEINLINE void vmpu_fault_clear_slave_port(int slave_port)
+{
+    /* We only clear the bits if the slave port is valid. */
+    if (slave_port >= 0 && slave_port <= 4) {
+        uint32_t slave_port_bits = 1 << ((uint32_t) slave_port);
+        MPU->CESR |= (slave_port_bits << MPU_CESR_SPERR_SHIFT) & MPU_CESR_SPERR_SHIFT;
+    }
+}
+
+#endif /* __VMPU_FREESCALE_K64_H__ */

core/system/src/mpu/vmpu_freescale_k64.c

@@ -22,15 +22,15 @@
 #include "svc.h"
 #include "unvic.h"
 #include "vmpu.h"
+#include "vmpu_freescale_k64.h"
 #include "vmpu_freescale_k64_aips.h"
 #include "vmpu_freescale_k64_mem.h"
 #include "page_allocator_faults.h"
 
 uint32_t g_box_mem_pos;
 
-static int vmpu_fault_recovery_mpu(uint32_t pc, uint32_t sp, uint32_t fault_addr, uint32_t fault_status)
+static int vmpu_fault_recovery_mpu(uint32_t pc, uint32_t sp, uint32_t fault_addr)
 {
-    (void) fault_status;
     uint32_t start_addr, end_addr;
     uint8_t page;
 
@@ -92,9 +92,25 @@ void vmpu_sys_mux_handler(uint32_t lr, uint32_t msp)
                 fault_status = VMPU_SCB_BFSR;
 
                 /* check if the fault is an MPU fault */
-                if (MPU->CESR >> 27 && !vmpu_fault_recovery_mpu(pc, psp, fault_addr, fault_status)) {
-                    VMPU_SCB_BFSR = fault_status;
-                    return;
+                int slave_port = vmpu_fault_get_slave_port();
+                if (slave_port >= 0) {
+                    /* If the fault comes from the MPU module, we don't use the
+                     * bus fault syndrome register, but the MPU one. */
+                    fault_addr = MPU->SP[slave_port].EAR;
+
+                    /* Check if we can recover from the MPU fault. */
+                    if (!vmpu_fault_recovery_mpu(pc, psp, fault_addr)) {
+                        /* We clear the bus fault status anyway. */
+                        VMPU_SCB_BFSR = fault_status;
+
+                        /* We also clear the MPU fault status bit. */
+                        vmpu_fault_clear_slave_port(slave_port);
+
+                        /* Recover from the exception. */
+                        return;
+                    }
+                } else if (slave_port == VMPU_FAULT_MULTIPLE) {
+                    DPRINTF("Multiple MPU violations found.\r\n");
                 }
 
                 /* check if the fault is the special register corner case */