* [PATCH v2 0/3] Nuvoton WPCM450 FIU SPI flash controller
@ 2022-11-24 19:13 Jonathan Neuschäfer
2022-11-24 19:13 ` [PATCH v2 1/3] dt-bindings: spi: Add Nuvoton WPCM450 Flash Interface Unit (FIU) Jonathan Neuschäfer
` (2 more replies)
0 siblings, 3 replies; 15+ messages in thread
From: Jonathan Neuschäfer @ 2022-11-24 19:13 UTC (permalink / raw)
To: linux-spi, openbmc
Cc: Rob Herring, Krzysztof Kozlowski, Jonathan Neuschäfer,
devicetree, linux-kernel
This patchset adds DT bindings and a driver for the Flash Interface Unit
(FIU), the SPI flash controller in the Nuvoton WPCM450 BMC SoC. It
supports four chip selects, and direct (memory-mapped) access to 16 MiB
per chip. Larger flash chips can be accessed by software-defined SPI
transfers.
The existing NPCM7xx FIU driver is sufficitently incompatible with the
WPCM450 FIU that I decided to write a new driver.
Changelog for v2:
- Dropped the patches which have been applied in the meantime, leaving
only three out of eight
- Changed the binding to require both items in the reg property, because
there is no need to keep the second item optional, suggested by
Krzysztof Kozlowski
- Various other cleanups suggested by Krzysztof Kozlowski and the kernel
test robot
Jonathan
Jonathan Neuschäfer (3):
dt-bindings: spi: Add Nuvoton WPCM450 Flash Interface Unit (FIU)
spi: wpcm-fiu: Add driver for Nuvoton WPCM450 Flash Interface Unit
(FIU)
spi: wpcm-fiu: Add direct map support
.../bindings/spi/nuvoton,wpcm450-fiu.yaml | 66 +++
drivers/spi/Kconfig | 11 +
drivers/spi/Makefile | 1 +
drivers/spi/spi-wpcm-fiu.c | 508 ++++++++++++++++++
4 files changed, 586 insertions(+)
create mode 100644 Documentation/devicetree/bindings/spi/nuvoton,wpcm450-fiu.yaml
create mode 100644 drivers/spi/spi-wpcm-fiu.c
--
2.35.1
^ permalink raw reply [flat|nested] 15+ messages in thread* [PATCH v2 1/3] dt-bindings: spi: Add Nuvoton WPCM450 Flash Interface Unit (FIU) 2022-11-24 19:13 [PATCH v2 0/3] Nuvoton WPCM450 FIU SPI flash controller Jonathan Neuschäfer @ 2022-11-24 19:13 ` Jonathan Neuschäfer 2022-11-25 8:33 ` Krzysztof Kozlowski ` (2 more replies) 2022-11-24 19:13 ` [PATCH v2 2/3] spi: wpcm-fiu: Add driver for " Jonathan Neuschäfer 2022-11-24 19:14 ` [PATCH v2 3/3] spi: wpcm-fiu: Add direct map support Jonathan Neuschäfer 2 siblings, 3 replies; 15+ messages in thread From: Jonathan Neuschäfer @ 2022-11-24 19:13 UTC (permalink / raw) To: linux-spi, openbmc Cc: Rob Herring, Krzysztof Kozlowski, Jonathan Neuschäfer, devicetree, linux-kernel, Mark Brown The Flash Interface Unit (FIU) is the SPI flash controller in the Nuvoton WPCM450 BMC SoC. It supports four chip selects, and direct (memory-mapped) access to 16 MiB per chip. Larger flash chips can be accessed by software-defined SPI transfers. The FIU in newer NPCM7xx SoCs is not compatible with the WPCM450 FIU. Signed-off-by: Jonathan Neuschäfer <j.neuschaefer@gmx.net> --- v2: - A few cleanups suggested by Krzysztof Kozlowski - Simplify binding by making second reg item mandatory v1: - https://lore.kernel.org/lkml/20221105185911.1547847-4-j.neuschaefer@gmx.net/ --- .../bindings/spi/nuvoton,wpcm450-fiu.yaml | 66 +++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 Documentation/devicetree/bindings/spi/nuvoton,wpcm450-fiu.yaml diff --git a/Documentation/devicetree/bindings/spi/nuvoton,wpcm450-fiu.yaml b/Documentation/devicetree/bindings/spi/nuvoton,wpcm450-fiu.yaml new file mode 100644 index 0000000000000..ef94803e75d90 --- /dev/null +++ b/Documentation/devicetree/bindings/spi/nuvoton,wpcm450-fiu.yaml @@ -0,0 +1,66 @@ +# SPDX-License-Identifier: GPL-2.0-only OR BSD-2-Clause +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/spi/nuvoton,wpcm450-fiu.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Nuvoton WPCM450 Flash Interface Unit (FIU) + +maintainers: + - Jonathan Neuschäfer <j.neuschaefer@gmx.net> + +allOf: + - $ref: /schemas/spi/spi-controller.yaml# + +properties: + compatible: + const: nuvoton,wpcm450-fiu + + reg: + items: + - description: FIU registers + - description: Memory-mapped flash contents + + reg-names: + items: + - const: control + - const: memory + + interrupts: + maxItems: 1 + + clocks: + maxItems: 1 + + nuvoton,shm: + $ref: /schemas/types.yaml#/definitions/phandle + description: a phandle to the SHM block (see ../arm/nuvoton,shm.yaml) + +required: + - compatible + - reg + - clocks + +unevaluatedProperties: false + +examples: + - | + #include <dt-bindings/clock/nuvoton,wpcm450-clk.h> + spi@c8000000 { + compatible = "nuvoton,wpcm450-fiu"; + reg = <0xc8000000 0x1000>, <0xc0000000 0x4000000>; + #address-cells = <1>; + #size-cells = <0>; + reg-names = "control", "memory"; + clocks = <&clk WPCM450_CLK_FIU>; + nuvoton,shm = <&shm>; + + flash@0 { + compatible = "jedec,spi-nor"; + }; + }; + + shm: syscon@c8001000 { + compatible = "nuvoton,wpcm450-shm", "syscon"; + reg = <0xc8001000 0x1000>; + }; -- 2.35.1 ^ permalink raw reply related [flat|nested] 15+ messages in thread
* Re: [PATCH v2 1/3] dt-bindings: spi: Add Nuvoton WPCM450 Flash Interface Unit (FIU) 2022-11-24 19:13 ` [PATCH v2 1/3] dt-bindings: spi: Add Nuvoton WPCM450 Flash Interface Unit (FIU) Jonathan Neuschäfer @ 2022-11-25 8:33 ` Krzysztof Kozlowski 2022-11-25 13:13 ` Mark Brown 2022-11-26 22:25 ` Rob Herring 2 siblings, 0 replies; 15+ messages in thread From: Krzysztof Kozlowski @ 2022-11-25 8:33 UTC (permalink / raw) To: Jonathan Neuschäfer, linux-spi, openbmc Cc: Rob Herring, Krzysztof Kozlowski, devicetree, linux-kernel, Mark Brown On 24/11/2022 20:13, Jonathan Neuschäfer wrote: > The Flash Interface Unit (FIU) is the SPI flash controller in the > Nuvoton WPCM450 BMC SoC. It supports four chip selects, and direct > (memory-mapped) access to 16 MiB per chip. Larger flash chips can be > accessed by software-defined SPI transfers. > > The FIU in newer NPCM7xx SoCs is not compatible with the WPCM450 FIU. > > Signed-off-by: Jonathan Neuschäfer <j.neuschaefer@gmx.net> > --- > Reviewed-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org> Best regards, Krzysztof ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH v2 1/3] dt-bindings: spi: Add Nuvoton WPCM450 Flash Interface Unit (FIU) 2022-11-24 19:13 ` [PATCH v2 1/3] dt-bindings: spi: Add Nuvoton WPCM450 Flash Interface Unit (FIU) Jonathan Neuschäfer 2022-11-25 8:33 ` Krzysztof Kozlowski @ 2022-11-25 13:13 ` Mark Brown 2022-11-25 14:33 ` Jonathan Neuschäfer 2022-11-26 22:25 ` Rob Herring 2 siblings, 1 reply; 15+ messages in thread From: Mark Brown @ 2022-11-25 13:13 UTC (permalink / raw) To: Jonathan Neuschäfer Cc: linux-spi, openbmc, Rob Herring, Krzysztof Kozlowski, devicetree, linux-kernel [-- Attachment #1: Type: text/plain, Size: 698 bytes --] On Thu, Nov 24, 2022 at 08:13:58PM +0100, Jonathan Neuschäfer wrote: > The Flash Interface Unit (FIU) is the SPI flash controller in the > Nuvoton WPCM450 BMC SoC. It supports four chip selects, and direct > (memory-mapped) access to 16 MiB per chip. Larger flash chips can be > accessed by software-defined SPI transfers. You didn't send me the cover letter for this series. As documented in submitting-patches.rst please send things to the maintainers for the code you would like to change. The normal kernel workflow is that people apply patches from their inboxes, if they aren't copied they are likely to not see the patch at all and it is much more difficult to apply patches. [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 488 bytes --] ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH v2 1/3] dt-bindings: spi: Add Nuvoton WPCM450 Flash Interface Unit (FIU) 2022-11-25 13:13 ` Mark Brown @ 2022-11-25 14:33 ` Jonathan Neuschäfer 0 siblings, 0 replies; 15+ messages in thread From: Jonathan Neuschäfer @ 2022-11-25 14:33 UTC (permalink / raw) To: Mark Brown Cc: Jonathan Neuschäfer, devicetree, openbmc, linux-kernel, linux-spi, Rob Herring, Krzysztof Kozlowski [-- Attachment #1: Type: text/plain, Size: 1409 bytes --] On Fri, Nov 25, 2022 at 01:13:29PM +0000, Mark Brown wrote: > On Thu, Nov 24, 2022 at 08:13:58PM +0100, Jonathan Neuschäfer wrote: > > The Flash Interface Unit (FIU) is the SPI flash controller in the > > Nuvoton WPCM450 BMC SoC. It supports four chip selects, and direct > > (memory-mapped) access to 16 MiB per chip. Larger flash chips can be > > accessed by software-defined SPI transfers. > > You didn't send me the cover letter for this series. As documented in > submitting-patches.rst please send things to the maintainers for the > code you would like to change. The normal kernel workflow is that > people apply patches from their inboxes, if they aren't copied they are > likely to not see the patch at all and it is much more difficult to > apply patches. Ah, sorry. I wrongly associated you with a different subsystem (I think MFD), which became irrelevant for this iteration of the patchset, rather than SPI. Here's the relevant/new part of the cover letter, for your convenience: Changelog for v2: - Dropped the patches which have been applied in the meantime, leaving only three out of eight - Changed the binding to require both items in the reg property, because there is no need to keep the second item optional, suggested by Krzysztof Kozlowski - Various other cleanups suggested by Krzysztof Kozlowski and the kernel test robot Jonathan [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 833 bytes --] ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH v2 1/3] dt-bindings: spi: Add Nuvoton WPCM450 Flash Interface Unit (FIU) 2022-11-24 19:13 ` [PATCH v2 1/3] dt-bindings: spi: Add Nuvoton WPCM450 Flash Interface Unit (FIU) Jonathan Neuschäfer 2022-11-25 8:33 ` Krzysztof Kozlowski 2022-11-25 13:13 ` Mark Brown @ 2022-11-26 22:25 ` Rob Herring 2022-11-28 11:05 ` Conor Dooley 2 siblings, 1 reply; 15+ messages in thread From: Rob Herring @ 2022-11-26 22:25 UTC (permalink / raw) To: Jonathan Neuschäfer Cc: linux-kernel, openbmc, linux-spi, Mark Brown, Krzysztof Kozlowski, Rob Herring, devicetree On Thu, 24 Nov 2022 20:13:58 +0100, Jonathan Neuschäfer wrote: > The Flash Interface Unit (FIU) is the SPI flash controller in the > Nuvoton WPCM450 BMC SoC. It supports four chip selects, and direct > (memory-mapped) access to 16 MiB per chip. Larger flash chips can be > accessed by software-defined SPI transfers. > > The FIU in newer NPCM7xx SoCs is not compatible with the WPCM450 FIU. > > Signed-off-by: Jonathan Neuschäfer <j.neuschaefer@gmx.net> > --- > > v2: > - A few cleanups suggested by Krzysztof Kozlowski > - Simplify binding by making second reg item mandatory > > v1: > - https://lore.kernel.org/lkml/20221105185911.1547847-4-j.neuschaefer@gmx.net/ > --- > .../bindings/spi/nuvoton,wpcm450-fiu.yaml | 66 +++++++++++++++++++ > 1 file changed, 66 insertions(+) > create mode 100644 Documentation/devicetree/bindings/spi/nuvoton,wpcm450-fiu.yaml > My bot found errors running 'make DT_CHECKER_FLAGS=-m dt_binding_check' on your patch (DT_CHECKER_FLAGS is new in v5.13): yamllint warnings/errors: dtschema/dtc warnings/errors: Documentation/devicetree/bindings/spi/nuvoton,wpcm450-fiu.example.dts:18:18: fatal error: dt-bindings/clock/nuvoton,wpcm450-clk.h: No such file or directory 18 | #include <dt-bindings/clock/nuvoton,wpcm450-clk.h> | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ compilation terminated. make[1]: *** [scripts/Makefile.lib:406: Documentation/devicetree/bindings/spi/nuvoton,wpcm450-fiu.example.dtb] Error 1 make[1]: *** Waiting for unfinished jobs.... make: *** [Makefile:1492: dt_binding_check] Error 2 doc reference errors (make refcheckdocs): See https://patchwork.ozlabs.org/project/devicetree-bindings/patch/20221124191400.287918-2-j.neuschaefer@gmx.net This check can fail if there are any dependencies. The base for a patch series is generally the most recent rc1. If you already ran 'make dt_binding_check' and didn't see the above error(s), then make sure 'yamllint' is installed and dt-schema is up to date: pip3 install dtschema --upgrade Please check and re-submit after running the above command. ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH v2 1/3] dt-bindings: spi: Add Nuvoton WPCM450 Flash Interface Unit (FIU) 2022-11-26 22:25 ` Rob Herring @ 2022-11-28 11:05 ` Conor Dooley 2022-11-28 13:58 ` Jonathan Neuschäfer 0 siblings, 1 reply; 15+ messages in thread From: Conor Dooley @ 2022-11-28 11:05 UTC (permalink / raw) To: Rob Herring Cc: Jonathan Neuschäfer, linux-kernel, openbmc, linux-spi, Mark Brown, Krzysztof Kozlowski, Rob Herring, devicetree On Sat, Nov 26, 2022 at 04:25:36PM -0600, Rob Herring wrote: > > On Thu, 24 Nov 2022 20:13:58 +0100, Jonathan Neuschäfer wrote: > > The Flash Interface Unit (FIU) is the SPI flash controller in the > > Nuvoton WPCM450 BMC SoC. It supports four chip selects, and direct > > (memory-mapped) access to 16 MiB per chip. Larger flash chips can be > > accessed by software-defined SPI transfers. > > > > The FIU in newer NPCM7xx SoCs is not compatible with the WPCM450 FIU. > > > > Signed-off-by: Jonathan Neuschäfer <j.neuschaefer@gmx.net> > > --- > > > > v2: > > - A few cleanups suggested by Krzysztof Kozlowski > > - Simplify binding by making second reg item mandatory > > > > v1: > > - https://lore.kernel.org/lkml/20221105185911.1547847-4-j.neuschaefer@gmx.net/ > > --- > > .../bindings/spi/nuvoton,wpcm450-fiu.yaml | 66 +++++++++++++++++++ > > 1 file changed, 66 insertions(+) > > create mode 100644 Documentation/devicetree/bindings/spi/nuvoton,wpcm450-fiu.yaml > > > > My bot found errors running 'make DT_CHECKER_FLAGS=-m dt_binding_check' > on your patch (DT_CHECKER_FLAGS is new in v5.13): > > yamllint warnings/errors: > > dtschema/dtc warnings/errors: > Documentation/devicetree/bindings/spi/nuvoton,wpcm450-fiu.example.dts:18:18: fatal error: dt-bindings/clock/nuvoton,wpcm450-clk.h: No such file or directory > 18 | #include <dt-bindings/clock/nuvoton,wpcm450-clk.h> > | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ > compilation terminated. > make[1]: *** [scripts/Makefile.lib:406: Documentation/devicetree/bindings/spi/nuvoton,wpcm450-fiu.example.dtb] Error 1 > make[1]: *** Waiting for unfinished jobs.... > make: *** [Makefile:1492: dt_binding_check] Error 2 FWIW this seems to now be in linux-next as dd71cd4dd6c9 ("spi: Add Nuvoton WPCM450 Flash Interface Unit (FIU) bindings") & is breaking dt_binding_check. Thanks, Conor. ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH v2 1/3] dt-bindings: spi: Add Nuvoton WPCM450 Flash Interface Unit (FIU) 2022-11-28 11:05 ` Conor Dooley @ 2022-11-28 13:58 ` Jonathan Neuschäfer 2022-11-28 14:09 ` Conor Dooley 0 siblings, 1 reply; 15+ messages in thread From: Jonathan Neuschäfer @ 2022-11-28 13:58 UTC (permalink / raw) To: Conor Dooley Cc: Rob Herring, Jonathan Neuschäfer, linux-kernel, openbmc, linux-spi, Mark Brown, Krzysztof Kozlowski, Rob Herring, devicetree [-- Attachment #1: Type: text/plain, Size: 1144 bytes --] On Mon, Nov 28, 2022 at 11:05:31AM +0000, Conor Dooley wrote: > On Sat, Nov 26, 2022 at 04:25:36PM -0600, Rob Herring wrote: [...] > > dtschema/dtc warnings/errors: > > Documentation/devicetree/bindings/spi/nuvoton,wpcm450-fiu.example.dts:18:18: fatal error: dt-bindings/clock/nuvoton,wpcm450-clk.h: No such file or directory > > 18 | #include <dt-bindings/clock/nuvoton,wpcm450-clk.h> > > | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ > > compilation terminated. > > make[1]: *** [scripts/Makefile.lib:406: Documentation/devicetree/bindings/spi/nuvoton,wpcm450-fiu.example.dtb] Error 1 > > make[1]: *** Waiting for unfinished jobs.... > > make: *** [Makefile:1492: dt_binding_check] Error 2 > > FWIW this seems to now be in linux-next as dd71cd4dd6c9 ("spi: Add Nuvoton > WPCM450 Flash Interface Unit (FIU) bindings") & is breaking > dt_binding_check. Ah, sorry about that. It should resolve itself once nuvoton,wpcm450-clk binding gets merged, but I don't see a definite timeframe for that, yet. Alternatively, I can send a patch to simplify the example in the FIU binding. Jonathan [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 833 bytes --] ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH v2 1/3] dt-bindings: spi: Add Nuvoton WPCM450 Flash Interface Unit (FIU) 2022-11-28 13:58 ` Jonathan Neuschäfer @ 2022-11-28 14:09 ` Conor Dooley 2022-11-28 17:57 ` Mark Brown 0 siblings, 1 reply; 15+ messages in thread From: Conor Dooley @ 2022-11-28 14:09 UTC (permalink / raw) To: Jonathan Neuschäfer Cc: Rob Herring, linux-kernel, openbmc, linux-spi, Mark Brown, Krzysztof Kozlowski, Rob Herring, devicetree On Mon, Nov 28, 2022 at 02:58:57PM +0100, Jonathan Neuschäfer wrote: > On Mon, Nov 28, 2022 at 11:05:31AM +0000, Conor Dooley wrote: > > On Sat, Nov 26, 2022 at 04:25:36PM -0600, Rob Herring wrote: > [...] > > > dtschema/dtc warnings/errors: > > > Documentation/devicetree/bindings/spi/nuvoton,wpcm450-fiu.example.dts:18:18: fatal error: dt-bindings/clock/nuvoton,wpcm450-clk.h: No such file or directory > > > 18 | #include <dt-bindings/clock/nuvoton,wpcm450-clk.h> > > > | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ > > > compilation terminated. > > > make[1]: *** [scripts/Makefile.lib:406: Documentation/devicetree/bindings/spi/nuvoton,wpcm450-fiu.example.dtb] Error 1 > > > make[1]: *** Waiting for unfinished jobs.... > > > make: *** [Makefile:1492: dt_binding_check] Error 2 > > > > FWIW this seems to now be in linux-next as dd71cd4dd6c9 ("spi: Add Nuvoton > > WPCM450 Flash Interface Unit (FIU) bindings") & is breaking > > dt_binding_check. > > Ah, sorry about that. It should resolve itself once nuvoton,wpcm450-clk > binding gets merged, but I don't see a definite timeframe for that, yet. > > Alternatively, I can send a patch to simplify the example in the FIU > binding. Without being a Responsible Adult^TM for either SPI or DT, my preference would be for simplifying the binding so that if your clk stuff doesn't land for 6.2 the binding checks still work. ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH v2 1/3] dt-bindings: spi: Add Nuvoton WPCM450 Flash Interface Unit (FIU) 2022-11-28 14:09 ` Conor Dooley @ 2022-11-28 17:57 ` Mark Brown 0 siblings, 0 replies; 15+ messages in thread From: Mark Brown @ 2022-11-28 17:57 UTC (permalink / raw) To: Conor Dooley Cc: Jonathan Neuschäfer, Rob Herring, linux-kernel, openbmc, linux-spi, Krzysztof Kozlowski, Rob Herring, devicetree [-- Attachment #1: Type: text/plain, Size: 292 bytes --] On Mon, Nov 28, 2022 at 02:09:37PM +0000, Conor Dooley wrote: > Without being a Responsible Adult^TM for either SPI or DT, my preference > would be for simplifying the binding so that if your clk stuff doesn't > land for 6.2 the binding checks still work. Yes, please simplify the example. [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 488 bytes --] ^ permalink raw reply [flat|nested] 15+ messages in thread
* [PATCH v2 2/3] spi: wpcm-fiu: Add driver for Nuvoton WPCM450 Flash Interface Unit (FIU) 2022-11-24 19:13 [PATCH v2 0/3] Nuvoton WPCM450 FIU SPI flash controller Jonathan Neuschäfer 2022-11-24 19:13 ` [PATCH v2 1/3] dt-bindings: spi: Add Nuvoton WPCM450 Flash Interface Unit (FIU) Jonathan Neuschäfer @ 2022-11-24 19:13 ` Jonathan Neuschäfer 2022-11-25 13:04 ` Mark Brown 2022-11-24 19:14 ` [PATCH v2 3/3] spi: wpcm-fiu: Add direct map support Jonathan Neuschäfer 2 siblings, 1 reply; 15+ messages in thread From: Jonathan Neuschäfer @ 2022-11-24 19:13 UTC (permalink / raw) To: linux-spi, openbmc Cc: Rob Herring, Krzysztof Kozlowski, Jonathan Neuschäfer, devicetree, linux-kernel, Mark Brown The Flash Interface Unit (FIU) is the SPI flash controller in the Nuvoton WPCM450 BMC SoC. It supports four chip selects, and direct (memory-mapped) access to 16 MiB per chip. Larger flash chips can be accessed by software-defined SPI transfers. The FIU in newer NPCM7xx SoCs is not compatible with the WPCM450 FIU. Signed-off-by: Jonathan Neuschäfer <j.neuschaefer@gmx.net> --- v2: - Fix a few nits from the kernel test robot v1: - https://lore.kernel.org/lkml/20221105185911.1547847-8-j.neuschaefer@gmx.net/ --- drivers/spi/Kconfig | 11 + drivers/spi/Makefile | 1 + drivers/spi/spi-wpcm-fiu.c | 444 +++++++++++++++++++++++++++++++++++++ 3 files changed, 456 insertions(+) create mode 100644 drivers/spi/spi-wpcm-fiu.c diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig index d1bb62f7368b7..ee5f9e61cc280 100644 --- a/drivers/spi/Kconfig +++ b/drivers/spi/Kconfig @@ -635,6 +635,17 @@ config SPI_MTK_SNFI is implemented as a SPI-MEM controller with pipelined ECC capcability. +config SPI_WPCM_FIU + tristate "Nuvoton WPCM450 Flash Interface Unit" + depends on ARCH_NPCM || COMPILE_TEST + select REGMAP + help + This enables support got the Flash Interface Unit SPI controller + present in the Nuvoton WPCM450 SoC. + + This driver does not support generic SPI. The implementation only + supports the spi-mem interface. + config SPI_NPCM_FIU tristate "Nuvoton NPCM FLASH Interface Unit" depends on ARCH_NPCM || COMPILE_TEST diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile index 4b34e855c8412..e30196d0a4cf9 100644 --- a/drivers/spi/Makefile +++ b/drivers/spi/Makefile @@ -83,6 +83,7 @@ obj-$(CONFIG_SPI_MTK_NOR) += spi-mtk-nor.o obj-$(CONFIG_SPI_MTK_SNFI) += spi-mtk-snfi.o obj-$(CONFIG_SPI_MXIC) += spi-mxic.o obj-$(CONFIG_SPI_MXS) += spi-mxs.o +obj-$(CONFIG_SPI_WPCM_FIU) += spi-wpcm-fiu.o obj-$(CONFIG_SPI_NPCM_FIU) += spi-npcm-fiu.o obj-$(CONFIG_SPI_NPCM_PSPI) += spi-npcm-pspi.o obj-$(CONFIG_SPI_NXP_FLEXSPI) += spi-nxp-fspi.o diff --git a/drivers/spi/spi-wpcm-fiu.c b/drivers/spi/spi-wpcm-fiu.c new file mode 100644 index 0000000000000..e525fe074f883 --- /dev/null +++ b/drivers/spi/spi-wpcm-fiu.c @@ -0,0 +1,444 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (C) 2022 Jonathan Neuschäfer + +#include <linux/clk.h> +#include <linux/mfd/syscon.h> +#include <linux/module.h> +#include <linux/of_address.h> +#include <linux/of_device.h> +#include <linux/platform_device.h> +#include <linux/regmap.h> +#include <linux/spi/spi-mem.h> + +#define FIU_CFG 0x00 +#define FIU_BURST_BFG 0x01 +#define FIU_RESP_CFG 0x02 +#define FIU_CFBB_PROT 0x03 +#define FIU_FWIN1_LOW 0x04 +#define FIU_FWIN1_HIGH 0x06 +#define FIU_FWIN2_LOW 0x08 +#define FIU_FWIN2_HIGH 0x0a +#define FIU_FWIN3_LOW 0x0c +#define FIU_FWIN3_HIGH 0x0e +#define FIU_PROT_LOCK 0x10 +#define FIU_PROT_CLEAR 0x11 +#define FIU_SPI_FL_CFG 0x14 +#define FIU_UMA_CODE 0x16 +#define FIU_UMA_AB0 0x17 +#define FIU_UMA_AB1 0x18 +#define FIU_UMA_AB2 0x19 +#define FIU_UMA_DB0 0x1a +#define FIU_UMA_DB1 0x1b +#define FIU_UMA_DB2 0x1c +#define FIU_UMA_DB3 0x1d +#define FIU_UMA_CTS 0x1e +#define FIU_UMA_ECTS 0x1f + +#define FIU_BURST_CFG_R16 3 + +#define FIU_UMA_CTS_D_SIZE(x) (x) +#define FIU_UMA_CTS_A_SIZE BIT(3) +#define FIU_UMA_CTS_WR BIT(4) +#define FIU_UMA_CTS_CS(x) ((x) << 5) +#define FIU_UMA_CTS_EXEC_DONE BIT(7) + +#define SHM_FLASH_SIZE 0x02 +#define SHM_FLASH_SIZE_STALL_HOST BIT(6) + +/* + * I observed a typical wait time of 16 iterations for a UMA transfer to + * finish, so this should be a safe limit. + */ +#define UMA_WAIT_ITERATIONS 100 + +struct wpcm_fiu_spi { + struct device *dev; + struct clk *clk; + void __iomem *regs; + struct regmap *shm_regmap; +}; + +static void wpcm_fiu_set_opcode(struct wpcm_fiu_spi *fiu, u8 opcode) +{ + writeb(opcode, fiu->regs + FIU_UMA_CODE); +} + +static void wpcm_fiu_set_addr(struct wpcm_fiu_spi *fiu, u32 addr) +{ + writeb((addr >> 0) & 0xff, fiu->regs + FIU_UMA_AB0); + writeb((addr >> 8) & 0xff, fiu->regs + FIU_UMA_AB1); + writeb((addr >> 16) & 0xff, fiu->regs + FIU_UMA_AB2); +} + +static void wpcm_fiu_set_data(struct wpcm_fiu_spi *fiu, const u8 *data, unsigned int nbytes) +{ + int i; + + for (i = 0; i < nbytes; i++) + writeb(data[i], fiu->regs + FIU_UMA_DB0 + i); +} + +static void wpcm_fiu_get_data(struct wpcm_fiu_spi *fiu, u8 *data, unsigned int nbytes) +{ + int i; + + for (i = 0; i < nbytes; i++) + data[i] = readb(fiu->regs + FIU_UMA_DB0 + i); +} + +/* + * Perform a UMA (User Mode Access) operation, i.e. a software-controlled SPI transfer. + */ +static int wpcm_fiu_do_uma(struct wpcm_fiu_spi *fiu, unsigned int cs, + bool use_addr, bool write, int data_bytes) +{ + int i = 0; + u8 cts = FIU_UMA_CTS_EXEC_DONE | FIU_UMA_CTS_CS(cs); + + if (use_addr) + cts |= FIU_UMA_CTS_A_SIZE; + if (write) + cts |= FIU_UMA_CTS_WR; + cts |= FIU_UMA_CTS_D_SIZE(data_bytes); + + writeb(cts, fiu->regs + FIU_UMA_CTS); + + for (i = 0; i < UMA_WAIT_ITERATIONS; i++) + if (!(readb(fiu->regs + FIU_UMA_CTS) & FIU_UMA_CTS_EXEC_DONE)) + return 0; + + dev_info(fiu->dev, "UMA transfer has not finished in %d iterations\n", UMA_WAIT_ITERATIONS); + return -EIO; +} + +static void wpcm_fiu_ects_assert(struct wpcm_fiu_spi *fiu, unsigned int cs) +{ + u8 ects = readb(fiu->regs + FIU_UMA_ECTS); + + ects &= ~BIT(cs); + writeb(ects, fiu->regs + FIU_UMA_ECTS); +} + +static void wpcm_fiu_ects_deassert(struct wpcm_fiu_spi *fiu, unsigned int cs) +{ + u8 ects = readb(fiu->regs + FIU_UMA_ECTS); + + ects |= BIT(cs); + writeb(ects, fiu->regs + FIU_UMA_ECTS); +} + +struct wpcm_fiu_op_shape { + bool (*match)(const struct spi_mem_op *op); + int (*exec)(struct spi_mem *mem, const struct spi_mem_op *op); +}; + +static bool wpcm_fiu_normal_match(const struct spi_mem_op *op) +{ + // Opcode 0x0b (FAST READ) is treated differently in hardware + if (op->cmd.opcode == 0x0b) + return false; + + return (op->addr.nbytes == 0 || op->addr.nbytes == 3) && + op->dummy.nbytes == 0 && op->data.nbytes <= 4; +} + +static int wpcm_fiu_normal_exec(struct spi_mem *mem, const struct spi_mem_op *op) +{ + struct wpcm_fiu_spi *fiu = spi_controller_get_devdata(mem->spi->controller); + int ret; + + wpcm_fiu_set_opcode(fiu, op->cmd.opcode); + wpcm_fiu_set_addr(fiu, op->addr.val); + if (op->data.dir == SPI_MEM_DATA_OUT) + wpcm_fiu_set_data(fiu, op->data.buf.out, op->data.nbytes); + + ret = wpcm_fiu_do_uma(fiu, mem->spi->chip_select, op->addr.nbytes == 3, + op->data.dir == SPI_MEM_DATA_OUT, op->data.nbytes); + + if (op->data.dir == SPI_MEM_DATA_IN) + wpcm_fiu_get_data(fiu, op->data.buf.in, op->data.nbytes); + + return ret; +} + +static bool wpcm_fiu_fast_read_match(const struct spi_mem_op *op) +{ + return op->cmd.opcode == 0x0b && op->addr.nbytes == 3 && + op->dummy.nbytes == 1 && + op->data.nbytes >= 1 && op->data.nbytes <= 4 && + op->data.dir == SPI_MEM_DATA_IN; +} + +static int wpcm_fiu_fast_read_exec(struct spi_mem *mem, const struct spi_mem_op *op) +{ + return -EINVAL; +} + +/* + * 4-byte addressing. + * + * Flash view: [ C A A A A D D D D] + * bytes: 13 aa bb cc dd -> 5a a5 f0 0f + * FIU's view: [ C A A A][ C D D D D] + * FIU mode: [ read/write][ read ] + */ +static bool wpcm_fiu_4ba_match(const struct spi_mem_op *op) +{ + return op->addr.nbytes == 4 && op->dummy.nbytes == 0 && op->data.nbytes <= 4; +} + +static int wpcm_fiu_4ba_exec(struct spi_mem *mem, const struct spi_mem_op *op) +{ + struct wpcm_fiu_spi *fiu = spi_controller_get_devdata(mem->spi->controller); + int cs = mem->spi->chip_select; + + wpcm_fiu_ects_assert(fiu, cs); + + wpcm_fiu_set_opcode(fiu, op->cmd.opcode); + wpcm_fiu_set_addr(fiu, op->addr.val >> 8); + wpcm_fiu_do_uma(fiu, cs, true, false, 0); + + wpcm_fiu_set_opcode(fiu, op->addr.val & 0xff); + wpcm_fiu_set_addr(fiu, 0); + if (op->data.dir == SPI_MEM_DATA_OUT) + wpcm_fiu_set_data(fiu, op->data.buf.out, op->data.nbytes); + wpcm_fiu_do_uma(fiu, cs, false, op->data.dir == SPI_MEM_DATA_OUT, op->data.nbytes); + + wpcm_fiu_ects_deassert(fiu, cs); + + if (op->data.dir == SPI_MEM_DATA_IN) + wpcm_fiu_get_data(fiu, op->data.buf.in, op->data.nbytes); + + return 0; +} + +/* + * RDID (Read Identification) needs special handling because Linux expects to + * be able to read 6 ID bytes and FIU can only read up to 4 at once. + * + * We're lucky in this case, because executing the RDID instruction twice will + * result in the same result. + * + * What we do is as follows (C: write command/opcode byte, D: read data byte, + * A: write address byte): + * + * 1. C D D D + * 2. C A A A D D D + */ +static bool wpcm_fiu_rdid_match(const struct spi_mem_op *op) +{ + return op->cmd.opcode == 0x9f && op->addr.nbytes == 0 && + op->dummy.nbytes == 0 && op->data.nbytes == 6 && + op->data.dir == SPI_MEM_DATA_IN; +} + +static int wpcm_fiu_rdid_exec(struct spi_mem *mem, const struct spi_mem_op *op) +{ + struct wpcm_fiu_spi *fiu = spi_controller_get_devdata(mem->spi->controller); + int cs = mem->spi->chip_select; + + /* First transfer */ + wpcm_fiu_set_opcode(fiu, op->cmd.opcode); + wpcm_fiu_set_addr(fiu, 0); + wpcm_fiu_do_uma(fiu, cs, false, false, 3); + wpcm_fiu_get_data(fiu, op->data.buf.in, 3); + + /* Second transfer */ + wpcm_fiu_set_opcode(fiu, op->cmd.opcode); + wpcm_fiu_set_addr(fiu, 0); + wpcm_fiu_do_uma(fiu, cs, true, false, 3); + wpcm_fiu_get_data(fiu, op->data.buf.in + 3, 3); + + return 0; +} + +/* + * With some dummy bytes. + * + * C A A A X* X D D D D + * [C A A A D*][C D D D D] + */ +static bool wpcm_fiu_dummy_match(const struct spi_mem_op *op) +{ + // Opcode 0x0b (FAST READ) is treated differently in hardware + if (op->cmd.opcode == 0x0b) + return false; + + return (op->addr.nbytes == 0 || op->addr.nbytes == 3) && + op->dummy.nbytes >= 1 && op->dummy.nbytes <= 5 && + op->data.nbytes <= 4; +} + +static int wpcm_fiu_dummy_exec(struct spi_mem *mem, const struct spi_mem_op *op) +{ + struct wpcm_fiu_spi *fiu = spi_controller_get_devdata(mem->spi->controller); + int cs = mem->spi->chip_select; + + wpcm_fiu_ects_assert(fiu, cs); + + /* First transfer */ + wpcm_fiu_set_opcode(fiu, op->cmd.opcode); + wpcm_fiu_set_addr(fiu, op->addr.val); + wpcm_fiu_do_uma(fiu, cs, op->addr.nbytes != 0, true, op->dummy.nbytes - 1); + + /* Second transfer */ + wpcm_fiu_set_opcode(fiu, 0); + wpcm_fiu_set_addr(fiu, 0); + wpcm_fiu_do_uma(fiu, cs, false, false, op->data.nbytes); + wpcm_fiu_get_data(fiu, op->data.buf.in, op->data.nbytes); + + wpcm_fiu_ects_deassert(fiu, cs); + + return 0; +} + +static const struct wpcm_fiu_op_shape wpcm_fiu_op_shapes[] = { + { .match = wpcm_fiu_normal_match, .exec = wpcm_fiu_normal_exec }, + { .match = wpcm_fiu_fast_read_match, .exec = wpcm_fiu_fast_read_exec }, + { .match = wpcm_fiu_4ba_match, .exec = wpcm_fiu_4ba_exec }, + { .match = wpcm_fiu_rdid_match, .exec = wpcm_fiu_rdid_exec }, + { .match = wpcm_fiu_dummy_match, .exec = wpcm_fiu_dummy_exec }, +}; + +static const struct wpcm_fiu_op_shape *wpcm_fiu_find_op_shape(const struct spi_mem_op *op) +{ + size_t i; + + for (i = 0; i < ARRAY_SIZE(wpcm_fiu_op_shapes); i++) { + const struct wpcm_fiu_op_shape *shape = &wpcm_fiu_op_shapes[i]; + + if (shape->match(op)) + return shape; + } + + return NULL; +} + +static bool wpcm_fiu_supports_op(struct spi_mem *mem, const struct spi_mem_op *op) +{ + if (!spi_mem_default_supports_op(mem, op)) + return false; + + if (op->cmd.dtr || op->addr.dtr || op->dummy.dtr || op->data.dtr) + return false; + + if (op->cmd.buswidth > 1 || op->addr.buswidth > 1 || + op->dummy.buswidth > 1 || op->data.buswidth > 1) + return false; + + return wpcm_fiu_find_op_shape(op) != NULL; +} + +/* + * In order to ensure the integrity of SPI transfers performed via UMA, + * temporarily disable (stall) memory accesses coming from the host CPU. + */ +static void wpcm_fiu_stall_host(struct wpcm_fiu_spi *fiu, bool stall) +{ + if (fiu->shm_regmap) { + int res = regmap_update_bits(fiu->shm_regmap, SHM_FLASH_SIZE, + SHM_FLASH_SIZE_STALL_HOST, + stall ? SHM_FLASH_SIZE_STALL_HOST : 0); + if (res) + dev_warn(fiu->dev, "Failed to (un)stall host memory accesses: %d\n", res); + } +} + +static int wpcm_fiu_exec_op(struct spi_mem *mem, const struct spi_mem_op *op) +{ + struct wpcm_fiu_spi *fiu = spi_controller_get_devdata(mem->spi->controller); + const struct wpcm_fiu_op_shape *shape = wpcm_fiu_find_op_shape(op); + + wpcm_fiu_stall_host(fiu, true); + + if (shape) + return shape->exec(mem, op); + + wpcm_fiu_stall_host(fiu, false); + + return -ENOTSUPP; +} + +static int wpcm_fiu_adjust_op_size(struct spi_mem *mem, struct spi_mem_op *op) +{ + if (op->data.nbytes > 4) + op->data.nbytes = 4; + + return 0; +} + +static const struct spi_controller_mem_ops wpcm_fiu_mem_ops = { + .adjust_op_size = wpcm_fiu_adjust_op_size, + .supports_op = wpcm_fiu_supports_op, + .exec_op = wpcm_fiu_exec_op, +}; + +static void wpcm_fiu_hw_init(struct wpcm_fiu_spi *fiu) +{ + /* Deassert all manually asserted chip selects */ + writeb(0x0f, fiu->regs + FIU_UMA_ECTS); +} + +static int wpcm_fiu_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct spi_controller *ctrl; + struct wpcm_fiu_spi *fiu; + struct resource *res; + + ctrl = devm_spi_alloc_master(dev, sizeof(*fiu)); + if (!ctrl) + return -ENOMEM; + + fiu = spi_controller_get_devdata(ctrl); + fiu->dev = dev; + + res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "control"); + fiu->regs = devm_ioremap_resource(dev, res); + if (IS_ERR(fiu->regs)) { + dev_err(dev, "Failed to map registers\n"); + return PTR_ERR(fiu->regs); + } + + fiu->clk = devm_clk_get_enabled(dev, NULL); + if (IS_ERR(fiu->clk)) + return PTR_ERR(fiu->clk); + + fiu->shm_regmap = syscon_regmap_lookup_by_phandle_optional(dev->of_node, "nuvoton,shm"); + + wpcm_fiu_hw_init(fiu); + + ctrl->bus_num = -1; + ctrl->mem_ops = &wpcm_fiu_mem_ops; + ctrl->num_chipselect = 4; + ctrl->dev.of_node = dev->of_node; + + /* + * The FIU doesn't include a clock divider, the clock is entirely + * determined by the AHB3 bus clock. + */ + ctrl->min_speed_hz = clk_get_rate(fiu->clk); + ctrl->max_speed_hz = clk_get_rate(fiu->clk); + + return devm_spi_register_controller(dev, ctrl); +} + +static const struct of_device_id wpcm_fiu_dt_ids[] = { + { .compatible = "nuvoton,wpcm450-fiu", }, + { } +}; +MODULE_DEVICE_TABLE(of, wpcm_fiu_dt_ids); + +static struct platform_driver wpcm_fiu_driver = { + .driver = { + .name = "wpcm450-fiu", + .bus = &platform_bus_type, + .of_match_table = wpcm_fiu_dt_ids, + }, + .probe = wpcm_fiu_probe, +}; +module_platform_driver(wpcm_fiu_driver); + +MODULE_DESCRIPTION("Nuvoton WPCM450 FIU SPI controller driver"); +MODULE_AUTHOR("Jonathan Neuschäfer <j.neuschaefer@gmx.net>"); +MODULE_LICENSE("GPL"); -- 2.35.1 ^ permalink raw reply related [flat|nested] 15+ messages in thread
* Re: [PATCH v2 2/3] spi: wpcm-fiu: Add driver for Nuvoton WPCM450 Flash Interface Unit (FIU) 2022-11-24 19:13 ` [PATCH v2 2/3] spi: wpcm-fiu: Add driver for " Jonathan Neuschäfer @ 2022-11-25 13:04 ` Mark Brown 2022-11-25 16:33 ` Jonathan Neuschäfer 0 siblings, 1 reply; 15+ messages in thread From: Mark Brown @ 2022-11-25 13:04 UTC (permalink / raw) To: Jonathan Neuschäfer Cc: linux-spi, openbmc, Rob Herring, Krzysztof Kozlowski, devicetree, linux-kernel [-- Attachment #1: Type: text/plain, Size: 1913 bytes --] On Thu, Nov 24, 2022 at 08:13:59PM +0100, Jonathan Neuschäfer wrote: > The Flash Interface Unit (FIU) is the SPI flash controller in the > Nuvoton WPCM450 BMC SoC. It supports four chip selects, and direct > (memory-mapped) access to 16 MiB per chip. Larger flash chips can be > accessed by software-defined SPI transfers. Those software defined SPI transfers seem to be most of the way to supporting normal SPI controller operations, they just need wiring up. That would both support people hooking other SPI chips up to the board and might help support future flash stuff without needing custom code in the driver like you've got now. > +static int wpcm_fiu_do_uma(struct wpcm_fiu_spi *fiu, unsigned int cs, > + bool use_addr, bool write, int data_bytes) > +{ This appears to only support half duplex access but the driver doesn't flag itself as SPI_CONTROLLER_HALF_DUPLEX. > + cts |= FIU_UMA_CTS_D_SIZE(data_bytes); I'm guessing there's a limit on data_bytes that should be enforced. The driver should probably also flag a max transfer size, though that might cause issues if the limit is different between spi-mem and regular transfers. > +/* > + * RDID (Read Identification) needs special handling because Linux expects to > + * be able to read 6 ID bytes and FIU can only read up to 4 at once. > + * > + * We're lucky in this case, because executing the RDID instruction twice will > + * result in the same result. > + * > + * What we do is as follows (C: write command/opcode byte, D: read data byte, > + * A: write address byte): > + * > + * 1. C D D D > + * 2. C A A A D D D > + */ If the driver were implementing regular SPI operations and advertising a maximum transfer length this should just work without having to jump through hoops. The core can split transfers up into sections that fit within the controller limits transparently. [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 488 bytes --] ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH v2 2/3] spi: wpcm-fiu: Add driver for Nuvoton WPCM450 Flash Interface Unit (FIU) 2022-11-25 13:04 ` Mark Brown @ 2022-11-25 16:33 ` Jonathan Neuschäfer 2022-11-25 16:48 ` Mark Brown 0 siblings, 1 reply; 15+ messages in thread From: Jonathan Neuschäfer @ 2022-11-25 16:33 UTC (permalink / raw) To: Mark Brown Cc: Jonathan Neuschäfer, linux-spi, openbmc, Rob Herring, Krzysztof Kozlowski, devicetree, linux-kernel [-- Attachment #1: Type: text/plain, Size: 3112 bytes --] Hello, On Fri, Nov 25, 2022 at 01:04:54PM +0000, Mark Brown wrote: > On Thu, Nov 24, 2022 at 08:13:59PM +0100, Jonathan Neuschäfer wrote: > > > The Flash Interface Unit (FIU) is the SPI flash controller in the > > Nuvoton WPCM450 BMC SoC. It supports four chip selects, and direct > > (memory-mapped) access to 16 MiB per chip. Larger flash chips can be > > accessed by software-defined SPI transfers. > > Those software defined SPI transfers seem to be most of the way to > supporting normal SPI controller operations, they just need wiring up. > That would both support people hooking other SPI chips up to the board > and might help support future flash stuff without needing custom code in > the driver like you've got now. I'm not so sure. The hardware mechanism allowing "software defined" SPI transfers is strongly oriented towards SPI flash, and it already felt like a stretch to implement all the features that Linux expects of a SPI MEM controller. As to connecting non-memory chips: There is also a second, completely different SPI controller in this SoC, which is used on some boards (in factory configuration) to drive a little status LCD. I think it would be easiest to use that one for custom hardware extensions. > > > +static int wpcm_fiu_do_uma(struct wpcm_fiu_spi *fiu, unsigned int cs, > > + bool use_addr, bool write, int data_bytes) > > +{ > > This appears to only support half duplex access but the driver doesn't > flag itself as SPI_CONTROLLER_HALF_DUPLEX. Ok, I'll add it. > > > + cts |= FIU_UMA_CTS_D_SIZE(data_bytes); > > I'm guessing there's a limit on data_bytes that should be enforced. The > driver should probably also flag a max transfer size, though that might > cause issues if the limit is different between spi-mem and regular > transfers. For the existing spi-mem case, the transfer size is limited through wpcm_fiu_adjust_op_size. I *think* this is enough, but please correct me if I'm wrong. > > +/* > > + * RDID (Read Identification) needs special handling because Linux expects to > > + * be able to read 6 ID bytes and FIU can only read up to 4 at once. > > + * > > + * We're lucky in this case, because executing the RDID instruction twice will > > + * result in the same result. > > + * > > + * What we do is as follows (C: write command/opcode byte, D: read data byte, > > + * A: write address byte): > > + * > > + * 1. C D D D > > + * 2. C A A A D D D > > + */ > > If the driver were implementing regular SPI operations and advertising > a maximum transfer length this should just work without having to jump > through hoops. The core can split transfers up into sections that fit > within the controller limits transparently. As far as I'm aware, the controller is not capable of performing a pure read transfer, because the command byte (a byte that is written, in half-duplex) is always included at the start. I think this limitation would break your idea. IOW, the hoops aren't nice, but I think they're necessary. Thanks for your review, Jonathan [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 833 bytes --] ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH v2 2/3] spi: wpcm-fiu: Add driver for Nuvoton WPCM450 Flash Interface Unit (FIU) 2022-11-25 16:33 ` Jonathan Neuschäfer @ 2022-11-25 16:48 ` Mark Brown 0 siblings, 0 replies; 15+ messages in thread From: Mark Brown @ 2022-11-25 16:48 UTC (permalink / raw) To: Jonathan Neuschäfer Cc: linux-spi, openbmc, Rob Herring, Krzysztof Kozlowski, devicetree, linux-kernel [-- Attachment #1: Type: text/plain, Size: 1168 bytes --] On Fri, Nov 25, 2022 at 05:33:31PM +0100, Jonathan Neuschäfer wrote: > As to connecting non-memory chips: There is also a second, completely > different SPI controller in this SoC, which is used on some boards (in > factory configuration) to drive a little status LCD. I think it would be > easiest to use that one for custom hardware extensions. That's never stopped hardware engineers. Perhaps it's simpler for pinmuxing, layout or other reasons in a given design. > > If the driver were implementing regular SPI operations and advertising > > a maximum transfer length this should just work without having to jump > > through hoops. The core can split transfers up into sections that fit > > within the controller limits transparently. > As far as I'm aware, the controller is not capable of performing a pure > read transfer, because the command byte (a byte that is written, in > half-duplex) is always included at the start. I think this limitation > would break your idea. > IOW, the hoops aren't nice, but I think they're necessary. Ah, I see. That is very limiting. I'm very surprised that the 6 byte thing works at all TBH. [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 488 bytes --] ^ permalink raw reply [flat|nested] 15+ messages in thread
* [PATCH v2 3/3] spi: wpcm-fiu: Add direct map support 2022-11-24 19:13 [PATCH v2 0/3] Nuvoton WPCM450 FIU SPI flash controller Jonathan Neuschäfer 2022-11-24 19:13 ` [PATCH v2 1/3] dt-bindings: spi: Add Nuvoton WPCM450 Flash Interface Unit (FIU) Jonathan Neuschäfer 2022-11-24 19:13 ` [PATCH v2 2/3] spi: wpcm-fiu: Add driver for " Jonathan Neuschäfer @ 2022-11-24 19:14 ` Jonathan Neuschäfer 2 siblings, 0 replies; 15+ messages in thread From: Jonathan Neuschäfer @ 2022-11-24 19:14 UTC (permalink / raw) To: linux-spi, openbmc Cc: Rob Herring, Krzysztof Kozlowski, Jonathan Neuschäfer, devicetree, linux-kernel, Mark Brown Besides software controlled SPI transfers (UMA, "user mode access"), FIU also supports a 16 MiB mapping window per attached flash chip. This patch implements direct mapped read access, to speed up flash reads. Without direct mapping: # time dd if=/dev/mtd0ro of=dump bs=1M 16+0 records in 16+0 records out real 1m 47.74s user 0m 0.00s sys 1m 47.75s With direct mapping: # time dd if=/dev/mtd0ro of=dump bs=1M 16+0 records in 16+0 records out real 0m 30.81s user 0m 0.00s sys 0m 30.81s Signed-off-by: Jonathan Neuschäfer <j.neuschaefer@gmx.net> --- v2: - Fix a few nits from the kernel test robot - Fix check for fiu->memory mapping error v1: - https://lore.kernel.org/lkml/20221105185911.1547847-9-j.neuschaefer@gmx.net/ --- drivers/spi/spi-wpcm-fiu.c | 64 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/drivers/spi/spi-wpcm-fiu.c b/drivers/spi/spi-wpcm-fiu.c index e525fe074f883..ab33710d50ac8 100644 --- a/drivers/spi/spi-wpcm-fiu.c +++ b/drivers/spi/spi-wpcm-fiu.c @@ -51,10 +51,16 @@ */ #define UMA_WAIT_ITERATIONS 100 +/* The memory-mapped view of flash is 16 MiB long */ +#define MAX_MEMORY_SIZE_PER_CS (16 << 20) +#define MAX_MEMORY_SIZE_TOTAL (4 * MAX_MEMORY_SIZE_PER_CS) + struct wpcm_fiu_spi { struct device *dev; struct clk *clk; void __iomem *regs; + void __iomem *memory; + size_t memory_size; struct regmap *shm_regmap; }; @@ -367,14 +373,64 @@ static int wpcm_fiu_adjust_op_size(struct spi_mem *mem, struct spi_mem_op *op) return 0; } +static int wpcm_fiu_dirmap_create(struct spi_mem_dirmap_desc *desc) +{ + struct wpcm_fiu_spi *fiu = spi_controller_get_devdata(desc->mem->spi->controller); + int cs = desc->mem->spi->chip_select; + + if (desc->info.op_tmpl.data.dir != SPI_MEM_DATA_IN) + return -ENOTSUPP; + + /* + * Unfortunately, FIU only supports a 16 MiB direct mapping window (per + * attached flash chip), but the SPI MEM core doesn't support partial + * direct mappings. This means that we can't support direct mapping on + * flashes that are bigger than 16 MiB. + */ + if (desc->info.offset + desc->info.length > MAX_MEMORY_SIZE_PER_CS) + return -ENOTSUPP; + + /* Don't read past the memory window */ + if (cs * MAX_MEMORY_SIZE_PER_CS + desc->info.offset + desc->info.length > fiu->memory_size) + return -ENOTSUPP; + + return 0; +} + +static ssize_t wpcm_fiu_direct_read(struct spi_mem_dirmap_desc *desc, u64 offs, size_t len, void *buf) +{ + struct wpcm_fiu_spi *fiu = spi_controller_get_devdata(desc->mem->spi->controller); + int cs = desc->mem->spi->chip_select; + + if (offs >= MAX_MEMORY_SIZE_PER_CS) + return -ENOTSUPP; + + offs += cs * MAX_MEMORY_SIZE_PER_CS; + + if (!fiu->memory || offs >= fiu->memory_size) + return -ENOTSUPP; + + len = min_t(size_t, len, fiu->memory_size - offs); + memcpy_fromio(buf, fiu->memory + offs, len); + + return len; +} + static const struct spi_controller_mem_ops wpcm_fiu_mem_ops = { .adjust_op_size = wpcm_fiu_adjust_op_size, .supports_op = wpcm_fiu_supports_op, .exec_op = wpcm_fiu_exec_op, + .dirmap_create = wpcm_fiu_dirmap_create, + .dirmap_read = wpcm_fiu_direct_read, }; static void wpcm_fiu_hw_init(struct wpcm_fiu_spi *fiu) { + /* Configure memory-mapped flash access */ + writeb(FIU_BURST_CFG_R16, fiu->regs + FIU_BURST_BFG); + writeb(MAX_MEMORY_SIZE_TOTAL / (512 << 10), fiu->regs + FIU_CFG); + writeb(MAX_MEMORY_SIZE_PER_CS / (512 << 10) | BIT(6), fiu->regs + FIU_SPI_FL_CFG); + /* Deassert all manually asserted chip selects */ writeb(0x0f, fiu->regs + FIU_UMA_ECTS); } @@ -404,6 +460,14 @@ static int wpcm_fiu_probe(struct platform_device *pdev) if (IS_ERR(fiu->clk)) return PTR_ERR(fiu->clk); + res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "memory"); + fiu->memory = devm_ioremap_resource(dev, res); + fiu->memory_size = min_t(size_t, resource_size(res), MAX_MEMORY_SIZE_TOTAL); + if (IS_ERR(fiu->memory)) { + dev_err(dev, "Failed to map flash memory window\n"); + return PTR_ERR(fiu->memory); + } + fiu->shm_regmap = syscon_regmap_lookup_by_phandle_optional(dev->of_node, "nuvoton,shm"); wpcm_fiu_hw_init(fiu); -- 2.35.1 ^ permalink raw reply related [flat|nested] 15+ messages in thread
end of thread, other threads:[~2022-11-28 18:15 UTC | newest] Thread overview: 15+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2022-11-24 19:13 [PATCH v2 0/3] Nuvoton WPCM450 FIU SPI flash controller Jonathan Neuschäfer 2022-11-24 19:13 ` [PATCH v2 1/3] dt-bindings: spi: Add Nuvoton WPCM450 Flash Interface Unit (FIU) Jonathan Neuschäfer 2022-11-25 8:33 ` Krzysztof Kozlowski 2022-11-25 13:13 ` Mark Brown 2022-11-25 14:33 ` Jonathan Neuschäfer 2022-11-26 22:25 ` Rob Herring 2022-11-28 11:05 ` Conor Dooley 2022-11-28 13:58 ` Jonathan Neuschäfer 2022-11-28 14:09 ` Conor Dooley 2022-11-28 17:57 ` Mark Brown 2022-11-24 19:13 ` [PATCH v2 2/3] spi: wpcm-fiu: Add driver for " Jonathan Neuschäfer 2022-11-25 13:04 ` Mark Brown 2022-11-25 16:33 ` Jonathan Neuschäfer 2022-11-25 16:48 ` Mark Brown 2022-11-24 19:14 ` [PATCH v2 3/3] spi: wpcm-fiu: Add direct map support Jonathan Neuschäfer
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).