Debian Codegraph @

bootloaders/caterina/Caterina.c

raw
1 /*
2 LUFA Library
3 Copyright (C) Dean Camera, 2011.
4
5 dean [at] fourwalledcubicle [dot] com
6 www.lufa-lib.org
7 */
8
9 /*
10 Copyright 2011 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 disclaim 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_CATERINA_C
37 #include "Caterina.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 /* Pulse generation counters to keep track of the time remaining for each pulse type */
60 #define TX_RX_LED_PULSE_PERIOD 100
61 uint16_t TxLEDPulse = 0; // time remaining for Tx LED pulse
62 uint16_t RxLEDPulse = 0; // time remaining for Rx LED pulse
63
64 /* Bootloader timeout timer */
65 #define TIMEOUT_PERIOD 8000
66 uint16_t Timeout = 0;
67
68 uint16_t bootKey = 0x7777;
69 volatile uint16_t *const bootKeyPtr = (volatile uint16_t *)0x0800;
70
71 void StartSketch(void)
72 {
73 cli();
74
75 /* Undo TIMER1 setup and clear the count before running the sketch */
76 TIMSK1 = 0;
77 TCCR1B = 0;
78 TCNT1H = 0; // 16-bit write to TCNT1 requires high byte be written first
79 TCNT1L = 0;
80
81 /* Relocate the interrupt vector table to the application section */
82 MCUCR = (1 << IVCE);
83 MCUCR = 0;
84
85 L_LED_OFF();
86 TX_LED_OFF();
87 RX_LED_OFF();
88
89 /* jump to beginning of application space */
90 __asm__ volatile("jmp 0x0000");
91 }
92
93 /* Breathing animation on L LED indicates bootloader is running */
94 uint16_t LLEDPulse;
95 void LEDPulse(void)
96 {
97 LLEDPulse++;
98 uint8_t p = LLEDPulse >> 8;
99 if (p > 127)
100 p = 254-p;
101 p += p;
102 if (((uint8_t)LLEDPulse) > p)
103 L_LED_OFF();
104 else
105 L_LED_ON();
106 }
107
108 /** Main program entry point. This routine configures the hardware required by the bootloader, then continuously
109 * runs the bootloader processing routine until it times out or is instructed to exit.
110 */
111 int main(void)
112 {
113 /* Save the value of the boot key memory before it is overwritten */
114 uint16_t bootKeyPtrVal = *bootKeyPtr;
115 *bootKeyPtr = 0;
116
117 /* Check the reason for the reset so we can act accordingly */
118 uint8_t mcusr_state = MCUSR; // store the initial state of the Status register
119 MCUSR = 0; // clear all reset flags
120
121 /* Watchdog may be configured with a 15 ms period so must disable it before going any further */
122 wdt_disable();
123
124 if (mcusr_state & (1<<EXTRF)) {
125 // External reset - we should continue to self-programming mode.
126 } else if ((mcusr_state & (1<<PORF)) && (pgm_read_word(0) != 0xFFFF)) {
127 // After a power-on reset skip the bootloader and jump straight to sketch
128 // if one exists.
129 StartSketch();
130 } else if ((mcusr_state & (1<<WDRF)) && (bootKeyPtrVal != bootKey) && (pgm_read_word(0) != 0xFFFF)) {
131 // If it looks like an "accidental" watchdog reset then start the sketch.
132 StartSketch();
133 }
134
135 /* Setup hardware required for the bootloader */
136 SetupHardware();
137
138 /* Enable global interrupts so that the USB stack can function */
139 sei();
140
141 Timeout = 0;
142
143 while (RunBootloader)
144 {
145 CDC_Task();
146 USB_USBTask();
147 /* Time out and start the sketch if one is present */
148 if (Timeout > TIMEOUT_PERIOD)
149 RunBootloader = false;
150
151 LEDPulse();
152 }
153
154 /* Disconnect from the host - USB interface will be reset later along with the AVR */
155 USB_Detach();
156
157 /* Jump to beginning of application space to run the sketch - do not reset */
158 StartSketch();
159 }
160
161 /** Configures all hardware required for the bootloader. */
162 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 LED_SETUP();
176 CPU_PRESCALE(0);
177 L_LED_OFF();
178 TX_LED_OFF();
179 RX_LED_OFF();
180
181 /* Initialize TIMER1 to handle bootloader timeout and LED tasks.
182 * With 16 MHz clock and 1/64 prescaler, timer 1 is clocked at 250 kHz
183 * Our chosen compare match generates an interrupt every 1 ms.
184 * This interrupt is disabled selectively when doing memory reading, erasing,
185 * or writing since SPM has tight timing requirements.
186 */
187 OCR1AH = 0;
188 OCR1AL = 250;
189 TIMSK1 = (1 << OCIE1A); // enable timer 1 output compare A match interrupt
190 TCCR1B = ((1 << CS11) | (1 << CS10)); // 1/64 prescaler on timer 1 input
191
192 /* Initialize USB Subsystem */
193 USB_Init();
194 }
195
196 //uint16_t ctr = 0;
197 ISR(TIMER1_COMPA_vect, ISR_BLOCK)
198 {
199 /* Reset counter */
200 TCNT1H = 0;
201 TCNT1L = 0;
202
203 /* Check whether the TX or RX LED one-shot period has elapsed. if so, turn off the LED */
204 if (TxLEDPulse && !(--TxLEDPulse))
205 TX_LED_OFF();
206 if (RxLEDPulse && !(--RxLEDPulse))
207 RX_LED_OFF();
208
209 if (pgm_read_word(0) != 0xFFFF)
210 Timeout++;
211 }
212
213 /** Event handler for the USB_ConfigurationChanged event. This configures the device's endpoints ready
214 * to relay data to and from the attached USB host.
215 */
216 void EVENT_USB_Device_ConfigurationChanged(void)
217 {
218 /* Setup CDC Notification, Rx and Tx Endpoints */
219 Endpoint_ConfigureEndpoint(CDC_NOTIFICATION_EPNUM, EP_TYPE_INTERRUPT,
220 ENDPOINT_DIR_IN, CDC_NOTIFICATION_EPSIZE,
221 ENDPOINT_BANK_SINGLE);
222
223 Endpoint_ConfigureEndpoint(CDC_TX_EPNUM, EP_TYPE_BULK,
224 ENDPOINT_DIR_IN, CDC_TXRX_EPSIZE,
225 ENDPOINT_BANK_SINGLE);
226
227 Endpoint_ConfigureEndpoint(CDC_RX_EPNUM, EP_TYPE_BULK,
228 ENDPOINT_DIR_OUT, CDC_TXRX_EPSIZE,
229 ENDPOINT_BANK_SINGLE);
230 }
231
232 /** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
233 * the device from the USB host before passing along unhandled control requests to the library for processing
234 * internally.
235 */
236 void EVENT_USB_Device_ControlRequest(void)
237 {
238 /* Ignore any requests that aren't directed to the CDC interface */
239 if ((USB_ControlRequest.bmRequestType & (CONTROL_REQTYPE_TYPE | CONTROL_REQTYPE_RECIPIENT)) !=
240 (REQTYPE_CLASS | REQREC_INTERFACE))
241 {
242 return;
243 }
244
245 /* Process CDC specific control requests */
246 switch (USB_ControlRequest.bRequest)
247 {
248 case CDC_REQ_GetLineEncoding:
249 if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
250 {
251 Endpoint_ClearSETUP();
252
253 /* Write the line coding data to the control endpoint */
254 Endpoint_Write_Control_Stream_LE(&LineEncoding, sizeof(CDC_LineEncoding_t));
255 Endpoint_ClearOUT();
256 }
257
258 break;
259 case CDC_REQ_SetLineEncoding:
260 if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
261 {
262 Endpoint_ClearSETUP();
263
264 /* Read the line coding data in from the host into the global struct */
265 Endpoint_Read_Control_Stream_LE(&LineEncoding, sizeof(CDC_LineEncoding_t));
266 Endpoint_ClearIN();
267 }
268
269 break;
270 }
271 }
272
273 #if !defined(NO_BLOCK_SUPPORT)
274 /** Reads or writes a block of EEPROM or FLASH memory to or from the appropriate CDC data endpoint, depending
275 * on the AVR910 protocol command issued.
276 *
277 * \param[in] Command Single character AVR910 protocol command indicating what memory operation to perform
278 */
279 static void ReadWriteMemoryBlock(const uint8_t Command)
280 {
281 uint16_t BlockSize;
282 char MemoryType;
283
284 bool HighByte = false;
285 uint8_t LowByte = 0;
286
287 BlockSize = (FetchNextCommandByte() << 8);
288 BlockSize |= FetchNextCommandByte();
289
290 MemoryType = FetchNextCommandByte();
291
292 if ((MemoryType != 'E') && (MemoryType != 'F'))
293 {
294 /* Send error byte back to the host */
295 WriteNextResponseByte('?');
296
297 return;
298 }
299
300 /* Disable timer 1 interrupt - can't afford to process nonessential interrupts
301 * while doing SPM tasks */
302 TIMSK1 = 0;
303
304 /* Check if command is to read memory */
305 if (Command == 'g')
306 {
307 /* Re-enable RWW section */
308 boot_rww_enable();
309
310 while (BlockSize--)
311 {
312 if (MemoryType == 'F')
313 {
314 /* Read the next FLASH byte from the current FLASH page */
315 #if (FLASHEND > 0xFFFF)
316 WriteNextResponseByte(pgm_read_byte_far(CurrAddress | HighByte));
317 #else
318 WriteNextResponseByte(pgm_read_byte(CurrAddress | HighByte));
319 #endif
320
321 /* If both bytes in current word have been read, increment the address counter */
322 if (HighByte)
323 CurrAddress += 2;
324
325 HighByte = !HighByte;
326 }
327 else
328 {
329 /* Read the next EEPROM byte into the endpoint */
330 WriteNextResponseByte(eeprom_read_byte((uint8_t*)(intptr_t)(CurrAddress >> 1)));
331
332 /* Increment the address counter after use */
333 CurrAddress += 2;
334 }
335 }
336 }
337 else
338 {
339 uint32_t PageStartAddress = CurrAddress;
340
341 if (MemoryType == 'F')
342 {
343 boot_page_erase(PageStartAddress);
344 boot_spm_busy_wait();
345 }
346
347 while (BlockSize--)
348 {
349 if (MemoryType == 'F')
350 {
351 /* If both bytes in current word have been written, increment the address counter */
352 if (HighByte)
353 {
354 /* Write the next FLASH word to the current FLASH page */
355 boot_page_fill(CurrAddress, ((FetchNextCommandByte() << 8) | LowByte));
356
357 /* Increment the address counter after use */
358 CurrAddress += 2;
359 }
360 else
361 {
362 LowByte = FetchNextCommandByte();
363 }
364
365 HighByte = !HighByte;
366 }
367 else
368 {
369 /* Write the next EEPROM byte from the endpoint */
370 eeprom_write_byte((uint8_t*)((intptr_t)(CurrAddress >> 1)), FetchNextCommandByte());
371
372 /* Increment the address counter after use */
373 CurrAddress += 2;
374 }
375 }
376
377 /* If in FLASH programming mode, commit the page after writing */
378 if (MemoryType == 'F')
379 {
380 /* Commit the flash page to memory */
381 boot_page_write(PageStartAddress);
382
383 /* Wait until write operation has completed */
384 boot_spm_busy_wait();
385 }
386
387 /* Send response byte back to the host */
388 WriteNextResponseByte('\r');
389 }
390
391 /* Re-enable timer 1 interrupt disabled earlier in this routine */
392 TIMSK1 = (1 << OCIE1A);
393 }
394 #endif
395
396 /** Retrieves the next byte from the host in the CDC data OUT endpoint, and clears the endpoint bank if needed
397 * to allow reception of the next data packet from the host.
398 *
399 * \return Next received byte from the host in the CDC data OUT endpoint
400 */
401 static uint8_t FetchNextCommandByte(void)
402 {
403 /* Select the OUT endpoint so that the next data byte can be read */
404 Endpoint_SelectEndpoint(CDC_RX_EPNUM);
405
406 /* If OUT endpoint empty, clear it and wait for the next packet from the host */
407 while (!(Endpoint_IsReadWriteAllowed()))
408 {
409 Endpoint_ClearOUT();
410
411 while (!(Endpoint_IsOUTReceived()))
412 {
413 if (USB_DeviceState == DEVICE_STATE_Unattached)
414 return 0;
415 }
416 }
417
418 /* Fetch the next byte from the OUT endpoint */
419 return Endpoint_Read_8();
420 }
421
422 /** Writes the next response byte to the CDC data IN endpoint, and sends the endpoint back if needed to free up the
423 * bank when full ready for the next byte in the packet to the host.
424 *
425 * \param[in] Response Next response byte to send to the host
426 */
427 static void WriteNextResponseByte(const uint8_t Response)
428 {
429 /* Select the IN endpoint so that the next data byte can be written */
430 Endpoint_SelectEndpoint(CDC_TX_EPNUM);
431
432 /* If IN endpoint full, clear it and wait until ready for the next packet to the host */
433 if (!(Endpoint_IsReadWriteAllowed()))
434 {
435 Endpoint_ClearIN();
436
437 while (!(Endpoint_IsINReady()))
438 {
439 if (USB_DeviceState == DEVICE_STATE_Unattached)
440 return;
441 }
442 }
443
444 /* Write the next byte to the IN endpoint */
445 Endpoint_Write_8(Response);
446
447 TX_LED_ON();
448 TxLEDPulse = TX_RX_LED_PULSE_PERIOD;
449 }
450
451 #define STK_OK 0x10
452 #define STK_INSYNC 0x14 // ' '
453 #define CRC_EOP 0x20 // 'SPACE'
454 #define STK_GET_SYNC 0x30 // '0'
455
456 #define STK_GET_PARAMETER 0x41 // 'A'
457 #define STK_SET_DEVICE 0x42 // 'B'
458 #define STK_SET_DEVICE_EXT 0x45 // 'E'
459 #define STK_LOAD_ADDRESS 0x55 // 'U'
460 #define STK_UNIVERSAL 0x56 // 'V'
461 #define STK_PROG_PAGE 0x64 // 'd'
462 #define STK_READ_PAGE 0x74 // 't'
463 #define STK_READ_SIGN 0x75 // 'u'
464
465 /** Task to read in AVR910 commands from the CDC data OUT endpoint, process them, perform the required actions
466 * and send the appropriate response back to the host.
467 */
468 void CDC_Task(void)
469 {
470 /* Select the OUT endpoint */
471 Endpoint_SelectEndpoint(CDC_RX_EPNUM);
472
473 /* Check if endpoint has a command in it sent from the host */
474 if (!(Endpoint_IsOUTReceived()))
475 return;
476
477 RX_LED_ON();
478 RxLEDPulse = TX_RX_LED_PULSE_PERIOD;
479
480 /* Read in the bootloader command (first byte sent from host) */
481 uint8_t Command = FetchNextCommandByte();
482
483 if (Command == 'E')
484 {
485 /* We nearly run out the bootloader timeout clock,
486 * leaving just a few hundred milliseconds so the
487 * bootloder has time to respond and service any
488 * subsequent requests */
489 Timeout = TIMEOUT_PERIOD - 500;
490
491 /* Re-enable RWW section - must be done here in case
492 * user has disabled verification on upload. */
493 boot_rww_enable_safe();
494
495 // Send confirmation byte back to the host
496 WriteNextResponseByte('\r');
497 }
498 else if (Command == 'T')
499 {
500 FetchNextCommandByte();
501
502 // Send confirmation byte back to the host
503 WriteNextResponseByte('\r');
504 }
505 else if ((Command == 'L') || (Command == 'P'))
506 {
507 // Send confirmation byte back to the host
508 WriteNextResponseByte('\r');
509 }
510 else if (Command == 't')
511 {
512 // Return ATMEGA128 part code - this is only to allow AVRProg to use the bootloader
513 WriteNextResponseByte(0x44);
514 WriteNextResponseByte(0x00);
515 }
516 else if (Command == 'a')
517 {
518 // Indicate auto-address increment is supported
519 WriteNextResponseByte('Y');
520 }
521 else if (Command == 'A')
522 {
523 // Set the current address to that given by the host
524 CurrAddress = (FetchNextCommandByte() << 9);
525 CurrAddress |= (FetchNextCommandByte() << 1);
526
527 // Send confirmation byte back to the host
528 WriteNextResponseByte('\r');
529 }
530 else if (Command == 'p')
531 {
532 // Indicate serial programmer back to the host
533 WriteNextResponseByte('S');
534 }
535 else if (Command == 'S')
536 {
537 // Write the 7-byte software identifier to the endpoint
538 for (uint8_t CurrByte = 0; CurrByte < 7; CurrByte++)
539 WriteNextResponseByte(SOFTWARE_IDENTIFIER[CurrByte]);
540 }
541 else if (Command == 'V')
542 {
543 WriteNextResponseByte('0' + BOOTLOADER_VERSION_MAJOR);
544 WriteNextResponseByte('0' + BOOTLOADER_VERSION_MINOR);
545 }
546 else if (Command == 's')
547 {
548 WriteNextResponseByte(AVR_SIGNATURE_3);
549 WriteNextResponseByte(AVR_SIGNATURE_2);
550 WriteNextResponseByte(AVR_SIGNATURE_1);
551 }
552 else if (Command == 'e')
553 {
554 // Clear the application section of flash
555 for (uint32_t CurrFlashAddress = 0; CurrFlashAddress < BOOT_START_ADDR; CurrFlashAddress += SPM_PAGESIZE)
556 {
557 boot_page_erase(CurrFlashAddress);
558 boot_spm_busy_wait();
559 boot_page_write(CurrFlashAddress);
560 boot_spm_busy_wait();
561 }
562
563 // Send confirmation byte back to the host
564 WriteNextResponseByte('\r');
565 }
566 #if !defined(NO_LOCK_BYTE_WRITE_SUPPORT)
567 else if (Command == 'l')
568 {
569 // Set the lock bits to those given by the host
570 boot_lock_bits_set(FetchNextCommandByte());
571
572 // Send confirmation byte back to the host
573 WriteNextResponseByte('\r');
574 }
575 #endif
576 else if (Command == 'r')
577 {
578 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_LOCK_BITS));
579 }
580 else if (Command == 'F')
581 {
582 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_LOW_FUSE_BITS));
583 }
584 else if (Command == 'N')
585 {
586 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_HIGH_FUSE_BITS));
587 }
588 else if (Command == 'Q')
589 {
590 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_EXTENDED_FUSE_BITS));
591 }
592 #if !defined(NO_BLOCK_SUPPORT)
593 else if (Command == 'b')
594 {
595 WriteNextResponseByte('Y');
596
597 // Send block size to the host
598 WriteNextResponseByte(SPM_PAGESIZE >> 8);
599 WriteNextResponseByte(SPM_PAGESIZE & 0xFF);
600 }
601 else if ((Command == 'B') || (Command == 'g'))
602 {
603 // Keep resetting the timeout counter if we're receiving self-programming instructions
604 Timeout = 0;
605 // Delegate the block write/read to a separate function for clarity
606 ReadWriteMemoryBlock(Command);
607 }
608 #endif
609 #if !defined(NO_FLASH_BYTE_SUPPORT)
610 else if (Command == 'C')
611 {
612 // Write the high byte to the current flash page
613 boot_page_fill(CurrAddress, FetchNextCommandByte());
614
615 // Send confirmation byte back to the host
616 WriteNextResponseByte('\r');
617 }
618 else if (Command == 'c')
619 {
620 // Write the low byte to the current flash page
621 boot_page_fill(CurrAddress | 0x01, FetchNextCommandByte());
622
623 // Increment the address
624 CurrAddress += 2;
625
626 // Send confirmation byte back to the host
627 WriteNextResponseByte('\r');
628 }
629 else if (Command == 'm')
630 {
631 // Commit the flash page to memory
632 boot_page_write(CurrAddress);
633
634 // Wait until write operation has completed
635 boot_spm_busy_wait();
636
637 // Send confirmation byte back to the host
638 WriteNextResponseByte('\r');
639 }
640 else if (Command == 'R')
641 {
642 #if (FLASHEND > 0xFFFF)
643 uint16_t ProgramWord = pgm_read_word_far(CurrAddress);
644 #else
645 uint16_t ProgramWord = pgm_read_word(CurrAddress);
646 #endif
647
648 WriteNextResponseByte(ProgramWord >> 8);
649 WriteNextResponseByte(ProgramWord & 0xFF);
650 }
651 #endif
652 #if !defined(NO_EEPROM_BYTE_SUPPORT)
653 else if (Command == 'D')
654 {
655 // Read the byte from the endpoint and write it to the EEPROM
656 eeprom_write_byte((uint8_t*)((intptr_t)(CurrAddress >> 1)), FetchNextCommandByte());
657
658 // Increment the address after use
659 CurrAddress += 2;
660
661 // Send confirmation byte back to the host
662 WriteNextResponseByte('\r');
663 }
664 else if (Command == 'd')
665 {
666 // Read the EEPROM byte and write it to the endpoint
667 WriteNextResponseByte(eeprom_read_byte((uint8_t*)((intptr_t)(CurrAddress >> 1))));
668
669 // Increment the address after use
670 CurrAddress += 2;
671 }
672 #endif
673 else if (Command != 27)
674 {
675 // Unknown (non-sync) command, return fail code
676 WriteNextResponseByte('?');
677 }
678
679
680 /* Select the IN endpoint */
681 Endpoint_SelectEndpoint(CDC_TX_EPNUM);
682
683 /* Remember if the endpoint is completely full before clearing it */
684 bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());
685
686 /* Send the endpoint data to the host */
687 Endpoint_ClearIN();
688
689 /* If a full endpoint's worth of data was sent, we need to send an empty packet afterwards to signal end of transfer */
690 if (IsEndpointFull)
691 {
692 while (!(Endpoint_IsINReady()))
693 {
694 if (USB_DeviceState == DEVICE_STATE_Unattached)
695 return;
696 }
697
698 Endpoint_ClearIN();
699 }
700
701 /* Wait until the data has been sent to the host */
702 while (!(Endpoint_IsINReady()))
703 {
704 if (USB_DeviceState == DEVICE_STATE_Unattached)
705 return;
706 }
707
708 /* Select the OUT endpoint */
709 Endpoint_SelectEndpoint(CDC_RX_EPNUM);
710
711 /* Acknowledge the command from the host */
712 Endpoint_ClearOUT();
713 }
714