cvupgrade.c

Go to the documentation of this file.

/************************************************************************

 CAEN SpA - Viareggio
 www.caen.it

 Program: cvupgrade
 Date:    15/02/2010
 Author:  CAEN Computing Division (support.computing@caen.it)

 ------------------------------------------------------------------------
 Description
 ------------------------------------------------------------------------
 This program allows to upgrade the firmware of any CAEN module that
 supports the firmware download through the USB/CONET cable.(except for the
 bridges V1718 and V2718 that use the program 'CAENVMEUpgrade').
 The firmware upgrade consists in writing the configuration file (Altera
 Raw Binary Format) into the flash memory of the board. Usually the flash
 memory contains two images of the configuration file, called 'standard'
 and 'backup'. The 'standard' image only will normally be overwritten ; 
 the new firmware will be loaded by the FPGA after the first power cycle.
 If an error occurs while upgrading, it may happen that the FPGA is not
 properly configured and the board does not respond to the VME access.
 In this case you can restore the old firmware (i.e. the 'backup' image)
 just moving the relevant jumper from STD to BKP and power cycling the
 board. Now you can retry to upgrade the 'standard' image.
 Warning: never upgrade the 'backup' image until you are sure that the
 'standard' works properly.
 This program reads some parameters that define the type of the board
 being upgraded from a file called CVupgrade_params.txt that must be
 in the same directory of CVupgrade. There is one CVupgrade_params file
 for each type of board that can be upgraded.

 ------------------------------------------------------------------------

 ------------------------------------------------------------------------
 Portability
 ------------------------------------------------------------------------
 This program is ANSI C and can be compilated on any platform, except
 for the functions that allow to initialize and access the VME bus.
 For VME Boards, if CAEN's VME bridges (both V1718 and V2718) are used as VME masters,
 a proper installation of the CAENComm library DLL on PC is the only requirement.
 If a different VME Bridge/CPU is used, the CAENComm function calls MUST be reimplemented.

*************************************************************************/
/*------------------------------------------------------------------------
  Modification history:
  ------------------------------------------------------------------------
  Version  | Author | Date       | Changes made
  ------------------------------------------------------------------------
  1.0      | CTIN   | 01.02.2008 | initial version.
  1.1      | LCOL   | 29.05.2008 | Updated WriteFlashPage to account for 
           |        |            | a longer flash erase times 
           |        |            | (increase from 20 to 40 ms).
  1.2      | LCOL   | 25.06.2008 | Added flash enable polarity parameter.         
  1.3      | CTIN   | 26.01.2009 | Extended compatibility to 16, 32 and 64
           |        |            | Mbit flash size;
           |        |            | Replaced fixed wait time (page erasing)
           |        |            | with busy polling;
           |        |            | Add -link and -bdnum command line options
  2.0      | ALUK   | 03.10.2009 | Add the CAENComm as reference library for the 
                   |            |                        | low level access.
  2.1      | ALUK   | 14.02.2010 | Add Keyinfo and KeyWrite functionalities 
                   |        |            |(only Digitizer boards)
  2.2      | NDA        | 15.04.2010 | Added optional command line parameter: modelname
                   |        |            | Added model name (if defined) to the KeyInfo filename
                   |        |            | Changed KeyInfo filename from KeyInfo### to BoardInfo###
                   |        |            | Added main switch -License: this will print (default) or delete ( -delete option)
                   |        |            | the license data
  2.3      | NDA    | 29.07.2010 | Add -Key main switch to set the DPP key file without have to upgrade the firmware
  2.4      | ALUK   | 15.07.2012 | Add -fwrel main switch to get the firmware release of the board
  ------------------------------------------------------------------------

  ------------------------------------------------------------------------*/

#define REVISION  "2.4"

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>

#include "flash.h"

#include "CFASegment.h"

