RE: Background DFU postvalidation

fhfs — Thu, 19 Sep 2019 12:30:47 GMT

Nevermind, I should not have called "background_dfu_handle_event(&dfu.bg_dfu_ctx, BACKGROUND_DFU_EVENT_TRANSFER_COMPLETE);" and run app_sched_execute in my main loop.

RE: Background DFU postvalidation

Einar Thorsrud — Thu, 19 Sep 2019 12:27:07 GMT

Hi,

I see. I need some time to look into this, but I will update you as soon as possible.

RE: Background DFU postvalidation

fhfs — Wed, 18 Sep 2019 13:43:04 GMT

Yes, nrf_dfu_validation_post_data_execute is never called which is why there is no firmware to validate. I should be seeing rtt message "Whole firmware image received. Postvalidating." from function "on_data_obj_execute_request_sched" in nrf_dfu_req_handler

SDK version 15.3.0

This is how we use the Background DFU from the application.

#include "string.h"

#include "app_scheduler.h"
#include "crc32.h"

#include "background_dfu_transport.h"
#include "background_dfu_block.h"
#include "background_dfu_transport.h"

#include "nrf_delay.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_dfu_settings.h"

#include "DFU.h"
#include "ANT.h"
#include "ANT_message_response_types.h"

#define DFU_BLOCK_SIZE 4096
#define DFU_MAX_PACKET_SIZE 29
#define DFU_BLOCK_REMAINDER (DFU_BLOCK_SIZE % DFU_MAX_PACKET_SIZE)
#define SCHED_QUEUE_SIZE				(192)
#define SCHED_MAX_EVENT_DATA_SIZE		(sizeof(nrf_dfu_request_t))                       /**< Maximum size of scheduler events. */

typedef struct
{
	uint8_t *buffer;
	uint16_t size;
	uint32_t crc;
	uint16_t index;
} dfu_init_packet_t;

typedef struct
{
	uint32_t firmware_size,  					// size in bytes
		firmware_crc,
		index,     								// bytes of update succesfully written to flash
		packet_count,
		block_number,
		block_crc;
	uint8_t *block;  			// malloced block, to be written to flash
	background_dfu_trigger_t trigger;
	background_dfu_context_t bg_dfu_ctx;  	// Background DFU context
	dfu_init_packet_t init_packet;
}background_device_firmware_update_t;

static background_device_firmware_update_t dfu;

extern response_t on_enter_bootloader(uint8_t* buffer, uint8_t len);

static int dfu_start(uint8_t *buffer, uint8_t len)
{
	uint32_t dfu_packet_address = ((buffer[0] << 16) + (buffer[1] << 8) + buffer[2]),      // first 3 bytes contain address
			init_packet_size = 0, 	// next two bytes (max 0x1000)
			init_packet_crc = 0, 	// next 4 bytes	(crc32, 4 bytes)
			firmware_size = 0, 		// next 3 bytes (firmware size max 0x100000)
			firmware_crc = 0; 		// next 4 bytes	(crc32, 4 bytes)
	
	init_packet_size = (buffer[3] << 8) + buffer[4];
	init_packet_crc = ((buffer[5] << 24) + (buffer[6] << 16) + (buffer[7] << 8) + buffer[8]);
	firmware_size = ((buffer[9] << 16) + (buffer[10] << 8) + buffer[11]);
	firmware_crc = ((buffer[12] << 24) + (buffer[13] << 16) + (buffer[14] << 8) + buffer[15]);
	
	// null check
	if(init_packet_size == 0 || init_packet_crc == 0 || firmware_size == 0 || firmware_crc == 0)
		return RESPONSE_ERROR;
	
	// initialize dfu struct to 0
	memset(&dfu, 0, sizeof(dfu));
	dfu.firmware_size = firmware_size;
	dfu.firmware_crc = firmware_crc;
	
	// set init packet struct to 0
	dfu.init_packet.size = init_packet_size;
	dfu.init_packet.buffer = malloc(init_packet_size);
	dfu.init_packet.crc = init_packet_crc;
	
	APP_SCHED_INIT(SCHED_MAX_EVENT_DATA_SIZE, SCHED_QUEUE_SIZE);
	
	return RESPONSE_SUCCESS;
}

