Bootloaders/CDC/BootloaderCDC.c

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