Add W25 FLASH driver; Use attribute definitions in nuttx/compiler.h

git-svn-id: https://nuttx.svn.sourceforge.net/svnroot/nuttx/trunk@5161 7fd9a85b-ad96-42d3-883c-3090e2eb8679

34 files changed, 1383 insertions, 66 deletions

diff --git a/nuttx/ChangeLog b/nuttx/ChangeLog
index 309fd0596..59736290a 100644
--- a/nuttx/ChangeLog
+++ b/nuttx/ChangeLog
@@ -3361,3 +3361,10 @@
 	  way it was.  The really interrupt related problem was in stm32_spi.c:
 	  When SPI3 is not enabled, then the irqrestore() falls in the
 	  else clause.
+	* include/nuttx/compiler.h and other files:  Moved always_inline
+	  and noinline __attributes__ here.  Also replaced all occurrences
+	  of explicit __atributes__ in other files with definitions from
+	  this header file.
+	* drivers/mtd/w25.c:  The Windbond SPI FLASH W25 FLASH driver is
+	  code complete (but still untested).
+
diff --git a/nuttx/arch/8051/src/up_assert.c b/nuttx/arch/8051/src/up_assert.c
index 10a5daf35..46d731041 100644
--- a/nuttx/arch/8051/src/up_assert.c
+++ b/nuttx/arch/8051/src/up_assert.c
@@ -1,7 +1,7 @@
 /************************************************************************
  * up_assert.c
  *
- *   Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2007, 2009, 2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -65,7 +65,7 @@
  * Name: _up_assert
  ************************************************************************/
 
