nRF52840 Zephyr dual QSPI MX25R64 flash example

[matt_C]

I am trying to modify the nRF52840dk_nrf52840 spi_flash sample, ncs/zephyr/samples/drivers/spi_flash, to use dual QSPI. 

Following is my device tree configuration:

&spi1 {
	compatible = "nordic,nrf-spi";
	status = "okay";
	sck-pin = <31>;
	mosi-pin = <30>;
	miso-pin = <45>;
};

&qspi {
	status = "okay";
	sck-pin = <31>;
	io-pins = <30 45>;
	csn-pins = <29>;
	mx25r64: mx25r6435f@0 {
		compatible = "nordic,qspi-nor";
		reg = <0>;
		quad-enable-requirements = "NONE";
		/* MX24R64 supports only pp and pp4io */
		writeoc = "pp";
		/* MX24R64 supports all readoc options */
		readoc = "fastread";
		sck-frequency = <8000000>;
		label = "MX25R64";
		jedec-id = [c2 28 17];
		sfdp-bfp = [
			e5 20 f1 ff  ff ff ff 03  44 eb 08 6b  08 3b 04 bb
			ee ff ff ff  ff ff 00 ff  ff ff 00 ff  0c 20 0f 52
			10 d8 00 ff  23 72 f5 00  82 ed 04 cc  44 83 68 44
			30 b0 30 b0  f7 c4 d5 5c  00 be 29 ff  f0 d0 ff ff
		];
		size = <67108864>;
		has-dpd;
		t-enter-dpd = <10000>;
		t-exit-dpd = <35000>;
	};
};

I am using the main.c from the ncs/zephyr/samples/drivers/spi_flash example code.

JEDEC QSPI-NOR SPI flash testing
==========================
SPI flash driver MX25R64 was not found!

If I debug it and step into "device_get_binding()" and go down to '*z_impl_device_get_binding()" it will find the device with the following details.

dev->name = "MX25R64"
dev->config = 0x15884 <flash_id>
dev->api = 0x158d4 <qspi_nor_api>
dev->data = 0x200000e4 <qspi_nor_memory_data>

However, "sys_bitfield_test_bit()", in "z_device_ready()", indicates that the device failed initialization.

I am running this code on a custom board that is known good. I have existing code using the nRF_SDK v15.3.0 that successfully uses the MX25R64 with SPI.

What am I missing to get the MX25R64 to work with dual QSPI in Zephyr?

[matt_C]

Using the nRF52840DK I was able to get dual-SPI to work using the following overlay.

nrf52840dk_nrf52840.overlay

However, I am still not able to get the dual-SPI to work on my custom board.

The only difference I see is that the version of the MX25R64 on the nRF52840DK has the the function HOLD# as a dual function on SIO3 and the version of the MX25R64 that I am using has RESET# as the dual function on SIO3. 

To address this I soldered a wire to always pull the RESET# high, but this did not work and I get the same error.

---

I had been setting RESET# high in the following board.c file that is enabled before the kernel, like I have done successfully with pins used for I2C power and pull-up, but this did not fix the flash problem. 

#include "board.h"

#include <hal/nrf_gpio.h>
#include <init.h>

static int custom_board_nRF52840_init(struct device *dev) {
    ARG_UNUSED(dev);

    /// Enable the I2C power.
    nrf_gpio_cfg_output(BOARD_I2C_ENABLE_POWER_PIN_MAP);

    nrf_gpio_pin_set(BOARD_I2C_ENABLE_POWER_PIN_MAP);

    /// Enable the I2C pullup.
    nrf_gpio_cfg_output(BOARD_I2C_PULLUP_PIN_MAP);

    nrf_gpio_pin_set(BOARD_I2C_PULLUP_PIN_MAP);

    /// Turn off the active low pin reset for the mx25r64 NOR flash.
    nrf_gpio_cfg_output(BOARD_NOR_FLASH_RESET_PIN_MAP);

    nrf_gpio_pin_set(BOARD_NOR_FLASH_RESET_PIN_MAP);

    return 0;
}

