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