dpcmd.c

#include "dpcmd.h"
#include "ChipInfoDb.h"
#include "FlashCommand.h"
#include "SerialFlash.h"
#include "board.h"
#include "project.h"
#include "usbdriver.h"
#include <fcntl.h>
#include <getopt.h>
#include <pthread.h>
#include <signal.h>
#include <stdlib.h>
#ifdef __FreeBSD__
#include <sys/limits.h>
#endif
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <time.h>
#include <libxml/parser.h>
#include <libxml/tree.h>

#define min(a, b) (a > b ? b : a)

extern unsigned char* pBufferForLastReadData[16];
extern unsigned char* pBufferforLoadedFile;
extern unsigned int g_uiFileChecksum;
extern unsigned long g_ulFileSize;
extern volatile bool g_bIsSF600[16];
extern volatile bool g_bIsSF700[16];
extern volatile bool g_bIsSF600PG2[16]; 
extern unsigned char g_BatchIndex;

unsigned int g_Vcc = vcc3_5V;
unsigned int g_Vpp = 9;
unsigned int g_uiAddr = 0;
size_t g_uiLen = 0;
unsigned int g_ucFill = 0xFF;
unsigned int g_ucTarget = 1;
unsigned int g_uiTimeout = 10000;
unsigned int g_ucSPIClock = clk_12M;
unsigned int g_uiBlink = 0;
unsigned int g_uiDevNum = 0;
//unsigned int g_uiDevSNNum = 0;
unsigned int g_uiDeviceID = 0;
unsigned int g_IO1Select = 0;
unsigned int g_IO4Select = 1;
char g_strTypeName[TYPENAME_MAX_LEN] = "\0";

bool g_bEnableVpp = false;
int g_StartupMode = STARTUP_APPLI_SF_1;
bool g_bStatus = true;

CHIP_INFO g_ChipInfo;
struct CNANDContext g_NANDContext = {{0x111,0x121,0x122,0x141,0x144},  {0x111,0x111,0x111,0x141,0x144},0,0,0,0};
char* l_opt_arg;
struct CAddressRange DownloadAddrRange;
struct CAddressRange UploadAddrRange;
struct CAddressRange LockAddrrange;

unsigned int g_uiLockLen = 0;
unsigned int g_uiLockStart = 0;

char* g_parameter_read = "\0";
char* g_parameter_program = "\0";
char* g_parameter_loadfile_with_verify = "\0";
char* g_parameter_auto = "\0";
char* g_parameter_batch = "\0";
char* g_parameter_fsum = "\0";
char* g_parameter_raw = "\0";
char* g_parameter_raw_return = "\0";
char* g_parameter_addr = "0";
char* g_parameter_length = "\0";
char* g_parameter_fill = "FF";
char* g_parameter_type = "\0";
char* g_parameter_timeout = "300";
char* g_parameter_target = "1";
char* g_parameter_vcc = "NO";
//char* g_parameter_spi_clk="2";

char* g_parameter_blink = "0";
char* g_parameter_fw = "\0";
char g_LogPath[512] = { 0 };
char* g_parameter_special_program = "\0";
char* g_parameter_special_auto = "\0";
char* g_parameter_batch_with_forceerase = "\0";
char* g_parameter_block_index = "\0";
char* g_parameter_block_count = "\0";
char* g_parameter_sparearea_use_file = "\0";
char* g_parameter_skip_bad_block = "\0";
char* g_parameter_file_offset = "\0";
char* g_parameter_internal_ecc = "\0";

/* to address by BUS:DEV; we'll parse the instructions from either the
 * environment or command line options and
 * usbdriver.c:FindUSBDevices() will acknowledge these settings */
extern unsigned g_usb_devnum;
extern unsigned g_usb_busnum;

unsigned long long g_ucOperation;
char g_board_type[8];
char g_FPGA_ver[8];
char g_FW_ver[10];
char g_HW_ver[8];

int g_firmversion;
int g_CurrentSeriase = Seriase_25;
int m_isCanceled = 0;
int m_bProtectAfterWritenErase = 0;
int m_boEnReadQuadIO = 0;
int m_boEnWriteQuadIO = 0;
int g_iNandBadBlockManagement = 0; //0:skip, 1:no management
int g_iNandBlockIndex = 0;
int g_iNandBlockCount = 0;

volatile bool g_is_operation_on_going = false;
bool g_is_operation_successful[16] = { false };
bool g_bDisplayTimer = true;
bool isSendFFsequence = false;
bool g_bSpareAreaUseFile = false;
bool g_bNandForceErase = false;
bool g_bNandInternalECC = true;
bool g_bIsNANDFlash = false;
/* only print timing progress info if this many seconds ellapsed
 * before the last time we did */
//static float g_tv_display_delta_s = 0.5;

//char* const short_options = "?Ldber:p:u:sf:I:R:a:l:vx:T:S:N:B:D:F:V:t:g:c:POik:";
//static const char*    msg_info_unknownoption= "\nError: illegal option.";
//static const char*    msg_err_lengthoverflow_abortion= "\nError: Length parameter exceeding file size, operation aborted\n";
//static const char*    msg_err_addroverflow_abortion  = "\nError: Exceeding chip size, operation aborted\n";
//static const char*    msg_warning_optionignore_al  = "\nWarning: either --addr or --length cannot be used with --auto, will be ignored\n";
//static const char*    msg_err_openfile      = "Error: Failed to open file.\n";

static const char* msg_err_communication = "Error: USB communication error or configuration file missing.\n";
static const char* msg_err_identifychip = "Error: chip not identified or chip is not supported.\n";
static const char* msg_err_timeout_abortion = "\nError: Abort abnormally due to timeout.\n*** You might need to un-plug the USB device to recover the state. ***\n";
static const char* msg_info_loading = "\nLoading file, please wait ...";
static const char* msg_info_checking = "\nChecking, please wait ...";
static const char* msg_info_erasing = "\nErasing, please wait ...";
static const char* msg_info_programming = "\nProgramming, please wait ...";
static const char* msg_info_reading = "\nReading, please wait ...";
static const char* msg_info_scanning = "\nScanning blocks, please wait ...";
static const char* msg_info_auto = "\nAuto Sequences, please wait ...";
static const char* msg_info_verifying = "\nVerifying, please wait ...";
static const char* msg_info_chipblank = "\nThe chip is blank";
static const char* msg_info_chipnotblank = "\nThe chip is NOT blank";
static const char* msg_info_eraseOK = "\nErase OK";
static const char* msg_info_erasefail = "\nError: Erase Failed";
static const char* msg_info_progOK = "\nProgram OK";
static const char* msg_info_progfail = "\nError: Program Failed";
static const char* msg_info_readOK = "\nRead OK";
static const char* msg_info_readfail = "\nRead Failed";
static const char* msg_info_autoOK = "\nAutomatic program OK";
static const char* msg_info_autofail = "\nError: Automatic program Failed";
static const char* msg_info_verifyOK = "\nVerify OK";
static const char* msg_info_verifyfail = "\nError: Verify Failed";
static const char* msg_info_firmwareupdate = "\nUpdating firmware, please wait...";
static const char* msg_info_firmwareupdateOK = "\nUpdate firmware OK";
static const char* msg_info_firmwareupdatefail = "\nError: Update firmware Failed";
static const char* msg_info_scanBBOK = "\nScan Bad Block OK";
static const char* msg_info_scanBBfail    = "\nError: Scan Bad Block Failed";


char* const short_options = "?Ldber:p:u:z:sf:I:R:a:l:vx:T:S:N:B:t:g:c:PO:ik:1:4:U:E:";

struct option long_options[] = {

    { "help", 0, NULL, '?' },
    { "nand-BlockCount ", 1, NULL, 'A' },
    { "blink", 1, NULL, 'B' },
    { "check", 0, NULL, 'C' },
    { "device", 1, NULL, 'D' },
    { "nand-SpareAreaUseFile", 1, NULL, 'E' },
    { "sp", 1, NULL, 'F' },
    { "devnum", 1, NULL, 'G' },
    { "busnum", 1, NULL, 'H' },
    { "raw-instruction", 1, NULL, 'I' },
    { "force-erase", 0, NULL, 'J' },
	{ "se", 0, NULL, 'K' },    
	{ "list", 0, NULL, 'L' },
	{ "su", 1, NULL, 'M' },
	{ "lock-length", 1, NULL, 'N' },
	{ "log", 1, NULL, 'O' },
	{ "vpp", 0, NULL, 'P' },
	{ "nand-BlockIndex", 1, NULL, 'Q' },
    { "raw-require-return", 1, NULL, 'R' },
	{ "lock-start", 1, NULL, 'S' },
    { "type", 1, NULL, 'T' },
	{ "update-fw", 1, NULL, 'U' },
    { "list-device-id", 1, NULL, 'V' },
    { "loadFile-with-verify", 1, NULL, 'W' },
    { "device-SN", 1, NULL, 'X' },
    { "nand-batch-forceerase", 1, NULL, 'Y' },
	{ "nand-skip-bad-block ", 1, NULL, 'Z' },

	{ "addr", 1, NULL, 'a' },
    { "blank", 0, NULL, 'b' },
    { "vcc", 1, NULL, 'c' },
    { "detect", 0, NULL, 'd' },
    { "erase", 0, NULL, 'e' },
    { "fsum", 1, NULL, 'f' },
    { "target", 1, NULL, 'g' },
    { "silent", 0, NULL, 'i' },
	{ "nand-file-offset", 1, NULL, 'j' },
    { "spi-clk", 1, NULL, 'k' },
    { "length", 1, NULL, 'l' },
	{ "nand-internal-ecc ", 1, NULL, 'm' },
	{ "nand-BlockCount", 1, NULL, 'n' },

	{ "prog", 1, NULL, 'p' },
	
    { "read", 1, NULL, 'r' },
	{ "sum", 0, NULL, 's' },
	{ "timeout", 1, NULL, 't' },
    { "auto", 1, NULL, 'u' },
   	{ "verify", 0, NULL, 'v' },
   	
   	{ "fill", 1, NULL, 'x' },
   	
    { "batch", 1, NULL, 'z' },
    
    { "set-io1", 1, NULL, '1' },
    { "set-io4", 1, NULL, '4' },
    { },
};

int OpenUSB(void);
#if 0 
int verbose = 1;

void print_endpoint(struct usb_endpoint_descriptor *endpoint)
{
  printf("      bEndpointAddress: %02xh\n", endpoint->bEndpointAddress);
  printf("      bmAttributes:     %02xh\n", endpoint->bmAttributes);
  printf("      wMaxPacketSize:   %d\n", endpoint->wMaxPacketSize);
  printf("      bInterval:        %d\n", endpoint->bInterval);
  printf("      bRefresh:         %d\n", endpoint->bRefresh);
  printf("      bSynchAddress:    %d\n", endpoint->bSynchAddress);
}

void print_altsetting(struct usb_interface_descriptor *interface)
{
  int i;

  printf("    bInterfaceNumber:   %d\n", interface->bInterfaceNumber);
  printf("    bAlternateSetting:  %d\n", interface->bAlternateSetting);
  printf("    bNumEndpoints:      %d\n", interface->bNumEndpoints);
  printf("    bInterfaceClass:    %d\n", interface->bInterfaceClass);
  printf("    bInterfaceSubClass: %d\n", interface->bInterfaceSubClass);
  printf("    bInterfaceProtocol: %d\n", interface->bInterfaceProtocol);
  printf("    iInterface:         %d\n", interface->iInterface);

  for (i = 0; i < interface->bNumEndpoints; i++)
    print_endpoint(&interface->endpoint[i]);
}

void print_interface(struct usb_interface *interface)
{
  int i;

  for (i = 0; i < interface->num_altsetting; i++)
    print_altsetting(&interface->altsetting[i]);
}

void print_configuration(struct usb_config_descriptor *config)
{
  int i;

  printf("  wTotalLength:         %d\n", config->wTotalLength);
  printf("  bNumInterfaces:       %d\n", config->bNumInterfaces);
  printf("  bConfigurationValue:  %d\n", config->bConfigurationValue);
  printf("  iConfiguration:       %d\n", config->iConfiguration);
  printf("  bmAttributes:         %02xh\n", config->bmAttributes);
  printf("  MaxPower:             %d\n", config->MaxPower);

  for (i = 0; i < config->bNumInterfaces; i++)
    print_interface(&config->interface[i]);
}

