Bootloaders/DFU/BootloaderDFU.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2009.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2009  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, and distribute this software
  13   and its documentation for any purpose and without fee is hereby
  14   granted, provided that the above copyright notice appear in all
  15   copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 /** \file
  32  *
  33  *  Main source file for the DFU class bootloader. This file contains the complete bootloader logic.
  34  */
  35
  36 #define  INCLUDE_FROM_BOOTLOADER_C
  37 #include "BootloaderDFU.h"
  38
  39 /** Flag to indicate if the bootloader is currently running in secure mode, disallowing memory operations
  40  *  other than erase. This is initially set to the value set by SECURE_MODE, and cleared by the bootloader
  41  *  once a memory erase has completed.
  42  */
  43 bool IsSecure      = SECURE_MODE;
  44
  45 /** Flag to indicate if the bootloader should be running, or should exit and allow the application code to run
  46  *  via a soft reset. When cleared, the bootloader will abort, the USB interface will shut down and the application
  47  *  jumped to via an indirect jump to location 0x0000 (or other location specified by the host).
  48  */
  49 bool RunBootloader = true;
  50
  51 /** Flag to indicate if the bootloader is waiting to exit. When the host requests the bootloader to exit and
  52  *  jump to the application address it specifies, it sends two sequential commands which must be properly
  53  *  acknowledged. Upon reception of the first the RunBootloader flag is cleared and the WaitForExit flag is set,
  54  *  causing the bootloader to wait for the final exit command before shutting down.
  55  */
  56 bool WaitForExit = false;
  57
  58 /** Current DFU state machine state, one of the values in the DFU_State_t enum. */
  59 uint8_t DFU_State = dfuIDLE;
  60
  61 /** Status code of the last executed DFU command. This is set to one of the values in the DFU_Status_t enum after
  62  *  each operation, and returned to the host when a Get Status DFU request is issued.
  63  */
  64 uint8_t DFU_Status = OK;
  65
  66 /** Data containing the DFU command sent from the host. */
  67 DFU_Command_t SentCommand;
  68
  69 /** Response to the last issued Read Data DFU command. Unlike other DFU commands, the read command
  70  *  requires a single byte response from the bootloader containing the read data when the next DFU_UPLOAD command
  71  *  is issued by the host.
  72  */
  73 uint8_t ResponseByte;
  74
  75 /** Pointer to the start of the user application. By default this is 0x0000 (the reset vector), however the host
  76  *  may specify an alternate address when issuing the application soft-start command.
  77  */
  78 AppPtr_t AppStartPtr = (AppPtr_t)0x0000;
  79
  80 /** 64-bit flash page number. This is concatenated with the current 16-bit address on USB AVRs containing more than
  81  *  64KB of flash memory.
  82  */
  83 uint8_t Flash64KBPage = 0;
  84
  85 /** Memory start address, indicating the current address in the memory being addressed (either FLASH or EEPROM
  86  *  depending on the issued command from the host).
  87  */
  88 uint16_t StartAddr = 0x0000;
  89
  90 /** Memory end address, indicating the end address to read to/write from in the memory being addressed (either FLASH
  91  *  of EEPROM depending on the issued command from the host).
  92  */
  93 uint16_t EndAddr = 0x0000;
  94
  95 /** Main program entry point. This routine configures the hardware required by the bootloader, then continuously
  96  *  runs the bootloader processing routine until instructed to soft-exit, or hard-reset via the watchdog to start
  97  *  the loaded application code.
  98  */
  99 int main(void)
 100 {
 101         /* Configure hardware required by the bootloader */
 102         SetupHardware();
 103
 104         /* Run the USB management task while the bootloader is supposed to be running */
 105         while (RunBootloader || WaitForExit)
 106           USB_USBTask();
 107
 108         /* Reset configured hardware back to their original states for the user application */
 109         ResetHardware();
 110
 111         /* Start the user application */
 112         AppStartPtr();
 113 }
 114
 115 /** Configures all hardware required for the bootloader. */
 116 void SetupHardware(void)
 117 {
 118         /* Disable watchdog if enabled by bootloader/fuses */
 119         MCUSR &= ~(1 << WDRF);
 120         wdt_disable();
 121
 122         /* Disable clock division */
 123         clock_prescale_set(clock_div_1);
 124
 125         /* Relocate the interrupt vector table to the bootloader section */
 126         MCUCR = (1 << IVCE);
 127         MCUCR = (1 << IVSEL);
 128
 129         /* Initialize the USB subsystem */
 130         USB_Init();
 131 }
 132
 133 /** Resets all configured hardware required for the bootloader back to their original states. */
 134 void ResetHardware(void)
 135 {
 136         /* Shut down the USB subsystem */
 137         USB_ShutDown();
 138
 139         /* Relocate the interrupt vector table back to the application section */
 140         MCUCR = (1 << IVCE);
 141         MCUCR = 0;
 142 }
 143
 144 /** Event handler for the USB_Disconnect event. This indicates that the bootloader should exit and the user
 145  *  application started.
 146  */
 147 void EVENT_USB_Disconnect(void)
 148 {
 149         /* Upon disconnection, run user application */
 150         RunBootloader = false;
 151 }
 152
 153 /** Event handler for the USB_UnhandledControlPacket event. This is used to catch standard and class specific
 154  *  control requests that are not handled internally by the USB library (including the DFU commands, which are
 155  *  all issued via the control endpoint), so that they can be handled appropriately for the application.
 156  */
 157 void EVENT_USB_UnhandledControlPacket(void)
 158 {
 159         /* Get the size of the command and data from the wLength value */
 160         SentCommand.DataSize = USB_ControlRequest.wLength;
 161
 162         switch (USB_ControlRequest.bRequest)
 163         {
 164                 case DFU_DNLOAD:
 165                         Endpoint_ClearSETUP();
 166
 167                         /* Check if bootloader is waiting to terminate */
 168                         if (WaitForExit)
 169                         {
 170                                 /* Bootloader is terminating - process last received command */
 171                                 ProcessBootloaderCommand();
 172
 173                                 /* Indicate that the last command has now been processed - free to exit bootloader */
 174                                 WaitForExit = false;
 175                         }
 176
 177                         /* If the request has a data stage, load it into the command struct */
 178                         if (SentCommand.DataSize)
 179                         {
 180                                 while (!(Endpoint_IsOUTReceived()));
 181
 182                                 /* First byte of the data stage is the DNLOAD request's command */
 183                                 SentCommand.Command = Endpoint_Read_Byte();
 184
 185                                 /* One byte of the data stage is the command, so subtract it from the total data bytes */
 186                                 SentCommand.DataSize--;
 187
 188                                 /* Load in the rest of the data stage as command parameters */
 189                                 for (uint8_t DataByte = 0; (DataByte < sizeof(SentCommand.Data)) &&
 190                                      Endpoint_BytesInEndpoint(); DataByte++)
 191                                 {
 192                                         SentCommand.Data[DataByte] = Endpoint_Read_Byte();
 193                                         SentCommand.DataSize--;
 194                                 }
 195
 196                                 /* Process the command */
 197                                 ProcessBootloaderCommand();
 198                         }
 199
 200                         /* Check if currently downloading firmware */
 201                         if (DFU_State == dfuDNLOAD_IDLE)
 202                         {
 203                                 if (!(SentCommand.DataSize))
 204                                 {
 205                                         DFU_State = dfuIDLE;
 206                                 }
 207                                 else
 208                                 {
 209                                         /* Throw away the filler bytes before the start of the firmware */
 210                                         DiscardFillerBytes(DFU_FILLER_BYTES_SIZE);
 211
 212                                         /* Throw away the page alignment filler bytes before the start of the firmware */
 213                                         DiscardFillerBytes(StartAddr % SPM_PAGESIZE);
 214
 215                                         /* Calculate the number of bytes remaining to be written */
 216                                         uint16_t BytesRemaining = ((EndAddr - StartAddr) + 1);
 217
 218                                         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))        // Write flash
 219                                         {
 220                                                 /* Calculate the number of words to be written from the number of bytes to be written */
 221                                                 uint16_t WordsRemaining = (BytesRemaining >> 1);
 222
 223                                                 union
 224                                                 {
 225                                                         uint16_t Words[2];
 226                                                         uint32_t Long;
 227                                                 } CurrFlashAddress                 = {.Words = {StartAddr, Flash64KBPage}};
 228
 229                                                 uint32_t CurrFlashPageStartAddress = CurrFlashAddress.Long;
 230                                                 uint8_t  WordsInFlashPage          = 0;
 231
 232                                                 while (WordsRemaining--)
 233                                                 {
 234                                                         /* Check if endpoint is empty - if so clear it and wait until ready for next packet */
 235                                                         if (!(Endpoint_BytesInEndpoint()))
 236                                                         {
 237                                                                 Endpoint_ClearOUT();
 238                                                                 while (!(Endpoint_IsOUTReceived()));
 239                                                         }
 240
 241                                                         /* Write the next word into the current flash page */
 242                                                         boot_page_fill(CurrFlashAddress.Long, Endpoint_Read_Word_LE());
 243
 244                                                         /* Adjust counters */
 245                                                         WordsInFlashPage      += 1;
 246                                                         CurrFlashAddress.Long += 2;
 247
 248                                                         /* See if an entire page has been written to the flash page buffer */
 249                                                         if ((WordsInFlashPage == (SPM_PAGESIZE >> 1)) || !(WordsRemaining))
 250                                                         {
 251                                                                 /* Commit the flash page to memory */
 252                                                                 boot_page_write(CurrFlashPageStartAddress);
 253                                                                 boot_spm_busy_wait();
 254
 255                                                                 /* Check if programming incomplete */
 256                                                                 if (WordsRemaining)
 257                                                                 {
 258                                                                         CurrFlashPageStartAddress = CurrFlashAddress.Long;
 259                                                                         WordsInFlashPage          = 0;
 260
 261                                                                         /* Erase next page's temp buffer */
 262                                                                         boot_page_erase(CurrFlashAddress.Long);
 263                                                                         boot_spm_busy_wait();
 264                                                                 }
 265                                                         }
 266                                                 }
 267
 268                                                 /* Once programming complete, start address equals the end address */
 269                                                 StartAddr = EndAddr;
 270
 271                                                 /* Re-enable the RWW section of flash */
 272                                                 boot_rww_enable();
 273                                         }
 274                                         else                                                   // Write EEPROM
 275                                         {
 276                                                 while (BytesRemaining--)
 277                                                 {
 278                                                         /* Check if endpoint is empty - if so clear it and wait until ready for next packet */
 279                                                         if (!(Endpoint_BytesInEndpoint()))
 280                                                         {
 281                                                                 Endpoint_ClearOUT();
 282                                                                 while (!(Endpoint_IsOUTReceived()));
 283                                                         }
 284
 285                                                         /* Read the byte from the USB interface and write to to the EEPROM */
 286                                                         eeprom_write_byte((uint8_t*)StartAddr, Endpoint_Read_Byte());
 287
 288                                                         /* Adjust counters */
 289                                                         StartAddr++;
 290                                                 }
 291                                         }
 292
 293                                         /* Throw away the currently unused DFU file suffix */
 294                                         DiscardFillerBytes(DFU_FILE_SUFFIX_SIZE);
 295                                 }
 296                         }
 297
 298                         Endpoint_ClearOUT();
 299
 300                         /* Acknowledge status stage */
 301                         while (!(Endpoint_IsINReady()));
 302                         Endpoint_ClearIN();
 303
 304                         break;
 305                 case DFU_UPLOAD:
 306                         Endpoint_ClearSETUP();
 307
 308                         while (!(Endpoint_IsINReady()));
 309
 310                         if (DFU_State != dfuUPLOAD_IDLE)
 311                         {
 312                                 if ((DFU_State == dfuERROR) && IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))       // Blank Check
 313                                 {
 314                                         /* Blank checking is performed in the DFU_DNLOAD request - if we get here we've told the host
 315                                            that the memory isn't blank, and the host is requesting the first non-blank address */
 316                                         Endpoint_Write_Word_LE(StartAddr);
 317                                 }
 318                                 else
 319                                 {
 320                                         /* Idle state upload - send response to last issued command */
 321                                         Endpoint_Write_Byte(ResponseByte);
 322                                 }
 323                         }
 324                         else
 325                         {
 326                                 /* Determine the number of bytes remaining in the current block */
 327                                 uint16_t BytesRemaining = ((EndAddr - StartAddr) + 1);
 328
 329                                 if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))            // Read FLASH
 330                                 {
 331                                         /* Calculate the number of words to be written from the number of bytes to be written */
 332                                         uint16_t WordsRemaining = (BytesRemaining >> 1);
 333
 334                                         union
 335                                         {
 336                                                 uint16_t Words[2];
 337                                                 uint32_t Long;
 338                                         } CurrFlashAddress = {.Words = {StartAddr, Flash64KBPage}};
 339
 340                                         while (WordsRemaining--)
 341                                         {
 342                                                 /* Check if endpoint is full - if so clear it and wait until ready for next packet */
 343                                                 if (Endpoint_BytesInEndpoint() == FIXED_CONTROL_ENDPOINT_SIZE)
 344                                                 {
 345                                                         Endpoint_ClearIN();
 346                                                         while (!(Endpoint_IsINReady()));
 347                                                 }
 348
 349                                                 /* Read the flash word and send it via USB to the host */
 350                                                 #if (FLASHEND > 0xFFFF)
 351                                                         Endpoint_Write_Word_LE(pgm_read_word_far(CurrFlashAddress.Long));
 352                                                 #else
 353                                                         Endpoint_Write_Word_LE(pgm_read_word(CurrFlashAddress.Long));
 354                                                 #endif
 355
 356                                                 /* Adjust counters */
 357                                                 CurrFlashAddress.Long += 2;
 358                                         }
 359
 360                                         /* Once reading is complete, start address equals the end address */
 361                                         StartAddr = EndAddr;
 362                                 }
 363                                 else if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x02))       // Read EEPROM
 364                                 {
 365                                         while (BytesRemaining--)
 366                                         {
 367                                                 /* Check if endpoint is full - if so clear it and wait until ready for next packet */
 368                                                 if (Endpoint_BytesInEndpoint() == FIXED_CONTROL_ENDPOINT_SIZE)
 369                                                 {
 370                                                         Endpoint_ClearIN();
 371                                                         while (!(Endpoint_IsINReady()));
 372                                                 }
 373
 374                                                 /* Read the EEPROM byte and send it via USB to the host */
 375                                                 Endpoint_Write_Byte(eeprom_read_byte((uint8_t*)StartAddr));
 376
 377                                                 /* Adjust counters */
 378                                                 StartAddr++;
 379                                         }
 380                                 }
 381
 382                                 /* Return to idle state */
 383                                 DFU_State = dfuIDLE;
 384                         }
 385
 386                         Endpoint_ClearIN();
 387
 388                         /* Acknowledge status stage */
 389                         while (!(Endpoint_IsOUTReceived()));
 390                         Endpoint_ClearOUT();
 391
 392                         break;
 393                 case DFU_GETSTATUS:
 394                         Endpoint_ClearSETUP();
 395
 396                         /* Write 8-bit status value */
 397                         Endpoint_Write_Byte(DFU_Status);
 398
 399                         /* Write 24-bit poll timeout value */
 400                         Endpoint_Write_Byte(0);
 401                         Endpoint_Write_Word_LE(0);
 402
 403                         /* Write 8-bit state value */
 404                         Endpoint_Write_Byte(DFU_State);
 405
 406                         /* Write 8-bit state string ID number */
 407                         Endpoint_Write_Byte(0);
 408
 409                         Endpoint_ClearIN();
 410
 411                         /* Acknowledge status stage */
 412                         while (!(Endpoint_IsOUTReceived()));
 413                         Endpoint_ClearOUT();
 414
 415                         break;
 416                 case DFU_CLRSTATUS:
 417                         Endpoint_ClearSETUP();
 418
 419                         /* Reset the status value variable to the default OK status */
 420                         DFU_Status = OK;
 421
 422                         /* Acknowledge status stage */
 423                         while (!(Endpoint_IsINReady()));
 424                         Endpoint_ClearIN();
 425
 426                         break;
 427                 case DFU_GETSTATE:
 428                         Endpoint_ClearSETUP();
 429
 430                         /* Write the current device state to the endpoint */
 431                         Endpoint_Write_Byte(DFU_State);
 432
 433                         Endpoint_ClearIN();
 434
 435                         /* Acknowledge status stage */
 436                         while (!(Endpoint_IsOUTReceived()));
 437                         Endpoint_ClearOUT();
 438
 439                         break;
 440                 case DFU_ABORT:
 441                         Endpoint_ClearSETUP();
 442
 443                         /* Reset the current state variable to the default idle state */
 444                         DFU_State = dfuIDLE;
 445
 446                         /* Acknowledge status stage */
 447                         while (!(Endpoint_IsINReady()));
 448                         Endpoint_ClearIN();
 449
 450                         break;
 451         }
 452 }
 453
 454 /** Routine to discard the specified number of bytes from the control endpoint stream. This is used to
 455  *  discard unused bytes in the stream from the host, including the memory program block suffix.
 456  *
 457  *  \param[in] NumberOfBytes  Number of bytes to discard from the host from the control endpoint
 458  */
 459 static void DiscardFillerBytes(uint8_t NumberOfBytes)
 460 {
 461         while (NumberOfBytes--)
 462         {
 463                 if (!(Endpoint_BytesInEndpoint()))
 464                 {
 465                         Endpoint_ClearOUT();
 466
 467                         /* Wait until next data packet received */
 468                         while (!(Endpoint_IsOUTReceived()));
 469                 }
 470                 else
 471                 {
 472                         Endpoint_Discard_Byte();
 473                 }
 474         }
 475 }
 476
 477 /** Routine to process an issued command from the host, via a DFU_DNLOAD request wrapper. This routine ensures
 478  *  that the command is allowed based on the current secure mode flag value, and passes the command off to the
 479  *  appropriate handler function.
 480  */
 481 static void ProcessBootloaderCommand(void)
 482 {
 483         /* Check if device is in secure mode */
 484         if (IsSecure)
 485         {
 486                 /* Don't process command unless it is a READ or chip erase command */
 487                 if (!(((SentCommand.Command == COMMAND_WRITE)             &&
 488                         IS_TWOBYTE_COMMAND(SentCommand.Data, 0x00, 0xFF)) ||
 489                            (SentCommand.Command == COMMAND_READ)))
 490                 {
 491                         /* Set the state and status variables to indicate the error */
 492                         DFU_State  = dfuERROR;
 493                         DFU_Status = errWRITE;
 494
 495                         /* Stall command */
 496                         Endpoint_StallTransaction();
 497
 498                         /* Don't process the command */
 499                         return;
 500                 }
 501         }
 502
 503         /* Dispatch the required command processing routine based on the command type */
 504         switch (SentCommand.Command)
 505         {
 506                 case COMMAND_PROG_START:
 507                         ProcessMemProgCommand();
 508                         break;
 509                 case COMMAND_DISP_DATA:
 510                         ProcessMemReadCommand();
 511                         break;
 512                 case COMMAND_WRITE:
 513                         ProcessWriteCommand();
 514                         break;
 515                 case COMMAND_READ:
 516                         ProcessReadCommand();
 517                         break;
 518                 case COMMAND_CHANGE_BASE_ADDR:
 519                         if (IS_TWOBYTE_COMMAND(SentCommand.Data, 0x03, 0x00))              // Set 64KB flash page command
 520                           Flash64KBPage = SentCommand.Data[2];
 521
 522                         break;
 523         }
 524 }
 525
 526 /** Routine to concatenate the given pair of 16-bit memory start and end addresses from the host, and store them
 527  *  in the StartAddr and EndAddr global variables.
 528  */
 529 static void LoadStartEndAddresses(void)
 530 {
 531         union
 532         {
 533                 uint8_t  Bytes[2];
 534                 uint16_t Word;
 535         } Address[2] = {{.Bytes = {SentCommand.Data[2], SentCommand.Data[1]}},
 536                         {.Bytes = {SentCommand.Data[4], SentCommand.Data[3]}}};
 537
 538         /* Load in the start and ending read addresses from the sent data packet */
 539         StartAddr = Address[0].Word;
 540         EndAddr   = Address[1].Word;
 541 }
 542
 543 /** Handler for a Memory Program command issued by the host. This routine handles the preparations needed
 544  *  to write subsequent data from the host into the specified memory.
 545  */
 546 static void ProcessMemProgCommand(void)
 547 {
 548         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00) ||                          // Write FLASH command
 549             IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))                            // Write EEPROM command
 550         {
 551                 /* Load in the start and ending read addresses */
 552                 LoadStartEndAddresses();
 553
 554                 /* If FLASH is being written to, we need to pre-erase the first page to write to */
 555                 if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))
 556                 {
 557                         union
 558                         {
 559                                 uint16_t Words[2];
 560                                 uint32_t Long;
 561                         } CurrFlashAddress = {.Words = {StartAddr, Flash64KBPage}};
 562
 563                         /* Erase the current page's temp buffer */
 564                         boot_page_erase(CurrFlashAddress.Long);
 565                         boot_spm_busy_wait();
 566                 }
 567
 568                 /* Set the state so that the next DNLOAD requests reads in the firmware */
 569                 DFU_State = dfuDNLOAD_IDLE;
 570         }
 571 }
 572
 573 /** Handler for a Memory Read command issued by the host. This routine handles the preparations needed
 574  *  to read subsequent data from the specified memory out to the host, as well as implementing the memory
 575  *  blank check command.
 576  */
 577 static void ProcessMemReadCommand(void)
 578 {
 579         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00) ||                          // Read FLASH command
 580         IS_ONEBYTE_COMMAND(SentCommand.Data, 0x02))                            // Read EEPROM command
 581         {
 582                 /* Load in the start and ending read addresses */
 583                 LoadStartEndAddresses();
 584
 585                 /* Set the state so that the next UPLOAD requests read out the firmware */
 586                 DFU_State = dfuUPLOAD_IDLE;
 587         }
 588         else if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))                       // Blank check FLASH command
 589         {
 590                 uint32_t CurrFlashAddress = 0;
 591
 592                 while (CurrFlashAddress < BOOT_START_ADDR)
 593                 {
 594                         /* Check if the current byte is not blank */
 595                         #if (FLASHEND > 0xFFFF)
 596                         if (pgm_read_byte_far(CurrFlashAddress) != 0xFF)
 597                         #else
 598                         if (pgm_read_byte(CurrFlashAddress) != 0xFF)
 599                         #endif
 600                         {
 601                                 /* Save the location of the first non-blank byte for response back to the host */
 602                                 Flash64KBPage = (CurrFlashAddress >> 16);
 603                                 StartAddr     = CurrFlashAddress;
 604
 605                                 /* Set state and status variables to the appropriate error values */
 606                                 DFU_State  = dfuERROR;
 607                                 DFU_Status = errCHECK_ERASED;
 608
 609                                 break;
 610                         }
 611
 612                         CurrFlashAddress++;
 613                 }
 614         }
 615 }
 616
 617 /** Handler for a Data Write command issued by the host. This routine handles non-programming commands such as
 618  *  bootloader exit (both via software jumps and hardware watchdog resets) and flash memory erasure.
 619  */
 620 static void ProcessWriteCommand(void)
 621 {
 622         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x03))                            // Start application
 623         {
 624                 /* Indicate that the bootloader is terminating */
 625                 WaitForExit = true;
 626
 627                 /* Check if empty request data array - an empty request after a filled request retains the
 628                    previous valid request data, but initializes the reset */
 629                 if (!(SentCommand.DataSize))
 630                 {
 631                         if (SentCommand.Data[1] == 0x00)                                   // Start via watchdog
 632                         {
 633                                 /* Start the watchdog to reset the AVR once the communications are finalized */
 634                                 wdt_enable(WDTO_250MS);
 635                         }
 636                         else                                                               // Start via jump
 637                         {
 638                                 /* Load in the jump address into the application start address pointer */
 639                                 union
 640                                 {
 641                                         uint8_t  Bytes[2];
 642                                         AppPtr_t FuncPtr;
 643                                 } Address = {.Bytes = {SentCommand.Data[4], SentCommand.Data[3]}};
 644
 645                                 AppStartPtr = Address.FuncPtr;
 646
 647                                 /* Set the flag to terminate the bootloader at next opportunity */
 648                                 RunBootloader = false;
 649                         }
 650                 }
 651         }
 652         else if (IS_TWOBYTE_COMMAND(SentCommand.Data, 0x00, 0xFF))                 // Erase flash
 653         {
 654                 uint32_t CurrFlashAddress = 0;
 655
 656                 /* Clear the application section of flash */
 657                 while (CurrFlashAddress < BOOT_START_ADDR)
 658                 {
 659                         boot_page_erase(CurrFlashAddress);
 660                         boot_spm_busy_wait();
 661                         boot_page_write(CurrFlashAddress);
 662                         boot_spm_busy_wait();
 663
 664                         CurrFlashAddress += SPM_PAGESIZE;
 665                 }
 666
 667                 /* Re-enable the RWW section of flash as writing to the flash locks it out */
 668                 boot_rww_enable();
 669
 670                 /* Memory has been erased, reset the security bit so that programming/reading is allowed */
 671                 IsSecure = false;
 672         }
 673 }
 674
 675 /** Handler for a Data Read command issued by the host. This routine handles bootloader information retrieval
 676  *  commands such as device signature and bootloader version retrieval.
 677  */
 678 static void ProcessReadCommand(void)
 679 {
 680         const uint8_t BootloaderInfo[3] = {BOOTLOADER_VERSION, BOOTLOADER_ID_BYTE1, BOOTLOADER_ID_BYTE2};
 681         const uint8_t SignatureInfo[3]  = {AVR_SIGNATURE_1,    AVR_SIGNATURE_2,     AVR_SIGNATURE_3};
 682
 683         uint8_t DataIndexToRead = SentCommand.Data[1];
 684
 685         if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x00))                         // Read bootloader info
 686         {
 687                 ResponseByte = BootloaderInfo[DataIndexToRead];
 688         }
 689         else if (IS_ONEBYTE_COMMAND(SentCommand.Data, 0x01))                    // Read signature byte
 690         {
 691                 ResponseByte = SignatureInfo[DataIndexToRead - 0x30];
 692         }
 693 }