Portenta H7: Setting up LittleFS to work on QSPI

[mjs513]

@KurtE - @facchinm - @pillo79

Been experimenting with using LittleFS in conjunction with QSPI and not having much luck. Reason for using LittleFS and not FS is that LittleFS addresses wear leveling.

Using the sample LittleFS: https://github.com/zephyrproject-rtos/zephyr/tree/main/samples/subsys/fs/littlefs but keep getting an error message

\Giga_zephyr\h7_littlefs\h7_littlefs.ino:17:
C:\Users\Merli\AppData\Local\Arduino15\packages\arduino\hardware\zephyr\0.2.0\variants\arduino_portenta_h7/llext-edk/include/zephyr/include/zephyr/fs/littlefs.h:14:10: fatal error: lfs.h: No such file or directory
   14 | #include <lfs.h>
      |          ^~~~~~~
compilation terminated.
exit status 1

Now in the config file for the H7 I have:

CONFIG_FLASH=y
CONFIG_FLASH_MAP=y

CONFIG_FILE_SYSTEM=y
CONFIG_FILE_SYSTEM_LITTLEFS=y
CONFIG_FS_LITTLEFS_FC_HEAP_SIZE=2048

CONFIG_FLASH=y
CONFIG_FLASH_MAP=y

CONFIG_FILE_SYSTEM=y
CONFIG_FILE_SYSTEM_LITTLEFS=y
CONFIG_FS_LITTLEFS_FC_HEAP_SIZE=2048
CONFIG_FS_LITTLEFS_FMP_DEV=y

Note am using CONFIG_FS_LITTLEFS_FMP_DEV=y since we are using flash:

config FS_LITTLEFS_FMP_DEV
	bool "Support for littlefs on flash devices"
	depends on FLASH_MAP
	depends on FLASH_PAGE_LAYOUT || !FLASH_HAS_EXPLICIT_ERASE
	default y
	help
	  Enable this option to provide support for littlefs on flash devices
	  (using the flash_map API).

config FS_LITTLEFS_BLK_DEV
	bool "Support for littlefs on block devices"
	help
	  Enable this option to provide support for littlefs on the block
	  devices (like for example SD card).

No changes made to overlay yet - just trying to get past not finding lfs.h. In the H7 includes file added:

-iwithprefixbefore/llext-edk/include/modules/fs/littlefs
-iwithprefixbefore/llext-edk/include/zephyr/subsys/fs/
-iwithprefixbefore/llext-edk/include/zephyr/modules/fs/littlefs

I did find that lfs.h is located in modules directory which is at the same level as zephyr sdk and arduino cores. Same directory as arduinoAPI.

Any suggestions to get this working or will littleFS not be supported.

EDIT: digging deeper it looks may have to modify the build flags in h7 variant? the includes.txt file is insufficient?

[mjs513]

just to test qspi storage partition ran the following sketch:

#include <Arduino.h>

/*
 * Copyright (c) 2016 Intel Corporation.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
/* references:
https://docs.zephyrproject.org/apidoc/latest/group__flash__interface.html
https://github.com/zephyrproject-rtos/zephyr/tree/main/samples/drivers/spi_flash

*/

#include <zephyr/kernel.h>
#include <zephyr/drivers/flash.h>
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <stdio.h>
#include <string.h>

#define SPI_FLASH_SECTOR_SIZE        4096
#define DT_SIZE_K(x) ((x) * 1024)
#define SPI_FLASH_TEST_REGION_OFFSET \
	DT_REG_SIZE(DT_NODE_BY_FIXED_PARTITION_LABEL(storage))

#if defined(CONFIG_FLASH_STM32_OSPI) || defined(CONFIG_FLASH_STM32_QSPI) || defined(CONFIG_FLASH_STM32_XSPI)
#define SPI_FLASH_MULTI_SECTOR_TEST
#endif

#define SPI_FLASH_COMPAT st_stm32_qspi_nor

const uint8_t erased[] = { 0xff, 0xff, 0xff, 0xff };

void single_sector_test(const struct device *flash_dev)
{
	const uint8_t expected[] = { 0x66, 0x66, 0x20, 0x99 };
	const size_t len = sizeof(expected);
	uint8_t buf[sizeof(expected)];
	int rc;

	printf("\nPerform test on single sector");
	/* Write protection needs to be disabled before each write or
	 * erase, since the flash component turns on write protection
	 * automatically after completion of write and erase
	 * operations.
	 */
	printf("\nTest 1: Flash erase\n");

	/* Full flash erase if SPI_FLASH_TEST_REGION_OFFSET = 0 and
	 * SPI_FLASH_SECTOR_SIZE = flash size
	 */
	rc = flash_erase(flash_dev, SPI_FLASH_TEST_REGION_OFFSET,
			 SPI_FLASH_SECTOR_SIZE);
	if (rc != 0) {
		printf("Flash erase failed! %d\n", rc);
	} else {
		/* Check erased pattern */
		memset(buf, 0, len);
		rc = flash_read(flash_dev, SPI_FLASH_TEST_REGION_OFFSET, buf, len);
		if (rc != 0) {
			printf("Flash read failed! %d\n", rc);
			return;
		}
		if (memcmp(erased, buf, len) != 0) {
			printf("Flash erase failed at offset 0x%x got 0x%x\n",
				SPI_FLASH_TEST_REGION_OFFSET, *(uint32_t *)buf);
			return;
		}
		printf("Flash erase succeeded!\n");
	}
	printf("\nTest 2: Flash write\n");

	printf("Attempting to write %zu bytes\n", len);
	rc = flash_write(flash_dev, SPI_FLASH_TEST_REGION_OFFSET, expected, len);
	if (rc != 0) {
		printf("Flash write failed! %d\n", rc);
		return;
	}

	memset(buf, 0, len);
	rc = flash_read(flash_dev, SPI_FLASH_TEST_REGION_OFFSET, buf, len);
	if (rc != 0) {
		printf("Flash read failed! %d\n", rc);
		return;
	}

	if (memcmp(expected, buf, len) == 0) {
		printf("Data read matches data written. Good!!\n");
	} else {
		const uint8_t *wp = expected;
		const uint8_t *rp = buf;
		const uint8_t *rpe = rp + len;

		printf("Data read does not match data written!!\n");
		while (rp < rpe) {
			printf("%08x wrote %02x read %02x %s\n",
			       (uint32_t)(SPI_FLASH_TEST_REGION_OFFSET + (rp - buf)),
			       *wp, *rp, (*rp == *wp) ? "match" : "MISMATCH");
			++rp;
			++wp;
		}
	}
}

