Bootloaders/CDC/BootloaderCDC.c

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