typedef struct UpgradeParams {
  unsigned int                  Type  ;
  unsigned int                  Link  ;
  unsigned int                  BdNum ;
  unsigned long                 BaseAddress;  
  unsigned int                  FirstPageStd;         // First page of the Standard image
  unsigned int                  FirstPageBck;         // First page of the Backup image
  uint64_t                              key; 
  unsigned int                  image     ;
  unsigned int                  noverify  ;
  unsigned int                  verifyonly;
  unsigned int                  delete    ;
  unsigned int                  cfa               ;                       // CFA mode
  char                                  ConfFile[1000];
  char                                  Models[1000];
  char                                  modelName[50];
  char                                  family[50];
  char                                  filepath[1000];
  unsigned int                  ROCFwm;
  unsigned int                  AMCFwm;
} cvUpgradeParams;


static void Usage() {
        printf("Syntax: cvUpgrade ConfFile ConnType[USB|OPTLINK] [ConfigOptions][DeviceOptions]\n");
                printf("Syntax: cvUpgrade -KeyInfo ConnType[USB|OPTLINK] [DeviceOptions]\n");
                printf("Syntax: cvUpgrade -License ConnType[USB|OPTLINK] [LicenseOptions]\n");
        printf("Syntax: cvUpgrade -Key N ConnType[USB|OPTLINK] [DeviceOptions]\n\n");
                printf("Syntax: cvUpgrade -fvrel ConnType[USB|OPTLINK] [DeviceOptions]\n\n");
        printf("Description: write the file 'ConfFile' (Altera Raw Binary Format) into\n");
        printf("the flash memory of board connected by the specified connection type OR\n");
        printf("retrieve the keyinfo data from the board and store it on BoardInfo.dat file OR\n");
                printf("retrieve or delete the license data from the board:\n");
                printf("  to delete the license file you must specify -delete option\n\n");
        printf("ConfigOptions:\n\n");
        printf("-backup: write backup image\n\n");
                printf("-key    N: The key value to enable the DPP firmware\n\n"); 
        printf("-no_verify: disable verify (don't read and compare the flash content)\n\n");
        printf("-verify_only: read the flash content and compare with the ConfFile file\n\n");
                printf("DeviceOptions:\n\n");
        printf("-param filename: allow to specify the file that contain the parameters for the\n");
        printf("                 board that is being upgraded (default is cvUpgrade_params.txt)\n");
                printf("                                 With CFA files this option is not required.\n\n");
                printf("-rbf: specifies that the config file to be updated is in RBF format.\n");
        printf("-link   N: when using CONET, it is the optical link number to be used\n");
                printf("           when using USB, it is the USB device number to be used (default is 0)\n\n");
        printf("-bdnum  N: select board number in a chainable link (V2718 only)\n\n");
                printf("-VMEbaseaddress   N: The base address of the VME slave board to be upgraded (Hex 32 bit)\n\n");
        printf("-modelname ModelName: specify the model name (e.g. V1724B)\n\n");
        printf("-filepath Folder: specify the folder where store the KeyInfo file\n\n");
                printf("LicenseOptions:\n\n");
        printf("-delete : deletes the license data\n");
}


//******************************************************************************
// ReadConfigurationROM
//******************************************************************************
static int ReadConfigurationROM(cvFlashAccess *Flash, CROM_MAP *crom)
{
  unsigned char data[AT45_PAGE_SIZE];
  int res = 0;

  res = ReadFlashPage(Flash, data, ROM_FLASH_PAGE);

  if (res == 0) {
      crom->crom_chksum     = (uint8_t)(data[0]);
      crom->crom_chksum_len = (uint32_t) ((data[1] << 16) | (data[2] << 8) | data[3]);
      crom->crom_const      = (uint32_t) ((data[4] << 16) | (data[5] << 8) | data[6]);
      crom->crom_c_code     = (uint8_t)(data[7]);
      crom->crom_r_code     = (uint8_t)(data[8]);
      crom->crom_OUI        = (uint32_t) ((data[9] << 16) | (data[10] << 8) | data[11]);
      crom->crom_version    = (uint8_t)(data[12]);
      crom->crom_board_id   = (uint32_t) ((data[13] << 16) | (data[14] << 8) | data[15]);
      crom->crom_revision   = (uint32_t) ( (data[16] << 24) | (data[17] << 16) | (data[18] << 8) | data[19]);
      crom->crom_serial     = (uint16_t) ((data[32] << 8) | (data[33]));
      crom->crom_VCXO_type  = (uint8_t)(data[34]);
  }
  return res;
}


