Bootloaders/DFU/BootloaderDFU.c

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