UCD3138064: bootloader to app question

Hi Jonathan,

I appreciate your quick response!

Okay, I roughly understand your point about performing the jump under a software interrupt. I've written the JumpToAPP function within the software interrupt handler. Perhaps I didn’t explain my issue clearly earlier. My main question is: ​Does the code below actually achieve the jump functionality? Additionally, the APP size is ​53KB, which seems too large for on-the-fly updates. Could you review this?

#include "cyclone_device.h"
//#include "user_define.h"
#include "system_defines.h"
#include "pmbus_commands.h"
#include "pmbus_common.h"
#include "variables.h"
#include "function_definitions.h"
#include "software_interrupts.h"


extern Uint32 zero_out_integrity_word_start[32];
extern Uint32 clear_program_flash_1_start[32];
extern Uint32 write_word_1st_pflash_block_start[32];
extern void zero_out_integrity_word(void);
#pragma DATA_SECTION(program_area, ".ram_for_program_area")
Uint32 program_area[32]; // small RAM area for storing programs which modify program flashes





#pragma INTERRUPT(undefined_instruction_exception,UDEF)
void undefined_instruction_exception(void)
{
}

#pragma INTERRUPT(software_interrupt,SWI)
void software_interrupt(Uint32 arg1, Uint32 arg2, Uint32 arg3, Uint8 swi_number)
 //void software_interrupt(Uint32 *address, Uint32 data, Uint32 more_data, Uint8 swi_number)
{
	//make sure interrupts are disabled
	asm(" STMFD   SP!, {R4} "); //Store R4
    asm(" MRS     r4, cpsr "); 		// get psr
    asm(" ORR     r4, r4, #0xc0 "); // set interrupt disables
    asm(" MSR     cpsr_cf, r4"); 	// restore psr
    asm(" LDMFD   SP!, {R4}  ");    //Restore R4 

	switch (swi_number) //handle flash write/erase and ROM backdoor first
	{
	case 0: 
		//--------------------------------------------------------------------------------------
		// SWI ALIAS: erase_data_flash_segment()
		// 	Erases one segment of Data Flash and wait for erase to complete.
		//--------------------------------------------------------------------------------------
	case 1: 	
		//--------------------------------------------------------------------------------------
		// SWI ALIAS: erase_dflash_segment_no_delay()
		// 	Erase one segment of Data Flash and return without waiting for completion.
		//--------------------------------------------------------------------------------------
		{
			union DFLASHCTRL_REG dflashctrl_shadow;	// Shadow copy of control register

			if (arg1 >= DATA_FLASH_NUM_SEGMENTS)	
			{
				return;		// Invalid segment number
			}
			DecRegs.FLASHILOCK.all = DFlash_Lock_Key;//0x42DC157E; //unlock flash write;
			// Set the bits in the Data Flash Control Register to erase the indicated segment
			dflashctrl_shadow.all = DecRegs.DFLASHCTRL.all;	// Read the hardware register
			dflashctrl_shadow.bit.PAGE_ERASE = 1; 			// Erase one segment
			dflashctrl_shadow.bit.PAGE_SEL = arg1;		// Segment number
			DecRegs.DFLASHCTRL.all = dflashctrl_shadow.all;	// Write the hardware register
			if (swi_number == 1)	// 0= Wait for erase to complete, 1= return immediately
			{
				return;
			}
			while(DecRegs.DFLASHCTRL.bit.BUSY != 0)
			{
				; //do nothing while it programs
			}
			return;

		}
	case 3: //write word to data flash
	{
		union  MFBALRX_REG mfbalr_shadow;

		if(((arg1) < DATA_FLASH_START_ADDRESS) ||
			((arg1) > DATA_FLASH_END_ADDRESS))
		{//if out of data flash range
			return;
		}

		//this clears read only bit to permit writes to data flash.
		DecRegs.FLASHILOCK.all = DFlash_Lock_Key;//0x42DC157E; //unlock flash write

		// Clear read-only bit to allow writes to Data Flash.
		mfbalr_shadow.all = DecRegs.MFBALR2.all;
		mfbalr_shadow.bit.BLOCK_SIZE =2;
		mfbalr_shadow.bit.ADDRESS = 0x22;
		mfbalr_shadow.bit.RONLY = 0;
	    DecRegs.MFBALR2.all = mfbalr_shadow.all; //enable program flash write


		//put data in word.
		*(Uint32 *)(arg1 & 0xfffffffc) = arg2 ;

		//Set RONLY bit to protect dataflash
		mfbalr_shadow.all = DecRegs.MFBALR2.all;
		mfbalr_shadow.bit.RONLY = 1;
	    DecRegs.MFBALR2.all = mfbalr_shadow.all; //enable program flash write

		while(DecRegs.DFLASHCTRL.bit.BUSY != 0)
		{
			; //do nothing while it programs
		}
		return;
	}

		//handle interrupt enables/disables next
	case 4: //enable fiq
		asm(" MRS     r0, spsr "); //get saved psr
		asm(" BIC     r0, r0, #0x40 "); // clear fiq disable
		asm(" MSR     spsr, r0"); //restore saved psr
		return;
	case 5: //disable fiq
		asm(" MRS     r0, spsr "); //get saved psr
		asm(" ORR     r0, r0, #0x40 "); // set fiq disable
		asm(" MSR     spsr, r0"); //restore saved psr
		return;
	case 6: //enable irq
		asm(" MRS     r0, spsr "); //get saved psr
		asm(" BIC     r0, r0, #0x80 "); // clear irq disable
		asm(" MSR     spsr, r0"); //restore saved psr
		return;
	case 7: //disable irq
		asm(" MRS     r0, spsr "); //get saved psr
		asm(" ORR     r0, r0, #0x80 "); // set irq disable
		asm(" MSR     spsr, r0"); //restore saved psr
		return;
	case 8: //write to fiq/irq program_control_register
		CimRegs.FIRQPR.all = arg1;
		return;
	case 9: //write to fiq/irq program_control_register
		CimRegs.REQMASK.all = arg1;
		return;
	case 10: // switch to supervisor mode
		asm(" MRS     r0, spsr "); //get saved psr
		asm(" BIC	  r0, r0, #0x1F "); // clear 5 lsbs.
		asm(" ORR     r0, r0, #0x13 "); // set mode bits to 13.
		asm(" MSR     spsr, r0"); //restore saved psr
		return;
	case 11: // switch to user mode
		asm(" MRS     r0, spsr "); //get saved psr
		asm(" BIC	  r0, r0, #0x1F "); // clear 5 lsbs.
		asm(" ORR     r0, r0, #0x10 "); // set mode bits to 10.
		asm(" MSR     spsr, r0"); //restore saved psr
		return;
	case 12: // clear integrity word.
		{
		    register  Uint32  *  program_index  =  (Uint32  *)  program_area;
		                //store destination address for program
            register  Uint32  *  source_index  =  (Uint32  *) zero_out_integrity_word_start;  //Used  for  source  address  of PFLASH;
            register Uint32 counter;

            union  MFBALRX_REG mfbalr_shadow;
            mfbalr_shadow.all = DecRegs.MFBALR17.all;
            mfbalr_shadow.bit.RONLY = 0;
            DecRegs.MFBALR17.all = mfbalr_shadow.all; //enable program flash write

            for(counter=0;  counter  <  84;  counter++)  //Copy  program  from PFLASH to RAM
            {
                *(program_index++)=*(source_index++);
            }

            zero_out_integrity_word();
		                return;
		}
	case 13: //write block to data flash
		//--------------------------------------------------------------------------------------
		// SWI ALIAS: write_data_flash_block()
		// 	Copies a block of data from a source (typically RAM) to a destination in Data Flash.
		// Handles locking and unlocking the read-only bit.
		// Includes necessary delays while writing.
		// Assumptions:  
		//	Destination address is in Data Flash.
		//	Destination addresses start and end on word boundary.
		//	Source addresses start and end on word boundaries.
		//--------------------------------------------------------------------------------------
		{
			volatile Uint32* dest_ptr = (volatile Uint32*)(arg1 & 0xfffffffc);
			Uint32*	src_ptr =  (Uint32*)(arg2);
			int32	byte_counter = (int32)arg3;	// Use int instead of Uint in case count is not a multiple of 4

			union  MFBALRX_REG mfbalr_shadow;

			// Validate that destination address is in Data Flash
			if(  ((arg1) < DATA_FLASH_START_ADDRESS)
				||((arg1) > DATA_FLASH_END_ADDRESS)  )
			{//if out of data flash range
				flash_write_status = FLASH_INVALID_ADDRESS;
				return;	// Return without writing to DFlash
			}

			// Clear read-only bit to allow writes to Data Flash.
			mfbalr_shadow.all = DecRegs.MFBALR2.all;
			mfbalr_shadow.bit.RONLY = 0;
		    DecRegs.MFBALR2.all = mfbalr_shadow.all; //enable program flash write

			// Copy a block of RAM to DFlash						     
			while (byte_counter > 0)
			{
				Uint32	temp_word = *src_ptr++;
				DecRegs.FLASHILOCK.all = DFlash_Lock_Key;//0x42DC157E; //unlock flash write
				// Write the temp word to DFlash.
				*dest_ptr = temp_word;

				// *** Should add value to checksum.
				// checksum += temp.word;

				// Wait for any previous writes to complete.
				while(DecRegs.DFLASHCTRL.bit.BUSY != 0)
				{
					; //do nothing while it programs
				}

				// Read back value from DFlash. Abort if it does not match intended value.
				if (*dest_ptr != temp_word)
				{
					// Set an error flag to indicate write failure.
					flash_write_status = FLASH_MISCOMPARE;
					return;	
				}

				dest_ptr++;
				byte_counter -= 4;
			}

			// Set read-only bit to protect Data Flash
			mfbalr_shadow.all = DecRegs.MFBALR2.all;
			mfbalr_shadow.bit.RONLY = 1;
		    DecRegs.MFBALR2.all = mfbalr_shadow.all; 
			flash_write_status = FLASH_SUCCESS;
			return;
		}
	case 14: // erase entire Program Flash
		{
		   register  Uint32  *  program_index  =  (Uint32  *)  program_area;
		                           //store destination address for program
           register  Uint32  *  source_index  =  (Uint32  *) clear_program_flash_1_start;  //Used  for  source  address  of PFLASH;
           register Uint32 counter;

           union  MFBALRX_REG mfbalr_shadow;
           mfbalr_shadow.all = DecRegs.MFBALR17.all;
           mfbalr_shadow.bit.RONLY = 0;
           DecRegs.MFBALR17.all = mfbalr_shadow.all; //enable program flash write

           for(counter=0;  counter  <  84;  counter++)  //Copy  program  from PFLASH to RAM
           {
               *(program_index++)=*(source_index++);
           }

			clear_program_flash_1();

			return;
		}
	case 15:
	   {   Uint8 j;
	       for(j=0;j<(FWdataCnt-1);)
            {

             pflash_write_data.uc[0]=FWupdata[j++];
             pflash_write_data.uc[1]=FWupdata[j++];
             pflash_write_data.uc[2]=FWupdata[j++];
             pflash_write_data.uc[3]=FWupdata[j++];


	         if(FlashDestAdress<0x00008000)
	          {
	            register  Uint32  *  program_index  =  (Uint32  *)  program_area;
	                                      //store destination address for program
                register  Uint32  *  source_index  =  (Uint32  *) write_word_1st_pflash_block_start;  //Used  for  source  address  of PFLASH;
                register Uint32 counter;

                union  MFBALRX_REG mfbalr_shadow;
                mfbalr_shadow.all = DecRegs.MFBALR17.all;
                mfbalr_shadow.bit.RONLY = 0;
                DecRegs.MFBALR17.all = mfbalr_shadow.all; //enable program flash write

                for(counter=0;  counter  <  52;  counter++)  //Copy  program  from PFLASH to RAM
                 {
                  *(program_index++)=*(source_index++);
                 }

	            write_word_1st_pflash_block();
	          }
	        else if(FlashDestAdress<0x0000fffC)
	         {
	           DecRegs.FLASHILOCK.all =  PROGRAM_FLASH2_INTERLOCK_KEY;
	           *((volatile unsigned long *)FlashDestAdress) = pflash_write_data.ul;
	           while((DecRegs.PFLASHCTRL2.bit.BUSY != 0))
	                  {
	                                ; //do nothing while it programs
	                  }

	          }
	       FlashDestAdress+=4;

            }
	       return;

	   }

		case 99:
		{
		    typedef void (*AppEntry)(void);
		    AppEntry app_entry = (AppEntry)(*(volatile Uint32*)FLASHPROGRAMBASE);

		    //jump to app
		    app_entry();

		}
		/*****************************************************************************************************/
	default:
		break;
	}
}
#pragma INTERRUPT(abort_prefetch_exception,PABT)
void abort_prefetch_exception(void)
{
}

#pragma INTERRUPT(abort_data_fetch_exception,DABT)
void abort_data_fetch_exception(void)
{
}


#pragma INTERRUPT(fast_interrupt,FIQ)
void fast_interrupt(void)
{
}

Hello Rex,

I will provide a response by the end of the week.

Regards,

Jonathan Wong

Hello Rex,

Have you see our On-the-fly update example for UCD3138064? Below is an article by Ian Bower that demonstrates the steps. If you are interested in the code, then let me know.

On-the-fly power supply firmware upgrades.docx

The UCD3138064 only has 64kB of program flash. If my understanding is correct, then you are not switching between two programs, but just going from boot ROM to the APP?

Regards,

Jonathan Wong

Hello Jonathan,

Yes, due to capacity constraints, I don’t need on-the-fly functionality. My current issue is that the bootloader fails to work properly after jumping to the APP. So, my question is: Is my jump code correct? If convenient, you can share your on-the-fly code with me, as it includes the jump logic. This will help me deepen my understanding of the UCD3138 jump mechanism!Thank you!

Thanks for your help, I have cloesed this issue.