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