littlefs not mount to external flash winbond w25q256

RE: littlefs not mount to external flash winbond w25q256

AHaug — Mon, 22 Sep 2025 13:14:59 GMT

Hi,

You're query is incomprehensive. Please use the insert code boxes that I mentioned. I've edited your reply yet again to use those.

Your device initializes, but as the error states

"Erase error: address or size exceeds expected values.Addr: 0x480000 size 65536"

Seems to me that you are writing out of bounds.

Kind regards,
Andreas

RE: littlefs not mount to external flash winbond w25q256

pushparaj — Tue, 16 Sep 2025 05:14:14 GMT

hi AHaug aHuag can u response for the issue

RE: littlefs not mount to external flash winbond w25q256

pushparaj — Wed, 10 Sep 2025 01:17:28 GMT

#include <stdio.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/fs/fs.h>
#include <zephyr/fs/littlefs.h>
#include <zephyr/logging/log.h>
#include <zephyr/storage/flash_map.h>
#include <zephyr/drivers/flash.h>


LOG_MODULE_REGISTER(main);

#define MAX_PATH_LEN 255
#define DATA_BLOCK_SIZE 406
#define WRITE_INTERVAL_MS 1000  // 1 second
#define MAX_FILE_SIZE_MB 10     // Very conservative 10MB limit per file
#define MAX_TOTAL_USAGE_MB 25   // Stop writing when 25MB total is used
#define MAX_FILE_SIZE_BYTES (MAX_FILE_SIZE_MB * 1024 * 1024)
#define MAX_TOTAL_USAGE_BYTES (MAX_TOTAL_USAGE_MB * 1024 * 1024)

static uint8_t data_buffer[DATA_BLOCK_SIZE];
static uint32_t write_counter = 0;
static uint32_t total_bytes_written = 0;
static uint32_t current_file_size = 0;

static void generate_data_pattern(uint8_t *buffer, uint32_t sequence_num)
{
	// Create a header with metadata (16 bytes)
	struct data_header {
		uint32_t sequence;      // 4 bytes - sequence number
		uint64_t timestamp;     // 8 bytes - system uptime
		uint32_t checksum;      // 4 bytes - simple checksum
	} __packed;

	struct data_header *header = (struct data_header *)buffer;
	
	// Fill header
	header->sequence = sequence_num;
	header->timestamp = k_uptime_get();
	
	// Fill remaining 390 bytes with pattern
	uint8_t *data_section = buffer + sizeof(struct data_header);
	uint16_t remaining_bytes = DATA_BLOCK_SIZE - sizeof(struct data_header);
	
	// Create pattern: repeating sequence with variations
	for (int i = 0; i < remaining_bytes; i++) {
		if (i % 16 == 0) {
			// Every 16th byte: sequence-dependent value
			data_section[i] = (sequence_num + i) & 0xFF;
		} else if (i % 8 == 0) {
			// Every 8th byte: timestamp-dependent value
			data_section[i] = (header->timestamp >> (i % 32)) & 0xFF;
		} else {
			// Other bytes: mixed pattern
			data_section[i] = (0x55 ^ (i & 0xFF) ^ (sequence_num & 0xFF));
		}
	}
	
	// Calculate simple checksum (sum of all data bytes)
	uint32_t checksum = 0;
	for (int i = sizeof(struct data_header); i < DATA_BLOCK_SIZE; i++) {
		checksum += buffer[i];
	}
	header->checksum = checksum;
}
static int write_406_bytes_continuous(char *fname, struct fs_mount_t *mp)
{
    struct fs_file_t file;
    int rc, ret;
    struct fs_statvfs sbuf;
    struct fs_dirent entry;

    // Get current file size before writing
    rc = fs_stat(fname, &entry);
    if (rc == 0) {
        current_file_size = entry.size;  // Update with actual file size
    } else if (rc != -ENOENT) {
        LOG_ERR("Failed to stat file %s: %d", fname, rc);
        return rc;
    }

    // Check total usage limit FIRST
    if (total_bytes_written > MAX_TOTAL_USAGE_BYTES) {
        LOG_ERR("Total usage limit reached (%u MB) - stopping all writes", MAX_TOTAL_USAGE_MB);
        return -ENOSPC;
    }

    // Check file size limit BEFORE writing
    if (current_file_size + DATA_BLOCK_SIZE > MAX_FILE_SIZE_BYTES) {
        LOG_WRN("File size limit reached (%u MB) - need new file", MAX_FILE_SIZE_MB);
        return -EFBIG;
    }

    // Rest of function remains the same...
    fs_file_t_init(&file);
    
    rc = fs_open(&file, fname, FS_O_CREATE | FS_O_APPEND | FS_O_WRITE);
    if (rc < 0) {
        LOG_ERR("FAIL: open %s: %d", fname, rc);
        return rc;
    }

    generate_data_pattern(data_buffer, write_counter);

    rc = fs_write(&file, data_buffer, DATA_BLOCK_SIZE);
    if (rc < 0) {
        LOG_ERR("FAIL: write %s: %d", fname, rc);
        goto out;
    }

    if (rc != DATA_BLOCK_SIZE) {
        LOG_WRN("Partial write: expected %d, wrote %d bytes", DATA_BLOCK_SIZE, rc);
    }

    total_bytes_written += rc;
    current_file_size += rc;
    
    // Improved logging with better formatting
    LOG_PRINTK("Write #%u: %d bytes (File: %u KB, Total: %u KB = %.2f MB)\n", 
               write_counter, rc, current_file_size / 1024, 
               total_bytes_written / 1024, (float)total_bytes_written / (1024.0 * 1024.0));

out:
    ret = fs_close(&file);
    if (ret < 0) {
        LOG_ERR("FAIL: close %s: %d", fname, ret);
        return ret;
    }

    return (rc < 0 ? rc : 0);
}

