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