CDCE6214: eeprom write failed

Hi Xiao, 
We don't have any reference designs for this. 

But please review attached CDCE6214 EEPROM script programming procedure done by TICSpro: 

import time
import clr
clr.AddReference("System.Windows.Forms")
from System.Windows.Media import SolidColorBrush,Colors,Color,LinearGradientBrush,ColorConverter
from System.Windows import TextAlignment,VerticalAlignment,FontWeights
from time import sleep,ctime,clock
from System.IO import Directory, Path, File
import re
from System.Windows.Forms import DialogResult, MessageBox, MessageBoxButtons, MessageBoxIcon,OpenFileDialog,SaveFileDialog
from INIParser import ConfigFileParser
from System import Array,Byte
import datetime
from math import floor, pow, ceil
from System.Threading import Thread

global_gui_eeprom_and_reg_data = None         
gDebug = True


def dbg2txt(msg):
    global gDebug
    if gDebug:
        try:
            msg = str(msg)
            strFile = r"TT_debug.log"
            strDir = Path.GetDirectoryName(__file__)
            strFullPath = Path.Combine(strDir, strFile)
            fh = open(strFullPath,"a")
            fh.write(ctime() + "\t" + msg + "\n")
            fh.close()
            fh = None
        except IOError as errdetails:
            UpdateStatusBar("Log File Error: {%1}".format(errdetails.errno, errdetails.strerror))

def BTN_EEP_REGCOMMIT_Update():
    iCRC = ReadParameterAndUpdateUI("nvmlcrc")
    UpdateStatusBar("EEPROM, Register Commit: inital read CRC %i"%iCRC)
    
    if eewriteconfirm(): 
        UpdateStatusBar("EEPROM, Register Commit: disable write protection.")
        ee_lock.iValue = 5; WriteParameter("ee_lock", ee_lock.iValue)
        Thread.Sleep(50)
        UpdateStatusBar("EEPROM, Register Commit: transfer register content.")

        regcommit.iValue = 1; WriteParameter("regcommit", regcommit.iValue)   
        
        Thread.Sleep(400)
        if oeimode.iValue == 1:              
            UpdateStatusBar("EEPROM, Register Commit: set interface mode bit.")
            iregc = ReadParameterAndUpdateUI("regcommit_page")

            iNVMadr = 16 + iregc * 24                                           
            WriteParameter("nvm_rd_addr", iNVMadr)
            iWork = ReadParameterAndUpdateUI("nvm_rd_data")
            if iWork % 2 == 0:                                                 
                iWork += 1
                WriteParameter("nvm_wr_addr",iNVMadr)
                WriteParameter("nvm_wr_data",iWork)
                waitonly(0.05)

        ReadAllRegisters()
        UpdateStatusBar("EEPROM, Register Commit: refresh CRC.")
        
        update_crc.iValue = 1; WriteParameter("update_crc", update_crc.iValue)  
        check_nvm_busy_time_start = time.clock()
        check_nvm_busy_time_stop = check_nvm_busy_time_start
        is_nvm_busy = ReadParameterAndUpdateUI("nvmbusy")
        while 1 == is_nvm_busy and (check_nvm_busy_time_stop - check_nvm_busy_time_start) < 3:
            check_nvm_busy_time_stop = time.clock()
            is_nvm_busy = ReadParameterAndUpdateUI("nvmbusy")
            
        if 1 == is_nvm_busy:
            UpdateStatusBar("WARNING, after 3 seconds, EEPROM is still busy!  Aborting.")
        else:
            UpdateStatusBar("EEPROM no longer busy.  Done commit.")
        iCRC = ReadParameterAndUpdateUI("nvmlcrc")
        if iCRC == -1:
            UpdateStatusBar("EEPROM, Register Commit: reading CRC from device failed.")
            iCRC = 0 
        else:
            UpdateStatusBar("EEPROM, Register Commit: readback CRC %i" % iCRC)
            
        WriteParameter("nvm_wr_addr", 63)           
        WriteParameter("nvm_wr_data", iCRC)
        
        Thread.Sleep(50)
        
        regcommit.iValue = 0
        update_crc.iValue = 0
        ee_lock.iValue = 10
        UpdateStatusBar("EEPROM, Register Commit: re-enable write protection. Done.")

def BTN_EEP_DIR_WRITE2DEVICE_Update():
    filename = eeselectfile()
    if filename:
        eewritefile(filename)

