cortex_a: drop useless cache invalidate on mem write

The initial OpenOCD code for Cortex-A (ARMv7a) [1] was merged in
2009 but, due to lack of public documentation for ARMv7a, it was
almost a simple copy/paste from the existing code for Cortex-M
(ARMv7m).

On Cortex-M the same AP provides access to both CPU debug and CPU
memory. This feature is not present on ARMv7a.
To still keep some communality with ARMv7m code, the change [2]
splits the CPU debug access from the CPU memory access by using
two independent AP; this is copied from the system architecture of
TI OMAP3530 which provides to DAP a direct AHB-AP memory bus on
AP#0, separated from AP#1 for the APB-AP CPU debug.
But the direct memory access through the system bus breaks the
coherency between memory and CPU caches, so change [3] added some
cache invalidation to avoid issues.

The code to allow ARMv7a CPU to really read/write in CPU memory
was added by change [4] in 2011. Such still not optimized
implementation was very slow, so it did not replace the access
through the system bus. A selection through DAP's 'apsel" command
was used to select between the two modes.

Only in 2015, with change [5], the speed of CPU read/write was
improved using the DCC_FAST_MODE. But the direct access to the
memory through the system bus remained.

Finally, with change [6] in 2018 the system bus access was dropped
for good, as the new virtual target "mem_ap" could implement such
access in a more clean way.
Only memory access through CPU remained for ARMv7a.
Nevertheless, a useless cache invalidation remained in the code,
decreasing the speed of the write access.

Drop the useless cache invalidate on CPU memory write and the
associated comment, not anymore valid.
Drop the now unused function armv7a_cache_auto_flush_on_write().

This provides a speedup of between 4 and 8, depending on adapter
and JTAG/SWD speed.

Link: [1] 7a93100c2dfe ("Add minimalist Cortex A8 file")
Link: [2] 1d0b276c9f75 ("The rest of the Cortex-A8 support from Magnus: ...")
Link: [3] d4e4d65d284f ("Cache invalidation when writing to memory")
Link: [4] 05ab8bdb813a ("cortex_a9: implement read/write memory through APB-AP")
Link: [5] 0228f8e8274d ("Cortex A: fix extra memory read and non-word sizes")
Link: [6] fac9be64d944 ("target/cortex_a: remove buggy memory AP accesses")

Change-Id: Ifa3c7ddf2698b2c87037fb48f783844034a7140e
Signed-off-by: Antonio Borneo <borneo.antonio@gmail.com>
Reviewed-on: https://review.openocd.org/c/openocd/+/8229
Tested-by: jenkins
Reviewed-by: Oleksij Rempel <linux@rempel-privat.de>

diff --git a/src/target/armv7a_cache.c b/src/target/armv7a_cache.c
index e1f0dfafb0bdd4bc25c65e2ef349ffd6fd3544c5..681c06affca18b7a6d1202bc980370a34225b9f0 100644 (file)
--- a/src/target/armv7a_cache.c
+++ b/src/target/armv7a_cache.c
@@ -391,27 +391,6 @@ int armv7a_cache_flush_virt(struct target *target, uint32_t virt,
        return ERROR_OK;
 }
 
-/*
- * We assume that target core was chosen correctly. It means if same data
- * was handled by two cores, other core will loose the changes. Since it
- * is impossible to know (FIXME) which core has correct data, keep in mind
- * that some kind of data lost or corruption is possible.
- * Possible scenario:
- *  - core1 loaded and changed data on 0x12345678
- *  - we halted target and modified same data on core0
- *  - data on core1 will be lost.
- */
-int armv7a_cache_auto_flush_on_write(struct target *target, uint32_t virt,
-                                       uint32_t size)
-{
-       struct armv7a_common *armv7a = target_to_armv7a(target);
-
-       if (!armv7a->armv7a_mmu.armv7a_cache.auto_cache_enabled)
-               return ERROR_OK;
-
-       return armv7a_cache_flush_virt(target, virt, size);
-}
-
 COMMAND_HANDLER(arm7a_l1_cache_info_cmd)
 {
        struct target *target = get_current_target(CMD_CTX);

diff --git a/src/target/armv7a_cache.h b/src/target/armv7a_cache.h
index 17ec5e6de1fd6c7f9f9a67a9b71aa28133a85125..3e3eae55c571b94c3c093d6a559643f56b4f7513 100644 (file)
--- a/src/target/armv7a_cache.h
+++ b/src/target/armv7a_cache.h
@@ -20,8 +20,6 @@ int armv7a_l1_d_cache_flush_virt(struct target *target, uint32_t virt,
 int armv7a_l1_i_cache_inval_all(struct target *target);
 int armv7a_l1_i_cache_inval_virt(struct target *target, uint32_t virt,
                                        uint32_t size);
-int armv7a_cache_auto_flush_on_write(struct target *target, uint32_t virt,
-                                       uint32_t size);
 int armv7a_cache_auto_flush_all_data(struct target *target);
 int armv7a_cache_flush_virt(struct target *target, uint32_t virt,
                                uint32_t size);

diff --git a/src/target/cortex_a.c b/src/target/cortex_a.c
index 78fd4482c3d7e7e3913f1aa66fad733fe8884e57..f90c02a9589eb5e2a5cb25d785c0ae36c0500fe8 100644 (file)
--- a/src/target/cortex_a.c
+++ b/src/target/cortex_a.c
@@ -2791,9 +2791,6 @@ static int cortex_a_write_memory(struct target *target, target_addr_t address,
        LOG_DEBUG("Writing memory at address " TARGET_ADDR_FMT "; size %" PRIu32 "; count %" PRIu32,
                address, size, count);
 
-       /* memory writes bypass the caches, must flush before writing */
-       armv7a_cache_auto_flush_on_write(target, address, size * count);
-
        cortex_a_prep_memaccess(target, 0);
        retval = cortex_a_write_cpu_memory(target, address, size, count, buffer);
        cortex_a_post_memaccess(target, 0);