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