static int dfu_init_packet(uint8_t *buffer, uint8_t len)
{
	uint16_t dfu_packet_address = ((buffer[1] << 8) + buffer[2]);      // first byte signals init packet, next 2 bytes contain address
	
	// if address + remainder is larger or equal to init packet size
	if((dfu_packet_address + (dfu.init_packet.size % DFU_MAX_PACKET_SIZE)) >= (dfu.init_packet.size))
	{
		uint8_t last_packet_remainder = dfu.init_packet.size % DFU_MAX_PACKET_SIZE;
		memcpy(dfu.init_packet.buffer + dfu.init_packet.index, buffer + 3, last_packet_remainder);
		dfu.init_packet.index += last_packet_remainder;
	}
	else //if((dfu_packet_address / DFU_MAX_PACKET_SIZE) < (dfu.init_packet.size / DFU_MAX_PACKET_SIZE))
	{
		memcpy(dfu.init_packet.buffer + dfu.init_packet.index, buffer+3, DFU_MAX_PACKET_SIZE);
		dfu.init_packet.index += DFU_MAX_PACKET_SIZE;
	}
	
	// if init packet completed 
	if (dfu.init_packet.index == dfu.init_packet.size)
	{
		dfu_init_packet_complete();
	}
}


int dfu_packet(uint8_t* buffer, uint8_t len)
{
	uint32_t dfu_packet_address = ((buffer[0] << 16) + (buffer[1] << 8) + buffer[2]),     // first 3 bytes contain address
		block_index = dfu_packet_address % DFU_BLOCK_SIZE;
	uint8_t dfu_packet_length = len - 3;
	uint32_t err_code = NRF_SUCCESS;
	
	dfu.packet_count++;     // just keeping count, may be removed
	
	// Handle init packets
	if(dfu_packet_address == 0xffffff)
	{
		dfu_start(buffer, len);
		return RESPONSE_SUCCESS;
	}
	else if(dfu_packet_address > 0xf00000 - 1)
	{
		dfu_init_packet(buffer, len);
		return RESPONSE_SUCCESS;
	}
	
	// if this is the block remainder
	if((block_index / DFU_MAX_PACKET_SIZE) == (DFU_BLOCK_SIZE / DFU_MAX_PACKET_SIZE))
	{
		// dfu_packet_address should be the same as dfu_block + block_index
		memcpy(dfu.block + block_index, buffer + 3, DFU_BLOCK_REMAINDER);
		block_index += DFU_BLOCK_REMAINDER;
		NRF_LOG_INFO("Block Remainder packet(%d) coppied to buffer at %04X", DFU_BLOCK_REMAINDER, block_index);
	}
	// Last packet of last block remainder Check
	else if(((dfu.index + block_index) / DFU_MAX_PACKET_SIZE) == (dfu.firmware_size / DFU_MAX_PACKET_SIZE))
	{
		uint8_t last_packet_remainder = (dfu.firmware_size % DFU_BLOCK_SIZE) % DFU_MAX_PACKET_SIZE;
		// dfu_packet_address should be the same as dfu_block + block_index
		memcpy(dfu.block + block_index, buffer + 3, last_packet_remainder);
		block_index += last_packet_remainder;
		NRF_LOG_INFO("Last packet(%d) coppied to buffer at %04X", last_packet_remainder, block_index);
	}
	else
	{
		// dfu_packet_address should be the same as dfu_block + block_index
		memcpy(dfu.block + block_index, buffer + 3, dfu_packet_length);
		block_index += dfu_packet_length;
	}
	
	// End of block check
	if(block_index == DFU_BLOCK_SIZE || 
		((dfu.index + block_index) == dfu.firmware_size))
	{
		// Calculate and send CRC32
		dfu.block_crc = crc32_compute(dfu.block, block_index, &dfu.block_crc);
		send_acknowledge_crc_to_beast(dfu.block_crc, (dfu_packet_address >> 12));
		
		// put block in scheduler to be written to flash
		if((err_code = dfu_process_block(dfu.block)) != BACKGROUND_DFU_BLOCK_SUCCESS)
		{
			NRF_LOG_ERROR("dfu_process_block failed (0x%X)", err_code);
			return RESPONSE_ERROR;
		}
		
		// Add processed bytes to total index
		dfu.index += block_index;
		// Reset block index
		block_index = 0;
		
		// Clear processed block
		memset(dfu.block, 0, DFU_BLOCK_SIZE);
		
		NRF_LOG_INFO("app_sched_execute %06X", dfu.index);
		// Process event 
		app_sched_execute();
		
		// flush rtt log
		NRF_LOG_FLUSH();
		if (dfu.index == dfu.firmware_size)
		{
			NRF_LOG_INFO("app_sched_execute dfu.index == dfu.firmware_size");
			// Process event 
			app_sched_execute();
			err_code = background_dfu_handle_event(&dfu.bg_dfu_ctx, BACKGROUND_DFU_EVENT_TRANSFER_COMPLETE);
			if (err_code != NRF_SUCCESS)
				return err_code;		
			NRF_LOG_FLUSH();
		}
	}
	
	return RESPONSE_SUCCESS;
}

