mirror of
https://github.com/ole00/afterburner.git
synced 2024-06-10 12:29:37 +00:00
e9d005213e
The PD feature is now selectively enabled or disabled based on the JED contents. Also, when fuses are read the printout of the JED file reflects the PD fuse bit state. So, when the PD fuse bit is enabled then the JED file contains an extra fuse bit set to 1. The ATF22V10C now behaves the same way regarding the PD fuse bit (previously Afterburner always disabled the PD function). credits: GALmate software
1812 lines
46 KiB
C++
1812 lines
46 KiB
C++
/*
|
|
(banner font: aciiart.eu)
|
|
_____________________________________________________________
|
|
| _ __ _ _ \
|
|
| / \ / _| |_ ___ _ _| |__ _ _ _ __ ___ ___ _ _ |\
|
|
| / _ \| |_| '_/ _ \| '_/ '_ \| | | | '_/ _ \/ _ \| '_/ ||
|
|
| / ___ \ _| |_| __/| | | |_) | |_| | | | | | | __/| | ||
|
|
| /_/ \_\| \__\___||_| |____/\___,_|_| |_| |_|___||_| ||
|
|
\_____________________________________________________________||
|
|
'------------------------------------------------------------'
|
|
|
|
Afterburner: GAL IC Programmer for Arduino by -= olin =-
|
|
|
|
Based on ATFblast 3.1 by Bruce Abbott
|
|
http://www.bhabbott.net.nz/atfblast.html
|
|
|
|
Based on GALBLAST by Manfred Winterhoff
|
|
http://www.armory.com/%7Erstevew/Public/Pgmrs/GAL/_ClikMe1st.htm
|
|
|
|
Based on GALmate by Yorck Thiele
|
|
https://www.ythiee.com/2021/06/06/galmate-hardware/
|
|
|
|
Supports:
|
|
* National GAL16V8
|
|
* Lattice GAL16V8A, GAL16V8B, GAL16V8D
|
|
* Lattice GAL22V10B
|
|
* Atmel ATF16V8B, ATF16V8C, ATF22V10B, ATF22V10CQZ
|
|
|
|
Requires:
|
|
* afterburner PC program to upload JED fuse map, erase, read etc.
|
|
* simple programming circuit. See: https://github.com/ole00/afterburner
|
|
|
|
Changelog:
|
|
* 2019.02.02 - initial version 0.1
|
|
* 2019.04.09 - v. 0.3,
|
|
- added set & check of gal type,
|
|
- fixed ATF22V10 and GAL22V10 CFG reading bug (porting bug)
|
|
|
|
*/
|
|
|
|
|
|
#define VERSION "0.4.2"
|
|
|
|
//#define DEBUG_PES
|
|
//#define DEBUG_VERIFY
|
|
|
|
//ARDUINO UNO pin mapping
|
|
// GAL PIN NAME | ARDUINO UNO PIN NUMBER
|
|
|
|
//programing voltage control pin
|
|
#define PIN_VPP 11
|
|
#define PIN_SDOUT 12
|
|
#define PIN_STROBE 13
|
|
#define PIN_PV 9
|
|
#define PIN_SDIN 8
|
|
|
|
|
|
#define PIN_RA0 10
|
|
#define PIN_RA1 2
|
|
#define PIN_RA2 3
|
|
#define PIN_RA3 4
|
|
#define PIN_RA4 5
|
|
#define PIN_RA5 6
|
|
#define PIN_SCLK 7
|
|
|
|
|
|
|
|
|
|
#define COMMAND_NONE 0
|
|
#define COMMAND_UNKNOWN 1
|
|
#define COMMAND_IDENTIFY_PROGRAMMER '*'
|
|
#define COMMAND_HELP 'h'
|
|
#define COMMAND_UPLOAD 'u'
|
|
#define COMMAND_DEBUG 'd'
|
|
#define COMMAND_READ_PES 'p'
|
|
#define COMMAND_READ_FUSES 'r'
|
|
#define COMMAND_WRITE_FUSES 'w'
|
|
#define COMMAND_VERIFY_FUSES 'v'
|
|
#define COMMAND_ERASE_GAL 'c'
|
|
#define COMMAND_UTX '#'
|
|
#define COMMAND_ECHO 'e'
|
|
#define COMMAND_TEST_VOLTAGE 't'
|
|
#define COMMAND_SET_GAL_TYPE 'g'
|
|
#define COMMAND_ENABLE_CHECK_TYPE 'f'
|
|
#define COMMAND_DISABLE_CHECK_TYPE 'F'
|
|
#define COMMAND_ENABLE_SECURITY 's'
|
|
#define COMMAND_ENABLE_APD 'z'
|
|
#define COMMAND_DISABLE_APD 'Z'
|
|
|
|
#define READGAL 0
|
|
#define VERIFYGAL 1
|
|
#define READPES 2
|
|
#define SCLKTEST 3
|
|
#define WRITEGAL 4
|
|
#define ERASEGAL 5
|
|
#define ERASEALL 6
|
|
#define BURNSECURITY 7
|
|
#define WRITEPES 8
|
|
#define VPPTEST 9
|
|
#define INIT 100
|
|
|
|
//check GAL type before starting an operation
|
|
#define FLAG_BIT_TYPE_CHECK (1 << 0)
|
|
|
|
// ATF16V8C flavour
|
|
#define FLAG_BIT_ATF16V8C (1 << 1)
|
|
|
|
// Keep the power-down feature enabled for ATF C GALs
|
|
#define FLAG_BIT_APD (1 << 2)
|
|
|
|
// contents of pes[3]
|
|
// Atmel PES is text string eg. 1B8V61F1 or 3Z01V22F1
|
|
// ^ ^
|
|
#define LATTICE 0xA1
|
|
#define NATIONAL 0x8F
|
|
#define SGSTHOMSON 0x20
|
|
#define ATMEL16 'V'
|
|
#define ATMEL22 '1'
|
|
|
|
typedef enum {
|
|
UNKNOWN,
|
|
GAL16V8,
|
|
GAL20V8,
|
|
GAL22V10,
|
|
ATF16V8B,
|
|
ATF22V10B,
|
|
ATF22V10C,
|
|
LAST_GAL_TYPE //dummy
|
|
} GALTYPE;
|
|
|
|
#define BIT_NONE 0
|
|
#define BIT_ZERO 1
|
|
#define BIT_ONE 2
|
|
|
|
// config bit numbers
|
|
|
|
#define CFG_BASE_16 2048
|
|
#define CFG_BASE_20 2560
|
|
#define CFG_BASE_22 5808
|
|
|
|
#define CFG_STROBE_ROW 0
|
|
#define CFG_SET_ROW 1
|
|
|
|
// Atmel power-down row
|
|
#define CFG_ROW_APD 59
|
|
|
|
// common CFG fuse address map for cfg16V8 and cfg20V8
|
|
// the only difference is the starting address: 2048 for cfg16V8 and 2560 for cfg20V8
|
|
// total size: 82
|
|
static const unsigned char cfgV8[]=
|
|
{
|
|
80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,
|
|
0,1,2,3,
|
|
145,
|
|
72,73,74,75,76,77,78,79,
|
|
144,
|
|
4,5,6,7,
|
|
112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
|
|
};
|
|
|
|
// common CFG fuse address map for cfg16V8AB and cfg20V8AB
|
|
// the only difference is the starting address: 2048 for cfg16V8AB and 2560 for cfg20V8AB
|
|
// total size: 82
|
|
static const unsigned char cfgV8AB[]=
|
|
{
|
|
0,1,2,3,
|
|
145,
|
|
72,73,74,75,
|
|
80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
|
|
76,77,78,79,
|
|
144,
|
|
4,5,6,7,
|
|
};
|
|
|
|
// common CFG fuse address map for cfg22V10
|
|
// starting address: 5808
|
|
// total size 20
|
|
static const unsigned char cfgV10[]=
|
|
{
|
|
1,0,3,2,5,4,7,6,9,8,11,10,13,12,15,14,17,16,19,18,
|
|
};
|
|
|
|
|
|
// UES user electronic signature
|
|
// PES programmer electronic signature (ATF = text string, others = Vendor/Vpp/timing)
|
|
// cfg configuration bits for OLMCs
|
|
|
|
// GAL info
|
|
static struct
|
|
{
|
|
GALTYPE type;
|
|
unsigned char id0,id1; /* variant 1, variant 2 (eg. 16V8=0x00, 16V8A+=0x1A)*/
|
|
short fuses; /* total number of fuses */
|
|
char pins; /* number of pins on chip */
|
|
char rows; /* number of fuse rows */
|
|
unsigned char bits; /* number of fuses per row */
|
|
char uesrow; /* UES row number */
|
|
short uesfuse; /* first UES fuse number */
|
|
char uesbytes; /* number of UES bytes */
|
|
char eraserow; /* row adddeess for erase */
|
|
char eraseallrow; /* row address for erase all (also PES) */
|
|
char pesrow; /* row address for PES read/write */
|
|
char pesbytes; /* number of PES bytes */
|
|
char cfgrow; /* row address of config bits (ACW) */
|
|
unsigned short cfgbase; /* base address of the config bit numbers */
|
|
const unsigned char *cfg; /* pointer to config bit numbers */
|
|
unsigned char cfgbits; /* number of config bits */
|
|
unsigned char cfgmethod; /* strobe or set row for reading config */
|
|
}
|
|
galinfo[]=
|
|
{
|
|
// + fuses + bits +uesbytes +pesrow +cfgbase
|
|
// | +pins | +uesrow | +eraserow| +pesbytes | +cfg
|
|
// +-- type + id0 + id1 | | +rows | | +uesfuse | +eraseallrow +cfgrow | | + cfgbits +cfgmethod
|
|
// | | | | | | | | | | | | | | | | | | |
|
|
{UNKNOWN, 0x00, 0x00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, NULL, 0 , 0},
|
|
{GAL16V8, 0x00, 0x1A, 2194, 20, 32, 64, 32, 2056, 8, 63, 54, 58, 8, 60, CFG_BASE_16, cfgV8AB, sizeof(cfgV8AB), CFG_STROBE_ROW},
|
|
{GAL20V8, 0x20, 0x3A, 2706, 24, 40, 64, 40, 2568, 8, 63, 59, 58, 8, 60, CFG_BASE_20, cfgV8AB, sizeof(cfgV8AB), CFG_STROBE_ROW},
|
|
{GAL22V10, 0x48, 0x49, 5892, 24, 44, 132, 44, 5828, 8, 61, 60, 58, 10, 16, CFG_BASE_22, cfgV10, sizeof(cfgV10) , CFG_SET_ROW },
|
|
{ATF16V8B, 0x00, 0x00, 2194, 20, 32, 64, 32, 2056, 8, 63, 54, 58, 8, 60, CFG_BASE_16, cfgV8AB, sizeof(cfgV8AB), CFG_STROBE_ROW},
|
|
{ATF22V10B, 0x00, 0x00, 5892, 24, 44, 132, 44, 5828, 8, 61, 60, 58, 10, 16, CFG_BASE_22, cfgV10, sizeof(cfgV10) , CFG_SET_ROW },
|
|
{ATF22V10C, 0x00, 0x00, 5892, 24, 44, 132, 44, 5828, 8, 61, 60, 58, 10, 16, CFG_BASE_22, cfgV10, sizeof(cfgV10) , CFG_SET_ROW },
|
|
};
|
|
|
|
// MAXFUSES calculated as the biggest required space to hold the fuse bitmap + UES bitmap + CFG bitmap
|
|
// MAXFUSES = ((132 * 44 bits) / 8) + uesbytes + ((20 + 1) / 8) // +1 is the power-down extra fuse
|
|
// 726 + 8 + 3
|
|
#define MAXFUSES 737
|
|
|
|
|
|
GALTYPE gal __attribute__ ((section (".noinit"))); //the gal device index pointing to galinfo, value is preserved between resets
|
|
|
|
static short security = 0, erasetime = 100, progtime = 100, vpp = 0;
|
|
|
|
char echoEnabled;
|
|
unsigned char pes[12];
|
|
char line[64];
|
|
char programName[32];
|
|
short lineIndex;
|
|
char endOfLine;
|
|
char mapUploaded;
|
|
char isUploading;
|
|
char uploadError;
|
|
unsigned char fusemap[MAXFUSES];
|
|
unsigned char flagBits;
|
|
|
|
|
|
static void setFuseBit(unsigned short bitPos);
|
|
static unsigned short checkSum(unsigned short n);
|
|
static char checkGalTypeViaPes(void);
|
|
static void turnOff(void);
|
|
static void printFormatedNumberHex2(unsigned char num) ;
|
|
|
|
// print some help on the serial console
|
|
void printHelp(char full) {
|
|
Serial.println(F("AFTerburner v." VERSION));
|
|
if (!full) {
|
|
Serial.println(F("type 'h' for help"));
|
|
return;
|
|
}
|
|
Serial.println(F("commands:"));
|
|
Serial.println(F(" h - print help"));
|
|
Serial.println(F(" e - toggle echo"));
|
|
Serial.println(F(" p - read & print PES"));
|
|
Serial.println(F(" r - read & print fuses"));
|
|
Serial.println(F(" u - upload fuses"));
|
|
Serial.println(F(" w - write uploaded fuses"));
|
|
Serial.println(F(" v - verify fuses"));
|
|
Serial.println(F(" c - erase chip"));
|
|
Serial.println(F(" t - test VPP"));
|
|
}
|
|
|
|
static void setFlagBit(uint8_t flag, uint8_t value) {
|
|
if (value) {
|
|
flagBits |= flag;
|
|
} else {
|
|
flagBits &= ~flag;
|
|
}
|
|
}
|
|
|
|
|
|
static void setupGpios(uint8_t pm) {
|
|
|
|
// Serial input of the GAL chip, output from Arduino
|
|
pinMode(PIN_SDIN, pm);
|
|
|
|
pinMode(PIN_STROBE, pm);
|
|
pinMode(PIN_PV, pm);
|
|
pinMode(PIN_RA0, pm);
|
|
pinMode(PIN_RA1, pm);
|
|
pinMode(PIN_RA2, pm);
|
|
pinMode(PIN_RA3, pm);
|
|
pinMode(PIN_RA4, pm);
|
|
pinMode(PIN_RA5, pm);
|
|
pinMode(PIN_SCLK, pm);
|
|
|
|
pinMode(PIN_VPP, pm);
|
|
}
|
|
|
|
// setup the Arduino board
|
|
void setup() {
|
|
// initialize serial:
|
|
Serial.begin(57600);
|
|
isUploading = 0;
|
|
endOfLine = 0;
|
|
echoEnabled = 0;
|
|
mapUploaded = 0;
|
|
lineIndex = 0;
|
|
setFlagBit(FLAG_BIT_TYPE_CHECK, 1); //do type check
|
|
|
|
// Serial output from the GAL chip, input for Arduino
|
|
pinMode(PIN_SDOUT, INPUT);
|
|
|
|
// Set all GPIO pins to Input to prevent accidents when
|
|
// inserting the GAL IC into socket.
|
|
setupGpios(INPUT);
|
|
|
|
printHelp(0);
|
|
Serial.println(">");
|
|
}
|
|
|
|
|
|
// read from serial line and discard the data
|
|
void readGarbage() {
|
|
while (Serial.available() > 0) {
|
|
Serial.read();
|
|
}
|
|
}
|
|
|
|
// Reads input from the serial terminal and returns the command
|
|
// which is the first character of the entered text.
|
|
|
|
char handleTerminalCommands() {
|
|
char c;
|
|
|
|
while (Serial.available() > 0) {
|
|
c = Serial.read();
|
|
line[lineIndex] = c;
|
|
if (c == '\n' || c == '\r') {
|
|
endOfLine = 1;
|
|
}
|
|
//echo input to output
|
|
else {
|
|
if (!isUploading && echoEnabled) {
|
|
Serial.print(c);
|
|
}
|
|
}
|
|
if (lineIndex >= 62) {
|
|
lineIndex = 0;
|
|
readGarbage();
|
|
Serial.println();
|
|
Serial.println("Error: line too long.");
|
|
} else {
|
|
lineIndex++;
|
|
}
|
|
}
|
|
if (endOfLine) {
|
|
c = COMMAND_NONE;
|
|
|
|
//single letter command entered
|
|
if (lineIndex == 2) {
|
|
c = line[0];
|
|
} else if (lineIndex > 2) {
|
|
c = line[0];
|
|
if (!isUploading || c != '#') {
|
|
if (c != COMMAND_SET_GAL_TYPE) {
|
|
c = COMMAND_UNKNOWN;
|
|
}
|
|
}
|
|
}
|
|
if (!isUploading) {
|
|
Serial.println();
|
|
line[lineIndex] = 0;
|
|
lineIndex = 0;
|
|
}
|
|
endOfLine = 0;
|
|
return c;
|
|
}
|
|
return COMMAND_NONE;
|
|
}
|
|
|
|
// Parses decimal integer number typed as 4 digit.
|
|
// Returns the number value.
|
|
unsigned short parse4dec(char i) {
|
|
unsigned short v = (line[i++] - '0') * 1000;
|
|
v += (line[i++] - '0') * 100;
|
|
v += (line[i++] - '0') * 10;
|
|
v += line[i] - '0';
|
|
return v;
|
|
}
|
|
|
|
// Converts textual hex value 0-9, A-F to a number.
|
|
unsigned char toHex(char c) {
|
|
if (c >= '0' && c <= '9') return c - '0';
|
|
if (c >= 'A' && c <= 'F') return c - 'A' + 10;
|
|
if (c >= 'a' && c <= 'f') return c - 'a' + 10;
|
|
return 0;
|
|
}
|
|
|
|
// Parses hexdecimal integer number typed as 2 digit.
|
|
// Returns the number value.
|
|
unsigned short parse2hex(char i) {
|
|
if (line[i] == '\r' || line[i] == 0 || line[i] == ' ') {
|
|
return -1;
|
|
}
|
|
|
|
unsigned short v = toHex(line[i++]) << 4;
|
|
return v + toHex(line[i]);
|
|
}
|
|
|
|
// Parses hexdecimal integer number typed as 4 digit.
|
|
// Returns the number value.
|
|
unsigned short parse4hex(char i) {
|
|
if (line[i] == '\r' || line[i] == 0 || line[i] == ' ') {
|
|
return -1;
|
|
}
|
|
|
|
unsigned short v = ((unsigned short)toHex(line[i++])) << 12;
|
|
v |= ((unsigned short)toHex(line[i++])) << 8;
|
|
v |= toHex(line[i++]) << 4;
|
|
return v + toHex(line[i]);
|
|
}
|
|
|
|
// Parses a line fed by the serial connection.
|
|
// This hnadles a primitive upload protocol that
|
|
// expects a programatic data feed - not suitable
|
|
// for human interaction.
|
|
// Data: each command on its own line
|
|
// line starts with '#' character followed by a command
|
|
// and a space. Then a command specific data follow.
|
|
// Commands:
|
|
// t <gal index>: gal type index to the GALTYPEE enum
|
|
// f <fuse index> <row>: row of fuse-map data starting on fuse bit index
|
|
// c <checksum> : checksum of the whole fuse map
|
|
// e : end ofthe upload transfer - returns to terminal
|
|
|
|
void parseUploadLine() {
|
|
switch (line[1]) {
|
|
case 'e': {
|
|
if (uploadError) {
|
|
Serial.print(F("ER upload failed"));
|
|
} else {
|
|
Serial.print(F("OK upload finished"));
|
|
}
|
|
isUploading = 0;
|
|
} break;
|
|
|
|
// gal type
|
|
case 't': {
|
|
short v = line[3] - '0';
|
|
if (v > 0 && v < LAST_GAL_TYPE) {
|
|
gal = (GALTYPE) v;
|
|
Serial.print(F("OK gal set: "));
|
|
Serial.println((short) gal, DEC);
|
|
} else {
|
|
Serial.println(F("ER unknown gal index"));
|
|
uploadError = 1;
|
|
}
|
|
} break;
|
|
|
|
//fusemap data
|
|
case 'f': {
|
|
char i = 8;
|
|
char j;
|
|
unsigned short addr = parse4dec(3);
|
|
short v;
|
|
do {
|
|
v = parse2hex(i);
|
|
if (v >= 0) {
|
|
for (j = 0; j < 8; j++) {
|
|
// if fuse bit is set -> then change the fusemap
|
|
if (v & (1 << j)) {
|
|
setFuseBit(addr);
|
|
}
|
|
addr++;
|
|
}
|
|
i += 2;
|
|
}
|
|
} while (v >= 0);
|
|
|
|
//any fuse being set is considered as uploaded fuse map
|
|
mapUploaded = 1;
|
|
|
|
Serial.print(F("OK "));
|
|
Serial.println((short) addr, DEC);
|
|
} break;
|
|
|
|
//checksum
|
|
case 'c': {
|
|
unsigned short val = parse4hex(3);
|
|
unsigned char apdFuse = (flagBits & FLAG_BIT_APD) ? 1 : 0;
|
|
unsigned short cs = checkSum(galinfo[gal].fuses + apdFuse);
|
|
if (cs == val) {
|
|
Serial.println(F("OK checksum matches"));
|
|
} else {
|
|
uploadError = 1;
|
|
Serial.print(F("ER checksum:"));
|
|
Serial.print(cs, HEX);
|
|
Serial.print(F(" expected:"));
|
|
Serial.println(val, HEX);
|
|
}
|
|
} break;
|
|
|
|
default:
|
|
uploadError = 1;
|
|
Serial.println(F("ER unknown upload cmd"));
|
|
}
|
|
|
|
lineIndex = 0;
|
|
}
|
|
// *********************************************************
|
|
|
|
|
|
// set/reset individual pins of GAL
|
|
static void setVCC(char on) {
|
|
//no control for turning the voltage on of
|
|
//it is assumed the voltage is always on
|
|
}
|
|
|
|
static void setVPP(char on) {
|
|
//programming voltage is controlled by VPP_PIN,
|
|
//but the programming voltage must be set manually by user turning a Pot
|
|
digitalWrite(PIN_VPP, on ? 1 : 0);
|
|
|
|
//Serial.print(F("VPP set to:"));
|
|
//Serial.println( on ? "12V": "5V");
|
|
delay(10);
|
|
}
|
|
|
|
|
|
|
|
static void setSTB(char on) {
|
|
digitalWrite(PIN_STROBE, on ? 1:0);
|
|
}
|
|
|
|
static void setPV(char on) {
|
|
digitalWrite(PIN_PV, on ? 1:0);
|
|
}
|
|
|
|
static void setSDIN(char on) {
|
|
digitalWrite(PIN_SDIN, on ? 1:0);
|
|
}
|
|
|
|
static void setSCLK(char on){
|
|
digitalWrite(PIN_SCLK, on ? 1:0);
|
|
}
|
|
|
|
// output row address (RA0-5)
|
|
static void setRow(char row)
|
|
{
|
|
digitalWrite(PIN_RA0, (row & 0x1));
|
|
digitalWrite(PIN_RA1, ((row & 0x2) ? 1:0));
|
|
digitalWrite(PIN_RA2, ((row & 0x4) ? 1:0));
|
|
digitalWrite(PIN_RA3, ((row & 0x8) ? 1:0));
|
|
digitalWrite(PIN_RA4, ((row & 0x10) ? 1:0));
|
|
digitalWrite(PIN_RA5, ((row & 0x20) ? 1:0));
|
|
}
|
|
|
|
// serial data out form the GAL chip -> received by Arduino
|
|
static char getSDOUT(void)
|
|
{
|
|
return digitalRead(PIN_SDOUT) != 0;
|
|
}
|
|
|
|
// GAL finish sequence
|
|
static void turnOff(void)
|
|
{
|
|
delay(100);
|
|
setPV(0); // P/V- low
|
|
setRow(0x3F);// RA0-5 high
|
|
setSDIN(1); // SDIN high
|
|
setVPP(0); // Vpp off (+12V)
|
|
setPV(1); // P/V- high
|
|
delay(2);
|
|
setVCC(0); // turn off VCC (if controlled)
|
|
|
|
setupGpios(INPUT);
|
|
delay(100); //ensure VPP is low
|
|
}
|
|
|
|
// GAL init sequence
|
|
static void turnOn(char mode) {
|
|
setupGpios(OUTPUT);
|
|
|
|
if (
|
|
mode == WRITEGAL ||
|
|
mode == ERASEGAL ||
|
|
mode == ERASEALL ||
|
|
mode == BURNSECURITY ||
|
|
mode == WRITEPES ||
|
|
mode == VPPTEST ||
|
|
mode == READPES ||
|
|
mode == READGAL
|
|
) {
|
|
mode = 1;
|
|
} else {
|
|
mode = 0;
|
|
}
|
|
|
|
// setVPP(mode);
|
|
setVPP(0); // VPP off
|
|
setPV(0); // P/V- low
|
|
setRow(0x3F); // RA0-5 high - erase sequence ?
|
|
//setRow(0); // RA0-5 low
|
|
setSDIN(1); // SDIN high
|
|
setSCLK(1); // SCLK high
|
|
setSTB(1); // STB high
|
|
setVCC(1); // turn on VCC (if controlled)
|
|
delay(100);
|
|
setSCLK(0); // SCLK low
|
|
setVPP(mode);
|
|
delay(20);
|
|
}
|
|
|
|
|
|
// clock and receive a bit in from GAL SDOUT
|
|
static char receiveBit(void)
|
|
{
|
|
char b = getSDOUT();
|
|
setSCLK(1);
|
|
setSCLK(0);
|
|
return b;
|
|
}
|
|
|
|
// read n number of bits
|
|
static void discardBits(short n)
|
|
{
|
|
while (n-- > 0) {
|
|
receiveBit();
|
|
}
|
|
}
|
|
|
|
// clock a bit and send it out to GAL SDIN
|
|
static void sendBit(char bitValue, char skipClkLow = 0)
|
|
{
|
|
setSDIN(bitValue);
|
|
setSCLK(1);
|
|
if (!skipClkLow) {
|
|
setSCLK(0);
|
|
}
|
|
}
|
|
|
|
// send n number of bits to GAL
|
|
static void sendBits(short n, char bitValue)
|
|
{
|
|
char skipClkLow = flagBits & FLAG_BIT_ATF16V8C;
|
|
while (n-- > 0) {
|
|
sendBit(bitValue, skipClkLow && n == 0);
|
|
}
|
|
}
|
|
|
|
// send row address bits to SDIN
|
|
// ATF22V10C MSb first, other 22V10 LSb first
|
|
static void sendAddress(unsigned char n, unsigned char row)
|
|
{
|
|
switch (gal) {
|
|
case ATF22V10C:
|
|
while (n-- > 1) {
|
|
sendBit(row & 32); // clock in row number bits 5-1
|
|
row <<= 1;
|
|
}
|
|
setSDIN(row & 32); // SDIN = row number bit 0
|
|
break;
|
|
default:
|
|
while (n-- > 0) {
|
|
sendBit(row & 1); // clock in row number bits 0-5
|
|
row >>= 1;
|
|
}
|
|
setSDIN(0); // SDIN = low
|
|
}
|
|
}
|
|
|
|
|
|
// pulse STB pin low for some milliseconds
|
|
static void strobe(unsigned short msec)
|
|
{
|
|
setSTB(0);
|
|
delay(msec);
|
|
setSTB(1);
|
|
}
|
|
|
|
// 16V8, 20V8 RA0-5 = row address, strobe.
|
|
// 22V10 RA0-5 = 0, send row address (6 bits), strobe.
|
|
// setBit: 0 - do not set bit, 1- set bit value 0, 2 - set bit value 1
|
|
static void strobeRow(char row, char setBit = BIT_NONE)
|
|
{
|
|
switch(gal) {
|
|
case GAL16V8:
|
|
case GAL20V8:
|
|
case ATF16V8B:
|
|
setRow(row); // set RA0-5 to row number
|
|
if (setBit) {
|
|
sendBits(1, setBit - 1);
|
|
}
|
|
strobe(2); // pulse /STB for 2ms
|
|
break;
|
|
case GAL22V10:
|
|
case ATF22V10B:
|
|
case ATF22V10C:
|
|
setRow(0); // set RA0-5 low
|
|
sendAddress(6,row); // send row number (6 bits)
|
|
setSTB(0);
|
|
setSTB(1); // pulse /STB
|
|
setSDIN(0); // SDIN low
|
|
}
|
|
}
|
|
|
|
|
|
// read PES: programmer electronic signature (ATF = text string, others = Vendor/Vpp/timing)
|
|
static void readPes(void) {
|
|
unsigned short bitmask;
|
|
short byteIndex;
|
|
|
|
#ifdef DEBUG_PES
|
|
Serial.print(F("testing gal "));
|
|
Serial.print(gal, DEC);
|
|
Serial.println();
|
|
#endif
|
|
turnOn(READPES);
|
|
|
|
strobeRow(galinfo[gal].pesrow);
|
|
|
|
if (gal == ATF16V8B) {
|
|
setPV(1); //Required for ATF16V8C
|
|
}
|
|
|
|
for(byteIndex = 0; byteIndex < galinfo[gal].pesbytes; byteIndex++) {
|
|
unsigned char value = 0;
|
|
|
|
for (bitmask = 0x1; bitmask <= 0x80; bitmask <<= 1) {
|
|
if (receiveBit()) {
|
|
value |= bitmask;
|
|
}
|
|
}
|
|
pes[byteIndex] = value;
|
|
}
|
|
|
|
turnOff();
|
|
}
|
|
|
|
|
|
static unsigned char getDuration(unsigned char index) {
|
|
switch (index) {
|
|
case 0: return 1;
|
|
case 1: return 2;
|
|
case 2: return 5;
|
|
case 3: return 10;
|
|
case 4: return 20;
|
|
case 5: return 30;
|
|
case 6: return 40;
|
|
case 7: return 50;
|
|
case 8: return 60;
|
|
case 9: return 70;
|
|
case 10: return 80;
|
|
case 11: return 90;
|
|
case 12: return 100;
|
|
case 13: return 200;
|
|
default: return 0;
|
|
}
|
|
}
|
|
|
|
void parsePes(char type) {
|
|
unsigned char algo;
|
|
|
|
if (UNKNOWN == type) {
|
|
type = gal;
|
|
}
|
|
|
|
switch (type) {
|
|
case ATF16V8B:
|
|
case ATF22V10B:
|
|
case ATF22V10C:
|
|
progtime = 20;
|
|
erasetime = 100;
|
|
vpp = 48; /* 12.0V */
|
|
break;
|
|
default:
|
|
algo = pes[1] & 0x0F;
|
|
if (algo == 5) {
|
|
erasetime = (25 << ((pes[4] >> 2) &7)) / 2;
|
|
progtime = getDuration(((((unsigned short)pes[5] << 8)| pes[4]) >> 5) & 15);
|
|
vpp = 2 * ((pes[5] >> 1) & 31) + 20;
|
|
}
|
|
else switch(gal) {
|
|
case GAL16V8:
|
|
case GAL20V8:
|
|
erasetime=100;
|
|
switch(algo) {
|
|
case 0:
|
|
vpp = 63; // 15.75V
|
|
progtime = 100;
|
|
break;
|
|
case 1:
|
|
vpp = 63; // 15.75V
|
|
progtime = 80;
|
|
break;
|
|
case 2:
|
|
vpp = 66; // 16.5V
|
|
progtime = 10;
|
|
break;
|
|
case 3:
|
|
vpp = (pes[3] == NATIONAL) ? 60 : 58; // 15.0V or 14.5V
|
|
progtime = 40;
|
|
break;
|
|
case 4:
|
|
vpp = 56; // 14V
|
|
progtime = 100;
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
erasetime = (pes[3] == NATIONAL) ? 50 : 100;
|
|
switch(algo) {
|
|
case 0:
|
|
vpp = 66; // 16.5V
|
|
progtime = 10;
|
|
break;
|
|
case 1:
|
|
vpp = 63; // 15.75V
|
|
progtime = 100;
|
|
break;
|
|
case 2:
|
|
vpp = (pes[3] == NATIONAL) ? 60 : 58; // 15.0V or 14.5V
|
|
progtime = 40;
|
|
break;
|
|
case 3:
|
|
vpp = 56; // 14V
|
|
progtime = 100;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Afterburnes seems to work with programming voltages reduced by 2V
|
|
vpp -= 8; // -2V
|
|
}
|
|
|
|
static void setGalDefaults(void) {
|
|
if (gal == ATF16V8B || gal == ATF22V10B || gal == ATF22V10C) {
|
|
progtime = 20;
|
|
erasetime = 100;
|
|
vpp = 40; /* 10V */
|
|
} else {
|
|
progtime = 80;
|
|
erasetime = 80;
|
|
vpp = 44; /* 11V */
|
|
}
|
|
}
|
|
|
|
// print PES information
|
|
void printPes(char type) {
|
|
|
|
Serial.print(F("PES info: "));
|
|
//voltage
|
|
if (pes[3] == ATMEL16 || pes[3] == ATMEL22) {
|
|
//Serial.print(" ");
|
|
} else {
|
|
if (pes[1] & 0x10) {
|
|
Serial.print(F("3.3V "));
|
|
} else {
|
|
Serial.print(F("5V "));
|
|
}
|
|
}
|
|
|
|
//manufacturer
|
|
switch (pes[3]) {
|
|
case LATTICE: Serial.print(F("Lattice ")); break;
|
|
case NATIONAL: Serial.print(F("National ")); break;
|
|
case SGSTHOMSON: Serial.print(F("ST Microsystems ")); break;
|
|
case ATMEL16:
|
|
case ATMEL22: Serial.print(F("Atmel ")); break;
|
|
default: Serial.print(F("Unknown GAL, "));
|
|
}
|
|
|
|
// GAL type
|
|
switch (type) {
|
|
case GAL16V8: Serial.print(F("GAL16V8 ")); break;
|
|
case GAL20V8: Serial.print(F("GAL20V8 ")); break;
|
|
case GAL22V10: Serial.print(F("GAL20V10 ")); break;
|
|
case ATF16V8B: Serial.print(0 == (flagBits & FLAG_BIT_ATF16V8C) ? F("ATF16V8B "): F("ATF16V8C ")); break;
|
|
case ATF22V10B: Serial.print(F("ATF22V10B ")); break;
|
|
case ATF22V10C: Serial.print(F("ATF22V10C ")); break;
|
|
}
|
|
|
|
//programming info
|
|
if (UNKNOWN != type) {
|
|
Serial.print(F(" VPP="));
|
|
Serial.print(vpp >> 2, DEC);
|
|
Serial.print(F("."));
|
|
Serial.print((vpp & 3) * 25, DEC);
|
|
Serial.print(F(" Timing: prog="));
|
|
Serial.print(progtime, DEC);
|
|
Serial.print(F(" erase="));
|
|
Serial.print(erasetime / 4, DEC);
|
|
} else {
|
|
Serial.print(F(" try VPP=10..14 in 1V steps"));
|
|
}
|
|
|
|
Serial.println();
|
|
}
|
|
|
|
// sets a fuse bit on particular position
|
|
// expects that the fusemap was cleared (set to zero) beforehand
|
|
static void setFuseBit(unsigned short bitPos) {
|
|
fusemap[bitPos >> 3] |= (1 << (bitPos & 7));
|
|
}
|
|
|
|
// gets a fuse bit from specific fuse position
|
|
static char getFuseBit(unsigned short bitPos) {
|
|
return (fusemap[bitPos >> 3] & (1 << (bitPos & 7))) ? 1 : 0;
|
|
}
|
|
|
|
// generic fuse-map reading, fuse-map bits are stored in fusemap array
|
|
static void readGalFuseMap(const unsigned char* cfgArray, char useDelay, char doDiscardBits) {
|
|
unsigned short cfgAddr = galinfo[gal].cfgbase;
|
|
unsigned short row, bit;
|
|
unsigned short addr;
|
|
|
|
if (flagBits & FLAG_BIT_ATF16V8C) {
|
|
setPV(0);
|
|
}
|
|
|
|
// read fuse rows
|
|
for(row = 0; row < galinfo[gal].rows; row++) {
|
|
strobeRow(row); //set address of the row
|
|
if (flagBits & FLAG_BIT_ATF16V8C) {
|
|
setSDIN(0);
|
|
setPV(1);
|
|
}
|
|
for(bit = 0; bit < galinfo[gal].bits; bit++) {
|
|
// check the received bit is 1 and if so then set the fuse map
|
|
if (receiveBit()) {
|
|
addr = galinfo[gal].rows;
|
|
addr *= bit;
|
|
addr += row;
|
|
setFuseBit(addr);
|
|
}
|
|
}
|
|
if (useDelay) {
|
|
delay(useDelay);
|
|
}
|
|
if (flagBits & FLAG_BIT_ATF16V8C) {
|
|
setPV(0);
|
|
}
|
|
}
|
|
|
|
// read UES
|
|
strobeRow(galinfo[gal].uesrow);
|
|
if (flagBits & FLAG_BIT_ATF16V8C) {
|
|
setSDIN(0);
|
|
setPV(1);
|
|
}
|
|
|
|
if (doDiscardBits) {
|
|
discardBits(doDiscardBits);
|
|
}
|
|
for(bit = 0; bit < 64; bit++) {
|
|
if (receiveBit()) {
|
|
addr = galinfo[gal].uesfuse;
|
|
addr += bit;
|
|
setFuseBit(addr);
|
|
}
|
|
}
|
|
if (useDelay) {
|
|
delay(useDelay);
|
|
}
|
|
if (flagBits & FLAG_BIT_ATF16V8C) {
|
|
setPV(0);
|
|
}
|
|
|
|
// read CFG
|
|
if (galinfo[gal].cfgmethod == CFG_STROBE_ROW) {
|
|
strobeRow(galinfo[gal].cfgrow);
|
|
if (flagBits & FLAG_BIT_ATF16V8C) {
|
|
setSDIN(0);
|
|
setPV(1);
|
|
}
|
|
} else {
|
|
setRow(galinfo[gal].cfgrow);
|
|
strobe(1);
|
|
}
|
|
for(bit = 0; bit < galinfo[gal].cfgbits; bit++) {
|
|
if (receiveBit()) {
|
|
setFuseBit(cfgAddr + cfgArray[bit]);
|
|
}
|
|
}
|
|
|
|
//check APD fuse bit - only for ATF16V8C or ATF22V10C
|
|
if ((flagBits & FLAG_BIT_ATF16V8C) || gal == ATF22V10C) {
|
|
setPV(0);
|
|
if (gal == ATF22V10C) {
|
|
setRow(0);
|
|
sendAddress(6, CFG_ROW_APD);
|
|
strobe(1);
|
|
} else { //ATF16V8C
|
|
setRow(CFG_ROW_APD);
|
|
strobe(1);
|
|
setPV(1);
|
|
}
|
|
setFlagBit(FLAG_BIT_APD, receiveBit());
|
|
}
|
|
}
|
|
|
|
// generic fuse-map verification, fuse map bits are compared against read bits
|
|
static unsigned short verifyGalFuseMap(const unsigned char* cfgArray, char useDelay, char doDiscardBits) {
|
|
unsigned short cfgAddr = galinfo[gal].cfgbase;
|
|
unsigned short row, bit;
|
|
unsigned short addr;
|
|
char fuseBit; // fuse bit received from GAL
|
|
char mapBit; // fuse bit stored in RAM
|
|
unsigned short errors = 0;
|
|
|
|
if (flagBits & FLAG_BIT_ATF16V8C) {
|
|
setPV(0);
|
|
}
|
|
|
|
// read fuse rows
|
|
for(row = 0; row < galinfo[gal].rows; row++) {
|
|
strobeRow(row);
|
|
if (flagBits & FLAG_BIT_ATF16V8C) {
|
|
setSDIN(0);
|
|
setPV(1);
|
|
}
|
|
for(bit = 0; bit < galinfo[gal].bits; bit++) {
|
|
addr = galinfo[gal].rows;
|
|
addr *= bit;
|
|
addr += row;
|
|
mapBit = getFuseBit(addr);
|
|
fuseBit = receiveBit();
|
|
if (mapBit != fuseBit) {
|
|
#ifdef DEBUG_VERIFY
|
|
Serial.print(F("f a="));
|
|
Serial.println((row * galinfo[gal].bits) + bit, DEC);
|
|
#endif
|
|
errors++;
|
|
}
|
|
}
|
|
if (useDelay) {
|
|
delay(useDelay);
|
|
}
|
|
if (flagBits & FLAG_BIT_ATF16V8C) {
|
|
setPV(0);
|
|
}
|
|
}
|
|
|
|
// read UES
|
|
strobeRow(galinfo[gal].uesrow);
|
|
if (flagBits & FLAG_BIT_ATF16V8C) {
|
|
setSDIN(0);
|
|
setPV(1);
|
|
}
|
|
if (doDiscardBits) {
|
|
discardBits(doDiscardBits);
|
|
}
|
|
for(bit = 0; bit < 64; bit++) {
|
|
addr = galinfo[gal].uesfuse;
|
|
addr += bit;
|
|
mapBit = getFuseBit(addr);
|
|
fuseBit = receiveBit();
|
|
if (mapBit != fuseBit) {
|
|
#ifdef DEBUG_VERIFY
|
|
Serial.print(F("U a="));
|
|
Serial.println(bit, DEC);
|
|
#endif
|
|
errors++;
|
|
}
|
|
}
|
|
if (useDelay) {
|
|
delay(useDelay);
|
|
}
|
|
if (flagBits & FLAG_BIT_ATF16V8C) {
|
|
setPV(0);
|
|
}
|
|
// read CFG
|
|
if (galinfo[gal].cfgmethod == CFG_STROBE_ROW) {
|
|
strobeRow(galinfo[gal].cfgrow);
|
|
if (flagBits & FLAG_BIT_ATF16V8C) {
|
|
setSDIN(0);
|
|
setPV(1);
|
|
}
|
|
} else {
|
|
setRow(galinfo[gal].cfgrow);
|
|
strobe(1);
|
|
}
|
|
for(bit = 0; bit < galinfo[gal].cfgbits; bit++) {
|
|
mapBit = getFuseBit(cfgAddr + cfgArray[bit]);
|
|
fuseBit = receiveBit();
|
|
if (mapBit != fuseBit) {
|
|
#ifdef DEBUG_VERIFY
|
|
Serial.print(F("C a="));
|
|
Serial.println(bit, DEC);
|
|
#endif
|
|
errors++;
|
|
}
|
|
}
|
|
|
|
//verify PD fuse on Atmel's C GALs
|
|
if ((flagBits & FLAG_BIT_ATF16V8C) || gal == ATF22V10C) {
|
|
setPV(0);
|
|
if (gal == ATF22V10C) {
|
|
setRow(0);
|
|
sendAddress(6, CFG_ROW_APD);
|
|
strobe(1);
|
|
} else { //ATF16V8C
|
|
setRow(CFG_ROW_APD);
|
|
strobe(1);
|
|
setPV(1);
|
|
}
|
|
|
|
mapBit = (flagBits & FLAG_BIT_APD)? 1 : 0;
|
|
fuseBit = receiveBit();
|
|
if (mapBit != fuseBit) {
|
|
#ifdef DEBUG_VERIFY
|
|
Serial.println(F("C pd"));
|
|
#endif
|
|
errors++;
|
|
}
|
|
}
|
|
|
|
return errors;
|
|
}
|
|
|
|
|
|
// main fuse-map reading and verification function
|
|
// READING: reads fuse rows, UES, CFG from GAL and stores into fusemap bit array RAM.
|
|
// VERIFY: reads fuse rows, UES, CFG from GAL and compares with fusemap bit array in RAM.
|
|
static void readOrVerifyGal(char verify)
|
|
{
|
|
unsigned short i;
|
|
unsigned char* cfgArray = (unsigned char*) cfgV8;
|
|
|
|
//ensure fusemap is cleared before READ operation, keep it for VERIFY operation.
|
|
if (!verify) {
|
|
for (i = 0; i < MAXFUSES; i++) {
|
|
fusemap[i] = 0;
|
|
}
|
|
}
|
|
|
|
turnOn(READGAL);
|
|
|
|
switch(gal)
|
|
{
|
|
case GAL16V8:
|
|
case GAL20V8:
|
|
if (pes[2] == 0x1A || pes[2] == 0x3A) {
|
|
cfgArray = (unsigned char*) cfgV8AB;
|
|
}
|
|
//read without delay, no discard
|
|
if (verify) {
|
|
i = verifyGalFuseMap(cfgArray, 0, 0);
|
|
} else {
|
|
readGalFuseMap(cfgArray, 0, 0);
|
|
}
|
|
break;
|
|
|
|
case ATF16V8B:
|
|
//read without delay, no discard
|
|
if (verify) {
|
|
i = verifyGalFuseMap(cfgV8AB, 0, 0);
|
|
} else {
|
|
readGalFuseMap(cfgV8AB, 0, 0);
|
|
}
|
|
break;
|
|
|
|
case GAL22V10:
|
|
case ATF22V10B:
|
|
case ATF22V10C:
|
|
//read with delay 1 ms, discard 68 cfg bits on ATFxx
|
|
if (verify) {
|
|
i = verifyGalFuseMap(cfgV10, 1, (gal == GAL22V10) ? 0 : 68);
|
|
} else {
|
|
readGalFuseMap(cfgV10, 1, (gal == GAL22V10) ? 0 : 68);
|
|
}
|
|
break;
|
|
}
|
|
turnOff();
|
|
|
|
if (verify && i > 0) {
|
|
Serial.print(F("ER verify failed. Bit errors: "));
|
|
Serial.println(i, DEC);
|
|
}
|
|
}
|
|
|
|
// fuse-map writing function for V8 GAL chips
|
|
static void writeGalFuseMapV8(const unsigned char* cfgArray) {
|
|
unsigned short cfgAddr = galinfo[gal].cfgbase;
|
|
unsigned char row, rbit;
|
|
unsigned short addr;
|
|
unsigned char rbitMax = galinfo[gal].bits;
|
|
const unsigned char skipLastClk = (flagBits & FLAG_BIT_ATF16V8C) ? 1 : 0;
|
|
|
|
setPV(1);
|
|
// write fuse rows
|
|
for (row = 0; row < galinfo[gal].rows; row++) {
|
|
setRow(row);
|
|
for(rbit = 0; rbit < rbitMax; rbit++) {
|
|
addr = galinfo[gal].rows;
|
|
addr *= rbit;
|
|
addr += row;
|
|
sendBit(getFuseBit(addr), rbit == rbitMax - 1 ? skipLastClk : 0);
|
|
}
|
|
strobe(progtime);
|
|
}
|
|
|
|
// write UES
|
|
setRow(galinfo[gal].uesrow);
|
|
for (rbit = 0; rbit < 64; rbit++) {
|
|
addr = galinfo[gal].uesfuse;
|
|
addr += rbit;
|
|
sendBit(getFuseBit(addr), rbit == 63 ? skipLastClk : 0);
|
|
}
|
|
strobe(progtime);
|
|
|
|
// write CFG (all ICs use setRow)
|
|
rbitMax = galinfo[gal].cfgbits;
|
|
setRow(galinfo[gal].cfgrow);
|
|
for(rbit = 0; rbit < rbitMax; rbit++) {
|
|
sendBit(getFuseBit(cfgAddr + cfgArray[rbit]), rbit == rbitMax - 1 ? skipLastClk : 0);
|
|
}
|
|
strobe(progtime);
|
|
setPV(0);
|
|
|
|
// disable power-down if the APD flag is not set (only for ATF16V8C)
|
|
if (skipLastClk && (flagBits & FLAG_BIT_APD) == 0) {
|
|
setPV(1);
|
|
strobeRow(CFG_ROW_APD, BIT_ZERO); // strobe row and send one bit with value 0
|
|
setPV(0);
|
|
}
|
|
}
|
|
|
|
// fuse-map writing function for V10 GAL chips
|
|
static void writeGalFuseMapV10(const unsigned char* cfgArray, char fillUesStart, char useSdin) {
|
|
unsigned short cfgAddr = galinfo[gal].cfgbase;
|
|
unsigned char row, bit;
|
|
unsigned short addr;
|
|
|
|
setRow(0); //RA0-5 low
|
|
// write fuse rows
|
|
for (row = 0; row < galinfo[gal].rows; row++) {
|
|
for (bit = 0; bit < galinfo[gal].bits; bit++) {
|
|
addr = galinfo[gal].rows;
|
|
addr *= bit;
|
|
addr += row;
|
|
sendBit(getFuseBit(addr));
|
|
}
|
|
sendAddress(6, row);
|
|
setPV(1);
|
|
strobe(progtime);
|
|
setPV(0);
|
|
}
|
|
|
|
// write UES
|
|
if (fillUesStart) {
|
|
sendBits(68, 1);
|
|
}
|
|
for (bit = 0; bit < 64; bit++) {
|
|
addr = galinfo[gal].uesfuse;
|
|
addr += bit;
|
|
sendBit(getFuseBit(addr));
|
|
}
|
|
if (!fillUesStart) {
|
|
sendBits(68, 1);
|
|
}
|
|
sendAddress(6, galinfo[gal].uesrow);
|
|
setPV(1);
|
|
strobe(progtime);
|
|
setPV(0);
|
|
|
|
// write CFG
|
|
setRow(galinfo[gal].cfgrow);
|
|
for(bit = 0; bit < galinfo[gal].cfgbits - useSdin; bit++) {
|
|
sendBit(getFuseBit(cfgAddr + cfgArray[bit]));
|
|
}
|
|
if (useSdin) {
|
|
setSDIN(getFuseBit(cfgAddr + cfgArray[19]));
|
|
}
|
|
setPV(1);
|
|
strobe(progtime);
|
|
setPV(0);
|
|
|
|
if (useSdin && (flagBits & FLAG_BIT_APD) == 0) {
|
|
// disable power-down feature (JEDEC bit #5892)
|
|
setRow(0);
|
|
sendAddress(6, CFG_ROW_APD);
|
|
setPV(1);
|
|
strobe(progtime);
|
|
setPV(0);
|
|
}
|
|
}
|
|
|
|
// main fuse-map writing function
|
|
static void writeGal()
|
|
{
|
|
unsigned short i;
|
|
unsigned char* cfgArray = (unsigned char*) cfgV8;
|
|
|
|
|
|
turnOn(WRITEGAL);
|
|
|
|
switch(gal)
|
|
{
|
|
case GAL16V8:
|
|
case GAL20V8:
|
|
if (pes[2] == 0x1A || pes[2] == 0x3A) {
|
|
cfgArray = (unsigned char*) cfgV8AB;
|
|
}
|
|
writeGalFuseMapV8(cfgArray);
|
|
break;
|
|
|
|
case ATF16V8B:
|
|
writeGalFuseMapV8(cfgV8AB);
|
|
break;
|
|
|
|
case GAL22V10:
|
|
case ATF22V10B:
|
|
case ATF22V10C:
|
|
writeGalFuseMapV10(cfgV10, (gal == GAL22V10) ? 0 : 1, (gal == ATF22V10C) ? 1 : 0);
|
|
break;
|
|
}
|
|
turnOff();
|
|
}
|
|
|
|
// erases fuse-map in the GAL
|
|
static void eraseGAL(void)
|
|
{
|
|
turnOn(ERASEGAL);
|
|
|
|
setPV(1);
|
|
setRow(galinfo[gal].eraserow);
|
|
if (gal == GAL16V8 || gal == ATF16V8B || gal==GAL20V8) {
|
|
sendBit(1);
|
|
}
|
|
strobe(erasetime);
|
|
setPV(0);
|
|
turnOff();
|
|
}
|
|
|
|
// sets security bit - disables fuse reading
|
|
static void secureGAL(void)
|
|
{
|
|
turnOn(WRITEGAL);
|
|
|
|
setPV(1);
|
|
strobeRow(61, BIT_ONE); // strobe row and send one bit with value 1
|
|
|
|
setPV(0);
|
|
turnOff();
|
|
}
|
|
|
|
static char checkGalTypeViaPes(void)
|
|
{
|
|
char type = UNKNOWN;
|
|
|
|
#ifdef DEBUG_PES
|
|
char i;
|
|
Serial.println(F("PES raw bytes:"));
|
|
for (i = 0; i < 10; i++) {
|
|
printFormatedNumberHex2(pes[i]);
|
|
Serial.print(F(" "));
|
|
}
|
|
Serial.println();
|
|
#endif
|
|
setFlagBit(FLAG_BIT_ATF16V8C, 0);
|
|
|
|
if (pes[7] == 'F' && pes[6]== '2' && pes[5]== '2' && (pes[4]== 'V' || pes[4]=='L') && pes[3]== '1' && pes[2]=='0') {
|
|
if (pes[1] == 'B') {
|
|
type = ATF22V10B;
|
|
} else {
|
|
type = ATF22V10C;
|
|
}
|
|
}
|
|
else if (pes[6] == 'F' && pes[5] == '1' && pes[4]== '6' && pes[3] == 'V' && pes[2]=='8') {
|
|
type = ATF16V8B;
|
|
if (pes[1] == 'C') { // ATF16V8C
|
|
setFlagBit(FLAG_BIT_ATF16V8C, 1);
|
|
}
|
|
}
|
|
else if (pes[2] != 0x00 && pes[2] != 0xFF) {
|
|
for (type = (sizeof(galinfo) / sizeof(galinfo[0])) - 1; type; type--) {
|
|
if (pes[2] == galinfo[type].id0 || pes[2] == galinfo[type].id1) break;
|
|
}
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
// checks whether gal type corresponds to PES information on the IC
|
|
// note: PES must be read beforehand
|
|
static char testProperGAL(void)
|
|
{
|
|
char type = checkGalTypeViaPes();
|
|
|
|
if (type == 0) {
|
|
//Unknown or illegal PES,
|
|
goto error;
|
|
}
|
|
else if (type != gal) {
|
|
//PES indicates a different GAL type than selected. Change to detected GAL type?
|
|
goto error;
|
|
}
|
|
|
|
return 1;
|
|
|
|
error:
|
|
Serial.println(F("ER unknown or wrong GAL type (check Power ON)"));
|
|
return 0;
|
|
}
|
|
|
|
// prints a hexadecimal number - 2 digits with a leading zero
|
|
static void printFormatedNumberHex2(unsigned char num) {
|
|
if (num < 16) {
|
|
Serial.print(F("0"));
|
|
}
|
|
Serial.print(num, HEX);
|
|
}
|
|
|
|
// prints a hexadecimal number - 4 digits with a leading zero
|
|
static void printFormatedNumberHex4(unsigned short num) {
|
|
if (num < 0x10) {
|
|
Serial.print(F("000"));
|
|
} else
|
|
if (num < 0x100) {
|
|
Serial.print(F("00"));
|
|
} else
|
|
if (num < 0x1000) {
|
|
Serial.print(F("0"));
|
|
}
|
|
Serial.print(num, HEX);
|
|
}
|
|
|
|
// prints a decimal number - 4 digits with a leading zero
|
|
static void printFormatedNumberDec4(unsigned short num) {
|
|
if (num < 1) {
|
|
Serial.print(F("0000"));
|
|
return;
|
|
}
|
|
|
|
if (num < 10) {
|
|
Serial.print(F("000"));
|
|
} else
|
|
if (num < 100) {
|
|
Serial.print(F("00"));
|
|
} else
|
|
if (num < 1000) {
|
|
Serial.print(F("0"));
|
|
}
|
|
Serial.print(num, DEC);
|
|
}
|
|
|
|
// adds a formated decimal number with a leading zero to a line buffer at position 'i'
|
|
static unsigned char addFormatedNumberDec4(unsigned short num, unsigned char i) {
|
|
char cnt = 3;
|
|
|
|
while (cnt >= 0) {
|
|
line[i + cnt] = '0' + (num % 10);
|
|
num /= 10;
|
|
cnt--;
|
|
}
|
|
return i + 4;
|
|
}
|
|
|
|
// calculates fuse-map checksum and returns it
|
|
static unsigned short checkSum(unsigned short n)
|
|
{
|
|
unsigned short c, e, i;
|
|
unsigned long a;
|
|
|
|
c = e= 0;
|
|
a = 0;
|
|
for (i = 0; i < n; i++) {
|
|
e++;
|
|
if (e == 9) {
|
|
e = 1;
|
|
a += c;
|
|
c = 0;
|
|
}
|
|
c >>= 1;
|
|
if (getFuseBit(i)) {
|
|
c += 0x80;
|
|
}
|
|
}
|
|
return (unsigned short)((c >> (8 - e)) + a);
|
|
}
|
|
|
|
static void printGalName() {
|
|
switch (gal) {
|
|
case GAL16V8: Serial.println(F("GAL16V8")); break;
|
|
case GAL20V8: Serial.println(F("GAL20V8")); break;
|
|
case GAL22V10: Serial.println(F("GAL22V10")); break;
|
|
case ATF16V8B:
|
|
if (flagBits & FLAG_BIT_ATF16V8C) {
|
|
Serial.println(F("ATF16V8C"));
|
|
} else {
|
|
Serial.println(F("ATF16V8B"));
|
|
}
|
|
break;
|
|
case ATF22V10B: Serial.println(F("ATF22V10B")); break;
|
|
case ATF22V10C: Serial.println(F("ATF22V10C")); break;
|
|
default: Serial.println(F("GAL")); break;
|
|
}
|
|
}
|
|
|
|
// prints the contents of fuse-map array in the form of JEDEC text file
|
|
static void printJedec()
|
|
{
|
|
unsigned short i, j, k, n;
|
|
unsigned char unused, start;
|
|
uint8_t apdFuse = (flagBits & FLAG_BIT_APD) ? 1 : 0;
|
|
|
|
Serial.print(F("JEDEC file for "));
|
|
printGalName();
|
|
Serial.print(F("*QP")); Serial.print(galinfo[gal].pins, DEC);
|
|
Serial.print(F("*QF")); Serial.print(galinfo[gal].fuses + apdFuse, DEC);
|
|
Serial.println(F("*QV0*F0*G0*X0*"));
|
|
|
|
for( i = k = 0; i < galinfo[gal].bits; i++) {
|
|
unused = 1;
|
|
n = 0;
|
|
line[n++] = 'L';
|
|
n = addFormatedNumberDec4(k, n);
|
|
line[n++] = ' ';
|
|
for(j= 0; j < galinfo[gal].rows; j++, k++) {
|
|
if (getFuseBit(k)) {
|
|
unused = 0;
|
|
line[n++] = '1';
|
|
} else {
|
|
line[n++] = '0';
|
|
}
|
|
}
|
|
line[n++] = '*';
|
|
line[n++] = 0;
|
|
if (!unused) {
|
|
Serial.println(line);
|
|
}
|
|
}
|
|
|
|
if( k < galinfo[gal].uesfuse) {
|
|
unused = 1;
|
|
n = 0;
|
|
line[n++] = 'L';
|
|
n = addFormatedNumberDec4(k, n);
|
|
line[n++] = ' ';
|
|
|
|
while(k < galinfo[gal].uesfuse) {
|
|
if (getFuseBit(k)) {
|
|
unused = 0;
|
|
line[n++] = '1';
|
|
} else {
|
|
line[n++] = '0';
|
|
}
|
|
k++;
|
|
}
|
|
line[n++] = '*';
|
|
line[n++] = 0;
|
|
if (!unused) {
|
|
Serial.println(line);
|
|
}
|
|
}
|
|
line[0] = 0;
|
|
|
|
|
|
// UES in byte form
|
|
Serial.print(F("N UES"));
|
|
for (j = 0;j < galinfo[gal].uesbytes; j++) {
|
|
n = 0;
|
|
for (i = 0; i < 8; i++) {
|
|
if (getFuseBit(k + 8 * j + i)) {
|
|
if (gal == ATF22V10C) {
|
|
n |= 1 << (7 - i); // big-endian
|
|
}
|
|
else {
|
|
n |= 1 << i; // little-endian
|
|
}
|
|
}
|
|
}
|
|
Serial.print(F(" "));
|
|
printFormatedNumberHex2(n);
|
|
}
|
|
Serial.println(F("*"));
|
|
|
|
// UES in bit form
|
|
Serial.print(F("L"));
|
|
printFormatedNumberDec4(k);
|
|
Serial.print(F(" "));
|
|
|
|
for(j = 0; j < 8 * galinfo[gal].uesbytes; j++) {
|
|
if (getFuseBit(k++)) {
|
|
Serial.print(F("1"));
|
|
} else {
|
|
Serial.print(F("0"));
|
|
}
|
|
}
|
|
Serial.println(F("*"));
|
|
|
|
// CFG bits
|
|
if (k < galinfo[gal].fuses) {
|
|
Serial.print(F("L"));
|
|
printFormatedNumberDec4(k);
|
|
Serial.print(F(" "));
|
|
|
|
while( k < galinfo[gal].fuses) {
|
|
if (getFuseBit(k++)) {
|
|
Serial.print(F("1"));
|
|
} else {
|
|
Serial.print(F("0"));
|
|
}
|
|
}
|
|
//ATF16V8C
|
|
if (apdFuse) {
|
|
Serial.print(F("1"));
|
|
setFuseBit(k); // set for correct check-sum calculation
|
|
}
|
|
Serial.println(F("*"));
|
|
} else if (apdFuse) { //ATF22V10C
|
|
Serial.print(F("L"));
|
|
printFormatedNumberDec4(k);
|
|
Serial.println(F(" 1*"));
|
|
setFuseBit(k); // set for correct check-sum calculation
|
|
}
|
|
|
|
Serial.print(F("N PES"));
|
|
for(i = 0; i < galinfo[gal].pesbytes; i++) {
|
|
Serial.print(F(" "));
|
|
printFormatedNumberHex2(pes[i]);
|
|
}
|
|
Serial.println(F("*"));
|
|
Serial.print(F("C"));
|
|
printFormatedNumberHex4(checkSum(galinfo[gal].fuses + apdFuse));
|
|
Serial.println();
|
|
Serial.println(F("*"));
|
|
}
|
|
|
|
|
|
// helper print function to save RAM space
|
|
static void printNoFusesError() {
|
|
Serial.println(F("ER fuse map not uploaded"));
|
|
}
|
|
|
|
static void testVoltage(int seconds) {
|
|
int i;
|
|
|
|
pinMode(PIN_VPP, OUTPUT);
|
|
setVPP(1);
|
|
for (i = 0 ; i < seconds; i++) {
|
|
delay(1000);
|
|
}
|
|
setVPP(0);
|
|
pinMode(PIN_VPP, INPUT);
|
|
}
|
|
|
|
|
|
// returns 1 if type check if OK, 0 if gal type does not match the type read from PES
|
|
static char doTypeCheck(void) {
|
|
|
|
if (0 == flagBits & FLAG_BIT_TYPE_CHECK) {
|
|
return 1; // no need to do type check
|
|
}
|
|
readPes();
|
|
parsePes(UNKNOWN);
|
|
return testProperGAL();
|
|
}
|
|
|
|
// Arduino main loop
|
|
void loop() {
|
|
|
|
|
|
// read a command from serial terminal or COMMAND_NONE if nothing is received from serial
|
|
char command = handleTerminalCommands();
|
|
|
|
// any unexpected input when uploading fuse map terminates the upload process
|
|
if (isUploading && command != COMMAND_UTX && command != COMMAND_NONE) {
|
|
Serial.println(F("ER upload aborted"));
|
|
isUploading = 0;
|
|
lineIndex = 0;
|
|
}
|
|
|
|
// handle commands received from the serial terminal
|
|
switch (command) {
|
|
|
|
// print some help
|
|
case COMMAND_HELP: {
|
|
printHelp(1);
|
|
} break;
|
|
|
|
case COMMAND_IDENTIFY_PROGRAMMER : {
|
|
printHelp(0);
|
|
} break;
|
|
|
|
// verify fuse-map bits and bits read from the GAL chip
|
|
case COMMAND_VERIFY_FUSES: {
|
|
if (mapUploaded) {
|
|
if (doTypeCheck()) {
|
|
readOrVerifyGal(1); //just verify, do not overwrite fusemap
|
|
}
|
|
} else {
|
|
printNoFusesError();
|
|
}
|
|
} break;
|
|
|
|
// handle upload command - start the download of fuse-map
|
|
case COMMAND_UPLOAD: {
|
|
short i;
|
|
// clean fuses
|
|
for (i = 0; i < MAXFUSES; i++) {
|
|
fusemap[i] = 0;
|
|
}
|
|
isUploading = 1;
|
|
uploadError = 0;
|
|
} break;
|
|
|
|
// command of the upload protocol
|
|
case COMMAND_UTX : {
|
|
parseUploadLine();
|
|
} break;
|
|
|
|
// read and print the PES
|
|
case COMMAND_READ_PES : {
|
|
char type;
|
|
readPes();
|
|
type = checkGalTypeViaPes();
|
|
parsePes(type);
|
|
printPes(type);
|
|
} break;
|
|
|
|
// read fuse-map from the GAL and print it in the JEDEC form
|
|
case COMMAND_READ_FUSES : {
|
|
if (doTypeCheck()) {
|
|
readOrVerifyGal(0); //just read, no verification
|
|
printJedec();
|
|
}
|
|
} break;
|
|
|
|
// write current fuse-map to the GAL chip
|
|
case COMMAND_WRITE_FUSES : {
|
|
if (mapUploaded) {
|
|
if (doTypeCheck()) {
|
|
writeGal();
|
|
//TODO security
|
|
}
|
|
} else {
|
|
printNoFusesError();
|
|
}
|
|
} break;
|
|
|
|
// erases the fuse-map on the GAL chip
|
|
case COMMAND_ERASE_GAL: {
|
|
if (doTypeCheck()) {
|
|
eraseGAL();
|
|
}
|
|
} break;
|
|
|
|
// sets the security bit
|
|
case COMMAND_ENABLE_SECURITY: {
|
|
if (doTypeCheck()) {
|
|
secureGAL();
|
|
}
|
|
} break;
|
|
|
|
// keep atmel power-down feature enabled during write
|
|
case COMMAND_ENABLE_APD: {
|
|
setFlagBit(FLAG_BIT_APD, 1);
|
|
Serial.println(F("OK APD set"));
|
|
} break;
|
|
|
|
case COMMAND_DISABLE_APD: {
|
|
setFlagBit(FLAG_BIT_APD, 0);
|
|
Serial.println(F("OK APD cleared"));
|
|
} break;
|
|
|
|
// toggles terminal echo
|
|
case COMMAND_ECHO : {
|
|
echoEnabled = 1 - echoEnabled;
|
|
} break;
|
|
|
|
case COMMAND_TEST_VOLTAGE : {
|
|
testVoltage(20);
|
|
} break;
|
|
|
|
case COMMAND_SET_GAL_TYPE : {
|
|
char type = line[1] - '0';
|
|
if (type >= 1 && type < LAST_GAL_TYPE) {
|
|
gal = (GALTYPE) type;
|
|
if (0 == flagBits & FLAG_BIT_TYPE_CHECK) { //no type check requested
|
|
setGalDefaults();
|
|
}
|
|
} else {
|
|
Serial.println(F("ER Unknown gal type"));
|
|
}
|
|
} break;
|
|
case COMMAND_ENABLE_CHECK_TYPE: {
|
|
setFlagBit(FLAG_BIT_TYPE_CHECK, 1);
|
|
} break;
|
|
case COMMAND_DISABLE_CHECK_TYPE: {
|
|
setFlagBit(FLAG_BIT_TYPE_CHECK, 0);
|
|
} break;
|
|
default: {
|
|
if (command != COMMAND_NONE) {
|
|
Serial.print(F("ER Unknown command: "));
|
|
Serial.println(line);
|
|
}
|
|
}
|
|
}
|
|
|
|
// display prompt character - important for the PC program to check that Arduino
|
|
// finished the desired operation
|
|
if (command != COMMAND_NONE) {
|
|
Serial.println(F(">"));
|
|
}
|
|
|
|
// and that's it!
|
|
}
|