Projects/AVRISP/Lib/PDIProtocol.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  *  PDI Protocol handler, to process V2 Protocol wrapped PDI commands used in Atmel programmer devices.
  34  */
  35
  36 #define  INCLUDE_FROM_PDIPROTOCOL_C
  37 #include "PDIProtocol.h"
  38
  39 #if defined(ENABLE_PDI_PROTOCOL) || defined(__DOXYGEN__)
  40 #warning PDI Programming Protocol support is incomplete and not currently suitable for use.
  41
  42 uint32_t XPROG_Param_NVMBase;
  43 uint32_t XPROG_Param_EEPageSize;
  44
  45 /** Handler for the CMD_XPROG_SETMODE command, which sets the programmer-to-target protocol used for PDI
  46  *  XMEGA programming (either PDI or JTAG). Only PDI programming is supported.
  47  */
  48 void PDIProtocol_XPROG_SetMode(void)
  49 {
  50         struct
  51         {
  52                 uint8_t Protocol;
  53         } SetMode_XPROG_Params;
  54
  55         Endpoint_Read_Stream_LE(&SetMode_XPROG_Params, sizeof(SetMode_XPROG_Params));
  56
  57         Endpoint_ClearOUT();
  58         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
  59
  60         Endpoint_Write_Byte(CMD_XPROG_SETMODE);
  61         Endpoint_Write_Byte((SetMode_XPROG_Params.Protocol == XPRG_PROTOCOL_PDI) ? STATUS_CMD_OK : STATUS_CMD_FAILED);
  62         Endpoint_ClearIN();
  63 }
  64
  65 /** Handler for the CMD_XPROG command, which wraps up XPROG commands in a V2 wrapper which need to be
  66  *  removed and processed so that the underlying XPROG command can be handled.
  67  */
  68 void PDIProtocol_XPROG_Command(void)
  69 {
  70         uint8_t XPROGCommand = Endpoint_Read_Byte();
  71
  72         switch (XPROGCommand)
  73         {
  74                 case XPRG_CMD_ENTER_PROGMODE:
  75                         PDIProtocol_EnterXPROGMode();
  76                         break;
  77                 case XPRG_CMD_LEAVE_PROGMODE:
  78                         PDIProtocol_LeaveXPROGMode();
  79                         break;
  80                 case XPRG_CMD_ERASE:
  81                         PDIProtocol_Erase();
  82                         break;
  83                 case XPRG_CMD_WRITE_MEM:
  84                         PDIProtocol_WriteMemory();
  85                         break;
  86                 case XPRG_CMD_READ_MEM:
  87                         PDIProtocol_ReadMemory();
  88                         break;
  89                 case XPRG_CMD_CRC:
  90                         PDIProtocol_ReadCRC();
  91                         break;
  92                 case XPRG_CMD_SET_PARAM:
  93                         PDIProtocol_SetParam();
  94                         break;
  95         }
  96 }
  97
  98 /** Handler for the XPROG ENTER_PROGMODE command to establish a PDI connection with the attached device. */
  99 static void PDIProtocol_EnterXPROGMode(void)
 100 {
 101         Endpoint_ClearOUT();
 102         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 103
 104         /* Enable PDI programming mode with the attached target */
 105         PDITarget_EnableTargetPDI();
 106
 107         /* Store the RESET key into the RESET PDI register to keep the XMEGA in reset */
 108         PDITarget_SendByte(PDI_CMD_STCS | PDI_RESET_REG);
 109         PDITarget_SendByte(PDI_RESET_KEY);
 110
 111         /* Enable access to the XPROG NVM bus by sending the documented NVM access key to the device */
 112         PDITarget_SendByte(PDI_CMD_KEY);
 113         for (uint8_t i = sizeof(PDI_NVMENABLE_KEY); i > 0; i--)
 114           PDITarget_SendByte(PDI_NVMENABLE_KEY[i - 1]);
 115
 116         /* Wait until the NVM bus becomes active */
 117         bool NVMBusEnabled = NVMTarget_WaitWhileNVMBusBusy();
 118
 119         Endpoint_Write_Byte(CMD_XPROG);
 120         Endpoint_Write_Byte(XPRG_CMD_ENTER_PROGMODE);
 121         Endpoint_Write_Byte(NVMBusEnabled ? XPRG_ERR_OK : XPRG_ERR_FAILED);
 122         Endpoint_ClearIN();
 123 }
 124
 125 /** Handler for the XPROG LEAVE_PROGMODE command to terminate the PDI programming connection with
 126  *  the attached device.
 127  */
 128 static void PDIProtocol_LeaveXPROGMode(void)
 129 {
 130         Endpoint_ClearOUT();
 131         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 132
 133         /* Clear the RESET key in the RESET PDI register to allow the XMEGA to run */
 134         PDITarget_SendByte(PDI_CMD_STCS | PDI_RESET_REG);
 135         PDITarget_SendByte(0x00);
 136
 137         PDITarget_DisableTargetPDI();
 138
 139         Endpoint_Write_Byte(CMD_XPROG);
 140         Endpoint_Write_Byte(XPRG_CMD_LEAVE_PROGMODE);
 141         Endpoint_Write_Byte(XPRG_ERR_OK);
 142         Endpoint_ClearIN();
 143 }
 144
 145 /** Handler for the XPRG ERASE command to erase a specific memory address space in the attached device. */
 146 static void PDIProtocol_Erase(void)
 147 {
 148         uint8_t ReturnStatus = XPRG_ERR_OK;
 149
 150         struct
 151         {
 152                 uint8_t  MemoryType;
 153                 uint32_t Address;
 154         } Erase_XPROG_Params;
 155
 156         Endpoint_Read_Stream_LE(&Erase_XPROG_Params, sizeof(Erase_XPROG_Params));
 157
 158         Endpoint_ClearOUT();
 159         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 160
 161         // TODO: Send erase command here via PDI protocol
 162
 163         Endpoint_Write_Byte(CMD_XPROG);
 164         Endpoint_Write_Byte(XPRG_CMD_ERASE);
 165         Endpoint_Write_Byte(ReturnStatus);
 166         Endpoint_ClearIN();
 167 }
 168
 169 /** Handler for the XPROG WRITE_MEMORY command to write to a specific memory space within the attached device. */
 170 static void PDIProtocol_WriteMemory(void)
 171 {
 172         uint8_t ReturnStatus = XPRG_ERR_OK;
 173
 174         struct
 175         {
 176                 uint8_t  MemoryType;
 177                 uint32_t Address;
 178                 uint16_t Length;
 179                 uint8_t  ProgData[256];
 180         } WriteMemory_XPROG_Params;
 181
 182         Endpoint_Read_Stream_LE(&WriteMemory_XPROG_Params, (sizeof(WriteMemory_XPROG_Params) -
 183                                                             sizeof(WriteMemory_XPROG_Params).ProgData));
 184         WriteMemory_XPROG_Params.Address = SwapEndian_32(WriteMemory_XPROG_Params.Address);
 185         WriteMemory_XPROG_Params.Length  = SwapEndian_16(WriteMemory_XPROG_Params.Length);
 186         Endpoint_Read_Stream_LE(&WriteMemory_XPROG_Params.ProgData, WriteMemory_XPROG_Params.Length);
 187
 188         Endpoint_ClearOUT();
 189         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 190
 191         // TODO: Send program command here via PDI protocol
 192
 193         Endpoint_Write_Byte(CMD_XPROG);
 194         Endpoint_Write_Byte(XPRG_CMD_READ_MEM);
 195         Endpoint_Write_Byte(ReturnStatus);
 196         Endpoint_ClearIN();
 197 }
 198
 199 /** Handler for the XPROG READ_MEMORY command to read data from a specific address space within the
 200  *  attached device.
 201  */
 202 static void PDIProtocol_ReadMemory(void)
 203 {
 204         uint8_t ReturnStatus = XPRG_ERR_OK;
 205
 206         struct
 207         {
 208                 uint8_t  MemoryType;
 209                 uint32_t Address;
 210                 uint16_t Length;
 211         } ReadMemory_XPROG_Params;
 212
 213         Endpoint_Read_Stream_LE(&ReadMemory_XPROG_Params, sizeof(ReadMemory_XPROG_Params));
 214         ReadMemory_XPROG_Params.Address = SwapEndian_32(ReadMemory_XPROG_Params.Address);
 215         ReadMemory_XPROG_Params.Length  = SwapEndian_16(ReadMemory_XPROG_Params.Length);
 216
 217         Endpoint_ClearOUT();
 218         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 219
 220         if (ReadMemory_XPROG_Params.MemoryType == XPRG_MEM_TYPE_USERSIG)
 221         {
 222                 PDITarget_SendByte(PDI_CMD_STS | (PDI_DATSIZE_1BYTE << 2));
 223                 NVMTarget_SendNVMRegAddress(NVM_REG_CMD);
 224                 PDITarget_SendByte(NVM_CMD_READUSERSIG);
 225
 226                 // TODO
 227         }
 228
 229         Endpoint_Write_Byte(CMD_XPROG);
 230         Endpoint_Write_Byte(XPRG_CMD_READ_MEM);
 231         Endpoint_Write_Byte(ReturnStatus);
 232
 233         Endpoint_ClearIN();
 234 }
 235
 236 /** Handler for the XPROG CRC command to read a specific memory space's CRC value for comparison between the
 237  *  attached device's memory and a data set on the host.
 238  */
 239 static void PDIProtocol_ReadCRC(void)
 240 {
 241         uint8_t ReturnStatus = XPRG_ERR_OK;
 242
 243         struct
 244         {
 245                 uint8_t CRCType;
 246         } ReadCRC_XPROG_Params;
 247
 248         Endpoint_Read_Stream_LE(&ReadCRC_XPROG_Params, sizeof(ReadCRC_XPROG_Params));
 249         Endpoint_ClearOUT();
 250         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 251
 252         uint32_t MemoryCRC;
 253
 254         if (ReadCRC_XPROG_Params.CRCType == XPRG_CRC_APP)
 255           MemoryCRC = NVMTarget_GetMemoryCRC(NVM_CMD_APPCRC);
 256         else if (ReadCRC_XPROG_Params.CRCType == XPRG_CRC_BOOT)
 257           MemoryCRC = NVMTarget_GetMemoryCRC(NVM_CMD_BOOTCRC);
 258         else
 259           MemoryCRC = NVMTarget_GetMemoryCRC(NVM_CMD_FLASHCRC);
 260
 261         Endpoint_Write_Byte(CMD_XPROG);
 262         Endpoint_Write_Byte(XPRG_CMD_CRC);
 263         Endpoint_Write_Byte(ReturnStatus);
 264
 265         if (ReturnStatus == XPRG_ERR_OK)
 266         {
 267                 Endpoint_Write_Byte(MemoryCRC >> 16);
 268                 Endpoint_Write_Word_LE(MemoryCRC & 0xFFFF);
 269         }
 270
 271         Endpoint_ClearIN();
 272 }
 273
 274 /** Handler for the XPROG SET_PARAM command to set a PDI parameter for use when communicating with the
 275  *  attached device.
 276  */
 277 static void PDIProtocol_SetParam(void)
 278 {
 279         uint8_t ReturnStatus = XPRG_ERR_OK;
 280
 281         uint8_t XPROGParam = Endpoint_Read_Byte();
 282
 283         if (XPROGParam == XPRG_PARAM_NVMBASE)
 284           XPROG_Param_NVMBase = Endpoint_Read_DWord_BE();
 285         else if (XPROGParam == XPRG_PARAM_EEPPAGESIZE)
 286           XPROG_Param_EEPageSize = Endpoint_Read_Word_BE();
 287         else
 288           ReturnStatus = XPRG_ERR_FAILED;
 289
 290         Endpoint_ClearOUT();
 291         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 292
 293         Endpoint_Write_Byte(CMD_XPROG);
 294         Endpoint_Write_Byte(XPRG_CMD_SET_PARAM);
 295         Endpoint_Write_Byte(ReturnStatus);
 296         Endpoint_ClearIN();
 297 }
 298
 299 #endif