Bootloaders/CDC/BootloaderCDC.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2011.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 /** \file
  32  *
  33  *  Main source file for the CDC class bootloader. This file contains the complete bootloader logic.
  34  */
  35
  36 #define  INCLUDE_FROM_BOOTLOADERCDC_C
  37 #include "BootloaderCDC.h"
  38
  39 /** Contains the current baud rate and other settings of the first virtual serial port. This must be retained as some
  40  *  operating systems will not open the port unless the settings can be set successfully.
  41  */
  42 static CDC_LineEncoding_t LineEncoding = { .BaudRateBPS = 0,
  43                                            .CharFormat  = CDC_LINEENCODING_OneStopBit,
  44                                            .ParityType  = CDC_PARITY_None,
  45                                            .DataBits    = 8                            };
  46
  47 /** Current address counter. This stores the current address of the FLASH or EEPROM as set by the host,
  48  *  and is used when reading or writing to the AVRs memory (either FLASH or EEPROM depending on the issued
  49  *  command.)
  50  */
  51 static uint32_t CurrAddress;
  52
  53 /** Flag to indicate if the bootloader should be running, or should exit and allow the application code to run
  54  *  via a watchdog reset. When cleared the bootloader will exit, starting the watchdog and entering an infinite
  55  *  loop until the AVR restarts and the application runs.
  56  */
  57 static bool RunBootloader = true;
  58
  59
  60 /** Main program entry point. This routine configures the hardware required by the bootloader, then continuously
  61  *  runs the bootloader processing routine until instructed to soft-exit, or hard-reset via the watchdog to start
  62  *  the loaded application code.
  63  */
  64 int main(void)
  65 {
  66         /* 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_ControlRequest event. This is used to catch and process control requests sent to
 125  *  the device from the USB host before passing along unhandled control requests to the library for processing
 126  *  internally.
 127  */
 128 void EVENT_USB_Device_ControlRequest(void)
 129 {
 130         /* Ignore any requests that aren't directed to the CDC interface */
 131         if ((USB_ControlRequest.bmRequestType & (CONTROL_REQTYPE_TYPE | CONTROL_REQTYPE_RECIPIENT)) !=
 132             (REQTYPE_CLASS | REQREC_INTERFACE))
 133         {
 134                 return;
 135         }
 136
 137         /* Process CDC specific control requests */
 138         switch (USB_ControlRequest.bRequest)
 139         {
 140                 case CDC_REQ_GetLineEncoding:
 141                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 142                         {
 143                                 Endpoint_ClearSETUP();
 144
 145                                 /* Write the line coding data to the control endpoint */
 146                                 Endpoint_Write_Control_Stream_LE(&LineEncoding, sizeof(CDC_LineEncoding_t));
 147                                 Endpoint_ClearOUT();
 148                         }
 149
 150                         break;
 151                 case CDC_REQ_SetLineEncoding:
 152                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 153                         {
 154                                 Endpoint_ClearSETUP();
 155
 156                                 /* Read the line coding data in from the host into the global struct */
 157                                 Endpoint_Read_Control_Stream_LE(&LineEncoding, sizeof(CDC_LineEncoding_t));
 158                                 Endpoint_ClearIN();
 159                         }
 160
 161                         break;
 162         }
 163 }
 164
 165 #if !defined(NO_BLOCK_SUPPORT)
 166 /** Reads or writes a block of EEPROM or FLASH memory to or from the appropriate CDC data endpoint, depending
 167  *  on the AVR910 protocol command issued.
 168  *
 169  *  \param[in] Command  Single character AVR910 protocol command indicating what memory operation to perform
 170  */
 171 static void ReadWriteMemoryBlock(const uint8_t Command)
 172 {
 173         uint16_t BlockSize;
 174         char     MemoryType;
 175
 176         bool     HighByte = false;
 177         uint8_t  LowByte  = 0;
 178
 179         BlockSize  = (FetchNextCommandByte() << 8);
 180         BlockSize |=  FetchNextCommandByte();
 181
 182         MemoryType =  FetchNextCommandByte();
 183
 184         if ((MemoryType != 'E') && (MemoryType != 'F'))
 185         {
 186                 /* Send error byte back to the host */
 187                 WriteNextResponseByte('?');
 188
 189                 return;
 190         }
 191
 192         /* Check if command is to read memory */
 193         if (Command == 'g')
 194         {
 195                 /* Re-enable RWW section */
 196                 boot_rww_enable();
 197
 198                 while (BlockSize--)
 199                 {
 200                         if (MemoryType == 'F')
 201                         {
 202                                 /* Read the next FLASH byte from the current FLASH page */
 203                                 #if (FLASHEND > 0xFFFF)
 204                                 WriteNextResponseByte(pgm_read_byte_far(CurrAddress | HighByte));
 205                                 #else
 206                                 WriteNextResponseByte(pgm_read_byte(CurrAddress | HighByte));
 207                                 #endif
 208
 209                                 /* If both bytes in current word have been read, increment the address counter */
 210                                 if (HighByte)
 211                                   CurrAddress += 2;
 212
 213                                 HighByte = !HighByte;
 214                         }
 215                         else
 216                         {
 217                                 /* Read the next EEPROM byte into the endpoint */
 218                                 WriteNextResponseByte(eeprom_read_byte((uint8_t*)(intptr_t)(CurrAddress >> 1)));
 219
 220                                 /* Increment the address counter after use */
 221                                 CurrAddress += 2;
 222                         }
 223                 }
 224         }
 225         else
 226         {
 227                 uint32_t PageStartAddress = CurrAddress;
 228
 229                 if (MemoryType == 'F')
 230                 {
 231                         boot_page_erase(PageStartAddress);
 232                         boot_spm_busy_wait();
 233                 }
 234
 235                 while (BlockSize--)
 236                 {
 237                         if (MemoryType == 'F')
 238                         {
 239                                 /* If both bytes in current word have been written, increment the address counter */
 240                                 if (HighByte)
 241                                 {
 242                                         /* Write the next FLASH word to the current FLASH page */
 243                                         boot_page_fill(CurrAddress, ((FetchNextCommandByte() << 8) | LowByte));
 244
 245                                         /* Increment the address counter after use */
 246                                         CurrAddress += 2;
 247                                 }
 248                                 else
 249                                 {
 250                                         LowByte = FetchNextCommandByte();
 251                                 }
 252
 253                                 HighByte = !HighByte;
 254                         }
 255                         else
 256                         {
 257                                 /* Write the next EEPROM byte from the endpoint */
 258                                 eeprom_write_byte((uint8_t*)((intptr_t)(CurrAddress >> 1)), FetchNextCommandByte());
 259
 260                                 /* Increment the address counter after use */
 261                                 CurrAddress += 2;
 262                         }
 263                 }
 264
 265                 /* If in FLASH programming mode, commit the page after writing */
 266                 if (MemoryType == 'F')
 267                 {
 268                         /* Commit the flash page to memory */
 269                         boot_page_write(PageStartAddress);
 270
 271                         /* Wait until write operation has completed */
 272                         boot_spm_busy_wait();
 273                 }
 274
 275                 /* Send response byte back to the host */
 276                 WriteNextResponseByte('\r');
 277         }
 278 }
 279 #endif
 280
 281 /** Retrieves the next byte from the host in the CDC data OUT endpoint, and clears the endpoint bank if needed
 282  *  to allow reception of the next data packet from the host.
 283  *
 284  *  \return Next received byte from the host in the CDC data OUT endpoint
 285  */
 286 static uint8_t FetchNextCommandByte(void)
 287 {
 288         /* Select the OUT endpoint so that the next data byte can be read */
 289         Endpoint_SelectEndpoint(CDC_RX_EPNUM);
 290
 291         /* If OUT endpoint empty, clear it and wait for the next packet from the host */
 292         while (!(Endpoint_IsReadWriteAllowed()))
 293         {
 294                 Endpoint_ClearOUT();
 295
 296                 while (!(Endpoint_IsOUTReceived()))
 297                 {
 298                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 299                           return 0;
 300                 }
 301         }
 302
 303         /* Fetch the next byte from the OUT endpoint */
 304         return Endpoint_Read_Byte();
 305 }
 306
 307 /** Writes the next response byte to the CDC data IN endpoint, and sends the endpoint back if needed to free up the
 308  *  bank when full ready for the next byte in the packet to the host.
 309  *
 310  *  \param[in] Response  Next response byte to send to the host
 311  */
 312 static void WriteNextResponseByte(const uint8_t Response)
 313 {
 314         /* Select the IN endpoint so that the next data byte can be written */
 315         Endpoint_SelectEndpoint(CDC_TX_EPNUM);
 316
 317         /* If IN endpoint full, clear it and wait until ready for the next packet to the host */
 318         if (!(Endpoint_IsReadWriteAllowed()))
 319         {
 320                 Endpoint_ClearIN();
 321
 322                 while (!(Endpoint_IsINReady()))
 323                 {
 324                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 325                           return;
 326                 }
 327         }
 328
 329         /* Write the next byte to the IN endpoint */
 330         Endpoint_Write_Byte(Response);
 331 }
 332
 333 /** Task to read in AVR910 commands from the CDC data OUT endpoint, process them, perform the required actions
 334  *  and send the appropriate response back to the host.
 335  */
 336 void CDC_Task(void)
 337 {
 338         /* Select the OUT endpoint */
 339         Endpoint_SelectEndpoint(CDC_RX_EPNUM);
 340
 341         /* Check if endpoint has a command in it sent from the host */
 342         if (!(Endpoint_IsOUTReceived()))
 343           return;
 344
 345         /* Read in the bootloader command (first byte sent from host) */
 346         uint8_t Command = FetchNextCommandByte();
 347
 348         if (Command == 'E')
 349         {
 350                 RunBootloader = false;
 351
 352                 /* Send confirmation byte back to the host */
 353                 WriteNextResponseByte('\r');
 354         }
 355         else if (Command == 'T')
 356         {
 357                 FetchNextCommandByte();
 358
 359                 /* Send confirmation byte back to the host */
 360                 WriteNextResponseByte('\r');
 361         }
 362         else if ((Command == 'L') || (Command == 'P'))
 363         {
 364                 /* Send confirmation byte back to the host */
 365                 WriteNextResponseByte('\r');
 366         }
 367         else if (Command == 't')
 368         {
 369                 /* Return ATMEGA128 part code - this is only to allow AVRProg to use the bootloader */
 370                 WriteNextResponseByte(0x44);
 371                 WriteNextResponseByte(0x00);
 372         }
 373         else if (Command == 'a')
 374         {
 375                 /* Indicate auto-address increment is supported */
 376                 WriteNextResponseByte('Y');
 377         }
 378         else if (Command == 'A')
 379         {
 380                 /* Set the current address to that given by the host */
 381                 CurrAddress   = (FetchNextCommandByte() << 9);
 382                 CurrAddress  |= (FetchNextCommandByte() << 1);
 383
 384                 /* Send confirmation byte back to the host */
 385                 WriteNextResponseByte('\r');
 386         }
 387         else if (Command == 'p')
 388         {
 389                 /* Indicate serial programmer back to the host */
 390                 WriteNextResponseByte('S');
 391         }
 392         else if (Command == 'S')
 393         {
 394                 /* Write the 7-byte software identifier to the endpoint */
 395                 for (uint8_t CurrByte = 0; CurrByte < 7; CurrByte++)
 396                   WriteNextResponseByte(SOFTWARE_IDENTIFIER[CurrByte]);
 397         }
 398         else if (Command == 'V')
 399         {
 400                 WriteNextResponseByte('0' + BOOTLOADER_VERSION_MAJOR);
 401                 WriteNextResponseByte('0' + BOOTLOADER_VERSION_MINOR);
 402         }
 403         else if (Command == 's')
 404         {
 405                 WriteNextResponseByte(AVR_SIGNATURE_3);
 406                 WriteNextResponseByte(AVR_SIGNATURE_2);
 407                 WriteNextResponseByte(AVR_SIGNATURE_1);
 408         }
 409         else if (Command == 'e')
 410         {
 411                 /* Clear the application section of flash */
 412                 for (uint32_t CurrFlashAddress = 0; CurrFlashAddress < BOOT_START_ADDR; CurrFlashAddress += SPM_PAGESIZE)
 413                 {
 414                         boot_page_erase(CurrFlashAddress);
 415                         boot_spm_busy_wait();
 416                         boot_page_write(CurrFlashAddress);
 417                         boot_spm_busy_wait();
 418                 }
 419
 420                 /* Send confirmation byte back to the host */
 421                 WriteNextResponseByte('\r');
 422         }
 423         #if !defined(NO_LOCK_BYTE_WRITE_SUPPORT)
 424         else if (Command == 'l')
 425         {
 426                 /* Set the lock bits to those given by the host */
 427                 boot_lock_bits_set(FetchNextCommandByte());
 428
 429                 /* Send confirmation byte back to the host */
 430                 WriteNextResponseByte('\r');
 431         }
 432         #endif
 433         else if (Command == 'r')
 434         {
 435                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_LOCK_BITS));
 436         }
 437         else if (Command == 'F')
 438         {
 439                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_LOW_FUSE_BITS));
 440         }
 441         else if (Command == 'N')
 442         {
 443                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_HIGH_FUSE_BITS));
 444         }
 445         else if (Command == 'Q')
 446         {
 447                 WriteNextResponseByte(boot_lock_fuse_bits_get(GET_EXTENDED_FUSE_BITS));
 448         }
 449         #if !defined(NO_BLOCK_SUPPORT)
 450         else if (Command == 'b')
 451         {
 452                 WriteNextResponseByte('Y');
 453
 454                 /* Send block size to the host */
 455                 WriteNextResponseByte(SPM_PAGESIZE >> 8);
 456                 WriteNextResponseByte(SPM_PAGESIZE & 0xFF);
 457         }
 458         else if ((Command == 'B') || (Command == 'g'))
 459         {
 460                 /* Delegate the block write/read to a separate function for clarity */
 461                 ReadWriteMemoryBlock(Command);
 462         }
 463         #endif
 464         #if !defined(NO_FLASH_BYTE_SUPPORT)
 465         else if (Command == 'C')
 466         {
 467                 /* Write the high byte to the current flash page */
 468                 boot_page_fill(CurrAddress, FetchNextCommandByte());
 469
 470                 /* Send confirmation byte back to the host */
 471                 WriteNextResponseByte('\r');
 472         }
 473         else if (Command == 'c')
 474         {
 475                 /* Write the low byte to the current flash page */
 476                 boot_page_fill(CurrAddress | 0x01, FetchNextCommandByte());
 477
 478                 /* Increment the address */
 479                 CurrAddress += 2;
 480
 481                 /* Send confirmation byte back to the host */
 482                 WriteNextResponseByte('\r');
 483         }
 484         else if (Command == 'm')
 485         {
 486                 /* Commit the flash page to memory */
 487                 boot_page_write(CurrAddress);
 488
 489                 /* Wait until write operation has completed */
 490                 boot_spm_busy_wait();
 491
 492                 /* Send confirmation byte back to the host */
 493                 WriteNextResponseByte('\r');
 494         }
 495         else if (Command == 'R')
 496         {
 497                 #if (FLASHEND > 0xFFFF)
 498                 uint16_t ProgramWord = pgm_read_word_far(CurrAddress);
 499                 #else
 500                 uint16_t ProgramWord = pgm_read_word(CurrAddress);
 501                 #endif
 502
 503                 WriteNextResponseByte(ProgramWord >> 8);
 504                 WriteNextResponseByte(ProgramWord & 0xFF);
 505         }
 506         #endif
 507         #if !defined(NO_EEPROM_BYTE_SUPPORT)
 508         else if (Command == 'D')
 509         {
 510                 /* Read the byte from the endpoint and write it to the EEPROM */
 511                 eeprom_write_byte((uint8_t*)((intptr_t)(CurrAddress >> 1)), FetchNextCommandByte());
 512
 513                 /* Increment the address after use */
 514                 CurrAddress += 2;
 515
 516                 /* Send confirmation byte back to the host */
 517                 WriteNextResponseByte('\r');
 518         }
 519         else if (Command == 'd')
 520         {
 521                 /* Read the EEPROM byte and write it to the endpoint */
 522                 WriteNextResponseByte(eeprom_read_byte((uint8_t*)((intptr_t)(CurrAddress >> 1))));
 523
 524                 /* Increment the address after use */
 525                 CurrAddress += 2;
 526         }
 527         #endif
 528         else if (Command != 27)
 529         {
 530                 /* Unknown (non-sync) command, return fail code */
 531                 WriteNextResponseByte('?');
 532         }
 533
 534         /* Select the IN endpoint */
 535         Endpoint_SelectEndpoint(CDC_TX_EPNUM);
 536
 537         /* Remember if the endpoint is completely full before clearing it */
 538         bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());
 539
 540         /* Send the endpoint data to the host */
 541         Endpoint_ClearIN();
 542
 543         /* If a full endpoint's worth of data was sent, we need to send an empty packet afterwards to signal end of transfer */
 544         if (IsEndpointFull)
 545         {
 546                 while (!(Endpoint_IsINReady()))
 547                 {
 548                         if (USB_DeviceState == DEVICE_STATE_Unattached)
 549                           return;
 550                 }
 551
 552                 Endpoint_ClearIN();
 553         }
 554
 555         /* Wait until the data has been sent to the host */
 556         while (!(Endpoint_IsINReady()))
 557         {
 558                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 559                   return;
 560         }
 561
 562         /* Select the OUT endpoint */
 563         Endpoint_SelectEndpoint(CDC_RX_EPNUM);
 564
 565         /* Acknowledge the command from the host */
 566         Endpoint_ClearOUT();
 567 }
 568