public UInt32 Write(ref TASKMessage msg)
{
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
List <Parameter> OpReglist = new List <Parameter>();
ParamContainer demparameterlist = msg.task_parameterlist;
if (demparameterlist == null)
{
return(ret);
}
foreach (Parameter p in demparameterlist.parameterlist)
{
if (p == null)
{
continue;
}
OpReglist.Add(p);
}
//Write
ret = WriteByte(OpReglist);
return(ret);
}
public static List <Parameter> GenerateParameterList(ref TASKMessage msg)
{
List <Parameter> OpParamList = new List <Parameter>();
ParamContainer demparameterlist = msg.task_parameterlist;
if (demparameterlist == null)
{
return(null);
}
foreach (Parameter p in demparameterlist.parameterlist)
{
if ((p.guid & ElementDefine.SectionMask) == ElementDefine.VirtualElement) //略过虚拟参数
{
continue;
}
if (p == null)
{
break;
}
OpParamList.Add(p);
}
OpParamList = OpParamList.Distinct().ToList();
return(OpParamList);
}
public static List <byte> Generate(ref TASKMessage msg)
{
Reg reg = null;
byte baddress = 0;
List <byte> OpReglist = new List <byte>();
ParamContainer demparameterlist = msg.task_parameterlist;
if (demparameterlist == null)
{
return(null);
}
foreach (Parameter p in demparameterlist.parameterlist)
{
if ((p.guid & ElementDefine.SectionMask) == ElementDefine.VirtualElement) //略过虚拟参数
{
continue;
}
if (p == null)
{
break;
}
foreach (KeyValuePair <string, Reg> dic in p.reglist)
{
reg = dic.Value;
baddress = (byte)reg.address;
if (OpReglist.Contains(baddress) == false)
{
OpReglist.Add(baddress);
}
}
}
return(OpReglist);
}
public virtual UInt32 Read(ref TASKMessage msg)
{
byte bdata = 0;
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
List <byte> OpReglist = new List <byte>();
ParamContainer demparameterlist = msg.task_parameterlist;
if (demparameterlist == null)
{
return(ret);
}
OpReglist = RegisterListGenerator.Generate(ref msg);
if (OpReglist == null)
{
return(ret);
}
foreach (byte badd in OpReglist)
{
ret = ReadByte(badd, ref bdata);
parent.m_OpRegImg[badd].err = ret;
parent.m_OpRegImg[badd].val = bdata;
//if (ret != LibErrorCode.IDS_ERR_SUCCESSFUL)
// return ret;
}
return(ret);
}
public UInt32 ConvertHexToPhysical(ref TASKMessage msg) //Scan 把这里污染了
{
Parameter param = null;
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
List <Parameter> OpParamList = new List <Parameter>();
OpParamList = ParamListGenerator.Generate(ref msg);
if (OpParamList == null)
{
return(ret);
}
for (int i = 0; i < OpParamList.Count; i++)
{
param = (Parameter)OpParamList[i];
if (param == null)
{
continue;
}
dem_dm.Hex2Physical(ref param);
}
return(ret);
}
public UInt32 ConvertPhysicalToHex(ref TASKMessage msg)
{
Parameter param = null;
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
List <Parameter> OpParamList = new List <Parameter>();
OpParamList = ParamListGenerator.Generate(ref msg);
if (OpParamList == null)
{
return(ret);
}
for (int i = 0; i < OpParamList.Count; i++)
{
param = (Parameter)OpParamList[i];
if (param == null)
{
continue;
}
if ((param.guid & ElementDefine.SectionMask) == ElementDefine.TemperatureElement)
{
continue;
}
dem_dm.Physical2Hex(ref param);
}
return(ret);
}
public UInt32 Read(ref TASKMessage bgworker)
{
UInt32 ret = 0;
ret = m_dem_bm.Read(ref bgworker);
return(ret);
}
public UInt32 Write(ref TASKMessage msg) //Expert 把这里污染了 //去掉了污染20200513
{
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
List <byte> OpReglist = new List <byte>();
OpReglist = RegisterListGenerator.Generate(ref msg);
if (OpReglist == null)
{
return(ret);
}
//Removed this warning as discussed with Jianping 20200513
//if (msg.gm.sflname == "Expert")
//{
// if (isContainEfuseRegisters(OpReglist) == true)
// {
// System.Windows.Forms.MessageBox.Show("Please provide programming voltage or the write operation may be unsuccessful!");
// //msg.gm.message = "Please provide programming voltage or the write operation may be unsuccessful!";
// //msg.controlreq = COMMON_CONTROL.COMMON_CONTROL_WARNING;
// }
//}
foreach (byte badd in OpReglist)
{
ret = WriteByte(badd, (byte)parent.m_OpRegImg[badd].val);
parent.m_OpRegImg[badd].err = ret;
//if (ret != LibErrorCode.IDS_ERR_SUCCESSFUL)
// return ret;
}
return(ret);
}
public UInt32 GetRegisteInfor(ref TASKMessage msg)
{
#if false
byte bdata = 0;
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
msg.errorcode = LibErrorCode.IDS_ERR_SUCCESSFUL;
// Write k=1.2 to TSET
if (firsttime)
{
ReadOneByte(0x05, ref bdata);
bdata &= 0xfc;
bdata |= 0x02;
WriteOneByte(0x05, bdata);
firsttime = false;
}
// Write k=1.2 to TSET
ret = ReadOneByte(0x40, ref bdata);
if ((ret != LibErrorCode.IDS_ERR_SUCCESSFUL) || ((bdata & 0x20) == 0))
{
msg.sm.parts[0] = true;
return(LibErrorCode.IDS_ERR_SUCCESSFUL);
}
else
{
msg.sm.parts[0] = false;
}
ret = ReadOneByte(0x10, ref bdata);
if (ret != LibErrorCode.IDS_ERR_SUCCESSFUL)
{
msg.sm.parts[0] = true;
return(LibErrorCode.IDS_ERR_SUCCESSFUL);
}
else
{
msg.sm.parts[0] = false;
}
if (bdata < 0x06)
{
ret = WriteOneByte(0x10, 0x0A);
if (ret != LibErrorCode.IDS_ERR_SUCCESSFUL)
{
msg.sm.parts[0] = true;
return(LibErrorCode.IDS_ERR_SUCCESSFUL);
}
else
{
msg.sm.parts[0] = false;
}
}
#endif
return(LibErrorCode.IDS_ERR_SUCCESSFUL);
}
public UInt32 Read(ref TASKMessage bgworker)
{
UInt32 ret = 0;
//if (bgworker.gm.sflname == "Scan") //Scan里面有个PreRead，所以这里只能区别处理
// ret = m_scan_dem_bm.Read(ref bgworker);
//else
ret = m_dem_bm_base.Read(ref bgworker);
return(ret);
}
public UInt32 Command(ref TASKMessage bgworker)
{
var ret = m_dem_bm.Command(ref bgworker);
if (ret != LibErrorCode.IDS_ERR_SUCCESSFUL)
{
m_dem_bm.PowerOff();
}
return(ret);
}
public UInt32 BitOperation(ref TASKMessage msg)
{
Reg reg = null;
byte baddress = 0;
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
List <byte> OpReglist = new List <byte>();
ParamContainer demparameterlist = msg.task_parameterlist;
if (demparameterlist == null)
{
return(ret);
}
foreach (Parameter p in demparameterlist.parameterlist)
{
if ((p.guid & ElementDefine.SectionMask) == ElementDefine.VirtualElement) //略过虚拟参数
{
continue;
}
switch (p.guid & ElementDefine.SectionMask)
{
case ElementDefine.OperationElement:
{
if (p == null)
{
break;
}
foreach (KeyValuePair <string, Reg> dic in p.reglist)
{
reg = dic.Value;
baddress = (byte)reg.address;
parent.m_OpRegImg[baddress].val = 0x00;
dem_dm.WriteToRegImg(p, 1);
OpReglist.Add(baddress);
}
break;
}
}
}
OpReglist = OpReglist.Distinct().ToList();
//Write
foreach (byte badd in OpReglist)
{
ret = WriteWord(badd, parent.m_OpRegImg[badd].val);
parent.m_OpRegImg[badd].err = ret;
}
return(ret);
}
public override UInt32 Command(ref TASKMessage msg)
{
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
switch ((ElementDefine.COMMAND)msg.sub_task)
{
default:
break;
}
return(ret);
}
private uint ReadAvrage(ref TASKMessage msg)
{
uint errorcode = 0;
List <double[]> llt = new List <double[]>();
List <double> avr = new List <double>();
foreach (Parameter param in msg.task_parameterlist.parameterlist)
{
llt.Add(new double[5]);
avr.Add(0);
}
for (int i = 0; i < 5; i++)
{
errorcode = Read(ref msg);
if (errorcode != LibErrorCode.IDS_ERR_SUCCESSFUL)
{
return(errorcode);
}
errorcode = ConvertHexToPhysical(ref msg);
if (errorcode != LibErrorCode.IDS_ERR_SUCCESSFUL)
{
return(errorcode);
}
for (int j = 0; j < msg.task_parameterlist.parameterlist.Count; j++)
{
llt[j][i] = msg.task_parameterlist.parameterlist[j].phydata;
avr[j] += llt[j][i];
}
Thread.Sleep(100);
}
for (int j = 0; j < msg.task_parameterlist.parameterlist.Count; j++)
{
//llt[j][i] = msg.task_parameterlist.parameterlist[j].phydata;
avr[j] /= 5;
int minIndex = 0;
double err = 999;
for (int i = 0; i < 5; i++)
{
if (err > Math.Abs(llt[j][i] - avr[j]))
{
err = Math.Abs(llt[j][i] - avr[j]);
minIndex = i;
}
}
msg.task_parameterlist.parameterlist[j].phydata = llt[j][minIndex];
}
return(errorcode);
}
private UInt32 GetEfuseHexData(ref TASKMessage msg)
{
string tmp = "";
for (ushort i = ElementDefine.EF_USR_OFFSET; i <= ElementDefine.EF_USR_TOP; i++)
{
if (parent.m_OpRegImg[i].err != LibErrorCode.IDS_ERR_SUCCESSFUL)
{
return(parent.m_OpRegImg[i].err);
}
tmp += "0x" + i.ToString("X2") + ", " + "0x" + parent.m_OpRegImg[i].val.ToString("X2") + "\r\n";
}
msg.sm.efusehexdata = tmp;
return(LibErrorCode.IDS_ERR_SUCCESSFUL);
}
private UInt32 GetEfuseBinData(ref TASKMessage msg)
{
List <byte> tmp = new List <byte>();
for (ushort i = ElementDefine.EF_USR_OFFSET; i <= ElementDefine.EF_USR_TOP; i++)
{
if (parent.m_OpRegImg[i].err != LibErrorCode.IDS_ERR_SUCCESSFUL)
{
return(parent.m_OpRegImg[i].err);
}
tmp.Add((byte)i);
tmp.Add((byte)(parent.m_OpRegImg[i].val));
}
msg.sm.efusebindata = tmp;
return(LibErrorCode.IDS_ERR_SUCCESSFUL);
}
public UInt32 Read(ref TASKMessage msg)
{
Reg reg = null;
byte baddress = 0;
UInt16 wdata = 0;
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
List <byte> OpReglist = new List <byte>();
ParamContainer demparameterlist = msg.task_parameterlist;
if (demparameterlist == null)
{
return(ret);
}
foreach (Parameter p in demparameterlist.parameterlist)
{
if (p == null)
{
break;
}
foreach (KeyValuePair <string, Reg> dic in p.reglist)
{
reg = dic.Value;
baddress = (byte)reg.address;
OpReglist.Add(baddress);
}
}
OpReglist = OpReglist.Distinct().ToList();
//Read
foreach (byte badd in OpReglist)
{
ret = ReadWord(badd, ref wdata);
parent.m_OpRegImg[badd].err = ret;
parent.m_OpRegImg[badd].val = wdata;
if (ret != LibErrorCode.IDS_ERR_SUCCESSFUL)
{
return(ret);
}
}
return(ret);
}
private UInt32 DownloadWithoutPowerControl(ref TASKMessage msg)
{
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
PrepareHexData();
ret = SetWorkMode(ElementDefine.EFUSE_MODE.PROGRAM);
if (ret != LibErrorCode.IDS_ERR_SUCCESSFUL)
{
return(ret);
}
for (byte badd = (byte)ElementDefine.EF_USR_OFFSET; badd <= (byte)ElementDefine.EF_USR_TOP; badd++)
{
#if debug
ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
#else
ret = parent.m_OpRegImg[badd].err;
#endif
if (ret != LibErrorCode.IDS_ERR_SUCCESSFUL)
{
return(ret);
}
#if debug
EFUSEUSRbuf[badd - ElementDefine.EF_USR_OFFSET] = 0;
#else
EFUSEUSRbuf[badd - ElementDefine.EF_USR_OFFSET] = parent.m_OpRegImg[badd].val;
#endif
ret = WriteByte((byte)(badd), (byte)parent.m_OpRegImg[badd].val);
parent.m_OpRegImg[(byte)(badd)].err = ret;
if (ret != LibErrorCode.IDS_ERR_SUCCESSFUL)
{
return(ret);
}
}
ret = SetWorkMode(ElementDefine.EFUSE_MODE.NORMAL);
if (ret != LibErrorCode.IDS_ERR_SUCCESSFUL)
{
return(ret);
}
return(ret);
}
public UInt32 ConvertPhysicalToHex(ref TASKMessage bgworker)
{
if (bgworker.gm.sflname == "Expert")
{
return(m_expert_dem_bm.ConvertPhysicalToHex(ref bgworker));
}
else if (bgworker.gm.sflname == "Register Config")
{
return(m_register_config_dem_bm.ConvertPhysicalToHex(ref bgworker));
}
else if (bgworker.gm.sflname == "EFUSE Config")
{
return(m_efuse_config_dem_bm.ConvertPhysicalToHex(ref bgworker));
}
else
{
return(m_dem_bm_base.ConvertPhysicalToHex(ref bgworker));
}
}
public virtual UInt32 Read(ref TASKMessage msg)
{
UInt16 wdata = 0;
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
List <byte> OpReglist = new List <byte>();
ParamContainer demparameterlist = msg.task_parameterlist;
if (demparameterlist == null)
{
return(ret);
}
AutomationElement aElem = parent.m_busoption.GetATMElementbyGuid(AutomationElement.GUIDATMTestStart);
if (aElem != null)
{
bool bsim = true;
bsim |= (aElem.dbValue > 0.0) ? true : false;
aElem = parent.m_busoption.GetATMElementbyGuid(AutomationElement.GUIDATMTestSimulation);
bsim |= (aElem.dbValue > 0.0) ? true : false;
}
OpReglist = RegisterListGenerator.Generate(ref msg);
if (OpReglist == null)
{
return(ret);
}
foreach (byte badd in OpReglist)
{
ret = ReadWord(badd, ref wdata);
parent.m_OpRegImg[badd].err = ret;
parent.m_OpRegImg[badd].val = wdata;
if (ret != LibErrorCode.IDS_ERR_SUCCESSFUL)
{
return(ret);
}
}
return(ret);
}
public UInt32 Command(ref TASKMessage msg)
{
switch ((ElementDefine.COMMAND)msg.sub_task)
{
case ElementDefine.COMMAND.DGB: //DBG
WriteOneByte(0xe0, 0x64);
WriteOneByte(0xe0, 0x62);
WriteOneByte(0xe0, 0x67);
break;
case ElementDefine.COMMAND.BURN: //BURN
WriteOneByte(0xf9, 0x01);
WriteOneByte(0xf9, 0x01);
break;
case ElementDefine.COMMAND.FREEZE: //FREEZE
WriteOneByte(0xf9, 0x02);
WriteOneByte(0xf9, 0x02);
break;
}
return(LibErrorCode.IDS_ERR_SUCCESSFUL);
}
public UInt32 ConvertPhysicalToHex(ref TASKMessage msg)
{
Parameter param = null;
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
List <Parameter> OpReglist = new List <Parameter>();
ParamContainer demparameterlist = msg.task_parameterlist;
if (demparameterlist == null)
{
return(ret);
}
foreach (Parameter p in demparameterlist.parameterlist)
{
if (p == null)
{
continue;
}
OpReglist.Add(p);
}
if (OpReglist.Count != 0)
{
for (int i = 0; i < OpReglist.Count; i++)
{
param = OpReglist[i];
if (param == null)
{
continue;
}
parent.Physical2Hex(ref param);
}
}
return(ret);
}
public UInt32 Command(ref TASKMessage bgworker)
{
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
switch ((ElementDefine.COMMAND)bgworker.sub_task)
{
case ElementDefine.COMMAND.REGISTER_CONFIG_WRITE:
case ElementDefine.COMMAND.REGISTER_CONFIG_READ:
{
ret = m_register_config_dem_bm.Command(ref bgworker);
break;
}
case ElementDefine.COMMAND.EFUSE_CONFIG_WRITE:
case ElementDefine.COMMAND.EFUSE_CONFIG_READ:
case ElementDefine.COMMAND.EFUSE_CONFIG_SAVE_EFUSE_HEX:
{
ret = m_efuse_config_dem_bm.Command(ref bgworker);
break;
}
}
return(ret);
}
public UInt32 Write(ref TASKMessage msg)
{
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
List <byte> OpReglist = new List <byte>();
OpReglist = RegisterListGenerator.Generate(ref msg);
if (OpReglist == null)
{
return(ret);
}
foreach (byte badd in OpReglist)
{
ret = WriteWord(badd, parent.m_OpRegImg[badd].val);
parent.m_OpRegImg[badd].err = ret;
if (ret != LibErrorCode.IDS_ERR_SUCCESSFUL)
{
return(ret);
}
}
return(ret);
}
public UInt32 Command(ref TASKMessage bgworker)
{
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
switch ((ElementDefine.COMMAND)bgworker.sub_task)
{
case ElementDefine.COMMAND.REGISTER_CONFIG_WRITE:
case ElementDefine.COMMAND.REGISTER_CONFIG_READ:
{
ret = m_register_config_dem_bm.Command(ref bgworker);
break;
}
case ElementDefine.COMMAND.EFUSE_CONFIG_WRITE:
case ElementDefine.COMMAND.EFUSE_CONFIG_READ:
case ElementDefine.COMMAND.EFUSE_CONFIG_SAVE_EFUSE_HEX:
{
ret = m_efuse_config_dem_bm.Command(ref bgworker);
break;
}
case ElementDefine.COMMAND.MP_BIN_FILE_CHECK:
case ElementDefine.COMMAND.MP_FROZEN_BIT_CHECK_PC:
case ElementDefine.COMMAND.MP_FROZEN_BIT_CHECK:
case ElementDefine.COMMAND.MP_DIRTY_CHIP_CHECK_PC:
case ElementDefine.COMMAND.MP_DIRTY_CHIP_CHECK:
case ElementDefine.COMMAND.MP_DOWNLOAD_PC:
case ElementDefine.COMMAND.MP_DOWNLOAD:
case ElementDefine.COMMAND.MP_READ_BACK_CHECK_PC:
case ElementDefine.COMMAND.MP_READ_BACK_CHECK:
{
ret = m_mass_production_dem_bm.Command(ref bgworker);
break;
}
}
return(ret);
}
public UInt32 Command(ref TASKMessage bgworker)
{
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
//EXPERT_ENTER_SERIAL_MODE = 0x01,
//EXPERT_ENTER_PARALLEL_MODE = 0x02,
//EXPERT_ENTER_SHIP_MODE = 0x03,
//EXPERT_ENTER_SLEEP_MODE = 0x04,
//EXPERT_EXIT_SLEEP_MODE = 0x05,
//EXPERT_ENTER_TEST_MODE = 0x06,
//EXPERT_EXIT_TEST_MODE = 0x07,
//EXPERT_ENTER_FET_CTRL = 0x08,
//EXPERT_EXIT_FET_CTRL = 0x09,
//EXPERT_ENTER_TRIM_MODE = 0x0a,
switch ((ElementDefine.COMMAND)bgworker.sub_task)
{
case ElementDefine.COMMAND.EXPERT_ENTER_SERIAL_MODE:
case ElementDefine.COMMAND.EXPERT_ENTER_PARALLEL_MODE:
case ElementDefine.COMMAND.EXPERT_ENTER_SHIP_MODE:
case ElementDefine.COMMAND.EXPERT_ENTER_SLEEP_MODE:
case ElementDefine.COMMAND.EXPERT_EXIT_SLEEP_MODE:
case ElementDefine.COMMAND.EXPERT_ENTER_TEST_MODE:
case ElementDefine.COMMAND.EXPERT_EXIT_TEST_MODE:
case ElementDefine.COMMAND.EXPERT_ENTER_FET_CTRL:
case ElementDefine.COMMAND.EXPERT_EXIT_FET_CTRL:
case ElementDefine.COMMAND.EXPERT_ENTER_TRIM_MODE:
ret = m_expert_dem_bm.Command(ref bgworker);
break;
case ElementDefine.COMMAND.TRIM_SLOPE_TRIMMING:
case ElementDefine.COMMAND.TRIM_OFFSET_TRIMMING:
ret = m_trim_dem_bm.Command(ref bgworker);
break;
}
return(ret);
}
public UInt32 GetRegisteInfor(ref TASKMessage msg)
{
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
return(ret);
}
public virtual UInt32 GetSystemInfor(ref TASKMessage msg)
{
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
return(ret);
}
public virtual UInt32 Command(ref TASKMessage msg)
{
UInt32 ret = LibErrorCode.IDS_ERR_SUCCESSFUL;
return(ret);
}
public UInt32 ConvertHexToPhysical(ref TASKMessage bgworker)
{
return(m_dem_bm.ConvertHexToPhysical(ref bgworker));
}
