Merge remote-tracking branch 'lib/master'

# Conflicts:
#	OpenHardwareMonitorLib/Hardware/Memory/MemoryGroup.cs
#	OpenHardwareMonitorLib/Hardware/Motherboard/Lpc/LpcIO.cs

Author: sergiye

OpenHardwareMonitorLib/Hardware/Memory/MemoryGroup.cs

@@ -1,4 +1,9 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using RAMSPDToolkit.I2CSMBus;
 using RAMSPDToolkit.SPD;
@@ -9,116 +14,196 @@
 
 namespace OpenHardwareMonitor.Hardware.Memory;
 
-internal class MemoryGroup : IGroup
+internal class MemoryGroup : IGroup, IHardwareChanged
 {
-    //Retry 12x
-    private const int RetryCount = 12;
-    //Retry every 2.5 seconds
-    private const int RetryTime = 2500;
     private static readonly object _lock = new();
+    private List<Hardware> _hardware = [];
 
-    private readonly List<Hardware> _hardware = [];
+    private CancellationTokenSource _cancellationTokenSource;
+    private Exception _lastException;
+    private bool _opened = false;
 
-    static MemoryGroup()
+    public MemoryGroup(ISettings settings)
     {
-        if (OperatingSystemHelper.IsAdministrator() && Ring0.IsOpen)
+        if (Ring0.IsOpen && (DriverManager.Driver is null || !DriverManager.Driver.IsOpen))
         {
-            //Assign implementation of IDriver
+            // Assign implementation of IDriver.
             DriverManager.Driver = new RAMSPDToolkitDriver(Ring0.KernelDriver);
             SMBusManager.UseWMI = false;
         }
-    }
 
-    public MemoryGroup(ISettings settings)
-    {
-        _hardware.Add(new TotalMemory(settings));
         _hardware.Add(new VirtualMemory(settings));
+        _hardware.Add(new TotalMemory(settings));
 
-        if (OperatingSystemHelper.IsAdministrator())
+        if (DriverManager.Driver == null)
         {
-            Task.Run(async () =>
-            {
-                var _elapsedCounter = 0;
-                while (true)
-                {
-                    //SMBus might not be detected right after boot
-                    if (DetectThermalSensors(out var accessors) || _elapsedCounter++ >= RetryCount)
-                    {
-                        if (accessors != null)
-                            AddDimms(accessors, settings);
-                        break;
-                    }
-                    await Task.Delay(RetryTime);
-                }
-            });
+            return;
         }
-    }
 
-    public string GetReport()
-    {
-        return null;
+        if (!TryAddDimms(settings))
+        {
+            StartRetryTask(settings);
+        }
+
+        _opened = true;
     }
 
+    public event HardwareEventHandler HardwareAdded;
+    public event HardwareEventHandler HardwareRemoved;
+
     public IReadOnlyList<IHardware> Hardware => _hardware;
 
-    public void Close()
+    public string GetReport()
     {
-        foreach (Hardware ram in _hardware)
-            ram.Close();
+        StringBuilder report = new();
+        report.AppendLine("Memory Report:");
+        if (_lastException != null)
+        {
+            report.AppendLine($"Error while detecting memory: {_lastException.Message}");
+        }
+
+        foreach (Hardware hardware in _hardware)
+        {
+            report.AppendLine($"{hardware.Name} ({hardware.Identifier}):");
+            report.AppendLine();
+            foreach (ISensor sensor in hardware.Sensors)
+            {
+                report.AppendLine($"{sensor.Name}: {sensor.Value?.ToString() ?? "No value"}");
+            }
+        }
+
+        return report.ToString();
     }
 
-    private static bool DetectThermalSensors(out List<SPDAccessor> accessors)
+    public void Close()
     {
         lock (_lock)
         {
-            var list = new List<SPDAccessor>();
+            _opened = false;
+            foreach (Hardware ram in _hardware)
+                ram.Close();
 
-            bool ramDetected = false;
+            _hardware.Clear();
 
-            SMBusManager.DetectSMBuses();
+            _cancellationTokenSource?.Cancel();
+            _cancellationTokenSource?.Dispose();
+            _cancellationTokenSource = null;
+        }
+    }
 
-            //Go through detected SMBuses
-            foreach (var smbus in SMBusManager.RegisteredSMBuses)
+    private bool TryAddDimms(ISettings settings)
+    {
+        try
+        {
+            lock (_lock)
             {
-                //Go through possible RAM slots
-                for (byte i = SPDConstants.SPD_BEGIN; i <= SPDConstants.SPD_END; ++i)
+                if (!_opened)
                 {
-                    //Detect type of RAM, if available
-                    var detector = new SPDDetector(smbus, i);
+                    return true;
+                }
 
-                    //RAM available and detected
-                    if (detector.Accessor != null)
+                if (DetectThermalSensors(out List<SPDAccessor> accessors))
+                {
+                    AddDimms(accessors, settings);
+                    return true;
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            _lastException = ex;
+            Debug.Assert(false, "Exception while detecting RAM: " + ex.Message);
+        }
+
+        return false;
+    }
+
+    private void StartRetryTask(ISettings settings)
+    {
+        _cancellationTokenSource = new CancellationTokenSource();
+
+        Task.Run(async () =>
+        {
+            int retryRemaining = 5;
+
+            while (!_cancellationTokenSource.IsCancellationRequested && --retryRemaining > 0)
+            {
+                await Task.Delay(TimeSpan.FromSeconds(2.5), _cancellationTokenSource.Token).ConfigureAwait(false);
+
+                if (TryAddDimms(settings))
+                {
+                    lock (_lock)
                     {
-                        //We are only interested in modules with thermal sensor
-                        if (detector.Accessor is IThermalSensor { HasThermalSensor: true })
-                            list.Add(detector.Accessor);
+                        if (!_opened)
+                        {
+                            return;
+                        }
+
+                        foreach (Hardware hardware in _hardware.OfType<DimmMemory>())
+                        {
+                            HardwareAdded?.Invoke(hardware);
+                        }
 
-                        ramDetected = true;
+                        _cancellationTokenSource.Dispose();
+                        _cancellationTokenSource = null;
+
+                        break;
                     }
+
                 }
             }
+        }, _cancellationTokenSource.Token);
+    }
 
-            accessors = list.Count > 0 ? list : [];
-            return ramDetected;
+    private static bool DetectThermalSensors(out List<SPDAccessor> accessors)
+    {
+        accessors = [];
+
+        bool ramDetected = false;
+
+        SMBusManager.DetectSMBuses();
+
+        //Go through detected SMBuses
+        foreach (SMBusInterface smbus in SMBusManager.RegisteredSMBuses)
+        {
+            //Go through possible RAM slots
+            for (byte i = SPDConstants.SPD_BEGIN; i <= SPDConstants.SPD_END; ++i)
+            {
+                //Detect type of RAM, if available
+                SPDDetector detector = new(smbus, i);
+
+                //RAM available and detected
+                if (detector.Accessor != null)
+                {
+                    //We are only interested in modules with thermal sensor
+                    if (detector.Accessor is IThermalSensor { HasThermalSensor: true })
+                        accessors.Add(detector.Accessor);
+
+                    ramDetected = true;
+                }
+            }
         }
+
+        return ramDetected;
     }
 
     private void AddDimms(List<SPDAccessor> accessors, ISettings settings)
     {
-        foreach (var ram in accessors)
+        List<Hardware> newHardwareList = [.. _hardware];
+
+        foreach (SPDAccessor ram in accessors)
         {
             //Default value
             string name = $"DIMM #{ram.Index}";
 
             //Check if we can switch to the correct page
             if (ram.ChangePage(PageData.ModulePartNumber))
-            {
                 name = $"{ram.GetModuleManufacturerString()} - {ram.ModulePartNumber()} (#{ram.Index})";
-            }
 
-            var memory = new DimmMemory(ram, name, new Identifier("ram"), settings);
-
-            _hardware.Add(memory);
+            DimmMemory memory = new(ram, name, new Identifier($"memory/dimm/{ram.Index}"), settings);
+            newHardwareList.Add(memory);
         }
+
+        _hardware = newHardwareList;
     }
 }

OpenHardwareMonitorLib/Hardware/Motherboard/Identification.cs

@@ -103,6 +103,8 @@ public static Model GetModel(string name)
     {
         switch (name)
         {
+            case var _ when name.Equals("X870 AORUS ELITE WIFI7", StringComparison.OrdinalIgnoreCase):
+                return Model.X870_AORUS_ELITE_WIFI7;
             case var _ when name.Equals("880GMH/USB3", StringComparison.OrdinalIgnoreCase):
                 return Model._880GMH_USB3;
             case var _ when name.Equals("B85M-DGS", StringComparison.OrdinalIgnoreCase):
@@ -617,12 +619,16 @@ public static Model GetModel(string name)
                 return Model.X870E_AORUS_PRO;
             case var _ when name.Equals("X870E AORUS PRO ICE", StringComparison.OrdinalIgnoreCase):
                 return Model.X870E_AORUS_PRO_ICE;
+            case var _ when name.Equals("ROG STRIX X870-I GAMING WIFI", StringComparison.OrdinalIgnoreCase):
+                return Model.ROG_STRIX_X870_I_GAMING_WIFI;
             case var _ when name.Equals("X870E AORUS XTREME AI TOP", StringComparison.OrdinalIgnoreCase):
                 return Model.X870E_AORUS_XTREME_AI_TOP;
             case var _ when name.Equals("PROART X870E-CREATOR WIFI", StringComparison.OrdinalIgnoreCase):
                 return Model.PROART_X870E_CREATOR_WIFI;
             case var _ when name.Equals("PRIME X870-P", StringComparison.OrdinalIgnoreCase):
                 return Model.PRIME_X870_P;
+            case var _ when name.Equals("ROG STRIX X870-I GAMING WIFI", StringComparison.OrdinalIgnoreCase):
+                return Model.ROG_STRIX_X870_I_GAMING_WIFI;
             case var _ when name.Equals("ROG CROSSHAIR X870E HERO", StringComparison.OrdinalIgnoreCase):
                 return Model.ROG_CROSSHAIR_X870E_HERO;
             case var _ when name.Equals("MAG X870 TOMAHAWK WIFI (MS-7E51)", StringComparison.OrdinalIgnoreCase):

OpenHardwareMonitorLib/Hardware/Motherboard/Lpc/EC/EmbeddedController.cs

@@ -274,6 +274,12 @@ public abstract class EmbeddedController : Hardware
             ECSensor.CurrCPU,
             ECSensor.FanCPUOpt,
             ECSensor.FanWaterFlow),
+        new(Model.ROG_STRIX_X870_I_GAMING_WIFI,
+            BoardFamily.Amd800,
+            ECSensor.TempCPU,
+            ECSensor.TempCPUPackage,
+            ECSensor.TempMB,
+            ECSensor.TempVrm),
     };
 
     private static readonly Dictionary<BoardFamily, Dictionary<ECSensor, EmbeddedControllerSource>> _knownSensors = new()
@@ -322,6 +328,17 @@ public abstract class EmbeddedController : Hardware
                 { ECSensor.TempWaterOut, new EmbeddedControllerSource("Water Out", SensorType.Temperature, 0x0101, blank: -40) }
             }
         },
