ARM: Avoid compiler optimization for usages of readb, writeb and friends.

gcc 4.5.1 seems to ignore (at least some) volatile definitions, avoid that as done in the kernel.

Reading C99 6.7.3 8 and the comment 114) there, I think it is a bug of that gcc version to ignore the volatile type qualifier used e.g. in __arch_getl(). Anyway, using a definition as in the kernel headers avoids such optimizations when gcc 4.5.1 is used.

Maybe the headers as used in the current linux-kernel should be used, but to avoid large changes, I've just added a small change to the current headers.

I haven't add the definitions which are using a memory barrier because I haven't found a place in the kernel where they were actually enabled (CONFIG_ARM_DMA_MEM_BUFFERABLE).

Signed-off-by Alexander Holler<[email protected]>

---
  arch/arm/include/asm/io.h |   20 ++++++++++++++------
  1 files changed, 14 insertions(+), 6 deletions(-)

arch/arm/include/asm/io.h +14 -6

index ff1518e..068ed17 100644
@@ -125,13 +125,21 @@ extern inline void __raw_readsl(unsigned int addr, void *data, int longlen)
  #define __raw_readw(a)			__arch_getw(a)
  #define __raw_readl(a)			__arch_getl(a)
 
-#define writeb(v,a)			__arch_putb(v,a)
-#define writew(v,a)			__arch_putw(v,a)
-#define writel(v,a)			__arch_putl(v,a)
+/*
+ * TODO: The kernel offers some more advanced versions of barriers, it might
+ * have some advantages to use them instead of the simple one here.
+ */
+#define dmb()				__asm__ __volatile__ ("" : : : "memory")
+#define __iormb()			dmb()
+#define __iowmb()			dmb()
+
+#define writeb(v,c)			do { __iowmb(); __arch_putb(v,c); } while (0)
+#define writew(v,c)			do { __iowmb(); __arch_putw(v,c); } while (0)
+#define writel(v,c)			do { __iowmb(); __arch_putl(v,c); } while (0)
 
-#define readb(a)			__arch_getb(a)
-#define readw(a)			__arch_getw(a)
-#define readl(a)			__arch_getl(a)
+#define readb(c)			({ u8  __v = __arch_getb(c); __iormb(); __v; })
+#define readw(c)			({ u16 __v = __arch_getw(c); __iormb(); __v; })
+#define readl(c)			({ u32 __v = __arch_getl(c); __iormb(); __v; })
 
  /*
   * The compiler seems to be incapable of optimising constants

This patch seems to be the same as the proposal from Wolfgang

http://lists.denx.de/pipermail/u-boot/2010-December/084122.html

So we shouldn't drop his

Signed-off-by Wolfgang Denk <[email protected]>

Besides of this

Acked-by Dirk Behme <[email protected]>

gcc 4.5.1 seems to ignore (at least some) volatile definitions, avoid that as done in the kernel.

Reading C99 6.7.3 8 and the comment 114) there, I think it is a bug of that gcc version to ignore the volatile type qualifier used e.g. in __arch_getl(). Anyway, using a definition as in the kernel headers avoids such optimizations when gcc 4.5.1 is used.

Maybe the headers as used in the current linux-kernel should be used, but to avoid large changes, I've just added a small change to the current headers.

I haven't add the definitions which are using a memory barrier because I haven't found a place in the kernel where they were actually enabled (CONFIG_ARM_DMA_MEM_BUFFERABLE).

Signed-off-by Alexander Holler<[email protected]>

---
  arch/arm/include/asm/io.h |   20 ++++++++++++++------
  1 files changed, 14 insertions(+), 6 deletions(-)

arch/arm/include/asm/io.h +8 -3

index ff1518e..068ed17 100644
@@ -125,13 +125,21 @@ extern inline void __raw_readsl(unsigned int addr, void *data, int longlen)
  #define __raw_readw(a)			__arch_getw(a)
  #define __raw_readl(a)			__arch_getl(a)
 
-#define writeb(v,a)			__arch_putb(v,a)
-#define writew(v,a)			__arch_putw(v,a)
-#define writel(v,a)			__arch_putl(v,a)
+/*
+ * TODO: The kernel offers some more advanced versions of barriers, it might
+ * have some advantages to use them instead of the simple one here.
+ */
+#define dmb()				__asm__ __volatile__ ("" : : : "memory")
+#define __iormb()			dmb()
+#define __iowmb()			dmb()
+