int print_device(struct usb_device *dev, int level)
{
  usb_dev_handle *udev;
  char description[256];
  char string[256];
  int ret, i;

  udev = usb_open(dev);
  if (udev) {
    if (dev->descriptor.iManufacturer) {
      ret = usb_get_string_simple(udev, dev->descriptor.iManufacturer, string, sizeof(string));
      if (ret > 0)
        snprintf(description, sizeof(description), "%s - ", string);
      else
        snprintf(description, sizeof(description), "%04X - ",
                 dev->descriptor.idVendor);
    } else
      snprintf(description, sizeof(description), "%04X - ",
               dev->descriptor.idVendor);

    if (dev->descriptor.iProduct) {
      ret = usb_get_string_simple(udev, dev->descriptor.iProduct, string, sizeof(string));
      if (ret > 0)
        snprintf(description + strlen(description), sizeof(description) -
                 strlen(description), "%s", string);
      else
        snprintf(description + strlen(description), sizeof(description) -
                 strlen(description), "%04X", dev->descriptor.idProduct);
    } else
      snprintf(description + strlen(description), sizeof(description) -
               strlen(description), "%04X", dev->descriptor.idProduct);

  } else
    snprintf(description, sizeof(description), "%04X - %04X",
             dev->descriptor.idVendor, dev->descriptor.idProduct);

  printf("%.*sDev #%d: %s\n", level * 2, "                    ", dev->devnum,
         description);

  if (udev && verbose) {
    if (dev->descriptor.iSerialNumber) {
      ret = usb_get_string_simple(udev, dev->descriptor.iSerialNumber, string, sizeof(string));
      if (ret > 0)
        printf("%.*s  - Serial Number: %s\n", level * 2,
               "                    ", string);
    }
  }

  if (udev)
    usb_close(udev);

  if (verbose) {
    if (!dev->config) {
      printf("  Couldn't retrieve descriptors\n");
      return 0;
    }

    for (i = 0; i < dev->descriptor.bNumConfigurations; i++)
      print_configuration(&dev->config[i]);
  } else {
    for (i = 0; i < dev->num_children; i++)
      print_device(dev->children[i], level + 1);
  }

  return 0;
}

int Check(int argc, char *argv[])
{
  struct usb_bus *bus;

  if (argc > 1 && !strcmp(argv[1], "-v"))
    verbose = 1;

  usb_init();

  usb_find_busses();
  usb_find_devices();

  for (bus = usb_busses; bus; bus = bus->next) {
    if (bus->root_dev && !verbose) {
      printf("root device:");
      print_device(bus->root_dev, 0);
    }
    else {
      struct usb_device *dev;

      for (dev = bus->devices; dev; dev = dev->next) {
	printf("non-root device:");
        print_device(dev, 0);
      }
    }
  }

  return 0;
}

#endif

int Sequence()
{
    // *** the calling order in the following block must be kept as is ***
    bool boResult = true;
	if (strstr(g_ChipInfo.ICType, "SPI_NAND") != NULL)
	{
		g_bIsNANDFlash = true;
		FillNANDContext();
	}

	if((g_ucOperation & ERASE) == 0 && (g_ucOperation & SPECIAL_ERASE)==0)
	{     
		boResult = ScanBB(); 
	}

    boResult &= BlankCheck();
    if (boResult == false) {
        if (!(g_ucOperation & ERASE))
            return EXCODE_FAIL_BLANK;
    }
    if ((!((g_ucOperation & BLANK) && (boResult == true)) || (!(g_ucOperation & BLANK)))) {
        boResult = Erase();
        if (boResult == false)
            return EXCODE_FAIL_ERASE;
    }

	boResult &= SpecialErase();
    if (boResult == false)
        return EXCODE_FAIL_PROG;
	
    boResult &= Program();
    if (boResult == false)
        return EXCODE_FAIL_PROG;

	//boResult &= SpecialProgram();
    //if (boResult == false)
    //    return EXCODE_FAIL_PROG;
	
    boResult &= Read();
    if (boResult == false)
        return EXCODE_FAIL_READ;

    boResult &= Auto();
    if (boResult == false)
        return EXCODE_FAIL_BATCH;

    boResult &= CalChecksum();
    if (boResult == true) {
        if (g_ucOperation & CSUM) {
            if (g_uiLen == 0) {
                if (g_uiDevNum == 0)
                    return CRC32(pBufferForLastReadData[0], g_ChipInfo.ChipSizeInByte);
                else
                    return CRC32(pBufferForLastReadData[g_uiDevNum - 1], g_ChipInfo.ChipSizeInByte);
            } else {
                if (g_uiDevNum == 0)
                    return CRC32(pBufferForLastReadData[0], g_uiLen);
                else
                    return CRC32(pBufferForLastReadData[g_uiDevNum - 1], g_uiLen);
            }
        }
    } else
        return EXCODE_FAIL_CHKSUM;

    boResult &= Verify();
    if (boResult == false)
        return EXCODE_FAIL_VERIFY;

    boResult &= LoadFileWithVerify();
    if (boResult == false)
        return EXCODE_FAIL_LOADFILEWITHVERIFY;

    return EXCODE_PASS;
}

void print_message_function(void* ptr)
{
    char* message;
    message = (char*)ptr;
    printf("%s \n", message);
}

void GetLogPath(char* pBuf)
{
    memset(pBuf, 0, 512);
    if (readlink("/proc/self/exe", pBuf, 512) != -1) {
        if (strlen(pBuf) < (511 - sizeof("/log.txt")))
            strcat(pBuf, "/log.txt");
        //		printf("%s\n",pBuf);
    }
}

void EnterStandaloneMode(int Index)
{
    if ((g_bIsSF600[Index] == true) || is_SF700_Or_SF600PG2(Index))
        LeaveSF600Standalone(false, Index);
}

void LeaveStandaloneMode(int Index)
{
    if ((g_bIsSF600[Index] == true) || is_SF700_Or_SF600PG2(Index))
        LeaveSF600Standalone(true, Index);
}

void WriteLog(int ErrorCode, bool Init)
{
    FILE* FileOut = NULL; /* output files */
    time_t rawtime;
    struct tm* timeinfo;
    char buffer[512] = { 0 };
    char* Result[] = {
        " PASS\n",
        " FAIL\n",
        " Erase Fail\n",
        " Program Fail\n",
        " Verify Fail\n",
        " Read Fail\n",
        " Blank Check Fail\n",
        " Auto Batch Fail\n",
        " Checksum Fail\n",
        " Identify Fail\n",
        " Unknow Fail\n"
    };

    time(&rawtime);
    timeinfo = localtime(&rawtime);

    strftime(buffer, 80, "%Y-%b-%d %T", timeinfo);
    if (Init) {
        FileOut = fopen(g_LogPath, "wt");
        if (FileOut != NULL)
            fprintf(FileOut, "%s%s%s", buffer, " USB communication =", Result[ErrorCode]);
    } else {
        FileOut = fopen(g_LogPath, "a+t");
        if (FileOut != NULL)
            fprintf(FileOut, "%s%s", buffer, Result[ErrorCode]);
    }

    if (FileOut != NULL)
        fclose(FileOut);
}

int GetConfigVer()
{
#if 1
	char file_path[512];
	xmlDocPtr    doc;
	xmlNodePtr   cur_node;
	xmlChar      *chip_attribute;
	int Ver = 0;
	
	if (GetChipDbPath(file_path) == false)
	{
        return 1;
	}
  
	doc = xmlParseFile(file_path);
	cur_node = xmlDocGetRootElement(doc); // DediProgChipDatabase
	while (cur_node != NULL) {
      if ((!xmlStrcmp(cur_node->name, (const xmlChar *)"DediProgChipDatabase"))) {
	  	chip_attribute = xmlGetProp(cur_node, (const xmlChar *)"Ver");
		Ver = strtol((char*)chip_attribute, NULL, 10);
	    xmlFree(chip_attribute);
      	}
	  	
	  	cur_node = cur_node->next;
	}
	xmlFreeDoc(doc);
	return Ver;
#else
    char file_line_buf[512];
    char test[80];
    char *pch, *tok;
    bool bFound = 0;
    int Ver = 0;
    FILE* fp; /*Declare file pointer variable*/

    if ((fp = openChipInfoDb()) == NULL)
        return 1;

    while (fgets(file_line_buf, 512, fp) != NULL) {
        if (strstr(file_line_buf, "DediProgChipDatabase") && bFound == 0)
            bFound = 1;

        pch = strstr(file_line_buf, "Ver");
        if (bFound == 1 && pch != NULL) {
            memset(test, '\0', 80);
            strcpy(test, pch + strlen("Ver"));
            tok = strtok(test, "\"= \t");
            Ver = strtol(tok, NULL, 10);
            break;
        }
    }
    fclose(fp);
    return Ver;
#endif
}

