Bootloaders/CDC/BootloaderCDC.c

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