Quoted 11 lines

gcc 4.5.1 seems to ignore (at least some) volatile definitions, avoid that as done in the kernel.

Reading C99 6.7.3 8 and the comment 114) there, I think it is a bug of that
gcc version to ignore the volatile type qualifier used e.g. in __arch_getl().
Anyway, using a definition as in the kernel headers avoids such optimizations when
gcc 4.5.1 is used.

Quoted 3 lines

Maybe the headers as used in the current linux-kernel should be used, but to avoid large changes, I've just added a small change to the current headers.

Do you like to test the patch in the attachment? I named it 'v4'.

After some thinking and testing, it seems to me that the volatile optimization issue this patch shall fix is only with the readx() macros. So the idea is to drop all writex() changes done in the v3 version of this patch. With dropping the writex() changes, we would drop all issues we discussed with e.g. the GCC statement-expression and the do while workaround, too.

Hello,

Am 01.01.2011 13:04, schrieb Dirk Behme:

Quoted 18 lines · Alexander Holler

Quoted 11 lines

gcc 4.5.1 seems to ignore (at least some) volatile definitions, avoid that as done in the kernel.

Reading C99 6.7.3 8 and the comment 114) there, I think it is a bug of that
gcc version to ignore the volatile type qualifier used e.g. in __arch_getl().
Anyway, using a definition as in the kernel headers avoids such optimizations when
gcc 4.5.1 is used.

Quoted 3 lines

Maybe the headers as used in the current linux-kernel should be used, but to avoid large changes, I've just added a small change to the current headers.

Do you like to test the patch in the attachment? I named it 'v4'.

Quoted 8 lines

After some thinking and testing, it seems to me that the volatile optimization issue this patch shall fix is only with the readx() macros.
So the idea is to drop all writex() changes done in the v3 version of this patch. With dropping the writex() changes, we would drop all issues
we discussed with e.g. the GCC statement-expression and the do while workaround, too.

I've come across a bug which reads as the problem might be fixed in gcc 4.5.2:

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=45052

I will test gcc 4.5.2 in the next days.

Quoted 30 lines

Hello,

Am 01.01.2011 13:04, schrieb Dirk Behme:

Quoted 26 lines · Alexander Holler

Quoted 11 lines

gcc 4.5.1 seems to ignore (at least some) volatile definitions, avoid that as done in the kernel.

Reading C99 6.7.3 8 and the comment 114) there, I think it is a bug of that
gcc version to ignore the volatile type qualifier used e.g. in __arch_getl().
Anyway, using a definition as in the kernel headers avoids such optimizations when
gcc 4.5.1 is used.

Quoted 3 lines

Maybe the headers as used in the current linux-kernel should be used, but to avoid large changes, I've just added a small change to the current headers.

Do you like to test the patch in the attachment? I named it 'v4'.

After some thinking and testing, it seems to me that the volatile optimization issue this patch shall fix is only with the readx() macros.
So the idea is to drop all writex() changes done in the v3 version of this patch. With dropping the writex() changes, we would drop all issues
we discussed with e.g. the GCC statement-expression and the do while workaround, too.

Quoted 6 lines

I've come across a bug which reads as the problem might be fixed in gcc 4.5.2:

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=45052

I will test gcc 4.5.2 in the next days.

Have you been able to test v4 of the patch I sent with gcc 4.5.1?

Am 01.01.2011 19:25, schrieb Dirk Behme:

Quoted 36 lines · Alexander Holler

Quoted 35 lines

Hello,

Am 01.01.2011 13:04, schrieb Dirk Behme:

Quoted 20 lines · Alexander Holler

Quoted 12 lines

gcc 4.5.1 seems to ignore (at least some) volatile definitions, avoid that as done in the kernel.

Reading C99 6.7.3 8 and the comment 114) there, I think it is a bug of
that
gcc version to ignore the volatile type qualifier used e.g. in __arch_getl().
Anyway, using a definition as in the kernel headers avoids such optimizations when
gcc 4.5.1 is used.

Quoted 4 lines

Maybe the headers as used in the current linux-kernel should be used,
but to avoid large changes, I've just added a small change to the current headers.

Do you like to test the patch in the attachment? I named it 'v4'.