def BTN_EEP_DIR_READ2FILE_Update():
    dialog = SaveFileDialog()
    dialog.Filter = "All Files (*.*)|*.*|EEPROM HEX Files (*.hxt)|*.hxt"
    dialog.FilterIndex = 2
    dialog.Title = "Export Unit EEPROM to HEX Image"
    if dialog.ShowDialog() == DialogResult.OK:   
        eeprom_and_regs = eeprom_to_eeprom_data()
        if eeprom_and_regs != None:
            dump_string = create_eeprom_dump_string(*eeprom_and_regs)
        
            fh = open(dialog.FileName,"w")
            fh.write(dump_string)
            fh.close()
            
            UpdateStatusBar("EEPROM file saved (" + dialog.FileName+ ")")
        else:
            UpdateStatusBar("Failed to get data to save int (" + dialog.FileName + ")")
    else:
        UpdateStatusBar("EEPROM read aborted (" + dialog.FileName + ")")
    pass

def eeselectfile(open_true_or_save_false=True):
    if open_true_or_save_false:
        dialog = OpenFileDialog()
    else:
        dialog = SaveFileDialog()
    dialog.Filter = "All Files (*.*)|*.*|EEPROM HEX Files (*.hxt)|*.hxt"
    dialog.FilterIndex = 2
    dialog.Title = "Select EEPROM Image"
    if dialog.ShowDialog() == DialogResult.OK:
        return dialog.FileName
        
    return None

def eewritefile(filename):
    if eewriteconfirm():
        waitval = 0.01
        iCRCfromFILE = 0
        iCRC = 0
        UpdateStatusBar("Writing EEPROM File " + filename)
        ee_lock.iValue = 5; WriteParameter("ee_lock", ee_lock.iValue)
        eewait(waitval)
        
        strHXT = ""
        if len(filename) > 4:
            fh = open(filename,"r")
            for line in fh:
                strHXT = strHXT + line
            fh.close()
            lHXT = re.findall(r'([0-9][0-9])\t0x([0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f])\t([0-9][0-9]*)',strHXT)
            if len(lHXT)==64:
                liEE = []
                for i in range(0,64):
                    if len(lHXT[i])==3:
                        liEE.append(int(lHXT[i][1][0:2],16))
                        liEE.append(int(lHXT[i][1][2:4],16))
                    else:
                        dbg2txt('hxt format issue len=' +str(len(lHXT[i])) + ' '+str(lHXT[i]))
                dbg2txt(str(len(liEE)) +' '+ str(liEE))
                lCRC = jedec_crc16(liEE,int(lHXT[0][2]),True)
                dbg2txt("reg2ee calc CRC vs NVMSCRC " + '{:#06x}'.format(lCRC[0]) + ":" + '{:#06x}'.format(lCRC[1]))
                for i in range(0,64):
                    if len(lHXT[i])==3:
                        WriteParameter("nvm_wr_addr",int(lHXT[i][0]))
                        eewait(waitval)
                        if i==63:
                            iCRCfromFILE = int(lHXT[i][2])
                            WriteParameter("nvm_wr_data",iCRCfromFILE)
                        else:
                            WriteParameter("nvm_wr_data",int(lHXT[i][2]))
                        eewait(waitval)
            else:
                UpdateStatusBar("HXT File doesn't have 64 words. Canceled.")
                g.retval = g.retval & False
            eewait(0.1)
            WriteParameter("update_crc",1)
            eewait(waitval)
            iCRC = int(ReadParameter("nvmlcrc"))
            strlivecrc = '{:#06x}'.format(iCRC)
            eewait(waitval)
            UpdateStatusBar("EEPROM written, CRC of FILE / DEVICE / CRCERR " + '{:#06x}'.format(iCRCfromFILE) + " / " + strlivecrc + " / " + '{:#06x}'.format(int(ReadParameter("nvmcrcerr"))))   
    pass

def eewriteconfirm():
    retval = MessageBox.Show("Do you really want to write to the EEPROM?", "Confirmation", MessageBoxButtons.YesNo, MessageBoxIcon.Question)
    if retval == DialogResult.Yes:
        retval = True
    else:
        retval = False
    return retval

def eewait(val):
    retval = 0
    rb = 1
    tDiff = 1
    while rb == 1 and tDiff >= 0.008 and retval > 0:
        tBefore = clock()
        sleep(val)
        rb = int(ReadParameter("nvmbusy"))
        tAfter = clock()
        tDiff = tAfter - tBefore
        retval += 1
    return retval

def waitonly(val):
    retval=0
    tDiff = 0.0000001
    while tDiff <= val:
        tBefore = clock()
        sleep(val)
        tAfter = clock()
        tDiff = tAfter - tBefore
        retval +=1
    return retval

def rbwait(val,bitfield,bUI=True):
    retval=-1
    tDiff = 0.000001
    while tDiff <= val:
        tBefore = clock()
        sleep(val)
        tAfter = clock()
        tDiff = tAfter - tBefore
    if bUI:
        retval = ReadParameterAndUpdateUI(bitfield)
    else:
        retval = ReadParameter(bitfield)
    return retval

def jedec_crc16(lEEPROM,iFileCRC,bCheckFileCRC):
    retval = [-1,-1] 
    ilen = len(lEEPROM)
    if ilen:
        iCRC = 0x0000
        iVal = 0x0000
        iStr = ""
        for i in range(0,ilen-1):       
            iVal = lEEPROM[i] ^ iCRC
            jCRC = 0
            iRST = 0
            iPOL = 0x1021
            iStr = iStr + '{:#06x}'.format(lEEPROM[i])+"\t"+'{:#06x}'.format(iVal) + "\t"
            for j in range(0,16):
                iRST = MSB(iVal) ^ MSB(jCRC)
                jCRC = (jCRC <<1 ) & 0xFFFF
                if iRST:
                    jCRC = jCRC ^ iPOL
                iVal = iVal << 1
            iCRC = jCRC
            iStr = iStr + str(i)+"\t"+ '{:#06x}'.format(lEEPROM[i])+"\t"+'{:#06x}'.format(iCRC) + "\n"
        retval[0] = iCRC & 0xFFFF
        dbg2txt(iStr)
        if bCheckFileCRC:
            retval[1] = iFileCRC & 0xFFFF
        dbg2txt('JEDEC CRC: ' + '{:#06x}'.format(retval[0]) + ' / '+'{:#06x}'.format(retval[1]))
    else:
        dbg2txt("jedec crc - image length mismatch " + str(len(lEEPROM)))
    return retval

def MSB(val):
    retval = 0
    if val & 0x8000:
        retval = 1
    return retval

def create_eeprom_dump_string(eeb, eep0, eep1, other_regs=None):
    if other_regs:
        lbf, l = other_regs
    else:
        lbf = []
        l = []
    
    
    file_string = "----- CDCE6214-Q1 EEPROM HEX TEXT FILE ------\n"
    file_string += "Header Info\t" + ctime()+"\n"
    ilen = len(l)
    for i in range(0,ilen):
        file_string += lbf[i] + "\t" + '{:#06x}'.format(int(l[i])) +"\n"
    file_string += "\n----- BASE   PAGE 0 ------\n"
    i=0
    for word in eeb:
        file_string += '{:#02d}'.format(i) + '\t' +  '{:#06x}'.format(int(word))+ '\t'+ str(int(word))+'\n'
        i +=1
    file_string += "\n----- CONFIG PAGE 0 ------\n"
    for word in eep0:
        file_string += '{:#02d}'.format(i)+ '\t' +  '{:#06x}'.format(int(word)) + '\t' + str(int(word))+ '\n'
        i +=1
    file_string += "\n----- CONFIG PAGE 1 ------\n"
    for word in eep1:
        file_string += '{:#02d}'.format(i)+ '\t' + '{:#06x}'.format(int(word))+ '\t' +  str(int(word))+ '\n'
        i +=1
    file_string += "----- END EEPROM HEX TEXT FILE ------"

    return file_string


def bRead_from_NVM_DAT_Update():
    UpdateStatusBar("About to readback nvm_rd_data")
    ReadParameterAndUpdateUI("nvm_rd_data")

def registers_to_eeprom_data():
    return []

def eeprom_to_eeprom_data():
    l = []
    eeb  = []
    eep0 = []
    eep1 = []
    lbf = ["nvmbusy","nvmcrcerr","nvm_wr_error","nvm_rd_error","nvmlcrc","nvmscrc","nvm_rd_addr","nvm_rd_data","nvm_wr_addr","nvm_wr_data"]
    for bf in lbf:
        l.append(ReadParameter(bf))
        
    UpdateStatusBar("Reading EEPROM... please wait.")
    for i in range(0, 16):
        WriteParameter("nvm_rd_addr",i)
        eeb.append(ReadParameter("nvm_rd_data"))
        eewait(0.005) 
    for i in range(16, 40):
        WriteParameter("nvm_rd_addr",i)
        eep0.append(ReadParameter("nvm_rd_data"))
        eewait(0.005) 
    for i in range(40,64):
        WriteParameter("nvm_rd_addr",i)
        eep1.append(ReadParameter("nvm_rd_data"))
        eewait(0.005) 
    UpdateStatusBar("EEPROM read done.")
    
    return (eeb, eep0, eep1, (lbf, l))


def bCalc_GUIEE_CRC_Update():
    calc_guieeprom_crc(*global_gui_eeprom_and_reg_data)

def calc_guieeprom_crc(eeb, eep0, eep1, other_regs=None):
    print ("calc_guieeprom_crc")
    try:
        if 64 != len(eeb) + len(eep0) + len(eep1):
            UpdateStatusBar("Error, eeprom data is 64 words long")
            return None
    except:
        UpdateStatusBar("Error, not ready to calculate CRC")
        return None
    
    liEE = []
    for eeprom_page in [eeb, eep0, eep1]:
        for val in eeprom_page:
            liEE.append((val >> 8) & 0xff)
            liEE.append(val & 0xff)
        
    lCRC = jedec_crc16(liEE, eeb[0], True)
    
    UpdateStatusBar("Calcualted CRC as {}".format(lCRC))
    UpdateStatusBar("Calcualted CRC as %04x : %04x" % (lCRC[0], lCRC[1]))


def eeprom_data_to_eeprom(eeb, eep0, eep1, other_regs=None):
    if other_regs:
        lbf, l = other_regs
    else:
        lbf = []
        l = []
    waitval = 0.01
    iCRCfromFILE = 0
    iCRC = 0
    UpdateStatusBar("Writing EEPROM")
    ee_lock.iValue = 5; WriteParameter("ee_lock", ee_lock.iValue)
    eewait(waitval)

    listEE = []
    listEE.extend(eeb)
    listEE.extend(eep0)
    listEE.extend(eep1)
    
    if len(listEE)==64:
        liEE = []
        for val in listEE:
            liEE.append((val >> 8) & 0xff)
            liEE.append(val & 0xff)
        
        lCRC = jedec_crc16(liEE, listEE[0], True)
        dbg2txt("reg2ee calc CRC vs NVMSCRC " + '{:#06x}'.format(lCRC[0]) + ":" + '{:#06x}'.format(lCRC[1]))
        dbg2txt("reg2ee eeprom_data crc = 0x%x" % listEE[63])
        dbg2txt("reg2ee calculated crc = {}".format(lCRC))
        iCRCfromFILE = listEE[63]
        for i, val in enumerate(listEE):
            WriteParameter("nvm_wr_addr", int(i))
            eewait(waitval)
            WriteParameter("nvm_wr_data", val)
            eewait(waitval)
    else:
        UpdateStatusBar("HXT File doesn't have 64 words. Canceled.")
        g.retval = g.retval & False
        
    eewait(0.1)
    WriteParameter("update_crc",1)
    eewait(waitval)
    iCRC = int(ReadParameter("nvmlcrc"))
    strlivecrc = '{:#06x}'.format(iCRC)
    eewait(waitval)
    UpdateStatusBar("EEPROM written, CRC of FILE / DEVICE / CRCERR " + '{:#06x}'.format(iCRCfromFILE) + " / " + strlivecrc + " / " + '{:#06x}'.format(int(ReadParameter("nvmcrcerr"))))   

    ee_lock.iValue = 10;

def eeprom_data_to_file(filename, eeb, eep0, eep1, extra):
    lines = []
    lines.append("CDCE6214-Q1 EEPROM export\n")
    lines.append("Design Name: {}\n".format(tc_DESIGNNAME.sValue))
    lines.append("Design Notes: {}\n".format(mtc_USERNOTES.sValue))
    lines.append(create_eeprom_dump_string(*global_gui_eeprom_and_reg_data))
    
    f = open(filename, "w")
    if f:
        f.writelines(lines)
        UpdateStatusBar("Wrote data to {}".format(filename))
        f.close()
    else:
        UpdateStatusBar("Failed to write to {}".format(filename))



def file_to_eeprom_data(filename):
    iCRCfromFILE = 0
    iCRC = 0
    UpdateStatusBar("Loading EEPROM File " + filename)
    
    strHXT = ""
    if len(filename) > 4:
        fh = open(filename,"r")
        for line in fh:
            strHXT = strHXT + line
        fh.close()
        lHXT = re.findall(r'([0-9][0-9])\t0x([0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f])\t([0-9][0-9]*)',strHXT)
        if len(lHXT)==64:
            liEE = []
            for i in range(0, 64):
                if len(lHXT[i]) == 3:
                    liEE.append(int(lHXT[i][1][0:2],16))
                    liEE.append(int(lHXT[i][1][2:4],16))
                else:
                    dbg2txt('hxt format issue len=' +str(len(lHXT[i])) + ' '+str(lHXT[i]))
            dbg2txt(str(len(liEE)) +' '+ str(liEE))
            lCRC = jedec_crc16(liEE,int(lHXT[0][2]),True)
            dbg2txt("reg2ee calc CRC vs NVMSCRC " + '{:#06x}'.format(lCRC[0]) + ":" + '{:#06x}'.format(lCRC[1]))
            
            eeb = []
            eep0 = []
            eep1 = []
            for i in range(0, 16):
                if len(lHXT[i])==3:
                    eeb.append(int(lHXT[i][2]))
                else:
                    UpdateStatusBar("Critical error reading in file.  Should have 3 sets of data at index %d" % i)
                    return False

            for i in range(16, 40):
                if len(lHXT[i])==3:
                    eep0.append(int(lHXT[i][2]))
                else:
                    UpdateStatusBar("Critical error reading in file.  Should have 3 sets of data at index %d" % i)
                    return False

            for i in range(40,64):
                if len(lHXT[i])==3:
                    eep1.append(int(lHXT[i][2]))
                else:
                    UpdateStatusBar("Critical error reading in file.  Should have 3 sets of data at index %d" % i)
                    return False
                    
            iCRCfromFILE = int(lHXT[63][2])
                    
        else:
            UpdateStatusBar("HXT File doesn't have 64 words. Canceled.")
            return None
            
        UpdateStatusBar("EEPROM loaded, CRC of FILE: " + '{:#06x}'.format(iCRCfromFILE) )
        return (eeb, eep0, eep1, None)


def bREG2GUIEEPROM_Update():
    """
    Convert registers to EEPROM map.
    """
    
    UpdateStatusBar("Creating GUI EEPROM from registers")
    
    eeprom_and_regs = registers_to_eeprom_data()
    
    tp = tics_pro_ini()
    
    global global_gui_eeprom_and_reg_data
    global_gui_eeprom_and_reg_data = eeprom_and_regs
    
    thestr = create_eeprom_dump_string(*eeprom_and_regs)
    mtc_EEPROMdump.sValue = thestr

def bEEPROM2GUIEEPROM_Update():
    """    
    """
    eeprom_and_regs = eeprom_to_eeprom_data()
    eeb, eep0, eep1, extra = eeprom_and_regs
    thestr = create_eeprom_dump_string(eeb, eep0, eep1, extra)
    mtc_EEPROMdump.sValue = thestr
    
    global global_gui_eeprom_and_reg_data
    global_gui_eeprom_and_reg_data = (eeb, eep0, eep1, extra)
    
  
def bGUIEEPROM2EEPROM_Update():
    if None == global_gui_eeprom_and_reg_data:
        UpdateStatusBar("Load eeprom data first")
    else:
        UpdateStatusBar("Writing EEPROM data to EEPROM")
        eeprom_data_to_eeprom(*global_gui_eeprom_and_reg_data)

def bEXPORT_EEPROM_FILE_Update():
    pass

def bIMPORT_EEPROM_FILE_Update():
    filename = eeselectfile()
    if filename:
        eeb, eep0, eep1, extra = file_to_eeprom_data(filename)
        
        global global_gui_eeprom_and_reg_data
        global_gui_eeprom_and_reg_data = (eeb, eep0, eep1, extra)

        thestr = create_eeprom_dump_string(eeb, eep0, eep1, extra)
        mtc_EEPROMdump.sValue = thestr

def bEXPORT_EEPROM_FILE_Update():
    filename = eeselectfile(open_true_or_save_false = False)
    if filename:
        eeprom_data_to_file(filename, *global_gui_eeprom_and_reg_data)
        UpdateStatusBar("Wrote GUI EEPROM data to {}".format(filename))
    
def bUpdate_ee_status_bits_Update():
    UpdateStatusBar("Updating the 5 controls...")
    ReadParameterAndUpdateUI("nvmcrcerr")
    ReadParameterAndUpdateUI("nvmbusy")
    ReadParameterAndUpdateUI("nvm_rd_error")
    ReadParameterAndUpdateUI("nvmscrc")
    ReadParameterAndUpdateUI("nvmlcrc")
    
    

Use pages 33/34 of CDCE6214 DS on how to program EEPROM: 

Regards, 

Vicente 

Hi Xiao, 
1. Yes, set bit 9 to 1'h given you wish to use page1 of EEPROM. 

2. Nvmbusy is a bit but it is reserved. 

3. Yes, it updates crc value register and sets EELOCK to high to prevent accidental programming. 

4. This puts the device in pin mode which disables I2C interface. The second part is done given once the device is in pin mode you cannot talk to it. It must be directly written through NVMadr/NVMdata.

Regards, 

Vicente