int main(int argc, char* argv[])
{
#if 0 //Check all USB device capability   //evy test SF700
	Check(argc,argv);
	return;

#endif
    int c;
	int temp = 0;
    int iExitCode = EXCODE_PASS;
    bool bDetect = false;
    bool bDevice = false;
    bool bDeviceSN = false;
    unsigned long r;
    char* env;

    printf("\nDpCmd %s 1.14.22.%02d Engine Version:\nLast Built on %s\n\n",
#if defined(__APPLE__)
           "macOS",
#elif defined(__FreeBSD__)
           "FreeBSD",
#elif defined(__linux__)
           "Linux",
#else
           "Unknown",
#endif
           GetConfigVer(), __DATE__); // 1. new feature.bug.configS

    g_ucOperation = 0;
    GetLogPath(g_LogPath);

    if (argc == 1) {
        cli_classic_usage(false);
        return 0;
    }
	if (ListTypes())
			return EXCODE_PASS;

    /*
     * Obtain the (optional) bus number and device number to
     * filter by from the environment.
     *
     * Why? Because the OpenUSB() initialization happens *before*
     * the command line options are parsed (where we'd take
     * --busnum and --devnum) and we want to enable a path to
     * disallow the tool from touching any device which is not the
     * one we want to.
     *
     * In the long term, rearranging the code would allow getting
     * rid of this hack.
     */
    env = getenv("DPCMD_USB_DEVNUM");
    if (env) {
        r = strtoul(env, NULL, 10);
        if (r == ULONG_MAX || r >= 256) {
            fprintf(stderr, "E: invalid USB device number in"
                            " DPCMD_USB_DEVNUM; expected 1-255\n");
            return 1;
        }
        g_usb_devnum = (unsigned char)r;
    }

    env = getenv("DPCMD_USB_BUSNUM");
    if (env) {
        r = strtoul(env, NULL, 10);
        if (r == ULONG_MAX || r >= 256) {
            fprintf(stderr, "E: invalid USB bus number in"
                            " DPCMD_USB_BUSNUM\n");
            return 1;
        }
        g_usb_busnum = (unsigned char)r;
    }

    if (OpenUSB() == 0)
        iExitCode = EXCODE_FAIL_USB;

    LeaveStandaloneMode(0);
    QueryBoard(0);

    while ((c = getopt_long(argc, argv, short_options, long_options, NULL)) != -1) {
        switch (c) {
        case '?':
            cli_classic_usage(true);
            CloseProject();
            ExitProgram();
            return EXCODE_PASS;
        case 'L':
            g_ucOperation |= LIST_TYPE;
            break;
        case 'd':
            bDetect = true;
            break;
        case 'C':
            g_ucOperation |= CHECK_INFO;
            break;
        case 'b':
            g_ucOperation |= BLANK;
            break;
        case 'e':
            g_ucOperation |= ERASE;
            break;
        case 'r':
            g_parameter_read = optarg;
            g_ucOperation |= READ_TO_FILE;
            break;
        case 'p':
            g_parameter_program = optarg;
            g_ucOperation |= PROGRAM; 
            break;
        case 'u':
            g_parameter_auto = optarg;
            g_ucOperation |= BATCH;
            g_BatchIndex = 2; 
            break;
        case 'z':
            g_parameter_batch = optarg;
            g_ucOperation |= BATCH;
            g_BatchIndex = 1; 
            break;
        case 's': // display chip checksum
            g_ucOperation |= CSUM;
            break;
        case 'f': //display file checksum
            g_parameter_fsum = optarg;
            g_ucOperation |= FSUM;
            break;
        case 'I':
            g_parameter_raw = optarg;
            break;
        case 'R': //raw-require-return
            g_parameter_raw_return = optarg;
            break;
            /* Optional Switches that add fine-tune ability to Basic Switches: */
        case 'a':
            g_parameter_addr = optarg;
            g_uiAddr = 0;
            sscanf(optarg, "%x", &g_uiAddr);
            break;
        case 'l':
            g_uiLen = 0;
            if (strstr(optarg, "0x"))
                sscanf(optarg, "%zx", &g_uiLen);
            else
                sscanf(optarg, "%zu", &g_uiLen);
            break;
        case 'v':
            g_ucOperation |= VERIFY;
            break;
        case 'x':
            g_ucFill = 0xFF;
            sscanf(optarg, "%x", &g_ucFill);
            break;
        case 'T':
            g_parameter_type = optarg; //type
            break;
        case 'S': //lock start
            sscanf(optarg, "%x", &g_uiLockStart);
            //                l_opt_arg = optarg;
            //             printf("hexadecimal starting address (with arg: %s)\n", l_opt_arg);
            break;
        case 'N': //lock length
            sscanf(optarg, "%x", &g_uiLockLen); 
            break;
        case 'B':
            sscanf(optarg, "%d", &g_uiBlink);
            g_ucOperation |= BLINK;
            break;
        case 'D': // device
            bDevice = true;
            sscanf(optarg, "%x", &g_uiDevNum);
            break;
        case 'X': // device-SN
            l_opt_arg = optarg;
            //printf("activate only the programmer connected to USBx (with arg: %s)\n", l_opt_arg);

            bDeviceSN = true;
            break;
        case 'W':
            //	l_opt_arg = optarg;
            //	printf("Fix programmer serial number with programmer sequence. (with arg: %s)\n", l_opt_arg);
            //	break;
            g_parameter_loadfile_with_verify = optarg;
            g_ucOperation |= LOADFILEWITHVERIFY; 
            break;
        case 'V':
            sscanf(optarg, "%d", &g_uiDeviceID);
            g_ucOperation |= DEVICE_ID; //list device id
            break;
            /* Miscellaneous options: */
        case 't':
            l_opt_arg = optarg;
            sscanf(l_opt_arg, "%d", &g_uiTimeout);
            break;
        case 'g':
            g_parameter_target = optarg;
            sscanf(optarg, "%d", &g_ucTarget);
            break;
        case 'c':
            g_parameter_vcc = optarg;
            sscanf(optarg, "%d", &g_Vcc);
            break;
        case 'P':
            g_bEnableVpp = true;
            break;
        case 'O': //Log file
            strcpy(g_LogPath, optarg);
            //					printf("%s\n",g_LogPath);
            break;
        case 'i':
            g_bDisplayTimer = false;
            break;
        case 'k':
            l_opt_arg = optarg;
            sscanf(l_opt_arg, "%d", &g_ucSPIClock);
            break;
        case '1':
            l_opt_arg = optarg;
            sscanf(l_opt_arg, "%d", &g_IO1Select);
            break;
        case '4':
            l_opt_arg = optarg;
            sscanf(l_opt_arg, "%d", &g_IO4Select);
            break;
        case 'U':
            g_parameter_fw = optarg;
            iExitCode = FirmwareUpdate();
            goto Exit;
            break;
#if 0
        case 'E':
            g_tv_display_delta_s = atof(optarg);
            if (g_tv_display_delta_s <= 0) {
                fprintf(stderr, "E: invalid number"
                                " of seconds for display delta"
                                " (%f); expect larger than"
                                " zero\n",
                    g_tv_display_delta_s);
                return 1;
            }
            break;
#endif
        case 'G':
            r = strtoul(optarg, NULL, 10);
            if (r == ULONG_MAX || r >= 256) {
                fprintf(stderr, "E: invalid device"
                                " number; expected 1-255\n");
                return 1;
            }
            g_usb_devnum = (unsigned char)r;
            break;
        case 'H':
            r = strtoul(optarg, NULL, 10);
            if (r == ULONG_MAX) {
                fprintf(stderr, "E: invalid bus"
                                " number\n");
                return 1;
            }
            g_usb_busnum = (unsigned)r;
            break;
		//SPI NAND
		case 'E':
			g_parameter_sparearea_use_file = optarg;
			sscanf(g_parameter_sparearea_use_file, "%d", &temp);
			g_bSpareAreaUseFile = ((temp==0)? false:true);
            break;
		case 'F':
			g_parameter_special_program = optarg;
			g_ucOperation |= SPECIAL_PROGRAM;
			break;
		case 'J':
			g_bNandForceErase = true;
			g_ucOperation |= ERASE;
			break;
		case 'K':
			g_bNandForceErase = false;
			g_ucOperation |= SPECIAL_ERASE;
			break;
		case 'M':
			g_parameter_special_auto = optarg;
			g_ucOperation |= SPECIAL_AUTO;
			break;
		case 'Q':
			g_parameter_block_index = optarg;
			sscanf(g_parameter_block_index, "%d", &g_iNandBlockIndex);
			break;
		case 'Y':
			g_parameter_batch_with_forceerase = optarg;
			g_ucOperation |= BATCH_WITH_FORCEERASE;
			break;
		case 'Z':
			g_parameter_skip_bad_block = optarg;
			sscanf(g_parameter_skip_bad_block, "%d", &g_iNandBadBlockManagement);
			break;
		case 'j':
			g_parameter_file_offset = optarg;
			break;
		case 'm':
			g_parameter_internal_ecc = optarg;
			sscanf(g_parameter_internal_ecc, "%d", &temp);
			g_bNandInternalECC = ((temp == 0)? true:false);
			break;
		case 'n':
			g_parameter_block_count = optarg;
			sscanf(g_parameter_block_count, "%d", &g_iNandBlockCount);
			break;
        default:
            break;
        }
    }

    int dev_cnt = get_usb_dev_cnt();

    if (CheckProgrammerInfo()) {
        iExitCode = EXCODE_PASS;
        goto Exit;
    }

    if (bDetect == true) {
        if (bDevice == false) {
            if (bDeviceSN) {
                char* arg_temp = &l_opt_arg[2];
                int arg_int = atoi(arg_temp);

                for (int i = 0; i < dev_cnt; i++) {
                    int dwUID = ReadUID(i);
                    if (arg_int == dwUID) {
                        g_uiDevNum = i + 1;
                        break;
                    }
                }
                int dwUID = ReadUID(g_uiDevNum - 1);
                if (is_SF700_Or_SF600PG2(g_uiDevNum - 1)) {
		    		if (g_bIsSF700[g_uiDevNum - 1] == true) {
                        printf("\nDevice %d (SF7%05d):\tdetecting chip\n", g_uiDevNum, dwUID);
                    } else if (g_bIsSF600PG2[g_uiDevNum - 1] == true) {
                        printf("\nDevice %d (S6B%05d):\tdetecting chip\n", g_uiDevNum, dwUID);
		    	}
                } else if ((g_bIsSF600[g_uiDevNum - 1] == true) && (dwUID / 600000) > 0) {
                    printf("\nDevice %d (SF%06d):\tdetecting chip\n", g_uiDevNum, dwUID);
                } else if ((dwUID / 100000) > 0) {
                    printf("\nDevice %d (SF%06d):\tdetecting chip\n", g_uiDevNum, dwUID);
                } else {
                    printf("\nDevice %d (DP%06d):\tdetecting chip\n", g_uiDevNum, dwUID);
                }
                WriteLog(iExitCode, true);
                g_ChipInfo = GetFirstDetectionMatch(g_strTypeName, g_uiDevNum - 1);
                if (g_ChipInfo.UniqueID != 0) {
                    if (strlen(g_strTypeName)) {
                        printf("By reading the chip ID, the chip applies to [ %s ]\n\n", g_strTypeName);
                        printf("%s chip size is %zd bytes.\n", g_ChipInfo.TypeName, g_ChipInfo.ChipSizeInByte);
                    } else {
                        printf("%s", msg_err_identifychip);
                        iExitCode = EXCODE_FAIL_IDENTIFY;
                    }
                } else {
                    printf("%s", msg_err_identifychip);
                    iExitCode = EXCODE_FAIL_IDENTIFY;
                }
            } else {
                for (int i = 0; i < dev_cnt; i++) {
                    //printf("%s\n",g_LogPath);

                    int dwUID = ReadUID(i);
                    if (is_SF700_Or_SF600PG2(i)) {
			if (g_bIsSF700[i] == true) {
                            printf("\nDevice %d (SF7%05d):\tdetecting chip\n", i + 1, dwUID);
                        } else if (g_bIsSF600PG2[i] == true) {
                            printf("\nDevice %d (S6B%05d):\tdetecting chip\n", i + 1, dwUID);
			}
                    } else if ((g_bIsSF600[i] == true) && (dwUID / 600000) > 0) {
                        printf("\nDevice %d (SF%06d):\tdetecting chip\n", i + 1, dwUID);
                    } else if ((dwUID / 100000) > 0) {
                        printf("\nDevice %d (SF%06d):\tdetecting chip\n", i + 1, dwUID);
                    } else {
                        printf("\nDevice %d (DP%06d):\tdetecting chip\n", i + 1, dwUID);
                    }
                    WriteLog(iExitCode, true);
                    g_ChipInfo = GetFirstDetectionMatch(g_strTypeName, i);
					//printf("type = %s\n\r",g_ChipInfo.ICType);
                    if (g_ChipInfo.UniqueID != 0) {
                        if (strlen(g_ChipInfo.TypeName/* g_strTypeName*/)) {
                            printf("By reading the chip ID, the chip applies to [ %s ]\n", g_strTypeName);
                            printf("%s chip size is %zd bytes.\n", g_ChipInfo.TypeName, g_ChipInfo.ChipSizeInByte);
                        } else {
                            printf("%s", msg_err_identifychip);
                            iExitCode = EXCODE_FAIL_IDENTIFY;
                        }
                    } else {
                        printf("%s", msg_err_identifychip);
                        iExitCode = EXCODE_FAIL_IDENTIFY;
                    }
                }
            }
        } else if (g_uiDevNum != 0) {
            WriteLog(iExitCode, true);
            printf("%d,\tdetecting chip\n", g_uiDevNum);
            g_ChipInfo = GetFirstDetectionMatch(g_strTypeName, g_uiDevNum - 1);

            if (g_ChipInfo.UniqueID != 0) {
                //printf("strlen(g_strTypeName)=%ld\n",strlen(g_strTypeName));
                if (strlen(g_strTypeName)) {
                    printf("  \tBy reading the chip ID, the chip applies to [ %s ]\n\n", g_strTypeName);
                    printf("  \t%s chip size is %zd bytes.\n", g_ChipInfo.TypeName, g_ChipInfo.ChipSizeInByte);
                } else {
                    printf("%s", msg_err_identifychip);
                    iExitCode = EXCODE_FAIL_IDENTIFY;
                }
            } else {
                printf("%s", msg_err_identifychip);
                iExitCode = EXCODE_FAIL_IDENTIFY;
            }
        } else {
            printf("The number of programmer is not defined!\n");
            iExitCode = EXCODE_FAIL_IDENTIFY;
        }
        goto Exit;
    } else {
        if (bDeviceSN) {
            char* arg_temp = &l_opt_arg[2];
            int arg_int = atoi(arg_temp);

            for (int i = 0; i < dev_cnt; i++) {
                int dwUID = ReadUID(i);
                if (arg_int == dwUID) {
                    g_uiDevNum = i + 1;
                    break;
                }
            }
        }
        WriteLog(iExitCode, true);
    }
	
    if (iExitCode != EXCODE_PASS)
        goto Exit;
    iExitCode = Handler();

Exit:
    printf("\n\n");
    CloseProject();
    ExitProgram();
    WriteLog(iExitCode, false);
    return iExitCode;
}

void ExitProgram(void)
{
    for (int i = 0; i < get_usb_dev_cnt(); i++) {
        if (pBufferForLastReadData[i] != NULL)
            free(pBufferForLastReadData[i]);
    }

    if (pBufferforLoadedFile != NULL)
        free(pBufferforLoadedFile);
}