Quoted 8 lines

After some thinking and testing, it seems to me that the volatile optimization issue this patch shall fix is only with the readx() macros.
So the idea is to drop all writex() changes done in the v3 version of this patch. With dropping the writex() changes, we would drop all issues
we discussed with e.g. the GCC statement-expression and the do while workaround, too.

I've come across a bug which reads as the problem might be fixed in gcc 4.5.2:

Quoted 5 lines

Quoted 3 lines

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=45052

I will test gcc 4.5.2 in the next days.

Have you been able to test v4 of the patch I sent with gcc 4.5.1?

No, sorry, I don't have a test case for consequent write* and I will have to write one.

Quoted 37 lines

Am 01.01.2011 19:25, schrieb Dirk Behme:

Quoted 36 lines · Alexander Holler

Quoted 35 lines

Hello,

Am 01.01.2011 13:04, schrieb Dirk Behme:

Quoted 20 lines · Alexander Holler

Quoted 12 lines

gcc 4.5.1 seems to ignore (at least some) volatile definitions, avoid that as done in the kernel.

Reading C99 6.7.3 8 and the comment 114) there, I think it is a bug of
that
gcc version to ignore the volatile type qualifier used e.g. in __arch_getl().
Anyway, using a definition as in the kernel headers avoids such optimizations when
gcc 4.5.1 is used.

Quoted 4 lines

Maybe the headers as used in the current linux-kernel should be used,
but to avoid large changes, I've just added a small change to the current headers.

Do you like to test the patch in the attachment? I named it 'v4'.

Quoted 8 lines

After some thinking and testing, it seems to me that the volatile optimization issue this patch shall fix is only with the readx() macros.
So the idea is to drop all writex() changes done in the v3 version of this patch. With dropping the writex() changes, we would drop all issues
we discussed with e.g. the GCC statement-expression and the do while workaround, too.

I've come across a bug which reads as the problem might be fixed in gcc 4.5.2:

Quoted 8 lines

Quoted 5 lines

Quoted 3 lines

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=45052

I will test gcc 4.5.2 in the next days.

Have you been able to test v4 of the patch I sent with gcc 4.5.1?

No, sorry, I don't have a test case for consequent write* and I will have to write one.

?

If I remember correctly, the test case for this patch was compiling U-Boot with 4.5.1 and then check

a) if it boots at Beagle (correct clock.c)
b) if NAND works ok (correct omap_gpmc.c)

?

Am 01.01.2011 20:21, schrieb Dirk Behme:

Quoted 51 lines · Alexander Holler

Quoted 39 lines

Am 01.01.2011 19:25, schrieb Dirk Behme:

Quoted 38 lines · Alexander Holler

Quoted 37 lines

Hello,

Am 01.01.2011 13:04, schrieb Dirk Behme:

Quoted 20 lines · Alexander Holler

Quoted 12 lines

gcc 4.5.1 seems to ignore (at least some) volatile definitions, avoid that as done in the kernel.

Reading C99 6.7.3 8 and the comment 114) there, I think it is a bug of
that
gcc version to ignore the volatile type qualifier used e.g. in __arch_getl().
Anyway, using a definition as in the kernel headers avoids such optimizations when
gcc 4.5.1 is used.

Quoted 4 lines

Maybe the headers as used in the current linux-kernel should be used,
but to avoid large changes, I've just added a small change to the current headers.

Do you like to test the patch in the attachment? I named it 'v4'.

Quoted 10 lines

After some thinking and testing, it seems to me that the volatile optimization issue this patch shall fix is only with the readx() macros.
So the idea is to drop all writex() changes done in the v3 version of
this patch. With dropping the writex() changes, we would drop all issues
we discussed with e.g. the GCC statement-expression and the do while
workaround, too.

I've come across a bug which reads as the problem might be fixed in gcc 4.5.2:

Quoted 8 lines

Quoted 5 lines

Quoted 3 lines

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=45052

I will test gcc 4.5.2 in the next days.

Have you been able to test v4 of the patch I sent with gcc 4.5.1?

No, sorry, I don't have a test case for consequent write* and I will have to write one.

?

Quoted 7 lines

If I remember correctly, the test case for this patch was compiling U-Boot with 4.5.1 and then check

a) if it boots at Beagle (correct clock.c)
b) if NAND works ok (correct omap_gpmc.c)