+        {
+            BoardFamily.Amd800, new Dictionary<ECSensor, EmbeddedControllerSource>
+            {
+                { ECSensor.TempCPU, new EmbeddedControllerSource("CPU", SensorType.Temperature, 0x0030) },
+                { ECSensor.TempCPUPackage, new EmbeddedControllerSource("CPU Package", SensorType.Temperature, 0x0031) },
+                { ECSensor.TempMB, new EmbeddedControllerSource("Motherboard", SensorType.Temperature, 0x0032) },
+                { ECSensor.TempVrm, new EmbeddedControllerSource("VRM", SensorType.Temperature, 0x0033) },
+                { ECSensor.TempTSensor, new EmbeddedControllerSource("T Sensor", SensorType.Temperature, 0x0036, blank: -40) },
+                { ECSensor.FanCPUOpt, new EmbeddedControllerSource("CPU Optional Fan", SensorType.Fan, 0x00b0, 2) }
+            }
+        },
         {
             BoardFamily.Intel100, new Dictionary<ECSensor, EmbeddedControllerSource>
             {
@@ -532,6 +549,9 @@ private enum ECSensor
 
         /// <summary>CPU temperature [℃]</summary>
         TempCPU,
+		
+        /// <summary>CPU Package temperature [℃]</summary>
+        TempCPUPackage,
 
         /// <summary>motherboard temperature [℃]</summary>
         TempMB,
@@ -582,6 +602,7 @@ private enum BoardFamily
         Amd400,
         Amd500,
         Amd600,
+		Amd800,
         Intel100,
         Intel300,
         Intel400,

OpenHardwareMonitorLib/Hardware/Motherboard/Lpc/IT87XX.cs

@@ -69,6 +69,7 @@ public IT87XX(Chip chip, ushort address, ushort gpioAddress, byte version, Mothe
         {
             Chip.IT8665E or Chip.IT8625E => new byte[] { 0x15, 0x16, 0x17, 0x1e, 0x1f, 0x92 },
             Chip.IT8792E => new byte[] { 0x15, 0x16, 0x17 },
+            Chip.IT8696E => new byte[] { 0, 0, 0, 0, 0 },
             _ => new byte[] { 0x15, 0x16, 0x17, 0x7f, 0xa7, 0xaf }
         };
 
@@ -155,8 +156,8 @@ Chip.IT8631E or
             case Chip.IT8696E:
                 Voltages = new float?[10];
                 Temperatures = new float?[6];
-                Fans = new float?[6];
-                Controls = new float?[6];
+                Fans = new float?[5];
+                Controls = new float?[5];
                 break;
 
             case Chip.IT87952E:

OpenHardwareMonitorLib/Hardware/Motherboard/Lpc/LpcIO.cs

@@ -383,7 +383,7 @@ private bool DetectWinbondFintek(LpcPort port, Motherboard motherboard)
             case 0xD5:
                 switch (revision)
                 {
-                    case 0x92:                                
+                    case 0x92:
                         switch (motherboard.Model)
                         {
                             case Model.B840P_PRO_WIFI:
@@ -405,14 +405,13 @@ private bool DetectWinbondFintek(LpcPort port, Motherboard motherboard)
                             case Model.Z890_EDGE_TI_WIFI:
                             case Model.Z890P_PRO_WIFI:
                             case Model.Z890A_PRO_WIFI:
-                            case Model.Z890_GAMING_PLUS_WIFI:
-                            case Model.Z890S_PRO_WIFI_PROJECT_ZERO:
                                 chip = Chip.NCT6687DR; // MSI AM5/LGA1851 Compatibility
                                 break;
                             default:
                                 chip = Chip.NCT6687D;
                                 break;
                         }
+
                         logicalDeviceNumber = WINBOND_NUVOTON_HARDWARE_MONITOR_LDN;
                         break;
                 }
@@ -774,6 +773,7 @@ private IGigabyteController FindGigabyteECUsingSmfi(LpcPort port, Chip chip, Ven
     private const byte IT87_LD_ACTIVE_REGISTER = 0x30;
 
     private readonly ushort[] REGISTER_PORTS = { 0x2E, 0x4E };
+
     private readonly ushort[] VALUE_PORTS = { 0x2F, 0x4F };
     // ReSharper restore InconsistentNaming
 }