//******************************************************************************
// ReadLicense
//******************************************************************************
static int ReadLicense(cvFlashAccess *Flash, uint8_t licenseData[LICENSE_DATA_SIZE])
{
  unsigned char data[AT45_PAGE_SIZE];
  int res = 0;

  if( (res = ReadFlashPage(Flash, data, LICENSE_FLASH_PAGE))!= 0) {
          return res;
  }
  memcpy( licenseData, data, LICENSE_DATA_SIZE); 
  return 0;
}


//******************************************************************************
// EraseLicense
//******************************************************************************
static int EraseLicense(cvFlashAccess *Flash)
{
  unsigned char data[AT45_PAGE_SIZE];

  memset( data, 0xff, sizeof( data));
  return WriteFlashPage(Flash, data, LICENSE_FLASH_PAGE);
}

//******************************************************************************
// PrintCROM2File
//******************************************************************************
static void PrintCROM2File(FILE *fp, const CROM_MAP *map) {
    fprintf(fp,"Checksum        = %X\n", map->crom_chksum);
    fprintf(fp,"Checksum Length = %X\n", map->crom_chksum_len);
    fprintf(fp,"Constant field  = %X\n", map->crom_const);
    fprintf(fp,"C Code          = %X\n", map->crom_c_code);
    fprintf(fp,"R Code          = %X\n", map->crom_r_code);
    fprintf(fp,"OUI             = %X\n", map->crom_OUI);
    fprintf(fp,"Version         = %X\n", map->crom_version);
    fprintf(fp,"Board ID        = %X\n", map->crom_board_id);
    fprintf(fp,"PCB Revision    = %d\n", map->crom_revision);
    fprintf(fp,"Serial Number   = %d\n", map->crom_serial);
    fprintf(fp,"VCXO Type ID    = %d\n", map->crom_VCXO_type);
}

//******************************************************************************
// KeyInfo
//******************************************************************************
static int KeyInfo(cvUpgradeParams *Config, cvFlashAccess *Flash) {
        int i;
        unsigned char security_vme[AT45_IDREG_LENGTH];
        // unsigned long vboard_base_address;
        char KeyFilename[200];
        FILE *cf = NULL;
        int res;

        CROM_MAP rom;

    /* initialize the connection */
    res = CAENComm_OpenDevice(Config->Type, Config->Link, Config->BdNum,  Config->BaseAddress, &Flash->Handle);
    if (res != CAENComm_Success) {
        printf("Cannot open the Device!\n");
        return(CvUpgrade_FileAccessError);
    }
   
        if (ReadFlashSecurityReg(Flash, security_vme)) {
      printf("Error while reading on-board flash memory!\n");
          return(CvUpgrade_FileAccessError);
        }
        if (ReadConfigurationROM(Flash, &rom)) {
      printf("Error while reading on-board flash memory!\n");
          return(CvUpgrade_FileAccessError);
        }
        if( strlen( Config->modelName)) {
                sprintf(KeyFilename, "%s/BoardInfo-%s-%d.dat", Config->filepath, Config->modelName, rom.crom_serial);
        } else {
                sprintf(KeyFilename, "%s/BoardInfo-%d.dat", Config->filepath, rom.crom_serial);
        }
    cf = fopen(KeyFilename,"w");
        if(cf == 0) {
      printf("Cannot open %s file! Exiting ...\n", KeyFilename);
      return(CvUpgrade_FileAccessError);
        }

    printf("Writing output file %s\n", KeyFilename);
        for(i=0; i < 64; i++) {
          fprintf(cf, "%02X", security_vme[64+i]);
          fprintf(cf, (i < 63) ? ":" : "\n");
        }
        PrintCROM2File(cf, &rom);

        CAENComm_CloseDevice(Flash->Handle);
        Flash->Handle= CAENCOM_INVALID_FILE_HANDLE;

        printf("\n");
        printf("Program exits successfully.\n");
    fclose(cf);
        return 0;
}

