nuttx/drivers/mtd/smart.c

6539 lines
184 KiB
C
Raw Normal View History

/****************************************************************************
* drivers/mtd/smart.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <debug.h>
#include <nuttx/crc8.h>
#include <nuttx/crc16.h>
#include <nuttx/crc32.h>
#include <nuttx/kmalloc.h>
#include <nuttx/fs/fs.h>
#include <nuttx/fs/ioctl.h>
#include <nuttx/mtd/mtd.h>
#include <nuttx/mtd/smart.h>
#include <nuttx/fs/smart.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#if 0 /* Define to enable checking */
# define CONFIG_SMART_LOCAL_CHECKFREE
#endif
#define SMART_STATUS_COMMITTED 0x80
#define SMART_STATUS_RELEASED 0x40
#define SMART_STATUS_CRC 0x20
#define SMART_STATUS_SIZEBITS 0x1c
#define SMART_STATUS_VERBITS 0x03
#if defined(CONFIG_SMART_CRC_16)
#define SMART_STATUS_VERSION 0x02
#elif defined(CONFIG_SMART_CRC_32)
#define SMART_STATUS_VERSION 0x03
#else
#define SMART_STATUS_VERSION 0x01
#endif
#define SMART_SECTSIZE_256 0x00
#define SMART_SECTSIZE_512 0x04
#define SMART_SECTSIZE_1024 0x08
#define SMART_SECTSIZE_2048 0x0c
#define SMART_SECTSIZE_4096 0x10
#define SMART_SECTSIZE_8192 0x14
#define SMART_SECTSIZE_16384 0x18
#define SMART_FMT_STAT_UNKNOWN 0
#define SMART_FMT_STAT_FORMATTED 1
#define SMART_FMT_STAT_NOFMT 2
#define SMART_FMT_POS1 sizeof(struct smart_sect_header_s)
#define SMART_FMT_POS2 (SMART_FMT_POS1 + 1)
#define SMART_FMT_POS3 (SMART_FMT_POS1 + 2)
#define SMART_FMT_POS4 (SMART_FMT_POS1 + 3)
#define SMART_FMT_SIG1 'S'
#define SMART_FMT_SIG2 'M'
#define SMART_FMT_SIG3 'R'
#define SMART_FMT_SIG4 'T'
#define SMART_FMT_VERSION_POS (SMART_FMT_POS1 + 4)
#define SMART_FMT_NAMESIZE_POS (SMART_FMT_POS1 + 5)
#define SMART_FMT_ROOTDIRS_POS (SMART_FMT_POS1 + 6)
#define SMARTFS_FMT_WEAR_POS 36
#define SMART_WEAR_LEVEL_FORMAT_SIG 32
#define SMART_PARTNAME_SIZE 4
#define SMART_FIRST_DIR_SECTOR 3 /* First root directory sector */
#define SMART_FIRST_ALLOC_SECTOR 12 /* First logical sector number
* we will use for assignment
* of requested alloc sectors.
* All entries below this are
* reserved (some for root dir
* entries other for our use
* such as format, sector,
* etc.) */
#if defined(CONFIG_MTD_SMART_READAHEAD) || (defined(CONFIG_DRVR_WRITABLE) && \
defined(CONFIG_MTD_SMART_WRITEBUFFER))
# define SMART_HAVE_RWBUFFER 1
#endif
#ifndef CONFIG_MTD_SMART_SECTOR_SIZE
2018-12-22 15:12:34 +01:00
# define CONFIG_MTD_SMART_SECTOR_SIZE 1024
#endif
#ifndef offsetof
#define offsetof(type, member) ( (size_t) &( ( (type *) 0)->member))
#endif
#define SMART_MAX_ALLOCS 10
#ifndef CONFIG_MTD_SMART_ALLOC_DEBUG
#define smart_malloc(d, b, n) kmm_malloc(b)
#define smart_zalloc(d, b, n) kmm_zalloc(b)
#define smart_free(d, p) kmm_free(p)
#endif
#define SMART_WEAR_FULL_RELOCATE_THRESHOLD 8
#define SMART_WEAR_REORG_THRESHOLD 14
#define SMART_WEAR_MIN_LEVEL 5
#define SMART_WEAR_FORCE_REORG_THRESHOLD 1
#define SMART_WEAR_BIT_DIVIDE 1
#define SMART_WEAR_ZERO_MASK 0x0f
#define SMART_WEAR_BLOCK_MASK 0x01
#define SMART_WEARFLAGS_FORCE_REORG 0x01
#define SMART_WEARFLAGS_WRITE_NEEDED 0x02
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
#define SET_BITMAP(m, n) do { (m)[(n) / 8] |= 1 << ((n) % 8); } while (0)
#define CLR_BITMAP(m, n) do { (m)[(n) / 8] &= ~(1 << ((n) % 8)); } while (0)
#define ISSET_BITMAP(m, n) ((m)[(n) / 8] & (1 << ((n) % 8)))
#ifdef CONFIG_SMARTFS_ALIGNED_ACCESS
# define SMARTFS_NEXTSECTOR(h) \
(uint16_t)((FAR const uint8_t *)(h)->nextsector)[1] << 8 | \
(uint16_t)((FAR const uint8_t *)(h)->nextsector)[0]
# define SMARTFS_SET_NEXTSECTOR(h, v) \
do \
{ \
((FAR uint8_t *)(h)->nextsector)[0] = (v) & 0xff; \
((FAR uint8_t *)(h)->nextsector)[1] = (v) >> 8; \
} while (0)
#else
# define SMARTFS_NEXTSECTOR(h) (*((FAR uint16_t *)(h)->nextsector))
# define SMARTFS_SET_NEXTSECTOR(h, v) \
do \
{ \
((*((FAR uint16_t *)(h)->nextsector)) = (uint16_t)(v)); \
} while (0)
#endif
Merged in ebsong/nuttx (pull request #712) Pull request for cortex-r4 codes * arm/armv7-r: Add general interrupt controller. This is based on armv7-a gic controller code. Signed-off-by: EunBong Song <eunb.song@samsung.com> * arm/armv7-r: add invalidate dcache in arm_head.S Adding invalidate dcache as a comment in arm_head.S. Signed-off-by: EunBong Song <eunb.song@samsung.com> * arm/armv7-r: Fix some wrong configuration of program status register. PSR_E_BIT bit should be set for big endian system. PSR_A_BIT bis is set automatically as arm cortex-r4 reference manual 3.7.4. So we don't need to set this bit. Signed-off-by: EunBong Song <eunb.song@samsung.com> * arm/armv7-r: Fix some wrong MPU register definition. Change MPU_RBAR_ADDR_MASK and MPU_RACR_TEX_SHIFT mask as arm cortex-r4 reference manual. Region Base Address Register 0-4 bits are reserved. MPU Region Access control register type 3-5 bits. Signed-off-by: EunBong Song <eunb.song@samsung.com> * driver/mtd: fix compilation error. This commit fixes below compilation errors. CC: mtd/smart.c mtd/smart.c:182:22: error: 'gWearBitToLevelMap4' defined but not used [-Werror=unused-const-variable=] static const uint8_t gWearBitToLevelMap4[] = ^~~~~~~~~~~~~~~~~~~ mtd/smart.c:170:22: error: 'gWearLevelToBitMap4' defined but not used [-Werror=unused-const-variable=] static const uint8_t gWearLevelToBitMap4[] = ^~~~~~~~~~~~~~~~~~~ cc1: all warnings being treated as errors make[1]: *** [smart.o] Error 1 Signed-off-by: Junyeon LEE <junyeon2.lee@samsung.com> Approved-by: GregoryN <gnutt@nuttx.org>
2018-08-29 03:50:41 +02:00
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
/****************************************************************************
* Private Data
****************************************************************************/
/* Bit mapping for wear level bits */
/* These are defined to allow updating the wear leveling with the minimum
* number of sector relocations / maximum use of 1 --> 0 transitions when
* incrementing the wear level.
*
* 0: 1111 8: 1011
* 1: 1110 9: 1010
* 2: 1100 10: 0010
* 3: 1000 11: 1101
* 4: 0111 12: 1001
* 5: 0110 13: 0001
* 6: 0100 14: 0011
* 7: 0000 15: 0101
*/
static const uint8_t g_wearlevel_to_bitmap4[] =
{
0x0f, 0x0e, 0x0c, 0x08, /* Single bit erased (x3) */
0x07, 0x06, 0x04, 0x00, /* Single bit erased (x3) */
0x0b, 0x0a, 0x02, /* Single bit erased (x2) */
0x0d, 0x09, 0x01, /* Single bit erased (x2) */
0x03,
0x05
};
/* Map a Wear Level bit pattern back to the wear level */
static const uint8_t g_wearbit_to_levelmap4[] =
{
7, 13, 10, 14, 6, 15, 5, 4,
3, 12, 9, 8, 2, 11, 1, 0
};
Merged in ebsong/nuttx (pull request #712) Pull request for cortex-r4 codes * arm/armv7-r: Add general interrupt controller. This is based on armv7-a gic controller code. Signed-off-by: EunBong Song <eunb.song@samsung.com> * arm/armv7-r: add invalidate dcache in arm_head.S Adding invalidate dcache as a comment in arm_head.S. Signed-off-by: EunBong Song <eunb.song@samsung.com> * arm/armv7-r: Fix some wrong configuration of program status register. PSR_E_BIT bit should be set for big endian system. PSR_A_BIT bis is set automatically as arm cortex-r4 reference manual 3.7.4. So we don't need to set this bit. Signed-off-by: EunBong Song <eunb.song@samsung.com> * arm/armv7-r: Fix some wrong MPU register definition. Change MPU_RBAR_ADDR_MASK and MPU_RACR_TEX_SHIFT mask as arm cortex-r4 reference manual. Region Base Address Register 0-4 bits are reserved. MPU Region Access control register type 3-5 bits. Signed-off-by: EunBong Song <eunb.song@samsung.com> * driver/mtd: fix compilation error. This commit fixes below compilation errors. CC: mtd/smart.c mtd/smart.c:182:22: error: 'gWearBitToLevelMap4' defined but not used [-Werror=unused-const-variable=] static const uint8_t gWearBitToLevelMap4[] = ^~~~~~~~~~~~~~~~~~~ mtd/smart.c:170:22: error: 'gWearLevelToBitMap4' defined but not used [-Werror=unused-const-variable=] static const uint8_t gWearLevelToBitMap4[] = ^~~~~~~~~~~~~~~~~~~ cc1: all warnings being treated as errors make[1]: *** [smart.o] Error 1 Signed-off-by: Junyeon LEE <junyeon2.lee@samsung.com> Approved-by: GregoryN <gnutt@nuttx.org>
2018-08-29 03:50:41 +02:00
#endif
/****************************************************************************
* Private Types
****************************************************************************/
#ifdef CONFIG_MTD_SMART_MINIMIZE_RAM
struct smart_cache_s
{
uint16_t logical; /* Logical sector number */
uint16_t physical; /* Associated physical sector */
uint16_t birth; /* The "birthday" of this entry */
};
#endif
/* When CRC is enabled, we allocate sectors in memory only and only write
* to the device when an actual writesector is performed. If during the
* alloc process we do a physical write, we would either have to hold off on
* writing the CRC value (which creates an invalid state on the device) or
* we would have to perform a write, release re-write every time which would
* increase the wear of the device 2x.
*/
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
struct smart_allocsector_s
{
struct smart_allocsector_s *next; /* Pointer to next alloc sector */
uint16_t logical; /* Logical sector number */
uint16_t physical; /* Associated physical sector */
};
#endif
struct smart_struct_s
{
FAR struct mtd_dev_s *mtd; /* Contained MTD interface */
struct mtd_geometry_s geo; /* Device geometry */
#if defined(CONFIG_FS_PROCFS) && !defined(CONFIG_FS_PROCFS_EXCLUDE_SMARTFS)
uint32_t unusedsectors; /* Count of unused sectors (i.e. free when erased) */
uint32_t blockerases; /* Count of unused sectors (i.e. free when erased) */
#endif
uint16_t neraseblocks; /* Number of erase blocks or sub-sectors */
uint16_t lastallocblock; /* Last block we allocated a sector from */
uint16_t freesectors; /* Total number of free sectors */
uint16_t releasesectors; /* Total number of released sectors */
uint16_t mtdblkspersector; /* Number of MTD blocks per SMART Sector */
uint16_t sectorsperblk; /* Number of sectors per erase block */
uint16_t sectorsize; /* Sector size on device */
uint16_t totalsectors; /* Total number of sectors on device */
uint32_t erasesize; /* Size of an erase block */
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 */
char partname[SMART_PARTNAME_SIZE];
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 */
uint8_t debuglevel; /* Debug reporting level */
uint8_t availsectperblk; /* Number of usable sectors per erase block */
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
uint8_t rootdirentries; /* Number of root directory entries */
uint8_t minor; /* Minor number of the block entry */
#endif
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
uint8_t wearflags; /* Indicates force erase of static blocks needed */
uint8_t minwearlevel; /* Min level in the wear level bits */
uint8_t maxwearlevel; /* Max level in the wear level bits */
uint8_t *wearstatus; /* Array of wear leveling bits */
uint32_t uneven_wearcount; /* Number of times the wear level has gone over max */
#endif
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
FAR struct smart_allocsector_s *allocsector; /* Pointer to first alloc sector */
#endif
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
FAR uint16_t *smap; /* Virtual to physical sector map */
#else
FAR uint8_t *sbitmap; /* Virtual sector used bit-map */
FAR struct smart_cache_s *scache; /* Sector cache */
uint16_t cache_entries; /* Number of valid entries in the cache */
uint16_t cache_lastlog; /* Keep track of the last sector accessed */
uint16_t cache_lastphys; /* Keep the physical sector number also */
uint16_t cache_nextbirth; /* Sector cache aging value */
#endif
#ifdef CONFIG_MTD_SMART_SECTOR_ERASE_DEBUG
FAR uint8_t *erasecounts; /* Number of erases for each erase block */
#endif
#ifdef CONFIG_MTD_SMART_ALLOC_DEBUG
size_t bytesalloc;
struct smart_alloc_s alloc[SMART_MAX_ALLOCS]; /* Array of memory allocations */
#endif
};
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
struct smart_multiroot_device_s
{
FAR struct smart_struct_s *dev;
uint8_t rootdirnum;
};
#endif
/* Format 1 sector header definition */
#if SMART_STATUS_VERSION == 1
#define SMART_FMT_VERSION 1
struct smart_sect_header_s
{
uint8_t logicalsector[2]; /* The logical sector number */
uint8_t seq; /* Incrementing sequence number */
uint8_t crc8; /* CRC-8 or seq number MSB */
uint8_t status; /* Status of this sector:
* Bit 7: 1 = Not committed
* 0 = committed
* Bit 6: 1 = Not released
* 0 = released
* Bit 5: Sector CRC enable
* Bit 4-2: Sector size on volume
* Bit 1-0: Format version (0x1) */
};
typedef uint8_t crc_t;
/* Format 2 sector header definition. This is for a 16-bit CRC */
#elif SMART_STATUS_VERSION == 2
#define SMART_FMT_VERSION 2
struct smart_sect_header_s
{
uint8_t logicalsector[2]; /* The logical sector number */
uint8_t crc16[2]; /* CRC-16 for this sector */
uint8_t status; /* Status of this sector:
* Bit 7: 1 = Not committed
* 0 = committed
* Bit 6: 1 = Not released
* 0 = released
* Bit 5: Sector CRC enable
* Bit 4-2: Sector size on volume
* Bit 1-0: Format version (0x2) */
uint8_t seq; /* Incrementing sequence number */
};
typedef uint16_t crc_t;
/* Format 3 (32-bit) sector header definition. Actually, this format
* isn't used yet and will likely be changed to a format to support
* NAND devices (possibly with an 18-bit sector size, allowing up to
* 256K sectors on a larger NAND device, though this would take a fair
* amount of RAM for management).
*/
#elif SMART_STATUS_VERSION == 3
#error "32-Bit mode not supported yet"
#define SMART_FMT_VERSION 3
struct smart_sect_header_s
{
uint8_t logicalsector[4]; /* The logical sector number */
uint8_t crc32[4]; /* CRC-32 for this sector */
uint8_t status; /* Status of this sector:
* Bit 7: 1 = Not committed
* 0 = committed
* Bit 6: 1 = Not released
* 0 = released
* Bit 5: Sector CRC enable
* Bit 4-2: Sector size on volume
* Bit 1-0: Format version (0x3) */
uint8_t seq; /* Incrementing sequence number */
};
typedef uint32_t crc_t;
#endif
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
/* Following two definitions copied from internal definition of fs/smartfs.
* Because needed to search chain_header and entry_header.
*/
#if defined(CONFIG_MTD_SMART_ENABLE_CRC) && defined(CONFIG_SMART_CRC_32)
struct smart_chain_header_s
{
uint8_t nextsector[4]; /* Next logical sector in the chain */
uint8_t used[4]; /* Number of bytes used in this sector */
uint8_t type; /* Type of sector entry (file or dir) */
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
};
#else
struct smart_chain_header_s
{
uint8_t type; /* Type of sector entry (file or dir) */
uint8_t nextsector[2]; /* Next logical sector in the chain */
uint8_t used[2]; /* Number of bytes used in this sector */
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
};
#endif
struct smart_entry_header_s
{
uint16_t flags; /* Flags, including permissions:
* 15: Empty entry
* 14: Active entry
* 12-0: Permissions bits */
int16_t firstsector; /* Sector number of the name */
uint32_t utc; /* Time stamp */
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
};
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
static int smart_open(FAR struct inode *inode);
static int smart_close(FAR struct inode *inode);
static ssize_t smart_reload(struct smart_struct_s *dev, FAR uint8_t *buffer,
off_t startblock, size_t nblocks);
static ssize_t smart_read(FAR struct inode *inode, unsigned char *buffer,
blkcnt_t start_sector, unsigned int nsectors);
static ssize_t smart_write(FAR struct inode *inode,
FAR const unsigned char *buffer, blkcnt_t start_sector,
unsigned int nsectors);
static int smart_geometry(FAR struct inode *inode,
FAR struct geometry *geometry);
static int smart_ioctl(FAR struct inode *inode, int cmd,
unsigned long arg);
static int smart_findfreephyssector(FAR struct smart_struct_s *dev,
uint8_t canrelocate);
static int smart_writesector(FAR struct smart_struct_s *dev,
unsigned long arg);
static inline int smart_allocsector(FAR struct smart_struct_s *dev,
unsigned long requested);
static int smart_readsector(FAR struct smart_struct_s *dev,
unsigned long arg);
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
static int smart_validate_crc(FAR struct smart_struct_s *dev);
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
#endif
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
static int smart_read_wearstatus(FAR struct smart_struct_s *dev);
static int smart_relocate_static_data(FAR struct smart_struct_s *dev,
uint16_t block);
#endif
static int smart_relocate_sector(FAR struct smart_struct_s *dev,
uint16_t oldsector, uint16_t newsector);
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
#ifdef CONFIG_MTD_SMART_FSCK
static int smart_fsck(FAR struct smart_struct_s *dev);
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
#endif
#ifdef CONFIG_SMART_DEV_LOOP
static ssize_t smart_loop_read(FAR struct file *filep, FAR char *buffer,
size_t buflen);
static ssize_t smart_loop_write(FAR struct file *filep,
FAR const char *buffer, size_t buflen);
static int smart_loop_ioctl(FAR struct file *filep, int cmd,
unsigned long arg);
#endif /* CONFIG_SMART_DEV_LOOP */
/****************************************************************************
* Private Data
****************************************************************************/
static const struct block_operations g_bops =
{
smart_open, /* open */
smart_close, /* close */
smart_read, /* read */
smart_write, /* write */
smart_geometry, /* geometry */
smart_ioctl /* ioctl */
};
#ifdef CONFIG_SMART_DEV_LOOP
static const struct file_operations g_fops =
{
NULL, /* open */
NULL, /* close */
smart_loop_read, /* read */
smart_loop_write, /* write */
NULL, /* seek */
smart_loop_ioctl, /* ioctl */
NULL /* poll */
#ifndef CONFIG_DISABLE_PSEUDOFS_OPERATIONS
, NULL /* unlink */
#endif
};
#endif /* CONFIG_SMART_DEV_LOOP */
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: smart_open
*
* Description: Open the block device
*
****************************************************************************/
static int smart_open(FAR struct inode *inode)
{
finfo("Entry\n");
return OK;
}
/****************************************************************************
* Name: smart_close
*
* Description: close the block device
*
****************************************************************************/
static int smart_close(FAR struct inode *inode)
{
finfo("Entry\n");
return OK;
}
/****************************************************************************
* Name: smart_malloc
*
* Description: Perform allocations and keep track of amount of allocated
* memory for this context.
*
****************************************************************************/
#ifdef CONFIG_MTD_SMART_ALLOC_DEBUG
FAR static void *smart_malloc(FAR struct smart_struct_s *dev,
size_t bytes, const char *name)
{
FAR void *ret = kmm_malloc(bytes);
uint8_t x;
/* Test if we are allocating the dev struct */
if (dev == NULL)
{
dev = ret;
dev->bytesalloc = 0;
for (x = 0; x < SMART_MAX_ALLOCS; x++)
{
dev->alloc[x].ptr = NULL;
}
}
/* Keep track of the total allocation */
if (ret != NULL)
{
dev->bytesalloc += bytes;
}
/* Keep track of individual allocs */
for (x = 0; x < SMART_MAX_ALLOCS; x++)
{
if (dev->alloc[x].ptr == NULL)
{
dev->alloc[x].ptr = ret;
dev->alloc[x].size = bytes;
dev->alloc[x].name = name;
break;
}
}
finfo("SMART alloc: %ld\n", dev->bytesalloc);
return ret;
}
#endif
/****************************************************************************
* Name: smart_zalloc
*
* Description: Perform allocations and keep track of amount of allocated
* memory for this context.
*
****************************************************************************/
#ifdef CONFIG_MTD_SMART_ALLOC_DEBUG
FAR static void *smart_zalloc(FAR struct smart_struct_s *dev,
size_t bytes, const char *name)
{
void *mem;
mem = smart_malloc(dev, bytes, name);
if (mem != NULL)
{
memset(mem, 0, bytes);
}
return mem;
}
#endif
/****************************************************************************
* Name: smart_free
*
* Description: Perform smart memory free operation.
*
****************************************************************************/
#ifdef CONFIG_MTD_SMART_ALLOC_DEBUG
static void smart_free(FAR struct smart_struct_s *dev, FAR void *ptr)
{
uint8_t x;
for (x = 0; x < SMART_MAX_ALLOCS; x++)
{
if (dev->alloc[x].ptr == ptr)
{
dev->alloc[x].ptr = NULL;
dev->bytesalloc -= dev->alloc[x].size;
kmm_free(ptr);
break;
}
}
}
#endif
/****************************************************************************
* Name: smart_set_count
*
* Description: Set either the freecount or releasecount value for the
* specified eraseblock (depending on which pointer is passed).
*
****************************************************************************/
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
static void smart_set_count(FAR struct smart_struct_s *dev,
FAR uint8_t *pcount, uint16_t block,
uint8_t count)
{
if (dev->sectorsperblk > 16)
{
pcount[block] = count;
}
else
{
/* Save the lower 4 bits of the count in a shared byte */
if (block & 0x01)
{
pcount[block >> 1] = (pcount[block >> 1] & 0xf0) |
(count & 0x0f);
}
else
{
pcount[block >> 1] = (pcount[block >> 1] & 0x0f) |
((count & 0x0f) << 4);
}
/* If we have 16 sectors per block, then the upper bit (representing
* 16) all get packed into shared bytes.
*/
if (dev->sectorsperblk == 16)
{
if (count == 16)
{
pcount[(dev->geo.neraseblocks >> 1) + (block >> 3)] |=
1 << (block & 0x07);
}
else
{
pcount[(dev->geo.neraseblocks >> 1) + (block >> 3)] &=
~(1 << (block & 0x07));
}
}
}
}
#endif
/****************************************************************************
* Name: smart_get_count
*
* Description: Get either the freecount or releasecount value for the
* specified eraseblock (depending on which pointer is passed).
*
****************************************************************************/
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
static uint8_t smart_get_count(FAR struct smart_struct_s *dev,
FAR uint8_t *pcount, uint16_t block)
{
uint8_t count;
if (dev->sectorsperblk > 16)
{
count = pcount[block];
}
else
{
/* Save the lower 4 bits of the count in a shared byte */
if (block & 0x01)
{
count = pcount[block >> 1] & 0x0f;
}
else
{
count = pcount[block >> 1] >> 4;
}
/* If we have 16 sectors per block, then the upper bit (representing
* 16) all get packed into shared bytes.
*/
if (dev->sectorsperblk == 16)
{
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
if (pcount[(dev->geo.neraseblocks >> 1) +
(block >> 3)] & (1 << (block & 0x07)))
{
count |= 0x10;
}
}
}
return count;
}
#endif
/****************************************************************************
* Name: smart_add_count
*
* Description: Add the specified value to and eraseblock count.
*
****************************************************************************/
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
static void smart_add_count(struct smart_struct_s *dev, uint8_t *pcount,
uint16_t block, int adder)
{
int16_t value;
value = smart_get_count(dev, pcount, block) + adder;
smart_set_count(dev, pcount, block, value);
}
#endif
/****************************************************************************
* Name: smart_checkfree
*
* Description: A debug routine for validating the free sector count used
* during development of the wear leveling code.
*
****************************************************************************/
#ifdef CONFIG_SMART_LOCAL_CHECKFREE
int smart_checkfree(FAR struct smart_struct_s *dev, int lineno)
{
uint16_t x;
uint16_t freecount;
#ifdef CONFIG_DEBUG_FS
uint16_t blockfree;
uint16_t blockrelease;
static uint16_t prev_freesectors = 0;
static uint16_t prev_releasesectors = 0;
static uint8_t *prev_freecount = NULL;
static uint8_t *prev_releasecount = NULL;
#endif
freecount = 0;
for (x = 0; x < dev->neraseblocks; x++)
{
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
freecount += smart_get_count(dev, dev->freecount, x);
#else
freecount += dev->freecount[x];
#endif
}
/* Test if the calculated freesectors equals the reported value */
#ifdef CONFIG_DEBUG_FS
if (freecount != dev->freesectors)
{
fwarn("WARNING: Free count incorrect in line %d! Calculated=%d, "
"dev->freesectors=%d\n",
lineno, freecount, dev->freesectors);
/* Determine what changed from the last time which caused this error */
fwarn(" ... Prev freesectors=%d, prev releasesectors=%d\n",
prev_freesectors, prev_releasesectors);
if (prev_freecount)
{
for (x = 0; x < dev->neraseblocks; x++)
{
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
blockfree = smart_get_count(dev, dev->freecount, x);
blockrelease = smart_get_count(dev, dev->releasecount, x);
#else
blockfree = dev->freecount[x];
blockrelease = dev->releasecount[x];
#endif
if (prev_freecount[x] != blockfree ||
prev_releasecount[x] != blockrelease)
{
/* This block's values are different from the last time ...
* report it.
*/
fwarn(" ... Block %d: Old Free=%d, old release=%d, "
"New free=%d, new release = %d\n",
x, prev_freecount[x], prev_releasecount[x],
blockfree, blockrelease);
}
}
}
/* Modify the freesector count to reflect the actual calculated
* freecount to get us back in line.
*/
dev->freesectors = freecount;
return -EIO;
}
/* Make a copy of the freecount and releasecount arrays to compare the
* differences between successive calls so we can evaluate what changed
* in the event an error is detected.
*/
if (prev_freecount == NULL)
{
prev_freecount = (FAR uint8_t *)
smart_malloc(dev, dev->neraseblocks << 1, "Free backup");
prev_releasecount = prev_freecount + dev->neraseblocks;
}
if (prev_freecount != NULL)
{
for (x = 0; x < dev->neraseblocks; x++)
{
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
prev_freecount[x] = smart_get_count(dev, dev->freecount, x);
prev_releasecount[x] = smart_get_count(dev, dev->releasecount, x);
#else
prev_freecount[x] = dev->freecount[x];
prev_releasecount[x] = dev->releasecount[x];
#endif
}
}
/* Save the previous freesectors count */
prev_freesectors = dev->freesectors;
prev_releasesectors = dev->releasesectors;
#endif
return OK;
}
#endif
/****************************************************************************
* Name: smart_reload
*
* Description: Read the specified number of sectors
*
****************************************************************************/
static ssize_t smart_reload(struct smart_struct_s *dev, FAR uint8_t *buffer,
off_t startblock, size_t nblocks)
{
ssize_t nread;
ssize_t mtdblocks;
ssize_t mtdstartblock;
/* Calculate the number of MTD blocks to read */
mtdblocks = nblocks * dev->mtdblkspersector;
/* Calculate the first MTD block number */
mtdstartblock = startblock * dev->mtdblkspersector;
/* Read the full erase block into the buffer */
2021-08-09 22:48:00 +02:00
finfo("Read %zu blocks starting at block %zu\n",
mtdblocks, mtdstartblock);
nread = MTD_BREAD(dev->mtd, mtdstartblock, mtdblocks, buffer);
if (nread != mtdblocks)
{
ferr("ERROR: Read %zd blocks starting at block %" PRIdOFF
" failed: %zd\n", nblocks, startblock, nread);
}
return nread;
}
/****************************************************************************
* Name: smart_read
*
* Description: Read the specified number of sectors
*
****************************************************************************/
static ssize_t smart_read(FAR struct inode *inode, unsigned char *buffer,
blkcnt_t start_sector, unsigned int nsectors)
{
FAR struct smart_struct_s *dev;
finfo("SMART: sector: %" PRIuOFF " nsectors: %u\n",
start_sector, nsectors);
DEBUGASSERT(inode && inode->i_private);
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
dev = ((FAR struct smart_multiroot_device_s *)inode->i_private)->dev;
#else
dev = (struct smart_struct_s *)inode->i_private;
#endif
return smart_reload(dev, buffer, start_sector, nsectors);
}
/****************************************************************************
* Name: smart_write
*
* Description: Write (or buffer) the specified number of sectors
*
****************************************************************************/
static ssize_t smart_write(FAR struct inode *inode,
FAR const unsigned char *buffer,
blkcnt_t start_sector, unsigned int nsectors)
{
FAR struct smart_struct_s *dev;
off_t alignedblock;
off_t mask;
off_t blkstowrite;
off_t offset;
off_t nextblock;
off_t mtdblkspererase;
off_t eraseblock;
size_t remaining;
size_t nxfrd;
int ret;
off_t mtdstartblock;
off_t mtdblockcount;
finfo("sector: %" PRIuOFF " nsectors: %u\n", start_sector, nsectors);
DEBUGASSERT(inode && inode->i_private);
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
dev = ((FAR struct smart_multiroot_device_s *)inode->i_private)->dev;
#else
dev = (FAR struct smart_struct_s *)inode->i_private;
#endif
/* I think maybe we need to lock on a mutex here */
/* Get the aligned block. Here is is assumed: (1) The number of R/W blocks
* per erase block is a power of 2, and (2) the erase begins with that same
* alignment.
*/
mask = dev->sectorsperblk - 1;
alignedblock = ((start_sector + mask) & ~mask) * dev->mtdblkspersector;
/* Convert SMART blocks into MTD blocks */
mtdstartblock = start_sector * dev->mtdblkspersector;
mtdblockcount = nsectors * dev->mtdblkspersector;
mtdblkspererase = dev->mtdblkspersector * dev->sectorsperblk;
finfo("mtdsector: %" PRIdOFF " mtdnsectors: %" PRIdOFF "\n",
mtdstartblock, mtdblockcount);
/* Start at first block to be written */
remaining = mtdblockcount;
nextblock = mtdstartblock;
offset = 0;
/* Loop for all blocks to be written */
while (remaining > 0)
{
/* If this is an aligned block, then erase the block */
if (alignedblock == nextblock)
{
/* Erase the erase block */
eraseblock = alignedblock / mtdblkspererase;
ret = MTD_ERASE(dev->mtd, eraseblock, 1);
if (ret < 0)
{
ferr("ERROR: Erase block=%" PRIdOFF " failed: %d\n",
eraseblock, ret);
/* Unlock the mutex if we add one */
return ret;
}
}
/* Calculate the number of blocks to write. */
blkstowrite = mtdblkspererase;
if (nextblock != alignedblock)
{
blkstowrite = alignedblock - nextblock;
}
if (blkstowrite > remaining)
{
blkstowrite = remaining;
}
/* Try to write to the sector. */
finfo("Write MTD block %" PRIdOFF " from offset %" PRIdOFF "\n",
nextblock, offset);
nxfrd = MTD_BWRITE(dev->mtd, nextblock, blkstowrite, &buffer[offset]);
if (nxfrd != blkstowrite)
{
/* The block is not empty!! What to do? */
ferr("ERROR: Write block %" PRIdOFF " failed: %zd.\n",
nextblock, nxfrd);
/* Unlock the mutex if we add one */
return -EIO;
}
/* Then update for amount written */
nextblock += blkstowrite;
remaining -= blkstowrite;
offset += blkstowrite * dev->geo.blocksize;
alignedblock += mtdblkspererase;
}
return nsectors;
}
/****************************************************************************
* Name: smart_geometry
*
* Description: Return device geometry
*
****************************************************************************/
static int smart_geometry(FAR struct inode *inode, struct geometry *geometry)
{
FAR struct smart_struct_s *dev;
uint32_t erasesize;
finfo("Entry\n");
DEBUGASSERT(inode);
if (geometry)
{
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
dev = ((FAR struct smart_multiroot_device_s *)inode->i_private)->dev;
#else
dev = (FAR struct smart_struct_s *)inode->i_private;
#endif
geometry->geo_available = true;
geometry->geo_mediachanged = false;
geometry->geo_writeenabled = true;
erasesize = dev->geo.erasesize;
geometry->geo_nsectors = dev->geo.neraseblocks * erasesize /
dev->sectorsize;
geometry->geo_sectorsize = dev->sectorsize;
finfo("available: true mediachanged: false writeenabled: %s\n",
geometry->geo_writeenabled ? "true" : "false");
finfo("nsectors: %" PRIuOFF " sectorsize: %" PRIi16 "\n",
geometry->geo_nsectors, geometry->geo_sectorsize);
return OK;
}
return -EINVAL;
}
/****************************************************************************
* Name: smart_setsectorsize
*
* Description: Sets the device's sector size and recalculates sector size
* dependent variables.
*
****************************************************************************/
static int smart_setsectorsize(FAR struct smart_struct_s *dev, uint16_t size)
{
uint32_t erasesize;
uint32_t totalsectors;
uint32_t allocsize;
/* Validate the size isn't zero so we don't divide by zero below */
if (size == 0)
{
size = CONFIG_MTD_SMART_SECTOR_SIZE;
}
if (size == dev->sectorsize)
{
return OK;
}
erasesize = dev->geo.erasesize;
dev->neraseblocks = dev->geo.neraseblocks;
dev->erasesize = erasesize;
dev->sectorsize = size;
dev->mtdblkspersector = dev->sectorsize / dev->geo.blocksize;
DEBUGASSERT(dev->sectorsize >= dev->geo.blocksize);
DEBUGASSERT(erasesize / dev->sectorsize <= 256);
if (erasesize / dev->sectorsize > 256)
{
/* We can't throw a error message here because it is too early.
* set the erasesize to zero and exit, then we will detect
* it during mksmartfs or mount.
*/
dev->erasesize = 0;
dev->sectorsperblk = 256;
dev->availsectperblk = 255;
}
else
{
2020-11-22 07:18:52 +01:00
/* Set the sectors per erase block and available sectors per erase
* block
*/
dev->sectorsperblk = erasesize / dev->sectorsize;
if (dev->sectorsperblk == 256)
{
dev->availsectperblk = 255;
}
else if (dev->sectorsperblk == 0)
{
return -EINVAL;
}
else
{
dev->availsectperblk = dev->sectorsperblk;
}
}
#if defined(CONFIG_FS_PROCFS) && !defined(CONFIG_FS_PROCFS_EXCLUDE_SMARTFS)
dev->unusedsectors = 0;
dev->blockerases = 0;
#endif
/* Release any existing rwbuffer and smap */
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
if (dev->smap != NULL)
{
smart_free(dev, dev->smap);
dev->smap = NULL;
}
#else
if (dev->sbitmap != NULL)
{
smart_free(dev, dev->sbitmap);
dev->sbitmap = NULL;
}
dev->cache_entries = 0;
dev->cache_lastlog = 0xffff;
dev->cache_nextbirth = 0;
#endif
if (dev->rwbuffer != NULL)
{
smart_free(dev, dev->rwbuffer);
dev->rwbuffer = NULL;
}
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
if (dev->wearstatus != NULL)
{
smart_free(dev, dev->wearstatus);
dev->wearstatus = NULL;
}
#endif
/* Allocate a virtual to physical sector map buffer. Also allocate
* the storage space for releasecount and freecounts.
*/
totalsectors = dev->neraseblocks * dev->sectorsperblk;
/* Validate the number of total sectors is small enough for a uint16_t */
if (totalsectors > 65536)
{
ferr("ERROR: Invalid SMART sector count %" PRIu32 "\n", totalsectors);
return -EINVAL;
}
else if (totalsectors == 65536)
{
/* Special case. We allow 65536 sectors and simply waste 2 sectors
* to allow a smaller sector size with almost maximum flash usage.
*/
totalsectors -= 2;
}
dev->totalsectors = (uint16_t) totalsectors;
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
allocsize = dev->neraseblocks << 1;
dev->smap = (FAR uint16_t *)
smart_malloc(dev, totalsectors * sizeof(uint16_t) + allocsize,
"Sector map");
if (!dev->smap)
{
ferr("ERROR: Error allocating SMART virtual map buffer\n");
goto errexit;
}
dev->releasecount = (FAR uint8_t *) dev->smap +
(totalsectors * sizeof(uint16_t));
dev->freecount = dev->releasecount + dev->neraseblocks;
#else
dev->sbitmap = (FAR uint8_t *)
smart_malloc(dev, (totalsectors + 7) >> 3, "Sector Bitmap");
if (dev->sbitmap == NULL)
{
ferr("ERROR: Error allocating SMART sector cache\n");
goto errexit;
}
/* Calculate the alloc size of the freesector and release sector arrays */
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
if (dev->sectorsperblk > 16)
{
allocsize = dev->neraseblocks << 1;
}
else if (dev->sectorsperblk == 16)
{
allocsize = dev->neraseblocks + (dev->neraseblocks >> 2);
}
else
{
allocsize = dev->neraseblocks;
}
#else
allocsize = dev->neraseblocks << 1;
#endif
/* Allocate the sector cache */
if (dev->scache == NULL)
{
dev->scache = (FAR struct smart_cache_s *) smart_malloc(dev,
CONFIG_MTD_SMART_SECTOR_CACHE_SIZE * sizeof(struct smart_cache_s) +
allocsize, "Sector Cache");
}
if (!dev->scache)
{
ferr("ERROR: Error allocating SMART sector cache\n");
goto errexit;
}
dev->releasecount = (FAR uint8_t *)dev->scache +
(CONFIG_MTD_SMART_SECTOR_CACHE_SIZE * sizeof(struct smart_cache_s));
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
if (dev->sectorsperblk > 16)
{
dev->freecount = dev->releasecount + dev->neraseblocks;
}
else if (dev->sectorsperblk == 16)
{
dev->freecount = dev->releasecount + (dev->neraseblocks >> 1) +
(dev->neraseblocks >> 3);
}
else
{
dev->freecount = dev->releasecount + (dev->neraseblocks >> 1);
}
#else
dev->freecount = dev->releasecount + dev->neraseblocks;
#endif
#endif /* CONFIG_MTD_SMART_MINIMIZE_RAM */
#ifdef CONFIG_MTD_SMART_SECTOR_ERASE_DEBUG
/* Allocate a buffer to hold the erase counts */
if (dev->erasecounts == NULL)
{
dev->erasecounts = (FAR uint8_t *)
smart_malloc(dev, dev->neraseblocks, "Erase counts");
}
if (!dev->erasecounts)
{
ferr("ERROR: Error allocating erase count array\n");
goto errexit;
}
memset(dev->erasecounts, 0, dev->neraseblocks);
#endif
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
/* Allocate the wear leveling status array */
dev->wearstatus = (FAR uint8_t *) smart_malloc(dev, dev->neraseblocks >>
SMART_WEAR_BIT_DIVIDE, "Wear status");
if (!dev->wearstatus)
{
ferr("ERROR: Error allocating wear level status array\n");
goto errexit;
}
memset(dev->wearstatus, CONFIG_SMARTFS_ERASEDSTATE, dev->neraseblocks >>
SMART_WEAR_BIT_DIVIDE);
dev->wearflags = 0;
dev->uneven_wearcount = 0;
#endif
/* Allocate a read/write buffer */
dev->rwbuffer = (FAR char *) smart_malloc(dev, size, "RW Buffer");
if (!dev->rwbuffer)
{
ferr("ERROR: Error allocating SMART read/write buffer\n");
goto errexit;
}
return OK;
/* On error for any allocation, we jump here and free anything that had
* previously been allocated.
*/
errexit:
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
if (dev->smap)
{
smart_free(dev, dev->smap);
dev->smap = NULL;
}
#else
if (dev->sbitmap)
{
smart_free(dev, dev->sbitmap);
dev->sbitmap = NULL;
}
if (dev->scache)
{
smart_free(dev, dev->scache);
dev->scache = NULL;
}
#endif
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
if (dev->wearstatus)
{
smart_free(dev, dev->wearstatus);
dev->wearstatus = NULL;
}
#endif
#ifdef CONFIG_MTD_SMART_SECTOR_ERASE_DEBUG
if (dev->erasecounts)
{
smart_free(dev, dev->erasecounts);
dev->erasecounts = NULL;
}
#endif
return -ENOMEM;
}
/****************************************************************************
* 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 actually changed.
*
****************************************************************************/
static ssize_t smart_bytewrite(FAR struct smart_struct_s *dev, size_t offset,
int nbytes, FAR 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 */
uint32_t startblock;
uint16_t nblocks;
/* First calculate the start block and number of blocks affected */
startblock = offset / dev->geo.blocksize;
nblocks = (offset - startblock * dev->geo.blocksize + nbytes +
dev->geo.blocksize - 1) / dev->geo.blocksize;
DEBUGASSERT(nblocks <= dev->mtdblkspersector);
/* Do a block read */
ret = MTD_BREAD(dev->mtd, startblock, nblocks,
(FAR uint8_t *)dev->rwbuffer);
if (ret < 0)
{
2021-08-09 22:48:00 +02:00
ferr("ERROR: Error %zd 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,
(FAR uint8_t *) dev->rwbuffer);
if (ret < 0)
{
2021-08-09 22:48:00 +02:00
ferr("ERROR: Error %zd writing to device\n", -ret);
goto errout;
}
}
ret = nbytes;
errout:
return ret;
}
/****************************************************************************
* Name: smart_add_sector_to_cache
*
2018-12-27 15:45:26 +01:00
* Description: Adds a logical to physical sector mapping to the sector
* map cache. The cache is used to minimize RAM by eliminating
* a one-to-one mapping of all logical sectors and only keeping
* a fixed number of mappings per the
* CONFIG_MTD_SMART_SECTOR_CACHE_SIZE parameter. Sectors are
* automatically managed and removed based on the time since
* they were accessed last.
*
****************************************************************************/
#ifdef CONFIG_MTD_SMART_MINIMIZE_RAM
static int smart_add_sector_to_cache(FAR struct smart_struct_s *dev,
uint16_t logical, uint16_t physical, int line)
{
uint16_t index;
uint16_t x;
uint16_t oldest;
/* If we aren't full yet, just add the sector to the end of the list */
index = 1;
if (dev->cache_entries < CONFIG_MTD_SMART_SECTOR_CACHE_SIZE)
{
oldest = 0;
index = dev->cache_entries++;
}
else
{
2020-11-22 07:18:52 +01:00
/* Cache is full. We must find the least accessed entry and replace
* it
*/
oldest = 0xffff;
for (x = 0; x < CONFIG_MTD_SMART_SECTOR_CACHE_SIZE; x++)
{
/* Never replace cache entries for system sectors */
if (dev->scache[x].logical < SMART_FIRST_ALLOC_SECTOR)
continue;
/* If the hit count is zero, then choose this entry */
if (dev->scache[x].birth < oldest)
{
oldest = dev->scache[x].birth;
index = x;
}
}
}
/* Now add the sector at index */
dev->scache[index].logical = logical;
dev->scache[index].physical = physical;
dev->scache[index].birth = dev->cache_nextbirth++;
dev->cache_lastlog = logical;
dev->cache_lastphys = physical;
if (dev->debuglevel > 1)
{
_err("Add Cache sector: Log=%d, Phys=%d at index %d from line %d\n",
logical, physical, index, line);
}
/* Test if the birthdays need to be adjusted */
if (oldest >= CONFIG_MTD_SMART_SECTOR_CACHE_SIZE + 1024)
{
for (x = 0; x < dev->cache_entries; x++)
{
dev->scache[x].birth -= 1024;
}
dev->cache_nextbirth -= 1024;
}
return index;
}
#endif
/****************************************************************************
* Name: smart_cache_lookup
*
* Description: Perform a cache lookup for the requested logical sector.
* If the sector is in the cache, then update the hitcount and
* return the physical mapping. If a cache miss occurs, then
* the routine will scan the volume to find the logical sector
* and add / replace a cache entry with the newly located
* sector.
*
****************************************************************************/
#ifdef CONFIG_MTD_SMART_MINIMIZE_RAM
static uint16_t smart_cache_lookup(FAR struct smart_struct_s *dev,
uint16_t logical)
{
int ret;
uint16_t block;
uint16_t sector;
uint16_t x;
uint16_t physical;
uint16_t logicalsector;
struct smart_sect_header_s header;
size_t readaddress;
physical = 0xffff;
/* Test if searching for the last sector used */
if (logical == dev->cache_lastlog)
{
return dev->cache_lastphys;
}
/* First search for the entry in the cache */
for (x = 0; x < dev->cache_entries; x++)
{
if (dev->scache[x].logical == logical)
{
/* Entry found in the cache. Grab the physical mapping. */
physical = dev->scache[x].physical;
break;
}
}
/* If the entry wasn't found in the cache, then we must search the volume
* for it and add it to the cache.
*/
if (physical == 0xffff)
{
/* Now scan the MTD device. Instead of scanning start to end, we
* span the erase blocks and read one sector from each at a time.
* this helps speed up the search on volumes that aren't full
* because of sector allocation scheme will use the lower sector
* numbers in each erase block first.
*/
for (sector = 0;
sector < dev->availsectperblk && physical == 0xffff;
sector++)
{
/* Now scan across each erase block */
for (block = 0; block < dev->geo.neraseblocks; block++)
{
/* Calculate the read address for this sector */
readaddress = block * dev->erasesize +
sector * dev->sectorsize;
/* Read the header for this sector */
ret = MTD_READ(dev->mtd, readaddress,
sizeof(struct smart_sect_header_s),
(FAR uint8_t *) &header);
if (ret != sizeof(struct smart_sect_header_s))
{
goto err_out;
}
/* Get the logical sector number for this physical sector */
logicalsector = *((FAR uint16_t *) header.logicalsector);
#if CONFIG_SMARTFS_ERASEDSTATE == 0x00
if (logicalsector == 0)
{
continue;
}
#endif
/* Test if this sector has been committed */
if ((header.status & SMART_STATUS_COMMITTED) ==
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_COMMITTED))
{
continue;
}
/* Test if this sector has been release and skip it if it has */
if ((header.status & SMART_STATUS_RELEASED) !=
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_RELEASED))
{
continue;
}
if ((header.status & SMART_STATUS_VERBITS) !=
SMART_STATUS_VERSION)
{
continue;
}
/* Test if this is the sector we are looking for */
if (logicalsector == logical)
{
2020-11-22 07:18:52 +01:00
/* This is the sector we are looking for! Add it to the
* cache
*/
physical = block * dev->sectorsperblk + sector;
smart_add_sector_to_cache(dev, logical, physical,
__LINE__);
break;
}
}
}
}
/* Update the last logical sector found variable */
dev->cache_lastlog = logical;
dev->cache_lastphys = physical;
err_out:
return physical;
}
#endif
/****************************************************************************
* Name: smart_update_cache
*
* Description: Updates a cache entry (if present) replacing the logical
* sector's physical sector mapping with the new one provided.
* This does not affect the hit count.
*
****************************************************************************/
#ifdef CONFIG_MTD_SMART_MINIMIZE_RAM
static void smart_update_cache(FAR struct smart_struct_s *dev, uint16_t
logical, uint16_t physical)
{
uint16_t x;
/* Scan through all cache entries and find the logical sector entry */
for (x = 0; x < dev->cache_entries; x++)
{
if (dev->scache[x].logical == logical)
{
/* Entry found. Update it's physical mapping */
dev->scache[x].physical = physical;
/* If we are freeing a sector, then remove the logical entry from
* the cache.
*/
if (physical == 0xffff)
{
dev->scache[x].logical =
dev->scache[dev->cache_entries - 1].logical;
dev->scache[x].physical =
dev->scache[dev->cache_entries - 1].physical;
dev->cache_entries--;
}
if (dev->debuglevel > 1)
{
_err("Update Cache: Log=%d, Phys=%d at index %d\n",
logical, physical, x);
}
break;
}
}
if (dev->cache_lastlog == logical)
{
dev->cache_lastphys = physical;
}
}
#endif
/****************************************************************************
* Name: smart_get_wear_level
*
* Description: Gets the wear level of the specified block. Wear levels are
* encoded to minimize the number of zero to one transitions,
* possibly allowing updates to made on NOR devices that have
* no CRC enabled.
*
****************************************************************************/
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
static uint8_t smart_get_wear_level(FAR struct smart_struct_s *dev,
uint16_t block)
{
uint8_t bits;
bits = dev->wearstatus[block >> SMART_WEAR_BIT_DIVIDE];
if (block & 0x01)
{
/* Use the upper nibble */
bits >>= 4;
}
else
{
/* Use the lower nibble */
bits &= 0x0f;
}
/* Lookup and return the level using the BitToLevel map */
return g_wearbit_to_levelmap4[bits];
}
#endif
/****************************************************************************
* Name: smart_find_wear_minmax
*
* Description: Find the minimum and maximum wear levels. This is used when
* we increment the wear level of a minimum value block so that
* we can detect if a new minimum exists and perform
* normalization of the wear-levels.
*
****************************************************************************/
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
static void smart_find_wear_minmax(FAR struct smart_struct_s *dev)
{
uint16_t x;
unsigned char level;
dev->minwearlevel = 15;
dev->maxwearlevel = 0;
/* Loop through all erase blocks and find min / max level */
for (x = 0; x < dev->geo.neraseblocks; x++)
{
/* Find wear level of the minimum worn block */
level = smart_get_wear_level(dev, x);
if (level < dev->minwearlevel)
{
dev->minwearlevel = level;
}
/* Find wear level of the maximum worn block */
if (level > dev->maxwearlevel)
{
dev->maxwearlevel = level;
}
}
#ifdef CONFIG_MTD_SMART_SECTOR_ERASE_DEBUG
/* Also adjust the erase counts */
level = 255;
for (x = 0; x < dev->geo.neraseblocks; x++)
{
if (dev->erasecounts[x] < level)
{
level = dev->erasecounts[x];
}
}
if (level != 0)
{
for (x = 0; x < dev->geo.neraseblocks; x++)
{
dev->erasecounts[x] -= level;
}
}
#endif
}
#endif
/****************************************************************************
* Name: smart_set_wear_level
*
* Description: Sets the wear level of the specified block. The wear level
* is a 4-bit field packed 2 entries per byte and is mapped to
* a bit field which minimizes the number of 0 to 1 transitions
2018-12-27 15:45:26 +01:00
* such that entries can be updated on a NOR flash without the
* need to relocate the format sector (assuming CRC is not
* enabled, in which case a relocated is needed for ANY change).
*
****************************************************************************/
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
static int smart_set_wear_level(FAR struct smart_struct_s *dev,
uint16_t block, uint8_t level)
{
uint8_t bits;
uint8_t oldlevel;
/* Get the old wear level to test if we need to update min / max */
oldlevel = smart_get_wear_level(dev, block);
/* Get the bit map for this wear level from the static map array */
if (level > 15)
{
_err("ERROR: Fatal Design Error! Wear level > 15, block=%d\n", block);
/* This is a design flaw, but we still allow processing, otherwise we
* will corrupt the volume. It's better to have a few blocks that are
* worn a bit more than to create an error condition on the volume.
*
* Set the level to the maximum value and add to the un-even wear count
* to keep track of the number of times this has happened.
*/
level = 15;
dev->uneven_wearcount++;
}
bits = g_wearlevel_to_bitmap4[level];
if (block & 0x01)
{
/* Use the upper nibble */
dev->wearstatus[block >> SMART_WEAR_BIT_DIVIDE] &= 0x0f;
dev->wearstatus[block >> SMART_WEAR_BIT_DIVIDE] |= bits << 4;
}
else
{
/* Use the lower nibble */
dev->wearstatus[block >> SMART_WEAR_BIT_DIVIDE] &= 0xf0;
dev->wearstatus[block >> SMART_WEAR_BIT_DIVIDE] |= bits;
}
/* Mark wear bits as dirty */
dev->wearflags |= SMART_WEARFLAGS_WRITE_NEEDED;
/* Test if min / max need to be updated */
if (oldlevel + 1 == level)
{
/* Test if max needs to be updated */
if (level > dev->maxwearlevel)
{
dev->maxwearlevel = level;
}
/* Test if this was the min level. If it was, then
* we need to rescan for min.
*/
if (oldlevel == dev->minwearlevel)
{
smart_find_wear_minmax(dev);
if (oldlevel != dev->minwearlevel)
finfo("##### New min wear level = %d\n", dev->minwearlevel);
}
}
return 0;
}
#endif
/****************************************************************************
* Name: smart_scan
*
* Description: Performs a scan of the MTD device searching for format
* information and fills in logical sector mapping, freesector
* count, etc.
*
****************************************************************************/
static int smart_scan(FAR struct smart_struct_s *dev)
{
int sector;
int ret;
uint16_t totalsectors;
uint16_t sectorsize;
uint16_t prerelease;
uint16_t logicalsector;
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
uint16_t winner;
uint16_t loser;
uint32_t readaddress;
uint32_t offset;
uint16_t seq1;
uint16_t seq2;
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
uint16_t seqwrap;
struct smart_sect_header_s header;
#ifdef CONFIG_MTD_SMART_MINIMIZE_RAM
int dupsector;
uint16_t duplogsector;
#endif
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
int x;
char devname[32];
FAR struct smart_multiroot_device_s *rootdirdev;
#endif
static const uint16_t sizetbl[8] =
{
CONFIG_MTD_SMART_SECTOR_SIZE,
512, 1024, 4096, 2048, 8192, 16384, 32768
};
finfo("Entry\n");
/* Find the sector size on the volume by reading headers from
* sectors of decreasing size. On a formatted volume, the sector
* size is saved in the header status byte of search sector, so
* by starting with the largest supported sector size and
* decreasing from there, we will be sure to find data that is
* a header and not sector data.
*/
sectorsize = 0xffff;
offset = 16384;
while (sectorsize == 0xffff)
{
readaddress = 0;
while (readaddress < dev->erasesize * dev->geo.neraseblocks)
{
/* Read the next sector from the device */
ret = MTD_READ(dev->mtd, readaddress,
sizeof(struct smart_sect_header_s),
(FAR uint8_t *) &header);
if (ret != sizeof(struct smart_sect_header_s))
{
goto err_out;
}
if (header.status != CONFIG_SMARTFS_ERASEDSTATE)
{
sectorsize =
sizetbl[(header.status & SMART_STATUS_SIZEBITS) >> 2];
break;
}
readaddress += offset;
}
if (sectorsize == 0xffff)
{
sectorsize = CONFIG_MTD_SMART_SECTOR_SIZE;
}
offset >>= 1;
if (offset < 256 && sectorsize == 0xffff)
{
/* No valid sectors found on device. Default the
* sector size to the CONFIG value
*/
sectorsize = CONFIG_MTD_SMART_SECTOR_SIZE;
}
}
/* Now set the sectorsize and other sectorsize derived variables */
ret = smart_setsectorsize(dev, sectorsize);
if (ret != OK)
{
goto err_out;
}
/* Initialize the device variables */
totalsectors = dev->totalsectors;
dev->formatstatus = SMART_FMT_STAT_NOFMT;
dev->freesectors = dev->availsectperblk * dev->geo.neraseblocks;
dev->releasesectors = 0;
/* Initialize the freecount and releasecount arrays */
for (sector = 0; sector < dev->neraseblocks; sector++)
{
if (sector == dev->neraseblocks - 1 && dev->totalsectors == 65534)
{
prerelease = 2;
}
else
{
prerelease = 0;
}
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
smart_set_count(dev, dev->freecount, sector,
dev->availsectperblk - prerelease);
smart_set_count(dev, dev->releasecount, sector, prerelease);
#else
dev->freecount[sector] = dev->availsectperblk - prerelease;
dev->releasecount[sector] = prerelease;
#endif
}
/* Initialize the sector map */
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
for (sector = 0; sector < totalsectors; sector++)
{
dev->smap[sector] = -1;
}
#else
/* Clear all logical sector used bits */
memset(dev->sbitmap, 0, (dev->totalsectors + 7) >> 3);
#endif
/* Now scan the MTD device */
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
/* At first, set the loser sector as the invalid value */
loser = totalsectors;
for (sector = 0; sector < totalsectors; sector++)
{
finfo("Scan sector %d\n", sector);
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
winner = sector;
/* Calculate the read address for this sector */
readaddress = sector * dev->mtdblkspersector * dev->geo.blocksize;
/* Read the header for this sector */
ret = MTD_READ(dev->mtd, readaddress,
sizeof(struct smart_sect_header_s),
(FAR uint8_t *)&header);
if (ret != sizeof(struct smart_sect_header_s))
{
goto err_out;
}
/* Get the logical sector number for this physical sector */
logicalsector = *((FAR uint16_t *) header.logicalsector);
#if CONFIG_SMARTFS_ERASEDSTATE == 0x00
if (logicalsector == 0)
{
logicalsector = -1;
}
#endif
/* Test if this sector has been committed */
if ((header.status & SMART_STATUS_COMMITTED) ==
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_COMMITTED))
{
continue;
}
/* This block is committed, therefore not free. Update the
* erase block's freecount.
*/
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
smart_add_count(dev, dev->freecount, sector / dev->sectorsperblk, -1);
#else
dev->freecount[sector / dev->sectorsperblk]--;
#endif
dev->freesectors--;
/* Test if this sector has been release and if it has,
* update the erase block's releasecount.
*/
if ((header.status & SMART_STATUS_RELEASED) !=
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_RELEASED))
{
/* Keep track of the total number of released sectors and
* released sectors per erase block.
*/
dev->releasesectors++;
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
smart_add_count(dev, dev->releasecount,
sector / dev->sectorsperblk, 1);
#else
dev->releasecount[sector / dev->sectorsperblk]++;
#endif
continue;
}
if ((header.status & SMART_STATUS_VERBITS) != SMART_STATUS_VERSION)
{
continue;
}
/* Validate the logical sector number is in bounds */
if (logicalsector >= totalsectors)
{
/* Error in logical sector read from the MTD device */
ferr("ERROR: Invalid logical sector %d at physical %d.\n",
logicalsector, sector);
continue;
}
/* If this is logical sector zero, then read in the signature
* information to validate the format signature.
*/
if (logicalsector == 0)
{
/* Read the sector data */
ret = MTD_READ(dev->mtd, readaddress, 32,
(FAR uint8_t *)dev->rwbuffer);
if (ret != 32)
{
ferr("ERROR: Error reading physical sector %d.\n", sector);
goto err_out;
}
/* Validate the format signature */
if (dev->rwbuffer[SMART_FMT_POS1] != SMART_FMT_SIG1 ||
dev->rwbuffer[SMART_FMT_POS2] != SMART_FMT_SIG2 ||
dev->rwbuffer[SMART_FMT_POS3] != SMART_FMT_SIG3 ||
dev->rwbuffer[SMART_FMT_POS4] != SMART_FMT_SIG4)
{
/* Invalid signature on a sector claiming to be sector 0!
* What should we do? Release it?
*/
continue;
}
/* Mark the volume as formatted and set the sector size */
dev->formatstatus = SMART_FMT_STAT_FORMATTED;
dev->namesize = dev->rwbuffer[SMART_FMT_NAMESIZE_POS];
dev->formatversion = dev->rwbuffer[SMART_FMT_VERSION_POS];
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
dev->rootdirentries = dev->rwbuffer[SMART_FMT_ROOTDIRS_POS];
/* If rootdirentries is greater than 1, then we need to register
* additional block devices.
*/
for (x = 1; x < dev->rootdirentries; x++)
{
if (dev->partname[0] != '\0')
{
snprintf(devname, sizeof(devname), "/dev/smart%d%sd%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.
*/
rootdirdev = (struct smart_multiroot_device_s *)
smart_malloc(dev, sizeof(*rootdirdev), "Root Dir");
if (rootdirdev == NULL)
{
ferr("ERROR: Memory alloc failed\n");
ret = -ENOMEM;
goto err_out;
}
/* Populate the rootdirdev */
rootdirdev->dev = dev;
rootdirdev->rootdirnum = x;
/* Inode private data is a reference to the SMART device
* structure.
*/
ret = register_blockdriver(devname, &g_bops, 0, rootdirdev);
}
#endif
}
/* Test for duplicate logical sectors on the device */
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
if (dev->smap[logicalsector] != 0xffff)
#else
if (dev->sbitmap[logicalsector >> 3] & (1 << (logicalsector & 0x07)))
#endif
{
/* 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.
*/
#if SMART_STATUS_VERSION == 1
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
if ((header.status & SMART_STATUS_CRC) !=
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_CRC))
{
seq2 = header.seq;
}
else
{
seq2 = *((FAR uint16_t *) &header.seq);
}
#else
seq2 = header.seq;
#endif
/* We must re-read the 1st physical sector to get it's seq number */
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
readaddress = dev->smap[logicalsector] * dev->mtdblkspersector *
dev->geo.blocksize;
#else
/* For minimize RAM, we have to rescan to find the 1st sector
* claiming to be this logical sector.
*/
for (dupsector = 0; dupsector < sector; dupsector++)
{
/* Calculate the read address for this sector */
readaddress = dupsector * dev->mtdblkspersector *
dev->geo.blocksize;
/* Read the header for this sector */
ret = MTD_READ(dev->mtd, readaddress,
sizeof(struct smart_sect_header_s),
(FAR uint8_t *) &header);
if (ret != sizeof(struct smart_sect_header_s))
{
goto err_out;
}
/* Get the logical sector number for this physical sector */
duplogsector = *((FAR uint16_t *) header.logicalsector);
#if CONFIG_SMARTFS_ERASEDSTATE == 0x00
if (duplogsector == 0)
{
duplogsector = -1;
}
#endif
/* Test if this sector has been committed */
if ((header.status & SMART_STATUS_COMMITTED) ==
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_COMMITTED))
{
continue;
}
/* Test if this sector has been release and skip it if it has */
if ((header.status & SMART_STATUS_RELEASED) !=
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_RELEASED))
{
continue;
}
if ((header.status & SMART_STATUS_VERBITS) !=
SMART_STATUS_VERSION)
{
continue;
}
2020-11-22 07:18:52 +01:00
/* Now compare if this logical sector matches the current
* sector
*/
if (duplogsector == logicalsector)
{
break;
}
}
#endif
ret = MTD_READ(dev->mtd, readaddress,
sizeof(struct smart_sect_header_s),
(FAR uint8_t *) &header);
if (ret != sizeof(struct smart_sect_header_s))
{
goto err_out;
}
#if SMART_STATUS_VERSION == 1
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
if ((header.status & SMART_STATUS_CRC) !=
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_CRC))
{
seq1 = header.seq;
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
seqwrap = 0xf0;
}
else
{
seq1 = *((FAR uint16_t *) &header.seq);
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
seqwrap = 0xfff0;
}
#else
seq1 = header.seq;
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
seqwrap = 0xf0;
#endif
/* Now determine who wins */
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
if ((seq1 > seqwrap && seq2 < 10) || seq2 > seq1)
{
/* Seq 2 is the winner ... bigger or it wrapped */
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
winner = sector;
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
loser = dev->smap[logicalsector];
#else
loser = dupsector;
#endif
}
else
{
/* We keep the original mapping and seq2 is the loser */
loser = sector;
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
winner = dev->smap[logicalsector];
#else
winner = smart_cache_lookup(dev, logicalsector);
#endif
}
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
finfo("Duplicate Sector winner=%d, loser=%d\n", winner, loser);
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
/* Check CRC of the winner sector just in case */
ret = MTD_BREAD(dev->mtd, winner * dev->mtdblkspersector,
dev->mtdblkspersector,
(FAR uint8_t *) dev->rwbuffer);
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
if (ret == dev->mtdblkspersector)
{
/* Validate the CRC of the read-back data */
ret = smart_validate_crc(dev);
}
if (ret != OK)
{
/* The winner sector has CRC error, so we select the loser
* sector. After swapping the winner and the loser sector, we
* will release the loser sector with CRC error.
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
*/
if (sector == winner)
{
/* winner: sector(CRC error) -> origin
* loser : origin -> sector(CRC error)
*/
winner = loser;
loser = sector;
}
else
{
/* winner: origin(CRC error) -> sector
* loser : sector -> origin(CRC error)
*/
loser = winner;
winner = sector;
}
finfo("Duplicate Sector winner=%d, loser=%d\n", winner, loser);
}
#endif /* CONFIG_MTD_SMART_ENABLE_CRC */
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
/* Now release the loser sector */
readaddress = loser * dev->mtdblkspersector * dev->geo.blocksize;
ret = MTD_READ(dev->mtd, readaddress,
sizeof(struct smart_sect_header_s),
(FAR uint8_t *)&header);
if (ret != sizeof(struct smart_sect_header_s))
{
goto err_out;
}
#if CONFIG_SMARTFS_ERASEDSTATE == 0xff
header.status &= ~SMART_STATUS_RELEASED;
#else
header.status |= SMART_STATUS_RELEASED;
#endif
offset = readaddress +
offsetof(struct smart_sect_header_s, status);
ret = smart_bytewrite(dev, offset, 1, &header.status);
if (ret < 0)
{
ferr("ERROR: Error %d releasing duplicate sector\n", -ret);
goto err_out;
}
}
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
/* Test if this sector is loser of duplicate logical sector */
if (sector == loser)
{
continue;
}
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
/* Update the logical to physical sector map */
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
dev->smap[logicalsector] = winner;
#else
/* Mark the logical sector as used in the bitmap */
dev->sbitmap[logicalsector >> 3] |= 1 << (logicalsector & 0x07);
if (logicalsector < SMART_FIRST_ALLOC_SECTOR)
{
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
smart_add_sector_to_cache(dev, logicalsector, winner, __LINE__);
}
#endif
}
#if defined (CONFIG_MTD_SMART_WEAR_LEVEL) && (SMART_STATUS_VERSION == 1)
#ifdef CONFIG_MTD_SMART_CONVERT_WEAR_FORMAT
/* We need to check if we are converting an older format with incorrect
* wear leveling data in sector zero to the new format. The old format
* put all zeros in the wear level bit locations, but the new (better)
* way is to leave them 0xff.
*/
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
sector = dev->smap[0];
#else
sector = smart_cache_lookup(dev, 0);
#endif
/* Validate the sector is valid ... may be an unformatted device */
if (sector != 0xffff)
{
/* Read the sector data */
ret = MTD_BREAD(dev->mtd, sector * dev->mtdblkspersector,
dev->mtdblkspersector, (uint8_t *) dev->rwbuffer);
if (ret != dev->mtdblkspersector)
{
ferr("ERROR: Error reading physical sector %d.\n", sector);
goto err_out;
}
/* Check for old format wear leveling */
if (dev->rwbuffer[SMART_WEAR_LEVEL_FORMAT_SIG] == 0)
{
/* Old format detected. We must relocate sector zero and fill it
* in with 0xff.
*/
uint16_t newsector = smart_findfreephyssector(dev, FALSE);
if (newsector == 0xffff)
{
/* Unable to find a free sector!!! */
ferr("ERROR: Can't find a free sector for relocation\n");
ret = -ENOSPC;
goto err_out;
}
memset(&dev->rwbuffer[SMART_WEAR_LEVEL_FORMAT_SIG], 0xff,
dev->mtdblkspersector * dev->geo.blocksize -
SMART_WEAR_LEVEL_FORMAT_SIG);
smart_relocate_sector(dev, sector, newsector);
/* Update the free and release sector counts */
dev->freesectors--;
dev->releasesectors++;
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
dev->smap[0] = newsector;
dev->freecount[newsector / dev->sectorsperblk]--;
dev->releasecount[sector / dev->sectorsperblk]++;
#else
smart_update_cache(dev, 0, newsector);
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
smart_add_count(dev, dev->freecount,
newsector / dev->sectorsperblk, -1);
smart_add_count(dev, dev->releasecount,
sector / dev->sectorsperblk, 1);
#endif
#endif
}
}
#endif /* CONFIG_MTD_SMART_CONVERT_WEAR_FORMAT */
#endif /* CONFIG_MTD_SMART_WEAR_LEVEL && SMART_STATUS_VERSION == 1 */
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
#ifdef CONFIG_MTD_SMART_FSCK
smart_fsck(dev);
#endif
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
/* Read the wear leveling status bits */
smart_read_wearstatus(dev);
#endif
finfo("SMART Scan\n");
finfo(" Erase size: %10d\n", dev->sectorsperblk * dev->sectorsize);
finfo(" Erase count: %10d\n", dev->neraseblocks);
finfo(" Sect/block: %10d\n", dev->sectorsperblk);
finfo(" MTD Blk/Sect: %10d\n", dev->mtdblkspersector);
/* Validate the geometry */
if (dev->mtdblkspersector == 0 || dev->sectorsperblk == 0 ||
dev->sectorsperblk == 0 || dev->sectorsize == 0)
{
ferr("ERROR: Invalid Geometry!\n");
ret = -EINVAL;
goto err_out;
}
#ifdef CONFIG_MTD_SMART_ALLOC_DEBUG
finfo(" Allocations:\n");
for (sector = 0; sector < SMART_MAX_ALLOCS; sector++)
{
if (dev->alloc[sector].ptr != NULL)
{
finfo(" %s: %d\n",
dev->alloc[sector].name, dev->alloc[sector].size);
}
}
#endif
ret = OK;
err_out:
return ret;
}
/****************************************************************************
* Name: smart_getformat
*
* Description: Populates the SMART format structure based on the format
* information for the inode.
*
****************************************************************************/
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
static inline int smart_getformat(FAR struct smart_struct_s *dev,
FAR struct smart_format_s *fmt,
uint8_t rootdirnum)
#else
static inline int smart_getformat(FAR struct smart_struct_s *dev,
FAR struct smart_format_s *fmt)
#endif
{
int ret;
finfo("Entry\n");
DEBUGASSERT(fmt);
/* Test if we know the format status or not. If we don't know the
* status, then we must perform a scan of the device to search
* for the format marker
*/
if (dev->formatstatus != SMART_FMT_STAT_FORMATTED)
{
/* Perform the scan */
ret = smart_scan(dev);
if (ret != OK)
{
goto err_out;
}
}
/* Now fill in the structure */
if (dev->formatstatus == SMART_FMT_STAT_FORMATTED)
{
fmt->flags = SMART_FMT_ISFORMATTED;
}
else
{
fmt->flags = 0;
}
fmt->sectorsize = dev->sectorsize;
fmt->availbytes = dev->sectorsize -
sizeof(struct smart_sect_header_s);
fmt->nsectors = dev->totalsectors;
fmt->nfreesectors = dev->freesectors;
fmt->namesize = dev->namesize;
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
fmt->nrootdirentries = dev->rootdirentries;
fmt->rootdirnum = rootdirnum;
#endif
/* Add the released sectors to the reported free sector count */
fmt->nfreesectors += dev->releasesectors;
/* Subtract the reserved sector count */
fmt->nfreesectors -= dev->sectorsperblk + 4;
ret = OK;
err_out:
return ret;
}
/****************************************************************************
* Name: smart_erase_block_if_empty
*
* Description: Tests the specified erase block if it contains all free or
* released sectors and erases it.
*
****************************************************************************/
static void smart_erase_block_if_empty(FAR struct smart_struct_s *dev,
uint16_t block, uint8_t forceerase)
{
uint16_t freecount;
uint16_t releasecount;
uint16_t prerelease;
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
releasecount = smart_get_count(dev, dev->releasecount, block);
freecount = smart_get_count(dev, dev->freecount, block);
#else
releasecount = dev->releasecount[block];
freecount = dev->freecount[block];
#endif
if ((freecount + releasecount == dev->availsectperblk && freecount < 1) ||
forceerase)
{
/* Erase the block */
#if defined(CONFIG_FS_PROCFS) && !defined(CONFIG_FS_PROCFS_EXCLUDE_SMARTFS)
dev->unusedsectors += freecount;
dev->blockerases++;
#endif
MTD_ERASE(dev->mtd, block, 1);
#ifdef CONFIG_MTD_SMART_SECTOR_ERASE_DEBUG
if (dev->erasecounts)
{
dev->erasecounts[block]++;
}
#endif
/* If wear leveling enabled, then we must add one to the wear status */
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
smart_set_wear_level(dev, block, smart_get_wear_level(dev, block) + 1);
#endif
/* If we have a device with 65534 sectors, then disallow the last two
* physical sector if this is the last erase block on the device.
*/
if (block == dev->geo.neraseblocks - 1 && dev->totalsectors == 65534)
{
prerelease = 2;
}
else
{
prerelease = 0;
}
dev->freesectors += dev->availsectperblk - prerelease - freecount;
dev->releasesectors -= releasecount - prerelease;
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
smart_set_count(dev, dev->releasecount, block, prerelease);
smart_set_count(dev, dev->freecount, block,
dev->availsectperblk - prerelease);
#else
dev->releasecount[block] = prerelease;
dev->freecount[block] = dev->availsectperblk - prerelease;
#endif
/* Now that we have erased this block and updated the release / free
* counts, if we are in WEAR LEVELING enabled mode, we must check if
* this erase block's wear level has reached the threshold to warrant
* moving a minimum wear level block's data into it (i.e. relocating
* static data to this block so it will be worn less).
*/
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
if (!forceerase)
{
smart_relocate_static_data(dev, block);
}
#endif
#ifdef CONFIG_SMART_LOCAL_CHECKFREE
if (smart_checkfree(dev, __LINE__) != OK)
{
fwarn(" ...while eraseing block %d\n", block);
}
#endif
}
}
/****************************************************************************
* Name: smart_relocate_static_data
*
* Description: Tests if the specified block has reached the wear threshold
* for static data relocation and if it has, relocates a less
* worn block to it.
*
****************************************************************************/
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
static int smart_relocate_static_data(FAR struct smart_struct_s *dev,
uint16_t block)
{
uint16_t freecount;
uint16_t x;
uint16_t sector;
uint16_t minblock;
uint16_t nextsector;
uint16_t newsector;
uint16_t mincount;
int ret;
FAR struct smart_sect_header_s *header;
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
FAR struct smart_allocsector_s *allocsector;
#endif
/* Now that we have erased this block and updated the release / free
* counts, if we are in WEAR LEVELING enabled mode, we must check if this
* erase block's wear level has reached the threshold to warrant moving a
* minimum wear level block's data into it (i.e. relocating static data to
* this block so it will be worn less).
*/
ret = OK;
header = (FAR struct smart_sect_header_s *) dev->rwbuffer;
#ifdef CONFIG_SMART_LOCAL_CHECKFREE
if (smart_checkfree(dev, __LINE__) != OK)
{
fwarn(" ...about to relocate static data %d\n", block);
}
#endif
if (smart_get_wear_level(dev, block) >= SMART_WEAR_FULL_RELOCATE_THRESHOLD)
{
/* Okay, this block is getting too worn. Move a minimum wear level
* block to it in it's entirety.
*/
/* Scan all erase blocks (or until we find a minimum wear level block
* with no free + released blocks.
*/
freecount = dev->sectorsperblk + 1;
minblock = dev->geo.neraseblocks;
mincount = 0;
for (x = 0; x < dev->geo.neraseblocks; x++)
{
if (smart_get_wear_level(dev, x) == dev->minwearlevel)
{
/* Don't allow the format sector or directory sector to
* be moved into a worn block. First get the format and
* dir sectors.
*/
mincount++;
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
if (smart_get_count(dev, dev->releasecount, x) +
smart_get_count(dev, dev->freecount, x) < freecount)
{
freecount = smart_get_count(dev, dev->releasecount, x) +
smart_get_count(dev, dev->freecount, x);
minblock = x;
}
#else
if (dev->freecount[x] + dev->releasecount[x] < freecount)
{
freecount = dev->freecount[x] + dev->releasecount[x];
minblock = x;
}
#endif
/* Break if freecount reaches zero */
if (freecount == 0)
{
/* We found a minimum wear-level block with no free
* sectors. relocate this block to the more highly worn
* block.
*/
break;
}
}
}
/* Okay, now move block 'x' to block 'block' and erase block 'x' */
x = minblock;
/* We are resuing nextsector and newsector variables here simply as
* variables for displaying debug data. I have learned through my
* years of programming that this is a really good way to create
* spaghetti code, but I didn't want to add stack variables just
* for debug data, and I *know* these variables aren't being used
* yet.
*/
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
nextsector = smart_get_count(dev, dev->freecount, x);
newsector = smart_get_count(dev, dev->releasecount, x);
#else
nextsector = dev->freecount[x];
newsector = dev->releasecount[x];
#endif
finfo("Moving block %d, wear %d, free %d, "
"released %d to block %d, wear %d\n",
x, smart_get_wear_level(dev, x),
nextsector, newsector,
block, smart_get_wear_level(dev, block));
nextsector = block * dev->sectorsperblk;
for (sector = x * dev->sectorsperblk; sector <
x * dev->sectorsperblk + dev->availsectperblk; sector++)
{
/* Read the next sector from this erase block */
ret = MTD_BREAD(dev->mtd, sector * dev->mtdblkspersector,
dev->mtdblkspersector, (FAR uint8_t *) dev->rwbuffer);
if (ret != dev->mtdblkspersector)
{
ferr("ERROR: Error reading sector %d\n", sector);
ret = -EIO;
goto errout;
}
/* Test if the block is in use */
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
/* Check if there is a temporary alloc for this physical sector */
allocsector = dev->allocsector;
while (allocsector)
{
if (allocsector->physical == sector)
{
break;
}
allocsector = allocsector->next;
}
/* If we found a temp allocation, just update the mapped physical
* location and move on to the next block ... there is no data to
* move yet.
*/
if (allocsector)
{
/* Get next sector from 'block' */
newsector = nextsector++;
if (newsector == 0xffff)
{
/* Unable to find a free sector!!! */
ferr("ERROR: Can't find a free sector for relocation\n");
ret = -ENOSPC;
goto errout;
}
/* Update the temporary allocation's physical sector */
allocsector->physical = newsector;
*((FAR uint16_t *) header->logicalsector) =
allocsector->logical;
}
else
#endif
{
if (((header->status & SMART_STATUS_COMMITTED) ==
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_COMMITTED)) ||
((header->status & SMART_STATUS_RELEASED) !=
(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.
*/
continue;
}
2020-11-22 07:18:52 +01:00
/* Find a new sector where it can live, NOT in this erase
* block
*/
newsector = nextsector++;
/* Relocate the sector data */
if ((ret = smart_relocate_sector(dev, sector, newsector)) < 0)
{
goto errout;
}
}
dev->freesectors--;
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
dev->smap[*((FAR uint16_t *) header->logicalsector)] = newsector;
#else
smart_update_cache(dev, *((FAR uint16_t *)header->logicalsector),
newsector);
#endif
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
smart_add_count(dev, dev->freecount, block, -1);
#else
dev->freecount[block]--;
#endif /* CONFIG_MTD_SMART_PACK_COUNTS */
}
#ifdef CONFIG_SMART_LOCAL_CHECKFREE
if (smart_checkfree(dev, __LINE__) != OK)
{
fwarn(" ...about to erase static block %d\n", block);
}
#endif
/* Now erase the block we just relocated, force erasing it */
smart_erase_block_if_empty(dev, x, TRUE);
}
#ifdef CONFIG_SMART_LOCAL_CHECKFREE
if (smart_checkfree(dev, __LINE__) != OK)
{
fwarn(" ...done erasing static block %d\n", block);
}
#endif
errout:
return ret;
}
#endif
/****************************************************************************
* Name: smart_calc_sector_crc
*
* Description: Calculate the CRC value for the sector data in the RW buffer
* based on the configured CRC size.
*
****************************************************************************/
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
static crc_t smart_calc_sector_crc(FAR struct smart_struct_s *dev)
{
crc_t crc = 0;
#ifdef CONFIG_SMART_CRC_8
/* Calculate CRC on data region of the sector */
crc = crc8((FAR uint8_t *)
&dev->rwbuffer[sizeof(struct smart_sect_header_s)],
dev->mtdblkspersector * dev->geo.blocksize -
sizeof(struct smart_sect_header_s));
/* Add logical sector number and seq to the CRC calculation */
crc = crc8part((FAR uint8_t *)dev->rwbuffer, 3, crc);
/* Add status to the CRC calculation */
crc = crc8part((FAR uint8_t *)
&dev->rwbuffer[offsetof(struct smart_sect_header_s, status)], 1, crc);
#elif defined(CONFIG_SMART_CRC_16)
/* Calculate CRC on data region of the sector */
crc = crc16((FAR uint8_t *)
&dev->rwbuffer[sizeof(struct smart_sect_header_s)],
dev->mtdblkspersector * dev->geo.blocksize -
sizeof(struct smart_sect_header_s));
/* Add logical sector number to the CRC calculation */
crc = crc16part((FAR uint8_t *) dev->rwbuffer, 2, crc);
/* Add status and seq to the CRC calculation */
crc = crc16part((uint8_t *)
&dev->rwbuffer[offsetof(struct smart_sect_header_s, status)], 2, crc);
#elif defined(CONFIG_SMART_CRC_32)
/* Calculate CRC on data region of the sector */
crc = crc32((FAR uint8_t *)
&dev->rwbuffer[sizeof(struct smart_sect_header_s)],
dev->mtdblkspersector * dev->geo.blocksize -
sizeof(struct smart_sect_header_s));
/* Add logical sector number, status and seq to the CRC calculation */
crc = crc32part((FAR uint8_t *) dev->rwbuffer, 6, crc);
#else
#error "Unknown CRC size!"
#endif
return crc;
}
#endif /* CONFIG_MTD_SMART_ENABLE_CRC */
/****************************************************************************
* Name: smart_llformat
*
* Description: Performs a low-level format of the flash device. This
* involves erasing the device and writing a valid sector
* zero (logical) with proper format signature.
*
* Input Parameters:
*
* arg: Upper 16 bits contains the sector size
* Lower 16 bits contains the number of root dir entries
*
****************************************************************************/
static inline int smart_llformat(FAR struct smart_struct_s *dev,
unsigned long arg)
{
FAR struct smart_sect_header_s *sectorheader;
size_t wrcount;
int x;
int ret;
uint8_t sectsize;
uint8_t prerelease;
uint16_t sectorsize;
finfo("Entry\n");
/* Get the sector size from the provided arg */
sectorsize = arg >> 16;
if (sectorsize == 0)
{
sectorsize = CONFIG_MTD_SMART_SECTOR_SIZE;
}
/* Set the sector size for the device */
ret = smart_setsectorsize(dev, sectorsize);
if (ret != OK)
{
return ret;
}
/* Check for invalid format */
if (dev->erasesize == 0 || dev->sectorsperblk == 0)
{
dev->erasesize = dev->geo.erasesize;
ferr("ERROR: Invalid geometery ... "
"Sectors per erase block must be 1-256\n");
ferr(" Erase block size = %" PRId32 "\n",
dev->erasesize);
ferr(" Sector size = %d\n",
dev->sectorsize);
ferr(" Sectors/erase block = %" PRId32 "\n",
dev->erasesize / dev->sectorsize);
return -EINVAL;
}
/* Erase the MTD device */
ret = MTD_IOCTL(dev->mtd, MTDIOC_BULKERASE, 0);
if (ret < 0)
{
return ret;
}
/* Now construct a logical sector zero header to write to the device. */
sectorheader = (FAR struct smart_sect_header_s *) dev->rwbuffer;
memset(dev->rwbuffer, CONFIG_SMARTFS_ERASEDSTATE, dev->sectorsize);
#if SMART_STATUS_VERSION == 1
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
/* CRC enabled. Using an 8-bit sequence number */
sectorheader->seq = 0;
#else
/* CRC not enabled. Using a 16-bit sequence number */
*((FAR uint16_t *) &sectorheader->seq) = 0;
#endif
#else /* SMART_STATUS_VERSION == 1 */
sectorheader->seq = 0;
#endif /* SMART_STATUS_VERSION == 1 */
/* Set the sector size of this sector */
sectsize = dev->sectorsize < 4096 ? (dev->sectorsize >> 9) :
dev->sectorsize == 4096 ? 3 : 5 + (dev->sectorsize >> 14);
sectsize <<= 2;
/* Set the sector logical sector to zero and setup the header status */
#if ( CONFIG_SMARTFS_ERASEDSTATE == 0xff )
*((FAR uint16_t *) sectorheader->logicalsector) = 0;
sectorheader->status = (uint8_t)~(SMART_STATUS_COMMITTED |
SMART_STATUS_VERBITS |
SMART_STATUS_SIZEBITS) |
SMART_STATUS_VERSION |
sectsize;
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
sectorheader->status &= ~SMART_STATUS_CRC;
#endif /* CONFIG_MTD_SMART_ENABLE_CRC */
#else /* CONFIG_SMARTFS_ERASEDSTATE == 0xff */
*((FAR uint16_t *) sectorheader->logicalsector) = 0xffff;
sectorheader->status = (uint8_t)(SMART_STATUS_COMMITTED |
SMART_STATUS_VERSION |
sectsize);
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
sectorheader->status |= SMART_STATUS_CRC;
#endif /* CONFIG_MTD_SMART_ENABLE_CRC */
#endif /* CONFIG_SMARTFS_ERASEDSTATE == 0xff */
/* Now add the format signature to the sector */
dev->rwbuffer[SMART_FMT_POS1] = SMART_FMT_SIG1;
dev->rwbuffer[SMART_FMT_POS2] = SMART_FMT_SIG2;
dev->rwbuffer[SMART_FMT_POS3] = SMART_FMT_SIG3;
dev->rwbuffer[SMART_FMT_POS4] = SMART_FMT_SIG4;
dev->rwbuffer[SMART_FMT_VERSION_POS] = SMART_FMT_VERSION;
dev->rwbuffer[SMART_FMT_NAMESIZE_POS] = CONFIG_SMARTFS_MAXNAMLEN;
/* Record the number of root directory entries we have */
dev->rwbuffer[SMART_FMT_ROOTDIRS_POS] = (uint8_t) (arg & 0xff);
#ifdef CONFIG_SMART_CRC_8
sectorheader->crc8 = smart_calc_sector_crc(dev);
#elif defined(CONFIG_SMART_CRC_16)
*((uint16_t *) sectorheader->crc16) = smart_calc_sector_crc(dev);
#elif defined(CONFIG_SMART_CRC_32)
*((uint32_t *) sectorheader->crc32) = smart_calc_sector_crc(dev);
#endif
/* Write the sector to the flash */
wrcount = MTD_BWRITE(dev->mtd, 0, dev->mtdblkspersector,
(FAR uint8_t *) dev->rwbuffer);
if (wrcount != dev->mtdblkspersector)
{
/* The block is not empty!! What to do? */
2021-08-09 22:48:00 +02:00
ferr("ERROR: Write block 0 failed: %zu.\n", wrcount);
/* Unlock the mutex if we add one */
return -EIO;
}
/* Now initialize our internal control variables */
ret = smart_setsectorsize(dev, sectorsize);
if (ret != OK)
{
return ret;
}
dev->formatstatus = SMART_FMT_STAT_UNKNOWN;
dev->freesectors = dev->availsectperblk * dev->geo.neraseblocks - 1;
dev->releasesectors = 0;
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
dev->uneven_wearcount = 0;
#endif
/* Initialize the released and free counts */
for (x = 0; x < dev->neraseblocks; x++)
{
/* Test for a geometry with 65536 sectors. We allow this, though
* we never use the last two sectors in this mode.
*/
if (x == dev->neraseblocks && dev->totalsectors == 65534)
{
prerelease = 2;
}
else
{
prerelease = 0;
}
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
smart_set_count(dev, dev->releasecount, x, prerelease);
smart_set_count(dev, dev->freecount, x,
dev->availsectperblk - prerelease);
#else
dev->releasecount[x] = prerelease;
dev->freecount[x] = dev->availsectperblk - prerelease;
#endif
}
/* Account for the format sector */
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
smart_set_count(dev, dev->freecount, 0, dev->availsectperblk - 1);
#else
dev->freecount[0]--;
#endif
/* Now initialize the logical to physical sector map */
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
dev->smap[0] = 0; /* Logical sector zero = physical sector 0 */
for (x = 1; x < dev->totalsectors; x++)
{
/* Mark all other logical sectors as non-existent */
dev->smap[x] = -1;
}
#endif
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
/* Un-register any extra directory device entries */
for (x = 2; x < 8; x++)
{
snprintf(dev->rwbuffer, 18, "/dev/smart%dd%d", dev->minor, x);
unregister_blockdriver(dev->rwbuffer);
}
#endif
return OK;
}
/****************************************************************************
* Name: smart_relocate_sector
*
* Description: Relocates the specified sector to the new sector location.
*
****************************************************************************/
static int smart_relocate_sector(FAR struct smart_struct_s *dev,
uint16_t oldsector, uint16_t newsector)
{
size_t offset;
FAR struct smart_sect_header_s *header;
uint8_t newstatus;
int ret;
header = (FAR struct smart_sect_header_s *) dev->rwbuffer;
/* Increment the sequence number and clear the "commit" flag */
#if SMART_STATUS_VERSION == 1
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
if ((header->status & SMART_STATUS_CRC) !=
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_CRC))
{
#endif
/* Using 8-bit sequence */
header->seq++;
if (header->seq == 0xff)
{
header->seq = 1;
}
#if SMART_STATUS_VERSION == 1
}
else
{
/* Using 16-bit sequence and no CRC */
(*((FAR uint16_t *) &header->seq))++;
if (*((FAR uint16_t *) &header->seq) == 0xffff)
{
*((FAR uint16_t *) &header->seq) = 1;
}
}
#endif
/* When CRC is enabled, we must pre-commit the sector and also
* calculate an updated CRC for the sector prior to writing
* since we changed the sequence number.
*/
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
/* First pre-commit the sector */
#if CONFIG_SMARTFS_ERASEDSTATE == 0xff
header->status &= ~(SMART_STATUS_COMMITTED | SMART_STATUS_CRC);
#else
header->status |= SMART_STATUS_COMMITTED | SMART_STATUS_CRC;
#endif
/* Now calculate the new CRC */
#ifdef CONFIG_SMART_CRC_8
header->crc8 = smart_calc_sector_crc(dev);
#elif defined(CONFIG_SMART_CRC_16)
*((uint16_t *) header->crc16) = smart_calc_sector_crc(dev);
#elif defined(CONFIG_SMART_CRC_32)
*((uint32_t *) header->crc32) = smart_calc_sector_crc(dev);
#endif
/* Write the data to the new physical sector location */
ret = MTD_BWRITE(dev->mtd, newsector * dev->mtdblkspersector,
dev->mtdblkspersector, (FAR uint8_t *) dev->rwbuffer);
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
if (ret != dev->mtdblkspersector)
{
ferr("Error writing to new sector %d\n", newsector);
goto errout;
}
#else /* CONFIG_MTD_SMART_ENABLE_CRC */
#if CONFIG_SMARTFS_ERASEDSTATE == 0xff
header->status |= SMART_STATUS_COMMITTED;
#else
header->status &= ~SMART_STATUS_COMMITTED;
#endif
/* Write the data to the new physical sector location */
ret = MTD_BWRITE(dev->mtd, newsector * dev->mtdblkspersector,
dev->mtdblkspersector, (FAR uint8_t *) dev->rwbuffer);
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
if (ret != dev->mtdblkspersector)
{
ferr("Error writing to new sector %d\n", newsector);
goto errout;
}
/* Commit the sector */
offset = newsector * dev->mtdblkspersector * dev->geo.blocksize +
offsetof(struct smart_sect_header_s, status);
#if CONFIG_SMARTFS_ERASEDSTATE == 0xff
newstatus = header->status & ~SMART_STATUS_COMMITTED;
#else
newstatus = header->status | SMART_STATUS_COMMITTED;
#endif
ret = smart_bytewrite(dev, offset, 1, &newstatus);
if (ret < 0)
{
ferr("ERROR: Error %d committing new sector %d\n" -ret, newsector);
goto errout;
}
#endif /* CONFIG_MTD_SMART_ENABLE_CRC */
/* Release the old physical sector */
#if CONFIG_SMARTFS_ERASEDSTATE == 0xff
newstatus = header->status & ~(SMART_STATUS_RELEASED |
SMART_STATUS_COMMITTED);
#else
newstatus = header->status | SMART_STATUS_RELEASED |
SMART_STATUS_COMMITTED;
#endif
offset = oldsector * dev->mtdblkspersector * dev->geo.blocksize +
offsetof(struct smart_sect_header_s, status);
ret = smart_bytewrite(dev, offset, 1, &newstatus);
if (ret < 0)
{
ferr("ERROR: Error %d releasing old sector %d\n" -ret, oldsector);
}
errout:
return ret;
}
/****************************************************************************
* Name: smart_relocate_block
*
* Description: Relocates the specified MTD erase block by moving any
* active sectors to a different erase block and then erases
* the selected block.
*
****************************************************************************/
static int smart_relocate_block(FAR struct smart_struct_s *dev,
uint16_t block)
{
uint16_t newsector;
uint16_t oldrelease;
int x;
int ret;
FAR struct smart_sect_header_s *header;
uint8_t prerelease;
uint16_t freecount;
#if defined(CONFIG_SMART_LOCAL_CHECKFREE) && defined(CONFIG_DEBUG_FS)
uint16_t releasecount;
#endif
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
FAR struct smart_allocsector_s *allocsector;
#endif
/* 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.
*/
header = (FAR struct smart_sect_header_s *) dev->rwbuffer;
#ifdef CONFIG_SMART_LOCAL_CHECKFREE
if (smart_checkfree(dev, __LINE__) != OK)
{
fwarn(" ...while relocating block %d, free=%d\n",
block, dev->freesectors);
}
#endif
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
freecount = smart_get_count(dev, dev->freecount, block);
#if defined(CONFIG_FS_PROCFS) && !defined(CONFIG_FS_PROCFS_EXCLUDE_SMARTFS)
#if defined(CONFIG_SMART_LOCAL_CHECKFREE) && defined(CONFIG_DEBUG_FS)
releasecount = smart_get_count(dev, dev->releasecount, block);
#endif
#endif
/* Ensure we aren't relocating a block containing the only free sectors */
if (freecount >= dev->freesectors)
{
ferr("ERROR: Program bug! "
"Relocating the only block (%d) with free sectors!\n",
block);
ret = -EIO;
goto errout;
}
smart_set_count(dev, dev->freecount, block, 0);
#else /* CONFIG_MTD_SMART_PACK_COUNTS */
freecount = dev->freecount[block];
#if defined(CONFIG_FS_PROCFS) && !defined(CONFIG_FS_PROCFS_EXCLUDE_SMARTFS)
#if defined(CONFIG_SMART_LOCAL_CHECKFREE) && defined(CONFIG_DEBUG_FS)
releasecount = dev->releasecount[block];
#endif
#endif
dev->freecount[block] = 0;
#endif
/* Next move all live data in the block to a new home. */
for (x = block * dev->sectorsperblk; x <
block * dev->sectorsperblk + dev->availsectperblk; x++)
{
/* Read the next sector from this erase block */
ret = MTD_BREAD(dev->mtd, x * dev->mtdblkspersector,
dev->mtdblkspersector, (FAR uint8_t *) dev->rwbuffer);
if (ret != dev->mtdblkspersector)
{
ferr("ERROR: Error reading sector %d\n", x);
ret = -EIO;
goto errout;
}
/* Test if the block is in use */
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
/* Check if there is a temporary alloc for this physical sector */
allocsector = dev->allocsector;
while (allocsector)
{
if (allocsector->physical == x)
break;
allocsector = allocsector->next;
}
/* If we found a temp allocation, just update the mapped physical
* location and move on to the next block ... there is no data to
* move yet.
*/
if (allocsector)
{
newsector = smart_findfreephyssector(dev, FALSE);
if (newsector == 0xffff)
{
/* Unable to find a free sector!!! */
ferr("ERROR: Can't find a free sector for relocation\n");
ret = -ENOSPC;
goto errout;
}
/* Update the temporary allocation's physical sector */
allocsector->physical = newsector;
*((FAR uint16_t *) header->logicalsector) = allocsector->logical;
}
else
#endif
{
if (((header->status & SMART_STATUS_COMMITTED) ==
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_COMMITTED)) ||
((header->status & SMART_STATUS_RELEASED) !=
(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.
*/
continue;
}
/* Find a new sector where it can live, NOT in this erase block */
newsector = smart_findfreephyssector(dev, FALSE);
if (newsector == 0xffff)
{
/* Unable to find a free sector!!! */
ferr("ERROR: Can't find a free sector for relocation\n");
ret = -ENOSPC;
goto errout;
}
/* Relocate the sector data */
if ((ret = smart_relocate_sector(dev, x, newsector)) < 0)
{
goto errout;
}
}
/* Update the variables */
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
dev->smap[*((FAR uint16_t *) header->logicalsector)] = newsector;
#else
smart_update_cache(dev, *((FAR uint16_t *) header->logicalsector),
newsector);
#endif
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
smart_add_count(dev, dev->freecount, newsector / dev->sectorsperblk,
-1);
#else
dev->freecount[newsector / dev->sectorsperblk]--;
#endif
}
/* Now erase the erase block */
MTD_ERASE(dev->mtd, block, 1);
#if defined(CONFIG_FS_PROCFS) && !defined(CONFIG_FS_PROCFS_EXCLUDE_SMARTFS)
dev->unusedsectors += freecount;
dev->blockerases++;
#endif
#ifdef CONFIG_MTD_SMART_SECTOR_ERASE_DEBUG
if (dev->erasecounts)
{
dev->erasecounts[block]++;
}
#endif
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
/* Update the new wear level count */
smart_set_wear_level(dev, block, smart_get_wear_level(dev, block) + 1);
#endif
/* Update the free and release sectors for this erase block. */
if (x == dev->neraseblocks && dev->totalsectors == 65534)
{
/* We can't use the last two sectors on a 65536 sector device,
* so "pre-release" them so they never get allocated.
*/
prerelease = 2;
}
else
{
prerelease = 0;
}
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
oldrelease = smart_get_count(dev, dev->releasecount, block);
dev->freesectors += oldrelease - prerelease;
dev->releasesectors -= oldrelease - prerelease;
smart_set_count(dev, dev->freecount, block,
dev->availsectperblk - prerelease);
smart_set_count(dev, dev->releasecount, block, prerelease);
#else
oldrelease = dev->releasecount[block];
dev->freesectors += oldrelease - prerelease;
dev->releasesectors -= oldrelease - prerelease;
dev->freecount[block] = dev->availsectperblk - prerelease;
dev->releasecount[block] = prerelease;
#endif
#ifdef CONFIG_SMART_LOCAL_CHECKFREE
if (smart_checkfree(dev, __LINE__) != OK)
{
fwarn(" ...while relocating block %d, "
"free=%d, release=%d, oldrelease=%d\n",
block, freecount, releasecount, oldrelease);
}
#endif
/* Test if this erase causes the block to reach the full relocate
* threshold requiring static data relocation.
*/
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
smart_relocate_static_data(dev, block);
#endif
return OK;
errout:
/* Restore the block's freecount if error */
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
smart_set_count(dev, dev->freecount, block, freecount);
#else
dev->freecount[block] = freecount;
#endif
return ret;
}
/****************************************************************************
* Name: smart_findfreephyssector
*
* Description: Finds a free physical sector based on free and released
* count logic, taking into account reserved sectors.
*
****************************************************************************/
static int smart_findfreephyssector(FAR struct smart_struct_s *dev,
uint8_t canrelocate)
{
uint16_t count;
uint16_t allocfreecount;
uint16_t allocblock;
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
uint16_t wornfreecount;
uint16_t wornblock;
uint8_t wearlevel;
uint8_t wornlevel;
uint8_t maxwearlevel;
#endif
uint16_t physicalsector;
uint16_t block;
uint32_t readaddr;
struct smart_sect_header_s header;
int ret;
uint16_t i;
/* Determine which erase block we should allocate the new
* sector from. This is based on the number of free sectors
* available in each erase block.
*/
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
retry:
#endif
allocfreecount = 0;
allocblock = 0xffff;
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
wornfreecount = 0;
wornblock = 0xffff;
wornlevel = 15;
maxwearlevel = 0;
#endif
physicalsector = 0xffff;
if (++dev->lastallocblock >= dev->neraseblocks)
{
dev->lastallocblock = 0;
}
block = dev->lastallocblock;
for (i = 0; i < dev->neraseblocks; i++)
{
/* Test if this block has more free blocks than the
* currently selected block
*/
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
count = smart_get_count(dev, dev->freecount, block);
#else
count = dev->freecount[block];
#endif
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
/* Keep track of the block with the max free sectors that is worn */
wearlevel = smart_get_wear_level(dev, block);
if (wearlevel >= SMART_WEAR_FULL_RELOCATE_THRESHOLD)
{
if (wearlevel > maxwearlevel && count > 0)
{
maxwearlevel = wearlevel;
}
if (count > wornfreecount || (count > 0 && wearlevel < wornlevel))
{
/* Keep track of this block. If there are only worn blocks
* with free sectors left, then we will use it.
*/
if (i < dev->neraseblocks - 1 || !wornfreecount)
{
wornfreecount = count;
wornblock = block;
wornlevel = wearlevel;
}
}
}
else
#endif
if (count > allocfreecount)
{
/* Assign this block to alloc from */
if (i < dev->neraseblocks - 1 || !allocfreecount)
{
allocblock = block;
allocfreecount = count;
}
}
if (++block >= dev->neraseblocks)
{
block = 0;
}
}
/* Check if we found an allocblock. */
if (allocblock == 0xffff)
{
/* No un-worn blocks with free sectors */
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
/* If we are allowed to relocate unworn blocks then do so now */
if (canrelocate && wornfreecount < (dev->sectorsperblk >> 2) &&
wornlevel == maxwearlevel)
{
/* Relocate up to 8 unworn blocks */
block = 0;
for (i = 0; i < 8; )
{
if (smart_get_wear_level(dev, block) <
SMART_WEAR_FORCE_REORG_THRESHOLD)
{
if (smart_relocate_block(dev, block) < 0)
{
ferr("ERROR: Error relocating block while finding "
"free phys sector\n");
return -1;
}
i++;
}
block++;
}
if (i > 0)
{
/* Disable relocate for retry */
canrelocate = FALSE;
goto retry;
}
}
else
{
dev->wearflags |= SMART_WEARFLAGS_FORCE_REORG;
}
/* Test if we found a worn block with free sectors */
if (wornblock != 0xffff)
{
allocblock = wornblock;
}
else
#endif
{
char buffer[8 * 12 + 1];
long remaining;
int j;
int k;
ferr("ERROR: Program bug! Expected a free sector, free=%d\n",
dev->freesectors);
for (i = 0, remaining = dev->neraseblocks;
remaining > 0;
i += 8, remaining -= 8)
{
for (j = 0, k = 0; j < 8 && j < remaining ; j++)
{
k += sprintf(&buffer[k], "%12d", dev->freecount[i + j]);
}
ferr("%04x:%s\n", i, buffer);
}
/* No free sectors found! Bug? */
return -ENOSPC;
}
}
/* Now find a free physical sector within this selected erase block to
* allocate.
*/
for (i = allocblock * dev->sectorsperblk;
i < allocblock * dev->sectorsperblk + dev->availsectperblk; i++)
{
/* Check if this physical sector is available. */
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
/* First check if there is a temporary alloc in place */
FAR struct smart_allocsector_s *allocsect;
allocsect = dev->allocsector;
while (allocsect)
{
if (allocsect->physical == i)
{
break;
}
allocsect = allocsect->next;
}
/* If we found this physical sector above, then continue on
* to the next physical sector in this block ... this one has
* a temporary allocation assigned.
*/
if (allocsect)
{
continue;
}
#endif
/* Now check on the physical media */
readaddr = i * dev->mtdblkspersector * dev->geo.blocksize;
ret = MTD_READ(dev->mtd, readaddr, sizeof(struct smart_sect_header_s),
(FAR uint8_t *) &header);
if (ret != sizeof(struct smart_sect_header_s))
{
ferr("ERROR: Error reading phys sector %d\n", physicalsector);
return -1;
}
if ((*((FAR uint16_t *) header.logicalsector) == 0xffff) &&
#if SMART_STATUS_VERSION == 1
(*((FAR uint16_t *) &header.seq) == 0xffff) &&
#else
(header.seq == CONFIG_SMARTFS_ERASEDSTATE) &&
#endif
((header.status & SMART_STATUS_COMMITTED) ==
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_COMMITTED)))
{
physicalsector = i;
dev->lastallocblock = allocblock;
break;
}
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
else
{
/* The FLASH may be not erased in the initial delivery state.
* Just in case for the recovery of this fatal situation,
* after once erasing the sector, return the sector as a free
* sector.
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
*/
if (1 == dev->availsectperblk)
{
MTD_ERASE(dev->mtd, allocblock, 1);
physicalsector = i;
dev->lastallocblock = allocblock;
break;
}
}
}
if (physicalsector == 0xffff)
{
ferr("ERROR: Program bug! Expected a free sector\n");
}
if (physicalsector >= dev->totalsectors)
{
ferr("ERROR: Program bug! Selected sector too big!!!\n");
}
return physicalsector;
}
/****************************************************************************
* Name: smart_garbagecollect
*
* Description: Performs garbage collection if needed. This is determined
* by the count of released sectors relative to free and
* total sectors.
*
****************************************************************************/
static int smart_garbagecollect(FAR struct smart_struct_s *dev)
{
uint16_t collectblock;
uint16_t releasemax;
bool collect = TRUE;
int x;
int ret;
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
uint8_t count;
#endif
while (collect)
{
collect = FALSE;
/* Test if the released sectors count is greater than the
* free sectors. If it is, then we will do garbage collection.
*/
if (dev->releasesectors > dev->freesectors && dev->freesectors <
(dev->totalsectors >> 5))
{
collect = TRUE;
}
/* Test if we have more reached our reserved free sector limit */
if (dev->freesectors <= (dev->sectorsperblk << 0) + 4)
{
collect = TRUE;
}
/* Test if we need to garbage collect */
if (collect)
{
/* Find the block with the most released sectors */
collectblock = 0xffff;
releasemax = 0;
for (x = 0; x < dev->neraseblocks; x++)
{
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
/* Don't collect blocks that have been worn completely */
if (smart_get_wear_level(dev, x) >= SMART_WEAR_REORG_THRESHOLD)
{
continue;
}
#endif
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
count = smart_get_count(dev, dev->releasecount, x);
if (count > releasemax)
{
releasemax = count;
collectblock = x;
}
#else
if (dev->releasecount[x] > releasemax)
{
releasemax = dev->releasecount[x];
collectblock = x;
}
#endif
}
#if 0
releasemax = smart_get_count(dev, dev->releasecount, collectblock);
#endif
if (collectblock == 0xffff)
{
/* Need to collect, but no sectors with released blocks! */
ret = -ENOSPC;
goto errout;
}
#ifdef CONFIG_SMART_LOCAL_CHECKFREE
if (smart_checkfree(dev, __LINE__) != OK)
{
fwarn(" ...before collecting block %d\n", collectblock);
}
#endif
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
finfo("Collecting block %d, free=%d released=%d, "
"totalfree=%d, totalrelease=%d\n",
collectblock,
smart_get_count(dev, dev->freecount, collectblock),
smart_get_count(dev, dev->releasecount, collectblock),
dev->freesectors, dev->releasesectors);
#else
finfo("Collecting block %d, free=%d released=%d\n",
collectblock, dev->freecount[collectblock],
dev->releasecount[collectblock]);
#endif
/* Relocate the active data in the collection block */
ret = smart_relocate_block(dev, collectblock);
#ifdef CONFIG_SMART_LOCAL_CHECKFREE
if (smart_checkfree(dev, __LINE__) != OK)
{
fwarn(" ...while collecting block %d\n", collectblock);
}
#endif
if (ret != OK)
{
goto errout;
}
}
}
return OK;
errout:
return ret;
}
/****************************************************************************
* Name: smart_write_wearstatus
*
* Description: Writes the wear leveling status bits to sector zero (and
* possibly others if it doesn't fit) such that is is persisted
* across OS reboots.
*
****************************************************************************/
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
static int smart_write_wearstatus(struct smart_struct_s *dev)
{
uint16_t sector;
uint16_t remaining;
uint16_t towrite;
struct smart_read_write_s req;
int ret;
uint8_t buffer[8];
uint8_t write_buffer = 0;
sector = 0;
remaining = dev->geo.neraseblocks >> 1;
memset(buffer, 0xff, sizeof(buffer));
#if defined(CONFIG_FS_PROCFS) && !defined(CONFIG_FS_PROCFS_EXCLUDE_SMARTFS)
if (dev->blockerases > 0)
{
*((uint32_t *) buffer) = dev->blockerases;
write_buffer = 1;
}
#endif
/* Write the uneven wear count just prior to the wear bits */
if (dev->uneven_wearcount != 0)
{
*((uint32_t *) &buffer[4]) = dev->uneven_wearcount;
write_buffer = 1;
}
/* Test if we need to write either total block erase count or
* uneven wearcount (or both)
*/
if (write_buffer)
{
req.logsector = sector;
req.offset = SMARTFS_FMT_WEAR_POS - 8;
req.count = sizeof(buffer);
req.buffer = buffer;
ret = smart_writesector(dev, (unsigned long) &req);
if (ret != OK)
{
goto errout;
}
}
/* Write all wear level bits to logical sector zero, one, two */
while (remaining)
{
/* Calculate the number of bytes to write to this sector */
towrite = remaining;
if (towrite >
dev->sectorsize - (SMARTFS_FMT_WEAR_POS +
sizeof(struct smart_sect_header_s)))
{
towrite = dev->sectorsize -
(SMARTFS_FMT_WEAR_POS +
sizeof(struct smart_sect_header_s));
}
/* Setup the sector write request (we are our own client) */
req.logsector = sector;
req.offset = SMARTFS_FMT_WEAR_POS;
req.count = towrite;
req.buffer =
&dev->wearstatus[(dev->geo.neraseblocks >> SMART_WEAR_BIT_DIVIDE) -
remaining];
/* Write the sector */
ret = smart_writesector(dev, (unsigned long) &req);
if (ret != OK)
{
goto errout;
}
/* Decrement the remaining count */
remaining -= towrite;
if (remaining)
{
/* Data doesn't fit in a single sector. Use the reserved sectors */
sector++;
if (sector >= SMART_FIRST_DIR_SECTOR)
{
/* Error, wear status bit too large! */
ferr("ERROR: Invalid geometry "
"- wear level status too large\n");
ret = -EINVAL;
goto errout;
}
}
}
/* Now clear the NEEDS_WRITE wear status bit */
dev->wearflags &= ~SMART_WEARFLAGS_WRITE_NEEDED;
ret = OK;
errout:
return ret;
}
#endif
/****************************************************************************
* Name: smart_read_wearstatus
*
* Description: Reads the wear leveling status bits from sector zero (and
* possibly others if it doesn't fit) such that is is persisted
* across OS reboots.
*
****************************************************************************/
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
static inline int smart_read_wearstatus(FAR struct smart_struct_s *dev)
{
struct smart_read_write_s req;
uint16_t sector;
uint16_t physsector;
uint16_t remaining;
uint16_t toread;
uint8_t buffer[8];
int ret;
/* Prepare to read the total block erases and uneven wearcount values */
sector = 0;
req.logsector = sector;
req.offset = SMARTFS_FMT_WEAR_POS - 8;
req.count = sizeof(buffer);
req.buffer = buffer;
ret = smart_readsector(dev, (unsigned long) &req);
if (ret != sizeof(buffer))
{
goto errout;
}
/* Get the uneven wearcount value */
dev->uneven_wearcount = *((uint32_t *) &buffer[4]);
/* Check for erased state */
#if ( CONFIG_SMARTFS_ERASEDSTATE == 0xff )
if (dev->uneven_wearcount == 0xffffffff)
{
dev->uneven_wearcount = 0;
}
#endif
#if defined(CONFIG_FS_PROCFS) && !defined(CONFIG_FS_PROCFS_EXCLUDE_SMARTFS)
/* Get the block erases count */
dev->blockerases = *((uint32_t *) buffer);
#if ( CONFIG_SMARTFS_ERASEDSTATE == 0xff )
if (dev->blockerases == 0xffffffff)
{
dev->blockerases = 0;
}
#endif
#endif
/* Read all wear level bits from the flash */
remaining = dev->geo.neraseblocks >> 1;
while (remaining)
{
/* Calculate number of bytes to read from this sector */
toread = remaining;
if (toread > dev->sectorsize -
(SMARTFS_FMT_WEAR_POS + sizeof(struct smart_sect_header_s)))
{
toread = dev->sectorsize -
(SMARTFS_FMT_WEAR_POS +
sizeof(struct smart_sect_header_s));
}
/* Setup the sector read request (we are our own client) */
req.logsector = sector;
req.offset = SMARTFS_FMT_WEAR_POS;
req.count = toread;
req.buffer =
&dev->wearstatus[(dev->geo.neraseblocks >> SMART_WEAR_BIT_DIVIDE) -
remaining];
/* Validate wear status sector has been allocated */
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
physsector = dev->smap[req.logsector];
#else
physsector = smart_cache_lookup(dev, req.logsector);
#endif
if ((sector != 0) && (physsector == 0xffff))
{
/* This logical sector does not exist yet. We must allocate it */
ret = smart_allocsector(dev, sector);
if (ret != sector)
{
ferr("ERROR: Unable to allocate wear level status sector %d\n",
sector);
ret = -EINVAL;
goto errout;
}
}
/* Read the sector */
ret = smart_readsector(dev, (unsigned long) &req);
if (ret != toread)
{
goto errout;
}
/* Decrement the remaining count */
remaining -= toread;
if (remaining)
{
/* Data doesn't fit in a single sector. Use the reserved sectors */
sector++;
if (sector >= SMART_FIRST_DIR_SECTOR)
{
/* Error, wear status bit too large! */
ferr("ERROR: Invalid geometry "
"- wear level status too large\n");
ret = -EINVAL;
goto errout;
}
}
}
/* Now interrogate the status bits */
smart_find_wear_minmax(dev);
#ifdef CONFIG_MTD_SMART_SECTOR_ERASE_DEBUG
/* Set the erase counts equal to the wear levels */
for (sector = 0; sector < dev->geo.neraseblocks; sector++)
{
dev->erasecounts[sector] = smart_get_wear_level(dev, sector);
}
#endif
ret = OK;
errout:
return ret;
}
#endif
/****************************************************************************
* Name: smart_write_alloc_sector
*
* Description: Writes a newly allocated sector's header to the RW buffer
* and updates sector mapping variables. If CRC isn't enabled
* it also writes the header to the device.
*
****************************************************************************/
static int smart_write_alloc_sector(FAR struct smart_struct_s *dev,
uint16_t logical, uint16_t physical)
{
int ret = 1;
uint8_t sectsize;
FAR struct smart_sect_header_s *header;
memset(dev->rwbuffer, CONFIG_SMARTFS_ERASEDSTATE, dev->sectorsize);
header = (FAR struct smart_sect_header_s *) dev->rwbuffer;
*((FAR uint16_t *) header->logicalsector) = logical;
#if SMART_STATUS_VERSION == 1
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
header->seq = 0;
#else
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
*((FAR uint16_t *) &header->seq) = 0;
#endif /* CONFIG_MTD_SMART_ENABLE_CRC */
#else
header->seq = 0;
#endif
/* Calculate the 3-bit logical sector size in bits 2-4:
* 000b - 256 bytes
* 001b - 512 bytes
* 010b - 1024 bytes
* 100b - 2048 bytes
* 011b - 4096 bytes
* 101b - 8192 bytes
* 110b - 16384 bytes
* 110b - 32768 bytes
*/
sectsize = dev->sectorsize < 4096 ? (dev->sectorsize >> 9) :
dev->sectorsize == 4096 ? 3 : 5 + (dev->sectorsize >> 14);
sectsize <<= 2;
#if CONFIG_SMARTFS_ERASEDSTATE == 0xff
header->status = ~(SMART_STATUS_COMMITTED | SMART_STATUS_SIZEBITS |
SMART_STATUS_VERBITS) | SMART_STATUS_VERSION | sectsize;
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
header->status &= ~SMART_STATUS_CRC;
#endif /* CONFIG_MTD_SMART_ENABLE_CRC */
#else
header->status = SMART_STATUS_COMMITTED | SMART_STATUS_VERSION | sectsize;
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
header->status |= SMART_STATUS_CRC;
#endif /* CONFIG_MTD_SMART_ENABLE_CRC */
#endif
/* Write the header to the physical sector location */
#ifndef CONFIG_MTD_SMART_ENABLE_CRC
finfo("Write MTD block %d\n", physical * dev->mtdblkspersector);
ret = MTD_BWRITE(dev->mtd, physical * dev->mtdblkspersector, 1,
(FAR uint8_t *) dev->rwbuffer);
if (ret != 1)
{
/* The block is not empty!! What to do? */
ferr("ERROR: Write block %d failed: %d.\n", physical *
dev->mtdblkspersector, ret);
/* Unlock the mutex if we add one */
return -EIO;
}
#endif /* CONFIG_MTD_SMART_ENABLE_CRC */
return ret;
}
/****************************************************************************
* Name: smart_validate_crc
*
* Description: Validates the CRC data in the sector's header against the
* data in the sector. Assumes the entire sector has been
* read into the RW buffer already.
*
****************************************************************************/
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
static int smart_validate_crc(FAR struct smart_struct_s *dev)
{
crc_t crc;
FAR struct smart_sect_header_s *header;
/* Calculate CRC on data region of the sector */
crc = smart_calc_sector_crc(dev);
header = (FAR struct smart_sect_header_s *) dev->rwbuffer;
#ifdef CONFIG_SMART_CRC_8
/* Test 8-bit CRC */
if (crc != header->crc8)
{
return -EIO;
}
#elif defined(CONFIG_SMART_CRC_16)
/* Test 16-bit CRC */
if (crc != *((uint16_t *) header->crc16))
{
return -EIO;
}
#elif defined(CONFIG_SMART_CRC_32)
if (crc != *((uint32_t *) header->crc32))
{
return -EIO;
}
#endif
/* CRC checkout out okay */
return OK;
}
#endif
/****************************************************************************
* Name: smart_writesector
*
* Description: Writes data to the specified logical sector. The sector
* should have already been allocated prior to the write. If
* the logical sector already has data on the device, it will
* be released and a new physical sector will be created and
* mapped to the logical sector.
*
****************************************************************************/
static int smart_writesector(FAR struct smart_struct_s *dev,
unsigned long arg)
{
int ret;
bool needsrelocate = FALSE;
uint32_t mtdblock;
uint16_t physsector;
uint16_t oldphyssector;
uint16_t block;
FAR struct smart_read_write_s *req;
FAR struct smart_sect_header_s *header;
size_t offset;
uint8_t byte;
#if defined(CONFIG_MTD_SMART_WEAR_LEVEL) || !defined(CONFIG_MTD_SMART_ENABLE_CRC)
uint16_t x;
#endif
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
FAR struct smart_allocsector_s *allocsector;
#endif
finfo("Entry\n");
req = (FAR struct smart_read_write_s *) arg;
DEBUGASSERT(req->offset <= dev->sectorsize);
DEBUGASSERT(req->offset + req->count <= dev->sectorsize);
/* Ensure the logical sector has been allocated */
if (req->logsector >= dev->totalsectors)
{
ferr("ERROR: Logical sector %d too large\n", req->logsector);
ret = -EINVAL;
goto errout;
}
header = (FAR struct smart_sect_header_s *)dev->rwbuffer;
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
/* Test if an adjustment to the wear levels is needed */
if (dev->minwearlevel >= SMART_WEAR_MIN_LEVEL ||
(dev->minwearlevel > 0 &&
dev->maxwearlevel >= SMART_WEAR_REORG_THRESHOLD))
{
/* Subtract dev->minwearlevel from all wear levels */
offset = dev->minwearlevel;
2021-08-09 22:48:00 +02:00
finfo("Reducing wear level bits by %zu\n", offset);
for (x = 0; x < dev->geo.neraseblocks; x++)
{
smart_set_wear_level(dev, x,
smart_get_wear_level(dev, x) - offset);
}
dev->minwearlevel -= offset;
dev->maxwearlevel -= offset;
/* Now write the new wear bits to the flash */
dev->wearflags &= ~SMART_WEARFLAGS_FORCE_REORG;
dev->wearflags |= SMART_WEARFLAGS_WRITE_NEEDED;
}
#endif
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
physsector = dev->smap[req->logsector];
#else
physsector = smart_cache_lookup(dev, req->logsector);
#endif
if (physsector == 0xffff)
{
ferr("ERROR: Logical sector %d not allocated\n", req->logsector);
ret = -EINVAL;
goto errout;
}
/* Read the sector data into our buffer */
mtdblock = physsector * dev->mtdblkspersector;
ret = MTD_BREAD(dev->mtd, mtdblock, dev->mtdblkspersector, (FAR uint8_t *)
dev->rwbuffer);
if (ret != dev->mtdblkspersector)
{
ferr("ERROR: Error reading phys sector %d\n", physsector);
ret = -EIO;
goto errout;
}
/* Test if we need to relocate the sector to perform the write */
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
allocsector = dev->allocsector;
while (allocsector)
{
/* Test if the requested logical sector is a temp alloc */
if (allocsector->logical == req->logsector)
{
break;
}
allocsector = allocsector->next;
}
/* When CRC is enabled, then we always have to relocate the sector if
* it is not a temporary alloc (i.e. initial alloc before the very first
* write operation).
*/
if (!allocsector)
{
needsrelocate = TRUE;
}
#else
/* When CRC is not enabled, we may be able to simply add the new data to
* the sector if it doesn't conflict with existing data on the device.
* Test if there is a conflict in the data.
*/
for (x = 0; x < req->count; x++)
{
/* Test if the next byte can be written to the flash */
byte = dev->rwbuffer[sizeof(struct smart_sect_header_s) +
req->offset + x];
#if CONFIG_SMARTFS_ERASEDSTATE == 0xff
if (((byte ^ req->buffer[x]) | byte) != byte)
{
needsrelocate = TRUE;
break;
}
#else
if (((byte ^ req->buffer[x]) | req->buffer[x]) != req->buffer[x])
{
needsrelocate = TRUE;
break;
}
#endif
}
#endif /* CONFIG_MTD_SMART_ENABLE_CRC */
/* If we are not using CRC and on a device that supports re-writing
2018-12-27 15:45:26 +01:00
* bits from 1 to 0 without needing a block erase, such as NOR
* FLASH, then we can simply update the data in place and don't need
* to relocate the sector. Test if we need to relocate or not.
*/
if (needsrelocate)
{
/* Find a new physical sector to save data to */
oldphyssector = physsector;
physsector = smart_findfreephyssector(dev, FALSE);
if (physsector == 0xffff)
{
ferr("ERROR: Error relocating sector %d\n", req->logsector);
ret = -EIO;
goto errout;
}
/* Update the sequence number to indicate the sector was moved */
#if SMART_STATUS_VERSION == 1
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
if ((header->status & SMART_STATUS_CRC) !=
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_CRC))
{
#endif
header->seq++;
if (header->seq == 0xff)
{
header->seq = 0;
}
#if SMART_STATUS_VERSION == 1
}
else
{
(*((FAR uint16_t *) &header->seq))++;
if (*((FAR uint16_t *) &header->seq) == 0xffff)
*((FAR uint16_t *) &header->seq) = 1;
}
#else
header->seq++;
#endif
#if CONFIG_SMARTFS_ERASEDSTATE == 0xff
header->status |= SMART_STATUS_COMMITTED;
#else
header->status &= SMART_STATUS_COMMITTED;
#endif
}
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
/* When CRC is enabled and we have a temp alloc, then fill in the RW buffer
* with the header information prior to copying the write data to the buf.
*/
if (allocsector)
{
smart_write_alloc_sector(dev, allocsector->logical,
allocsector->physical);
/* Remove allocsector from the list and free the memory */
if (dev->allocsector == allocsector)
{
/* We are the head item. Remove ourselves as head */
dev->allocsector = allocsector->next;
}
else
{
FAR struct smart_allocsector_s *prev;
/* Start at head and find our entry */
prev = dev->allocsector;
while (prev && prev->next != allocsector)
{
/* Scan the list until we find this entry */
prev = prev->next;
}
if (prev)
{
/* Remove from the list */
prev->next = allocsector->next;
}
}
/* Now free the memory */
kmm_free(allocsector);
}
/* Now copy the data to the sector buffer. */
memcpy(&dev->rwbuffer[sizeof(struct smart_sect_header_s) + req->offset],
req->buffer, req->count);
/* Commit the sector ahead of time. The CRC will protect us */
#if CONFIG_SMARTFS_ERASEDSTATE == 0xff
header->status &= ~(SMART_STATUS_COMMITTED | SMART_STATUS_CRC);
#else
header->status |= SMART_STATUS_COMMITTED | SMART_STATUS_CRC;
#endif
/* Now calculate the CRC value for the sector */
#ifdef CONFIG_SMART_CRC_8
header->crc8 = smart_calc_sector_crc(dev);
#elif defined(CONFIG_SMART_CRC_16)
*((uint16_t *) header->crc16) = smart_calc_sector_crc(dev);
#elif defined(CONFIG_SMART_CRC_32)
*((uint32_t *) header->crc32) = smart_calc_sector_crc(dev);
#endif
#else /* CONFIG_MTD_SMART_ENABLE_CRC */
/* Now copy the data to the sector buffer. */
memcpy(&dev->rwbuffer[sizeof(struct smart_sect_header_s) + req->offset],
req->buffer, req->count);
#endif /* CONFIG_MTD_SMART_ENABLE_CRC */
/* Now write the sector buffer to the device. */
if (needsrelocate)
{
/* Write the entire sector to the new physical location, uncommitted. */
ret = MTD_BWRITE(dev->mtd, physsector * dev->mtdblkspersector,
dev->mtdblkspersector, (FAR uint8_t *) dev->rwbuffer);
if (ret != dev->mtdblkspersector)
{
ferr("ERROR: Error writing to physical sector %d\n", physsector);
ret = -EIO;
goto errout;
}
/* Commit the new physical sector */
#ifndef CONFIG_MTD_SMART_ENABLE_CRC
#if CONFIG_SMARTFS_ERASEDSTATE == 0xff
byte = header->status & ~SMART_STATUS_COMMITTED;
#else
byte = header->status | SMART_STATUS_COMMITTED;
#endif
offset = physsector * dev->mtdblkspersector * dev->geo.blocksize +
offsetof(struct smart_sect_header_s, status);
ret = smart_bytewrite(dev, offset, 1, &byte);
if (ret != 1)
{
finfo("Error committing physical sector %d\n", physsector);
ret = -EIO;
goto errout;
}
#endif
/* Release the old physical sector */
#if CONFIG_SMARTFS_ERASEDSTATE == 0xff
byte = header->status & ~(SMART_STATUS_RELEASED |
SMART_STATUS_COMMITTED);
#else
byte = header->status | SMART_STATUS_RELEASED |
SMART_STATUS_COMMITTED;
#endif
offset = mtdblock * dev->geo.blocksize +
offsetof(struct smart_sect_header_s, status);
ret = smart_bytewrite(dev, offset, 1, &byte);
2018-12-27 15:45:26 +01:00
/* Update releasecount for the released sector and freecount for the
* newly allocated physical sector.
*/
block = oldphyssector / dev->sectorsperblk;
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
smart_add_count(dev, dev->releasecount, block, 1);
smart_add_count(dev, dev->freecount, physsector / dev->sectorsperblk,
-1);
#else
dev->releasecount[block]++;
dev->freecount[physsector / dev->sectorsperblk]--;
#endif
dev->freesectors--;
dev->releasesectors++;
#ifdef CONFIG_SMART_LOCAL_CHECKFREE
/* Perform debug free count checking enabled */
smart_checkfree(dev, __LINE__);
#endif
/* Update the sector map */
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
dev->smap[req->logsector] = physsector;
#else
smart_update_cache(dev, req->logsector, physsector);
#endif
/* Test if releasing the sector created an empty erase block */
smart_erase_block_if_empty(dev, block, FALSE);
/* Since we performed a relocation, do garbage collection to
* ensure we don't fill up our flash with released blocks.
*/
smart_garbagecollect(dev);
}
else /* needsrelocate */
{
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
/* Write the entire sector to FLASH when CRC enabled */
ret = MTD_BWRITE(dev->mtd, physsector * dev->mtdblkspersector,
dev->mtdblkspersector, (FAR uint8_t *) dev->rwbuffer);
if (ret != dev->mtdblkspersector)
{
ferr("ERROR: Error writing to physical sector %d\n", physsector);
ret = -EIO;
goto errout;
}
/* Read the sector back and validate the CRC. */
ret = MTD_BREAD(dev->mtd, physsector * dev->mtdblkspersector,
dev->mtdblkspersector, (FAR uint8_t *) dev->rwbuffer);
if (ret == dev->mtdblkspersector)
{
/* Validate the CRC of the read-back data */
ret = smart_validate_crc(dev);
}
if (ret != OK)
{
/* TODO: Mark this as a bad block! */
ferr("ERROR: Error validating physical sector %d\n", physsector);
ret = -EIO;
goto errout;
}
#else
/* Not relocated. Just write the portion of the sector that needs
* to be written.
*/
offset = mtdblock * dev->geo.blocksize +
sizeof(struct smart_sect_header_s) + req->offset;
ret = smart_bytewrite(dev, offset, req->count, req->buffer);
#endif
}
ret = OK;
errout:
return ret;
}
/****************************************************************************
* Name: smart_readsector
*
* Description: Reads data from the specified logical sector. The sector
* should have already been allocated prior to the read.
*
****************************************************************************/
static int smart_readsector(FAR struct smart_struct_s *dev,
unsigned long arg)
{
int ret;
uint16_t physsector;
FAR struct smart_read_write_s *req;
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
#if SMART_STATUS_VERSION == 1
FAR struct smart_sect_header_s *header;
#endif
#else
uint32_t readaddr;
struct smart_sect_header_s header;
#endif
finfo("Entry\n");
req = (FAR struct smart_read_write_s *) arg;
DEBUGASSERT(req->offset < dev->sectorsize);
DEBUGASSERT(req->offset + req->count + sizeof(struct smart_sect_header_s)
<= dev->sectorsize);
/* Ensure the logical sector has been allocated */
if (req->logsector >= dev->totalsectors)
{
ferr("ERROR: Logical sector %d too large\n", req->logsector);
return -EINVAL;
}
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
physsector = dev->smap[req->logsector];
#else
physsector = smart_cache_lookup(dev, req->logsector);
#endif
if (physsector == 0xffff)
{
ferr("ERROR: Logical sector %d not allocated\n", req->logsector);
return -EINVAL;
}
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
/* When CRC is enabled, we read the entire sector into RAM so we can
* validate the CRC.
*/
ret = MTD_BREAD(dev->mtd, physsector * dev->mtdblkspersector,
dev->mtdblkspersector, (FAR uint8_t *) dev->rwbuffer);
if (ret != dev->mtdblkspersector)
{
/* TODO: Mark the block bad */
ferr("ERROR: Error reading phys sector %d\n", physsector);
return -EIO;
}
#if SMART_STATUS_VERSION == 1
/* Test if this sector has CRC enabled or not */
header = (FAR struct smart_sect_header_s *) dev->rwbuffer;
if ((header->status & SMART_STATUS_CRC) ==
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_CRC))
{
/* Format VERSION 1 supports either no CRC or 8-bit CRC. Looks like
* CRC not enabled for this sector, so skip the CRC test.
*/
}
else
#endif
{
/* Validate the read CRC against the calculated sector CRC */
ret = smart_validate_crc(dev);
if (ret != OK)
{
/* TODO: Mark the block bad */
ferr("ERROR: Error validating sector %d CRC during read\n",
physsector);
return -EIO;
}
}
/* Copy data to the output buffer */
memmove((FAR char *) req->buffer, &dev->rwbuffer[req->offset +
sizeof(struct smart_sect_header_s)], req->count);
ret = req->count;
#else /* CONFIG_MTD_SMART_ENABLE_CRC */
/* Read the sector header data to validate as a sanity check */
ret = MTD_READ(dev->mtd, physsector * dev->mtdblkspersector *
dev->geo.blocksize, sizeof(struct smart_sect_header_s),
(FAR uint8_t *)&header);
if (ret != sizeof(struct smart_sect_header_s))
{
ferr("ERROR: Error reading sector %d header\n", physsector);
return -EIO;
}
/* Do a sanity check on the header data */
if (((*(FAR uint16_t *) header.logicalsector) != req->logsector) ||
((header.status & SMART_STATUS_COMMITTED) ==
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_COMMITTED)))
{
/* Error in sector header! How do we handle this? */
ferr("ERROR: Error in logical sector %d header, phys=%d\n",
req->logsector, physsector);
return -EIO;
}
/* Read the sector data into the buffer */
readaddr = (uint32_t)physsector * dev->mtdblkspersector *
dev->geo.blocksize + req->offset +
sizeof(struct smart_sect_header_s);
ret = MTD_READ(dev->mtd, readaddr, req->count, (FAR uint8_t *)
req->buffer);
if (ret != req->count)
{
ferr("ERROR: Error reading phys sector %d\n", physsector);
return -EIO;
}
#endif
return ret;
}
/****************************************************************************
* Name: smart_allocsector
*
* Description: Allocates a new logical sector. If an argument is given,
* then it tries to allocate the specified sector number.
*
****************************************************************************/
static inline int smart_allocsector(FAR struct smart_struct_s *dev,
unsigned long requested)
{
uint16_t logsector = 0xffff; /* Logical sector number selected */
uint16_t physicalsector; /* The selected physical sector */
#ifndef CONFIG_MTD_SMART_ENABLE_CRC
int ret;
#endif
int x;
/* Validate that we have enough sectors available to perform an
* allocation. We have to ensure we keep enough reserved sectors
* on hand to do released sector garbage collection.
*/
if (dev->freesectors <= (dev->sectorsperblk << 0) + 4)
{
/* Do a garbage collect and then test freesectors again */
if (dev->releasesectors + dev->freesectors > dev->sectorsperblk + 4)
{
for (x = 0; x < dev->availsectperblk; x++)
{
smart_garbagecollect(dev);
if (dev->freesectors > dev->availsectperblk + 4)
{
break;
}
}
if (dev->freesectors <= (dev->availsectperblk << 0) + 4)
{
/* No space left!! */
return -ENOSPC;
}
}
else
{
/* No space left!! */
return -ENOSPC;
}
}
/* Check if a specific sector is being requested and allocate that
* sector if it isn't already in use.
*/
if ((requested > 0) && (requested < dev->totalsectors))
{
/* Validate the sector is not already allocated */
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
if (dev->smap[requested] == (uint16_t) -1)
#else
if (!(dev->sbitmap[requested >> 3] & (1 << (requested & 0x07))))
#endif
{
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
FAR struct smart_allocsector_s *allocsect;
/* Ensure this logical sector doesn't have a temporary alloc */
allocsect = dev->allocsector;
while (allocsect)
{
if (allocsect->logical == requested)
{
break;
}
allocsect = allocsect->next;
}
if (allocsect != NULL)
{
}
else
#endif
logsector = requested;
}
}
/* Check if we need to scan for an available logical sector */
if (logsector == 0xffff)
{
/* Loop through all sectors and find one to allocate */
for (x = SMART_FIRST_ALLOC_SECTOR; x < dev->totalsectors; x++)
{
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
if (dev->smap[x] == (uint16_t) -1)
#else
if (!(dev->sbitmap[x >> 3] & (1 << (x & 0x07))))
#endif
{
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
FAR struct smart_allocsector_s *allocsect;
/* Ensure this logical sector doesn't have a temporary alloc
* when CRC is enabled. With CRC enabled, when a sector is
* allocated, we don't actually update the FLASH until the
* very end when we have all data so the CRC can be calculated.
* Instead, we keep an in-memory linked list of allocated
* sectors until the write sector occurs.
*/
allocsect = dev->allocsector;
while (allocsect)
{
if (allocsect->logical == x)
{
break;
}
allocsect = allocsect->next;
}
if (allocsect != NULL)
{
/* This logical sector has an in-memory temp alloc */
continue;
}
#endif
/* Unused logical sector found. Use this one */
logsector = x;
break;
}
}
}
/* Test for an error allocating a sector */
if (logsector == 0xffff)
{
/* Hmmm. We think we had enough logical sectors, but
* something happened and we didn't find any free
* logical sectors. What do do? Report an error?
* rescan and try again to "self heal" in case of a
* bug in our code?
*/
ferr("ERROR: No free logical sector numbers! Free sectors = %d\n",
dev->freesectors);
return -EIO;
}
/* Check if we need to do garbage collection. We have to
* ensure we keep enough reserved free sectors to perform garbage
* collection as it involves moving sectors from blocks with
* released sectors into blocks with free sectors, then
* erasing the vacated block.
*/
smart_garbagecollect(dev);
/* Find a free physical sector */
physicalsector = smart_findfreephyssector(dev, FALSE);
finfo("Alloc: log=%d, phys=%d, erase block=%d, free=%d, released=%d\n",
logsector, physicalsector, physicalsector /
dev->sectorsperblk, dev->freesectors, dev->releasesectors);
if (physicalsector == 0xffff)
{
return -ENOSPC;
}
#ifdef CONFIG_MTD_SMART_ENABLE_CRC
/* When CRC is enabled, we don't write the header to the device until
* the data is written via writesector. Just add the allocation to
* our temporary allocsector list and we'll pick it up later.
*/
{
FAR struct smart_allocsector_s *allocsect =
(FAR struct smart_allocsector_s *)
kmm_malloc(sizeof(struct smart_allocsector_s));
if (allocsect == NULL)
{
ferr("ERROR: Out of memory allocting sector\n");
return -ENOMEM;
}
/* Fill in the struct and add to the list. We are protected by the
* smartfs layer's mutex, so no locking is required.
*/
allocsect->logical = logsector;
allocsect->physical = physicalsector;
allocsect->next = dev->allocsector;
dev->allocsector = allocsect;
}
#else /* CONFIG_MTD_SMART_ENABLE_CRC */
2020-11-22 07:18:52 +01:00
/* Write the logical sector to the flash. We will fill it in with data
* later.
*/
ret = smart_write_alloc_sector(dev, logsector, physicalsector);
if (ret != 1)
{
/* Error writing sector, return error */
return ret;
}
#endif /* CONFIG_MTD_SMART_ENABLE_CRC */
/* Map the sector and update the free sector counts */
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
dev->smap[logsector] = physicalsector;
#else
dev->sbitmap[logsector >> 3] |= (1 << (logsector & 0x07));
smart_add_sector_to_cache(dev, logsector, physicalsector, __LINE__);
#endif
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
smart_add_count(dev, dev->freecount,
physicalsector / dev->sectorsperblk, -1);
#else
dev->freecount[physicalsector / dev->sectorsperblk]--;
#endif
dev->freesectors--;
/* Return the logical sector number */
return logsector;
}
/****************************************************************************
* Name: smart_freesector
*
* Description: Frees a logical sector from the device. Freeing (also
* called releasing) is performed by programming the released
* bit in the sector header's status byte.
*
****************************************************************************/
static inline int smart_freesector(FAR struct smart_struct_s *dev,
unsigned long logicalsector)
{
int ret;
int readaddr;
uint16_t physsector;
uint16_t block;
struct smart_sect_header_s header;
size_t offset;
/* Check if the logical sector is within bounds */
if ((logicalsector > 2) && (logicalsector < dev->totalsectors))
{
/* Validate the sector is actually allocated */
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
if (dev->smap[logicalsector] == (uint16_t) -1)
#else
if (!(dev->sbitmap[logicalsector >> 3] &
(1 << (logicalsector & 0x07))))
#endif
{
ferr("ERROR: Invalid release - sector %ld not allocated\n",
logicalsector);
ret = -EINVAL;
goto errout;
}
}
/* Okay to release the sector. Read the sector header info */
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
physsector = dev->smap[logicalsector];
#else
physsector = smart_cache_lookup(dev, logicalsector);
#endif
readaddr = physsector * dev->mtdblkspersector * dev->geo.blocksize;
ret = MTD_READ(dev->mtd, readaddr, sizeof(struct smart_sect_header_s),
(FAR uint8_t *) &header);
if (ret != sizeof(struct smart_sect_header_s))
{
goto errout;
}
/* Do a sanity check on the logical sector number */
if (*((FAR uint16_t *) header.logicalsector) != (uint16_t) logicalsector)
{
/* Hmmm... something is wrong. This should always match! Bug in our
* code?
*/
ferr("ERROR: Sector %ld logical sector in header doesn't match\n",
logicalsector);
ret = -EINVAL;
goto errout;
}
/* Mark the sector as released */
#if CONFIG_SMARTFS_ERASEDSTATE == 0xff
header.status &= ~SMART_STATUS_RELEASED;
#else
header.status |= SMART_STATUS_RELEASED;
#endif
/* Write the status back to the device */
offset = readaddr + offsetof(struct smart_sect_header_s, status);
ret = smart_bytewrite(dev, offset, 1, &header.status);
if (ret != 1)
{
ferr("ERROR: Error updating physical sector %d status\n", physsector);
goto errout;
}
/* Update the erase block's release count */
dev->releasesectors++;
block = physsector / dev->sectorsperblk;
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
smart_add_count(dev, dev->releasecount, block, 1);
#else
dev->releasecount[block]++;
#endif
/* Unmap this logical sector */
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
dev->smap[logicalsector] = (uint16_t) -1;
#else
dev->sbitmap[logicalsector >> 3] &= ~(1 << (logicalsector & 0x07));
smart_update_cache(dev, logicalsector, 0xffff);
#endif
/* If this block has only released blocks, then erase it */
smart_erase_block_if_empty(dev, block, FALSE);
ret = OK;
errout:
return ret;
}
/****************************************************************************
* Name: smart_ioctl
*
* Description: Return device geometry
*
****************************************************************************/
static int smart_ioctl(FAR struct inode *inode, int cmd, unsigned long arg)
{
FAR struct smart_struct_s *dev;
int ret;
#if defined(CONFIG_FS_PROCFS) && !defined(CONFIG_FS_PROCFS_EXCLUDE_SMARTFS)
FAR struct mtd_smart_procfs_data_s *procfs_data;
FAR struct mtd_smart_debug_data_s *debug_data;
#endif
finfo("Entry\n");
DEBUGASSERT(inode && inode->i_private);
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
dev = ((FAR struct smart_multiroot_device_s *)inode->i_private)->dev;
#else
dev = (FAR struct smart_struct_s *)inode->i_private;
#endif
/* Process the ioctl's we care about first, pass any we don't respond
* to directly to the underlying MTD device.
*/
switch (cmd)
{
case BIOC_GETFORMAT:
/* Return the format information for the device */
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
ret = smart_getformat(dev, (FAR struct smart_format_s *) arg,
((FAR struct smart_multiroot_device_s *)
inode->i_private)->rootdirnum);
#else
ret = smart_getformat(dev, (FAR struct smart_format_s *) arg);
#endif
goto ok_out;
case BIOC_READSECT:
/* Do a logical sector read and return the data */
ret = smart_readsector(dev, arg);
goto ok_out;
case BIOC_LLFORMAT:
/* Perform a low-level format on the flash */
ret = smart_llformat(dev, arg);
goto ok_out;
case BIOC_ALLOCSECT:
/* Ensure the FS is not trying to allocate a reserved sector */
if (arg < 3)
{
arg = (unsigned long) -1;
}
/* Allocate a logical sector for the upper layer file system */
ret = smart_allocsector(dev, arg);
goto ok_out;
case BIOC_FREESECT:
/* Free the specified logical sector */
ret = smart_freesector(dev, arg);
goto ok_out;
case BIOC_WRITESECT:
/* Write to the sector */
ret = smart_writesector(dev, arg);
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
if (dev->wearflags & SMART_WEARFLAGS_WRITE_NEEDED)
{
/* Write new wear status bits to the device */
smart_write_wearstatus(dev);
}
#endif
goto ok_out;
#if defined(CONFIG_FS_PROCFS) && !defined(CONFIG_FS_PROCFS_EXCLUDE_SMARTFS)
case BIOC_GETPROCFSD:
/* Get ProcFS data */
procfs_data = (FAR struct mtd_smart_procfs_data_s *)arg;
procfs_data->totalsectors = dev->totalsectors;
procfs_data->sectorsize = dev->sectorsize;
procfs_data->freesectors = dev->freesectors;
procfs_data->releasesectors = dev->releasesectors;
procfs_data->namelen = dev->namesize;
procfs_data->formatversion = dev->formatversion;
procfs_data->unusedsectors = dev->unusedsectors;
procfs_data->blockerases = dev->blockerases;
procfs_data->sectorsperblk = dev->sectorsperblk;
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
procfs_data->formatsector = dev->smap[0];
procfs_data->dirsector = dev->smap[3];
#else
procfs_data->formatsector = smart_cache_lookup(dev, 0);
procfs_data->dirsector = smart_cache_lookup(dev, 3);
#endif
#ifdef CONFIG_MTD_SMART_SECTOR_ERASE_DEBUG
procfs_data->neraseblocks = dev->geo.neraseblocks;
procfs_data->erasecounts = dev->erasecounts;
#endif
#ifdef CONFIG_MTD_SMART_ALLOC_DEBUG
procfs_data->allocs = dev->alloc;
procfs_data->alloccount = SMART_MAX_ALLOCS;
#endif
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
procfs_data->uneven_wearcount = dev->uneven_wearcount;
#endif
ret = OK;
goto ok_out;
#endif
case BIOC_DEBUGCMD:
#if defined(CONFIG_FS_PROCFS) && !defined(CONFIG_FS_PROCFS_EXCLUDE_SMARTFS)
debug_data = (FAR struct mtd_smart_debug_data_s *) arg;
switch (debug_data->debugcmd)
{
case SMART_DEBUG_CMD_SET_DEBUG_LEVEL:
dev->debuglevel = debug_data->debugdata;
finfo("Debug level set to %d\n", dev->debuglevel);
ret = OK;
goto ok_out;
}
#endif
break;
}
/* No other block driver ioctl commands are not recognized by this
* driver. Other possible MTD driver ioctl commands are passed through
* to the MTD driver (unchanged).
*/
ret = MTD_IOCTL(dev->mtd, cmd, arg);
if (ret < 0)
{
ferr("ERROR: MTD ioctl(%04x) failed: %d\n", cmd, ret);
}
ok_out:
return ret;
}
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
#ifdef CONFIG_MTD_SMART_FSCK
/****************************************************************************
* Name: smart_fsck_crc
*
* Description: Validate CRC to check smartfs filesystem
*
****************************************************************************/
#ifdef CONFIG_MTD_SMART_FSCK_ENABLE_CRC
static int smart_fsck_crc(FAR struct smart_struct_s *dev,
uint16_t physsector)
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
{
int ret;
ret = MTD_BREAD(dev->mtd, physsector * dev->mtdblkspersector,
dev->mtdblkspersector, (FAR uint8_t *)dev->rwbuffer);
if (ret != dev->mtdblkspersector)
{
ferr("ERROR: Error reading phys sector %d\n", physsector);
return ret;
}
ret = smart_validate_crc(dev);
if (ret != OK)
{
ferr("ERROR: Error validating sector %d CRC\n", physsector);
return ret;
}
return ret;
}
#endif
/****************************************************************************
* Name: smart_fsck_file
*
* Description: fsck for file entry
*
****************************************************************************/
static int smart_fsck_file(FAR struct smart_struct_s *dev,
FAR uint8_t *checkmap, uint16_t logsector)
{
int ret = OK;
ssize_t size;
uint32_t readaddress;
FAR struct smart_sect_header_s *header;
FAR struct smart_chain_header_s *chain;
FAR uint8_t *usedmap;
size_t mapsize;
uint16_t physsector;
int i;
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
if (logsector >= dev->totalsectors)
{
ret = -EINVAL;
return ret;
}
/* Allocate a bitmap table for sectors this file is using */
mapsize = (dev->totalsectors + 7) / 8;
usedmap = (FAR uint8_t *)kmm_zalloc(mapsize);
if (!usedmap)
{
ferr("ERROR: Out of memory used map\n");
return OK;
}
do
{
/* Read the header for file sector */
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
physsector = dev->smap[logsector];
#else
physsector = smart_cache_lookup(dev, logsector);
#endif
if (physsector >= dev->totalsectors)
{
ret = -ENXIO;
ferr("ERROR: Invalid phys sector %d\n", physsector);
break;
}
#ifdef CONFIG_MTD_SMART_FSCK_ENABLE_CRC
if (smart_fsck_crc(dev, physsector) != OK)
{
ret = -ENOENT;
ferr("ERROR: CRC phys sector %d\n", physsector);
break;
}
#endif
readaddress = physsector * dev->mtdblkspersector * dev->geo.blocksize;
size = MTD_READ(dev->mtd, readaddress,
sizeof(struct smart_sect_header_s) +
sizeof(struct smart_chain_header_s),
(uint8_t *)dev->rwbuffer);
if (size != (sizeof(struct smart_sect_header_s) +
sizeof(struct smart_chain_header_s)))
{
ret = -EIO;
ferr("Error reading phys sector %d\n", physsector);
break;
}
header = (struct smart_sect_header_s *) & dev->rwbuffer[0];
chain = (struct smart_chain_header_s *) &
dev->rwbuffer[sizeof(struct smart_sect_header_s)];
/* Test if the sector has live data (not free or not released) */
if (((header->status & SMART_STATUS_COMMITTED) ==
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_COMMITTED)) ||
((header->status & SMART_STATUS_RELEASED) !=
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_RELEASED)))
{
ret = -ENOENT;
ferr("ERROR: status(%02x) phys sector %d\n",
header->status, physsector);
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
break;
}
SET_BITMAP(usedmap, logsector);
/* next logical sector */
2022-09-05 01:02:24 +02:00
logsector = SMARTFS_NEXTSECTOR(chain);
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
}
while (logsector != 0xffff);
if (ret == OK)
{
/* These sectors in use are not removed */
for (i = 0; i < mapsize; i++)
{
checkmap[i] &= ~usedmap[i];
}
}
else
{
/* This file has any corruption, these sectors will be removed */
for (i = 0; i < mapsize; i++)
{
checkmap[i] |= usedmap[i];
}
}
kmm_free(usedmap);
return ret;
}
/****************************************************************************
* Name: smart_fsck_directory
*
* Description: fsck for directory entry
*
****************************************************************************/
static int smart_fsck_directory(FAR struct smart_struct_s *dev,
FAR uint8_t *checkmap, uint16_t logsector)
{
int ret = OK;
int relocate = 0;
ssize_t size;
FAR uint8_t *rwbuffer;
FAR struct smart_sect_header_s *header;
FAR struct smart_chain_header_s *chain;
FAR struct smart_entry_header_s *entry;
uint16_t entrysector;
uint16_t physsector;
uint16_t nextsector;
uint16_t newsector;
int entrysize;
FAR uint8_t *bottom;
FAR uint8_t *cur;
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
#ifdef CONFIG_DEBUG_FS_INFO
char entryname[dev->namesize + 1];
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
#endif
if ((logsector < SMART_FIRST_DIR_SECTOR) ||
(logsector >= dev->totalsectors))
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
{
ret = -EINVAL;
ferr("ERROR: Invalid log sector %d\n", logsector);
return ret;
}
/* Allocate sector buffer for Directory entry */
rwbuffer = (uint8_t *)kmm_malloc(dev->sectorsize);
if (!rwbuffer)
{
ferr("ERROR: Out of memory sector buffer\n");
return OK;
}
/* Read the Directory entry sector */
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
physsector = dev->smap[logsector];
#else
physsector = smart_cache_lookup(dev, logsector);
#endif
if (physsector >= dev->totalsectors)
{
ret = -ENXIO;
ferr("ERROR: Invalid phys sector %d\n", physsector);
goto errout;
}
size = MTD_BREAD(dev->mtd, physsector * dev->mtdblkspersector,
dev->mtdblkspersector, rwbuffer);
if (size != dev->mtdblkspersector)
{
ret = -EIO;
ferr("ERROR: reading phys sector %d\n", physsector);
goto errout;
}
header = (struct smart_sect_header_s *) & rwbuffer[0];
chain = (struct smart_chain_header_s *) &
rwbuffer[sizeof(struct smart_sect_header_s)];
entry = (struct smart_entry_header_s *) &
rwbuffer[sizeof(struct smart_sect_header_s) +
sizeof(struct smart_chain_header_s)];
#ifdef CONFIG_MTD_SMART_FSCK_ENABLE_CRC
/* Check CRC */
if (smart_fsck_crc(dev, physsector) != OK)
{
ret = -ENOENT;
ferr("ERROR: CRC phys sector %d\n", physsector);
goto errout;
}
#endif
/* Test if the sector has live data (not free or not released) */
if (((header->status & SMART_STATUS_COMMITTED) ==
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_COMMITTED)) ||
((header->status & SMART_STATUS_RELEASED) !=
(CONFIG_SMARTFS_ERASEDSTATE & SMART_STATUS_RELEASED)))
{
ret = -ENOENT;
ferr("ERROR: status(%02x) phys sector %d\n",
header->status, physsector);
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
goto errout;
}
/* Check next sector recursively */
2022-09-05 01:02:24 +02:00
nextsector = SMARTFS_NEXTSECTOR(chain);
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
if (nextsector != 0xffff)
{
finfo("Check next log sector %d\n", nextsector);
ret = smart_fsck_directory(dev, checkmap, nextsector);
if (ret != OK)
{
/* Invalidate the next sector */
ferr("Invalidate next log sector %d\n", nextsector);
2022-09-05 01:02:24 +02:00
SMARTFS_SET_NEXTSECTOR(chain, 0xffff);
/* Set flag to relocate later */
relocate = 1;
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
}
}
#define SMARTFS_DIRENT_EMPTY 0x8000 /* Set to non-erase state when entry used */
#define SMARTFS_DIRENT_ACTIVE 0x4000 /* Set to erase state when entry is active */
#define SMARTFS_DIRENT_TYPE 0x2000 /* Indicates the type of entry (file/dir) */
#define SMARTFS_DIRENT_DELETING 0x1000 /* Directory entry is being deleted */
#define SMARTFS_DIRENT_RESERVED 0x0E00 /* Reserved bits */
/* Check file or directory under this directory entry */
entrysize = sizeof(struct smart_entry_header_s) + dev->namesize;
bottom = rwbuffer + dev->sectorsize;
cur = &rwbuffer[sizeof(struct smart_sect_header_s) +
sizeof(struct smart_chain_header_s)];
while ((cur + entrysize) <= bottom)
{
ret = OK;
entry = (struct smart_entry_header_s *)cur;
if (entry->flags == 0xffff)
{
/* Test if the empty entry is exist or not? */
break;
}
#ifdef CONFIG_DEBUG_FS_INFO
strlcpy(entryname,
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
(const char *) (cur + sizeof(struct smart_entry_header_s)),
sizeof(entryname));
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
finfo("Check entry (name=%s flags=%02x logsector=%02x)\n",
entryname, entry->flags, entry->firstsector);
#endif
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
if (entry->flags & SMARTFS_DIRENT_ACTIVE)
{
entrysector = entry->firstsector;
if (entry->flags & SMARTFS_DIRENT_TYPE)
{
/* This entry is for directory */
ret = smart_fsck_directory(dev, checkmap, entrysector);
}
else
{
/* This entry is for file */
ret = smart_fsck_file(dev, checkmap, entrysector);
}
}
if (ret != OK)
{
#ifdef CONFIG_DEBUG_FS_INFO
finfo("Remove entry (name=%s flags=%02x)\n",
entryname, entry->flags);
#endif
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
if ((cur + (2 * entrysize)) <= bottom)
{
/* Truncate the current entry and overwrite with next entries */
memmove(cur, cur + entrysize, bottom - (cur + entrysize));
memset(bottom - entrysize, CONFIG_SMARTFS_ERASEDSTATE,
entrysize);
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
}
else
{
/* Only erase the current entry if next entry does not
* exist
*/
memset(cur, CONFIG_SMARTFS_ERASEDSTATE, entrysize);
cur += entrysize;
}
relocate = 1;
}
else
{
cur += entrysize;
}
}
/* Relocate sector */
if (relocate)
{
newsector = smart_findfreephyssector(dev, FALSE);
if (newsector == 0xffff)
{
ret = -ENOSPC;
ferr("Can't find a free sector for relocation\n");
goto errout;
}
memcpy(dev->rwbuffer, rwbuffer, dev->sectorsize);
ret = smart_relocate_sector(dev, physsector, newsector);
if (ret < 0)
{
ret = -EIO;
ferr("Can't relocate\n");
goto errout;
}
/* Update the variables */
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
dev->smap[*((FAR uint16_t *)header->logicalsector)] = newsector;
#else
smart_update_cache(dev, *((FAR uint16_t *)header->logicalsector),
newsector);
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
#endif
#ifdef CONFIG_MTD_SMART_PACK_COUNTS
smart_add_count(dev, dev->freecount,
newsector / dev->sectorsperblk, -1);
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
#else
dev->freecount[newsector / dev->sectorsperblk]--;
#endif
}
kmm_free(rwbuffer);
CLR_BITMAP(checkmap, logsector);
return OK;
errout:
kmm_free(rwbuffer);
SET_BITMAP(checkmap, logsector);
return ret;
}
/****************************************************************************
* Name: smart_fsck
*
* Description: Check and repair the file system
*
****************************************************************************/
static int smart_fsck(FAR struct smart_struct_s *dev)
{
uint16_t logsector;
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
uint16_t physsector;
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
#endif
FAR uint8_t *checkmap;
size_t mapsize;
uint8_t rootdirentries;
int x;
smartfs improvements #66 Author: Alan Carvalho de Assis <acassis@gmail.com> Run nxstyle on all .c and .h and fix all issues Author: Alin Jerpelea <alin.jerpelea@sony.com> drivers: mtd: smart: Add smartfs fsck feature Support fsck to check and repair the smartfs file system. If the power loss occurs during writing into the flash, the dead space are created in flash after the next power cycle. To avoid this problem, introduce fsck and keep the consistency of file system in initializing smartfs. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com> commit 60927c5fb6a353994341601f55071c618e97682b Author: Alin Jerpelea <alin.jerpelea@sony.com> Date: Thu Dec 28 18:27:21 2017 +0900 drivers: mtd: smart: Fix duplicate sector selection in SmartFS Add care for 16-bit sequence without CRC. drivers: mtd: smart: Check CRC of duplicate sectors In the illegal case by power-loss, when the multiple logical sectors are duplicated, we compare the sequence number of each sector and select the newer sector. Just in case, add CRC check for the newer sector. If the newer sector has CRC error, then we use the older sector. drivers: mtd: smart: SPI-Flash recovery from the initial error state The FLASH may be not erased in the initial delivery state. Just in case for the recovery of this fatal situation, after once erasing the sector, return the sector as a free sector. drivers: mtd: smart: Fix error handling in smartfs mtd driver Add error handling in relocate sector. drivers: mtd: smart: Fix initialize sector sequence value in smartfs Fix initialization of sequence value into sector header and also avoid unaligned memory access when CONFIG_MTD_SMART_ENABLE_CRC=n. drivers: mtd: smart: Fix handling of duplicate sector in smartfs In smartfs scan, if duplicate logical sector is found on the device, then smartfs selects the winner sector by comparing sequence number, and the loser sector is soon released. Fix a bug this loser sector is registered into logical-to-physical sector mapping table.
2020-01-09 14:14:39 +01:00
finfo("Entry\n");
/* Allocate a bitmap table for filesystem check */
mapsize = (dev->totalsectors + 7) / 8;
checkmap = (FAR uint8_t *)kmm_zalloc(mapsize);
if (!checkmap)
{
ferr("ERROR: Out of memory fsck map\n");
return -ENOMEM;
}
/* Set all of the sectors have live data into the check bitmap */
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
for (logsector = 0; logsector < dev->totalsectors; logsector++)
{
physsector = dev->smap[logsector];
if (physsector < dev->totalsectors)
{
SET_BITMAP(checkmap, logsector);
}
}
#else
memcpy(checkmap, dev->sbitmap, mapsize);
#endif
/* Check if the sector can be available from root directories */
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
rootdirentries = dev->rootdirentries;
#else
rootdirentries = 1;
#endif
for (x = 0; x < rootdirentries; x++)
{
smart_fsck_directory(dev, checkmap, SMART_FIRST_DIR_SECTOR + x);
}
/* Release the invalid sector except for format or directory entry sector */
for (logsector = SMART_FIRST_ALLOC_SECTOR;
logsector < dev->totalsectors; logsector++)
{
if (ISSET_BITMAP(checkmap, logsector))
{
smart_freesector(dev, logsector);
}
}
/* Free the bitmap table for filesystem check */
kmm_free(checkmap);
return OK;
}
#endif /* CONFIG_MTD_SMART_FSCK */
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: smart_initialize
*
* Description:
* Initialize to provide a block driver wrapper around an MTD interface
*
* Input Parameters:
* minor - The minor device number. The MTD block device will be
* registered as as /dev/smartN where N is the minor number.
* mtd - The MTD device that supports the FLASH interface.
*
****************************************************************************/
int smart_initialize(int minor, FAR struct mtd_dev_s *mtd,
FAR const char *partname)
{
FAR struct smart_struct_s *dev;
int ret = -ENOMEM;
uint32_t totalsectors;
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
FAR struct smart_multiroot_device_s *rootdirdev = NULL;
#endif
/* Sanity check */
#ifdef CONFIG_DEBUG_FEATURES
if (minor < 0 || minor > 255 || !mtd)
{
return -EINVAL;
}
#endif
/* Allocate a SMART device structure */
dev = (FAR struct smart_struct_s *)
smart_zalloc(NULL, sizeof(struct smart_struct_s), "Dev struct");
if (dev)
{
/* Initialize the SMART device structure */
dev->mtd = mtd;
/* Get the device geometry. (casting to uintptr_t first eliminates
* complaints on some architectures where the sizeof long is different
* from the size of a pointer).
*/
/* Set these to zero in case the device doesn't support them */
ret = MTD_IOCTL(mtd, MTDIOC_GEOMETRY,
(unsigned long)((uintptr_t)&dev->geo));
if (ret < 0)
{
ferr("ERROR: MTD ioctl(MTDIOC_GEOMETRY) failed: %d\n", ret);
goto errout;
}
/* Set the sector size to the default for now */
dev->sectorsize = 0;
ret = smart_setsectorsize(dev, CONFIG_MTD_SMART_SECTOR_SIZE);
if (ret != OK)
{
goto errout;
}
/* Calculate the totalsectors on this device and validate */
totalsectors = dev->neraseblocks * dev->sectorsperblk;
if (totalsectors > 65536)
{
ferr("ERROR: SMART Sector size too small for device\n");
ret = -EINVAL;
goto errout;
}
else if (totalsectors == 65536)
{
totalsectors -= 2;
}
2013-12-13 18:44:52 +01:00
dev->totalsectors = (uint16_t)totalsectors;
dev->freesectors = (uint16_t)dev->availsectperblk *
dev->geo.neraseblocks;
dev->lastallocblock = 0;
dev->debuglevel = 0;
/* Mark the device format status an unknown */
dev->formatstatus = SMART_FMT_STAT_UNKNOWN;
dev->namesize = CONFIG_SMARTFS_MAXNAMLEN;
if (partname)
{
strlcpy(dev->partname, partname, SMART_PARTNAME_SIZE);
}
else
{
dev->partname[0] = '\0';
}
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
dev->minor = minor;
#endif
/* Do a scan of the device */
ret = smart_scan(dev);
if (ret < 0)
{
ferr("ERROR: smart_scan failed: %d\n", -ret);
goto errout;
}
/* Create a MTD block device name */
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
if (partname != NULL)
2013-12-13 18:44:52 +01:00
{
snprintf(dev->rwbuffer, 18, "/dev/smart%d%sd1", minor, partname);
}
else
2013-12-13 18:44:52 +01:00
{
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.
*/
rootdirdev = (FAR struct smart_multiroot_device_s *)
smart_malloc(dev, sizeof(*rootdirdev), "Root Dir");
if (rootdirdev == NULL)
{
ferr("ERROR: register_blockdriver failed: %d\n", -ret);
ret = -ENOMEM;
goto errout;
}
/* Populate the rootdirdev */
rootdirdev->dev = dev;
rootdirdev->rootdirnum = 0;
ret = register_blockdriver(dev->rwbuffer, &g_bops, 0, rootdirdev);
#else
if (partname != NULL)
2013-12-13 18:44:52 +01:00
{
snprintf(dev->rwbuffer, 18, "/dev/smart%d%s", minor, partname);
}
else
2013-12-13 18:44:52 +01:00
{
snprintf(dev->rwbuffer, 18, "/dev/smart%d", minor);
}
/* Inode private data is a reference to the SMART device structure */
ret = register_blockdriver(dev->rwbuffer, &g_bops, 0, dev);
#endif
if (ret < 0)
{
ferr("ERROR: register_blockdriver failed: %d\n", -ret);
goto errout;
}
}
#ifdef CONFIG_SMART_DEV_LOOP
register_driver("/dev/smart", &g_fops, 0666, NULL);
#endif
return OK;
errout:
#ifndef CONFIG_MTD_SMART_MINIMIZE_RAM
smart_free(dev, dev->smap);
#else
smart_free(dev, dev->sbitmap);
smart_free(dev, dev->scache);
#endif
smart_free(dev, dev->rwbuffer);
#ifdef CONFIG_MTD_SMART_WEAR_LEVEL
smart_free(dev, dev->wearstatus);
#endif
#ifdef CONFIG_MTD_SMART_SECTOR_ERASE_DEBUG
smart_free(dev, dev->erasecounts);
#endif
#ifdef CONFIG_SMARTFS_MULTI_ROOT_DIRS
if (rootdirdev)
{
smart_free(dev, rootdirdev);
}
#endif
kmm_free(dev);
return ret;
}
/****************************************************************************
* Name: smart_losetup
*
* Description: Dynamically setups up a SMART enabled loop device that
* is backed by a file. The resulting loop device is a
* MTD type block device vs. a generic block device.
*
****************************************************************************/
#ifdef CONFIG_SMART_DEV_LOOP
static int smart_losetup(int minor, FAR const char *filename,
int sectsize, int erasesize, off_t offset, bool readonly)
{
FAR struct mtd_dev_s *mtd;
struct stat sb;
int x;
int ret;
char devpath[20];
/* Try to create a filemtd device using the filename provided */
mtd = filemtd_initialize(filename, offset, sectsize, erasesize);
if (mtd == NULL)
{
return -ENOENT;
}
/* Check if we need to dynamically assign a minor number */
if (minor == -1)
{
/* Start at zero and stat /dev/smartX until no entry found.
* Searching 0 to 256 should be sufficient.
*/
for (x = 0; x < 256; x++)
{
snprintf(devpath, sizeof(devpath), "/dev/smart%d", x);
ret = nx_stat(devpath, &sb, 1);
if (ret < 0)
{
/* We can use this minor number */
minor = x;
break;
}
}
}
/* Now create a smart MTD using the filemtd backing it */
ret = smart_initialize(minor, mtd, NULL);
if (ret != OK)
{
filemtd_teardown(mtd);
}
return ret;
}
#endif /* CONFIG_SMART_DEV_LOOP */
/****************************************************************************
* Name: loteardown
*
* Description:
* Undo the setup performed by losetup
*
****************************************************************************/
#ifdef CONFIG_SMART_DEV_LOOP
static int smart_loteardown(FAR const char *devname)
{
FAR struct smart_struct_s *dev;
FAR struct inode *inode;
int ret;
/* Sanity check */
#ifdef CONFIG_DEBUG_FEATURES
if (!devname)
{
return -EINVAL;
}
#endif
/* Open the block driver associated with devname so that we can get the
* inode reference.
*/
ret = open_blockdriver(devname, MS_RDONLY, &inode);
if (ret < 0)
{
ferr("ERROR: Failed to open %s: %d\n", devname, -ret);
return ret;
}
/* Inode private data is a reference to the loop device structure */
dev = (FAR struct smart_struct_s *)inode->i_private;
/* Validate this is a filemtd backended device */
if (!filemtd_isfilemtd(dev->mtd))
{
ferr("ERROR: Device is not a SMART loop: %s\n", devname);
return -EINVAL;
}
close_blockdriver(inode);
/* Now teardown the filemtd */
filemtd_teardown(dev->mtd);
unregister_blockdriver(devname);
kmm_free(dev);
return OK;
}
#endif /* CONFIG_SMART_DEV_LOOP */
/****************************************************************************
* Name: smart_loop_read
****************************************************************************/
#ifdef CONFIG_SMART_DEV_LOOP
static ssize_t smart_loop_read(FAR struct file *filep, FAR char *buffer,
size_t len)
{
return 0; /* Return EOF */
}
#endif /* CONFIG_SMART_DEV_LOOP */
/****************************************************************************
* Name: smart_loop_write
****************************************************************************/
#ifdef CONFIG_SMART_DEV_LOOP
static ssize_t smart_loop_write(FAR struct file *filep,
FAR const char *buffer, size_t len)
{
return len; /* Say that everything was written */
}
#endif /* CONFIG_SMART_DEV_LOOP */
/****************************************************************************
* Name: smart_loop_ioctl
****************************************************************************/
#ifdef CONFIG_SMART_DEV_LOOP
static int smart_loop_ioctl(FAR struct file *filep, int cmd,
unsigned long arg)
{
int ret;
switch (cmd)
{
/* Command: LOOPIOC_SETUP
* Description: Setup the loop device
* Argument: A pointer to a read-only instance of struct losetup_s.
* Dependencies: The loop device must be enabled (CONFIG_DEV_LOOP=y)
*/
case SMART_LOOPIOC_SETUP:
{
FAR struct smart_losetup_s *setup =
(FAR struct smart_losetup_s *)((uintptr_t)arg);
if (setup == NULL)
{
ret = -EINVAL;
}
else
{
ret = smart_losetup(setup->minor, setup->filename,
setup->sectsize, setup->erasesize,
setup->offset, setup->readonly);
}
}
break;
/* Command: LOOPIOC_TEARDOWN
* Description: Teardown a loop device previously setup via
* LOOPIOC_SETUP
* Argument: A read-able pointer to the path of the device to be
* torn down
* Dependencies: The loop device must be enabled (CONFIG_DEV_LOOP=y)
*/
case SMART_LOOPIOC_TEARDOWN:
{
FAR const char *devname = (FAR const char *)((uintptr_t)arg);
if (devname == NULL)
{
ret = -EINVAL;
}
else
{
ret = smart_loteardown(devname);
}
}
break;
default:
ret = -ENOTTY;
}
return ret;
}
#endif /* CONFIG_SMART_DEV_LOOP */