Пример #1
0
int touch_update_main(unsigned char bBlack)
{

    int retval = PASS;
    // -- This example section of commands show the high-level calls to -------
    // -- perform Target Initialization, SilcionID Test, Bulk-Erase, Target ---
    // -- RAM Load, FLASH-Block Program, and Target Checksum Verification. ----

    // >>>> ISSP Programming Starts Here <<<<
    CYTTSP_DBG(">>>> ISSP Programming Starts <<<<\n");

    // Acquire the device through reset or power cycle
#ifdef RESET_MODE
    // Initialize the Host & Target for ISSP operations
    if (fIsError = fXRESInitializeTargetForISSP())
    {
        retval = fIsError;
        ErrorTrap(fIsError);
        return fIsError;
    }
#else
    // Initialize the Host & Target for ISSP operations
    fIsError = fPowerCycleInitializeTargetForISSP();
    if (fIsError)
    {
        CYTTSP_DBG( "error - Initialize target for ISSP : %d\n", fIsError);
        retval = fIsError;
        ErrorTrap(fIsError);
        return fIsError;
    }
#endif

    CYTTSP_DBG(">>>> Run the SiliconID Verification, and proceed according to result <<<<\n");

    // Run the SiliconID Verification, and proceed according to result.
    fIsError = fVerifySiliconID();
    if (fIsError)
    {
        CYTTSP_DBG( "error - siliconID verification : %d\n", fIsError);
        retval = fIsError;
        ErrorTrap(fIsError);
        return fIsError;
    }

    CYTTSP_DBG(">>>> Bulk-Erase the Device <<<<\n");

#if 1
    // Bulk-Erase the Device.
    fIsError = fEraseTarget();
    if (fIsError)
    {
        CYTTSP_DBG("error - bulk-erase : %d\n", fIsError);
        retval = fIsError;
        ErrorTrap(fIsError);
        return fIsError;
    }

#endif

    CYTTSP_DBG(">>>> program flash block <<<<\n");

#if 1   // program flash block
    //==============================================================//
    // Program Flash blocks with predetermined data. In the final application
    // this data should come from the HEX output of PSoC Designer.
    binary_index = 0;
    iChecksumData = 0;     // Calculte the device checksum as you go
    for (iBlockCounter=0; iBlockCounter<BLOCKS_PER_BANK; iBlockCounter++)
    {
        msleep(1);
        fIsError = fReadWriteSetup();
        if (fIsError)
        {
            CYTTSP_DBG("error - fReadWriteSetup : %d\n", fIsError);
            retval = fIsError;
            ErrorTrap(fIsError);
            return fIsError;
        }

        LoadProgramData(bBankCounter, (unsigned char)iBlockCounter, bBlack);
        iChecksumData += iLoadTarget();

        fIsError = fProgramTargetBlock(bBankCounter,(unsigned char)iBlockCounter);
        if (fIsError)
        {
            CYTTSP_DBG("error - fProgramTargetBlock : %d\n", fIsError);
            retval = fIsError;
            ErrorTrap(fIsError);
            return fIsError;
        }

//			printk("Write Block: %d\n", iBlockCounter);

        fIsError = fReadStatus();
        if (fIsError)
        {
            CYTTSP_DBG("error - fReadStatus : %d\n", fIsError);
            retval = fIsError;
            ErrorTrap(fIsError);
            return fIsError;
        }

    }

#endif

    CYTTSP_DBG(">>>> verify <<<<\n");

#if 0  // verify

    //=======================================================//
    //PTJ: Doing Verify
    //PTJ: this code isnt needed in the program flow because we use PROGRAM-AND-VERIFY (ProgramAndVerify SROM Func)
    //PTJ: which has Verify built into it.
    // Verify included for completeness in case host desires to do a stand-alone verify at a later date.
    binary_index = 0;
    for (iBlockCounter=0; iBlockCounter<BLOCKS_PER_BANK; iBlockCounter++)
    {
        LoadProgramData(bBankCounter, (unsigned char) iBlockCounter);

        fIsError = fReadWriteSetup();
        if (fIsError)
        {
            CYTTSP_DBG("error - fReadWriteSetup : %d\n", fIsError);
            retval = fIsError;
            ErrorTrap(fIsError);
            return fIsError;
        }

        fIsError = fVerifySetup(bBankCounter,(unsigned char)iBlockCounter);
        if (fIsError)
        {
            CYTTSP_DBG("error - fVerifySetup : %d\n", fIsError);
            retval = fIsError;
            ErrorTrap(fIsError);
            return fIsError;
        }

        fIsError = fReadStatus();
        if (fIsError)
        {
            CYTTSP_DBG("error - fReadStatus : %d\n", fIsError);
            retval = fIsError;
            ErrorTrap(fIsError);
            return fIsError;
        }

        fIsError = fReadWriteSetup();
        if (fIsError)
        {
            CYTTSP_DBG("error - fReadWriteSetup : %d\n", fIsError);
            retval = fIsError;
            ErrorTrap(fIsError);
            return fIsError;
        }

        fIsError = fReadByteLoop();
        if (fIsError)
        {
            CYTTSP_DBG("error - fReadByteLoop : %d\n", fIsError);
            retval = fIsError;
            ErrorTrap(fIsError);
            return fIsError;
        }
    }
#endif // end verify

    CYTTSP_DBG(">>>> Program security data <<<<\n");

#if 1

    //=======================================================//
    // Program security data into target PSoC. In the final application this
    // data should come from the HEX output of PSoC Designer.

    abSecurityDataPtr = 0;
    for (bBankCounter=0; bBankCounter<NUM_BANKS; bBankCounter++)
    {
        //PTJ: READ-WRITE-SETUP used here to select SRAM Bank 1
        fIsError = fReadWriteSetup();
        if (fIsError)
        {
            CYTTSP_DBG("error - fReadWriteSetup : %d\n", fIsError);
            retval = fIsError;
            ErrorTrap(fIsError);
            return fIsError;
        }
        // Load one bank of security data from hex file into buffer
        fIsError = fLoadSecurityData(bBankCounter);
        if (fIsError)
        {
            CYTTSP_DBG("error - fLoadSecurityData : %d\n", fIsError);
            retval = fIsError;
            ErrorTrap(fIsError);
            return fIsError;
        }
        // Secure one bank of the target flash
        fIsError = fSecureTargetFlash();
        if (fIsError)
        {
            CYTTSP_DBG("error - fSecureTargetFlash : %d\n", fIsError);
            retval = fIsError;
            ErrorTrap(fIsError);
            return fIsError;
        }
    }
#endif

    CYTTSP_DBG(">>>> checksum <<<<\n");

#if 1   // checksum
    //Doing Checksum
    iChecksumTarget = 0;
    fIsError = fAccTargetBankChecksum(&iChecksumTarget);
    if (fIsError)
    {
        CYTTSP_DBG("error - fAccTargetBankChecksum : %d\n", fIsError);
        retval = fIsError;
        ErrorTrap(fIsError);
        return fIsError;
    }

    iChecksumData = iChecksumData & 0xFFFF;  //jpmoks : to be deleted.
    if (iChecksumTarget != iChecksumData)
    {
        CYTTSP_DBG("error - checksum is different\n");
        retval = fIsError;
        ErrorTrap(CHECKSUM_ERROR);
        return fIsError;
    }

#endif

    // *** SUCCESS ***
    // At this point, the Target has been successfully Initialize, ID-Checked,
    // Bulk-Erased, Block-Loaded, Block-Programmed, Block-Verified, and Device-
    // Checksum Verified.

    // You may want to restart Your Target PSoC Here.
    ReStartTarget();
    CYTTSP_DBG(">>>> firmware update success <<<<\n");
    return retval;
}
int cypress_update( int HW_ver )
{
	// -- This example section of commands show the high-level calls to -------
	// -- perform Target Initialization, SilcionID Test, Bulk-Erase, Target ---
	// -- RAM Load, FLASH-Block Program, and Target Checksum Verification. ----
	unsigned char fIsError = 0;
	//	unsigned char bTry=0;

	// >>>> ISSP Programming Starts Here <<<<

	//    ioctl(touch_fd, DEV_CTRL_TOUCH_INT_DISABLE,NULL);
	//    ioctl(touch_fd, DEV_CTRL_TOUCH_SET_FLAG,NULL);
	printk(KERN_INFO "[TSP] %s, %d, HW ver=%d\n", __func__, __LINE__,HW_ver);
#if defined(CONFIG_MACH_GIO)
	if( HW_ver == 1)
		pSocData = Firmware_Data_HW1;
	else if ( HW_ver == 2 )
		pSocData = Firmware_Data_HW2;
	else if ( HW_ver == 3 || HW_ver == 0 )
		pSocData = Firmware_Data_HW3;
	else if ( HW_ver == 17 )
		pSocData = Firmware_Data_HW11;
	else if ( HW_ver == 33 )
		pSocData = Firmware_Data_HW21;
	else if ( HW_ver == 34)
		pSocData = Firmware_Data_HW22;
	else if ( HW_ver == 35)
		pSocData = Firmware_Data_HW23;	
#elif defined(CONFIG_MACH_COOPER) 
	if( HW_ver == 4 || HW_ver == 3 || HW_ver == 0 )
		pSocData = Firmware_Data_HW3;
#else
	if( HW_ver == 1 )
		pSocData = Firmware_Data_HW1;
	else if( HW_ver == 2 )
		pSocData = Firmware_Data_HW2;
	else if( HW_ver == 3 )
		pSocData = Firmware_Data_HW3;
	else if( HW_ver == 4 )
		pSocData = Firmware_Data_HW4;
#endif
	else
	{
		printk(KERN_INFO "[TSP] %s, %d, HW ver is wrong!!\n", __func__, __LINE__);
		goto update_err;
	}
#ifdef TX_ON
	UART_Start();
	UART_CPutString("Start HSSP - Ovation");
	UART_PutCRLF();
#endif
	// >>>> ISSP Programming Starts Here <<<<

	// Acquire the device through reset or power cycle
#ifdef RESET_MODE
	UART_CPutString("Reset Mode activated");
#else
	//    UART_CPutString("Power Cycle Mode activated");
	// Initialize the Host & Target for ISSP operations
	fIsError = fPowerCycleInitializeTargetForISSP();
	if (fIsError )
	{
		printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
		ErrorTrap(fIsError);
		goto update_err;
	}
#endif

//	printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
#ifdef TX_ON
	UART_PutCRLF();
	UART_CPutString("Verify SiliconID");
#endif

//	printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);

	// Run the SiliconID Verification, and proceed according to result.
#if !defined(CONFIG_MACH_TASS) && !defined(CONFIG_MACH_TASSDT) && !defined(CONFIG_MACH_GIO)
	fIsError = fVerifySiliconID();
#endif
	if (fIsError )
	{
		printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
		ErrorTrap(fIsError);
		goto update_err;
	}

#ifdef TX_ON
	UART_PutCRLF();
	UART_CPutString("End VerifySiliconID");
#endif

//	printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);

#if 1
	// Bulk-Erase the Device.
	fIsError = fEraseTarget();
	if (fIsError )
	{
		printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
		ErrorTrap(fIsError);
		goto update_err;
	}

//	printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
#ifdef TX_ON
	UART_PutCRLF();
	UART_CPutString("End EraseTarget");
	UART_PutCRLF();
	UART_CPutString("Program Flash Blocks Start");
	UART_PutCRLF();
#endif

#endif

//	printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
#if 1   // program flash block
	//LCD_Char_Position(1, 0);
	//LCD_Char_PrintString("Program Flash Blocks Start");

	//==============================================================//
	// Program Flash blocks with predetermined data. In the final application
	// this data should come from the HEX output of PSoC Designer.

	iChecksumData = 0;     // Calculte the device checksum as you go
	for (iBlockCounter=0; iBlockCounter<BLOCKS_PER_BANK; iBlockCounter++)
	{
		fIsError = fReadWriteSetup();
		if (fIsError )
		{
			printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
			ErrorTrap(fIsError);
			goto update_err;
		}

		//LoadProgramData(bBankCounter, (unsigned char)iBlockCounter);
		iChecksumData += iLoadTarget(iBlockCounter);

		fIsError = fProgramTargetBlock(bBankCounter,(unsigned char)iBlockCounter);
		if (fIsError )
		{
			printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
			ErrorTrap(fIsError);
			goto update_err;
		}

		fIsError = fReadStatus();
		if (fIsError)
		{
			printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
			ErrorTrap(fIsError);
			goto update_err;
		}

#ifdef TX_ON
		UART_PutChar('#');
#endif

	}

#ifdef TX_ON
	UART_PutCRLF();
	UART_CPutString("Program Flash Blocks End");
#endif

#endif


#if 1  // verify
#ifdef TX_ON
	UART_PutCRLF();
	UART_CPutString("Verify Start");
	UART_PutCRLF();
#endif

	//=======================================================//
	//PTJ: Doing Verify
	//PTJ: this code isnt needed in the program flow because we use PROGRAM-AND-VERIFY (ProgramAndVerify SROM Func)
	//PTJ: which has Verify built into it.
	// Verify included for completeness in case host desires to do a stand-alone verify at a later date.

	for (iBlockCounter=0; iBlockCounter<BLOCKS_PER_BANK; iBlockCounter++)
	{
		//LoadProgramData(bBankCounter, (unsigned char) iBlockCounter);

		fIsError = fReadWriteSetup();
		if (fIsError )
		{
			printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
			ErrorTrap(fIsError);
			goto update_err;
		}

		fIsError = fVerifySetup(bBankCounter,(unsigned char)iBlockCounter);
		if (fIsError)
		{
			printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
			ErrorTrap(fIsError);
			goto update_err;
		}

		fIsError = fReadStatus();
		if (fIsError ) {
			printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
			ErrorTrap(fIsError);
			goto update_err;
		}

		fIsError = fReadWriteSetup();
		if (fIsError)  {
			printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
			ErrorTrap(fIsError);
			goto update_err;
		}

		fIsError = fReadByteLoop(iBlockCounter);
		if (fIsError ) {
			printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
			ErrorTrap(fIsError);
			goto update_err;
		}

#ifdef TX_ON
		UART_PutChar('.');
#endif

	}

#ifdef TX_ON
	UART_PutCRLF();
	UART_CPutString("Verify End");
#endif

#endif // end verify

#if 1
#ifdef TX_ON
	UART_PutCRLF();
	UART_CPutString("Security Start");
#endif


	//=======================================================//
	// Program security data into target PSoC. In the final application this
	// data should come from the HEX output of PSoC Designer.
	for (bBankCounter=0; (bBankCounter<NUM_BANKS) ; bBankCounter++)
	{
		//PTJ: READ-WRITE-SETUP used here to select SRAM Bank 1

		fIsError = fReadWriteSetup();
		if (fIsError )
		{
			printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
			ErrorTrap(fIsError);
			goto update_err;
		}
		// Load one bank of security data from hex file into buffer
   		fIsError = fLoadSecurityData(bBankCounter);
		if (fIsError )
		{
			printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
			ErrorTrap(fIsError);
			goto update_err;
		}
		// Secure one bank of the target flash
		fIsError = fSecureTargetFlash();
		if (fIsError )
		{
			printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
			ErrorTrap(fIsError);
			goto update_err;
		}
	}

#ifdef TX_ON
	UART_PutCRLF();
	UART_CPutString("End Security data");
#endif

#endif


#if 1   // checksum
#ifdef TX_ON
	UART_PutCRLF();
	UART_CPutString("CheckSum Start");
#endif

//	printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
	//PTJ: Doing Checksum
	iChecksumTarget = 0;
	fIsError = fAccTargetBankChecksum(&iChecksumTarget);
	if (fIsError )
	{
		printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
		ErrorTrap(fIsError);
		goto update_err;
	}

//	printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);
#ifdef TX_ON
	UART_PutCRLF();
	UART_CPutString("Checksum : iChecksumTarget (0x");
	UART_PutHexWord(iChecksumTarget);
	UART_CPutString("), iChecksumData (0x");
	UART_PutHexWord(iChecksumData);
	UART_CPutString(")");
#endif

	iChecksumTarget = iChecksumTarget & 0xFFFF;
	iChecksumData = iChecksumData & 0xFFFF;

	if (iChecksumTarget != iChecksumData)
	{
		printk(KERN_INFO "[TSP] %s, %d, iChecksumTarget=%d, iChecksumData=%d\n", __func__, __LINE__,iChecksumTarget, iChecksumData );
		ErrorTrap(CHECKSUM_ERROR);
		goto update_err;
	}

#ifdef TX_ON
	UART_PutCRLF();
	UART_CPutString("End Checksum");
#endif

#endif

	// *** SUCCESS ***
	// At this point, the Target has been successfully Initialize, ID-Checked,
	// Bulk-Erased, Block-Loaded, Block-Programmed, Block-Verified, and Device-
	// Checksum Verified.

	// You may want to restart Your Target PSoC Here.
	ReStartTarget();
//	printk(KERN_INFO "[TSP] %s, %d\n", __func__, __LINE__);

	return 1;

update_err:
	return 0;
}
Пример #3
0
signed char download_firmware_main(char *filename)
{
    struct file     *filp;
    struct inode    *inode = NULL;
    int	length = 0, remaining = 0, count = 0;
    mm_segment_t    oldfs;

    char *fw_buf = NULL, *buffer;

    oldfs = get_fs();
    set_fs(KERNEL_DS);

    filp = filp_open(filename, O_RDONLY, S_IRUSR);
    if (IS_ERR(filp)) {
        pr_info("%s: file %s filp_open error, is_err = %x\n", __func__, filename, (int)IS_ERR(filp));
        return -EIO;
    }

    if (!filp->f_op) {
        pr_info("%s: File Operation Method Error\n", __func__);
        return -EIO;
    }

    inode = filp->f_path.dentry->d_inode;

    if (!inode) {
        pr_info("%s: Get inode from filp failed\n", __func__);
        filp_close(filp, NULL);
        return -EIO;
    }

    pr_info("%s file offset opsition: %xh\n", __func__, (unsigned)filp->f_pos);

    length = i_size_read(inode->i_mapping->host);
    if (length == 0) {
        pr_info("%s: Try to get file size error\n", __func__);
        goto Transfer_DONE;
    }

    pr_info("%s: length=%d\n", __func__, length);
    fw_buf = (char *)kmalloc((length + 1), GFP_KERNEL);
    if (fw_buf == NULL) {
        pr_info("%s: kernel memory alloc error\n", __func__);
        filp_close(filp, NULL);
        return -EIO;
    }
    if (filp->f_op->read(filp, fw_buf, length, &filp->f_pos) != length) {
        pr_info("%s: file read error\n", __func__);
        goto Transfer_DONE;
    }
    /* >>>> ISSP Programming Starts Here <<<< */

#ifdef RESET_MODE
    fIsError = fXRESInitializeTargetForISSP();
    if (fIsError) {
        pr_info("power on failed!\n");
        ErrorTrap(fIsError);
    }
    pr_info("power on success!\n");
#else
    /* Initialize the Host & Target for ISSP operations */
    fIsError = fPowerCycleInitializeTargetForISSP();
    if (fIsError) {
        pr_info("power on failed!\n");
        ErrorTrap(fIsError);
    }
    pr_info("power on success!\n");
#endif
    /* Run the SiliconID Verification, and proceed according to result. */

    fIsError = fVerifySiliconID();
    if (fIsError) {
        pr_info("SiliconID Verification failed!\n");
        ErrorTrap(fIsError);
        return -EIO;
    }
    pr_info("SiliconID Verification success!\n");



    /*-----------------------------------------------------------------------
    xch: the function call below will erase one block (128bytes) of flash
    in the target device.  The block number to be erased is passed in
    as a parameter
    fEraseBlock(5);  // arbitrarily used the 5th block for debugging purposes
    --------------------------------------------------------------------------
    */

    fIsError = fEraseTarget();
    if (fIsError)
        ErrorTrap(fIsError);
    pr_info("erase one block success!\n");

    /* ==============================================================//
       Program Flash blocks with predetermined data. In the final application
       this data should come from the HEX output of PSoC Designer.
       firmware_transfer(tgt_fw);
     */
    remaining = length;
    buffer = fw_buf;
    iChecksumData = 0;     /* Calculte the device checksum as you go */
    for (bBankCounter = 0; bBankCounter < NUM_BANKS; bBankCounter++) {
        for (iBlockCounter = 0; iBlockCounter < BLOCKS_PER_BANK; iBlockCounter++) {
            /* count = (remaining > TARGET_DATABUFF_LEN)? TARGET_DATABUFF_LEN : remaining; */
            LoadProgramData(bBankCounter, (unsigned char)iBlockCounter, buffer, count);
            /*
               This loads the host with test data, not the DUT
               if(iBlockCounter==1)
               return;
               remaining = remaining - count;
               buffer = &fw_buf[count * (iBlockCounter+1)];
             */
            iChecksumData += iLoadTarget();	/* This loads the DUT */

#ifdef USE_TP
            SetTPHigh();    /* Only used of Test Points are enabled */
#endif
            fIsError = fProgramTargetBlock(bBankCounter, (unsigned char)iBlockCounter);
            if (fIsError)
                ErrorTrap(fIsError);
#ifdef USE_TP
            SetTPLow(); /* Only used of Test Points are enabled */
#endif
            fIsError = fReadStatus();
            if (fIsError) /* READ-STATUS after PROGRAM-AND-VERIFY */
                ErrorTrap(fIsError);
        }

    }
    pr_info("Program Flash blocks with predetermined data success.\n");

    /*=======================================================//
      Doing Verify
      Verify included for completeness in case host desires to do a
      stand-alone verify at a later date.
     */
    remaining = length;
    buffer = fw_buf;
    for (bBankCounter = 0; bBankCounter < NUM_BANKS; bBankCounter++) {
        for (iBlockCounter = 0; iBlockCounter < BLOCKS_PER_BANK; iBlockCounter++) {
            /* LoadProgramData(bBankCounter, (unsigned char) iBlockCounter,buffer,count);
               count = (remaining > TARGET_DATABUFF_LEN)? TARGET_DATABUFF_LEN : remaining;
             */
            LoadProgramData(bBankCounter, (unsigned char)iBlockCounter, buffer, count);
            /* This loads the host with test data, not the DUT
               remaining = remaining - count;
               buffer = &fw_buf[count * (iBlockCounter+1)];
             */
            fIsError = fVerifySetup(bBankCounter, (unsigned char)iBlockCounter);
            if (fIsError) {
                pr_info("fVerifySetup err = %d\n", fIsError);
                ErrorTrap(fIsError);
            }
            fIsError = fReadStatus();

            if (fIsError) {
                pr_info("fReadStatus err = %d\n", fIsError);
                ErrorTrap(fIsError);
            }
            fIsError = fReadByteLoop();
            if (fIsError) {
                pr_info("fReadByteLoop err = %d\n", fIsError);
                ErrorTrap(fIsError);
            }
        }
    }

    pr_info("Doing Verify success.\n");

    /*---------------------------------------------------------------------------
    xch: the function call below will erase one block (128bytes) of flash
    in the target device.  The block number to be erased is passed in
    as a parameter
    fEraseBlock(5);  // arbitrarily used the 5th block for debugging purposes
    -----------------------------------------------------------------------------*/

    /* =======================================================
     Program security data into target PSoC. In the final application
    this data should come from the HEX output of PSoC Designer
    */
    for (bBankCounter = 0; bBankCounter < NUM_BANKS; bBankCounter++) {
        /* Load one bank of security data from hex file into buffer */
        fIsError = fLoadSecurityData(bBankCounter, buffer);
        if (fIsError)
            ErrorTrap(fIsError);

        /* Secure one bank of the target flash */
        fIsError = fSecureTargetFlash();
        if (fIsError)
            ErrorTrap(fIsError);
    }
    pr_info("set securitydata success\n");
    /* ==============================================================
       Do VERIFY-SECURITY after SECURE
       Load one bank of security data from hex file into buffer
       loads abTargetDataOUT[] with security data that was used in secure
       bit stream
     */
    fIsError = fLoadSecurityData(bBankCounter, buffer);
    if (fIsError)
        ErrorTrap(fIsError);

    fIsError = fVerifySecurity();
    if (fIsError)
        ErrorTrap(fIsError);

    /* =======================================================
       Doing Checksum after VERIFY-SECURITY
     */
    iChecksumTarget = 0;
    for (bBankCounter = 0; bBankCounter < NUM_BANKS; bBankCounter++) {
        fIsError = fAccTargetBankChecksum(&iChecksumTarget);
        if (fIsError)
            ErrorTrap(fIsError);
    }

    pr_info("%s: checksum = %x\n", __func__, iChecksumTarget);
    if (iChecksumTarget != (iChecksumData & 0xFFFF))
        ErrorTrap(VERIFY_ERROR);

    pr_info("checksum success!\n");
    pr_info("download firmware success!\n");
    /* *** SUCCESS ***
       At this point, the Target has been successfully Initialize,
       ID-Checked, Bulk-Erased, Block-Loaded, Block-Programmed,
       Block-Verified, and Device-
       Checksum Verified.
     */

    return 0;

Transfer_DONE:
    kfree(fw_buf);
    filp_close(filp, NULL);
    set_fs(oldfs);

    return -EIO;
}