Add an MTD layer that will add read-ahead or write buffering to any MTD driver (incomplete)

drivers/Kconfig

@@ -35,6 +35,33 @@ config LOOP
 		file (or character device) as a block device.  See losetup() and
 		loteardown() in include/nuttx/fs/fs.h.
 
+config DRVR_WRITEBUFFER
+	bool "Enable write buffer support"
+	default n
+	---help---
+		Enable generic write buffering support that can be used by a variety
+		of drivers.
+
+if DRVR_WRITEBUFFER
+
+config DRVR_WRDELAY
+	int "Write flush delay"
+	default 350
+	---help---
+		If there is no write activity for this configured amount of time,
+		then the contents will be automatically flushed to the media.  This
+		reduces the likelihood that data will be stuck in the write buffer
+		at the time of power down.
+
+endif # DRVR_WRITEBUFFER
+
+config DRVR_READAHEAD
+	bool "Enable read-ahead buffer support"
+	default n
+	---help---
+		Enable generic read-ahead buffering support that can be used by a
+		variety of drivers.
+
 config RAMDISK
 	bool "RAM Disk Support"
 	default n

drivers/Makefile

@@ -1,7 +1,7 @@
 ############################################################################
 # drivers/Makefile
 #
-#   Copyright (C) 2007-2013 Gregory Nutt. All rights reserved.
+#   Copyright (C) 2007-2014 Gregory Nutt. All rights reserved.
 #   Author: Gregory Nutt <gnutt@nuttx.org>
 #
 # Redistribution and use in source and binary forms, with or without
@@ -73,7 +73,14 @@ ifneq ($(CONFIG_NFILE_DESCRIPTORS),0)
   CSRCS += dev_null.c dev_zero.c loop.c
 
 ifneq ($(CONFIG_DISABLE_MOUNTPOINT),y)
-  CSRCS += ramdisk.c rwbuffer.c
+  CSRCS += ramdisk.c
+ifneq ($(CONFIG_DRVR_WRITEBUFFER),y)
+  CSRCS += rwbuffer.c
+else
+ifneq ($(CONFIG_DRVR_READAHEAD),y)
+  CSRCS += rwbuffer.c
+endif
+endif
 endif
 
 ifeq ($(CONFIG_CAN),y)

drivers/mmcsd/mmcsd_sdio.c

@@ -144,7 +144,7 @@ struct mmcsd_state_s
 #endif
   /* Read-ahead and write buffering support */
 
-#if defined(CONFIG_FS_WRITEBUFFER) || defined(CONFIG_FS_READAHEAD)
+#if defined(CONFIG_DRVR_WRITEBUFFER) || defined(CONFIG_DRVR_READAHEAD)
   struct rwbuffer_s rwbuffer;
 #endif
 };
