External Memory on 9160dk

[Felipe Dantas]

Hi everyone,

  I working on a project for nrf9160 in 9160DK and i need to use the external flash memory onboard with nvs.h but i can't get it to work by anyway and a try to looking for an example or sample in Nordic site and forum but all topics that i founded are much old and don't compile (consider that i'm on ncs v2.6.1). Can someone provide me one example or sample for this? Thanks!

[Felipe Dantas]

Hi everyone,

Finally i can get use the external memory with NVS.h library how i need. I'll describe the proccess that i use to make this bellow. I hope can help other people with the same problem. Consider that i've in ncs 2.6.1. 

If you´re in 9160DK, is needed follow the steps on link below, programming the nrf9160_dk_board_controller_fw_2.0.1.hex on nrf52840 to able the nrf9160 to comunitace with the mx25r64:

https://docs.nordicsemi.com/bundle/ncs-latest/page/nrf/app_dev/device_guides/nrf91/nrf9160_external_flash.html

So, put this content on your prj.conf: 

# Logging
CONFIG_LOG=y

# Memory configs:
CONFIG_NVS=y
CONFIG_FLASH=y
CONFIG_FLASH_MAP=y

# SPI configs:
CONFIG_SPI=y
CONFIG_SPI_NOR=y
CONFIG_SPI_NOR_SFDP_DEVICETREE=y
CONFIG_PM_OVERRIDE_EXTERNAL_DRIVER_CHECK=y
CONFIG_SPI_NOR_FLASH_LAYOUT_PAGE_SIZE=4096

Create an overlay (nrf9160dk_nrf9160_ns.overlay) and put this content to instanciate the mx25r64 on devicetree:

/* Enable the external flash device (required) */
&mx25r64 {
    status = "okay";
};

/* Configure partition manager to use mx25r64 as the external flash device */
/ {
   chosen {
       nordic,pm-ext-flash = &mx25r64;
   };
};

/* Enable high performance mode to increase write/erase performance */
&mx25r64 {
   mxicy,mx25r-power-mode = "high-performance";
};  

And this is the main. content:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ncs_version.h>
#include <zephyr/kernel.h>
#include <zephyr/devicetree.h>
#include <zephyr/logging/log.h>
#include <zephyr/drivers/uart.h>
#include <zephyr/sys/printk.h>
#include <zephyr/drivers/flash.h>
#include <zephyr/storage/flash_map.h>
#include <zephyr/fs/nvs.h>

static struct nvs_fs fs;

/* Change the commented line according the memory sorce the you wants use */
//#define NVS_PARTITION storage_partition
#define NVS_PARTITION external_flash

#define NVS_PARTITION_DEVICE FIXED_PARTITION_DEVICE(NVS_PARTITION)
#define NVS_PARTITION_OFFSET FIXED_PARTITION_OFFSET(NVS_PARTITION)

#define NVS_BOOT_COUNTER_ID 0

int init_counter = 0;

void main(void)
{
    int rc = 0;
    struct flash_pages_info info;

    fs.flash_device = NVS_PARTITION_DEVICE;
    if (!device_is_ready(fs.flash_device))
    {
        printk("Flash device %s is not ready\n", fs.flash_device->name);
        return 0;
    }
    fs.offset = NVS_PARTITION_OFFSET;
    rc = flash_get_page_info_by_offs(fs.flash_device, fs.offset, &info);
    if (rc)
    {
        printk("Unable to get page info\n");
        return 0;
    }
    fs.sector_size = info.size;
    
    /* Change the commented line according the memory sorce the you wants use */
    fs.sector_count = 2048U; // using external memory mx25r64 (external_flash)
    //fs.sector_count = 6U; // using internal flash (storage_partition)

    

    rc = nvs_mount(&fs);
    if (rc)
    {
        printk("Flash Init failed\n");
        return 0;
    }

    nvs_read(&fs, NVS_BOOT_COUNTER_ID, &init_counter, sizeof(init_counter));

    init_counter++;

    nvs_write(&fs, NVS_BOOT_COUNTER_ID, &init_counter, sizeof(init_counter));

    printk("Hello World! Initialization number: %d.\r\n", init_counter);

    ssize_t free_space = nvs_calc_free_space(&fs);

    printk("Free space on NVS partition NVS: %zd bytes\n", free_space);
    /*
        while (1)
        {
        }
    */
}

See that is the nvs sample, but changed to work with the external flash memory.

Note that if you declare #define NVS_PARTITION storage_partition you will use the internal memory,

and if you declare #define NVS_PARTITION external_flash you will use the externall memory.

In other words, the file system  "static struct nvs_fs fs" will be created on local declared in #define NVS_PARTITION and you can confirm this throght the response of funtion "nvs_calc_free_space(&fs)".

Finally, see that you need to declare de size of of partition and it´s made in this commandlines in main.c:

    /* Change the commented line according the memory sorce the you wants use */

    fs.sector_count = 2048U; // using external memory mx25r64 (external_flash)

    //fs.sector_count = 6U; // using internal flash (storage_partition)

Note that the mx25r64 have 2048 pages with 4096bytes (it´s equal to 8MB or 64Mb). If you try to put biggers values, error will occurs. The maximum size on internal flash will deppends of your partition definition and you can see that on "partitions.yml" (generate automaticaly when you perform a pristine build). Inspect this file and you will see something like this:

nonsecure_storage:
  address: 0xf8000
  end_address: 0xfe000
  orig_span: &id001
  - nvs_storage
  region: flash_primary
  size: 0x6000
  span: *id001

Note that the final hexadecimal value "end_address"(FE000) minus start hexadecimal value "address"(F8000) is equal to size(6000), and it´s in decimal is equal to 24576 bytes. Divide this for the page size, that is 4096 and you have 6. And this is for what i've declared "fs.sector_count = 6U;" like size of internal memory. 

If someone have some doubts about this, feels free to send me a mensage.

Best regards!