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         }
 227 }
 228
 229 #if !defined(NO_BLOCK_SUPPORT)
 230 /** Reads or writes a block of EEPROM or FLASH memory to or from the appropriate CDC data endpoint, depending
 231  *  on the AVR910 protocol command issued.
 232  *
 233  *  \param[in] Command  Single character AVR910 protocol command indicating what memory operation to perform
 234  */
 235 static void ReadWriteMemoryBlock(const uint8_t Command)
 236 {
 237         uint16_t BlockSize;
 238         char     MemoryType;
 239
 240         uint8_t  HighByte = 0;
 241         uint8_t  LowByte  = 0;
 242
 243         BlockSize  = (FetchNextCommandByte() << 8);
 244         BlockSize |=  FetchNextCommandByte();
 245
 246         MemoryType =  FetchNextCommandByte();
 247
 248         if ((MemoryType != MEMORY_TYPE_FLASH) && (MemoryType != MEMORY_TYPE_EEPROM))
 249         {
 250                 /* Send error byte back to the host */
 251                 WriteNextResponseByte('?');
 252
 253                 return;
 254         }
 255
 256         /* Check if command is to read a memory block */
 257         if (Command == AVR109_COMMAND_BlockRead)
 258         {
 259                 /* Re-enable RWW section */
 260                 boot_rww_enable();
 261
 262                 while (BlockSize--)
 263                 {
 264                         if (MemoryType == MEMORY_TYPE_FLASH)
 265                         {
 266                                 /* Read the next FLASH byte from the current FLASH page */
 267                                 #if (FLASHEND > 0xFFFF)
 268                                 WriteNextResponseByte(pgm_read_byte_far(CurrAddress | HighByte));
 269                                 #else
 270                                 WriteNextResponseByte(pgm_read_byte(CurrAddress | HighByte));
 271                                 #endif
 272
 273                                 /* If both bytes in current word have been read, increment the address counter */
 274                                 if (HighByte)
 275                                   CurrAddress += 2;
 276
 277                                 HighByte = !HighByte;
 278                         }
 279                         else
 280                         {
 281                                 /* Read the next EEPROM byte into the endpoint */
 282                                 WriteNextResponseByte(eeprom_read_byte((uint8_t*)(intptr_t)(CurrAddress >> 1)));
 283
 284                                 /* Increment the address counter after use */
 285                                 CurrAddress += 2;
 286                         }
 287                 }
 288         }
 289         else
 290         {
 291                 uint32_t PageStartAddress = CurrAddress;
 292
 293                 if (MemoryType == MEMORY_TYPE_FLASH)
 294                 {
 295                         boot_page_erase(PageStartAddress);
 296                         boot_spm_busy_wait();
 297                 }
 298
 299                 while (BlockSize--)
 300                 {
 301                         if (MemoryType == MEMORY_TYPE_FLASH)
 302                         {
 303                                 /* If both bytes in current word have been written, increment the address counter */
 304                                 if (HighByte)
 305                                 {
 306                                         /* Write the next FLASH word to the current FLASH page */
 307                                         boot_page_fill(CurrAddress, ((FetchNextCommandByte() << 8) | LowByte));
 308
 309                                         /* Increment the address counter after use */
 310                                         CurrAddress += 2;
 311                                 }
 312                                 else
 313                                 {
 314                                         LowByte = FetchNextCommandByte();
 315                                 }
 316
 317                                 HighByte = !HighByte;
 318                         }
 319                         else
 320                         {
 321                                 /* Write the next EEPROM byte from the endpoint */
 322                                 eeprom_write_byte((uint8_t*)((intptr_t)(CurrAddress >> 1)), FetchNextCommandByte());
 323
 324                                 /* Increment the address counter after use */
 325                                 CurrAddress += 2;
 326                         }
 327                 }
 328
 329                 /* If in FLASH programming mode, commit the page after writing */
 330                 if (MemoryType == MEMORY_TYPE_FLASH)
 331                 {
 332                         /* Commit the flash page to memory */
 333                         boot_page_write(PageStartAddress);
 334
 335                         /* Wait until write operation has completed */
 336                         boot_spm_busy_wait();
 337                 }
 338
 339                 /* Send response byte back to the host */
 340                 WriteNextResponseByte('\r');
 341         }
 342 }
 343 #endif
 344
 345 /** Retrieves the next byte from the host in the CDC data OUT endpoint, and clears the endpoint bank if needed
 346  *  to allow reception of the next data packet from the host.
 347  *
 348  *  \return Next received byte from the host in the CDC data OUT endpoint
 349  */
 350 static uint8_t FetchNextCommandByte(void)
 351 {
 352         /* Select the OUT endpoint so that the next data byte can be read */
 353         Endpoint_SelectEndpoint(CDC_RX_EPADDR);
 354
 355         /* If OUT endpoint empty, clear it and wait for the next packet from the host */
 356         while (!(Endpoint_IsReadWriteAllowed()))
 357         {
 358                 Endpoint_ClearOUT();
 359
 360                 while (!(Endpoint_IsOUTReceived()))
 361                 {
 362                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 363                           return 0;
 364                 }
 365         }
 366
 367         /* Fetch the next byte from the OUT endpoint */
 368         return Endpoint_Read_8();
 369 }
 370
 371 /** Writes the next response byte to the CDC data IN endpoint, and sends the endpoint back if needed to free up the
 372  *  bank when full ready for the next byte in the packet to the host.
 373  *
 374  *  \param[in] Response  Next response byte to send to the host
 375  */
 376 static void WriteNextResponseByte(const uint8_t Response)
 377 {
 378         /* Select the IN endpoint so that the next data byte can be written */
 379         Endpoint_SelectEndpoint(CDC_TX_EPADDR);
 380
 381         /* If IN endpoint full, clear it and wait until ready for the next packet to the host */
 382         if (!(Endpoint_IsReadWriteAllowed()))
 383         {
 384                 Endpoint_ClearIN();
 385
 386                 while (!(Endpoint_IsINReady()))
 387                 {
 388                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 389                           return;
 390                 }
 391         }
 392
 393         /* Write the next byte to the IN endpoint */
 394         Endpoint_Write_8(Response);
 395 }
 396
 397 /** Task to read in AVR910 commands from the CDC data OUT endpoint, process them, perform the required actions
 398  *  and send the appropriate response back to the host.
 399  */
 400 static void CDC_Task(void)
 401 {
 402         /* Select the OUT endpoint */
 403         Endpoint_SelectEndpoint(CDC_RX_EPADDR);
 404
 405         /* Check if endpoint has a command in it sent from the host */
 406         if (!(Endpoint_IsOUTReceived()))
 407           return;
 408
 409         /* Read in the bootloader command (first byte sent from host) */
 410         uint8_t Command = FetchNextCommandByte();
 411
 412         if (Command == AVR109_COMMAND_ExitBootloader)
 413         {
 414                 RunBootloader = false;
 415
 416                 /* Send confirmation byte back to the host */
 417                 WriteNextResponseByte('\r');
 418         }
 419         else if ((Command == AVR109_COMMAND_SetLED) || (Command == AVR109_COMMAND_ClearLED) ||
 420                  (Command == AVR109_COMMAND_SelectDeviceType))
 421         {
 422                 FetchNextCommandByte();
 423
 424                 /* Send confirmation byte back to the host */
 425                 WriteNextResponseByte('\r');
 426         }
 427         else if ((Command == AVR109_COMMAND_EnterProgrammingMode) || (Command == AVR109_COMMAND_LeaveProgrammingMode))
 428         {
 429                 /* Send confirmation byte back to the host */
 430                 WriteNextResponseByte('\r');
 431         }
 432         else if (Command == AVR109_COMMAND_ReadPartCode)
 433         {
 434                 /* Return ATMEGA128 part code - this is only to allow AVRProg to use the bootloader */
 435                 WriteNextResponseByte(0x44);
 436                 WriteNextResponseByte(0x00);
 437         }
 438         else if (Command == AVR109_COMMAND_ReadAutoAddressIncrement)
 439         {
 440                 /* Indicate auto-address increment is supported */
 441                 WriteNextResponseByte('Y');
 442         }
 443         else if (Command == AVR109_COMMAND_SetCurrentAddress)
 444         {
 445                 /* Set the current address to that given by the host (translate 16-bit word address to byte address) */
 446                 CurrAddress   = (FetchNextCommandByte() << 9);
 447                 CurrAddress  |= (FetchNextCommandByte() << 1);
 448
 449                 /* Send confirmation byte back to the host */
 450                 WriteNextResponseByte('\r');
 451         }
 452         else if (Command == AVR109_COMMAND_ReadBootloaderInterface)
 453         {
 454                 /* Indicate serial programmer back to the host */
 455                 WriteNextResponseByte('S');
 456         }
 457         else if (Command == AVR109_COMMAND_ReadBootloaderIdentifier)
 458         {
 459                 /* Write the 7-byte software identifier to the endpoint */
 460                 for (uint8_t CurrByte = 0; CurrByte < 7; CurrByte++)
 461                   WriteNextResponseByte(SOFTWARE_IDENTIFIER[CurrByte]);
 462         }
 463         else if (Command == AVR109_COMMAND_ReadBootloaderSWVersion)
 464         {
 465                 WriteNextResponseByte('0' + BOOTLOADER_VERSION_MAJOR);
 466                 WriteNextResponseByte('0' + BOOTLOADER_VERSION_MINOR);
 467         }
 468         else if (Command == AVR109_COMMAND_ReadSignature)
 469         {
 470                 WriteNextResponseByte(AVR_SIGNATURE_3);
 471                 WriteNextResponseByte(AVR_SIGNATURE_2);
 472                 WriteNextResponseByte(AVR_SIGNATURE_1);
 473         }
 474         else if (Command == AVR109_COMMAND_EraseFLASH)
 475         {
 476                 /* Clear the application section of flash */
 477                 for (uint32_t CurrFlashAddress = 0; CurrFlashAddress < (uint32_t)BOOT_START_ADDR; CurrFlashAddress += SPM_PAGESIZE)
 478                 {
 479                         boot_page_erase(CurrFlashAddress);
 480                         boot_spm_busy_wait();
 481                         boot_page_write(CurrFlashAddress);
 482                         boot_spm_busy_wait();
 483                 }
 484
 485                 /* Send confirmation byte back to the host */
 486                 WriteNextResponseByte('\r');
 487         }
 488         #if !defined(NO_LOCK_BYTE_WRITE_SUPPORT)
 489         else if (Command == AVR109_COMMAND_WriteLockbits)
 490         {
 491                 /* Set the lock bits to those given by the host */
 492                 boot_lock_bits_set(FetchNextCommandByte());
 493
 494                 /* Send confirmation byte back to the host */
 495                 WriteNextResponseByte('\r');
 496         }
 497         #endif
 498         else if (Command == AVR109_COMMAND_ReadLockbits)
 499         {
 500                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_LOCK_BITS));
 501         }
 502         else if (Command == AVR109_COMMAND_ReadLowFuses)
 503         {
 504                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_LOW_FUSE_BITS));
 505         }
 506         else if (Command == AVR109_COMMAND_ReadHighFuses)
 507         {
 508                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_HIGH_FUSE_BITS));
 509         }
 510         else if (Command == AVR109_COMMAND_ReadExtendedFuses)
 511         {
 512                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_EXTENDED_FUSE_BITS));
 513         }
 514         #if !defined(NO_BLOCK_SUPPORT)
 515         else if (Command == AVR109_COMMAND_GetBlockWriteSupport)
 516         {
 517                 WriteNextResponseByte('Y');
 518
 519                 /* Send block size to the host */
 520                 WriteNextResponseByte(SPM_PAGESIZE >> 8);
 521                 WriteNextResponseByte(SPM_PAGESIZE & 0xFF);
 522         }
 523         else if ((Command == AVR109_COMMAND_BlockWrite) || (Command == AVR109_COMMAND_BlockRead))
 524         {
 525                 /* Delegate the block write/read to a separate function for clarity */
 526                 ReadWriteMemoryBlock(Command);
 527         }
 528         #endif
 529         #if !defined(NO_FLASH_BYTE_SUPPORT)
 530         else if (Command == AVR109_COMMAND_FillFlashPageWordHigh)
 531         {
 532                 /* Write the high byte to the current flash page */
 533                 boot_page_fill(CurrAddress, FetchNextCommandByte());
 534
 535                 /* Send confirmation byte back to the host */
 536                 WriteNextResponseByte('\r');
 537         }
 538         else if (Command == AVR109_COMMAND_FillFlashPageWordLow)
 539         {
 540                 /* Write the low byte to the current flash page */
 541                 boot_page_fill(CurrAddress | 0x01, FetchNextCommandByte());
 542
 543                 /* Increment the address */
 544                 CurrAddress += 2;
 545
 546                 /* Send confirmation byte back to the host */
 547                 WriteNextResponseByte('\r');
 548         }
 549         else if (Command == AVR109_COMMAND_WriteFlashPage)
 550         {
 551                 /* Commit the flash page to memory */
 552                 boot_page_write(CurrAddress);
 553
 554                 /* Wait until write operation has completed */
 555                 boot_spm_busy_wait();
 556
 557                 /* Send confirmation byte back to the host */
 558                 WriteNextResponseByte('\r');
 559         }
 560         else if (Command == AVR109_COMMAND_ReadFLASHWord)
 561         {
 562                 #if (FLASHEND > 0xFFFF)
 563                 uint16_t ProgramWord = pgm_read_word_far(CurrAddress);
 564                 #else
 565                 uint16_t ProgramWord = pgm_read_word(CurrAddress);
 566                 #endif
 567
 568                 WriteNextResponseByte(ProgramWord >> 8);
 569                 WriteNextResponseByte(ProgramWord & 0xFF);
 570         }
 571         #endif
 572         #if !defined(NO_EEPROM_BYTE_SUPPORT)
 573         else if (Command == AVR109_COMMAND_WriteEEPROM)
 574         {
 575                 /* Read the byte from the endpoint and write it to the EEPROM */
 576                 eeprom_write_byte((uint8_t*)((intptr_t)(CurrAddress >> 1)), FetchNextCommandByte());
 577
 578                 /* Increment the address after use */
 579                 CurrAddress += 2;
 580
 581                 /* Send confirmation byte back to the host */
 582                 WriteNextResponseByte('\r');
 583         }
 584         else if (Command == AVR109_COMMAND_ReadEEPROM)
 585         {
 586                 /* Read the EEPROM byte and write it to the endpoint */
 587                 WriteNextResponseByte(eeprom_read_byte((uint8_t*)((intptr_t)(CurrAddress >> 1))));
 588
 589                 /* Increment the address after use */
 590                 CurrAddress += 2;
 591         }
 592         #endif
 593         else if (Command != AVR109_COMMAND_Sync)
 594         {
 595                 /* Unknown (non-sync) command, return fail code */
 596                 WriteNextResponseByte('?');
 597         }
 598
 599         /* Select the IN endpoint */
 600         Endpoint_SelectEndpoint(CDC_TX_EPADDR);
 601
 602         /* Remember if the endpoint is completely full before clearing it */
 603         bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());
 604
 605         /* Send the endpoint data to the host */
 606         Endpoint_ClearIN();
 607
 608         /* If a full endpoint's worth of data was sent, we need to send an empty packet afterwards to signal end of transfer */
 609         if (IsEndpointFull)
 610         {
 611                 while (!(Endpoint_IsINReady()))
 612                 {
 613                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 614                           return;
 615                 }
 616
 617                 Endpoint_ClearIN();
 618         }
 619
 620         /* Wait until the data has been sent to the host */
 621         while (!(Endpoint_IsINReady()))
 622         {
 623                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 624                   return;
 625         }
 626
 627         /* Select the OUT endpoint */
 628         Endpoint_SelectEndpoint(CDC_RX_EPADDR);
 629
 630         /* Acknowledge the command from the host */
 631         Endpoint_ClearOUT();
 632 }
 633