// static int write_406_bytes_continuous(char *fname, struct fs_mount_t *mp)
// {
// 	struct fs_file_t file;
// 	int rc, ret;
// 	struct fs_statvfs sbuf;

// 	// Check total usage limit FIRST
// 	if (total_bytes_written > MAX_TOTAL_USAGE_BYTES) {
// 		LOG_ERR("Total usage limit reached (%u MB) - stopping all writes", MAX_TOTAL_USAGE_MB);
// 		return -ENOSPC;
// 	}

// 	// Check file size limit BEFORE writing
// 	if (current_file_size + DATA_BLOCK_SIZE > MAX_FILE_SIZE_BYTES) {
// 		LOG_WRN("File size limit reached (%u MB) - need new file", MAX_FILE_SIZE_MB);
// 		return -EFBIG;  // File too big error
// 	}

// 	// Check available space before writing
// 	rc = fs_statvfs(mp->mnt_point, &sbuf);
// 	if (rc == 0) {
// 		uint32_t used_kb = ((sbuf.f_blocks - sbuf.f_bfree) * sbuf.f_frsize) / 1024;
// 		if (used_kb > (MAX_TOTAL_USAGE_MB * 1024)) {
// 			LOG_ERR("Usage limit exceeded: %u KB used (max %u KB)", 
// 			        used_kb, MAX_TOTAL_USAGE_MB * 1024);
// 			return -ENOSPC;
// 		}
// 	}

// 	fs_file_t_init(&file);
	
// 	// Open file in append mode to continuously add data
// 	rc = fs_open(&file, fname, FS_O_CREATE | FS_O_APPEND | FS_O_WRITE);
// 	if (rc < 0)
// 	{
// 		LOG_ERR("FAIL: open %s: %d", fname, rc);
// 		return rc;
// 	}

// 	// Generate the 406-byte data pattern
// 	generate_data_pattern(data_buffer, write_counter);

// 	// Write exactly 406 bytes
// 	rc = fs_write(&file, data_buffer, DATA_BLOCK_SIZE);
// 	if (rc < 0)
// 	{
// 		LOG_ERR("FAIL: write %s: %d", fname, rc);
// 		goto out;
// 	}

// 	if (rc != DATA_BLOCK_SIZE) {
// 		LOG_WRN("Partial write: expected %d, wrote %d bytes", DATA_BLOCK_SIZE, rc);
// 	}

// 	total_bytes_written += rc;
// 	current_file_size += rc;
	