static int dfu_init_packet_complete()
{
	uint32_t err_code = NRF_SUCCESS;
	
	// Initialize and set trigger struct
	uint32_t little = dfu.init_packet.size;
	uint32_t big = uint32_big_decode((uint8_t*)&little);
	dfu.trigger.init_length = big;       										// Initpacket size
	
	// calculate received crc32 init packet
	little = crc32_compute(dfu.init_packet.buffer, dfu.init_packet.size, NULL);
	// check calculated crc
	if (little != dfu.init_packet.crc)
	{
		NRF_LOG_ERROR("Init Packet CRC(%08X) does not match calculated CRC(%08X)", dfu.init_packet.crc, little);
		return NRF_ERROR_INVALID_DATA;
	}
	big = uint32_big_decode((uint8_t*)&little);
	dfu.trigger.init_crc = big;     											// Initpacket crc
	
	little = dfu.firmware_size;
	big = uint32_big_decode((uint8_t*)&little);
	dfu.trigger.image_length = big;      										// Firmware size
	
	little = dfu.firmware_crc;     
	big = uint32_big_decode((uint8_t*)&little);
	dfu.trigger.image_crc = big;          										// Firmware crc
	dfu.trigger.flags = 0;      												// Trigger version(1 or 0 lsh 4) and dfu flag(bit 3)
	
	// allocate block in memory
	dfu.block = malloc(DFU_BLOCK_SIZE);
	memset(dfu.block, 0, DFU_BLOCK_SIZE);
	// NULL check on malloc
	if (dfu.block == NULL)
		return NRF_ERROR_NO_MEM;
		
	// Initialize dfu settings from flash if present
	err_code = nrf_dfu_settings_init(true);
	if (err_code != NRF_SUCCESS)
		return err_code;
	
	// Initialize dfu request handler
	err_code = nrf_dfu_req_handler_init(dfu_observer);
	if (err_code != NRF_SUCCESS)
		return err_code;
	
	// Init background dfu state machine
	background_dfu_state_init(&dfu.bg_dfu_ctx);
	if (dfu.bg_dfu_ctx.dfu_state != BACKGROUND_DFU_IDLE)
	{
		NRF_LOG_WARNING("Invalid state");
		return NRF_ERROR_INVALID_STATE;
	}
	
	// Transition from DFU_IDLE to DFU_DOWNLOAD_TRIG.
	err_code = background_dfu_handle_event(&dfu.bg_dfu_ctx, BACKGROUND_DFU_EVENT_TRANSFER_COMPLETE);
	if (err_code != NRF_SUCCESS)
		return err_code;
	
	// Process events
	app_sched_execute();
				
	// Process Trigger
	if (background_dfu_validate_trigger(&dfu.bg_dfu_ctx, (uint8_t *)&dfu.trigger, sizeof(dfu.trigger)))
	{
		if (!background_dfu_process_trigger(&dfu.bg_dfu_ctx, (uint8_t *)&dfu.trigger, sizeof(dfu.trigger)))
		{
			NRF_LOG_ERROR("NRF_ERROR_INTERNAL");
			return (err_code = NRF_ERROR_INTERNAL);
		}
	}
	
	// Process events
	app_sched_execute();
	
	// Set init packet data
	memcpy(dfu.block, dfu.init_packet.buffer, dfu.init_packet.size);
	dfu_process_block(dfu.block);
	
	// reset block count for firmware
	dfu.block_number = 0;
	
	// report back CRC32
	send_acknowledge_crc_to_beast(dfu.init_packet.crc, 0);
	
	// Process events
	app_sched_execute();
	
	return err_code;
}