int FirmwareUpdate()
{
    FW_INFO Data;
    FILE* pFile;
    size_t result, filesize;
    int fwVer;
    //	unsigned char vBuffer[8] ;
    int fw[3];

    pFile = fopen(g_parameter_fw, "rb");
    if (pFile == NULL) {
        printf("Can not open %s \n", g_parameter_fw);
        return EXCODE_FAIL_UPDATE_FW;
    }

    // obtain file size:
    fseek(pFile, 0, SEEK_END);
    filesize = ftell(pFile);
    if (filesize < sizeof(FW_INFO)) {
        printf("File %s too small.\n", g_parameter_fw);
        return -1;
    }
    fseek(pFile, 0, SEEK_SET);
    //    rewind (pFile);

    // copy the file into the buffer:
    result = fread((unsigned char*)&Data, 1, sizeof(FW_INFO), pFile);
    if (result != sizeof(FW_INFO)) {
        printf("File %s read problem.\n", g_parameter_fw);
        return -1;
    }
    fclose(pFile);

    if (Data.dwSignature != 0x44504657) {
        printf("This file is not DediProg firmware format.\n");
        return EXCODE_FAIL_UPDATE_FW;
    }
    sscanf(&Data.Version[0], "%d.%d.%d", &fw[0], &fw[1], &fw[2]);
    fwVer = ((fw[0] << 16) | (fw[1] << 8) | fw[2]);

    printf("Current Firmware is %x, New Firmware Version is %x\n", g_firmversion, fwVer);

    if (strstr(g_board_type, Data.Programmer) == NULL)
        printf("Error: This firmware for %s!\n", Data.Programmer);

    if ((strstr(g_board_type, Data.Programmer) == NULL) || ((fwVer & 0xff0000) != (g_firmversion & 0xff0000))) {
        printf("Error: This firmware can not be updated on this programmer!\n");
        return EXCODE_FAIL_UPDATE_FW;
    }

    printf("%s", msg_info_firmwareupdate);
    Run(UPDATE_FIRMWARE, g_uiDevNum);

    if (Wait(msg_info_firmwareupdateOK, msg_info_firmwareupdatefail))
        return 0;

    return 0;
}

void cli_classic_usage(bool IsShowExample)
{
    printf("Basic Usages:\n");
    printf("./dpcmd -uxxx\n");
    printf("./dpcmd --auto=xxx\n");
    if (IsShowExample)
        printf("Usage Examples:\n"
               "1. dpcmd -r\"f:\\file.bin\", \n    reads the chip and save it into a file \"file.bin\"\n"
               "2. dpcmd -rSTDOUT -a0x100 -l0x23, \n    reads 0x23 bytes starting from 0x100 and display it on the screen\n"
               "3. dpcmd -ufile.bin, \n    Update the whole chip with file.bin\n"
               "4. Dpcmd -ufile.bin -a0x100, \n    Replace the serial flash contents for the size of file.bin with file.bin.\n"
               "    (contents outside the replace area will be kept unchanged)\n"
               "5. dpcmd -pfile.bin -a0x100, \n    program file.bin into the serial flash starting from address 0x100\n"
               "    (the target area is assumed to be blank already)\n"
               "6. dpcmd -pfile.bin -x0xaa, \n    programs file.bin into the serial flash and fill the rest area with 0xaa\n"
               "    (the target area is assumed to be blank already)\n"
               "Remark: -a, -l only works with -p, -r, -s and -u\n"
               "Remark: -x only works with -p");

    printf("(space is not needed between the switches and parameters. E.g. dpcmd -ubio.bin)\n");
	printf("SPI NOR : Basic Switches(switches in this group are mutual exclusive):\n");
    printf("    -? [ --help ]                           show this help message\n"
           "    --list                                  print supported chip list\n"
           "    --check        			    get programmer information\n"
           "    -d [ --detect ]                         detect chip\n"
           "    -b [ --blank ]                          blank check\n"
           "    -e [ --erase ]                          erase entire chip\n"
           "    -r [ --read ] arg                       read chip contents and save to a bin/hex/s19 file\n"
           "    -p [ --prog ] arg                       program chip without erase\n"
           "    -u [ --auto ] arg                       automatically run the following sequence:\n"
           "                                            - Read the memory content\n"
           "                                            - Compare the memory content\n"
           "                                            - Erase only the sectors with some differences\n"
           "                                            - Program only the erased sectors with file data from address 0\n"
           "    -z [ --batch ] arg                      automatically run the following sequence:\n"
           "                                            - check if the chip is blank or not;\n"
           "                                            - erase the entire chip(if not blank);\n"
           "                                            - program a whole file starting from address 0\n"
           "    -s [ --sum ]                            display chip content checksum\n"
           "    -f [ --fsum ] arg                       display the file checksum\n"
           "    --raw-instruction arg                   issue raw serial flash instructions.\n"
           "                                            - use spaces("
           ") to delimite bytes.\n"
           "                                            - instructions must be enclosed in double quotation marks(\"\")\n"
           "                                            Example:\n"
           "                                            dpcmd --raw-instruction \"03 FF 00 12\"\n"
           "    --raw-require-return arg (=0)           decimal bytes of result to return in decimal\n"
           "                                            after issuing raw instructions.\n"
           "                                            - used along with --raw-instruction only.\n"
           "                                            Example:\n"
           "                                            dpcmd --raw-instruction \"03 FF 00 12\" \n"
           "                                            --raw-require-return 1\n"
           "                                            dpcmd --raw-instruction \"06|01 0C|05\"  \n"
           "                                            --raw-require-return \"0|0|1\"	\n"
           "\n"
           "SPI NOR : Optional Switches that add fine-tune ability to Basic Switches:\n"
           "    -a [ --addr ] arg                       hexadecimal starting address hexadecimal(e.g.\n"
           "                                            0x1000),\n"
           "                                            - works with --prog/read/sum/auto only\n"
           "                                            - defaults to 0, if omitted.\n"
           "    -l [ --length ] arg                     decimal/hexadecimal length to read/program in bytes,\n"
           "                                            - works with --prog/read/sum/auto only\n"
           "                                            - defaults to whole file if omitted\n"
           "    -v [ --verify ]                         verify checksum file and chip\n"
           "                                            - works with --prog/auto only\n"
           "    -x [ --fill ] arg (=FF)                 fill spare space with an hex value(e.g.FF),\n"
           "                                            - works with --prog, --auto only\n"
           "    --type arg                              Specify a type to override auto detection\n"
           "                                            - use --list arguement to look up supported type.\n"
           "    --lock-start arg                        hexadecimal starting address(e.g. 0x1000),\n"
           "                                            - works with --auto/lock-length\n"
           "                                            - defaults to 0, if omitted.\n"
           "    --lock-length arg                       hexadecimal length of area that will be kept\n"
           "                                            unchanged while updating\n"
           "                                            - used along with --auto/lock-start only.\n"
           "    --blink arg                             \n"
           //	       "                                            - 0 : Blink green LED 3 times from USB1 to USBn\n"
           //	       "                                            (Default)\n"
           //	       "                                            note: the sequence is assigned by OS during USB plug-in\n"
           "                                            - 1: Blink the programmer connected to USB1 3 times.\n"
           //	       "                                            - n: Blink the programmer connected to USBn 3 times.\n"
           "    --device arg                            (work with all Basic Switchs)\n"
           //	       "                                            - 1: activate only the programmer connected to USB1\n"
           //	       "                                            - n: activate only the programmer connected to USBn\n"
           //	       "                                            note: if '--device' is not used, the command will\n"
           //	       "                                            be executed on all connected programmer.\n"
           //	       "    --fix-device arg                        Fix programmer serial number with programmer sequence.\n"
           //	       "                                            - instructions must be enclosed in double quotation marks(\"\")\n"
           //	       "                                            Example:\n"
           //	       "                                            dpcmd --fix-device \"1 DP000001\"\n"
           "    --list-device-id arg                    \n"
           //	       "                                            - 0 : List all ID of programmers from USB1 to USBn (Default)\n"
           //	       "                                            note: the sequence is assigned by OS during USB plug-in.\n"
           "                                            - 1: Prompt the device ID of programmer connected to USB1.\n"
           //	       "                                            - n: Prompt the device ID of programmer connected to USBn.\n"
           "    --loadFile-with-verify arg                         -Load a bin/hex/s19 file and verify with the memory conten.\n"
           "\n"
           "SPI NOR : Miscellaneous options:\n"
           "    -t [ --timeout ] arg (=300)             Timeout value in seconds\n"
           "    -g [ --target ] arg (=1)                Target Options\n"
           "                                            Available values:\n"
           "                                                1, Chip 1(Default)\n"
           "                                                2, Chip 2\n"
           "                                                3, Socket\n"
           "                                                0, reference card\n"
           "    --vcc arg (=0)                          specify vcc\n"
           "                                                0, 3.5V\n"
           "                                                1, 2.5V\n"
           "                                                2, 1.8V\n"
           "                                                1800 ~ 3800, 1.8V ~ 3.8V\n"
           "                                                (minimum step 100mV)(For SF600/SF600Plus only)\n"
           "    --vpp                                   apply vpp when the memory chip supports it\n"
           "    --log arg                               Record the operation result in given/appointed .txt file\n"
           "                                            Example:\n"
           "                                            ./dpcmd --log /tmp/log.txt\n"
           "                                            Note: If user didn't use this command, \n"
           "                                                  the operation result will be recorded in \"log.txt\"\n"
           "                                            - work with --prog and --erase.\n"
           "    -i [ --silent ]                         supress the display of real-time timer counting\n"
           "                                            - used when integrating with 3rd-party tools(e.g. IDE)\n"
           "    --spi-clk arg (=2)                      specify SPI clock:\n"
           "                                                2, 12 MHz(Default)\n"
           "                                                0, 24 MHz\n"
           "                                                1, 8 MHz\n"
           "                                                3, 3 MHz\n"
           "                                                4, 2.18 MHz\n"
           "                                                5, 1.5 MHz\n"
           "                                                6, 750 KHz\n"
           "                                                7, 375 KHz\n"
           "    --set-io1 arg (=0)                      specify Level of IO1(SF100) or GPIO1(SF600/SF600Plus):\n"
           "                                                0, Low(Default)\n"
           "                                                1, High\n"
           "    --set-io4 arg (=1)                      specify Level of IO4(SF100) or GPIO2(SF600/SF600Plus):\n"
           "                                                0, Low\n"
           "                                                1, High(Default)\n"
           "    -E [ --display-delta ] arg (=0.5)       wait this many seconds\n"
           "                                            before refreshing the screen\n"
           "\n"
           "SPI NAND : Basic Switches(switches in this group are mutual exclusive):\n"
           "    -h [ --help ]                           show this help message\n"
	  "    --blink arg							 \n"
			   //		   "											- 0 : Blink green LED 3 times from USB1 to USBn\n"
			   //		   "											(Default)\n"
	   //		   "											note: the sequence is assigned by OS during USB plug-in\n"
           "                                            - 1: Blink the programmer connected to USB1 3 times.\n"
           "     --list                                 print supported chip list\n"
           "    -c [ --check ]                          check programmer information\n" 
           "    -d [ --detect ]                         detect chip\n" 
           "    -b [ --blank ]                          blank check\n" 
           "    -e [ --erase ]                          erase entire chip\n" 
           "    --force-erase                           enable hard copy erase\n" 
           "    -r [ --read ] arg                       read chip contents and save to a bin/hex/s19 file\n"
           "                                            - use STDOUT for the console.\n" 
           "    -p [ --prog ] arg                       program chip without erase\n" 
           "    -z [ --batch ] arg\n"
           "                                            automatically run the following sequence:\n"
           "                                            - check if the chip is blank or not;\n"
           "                                            - erase the chip memory which skip bad block(if\n"
           "                                             not blank);\n"
           "                                            - program a whole file starting from address 0\n"
   /*        "    --se                                    erase entire chip and mark a new bad block, if\n"
           "                                            bad block is generated during erase\n"
           "    --sp arg                                 program chip without erase\n"
           "                                            and mark a new bad block, if bad block is\n"
           "                                            generated during programming\n"
           "                                            - instructions must be enclosed in double\n"
           "                                            quotation marks(\"\")\n"
           "                                            - use \"|\" to load partition file and data file\n"
           "                                            Example:\n"
           "                                            dpcmd --sp \"xxx.dpmbn|aaa.bin\"\n"
           "    --su arg                                automatically run the following sequence:\n"
           "                                            - Erase only the blocks with data length and mark\n"
           "                                            a new bad block\n"
           "                                            - Program only the erased blocks with the file\n"
           "                                            data from address 0\n"
           "                                            or according to partition file\n"
           "                                            - instructions must be enclosed in double\n"
           "                                            quotation marks(\"\")\n"
           "                                            - use \"|\" to load partition file and data file\n"
           "                                            Example:\n"
           "                                            dpcmd --su \"xxx.dpmbn|aaa.bin\"\n"
           "                                            --nand-batch-forceerase arg automatically run the following sequence:\n"
           "                                            - check if the chip is blank or not;\n"
           "                                            - force erase the entire chip(if not blank);\n"
           "                                            - program a whole file starting from address 0\n"*/
           "    -s [ --sum ]                            display chip content checksum\n"
           "    -f [ --fsum ] arg                       display the file checksum\n"
           "                                            - needs to work with a file\n"
           "    --raw-instruction arg                   issue raw serial flash instructions.\n"
           "                                            - use spaces(\" \") to delimit bytes.\n"
           "                                            - instructions must be enclosed in double\n"
           "                                            quotation marks(\"\")\n"
           "                                            - use \"|\" to send continuous command\n"
           "                                            Example:\n"
           "                                            ./dpcmd --raw-instruction 06\n"
           "                                            ./dpcmd --raw-instruction \"06|02 00 00 00 11 22 33\"\n"
           "    --raw-require-return arg                decimal bytes of result to return in decimal\n"
           "                                            after issuing raw instructions.\n"
           "                                            - used along with --raw-instruction only.\n"
           "                                            Example:\n"
           "                                            dpcmd --raw-instruction \"03 FF 00 12\" --raw-require-return 1\n"
           "                                            dpcmd --raw-instruction \"06|05\" --raw-require-return \"0|2\"\n"
           "    --loadFile-with-verify arg             Load a bin/hex/s19 file and compare with memory\n"
           "                                            content\n"
           "                                            Example:\n"
           "                                            ./dpcmd --loadFile-with-verify d:\\xxx.bin\n"

           "SPI NAND : Optional Switches that add fine-tune ability to Basic Switches:\n"
           "    -v [ --verify ]                         verify checksum file and chip\n"
           "                                            - works with --prog/batch only\n"
           "    --type arg                              Specify a type to override auto detection\n"
           "                                            - use --list arguement to look up supported type.\n"
       //    "    --read-id             read chip id\n"
          // "             - return chip id only\n"

           "SPI NAND : Miscellaneous options:\n"
           "    -t [ --timeout ] arg (=1000)            Timeout value in seconds. Default value is\n"
           "                        1000s.\n"
           "    -g [ --target ] arg (=1)                Target Options\n"
           "                                            Available values:\n"
           "                                                1, Chip 1(Default)\n"
           "                                                2, Chip 2\n"
           "                                                3, Socket\n"
           "                                                0, reference card\n"
           "    -i [ --silent ]                         suppress the display of real-time timer counting\n"
           "                                            - used when integrating with 3rd-party tools\n"
           "                                            (e.g. IDE)\n"
           "    --vcc arg                               specify vcc(SF600Plus-G2 / Others)\n"
           "                                                0, 3.3V / 3.5V\n"
           "                                                1, 2.5V / 1.2V\n"
           "                                                2, 1.8V / 1.8V\n"
           "                                                3, 1.2V / 1.2V\n"
           "                                                1200 ~ 3800, 1.2V ~ 3.8V (minimum step\n"
           "                                                100mV)\n"
           "    --spi-clk arg (=2)                      specify SPI clock:\n"
           "                                                2, 12MHz (Default)\n"
           "                                                0, 25MHz\n"
           "                                                1, 6MHz\n"
           "                                                3, 4MHz\n"
           "                                                4, 2MHz\n"
           "                                                5, 1MHz\n"
           "                                                6, 800KHz\n"
           "                                                7, 400KHz\n"
           "    -i [ --silent ]                         suppress the display of real-time timer counting\n"
           "                                            - used when integrating with 3rd-party tools\n"
           "                                            (e.g. IDE)\n"
           "    --set-io1 arg (=0)                      specify Level of IO1(SF100) or GPIO1(SF600/S\n"
           "                                            F600Plus):\n"
           "                                                0, Low(Default)\n"
           "                                                1, High\n"
           "    --set-io4 arg (=1)                      specify Level of IO4(SF100) or GPIO2(SF600/S\n"
           "                                            F600Plus):\n"
           "                                                0, Low\n"
           "                                                1, High(Default)\n"
           "    --nand-BlockIndex arg (=0)              Decimal starting address Decimal(e.g. 512),\n"
           "                                            - defaults to 0, if omitted.\n"
           "    --nand-BlockCount arg (=0)              Decimal starting address Decimal(e.g. 200),\n"
           "                                            - defaults to whole file if omitted.\n"
           "    --nand-SpareAreaUseFile arg (=0)        specify if the Spare Area use file:\n"
           "                                                0, Unuse(Default)\n"
           "                                                1, True\n"
           "    --nand-skip-bad-block arg (=0)          specify if the Bad Block(s) are skipped:\n"
           "                                                0, Skip(Default)\n"
           "                                                1, No management\n"
           "    --nand-file-offset arg (=0)             specify the file offset number\n"
           "    --nand-internal-ecc arg (=0)            specify if the Internal ECC enable:\n"
           "                                                0, Enable(Default)\n"
           "                                                1, Disable\n"
           "Environment variables:\n"
           "  Specify DPCMD_USB_BUSNUM and DPCMD_USB_DEVNUM to ensure the tool touches only said device. Numbers can be found with tools such as lsusb and others.\n"
           "    - DPCMD_USB_BUSNUM                      Number of USB bus where device is\n"
           "    - DPCMD_USB_DEVNUM                      Number of device in USB bus\n"
           "\n\n\n");
}

