Bootloaders/CDC/BootloaderCDC.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 CDC class bootloader. This file contains the complete bootloader logic.
  34  */
  35
  36 #define  INCLUDE_FROM_BOOTLOADERCDC_C
  37 #include "BootloaderCDC.h"
  38
  39 /** Contains the current baud rate and other settings of the first virtual serial port. This must be retained as some
  40  *  operating systems will not open the port unless the settings can be set successfully.
  41  */
  42 static CDC_LineEncoding_t LineEncoding = { .BaudRateBPS = 0,
  43                                            .CharFormat  = CDC_LINEENCODING_OneStopBit,
  44                                            .ParityType  = CDC_PARITY_None,
  45                                            .DataBits    = 8                            };
  46
  47 /** Current address counter. This stores the current address of the FLASH or EEPROM as set by the host,
  48  *  and is used when reading or writing to the AVRs memory (either FLASH or EEPROM depending on the issued
  49  *  command.)
  50  */
  51 static uint32_t CurrAddress;
  52
  53 /** Flag to indicate if the bootloader should be running, or should exit and allow the application code to run
  54  *  via a watchdog reset. When cleared the bootloader will exit, starting the watchdog and entering an infinite
  55  *  loop until the AVR restarts and the application runs.
  56  */
  57 static bool RunBootloader = true;
  58
  59 /** Magic lock for forced application start. If the HWBE fuse is programmed and BOOTRST is unprogrammed, the bootloader
  60  *  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
  61  *  low when the application attempts to start via a watchdog reset, the bootloader will re-start. If set to the value
  62  *  \ref MAGIC_BOOT_KEY the special init function \ref Application_Jump_Check() will force the application to start.
  63  */
  64 uint16_t MagicBootKey ATTR_NO_INIT;
  65
  66
  67 /** Special startup routine to check if the bootloader was started via a watchdog reset, and if the magic application
  68  *  start key has been loaded into \ref MagicBootKey. If the bootloader started via the watchdog and the key is valid,
  69  *  this will force the user application to start via a software jump.
  70  */
  71 void Application_Jump_Check(void)
  72 {
  73         bool JumpToApplication = false;
  74
  75         #if (BOARD == BOARD_LEONARDO)
  76                 /* Enable pull-up on the IO13 pin so we can use it to select the mode */
  77                 PORTC |= (1 << 7);
  78                 Delay_MS(10);
  79
  80                 /* If IO13 is not jumpered to ground, start the user application instead */
  81                 JumpToApplication = ((PINC & (1 << 7)) != 0);
  82
  83                 /* Disable pull-up after the check has completed */
  84                 PORTC &= ~(1 << 7);
  85         #elif ((BOARD == BOARD_XPLAIN) || (BOARD == BOARD_XPLAIN_REV1))
  86                 /* Disable JTAG debugging */
  87                 JTAG_DISABLE();
  88
  89                 /* Enable pull-up on the JTAG TCK pin so we can use it to select the mode */
  90                 PORTF |= (1 << 4);
  91                 Delay_MS(10);
  92
  93                 /* If the TCK pin is not jumpered to ground, start the user application instead */
  94                 JumpToApplication = ((PINF & (1 << 4)) != 0);
  95
  96                 /* Re-enable JTAG debugging */
  97                 JTAG_ENABLE();
  98         #else
  99                 /* Check if the device's BOOTRST fuse is set */
 100                 if (boot_lock_fuse_bits_get(GET_HIGH_FUSE_BITS) & FUSE_BOOTRST)
 101                 {
 102                         /* If the reset source was not an external reset or the key is correct, clear it and jump to the application */
 103                         if (!(MCUSR & (1 << EXTRF)) || (MagicBootKey == MAGIC_BOOT_KEY))
 104                           JumpToApplication = true;
 105
 106                         /* Clear reset source */
 107                         MCUSR &= ~(1 << EXTRF);
 108                 }
 109                 else
 110                 {
 111                         /* If the reset source was the bootloader and the key is correct, clear it and jump to the application;
 112                          * this can happen in the HWBE fuse is set, and the HBE pin is low during the watchdog reset */
 113                         if ((MCUSR & (1 << WDRF)) && (MagicBootKey == MAGIC_BOOT_KEY))
 114                                 JumpToApplication = true;
 115
 116                         /* Clear reset source */
 117                         MCUSR &= ~(1 << WDRF);
 118                 }
 119         #endif
 120
 121         /* Don't run the user application if the reset vector is blank (no app loaded) */
 122         bool ApplicationValid = (pgm_read_word_near(0) != 0xFFFF);
 123
 124         /* If a request has been made to jump to the user application, honor it */
 125         if (JumpToApplication && ApplicationValid)
 126         {
 127                 /* Turn off the watchdog */
 128                 MCUSR &= ~(1 << WDRF);
 129                 wdt_disable();
 130
 131                 /* Clear the boot key and jump to the user application */
 132                 MagicBootKey = 0;
 133
 134                 // cppcheck-suppress constStatement
 135                 ((void (*)(void))0x0000)();
 136         }
 137 }
 138
 139 /** Main program entry point. This routine configures the hardware required by the bootloader, then continuously
 140  *  runs the bootloader processing routine until instructed to soft-exit, or hard-reset via the watchdog to start
 141  *  the loaded application code.
 142  */
 143 int main(void)
 144 {
 145         /* Setup hardware required for the bootloader */
 146         SetupHardware();
 147
 148         /* Turn on first LED on the board to indicate that the bootloader has started */
 149         LEDs_SetAllLEDs(LEDS_LED1);
 150
 151         /* Enable global interrupts so that the USB stack can function */
 152         GlobalInterruptEnable();
 153
 154         while (RunBootloader)
 155         {
 156                 CDC_Task();
 157                 USB_USBTask();
 158         }
 159
 160         /* Wait a short time to end all USB transactions and then disconnect */
 161         _delay_us(1000);
 162
 163         /* Disconnect from the host - USB interface will be reset later along with the AVR */
 164         USB_Detach();
 165
 166         /* Unlock the forced application start mode of the bootloader if it is restarted */
 167         MagicBootKey = MAGIC_BOOT_KEY;
 168
 169         /* Enable the watchdog and force a timeout to reset the AVR */
 170         wdt_enable(WDTO_250MS);
 171
 172         for (;;);
 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 /** ISR to periodically toggle the LEDs on the board to indicate that the bootloader is active. */
 199 ISR(TIMER1_OVF_vect, ISR_BLOCK)
 200 {
 201         LEDs_ToggleLEDs(LEDS_LED1 | LEDS_LED2);
 202 }
 203
 204 /** Event handler for the USB_ConfigurationChanged event. This configures the device's endpoints ready
 205  *  to relay data to and from the attached USB host.
 206  */
 207 void EVENT_USB_Device_ConfigurationChanged(void)
 208 {
 209         /* Setup CDC Notification, Rx and Tx Endpoints */
 210         Endpoint_ConfigureEndpoint(CDC_NOTIFICATION_EPADDR, EP_TYPE_INTERRUPT,
 211                                    CDC_NOTIFICATION_EPSIZE, 1);
 212
 213         Endpoint_ConfigureEndpoint(CDC_TX_EPADDR, EP_TYPE_BULK, CDC_TXRX_EPSIZE, 1);
 214
 215         Endpoint_ConfigureEndpoint(CDC_RX_EPADDR, EP_TYPE_BULK, CDC_TXRX_EPSIZE, 1);
 216 }
 217
 218 /** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
 219  *  the device from the USB host before passing along unhandled control requests to the library for processing
 220  *  internally.
 221  */
 222 void EVENT_USB_Device_ControlRequest(void)
 223 {
 224         /* Ignore any requests that aren't directed to the CDC interface */
 225         if ((USB_ControlRequest.bmRequestType & (CONTROL_REQTYPE_TYPE | CONTROL_REQTYPE_RECIPIENT)) !=
 226             (REQTYPE_CLASS | REQREC_INTERFACE))
 227         {
 228                 return;
 229         }
 230
 231         /* Activity - toggle indicator LEDs */
 232         LEDs_ToggleLEDs(LEDS_LED1 | LEDS_LED2);
 233
 234         /* Process CDC specific control requests */
 235         switch (USB_ControlRequest.bRequest)
 236         {
 237                 case CDC_REQ_GetLineEncoding:
 238                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 239                         {
 240                                 Endpoint_ClearSETUP();
 241
 242                                 /* Write the line coding data to the control endpoint */
 243                                 Endpoint_Write_Control_Stream_LE(&LineEncoding, sizeof(CDC_LineEncoding_t));
 244                                 Endpoint_ClearOUT();
 245                         }
 246
 247                         break;
 248                 case CDC_REQ_SetLineEncoding:
 249                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 250                         {
 251                                 Endpoint_ClearSETUP();
 252
 253                                 /* Read the line coding data in from the host into the global struct */
 254                                 Endpoint_Read_Control_Stream_LE(&LineEncoding, sizeof(CDC_LineEncoding_t));
 255                                 Endpoint_ClearIN();
 256                         }
 257
 258                         break;
 259         case CDC_REQ_SetControlLineState:
 260                 if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 261                 {
 262                     Endpoint_ClearSETUP();
 263                     Endpoint_ClearStatusStage();
 264                 }
 265
 266                 break;
 267         }
 268 }
 269
 270 #if !defined(NO_BLOCK_SUPPORT)
 271 /** Reads or writes a block of EEPROM or FLASH memory to or from the appropriate CDC data endpoint, depending
 272  *  on the AVR109 protocol command issued.
 273  *
 274  *  \param[in] Command  Single character AVR109 protocol command indicating what memory operation to perform
 275  */
 276 static void ReadWriteMemoryBlock(const uint8_t Command)
 277 {
 278         uint16_t BlockSize;
 279         char     MemoryType;
 280
 281         uint8_t  HighByte = 0;
 282         uint8_t  LowByte  = 0;
 283
 284         BlockSize  = (FetchNextCommandByte() << 8);
 285         BlockSize |=  FetchNextCommandByte();
 286
 287         MemoryType =  FetchNextCommandByte();
 288
 289         if ((MemoryType != MEMORY_TYPE_FLASH) && (MemoryType != MEMORY_TYPE_EEPROM))
 290         {
 291                 /* Send error byte back to the host */
 292                 WriteNextResponseByte('?');
 293
 294                 return;
 295         }
 296
 297         /* Check if command is to read a memory block */
 298         if (Command == AVR109_COMMAND_BlockRead)
 299         {
 300                 /* Re-enable RWW section */
 301                 boot_rww_enable();
 302
 303                 while (BlockSize--)
 304                 {
 305                         if (MemoryType == MEMORY_TYPE_FLASH)
 306                         {
 307                                 /* Read the next FLASH byte from the current FLASH page */
 308                                 #if (FLASHEND > 0xFFFF)
 309                                 WriteNextResponseByte(pgm_read_byte_far(CurrAddress | HighByte));
 310                                 #else
 311                                 WriteNextResponseByte(pgm_read_byte(CurrAddress | HighByte));
 312                                 #endif
 313
 314                                 /* If both bytes in current word have been read, increment the address counter */
 315                                 if (HighByte)
 316                                   CurrAddress += 2;
 317
 318                                 HighByte = !HighByte;
 319                         }
 320                         else
 321                         {
 322                                 /* Read the next EEPROM byte into the endpoint */
 323                                 WriteNextResponseByte(eeprom_read_byte((uint8_t*)(intptr_t)(CurrAddress >> 1)));
 324
 325                                 /* Increment the address counter after use */
 326                                 CurrAddress += 2;
 327                         }
 328                 }
 329         }
 330         else
 331         {
 332                 uint32_t PageStartAddress = CurrAddress;
 333
 334                 if (MemoryType == MEMORY_TYPE_FLASH)
 335                 {
 336                         boot_page_erase(PageStartAddress);
 337                         boot_spm_busy_wait();
 338                 }
 339
 340                 while (BlockSize--)
 341                 {
 342                         if (MemoryType == MEMORY_TYPE_FLASH)
 343                         {
 344                                 /* If both bytes in current word have been written, increment the address counter */
 345                                 if (HighByte)
 346                                 {
 347                                         /* Write the next FLASH word to the current FLASH page */
 348                                         boot_page_fill(CurrAddress, ((FetchNextCommandByte() << 8) | LowByte));
 349
 350                                         /* Increment the address counter after use */
 351                                         CurrAddress += 2;
 352                                 }
 353                                 else
 354                                 {
 355                                         LowByte = FetchNextCommandByte();
 356                                 }
 357
 358                                 HighByte = !HighByte;
 359                         }
 360                         else
 361                         {
 362                                 /* Write the next EEPROM byte from the endpoint */
 363                                 eeprom_write_byte((uint8_t*)((intptr_t)(CurrAddress >> 1)), FetchNextCommandByte());
 364
 365                                 /* Increment the address counter after use */
 366                                 CurrAddress += 2;
 367                         }
 368                 }
 369
 370                 /* If in FLASH programming mode, commit the page after writing */
 371                 if (MemoryType == MEMORY_TYPE_FLASH)
 372                 {
 373                         /* Commit the flash page to memory */
 374                         boot_page_write(PageStartAddress);
 375
 376                         /* Wait until write operation has completed */
 377                         boot_spm_busy_wait();
 378                 }
 379
 380                 /* Send response byte back to the host */
 381                 WriteNextResponseByte('\r');
 382         }
 383 }
 384 #endif
 385
 386 /** Retrieves the next byte from the host in the CDC data OUT endpoint, and clears the endpoint bank if needed
 387  *  to allow reception of the next data packet from the host.
 388  *
 389  *  \return Next received byte from the host in the CDC data OUT endpoint
 390  */
 391 static uint8_t FetchNextCommandByte(void)
 392 {
 393         /* Select the OUT endpoint so that the next data byte can be read */
 394         Endpoint_SelectEndpoint(CDC_RX_EPADDR);
 395
 396         /* If OUT endpoint empty, clear it and wait for the next packet from the host */
 397         while (!(Endpoint_IsReadWriteAllowed()))
 398         {
 399                 Endpoint_ClearOUT();
 400
 401                 while (!(Endpoint_IsOUTReceived()))
 402                 {
 403                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 404                           return 0;
 405                 }
 406         }
 407
 408         /* Fetch the next byte from the OUT endpoint */
 409         return Endpoint_Read_8();
 410 }
 411
 412 /** Writes the next response byte to the CDC data IN endpoint, and sends the endpoint back if needed to free up the
 413  *  bank when full ready for the next byte in the packet to the host.
 414  *
 415  *  \param[in] Response  Next response byte to send to the host
 416  */
 417 static void WriteNextResponseByte(const uint8_t Response)
 418 {
 419         /* Select the IN endpoint so that the next data byte can be written */
 420         Endpoint_SelectEndpoint(CDC_TX_EPADDR);
 421
 422         /* If IN endpoint full, clear it and wait until ready for the next packet to the host */
 423         if (!(Endpoint_IsReadWriteAllowed()))
 424         {
 425                 Endpoint_ClearIN();
 426
 427                 while (!(Endpoint_IsINReady()))
 428                 {
 429                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 430                           return;
 431                 }
 432         }
 433
 434         /* Write the next byte to the IN endpoint */
 435         Endpoint_Write_8(Response);
 436 }
 437
 438 /** Task to read in AVR109 commands from the CDC data OUT endpoint, process them, perform the required actions
 439  *  and send the appropriate response back to the host.
 440  */
 441 static void CDC_Task(void)
 442 {
 443         /* Select the OUT endpoint */
 444         Endpoint_SelectEndpoint(CDC_RX_EPADDR);
 445
 446         /* Check if endpoint has a command in it sent from the host */
 447         if (!(Endpoint_IsOUTReceived()))
 448           return;
 449
 450         /* Read in the bootloader command (first byte sent from host) */
 451         uint8_t Command = FetchNextCommandByte();
 452
 453         if (Command == AVR109_COMMAND_ExitBootloader)
 454         {
 455                 RunBootloader = false;
 456
 457                 /* Send confirmation byte back to the host */
 458                 WriteNextResponseByte('\r');
 459         }
 460         else if ((Command == AVR109_COMMAND_SetLED) || (Command == AVR109_COMMAND_ClearLED) ||
 461                  (Command == AVR109_COMMAND_SelectDeviceType))
 462         {
 463                 FetchNextCommandByte();
 464
 465                 /* Send confirmation byte back to the host */
 466                 WriteNextResponseByte('\r');
 467         }
 468         else if ((Command == AVR109_COMMAND_EnterProgrammingMode) || (Command == AVR109_COMMAND_LeaveProgrammingMode))
 469         {
 470                 /* Send confirmation byte back to the host */
 471                 WriteNextResponseByte('\r');
 472         }
 473         else if (Command == AVR109_COMMAND_ReadPartCode)
 474         {
 475                 /* Return ATMEGA128 part code - this is only to allow AVRProg to use the bootloader */
 476                 WriteNextResponseByte(0x44);
 477                 WriteNextResponseByte(0x00);
 478         }
 479         else if (Command == AVR109_COMMAND_ReadAutoAddressIncrement)
 480         {
 481                 /* Indicate auto-address increment is supported */
 482                 WriteNextResponseByte('Y');
 483         }
 484         else if (Command == AVR109_COMMAND_SetCurrentAddress)
 485         {
 486                 /* Set the current address to that given by the host (translate 16-bit word address to byte address) */
 487                 CurrAddress   = (FetchNextCommandByte() << 9);
 488                 CurrAddress  |= (FetchNextCommandByte() << 1);
 489
 490                 /* Send confirmation byte back to the host */
 491                 WriteNextResponseByte('\r');
 492         }
 493         else if (Command == AVR109_COMMAND_ReadBootloaderInterface)
 494         {
 495                 /* Indicate serial programmer back to the host */
 496                 WriteNextResponseByte('S');
 497         }
 498         else if (Command == AVR109_COMMAND_ReadBootloaderIdentifier)
 499         {
 500                 /* Write the 7-byte software identifier to the endpoint */
 501                 for (uint8_t CurrByte = 0; CurrByte < 7; CurrByte++)
 502                   WriteNextResponseByte(SOFTWARE_IDENTIFIER[CurrByte]);
 503         }
 504         else if (Command == AVR109_COMMAND_ReadBootloaderSWVersion)
 505         {
 506                 WriteNextResponseByte('0' + BOOTLOADER_VERSION_MAJOR);
 507                 WriteNextResponseByte('0' + BOOTLOADER_VERSION_MINOR);
 508         }
 509         else if (Command == AVR109_COMMAND_ReadSignature)
 510         {
 511                 WriteNextResponseByte(AVR_SIGNATURE_3);
 512                 WriteNextResponseByte(AVR_SIGNATURE_2);
 513                 WriteNextResponseByte(AVR_SIGNATURE_1);
 514         }
 515         else if (Command == AVR109_COMMAND_EraseFLASH)
 516         {
 517                 /* Clear the application section of flash */
 518                 for (uint32_t CurrFlashAddress = 0; CurrFlashAddress < (uint32_t)BOOT_START_ADDR; CurrFlashAddress += SPM_PAGESIZE)
 519                 {
 520                         boot_page_erase(CurrFlashAddress);
 521                         boot_spm_busy_wait();
 522                         boot_page_write(CurrFlashAddress);
 523                         boot_spm_busy_wait();
 524                 }
 525
 526                 /* Send confirmation byte back to the host */
 527                 WriteNextResponseByte('\r');
 528         }
 529         #if !defined(NO_LOCK_BYTE_WRITE_SUPPORT)
 530         else if (Command == AVR109_COMMAND_WriteLockbits)
 531         {
 532                 /* Set the lock bits to those given by the host */
 533                 boot_lock_bits_set(FetchNextCommandByte());
 534
 535                 /* Send confirmation byte back to the host */
 536                 WriteNextResponseByte('\r');
 537         }
 538         #endif
 539         else if (Command == AVR109_COMMAND_ReadLockbits)
 540         {
 541                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_LOCK_BITS));
 542         }
 543         else if (Command == AVR109_COMMAND_ReadLowFuses)
 544         {
 545                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_LOW_FUSE_BITS));
 546         }
 547         else if (Command == AVR109_COMMAND_ReadHighFuses)
 548         {
 549                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_HIGH_FUSE_BITS));
 550         }
 551         else if (Command == AVR109_COMMAND_ReadExtendedFuses)
 552         {
 553                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_EXTENDED_FUSE_BITS));
 554         }
 555         #if !defined(NO_BLOCK_SUPPORT)
 556         else if (Command == AVR109_COMMAND_GetBlockWriteSupport)
 557         {
 558                 WriteNextResponseByte('Y');
 559
 560                 /* Send block size to the host */
 561                 WriteNextResponseByte(SPM_PAGESIZE >> 8);
 562                 WriteNextResponseByte(SPM_PAGESIZE & 0xFF);
 563         }
 564         else if ((Command == AVR109_COMMAND_BlockWrite) || (Command == AVR109_COMMAND_BlockRead))
 565         {
 566                 /* Delegate the block write/read to a separate function for clarity */
 567                 ReadWriteMemoryBlock(Command);
 568         }
 569         #endif
 570         #if !defined(NO_FLASH_BYTE_SUPPORT)
 571         else if (Command == AVR109_COMMAND_FillFlashPageWordHigh)
 572         {
 573                 /* Write the high byte to the current flash page */
 574                 boot_page_fill(CurrAddress, FetchNextCommandByte());
 575
 576                 /* Send confirmation byte back to the host */
 577                 WriteNextResponseByte('\r');
 578         }
 579         else if (Command == AVR109_COMMAND_FillFlashPageWordLow)
 580         {
 581                 /* Write the low byte to the current flash page */
 582                 boot_page_fill(CurrAddress | 0x01, FetchNextCommandByte());
 583
 584                 /* Increment the address */
 585                 CurrAddress += 2;
 586
 587                 /* Send confirmation byte back to the host */
 588                 WriteNextResponseByte('\r');
 589         }
 590         else if (Command == AVR109_COMMAND_WriteFlashPage)
 591         {
 592                 /* Commit the flash page to memory */
 593                 boot_page_write(CurrAddress);
 594
 595                 /* Wait until write operation has completed */
 596                 boot_spm_busy_wait();
 597
 598                 /* Send confirmation byte back to the host */
 599                 WriteNextResponseByte('\r');
 600         }
 601         else if (Command == AVR109_COMMAND_ReadFLASHWord)
 602         {
 603                 #if (FLASHEND > 0xFFFF)
 604                 uint16_t ProgramWord = pgm_read_word_far(CurrAddress);
 605                 #else
 606                 uint16_t ProgramWord = pgm_read_word(CurrAddress);
 607                 #endif
 608
 609                 WriteNextResponseByte(ProgramWord >> 8);
 610                 WriteNextResponseByte(ProgramWord & 0xFF);
 611         }
 612         #endif
 613         #if !defined(NO_EEPROM_BYTE_SUPPORT)
 614         else if (Command == AVR109_COMMAND_WriteEEPROM)
 615         {
 616                 /* Read the byte from the endpoint and write it to the EEPROM */
 617                 eeprom_write_byte((uint8_t*)((intptr_t)(CurrAddress >> 1)), FetchNextCommandByte());
 618
 619                 /* Increment the address after use */
 620                 CurrAddress += 2;
 621
 622                 /* Send confirmation byte back to the host */
 623                 WriteNextResponseByte('\r');
 624         }
 625         else if (Command == AVR109_COMMAND_ReadEEPROM)
 626         {
 627                 /* Read the EEPROM byte and write it to the endpoint */
 628                 WriteNextResponseByte(eeprom_read_byte((uint8_t*)((intptr_t)(CurrAddress >> 1))));
 629
 630                 /* Increment the address after use */
 631                 CurrAddress += 2;
 632         }
 633         #endif
 634         else if (Command != AVR109_COMMAND_Sync)
 635         {
 636                 /* Unknown (non-sync) command, return fail code */
 637                 WriteNextResponseByte('?');
 638         }
 639
 640         /* Select the IN endpoint */
 641         Endpoint_SelectEndpoint(CDC_TX_EPADDR);
 642
 643         /* Remember if the endpoint is completely full before clearing it */
 644         bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());
 645
 646         /* Send the endpoint data to the host */
 647         Endpoint_ClearIN();
 648
 649         /* If a full endpoint's worth of data was sent, we need to send an empty packet afterwards to signal end of transfer */
 650         if (IsEndpointFull)
 651         {
 652                 while (!(Endpoint_IsINReady()))
 653                 {
 654                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 655                           return;
 656                 }
 657
 658                 Endpoint_ClearIN();
 659         }
 660
 661         /* Wait until the data has been sent to the host */
 662         while (!(Endpoint_IsINReady()))
 663         {
 664                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 665                   return;
 666         }
 667
 668         /* Select the OUT endpoint */
 669         Endpoint_SelectEndpoint(CDC_RX_EPADDR);
 670
 671         /* Acknowledge the command from the host */
 672         Endpoint_ClearOUT();
 673 }
 674