Bootloaders/DFU/BootloaderDFU.c

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