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                 // TODO - enable NVM bus via KEY
 136         }
 137
 138         Endpoint_Write_Byte(CMD_XPROG);
 139         Endpoint_Write_Byte(XPRG_CMD_ENTER_PROGMODE);
 140         Endpoint_Write_Byte(NVMBusEnabled ? XPRG_ERR_OK : XPRG_ERR_FAILED);
 141         Endpoint_ClearIN();
 142 }
 143
 144 /** Handler for the XPROG LEAVE_PROGMODE command to terminate the PDI programming connection with
 145  *  the attached device.
 146  */
 147 static void XPROGProtocol_LeaveXPROGMode(void)
 148 {
 149         Endpoint_ClearOUT();
 150         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 151
 152         if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)
 153         {
 154                 /* Clear the RESET key in the RESET PDI register to allow the XMEGA to run */
 155                 XPROGTarget_SendByte(PDI_CMD_STCS | PDI_RESET_REG);
 156                 XPROGTarget_SendByte(0x00);
 157
 158                 XPROGTarget_DisableTargetPDI();
 159         }
 160         else
 161         {
 162                 // TODO - Disable TPI via register
 163
 164                 XPROGTarget_DisableTargetTPI();
 165         }
 166
 167         Endpoint_Write_Byte(CMD_XPROG);
 168         Endpoint_Write_Byte(XPRG_CMD_LEAVE_PROGMODE);
 169         Endpoint_Write_Byte(XPRG_ERR_OK);
 170         Endpoint_ClearIN();
 171 }
 172
 173 /** Handler for the XPRG ERASE command to erase a specific memory address space in the attached device. */
 174 static void XPROGProtocol_Erase(void)
 175 {
 176         uint8_t ReturnStatus = XPRG_ERR_OK;
 177
 178         struct
 179         {
 180                 uint8_t  MemoryType;
 181                 uint32_t Address;
 182         } Erase_XPROG_Params;
 183
 184         Endpoint_Read_Stream_LE(&Erase_XPROG_Params, sizeof(Erase_XPROG_Params));
 185         Erase_XPROG_Params.Address = SwapEndian_32(Erase_XPROG_Params.Address);
 186
 187         Endpoint_ClearOUT();
 188         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 189
 190         uint8_t EraseCommand = XMEGA_NVM_CMD_NOOP;
 191
 192         if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)
 193         {
 194                 /* Determine which NVM command to send to the device depending on the memory to erase */
 195                 if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_CHIP)
 196                   EraseCommand = XMEGA_NVM_CMD_CHIPERASE;
 197                 else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_APP)
 198                   EraseCommand = XMEGA_NVM_CMD_ERASEAPPSEC;
 199                 else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_BOOT)
 200                   EraseCommand = XMEGA_NVM_CMD_ERASEBOOTSEC;
 201                 else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_EEPROM)
 202                   EraseCommand = XMEGA_NVM_CMD_ERASEEEPROM;
 203                 else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_APP_PAGE)
 204                   EraseCommand = XMEGA_NVM_CMD_ERASEAPPSECPAGE;
 205                 else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_BOOT_PAGE)
 206                   EraseCommand = XMEGA_NVM_CMD_ERASEBOOTSECPAGE;
 207                 else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_EEPROM_PAGE)
 208                   EraseCommand = XMEGA_NVM_CMD_ERASEEEPROMPAGE;
 209                 else if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_USERSIG)
 210                   EraseCommand = XMEGA_NVM_CMD_ERASEUSERSIG;
 211
 212                 /* Erase the target memory, indicate timeout if ocurred */
 213                 if (!(XMEGANVM_EraseMemory(EraseCommand, Erase_XPROG_Params.Address)))
 214                   ReturnStatus = XPRG_ERR_TIMEOUT;
 215         }
 216         else
 217         {
 218                 // TODO
 219         }
 220
 221         Endpoint_Write_Byte(CMD_XPROG);
 222         Endpoint_Write_Byte(XPRG_CMD_ERASE);
 223         Endpoint_Write_Byte(ReturnStatus);
 224         Endpoint_ClearIN();
 225 }
 226
 227 /** Handler for the XPROG WRITE_MEMORY command to write to a specific memory space within the attached device. */
 228 static void XPROGProtocol_WriteMemory(void)
 229 {
 230         uint8_t ReturnStatus = XPRG_ERR_OK;
 231
 232         struct
 233         {
 234                 uint8_t  MemoryType;
 235                 uint8_t  PageMode;
 236                 uint32_t Address;
 237                 uint16_t Length;
 238                 uint8_t  ProgData[256];
 239         } WriteMemory_XPROG_Params;
 240
 241         Endpoint_Read_Stream_LE(&WriteMemory_XPROG_Params, (sizeof(WriteMemory_XPROG_Params) -
 242                                                             sizeof(WriteMemory_XPROG_Params).ProgData));
 243         WriteMemory_XPROG_Params.Address = SwapEndian_32(WriteMemory_XPROG_Params.Address);
 244         WriteMemory_XPROG_Params.Length  = SwapEndian_16(WriteMemory_XPROG_Params.Length);
 245         Endpoint_Read_Stream_LE(&WriteMemory_XPROG_Params.ProgData, WriteMemory_XPROG_Params.Length);
 246
 247         Endpoint_ClearOUT();
 248         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 249
 250         /* Assume FLASH page programming by default, as it is the common case */
 251         uint8_t WriteCommand     = XMEGA_NVM_CMD_WRITEFLASHPAGE;
 252         uint8_t WriteBuffCommand = XMEGA_NVM_CMD_LOADFLASHPAGEBUFF;
 253         uint8_t EraseBuffCommand = XMEGA_NVM_CMD_ERASEFLASHPAGEBUFF;
 254         bool    PagedMemory      = true;
 255
 256         if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)
 257         {
 258                 if (WriteMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_APPL)
 259                 {
 260                         WriteCommand     = XMEGA_NVM_CMD_WRITEAPPSECPAGE;
 261                 }
 262                 else if (WriteMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_BOOT)
 263                 {
 264                         WriteCommand     = XMEGA_NVM_CMD_WRITEBOOTSECPAGE;
 265                 }
 266                 else if (WriteMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_EEPROM)
 267                 {
 268                         WriteCommand     = XMEGA_NVM_CMD_WRITEEEPROMPAGE;
 269                         WriteBuffCommand = XMEGA_NVM_CMD_LOADEEPROMPAGEBUFF;
 270                         EraseBuffCommand = XMEGA_NVM_CMD_ERASEEEPROMPAGEBUFF;
 271                 }
 272                 else if (WriteMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_USERSIG)
 273                 {
 274                         /* User signature is paged, but needs us to manually indicate the mode bits since the host doesn't set them */
 275                         WriteMemory_XPROG_Params.PageMode = (XPRG_PAGEMODE_ERASE | XPRG_PAGEMODE_WRITE);
 276                         WriteCommand     = XMEGA_NVM_CMD_WRITEUSERSIG;
 277                 }
 278                 else if (WriteMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_FUSE)
 279                 {
 280                         WriteCommand     = XMEGA_NVM_CMD_WRITEFUSE;
 281                         PagedMemory      = false;
 282                 }
 283                 else if (WriteMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_LOCKBITS)
 284                 {
 285                         WriteCommand     = XMEGA_NVM_CMD_WRITELOCK;
 286                         PagedMemory      = false;
 287                 }
 288
 289                 /* Send the appropriate memory write commands to the device, indicate timeout if occurred */
 290                 if ((PagedMemory && !XMEGANVM_WritePageMemory(WriteBuffCommand, EraseBuffCommand, WriteCommand,
 291                                                                                                            WriteMemory_XPROG_Params.PageMode, WriteMemory_XPROG_Params.Address,
 292                                                                                                            WriteMemory_XPROG_Params.ProgData, WriteMemory_XPROG_Params.Length)) ||
 293                    (!PagedMemory && !XMEGANVM_WriteByteMemory(WriteCommand, WriteMemory_XPROG_Params.Address,
 294                                                                                                            WriteMemory_XPROG_Params.ProgData)))
 295                 {
 296                         ReturnStatus = XPRG_ERR_TIMEOUT;
 297                 }
 298         }
 299         else
 300         {
 301                 // TODO
 302         }
 303
 304         Endpoint_Write_Byte(CMD_XPROG);
 305         Endpoint_Write_Byte(XPRG_CMD_WRITE_MEM);
 306         Endpoint_Write_Byte(ReturnStatus);
 307         Endpoint_ClearIN();
 308 }
 309
 310 /** Handler for the XPROG READ_MEMORY command to read data from a specific address space within the
 311  *  attached device.
 312  */
 313 static void XPROGProtocol_ReadMemory(void)
 314 {
 315         uint8_t ReturnStatus = XPRG_ERR_OK;
 316
 317         struct
 318         {
 319                 uint8_t  MemoryType;
 320                 uint32_t Address;
 321                 uint16_t Length;
 322         } ReadMemory_XPROG_Params;
 323
 324         Endpoint_Read_Stream_LE(&ReadMemory_XPROG_Params, sizeof(ReadMemory_XPROG_Params));
 325         ReadMemory_XPROG_Params.Address = SwapEndian_32(ReadMemory_XPROG_Params.Address);
 326         ReadMemory_XPROG_Params.Length  = SwapEndian_16(ReadMemory_XPROG_Params.Length);
 327
 328         Endpoint_ClearOUT();
 329         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 330
 331         uint8_t ReadBuffer[256];
 332
 333         if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)
 334         {
 335                 /* Read the target's memory, indicate timeout if occurred */
 336                 if (!(XMEGANVM_ReadMemory(ReadMemory_XPROG_Params.Address, ReadBuffer, ReadMemory_XPROG_Params.Length)))
 337                   ReturnStatus = XPRG_ERR_TIMEOUT;
 338         }
 339         else
 340         {
 341                 // TODO
 342         }
 343
 344         Endpoint_Write_Byte(CMD_XPROG);
 345         Endpoint_Write_Byte(XPRG_CMD_READ_MEM);
 346         Endpoint_Write_Byte(ReturnStatus);
 347
 348         if (ReturnStatus == XPRG_ERR_OK)
 349           Endpoint_Write_Stream_LE(ReadBuffer, ReadMemory_XPROG_Params.Length);
 350
 351         Endpoint_ClearIN();
 352 }
 353
 354 /** Handler for the XPROG CRC command to read a specific memory space's CRC value for comparison between the
 355  *  attached device's memory and a data set on the host.
 356  */
 357 static void XPROGProtocol_ReadCRC(void)
 358 {
 359         uint8_t ReturnStatus = XPRG_ERR_OK;
 360
 361         struct
 362         {
 363                 uint8_t CRCType;
 364         } ReadCRC_XPROG_Params;
 365
 366         Endpoint_Read_Stream_LE(&ReadCRC_XPROG_Params, sizeof(ReadCRC_XPROG_Params));
 367         Endpoint_ClearOUT();
 368         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 369
 370         uint8_t  CRCCommand = XMEGA_NVM_CMD_NOOP;
 371         uint32_t MemoryCRC;
 372
 373         if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)
 374         {
 375                 /* Determine which NVM command to send to the device depending on the memory to CRC */
 376                 if (ReadCRC_XPROG_Params.CRCType == XPRG_CRC_APP)
 377                   CRCCommand = XMEGA_NVM_CMD_APPCRC;
 378                 else if (ReadCRC_XPROG_Params.CRCType == XPRG_CRC_BOOT)
 379                   CRCCommand = XMEGA_NVM_CMD_BOOTCRC;
 380                 else
 381                   CRCCommand = XMEGA_NVM_CMD_FLASHCRC;
 382
 383                 /* Perform and retrieve the memory CRC, indicate timeout if occurred */
 384                 if (!(XMEGANVM_GetMemoryCRC(CRCCommand, &MemoryCRC)))
 385                   ReturnStatus = XPRG_ERR_TIMEOUT;
 386         }
 387         else
 388         {
 389                 /* TPI does not support memory CRC */
 390                 ReturnStatus = XPRG_ERR_FAILED;
 391         }
 392
 393         Endpoint_Write_Byte(CMD_XPROG);
 394         Endpoint_Write_Byte(XPRG_CMD_CRC);
 395         Endpoint_Write_Byte(ReturnStatus);
 396
 397         if (ReturnStatus == XPRG_ERR_OK)
 398         {
 399                 Endpoint_Write_Byte(MemoryCRC >> 16);
 400                 Endpoint_Write_Word_LE(MemoryCRC & 0xFFFF);
 401         }
 402
 403         Endpoint_ClearIN();
 404 }
 405
 406 /** Handler for the XPROG SET_PARAM command to set a XPROG parameter for use when communicating with the
 407  *  attached device.
 408  */
 409 static void XPROGProtocol_SetParam(void)
 410 {
 411         uint8_t ReturnStatus = XPRG_ERR_OK;
 412
 413         uint8_t XPROGParam = Endpoint_Read_Byte();
 414
 415         /* Determine which parameter is being set, store the new parameter value */
 416         if (XPROGParam == XPRG_PARAM_NVMBASE)
 417           XPROG_Param_NVMBase = Endpoint_Read_DWord_BE();
 418         else if (XPROGParam == XPRG_PARAM_EEPPAGESIZE)
 419           XPROG_Param_EEPageSize = Endpoint_Read_Word_BE();
 420         else
 421           ReturnStatus = XPRG_ERR_FAILED;
 422
 423         Endpoint_ClearOUT();
 424         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 425
 426         Endpoint_Write_Byte(CMD_XPROG);
 427         Endpoint_Write_Byte(XPRG_CMD_SET_PARAM);
 428         Endpoint_Write_Byte(ReturnStatus);
 429         Endpoint_ClearIN();
 430 }
 431
 432 #endif