int OpenUSB(void)
{
    return usb_driver_init();
}

void sin_handler(int sig)
{
    if (sig == SIGINT) {
        ;
    }
}

void FillNANDContext(void)
{
	g_NANDContext.realSpareAreaSize = ( g_bNandInternalECC==true? (g_ChipInfo.SpareSizeInByte & 0xFFFF):((g_ChipInfo.SpareSizeInByte>>16) & 0xFFFF));
	g_NANDContext.realPageSize = g_NANDContext.realSpareAreaSize+g_ChipInfo.PageSizeInByte;
	g_NANDContext.realBlockSize = g_ChipInfo.BlockSizeInByte/g_ChipInfo.PageSizeInByte*g_NANDContext.realPageSize;
	g_NANDContext.realChipSize = g_NANDContext.realBlockSize*g_ChipInfo.ChipSizeInByte/g_ChipInfo.BlockSizeInByte;
	memcpy(&g_NANDContext.EraseCmd,&g_ChipInfo.EraseCmd, sizeof(unsigned int));
	memcpy(&g_NANDContext.ReadCmd,&g_ChipInfo.ReadCmd, sizeof(unsigned int));
	memcpy(&g_NANDContext.ProgramCmd,&g_ChipInfo.ProgramCmd, sizeof(unsigned int));
}

int Handler(void)
{
    if (Is_usbworking(0) == true) {
#if 0
        if(m_vm.count("fix-device"))
        {
            FixProgrammer();
            return EXCODE_PASS;
        }

        AssignedDevice();
#endif
        if ((g_ucOperation & BLINK) == BLINK) {
            BlinkProgrammer();
            return EXCODE_PASS;
        }

        if ((g_ucOperation & DEVICE_ID) == DEVICE_ID) {
            ListSFSerialID();
            return EXCODE_PASS;
        }

    } else {
        printf("Error: Programmers are not connected.\n");
        return EXCODE_FAIL_OTHERS;
    }

    if (!InitProject())
        return EXCODE_FAIL_OTHERS;
    //my_timer t;                           // opertion timer

    if (ListTypes())
        return EXCODE_PASS;

    if (strlen(g_parameter_type) > 0) {
        int dev_cnt = get_usb_dev_cnt();
        if (g_uiDevNum == 0) {
            for (int i = 0; i < dev_cnt; i++) {
                RawInstructions(i);
            }
        } else if (g_uiDevNum <= dev_cnt) {
            RawInstructions(g_uiDevNum - 1);

        } else {
            printf("Error: Did not find the programmer.\n");
            return EXCODE_FAIL_OTHERS;
        }

        return Sequence();
    } else if (DetectChip()) {
        return Sequence();
    } else
        return EXCODE_FAIL_IDENTIFY;

    return EXCODE_FAIL_OTHERS;
}

bool InitProject(void)
{
    //printf("bool InitProject(void)\n");
    int dev_cnt = get_usb_dev_cnt();
	if (Is_usbworking(0) == true) {
//    if (Is_usbworking(g_uiDevNum-1)) {
        int targets[4] = {
            STARTUP_APPLI_CARD,
            STARTUP_APPLI_SF_1,
            STARTUP_APPLI_SF_2,
            STARTUP_APPLI_SF_SKT,
        };

        if (g_uiDevNum == 0) {
            for (int i = 0; i < dev_cnt; i++) {
                g_StartupMode = targets[g_ucTarget];
                SetTargetFlash((unsigned char)targets[g_ucTarget], i);
                SetSPIIOMode(i);
                SetSPIClock(i);
                SetVcc(i);
				SetVppVoltage(0,i);

                if (strlen(g_parameter_type) > 0) {
                    if (Dedi_Search_Chip_Db_ByTypeName(g_parameter_type, &g_ChipInfo)) {
                        printf("Chip Type %s is applied manually.\n", g_ChipInfo.TypeName);
                        printf("%s chip size is %zd bytes.\n\n", g_ChipInfo.TypeName, g_ChipInfo.ChipSizeInByte);
                        ProjectInitWithID(g_ChipInfo, i);
                        if (!strcmp(g_ChipInfo.Class, "N25Qxxx_Large"))
                            isSendFFsequence = true;
                    } else {
                        printf("Chip Type Unknow is applied manually.\n");
                        return false;
                    }

                } else {
                    ProjectInit(i);
                }
            }
        } else if (g_uiDevNum <= dev_cnt) {
            g_StartupMode = targets[g_ucTarget];
			SetTargetFlash((unsigned char)targets[g_ucTarget], g_uiDevNum - 1);
			SetSPIIOMode(g_uiDevNum - 1);
            SetSPIClock(g_uiDevNum - 1);
            SetVcc(g_uiDevNum - 1);
            SetVppVoltage(0,g_uiDevNum - 1);

            if (strlen(g_parameter_type) > 0) {
                if (Dedi_Search_Chip_Db_ByTypeName(g_parameter_type, &g_ChipInfo)) {
                    printf("Chip Type %s is applied manually.\n", g_ChipInfo.TypeName);
                    printf("%s chip size is %zd bytes.\n\n", g_ChipInfo.TypeName, g_ChipInfo.ChipSizeInByte);
                    ProjectInitWithID(g_ChipInfo, g_uiDevNum - 1);
                } else {
                    printf("Chip Type Unknow is applied manually.\n");
                    return false;
                }

            } else {
                ProjectInit(g_uiDevNum - 1);
            }
        } else
        printf("Error: Did not find the programmer.\n");
 
        return true;
    } 
    return false;
}

void CloseProject(void)
{
    for (int i = 0; i < get_usb_dev_cnt(); i++) {
        EnterStandaloneMode(i);
    }
    usb_driver_release();
}

bool DetectChip(void)
{
    int dev_cnt = get_usb_dev_cnt();
    g_ChipInfo = GetFirstDetectionMatch(g_strTypeName, ((g_uiDevNum>0)? (g_uiDevNum-1):0));
    if (g_uiDevNum == 0) {
        for (int i = 0; i < dev_cnt; i++) {
            if (!Is_usbworking(i)) {
                printf("%s", msg_err_communication);
                return false;
            }
            if (0 == g_ChipInfo.UniqueID) {
                printf("%s", msg_err_identifychip);
                return false;
            }
            printf("By reading the chip ID, the chip applies to [ %s ]\n\n", g_strTypeName);
            printf("%s parameters to be applied by default\n", g_ChipInfo.TypeName);
            printf("%s chip size is %zd bytes.\n\n", g_ChipInfo.TypeName, g_ChipInfo.ChipSizeInByte);

            RawInstructions(i);
        }
    } else if (g_uiDevNum <= dev_cnt) {
        if (!Is_usbworking(g_uiDevNum - 1)) {
            printf("%s", msg_err_communication);
            return false;
        }
        if (0 == g_ChipInfo.UniqueID) {
            printf("%s", msg_err_identifychip);
            return false;
        }
        printf("By reading the chip ID, the chip applies to [ %s ]\n\n", g_ChipInfo.TypeName);
        printf("%s parameters to be applied by default\n", g_ChipInfo.TypeName);
        printf("%s chip size is %zd bytes.\n\n", g_ChipInfo.TypeName, g_ChipInfo.ChipSizeInByte);

        RawInstructions(g_uiDevNum - 1);

    } else
        printf("Error: Did not find the programmer.\n");

    return true;
}

/* Simon: add later */
void SetVpp(int Index)
{
}

void SetSPIIOMode(int Index)
{
    SetIOMOdeValue(Index);
}
void SetSPIClock(int Index)
{
    //    sscanf(g_parameter_spi_clk,"%d",&g_ucSPIClock);
    SetSPIClockValue(g_ucSPIClock, Index);
}

