Patches from Petteri Aimonen + stdbool and rand() changes for Freddie Chopin

git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@5415 42af7a65-404d-4744-a932-0658087f49c3

38 files changed, 1157 insertions, 192 deletions

diff --git a/NxWidgets/ChangeLog.txt b/NxWidgets/ChangeLog.txt
index c3ae00d6a..7f7b21247 100644
--- a/NxWidgets/ChangeLog.txt
+++ b/NxWidgets/ChangeLog.txt
@@ -213,4 +213,8 @@
   Submitted by Petteri Aimonen.
 * NxWidgets:CText and NxWidgets:CNumericEdite:  Fix some memory freeing bugs
   (from Petteri Aimonen).
-  
\ No newline at end of file
+* NxWidgets::CScrollingPanel:  Usability improvements.  It is borderless for now,
+  because there was no easy way to redraw only the required part of the border.
+  Contributed by Petteri Aimonen.
+* NxWidgets::CNxWidgets and NxWM::CStartWindow: Small changes to make sub-
+  classing easier (from Petteri Aimonen).
diff --git a/NxWidgets/libnxwidgets/include/cnxwidget.hxx b/NxWidgets/libnxwidgets/include/cnxwidget.hxx
index 2ca055c1c..dda8efc1d 100644
--- a/NxWidgets/libnxwidgets/include/cnxwidget.hxx
+++ b/NxWidgets/libnxwidgets/include/cnxwidget.hxx
@@ -1058,7 +1058,7 @@ namespace NXWidgets
      * @return True if the click was successful.
      */
 
-    bool click(nxgl_coord_t x, nxgl_coord_t y);
+    virtual bool click(nxgl_coord_t x, nxgl_coord_t y);
 
     /**
      * Check if the click is a double-click.
diff --git a/NxWidgets/libnxwidgets/src/cscrollingpanel.cxx b/NxWidgets/libnxwidgets/src/cscrollingpanel.cxx
index d3ee40cf9..b7c507bb2 100644
--- a/NxWidgets/libnxwidgets/src/cscrollingpanel.cxx
+++ b/NxWidgets/libnxwidgets/src/cscrollingpanel.cxx
@@ -70,11 +70,12 @@
 /****************************************************************************
  * Included Files
  ****************************************************************************/
- 
+
 #include <nuttx/config.h>
 
 #include <stdint.h>
 #include <stdbool.h>
+#include <debug.h>
 
 #include "cwidgetcontrol.hxx"
 #include "cscrollingpanel.hxx"
