iomap: Constify ioreadX() iomem argument
Subsystems (20)
cover iomap: Constify ioreadX() iomem argument
Hi,
The ioread8/16/32() and others have inconsistent interface among the
architectures: some taking address as const, some not.
It seems there is nothing really stopping all of them to take pointer to const.
Patchset was really tested on all affected architectures. Build testing is in progress - I hope auto-builders will point any issues.
Todo
==
Convert also string versions (ioread16_rep() etc) if this aproach looks OK.
Merging
===The first 5 patches - iomap, alpha, sh, parisc and powerpc - should probably go via one tree, or even squashed into one.
All other can go separately after these get merged.
Best regards,
Krzysztof
Krzysztof Kozlowski (13):
iomap: Constify ioreadX() iomem argument (as in generic
implementation)
alpha: Constify ioreadX() iomem argument (as in generic
implementation)
sh: Constify ioreadX() iomem argument (as in generic implementation)
parisc: Constify ioreadX() iomem argument (as in generic
implementation)
powerpc: Constify ioreadX() iomem argument (as in generic
implementation)
arc: Constify ioreadX() iomem argument (as in generic implementation) drm/mgag200: Constify ioreadX() iomem argument (as in generic
implementation)
drm/nouveau: Constify ioreadX() iomem argument (as in generic
implementation)
media: fsl-viu: Constify ioreadX() iomem argument (as in generic
implementation)
net: wireless: ath5k: Constify ioreadX() iomem argument (as in generic
implementation)
net: wireless: rtl818x: Constify ioreadX() iomem argument (as in
generic implementation)
ntb: intel: Constify ioreadX() iomem argument (as in generic
implementation)
virtio: pci: Constify ioreadX() iomem argument (as in generic
implementation)
arch/alpha/include/asm/core_apecs.h | 6 +-- arch/alpha/include/asm/core_cia.h | 6 +-- arch/alpha/include/asm/core_lca.h | 6 +-- arch/alpha/include/asm/core_marvel.h | 4 +- arch/alpha/include/asm/core_mcpcia.h | 6 +-- arch/alpha/include/asm/core_t2.h | 2 +- arch/alpha/include/asm/io.h | 12 +++--- arch/alpha/include/asm/io_trivial.h | 16 ++++---- arch/alpha/include/asm/jensen.h | 2 +- arch/alpha/include/asm/machvec.h | 6 +-- arch/alpha/kernel/core_marvel.c | 2 +- arch/alpha/kernel/io.c | 6 +-- arch/arc/plat-axs10x/axs10x.c | 4 +- arch/parisc/include/asm/io.h | 4 +- arch/parisc/lib/iomap.c | 48 +++++++++++----------- arch/powerpc/kernel/iomap.c | 22 +++++----- arch/sh/kernel/iomap.c | 10 ++--- drivers/gpu/drm/mgag200/mgag200_drv.h | 4 +- drivers/gpu/drm/nouveau/nouveau_bo.c | 2 +- drivers/media/platform/fsl-viu.c | 2 +- drivers/net/wireless/ath/ath5k/ahb.c | 10 ++--- .../net/wireless/realtek/rtl818x/rtl8180/rtl8180.h | 6 +-- drivers/ntb/hw/intel/ntb_hw_gen1.c | 2 +- drivers/ntb/hw/intel/ntb_hw_gen3.h | 2 +- drivers/ntb/hw/intel/ntb_hw_intel.h | 2 +- drivers/virtio/virtio_pci_modern.c | 6 +-- include/asm-generic/iomap.h | 22 +++++----- include/linux/io-64-nonatomic-hi-lo.h | 4 +- include/linux/io-64-nonatomic-lo-hi.h | 4 +- lib/iomap.c | 18 ++++---- 30 files changed, 123 insertions(+), 123 deletions(-)
Signature · 1 line
2.7.4
PATCH 1/13 iomap: Constify ioreadX() iomem argument (as in generic implementation)
The ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- include/asm-generic/iomap.h | 22 +++++++++++----------- include/linux/io-64-nonatomic-hi-lo.h | 4 ++-- include/linux/io-64-nonatomic-lo-hi.h | 4 ++-- lib/iomap.c | 18 +++++++++--------- 4 files changed, 24 insertions(+), 24 deletions(-)
include/asm-generic/iomap.h +11 -11
@@ -26,14 +26,14 @@* in the low address range. Architectures for which this is not * true can't use this generic implementation. */ -extern unsigned int ioread8 (void __iomem *); -extern unsigned int ioread16 (void __iomem *); -extern unsigned int ioread16be (void __iomem *); -extern unsigned int ioread32 (void __iomem *); -extern unsigned int ioread32be (void __iomem *); +extern unsigned int ioread8 (const void __iomem *); +extern unsigned int ioread16 (const void __iomem *); +extern unsigned int ioread16be (const void __iomem *); +extern unsigned int ioread32 (const void __iomem *); +extern unsigned int ioread32be (const void __iomem *);#ifdef CONFIG_64BIT -extern u64 ioread64 (void __iomem *); -extern u64 ioread64be (void __iomem *); +extern u64 ioread64 (const void __iomem *); +extern u64 ioread64be (const void __iomem *);#endif #ifdef readq
@@ -41,10 +41,10 @@ extern u64 ioread64be(void __iomem *);#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); +extern u64 ioread64_lo_hi (const void __iomem *addr); +extern u64 ioread64_hi_lo (const void __iomem *addr); +extern u64 ioread64be_lo_hi (const void __iomem *addr); +extern u64 ioread64be_hi_lo (const void __iomem *addr);#endif extern void iowrite8 (u8 ,void __iomem *);
include/linux/io-64-nonatomic-hi-lo.h +2 -2
@@ -57,7 +57,7 @@ static inline void hi_lo_writeq_relaxed(__u64 val, volatile void __iomem *addr)#ifndef ioread64_hi_lo#define ioread64_hi_lo ioread64_hi_lo -static inline u64 ioread64_hi_lo (void __iomem *addr) +static inline u64 ioread64_hi_lo (const void __iomem *addr) {u32 low, high;
@@ -79,7 +79,7 @@ static inline void iowrite64_hi_lo(u64 val, void __iomem *addr)#ifndef ioread64be_hi_lo#define ioread64be_hi_lo ioread64be_hi_lo -static inline u64 ioread64be_hi_lo (void __iomem *addr) +static inline u64 ioread64be_hi_lo (const void __iomem *addr) {u32 low, high;
include/linux/io-64-nonatomic-lo-hi.h +2 -2
@@ -57,7 +57,7 @@ static inline void lo_hi_writeq_relaxed(__u64 val, volatile void __iomem *addr)#ifndef ioread64_lo_hi#define ioread64_lo_hi ioread64_lo_hi -static inline u64 ioread64_lo_hi (void __iomem *addr) +static inline u64 ioread64_lo_hi (const void __iomem *addr) {u32 low, high;
@@ -79,7 +79,7 @@ static inline void iowrite64_lo_hi(u64 val, void __iomem *addr)#ifndef ioread64be_lo_hi#define ioread64be_lo_hi ioread64be_lo_hi -static inline u64 ioread64be_lo_hi (void __iomem *addr) +static inline u64 ioread64be_lo_hi (const void __iomem *addr) {u32 low, high;
lib/iomap.c +9 -9
@@ -70,27 +70,27 @@ static void bad_io_access(unsigned long port, const char *access)#define mmio_read64be (addr) swab64(readq(addr))#endif -unsigned int ioread8 (void __iomem *addr) +unsigned int ioread8 (const void __iomem *addr) { IO_COND(addr, return inb(port), return readb(addr));return 0xff ; } -unsigned int ioread16 (void __iomem *addr) +unsigned int ioread16 (const void __iomem *addr) { IO_COND(addr, return inw(port), return readw(addr));return 0xffff ; } -unsigned int ioread16be (void __iomem *addr) +unsigned int ioread16be (const void __iomem *addr) { IO_COND(addr, return pio_read16be(port), return mmio_read16be(addr));return 0xffff ; } -unsigned int ioread32 (void __iomem *addr) +unsigned int ioread32 (const void __iomem *addr) { IO_COND(addr, return inl(port), return readl(addr));return 0xffffffff ; } -unsigned int ioread32be (void __iomem *addr) +unsigned int ioread32be (const void __iomem *addr) { IO_COND(addr, return pio_read32be(port), return mmio_read32be(addr));return 0xffffffff ;
@@ -142,26 +142,26 @@ static u64 pio_read64be_hi_lo(unsigned long port)return lo | (hi <<32 ); } -u64 ioread64_lo_hi (void __iomem *addr) +u64 ioread64_lo_hi (const void __iomem *addr) { IO_COND(addr, return pio_read64_lo_hi(port), return readq(addr));return 0xffffffffffffffffULL ; } -u64 ioread64_hi_lo (void __iomem *addr) +u64 ioread64_hi_lo (const void __iomem *addr) { IO_COND(addr, return pio_read64_hi_lo(port), return readq(addr));return 0xffffffffffffffffULL ; } -u64 ioread64be_lo_hi (void __iomem *addr) +u64 ioread64be_lo_hi (const void __iomem *addr) { IO_COND(addr, return pio_read64be_lo_hi(port), return mmio_read64be(addr));return 0xffffffffffffffffULL ; } -u64 ioread64be_hi_lo (void __iomem *addr) +u64 ioread64be_hi_lo (const void __iomem *addr) { IO_COND(addr, return pio_read64be_hi_lo(port), return mmio_read64be(addr));
Signature · 1 line
2.7.4
A message that is not in the archive (sent off-list or not yet received): 1578415992-24054-1-git-send-email-krzk-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org
PATCH 1/13 iomap: Constify ioreadX() iomem argument (as in generic implementation)
The ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- include/asm-generic/iomap.h | 22 +++++++++++----------- include/linux/io-64-nonatomic-hi-lo.h | 4 ++-- include/linux/io-64-nonatomic-lo-hi.h | 4 ++-- lib/iomap.c | 18 +++++++++--------- 4 files changed, 24 insertions(+), 24 deletions(-)
include/asm-generic/iomap.h +11 -11
@@ -26,14 +26,14 @@* in the low address range. Architectures for which this is not * true can't use this generic implementation. */ -extern unsigned int ioread8 (void __iomem *); -extern unsigned int ioread16 (void __iomem *); -extern unsigned int ioread16be (void __iomem *); -extern unsigned int ioread32 (void __iomem *); -extern unsigned int ioread32be (void __iomem *); +extern unsigned int ioread8 (const void __iomem *); +extern unsigned int ioread16 (const void __iomem *); +extern unsigned int ioread16be (const void __iomem *); +extern unsigned int ioread32 (const void __iomem *); +extern unsigned int ioread32be (const void __iomem *);#ifdef CONFIG_64BIT -extern u64 ioread64 (void __iomem *); -extern u64 ioread64be (void __iomem *); +extern u64 ioread64 (const void __iomem *); +extern u64 ioread64be (const void __iomem *);#endif #ifdef readq
@@ -41,10 +41,10 @@ extern u64 ioread64be(void __iomem *);#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); +extern u64 ioread64_lo_hi (const void __iomem *addr); +extern u64 ioread64_hi_lo (const void __iomem *addr); +extern u64 ioread64be_lo_hi (const void __iomem *addr); +extern u64 ioread64be_hi_lo (const void __iomem *addr);#endif extern void iowrite8 (u8 ,void __iomem *);
include/linux/io-64-nonatomic-hi-lo.h +2 -2
@@ -57,7 +57,7 @@ static inline void hi_lo_writeq_relaxed(__u64 val, volatile void __iomem *addr)#ifndef ioread64_hi_lo#define ioread64_hi_lo ioread64_hi_lo -static inline u64 ioread64_hi_lo (void __iomem *addr) +static inline u64 ioread64_hi_lo (const void __iomem *addr) {u32 low, high;
@@ -79,7 +79,7 @@ static inline void iowrite64_hi_lo(u64 val, void __iomem *addr)#ifndef ioread64be_hi_lo#define ioread64be_hi_lo ioread64be_hi_lo -static inline u64 ioread64be_hi_lo (void __iomem *addr) +static inline u64 ioread64be_hi_lo (const void __iomem *addr) {u32 low, high;
include/linux/io-64-nonatomic-lo-hi.h +2 -2
@@ -57,7 +57,7 @@ static inline void lo_hi_writeq_relaxed(__u64 val, volatile void __iomem *addr)#ifndef ioread64_lo_hi#define ioread64_lo_hi ioread64_lo_hi -static inline u64 ioread64_lo_hi (void __iomem *addr) +static inline u64 ioread64_lo_hi (const void __iomem *addr) {u32 low, high;
@@ -79,7 +79,7 @@ static inline void iowrite64_lo_hi(u64 val, void __iomem *addr)#ifndef ioread64be_lo_hi#define ioread64be_lo_hi ioread64be_lo_hi -static inline u64 ioread64be_lo_hi (void __iomem *addr) +static inline u64 ioread64be_lo_hi (const void __iomem *addr) {u32 low, high;
lib/iomap.c +9 -9
@@ -70,27 +70,27 @@ static void bad_io_access(unsigned long port, const char *access)#define mmio_read64be (addr) swab64(readq(addr))#endif -unsigned int ioread8 (void __iomem *addr) +unsigned int ioread8 (const void __iomem *addr) { IO_COND(addr, return inb(port), return readb(addr));return 0xff ; } -unsigned int ioread16 (void __iomem *addr) +unsigned int ioread16 (const void __iomem *addr) { IO_COND(addr, return inw(port), return readw(addr));return 0xffff ; } -unsigned int ioread16be (void __iomem *addr) +unsigned int ioread16be (const void __iomem *addr) { IO_COND(addr, return pio_read16be(port), return mmio_read16be(addr));return 0xffff ; } -unsigned int ioread32 (void __iomem *addr) +unsigned int ioread32 (const void __iomem *addr) { IO_COND(addr, return inl(port), return readl(addr));return 0xffffffff ; } -unsigned int ioread32be (void __iomem *addr) +unsigned int ioread32be (const void __iomem *addr) { IO_COND(addr, return pio_read32be(port), return mmio_read32be(addr));return 0xffffffff ;
@@ -142,26 +142,26 @@ static u64 pio_read64be_hi_lo(unsigned long port)return lo | (hi <<32 ); } -u64 ioread64_lo_hi (void __iomem *addr) +u64 ioread64_lo_hi (const void __iomem *addr) { IO_COND(addr, return pio_read64_lo_hi(port), return readq(addr));return 0xffffffffffffffffULL ; } -u64 ioread64_hi_lo (void __iomem *addr) +u64 ioread64_hi_lo (const void __iomem *addr) { IO_COND(addr, return pio_read64_hi_lo(port), return readq(addr));return 0xffffffffffffffffULL ; } -u64 ioread64be_lo_hi (void __iomem *addr) +u64 ioread64be_lo_hi (const void __iomem *addr) { IO_COND(addr, return pio_read64be_lo_hi(port), return mmio_read64be(addr));return 0xffffffffffffffffULL ; } -u64 ioread64be_hi_lo (void __iomem *addr) +u64 ioread64be_hi_lo (const void __iomem *addr) { IO_COND(addr, return pio_read64be_hi_lo(port), return mmio_read64be(addr));
Signature · 1 line
2.7.4
PATCH 2/13 alpha: Constify ioreadX() iomem argument (as in generic implementation)
In reply to a message not in the archiveThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/alpha/include/asm/core_apecs.h | 6 +++--- arch/alpha/include/asm/core_cia.h | 6 +++--- arch/alpha/include/asm/core_lca.h | 6 +++--- arch/alpha/include/asm/core_marvel.h | 4 ++-- arch/alpha/include/asm/core_mcpcia.h | 6 +++--- arch/alpha/include/asm/core_t2.h | 2 +- arch/alpha/include/asm/io.h | 12 ++++++------ arch/alpha/include/asm/io_trivial.h | 16 ++++++++-------- arch/alpha/include/asm/jensen.h | 2 +- arch/alpha/include/asm/machvec.h | 6 +++--- arch/alpha/kernel/core_marvel.c | 2 +- arch/alpha/kernel/io.c | 6 +++--- 12 files changed, 37 insertions(+), 37 deletions(-)
arch/alpha/include/asm/core_apecs.h +3 -3
@@ -384,7 +384,7 @@ struct el_apecs_procdata } \ }while (0 ) -__EXTERN_INLINE unsigned int apecs_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int apecs_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -420,7 +420,7 @@ __EXTERN_INLINE void apecs_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int apecs_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int apecs_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -456,7 +456,7 @@ __EXTERN_INLINE void apecs_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int apecs_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int apecs_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (addr <APECS_DENSE_MEM )
arch/alpha/include/asm/core_cia.h +3 -3
@@ -342,7 +342,7 @@ struct el_CIA_sysdata_mcheck {#define vuip volatile unsigned int __force *#define vulp volatile unsigned long __force * -__EXTERN_INLINE unsigned int cia_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int cia_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -374,7 +374,7 @@ __EXTERN_INLINE void cia_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int cia_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int cia_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -404,7 +404,7 @@ __EXTERN_INLINE void cia_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int cia_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int cia_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (addr <CIA_DENSE_MEM )
arch/alpha/include/asm/core_lca.h +3 -3
@@ -230,7 +230,7 @@ union el_lca { }while (0 ) -__EXTERN_INLINE unsigned int lca_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int lca_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -266,7 +266,7 @@ __EXTERN_INLINE void lca_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int lca_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int lca_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -302,7 +302,7 @@ __EXTERN_INLINE void lca_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int lca_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int lca_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (addr <LCA_DENSE_MEM )
arch/alpha/include/asm/core_marvel.h +2 -2
@@ -332,10 +332,10 @@ struct io7 {#define vucp volatile unsigned char __force *#define vusp volatile unsigned short __force * -extern unsigned int marvel_ioread8 (void __iomem *); +extern unsigned int marvel_ioread8 (const void __iomem *);extern void marvel_iowrite8 (u8 b,void __iomem *); -__EXTERN_INLINE unsigned int marvel_ioread16(void __iomem *addr) +__EXTERN_INLINE unsigned int marvel_ioread16(const void __iomem *addr) {return __kernel_ldwu (*(vusp )addr); }
arch/alpha/include/asm/core_mcpcia.h +3 -3
@@ -267,7 +267,7 @@ extern inline int __mcpcia_is_mmio(unsigned long addr)return (addr &0x80000000UL ) ==0 ; } -__EXTERN_INLINE unsigned int mcpcia_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int mcpcia_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long )xaddr &MCPCIA_MEM_MASK ;unsigned long hose = (unsigned long )xaddr & ~MCPCIA_MEM_MASK ;
@@ -291,7 +291,7 @@ __EXTERN_INLINE void mcpcia_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + hose +0x00 ) = w; } -__EXTERN_INLINE unsigned int mcpcia_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int mcpcia_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long )xaddr &MCPCIA_MEM_MASK ;unsigned long hose = (unsigned long )xaddr & ~MCPCIA_MEM_MASK ;
@@ -315,7 +315,7 @@ __EXTERN_INLINE void mcpcia_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + hose +0x08 ) = w; } -__EXTERN_INLINE unsigned int mcpcia_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int mcpcia_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long )xaddr;
arch/alpha/include/asm/core_t2.h +1 -1
@@ -572,7 +572,7 @@ __EXTERN_INLINE int t2_is_mmio(const volatile void __iomem *addr)it doesn't make sense to merge the pio and mmio routines. */ #define IOPORT (OS ,NS ) \ -__EXTERN_INLINE unsigned int t2_ioread##NS(void __iomem *xaddr) \ +__EXTERN_INLINE unsigned int t2_ioread##NS(const void __iomem *xaddr) \ { \ if (t2_is_mmio(xaddr)) \ return t2_read##OS(xaddr); \
arch/alpha/include/asm/io.h +6 -6
@@ -151,9 +151,9 @@ static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr) \ alpha_mv.mv_##NAME(b, addr); \ } -REMAP1(unsigned int, ioread8, /**/) -REMAP1(unsigned int, ioread16, /**/) -REMAP1(unsigned int, ioread32, /**/) +REMAP1(unsigned int, ioread8, const) +REMAP1(unsigned int, ioread16, const) +REMAP1(unsigned int, ioread32, const) REMAP1(u8, readb, const volatile) REMAP1(u16, readw, const volatile) REMAP1(u32, readl, const volatile)
@@ -308,14 +308,14 @@ static inline int __is_mmio(const volatile void __iomem *addr)*/ #if IO_CONCAT (__IO_PREFIX,trivial_io_bw) -extern inline unsigned int ioread8 (void __iomem *addr) +extern inline unsigned int ioread8 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread8)(addr);mb ();return ret; } -extern inline unsigned int ioread16 (void __iomem *addr) +extern inline unsigned int ioread16 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread16)(addr);mb ();
@@ -356,7 +356,7 @@ extern inline void outw(u16 b, unsigned long port)#endif #if IO_CONCAT (__IO_PREFIX,trivial_io_lq) -extern inline unsigned int ioread32 (void __iomem *addr) +extern inline unsigned int ioread32 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread32)(addr);mb ();
arch/alpha/include/asm/io_trivial.h +8 -8
@@ -7,15 +7,15 @@#if IO_CONCAT (__IO_PREFIX,trivial_io_bw) __EXTERN_INLINE unsigned int -IO_CONCAT (__IO_PREFIX ,ioread8 )(void __iomem *a) +IO_CONCAT (__IO_PREFIX ,ioread8 )(const void __iomem *a) { -return __kernel_ldbu (*(volatile u8 __force *)a); +return __kernel_ldbu (*(const volatile u8 __force *)a); } __EXTERN_INLINE unsigned int -IO_CONCAT (__IO_PREFIX ,ioread16 )(void __iomem *a) +IO_CONCAT (__IO_PREFIX ,ioread16 )(const void __iomem *a) { -return __kernel_ldwu (*(volatile u16 __force *)a); +return __kernel_ldwu (*(const volatile u16 __force *)a); }__EXTERN_INLINE void
@@ -33,9 +33,9 @@ IO_CONCAT(__IO_PREFIX,iowrite16)(u16 b, void __iomem *a)#if IO_CONCAT (__IO_PREFIX,trivial_io_lq) __EXTERN_INLINE unsigned int -IO_CONCAT (__IO_PREFIX ,ioread32 )(void __iomem *a) +IO_CONCAT (__IO_PREFIX ,ioread32 )(const void __iomem *a) { -return *(volatile u32 __force *)a; +return *(const volatile u32 __force *)a; }__EXTERN_INLINE void
@@ -73,14 +73,14 @@ IO_CONCAT(__IO_PREFIX,writew)(u16 b, volatile void __iomem *a) __EXTERN_INLINE u8IO_CONCAT (__IO_PREFIX ,readb )(const volatile void __iomem *a) { -void __iomem *addr = (void __iomem *)a; +const void __iomem *addr = (const void __iomem *)a;return IO_CONCAT (__IO_PREFIX,ioread8)(addr); } __EXTERN_INLINE u16IO_CONCAT (__IO_PREFIX ,readw )(const volatile void __iomem *a) { -void __iomem *addr = (void __iomem *)a; +const void __iomem *addr = (const void __iomem *)a;return IO_CONCAT (__IO_PREFIX,ioread16)(addr); }
arch/alpha/include/asm/jensen.h +1 -1
@@ -305,7 +305,7 @@ __EXTERN_INLINE int jensen_is_mmio(const volatile void __iomem *addr)that it doesn't make sense to merge them. */ #define IOPORT (OS ,NS ) \ -__EXTERN_INLINE unsigned int jensen_ioread##NS(void __iomem *xaddr) \ +__EXTERN_INLINE unsigned int jensen_ioread##NS(const void __iomem *xaddr) \ { \ if (jensen_is_mmio(xaddr)) \ return jensen_read##OS(xaddr - 0x100000000ul); \
arch/alpha/include/asm/machvec.h +3 -3
@@ -46,9 +46,9 @@ struct alpha_machine_vectorvoid (*mv_pci_tbi)(struct pci_controller *hose,dma_addr_t start,dma_addr_t end); -unsigned int (*mv_ioread8)(void __iomem *); -unsigned int (*mv_ioread16)(void __iomem *); -unsigned int (*mv_ioread32)(void __iomem *); +unsigned int (*mv_ioread8)(const void __iomem *); +unsigned int (*mv_ioread16)(const void __iomem *); +unsigned int (*mv_ioread32)(const void __iomem *);void (*mv_iowrite8)(u8 ,void __iomem *);void (*mv_iowrite16)(u16 ,void __iomem *);
arch/alpha/kernel/core_marvel.c +1 -1
@@ -807,7 +807,7 @@ void __iomem *marvel_ioportmap (unsigned long addr) }unsigned int -marvel_ioread8 (void __iomem *xaddr) +marvel_ioread8 (const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (__marvel_is_port_kbd (addr))
arch/alpha/kernel/io.c +3 -3
@@ -14,21 +14,21 @@"generic", which bumps through the machine vector. */ unsigned int -ioread8 (void __iomem *addr) +ioread8 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread8)(addr);mb ();return ret; } -unsigned int ioread16 (void __iomem *addr) +unsigned int ioread16 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread16)(addr);mb ();return ret; } -unsigned int ioread32 (void __iomem *addr) +unsigned int ioread32 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread32)(addr);mb ();
Signature · 1 line
2.7.4
PATCH 2/13 sh: Constify ioreadX() iomem argument (as in generic implementation)
In reply to a message not in the archiveThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/sh/kernel/iomap.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
arch/sh/kernel/iomap.c +5 -5
@@ -8,31 +8,31 @@#include <linux/module.h> #include <linux/io.h> -unsigned int ioread8 (void __iomem *addr) +unsigned int ioread8 (const void __iomem *addr) {return readb (addr); }EXPORT_SYMBOL (ioread8); -unsigned int ioread16 (void __iomem *addr) +unsigned int ioread16 (const void __iomem *addr) {return readw (addr); }EXPORT_SYMBOL (ioread16); -unsigned int ioread16be (void __iomem *addr) +unsigned int ioread16be (const void __iomem *addr) {return be16_to_cpu (__raw_readw (addr)); }EXPORT_SYMBOL (ioread16be); -unsigned int ioread32 (void __iomem *addr) +unsigned int ioread32 (const void __iomem *addr) {return readl (addr); }EXPORT_SYMBOL (ioread32); -unsigned int ioread32be (void __iomem *addr) +unsigned int ioread32be (const void __iomem *addr) {return be32_to_cpu (__raw_readl (addr)); }
Signature · 1 line
2.7.4
PATCH 3/13 alpha: Constify ioreadX() iomem argument (as in generic implementation)
In reply to a message not in the archiveThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/alpha/include/asm/core_apecs.h | 6 +++--- arch/alpha/include/asm/core_cia.h | 6 +++--- arch/alpha/include/asm/core_lca.h | 6 +++--- arch/alpha/include/asm/core_marvel.h | 4 ++-- arch/alpha/include/asm/core_mcpcia.h | 6 +++--- arch/alpha/include/asm/core_t2.h | 2 +- arch/alpha/include/asm/io.h | 12 ++++++------ arch/alpha/include/asm/io_trivial.h | 16 ++++++++-------- arch/alpha/include/asm/jensen.h | 2 +- arch/alpha/include/asm/machvec.h | 6 +++--- arch/alpha/kernel/core_marvel.c | 2 +- arch/alpha/kernel/io.c | 6 +++--- 12 files changed, 37 insertions(+), 37 deletions(-)
arch/alpha/include/asm/core_apecs.h +3 -3
@@ -384,7 +384,7 @@ struct el_apecs_procdata } \ }while (0 ) -__EXTERN_INLINE unsigned int apecs_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int apecs_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -420,7 +420,7 @@ __EXTERN_INLINE void apecs_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int apecs_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int apecs_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -456,7 +456,7 @@ __EXTERN_INLINE void apecs_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int apecs_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int apecs_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (addr <APECS_DENSE_MEM )
arch/alpha/include/asm/core_cia.h +3 -3
@@ -342,7 +342,7 @@ struct el_CIA_sysdata_mcheck {#define vuip volatile unsigned int __force *#define vulp volatile unsigned long __force * -__EXTERN_INLINE unsigned int cia_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int cia_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -374,7 +374,7 @@ __EXTERN_INLINE void cia_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int cia_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int cia_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -404,7 +404,7 @@ __EXTERN_INLINE void cia_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int cia_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int cia_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (addr <CIA_DENSE_MEM )
arch/alpha/include/asm/core_lca.h +3 -3
@@ -230,7 +230,7 @@ union el_lca { }while (0 ) -__EXTERN_INLINE unsigned int lca_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int lca_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -266,7 +266,7 @@ __EXTERN_INLINE void lca_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int lca_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int lca_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -302,7 +302,7 @@ __EXTERN_INLINE void lca_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int lca_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int lca_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (addr <LCA_DENSE_MEM )
arch/alpha/include/asm/core_marvel.h +2 -2
@@ -332,10 +332,10 @@ struct io7 {#define vucp volatile unsigned char __force *#define vusp volatile unsigned short __force * -extern unsigned int marvel_ioread8 (void __iomem *); +extern unsigned int marvel_ioread8 (const void __iomem *);extern void marvel_iowrite8 (u8 b,void __iomem *); -__EXTERN_INLINE unsigned int marvel_ioread16(void __iomem *addr) +__EXTERN_INLINE unsigned int marvel_ioread16(const void __iomem *addr) {return __kernel_ldwu (*(vusp )addr); }
arch/alpha/include/asm/core_mcpcia.h +3 -3
@@ -267,7 +267,7 @@ extern inline int __mcpcia_is_mmio(unsigned long addr)return (addr &0x80000000UL ) ==0 ; } -__EXTERN_INLINE unsigned int mcpcia_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int mcpcia_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long )xaddr &MCPCIA_MEM_MASK ;unsigned long hose = (unsigned long )xaddr & ~MCPCIA_MEM_MASK ;
@@ -291,7 +291,7 @@ __EXTERN_INLINE void mcpcia_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + hose +0x00 ) = w; } -__EXTERN_INLINE unsigned int mcpcia_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int mcpcia_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long )xaddr &MCPCIA_MEM_MASK ;unsigned long hose = (unsigned long )xaddr & ~MCPCIA_MEM_MASK ;
@@ -315,7 +315,7 @@ __EXTERN_INLINE void mcpcia_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + hose +0x08 ) = w; } -__EXTERN_INLINE unsigned int mcpcia_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int mcpcia_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long )xaddr;
arch/alpha/include/asm/core_t2.h +1 -1
@@ -572,7 +572,7 @@ __EXTERN_INLINE int t2_is_mmio(const volatile void __iomem *addr)it doesn't make sense to merge the pio and mmio routines. */ #define IOPORT (OS ,NS ) \ -__EXTERN_INLINE unsigned int t2_ioread##NS(void __iomem *xaddr) \ +__EXTERN_INLINE unsigned int t2_ioread##NS(const void __iomem *xaddr) \ { \ if (t2_is_mmio(xaddr)) \ return t2_read##OS(xaddr); \
arch/alpha/include/asm/io.h +6 -6
@@ -151,9 +151,9 @@ static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr) \ alpha_mv.mv_##NAME(b, addr); \ } -REMAP1(unsigned int, ioread8, /**/) -REMAP1(unsigned int, ioread16, /**/) -REMAP1(unsigned int, ioread32, /**/) +REMAP1(unsigned int, ioread8, const) +REMAP1(unsigned int, ioread16, const) +REMAP1(unsigned int, ioread32, const) REMAP1(u8, readb, const volatile) REMAP1(u16, readw, const volatile) REMAP1(u32, readl, const volatile)
@@ -308,14 +308,14 @@ static inline int __is_mmio(const volatile void __iomem *addr)*/ #if IO_CONCAT (__IO_PREFIX,trivial_io_bw) -extern inline unsigned int ioread8 (void __iomem *addr) +extern inline unsigned int ioread8 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread8)(addr);mb ();return ret; } -extern inline unsigned int ioread16 (void __iomem *addr) +extern inline unsigned int ioread16 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread16)(addr);mb ();
@@ -356,7 +356,7 @@ extern inline void outw(u16 b, unsigned long port)#endif #if IO_CONCAT (__IO_PREFIX,trivial_io_lq) -extern inline unsigned int ioread32 (void __iomem *addr) +extern inline unsigned int ioread32 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread32)(addr);mb ();
arch/alpha/include/asm/io_trivial.h +8 -8
@@ -7,15 +7,15 @@#if IO_CONCAT (__IO_PREFIX,trivial_io_bw) __EXTERN_INLINE unsigned int -IO_CONCAT (__IO_PREFIX ,ioread8 )(void __iomem *a) +IO_CONCAT (__IO_PREFIX ,ioread8 )(const void __iomem *a) { -return __kernel_ldbu (*(volatile u8 __force *)a); +return __kernel_ldbu (*(const volatile u8 __force *)a); } __EXTERN_INLINE unsigned int -IO_CONCAT (__IO_PREFIX ,ioread16 )(void __iomem *a) +IO_CONCAT (__IO_PREFIX ,ioread16 )(const void __iomem *a) { -return __kernel_ldwu (*(volatile u16 __force *)a); +return __kernel_ldwu (*(const volatile u16 __force *)a); }__EXTERN_INLINE void
@@ -33,9 +33,9 @@ IO_CONCAT(__IO_PREFIX,iowrite16)(u16 b, void __iomem *a)#if IO_CONCAT (__IO_PREFIX,trivial_io_lq) __EXTERN_INLINE unsigned int -IO_CONCAT (__IO_PREFIX ,ioread32 )(void __iomem *a) +IO_CONCAT (__IO_PREFIX ,ioread32 )(const void __iomem *a) { -return *(volatile u32 __force *)a; +return *(const volatile u32 __force *)a; }__EXTERN_INLINE void
@@ -73,14 +73,14 @@ IO_CONCAT(__IO_PREFIX,writew)(u16 b, volatile void __iomem *a) __EXTERN_INLINE u8IO_CONCAT (__IO_PREFIX ,readb )(const volatile void __iomem *a) { -void __iomem *addr = (void __iomem *)a; +const void __iomem *addr = (const void __iomem *)a;return IO_CONCAT (__IO_PREFIX,ioread8)(addr); } __EXTERN_INLINE u16IO_CONCAT (__IO_PREFIX ,readw )(const volatile void __iomem *a) { -void __iomem *addr = (void __iomem *)a; +const void __iomem *addr = (const void __iomem *)a;return IO_CONCAT (__IO_PREFIX,ioread16)(addr); }
arch/alpha/include/asm/jensen.h +1 -1
@@ -305,7 +305,7 @@ __EXTERN_INLINE int jensen_is_mmio(const volatile void __iomem *addr)that it doesn't make sense to merge them. */ #define IOPORT (OS ,NS ) \ -__EXTERN_INLINE unsigned int jensen_ioread##NS(void __iomem *xaddr) \ +__EXTERN_INLINE unsigned int jensen_ioread##NS(const void __iomem *xaddr) \ { \ if (jensen_is_mmio(xaddr)) \ return jensen_read##OS(xaddr - 0x100000000ul); \
arch/alpha/include/asm/machvec.h +3 -3
@@ -46,9 +46,9 @@ struct alpha_machine_vectorvoid (*mv_pci_tbi)(struct pci_controller *hose,dma_addr_t start,dma_addr_t end); -unsigned int (*mv_ioread8)(void __iomem *); -unsigned int (*mv_ioread16)(void __iomem *); -unsigned int (*mv_ioread32)(void __iomem *); +unsigned int (*mv_ioread8)(const void __iomem *); +unsigned int (*mv_ioread16)(const void __iomem *); +unsigned int (*mv_ioread32)(const void __iomem *);void (*mv_iowrite8)(u8 ,void __iomem *);void (*mv_iowrite16)(u16 ,void __iomem *);
arch/alpha/kernel/core_marvel.c +1 -1
@@ -807,7 +807,7 @@ void __iomem *marvel_ioportmap (unsigned long addr) }unsigned int -marvel_ioread8 (void __iomem *xaddr) +marvel_ioread8 (const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (__marvel_is_port_kbd (addr))
arch/alpha/kernel/io.c +3 -3
@@ -14,21 +14,21 @@"generic", which bumps through the machine vector. */ unsigned int -ioread8 (void __iomem *addr) +ioread8 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread8)(addr);mb ();return ret; } -unsigned int ioread16 (void __iomem *addr) +unsigned int ioread16 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread16)(addr);mb ();return ret; } -unsigned int ioread32 (void __iomem *addr) +unsigned int ioread32 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread32)(addr);mb ();
Signature · 1 line
2.7.4
PATCH 3/13 sh: Constify ioreadX() iomem argument (as in generic implementation)
In reply to a message not in the archiveThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/sh/kernel/iomap.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
arch/sh/kernel/iomap.c +5 -5
@@ -8,31 +8,31 @@#include <linux/module.h> #include <linux/io.h> -unsigned int ioread8 (void __iomem *addr) +unsigned int ioread8 (const void __iomem *addr) {return readb (addr); }EXPORT_SYMBOL (ioread8); -unsigned int ioread16 (void __iomem *addr) +unsigned int ioread16 (const void __iomem *addr) {return readw (addr); }EXPORT_SYMBOL (ioread16); -unsigned int ioread16be (void __iomem *addr) +unsigned int ioread16be (const void __iomem *addr) {return be16_to_cpu (__raw_readw (addr)); }EXPORT_SYMBOL (ioread16be); -unsigned int ioread32 (void __iomem *addr) +unsigned int ioread32 (const void __iomem *addr) {return readl (addr); }EXPORT_SYMBOL (ioread32); -unsigned int ioread32be (void __iomem *addr) +unsigned int ioread32be (const void __iomem *addr) {return be32_to_cpu (__raw_readl (addr)); }
Signature · 1 line
2.7.4
PATCH 4/13 parisc: Constify ioreadX() iomem argument (as in generic implementation)
In reply to a message not in the archiveThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/parisc/include/asm/io.h | 4 ++-- arch/parisc/lib/iomap.c | 48 ++++++++++++++++++++++---------------------- 2 files changed, 26 insertions(+), 26 deletions(-)
arch/parisc/include/asm/io.h +2 -2
@@ -303,8 +303,8 @@ extern void outsl (unsigned long port, const void *src, unsigned long count);#define ioread64be ioread64be#define iowrite64 iowrite64#define iowrite64be iowrite64be -extern u64 ioread64 (void __iomem *addr); -extern u64 ioread64be (void __iomem *addr); +extern u64 ioread64 (const void __iomem *addr); +extern u64 ioread64be (const void __iomem *addr);extern void iowrite64 (u64 val,void __iomem *addr);extern void iowrite64be (u64 val,void __iomem *addr);
arch/parisc/lib/iomap.c +24 -24
140 lines not on this page · raw message
Signature · 1 line
2.7.4
PATCH 5/13 powerpc: Constify ioreadX() iomem argument (as in generic implementation)
In reply to a message not in the archiveThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/powerpc/kernel/iomap.c | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-)
arch/powerpc/kernel/iomap.c +11 -11
@@ -15,23 +15,23 @@* Here comes the ppc64 implementation of the IOMAP * interfaces. */ -unsigned int ioread8 (void __iomem *addr) +unsigned int ioread8 (const void __iomem *addr) {return readb (addr); } -unsigned int ioread16 (void __iomem *addr) +unsigned int ioread16 (const void __iomem *addr) {return readw (addr); } -unsigned int ioread16be (void __iomem *addr) +unsigned int ioread16be (const void __iomem *addr) {return readw_be (addr); } -unsigned int ioread32 (void __iomem *addr) +unsigned int ioread32 (const void __iomem *addr) {return readl (addr); } -unsigned int ioread32be (void __iomem *addr) +unsigned int ioread32be (const void __iomem *addr) {return readl_be (addr); }
@@ -41,27 +41,27 @@ EXPORT_SYMBOL(ioread16be);EXPORT_SYMBOL (ioread32);EXPORT_SYMBOL (ioread32be);#ifdef __powerpc64__ -u64 ioread64 (void __iomem *addr) +u64 ioread64 (const void __iomem *addr) {return readq (addr); } -u64 ioread64_lo_hi (void __iomem *addr) +u64 ioread64_lo_hi (const void __iomem *addr) {return readq (addr); } -u64 ioread64_hi_lo (void __iomem *addr) +u64 ioread64_hi_lo (const void __iomem *addr) {return readq (addr); } -u64 ioread64be (void __iomem *addr) +u64 ioread64be (const void __iomem *addr) {return readq_be (addr); } -u64 ioread64be_lo_hi (void __iomem *addr) +u64 ioread64be_lo_hi (const void __iomem *addr) {return readq_be (addr); } -u64 ioread64be_hi_lo (void __iomem *addr) +u64 ioread64be_hi_lo (const void __iomem *addr) {return readq_be (addr); }
Signature · 1 line
2.7.4
PATCH 6/13 arc: Constify ioreadX() iomem argument (as in generic implementation)
In reply to a message not in the archiveThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/arc/plat-axs10x/axs10x.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
arch/arc/plat-axs10x/axs10x.c +2 -2
@@ -84,7 +84,7 @@ static void __init axs10x_print_board_ver(unsigned int creg, const char *str)unsigned int val; } board; - board.val =ioread32 ((void __iomem *)creg); + board.val =ioread32 ((const void __iomem *)creg);pr_info ("AXS: %s FPGA Date: %u-%u-%u\n" , str, board.d, board.m, board.y); }
@@ -95,7 +95,7 @@ static void __init axs10x_early_init(void)char mb[32 ];/* Determine motherboard version */ -if (ioread32 ((void __iomem *)CREG_MB_CONFIG ) & (1 <<28 )) +if (ioread32 ((const void __iomem *)CREG_MB_CONFIG ) & (1 <<28 )) mb_rev =3 ;/* HT-3 (rev3.0) */ else mb_rev =2 ;/* HT-2 (rev2.0) */
Signature · 1 line
2.7.4
PATCH 7/13 drm/mgag200: Constify ioreadX() iomem argument (as in generic implementation)
In reply to a message not in the archiveThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/gpu/drm/mgag200/mgag200_drv.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/gpu/drm/mgag200/mgag200_drv.h +2 -2
@@ -34,9 +34,9 @@#define MGAG200FB_CONN_LIMIT 1 -#define RREG8 (reg) ioread8(((void __iomem *)mdev->rmmio) + (reg)) +#define RREG8 (reg) ioread8(((const void __iomem *)mdev->rmmio) + (reg))#define WREG8 (reg, v) iowrite8(v, ((void __iomem *)mdev->rmmio) + (reg)) -#define RREG32 (reg) ioread32(((void __iomem *)mdev->rmmio) + (reg)) +#define RREG32 (reg) ioread32(((const void __iomem *)mdev->rmmio) + (reg))#define WREG32 (reg, v) iowrite32(v, ((void __iomem *)mdev->rmmio) + (reg))#define ATTR_INDEX 0x1fc0
Signature · 1 line
2.7.4
PATCH 8/13 drm/nouveau: Constify ioreadX() iomem argument (as in generic implementation)
In reply to a message not in the archiveThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/gpu/drm/nouveau/nouveau_bo.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/gpu/drm/nouveau/nouveau_bo.c +1 -1
@@ -613,7 +613,7 @@ nouveau_bo_rd32(struct nouveau_bo *nvbo, unsigned index) mem += index;if (is_iomem) -return ioread32_native ((void __force __iomem *)mem); +return ioread32_native ((const void __force __iomem *)mem);else return *mem; }
Signature · 1 line
2.7.4
PATCH 9/13 media: fsl-viu: Constify ioreadX() iomem argument (as in generic implementation)
In reply to a message not in the archiveThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/media/platform/fsl-viu.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/media/platform/fsl-viu.c +1 -1
@@ -34,7 +34,7 @@/* Allow building this driver with COMPILE_TEST */ #if !defined(CONFIG_PPC ) && !defined(CONFIG_MICROBLAZE )#define out_be32 (v, a) iowrite32be(a, (void __iomem *)v) -#define in_be32 (a) ioread32be((void __iomem *)a) +#define in_be32 (a) ioread32be((const void __iomem *)a)#endif #define BUFFER_TIMEOUT msecs_to_jiffies(500)/* 0.5 seconds */
Signature · 1 line
2.7.4
PATCH 10/13 net: wireless: ath5k: Constify ioreadX() iomem argument (as in generic implementation)
In reply to a message not in the archiveThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/net/wireless/ath/ath5k/ahb.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
drivers/net/wireless/ath/ath5k/ahb.c +5 -5
@@ -138,18 +138,18 @@ static int ath_ahb_probe(struct platform_device *pdev)if (bcfg->devid >=AR5K_SREV_AR2315_R6 ) {/* Enable WMAC AHB arbitration */ - reg =ioread32 ((void __iomem *)AR5K_AR2315_AHB_ARB_CTL ); + reg =ioread32 ((const void __iomem *)AR5K_AR2315_AHB_ARB_CTL ); reg |=AR5K_AR2315_AHB_ARB_CTL_WLAN ;iowrite32 (reg, (void __iomem *)AR5K_AR2315_AHB_ARB_CTL );/* Enable global WMAC swapping */ - reg =ioread32 ((void __iomem *)AR5K_AR2315_BYTESWAP ); + reg =ioread32 ((const void __iomem *)AR5K_AR2315_BYTESWAP ); reg |=AR5K_AR2315_BYTESWAP_WMAC ;iowrite32 (reg, (void __iomem *)AR5K_AR2315_BYTESWAP ); }else {/* Enable WMAC DMA access (assuming 5312 or 231x*/ /* TODO: check other platforms */ - reg =ioread32 ((void __iomem *)AR5K_AR5312_ENABLE ); + reg =ioread32 ((const void __iomem *)AR5K_AR5312_ENABLE );if (to_platform_device (ah->dev)->id ==0 ) reg |=AR5K_AR5312_ENABLE_WLAN0 ;else
@@ -202,12 +202,12 @@ static int ath_ahb_remove(struct platform_device *pdev)if (bcfg->devid >=AR5K_SREV_AR2315_R6 ) {/* Disable WMAC AHB arbitration */ - reg =ioread32 ((void __iomem *)AR5K_AR2315_AHB_ARB_CTL ); + reg =ioread32 ((const void __iomem *)AR5K_AR2315_AHB_ARB_CTL ); reg &= ~AR5K_AR2315_AHB_ARB_CTL_WLAN ;iowrite32 (reg, (void __iomem *)AR5K_AR2315_AHB_ARB_CTL ); }else {/*Stop DMA access */ - reg =ioread32 ((void __iomem *)AR5K_AR5312_ENABLE ); + reg =ioread32 ((const void __iomem *)AR5K_AR5312_ENABLE );if (to_platform_device (ah->dev)->id ==0 ) reg &= ~AR5K_AR5312_ENABLE_WLAN0 ;else
Signature · 1 line
2.7.4
PATCH 11/13 net: wireless: rtl818x: Constify ioreadX() iomem argument (as in generic implementation)
In reply to a message not in the archiveThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/net/wireless/realtek/rtl818x/rtl8180/rtl8180.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/net/wireless/realtek/rtl818x/rtl8180/rtl8180.h +3 -3
@@ -150,17 +150,17 @@ void rtl8180_write_phy(struct ieee80211_hw *dev, u8 addr, u32 data);void rtl8180_set_anaparam (struct rtl8180_priv *priv,u32 anaparam);void rtl8180_set_anaparam2 (struct rtl8180_priv *priv,u32 anaparam2); -static inline u8 rtl818x_ioread8 (struct rtl8180_priv *priv,u8 __iomem *addr) +static inline u8 rtl818x_ioread8 (struct rtl8180_priv *priv,const u8 __iomem *addr) {return ioread8 (addr); } -static inline u16 rtl818x_ioread16 (struct rtl8180_priv *priv,__le16 __iomem *addr) +static inline u16 rtl818x_ioread16 (struct rtl8180_priv *priv,const __le16 __iomem *addr) {return ioread16 (addr); } -static inline u32 rtl818x_ioread32 (struct rtl8180_priv *priv,__le32 __iomem *addr) +static inline u32 rtl818x_ioread32 (struct rtl8180_priv *priv,const __le32 __iomem *addr) {return ioread32 (addr); }
Signature · 1 line
2.7.4
PATCH 12/13 ntb: intel: Constify ioreadX() iomem argument (as in generic implementation)
In reply to a message not in the archiveThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/ntb/hw/intel/ntb_hw_gen1.c | 2 +- drivers/ntb/hw/intel/ntb_hw_gen3.h | 2 +- drivers/ntb/hw/intel/ntb_hw_intel.h | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-)
drivers/ntb/hw/intel/ntb_hw_gen1.c +1 -1
@@ -1202,7 +1202,7 @@ int intel_ntb_peer_spad_write(struct ntb_dev *ntb, int pidx, int sidx, ndev->peer_reg->spad); } -static u64 xeon_db_ioread (void __iomem *mmio) +static u64 xeon_db_ioread (const void __iomem *mmio) {return (u64 )ioread16 (mmio); }
drivers/ntb/hw/intel/ntb_hw_gen3.h +1 -1
@@ -91,7 +91,7 @@#define GEN3_DB_TOTAL_SHIFT 33#define GEN3_SPAD_COUNT 16 -static inline u64 gen3_db_ioread (void __iomem *mmio) +static inline u64 gen3_db_ioread (const void __iomem *mmio) {return ioread64 (mmio); }
drivers/ntb/hw/intel/ntb_hw_intel.h +1 -1
@@ -102,7 +102,7 @@ struct intel_ntb_dev;struct intel_ntb_reg {int (*poll_link)(struct intel_ntb_dev *ndev);int (*link_is_up)(struct intel_ntb_dev *ndev); -u64 (*db_ioread)(void __iomem *mmio); +u64 (*db_ioread)(const void __iomem *mmio);void (*db_iowrite)(u64 db_bits,void __iomem *mmio);unsigned long ntb_ctl;resource_size_t db_size;
Signature · 1 line
2.7.4
PATCH 13/13 virtio: pci: Constify ioreadX() iomem argument (as in generic implementation)
In reply to a message not in the archiveThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/virtio/virtio_pci_modern.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/virtio/virtio_pci_modern.c +3 -3
@@ -26,16 +26,16 @@* method, i.e. 32-bit accesses for 32-bit fields, 16-bit accesses * for 16-bit fields and 8-bit accesses for 8-bit fields. */ -static inline u8 vp_ioread8 (u8 __iomem *addr) +static inline u8 vp_ioread8 (const u8 __iomem *addr) {return ioread8 (addr); } -static inline u16 vp_ioread16 (__le16 __iomem *addr) +static inline u16 vp_ioread16 (const __le16 __iomem *addr) {return ioread16 (addr); } -static inline u32 vp_ioread32 (__le32 __iomem *addr) +static inline u32 vp_ioread32 (const __le32 __iomem *addr) {return ioread32 (addr); }
Signature · 1 line
2.7.4
PATCH 1/13 iomap: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- include/asm-generic/iomap.h | 22 +++++++++++----------- include/linux/io-64-nonatomic-hi-lo.h | 4 ++-- include/linux/io-64-nonatomic-lo-hi.h | 4 ++-- lib/iomap.c | 18 +++++++++--------- 4 files changed, 24 insertions(+), 24 deletions(-)
include/asm-generic/iomap.h +11 -11
@@ -26,14 +26,14 @@* in the low address range. Architectures for which this is not * true can't use this generic implementation. */ -extern unsigned int ioread8 (void __iomem *); -extern unsigned int ioread16 (void __iomem *); -extern unsigned int ioread16be (void __iomem *); -extern unsigned int ioread32 (void __iomem *); -extern unsigned int ioread32be (void __iomem *); +extern unsigned int ioread8 (const void __iomem *); +extern unsigned int ioread16 (const void __iomem *); +extern unsigned int ioread16be (const void __iomem *); +extern unsigned int ioread32 (const void __iomem *); +extern unsigned int ioread32be (const void __iomem *);#ifdef CONFIG_64BIT -extern u64 ioread64 (void __iomem *); -extern u64 ioread64be (void __iomem *); +extern u64 ioread64 (const void __iomem *); +extern u64 ioread64be (const void __iomem *);#endif #ifdef readq
@@ -41,10 +41,10 @@ extern u64 ioread64be(void __iomem *);#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); +extern u64 ioread64_lo_hi (const void __iomem *addr); +extern u64 ioread64_hi_lo (const void __iomem *addr); +extern u64 ioread64be_lo_hi (const void __iomem *addr); +extern u64 ioread64be_hi_lo (const void __iomem *addr);#endif extern void iowrite8 (u8 ,void __iomem *);
include/linux/io-64-nonatomic-hi-lo.h +2 -2
@@ -57,7 +57,7 @@ static inline void hi_lo_writeq_relaxed(__u64 val, volatile void __iomem *addr)#ifndef ioread64_hi_lo#define ioread64_hi_lo ioread64_hi_lo -static inline u64 ioread64_hi_lo (void __iomem *addr) +static inline u64 ioread64_hi_lo (const void __iomem *addr) {u32 low, high;
@@ -79,7 +79,7 @@ static inline void iowrite64_hi_lo(u64 val, void __iomem *addr)#ifndef ioread64be_hi_lo#define ioread64be_hi_lo ioread64be_hi_lo -static inline u64 ioread64be_hi_lo (void __iomem *addr) +static inline u64 ioread64be_hi_lo (const void __iomem *addr) {u32 low, high;
include/linux/io-64-nonatomic-lo-hi.h +2 -2
@@ -57,7 +57,7 @@ static inline void lo_hi_writeq_relaxed(__u64 val, volatile void __iomem *addr)#ifndef ioread64_lo_hi#define ioread64_lo_hi ioread64_lo_hi -static inline u64 ioread64_lo_hi (void __iomem *addr) +static inline u64 ioread64_lo_hi (const void __iomem *addr) {u32 low, high;
@@ -79,7 +79,7 @@ static inline void iowrite64_lo_hi(u64 val, void __iomem *addr)#ifndef ioread64be_lo_hi#define ioread64be_lo_hi ioread64be_lo_hi -static inline u64 ioread64be_lo_hi (void __iomem *addr) +static inline u64 ioread64be_lo_hi (const void __iomem *addr) {u32 low, high;
lib/iomap.c +9 -9
@@ -70,27 +70,27 @@ static void bad_io_access(unsigned long port, const char *access)#define mmio_read64be (addr) swab64(readq(addr))#endif -unsigned int ioread8 (void __iomem *addr) +unsigned int ioread8 (const void __iomem *addr) { IO_COND(addr, return inb(port), return readb(addr));return 0xff ; } -unsigned int ioread16 (void __iomem *addr) +unsigned int ioread16 (const void __iomem *addr) { IO_COND(addr, return inw(port), return readw(addr));return 0xffff ; } -unsigned int ioread16be (void __iomem *addr) +unsigned int ioread16be (const void __iomem *addr) { IO_COND(addr, return pio_read16be(port), return mmio_read16be(addr));return 0xffff ; } -unsigned int ioread32 (void __iomem *addr) +unsigned int ioread32 (const void __iomem *addr) { IO_COND(addr, return inl(port), return readl(addr));return 0xffffffff ; } -unsigned int ioread32be (void __iomem *addr) +unsigned int ioread32be (const void __iomem *addr) { IO_COND(addr, return pio_read32be(port), return mmio_read32be(addr));return 0xffffffff ;
@@ -142,26 +142,26 @@ static u64 pio_read64be_hi_lo(unsigned long port)return lo | (hi <<32 ); } -u64 ioread64_lo_hi (void __iomem *addr) +u64 ioread64_lo_hi (const void __iomem *addr) { IO_COND(addr, return pio_read64_lo_hi(port), return readq(addr));return 0xffffffffffffffffULL ; } -u64 ioread64_hi_lo (void __iomem *addr) +u64 ioread64_hi_lo (const void __iomem *addr) { IO_COND(addr, return pio_read64_hi_lo(port), return readq(addr));return 0xffffffffffffffffULL ; } -u64 ioread64be_lo_hi (void __iomem *addr) +u64 ioread64be_lo_hi (const void __iomem *addr) { IO_COND(addr, return pio_read64be_lo_hi(port), return mmio_read64be(addr));return 0xffffffffffffffffULL ; } -u64 ioread64be_hi_lo (void __iomem *addr) +u64 ioread64be_hi_lo (const void __iomem *addr) { IO_COND(addr, return pio_read64be_hi_lo(port), return mmio_read64be(addr));
Signature · 1 line
2.7.4
PATCH 2/13 alpha: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/alpha/include/asm/core_apecs.h | 6 +++--- arch/alpha/include/asm/core_cia.h | 6 +++--- arch/alpha/include/asm/core_lca.h | 6 +++--- arch/alpha/include/asm/core_marvel.h | 4 ++-- arch/alpha/include/asm/core_mcpcia.h | 6 +++--- arch/alpha/include/asm/core_t2.h | 2 +- arch/alpha/include/asm/io.h | 12 ++++++------ arch/alpha/include/asm/io_trivial.h | 16 ++++++++-------- arch/alpha/include/asm/jensen.h | 2 +- arch/alpha/include/asm/machvec.h | 6 +++--- arch/alpha/kernel/core_marvel.c | 2 +- arch/alpha/kernel/io.c | 6 +++--- 12 files changed, 37 insertions(+), 37 deletions(-)
arch/alpha/include/asm/core_apecs.h +3 -3
@@ -384,7 +384,7 @@ struct el_apecs_procdata } \ }while (0 ) -__EXTERN_INLINE unsigned int apecs_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int apecs_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -420,7 +420,7 @@ __EXTERN_INLINE void apecs_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int apecs_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int apecs_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -456,7 +456,7 @@ __EXTERN_INLINE void apecs_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int apecs_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int apecs_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (addr <APECS_DENSE_MEM )
arch/alpha/include/asm/core_cia.h +3 -3
@@ -342,7 +342,7 @@ struct el_CIA_sysdata_mcheck {#define vuip volatile unsigned int __force *#define vulp volatile unsigned long __force * -__EXTERN_INLINE unsigned int cia_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int cia_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -374,7 +374,7 @@ __EXTERN_INLINE void cia_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int cia_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int cia_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -404,7 +404,7 @@ __EXTERN_INLINE void cia_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int cia_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int cia_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (addr <CIA_DENSE_MEM )
arch/alpha/include/asm/core_lca.h +3 -3
@@ -230,7 +230,7 @@ union el_lca { }while (0 ) -__EXTERN_INLINE unsigned int lca_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int lca_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -266,7 +266,7 @@ __EXTERN_INLINE void lca_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int lca_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int lca_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -302,7 +302,7 @@ __EXTERN_INLINE void lca_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int lca_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int lca_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (addr <LCA_DENSE_MEM )
arch/alpha/include/asm/core_marvel.h +2 -2
@@ -332,10 +332,10 @@ struct io7 {#define vucp volatile unsigned char __force *#define vusp volatile unsigned short __force * -extern unsigned int marvel_ioread8 (void __iomem *); +extern unsigned int marvel_ioread8 (const void __iomem *);extern void marvel_iowrite8 (u8 b,void __iomem *); -__EXTERN_INLINE unsigned int marvel_ioread16(void __iomem *addr) +__EXTERN_INLINE unsigned int marvel_ioread16(const void __iomem *addr) {return __kernel_ldwu (*(vusp )addr); }
arch/alpha/include/asm/core_mcpcia.h +3 -3
@@ -267,7 +267,7 @@ extern inline int __mcpcia_is_mmio(unsigned long addr)return (addr &0x80000000UL ) =0 ; } -__EXTERN_INLINE unsigned int mcpcia_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int mcpcia_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long )xaddr &MCPCIA_MEM_MASK ;unsigned long hose = (unsigned long )xaddr & ~MCPCIA_MEM_MASK ;
@@ -291,7 +291,7 @@ __EXTERN_INLINE void mcpcia_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + hose +0x00 ) = w; } -__EXTERN_INLINE unsigned int mcpcia_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int mcpcia_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long )xaddr &MCPCIA_MEM_MASK ;unsigned long hose = (unsigned long )xaddr & ~MCPCIA_MEM_MASK ;
@@ -315,7 +315,7 @@ __EXTERN_INLINE void mcpcia_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + hose +0x08 ) = w; } -__EXTERN_INLINE unsigned int mcpcia_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int mcpcia_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long )xaddr;
arch/alpha/include/asm/core_t2.h +1 -1
@@ -572,7 +572,7 @@ __EXTERN_INLINE int t2_is_mmio(const volatile void __iomem *addr)it doesn't make sense to merge the pio and mmio routines. */ #define IOPORT (OS ,NS ) \ -__EXTERN_INLINE unsigned int t2_ioread##NS(void __iomem *xaddr) \ +__EXTERN_INLINE unsigned int t2_ioread##NS(const void __iomem *xaddr) \ { \ if (t2_is_mmio(xaddr)) \ return t2_read##OS(xaddr); \
arch/alpha/include/asm/io.h +6 -6
@@ -151,9 +151,9 @@ static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr) \ alpha_mv.mv_##NAME(b, addr); \ } -REMAP1(unsigned int, ioread8, /**/) -REMAP1(unsigned int, ioread16, /**/) -REMAP1(unsigned int, ioread32, /**/) +REMAP1(unsigned int, ioread8, const) +REMAP1(unsigned int, ioread16, const) +REMAP1(unsigned int, ioread32, const) REMAP1(u8, readb, const volatile) REMAP1(u16, readw, const volatile) REMAP1(u32, readl, const volatile)
@@ -308,14 +308,14 @@ static inline int __is_mmio(const volatile void __iomem *addr)*/ #if IO_CONCAT (__IO_PREFIX,trivial_io_bw) -extern inline unsigned int ioread8 (void __iomem *addr) +extern inline unsigned int ioread8 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread8)(addr);mb ();return ret; } -extern inline unsigned int ioread16 (void __iomem *addr) +extern inline unsigned int ioread16 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread16)(addr);mb ();
@@ -356,7 +356,7 @@ extern inline void outw(u16 b, unsigned long port)#endif #if IO_CONCAT (__IO_PREFIX,trivial_io_lq) -extern inline unsigned int ioread32 (void __iomem *addr) +extern inline unsigned int ioread32 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread32)(addr);mb ();
arch/alpha/include/asm/io_trivial.h +8 -8
@@ -7,15 +7,15 @@#if IO_CONCAT (__IO_PREFIX,trivial_io_bw) __EXTERN_INLINE unsigned int -IO_CONCAT (__IO_PREFIX ,ioread8 )(void __iomem *a) +IO_CONCAT (__IO_PREFIX ,ioread8 )(const void __iomem *a) { -return __kernel_ldbu (*(volatile u8 __force *)a); +return __kernel_ldbu (*(const volatile u8 __force *)a); } __EXTERN_INLINE unsigned int -IO_CONCAT (__IO_PREFIX ,ioread16 )(void __iomem *a) +IO_CONCAT (__IO_PREFIX ,ioread16 )(const void __iomem *a) { -return __kernel_ldwu (*(volatile u16 __force *)a); +return __kernel_ldwu (*(const volatile u16 __force *)a); }__EXTERN_INLINE void
@@ -33,9 +33,9 @@ IO_CONCAT(__IO_PREFIX,iowrite16)(u16 b, void __iomem *a)#if IO_CONCAT (__IO_PREFIX,trivial_io_lq) __EXTERN_INLINE unsigned int -IO_CONCAT (__IO_PREFIX ,ioread32 )(void __iomem *a) +IO_CONCAT (__IO_PREFIX ,ioread32 )(const void __iomem *a) { -return *(volatile u32 __force *)a; +return *(const volatile u32 __force *)a; }__EXTERN_INLINE void
@@ -73,14 +73,14 @@ IO_CONCAT(__IO_PREFIX,writew)(u16 b, volatile void __iomem *a) __EXTERN_INLINE u8IO_CONCAT (__IO_PREFIX ,readb )(const volatile void __iomem *a) { -void __iomem *addr = (void __iomem *)a; +const void __iomem *addr = (const void __iomem *)a;return IO_CONCAT (__IO_PREFIX,ioread8)(addr); } __EXTERN_INLINE u16IO_CONCAT (__IO_PREFIX ,readw )(const volatile void __iomem *a) { -void __iomem *addr = (void __iomem *)a; +const void __iomem *addr = (const void __iomem *)a;return IO_CONCAT (__IO_PREFIX,ioread16)(addr); }
arch/alpha/include/asm/jensen.h +1 -1
@@ -305,7 +305,7 @@ __EXTERN_INLINE int jensen_is_mmio(const volatile void __iomem *addr)that it doesn't make sense to merge them. */ #define IOPORT (OS ,NS ) \ -__EXTERN_INLINE unsigned int jensen_ioread##NS(void __iomem *xaddr) \ +__EXTERN_INLINE unsigned int jensen_ioread##NS(const void __iomem *xaddr) \ { \ if (jensen_is_mmio(xaddr)) \ return jensen_read##OS(xaddr - 0x100000000ul); \
arch/alpha/include/asm/machvec.h +3 -3
@@ -46,9 +46,9 @@ struct alpha_machine_vectorvoid (*mv_pci_tbi)(struct pci_controller *hose,dma_addr_t start,dma_addr_t end); -unsigned int (*mv_ioread8)(void __iomem *); -unsigned int (*mv_ioread16)(void __iomem *); -unsigned int (*mv_ioread32)(void __iomem *); +unsigned int (*mv_ioread8)(const void __iomem *); +unsigned int (*mv_ioread16)(const void __iomem *); +unsigned int (*mv_ioread32)(const void __iomem *);void (*mv_iowrite8)(u8 ,void __iomem *);void (*mv_iowrite16)(u16 ,void __iomem *);
arch/alpha/kernel/core_marvel.c +1 -1
@@ -807,7 +807,7 @@ void __iomem *marvel_ioportmap (unsigned long addr) }unsigned int -marvel_ioread8 (void __iomem *xaddr) +marvel_ioread8 (const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (__marvel_is_port_kbd (addr))
arch/alpha/kernel/io.c +3 -3
@@ -14,21 +14,21 @@"generic", which bumps through the machine vector. */ unsigned int -ioread8 (void __iomem *addr) +ioread8 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread8)(addr);mb ();return ret; } -unsigned int ioread16 (void __iomem *addr) +unsigned int ioread16 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread16)(addr);mb ();return ret; } -unsigned int ioread32 (void __iomem *addr) +unsigned int ioread32 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread32)(addr);mb ();
Signature · 1 line
2.7.4
Re: [RFT 02/13] alpha: Constify ioreadX() iomem argument (as in generic implementation)
Hi Krzysztof,
Quoted 12 lines · Krzysztof Kozlowski
The
ioreadX()helpers have inconsistent interface. On some architectures void*__iomemaddress argument is a pointer to const, on some not.Implementations of
ioreadX()do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.Signed-off-by Krzysztof Kozlowski <[email protected]>
arch/alpha/include/asm/io.h static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr) \ · line 156
Quoted 9 lines
arch/alpha/include/asm/io.h +3
-3@@ -151,9 +151,9 @@ static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr) \ alpha_mv.mv_##NAME(b, addr); \ } -REMAP1(unsigned int, ioread8, /**/) -REMAP1(unsigned int, ioread16, /**/) -REMAP1(unsigned int, ioread32, /**/) +REMAP1(unsigned int, ioread8, const) +REMAP1(unsigned int, ioread16, const) +REMAP1(unsigned int, ioread32, const)
If these would become "const volatile", there would no longer be a need for the last parameter of the REMAP1() macro.
arch/alpha/include/asm/io.h static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr) \ · line 159
Quoted 3 lines
arch/alpha/include/asm/io.h +0
-0REMAP1(u8, readb, const volatile) REMAP1(u16, readw, const volatile) REMAP1(u32, readl, const volatile)
Same for REMAP2() macro below, for iowrite*().
Gr{oetje,eeting}s,
Geert
Signature · 5 lines
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: [RFT 02/13] alpha: Constify ioreadX() iomem argument (as in generic implementation)
Quoted 28 lines · Geert Uytterhoeven
Hi Krzysztof,
Quoted 12 lines · Krzysztof Kozlowski
The
ioreadX()helpers have inconsistent interface. On some architectures void*__iomemaddress argument is a pointer to const, on some not.Implementations of
ioreadX()do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.Signed-off-by Krzysztof Kozlowski <[email protected]>arch/alpha/include/asm/io.h static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr) \ · line 156
Quoted 9 lines
arch/alpha/include/asm/io.h +3
-3@@ -151,9 +151,9 @@ static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr) \ alpha_mv.mv_##NAME(b, addr); \ } -REMAP1(unsigned int, ioread8, /**/) -REMAP1(unsigned int, ioread16, /**/) -REMAP1(unsigned int, ioread32, /**/) +REMAP1(unsigned int, ioread8, const) +REMAP1(unsigned int, ioread16, const) +REMAP1(unsigned int, ioread32, const)If these would become "const volatile", there would no longer be a need for the last parameter of the
REMAP1()macro.
Quoted 5 lines
arch/alpha/include/asm/io.h static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr) \ · line 159
Quoted 3 lines
arch/alpha/include/asm/io.h +0
-0REMAP1(u8, readb, const volatile) REMAP1(u16, readw, const volatile) REMAP1(u32, readl, const volatile)Same for
REMAP2()macro below, for iowrite*().
Good point, thanks!
Best regards,
Krzysztof
Re: [RFT 02/13] alpha: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Geert UytterhoevenQuoted 28 lines · Geert Uytterhoeven
Hi Krzysztof,
Quoted 12 lines · Krzysztof Kozlowski
The
ioreadX()helpers have inconsistent interface. On some architectures void*__iomemaddress argument is a pointer to const, on some not.Implementations of
ioreadX()do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.Signed-off-by Krzysztof Kozlowski <[email protected]>arch/alpha/include/asm/io.h static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr) \ · line 156
Quoted 9 lines
arch/alpha/include/asm/io.h +3
-3@@ -151,9 +151,9 @@ static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr) \ alpha_mv.mv_##NAME(b, addr); \ } -REMAP1(unsigned int, ioread8, /**/) -REMAP1(unsigned int, ioread16, /**/) -REMAP1(unsigned int, ioread32, /**/) +REMAP1(unsigned int, ioread8, const) +REMAP1(unsigned int, ioread16, const) +REMAP1(unsigned int, ioread32, const)If these would become "const volatile", there would no longer be a need for the last parameter of the
REMAP1()macro.
Quoted 5 lines
arch/alpha/include/asm/io.h static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr) \ · line 159
Quoted 3 lines
arch/alpha/include/asm/io.h +0
-0REMAP1(u8, readb, const volatile) REMAP1(u16, readw, const volatile) REMAP1(u32, readl, const volatile)Same for
REMAP2()macro below, for iowrite*().
Good point, thanks!
Best regards,
Krzysztof
Re: [RFT 02/13] alpha: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiHi Krzysztof,
Quoted 12 lines · Krzysztof Kozlowski
The
ioreadX()helpers have inconsistent interface. On some architectures void*__iomemaddress argument is a pointer to const, on some not.Implementations of
ioreadX()do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.Signed-off-by Krzysztof Kozlowski <[email protected]>
arch/alpha/include/asm/io.h static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr) \ · line 156
Quoted 9 lines
arch/alpha/include/asm/io.h +3
-3@@ -151,9 +151,9 @@ static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr) \ alpha_mv.mv_##NAME(b, addr); \ } -REMAP1(unsigned int, ioread8, /**/) -REMAP1(unsigned int, ioread16, /**/) -REMAP1(unsigned int, ioread32, /**/) +REMAP1(unsigned int, ioread8, const) +REMAP1(unsigned int, ioread16, const) +REMAP1(unsigned int, ioread32, const)
If these would become "const volatile", there would no longer be a need for the last parameter of the REMAP1() macro.
arch/alpha/include/asm/io.h static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr) \ · line 159
Quoted 3 lines
arch/alpha/include/asm/io.h +0
-0REMAP1(u8, readb, const volatile) REMAP1(u16, readw, const volatile) REMAP1(u32, readl, const volatile)
Same for REMAP2() macro below, for iowrite*().
Gr{oetje,eeting}s,
Geert
Signature · 5 lines
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
PATCH 2/13 alpha: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/alpha/include/asm/core_apecs.h | 6 +++--- arch/alpha/include/asm/core_cia.h | 6 +++--- arch/alpha/include/asm/core_lca.h | 6 +++--- arch/alpha/include/asm/core_marvel.h | 4 ++-- arch/alpha/include/asm/core_mcpcia.h | 6 +++--- arch/alpha/include/asm/core_t2.h | 2 +- arch/alpha/include/asm/io.h | 12 ++++++------ arch/alpha/include/asm/io_trivial.h | 16 ++++++++-------- arch/alpha/include/asm/jensen.h | 2 +- arch/alpha/include/asm/machvec.h | 6 +++--- arch/alpha/kernel/core_marvel.c | 2 +- arch/alpha/kernel/io.c | 6 +++--- 12 files changed, 37 insertions(+), 37 deletions(-)
arch/alpha/include/asm/core_apecs.h +3 -3
@@ -384,7 +384,7 @@ struct el_apecs_procdata } \ }while (0 ) -__EXTERN_INLINE unsigned int apecs_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int apecs_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -420,7 +420,7 @@ __EXTERN_INLINE void apecs_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int apecs_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int apecs_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -456,7 +456,7 @@ __EXTERN_INLINE void apecs_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int apecs_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int apecs_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (addr <APECS_DENSE_MEM )
arch/alpha/include/asm/core_cia.h +3 -3
@@ -342,7 +342,7 @@ struct el_CIA_sysdata_mcheck {#define vuip volatile unsigned int __force *#define vulp volatile unsigned long __force * -__EXTERN_INLINE unsigned int cia_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int cia_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -374,7 +374,7 @@ __EXTERN_INLINE void cia_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int cia_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int cia_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -404,7 +404,7 @@ __EXTERN_INLINE void cia_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int cia_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int cia_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (addr <CIA_DENSE_MEM )
arch/alpha/include/asm/core_lca.h +3 -3
@@ -230,7 +230,7 @@ union el_lca { }while (0 ) -__EXTERN_INLINE unsigned int lca_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int lca_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -266,7 +266,7 @@ __EXTERN_INLINE void lca_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int lca_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int lca_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -302,7 +302,7 @@ __EXTERN_INLINE void lca_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int lca_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int lca_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (addr <LCA_DENSE_MEM )
arch/alpha/include/asm/core_marvel.h +2 -2
@@ -332,10 +332,10 @@ struct io7 {#define vucp volatile unsigned char __force *#define vusp volatile unsigned short __force * -extern unsigned int marvel_ioread8 (void __iomem *); +extern unsigned int marvel_ioread8 (const void __iomem *);extern void marvel_iowrite8 (u8 b,void __iomem *); -__EXTERN_INLINE unsigned int marvel_ioread16(void __iomem *addr) +__EXTERN_INLINE unsigned int marvel_ioread16(const void __iomem *addr) {return __kernel_ldwu (*(vusp )addr); }
arch/alpha/include/asm/core_mcpcia.h +3 -3
@@ -267,7 +267,7 @@ extern inline int __mcpcia_is_mmio(unsigned long addr)return (addr &0x80000000UL ) ==0 ; } -__EXTERN_INLINE unsigned int mcpcia_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int mcpcia_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long )xaddr &MCPCIA_MEM_MASK ;unsigned long hose = (unsigned long )xaddr & ~MCPCIA_MEM_MASK ;
@@ -291,7 +291,7 @@ __EXTERN_INLINE void mcpcia_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + hose +0x00 ) = w; } -__EXTERN_INLINE unsigned int mcpcia_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int mcpcia_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long )xaddr &MCPCIA_MEM_MASK ;unsigned long hose = (unsigned long )xaddr & ~MCPCIA_MEM_MASK ;
@@ -315,7 +315,7 @@ __EXTERN_INLINE void mcpcia_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + hose +0x08 ) = w; } -__EXTERN_INLINE unsigned int mcpcia_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int mcpcia_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long )xaddr;
arch/alpha/include/asm/core_t2.h +1 -1
@@ -572,7 +572,7 @@ __EXTERN_INLINE int t2_is_mmio(const volatile void __iomem *addr)it doesn't make sense to merge the pio and mmio routines. */ #define IOPORT (OS ,NS ) \ -__EXTERN_INLINE unsigned int t2_ioread##NS(void __iomem *xaddr) \ +__EXTERN_INLINE unsigned int t2_ioread##NS(const void __iomem *xaddr) \ { \ if (t2_is_mmio(xaddr)) \ return t2_read##OS(xaddr); \
arch/alpha/include/asm/io.h +6 -6
@@ -151,9 +151,9 @@ static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr) \ alpha_mv.mv_##NAME(b, addr); \ } -REMAP1(unsigned int, ioread8, /**/) -REMAP1(unsigned int, ioread16, /**/) -REMAP1(unsigned int, ioread32, /**/) +REMAP1(unsigned int, ioread8, const) +REMAP1(unsigned int, ioread16, const) +REMAP1(unsigned int, ioread32, const) REMAP1(u8, readb, const volatile) REMAP1(u16, readw, const volatile) REMAP1(u32, readl, const volatile)
@@ -308,14 +308,14 @@ static inline int __is_mmio(const volatile void __iomem *addr)*/ #if IO_CONCAT (__IO_PREFIX,trivial_io_bw) -extern inline unsigned int ioread8 (void __iomem *addr) +extern inline unsigned int ioread8 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread8)(addr);mb ();return ret; } -extern inline unsigned int ioread16 (void __iomem *addr) +extern inline unsigned int ioread16 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread16)(addr);mb ();
@@ -356,7 +356,7 @@ extern inline void outw(u16 b, unsigned long port)#endif #if IO_CONCAT (__IO_PREFIX,trivial_io_lq) -extern inline unsigned int ioread32 (void __iomem *addr) +extern inline unsigned int ioread32 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread32)(addr);mb ();
arch/alpha/include/asm/io_trivial.h +8 -8
@@ -7,15 +7,15 @@#if IO_CONCAT (__IO_PREFIX,trivial_io_bw) __EXTERN_INLINE unsigned int -IO_CONCAT (__IO_PREFIX ,ioread8 )(void __iomem *a) +IO_CONCAT (__IO_PREFIX ,ioread8 )(const void __iomem *a) { -return __kernel_ldbu (*(volatile u8 __force *)a); +return __kernel_ldbu (*(const volatile u8 __force *)a); } __EXTERN_INLINE unsigned int -IO_CONCAT (__IO_PREFIX ,ioread16 )(void __iomem *a) +IO_CONCAT (__IO_PREFIX ,ioread16 )(const void __iomem *a) { -return __kernel_ldwu (*(volatile u16 __force *)a); +return __kernel_ldwu (*(const volatile u16 __force *)a); }__EXTERN_INLINE void
@@ -33,9 +33,9 @@ IO_CONCAT(__IO_PREFIX,iowrite16)(u16 b, void __iomem *a)#if IO_CONCAT (__IO_PREFIX,trivial_io_lq) __EXTERN_INLINE unsigned int -IO_CONCAT (__IO_PREFIX ,ioread32 )(void __iomem *a) +IO_CONCAT (__IO_PREFIX ,ioread32 )(const void __iomem *a) { -return *(volatile u32 __force *)a; +return *(const volatile u32 __force *)a; }__EXTERN_INLINE void
@@ -73,14 +73,14 @@ IO_CONCAT(__IO_PREFIX,writew)(u16 b, volatile void __iomem *a) __EXTERN_INLINE u8IO_CONCAT (__IO_PREFIX ,readb )(const volatile void __iomem *a) { -void __iomem *addr = (void __iomem *)a; +const void __iomem *addr = (const void __iomem *)a;return IO_CONCAT (__IO_PREFIX,ioread8)(addr); } __EXTERN_INLINE u16IO_CONCAT (__IO_PREFIX ,readw )(const volatile void __iomem *a) { -void __iomem *addr = (void __iomem *)a; +const void __iomem *addr = (const void __iomem *)a;return IO_CONCAT (__IO_PREFIX,ioread16)(addr); }
arch/alpha/include/asm/jensen.h +1 -1
@@ -305,7 +305,7 @@ __EXTERN_INLINE int jensen_is_mmio(const volatile void __iomem *addr)that it doesn't make sense to merge them. */ #define IOPORT (OS ,NS ) \ -__EXTERN_INLINE unsigned int jensen_ioread##NS(void __iomem *xaddr) \ +__EXTERN_INLINE unsigned int jensen_ioread##NS(const void __iomem *xaddr) \ { \ if (jensen_is_mmio(xaddr)) \ return jensen_read##OS(xaddr - 0x100000000ul); \
arch/alpha/include/asm/machvec.h +3 -3
@@ -46,9 +46,9 @@ struct alpha_machine_vectorvoid (*mv_pci_tbi)(struct pci_controller *hose,dma_addr_t start,dma_addr_t end); -unsigned int (*mv_ioread8)(void __iomem *); -unsigned int (*mv_ioread16)(void __iomem *); -unsigned int (*mv_ioread32)(void __iomem *); +unsigned int (*mv_ioread8)(const void __iomem *); +unsigned int (*mv_ioread16)(const void __iomem *); +unsigned int (*mv_ioread32)(const void __iomem *);void (*mv_iowrite8)(u8 ,void __iomem *);void (*mv_iowrite16)(u16 ,void __iomem *);
arch/alpha/kernel/core_marvel.c +1 -1
@@ -807,7 +807,7 @@ void __iomem *marvel_ioportmap (unsigned long addr) }unsigned int -marvel_ioread8 (void __iomem *xaddr) +marvel_ioread8 (const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (__marvel_is_port_kbd (addr))
arch/alpha/kernel/io.c +3 -3
@@ -14,21 +14,21 @@"generic", which bumps through the machine vector. */ unsigned int -ioread8 (void __iomem *addr) +ioread8 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread8)(addr);mb ();return ret; } -unsigned int ioread16 (void __iomem *addr) +unsigned int ioread16 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread16)(addr);mb ();return ret; } -unsigned int ioread32 (void __iomem *addr) +unsigned int ioread32 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread32)(addr);mb ();
Signature · 1 line
2.7.4
PATCH 2/13 sh: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/sh/kernel/iomap.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
arch/sh/kernel/iomap.c +5 -5
@@ -8,31 +8,31 @@#include <linux/module.h> #include <linux/io.h> -unsigned int ioread8 (void __iomem *addr) +unsigned int ioread8 (const void __iomem *addr) {return readb (addr); }EXPORT_SYMBOL (ioread8); -unsigned int ioread16 (void __iomem *addr) +unsigned int ioread16 (const void __iomem *addr) {return readw (addr); }EXPORT_SYMBOL (ioread16); -unsigned int ioread16be (void __iomem *addr) +unsigned int ioread16be (const void __iomem *addr) {return be16_to_cpu (__raw_readw (addr)); }EXPORT_SYMBOL (ioread16be); -unsigned int ioread32 (void __iomem *addr) +unsigned int ioread32 (const void __iomem *addr) {return readl (addr); }EXPORT_SYMBOL (ioread32); -unsigned int ioread32be (void __iomem *addr) +unsigned int ioread32be (const void __iomem *addr) {return be32_to_cpu (__raw_readl (addr)); }
Signature · 1 line
2.7.4
PATCH 2/13 sh: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/sh/kernel/iomap.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
arch/sh/kernel/iomap.c +5 -5
@@ -8,31 +8,31 @@#include <linux/module.h> #include <linux/io.h> -unsigned int ioread8 (void __iomem *addr) +unsigned int ioread8 (const void __iomem *addr) {return readb (addr); }EXPORT_SYMBOL (ioread8); -unsigned int ioread16 (void __iomem *addr) +unsigned int ioread16 (const void __iomem *addr) {return readw (addr); }EXPORT_SYMBOL (ioread16); -unsigned int ioread16be (void __iomem *addr) +unsigned int ioread16be (const void __iomem *addr) {return be16_to_cpu (__raw_readw (addr)); }EXPORT_SYMBOL (ioread16be); -unsigned int ioread32 (void __iomem *addr) +unsigned int ioread32 (const void __iomem *addr) {return readl (addr); }EXPORT_SYMBOL (ioread32); -unsigned int ioread32be (void __iomem *addr) +unsigned int ioread32be (const void __iomem *addr) {return be32_to_cpu (__raw_readl (addr)); }
Signature · 1 line
2.7.4
PATCH 3/13 alpha: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/alpha/include/asm/core_apecs.h | 6 +++--- arch/alpha/include/asm/core_cia.h | 6 +++--- arch/alpha/include/asm/core_lca.h | 6 +++--- arch/alpha/include/asm/core_marvel.h | 4 ++-- arch/alpha/include/asm/core_mcpcia.h | 6 +++--- arch/alpha/include/asm/core_t2.h | 2 +- arch/alpha/include/asm/io.h | 12 ++++++------ arch/alpha/include/asm/io_trivial.h | 16 ++++++++-------- arch/alpha/include/asm/jensen.h | 2 +- arch/alpha/include/asm/machvec.h | 6 +++--- arch/alpha/kernel/core_marvel.c | 2 +- arch/alpha/kernel/io.c | 6 +++--- 12 files changed, 37 insertions(+), 37 deletions(-)
arch/alpha/include/asm/core_apecs.h +3 -3
@@ -384,7 +384,7 @@ struct el_apecs_procdata } \ }while (0 ) -__EXTERN_INLINE unsigned int apecs_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int apecs_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -420,7 +420,7 @@ __EXTERN_INLINE void apecs_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int apecs_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int apecs_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -456,7 +456,7 @@ __EXTERN_INLINE void apecs_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int apecs_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int apecs_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (addr <APECS_DENSE_MEM )
arch/alpha/include/asm/core_cia.h +3 -3
@@ -342,7 +342,7 @@ struct el_CIA_sysdata_mcheck {#define vuip volatile unsigned int __force *#define vulp volatile unsigned long __force * -__EXTERN_INLINE unsigned int cia_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int cia_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -374,7 +374,7 @@ __EXTERN_INLINE void cia_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int cia_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int cia_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -404,7 +404,7 @@ __EXTERN_INLINE void cia_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int cia_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int cia_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (addr <CIA_DENSE_MEM )
arch/alpha/include/asm/core_lca.h +3 -3
@@ -230,7 +230,7 @@ union el_lca { }while (0 ) -__EXTERN_INLINE unsigned int lca_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int lca_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -266,7 +266,7 @@ __EXTERN_INLINE void lca_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int lca_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int lca_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -302,7 +302,7 @@ __EXTERN_INLINE void lca_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int lca_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int lca_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (addr <LCA_DENSE_MEM )
arch/alpha/include/asm/core_marvel.h +2 -2
@@ -332,10 +332,10 @@ struct io7 {#define vucp volatile unsigned char __force *#define vusp volatile unsigned short __force * -extern unsigned int marvel_ioread8 (void __iomem *); +extern unsigned int marvel_ioread8 (const void __iomem *);extern void marvel_iowrite8 (u8 b,void __iomem *); -__EXTERN_INLINE unsigned int marvel_ioread16(void __iomem *addr) +__EXTERN_INLINE unsigned int marvel_ioread16(const void __iomem *addr) {return __kernel_ldwu (*(vusp )addr); }
arch/alpha/include/asm/core_mcpcia.h +3 -3
@@ -267,7 +267,7 @@ extern inline int __mcpcia_is_mmio(unsigned long addr)return (addr &0x80000000UL ) =0 ; } -__EXTERN_INLINE unsigned int mcpcia_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int mcpcia_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long )xaddr &MCPCIA_MEM_MASK ;unsigned long hose = (unsigned long )xaddr & ~MCPCIA_MEM_MASK ;
@@ -291,7 +291,7 @@ __EXTERN_INLINE void mcpcia_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + hose +0x00 ) = w; } -__EXTERN_INLINE unsigned int mcpcia_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int mcpcia_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long )xaddr &MCPCIA_MEM_MASK ;unsigned long hose = (unsigned long )xaddr & ~MCPCIA_MEM_MASK ;
@@ -315,7 +315,7 @@ __EXTERN_INLINE void mcpcia_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + hose +0x08 ) = w; } -__EXTERN_INLINE unsigned int mcpcia_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int mcpcia_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long )xaddr;
arch/alpha/include/asm/core_t2.h +1 -1
@@ -572,7 +572,7 @@ __EXTERN_INLINE int t2_is_mmio(const volatile void __iomem *addr)it doesn't make sense to merge the pio and mmio routines. */ #define IOPORT (OS ,NS ) \ -__EXTERN_INLINE unsigned int t2_ioread##NS(void __iomem *xaddr) \ +__EXTERN_INLINE unsigned int t2_ioread##NS(const void __iomem *xaddr) \ { \ if (t2_is_mmio(xaddr)) \ return t2_read##OS(xaddr); \
arch/alpha/include/asm/io.h +6 -6
@@ -151,9 +151,9 @@ static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr) \ alpha_mv.mv_##NAME(b, addr); \ } -REMAP1(unsigned int, ioread8, /**/) -REMAP1(unsigned int, ioread16, /**/) -REMAP1(unsigned int, ioread32, /**/) +REMAP1(unsigned int, ioread8, const) +REMAP1(unsigned int, ioread16, const) +REMAP1(unsigned int, ioread32, const) REMAP1(u8, readb, const volatile) REMAP1(u16, readw, const volatile) REMAP1(u32, readl, const volatile)
@@ -308,14 +308,14 @@ static inline int __is_mmio(const volatile void __iomem *addr)*/ #if IO_CONCAT (__IO_PREFIX,trivial_io_bw) -extern inline unsigned int ioread8 (void __iomem *addr) +extern inline unsigned int ioread8 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread8)(addr);mb ();return ret; } -extern inline unsigned int ioread16 (void __iomem *addr) +extern inline unsigned int ioread16 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread16)(addr);mb ();
@@ -356,7 +356,7 @@ extern inline void outw(u16 b, unsigned long port)#endif #if IO_CONCAT (__IO_PREFIX,trivial_io_lq) -extern inline unsigned int ioread32 (void __iomem *addr) +extern inline unsigned int ioread32 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread32)(addr);mb ();
arch/alpha/include/asm/io_trivial.h +8 -8
@@ -7,15 +7,15 @@#if IO_CONCAT (__IO_PREFIX,trivial_io_bw) __EXTERN_INLINE unsigned int -IO_CONCAT (__IO_PREFIX ,ioread8 )(void __iomem *a) +IO_CONCAT (__IO_PREFIX ,ioread8 )(const void __iomem *a) { -return __kernel_ldbu (*(volatile u8 __force *)a); +return __kernel_ldbu (*(const volatile u8 __force *)a); } __EXTERN_INLINE unsigned int -IO_CONCAT (__IO_PREFIX ,ioread16 )(void __iomem *a) +IO_CONCAT (__IO_PREFIX ,ioread16 )(const void __iomem *a) { -return __kernel_ldwu (*(volatile u16 __force *)a); +return __kernel_ldwu (*(const volatile u16 __force *)a); }__EXTERN_INLINE void
@@ -33,9 +33,9 @@ IO_CONCAT(__IO_PREFIX,iowrite16)(u16 b, void __iomem *a)#if IO_CONCAT (__IO_PREFIX,trivial_io_lq) __EXTERN_INLINE unsigned int -IO_CONCAT (__IO_PREFIX ,ioread32 )(void __iomem *a) +IO_CONCAT (__IO_PREFIX ,ioread32 )(const void __iomem *a) { -return *(volatile u32 __force *)a; +return *(const volatile u32 __force *)a; }__EXTERN_INLINE void
@@ -73,14 +73,14 @@ IO_CONCAT(__IO_PREFIX,writew)(u16 b, volatile void __iomem *a) __EXTERN_INLINE u8IO_CONCAT (__IO_PREFIX ,readb )(const volatile void __iomem *a) { -void __iomem *addr = (void __iomem *)a; +const void __iomem *addr = (const void __iomem *)a;return IO_CONCAT (__IO_PREFIX,ioread8)(addr); } __EXTERN_INLINE u16IO_CONCAT (__IO_PREFIX ,readw )(const volatile void __iomem *a) { -void __iomem *addr = (void __iomem *)a; +const void __iomem *addr = (const void __iomem *)a;return IO_CONCAT (__IO_PREFIX,ioread16)(addr); }
arch/alpha/include/asm/jensen.h +1 -1
@@ -305,7 +305,7 @@ __EXTERN_INLINE int jensen_is_mmio(const volatile void __iomem *addr)that it doesn't make sense to merge them. */ #define IOPORT (OS ,NS ) \ -__EXTERN_INLINE unsigned int jensen_ioread##NS(void __iomem *xaddr) \ +__EXTERN_INLINE unsigned int jensen_ioread##NS(const void __iomem *xaddr) \ { \ if (jensen_is_mmio(xaddr)) \ return jensen_read##OS(xaddr - 0x100000000ul); \
arch/alpha/include/asm/machvec.h +3 -3
@@ -46,9 +46,9 @@ struct alpha_machine_vectorvoid (*mv_pci_tbi)(struct pci_controller *hose,dma_addr_t start,dma_addr_t end); -unsigned int (*mv_ioread8)(void __iomem *); -unsigned int (*mv_ioread16)(void __iomem *); -unsigned int (*mv_ioread32)(void __iomem *); +unsigned int (*mv_ioread8)(const void __iomem *); +unsigned int (*mv_ioread16)(const void __iomem *); +unsigned int (*mv_ioread32)(const void __iomem *);void (*mv_iowrite8)(u8 ,void __iomem *);void (*mv_iowrite16)(u16 ,void __iomem *);
arch/alpha/kernel/core_marvel.c +1 -1
@@ -807,7 +807,7 @@ void __iomem *marvel_ioportmap (unsigned long addr) }unsigned int -marvel_ioread8 (void __iomem *xaddr) +marvel_ioread8 (const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (__marvel_is_port_kbd (addr))
arch/alpha/kernel/io.c +3 -3
@@ -14,21 +14,21 @@"generic", which bumps through the machine vector. */ unsigned int -ioread8 (void __iomem *addr) +ioread8 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread8)(addr);mb ();return ret; } -unsigned int ioread16 (void __iomem *addr) +unsigned int ioread16 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread16)(addr);mb ();return ret; } -unsigned int ioread32 (void __iomem *addr) +unsigned int ioread32 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread32)(addr);mb ();
Signature · 1 line
2.7.4
PATCH 3/13 alpha: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/alpha/include/asm/core_apecs.h | 6 +++--- arch/alpha/include/asm/core_cia.h | 6 +++--- arch/alpha/include/asm/core_lca.h | 6 +++--- arch/alpha/include/asm/core_marvel.h | 4 ++-- arch/alpha/include/asm/core_mcpcia.h | 6 +++--- arch/alpha/include/asm/core_t2.h | 2 +- arch/alpha/include/asm/io.h | 12 ++++++------ arch/alpha/include/asm/io_trivial.h | 16 ++++++++-------- arch/alpha/include/asm/jensen.h | 2 +- arch/alpha/include/asm/machvec.h | 6 +++--- arch/alpha/kernel/core_marvel.c | 2 +- arch/alpha/kernel/io.c | 6 +++--- 12 files changed, 37 insertions(+), 37 deletions(-)
arch/alpha/include/asm/core_apecs.h +3 -3
@@ -384,7 +384,7 @@ struct el_apecs_procdata } \ }while (0 ) -__EXTERN_INLINE unsigned int apecs_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int apecs_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -420,7 +420,7 @@ __EXTERN_INLINE void apecs_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int apecs_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int apecs_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -456,7 +456,7 @@ __EXTERN_INLINE void apecs_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int apecs_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int apecs_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (addr <APECS_DENSE_MEM )
arch/alpha/include/asm/core_cia.h +3 -3
@@ -342,7 +342,7 @@ struct el_CIA_sysdata_mcheck {#define vuip volatile unsigned int __force *#define vulp volatile unsigned long __force * -__EXTERN_INLINE unsigned int cia_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int cia_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -374,7 +374,7 @@ __EXTERN_INLINE void cia_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int cia_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int cia_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -404,7 +404,7 @@ __EXTERN_INLINE void cia_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int cia_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int cia_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (addr <CIA_DENSE_MEM )
arch/alpha/include/asm/core_lca.h +3 -3
@@ -230,7 +230,7 @@ union el_lca { }while (0 ) -__EXTERN_INLINE unsigned int lca_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int lca_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -266,7 +266,7 @@ __EXTERN_INLINE void lca_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int lca_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int lca_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;unsigned long result, base_and_type;
@@ -302,7 +302,7 @@ __EXTERN_INLINE void lca_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + base_and_type) = w; } -__EXTERN_INLINE unsigned int lca_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int lca_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (addr <LCA_DENSE_MEM )
arch/alpha/include/asm/core_marvel.h +2 -2
@@ -332,10 +332,10 @@ struct io7 {#define vucp volatile unsigned char __force *#define vusp volatile unsigned short __force * -extern unsigned int marvel_ioread8 (void __iomem *); +extern unsigned int marvel_ioread8 (const void __iomem *);extern void marvel_iowrite8 (u8 b,void __iomem *); -__EXTERN_INLINE unsigned int marvel_ioread16(void __iomem *addr) +__EXTERN_INLINE unsigned int marvel_ioread16(const void __iomem *addr) {return __kernel_ldwu (*(vusp )addr); }
arch/alpha/include/asm/core_mcpcia.h +3 -3
@@ -267,7 +267,7 @@ extern inline int __mcpcia_is_mmio(unsigned long addr)return (addr &0x80000000UL ) ==0 ; } -__EXTERN_INLINE unsigned int mcpcia_ioread8(void __iomem *xaddr) +__EXTERN_INLINE unsigned int mcpcia_ioread8(const void __iomem *xaddr) {unsigned long addr = (unsigned long )xaddr &MCPCIA_MEM_MASK ;unsigned long hose = (unsigned long )xaddr & ~MCPCIA_MEM_MASK ;
@@ -291,7 +291,7 @@ __EXTERN_INLINE void mcpcia_iowrite8(u8 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + hose +0x00 ) = w; } -__EXTERN_INLINE unsigned int mcpcia_ioread16(void __iomem *xaddr) +__EXTERN_INLINE unsigned int mcpcia_ioread16(const void __iomem *xaddr) {unsigned long addr = (unsigned long )xaddr &MCPCIA_MEM_MASK ;unsigned long hose = (unsigned long )xaddr & ~MCPCIA_MEM_MASK ;
@@ -315,7 +315,7 @@ __EXTERN_INLINE void mcpcia_iowrite16(u16 b, void __iomem *xaddr) *(vuip) ((addr <<5 ) + hose +0x08 ) = w; } -__EXTERN_INLINE unsigned int mcpcia_ioread32(void __iomem *xaddr) +__EXTERN_INLINE unsigned int mcpcia_ioread32(const void __iomem *xaddr) {unsigned long addr = (unsigned long )xaddr;
arch/alpha/include/asm/core_t2.h +1 -1
@@ -572,7 +572,7 @@ __EXTERN_INLINE int t2_is_mmio(const volatile void __iomem *addr)it doesn't make sense to merge the pio and mmio routines. */ #define IOPORT (OS ,NS ) \ -__EXTERN_INLINE unsigned int t2_ioread##NS(void __iomem *xaddr) \ +__EXTERN_INLINE unsigned int t2_ioread##NS(const void __iomem *xaddr) \ { \ if (t2_is_mmio(xaddr)) \ return t2_read##OS(xaddr); \
arch/alpha/include/asm/io.h +6 -6
@@ -151,9 +151,9 @@ static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr) \ alpha_mv.mv_##NAME(b, addr); \ } -REMAP1(unsigned int, ioread8, /**/) -REMAP1(unsigned int, ioread16, /**/) -REMAP1(unsigned int, ioread32, /**/) +REMAP1(unsigned int, ioread8, const) +REMAP1(unsigned int, ioread16, const) +REMAP1(unsigned int, ioread32, const) REMAP1(u8, readb, const volatile) REMAP1(u16, readw, const volatile) REMAP1(u32, readl, const volatile)
@@ -308,14 +308,14 @@ static inline int __is_mmio(const volatile void __iomem *addr)*/ #if IO_CONCAT (__IO_PREFIX,trivial_io_bw) -extern inline unsigned int ioread8 (void __iomem *addr) +extern inline unsigned int ioread8 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread8)(addr);mb ();return ret; } -extern inline unsigned int ioread16 (void __iomem *addr) +extern inline unsigned int ioread16 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread16)(addr);mb ();
@@ -356,7 +356,7 @@ extern inline void outw(u16 b, unsigned long port)#endif #if IO_CONCAT (__IO_PREFIX,trivial_io_lq) -extern inline unsigned int ioread32 (void __iomem *addr) +extern inline unsigned int ioread32 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread32)(addr);mb ();
arch/alpha/include/asm/io_trivial.h +8 -8
@@ -7,15 +7,15 @@#if IO_CONCAT (__IO_PREFIX,trivial_io_bw) __EXTERN_INLINE unsigned int -IO_CONCAT (__IO_PREFIX ,ioread8 )(void __iomem *a) +IO_CONCAT (__IO_PREFIX ,ioread8 )(const void __iomem *a) { -return __kernel_ldbu (*(volatile u8 __force *)a); +return __kernel_ldbu (*(const volatile u8 __force *)a); } __EXTERN_INLINE unsigned int -IO_CONCAT (__IO_PREFIX ,ioread16 )(void __iomem *a) +IO_CONCAT (__IO_PREFIX ,ioread16 )(const void __iomem *a) { -return __kernel_ldwu (*(volatile u16 __force *)a); +return __kernel_ldwu (*(const volatile u16 __force *)a); }__EXTERN_INLINE void
@@ -33,9 +33,9 @@ IO_CONCAT(__IO_PREFIX,iowrite16)(u16 b, void __iomem *a)#if IO_CONCAT (__IO_PREFIX,trivial_io_lq) __EXTERN_INLINE unsigned int -IO_CONCAT (__IO_PREFIX ,ioread32 )(void __iomem *a) +IO_CONCAT (__IO_PREFIX ,ioread32 )(const void __iomem *a) { -return *(volatile u32 __force *)a; +return *(const volatile u32 __force *)a; }__EXTERN_INLINE void
@@ -73,14 +73,14 @@ IO_CONCAT(__IO_PREFIX,writew)(u16 b, volatile void __iomem *a) __EXTERN_INLINE u8IO_CONCAT (__IO_PREFIX ,readb )(const volatile void __iomem *a) { -void __iomem *addr = (void __iomem *)a; +const void __iomem *addr = (const void __iomem *)a;return IO_CONCAT (__IO_PREFIX,ioread8)(addr); } __EXTERN_INLINE u16IO_CONCAT (__IO_PREFIX ,readw )(const volatile void __iomem *a) { -void __iomem *addr = (void __iomem *)a; +const void __iomem *addr = (const void __iomem *)a;return IO_CONCAT (__IO_PREFIX,ioread16)(addr); }
arch/alpha/include/asm/jensen.h +1 -1
@@ -305,7 +305,7 @@ __EXTERN_INLINE int jensen_is_mmio(const volatile void __iomem *addr)that it doesn't make sense to merge them. */ #define IOPORT (OS ,NS ) \ -__EXTERN_INLINE unsigned int jensen_ioread##NS(void __iomem *xaddr) \ +__EXTERN_INLINE unsigned int jensen_ioread##NS(const void __iomem *xaddr) \ { \ if (jensen_is_mmio(xaddr)) \ return jensen_read##OS(xaddr - 0x100000000ul); \
arch/alpha/include/asm/machvec.h +3 -3
@@ -46,9 +46,9 @@ struct alpha_machine_vectorvoid (*mv_pci_tbi)(struct pci_controller *hose,dma_addr_t start,dma_addr_t end); -unsigned int (*mv_ioread8)(void __iomem *); -unsigned int (*mv_ioread16)(void __iomem *); -unsigned int (*mv_ioread32)(void __iomem *); +unsigned int (*mv_ioread8)(const void __iomem *); +unsigned int (*mv_ioread16)(const void __iomem *); +unsigned int (*mv_ioread32)(const void __iomem *);void (*mv_iowrite8)(u8 ,void __iomem *);void (*mv_iowrite16)(u16 ,void __iomem *);
arch/alpha/kernel/core_marvel.c +1 -1
@@ -807,7 +807,7 @@ void __iomem *marvel_ioportmap (unsigned long addr) }unsigned int -marvel_ioread8 (void __iomem *xaddr) +marvel_ioread8 (const void __iomem *xaddr) {unsigned long addr = (unsigned long ) xaddr;if (__marvel_is_port_kbd (addr))
arch/alpha/kernel/io.c +3 -3
@@ -14,21 +14,21 @@"generic", which bumps through the machine vector. */ unsigned int -ioread8 (void __iomem *addr) +ioread8 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread8)(addr);mb ();return ret; } -unsigned int ioread16 (void __iomem *addr) +unsigned int ioread16 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread16)(addr);mb ();return ret; } -unsigned int ioread32 (void __iomem *addr) +unsigned int ioread32 (const void __iomem *addr) {unsigned int ret =IO_CONCAT (__IO_PREFIX,ioread32)(addr);mb ();
Signature · 1 line
2.7.4
PATCH 3/13 sh: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/sh/kernel/iomap.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
arch/sh/kernel/iomap.c +5 -5
@@ -8,31 +8,31 @@#include <linux/module.h> #include <linux/io.h> -unsigned int ioread8 (void __iomem *addr) +unsigned int ioread8 (const void __iomem *addr) {return readb (addr); }EXPORT_SYMBOL (ioread8); -unsigned int ioread16 (void __iomem *addr) +unsigned int ioread16 (const void __iomem *addr) {return readw (addr); }EXPORT_SYMBOL (ioread16); -unsigned int ioread16be (void __iomem *addr) +unsigned int ioread16be (const void __iomem *addr) {return be16_to_cpu (__raw_readw (addr)); }EXPORT_SYMBOL (ioread16be); -unsigned int ioread32 (void __iomem *addr) +unsigned int ioread32 (const void __iomem *addr) {return readl (addr); }EXPORT_SYMBOL (ioread32); -unsigned int ioread32be (void __iomem *addr) +unsigned int ioread32be (const void __iomem *addr) {return be32_to_cpu (__raw_readl (addr)); }
Signature · 1 line
2.7.4
Arnd Bergmann
maintainerRe: [RFT 03/13] sh: Constify ioreadX() iomem argument (as in generic implementation)
Quoted 9 lines · Krzysztof Kozlowski
The
ioreadX()helpers have inconsistent interface. On some architectures void*__iomemaddress argument is a pointer to const, on some not.Implementations of
ioreadX()do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.Signed-off-by Krzysztof Kozlowski <[email protected]>
The patch looks good, but I think this has to be done together with the powerpc version and the header that declares the function, for bisectibility.
Arnd
Arnd Bergmann
maintainerRe: [RFT 03/13] sh: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiQuoted 9 lines · Krzysztof Kozlowski
The
ioreadX()helpers have inconsistent interface. On some architectures void*__iomemaddress argument is a pointer to const, on some not.Implementations of
ioreadX()do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.Signed-off-by Krzysztof Kozlowski <[email protected]>
The patch looks good, but I think this has to be done together with the powerpc version and the header that declares the function, for bisectibility.
Arnd
PATCH 3/13 sh: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/sh/kernel/iomap.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
arch/sh/kernel/iomap.c +5 -5
@@ -8,31 +8,31 @@#include <linux/module.h> #include <linux/io.h> -unsigned int ioread8 (void __iomem *addr) +unsigned int ioread8 (const void __iomem *addr) {return readb (addr); }EXPORT_SYMBOL (ioread8); -unsigned int ioread16 (void __iomem *addr) +unsigned int ioread16 (const void __iomem *addr) {return readw (addr); }EXPORT_SYMBOL (ioread16); -unsigned int ioread16be (void __iomem *addr) +unsigned int ioread16be (const void __iomem *addr) {return be16_to_cpu (__raw_readw (addr)); }EXPORT_SYMBOL (ioread16be); -unsigned int ioread32 (void __iomem *addr) +unsigned int ioread32 (const void __iomem *addr) {return readl (addr); }EXPORT_SYMBOL (ioread32); -unsigned int ioread32be (void __iomem *addr) +unsigned int ioread32be (const void __iomem *addr) {return be32_to_cpu (__raw_readl (addr)); }
Signature · 1 line
2.7.4
PATCH 4/13 parisc: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/parisc/include/asm/io.h | 4 ++-- arch/parisc/lib/iomap.c | 48 ++++++++++++++++++++++---------------------- 2 files changed, 26 insertions(+), 26 deletions(-)
arch/parisc/include/asm/io.h +2 -2
@@ -303,8 +303,8 @@ extern void outsl (unsigned long port, const void *src, unsigned long count);#define ioread64be ioread64be#define iowrite64 iowrite64#define iowrite64be iowrite64be -extern u64 ioread64 (void __iomem *addr); -extern u64 ioread64be (void __iomem *addr); +extern u64 ioread64 (const void __iomem *addr); +extern u64 ioread64be (const void __iomem *addr);extern void iowrite64 (u64 val,void __iomem *addr);extern void iowrite64be (u64 val,void __iomem *addr);
arch/parisc/lib/iomap.c +24 -24
140 lines not on this page · raw message
Signature · 1 line
2.7.4
PATCH 4/13 parisc: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/parisc/include/asm/io.h | 4 ++-- arch/parisc/lib/iomap.c | 48 ++++++++++++++++++++++---------------------- 2 files changed, 26 insertions(+), 26 deletions(-)
arch/parisc/include/asm/io.h +2 -2
@@ -303,8 +303,8 @@ extern void outsl (unsigned long port, const void *src, unsigned long count);#define ioread64be ioread64be#define iowrite64 iowrite64#define iowrite64be iowrite64be -extern u64 ioread64 (void __iomem *addr); -extern u64 ioread64be (void __iomem *addr); +extern u64 ioread64 (const void __iomem *addr); +extern u64 ioread64be (const void __iomem *addr);extern void iowrite64 (u64 val,void __iomem *addr);extern void iowrite64be (u64 val,void __iomem *addr);
arch/parisc/lib/iomap.c +24 -24
140 lines not on this page · raw message
Signature · 1 line
2.7.4
PATCH 5/13 powerpc: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/powerpc/kernel/iomap.c | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-)
arch/powerpc/kernel/iomap.c +11 -11
@@ -15,23 +15,23 @@* Here comes the ppc64 implementation of the IOMAP * interfaces. */ -unsigned int ioread8 (void __iomem *addr) +unsigned int ioread8 (const void __iomem *addr) {return readb (addr); } -unsigned int ioread16 (void __iomem *addr) +unsigned int ioread16 (const void __iomem *addr) {return readw (addr); } -unsigned int ioread16be (void __iomem *addr) +unsigned int ioread16be (const void __iomem *addr) {return readw_be (addr); } -unsigned int ioread32 (void __iomem *addr) +unsigned int ioread32 (const void __iomem *addr) {return readl (addr); } -unsigned int ioread32be (void __iomem *addr) +unsigned int ioread32be (const void __iomem *addr) {return readl_be (addr); }
@@ -41,27 +41,27 @@ EXPORT_SYMBOL(ioread16be);EXPORT_SYMBOL (ioread32);EXPORT_SYMBOL (ioread32be);#ifdef __powerpc64__ -u64 ioread64 (void __iomem *addr) +u64 ioread64 (const void __iomem *addr) {return readq (addr); } -u64 ioread64_lo_hi (void __iomem *addr) +u64 ioread64_lo_hi (const void __iomem *addr) {return readq (addr); } -u64 ioread64_hi_lo (void __iomem *addr) +u64 ioread64_hi_lo (const void __iomem *addr) {return readq (addr); } -u64 ioread64be (void __iomem *addr) +u64 ioread64be (const void __iomem *addr) {return readq_be (addr); } -u64 ioread64be_lo_hi (void __iomem *addr) +u64 ioread64be_lo_hi (const void __iomem *addr) {return readq_be (addr); } -u64 ioread64be_hi_lo (void __iomem *addr) +u64 ioread64be_hi_lo (const void __iomem *addr) {return readq_be (addr); }
Signature · 1 line
2.7.4
PATCH 5/13 powerpc: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/powerpc/kernel/iomap.c | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-)
arch/powerpc/kernel/iomap.c +11 -11
@@ -15,23 +15,23 @@* Here comes the ppc64 implementation of the IOMAP * interfaces. */ -unsigned int ioread8 (void __iomem *addr) +unsigned int ioread8 (const void __iomem *addr) {return readb (addr); } -unsigned int ioread16 (void __iomem *addr) +unsigned int ioread16 (const void __iomem *addr) {return readw (addr); } -unsigned int ioread16be (void __iomem *addr) +unsigned int ioread16be (const void __iomem *addr) {return readw_be (addr); } -unsigned int ioread32 (void __iomem *addr) +unsigned int ioread32 (const void __iomem *addr) {return readl (addr); } -unsigned int ioread32be (void __iomem *addr) +unsigned int ioread32be (const void __iomem *addr) {return readl_be (addr); }
@@ -41,27 +41,27 @@ EXPORT_SYMBOL(ioread16be);EXPORT_SYMBOL (ioread32);EXPORT_SYMBOL (ioread32be);#ifdef __powerpc64__ -u64 ioread64 (void __iomem *addr) +u64 ioread64 (const void __iomem *addr) {return readq (addr); } -u64 ioread64_lo_hi (void __iomem *addr) +u64 ioread64_lo_hi (const void __iomem *addr) {return readq (addr); } -u64 ioread64_hi_lo (void __iomem *addr) +u64 ioread64_hi_lo (const void __iomem *addr) {return readq (addr); } -u64 ioread64be (void __iomem *addr) +u64 ioread64be (const void __iomem *addr) {return readq_be (addr); } -u64 ioread64be_lo_hi (void __iomem *addr) +u64 ioread64be_lo_hi (const void __iomem *addr) {return readq_be (addr); } -u64 ioread64be_hi_lo (void __iomem *addr) +u64 ioread64be_hi_lo (const void __iomem *addr) {return readq_be (addr); }
Signature · 1 line
2.7.4
PATCH 6/13 arc: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/arc/plat-axs10x/axs10x.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
arch/arc/plat-axs10x/axs10x.c +2 -2
@@ -84,7 +84,7 @@ static void __init axs10x_print_board_ver(unsigned int creg, const char *str)unsigned int val; } board; - board.val =ioread32 ((void __iomem *)creg); + board.val =ioread32 ((const void __iomem *)creg);pr_info ("AXS: %s FPGA Date: %u-%u-%u\n" , str, board.d, board.m, board.y); }
@@ -95,7 +95,7 @@ static void __init axs10x_early_init(void)char mb[32 ];/* Determine motherboard version */ -if (ioread32 ((void __iomem *)CREG_MB_CONFIG ) & (1 <<28 )) +if (ioread32 ((const void __iomem *)CREG_MB_CONFIG ) & (1 <<28 )) mb_rev =3 ;/* HT-3 (rev3.0) */ else mb_rev =2 ;/* HT-2 (rev2.0) */
Signature · 1 line
2.7.4
Arnd Bergmann
maintainerRe: [RFT 06/13] arc: Constify ioreadX() iomem argument (as in generic implementation)
Quoted 9 lines · Krzysztof Kozlowski
The
ioreadX()helpers have inconsistent interface. On some architectures void*__iomemaddress argument is a pointer to const, on some not.Implementations of
ioreadX()do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.Signed-off-by Krzysztof Kozlowski <[email protected]>
The patch looks correct, but I would not bother here, as it has no effect on the compiler or its output.
Arnd
Arnd Bergmann
maintainerRe: [RFT 06/13] arc: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiQuoted 9 lines · Krzysztof Kozlowski
The
ioreadX()helpers have inconsistent interface. On some architectures void*__iomemaddress argument is a pointer to const, on some not.Implementations of
ioreadX()do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.Signed-off-by Krzysztof Kozlowski <[email protected]>
The patch looks correct, but I would not bother here, as it has no effect on the compiler or its output.
Arnd
PATCH 6/13 arc: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- arch/arc/plat-axs10x/axs10x.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
arch/arc/plat-axs10x/axs10x.c +2 -2
@@ -84,7 +84,7 @@ static void __init axs10x_print_board_ver(unsigned int creg, const char *str)unsigned int val; } board; - board.val =ioread32 ((void __iomem *)creg); + board.val =ioread32 ((const void __iomem *)creg);pr_info ("AXS: %s FPGA Date: %u-%u-%u\n" , str, board.d, board.m, board.y); }
@@ -95,7 +95,7 @@ static void __init axs10x_early_init(void)char mb[32 ];/* Determine motherboard version */ -if (ioread32 ((void __iomem *)CREG_MB_CONFIG ) & (1 <<28 )) +if (ioread32 ((const void __iomem *)CREG_MB_CONFIG ) & (1 <<28 )) mb_rev =3 ;/* HT-3 (rev3.0) */ else mb_rev =2 ;/* HT-2 (rev2.0) */
Signature · 1 line
2.7.4
PATCH 7/13 drm/mgag200: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/gpu/drm/mgag200/mgag200_drv.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/gpu/drm/mgag200/mgag200_drv.h +2 -2
@@ -34,9 +34,9 @@#define MGAG200FB_CONN_LIMIT 1 -#define RREG8 (reg) ioread8(((void __iomem *)mdev->rmmio) + (reg)) +#define RREG8 (reg) ioread8(((const void __iomem *)mdev->rmmio) + (reg))#define WREG8 (reg, v) iowrite8(v, ((void __iomem *)mdev->rmmio) + (reg)) -#define RREG32 (reg) ioread32(((void __iomem *)mdev->rmmio) + (reg)) +#define RREG32 (reg) ioread32(((const void __iomem *)mdev->rmmio) + (reg))#define WREG32 (reg, v) iowrite32(v, ((void __iomem *)mdev->rmmio) + (reg))#define ATTR_INDEX 0x1fc0
Signature · 1 line
2.7.4
PATCH 7/13 drm/mgag200: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/gpu/drm/mgag200/mgag200_drv.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/gpu/drm/mgag200/mgag200_drv.h +2 -2
@@ -34,9 +34,9 @@#define MGAG200FB_CONN_LIMIT 1 -#define RREG8 (reg) ioread8(((void __iomem *)mdev->rmmio) + (reg)) +#define RREG8 (reg) ioread8(((const void __iomem *)mdev->rmmio) + (reg))#define WREG8 (reg, v) iowrite8(v, ((void __iomem *)mdev->rmmio) + (reg)) -#define RREG32 (reg) ioread32(((void __iomem *)mdev->rmmio) + (reg)) +#define RREG32 (reg) ioread32(((const void __iomem *)mdev->rmmio) + (reg))#define WREG32 (reg, v) iowrite32(v, ((void __iomem *)mdev->rmmio) + (reg))#define ATTR_INDEX 0x1fc0
Signature · 1 line
2.7.4
PATCH 8/13 drm/nouveau: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/gpu/drm/nouveau/nouveau_bo.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/gpu/drm/nouveau/nouveau_bo.c +1 -1
@@ -613,7 +613,7 @@ nouveau_bo_rd32(struct nouveau_bo *nvbo, unsigned index) mem += index;if (is_iomem) -return ioread32_native ((void __force __iomem *)mem); +return ioread32_native ((const void __force __iomem *)mem);else return *mem; }
Signature · 1 line
2.7.4
PATCH 8/13 drm/nouveau: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/gpu/drm/nouveau/nouveau_bo.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/gpu/drm/nouveau/nouveau_bo.c +1 -1
@@ -613,7 +613,7 @@ nouveau_bo_rd32(struct nouveau_bo *nvbo, unsigned index) mem += index;if (is_iomem) -return ioread32_native ((void __force __iomem *)mem); +return ioread32_native ((const void __force __iomem *)mem);else return *mem; }
Signature · 1 line
2.7.4
PATCH 9/13 media: fsl-viu: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/media/platform/fsl-viu.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/media/platform/fsl-viu.c +1 -1
@@ -34,7 +34,7 @@/* Allow building this driver with COMPILE_TEST */ #if !defined(CONFIG_PPC ) && !defined(CONFIG_MICROBLAZE )#define out_be32 (v, a) iowrite32be(a, (void __iomem *)v) -#define in_be32 (a) ioread32be((void __iomem *)a) +#define in_be32 (a) ioread32be((const void __iomem *)a)#endif #define BUFFER_TIMEOUT msecs_to_jiffies(500)/* 0.5 seconds */
Signature · 1 line
2.7.4
PATCH 9/13 media: fsl-viu: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/media/platform/fsl-viu.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/media/platform/fsl-viu.c +1 -1
@@ -34,7 +34,7 @@/* Allow building this driver with COMPILE_TEST */ #if !defined(CONFIG_PPC ) && !defined(CONFIG_MICROBLAZE )#define out_be32 (v, a) iowrite32be(a, (void __iomem *)v) -#define in_be32 (a) ioread32be((void __iomem *)a) +#define in_be32 (a) ioread32be((const void __iomem *)a)#endif #define BUFFER_TIMEOUT msecs_to_jiffies(500)/* 0.5 seconds */
Signature · 1 line
2.7.4
PATCH 10/13 net: wireless: ath5k: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/net/wireless/ath/ath5k/ahb.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
drivers/net/wireless/ath/ath5k/ahb.c +5 -5
@@ -138,18 +138,18 @@ static int ath_ahb_probe(struct platform_device *pdev)if (bcfg->devid >=AR5K_SREV_AR2315_R6 ) {/* Enable WMAC AHB arbitration */ - reg =ioread32 ((void __iomem *)AR5K_AR2315_AHB_ARB_CTL ); + reg =ioread32 ((const void __iomem *)AR5K_AR2315_AHB_ARB_CTL ); reg |=AR5K_AR2315_AHB_ARB_CTL_WLAN ;iowrite32 (reg, (void __iomem *)AR5K_AR2315_AHB_ARB_CTL );/* Enable global WMAC swapping */ - reg =ioread32 ((void __iomem *)AR5K_AR2315_BYTESWAP ); + reg =ioread32 ((const void __iomem *)AR5K_AR2315_BYTESWAP ); reg |=AR5K_AR2315_BYTESWAP_WMAC ;iowrite32 (reg, (void __iomem *)AR5K_AR2315_BYTESWAP ); }else {/* Enable WMAC DMA access (assuming 5312 or 231x*/ /* TODO: check other platforms */ - reg =ioread32 ((void __iomem *)AR5K_AR5312_ENABLE ); + reg =ioread32 ((const void __iomem *)AR5K_AR5312_ENABLE );if (to_platform_device (ah->dev)->id =0 ) reg |=AR5K_AR5312_ENABLE_WLAN0 ;else
@@ -202,12 +202,12 @@ static int ath_ahb_remove(struct platform_device *pdev)if (bcfg->devid >=AR5K_SREV_AR2315_R6 ) {/* Disable WMAC AHB arbitration */ - reg =ioread32 ((void __iomem *)AR5K_AR2315_AHB_ARB_CTL ); + reg =ioread32 ((const void __iomem *)AR5K_AR2315_AHB_ARB_CTL ); reg &= ~AR5K_AR2315_AHB_ARB_CTL_WLAN ;iowrite32 (reg, (void __iomem *)AR5K_AR2315_AHB_ARB_CTL ); }else {/*Stop DMA access */ - reg =ioread32 ((void __iomem *)AR5K_AR5312_ENABLE ); + reg =ioread32 ((const void __iomem *)AR5K_AR5312_ENABLE );if (to_platform_device (ah->dev)->id =0 ) reg &= ~AR5K_AR5312_ENABLE_WLAN0 ;else
Signature · 1 line
2.7.4
PATCH 10/13 net: wireless: ath5k: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/net/wireless/ath/ath5k/ahb.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
drivers/net/wireless/ath/ath5k/ahb.c +5 -5
@@ -138,18 +138,18 @@ static int ath_ahb_probe(struct platform_device *pdev)if (bcfg->devid >=AR5K_SREV_AR2315_R6 ) {/* Enable WMAC AHB arbitration */ - reg =ioread32 ((void __iomem *)AR5K_AR2315_AHB_ARB_CTL ); + reg =ioread32 ((const void __iomem *)AR5K_AR2315_AHB_ARB_CTL ); reg |=AR5K_AR2315_AHB_ARB_CTL_WLAN ;iowrite32 (reg, (void __iomem *)AR5K_AR2315_AHB_ARB_CTL );/* Enable global WMAC swapping */ - reg =ioread32 ((void __iomem *)AR5K_AR2315_BYTESWAP ); + reg =ioread32 ((const void __iomem *)AR5K_AR2315_BYTESWAP ); reg |=AR5K_AR2315_BYTESWAP_WMAC ;iowrite32 (reg, (void __iomem *)AR5K_AR2315_BYTESWAP ); }else {/* Enable WMAC DMA access (assuming 5312 or 231x*/ /* TODO: check other platforms */ - reg =ioread32 ((void __iomem *)AR5K_AR5312_ENABLE ); + reg =ioread32 ((const void __iomem *)AR5K_AR5312_ENABLE );if (to_platform_device (ah->dev)->id ==0 ) reg |=AR5K_AR5312_ENABLE_WLAN0 ;else
@@ -202,12 +202,12 @@ static int ath_ahb_remove(struct platform_device *pdev)if (bcfg->devid >=AR5K_SREV_AR2315_R6 ) {/* Disable WMAC AHB arbitration */ - reg =ioread32 ((void __iomem *)AR5K_AR2315_AHB_ARB_CTL ); + reg =ioread32 ((const void __iomem *)AR5K_AR2315_AHB_ARB_CTL ); reg &= ~AR5K_AR2315_AHB_ARB_CTL_WLAN ;iowrite32 (reg, (void __iomem *)AR5K_AR2315_AHB_ARB_CTL ); }else {/*Stop DMA access */ - reg =ioread32 ((void __iomem *)AR5K_AR5312_ENABLE ); + reg =ioread32 ((const void __iomem *)AR5K_AR5312_ENABLE );if (to_platform_device (ah->dev)->id ==0 ) reg &= ~AR5K_AR5312_ENABLE_WLAN0 ;else
Signature · 1 line
2.7.4
PATCH 11/13 net: wireless: rtl818x: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/net/wireless/realtek/rtl818x/rtl8180/rtl8180.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/net/wireless/realtek/rtl818x/rtl8180/rtl8180.h +3 -3
@@ -150,17 +150,17 @@ void rtl8180_write_phy(struct ieee80211_hw *dev, u8 addr, u32 data);void rtl8180_set_anaparam (struct rtl8180_priv *priv,u32 anaparam);void rtl8180_set_anaparam2 (struct rtl8180_priv *priv,u32 anaparam2); -static inline u8 rtl818x_ioread8 (struct rtl8180_priv *priv,u8 __iomem *addr) +static inline u8 rtl818x_ioread8 (struct rtl8180_priv *priv,const u8 __iomem *addr) {return ioread8 (addr); } -static inline u16 rtl818x_ioread16 (struct rtl8180_priv *priv,__le16 __iomem *addr) +static inline u16 rtl818x_ioread16 (struct rtl8180_priv *priv,const __le16 __iomem *addr) {return ioread16 (addr); } -static inline u32 rtl818x_ioread32 (struct rtl8180_priv *priv,__le32 __iomem *addr) +static inline u32 rtl818x_ioread32 (struct rtl8180_priv *priv,const __le32 __iomem *addr) {return ioread32 (addr); }
Signature · 1 line
2.7.4
PATCH 11/13 net: wireless: rtl818x: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/net/wireless/realtek/rtl818x/rtl8180/rtl8180.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/net/wireless/realtek/rtl818x/rtl8180/rtl8180.h +3 -3
@@ -150,17 +150,17 @@ void rtl8180_write_phy(struct ieee80211_hw *dev, u8 addr, u32 data);void rtl8180_set_anaparam (struct rtl8180_priv *priv,u32 anaparam);void rtl8180_set_anaparam2 (struct rtl8180_priv *priv,u32 anaparam2); -static inline u8 rtl818x_ioread8 (struct rtl8180_priv *priv,u8 __iomem *addr) +static inline u8 rtl818x_ioread8 (struct rtl8180_priv *priv,const u8 __iomem *addr) {return ioread8 (addr); } -static inline u16 rtl818x_ioread16 (struct rtl8180_priv *priv,__le16 __iomem *addr) +static inline u16 rtl818x_ioread16 (struct rtl8180_priv *priv,const __le16 __iomem *addr) {return ioread16 (addr); } -static inline u32 rtl818x_ioread32 (struct rtl8180_priv *priv,__le32 __iomem *addr) +static inline u32 rtl818x_ioread32 (struct rtl8180_priv *priv,const __le32 __iomem *addr) {return ioread32 (addr); }
Signature · 1 line
2.7.4
PATCH 12/13 ntb: intel: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/ntb/hw/intel/ntb_hw_gen1.c | 2 +- drivers/ntb/hw/intel/ntb_hw_gen3.h | 2 +- drivers/ntb/hw/intel/ntb_hw_intel.h | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-)
drivers/ntb/hw/intel/ntb_hw_gen1.c +1 -1
@@ -1202,7 +1202,7 @@ int intel_ntb_peer_spad_write(struct ntb_dev *ntb, int pidx, int sidx, ndev->peer_reg->spad); } -static u64 xeon_db_ioread (void __iomem *mmio) +static u64 xeon_db_ioread (const void __iomem *mmio) {return (u64 )ioread16 (mmio); }
drivers/ntb/hw/intel/ntb_hw_gen3.h +1 -1
@@ -91,7 +91,7 @@#define GEN3_DB_TOTAL_SHIFT 33#define GEN3_SPAD_COUNT 16 -static inline u64 gen3_db_ioread (void __iomem *mmio) +static inline u64 gen3_db_ioread (const void __iomem *mmio) {return ioread64 (mmio); }
drivers/ntb/hw/intel/ntb_hw_intel.h +1 -1
@@ -102,7 +102,7 @@ struct intel_ntb_dev;struct intel_ntb_reg {int (*poll_link)(struct intel_ntb_dev *ndev);int (*link_is_up)(struct intel_ntb_dev *ndev); -u64 (*db_ioread)(void __iomem *mmio); +u64 (*db_ioread)(const void __iomem *mmio);void (*db_iowrite)(u64 db_bits,void __iomem *mmio);unsigned long ntb_ctl;resource_size_t db_size;
Signature · 1 line
2.7.4
PATCH 12/13 ntb: intel: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/ntb/hw/intel/ntb_hw_gen1.c | 2 +- drivers/ntb/hw/intel/ntb_hw_gen3.h | 2 +- drivers/ntb/hw/intel/ntb_hw_intel.h | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-)
drivers/ntb/hw/intel/ntb_hw_gen1.c +1 -1
@@ -1202,7 +1202,7 @@ int intel_ntb_peer_spad_write(struct ntb_dev *ntb, int pidx, int sidx, ndev->peer_reg->spad); } -static u64 xeon_db_ioread (void __iomem *mmio) +static u64 xeon_db_ioread (const void __iomem *mmio) {return (u64 )ioread16 (mmio); }
drivers/ntb/hw/intel/ntb_hw_gen3.h +1 -1
@@ -91,7 +91,7 @@#define GEN3_DB_TOTAL_SHIFT 33#define GEN3_SPAD_COUNT 16 -static inline u64 gen3_db_ioread (void __iomem *mmio) +static inline u64 gen3_db_ioread (const void __iomem *mmio) {return ioread64 (mmio); }
drivers/ntb/hw/intel/ntb_hw_intel.h +1 -1
@@ -102,7 +102,7 @@ struct intel_ntb_dev;struct intel_ntb_reg {int (*poll_link)(struct intel_ntb_dev *ndev);int (*link_is_up)(struct intel_ntb_dev *ndev); -u64 (*db_ioread)(void __iomem *mmio); +u64 (*db_ioread)(const void __iomem *mmio);void (*db_iowrite)(u64 db_bits,void __iomem *mmio);unsigned long ntb_ctl;resource_size_t db_size;
Signature · 1 line
2.7.4
PATCH 13/13 virtio: pci: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/virtio/virtio_pci_modern.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/virtio/virtio_pci_modern.c +3 -3
@@ -26,16 +26,16 @@* method, i.e. 32-bit accesses for 32-bit fields, 16-bit accesses * for 16-bit fields and 8-bit accesses for 8-bit fields. */ -static inline u8 vp_ioread8 (u8 __iomem *addr) +static inline u8 vp_ioread8 (const u8 __iomem *addr) {return ioread8 (addr); } -static inline u16 vp_ioread16 (__le16 __iomem *addr) +static inline u16 vp_ioread16 (const __le16 __iomem *addr) {return ioread16 (addr); } -static inline u32 vp_ioread32 (__le32 __iomem *addr) +static inline u32 vp_ioread32 (const __le32 __iomem *addr) {return ioread32 (addr); }
Signature · 1 line
2.7.4
PATCH 13/13 virtio: pci: Constify ioreadX() iomem argument (as in generic implementation)
In reply to Krzysztof KozlowskiThe ioreadX() helpers have inconsistent interface. On some architectures void *__iomem address argument is a pointer to const, on some not.
Implementations of ioreadX() do not modify the memory under the address so they can be converted to a "const" version for const-safety and consistency among architectures.
--- drivers/virtio/virtio_pci_modern.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/virtio/virtio_pci_modern.c +3 -3
@@ -26,16 +26,16 @@* method, i.e. 32-bit accesses for 32-bit fields, 16-bit accesses * for 16-bit fields and 8-bit accesses for 8-bit fields. */ -static inline u8 vp_ioread8 (u8 __iomem *addr) +static inline u8 vp_ioread8 (const u8 __iomem *addr) {return ioread8 (addr); } -static inline u16 vp_ioread16 (__le16 __iomem *addr) +static inline u16 vp_ioread16 (const __le16 __iomem *addr) {return ioread16 (addr); } -static inline u32 vp_ioread32 (__le32 __iomem *addr) +static inline u32 vp_ioread32 (const __le32 __iomem *addr) {return ioread32 (addr); }
Signature · 1 line
2.7.4
Hi Krzysztof,
Quoted 5 lines · Krzysztof Kozlowski
The ioread8/16/32() and others have inconsistent interface among the
architectures: some taking address as const, some not.It seems there is nothing really stopping all of them to take pointer to const.
Shouldn't all of them take const volatile __iomem pointers? It seems the "volatile" is missing from all but the implementations in include/asm-generic/io.h.
Quoted 9 lines
Patchset was really tested on all affected architectures. Build testing is in progress - I hope auto-builders will point any issues.
Todo
====
Convert also string versions (ioread16_rep()etc) if this aproach looks OK.
Quoted 4 lines
Merging
=======
The first 5 patches - iomap, alpha, sh, parisc and powerpc - should probably go via one tree, or even squashed into one.
Yes, they should be squashed, cfr. Arnd's comment. I also wouldn't bother doing the updates in patches 6-10.
The rest looks good to me.
Thanks a lot!
Gr{oetje,eeting}s,
Geert
Signature · 5 lines
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
Geert Uytterhoeven
Reviewed-byHi Krzysztof,
Quoted 10 lines · Geert Uytterhoeven
Quoted 5 lines · Krzysztof Kozlowski
The ioread8/16/32() and others have inconsistent interface among the
architectures: some taking address as const, some not.It seems there is nothing really stopping all of them to take pointer to const.
Shouldn't all of them take const volatile
__iomempointers? It seems the "volatile" is missing from all but the implementations ininclude/asm-generic/io.h.
As my "volatile" comment applies to iowrite*(), too, probably that should be done in a separate patch.
Hence with patches 1-5 squashed, and for patches 11-13:
Gr{oetje,eeting}s,
Geert
Signature · 5 lines
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
Quoted 15 lines · Geert Uytterhoeven
Hi Krzysztof,
Quoted 10 lines · Geert Uytterhoeven
Quoted 5 lines · Krzysztof Kozlowski
The ioread8/16/32() and others have inconsistent interface among the
architectures: some taking address as const, some not.It seems there is nothing really stopping all of them to take pointer to const.
Shouldn't all of them take const volatile
__iomempointers? It seems the "volatile" is missing from all but the implementations ininclude/asm-generic/io.h.
Quoted 5 lines
As my "volatile" comment applies to iowrite*(), too, probably that should be done in a separate patch.
Hence with patches 1-5 squashed, and for patches 11-13:
Reviewed-by Geert Uytterhoeven <[email protected]>
I'll add to this one also changes to ioreadX_rep() and add another patch for volatile for reads and writes. I guess your review will be appreciated once more because of ioreadX_rep()
Thanks,
Krzysztof
Le 08/01/2020 à 09:18, Krzysztof Kozlowski a écrit :
Quoted 19 lines · Geert Uytterhoeven
Quoted 18 lines
Hi Krzysztof,
Quoted 10 lines · Geert Uytterhoeven
Quoted 5 lines · Krzysztof Kozlowski
The ioread8/16/32() and others have inconsistent interface among the
architectures: some taking address as const, some not.It seems there is nothing really stopping all of them to take pointer to const.
Shouldn't all of them take const volatile
__iomempointers? It seems the "volatile" is missing from all but the implementations ininclude/asm-generic/io.h.As my "volatile" comment applies to iowrite*(), too, probably that should be done in a separate patch.
Quoted 7 lines
Quoted 2 lines
Hence with patches 1-5 squashed, and for patches 11-13:
Reviewed-by Geert Uytterhoeven <[email protected]>I'll add to this one also changes to
ioreadX_rep()and add another patch for volatile for reads and writes. I guess your review will be appreciated once more because ofioreadX_rep()
volatile should really only be used where deemed necessary:
https://www.kernel.org/doc/html/latest/process/volatile-considered-harmful.html
It is said: " ... accessor functions might use volatile on architectures where direct I/O memory access does work. Essentially, each accessor call becomes a little critical section on its own and ensures that the access happens as expected by the programmer."
Christophe
_______________________________________________
linux-snps-arc mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-snps-arc
Hi Christophe,
Quoted 24 lines · Christophe Leroy
Quoted 16 lines · Krzysztof Kozlowski
Quoted 15 lines · Geert Uytterhoeven
Quoted 10 lines · Geert Uytterhoeven
Quoted 5 lines · Krzysztof Kozlowski
The ioread8/16/32() and others have inconsistent interface among the
architectures: some taking address as const, some not.It seems there is nothing really stopping all of them to take pointer to const.
Shouldn't all of them take const volatile
__iomempointers? It seems the "volatile" is missing from all but the implementations ininclude/asm-generic/io.h.As my "volatile" comment applies to iowrite*(), too, probably that should be done in a separate patch.
Quoted 6 lines
Quoted 2 lines
Hence with patches 1-5 squashed, and for patches 11-13:
Reviewed-by Geert Uytterhoeven <[email protected]>I'll add to this one also changes to
ioreadX_rep()and add another patch for volatile for reads and writes. I guess your review will be appreciated once more because ofioreadX_rep()
Quoted 8 lines
volatile should really only be used where deemed necessary:
https://www.kernel.org/doc/html/latest/process/volatile-considered-harmful.html
It is said: " ... accessor functions might use volatile on architectures where direct I/O memory access does work. Essentially, each accessor call becomes a little critical section on its own and ensures that the access happens as expected by the programmer."
That is exactly the use case here: all above are accessor functions.
Why would ioreadX() not need volatile, while readY() does?
Gr{oetje,eeting}s,
Geert
Signature · 5 lines
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
Hi Geert,
Le 08/01/2020 à 09:43, Geert Uytterhoeven a écrit :
Quoted 31 lines
Hi Christophe,
Quoted 28 lines · Christophe Leroy
Quoted 16 lines · Krzysztof Kozlowski
Quoted 15 lines · Geert Uytterhoeven
Quoted 10 lines · Geert Uytterhoeven
Quoted 5 lines · Krzysztof Kozlowski
The ioread8/16/32() and others have inconsistent interface among the
architectures: some taking address as const, some not.It seems there is nothing really stopping all of them to take pointer to const.
Shouldn't all of them take const volatile
__iomempointers? It seems the "volatile" is missing from all but the implementations ininclude/asm-generic/io.h.As my "volatile" comment applies to iowrite*(), too, probably that should be done in a separate patch.
Quoted 6 lines
Quoted 2 lines
Hence with patches 1-5 squashed, and for patches 11-13:
Reviewed-by Geert Uytterhoeven <[email protected]>I'll add to this one also changes to
ioreadX_rep()and add another patch for volatile for reads and writes. I guess your review will be appreciated once more because ofioreadX_rep()volatile should really only be used where deemed necessary:
https://www.kernel.org/doc/html/latest/process/volatile-considered-harmful.html
Quoted 9 lines
Quoted 4 lines
It is said: " ... accessor functions might use volatile on architectures where direct I/O memory access does work. Essentially, each accessor call becomes a little critical section on its own and ensures that the access happens as expected by the programmer."
That is exactly the use case here: all above are accessor functions.
Why would
ioreadX()not need volatile, whilereadY()does?
My point was: it might be necessary for some arches and not for others.
And as pointed by Arnd, the volatile is really only necessary for the dereference itself, should the arch use dereferencing.
So I guess the best would be to go in the other direction: remove volatile keyword wherever possible instead of adding it where it is not needed.
Christophe
From: Christophe Leroy
Quoted 1 line
Sent: 08 January 2020 08:49
...
Quoted 2 lines
And as pointed by Arnd, the volatile is really only necessary for the dereference itself, should the arch use dereferencing.
I've had trouble with some versions of gcc and reading of 'volatile unsigned char *'. It tended to follow the memory read with an extra mask with 0xff.
(I suspect that internally the value landed into a temporary 'int' variable.)
I got better code using memory barriers.
So putting an asm barrier for the exact location of the memory read either side of the read should have the desired effect without adding extra instructions.
(You might think 'volatile' would mean that - but it doesn't.)
David
-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK Registration No: 1397386 (Wales)
Hi Geert,
Le 08/01/2020 à 09:43, Geert Uytterhoeven a écrit :
Quoted 31 lines
Hi Christophe,
Quoted 28 lines · Christophe Leroy
Quoted 16 lines · Krzysztof Kozlowski
Quoted 15 lines · Geert Uytterhoeven
Quoted 10 lines · Geert Uytterhoeven
Quoted 5 lines · Krzysztof Kozlowski
The ioread8/16/32() and others have inconsistent interface among the
architectures: some taking address as const, some not.It seems there is nothing really stopping all of them to take pointer to const.
Shouldn't all of them take const volatile
__iomempointers? It seems the "volatile" is missing from all but the implementations ininclude/asm-generic/io.h.As my "volatile" comment applies to iowrite*(), too, probably that should be done in a separate patch.
Quoted 6 lines
Quoted 2 lines
Hence with patches 1-5 squashed, and for patches 11-13:
Reviewed-by Geert Uytterhoeven <[email protected]>I'll add to this one also changes to
ioreadX_rep()and add another patch for volatile for reads and writes. I guess your review will be appreciated once more because ofioreadX_rep()volatile should really only be used where deemed necessary:
https://www.kernel.org/doc/html/latest/process/volatile-considered-harmful.html
Quoted 9 lines
Quoted 4 lines
It is said: " ... accessor functions might use volatile on architectures where direct I/O memory access does work. Essentially, each accessor call becomes a little critical section on its own and ensures that the access happens as expected by the programmer."
That is exactly the use case here: all above are accessor functions.
Why would
ioreadX()not need volatile, whilereadY()does?
My point was: it might be necessary for some arches and not for others.
And as pointed by Arnd, the volatile is really only necessary for the dereference itself, should the arch use dereferencing.
So I guess the best would be to go in the other direction: remove volatile keyword wherever possible instead of adding it where it is not needed.
Christophe
_______________________________________________
Virtualization mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/virtualization
Hi Christophe,
Quoted 24 lines · Christophe Leroy
Quoted 16 lines · Krzysztof Kozlowski
Quoted 15 lines · Geert Uytterhoeven
Quoted 10 lines · Geert Uytterhoeven
Quoted 5 lines · Krzysztof Kozlowski
The ioread8/16/32() and others have inconsistent interface among the
architectures: some taking address as const, some not.It seems there is nothing really stopping all of them to take pointer to const.
Shouldn't all of them take const volatile
__iomempointers? It seems the "volatile" is missing from all but the implementations ininclude/asm-generic/io.h.As my "volatile" comment applies to iowrite*(), too, probably that should be done in a separate patch.
Quoted 6 lines
Quoted 2 lines
Hence with patches 1-5 squashed, and for patches 11-13:
Reviewed-by Geert Uytterhoeven <[email protected]>I'll add to this one also changes to
ioreadX_rep()and add another patch for volatile for reads and writes. I guess your review will be appreciated once more because ofioreadX_rep()
Quoted 8 lines
volatile should really only be used where deemed necessary:
https://www.kernel.org/doc/html/latest/process/volatile-considered-harmful.html
It is said: " ... accessor functions might use volatile on architectures where direct I/O memory access does work. Essentially, each accessor call becomes a little critical section on its own and ensures that the access happens as expected by the programmer."
That is exactly the use case here: all above are accessor functions.
Why would ioreadX() not need volatile, while readY() does?
Gr{oetje,eeting}s,
Geert
Signature · 9 lines
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 _______________________________________________ Virtualization mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/virtualization
Arnd Bergmann
maintainerQuoted 7 lines · Christophe Leroy
Quoted 5 lines · Krzysztof Kozlowski
On Wed, 8 Jan 2020 at 09:13, Geert Uytterhoeven <[email protected]> wrote:
I'll add to this one also changes toioreadX_rep()and add another patch for volatile for reads and writes. I guess your review will be appreciated once more because ofioreadX_rep()
Quoted 8 lines
volatile should really only be used where deemed necessary:
https://www.kernel.org/doc/html/latest/process/volatile-considered-harmful.html
It is said: " ... accessor functions might use volatile on architectures where direct I/O memory access does work. Essentially, each accessor call becomes a little critical section on its own and ensures that the access happens as expected by the programmer."
The I/O accessors are one of the few places in which 'volatile' generally makes sense, at least for the implementations that do a plain pointer dereference (probably none of the ones in question here).
In case of readl/writel, this is what we do in asm-generic:
static inline u32 __raw_readl(const volatile void __iomem *addr)
{
return *(const volatile u32 __force *)addr;
}The __force-cast that removes the __iomem here also means that the 'volatile' keyword could be dropped from the argument list, as it has no real effect any more, but then there are a few drivers that mark their iomem pointers as either 'volatile void __iomem*' or (worse) 'volatile void *', so we keep it in the argument list to not add warnings for those drivers.
It may be time to change these drivers to not use volatile for __iomem pointers, but that seems out of scope for what Krzysztof is trying to do. Ideally we would be consistent here though, either using volatile all the time or never.
Arnd
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
Quoted 21 lines · Arnd Bergmann
Quoted 7 lines · Christophe Leroy
Quoted 5 lines · Krzysztof Kozlowski
On Wed, 8 Jan 2020 at 09:13, Geert Uytterhoeven <[email protected]> wrote:
I'll add to this one also changes toioreadX_rep()and add another patch for volatile for reads and writes. I guess your review will be appreciated once more because ofioreadX_rep()Quoted 8 lines
volatile should really only be used where deemed necessary:
https://www.kernel.org/doc/html/latest/process/volatile-considered-harmful.html
It is said: " ... accessor functions might use volatile on architectures where direct I/O memory access does work. Essentially, each accessor call becomes a little critical section on its own and ensures that the access happens as expected by the programmer."
The I/O accessors are one of the few places in which 'volatile' generally makes sense, at least for the implementations that do a plain pointer dereference (probably none of the ones in question here).
Quoted 6 lines
In case of readl/writel, this is what we do in asm-generic:
static inline u32
__raw_readl(const volatile void __iomem *addr){ return *(const volatile u32 __force *)addr; }
SuperH is another example:
1. ioread8_rep(void __iomem *addr, void *dst, unsigned long count) calls mmio_insb()
2. static inline void mmio_insb(void __iomem *addr, u8 *dst, int count) calls __raw_readb()
3. #define __raw_readb(a) (__chk_io_ptr(a), *(volatile u8 __force *)(a))
Even if interface was not marked as volatile, in fact its implementation was casting to volatile.
Quoted 11 lines
The __force-cast that removes the
__iomemhere also means that the 'volatile' keyword could be dropped from the argument list, as it has no real effect any more, but then there are a few drivers that mark their iomem pointers as either 'volatile void __iomem*' or (worse) 'volatile void *', so we keep it in the argument list to not add warnings for those drivers.It may be time to change these drivers to not use volatile for
__iomempointers, but that seems out of scope for what Krzysztof is trying to do. Ideally we would be consistent here though, either using volatile all the time or never.
Indeed. I guess there are no objections around const so let me send v2 for const only.
Best regards,
Krzysztof
_______________________________________________
Virtualization mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/virtualization
Arnd Bergmann
maintainerQuoted 7 lines · Krzysztof Kozlowski
Quoted 7 lines
The __force-cast that removes the
__iomemhere also means that the 'volatile' keyword could be dropped from the argument list, as it has no real effect any more, but then there are a few drivers that mark their iomem pointers as either 'volatile void __iomem*' or (worse) 'volatile void *', so we keep it in the argument list to not add warnings for those drivers.
Quoted 7 lines
Quoted 4 lines
It may be time to change these drivers to not use volatile for
__iomempointers, but that seems out of scope for what Krzysztof is trying to do. Ideally we would be consistent here though, either using volatile all the time or never.Indeed. I guess there are no objections around const so let me send v2 for const only.
Ok, sounds good. Maybe mention in the changelog then that the 'volatile' in the interface is intentionally left out, and that only users of readl/writel still have it to deal with existing drivers.
Arnd
Arnd Bergmann
maintainerQuoted 7 lines · Krzysztof Kozlowski
Quoted 7 lines
The __force-cast that removes the
__iomemhere also means that the 'volatile' keyword could be dropped from the argument list, as it has no real effect any more, but then there are a few drivers that mark their iomem pointers as either 'volatile void __iomem*' or (worse) 'volatile void *', so we keep it in the argument list to not add warnings for those drivers.
Quoted 7 lines
Quoted 4 lines
It may be time to change these drivers to not use volatile for
__iomempointers, but that seems out of scope for what Krzysztof is trying to do. Ideally we would be consistent here though, either using volatile all the time or never.Indeed. I guess there are no objections around const so let me send v2 for const only.
Ok, sounds good. Maybe mention in the changelog then that the 'volatile' in the interface is intentionally left out, and that only users of readl/writel still have it to deal with existing drivers.
Arnd
Arnd Bergmann
maintainerQuoted 7 lines · Christophe Leroy
Quoted 5 lines · Krzysztof Kozlowski
On Wed, 8 Jan 2020 at 09:13, Geert Uytterhoeven <[email protected]> wrote:
I'll add to this one also changes toioreadX_rep()and add another patch for volatile for reads and writes. I guess your review will be appreciated once more because ofioreadX_rep()
Quoted 8 lines
volatile should really only be used where deemed necessary:
https://www.kernel.org/doc/html/latest/process/volatile-considered-harmful.html
It is said: " ... accessor functions might use volatile on architectures where direct I/O memory access does work. Essentially, each accessor call becomes a little critical section on its own and ensures that the access happens as expected by the programmer."
The I/O accessors are one of the few places in which 'volatile' generally makes sense, at least for the implementations that do a plain pointer dereference (probably none of the ones in question here).
In case of readl/writel, this is what we do in asm-generic:
static inline u32 __raw_readl(const volatile void __iomem *addr)
{
return *(const volatile u32 __force *)addr;
}The __force-cast that removes the __iomem here also means that the 'volatile' keyword could be dropped from the argument list, as it has no real effect any more, but then there are a few drivers that mark their iomem pointers as either 'volatile void __iomem*' or (worse) 'volatile void *', so we keep it in the argument list to not add warnings for those drivers.
It may be time to change these drivers to not use volatile for __iomem pointers, but that seems out of scope for what Krzysztof is trying to do. Ideally we would be consistent here though, either using volatile all the time or never.
Arnd
_______________________________________________
Virtualization mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/virtualization
Le 08/01/2020 à 09:18, Krzysztof Kozlowski a écrit :
Quoted 19 lines · Geert Uytterhoeven
Quoted 18 lines
Hi Krzysztof,
Quoted 10 lines · Geert Uytterhoeven
Quoted 5 lines · Krzysztof Kozlowski
The ioread8/16/32() and others have inconsistent interface among the
architectures: some taking address as const, some not.It seems there is nothing really stopping all of them to take pointer to const.
Shouldn't all of them take const volatile
__iomempointers? It seems the "volatile" is missing from all but the implementations ininclude/asm-generic/io.h.As my "volatile" comment applies to iowrite*(), too, probably that should be done in a separate patch.
Quoted 7 lines
Quoted 2 lines
Hence with patches 1-5 squashed, and for patches 11-13:
Reviewed-by Geert Uytterhoeven <[email protected]>I'll add to this one also changes to
ioreadX_rep()and add another patch for volatile for reads and writes. I guess your review will be appreciated once more because ofioreadX_rep()
volatile should really only be used where deemed necessary:
https://www.kernel.org/doc/html/latest/process/volatile-considered-harmful.html
It is said: " ... accessor functions might use volatile on architectures where direct I/O memory access does work. Essentially, each accessor call becomes a little critical section on its own and ensures that the access happens as expected by the programmer."
Christophe
_______________________________________________
Virtualization mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/virtualization
Quoted 15 lines · Geert Uytterhoeven
Hi Krzysztof,
Quoted 10 lines · Geert Uytterhoeven
Quoted 5 lines · Krzysztof Kozlowski
The ioread8/16/32() and others have inconsistent interface among the
architectures: some taking address as const, some not.It seems there is nothing really stopping all of them to take pointer to const.
Shouldn't all of them take const volatile
__iomempointers? It seems the "volatile" is missing from all but the implementations ininclude/asm-generic/io.h.
Quoted 5 lines
As my "volatile" comment applies to iowrite*(), too, probably that should be done in a separate patch.
Hence with patches 1-5 squashed, and for patches 11-13:
Reviewed-by Geert Uytterhoeven <[email protected]>
I'll add to this one also changes to ioreadX_rep() and add another patch for volatile for reads and writes. I guess your review will be appreciated once more because of ioreadX_rep()
Thanks,
Krzysztof
Geert Uytterhoeven
Reviewed-byHi Krzysztof,
Quoted 10 lines · Geert Uytterhoeven
Quoted 5 lines · Krzysztof Kozlowski
The ioread8/16/32() and others have inconsistent interface among the
architectures: some taking address as const, some not.It seems there is nothing really stopping all of them to take pointer to const.
Shouldn't all of them take const volatile
__iomempointers? It seems the "volatile" is missing from all but the implementations ininclude/asm-generic/io.h.
As my "volatile" comment applies to iowrite*(), too, probably that should be done in a separate patch.
Hence with patches 1-5 squashed, and for patches 11-13:
Gr{oetje,eeting}s,
Geert
Signature · 5 lines
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
Quoted 7 lines · Geert Uytterhoeven
Hi Krzysztof,
Quoted 3 lines · Krzysztof Kozlowski
The ioread8/16/32() and others have inconsistent interface among the
architectures: some taking address as const, some not.
Quoted 6 lines
Quoted 2 lines
It seems there is nothing really stopping all of them to take pointer to const.
Shouldn't all of them take const volatile
__iomempointers? It seems the "volatile" is missing from all but the implementations ininclude/asm-generic/io.h.
It's kind of separate issue although I could squash it to limit redundant changes.
Quoted 1 line
Quoted 1 line
Patchset was really tested on all affected architectures.
I just spot an error in my first message. I wanted to say:
"Patchset was NOT really tested on all affected architectures."
Obviously.
Quoted 8 lines
Quoted 8 lines
Build testing is in progress - I hope auto-builders will point any issues.
Todo
====
Convert also string versions (ioread16_rep()etc) if this aproach looks OK.
Quoted 7 lines
Quoted 4 lines
Merging
=======
The first 5 patches - iomap, alpha, sh, parisc and powerpc - should probably go via one tree, or even squashed into one.Yes, they should be squashed, cfr. Arnd's comment. I also wouldn't bother doing the updates in patches 6-10.
Indeed, thanks for comments.
Best regards,
Krzysztof
Quoted 7 lines · Geert Uytterhoeven
Hi Krzysztof,
Quoted 3 lines · Krzysztof Kozlowski
The ioread8/16/32() and others have inconsistent interface among the
architectures: some taking address as const, some not.
Quoted 6 lines
Quoted 2 lines
It seems there is nothing really stopping all of them to take pointer to const.
Shouldn't all of them take const volatile
__iomempointers? It seems the "volatile" is missing from all but the implementations ininclude/asm-generic/io.h.
It's kind of separate issue although I could squash it to limit redundant changes.
Quoted 1 line
Quoted 1 line
Patchset was really tested on all affected architectures.
I just spot an error in my first message. I wanted to say:
"Patchset was NOT really tested on all affected architectures."
Obviously.
Quoted 8 lines
Quoted 8 lines
Build testing is in progress - I hope auto-builders will point any issues.
Todo
====
Convert also string versions (ioread16_rep()etc) if this aproach looks OK.
Quoted 7 lines
Quoted 4 lines
Merging
=======
The first 5 patches - iomap, alpha, sh, parisc and powerpc - should probably go via one tree, or even squashed into one.Yes, they should be squashed, cfr. Arnd's comment. I also wouldn't bother doing the updates in patches 6-10.
Indeed, thanks for comments.
Best regards,
Krzysztof
Hi Krzysztof,
Quoted 5 lines · Krzysztof Kozlowski
The ioread8/16/32() and others have inconsistent interface among the
architectures: some taking address as const, some not.It seems there is nothing really stopping all of them to take pointer to const.
Shouldn't all of them take const volatile __iomem pointers? It seems the "volatile" is missing from all but the implementations in include/asm-generic/io.h.
Quoted 9 lines
Patchset was really tested on all affected architectures. Build testing is in progress - I hope auto-builders will point any issues.
Todo
====
Convert also string versions (ioread16_rep()etc) if this aproach looks OK.
Quoted 4 lines
Merging
=======
The first 5 patches - iomap, alpha, sh, parisc and powerpc - should probably go via one tree, or even squashed into one.
Yes, they should be squashed, cfr. Arnd's comment. I also wouldn't bother doing the updates in patches 6-10.
The rest looks good to me.
Thanks a lot!
Gr{oetje,eeting}s,
Geert
Signature · 5 lines
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