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