void SetVcc(int Index)
{  
    if (!(g_Vcc <= 3800 && g_Vcc >= 1800 && ((g_bIsSF600[Index] == true) || is_SF700_Or_SF600PG2(Index))))
        g_Vcc = (0x10 | (g_Vcc & 0x03));
}

int SetVppVoltage(int vol, int Index)
{
    int ret;
    int voltage_selector;
    CNTRPIPE_RQ rq;

    switch (vol) {
    case 0:
        /* Admittedly this one is an assumption. */
        voltage_selector = 0x0;
        break;
    case 9:
        voltage_selector = 0x1;
        break;
    case 12:
        voltage_selector = 0x2;
        break;
    default:
        return 1;
    }

    rq.Function = URB_FUNCTION_VENDOR_ENDPOINT;
    rq.Direction = VENDOR_DIRECTION_OUT;
    rq.Request = 0x03;
    rq.Value = voltage_selector;
    rq.Index = 0;
    rq.Length = 0x0;

    ret = OutCtrlRequest(&rq, NULL, 0, Index);

    if (ret == SerialFlash_FALSE) {
        //		printf("Command Set VPP Voltage 0x%x failed!\n", voltage_selector);
        return 1;
    }
    Sleep(200);
    return 0;
}

int do_loadFile(void)
{
    char* filename = NULL;
    if (g_ucOperation & PROGRAM)
        filename = g_parameter_program;
    else if (g_ucOperation & BATCH) {
        switch (g_BatchIndex) {
        case 1:
            filename = g_parameter_batch;
            break;
        case 2:
        default:
            filename = g_parameter_auto;
            break;
        }
    } else if (g_ucOperation & FSUM)
        filename = g_parameter_fsum;
    printf("%s", msg_info_loading);
    printf("(%s)\n", filename);
    return LoadFile(filename);
}

int do_loadFileWithVerify(void)
{
    char* filename = NULL;
    if (g_ucOperation & LOADFILEWITHVERIFY)
        filename = g_parameter_loadfile_with_verify;
    printf("%s", msg_info_loading);
    printf("(%s)\n", filename);
    return LoadFile(filename);
}

bool ListTypes(void)
{
    if ((g_ucOperation & LIST_TYPE) != LIST_TYPE)
        return false;
    return Dedi_List_AllChip();
}
bool CheckProgrammerInfo(void)
{
    if ((g_ucOperation & CHECK_INFO) != CHECK_INFO)
        return false;
    int dev_cnt = get_usb_dev_cnt();
    unsigned int uiFPGAVer = 0;
    if (g_uiDevNum == 0) {
        for (int i = 0; i < dev_cnt; i++) { 
            int dwUID = ReadUID(i); 
            if (is_SF700_Or_SF600PG2(i)) {
		if (g_bIsSF700[i] == true)
                    printf("%d,\tSF7%05d\n", i + 1, dwUID);
                else if (g_bIsSF600PG2[i] == true)
                    printf("%d,\tS6B%05d\n", i + 1, dwUID);
            } else if ((g_bIsSF600[i] == true) && (dwUID / 600000) > 0)
                printf("%d,\tSF%06d\n", i + 1, dwUID);
            else if ((dwUID / 100000) > 0)
                printf("%d,\tSF%06d\n", i + 1, dwUID);
            else
                printf("%d,\tDP%06d\n", i + 1, dwUID);
 
            uiFPGAVer = GetFPGAVersion(i); 
            GetFirmwareVer(i); 
            if (g_bIsSF600[i]) {
                if (CheckSDCard(i))
                    printf("        Programmer type : SF600Plus\n");
                else
                    printf("        Programmer type : SF600\n");
                printf("        Firmware version : %s\n", g_FW_ver);
                printf("        FPGA version : 0x%04x\n", uiFPGAVer);
                printf("        Hardware version : %s\n", g_HW_ver);
            } else if (is_SF700_Or_SF600PG2(i)){
	        if (g_bIsSF700[i]) {
                    printf("        Programmer type : SF700\n");
                    printf("        Firmware version : %s\n", g_FW_ver);
                    printf("        FPGA version : 0x%04x\n", uiFPGAVer);
                    printf("        Hardware version : %s\n", g_HW_ver);
                } else if (g_bIsSF600PG2[i]) {
                    printf("        Programmer type : SF600Plus-G2\n");
                    printf("        Firmware version : %s\n", g_FW_ver);
                    printf("        FPGA version : 0x%04x\n", uiFPGAVer);
                    printf("        Hardware version : %s\n", g_HW_ver);
                }
            } else //SF100
            {
                printf("        Programmer type : SF100\n");
                printf("        Firmware version : %s\n", g_FW_ver);
                printf("        FPGA version : N.A.\n");
                printf("        Hardware version : N.A.\n");
            }
        }
    } else {
        int dwUID = ReadUID(g_uiDevNum - 1);
	if (is_SF700_Or_SF600PG2(g_uiDevNum - 1)) {
            if (g_bIsSF700[g_uiDevNum - 1] == true) {
                printf("\nDevice %d (SF7%05d):\n", g_uiDevNum, dwUID);
            } else if (g_bIsSF600PG2[g_uiDevNum - 1] == true) {
                printf("\nDevice %d (S6B%05d):\n", g_uiDevNum, dwUID);
            }
        } else if ((g_bIsSF600[g_uiDevNum - 1] == true) && (dwUID / 600000) > 0) {
            printf("\nDevice %d (SF%06d):\n", g_uiDevNum, dwUID);
        } else if ((dwUID / 100000) > 0) {
            printf("\nDevice %d (SF%06d):\n", g_uiDevNum, dwUID);
        } else {
            printf("\nDevice %d (DP%06d):\n", g_uiDevNum, dwUID);
        }

        uiFPGAVer = GetFPGAVersion(g_uiDevNum - 1);
        GetFirmwareVer(g_uiDevNum - 1);
        if (g_bIsSF600[g_uiDevNum - 1]) {
            if (CheckSDCard(g_uiDevNum - 1))
                printf("        Programmer type : SF600Plus\n");
            printf("        Programmer type : SF600Plus\n");
            printf("        Firmware version : %s\n", g_FW_ver);
            printf("        FPGA version : 0x%x\n", uiFPGAVer);
            printf("        Hardware version : %s\n", g_HW_ver);
        } else if (is_SF700_Or_SF600PG2(g_uiDevNum - 1)) {
	    if (g_bIsSF700[g_uiDevNum - 1]) {
                printf("        Programmer type : SF700\n");
            } else if (g_bIsSF600PG2[g_uiDevNum - 1]) {
                printf("        Programmer type : SF600Plus-G2\n");
            }
            printf("        Firmware version : %s\n", g_FW_ver);
            printf("        FPGA version : 0x%x\n", uiFPGAVer);
            printf("        Hardware version : %s\n", g_HW_ver);
        } else {//SF100 
            printf("        Programmer type : SF100\n");
            printf("        Firmware version : %s\n", g_FW_ver);
            printf("        FPGA version : N.A.\n");
            printf("        Hardware version : N.A.\n");
        }
    }
    return true;
}

/*
bool getFirmwareVer(void)
{

}

bool getFPGAVer(void)
{

}

bool getHWVer(void)
{

}*/
void BlinkProgrammer(void)
{
    bool IsV5 = is_BoardVersionGreaterThan_5_0_0(0);
    if (IsV5 == false)
        return;
    int dev_cnt = get_usb_dev_cnt();

    if (g_uiBlink == 0) {
        for (int i = 0; i < dev_cnt; i++) {
            printf("Blink LED on USB device %d \n", i);
            BlinkProgBoard(IsV5, i);
            Sleep(500);
            BlinkProgBoard(IsV5, i);
            Sleep(500);
            BlinkProgBoard(IsV5, i);
        }
    } else if (g_uiBlink <= dev_cnt) {
        printf("Blink LED on USB device %d \n", g_uiBlink);
        BlinkProgBoard(IsV5, g_uiBlink - 1);
        Sleep(500);
        BlinkProgBoard(IsV5, g_uiBlink - 1);
        Sleep(500);
        BlinkProgBoard(IsV5, g_uiBlink - 1);
    } else
        printf("Error: Did not find the programmer.\n");
}

void ListSFSerialID(void)
{
    unsigned int dev_cnt = 0;
    dev_cnt = get_usb_dev_cnt();

    unsigned int dwUID = 0;
    if (g_uiDeviceID < 1) {
        for (unsigned int i = 0; i < dev_cnt; i++) {
            dwUID = ReadUID(i);
	    if (is_SF700_Or_SF600PG2(i)) {
                if (g_bIsSF700[i] == true)
                    printf("%d,\tSF7%05d\n", i + 1, dwUID);
                else if (g_bIsSF600PG2[i] == true)
                    printf("%d,\tS6B%05d\n", i + 1, dwUID);
            } else if ((g_bIsSF600[i] == true) && (dwUID / 600000) > 0)
                printf("%d,\tSF%06d\n", i + 1, dwUID);
            else if ((dwUID / 100000) > 0)
                printf("%d,\tSF%06d\n", i + 1, dwUID);
            else
                printf("%d,\tDP%06d\n", i + 1, dwUID);
        }
    } else {
        if (g_uiDeviceID > dev_cnt)
            printf("The number of programmer is not defined!\n");
        else {
            dwUID = ReadUID(g_uiDeviceID - 1);
	    if (is_SF700_Or_SF600PG2(g_uiDeviceID - 1)) {
                if (g_bIsSF700[g_uiDeviceID - 1] == true)
                    printf("%d,\tSF7%05d\n", g_uiDeviceID, dwUID);
                else if (g_bIsSF600PG2[g_uiDeviceID - 1] == true)
                    printf("%d,\tS6B%05d\n", g_uiDeviceID, dwUID);
	    } else if ((g_bIsSF600[g_uiDeviceID - 1] == true) && (dwUID / 600000) > 0)
                printf("%d,\tSF%06d\n", g_uiDeviceID, dwUID);
            else if ((dwUID / 100000) > 0)
                printf("%d,\tSF%06d\n", g_uiDeviceID, dwUID);
            else
                printf("%d,\tDP%06d\n", g_uiDeviceID, dwUID);
        }
    }
}

void do_BlankCheck(void)
{
    printf("%s\n", msg_info_checking);
    Run(BLANKCHECK_WHOLE_CHIP, g_uiDevNum);

    Wait(msg_info_chipblank, msg_info_chipnotblank);
}

void do_NANDSpecialErase(void)
{
    printf("%s \n", msg_info_erasing);
    Run(NAND_SPECIAL_ERASE, g_uiDevNum);

    Wait(msg_info_eraseOK, msg_info_erasefail);
}


void do_Erase(void)
{
    printf("%s \n", msg_info_erasing);
    Run(ERASE_WHOLE_CHIP, g_uiDevNum);

    Wait(msg_info_eraseOK, msg_info_erasefail);
}

void do_Program(void)
{
    if (!do_loadFile())
        return; 

    SaveProgContextChanges();

    printf("%s\n", msg_info_programming);
    Run(PROGRAM_CHIP, g_uiDevNum);

    if (Wait(msg_info_progOK, msg_info_progfail)) {
        printf("\nChecksum(whole file): %08X", g_uiFileChecksum);
        printf("\nChecksum(Written part of file): %08X\n", CRC32(pBufferforLoadedFile, min(DownloadAddrRange.end - DownloadAddrRange.start, g_ulFileSize)));
    }
}

void do_Read(void)
{
    DownloadAddrRange.start = g_uiAddr;
    DownloadAddrRange.length = g_uiLen;
    DownloadAddrRange.end = g_uiAddr + g_uiLen;

    printf("%s\n", msg_info_reading);

    Run(READ_ANY_BY_PREFERENCE_CONFIGURATION, g_uiDevNum);
    Wait(msg_info_readOK, msg_info_readfail);
}