@@ -203,7 +203,7 @@ static ssize_t mmcsd_readsingle(FAR struct mmcsd_state_s *priv,
 static ssize_t mmcsd_readmultiple(FAR struct mmcsd_state_s *priv,
                  FAR uint8_t *buffer, off_t startblock, size_t nblocks);
 #endif
-#ifdef CONFIG_FS_READAHEAD
+#ifdef CONFIG_DRVR_READAHEAD
 static ssize_t mmcsd_reload(FAR void *dev, FAR uint8_t *buffer,
                  off_t startblock, size_t nblocks);
 #endif
@@ -214,7 +214,7 @@ static ssize_t mmcsd_writesingle(FAR struct mmcsd_state_s *priv,
 static ssize_t mmcsd_writemultiple(FAR struct mmcsd_state_s *priv,
                  FAR const uint8_t *buffer, off_t startblock, size_t nblocks);
 #endif
-#ifdef CONFIG_FS_WRITEBUFFER
+#ifdef CONFIG_DRVR_WRITEBUFFER
 static ssize_t mmcsd_flush(FAR void *dev, FAR const uint8_t *buffer,
                  off_t startblock, size_t nblocks);
 #endif
@@ -1538,7 +1538,7 @@ static ssize_t mmcsd_readmultiple(FAR struct mmcsd_state_s *priv,
  *
  ****************************************************************************/
 
-#ifdef CONFIG_FS_READAHEAD
+#ifdef CONFIG_DRVR_READAHEAD
 static ssize_t mmcsd_reload(FAR void *dev, FAR uint8_t *buffer,
                             off_t startblock, size_t nblocks)
 {
@@ -1911,12 +1911,12 @@ static ssize_t mmcsd_writemultiple(FAR struct mmcsd_state_s *priv,
  *
  ****************************************************************************/
 
-#if defined(CONFIG_FS_WRITABLE) && defined(CONFIG_FS_WRITEBUFFER)
+#if defined(CONFIG_FS_WRITABLE) && defined(CONFIG_DRVR_WRITEBUFFER)
 static ssize_t mmcsd_flush(FAR void *dev, FAR const uint8_t *buffer,
                            off_t startblock, size_t nblocks)
 {
   FAR struct mmcsd_state_s *priv = (FAR struct mmcsd_state_s *)dev;
-#ifndef CONFIG_MMCSD_MULTIBLOCK_DISABLE
+#ifdef CONFIG_MMCSD_MULTIBLOCK_DISABLE
   size_t block;
   size_t endblock;
 #endif
@@ -2028,7 +2028,7 @@ static ssize_t mmcsd_read(FAR struct inode *inode, unsigned char *buffer,
                           size_t startsector, unsigned int nsectors)
 {
   FAR struct mmcsd_state_s *priv;
-#if !defined(CONFIG_FS_READAHEAD) && defined(CONFIG_MMCSD_MULTIBLOCK_DISABLE)
+#if !defined(CONFIG_DRVR_READAHEAD) && defined(CONFIG_MMCSD_MULTIBLOCK_DISABLE)
   size_t sector;
   size_t endsector;
 #endif
@@ -2043,7 +2043,7 @@ static ssize_t mmcsd_read(FAR struct inode *inode, unsigned char *buffer,
     {
       mmcsd_takesem(priv);
 
-#if defined(CONFIG_FS_READAHEAD)
+#if defined(CONFIG_DRVR_READAHEAD)
       /* Get the data from the read-ahead buffer */
 
       ret = rwb_read(&priv->rwbuffer, startsector, nsectors, buffer);
@@ -2103,7 +2103,7 @@ static ssize_t mmcsd_write(FAR struct inode *inode, FAR const unsigned char *buf
                            size_t startsector, unsigned int nsectors)
 {
   FAR struct mmcsd_state_s *priv;
-#if !defined(CONFIG_FS_WRITEBUFFER) && defined(CONFIG_MMCSD_MULTIBLOCK_DISABLE)
+#if defined(CONFIG_MMCSD_MULTIBLOCK_DISABLE)
   size_t sector;
   size_t endsector;
 #endif
@@ -2115,7 +2115,7 @@ static ssize_t mmcsd_write(FAR struct inode *inode, FAR const unsigned char *buf
 
   mmcsd_takesem(priv);
 
-#if defined(CONFIG_FS_WRITEBUFFER)
+#if defined(CONFIG_DRVR_WRITEBUFFER)
   /* Write the data to the write buffer */
 
   ret = rwb_write(&priv->rwbuffer, startsector, nsectors, buffer);
@@ -3271,9 +3271,10 @@ int mmcsd_slotinitialize(int minor, FAR struct sdio_dev_s *dev)
             }
         }
 
-#if defined(CONFIG_FS_WRITEBUFFER) || defined(CONFIG_FS_READAHEAD)
+#if defined(CONFIG_DRVR_WRITEBUFFER) || defined(CONFIG_DRVR_READAHEAD)
       /* Initialize buffering */
 
+#warning "Missing setup of rwbuffer"
       ret = rwb_initialize(&priv->rwbuffer);
       if (ret < 0)
         {
@@ -3298,7 +3299,7 @@ int mmcsd_slotinitialize(int minor, FAR struct sdio_dev_s *dev)
   return OK;
 
 errout_with_buffers:
-#if defined(CONFIG_FS_WRITEBUFFER) || defined(CONFIG_FS_READAHEAD)
+#if defined(CONFIG_DRVR_WRITEBUFFER) || defined(CONFIG_DRVR_READAHEAD)
   rwb_uninitialize(&priv->rwbuffer);
 errout_with_hwinit:
 #endif

drivers/mtd/Kconfig

@@ -66,6 +66,40 @@ config MTD_BYTE_WRITE
 		support such writes.  The SMART file system can take advantage of
 		this option if it is enabled.
 
+config MTD_WRBUFFER
+	bool "Enable MTD write buffering
+	default n
+	depends on DRVR_WRITEBUFFER
+	---help---
+		Build the mtd_rwbuffer layer and enable support for write buffering.
+
+if MTD_WRBUFFER
+
+config MTD_NWRBLOCKS
+	int "MTD write buffer size"
+	default 4
+	---help---
+		The size of the MTD write buffer (in blocks)
+
+endif # MTD_WRBUFFER
+
+config MTD_READAHEAD
+	bool "Enable MTD read-ahead buffering
+	default n
+	depends on DRVR_READAHEAD
+	---help---
+		Build the mtd_rwbuffer layer and enable support for read-ahead buffering.
+
+if MTD_READAHEAD
+
+config MTD_NRDBLOCKS
+	int "MTD read-head buffer size"
+	default 4
+	---help---
+		The size of the MTD read-ahead buffer (in blocks)
+
+endif # MTD_READAHEAD
+
 config MTD_CONFIG
 	bool "Enable Dev Config (MTD based) device"
 	default n
@@ -73,6 +107,8 @@ config MTD_CONFIG
 		Provides a /dev/config device for saving / restoring application
 		configuration data to a standard MTD device or partition.
 
+if MTD_CONFIG
+
 config MTD_CONFIG_RAM_CONSOLIDATE
 	bool "Always use RAM consolidation method (work in progress)"
 	default n
@@ -97,13 +133,14 @@ config MTD_CONFIG_RAM_CONSOLIDATE
 
 config MTD_CONFIG_ERASEDVALUE
 	hex "Erased value of bytes on the MTD device"
-	depends on MTD_CONFIG
 	default 0xff
 	---help---
 		Specifies the value of the erased state of the MTD FLASH.  For
 		most FLASH parts, this is 0xff, but could also be zero depending
 		on the device.
 
+endif # MTD_CONFIG
+
 comment "MTD Device Drivers"
 
 menuconfig MTD_NAND

drivers/mtd/Make.defs

@@ -49,6 +49,14 @@ ifeq ($(CONFIG_MTD_SECT512),y)
 CSRCS += sector512.c
 endif
 
+ifeq ($(CONFIG_MTD_WRBUFFER),y)
+CSRCS += mtd_rwbuffer.c
+else
+ifeq ($(CONFIG_MTD_READAHEAD),y)
+CSRCS += mtd_rwbuffer.c
+endif
+endif
+
 ifeq ($(CONFIG_MTD_NAND),y)
 CSRCS += mtd_nand.c mtd_onfi.c mtd_nandscheme.c mtd_nandmodel.c mtd_modeltab.c
 ifeq ($(CONFIG_MTD_NAND_SWECC),y)

drivers/mtd/ftl.c

@@ -56,11 +56,11 @@
 #include <nuttx/rwbuffer.h>
 
 /****************************************************************************
- * Private Definitions
+ * Pre-processor Definitions
  ****************************************************************************/
 
-#if defined(CONFIG_FS_READAHEAD) || (defined(CONFIG_FS_WRITABLE) && defined(CONFIG_FS_WRITEBUFFER))
+#if defined(CONFIG_DRVR_READAHEAD) || defined(CONFIG_DRVR_WRITEBUFFER)
-#  defined CONFIG_FTL_RWBUFFER 1
+#  define CONFIG_FTL_RWBUFFER 1
 #endif
 
 /****************************************************************************
@@ -111,7 +111,7 @@ static const struct block_operations g_bops =
 #ifdef CONFIG_FS_WRITABLE
   ftl_write,    /* write    */
 #else
-  NULL,        /* write    */
+  NULL,         /* write    */
 #endif
   ftl_geometry, /* geometry */
   ftl_ioctl     /* ioctl    */
@@ -181,13 +181,14 @@ static ssize_t ftl_reload(FAR void *priv, FAR uint8_t *buffer,
 static ssize_t ftl_read(FAR struct inode *inode, unsigned char *buffer,
                         size_t start_sector, unsigned int nsectors)
 {
-  struct ftl_struct_s *dev;
+  FAR struct ftl_struct_s *dev;
 
   fvdbg("sector: %d nsectors: %d\n", start_sector, nsectors);
 
   DEBUGASSERT(inode && inode->i_private);
-  dev = (struct ftl_struct_s *)inode->i_private;
+
-#ifdef CONFIG_FS_READAHEAD
+  dev = (FAR struct ftl_struct_s *)inode->i_private;
+#ifdef CONFIG_DRVR_READAHEAD
   return rwb_read(&dev->rwb, start_sector, nsectors, buffer);
 #else
   return ftl_reload(dev, buffer, start_sector, nsectors);
@@ -388,7 +389,7 @@ static ssize_t ftl_write(FAR struct inode *inode, const unsigned char *buffer,
 
   DEBUGASSERT(inode && inode->i_private);
   dev = (struct ftl_struct_s *)inode->i_private;
-#ifdef CONFIG_FS_WRITEBUFFER
+#ifdef CONFIG_DRVR_WRITEBUFFER
   return rwb_write(&dev->rwb, start_sector, nsectors, buffer);
 #else
   return ftl_flush(dev, buffer, start_sector, nsectors);
@@ -566,15 +567,16 @@ int ftl_initialize(int minor, FAR struct mtd_dev_s *mtd)
       dev->rwb.nblocks     = dev->geo.neraseblocks * dev->blkper;
       dev->rwb.dev         = (FAR void *)dev;
 
-#if defined(CONFIG_FS_WRITABLE) && defined(CONFIG_FS_WRITEBUFFER)
+#if defined(CONFIG_FS_WRITABLE) && defined(CONFIG_DRVR_WRITEBUFFER)
       dev->rwb.wrmaxblocks = dev->blkper;
       dev->rwb.wrflush     = ftl_flush;
 #endif
 
-#ifdef CONFIG_FS_READAHEAD
+#ifdef CONFIG_DRVR_READAHEAD
       dev->rwb.rhmaxblocks = dev->blkper;
       dev->rwb.rhreload    = ftl_reload;
 #endif
+
       ret = rwb_initialize(&dev->rwb);
       if (ret < 0)
         {

drivers/mtd/mtd_procfs.c

@@ -327,6 +327,7 @@ static int mtd_stat(const char *relpath, struct stat *buf)
  * in the procfs system simply for information purposes (if desired).
  *
  ****************************************************************************/
+
 int mtd_register(FAR struct mtd_dev_s *mtd, FAR const char *name)
 {
   FAR struct mtd_dev_s *plast;
@@ -359,6 +360,8 @@ int mtd_register(FAR struct mtd_dev_s *mtd, FAR const char *name)
 
       plast->pnext = mtd;
     }
+
+  return OK;
 }
 
 #endif /* !CONFIG_DISABLE_MOUNTPOINT && CONFIG_FS_PROCFS */

drivers/mtd/mtd_rwbuffer.c

@@ -0,0 +1,417 @@
+/************************************************************************************
+ * drivers/mtd/mtd_rwbuffer.c
+ * MTD driver that contains another MTD driver and provides read-ahead and/or write
+ * buffering.
+ *
+ *   Copyright (C) 2014 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 <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <assert.h>
+#include <errno.h>
+#include <debug.h>
+
+#include <nuttx/kmalloc.h>
+#include <nuttx/rwbuffer.h>
+#include <nuttx/fs/ioctl.h>
+#include <nuttx/mtd/mtd.h>
+
+#if defined(CONFIG_DRVR_WRITEBUFFER) || defined(CONFIG_DRVR_READAHEAD)
+
+/************************************************************************************
+ * Pre-processor Definitions
+ ************************************************************************************/
+
+#ifndef CONFIG_MTD_NWRBLOCKS
+#  define CONFIG_MTD_NWRBLOCKS 4
+#endif
+
+#ifndef CONFIG_MTD_NRDBLOCKS
+#  define CONFIG_MTD_NRDBLOCKS 4
+#endif
+
+/************************************************************************************
+ * 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 mtd_rwbuffer_s.
+ */
+
+struct mtd_rwbuffer_s
+{
+  struct mtd_dev_s          mtd;  /* Our exported MTD interface */
+  FAR struct mtd_dev_s     *dev;  /* Saved lower level MTD interface instance */
+  struct rwbuffer_s         rwb;  /* The rwbuffer state structure */
+  uint16_t                  spb;  /* Number of sectors per block */
+};
+
+/************************************************************************************
+ * Private Function Prototypes
+ ************************************************************************************/
+
+/* rwbuffer callouts */
+
+static ssize_t mtd_reload(FAR void *dev, FAR uint8_t *buffer, off_t startblock,
+                          size_t nblocks);
+static ssize_t mtd_flush(FAR void *dev, FAR const uint8_t *buffer, off_t startblock,
+                         size_t nblocks);
+
+/* MTD driver methods */
+
+static int mtd_erase(FAR struct mtd_dev_s *dev, off_t block, size_t nsectors);
+static ssize_t mtd_bread(FAR struct mtd_dev_s *dev, off_t block,
+                         size_t nsectors, FAR uint8_t *buf);
+static ssize_t mtd_bwrite(FAR struct mtd_dev_s *dev, off_t block,
+                          size_t nsectors, FAR const uint8_t *buf);
+static ssize_t mtd_read(FAR struct mtd_dev_s *dev, off_t offset, size_t nbytes,
+                        FAR uint8_t *buffer);
+static int mtd_ioctl(FAR struct mtd_dev_s *dev, int cmd, unsigned long arg);
+
+/************************************************************************************
+ * Private Data
+ ************************************************************************************/
+
+/************************************************************************************
+ * Private Functions
+ ************************************************************************************/
+
+/************************************************************************************
+ * Name: mtd_reload
+ *
+ * Description:
+ *   Reload the read-ahead buffer
+ *
+ ************************************************************************************/
+
+static ssize_t mtd_reload(FAR void *dev, FAR uint8_t *buffer, off_t startblock,
+                          size_t nblocks)
+{
+  FAR struct mtd_rwbuffer_s *priv = (FAR struct mtd_rwbuffer_s *)dev;
+  DEBUGASSERT(priv && priv->dev);
+
+  /* This is just a pass-through to the contained MTD */
+
+  return priv->dev->bread(priv->dev, startblock, nblocks, buffer);
+}
+
+/************************************************************************************
+ * Name: mtd_flush
+ *
+ * Description:
+ *   Flush the write buffer to hardware
+ *
+ ************************************************************************************/
+
+static ssize_t mtd_flush(FAR void *dev, FAR const uint8_t *buffer, off_t startblock,
+                         size_t nblocks)
+{
+  FAR struct mtd_rwbuffer_s *priv = (FAR struct mtd_rwbuffer_s *)dev;
+  DEBUGASSERT(priv && priv->dev);
+
+  /* This is just a pass-through to the contained MTD */
+
+  return priv->dev->bwrite(priv->dev, startblock, nblocks, buffer);
+}
+
+/************************************************************************************
+ * Name: mtd_erase
+ ************************************************************************************/
+
+static int mtd_erase(FAR struct mtd_dev_s *dev, off_t block, size_t nblocks)
+{
+  FAR struct mtd_rwbuffer_s *priv = (FAR struct mtd_rwbuffer_s *)dev;
+  off_t sector;
+  size_t nsectors;
+  int ret;
+
+  fvdbg("block: %08lx nsectors: %lu\n",
+        (unsigned long)block, (unsigned int)nsectors);
+
+  /* Convert to logical sectors and sector numbers */
+
+  sector   = block * priv->spb;
+  nsectors = nblocks * priv->spb;
+
+  /* Then invalidate in cached data */
+
+  ret = rwb_invalidate(&priv->rwb, sector, nsectors);
+  if (ret < 0)
+    {
+      fdbg("ERROR: rwb_invalidate failed: %d\n", ret);
+      return ret;
+    }
+
+  /* Then let the lower level MTD driver do the real erase */
+
+  return priv->dev->erase(priv->dev, block, nblocks);
+}
+
+/************************************************************************************
+ * Name: mtd_bread
+ ************************************************************************************/
+
+static ssize_t mtd_bread(FAR struct mtd_dev_s *dev, off_t sector,
+                          size_t nsectors, FAR uint8_t *buffer)
+{
+  FAR struct mtd_rwbuffer_s *priv = (FAR struct mtd_rwbuffer_s *)dev;
+
+  /* Let the rwbuffer logic do it real work.  It will call out to mtd_reload if is
+   * needs to read any data.
+   */
+
+  return rwb_read(&priv->rwb, sector, nsectors, buffer);
+}
+
+/************************************************************************************
+ * Name: mtd_bwrite
+ ************************************************************************************/
+
+static ssize_t mtd_bwrite(FAR struct mtd_dev_s *dev, off_t block, size_t nsectors,
+                            FAR const uint8_t *buffer)
+{
+  FAR struct mtd_rwbuffer_s *priv = (FAR struct mtd_rwbuffer_s *)dev;
+
+  /* Let the rwbuffer logic do it real work.  It will call out to wrb_reload it is
+   * needs to read any data.
+   */
+
+  return rwb_write(&priv->rwb, block, nsectors, buffer);
+}
+
+/************************************************************************************
+ * Name: mtd_read
+ ************************************************************************************/
+
+static ssize_t mtd_read(FAR struct mtd_dev_s *dev, off_t offset, size_t nbytes,
+                         FAR uint8_t *buffer)
+{
+  FAR struct mtd_rwbuffer_s *priv = (FAR struct mtd_rwbuffer_s *)dev;
+
+  /* Let the rwbuffer logic do it real work.  It will call out to mtd_reload it is
+   * needs to read any data.
+   */
+
+  return mtd_readbytes(&priv->rwb, offset, nbytes, buffer);
+}
+
+/************************************************************************************
+ * Name: mtd_ioctl
+ ************************************************************************************/
+
+static int mtd_ioctl(FAR struct mtd_dev_s *dev, int cmd, unsigned long arg)
+{
+  FAR struct mtd_rwbuffer_s *priv = (FAR struct mtd_rwbuffer_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    = priv->rwb.blocksize;
+              geo->erasesize    = priv->rwb.blocksize* priv->spb;
+              geo->neraseblocks = priv->rwb.nblocks * priv->spb;
+              ret               = OK;
+
+              fvdbg("blocksize: %d erasesize: %d neraseblocks: %d\n",
+                    geo->blocksize, geo->erasesize, geo->neraseblocks);
+            }
+        }
+        break;
+
+      case MTDIOC_BULKERASE:
+        {
+          /* Erase the entire device */
+
+          ret = priv->dev->ioctl(priv->dev, MTDIOC_BULKERASE, 0);
+          if (ret >= 0)
+            {
+              fdbg("ERROR: Device ioctl failed: %d\n", ret);
+              break;
+            }
+
+          /* Then invalidate in cached data */
+
+         ret = rwb_invalidate(&priv->rwb,0, priv->rwb.nblocks);
+         if (ret < 0)
+           {
+              fdbg("ERROR: rwb_invalidate failed: %d\n", ret);
+           }
+        }
+        break;
+
+      case MTDIOC_XIPBASE:
+      default:
+        ret = -ENOTTY; /* Bad command */
+        break;
+    }
+
+  fvdbg("return %d\n", ret);
+  return ret;
+}
+
+/************************************************************************************
+ * Public Functions
+ ************************************************************************************/
+
+/************************************************************************************
+ * Name: mtd_rwb_initialize
+ *
+ * Description:
+ *   Create an initialized MTD device instance.  This MTD driver contains another
+ *   MTD driver and converts a larger sector size to a standard 512 byte sector
+ *   size.
+ *
+ *   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 *mtd_rwb_initialize(FAR struct mtd_dev_s *mtd)
+{
+  FAR struct mtd_rwbuffer_s *priv;
+  struct mtd_geometry_s geo;
+  int ret;
+
+  fvdbg("mtd: %p\n", mtd);
+  DEBUGASSERT(mtd && mtd->ioctl);
+
+  /* Get the device geometry */
+
+  ret = mtd->ioctl(mtd, MTDIOC_GEOMETRY, (unsigned long)((uintptr_t)&geo));
+  if (ret < 0)
+    {
+      fdbg("ERROR: MTDIOC_GEOMETRY ioctl failed: %d\n", ret);
+      return NULL;
+    }
+
+  /* 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 mtd_rwbuffer_s *)kzalloc(sizeof(struct mtd_rwbuffer_s));
+  if (priv)
+    {
+      /* Initialize the allocated structure. (unsupported methods/fields
+       * were already nullified by kzalloc).
+       */
+
+      priv->mtd.erase    = mtd_erase;  /* Our MTD erase method */
+      priv->mtd.bread    = mtd_bread;  /* Our MTD bread method */
+      priv->mtd.bwrite   = mtd_bwrite; /* Our MTD bwrite method */
+      priv->mtd.read     = mtd_read;   /* Our MTD read method */
+      priv->mtd.ioctl    = mtd_ioctl;  /* Our MTD ioctl method */
+
+      priv->dev          = mtd;        /* The contained MTD instance */
+
+      /* Sectors per block.  The erase block size must be an even multiple
+       * of the sector size.
+       */
+
+      priv->spb          = geo.erasesize / geo.blocksize;
+      DEBUGASSERT((size_t)priv->spb * geo_blocksize = geo.erasesize);
+
+      /* Values must be provided to rwb_initialize() */
+      /* Supported geometry */
+
+      priv->rwb.blocksize = geo.blocksize;
+      priv->rwb.nblocks   = geo.neraseblocks * priv->spb;
+
+      /* Buffer setup */
+
+#ifdef CONFIG_DRVR_WRITEBUFFER
+      priv->rwb.wrmaxblocks = CONFIG_MTD_NWRBLOCKS;
+#endif
+#ifdef CONFIG_DRVR_READAHEAD
+      priv->rwb.rhmaxblocks = CONFIG_MTD_NRDBLOCKS;
+#endif
+
+      /* Callouts */
+
+      priv->rwb.dev       = priv;             /* Device state passed to callouts */
+      priv->rwb.wrflush   = mtd_flush;        /* Callout to flush buffer */
+      priv->rwb.rhreload  = mtd_reload;       /* Callout to reload buffer */
+
+      /* Initialize read-ahead/write buffering */
+
+      ret = rwb_initialize(&priv->rwb);
+      if (ret < 0)
+        {
+          fdbg("ERROR: rwb_initialize failed: %d\n", ret);
+          kfree(priv);
+          return NULL;
+        }
+    }
+
+  /* Register the MTD with the procfs system if enabled */
+
+#ifdef CONFIG_MTD_REGISTRATION
+  mtd_register(&priv->mtd, "rwbuffer");
+#endif
+
+  /* Return the implementation-specific state structure as the MTD device */
+
+  fvdbg("Return %p\n", priv);
+  return &priv->mtd;
+}
+
+#endif /* CONFIG_DRVR_WRITEBUFFER || CONFIG_DRVR_READAHEAD */

drivers/mtd/smart.c

@@ -105,7 +105,8 @@
                                              * other for our use, such as format
                                              * sector, etc. */
 
-#if defined(CONFIG_FS_READAHEAD) || (defined(CONFIG_FS_WRITABLE) && defined(CONFIG_FS_WRITEBUFFER))
+#if defined(CONFIG_DRVR_READAHEAD) || (defined(CONFIG_DRVR_WRITABLE) && \
+    defined(CONFIG_DRVR_WRITEBUFFER))
 #  define CONFIG_SMART_RWBUFFER 1
 #endif
 

include/nuttx/rwbuffer.h

@@ -1,7 +1,7 @@
 /****************************************************************************
  * include/nuttx/rwbuffer.h
  *
- *   Copyright (C) 2009 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2009, 2014 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -33,10 +33,6 @@
  *
  ****************************************************************************/
 
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
 #ifndef __INCLUDE_NUTTX_RWBUFFER_H
 #define __INCLUDE_NUTTX_RWBUFFER_H
 
@@ -51,7 +47,7 @@
 #include <semaphore.h>
 #include <nuttx/wqueue.h>
 
-#if defined(CONFIG_FS_WRITEBUFFER) || defined(CONFIG_FS_READAHEAD)
+#if defined(CONFIG_DRVR_WRITEBUFFER) || defined(CONFIG_DRVR_READAHEAD)
 
 /**********************************************************************
  * Pre-processor Definitions
@@ -107,45 +103,50 @@ struct rwbuffer_s
 
   uint16_t      blocksize;       /* The size of one block */
   size_t        nblocks;         /* The total number blocks supported */
-  FAR void     *dev;             /* Device state passed to callout functions */
 
-  /* Write buffer setup.  If CONFIG_FS_WRITEBUFFER is defined, but you
+  /* Read-ahead/Write buffer sizes.  Buffering can be disabled (even if it
-   * want read-ahead-only operation, (1) set wrmaxblocks to zero and do
+   * is enabled in the configuration) by setting the buffer size to zero
-   * not use rwb_write().
+   * blocks.
    */
 
-#ifdef CONFIG_FS_WRITEBUFFER
+#ifdef CONFIG_DRVR_WRITEBUFFER
   uint16_t      wrmaxblocks;     /* The number of blocks to buffer in memory */
-  rwbflush_t    wrflush;         /* Callout to flush the write buffer */
+#endif
+#ifdef CONFIG_DRVR_READAHEAD
+  uint16_t      rhmaxblocks;     /* The number of blocks to buffer in memory */
 #endif
 
-  /* Read-ahead buffer setup.  If CONFIG_FS_READAHEAD is defined but you
+  /* Callback functions.
-   * want write-buffer-only operation, then (1) set rhmaxblocks to zero and
+   *
-   * do not use rwb_read().
+   * wrflush.  This callback is normally used to flush the contents of
+   *   the write buffer.  If write buffering is disabled, then this
+   *   function will instead be used to perform unbuffered writes.
+   * rhrelad.  This callback is normally used to read new data into the
+   *   read-ahead buffer.  If read-ahead buffering is disabled, then this
+   *   function will instead be used to perform unbuffered reads.
    */
 
-#ifdef CONFIG_FS_READAHEAD
+  FAR void     *dev;             /* Device state passed to callout functions */
-  uint16_t      rhmaxblocks;     /* The number of blocks to buffer in memory */
+  rwbflush_t    wrflush;         /* Callout to flush the write buffer */
   rwbreload_t   rhreload;        /* Callout to reload the read-ahead buffer */
-#endif
 
   /********************************************************************/
-  /* The user should never modify any of the remaing fields */
+  /* The user should never modify any of the remaining fields */
 
-  /* This is the state of the write buffer */
+  /* This is the state of the write buffering */
 
-#ifdef CONFIG_FS_WRITEBUFFER
+#ifdef CONFIG_DRVR_WRITEBUFFER
   sem_t         wrsem;           /* Enforces exclusive access to the write buffer */
-  struct work_s work;            /* Delayed work to flush buffer after adelay with no activity */
+  struct work_s work;            /* Delayed work to flush buffer after a delay with no activity */
   uint8_t      *wrbuffer;        /* Allocated write buffer */
   uint16_t      wrnblocks;       /* Number of blocks in write buffer */
   off_t         wrblockstart;    /* First block in write buffer */
   off_t         wrexpectedblock; /* Next block expected */
 #endif
 
-  /* This is the state of the read-ahead buffer */
+  /* This is the state of the read-ahead buffering */
 
-#ifdef CONFIG_FS_READAHEAD
+#ifdef CONFIG_DRVR_READAHEAD
   sem_t         rhsem;           /* Enforces exclusive access to the write buffer */
   uint8_t      *rhbuffer;        /* Allocated read-ahead buffer */
   uint16_t      rhnblocks;       /* Number of blocks in read-ahead buffer */
@@ -160,7 +161,8 @@ struct rwbuffer_s
 #undef EXTERN
 #if defined(__cplusplus)
 #define EXTERN EXTERN "C"
-EXTERN "C" {
+EXTERN "C"
+{
 #else
 #define EXTERN extern
 #endif
@@ -171,22 +173,32 @@ EXTERN "C" {
 
 /* Buffer initialization */
 
-EXTERN int rwb_initialize(FAR struct rwbuffer_s *rwb);
+int rwb_initialize(FAR struct rwbuffer_s *rwb);
-EXTERN void rwb_uninitialize(FAR struct rwbuffer_s *rwb);
+void rwb_uninitialize(FAR struct rwbuffer_s *rwb);
 
-/* Buffer transfers */
+/* Block oriented transfers */
 
-EXTERN ssize_t rwb_read(FAR struct rwbuffer_s *rwb, off_t startblock,
+ssize_t rwb_read(FAR struct rwbuffer_s *rwb, off_t startblock,
-                        size_t blockcount, FAR uint8_t *rdbuffer);
+                 size_t blockcount, FAR uint8_t *rdbuffer);
-EXTERN ssize_t rwb_write(FAR struct rwbuffer_s *rwb,
+ssize_t rwb_write(FAR struct rwbuffer_s *rwb,
-                         off_t startblock, size_t blockcount,
+                  off_t startblock, size_t blockcount,
-                         FAR const uint8_t *wrbuffer);
+                  FAR const uint8_t *wrbuffer);
-EXTERN int rwb_mediaremoved(FAR struct rwbuffer_s *rwb);
+
+/* Character oriented transfers */
+
+ssize_t mtd_readbytes(FAR struct rwbuffer_s *dev, off_t offset,
+                      size_t nbytes, FAR uint8_t *buffer);
+
+/* Media events */
+
+int rwb_mediaremoved(FAR struct rwbuffer_s *rwb);
+int rwb_invalidate(FAR struct rwbuffer_s *rwb,
+                   off_t startblock, size_t blockcount);
 
 #undef EXTERN
 #if defined(__cplusplus)
 }
 #endif
 
-#endif /* CONFIG_FS_WRITEBUFFER || CONFIG_READAHEAD_BUFFER */
+#endif /* CONFIG_DRVR_WRITEBUFFER || CONFIG_DRVR_READAHEAD */
 #endif /* __INCLUDE_NUTTX_RWBUFFER_H */