From f754a8021ca6db4acae67d4fa379b76d47514daf Mon Sep 17 00:00:00 2001 From: Andrzej Puzdrowski Date: Thu, 9 Jan 2020 11:35:13 +0100 Subject: [PATCH] fs: remove NFFS subsystem NFFS is removed as it has serious bugs (by design) which haven't been resolved since extended range of time. One of most serious issues bunch were described here: https://github.com/apache/mynewt-nffs/issues/10 Since lack of support NFFS upsterem it doesn't make sense to keep it in zephyr. Signed-off-by: Andrzej Puzdrowski --- include/fs/fs.h | 1 - include/fs/fs_interface.h | 2 +- subsys/fs/CMakeLists.txt | 2 - subsys/fs/Kconfig | 64 ---- subsys/fs/nffs_fs.c | 613 -------------------------------------- subsys/fs/shell.c | 62 +--- 6 files changed, 4 insertions(+), 740 deletions(-) delete mode 100644 subsys/fs/nffs_fs.c diff --git a/include/fs/fs.h b/include/fs/fs.h index d35b6a6976fd0a..1ad785baa96289 100644 --- a/include/fs/fs.h +++ b/include/fs/fs.h @@ -47,7 +47,6 @@ enum fs_dir_entry_type { enum fs_type { FS_FATFS = 0, - FS_NFFS, FS_LITTLEFS, FS_TYPE_END, }; diff --git a/include/fs/fs_interface.h b/include/fs/fs_interface.h index 684ec18d57188c..42bbd1133bf67b 100644 --- a/include/fs/fs_interface.h +++ b/include/fs/fs_interface.h @@ -11,7 +11,7 @@ extern "C" { #endif -#if defined(CONFIG_FILE_SYSTEM_LITTLEFS) || defined(CONFIG_FILE_SYSTEM_NFFS) +#if defined(CONFIG_FILE_SYSTEM_LITTLEFS) #define MAX_FILE_NAME 256 #else /* FAT_FS */ #define MAX_FILE_NAME 12 /* Uses 8.3 SFN */ diff --git a/subsys/fs/CMakeLists.txt b/subsys/fs/CMakeLists.txt index 54af259b33fbc5..66e01e4df70702 100644 --- a/subsys/fs/CMakeLists.txt +++ b/subsys/fs/CMakeLists.txt @@ -8,14 +8,12 @@ if(CONFIG_FILE_SYSTEM) zephyr_library_sources(fs.c fs_impl.c) zephyr_library_sources_ifdef(CONFIG_FAT_FILESYSTEM_ELM fat_fs.c) zephyr_library_sources_ifdef(CONFIG_FILE_SYSTEM_LITTLEFS littlefs_fs.c) - zephyr_library_sources_ifdef(CONFIG_FILE_SYSTEM_NFFS nffs_fs.c) zephyr_library_sources_ifdef(CONFIG_FILE_SYSTEM_SHELL shell.c) zephyr_library_link_libraries(FS) target_link_libraries_ifdef(CONFIG_FAT_FILESYSTEM_ELM FS INTERFACE ELMFAT) target_link_libraries_ifdef(CONFIG_FILE_SYSTEM_LITTLEFS FS INTERFACE LITTLEFS) - target_link_libraries_ifdef(CONFIG_FILE_SYSTEM_NFFS FS INTERFACE NFFS) endif() add_subdirectory_ifdef(CONFIG_FCB ./fcb) diff --git a/subsys/fs/Kconfig b/subsys/fs/Kconfig index a299af36002f0b..b65aa47908e473 100644 --- a/subsys/fs/Kconfig +++ b/subsys/fs/Kconfig @@ -28,14 +28,6 @@ config FAT_FILESYSTEM_ELM help Use the ELM FAT File system implementation. -config FILE_SYSTEM_NFFS - bool "NFFS file system support" - depends on FLASH_PAGE_LAYOUT - help - Enables NFFS file system support. - Note: NFFS requires 1-byte unaligned access to flash thus it - will not work on devices that support only aligned flash access. - config FILE_SYSTEM_LITTLEFS bool "LittleFS file system support" depends on FLASH_MAP @@ -69,62 +61,6 @@ config FS_FATFS_NUM_DIRS default 4 endmenu -menu "NFFS Settings" - visible if FILE_SYSTEM_NFFS - -config FS_NFFS_FLASH_DEV_NAME - string "Flash device name to be used" - -config FS_NFFS_NUM_INODES - int "Maximum number of inodes" - range 1 32768 - default 100 - -config FS_NFFS_NUM_BLOCKS - int "Maximum number of blocks" - range 1 32768 - default 100 - -config FS_NFFS_NUM_FILES - int "Maximum number of opened files" - range 1 256 - default 4 - -config FS_NFFS_NUM_DIRS - int "Maximum number of opened directories" - range 1 256 - default 4 - -config FS_NFFS_NUM_CACHE_INODES - int "Number of cached files' inodes" - range 1 512 - default 4 - -config FS_NFFS_NUM_CACHE_BLOCKS - int "Number of cached blocks" - range 1 512 - default 64 - -config NFFS_FILESYSTEM_MAX_AREAS - int "Maximum number of areas" - range 2 64 - default 8 - help - This defines maximum number of areas located on flash. Each area can - be erased without affecting other areas thus the size of area can - affect performance of GC where single area has to be rewritten. - At least one scratch and one non-scratch area is required. - -config NFFS_FILESYSTEM_MAX_BLOCK_SIZE - int "Maximum block size" - range 16 2048 - default 2048 - help - This determines the maximum size of data block written to flash. - Writes larger than this size are split into multiple write operations. - -endmenu - source "subsys/fs/Kconfig.littlefs" endif # FILE_SYSTEM diff --git a/subsys/fs/nffs_fs.c b/subsys/fs/nffs_fs.c deleted file mode 100644 index 7556d0320fc023..00000000000000 --- a/subsys/fs/nffs_fs.c +++ /dev/null @@ -1,613 +0,0 @@ -/* - * Copyright (c) 2017 Codecoup - * - * SPDX-License-Identifier: Apache-2.0 - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "fs_impl.h" - -#define NFFS_MAX_FILE_NAME 256 - -/* - * NFFS code keeps fs state in RAM but access to these structures is not - * thread-safe - we need global lock for each fs operation to guarantee two - * threads won't modify NFFS at the same time. - */ -static struct k_mutex nffs_lock; - -/* - * TODO: Get rid of global flash_dev which limits - * system to have multiple instances of NFFS. - */ -static struct device *flash_dev; - -/* nffs flash area descriptors */ -static struct nffs_area_desc descs[CONFIG_NFFS_FILESYSTEM_MAX_AREAS + 1]; - -K_MEM_SLAB_DEFINE(nffs_file_pool, sizeof(struct nffs_file), - CONFIG_FS_NFFS_NUM_FILES, 4); -K_MEM_SLAB_DEFINE(nffs_dir_pool, sizeof(struct nffs_dir), - CONFIG_FS_NFFS_NUM_DIRS, 4); -K_MEM_SLAB_DEFINE(nffs_inode_entry_pool, sizeof(struct nffs_inode_entry), - CONFIG_FS_NFFS_NUM_INODES, 4); -K_MEM_SLAB_DEFINE(nffs_block_entry_pool, sizeof(struct nffs_hash_entry), - CONFIG_FS_NFFS_NUM_BLOCKS, 4); -K_MEM_SLAB_DEFINE(nffs_cache_inode_pool, sizeof(struct nffs_cache_inode), - CONFIG_FS_NFFS_NUM_CACHE_INODES, 4); -K_MEM_SLAB_DEFINE(nffs_cache_block_pool, sizeof(struct nffs_cache_block), - CONFIG_FS_NFFS_NUM_CACHE_BLOCKS, 4); - -static int translate_error(int error) -{ - switch (error) { - case FS_EOK: - return 0; - case FS_ECORRUPT: - case FS_EHW: - return -EIO; - case FS_EOFFSET: - case FS_EINVAL: - return -EINVAL; - case FS_ENOMEM: - return -ENOMEM; - case FS_ENOENT: - return -ENOENT; - case FS_EEMPTY: - return -ENODEV; - case FS_EFULL: - return -ENOSPC; - case FS_EUNEXP: - case FS_EOS: - return -EIO; - case FS_EEXIST: - return -EEXIST; - case FS_EACCESS: - return -EACCES; - case FS_EUNINIT: - return -EIO; - } - - return -EIO; -} - -int nffs_os_mempool_init(void) -{ - /* - * Just reinitialize slabs here - this is what original implementation - * does. We assume all references to previously allocated blocks, if - * any, are invalidated in NFFS code already. - */ - - k_mem_slab_init(&nffs_file_pool, _k_mem_slab_buf_nffs_file_pool, - sizeof(struct nffs_file), - CONFIG_FS_NFFS_NUM_FILES); - k_mem_slab_init(&nffs_dir_pool, _k_mem_slab_buf_nffs_dir_pool, - sizeof(struct nffs_dir), - CONFIG_FS_NFFS_NUM_DIRS); - k_mem_slab_init(&nffs_inode_entry_pool, - _k_mem_slab_buf_nffs_inode_entry_pool, - sizeof(struct nffs_inode_entry), - CONFIG_FS_NFFS_NUM_INODES); - k_mem_slab_init(&nffs_block_entry_pool, - _k_mem_slab_buf_nffs_block_entry_pool, - sizeof(struct nffs_hash_entry), - CONFIG_FS_NFFS_NUM_BLOCKS); - k_mem_slab_init(&nffs_cache_inode_pool, - _k_mem_slab_buf_nffs_cache_inode_pool, - sizeof(struct nffs_cache_inode), - CONFIG_FS_NFFS_NUM_CACHE_INODES); - k_mem_slab_init(&nffs_cache_block_pool, - _k_mem_slab_buf_nffs_cache_block_pool, - sizeof(struct nffs_cache_block), - CONFIG_FS_NFFS_NUM_CACHE_BLOCKS); - - return 0; -} - -void *nffs_os_mempool_get(nffs_os_mempool_t *pool) -{ - int rc; - void *ptr; - - rc = k_mem_slab_alloc(pool, &ptr, K_NO_WAIT); - if (rc) { - ptr = NULL; - } - - return ptr; -} - -int nffs_os_mempool_free(nffs_os_mempool_t *pool, void *block) -{ - k_mem_slab_free(pool, &block); - - return 0; -} - -int nffs_os_flash_read(uint8_t id, uint32_t address, void *dst, - uint32_t num_bytes) -{ - int rc; - - rc = flash_read(flash_dev, address, dst, num_bytes); - - return rc; -} - -int nffs_os_flash_write(uint8_t id, uint32_t address, const void *src, - uint32_t num_bytes) -{ - int rc; - - rc = flash_write_protection_set(flash_dev, false); - if (rc) { - return rc; - } - - rc = flash_write(flash_dev, address, src, num_bytes); - - /* Ignore errors here - this does not affect write operation */ - (void) flash_write_protection_set(flash_dev, true); - - return rc; -} - -int nffs_os_flash_erase(uint8_t id, uint32_t address, uint32_t num_bytes) -{ - int rc; - - rc = flash_write_protection_set(flash_dev, false); - if (rc) { - return rc; - } - - rc = flash_erase(flash_dev, address, num_bytes); - - /* Ignore errors here - this does not affect erase operation */ - (void) flash_write_protection_set(flash_dev, true); - - return rc; -} - -int nffs_os_flash_info(uint8_t id, uint32_t sector, uint32_t *address, - uint32_t *size) -{ - struct flash_pages_info pi; - int rc; - - rc = flash_get_page_info_by_idx(flash_dev, sector, &pi); - __ASSERT(rc == 0, "Failed to obtain flash page data"); - - *address = pi.start_offset; - *size = pi.size; - - return 0; -} - -uint16_t nffs_os_crc16_ccitt(uint16_t initial_crc, const void *buf, int len, - int final) -{ - return crc16(buf, len, 0x1021, initial_crc, final); -} - -static int inode_to_dirent(struct nffs_inode_entry *inode, - struct fs_dirent *entry) -{ - u8_t name_len; - uint32_t size; - int rc; - - rc = nffs_inode_read_filename(inode, sizeof(entry->name), entry->name, - &name_len); - if (rc) { - return rc; - } - - if (nffs_hash_id_is_dir(inode->nie_hash_entry.nhe_id)) { - entry->type = FS_DIR_ENTRY_DIR; - entry->size = 0; - } else { - entry->type = FS_DIR_ENTRY_FILE; - rc = nffs_inode_data_len(inode, &size); - if (rc) { - return rc; - } - entry->size = size; - } - - return rc; -} - -static int nffs_open(struct fs_file_t *zfp, const char *file_name) -{ - int rc; - - file_name = fs_impl_strip_prefix(file_name, zfp->mp); - - k_mutex_lock(&nffs_lock, K_FOREVER); - - zfp->filep = NULL; - - if (!nffs_misc_ready()) { - k_mutex_unlock(&nffs_lock); - return -ENODEV; - } - - rc = nffs_file_open((struct nffs_file **)&zfp->filep, file_name, - FS_ACCESS_READ | FS_ACCESS_WRITE); - - k_mutex_unlock(&nffs_lock); - - return translate_error(rc); -} - -static int nffs_close(struct fs_file_t *zfp) -{ - int rc; - - k_mutex_lock(&nffs_lock, K_FOREVER); - - rc = nffs_file_close(zfp->filep); - if (!rc) { - zfp->filep = NULL; - } - - k_mutex_unlock(&nffs_lock); - - return translate_error(rc); -} - -static int nffs_unlink(struct fs_mount_t *mountp, const char *path) -{ - int rc; - - path = fs_impl_strip_prefix(path, mountp); - - k_mutex_lock(&nffs_lock, K_FOREVER); - - rc = nffs_path_unlink(path); - - k_mutex_unlock(&nffs_lock); - - return translate_error(rc); -} - -static ssize_t nffs_read(struct fs_file_t *zfp, void *ptr, size_t size) -{ - uint32_t br; - int rc; - - k_mutex_lock(&nffs_lock, K_FOREVER); - - rc = nffs_file_read(zfp->filep, size, ptr, &br); - - k_mutex_unlock(&nffs_lock); - - if (rc) { - return translate_error(rc); - } - - return br; -} - -static ssize_t nffs_write(struct fs_file_t *zfp, const void *ptr, size_t size) -{ - int rc; - - k_mutex_lock(&nffs_lock, K_FOREVER); - - rc = nffs_write_to_file(zfp->filep, ptr, size); - - k_mutex_unlock(&nffs_lock); - - if (rc) { - return translate_error(rc); - } - - /* We need to assume all bytes were written */ - return size; -} - -static int nffs_seek(struct fs_file_t *zfp, off_t offset, int whence) -{ - uint32_t len; - u32_t pos; - int rc; - - k_mutex_lock(&nffs_lock, K_FOREVER); - - switch (whence) { - case FS_SEEK_SET: - pos = offset; - break; - case FS_SEEK_CUR: - pos = ((struct nffs_file *)zfp->filep)->nf_offset + offset; - break; - case FS_SEEK_END: - rc = nffs_inode_data_len(((struct nffs_file *)zfp->filep)->nf_inode_entry, &len); - if (rc) { - k_mutex_unlock(&nffs_lock); - return -EINVAL; - } - pos = len + offset; - break; - default: - k_mutex_unlock(&nffs_lock); - return -EINVAL; - } - - rc = nffs_file_seek(zfp->filep, pos); - - k_mutex_unlock(&nffs_lock); - - return translate_error(rc); -} - -static off_t nffs_tell(struct fs_file_t *zfp) -{ - u32_t offset; - - k_mutex_lock(&nffs_lock, K_FOREVER); - - if (!zfp->filep) { - k_mutex_unlock(&nffs_lock); - return -EIO; - } - - offset = ((struct nffs_file *)zfp->filep)->nf_offset; - - k_mutex_unlock(&nffs_lock); - - return offset; -} - -static int nffs_truncate(struct fs_file_t *zfp, off_t length) -{ - /* - * FIXME: - * There is no API in NFFS to truncate opened file. For now we return - * ENOTSUP, but this should be revisited if truncation is implemented - * in NFFS at some point. - */ - - return -ENOTSUP; -} - -static int nffs_sync(struct fs_file_t *zfp) -{ - /* - * Files are written to flash immediately so we do not need to support - * sync call - just return success. - */ - - return 0; -} - -static int nffs_mkdir(struct fs_mount_t *mountp, const char *path) -{ - int rc; - - path = fs_impl_strip_prefix(path, mountp); - - k_mutex_lock(&nffs_lock, K_FOREVER); - - if (!nffs_misc_ready()) { - k_mutex_unlock(&nffs_lock); - return -ENODEV; - } - - rc = nffs_path_new_dir(path, NULL); - - k_mutex_unlock(&nffs_lock); - - return translate_error(rc); -} - -static int nffs_opendir(struct fs_dir_t *zdp, const char *path) -{ - int rc; - - path = fs_impl_strip_prefix(path, zdp->mp); - - k_mutex_lock(&nffs_lock, K_FOREVER); - - zdp->dirp = NULL; - - if (!nffs_misc_ready()) { - k_mutex_unlock(&nffs_lock); - return -ENODEV; - } - - rc = nffs_dir_open(path, (struct nffs_dir **)&zdp->dirp); - - k_mutex_unlock(&nffs_lock); - - return translate_error(rc); -} - -static int nffs_readdir(struct fs_dir_t *zdp, struct fs_dirent *entry) -{ - struct nffs_dirent *dirent; - int rc; - - k_mutex_lock(&nffs_lock, K_FOREVER); - - rc = nffs_dir_read(zdp->dirp, &dirent); - switch (rc) { - case 0: - rc = inode_to_dirent(dirent->nde_inode_entry, entry); - break; - case FS_ENOENT: - entry->name[0] = 0; - rc = 0; - break; - default: - break; - } - - k_mutex_unlock(&nffs_lock); - - return translate_error(rc); -} - -static int nffs_closedir(struct fs_dir_t *zdp) -{ - int rc; - - k_mutex_lock(&nffs_lock, K_FOREVER); - - rc = nffs_dir_close(zdp->dirp); - if (!rc) { - zdp->dirp = NULL; - } - - k_mutex_unlock(&nffs_lock); - - return translate_error(rc); -} - -static int nffs_stat(struct fs_mount_t *mountp, - const char *path, struct fs_dirent *entry) -{ - struct nffs_path_parser parser; - struct nffs_inode_entry *parent; - struct nffs_inode_entry *inode; - int rc; - - path = fs_impl_strip_prefix(path, mountp); - - k_mutex_lock(&nffs_lock, K_FOREVER); - - nffs_path_parser_new(&parser, path); - - rc = nffs_path_find(&parser, &inode, &parent); - if (rc == 0) { - rc = inode_to_dirent(inode, entry); - } - - k_mutex_unlock(&nffs_lock); - - return translate_error(rc); -} - -static int nffs_statvfs(struct fs_mount_t *mountp, - const char *path, struct fs_statvfs *stat) -{ - /* - * FIXME: - * There is not API to retrieve such data in NFFS. - */ - - return -ENOTSUP; -} - -static int nffs_rename(struct fs_mount_t *mountp, const char *from, - const char *to) -{ - int rc; - - from = fs_impl_strip_prefix(from, mountp); - to = fs_impl_strip_prefix(to, mountp); - - k_mutex_lock(&nffs_lock, K_FOREVER); - - if (!nffs_misc_ready()) { - k_mutex_unlock(&nffs_lock); - return -ENODEV; - } - - rc = nffs_path_rename(from, to); - - k_mutex_unlock(&nffs_lock); - - return translate_error(rc); -} - -static int nffs_mount(struct fs_mount_t *mountp) -{ - struct nffs_flash_desc *flash_desc = - (struct nffs_flash_desc *)mountp->fs_data; - int cnt; - int rc; - - /* Set flash device */ - flash_dev = (struct device *)mountp->storage_dev; - - /* Set flash descriptor fields */ - flash_desc->id = 0; - flash_desc->sector_count = flash_get_page_count(flash_dev); - flash_desc->area_offset = DT_FLASH_AREA_STORAGE_OFFSET; - flash_desc->area_size = DT_FLASH_AREA_STORAGE_SIZE; - - rc = nffs_misc_reset(); - if (rc) { - return -EIO; - } - - cnt = CONFIG_NFFS_FILESYSTEM_MAX_AREAS; - rc = nffs_misc_desc_from_flash_area(flash_desc, &cnt, descs); - if (rc) { - return -EIO; - } - - rc = nffs_restore_full(descs); - switch (rc) { - case 0: - break; - case FS_ECORRUPT: - rc = nffs_format_full(descs); - if (rc) { - return -EIO; - } - break; - default: - return -EIO; - } - - return 0; -} - -/* File system interface */ -static struct fs_file_system_t nffs_fs = { - .open = nffs_open, - .close = nffs_close, - .read = nffs_read, - .write = nffs_write, - .lseek = nffs_seek, - .tell = nffs_tell, - .truncate = nffs_truncate, - .sync = nffs_sync, - .opendir = nffs_opendir, - .readdir = nffs_readdir, - .closedir = nffs_closedir, - .mount = nffs_mount, - .unlink = nffs_unlink, - .rename = nffs_rename, - .mkdir = nffs_mkdir, - .stat = nffs_stat, - .statvfs = nffs_statvfs, -}; - -static int nffs_init(struct device *dev) -{ - ARG_UNUSED(dev); - - k_mutex_init(&nffs_lock); - - return fs_register(FS_NFFS, &nffs_fs); -} - -SYS_INIT(nffs_init, APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT); diff --git a/subsys/fs/shell.c b/subsys/fs/shell.c index 5400b29a8ce024..012e95acd52bfe 100644 --- a/subsys/fs/shell.c +++ b/subsys/fs/shell.c @@ -27,18 +27,6 @@ static struct fs_mount_t fatfs_mnt = { .fs_data = &fat_fs, }; #endif -/* NFFS */ -#ifdef CONFIG_FILE_SYSTEM_NFFS -#include -#define NFFS_MNTP "/nffs" -/* NFFS work area struct */ -static struct nffs_flash_desc flash_desc; -/* mounting info */ -static struct fs_mount_t nffs_mnt = { - .type = FS_NFFS, - .fs_data = &flash_desc, -}; -#endif /* LITTLEFS */ #ifdef CONFIG_FILE_SYSTEM_LITTLEFS #include @@ -428,8 +416,7 @@ static int cmd_write(const struct shell *shell, size_t argc, char **argv) } #if defined(CONFIG_FAT_FILESYSTEM_ELM) \ - || defined(CONFIG_FILE_SYSTEM_LITTLEFS) \ - || defined(CONFIG_FILE_SYSTEM_NFFS) + || defined(CONFIG_FILE_SYSTEM_LITTLEFS) static char *mntpt_prepare(char *mntpt) { char *cpy_mntpt; @@ -471,41 +458,6 @@ static int cmd_mount_fat(const struct shell *shell, size_t argc, char **argv) } #endif -#if defined(CONFIG_FILE_SYSTEM_NFFS) -static int cmd_mount_nffs(const struct shell *shell, size_t argc, char **argv) -{ - struct device *flash_dev; - char *mntpt; - int res; - - mntpt = mntpt_prepare(argv[1]); - if (!mntpt) { - shell_error(shell, - "Failed to allocate buffer for mount point"); - return -ENOEXEC; - } - - nffs_mnt.mnt_point = (const char *)mntpt; - flash_dev = device_get_binding(CONFIG_FS_NFFS_FLASH_DEV_NAME); - if (!flash_dev) { - shell_error(shell, "nffs device %s not found", - CONFIG_FS_NFFS_FLASH_DEV_NAME); - return -ENOEXEC; - } - - nffs_mnt.storage_dev = flash_dev; - res = fs_mount(&nffs_mnt); - if (res != 0) { - shell_error(shell, "Error mounting nffs: %d", res); - return -ENOEXEC; - } - - shell_print(shell, "Successfully mounted fs:%s", nffs_mnt.mnt_point); - - return 0; -} -#endif - #if defined(CONFIG_FILE_SYSTEM_LITTLEFS) static int cmd_mount_littlefs(const struct shell *shell, size_t argc, char **argv) @@ -535,8 +487,7 @@ static int cmd_mount_littlefs(const struct shell *shell, size_t argc, char **arg #endif #if defined(CONFIG_FAT_FILESYSTEM_ELM) \ - || defined(CONFIG_FILE_SYSTEM_LITTLEFS) \ - || defined(CONFIG_FILE_SYSTEM_NFFS) + || defined(CONFIG_FILE_SYSTEM_LITTLEFS) SHELL_STATIC_SUBCMD_SET_CREATE(sub_fs_mount, #if defined(CONFIG_FAT_FILESYSTEM_ELM) SHELL_CMD_ARG(fat, NULL, @@ -550,12 +501,6 @@ SHELL_STATIC_SUBCMD_SET_CREATE(sub_fs_mount, cmd_mount_littlefs, 2, 0), #endif -#if defined(CONFIG_FILE_SYSTEM_NFFS) - SHELL_CMD_ARG(nffs, NULL, - "Mount nffs. fs mount nffs ", - cmd_mount_nffs, 2, 0), -#endif - SHELL_SUBCMD_SET_END ); #endif @@ -565,8 +510,7 @@ SHELL_STATIC_SUBCMD_SET_CREATE(sub_fs, SHELL_CMD(ls, NULL, "List files in current directory", cmd_ls), SHELL_CMD_ARG(mkdir, NULL, "Create directory", cmd_mkdir, 2, 0), #if defined(CONFIG_FAT_FILESYSTEM_ELM) \ - || defined(CONFIG_FILE_SYSTEM_LITTLEFS) \ - || defined(CONFIG_FILE_SYSTEM_NFFS) + || defined(CONFIG_FILE_SYSTEM_LITTLEFS) SHELL_CMD(mount, &sub_fs_mount, " ", NULL), #endif