Bootloaders/DFU/BootloaderDFU.c

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