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