DFU with external QSPI memory

RE: DFU with external QSPI memory

Dominik Eugster — Thu, 20 Jun 2024 20:35:00 GMT

Hi Tom

Can you tell me how you implemented the callback of the SPI (I'm using QSPI but it will be smilar)

In the function on_data_obj_write_request is the call for nrf_dfu_flash_store (file nrf_dfu_req_handler.c

static void on_data_obj_write_request(nrf_dfu_request_t * p_req, nrf_dfu_response_t * p_res)
{
    NRF_LOG_DEBUG("Handle NRF_DFU_OP_OBJECT_WRITE (data)");

    if (!nrf_dfu_validation_init_cmd_present())
    {
        /* Can't accept data because DFU isn't initialized by init command. */
        p_res->result = NRF_DFU_RES_CODE_OPERATION_NOT_PERMITTED;
        return;
    }

    uint32_t const data_object_offset = s_dfu_settings.progress.firmware_image_offset -
                                        s_dfu_settings.progress.firmware_image_offset_last;

    if ((p_req->write.len + data_object_offset) > s_dfu_settings.progress.data_object_size)
    {
        /* Can't accept data because too much data has been received. */
        NRF_LOG_ERROR("Write request too long");
        p_res->result = NRF_DFU_RES_CODE_INVALID_PARAMETER;
        return;
    }

    uint32_t const write_addr = m_firmware_start_addr + s_dfu_settings.write_offset;
    /* CRC must be calculated before handing off the data to fstorage because the data is
     * freed on write completion.
     */
    uint32_t const next_crc =
        crc32_compute(p_req->write.p_data, p_req->write.len, &s_dfu_settings.progress.firmware_image_crc);

    ASSERT(p_req->callback.write);

    ret_code_t ret =
        nrf_dfu_flash_store(write_addr, p_req->write.p_data, p_req->write.len, p_req->callback.write);

    if (ret != NRF_SUCCESS)
    {
        /* When nrf_dfu_flash_store() fails because there is no space in the queue,
         * stop processing the request so that the peer can detect a CRC error
         * and retransmit this object. Remember to manually free the buffer !
         */
        p_req->callback.write((void*)p_req->write.p_data);
        return;
    }

    /* Update the CRC of the firmware image. */
    s_dfu_settings.write_offset                   += p_req->write.len;
    s_dfu_settings.progress.firmware_image_offset += p_req->write.len;
    s_dfu_settings.progress.firmware_image_crc     = next_crc;

    /* This is only used when the PRN is triggered and the 'write' message
     * is answered with a CRC message and these field are copied into the response.
     */
    p_res->write.crc    = s_dfu_settings.progress.firmware_image_crc;
    p_res->write.offset = s_dfu_settings.progress.firmware_image_offset;
}

There is a callback which is needed:

ret_code_t ret =
        nrf_dfu_flash_store(write_addr, p_req->write.p_data, p_req->write.len, p_req->callback.write);

inside this function I use the QSPI function:

hal_qspi_write(&p_src, len, (dest & EXTERNAL_FLASH_ADDRESS_LOWER_BYTES), (void*)callback))

which at the end is calling the nrfx function nrfx_qspi_write.

Here I should have a callback, but I don't know what I should implement.

The original callback in the nrf_fstorage_write is implemented like this:
return (p_fs->p_api)->write(p_fs, dest, p_src, len, p_context);

ret_code_t nrf_fstorage_write(nrf_fstorage_t const * p_fs,
                              uint32_t               dest,
                              void           const * p_src,
                              uint32_t               len,
                              void                 * p_context)
{
    NRF_FSTORAGE_PARAM_CHECK(p_fs,        NRF_ERROR_NULL);
    NRF_FSTORAGE_PARAM_CHECK(p_src,       NRF_ERROR_NULL);
    NRF_FSTORAGE_PARAM_CHECK(p_fs->p_api, NRF_ERROR_INVALID_STATE);
    NRF_FSTORAGE_PARAM_CHECK(len,         NRF_ERROR_INVALID_LENGTH);

    /* Length must be a multiple of the program unit. */
    NRF_FSTORAGE_PARAM_CHECK(!(len % p_fs->p_flash_info->program_unit), NRF_ERROR_INVALID_LENGTH);

    /* Source and destination addresses must be word-aligned. */
    NRF_FSTORAGE_PARAM_CHECK(addr_is_aligned32(dest),                NRF_ERROR_INVALID_ADDR);
    NRF_FSTORAGE_PARAM_CHECK(addr_is_aligned32((uint32_t)p_src),     NRF_ERROR_INVALID_ADDR);
    NRF_FSTORAGE_PARAM_CHECK(addr_is_within_bounds(p_fs, dest, len), NRF_ERROR_INVALID_ADDR);

    return (p_fs->p_api)->write(p_fs, dest, p_src, len, p_context);
}

Now the DFU is strating on bank1 but the App is generating an error because data is missing because of this callack I guess?

RE: DFU with external QSPI memory

Dominik Eugster — Wed, 01 May 2024 14:25:58 GMT

Is there somebody who can share the sample project which is running?
Thank you so much for any feedback.

Regards

RE: DFU with external QSPI memory

Dipak — Wed, 19 May 2021 13:35:43 GMT

Hi Mohammad & TomWS,

I am trying to implement the same thing.

It would be very helpful for me if I could start with a sample project that demonstrates the principles of the DFU from external storage.

Please guide us!

Dipak

RE: DFU with external QSPI memory

Vijay Prakash — Wed, 19 May 2021 10:07:37 GMT

Hi Maik,

I am trying to implement the same. Let me know if you got any luck on this?

RE: DFU with external QSPI memory

Hein — Thu, 30 Apr 2020 09:06:55 GMT

Hello Mohammad,

I'm starting with exactly the same task on the nRF52840. I will retrieve the DFU files via a cellular path and would like to save the files in external flash. Then I would like to continue the DFU from the external flash.
It would be very helpful for me if I could start with a sample project that demonstrates the principles of the DFU from external storage.
So I would like to ask you if there is a way to share a demo project or similar helpful things to get you started faster.
Thank you and best regards
Maik

RE: DFU with external QSPI memory

Mohammad — Thu, 14 Nov 2019 04:51:11 GMT

Hi Hung Bui & TomWS,

Sorry for the late response. I am busy with some other task. I have completed the Bootloader for QSPI external memory. Its working fine.

I have check the firmware update without SD and also did some modification in SD activation in order to receive new SD upgrade.

I will write a brief note later on, how to modifiy the present bootloader to place the firmware image(APP + SD), it will help some other guys.

I thank to Hung Bui and TomWS helping me in this issue.

But there is a lack of support from nordic team, because Hung Bui has disappeared long back.

RE: DFU with external QSPI memory

Mohammad — Tue, 29 Oct 2019 08:53:17 GMT

After the hash is verified successfully. Old setting are erased and new one written at 0x000FF000 and 0x000FE000. Then bootloader resets and check the backup settings which inturn throws ""Destination settings are identical to source, write not needed. Skipping".

After that it goes to NMI_Handler Exception.

But when i disable the External QSPI storage and work with standard bootloader code everything works fine, there is no NMI_Handler Exception.

Pls help me to solve this issue.

RE: DFU with external QSPI memory

TomWS — Mon, 28 Oct 2019 18:15:17 GMT

I'm not sure why you're getting a hardware fault, examining the stack might give you a clue. However, I also don't know why you're modifying the bank1 start address. ISTM that using the beginning of the QSPI memory should be sufficient. What you store in QSPI flash doesn't have to have the same location as the firmware address. Here is my dfu_bank1_start_addr():

uint32_t nrf_dfu_bank1_start_addr(void)
{
  if ((s_dfu_settings.bank_0.bank_code == NRF_DFU_BANK_VALID_APP) && s_dfu_settings.bank_0.image_size) { // is there an app already loaded?
    return EXTERNAL_FLASH_ADDRESS;  // yes, use external flash for bank1
  }    
  // no, use bank 0 for downloading
  uint32_t bank0_addr = nrf_dfu_bank0_start_addr();
  return ALIGN_TO_PAGE(bank0_addr + s_dfu_settings.bank_0.image_size);
}

RE: DFU with external QSPI memory

Mohammad — Sun, 27 Oct 2019 18:58:27 GMT

Hi TomWS,

Thanks for rour response.

I have made modification according to your instruction. But it throws hardware error after the hash verification succeed.

nrf_dfu_bank1_start_addr(void) will return return ALIGN_TO_PAGE(0x0A00000 + bank0_addr + s_dfu_settings.bank_0.image_size);

ASSERT((cache_address & 0x000FFFFF) <= DFU_REGION_END(bootloader_start_addr));
cache_too_small = required_size > (DFU_REGION_END(bootloader_start_addr) - (cache_address & 0x000FFFFF));
delete_more = cache_too_small || single_bank; // Delete app or SoftDevice only if we need more room, or if single bank is requested.

And strip off the upper bits of the synthetic address before using in QSPI read & write functions.

RE: DFU with external QSPI memory

TomWS — Sat, 26 Oct 2019 21:14:11 GMT

[quote userid="73888" url="~/f/nordic-q-a/48961/dfu-with-external-qspi-memory/216938"] Hi TomWS, Thanks for your reply. Can you pls let me know where i need to use this, EXTERNAL_FLASH_ADDRESS=0x0A00000; [/quote]

I would have expected you to know this by now. However, to answer your question, there are two places where this is relevant. On the start of download where the DFU code gets the Bank1 start address:

File: nrf_dfu_utils.c, nrf_dfu_bank1_start_addr()

You need to return the synthetic address used to distinguish your external flash.

And in your QSPI read & write functions where you need to strip off the upper bits of the synthetic address before using it.

Note, as mentioned in an earlier reply (about 2 months ago), once you use a 'synthetic' address that is outside the range of the device flash, you need to modify the error checking in nrf_dfu_cache_prepare() as in:

        //TWS: IGNORED! ASSERT(cache_address <= DFU_REGION_END(bootloader_start_addr));
        //TWS: REPLACED BELOW: cache_too_small = required_size > (DFU_REGION_END(bootloader_start_addr) - cache_address);
        cache_too_small = required_size > EXTERNAL_FLASH_SIZE;
        delete_more     = cache_too_small || single_bank; // Delete app or SoftDevice only if we need more room, or if single bank is requested.

RE: DFU with external QSPI memory

Mohammad — Fri, 25 Oct 2019 22:12:45 GMT

Hi TomWS,

Thanks for your reply.

Can you pls let me know where i need to use this,

EXTERNAL_FLASH_ADDRESS=0x0A00000;

RE: DFU with external QSPI memory

TomWS — Fri, 25 Oct 2019 21:24:02 GMT

There are multiple phases in the firmware download.

In the first phase (after checking that the image is valid and will fit), the image is downloaded in chunks, with each chunk either stored directly at the firmware final destination (if you are single buffering or if there isn't a valid image in place already), or to the backup buffer. The 'settings' blocks record where the incoming image is stored and also it's final destination.

Once the image is completely downloaded and verified, the settings blocks are saved with the corresponding addresses and the next phase (where the image is copied, IF NECESSARY, from its buffer to its final destination) is begun.

In the next phase the settings are checked and, if the final destination AND the stored address are exactly the same, the DFU code 'knows' that the image is already in it's intended location and therefore does not need to copy the image.

In your case, since you are using the same address in QSPI memory as the final destination, hence the copy code thinks there is nothing to do.

The 'trick' is to have the QSPI buffer address mapped outside of the normal range of program memory so the settings blocks can distinguish between buffered image and a properly loaded image. You can still use '1000' as a starting address in QSPI memory, but the code sets and strips off the address field used to distinguish between internal vs external memory. In my case, I used:

EXTERNAL_FLASH_ADDRESS=0x0A00000;

So address 0x1000 would map to 0x0A01000 in the code.

RE: DFU with external QSPI memory

Mohammad — Fri, 25 Oct 2019 13:43:33 GMT

Hi TomWS,

Thanks for your response.

Hash test is passed. But still the blinky_pca10056_mbr.hex is not written into flash memory because the image_copy throws,

<debug> app: No copy needed.

I dont understand why the (src_addr == dst_addr) are identical.

waiting for reply.

=========================================================================

<info> nrf_dfu_req_handler: Whole firmware image received. Postvalidating.
<info> nrf_dfu_validation: Convert to hash to big-endian format for use in nrf_crypto
<info> nrf_dfu_validation: Hash verification. start address: 0x1000, size: 0x6AC
<debug> nrf_dfu_validation: Source address = 0x1000 and destination address = 0x16AC
<debug> nrf_dfu_validation: Reading buffer at address = 0x1000 with size = 0x6AC
<debug> nrf_dfu_qspi: nrf_qspistorage_read(addr=0x1000, src=0x200084F8, len=1708 bytes), queue usage: 1
<warning> nrf_dfu_validation: Hash verification Passed!!!!!!
<info> nrf_dfu_validation: Expected FW hash:
<info> nrf_dfu_validation: 84 5F 42 4A E0 E9 54 C9|._BJ..T.
<info> nrf_dfu_validation: 7C 95 6F CE E7 C1 D9 7B||.o....{
<info> nrf_dfu_validation: 08 6A D9 E9 4A 44 C6 46|.j..JD.F
<info> nrf_dfu_validation: F7 E8 9F A1 A5 BE 18 46|.......F
<info> nrf_dfu_validation: Actual FW hash:
<info> nrf_dfu_validation: 84 5F 42 4A E0 E9 54 C9|._BJ..T.
<info> nrf_dfu_validation: 7C 95 6F CE E7 C1 D9 7B||.o....{
<info> nrf_dfu_validation: 08 6A D9 E9 4A 44 C6 46|.j..JD.F
<info> nrf_dfu_validation: F7 E8 9F A1 A5 BE 18 46|.......F
<info> nrf_dfu_validation: Invalidating old application in bank 0.
<debug> nrf_dfu_serial: Sending Response: [0x4, 0x1]
<debug> nrf_dfu_settings: Writing settings...
<debug> nrf_dfu_settings: Erasing old settings at: 0x000FF000
<debug> nrf_dfu_flash: nrf_fstorage_erase(addr=0x0x000FF000, len=1 pages), queue usage: 1
<debug> nrf_dfu_flash: Flash erase success: addr=0x000FF000, pending 0
<debug> nrf_dfu_flash: nrf_fstorage_write(addr=0x000FF000, src=0x20009504, len=896 bytes), queue usage: 1
<debug> nrf_dfu_flash: Flash write success: addr=0x000FF000, pending 0
<debug> nrf_dfu_settings: Backing up settings page to address 0xFE000.
<debug> nrf_dfu_settings: Writing settings...
<debug> nrf_dfu_settings: Erasing old settings at: 0x000FE000
<debug> nrf_dfu_flash: nrf_fstorage_erase(addr=0x0x000FE000, len=1 pages), queue usage: 1
<debug> nrf_dfu_flash: Flash erase success: addr=0x000FE000, pending 0
<debug> nrf_dfu_flash: nrf_fstorage_write(addr=0x000FE000, src=0x20009884, len=896 bytes), queue usage: 1
<debug> nrf_dfu_flash: Flash write success: addr=0x000FE000, pending 0
<info> nrf_dfu_req_handler: All flash operations have completed. DFU completed.
<debug> app: Shutting down transports (found: 1)
<info> app: Resetting bootloader.
<debug> nrf_dfu_settings: Backing up settings page to address 0xFE000.
<debug> nrf_dfu_settings: Destination settings are identical to source, write not needed. Skipping.
<info> app: Inside main, Bootloader size = 73728
<debug> app: In nrf_bootloader_init
<debug> nrf_dfu_settings: Calling nrf_dfu_settings_init()...
<debug> nrf_dfu_flash: Initializing nrf_fstorage_nvmc backend.
<debug> nrf_dfu_settings: Using settings page.
<debug> nrf_dfu_settings: Copying forbidden parts from backup page.
<debug> nrf_dfu_settings: Destination settings are identical to source, write not needed. Skipping.
<debug> nrf_dfu_settings: Backing up settings page to address 0xFE000.
<debug> nrf_dfu_settings: Destination settings are identical to source, write not needed. Skipping.
<info> app: Enter nrf_bootloader_fw_activate
<info> app: Valid App
<info> app: Enter nrf_dfu_app_continue
<debug> app: No copy needed
<info> app: Setting app as valid
<debug> nrf_dfu_settings: Writing settings...
<debug> nrf_dfu_settings: Erasing old settings at: 0x000FF000
<debug> nrf_dfu_flash: nrf_fstorage_erase(addr=0x0x000FF000, len=1 pages), queue usage: 0
<debug> nrf_dfu_flash: Flash erase success: addr=0x000FF000, pending 0
<debug> nrf_dfu_flash: nrf_fstorage_write(addr=0x000FF000, src=0x20009504, len=896 bytes), queue usage: 1
<debug> nrf_dfu_flash: Flash write success: addr=0x000FF000, pending 0
<debug> nrf_dfu_settings: Backing up settings page to address 0xFE000.
<debug> nrf_dfu_settings: Writing settings...
<debug> nrf_dfu_settings: Erasing old settings at: 0x000FE000
<debug> nrf_dfu_flash: nrf_fstorage_erase(addr=0x0x000FE000, len=1 pages), queue usage: 1
<debug> nrf_dfu_flash: Flash erase success: addr=0x000FE000, pending 0
<debug> nrf_dfu_flash: nrf_fstorage_write(addr=0x000FE000, src=0x20009884, len=896 bytes), queue usage: 1
<debug> nrf_dfu_flash: Flash write success: addr=0x000FE000, pending 0
<info> app: Resetting bootloader.
<debug> nrf_dfu_settings: Backing up settings page to address 0xFE000.
<debug> nrf_dfu_settings: Destination settings are identical to source, write not needed. Skipping.
<info> app: Inside main, Bootloader size = 73728

RE: DFU with external QSPI memory

TomWS — Fri, 25 Oct 2019 12:34:01 GMT

I find it odd (no pun intended) that the buffer isn't aligned on a 32bit boundary, but the modifier __ALIGN(4) can be used to force it on a 4 byte boundary as in:

__ALIGN(4) uint8_t m_buffer_rx[CODE_PAGE_SIZE];

RE: DFU with external QSPI memory

Mohammad — Fri, 25 Oct 2019 11:19:33 GMT

Hi TomWS

Actually i have problem in reading QSPI data for hash calculation. I have decalred a array

uint8_t m_buffer_rx[CODE_PAGE_SIZE];

In which reading data from QSPI read,

NRF_LOG_DEBUG("Reading buffer at address = 0x%x with size = 0x%x", src_addr, bytes);
nrf_dfu_qspi_read(src_addr, &m_buffer_rx, ALIGN_NUM(sizeof(uint32_t), bytes));

Error is thrown after the nrf_dfu_qspi_read is called,

<info> nrf_dfu_validation: Hash verification. start address: 0x5000, size: 0x6AC
<debug> nrf_dfu_qspi: nrf_qspistorage_read(addr=0x5000, src=0x200084FD, len=1708 bytes), queue usage: 1
<error> app: Received a fault! id: 0x00004002, pc: 0x00000000, info: 0x2003FD80

NRFX_ASSERT(nrfx_is_word_aligned(p_rx_buffer)) is thrown error because address of m_buffer_rx = 0x200084FD.

((((uint32_t)p_object) & 0x3u) == 0u); ==> 1

How to solve this issue??

RE: DFU with external QSPI memory

TomWS — Thu, 24 Oct 2019 21:41:30 GMT

@Mohammad, the Hex file line you're referencing is only 14 bytes of data. Consequently the next two bytes of QSPI flash are not written and hence are 0xff in value. The hash calculation may be assuming that the extra two bytes are padded with zeroes to make it a full word write (to Flash Memory).

From what I've seen with the BLE data transfers to the DFU code, all data blocks have always been full word multiples so I'm not sure how the raw Hex data would appear on the DFU end of the transfer.

RE: DFU with external QSPI memory

Hung Bui — Wed, 23 Oct 2019 14:54:36 GMT

Hi Mohammad,

I'm sorry for late response, I was on vacation last week.

If you don't have the example, the application is supposed to start at address 0x1000. I'm not sure why you set the Flash Start to 0x26000

You may want to check how the last packet is written to QSPI.

But please clarify how you have " Hash verification succeed " did you remove the hash checking ?

RE: DFU with external QSPI memory

Mohammad — Mon, 14 Oct 2019 20:52:52 GMT

Hi Hung,

I compared the blinky_pca10056_mbr.hex with the data written into QSPI, couple of data is mismatch with hex.

In blinky_pca10056_mbr.hex at 4th line before end of hex file as follows

:0E1698000D0E0F10000000000338FDD8704743
:0416A8000090D003DB

Data from end of the QSPI file

d e f 10 0 0 0 0 3 38 fd d8 70 47 ff ff 0 90 d0 3

If you compare the above two extra two bytes 0xFF and 0xFF is read from QSPI, but remaining all are same.

I dont know why 0xFF, 0xFF is there after d e f 10 0 0 0 0 3 38 fd d8 70 47.

devzone.nordicsemi.com/.../QSPI-data-read.txtThis makes the hash verification fails.devzone.nordicsemi.com/.../blinky_5F00_pca10056_5F00_mbr.hex

RE: DFU with external QSPI memory

Mohammad — Fri, 11 Oct 2019 11:02:14 GMT

Hi Hung,

I assume you don't have the softdevice ? yes correct

Where do you put the application to ? In blinky_pca10056_mbr project i have set the FLASH_START = 0x26000

RE: DFU with external QSPI memory

Hung Bui — Thu, 10 Oct 2019 14:33:01 GMT

I assume you don't have the softdevice ?

Where do you put the application to ?

You can try to do a hex dump (nrfjprog --readcode) to read the flash after you do DFU, and compare it with when you flash only the MBR and the blinky.

RE: DFU with external QSPI memory

Mohammad — Thu, 10 Oct 2019 13:08:09 GMT

Hi Hung,
I used blinky_pca10056_mbr.hex found in examples under nordic SDK 15.3 to generate the dfu_app_pkg.zip. I followed the below steps,

1. In the blinky_pca10056_mbr example code, i modified the FLASH_START=0x26000, in order to place code above SD section.

2. Then i generated the settings file,
nrfutil settings generate --family NRF52840 --application blinky_pca10056_mbr.hex --application-version 5 --bootloader-version 2 --bl-settings-version 2 settings.hex

Bootloader DFU Settings:
* File: settings.hex
* Family: NRF52840
* Start Address: 0x000FF000
* CRC: 0x236ED638
* Settings Version: 0x00000002 (2)
* App Version: 0x00000005 (5)
* Bootloader Version: 0x00000002 (2)
* Bank Layout: 0x00000000
* Current Bank: 0x00000000
* Application Size: 0x000006AC (1708 bytes)
* Application CRC: 0x4009821F
* Bank0 Bank Code: 0x00000001
* Softdevice Size: 0x00000000 (0 bytes)
* Boot Validation CRC: 0x1202D358
* SD Boot Validation Type: 0x00000000 (0)
* App Boot Validation Type: 0x00000001 (1)

3. Then I merged the blinky_pca10056_mbr.hex and settings.hex into app_settings.hex

4. Finally the dfu_app_pkg is generated,

nrfutil pkg generate --hw-version 52 --sd-req 0x00 --application-version 5 --application app_settings.hex --key-file Test2.key app_dfu_pkg.zip

5. I am sending the app_dfu_pkg.zip,
nrfutil dfu usb-serial -pkg app_dfu_pkg.zip -p COM5 -b 115200

6. The output,
<info> app: Enter nrf_bootloader_fw_activate
<info> app: No firmware to activate.
<info> app: App is valid
<info> app: DFU mode requested via button.
<info> nrf_bootloader_wdt: WDT is not enabled
<info> app: in weak nrf_dfu_init_user
<info> app: Entering DFU mode.
<info> app: Enter main loop
<info> nrf_dfu_serial_usb: USB power detected
<info> nrf_dfu_serial_usb: USB ready
<warning> nrf_dfu_serial_usb: Could not read from CDC. Error: 0x92.
<info> nrf_dfu_validation: Signature required. Checking signature.
<info> nrf_dfu_validation: Calculating hash (len: 63)
<info> nrf_dfu_validation: Verify signature
<info> nrf_dfu_validation: Image verified
<info> app: Enter nrf_dfu_cache_prepare()
<info> app: required_size: 0xD9324.
<info> app: single_bank: false.
<info> app: keep_app: false.
<info> app: keep_softdevice: false.
<info> app: SD_PRESENT: false.
<info> app: Bank contents:
<info> app: Bank 0 code: 0x01: Size: 0xD9324
<info> app: Bank 1 code: 0x00: Size: 0x0
<info> app: pass: 0.
<info> app: cache_address: 0xDB000.
<info> app: cache_too_small: true.
<info> app: keep_firmware: false.
<info> app: delete_more: true.
<info> app: pass: 1.
<info> app: cache_address: 0x1000.
<info> app: cache_too_small: false.
<info> app: keep_firmware: true.
<info> app: delete_more: false.
<info> nrf_dfu_validation: Write address set to 0x00001000
<info> nrf_dfu_req_handler: Writing valid init command to flash.
<info> nrf_dfu_req_handler: Whole firmware image received. Postvalidating.
<info> nrf_dfu_validation: Convert to hash to big-endian format for use in nrf_crypto
<info> nrf_dfu_validation: Hash verification. start address: 0x1000, size: 0xD9324
--------------------------- Hash verification succeed -----------------------
<info> nrf_dfu_validation: Invalidating old application in bank 0.
<info> nrf_dfu_req_handler: All flash operations have completed. DFU completed.
<info> app: Resetting bootloader.
<info> app: Inside main
<info> app: Enter nrf_bootloader_fw_activate
<info> app: Valid App
<info> app: Enter nrf_dfu_app_continue
<info> app: Setting app as valid
<info> app: Resetting bootloader.
<info> app: Inside main
<info> app: Inside main

--------- But the Led Blink doesn't working --------------

RE: DFU with external QSPI memory

Hung Bui — Wed, 09 Oct 2019 14:14:10 GMT

So you have checked what written in QSPI and the last byte was not the same ? Could you check why that happens ? Note that the size of the last packet is not the same size as other packet.

RE: DFU with external QSPI memory

Mohammad — Wed, 09 Oct 2019 10:53:29 GMT

Hi Hung,

<info> nrf_dfu_serial_usb: USB power detected
<info> nrf_dfu_serial_usb: USB ready
<warning> nrf_dfu_serial_usb: Could not read from CDC. Error: 0x92.
<info> nrf_dfu_req_handler: Handle NRF_DFU_OP_RECEIPT_NOTIF_SET
<info> nrf_dfu_req_handler: Request handling complete. Result: 0x1
<info> nrf_dfu_req_handler: Handle NRF_DFU_OP_MTU_GET
<info> nrf_dfu_req_handler: Request handling complete. Result: 0x1
<info> nrf_dfu_req_handler: Handle NRF_DFU_OP_OBJECT_SELECT (command)
<info> nrf_dfu_req_handler: Request handling complete. Result: 0x1
<info> nrf_dfu_req_handler: Handle NRF_DFU_OP_OBJECT_CREATE (command)
<info> nrf_dfu_req_handler: Request handling complete. Result: 0x1
<info> nrf_dfu_req_handler: Handle NRF_DFU_OP_OBJECT_WRITE (command)
<info> nrf_dfu_req_handler: Request handling complete. Result: 0x1
<info> nrf_dfu_req_handler: Handle NRF_DFU_OP_CRC_GET (command)
<info> nrf_dfu_req_handler: Request handling complete. Result: 0x1
<info> nrf_dfu_req_handler: Handle NRF_DFU_OP_OBJECT_EXECUTE (command)
<info> nrf_dfu_validation: PB: Init packet data len: 62
<info> nrf_dfu_validation: Signature required. Checking signature.
<info> nrf_dfu_validation: Calculating hash (len: 62)
<info> nrf_dfu_validation: Verify signature
<info> nrf_dfu_validation: Image verified
<info> nrf_dfu_validation: Write address set to 0x00001000
<info> nrf_dfu_settings: Backing up settings page to address 0xFE000.
<info> nrf_dfu_req_handler: Writing valid init command to flash.
<info> nrf_dfu_req_handler: Request handling complete. Result: 0x1
<info> nrf_dfu_req_handler: Handle NRF_DFU_OP_OBJECT_SELECT (data)
<info> nrf_dfu_req_handler: crc = 0x0, offset = 0x0, max_size = 0x1000
<info> nrf_dfu_req_handler: Request handling complete. Result: 0x1
<info> nrf_dfu_req_handler: Handle NRF_DFU_OP_OBJECT_CREATE (data)
<info> nrf_dfu_req_handler: Creating object with size: 1708. Offset: 0x00000000, CRC: 0x00000000
<info> nrf_dfu_req_handler: Request handling complete. Result: 0x1
<info> nrf_dfu_req_handler: Handle NRF_DFU_OP_OBJECT_WRITE (data)

------------------------------------------QSPI write---------------------------------------
<info> nrf_dfu_req_handler: Wirting to qspi at address 0x1000 with length 0x400
<info> nrf_dfu_req_handler: Data inconsistent at location = 1023, QSPIData[1023] = 0 and Imagedata[1023] = 32
<info> nrf_dfu_req_handler: Data inconsistent, times = 1
<info> nrf_dfu_req_handler: Request handling complete. Result: 0x1
<info> nrf_dfu_req_handler: Handle NRF_DFU_OP_OBJECT_WRITE (data)
<info> nrf_dfu_req_handler: Wirting to qspi at address 0x1400 with length 0x2AC
<info> nrf_dfu_req_handler: Data inconsistent at location = 683, QSPIData[683] = 70 and Imagedata[683] = 3
<info> nrf_dfu_req_handler: Data inconsistent, times = 1

------------------------------------------------------------------------------------
<info> nrf_dfu_req_handler: Request handling complete. Result: 0x1
<info> nrf_dfu_req_handler: Handle NRF_DFU_OP_CRC_GET (data)
<info> nrf_dfu_req_handler: Offset:1708, CRC:0x4009821F
<info> nrf_dfu_req_handler: Request handling complete. Result: 0x1
<info> nrf_dfu_req_handler: Handle NRF_DFU_OP_OBJECT_EXECUTE (data)
<info> nrf_dfu_req_handler: Whole firmware image received. Postvalidating.
<info> nrf_dfu_validation: Hash verification. start address: 0x1000, size: 0x6AC
<warning> nrf_dfu_validation: Hash verification failed.
<info> nrf_dfu_validation: Expected FW hash:
<info> nrf_dfu_validation: 97 AF 3F C4 72 7B DD 8B|..?.r{..
<info> nrf_dfu_validation: 21 75 95 95 DF 47 D9 88|!u...G..
<info> nrf_dfu_validation: D1 38 7A C0 32 8C 0C E4|.8z.2...
<info> nrf_dfu_validation: 0A 11 68 6E 78 7A B3 54|..hnxz.T
<info> nrf_dfu_validation: Actual FW hash:
<info> nrf_dfu_validation: 4F 4A FE AE 1A 61 B8 CB|OJ...a..
<info> nrf_dfu_validation: 96 05 85 07 BA 8B 88 60|.......`
<info> nrf_dfu_validation: 9E C0 F7 38 11 1D C3 6A|...8...j
<info> nrf_dfu_validation: BD 04 FC 39 3C 13 BA B6|...9<...
<warning> nrf_dfu_serial: DFU request completed with result: 0xB
<info> nrf_dfu_settings: Backing up settings page to address 0xFE000.
<info> nrf_dfu_req_handler: All flash operations have completed. DFU completed.
<info> app: Resetting bootloader.
<info> nrf_dfu_settings: Backing up settings page to address 0xFE000.
<info> app: Inside main
<info> app: In nrf_bootloader_init
<info> nrf_dfu_settings: Backing up settings page to address 0xFE000.
<info> app: Enter nrf_bootloader_fw_activate
<info> app: No firmware to activate.
<info> app: Boot validation failed. No valid app to boot.
<info> app: DFU mode because app is not valid.
<info> nrf_bootloader_wdt: WDT is not enabled
<info> app: in weak nrf_dfu_init_user
<info> app: Entering DFU mode.
<info> app: Enter main loop
<info> nrf_dfu_serial_usb: USB power detected
<info> nrf_dfu_serial_usb: USB ready

This is the output from NRF_LOG. The last byte written to QSPI is not same as image received.

RE: DFU with external QSPI memory

Hung Bui — Wed, 09 Oct 2019 08:46:58 GMT

Hi Mohammad,

Yes, it's the correct place to replace the nrf_dfu_flash_store() with your qspi function.

You then need to check if the image copied to the qspi flash correctly after the image is fully transferred.

RE: DFU with external QSPI memory

Mohammad — Tue, 08 Oct 2019 14:17:36 GMT

Hi Hung,

Inside on_data_obj_write_request(), i am using ret_code_t ret = nrf_drv_qspi_write( p_req->write.p_data, p_req->write.len, write_addr) to write into QSPI instead of writing into flash.

Is that correct?