Add io{read|write}64 to io-64-atomic headers
Subsystems (9)
Logan Gunthorpe
maintainerv12 cover Add io{read|write}64 to io-64-atomic headers
This is v12 of my cleanup series to push a number of instances of people defining their own io{read|write}64 functions into common headers seing they don't exist in non-64bit systems. This series adds inline functions to the io-64-nonatomic headers and then cleans up the drivers that defined their own copies.
This cleanup was originally requested by Greg after he reviewed my Switchtec NTB code. And I hope someone can pick it up or at least give feedback on it soon as it's been around relatively unchanged for a few cycles now and I'm getting a bit tired of resubmitting it with little to no interest.
Thanks,
Logan
--
Changes since v11:
- Rebased onto v4.16-rc5
- Added a patch (0001) to fix some old and new sparse warnings that the kbuild robot warned about this cycle. The latest version of sparse was required to reproduce these.
- Added a patch (0002) to add io{read|write}64 to parisc which the kbuild robot also found errors for this cycle
Changes since v10:
- Rebased onto v4.16-rc4, this droped the drm/tilcdc patch which was picked up by that tree and is already in 4.16.
Changes since v9:
- Rebased onto v4.15-rc6
- Fixed a couple of issues in the new version of the CAAM patch as pointed out by Horia
Changes since v8:
- Rebased onto v4.15-rc2, as a result rewrote patch 7 seeing someone did some similar cleanup in that area.
- Added a patch to clean up the Switchtec NTB driver which landed in v4.15-rc1
Changes since v7:
- Fix minor nits from Andy Shevchenko
- Rebased onto v4.14-rc1
Changes since v6:
** none **
Changes since v5:
- Added a fix to the tilcdc driver to ensure it doesn't use the non-atomic operation. (This includes adding io{read|write}64[be]_is_nonatomic defines).
Changes since v4:
- Add functions so the powerpc implementation of iomap.c compiles. (As noticed by Horia)
Changes since v3:
- I noticed powerpc didn't use the appropriate functions seeing readq/writeq were not defined when iomap.h was included. Thus I've included a patch to adjust this
- Fixed some mistakes with a couple of the defines in io-64-nonatomic* headers
- Fixed a typo noticed by Horia.
(earlier versions were drastically different)
--
Logan Gunthorpe (9):
iomap: Fix sparse endian check warnings
parisc: iomap: introduce io{read|write}64
powerpc: io.h: move iomap.h include so that it can use readq/writeq
defs
powerpc: iomap.c: introduce io{read|write}64_{lo_hi|hi_lo}
iomap: introduce io{read|write}64_{lo_hi|hi_lo}
io-64-nonatomic: add io{read|write}64[be]{_lo_hi|_hi_lo} macros
ntb: ntb_hw_intel: use io-64-nonatomic instead of in-driver hacks
crypto: caam: cleanup CONFIG_64BIT ifdefs when using io{read|write}64
ntb: ntb_hw_switchtec: Cleanup 64bit IO defines to use the common
header
arch/parisc/include/asm/io.h | 9 +++ arch/parisc/lib/iomap.c | 64 +++++++++++++++ arch/powerpc/include/asm/io.h | 6 +- arch/powerpc/kernel/iomap.c | 40 +++++++++ drivers/crypto/caam/regs.h | 30 +------ drivers/ntb/hw/intel/ntb_hw_intel.c | 30 +------ drivers/ntb/hw/mscc/ntb_hw_switchtec.c | 36 +-------- include/asm-generic/iomap.h | 26 ++++-- include/linux/io-64-nonatomic-hi-lo.h | 64 +++++++++++++++ include/linux/io-64-nonatomic-lo-hi.h | 64 +++++++++++++++ lib/iomap.c | 143 ++++++++++++++++++++++++++++++++- 11 files changed, 412 insertions(+), 100 deletions(-)
--
2.11.0
Logan Gunthorpe
maintainerPATCH v12 1/9 iomap: Fix sparse endian check warnings
Warnings of the form:
lib/iomap.c:84:9: warning: cast to restricted __be16
Are found when running sparse checker with:
make C=2 CF=-D__CHECK_ENDIAN__
This patch casts them with __force to suppress the warnings.
Also, it looks like the wrong conversion function was used in the mmio_writeXXbe macros: 'val' is a cpu value to be written to a big endian register. Therefore cpu_to_beXX should have been used instead of beXX_to_cpu. Both are equivalent, functionally, but have different meanings. So there was no real bug just confusion for people reading the code and the sparse endian check.
--- lib/iomap.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-)
lib/iomap.c +6 -4
@@ -65,8 +65,8 @@ static void bad_io_access(unsigned long port, const char *access)#endif #ifndef mmio_read16be -#define mmio_read16be (addr) be16_to_cpu(__raw_readw(addr)) -#define mmio_read32be (addr) be32_to_cpu(__raw_readl(addr)) +#define mmio_read16be (addr) be16_to_cpu((__be16 __force)__raw_readw(addr)) +#define mmio_read32be (addr) be32_to_cpu((__be32 __force)__raw_readl(addr))#endif unsigned int ioread8 (void __iomem *addr)
@@ -106,8 +106,10 @@ EXPORT_SYMBOL(ioread32be);#endif #ifndef mmio_write16be -#define mmio_write16be (val,port) __raw_writew(be16_to_cpu(val),port) -#define mmio_write32be (val,port) __raw_writel(be32_to_cpu(val),port) +#define mmio_write16be (val, port) \ + __raw_writew((u16 __force)cpu_to_be16(val), port) +#define mmio_write32be (val, port) \ + __raw_writel((u32 __force)cpu_to_be32(val), port)#endif void iowrite8 (u8 val,void __iomem *addr)
Signature · 1 line
2.11.0
Re: [PATCH v12 1/9] iomap: Fix sparse endian check warnings
Quoted 9 lines · Logan Gunthorpe
Warnings of the form:
lib/iomap.c:84:9: warning: cast to restricted__be16Are found when running sparse checker with:
make C=2 CF=-D__CHECK_ENDIAN__
This patch casts them with
__forceto suppress the warnings.
Hi,
it looks correct but if you should explain why the warning is not a valid one. Once done, you can then explain what problem you have fixed instead of saying you suppressed a warning.
Quoted 1 line
Also, it looks like the wrong conversion function was used in
I would suggest to split the patch in two since it does two different things which should have their own explanation.
Quoted 5 lines
lib/iomap.c +0
-0
lib/iomap.c EXPORT_SYMBOL(ioread32be); · line 113
Quoted 10 lines
lib/iomap.c +4
-2@@ -106,8 +106,10 @@ EXPORT_SYMBOL(ioread32be);#endif #ifndef mmio_write16be -#define mmio_write16be (val,port) __raw_writew(be16_to_cpu(val),port) -#define mmio_write32be (val,port) __raw_writel(be32_to_cpu(val),port) +#define mmio_write16be (val, port) \ + __raw_writew((u16 __force)cpu_to_be16(val), port) +#define mmio_write32be (val, port) \ + __raw_writel((u32 __force)cpu_to_be32(val), port)#endif
I think that in this sort of replacement, it's better to not split the lines (even if larger than 80, that's it).
-- Luc Van Oostenryck
Logan Gunthorpe
maintainerRe: [PATCH v12 1/9] iomap: Fix sparse endian check warnings
Hi Luc,
Thanks for the feedback. I'll try to address your points in a v13 shortly.
Logan
Quoted 30 lines · Luc Van Oostenryck
it looks correct but if you should explain why the warning is not a valid one. Once done, you can then explain what problem you have fixed instead of saying you suppressed a warning.
Quoted 1 line
Also, it looks like the wrong conversion function was used in
I would suggest to split the patch in two since it does two different things which should have their own explanation.
Quoted 5 lines
lib/iomap.c +0
-0lib/iomap.c EXPORT_SYMBOL(ioread32be); · line 113
Quoted 10 lines
lib/iomap.c +4
-2@@ -106,8 +106,10 @@ EXPORT_SYMBOL(ioread32be);#endif #ifndef mmio_write16be -#define mmio_write16be (val,port) __raw_writew(be16_to_cpu(val),port) -#define mmio_write32be (val,port) __raw_writel(be32_to_cpu(val),port) +#define mmio_write16be (val, port) \ + __raw_writew((u16 __force)cpu_to_be16(val), port) +#define mmio_write32be (val, port) \ + __raw_writel((u32 __force)cpu_to_be32(val), port)#endif I think that in this sort of replacement, it's better to not split the lines (even if larger than 80, that's it).
-- Luc Van Oostenryck
Logan Gunthorpe
maintainerPATCH v12 2/9 parisc: iomap: introduce io{read|write}64
In reply to Logan GunthorpeAdd support for io{read|write}64() functions in parisc architecture. These are pretty straightforward copies of similar functions which make use of readq and writeq.
Also, indicate that the lo_hi and hi_lo variants of these functions are not provided by this architecture.
--- arch/parisc/include/asm/io.h | 9 +++++++ arch/parisc/lib/iomap.c | 64 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 73 insertions(+)
arch/parisc/include/asm/io.h +9 -0
@@ -311,6 +311,15 @@ extern void outsl (unsigned long port, const void *src, unsigned long count);* value for either 32 or 64 bit mode */ #define F_EXTEND (x) ((unsigned long)((x) | (0xffffffff00000000ULL))) +#define ioread64 ioread64 +#define ioread64be ioread64be +#define iowrite64 iowrite64 +#define iowrite64be iowrite64be +extern u64 ioread64 (void __iomem *addr); +extern u64 ioread64be (void __iomem *addr); +extern void iowrite64 (u64 val,void __iomem *addr); +extern void iowrite64be (u64 val,void __iomem *addr); +#include <asm-generic/iomap.h> /*
arch/parisc/lib/iomap.c +64 -0
121 lines not on this page · raw message
Signature · 1 line
2.11.0
Logan Gunthorpe
maintainerPATCH v12 3/9 powerpc: io.h: move iomap.h include so that it can use readq/writeq defs
In reply to Logan GunthorpeSubsequent patches in this series makes use of the readq and writeq defines in iomap.h. However, as is, they get missed on the powerpc platform seeing the include comes before the define. This patch moves the include down to fix this.
--- arch/powerpc/include/asm/io.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
arch/powerpc/include/asm/io.h +2 -2
@@ -33,8 +33,6 @@ extern struct pci_dev *isa_bridge_pcidev;#include <asm/mmu.h> #include <asm/ppc_asm.h> -#include <asm-generic/iomap.h> -#ifdef CONFIG_PPC64 #include <asm/paca.h> #endif
@@ -663,6 +661,8 @@ static inline void name at \#define writel_relaxed (v, addr) writel(v, addr)#define writeq_relaxed (v, addr) writeq(v, addr) +#include <asm-generic/iomap.h> +#ifdef CONFIG_PPC32 #define mmiowb ()#else
Signature · 1 line
2.11.0
Logan Gunthorpe
maintainerPATCH v12 4/9 powerpc: iomap.c: introduce io{read|write}64_{lo_hi|hi_lo}
In reply to Logan GunthorpeThese functions will be introduced into the generic iomap.c so they can deal with PIO accesses in hi-lo/lo-hi variants. Thus, the powerpc version of iomap.c will need to provide the same functions even though, in this arch, they are identical to the regular io{read|write}64 functions.
--- arch/powerpc/kernel/iomap.c | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+)
arch/powerpc/kernel/iomap.c +40 -0
@@ -45,12 +45,32 @@ u64 ioread64(void __iomem *addr) {return readq (addr); } +u64 ioread64_lo_hi (void __iomem *addr) +{ +return readq (addr); +} +u64 ioread64_hi_lo (void __iomem *addr) +{ +return readq (addr); +}u64 ioread64be (void __iomem *addr) {return readq_be (addr); } +u64 ioread64be_lo_hi (void __iomem *addr) +{ +return readq_be (addr); +} +u64 ioread64be_hi_lo (void __iomem *addr) +{ +return readq_be (addr); +}EXPORT_SYMBOL (ioread64); +EXPORT_SYMBOL (ioread64_lo_hi); +EXPORT_SYMBOL (ioread64_hi_lo);EXPORT_SYMBOL (ioread64be); +EXPORT_SYMBOL (ioread64be_lo_hi); +EXPORT_SYMBOL (ioread64be_hi_lo);#endif /* __powerpc64__ */ void iowrite8 (u8 val,void __iomem *addr)
@@ -83,12 +103,32 @@ void iowrite64(u64 val, void __iomem *addr) {writeq (val, addr); } +void iowrite64_lo_hi (u64 val,void __iomem *addr) +{ +writeq (val, addr); +} +void iowrite64_hi_lo (u64 val,void __iomem *addr) +{ +writeq (val, addr); +}void iowrite64be (u64 val,void __iomem *addr) {writeq_be (val, addr); } +void iowrite64be_lo_hi (u64 val,void __iomem *addr) +{ +writeq_be (val, addr); +} +void iowrite64be_hi_lo (u64 val,void __iomem *addr) +{ +writeq_be (val, addr); +}EXPORT_SYMBOL (iowrite64); +EXPORT_SYMBOL (iowrite64_lo_hi); +EXPORT_SYMBOL (iowrite64_hi_lo);EXPORT_SYMBOL (iowrite64be); +EXPORT_SYMBOL (iowrite64be_lo_hi); +EXPORT_SYMBOL (iowrite64be_hi_lo);#endif /* __powerpc64__ */ /*
Signature · 1 line
2.11.0
Logan Gunthorpe
maintainerPATCH v12 5/9 iomap: introduce io{read|write}64_{lo_hi|hi_lo}
In reply to Logan GunthorpeIn order to provide non-atomic functions for io{read|write}64 that will use readq and writeq when appropriate. We define a number of variants of these functions in the generic iomap that will do non-atomic operations on pio but atomic operations on mmio.
These functions are only defined if readq and writeq are defined. If they are not, then the wrappers that always use non-atomic operations from include/linux/io-64-nonatomic*.h will be used.
--- arch/powerpc/include/asm/io.h | 2 + include/asm-generic/iomap.h | 26 +++++++-- lib/iomap.c | 133 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 155 insertions(+), 6 deletions(-)
arch/powerpc/include/asm/io.h +2 -0
@@ -788,8 +788,10 @@ extern void __iounmap_at(void *ea, unsigned long size);#define mmio_read16be (addr) readw_be(addr)#define mmio_read32be (addr) readl_be(addr) +#define mmio_read64be (addr) readq_be(addr)#define mmio_write16be (val, addr) writew_be(val, addr)#define mmio_write32be (val, addr) writel_be(val, addr) +#define mmio_write64be (val, addr) writeq_be(val, addr)#define mmio_insb (addr, dst, count) readsb(addr, dst, count)#define mmio_insw (addr, dst, count) readsw(addr, dst, count)#define mmio_insl (addr, dst, count) readsl(addr, dst, count)
include/asm-generic/iomap.h +20 -6
@@ -31,9 +31,16 @@ extern unsigned int ioread16(void __iomem *);extern unsigned int ioread16be (void __iomem *);extern unsigned int ioread32 (void __iomem *);extern unsigned int ioread32be (void __iomem *); -#ifdef CONFIG_64BIT -extern u64 ioread64 (void __iomem *); -extern u64 ioread64be (void __iomem *); + +#ifdef readq +#define ioread64_lo_hi ioread64_lo_hi +#define ioread64_hi_lo ioread64_hi_lo +#define ioread64be_lo_hi ioread64be_lo_hi +#define ioread64be_hi_lo ioread64be_hi_lo +extern u64 ioread64_lo_hi (void __iomem *addr); +extern u64 ioread64_hi_lo (void __iomem *addr); +extern u64 ioread64be_lo_hi (void __iomem *addr); +extern u64 ioread64be_hi_lo (void __iomem *addr);#endif extern void iowrite8 (u8 ,void __iomem *);
@@ -41,9 +48,16 @@ extern void iowrite16(u16, void __iomem *);extern void iowrite16be (u16 ,void __iomem *);extern void iowrite32 (u32 ,void __iomem *);extern void iowrite32be (u32 ,void __iomem *); -#ifdef CONFIG_64BIT -extern void iowrite64 (u64 ,void __iomem *); -extern void iowrite64be (u64 ,void __iomem *); + +#ifdef writeq +#define iowrite64_lo_hi iowrite64_lo_hi +#define iowrite64_hi_lo iowrite64_hi_lo +#define iowrite64be_lo_hi iowrite64be_lo_hi +#define iowrite64be_hi_lo iowrite64be_hi_lo +extern void iowrite64_lo_hi (u64 val,void __iomem *addr); +extern void iowrite64_hi_lo (u64 val,void __iomem *addr); +extern void iowrite64be_lo_hi (u64 val,void __iomem *addr); +extern void iowrite64be_hi_lo (u64 val,void __iomem *addr);#endif /*
lib/iomap.c +133 -0
157 lines not on this page · raw message
Signature · 1 line
2.11.0
Logan Gunthorpe
maintainerPATCH v12 6/9 io-64-nonatomic: add io{read|write}64[be]{_lo_hi|_hi_lo} macros
In reply to Logan GunthorpeThis patch adds generic io{read|write}64[be]{_lo_hi|_hi_lo} macros if they are not already defined by the architecture. (As they are provided by the generic iomap library).
The patch also points io{read|write}64[be] to the variant specified by the header name.
This is because new drivers are encouraged to use ioreadXX, et al instead of readX[1], et al -- and mixing ioreadXX with readq is pretty ugly.
[1] LDD3: section 9.4.2
--- include/linux/io-64-nonatomic-hi-lo.h | 64 +++++++++++++++++++++++++++++++++++ include/linux/io-64-nonatomic-lo-hi.h | 64 +++++++++++++++++++++++++++++++++++ 2 files changed, 128 insertions(+)
include/linux/io-64-nonatomic-hi-lo.h +64 -0
@@ -55,4 +55,68 @@ static inline void hi_lo_writeq_relaxed(__u64 val, volatile void __iomem *addr)#define writeq_relaxed hi_lo_writeq_relaxed#endif +#ifndef ioread64_hi_lo +#define ioread64_hi_lo ioread64_hi_lo +static inline u64 ioread64_hi_lo (void __iomem *addr) +{ +u32 low, high; + + high =ioread32 (addr +sizeof (u32)); + low =ioread32 (addr); + +return low + ((u64 )high <<32 ); +} +#endif + +#ifndef iowrite64_hi_lo +#define iowrite64_hi_lo iowrite64_hi_lo +static inline void iowrite64_hi_lo (u64 val,void __iomem *addr) +{ +iowrite32 (val >>32 , addr +sizeof (u32)); +iowrite32 (val, addr); +} +#endif + +#ifndef ioread64be_hi_lo +#define ioread64be_hi_lo ioread64be_hi_lo +static inline u64 ioread64be_hi_lo (void __iomem *addr) +{ +u32 low, high; + + high =ioread32be (addr); + low =ioread32be (addr +sizeof (u32)); + +return low + ((u64 )high <<32 ); +} +#endif + +#ifndef iowrite64be_hi_lo +#define iowrite64be_hi_lo iowrite64be_hi_lo +static inline void iowrite64be_hi_lo (u64 val,void __iomem *addr) +{ +iowrite32be (val >>32 , addr); +iowrite32be (val, addr +sizeof (u32)); +} +#endif + +#ifndef ioread64 +#define ioread64_is_nonatomic +#define ioread64 ioread64_hi_lo +#endif + +#ifndef iowrite64 +#define iowrite64_is_nonatomic +#define iowrite64 iowrite64_hi_lo +#endif + +#ifndef ioread64be +#define ioread64be_is_nonatomic +#define ioread64be ioread64be_hi_lo +#endif + +#ifndef iowrite64be +#define iowrite64be_is_nonatomic +#define iowrite64be iowrite64be_hi_lo +#endif +#endif /* _LINUX_IO_64_NONATOMIC_HI_LO_H_ */
include/linux/io-64-nonatomic-lo-hi.h +64 -0
68 lines not on this page · raw message
Signature · 1 line
2.11.0
Logan Gunthorpe
maintainerPATCH v12 7/9 ntb: ntb_hw_intel: use io-64-nonatomic instead of in-driver hacks
In reply to Logan GunthorpeNow that ioread64 and iowrite64 are available in io-64-nonatomic, we can remove the hack at the top of ntb_hw_intel.c and replace it with an include.
# Please enter the commit message for your changes. Lines starting
# with '#' will be ignored, and an empty message aborts the commit.
#
# Date: Mon Jun 19 12:18:31 2017 -0600
#
# interactive rebase in progress; onto ae64f9bd1d36
# Last commands done (6 commands done):
# pick cf3e4dab2173 io-64-nonatomic: add io{read|write}64[be]{_lo_hi|_hi_lo} macros
# r 79b4c4b8490c ntb: ntb_hw_intel: use io-64-nonatomic instead of in-driver hacks
# Next commands to do (2 remaining commands):
# r 19b6c1f3b15d crypto: caam: cleanup CONFIG_64BIT ifdefs when using io{read|write}64
# r f3c8723446ef ntb_hw_switchtec: Cleanup 64bit IO defines to use the common header
# You are currently editing a commit while rebasing branch 'io64_v9' on 'ae64f9bd1d36'.
#
# Changes to be committed:
# modified: drivers/ntb/hw/intel/ntb_hw_intel.c
#
---
drivers/ntb/hw/intel/ntb_hw_intel.c | 30 +-----------------------------
1 file changed, 1 insertion(+), 29 deletions(-)drivers/ntb/hw/intel/ntb_hw_intel.c +1 -29
@@ -59,6 +59,7 @@#include <linux/random.h> #include <linux/slab.h> #include <linux/ntb.h> +#include <linux/io-64-nonatomic-lo-hi.h> #include "ntb_hw_intel.h"
@@ -149,35 +150,6 @@ MODULE_PARM_DESC(xeon_b2b_dsd_bar5_addr32,static inline enum ntb_topo xeon_ppd_topo (struct intel_ntb_dev *ndev,u8 ppd);static int xeon_init_isr (struct intel_ntb_dev *ndev); -#ifndef ioread64 -#ifdef readq -#define ioread64 readq -#else -#define ioread64 _ioread64 -static inline u64 _ioread64 (void __iomem *mmio) -{ -u64 low, high; - - low =ioread32 (mmio); - high =ioread32 (mmio +sizeof (u32)); -return low | (high <<32 ); -} -#endif -#endif - -#ifndef iowrite64 -#ifdef writeq -#define iowrite64 writeq -#else -#define iowrite64 _iowrite64 -static inline void _iowrite64 (u64 val,void __iomem *mmio) -{ -iowrite32 (val, mmio); -iowrite32 (val >>32 , mmio +sizeof (u32)); -} -#endif -#endif -static inline int pdev_is_xeon (struct pci_dev *pdev) {switch (pdev->device) {
Signature · 1 line
2.11.0
Logan Gunthorpe
maintainerPATCH v12 8/9 crypto: caam: cleanup CONFIG_64BIT ifdefs when using io{read|write}64
In reply to Logan GunthorpeClean up the extra ifdefs which defined the wr_reg64 and rd_reg64 functions in non-64bit cases in favour of the new common io-64-nonatomic-lo-hi header.
To be consistent with CAAM engine HW spec: in case of 64-bit registers, irrespective of device endianness, the lower address should be read from / written to first, followed by the upper address. Indeed the I/O accessors in CAAM driver currently don't follow the spec, however this is a good opportunity to fix the code.
--- drivers/crypto/caam/regs.h | 30 +++--------------------------- 1 file changed, 3 insertions(+), 27 deletions(-)
drivers/crypto/caam/regs.h +3 -27
@@ -10,7 +10,7 @@#include <linux/types.h> #include <linux/bitops.h> -#include <linux/io.h> +#include <linux/io-64-nonatomic-lo-hi.h> /* * Architecture-specific register access methods
@@ -136,10 +136,9 @@ static inline void clrsetbits_32(void __iomem *reg, u32 clear, u32 set)* base + 0x0000 : least-significant 32 bits * base + 0x0004 : most-significant 32 bits */ -#ifdef CONFIG_64BIT static inline void wr_reg64 (void __iomem *reg,u64 data) { -if (caam_little_end) +if (!caam_imx && caam_little_end)iowrite64 (data, reg);else iowrite64be (data, reg);
@@ -147,35 +146,12 @@ static inline void wr_reg64(void __iomem *reg, u64 data)static inline u64 rd_reg64 (void __iomem *reg) { -if (caam_little_end) +if (!caam_imx && caam_little_end)return ioread64 (reg);else return ioread64be (reg); } -#else /* CONFIG_64BIT */ -static inline void wr_reg64 (void __iomem *reg,u64 data) -{ -if (!caam_imx && caam_little_end) { -wr_reg32 ((u32 __iomem *)(reg) +1 , data >>32 ); -wr_reg32 ((u32 __iomem *)(reg), data); - }else { -wr_reg32 ((u32 __iomem *)(reg), data >>32 ); -wr_reg32 ((u32 __iomem *)(reg) +1 , data); - } -} - -static inline u64 rd_reg64 (void __iomem *reg) -{ -if (!caam_imx && caam_little_end) -return ((u64 )rd_reg32 ((u32 __iomem *)(reg) +1 ) <<32 | - (u64 )rd_reg32 ((u32 __iomem *)(reg))); - -return ((u64 )rd_reg32 ((u32 __iomem *)(reg)) <<32 | - (u64 )rd_reg32 ((u32 __iomem *)(reg) +1 )); -} -#endif /* CONFIG_64BIT */ -static inline u64 cpu_to_caam_dma64 (dma_addr_t value) {if (caam_imx)
Signature · 1 line
2.11.0
Logan Gunthorpe
maintainerPATCH v12 9/9 ntb: ntb_hw_switchtec: Cleanup 64bit IO defines to use the common header
In reply to Logan GunthorpeClean up the ifdefs which conditionally defined the io{read|write}64 functions in favour of the new common io-64-nonatomic-lo-hi header.
Per a nit from Andy Shevchenko, the include list is also made alphabetical.
--- drivers/ntb/hw/mscc/ntb_hw_switchtec.c | 36 ++++------------------------------ 1 file changed, 4 insertions(+), 32 deletions(-)
drivers/ntb/hw/mscc/ntb_hw_switchtec.c +4 -32
@@ -13,12 +13,13 @@* */ -#include <linux/switchtec.h> -#include <linux/module.h> +#include <linux/interrupt.h> +#include <linux/io-64-nonatomic-lo-hi.h> #include <linux/delay.h> #include <linux/kthread.h> -#include <linux/interrupt.h> +#include <linux/module.h> #include <linux/ntb.h> +#include <linux/switchtec.h> MODULE_DESCRIPTION ("Microsemi Switchtec(tm) NTB Driver" );MODULE_VERSION ("0.1" );
@@ -35,35 +36,6 @@ module_param(use_lut_mws, bool, 0644);MODULE_PARM_DESC (use_lut_mws,"Enable the use of the LUT based memory windows" ); -#ifndef ioread64 -#ifdef readq -#define ioread64 readq -#else -#define ioread64 _ioread64 -static inline u64 _ioread64 (void __iomem *mmio) -{ -u64 low, high; - - low =ioread32 (mmio); - high =ioread32 (mmio +sizeof (u32)); -return low | (high <<32 ); -} -#endif -#endif - -#ifndef iowrite64 -#ifdef writeq -#define iowrite64 writeq -#else -#define iowrite64 _iowrite64 -static inline void _iowrite64 (u64 val,void __iomem *mmio) -{ -iowrite32 (val, mmio); -iowrite32 (val >>32 , mmio +sizeof (u32)); -} -#endif -#endif -#define SWITCHTEC_NTB_MAGIC 0x45CC0001#define MAX_MWS 128
Signature · 1 line
2.11.0