// 	LOG_PRINTK("Write #%u: %d bytes (File: %u KB, Total: %u MB)\n", 
// 		   write_counter, rc, current_file_size / 1024, 
// 		   total_bytes_written / (1024 * 1024));

// out:
// 	ret = fs_close(&file);
// 	if (ret < 0)
// 	{
// 		LOG_ERR("FAIL: close %s: %d", fname, ret);
// 		return ret;
// 	}

// 	return (rc < 0 ? rc : 0);
// }

static int lsdir(const char *path)
{
	int res;
	struct fs_dir_t dirp;
	static struct fs_dirent entry;

	fs_dir_t_init(&dirp);

	res = fs_opendir(&dirp, path);
	if (res)
	{
		LOG_ERR("Error opening dir %s [%d]\n", path, res);
		return res;
	}

	LOG_PRINTK("\nListing dir %s ...\n", path);
	for (;;)
	{
		res = fs_readdir(&dirp, &entry);

		if (res || entry.name[0] == 0)
		{
			if (res < 0)
			{
				LOG_ERR("Error reading dir [%d]\n", res);
			}
			break;
		}

		if (entry.type == FS_DIR_ENTRY_DIR)
		{
			LOG_PRINTK("[DIR ] %s\n", entry.name);
		}
		else
		{
			LOG_PRINTK("[FILE] %s (size = %zu)\n",
					   entry.name, entry.size);
		}
	}

	fs_closedir(&dirp);
	return res;
}

#ifdef CONFIG_APP_LITTLEFS_STORAGE_FLASH
static int littlefs_flash_erase(unsigned int id)
{
    const struct flash_area *pfa;
    int rc;

    rc = flash_area_open(id, &pfa);
    if (rc < 0) {
        LOG_ERR("FAIL: unable to find flash area %u: %d\n", id, rc);
        return rc;
    }

    LOG_PRINTK("=== FLASH AREA INFO ===\n");
    LOG_PRINTK("Area ID: %u\n", id);
    LOG_PRINTK("Offset: 0x%x\n", (unsigned int)pfa->fa_off);
    LOG_PRINTK("Size: %u bytes (%u KB)\n", 
               (unsigned int)pfa->fa_size, (unsigned int)pfa->fa_size / 1024);
    LOG_PRINTK("Device: %s\n", pfa->fa_dev->name);
    
    if (strstr(pfa->fa_dev->name, "w25q") != NULL ||
        strstr(pfa->fa_dev->name, "qspi") != NULL) {
        LOG_PRINTK("✓ Using EXTERNAL QSPI flash\n");
    } else {
        LOG_PRINTK("⚠ Using INTERNAL flash\n");
    }
    LOG_PRINTK("=====================\n");

    if (IS_ENABLED(CONFIG_APP_WIPE_STORAGE)) {
        rc = flash_area_flatten(pfa, 0, pfa->fa_size);
        LOG_PRINTK("Erasing flash area ... %d\n", rc);
    }
	LOG_PRINTK("flash area flatten ... \n");
    flash_area_close(pfa);
    return rc;
}

#define PARTITION_NODE DT_NODELABEL(lfs1)

#if DT_NODE_EXISTS(PARTITION_NODE)
FS_FSTAB_DECLARE_ENTRY(PARTITION_NODE);	
#else
FS_LITTLEFS_DECLARE_DEFAULT_CONFIG(storage);
static struct fs_mount_t lfs_storage_mnt = {
	.type = FS_LITTLEFS,
	.fs_data = &storage,
	.storage_dev = (void *)PM_LITTLEFS_STORAGE_ID,
	.mnt_point = "/lfs",
};
#endif

struct fs_mount_t *mountpoint =
#if DT_NODE_EXISTS(PARTITION_NODE)
	&FS_FSTAB_ENTRY(PARTITION_NODE)
#else
	&lfs_storage_mnt
#endif
	;

