Bootloaders/CDC/BootloaderCDC.c

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