?

No. None of those must fail when the compiler optimizes consequent write* to one write* because the compiler ignores the volatile keyword. I've only found the problem with consequent read* (in clock.c), but there might be problems with consequent write* somewhere else too. So if you remove the change for those write* some other problems might arise and just through booting a kernel those might not be found. So I think it would be dangerous to remove the change for write* when using gcc 4.5.x

And because the patch fixes only write* and read* some stuff in u-boot which uses volatile in another context might still fail, therefore I vote to use the current kernel headers where other things besides read* and write* are using those barriers too.

Quoted 69 lines · Alexander Holler

Am 01.01.2011 20:21, schrieb Dirk Behme:

Quoted 51 lines · Alexander Holler

Quoted 39 lines

Am 01.01.2011 19:25, schrieb Dirk Behme:

Quoted 38 lines · Alexander Holler

Quoted 37 lines

Hello,

Am 01.01.2011 13:04, schrieb Dirk Behme:

Quoted 20 lines · Alexander Holler

Quoted 12 lines

gcc 4.5.1 seems to ignore (at least some) volatile definitions, avoid that as done in the kernel.

Reading C99 6.7.3 8 and the comment 114) there, I think it is a bug of
that
gcc version to ignore the volatile type qualifier used e.g. in __arch_getl().
Anyway, using a definition as in the kernel headers avoids such optimizations when
gcc 4.5.1 is used.

Quoted 4 lines

Maybe the headers as used in the current linux-kernel should be used,
but to avoid large changes, I've just added a small change to the current headers.

Do you like to test the patch in the attachment? I named it 'v4'.

Quoted 10 lines

After some thinking and testing, it seems to me that the volatile optimization issue this patch shall fix is only with the readx() macros.
So the idea is to drop all writex() changes done in the v3 version of
this patch. With dropping the writex() changes, we would drop all issues
we discussed with e.g. the GCC statement-expression and the do while
workaround, too.

I've come across a bug which reads as the problem might be fixed in gcc 4.5.2:

Quoted 8 lines

Quoted 5 lines

Quoted 3 lines

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=45052

I will test gcc 4.5.2 in the next days.

Have you been able to test v4 of the patch I sent with gcc 4.5.1?

No, sorry, I don't have a test case for consequent write* and I will have to write one.

?

Quoted 7 lines

If I remember correctly, the test case for this patch was compiling U-Boot with 4.5.1 and then check

a) if it boots at Beagle (correct clock.c)
b) if NAND works ok (correct omap_gpmc.c)

?

No. None of those must fail when the compiler optimizes consequent write* to one write* because the compiler ignores the volatile keyword. I've only found the problem with consequent read* (in clock.c), but there might be problems with consequent write* somewhere else too. So if you remove the change for those write* some other problems might arise and just through booting a kernel those might not be found. So I think it would be dangerous to remove the change for write* when using gcc 4.5.x

Quoted 4 lines

And because the patch fixes only write* and read* some stuff in u-boot which uses volatile in another context might still fail, therefore I vote to use the current kernel headers where other things besides read* and write* are using those barriers too.

Just to understand correctly: Do you want to say that we should ignore your v3 patch

http://lists.denx.de/pipermail/u-boot/2010-December/084132.html

?

And that you didn't test the v4 patch

http://lists.denx.de/pipermail/u-boot/2011-January/084481.html

with the test you did in

http://lists.denx.de/pipermail/u-boot/2010-December/084134.html

("tested with both gcc 4.3.5 and gcc 4.5.1 using binutils 2.20.1") because you now think this test isn't sufficient?

Quoted 90 lines · Alexander Holler

Quoted 69 lines

Am 01.01.2011 20:21, schrieb Dirk Behme:

Quoted 51 lines · Alexander Holler

Quoted 39 lines

Am 01.01.2011 19:25, schrieb Dirk Behme:

Quoted 38 lines · Alexander Holler

Quoted 37 lines

Hello,

Am 01.01.2011 13:04, schrieb Dirk Behme:

Quoted 20 lines · Alexander Holler

Quoted 12 lines

gcc 4.5.1 seems to ignore (at least some) volatile definitions, avoid that as done in the kernel.

Reading C99 6.7.3 8 and the comment 114) there, I think it is a bug of
that
gcc version to ignore the volatile type qualifier used e.g. in __arch_getl().
Anyway, using a definition as in the kernel headers avoids such optimizations when
gcc 4.5.1 is used.

