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