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