forksand
/
qmk_firmware
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Reorganise V2Protocol.c, add in function to assert or de-assert target RESET pin.

Browse Source
pull/1469/head
Dean Camera 16 years ago
parent 04354ffcad
commit 32cc2b8d4d
5 changed files with 132 additions and 93 deletions
Show Stats Download Patch File Download Diff File

2
Projects/Unfinished/AVRISP/AVRISP.c
Unescape View File

@ -43,7 +43,7 @@ int main(void)
{ {
SetupHardware(); SetupHardware();
V2Protocol_ConfigureHardware(); V2Protocol_Init();
printf("AVRISP-MKII Clone\r\n"); printf("AVRISP-MKII Clone\r\n");

8
Projects/Unfinished/AVRISP/AVRISP.txt
Unescape View File

@ -55,9 +55,6 @@
* This device spoofs Atmel's official AVRISP-MKII device PID so that it remains compatible with Atmel's AVRISP-MKII * This device spoofs Atmel's official AVRISP-MKII device PID so that it remains compatible with Atmel's AVRISP-MKII
* drivers. When promted, direct your OS to install Atmel's AVRISP-MKII drivers provided with AVRStudio. * drivers. When promted, direct your OS to install Atmel's AVRISP-MKII drivers provided with AVRStudio.
* *
* This demo contains both FLASH and EEPROM data, as compiled .HEX and .EEP files respectively. <b>Both</b> files must
* be loaded into the device for it to perform correctly.
*
* \section SSec_Options Project Options * \section SSec_Options Project Options
* *
* The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value. * The following defines can be found in this demo, which can control the demo behaviour when defined, or changed in value.
@ -74,11 +71,6 @@
* <td>PORT register for the programmer's target RESET line.</td> * <td>PORT register for the programmer's target RESET line.</td>
* </tr> * </tr>
* <tr> * <tr>
* <td>RESET_LINE_PIN</td>
* <td>Makefile CDEFS</td>
* <td>PIN register for the programmer's target RESET line.</td>
* </tr>
* <tr>
* <td>RESET_LINE_DDR</td> * <td>RESET_LINE_DDR</td>
* <td>Makefile CDEFS</td> * <td>Makefile CDEFS</td>
* <td>DDR register for the programmer's target RESET line.</td> * <td>DDR register for the programmer's target RESET line.</td>

176
Projects/Unfinished/AVRISP/Lib/V2Protocol.c
Unescape View File

@ -36,48 +36,109 @@
#define INCLUDE_FROM_V2PROTOCOL_C #define INCLUDE_FROM_V2PROTOCOL_C
#include "V2Protocol.h" #include "V2Protocol.h"
ParameterItem_t ParameterTable[] EEMEM = /* Table of masks for SPI_Init() from a given PARAM_SCK_DURATION value */
static const uint8_t SPIMaskFromSCKDuration[] =
{
#if (F_CPU == 8000000)
SPI_SPEED_FCPU_DIV_2,
#endif
SPI_SPEED_FCPU_DIV_2, SPI_SPEED_FCPU_DIV_4, SPI_SPEED_FCPU_DIV_8,
SPI_SPEED_FCPU_DIV_16, SPI_SPEED_FCPU_DIV_32, SPI_SPEED_FCPU_DIV_64
#if (F_CPU == 16000000)
, SPI_SPEED_FCPU_DIV_128
#endif
};
/* Non-Volatile Parameter Values for EEPROM storage */
uint8_t EEMEM EEPROM_Rest_Polarity;
/* Volatile Parameter Values for RAM storage */
static ParameterItem_t ParameterTable[] =
{ {
{ .ParameterID = PARAM_BUILD_NUMBER_LOW, { .ParameterID = PARAM_BUILD_NUMBER_LOW,
.ParameterValue = 0x00 }, .ParameterValue = (LUFA_VERSION_INTEGER >> 8) },
{ .ParameterID = PARAM_BUILD_NUMBER_HIGH, { .ParameterID = PARAM_BUILD_NUMBER_HIGH,
.ParameterValue = 0x00 }, .ParameterValue = (LUFA_VERSION_INTEGER & 0xFF) },
{ .ParameterID = PARAM_HW_VER, { .ParameterID = PARAM_HW_VER,
.ParameterValue = 0x01 }, .ParameterValue = 0x01 },
{ .ParameterID = PARAM_SW_MAJOR, { .ParameterID = PARAM_SW_MAJOR,
.ParameterValue = 0x01 }, .ParameterValue = 0x01 },
{ .ParameterID = PARAM_SW_MINOR, { .ParameterID = PARAM_SW_MINOR,
.ParameterValue = 0x00 }, .ParameterValue = 0x00 },
{ .ParameterID = PARAM_VTARGET, { .ParameterID = PARAM_VTARGET,
.ParameterValue = 0x00 }, .ParameterValue = 0x00 },
{ .ParameterID = PARAM_SCK_DURATION, { .ParameterID = PARAM_SCK_DURATION,
.ParameterValue = 0x00 }, .ParameterValue = sizeof(SPIMaskFromSCKDuration) },
{ .ParameterID = PARAM_RESET_POLARITY, { .ParameterID = PARAM_RESET_POLARITY,
.ParameterValue = 0x00 }, .ParameterValue = 0x01 },
{ .ParameterID = PARAM_STATUS_TGT_CONN, { .ParameterID = PARAM_STATUS_TGT_CONN,
.ParameterValue = 0x00 }, .ParameterValue = 0x00 },
{ .ParameterID = PARAM_DISCHARGEDELAY, { .ParameterID = PARAM_DISCHARGEDELAY,
.ParameterValue = 0x00 }, .ParameterValue = 0x00 },
}; };
void V2Protocol_ConfigureHardware(void)
{
#if F_CPU == 8000000
uint8_t SPIMaskFromSCKDuration[] = {SPI_SPEED_FCPU_DIV_128, SPI_SPEED_FCPU_DIV_128, SPI_SPEED_FCPU_DIV_128,
SPI_SPEED_FCPU_DIV_128, SPI_SPEED_FCPU_DIV_128, SPI_SPEED_FCPU_DIV_128};
#else
uint8_t SPIMaskFromSCKDuration[] = {SPI_SPEED_FCPU_DIV_128, SPI_SPEED_FCPU_DIV_128, SPI_SPEED_FCPU_DIV_128,
SPI_SPEED_FCPU_DIV_128, SPI_SPEED_FCPU_DIV_128, SPI_SPEED_FCPU_DIV_128};
#endif
uint8_t SCKDuration = eeprom_read_byte(&V2Protocol_GetParameterItem(PARAM_SCK_DURATION)->ParameterValue); static void V2Protocol_ReconfigureSPI(void)
{
uint8_t SCKDuration = V2Protocol_GetParameter(PARAM_SCK_DURATION);
if (SCKDuration > sizeof(SPIMaskFromSCKDuration)) if (SCKDuration >= sizeof(SPIMaskFromSCKDuration))
SCKDuration = SPIMaskFromSCKDuration; SCKDuration = (sizeof(SPIMaskFromSCKDuration) - 1);
SPI_Init(SPIMaskFromSCKDuration[SCKDuration], true); SPI_Init(SPIMaskFromSCKDuration[SCKDuration], true);
} }
static void V2Protocol_ChangeTargetResetLine(bool ResetTarget)
{
if (ResetTarget)
{
RESET_LINE_DDR |= RESET_LINE_MASK;
if (!(V2Protocol_GetParameter(PARAM_RESET_POLARITY)))
RESET_LINE_PORT |= RESET_LINE_MASK;
}
else
{
RESET_LINE_PORT &= ~RESET_LINE_MASK;
RESET_LINE_DDR &= ~RESET_LINE_MASK;
}
}
static uint8_t V2Protocol_GetParameter(uint8_t ParamID)
{
/* Find the parameter in the parameter table and retrieve the value */
for (uint8_t TableIndex = 0; TableIndex < (sizeof(ParameterTable) / sizeof(ParameterTable[0])); TableIndex++)
{
if (ParamID == ParameterTable[TableIndex].ParameterID)
return ParameterTable[TableIndex].ParameterValue;
}
return 0;
}
static void V2Protocol_SetParameter(uint8_t ParamID, uint8_t Value)
{
/* The target RESET line polarity is a non-volatile parameter, save to EEPROM when changed */
if (ParamID == PARAM_RESET_POLARITY)
eeprom_write_byte(&EEPROM_Rest_Polarity, Value);
/* Find the parameter in the parameter table and store the new value */
for (uint8_t TableIndex = 0; TableIndex < (sizeof(ParameterTable) / sizeof(ParameterTable[0])); TableIndex++)
{
if (ParamID == ParameterTable[TableIndex].ParameterID)
{
ParameterTable[TableIndex].ParameterValue = Value;
return;
}
}
}
void V2Protocol_Init(void)
{
/* Target RESET line polarity is a non-volatile value, retrieve current parameter value from EEPROM */
V2Protocol_SetParameter(PARAM_RESET_POLARITY, eeprom_read_byte(&EEPROM_Rest_Polarity));
}
void V2Protocol_ProcessCommand(void) void V2Protocol_ProcessCommand(void)
{ {
uint8_t V2Command = Endpoint_Read_Byte(); uint8_t V2Command = Endpoint_Read_Byte();
@ -85,28 +146,17 @@ void V2Protocol_ProcessCommand(void)
switch (V2Command) switch (V2Command)
{ {
case CMD_SIGN_ON: case CMD_SIGN_ON:
V2Protocol_ProcessCmdSignOn(); V2Protocol_Command_SignOn();
break; break;
case CMD_SET_PARAMETER: case CMD_SET_PARAMETER:
case CMD_GET_PARAMETER: case CMD_GET_PARAMETER:
V2Protocol_ProcessCmdGetSetParam(V2Command); V2Protocol_Command_GetSetParam(V2Command);
break; break;
case CMD_SPI_MULTI: case CMD_SPI_MULTI:
V2Protocol_ProcessCmdSPIMulti(); V2Protocol_Command_SPIMulti();
break; break;
default: default:
while (Endpoint_BytesInEndpoint() == AVRISP_DATA_EPSIZE) V2Protocol_Command_Unknown(V2Command);
{
Endpoint_ClearOUT();
while (!(Endpoint_IsOUTReceived()));
}
Endpoint_ClearOUT();
Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
Endpoint_Write_Byte(V2Command);
Endpoint_Write_Byte(STATUS_CMD_UNKNOWN);
Endpoint_ClearIN();
break; break;
} }
@ -116,24 +166,29 @@ void V2Protocol_ProcessCommand(void)
Endpoint_SetEndpointDirection(ENDPOINT_DIR_OUT); Endpoint_SetEndpointDirection(ENDPOINT_DIR_OUT);
} }
static ParameterItem_t* V2Protocol_GetParameterItem(uint8_t ParamID) static void V2Protocol_Command_Unknown(uint8_t V2Command)
{ {
for (uint8_t TableIndex = 0; TableIndex < (sizeof(ParameterTable) / sizeof(ParameterTable[0])); TableIndex++) while (Endpoint_BytesInEndpoint() == AVRISP_DATA_EPSIZE)
{ {
if (ParamID == eeprom_read_byte(&ParameterTable[TableIndex].ParameterID)) Endpoint_ClearOUT();
return &ParameterTable[TableIndex]; while (!(Endpoint_IsOUTReceived()));
} }
return NULL; Endpoint_ClearOUT();
Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
Endpoint_Write_Byte(V2Command);
Endpoint_Write_Byte(STATUS_CMD_UNKNOWN);
Endpoint_ClearIN();
} }
static void V2Protocol_ProcessCmdSignOn(void) static void V2Protocol_Command_SignOn(void)
{ {
Endpoint_ClearOUT(); Endpoint_ClearOUT();
Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN); Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
Endpoint_WaitUntilReady(); Endpoint_WaitUntilReady();
V2Protocol_ConfigureHardware(); V2Protocol_ReconfigureSPI();
Endpoint_Write_Byte(CMD_SIGN_ON); Endpoint_Write_Byte(CMD_SIGN_ON);
Endpoint_Write_Byte(STATUS_CMD_OK); Endpoint_Write_Byte(STATUS_CMD_OK);
@ -142,7 +197,7 @@ static void V2Protocol_ProcessCmdSignOn(void)
Endpoint_ClearIN(); Endpoint_ClearIN();
} }
static void V2Protocol_ProcessCmdGetSetParam(uint8_t V2Command) static void V2Protocol_Command_GetSetParam(uint8_t V2Command)
{ {
uint8_t ParamID = Endpoint_Read_Byte(); uint8_t ParamID = Endpoint_Read_Byte();
uint8_t ParamValue = Endpoint_Read_Byte(); uint8_t ParamValue = Endpoint_Read_Byte();
@ -151,28 +206,18 @@ static void V2Protocol_ProcessCmdGetSetParam(uint8_t V2Command)
Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN); Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
Endpoint_WaitUntilReady(); Endpoint_WaitUntilReady();
ParameterItem_t* ParameterItem = V2Protocol_GetParameterItem(ParamID);
Endpoint_Write_Byte(V2Command); Endpoint_Write_Byte(V2Command);
Endpoint_Write_Byte(STATUS_CMD_OK);
if (ParameterItem != NULL) if (V2Command == CMD_SET_PARAMETER)
{ V2Protocol_SetParameter(ParamID, ParamValue);
Endpoint_Write_Byte(STATUS_CMD_OK);
if (V2Command == CMD_SET_PARAMETER)
eeprom_write_byte(&ParameterItem->ParameterValue, ParamValue);
else
Endpoint_Write_Byte(eeprom_read_byte(&ParameterItem->ParameterValue));
}
else else
{ Endpoint_Write_Byte(V2Protocol_GetParameter(ParamID));
Endpoint_Write_Byte(STATUS_CMD_FAILED);
}
Endpoint_ClearIN(); Endpoint_ClearIN();
} }
static void V2Protocol_ProcessCmdSPIMulti(void) static void V2Protocol_Command_SPIMulti(void)
{ {
uint8_t TxBytes = Endpoint_Read_Byte(); uint8_t TxBytes = Endpoint_Read_Byte();
uint8_t RxBytes = Endpoint_Read_Byte(); uint8_t RxBytes = Endpoint_Read_Byte();
@ -204,14 +249,9 @@ static void V2Protocol_ProcessCmdSPIMulti(void)
while (CurrRxPos < RxBytes) while (CurrRxPos < RxBytes)
{ {
if (CurrTxPos < TxBytes) if (CurrTxPos < TxBytes)
{ Endpoint_Write_Byte(SPI_TransferByte(TxData[CurrTxPos++]));
Endpoint_Write_Byte(SPI_TransferByte(TxData[CurrTxPos]));
CurrTxPos++;
}
else else
{ Endpoint_Write_Byte(SPI_ReceiveByte());
Endpoint_Write_Byte(SPI_ReceiveByte());
}
CurrRxPos++; CurrRxPos++;
} }

18
Projects/Unfinished/AVRISP/Lib/V2Protocol.h
Unescape View File

@ -38,7 +38,9 @@
/* Includes: */ /* Includes: */
#include <avr/io.h> #include <avr/io.h>
#include <avr/eeprom.h>
#include <LUFA/Version.h>
#include <LUFA/Drivers/USB/USB.h> #include <LUFA/Drivers/USB/USB.h>
#include <LUFA/Drivers/Peripheral/SPI.h> #include <LUFA/Drivers/Peripheral/SPI.h>
@ -57,14 +59,20 @@
} ParameterItem_t; } ParameterItem_t;
/* Function Prototypes: */ /* Function Prototypes: */
void V2Protocol_ConfigureHardware(void); void V2Protocol_Init(void);
void V2Protocol_ProcessCommand(void); void V2Protocol_ProcessCommand(void);
#if defined(INCLUDE_FROM_V2PROTOCOL_C) #if defined(INCLUDE_FROM_V2PROTOCOL_C)
static ParameterItem_t* V2Protocol_GetParameterItem(uint8_t ParamID); static void V2Protocol_ReconfigureSPI(void);
static void V2Protocol_ProcessCmdSignOn(void); static void V2Protocol_ChangeTargetResetLine(bool ResetTarget);
static void V2Protocol_ProcessCmdGetSetParam(uint8_t V2Command);
static void V2Protocol_ProcessCmdSPIMulti(void); static uint8_t V2Protocol_GetParameter(uint8_t ParamID);
static void V2Protocol_SetParameter(uint8_t ParamID, uint8_t Value);
static void V2Protocol_Command_Unknown(uint8_t V2Command);
static void V2Protocol_Command_SignOn(void);
static void V2Protocol_Command_GetSetParam(uint8_t V2Command);
static void V2Protocol_Command_SPIMulti(void);
#endif #endif
#endif #endif

1
Projects/Unfinished/AVRISP/makefile
Unescape View File

@ -194,7 +194,6 @@ CSTANDARD = -std=gnu99
# Place -D or -U options here for C sources # Place -D or -U options here for C sources
CDEFS = -DF_CPU=$(F_CPU)UL -DF_CLOCK=$(F_CLOCK)UL -DBOARD=BOARD_$(BOARD) $(LUFA_OPTS) CDEFS = -DF_CPU=$(F_CPU)UL -DF_CLOCK=$(F_CLOCK)UL -DBOARD=BOARD_$(BOARD) $(LUFA_OPTS)
CDEFS += -DRESET_LINE_PORT=PORTA CDEFS += -DRESET_LINE_PORT=PORTA
CDEFS += -DRESET_LINE_PIN=PINA
CDEFS += -DRESET_LINE_DDR=DDRA CDEFS += -DRESET_LINE_DDR=DDRA
CDEFS += -DRESET_LINE_MASK="(1 << 0)" CDEFS += -DRESET_LINE_MASK="(1 << 0)"

Write Preview
Loading…
Cancel
Save