Bootloaders/CDC/BootloaderCDC.c

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