-static void _up_assert(int errorcode) /* __attribute__ ((noreturn)) */
+static void _up_assert(int errorcode) /* noreturn_function */
 {
   /* Are we in an interrupt handler or the idle task? */
 
diff --git a/nuttx/arch/arm/include/armv7-m/irq.h b/nuttx/arch/arm/include/armv7-m/irq.h
index b6306d339..606b3988f 100644
--- a/nuttx/arch/arm/include/armv7-m/irq.h
+++ b/nuttx/arch/arm/include/armv7-m/irq.h
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/include/armv7-m/irq.h
  *
- *   Copyright (C) 2009, 2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2009, 2011-2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -48,6 +48,7 @@
 
 #include <nuttx/irq.h>
 #ifndef __ASSEMBLY__
+#  include <nuttx/compiler.h>
 #  include <stdint.h>
 #endif
 
@@ -131,7 +132,7 @@ struct xcptcontext
 
 /* Disable IRQs */
 
-static inline void irqdisable(void) __attribute__((always_inline));
+static inline void irqdisable(void) inline_function;
 static inline void irqdisable(void)
 {
   __asm__ __volatile__ ("\tcpsid  i\n");
@@ -139,7 +140,7 @@ static inline void irqdisable(void)
 
 /* Save the current primask state & disable IRQs */
 
-static inline irqstate_t irqsave(void) __attribute__((always_inline));
+static inline irqstate_t irqsave(void) inline_function;
 static inline irqstate_t irqsave(void)
 {
   unsigned short primask;
@@ -161,7 +162,7 @@ static inline irqstate_t irqsave(void)
 
 /* Enable IRQs */
 
-static inline void irqenable(void) __attribute__((always_inline));
+static inline void irqenable(void) inline_function;
 static inline void irqenable(void)
 {
   __asm__ __volatile__ ("\tcpsie  i\n");
@@ -169,7 +170,7 @@ static inline void irqenable(void)
 
 /* Restore saved primask state */
 
-static inline void irqrestore(irqstate_t primask) __attribute__((always_inline));
+static inline void irqrestore(irqstate_t primask) inline_function;
 static inline void irqrestore(irqstate_t primask)
 {
   /* If bit 0 of the primask is 0, then we need to restore
@@ -189,7 +190,7 @@ static inline void irqrestore(irqstate_t primask)
 
 /* Get/set the primask register */
 
-static inline uint8_t getprimask(void) __attribute__((always_inline));
+static inline uint8_t getprimask(void) inline_function;
 static inline uint8_t getprimask(void)
 {
   uint32_t primask;
@@ -203,7 +204,7 @@ static inline uint8_t getprimask(void)
   return (uint8_t)primask;
 }
 
-static inline void setprimask(uint32_t primask) __attribute__((always_inline));
+static inline void setprimask(uint32_t primask) inline_function;
 static inline void setprimask(uint32_t primask)
 {
   __asm__ __volatile__
@@ -216,7 +217,7 @@ static inline void setprimask(uint32_t primask)
 
 /* Get/set the basepri register */
 
-static inline uint8_t getbasepri(void) __attribute__((always_inline));
+static inline uint8_t getbasepri(void) inline_function;
 static inline uint8_t getbasepri(void)
 {
   uint32_t basepri;
@@ -231,7 +232,7 @@ static inline uint8_t getbasepri(void)
   return (uint8_t)basepri;
 }
 
-static inline void setbasepri(uint32_t basepri) __attribute__((always_inline));
+static inline void setbasepri(uint32_t basepri) inline_function;
 static inline void setbasepri(uint32_t basepri)
 {
   __asm__ __volatile__
@@ -244,7 +245,7 @@ static inline void setbasepri(uint32_t basepri)
 
 /* Get/set IPSR */
 
-static inline uint32_t getipsr(void) __attribute__((always_inline));
+static inline uint32_t getipsr(void) inline_function;
 static inline uint32_t getipsr(void)
 {
   uint32_t ipsr;
@@ -258,7 +259,7 @@ static inline uint32_t getipsr(void)
   return ipsr;
 }
 
-static inline void setipsr(uint32_t ipsr) __attribute__((always_inline));
+static inline void setipsr(uint32_t ipsr) inline_function;
 static inline void setipsr(uint32_t ipsr)
 {
   __asm__ __volatile__
@@ -271,7 +272,7 @@ static inline void setipsr(uint32_t ipsr)
 
 /* Get/set CONTROL */
 
-static inline uint32_t getcontrol(void) __attribute__((always_inline));
+static inline uint32_t getcontrol(void) inline_function;
 static inline uint32_t getcontrol(void)
 {
   uint32_t control;
@@ -285,7 +286,7 @@ static inline uint32_t getcontrol(void)
   return control;
 }
 
-static inline void setcontrol(uint32_t control) __attribute__((always_inline));
+static inline void setcontrol(uint32_t control) inline_function;
 static inline void setcontrol(uint32_t control)
 {
   __asm__ __volatile__
diff --git a/nuttx/arch/arm/src/arm/up_assert.c b/nuttx/arch/arm/src/arm/up_assert.c
index 023e6e22d..3d75a4655 100644
--- a/nuttx/arch/arm/src/arm/up_assert.c
+++ b/nuttx/arch/arm/src/arm/up_assert.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/arm/up_assert.c
  *
- *   Copyright (C) 2007-2010 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2007-2010, 2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -252,7 +252,7 @@ static void up_dumpstate(void)
  * Name: _up_assert
  ****************************************************************************/
 
-static void _up_assert(int errorcode) /* __attribute__ ((noreturn)) */
+static void _up_assert(int errorcode) /* noreturn_function */
 {
   /* Are we in an interrupt handler or the idle task? */
 
diff --git a/nuttx/arch/arm/src/armv7-m/svcall.h b/nuttx/arch/arm/src/armv7-m/svcall.h
index 9a4db89b1..675829799 100644
--- a/nuttx/arch/arm/src/armv7-m/svcall.h
+++ b/nuttx/arch/arm/src/armv7-m/svcall.h
@@ -74,7 +74,7 @@
 
 /* SYS call 1:
  *
- * void up_fullcontextrestore(uint32_t *restoreregs) __attribute__ ((noreturn));
+ * void up_fullcontextrestore(uint32_t *restoreregs) noreturn_function;
  */
 
 #define SYS_restore_context (1)
diff --git a/nuttx/arch/arm/src/armv7-m/up_assert.c b/nuttx/arch/arm/src/armv7-m/up_assert.c
index 2662cbe37..282ff6a57 100644
--- a/nuttx/arch/arm/src/armv7-m/up_assert.c
+++ b/nuttx/arch/arm/src/armv7-m/up_assert.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/arm/src/armv7-m/up_assert.c
  *
- *   Copyright (C) 2009-2010 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2009-2010, 2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -262,7 +262,7 @@ static void up_dumpstate(void)
  * Name: _up_assert
  ****************************************************************************/
 
-static void _up_assert(int errorcode) /* __attribute__ ((noreturn)) */
+static void _up_assert(int errorcode) /* noreturn_function */
 {
   /* Are we in an interrupt handler or the idle task? */
 
diff --git a/nuttx/arch/arm/src/armv7-m/up_fullcontextrestore.S b/nuttx/arch/arm/src/armv7-m/up_fullcontextrestore.S
index 3ce51c9cd..4c77b66b8 100755
--- a/nuttx/arch/arm/src/armv7-m/up_fullcontextrestore.S
+++ b/nuttx/arch/arm/src/armv7-m/up_fullcontextrestore.S
@@ -69,7 +69,7 @@
  * Description:
  *   Restore the current thread context.  Full prototype is:
  *
- *   void up_fullcontextrestore(uint32_t *restoreregs) __attribute__ ((noreturn));
+ *   void up_fullcontextrestore(uint32_t *restoreregs) noreturn_function;
  *
  * Return:
  *   None
diff --git a/nuttx/arch/arm/src/armv7-m/up_svcall.c b/nuttx/arch/arm/src/armv7-m/up_svcall.c
index 5a4d64fe2..d32f0afc2 100644
--- a/nuttx/arch/arm/src/armv7-m/up_svcall.c
+++ b/nuttx/arch/arm/src/armv7-m/up_svcall.c
@@ -280,7 +280,7 @@ int up_svcall(int irq, FAR void *context)
 
       /* R0=SYS_restore_context: This a restore context command:
        *
-       *   void up_fullcontextrestore(uint32_t *restoreregs) __attribute__ ((noreturn));
+       *   void up_fullcontextrestore(uint32_t *restoreregs) noreturn_function;
        *
        * At this point, the following values are saved in context:
        *
diff --git a/nuttx/arch/arm/src/common/up_internal.h b/nuttx/arch/arm/src/common/up_internal.h
index 45cb1dcc0..9f20775c0 100644
--- a/nuttx/arch/arm/src/common/up_internal.h
+++ b/nuttx/arch/arm/src/common/up_internal.h
@@ -40,7 +40,10 @@
  * Included Files
  ****************************************************************************/
 
+#include <nuttx/config.h>
+
 #ifndef __ASSEMBLY__
+#  include <nuttx/compiler.h>
 #  include <sys/types.h>
 #  include <stdint.h>
 #endif
@@ -223,7 +226,7 @@ extern void up_boot(void);
 extern void up_copystate(uint32_t *dest, uint32_t *src);
 extern void up_decodeirq(uint32_t *regs);
 extern int  up_saveusercontext(uint32_t *saveregs);
-extern void up_fullcontextrestore(uint32_t *restoreregs) __attribute__ ((noreturn));
+extern void up_fullcontextrestore(uint32_t *restoreregs) noreturn_function;
 extern void up_switchcontext(uint32_t *saveregs, uint32_t *restoreregs);
 
 /* Signal handling **********************************************************/
diff --git a/nuttx/arch/avr/src/avr/avr_internal.h b/nuttx/arch/avr/src/avr/avr_internal.h
index c87254b77..031000cd1 100644
--- a/nuttx/arch/avr/src/avr/avr_internal.h
+++ b/nuttx/arch/avr/src/avr/avr_internal.h
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/avr/src/avr/avr_internal.h
  *
- *   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011-2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -40,7 +40,10 @@
  * Included Files
  ****************************************************************************/
 
+#include <nuttx/config.h>
+
 #ifndef __ASSEMBLY__
+#  include <nuttx/compiler.h>
 #  include <sys/types.h>
 #  include <stdint.h>
 #  include <stdbool.h>
@@ -111,7 +114,7 @@ extern void up_copystate(uint8_t *dest, uint8_t *src);
  *
  ************************************************************************************/
 
-extern void up_fullcontextrestore(uint8_t *restoreregs) __attribute__ ((noreturn));
+extern void up_fullcontextrestore(uint8_t *restoreregs) noreturn_function;
 
 /************************************************************************************
  * Name:  up_switchcontext
diff --git a/nuttx/arch/avr/src/avr32/avr32_internal.h b/nuttx/arch/avr/src/avr32/avr32_internal.h
index 680e2c804..3d45f6c54 100644
--- a/nuttx/arch/avr/src/avr32/avr32_internal.h
+++ b/nuttx/arch/avr/src/avr32/avr32_internal.h
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/avr/src/avr32/up_internal.h
  *
- *   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011-2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -40,7 +40,10 @@
  * Included Files
  ****************************************************************************/
 
+#include <nuttx/config.h>
+
 #ifndef __ASSEMBLY__
+#  include <nuttx/compiler.h>
 #  include <stdint.h>
 #endif
 
@@ -109,7 +112,7 @@ extern void up_copystate(uint32_t *dest, uint32_t *src);
  *
  ************************************************************************************/
 
-extern void up_fullcontextrestore(uint32_t *restoreregs) __attribute__ ((noreturn));
+extern void up_fullcontextrestore(uint32_t *restoreregs) noreturn_function;
 
 /************************************************************************************
  * Name:  up_switchcontext
diff --git a/nuttx/arch/avr/src/common/up_assert.c b/nuttx/arch/avr/src/common/up_assert.c
index 82c58d658..12bb564d3 100644
--- a/nuttx/arch/avr/src/common/up_assert.c
+++ b/nuttx/arch/avr/src/common/up_assert.c
@@ -90,7 +90,7 @@
  * Name: _up_assert
  ****************************************************************************/
 
-static void _up_assert(int errorcode) /* __attribute__ ((noreturn)) */
+static void _up_assert(int errorcode) /* noreturn_function */
 {
   /* Are we in an interrupt handler or the idle task? */
 
diff --git a/nuttx/arch/hc/src/common/up_internal.h b/nuttx/arch/hc/src/common/up_internal.h
index e54b86dec..f1daf690f 100644
--- a/nuttx/arch/hc/src/common/up_internal.h
+++ b/nuttx/arch/hc/src/common/up_internal.h
@@ -41,7 +41,9 @@
  ****************************************************************************/
 
 #include <nuttx/config.h>
+
 #ifndef __ASSEMBLY__
+#  include <nuttx/compiler.h>
 #  include <stdint.h>
 #endif
 
@@ -152,7 +154,7 @@ extern void up_copystate(uint8_t *dest, uint8_t *src);
 extern void up_decodeirq(uint8_t *regs);
 extern void up_irqinitialize(void);
 extern int  up_saveusercontext(uint8_t *saveregs);
-extern void up_fullcontextrestore(uint8_t *restoreregs) __attribute__ ((noreturn));
+extern void up_fullcontextrestore(uint8_t *restoreregs) noreturn_function;
 extern void up_switchcontext(uint8_t *saveregs, uint8_t *restoreregs);
 
 /* Interrupt handling */
diff --git a/nuttx/arch/hc/src/m9s12/m9s12_assert.c b/nuttx/arch/hc/src/m9s12/m9s12_assert.c
index 386bcb2df..ff9ce5ca4 100644
--- a/nuttx/arch/hc/src/m9s12/m9s12_assert.c
+++ b/nuttx/arch/hc/src/m9s12/m9s12_assert.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/hc/src/m9s12/m9s12_assert.c
  *
- *   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011-2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -247,7 +247,7 @@ static void up_dumpstate(void)
  * Name: _up_assert
  ****************************************************************************/
 
-static void _up_assert(int errorcode) /* __attribute__ ((noreturn)) */
+static void _up_assert(int errorcode) /* noreturn_function */
 {
   /* Are we in an interrupt handler or the idle task? */
 
diff --git a/nuttx/arch/mips/include/mips32/syscall.h b/nuttx/arch/mips/include/mips32/syscall.h
index 9c497c8b6..d91eed993 100644
--- a/nuttx/arch/mips/include/mips32/syscall.h
+++ b/nuttx/arch/mips/include/mips32/syscall.h
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/mips/include/mips32/syscall.h
  *
- *   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011-2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -150,7 +150,7 @@
 
 /* SYS call 1:
  *
- * void up_fullcontextrestore(uint32_t *restoreregs) __attribute__ ((noreturn));
+ * void up_fullcontextrestore(uint32_t *restoreregs) noreturn_function;
  */
 
 #define SYS_restore_context (1)
diff --git a/nuttx/arch/mips/src/mips32/up_assert.c b/nuttx/arch/mips/src/mips32/up_assert.c
index 881ec12cb..ed4ee4cf7 100644
--- a/nuttx/arch/mips/src/mips32/up_assert.c
+++ b/nuttx/arch/mips/src/mips32/up_assert.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/mips/src/mips32/up_assert.c
  *
- *   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011-2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -90,7 +90,7 @@
  * Name: _up_assert
  ****************************************************************************/
 
-static void _up_assert(int errorcode) /* __attribute__ ((noreturn)) */
+static void _up_assert(int errorcode) /* noreturn_function */
 {
   /* Are we in an interrupt handler or the idle task? */
 
diff --git a/nuttx/arch/mips/src/mips32/up_swint0.c b/nuttx/arch/mips/src/mips32/up_swint0.c
index 6a1042721..87ccddf71 100644
--- a/nuttx/arch/mips/src/mips32/up_swint0.c
+++ b/nuttx/arch/mips/src/mips32/up_swint0.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/mips/src/mips32/up_swint0.c
  *
- *   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011-2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -290,7 +290,7 @@ int up_swint0(int irq, FAR void *context)
     {
       /* R4=SYS_restore_context: This a restore context command:
        *
-       *   void up_fullcontextrestore(uint32_t *restoreregs) __attribute__ ((noreturn));
+       *   void up_fullcontextrestore(uint32_t *restoreregs) noreturn_function;
        *
        * At this point, the following values are saved in context:
        *
diff --git a/nuttx/arch/sh/src/common/up_assert.c b/nuttx/arch/sh/src/common/up_assert.c
index cfd7854df..ccc0c98e6 100644
--- a/nuttx/arch/sh/src/common/up_assert.c
+++ b/nuttx/arch/sh/src/common/up_assert.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/sh/src/common/up_assert.c
  *
- *   Copyright (C) 2008-2009 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2008-2009, 2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -76,7 +76,7 @@
  * Name: _up_assert
  ****************************************************************************/
 
-static void _up_assert(int errorcode) /* __attribute__ ((noreturn)) */
+static void _up_assert(int errorcode) /* noreturn_function */
 {
   /* Are we in an interrupt handler or the idle task? */
 
diff --git a/nuttx/arch/sh/src/common/up_internal.h b/nuttx/arch/sh/src/common/up_internal.h
index 0504755f6..f47b1078f 100644
--- a/nuttx/arch/sh/src/common/up_internal.h
+++ b/nuttx/arch/sh/src/common/up_internal.h
@@ -40,7 +40,10 @@
  * Included Files
  ****************************************************************************/
 
+#include <nuttx/config.h>
+
 #ifndef __ASSEMBLY__
+#  include <nuttx/compiler.h>
 #  include <stdint.h>
 #endif
 
@@ -144,7 +147,7 @@ extern void up_copystate(uint32_t *dest, uint32_t *src);
 extern void up_dataabort(uint32_t *regs);
 extern void up_decodeirq(uint32_t *regs);
 extern uint32_t *up_doirq(int irq, uint32_t *regs);
-extern void up_fullcontextrestore(uint32_t *regs) __attribute__ ((noreturn));
+extern void up_fullcontextrestore(uint32_t *regs) noreturn_function;
 extern void up_irqinitialize(void);
 extern void up_prefetchabort(uint32_t *regs);
 extern int  up_saveusercontext(uint32_t *regs);
diff --git a/nuttx/arch/sim/src/up_internal.h b/nuttx/arch/sim/src/up_internal.h
index 04fd71efc..dff51b9cf 100644
--- a/nuttx/arch/sim/src/up_internal.h
+++ b/nuttx/arch/sim/src/up_internal.h
@@ -41,6 +41,7 @@
  **************************************************************************/
 
 #include <nuttx/config.h>
+#include <nuttx/compiler.h>
 #include <sys/types.h>
 #include <nuttx/irq.h>
 
@@ -150,7 +151,7 @@ extern volatile int g_eventloop;
 /* up_setjmp.S ************************************************************/
 
 extern int  up_setjmp(int *jb);
-extern void up_longjmp(int *jb, int val) __attribute__ ((noreturn));
+extern void up_longjmp(int *jb, int val) noreturn_function;
 
 /* up_devconsole.c ********************************************************/
 
diff --git a/nuttx/arch/x86/include/i486/arch.h b/nuttx/arch/x86/include/i486/arch.h
index 64d9d85bf..6bb2418d7 100644
--- a/nuttx/arch/x86/include/i486/arch.h
+++ b/nuttx/arch/x86/include/i486/arch.h
@@ -45,7 +45,9 @@
  ****************************************************************************/
 
 #include <nuttx/config.h>
+
 #ifndef __ASSEMBLY__
+#  include <nuttx/compiler.h>
 #  include <stdint.h>
 #endif
 
@@ -323,7 +325,7 @@ struct gdt_entry_s
   uint8_t  access;             /* Access flags, determine ring segment can be used in */
   uint8_t  granularity;
   uint8_t  hibase;             /* The last 8 bits of the base */
-} __attribute__((packed));
+} packed_struct;
 
 /* This structure refers to the array of GDT entries, and is in the format
  * required by the lgdt instruction.
@@ -333,7 +335,7 @@ struct gdt_ptr_s
 {
   uint16_t limit;               /* The upper 16 bits of all selector limits */
   uint32_t base;                /* The address of the first GDT entry */
-} __attribute__((packed));
+} packed_struct;
 
 /* IDT data structures ******************************************************
  *
@@ -349,7 +351,7 @@ struct idt_entry_s
   uint8_t  zero;             /* This must always be zero */
   uint8_t  flags;            /* (See documentation) */
   uint16_t hibase;           /* Upper 16-bits of vector address for interrupt */
-} __attribute__((packed));
+} packed_struct;
 
 /* A struct describing a pointer to an array of interrupt handlers.  This is
  * in a format suitable for giving to 'lidt'.
@@ -359,7 +361,7 @@ struct idt_ptr_s
 {
   uint16_t limit;
   uint32_t base;             /* The address of the first GDT entry */
-} __attribute__((packed));
+} packed_struct;
 
 /****************************************************************************
  * Inline functions
diff --git a/nuttx/arch/x86/src/common/up_assert.c b/nuttx/arch/x86/src/common/up_assert.c
index be82a3616..aa752f84e 100644
--- a/nuttx/arch/x86/src/common/up_assert.c
+++ b/nuttx/arch/x86/src/common/up_assert.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * arch/x86/src/common/up_assert.c
  *
- *   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011-2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -209,7 +209,7 @@ static void up_dumpstate(void)
  * Name: _up_assert
  ****************************************************************************/
 
-static void _up_assert(int errorcode) /* __attribute__ ((noreturn)) */
+static void _up_assert(int errorcode) /* noreturn_function */
 {
   /* Are we in an interrupt handler or the idle task? */
 
diff --git a/nuttx/arch/x86/src/common/up_internal.h b/nuttx/arch/x86/src/common/up_internal.h
index 22956ecb3..df43ca1a8 100644
--- a/nuttx/arch/x86/src/common/up_internal.h
+++ b/nuttx/arch/x86/src/common/up_internal.h
@@ -40,7 +40,10 @@
  * Included Files
  ****************************************************************************/
 
+#include <nuttx/config.h>
+
 #ifndef __ASSEMBLY__
+#  include <nuttx/compiler.h>
 #  include <stdint.h>
 #endif
 
@@ -174,7 +177,7 @@ extern void up_irqinitialize(void);
 extern void weak_function up_dmainitialize(void);
 #endif
 extern int  up_saveusercontext(uint32_t *saveregs);
-extern void up_fullcontextrestore(uint32_t *restoreregs) __attribute__ ((noreturn));
+extern void up_fullcontextrestore(uint32_t *restoreregs) noreturn_function;
 extern void up_switchcontext(uint32_t *saveregs, uint32_t *restoreregs);
 extern void up_sigdeliver(void);
 extern void up_lowputc(char ch);
diff --git a/nuttx/arch/x86/src/i486/up_irq.c b/nuttx/arch/x86/src/i486/up_irq.c
index 3eb6d6070..a160379e2 100644
--- a/nuttx/arch/x86/src/i486/up_irq.c
+++ b/nuttx/arch/x86/src/i486/up_irq.c
@@ -39,6 +39,7 @@
  ****************************************************************************/
 
 #include <nuttx/config.h>
+#include <nuttx/compiler.h>
 
 #include <stdint.h>
 #include <string.h>
@@ -62,7 +63,7 @@
  * Private Function Prototypes
  ****************************************************************************/
 
-static void idt_outb(uint8_t val, uint16_t addr) __attribute__((noinline));
+static void idt_outb(uint8_t val, uint16_t addr) noinline_function;
 static void up_remappic(void);
 static void up_idtentry(unsigned int index, uint32_t base, uint16_t sel,
                         uint8_t flags);
diff --git a/nuttx/arch/x86/src/qemu/qemu_fullcontextrestore.S b/nuttx/arch/x86/src/qemu/qemu_fullcontextrestore.S
index 50ebdc041..8ba59a5a7 100644
--- a/nuttx/arch/x86/src/qemu/qemu_fullcontextrestore.S
+++ b/nuttx/arch/x86/src/qemu/qemu_fullcontextrestore.S
@@ -1,7 +1,7 @@
 /**************************************************************************
  * arch/x86/src/qemu/qemu_fullcontextrestore.S
  *
- *   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011-2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -89,7 +89,7 @@
  * Name: up_fullcontextrestore
  *
  * Full C prototype:
- *  void up_fullcontextrestore(uint32_t *regs) __attribute__ ((noreturn));
+ *  void up_fullcontextrestore(uint32_t *regs) noreturn_function;
  *
  **************************************************************************/
 
diff --git a/nuttx/arch/x86/src/qemu/qemu_handlers.c b/nuttx/arch/x86/src/qemu/qemu_handlers.c
index aeb9b8b1f..a0d6028aa 100644
--- a/nuttx/arch/x86/src/qemu/qemu_handlers.c
+++ b/nuttx/arch/x86/src/qemu/qemu_handlers.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  *  arch/x86/src/qemu/qemu_handlers.c
  *
- *   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2011-2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -38,6 +38,7 @@
  ****************************************************************************/
 
 #include <nuttx/config.h>
+#include <nuttx/compiler.h>
 
 #include <nuttx/arch.h>
 #include <arch/io.h>
@@ -52,7 +53,7 @@
  * Private Function Prototypes
  ****************************************************************************/
 
-static void idt_outb(uint8_t val, uint16_t addr) __attribute__((noinline));
+static void idt_outb(uint8_t val, uint16_t addr) noinline_function;
 
 /****************************************************************************
  * Private Data
diff --git a/nuttx/arch/z16/src/common/up_assert.c b/nuttx/arch/z16/src/common/up_assert.c
index d7d614a91..5832ead45 100644
--- a/nuttx/arch/z16/src/common/up_assert.c
+++ b/nuttx/arch/z16/src/common/up_assert.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * common/up_assert.c
  *
- *   Copyright (C) 2008-2009 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2008-2009, 2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -77,7 +77,7 @@
  * Name: _up_assert
  ****************************************************************************/
 
-static void _up_assert(int errorcode) /* __attribute__ ((noreturn)) */
+static void _up_assert(int errorcode) /* noreturn_function */
 {
   /* Are we in an interrupt handler or the idle task? */
 
diff --git a/nuttx/arch/z80/src/common/up_assert.c b/nuttx/arch/z80/src/common/up_assert.c
index b35e8dd33..ff4e569fb 100644
--- a/nuttx/arch/z80/src/common/up_assert.c
+++ b/nuttx/arch/z80/src/common/up_assert.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * common/up_assert.c
  *
- *   Copyright (C) 2007-2009 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2007-2009, 2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -77,7 +77,7 @@
  * Name: _up_assert
  ****************************************************************************/
 
-static void _up_assert(int errorcode) /* __attribute__ ((noreturn)) */
+static void _up_assert(int errorcode) /* noreturn_function */
 {
   /* Are we in an interrupt handler or the idle task? */
 
diff --git a/nuttx/drivers/mtd/Kconfig b/nuttx/drivers/mtd/Kconfig
index bda5afa84..ae656c474 100644
--- a/nuttx/drivers/mtd/Kconfig
+++ b/nuttx/drivers/mtd/Kconfig
@@ -36,19 +36,19 @@ config AT45DB_PWRSAVE
 	bool "enables power save"
 	default n
 	depends on MTD_AT45DB
-	
+
 config MTD_MP25P
-	bool "SPI-based M25P1 falsh"
+	bool "SPI-based M25P FLASH"
 	default n
 	select SPI
 
 config MP25P_SPIMODE
-	int "mp25p spi mode"
+	int "MP25P SPI mode"
 	default 0
 	depends on MTD_MP25P
 
 config MP25P_MANUFACTURER
-	hex "mp25p manufacturers ID"
+	hex "MP25P manufacturers ID"
 	default 0x20
 	depends on MTD_MP25P
 	---help---
@@ -66,3 +66,68 @@ config MTD_RAMTRON
 config MTD_RAM
 	bool "Memory bus ram"
 	default n
+
+config MTD_SST25
+	bool "SPI-based SST25 FLASH"
+	default n
+	select SPI
+
+config SST25_SPIMODE
+	int "SST25 SPI Mode"
+	default 0
+	depends on MTD_SST25
+
+config SST25_SPIFREQUENCY
+	int "SST25 SPI Frequency"
+	default 20000000
+	depends on MTD_SST25
+
+config SST25_READONLY
+	bool "SST25 Read-Only FLASH"
+	default n
+	depends on MTD_SST25
+
+config SST25_SECTOR512
+	bool "Simulate 512 byte Erase Blocks"
+	default n
+	depends on MTD_SST25
+
+config SST25_SLOWWRITE
+	bool
+	default y
+	depends on MTD_SST25
+
+config SST25_SLOWREAD
+	bool
+	default n
+	depends on MTD_SST25
+
+config MTD_W25
+	bool "SPI-based W25 FLASH"
+	default n
+	select SPI
+
+config W25_SPIMODE
+	int "W25 SPI Mode"
+	default 0
+	depends on MTD_W25
+
+config W25_SPIFREQUENCY
+	int "W25 SPI Frequency"
+	default 20000000
+	depends on MTD_W25
+
+config W25_READONLY
+	bool "W25 Read-Only FLASH"
+	default n
+	depends on MTD_W25
+
+config W25_SECTOR512
+	bool "Simulate 512 byte Erase Blocks"
+	default n
+	depends on MTD_W25
+
+config W25_SLOWREAD
+	bool
+	default n
+	depends on MTD_W25
diff --git a/nuttx/drivers/mtd/Make.defs b/nuttx/drivers/mtd/Make.defs
index 866d7c713..258e77ec9 100644
--- a/nuttx/drivers/mtd/Make.defs
+++ b/nuttx/drivers/mtd/Make.defs
@@ -47,6 +47,10 @@ ifeq ($(CONFIG_MTD_SST25),y)
 CSRCS += sst25.c
 endif
 
+ifeq ($(CONFIG_MTD_W25),y)
+CSRCS += w25.c
+endif
+
 # Include MTD driver support
 
 DEPPATH += --dep-path mtd
diff --git a/nuttx/drivers/mtd/w25.c b/nuttx/drivers/mtd/w25.c
new file mode 100644
index 000000000..0d7028fec
--- /dev/null
+++ b/nuttx/drivers/mtd/w25.c
@@ -0,0 +1,1188 @@
+/************************************************************************************
+ * drivers/mtd/w25.c
+ * Driver for SPI-based W25x16, x32, and x64 and W25q16, q32, q64, and q128 FLASH
+ *
+ *   Copyright (C) 2012 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ************************************************************************************/
+
+/************************************************************************************
+ * Included Files
+ ************************************************************************************/
+
+#include <nuttx/config.h>
+
+#include <sys/types.h>
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <assert.h>
+#include <errno.h>
+#include <debug.h>
+
+#include <nuttx/kmalloc.h>
+#include <nuttx/fs/ioctl.h>
+#include <nuttx/spi.h>
+#include <nuttx/mtd.h>
+
+/************************************************************************************
+ * Pre-processor Definitions
+ ************************************************************************************/
+/* Configuration ********************************************************************/
+/* Per the data sheet, the W25 parts can be driven with either SPI mode 0 (CPOL=0
+ * and CPHA=0) or mode 3 (CPOL=1 and CPHA=1). But I have heard that other devices
+ * can operate in mode 0 or 1.  So you may need to specify CONFIG_W25_SPIMODE to
+ * select the best mode for your device.  If CONFIG_W25_SPIMODE is not defined,
+ * mode 0 will be used.
+ */
+
+#ifndef CONFIG_W25_SPIMODE
+#  define CONFIG_W25_SPIMODE SPIDEV_MODE0
+#endif
+
+/* SPI Frequency.  May be up to 25MHz. */
+
+#ifndef CONFIG_W25_SPIFREQUENCY
+#  define CONFIG_W25_SPIFREQUENCY 20000000
+#endif
+
+/* W25 Instructions *****************************************************************/
+/*      Command                    Value      Description                           */
+/*                                                                                  */
+#define W25_WREN                   0x06    /* Write enable                          */
+#define W25_WRDI                   0x04    /* Write Disable                         */
+#define W25_RDSR                   0x05    /* Read status register                  */
+#define W25_WRSR                   0x01    /* Write Status Register                 */
+#define W25_RDDATA                 0x03    /* Read data bytes                       */
+#define W25_FRD                    0x0b    /* Higher speed read                     */
+#define W25_FRDD                   0x3b    /* Fast read, dual output                */
+#define W25_PP                     0x02    /* Program page                          */
+#define W25_BE                     0xd8    /* Block Erase (64KB)                    */
+#define W25_SE                     0x20    /* Sector erase (4KB)                    */
+#define W25_CE                     0xc7    /* Chip erase                            */
+#define W25_PD                     0xb9    /* Power down                            */
+#define W25_PURDID                 0xab    /* Release PD, Device ID                 */
+#define W25_RDMFID                 0x90    /* Read Manufacturer / Device            */
+#define W25_JEDEC_ID               0x9f    /* JEDEC ID read                         */
+
+/* W25 Registers ********************************************************************/
+/* Read ID (RDID) register values */
+
+#define W25_MANUFACTURER           0xef   /* Winbond Serial Flash */
+#define W25X16_DEVID               0x14   /* W25X16 device ID (0xab, 0x90) */
+#define W25X32_DEVID               0x15   /* W25X16 device ID (0xab, 0x90) */
+#define W25X64_DEVID               0x16   /* W25X16 device ID (0xab, 0x90) */
+
+/* JEDEC Read ID register values */
+
+#define W25_JEDEC_MANUFACTURER     0xef  /* SST manufacturer ID */
+#define W25X_JEDEC_MEMORY_TYPE     0x30  /* W25X memory type */
+#define W25Q_JEDEC_MEMORY_TYPE_A   0x40  /* W25Q memory type */
+#define W25Q_JEDEC_MEMORY_TYPE_B   0x60  /* W25Q memory type */
+
+#define W25_JEDEC_CAPACITY_16MBIT  0x15  /* 512x4096  = 16Mbit memory capacity */
+#define W25_JEDEC_CAPACITY_32MBIT  0x16  /* 1024x4096 = 32Mbit memory capacity */
+#define W25_JEDEC_CAPACITY_64MBIT  0x17  /* 2048x4096 = 64Mbit memory capacity */
+#define W25_JEDEC_CAPACITY_128MBIT 0x18  /* 4096x4096 = 128Mbit memory capacity */
+
+#define NSECTORS_16MBIT            512   /* 512 sectors x 4096 bytes/sector = 2Mb */
+#define NSECTORS_32MBIT            1024  /* 1024 sectors x 4096 bytes/sector = 4Mb */
+#define NSECTORS_64MBIT            2048  /* 2048 sectors x 4096 bytes/sector = 8Mb */
+#define NSECTORS_128MBIT           4096  /* 4096 sectors x 4096 bytes/sector = 16Mb */
+
+/* Status register bit definitions */
+
+#define W25_SR_BUSY                (1 << 0)  /* Bit 0: Write in progress */
+#define W25_SR_WEL                 (1 << 1)  /* Bit 1: Write enable latch bit */
+#define W25_SR_BP_SHIFT            (2)       /* Bits 2-5: Block protect bits */
+#define W25_SR_BP_MASK             (15 << W25_SR_BP_SHIFT)
+#  define W25X16_SR_BP_NONE        (0 << W25_SR_BP_SHIFT)  /* Unprotected */
+#  define W25X16_SR_BP_UPPER32nd   (1 << W25_SR_BP_SHIFT)  /* Upper 32nd */
+#  define W25X16_SR_BP_UPPER16th   (2 << W25_SR_BP_SHIFT)  /* Upper 16th */
+#  define W25X16_SR_BP_UPPER8th    (3 << W25_SR_BP_SHIFT)  /* Upper 8th */
+#  define W25X16_SR_BP_UPPERQTR    (4 << W25_SR_BP_SHIFT)  /* Upper quarter */
+#  define W25X16_SR_BP_UPPERHALF   (5 << W25_SR_BP_SHIFT)  /* Upper half */
+#  define W25X16_SR_BP_ALL         (6 << W25_SR_BP_SHIFT)  /* All sectors */
+#  define W25X16_SR_BP_LOWER32nd   (9 << W25_SR_BP_SHIFT)  /* Lower 32nd */
+#  define W25X16_SR_BP_LOWER16th   (10 << W25_SR_BP_SHIFT) /* Lower 16th */
+#  define W25X16_SR_BP_LOWER8th    (11 << W25_SR_BP_SHIFT) /* Lower 8th */
+#  define W25X16_SR_BP_LOWERQTR    (12 << W25_SR_BP_SHIFT) /* Lower quarter */
+#  define W25X16_SR_BP_LOWERHALF   (13 << W25_SR_BP_SHIFT) /* Lower half */
+
+#  define W25X32_SR_BP_NONE        (0 << W25_SR_BP_SHIFT)  /* Unprotected */
+#  define W25X32_SR_BP_UPPER64th   (1 << W25_SR_BP_SHIFT)  /* Upper 64th */
+#  define W25X32_SR_BP_UPPER32nd   (2 << W25_SR_BP_SHIFT)  /* Upper 32nd */
+#  define W25X32_SR_BP_UPPER16th   (3 << W25_SR_BP_SHIFT)  /* Upper 16th */
+#  define W25X32_SR_BP_UPPER8th    (4 << W25_SR_BP_SHIFT)  /* Upper 8th */
+#  define W25X32_SR_BP_UPPERQTR    (5 << W25_SR_BP_SHIFT)  /* Upper quarter */
+#  define W25X32_SR_BP_UPPERHALF   (6 << W25_SR_BP_SHIFT)  /* Upper half */
+#  define W25X32_SR_BP_ALL         (7 << W25_SR_BP_SHIFT)  /* All sectors */
+#  define W25X32_SR_BP_LOWER64th   (9 << W25_SR_BP_SHIFT)  /* Lower 64th */
+#  define W25X32_SR_BP_LOWER32nd   (10 << W25_SR_BP_SHIFT) /* Lower 32nd */
+#  define W25X32_SR_BP_LOWER16th   (11 << W25_SR_BP_SHIFT) /* Lower 16th */
+#  define W25X32_SR_BP_LOWER8th    (12 << W25_SR_BP_SHIFT) /* Lower 8th */
+#  define W25X32_SR_BP_LOWERQTR    (13 << W25_SR_BP_SHIFT) /* Lower quarter */
+#  define W25X32_SR_BP_LOWERHALF   (14 << W25_SR_BP_SHIFT) /* Lower half */
+
+#  define W25X64_SR_BP_NONE        (0 << W25_SR_BP_SHIFT)  /* Unprotected */
+#  define W25X64_SR_BP_UPPER64th   (1 << W25_SR_BP_SHIFT)  /* Upper 64th */
+#  define W25X64_SR_BP_UPPER32nd   (2 << W25_SR_BP_SHIFT)  /* Upper 32nd */
+#  define W25X64_SR_BP_UPPER16th   (3 << W25_SR_BP_SHIFT)  /* Upper 16th */
+#  define W25X64_SR_BP_UPPER8th    (4 << W25_SR_BP_SHIFT)  /* Upper 8th */
+#  define W25X64_SR_BP_UPPERQTR    (5 << W25_SR_BP_SHIFT)  /* Upper quarter */
+#  define W25X64_SR_BP_UPPERHALF   (6 << W25_SR_BP_SHIFT)  /* Upper half */
+#  define W25X46_SR_BP_ALL         (7 << W25_SR_BP_SHIFT)  /* All sectors */
+#  define W25X64_SR_BP_LOWER64th   (9 << W25_SR_BP_SHIFT)  /* Lower 64th */
+#  define W25X64_SR_BP_LOWER32nd   (10 << W25_SR_BP_SHIFT) /* Lower 32nd */
+#  define W25X64_SR_BP_LOWER16th   (11 << W25_SR_BP_SHIFT) /* Lower 16th */
+#  define W25X64_SR_BP_LOWER8th    (12 << W25_SR_BP_SHIFT) /* Lower 8th */
+#  define W25X64_SR_BP_LOWERQTR    (13 << W25_SR_BP_SHIFT) /* Lower quarter */
+#  define W25X64_SR_BP_LOWERHALF   (14 << W25_SR_BP_SHIFT) /* Lower half */
+                                             /* Bit 6: Reserved */
+#define W25_SR_SRP                 (1 << 7)  /* Bit 7: Status register write protect */
+
+#define W25_DUMMY                  0xa5
+
+/* Chip Geometries ******************************************************************/
+/* All members of the family support uniform 4K-byte sectors and 256 byte pages */
+
+#define W25_SECTOR_SHIFT           12        /* Sector size 1 << 12 = 4Kb */
+#define W25_SECTOR_SIZE            (1 << 12) /* Sector size 1 << 12 = 4Kb */
+#define W25_PAGE_SHIFT             8         /* Sector size 1 << 8 = 256b */
+#define W25_PAGE_SIZE              (1 << 8)  /* Sector size 1 << 8 = 256b */
+
+#ifdef CONFIG_W25_SECTOR512                  /* Simulate a 512 byte sector */
+#  define W25_SECTOR512_SHIFT      9         /* Sector size 1 << 9 = 512 bytes */
+#  define W25_SECTOR512_SIZE       (1 << 9)  /* Sector size 1 << 9 = 512 bytes */
+#endif
+
+#define W25_ERASED_STATE           0xff      /* State of FLASH when erased */
+
+/* Cache flags */
+
+#define W25_CACHE_VALID            (1 << 0)  /* 1=Cache has valid data */
+#define W25_CACHE_DIRTY            (1 << 1)  /* 1=Cache is dirty */
+#define W25_CACHE_ERASED           (1 << 2)  /* 1=Backing FLASH is erased */
+
+#define IS_VALID(p)                ((((p)->flags) & W25_CACHE_VALID) != 0)
+#define IS_DIRTY(p)                ((((p)->flags) & W25_CACHE_DIRTY) != 0)
+#define IS_ERASED(p)               ((((p)->flags) & W25_CACHE_DIRTY) != 0)
+
+#define SET_VALID(p)               do { (p)->flags |= W25_CACHE_VALID; } while (0)
+#define SET_DIRTY(p)               do { (p)->flags |= W25_CACHE_DIRTY; } while (0)
+#define SET_ERASED(p)              do { (p)->flags |= W25_CACHE_DIRTY; } while (0)
+
+#define CLR_VALID(p)               do { (p)->flags &= ~W25_CACHE_VALID; } while (0)
+#define CLR_DIRTY(p)               do { (p)->flags &= ~W25_CACHE_DIRTY; } while (0)
+#define CLR_ERASED(p)              do { (p)->flags &= ~W25_CACHE_DIRTY; } while (0)
+
+/************************************************************************************
+ * Private Types
+ ************************************************************************************/
+
+/* This type represents the state of the MTD device.  The struct mtd_dev_s must
+ * appear at the beginning of the definition so that you can freely cast between
+ * pointers to struct mtd_dev_s and struct w25_dev_s.
+ */
+
+struct w25_dev_s
+{
+  struct mtd_dev_s      mtd;         /* MTD interface */
+  FAR struct spi_dev_s *spi;         /* Saved SPI interface instance */
+  uint16_t              nsectors;    /* Number of erase sectors */
+
+#if defined(CONFIG_W25_SECTOR512) && !defined(CONFIG_W25_READONLY)
+  uint8_t               flags;       /* Buffered sector flags */
+  uint16_t              esectno;     /* Erase sector number in the cache*/
+  FAR uint8_t          *sector;      /* Allocated sector data */
+#endif
+};
+
+/************************************************************************************
+ * Private Function Prototypes
+ ************************************************************************************/
+
+/* Helpers */
+
+static void w25_lock(FAR struct spi_dev_s *spi);
+static inline void w25_unlock(FAR struct spi_dev_s *spi);
+static inline int w25_readid(FAR struct w25_dev_s *priv);
+#ifndef CONFIG_W25_READONLY
+static void w25_unprotect(FAR struct w25_dev_s *priv);
+#endif
+static uint8_t w25_waitwritecomplete(FAR struct w25_dev_s *priv);
+static inline void w25_wren(FAR struct w25_dev_s *priv);
+static inline void w25_wrdi(FAR struct w25_dev_s *priv);
+static void w25_sectorerase(FAR struct w25_dev_s *priv, off_t offset);
+static inline int w25_chiperase(FAR struct w25_dev_s *priv);
+static void w25_byteread(FAR struct w25_dev_s *priv, FAR uint8_t *buffer,
+                           off_t address, size_t nbytes);
+#ifndef CONFIG_W25_READONLY
+static void w25_pagewrite(FAR struct w25_dev_s *priv, FAR const uint8_t *buffer,
+                            off_t address, size_t nbytes);
+#endif
+#ifdef CONFIG_W25_SECTOR512
+static void w25_cacheflush(struct w25_dev_s *priv);
+static FAR uint8_t *w25_cacheread(struct w25_dev_s *priv, off_t sector);
+static void w25_cacheerase(struct w25_dev_s *priv, off_t sector);
+static void w25_cachewrite(FAR struct w25_dev_s *priv, FAR const uint8_t *buffer,
+                             off_t sector, size_t nsectors);
+#endif
+
+/* MTD driver methods */
+
+static int w25_erase(FAR struct mtd_dev_s *dev, off_t startblock, size_t nblocks);
+static ssize_t w25_bread(FAR struct mtd_dev_s *dev, off_t startblock,
+                           size_t nblocks, FAR uint8_t *buf);
+static ssize_t w25_bwrite(FAR struct mtd_dev_s *dev, off_t startblock,
+                            size_t nblocks, FAR const uint8_t *buf);
+static ssize_t w25_read(FAR struct mtd_dev_s *dev, off_t offset, size_t nbytes,
+                          FAR uint8_t *buffer);
+static int w25_ioctl(FAR struct mtd_dev_s *dev, int cmd, unsigned long arg);
+
+/************************************************************************************
+ * Private Data
+ ************************************************************************************/
+
+/************************************************************************************
+ * Private Functions
+ ************************************************************************************/
+
+/************************************************************************************
+ * Name: w25_lock
+ ************************************************************************************/
+
+static void w25_lock(FAR struct spi_dev_s *spi)
+{
+  /* On SPI busses where there are multiple devices, it will be necessary to
+   * lock SPI to have exclusive access to the busses for a sequence of
+   * transfers.  The bus should be locked before the chip is selected.
+   *
+   * This is a blocking call and will not return until we have exclusiv access to
+   * the SPI buss.  We will retain that exclusive access until the bus is unlocked.
+   */
+
+  (void)SPI_LOCK(spi, true);
+
+  /* After locking the SPI bus, the we also need call the setfrequency, setbits, and
+   * setmode methods to make sure that the SPI is properly configured for the device.
+   * If the SPI buss is being shared, then it may have been left in an incompatible
+   * state.
+   */
+
+  SPI_SETMODE(spi, CONFIG_W25_SPIMODE);
+  SPI_SETBITS(spi, 8);
+  (void)SPI_SETFREQUENCY(spi, CONFIG_W25_SPIFREQUENCY);
+}
+
+/************************************************************************************
+ * Name: w25_unlock
+ ************************************************************************************/
+
+static inline void w25_unlock(FAR struct spi_dev_s *spi)
+{
+  (void)SPI_LOCK(spi, false);
+}
+
+/************************************************************************************
+ * Name: w25_readid
+ ************************************************************************************/
+
+static inline int w25_readid(struct w25_dev_s *priv)
+{
+  uint16_t manufacturer;
+  uint16_t memory;
+  uint16_t capacity;
+
+  fvdbg("priv: %p\n", priv);
+
+  /* Lock the SPI bus, configure the bus, and select this FLASH part. */
+
+  w25_lock(priv->spi);
+  SPI_SELECT(priv->spi, SPIDEV_FLASH, true);
+
+  /* Send the "Read ID (RDID)" command and read the first three ID bytes */
+
+  (void)SPI_SEND(priv->spi, W25_JEDEC_ID);
+  manufacturer = SPI_SEND(priv->spi, W25_DUMMY);
+  memory       = SPI_SEND(priv->spi, W25_DUMMY);
+  capacity     = SPI_SEND(priv->spi, W25_DUMMY);
+
+  /* Deselect the FLASH and unlock the bus */
+
+  SPI_SELECT(priv->spi, SPIDEV_FLASH, false);
+  w25_unlock(priv->spi);
+
+  fvdbg("manufacturer: %02x memory: %02x capacity: %02x\n",
+        manufacturer, memory, capacity);
+
+  /* Check for a valid manufacturer and memory type */
+
+  if (manufacturer == W25_JEDEC_MANUFACTURER &&
+      (memory == W25X_JEDEC_MEMORY_TYPE ||
+       memory == W25Q_JEDEC_MEMORY_TYPE_A ||
+       memory == W25Q_JEDEC_MEMORY_TYPE_B))
+    {
+      /* Okay.. is it a FLASH capacity that we understand? If so, save
+       * the FLASH capacity.
+       */
+
+      /* 16M-bit / 2M-byte (2,097,152)
+       *
+       * W24X16, W25Q16BV, W25Q16CL, W25Q16CV, W25Q16DW
+       */
+
+      if (capacity == W25_JEDEC_CAPACITY_16MBIT)
+        {
+           priv->nsectors = NSECTORS_16MBIT;
+        }
+
+      /* 32M-bit / M-byte (4,194,304)
+       *
+       * W25X32, W25Q32BV, W25Q32DW
+       */
+
+      else if (capacity == W25_JEDEC_CAPACITY_32MBIT)
+        {
+           priv->nsectors = NSECTORS_32MBIT;
+        }
+
+      /* 64M-bit / 8M-byte (8,388,608)
+       *
+       * W25X64,  W25Q64BV, W25Q64CV, W25Q64DW
+       */
+
+      else if (capacity == W25_JEDEC_CAPACITY_64MBIT)
+        {
+           priv->nsectors = NSECTORS_64MBIT;
+        }
+
+      /* 128M-bit / 16M-byte (16,777,216)
+       *
+       * W25Q128BV
+       */
+
+      else if (capacity == W25_JEDEC_CAPACITY_128MBIT)
+        {
+           priv->nsectors = NSECTORS_128MBIT;
+        }
+      else
+        {
+          /* Nope.. we don't understand this capacity. */
+
+          return -ENODEV;
+        }
+
+      return OK;
+    }
+
+  /* We don't understand the manufacturer or the memory type */
+
+  return -ENODEV;
+}
+
+/************************************************************************************
+ * Name: w25_unprotect
+ ************************************************************************************/
+
+#ifndef CONFIG_W25_READONLY
+static void w25_unprotect(FAR struct w25_dev_s *priv)
+{
+  /* Select this FLASH part */
+
+  SPI_SELECT(priv->spi, SPIDEV_FLASH, true);
+
+  /* Send "Write enable (WREN)" */
+
+  w25_wren(priv);
+
+  /* Re-select this FLASH part (This might not be necessary... but is it shown in
+   * the SST25 timing diagrams from which this code was leveraged.)
+   */
+
+  SPI_SELECT(priv->spi, SPIDEV_FLASH, false);
+  SPI_SELECT(priv->spi, SPIDEV_FLASH, true);
+
+  /* Send "Write enable status (EWSR)" */
+
+  SPI_SEND(priv->spi, W25_WRSR);
+
+  /* Following by the new status value */
+
+  SPI_SEND(priv->spi, 0);
+  SPI_SEND(priv->spi, 0);
+}
+#endif
+
+/************************************************************************************
+ * Name: w25_waitwritecomplete
+ ************************************************************************************/
+
+static uint8_t w25_waitwritecomplete(struct w25_dev_s *priv)
+{
+  uint8_t status;
+
+  /* Are we the only device on the bus? */
+
+#ifdef CONFIG_SPI_OWNBUS
+
+  /* Select this FLASH part */
+
+  SPI_SELECT(priv->spi, SPIDEV_FLASH, true);
+
+  /* Send "Read Status Register (RDSR)" command */
+
+  (void)SPI_SEND(priv->spi, W25_RDSR);
+  
+  /* Loop as long as the memory is busy with a write cycle */
+
+  do
+    {
+      /* Send a dummy byte to generate the clock needed to shift out the status */
+
+      status = SPI_SEND(priv->spi, W25_DUMMY);
+    }
+  while ((status & W25_SR_BUSY) != 0);
+
+  /* Deselect the FLASH */
+
+  SPI_SELECT(priv->spi, SPIDEV_FLASH, false);
+
+#else
+
+  /* Loop as long as the memory is busy with a write cycle */
+
+  do
+    {
+      /* Select this FLASH part */
+
+      SPI_SELECT(priv->spi, SPIDEV_FLASH, true);
+
+      /* Send "Read Status Register (RDSR)" command */
+
+      (void)SPI_SEND(priv->spi, W25_RDSR);
+
+      /* Send a dummy byte to generate the clock needed to shift out the status */
+
+      status = SPI_SEND(priv->spi, W25_DUMMY);
+
+      /* Deselect the FLASH */
+
+      SPI_SELECT(priv->spi, SPIDEV_FLASH, false);
+
+      /* Given that writing could take up to few tens of milliseconds, and erasing
+       * could take more.  The following short delay in the "busy" case will allow
+       * other peripherals to access the SPI bus.
+       */
+
+#if 0 /* Makes writes too slow */
+      if ((status & W25_SR_BUSY) != 0)
+        {
+          w25_unlock(priv->spi);
+          usleep(1000);
+          w25_lock(priv->spi);
+        }
+#endif
+    }
+  while ((status & W25_SR_BUSY) != 0);
+#endif
+
+  return status;
+}
+
+/************************************************************************************
+ * Name:  w25_wren
+ ************************************************************************************/
+
+static inline void w25_wren(struct w25_dev_s *priv)
+{
+  /* Select this FLASH part */
+
+  SPI_SELECT(priv->spi, SPIDEV_FLASH, true);
+
+  /* Send "Write Enable (WREN)" command */
+
+  (void)SPI_SEND(priv->spi, W25_WREN);
+  
+  /* Deselect the FLASH */
+
+  SPI_SELECT(priv->spi, SPIDEV_FLASH, false);
+}
+
+/************************************************************************************
+ * Name:  w25_wrdi
+ ************************************************************************************/
+
+static inline void w25_wrdi(struct w25_dev_s *priv)
+{
+  /* Select this FLASH part */
+
+  SPI_SELECT(priv->spi, SPIDEV_FLASH, true);
+
+  /* Send "Write Disable (WRDI)" command */
+
+  (void)SPI_SEND(priv->spi, W25_WRDI);
+  
+  /* Deselect the FLASH */
+
+  SPI_SELECT(priv->spi, SPIDEV_FLASH, false);
+}
+
+/************************************************************************************
+ * Name:  w25_sectorerase
+ ************************************************************************************/
+
+static void w25_sectorerase(struct w25_dev_s *priv, off_t sector)
+{
+  off_t address = sector << W25_SECTOR_SHIFT;
+
+  fvdbg("sector: %08lx\n", (long)sector);
+
+  /* Wait for any preceding write or erase operation to complete. */
+
+  (void)w25_waitwritecomplete(priv);
+
+  /* Send write enable instruction */
+
+  w25_wren(priv);
+
+  /* Select this FLASH part */
+
+  SPI_SELECT(priv->spi, SPIDEV_FLASH, true);
+
+  /* Send the "Sector Erase (SE)" instruction */
+
+  (void)SPI_SEND(priv->spi, W25_SE);
+
+  /* Send the sector address high byte first. Only the most significant bits (those
+   * corresponding to the sector) have any meaning.
+   */
+
+  (void)SPI_SEND(priv->spi, (address >> 16) & 0xff);
+  (void)SPI_SEND(priv->spi, (address >> 8) & 0xff);
+  (void)SPI_SEND(priv->spi, address & 0xff);
+
+  /* Deselect the FLASH */
+
+  SPI_SELECT(priv->spi, SPIDEV_FLASH, false);
+}
+
+/************************************************************************************
+ * Name:  w25_chiperase
+ ************************************************************************************/
+
+static inline int w25_chiperase(struct w25_dev_s *priv)
+{
+  fvdbg("priv: %p\n", priv);
+
+  /* Wait for any preceding write or erase operation to complete. */
+
+  (void)w25_waitwritecomplete(priv);
+
+  /* Send write enable instruction */
+
+  w25_wren(priv);
+
+  /* Select this FLASH part */
+
+  SPI_SELECT(priv->spi, SPIDEV_FLASH, true);
+
+  /* Send the "Chip Erase (CE)" instruction */
+
+  (void)SPI_SEND(priv->spi, W25_CE);
+
+  /* Deselect the FLASH */
+
+  SPI_SELECT(priv->spi, SPIDEV_FLASH, false);
+  fvdbg("Return: OK\n");
+  return OK;
+}
+
+/************************************************************************************
+ * Name: w25_byteread
+ ************************************************************************************/
+
+static void w25_byteread(FAR struct w25_dev_s *priv, FAR uint8_t *buffer,
+                           off_t address, size_t nbytes)
+{
+  uint8_t status;
+
+  fvdbg("address: %08lx nbytes: %d\n", (long)address, (int)nbytes);
+
+  /* Wait for any preceding write or erase operation to complete. */
+
+  status = w25_waitwritecomplete(priv);
+  DEBUGASSERT((status & (W25_SR_WEL|W25_SR_BP_MASK)) == 0);
+
+  /* Make sure that writing is disabled */
+
+  w25_wrdi(priv);
+
+  /* Select this FLASH part */
+
+  SPI_SELECT(priv->spi, SPIDEV_FLASH, true);
+
+  /* Send "Read from Memory " instruction */
+
+#ifdef CONFIG_W25_SLOWREAD
+  (void)SPI_SEND(priv->spi, W25_RDDATA);
+#else
+  (void)SPI_SEND(priv->spi, W25_FRD);
+#endif
+
+  /* Send the address high byte first. */
+
+  (void)SPI_SEND(priv->spi, (address >> 16) & 0xff);
+  (void)SPI_SEND(priv->spi, (address >> 8) & 0xff);
+  (void)SPI_SEND(priv->spi, address & 0xff);
+
+  /* Send a dummy byte */
+
+#ifndef CONFIG_W25_SLOWREAD
+  (void)SPI_SEND(priv->spi, W25_DUMMY);
+#endif
+
+  /* Then read all of the requested bytes */
+
+  SPI_RECVBLOCK(priv->spi, buffer, nbytes);
+
+  /* Deselect the FLASH */
+
+  SPI_SELECT(priv->spi, SPIDEV_FLASH, false);
+}
+
+/************************************************************************************
+ * Name:  w25_pagewrite
+ ************************************************************************************/
+
+#ifndef CONFIG_W25_READONLY
+static void w25_pagewrite(struct w25_dev_s *priv, FAR const uint8_t *buffer,
+                          off_t address, size_t nbytes)
+{
+  uint8_t status;
+
+  fvdbg("address: %08lx nwords: %d\n", (long)address, (int)nbytes);
+  DEBUGASSERT(priv && buffer && ((uintptr_t)buffer & 0xff) == 0 &&
+             (nbytes & 0xff) == 0);
+
+  for (; nbytes > 0; nbytes -= W25_PAGE_SIZE)
+    {
+      /* Wait for any preceding write or erase operation to complete. */
+
+      status = w25_waitwritecomplete(priv);
+      DEBUGASSERT((status & (W25_SR_WEL|W25_SR_BP_MASK)) == 0);
+
+      /* Enable write access to the FLASH */
+
+      w25_wren(priv);
+
+      /* Select this FLASH part */
+
+      SPI_SELECT(priv->spi, SPIDEV_FLASH, true);
+
+      /* Send the "Page Program (W25_PP)" Command */
+
+      SPI_SEND(priv->spi, W25_PP);
+
+      /* Send the address high byte first. */
+
+      (void)SPI_SEND(priv->spi, (address >> 16) & 0xff);
+      (void)SPI_SEND(priv->spi, (address >> 8) & 0xff);
+      (void)SPI_SEND(priv->spi, address & 0xff);
+
+      /* Then send the page of data */
+
+      SPI_SNDBLOCK(priv->spi, buffer, W25_PAGE_SIZE);
+
+      /* Deselect the FLASH and setup for the next pass through the loop */
+
+      SPI_SELECT(priv->spi, SPIDEV_FLASH, false);
+
+      /* Update addresses */
+
+      address += W25_PAGE_SIZE;
+      buffer  += W25_PAGE_SIZE;
+    }
+
+  /* Disable writing */
+
+  w25_wrdi(priv);
+}
+#endif
+
+/************************************************************************************
+ * Name: w25_cacheflush
+ ************************************************************************************/
+
+#if defined(CONFIG_W25_SECTOR512) && !defined(CONFIG_W25_READONLY)
+static void w25_cacheflush(struct w25_dev_s *priv)
+{
+  /* If the cached is dirty (meaning that it no longer matches the old FLASH contents)
+   * or was erased (with the cache containing the correct FLASH contents), then write
+   * the cached erase block to FLASH.
+   */
+
+  if (IS_DIRTY(priv) || IS_ERASED(priv))
+    {
+      /* Write entire erase block to FLASH */
+
+      w25_pagewrite(priv, priv->sector, (off_t)priv->esectno << W25_SECTOR_SHIFT,
+                      W25_SECTOR_SIZE);
+
+      /* The case is no long dirty and the FLASH is no longer erased */
+
+      CLR_DIRTY(priv);
+      CLR_ERASED(priv);
+    }
+}
+#endif
+
+/************************************************************************************
+ * Name: w25_cacheread
+ ************************************************************************************/
+
+#if defined(CONFIG_W25_SECTOR512) && !defined(CONFIG_W25_READONLY)
+static FAR uint8_t *w25_cacheread(struct w25_dev_s *priv, off_t sector)
+{
+  off_t esectno;
+  int   shift;
+  int   index;
+ 
+  /* Convert from the 512 byte sector to the erase sector size of the device.  For
+   * exmample, if the actual erase sector size if 4Kb (1 << 12), then we first
+   * shift to the right by 3 to get the sector number in 4096 increments.
+   */
+
+  shift    = W25_SECTOR_SHIFT - W25_SECTOR512_SHIFT;
+  esectno  = sector >> shift;
+  fvdbg("sector: %ld esectno: %d shift=%d\n", sector, esectno, shift);
+
+  /* Check if the requested erase block is already in the cache */
+
+  if (!IS_VALID(priv) || esectno != priv->esectno)
+    {
+      /* No.. Flush any dirty erase block currently in the cache */
+
+      w25_cacheflush(priv);
+
+      /* Read the erase block into the cache */
+
+      w25_byteread(priv, priv->sector, (esectno << W25_SECTOR_SHIFT), W25_SECTOR_SIZE);
+
+      /* Mark the sector as cached */
+
+      priv->esectno = esectno;
+
+      SET_VALID(priv);          /* The data in the cache is valid */
+      CLR_DIRTY(priv);          /* It should match the FLASH contents */
+      CLR_ERASED(priv);         /* The underlying FLASH has not been erased */
+    }
+
+  /* Get the index to the 512 sector in the erase block that holds the argument */
+
+  index = sector & ((1 << shift) - 1);
+
+  /* Return the address in the cache that holds this sector */
+
+  return &priv->sector[index << W25_SECTOR512_SHIFT];
+}
+#endif
+
+/************************************************************************************
+ * Name: w25_cacheerase
+ ************************************************************************************/
+
+#if defined(CONFIG_W25_SECTOR512) && !defined(CONFIG_W25_READONLY)
+static void w25_cacheerase(struct w25_dev_s *priv, off_t sector)
+{
+  FAR uint8_t *dest;
+
+  /* First, make sure that the erase block containing the 512 byte sector is in
+   * the cache.
+   */
+
+  dest = w25_cacheread(priv, sector);
+
+  /* Erase the block containing this sector if it is not already erased.
+   * The erased indicated will be cleared when the data from the erase sector
+   * is read into the cache and set here when we erase the block.
+   */
+
+  if (!IS_ERASED(priv))
+    {
+      off_t esectno  = sector >> (W25_SECTOR_SHIFT - W25_SECTOR512_SHIFT);
+      fvdbg("sector: %ld esectno: %d\n", sector, esectno);
+
+      w25_sectorerase(priv, esectno);
+      SET_ERASED(priv);
+    }
+
+  /* Put the cached sector data into the erase state and mart the cache as dirty
+   * (but don't update the FLASH yet.  The caller will do that at a more optimal
+   * time).
+   */
+
+  memset(dest, W25_ERASED_STATE, W25_SECTOR512_SIZE);
+  SET_DIRTY(priv);
+}
+#endif
+
+/************************************************************************************
+ * Name: w25_cachewrite
+ ************************************************************************************/
+
+#if defined(CONFIG_W25_SECTOR512) && !defined(CONFIG_W25_READONLY)
+static void w25_cachewrite(FAR struct w25_dev_s *priv, FAR const uint8_t *buffer,
+                            off_t sector, size_t nsectors)
+{
+  FAR uint8_t *dest;
+
+  for (; nsectors > 0; nsectors--)
+    {
+      /* First, make sure that the erase block containing 512 byte sector is in
+       * memory.
+       */
+
+      dest = w25_cacheread(priv, sector);
+
+      /* Erase the block containing this sector if it is not already erased.
+       * The erased indicated will be cleared when the data from the erase sector
+       * is read into the cache and set here when we erase the sector.
+       */
+
+      if (!IS_ERASED(priv))
+        {
+          off_t esectno  = sector >> (W25_SECTOR_SHIFT - W25_SECTOR512_SHIFT);
+          fvdbg("sector: %ld esectno: %d\n", sector, esectno);
+
+          w25_sectorerase(priv, esectno);
+          SET_ERASED(priv);
+        }
+
+      /* Copy the new sector data into cached erase block */
+
+      memcpy(dest, buffer, W25_SECTOR512_SIZE);
+      SET_DIRTY(priv);
+
+      /* Set up for the next 512 byte sector */
+
+      buffer += W25_SECTOR512_SIZE;
+      sector++;
+    }
+
+  /* Flush the last erase block left in the cache */
+
+  w25_cacheflush(priv);
+}
+#endif
+
+/************************************************************************************
+ * Name: w25_erase
+ ************************************************************************************/
+
+static int w25_erase(FAR struct mtd_dev_s *dev, off_t startblock, size_t nblocks)
+{
+#ifdef CONFIG_W25_READONLY
+  return -EACESS
+#else
+  FAR struct w25_dev_s *priv = (FAR struct w25_dev_s *)dev;
+  size_t blocksleft = nblocks;
+
+  fvdbg("startblock: %08lx nblocks: %d\n", (long)startblock, (int)nblocks);
+
+  /* Lock access to the SPI bus until we complete the erase */
+
+  w25_lock(priv->spi);
+
+  while (blocksleft-- > 0)
+    {
+      /* Erase each sector */
+
+#ifdef CONFIG_W25_SECTOR512
+      w25_cacheerase(priv, startblock);
+#else
+      w25_sectorerase(priv, startblock);
+#endif
+      startblock++;
+    }
+
+#ifdef CONFIG_W25_SECTOR512
+  /* Flush the last erase block left in the cache */
+
+  w25_cacheflush(priv);
+#endif
+
+  w25_unlock(priv->spi);
+  return (int)nblocks;
+#endif
+}
+
+/************************************************************************************
+ * Name: w25_bread
+ ************************************************************************************/
+
+static ssize_t w25_bread(FAR struct mtd_dev_s *dev, off_t startblock, size_t nblocks,
+                           FAR uint8_t *buffer)
+{
+#ifdef CONFIG_W25_SECTOR512
+  ssize_t nbytes;
+
+  fvdbg("startblock: %08lx nblocks: %d\n", (long)startblock, (int)nblocks);
+
+  /* On this device, we can handle the block read just like the byte-oriented read */
+
+  nbytes = w25_read(dev, startblock << W25_SECTOR512_SHIFT, nblocks << W25_SECTOR512_SHIFT, buffer);
+  if (nbytes > 0)
+    {
+      return nbytes >> W25_SECTOR512_SHIFT;
+    }
+
+  return (int)nbytes;
+#else
+  FAR struct w25_dev_s *priv = (FAR struct w25_dev_s *)dev;
+  ssize_t nbytes;
+
+  fvdbg("startblock: %08lx nblocks: %d\n", (long)startblock, (int)nblocks);
+
+  /* On this device, we can handle the block read just like the byte-oriented read */
+
+  nbytes = w25_read(dev, startblock << W25_SECTOR_SHIFT, nblocks << W25_SECTOR_SHIFT, buffer);
+  if (nbytes > 0)
+    {
+      return nbytes >> W25_SECTOR_SHIFT;
+    }
+
+  return (int)nbytes;
+#endif
+}
+
+/************************************************************************************
+ * Name: w25_bwrite
+ ************************************************************************************/
+
+static ssize_t w25_bwrite(FAR struct mtd_dev_s *dev, off_t startblock, size_t nblocks,
+                            FAR const uint8_t *buffer)
+{
+#ifdef CONFIG_W25_READONLY
+  return -EACCESS;
+#else
+  FAR struct w25_dev_s *priv = (FAR struct w25_dev_s *)dev;
+
+  fvdbg("startblock: %08lx nblocks: %d\n", (long)startblock, (int)nblocks);
+
+  /* Lock the SPI bus and write all of the pages to FLASH */
+
+  w25_lock(priv->spi);
+
+#if defined(CONFIG_W25_SECTOR512)
+  w25_cachewrite(priv, buffer, startblock, nblocks);
+#else
+  w25_pagewrite(priv, buffer, startblock << W25_SECTOR_SHIFT,
+                  nblocks << W25_SECTOR_SHIFT);
+#endif
+  w25_unlock(priv->spi);
+
+  return nblocks;
+#endif
+}
+
+/************************************************************************************
+ * Name: w25_read
+ ************************************************************************************/
+
+static ssize_t w25_read(FAR struct mtd_dev_s *dev, off_t offset, size_t nbytes,
+                          FAR uint8_t *buffer)
+{
+  FAR struct w25_dev_s *priv = (FAR struct w25_dev_s *)dev;
+
+  fvdbg("offset: %08lx nbytes: %d\n", (long)offset, (int)nbytes);
+
+  /* Lock the SPI bus and select this FLASH part */
+
+  w25_lock(priv->spi);
+  w25_byteread(priv, buffer, offset, nbytes);
+  w25_unlock(priv->spi);
+
+  fvdbg("return nbytes: %d\n", (int)nbytes);
+  return nbytes;
+}
+
+/************************************************************************************
+ * Name: w25_ioctl
+ ************************************************************************************/
+
+static int w25_ioctl(FAR struct mtd_dev_s *dev, int cmd, unsigned long arg)
+{
+  FAR struct w25_dev_s *priv = (FAR struct w25_dev_s *)dev;
+  int ret = -EINVAL; /* Assume good command with bad parameters */
+
+  fvdbg("cmd: %d \n", cmd);
+
+  switch (cmd)
+    {
+      case MTDIOC_GEOMETRY:
+        {
+          FAR struct mtd_geometry_s *geo = (FAR struct mtd_geometry_s *)((uintptr_t)arg);
+          if (geo)
+            {
+              /* Populate the geometry structure with information need to know
+               * the capacity and how to access the device.
+               *
+               * NOTE: that the device is treated as though it where just an array
+               * of fixed size blocks.  That is most likely not true, but the client
+               * will expect the device logic to do whatever is necessary to make it
+               * appear so.
+               */
+
+#ifdef CONFIG_W25_SECTOR512
+              geo->blocksize    = (1 << W25_SECTOR512_SHIFT);
+              geo->erasesize    = (1 << W25_SECTOR512_SHIFT);
+              geo->neraseblocks = priv->nsectors << (W25_SECTOR_SHIFT - W25_SECTOR512_SHIFT);
+#else
+              geo->blocksize    = W25_SECTOR_SIZE;
+              geo->erasesize    = W25_SECTOR_SIZE;
+              geo->neraseblocks = priv->nsectors;
+#endif
+              ret               = OK;
+
+              fvdbg("blocksize: %d erasesize: %d neraseblocks: %d\n",
+                    geo->blocksize, geo->erasesize, geo->neraseblocks);
+            }
+        }
+        break;
+
+      case MTDIOC_BULKERASE:
+        {
+            /* Erase the entire device */
+
+            w25_lock(priv->spi);
+            ret = w25_chiperase(priv);
+            w25_unlock(priv->spi);
+        }
+        break;
+ 
+      case MTDIOC_XIPBASE:
+      default:
+        ret = -ENOTTY; /* Bad command */
+        break;
+    }
+
+  fvdbg("return %d\n", ret);
+  return ret;
+}
+
+/************************************************************************************
+ * Public Functions
+ ************************************************************************************/
+
+/************************************************************************************
+ * Name: w25_initialize
+ *
+ * Description:
+ *   Create an initialize MTD device instance.  MTD devices are not registered
+ *   in the file system, but are created as instances that can be bound to
+ *   other functions (such as a block or character driver front end).
+ *
+ ************************************************************************************/
+
+FAR struct mtd_dev_s *w25_initialize(FAR struct spi_dev_s *spi)
+{
+  FAR struct w25_dev_s *priv;
+  int ret;
+
+  fvdbg("spi: %p\n", spi);
+
+  /* Allocate a state structure (we allocate the structure instead of using
+   * a fixed, static allocation so that we can handle multiple FLASH devices.
+   * The current implementation would handle only one FLASH part per SPI
+   * device (only because of the SPIDEV_FLASH definition) and so would have
+   * to be extended to handle multiple FLASH parts on the same SPI bus.
+   */
+
+  priv = (FAR struct w25_dev_s *)kzalloc(sizeof(struct w25_dev_s));
+  if (priv)
+    {
+      /* Initialize the allocated structure */
+
+      priv->mtd.erase  = w25_erase;
+      priv->mtd.bread  = w25_bread;
+      priv->mtd.bwrite = w25_bwrite;
+      priv->mtd.read   = w25_read;
+      priv->mtd.ioctl  = w25_ioctl;
+      priv->spi        = spi;
+
+      /* Deselect the FLASH */
+
+      SPI_SELECT(spi, SPIDEV_FLASH, false);
+
+      /* Identify the FLASH chip and get its capacity */
+
+      ret = w25_readid(priv);
+      if (ret != OK)
+        {
+          /* Unrecognized! Discard all of that work we just did and return NULL */
+
+          fdbg("Unrecognized\n");
+          kfree(priv);
+          priv = NULL;
+        }
+      else
+        {
+          /* Make sure the the FLASH is unprotected so that we can write into it */
+
+#ifndef CONFIG_W25_READONLY
+          w25_unprotect(priv);
+#endif
+
+#ifdef CONFIG_W25_SECTOR512        /* Simulate a 512 byte sector */
+          /* Allocate a buffer for the erase block cache */
+
+          priv->sector = (FAR uint8_t *)kmalloc(W25_SECTOR_SIZE);
+          if (!priv->sector)
+            {
+              /* Allocation failed! Discard all of that work we just did and return NULL */
+
+              fdbg("Allocation failed\n");
+              kfree(priv);
+              priv = NULL;
+            }
+#endif
+        }
+    }
+
+  /* Return the implementation-specific state structure as the MTD device */
+
+  fvdbg("Return %p\n", priv);
+  return (FAR struct mtd_dev_s *)priv;
+}
diff --git a/nuttx/include/nuttx/analog/adc.h b/nuttx/include/nuttx/analog/adc.h
index 873f5d9da..f654bff05 100644
--- a/nuttx/include/nuttx/analog/adc.h
+++ b/nuttx/include/nuttx/analog/adc.h
@@ -47,6 +47,7 @@
  ************************************************************************************/
 
 #include <nuttx/config.h>
+#include <nuttx/compiler.h>
 
 #include <sys/types.h>
 #include <stdint.h>
@@ -78,7 +79,7 @@ struct adc_msg_s
 {
   uint8_t      am_channel;               /* The 8-bit ADC Channel */
   int32_t      am_data;                  /* ADC convert result (4 bytes) */
-} __attribute__((__packed__));
+} packed_struct;
 
 struct adc_fifo_s
 {
diff --git a/nuttx/include/nuttx/compiler.h b/nuttx/include/nuttx/compiler.h
index 733d58eec..1e0af4382 100644
--- a/nuttx/include/nuttx/compiler.h
+++ b/nuttx/include/nuttx/compiler.h
@@ -1,7 +1,7 @@
 /****************************************************************************
  * include/nuttx/compiler.h
  *
- *   Copyright (C) 2007-2009 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2007-2009, 2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -92,6 +92,14 @@
 # define reentrant_function
 # define naked_function
 
+/* The inline_function attribute informs GCC that the function should always
+ * be inlined, regardless of the level of optimization.  The noinline_function
+ * indicates that the function should never be inlined.
+ */
+
+# define inline_function __attribute__ ((always_inline))
+# define noinline_function __attribute__ ((noinline))
+
 /* GCC has does not use storage classes to qualify addressing */
 
 # define FAR
@@ -224,10 +232,15 @@
 # define noreturn_function
 # define packed_struct
 
-/* SDCC does support "naked" function s*/
+/* SDCC does support "naked" functions */
 
 # define naked_function __naked
 
+/* SDCC does not support forced inlining. */
+
+# define inline_function
+# define noinline_function
+
 /* The reentrant attribute informs SDCC that the function
  * must be reentrant.  In this case, SDCC will store input
  * arguments on the stack to support reentrancy.
@@ -320,11 +333,13 @@
 # define weak_function
 # define weak_const_function
 
-/* The Zilog compiler does not support the noreturn, packed, or naked attributes */
+/* The Zilog compiler does not support the noreturn, packed, naked attributes */
 
 # define noreturn_function
 # define packed_struct
 # define naked_function
+# define inline_function
+# define noinline_function
 
 /* The Zilog compiler does not support the reentrant attribute */
 
@@ -406,7 +421,8 @@
 # define packed_struct
 # define reentrant_function
 # define naked_function
-
+# define inline_function
+# define noinline_function
 
 # define FAR
 # define NEAR
diff --git a/nuttx/include/nuttx/mtd.h b/nuttx/include/nuttx/mtd.h
index 5b955a45f..44582c412 100644
--- a/nuttx/include/nuttx/mtd.h
+++ b/nuttx/include/nuttx/mtd.h
@@ -220,6 +220,19 @@ EXTERN FAR struct mtd_dev_s *at24c_initialize(FAR struct i2c_dev_s *dev);
 
 EXTERN FAR struct mtd_dev_s *sst25_initialize(FAR struct spi_dev_s *dev);
 
+
+/****************************************************************************
+ * Name: w25_initialize
+ *
+ * Description:
+ *   Create an initialized MTD device instance.  MTD devices are not registered
+ *   in the file system, but are created as instances that can be bound to
+ *   other functions (such as a block or character driver front end).
+ *
+ ****************************************************************************/
+
+EXTERN FAR struct mtd_dev_s *w25_initialize(FAR struct spi_dev_s *dev);
+
 #undef EXTERN
 #ifdef __cplusplus
 }