// 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; }
// Disconnect and cleanup, if necessary. // DLLEXPORT(void) flClose(struct FLContext *handle) { if ( handle ) { usbCloseDevice(handle->device, 0); if ( handle->writeBuffer.data ) { bufDestroy(&handle->writeBuffer); } free((void*)handle); } }
// 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; }
// 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; }
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; }