Projects/AVRISP/Lib/XPROG/XPROGProtocol.c

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