Projects/AVRISP-MKII/Lib/XPROG/XPROGProtocol.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  *  XPROG Protocol handler, to process V2 Protocol wrapped XPROG commands used in Atmel programmer devices.
  34  */
  35
  36 #define  INCLUDE_FROM_XPROGPROTOCOL_C
  37 #include "XPROGProtocol.h"
  38
  39 #if defined(ENABLE_XPROG_PROTOCOL) || defined(__DOXYGEN__)
  40 /** Base absolute address for the target's NVM controller for PDI programming */
  41 uint32_t XPROG_Param_NVMBase = 0x010001C0;
  42
  43 /** Size in bytes of the target's EEPROM page */
  44 uint16_t XPROG_Param_EEPageSize;
  45
  46 /** Address of the TPI device's NVMCMD register for TPI programming */
  47 uint8_t  XPROG_Param_NVMCMDRegAddr;
  48
  49 /** Address of the TPI device's NVMCSR register for TPI programming */
  50 uint8_t  XPROG_Param_NVMCSRRegAddr;
  51
  52 /** Currently selected XPROG programming protocol */
  53 uint8_t  XPROG_SelectedProtocol = XPRG_PROTOCOL_PDI;
  54
  55 /** Handler for the CMD_XPROG_SETMODE command, which sets the programmer-to-target protocol used for PDI/TPI
  56  *  programming.
  57  */
  58 void XPROGProtocol_SetMode(void)
  59 {
  60         struct
  61         {
  62                 uint8_t Protocol;
  63         } SetMode_XPROG_Params;
  64
  65         Endpoint_Read_Stream_LE(&SetMode_XPROG_Params, sizeof(SetMode_XPROG_Params), NO_STREAM_CALLBACK);
  66
  67         Endpoint_ClearOUT();
  68         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
  69
  70         XPROG_SelectedProtocol = SetMode_XPROG_Params.Protocol;
  71
  72         Endpoint_Write_Byte(CMD_XPROG_SETMODE);
  73         Endpoint_Write_Byte((SetMode_XPROG_Params.Protocol != XPRG_PROTOCOL_JTAG) ? STATUS_CMD_OK : STATUS_CMD_FAILED);
  74         Endpoint_ClearIN();
  75 }
  76
  77 /** Handler for the CMD_XPROG command, which wraps up XPROG commands in a V2 wrapper which need to be
  78  *  removed and processed so that the underlying XPROG command can be handled.
  79  */
  80 void XPROGProtocol_Command(void)
  81 {
  82         uint8_t XPROGCommand = Endpoint_Read_Byte();
  83
  84         switch (XPROGCommand)
  85         {
  86                 case XPRG_CMD_ENTER_PROGMODE:
  87                         XPROGProtocol_EnterXPROGMode();
  88                         break;
  89                 case XPRG_CMD_LEAVE_PROGMODE:
  90                         XPROGProtocol_LeaveXPROGMode();
  91                         break;
  92                 case XPRG_CMD_ERASE:
  93                         XPROGProtocol_Erase();
  94                         break;
  95                 case XPRG_CMD_WRITE_MEM:
  96                         XPROGProtocol_WriteMemory();
  97                         break;
  98                 case XPRG_CMD_READ_MEM:
  99                         XPROGProtocol_ReadMemory();
 100                         break;
 101                 case XPRG_CMD_CRC:
 102                         XPROGProtocol_ReadCRC();
 103                         break;
 104                 case XPRG_CMD_SET_PARAM:
 105                         XPROGProtocol_SetParam();
 106                         break;
 107         }
 108 }
 109
 110 /** Handler for the XPROG ENTER_PROGMODE command to establish a connection with the attached device. */
 111 static void XPROGProtocol_EnterXPROGMode(void)
 112 {
 113         Endpoint_ClearOUT();
 114         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 115
 116         bool NVMBusEnabled;
 117
 118         if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)
 119         {
 120                 /* Enable PDI programming mode with the attached target */
 121                 XPROGTarget_EnableTargetPDI();
 122
 123                 /* Store the RESET key into the RESET PDI register to keep the XMEGA in reset */
 124                 XPROGTarget_SendByte(PDI_CMD_STCS | PDI_RESET_REG);
 125                 XPROGTarget_SendByte(PDI_RESET_KEY);
 126
 127                 /* Lower direction change guard time to 8 USART bits */
 128                 XPROGTarget_SendByte(PDI_CMD_STCS | PDI_CTRL_REG);
 129                 XPROGTarget_SendByte(0x04);
 130
 131                 /* Enable access to the XPROG NVM bus by sending the documented NVM access key to the device */
 132                 XPROGTarget_SendByte(PDI_CMD_KEY);
 133                 for (uint8_t i = sizeof(PDI_NVMENABLE_KEY); i > 0; i--)
 134                   XPROGTarget_SendByte(PDI_NVMENABLE_KEY[i - 1]);
 135
 136                 /* Wait until the NVM bus becomes active */
 137                 NVMBusEnabled = XMEGANVM_WaitWhileNVMBusBusy();
 138         }
 139         else
 140         {
 141                 /* Enable TPI programming mode with the attached target */
 142                 XPROGTarget_EnableTargetTPI();
 143
 144                 /* Lower direction change guard time to 8 USART bits */
 145                 XPROGTarget_SendByte(TPI_CMD_SSTCS | TPI_CTRL_REG);
 146                 XPROGTarget_SendByte(0x04);
 147
 148                 /* Enable access to the XPROG NVM bus by sending the documented NVM access key to the device */
 149                 XPROGTarget_SendByte(TPI_CMD_SKEY);
 150                 for (uint8_t i = sizeof(TPI_NVMENABLE_KEY); i > 0; i--)
 151                   XPROGTarget_SendByte(TPI_NVMENABLE_KEY[i - 1]);
 152
 153                 /* Wait until the NVM bus becomes active */
 154                 NVMBusEnabled = TINYNVM_WaitWhileNVMBusBusy();
 155         }
 156
 157         Endpoint_Write_Byte(CMD_XPROG);
 158         Endpoint_Write_Byte(XPRG_CMD_ENTER_PROGMODE);
 159         Endpoint_Write_Byte(NVMBusEnabled ? XPRG_ERR_OK : XPRG_ERR_FAILED);
 160         Endpoint_ClearIN();
 161 }
 162
 163 /** Handler for the XPROG LEAVE_PROGMODE command to terminate the PDI programming connection with
 164  *  the attached device.
 165  */
 166 static void XPROGProtocol_LeaveXPROGMode(void)
 167 {
 168         Endpoint_ClearOUT();
 169         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 170
 171         if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)
 172         {
 173                 /* Clear the RESET key in the RESET PDI register to allow the XMEGA to run */
 174                 XPROGTarget_SendByte(PDI_CMD_STCS | PDI_RESET_REG);
 175                 XPROGTarget_SendByte(0x00);
 176
 177                 XPROGTarget_DisableTargetPDI();
 178         }
 179         else
 180         {
 181                 /* Clear the NVMEN bit in the TPI CONTROL register to disable TPI mode */
 182                 XPROGTarget_SendByte(TPI_CMD_SSTCS | TPI_CTRL_REG);
 183                 XPROGTarget_SendByte(0x00);
 184
 185                 XPROGTarget_DisableTargetTPI();
 186         }
 187
 188         Endpoint_Write_Byte(CMD_XPROG);
 189         Endpoint_Write_Byte(XPRG_CMD_LEAVE_PROGMODE);
 190         Endpoint_Write_Byte(XPRG_ERR_OK);
 191         Endpoint_ClearIN();
 192 }
 193
 194 /** Handler for the XPRG ERASE command to erase a specific memory address space in the attached device. */
 195 static void XPROGProtocol_Erase(void)
 196 {
 197         uint8_t ReturnStatus = XPRG_ERR_OK;
 198
 199         struct
 200         {
 201                 uint8_t  MemoryType;
 202                 uint32_t Address;
 203         } Erase_XPROG_Params;
 204
 205         Endpoint_Read_Stream_LE(&Erase_XPROG_Params, sizeof(Erase_XPROG_Params), NO_STREAM_CALLBACK);
 206         Erase_XPROG_Params.Address = SwapEndian_32(Erase_XPROG_Params.Address);
 207
 208         Endpoint_ClearOUT();
 209         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 210
 211         if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)
 212         {
 213                 uint8_t EraseCommand = XMEGA_NVM_CMD_NOOP;
 214
 215                 /* Determine which NVM command to send to the device depending on the memory to erase */
 216                 switch (Erase_XPROG_Params.MemoryType)
 217                 {
 218                         case XPRG_ERASE_CHIP:
 219                                 EraseCommand = XMEGA_NVM_CMD_CHIPERASE;
 220                                 break;
 221                         case XPRG_ERASE_APP:
 222                                 EraseCommand = XMEGA_NVM_CMD_ERASEAPPSEC;
 223                                 break;
 224                         case XPRG_ERASE_BOOT:
 225                                 EraseCommand = XMEGA_NVM_CMD_ERASEBOOTSEC;
 226                                 break;
 227                         case XPRG_ERASE_EEPROM:
 228                                 EraseCommand = XMEGA_NVM_CMD_ERASEEEPROM;
 229                                 break;
 230                         case XPRG_ERASE_APP_PAGE:
 231                                 EraseCommand = XMEGA_NVM_CMD_ERASEAPPSECPAGE;
 232                                 break;
 233                         case XPRG_ERASE_BOOT_PAGE:
 234                                 EraseCommand = XMEGA_NVM_CMD_ERASEBOOTSECPAGE;
 235                                 break;
 236                         case XPRG_ERASE_EEPROM_PAGE:
 237                                 EraseCommand = XMEGA_NVM_CMD_ERASEEEPROMPAGE;
 238                                 break;
 239                         case XPRG_ERASE_USERSIG:
 240                                 EraseCommand = XMEGA_NVM_CMD_ERASEUSERSIG;
 241                                 break;
 242                 }
 243
 244                 /* Erase the target memory, indicate timeout if ocurred */
 245                 if (!(XMEGANVM_EraseMemory(EraseCommand, Erase_XPROG_Params.Address)))
 246                   ReturnStatus = XPRG_ERR_TIMEOUT;
 247         }
 248         else
 249         {
 250                 /* Erase the target memory, indicate timeout if ocurred */
 251                 if (!(TINYNVM_EraseMemory(TINY_NVM_CMD_CHIPERASE, Erase_XPROG_Params.Address)))
 252                   ReturnStatus = XPRG_ERR_TIMEOUT;
 253         }
 254
 255         Endpoint_Write_Byte(CMD_XPROG);
 256         Endpoint_Write_Byte(XPRG_CMD_ERASE);
 257         Endpoint_Write_Byte(ReturnStatus);
 258         Endpoint_ClearIN();
 259 }
 260
 261 /** Handler for the XPROG WRITE_MEMORY command to write to a specific memory space within the attached device. */
 262 static void XPROGProtocol_WriteMemory(void)
 263 {
 264         uint8_t ReturnStatus = XPRG_ERR_OK;
 265
 266         struct
 267         {
 268                 uint8_t  MemoryType;
 269                 uint8_t  PageMode;
 270                 uint32_t Address;
 271                 uint16_t Length;
 272                 uint8_t  ProgData[256];
 273         } WriteMemory_XPROG_Params;
 274
 275         Endpoint_Read_Stream_LE(&WriteMemory_XPROG_Params, (sizeof(WriteMemory_XPROG_Params) -
 276                                                             sizeof(WriteMemory_XPROG_Params).ProgData), NO_STREAM_CALLBACK);
 277         WriteMemory_XPROG_Params.Address = SwapEndian_32(WriteMemory_XPROG_Params.Address);
 278         WriteMemory_XPROG_Params.Length  = SwapEndian_16(WriteMemory_XPROG_Params.Length);
 279         Endpoint_Read_Stream_LE(&WriteMemory_XPROG_Params.ProgData, WriteMemory_XPROG_Params.Length, NO_STREAM_CALLBACK);
 280
 281         Endpoint_ClearOUT();
 282         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 283
 284         if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)
 285         {
 286                 /* Assume FLASH page programming by default, as it is the common case */
 287                 uint8_t WriteCommand     = XMEGA_NVM_CMD_WRITEFLASHPAGE;
 288                 uint8_t WriteBuffCommand = XMEGA_NVM_CMD_LOADFLASHPAGEBUFF;
 289                 uint8_t EraseBuffCommand = XMEGA_NVM_CMD_ERASEFLASHPAGEBUFF;
 290                 bool    PagedMemory      = true;
 291
 292                 switch (WriteMemory_XPROG_Params.MemoryType)
 293                 {
 294                         case XPRG_MEM_TYPE_APPL:
 295                                 WriteCommand     = XMEGA_NVM_CMD_WRITEAPPSECPAGE;
 296                                 break;
 297                         case XPRG_MEM_TYPE_BOOT:
 298                                 WriteCommand     = XMEGA_NVM_CMD_WRITEBOOTSECPAGE;
 299                                 break;
 300                         case XPRG_MEM_TYPE_EEPROM:
 301                                 WriteCommand     = XMEGA_NVM_CMD_WRITEEEPROMPAGE;
 302                                 WriteBuffCommand = XMEGA_NVM_CMD_LOADEEPROMPAGEBUFF;
 303                                 EraseBuffCommand = XMEGA_NVM_CMD_ERASEEEPROMPAGEBUFF;
 304                                 break;
 305                         case XPRG_MEM_TYPE_USERSIG:
 306                                 /* User signature is paged, but needs us to manually indicate the mode bits since the host doesn't set them */
 307                                 WriteMemory_XPROG_Params.PageMode = (XPRG_PAGEMODE_ERASE | XPRG_PAGEMODE_WRITE);
 308                                 WriteCommand     = XMEGA_NVM_CMD_WRITEUSERSIG;
 309                                 break;
 310                         case XPRG_MEM_TYPE_FUSE:
 311                                 WriteCommand     = XMEGA_NVM_CMD_WRITEFUSE;
 312                                 PagedMemory      = false;
 313                                 break;
 314                         case XPRG_MEM_TYPE_LOCKBITS:
 315                                 WriteCommand     = XMEGA_NVM_CMD_WRITELOCK;
 316                                 PagedMemory      = false;
 317                                 break;
 318                 }
 319
 320                 /* Send the appropriate memory write commands to the device, indicate timeout if occurred */
 321                 if ((PagedMemory && !(XMEGANVM_WritePageMemory(WriteBuffCommand, EraseBuffCommand, WriteCommand,
 322                                                                                                            WriteMemory_XPROG_Params.PageMode, WriteMemory_XPROG_Params.Address,
 323                                                                                                            WriteMemory_XPROG_Params.ProgData, WriteMemory_XPROG_Params.Length))) ||
 324                    (!PagedMemory && !(XMEGANVM_WriteByteMemory(WriteCommand, WriteMemory_XPROG_Params.Address,
 325                                                                                                            WriteMemory_XPROG_Params.ProgData[0]))))
 326                 {
 327                         ReturnStatus = XPRG_ERR_TIMEOUT;
 328                 }
 329         }
 330         else
 331         {
 332                 /* Send write command to the TPI device, indicate timeout if occurred */
 333                 if (!(TINYNVM_WriteMemory(WriteMemory_XPROG_Params.Address, WriteMemory_XPROG_Params.ProgData,
 334                       WriteMemory_XPROG_Params.Length)))
 335                 {
 336                         ReturnStatus = XPRG_ERR_TIMEOUT;
 337                 }
 338         }
 339
 340         Endpoint_Write_Byte(CMD_XPROG);
 341         Endpoint_Write_Byte(XPRG_CMD_WRITE_MEM);
 342         Endpoint_Write_Byte(ReturnStatus);
 343         Endpoint_ClearIN();
 344 }
 345
 346 /** Handler for the XPROG READ_MEMORY command to read data from a specific address space within the
 347  *  attached device.
 348  */
 349 static void XPROGProtocol_ReadMemory(void)
 350 {
 351         uint8_t ReturnStatus = XPRG_ERR_OK;
 352
 353         struct
 354         {
 355                 uint8_t  MemoryType;
 356                 uint32_t Address;
 357                 uint16_t Length;
 358         } ReadMemory_XPROG_Params;
 359
 360         Endpoint_Read_Stream_LE(&ReadMemory_XPROG_Params, sizeof(ReadMemory_XPROG_Params), NO_STREAM_CALLBACK);
 361         ReadMemory_XPROG_Params.Address = SwapEndian_32(ReadMemory_XPROG_Params.Address);
 362         ReadMemory_XPROG_Params.Length  = SwapEndian_16(ReadMemory_XPROG_Params.Length);
 363
 364         Endpoint_ClearOUT();
 365         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 366
 367         uint8_t ReadBuffer[256];
 368
 369         if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)
 370         {
 371                 /* Read the PDI target's memory, indicate timeout if occurred */
 372                 if (!(XMEGANVM_ReadMemory(ReadMemory_XPROG_Params.Address, ReadBuffer, ReadMemory_XPROG_Params.Length)))
 373                   ReturnStatus = XPRG_ERR_TIMEOUT;
 374         }
 375         else
 376         {
 377                 /* Read the TPI target's memory, indicate timeout if occurred */
 378                 if (!(TINYNVM_ReadMemory(ReadMemory_XPROG_Params.Address, ReadBuffer, ReadMemory_XPROG_Params.Length)))
 379                   ReturnStatus = XPRG_ERR_TIMEOUT;
 380         }
 381
 382         Endpoint_Write_Byte(CMD_XPROG);
 383         Endpoint_Write_Byte(XPRG_CMD_READ_MEM);
 384         Endpoint_Write_Byte(ReturnStatus);
 385
 386         if (ReturnStatus == XPRG_ERR_OK)
 387           Endpoint_Write_Stream_LE(ReadBuffer, ReadMemory_XPROG_Params.Length, NO_STREAM_CALLBACK);
 388
 389         Endpoint_ClearIN();
 390 }
 391
 392 /** Handler for the XPROG CRC command to read a specific memory space's CRC value for comparison between the
 393  *  attached device's memory and a data set on the host.
 394  */
 395 static void XPROGProtocol_ReadCRC(void)
 396 {
 397         uint8_t ReturnStatus = XPRG_ERR_OK;
 398
 399         struct
 400         {
 401                 uint8_t CRCType;
 402         } ReadCRC_XPROG_Params;
 403
 404         Endpoint_Read_Stream_LE(&ReadCRC_XPROG_Params, sizeof(ReadCRC_XPROG_Params), NO_STREAM_CALLBACK);
 405
 406         Endpoint_ClearOUT();
 407         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 408
 409         uint32_t MemoryCRC;
 410
 411         if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)
 412         {
 413                 uint8_t CRCCommand;
 414
 415                 /* Determine which NVM command to send to the device depending on the memory to CRC */
 416                 switch (ReadCRC_XPROG_Params.CRCType)
 417                 {
 418                         case XPRG_CRC_APP:
 419                                 CRCCommand = XMEGA_NVM_CMD_APPCRC;
 420                                 break;
 421                         case XPRG_CRC_BOOT:
 422                                 CRCCommand = XMEGA_NVM_CMD_BOOTCRC;
 423                                 break;
 424                         default:
 425                                 CRCCommand = XMEGA_NVM_CMD_FLASHCRC;
 426                                 break;
 427                 }
 428
 429                 /* Perform and retrieve the memory CRC, indicate timeout if occurred */
 430                 if (!(XMEGANVM_GetMemoryCRC(CRCCommand, &MemoryCRC)))
 431                   ReturnStatus = XPRG_ERR_TIMEOUT;
 432         }
 433         else
 434         {
 435                 /* TPI does not support memory CRC */
 436                 ReturnStatus = XPRG_ERR_FAILED;
 437         }
 438
 439         Endpoint_Write_Byte(CMD_XPROG);
 440         Endpoint_Write_Byte(XPRG_CMD_CRC);
 441         Endpoint_Write_Byte(ReturnStatus);
 442
 443         if (ReturnStatus == XPRG_ERR_OK)
 444         {
 445                 Endpoint_Write_Byte(MemoryCRC >> 16);
 446                 Endpoint_Write_Word_LE(MemoryCRC & 0xFFFF);
 447         }
 448
 449         Endpoint_ClearIN();
 450 }
 451
 452 /** Handler for the XPROG SET_PARAM command to set a XPROG parameter for use when communicating with the
 453  *  attached device.
 454  */
 455 static void XPROGProtocol_SetParam(void)
 456 {
 457         uint8_t ReturnStatus = XPRG_ERR_OK;
 458
 459         uint8_t XPROGParam = Endpoint_Read_Byte();
 460
 461         /* Determine which parameter is being set, store the new parameter value */
 462         switch (XPROGParam)
 463         {
 464                 case XPRG_PARAM_NVMBASE:
 465                         XPROG_Param_NVMBase = Endpoint_Read_DWord_BE();
 466                         break;
 467                 case XPRG_PARAM_EEPPAGESIZE:
 468                         XPROG_Param_EEPageSize = Endpoint_Read_Word_BE();
 469                         break;
 470                 case XPRG_PARAM_NVMCMD_REG:
 471                         XPROG_Param_NVMCMDRegAddr = Endpoint_Read_Byte();
 472                         break;
 473                 case XPRG_PARAM_NVMCSR_REG:
 474                         XPROG_Param_NVMCSRRegAddr = Endpoint_Read_Byte();
 475                         break;
 476                 default:
 477                         ReturnStatus = XPRG_ERR_FAILED;
 478                         break;
 479         }
 480
 481         Endpoint_ClearOUT();
 482         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 483
 484         Endpoint_Write_Byte(CMD_XPROG);
 485         Endpoint_Write_Byte(XPRG_CMD_SET_PARAM);
 486         Endpoint_Write_Byte(ReturnStatus);
 487         Endpoint_ClearIN();
 488 }
 489
 490 #endif