Bootloaders/CDC/BootloaderCDC.c

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