@@ -113,6 +114,13 @@ CScrollingPanel::CScrollingPanel(CWidgetControl *pWidgetControl,
 : CNxWidget(pWidgetControl, x, y, width, height, flags, style)
 {
   m_widgetControl = pWidgetControl;
+
+  // NOTE: CScrollingPanel is temporarily borderless because there was no
+  // easy way to redraw only the required part of the border.
+
+  m_flags.permeable = true;
+  m_flags.borderless = true;
+
   CRect rect;
   getClientRect(rect);
 
@@ -120,12 +128,10 @@ CScrollingPanel::CScrollingPanel(CWidgetControl *pWidgetControl,
   m_canvasHeight  = rect.getHeight();
   m_canvasX       = 0;
   m_canvasY       = 0;
-  
+
   setAllowsVerticalScroll(true);
   setAllowsHorizontalScroll(true);
   setContentScrolled(true);
-
-  m_flags.permeable = true;
 }
 
 /**
@@ -186,6 +192,24 @@ void CScrollingPanel::scroll(int32_t dx, int32_t dy)
           CGraphicsPort *port = m_widgetControl->getGraphicsPort();
           port->move(getX(), getY(), dx, dy, rect.getWidth(), rect.getHeight());
 
+          if (dx > 0)
+            {
+              revealedRects.push_back(CRect(getX(), getY(), dx, rect.getHeight()));
+            }
+          else if (dx < 0)
+            {
+              revealedRects.push_back(CRect(getX() + rect.getWidth() + dx, getY(), -dx, rect.getHeight()));
+            }
+
+          if (dy > 0)
+            {
+              revealedRects.push_back(CRect(getX(), getY(), rect.getWidth(), dy));
+            }
+          else if (dy < 0)
+            {
+              revealedRects.push_back(CRect(getX(), getY() + rect.getHeight() + dy, rect.getWidth(), -dy));
+            }
+
           // Adjust the scroll values
 
           m_canvasY += dy;
@@ -193,12 +217,20 @@ void CScrollingPanel::scroll(int32_t dx, int32_t dy)
 
           if (revealedRects.size() > 0)
             {
-              // Draw revealed sections
+              // Draw background to revealed sections
+              // Children will redraw themselves in moveTo.
 
               for (int i = 0; i < revealedRects.size(); ++i)
                 {
-                  drawBorder(port);
-                  drawContents(port);
+                  CRect &rrect = revealedRects[i];
+
+                  gvdbg("Redrawing %d,%d,%d,%d after scroll\n",
+                        rrect.getX(), rrect.getY(),
+                        rrect.getWidth(), rrect.getHeight());
+
+                  port->drawFilledRect(rrect.getX(), rrect.getY(),
+                                       rrect.getWidth(), rrect.getHeight(),
+                                       getBackgroundColor());
                 }
             }
         }
diff --git a/NxWidgets/nxwm/include/cstartwindow.hxx b/NxWidgets/nxwm/include/cstartwindow.hxx
index 671b01087..52a67fbd4 100644
--- a/NxWidgets/nxwm/include/cstartwindow.hxx
+++ b/NxWidgets/nxwm/include/cstartwindow.hxx
@@ -97,8 +97,8 @@ namespace NxWM
    */
 
   class CStartWindow : public IApplication,
-                       private IApplicationCallback,
-                       private NXWidgets::CWidgetEventHandler
+                       protected IApplicationCallback,
+                       protected NXWidgets::CWidgetEventHandler
   {
   protected:
     /**
diff --git a/nuttx/ChangeLog b/nuttx/ChangeLog
index ab1412ae2..0ec0fdc3d 100644
--- a/nuttx/ChangeLog
+++ b/nuttx/ChangeLog
@@ -3737,4 +3737,25 @@
 	* arch/z80/src/Makefile.sdccw:  Renamed makefiles with extensions zdiil,
 	  zdiiw, sdccl, and sdccw for the ZDS-II vs SDCC compilers and for the
 	  POSIX vs Windows native builds.
-
+	* nuttx/drivers/mtd/ftl.c:  Fix for the flash translation layer. Short
+	  unaligned writes were buggy.  From Petteri Aimonen.
+	* nuttx/libc/math/lib_round*.c:  Add rounding functions to the math
+	  library.  Contributed by Petteri Aimonen.
+	* include/cxx/cstdlib:  Add stroul().  From Petteri Aimonen.
+	* arch/*/include/limits.h:  Change signed minimum values from, for example,
+	  (-128) to (-127 - 1) to avoid overflows under certain conditions.  From
+	  Peterri Aimonen.
+	* graphics/nxtk/nxtk_subwindowmove.c: Previously it was very difficult to
+	  do e.g. "scroll by dx, dy". When given the full window area, nxtk_subwindowmove
+	  would clip the offset always to 0,0. It makes more sense for it to clip the
+	  source area and not modify the offset.  From Petteri Aimonen.
+	* graphics/nxtk/nxtk_getwindow.c: Clipping would change the offset of returned
+	  data, and caller has no way to know what the new offset would be. This messes
+	  up font drawing when the text is partially out of window, e.g. when scrolling.
+	  Also from Petteri Aimonen.
+	* include/stdbool.h: Can now be disabled for C++ files if CONFIG_C99_BOOL8 is
+	  defined.  CONFIG_C99_BOOL8 indicates (1) that the sizeof(_Bool) is one in both
+	  C and C++, and (2) the the C compiler is C99 and supports the _Bool intrinsic
+	  type. Requested by Freddie Chopin.
+	* include/stdlib/lib_rand.c:  Various additional changes so that the integer
+	  value zero can be returned.  Requested by Freddie Chopin.
diff --git a/nuttx/arch/8051/include/limits.h b/nuttx/arch/8051/include/limits.h
index f3021f6cc..fd8c086aa 100644
--- a/nuttx/arch/8051/include/limits.h
+++ b/nuttx/arch/8051/include/limits.h
@@ -45,7 +45,7 @@
  ************************************************************/
 
 #define CHAR_BIT    8
-#define SCHAR_MIN   (-128)
+#define SCHAR_MIN   (-SCHAR_MAX - 1)
 #define SCHAR_MAX   127
 #define UCHAR_MAX   255
 
@@ -59,17 +59,17 @@
 #define CHAR_MAX    SCHAR_MAX
 #endif
 
-#define SHRT_MIN    (-32768)
+#define SHRT_MIN    (-SHRT_MAX - 1)
 #define SHRT_MAX    32767
-#define USHRT_MAX   65535
+#define USHRT_MAX   65535U
 
-#define INT_MIN     (-32768)
+#define INT_MIN     (-INT_MAX - 1)
 #define INT_MAX     32767
-#define UINT_MAX    65535
+#define UINT_MAX    65535U
 
 /* These change on 32-bit and 64-bit platforms */
 
-#define LONG_MIN    (-2147483648L)
+#define LONG_MIN    (-LONG_MAX - 1)
 #define LONG_MAX    2147483647L
 #define ULONG_MAX   4294967295UL
 
@@ -77,8 +77,8 @@
  * first byte holding data space information.
  */
 
-#define PTR_MIN     (-8388608)
+#define PTR_MIN     (-PTR_MAX - 1)
 #define PTR_MAX     8388607
-#define UPTR_MAX    16777215
+#define UPTR_MAX    16777215U
 
 #endif /* __ARCH_8051_INCLUDE_LIMITS_H  */
diff --git a/nuttx/arch/arm/include/limits.h b/nuttx/arch/arm/include/limits.h
index 12c92f6cf..640db7e7b 100644
--- a/nuttx/arch/arm/include/limits.h
+++ b/nuttx/arch/arm/include/limits.h
@@ -45,7 +45,7 @@
  ****************************************************************************/
 
 #define CHAR_BIT    8
-#define SCHAR_MIN  (-128)
+#define SCHAR_MIN  (-SCHAR_MAX - 1)
 #define SCHAR_MAX   127
 #define UCHAR_MAX   255
 
@@ -59,28 +59,28 @@
 #define CHAR_MAX    SCHAR_MAX
 #endif
 
-#define SHRT_MIN    (-32768)
+#define SHRT_MIN    (-SHRT_MAX - 1)
 #define SHRT_MAX    32767
-#define USHRT_MAX   65535
+#define USHRT_MAX   65535U
 
-#define INT_MIN     (-2147483648)
+#define INT_MIN     (-INT_MAX - 1)
 #define INT_MAX     2147483647
-#define UINT_MAX    4294967295
+#define UINT_MAX    4294967295U
 
 /* These change on 32-bit and 64-bit platforms */
 
-#define LONG_MIN    (-2147483648L)
+#define LONG_MIN    (-LONG_MAX - 1)
 #define LONG_MAX    2147483647L
 #define ULONG_MAX   4294967295UL
 
-#define LLONG_MIN   (-9223372036854775808LL)
+#define LLONG_MIN   (-LLONG_MAX - 1)
 #define LLONG_MAX   9223372036854775807LL
 #define ULLONG_MAX  18446744073709551615ULL
 
 /* A pointer is 4 bytes */
 
-#define PTR_MIN     (-2147483648)
+#define PTR_MIN     (-PTR_MAX - 1)
 #define PTR_MAX     2147483647
-#define UPTR_MAX    4294967295
+#define UPTR_MAX    4294967295U
 
 #endif /* __ARCH_ARM_INCLUDE_LIMITS_H */
diff --git a/nuttx/arch/avr/include/avr/limits.h b/nuttx/arch/avr/include/avr/limits.h
index 67d66ce7a..db97a9a4a 100644
--- a/nuttx/arch/avr/include/avr/limits.h
+++ b/nuttx/arch/avr/include/avr/limits.h
@@ -45,7 +45,7 @@
  ****************************************************************************/
 
 #define CHAR_BIT    8
-#define SCHAR_MIN  (-128)
+#define SCHAR_MIN  (-SCHAR_MAX - 1)
 #define SCHAR_MAX   127
 #define UCHAR_MAX   255
 
@@ -59,31 +59,31 @@
 #define CHAR_MAX    SCHAR_MAX
 #endif
 
-#define SHRT_MIN    (-32768)
+#define SHRT_MIN    (-SHRT_MAX - 1)
 #define SHRT_MAX    32767
-#define USHRT_MAX   65535
+#define USHRT_MAX   65535U
 
 /* Integer is two bytes */
 
-#define INT_MIN     (-32768)
+#define INT_MIN     (-INT_MAX - 1)
 #define INT_MAX     32767
-#define UINT_MAX    65535
+#define UINT_MAX    65535U
 
 /* These change on 32-bit and 64-bit platforms */
 
-#define LONG_MIN    (-2147483648L)
+#define LONG_MIN    (-LONG_MAX - 1)
 #define LONG_MAX    2147483647L
 #define ULONG_MAX   4294967295UL
 
-#define LLONG_MIN   (-9223372036854775808LL)
+#define LLONG_MIN   (-LLONG_MAX - 1)
 #define LLONG_MAX   9223372036854775807LL
 #define ULLONG_MAX  18446744073709551615ULL
 
 /* A pointer is two bytes */
 
-#define PTR_MIN     (-32768)
+#define PTR_MIN     (-PTR_MAX - 1)
 #define PTR_MAX     32767
-#define UPTR_MAX    65535
+#define UPTR_MAX    65535U
 
 #endif /* __ARCH_AVR_INCLUDE_AVR_LIMITS_H */
 
diff --git a/nuttx/arch/avr/include/avr32/limits.h b/nuttx/arch/avr/include/avr32/limits.h
index f4fad08ff..ce3dd783d 100644
--- a/nuttx/arch/avr/include/avr32/limits.h
+++ b/nuttx/arch/avr/include/avr32/limits.h
@@ -45,7 +45,7 @@
  ****************************************************************************/
 
 #define CHAR_BIT    8
-#define SCHAR_MIN   (-128)
+#define SCHAR_MIN   (-SCHAR_MAX - 1)
 #define SCHAR_MAX   127
 #define UCHAR_MAX   255
 
@@ -59,31 +59,31 @@
 #define CHAR_MAX    SCHAR_MAX
 #endif
 
-#define SHRT_MIN    (-32768)
+#define SHRT_MIN    (-SHRT_MAX - 1)
 #define SHRT_MAX    32767
-#define USHRT_MAX   65535
+#define USHRT_MAX   65535U
 
 /* Integer is four bytes */
 
-#define INT_MIN     (-2147483648)
+#define INT_MIN     (-INT_MAX - 1)
 #define INT_MAX     2147483647
-#define UINT_MAX    4294967295
+#define UINT_MAX    4294967295U
 
 /* These change on 32-bit and 64-bit platforms */
 
-#define LONG_MIN    (-2147483648L)
+#define LONG_MIN    (-LONG_MAX - 1)
 #define LONG_MAX    2147483647L
 #define ULONG_MAX   4294967295UL
 
-#define LLONG_MIN   (-9223372036854775808LL)
+#define LLONG_MIN   (-LLONG_MAX - 1)
 #define LLONG_MAX   9223372036854775807LL
 #define ULLONG_MAX  18446744073709551615ULL
 
 /* A pointer is four bytes */
 
-#define PTR_MIN     (-2147483648)
+#define PTR_MIN     (-PTR_MAX - 1)
 #define PTR_MAX     2147483647
-#define UPTR_MAX    4294967295
+#define UPTR_MAX    4294967295U
 
 #endif /* __ARCH_AVR_INCLUDE_AVR32_LIMITS_H */
 
diff --git a/nuttx/arch/hc/include/hc12/limits.h b/nuttx/arch/hc/include/hc12/limits.h
index edb92c7e6..c35148a56 100644
--- a/nuttx/arch/hc/include/hc12/limits.h
+++ b/nuttx/arch/hc/include/hc12/limits.h
@@ -45,7 +45,7 @@
  ****************************************************************************/
 
 #define CHAR_BIT    8
-#define SCHAR_MIN   (-128)
+#define SCHAR_MIN   (-SCHAR_MAX - 1)
 #define SCHAR_MAX   127
 #define UCHAR_MAX   255
 
@@ -59,39 +59,38 @@
 #define CHAR_MAX    SCHAR_MAX
 #endif
 
-#define SHRT_MIN    (-32768)
+#define SHRT_MIN    (-SHRT_MAX - 1)
 #define SHRT_MAX    32767
-#define USHRT_MAX   65535
+#define USHRT_MAX   65535U
 
 /* The size of an integer is controlled with the -mshort or -mnoshort GCC
  * options.  GCC will set the pre-defined symbol __INT__ to indicate the size
  * of an integer
  */
 
+#define INT_MIN     (-INT_MAX - 1)
 #if __INT__ == 32
-#  define INT_MIN   (-2147483648)
 #  define INT_MAX   2147483647
 #  define UINT_MAX  4294967295
 #else
-#  define INT_MIN   (-32768)
 #  define INT_MAX   32767
-#  define UINT_MAX  65535
+#  define UINT_MAX  65535U
 #endif
 
 /* Long is 4-bytes and long long is 8 bytes in any case */
 
-#define LONG_MIN    (-2147483648L)
+#define LONG_MIN    (-LONG_MAX - 1)
 #define LONG_MAX    2147483647L
 #define ULONG_MAX   4294967295UL
 
-#define LLONG_MIN   (-9223372036854775808LL)
+#define LLONG_MIN   (-LLONG_MAX - 1)
 #define LLONG_MAX   9223372036854775807LL
 #define ULLONG_MAX  18446744073709551615ULL
 
 /* A pointer is 2 bytes */
 
-#define PTR_MIN     (-32768)
+#define PTR_MIN     (-PTR_MAX - 1)
 #define PTR_MAX     32767
-#define UPTR_MAX    65535
+#define UPTR_MAX    65535U
 
 #endif /* __ARCH_HC_INCLUDE_HC12_LIMITS_H */
diff --git a/nuttx/arch/hc/include/hcs12/limits.h b/nuttx/arch/hc/include/hcs12/limits.h
index 597626484..5b10d910f 100644
--- a/nuttx/arch/hc/include/hcs12/limits.h
+++ b/nuttx/arch/hc/include/hcs12/limits.h
@@ -45,7 +45,7 @@
  ****************************************************************************/
 
 #define CHAR_BIT    8
-#define SCHAR_MIN   (-128)
+#define SCHAR_MIN   (-SCHAR_MAX - 1)
 #define SCHAR_MAX   127
 #define UCHAR_MAX   255
 
@@ -59,39 +59,38 @@
 #define CHAR_MAX    SCHAR_MAX
 #endif
 
-#define SHRT_MIN    (-32768)
+#define SHRT_MIN    (-SHRT_MAX - 1)
 #define SHRT_MAX    32767
-#define USHRT_MAX   65535
+#define USHRT_MAX   65535U
 
 /* The size of an integer is controlled with the -mshort or -mnoshort GCC
  * options.  GCC will set the pre-defined symbol __INT__ to indicate the size
  * of an integer
  */
 
+#define INT_MIN     (-INT_MAX - 1)
 #if __INT__ == 32
-#  define INT_MIN   (-2147483648)
 #  define INT_MAX   2147483647
 #  define UINT_MAX  4294967295
 #else
-#  define INT_MIN   (-32768)
 #  define INT_MAX   32767
-#  define UINT_MAX  65535
+#  define UINT_MAX  65535U
 #endif
 
 /* Long is 4-bytes and long long is 8 bytes in any case */
 
-#define LONG_MIN    (-2147483648L)
+#define LONG_MIN    (-LONG_MAX - 1)
 #define LONG_MAX    2147483647L
 #define ULONG_MAX   4294967295UL
 
-#define LLONG_MIN   (-9223372036854775808LL)
+#define LLONG_MIN   (-LLONG_MAX - 1)
 #define LLONG_MAX   9223372036854775807LL
 #define ULLONG_MAX  18446744073709551615ULL
 
 /* A pointer is 2 bytes */
 
-#define PTR_MIN     (-32768)
+#define PTR_MIN     (-PTR_MAX - 1)
 #define PTR_MAX     32767
-#define UPTR_MAX    65535
+#define UPTR_MAX    65535U
 
 #endif /* __ARCH_HC_INCLUDE_HCS12_LIMITS_H */
diff --git a/nuttx/arch/mips/include/limits.h b/nuttx/arch/mips/include/limits.h
index 4feff7fe1..04001e55c 100644
--- a/nuttx/arch/mips/include/limits.h
+++ b/nuttx/arch/mips/include/limits.h
@@ -45,7 +45,7 @@
  ****************************************************************************/
 
 #define CHAR_BIT    8
-#define SCHAR_MIN   (-128)
+#define SCHAR_MIN   (-SCHAR_MAX - 1)
 #define SCHAR_MAX   127
 #define UCHAR_MAX   255
 
@@ -59,29 +59,29 @@
 #define CHAR_MAX    SCHAR_MAX
 #endif
 
-#define SHRT_MIN    (-32768)
+#define SHRT_MIN    (-SHRT_MAX - 1)
 #define SHRT_MAX    32767
-#define USHRT_MAX   65535
+#define USHRT_MAX   65535U
 
-#define INT_MIN     (-2147483648)
+#define INT_MIN     (-INT_MAX - 1)
 #define INT_MAX     2147483647
-#define UINT_MAX    4294967295
+#define UINT_MAX    4294967295U
 
 /* These change on 32-bit and 64-bit platforms */
 
-#define LONG_MIN    (-2147483648L)
+#define LONG_MIN    (-LONG_MAX - 1)
 #define LONG_MAX    2147483647L
 #define ULONG_MAX   4294967295UL
 
-#define LLONG_MIN   (-9223372036854775808LL)
+#define LLONG_MIN   (-LLONG_MAX - 1)
 #define LLONG_MAX   9223372036854775807LL
 #define ULLONG_MAX  18446744073709551615ULL
 
 /* A pointer is 4 bytes */
 
-#define PTR_MIN     (-2147483648)
+#define PTR_MIN     (-PTR_MAX - 1)
 #define PTR_MAX     2147483647
-#define UPTR_MAX    4294967295
+#define UPTR_MAX    4294967295U
 
 #endif /* __ARCH_MIPS_INCLUDE_LIMITS_H */
 
diff --git a/nuttx/arch/rgmp/include/limits.h b/nuttx/arch/rgmp/include/limits.h
index fdd8bfd10..a4458e301 100644
--- a/nuttx/arch/rgmp/include/limits.h
+++ b/nuttx/arch/rgmp/include/limits.h
@@ -45,7 +45,7 @@
  ************************************************************/
 
 #define CHAR_BIT    8
-#define SCHAR_MIN   (-128)
+#define SCHAR_MIN   (-SCHAR_MAX - 1)
 #define SCHAR_MAX   127
 #define UCHAR_MAX   255
 
@@ -59,28 +59,28 @@
 #define CHAR_MAX    SCHAR_MAX
 #endif
 
-#define SHRT_MIN    (-32768)
+#define SHRT_MIN    (-SHRT_MAX - 1)
 #define SHRT_MAX    32767
-#define USHRT_MAX   65535
+#define USHRT_MAX   65535U
 
-#define INT_MIN     (-2147483648)
+#define INT_MIN     (-INT_MAX - 1)
 #define INT_MAX     2147483647
-#define UINT_MAX    4294967295
+#define UINT_MAX    4294967295U
 
 /* These change on 32-bit and 64-bit platforms */
 
-#define LONG_MIN    (-2147483648L)
+#define LONG_MIN    (-LONG_MAX - 1)
 #define LONG_MAX    2147483647L
 #define ULONG_MAX   4294967295UL
 
-#define LLONG_MIN   (-9223372036854775808LL)
+#define LLONG_MIN   (-LLONG_MAX - 1)
 #define LLONG_MAX   9223372036854775807LL
 #define ULLONG_MAX  18446744073709551615ULL
 
 /* A pointer is 4 bytes */
 
-#define PTR_MIN     (-2147483648)
+#define PTR_MIN     (-PTR_MAX - 1)
 #define PTR_MAX     2147483647
-#define UPTR_MAX    4294967295
+#define UPTR_MAX    4294967295U
 
 #endif /* __ARCH_RGMP_INCLUDE_LIMITS_H  */
diff --git a/nuttx/arch/sh/include/m16c/limits.h b/nuttx/arch/sh/include/m16c/limits.h
index d836522e7..dba3e4fdc 100644
--- a/nuttx/arch/sh/include/m16c/limits.h
+++ b/nuttx/arch/sh/include/m16c/limits.h
@@ -45,7 +45,7 @@
  ****************************************************************************/
 
 #define CHAR_BIT    8
-#define SCHAR_MIN   (-128)
+#define SCHAR_MIN   (-SCHAR_MAX - 1)
 #define SCHAR_MAX   127
 #define UCHAR_MAX   255
 
@@ -59,9 +59,9 @@
 #define CHAR_MAX    SCHAR_MAX
 #endif
 
-#define SHRT_MIN    (-32768)
+#define SHRT_MIN    (-SHRT_MAX - 1)
 #define SHRT_MAX    32767
-#define USHRT_MAX   65535
+#define USHRT_MAX   65535U
 
 /* For M16C, type int is 16-bits, the same size as type 'short int' */
 
@@ -71,18 +71,18 @@
 
 /* For M16C, typle 'long int' is 32-bits */
 
-#define LONG_MIN    (-2147483648L)
+#define LONG_MIN    (-LONG_MAX - 1)
 #define LONG_MAX    2147483647L
 #define ULONG_MAX   4294967295UL
 
-#define LLONG_MIN   (-9223372036854775808LL)
+#define LLONG_MIN   (-LLONG_MAX - 1)
 #define LLONG_MAX   9223372036854775807LL
 #define ULLONG_MAX  18446744073709551615ULL
 
 /* A pointer is 2 bytes */
 
-#define PTR_MIN     (-32768)
+#define PTR_MIN     (-PTR_MAX - 1)
 #define PTR_MAX     32767
-#define UPTR_MAX    65535
+#define UPTR_MAX    65535U
 
 #endif /* __ARCH_SH_INCLUDE_M16C_LIMITS_H */
diff --git a/nuttx/arch/sh/include/sh1/limits.h b/nuttx/arch/sh/include/sh1/limits.h
index ce9085bfb..33c8ebcd3 100644
--- a/nuttx/arch/sh/include/sh1/limits.h
+++ b/nuttx/arch/sh/include/sh1/limits.h
@@ -45,7 +45,7 @@
  ****************************************************************************/
 
 #define CHAR_BIT    8
-#define SCHAR_MIN   (-128)
+#define SCHAR_MIN   (-SCHAR_MAX - 1)
 #define SCHAR_MAX   127
 #define UCHAR_MAX   255
 
@@ -59,30 +59,30 @@
 #define CHAR_MAX    SCHAR_MAX
 #endif
 
-#define SHRT_MIN    (-32768)
+#define SHRT_MIN    (-SHRT_MAX - 1)
 #define SHRT_MAX    32767
-#define USHRT_MAX   65535
+#define USHRT_MAX   65535U
 
 /* On SH-1, type 'int' is 32-bits */
 
-#define INT_MIN     (-2147483648)
+#define INT_MIN     (-INT_MAX - 1)
 #define INT_MAX     2147483647
-#define UINT_MAX    4294967295
+#define UINT_MAX    4294967295U
 
 /* On SH-1, type 'long' is the same size as type 'int', 32-bits */
 
-#define LONG_MIN    (-2147483648L)
+#define LONG_MIN    (-LONG_MAX - 1)
 #define LONG_MAX    2147483647L
 #define ULONG_MAX   4294967295UL
 
-#define LLONG_MIN   (-9223372036854775808LL)
+#define LLONG_MIN   (-LLONG_MAX - 1)
 #define LLONG_MAX   9223372036854775807LL
 #define ULLONG_MAX  18446744073709551615ULL
 
 /* A pointer is 4 bytes */
 
-#define PTR_MIN     (-2147483648)
+#define PTR_MIN     (-PTR_MAX - 1)
 #define PTR_MAX     2147483647
-#define UPTR_MAX    4294967295
+#define UPTR_MAX    4294967295U
 
 #endif /* __ARCH_SH_INCLUDE_SH1_LIMITS_H */
diff --git a/nuttx/arch/sim/include/limits.h b/nuttx/arch/sim/include/limits.h
index 9aa36b1d0..9288cb585 100644
--- a/nuttx/arch/sim/include/limits.h
+++ b/nuttx/arch/sim/include/limits.h
@@ -45,7 +45,7 @@
  ************************************************************/
 
 #define CHAR_BIT    8
-#define SCHAR_MIN   (-128)
+#define SCHAR_MIN   (-SCHAR_MAX - 1)
 #define SCHAR_MAX   127
 #define UCHAR_MAX   255
 
@@ -59,28 +59,28 @@
 #define CHAR_MAX    SCHAR_MAX
 #endif
 
-#define SHRT_MIN    (-32768)
+#define SHRT_MIN    (-SHRT_MAX - 1)
 #define SHRT_MAX    32767
-#define USHRT_MAX   65535
+#define USHRT_MAX   65535U
 
-#define INT_MIN     (-2147483648)
+#define INT_MIN     (-INT_MAX - 1)
 #define INT_MAX     2147483647
-#define UINT_MAX    4294967295
+#define UINT_MAX    4294967295U
 
 /* These change on 32-bit and 64-bit platforms */
 
-#define LONG_MIN    (-2147483648L)
+#define LONG_MIN    (-LONG_MAX - 1)
 #define LONG_MAX    2147483647L
 #define ULONG_MAX   4294967295UL
 
-#define LLONG_MIN   (-9223372036854775808LL)
+#define LLONG_MIN   (-LLONG_MAX - 1)
 #define LLONG_MAX   9223372036854775807LL
 #define ULLONG_MAX  18446744073709551615ULL
 
 /* A pointer is 4 bytes */
 
-#define PTR_MIN     (-2147483648)
+#define PTR_MIN     (-PTR_MAX - 1)
 #define PTR_MAX     2147483647
-#define UPTR_MAX    4294967295
+#define UPTR_MAX    4294967295U
 
 #endif /* __ARCH_SIM_INCLUDE_LIMITS_H  */
diff --git a/nuttx/arch/x86/include/i486/limits.h b/nuttx/arch/x86/include/i486/limits.h
index c2a9a620f..aa167a0af 100644
--- a/nuttx/arch/x86/include/i486/limits.h
+++ b/nuttx/arch/x86/include/i486/limits.h
@@ -45,7 +45,7 @@
  ****************************************************************************/
 
 #define CHAR_BIT    8
-#define SCHAR_MIN   (-128)
+#define SCHAR_MIN   (-SCHAR_MAX - 1)
 #define SCHAR_MAX   127
 #define UCHAR_MAX   255
 
@@ -59,28 +59,28 @@
 #define CHAR_MAX    SCHAR_MAX
 #endif
 
-#define SHRT_MIN    (-32768)
+#define SHRT_MIN    (-SHRT_MAX - 1)
 #define SHRT_MAX    32767
-#define USHRT_MAX   65535
+#define USHRT_MAX   65535U
 
-#define INT_MIN     (-2147483648)
+#define INT_MIN     (-INT_MAX - 1)
 #define INT_MAX     2147483647
-#define UINT_MAX    4294967295
+#define UINT_MAX    4294967295U
 
 /* These change on 32-bit and 64-bit platforms */
 
-#define LONG_MIN    (-2147483648L)
+#define LONG_MIN    (-LONG_MAX - 1)
 #define LONG_MAX    2147483647L
 #define ULONG_MAX   4294967295UL
 
-#define LLONG_MIN   (-9223372036854775808LL)
+#define LLONG_MIN   (-LLONG_MAX - 1)
 #define LLONG_MAX   9223372036854775807LL
 #define ULLONG_MAX  18446744073709551615ULL
 
 /* A pointer is 4 bytes */
 
-#define PTR_MIN     (-2147483648)
+#define PTR_MIN     (-PTR_MAX - 1)
 #define PTR_MAX     2147483647
-#define UPTR_MAX    4294967295
+#define UPTR_MAX    4294967295U
 
 #endif /* __ARCH_X86_INCLUDE_I486_LIMITS_H  */
diff --git a/nuttx/arch/z16/include/limits.h b/nuttx/arch/z16/include/limits.h
index 55ee7a2c5..6601c4737 100644
--- a/nuttx/arch/z16/include/limits.h
+++ b/nuttx/arch/z16/include/limits.h
@@ -45,7 +45,7 @@
  ****************************************************************************/
 
 #define CHAR_BIT    8
-#define SCHAR_MIN   (-128)
+#define SCHAR_MIN   (-SCHAR_MAX - 1)
 #define SCHAR_MAX   127
 #define UCHAR_MAX   255
 
@@ -59,26 +59,26 @@
 #define CHAR_MAX    SCHAR_MAX
 #endif
 
-#define SHRT_MIN    (-32768)
+#define SHRT_MIN    (-SHRT_MAX - 1)
 #define SHRT_MAX    32767
-#define USHRT_MAX   65535
+#define USHRT_MAX   65535U
 
-#define INT_MIN     (-2147483648)
+#define INT_MIN     (-INT_MAX - 1)
 #define INT_MAX     2147483647
-#define UINT_MAX    4294967295
+#define UINT_MAX    4294967295U
 
-#define LONG_MIN    (-2147483648L)
+#define LONG_MIN    (-LONG_MAX - 1)
 #define LONG_MAX    2147483647L
 #define ULONG_MAX   4294967295UL
 
-#define LLONG_MIN   (-2147483648L)
-#define LLONG_MAX   2147483647L
-#define ULLONG_MAX  4294967295UL
+#define LLONG_MIN   (-LLONG_MAX - 1)
+#define LLONG_MAX   2147483647LL
+#define ULLONG_MAX  4294967295ULL
 
 /* A pointer is 4 bytes */
 
-#define PTR_MIN     (-2147483648)
+#define PTR_MIN     (-PTR_MAX - 1)
 #define PTR_MAX     2147483647
-#define UPTR_MAX    4294967295
+#define UPTR_MAX    4294967295U
 
 #endif /* __ARCH_Z16_INCLUDE_LIMITS_H  */
diff --git a/nuttx/arch/z80/include/ez80/limits.h b/nuttx/arch/z80/include/ez80/limits.h
index 1dfa2afee..9e27b14e6 100644
--- a/nuttx/arch/z80/include/ez80/limits.h
+++ b/nuttx/arch/z80/include/ez80/limits.h
@@ -45,7 +45,7 @@
  ****************************************************************************/
 
 #define CHAR_BIT    8
-#define SCHAR_MIN   (-128)
+#define SCHAR_MIN   (-SCHAR_MAX - 1)
 #define SCHAR_MAX   127
 #define UCHAR_MAX   255
 
@@ -59,17 +59,17 @@
 #define CHAR_MAX    SCHAR_MAX
 #endif
 
-#define SHRT_MIN    (-32768)
+#define SHRT_MIN    (-SHRT_MAX - 1)
 #define SHRT_MAX    32767
-#define USHRT_MAX   65535
+#define USHRT_MAX   65535U
 
-#define INT_MIN     (-32768)
+#define INT_MIN     (-INT_MAX - 1)
 #define INT_MAX     32767
-#define UINT_MAX    65535
+#define UINT_MAX    65535U
 
 /* These change on 32-bit and 64-bit platforms */
 
-#define LONG_MIN    (-2147483648L)
+#define LONG_MIN    (-LONG_MAX - 1)
 #define LONG_MAX    2147483647L
 #define ULONG_MAX   4294967295UL
 
@@ -80,14 +80,13 @@
  *   ADL mode - 24 bits
  */
 
+#define PTR_MIN     (-PTR_MAX - 1)
 #ifdef CONFIG_EZ80_Z80MODE
-#define PTR_MIN     (-32768)
 #define PTR_MAX     32767
-#define UPTR_MAX    65535
+#define UPTR_MAX    65535U
 #else
-#define PTR_MIN     (-8388608)
 #define PTR_MAX     8388607
-#define UPTR_MAX    16777215
+#define UPTR_MAX    16777215U
 #endif
 
 #endif /* __ARCH_Z80_INCLUDE_EZ80_LIMITS_H */
diff --git a/nuttx/arch/z80/include/z8/limits.h b/nuttx/arch/z80/include/z8/limits.h
index 94614ee25..724d8c98d 100644
--- a/nuttx/arch/z80/include/z8/limits.h
+++ b/nuttx/arch/z80/include/z8/limits.h
@@ -45,7 +45,7 @@
  ****************************************************************************/
 
 #define CHAR_BIT    8
-#define SCHAR_MIN   (-128)
+#define SCHAR_MIN   (-SCHAR_MAX - 1)
 #define SCHAR_MAX   127
 #define UCHAR_MAX   255
 
@@ -59,24 +59,24 @@
 #define CHAR_MAX    SCHAR_MAX
 #endif
 
-#define SHRT_MIN    (-32768)
+#define SHRT_MIN    (-SHRT_MAX - 1)
 #define SHRT_MAX    32767
-#define USHRT_MAX   65535
+#define USHRT_MAX   65535U
 
-#define INT_MIN     (-32768)
+#define INT_MIN     (-INT_MAX - 1)
 #define INT_MAX     32767
-#define UINT_MAX    65535
+#define UINT_MAX    65535U
 
 /* These change on 32-bit and 64-bit platforms */
 
-#define LONG_MIN    (-2147483648L)
+#define LONG_MIN    (-LONG_MAX - 1)
 #define LONG_MAX    2147483647L
 #define ULONG_MAX   4294967295UL
 
 /* A pointer is 2 bytes */
 
-#define PTR_MIN     (-32768)
+#define PTR_MIN     (-PTR_MAX - 1)
 #define PTR_MAX     32767
-#define UPTR_MAX    65535
+#define UPTR_MAX    65535U
 
 #endif /* __ARCH_Z80_INCLUDE_Z8_LIMITS_H  */
diff --git a/nuttx/arch/z80/include/z80/limits.h b/nuttx/arch/z80/include/z80/limits.h
index ff5770442..f1a1c1e17 100644
--- a/nuttx/arch/z80/include/z80/limits.h
+++ b/nuttx/arch/z80/include/z80/limits.h
@@ -45,7 +45,7 @@
  ****************************************************************************/
 
 #define CHAR_BIT    8
-#define SCHAR_MIN   (-128)
+#define SCHAR_MIN   (-SCHAR_MAX - 1)
 #define SCHAR_MAX   127
 #define UCHAR_MAX   255
 
@@ -59,24 +59,24 @@
 #define CHAR_MAX    SCHAR_MAX
 #endif
 
-#define SHRT_MIN    (-32768)
+#define SHRT_MIN    (-SHRT_MAX - 1)
 #define SHRT_MAX    32767
-#define USHRT_MAX   65535
+#define USHRT_MAX   65535U
 
-#define INT_MIN     (-32768)
+#define INT_MIN     (-INT_MAX - 1)
 #define INT_MAX     32767
-#define UINT_MAX    65535
+#define UINT_MAX    65535U
 
 /* These change on 32-bit and 64-bit platforms */
 
-#define LONG_MIN    (-2147483648L)
+#define LONG_MIN    (-LONG_MAX - 1)
 #define LONG_MAX    2147483647L
 #define ULONG_MAX   4294967295UL
 
 /* A pointer is 2 bytes */
 
-#define PTR_MIN     (-32768)
+#define PTR_MIN     (-PTR_MAX - 1)
 #define PTR_MAX     32767
-#define UPTR_MAX    65535
+#define UPTR_MAX    65535U
 
 #endif /* __ARCH_Z80_INCLUDE_Z80_LIMITS_H  */
diff --git a/nuttx/drivers/mtd/Make.defs b/nuttx/drivers/mtd/Make.defs
index 258e77ec9..7db7592d4 100644
--- a/nuttx/drivers/mtd/Make.defs
+++ b/nuttx/drivers/mtd/Make.defs
@@ -51,6 +51,10 @@ ifeq ($(CONFIG_MTD_W25),y)
 CSRCS += w25.c
 endif
 
+ifeq ($(CONFIG_MTD_AT25),y)
+CSRCS += at25.c
+endif
+
 # Include MTD driver support
 
 DEPPATH += --dep-path mtd
diff --git a/nuttx/drivers/mtd/at25.c b/nuttx/drivers/mtd/at25.c
new file mode 100644
index 000000000..e35b794a5
--- /dev/null
+++ b/nuttx/drivers/mtd/at25.c
@@ -0,0 +1,708 @@
+/************************************************************************************
+ * drivers/mtd/at25.c
+ * Driver for SPI-based AT25DF321 (32Mbit) flash.
+ *
+ *   Copyright (C) 2009-2012 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
+ *           Petteri Aimonen <jpa@nx.mail.kapsi.fi>
+ *
+ * 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 <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
+ ************************************************************************************/
+
+#ifndef CONFIG_AT25_SPIMODE
+#  define CONFIG_AT25_SPIMODE SPIDEV_MODE0
+#endif
+
+/* AT25 Registers *******************************************************************/
+/* Indentification register values */
+
+#define AT25_MANUFACTURER         0x1F
+#define AT25_AT25DF321_TYPE       0x47 /* 32 M-bit */
+
+/*  AT25DF321 capacity is 4,194,304 bytes:
+ *  (64 sectors) * (65,536 bytes per sector)
+ *  (16384 pages) * (256 bytes per page)
+ */
+
+#define AT25_AT25DF321_SECTOR_SHIFT  12    /* Sector size 1 << 12 = 4096 */
+#define AT25_AT25DF321_NSECTORS      1024
+#define AT25_AT25DF321_PAGE_SHIFT    9     /* Page size 1 << 9 = 512 */
+#define AT25_AT25DF321_NPAGES        8192
+
+/* Instructions */
+/*      Command        Value      N Description             Addr Dummy Data */
+#define AT25_WREN      0x06    /* 1 Write Enable              0   0     0 */
+#define AT25_WRDI      0x04    /* 1 Write Disable             0   0     0 */
+#define AT25_RDID      0x9f    /* 1 Read Identification       0   0     1-3 */
+#define AT25_RDSR      0x05    /* 1 Read Status Register      0   0     >=1 */
+#define AT25_WRSR      0x01    /* 1 Write Status Register     0   0     1 */
+#define AT25_READ      0x03    /* 1 Read Data Bytes           3   0     >=1 */
+#define AT25_FAST_READ 0x0b    /* 1 Higher speed read         3   1     >=1 */
+#define AT25_PP        0x02    /* 1 Page Program              3   0     1-256 */
+#define AT25_SE        0x20    /* 1 Sector Erase              3   0     0 */
+#define AT25_BE        0xc7    /* 1 Bulk Erase                0   0     0 */
+#define AT25_DP        0xb9    /* 2 Deep power down           0   0     0 */
+#define AT25_RES       0xab    /* 2 Read Electronic Signature 0   3     >=1 */
+
+/* Status register bit definitions */
+
+#define AT25_SR_WIP            (1 << 0)    /* Bit 0: Write in progress bit */
+#define AT25_SR_WEL            (1 << 1)    /* Bit 1: Write enable latch bit */
+#define AT25_SR_EPE            (1 << 5)    /* Bit 5: Erase/program error */
+#define AT25_SR_UNPROT         0x00        /* Global unprotect command */
+
+#define AT25_DUMMY     0xa5
+
+/************************************************************************************
+ * 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 at25_dev_s.
+ */
+
+struct at25_dev_s
+{
+  struct mtd_dev_s mtd;      /* MTD interface */
+  FAR struct spi_dev_s *dev; /* Saved SPI interface instance */
+  uint8_t  sectorshift;      /* 16 or 18 */
+  uint8_t  pageshift;        /* 8 */
+  uint16_t nsectors;         /* 128 or 64 */
+  uint32_t npages;           /* 32,768 or 65,536 */
+};
+
+/************************************************************************************
+ * Private Function Prototypes
+ ************************************************************************************/
+
+/* Helpers */
+
+static void at25_lock(FAR struct spi_dev_s *dev);
+static inline void at25_unlock(FAR struct spi_dev_s *dev);
+static inline int at25_readid(struct at25_dev_s *priv);
+static void at25_waitwritecomplete(struct at25_dev_s *priv);
+static void at25_writeenable(struct at25_dev_s *priv);
+static inline void at25_sectorerase(struct at25_dev_s *priv, off_t offset);
+static inline int  at25_bulkerase(struct at25_dev_s *priv);
+static inline void at25_pagewrite(struct at25_dev_s *priv, FAR const uint8_t *buffer,
+                                  off_t offset);
+
+/* MTD driver methods */
+
+static int at25_erase(FAR struct mtd_dev_s *dev, off_t startblock, size_t nblocks);
+static ssize_t at25_bread(FAR struct mtd_dev_s *dev, off_t startblock,
+                          size_t nblocks, FAR uint8_t *buf);
+static ssize_t at25_bwrite(FAR struct mtd_dev_s *dev, off_t startblock,
+                           size_t nblocks, FAR const uint8_t *buf);
+static ssize_t at25_read(FAR struct mtd_dev_s *dev, off_t offset, size_t nbytes,
+                         FAR uint8_t *buffer);
+static int at25_ioctl(FAR struct mtd_dev_s *dev, int cmd, unsigned long arg);
+
+/************************************************************************************
+ * Private Data
+ ************************************************************************************/
+
+/************************************************************************************
+ * Private Functions
+ ************************************************************************************/
+
+/************************************************************************************
+ * Name: at25_lock
+ ************************************************************************************/
+
+static void at25_lock(FAR struct spi_dev_s *dev)
+{
+  /* 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(dev, 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(dev, CONFIG_AT25_SPIMODE);
+  SPI_SETBITS(dev, 8);
+  (void)SPI_SETFREQUENCY(dev, 20000000);
+}
+
+/************************************************************************************
+ * Name: at25_unlock
+ ************************************************************************************/
+
+static inline void at25_unlock(FAR struct spi_dev_s *dev)
+{
+  (void)SPI_LOCK(dev, false);
+}
+
+/************************************************************************************
+ * Name: at25_readid
+ ************************************************************************************/
+
+static inline int at25_readid(struct at25_dev_s *priv)
+{
+  uint16_t manufacturer;
+  uint16_t memory;
+  uint16_t version;
+
+  fvdbg("priv: %p\n", priv);
+
+  /* Lock the SPI bus, configure the bus, and select this FLASH part. */
+
+  at25_lock(priv->dev);
+  SPI_SELECT(priv->dev, SPIDEV_FLASH, true);
+
+  /* Send the "Read ID (RDID)" command and read the first three ID bytes */
+
+  (void)SPI_SEND(priv->dev, AT25_RDID);
+  manufacturer = SPI_SEND(priv->dev, AT25_DUMMY);
+  memory       = SPI_SEND(priv->dev, AT25_DUMMY);
+  
+  /* Deselect the FLASH and unlock the bus */
+
+  SPI_SELECT(priv->dev, SPIDEV_FLASH, false);
+  at25_unlock(priv->dev);
+
+  fvdbg("manufacturer: %02x memory: %02x\n",
+        manufacturer, memory);
+
+  /* Check for a valid manufacturer and memory type */
+
+  if (manufacturer == AT25_MANUFACTURER && memory == AT25_AT25DF321_TYPE)
+    {
+        priv->sectorshift = AT25_AT25DF321_SECTOR_SHIFT;
+        priv->nsectors    = AT25_AT25DF321_NSECTORS;
+        priv->pageshift   = AT25_AT25DF321_PAGE_SHIFT;
+        priv->npages      = AT25_AT25DF321_NPAGES;
+        return OK;
+    }
+
+  return -ENODEV;
+}
+
+/************************************************************************************
+ * Name: at25_waitwritecomplete
+ ************************************************************************************/
+
+static void at25_waitwritecomplete(struct at25_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->dev, SPIDEV_FLASH, true);
+
+  /* Send "Read Status Register (RDSR)" command */
+
+  (void)SPI_SEND(priv->dev, AT25_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->dev, AT25_DUMMY);
+    }
+  while ((status & AT25_SR_WIP) != 0);
+
+  /* Deselect the FLASH */
+
+  SPI_SELECT(priv->dev, SPIDEV_FLASH, false);
+
+#else
+
+  /* Loop as long as the memory is busy with a write cycle */
+
+  do
+    {
+      /* Select this FLASH part */
+
+      SPI_SELECT(priv->dev, SPIDEV_FLASH, true);
+
+      /* Send "Read Status Register (RDSR)" command */
+
+      (void)SPI_SEND(priv->dev, AT25_RDSR);
+
+      /* Send a dummy byte to generate the clock needed to shift out the status */
+
+      status = SPI_SEND(priv->dev, AT25_DUMMY);
+
+      /* Deselect the FLASH */
+
+      SPI_SELECT(priv->dev, 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 ((status & AT25_SR_WIP) != 0)
+        {
+          at25_unlock(priv->dev);
+          usleep(10000);
+          at25_lock(priv->dev);
+        }
+    }
+  while ((status & AT25_SR_WIP) != 0);
+#endif
+
+  if (status & AT25_SR_EPE)
+    {
+      fdbg("Write error, status: 0x%02x\n", status);
+    }
+  
+  fvdbg("Complete, status: 0x%02x\n", status);
+}
+
+/************************************************************************************
+ * Name:  at25_writeenable
+ ************************************************************************************/
+
+static void at25_writeenable(struct at25_dev_s *priv)
+{
+  SPI_SELECT(priv->dev, SPIDEV_FLASH, true);
+  (void)SPI_SEND(priv->dev, AT25_WREN);
+  SPI_SELECT(priv->dev, SPIDEV_FLASH, false);
+  fvdbg("Enabled\n");
+}
+
+/************************************************************************************
+ * Name:  at25_sectorerase
+ ************************************************************************************/
+
+static inline void at25_sectorerase(struct at25_dev_s *priv, off_t sector)
+{
+  off_t offset = sector << priv->sectorshift;
+
+  fvdbg("sector: %08lx\n", (long)sector);
+
+  /* Wait for any preceding write to complete.  We could simplify things by
+   * perform this wait at the end of each write operation (rather than at
+   * the beginning of ALL operations), but have the wait first will slightly
+   * improve performance.
+   */
+
+  at25_waitwritecomplete(priv);
+
+  /* Send write enable instruction */
+
+  at25_writeenable(priv);
+
+  /* Select this FLASH part */
+
+  SPI_SELECT(priv->dev, SPIDEV_FLASH, true);
+
+  /* Send the "Sector Erase (SE)" instruction */
+
+  (void)SPI_SEND(priv->dev, AT25_SE);
+
+  /* Send the sector offset high byte first.  For all of the supported
+   * parts, the sector number is completely contained in the first byte
+   * and the values used in the following two bytes don't really matter.
+   */
+
+  (void)SPI_SEND(priv->dev, (offset >> 16) & 0xff);
+  (void)SPI_SEND(priv->dev, (offset >> 8) & 0xff);
+  (void)SPI_SEND(priv->dev, offset & 0xff);
+
+  /* Deselect the FLASH */
+
+  SPI_SELECT(priv->dev, SPIDEV_FLASH, false);
+  fvdbg("Erased\n");
+}
+
+/************************************************************************************
+ * Name:  at25_bulkerase
+ ************************************************************************************/
+
+static inline int at25_bulkerase(struct at25_dev_s *priv)
+{
+  fvdbg("priv: %p\n", priv);
+
+  /* Wait for any preceding write to complete.  We could simplify things by
+   * perform this wait at the end of each write operation (rather than at
+   * the beginning of ALL operations), but have the wait first will slightly
+   * improve performance.
+   */
+
+  at25_waitwritecomplete(priv);
+
+  /* Send write enable instruction */
+
+  at25_writeenable(priv);
+
+  /* Select this FLASH part */
+
+  SPI_SELECT(priv->dev, SPIDEV_FLASH, true);
+
+  /* Send the "Bulk Erase (BE)" instruction */
+
+  (void)SPI_SEND(priv->dev, AT25_BE);
+
+  /* Deselect the FLASH */
+
+  SPI_SELECT(priv->dev, SPIDEV_FLASH, false);
+  fvdbg("Return: OK\n");
+  return OK;
+}
+
+/************************************************************************************
+ * Name:  at25_pagewrite
+ ************************************************************************************/
+
+static inline void at25_pagewrite(struct at25_dev_s *priv, FAR const uint8_t *buffer,
+                                  off_t page)
+{
+  off_t offset = page << 8;
+
+  fvdbg("page: %08lx offset: %08lx\n", (long)page, (long)offset);
+
+  /* Wait for any preceding write to complete.  We could simplify things by
+   * perform this wait at the end of each write operation (rather than at
+   * the beginning of ALL operations), but have the wait first will slightly
+   * improve performance.
+   */
+
+  at25_waitwritecomplete(priv);
+
+  /* Enable the write access to the FLASH */
+
+  at25_writeenable(priv);
+  
+  /* Select this FLASH part */
+
+  SPI_SELECT(priv->dev, SPIDEV_FLASH, true);
+
+  /* Send "Page Program (PP)" command */
+
+  (void)SPI_SEND(priv->dev, AT25_PP);
+
+  /* Send the page offset high byte first. */
+
+  (void)SPI_SEND(priv->dev, (offset >> 16) & 0xff);
+  (void)SPI_SEND(priv->dev, (offset >> 8) & 0xff);
+  (void)SPI_SEND(priv->dev, offset & 0xff);
+
+  /* Then write the specified number of bytes */
+
+  SPI_SNDBLOCK(priv->dev, buffer, 256);
+  
+  /* Deselect the FLASH: Chip Select high */
+
+  SPI_SELECT(priv->dev, SPIDEV_FLASH, false);
+  fvdbg("Written\n");
+}
+
+/************************************************************************************
+ * Name: at25_erase
+ ************************************************************************************/
+
+static int at25_erase(FAR struct mtd_dev_s *dev, off_t startblock, size_t nblocks)
+{
+  FAR struct at25_dev_s *priv = (FAR struct at25_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 */
+
+  at25_lock(priv->dev);
+  while (blocksleft-- > 0)
+    {
+      /* Erase each sector */
+
+      at25_sectorerase(priv, startblock);
+      startblock++;
+    }
+
+  at25_unlock(priv->dev);
+  return (int)nblocks;
+}
+
+/************************************************************************************
+ * Name: at25_bread
+ ************************************************************************************/
+
+static ssize_t at25_bread(FAR struct mtd_dev_s *dev, off_t startblock, size_t nblocks,
+                          FAR uint8_t *buffer)
+{
+  FAR struct at25_dev_s *priv = (FAR struct at25_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 = at25_read(dev, startblock << priv->pageshift, nblocks << priv->pageshift, buffer);
+  if (nbytes > 0)
+    {
+        return nbytes >> priv->pageshift;
+    }
+
+  return (int)nbytes;
+}
+
+/************************************************************************************
+ * Name: at25_bwrite
+ ************************************************************************************/
+
+static ssize_t at25_bwrite(FAR struct mtd_dev_s *dev, off_t startblock, size_t nblocks,
+                           FAR const uint8_t *buffer)
+{
+  FAR struct at25_dev_s *priv = (FAR struct at25_dev_s *)dev;
+  size_t blocksleft = nblocks;
+
+  fvdbg("startblock: %08lx nblocks: %d\n", (long)startblock, (int)nblocks);
+
+  /* Lock the SPI bus and write each page to FLASH */
+
+  at25_lock(priv->dev);
+  while (blocksleft-- > 0)
+    {
+      at25_pagewrite(priv, buffer, startblock * 2);
+      at25_pagewrite(priv, buffer + 256, startblock * 2 + 1);
+      buffer += 1 << priv->pageshift;
+      startblock++;
+   }
+
+  at25_unlock(priv->dev);
+  return nblocks;
+}
+
+/************************************************************************************
+ * Name: at25_read
+ ************************************************************************************/
+
+static ssize_t at25_read(FAR struct mtd_dev_s *dev, off_t offset, size_t nbytes,
+                         FAR uint8_t *buffer)
+{
+  FAR struct at25_dev_s *priv = (FAR struct at25_dev_s *)dev;
+
+  fvdbg("offset: %08lx nbytes: %d\n", (long)offset, (int)nbytes);
+
+  /* Wait for any preceding write to complete.  We could simplify things by
+   * perform this wait at the end of each write operation (rather than at
+   * the beginning of ALL operations), but have the wait first will slightly
+   * improve performance.
+   */
+
+  at25_waitwritecomplete(priv);
+
+  /* Lock the SPI bus and select this FLASH part */
+
+  at25_lock(priv->dev);
+  SPI_SELECT(priv->dev, SPIDEV_FLASH, true);
+
+  /* Send "Read from Memory " instruction */
+
+  (void)SPI_SEND(priv->dev, AT25_READ);
+
+  /* Send the page offset high byte first. */
+
+  (void)SPI_SEND(priv->dev, (offset >> 16) & 0xff);
+  (void)SPI_SEND(priv->dev, (offset >> 8) & 0xff);
+  (void)SPI_SEND(priv->dev, offset & 0xff);
+
+  /* Then read all of the requested bytes */
+
+  SPI_RECVBLOCK(priv->dev, buffer, nbytes);
+
+  /* Deselect the FLASH and unlock the SPI bus */
+
+  SPI_SELECT(priv->dev, SPIDEV_FLASH, false);
+  at25_unlock(priv->dev);
+
+  fvdbg("return nbytes: %d\n", (int)nbytes);
+  return nbytes;
+}
+
+/************************************************************************************
+ * Name: at25_ioctl
+ ************************************************************************************/
+
+static int at25_ioctl(FAR struct mtd_dev_s *dev, int cmd, unsigned long arg)
+{
+  FAR struct at25_dev_s *priv = (FAR struct at25_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.
+               */
+
+              geo->blocksize    = (1 << priv->pageshift);
+              geo->erasesize    = (1 << priv->sectorshift);
+              geo->neraseblocks = priv->nsectors;
+              ret               = OK;
+
+              fvdbg("blocksize: %d erasesize: %d neraseblocks: %d\n",
+                    geo->blocksize, geo->erasesize, geo->neraseblocks);
+            }
+        }
+        break;
+
+      case MTDIOC_BULKERASE:
+        {
+            /* Erase the entire device */
+
+            at25_lock(priv->dev);
+            ret = at25_bulkerase(priv);
+            at25_unlock(priv->dev);
+        }
+        break;
+ 
+      case MTDIOC_XIPBASE:
+      default:
+        ret = -ENOTTY; /* Bad command */
+        break;
+    }
+
+  fvdbg("return %d\n", ret);
+  return ret;
+}
+
+/************************************************************************************
+ * Public Functions
+ ************************************************************************************/
+
+/************************************************************************************
+ * Name: at25_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 *at25_initialize(FAR struct spi_dev_s *dev)
+{
+  FAR struct at25_dev_s *priv;
+  int ret;
+
+  fvdbg("dev: %p\n", dev);
+
+  /* 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 at25_dev_s *)kmalloc(sizeof(struct at25_dev_s));
+  if (priv)
+    {
+      /* Initialize the allocated structure */
+
+      priv->mtd.erase  = at25_erase;
+      priv->mtd.bread  = at25_bread;
+      priv->mtd.bwrite = at25_bwrite;
+      priv->mtd.read   = at25_read;
+      priv->mtd.ioctl  = at25_ioctl;
+      priv->dev        = dev;
+
+      /* Deselect the FLASH */
+
+      SPI_SELECT(dev, SPIDEV_FLASH, false);
+
+      /* Identify the FLASH chip and get its capacity */
+
+      ret = at25_readid(priv);
+      if (ret != OK)
+        {
+          /* Unrecognized! Discard all of that work we just did and return NULL */
+
+          fdbg("Unrecognized\n");
+          kfree(priv);
+          priv = NULL;
+        }
+        
+      /* Unprotect all sectors */
+
+      at25_writeenable(priv);
+      SPI_SELECT(priv->dev, SPIDEV_FLASH, true);
+      (void)SPI_SEND(priv->dev, AT25_WRSR);
+      (void)SPI_SEND(priv->dev, AT25_SR_UNPROT);
+      SPI_SELECT(priv->dev, SPIDEV_FLASH, false);
+    }
+
+  /* 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/drivers/mtd/ftl.c b/nuttx/drivers/mtd/ftl.c
index cdb35aa5c..6cf8f0317 100644
--- a/nuttx/drivers/mtd/ftl.c
+++ b/nuttx/drivers/mtd/ftl.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * drivers/mtd/ftl.c
  *
- *   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
@@ -229,6 +229,10 @@ static ssize_t ftl_flush(FAR void *priv, FAR const uint8_t *buffer,
   remaining = nblocks;
   if (alignedblock > startblock)
     {
+      /* Check if the write is shorter than to the end of the erase block */
+
+      bool short_write = (remaining < (alignedblock - startblock));
+      
       /* Read the full erase block into the buffer */
 
       rwblock = startblock & ~mask;
@@ -252,9 +256,19 @@ static ssize_t ftl_flush(FAR void *priv, FAR const uint8_t *buffer,
       /* Copy the user data at the end of the buffered erase block */
 
       offset = (startblock & mask) * dev->geo.blocksize;
-      nbytes = dev->geo.erasesize - offset;
+      
+      if (short_write)
+        {
+          nbytes = remaining * dev->geo.blocksize;
+        }
+      else
+        {
+          nbytes = dev->geo.erasesize - offset;
+        }
+      
       fvdbg("Copy %d bytes into erase block=%d at offset=%d\n",
              nbytes, eraseblock, offset);
+
       memcpy(dev->eblock + offset, buffer, nbytes);
 
       /* And write the erase back to flash */
@@ -268,8 +282,16 @@ static ssize_t ftl_flush(FAR void *priv, FAR const uint8_t *buffer,
 
       /* Then update for amount written */
 
-      remaining -= dev->blkper - (startblock & mask);
-      buffer    += nbytes;
+      if (short_write)
+        {
+          remaining = 0;
+        }
+      else
+        {
+          remaining -= dev->blkper - (startblock & mask);
+        }
+      
+      buffer += nbytes;
     }
 
   /* How handle full erase pages in the middle */
@@ -290,6 +312,7 @@ static ssize_t ftl_flush(FAR void *priv, FAR const uint8_t *buffer,
 
       fvdbg("Write %d bytes into erase block=%d at offset=0\n",
              dev->geo.erasesize, alignedblock);
+
       nxfrd = MTD_BWRITE(dev->mtd, alignedblock, dev->blkper, buffer);
       if (nxfrd != dev->blkper)
         {
diff --git a/nuttx/graphics/nxtk/nxtk_getwindow.c b/nuttx/graphics/nxtk/nxtk_getwindow.c
index 121c7702a..c91f2d22f 100644
--- a/nuttx/graphics/nxtk/nxtk_getwindow.c
+++ b/nuttx/graphics/nxtk/nxtk_getwindow.c
@@ -110,12 +110,15 @@ int nxtk_getwindow(NXTKWINDOW hfwnd, FAR const struct nxgl_rect_s *rect,
     }
 #endif
 
-  /* Clip the rectangle so that it lies within the sub-window bounds
-   * then move the rectangle to that it is relative to the containing
-   * window.
+  /* Move the rectangle to that it is relative to the containing
+   * window. If part of the rectangle lies outside the window,
+   * it will contain garbage data, but the contained area will be
+   * valid.
    */
 
-  nxtk_subwindowclip(fwnd, &getrect, rect, &fwnd->fwrect);
+  nxgl_rectoffset(&getrect, rect,
+                  fwnd->fwrect.pt1.x - fwnd->wnd.bounds.pt1.x,
+                  fwnd->fwrect.pt1.y - fwnd->wnd.bounds.pt1.y);
 
   /* Then get it */
 
diff --git a/nuttx/graphics/nxtk/nxtk_subwindowmove.c b/nuttx/graphics/nxtk/nxtk_subwindowmove.c
index a6fd9f5dd..3c2bb7f37 100644
--- a/nuttx/graphics/nxtk/nxtk_subwindowmove.c
+++ b/nuttx/graphics/nxtk/nxtk_subwindowmove.c
@@ -112,21 +112,19 @@ void nxtk_subwindowmove(FAR struct nxtk_framedwindow_s *fwnd,
 
   nxgl_rectintersect(&abssrc, &abssrc, &fwnd->fwrect);
 
-  /* Clip the offset so that the source rectangle does not move out of the
-   * the client sub-window.
-   */
+  /* Clip the source rectangle so that destination area is within the window. */
 
   destoffset->x = srcoffset->x;
   if (destoffset->x < 0)
     {
       if (abssrc.pt1.x + destoffset->x < bounds->pt1.x)
         {
-           destoffset->x = bounds->pt1.x - abssrc.pt1.x;
+           abssrc.pt1.x = bounds->pt1.x - destoffset->x;
         }
     }
   else if (abssrc.pt2.x + destoffset->x > bounds->pt2.x)
     {
-       destoffset->x = bounds->pt2.x - abssrc.pt2.x;
+       abssrc.pt2.x = bounds->pt2.x - destoffset->x;
     }
 
   destoffset->y = srcoffset->y;
@@ -134,12 +132,12 @@ void nxtk_subwindowmove(FAR struct nxtk_framedwindow_s *fwnd,
     {
       if (abssrc.pt1.y + destoffset->y < bounds->pt1.y)
         {
-           destoffset->y = bounds->pt1.y - abssrc.pt1.y;
+           abssrc.pt1.y = bounds->pt1.y - destoffset->y;
         }
     }
   else if (abssrc.pt2.y + destoffset->y > bounds->pt2.y)
     {
-       destoffset->y = bounds->pt2.y - abssrc.pt2.y;
+       abssrc.pt2.y = bounds->pt2.y - destoffset->y;
     }
 
 
diff --git a/nuttx/include/cxx/cmath b/nuttx/include/cxx/cmath
index 55c7c1dcc..b30d5548b 100644
--- a/nuttx/include/cxx/cmath
+++ b/nuttx/include/cxx/cmath
@@ -69,6 +69,7 @@ namespace std
   using ::log10f;
   using ::log2f;
   using ::modff;
+  using ::roundf;
   using ::powf;
   using ::sinf;
   using ::sinhf;
@@ -95,6 +96,7 @@ namespace std
   using ::log10;
   using ::log2;
   using ::modf;
+  using ::round;
   using ::pow;
   using ::sin;
   using ::sinh;
@@ -121,6 +123,7 @@ namespace std
   using ::log10l;
   using ::log2l;
   using ::modfl;
+  using ::roundl;
   using ::powl;
   using ::sinl;
   using ::sinhl;
diff --git a/nuttx/include/cxx/cstdlib b/nuttx/include/cxx/cstdlib
index 522f3fdb1..1bf8ed9da 100644
--- a/nuttx/include/cxx/cstdlib
+++ b/nuttx/include/cxx/cstdlib
@@ -70,6 +70,7 @@ namespace std
 #endif
 
   using ::strtol;
+  using ::strtoul;
   using ::strtod;
 
   using ::malloc;
diff --git a/nuttx/include/nuttx/fs/fs.h b/nuttx/include/nuttx/fs/fs.h
index aab4ae4be..1759310bc 100644
--- a/nuttx/include/nuttx/fs/fs.h
+++ b/nuttx/include/nuttx/fs/fs.h
@@ -176,7 +176,7 @@ struct mountpt_operations
 
   int     (*statfs)(FAR struct inode *mountpt, FAR struct statfs *buf);
 
-  /* Operations on pathes */
+  /* Operations on paths */
 
   int     (*unlink)(FAR struct inode *mountpt, FAR const char *relpath);
   int     (*mkdir)(FAR struct inode *mountpt, FAR const char *relpath, mode_t mode);
diff --git a/nuttx/include/nuttx/math.h b/nuttx/include/nuttx/math.h
index 160926d07..aaadb9c91 100644
--- a/nuttx/include/nuttx/math.h
+++ b/nuttx/include/nuttx/math.h
@@ -141,6 +141,14 @@ double      floor (double x);
 long double floorl(long double x);
 #endif
 
+float       roundf(float x);
+#if CONFIG_HAVE_DOUBLE
+double      round (double x);
+#endif
+#ifdef CONFIG_HAVE_LONG_DOUBLE
+long double roundl(long double x);
+#endif
+
 float       fabsf (float x);
 #if CONFIG_HAVE_DOUBLE
 double      fabs  (double x);
diff --git a/nuttx/include/nuttx/mtd.h b/nuttx/include/nuttx/mtd.h
index 44582c412..ff48d313f 100644
--- a/nuttx/include/nuttx/mtd.h
+++ b/nuttx/include/nuttx/mtd.h
@@ -220,7 +220,6 @@ 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
  *
@@ -233,6 +232,8 @@ EXTERN FAR struct mtd_dev_s *sst25_initialize(FAR struct spi_dev_s *dev);
 
 EXTERN FAR struct mtd_dev_s *w25_initialize(FAR struct spi_dev_s *dev);
 
+EXTERN FAR struct mtd_dev_s *at25_initialize(FAR struct spi_dev_s *dev);
+
 #undef EXTERN
 #ifdef __cplusplus
 }
diff --git a/nuttx/include/stdbool.h b/nuttx/include/stdbool.h
index f11219912..9c16aee29 100644
--- a/nuttx/include/stdbool.h
+++ b/nuttx/include/stdbool.h
@@ -42,10 +42,33 @@
 
 #include <nuttx/config.h>
 
+/* If CONFIG_ARCH_STDBOOL_H is set, then the archecture will provide its own
+ * stdbool.h file.  In this case, this header file will simply re-direct to
+ * the architecture-specfiic stdbool.h header file.
+ */
+
 #ifdef CONFIG_ARCH_STDBOOL_H
 #  include <arch/stdbool.h>
+
+/* NuttX will insist that the sizeof(bool) is 8-bits.  The sizeof of _Bool
+ * used by any specific compiler is implementation specific:  It can vary from
+ * compiler-to-compiler and even vary between different versions of the same
+ * compiler.  Compilers seems to be converging to sizeof(_Bool) == 1.  If that
+ * is true for your compiler, you should define CONFIG_C99_BOOL8 in your NuttX
+ * configuration for better standards compatibility.
+ *
+ * CONFIG_C99_BOOL8 - Means (1) your C++ compiler has sizeof(_Bool) == 8,
+ * (2) your C compiler supports the C99 _Bool intrinsic type, and (2) that
+ * the C99 _Bool type also has size 1.
+ */
+
 #else
+
+ /* nuttx/compiler.h may also define or undefine CONFIG_C99_BOOL8 */
+
 #  include <nuttx/compiler.h>
+
+#if !defined(__cplusplus) || !defined(CONFIG_C99_BOOL8)
 #  include <stdint.h>
 
 /****************************************************************************
@@ -58,10 +81,15 @@
  * NOTE: Under C99 'bool' is required to be defined to be the intrinsic type
  * _Bool.  However, in this NuttX context, we need backward compatibility
  * to pre-C99 standards where _Bool is not an intrinsic type.  Hence, we
- * use _Bool8 as the underlying type.
+ * use _Bool8 as the underlying type (unless CONFIG_C99_BOOL8 is defined)
  */
 
-#define bool  _Bool8
+#ifdef CONFIG_C99_BOOL8
+#  define bool _Bool
+#else
+#  define bool _Bool8
+#endif
+
 #define true  1
 #define false 0
 
@@ -83,7 +111,10 @@
  * as the underlying type.
  */
 
+#ifndef CONFIG_C99_BOOL8
 typedef uint8_t _Bool8;
+#endif
 
+#endif /* __cplusplus && CONFIG_C99_BOOL8 */
 #endif /* CONFIG_ARCH_STDBOOL_H */
 #endif /* __INCLUDE_STDBOOL_H */
diff --git a/nuttx/libc/math/Make.defs b/nuttx/libc/math/Make.defs
index bc6a265f0..ece25f4e5 100644
--- a/nuttx/libc/math/Make.defs
+++ b/nuttx/libc/math/Make.defs
@@ -40,17 +40,17 @@ ifeq ($(CONFIG_LIBM),y)
 CSRCS += lib_acosf.c lib_asinf.c lib_atan2f.c lib_atanf.c lib_ceilf.c lib_cosf.c
 CSRCS += lib_coshf.c  lib_expf.c lib_fabsf.c lib_floorf.c lib_fmodf.c lib_frexpf.c
 CSRCS += lib_ldexpf.c lib_logf.c lib_log10f.c lib_log2f.c lib_modff.c lib_powf.c
-CSRCS += lib_sinf.c lib_sinhf.c lib_sqrtf.c lib_tanf.c lib_tanhf.c
+CSRCS += lib_roundf.c lib_sinf.c lib_sinhf.c lib_sqrtf.c lib_tanf.c lib_tanhf.c
 
 CSRCS += lib_acos.c lib_asin.c lib_atan.c lib_atan2.c lib_ceil.c lib_cos.c
 CSRCS += lib_cosh.c lib_exp.c lib_fabs.c lib_floor.c lib_fmod.c lib_frexp.c
 CSRCS += lib_ldexp.c lib_log.c lib_log10.c lib_log2.c lib_modf.c lib_pow.c
-CSRCS += lib_sin.c lib_sinh.c lib_sqrt.c lib_tan.c lib_tanh.c
+CSRCS += lib_round.c lib_sin.c lib_sinh.c lib_sqrt.c lib_tan.c lib_tanh.c
 
 CSRCS += lib_acosl.c lib_asinl.c lib_atan2l.c lib_atanl.c lib_ceill.c lib_cosl.c
 CSRCS += lib_coshl.c lib_expl.c lib_fabsl.c lib_floorl.c lib_fmodl.c lib_frexpl.c
 CSRCS += lib_ldexpl.c lib_logl.c lib_log10l.c lib_log2l.c lib_modfl.c lib_powl.c
-CSRCS += lib_sinl.c lib_sinhl.c lib_sqrtl.c lib_tanl.c lib_tanhl.c
+CSRCS += lib_roundl.c lib_sinl.c lib_sinhl.c lib_sqrtl.c lib_tanl.c lib_tanhl.c
 
 CSRCS += lib_libexpi.c lib_libsqrtapprox.c
 
diff --git a/nuttx/libc/math/lib_round.c b/nuttx/libc/math/lib_round.c
new file mode 100644
index 000000000..6191cee5b
--- /dev/null
+++ b/nuttx/libc/math/lib_round.c
@@ -0,0 +1,40 @@
+/************************************************************************
+ * lib/math/lib_round.c
+ *
+ * This file is a part of NuttX:
+ *
+ *   Copyright (C) 2012 Gregory Nutt. All rights reserved.
+ *             (C) 2012 Petteri Aimonen <jpa@nx.mail.kapsi.fi>
+ *
+ ************************************************************************/
+
+/************************************************************************
+ * Included Files
+ ************************************************************************/
+
+#include <nuttx/config.h>
+#include <nuttx/compiler.h>
+
+#include <math.h>
+
+/************************************************************************
+ * Public Functions
+ ************************************************************************/
+
+#ifdef CONFIG_HAVE_DOUBLE
+double round(double x)
+{
+  double f = modf(x, &x);
+  if (x <= 0.0 && f <= -0.5)
+    {
+      x -= 1.0;
+    }
+  
+  if (x >= 0.0 && f >= 0.5)
+    {
+      x += 1.0;
+    }
+
+  return x;
+}
+#endif
diff --git a/nuttx/libc/math/lib_roundf.c b/nuttx/libc/math/lib_roundf.c
new file mode 100644
index 000000000..145cf3df6
--- /dev/null
+++ b/nuttx/libc/math/lib_roundf.c
@@ -0,0 +1,38 @@
+/************************************************************************
+ * lib/math/lib_roundf.c
+ *
+ * This file is a part of NuttX:
+ *
+ *   Copyright (C) 2012 Gregory Nutt. All rights reserved.
+ *             (C) 2012 Petteri Aimonen <jpa@nx.mail.kapsi.fi>
+ *
+ ************************************************************************/
+
+/************************************************************************
+ * Included Files
+ ************************************************************************/
+
+#include <nuttx/config.h>
+#include <nuttx/compiler.h>
+
+#include <math.h>
+
+/************************************************************************
+ * Public Functions
+ ************************************************************************/
+
+float roundf(float x)
+{
+  float f = modff(x, &x);
+  if (x <= 0.0f && f <= -0.5f)
+    {
+      x -= 1.0f;
+    }
+  
+  if (x >= 0.0f && f >= 0.5f)
+    {
+      x += 1.0f;
+    }
+
+  return x;
+}
diff --git a/nuttx/libc/math/lib_roundl.c b/nuttx/libc/math/lib_roundl.c
new file mode 100644
index 000000000..b2ddba670
--- /dev/null
+++ b/nuttx/libc/math/lib_roundl.c
@@ -0,0 +1,40 @@
+/************************************************************************
+ * lib/math/lib_round.c
+ *
+ * This file is a part of NuttX:
+ *
+ *   Copyright (C) 2012 Gregory Nutt. All rights reserved.
+ *             (C) 2012 Petteri Aimonen <jpa@nx.mail.kapsi.fi>
+ *
+ ************************************************************************/
+
+/************************************************************************
+ * Included Files
+ ************************************************************************/
+
+#include <nuttx/config.h>
+#include <nuttx/compiler.h>
+
+#include <math.h>
+
+/************************************************************************
+ * Public Functions
+ ************************************************************************/
+
+#ifdef CONFIG_HAVE_LONG_DOUBLE
+long double roundl(long double x)
+{
+  long double f = modfl(x, &x);
+  if (x <= 0.0 && f <= -0.5)
+    {
+      x -= 1.0;
+    }
+  
+  if (x >= 0.0 && f >= 0.5)
+    {
+      x += 1.0;
+    }
+
+  return x;
+}
+#endif
diff --git a/nuttx/libc/stdlib/lib_rand.c b/nuttx/libc/stdlib/lib_rand.c
index 0faef5d66..453a4537a 100644
--- a/nuttx/libc/stdlib/lib_rand.c
+++ b/nuttx/libc/stdlib/lib_rand.c
@@ -74,7 +74,7 @@ static unsigned int nrand(unsigned int nLimit);
 
 /* First order congruential generators */
 
-static inline void fgenerate1(void);
+static inline unsigned long fgenerate1(void);
 #if (CONFIG_LIB_RAND_ORDER == 1)
 static double_t frand1(void);
 #endif
@@ -82,7 +82,7 @@ static double_t frand1(void);
 /* Second order congruential generators */
 
 #if (CONFIG_LIB_RAND_ORDER > 1)
-static inline void fgenerate2(void);
+static inline unsigned long fgenerate2(void);
 #if (CONFIG_LIB_RAND_ORDER == 2)
 static double_t frand2(void);
 #endif
@@ -90,7 +90,7 @@ static double_t frand2(void);
 /* Third order congruential generators */
 
 #if (CONFIG_LIB_RAND_ORDER > 2)
-static inline void fgenerate3(void);
+static inline unsigned long fgenerate3(void);
 static double_t frand3(void);
 #endif
 #endif
@@ -141,7 +141,7 @@ static unsigned int nrand(unsigned int nLimit)
 
 /* First order congruential generators */
 
-static inline void fgenerate1(void)
+static inline unsigned long fgenerate1(void)
 {
   unsigned long randint;
 
@@ -152,6 +152,7 @@ static inline void fgenerate1(void)
 
   randint    = (RND1_CONSTK * g_randint1) % RND1_CONSTP;
   g_randint1 = (randint == 0 ? 1 : randint);
+  return randint;
 }
 
 #if (CONFIG_LIB_RAND_ORDER == 1)
@@ -159,18 +160,18 @@ static double_t frand1(void)
 {
   /* First order congruential generator. */
 
-  fgenerate1();
+  unsigned long randint = fgenerate1();
 
   /* Construct an floating point value in the range from 0.0 up to 1.0 */
 
-  return ((double_t)g_randint1) / ((double_t)RND1_CONSTP);
+  return ((double_t)randint) / ((double_t)RND1_CONSTP);
 }
 #endif
 
 /* Second order congruential generators */
 
 #if (CONFIG_LIB_RAND_ORDER > 1)
-static inline void fgenerate2(void)
+static inline unsigned long fgenerate2(void)
 {
   unsigned long randint;
 
@@ -190,6 +191,8 @@ static inline void fgenerate2(void)
     {
       g_randint2 = 1;
     }
+
+  return randint;
 }
 
 #if (CONFIG_LIB_RAND_ORDER == 2)
@@ -197,18 +200,18 @@ static double_t frand2(void)
 {
   /* Second order congruential generator */
 
-  fgenerate2();
+  unsigned long randint = fgenerate2();
 
   /* Construct an floating point value in the range from 0.0 up to 1.0 */
 
-  return ((double_t)g_randint1) / ((double_t)RND2_CONSTP);
+  return ((double_t)randint) / ((double_t)RND2_CONSTP);
 }
 #endif
 
 /* Third order congruential generators */
 
 #if (CONFIG_LIB_RAND_ORDER > 2)
-static inline void fgenerate3(void)
+static inline unsigned long fgenerate3(void)
 {
   unsigned long randint;
 
@@ -230,17 +233,19 @@ static inline void fgenerate3(void)
     {
       g_randint3 = 1;
     }
+
+  return randint;
 }
 
 static double_t frand3(void)
 {
   /* Third order congruential generator */
 
-  fgenerate3();
+  unsigned long randint = fgenerate3();
 
   /* Construct an floating point value in the range from 0.0 up to 1.0 */
 
-  return ((double_t)g_randint1) / ((double_t)RND3_CONSTP);
+  return ((double_t)randint) / ((double_t)RND3_CONSTP);
 }
 #endif
 #endif
@@ -258,10 +263,10 @@ void srand(unsigned int seed)
   g_randint1 = seed;
 #if (CONFIG_LIB_RAND_ORDER > 1)
   g_randint2 = seed;
-  fgenerate1();
+  (void)fgenerate1();
 #if (CONFIG_LIB_RAND_ORDER > 2)
   g_randint3 = seed;
-  fgenerate2();
+  (void)fgenerate2();
 #endif
 #endif
 }
diff --git a/nuttx/libxx/Kconfig b/nuttx/libxx/Kconfig
index 8b5fc42e8..9c78342c2 100644
--- a/nuttx/libxx/Kconfig
+++ b/nuttx/libxx/Kconfig
@@ -5,6 +5,14 @@
 
 comment "Basic CXX Support"
 
+config C99_BOOL8
+	bool "sizeof(_Bool) is 8-bits"
+	default n
+	---help---
+		This setting means (1) your C++ compiler has sizeof(_Bool) == 8, (2)
+		your C compiler supports the C99 _Bool intrinsic type, and (2) that
+		the C99 _Bool type also has size 1.
+
 config HAVE_CXX
 	bool "Have C++ compiler"
 	default n