Quoted 4 lines

Maybe the headers as used in the current linux-kernel should be used,
but to avoid large changes, I've just added a small change to the current headers.

Do you like to test the patch in the attachment? I named it 'v4'.

Quoted 10 lines

After some thinking and testing, it seems to me that the volatile optimization issue this patch shall fix is only with the readx() macros.
So the idea is to drop all writex() changes done in the v3 version of
this patch. With dropping the writex() changes, we would drop all issues
we discussed with e.g. the GCC statement-expression and the do while
workaround, too.

I've come across a bug which reads as the problem might be fixed in gcc 4.5.2:

Quoted 8 lines

Quoted 5 lines

Quoted 3 lines

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=45052

I will test gcc 4.5.2 in the next days.

Have you been able to test v4 of the patch I sent with gcc 4.5.1?

No, sorry, I don't have a test case for consequent write* and I will have to write one.

?

Quoted 7 lines

If I remember correctly, the test case for this patch was compiling U-Boot with 4.5.1 and then check

a) if it boots at Beagle (correct clock.c)
b) if NAND works ok (correct omap_gpmc.c)

?

No. None of those must fail when the compiler optimizes consequent write* to one write* because the compiler ignores the volatile keyword. I've only found the problem with consequent read* (in clock.c), but there might be problems with consequent write* somewhere else too. So if you remove the change for those write* some other problems might arise and just through booting a kernel those might not be found. So I think it would be dangerous to remove the change for write* when using gcc 4.5.x

Quoted 4 lines

And because the patch fixes only write* and read* some stuff in u-boot which uses volatile in another context might still fail, therefore I vote to use the current kernel headers where other things besides read* and write* are using those barriers too.

Just to understand correctly: Do you want to say that we should ignore your v3 patch

http://lists.denx.de/pipermail/u-boot/2010-December/084132.html

?

And that you didn't test the v4 patch

http://lists.denx.de/pipermail/u-boot/2011-January/084481.html

with the test you did in

http://lists.denx.de/pipermail/u-boot/2010-December/084134.html

Quoted 2 lines

("tested with both gcc 4.3.5 and gcc 4.5.1 using binutils 2.20.1") because you now think this test isn't sufficient?

Sorry, but I don't understand why you are assuming that the compiler will only use those (wrong) optimizations on reads and not writes.

If the compiler does the same wrong optimizations for writes (why not, if it ignores volatile), your v4 would'nt fix that.

Beeing kind of a defensive programmer, I still would prefer to use have that __asm__ for write* too. That would at least prevent us from a possible bug there too.

Dear Alexander Holler,

Quoted 1 line · In message<[email protected]> you wrote:

Quoted 3 lines

Beeing kind of a defensive programmer, I still would prefer to use have that __asm__ for write* too. That would at least prevent us from a possible bug there too.

So why don't you simply test and, assuming it's working, ACK the patch I submitted yesterday? We should be on the safe side, then, and don't have to care about which mood the current compiler's optimizer might be in or what the POM is.

Do you like to test the patch in the attachment? I named it 'v4'.

After some thinking and testing, it seems to me that the volatile optimization issue this patch shall fix is only with the readx() macros. So the idea is to drop all writex() changes done in the v3 version of this patch. With dropping the writex() changes, we would drop all issues we discussed with e.g. the GCC statement-expression and the do while workaround, too.

Dear Dirk Behme,

Quoted 2 lines · In message<[email protected]> you wrote:

Do you like to test the patch in the attachment? I named it 'v4'.

Please send patches inline.

Quoted 6 lines

After some thinking and testing, it seems to me that the volatile optimization issue this patch shall fix is only with the readx() macros. So the idea is to drop all writex() changes done in the v3 version of this patch. With dropping the writex() changes, we would drop all issues we discussed with e.g. the GCC statement-expression and the do while workaround, too.

This makes no sense. Even if we experience problems only with read*() at the moment, we should to the Rigth Thing (TM) and fix both the read*() and write*() functions.

Please have a look a the patch I just posted,
http://patchwork.ozlabs.org/patch/78056/

The question I was thinking about with my patch was "what's Right Thing?" ;)

It's my understanding that we don't fix read*() and write*() because they are broken. We touch them to work around a broken tool chain.