SYS_INIT(custom_board_nRF52840_init, PRE_KERNEL_1,
         CONFIG_KERNEL_INIT_PRIORITY_DEFAULT);

 

and using the following CMakeLists.txt file in my custom board folder.

# SPDX-License-Identifier: Apache-2.0

zephyr_library()

zephyr_library_sources(board.c)

zephyr_library_include_directories(${ZEPHYR_BASE}/drivers)

[matt_C]

Hakon does my RESET# pin need to be defined in the qspi portion of my device tree (*.dts), or is there something else I need to do for dual QSPI to work?

[Hakon]

I will ask about this internally. I'm not sure if what you are trying to do is supposed to work.

[matt_C]

From the following https://infocenter.nordicsemi.com/index.jsp?topic=%2Fps_nrf52840%2Fqspi.html, it mentions that the QSPI can be used for “Single/dual/quad SPI input/output”

[Hakon]

Response;

"I think the problem here is that the spi1 node is enabled with the same pins assigned that the QSPI is to use. The spi_flash sample by default enables SPI, so such configuration leads to two peripherals trying to use the same pins. As the Product Specification says, this "may result in unpredictable behavior".

Otherwise, the configuration looks okay. I tried to use the MX25R64 on nRF52840 DK in the two IO pins configuration with "pp" and "fastread" operation modes, and it worked fine. I tried this with the recent Zephyr (commit 3d39f72a88b3100ac83e7c6c285ae567aca640d0)."

[matt_C]

I removed the SPI1 portion from the device tree and I still have the same error.

Now that section of my device tree is simply

