// Write the standard firmware into the FX2's external EEPROM
DLLEXPORT(FLStatus) flFlashStandardFirmware(
struct FLContext *handle, const char *newVidPid, const char **error)
{
FLStatus flStatus, retVal = FL_SUCCESS;
struct Buffer i2cBuf = {0,};
BufferStatus bStatus;
FX2Status fxStatus;
uint16 newVid, newPid, newDid;
CHECK_STATUS(
!usbValidateVidPid(newVidPid), FL_USB_ERR, cleanup,
"flFlashStandardFirmware(): The supplied new VID:PID \"%s\" is invalid; it should look like 1D50:602B or 1D50:602B:0001",
newVidPid);
newVid = (uint16)strtoul(newVidPid, NULL, 16);
newPid = (uint16)strtoul(newVidPid+5, NULL, 16);
newDid = (uint16)((strlen(newVidPid) == 14) ? strtoul(newVidPid+10, NULL, 16) : 0x0000);
bStatus = bufInitialise(&i2cBuf, 0x4000, 0x00, error);
CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "flFlashStandardFirmware()");
flStatus = copyFirmwareAndRewriteIDs(
&eepromNoBootFirmware, newVid, newPid, newDid,
&i2cBuf, error);
CHECK_STATUS(flStatus, flStatus, cleanup, "flFlashStandardFirmware()");
fxStatus = fx2WriteEEPROM(handle->device, i2cBuf.data, (uint32)i2cBuf.length, error);
CHECK_STATUS(fxStatus, FL_FX2_ERR, cleanup, "flFlashStandardFirmware()");
cleanup:
bufDestroy(&i2cBuf);
return retVal;
}
// Load custom firmware (.hex) into the FX2's RAM
DLLEXPORT(FLStatus) flLoadCustomFirmware(
const char *curVidPid, const char *fwFile, const char **error)
{
FLStatus retVal = FL_SUCCESS;
struct Buffer fwBuf = {0,};
BufferStatus bStatus;
FX2Status fxStatus;
struct USBDevice *device = NULL;
USBStatus uStatus;
const char *const ext = fwFile + strlen(fwFile) - 4;
const bool isHex = (strcmp(".hex", ext) == 0) || (strcmp(".ihx", ext) == 0);
CHECK_STATUS(
!isHex, FL_FILE_ERR, cleanup,
"flLoadCustomFirmware(): Filename should have .hex or .ihx extension");
uStatus = usbOpenDevice(curVidPid, 1, 0, 0, &device, error);
CHECK_STATUS(uStatus, FL_USB_ERR, cleanup, "flLoadCustomFirmware()");
bStatus = bufInitialise(&fwBuf, 8192, 0x00, error);
CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "flLoadCustomFirmware()");
bStatus = bufReadFromIntelHexFile(&fwBuf, NULL, fwFile, error);
CHECK_STATUS(bStatus, FL_FILE_ERR, cleanup, "flLoadCustomFirmware()");
fxStatus = fx2WriteRAM(device, fwBuf.data, (uint32)fwBuf.length, error);
CHECK_STATUS(fxStatus, FL_FX2_ERR, cleanup, "flLoadCustomFirmware()");
cleanup:
bufDestroy(&fwBuf);
if ( device ) {
usbCloseDevice(device, 0);
}
return retVal;
}
// Load the standard FPGALink firmware into the FX2 at currentVid/currentPid.
DLLEXPORT(FLStatus) flLoadStandardFirmware(
const char *curVidPid, const char *newVidPid, const char **error)
{
FLStatus flStatus, retVal = FL_SUCCESS;
struct Buffer ramBuf = {0,};
BufferStatus bStatus;
FX2Status fxStatus;
struct USBDevice *device = NULL;
USBStatus uStatus;
uint16 newVid, newPid, newDid;
CHECK_STATUS(
!usbValidateVidPid(newVidPid), FL_USB_ERR, cleanup,
"flLoadStandardFirmware(): The supplied VID:PID:DID \"%s\" is invalid; it should look like 1D50:602B or 1D50:602B:0001",
newVidPid);
newVid = (uint16)strtoul(newVidPid, NULL, 16);
newPid = (uint16)strtoul(newVidPid+5, NULL, 16);
newDid = (uint16)((strlen(newVidPid) == 14) ? strtoul(newVidPid+10, NULL, 16) : 0x0000);
uStatus = usbOpenDevice(curVidPid, 1, 0, 0, &device, error);
CHECK_STATUS(uStatus, FL_USB_ERR, cleanup, "flLoadStandardFirmware()");
bStatus = bufInitialise(&ramBuf, 0x4000, 0x00, error);
CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "flLoadStandardFirmware()");
flStatus = copyFirmwareAndRewriteIDs(
&ramFirmware, newVid, newPid, newDid,
&ramBuf, error);
CHECK_STATUS(flStatus, flStatus, cleanup, "flLoadStandardFirmware()");
fxStatus = fx2WriteRAM(device, ramBuf.data, (uint32)ramBuf.length, error);
CHECK_STATUS(fxStatus, FL_FX2_ERR, cleanup, "flLoadStandardFirmware()");
cleanup:
bufDestroy(&ramBuf);
if ( device ) {
usbCloseDevice(device, 0);
}
return retVal;
}
// Flash custom firmware (.hex or .iic) into the FX2's EEPROM
DLLEXPORT(FLStatus) flFlashCustomFirmware(
struct FLContext *handle, const char *fwFile, const char **error)
{
FLStatus retVal = FL_SUCCESS;
struct Buffer fwData = {0,};
struct Buffer fwMask = {0,};
struct Buffer iicBuf = {0,};
BufferStatus bStatus;
FX2Status fxStatus;
I2CStatus iStatus;
const char *const ext = fwFile + strlen(fwFile) - 4;
const bool isHex = (strcmp(".hex", ext) == 0) || (strcmp(".ihx", ext) == 0);
const bool isI2C = (strcmp(".iic", ext) == 0);
CHECK_STATUS(
!isHex && !isI2C, FL_FX2_ERR, cleanup,
"flFlashCustomFirmware(): Filename should have .hex, .ihx or .iic extension");
bStatus = bufInitialise(&iicBuf, 8192, 0x00, error);
CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "flFlashCustomFirmware()");
if ( isHex ) {
// Load the .hex file, populate iicBuf:
bStatus = bufInitialise(&fwData, 8192, 0x00, error);
CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "flFlashCustomFirmware()");
bStatus = bufInitialise(&fwMask, 8192, 0x00, error);
CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "flFlashCustomFirmware()");
bStatus = bufReadFromIntelHexFile(&fwData, &fwMask, fwFile, error);
CHECK_STATUS(bStatus, FL_FILE_ERR, cleanup, "flFlashCustomFirmware()");
i2cInitialise(&iicBuf, 0x0000, 0x0000, 0x0000, CONFIG_BYTE_400KHZ);
iStatus = i2cWritePromRecords(&iicBuf, &fwData, &fwMask, error);
CHECK_STATUS(iStatus, FL_FX2_ERR, cleanup, "flFlashCustomFirmware()");
iStatus = i2cFinalise(&iicBuf, error);
CHECK_STATUS(iStatus, FL_FX2_ERR, cleanup);
} else if ( isI2C ) {
// Load the .iic file into the iicBuf:
bStatus = bufAppendFromBinaryFile(&iicBuf, fwFile, error);
CHECK_STATUS(bStatus, FL_FILE_ERR, cleanup, "flFlashCustomFirmware()");
}
fxStatus = fx2WriteEEPROM(handle->device, iicBuf.data, (uint32)iicBuf.length, error);
CHECK_STATUS(fxStatus, FL_FX2_ERR, cleanup, "flFlashCustomFirmware()");
cleanup:
bufDestroy(&iicBuf);
bufDestroy(&fwMask);
bufDestroy(&fwData);
return retVal;
}
DLLEXPORT(FLStatus) flLoadXsvfAndConvertToCsvf(
const char *xsvfFile, struct Buffer *csvfBuf, uint32 *maxBufSize, const char **error)
{
FLStatus fStatus, retVal = FL_SUCCESS;
BufferStatus bStatus;
XC xc;
xc.offset = 0;
bStatus = bufInitialise(&xc.xsvfBuf, 0x20000, 0, error);
CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "flLoadXsvfAndConvertToCsvf()");
bStatus = bufAppendFromBinaryFile(&xc.xsvfBuf, xsvfFile, error);
CHECK_STATUS(bStatus, FL_FILE_ERR, cleanup, "flLoadXsvfAndConvertToCsvf()");
fStatus = xsvfSwapBytes(&xc, csvfBuf, maxBufSize, error);
CHECK_STATUS(fStatus, fStatus, cleanup, "flLoadXsvfAndConvertToCsvf()");
cleanup:
bufDestroy(&xc.xsvfBuf);
return retVal;
}
static FLStatus shiftLeft(
struct Buffer *buffer, uint32 numBits, uint32 shiftCount, const char **error)
{
FLStatus retVal = FL_SUCCESS;
uint32 shiftBytes = shiftCount>>3;
uint32 shiftBits = shiftCount&7;
uint16 accum;
const uint8 *p = buffer->data;
const uint8 *const end = buffer->data + buffer->length;
struct Buffer newBuffer = {0,};
BufferStatus bStatus;
if ( shiftBits ) {
bStatus = bufInitialise(&newBuffer, 1024, 0x00, error);
CHECK_STATUS(bStatus, FL_BUF_INIT_ERR, cleanup, "shiftLeft()");
numBits &= 7; // Now the number of significant bits in first byte.
if ( numBits ) {
numBits = 8 - numBits; // Now the number of insignificant bits in first byte.
}
accum = p[0];
if ( p < end ) {
accum = (uint16)(accum >> (8-shiftBits));
if ( shiftBits > numBits ) {
// We're shifting by more than the number of insignificant bits
bStatus = bufAppendByte(&newBuffer, (uint8)(accum&0xFF), error);
CHECK_STATUS(bStatus, FL_BUF_APPEND_ERR, cleanup, "shiftLeft()");
}
accum = (uint16)((p[0]<<8) + p[1]);
p++;
while ( p < end ) {
accum = (uint16)(accum >> (8-shiftBits));
bStatus = bufAppendByte(&newBuffer, (uint8)(accum&0xFF), error);
CHECK_STATUS(bStatus, FL_BUF_APPEND_ERR, cleanup, "shiftLeft()");
accum = (uint16)((p[0]<<8) + p[1]);
p++;
}
}
accum &= 0xFF00;
accum = (uint16)(accum >> (8-shiftBits));
bStatus = bufAppendByte(&newBuffer, (uint8)(accum&0xFF), error);
CHECK_STATUS(bStatus, FL_BUF_APPEND_ERR, cleanup, "shiftLeft()");
bufSwap(&newBuffer, buffer);
}
// Append a write command to the end of the write buffer.
//
DLLEXPORT(FLStatus) flAppendWriteChannelCommand(
struct FLContext *handle, uint8 chan, uint32 count, const uint8 *data, const char **error)
{
FLStatus retVal = FL_SUCCESS;
BufferStatus bStatus;
uint8 command[5];
if ( !handle->writeBuffer.data ) {
// write buffer is lazily initialised
bStatus = bufInitialise(&handle->writeBuffer, 1024, 0x00, error);
CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "flAppendWriteChannelCommand()");
}
command[0] = chan & 0x7F;
flWriteLong(count, command+1);
bStatus = bufAppendBlock(&handle->writeBuffer, command, 5, error);
CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "flAppendWriteChannelCommand()");
bStatus = bufAppendBlock(&handle->writeBuffer, data, count, error);
CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "flAppendWriteChannelCommand()");
cleanup:
return retVal;
}
// Save the EEPROM to an .iic file
DLLEXPORT(FLStatus) flSaveFirmware(
struct FLContext *handle, uint32 eepromSize, const char *saveFile, const char **error)
{
FLStatus retVal = FL_SUCCESS;
struct Buffer i2cBuf = {0,};
BufferStatus bStatus;
FX2Status fxStatus;
const char *const ext = saveFile + strlen(saveFile) - 4;
CHECK_STATUS(
strcmp(".iic", ext), FL_FX2_ERR, cleanup,
"flSaveFirmware(): Filename should have .iic extension");
eepromSize <<= 7; // convert from kbits to bytes
bStatus = bufInitialise(&i2cBuf, eepromSize, 0x00, error);
CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "flSaveFirmware()");
fxStatus = fx2ReadEEPROM(handle->device, eepromSize, &i2cBuf, error);
CHECK_STATUS(fxStatus, FL_FX2_ERR, cleanup, "flSaveFirmware()");
bStatus = bufWriteBinaryFile(&i2cBuf, saveFile, 0UL, i2cBuf.length, error);
CHECK_STATUS(bStatus, FL_FILE_ERR, cleanup, "flSaveFirmware()");
cleanup:
bufDestroy(&i2cBuf);
return retVal;
}
int main(int argc, const char *argv[]) {
int retVal = 0;
struct Buffer csvfBuf = {0,};
BufferStatus bStatus;
FLStatus fStatus;
const char *error = NULL;
uint32 csvfBufSize = 0;
const char *srcFile, *dstFile;
const char *ext;
if ( argc != 3 ) {
fprintf(stderr, "Synopsis: %s [-u] <src.xsvf|src.svf> <dst.csvf>\n", argv[0]);
FAIL(1, cleanup);
}
srcFile = argv[1];
dstFile = argv[2];
ext = srcFile + strlen(srcFile) - 5;
bStatus = bufInitialise(&csvfBuf, 10240, 0x00, &error);
CHECK_STATUS(bStatus, 2, cleanup);
if ( strcmp(".svf", ext+1) == 0 ) {
fStatus = flLoadSvfAndConvertToCsvf(srcFile, &csvfBuf, &csvfBufSize, &error);
} else if ( strcmp(".xsvf", ext) == 0 ) {
fStatus = flLoadXsvfAndConvertToCsvf(srcFile, &csvfBuf, &csvfBufSize, &error);
} else {
fprintf(stderr, "Source filename should have an .svf or an .xsvf extension\n");
FAIL(3, cleanup);
}
CHECK_STATUS(fStatus, 4, cleanup);
//printf("CSVF_BUF_SIZE = %d\n", csvfBufSize);
bStatus = bufWriteBinaryFile(&csvfBuf, dstFile, 0, csvfBuf.length, &error);
CHECK_STATUS(bStatus, 6, cleanup);
cleanup:
bufDestroy(&csvfBuf);
if ( error ) {
fprintf(stderr, "%s\n", error);
bufFreeError(error);
}
return retVal;
}
// Load the standard FPGALink firmware into the FX2 at currentVid/currentPid.
DLLEXPORT(FLStatus) flLoadStandardFirmware(
const char *curVidPid, const char *newVidPid, const char *jtagPort, const char **error)
{
FLStatus flStatus, returnCode;
struct Buffer ramBuf = {0,};
BufferStatus bStatus;
FX2Status fxStatus;
struct USBDevice *device = NULL;
int uStatus;
uint16 newVid, newPid, newDid;
uint8 port, tdoBit, tdiBit, tmsBit, tckBit;
if ( !usbValidateVidPid(newVidPid) ) {
errRender(error, "flLoadStandardFirmware(): The supplied VID:PID:DID \"%s\" is invalid; it should look like 1D50:602B or 1D50:602B:0001", newVidPid);
FAIL(FL_USB_ERR);
}
newVid = (uint16)strtoul(newVidPid, NULL, 16);
newPid = (uint16)strtoul(newVidPid+5, NULL, 16);
newDid = (strlen(newVidPid) == 14) ? (uint16)strtoul(newVidPid+10, NULL, 16) : 0x0000;
if ( strlen(jtagPort) != 5 ) {
errRender(error, "flLoadStandardFirmware(): JTAG port specification must be <C|D><tdoBit><tdiBit><tmsBit><tckBit>");
FAIL(FL_FX2_ERR);
}
if ( (jtagPort[0] & 0xDF) == 'A' ) {
port = 0;
} else if ( (jtagPort[0] & 0xDF) == 'C' ) {
port = 2;
} else if ( (jtagPort[0] & 0xDF) == 'D' ) {
port = 3;
} else {
errRender(error, "flLoadStandardFirmware(): JTAG port specification must be <A|C|D><tdoBit><tdiBit><tmsBit><tckBit>");
FAIL(FL_FX2_ERR);
}
if (jtagPort[1] < '0' || jtagPort[1] > '7' || jtagPort[2] < '0' || jtagPort[2] > '7' || jtagPort[3] < '0' || jtagPort[3] > '7' || jtagPort[4] < '0' || jtagPort[4] > '7' ) {
errRender(error, "flLoadStandardFirmware(): JTAG port specification must be <A|C|D><tdoBit><tdiBit><tmsBit><tckBit>");
FAIL(FL_FX2_ERR);
}
tdoBit = jtagPort[1] - '0';
tdiBit = jtagPort[2] - '0';
tmsBit = jtagPort[3] - '0';
tckBit = jtagPort[4] - '0';
if (
port == 0 &&
(isInvalidPortABit(tdoBit) || isInvalidPortABit(tdiBit) ||
isInvalidPortABit(tmsBit) || isInvalidPortABit(tckBit))
) {
errRender(error, "flFlashStandardFirmware(): Only bits 0, 1, 3 & 7 are available for JTAG use on port A");
FAIL(FL_FX2_ERR);
}
uStatus = usbOpenDevice(curVidPid, 1, 0, 0, &device, error);
CHECK_STATUS(uStatus, "flLoadStandardFirmware()", FL_USB_ERR);
bStatus = bufInitialise(&ramBuf, 0x4000, 0x00, error);
CHECK_STATUS(bStatus, "flLoadStandardFirmware()", FL_ALLOC_ERR);
flStatus = copyFirmwareAndRewriteIDs(
&ramFirmware, newVid, newPid, newDid,
port, tdoBit, tdiBit, tmsBit, tckBit,
&ramBuf, error);
CHECK_STATUS(flStatus, "flLoadStandardFirmware()", flStatus);
fxStatus = fx2WriteRAM(device, ramBuf.data, ramBuf.length, error);
CHECK_STATUS(fxStatus, "flLoadStandardFirmware()", FL_FX2_ERR);
returnCode = FL_SUCCESS;
cleanup:
bufDestroy(&ramBuf);
if ( device ) {
usbCloseDevice(device, 0);
}
return returnCode;
}
DLLEXPORT(FLStatus) flFlashStandardFirmware(
struct FLContext *handle, const char *newVidPid, const char *jtagPort,
uint32 eepromSize, const char *xsvfFile, const char **error)
{
FLStatus flStatus, returnCode;
struct Buffer i2cBuf = {0,};
BufferStatus bStatus;
FX2Status fxStatus;
uint32 fwSize, xsvfSize, initSize;
uint16 newVid, newPid, newDid;
uint8 port, tdoBit, tdiBit, tmsBit, tckBit;
if ( !usbValidateVidPid(newVidPid) ) {
errRender(error, "flFlashStandardFirmware(): The supplied new VID:PID \"%s\" is invalid; it should look like 04B4:8613", newVidPid);
FAIL(FL_USB_ERR);
}
newVid = (uint16)strtoul(newVidPid, NULL, 16);
newPid = (uint16)strtoul(newVidPid+5, NULL, 16);
newDid = (strlen(newVidPid) == 14) ? (uint16)strtoul(newVidPid+10, NULL, 16) : 0x0000;
if ( strlen(jtagPort) != 5 ) {
errRender(error, "flFlashStandardFirmware(): JTAG port specification must be <C|D><tdoBit><tdiBit><tmsBit><tckBit>");
FAIL(FL_FX2_ERR);
}
if ( (jtagPort[0] & 0xDF) == 'A' ) {
port = 0;
} else if ( (jtagPort[0] & 0xDF) == 'C' ) {
port = 2;
} else if ( (jtagPort[0] & 0xDF) == 'D' ) {
port = 3;
} else {
errRender(error, "flFlashStandardFirmware(): JTAG port specification must be <A|C|D><tdoBit><tdiBit><tmsBit><tckBit>");
FAIL(FL_FX2_ERR);
}
if (jtagPort[1] < '0' || jtagPort[1] > '7' || jtagPort[2] < '0' || jtagPort[2] > '7' || jtagPort[3] < '0' || jtagPort[3] > '7' || jtagPort[4] < '0' || jtagPort[4] > '7' ) {
errRender(error, "flFlashStandardFirmware(): JTAG port specification must be <A|C|D><tdoBit><tdiBit><tmsBit><tckBit>");
FAIL(FL_FX2_ERR);
}
tdoBit = jtagPort[1] - '0';
tdiBit = jtagPort[2] - '0';
tmsBit = jtagPort[3] - '0';
tckBit = jtagPort[4] - '0';
if (
port == 0 &&
(isInvalidPortABit(tdoBit) || isInvalidPortABit(tdiBit) ||
isInvalidPortABit(tmsBit) || isInvalidPortABit(tckBit))
) {
errRender(error, "flFlashStandardFirmware(): Only bits 0, 1, 3 & 7 are available for JTAG use on port A");
FAIL(FL_FX2_ERR);
}
bStatus = bufInitialise(&i2cBuf, 0x4000, 0x00, error);
CHECK_STATUS(bStatus, "flFlashStandardFirmware()", FL_ALLOC_ERR);
if ( xsvfFile ) {
flStatus = copyFirmwareAndRewriteIDs(
&eepromWithBootFirmware, newVid, newPid, newDid,
port, tdoBit, tdiBit, tmsBit, tckBit,
&i2cBuf, error);
CHECK_STATUS(flStatus, "flFlashStandardFirmware()", flStatus);
fwSize = i2cBuf.length;
flStatus = convertJtagFileToCsvf(&i2cBuf, xsvfFile, error);
CHECK_STATUS(flStatus, "flFlashStandardFirmware()", flStatus);
xsvfSize = i2cBuf.length - fwSize;
if ( handle->writeBuffer.length ) {
// Write a big-endian uint24 length for the init data, then the data itself
const uint32 length = handle->writeBuffer.length;
if ( length > 0x20000 ) {
errRender(
error,
"flFlashStandardFirmware(): Cannot cope with %lu bytes of init data",
length);
FAIL(FL_FX2_ERR);
}
bStatus = bufAppendByte(&i2cBuf, (uint8)((length>>16) & 0xFF), error);
CHECK_STATUS(bStatus, "flFlashStandardFirmware()", FL_ALLOC_ERR);
bStatus = bufAppendByte(&i2cBuf, (uint8)((length>>8) & 0xFF), error);
CHECK_STATUS(bStatus, "flFlashStandardFirmware()", FL_ALLOC_ERR);
bStatus = bufAppendByte(&i2cBuf, (uint8)(length & 0xFF), error);
CHECK_STATUS(bStatus, "flFlashStandardFirmware()", FL_ALLOC_ERR);
bStatus = bufAppendBlock(
&i2cBuf, handle->writeBuffer.data, length, error);
CHECK_STATUS(bStatus, "flFlashStandardFirmware()", FL_ALLOC_ERR);
initSize = length + 3;
} else {
// Write a zero uint24 length so the firmware knows there's no init data to follow
bStatus = bufAppendByte(&i2cBuf, 0x00, error);
CHECK_STATUS(bStatus, "flFlashStandardFirmware()", FL_ALLOC_ERR);
bStatus = bufAppendByte(&i2cBuf, 0x00, error);
CHECK_STATUS(bStatus, "flFlashStandardFirmware()", FL_ALLOC_ERR);
bStatus = bufAppendByte(&i2cBuf, 0x00, error);
CHECK_STATUS(bStatus, "flFlashStandardFirmware()", FL_ALLOC_ERR);
initSize = 3;
}
} else {
int main(int argc, const char *argv[]) {
int retVal = 0;
struct Buffer data = {0,};
struct Buffer mask = {0,};
struct Buffer i2c = {0,};
BufferStatus bStatus;
I2CStatus iStatus;
int dStatus;
uint8 configByte;
const char *error = NULL;
if ( argc != 4 ) {
usage(argv[0]);
FAIL(1, cleanup);
}
if ( strstr(argv[2], "WithBoot") ) {
// Boot firmware explicitly connects
configByte = CONFIG_BYTE_400KHZ | CONFIG_BYTE_DISCON;
} else {
// NonBoot firmwares are connected automatically
configByte = CONFIG_BYTE_400KHZ;
}
bStatus = bufInitialise(&data, 0x4000, 0x00, &error);
CHECK_STATUS(bStatus, 2, cleanup);
bStatus = bufInitialise(&mask, 0x4000, 0x00, &error);
CHECK_STATUS(bStatus, 3, cleanup);
bStatus = bufReadFromIntelHexFile(&data, &mask, argv[1], &error);
CHECK_STATUS(bStatus, 4, cleanup);
if ( !strcmp("iic", argv[3]) ) {
// Get i2c records
bStatus = bufInitialise(&i2c, 0x4000, 0x00, &error);
CHECK_STATUS(bStatus, 5, cleanup);
i2cInitialise(&i2c, 0x0000, 0x0000, 0x0000, configByte);
iStatus = i2cWritePromRecords(&i2c, &data, &mask, &error);
CHECK_STATUS(iStatus, 6, cleanup);
iStatus = i2cFinalise(&i2c, &error);
CHECK_STATUS(iStatus, 7, cleanup);
// Dump the code
dStatus = dumpCode(argv[0], argv[2], &i2c);
CHECK_STATUS(dStatus, dStatus, cleanup);
} else if ( !strcmp("bix", argv[3]) ) {
// Dump the code
dStatus = dumpCode(argv[0], argv[2], &data);
CHECK_STATUS(dStatus, dStatus, cleanup);
} else {
usage(argv[0]);
FAIL(8, cleanup);
}
cleanup:
if ( error ) {
fprintf(stderr, "%s: %s\n", argv[0], error);
errFree(error);
}
bufDestroy(&i2c);
bufDestroy(&mask);
bufDestroy(&data);
return retVal;
}
int main(int argc, const char *argv[]) {
int returnCode = 0;
struct Buffer data1 = {0,};
struct Buffer mask1 = {0,};
struct Buffer data2 = {0,};
struct Buffer mask2 = {0,};
struct Buffer i2c1 = {0,};
struct Buffer i2c2 = {0,};
BufferStatus bStatus;
I2CStatus iStatus;
int dStatus;
uint8 configByte;
const char *error = NULL;
if ( argc != 5 ) { //&& argc != 6 ) {
usage(argv[0]);
FAIL(1);
}
if ( strstr(argv[3], "WithBoot") ) {
// Boot firmware explicitly connects
configByte = CONFIG_BYTE_400KHZ | CONFIG_BYTE_DISCON;
} else {
// NonBoot firmwares are connected automatically
configByte = CONFIG_BYTE_400KHZ;
}
bStatus = bufInitialise(&data1, 0x4000, 0x00, &error);
CHECK(bStatus, 2);
bStatus = bufInitialise(&mask1, 0x4000, 0x00, &error);
CHECK(bStatus, 3);
bStatus = bufReadFromIntelHexFile(&data1, &mask1, argv[1], &error);
CHECK(bStatus, 4);
bStatus = bufInitialise(&data2, 0x4000, 0x00, &error);
CHECK(bStatus, 5);
bStatus = bufInitialise(&mask2, 0x4000, 0x00, &error);
CHECK(bStatus, 6);
bStatus = bufReadFromIntelHexFile(&data2, &mask2, argv[2], &error);
CHECK(bStatus, 7);
if ( !strcmp("iic", argv[4]) ) {
// Get i2c records from first build
bStatus = bufInitialise(&i2c1, 0x4000, 0x00, &error);
CHECK(bStatus, 8);
i2cInitialise(&i2c1, 0x0000, 0x0000, 0x0000, configByte);
iStatus = i2cWritePromRecords(&i2c1, &data1, &mask1, &error);
CHECK(iStatus, 9);
iStatus = i2cFinalise(&i2c1, &error);
CHECK(iStatus, 10);
// Get i2c records from second build
bStatus = bufInitialise(&i2c2, 0x4000, 0x00, &error);
CHECK(bStatus, 11);
i2cInitialise(&i2c2, 0x0000, 0x0000, 0x0000, configByte);
iStatus = i2cWritePromRecords(&i2c2, &data2, &mask2, &error);
CHECK(iStatus, 12);
iStatus = i2cFinalise(&i2c2, &error);
CHECK(iStatus, 13);
// Dump the code
dStatus = dumpCode(argv[0], argv[3], &i2c1, &i2c2);
CHECK(dStatus, dStatus);
} else if ( !strcmp("bix", argv[4]) ) {
// Dump the code
dStatus = dumpCode(argv[0], argv[3], &data1, &data2);
CHECK(dStatus, dStatus);
} else {
usage(argv[0]);
FAIL(14);
}
cleanup:
if ( error ) {
fprintf(stderr, "%s: %s\n", argv[0], error);
errFree(error);
}
bufDestroy(&i2c2);
bufDestroy(&i2c1);
bufDestroy(&mask2);
bufDestroy(&data2);
bufDestroy(&mask1);
bufDestroy(&data1);
return returnCode;
}