static int GetFWRel(cvUpgradeParams *Config, cvFlashAccess *Flash) {
        /* initialize the connection */
        int ret,d32,i;
        unsigned char x,y;
        int chNum = 2;
        uint16_t BuildHexCode,d16;
        if( CAENComm_OpenDevice(Config->Type, Config->Link, Config->BdNum,  Config->BaseAddress, &Flash->Handle)!= CAENComm_Success){
        printf("Cannot open the Device!\n");
        return(CvUpgrade_FileAccessError);
    }

        if (strcmp(Config->Models,"DIGITIZERS") == 0) { 
                // DIGITIZERS
                if ((ret = CAENComm_Read32(Flash->Handle,Config->ROCFwm, &d32)) != CAENComm_Success) {
                        printf("unable to find ROC FPGA  release\n");
                        return -1;
                }
                y = (uint8_t) (d32 & 0xff);
                x = (uint8_t) ((d32 & 0xff00)>> 8);
                BuildHexCode = (uint16_t) ((d32 & 0xffff0000)>> 16);
                printf("ROC FPGA Release is %02d.%02d - Build %04X\n",x,y, BuildHexCode);

                for (i = 0; i< chNum; i++) {
                        if ((ret = CAENComm_Read32(Flash->Handle, Config->AMCFwm | (i<<8), &d32)) == CAENComm_Success) {
                                if ( (uint16_t)((d32 & 0xffff0000)>> 16) != 0x0000 ) break; // HACK this is for x780 support! AMC Build must be != 0000
                        }
                }
                if (i == (int32_t)chNum) {
                        printf("unable to find AMC FPGA release\n");
                        return -1;
                }
                y = (uint8_t) (d32 & 0xff);
                x = (uint8_t) ((d32 & 0xff00)>> 8);
                BuildHexCode = (uint16_t) ((d32 & 0xffff0000)>> 16);
                printf("AMC FPGA Release is %02d.%02d - Build %04X",x,y, BuildHexCode);
        }
        else {
                if (strcmp(Config->Models,"V1190,V1290") == 0) {
                        if ((ret = CAENComm_Read16(Flash->Handle,Config->ROCFwm, &d16)) != CAENComm_Success) {
                                printf("unable to find firmware release\n");
                                return -1;
                        }
                        y = (uint8_t) (d16 & 0xff);
                        x = (uint8_t) ((d16 & 0xff00)>> 8);
                        printf("Firmware Release is %02d.%02d\n",x,y);
                }
                else {
                        if ((ret = CAENComm_Read32(Flash->Handle,Config->ROCFwm, &d32)) != CAENComm_Success) {
                                printf("unable to find firmware release\n");
                                return -1;
                        }
                        y = (uint8_t) (d32 & 0xff);
                        x = (uint8_t) ((d32 & 0xff00)>> 8);
                        printf("Firmware Release is  %02d.%02d\n",x,y);
                }
        }
        CAENComm_CloseDevice(Flash->Handle);
        Flash->Handle= CAENCOM_INVALID_FILE_HANDLE;

        printf("\n");
        printf("Program exits successfully.\n");
        return 0;
}       

//******************************************************************************
// License
//******************************************************************************
static int License(cvUpgradeParams *Config, cvFlashAccess *Flash) {

        /* initialize the connection */
        if( CAENComm_OpenDevice(Config->Type, Config->Link, Config->BdNum,  Config->BaseAddress, &Flash->Handle)!= CAENComm_Success){
        printf("Cannot open the Device!\n");
        return(CvUpgrade_FileAccessError);
    }

        if( Config->delete) {
                // delete the license data
                if( EraseLicense( Flash)) {
                        printf("Error deleting license data! Exiting ...\n");
                        return(CvUpgrade_FileAccessError);
                }
        } else {
                uint8_t licenseData[LICENSE_DATA_SIZE];
                if( ReadLicense( Flash, licenseData)) {
                        printf("Error reading license data! Exiting ...\n");
                        return(CvUpgrade_FileAccessError);
                }
                // print the license data
                // check if a valid license
                printf("\n");
                if( ( licenseData[0]!= 0x00) || ( licenseData[1]!= 0x04)) {
                        printf("No valid license found!");
                } else {
                        int i;
                        for( i= 0; i< LICENSE_DATA_SIZE; i++) {
                                printf( "%02X ", licenseData[i]);
                        }
                }
        }
        CAENComm_CloseDevice(Flash->Handle);
        Flash->Handle= CAENCOM_INVALID_FILE_HANDLE;

        printf("\n");
        printf("Program exits successfully.\n");
        return 0;
}

