public static List <HardwareSubRegister> ProcessRegisterSetSubRegisters(string pFileName)
{
List <HardwareSubRegister> aSubRegs = new List <HardwareSubRegister>();
HardwareSubRegister aSubReg = null;
foreach (var ln in File.ReadAllLines(pFileName))
{
var m = Regexes.argSearchRegShift.Match(ln);
if (m.Success)
{
aSubReg = new HardwareSubRegister();
aSubReg.Name = m.Groups[2].Value;
aSubReg.FirstBit = Convert.ToInt32(m.Groups[4].Value);
continue;
}
m = Regexes.argSearchRegMask.Match(ln);
if (m.Success)
{
if (aSubReg == null)
{
continue;
}
aSubReg.Name = m.Groups[2].Value;
aSubReg.SizeInBits = GetSizeBit(m.Groups[4].Value);
if (aSubRegs.IndexOf(aSubReg) >= 0)
{
throw new Exception("Dubl Sub Registr");
}
aSubRegs.Add(aSubReg);
aSubReg = null;
}
}
return(aSubRegs);
}
private static HardwareSubRegister DeepCopy(HardwareSubRegister subreg)
{
HardwareSubRegister subreg_new = new HardwareSubRegister {
Name = subreg.Name,
FirstBit = subreg.FirstBit,
SizeInBits = subreg.SizeInBits,
KnownValues = (subreg.KnownValues != null) ? (KnownSubRegisterValue[])subreg.KnownValues.Clone() : null
};
return(subreg_new);
}
private static HardwareSubRegister CloneSubregister(HardwareSubRegister s)
{
return(new HardwareSubRegister
{
FirstBit = s.FirstBit,
KnownValues = (KnownSubRegisterValue[])s.KnownValues?.Clone(),
Name = s.Name,
ParentRegister = s.ParentRegister,
SizeInBits = s.SizeInBits
});
}
//---------------------------------
private static List <HardwareRegisterSet> ProcessLoadHardwareRegisterSet()
{
List <HardwareRegisterSet> oReg = new List <HardwareRegisterSet>();
List <HardwareSubRegister> alstSubReg = new List <HardwareSubRegister>();
var aLstPerep = GetBaseAdress(mNameCurrentAdr);
foreach (var perep in aLstPerep)
{
List <HardwareRegister> alstReg = new List <HardwareRegister>();
ulong aBaseAdress = perep.adress;
perep.used = true;
foreach (var reg in adicAdrrOffsetDriv)
{
HardwareRegister Reg = new HardwareRegister();
alstSubReg.Clear();
Reg.Name = reg.Key;
Reg.Address = FormatToHex(reg.Value + aBaseAdress);
Reg.SizeInBits = 32;
foreach (var subReg in adicBitsOffsetDriv)
{
if (subReg.Key.StartsWith(Reg.Name))
{
HardwareSubRegister hsr = new HardwareSubRegister
{
Name = subReg.Key.Remove(0, Reg.Name.Length + 1),
ParentRegister = Reg,
OriginalMacroBase = Reg.Name,
SizeInBits = GetSizeBit(subReg.Value),
FirstBit = GetFirstBit(subReg.Value),
};
if (hsr.SizeInBits == 0)
{
Console.WriteLine("size subreg 0 " + hsr.Name);
}
alstSubReg.Add(hsr);
}
}
Reg.SubRegisters = alstSubReg.ToArray();
alstReg.Add(Reg);
}
if (alstReg.Count > 0)
{
oReg.Add(new HardwareRegisterSet
{
ExpressionPrefix = mNameCurrentAdr,
UserFriendlyName = perep.Name,// astrUserFrendlyName,
Registers = alstReg.ToArray()
});
}
}
return(oReg);
}
private void SubRegisterDefinition()
{
_subRegister = new HardwareSubRegister();
_subRegister.Name = _lastMatch.Groups[3].Value;
_subRegister.FirstBit = _processedBits;
_subRegister.SizeInBits = int.Parse(_lastMatch.Groups[4].Value);
if (_subRegister.Name == string.Empty)
{
_subRegister.Name = string.Format("Unknown (0x{0:x})", _subRegister.FirstBit);
}
_subRegisters.Add(_subRegister);
_processedBits += _subRegister.SizeInBits;
SetExpectedMatches(SUBREGISTER_DEFINITION, SUBREGISTERS_END);
}
private void OnStart()
{
_processedBits = 0;
_registerNameToAddress = new Dictionary <string, string>();
_registerSetToAddress = new Dictionary <string, string>();
_subRegistersKnownValues = new Dictionary <string, IList <KeyValuePair <string, ulong> > >();
_registers = new List <HardwareRegister>();
_registerSets = new List <HardwareRegisterSet>();
_subRegisters = new List <HardwareSubRegister>();
_registersWithWrongBitsSum = new List <string>();
_duplicateRegisterDefinition = false;
_lastMatch = Match.Empty;
_matchedRegex = null;
_registerSet = null;
_register = null;
_subRegister = null;
_registerBits = new Dictionary <string, HardwareSubRegister>();
_expectedMatches = new List <Regex> {
REGISTER_SET_ADDRESS
};
}
public static List <HardwareSubRegister> ProcessRegisterSetSubRegisters(string pFileName)
{
List <HardwareSubRegister> aSubRegs = new List <HardwareSubRegister>();
Regex argSearchReg = new Regex(@"(#define) ([A-Z_0-9]+)[ \t]+\(0x([0-9a-f]+)[u]+[l]?[ <]+([\w]+).*");
Regex argSearchRegShift = new Regex(@"(#define)[ \t_]*([A-Z_0-9]+)(_Pos)[ \t]+([0-9]+).*");
Regex argSearchRegMask = new Regex(@"(#define)[ \t_]*([A-Z_0-9]+)(_Msk)[ \t]+\(0x([0-9a-f]+)[u]+[l]?[ <]+([\w]+).*");
HardwareSubRegister aSubReg = null;
Dictionary <string, int> aDicPos = new Dictionary <string, int>();
// Console.WriteLine("ProcessRegisterSetSubRegisters " + pFileName);
foreach (var ln in File.ReadAllLines(pFileName))
{
var m = argSearchReg.Match(ln);
if (m.Success)
{
aSubReg = new HardwareSubRegister();
aSubReg.Name = m.Groups[2].Value;
if (IsDigit(m.Groups[4].Value))
{
aSubReg.FirstBit = Convert.ToInt32(m.Groups[4].Value);
}
else
{
string astrDefArray = m.Groups[4].Value;
aSubReg.FirstBit = aDicPos[astrDefArray];
}
aSubReg.SizeInBits = GetSizeBit(m.Groups[3].Value);
if (aSubRegs.IndexOf(aSubReg) >= 0)
{
throw new Exception("Dubl Sub Registr");
}
aSubRegs.Add(aSubReg);
aSubReg = null;
continue;
}
m = argSearchRegShift.Match(ln);
if (m.Success)
{
aDicPos[m.Groups[2].Value + "_Pos"] = Convert.ToInt32(m.Groups[4].Value);
continue;
}
m = argSearchRegMask.Match(ln);
if (m.Success)
{
aSubReg = new HardwareSubRegister();
aSubReg.Name = m.Groups[2].Value;
aSubReg.FirstBit = aDicPos[m.Groups[5].Value];
aSubReg.SizeInBits = GetSizeBit(m.Groups[4].Value);
if (aSubRegs.IndexOf(aSubReg) >= 0)
{
Console.WriteLine("Dubl Sub Registr " + m.Groups[2].Value);
}
else
{
aSubRegs.Add(aSubReg);
}
aSubReg = null;
continue;
}
}
return(aSubRegs);
}
static void ProcessRegister(XmlElement reg, List <HardwareRegister> registers, string prefix, uint baseAddr, uint?defaultRegisterSize)
{
string regName = reg.SelectSingleNode("name").InnerText;
string access = reg.SelectSingleNode("access")?.InnerText;
uint addrOff = ParseScaledNonNegativeInteger(reg.SelectSingleNode("addressOffset").InnerText);
var regSizeProp = reg.SelectSingleNode("size");
uint regSize = regSizeProp != null?ParseScaledNonNegativeInteger(regSizeProp.InnerText) : (defaultRegisterSize ?? 32);
int count = 1, step = 0;
string dim = reg.SelectSingleNode("dim")?.InnerText;
if (dim != null)
{
count = (int)ParseScaledNonNegativeInteger(dim);
step = (int)ParseScaledNonNegativeInteger(reg.SelectSingleNode("dimIncrement").InnerText);
if (step * 8 != (int)regSize)
{
throw new Exception("Mismatching array step for " + regName);
}
}
for (int i = 0; i < count; i++)
{
List <HardwareSubRegister> subregs = new List <HardwareSubRegister>();
foreach (XmlElement fld in reg.SelectNodes("fields/field"))
{
var subreg = new HardwareSubRegister
{
Name = fld.SelectSingleNode("name").InnerText
};
var bitRange = fld.SelectSingleNode("bitRange")?.InnerText;
Match m;
if (bitRange != null)
{
int bit1, bit2;
if ((m = rgBitRange.Match(bitRange)).Success)
{
bit1 = int.Parse(m.Groups[1].Value);
bit2 = int.Parse(m.Groups[2].Value);
}
else if ((m = rgSingleBit.Match(bitRange)).Success)
{
bit1 = bit2 = int.Parse(m.Groups[1].Value);
}
else
{
continue;
}
int lsb = Math.Min(bit1, bit2);
int msb = Math.Max(bit1, bit2);
subreg.FirstBit = lsb;
subreg.SizeInBits = msb - lsb + 1;
}
else
{
var lsb = fld.SelectSingleNode("lsb")?.InnerText ?? fld.SelectSingleNode("bitOffset")?.InnerText;
var msb = fld.SelectSingleNode("msb")?.InnerText;
var bitWidth = fld.SelectSingleNode("bitWidth")?.InnerText;
if (lsb == null)
{
continue;
}
subreg.FirstBit = (int)ParseScaledNonNegativeInteger(lsb);
if (msb != null)
{
subreg.SizeInBits = (int)ParseScaledNonNegativeInteger(msb) - subreg.FirstBit + 1;
}
else if (bitWidth != null)
{
subreg.SizeInBits = (int)ParseScaledNonNegativeInteger(bitWidth);
}
else
{
continue;
}
}
XmlElement vals = (XmlElement)fld.SelectSingleNode("enumeratedValues");
var numOfAddedKnownValues = 0;
Regex rgTrivialKnownValue = new Regex("^value[0-9]+$");
if (vals != null && subreg.SizeInBits > 1 && subreg.SizeInBits != 32)
{
if (subreg.SizeInBits > 8)
{
Console.WriteLine(string.Format("Warning: suspiciously large register with known values: {0} ({1} bits)", subreg.Name, subreg.SizeInBits));
}
else
{
KnownSubRegisterValue[] values = new KnownSubRegisterValue[1 << subreg.SizeInBits];
bool foundNonTrivialDefinitions = false;
foreach (XmlElement ev in vals)
{
var knownValueProp = ev.SelectSingleNode("value");
if (DoNotCareBits(knownValueProp.InnerText))
{
continue;
}
var knownValueIndex = (int)ParseScaledNonNegativeInteger(knownValueProp.InnerText);
var knowValueName = ev.SelectSingleNode("name").InnerText;
if (IsUserFriendlyName(knowValueName))
{
values[knownValueIndex] = new KnownSubRegisterValue {
Name = knowValueName
};
++numOfAddedKnownValues;
if (!rgTrivialKnownValue.IsMatch(knowValueName))
{
foundNonTrivialDefinitions = true;
}
}
}
if (numOfAddedKnownValues > 0 && foundNonTrivialDefinitions)
{
int found = 0;
for (int j = 0; j < values.Length; j++)
{
if (values[j] == null)
{
values[j] = new KnownSubRegisterValue {
Name = string.Format("Unknown (0x{0:x})", j)
}
}
;
else
{
found++;
}
}
double utilization = (double)found / values.Length;
if (utilization > 0.5 || values.Length < 16)
{
subreg.KnownValues = values;
}
}
}
}
subregs.Add(subreg);
}
registers.Add(new HardwareRegister
{
Address = string.Format("0x{0:x8}", baseAddr + addrOff + i * step),
Name = prefix + regName.Replace("%s", i.ToString()),
ReadOnly = access == "read-only",
SubRegisters = subregs.Count == 0 ? null : subregs.ToArray(),
SizeInBits = (int)regSize
});
}
}
private static HardwareSubRegister DeepCopy(HardwareSubRegister subreg)
{
HardwareSubRegister subreg_new = new HardwareSubRegister {
Name = subreg.Name,
FirstBit = subreg.FirstBit,
SizeInBits = subreg.SizeInBits,
KnownValues = (subreg.KnownValues != null) ? (KnownSubRegisterValue[])subreg.KnownValues.Clone() : null
};
return subreg_new;
}
//---------------------------------
private static List<HardwareRegisterSet> ProcessLoadHardwareRegisterSet()
{
List<HardwareRegisterSet> oReg = new List<HardwareRegisterSet>();
List<HardwareSubRegister> alstSubReg = new List<HardwareSubRegister>();
var aLstPerep = GetBaseAdress(mNameCurrentAdr);
foreach (var perep in aLstPerep)
{
List<HardwareRegister> alstReg = new List<HardwareRegister>();
ulong aBaseAdress = perep.adress;
perep.used = true;
foreach (var reg in adicAdrrOffsetDriv)
{
HardwareRegister Reg = new HardwareRegister();
alstSubReg.Clear();
Reg.Name = reg.Key;
Reg.Address = FormatToHex(reg.Value + aBaseAdress);
Reg.SizeInBits = 32;
foreach (var subReg in adicBitsOffsetDriv)
{
if (subReg.Key.StartsWith(Reg.Name))
{
HardwareSubRegister hsr = new HardwareSubRegister
{
Name = subReg.Key.Remove(0, Reg.Name.Length + 1),
ParentRegister = Reg,
OriginalMacroBase = Reg.Name,
SizeInBits = GetSizeBit(subReg.Value),
FirstBit = GetFirstBit(subReg.Value),
};
if (hsr.SizeInBits == 0)
Console.WriteLine("size subreg 0 " + hsr.Name);
alstSubReg.Add(hsr);
}
}
Reg.SubRegisters = alstSubReg.ToArray();
alstReg.Add(Reg);
}
if (alstReg.Count > 0)
oReg.Add(new HardwareRegisterSet
{
ExpressionPrefix = mNameCurrentAdr,
UserFriendlyName = perep.Name,// astrUserFrendlyName,
Registers = alstReg.ToArray()
});
}
return oReg;
}
private void SubRegisterDefinition()
{
_subRegister = new HardwareSubRegister();
_subRegister.Name = _lastMatch.Groups[3].Value;
_subRegister.FirstBit = _processedBits;
_subRegister.SizeInBits = int.Parse(_lastMatch.Groups[4].Value);
if (_subRegister.Name == string.Empty)
{
_subRegister.Name = string.Format("Unknown (0x{0:x})", _subRegister.FirstBit);
}
_subRegisters.Add(_subRegister);
_processedBits += _subRegister.SizeInBits;
SetExpectedMatches(SUBREGISTER_DEFINITION, SUBREGISTERS_END);
}
private void OnStart()
{
_processedBits = 0;
_registerNameToAddress = new Dictionary<string, string>();
_registerSetToAddress = new Dictionary<string, string>();
_subRegistersKnownValues = new Dictionary<string, IList<KeyValuePair<string, ulong>>>();
_registers = new List<HardwareRegister>();
_registerSets = new List<HardwareRegisterSet>();
_subRegisters = new List<HardwareSubRegister>();
_registersWithWrongBitsSum = new List<string>();
_duplicateRegisterDefinition = false;
_lastMatch = Match.Empty;
_matchedRegex = null;
_registerSet = null;
_register = null;
_subRegister = null;
_registerBits = new Dictionary<string, HardwareSubRegister>();
_expectedMatches = new List<Regex> { REGISTER_SET_ADDRESS };
}
static void AdjustHardwareRegisters(string ccsDir, string mcuName, ref HardwareRegisterSet[] hardwareRegisterSets)
{
string dir = ccsDir + @"\ccs_base\common\targetdb\devices";
if (!Directory.Exists(dir))
{
throw new Exception("Missing " + dir);
}
string tiDefinitionFile = dir + "\\" + mcuName + ".xml";
if (!File.Exists(tiDefinitionFile))
{
return;
}
XmlDocument doc = new XmlDocument();
doc.Load(tiDefinitionFile);
Dictionary <string, ulong> oldRegisters = new Dictionary <string, ulong>();
foreach (var set in hardwareRegisterSets)
{
foreach (var reg in set.Registers)
{
string name = reg.Name;
if (name.EndsWith("_H"))
{
continue;
}
else if (name.EndsWith("_L"))
{
name = name.Substring(0, name.Length - 2);
}
oldRegisters[name] = ParseAddr(reg.Address);
}
}
List <HardwareRegisterSet> newRegisterSets = new List <HardwareRegisterSet>();
foreach (XmlNode node in doc.SelectNodes("device/cpu/instance"))
{
XmlElement el = node as XmlElement;
if (el == null)
{
continue;
}
string peripheralDefinition = Path.Combine(Path.GetDirectoryName(tiDefinitionFile), el.Attributes["href"].Value);
if (!File.Exists(peripheralDefinition))
{
throw new NotSupportedException();
}
string addr = el.Attributes["baseaddr"].Value;
if (addr != "0x0000")
{
throw new NotSupportedException();
}
if (peripheralDefinition.EndsWith("_NotVisible.xml"))
{
continue;
}
XmlDocument xmlModule = new XmlDocument();
xmlModule.Load(peripheralDefinition);
var newSet = new HardwareRegisterSet {
UserFriendlyName = xmlModule.SelectSingleNode("module").Attributes["description"].Value
};
newRegisterSets.Add(newSet);
List <HardwareRegister> newRegs = new List <HardwareRegister>();
foreach (XmlElement reg in xmlModule.SelectNodes("module/register"))
{
string registerID = reg.Attributes["id"].Value;
ulong lAddr = ParseAddr(reg.Attributes["offset"].Value.Trim());
ulong oldAddr;
int sizeInBits = int.Parse(reg.Attributes["width"].Value);
if (oldRegisters.TryGetValue(registerID, out oldAddr))
{
if (oldAddr != lAddr)
{
Debugger.Log(0, "Warning", "Address mismatch for " + registerID + "\n");
}
oldRegisters[registerID] = ulong.MaxValue;
}
HardwareRegister newReg = new HardwareRegister {
Name = registerID, Address = string.Format("0x{0:x}", lAddr), SizeInBits = sizeInBits
};
List <HardwareSubRegister> subRegs = new List <HardwareSubRegister>();
foreach (XmlElement field in reg.SelectNodes("bitfield"))
{
string fieldID = field.Attributes["id"].Value;
int start = int.Parse(field.Attributes["begin"].Value);
int end = int.Parse(field.Attributes["end"].Value);
int width = int.Parse(field.Attributes["width"].Value);
if (start == (end + width - 1))
{
int tmp = start;
start = end;
end = tmp;
}
if (end != (start + width - 1))
{
throw new NotSupportedException();
}
var subReg = new HardwareSubRegister {
Name = fieldID, FirstBit = start, SizeInBits = width
};
KnownSubRegisterValue[] subValues = null;
bool bad = false;
int bitenumValuesChecked = 0;
foreach (XmlElement val in field.SelectNodes("bitenum"))
{
if (subValues == null)
{
subValues = new KnownSubRegisterValue[1 << width];
}
string valName = val.Attributes["id"].Value;
int value = int.Parse(val.Attributes["value"].Value);
if (value >= subValues.Length)
{
bad = true;
}
else
{
subValues[value] = new KnownSubRegisterValue {
Name = valName
}
};
bitenumValuesChecked++;
}
if (bad)
{
subValues = null;
if (bitenumValuesChecked == (1 << width))
{
//There's a typo in the XML files. Sometimes the 'value' for a divider is taken from the divider value and not the bitfield value. Let's try fixing it!
subValues = new KnownSubRegisterValue[1 << width];
int idx = 0;
int lastDividerValue = 0;
foreach (XmlElement val in field.SelectNodes("bitenum"))
{
string valName = val.Attributes["id"].Value;
int tmp = valName.LastIndexOf('_');
int dividerValue = int.Parse(valName.Substring(tmp + 1));
if (dividerValue < lastDividerValue)
{
throw new NotSupportedException(); //If the values are listed in the ascending order, we can assume that they are listed in the bitfield value order.
}
lastDividerValue = dividerValue;
subValues[idx++] = new KnownSubRegisterValue {
Name = valName
};
}
}
}
if (subValues != null)
{
foreach (var v in subValues)
{
if (v == null)
{
subValues = null;
break;
}
}
}
subReg.KnownValues = subValues;
subRegs.Add(subReg);
}
if (subRegs.Count > 0)
{
newReg.SubRegisters = subRegs.ToArray();
}
newRegs.Add(newReg);
}
newSet.Registers = newRegs.ToArray();
}
foreach (var kv in oldRegisters)
{
if (kv.Value != ulong.MaxValue)
{
Debugger.Log(0, "", "TI XML does not list " + kv.Key + "\n");
}
}
hardwareRegisterSets = newRegisterSets.ToArray();
}