static int littlefs_mount(struct fs_mount_t *mp)
{
	int rc;

	rc = littlefs_flash_erase((uintptr_t)mp->storage_dev);
	if (rc < 0)
	{
		return rc;
	}
    
    LOG_PRINTK("storage device ID to: %u\n", (unsigned int)(uintptr_t)mp->storage_dev);

#if !DT_NODE_EXISTS(PARTITION_NODE) || \
	!(FSTAB_ENTRY_DT_MOUNT_FLAGS(PARTITION_NODE) & FS_MOUNT_FLAG_AUTOMOUNT)
	rc = fs_mount(mp);
	if (rc < 0)
	{
		LOG_PRINTK("FAIL: mount id %" PRIuPTR " at %s: %d\n",
				   (uintptr_t)mp->storage_dev, mp->mnt_point, rc);
		return rc;
	}
	LOG_PRINTK("manual mounted\n" );
	LOG_PRINTK("%s mount: %d\n", mp->mnt_point, rc);
#else
	LOG_PRINTK("%s automounted\n", mp->mnt_point);
#endif

	return 0;
}
#endif

static void print_flash_info(void)
{
    const struct device *flash_dev;
    const struct device *qspi_dev;

    flash_dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_flash_controller));
    if (device_is_ready(flash_dev)) {
        LOG_PRINTK("Flash controller: %s\n", flash_dev->name);
        LOG_PRINTK("Flash device ready: %s\n", device_is_ready(flash_dev) ? "YES" : "NO");
    }

    qspi_dev = DEVICE_DT_GET(DT_NODELABEL(w25q256));
    if (device_is_ready(qspi_dev)) {
        LOG_PRINTK("QSPI device: %s\n", qspi_dev->name);
        LOG_PRINTK("QSPI device ready: %s\n", device_is_ready(qspi_dev) ? "YES" : "NO");
    }

    if (strstr(flash_dev->name, "w25q") != NULL ||
        strstr(flash_dev->name, "qspi") != NULL) {
        LOG_PRINTK("✓ Using external QSPI flash\n");
    } else {
        LOG_PRINTK("Using internal flash\n");
    }
}

static void print_filesystem_stats(void)
{
    struct fs_statvfs sbuf;
    int rc;

    rc = fs_statvfs(mountpoint->mnt_point, &sbuf);
    if (rc < 0) {
        LOG_ERR("FAIL: statvfs: %d\n", rc);
        return;
    }

    uint32_t total_kb = (sbuf.f_blocks * sbuf.f_frsize) / 1024;
    uint32_t free_kb = (sbuf.f_bfree * sbuf.f_frsize) / 1024;
    uint32_t used_kb = total_kb - free_kb;

    LOG_PRINTK("=== FILESYSTEM STATS ===\n");
    LOG_PRINTK("Total: %u KB, Used: %u KB, Free: %u KB\n", 
               total_kb, used_kb, free_kb);
    LOG_PRINTK("Data written: %u KB (%u MB)\n",
               total_bytes_written / 1024, total_bytes_written / (1024 * 1024));
    LOG_PRINTK("========================\n");
}



