Bootloaders/DFU/BootloaderDFU.c

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