MMIO: make mmio operators type safe.
authorRonald G. Minnich <rminnich@gmail.com>
Mon, 22 Aug 2016 15:12:29 +0000 (08:12 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Wed, 24 Aug 2016 00:14:32 +0000 (20:14 -0400)
The operators took void *, which made it extremely
hard to debug incorrect usage, which I had a lot of
in the ahci driver. They are now type safe, e.g.
a write to a byte requires a uint8_t*, not a void *.

Change-Id: I089a8f3c5d71fcbc3250535e47e998ee3c15f08e
Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
[mlx4 recast, checkpatch fixups]
Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
kern/drivers/net/mlx4/main.c
kern/include/mmio.h

index c984ca1..93ec0eb 100644 (file)
@@ -1750,7 +1750,7 @@ static void mlx4_reset_vf_support(struct mlx4_dev *dev)
        uint32_t comm_rst;
        uint32_t comm_caps;
 
-       comm_caps = swab32(read32((__iomem char *)priv->mfunc.comm +
+       comm_caps = swab32(read32((__iomem uint32_t*)priv->mfunc.comm +
                                  MLX4_COMM_CHAN_CAPS));
        comm_rst = (comm_caps & (uint32_t)(1 << COMM_CHAN_RST_OFFSET));
 
index 70bb3f9..b4ade73 100644 (file)
  * On the simple architectures, we just read/write the memory location
  * directly.
  */
-static inline uint8_t __raw_read8(const volatile void __iomem *addr)
+static inline uint8_t __raw_read8(const volatile uint8_t __iomem *addr)
 {
        return *(const volatile uint8_t __force *)addr;
 }
 
-static inline uint16_t __raw_read16(const volatile void __iomem *addr)
+static inline uint16_t __raw_read16(const volatile uint16_t __iomem *addr)
 {
        return *(const volatile uint16_t __force *)addr;
 }
 
-static inline uint32_t __raw_read32(const volatile void __iomem *addr)
+static inline uint32_t __raw_read32(const volatile uint32_t __iomem *addr)
 {
        return *(const volatile uint32_t __force *)addr;
 }
 
-static inline uint64_t __raw_read64(const volatile void __iomem *addr)
+static inline uint64_t __raw_read64(const volatile uint64_t __iomem *addr)
 {
        return *(const volatile uint64_t __force *)addr;
 }
 
-static inline void __raw_write8(uint8_t value, volatile void __iomem *addr)
+static inline void __raw_write8(uint8_t value, volatile uint8_t __iomem *addr)
 {
        *(volatile uint8_t __force *)addr = value;
 }
 
-static inline void __raw_write16(uint16_t value, volatile void __iomem *addr)
+static inline void __raw_write16(uint16_t value,
+                                 volatile uint16_t __iomem *addr)
 {
        *(volatile uint16_t __force *)addr = value;
 }
 
-static inline void __raw_write32(uint32_t value, volatile void __iomem *addr)
+static inline void __raw_write32(uint32_t value,
+                                 volatile uint32_t __iomem *addr)
 {
        *(volatile uint32_t __force *)addr = value;
 }
 
-static inline void __raw_write64(uint64_t value, volatile void __iomem *addr)
+static inline void __raw_write64(uint64_t value,
+                                 volatile uint64_t __iomem *addr)
 {
        *(volatile uint64_t __force *)addr = value;
 }
@@ -72,42 +75,42 @@ static inline void __raw_write64(uint64_t value, volatile void __iomem *addr)
  * {read,write}{8,16,32,64}() access little endian memory and return result in
  * native endianness.
  */
-static inline uint8_t read8(const volatile void __iomem *addr)
+static inline uint8_t read8(const volatile uint8_t __iomem *addr)
 {
        return __raw_read8(addr);
 }
 
-static inline uint16_t read16(const volatile void __iomem *addr)
+static inline uint16_t read16(const volatile uint16_t __iomem *addr)
 {
        return le16_to_cpu(__raw_read16(addr));
 }
 
-static inline uint32_t read32(const volatile void __iomem *addr)
+static inline uint32_t read32(const volatile uint32_t __iomem *addr)
 {
        return le32_to_cpu(__raw_read32(addr));
 }
 
-static inline uint64_t read64(const volatile void __iomem *addr)
+static inline uint64_t read64(const volatile uint64_t __iomem *addr)
 {
        return le64_to_cpu(__raw_read64(addr));
 }
 
-static inline void write8(uint8_t value, volatile void __iomem *addr)
+static inline void write8(uint8_t value, volatile uint8_t __iomem *addr)
 {
        __raw_write8(value, addr);
 }
 
-static inline void write16(uint16_t value, volatile void __iomem *addr)
+static inline void write16(uint16_t value, volatile uint16_t __iomem *addr)
 {
        __raw_write16(cpu_to_le16(value), addr);
 }
 
-static inline void write32(uint32_t value, volatile void __iomem *addr)
+static inline void write32(uint32_t value, volatile uint32_t __iomem *addr)
 {
        __raw_write32(cpu_to_le32(value), addr);
 }
 
-static inline void write64(uint64_t value, volatile void __iomem *addr)
+static inline void write64(uint64_t value, volatile uint64_t __iomem *addr)
 {
        __raw_write64(cpu_to_le64(value), addr);
 }