int main(void)
{
	char fname_data[MAX_PATH_LEN];
	int rc;
	uint32_t file_number = 1;

	LOG_PRINTK("=== 406 Byte Continuous Write Demo ===\n");
	LOG_PRINTK("Writing %d bytes to external flash every %d ms\n", 
	           DATA_BLOCK_SIZE, WRITE_INTERVAL_MS);
	LOG_PRINTK("Max file size: %d MB, Max total usage: %d MB\n", 
	           MAX_FILE_SIZE_MB, MAX_TOTAL_USAGE_MB);
	LOG_PRINTK("Using mount point: %s\n", mountpoint->mnt_point);
	LOG_PRINTK("Storage device ID: %u\n", (unsigned int)(uintptr_t)mountpoint->storage_dev);
	
	print_flash_info();
	
	rc = littlefs_mount(mountpoint);
	if (rc < 0)
	{
		LOG_ERR("Failed to mount LittleFS: %d\n", rc);
		return 0;
	}

	// Setup initial file name
	snprintf(fname_data, sizeof(fname_data), "%s/data406_%03u.bin", 
	         mountpoint->mnt_point, file_number);

	// Delete existing files to start fresh
	LOG_PRINTK("Cleaning up old files...\n");
	for (int i = 1; i <= 10; i++) {
		char temp_fname[MAX_PATH_LEN];
		snprintf(temp_fname, sizeof(temp_fname), "%s/data406_%03u.bin", 
		         mountpoint->mnt_point, i);
		// fs_unlink(temp_fname);  // Remove old files (ignore errors)
	}

	// Initial file system status
	print_filesystem_stats();
	lsdir(mountpoint->mnt_point);

	LOG_PRINTK("\n=== Starting continuous 406-byte write loop ===\n");
	LOG_PRINTK("Current file: %s\n", fname_data);

	// Continuous write loop
	while (1) {
		write_counter++;
		
		LOG_PRINTK("\n--- Write cycle #%u ---\n", write_counter);

		// Write exactly 406 bytes to data file
		rc = write_406_bytes_continuous(fname_data, mountpoint);
		
		if (rc == -EFBIG) {
			// File size limit reached - create new file
			file_number++;
			snprintf(fname_data, sizeof(fname_data), "%s/data406_%03u.bin", 
			         mountpoint->mnt_point, file_number);
			current_file_size = 0;  // Reset file size counter
			LOG_PRINTK("Rotating to new file: %s\n", fname_data);
			
			// Try writing to new file
			rc = write_406_bytes_continuous(fname_data, mountpoint);
		}
		
		if (rc == -ENOSPC) {
			LOG_ERR("Storage space exhausted - stopping writes");
			break;
		}
		
		if (rc < 0) {
			LOG_ERR("Failed to write 406 bytes: %d\n", rc);
			// Continue trying instead of stopping
		}

		// Print filesystem stats every 100 writes
		if (write_counter % 100 == 0) {
			print_filesystem_stats();
			lsdir(mountpoint->mnt_point);
		}

		// Calculate and show data rate every 10 writes
		if (write_counter % 10 == 0) {
			uint64_t uptime_ms = k_uptime_get();
			if (uptime_ms > 0) {
				uint32_t bytes_per_sec = (total_bytes_written * 1000ULL) / uptime_ms;
				LOG_PRINTK("Data rate: %u bytes/sec (%u KB/sec)\n", 
				           bytes_per_sec, bytes_per_sec / 1024);
			}
		}

		// Wait for next write cycle
		k_msleep(WRITE_INTERVAL_MS);
	}

	LOG_PRINTK("Write loop terminated\n");
	return 0;
}

#
# Copyright (c) 2019 Peter Bigot Consulting, LLC
#
# SPDX-License-Identifier: Apache-2.0
#

# Optionally force the file system to be recreated
# CONFIG_APP_WIPE_STORAGE=y

# fs_dirent structures are big.
CONFIG_MAIN_STACK_SIZE=4096

# Let __ASSERT do its job
CONFIG_DEBUG=y

CONFIG_LOG=y
CONFIG_LOG_MODE_MINIMAL=y

CONFIG_FLASH=y
CONFIG_FLASH_MAP=y

CONFIG_FILE_SYSTEM=y
CONFIG_FILE_SYSTEM_LITTLEFS=y
CONFIG_NORDIC_QSPI_NOR=y

CONFIG_NORDIC_QSPI_NOR_FLASH_LAYOUT_PAGE_SIZE=65536
CONFIG_NORDIC_QSPI_NOR_STACK_WRITE_BUFFER_SIZE=16
CONFIG_APP_LITTLEFS_STORAGE_FLASH=y



CONFIG_LOG_DEFAULT_LEVEL=3
CONFIG_UART_CONSOLE=n
CONFIG_USE_SEGGER_RTT=y
CONFIG_LOG=y
CONFIG_RTT_CONSOLE=y
CONFIG_APP_WIPE_STORAGE=n

CONFIG_PARTITION_MANAGER_ENABLED=y
# CONFIG_PM_OVERRIDE_EXTERNAL_DRIVER_CHECK=y

/ {
aliases {
qspi-flash0 = &w25q256;
};

chosen {
// zephyr,flash-controller = &w25q256;
// zephyr,flash = &w25q256;
nordic,pm-ext-flash = &w25q256;

};

// fstab {
// compatible = "zephyr,fstab";
// lfs1: lfs1 {
// compatible = "zephyr,fstab,littlefs";
// mount-point = "/lfs";
// partition = <&lfs1_part>;
// // automount;
// read-size = <16>;
// prog-size = <16>;
// cache-size = <64>;
// lookahead-size = <32>;
// block-cycles = <512>;
// };
// };
};


