Bootloaders/DFU/BootloaderDFU.c

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