RISC-V non-coherent function pointer based cache management operations + non-coherent DMA support for AX45MP
Subsystems (4)
v6 cover RISC-V non-coherent function pointer based cache management operations + non-coherent DMA support for AX45MP
From: Lad Prabhakar <[email protected]>
Hi All,
RISC-V non-coherent function pointer based cache management operations
=======================================================================
As based on the previous discussion [0]. [1], It was suggested upon the below:
* Move out cache drivers from drivers/soc/folder
* Implement function pointers for CMO instead of ALTERNATIVE_x() macro
* Add cache drivers to drivers/cache folder
[0] https://lore.kernel.org/all/[email protected]/
[1] https://lore.kernel.org/linux-riscv/Y62nOqzyuUKqYDpq@spud/#R
This v6 version of the patch series add support to use function pointers for CMO and switches the current CMO implementations for zicbom and T-HEAD to use function pointers.
Note, with the above approach we might see some performance degradation due to additional checks.
----------x---------------------x--------------------x---------------x--------------
non-coherent DMA support for AX45MP
====================================
On the Andes AX45MP core, cache coherency is a specification option so it may not be supported. In this case DMA will fail. To get around with this issue this patch series does the below:
1] Andes alternative ports is implemented as errata which checks if the IOCP is missing and only then applies to CMO errata. One vendor specific SBI EXT (RZFIVE_SBI_EXT_IOCP_SW_WORKAROUND) is implemented as part of errata. If we could access the DTB in errata I can get rid of this EXT ID from OpenSBI. Is there any approach we can access the DTB in patch callback?
Below are the configs which Andes port provides (and are selected by RZ/Five):
- ERRATA_ANDES
- ERRATA_ANDES_CMO
2] Andes AX45MP core has a Programmable Physical Memory Attributes (PMA) block that allows dynamic adjustment of memory attributes in the runtime. It contains a configurable amount of PMA entries implemented as CSR registers to control the attributes of memory locations in interest. OpenSBI configures the PMA regions as required and creates a reserve memory node and propagates it to the higher boot stack.
An RFC patch for OpenSBI is posted here:
https://patchwork.ozlabs.org/project/opensbi/patch/[email protected]/
reserved-memory {
#address-cells = <2>;
#size-cells = <2>;
ranges;
pma_resv0@58000000 {
compatible = "shared-dma-pool";
reg = <0x0 0x58000000 0x0 0x08000000>;
no-map;
linux,dma-default;
};
};The above shared DMA pool gets appended to Linux DTB so the DMA memory requests go through this region.
3] We provide callbacks to synchronize specific content between memory and cache.
- arch_sync_dma_for_device()
- arch_sync_dma_for_cpu()
4] RZ/Five SoC selects the below configs
- AX45MP_L2_CACHE
- DMA_GLOBAL_POOL
- ERRATA_ANDES
- ERRATA_ANDES_CMO
OpenSBI implementation patches can be found here:
1] https://patchwork.ozlabs.org/project/opensbi/cover/[email protected]/
2]https://patchwork.ozlabs.org/project/opensbi/patch/[email protected]/ ----------x---------------------x--------------------x---------------x--------------
Note,
- This series requires testing on Cores with zicbom and T-Head SoCs
- Ive used GCC 12.2.0 for compilation (tested with allmodconfig)
- Tested all the IP blocks on RZ/Five which use DMA
v5.1 -> v6
* Dropped use of ALTERNATIVE_x() macro
* Now switched to used function pointers for CMO
* Moved driver to drivers/cache folder
v5 -> v5.1
* https://patchwork.kernel.org/project/linux-riscv/list/?series=708610&state=%2A&archive=both
v4 -> v5
* Rebased ALTERNATIVE_3() macro on top of Andrew's patches
* Rebased the changes on top of Heiko's alternative call patches
* Dropped configuring the PMA from Linux
* Dropped configuring the L2 cache from Linux and dropped the binding for same
* Now using runtime patching mechanism instead of compile time config
RFC v3 -> v4
* Implemented ALTERNATIVE_3() macro
* Now using runtime patching mechanism instead of compile time config
* Added Andes CMO as and errata
* Fixed comments pointed by Geert
RFC v2-> RFC v3
* Fixed review comments pointed by Conor
* Move DT binding into cache folder
* Fixed DT binding check issue
* Added andestech,ax45mp-cache.h header file
* Now passing the flags for the PMA setup as part of andestech,pma-regions property.
* Added andestech,inst/data-prefetch and andestech,tag/data-ram-ctl properties to configure the L2 cache.
* Registered the cache driver as platform driver
RFC v1-> RFC v2
* Moved out the code from arc/riscv to drivers/soc/renesas
* Now handling the PMA setup as part of the L2 cache
* Now making use of dma-noncoherent.c instead SoC specific implementation.
* Dropped arch_dma_alloc() and arch_dma_free()
* Switched to RISCV_DMA_NONCOHERENT
* Included DT binding doc
RFC v2: https://patchwork.kernel.org/project/linux-renesas-soc/cover/[email protected]/
RFC v1: https://patchwork.kernel.org/project/linux-renesas-soc/cover/[email protected]/
Cheers,
Prabhakar
Lad Prabhakar (6):
riscv: mm: dma-noncoherent: Switch using function pointers for cache
management
riscv: asm: vendorid_list: Add Andes Technology to the vendors list
riscv: errata: Add Andes alternative ports
dt-bindings: cache: r9a07g043f-l2-cache: Add DT binding documentation
for L2 cache controller
cache: Add L2 cache management for Andes AX45MP RISC-V core
soc: renesas: Kconfig: Select the required configs for RZ/Five SoC
.../cache/andestech,ax45mp-cache.yaml | 81 +++++ arch/riscv/Kconfig.erratas | 22 ++ arch/riscv/errata/Makefile | 1 + arch/riscv/errata/andes/Makefile | 1 + arch/riscv/errata/andes/errata.c | 71 +++++ arch/riscv/errata/thead/errata.c | 71 +++++ arch/riscv/include/asm/alternative.h | 3 + arch/riscv/include/asm/dma-noncoherent.h | 83 ++++++ arch/riscv/include/asm/errata_list.h | 53 ---- arch/riscv/include/asm/vendorid_list.h | 1 + arch/riscv/kernel/alternative.c | 5 + arch/riscv/kernel/cpufeature.c | 2 + arch/riscv/mm/dma-noncoherent.c | 94 +++++- arch/riscv/mm/pmem.c | 18 +- drivers/Kconfig | 2 + drivers/Makefile | 1 + drivers/cache/Kconfig | 10 + drivers/cache/Makefile | 3 + drivers/cache/ax45mp_cache.c | 279 ++++++++++++++++++ drivers/soc/renesas/Kconfig | 4 + 20 files changed, 744 insertions(+), 61 deletions(-) create mode 100644 Documentation/devicetree/bindings/cache/andestech,ax45mp-cache.yaml create mode 100644 arch/riscv/errata/andes/Makefile create mode 100644 arch/riscv/errata/andes/errata.c create mode 100644 arch/riscv/include/asm/dma-noncoherent.h create mode 100644 drivers/cache/Kconfig create mode 100644 drivers/cache/Makefile create mode 100644 drivers/cache/ax45mp_cache.c
Signature · 1 line
2.25.1
RFC PATCH v6 1/6 riscv: mm: dma-noncoherent: Switch using function pointers for cache management
From: Lad Prabhakar <[email protected]>
The current implementation of CMO was handled using the ALTERNATIVE_X() macro; this was manageable when there were a limited number of platforms using this. Now that we are having more and more platforms coming through with the CMO the use of the ALTERNATIVE_X() macro becomes unmanageable.
To avoid such issues this patch switches to use of function pointers instead of ALTERNATIVE_X() macro for cache management (the only draw being performance over the previous approach).
void (*clean_range)(unsigned long addr, unsigned long size); void (*inv_range)(unsigned long addr, unsigned long size); void (*flush_range)(unsigned long addr, unsigned long size);
The above function pointers are provided to be overridden where platforms using standard approach and for platforms who want handle the operation based on the operation the below function pointer is provided:
void (*riscv_dma_noncoherent_cmo_ops)(void *vaddr, size_t size,
enum dma_data_direction dir, enum dma_noncoherent_ops ops);
In the current patch we have moved the ZICBOM and T-Head CMO to use function pointers.
---v5->v6
* New patch
--- arch/riscv/errata/thead/errata.c | 71 ++++++++++++++++++ arch/riscv/include/asm/dma-noncoherent.h | 83 +++++++++++++++++++++ arch/riscv/include/asm/errata_list.h | 53 ------------- arch/riscv/kernel/cpufeature.c | 2 + arch/riscv/mm/dma-noncoherent.c | 94 ++++++++++++++++++++++-- arch/riscv/mm/pmem.c | 18 ++++- 6 files changed, 260 insertions(+), 61 deletions(-) create mode 100644 arch/riscv/include/asm/dma-noncoherent.h
arch/riscv/errata/thead/errata.c +71 -0
@@ -8,12 +8,72 @@#include <linux/module.h> #include <linux/string.h> #include <linux/uaccess.h> +#include <asm/dma-noncoherent.h> #include <asm/alternative.h> #include <asm/cacheflush.h> #include <asm/errata_list.h> #include <asm/patch.h> #include <asm/vendorid_list.h> +#ifdef CONFIG_ERRATA_THEAD_CMO +/* +* dcache.ipa rs1 (invalidate, physical address) +* | 31 - 25 | 24 - 20 | 19 - 15 | 14 - 12 | 11 - 7 | 6 - 0 | +* 0000001 01010 rs1 000 00000 0001011 +* dache.iva rs1 (invalida, virtual address) +* 0000001 00110 rs1 000 00000 0001011 +* +* dcache.cpa rs1 (clean, physical address) +* | 31 - 25 | 24 - 20 | 19 - 15 | 14 - 12 | 11 - 7 | 6 - 0 | +* 0000001 01001 rs1 000 00000 0001011 +* dcache.cva rs1 (clean, virtual address) +* 0000001 00100 rs1 000 00000 0001011 +* +* dcache.cipa rs1 (clean then invalidate, physical address) +* | 31 - 25 | 24 - 20 | 19 - 15 | 14 - 12 | 11 - 7 | 6 - 0 | +* 0000001 01011 rs1 000 00000 0001011 +* dcache.civa rs1 (... virtual address) +* 0000001 00111 rs1 000 00000 0001011 +* +* sync.s (make sure all cache operations finished) +* | 31 - 25 | 24 - 20 | 19 - 15 | 14 - 12 | 11 - 7 | 6 - 0 | +* 0000000 11001 00000 000 00000 0001011 +*/ +#define THEAD_inval_A0 ".long 0x0265000b" +#define THEAD_clean_A0 ".long 0x0245000b" +#define THEAD_flush_A0 ".long 0x0275000b" +#define THEAD_SYNC_S ".long 0x0190000b" + +#define THEAD_CMO_OP (_op, _start, _size, _cachesize) \ + asm volatile("mv a0, %1\n\t" \ + "j 2f\n\t" \ + "3:\n\t" \ + THEAD_##_op##_A0 "\n\t" \ + "add a0, a0, %0\n\t" \ + "2:\n\t" \ + "bltu a0, %2, 3b\n\t" \ + THEAD_SYNC_S \ + : : "r"(_cachesize), \ + "r"((unsigned long)(_start) & ~((_cachesize) - 1UL)), \ + "r"((unsigned long)(_start) + (_size)) \ + : "a0") + +static void thead_cmo_clean_range (unsigned long addr,unsigned long size) +{ +THEAD_CMO_OP (clean, addr, size, riscv_cbom_block_size); +} + +static void thead_cmo_flush_range (unsigned long addr,unsigned long size) +{ +THEAD_CMO_OP (flush, addr, size, riscv_cbom_block_size); +} + +static void thead_cmo_inval_range (unsigned long addr,unsigned long size) +{ +THEAD_CMO_OP (inval, addr, size, riscv_cbom_block_size); +} +#endif +static bool errata_probe_pbmt (unsigned int stage,unsigned long arch_id,unsigned long impid) {
@@ -33,6 +93,8 @@ static bool errata_probe_pbmt(unsigned int stage,static bool errata_probe_cmo (unsigned int stage,unsigned long arch_id,unsigned long impid) { +struct riscv_cache_ops thead_cmo_ops; +if (!IS_ENABLED (CONFIG_ERRATA_THEAD_CMO ))return false;
@@ -44,6 +106,15 @@ static bool errata_probe_cmo(unsigned int stage, riscv_cbom_block_size =L1_CACHE_BYTES ;riscv_noncoherent_supported (); + +memset (&thead_cmo_ops,0x0 ,sizeof (thead_cmo_ops)); +if (IS_ENABLED (CONFIG_ERRATA_THEAD_CMO )) { + thead_cmo_ops.clean_range = &thead_cmo_clean_range; + thead_cmo_ops.inv_range = &thead_cmo_inval_range; + thead_cmo_ops.flush_range = &thead_cmo_flush_range; +riscv_noncoherent_register_cache_ops (&thead_cmo_ops); + } +return true; }
arch/riscv/include/asm/dma-noncoherent.h new file +83 -0
83 lines not on this page · raw message
arch/riscv/include/asm/errata_list.h +0 -53
59 lines not on this page · raw message
arch/riscv/kernel/cpufeature.c +2 -0
@@ -14,6 +14,7 @@#include <linux/of.h> #include <asm/alternative.h> #include <asm/cacheflush.h> +#include <asm/dma-noncoherent.h> #include <asm/errata_list.h> #include <asm/hwcap.h> #include <asm/patch.h>
@@ -298,6 +299,7 @@ static bool __init_or_module cpufeature_probe_zicbom(unsigned int stage)return false;riscv_noncoherent_supported (); +riscv_noncoherent_register_cache_ops (&zicbom_cmo_ops);return true; }
arch/riscv/mm/dma-noncoherent.c +89 -5
134 lines not on this page · raw message
arch/riscv/mm/pmem.c +15 -3
@@ -6,16 +6,28 @@#include <linux/export.h> #include <linux/libnvdimm.h> -#include <asm/cacheflush.h> +#include <asm/dma-noncoherent.h> void arch_wb_cache_pmem (void *addr,size_t size) { -ALT_CMO_OP (clean, addr, size, riscv_cbom_block_size); +if (noncoherent_cache_ops.riscv_dma_noncoherent_cmo_ops) { + noncoherent_cache_ops.riscv_dma_noncoherent_cmo_ops (addr, size, +-1 ,NON_COHERENT_DMA_PMEM ); +return ; + } + +riscv_dma_noncoherent_clean (addr, size); }EXPORT_SYMBOL_GPL (arch_wb_cache_pmem);void arch_invalidate_pmem (void *addr,size_t size) { -ALT_CMO_OP (inval, addr, size, riscv_cbom_block_size); +if (noncoherent_cache_ops.riscv_dma_noncoherent_cmo_ops) { + noncoherent_cache_ops.riscv_dma_noncoherent_cmo_ops (addr, size, +-1 ,NON_COHERENT_DMA_PMEM ); +return ; + } + +riscv_dma_noncoherent_inval (addr, size); }EXPORT_SYMBOL_GPL (arch_invalidate_pmem);
Signature · 1 line
2.25.1
Re: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
Quoted 19 lines · Prabhakar
From: Lad Prabhakar <[email protected]>
The current implementation of CMO was handled using the
ALTERNATIVE_X()macro; this was manageable when there were a limited number of platforms using this. Now that we are having more and more platforms coming through with the CMO the use of theALTERNATIVE_X()macro becomes unmanageable.To avoid such issues this patch switches to use of function pointers instead of
ALTERNATIVE_X()macro for cache management (the only draw being performance over the previous approach).void (*clean_range)(unsigned long addr, unsigned long size); void (*inv_range)(unsigned long addr, unsigned long size); void (*flush_range)(unsigned long addr, unsigned long size);
The above function pointers are provided to be overridden where platforms using standard approach and for platforms who want handle the operation based on the operation the below function pointer is provided:
Quoted 8 lines
void (*riscv_dma_noncoherent_cmo_ops)(void *vaddr,
size_tsize,
enumdma_data_directiondir, enumdma_noncoherent_opsops);In the current patch we have moved the ZICBOM and T-Head CMO to use function pointers.
Signed-off-by Lad Prabhakar <[email protected]>
This looks like a nice improvement! I have a few suggestions for improvements, but no objections here.
Quoted 4 lines
arch/riscv/errata/thead/errata.c +0
-0
...
arch/riscv/errata/thead/errata.c static bool errata_probe_cmo(unsigned int stage, · line 116
Quoted 12 lines
arch/riscv/errata/thead/errata.c +8
-0@@ -44,6 +106,15 @@ static bool errata_probe_cmo(unsigned int stage, riscv_cbom_block_size =L1_CACHE_BYTES ;riscv_noncoherent_supported (); + +memset (&thead_cmo_ops,0x0 ,sizeof (thead_cmo_ops)); +if (IS_ENABLED (CONFIG_ERRATA_THEAD_CMO )) { + thead_cmo_ops.clean_range = &thead_cmo_clean_range; + thead_cmo_ops.inv_range = &thead_cmo_inval_range; + thead_cmo_ops.flush_range = &thead_cmo_flush_range; +riscv_noncoherent_register_cache_ops (&thead_cmo_ops); + }
The implementation here looks reasonable, just wonder whether the classification as an 'errata' makes sense. I would probably consider this a 'driver' at this point, but that's just a question of personal preference.
For the operations structure, I think a 'static const struct riscv_cache_ops' is more intuitive than assigning the members individually.
Quoted 19 lines
arch/riscv/errata/thead/errata.c +14
-0+ +enum dma_noncoherent_ops { +NON_COHERENT_SYNC_DMA_FOR_DEVICE =0 , +NON_COHERENT_SYNC_DMA_FOR_CPU , +NON_COHERENT_DMA_PREP , +NON_COHERENT_DMA_PMEM , +}; + +/* +* struct riscv_cache_ops - Structure for CMO function pointers +* @clean_range: Function pointer for clean cache +* @inv_range: Function pointer for invalidate cache +* @flush_range: Function pointer for flushing the cache +* @riscv_dma_noncoherent_cmo_ops: Function pointer for platforms who want
+ * to handle CMO themselves. If this function pointer is set rest of the
+ * function pointers will be NULL.
+ */
arch/riscv/errata/thead/errata.c
Quoted 8 lines
arch/riscv/errata/thead/errata.c +8
-0+struct riscv_cache_ops { +void (*clean_range)(unsigned long addr,unsigned long size); +void (*inv_range)(unsigned long addr,unsigned long size); +void (*flush_range)(unsigned long addr,unsigned long size); +void (*riscv_dma_noncoherent_cmo_ops)(void *vaddr,size_t size, +enum dma_data_direction dir, +enum dma_noncoherent_ops ops); +};
I don't quite see how the fourth operation is used here. Are there cache controllers that need something beyond clean/inv/flush?
Quoted 13 lines
arch/riscv/errata/thead/errata.c +4
-0+ +#else + +static void riscv_noncoherent_register_cache_ops(struct
riscv_cache_ops*ops) {}arch/riscv/errata/thead/errata.c +2
-0+ +static inline void riscv_dma_noncoherent_clean(void *vaddr, size_tsize) {}
arch/riscv/errata/thead/errata.c +2
-0+ +static inline void riscv_dma_noncoherent_flush(void *vaddr, size_tsize) {}
arch/riscv/errata/thead/errata.c +2
-0+ +static inline void riscv_dma_noncoherent_inval(void *vaddr, size_t
Quoted 1 line
size) {}
I think you can drop the #else path here: if there is no noncoherent DMA, then nothing should ever call these functions, right?
Quoted 2 lines
arch/riscv/errata/thead/errata.c +2
-0+ +#ifdef CONFIG_RISCV_ISA_ZICBOM
...
Quoted 4 lines
arch/riscv/errata/thead/errata.c +4
-0+struct riscv_cache_ops zicbom_cmo_ops = { + .clean_range = &zicbom_cmo_clean_range, + .inv_range = &zicbom_cmo_inval_range, + .flush_range = &zicbom_cmo_flush_range,
arch/riscv/errata/thead/errata.c
Quoted 10 lines
arch/riscv/errata/thead/errata.c +10
-0+}; +#else +struct riscv_cache_ops zicbom_cmo_ops = { + .clean_range =NULL , + .inv_range =NULL , + .flush_range =NULL , + .riscv_dma_noncoherent_cmo_ops =NULL , +}; +#endif +EXPORT_SYMBOL (zicbom_cmo_ops);
Same here: If the ZICBOM ISA is disabled, nothing should reference zicbom_cmo_ops. Also, since ZICBOM is a standard extension, I think it makes sense to always have it enabled, at least whenever noncoherent DMA is supported, that way it can be the default that gets used in the absence of any nonstandard cache controller.
Arnd
Conor Dooley
maintainerRe: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
Quoted 20 lines · Arnd Bergmann
Quoted 5 lines · Prabhakar
From: Lad Prabhakar <[email protected]>
arch/riscv/mm/dma-noncoherent.c +4
-0+struct riscv_cache_ops zicbom_cmo_ops = { + .clean_range = &zicbom_cmo_clean_range, + .inv_range = &zicbom_cmo_inval_range, + .flush_range = &zicbom_cmo_flush_range,arch/riscv/mm/dma-noncoherent.c line 66
Quoted 10 lines
arch/riscv/mm/dma-noncoherent.c +10
-0+}; +#else +struct riscv_cache_ops zicbom_cmo_ops = { + .clean_range =NULL , + .inv_range =NULL , + .flush_range =NULL , + .riscv_dma_noncoherent_cmo_ops =NULL , +}; +#endif +EXPORT_SYMBOL (zicbom_cmo_ops);Same here: If the ZICBOM ISA is disabled, nothing should reference
zicbom_cmo_ops.
Quoted 5 lines
Also, since ZICBOM is a standard
extension, I think it makes sense to always have it enabled, at least whenever noncoherent DMA is supported, that way it can be the default that gets used in the absence of any nonstandard cache controller.
While I think of it, this is not possible as Zicbom requires toolchain support whereas the alternative methods for non-coherent DMA do not.
Thanks,
Conor.
Re: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
Quoted 21 lines · Conor Dooley
Quoted 19 lines · Arnd Bergmann
Quoted 5 lines · Prabhakar
From: Lad Prabhakar <[email protected]>
arch/riscv/mm/dma-noncoherent.c +4
-0+struct riscv_cache_ops zicbom_cmo_ops = { + .clean_range = &zicbom_cmo_clean_range, + .inv_range = &zicbom_cmo_inval_range, + .flush_range = &zicbom_cmo_flush_range,arch/riscv/mm/dma-noncoherent.c line 66
Quoted 10 lines
arch/riscv/mm/dma-noncoherent.c +10
-0+}; +#else +struct riscv_cache_ops zicbom_cmo_ops = { + .clean_range =NULL , + .inv_range =NULL , + .flush_range =NULL , + .riscv_dma_noncoherent_cmo_ops =NULL , +}; +#endif +EXPORT_SYMBOL (zicbom_cmo_ops);Same here: If the ZICBOM ISA is disabled, nothing should reference
zicbom_cmo_ops.
Quoted 8 lines
Quoted 5 lines
Also, since ZICBOM is a standard
extension, I think it makes sense to always have it enabled, at least whenever noncoherent DMA is supported, that way it can be the default that gets used in the absence of any nonstandard cache controller.While I think of it, this is not possible as Zicbom requires toolchain support whereas the alternative methods for non-coherent DMA do not.
Ah, I see. Would it be possible to use the same .long trick as in the other ones though? Something like
#if CONFIG_AS_VERSION >= 23600 /* or whichever version */
/* proper inline asm */
#else
/* .long hack */#endif
That way everyone can use it, and the hack would automatically go away in a few years after linux requires a newer toolchain.
Alternatively, the entire noncoherent-dma support could be made to depend on whichever toolchain introduced Zicbom.
Arnd
Conor Dooley
maintainerRe: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
Quoted 40 lines · Arnd Bergmann
Quoted 21 lines · Conor Dooley
Quoted 19 lines · Arnd Bergmann
Quoted 5 lines · Prabhakar
From: Lad Prabhakar <[email protected]>
arch/riscv/mm/dma-noncoherent.c +4
-0+struct riscv_cache_ops zicbom_cmo_ops = { + .clean_range = &zicbom_cmo_clean_range, + .inv_range = &zicbom_cmo_inval_range, + .flush_range = &zicbom_cmo_flush_range,arch/riscv/mm/dma-noncoherent.c line 66
Quoted 10 lines
arch/riscv/mm/dma-noncoherent.c +10
-0+}; +#else +struct riscv_cache_ops zicbom_cmo_ops = { + .clean_range =NULL , + .inv_range =NULL , + .flush_range =NULL , + .riscv_dma_noncoherent_cmo_ops =NULL , +}; +#endif +EXPORT_SYMBOL (zicbom_cmo_ops);Same here: If the ZICBOM ISA is disabled, nothing should reference
zicbom_cmo_ops.Quoted 8 lines
Quoted 5 lines
Also, since ZICBOM is a standard
extension, I think it makes sense to always have it enabled, at least whenever noncoherent DMA is supported, that way it can be the default that gets used in the absence of any nonstandard cache controller.While I think of it, this is not possible as Zicbom requires toolchain support whereas the alternative methods for non-coherent DMA do not.
Ah, I see. Would it be possible to use the same .long trick as in the other ones though? Something like
#if
CONFIG_AS_VERSION>= 23600 /* or whichever version *//* proper inline asm */ #else /* .long hack */
Quoted 7 lines
#endif
That way everyone can use it, and the hack would automatically go away in a few years after linux requires a newer toolchain.
Alternatively, the entire noncoherent-dma support could be made to depend on whichever toolchain introduced Zicbom.
Ehh, I don't think that's a great idea. It'd require far too recent a toolchain IMO.
Ideally, in my opinion, we'd just do something like what Drew has proposed for Zicboz, negating the need for a check at all:
https://lore.kernel.org/linux-riscv/[email protected]/
Been waiting for that to be re-spun and Palmer to accept it before doing the same thing for Zicbom. At present we have this in the arch Kconfig:
config TOOLCHAIN_HAS_ZICBOM
bool default y depends on !64BIT || $(cc-option,-mabi=lp64 -march=rv64ima_zicbom) depends on !32BIT || $(cc-option,-mabi=ilp32 -march=rv32ima_zicbom) depends on LLD_VERSION >= 150000 || LD_VERSION >= 23800
config RISCV_ISA_ZICBOM
bool "Zicbom extension support for non-coherent DMA operation" depends on TOOLCHAIN_HAS_ZICBOM
The linker version check is entirely due to the linker having issues if it sees zicbom in the ISA string in object files.
I'd been intending to do that for Zicbom anyway, so I guess I'll just go do it & Prabhakar can attach it to his v7..
Thanks,
Conor.
Conor Dooley
maintainerRe: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
Quoted 70 lines · Conor Dooley
Quoted 40 lines · Arnd Bergmann
Quoted 21 lines · Conor Dooley
Quoted 19 lines · Arnd Bergmann
Quoted 5 lines · Prabhakar
From: Lad Prabhakar <[email protected]>
arch/riscv/mm/dma-noncoherent.c +4
-0+struct riscv_cache_ops zicbom_cmo_ops = { + .clean_range = &zicbom_cmo_clean_range, + .inv_range = &zicbom_cmo_inval_range, + .flush_range = &zicbom_cmo_flush_range,arch/riscv/mm/dma-noncoherent.c line 66
Quoted 10 lines
arch/riscv/mm/dma-noncoherent.c +10
-0+}; +#else +struct riscv_cache_ops zicbom_cmo_ops = { + .clean_range =NULL , + .inv_range =NULL , + .flush_range =NULL , + .riscv_dma_noncoherent_cmo_ops =NULL , +}; +#endif +EXPORT_SYMBOL (zicbom_cmo_ops);Same here: If the ZICBOM ISA is disabled, nothing should reference
zicbom_cmo_ops.Quoted 8 lines
Quoted 5 lines
Also, since ZICBOM is a standard
extension, I think it makes sense to always have it enabled, at least whenever noncoherent DMA is supported, that way it can be the default that gets used in the absence of any nonstandard cache controller.While I think of it, this is not possible as Zicbom requires toolchain support whereas the alternative methods for non-coherent DMA do not.
Ah, I see. Would it be possible to use the same .long trick as in the other ones though? Something like
#if
CONFIG_AS_VERSION>= 23600 /* or whichever version *//* proper inline asm */ #else /* .long hack */Quoted 7 lines
#endif
That way everyone can use it, and the hack would automatically go away in a few years after linux requires a newer toolchain.
Alternatively, the entire noncoherent-dma support could be made to depend on whichever toolchain introduced Zicbom.
Ehh, I don't think that's a great idea. It'd require far too recent a toolchain IMO.
Ideally, in my opinion, we'd just do something like what Drew has proposed for Zicboz, negating the need for a check at all:
https://lore.kernel.org/linux-riscv/[email protected]/Been waiting for that to be re-spun and Palmer to accept it before doing the same thing for Zicbom. At present we have this in the arch
Kconfig:config
TOOLCHAIN_HAS_ZICBOMbool default y depends on !64BIT || $(cc-option,-mabi=lp64 -march=rv64ima_zicbom) depends on !32BIT || $(cc-option,-mabi=ilp32 -march=rv32ima_zicbom) depends on LLD_VERSION >= 150000 || LD_VERSION >= 23800config
RISCV_ISA_ZICBOM
bool "Zicbom extension support for non-coherent DMA operation" depends onTOOLCHAIN_HAS_ZICBOM
Quoted 5 lines
The linker version check is entirely due to the linker having issues if it sees zicbom in the ISA string in object files.
I'd been intending to do that for Zicbom anyway, so I guess I'll just go do it & Prabhakar can attach it to his v7..
Should pop up here in a few minutes..
https://lore.kernel.org/linux-riscv/[email protected]/
Hopefully that both works & makes life easier. Certainly from a CI coverage point of view, relaxing toolchain requirements makes *my* life easier!
Re: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
In reply to Arnd BergmannHi Arnd,
Thank you for the review.
Quoted 40 lines · Arnd Bergmann
Quoted 19 lines · Prabhakar
From: Lad Prabhakar <[email protected]>
The current implementation of CMO was handled using the
ALTERNATIVE_X()macro; this was manageable when there were a limited number of platforms using this. Now that we are having more and more platforms coming through with the CMO the use of theALTERNATIVE_X()macro becomes unmanageable.To avoid such issues this patch switches to use of function pointers instead of
ALTERNATIVE_X()macro for cache management (the only draw being performance over the previous approach).void (*clean_range)(unsigned long addr, unsigned long size); void (*inv_range)(unsigned long addr, unsigned long size); void (*flush_range)(unsigned long addr, unsigned long size);
The above function pointers are provided to be overridden where platforms using standard approach and for platforms who want handle the operation based on the operation the below function pointer is provided:
Quoted 8 lines
void (*riscv_dma_noncoherent_cmo_ops)(void *vaddr,
size_tsize,
enumdma_data_directiondir, enumdma_noncoherent_opsops);In the current patch we have moved the ZICBOM and T-Head CMO to use function pointers.
Signed-off-by Lad Prabhakar <[email protected]>This looks like a nice improvement! I have a few suggestions for improvements, but no objections here.
Quoted 4 lines
arch/riscv/errata/thead/errata.c +0
-0...
Quoted 2 lines
arch/riscv/errata/thead/errata.c +0
-0@@ -44,6 +106,15 @@ static bool errata_probe_cmo(unsigned int stage,
Quoted 16 lines
arch/riscv/errata/thead/errata.c static bool errata_probe_cmo(unsigned int stage, · line 116
Quoted 10 lines
arch/riscv/errata/thead/errata.c +8
-0riscv_cbom_block_size =L1_CACHE_BYTES ;riscv_noncoherent_supported (); + +memset (&thead_cmo_ops,0x0 ,sizeof (thead_cmo_ops)); +if (IS_ENABLED (CONFIG_ERRATA_THEAD_CMO )) { + thead_cmo_ops.clean_range = &thead_cmo_clean_range; + thead_cmo_ops.inv_range = &thead_cmo_inval_range; + thead_cmo_ops.flush_range = &thead_cmo_flush_range; +riscv_noncoherent_register_cache_ops (&thead_cmo_ops); + }The implementation here looks reasonable, just wonder whether the classification as an 'errata' makes sense. I would probably consider this a 'driver' at this point, but that's just a question of personal preference.
zicbom is a CPU feature that doesn't have any DT node and hence no driver and similarly for T-HEAD SoC. Also the arch_setup_dma_ops() happens quite early before driver probing due to which we get WARN() messages during bootup hence I have implemented it as errata; as errata patching happens quite early.
Quoted 3 lines
For the operations structure, I think a 'static const struct
riscv_cache_ops' is more intuitive than assigning the members individually.
OK.
Quoted 23 lines
Quoted 23 lines
arch/riscv/errata/thead/errata.c +14
-0+ +enum dma_noncoherent_ops { +NON_COHERENT_SYNC_DMA_FOR_DEVICE =0 , +NON_COHERENT_SYNC_DMA_FOR_CPU , +NON_COHERENT_DMA_PREP , +NON_COHERENT_DMA_PMEM , +}; + +/* +* struct riscv_cache_ops - Structure for CMO function pointers +* @clean_range: Function pointer for clean cache +* @inv_range: Function pointer for invalidate cache +* @flush_range: Function pointer for flushing the cache +* @riscv_dma_noncoherent_cmo_ops: Function pointer for platforms who want
+ * to handle CMO themselves. If this function pointer is set rest of the
+ * function pointers will be NULL.
+ */arch/riscv/errata/thead/errata.c +4
-0+struct riscv_cache_ops { +void (*clean_range)(unsigned long addr,unsigned long size); +void (*inv_range)(unsigned long addr,unsigned long size); +void (*flush_range)(unsigned long addr,unsigned long size);
Quoted 9 lines
arch/riscv/errata/thead/errata.c
Quoted 4 lines
arch/riscv/errata/thead/errata.c +4
-0+void (*riscv_dma_noncoherent_cmo_ops)(void *vaddr,size_t size, +enum dma_data_direction dir, +enum dma_noncoherent_ops ops); +};I don't quite see how the fourth operation is used here. Are there cache controllers that need something beyond clean/inv/flush?
This is for platforms that dont follow standard cache operations (like done in patch 5/6) and there drivers decide on the operations depending on the ops and dir.
Quoted 10 lines
Quoted 10 lines
arch/riscv/errata/thead/errata.c +4
-0+ +#else + +static void riscv_noncoherent_register_cache_ops(struct
riscv_cache_ops*ops) {}arch/riscv/errata/thead/errata.c +2
-0+ +static inline void riscv_dma_noncoherent_clean(void *vaddr, size_tsize) {}
arch/riscv/errata/thead/errata.c +2
-0+ +static inline void riscv_dma_noncoherent_flush(void *vaddr, size_t
Quoted 9 lines
Quoted 4 lines
size) {}
arch/riscv/errata/thead/errata.c +2
-0+ +static inline void riscv_dma_noncoherent_inval(void *vaddr, size_tsize) {}
I think you can drop the #else path here: if there is no noncoherent DMA, then nothing should ever call these functions, right?
Yes it shouldn't be called.
Quoted 12 lines
Quoted 2 lines
arch/riscv/errata/thead/errata.c +2
-0+ +#ifdef CONFIG_RISCV_ISA_ZICBOM ...
Quoted 9 lines
arch/riscv/errata/thead/errata.c +9
-0+struct riscv_cache_ops zicbom_cmo_ops = { + .clean_range = &zicbom_cmo_clean_range, + .inv_range = &zicbom_cmo_inval_range, + .flush_range = &zicbom_cmo_flush_range, +}; +#else +struct riscv_cache_ops zicbom_cmo_ops = { + .clean_range =NULL , + .inv_range = NULL,
Quoted 8 lines
arch/riscv/errata/thead/errata.c
Quoted 5 lines
arch/riscv/errata/thead/errata.c +5
-0+ .flush_range = NULL, + .riscv_dma_noncoherent_cmo_ops = NULL, +}; +#endif +EXPORT_SYMBOL (zicbom_cmo_ops);Same here: If the ZICBOM ISA is disabled, nothing should reference
zicbom_cmo_ops.
OK.
Cheers,
Prabhakar
Re: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
Quoted 9 lines · Prabhakar
Quoted 9 lines
Quoted 8 lines
arch/riscv/errata/thead/errata.c +8
-0+ +memset (&thead_cmo_ops,0x0 ,sizeof (thead_cmo_ops)); +if (IS_ENABLED (CONFIG_ERRATA_THEAD_CMO )) { + thead_cmo_ops.clean_range = &thead_cmo_clean_range; + thead_cmo_ops.inv_range = &thead_cmo_inval_range; + thead_cmo_ops.flush_range = &thead_cmo_flush_range; +riscv_noncoherent_register_cache_ops (&thead_cmo_ops); + }
Quoted 7 lines
Quoted 5 lines
The implementation here looks reasonable, just wonder whether the classification as an 'errata' makes sense. I would probably consider this a 'driver' at this point, but that's just a question of personal preference.
zicbom is a CPU feature that doesn't have any DT node and hence no driver and similarly for T-HEAD SoC.
A driver does not have to be a 'struct platform_driver' that matches to a device node, my point was more about what to name it, regardless of how the code is entered.
Quoted 4 lines
Also the
arch_setup_dma_ops()
happens quite early before driver probing due to which we getWARN()messages during bootup hence I have implemented it as errata; as errata patching happens quite early.
But there is no more patching here, just setting the function pointers, right?
Quoted 13 lines
Quoted 4 lines
Quoted 4 lines
arch/riscv/include/asm/dma-noncoherent.h new file +4
-0+struct riscv_cache_ops { +void (*clean_range)(unsigned long addr,unsigned long size); +void (*inv_range)(unsigned long addr,unsigned long size); +void (*flush_range)(unsigned long addr,unsigned long size);Quoted 9 lines
arch/riscv/include/asm/dma-noncoherent.h line 34
Quoted 4 lines
arch/riscv/include/asm/dma-noncoherent.h new file +4
-0+void (*riscv_dma_noncoherent_cmo_ops)(void *vaddr,size_t size, +enum dma_data_direction dir, +enum dma_noncoherent_ops ops); +};I don't quite see how the fourth operation is used here. Are there cache controllers that need something beyond clean/inv/flush?
Quoted 3 lines
This is for platforms that dont follow standard cache operations (like done in patch 5/6) and there drivers decide on the operations depending on the ops and dir.
My feeling is that the set of operations that get called should not depend on the cache controller but at best the CPU. I tried to enumerate how zicbom and ax45 differ here, and how that compares to other architectures:
zicbom ax45,mips,arc arm arm64 fromdevice clean/flush inval/inval inval/inval clean/inval todevice clean/- clean/- clean/- clean/- bidi flush/flush flush/inval clean/inval clean/inval
So everyone does the same operation for DMA_TO_DEVICE, but they differ in the DMA_FROM_DEVICE handling, for reasons I don't quite see:
Your ax45 code does the same as arc and mips. arm and arm64 skip invalidating the cache before bidi mappings, but arm has a FIXME comment about that. arm64 does a 'clean' instead of 'inval' when mapping a fromdevice page, which seems valid but slower than necessary.
Could the zicbom operations be changed to do the same things as the ax45/mips/arc ones, or are there specific details in the zicbom spec that require this?
Arnd
Re: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
Quoted 24 lines · Arnd Bergmann
Quoted 9 lines · Prabhakar
Quoted 9 lines
Quoted 8 lines
arch/riscv/errata/thead/errata.c +8
-0+ +memset (&thead_cmo_ops,0x0 ,sizeof (thead_cmo_ops)); +if (IS_ENABLED (CONFIG_ERRATA_THEAD_CMO )) { + thead_cmo_ops.clean_range = &thead_cmo_clean_range; + thead_cmo_ops.inv_range = &thead_cmo_inval_range; + thead_cmo_ops.flush_range = &thead_cmo_flush_range; +riscv_noncoherent_register_cache_ops (&thead_cmo_ops); + }Quoted 7 lines
Quoted 5 lines
The implementation here looks reasonable, just wonder whether the classification as an 'errata' makes sense. I would probably consider this a 'driver' at this point, but that's just a question of personal preference.
zicbom is a CPU feature that doesn't have any DT node and hence no driver and similarly for T-HEAD SoC.
A driver does not have to be a 'struct
platform_driver' that matches to a device node, my point was more about what to name it, regardless of how the code is entered.
Quoted 8 lines
Quoted 4 lines
Also the
arch_setup_dma_ops()
happens quite early before driver probing due to which we getWARN()messages during bootup hence I have implemented it as errata; as errata patching happens quite early.But there is no more patching here, just setting the function pointers, right?
Yes that's right.
Quoted 37 lines
Quoted 13 lines
Quoted 4 lines
Quoted 4 lines
arch/riscv/include/asm/dma-noncoherent.h new file +4
-0+struct riscv_cache_ops { +void (*clean_range)(unsigned long addr,unsigned long size); +void (*inv_range)(unsigned long addr,unsigned long size); +void (*flush_range)(unsigned long addr,unsigned long size);Quoted 9 lines
arch/riscv/include/asm/dma-noncoherent.h line 34
Quoted 4 lines
arch/riscv/include/asm/dma-noncoherent.h new file +4
-0+void (*riscv_dma_noncoherent_cmo_ops)(void *vaddr,size_t size, +enum dma_data_direction dir, +enum dma_noncoherent_ops ops); +};I don't quite see how the fourth operation is used here. Are there cache controllers that need something beyond clean/inv/flush?
Quoted 3 lines
This is for platforms that dont follow standard cache operations (like done in patch 5/6) and there drivers decide on the operations depending on the ops and dir.
My feeling is that the set of operations that get called should not depend on the cache controller but at best the CPU. I tried to enumerate how zicbom and ax45 differ here, and how that compares to other architectures:
zicbom ax45,mips,arc arm arm64 fromdevice clean/flush inval/inval inval/inval clean/inval todevice clean/- clean/- clean/- clean/- bidi flush/flush flush/inval clean/inval clean/invalSo everyone does the same operation for
DMA_TO_DEVICE, but they differ in theDMA_FROM_DEVICEhandling, for reasons I don't quite see:Your ax45 code does the same as arc and mips. arm and arm64 skip invalidating the cache before bidi mappings, but arm has a FIXME comment about that. arm64 does a 'clean' instead of 'inval' when mapping a fromdevice page, which seems valid but slower than necessary.
Quoted 4 lines
Could the zicbom operations be changed to do the same things as the ax45/mips/arc ones, or are there specific details in the zicbom spec that require this?
I'll let the RISC-V experts respond here.
Cheers,
Prabhakar
_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv
Re: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
Quoted 38 lines · Prabhakar
Quoted 37 lines · Arnd Bergmann
Quoted 13 lines
Quoted 4 lines
Quoted 4 lines
arch/riscv/include/asm/dma-noncoherent.h new file +4
-0+struct riscv_cache_ops { +void (*clean_range)(unsigned long addr,unsigned long size); +void (*inv_range)(unsigned long addr,unsigned long size); +void (*flush_range)(unsigned long addr,unsigned long size);Quoted 9 lines
arch/riscv/include/asm/dma-noncoherent.h line 34
Quoted 4 lines
arch/riscv/include/asm/dma-noncoherent.h new file +4
-0+void (*riscv_dma_noncoherent_cmo_ops)(void *vaddr,size_t size, +enum dma_data_direction dir, +enum dma_noncoherent_ops ops); +};I don't quite see how the fourth operation is used here. Are there cache controllers that need something beyond clean/inv/flush?
Quoted 3 lines
This is for platforms that dont follow standard cache operations (like done in patch 5/6) and there drivers decide on the operations depending on the ops and dir.
My feeling is that the set of operations that get called should not depend on the cache controller but at best the CPU. I tried to enumerate how zicbom and ax45 differ here, and how that compares to other architectures:
zicbom ax45,mips,arc arm arm64 fromdevice clean/flush inval/inval inval/inval clean/inval todevice clean/- clean/- clean/- clean/- bidi flush/flush flush/inval clean/inval clean/invalSo everyone does the same operation for
DMA_TO_DEVICE, but they differ in theDMA_FROM_DEVICEhandling, for reasons I don't quite see:Your ax45 code does the same as arc and mips. arm and arm64 skip invalidating the cache before bidi mappings, but arm has a FIXME comment about that. arm64 does a 'clean' instead of 'inval' when mapping a fromdevice page, which seems valid but slower than necessary.
Quoted 5 lines
Quoted 4 lines
Could the zicbom operations be changed to do the same things as the ax45/mips/arc ones, or are there specific details in the zicbom spec that require this?
I'll let the RISC-V experts respond here.
Adding Christoph Hellwig and Will Deacon to Cc as well.
I had another look at the arm64 side, which (like the zicbom variant) uses 'clean' on dma_sync_single_for_device(DMA_FROM_DEVICE), as that has changed not that long ago, see
I'm still not sure what the correct set of operations has to be, but nothing in that patch description sounds ISA or even microarchitecture specific.
Arnd
_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv
Re: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
Quoted 24 lines · Arnd Bergmann
Quoted 23 lines · Prabhakar
Quoted 22 lines · Arnd Bergmann
Quoted 13 lines
Quoted 4 lines
Quoted 4 lines
arch/riscv/include/asm/dma-noncoherent.h new file +4
-0+struct riscv_cache_ops { +void (*clean_range)(unsigned long addr,unsigned long size); +void (*inv_range)(unsigned long addr,unsigned long size); +void (*flush_range)(unsigned long addr,unsigned long size);Quoted 9 lines
arch/riscv/include/asm/dma-noncoherent.h line 34
Quoted 4 lines
arch/riscv/include/asm/dma-noncoherent.h new file +4
-0+void (*riscv_dma_noncoherent_cmo_ops)(void *vaddr,size_t size, +enum dma_data_direction dir, +enum dma_noncoherent_ops ops); +};I don't quite see how the fourth operation is used here. Are there cache controllers that need something beyond clean/inv/flush?
Quoted 3 lines
This is for platforms that dont follow standard cache operations (like done in patch 5/6) and there drivers decide on the operations depending on the ops and dir.
My feeling is that the set of operations that get called should not depend on the cache controller but at best the CPU. I tried to enumerate how zicbom and ax45 differ here, and how that compares to other architectures:
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
zicbom ax45,mips,arc arm arm64 fromdevice clean/flush inval/inval inval/inval clean/inval todevice clean/- clean/- clean/- clean/- bidi flush/flush flush/inval clean/inval clean/inval
I did a bit of digging on lore for context on why the ops are what they are..
In v3 of the Zicbom enablement patchset, things looked like:
fromdevice inval/inval
todevice clean/-
bidi flush/inval
v3:
https://lore.kernel.org/linux-riscv/[email protected]/
Samuel had some comments about the invals:
https://lore.kernel.org/linux-riscv/[email protected]/
In v4 it was changed to:
fromdevice inval/flush
todevice clean/-
bidi flush/flush
v4:
https://lore.kernel.org/linux-riscv/[email protected]/
Christoph replied to that one, linking the thread belonging to the commit you pointed out earlier:
https://lore.kernel.org/linux-riscv/[email protected]/
v5 produced what you have in your table above:
https://lore.kernel.org/linux-riscv/[email protected]/
Quoted 23 lines
Quoted 11 lines
Quoted 11 lines
So everyone does the same operation for
DMA_TO_DEVICE, but they differ in theDMA_FROM_DEVICEhandling, for reasons I don't quite see:Your ax45 code does the same as arc and mips. arm and arm64 skip invalidating the cache before bidi mappings, but arm has a FIXME comment about that. arm64 does a 'clean' instead of 'inval' when mapping a fromdevice page, which seems valid but slower than necessary.
Quoted 5 lines
Quoted 4 lines
Could the zicbom operations be changed to do the same things as the ax45/mips/arc ones, or are there specific details in the zicbom spec that require this?
I'll let the RISC-V experts respond here.
Adding Christoph Hellwig and Will Deacon to Cc as well.
I had another look at the arm64 side, which (like the zicbom variant) uses 'clean' on
dma_sync_single_for_device(DMA_FROM_DEVICE), as that has changed not that long ago, see
Quoted 5 lines
I'm still not sure what the correct set of operations has to be, but nothing in that patch description sounds ISA or even microarchitecture specific.
Hope the lore archaeology helps jog people's memories...
Conor
_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv
Re: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
In reply to Arnd BergmannQuoted 5 lines · Arnd Bergmann
I had another look at the arm64 side, which (like the zicbom variant) uses 'clean' on
dma_sync_single_for_device(DMA_FROM_DEVICE), as that has changed not that long ago, see
which IIRC has been reverted recently.
Quoted 3 lines
I'm still not sure what the correct set of operations has to be, but nothing in that patch description sounds ISA or even microarchitecture specific.
Nothing is ISA specific, and the only micro architecture related thing is if the specific core can speculate memory accesses. See the table in arch/arc/mm/dma.c for details.
And as commented on the arm64 patch I really hate architectures getting creative here, as I'd much prefer to move the choice of primitives to the core DMA code and just provide helpers to invalidate/writeback/ writeback+invalidate from the architectures eventually.
Re: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
Quoted 8 lines · Christoph Hellwig
Quoted 5 lines · Arnd Bergmann
I had another look at the arm64 side, which (like the zicbom variant) uses 'clean' on
dma_sync_single_for_device(DMA_FROM_DEVICE), as that has changed not that long ago, seewhich IIRC has been reverted recently.
To clarify: I was looking at arch_sync_dma_for_device(), which changed from 'invalidate' to 'clean' last June in commit c50f11c6196f ("arm64: mm: Don't invalidate FROM_DEVICE buffers at start of DMA transfer"). I don't see a revert for that.
The one that was reverted recently is arch_dma_prep_coherent, which was changed and reverted in
c44094eee32 Aug 23 2022 flush->cleanb7d9aae4048 Dec 6 2022 clean->flush
I'm primarily interested in the streaming mappings (arch_sync_*) at the moment.
Quoted 4 lines
Quoted 3 lines
I'm still not sure what the correct set of operations has to be, but nothing in that patch description sounds ISA or even microarchitecture specific.
Quoted 8 lines
Nothing is ISA specific, and the only micro architecture related thing is if the specific core can speculate memory accesses. See the table in
arch/arc/mm/dma.cfor details.And as commented on the arm64 patch I really hate architectures getting creative here, as I'd much prefer to move the choice of primitives to the core DMA code and just provide helpers to invalidate/writeback/ writeback+invalidate from the architectures eventually.
Agreed, that's why I particularly don't like the idea of giving SoC specific L2$ drivers the option of making custom choices here.
The arch_dma_prep_coherent() change is arguably arm64 specific because it is only needed for machines sharing memory with EL3 firmware that enforces buffer ownership, but even for that it would be nice to have a central definition and some architecture specific flag that picks one behavior or the other. Same thing for the speculative access difference.
I looked at all the implementations now and put them in a table[1] to see what the differences are. The only bit that I think needs discussion is the dma_sync_single_for_device(DMA_FROM_DEVICE) op that I mentioned above. I see that arm64, csky, powerpc, riscv and parisc all write out at least partical cache lines first to avoid losing dirty data in the part that is not written by the device[2][3], while the other ones don't[4].
The other differences I found are:
- arm and arm64 use clean instead of flush for
dma_sync_single_for_device(DMA_BIDIRECTIONAL).
This seems harmless, since there is another
invalidation at the _for_cpu() step.
- hexagon, m68k, openrisc and sh don't deal with
speculative loads
- m68k, nios2, openrisc, parisc and xtensa use flush instead of clean for DMA_TO_DEVICE, presumably because they don't have a flush without invalidate.
- microblaze, parisc and powerpc use the same function for _for_device and _for_cpu, which is slightly wasteful but harmless.
- openrisc lacks support for bidirectional mappings, which is a bug
- sparc32 and xtensa only supports writethrough caches and consequently skips the clean before DMA but instead invalidate the buffer in the _for_cpu operation.
I also see that at least arc, arm, mips and riscv all want CPU specific cache management operations to be registered at boot time. While Russell had some concerns about your suggestion to generalize the arm version, we could start by moving the abstracted riscv version into kernel/dma/direct.c and make sure it can be shared with at least mips and arc, provided that we can agree on the DMA_FROM_DEVICE behavior.
Arnd
[1] https://docs.google.com/spreadsheets/d/1qDuMqB6TnRTj_CgUwgIIm_RJ6EZO76qohpTJUMQjUEo/edit#gid=0
[2] https://git.kernel.org/torvalds/c/c50f11c6196f
[3] https://git.kernel.org/torvalds/c/03d70617b8a7
[4] https://lore.kernel.org/all/20220606152150.GA31568@willie-the-truck/
_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv
Re: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
Quoted 15 lines · Arnd Bergmann
Quoted 8 lines · Christoph Hellwig
Quoted 5 lines · Arnd Bergmann
I had another look at the arm64 side, which (like the zicbom variant) uses 'clean' on
dma_sync_single_for_device(DMA_FROM_DEVICE), as that has changed not that long ago, seewhich IIRC has been reverted recently.
To clarify: I was looking at
arch_sync_dma_for_device(), which changed from 'invalidate' to 'clean' last June in commitc50f11c6196f("arm64: mm: Don't invalidateFROM_DEVICEbuffers at start of DMA transfer"). I don't see a revert for that.
Quoted 8 lines
The one that was reverted recently is
arch_dma_prep_coherent, which was changed and reverted in
c44094eee32Aug 23 2022flush->cleanb7d9aae4048Dec 6 2022clean->flushI'm primarily interested in the streaming mappings (arch_sync_*) at the moment.
Just as an FYI, but we plan to revert the revert (i.e. go back to 'clean') here once Qualcomm's modem firmware loader has been updated:
https://lore.kernel.org/r/[email protected]
Will
_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv
Re: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
In reply to Arnd BergmannQuoted 5 lines · Arnd Bergmann
To clarify: I was looking at
arch_sync_dma_for_device(), which changed from 'invalidate' to 'clean' last June in commitc50f11c6196f("arm64: mm: Don't invalidateFROM_DEVICEbuffers at start of DMA transfer"). I don't see a revert for that.
Quoted 8 lines
The one that was reverted recently is
arch_dma_prep_coherent, which was changed and reverted in
c44094eee32Aug 23 2022flush->cleanb7d9aae4048Dec 6 2022clean->flushI'm primarily interested in the streaming mappings (arch_sync_*) at the moment.
Oh, true. I've been confused about the two changes.
Quoted 2 lines
Agreed, that's why I particularly don't like the idea of giving SoC specific L2$ drivers the option of making custom choices here.
Yes, moving this into individual drivers is an absolute no-go.
Quoted 6 lines
The
arch_dma_prep_coherent()change is arguably arm64 specific because it is only needed for machines sharing memory with EL3 firmware that enforces buffer ownership, but even for that it would be nice to have a central definition and some architecture specific flag that picks one behavior or the other. Same thing for the speculative access difference.
Yes.
Quoted 7 lines
I looked at all the implementations now and put them in a table[1] to see what the differences are. The only bit that I think needs discussion is the
dma_sync_single_for_device(DMA_FROM_DEVICE)op that I mentioned above. I see that arm64, csky, powerpc, riscv and parisc all write out at least partical cache lines first to avoid losing dirty data in the part that is not written by the device[2][3], while the other ones don't[4].
I'm tempted to declare [4] buggy until proof of the inverse.
Quoted 8 lines
I also see that at least arc, arm, mips and riscv all want CPU specific cache management operations to be registered at boot time. While Russell had some concerns about your suggestion to generalize the arm version, we could start by moving the abstracted riscv version into
kernel/dma/direct.cand make sure it can be shared with at least mips and arc, provided that we can agree on theDMA_FROM_DEVICEbehavior.
Yes, I'd really like to start out with a common version and then move bits over. There's also some interesting bits about handling highmem for architectures that needs virtual addresss for flushing that might be worth sharing, too.
Thіs should be a new file in kernel/dma/ as it's not only used by dma-direct but also by dma-iommu, and to keep the code nicely separated.
Can you give it a go?
_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv
Re: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
Quoted 10 lines · Christoph Hellwig
Quoted 7 lines · Arnd Bergmann
I looked at all the implementations now and put them in a table[1] to see what the differences are. The only bit that I think needs discussion is the
dma_sync_single_for_device(DMA_FROM_DEVICE)op that I mentioned above. I see that arm64, csky, powerpc, riscv and parisc all write out at least partical cache lines first to avoid losing dirty data in the part that is not written by the device[2][3], while the other ones don't[4].I'm tempted to declare [4] buggy until proof of the inverse.
Having looked at this some more, I see that the powerpc version is a bit problematic here as well: this one flushes the partial cache lines before and after the DMA transfer, while only invalidating the full cache lines. If a partical cache line gets written to by the CPU while the buffer is owned by the device, this means that the received data from the device is immediately overwritten by the second flush.
The arm64 and riscv behavior of doing a flush before and an invalidate after the DMA seems a bit more appropriate, as that ends up keeping the DMA data but discarding anything written by the CPU.
Obviously there is no winning either way if the same cache line gets written by both CPU and device, I'm just trying to figure out what behavior we actually want here.
The best I can think of so far is:
- flush the partial cache lines before the DMA, as powerpc does, and just invalidate the full cache lines
- only invalidate but not clean/flush after the DMA. This is the arm64 behavior
- warn when flushing partial cache lines
if dma_debug is enabled.
Quoted 14 lines
Quoted 8 lines
I also see that at least arc, arm, mips and riscv all want CPU specific cache management operations to be registered at boot time. While Russell had some concerns about your suggestion to generalize the arm version, we could start by moving the abstracted riscv version into
kernel/dma/direct.cand make sure it can be shared with at least mips and arc, provided that we can agree on theDMA_FROM_DEVICEbehavior.Yes, I'd really like to start out with a common version and then move bits over. There's also some interesting bits about handling highmem for architectures that needs virtual addresss for flushing that might be worth sharing, too.
Quoted 5 lines
Thіs should be a new file in
kernel/dma/as it's not only used by dma-direct but also by dma-iommu, and to keep the code nicely separated.Can you give it a go?
I started this at the beginning of the week but couldn't finish it at all, but still plan to get back to it next week.
Aside from the question for how to handle flush vs invalidate on DMA_FROM_DEVICE, I'm still trying to figure out how to best handle highmem with architecture specific cache management operations. The easy approach would be to leave that up to the architecture, passing only a physical address to the flush function. A nicer interface might be to move the loop over highmem pages out into common code, flush lowmem pages by virtual addresss, and have a separate callback for highmem pages that takes a page pointer, like
struct dma_cache_ops {
void (*dma_cache_wback_inv)(void *start, unsigned long sz);
void (*dma_cache_inv)(void *start, unsigned long sz);
void (*dma_cache_wback)(void *start, unsigned long sz);
#ifdef CONFIG_HIGHMEM
void (*dma_cache_wback_inv_high_page)(struct page *, size_t start, unsigned long sz);
void (*dma_cache_inv_high_page)(struct page *, size_t start, unsigned long sz);
void (*dma_cache_wback_high_page)(struct page *, size_t start, unsigned long sz);#endif
};
Let me know if you have a preference here, before I spend too much time on something we don't want in the end.
Arnd
Re: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
Quoted 5 lines · Arnd Bergmann
Having looked at this some more, I see that the powerpc version is a bit problematic here as well: this one flushes the partial cache lines before and after the DMA transfer, while only invalidating the full cache lines.
That feels really odd, and might be worth a bug report to the PPC maintainers.
Quoted 4 lines
Obviously there is no winning either way if the same cache line gets written by both CPU and device, I'm just trying to figure out what behavior we actually want here.
There isn't, and that's why we require DMAed regions to be cache line aligned.
Quoted 6 lines
Aside from the question for how to handle flush vs invalidate on
DMA_FROM_DEVICE, I'm still trying to figure out how to best handle highmem with architecture specific cache management operations. The easy approach would be to leave that up to the architecture, passing only a physical address to the flush function.
I suspect that is a good enough first step. Especially as I remember that some architectures have physical address based cache management anyway (unless we removed them in the meantime).
Quoted 5 lines
A nicer interface might be to move the
loop over highmem pages out into common code, flush lowmem pages by virtual addresss, and have a separate callback for highmem pages that takes a page pointer, like
I'd rather avoid multiple callbacks if we can. But maybe solve the simple problem first and just pass the paddr and then iterate from there.
Quoted 9 lines
struct dma_cache_ops {
void (*dma_cache_wback_inv)(void *start, unsigned long sz);
void (*dma_cache_inv)(void *start, unsigned long sz);
void (*dma_cache_wback)(void *start, unsigned long sz);
#ifdef CONFIG_HIGHMEM
void (*dma_cache_wback_inv_high_page)(struct page *, size_t start, unsigned long sz);
void (*dma_cache_inv_high_page)(struct page *, size_t start, unsigned long sz);
void (*dma_cache_wback_high_page)(struct page *, size_t start, unsigned long sz);Btw, I really don't think these should be indirect calls. For sane architectures there should be exactly one way to call them, and the onces that have different implementations really should be using alternatives instead of expensive indirect calls.
Re: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
Quoted 9 lines · Christoph Hellwig
Quoted 5 lines · Arnd Bergmann
Having looked at this some more, I see that the powerpc version is a bit problematic here as well: this one flushes the partial cache lines before and after the DMA transfer, while only invalidating the full cache lines.
That feels really odd, and might be worth a bug report to the PPC maintainers.
Right, my first step would be to change all of the current outliers to use the same set of operations where possible.
Quoted 10 lines
Quoted 6 lines
Aside from the question for how to handle flush vs invalidate on
DMA_FROM_DEVICE, I'm still trying to figure out how to best handle highmem with architecture specific cache management operations. The easy approach would be to leave that up to the architecture, passing only a physical address to the flush function.I suspect that is a good enough first step. Especially as I remember that some architectures have physical address based cache management anyway (unless we removed them in the meantime).
ok
Quoted 9 lines
Quoted 5 lines
A nicer interface might be to move the
loop over highmem pages out into common code, flush lowmem pages by virtual addresss, and have a separate callback for highmem pages that takes a page pointer, likeI'd rather avoid multiple callbacks if we can. But maybe solve the simple problem first and just pass the paddr and then iterate from there.
Ok, fair enough. This means we can't easily put the kmap_atomic() into common code for highmem, though the per-page loop would still work.
Quoted 9 lines
Quoted 8 lines
struct dma_cache_ops { void (*dma_cache_wback_inv)(void *start, unsigned long sz); void (*dma_cache_inv)(void *start, unsigned long sz); void (*dma_cache_wback)(void *start, unsigned long sz); #ifdef CONFIG_HIGHMEM void (*dma_cache_wback_inv_high_page)(struct page *, size_t start, unsigned long sz); void (*dma_cache_inv_high_page)(struct page *, size_t start, unsigned long sz); void (*dma_cache_wback_high_page)(struct page *, size_t start, unsigned long sz);
Quoted 4 lines
Btw, I really don't think these should be indirect calls. For sane architectures there should be exactly one way to call them, and the onces that have different implementations really should be using alternatives instead of expensive indirect calls.
I was thinking of using STATIC_CALL() as an optimization here, which I find easier to read and understand than alternatives. One advantage here is that this allows the actual cache operations to be declared locally in the architecture without letting drivers call them, but still update the common code to work without indirect branches.
The main downside is that this is currently only optimized on powerpc and x86, both of which don't actually need CPU specific callbacks. ARC, ARM, and MIPS on the other hand already have indirect function pointers, RISC-V would likely benefit the most from either alternatives or static_call, as it already uses alternatives and has one implementation that is clearly preferred over the others.
Arnd
Re: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
Quoted 5 lines · Arnd Bergmann
Quoted 2 lines
That feels really odd, and might be worth a bug report to the PPC maintainers.
Right, my first step would be to change all of the current outliers to use the same set of operations where possible.
Sounds good.
Quoted 7 lines
Quoted 3 lines
I'd rather avoid multiple callbacks if we can. But maybe solve the simple problem first and just pass the paddr and then iterate from there.
Ok, fair enough. This means we can't easily put the
kmap_atomic()into common code for highmem, though the per-page loop would still work.
Yes. Given how messy many of the ops are I think one step at a time is always good.
Quoted 6 lines
I was thinking of using
STATIC_CALL()as an optimization here, which I find easier to read and understand than alternatives. One advantage here is that this allows the actual cache operations to be declared locally in the architecture without letting drivers call them, but still update the common code to work without indirect branches.
Quoted 7 lines
The main downside is that this is currently only optimized on powerpc and x86, both of which don't actually need CPU specific callbacks. ARC, ARM, and MIPS on the other hand already have indirect function pointers, RISC-V would likely benefit the most from either alternatives or
static_call, as it already uses alternatives and has one implementation that is clearly preferred over the others.
For now I'd just keep doing direct calls into the arch code, just for the lower level invalidate, writeback, invalidate+writeback calls as that helps cementinc the logic of which of those to use in well documented core code.
And I'm not really sure I'd like to go beyond that - making it too easy pluggable will make people feel more comfortable doing stupid things here. And yes, maybe that's personal because I've warned the RISC-V people years ago that they'll need architectural cache management instructions yesterday and the answer was that no one is going to use them on modern CPUs. *sigh*
Re: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
Quoted 15 lines · Christoph Hellwig
Quoted 6 lines · Arnd Bergmann
I was thinking of using
STATIC_CALL()as an optimization here, which I find easier to read and understand than alternatives. One advantage here is that this allows the actual cache operations to be declared locally in the architecture without letting drivers call them, but still update the common code to work without indirect branches.Quoted 7 lines
The main downside is that this is currently only optimized on powerpc and x86, both of which don't actually need CPU specific callbacks. ARC, ARM, and MIPS on the other hand already have indirect function pointers, RISC-V would likely benefit the most from either alternatives or
static_call, as it already uses alternatives and has one implementation that is clearly preferred over the others.
Quoted 4 lines
For now I'd just keep doing direct calls into the arch code, just for the lower level invalidate, writeback, invalidate+writeback calls as that helps cementinc the logic of which of those to use in well documented core code.
Ok.
Quoted 3 lines
And I'm not really sure I'd like to go beyond that - making it too easy pluggable will make people feel more comfortable doing stupid things here.
I fear the bigger risk is still making the functions callable from device driver code than it is to make the functions globally settable.
You introduced the mips version in f8c55dc6e828 ("MIPS: use generic dma noncoherent ops for simple noncoherent platforms"), which was clearly meant as an implementation detail, yet we already have a driver that slipped in with 3bdffa8ffb45 ("Input: Add N64 controller driver") that just calls this directly rather than using the dma-mapping interface.
On the other hand, the indirect function pointers for per-cpu cache operations are not easily translated anyway:
with the three architectures that multiplex between cpu specific operations, arc uses physical addresses, mips uses virtual addresses (because of highmem), and arm even uses both because of incompatible requirements between l1 and l2 cache operations. arm32 also seems to have the superset of all possible corner cases that one might see elsewhere (prefetching vs in-order, writethrough vs writeback, broken broadcast invalidation, ...).
Quoted 4 lines
And yes, maybe that's personal because I've warned the RISC-V people years ago that they'll need architectural cache management instructions yesterday and the answer was that no one is going to use them on modern CPUs. *sigh*
To be fair, from the ISA point of view, it really shouldn't be necessary as long as you have a sane SoC design. In practice there are always chips that are cutting corners, or use the new CPU core as a drop-in for an existing design. Arm SBSA tried to enforce the same thing and also failed for pretty much the same reason.
Arnd
Re: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
Quoted 8 lines · Arnd Bergmann
Quoted 3 lines
And I'm not really sure I'd like to go beyond that - making it too easy pluggable will make people feel more comfortable doing stupid things here.
I fear the bigger risk is still making the functions callable from device driver code than it is to make the functions globally settable.
Quoted 6 lines
You introduced the mips version in
f8c55dc6e828("MIPS: use generic dma noncoherent ops for simple noncoherent platforms"), which was clearly meant as an implementation detail, yet we already have a driver that slipped in with3bdffa8ffb45("Input: Add N64 controller driver") that just calls this directly rather than using the dma-mapping interface.
MIPS actually has a bit of a history of these odd bypasses that it seems like this driver copied. rmk has been very worried by this bypassing, and in general I agree. But there's only so much we can do except for auditing drivers. Especially as none of these helpers is exported and built-in only drivers are quite rare.
Quoted 11 lines
Quoted 4 lines
And yes, maybe that's personal because I've warned the RISC-V people years ago that they'll need architectural cache management instructions yesterday and the answer was that no one is going to use them on modern CPUs. *sigh*
To be fair, from the ISA point of view, it really shouldn't be necessary as long as you have a sane SoC design. In practice there are always chips that are cutting corners, or use the new CPU core as a drop-in for an existing design. Arm SBSA tried to enforce the same thing and also failed for pretty much the same reason.
Not wiring up IP blocks for cache coherency is cheap. So it totally makes sense for dirt cheap SOCs, or even for low performance periphals in general. The GPU folks also believe they can make some things faster by deliberately turning coherency off on SOCs that support coherency.
In addition to that cache maintainance is absolutely needed for NVDIMM support.
Conor Dooley
maintainerRe: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
In reply to Prabhakar+CC Icenowy
Hey Prabhakar,
Quoted 6 lines · Prabhakar
From: Lad Prabhakar <[email protected]>
The current implementation of CMO was handled using the
ALTERNATIVE_X()macro; this was manageable when there were a limited number of platforms using this. Now that we are having more and more platforms coming through with the CMO the use of theALTERNATIVE_X()macro becomes unmanageable.
Nitpick time! This opening paragraph is all a little oddly worded IMO. How about:
Currently, selecting which CMOs to use on a given platform is done using and ALTERNATIVE_X() macro. This was manageable when there were just two CMO implementations, but now that there are more and more platforms coming needing custom CMOs, the use of the ALTERNATIVE_X() macro is unmanageable.
Quoted 2 lines
To avoid such issues this patch switches to use of function pointers instead of
ALTERNATIVE_X()macro for cache management (the only draw being
s/draw/drawback
Quoted 1 line
performance over the previous approach).
Did you notice a performance decrease or are you speculating? Perhaps Icenowy - who I know benched their implmentation of a new CMO macro for THEAD stuff can do so again for this.
Quoted 7 lines
void (*clean_range)(unsigned long addr, unsigned long size); void (*inv_range)(unsigned long addr, unsigned long size); void (*flush_range)(unsigned long addr, unsigned long size);
The above function pointers are provided to be overridden where platforms using standard approach and for platforms who want handle the operation based on the operation the below function pointer is provided:
Think you've left out some words here chief!
Perhaps s/and for platforms who/. For platforms that/ & on the line after, s/operation/direction/ ?
Quoted 6 lines
void (*riscv_dma_noncoherent_cmo_ops)(void *vaddr,
size_tsize,
enumdma_data_directiondir, enumdma_noncoherent_opsops);In the current patch we have moved the ZICBOM and T-Head CMO to use function pointers.
"Convert ZICBOM..."
Quoted 61 lines
Signed-off-by Lad Prabhakar <[email protected]>---
v5->v6
* New patch--- arch/riscv/errata/thead/errata.c | 71 ++++++++++++++++++ arch/riscv/include/asm/dma-noncoherent.h | 83 +++++++++++++++++++++ arch/riscv/include/asm/errata_list.h | 53 ------------- arch/riscv/kernel/cpufeature.c | 2 + arch/riscv/mm/dma-noncoherent.c | 94 ++++++++++++++++++++++-- arch/riscv/mm/pmem.c | 18 ++++- 6 files changed, 260 insertions(+), 61 deletions(-) create mode 100644 arch/riscv/include/asm/dma-noncoherent.harch/riscv/errata/thead/errata.c +33
-0@@ -8,12 +8,72 @@#include <linux/module.h> #include <linux/string.h> #include <linux/uaccess.h> +#include <asm/dma-noncoherent.h> #include <asm/alternative.h> #include <asm/cacheflush.h> #include <asm/errata_list.h> #include <asm/patch.h> #include <asm/vendorid_list.h> +#ifdef CONFIG_ERRATA_THEAD_CMO +/* +* dcache.ipa rs1 (invalidate, physical address) +* | 31 - 25 | 24 - 20 | 19 - 15 | 14 - 12 | 11 - 7 | 6 - 0 | +* 0000001 01010 rs1 000 00000 0001011 +* dache.iva rs1 (invalida, virtual address) +* 0000001 00110 rs1 000 00000 0001011 +* +* dcache.cpa rs1 (clean, physical address) +* | 31 - 25 | 24 - 20 | 19 - 15 | 14 - 12 | 11 - 7 | 6 - 0 | +* 0000001 01001 rs1 000 00000 0001011 +* dcache.cva rs1 (clean, virtual address) +* 0000001 00100 rs1 000 00000 0001011 +* +* dcache.cipa rs1 (clean then invalidate, physical address) +* | 31 - 25 | 24 - 20 | 19 - 15 | 14 - 12 | 11 - 7 | 6 - 0 | +* 0000001 01011 rs1 000 00000 0001011 +* dcache.civa rs1 (... virtual address) +* 0000001 00111 rs1 000 00000 0001011 +* +* sync.s (make sure all cache operations finished) +* | 31 - 25 | 24 - 20 | 19 - 15 | 14 - 12 | 11 - 7 | 6 - 0 | +* 0000000 11001 00000 000 00000 0001011 +*/ +#define THEAD_inval_A0 ".long 0x0265000b" +#define THEAD_clean_A0 ".long 0x0245000b" +#define THEAD_flush_A0 ".long 0x0275000b" +#define THEAD_SYNC_S ".long 0x0190000b" + +#define THEAD_CMO_OP (_op, _start, _size, _cachesize) \ + asm volatile("mv a0, %1\n\t" \ + "j 2f\n\t" \
arch/riscv/errata/thead/errata.c line 59
Quoted 10 lines
arch/riscv/errata/thead/errata.c +10
-0+ "3:\n\t" \ + THEAD_##_op##_A0 "\n\t" \ + "add a0, a0, %0\n\t" \ + "2:\n\t" \ + "bltu a0, %2, 3b\n\t" \ + THEAD_SYNC_S \ + : : "r"(_cachesize), \ +" r"((unsigned long)(_start) & ~((_cachesize) - 1UL)), \ +" r"((unsigned long)(_start) + (_size)) \ + : "a0")
I'm not going to provide a tested-by for the THEAD stuff, as I have no metrics - but I booted my usual NFS and did some tyre kicking. Seemed grand.
Quoted 29 lines
arch/riscv/errata/thead/errata.c +18
-0+static void thead_cmo_clean_range (unsigned long addr,unsigned long size) +{ +THEAD_CMO_OP (clean, addr, size, riscv_cbom_block_size); +} + +static void thead_cmo_flush_range (unsigned long addr,unsigned long size) +{ +THEAD_CMO_OP (flush, addr, size, riscv_cbom_block_size); +} + +static void thead_cmo_inval_range (unsigned long addr,unsigned long size) +{ +THEAD_CMO_OP (inval, addr, size, riscv_cbom_block_size); +} +#endif +static bool errata_probe_pbmt (unsigned int stage,unsigned long arch_id,unsigned long impid) {@@ -33,6 +93,8 @@ static bool errata_probe_pbmt(unsigned int stage,static bool errata_probe_cmo (unsigned int stage,unsigned long arch_id,unsigned long impid) { +struct riscv_cache_ops thead_cmo_ops; +if (!IS_ENABLED (CONFIG_ERRATA_THEAD_CMO ))return false;
arch/riscv/errata/thead/errata.c static bool errata_probe_cmo(unsigned int stage, · line 111
Quoted 6 lines
arch/riscv/errata/thead/errata.c +3
-0@@ -44,6 +106,15 @@ static bool errata_probe_cmo(unsigned int stage, riscv_cbom_block_size =L1_CACHE_BYTES ;riscv_noncoherent_supported (); + +memset (&thead_cmo_ops,0x0 ,sizeof (thead_cmo_ops)); +if (IS_ENABLED (CONFIG_ERRATA_THEAD_CMO )) {
With CONFIG_ERRATA_THEAD_CMO=n:
/stuff/linux/arch/riscv/errata/thead/errata.c: In function 'errata_probe_cmo':
/stuff/linux/arch/riscv/errata/thead/errata.c:112:46: error: 'thead_cmo_clean_range' undeclared (first use in this function)
112 | thead_cmo_ops.clean_range = &thead_cmo_clean_range;
| ^~~~~~~~~~~~~~~~~~~~~
/stuff/linux/arch/riscv/errata/thead/errata.c:112:46: note: each undeclared identifier is reported only once for each function it appears in
/stuff/linux/arch/riscv/errata/thead/errata.c:113:44: error: 'thead_cmo_inval_range' undeclared (first use in this function)
113 | thead_cmo_ops.inv_range = &thead_cmo_inval_range;
| ^~~~~~~~~~~~~~~~~~~~~
/stuff/linux/arch/riscv/errata/thead/errata.c:114:46: error: 'thead_cmo_flush_range' undeclared (first use in this function)
114 | thead_cmo_ops.flush_range = &thead_cmo_flush_range;
| ^~~~~~~~~~~~~~~~~~~~~These functions are only present if CONFIG_ERRATA_THEAD_CMO is set, so this cannot be an IS_ENABLED() as things stand.
arch/riscv/errata/thead/errata.c static bool errata_probe_cmo(unsigned int stage, · line 114
Quoted 3 lines
arch/riscv/errata/thead/errata.c +3
-0+ thead_cmo_ops.clean_range = &thead_cmo_clean_range; + thead_cmo_ops.inv_range = &thead_cmo_inval_range; + thead_cmo_ops.flush_range = &thead_cmo_flush_range;
As Arnd suggested, I'd rather see a static const struct riscv_cache_ops type deal too, so you can just call register() directly.
Quoted 21 lines
arch/riscv/errata/thead/errata.c +3
-0+riscv_noncoherent_register_cache_ops (&thead_cmo_ops); + } +return true; }arch/riscv/include/asm/dma-noncoherent.h new file +9
-0@@ -0,0 +1,83 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* Copyright (C) 2022 Renesas Electronics Corp. +*/ + +#ifndef __ASM_DMA_NONCOHERENT_H +#define __ASM_DMA_NONCOHERENT_H + +#include <linux/dma-direct.h>
arch/riscv/include/asm/dma-noncoherent.h line 19
Quoted 10 lines
arch/riscv/include/asm/dma-noncoherent.h new file +10
-0+ +enum dma_noncoherent_ops { +NON_COHERENT_SYNC_DMA_FOR_DEVICE =0 , +NON_COHERENT_SYNC_DMA_FOR_CPU , +NON_COHERENT_DMA_PREP , +NON_COHERENT_DMA_PMEM , +}; + +/* +* struct riscv_cache_ops - Structure for CMO function pointers
Drop the "function pointers" from everything here IMO.
arch/riscv/include/asm/dma-noncoherent.h line 25
Quoted 6 lines
arch/riscv/include/asm/dma-noncoherent.h new file +6
-0+* @clean_range: Function pointer for clean cache +* @inv_range: Function pointer for invalidate cache +* @flush_range: Function pointer for flushing the cache +* @riscv_dma_noncoherent_cmo_ops: Function pointer for platforms who want +* to handle CMO themselves. If this function pointer is set rest of the +* function pointers will be NULL.
Will be NULL? Or must be NULL?
Assuming you keep it, as I see Arnd is questioning it, I think a better description is needed for this one. And a rename of the function name, the one you have right now is oddly juxtaposed and a bit confusing. I don't really have something much better to suggest, so I am gonna use cmo_omnibus here...
@cmo_omnibus: For platforms whose CMO capabilities do not align with the
standard cache management operations. If set, the specific ops must be left unset.
Circling back ages later, cmo_universal()?
Quoted 43 lines
arch/riscv/include/asm/dma-noncoherent.h new file +43
-0+struct riscv_cache_ops { +void (*clean_range)(unsigned long addr,unsigned long size); +void (*inv_range)(unsigned long addr,unsigned long size); +void (*flush_range)(unsigned long addr,unsigned long size); +void (*riscv_dma_noncoherent_cmo_ops)(void *vaddr,size_t size, +enum dma_data_direction dir, +enum dma_noncoherent_ops ops); +}; + +extern struct riscv_cache_ops zicbom_cmo_ops; + +#ifdef CONFIG_RISCV_DMA_NONCOHERENT + +extern struct riscv_cache_ops noncoherent_cache_ops; + +void riscv_noncoherent_register_cache_ops (struct riscv_cache_ops *ops); + +static inline void riscv_dma_noncoherent_clean (void *vaddr,size_t size) +{ +if (noncoherent_cache_ops.clean_range) { +unsigned long addr = (unsigned long )vaddr; + + noncoherent_cache_ops.clean_range (addr, size); + } +} + +static inline void riscv_dma_noncoherent_flush (void *vaddr,size_t size) +{ +if (noncoherent_cache_ops.flush_range) { +unsigned long addr = (unsigned long )vaddr; + + noncoherent_cache_ops.flush_range (addr, size); + } +} + +static inline void riscv_dma_noncoherent_inval (void *vaddr,size_t size) +{ +if (noncoherent_cache_ops.inv_range) { +unsigned long addr = (unsigned long )vaddr; + + noncoherent_cache_ops.inv_range (addr, size); + } +}
arch/riscv/include/asm/dma-noncoherent.h line 79
Quoted 10 lines
arch/riscv/include/asm/dma-noncoherent.h new file +10
-0+ +#else + +static void riscv_noncoherent_register_cache_ops (struct riscv_cache_ops *ops) {} + +static inline void riscv_dma_noncoherent_clean (void *vaddr,size_t size) {} + +static inline void riscv_dma_noncoherent_flush (void *vaddr,size_t size) {} + +static inline void riscv_dma_noncoherent_inval (void *vaddr,size_t size) {}
Can these ever be used if DMA_NONCOHERENT is not set? I think riscv/mm/Makefile gates their usage on the symbol, no?
Quoted 6 lines
arch/riscv/include/asm/dma-noncoherent.h new file +4
-0+ +#endif + +#endif /* __ASM_DMA_NONCOHERENT_H */ arch/riscv/include/asm/errata_list.h +0
-0
[...]
Quoted 9 lines
arch/riscv/mm/dma-noncoherent.c +1
-0@@ -9,23 +9,82 @@#include <linux/dma-map-ops.h> #include <linux/mm.h> #include <asm/cacheflush.h> +#include <asm/dma-noncoherent.h>
arch/riscv/mm/dma-noncoherent.c line 22
Quoted 10 lines
arch/riscv/mm/dma-noncoherent.c +7
-0static bool noncoherent_supported; +struct riscv_cache_ops noncoherent_cache_ops = { + .clean_range =NULL , + .inv_range =NULL , + .flush_range =NULL , + .riscv_dma_noncoherent_cmo_ops =NULL , +}; +EXPORT_SYMBOL (noncoherent_cache_ops);
These exports should be _GPL, no? The file is GPLed. Ditto the others.
Quoted 106 lines
arch/riscv/mm/dma-noncoherent.c +67
-5+#ifdef CONFIG_RISCV_ISA_ZICBOM +#define ZICBOM_CMO_OP (_op, _start, _size, _cachesize) \ + asm volatile("mv a0, %1\n\t" \ + "j 2f\n\t" \ + "3:\n\t" \ + "cbo." __stringify(_op) " (a0)\n\t" \ + "add a0, a0, %0\n\t" \ + "2:\n\t" \ + "bltu a0, %2, 3b\n\t" \ + : : "r"(_cachesize), \ + "r"((unsigned long)(_start) & ~((_cachesize) - 1UL)), \ + "r"((unsigned long)(_start) + (_size)) \ + : "a0") + +static void zicbom_cmo_clean_range (unsigned long addr,unsigned long size) +{ +ZICBOM_CMO_OP (clean, addr, size, riscv_cbom_block_size); +} + +static void zicbom_cmo_flush_range (unsigned long addr,unsigned long size) +{ +ZICBOM_CMO_OP (flush, addr, size, riscv_cbom_block_size); +} + +static void zicbom_cmo_inval_range (unsigned long addr,unsigned long size) +{ +ZICBOM_CMO_OP (inval, addr, size, riscv_cbom_block_size); +} + +struct riscv_cache_ops zicbom_cmo_ops = { + .clean_range = &zicbom_cmo_clean_range, + .inv_range = &zicbom_cmo_inval_range, + .flush_range = &zicbom_cmo_flush_range, +}; +#else +struct riscv_cache_ops zicbom_cmo_ops = { + .clean_range =NULL , + .inv_range =NULL , + .flush_range =NULL , + .riscv_dma_noncoherent_cmo_ops =NULL , +}; +#endif +EXPORT_SYMBOL (zicbom_cmo_ops); +void arch_sync_dma_for_device (phys_addr_t paddr,size_t size,enum dma_data_direction dir) {void *vaddr =phys_to_virt (paddr); +if (noncoherent_cache_ops.riscv_dma_noncoherent_cmo_ops) { + noncoherent_cache_ops.riscv_dma_noncoherent_cmo_ops (vaddr, size, dir, +NON_COHERENT_SYNC_DMA_FOR_DEVICE ); +return ; + } +switch (dir) {case DMA_TO_DEVICE : -ALT_CMO_OP (clean, vaddr, size, riscv_cbom_block_size); +riscv_dma_noncoherent_clean (vaddr, size);break ;case DMA_FROM_DEVICE : -ALT_CMO_OP (clean, vaddr, size, riscv_cbom_block_size); +riscv_dma_noncoherent_clean (vaddr, size);break ;case DMA_BIDIRECTIONAL : -ALT_CMO_OP (flush, vaddr, size, riscv_cbom_block_size); +riscv_dma_noncoherent_flush (vaddr, size);break ;default :break ;@@ -37,12 +96,18 @@ void arch_sync_dma_for_cpu(phys_addr_t paddr, size_t size, {void *vaddr =phys_to_virt (paddr); +if (noncoherent_cache_ops.riscv_dma_noncoherent_cmo_ops) { + noncoherent_cache_ops.riscv_dma_noncoherent_cmo_ops (vaddr, size, dir, +NON_COHERENT_SYNC_DMA_FOR_CPU ); +return ; + } +switch (dir) {case DMA_TO_DEVICE :break ;case DMA_FROM_DEVICE :case DMA_BIDIRECTIONAL : -ALT_CMO_OP (flush, vaddr, size, riscv_cbom_block_size); +riscv_dma_noncoherent_flush (vaddr, size);break ;default :break ;@@ -53,7 +118,13 @@ void arch_dma_prep_coherent(struct page *page, size_t size) {void *flush_addr =page_address (page); -ALT_CMO_OP (flush, flush_addr, size, riscv_cbom_block_size); +if (noncoherent_cache_ops.riscv_dma_noncoherent_cmo_ops) { + noncoherent_cache_ops.riscv_dma_noncoherent_cmo_ops (flush_addr, size,-1 , +NON_COHERENT_DMA_PREP ); +return ; + } + +riscv_dma_noncoherent_flush (flush_addr, size); } void arch_setup_dma_ops(struct device *dev, u64 dma_base, u64 size,
arch/riscv/mm/dma-noncoherent.c void riscv_noncoherent_supported(void) · line 151
Quoted 3 lines
arch/riscv/mm/dma-noncoherent.c +0
-0@@ -78,3 +149,16 @@ void riscv_noncoherent_supported(void) "Non-coherent DMA support enabled without a block size\n"); noncoherent_supported = true; }
Barring the function name, which I really don't like - it really is confusingly named. Something like cmo_universal() would get it's point across a bit better I think.
arch/riscv/mm/dma-noncoherent.c void riscv_noncoherent_supported(void) · line 162
Quoted 10 lines
arch/riscv/mm/dma-noncoherent.c +10
-0+void riscv_noncoherent_register_cache_ops (struct riscv_cache_ops *ops) +{ +if (!ops) +return ; + +if (ops->riscv_dma_noncoherent_cmo_ops) + noncoherent_cache_ops.riscv_dma_noncoherent_cmo_ops = + ops->riscv_dma_noncoherent_cmo_ops; +else + noncoherent_cache_ops = *ops;
Can we just chop off the extra step here? Behaviourally this is going to be no different whether someone sets the universal op and the individual ones anyway.
arch/riscv/mm/dma-noncoherent.c void riscv_noncoherent_supported(void) · line 164
Quoted 2 lines
arch/riscv/mm/dma-noncoherent.c +2
-0+} +EXPORT_SYMBOL (riscv_noncoherent_register_cache_ops);
_GPL again I think!
I'm happy with this approach, modulo the minor bits I've pointed out. I do really like that it takes us away from messing with an asm alternative every time someone wants to do this stuff differently or for a new platform.
I would like Heiko to have a look at what you've done here, but ye looks promising IMO.
Thanks,
Conor.
Re: [RFC PATCH v6 1/6] riscv: mm: dma-noncoherent: Switch using function pointers for cache management
Hi Conor,
Thank you for the review.
Quoted 13 lines · Conor Dooley
+CC Icenowy
Hey Prabhakar,
Quoted 6 lines · Prabhakar
From: Lad Prabhakar <[email protected]>
The current implementation of CMO was handled using the
ALTERNATIVE_X()macro; this was manageable when there were a limited number of platforms using this. Now that we are having more and more platforms coming through with the CMO the use of theALTERNATIVE_X()macro becomes unmanageable.
Quoted 8 lines
Nitpick time! This opening paragraph is all a little oddly worded IMO. How about:
Currently, selecting which CMOs to use on a given platform is done using and
ALTERNATIVE_X()macro. This was manageable when there were just two CMO implementations, but now that there are more and more platforms coming needing custom CMOs, the use of theALTERNATIVE_X()macro is unmanageable.
sounds good.
Quoted 5 lines
Quoted 2 lines
To avoid such issues this patch switches to use of function pointers instead of
ALTERNATIVE_X()macro for cache management (the only draw beings/draw/drawback
oops.
Quoted 6 lines
Quoted 1 line
performance over the previous approach).
Did you notice a performance decrease or are you speculating? Perhaps Icenowy - who I know benched their implmentation of a new CMO macro for THEAD stuff can do so again for this.
I actually haven't benchmarked the speeds to tbh I am speculating it because of the additional checks. Maybe If I export the functions instead of having them in the header and have static keys for each callback maybe that will reduce some lag if any. Does that sound good?
Quoted 4 lines
Quoted 4 lines
void (*clean_range)(unsigned long addr, unsigned long size); void (*inv_range)(unsigned long addr, unsigned long size); void (*flush_range)(unsigned long addr, unsigned long size);
Quoted 8 lines
Quoted 3 lines
The above function pointers are provided to be overridden where platforms using standard approach and for platforms who want handle the operation based on the operation the below function pointer is provided:
Think you've left out some words here chief!
Perhaps s/and for platforms who/. For platforms that/ & on the line after, s/operation/direction/ ?
I'll re-word it.
Quoted 9 lines
Quoted 6 lines
void (*riscv_dma_noncoherent_cmo_ops)(void *vaddr,
size_tsize,
enumdma_data_directiondir, enumdma_noncoherent_opsops);In the current patch we have moved the ZICBOM and T-Head CMO to use function pointers.
"Convert ZICBOM..."
OK.
Quoted 67 lines
Quoted 67 lines
Signed-off-by Lad Prabhakar <[email protected]>---
v5->v6
* New patch--- arch/riscv/errata/thead/errata.c | 71 ++++++++++++++++++ arch/riscv/include/asm/dma-noncoherent.h | 83 +++++++++++++++++++++ arch/riscv/include/asm/errata_list.h | 53 ------------- arch/riscv/kernel/cpufeature.c | 2 + arch/riscv/mm/dma-noncoherent.c | 94 ++++++++++++++++++++++-- arch/riscv/mm/pmem.c | 18 ++++- 6 files changed, 260 insertions(+), 61 deletions(-) create mode 100644 arch/riscv/include/asm/dma-noncoherent.harch/riscv/errata/thead/errata.c +39
-0@@ -8,12 +8,72 @@#include <linux/module.h> #include <linux/string.h> #include <linux/uaccess.h> +#include <asm/dma-noncoherent.h> #include <asm/alternative.h> #include <asm/cacheflush.h> #include <asm/errata_list.h> #include <asm/patch.h> #include <asm/vendorid_list.h> +#ifdef CONFIG_ERRATA_THEAD_CMO +/* +* dcache.ipa rs1 (invalidate, physical address) +* | 31 - 25 | 24 - 20 | 19 - 15 | 14 - 12 | 11 - 7 | 6 - 0 | +* 0000001 01010 rs1 000 00000 0001011 +* dache.iva rs1 (invalida, virtual address) +* 0000001 00110 rs1 000 00000 0001011 +* +* dcache.cpa rs1 (clean, physical address) +* | 31 - 25 | 24 - 20 | 19 - 15 | 14 - 12 | 11 - 7 | 6 - 0 | +* 0000001 01001 rs1 000 00000 0001011 +* dcache.cva rs1 (clean, virtual address) +* 0000001 00100 rs1 000 00000 0001011 +* +* dcache.cipa rs1 (clean then invalidate, physical address) +* | 31 - 25 | 24 - 20 | 19 - 15 | 14 - 12 | 11 - 7 | 6 - 0 | +* 0000001 01011 rs1 000 00000 0001011 +* dcache.civa rs1 (... virtual address) +* 0000001 00111 rs1 000 00000 0001011 +* +* sync.s (make sure all cache operations finished) +* | 31 - 25 | 24 - 20 | 19 - 15 | 14 - 12 | 11 - 7 | 6 - 0 | +* 0000000 11001 00000 000 00000 0001011 +*/ +#define THEAD_inval_A0 ".long 0x0265000b" +#define THEAD_clean_A0 ".long 0x0245000b" +#define THEAD_flush_A0 ".long 0x0275000b" +#define THEAD_SYNC_S ".long 0x0190000b" + +#define THEAD_CMO_OP (_op, _start, _size, _cachesize) \ + asm volatile("mv a0, %1\n\t" \ + "j 2f\n\t" \ + "3:\n\t" \ + THEAD_##_op##_A0 "\n\t" \ + "add a0, a0, %0\n\t" \ + "2:\n\t" \ + "bltu a0, %2, 3b\n\t" \ + THEAD_SYNC_S \
Quoted 9 lines
arch/riscv/errata/thead/errata.c line 59
Quoted 4 lines
arch/riscv/errata/thead/errata.c +4
-0+ : : "r"(_cachesize), \ + "r"((unsigned long)(_start) & ~((_cachesize) - 1UL)), \ + "r"((unsigned long)(_start) + (_size)) \ + : "a0")I'm not going to provide a tested-by for the THEAD stuff, as I have no metrics - but I booted my usual NFS and did some tyre kicking. Seemed grand.
\o/
Quoted 50 lines
Quoted 29 lines
arch/riscv/errata/thead/errata.c +18
-0+static void thead_cmo_clean_range (unsigned long addr,unsigned long size) +{ +THEAD_CMO_OP (clean, addr, size, riscv_cbom_block_size); +} + +static void thead_cmo_flush_range (unsigned long addr,unsigned long size) +{ +THEAD_CMO_OP (flush, addr, size, riscv_cbom_block_size); +} + +static void thead_cmo_inval_range (unsigned long addr,unsigned long size) +{ +THEAD_CMO_OP (inval, addr, size, riscv_cbom_block_size); +} +#endif +static bool errata_probe_pbmt (unsigned int stage,unsigned long arch_id,unsigned long impid) {@@ -33,6 +93,8 @@ static bool errata_probe_pbmt(unsigned int stage,static bool errata_probe_cmo (unsigned int stage,unsigned long arch_id,unsigned long impid) { +struct riscv_cache_ops thead_cmo_ops; +if (!IS_ENABLED (CONFIG_ERRATA_THEAD_CMO ))return false;arch/riscv/errata/thead/errata.c static bool errata_probe_cmo(unsigned int stage, · line 111
Quoted 6 lines
arch/riscv/errata/thead/errata.c +3
-0@@ -44,6 +106,15 @@ static bool errata_probe_cmo(unsigned int stage, riscv_cbom_block_size =L1_CACHE_BYTES ;riscv_noncoherent_supported (); + +memset (&thead_cmo_ops,0x0 ,sizeof (thead_cmo_ops)); +if (IS_ENABLED (CONFIG_ERRATA_THEAD_CMO )) {With
CONFIG_ERRATA_THEAD_CMO=n:/stuff/linux/arch/riscv/errata/thead/errata.c: In function '
errata_probe_cmo':
/stuff/linux/arch/riscv/errata/thead/errata.c:112:46: error: 'thead_cmo_clean_range' undeclared (first use in this function)112 | thead_cmo_ops.clean_range = &thead_cmo_clean_range; | ^~~~~~~~~~~~~~~~~~~~~ /stuff/linux/arch/riscv/errata/thead/errata.c:112:46: note: each undeclared identifier is reported only once for each function it appears in /stuff/linux/arch/riscv/errata/thead/errata.c:113:44: error: 'thead_cmo_inval_range' undeclared (first use in this function) 113 | thead_cmo_ops.inv_range = &thead_cmo_inval_range; | ^~~~~~~~~~~~~~~~~~~~~ /stuff/linux/arch/riscv/errata/thead/errata.c:114:46: error: 'thead_cmo_flush_range' undeclared (first use in this function) 114 | thead_cmo_ops.flush_range = &thead_cmo_flush_range; | ^~~~~~~~~~~~~~~~~~~~~
Quoted 3 lines
These functions are only present if
CONFIG_ERRATA_THEAD_CMOis set, so this cannot be anIS_ENABLED()as things stand.
OK, I'll fix this.
Quoted 8 lines
arch/riscv/errata/thead/errata.c static bool errata_probe_cmo(unsigned int stage, · line 114
Quoted 3 lines
arch/riscv/errata/thead/errata.c +3
-0+ thead_cmo_ops.clean_range = &thead_cmo_clean_range; + thead_cmo_ops.inv_range = &thead_cmo_inval_range; + thead_cmo_ops.flush_range = &thead_cmo_flush_range;As Arnd suggested, I'd rather see a
static const struct riscv_cache_opstype deal too, so you can just callregister()directly.
Sure will do that.
Quoted 25 lines
Quoted 25 lines
arch/riscv/errata/thead/errata.c +3
-0+riscv_noncoherent_register_cache_ops (&thead_cmo_ops); + } +return true; }arch/riscv/include/asm/dma-noncoherent.h new file +13
-0@@ -0,0 +1,83 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* Copyright (C) 2022 Renesas Electronics Corp. +*/ + +#ifndef __ASM_DMA_NONCOHERENT_H +#define __ASM_DMA_NONCOHERENT_H + +#include <linux/dma-direct.h> + +enum dma_noncoherent_ops { +NON_COHERENT_SYNC_DMA_FOR_DEVICE =0 , + NON_COHERENT_SYNC_DMA_FOR_CPU,
Quoted 9 lines
arch/riscv/include/asm/dma-noncoherent.h line 19
Quoted 6 lines
arch/riscv/include/asm/dma-noncoherent.h new file +6
-0+NON_COHERENT_DMA_PREP , + NON_COHERENT_DMA_PMEM, +}; + +/* +* struct riscv_cache_ops - Structure for CMO function pointers Drop the "function pointers" from everything here IMO.
OK.
Quoted 14 lines
arch/riscv/include/asm/dma-noncoherent.h line 25
Quoted 6 lines
arch/riscv/include/asm/dma-noncoherent.h new file +6
-0+* @clean_range: Function pointer for clean cache +* @inv_range: Function pointer for invalidate cache +* @flush_range: Function pointer for flushing the cache +* @riscv_dma_noncoherent_cmo_ops: Function pointer for platforms who want +* to handle CMO themselves. If this function pointer is set rest of the +* function pointers will be NULL. Will be NULL? Or must be NULL?
Assuming you keep it, as I see Arnd is questioning it, I think a better description is needed for this one. And a rename of the function name, the one you have right now is oddly juxtaposed and a bit confusing. I don't really have something much better to suggest, so I am gonna usecmo_omnibushere...
Quoted 4 lines
@cmo_omnibus: For platforms whose CMO capabilities do not align with the
standard cache management operations. If set, the specific ops must be left unset.
OK, I'll update the description as above.
Quoted 2 lines
Circling back ages later,
cmo_universal()?
Sounds good to me.
Quoted 48 lines
Quoted 48 lines
arch/riscv/include/asm/dma-noncoherent.h new file +48
-0+struct riscv_cache_ops { +void (*clean_range)(unsigned long addr,unsigned long size); +void (*inv_range)(unsigned long addr,unsigned long size); +void (*flush_range)(unsigned long addr,unsigned long size); +void (*riscv_dma_noncoherent_cmo_ops)(void *vaddr,size_t size, +enum dma_data_direction dir, +enum dma_noncoherent_ops ops); +}; + +extern struct riscv_cache_ops zicbom_cmo_ops; + +#ifdef CONFIG_RISCV_DMA_NONCOHERENT + +extern struct riscv_cache_ops noncoherent_cache_ops; + +void riscv_noncoherent_register_cache_ops (struct riscv_cache_ops *ops); + +static inline void riscv_dma_noncoherent_clean (void *vaddr,size_t size) +{ +if (noncoherent_cache_ops.clean_range) { +unsigned long addr = (unsigned long )vaddr; + + noncoherent_cache_ops.clean_range (addr, size); + } +} + +static inline void riscv_dma_noncoherent_flush (void *vaddr,size_t size) +{ +if (noncoherent_cache_ops.flush_range) { +unsigned long addr = (unsigned long )vaddr; + + noncoherent_cache_ops.flush_range (addr, size); + } +} + +static inline void riscv_dma_noncoherent_inval (void *vaddr,size_t size) +{ +if (noncoherent_cache_ops.inv_range) { +unsigned long addr = (unsigned long )vaddr; + + noncoherent_cache_ops.inv_range (addr, size); + } +} + +#else + +static void riscv_noncoherent_register_cache_ops (struct riscv_cache_ops *ops) {} +
Quoted 9 lines
arch/riscv/include/asm/dma-noncoherent.h line 79
Quoted 5 lines
arch/riscv/include/asm/dma-noncoherent.h new file +5
-0+static inline void riscv_dma_noncoherent_clean (void *vaddr,size_t size) {} + +static inline void riscv_dma_noncoherent_flush (void *vaddr,size_t size) {} + +static inline void riscv_dma_noncoherent_inval (void *vaddr,size_t size) {}Can these ever be used if
DMA_NONCOHERENTis not set? I think riscv/mm/Makefile gates their usage on the symbol, no?
I think I can get rid of these.
Quoted 21 lines
Quoted 6 lines
arch/riscv/include/asm/dma-noncoherent.h new file +4
-0+ +#endif + +#endif /* __ASM_DMA_NONCOHERENT_H */ arch/riscv/include/asm/errata_list.h +0
-0[...]
Quoted 12 lines
arch/riscv/mm/dma-noncoherent.c +1
-0@@ -9,23 +9,82 @@#include <linux/dma-map-ops.h> #include <linux/mm.h> #include <asm/cacheflush.h> +#include <asm/dma-noncoherent.h> static bool noncoherent_supported;
Quoted 10 lines
arch/riscv/mm/dma-noncoherent.c line 22
Quoted 7 lines
arch/riscv/mm/dma-noncoherent.c +7
-0+struct riscv_cache_ops noncoherent_cache_ops = { + .clean_range =NULL , + .inv_range =NULL , + .flush_range =NULL , + .riscv_dma_noncoherent_cmo_ops =NULL , +}; +EXPORT_SYMBOL (noncoherent_cache_ops);These exports should be
_GPL, no? The file is GPLed. Ditto the others.
Agreed.
Quoted 104 lines
Quoted 104 lines
arch/riscv/mm/dma-noncoherent.c +67
-5+#ifdef CONFIG_RISCV_ISA_ZICBOM +#define ZICBOM_CMO_OP (_op, _start, _size, _cachesize) \ + asm volatile("mv a0, %1\n\t" \ + "j 2f\n\t" \ + "3:\n\t" \ + "cbo." __stringify(_op) " (a0)\n\t" \ + "add a0, a0, %0\n\t" \ + "2:\n\t" \ + "bltu a0, %2, 3b\n\t" \ + : : "r"(_cachesize), \ + "r"((unsigned long)(_start) & ~((_cachesize) - 1UL)), \ + "r"((unsigned long)(_start) + (_size)) \ + : "a0") + +static void zicbom_cmo_clean_range (unsigned long addr,unsigned long size) +{ +ZICBOM_CMO_OP (clean, addr, size, riscv_cbom_block_size); +} + +static void zicbom_cmo_flush_range (unsigned long addr,unsigned long size) +{ +ZICBOM_CMO_OP (flush, addr, size, riscv_cbom_block_size); +} + +static void zicbom_cmo_inval_range (unsigned long addr,unsigned long size) +{ +ZICBOM_CMO_OP (inval, addr, size, riscv_cbom_block_size); +} + +struct riscv_cache_ops zicbom_cmo_ops = { + .clean_range = &zicbom_cmo_clean_range, + .inv_range = &zicbom_cmo_inval_range, + .flush_range = &zicbom_cmo_flush_range, +}; +#else +struct riscv_cache_ops zicbom_cmo_ops = { + .clean_range =NULL , + .inv_range =NULL , + .flush_range =NULL , + .riscv_dma_noncoherent_cmo_ops =NULL , +}; +#endif +EXPORT_SYMBOL (zicbom_cmo_ops); +void arch_sync_dma_for_device (phys_addr_t paddr,size_t size,enum dma_data_direction dir) {void *vaddr =phys_to_virt (paddr); +if (noncoherent_cache_ops.riscv_dma_noncoherent_cmo_ops) { + noncoherent_cache_ops.riscv_dma_noncoherent_cmo_ops (vaddr, size, dir, +NON_COHERENT_SYNC_DMA_FOR_DEVICE ); +return ; + } +switch (dir) {case DMA_TO_DEVICE : -ALT_CMO_OP (clean, vaddr, size, riscv_cbom_block_size); +riscv_dma_noncoherent_clean (vaddr, size);break ;case DMA_FROM_DEVICE : -ALT_CMO_OP (clean, vaddr, size, riscv_cbom_block_size); +riscv_dma_noncoherent_clean (vaddr, size);break ;case DMA_BIDIRECTIONAL : -ALT_CMO_OP (flush, vaddr, size, riscv_cbom_block_size); +riscv_dma_noncoherent_flush (vaddr, size);break ;default :break ;@@ -37,12 +96,18 @@ void arch_sync_dma_for_cpu(phys_addr_t paddr, size_t size, {void *vaddr =phys_to_virt (paddr); +if (noncoherent_cache_ops.riscv_dma_noncoherent_cmo_ops) { + noncoherent_cache_ops.riscv_dma_noncoherent_cmo_ops (vaddr, size, dir, +NON_COHERENT_SYNC_DMA_FOR_CPU ); +return ; + } +switch (dir) {case DMA_TO_DEVICE :break ;case DMA_FROM_DEVICE :case DMA_BIDIRECTIONAL : -ALT_CMO_OP (flush, vaddr, size, riscv_cbom_block_size); +riscv_dma_noncoherent_flush (vaddr, size);break ;default :break ;@@ -53,7 +118,13 @@ void arch_dma_prep_coherent(struct page *page, size_t size) {void *flush_addr =page_address (page); -ALT_CMO_OP (flush, flush_addr, size, riscv_cbom_block_size); +if (noncoherent_cache_ops.riscv_dma_noncoherent_cmo_ops) { + noncoherent_cache_ops.riscv_dma_noncoherent_cmo_ops (flush_addr, size,-1 , +NON_COHERENT_DMA_PREP ); +return ; + } + +riscv_dma_noncoherent_flush (flush_addr, size); }
Quoted 10 lines
arch/riscv/mm/dma-noncoherent.c void riscv_noncoherent_supported(void) · line 151
Quoted 5 lines
arch/riscv/mm/dma-noncoherent.c +0
-0void arch_setup_dma_ops(struct device *dev, u64 dma_base, u64 size,@@ -78,3 +149,16 @@ void riscv_noncoherent_supported(void) "Non-coherent DMA support enabled without a block size\n"); noncoherent_supported = true; }Barring the function name, which I really don't like - it really is confusingly named. Something like
cmo_universal()would get it's point across a bit better I think.
OK, I'll rename riscv_dma_noncoherent_cmo_ops to cmo_universal.
Quoted 6 lines
Quoted 6 lines
arch/riscv/mm/dma-noncoherent.c +6
-0+void riscv_noncoherent_register_cache_ops (struct riscv_cache_ops *ops) +{ +if (!ops) +return ; + +if (ops->riscv_dma_noncoherent_cmo_ops)
Quoted 9 lines
arch/riscv/mm/dma-noncoherent.c void riscv_noncoherent_supported(void) · line 162
Quoted 4 lines
arch/riscv/mm/dma-noncoherent.c +4
-0+ noncoherent_cache_ops.riscv_dma_noncoherent_cmo_ops = + ops->riscv_dma_noncoherent_cmo_ops; + else + noncoherent_cache_ops = *ops;Can we just chop off the extra step here? Behaviourally this is going to be no different whether someone sets the universal op and the individual ones anyway.
Agreed.
Quoted 5 lines
arch/riscv/mm/dma-noncoherent.c void riscv_noncoherent_supported(void) · line 164
Quoted 2 lines
arch/riscv/mm/dma-noncoherent.c +2
-0+} +EXPORT_SYMBOL (riscv_noncoherent_register_cache_ops);
_GPLagain I think!
OK.
Quoted 5 lines
I'm happy with this approach, modulo the minor bits I've pointed out. I do really like that it takes us away from messing with an asm alternative every time someone wants to do this stuff differently or for a new platform.
\o/
Quoted 6 lines
I would like Heiko to have a look at what you've done here, but ye looks promising IMO.
Thanks,
Conor.
Cheers,
Prabhakar
PATCH v6 2/6 riscv: asm: vendorid_list: Add Andes Technology to the vendors list
In reply to PrabhakarFrom: Lad Prabhakar <[email protected]>
Add Andes Technology to the vendors list.
---
v5 -> v6
* No change
v4 -> v5
* Included RB tags
RFC v3 -> v4
* New patch
--- arch/riscv/include/asm/vendorid_list.h | 1 + 1 file changed, 1 insertion(+)
arch/riscv/include/asm/vendorid_list.h +1 -0
@@ -5,6 +5,7 @@#ifndef ASM_VENDOR_LIST_H #define ASM_VENDOR_LIST_H +#define ANDESTECH_VENDOR_ID 0x31e#define SIFIVE_VENDOR_ID 0x489#define THEAD_VENDOR_ID 0x5b7
Signature · 7 lines
2.25.1 _______________________________________________ linux-riscv mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-riscv
PATCH v6 3/6 riscv: errata: Add Andes alternative ports
In reply to PrabhakarFrom: Lad Prabhakar <[email protected]>
Add required ports of the Alternative scheme for Andes CPU cores.
I/O Coherence Port (IOCP) provides an AXI interface for connecting external non-caching masters, such as DMA controllers. IOCP is a specification option and is disabled on the Renesas RZ/Five SoC due to this reason cache management needs a software workaround.
---
v5 -> v6
* Dropped patching alternative and now just probing IOCP
v4 -> v5
* Sorted the Kconfig/Makefile/Switch based on Core name
* Added a comments
* Introduced RZFIVE_SBI_EXT_IOCP_SW_WORKAROUND SBI EXT ID to check if CMO needs to be applied. Is there a way we can access the DTB while patching as we can drop this SBI EXT ID and add a DT property instead for cmo?
RFC v3 -> v4
* New patch
--- arch/riscv/Kconfig.erratas | 22 +++++++++ arch/riscv/errata/Makefile | 1 + arch/riscv/errata/andes/Makefile | 1 + arch/riscv/errata/andes/errata.c | 71 ++++++++++++++++++++++++++++ arch/riscv/include/asm/alternative.h | 3 ++ arch/riscv/kernel/alternative.c | 5 ++ 6 files changed, 103 insertions(+) create mode 100644 arch/riscv/errata/andes/Makefile create mode 100644 arch/riscv/errata/andes/errata.c
arch/riscv/Kconfig.erratas +22 -0
@@ -1,5 +1,27 @@ menu "CPU errata selection" +config ERRATA_ANDES + bool "Andes AX45MP errata" + depends on !XIP_KERNEL + select RISCV_ALTERNATIVE + help + All Andes errata Kconfig depend on this Kconfig. Disabling + this Kconfig will disable all Andes errata. Please say "Y" + here if your platform uses Andes CPU cores. + + Otherwise, please say "N" here to avoid unnecessary overhead. + +config ERRATA_ANDES_CMO + bool "Apply Andes cache management errata" + depends on ERRATA_ANDES && MMU && ARCH_R9A07G043 + select RISCV_DMA_NONCOHERENT + default y + help + This will apply the cache management errata to handle the + non-standard handling on non-coherent operations on Andes cores. + + If you don't know what to do here, say "Y". + config ERRATA_SIFIVE bool "SiFive errata" depends on !XIP_KERNEL
arch/riscv/errata/Makefile +1 -0
@@ -1,2 +1,3 @@ +obj-$(CONFIG_ERRATA_ANDES) += andes/ obj-$(CONFIG_ERRATA_SIFIVE) += sifive/ obj-$(CONFIG_ERRATA_THEAD) += thead/
arch/riscv/errata/andes/Makefile new file +1 -0
@@ -0,0 +1 @@ +obj-y += errata.o
arch/riscv/errata/andes/errata.c new file +71 -0
71 lines not on this page · raw message
arch/riscv/include/asm/alternative.h +3 -0
@@ -43,6 +43,9 @@ struct errata_checkfunc_id {bool (*func)(struct alt_entry *alt); }; +void andes_errata_patch_func (struct alt_entry *begin,struct alt_entry *end, +unsigned long archid,unsigned long impid, +unsigned int stage);void sifive_errata_patch_func (struct alt_entry *begin,struct alt_entry *end,unsigned long archid,unsigned long impid,unsigned int stage);
arch/riscv/kernel/alternative.c +5 -0
@@ -40,6 +40,11 @@ static void __init_or_module riscv_fill_cpu_mfr_info(struct cpu_manufacturer_inf#endif switch (cpu_mfr_info->vendor_id) { +#ifdef CONFIG_ERRATA_ANDES +case ANDESTECH_VENDOR_ID : + cpu_mfr_info->patch_func = andes_errata_patch_func; +break ; +#endif #ifdef CONFIG_ERRATA_SIFIVE case SIFIVE_VENDOR_ID : cpu_mfr_info->patch_func = sifive_errata_patch_func;
Signature · 7 lines
2.25.1 _______________________________________________ linux-riscv mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-riscv
Re: [PATCH v6 3/6] riscv: errata: Add Andes alternative ports
Quoted 52 lines · Prabhakar
From: Lad Prabhakar <[email protected]>
Add required ports of the Alternative scheme for Andes CPU cores.
I/O Coherence Port (IOCP) provides an AXI interface for connecting external non-caching masters, such as DMA controllers. IOCP is a specification option and is disabled on the Renesas RZ/Five SoC due to this reason cache management needs a software workaround.
Signed-off-by Lad Prabhakar <[email protected]>---
v5 -> v6
* Dropped patching alternative and now just probing IOCPv4 -> v5
* Sorted the Kconfig/Makefile/Switch based on Core name
* Added a comments
* IntroducedRZFIVE_SBI_EXT_IOCP_SW_WORKAROUNDSBI EXT ID to check if CMO needs to be applied. Is there a way we can access the DTB while patching as we can drop this SBI EXT ID and add a DT property instead for cmo?RFC v3 -> v4
* New patch--- arch/riscv/Kconfig.erratas | 22 +++++++++ arch/riscv/errata/Makefile | 1 + arch/riscv/errata/andes/Makefile | 1 + arch/riscv/errata/andes/errata.c | 71 ++++++++++++++++++++++++++++ arch/riscv/include/asm/alternative.h | 3 ++ arch/riscv/kernel/alternative.c | 5 ++ 6 files changed, 103 insertions(+) create mode 100644 arch/riscv/errata/andes/Makefile create mode 100644 arch/riscv/errata/andes/errata.carch/riscv/Kconfig.erratas +11
-0@@ -1,5 +1,27 @@ menu "CPU errata selection" +config ERRATA_ANDES + bool "Andes AX45MP errata" + depends on !XIP_KERNEL + select RISCV_ALTERNATIVE + help + All Andes errata Kconfig depend on this Kconfig. Disabling + this Kconfig will disable all Andes errata. Please say "Y" + here if your platform uses Andes CPU cores. + + Otherwise, please say "N" here to avoid unnecessary overhead. +
arch/riscv/Kconfig.erratas line 23
Quoted 10 lines
arch/riscv/Kconfig.erratas +10
-0+config ERRATA_ANDES_CMO + bool "Apply Andes cache management errata" + depends on ERRATA_ANDES && MMU && ARCH_R9A07G043 + select RISCV_DMA_NONCOHERENT + default y + help + This will apply the cache management errata to handle the + non-standard handling on non-coherent operations on Andes cores. + + If you don't know what to do here, say "Y".
Ideally we would not need errata to turn this stuff on at all, but, as you pointed out to me off-list, arch_setup_dma_ops() complains if we have not set up.
I'm happy to commit to trying to sort that out in follow on work w/ MPFS, since in that case it really isn't errata, and not require it for this series as you do fit that particular bill IMO.
Thanks,
Conor.
PATCH v6 4/6 dt-bindings: cache: r9a07g043f-l2-cache: Add DT binding documentation for L2 cache controller
In reply to PrabhakarFrom: Lad Prabhakar <[email protected]>
Add DT binding documentation for L2 cache controller found on RZ/Five SoC.
The Renesas RZ/Five microprocessor includes a RISC-V CPU Core (AX45MP Single) from Andes. The AX45MP core has an L2 cache controller, this patch describes the L2 cache block.
---
v5 -> v6
* Included RB tag from Geert
v4 -> v5
* Dropped L2 cache configuration properties
* Dropped PMA configuration properties
* Ordered the required list to match the properties list
RFC v3 -> v4
* Dropped l2 cache configuration parameters
* s/larger/large
* Added minItems/maxItems for andestech,pma-regions
--- .../cache/andestech,ax45mp-cache.yaml | 81 +++++++++++++++++++ 1 file changed, 81 insertions(+) create mode 100644 Documentation/devicetree/bindings/cache/andestech,ax45mp-cache.yaml
Documentation/devicetree/bindings/cache/andestech,ax45mp-cache.yaml new file +81 -0
@@ -0,0 +1,81 @@ +# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause) +# Copyright (C) 2022 Renesas Electronics Corp. +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/cache/andestech,ax45mp-cache.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Andestech AX45MP L2 Cache Controller + +maintainers: + - Lad Prabhakar <[email protected]> + +description: + A level-2 cache (L2C) is used to improve the system performance by providing + a large amount of cache line entries and reasonable access delays. The L2C + is shared between cores, and a non-inclusive non-exclusive policy is used. + +select: + properties: + compatible: + contains: + enum: + - andestech,ax45mp-cache + + required: + - compatible + +properties: + compatible: + items: + - const: andestech,ax45mp-cache + - const: cache + + reg: + maxItems: 1 + + interrupts: + maxItems: 1 + + cache-line-size: + const: 64 + + cache-level: + const: 2 + + cache-sets: + const: 1024 + + cache-size: + enum: [131072, 262144, 524288, 1048576, 2097152] + + cache-unified: true + + next-level-cache: true + +additionalProperties: false + +required: + - compatible + - reg + - interrupts + - cache-line-size + - cache-level + - cache-sets + - cache-size + - cache-unified + +examples: + - | + #include <dt-bindings/interrupt-controller/irq.h> + + cache-controller@2010000 { + compatible = "andestech,ax45mp-cache", "cache"; + reg = <0x13400000 0x100000>; + interrupts = <508 IRQ_TYPE_LEVEL_HIGH>; + cache-line-size = <64>; + cache-level = <2>; + cache-sets = <1024>; + cache-size = <262144>; + cache-unified; + };
Signature · 7 lines
2.25.1 _______________________________________________ linux-riscv mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-riscv
Re: [PATCH v6 4/6] dt-bindings: cache: r9a07g043f-l2-cache: Add DT binding documentation for L2 cache controller
Quoted 8 lines · Prabhakar
From: Lad Prabhakar <[email protected]>
Add DT binding documentation for L2 cache controller found on RZ/Five SoC.
The Renesas RZ/Five microprocessor includes a RISC-V CPU Core (AX45MP Single) from Andes. The AX45MP core has an L2 cache controller, this patch describes the L2 cache block.
Quoted 5 lines
Signed-off-by Lad Prabhakar <[email protected]>Reviewed-by Rob Herring <[email protected]>---
v5 -> v6
* Included RB tag from Geert
I think not!
Quoted 42 lines
v4 -> v5
* Dropped L2 cache configuration properties
* Dropped PMA configuration properties
* Ordered the required list to match the properties listRFC v3 -> v4
* Dropped l2 cache configuration parameters
* s/larger/large
* Added minItems/maxItems for andestech,pma-regions--- .../cache/andestech,ax45mp-cache.yaml | 81 +++++++++++++++++++ 1 file changed, 81 insertions(+) create mode 100644 Documentation/devicetree/bindings/cache/andestech,ax45mp-cache.yamlDocumentation/devicetree/bindings/cache/andestech,ax45mp-cache.yaml new file +22
-0@@ -0,0 +1,81 @@ +# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause) +# Copyright (C) 2022 Renesas Electronics Corp. +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/cache/andestech,ax45mp-cache.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Andestech AX45MP L2 Cache Controller + +maintainers: + - Lad Prabhakar <[email protected]> + +description: + A level-2 cache (L2C) is used to improve the system performance by providing + a large amount of cache line entries and reasonable access delays. The L2C + is shared between cores, and a non-inclusive non-exclusive policy is used. + +select: + properties: + compatible: + contains: + enum:
Documentation/devicetree/bindings/cache/andestech,ax45mp-cache.yaml line 32
Quoted 10 lines
Documentation/devicetree/bindings/cache/andestech,ax45mp-cache.yaml new file +10
-0+ - andestech,ax45mp-cache + + required: + - compatible + +properties: + compatible: + items: + - const: andestech,ax45mp-cache + - const: cache
You might find value in a specific compatible for your SoC & enforce constraints for it. Or you might not & I don't care either way :)
Thanks,
Conor.
Re: [PATCH v6 4/6] dt-bindings: cache: r9a07g043f-l2-cache: Add DT binding documentation for L2 cache controller
Hi Conor,
Thank you for the review.
Quoted 10 lines · Conor Dooley
Quoted 8 lines · Prabhakar
From: Lad Prabhakar <[email protected]>
Add DT binding documentation for L2 cache controller found on RZ/Five SoC.
The Renesas RZ/Five microprocessor includes a RISC-V CPU Core (AX45MP Single) from Andes. The AX45MP core has an L2 cache controller, this patch describes the L2 cache block.
Quoted 8 lines
Quoted 5 lines
Signed-off-by Lad Prabhakar <[email protected]>Reviewed-by Rob Herring <[email protected]>---
v5 -> v6
* Included RB tag from GeertI think not!
Sorry that was a typo. I meant Rob :)
Quoted 47 lines
Quoted 47 lines
v4 -> v5
* Dropped L2 cache configuration properties
* Dropped PMA configuration properties
* Ordered the required list to match the properties listRFC v3 -> v4
* Dropped l2 cache configuration parameters
* s/larger/large
* Added minItems/maxItems for andestech,pma-regions--- .../cache/andestech,ax45mp-cache.yaml | 81 +++++++++++++++++++ 1 file changed, 81 insertions(+) create mode 100644 Documentation/devicetree/bindings/cache/andestech,ax45mp-cache.yamlDocumentation/devicetree/bindings/cache/andestech,ax45mp-cache.yaml new file +27
-0@@ -0,0 +1,81 @@ +# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause) +# Copyright (C) 2022 Renesas Electronics Corp. +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/cache/andestech,ax45mp-cache.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Andestech AX45MP L2 Cache Controller + +maintainers: + - Lad Prabhakar <[email protected]> + +description: + A level-2 cache (L2C) is used to improve the system performance by providing + a large amount of cache line entries and reasonable access delays. The L2C + is shared between cores, and a non-inclusive non-exclusive policy is used. + +select: + properties: + compatible: + contains: + enum: + - andestech,ax45mp-cache + + required: + - compatible +
Quoted 9 lines
Documentation/devicetree/bindings/cache/andestech,ax45mp-cache.yaml line 32
Quoted 5 lines
Documentation/devicetree/bindings/cache/andestech,ax45mp-cache.yaml new file +5
-0+properties: + compatible: + items: + - const: andestech,ax45mp-cache + - const: cacheYou might find value in a specific compatible for your SoC & enforce constraints for it. Or you might not & I don't care either way :)
Good point actually. Geert what do you think?
Cheers,
Prabhakar
Re: [PATCH v6 4/6] dt-bindings: cache: r9a07g043f-l2-cache: Add DT binding documentation for L2 cache controller
Hi Prabhakar,
Quoted 52 lines · Prabhakar
Quoted 42 lines · Conor Dooley
Quoted 41 lines · Prabhakar
From: Lad Prabhakar <[email protected]>
Add DT binding documentation for L2 cache controller found on RZ/Five SoC.
The Renesas RZ/Five microprocessor includes a RISC-V CPU Core (AX45MP Single) from Andes. The AX45MP core has an L2 cache controller, this patch describes the L2 cache block.
Signed-off-by Lad Prabhakar <[email protected]>Reviewed-by Rob Herring <[email protected]>Documentation/devicetree/bindings/cache/andestech,ax45mp-cache.yaml new file +27
-0@@ -0,0 +1,81 @@ +# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause) +# Copyright (C) 2022 Renesas Electronics Corp. +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/cache/andestech,ax45mp-cache.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Andestech AX45MP L2 Cache Controller + +maintainers: + - Lad Prabhakar <[email protected]> + +description: + A level-2 cache (L2C) is used to improve the system performance by providing + a large amount of cache line entries and reasonable access delays. The L2C + is shared between cores, and a non-inclusive non-exclusive policy is used. + +select: + properties: + compatible: + contains: + enum: + - andestech,ax45mp-cache + + required: + - compatible +Quoted 9 lines
Documentation/devicetree/bindings/cache/andestech,ax45mp-cache.yaml line 32
Quoted 5 lines
Documentation/devicetree/bindings/cache/andestech,ax45mp-cache.yaml new file +5
-0+properties: + compatible: + items: + - const: andestech,ax45mp-cache + - const: cacheYou might find value in a specific compatible for your SoC & enforce constraints for it. Or you might not & I don't care either way :)
Quoted 1 line
Good point actually. Geert what do you think?
That might be prudent, to cater for the way the standard AX45MP cache block is integrated into the RZ/Five (or any other) SoC.
Still, in the absence of an SoC-specific compatible value, you can handle integration issues using soc_device_match().
Gr{oetje,eeting}s,
Geert
--
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]
In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that.
-- Linus Torvalds
Re: [PATCH v6 4/6] dt-bindings: cache: r9a07g043f-l2-cache: Add DT binding documentation for L2 cache controller
Hi Geert,
Thanks for the feedback.
Quoted 57 lines · Geert Uytterhoeven
Hi Prabhakar,
Quoted 52 lines · Prabhakar
Quoted 51 lines · Conor Dooley
Quoted 36 lines · Prabhakar
From: Lad Prabhakar <[email protected]>
Add DT binding documentation for L2 cache controller found on RZ/Five SoC.
The Renesas RZ/Five microprocessor includes a RISC-V CPU Core (AX45MP Single) from Andes. The AX45MP core has an L2 cache controller, this patch describes the L2 cache block.
Signed-off-by Lad Prabhakar <[email protected]>Reviewed-by Rob Herring <[email protected]>Documentation/devicetree/bindings/cache/andestech,ax45mp-cache.yaml new file +22
-0@@ -0,0 +1,81 @@ +# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause) +# Copyright (C) 2022 Renesas Electronics Corp. +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/cache/andestech,ax45mp-cache.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Andestech AX45MP L2 Cache Controller + +maintainers: + - Lad Prabhakar <[email protected]> + +description: + A level-2 cache (L2C) is used to improve the system performance by providing + a large amount of cache line entries and reasonable access delays. The L2C + is shared between cores, and a non-inclusive non-exclusive policy is used. + +select: + properties: + compatible: + contains: + enum:Documentation/devicetree/bindings/cache/andestech,ax45mp-cache.yaml line 32
Quoted 10 lines
Documentation/devicetree/bindings/cache/andestech,ax45mp-cache.yaml new file +10
-0+ - andestech,ax45mp-cache + + required: + - compatible + +properties: + compatible: + items: + - const: andestech,ax45mp-cache + - const: cacheYou might find value in a specific compatible for your SoC & enforce constraints for it. Or you might not & I don't care either way :)
Quoted 8 lines
Quoted 1 line
Good point actually. Geert what do you think?
That might be prudent, to cater for the way the standard AX45MP cache block is integrated into the RZ/Five (or any other) SoC.
Still, in the absence of an SoC-specific compatible value, you can handle integration issues using
soc_device_match().
Agreed, I'll continue with the current DT bindings.
Cheers,
Prabhakar
PATCH v6 5/6 cache: Add L2 cache management for Andes AX45MP RISC-V core
In reply to PrabhakarFrom: Lad Prabhakar <[email protected]>
I/O Coherence Port (IOCP) provides an AXI interface for connecting external non-caching masters, such as DMA controllers. The accesses from IOCP are coherent with D-Caches and L2 Cache.
IOCP is a specification option and is disabled on the Renesas RZ/Five SoC due to this reason IP blocks using DMA will fail.
The Andes AX45MP core has a Programmable Physical Memory Attributes (PMA) block that allows dynamic adjustment of memory attributes in the runtime. It contains a configurable amount of PMA entries implemented as CSR registers to control the attributes of memory locations in interest. Below are the memory attributes supported:
* Device, Non-bufferable
* Device, bufferable
* Memory, Non-cacheable, Non-bufferable
* Memory, Non-cacheable, Bufferable
* Memory, Write-back, No-allocate
* Memory, Write-back, Read-allocate
* Memory, Write-back, Write-allocate
* Memory, Write-back, Read and Write-allocate
More info about PMA (section 10.3):
As a workaround for SoCs with IOCP disabled CMO needs to be handled by software. Firstly OpenSBI configures the memory region as "Memory, Non-cacheable, Bufferable" and passes this region as a global shared dma pool as a DT node. With DMA_GLOBAL_POOL enabled all DMA allocations happen from this region and synchronization callbacks are implemented to synchronize when doing DMA transactions.
Example PMA region passes as a DT node from OpenSBI:
reserved-memory {
#address-cells = <2>;
#size-cells = <2>;
ranges;
pma_resv0@58000000 {
compatible = "shared-dma-pool";
reg = <0x0 0x58000000 0x0 0x08000000>;
no-map;
linux,dma-default;
};
};---
v5 -> v6
* Moved driver to cache folder
* Switched to new API for CMO
v4 -> v5
* Dropped code for configuring L2 cache
* Dropped code for configuring PMA
* Updated commit message
* Added comments
* Changed static branch enable/disable order
RFC v3 -> v4
* Made use of runtime patching instead of compile time
* Now just exposing single function ax45mp_no_iocp_cmo() for CMO handling
* Added a check to make sure cache line size is always 64 bytes
* Renamed folder rzf -> rzfive
* Improved Kconfig description
* Dropped L2 cache configuration
* Dropped unnecessary casts
* Fixed comments pointed by Geert.
--- drivers/Kconfig | 2 + drivers/Makefile | 1 + drivers/cache/Kconfig | 10 ++ drivers/cache/Makefile | 3 + drivers/cache/ax45mp_cache.c | 279 +++++++++++++++++++++++++++++++++++ 5 files changed, 295 insertions(+) create mode 100644 drivers/cache/Kconfig create mode 100644 drivers/cache/Makefile create mode 100644 drivers/cache/ax45mp_cache.c
drivers/Kconfig +2 -0
@@ -15,6 +15,8 @@ source "drivers/base/Kconfig" source "drivers/bus/Kconfig" +source "drivers/cache/Kconfig" + source "drivers/connector/Kconfig" source "drivers/firmware/Kconfig"
drivers/Makefile +1 -0
@@ -6,6 +6,7 @@ # Rewritten to use lists instead of if-statements. # +obj-y += cache/ obj-y += irqchip/ obj-y += bus/
drivers/cache/Kconfig new file +10 -0
@@ -0,0 +1,10 @@ +# SPDX-License-Identifier: GPL-2.0 +menu "Cache Drivers" + +config AX45MP_L2_CACHE + bool "Andes Technology AX45MP L2 Cache controller" + depends on RISCV && RISCV_DMA_NONCOHERENT + help + Support for the L2 cache controller on Andes Technology AX45MP platforms. + +endmenu
drivers/cache/Makefile new file +3 -0
@@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0 + +obj-$(CONFIG_AX45MP_L2_CACHE) += ax45mp_cache.o
drivers/cache/ax45mp_cache.c new file +279 -0
279 lines not on this page · raw message
Signature · 7 lines
2.25.1 _______________________________________________ linux-riscv mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-riscv
Re: [PATCH v6 5/6] cache: Add L2 cache management for Andes AX45MP RISC-V core
Quoted 61 lines · Prabhakar
From: Lad Prabhakar <[email protected]>
I/O Coherence Port (IOCP) provides an AXI interface for connecting external non-caching masters, such as DMA controllers. The accesses from IOCP are coherent with D-Caches and L2 Cache.
IOCP is a specification option and is disabled on the Renesas RZ/Five SoC due to this reason IP blocks using DMA will fail.
The Andes AX45MP core has a Programmable Physical Memory Attributes (PMA) block that allows dynamic adjustment of memory attributes in the runtime. It contains a configurable amount of PMA entries implemented as CSR registers to control the attributes of memory locations in interest. Below are the memory attributes supported:
* Device, Non-bufferable
* Device, bufferable
* Memory, Non-cacheable, Non-bufferable
* Memory, Non-cacheable, Bufferable
* Memory, Write-back, No-allocate
* Memory, Write-back, Read-allocate
* Memory, Write-back, Write-allocate
* Memory, Write-back, Read and Write-allocateMore info about PMA (section 10.3):
As a workaround for SoCs with IOCP disabled CMO needs to be handled by software. Firstly OpenSBI configures the memory region as "Memory, Non-cacheable, Bufferable" and passes this region as a global shared dma pool as a DT node. With
DMA_GLOBAL_POOLenabled all DMA allocations happen from this region and synchronization callbacks are implemented to synchronize when doing DMA transactions.Example PMA region passes as a DT node from OpenSBI:
reserved-memory { #address-cells = <2>; #size-cells = <2>; ranges; pma_resv0@58000000 { compatible = "shared-dma-pool"; reg = <0x0 0x58000000 0x0 0x08000000>; no-map; linux,dma-default; }; };Signed-off-by Lad Prabhakar <[email protected]>drivers/cache/ax45mp_cache.c new file +6
-0@@ -0,0 +1,279 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* non-coherent cache functions for Andes AX45MP +* +* Copyright (C) 2022 Renesas Electronics Corp. +*/
drivers/cache/ax45mp_cache.c line 16
Quoted 10 lines
drivers/cache/ax45mp_cache.c new file +10
-0+ +#include <asm/dma-noncoherent.h> +#include <linux/cacheflush.h> +#include <linux/cacheinfo.h> +#include <linux/dma-direction.h> +#include <linux/of_address.h> +#include <linux/of_platform.h> + +#include <asm/cacheflush.h> +#include <asm/sbi.h>
You don't actually need this anymore, do you?
drivers/cache/ax45mp_cache.c line 239
Quoted 11 lines
drivers/cache/ax45mp_cache.c new file +11
-0+static int ax45mp_l2c_probe (struct platform_device *pdev) +{ +struct riscv_cache_ops ax45mp_cmo_ops; + +/* +* riscv_cbom_block_size is set very much earlier so we can +* definitely rely on it and only if its being set we continue +* further in the probe path. +*/ +if (!riscv_cbom_block_size) +return 0 ;
Return 0? That's because we may actually have the IOCP & do not want to install ops, right?
If so, please add that to the comment.
drivers/cache/ax45mp_cache.c line 252
Quoted 13 lines
drivers/cache/ax45mp_cache.c new file +13
-0+ + ax45mp_priv =devm_kzalloc (&pdev->dev,sizeof (*ax45mp_priv),GFP_KERNEL ); +if (!ax45mp_priv) +return -ENOMEM ; + + ax45mp_priv->l2c_base =devm_platform_ioremap_resource (pdev,0 ); +if (IS_ERR (ax45mp_priv->l2c_base)) +return PTR_ERR (ax45mp_priv->l2c_base); + +ax45mp_get_l2_line_size (pdev); + +memset (&ax45mp_cmo_ops,0x0 ,sizeof (ax45mp_cmo_ops)); + ax45mp_cmo_ops.riscv_dma_noncoherent_cmo_ops = &ax45mp_no_iocp_cmo;
Yah, drop this dance and use a static struct foo_ops construct please.
With those two, I'm happy with this I guess..
Quoted 17 lines
drivers/cache/ax45mp_cache.c new file +17
-0+riscv_noncoherent_register_cache_ops (&ax45mp_cmo_ops); + +return 0 ; +} + +static const struct of_device_id ax45mp_cache_ids[] = { + { .compatible ="andestech,ax45mp-cache" }, + {/* sentinel */ } +}; + +static struct platform_driver ax45mp_l2c_driver = { + .driver = { + .name ="ax45mp-l2c" , + .of_match_table = ax45mp_cache_ids, + }, + .probe = ax45mp_l2c_probe, +};
drivers/cache/ax45mp_cache.c line 279
Quoted 10 lines
drivers/cache/ax45mp_cache.c new file +10
-0+ +static int __init ax45mp_cache_init (void ) +{ +return platform_driver_register (&ax45mp_l2c_driver); +} +arch_initcall (ax45mp_cache_init); + +MODULE_AUTHOR ("Lad Prabhakar <[email protected]>" ); +MODULE_DESCRIPTION ("Andes AX45MP L2 cache driver" ); +MODULE_LICENSE ("GPL" );
BTW, I think these are surplus-to-requirements since this is never going to be built as a module.
If you resurrect the directory level maintainers entry from my v5.1, you can also add:
Thanks,
Conor.
Re: [PATCH v6 5/6] cache: Add L2 cache management for Andes AX45MP RISC-V core
Hi Conor,
Thank you for the review.
Quoted 67 lines · Conor Dooley
Quoted 65 lines · Prabhakar
From: Lad Prabhakar <[email protected]>
I/O Coherence Port (IOCP) provides an AXI interface for connecting external non-caching masters, such as DMA controllers. The accesses from IOCP are coherent with D-Caches and L2 Cache.
IOCP is a specification option and is disabled on the Renesas RZ/Five SoC due to this reason IP blocks using DMA will fail.
The Andes AX45MP core has a Programmable Physical Memory Attributes (PMA) block that allows dynamic adjustment of memory attributes in the runtime. It contains a configurable amount of PMA entries implemented as CSR registers to control the attributes of memory locations in interest. Below are the memory attributes supported:
* Device, Non-bufferable
* Device, bufferable
* Memory, Non-cacheable, Non-bufferable
* Memory, Non-cacheable, Bufferable
* Memory, Write-back, No-allocate
* Memory, Write-back, Read-allocate
* Memory, Write-back, Write-allocate
* Memory, Write-back, Read and Write-allocateMore info about PMA (section 10.3):
As a workaround for SoCs with IOCP disabled CMO needs to be handled by software. Firstly OpenSBI configures the memory region as "Memory, Non-cacheable, Bufferable" and passes this region as a global shared dma pool as a DT node. With
DMA_GLOBAL_POOLenabled all DMA allocations happen from this region and synchronization callbacks are implemented to synchronize when doing DMA transactions.Example PMA region passes as a DT node from OpenSBI:
reserved-memory { #address-cells = <2>; #size-cells = <2>; ranges; pma_resv0@58000000 { compatible = "shared-dma-pool"; reg = <0x0 0x58000000 0x0 0x08000000>; no-map; linux,dma-default; }; };Signed-off-by Lad Prabhakar <[email protected]>drivers/cache/ax45mp_cache.c new file +10
-0@@ -0,0 +1,279 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* non-coherent cache functions for Andes AX45MP +* +* Copyright (C) 2022 Renesas Electronics Corp. +*/ + +#include <asm/dma-noncoherent.h> +#include <linux/cacheflush.h> +#include <linux/cacheinfo.h>
Quoted 9 lines
drivers/cache/ax45mp_cache.c line 16
Quoted 6 lines
drivers/cache/ax45mp_cache.c new file +6
-0+#include <linux/dma-direction.h> +#include <linux/of_address.h> +#include <linux/of_platform.h> + +#include <asm/cacheflush.h> +#include <asm/sbi.h> You don't actually need this anymore, do you?
Agreed these can be dropped now.
Quoted 7 lines
Quoted 7 lines
drivers/cache/ax45mp_cache.c new file +7
-0+static int ax45mp_l2c_probe (struct platform_device *pdev) +{ +struct riscv_cache_ops ax45mp_cmo_ops; + +/* +* riscv_cbom_block_size is set very much earlier so we can +* definitely rely on it and only if its being set we continue
Quoted 9 lines
drivers/cache/ax45mp_cache.c line 239
Quoted 4 lines
drivers/cache/ax45mp_cache.c new file +4
-0+* further in the probe path. +*/ +if (!riscv_cbom_block_size) +return 0 ;Return 0? That's because we may actually have the IOCP & do not want to install ops, right?
If so, please add that to the comment.
OK, I will add that.
Quoted 7 lines
Quoted 7 lines
drivers/cache/ax45mp_cache.c new file +7
-0+ + ax45mp_priv =devm_kzalloc (&pdev->dev,sizeof (*ax45mp_priv),GFP_KERNEL ); +if (!ax45mp_priv) +return -ENOMEM ; + + ax45mp_priv->l2c_base =devm_platform_ioremap_resource (pdev,0 ); +if (IS_ERR (ax45mp_priv->l2c_base))
Quoted 9 lines
drivers/cache/ax45mp_cache.c line 252
Quoted 6 lines
drivers/cache/ax45mp_cache.c new file +6
-0+return PTR_ERR (ax45mp_priv->l2c_base); + +ax45mp_get_l2_line_size (pdev); + +memset (&ax45mp_cmo_ops,0x0 ,sizeof (ax45mp_cmo_ops)); + ax45mp_cmo_ops.riscv_dma_noncoherent_cmo_ops = &ax45mp_no_iocp_cmo;Yah, drop this dance and use a static struct
foo_opsconstruct please.
Will do.
Quoted 25 lines
With those two, I'm happy with this I guess..
Reviewed-by Conor Dooley <[email protected]>Quoted 22 lines
drivers/cache/ax45mp_cache.c new file +22
-0+riscv_noncoherent_register_cache_ops (&ax45mp_cmo_ops); + +return 0 ; +} + +static const struct of_device_id ax45mp_cache_ids[] = { + { .compatible ="andestech,ax45mp-cache" }, + {/* sentinel */ } +}; + +static struct platform_driver ax45mp_l2c_driver = { + .driver = { + .name ="ax45mp-l2c" , + .of_match_table = ax45mp_cache_ids, + }, + .probe = ax45mp_l2c_probe, +}; + +static int __init ax45mp_cache_init (void ) +{ +return platform_driver_register (&ax45mp_l2c_driver); +}
Quoted 9 lines
drivers/cache/ax45mp_cache.c line 279
Quoted 5 lines
drivers/cache/ax45mp_cache.c new file +5
-0+arch_initcall (ax45mp_cache_init); + +MODULE_AUTHOR ("Lad Prabhakar <[email protected]>" ); +MODULE_DESCRIPTION ("Andes AX45MP L2 cache driver" ); +MODULE_LICENSE ("GPL" );BTW, I think these are surplus-to-requirements since this is never going to be built as a module.
Agreed, I will drop it.
Quoted 2 lines
If you resurrect the directory level maintainers entry from my v5.1, you can also add:
Sure I'll add it in the next version..
Quoted 2 lines
Acked-by Conor Dooley <[email protected]>
... and also include your ACK.
Cheers,
Prabhakar
PATCH v6 6/6 soc: renesas: Kconfig: Select the required configs for RZ/Five SoC
In reply to PrabhakarFrom: Lad Prabhakar <[email protected]>
Explicitly select the required Cache management and Errata configs required for the RZ/Five SoC.
---v5->v6
* New patch
--- drivers/soc/renesas/Kconfig | 4 ++++ 1 file changed, 4 insertions(+)
drivers/soc/renesas/Kconfig +4 -0
@@ -340,6 +340,10 @@ if RISCV config ARCH_R9A07G043 bool "RISC-V Platform support for RZ/Five" select ARCH_RZG2L + select AX45MP_L2_CACHE + select DMA_GLOBAL_POOL + select ERRATA_ANDES + select ERRATA_ANDES_CMO help This enables support for the Renesas RZ/Five SoC.
Signature · 7 lines
2.25.1 _______________________________________________ linux-riscv mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-riscv
Re: [PATCH v6 6/6] soc: renesas: Kconfig: Select the required configs for RZ/Five SoC
FWIW: