#if !defined _TMA140_DOWNLOAD_CORI_H_ | |
#define _TMA140_DOWNLOAD_CORI_H_ | |
////////////////////////////////////////////////////////////////////////// | |
////////////////////////////////////////////////////////////////////////// | |
///// | |
///// issp_revision.h | |
///// | |
////////////////////////////////////////////////////////////////////////// | |
////////////////////////////////////////////////////////////////////////// | |
#define PROJECT_REV_304 | |
////////////////////////////////////////////////////////////////////////// | |
////////////////////////////////////////////////////////////////////////// | |
///// | |
///// issp_directives.h | |
///// | |
////////////////////////////////////////////////////////////////////////// | |
////////////////////////////////////////////////////////////////////////// | |
//#define CY8CTMA300E_36LQXI | |
//#define CY8CTMA301D_48LTXI | |
#define CY8CTMA340_36LQXI | |
////////////////////////////////////////////////////////////////////////// | |
////////////////////////////////////////////////////////////////////////// | |
///// | |
///// issp_defs.h | |
///// | |
////////////////////////////////////////////////////////////////////////// | |
////////////////////////////////////////////////////////////////////////// | |
// Block-Verify Uses 128-Bytes of RAM | |
#define TARGET_DATABUFF_LEN 128 // **** CY8C20x66 Device **** | |
// The number of Flash blocks in each part is defined here. This is used in | |
// main programming loop when programming and verifying the blocks. | |
#define NUM_BANKS 1 | |
#define BLOCKS_PER_BANK 256 | |
//#define BLOCKS_PER_BANK 128 | |
#define SECURITY_BYTES_PER_BANK 64 | |
////////////////////////////////////////////////////////////////////////// | |
////////////////////////////////////////////////////////////////////////// | |
///// | |
///// issp_delays.h | |
///// | |
////////////////////////////////////////////////////////////////////////// | |
////////////////////////////////////////////////////////////////////////// | |
// DELAY_M is the slope of the Delay = Mx + B equation | |
#define DELAY_M 1 | |
// DELAY_B is the offset of the delay in Delay = Mx + B. | |
#define DELAY_B 3 | |
/////////////////////////////////////////////////////////////////////////////// | |
// CAUTION: | |
// For the above parameters the minimum delay value is 3 (this would result in | |
// 0 being passed for a minimum delay. A value less than 3 would actually | |
// create a negative number, causing a very long delay | |
/////////////////////////////////////////////////////////////////////////////// | |
// TRANSITION_TIMEOUT is a loop counter for a 100msec timeout when waiting for | |
// a high-to-low transition. This is used in the polling loop of | |
// fDetectHiLoTransition(). Each pass through the loop takes approximately 15 | |
// usec. 100 msec is about 6740 loops. 13480 | |
#define TRANSITION_TIMEOUT (65535*10) | |
//#define TRANSITION_TIMEOUT (100*1000) | |
// XRES_DELAY is the time duration for which XRES is asserted. This defines | |
// a 63 usec delay. | |
// The minimum Xres time (from the device datasheet) is 10 usec. | |
#define XRES_CLK_DELAY ((63 - DELAY_B) / DELAY_M) | |
// POWER_CYCLE_DELAY is the time required when power is cycled to the target | |
// device to create a power reset after programming has been completed. The | |
// actual time of this delay will vary from system to system depending on the | |
// bypass capacitor size. A delay of 150 usec is used here. | |
#define POWER_CYCLE_DELAY ((150 - DELAY_B) / DELAY_M) | |
// DELAY_100us delays 100 usec. This is used in fXRESInitializeTargetForISSP to | |
// time the wait for Vdd to become stable after a power up. A loop runs 10 of | |
// these for a total delay of 1 msec. | |
#define DELAY100us ((100 - DELAY_B) / DELAY_M) | |
////////////////////////////////////////////////////////////////////////// | |
////////////////////////////////////////////////////////////////////////// | |
///// | |
///// issp_errors.h | |
///// | |
////////////////////////////////////////////////////////////////////////// | |
////////////////////////////////////////////////////////////////////////// | |
// The following are defines for error messages from the ISSP program. | |
#define PASS 0 | |
// PASS is used to indicate that a function completed successfully. | |
#define ERROR -1 | |
// ERROR is a generic failure used within lower level functions before the | |
// error is reported. This should not be seen as an error that is reported | |
// from main. | |
#define INIT_ERROR 1 | |
// INIT_ERROR means a step in chip initialization failed. | |
#define SiID_ERROR 2 | |
// SiID_ERROR means that the Silicon ID check failed. This happens if the | |
// target part does not match the device type that the ISSP program is | |
// configured for. | |
#define ERASE_ERROR 3 | |
// ERASE_ERROR means that the bulk erase step failed. | |
#define BLOCK_ERROR 4 | |
// BLOCK_ERROR means that a step in programming a Flash block or the verify | |
// of the block failed. | |
#define VERIFY_ERROR 5 | |
// VERIFY_ERROR means that the checksum verification failed. | |
#define SECURITY_ERROR 6 | |
// SECURITY_ERROR means that the write of the security information failed. | |
#define STATUS_ERROR 7 | |
#define CHECKSUM_ERROR 8 | |
#define NO_FIRMWARE_ERROR 0x10 | |
#define FILE_ACCESS_ERROR 0x11 | |
////////////////////////////////////////////////////////////////////////// | |
////////////////////////////////////////////////////////////////////////// | |
///// | |
///// issp_vectors.h | |
///// | |
////////////////////////////////////////////////////////////////////////// | |
////////////////////////////////////////////////////////////////////////// | |
#ifdef CY8CTMA300D_36LQXI | |
unsigned char target_id_v[] = {0x05, 0x79}; //ID for CY8CTMA300D_36LQXI | |
#endif | |
#ifdef CY8CTMA300E_36LQXI | |
unsigned char target_id_v[] = {0x05, 0x82}; //ID for CY8CTMA300E_36LQXI | |
#endif | |
#ifdef CY8CTMA340_36LQXI | |
unsigned char target_id_v[] = {0x05, 0x96}; //ID for CY8CTMA340_36LQXI | |
#endif | |
#ifdef CY8CTMA301D_48LTXI | |
unsigned char target_id_v[] = {0x05, 0x77}; //ID for CY8CTMA301D_48LTXI | |
#endif | |
const unsigned int num_bits_checksum = 418; | |
const unsigned char checksum_v[] = | |
{ | |
0xDE, 0xE2, 0x1F, 0x7F, 0x02, 0x7D, 0xC4, 0x09, 0xF7, 0x00, | |
0x1F, 0x9F, 0x07, 0x5E, 0x7C, 0x81, 0xF9, 0xF4, 0x01, 0xF7, | |
0xF0, 0x07, 0xDC, 0x40, 0x1F, 0x70, 0x01, 0xFD, 0xEE, 0x01, | |
0xF7, 0xA0, 0x1F, 0xDE, 0xA0, 0x1F, 0x7B, 0x00, 0x7D, 0xE0, | |
0x0F, 0xF7, 0xC0, 0x07, 0xDF, 0x28, 0x1F, 0x7D, 0x18, 0x7D, | |
0xFE, 0x25, 0xC0 | |
}; | |
const unsigned char read_status[] = | |
{ | |
0xBF, 0x00, 0x80 | |
}; | |
const unsigned int num_bits_id_setup_1 = 616; | |
const unsigned char id_setup_1[] = | |
{ | |
0xCA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, | |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D, 0xEE, 0x21, 0xF7, | |
0xF0, 0x27, 0xDC, 0x40, 0x9F, 0x70, 0x01, 0xFD, 0xEE, 0x01, | |
0xE7, 0xC1, 0xD7, 0x9F, 0x20, 0x7E, 0x3F, 0x9D, 0x78, 0xF6, | |
0x21, 0xF7, 0xB8, 0x87, 0xDF, 0xC0, 0x1F, 0x71, 0x00, 0x7D, | |
0xC0, 0x07, 0xF7, 0xB8, 0x07, 0xDE, 0x80, 0x7F, 0x7A, 0x80, | |
0x7D, 0xEC, 0x01, 0xF7, 0x80, 0x4F, 0xDF, 0x00, 0x1F, 0x7C, | |
0xA0, 0x7D, 0xF4, 0x61, 0xF7, 0xF8, 0x97 | |
}; | |
const unsigned int num_bits_id_setup_2 = 418; | |
const unsigned char id_setup_2[] = | |
{ | |
0xDE, 0xE2, 0x1F, 0x7F, 0x02, 0x7D, 0xC4, 0x09, 0xF7, 0x00, | |
0x1F, 0x9F, 0x07, 0x5E, 0x7C, 0x81, 0xF9, 0xF4, 0x01, 0xF7, | |
0xF0, 0x07, 0xDC, 0x40, 0x1F, 0x70, 0x01, 0xFD, 0xEE, 0x01, | |
0xF7, 0xA0, 0x1F, 0xDE, 0xA0, 0x1F, 0x7B, 0x00, 0x7D, 0xE0, | |
0x0D, 0xF7, 0xC0, 0x07, 0xDF, 0x28, 0x1F, 0x7D, 0x18, 0x7D, | |
0xFE, 0x25, 0xC0 | |
}; | |
const unsigned int num_bits_tsync_enable = 110; | |
const unsigned char tsync_enable[] = | |
{ | |
0xDE, 0xE2, 0x1F, 0x7F, 0x02, 0x7D, 0xC4, 0x09, 0xF7, 0x00, | |
0x1F, 0xDE, 0xE0, 0x1C | |
}; | |
const unsigned int num_bits_tsync_disable = 110; | |
const unsigned char tsync_disable[] = | |
{ | |
0xDE, 0xE2, 0x1F, 0x71, 0x00, 0x7D, 0xFC, 0x01, 0xF7, 0x00, | |
0x1F, 0xDE, 0xE0, 0x1C | |
}; | |
#if 0 | |
const unsigned int num_bits_set_block_num = 33; | |
const unsigned char set_block_num[] = | |
{ | |
0xDE, 0xE0, 0x1E, 0x7D, 0x00, 0x70 | |
}; | |
#else | |
const unsigned int num_bits_set_block_num = 11; | |
const unsigned char set_block_num[] = | |
{ | |
0x9F, 0x40 | |
}; | |
#endif | |
const unsigned int num_bits_set_block_num_end = 3; //PTJ: this selects the first three bits of set_block_num_end | |
const unsigned char set_block_num_end = 0xE0; | |
const unsigned int num_bits_read_write_setup = 66; //PTJ: | |
const unsigned char read_write_setup[] = | |
{ | |
0xDE, 0xF0, 0x1F, 0x78, 0x00, 0x7D, 0xA0, 0x03, 0xC0 | |
}; | |
const unsigned int num_bits_my_verify_setup = 440; | |
const unsigned char verify_setup[] = | |
{ | |
0xDE, 0xE2, 0x1F, 0x7F, 0x02, 0x7D, 0xC4, 0x09, 0xF7, 0x00, | |
0x1F, 0x9F, 0x07, 0x5E, 0x7C, 0x81, 0xF9, 0xF7, 0x01, 0xF7, | |
0xF0, 0x07, 0xDC, 0x40, 0x1F, 0x70, 0x01, 0xFD, 0xEE, 0x01, | |
0xF6, 0xA8, 0x0F, 0xDE, 0x80, 0x7F, 0x7A, 0x80, 0x7D, 0xEC, | |
0x01, 0xF7, 0x80, 0x0F, 0xDF, 0x00, 0x1F, 0x7C, 0xA0, 0x7D, | |
0xF4, 0x61, 0xF7, 0xF8, 0x97 | |
}; | |
const unsigned int num_bits_erase = 396; //PTJ: erase with TSYNC Enable and Disable | |
const unsigned char erase[] = | |
{ | |
0xDE, 0xE2, 0x1F, 0x7F, 0x02, 0x7D, 0xC4, 0x09, 0xF7, 0x00, | |
0x1F, 0x9F, 0x07, 0x5E, 0x7C, 0x85, 0xFD, 0xFC, 0x01, 0xF7, | |
0x10, 0x07, 0xDC, 0x00, 0x7F, 0x7B, 0x80, 0x7D, 0xE0, 0x0B, | |
0xF7, 0xA0, 0x1F, 0xDE, 0xA0, 0x1F, 0x7B, 0x04, 0x7D, 0xF0, | |
0x01, 0xF7, 0xC9, 0x87, 0xDF, 0x48, 0x1F, 0x7F, 0x89, 0x70 | |
}; | |
const unsigned int num_bits_secure = 440; //PTJ: secure with TSYNC Enable and Disable | |
const unsigned char secure[] = | |
{ | |
0xDE, 0xE2, 0x1F, 0x7F, 0x02, 0x7D, 0xC4, 0x09, 0xF7, 0x00, | |
0x1F, 0x9F, 0x07, 0x5E, 0x7C, 0x81, 0xF9, 0xF7, 0x01, 0xF7, | |
0xF0, 0x07, 0xDC, 0x40, 0x1F, 0x70, 0x01, 0xFD, 0xEE, 0x01, | |
0xF6, 0xA0, 0x0F, 0xDE, 0x80, 0x7F, 0x7A, 0x80, 0x7D, 0xEC, | |
0x01, 0xF7, 0x80, 0x27, 0xDF, 0x00, 0x1F, 0x7C, 0xA0, 0x7D, | |
0xF4, 0x61, 0xF7, 0xF8, 0x97 | |
}; | |
const unsigned int num_bits_program_and_verify = 440; //PTJ: length of program_block[], not including zero padding at end | |
const unsigned char program_and_verify[] = | |
{ | |
0xDE, 0xE2, 0x1F, 0x7F, 0x02, 0x7D, 0xC4, 0x09, 0xF7, 0x00, | |
0x1F, 0x9F, 0x07, 0x5E, 0x7C, 0x81, 0xF9, 0xF7, 0x01, 0xF7, | |
0xF0, 0x07, 0xDC, 0x40, 0x1F, 0x70, 0x01, 0xFD, 0xEE, 0x01, | |
0xF6, 0xA0, 0x0F, 0xDE, 0x80, 0x7F, 0x7A, 0x80, 0x7D, 0xEC, | |
0x01, 0xF7, 0x80, 0x57, 0xDF, 0x00, 0x1F, 0x7C, 0xA0, 0x7D, | |
0xF4, 0x61, 0xF7, 0xF8, 0x97 | |
}; | |
const unsigned char read_id_v[] = | |
{ | |
0xBF, 0x00, 0xDF, 0x90, 0x00, 0xFE, 0x60, 0xFF, 0x00 | |
}; | |
const unsigned char write_byte_start = 0x90; //PTJ: this is set to SRAM 0x80 | |
const unsigned char write_byte_end = 0xE0; | |
const unsigned char num_bits_wait_and_poll_end = 40; | |
const unsigned char wait_and_poll_end[] = | |
{ | |
0x00, 0x00, 0x00, 0x00, 0x00 | |
}; | |
const unsigned char read_checksum_v[] = | |
{ | |
0xBF, 0x20, 0xDF, 0x80, 0x80 | |
}; | |
const unsigned char read_byte_v[] = | |
{ | |
0xB0, 0x80 | |
}; | |
////////////////////////////////////////////////////////////////////////// | |
////////////////////////////////////////////////////////////////////////// | |
///// | |
///// issp_extern.h | |
///// | |
////////////////////////////////////////////////////////////////////////// | |
////////////////////////////////////////////////////////////////////////// | |
extern signed char fXRESInitializeTargetForISSP(void); | |
extern signed char fPowerCycleInitializeTargetForISSP(void); | |
extern signed char fEraseTarget(void); | |
extern unsigned int iLoadTarget(void); | |
extern void ReStartTarget(void); | |
extern signed char fVerifySiliconID(void); | |
extern signed char fAccTargetBankChecksum(unsigned int*); | |
extern signed char fProgramTargetBlock(unsigned char, unsigned char); | |
extern signed char fVerifyTargetBlock(unsigned char, unsigned char); | |
extern signed char fVerifySetup(unsigned char, unsigned char); //PTJ: VERIFY-SETUP | |
extern signed char fReadByteLoop(void); //PTJ: read bytes after VERIFY-SETUP | |
extern signed char fSecureTargetFlash(void); | |
extern signed char fReadStatus(void); //PTJ: READ-STATUS | |
extern signed char fReadWriteSetup(void); //PTJ: READ-WRITE-SETUP | |
//extern void InitTargetTestData(void); | |
extern void LoadArrayWithSecurityData(unsigned char, unsigned char, unsigned char); | |
extern void LoadProgramData(unsigned char, unsigned char); | |
extern signed char fLoadSecurityData(unsigned char); | |
extern void Delay(unsigned int); | |
extern unsigned char fSDATACheck(void); | |
extern void SCLKHigh(void); | |
extern void SCLKLow(void); | |
#ifndef RESET_MODE //only needed when power cycle mode | |
extern void SetSCLKHiZ(void); | |
#endif | |
extern void SetSCLKStrong(void); | |
extern void SetSDATAHigh(void); | |
extern void SetSDATALow(void); | |
extern void SetSDATAHiZ(void); | |
extern void SetSDATAStrong(void); | |
extern void AssertXRES(void); | |
extern void DeassertXRES(void); | |
extern void SetXRESStrong(void); | |
extern void ApplyTargetVDD(void); | |
extern void RemoveTargetVDD(void); | |
extern void SetTargetVDDStrong(void); | |
#ifdef TX_ON | |
extern void UART_PutHexHalf(char ch); | |
extern void UART_PutHexByte(unsigned char ch); | |
extern void UART_PutHexWord(unsigned int ch); | |
#endif | |
extern unsigned char fIsError; | |
#endif //_TMA140_DOWNLOAD_CORI_H_ | |