Projects/Incomplete/AVRISP/Lib/V2Protocol.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  *  V2Protocol handler, to process V2 Protocol commands used in Atmel programmer devices.
  34  */
  35
  36 #define  INCLUDE_FROM_V2PROTOCOL_C
  37 #include "V2Protocol.h"
  38
  39 uint32_t CurrentAddress;
  40
  41
  42 /* Table of masks for SPI_Init() from a given PARAM_SCK_DURATION value */
  43 static const uint8_t SPIMaskFromSCKDuration[MAX_SPI_SETTINGS] =
  44         {
  45                 #if (F_CPU == 8000000)
  46                 SPI_SPEED_FCPU_DIV_2,
  47                 #endif
  48                 SPI_SPEED_FCPU_DIV_2, SPI_SPEED_FCPU_DIV_4, SPI_SPEED_FCPU_DIV_8,
  49                 SPI_SPEED_FCPU_DIV_16, SPI_SPEED_FCPU_DIV_32, SPI_SPEED_FCPU_DIV_64
  50                 #if (F_CPU == 16000000)
  51                 , SPI_SPEED_FCPU_DIV_128
  52                 #endif
  53         };
  54
  55 static void V2Protocol_ReconfigureSPI(void)
  56 {
  57         uint8_t SCKDuration = V2Params_GetParameterValue(PARAM_SCK_DURATION);
  58
  59         if (SCKDuration >= MAX_SPI_SETTINGS)
  60           SCKDuration = (MAX_SPI_SETTINGS - 1);
  61
  62         SPI_Init(SPIMaskFromSCKDuration[SCKDuration], true);
  63 }
  64
  65 static void V2Protocol_ChangeTargetResetLine(bool ResetTarget)
  66 {
  67         if (ResetTarget)
  68         {
  69                 RESET_LINE_DDR  |= RESET_LINE_MASK;
  70
  71                 if (!(V2Params_GetParameterValue(PARAM_RESET_POLARITY)))
  72                   RESET_LINE_PORT |= RESET_LINE_MASK;
  73         }
  74         else
  75         {
  76                 RESET_LINE_PORT &= ~RESET_LINE_MASK;
  77                 RESET_LINE_DDR  &= ~RESET_LINE_MASK;
  78         }
  79 }
  80
  81 void V2Protocol_ProcessCommand(void)
  82 {
  83         uint8_t V2Command = Endpoint_Read_Byte();
  84
  85         switch (V2Command)
  86         {
  87                 case CMD_SIGN_ON:
  88                         V2Protocol_Command_SignOn();
  89                         break;
  90                 case CMD_SET_PARAMETER:
  91                 case CMD_GET_PARAMETER:
  92                         V2Protocol_Command_GetSetParam(V2Command);
  93                         break;
  94                 case CMD_LOAD_ADDRESS:
  95                         V2Protocol_Command_LoadAddress();
  96                         break;
  97                 case CMD_SPI_MULTI:
  98                         V2Protocol_Command_SPIMulti();
  99                         break;
 100                 default:
 101                         V2Protocol_Command_Unknown(V2Command);
 102                         break;
 103         }
 104
 105         printf("COMMAND 0x%02x\r\n", V2Command);
 106
 107         Endpoint_WaitUntilReady();
 108         Endpoint_SetEndpointDirection(ENDPOINT_DIR_OUT);
 109 }
 110
 111 static void V2Protocol_Command_Unknown(uint8_t V2Command)
 112 {
 113         /* Discard all incomming data */
 114         while (Endpoint_BytesInEndpoint() == AVRISP_DATA_EPSIZE)
 115         {
 116                 Endpoint_ClearOUT();
 117                 Endpoint_WaitUntilReady();
 118         }
 119
 120         Endpoint_ClearOUT();
 121         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 122         Endpoint_WaitUntilReady();
 123
 124         Endpoint_Write_Byte(V2Command);
 125         Endpoint_Write_Byte(STATUS_CMD_UNKNOWN);
 126         Endpoint_ClearIN();
 127 }
 128
 129 static void V2Protocol_Command_SignOn(void)
 130 {
 131         Endpoint_ClearOUT();
 132         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 133         Endpoint_WaitUntilReady();
 134
 135         V2Protocol_ReconfigureSPI();
 136         CurrentAddress = 0;
 137
 138         Endpoint_Write_Byte(CMD_SIGN_ON);
 139         Endpoint_Write_Byte(STATUS_CMD_OK);
 140         Endpoint_Write_Byte(PROGRAMMER_ID_LEN);
 141         Endpoint_Write_Stream_LE(PROGRAMMER_ID, PROGRAMMER_ID_LEN);
 142         Endpoint_ClearIN();
 143 }
 144
 145 static void V2Protocol_Command_GetSetParam(uint8_t V2Command)
 146 {
 147         uint8_t ParamID    = Endpoint_Read_Byte();
 148         uint8_t ParamValue = Endpoint_Read_Byte();
 149
 150         Endpoint_ClearOUT();
 151         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 152         Endpoint_WaitUntilReady();
 153
 154         uint8_t ParamPrivs = V2Params_GetParameterPrivellages(ParamID);
 155
 156         Endpoint_Write_Byte(V2Command);
 157
 158         if ((V2Command == CMD_SET_PARAMETER) && (ParamPrivs & PARAM_PRIV_WRITE))
 159         {
 160                 Endpoint_Write_Byte(STATUS_CMD_OK);
 161                 V2Params_SetParameterValue(ParamID, ParamValue);
 162         }
 163         else if ((V2Command == CMD_GET_PARAMETER) && (ParamPrivs & PARAM_PRIV_READ))
 164         {
 165                 Endpoint_Write_Byte(STATUS_CMD_OK);
 166                 Endpoint_Write_Byte(V2Params_GetParameterValue(ParamID));
 167         }
 168         else
 169         {
 170                 Endpoint_Write_Byte(STATUS_CMD_FAILED);
 171         }
 172
 173         Endpoint_ClearIN();
 174 }
 175
 176 static void V2Protocol_Command_LoadAddress(void)
 177 {
 178         CurrentAddress = Endpoint_Read_DWord_LE();
 179
 180         Endpoint_ClearOUT();
 181         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 182         Endpoint_WaitUntilReady();
 183
 184         Endpoint_Write_Byte(CMD_LOAD_ADDRESS);
 185         Endpoint_Write_Byte(STATUS_CMD_OK);
 186         Endpoint_ClearIN();
 187 }
 188
 189 static void V2Protocol_Command_SPIMulti(void)
 190 {
 191         uint8_t TxBytes     = Endpoint_Read_Byte();
 192         uint8_t RxBytes     = Endpoint_Read_Byte();
 193         uint8_t RxStartAddr = Endpoint_Read_Byte();
 194         uint8_t TxData[255];
 195
 196         Endpoint_Read_Stream_LE(TxData, TxBytes);
 197
 198         Endpoint_ClearOUT();
 199         Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
 200         Endpoint_WaitUntilReady();
 201
 202         Endpoint_Write_Byte(CMD_SPI_MULTI);
 203         Endpoint_Write_Byte(STATUS_CMD_OK);
 204
 205         uint8_t CurrTxPos = 0;
 206         uint8_t CurrRxPos = 0;
 207
 208         /* Write out bytes to transmit until the start of the bytes to receive is met */
 209         while (CurrTxPos < RxStartAddr)
 210         {
 211                 if (CurrTxPos < TxBytes)
 212                   SPI_SendByte(TxData[CurrTxPos]);
 213                 else
 214                   SPI_SendByte(0);
 215
 216                 CurrTxPos++;
 217         }
 218
 219         /* Transmit remaining bytes with padding as needed, read in response bytes */
 220         while (CurrRxPos < RxBytes)
 221         {
 222                 if (CurrTxPos < TxBytes)
 223                   Endpoint_Write_Byte(SPI_TransferByte(TxData[CurrTxPos++]));
 224                 else
 225                   Endpoint_Write_Byte(SPI_ReceiveByte());
 226
 227                 CurrRxPos++;
 228         }
 229
 230         Endpoint_Write_Byte(STATUS_CMD_OK);
 231         Endpoint_ClearIN();
 232 }