//******************************************************************************
// WriteKey
//******************************************************************************
int WriteKey(cvUpgradeParams *Config, cvFlashAccess *Flash)
{
    unsigned int err=0, res, handleToClose= 0;    
        unsigned char key_page[LICENSE_DATA_SIZE];
    int k;    

        if ((Config->key != 0) && 
                ((!strncmp(Config->Models,"DIGITIZERS",1000)) || 
                (!strncmp(Config->Models,"V1495",1000)))) {
                        if( Flash->Handle== CAENCOM_INVALID_FILE_HANDLE) {
                                res = CAENComm_OpenDevice(Config->Type, Config->Link, Config->BdNum,  Config->BaseAddress, &Flash->Handle);
                                if (res != CAENComm_Success) {
                                        printf("Cannot open the Device!\n");
                                        return(CvUpgrade_FileAccessError);
                                }
                                handleToClose= 1;
                        }

                        memset(key_page, 0, LICENSE_DATA_SIZE);
                        for (k = LICENSE_DATA_SIZE- 1; k > -1; k--) {
                                key_page[LICENSE_DATA_SIZE- 1- k] = (unsigned char) ((Config->key >> (k * 8)) & 0xFF);
                        }       
                        WriteFlashPage(Flash, key_page, LICENSE_FLASH_PAGE);
                        if( handleToClose) {
                                CAENComm_CloseDevice(Flash->Handle);
                                Wait_ms(1000);
                                Flash->Handle= CAENCOM_INVALID_FILE_HANDLE;
                        }
            printf("\nKey written successfully\n");
        }
    return err;
}

//******************************************************************************
// validateModel
//******************************************************************************
int validateModel(cvUpgradeParams *config, cvFlashAccess* flash, char** fwData, int* fwSize) {
        FILE* fin = fopen(config->ConfFile, "rb");
        while (!feof(fin)) {
                int last;
                CFASegmentPtr segm = newSegment(fin, &last);
                if (segm == NULL) {
                        fclose(fin);
                        return -2;
                }
                if (getSegmentType(segm) == CFA_SEGMENT_TYPE_1) {
                        CFASegmentType1* t1s = toType1(segm);
                        int i, j;
                        for (i = 0; i < t1s->numModels; i++) {
                                for (j = 0; j<t1s->models[i]->numChecks; j++) {
                                        uint32_t address = t1s->models[i]->registerChecks[j].address;
                                        uint32_t value;
                                        if (t1s->accessType == 2) CAENComm_Read16(flash->Handle, address, (uint16_t*)&value);
                                        else CAENComm_Read32(flash->Handle, address, &value);
                                        if (value != t1s->models[i]->registerChecks[j].value) break;
                                }
                                if (j == t1s->models[i]->numChecks) { /* this means that all the checks match */
                                        flash->PageSize = t1s->flashPageSize;
                                        flash->RegSize = t1s->accessType;
                                        flash->Sel_Flash = t1s->flashCsAddress;
                                        flash->RW_Flash = t1s->flashCwAddress;
                                        flash->FlashEnable = t1s->flashEnLevel;
                                        config->FirstPageStd = t1s->flashStdAddress;
                                        config->FirstPageBck = t1s->flashBckAddress;

                                        *fwData = malloc(t1s->fwSizeBytes);
                                        memcpy(*fwData, t1s->fwData, t1s->fwSizeBytes);
                                        *fwSize = t1s->fwSizeBytes;

                                        sprintf(config->Models, "id %d", t1s->models[i]->modelId);

                                        deleteSegment(segm);
                                        fclose(fin);
                                        return 0;
                                }
                        }
                }
                deleteSegment(segm);
                if (last) break;
        }
        fclose(fin);
        return -1;
}



