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