/delete-node/ &storage_partition;
/delete-node/ &mx25r64;

&qspi {
status = "okay";
pinctrl-0 = <&qspi_custom>;
pinctrl-1 = <&qspi_sleep_custom>;
pinctrl-names = "default", "sleep";

w25q256: w25q256ve@0 {
compatible = "nordic,qspi-nor";
reg = <0>;
size = <DT_SIZE_M(32)>;
sck-frequency = <32000000>;
writeoc = "pp4o";
readoc = "read4io";

jedec-id = [ ef 40 19 ];
has-dpd;
t-enter-dpd = <3000>;
t-exit-dpd = <30000>;
// address-size-32;
// partitions {
// compatible = "fixed-partitions";
// #address-cells = <1>;
// #size-cells = <1>;

// /* LittleFS partition (0-4MB) - CHANGED: Larger partition */
// lfs1_part: partition@0 {
// label = "littlefs_storage";
// reg = <0x00000000 DT_SIZE_M(4)>;
// };

// /* Test area (4MB-8MB) */
// test_partition: partition@400000 {
// label = "test_area";
// reg = <0x00400000 DT_SIZE_M(4)>;
// };

// external_storage_partition: partition@800000 {
// label = "external_storage";
// reg = <0x00800000 DT_SIZE_M(24)>;
// };
// };
};
};

&pinctrl {
qspi_custom: qspi_custom {
group1 {
psels = <NRF_PSEL(QSPI_SCK, 0, 19)>,
<NRF_PSEL(QSPI_IO0, 0, 14)>,
<NRF_PSEL(QSPI_IO1, 0, 23)>,
<NRF_PSEL(QSPI_IO2, 0, 11)>,
<NRF_PSEL(QSPI_IO3, 1, 0)>,
<NRF_PSEL(QSPI_CSN, 0, 16)>;
nordic,drive-mode = <NRF_DRIVE_H0H1>;
};
};

qspi_sleep_custom: qspi_sleep_custom {
group1 {
psels = <NRF_PSEL(QSPI_SCK, 0, 19)>,
<NRF_PSEL(QSPI_IO0, 0, 14)>,
<NRF_PSEL(QSPI_IO1, 0, 23)>,
<NRF_PSEL(QSPI_IO2, 0, 11)>,
<NRF_PSEL(QSPI_IO3, 1, 0)>,
<NRF_PSEL(QSPI_CSN, 0, 16)>;
low-power-enable;
};
};
};

pm_static.yml

littlefs_storage:
address: 0x0
size: 0x00400000
device: w25q256ve@0
region: external_flash

if i changed 4mb size to 8mb size in pm_static.yml ,it through error, if i gave 4mbit doesnt through any error it write in flash


00> *** Booting nRF Connect SDK v2.9.0-7787b2649840 ***
00> *** Using Zephyr OS v3.7.99-1f8f3dc29142 ***
00> === 406 Byte Continuous Write Demo ===
00> Writing 406 bytes to external flash every 1000 ms
00> Max file size: 10 MB, Max total usage: 25 MB
00> Using mount point: /lfs
00> Storage device ID: 1
00> Flash controller: flash-controller@4001e000
00> Flash device ready: YES
00> QSPI device: w25q256ve@0
00> QSPI device ready: YES
00> Using internal flash
00> === FLASH AREA INFO ===
00> Area ID: 1
00> Offset: 0x0
00> Size: 8388608 bytes (8192 KB)
00> Device: w25q256ve@0
00> â Using EXTERNAL QSPI flash
00> =====================
00> flash area flatten ...
00> storage device ID to: 1
00> I: LittleFS version 2.9, disk version 2.1
00> I: FS at w25q256ve@0:0x0 is 128 0x10000-byte blocks with 512 cycle
00> I: sizes: rd 16 ; pr 16 ; ca 64 ; la 32
00> E: WEST_TOPDIR/modules/fs/littlefs/lfs.c:4531: Invalid block count (64 != 128)
00> W: can't mount (LFS -22); formatting
00> I: /lfs mounted
00> manual mounted
00> /lfs mount: 0
00> Cleaning up old files...
00> === FILESYSTEM STATS ===
00> Total: 8192 KB, Used: 128 KB, Free: 8064 KB
00> Data writ
00> --- Write cycle #5 ---
00> E: erase error: address or size exceeds expected values.Addr: 0x480000 size 65536
00> E: file write error (-22)
00> E: FAIL: write /lfs/data406_001.bin: -22
00> E: Failed to write 406 bytes: -22
00>
00>
00> --- Write cycle #6 ---
00> E: erase error: address or size exceeds expected values.Addr: 0x490000 size 65536
00> E: file write error (-22)
00> E: FAIL: write /lfs/data406_001.bin: -22
00> E: Failed to write 406 bytes: -22
00>
00>
00> --- Write cycle #7 ---
00> E: erase error: address or size exceeds expected values.Addr: 0x4a0000 size 65536
00> E: file write error (-22)
00> E: FAIL: write /lfs/data406_001.bin: -22
00> E: Failed to write 406 bytes: -22
00>
00>
00> --- Write cycle #8 ---
00> E: erase error: address or size exceeds expected values.Addr: 0x4b0000 size 65536
00> E: file write error (-22)
00> E: FAIL: write /lfs/data406_001.bin: -22
00> E: Failed to write 406 bytes: -22
00>
(Connection lost)

