Bootloaders/CDC/BootloaderCDC.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2020.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2020  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 (!(BootloaderAPI_ReadFuse(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                 while (BlockSize--)
 301                 {
 302                         if (MemoryType == MEMORY_TYPE_FLASH)
 303                         {
 304                                 /* Read the next FLASH byte from the current FLASH page */
 305                                 #if (FLASHEND > 0xFFFF)
 306                                 WriteNextResponseByte(pgm_read_byte_far(CurrAddress | HighByte));
 307                                 #else
 308                                 WriteNextResponseByte(pgm_read_byte(CurrAddress | HighByte));
 309                                 #endif
 310
 311                                 /* If both bytes in current word have been read, increment the address counter */
 312                                 if (HighByte)
 313                                   CurrAddress += 2;
 314
 315                                 HighByte = !HighByte;
 316                         }
 317                         else
 318                         {
 319                                 /* Read the next EEPROM byte into the endpoint */
 320                                 WriteNextResponseByte(eeprom_read_byte((uint8_t*)(intptr_t)(CurrAddress >> 1)));
 321
 322                                 /* Increment the address counter after use */
 323                                 CurrAddress += 2;
 324                         }
 325                 }
 326         }
 327         else
 328         {
 329                 uint32_t PageStartAddress = CurrAddress;
 330
 331                 if (MemoryType == MEMORY_TYPE_FLASH)
 332                   BootloaderAPI_ErasePage(PageStartAddress);
 333
 334                 while (BlockSize--)
 335                 {
 336                         if (MemoryType == MEMORY_TYPE_FLASH)
 337                         {
 338                                 /* If both bytes in current word have been written, increment the address counter */
 339                                 if (HighByte)
 340                                 {
 341                                         /* Write the next FLASH word to the current FLASH page */
 342                                         BootloaderAPI_FillWord(CurrAddress, ((FetchNextCommandByte() << 8) | LowByte));
 343
 344                                         /* Increment the address counter after use */
 345                                         CurrAddress += 2;
 346                                 }
 347                                 else
 348                                 {
 349                                         LowByte = FetchNextCommandByte();
 350                                 }
 351
 352                                 HighByte = !HighByte;
 353                         }
 354                         else
 355                         {
 356                                 /* Write the next EEPROM byte from the endpoint */
 357                                 eeprom_update_byte((uint8_t*)((intptr_t)(CurrAddress >> 1)), FetchNextCommandByte());
 358
 359                                 /* Increment the address counter after use */
 360                                 CurrAddress += 2;
 361                         }
 362                 }
 363
 364                 /* If in FLASH programming mode, commit the page after writing */
 365                 if (MemoryType == MEMORY_TYPE_FLASH)
 366                 {
 367                         /* Commit the flash page to memory */
 368                         BootloaderAPI_WritePage(PageStartAddress);
 369                 }
 370
 371                 /* Send response byte back to the host */
 372                 WriteNextResponseByte('\r');
 373         }
 374 }
 375 #endif
 376
 377 /** Retrieves the next byte from the host in the CDC data OUT endpoint, and clears the endpoint bank if needed
 378  *  to allow reception of the next data packet from the host.
 379  *
 380  *  \return Next received byte from the host in the CDC data OUT endpoint
 381  */
 382 static uint8_t FetchNextCommandByte(void)
 383 {
 384         /* Select the OUT endpoint so that the next data byte can be read */
 385         Endpoint_SelectEndpoint(CDC_RX_EPADDR);
 386
 387         /* If OUT endpoint empty, clear it and wait for the next packet from the host */
 388         while (!(Endpoint_IsReadWriteAllowed()))
 389         {
 390                 Endpoint_ClearOUT();
 391
 392                 while (!(Endpoint_IsOUTReceived()))
 393                 {
 394                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 395                           return 0;
 396                 }
 397         }
 398
 399         /* Fetch the next byte from the OUT endpoint */
 400         return Endpoint_Read_8();
 401 }
 402
 403 /** Writes the next response byte to the CDC data IN endpoint, and sends the endpoint back if needed to free up the
 404  *  bank when full ready for the next byte in the packet to the host.
 405  *
 406  *  \param[in] Response  Next response byte to send to the host
 407  */
 408 static void WriteNextResponseByte(const uint8_t Response)
 409 {
 410         /* Select the IN endpoint so that the next data byte can be written */
 411         Endpoint_SelectEndpoint(CDC_TX_EPADDR);
 412
 413         /* If IN endpoint full, clear it and wait until ready for the next packet to the host */
 414         if (!(Endpoint_IsReadWriteAllowed()))
 415         {
 416                 Endpoint_ClearIN();
 417
 418                 while (!(Endpoint_IsINReady()))
 419                 {
 420                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 421                           return;
 422                 }
 423         }
 424
 425         /* Write the next byte to the IN endpoint */
 426         Endpoint_Write_8(Response);
 427 }
 428
 429 /** Task to read in AVR109 commands from the CDC data OUT endpoint, process them, perform the required actions
 430  *  and send the appropriate response back to the host.
 431  */
 432 static void CDC_Task(void)
 433 {
 434         /* Select the OUT endpoint */
 435         Endpoint_SelectEndpoint(CDC_RX_EPADDR);
 436
 437         /* Check if endpoint has a command in it sent from the host */
 438         if (!(Endpoint_IsOUTReceived()))
 439           return;
 440
 441         /* Read in the bootloader command (first byte sent from host) */
 442         uint8_t Command = FetchNextCommandByte();
 443
 444         if (Command == AVR109_COMMAND_ExitBootloader)
 445         {
 446                 RunBootloader = false;
 447
 448                 /* Send confirmation byte back to the host */
 449                 WriteNextResponseByte('\r');
 450         }
 451         else if ((Command == AVR109_COMMAND_SetLED) || (Command == AVR109_COMMAND_ClearLED) ||
 452                  (Command == AVR109_COMMAND_SelectDeviceType))
 453         {
 454                 FetchNextCommandByte();
 455
 456                 /* Send confirmation byte back to the host */
 457                 WriteNextResponseByte('\r');
 458         }
 459         else if ((Command == AVR109_COMMAND_EnterProgrammingMode) || (Command == AVR109_COMMAND_LeaveProgrammingMode))
 460         {
 461                 /* Send confirmation byte back to the host */
 462                 WriteNextResponseByte('\r');
 463         }
 464         else if (Command == AVR109_COMMAND_ReadPartCode)
 465         {
 466                 /* Return ATMEGA128 part code - this is only to allow AVRProg to use the bootloader */
 467                 WriteNextResponseByte(0x44);
 468                 WriteNextResponseByte(0x00);
 469         }
 470         else if (Command == AVR109_COMMAND_ReadAutoAddressIncrement)
 471         {
 472                 /* Indicate auto-address increment is supported */
 473                 WriteNextResponseByte('Y');
 474         }
 475         else if (Command == AVR109_COMMAND_SetCurrentAddress)
 476         {
 477                 /* Set the current address to that given by the host (translate 16-bit word address to byte address) */
 478                 CurrAddress   = (FetchNextCommandByte() << 9);
 479                 CurrAddress  |= (FetchNextCommandByte() << 1);
 480
 481                 /* Send confirmation byte back to the host */
 482                 WriteNextResponseByte('\r');
 483         }
 484         else if (Command == AVR109_COMMAND_ReadBootloaderInterface)
 485         {
 486                 /* Indicate serial programmer back to the host */
 487                 WriteNextResponseByte('S');
 488         }
 489         else if (Command == AVR109_COMMAND_ReadBootloaderIdentifier)
 490         {
 491                 /* Write the 7-byte software identifier to the endpoint */
 492                 for (uint8_t CurrByte = 0; CurrByte < 7; CurrByte++)
 493                   WriteNextResponseByte(SOFTWARE_IDENTIFIER[CurrByte]);
 494         }
 495         else if (Command == AVR109_COMMAND_ReadBootloaderSWVersion)
 496         {
 497                 WriteNextResponseByte('0' + BOOTLOADER_VERSION_MAJOR);
 498                 WriteNextResponseByte('0' + BOOTLOADER_VERSION_MINOR);
 499         }
 500         else if (Command == AVR109_COMMAND_ReadSignature)
 501         {
 502                 WriteNextResponseByte(AVR_SIGNATURE_3);
 503                 WriteNextResponseByte(AVR_SIGNATURE_2);
 504                 WriteNextResponseByte(AVR_SIGNATURE_1);
 505         }
 506         else if (Command == AVR109_COMMAND_EraseFLASH)
 507         {
 508                 /* Clear the application section of flash */
 509                 for (uint32_t CurrFlashAddress = 0; CurrFlashAddress < (uint32_t)BOOT_START_ADDR; CurrFlashAddress += SPM_PAGESIZE)
 510                         BootloaderAPI_ErasePage(CurrFlashAddress);
 511
 512                 /* Send confirmation byte back to the host */
 513                 WriteNextResponseByte('\r');
 514         }
 515         #if !defined(NO_LOCK_BYTE_WRITE_SUPPORT)
 516         else if (Command == AVR109_COMMAND_WriteLockbits)
 517         {
 518                 /* Set the lock bits to those given by the host */
 519                 BootloaderAPI_WriteLock(FetchNextCommandByte());
 520
 521                 /* Send confirmation byte back to the host */
 522                 WriteNextResponseByte('\r');
 523         }
 524         #endif
 525         else if (Command == AVR109_COMMAND_ReadLockbits)
 526         {
 527                 WriteNextResponseByte(BootloaderAPI_ReadLock());
 528         }
 529         else if (Command == AVR109_COMMAND_ReadLowFuses)
 530         {
 531                 WriteNextResponseByte(BootloaderAPI_ReadFuse(GET_LOW_FUSE_BITS));
 532         }
 533         else if (Command == AVR109_COMMAND_ReadHighFuses)
 534         {
 535                 WriteNextResponseByte(BootloaderAPI_ReadFuse(GET_HIGH_FUSE_BITS));
 536         }
 537         else if (Command == AVR109_COMMAND_ReadExtendedFuses)
 538         {
 539                 WriteNextResponseByte(BootloaderAPI_ReadFuse(GET_EXTENDED_FUSE_BITS));
 540         }
 541         #if !defined(NO_BLOCK_SUPPORT)
 542         else if (Command == AVR109_COMMAND_GetBlockWriteSupport)
 543         {
 544                 WriteNextResponseByte('Y');
 545
 546                 /* Send block size to the host */
 547                 WriteNextResponseByte(SPM_PAGESIZE >> 8);
 548                 WriteNextResponseByte(SPM_PAGESIZE & 0xFF);
 549         }
 550         else if ((Command == AVR109_COMMAND_BlockWrite) || (Command == AVR109_COMMAND_BlockRead))
 551         {
 552                 /* Delegate the block write/read to a separate function for clarity */
 553                 ReadWriteMemoryBlock(Command);
 554         }
 555         #endif
 556         #if !defined(NO_FLASH_BYTE_SUPPORT)
 557         else if (Command == AVR109_COMMAND_FillFlashPageWordHigh)
 558         {
 559                 /* Write the high byte to the current flash page */
 560                 BootloaderAPI_FillWord(CurrAddress, FetchNextCommandByte());
 561
 562                 /* Send confirmation byte back to the host */
 563                 WriteNextResponseByte('\r');
 564         }
 565         else if (Command == AVR109_COMMAND_FillFlashPageWordLow)
 566         {
 567                 /* Write the low byte to the current flash page */
 568                 BootloaderAPI_FillWord(CurrAddress | 0x01, FetchNextCommandByte());
 569
 570                 /* Increment the address */
 571                 CurrAddress += 2;
 572
 573                 /* Send confirmation byte back to the host */
 574                 WriteNextResponseByte('\r');
 575         }
 576         else if (Command == AVR109_COMMAND_WriteFlashPage)
 577         {
 578                 /* Commit the flash page to memory */
 579                 BootloaderAPI_WritePage(CurrAddress);
 580
 581                 /* Send confirmation byte back to the host */
 582                 WriteNextResponseByte('\r');
 583         }
 584         else if (Command == AVR109_COMMAND_ReadFLASHWord)
 585         {
 586                 #if (FLASHEND > 0xFFFF)
 587                 uint16_t ProgramWord = pgm_read_word_far(CurrAddress);
 588                 #else
 589                 uint16_t ProgramWord = pgm_read_word(CurrAddress);
 590                 #endif
 591
 592                 WriteNextResponseByte(ProgramWord >> 8);
 593                 WriteNextResponseByte(ProgramWord & 0xFF);
 594         }
 595         #endif
 596         #if !defined(NO_EEPROM_BYTE_SUPPORT)
 597         else if (Command == AVR109_COMMAND_WriteEEPROM)
 598         {
 599                 /* Read the byte from the endpoint and write it to the EEPROM */
 600                 eeprom_update_byte((uint8_t*)((intptr_t)(CurrAddress >> 1)), FetchNextCommandByte());
 601
 602                 /* Increment the address after use */
 603                 CurrAddress += 2;
 604
 605                 /* Send confirmation byte back to the host */
 606                 WriteNextResponseByte('\r');
 607         }
 608         else if (Command == AVR109_COMMAND_ReadEEPROM)
 609         {
 610                 /* Read the EEPROM byte and write it to the endpoint */
 611                 WriteNextResponseByte(eeprom_read_byte((uint8_t*)((intptr_t)(CurrAddress >> 1))));
 612
 613                 /* Increment the address after use */
 614                 CurrAddress += 2;
 615         }
 616         #endif
 617         else if (Command != AVR109_COMMAND_Sync)
 618         {
 619                 /* Unknown (non-sync) command, return fail code */
 620                 WriteNextResponseByte('?');
 621         }
 622
 623         /* Select the IN endpoint */
 624         Endpoint_SelectEndpoint(CDC_TX_EPADDR);
 625
 626         /* Remember if the endpoint is completely full before clearing it */
 627         bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());
 628
 629         /* Send the endpoint data to the host */
 630         Endpoint_ClearIN();
 631
 632         /* If a full endpoint's worth of data was sent, we need to send an empty packet afterwards to signal end of transfer */
 633         if (IsEndpointFull)
 634         {
 635                 while (!(Endpoint_IsINReady()))
 636                 {
 637                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 638                           return;
 639                 }
 640
 641                 Endpoint_ClearIN();
 642         }
 643
 644         /* Wait until the data has been sent to the host */
 645         while (!(Endpoint_IsINReady()))
 646         {
 647                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 648                   return;
 649         }
 650
 651         /* Select the OUT endpoint */
 652         Endpoint_SelectEndpoint(CDC_RX_EPADDR);
 653
 654         /* Acknowledge the command from the host */
 655         Endpoint_ClearOUT();
 656 }