|
diff --git a/configs/mikroe-stm32f4/Kconfig b/configs/mikroe-stm32f4/Kconfig
index 8e55f0d1740..0790f123a6a 100644
--- a/configs/mikroe-stm32f4/Kconfig
+++ b/configs/mikroe-stm32f4/Kconfig
@@ -5,53 +5,94 @@
if ARCH_BOARD_MIKROE_STM32F4
-config PM_BUTTONS
- bool "PM Button support"
+config MIKROE_FLASH
+ bool "MTD driver for onboard 1M FLASH"
default n
- depends on PM && ARCH_IRQBUTTONS
+ select MTD
+ select MTD_M25P
+ select MTD_SMART
+ select FS_SMARTFS
+ select STM32_SPI3
+ select MTD_BYTE_WRITE
---help---
- Enable PM button EXTI interrupts to support PM testing
+ Configures an MTD device for use with the onboard flash
-config PM_BUTTON_ACTIVITY
- int "Button PM activity weight"
- default 10
- depends on PM_BUTTONS
+config MIKROE_FLASH_MINOR
+ int "Minor number for the FLASH /dev/smart entry"
+ default 0
+ depends on MIKROE_FLASH
---help---
- The activity weight to report to the power management subsystem when a button is pressed.
+ Sets the minor number for the FLASH MTD /dev entry
+
+config MIKROE_FLASH_PART
+ bool "Enable partition support on FLASH"
+ default n
+ depends on MIKROE_FLASH
+ ---help---
+ Enables creation of partitions on the FLASH
+
+config MIKROE_FLASH_PART_LIST
+ string "Flash partition size list"
+ default "256,768"
+ depends on MIKROE_FLASH_PART
+ ---help---
+ Comma separated list of partition sizes in KB
+
+config MIKROE_RAMMTD
+ bool "MTD driver for SMARTFS RAM disk"
+ default n
+ select MTD
+ select RAMMTD
+ ---help---
+ Configures an MTD based RAM device for use with SMARTFS.
+
+config MIKROE_RAMMTD_MINOR
+ int "Minor number for RAM /dev/smart entry"
+ default 1
+ depends on MIKROE_RAMMTD
+ ---help---
+ Sets the minor number for the RAM MTD /dev entry
+
+config MIKROE_RAMMTD_SIZE
+ int "Size in KB of the RAM device to create"
+ default 32
+ depends on MIKROE_RAMMTD
+ ---help---
+ Sets the size of static RAM allocation for the SMART RAM device
config PM_ALARM_SEC
int "PM_STANDBY delay (seconds)"
default 15
depends on PM && RTC_ALARM
- --help---
+ ---help---
Number of seconds to wait in PM_STANDBY before going to PM_STANDBY mode.
config PM_ALARM_NSEC
int "PM_STANDBY delay (nanoseconds)"
default 0
depends on PM && RTC_ALARM
- --help---
+ ---help---
Number of additional nanoseconds to wait in PM_STANDBY before going to PM_STANDBY mode.
config PM_SLEEP_WAKEUP
bool "PM_SLEEP wake-up alarm"
default n
depends on PM && RTC_ALARM
- --help---
+ ---help---
Wake-up of PM_SLEEP mode after a delay and resume normal operation.
config PM_SLEEP_WAKEUP_SEC
int "PM_SLEEP delay (seconds)"
default 10
depends on PM && RTC_ALARM
- --help---
+ ---help---
Number of seconds to wait in PM_SLEEP before going to PM_STANDBY mode.
config PM_SLEEP_WAKEUP_NSEC
int "PM_SLEEP delay (nanoseconds)"
default 0
depends on PM && RTC_ALARM
- --help---
+ ---help---
Number of additional nanoseconds to wait in PM_SLEEP before going to PM_STANDBY mode.
endif
diff --git a/configs/mikroe-stm32f4/README.txt b/configs/mikroe-stm32f4/README.txt
index ed4ecbf2c34..7d46fbc5ceb 100644
--- a/configs/mikroe-stm32f4/README.txt
+++ b/configs/mikroe-stm32f4/README.txt
@@ -2,7 +2,20 @@ README
======
This README discusses issues unique to NuttX configurations for the
-MikroElektronika Mikromedia for STM32F4 development board.
+MikroElektronika Mikromedia for STM32F4 development board. This is
+another board support by NuttX that uses the same STM32F407VGT6 MCU
+as does the STM32F4-Discovery board. This board, however, has very
+different on-board peripherals than does the STM32F4-Discovery:
+
+ - TFT display with touch panel,
+ - VS1053 stereo audio codec with headphone jack,
+ - SD card slot,
+ - Serial FLASH memory,
+ - USB OTG FS with micro-AB connector, and
+ - Battery connect and batter charger circuit.
+
+See the http://www.mikroe.com/mikromedia/stm32-m4/ for more information
+about this board.
Contents
========
diff --git a/configs/mikroe-stm32f4/src/up_nsh.c b/configs/mikroe-stm32f4/src/up_nsh.c
index e92a02e8385..226a715f6d5 100644
--- a/configs/mikroe-stm32f4/src/up_nsh.c
+++ b/configs/mikroe-stm32f4/src/up_nsh.c
@@ -128,9 +128,14 @@
# define CONFIG_EXAMPLES_SMART_NEBLOCKS (22)
# endif
-# undef CONFIG_EXAMPLES_SMART_BUFSIZE
-# define CONFIG_EXAMPLES_SMART_BUFSIZE \
- (CONFIG_RAMMTD_ERASESIZE * CONFIG_EXAMPLES_SMART_NEBLOCKS)
+#ifdef CONFIG_MIKROE_RAMMTD
+# ifndef CONFIG_MIKROE_RAMMTD_MINOR
+# define CONFIG_MIKROE_RAMMTD_MINOR 1
+# endif
+# ifndef CONFIG_MIKROE_RAMMTD_SIZE
+# define CONFIG_MIKROE_RAMMTD_SIZE 32
+# endif
+#endif
/* Debug ********************************************************************/
@@ -151,11 +156,6 @@
/****************************************************************************
* Private Data
****************************************************************************/
-/* Pre-allocated simulated flash */
-
-#ifdef CONFIG_RAMMTD
-//static uint8_t g_simflash[CONFIG_EXAMPLES_SMART_BUFSIZE];
-#endif
/****************************************************************************
* Public Functions
@@ -197,7 +197,7 @@ int nsh_archinitialize(void)
/* Now bind the SPI interface to the M25P8 SPI FLASH driver */
-#ifdef CONFIG_MTD
+#if defined(CONFIG_MTD) && defined(CONFIG_MIKROE_FLASH)
message("nsh_archinitialize: Bind SPI to the SPI flash driver\n");
mtd = m25p_initialize(spi);
if (!mtd)
@@ -208,28 +208,78 @@ int nsh_archinitialize(void)
{
message("nsh_archinitialize: Successfully bound SPI port 3 to the SPI FLASH driver\n");
- /* Now initialize a SMART Flash block device and bind it to the MTD device */
+#ifdef CONFIG_MIKROE_FLASH_PART
+ {
+ int partno;
+ int partsize;
+ int partoffset;
+ const char *partstring = CONFIG_MIKROE_FLASH_PART_LIST;
+ const char *ptr;
+ FAR struct mtd_dev_s *mtd_part;
+ char partname[4];
+
+ /* Now create a partition on the FLASH device */
+
+ partno = 0;
+ ptr = partstring;
+ partoffset = 0;
+ while (*ptr != '\0')
+ {
+ /* Get the partition size */
+
+ partsize = atoi(ptr);
+ mtd_part = mtd_partition(mtd, partoffset, (partsize>>2)*16);
+ partoffset += (partsize >> 2) * 16;
+
+ /* Now initialize a SMART Flash block device and bind it to the MTD device */
#if defined(CONFIG_MTD_SMART) && defined(CONFIG_FS_SMARTFS)
- smart_initialize(0, mtd);
+ sprintf(partname, "p%d", partno);
+ smart_initialize(CONFIG_MIKROE_FLASH_MINOR, mtd_part, partname);
#endif
+
+ /* Update the pointer to point to the next size in the list */
+
+ while ((*ptr >= '0') && (*ptr <= '9'))
+ {
+ ptr++;
+ }
+
+ if (*ptr == ',')
+ {
+ ptr++;
+ }
+
+ /* Increment the part number */
+
+ partno++;
+ }
+ }
+#else /* CONFIG_MIKROE_FLASH_PART */
+
+ /* Configure the device with no partition support */
+
+ smart_initialize(CONFIG_MIKROE_FLASH_MINOR, mtd, NULL);
+
+#endif /* CONFIG_MIKROE_FLASH_PART */
}
/* Create a RAM MTD device if configured */
-#ifdef CONFIG_RAMMTD
+#if defined(CONFIG_RAMMTD) && defined(CONFIG_MIKROE_RAMMTD)
{
- uint8_t *start = (uint8_t *) kmalloc(CONFIG_EXAMPLES_SMART_BUFSIZE);
- mtd = rammtd_initialize(start, CONFIG_EXAMPLES_SMART_BUFSIZE);
+ uint8_t *start = (uint8_t *) kmalloc(CONFIG_MIKROE_RAMMTD_SIZE * 1024);
+ mtd = rammtd_initialize(start, CONFIG_MIKROE_RAMMTD_SIZE * 1024);
mtd->ioctl(mtd, MTDIOC_BULKERASE, 0);
/* Now initialize a SMART Flash block device and bind it to the MTD device */
+
#if defined(CONFIG_MTD_SMART) && defined(CONFIG_FS_SMARTFS)
- smart_initialize(1, mtd);
+ smart_initialize(CONFIG_MIKROE_RAMMTD_MINOR, mtd, NULL);
#endif
}
-#endif /* CONFIG_RAMMTD */
+#endif /* CONFIG_RAMMTD && CONFIG_MIKROE_RAMMTD */
#endif /* CONFIG_MTD */
#endif /* CONFIG_STM32_SPI3 */
diff --git a/configs/mikroe-stm32f4/usbnsh/defconfig b/configs/mikroe-stm32f4/usbnsh/defconfig
index 29e948be5f5..3340a95e677 100644
--- a/configs/mikroe-stm32f4/usbnsh/defconfig
+++ b/configs/mikroe-stm32f4/usbnsh/defconfig
@@ -16,7 +16,7 @@ CONFIG_HOST_LINUX=y
#
# Build Configuration
#
-# CONFIG_APPS_DIR="../apps"
+CONFIG_APPS_DIR="../apps"
# CONFIG_BUILD_2PASS is not set
#
@@ -38,27 +38,8 @@ CONFIG_RAW_BINARY=y
#
# Debug Options
#
-CONFIG_DEBUG=y
-# CONFIG_DEBUG_VERBOSE is not set
-
-#
-# Subsystem Debug Options
-#
-# CONFIG_DEBUG_MM is not set
-# CONFIG_DEBUG_SCHED is not set
-# CONFIG_DEBUG_USB is not set
-CONFIG_DEBUG_FS=y
-# CONFIG_DEBUG_LIB is not set
-# CONFIG_DEBUG_BINFMT is not set
-# CONFIG_DEBUG_GRAPHICS is not set
-
-#
-# Driver Debug Options
-#
-# CONFIG_DEBUG_ANALOG is not set
-# CONFIG_DEBUG_SPI is not set
-# CONFIG_DEBUG_GPIO is not set
-CONFIG_DEBUG_SYMBOLS=y
+# CONFIG_DEBUG is not set
+# CONFIG_DEBUG_SYMBOLS is not set
#
# System Type
@@ -104,7 +85,6 @@ CONFIG_ARCH_HAVE_CMNVECTOR=y
# CONFIG_ARCH_FPU is not set
CONFIG_ARCH_HAVE_MPU=y
# CONFIG_ARMV7M_MPU is not set
-# CONFIG_DEBUG_HARDFAULT is not set
#
# ARMV7M Configuration Options
@@ -310,6 +290,13 @@ CONFIG_NSH_MMCSDSPIPORTNO=0
#
# Board-Specific Options
#
+CONFIG_MIKROE_FLASH=y
+CONFIG_MIKROE_FLASH_MINOR=0
+CONFIG_MIKROE_FLASH_PART=y
+CONFIG_MIKROE_FLASH_PART_LIST="256,768"
+CONFIG_MIKROE_RAMMTD=y
+CONFIG_MIKROE_RAMMTD_MINOR=1
+CONFIG_MIKROE_RAMMTD_SIZE=32
#
# RTOS Features
@@ -408,21 +395,27 @@ CONFIG_MMCSD_SPI=y
CONFIG_MMCSD_SPICLOCK=20000000
# CONFIG_MMCSD_SDIO is not set
CONFIG_MTD=y
-# CONFIG_MTD_PARTITION is not set
+
+#
+# MTD Configuration
+#
+CONFIG_MTD_PARTITION=y
+CONFIG_MTD_BYTE_WRITE=y
+
+#
+# MTD Device Drivers
+#
CONFIG_RAMMTD=y
CONFIG_RAMMTD_BLOCKSIZE=512
CONFIG_RAMMTD_ERASESIZE=4096
CONFIG_RAMMTD_ERASESTATE=0xff
# CONFIG_RAMMTD_FLASHSIM is not set
-CONFIG_RAMMTD_SMART=y
# CONFIG_MTD_AT24XX is not set
# CONFIG_MTD_AT45DB is not set
CONFIG_MTD_M25P=y
CONFIG_M25P_SPIMODE=0
CONFIG_M25P_MANUFACTURER=0x1C
CONFIG_M25P_MEMORY_TYPE=0x31
-CONFIG_M25P_SUBSECTOR_ERASE=y
-CONFIG_M25P_BYTEWRITE=y
CONFIG_MTD_SMART=y
CONFIG_MTD_SMART_SECTOR_SIZE=512
# CONFIG_MTD_RAMTRON is not set
@@ -441,7 +434,6 @@ CONFIG_SERIAL_REMOVABLE=y
CONFIG_ARCH_HAVE_USART2=y
CONFIG_MCU_SERIAL=y
CONFIG_STANDARD_SERIAL=y
-# CONFIG_SERIAL_TIOCSERGSTRUCT is not set
# CONFIG_USART2_SERIAL_CONSOLE is not set
CONFIG_NO_SERIAL_CONSOLE=y
@@ -529,7 +521,7 @@ CONFIG_FS_ROMFS=y
CONFIG_FS_SMARTFS=y
CONFIG_SMARTFS_ERASEDSTATE=0xff
CONFIG_SMARTFS_MAXNAMLEN=16
-CONFIG_SMARTFS_MULTI_ROOT_DIRS=y
+# CONFIG_SMARTFS_MULTI_ROOT_DIRS is not set
# CONFIG_FS_BINFS is not set
#
@@ -650,6 +642,7 @@ CONFIG_EXAMPLES_NSH=y
# CONFIG_EXAMPLES_NX is not set
# CONFIG_EXAMPLES_NXCONSOLE is not set
# CONFIG_EXAMPLES_NXFFS is not set
+# CONFIG_EXAMPLES_SMART is not set
# CONFIG_EXAMPLES_NXFLAT is not set
# CONFIG_EXAMPLES_NXHELLO is not set
# CONFIG_EXAMPLES_NXIMAGE is not set
@@ -664,8 +657,8 @@ CONFIG_EXAMPLES_NSH=y
# CONFIG_EXAMPLES_ROMFS is not set
# CONFIG_EXAMPLES_SENDMAIL is not set
# CONFIG_EXAMPLES_SERLOOP is not set
-CONFIG_EXAMPLES_FLASH_TEST=y
-CONFIG_EXAMPLES_SMART_TEST=y
+# CONFIG_EXAMPLES_FLASH_TEST is not set
+# CONFIG_EXAMPLES_SMART_TEST is not set
# CONFIG_EXAMPLES_TELNETD is not set
# CONFIG_EXAMPLES_THTTPD is not set
# CONFIG_EXAMPLES_TIFF is not set
@@ -774,23 +767,13 @@ CONFIG_NSH_LINELEN=64
CONFIG_NSH_NESTDEPTH=3
# CONFIG_NSH_DISABLESCRIPT is not set
# CONFIG_NSH_DISABLEBG is not set
-CONFIG_NSH_ROMFSETC=y
-# CONFIG_NSH_ROMFSRC is not set
-CONFIG_NSH_ROMFSMOUNTPT="/etc"
-CONFIG_NSH_INITSCRIPT="init.d/rcS"
-CONFIG_NSH_ROMFSDEVNO=0
-CONFIG_NSH_ROMFSSECTSIZE=64
-CONFIG_NSH_FATDEVNO=0
-CONFIG_NSH_FATSECTSIZE=512
-CONFIG_NSH_FATNSECTORS=1024
-CONFIG_NSH_FATMOUNTPT="/tmp"
+# CONFIG_NSH_ROMFSETC is not set
CONFIG_NSH_CONSOLE=y
# CONFIG_NSH_USBCONSOLE is not set
#
# USB Trace Support
#
-# CONFIG_NSH_USBDEV_TRACE is not set
# CONFIG_NSH_CONDEV is not set
CONFIG_NSH_ARCHINIT=y
diff --git a/configs/stm32f4discovery/README.txt b/configs/stm32f4discovery/README.txt
index f5a26141091..684c916f565 100644
--- a/configs/stm32f4discovery/README.txt
+++ b/configs/stm32f4discovery/README.txt
@@ -2,7 +2,20 @@ README
======
This README discusses issues unique to NuttX configurations for the
-STMicro STM32F4Discovery development board.
+STMicro STM32F4Discovery development board featuring the STM32F407VGT6
+MCU. The STM32F407VGT6 is a 168MHz Cortex-M4 operation with 1Mbit Flash
+memory and 128kbytes. The board features:
+
+ - On-board ST-LINK/V2 for programming and debugging,
+ - LIS302DL, ST MEMS motion sensor, 3-axis digital output accelerometer,
+ - MP45DT02, ST MEMS audio sensor, omni-directional digital microphone,
+ - CS43L22, audio DAC with integrated class D speaker driver,
+ - Eight LEDs and two push-buttons,
+ - USB OTG FS with micro-AB connector, and
+ - Easy access to most MCU pins.
+
+Refer to http://www.st.com/internet/evalboard/product/252419.jsp for
+further information about this board.
Contents
========
diff --git a/drivers/mtd/Kconfig b/drivers/mtd/Kconfig
index 310f494d82c..4754fbeb7ed 100644
--- a/drivers/mtd/Kconfig
+++ b/drivers/mtd/Kconfig
@@ -64,13 +64,6 @@ config RAMMTD_FLASHSIM
RAMMTD_FLASHSIM will add some extra logic to improve the level of
FLASH simulation.
-config RAMMTD_SMART
- bool "SMART block driver support in the RAM MTD driver"
- default n
- ---help---
- Builds in additional ioctl and interface code to support the
- SMART block driver / filesystem.
-
endif
config MTD_AT24XX
@@ -139,30 +132,14 @@ config M25P_MEMORY_TYPE
---help---
The memory type for M25 "P" series is 0x20, but the driver also supports "F" series
devices, such as the EON EN25F80 part which adds a 4K sector erase capability. The
- ID for "F" series parts from EON is 0x31.
-
-config M25P_SUBSECTOR_ERASE
- bool "Sub-Sector Erase"
- default n
- ---help---
- Some devices (such as the EON EN25F80) support a smaller erase block
- size (4K vs 64K). This option enables support for sub-sector erase.
- The SMART file system can take advantage of this option if it is enabled.
-
-config M25P_BYTEWRITE
- bool "Enable ByteWrite ioctl support"
- default n
- ---help---
- The M25P series of devices allow writing to a page with less than a full-page
- size of data. In this case, only the written bytes are updated without affecting
- the other bytes in the page. The SMART FS requires this option for proper operation.
+ memory type for "F" series parts from EON is 0x31. The 4K sector erase size will
+ automatically be enabled when filessytems that can use it are enabled, such as SMART.
endif
config MTD_SMART
bool "Sector Mapped Allocation for Really Tiny (SMART) Flash support"
default y
- select M25P_BYTEWRITE
---help---
The MP25x series of Flash devices are typically very small and have a very large
erase block size. This causes issues with the standard Flash Translation Layer
diff --git a/drivers/mtd/m25px.c b/drivers/mtd/m25px.c
index bfe21a7ddd4..17f7a0672f4 100644
--- a/drivers/mtd/m25px.c
+++ b/drivers/mtd/m25px.c
@@ -3,7 +3,7 @@
* Driver for SPI-based M25P1 (128Kbit), M25P64 (32Mbit), M25P64 (64Mbit), and
* M25P128 (128Mbit) FLASH (and compatible).
*
- * Copyright (C) 2009-2011 Gregory Nutt. All rights reserved.
+ * Copyright (C) 2009-2011, 2013 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt
*
* Redistribution and use in source and binary forms, with or without
@@ -114,6 +114,7 @@
#define M25P_EN25F80_PAGE_SHIFT 8 /* Page size 1 << 8 = 256 */
#define M25P_EN25F80_NPAGES 4096
#define M25P_EN25F80_SUBSECT_SHIFT 12 /* Sub-Sector size 1 << 12 = 4,096 */
+#define M25P_EN25F80_NSUBSECTORS 256
/* M25P32 capacity is 4,194,304 bytes:
* (64 sectors) * (65,536 bytes per sector)
@@ -203,7 +204,7 @@ struct m25p_dev_s
uint8_t pageshift; /* 8 */
uint16_t nsectors; /* 128 or 64 */
uint32_t npages; /* 32,768 or 65,536 */
-#ifdef CONFIG_M25P_SUBSECTOR_ERASE
+#ifdef CONFIG_MTD_SMART
uint8_t subsectorshift; /* 0, 12 or 13 (4K or 8K) */
#endif
};
@@ -219,13 +220,10 @@ static inline void m25p_unlock(FAR struct spi_dev_s *dev);
static inline int m25p_readid(struct m25p_dev_s *priv);
static void m25p_waitwritecomplete(struct m25p_dev_s *priv);
static void m25p_writeenable(struct m25p_dev_s *priv);
-static inline void m25p_sectorerase(struct m25p_dev_s *priv, off_t offset);
+static inline void m25p_sectorerase(struct m25p_dev_s *priv, off_t offset, uint8_t type);
static inline int m25p_bulkerase(struct m25p_dev_s *priv);
static inline void m25p_pagewrite(struct m25p_dev_s *priv, FAR const uint8_t *buffer,
off_t offset);
-#ifdef CONFIG_M25P_SUBSECTOR_ERASE
-static inline void m25p_subsectorerase(struct m25p_dev_s *priv, off_t offset);
-#endif
/* MTD driver methods */
@@ -236,6 +234,10 @@ static ssize_t m25p_bwrite(FAR struct mtd_dev_s *dev, off_t startblock,
size_t nblocks, FAR const uint8_t *buf);
static ssize_t m25p_read(FAR struct mtd_dev_s *dev, off_t offset, size_t nbytes,
FAR uint8_t *buffer);
+#ifdef CONFIG_MTD_BYTE_WRITE
+static ssize_t m25p_write(FAR struct mtd_dev_s *dev, off_t offset, size_t nbytes,
+ FAR const uint8_t *buffer);
+#endif
static int m25p_ioctl(FAR struct mtd_dev_s *dev, int cmd, unsigned long arg);
/************************************************************************************
@@ -320,7 +322,7 @@ static inline int m25p_readid(struct m25p_dev_s *priv)
{
/* Okay.. is it a FLASH capacity that we understand? */
-#ifdef CONFIG_M25P_SUBSECTOR_ERASE
+#ifdef CONFIG_MTD_SMART
priv->subsectorshift = 0;
#endif
@@ -338,11 +340,11 @@ static inline int m25p_readid(struct m25p_dev_s *priv)
{
/* Save the FLASH geometry */
- priv->sectorshift = M25P_EN25F80_SECTOR_SHIFT;
- priv->nsectors = M25P_EN25F80_NSECTORS;
priv->pageshift = M25P_EN25F80_PAGE_SHIFT;
priv->npages = M25P_EN25F80_NPAGES;
-#ifdef CONFIG_M25P_SUBSECTOR_ERASE
+ priv->sectorshift = M25P_EN25F80_SECTOR_SHIFT;
+ priv->nsectors = M25P_EN25F80_NSECTORS;
+#ifdef CONFIG_MTD_SMART
priv->subsectorshift = M25P_EN25F80_SUBSECT_SHIFT;
#endif
return OK;
@@ -480,9 +482,20 @@ static void m25p_writeenable(struct m25p_dev_s *priv)
* Name: m25p_sectorerase
************************************************************************************/
-static inline void m25p_sectorerase(struct m25p_dev_s *priv, off_t sector)
+static void m25p_sectorerase(struct m25p_dev_s *priv, off_t sector, uint8_t type)
{
- off_t offset = sector << priv->sectorshift;
+ off_t offset;
+
+#ifdef CONFIG_MTD_SMART
+ if (priv->subsectorshift > 0)
+ {
+ offset = sector << priv->subsectorshift;
+ }
+ else
+#endif
+ {
+ offset = sector << priv->sectorshift;
+ }
fvdbg("sector: %08lx\n", (long)sector);
@@ -502,9 +515,11 @@ static inline void m25p_sectorerase(struct m25p_dev_s *priv, off_t sector)
SPI_SELECT(priv->dev, SPIDEV_FLASH, true);
- /* Send the "Sector Erase (SE)" instruction */
+ /* Send the "Sector Erase (SE)" or Sub-Sector Erase (SSE) instruction
+ * that was passed in as the erase type.
+ */
- (void)SPI_SEND(priv->dev, M25P_SE);
+ (void)SPI_SEND(priv->dev, type);
/* Send the sector offset high byte first. For all of the supported
* parts, the sector number is completely contained in the first byte
@@ -521,53 +536,6 @@ static inline void m25p_sectorerase(struct m25p_dev_s *priv, off_t sector)
fvdbg("Erased\n");
}
-/************************************************************************************
- * Name: m25p_subsectorerase
- ************************************************************************************/
-
-#ifdef CONFIG_M25P_SUBSECTOR_ERASE
-static inline void m25p_subsectorerase(struct m25p_dev_s *priv, off_t subsector)
-{
- off_t offset = subsector << priv->subsectorshift;
-
- fvdbg("subsector: %9lx\n", (long)subsector);
-
- /* 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.
- */
-
- m25p_waitwritecomplete(priv);
-
- /* Send write enable instruction */
-
- m25p_writeenable(priv);
-
- /* Select this FLASH part */
-
- SPI_SELECT(priv->dev, SPIDEV_FLASH, true);
-
- /* Send the "Sub-Sector Erase (SSE)" instruction */
-
- (void)SPI_SEND(priv->dev, M25P_SSE);
-
- /* 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");
-}
-#endif
-
/************************************************************************************
* Name: m25p_bulkerase
************************************************************************************/
@@ -654,7 +622,7 @@ static inline void m25p_pagewrite(struct m25p_dev_s *priv, FAR const uint8_t *bu
* Name: m25p_bytewrite
************************************************************************************/
-#ifdef CONFIG_M25P_BYTEWRITE
+#ifdef CONFIG_MTD_BYTE_WRITE
static inline void m25p_bytewrite(struct m25p_dev_s *priv, FAR const uint8_t *buffer,
off_t offset, uint16_t count)
{
@@ -711,13 +679,55 @@ static int m25p_erase(FAR struct mtd_dev_s *dev, off_t startblock, size_t nblock
/* Lock access to the SPI bus until we complete the erase */
m25p_lock(priv->dev);
- while (blocksleft-- > 0)
+ while (blocksleft > 0)
{
- /* Erase each sector */
+#ifdef CONFIG_MTD_SMART
+ size_t sectorboundry;
+ size_t blkper;
- m25p_sectorerase(priv, startblock);
+ /* If we have a smaller erase size, then we will find as many full
+ * sector erase blocks as possible to speed up the process instead of
+ * erasing everything in smaller chunks.
+ */
+
+ if (priv->subsectorshift > 0)
+ {
+ blkper = 1 << (priv->sectorshift - priv->subsectorshift);
+ sectorboundry = (startblock + blkper - 1) / blkper;
+ sectorboundry *= blkper;
+
+ /* If we are on a sector boundry and have at least a full sector
+ * of blocks left to erase, then we can do a full sector erase.
+ */
+
+ if (startblock == sectorboundry && blocksleft >= blkper)
+ {
+ /* Do a full sector erase */
+
+ m25p_sectorerase(priv, startblock / blkper, M25P_SE);
+ startblock += blkper;
+ blocksleft -= blkper;
+ continue;
+ }
+ else
+ {
+ /* Just do a sub-sector erase */
+
+ m25p_sectorerase(priv, startblock, M25P_SSE);
+ startblock++;
+ blocksleft--;
+ continue;
+ }
+ }
+#endif
+
+ /* Not using sub-sector erase. Erase each full sector */
+
+ m25p_sectorerase(priv, startblock, M25P_SE);
startblock++;
+ blocksleft--;
}
+
m25p_unlock(priv->dev);
return (int)nblocks;
}
@@ -741,6 +751,7 @@ static ssize_t m25p_bread(FAR struct mtd_dev_s *dev, off_t startblock, size_t nb
{
return nbytes >> priv->pageshift;
}
+
return (int)nbytes;
}
@@ -766,8 +777,8 @@ static ssize_t m25p_bwrite(FAR struct mtd_dev_s *dev, off_t startblock, size_t n
buffer += pagesize;
startblock++;
}
- m25p_unlock(priv->dev);
+ m25p_unlock(priv->dev);
return nblocks;
}
@@ -817,6 +828,78 @@ static ssize_t m25p_read(FAR struct mtd_dev_s *dev, off_t offset, size_t nbytes,
return nbytes;
}
+/************************************************************************************
+ * Name: m25p_write
+ ************************************************************************************/
+
+#ifdef CONFIG_MTD_BYTE_WRITE
+static ssize_t m25p_write(FAR struct mtd_dev_s *dev, off_t offset, size_t nbytes,
+ FAR const uint8_t *buffer)
+{
+ FAR struct m25p_dev_s *priv = (FAR struct m25p_dev_s *)dev;
+ int startpage;
+ int endpage;
+ int count;
+ int index;
+ int pagesize;
+ int bytestowrite;
+
+ fvdbg("offset: %08lx nbytes: %d\n", (long)offset, (int)nbytes);
+
+ /* We must test if the offset + count crosses one or more pages
+ * and perform individual writes. The devices can only write in
+ * page increments.
+ */
+
+ startpage = offset / (1 << priv->pageshift);
+ endpage = (offset + nbytes) / (1 << priv->pageshift);
+
+ if (startpage == endpage)
+ {
+ /* All bytes within one programmable page. Just do the write. */
+
+ m25p_bytewrite(priv, buffer, offset, nbytes);
+ }
+ else
+ {
+ /* Write the 1st partial-page */
+
+ count = nbytes;
+ pagesize = (1 << priv->pageshift);
+ bytestowrite = pagesize - (offset & (pagesize-1));
+ m25p_bytewrite(priv, buffer, offset, bytestowrite);
+
+ /* Update offset and count */
+
+ offset += bytestowrite;
+ count -= bytestowrite;
+ index = bytestowrite;
+
+ /* Write full pages */
+
+ while (count >= pagesize)
+ {
+ m25p_bytewrite(priv, &buffer[index], offset, pagesize);
+
+ /* Update offset and count */
+
+ offset += pagesize;
+ count -= pagesize;
+ index += pagesize;
+ }
+
+ /* Now write any partial page at the end */
+
+ if (count > 0)
+ {
+ m25p_bytewrite(priv, &buffer[index], offset, count);
+ }
+ }
+
+ return nbytes;
+}
+#endif /* CONFIG_MTD_BYTE_WRITE */
+
/************************************************************************************
* Name: m25p_ioctl
************************************************************************************/
@@ -844,15 +927,22 @@ static int m25p_ioctl(FAR struct mtd_dev_s *dev, int cmd, unsigned long arg)
* appear so.
*/
- geo->blocksize = (1 << priv->pageshift);
- geo->erasesize = (1 << priv->sectorshift);
- geo->neraseblocks = priv->nsectors;
-#ifdef CONFIG_M25P_SUBSECTOR_ERASE
- geo->subsectorsize = (1 << priv->subsectorshift);
- geo->nsubsectors = priv->nsectors * (1 << (priv->sectorshift -
- priv->subsectorshift));
+ geo->blocksize = (1 << priv->pageshift);
+#ifdef CONFIG_MTD_SMART
+ if (priv->subsectorshift > 0)
+ {
+ geo->erasesize = (1 << priv->subsectorshift);
+ geo->neraseblocks = priv->nsectors * (1 << (priv->sectorshift -
+ priv->subsectorshift));
+ }
+ else
#endif
- ret = OK;
+ {
+ 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);
@@ -870,97 +960,6 @@ static int m25p_ioctl(FAR struct mtd_dev_s *dev, int cmd, unsigned long arg)
}
break;
-#ifdef CONFIG_FS_SMARTFS
- case MTDIOC_GETCAPS:
- {
- ret = 0;
-#ifdef CONFIG_M25P_BYTEWRITE
- ret |= MTDIOC_CAPS_BYTEWRITE;
-#endif
-
-#ifdef CONFIG_M25P_SUBSECTOR_ERASE
- ret |= MTDIOC_CAPS_SECTERASE;
-#endif
- break;
- }
-#endif /* CONFIG_FS_SMARTFS */
-
-#ifdef CONFIG_M25P_SUBSECTOR_ERASE
- case MTDIOC_SECTERASE:
- {
- m25p_subsectorerase(priv, (off_t) arg);
- ret = OK;
- break;
- }
-#endif
-
-#ifdef CONFIG_M25P_BYTEWRITE
- case MTDIOC_BYTEWRITE:
- {
- struct mtd_byte_write_s *bytewrite = (struct mtd_byte_write_s *) arg;
- int startpage;
- int endpage;
- int count;
- int index;
- int pagesize;
- int bytestowrite;
- size_t offset;
-
- /* We must test if the offset + count crosses one or more pages
- * and perform individual writes. The devices can only write in
- * page increments.
- */
-
- startpage = bytewrite->offset / (1 << priv->pageshift);
- endpage = (bytewrite->offset + bytewrite->count) / (1 << priv->pageshift);
-
- if (startpage == endpage)
- {
- m25p_bytewrite(priv, bytewrite->buffer, bytewrite->offset,
- bytewrite->count);
- }
- else
- {
- /* Write the 1st partial-page */
-
- count = bytewrite->count;
- pagesize = (1 << priv->pageshift);
- offset = bytewrite->offset;
- bytestowrite = pagesize - (bytewrite->offset & (pagesize-1));
- m25p_bytewrite(priv, bytewrite->buffer, offset, bytestowrite);
-
- /* Update offset and count */
-
- offset += bytestowrite;
- count -= bytestowrite;
- index = bytestowrite;
-
- /* Write full pages */
-
- while (count >= pagesize)
- {
- m25p_bytewrite(priv, &bytewrite->buffer[index], offset, pagesize);
-
- /* Update offset and count */
-
- offset += pagesize;
- count -= pagesize;
- index += pagesize;
- }
-
- /* Now write any partial page at the end */
-
- if (count > 0)
- {
- m25p_bytewrite(priv, &bytewrite->buffer[index], offset, count);
- }
- }
-
- ret = OK;
- break;
- }
-#endif
-
case MTDIOC_XIPBASE:
default:
ret = -ENOTTY; /* Bad command */
@@ -1010,6 +1009,9 @@ FAR struct mtd_dev_s *m25p_initialize(FAR struct spi_dev_s *dev)
priv->mtd.bread = m25p_bread;
priv->mtd.bwrite = m25p_bwrite;
priv->mtd.read = m25p_read;
+#ifdef CONFIG_MTD_BYTE_WRITE
+ priv->mtd.write = m25p_write;
+#endif
priv->mtd.ioctl = m25p_ioctl;
priv->dev = dev;
diff --git a/drivers/mtd/mtd_partition.c b/drivers/mtd/mtd_partition.c
index 1bff0af9c97..699a2fa5a67 100644
--- a/drivers/mtd/mtd_partition.c
+++ b/drivers/mtd/mtd_partition.c
@@ -137,7 +137,7 @@ static bool part_bytecheck(FAR struct mtd_partition_s *priv, off_t byoff)
erasesize = priv->blocksize * priv->blkpererase;
readend = (byoff + erasesize - 1) / erasesize;
- return readend < priv->neraseblocks;
+ return readend <= priv->neraseblocks;
}
/****************************************************************************
@@ -410,6 +410,12 @@ static int part_ioctl(FAR struct mtd_dev_s *dev, int cmd, unsigned long arg)
* sector count (where the size of a sector is provided the by parent MTD
* driver).
*
+ * NOTE: Since there may be a number of MTD partition drivers operating on
+ * the same, underlying FLASH driver, that FLASH driver must be capable
+ * of enforcing mutually exclusive access to the FLASH device. Without
+ * partitions, that mutual exclusion would be provided by the file system
+ * above the FLASH driver.
+ *
****************************************************************************/
FAR struct mtd_dev_s *mtd_partition(FAR struct mtd_dev_s *mtd, off_t firstblock,
@@ -483,6 +489,9 @@ FAR struct mtd_dev_s *mtd_partition(FAR struct mtd_dev_s *mtd, off_t firstblock,
part->child.bwrite = part_bwrite;
part->child.read = mtd->read ? part_read : NULL;
part->child.ioctl = part_ioctl;
+#ifdef CONFIG_MTD_BYTE_WRITE
+ part->child.write = mtd->write ? part_write : NULL;
+#endif
part->parent = mtd;
part->firstblock = erasestart * blkpererase;
diff --git a/drivers/mtd/rammtd.c b/drivers/mtd/rammtd.c
index 461cd7d9992..137f91f735a 100644
--- a/drivers/mtd/rammtd.c
+++ b/drivers/mtd/rammtd.c
@@ -228,7 +228,7 @@ static int ram_erase(FAR struct mtd_dev_s *dev, off_t startblock, size_t nblocks
* Name: ram_readbytes
****************************************************************************/
-#ifdef CONFIG_RAMMTD_SMART
+#ifdef CONFIG_MTD_SMART
static ssize_t ram_read_bytes(FAR struct mtd_dev_s *dev, off_t offset,
size_t nbytes, FAR uint8_t *buf)
{
@@ -328,6 +328,34 @@ static ssize_t ram_bwrite(FAR struct mtd_dev_s *dev, off_t startblock,
return nblocks;
}
+/****************************************************************************
+ * Name: ram_bytewrite
+ ****************************************************************************/
+
+#ifdef CONFIG_MTD_BYTE_WRITE
+static ssize_t ram_bytewrite(FAR struct mtd_dev_s *dev, off_t offset,
+ size_t nbytes, FAR const uint8_t *buf)
+{
+ FAR struct ram_dev_s *priv = (FAR struct ram_dev_s *)dev;
+ off_t maxaddr;
+
+ DEBUGASSERT(dev && buf);
+
+ /* Don't let the write exceed the size of the ram buffer */
+
+ maxaddr = priv->nblocks * CONFIG_RAMMTD_ERASESIZE;
+ if (offset + nbytes > maxaddr)
+ {
+ return 0;
+ }
+
+ /* Then write the data to RAM */
+
+ ram_write(&priv->start[offset], buf, nbytes);
+ return nbytes;
+}
+#endif
+
/****************************************************************************
* Name: ram_ioctl
****************************************************************************/
@@ -380,24 +408,6 @@ static int ram_ioctl(FAR struct mtd_dev_s *dev, int cmd, unsigned long arg)
}
break;
-#ifdef CONFIG_RAMMTD_SMART
- case MTDIOC_GETCAPS:
- {
- ret = MTDIOC_CAPS_BYTEWRITE;
- break;
- }
-
- case MTDIOC_BYTEWRITE:
- {
- struct mtd_byte_write_s *bytewrite = (struct mtd_byte_write_s *) arg;
-
- ram_write(&priv->start[bytewrite->offset], bytewrite->buffer,
- bytewrite->count);
- ret = OK;
- break;
- }
-#endif
-
default:
ret = -ENOTTY; /* Bad command */
break;
@@ -454,9 +464,14 @@ FAR struct mtd_dev_s *rammtd_initialize(FAR uint8_t *start, size_t size)
priv->mtd.bwrite = ram_bwrite;
priv->mtd.ioctl = ram_ioctl;
priv->mtd.erase = ram_erase;
+#ifdef CONFIG_MTD_BYTE_WRITE
+ priv->mtd.write = ram_bytewrite;
+#endif
-#ifdef CONFIG_RAMMTD_SMART
+#ifdef CONFIG_MTD_SMART
priv->mtd.read = ram_read_bytes;
+#else
+ priv->mtd.read = NULL;
#endif
priv->start = start;
diff --git a/drivers/mtd/smart.c b/drivers/mtd/smart.c
index 9de557b5ff1..35a367e5b2a 100644
--- a/drivers/mtd/smart.c
+++ b/drivers/mtd/smart.c
@@ -97,7 +97,7 @@
#define SMART_FMT_VERSION 1
-#define SMART_FIRST_ALLOC_SECTOR 16 /* First logical sector number we will
+#define SMART_FIRST_ALLOC_SECTOR 12 /* First logical sector number we will
* use for assignment of requested Alloc
* sectors. All enries below this are
* reserved (some for root dir entries,
@@ -134,6 +134,7 @@ struct smart_struct_s
FAR uint8_t *releasecount; /* Count of released sectors per erase block */
FAR uint8_t *freecount; /* Count of free sectors per erase block */
FAR char *rwbuffer; /* Our sector read/write buffer */
+ const FAR char *partname; /* Optional partition name */
uint8_t formatversion; /* Format version on the device */
uint8_t formatstatus; /* Indicates the status of the device format */
uint8_t namesize; /* Length of filenames on this device */
@@ -471,49 +472,21 @@ static int smart_setsectorsize(struct smart_struct_s *dev, uint16_t size)
{
uint32_t erasesize;
uint32_t totalsectors;
- int ret;
- /* Check if the device supports sub-sector erase regions. If it does, then
- * use the sub-sector erase size instead of the larger erase size to
- * provide finer granularity.
- */
+ /* Validate the size isn't zero so we don't divide by zero below */
-#ifdef CONFIG_MTD_SUBSECTOR_ERASE
- ret = MTD_IOCTL(dev->mtd, MTDIOC_GETCAPS, 0);
- if (ret >= 0)
+ if (size == 0)
{
- /* The block device supports the GETCAPS ioctl. Now check if sub-sector
- * erase is supported.
- */
-
- if (!(ret & MTDIOC_CAPS_SECTERASE))
- {
- /* Ensure the subsector size is zero */
- dev->geo.subsectorsize = 0;
- dev->geo.nsubsectors = 0;
- }
+ size = CONFIG_MTD_SMART_SECTOR_SIZE;
}
- /* Now calculate the variables */
-
- if (dev->geo.subsectorsize != 0)
- {
- /* Use the sub-sector erase size */
-
- erasesize = dev->geo.subsectorsize;
- dev->neraseblocks = dev->geo.nsubsectors;
- }
- else
-#endif /* CONFIG_MTD_SUBSECTOR_ERASE */
- {
- erasesize = dev->geo.erasesize;
- dev->neraseblocks = dev->geo.neraseblocks;
- }
+ erasesize = dev->geo.erasesize;
+ dev->neraseblocks = dev->geo.neraseblocks;
/* Most FLASH devices have erase size of 64K, but geo.erasesize is only
* 16 bits, so it will be zero
*/
-
+
if (erasesize == 0)
{
erasesize = 65536;
@@ -568,6 +541,74 @@ static int smart_setsectorsize(struct smart_struct_s *dev, uint16_t size)
return OK;
}
+/****************************************************************************
+ * Name: smart_bytewrite
+ *
+ * Description: Writes a non-page size count of bytes to the underlying
+ * MTD device. If the MTD driver supports a direct impl of
+ * write, then it uses it, otherwise it does a read-modify-write
+ * and depends on the architecture of the flash to only program
+ * bits that acutally changed.
+ *
+ ****************************************************************************/
+
+static ssize_t smart_bytewrite(struct smart_struct_s *dev, size_t offset,
+ int nbytes, const uint8_t *buffer)
+{
+ ssize_t ret;
+
+#ifdef CONFIG_MTD_BYTE_WRITE
+ /* Check if the underlying MTD device supports write */
+
+ if (dev->mtd->write != NULL)
+ {
+ /* Use the MTD's write method to write individual bytes */
+
+ ret = dev->mtd->write(dev->mtd, offset, nbytes, buffer);
+ }
+ else
+#endif
+ {
+ /* Perform block-based read-modify-write */
+
+ uint16_t startblock;
+ uint16_t nblocks;
+
+ /* First calculate the start block and number of blocks affected */
+
+ startblock = offset / dev->geo.blocksize;
+ nblocks = (nbytes + dev->geo.blocksize-1) / dev->geo.blocksize;
+ DEBUGASSERT(nblocks <= dev->mtdBlksPerSector);
+
+ /* Do a block read */
+
+ ret = MTD_BREAD(dev->mtd, startblock, nblocks, (uint8_t *) dev->rwbuffer);
+ if (ret < 0)
+ {
+ fdbg("Error %d reading from device\n", -ret);
+ goto errout;
+ }
+
+ /* Modify the data */
+
+ memcpy(&dev->rwbuffer[offset - startblock * dev->geo.blocksize], buffer, nbytes);
+
+ /* Write the data back to the device */
+
+ ret = MTD_BWRITE(dev->mtd, startblock, nblocks, (uint8_t *) dev->rwbuffer);
+ if (ret < 0)
+ {
+ fdbg("Error %d writing to device\n", -ret);
+ goto errout;
+ }
+ }
+
+ ret = nbytes;
+
+errout:
+ return ret;
+}
+
/****************************************************************************
* Name: smart_scan
*
@@ -581,17 +622,17 @@ static int smart_scan(struct smart_struct_s *dev)
{
int sector;
int ret;
- int x;
+ int offset;
uint16_t totalsectors;
uint16_t sectorsize;
uint16_t logicalsector;
uint16_t seq1;
uint16_t seq2;
- char devname[18];
size_t readaddress;
struct smart_sect_header_s header;
- struct mtd_byte_write_s bytewrite;
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
+ int x;
+ char devname[22];
struct smart_multiroot_device_s *rootdirdev;
#endif
@@ -675,7 +716,7 @@ static int smart_scan(struct smart_struct_s *dev)
}
#endif
- /* Test if this sector has been commited */
+ /* Test if this sector has been committed */
if ((header.status & SMART_STATUS_COMMITTED) ==
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_COMMITTED))
@@ -763,7 +804,16 @@ static int smart_scan(struct smart_struct_s *dev)
for (x = 1; x < dev->rootdirentries; x++)
{
- snprintf(devname, 18, "/dev/smart%dd%d", dev->minor, x + 1);
+ if (dev->partname != NULL)
+ {
+ snprintf(dev->rwbuffer, sizeof(devname), "/dev/smart%d%s%d",
+ dev->minor, dev->partname, x+1);
+ }
+ else
+ {
+ snprintf(devname, sizeof(devname), "/dev/smart%dd%d", dev->minor,
+ x + 1);
+ }
/* Inode private data is a reference to a struct containing
* the SMART device structure and the root directory number.
@@ -792,9 +842,9 @@ static int smart_scan(struct smart_struct_s *dev)
/* Test for duplicate logical sectors on the device */
- if (dev->sMap[logicalsector] != -1)
+ if (dev->sMap[logicalsector] != 0xFFFF)
{
- /* TODO: Uh-oh, we found more than 1 physical sector claiming to be
+ /* Uh-oh, we found more than 1 physical sector claiming to be
* the * same logical sector. Use the sequence number information
* to resolve who wins.
*/
@@ -853,10 +903,13 @@ static int smart_scan(struct smart_struct_s *dev)
#else
header.status |= SMART_STATUS_RELEASED;
#endif
- bytewrite.offset = readaddress + offsetof(struct smart_sect_header_s, status);
- bytewrite.count = 1;
- bytewrite.buffer = &header.status;
- ret = MTD_IOCTL(dev->mtd, MTDIOC_BYTEWRITE, (unsigned long) &bytewrite);
+ offset = readaddress + offsetof(struct smart_sect_header_s, status);
+ ret = smart_bytewrite(dev, offset, 1, &header.status);
+ if (ret < 0)
+ {
+ fdbg("Error %d releasing duplicate sector\n", -ret);
+ goto err_out;
+ }
}
/* Update the logical to physical sector map */
@@ -886,9 +939,11 @@ err_out:
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
static inline int smart_getformat(struct smart_struct_s *dev,
- struct smart_format_s *fmt, uint8_t rootdirnum)
+ struct smart_format_s *fmt,
+ uint8_t rootdirnum)
#else
-static inline int smart_getformat(struct smart_struct_s *dev, struct smart_format_s *fmt)
+static inline int smart_getformat(struct smart_struct_s *dev,
+ struct smart_format_s *fmt)
#endif
{
int ret;
@@ -914,8 +969,6 @@ static inline int smart_getformat(struct smart_struct_s *dev, struct smart_forma
}
}
- /* TODO: Determine if the underlying MTD device supports bytewrite */
-
/* Now fill in the structure */
if (dev->formatstatus == SMART_FMT_STAT_FORMATTED)
@@ -978,7 +1031,7 @@ static inline int smart_llformat(struct smart_struct_s *dev, unsigned long arg)
/* Erase the MTD device */
ret = MTD_IOCTL(dev->mtd, MTDIOC_BULKERASE, 0);
- if (ret != OK)
+ if (ret < 0)
{
return ret;
}
@@ -1180,8 +1233,9 @@ static int smart_garbagecollect(struct smart_struct_s *dev)
bool collect = TRUE;
int x;
int ret;
+ size_t offset;
struct smart_sect_header_s *header;
- struct mtd_byte_write_s bytewrite;
+ uint8_t newstatus;
while (collect)
{
@@ -1196,8 +1250,6 @@ static int smart_garbagecollect(struct smart_struct_s *dev)
{
releasedsectors += dev->releasecount[x];
if (dev->releasecount[x] > releasemax)
-// if (dev->releasecount[x] > releasemax &&
-// dev->freecount[x] < (dev->sectorsPerBlk >> 1))
{
releasemax = dev->releasecount[x];
collectblock = x;
@@ -1205,7 +1257,8 @@ static int smart_garbagecollect(struct smart_struct_s *dev)
}
/* Test if the released sectors count is greater than the
- * free sectors. If it is, then we will do garbage collection */
+ * free sectors. If it is, then we will do garbage collection.
+ */
if (releasedsectors > dev->freesectors)
collect = TRUE;
@@ -1238,7 +1291,8 @@ static int smart_garbagecollect(struct smart_struct_s *dev)
/* Perform collection on block with the most released sectors.
* First mark the block as having no free sectors so we don't
- * try to move sectors into the block we are trying to erase. */
+ * try to move sectors into the block we are trying to erase.
+ */
dev->freecount[collectblock] = 0;
@@ -1267,7 +1321,8 @@ static int smart_garbagecollect(struct smart_struct_s *dev)
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_RELEASED)))
{
/* This sector doesn't have live data (free or released).
- * just continue to the next sector and don't move it. */
+ * just continue to the next sector and don't move it.
+ */
continue;
}
@@ -1304,27 +1359,35 @@ static int smart_garbagecollect(struct smart_struct_s *dev)
/* Commit the sector */
- bytewrite.offset = newsector * dev->mtdBlksPerSector * dev->geo.blocksize +
+ offset = newsector * dev->mtdBlksPerSector * dev->geo.blocksize +
offsetof(struct smart_sect_header_s, status);
#if CONFIG_SMARTFS_ERASEDSTATE == 0xFF
- header->status &= ~SMART_STATUS_COMMITTED;
+ newstatus = header->status & ~SMART_STATUS_COMMITTED;
#else
- header->status |= SMART_STATUS_COMMITTED;
+ newstatus = header->status | SMART_STATUS_COMMITTED;
#endif
- bytewrite.count = 1;
- bytewrite.buffer = &header->status;
- ret = MTD_IOCTL(dev->mtd, MTDIOC_BYTEWRITE, (unsigned long) &bytewrite);
+ ret = smart_bytewrite(dev, offset, 1, &newstatus);
+ if (ret < 0)
+ {
+ fdbg("Error %d committing new sector %d\n" -ret, newsector);
+ goto errout;
+ }
/* Release the old physical sector */
#if CONFIG_SMARTFS_ERASEDSTATE == 0xFF
- header->status &= ~SMART_STATUS_RELEASED;
+ newstatus = header->status & ~SMART_STATUS_RELEASED;
#else
- header->status |= SMART_STATUS_RELEASED;
+ newstatus = header->status | SMART_STATUS_RELEASED;
#endif
- bytewrite.offset = x * dev->mtdBlksPerSector * dev->geo.blocksize +
+ offset = x * dev->mtdBlksPerSector * dev->geo.blocksize +
offsetof(struct smart_sect_header_s, status);
- ret = MTD_IOCTL(dev->mtd, MTDIOC_BYTEWRITE, (unsigned long) &bytewrite);
+ ret = smart_bytewrite(dev, offset, 1, &newstatus);
+ if (ret < 0)
+ {
+ fdbg("Error %d releasing old sector %d\n" -ret, x);
+ goto errout;
+ }
/* Update the variables */
@@ -1334,17 +1397,7 @@ static int smart_garbagecollect(struct smart_struct_s *dev)
/* Now erase the erase block */
-#ifdef CONFIG_MTD_SUBSECTOR_ERASE
- if (dev->geo.subsectorsize != 0)
- {
- /* Perform a sub-sector erase */
- MTD_IOCTL(dev->mtd, MTDIOC_SECTERASE, collectblock);
- }
- else
-#endif
- {
- MTD_ERASE(dev->mtd, collectblock, 1);
- }
+ MTD_ERASE(dev->mtd, collectblock, 1);
dev->freesectors += dev->releasecount[collectblock];
dev->freecount[collectblock] = dev->sectorsPerBlk;
@@ -1357,18 +1410,19 @@ static int smart_garbagecollect(struct smart_struct_s *dev)
/* Set the sector size in the 1st header */
uint8_t sectsize = dev->sectorsize >> 7;
- header = (struct smart_sect_header_s *) dev->rwbuffer;
#if ( CONFIG_SMARTFS_ERASEDSTATE == 0xFF )
- header->status = (uint8_t) ~SMART_STATUS_SIZEBITS | sectsize;
+ newstatus = (uint8_t) ~SMART_STATUS_SIZEBITS | sectsize;
#else
- header->status = (uint8_t) sectsize;
+ newstatus = (uint8_t) sectsize;
#endif
/* Write the sector size to the device */
- bytewrite.offset = offsetof(struct smart_sect_header_s, status);
- bytewrite.count = 1;
- bytewrite.buffer = &header->status;
- MTD_IOCTL(dev->mtd, MTDIOC_BYTEWRITE, (unsigned long) &bytewrite);
+ offset = offsetof(struct smart_sect_header_s, status);
+ ret = smart_bytewrite(dev, offset, 1, &newstatus);
+ if (ret < 0)
+ {
+ fdbg("Error %d setting sector 0 size\n", -ret);
+ }
}
/* Update the block aging information in the format signature sector */
@@ -1402,15 +1456,15 @@ errout:
#ifdef CONFIG_FS_WRITABLE
static inline int smart_writesector(struct smart_struct_s *dev, unsigned long arg)
{
- int ret;
- uint16_t x;
- bool needsrelocate = FALSE;
- uint16_t mtdblock;
- uint16_t physsector;
- struct smart_read_write_s *req;
- struct smart_sect_header_s *header;
- struct mtd_byte_write_s bytewrite;
- uint8_t byte;
+ int ret;
+ uint16_t x;
+ bool needsrelocate = FALSE;
+ uint16_t mtdblock;
+ uint16_t physsector;
+ struct smart_read_write_s *req;
+ struct smart_sect_header_s *header;
+ size_t offset;
+ uint8_t byte;
fvdbg("Entry\n");
req = (struct smart_read_write_s *) arg;
@@ -1515,16 +1569,14 @@ static inline int smart_writesector(struct smart_struct_s *dev, unsigned long ar
/* Commit the new physical sector */
#if CONFIG_SMARTFS_ERASEDSTATE == 0xFF
- header->status &= ~SMART_STATUS_COMMITTED;
+ byte = header->status & ~SMART_STATUS_COMMITTED;
#else
- header->status |= SMART_STATUS_COMMITTED;
+ byte = header->status | SMART_STATUS_COMMITTED;
#endif
- bytewrite.offset = physsector * dev->mtdBlksPerSector *
- dev->geo.blocksize + offsetof(struct smart_sect_header_s, status);
- bytewrite.count = 1;
- bytewrite.buffer = (uint8_t *) &header->status;
- ret = MTD_IOCTL(dev->mtd, MTDIOC_BYTEWRITE, (unsigned long) &bytewrite);
- if (ret != OK)
+ offset = physsector * dev->mtdBlksPerSector * dev->geo.blocksize +
+ offsetof(struct smart_sect_header_s, status);
+ ret = smart_bytewrite(dev, offset, 1, &byte);
+ if (ret != 1)
{
fvdbg("Error committing physical sector %d\n", physsector);
ret = -EIO;
@@ -1534,13 +1586,13 @@ static inline int smart_writesector(struct smart_struct_s *dev, unsigned long ar
/* Release the old physical sector */
#if CONFIG_SMARTFS_ERASEDSTATE == 0xFF
- header->status &= ~SMART_STATUS_RELEASED;
+ byte = header->status & ~SMART_STATUS_RELEASED;
#else
- header->status |= SMART_STATUS_RELEASED;
+ byte = header->status | SMART_STATUS_RELEASED;
#endif
- bytewrite.offset = mtdblock * dev->geo.blocksize +
+ offset = mtdblock * dev->geo.blocksize +
offsetof(struct smart_sect_header_s, status);
- ret = MTD_IOCTL(dev->mtd, MTDIOC_BYTEWRITE, (unsigned long) &bytewrite);
+ ret = smart_bytewrite(dev, offset, 1, &byte);
/* Update releasecount for released sector and freecount for the
* newly allocated physical sector. */
@@ -1564,11 +1616,9 @@ static inline int smart_writesector(struct smart_struct_s *dev, unsigned long ar
/* Not relocated. Just write the portion of the sector that needs
* to be written. */
- bytewrite.offset = mtdblock * dev->geo.blocksize +
+ offset = mtdblock * dev->geo.blocksize +
sizeof(struct smart_sect_header_s) + req->offset;
- bytewrite.count = req->count;
- bytewrite.buffer = req->buffer;
- ret = MTD_IOCTL(dev->mtd, MTDIOC_BYTEWRITE, (unsigned long) &bytewrite);
+ ret = smart_bytewrite(dev, offset, req->count, req->buffer);
}
ret = OK;
@@ -1743,9 +1793,8 @@ static inline int smart_allocsector(struct smart_struct_s *dev, unsigned long re
* rescan and try again to "self heal" in case of a
* bug in our code? */
- fdbg("Couldn't find free sector when I expected too\n");
-
- /* Unlock the mutex if we add one */
+ fdbg("No free logical sector numbers! Free sectors = %d\n",
+ dev->freesectors);
return -EIO;
}
@@ -1827,7 +1876,7 @@ static inline int smart_freesector(struct smart_struct_s *dev, unsigned long
uint16_t physsector;
uint16_t block;
struct smart_sect_header_s header;
- struct mtd_byte_write_s bytewrite;
+ size_t offset;
/* Check if the logical sector is within bounds */
@@ -1875,11 +1924,9 @@ static inline int smart_freesector(struct smart_struct_s *dev, unsigned long
/* Write the status back to the device */
- bytewrite.offset = readaddr + offsetof(struct smart_sect_header_s, status);
- bytewrite.count = 1;
- bytewrite.buffer = &header.status;
- ret = MTD_IOCTL(dev->mtd, MTDIOC_BYTEWRITE, (unsigned long) &bytewrite);
- if (ret != OK)
+ offset = readaddr + offsetof(struct smart_sect_header_s, status);
+ ret = smart_bytewrite(dev, offset, 1, &header.status);
+ if (ret != 1)
{
fdbg("Error updating physicl sector %d status\n", physsector);
goto errout;
@@ -1900,15 +1947,7 @@ static inline int smart_freesector(struct smart_struct_s *dev, unsigned long
{
/* Erase the block */
-#ifdef CONFIG_MTD_SUBSECTOR_ERASE
- if (dev->geo.subsectorsize != 0)
- {
- /* Perform a sub-sector erase */
- MTD_IOCTL(dev->mtd, MTDIOC_SECTERASE, block);
- }
- else
-#endif
- MTD_ERASE(dev->mtd, block, 1);
+ MTD_ERASE(dev->mtd, block, 1);
dev->freesectors += dev->releasecount[block];
dev->releasecount[block] = 0;
@@ -2050,7 +2089,7 @@ ok_out:
*
****************************************************************************/
-int smart_initialize(int minor, FAR struct mtd_dev_s *mtd)
+int smart_initialize(int minor, FAR struct mtd_dev_s *mtd, const char *partname)
{
struct smart_struct_s *dev;
int ret = -ENOMEM;
@@ -2084,10 +2123,6 @@ int smart_initialize(int minor, FAR struct mtd_dev_s *mtd)
/* Set these to zero in case the device doesn't support them */
-#ifdef CONFIG_MTD_SUBSECTOR_ERASE
- dev->geo.subsectorsize= 0;
- dev->geo.nsubsectors = 0;
-#endif
ret = MTD_IOCTL(mtd, MTDIOC_GEOMETRY, (unsigned long)((uintptr_t)&dev->geo));
if (ret < 0)
{
@@ -2123,6 +2158,7 @@ int smart_initialize(int minor, FAR struct mtd_dev_s *mtd)
dev->formatstatus = SMART_FMT_STAT_UNKNOWN;
dev->namesize = CONFIG_SMARTFS_MAXNAMLEN;
+ dev->partname = partname;
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
dev->minor = minor;
#endif
@@ -2130,7 +2166,10 @@ int smart_initialize(int minor, FAR struct mtd_dev_s *mtd)
/* Create a MTD block device name */
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
- snprintf(dev->rwbuffer, 18, "/dev/smart%dd1", minor);
+ if (partname != NULL)
+ snprintf(dev->rwbuffer, 18, "/dev/smart%d%sd1", minor, partname);
+ else
+ snprintf(dev->rwbuffer, 18, "/dev/smart%dd1", minor);
/* Inode private data is a reference to a struct containing
* the SMART device structure and the root directory number.
@@ -2154,7 +2193,10 @@ int smart_initialize(int minor, FAR struct mtd_dev_s *mtd)
ret = register_blockdriver(dev->rwbuffer, &g_bops, 0, rootdirdev);
#else
- snprintf(dev->rwbuffer, 18, "/dev/smart%d", minor);
+ if (partname != NULL)
+ snprintf(dev->rwbuffer, 18, "/dev/smart%d%s", minor, partname);
+ else
+ snprintf(dev->rwbuffer, 18, "/dev/smart%d", minor);
/* Inode private data is a reference to the SMART device structure */
@@ -2167,6 +2209,7 @@ int smart_initialize(int minor, FAR struct mtd_dev_s *mtd)
kfree(dev->sMap);
kfree(dev->rwbuffer);
kfree(dev);
+ goto errout;
}
/* Do a scan of the device */
diff --git a/fs/smartfs/smartfs_smart.c b/fs/smartfs/smartfs_smart.c
index 552c0e96e6c..a1613b899da 100644
--- a/fs/smartfs/smartfs_smart.c
+++ b/fs/smartfs/smartfs_smart.c
@@ -389,6 +389,7 @@ static int smartfs_close(FAR struct file *filep)
/* Remove ourselves from the linked list */
nextfile = fs->fs_head;
+ prevfile = nextfile;
while ((nextfile != sf) && (nextfile != NULL))
{
/* Save the previous file pointer too */
@@ -577,7 +578,7 @@ static int smartfs_sync_internal(struct smartfs_mountpt_s *fs,
if (sf->byteswritten > 0)
{
- fdbg("Syncing sector %d\n", sf->currsector);
+ fvdbg("Syncing sector %d\n", sf->currsector);
/* Read the existing sector used bytes value */
@@ -880,6 +881,7 @@ static off_t smartfs_seek_internal(struct smartfs_mountpt_s *fs,
switch (whence)
{
case SEEK_SET:
+ default:
newpos = offset;
break;
@@ -1034,7 +1036,7 @@ static int smartfs_sync(FAR struct file *filep)
struct inode *inode;
struct smartfs_mountpt_s *fs;
struct smartfs_ofile_s *sf;
- int ret = OK;
+ int ret;
/* Sanity checks */
@@ -1067,7 +1069,6 @@ static int smartfs_sync(FAR struct file *filep)
static int smartfs_dup(FAR const struct file *oldp, FAR struct file *newp)
{
- FAR struct smart_mountpt_s *fs;
struct smartfs_ofile_s *sf;
fvdbg("Dup %p->%p\n", oldp, newp);
@@ -1080,10 +1081,8 @@ static int smartfs_dup(FAR const struct file *oldp, FAR struct file *newp)
/* Recover our private data from the struct file instance */
- fs = (struct smart_mountpt_s *)oldp->f_inode->i_private;
sf = oldp->f_priv;
- DEBUGASSERT(fs != NULL);
DEBUGASSERT(sf != NULL);
/* Just increment the reference count on the ofile */
diff --git a/fs/smartfs/smartfs_utils.c b/fs/smartfs/smartfs_utils.c
index a72fef691af..30813a44bca 100644
--- a/fs/smartfs/smartfs_utils.c
+++ b/fs/smartfs/smartfs_utils.c
@@ -502,6 +502,8 @@ int smartfs_finddirentry(struct smartfs_mountpt_s *fs,
/* Read the directory */
+ offset = 0xFFFF;
+
#if CONFIG_SMARTFS_ERASEDSTATE == 0xFF
while (dirsector != 0xFFFF)
#else
@@ -549,7 +551,8 @@ int smartfs_finddirentry(struct smartfs_mountpt_s *fs,
/* Test if the name matches */
- if (strcmp(entry->name, fs->fs_workbuffer) == 0)
+ if (strncmp(entry->name, fs->fs_workbuffer,
+ fs->fs_llformat.namesize) == 0)
{
/* We found it! If this is the last segment entry,
* then report the entry. If it isn't the last
@@ -571,10 +574,11 @@ int smartfs_finddirentry(struct smartfs_mountpt_s *fs,
direntry->dfirst = dirstack[depth];
if (direntry->name == NULL)
{
- direntry->name = (char *) kmalloc(fs->fs_llformat.namesize);
+ direntry->name = (char *) kmalloc(fs->fs_llformat.namesize+1);
}
- strcpy(direntry->name, entry->name);
+ memset(direntry->name, 0, fs->fs_llformat.namesize + 1);
+ strncpy(direntry->name, entry->name, fs->fs_llformat.namesize);
direntry->datlen = 0;
/* Scan the file's sectors to calculate the length and perform
@@ -734,7 +738,7 @@ int smartfs_createentry(struct smartfs_mountpt_s *fs,
/* Validate the name isn't too long */
- if (strlen(filename) + 1 > fs->fs_llformat.namesize)
+ if (strlen(filename) > fs->fs_llformat.namesize)
{
return -ENAMETOOLONG;
}
@@ -887,13 +891,13 @@ int smartfs_createentry(struct smartfs_mountpt_s *fs,
entry->firstsector = nextsector;
entry->utc = 0;
memset(entry->name, 0, fs->fs_llformat.namesize);
- strncpy(entry->name, filename, fs->fs_llformat.namesize-1);
+ strncpy(entry->name, filename, fs->fs_llformat.namesize);
/* Now write the new entry to the parent directory sector */
readwrite.logsector = psector;
readwrite.offset = offset;
- readwrite.count = sizeof(struct smartfs_entry_header_s) + fs->fs_llformat.namesize;
+ readwrite.count = entrysize;
readwrite.buffer = (uint8_t *) &fs->fs_rwbuffer[offset];
ret = FS_IOCTL(fs, BIOC_WRITESECT, (unsigned long) &readwrite);
if (ret < 0)
@@ -911,11 +915,11 @@ int smartfs_createentry(struct smartfs_mountpt_s *fs,
direntry->datlen = 0;
if (direntry->name == NULL)
{
- direntry->name = (FAR char *) kmalloc(fs->fs_llformat.namesize);
+ direntry->name = (FAR char *) kmalloc(fs->fs_llformat.namesize+1);
}
- memset(direntry->name, 0, fs->fs_llformat.namesize);
- strncpy(direntry->name, filename, fs->fs_llformat.namesize-1);
+ memset(direntry->name, 0, fs->fs_llformat.namesize+1);
+ strncpy(direntry->name, filename, fs->fs_llformat.namesize);
ret = OK;
diff --git a/include/nuttx/fs/ioctl.h b/include/nuttx/fs/ioctl.h
index 463b96e18a8..bd80a715075 100644
--- a/include/nuttx/fs/ioctl.h
+++ b/include/nuttx/fs/ioctl.h
@@ -193,15 +193,6 @@
* of device memory */
#define MTDIOC_BULKERASE _MTDIOC(0x0003) /* IN: None
* OUT: None */
-#define MTDIOC_GETCAPS _MTDIOC(0x0004) /* IN: None
- * OUT: Capabilities flags */
-#define MTDIOC_SECTERASE _MTDIOC(0x0005) /* IN: Sector number to erase
- * OUT: None */
-#define MTDIOC_BYTEWRITE _MTDIOC(0x0006) /* IN: Pointer to bytewrite structure
- * OUT: None */
-
-#define MTDIOC_CAPS_SECTERASE 0x01
-#define MTDIOC_CAPS_BYTEWRITE 0x02
/* NuttX ARP driver ioctl definitions (see netinet/arp.h) *******************/
diff --git a/include/nuttx/mtd.h b/include/nuttx/mtd.h
index c4bf4fbeef2..a528d000331 100644
--- a/include/nuttx/mtd.h
+++ b/include/nuttx/mtd.h
@@ -83,10 +83,6 @@ struct mtd_geometry_s
uint16_t erasesize; /* Size of one erase blocks -- must be a multiple
* of blocksize. */
size_t neraseblocks; /* Number of erase blocks */
-#ifdef CONFIG_MTD_SUBSECTOR_ERASE
- uint16_t subsectorsize; /* Size of the sub-sector erase block */
- uint16_t nsubsectors; /* Number of sub-sector erase blocks */
-#endif
};
/* The following defines the information for writing bytes to a sector
@@ -179,8 +175,8 @@ extern "C"
* NOTE: Since there may be a number of MTD partition drivers operating on
* the same, underlying FLASH driver, that FLASH driver must be capable
* of enforcing mutually exclusive access to the FLASH device. Without
- * paritions, that mutual exclusing would be provided by the file system
- * abover the FLASH driver.
+ * partitions, that mutual exclusion would be provided by the file system
+ * above the FLASH driver.
*
****************************************************************************/
@@ -213,10 +209,13 @@ int ftl_initialize(int minor, FAR struct mtd_dev_s *mtd);
* minor - The minor device number. The MTD block device will be
* registered as as /dev/mtdsmartN where N is the minor number.
* mtd - The MTD device that supports the FLASH interface.
+ * partname - Optional partition name to append to dev entry, NULL if
+ * not supplied.
*
****************************************************************************/
-int smart_initialize(int minor, FAR struct mtd_dev_s *mtd);
+int smart_initialize(int minor, FAR struct mtd_dev_s *mtd,
+ FAR const char *partname);
/****************************************************************************
* Name: flash_eraseall
diff --git a/tools/kconfig2html.c b/tools/kconfig2html.c
index f6d21091a0c..9a089c41538 100644
--- a/tools/kconfig2html.c
+++ b/tools/kconfig2html.c
@@ -2368,7 +2368,8 @@ static char *parse_kconfigfile(FILE *stream, const char *kconfigdir)
{
/* Set token to NULL to skip to the next line */
- error("Unhandled token: %s\n", token);
+ error("File %s/Kconfig Unhandled token: %s\n",
+ kconfigdir, token);
token = NULL;
}
break;
|