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