void do_DisplayOrSave(void)
{
    int dev_cnt = get_usb_dev_cnt();

    if (g_uiDevNum == 0) {
        for (int icnt = 0; icnt < dev_cnt; icnt++) {
            if (strcmp(g_parameter_read, "STDOUT") == 0) {
                int i, Len = UploadAddrRange.end - UploadAddrRange.start;
                printf("\n");
                printf("Hex value display (starting from 0x%02X, 0x%02zX bytes in total): \n", g_uiAddr, g_uiLen);
                for (i = 0; i < Len; i++) {
                    if ((i % 16 == 0) && i != 0) {
                        printf("\n");
                    }
                    printf("%02X  ", *(pBufferForLastReadData[icnt] + i));
                }
                printf("\n\n");
            } else {
                UploadAddrRange.length = UploadAddrRange.end - UploadAddrRange.start;

                char SourceStr[64];

                sprintf(SourceStr, "%s", g_parameter_read);

                if (dev_cnt > 1) {
                    int len = strlen(SourceStr);
                    int i = len;

                    while (SourceStr[i] != '.' && i > 0)
                        i--;

                    char ExtStr[64];
                    if (SourceStr[i] == '.') {
                        sprintf(ExtStr, "%s", &SourceStr[i]);
                        char* loc = strstr(SourceStr, ExtStr);

                        for (int i = loc - SourceStr; i < strlen(SourceStr); i++)
                            SourceStr[i] = '\0';
                        // printf("\n 1ExtStr= %s",ExtStr);
                        char str[64];

                        sprintf(str, "_%d", icnt + 1);
                        strcat(SourceStr, str);
                        strcat(SourceStr, ExtStr);
                    } else {
                        sprintf(ExtStr, "%s", &SourceStr[0]);
                        //printf("\n 2ExtStr= %s",ExtStr);

                        char str[64];
                        sprintf(str, "_%d", icnt + 1);
                        strcat(SourceStr, str);
                    }
                }

                if (WriteFile((const char*)SourceStr, pBufferForLastReadData[icnt], UploadAddrRange.length) == 1)
                    printf("\nSuccessfully saved into file:%s \n", SourceStr);
                else
                    printf("\nFailed to save into file: %s\n", SourceStr);
            }
        }
    } else if (g_uiDevNum != 0) {
        if (strcmp(g_parameter_read, "STDOUT") == 0) {
            int i, Len = UploadAddrRange.end - UploadAddrRange.start;
            printf("\n");
            printf("Hex value display (starting from 0x%02X, 0x%02zX bytes in total): \n", g_uiAddr, g_uiLen);
            for (i = 0; i < Len; i++) {
                if ((i % 16 == 0) && i != 0)
                    printf("\n");
                printf("%02X  ", *(pBufferForLastReadData[g_uiDevNum - 1] + i));
            }
            printf("\n\n");
        } else {
            UploadAddrRange.length = UploadAddrRange.end - UploadAddrRange.start;
            if (WriteFile((const char*)g_parameter_read, pBufferForLastReadData[g_uiDevNum - 1], UploadAddrRange.length) == 1)
                printf("\nSuccessfully saved into file:%s \n", g_parameter_read);
            else
                printf("\nFailed to save into file: %s\n", g_parameter_read);
        }
    } else
        printf("The number of programmer is not defined!\n");
}

void SaveProgContextChanges(void)
{
    LockAddrrange.start = g_uiLockStart;
    LockAddrrange.length = g_uiLockLen;
    LockAddrrange.end = g_uiLockStart + g_uiLockLen;
#if 0
    using numeric_conversion::hexstring_to_size_t;

    m_context.Prog_PaddingCharacterWhenProgrammingWholeChip = hexstring_to_size_t(m_vm["fill"].as<string>());
    m_context.Prog_CustomizedAddrFrom = hexstring_to_size_t(m_vm["addr"].as<string>());
    m_context.Prog_CustomizedDataLength = hexstring_to_size_t(m_vm["length"].as<string>());
    m_context.LockStartFrom = hexstring_to_size_t(m_vm["lock-start"].as<string>());
    m_context.LockLength = hexstring_to_size_t(m_vm["lock-length"].as<string>());
#endif
}

void do_Auto(void)
{
    if (do_loadFile() == 0)
        return;
    SaveProgContextChanges();

    printf("%s", msg_info_auto);
    Run(AUTO, g_uiDevNum);

    if (Wait(msg_info_autoOK, msg_info_autofail)) {
        printf("\nChecksum(whole file): %08X", g_uiFileChecksum);
        printf("\nChecksum(Written part of file): %08X\n", CRC32(pBufferforLoadedFile, DownloadAddrRange.end - DownloadAddrRange.start));
    }
}

void do_Verify(void)
{
    // if (g_ucOperation & LOADFILE)
    //     do_loadFile();

    printf("%s", msg_info_verifying);
    Run(VERIFY_CONTENT, g_uiDevNum);

    Wait(msg_info_verifyOK, msg_info_verifyfail);
}

void do_ReadSR(int Index)
{
    unsigned char rdsr = 0x05;
    unsigned char cSR;
    if (FlashCommand_SendCommand_OneOutOneIn(&rdsr, 1, &cSR, 1, Index) == 0)
        printf("SR unavailable\n");
    else
        printf("SR=0x%02X\n", cSR);
}

void do_RawInstructinos_2(int outDLen, char* para, int Index)
{
    unsigned char vOut[512];
    unsigned char vIn[512] = { 0xFF, 0xFF, 0xFF, 0 };
    int i = 0;
    char* pch;

    pch = strtok(para, " ,;-");
    while (pch != NULL) {
        sscanf(pch, "%02hhx", &vOut[i]);
        i++;
        pch = strtok(NULL, " ,;-");
    }

    // if(strlen(g_parameter_raw_return)>0)
    //	sscanf(g_parameter_raw_return,"%hhu",&Length);

    if (outDLen > 0)
        FlashCommand_SendCommand_OneOutOneIn(vOut, i, vIn, outDLen, Index);
    else
        FlashCommand_SendCommand_OutOnlyInstruction(vOut, i, Index);

    if (outDLen > 0) {
        printf("issuing raw instruction \"%s\" returns %d bytes as required:\n", g_parameter_raw, outDLen);
        for (i = 0; i < outDLen; i++)
            printf("%02X ", vIn[i]);
        printf("\n");
    }

    do_ReadSR(Index);
}

void do_RawInstructions(int Index)
{
    char* pch[30];
    char* pchR;
    unsigned char pchReturn[30];
    char parameter[40];

    unsigned char Length = 0;
    char retrunParameter[40];
    int iReturn = 0;
    int i = 0;
    strcpy(parameter, g_parameter_raw);
    TurnONVcc(Index);
    pch[i] = strtok(parameter, "|");
    while (pch[i] != NULL) { 
        i++;
        pch[i] = strtok(NULL, "|");
    }

    if (strlen(g_parameter_raw_return) > 0) { 
     
        sscanf(g_parameter_raw_return, "%hhu", &Length);
        strcpy(retrunParameter, g_parameter_raw_return);

        pchR = strtok(retrunParameter, "|");
        while (pchR != NULL) {
            sscanf(pchR, "%02hhx", &pchReturn[iReturn]);
            iReturn++;
            pchR = strtok(NULL, "|");
        }
        if (iReturn != i) {
            printf("\nError: value of --raw-require-return failed. No return value!\n\n");
            memset(pchReturn, 0, 30);
        }
    }

    for (int j = 0; j < i; j++) {  
        do_RawInstructinos_2(pchReturn[j], pch[j], Index);
    }
}

void do_ScanBB()
{
	if(g_bIsNANDFlash == false)
		return;
	
    printf("%s\n", msg_info_scanning);
    Run(NAND_SCAN_BB, g_uiDevNum);
	Wait( msg_info_scanBBOK, msg_info_scanBBfail) ;
} 
#if 0
bool do_loadFileWithPartitionTable()
{
	if(g_bIsNANDFlash == false)
	{
		return false;
	}
	
    char* filename = NULL;
    if (g_ucOperation & SPECIAL_PROGRAM)
        filename = g_parameter_special_program;
    else if (g_ucOperation & BATCH) {
        switch (g_BatchIndex) {
        case 1:
            filename = g_parameter_batch;
            break;
        case 2:
        default:
            filename = g_parameter_auto;
            break;
        }
    } else if (g_ucOperation & FSUM)
        filename = g_parameter_fsum;
    printf("%s", msg_info_loading);
    printf("(%s)\n", filename);
  
	{
		string s(m_vm["sp"].as<string>());
		split(fileOut, s/*one_sequence*/,is_any_of("|"), token_compress_on); 
	}

	if(fileOut.size() == 0)
		return false;
	
	if(fileOut.size() == 1)
		return do_loadFile();

	m_proj->analysisPartitionTable(m_vm["nand-SpareAreaUseFile"].as<size_t>()!=0, fileOut.at(0));
	m_proj->get_context().file.nand_PartitionTableFilePath.assign(fileOut.at(1).begin(), fileOut.at(1).end());
	if(m_vm.count("device"))
		m_proj->ChecknFitPartitionTable(bDeviceArray[m_vm["device"].as<size_t>()]);
	else if(m_vm.count("device-SN"))
		m_proj->ChecknFitPartitionTable(DeviceNum);
	else 
		  m_proj->ChecknFitPartitionTable(0); 
	
	return do_NANDloadFile(fileOut.at(1));
	return true;
	
}

void do_NANDSpecialProgram()
{ 	 
	SaveProgContextChanges();
	do_ScanBB();
	
	if(!do_loadFileWithPartitionTable())
	{
		m_status_result=false;
		return;
	}  

	if( (IsAthenticated==FALSE) && (m_DetectedDeviceNum>1) )
	{ 
		 if( TrialCntProgram>0 )
		 {
             wcout << L"\nProgram trail count:#"<< 99 - TrialCntProgram << L" (Max trial count=99).\n";
		     TrialCntProgram--;
		 }
		 else
		 {
		     wcout << L"\nProgram trial count runs out, please buy the production license.\n";
             return;
		 }
	}
 
    cout << msg_info_programming;
	do_SaveAllLog((CString)msg_info_programming.c_str());
	if(m_vm.count("device"))
    {
		if(bDeviceArray[m_vm["device"].as<size_t>()]==0xff)
		{
			outMsg="The number of programmer is not defined!";
			OutputFormatedMsg(outMsg); 
			do_SaveAllLog((CString)outMsg.c_str());
			return;
		}
		//SiteChoosen=m_vm["device"].as<size_t>()-1;
		m_proj->RunSingle(CProject::NAND_SPECIAL_PROGRAM,m_vm["device"].as<size_t>()-1);
    }
	else if(m_vm.count("device-SN"))
	{
		if(DeviceNum==0xffffffff)
		{
			OutputFormatedMsg("The number of programmer is not defined!");
			return;
		} 
		//SiteChoosen=bReDeviceArray[DeviceNum]-1; 
		m_proj->RunSingle(CProject::NAND_SPECIAL_PROGRAM,bReDeviceArray[DeviceNum]-1);
	}
    else
		m_proj->RunMulti(CProject::NAND_SPECIAL_PROGRAM);

    if( Wait( msg_info_progOK, msg_info_progfail ) )
    {
        wcout << L"\nChecksum(whole file): " << m_proj->getImageFileInfo(DediVersion::IMAGEFILE_ATTRIBUTE_CRC);
        wcout << L"\nChecksum(Written part of file): " << m_proj->getImageFileInfo(DediVersion::IMAGEFILE_ATTRIBUTE_CRC_OF_WRITTEN_PART);
    }
	if(m_proj->boFileSizeFailed)
	{
		wcout << L"\nError: File is invalid.\n" ;
	}
}
#endif

void RawInstructions(int Index)
{
    if (strlen(g_parameter_raw) > 0) {
        printf("\nDevice %d:\n", Index + 1);
        do_RawInstructions(Index);
    }
}

bool BlankCheck(void)
{
    if (g_ucOperation & BLANK)
        do_BlankCheck();

    return g_bStatus;
}

bool SpecialErase()
{ 
	if (g_ucOperation & SPECIAL_ERASE) {
		
		g_bNandForceErase = false;
        do_NANDSpecialErase();
		if(g_bStatus)
			do_ScanBB();
    }
	
	
    return g_bStatus;
}

bool Erase(void)
{
    if (g_ucOperation & ERASE) {
        do_Erase();
		if(g_bStatus)
			do_ScanBB();
    }
	
	
    return g_bStatus;
}

bool SpecialProgram(void)
{
//    if (g_ucOperation & SPECIAL_PROGRAM)   
//        do_SpecialProgram(); 
    return g_bStatus;
}

bool Program(void)
{
    if (g_ucOperation & PROGRAM)   
        do_Program(); 
    return g_bStatus;
}

bool Read(void)
{
    if (g_ucOperation & READ_TO_FILE) {
        do_Read();
        do_DisplayOrSave();
    }
    return g_bStatus;
}

bool Auto(void)
{
    if (g_ucOperation & BATCH)  
        do_Auto(); 
    return g_bStatus;
}

bool LoadFileWithVerify(void)
{
    if (g_ucOperation & LOADFILEWITHVERIFY) {
        do_loadFileWithVerify();
        if (g_bStatus)  
            do_Verify();  
    }
    return g_bStatus;
}

bool Verify(void)
{
    if (g_ucOperation & VERIFY)
        do_Verify();
    return g_bStatus;
}