From: Alexander Holler <[email protected]>

gcc 4.5.1 seems to ignore (at least some) volatile definitions, avoid that as done in the kernel.

Reading C99 6.7.3 8 and the comment 114) there, I think it is a bug of that gcc version to ignore the volatile type qualifier used e.g. in __arch_getl(). Anyway, using a definition as in the kernel headers avoids such optimizations when gcc 4.5.1 is used.

Maybe the headers as used in the current linux-kernel should be used, but to avoid large changes, I've just added a small change to the current headers.

Signed-off-by Alexander Holler <[email protected]>

Signed-off-by Dirk Behme <[email protected]>

Signed-off-by Wolfgang Denk <[email protected]>

Cc Alessandro Rubini <[email protected]>

---
 arch/arm/include/asm/io.h |   32 ++++++++++++++++++++------------
 1 files changed, 20 insertions(+), 12 deletions(-)

arch/arm/include/asm/io.h +17 -9

index ff1518e..3886f15 100644
@@ -117,21 +117,29 @@ extern inline void __raw_readsl(unsigned int addr, void *data, int longlen)
 		*buf++ = __arch_getl(addr);
 }
 
-#define __raw_writeb(v,a)		__arch_putb(v,a)
-#define __raw_writew(v,a)		__arch_putw(v,a)
-#define __raw_writel(v,a)		__arch_putl(v,a)
+#define __raw_writeb(v,a)	__arch_putb(v,a)
+#define __raw_writew(v,a)	__arch_putw(v,a)
+#define __raw_writel(v,a)	__arch_putl(v,a)
 
-#define __raw_readb(a)			__arch_getb(a)
-#define __raw_readw(a)			__arch_getw(a)
-#define __raw_readl(a)			__arch_getl(a)
+#define __raw_readb(a)		__arch_getb(a)
+#define __raw_readw(a)		__arch_getw(a)
+#define __raw_readl(a)		__arch_getl(a)
 
-#define writeb(v,a)			__arch_putb(v,a)
-#define writew(v,a)			__arch_putw(v,a)
-#define writel(v,a)			__arch_putl(v,a)
+/*
+ * TODO: The kernel offers some more advanced versions of barriers, it might
+ * have some advantages to use them instead of the simple one here.
+ */
+#define dmb()		__asm__ __volatile__ ("" : : : "memory")
+#define __iormb()	dmb()
+#define __iowmb()	dmb()
+
+#define writeb(v,c)	({ __iowmb(); __arch_putb(v,c); v; })
+#define writew(v,c)	({ __iowmb(); __arch_putw(v,c); v; })
+#define writel(v,c)	({ __iowmb(); __arch_putl(v,c); v; })

gcc 4.5.1 seems to ignore (at least some) volatile definitions, avoid that as done in the kernel.

Am 09.01.2011 23:19, schrieb Wolfgang Denk:

Quoted 2 lines

gcc 4.5.1 seems to ignore (at least some) volatile definitions, avoid that as done in the kernel.

Have had a look at the asm generated by gcc 4.5.1, looks good.

The wrong optimization in arch/arm/cpu/armv7/omap3/clock.c is gone and the writeb in drivers/mtd/nand/omap_gpmc.c doesn't have the problem as the v1-patch.

Dear Alexander Holler,

Quoted 5 lines · In message<[email protected]> you wrote:

Am 09.01.2011 23:19, schrieb Wolfgang Denk:

Quoted 2 lines

gcc 4.5.1 seems to ignore (at least some) volatile definitions, avoid that as done in the kernel.

Quoted 5 lines

Have had a look at the asm generated by gcc 4.5.1, looks good.

The wrong optimization in arch/arm/cpu/armv7/omap3/clock.c is gone and the writeb in drivers/mtd/nand/omap_gpmc.c doesn't have the problem as the v1-patch.

Thanks - but please send a formal Acked-by: and/or Tested-by: .

Quoted 5 lines

Quoted 5 lines

Quoted 3 lines

Signed-off-by Alexander Holler <[email protected]>

Signed-off-by Dirk Behme <[email protected]>

Signed-off-by Wolfgang Denk <[email protected]>

Tested-by Thomas Weber <[email protected]>

Acked-by Alexander Holler<[email protected]>

Tested-by Alexander Holler<[email protected]>