Use accessor functions for MMIO

Some MMIO accesses used volatile, others didn't (and risked
non-execution of side effects) and even with volatile, some accesses
looked dubious.

Since the MMIO accessor functions and the onboard flash accessor
functions are functionally identical (but have different signatures),
make the flash accessors wrappers for the MMIO accessors.

For some of the conversions, I used Coccinelle. Semantic patch follows:

@@ typedef uint8_t; expression a; volatile uint8_t *b; @@ - b[a] + *(b
+ a) @@ expression a; volatile uint8_t *b; @@ - *(b) |= (a); + *(b) =
*(b) | (a); @@ expression a; volatile uint8_t *b; @@ - *(b) = (a); +
mmio_writeb(a, b); @@ volatile uint8_t *b; @@ - *(b) + mmio_readb(b) @@
type T; T b; @@ ( mmio_readb | mmio_writeb ) (..., - (T) - (b) + b )

Corresponding to flashrom svn r524.

Signed-off-by: Carl-Daniel Hailfinger <c-d.hailfinger.devel.2006@gmx.net>

Uwe tested read, write, erase with this patch on a random board to make
sure nothing breaks.

Acked-by: Uwe Hermann <uwe@hermann-uwe.de>

1 files changed, 35 insertions, 5 deletions

diff --git a/internal.c b/internal.c
index a9829a8..d2a9ae2 100644
--- a/internal.c
+++ b/internal.c
@@ -137,31 +137,61 @@ int internal_shutdown(void)
 
 void internal_chip_writeb(uint8_t val, chipaddr addr)
 {
-	*(volatile uint8_t *) addr = val;
+	mmio_writeb(val, (void *) addr);
 }
 
 void internal_chip_writew(uint16_t val, chipaddr addr)
 {
-	*(volatile uint16_t *) addr = val;
+	mmio_writew(val, (void *) addr);
 }
 
 void internal_chip_writel(uint32_t val, chipaddr addr)
 {
-	*(volatile uint32_t *) addr = val;
+	mmio_writel(val, (void *) addr);
 }
 
 uint8_t internal_chip_readb(const chipaddr addr)
 {
-	return *(volatile uint8_t *) addr;
+	return mmio_readb((void *) addr);
 }
 
 uint16_t internal_chip_readw(const chipaddr addr)
 {
-	return *(volatile uint16_t *) addr;
+	return mmio_readw((void *) addr);
 }
 
 uint32_t internal_chip_readl(const chipaddr addr)
 {
+	return mmio_readl((void *) addr);
+}
+
+void mmio_writeb(uint8_t val, void *addr)
+{
+	*(volatile uint8_t *) addr = val;
+}
+
+void mmio_writew(uint16_t val, void *addr)
+{
+	*(volatile uint16_t *) addr = val;
+}
+
+void mmio_writel(uint32_t val, void *addr)
+{
+	*(volatile uint32_t *) addr = val;
+}
+
+uint8_t mmio_readb(void *addr)
+{
+	return *(volatile uint8_t *) addr;
+}
+
+uint16_t mmio_readw(void *addr)
+{
+	return *(volatile uint16_t *) addr;
+}
+
+uint32_t mmio_readl(void *addr)
+{
 	return *(volatile uint32_t *) addr;
 }