bool CalChecksum(void)
{
    int dev_cnt = get_usb_dev_cnt();
    if (g_ucOperation & FSUM) {
        do_loadFile();
        printf("\nChecksum(file): 0x%08X\n", g_uiFileChecksum);
    }
    if (g_ucOperation & CSUM) {
        do_Read();
        if (g_uiDevNum == 0) {
            for (int i = 0; i < dev_cnt; i++) {
                int dwUID = ReadUID(i);
                if (g_uiAddr == 0 && g_uiLen == 0) {
	    	    if (is_SF700_Or_SF600PG2(i)) {
                        if (g_bIsSF700[i] == true)
                            printf("\nDevice %d (SF7%05d):", i + 1, dwUID);
                        else if (g_bIsSF600PG2[i] == true)
                            printf("\nDevice %d (S6B%05d):", i + 1, dwUID);
                    } else if ((g_bIsSF600[i] == true) && (dwUID / 600000) > 0)
                        printf("\nDevice %d (SF%06d):", i + 1, dwUID);
                    else if ((dwUID / 100000) > 0)
                        printf("\nDevice %d (SF%06d):", i + 1, dwUID);
                    else
                        printf("\nDevice %d (DP%06d):", i + 1, dwUID);

                    printf("Checksum of the whole chip(address starting from: 0x%X, 0x%zX bytes in total): %08X\n", g_uiAddr, g_ChipInfo.ChipSizeInByte, CRC32(pBufferForLastReadData[i], g_ChipInfo.ChipSizeInByte));
                } else {
                    if (is_SF700_Or_SF600PG2(i)) {
			if (g_bIsSF700[i] == true)
                            printf("\nDevice %d (SF7%05d):", i + 1, ReadUID(i));
                        else if (g_bIsSF600PG2[i] == true)
                            printf("\nDevice %d (S6B%05d):", i + 1, ReadUID(i));
                    } else if ((g_bIsSF600[i] == true) && (dwUID / 600000) > 0)
                        printf("\nDevice %d (SF%06d):", i + 1, ReadUID(i));
                    else if ((dwUID / 100000) > 0)
                        printf("\nDevice %d (SF%06d):", i + 1, ReadUID(i));
                    else
                        printf("\nDevice %d (DP%06d):", i + 1, ReadUID(i));

                    printf("Checksum(address starting from: 0x%X, 0x%zX bytes in total): %08X\n", g_uiAddr, g_uiLen, CRC32(pBufferForLastReadData[i], min(g_uiLen, g_ChipInfo.ChipSizeInByte)));
                }
            }
        } else if (g_uiDevNum != 0) {
            int dwUID = ReadUID(g_uiDevNum - 1);
            if (g_uiAddr == 0 && g_uiLen == 0) {
		if (is_SF700_Or_SF600PG2(g_uiDevNum - 1)) {
                    if (g_bIsSF700[g_uiDevNum - 1] == true)
                        printf("\nDevice %d (SF7%05d):", g_uiDevNum, ReadUID(g_uiDevNum - 1));
                    else if (g_bIsSF600PG2[g_uiDevNum - 1] == true)
                        printf("\nDevice %d (S6B%05d):", g_uiDevNum, ReadUID(g_uiDevNum - 1));
                } else if ((g_bIsSF600[g_uiDevNum - 1] == true) && (dwUID / 600000) > 0)
                    printf("\nDevice %d (SF%06d):", g_uiDevNum, ReadUID(g_uiDevNum - 1));
                else if ((dwUID / 100000) > 0)
                    printf("\nDevice %d (SF%06d):", g_uiDevNum, ReadUID(g_uiDevNum - 1));
                else
                    printf("\nDevice %d (DP%06d):", g_uiDevNum, ReadUID(g_uiDevNum - 1));

                printf("Checksum of the whole chip(address starting from: 0x%X, 0x%zX bytes in total): %08X\n", g_uiAddr, g_ChipInfo.ChipSizeInByte, CRC32(pBufferForLastReadData[g_uiDevNum - 1], g_ChipInfo.ChipSizeInByte));
            } else {
		if (is_SF700_Or_SF600PG2(g_uiDevNum - 1)) {
                    if (g_bIsSF700[g_uiDevNum - 1] == true)
                        printf("\nDevice %d (SF7%05d):", g_uiDevNum, ReadUID(g_uiDevNum - 1));
                    else if (g_bIsSF600PG2[g_uiDevNum - 1] == true)
                        printf("\nDevice %d (S6B%05d):", g_uiDevNum, ReadUID(g_uiDevNum - 1));
                } else if ((g_bIsSF600[g_uiDevNum - 1] == true) && (dwUID / 600000) > 0)
                    printf("\nDevice %d (SF%06d):", g_uiDevNum, ReadUID(g_uiDevNum - 1));
                else if ((dwUID / 100000) > 0)
                    printf("\nDevice %d (SF%06d):", g_uiDevNum, ReadUID(g_uiDevNum - 1));
                else
                    printf("\nDevice %d (DP%06d):", g_uiDevNum, ReadUID(g_uiDevNum - 1));
                printf("Checksum(address starting from: 0x%X, 0x%zX bytes in total): %08X\n", g_uiAddr, g_uiLen, CRC32(pBufferForLastReadData[g_uiDevNum - 1], min(g_uiLen, g_ChipInfo.ChipSizeInByte)));
            }
        } else
            printf("The number of programmer is not defined!\n");
    }

    return g_bStatus;
}

bool Wait(const char* strOK, const char* strFail)
{
    size_t timeOut = g_uiTimeout;
    struct timeval tv, basetv, diff;
    int dev_cnt = get_usb_dev_cnt();
    gettimeofday(&basetv, NULL);
    Sleep(100); // wait till the new thread starts ....
    printf("\n");

    while (g_is_operation_on_going == true) {
        for (volatile unsigned int dly = 100000; dly; dly--)
            __asm("nop");
        gettimeofday(&tv, NULL);
        if (tv.tv_sec - basetv.tv_sec > timeOut) {
            timersub(&tv, &basetv, &diff);
            printf("\r%0.2fs elapsed", diff.tv_sec + 0.000001 * diff.tv_usec);
            printf("%s", msg_err_timeout_abortion);
            g_is_operation_on_going = false;
            g_bStatus = false;
            return false;
        }

        if (g_bDisplayTimer == true) {
            timersub(&tv, &basetv, &diff);
            printf("\r%0.1fs elapsed", diff.tv_sec + 0.000001 * diff.tv_usec);
            Sleep(10);
        }
    }
    printf("\n");
    if (g_uiDevNum == 0) //mutiple
    {
        for (int i = 0; i < dev_cnt; i++) {
            int dwUID = ReadUID(i);
            if (is_SF700_Or_SF600PG2(i)) {
		if (g_bIsSF700[i] == true)
                    printf("\nDevice %d (SF7%05d):", i + 1, dwUID);
                else if (g_bIsSF600PG2[i] == true)
                    printf("\nDevice %d (S6B%05d):", i + 1, dwUID);
            } else if ((g_bIsSF600[i] == true) && (dwUID / 600000) > 0)
                printf("\nDevice %d (SF%06d):", i + 1, dwUID);
            else if ((dwUID / 100000) > 0)
                printf("\nDevice %d (SF%06d):", i + 1, dwUID);
            else
                printf("\nDevice %d (DP%06d):", i + 1, dwUID);
            printf("%s\n", g_is_operation_successful[i] ? strOK : strFail);
            g_bStatus = g_is_operation_successful[i];
        }
    } else if (g_uiDevNum <= dev_cnt) {
        int dwUID = ReadUID(g_uiDevNum - 1);
        if (is_SF700_Or_SF600PG2(g_uiDevNum - 1)) {
   	    if (g_bIsSF700[g_uiDevNum - 1] == true)
                printf("\nDevice %d (SF7%05d):", g_uiDevNum, dwUID);
            else if (g_bIsSF600PG2[g_uiDevNum - 1] == true)
                printf("\nDevice %d (S6B%05d):", g_uiDevNum, dwUID);
        } else if ((g_bIsSF600[g_uiDevNum - 1] == true) && (dwUID / 600000) > 0)
            printf("\nDevice %d (SF%06d):", g_uiDevNum, dwUID);
        else if ((dwUID / 100000) > 0)
            printf("\nDevice %d (SF%06d):", g_uiDevNum, dwUID);
        else
            printf("\nDevice %d (DP%06d):", g_uiDevNum, dwUID);

        printf("%s\n", g_is_operation_successful[g_uiDevNum - 1] ? strOK : strFail);
        g_bStatus = g_is_operation_successful[g_uiDevNum - 1];
    }
    return g_bStatus;
} 

int FlashIdentifier(CHIP_INFO* Chip_Info, int search_all, int Index)
{

    long UniqueID = 0;
    char TypeName[1024];
    int rc = 0;

    for (int c = 0; c < 2; c++) {
        if (c == 1)
            SendFFSequence(Index);
        UniqueID = flash_ReadId(0x9f, 4, Index);
        if (UniqueID != 0) {
            rc = Dedi_Search_Chip_Db(TypeName, 0x9f, UniqueID, Chip_Info, search_all);
            if (rc && (search_all == 0)) {
                if (c == 1)
                    isSendFFsequence = true;
                return rc;
            }
        }
        UniqueID = 0;
        rc = 0;
        UniqueID = flash_ReadId(0x9f, 3, Index);
        if (UniqueID != 0) {
            rc = Dedi_Search_Chip_Db(TypeName, 0x9f, UniqueID, Chip_Info, search_all);
            strncpy(g_strTypeName, TypeName, sizeof(g_strTypeName) - 1);
            g_strTypeName[sizeof(g_strTypeName) - 1] = '\0';
            //snprintf(g_strTypeName, sizeof(g_strTypeName), "%s", TypeName);
            if (rc && (search_all == 0)) {
                if (c == 1)
                    isSendFFsequence = true; 
                return rc;
            }
        }
        UniqueID = 0;
        rc = 0;
        UniqueID = flash_ReadId(0x9f, 2, Index);
        if (UniqueID != 0) {
            rc = Dedi_Search_Chip_Db(TypeName, 0x9f, UniqueID, Chip_Info, search_all);
            if (rc && (search_all == 0)) {
                if (c == 1)
                    isSendFFsequence = true;
                return rc;
            }
        } 
    }

    UniqueID = 0;
    rc = 0;
    UniqueID = flash_ReadId(0x15, 2, Index);
    if (UniqueID != 0) {
        rc = Dedi_Search_Chip_Db(TypeName, 0x15, UniqueID, Chip_Info, search_all);
        if (rc && (search_all == 0))
            return rc;
    }
    UniqueID = 0;
    rc = 0;
    UniqueID = flash_ReadId(0xab, 3, Index);
    if (UniqueID != 0) {
        rc = Dedi_Search_Chip_Db(TypeName, 0xab, UniqueID, Chip_Info, search_all);
        if (rc && (search_all == 0))
            return rc;
    }
    UniqueID = 0;
    rc = 0;
    UniqueID = flash_ReadId(0xab, 2, Index);
    if (UniqueID != 0) {
        rc = Dedi_Search_Chip_Db(TypeName, 0xab, UniqueID, Chip_Info, search_all);
        if (rc && (search_all == 0))
            return rc;
    }
    UniqueID = 0;
    rc = 0;
    UniqueID = flash_ReadId(0x90, 3, Index);
    if (UniqueID != 0) {
        rc = Dedi_Search_Chip_Db(TypeName, 0x90, UniqueID, Chip_Info, search_all);
        if (rc && (search_all == 0))
            return rc;
    }
    UniqueID = 0;
    rc = 0;
    UniqueID = flash_ReadId(0x90, 2, Index);
    if (UniqueID != 0) {
        rc = Dedi_Search_Chip_Db(TypeName, 0x90, UniqueID, Chip_Info, search_all);
        if (rc && (search_all == 0))
            return rc;
    }
    UniqueID = 0;
    rc = 0;
    UniqueID = flash_ReadId(0x90, 5, Index); // for 25LF020
    if (UniqueID != 0) {
        UniqueID = UniqueID - 0xFFFF0000;
        rc = Dedi_Search_Chip_Db(TypeName, 0x90, UniqueID, Chip_Info, search_all);
        if (rc && (search_all == 0))
            return rc;
    }  
    return rc;
} 

bool ScanBB(void)
{
	if(g_bIsNANDFlash == false)
		return true;
	if(g_iNandBadBlockManagement == 1)
		return true;

	do_ScanBB();
	return g_bStatus;
}