Bootloaders/DFU/BootloaderDFU.c

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