RE: littlefs not mount to external flash winbond w25q256

AHaug — Tue, 26 Aug 2025 12:46:32 GMT

Hello,

Thank you for attaching this. For future references, please use the insert -> code functionality to make it easier to review the contents of your reply (such as I've edited your reply to show):

Is this the sample you've based your application on?

There should be a sample that you can use directly for the nrf52840dk with the qspi external flash overlay set up https://github.com/zephyrproject-rtos/zephyr/blob/main/samples/subsys/fs/fs_sample/boards/nrf52840dk_nrf52840_qspi.overlay which should work out of the box if you add a pm_static.yml as well as modify the overlay to use your winbound external flash instead of the mx25

Kind regards,
Andreas

RE: littlefs not mount to external flash winbond w25q256

pushparaj — Thu, 21 Aug 2025 11:22:10 GMT

i have created pm_static.yml file in that i have configure external memory

external_flash:
address: 0x0
size: 0x2000000 # 32MB
device: w25q256ve@0
region: external_flash

littlefs_storage:
address: 0x0
size: 0x2000000 # 32MB for LittleFS
device: w25q256ve@0
region: external_flash

I have changed my overlay file like removing partition and fstab .

/ {
aliases 
qspi-flash0 = &w25q256;
};

chosen {
zephyr,flash-controller = &w25q256;
// zephyr,flash = &w25q256;
nordic,pm-ext-flash = &w25q256;

};

// fstab {
// compatible = "zephyr,fstab";
// lfs1: lfs1 {
// compatible = "zephyr,fstab,littlefs";
// mount-point = "/lfs";
// partition = <&lfs1_part>;
// // automount;
// read-size = <16>;
// prog-size = <16>;
// cache-size = <64>;
// lookahead-size = <32>;
// block-cycles = <512>;
// };
// };
};


/delete-node/ &storage_partition;
/delete-node/ &mx25r64;

&qspi {
status = "okay";
pinctrl-0 = <&qspi_custom>;
pinctrl-1 = <&qspi_sleep_custom>;
pinctrl-names = "default", "sleep";

w25q256: w25q256ve@0 {
compatible = "nordic,qspi-nor";
reg = <0>;
size = <DT_SIZE_M(32)>;
sck-frequency = <8000000>;
writeoc = "pp4o";
readoc = "read4io";

jedec-id = [ ef 40 19 ];
has-dpd;
t-enter-dpd = <3000>;
t-exit-dpd = <30000>;

// partitions {
// compatible = "fixed-partitions";
// #address-cells = <1>;
// #size-cells = <1>;

// /* LittleFS partition (0-4MB) - CHANGED: Larger partition */
// lfs1_part: partition@0 {
// label = "littlefs_storage";
// reg = <0x00000000 DT_SIZE_M(4)>;
// };

// /* Test area (4MB-8MB) */
// test_partition: partition@400000 {
// label = "test_area";
// reg = <0x00400000 DT_SIZE_M(4)>;
// };

// external_storage_partition: partition@800000 {
// label = "external_storage";
// reg = <0x00800000 DT_SIZE_M(24)>;
// };
// };
};
};