//******************************************************************************
// cvUpgrade
//******************************************************************************
int cvUpgrade(cvUpgradeParams *Config, cvFlashAccess *Flash)
{
    unsigned int i, j, page, pa,  NumPages, err=0, done;    
    unsigned int CFsize;
    unsigned char c, *CFdata = NULL;
    unsigned char pdr[2048];
    int res;

    FILE *cf;

        /* initialize the connection */
    res = CAENComm_OpenDevice(Config->Type, Config->Link, Config->BdNum,  Config->BaseAddress, &Flash->Handle);
    if (res != CAENComm_Success) {
        printf("Cannot open the Device!\n");
                return(CvUpgrade_CAENCommError);
    }


    // ************************************************
    // Open Binary Configuration File
    // ************************************************
        if (!Config->cfa) {
                // open and read the configuration file
                cf = fopen(Config->ConfFile,"rb");
                if(cf == 0) {
                        printf("Can't open file %s\n",Config->ConfFile);
                        Usage();
                        CAENComm_CloseDevice(Flash->Handle);
                        return(CvUpgrade_FileAccessError);
                }
                // calculate the size
                fseek (cf, 0, SEEK_END);
                CFsize = ftell (cf);
                fseek (cf, 0, SEEK_SET);
                if ( (CFdata = (unsigned char *)malloc(CFsize)) == NULL ) {
                        printf("Can't allocate %d bytes\n",CFsize);
                        CAENComm_CloseDevice(Flash->Handle);
                        return(-3);
                }

                for(i=0; i<CFsize; i++) {
                        // read one byte from file and mirror it (lsb becomes msb)
                        c = (unsigned char)fgetc(cf);
                        CFdata[i]=0;
                        for(j=0; j<8; j++)
                                CFdata[i] |= ( (c >> (7-j)) & 1) << j;
                }
                fclose(cf);

        } else {
                printf("CFA Mode. Reading archive.\n");
                if (validateModel(Config, Flash, &CFdata, &CFsize)) {
                        printf("Error: no compatible firmware found in archive!\n");
                        CAENComm_CloseDevice(Flash->Handle);
                        return -99;
                }
                printf("Compatible firmware found in archive.\n");

                for (i=0; i<CFsize; i++) {
                        char c = CFdata[i];
                        CFdata[i] = 0;
                        for (j=0; j<8; j++)
                                CFdata[i] |= ( (c >> (7-j)) & 1) << j;
                }
        }


    NumPages = (CFsize % Flash->PageSize == 0) ? (CFsize / Flash->PageSize) : (CFsize / Flash->PageSize) + 1;

        printf("Board Types: %s\n", Config->Models);
    if (Config->image == 0) {
        if(!Config->verifyonly)
          printf("Overwriting Standard image of the firmware with %s\n", Config->ConfFile);
        else
            printf("Verifying Standard image of the firmware with %s\n", Config->ConfFile);
        pa = Config->FirstPageStd;
    }
    else {
        if(!Config->verifyonly)
            printf("Overwriting Backup image of the firmware with %s\n", Config->ConfFile);
        else
            printf("Verifying Backup image of the firmware with %s\n", Config->ConfFile);
        pa = Config->FirstPageBck;
    }

    printf("0%% Done\n");
    done = 10;

    // ************************************************
    // Start for loop
    // ************************************************
    for(page=0; page < NumPages; page++)  {
        if(!Config->verifyonly) {
            // Write Page
            if (WriteFlashPage(Flash, CFdata + page*Flash->PageSize, pa + page) < 0) {
                printf("\nCommunication Error: the board at Base Address %08X does not respond\n", (unsigned int) (Config->BaseAddress));
                err = 1;
                break;
                }
        }

        if(!Config->noverify) {
            // Read Page
            if (ReadFlashPage(Flash, pdr, pa + page) < 0) {
                printf("\nCommunication Error: the board at Base Address %08X does not respond\n", (unsigned int) (Config->BaseAddress));
                err = 1;
                break;
            }
            // Verify Page
            for(i=0; (i<Flash->PageSize) && ((page*Flash->PageSize+i) < CFsize); i++)  {
                if(pdr[i] != CFdata[page*Flash->PageSize + i])  {
                    printf("\nFlash verify error (byte %d of page %d)!\n", i, pa + page);
                    if ((Config->image == 0) && !Config->verifyonly)
                        printf("The STD image can be corrupted! \nMove the jumper to Backup image and cycle the power\n");
                    err = 1;
                    break;
                }
            }
        }
        if (err)
            break;

        if (page == (NumPages-1)) {
            printf("100%% Done\n");
        } else if ( page >= (NumPages*done/100) ) {
            printf("%d%% Done\n", done);
            done += 10;
        }
    }  // end of for loop

    if(!err) {
        if (Config->verifyonly) {
            printf("\nFirmware verified successfully. Read %d bytes\n", CFsize);
        } else {
            printf("\nFirmware updated successfully. Written %d bytes\n", CFsize);
            printf("The new firmware will be loaded after a power cycle\n");
        }
    }

    if (CFdata != NULL) 
        free(CFdata);

        if( !err) {
                err= WriteKey( Config, Flash);
        }
    CAENComm_CloseDevice(Flash->Handle);
        Flash->Handle= CAENCOM_INVALID_FILE_HANDLE;
    Wait_ms(1000);
 
    return err;

}