&qspi {
	status = "okay";
	sck-pin = <31>;
	io-pins = <30 45>;
	csn-pins = <29>;
	mx25r64: mx25r6435f@0 {
		compatible = "nordic,qspi-nor";
		reg = <0>;
		quad-enable-requirements = "NONE";
		/* MX24R64 supports only pp and pp4io */
		writeoc = "pp";
		/* MX24R64 supports all readoc options */
		readoc = "fastread";
		sck-frequency = <8000000>;
		label = "MX25R64";
		jedec-id = [c2 28 17];
		sfdp-bfp = [
			e5 20 f1 ff  ff ff ff 03  44 eb 08 6b  08 3b 04 bb
			ee ff ff ff  ff ff 00 ff  ff ff 00 ff  0c 20 0f 52
			10 d8 00 ff  23 72 f5 00  82 ed 04 cc  44 83 68 44
			30 b0 30 b0  f7 c4 d5 5c  00 be 29 ff  f0 d0 ff ff
		];
		size = <67108864>;
		has-dpd;
		t-enter-dpd = <10000>;
		t-exit-dpd = <35000>;
	};

And my prj.conf settings are

CONFIG_NORDIC_QSPI_NOR=y
CONFIG_NORDIC_QSPI_NOR_FLASH_LAYOUT_PAGE_SIZE=4096
CONFIG_DEBUG=y
CONFIG_FLASH=y
CONFIG_FLASH_MAP=y
CONFIG_FLASH_PAGE_LAYOUT=y

Following is my testing code, based on the nRF52840dk_nrf52840 spi_flash sample in ncs/zephyr/samples/drivers/spi_flash,

#if (CONFIG_NORDIC_QSPI_NOR - 0) || \
    DT_NODE_HAS_STATUS(DT_INST(0, nordic_qspi_nor), okay)
#define FLASH_DEVICE DT_INST(0, nordic_qspi_nor)

#if DT_NODE_HAS_STATUS(FLASH_DEVICE, okay)
#define FLASH_DEVICE_LABEL DT_LABEL(FLASH_DEVICE)
#define FLASH_NAME         "NORDIC QSPI-NOR"
#else
#error "Your device tree has no enabled nodes with compatible "nordic,qspi_nor""
#define FLASH_DEVICE_LABEL "<none>"
#endif  ///< #if DT_NODE_HAS_STATUS(FLASH_DEVICE, okay)

#else
#error Unsupported flash driver
#endif

#define FLASH_TEST_REGION_OFFSET 0xff000
#define FLASH_SECTOR_SIZE 4096


void testMx25r64(void) {
    const uint8_t  expected[] = {0x55, 0xaa, 0x66, 0x99};
    const size_t   len        = sizeof(expected);
    uint8_t        buf[sizeof(expected)];
    struct device *flash_dev;
    int            rc;
    
    printk("\n" FLASH_NAME " SPI flash testing\n");
    printk("==========================\n");
    
    flash_dev = device_get_binding(FLASH_DEVICE_LABEL);
    
    if (!flash_dev) {
        printk(RED("SPI flash driver %s was not found!\n"),
               FLASH_DEVICE_LABEL);
        return;
    }
    
    /* 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.
	 */
    printk("\nTest 1: Flash erase\n");
    flash_write_protection_set(flash_dev, false);
    
    rc = flash_erase(flash_dev, FLASH_TEST_REGION_OFFSET,
                     FLASH_SECTOR_SIZE);
    if (rc != 0) {
        printk(RED("Flash erase failed! %d\n"), rc);
    } else {
        printk("Flash erase succeeded!\n");
    }
    
    printk("\nTest 2: Flash write\n");
    flash_write_protection_set(flash_dev, false);
    
    printk("Attempting to write %u bytes\n", len);
    rc = flash_write(flash_dev, FLASH_TEST_REGION_OFFSET, expected, len);
    if (rc != 0) {
        printk(RED("Flash write failed! %d\n"), rc);
        return;
    }
    
    memset(buf, 0, len);
    rc = flash_read(flash_dev, FLASH_TEST_REGION_OFFSET, buf, len);
    if (rc != 0) {
        printk(RED("Flash read failed! %d\n"), rc);
        return;
    }
    
    if (memcmp(expected, buf, len) == 0) {
        printk("Data read matches data written. Good!!\n");
    } else {
        const uint8_t *wp  = expected;
        const uint8_t *rp  = buf;
        const uint8_t *rpe = rp + len;
        
        printk(RED("Data read does not match data written!!\n"));
        while (rp < rpe) {
            printk(RED("%08x wrote %02x read %02x %s\n"),
                   (uint32_t)(FLASH_TEST_REGION_OFFSET + (rp - buf)),
                   *wp, *rp, (*rp == *wp) ? "match" : "MISMATCH");
            ++rp;
            ++wp;
        }
    }
}

In this testing code I get “SPI flash driver MX25R64 was not found!”

[matt_C]

I finally got it working, I had mis-labeled one of the pins in the device tree.

[Akash Patel]

Hi Matt,

If you got this working, can you share the final device tree file you are using? Thanks.

[matt_C]

The following device tree should work for the nRF52840DK

/*
 * Copyright (c) 2017 Linaro Limited
 *
 * SPDX-License-Identifier: Apache-2.0
 */

/dts-v1/;
#include <nordic/nrf52840_qiaa.dtsi>

/ {
	model = "Nordic nRF52840 DK NRF52840";
	compatible = "nordic,nrf52840-dk-nrf52840";

	chosen {
		zephyr,console = &uart0;
		zephyr,shell-uart = &uart0;
		zephyr,uart-mcumgr = &uart0;
		zephyr,bt-mon-uart = &uart0;
		zephyr,bt-c2h-uart = &uart0;
		zephyr,sram = &sram0;
		zephyr,flash = &flash0;
		zephyr,code-partition = &slot0_partition;
	};

	leds {
		compatible = "gpio-leds";
		led0: led_0 {
			gpios = <&gpio0 13 GPIO_ACTIVE_LOW>;
			label = "Green LED 0";
		};
		led1: led_1 {
			gpios = <&gpio0 14 GPIO_ACTIVE_LOW>;
			label = "Green LED 1";
		};
		led2: led_2 {
			gpios = <&gpio0 15 GPIO_ACTIVE_LOW>;
			label = "Green LED 2";
		};
		led3: led_3 {
			gpios = <&gpio0 16 GPIO_ACTIVE_LOW>;
			label = "Green LED 3";
		};
	};

	pwmleds {
		compatible = "pwm-leds";
		pwm_led0: pwm_led_0 {
			pwms = <&pwm0 13>;
		};
	};

	buttons {
		compatible = "gpio-keys";
		button0: button_0 {
			gpios = <&gpio0 11 (GPIO_PULL_UP | GPIO_ACTIVE_LOW)>;
			label = "Push button switch 0";
		};
		button1: button_1 {
			gpios = <&gpio0 12 (GPIO_PULL_UP | GPIO_ACTIVE_LOW)>;
			label = "Push button switch 1";
		};
		button2: button_2 {
			gpios = <&gpio0 24 (GPIO_PULL_UP | GPIO_ACTIVE_LOW)>;
			label = "Push button switch 2";
		};
		button3: button_3 {
			gpios = <&gpio0 25 (GPIO_PULL_UP | GPIO_ACTIVE_LOW)>;
			label = "Push button switch 3";
		};
	};

	arduino_header: connector {
		compatible = "arduino-header-r3";
		#gpio-cells = <2>;
		gpio-map-mask = <0xffffffff 0xffffffc0>;
		gpio-map-pass-thru = <0 0x3f>;
		gpio-map = <0 0 &gpio0 3 0>,	/* A0 */
			   <1 0 &gpio0 4 0>,	/* A1 */
			   <2 0 &gpio0 28 0>,	/* A2 */
			   <3 0 &gpio0 29 0>,	/* A3 */
			   <4 0 &gpio0 30 0>,	/* A4 */
			   <5 0 &gpio0 31 0>,	/* A5 */
			   <6 0 &gpio1 1 0>,	/* D0 */
			   <7 0 &gpio1 2 0>,	/* D1 */
			   <8 0 &gpio1 3 0>,	/* D2 */
			   <9 0 &gpio1 4 0>,	/* D3 */
			   <10 0 &gpio1 5 0>,	/* D4 */
			   <11 0 &gpio1 6 0>,	/* D5 */
			   <12 0 &gpio1 7 0>,	/* D6 */
			   <13 0 &gpio1 8 0>,	/* D7 */
			   <14 0 &gpio1 10 0>,	/* D8 */
			   <15 0 &gpio1 11 0>,	/* D9 */
			   <16 0 &gpio1 12 0>,	/* D10 */
			   <17 0 &gpio1 13 0>,	/* D11 */
			   <18 0 &gpio1 14 0>,	/* D12 */
			   <19 0 &gpio1 15 0>,	/* D13 */
			   <20 0 &gpio0 26 0>,	/* D14 */
			   <21 0 &gpio0 27 0>;	/* D15 */
	};

	arduino_adc: analog-connector {
		compatible = "arduino,uno-adc";
		#io-channel-cells = <1>;
		io-channel-map = <0 &adc 1>,	/* A0 = P0.3 = AIN1 */
				 <1 &adc 2>,	/* A1 = P0.4 = AIN2 */
				 <2 &adc 4>,	/* A2 = P0.28 = AIN4 */
				 <3 &adc 5>,	/* A3 = P0.29 = AIN5 */
				 <4 &adc 6>,	/* A4 = P0.30 = AIN6 */
				 <5 &adc 7>;	/* A5 = P0.31 = AIN7 */
	};

	/* These aliases are provided for compatibility with samples */
	aliases {
		led0 = &led0;
		led1 = &led1;
		led2 = &led2;
		led3 = &led3;
		pwm-led0 = &pwm_led0;
		sw0 = &button0;
		sw1 = &button1;
		sw2 = &button2;
		sw3 = &button3;
	};
};

&adc {
	status = "okay";
};

&gpiote {
	status = "okay";
};

&gpio0 {
	status = "okay";
};

&gpio1 {
	status = "okay";
};

&uart0 {
	compatible = "nordic,nrf-uarte";
	status = "okay";
	current-speed = <115200>;
	tx-pin = <6>;
	rx-pin = <8>;
	rts-pin = <5>;
	cts-pin = <7>;
};

arduino_serial: &uart1 {
	status = "okay";
	current-speed = <115200>;
	rx-pin = <33>;
	tx-pin = <34>;
};

arduino_i2c: &i2c0 {
	compatible = "nordic,nrf-twi";
	status = "okay";
	sda-pin = <26>;
	scl-pin = <27>;
};

&i2c1 {
	compatible = "nordic,nrf-twi";
	/* Cannot be used together with spi1. */
	/* status = "okay"; */
	sda-pin = <30>;
	scl-pin = <31>;
};

&pwm0 {
	status = "okay";
	ch0-pin = <13>;
	ch0-inverted;
};

&spi0 {
	compatible = "nordic,nrf-spi";
	/* Cannot be used together with i2c0. */
	/* status = "okay"; */
	sck-pin = <27>;
	mosi-pin = <26>;
	miso-pin = <29>;
};

&spi1 {
	compatible = "nordic,nrf-spi";
	status = "okay";
	sck-pin = <31>;
	mosi-pin = <30>;
	miso-pin = <40>;
};

// &spi2 {
// 	compatible = "nordic,nrf-spi";
// 	status = "disabled";
// 	sck-pin = <19>;
// 	mosi-pin = <20>;
// 	miso-pin = <21>;
// };

&qspi {
	status = "okay";
	sck-pin = <19>;
	io-pins = <20>, <21>;
	csn-pins = <17>;
	mx25r64: mx25r6435f@0 {
		compatible = "nordic,qspi-nor";
		reg = <0>;
		quad-enable-requirements = "NONE";
		/* MX24R64 supports only pp and pp4io */
		writeoc = "pp";
		/* MX24R64 supports all readoc options */
		readoc = "fastread";
		sck-frequency = <8000000>;
		label = "MX25R64";
		jedec-id = [c2 28 17];
		sfdp-bfp = [
			e5 20 f1 ff  ff ff ff 03  44 eb 08 6b  08 3b 04 bb
			ee ff ff ff  ff ff 00 ff  ff ff 00 ff  0c 20 0f 52
			10 d8 00 ff  23 72 f5 00  82 ed 04 cc  44 83 68 44
			30 b0 30 b0  f7 c4 d5 5c  00 be 29 ff  f0 d0 ff ff
		];
		size = <67108864>;
		has-dpd;
		t-enter-dpd = <10000>;
		t-exit-dpd = <35000>;
	};
};

arduino_spi: &spi3 {
	status = "okay";
	sck-pin = <47>;
	miso-pin = <46>;
	mosi-pin = <45>;
	cs-gpios = <&arduino_header 16 GPIO_ACTIVE_LOW>; /* D10 */
};

&flash0 {

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

		boot_partition: partition@0 {
			label = "mcuboot";
			reg = <0x000000000 0x0000C000>;
		};
		slot0_partition: partition@c000 {
			label = "image-0";
			reg = <0x0000C000 0x00067000>;
		};
		slot1_partition: partition@73000 {
			label = "image-1";
			reg = <0x00073000 0x00067000>;
		};
		scratch_partition: partition@da000 {
			label = "image-scratch";
			reg = <0x000da000 0x0001e000>;
		};

		/*
		 * The flash starting at 0x000f8000 and ending at
		 * 0x000fffff is reserved for use by the application.
		 */

		/*
		 * Storage partition will be used by FCB/LittleFS/NVS
		 * if enabled.
		 */
		storage_partition: partition@f8000 {
			label = "storage";
			reg = <0x000f8000 0x00008000>;
		};
	};
};

&usbd {
	compatible = "nordic,nrf-usbd";
	status = "okay";
};