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 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         sei();
 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         bool     HighByte = false;
 241         uint8_t  LowByte  = 0;
 242
 243         BlockSize  = (FetchNextCommandByte() << 8);
 244         BlockSize |=  FetchNextCommandByte();
 245
 246         MemoryType =  FetchNextCommandByte();
 247
 248         if ((MemoryType != 'E') && (MemoryType != 'F'))
 249         {
 250                 /* Send error byte back to the host */
 251                 WriteNextResponseByte('?');
 252
 253                 return;
 254         }
 255
 256         /* Check if command is to read memory */
 257         if (Command == 'g')
 258         {
 259                 /* Re-enable RWW section */
 260                 boot_rww_enable();
 261
 262                 while (BlockSize--)
 263                 {
 264                         if (MemoryType == 'F')
 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 == 'F')
 294                 {
 295                         boot_page_erase(PageStartAddress);
 296                         boot_spm_busy_wait();
 297                 }
 298
 299                 while (BlockSize--)
 300                 {
 301                         if (MemoryType == 'F')
 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 == 'F')
 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 == 'E')
 413         {
 414                 RunBootloader = false;
 415
 416                 /* Send confirmation byte back to the host */
 417                 WriteNextResponseByte('\r');
 418         }
 419         else if (Command == 'T')
 420         {
 421                 FetchNextCommandByte();
 422
 423                 /* Send confirmation byte back to the host */
 424                 WriteNextResponseByte('\r');
 425         }
 426         else if ((Command == 'L') || (Command == 'P'))
 427         {
 428                 /* Send confirmation byte back to the host */
 429                 WriteNextResponseByte('\r');
 430         }
 431         else if (Command == 't')
 432         {
 433                 /* Return ATMEGA128 part code - this is only to allow AVRProg to use the bootloader */
 434                 WriteNextResponseByte(0x44);
 435                 WriteNextResponseByte(0x00);
 436         }
 437         else if (Command == 'a')
 438         {
 439                 /* Indicate auto-address increment is supported */
 440                 WriteNextResponseByte('Y');
 441         }
 442         else if (Command == 'A')
 443         {
 444                 /* Set the current address to that given by the host */
 445                 CurrAddress   = (FetchNextCommandByte() << 9);
 446                 CurrAddress  |= (FetchNextCommandByte() << 1);
 447
 448                 /* Send confirmation byte back to the host */
 449                 WriteNextResponseByte('\r');
 450         }
 451         else if (Command == 'p')
 452         {
 453                 /* Indicate serial programmer back to the host */
 454                 WriteNextResponseByte('S');
 455         }
 456         else if (Command == 'S')
 457         {
 458                 /* Write the 7-byte software identifier to the endpoint */
 459                 for (uint8_t CurrByte = 0; CurrByte < 7; CurrByte++)
 460                   WriteNextResponseByte(SOFTWARE_IDENTIFIER[CurrByte]);
 461         }
 462         else if (Command == 'V')
 463         {
 464                 WriteNextResponseByte('0' + BOOTLOADER_VERSION_MAJOR);
 465                 WriteNextResponseByte('0' + BOOTLOADER_VERSION_MINOR);
 466         }
 467         else if (Command == 's')
 468         {
 469                 WriteNextResponseByte(AVR_SIGNATURE_3);
 470                 WriteNextResponseByte(AVR_SIGNATURE_2);
 471                 WriteNextResponseByte(AVR_SIGNATURE_1);
 472         }
 473         else if (Command == 'e')
 474         {
 475                 /* Clear the application section of flash */
 476                 for (uint32_t CurrFlashAddress = 0; CurrFlashAddress < (uint32_t)BOOT_START_ADDR; CurrFlashAddress += SPM_PAGESIZE)
 477                 {
 478                         boot_page_erase(CurrFlashAddress);
 479                         boot_spm_busy_wait();
 480                         boot_page_write(CurrFlashAddress);
 481                         boot_spm_busy_wait();
 482                 }
 483
 484                 /* Send confirmation byte back to the host */
 485                 WriteNextResponseByte('\r');
 486         }
 487         #if !defined(NO_LOCK_BYTE_WRITE_SUPPORT)
 488         else if (Command == 'l')
 489         {
 490                 /* Set the lock bits to those given by the host */
 491                 boot_lock_bits_set(FetchNextCommandByte());
 492
 493                 /* Send confirmation byte back to the host */
 494                 WriteNextResponseByte('\r');
 495         }
 496         #endif
 497         else if (Command == 'r')
 498         {
 499                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_LOCK_BITS));
 500         }
 501         else if (Command == 'F')
 502         {
 503                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_LOW_FUSE_BITS));
 504         }
 505         else if (Command == 'N')
 506         {
 507                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_HIGH_FUSE_BITS));
 508         }
 509         else if (Command == 'Q')
 510         {
 511                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_EXTENDED_FUSE_BITS));
 512         }
 513         #if !defined(NO_BLOCK_SUPPORT)
 514         else if (Command == 'b')
 515         {
 516                 WriteNextResponseByte('Y');
 517
 518                 /* Send block size to the host */
 519                 WriteNextResponseByte(SPM_PAGESIZE >> 8);
 520                 WriteNextResponseByte(SPM_PAGESIZE & 0xFF);
 521         }
 522         else if ((Command == 'B') || (Command == 'g'))
 523         {
 524                 /* Delegate the block write/read to a separate function for clarity */
 525                 ReadWriteMemoryBlock(Command);
 526         }
 527         #endif
 528         #if !defined(NO_FLASH_BYTE_SUPPORT)
 529         else if (Command == 'C')
 530         {
 531                 /* Write the high byte to the current flash page */
 532                 boot_page_fill(CurrAddress, FetchNextCommandByte());
 533
 534                 /* Send confirmation byte back to the host */
 535                 WriteNextResponseByte('\r');
 536         }
 537         else if (Command == 'c')
 538         {
 539                 /* Write the low byte to the current flash page */
 540                 boot_page_fill(CurrAddress | 0x01, FetchNextCommandByte());
 541
 542                 /* Increment the address */
 543                 CurrAddress += 2;
 544
 545                 /* Send confirmation byte back to the host */
 546                 WriteNextResponseByte('\r');
 547         }
 548         else if (Command == 'm')
 549         {
 550                 /* Commit the flash page to memory */
 551                 boot_page_write(CurrAddress);
 552
 553                 /* Wait until write operation has completed */
 554                 boot_spm_busy_wait();
 555
 556                 /* Send confirmation byte back to the host */
 557                 WriteNextResponseByte('\r');
 558         }
 559         else if (Command == 'R')
 560         {
 561                 #if (FLASHEND > 0xFFFF)
 562                 uint16_t ProgramWord = pgm_read_word_far(CurrAddress);
 563                 #else
 564                 uint16_t ProgramWord = pgm_read_word(CurrAddress);
 565                 #endif
 566
 567                 WriteNextResponseByte(ProgramWord >> 8);
 568                 WriteNextResponseByte(ProgramWord & 0xFF);
 569         }
 570         #endif
 571         #if !defined(NO_EEPROM_BYTE_SUPPORT)
 572         else if (Command == 'D')
 573         {
 574                 /* Read the byte from the endpoint and write it to the EEPROM */
 575                 eeprom_write_byte((uint8_t*)((intptr_t)(CurrAddress >> 1)), FetchNextCommandByte());
 576
 577                 /* Increment the address after use */
 578                 CurrAddress += 2;
 579
 580                 /* Send confirmation byte back to the host */
 581                 WriteNextResponseByte('\r');
 582         }
 583         else if (Command == 'd')
 584         {
 585                 /* Read the EEPROM byte and write it to the endpoint */
 586                 WriteNextResponseByte(eeprom_read_byte((uint8_t*)((intptr_t)(CurrAddress >> 1))));
 587
 588                 /* Increment the address after use */
 589                 CurrAddress += 2;
 590         }
 591         #endif
 592         else if (Command != 27)
 593         {
 594                 /* Unknown (non-sync) command, return fail code */
 595                 WriteNextResponseByte('?');
 596         }
 597
 598         /* Select the IN endpoint */
 599         Endpoint_SelectEndpoint(CDC_TX_EPADDR);
 600
 601         /* Remember if the endpoint is completely full before clearing it */
 602         bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());
 603
 604         /* Send the endpoint data to the host */
 605         Endpoint_ClearIN();
 606
 607         /* If a full endpoint's worth of data was sent, we need to send an empty packet afterwards to signal end of transfer */
 608         if (IsEndpointFull)
 609         {
 610                 while (!(Endpoint_IsINReady()))
 611                 {
 612                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 613                           return;
 614                 }
 615
 616                 Endpoint_ClearIN();
 617         }
 618
 619         /* Wait until the data has been sent to the host */
 620         while (!(Endpoint_IsINReady()))
 621         {
 622                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 623                   return;
 624         }
 625
 626         /* Select the OUT endpoint */
 627         Endpoint_SelectEndpoint(CDC_RX_EPADDR);
 628
 629         /* Acknowledge the command from the host */
 630         Endpoint_ClearOUT();
 631 }
 632