/**
 * @brief Pass block of retrieved data to background DFU module.
 *
 * @param[in]  p_block  Pointer to block of retrieved data.
 */
static int dfu_process_block(uint8_t *p_block)
{
	background_dfu_block_t block;
	background_dfu_block_result_t result;

	block.number = dfu.block_number;
	block.size = DFU_BLOCK_SIZE;
	block.p_payload = p_block;

	NRF_LOG_INFO("Process block %d", block.number);
	dfu.block_number++;

	result = background_dfu_process_block(&dfu.bg_dfu_ctx, &block);
	if (result != BACKGROUND_DFU_BLOCK_SUCCESS)
	{
		NRF_LOG_ERROR("Error in background_dfu_process_block (%d)", result);
	}
	return result;
}

// Background DFU required callbacks

static void dfu_observer(nrf_dfu_evt_type_t evt_type)
{
	switch (evt_type)
	{
	case NRF_DFU_EVT_DFU_COMPLETED:
        NRF_LOG_INFO("NRF_DFU_EVT_DFU_COMPLETED");
		break;

	default:
		break;
	}
}

uint32_t background_dfu_random(void)
{
	// Intentionally empty: multicast DFU not implemented.
	return 0;
}

void background_dfu_transport_block_request_send(background_dfu_context_t *p_dfu_ctx,
	background_dfu_request_bitmap_t *p_req_bmp)
{
	// Intentionally empty: multicast DFU not implemented.
}

void background_dfu_handle_error(void)
{
	NRF_LOG_ERROR("background_dfu_handle_error");
}

void background_dfu_transport_state_update(background_dfu_context_t *p_dfu_ctx)
{
	switch (p_dfu_ctx->dfu_state)
	{
	case BACKGROUND_DFU_DOWNLOAD_TRIG:
		NRF_LOG_INFO("state_update BACKGROUND_DFU_DOWNLOAD_TRIG");
		break;

	case BACKGROUND_DFU_DOWNLOAD_INIT_CMD:
		NRF_LOG_INFO("state_update BACKGROUND_DFU_DOWNLOAD_INIT_CMD");
		break;

	case BACKGROUND_DFU_DOWNLOAD_FIRMWARE:
		NRF_LOG_INFO("state_update BACKGROUND_DFU_DOWNLOAD_FIRMWARE");
		break;

	case BACKGROUND_DFU_WAIT_FOR_RESET:
	case BACKGROUND_DFU_IDLE:
		NRF_LOG_INFO("state_update BACKGROUND_DFU_WAIT_FOR_RESET or IDLE");
		break;

	default:
		NRF_LOG_WARNING("Unhandled state in background_dfu_transport_state_update (s: %s).",
			(uint32_t)background_dfu_state_to_string(p_dfu_ctx->dfu_state));
	}
}

void background_dfu_transport_send_request(background_dfu_context_t *p_dfu_ctx)
{
	switch (dfu.bg_dfu_ctx.dfu_state)
	{
	case BACKGROUND_DFU_DOWNLOAD_TRIG:
		NRF_LOG_INFO("send_request BACKGROUND_DFU_DOWNLOAD_TRIG");
		break;

	default:
		// In other states download operation is triggered by state_update() notification.
		break;
	}
}

The bootloader has no transport and is very basic just like "nRF5_SDK_15.3.0_59ac345/examples/iot/bootloader/main.c"

RE: Background DFU postvalidation

Einar Thorsrud — Wed, 18 Sep 2019 13:03:13 GMT

Hi,

"No firmware to activate" is printed from nrf_bootloader_fw_activate() when there is no firmware to activate in bank 1, according to the bootloader settings. So for some reason, the bootloader settings do not indicate a valid app.

Can you elaborate more on how your application implements DFU and how the bootloader does it? Can you share details about SDK version, examples, your code etc to show what you are doing?