#if defined SPI_FLASH_MULTI_SECTOR_TEST
void multi_sector_test(const struct device *flash_dev)
{
	const uint8_t expected[] = { 0x55, 0xaa, 0x66, 0x99 };
	const size_t len = sizeof(expected);
	uint8_t buf[sizeof(expected)];
	int rc;

	printf("\nPerform test on multiple consecutive sectors");

	/* Write protection needs to be disabled before each write or
	 * erase, since the flash component turns on write protection
	 * automatically after completion of write and erase
	 * operations.
	 */
	printf("\nTest 1: Flash erase\n");

	/* Full flash erase if SPI_FLASH_TEST_REGION_OFFSET = 0 and
	 * SPI_FLASH_SECTOR_SIZE = flash size
	 * Erase 2 sectors for check for erase of consequtive sectors
	 */
	rc = flash_erase(flash_dev, SPI_FLASH_TEST_REGION_OFFSET, SPI_FLASH_SECTOR_SIZE * 2);
	if (rc != 0) {
		printf("Flash erase failed! %d\n", rc);
	} else {
		/* Read the content and check for erased */
		memset(buf, 0, len);
		size_t offs = SPI_FLASH_TEST_REGION_OFFSET;

		while (offs < SPI_FLASH_TEST_REGION_OFFSET + 2 * SPI_FLASH_SECTOR_SIZE) {
			rc = flash_read(flash_dev, offs, buf, len);
			if (rc != 0) {
				printf("Flash read failed! %d\n", rc);
				return;
			}
			if (memcmp(erased, buf, len) != 0) {
				printf("Flash erase failed at offset 0x%x got 0x%x\n",
				offs, *(uint32_t *)buf);
				return;
			}
			offs += SPI_FLASH_SECTOR_SIZE;
		}
		printf("Flash erase succeeded!\n");
	}

	printf("\nTest 2: Flash write\n");

	size_t offs = SPI_FLASH_TEST_REGION_OFFSET;

	while (offs < SPI_FLASH_TEST_REGION_OFFSET + 2 * SPI_FLASH_SECTOR_SIZE) {
		printf("Attempting to write %zu bytes at offset 0x%x\n", len, offs);
		rc = flash_write(flash_dev, offs, expected, len);
		if (rc != 0) {
			printf("Flash write failed! %d\n", rc);
			return;
		}

		memset(buf, 0, len);
		rc = flash_read(flash_dev, offs, buf, len);
		if (rc != 0) {
			printf("Flash read failed! %d\n", rc);
			return;
		}

		if (memcmp(expected, buf, len) == 0) {
			printf("Data read matches data written. Good!!\n");
		} else {
			const uint8_t *wp = expected;
			const uint8_t *rp = buf;
			const uint8_t *rpe = rp + len;

			printf("Data read does not match data written!!\n");
			while (rp < rpe) {
				printf("%08x wrote %02x read %02x %s\n",
					(uint32_t)(offs + (rp - buf)),
					*wp, *rp, (*rp == *wp) ? "match" : "MISMATCH");
				++rp;
				++wp;
			}
		}
		offs += SPI_FLASH_SECTOR_SIZE;
	}
}
#endif

void setup() {
  while(!Serial && millis()<5000){}
  Serial.begin(9600);

	const struct device *flash_dev = DEVICE_DT_GET_ONE(SPI_FLASH_COMPAT);

	if (!device_is_ready(flash_dev)) {
		printk("%s: device not ready.\n", flash_dev->name);
		while(1){}
	}

	printf("\n%s SPI flash testing\n", flash_dev->name);
	printf("==========================\n");
  printf("Device Info:\n");

  uint64_t size = 0;
  flash_get_size(flash_dev, &size);
  printf("Flash Size: %lld\n", 	size);
  printf("Expected: %d\n\n", DT_SIZE_K(15872));

	single_sector_test(flash_dev);
#if defined SPI_FLASH_MULTI_SECTOR_TEST
	multi_sector_test(flash_dev);
#endif
}

void loop() {
  // put your main code here, to run repeatedly:

}

It succeeded in running successfully

qspi-nor-flash@90000000 SPI flash testing
==========================
Device Info:
Flash Size: 16777216
Expected: 16252928


Perform test on single sector
Test 1: Flash erase
Flash erase succeeded!

Test 2: Flash write
Attempting to write 4 bytes
Data read matches data written. Good!!

Perform test on multiple consecutive sectors
Test 1: Flash erase
Flash erase succeeded!

Test 2: Flash write
Attempting to write 4 bytes at offset 0xf80000
Data read matches data written. Good!!
Attempting to write 4 bytes at offset 0xf81000
Data read matches data written. Good!!