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 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 static 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 the USB and other board hardware drivers */
 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         /* Activity - toggle indicator LEDs */
 152         LEDs_ToggleLEDs(LEDS_LED1 | LEDS_LED2);
 153
 154         /* Process CDC specific control requests */
 155         switch (USB_ControlRequest.bRequest)
 156         {
 157                 case CDC_REQ_GetLineEncoding:
 158                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 159                         {
 160                                 Endpoint_ClearSETUP();
 161
 162                                 /* Write the line coding data to the control endpoint */
 163                                 Endpoint_Write_Control_Stream_LE(&LineEncoding, sizeof(CDC_LineEncoding_t));
 164                                 Endpoint_ClearOUT();
 165                         }
 166
 167                         break;
 168                 case CDC_REQ_SetLineEncoding:
 169                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 170                         {
 171                                 Endpoint_ClearSETUP();
 172
 173                                 /* Read the line coding data in from the host into the global struct */
 174                                 Endpoint_Read_Control_Stream_LE(&LineEncoding, sizeof(CDC_LineEncoding_t));
 175                                 Endpoint_ClearIN();
 176                         }
 177
 178                         break;
 179         }
 180 }
 181
 182 #if !defined(NO_BLOCK_SUPPORT)
 183 /** Reads or writes a block of EEPROM or FLASH memory to or from the appropriate CDC data endpoint, depending
 184  *  on the AVR910 protocol command issued.
 185  *
 186  *  \param[in] Command  Single character AVR910 protocol command indicating what memory operation to perform
 187  */
 188 static void ReadWriteMemoryBlock(const uint8_t Command)
 189 {
 190         uint16_t BlockSize;
 191         char     MemoryType;
 192
 193         bool     HighByte = false;
 194         uint8_t  LowByte  = 0;
 195
 196         BlockSize  = (FetchNextCommandByte() << 8);
 197         BlockSize |=  FetchNextCommandByte();
 198
 199         MemoryType =  FetchNextCommandByte();
 200
 201         if ((MemoryType != 'E') && (MemoryType != 'F'))
 202         {
 203                 /* Send error byte back to the host */
 204                 WriteNextResponseByte('?');
 205
 206                 return;
 207         }
 208
 209         /* Check if command is to read memory */
 210         if (Command == 'g')
 211         {
 212                 /* Re-enable RWW section */
 213                 boot_rww_enable();
 214
 215                 while (BlockSize--)
 216                 {
 217                         if (MemoryType == 'F')
 218                         {
 219                                 /* Read the next FLASH byte from the current FLASH page */
 220                                 #if (FLASHEND > 0xFFFF)
 221                                 WriteNextResponseByte(pgm_read_byte_far(CurrAddress | HighByte));
 222                                 #else
 223                                 WriteNextResponseByte(pgm_read_byte(CurrAddress | HighByte));
 224                                 #endif
 225
 226                                 /* If both bytes in current word have been read, increment the address counter */
 227                                 if (HighByte)
 228                                   CurrAddress += 2;
 229
 230                                 HighByte = !HighByte;
 231                         }
 232                         else
 233                         {
 234                                 /* Read the next EEPROM byte into the endpoint */
 235                                 WriteNextResponseByte(eeprom_read_byte((uint8_t*)(intptr_t)(CurrAddress >> 1)));
 236
 237                                 /* Increment the address counter after use */
 238                                 CurrAddress += 2;
 239                         }
 240                 }
 241         }
 242         else
 243         {
 244                 uint32_t PageStartAddress = CurrAddress;
 245
 246                 if (MemoryType == 'F')
 247                 {
 248                         boot_page_erase(PageStartAddress);
 249                         boot_spm_busy_wait();
 250                 }
 251
 252                 while (BlockSize--)
 253                 {
 254                         if (MemoryType == 'F')
 255                         {
 256                                 /* If both bytes in current word have been written, increment the address counter */
 257                                 if (HighByte)
 258                                 {
 259                                         /* Write the next FLASH word to the current FLASH page */
 260                                         boot_page_fill(CurrAddress, ((FetchNextCommandByte() << 8) | LowByte));
 261
 262                                         /* Increment the address counter after use */
 263                                         CurrAddress += 2;
 264                                 }
 265                                 else
 266                                 {
 267                                         LowByte = FetchNextCommandByte();
 268                                 }
 269
 270                                 HighByte = !HighByte;
 271                         }
 272                         else
 273                         {
 274                                 /* Write the next EEPROM byte from the endpoint */
 275                                 eeprom_write_byte((uint8_t*)((intptr_t)(CurrAddress >> 1)), FetchNextCommandByte());
 276
 277                                 /* Increment the address counter after use */
 278                                 CurrAddress += 2;
 279                         }
 280                 }
 281
 282                 /* If in FLASH programming mode, commit the page after writing */
 283                 if (MemoryType == 'F')
 284                 {
 285                         /* Commit the flash page to memory */
 286                         boot_page_write(PageStartAddress);
 287
 288                         /* Wait until write operation has completed */
 289                         boot_spm_busy_wait();
 290                 }
 291
 292                 /* Send response byte back to the host */
 293                 WriteNextResponseByte('\r');
 294         }
 295 }
 296 #endif
 297
 298 /** Retrieves the next byte from the host in the CDC data OUT endpoint, and clears the endpoint bank if needed
 299  *  to allow reception of the next data packet from the host.
 300  *
 301  *  \return Next received byte from the host in the CDC data OUT endpoint
 302  */
 303 static uint8_t FetchNextCommandByte(void)
 304 {
 305         /* Select the OUT endpoint so that the next data byte can be read */
 306         Endpoint_SelectEndpoint(CDC_RX_EPNUM);
 307
 308         /* If OUT endpoint empty, clear it and wait for the next packet from the host */
 309         while (!(Endpoint_IsReadWriteAllowed()))
 310         {
 311                 Endpoint_ClearOUT();
 312
 313                 while (!(Endpoint_IsOUTReceived()))
 314                 {
 315                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 316                           return 0;
 317                 }
 318         }
 319
 320         /* Fetch the next byte from the OUT endpoint */
 321         return Endpoint_Read_8();
 322 }
 323
 324 /** Writes the next response byte to the CDC data IN endpoint, and sends the endpoint back if needed to free up the
 325  *  bank when full ready for the next byte in the packet to the host.
 326  *
 327  *  \param[in] Response  Next response byte to send to the host
 328  */
 329 static void WriteNextResponseByte(const uint8_t Response)
 330 {
 331         /* Select the IN endpoint so that the next data byte can be written */
 332         Endpoint_SelectEndpoint(CDC_TX_EPNUM);
 333
 334         /* If IN endpoint full, clear it and wait until ready for the next packet to the host */
 335         if (!(Endpoint_IsReadWriteAllowed()))
 336         {
 337                 Endpoint_ClearIN();
 338
 339                 while (!(Endpoint_IsINReady()))
 340                 {
 341                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 342                           return;
 343                 }
 344         }
 345
 346         /* Write the next byte to the IN endpoint */
 347         Endpoint_Write_8(Response);
 348 }
 349
 350 /** Task to read in AVR910 commands from the CDC data OUT endpoint, process them, perform the required actions
 351  *  and send the appropriate response back to the host.
 352  */
 353 static void CDC_Task(void)
 354 {
 355         /* Select the OUT endpoint */
 356         Endpoint_SelectEndpoint(CDC_RX_EPNUM);
 357
 358         /* Check if endpoint has a command in it sent from the host */
 359         if (!(Endpoint_IsOUTReceived()))
 360           return;
 361
 362         /* Read in the bootloader command (first byte sent from host) */
 363         uint8_t Command = FetchNextCommandByte();
 364
 365         if (Command == 'E')
 366         {
 367                 RunBootloader = false;
 368
 369                 /* Send confirmation byte back to the host */
 370                 WriteNextResponseByte('\r');
 371         }
 372         else if (Command == 'T')
 373         {
 374                 FetchNextCommandByte();
 375
 376                 /* Send confirmation byte back to the host */
 377                 WriteNextResponseByte('\r');
 378         }
 379         else if ((Command == 'L') || (Command == 'P'))
 380         {
 381                 /* Send confirmation byte back to the host */
 382                 WriteNextResponseByte('\r');
 383         }
 384         else if (Command == 't')
 385         {
 386                 /* Return ATMEGA128 part code - this is only to allow AVRProg to use the bootloader */
 387                 WriteNextResponseByte(0x44);
 388                 WriteNextResponseByte(0x00);
 389         }
 390         else if (Command == 'a')
 391         {
 392                 /* Indicate auto-address increment is supported */
 393                 WriteNextResponseByte('Y');
 394         }
 395         else if (Command == 'A')
 396         {
 397                 /* Set the current address to that given by the host */
 398                 CurrAddress   = (FetchNextCommandByte() << 9);
 399                 CurrAddress  |= (FetchNextCommandByte() << 1);
 400
 401                 /* Send confirmation byte back to the host */
 402                 WriteNextResponseByte('\r');
 403         }
 404         else if (Command == 'p')
 405         {
 406                 /* Indicate serial programmer back to the host */
 407                 WriteNextResponseByte('S');
 408         }
 409         else if (Command == 'S')
 410         {
 411                 /* Write the 7-byte software identifier to the endpoint */
 412                 for (uint8_t CurrByte = 0; CurrByte < 7; CurrByte++)
 413                   WriteNextResponseByte(SOFTWARE_IDENTIFIER[CurrByte]);
 414         }
 415         else if (Command == 'V')
 416         {
 417                 WriteNextResponseByte('0' + BOOTLOADER_VERSION_MAJOR);
 418                 WriteNextResponseByte('0' + BOOTLOADER_VERSION_MINOR);
 419         }
 420         else if (Command == 's')
 421         {
 422                 WriteNextResponseByte(AVR_SIGNATURE_3);
 423                 WriteNextResponseByte(AVR_SIGNATURE_2);
 424                 WriteNextResponseByte(AVR_SIGNATURE_1);
 425         }
 426         else if (Command == 'e')
 427         {
 428                 /* Clear the application section of flash */
 429                 for (uint32_t CurrFlashAddress = 0; CurrFlashAddress < BOOT_START_ADDR; CurrFlashAddress += SPM_PAGESIZE)
 430                 {
 431                         boot_page_erase(CurrFlashAddress);
 432                         boot_spm_busy_wait();
 433                         boot_page_write(CurrFlashAddress);
 434                         boot_spm_busy_wait();
 435                 }
 436
 437                 /* Send confirmation byte back to the host */
 438                 WriteNextResponseByte('\r');
 439         }
 440         #if !defined(NO_LOCK_BYTE_WRITE_SUPPORT)
 441         else if (Command == 'l')
 442         {
 443                 /* Set the lock bits to those given by the host */
 444                 boot_lock_bits_set(FetchNextCommandByte());
 445
 446                 /* Send confirmation byte back to the host */
 447                 WriteNextResponseByte('\r');
 448         }
 449         #endif
 450         else if (Command == 'r')
 451         {
 452                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_LOCK_BITS));
 453         }
 454         else if (Command == 'F')
 455         {
 456                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_LOW_FUSE_BITS));
 457         }
 458         else if (Command == 'N')
 459         {
 460                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_HIGH_FUSE_BITS));
 461         }
 462         else if (Command == 'Q')
 463         {
 464                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_EXTENDED_FUSE_BITS));
 465         }
 466         #if !defined(NO_BLOCK_SUPPORT)
 467         else if (Command == 'b')
 468         {
 469                 WriteNextResponseByte('Y');
 470
 471                 /* Send block size to the host */
 472                 WriteNextResponseByte(SPM_PAGESIZE >> 8);
 473                 WriteNextResponseByte(SPM_PAGESIZE & 0xFF);
 474         }
 475         else if ((Command == 'B') || (Command == 'g'))
 476         {
 477                 /* Delegate the block write/read to a separate function for clarity */
 478                 ReadWriteMemoryBlock(Command);
 479         }
 480         #endif
 481         #if !defined(NO_FLASH_BYTE_SUPPORT)
 482         else if (Command == 'C')
 483         {
 484                 /* Write the high byte to the current flash page */
 485                 boot_page_fill(CurrAddress, FetchNextCommandByte());
 486
 487                 /* Send confirmation byte back to the host */
 488                 WriteNextResponseByte('\r');
 489         }
 490         else if (Command == 'c')
 491         {
 492                 /* Write the low byte to the current flash page */
 493                 boot_page_fill(CurrAddress | 0x01, FetchNextCommandByte());
 494
 495                 /* Increment the address */
 496                 CurrAddress += 2;
 497
 498                 /* Send confirmation byte back to the host */
 499                 WriteNextResponseByte('\r');
 500         }
 501         else if (Command == 'm')
 502         {
 503                 /* Commit the flash page to memory */
 504                 boot_page_write(CurrAddress);
 505
 506                 /* Wait until write operation has completed */
 507                 boot_spm_busy_wait();
 508
 509                 /* Send confirmation byte back to the host */
 510                 WriteNextResponseByte('\r');
 511         }
 512         else if (Command == 'R')
 513         {
 514                 #if (FLASHEND > 0xFFFF)
 515                 uint16_t ProgramWord = pgm_read_word_far(CurrAddress);
 516                 #else
 517                 uint16_t ProgramWord = pgm_read_word(CurrAddress);
 518                 #endif
 519
 520                 WriteNextResponseByte(ProgramWord >> 8);
 521                 WriteNextResponseByte(ProgramWord & 0xFF);
 522         }
 523         #endif
 524         #if !defined(NO_EEPROM_BYTE_SUPPORT)
 525         else if (Command == 'D')
 526         {
 527                 /* Read the byte from the endpoint and write it to the EEPROM */
 528                 eeprom_write_byte((uint8_t*)((intptr_t)(CurrAddress >> 1)), FetchNextCommandByte());
 529
 530                 /* Increment the address after use */
 531                 CurrAddress += 2;
 532
 533                 /* Send confirmation byte back to the host */
 534                 WriteNextResponseByte('\r');
 535         }
 536         else if (Command == 'd')
 537         {
 538                 /* Read the EEPROM byte and write it to the endpoint */
 539                 WriteNextResponseByte(eeprom_read_byte((uint8_t*)((intptr_t)(CurrAddress >> 1))));
 540
 541                 /* Increment the address after use */
 542                 CurrAddress += 2;
 543         }
 544         #endif
 545         else if (Command != 27)
 546         {
 547                 /* Unknown (non-sync) command, return fail code */
 548                 WriteNextResponseByte('?');
 549         }
 550
 551         /* Select the IN endpoint */
 552         Endpoint_SelectEndpoint(CDC_TX_EPNUM);
 553
 554         /* Remember if the endpoint is completely full before clearing it */
 555         bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());
 556
 557         /* Send the endpoint data to the host */
 558         Endpoint_ClearIN();
 559
 560         /* If a full endpoint's worth of data was sent, we need to send an empty packet afterwards to signal end of transfer */
 561         if (IsEndpointFull)
 562         {
 563                 while (!(Endpoint_IsINReady()))
 564                 {
 565                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 566                           return;
 567                 }
 568
 569                 Endpoint_ClearIN();
 570         }
 571
 572         /* Wait until the data has been sent to the host */
 573         while (!(Endpoint_IsINReady()))
 574         {
 575                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 576                   return;
 577         }
 578
 579         /* Select the OUT endpoint */
 580         Endpoint_SelectEndpoint(CDC_RX_EPNUM);
 581
 582         /* Acknowledge the command from the host */
 583         Endpoint_ClearOUT();
 584 }
 585