// ============================================================================ // fAddTargetBankChecksum() // Reads and adds the target bank checksum to the referenced accumulator. // Returns: // 0 if successful // VERIFY_ERROR if timed out on handshake to the device. // ============================================================================ signed char fAccTargetBankChecksum(unsigned int *pAcc) { unsigned int wCheckSumData; SendVector(checksum_setup, num_bits_checksum_setup); //PTJ:CHECKSUM-SETUP, it is taking 100ms > time > 200ms to complete the checksum if ((fIsError = fDetectHiLoTransition())) { //100ms is default return (VERIFY_ERROR); } SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); SendVector(tsync_enable, num_bits_tsync_enable); //Send Read Checksum vector and get Target Checksum SendVector(read_checksum_v, 11); // first 11-bits is ReadCKSum-MSB RunClock(2); // Two SCLKs between write & read bTargetDataIN = bReceiveByte(); wCheckSumData = bTargetDataIN << 8; RunClock(1); // See Fig. 6 SendVector(read_checksum_v + 2, 12); // 12 bits starting from 3rd character RunClock(2); // Read-LSB Command bTargetDataIN = bReceiveByte(); wCheckSumData |= (bTargetDataIN & 0xFF); RunClock(1); SendVector(read_checksum_v + 3, 1); // Send the final bit of the command //PTJ: read_checksum_v may have to change if TSYNC needs to be enabled SendVector(tsync_disable, num_bits_tsync_disable); *pAcc = wCheckSumData; return (PASS); }
// ============================================================================ // fXRESInitializeTargetForISSP() // Implements the intialization vectors for the device. // Returns: // 0 if successful // INIT_ERROR if timed out on handshake to the device. // ============================================================================ signed char fXRESInitializeTargetForISSP(void) { // Configure the pins for initialization SetSDATAHiZ(); SetSCLKStrong(); SCLKLow(); // Cycle reset and put the device in programming mode when it exits reset AssertXRES(); DeassertXRES(); // !!! NOTE: // The timing spec that requires that the first Init-Vector happen within // 1 msec after the reset/power up. For this reason, it is not advisable // to separate the above RESET_MODE or POWER_CYCLE_MODE code from the // Init-Vector instructions below. Doing so could introduce excess delay // and cause the target device to exit ISSP Mode. //PTJ: Send id_setup_1 instead of init1_v //PTJ: both send CA Test Key and do a Calibrate1 SROM function SendVector(id_setup_1, num_bits_id_setup_1); if (fIsError = fDetectHiLoTransition()) { // TX8SW_CPutString("\r\n fDetectHiLoTransition Error"); printk("\r\n fDetectHiLoTransition Error\n"); return (INIT_ERROR); } SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); // NOTE: DO NOT not wait for HiLo on SDATA after vector Init-3 // it does not occur (per spec). return (PASS); }
// ============================================================================ // fProgramTargetBlock() // Program one block with data that has been loaded into a RAM buffer in the // target device. // Returns: // 0 if successful // BLOCK_ERROR if timed out on handshake to the device. // ============================================================================ signed char fProgramTargetBlock(unsigned char bBankNumber, unsigned char bBlockNumber) { SendVector(tsync_enable, num_bits_tsync_enable); SendVector(set_block_num, num_bits_set_block_num); // Set the drive here because SendByte() does not. SetSDATAStrong(); SendByte(bBlockNumber, 8); SendByte(set_block_num_end, 3); SendVector(tsync_disable, num_bits_tsync_disable); //PTJ: // Send the program-block vector. SendVector(program_and_verify, num_bits_program_and_verify); //PTJ: PROGRAM-AND-VERIFY // wait for acknowledge from target. if ((fIsError = fDetectHiLoTransition())) { return (BLOCK_ERROR); } // Send the Wait-For-Poll-End vector SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); return (PASS); //PTJ: Don't do READ-STATUS here because that will //PTJ: require that we return multiple error values, if error occurs }
// ============================================================================ // fAddTargetBankChecksum() // Reads and adds the target bank checksum to the referenced accumulator. // Returns: // 0 if successful // VERIFY_ERROR if timed out on handshake to the device. // ============================================================================ signed char fAccTargetBankChecksum(unsigned int* pAcc) { unsigned int wCheckSumData=0; SendVector(checksum_v, num_bits_checksum); fIsError = fDetectHiLoTransition(); if (fIsError ) { return(CHECKSUM_ERROR); } SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); //SendVector(tsync_enable, num_bits_tsync_enable); //Send Read Checksum vector and get Target Checksum SendVector(read_checksum_v, 11); // first 11-bits is ReadCKSum-MSB RunClock(2); // Two SCLKs between write & read bTargetDataIN = bReceiveByte(); wCheckSumData = ((unsigned int)(bTargetDataIN))<<8; RunClock(1); // See Fig. 6 SendVector(read_checksum_v + 2, 12); // 12 bits starting from 3rd character RunClock(2); // Read-LSB Command bTargetDataIN = bReceiveByte(); wCheckSumData |= (unsigned int) bTargetDataIN; RunClock(1); SendVector(read_checksum_v + 4, 1); // Send the final bit of the command //SendVector(tsync_disable, num_bits_tsync_disable); *pAcc = wCheckSumData; return(PASS); }
// ============================================================================ // fSecureTargetFlash() // Before calling, load the array, abTargetDataOUT, with the desired security // settings using LoadArrayWithSecurityData(StartAddress,Length,SecurityType). // The can be called multiple times with different SecurityTypes as needed for // particular Flash Blocks. Or set them all the same using the call below: // LoadArrayWithSecurityData(0,SECURITY_BYTES_PER_BANK, 0); // Returns: // 0 if successful // SECURITY_ERROR if timed out on handshake to the device. // ============================================================================ signed char fSecureTargetFlash(void) { unsigned char bTemp; // Transfer the temporary RAM array into the target bTargetAddress = 0x00; bTargetDataPtr = 0x00; SetSDATAStrong(); while (bTargetDataPtr < SECURITY_BYTES_PER_BANK) { bTemp = abTargetDataOUT[bTargetDataPtr]; SendByte(write_byte_start, 4); SendByte(bTargetAddress, 7); SendByte(bTemp, 8); SendByte(write_byte_end, 3); // SendBytes() uses MSBits, so increment the address by '2' to put // the 0..n address into the seven MSBit locations bTargetAddress += 2; //PTJ: inc by 2 in order to support a 128 byte address space bTargetDataPtr++; } SendVector(secure, num_bits_secure); //PTJ: if ((fIsError = fDetectHiLoTransition())) { return (SECURITY_ERROR); } SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); return (PASS); }
signed char fSecureTargetFlash(void) { unsigned char bTemp; bTargetAddress = 0x00; bTargetDataPtr = 0x00; SetSDATAStrong(); while (bTargetDataPtr < SecurityBytesPerBank) { bTemp = abTargetDataOUT[bTargetDataPtr]; SendByte(write_byte_start, 4); SendByte(bTargetAddress, 7); SendByte(bTemp, 8); SendByte(write_byte_end, 3); bTargetAddress += 2; /*PTJ: inc by 2 in order to support a 128 byte address space*/ bTargetDataPtr++; } SendVector(secure, num_bits_secure); fIsError = fDetectHiLoTransition(); if (fIsError != 0) return SECURITY_ERROR; SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); return PASS; }
signed char fAccTargetBankChecksum(unsigned int *pAcc) { unsigned int wCheckSumData = 0; SendVector(checksum_v, num_bits_checksum); fIsError = fDetectHiLoTransition(); if (fIsError != 0) return CHECKSUM_ERROR; SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); SendVector(tsync_enable, num_bits_tsync_enable); SendVector(read_checksum_v, 11); /*first 11-bits is ReadCKSum-MSB*/ RunClock(2); /*Two SCLKs between write & read*/ bTargetDataIN = bReceiveByte(); wCheckSumData = bTargetDataIN<<8; RunClock(1); /*12 bits starting from 3rd character*/ SendVector(read_checksum_v + 2, 12); RunClock(2); /* Read-LSB Command*/ bTargetDataIN = bReceiveByte(); wCheckSumData |= (bTargetDataIN & 0xFF); RunClock(1); /*Send the final bit of the command */ SendVector(read_checksum_v + 3, 1); /* Send the final bit of the command PTJ: read_checksum_v may have to change if TSYNC needs to be enabled*/ SendVector(tsync_disable, num_bits_tsync_disable); *pAcc = wCheckSumData; return PASS; }
signed char fEraseTarget(void) { SendVector(erase, num_bits_erase); fIsError = fDetectHiLoTransition(); if (fIsError != 0) return ERASE_ERROR; SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); return PASS; }
// ============================================================================ // fEraseTarget() // Perform a bulk erase of the target device. // Returns: // 0 if successful // ERASE_ERROR if timed out on handshake to the device. // ============================================================================ signed char fEraseTarget(void) { SendVector(erase, num_bits_erase); if (fIsError = fDetectHiLoTransition()) { return(ERASE_ERROR); } SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); return(PASS); }
// ============================================================================ // fVerifySiliconID() // Returns: // 0 if successful // Si_ID_ERROR if timed out on handshake to the device. // ============================================================================ signed char fVerifySiliconID(void) { SendVector(id_setup_2, num_bits_id_setup_2); if (fIsError = fDetectHiLoTransition()) { return(SiID_ERROR); } SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); SendVector(tsync_enable, num_bits_tsync_enable); //Send Read ID vector and get Target ID SendVector(read_id_v, 11); // Read-MSB Vector is the first 11-Bits RunClock(2); // Two SCLK cycles between write & read bTargetID[0] = bReceiveByte(); RunClock(1); SendVector(read_id_v+2, 12); // 1+11 bits starting from the 3rd byte RunClock(2); // Read-LSB Command bTargetID[1] = bReceiveByte(); RunClock(1); SendVector(read_id_v+4, 1); // 1 bit starting from the 5th byte //read Revision ID from Accumulator A and Accumulator X //SendVector(read_id_v+5, 11); //11 bits starting from the 6th byte //RunClock(2); //bTargetID[2] = bReceiveByte(); //Read from Acc.X //RunClock(1); //SendVector(read_id_v+7, 12); //1+11 bits starting from the 8th byte // //RunClock(2); //bTargetID[3] = bReceiveByte(); //Read from Acc.A // //RunClock(1); //SendVector(read_id_v+4, 1); //1 bit starting from the 5th byte, SendVector(tsync_disable, num_bits_tsync_disable); printk(KERN_ERR "[CYPRESS] Silicon ID : %x %x\n", bTargetID[0], bTargetID[1]); if (!(bTargetID[0] == target_id_v[0] || bTargetID[0] == target_id_v_2[0]) //etinum || !(bTargetID[1] == target_id_v[1] || bTargetID[1] == target_id_v_2[1]) //etinum ) { #if 1 return(PASS); #else return(SiID_ERROR); #endif } else { return(PASS); } }
// ============================================================================ // fEraseTarget() // Perform a bulk erase of the target device. // Returns: // 0 if successful // ERASE_ERROR if timed out on handshake to the device. // ============================================================================ signed char fEraseTarget(void) { SendVector(erase, num_bits_erase); if ((fIsError = fDetectHiLoTransition()) != PASS) { // TX8SW_CPutString("\r\n fDetectHiLoTransition"); printk("\r\n fDetectHiLoTransition\n"); return(ERASE_ERROR); } SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); return(PASS); }
// ============================================================================ // fEraseTarget() // Perform a bulk erase of the target device. // Returns: // 0 if successful // ERASE_ERROR if timed out on handshake to the device. // ============================================================================ signed char fEraseTarget(void) { SendVector(erase, num_bits_erase); if ((fIsError = fDetectHiLoTransition())) { // TX8SW_CPutString("fDetectHiLoTransition"); //printk(KERN_DEBUG"touchkey:fDetectHiLoTransition\n"); // issp_test_2010 block return (ERASE_ERROR); } SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); return (PASS); }
// ============================================================================ // fEraseTarget() // Perform a bulk erase of the target device. // Returns: // 0 if successful // ERASE_ERROR if timed out on handshake to the device. // ============================================================================ signed char fEraseTarget(void) { SendVector(erase, num_bits_erase); if ((fIsError = fDetectHiLoTransition())) { // TX8SW_CPutString("\r\n fDetectHiLoTransition"); printk(KERN_INFO "\r\n fEraseTarget fDetectHiLoTransition\n"); /* issp_test_2010 block */ return (ERASE_ERROR); } SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); return (PASS); }
// ============================================================================ // fVerifyTargetBlock() // Verify the block just written to. This can be done byte-by-byte before the // protection bits are set. // Returns: // 0 if successful // BLOCK_ERROR if timed out on handshake to the device. // ============================================================================ signed char fVerifyTargetBlock(unsigned char bBankNumber, unsigned char bBlockNumber) { SendVector(set_block_number, 11); //Set the drive here because SendByte() does not SetSDATAStrong(); SendByte(bBlockNumber, 8); SendByte(set_block_number_end, 3); SendVector(verify_setup_v, num_bits_verify_setup); if ((fIsError = fDetectHiLoTransition())) { return (BLOCK_ERROR); } SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); bTargetAddress = 0; bTargetDataPtr = 0; while (bTargetDataPtr < TARGET_DATABUFF_LEN) { //Send Read Byte vector and then get a byte from Target SendVector(read_byte_v, 4); //PTJ 308: this was changed from sending the first 5 bits to sending the first 4 // Set the drive here because SendByte() does not SetSDATAStrong(); SendByte(bTargetAddress, 6); RunClock(2); // Run two SCLK cycles between writing and reading SetSDATAHiZ(); // Set to HiZ so Target can drive SDATA bTargetDataIN = bReceiveByte(); RunClock(1); SendVector(read_byte_v + 1, 1); // Send the ReadByte Vector End // Test the Byte that was read from the Target against the original // value (already in the 128-Byte array "abTargetDataOUT[]"). If it // matches, then bump the address & pointer,loop-back and continue. // If it does NOT match abort the loop and return an error. if (bTargetDataIN != abTargetDataOUT[bTargetDataPtr]) return (BLOCK_ERROR); bTargetDataPtr++; // Increment the address by four to accomodate 6-Bit addressing // (puts the 6-bit address into MSBit locations for "SendByte()"). bTargetAddress += 4; } return (PASS); }
/* ============================================================================ // fVerifySiliconID() // Returns: // 0 if successful // Si_ID_ERROR if timed out on handshake to the device. ============================================================================*/ signed char fVerifySiliconID(void) { SendVector(id_setup_2, num_bits_id_setup_2); fIsError = fDetectHiLoTransition(); if (fIsError) return SiID_ERROR; SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); SendVector(tsync_enable, num_bits_tsync_enable); /* Send Read ID vector and get Target ID */ SendVector(read_id_v, 11); /* Read-MSB Vector is the first 11-Bits */ RunClock(2); /* Two SCLK cycles between write & read */ bTargetID[0] = bReceiveByte(); RunClock(1); SendVector(read_id_v+2, 12); /* 1+11 bits starting from the 3rd byte */ RunClock(2); /* Read-LSB Command */ bTargetID[1] = bReceiveByte(); RunClock(1); SendVector(read_id_v+4, 1); /* 1 bit starting from the 5th byte */ /* read Revision ID from Accumulator A and Accumulator X */ SendVector(read_id_v+5, 11); /* 11 bits starting from the 6th byte */ RunClock(2); bTargetID[2] = bReceiveByte(); /* Read from Acc.X */ RunClock(1); SendVector(read_id_v+7, 12); /* 1+11 bits starting from the 8th byte */ RunClock(2); bTargetID[3] = bReceiveByte(); /* Read from Acc.A */ RunClock(1); SendVector(read_id_v+4, 1); /*1 bit starting from the 5th byte, */ SendVector(tsync_disable, num_bits_tsync_disable); pr_info("%s: bTargetID[0] = %x, bTargetID[1] = %x\n", __func__, bTargetID[0], bTargetID[1]); if (bTargetID[0] == target_id_v_1[0] || bTargetID[1] == target_id_v_1[1]) return PASS; else if (bTargetID[0] == target_id_v_2[0] || bTargetID[1] == target_id_v_2[1]) return PASS; else return SiID_ERROR; }
signed char fVerifySetup(unsigned char bBankNumber, unsigned char bBlockNumber) { SendVector(set_block_num, num_bits_set_block_num); /* Set the drive here because SendByte() does not */ SetSDATAStrong(); SendByte(bBlockNumber, 8); SendByte(set_block_num_end, 3); SendVector(verify_setup, num_bits_my_verify_setup); fIsError = fDetectHiLoTransition(); if (fIsError != 0) return VERIFY_ERROR; SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); return PASS; }
/* ============================================================================ // fXRESInitializeTargetForISSP() // Implements the intialization vectors for the device. // Returns: // 0 if successful // INIT_ERROR if timed out on handshake to the device. ============================================================================*/ signed char fXRESInitializeTargetForISSP(void) { /* Configure the pins for initialization */ SetSDATAHiZ(); SetSCLKStrong(); SCLKLow(); #ifdef ACTIVE_LOW_XRES AssertXRES(); /* assert XRES before setting XRES pin to strong */ SetXRESStrong(); DeassertXRES(); /* Delay(XRES_CLK_DELAY); */ mdelay(1); AssertXRES(); #else /* Cycle reset and put the device in programming mode when it exits reset */ SetXRESStrong(); AssertXRES(); Delay(XRES_CLK_DELAY); DeassertXRES(); #endif /* !!! NOTE: // The timing spec that requires that the first Init-Vector happen within // 1 msec after the reset/power up. For this reason, it is not advisable // to separate the above RESET_MODE or POWER_CYCLE_MODE code from the // Init-Vector instructions below. Doing so could introduce excess delay // and cause the target device to exit ISSP Mode. */ SendVector(id_setup_1, num_bits_id_setup_1); fIsError = fDetectHiLoTransition(); if (fIsError) return INIT_ERROR; SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); /* NOTE: DO NOT not wait for HiLo on SDATA after vector Init-3 // it does not occur (per spec). */ return PASS; }
// ============================================================================ // fVerifySetup() // Verify the block just written to. This can be done byte-by-byte before the // protection bits are set. // Returns: // 0 if successful // BLOCK_ERROR if timed out on handshake to the device. // ============================================================================ signed char fVerifySetup(unsigned char bBankNumber, unsigned char bBlockNumber) { SendVector(tsync_enable, num_bits_tsync_enable); SendVector(set_block_num, num_bits_set_block_num); //Set the drive here because SendByte() does not SetSDATAStrong(); SendByte(bBlockNumber, 8); SendByte(set_block_num_end, 3); //PTJ: SendVector(tsync_disable, num_bits_tsync_disable); //PTJ: SendVector(verify_setup, num_bits_my_verify_setup); //PTJ: if ((fIsError = fDetectHiLoTransition())) { return (BLOCK_ERROR); } SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); return (PASS); }
/* ============================================================================ // fSecureTargetFlash() // Before calling, load the array, abTargetDataOUT, with the desired security // settings using LoadArrayWithSecurityData(StartAddress,Length,SecurityType). // The can be called multiple times with different SecurityTypes as needed for // particular Flash Blocks. Or set them all the same using the call below: // LoadArrayWithSecurityData(0,SECURITY_BYTES_PER_BANK, 0); // Returns: // 0 if successful // SECURITY_ERROR if timed out on handshake to the device. ============================================================================*/ signed char fSecureTargetFlash(void) { unsigned char bTemp; /* Transfer the temporary RAM array into the target */ bTargetAddress = 0x00; bTargetDataPtr = 0x00; SendVector(tsync_enable, num_bits_tsync_enable); SendVector(read_write_setup, num_bits_read_write_setup); SetSDATAStrong(); while (bTargetDataPtr < SECURITY_BYTES_PER_BANK) { bTemp = abTargetDataOUT[bTargetDataPtr]; SendByte(write_byte_start, 4); SendByte(bTargetAddress, 7); SendByte(bTemp, 8); SendByte(write_byte_end, 3); /* SendBytes() uses MSBits, so increment the address by '2' to put // the 0..n address into the seven MSBit locations */ bTargetAddress += 2; /* inc by 2 in order to support a 128 byte address space */ bTargetDataPtr++; } SendVector(tsync_disable, num_bits_tsync_disable); SendVector(secure, num_bits_secure); fIsError = fDetectHiLoTransition(); if (fIsError) return SECURITY_ERROR; SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); return PASS; }
/*============================================================================ fXRESInitializeTargetForISSP() Implements the intialization vectors for the device. Returns: 0 if successful INIT_ERROR if timed out on handshake to the device. ============================================================================ */ signed char fXRESInitializeTargetForISSP(void) { /*Configure the pins for initialization*/ SetSDATAHiZ(); SetSCLKStrong(); SCLKLow(); SetXRESStrong(); /* Cycle reset and put the device in programming mode when it exits reset */ AssertXRES(); Delay(XRES_CLK_DELAY); DeassertXRES(); /* !!! NOTE: The timing spec that requires that the first Init-Vector happen within 1 msec after the reset/power up. For this reason, it is not advisable to separate the above RESET_MODE or POWER_CYCLE_MODE code from the Init-Vector instructions below. Doing so could introduce excess delay and cause the target device to exit ISSP Mode. PTJ: Send id_setup_1 instead of init1_v PTJ: both send CA Test Key and do a Calibrate1 SROM function */ SendVector(id_setup_1, num_bits_id_setup_1); fIsError = fDetectHiLoTransition(); if (fIsError != 0) return INIT_ERROR; SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); /* NOTE: DO NOT not wait for HiLo on SDATA after vector Init-3 it does not occur (per spec). */ return PASS; }
signed char fAccTargetBankChecksum(unsigned int *pAcc) { unsigned int wCheckSumData = 0; SendVector(checksum_v, num_bits_checksum); fIsError = fDetectHiLoTransition(); if (fIsError != 0) return CHECKSUM_ERROR; SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); /*Send Read Checksum vector and get Target Checksum*/ SendVector(read_checksum_v, 11); /*first 11-bits is ReadCKSum-MSB*/ RunClock(2); /*Two SCLKs between write & read*/ bTargetDataIN = bReceiveByte(); RunClock(1); wCheckSumData = ((unsigned int) bTargetDataIN)<<8; /*12 bits starting from 3rd character*/ SendVector(read_checksum_v + 2, 12); RunClock(2); /* Read-LSB Command*/ bTargetDataIN = bReceiveByte(); RunClock(1); /*Send the final bit of the command */ SendVector(read_checksum_v + 4, 1); wCheckSumData |= (unsigned int) bTargetDataIN; *pAcc = wCheckSumData; return PASS; }
// ============================================================================ // fVerifySiliconID() // Returns: // 0 if successful // Si_ID_ERROR if timed out on handshake to the device. // ============================================================================ signed char fVerifySiliconID(void) { SendVector(id_setup_2, num_bits_id_setup_2); fIsError = fDetectHiLoTransition(); if (fIsError) { #ifdef TX_ON UART_PutCRLF(); UART_CPutString("fDetectHiLoTransition Error"); #endif return(SiID_ERROR); } SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); SendVector(tsync_enable, num_bits_tsync_enable); //Send Read ID vector and get Target ID SendVector(read_id_v, 11); // Read-MSB Vector is the first 11-Bits RunClock(2); // Two SCLK cycles between write & read bTargetID[0] = bReceiveByte(); RunClock(1); SendVector(read_id_v+2, 12); // 1+11 bits starting from the 3rd byte RunClock(2); // Read-LSB Command bTargetID[1] = bReceiveByte(); RunClock(1); SendVector(read_id_v+4, 1); // 1 bit starting from the 5th byte //read Revision ID from Accumulator A and Accumulator X //SendVector(read_id_v+5, 11); //11 bits starting from the 6th byte //RunClock(2); //bTargetID[2] = bReceiveByte(); //Read from Acc.X //RunClock(1); //SendVector(read_id_v+7, 12); //1+11 bits starting from the 8th byte // //RunClock(2); //bTargetID[3] = bReceiveByte(); //Read from Acc.A // //RunClock(1); //SendVector(read_id_v+4, 1); //1 bit starting from the 5th byte, SendVector(tsync_disable, num_bits_tsync_disable); #ifdef TX_ON // Print READ-ID UART_PutCRLF(); UART_CPutString("Silicon-ID : "); UART_PutChar(' '); UART_PutHexByte(bTargetID[0]); UART_PutChar(' '); UART_PutHexByte(bTargetID[1]); UART_PutChar(' '); #endif #ifdef LCD_ON LCD_Char_Position(1, 0); LCD_Char_PrintString("ID : "); LCD_Char_PrintInt8(bTargetID[0]); LCD_Char_PutChar(' '); LCD_Char_PrintInt8(bTargetID[1]); LCD_Char_PutChar(' '); #endif if (bTargetID[0] == target_id_v[0] && bTargetID[1] == target_id_v[1]) { return(PASS); } else if (bTargetID[0] == target_id_v2[0] && bTargetID[1] == target_id_v2[1]) { return(PASS); } else { printk("%x %x \n", bTargetID[0], bTargetID[1]); return(SiID_ERROR); } }
// ============================================================================ // fVerifySiliconID() // Returns: // 0 if successful // Si_ID_ERROR if timed out on handshake to the device. // ============================================================================ signed char fVerifySiliconID(void) { SendVector(id_setup_2, num_bits_id_setup_2); //printk(KERN_ERR"fVerifySiliconID: SendVector id_stup2 END\n"); if ((fIsError = fDetectHiLoTransition())) { printk(KERN_INFO "fVerifySiliconID(): fDetectHiLoTransition Error\n"); return (SiID_ERROR); } SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); SendVector(tsync_enable, num_bits_tsync_enable); //printk(KERN_ERR"fVerifySiliconID: SendVector(wait_and_poll_end) (tsync_enable) END\n"); //Send Read ID vector and get Target ID SendVector(read_id_v, 11); // Read-MSB Vector is the first 11-Bits RunClock(2); // Two SCLK cycles between write & read bTargetID[0] = bReceiveByte(); RunClock(1); SendVector(read_id_v + 2, 12); // 1+11 bits starting from the 3rd byte RunClock(2); // Read-LSB Command bTargetID[1] = bReceiveByte(); RunClock(1); SendVector(read_id_v + 4, 1); // 1 bit starting from the 5th byte //read Revision ID from Accumulator A and Accumulator X SendVector(read_id_v + 5, 11); //11 bits starting from the 6th byte RunClock(2); bTargetID[2] = bReceiveByte(); //Read from Acc.X RunClock(1); SendVector(read_id_v + 7, 12); //1+11 bits starting from the 8th byte RunClock(2); bTargetID[3] = bReceiveByte(); //Read from Acc.A RunClock(1); SendVector(read_id_v + 4, 1); //1bit starting from the 5th byte, SendVector(tsync_disable, num_bits_tsync_disable); // Print READ-ID /* TX8SW_CPutString("\r\n Silicon-ID : "); TX8SW_PutChar(' '); TX8SW_PutSHexByte(bTargetID[0]); TX8SW_PutChar(' '); TX8SW_PutSHexByte(bTargetID[1]); TX8SW_PutChar(' '); TX8SW_PutSHexByte(bTargetID[2]); TX8SW_PutChar(' '); TX8SW_PutSHexByte(bTargetID[3]); TX8SW_PutChar(' '); */ #if 0 // issp_test_20100709 block printk("issp_routines.c: ID0:0x%X, ID1:0x%X, ID2: 0x%X, ID2: 0x%X\n", bTargetID[0], bTargetID[1], bTargetID[2], bTargetID[3]); if ((bTargetID[0] != target_id_v[0]) || (bTargetID[1] != target_id_v[1]) || (bTargetID[2] != target_id_v[2]) || (bTargetID[3] != target_id_v[3])) { return (SiID_ERROR); } else { return (PASS); } #else return (PASS); #endif }
signed char fVerifySiliconID(void) { SendVector(id_setup_2, num_bits_id_setup_2); fIsError = fDetectHiLoTransition(); if (fIsError != 0) { #ifdef TX_ON TX8SW_PutCRLF(); TX8SW_CPutString("fDetectHiLoTransition Error"); #endif #ifdef LCD_ON LCD_Char_PrintString("fDetectHiLoTransition Error"); #endif return SiID_ERROR; } SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); /* Send Read ID vector and get Target ID */ SendVector(read_id_v, 11); /*Read-MSB Vector is the first 11-Bits */ RunClock(2); /*Two SCLK cycles between write & read */ bTargetID[0] = bReceiveByte(); RunClock(1); /* 1+11 bits starting from the 3rd byte */ SendVector(read_id_v + 2, 12); RunClock(2); /* Read-LSB Command */ bTargetID[1] = bReceiveByte(); RunClock(1); SendVector(read_id_v+4, 1); /*1 bit starting from the 5th byte */ #ifdef TX_ON /*Print READ-ID */ TX8SW_PutCRLF(); TX8SW_CPutString("Silicon-ID : "); TX8SW_PutChar(' '); TX8SW_PutSHexByte(bTargetID[0]); TX8SW_PutChar(' '); TX8SW_PutSHexByte(bTargetID[1]); TX8SW_PutChar(' '); /* See the latest spec. 40-95002, 40-95004, 001-15870, AN2026d*/ switch (bTargetID[0]) { case 0x00: TX8SW_CPutString( "\r\nPSoC1 = 00xx (including Ovation-ONS)"); switch (bTargetID[1]) { case 0x68: TX8SW_CPutString( "\r\nCY8C20234 8K, 512B(Quark)"); TargetDatabufLen = 64; NumBanks = 1; BlocksPerBank = 128; SecurityBytesPerBank = 64; break; case 0xAD: TX8SW_CPutString( "\r\nCY8C20446A-24LQXI 16K, 2K(Krypton)"); TargetDatabufLen = 128; NumBanks = 1; BlocksPerBank = 128; SecurityBytesPerBank = 64; break; case 0x37: TX8SW_CPutString( "\r\nCY8C21334 Automotive(Neutron) 8K,512B"); TargetDatabufLen = 64; NumBanks = 1; BlocksPerBank = 128; SecurityBytesPerBank = 64; break; case 0x38: TX8SW_CPutString( "\r\nCY8C21434 Neutron"); TargetDatabufLen = 64; NumBanks = 1; BlocksPerBank = 128; SecurityBytesPerBank = 64; break; default: break; } break; case 0x01: TX8SW_CPutString( "\r\nPSoC1 = 01xx(continued family and mask set growth"); break; case 0x02: TX8SW_CPutString( "\r\nPSoC1 + SmartSense = 02xx"); break; case 0x03: TX8SW_CPutString("\r\nUnallocated = 03xx"); break; case 0x04: TX8SW_CPutString("\r\nPower PSoC = 04xx"); break; case 0x05: TX8SW_CPutString( "\r\nTrueTouch Multi-Touch All Points(TMA) = 05xx"); switch (bTargetID[1]) { case 0x9A: TX8SW_CPutString( "\r\nCY8CTMA340-LQI-01"); TargetDatabufLen = 128; NumBanks = 1; BlocksPerBank = 256; SecurityBytesPerBank = 64; break; default: break; } break; case 0x06: TX8SW_CPutString( "\r\nTrueTouch Single Touch(TST) = 06xx"); break; case 0x07: TX8SW_CPutString( "\r\nTrueTouch Multi-Touch Gesture(TMG) = 07xx"); break; case 0x08: TX8SW_CPutString( "\r\nPSoC1 Value = 08xx"); break; case 0x09: TX8SW_CPutString( "\r\nPSoC1 PLC = 09xx"); break; case 0x0A: TX8SW_CPutString( "\r\nPSoC1 PLC + Ez Color = 0Axx"); break; case 0x0B: TX8SW_CPutString( "\r\nPSoC1 + SmartSense_EMC = 0Bxx"); break; case 0x0C: TX8SW_CPutString( "\r\nHaptics Only = 0Cxx"); break; case 0x0D: TX8SW_CPutString( "\r\nHaptics + TrueTouch Multi-Touch All Points(TMA) = 0Dxx"); break; case 0x0E: TX8SW_CPutString( "\r\nHaptics + TrueTouch Single Touch(TST = 0Exx"); break; case 0x0F: TX8SW_CPutString( "\r\nHaptics + TrueTouch Multi-Touch Gesture(TMG) = 0Fxx"); break; default: TX8SW_CPutString("\r\nUnknown Silicon ID !!"); while (1) ; break; } #endif target_id_v[0] = bTargetID[0]; target_id_v[1] = bTargetID[1]; #ifdef LCD_ON LCD_Char_Position(1, 0); LCD_Char_PrintString("ID : "); LCD_Char_PrintInt8(bTargetID[0]); LCD_Char_PutChar(' '); LCD_Char_PrintInt8(bTargetID[1]); LCD_Char_PutChar(' '); #endif if (bTargetID[0] != target_id_v[0] || bTargetID[1] != target_id_v[1]) return SiID_ERROR; else return PASS; }
/* ============================================================================ fPowerCycleInitializeTargetForISSP() Implements the intialization vectors for the device. The first time fDetectHiLoTransition is called the Clk pin is highZ because the clock is not needed during acquire. Returns: 0 if successful INIT_ERROR if timed out on handshake to the device. ============================================================================ */ signed char fPowerCycleInitializeTargetForISSP(void) { unsigned char n; /* Set all pins to highZ to avoid back powering the PSoC through the GPIO protection diodes. */ SetSCLKHiZ(); SetSDATAHiZ(); /* Turn on power to the target device before other signals */ SetTargetVDDStrong(); for (n = 0; n < 100; n++) Delay(50000); ApplyTargetVDD(); /* wait 1msec for the power to stabilize */ for (n = 0; n < 10; n++) Delay(DELAY100us); /* Set SCLK to high Z so there is no clock and wait for a high to low transition on SDAT. SCLK is not needed this time. */ SetSCLKHiZ(); fIsError = fDetectHiLoTransition(); if (fIsError != 0) return INIT_ERROR; /*Configure the pins for initialization */ SetSDATAHiZ(); SetSCLKStrong(); SCLKLow(); /*PTJ: DO NOT SET A BREAKPOINT HERE AND EXPECT SILICON ID TO PASS! !!! NOTE: The timing spec that requires that the first Init-Vector happen within 1 msec after the reset/power up. For this reason, it is not advisable to separate the above RESET_MODE or POWER_CYCLE_MODE code from the Init-Vector instructions below. Doing so could introduce excess delay and cause the target device to exit ISSP Mode. */ SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); /*20100114 KJHW(Jason) : 0114 by KJHW */ SendVector(id_setup_1, num_bits_id_setup_1); fIsError = fDetectHiLoTransition(); if (fIsError != 0) return INIT_ERROR; SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); /* NOTE: DO NOT not wait for HiLo on SDATA after vector Init-3 it does not occur (per spec). */ return PASS; }
/* ============================================================================ // XCH: fVerifySecurity() // This step is optional. Verifies that the security bits have been written correctly ============================================================================ */ signed char fVerifySecurity(void) { /* unsigned char bBlockNumber = 0;//wly */ bTargetAddress = 0x00; #ifdef USE_TP SetTPHigh(); /* Only used of Test Points are enabled */ #endif #ifdef USE_TP SetTPLow(); /* Only used of Test Points are enabled */ #endif SendVector(verify_security, num_bits_verify_security); fIsError = fDetectHiLoTransition(); if (fIsError) return INIT_ERROR; #ifdef USE_TP SetTPHigh(); /* Only used of Test Points are enabled */ #endif #ifdef USE_TP SetTPLow(); /* Only used of Test Points are enabled */ #endif SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); bTargetAddress = 0x00; bTargetDataPtr = 0x00; SendVector(tsync_enable, num_bits_tsync_enable); SendVector(read_write_setup, num_bits_read_write_setup); /* fReadWriteSetup(); */ /* we do SECURITY_BYTES_PER_BANK * 2 because we bTargetAddress += 2 */ while (bTargetAddress < (SECURITY_BYTES_PER_BANK * 2)) { /* Send Read Byte vector and then get a byte from Target */ SendVector(read_byte_v, 4); /* Set the drive here because SendByte() does not */ SetSDATAStrong(); SendByte(bTargetAddress, 7); SetSDATAHiZ(); /* Set to HiZ so Target can drive SDATA */ RunClock(2); /* Run two SCLK cycles between writing and reading */ bTargetDataIN = bReceiveByte(); RunClock(1); SendVector(read_byte_v + 1, 1); /* Send the ReadByte Vector End */ /* Test the Byte that was read from the Target against the original // value (already in the 128-Byte array "abTargetDataOUT[]"). If it // matches, then bump the address & pointer,loop-back and continue. // If it does NOT match abort the loop and return and error. */ if (bTargetDataIN != abTargetDataOUT[bTargetDataPtr]) return BLOCK_ERROR; /* Increment the address by two to accomodate 7-Bit addressing (puts the 7-bit address into MSBit locations for "SendByte()"). */ bTargetDataPtr++; bTargetAddress += 2; } SendVector(tsync_disable, num_bits_tsync_disable); return PASS; }
/* ============================================================================ // fEraseBlock() // Perform a block erase of the target device. // Returns: // 0 if successful // ERASE_ERROR if timed out on handshake to the device. ============================================================================*/ signed char fEraseBlock(unsigned char bBlockNumber) { unsigned char bTargetDataPtr = 0; SendVector(tsync_enable, num_bits_tsync_enable); SendVector(read_write_setup, num_bits_read_write_setup); /* Set SDATA to Strong Drive here because SendByte() does not */ SetSDATAStrong(); /* Transfer the temporary RAM array into the target. // In this section, a 128-Byte array was specified by #define, so the entire // 128-Bytes are written in this loop. */ bTargetAddress = 0x00; while (bTargetDataPtr < TARGET_DATABUFF_LEN) { SendByte(write_byte_start, 4); /* we need to be able to write 128 bytes from address 0x80 to 0xFF*/ SendByte(bTargetAddress, 7); /* we need to be able to write 128 bytes from address 0x80 to 0xFF*/ SendByte(0, 8); /* load 0x00 */ SendByte(write_byte_end, 3); /* !!!NOTE: // SendByte() uses MSbits, so inc by '2' to put the 0..128 address into // the seven MSBit locations. // // This can be confusing, but check the logic: // The address is only 7-Bits long. The SendByte() subroutine will // send however-many bits, BUT...always reads them bits from left-to- // right. So in order to pass a value of 0..128 as the address using // SendByte(), we have to left justify the address by 1-Bit. // This can be done easily by incrementing the address each time by // '2' rather than by '1'. */ bTargetAddress += 2; /* inc by 2 in order to support a 128 byte address space */ bTargetDataPtr++; } SendVector(set_block_num, num_bits_set_block_num); /* Set the drive here because SendByte() does not. */ SetSDATAStrong(); SendByte(bBlockNumber, 8); SendByte(set_block_num_end, 3); SendVector(tsync_disable, num_bits_tsync_disable); /* Send the program-and-verify vector. */ SendVector(program_and_verify, num_bits_program_and_verify); /* wait for acknowledge from target. */ fIsError = fDetectHiLoTransition(); if (fIsError) return BLOCK_ERROR; /* Send the Wait-For-Poll-End vector */ SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); /*---------------------------------------------------------------- // XCH: the lines below actually implement the erase SROM function // however, Product Engineering recommends using the WRITE SROM // function instead and write all '0' to the block. The function // below is saved for possible future implementation */ /* SendVector(tsync_enable, num_bits_tsync_enable); // SendVector(set_block_num, num_bits_set_block_num); // Set the drive here because SendByte() does not. // SetSDATAStrong(); // SendByte(bBlockNumber,8); // SendByte(set_block_num_end, 3); // SendVector(tsync_disable, num_bits_tsync_disable); // Send the erase-block vector. // SendVector(erase_block, num_bits_erase_block); // wait for acknowledge from target. // if (fIsError == fDetectHiLoTransition()) { // return(BLOCK_ERROR); // } // Send the Wait-For-Poll-End vector // SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); //----------------------------------------------------------------- */ return PASS; }
/* ============================================================================ // fPowerCycleInitializeTargetForISSP() // Implements the intialization vectors for the device. // The first time fDetectHiLoTransition is called the Clk pin is highZ because // the clock is not needed during acquire. // Returns: // 0 if successful // INIT_ERROR if timed out on handshake to the device. ============================================================================*/ signed char fPowerCycleInitializeTargetForISSP(void) { unsigned char n; SetSDATALow(); SCLKLow(); RemoveTargetVDD(); mdelay(500); SetSCLKHiZ(); SetSDATAHiZ(); /* Set all pins to highZ to avoid back powering the PSoC through the GPIO // protection diodes. */ /* Turn on power to the target device before other signals */ SetTargetVDDStrong(); ApplyTargetVDD(); /* wait 1msec for the power to stabilize */ for (n = 0; n < 10; n++) udelay(DELAY100us); /* Set SCLK to high Z so there is no clock and wait for a high to low // transition on SDAT. SCLK is not needed this time. */ SetSCLKHiZ(); mdelay(10); /* //fIsError = fDetectHiLoTransition(); //if (fIsError ) { //printk("wly: fDetectHiLoTransition 11111 failed!\n"); //return(INIT_ERROR); //} */ /* Configure the pins for initialization */ SetSDATAHiZ(); SetSCLKStrong(); SCLKLow(); /* DO NOT SET A BREAKPOINT HERE AND EXPECT SILICON ID TO PASS! */ /* !!! NOTE: // The timing spec that requires that the first Init-Vector happen within // 1 msec after the reset/power up. For this reason, it is not advisable // to separate the above RESET_MODE or POWER_CYCLE_MODE code from the // Init-Vector instructions below. Doing so could introduce excess delay // and cause the target device to exit ISSP Mode. */ SendVector(id_setup_1, num_bits_id_setup_1); fIsError = fDetectHiLoTransition(); if (fIsError) { pr_info("wly: fDetectHiLoTransition 222222 failed!\n"); return INIT_ERROR; } SendVector(wait_and_poll_end, num_bits_wait_and_poll_end); /* NOTE: DO NOT not wait for HiLo on SDATA after vector Init-3 // it does not occur (per spec). */ return PASS; }