//******************************************************************************
// MAIN
//******************************************************************************
int main(int argc,char *argv[])
{
    int err=0;
        int key = 0;
        int license = 0;
        int fwrel = 0;
        int writeKey= 0;
    cvUpgradeParams Params;
    cvFlashAccess   FlashInfo;
    char ParamFile[1000] = "cvUpgrade_params.txt";
        int argIndex= 1;

    FILE *bdf;

    printf("\n");
    printf("********************************************************\n");
    printf(" CAEN SpA - Front-End Division                          \n");
    printf("--------------------------------------------------------\n");
    printf(" CAEN Board Firmware Upgrade                              \n");
    printf(" Version %s                                             \n", REVISION);
    printf("********************************************************\n\n");

    // Check command arguments (must be at least 2)
    if (argc < 3)  {
        Usage();
        return(-1);
    }

    // Inizialize defaults 
        FlashInfo.Handle= CAENCOM_INVALID_FILE_HANDLE;
    FlashInfo.FlashEnable = 0;
    Params.Link = 0;
    Params.BdNum = 0;
    Params.image = 0; // Default = standard
        Params.noverify = 0;
        Params.verifyonly = 0;
    Params.BaseAddress = 0;
    Params.key = 0;
        *Params.modelName= '\0';
        Params.delete = 0;
        Params.cfa = 1;

    strstr(Params.ConfFile, "cvUpgrade_params.txt");
        if (strcmp(argv[argIndex],"-KeyInfo") == 0 ) {
                key = 1;
        } else if (strcmp(argv[argIndex],"-License") == 0 ) {
                license = 1;
        } else if (strcmp(argv[argIndex],"-Key") == 0 ) {
                sscanf(argv[++argIndex], "%llx", &Params.key); 
                writeKey = 1;
        } else if (strcmp(argv[argIndex],"-fwrel") == 0 ) {
                fwrel = 1;
        } else {
                sprintf(Params.ConfFile, argv[argIndex]);
        }
        argIndex++;
    if (strcmp(argv[argIndex],"USB") == 0) Params.Type = CAENComm_USB;
        if (strcmp(argv[argIndex],"OPTLINK") == 0) Params.Type = CAENComm_PCI_OpticalLink;
//      if (strcmp(argv[argIndex],"PCIE_OPTLINK") == 0) Params.Type = CAENComm_PCIE_OpticalLink;
        argIndex++;
    for (; argIndex<argc; argIndex++) {
        if ( strcmp(argv[argIndex],"-backup") == 0 )
            Params.image = 1;
        if ( strcmp(argv[argIndex],"-no_verify") == 0 )
            Params.noverify = 1;
        if ( strcmp(argv[argIndex],"-verify_only") == 0 )
            Params.verifyonly = 1;        
        if ( strcmp(argv[argIndex],"-param") == 0 )
            sprintf(ParamFile, "%s", argv[++argIndex]);
                if ( strcmp(argv[argIndex],"-rbf") == 0 )
                        Params.cfa = 0;
                if ( strcmp(argv[argIndex],"-VMEbaseaddress") == 0 )
                        sscanf(argv[++argIndex], "%x", (unsigned int *) (&Params.BaseAddress));
                if ( strcmp(argv[argIndex],"-key") == 0 )
                        sscanf(argv[++argIndex], "%llx", &Params.key); 
        if ( strcmp(argv[argIndex],"-link") == 0 )
            Params.Link = atoi(argv[++argIndex]);  
        if ( strcmp(argv[argIndex],"-bdnum") == 0 )
            Params.BdNum = atoi(argv[++argIndex]);  
                if ( strcmp(argv[argIndex],"-modelname") == 0 ) {
                        strncpy( Params.modelName, argv[++argIndex], sizeof( Params.modelName));
                        Params.modelName[ sizeof( Params.modelName)- 1]= '\0';
                }
                if ( strcmp(argv[argIndex],"-modelfamily") == 0 ) {
                        strncpy( Params.family, argv[++argIndex], sizeof( Params.family));
                        Params.family[ sizeof( Params.family)- 1]= '\0';
                }
                if ( strcmp(argv[argIndex],"-filepath") == 0 ) {
                        strncpy( Params.filepath, argv[++argIndex], sizeof( Params.filepath));
                        Params.filepath[ sizeof( Params.filepath)- 1]= '\0';
                }
        if ( strcmp(argv[argIndex],"-delete") == 0 )
            Params.delete = 1;
    }

    // open the board descriptor file
        if ((!Params.cfa) || (fwrel)  || (license) || (key) | (writeKey)) {
                bdf = fopen(ParamFile,"r");
                if(bdf == 0) {
                        printf("Can't open file %s\n", ParamFile);
                        Usage();
                        return (-2); 
                }

                fscanf(bdf, "%s", Params.Models);
                fscanf(bdf, "%x", (unsigned int *) (&FlashInfo.Sel_Flash));
                fscanf(bdf, "%x", (unsigned int *) (&FlashInfo.RW_Flash));
                fscanf(bdf, "%d", &FlashInfo.RegSize);
                fscanf(bdf, "%d", &FlashInfo.PageSize);
                fscanf(bdf, "%d", &Params.FirstPageStd);
                fscanf(bdf, "%d", &Params.FirstPageBck);
                if (!feof(bdf)) {
                        int tmp;
                        if (fscanf(bdf, "%d", &tmp) > 0)
                                FlashInfo.FlashEnable = tmp;
                }
                fscanf(bdf, "%x", &Params.ROCFwm);
                fscanf(bdf, "%x", &Params.AMCFwm);
                fclose(bdf);
        }

    // Call cvUpgrade function
        //if (key == 0)
 //     err = cvUpgrade(&Params, &FlashInfo);
        //else {
        //      if ((!strncmp(Params.Models,"DIGITIZERS",1000)) || 
        //              (!strncmp(Params.Models,"V1495",1000)) ) {
        //                      err = KeyInfo(&Params, &FlashInfo);
        //      }
        //}
        if (key ) {
                if ((!strncmp(Params.Models,"DIGITIZERS",1000)) || 
                        (!strncmp(Params.Models,"V1495",1000)) ) {
                                err = KeyInfo(&Params, &FlashInfo);
                }
        } else if (license ) {
                if ((!strncmp(Params.Models,"DIGITIZERS",1000)) || 
                        (!strncmp(Params.Models,"V1495",1000)) ) {
                                err = License(&Params, &FlashInfo);
                }
        } else if (writeKey ) {
                err = WriteKey(&Params, &FlashInfo);
        } else if (fwrel ) {
                err = GetFWRel(&Params, &FlashInfo);
        } else {
      err = cvUpgrade(&Params, &FlashInfo);
          if (err) return err;
        }
    if (err)
        return (CvUpgrade_GenericError);
    else
        return 0;
}