&pinctrl {
qspi_custom: qspi_custom {
group1 {
psels = <NRF_PSEL(QSPI_SCK, 0, 19)>,
<NRF_PSEL(QSPI_IO0, 0, 14)>,
<NRF_PSEL(QSPI_IO1, 0, 23)>,
<NRF_PSEL(QSPI_IO2, 0, 11)>,
<NRF_PSEL(QSPI_IO3, 1, 0)>,
<NRF_PSEL(QSPI_CSN, 0, 16)>;
nordic,drive-mode = <NRF_DRIVE_H0H1>;
};
};

qspi_sleep_custom: qspi_sleep_custom {
group1 {
psels = <NRF_PSEL(QSPI_SCK, 0, 19)>,
<NRF_PSEL(QSPI_IO0, 0, 14)>,
<NRF_PSEL(QSPI_IO1, 0, 23)>,
<NRF_PSEL(QSPI_IO2, 0, 11)>,
<NRF_PSEL(QSPI_IO3, 1, 0)>,
<NRF_PSEL(QSPI_CSN, 0, 16)>;
low-power-enable;
};
};
};

changed this line .storage_dev = (void *)PM_LITTLEFS_STORAGE_ID,

#define PARTITION_NODE DT_NODELABEL(lfs1)

#if DT_NODE_EXISTS(PARTITION_NODE)
FS_FSTAB_DECLARE_ENTRY(PARTITION_NODE);
#else
FS_LITTLEFS_DECLARE_DEFAULT_CONFIG(storage);
static struct fs_mount_t lfs_storage_mnt = {
.type = FS_LITTLEFS,
.fs_data = &storage,
.storage_dev = (void *)PM_LITTLEFS_STORAGE_ID,
.mnt_point = "/lfs",
};
#endif

i can see that external flash is visible in flash area.
and this is the output in this write operation get failed

*** Booting nRF Connect SDK v2.9.0-7787b2649840 ***
*** Using Zephyr OS v3.7.99-1f8f3dc29142 ***
=== 406 Byte Continuous Write Demo ===
Writing 406 bytes to external flash every 1000 ms
Using mount point: /lfs
Storage device ID: 2
Flash controller: w25q256ve@0
Flash device ready: YES
QSPI device: w25q256ve@0
QSPI device ready: YES
â Using external QSPI flash
=== FLASH AREA INFO ===
Area ID: 2
Offset: 0x0
Size: 33554432 bytes (32768 KB)
Device: w25q256ve@0
â Using EXTERNAL QSPI flash
=====================
storage device ID to: 2
I: LittleFS version 2.9, disk version 2.1
I: FS at w25q256ve@0:0x0 is 512 0x10000-byte blocks with 512 cycle
I: sizes: rd 16 ; pr 16 ; ca 64 ; la 32
manual mounted
/lfs mount: 0
Deleting existing data file to start fresh...
=== FILESYSTEM STATS ===
Total: 32768 KB, Used: 128 KB, Free: 32640 KB
Data written: 0 bytes (0 KB)
========================

Listing dir /lfs ...
[FILE] data406_001.bin (size = 0)

=== Starting continuous 406-byte write loop ===

--- Write cycle #1 ---
E: eras
--- Write cycle #4 ---
E: erase error: address or size exceeds expected values.Addr: 0x1000000 size 65536
E: file write error (-22)
E: FAIL: write /lfs/data406.bin: -22
E: Failed to write 406 bytes: -22


--- Write cycle #5 ---
E: erase error: address or size exceeds expected values.Addr: 0x1010000 size 65536
E: file write error (-22)
E: FAIL: write /lfs/data406.bin: -22
E: Failed to write 406 bytes: -22

RE: littlefs not mount to external flash winbond w25q256

pushparaj — Wed, 20 Aug 2025 05:20:46 GMT

this is the output

Area 1 at 0xfa000 on flash-controller@4001e000 for 24576 bytes showing only internal 24 bytes