Add DIMM Temperature to LHM. (#1743)

* Add DIMM Temperature to LHM.

* Remove RAMSPDToolkit as submodule and use nuget package instead.
Upgrade System.Management assembly (required for nuget package).
Implement retry mechanism for RAM detection due to possible issue at system boot.

* Change to static field.

* Driver now back in LHM.
Ring0 replaced with OLS implementation.

* Update package version.

* Undo most of changes.
Implement IDriver interface.

* Change package to new one.

* Review changes.
Explicitly set UseWMI (current default is also false).

* PR comments:
Now having one DimmMemory instance per RAM stick.
Separated memory sensors into two new classes.

* PR feedback

---------

Co-authored-by: PhyxionNL <7643972+PhyxionNL@users.noreply.github.com>

Author: Blacktempel

LibreHardwareMonitorLib/Hardware/Memory/DimmMemory.cs

@@ -0,0 +1,64 @@
+// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+// If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+// Copyright (C) LibreHardwareMonitor and Contributors.
+// Partial Copyright (C) Michael Möller <mmoeller@openhardwaremonitor.org> and Contributors.
+// All Rights Reserved.
+
+using LibreHardwareMonitor.Hardware.Memory.Sensors;
+using RAMSPDToolkit.SPD;
+using RAMSPDToolkit.SPD.Enums;
+using RAMSPDToolkit.SPD.Interfaces;
+using RAMSPDToolkit.SPD.Interop.Shared;
+
+namespace LibreHardwareMonitor.Hardware.Memory;
+
+internal sealed class DimmMemory : Hardware
+{
+    private readonly SpdThermalSensor _thermalSensor;
+
+    public DimmMemory(SPDAccessor accessor, string name, Identifier identifier, ISettings settings)
+        : base(name, identifier, settings)
+    {
+        //Check which kind of RAM we have
+        switch (accessor.MemoryType())
+        {
+            case SPDMemoryType.SPD_DDR4_SDRAM:
+            case SPDMemoryType.SPD_DDR4E_SDRAM:
+            case SPDMemoryType.SPD_LPDDR4_SDRAM:
+            case SPDMemoryType.SPD_LPDDR4X_SDRAM:
+                _thermalSensor = new SpdThermalSensor($"DIMM #{accessor.Index}",
+                                                      accessor.Index,
+                                                      SensorType.Temperature,
+                                                      this,
+                                                      settings,
+                                                      accessor as IThermalSensor);
+
+                break;
+            case SPDMemoryType.SPD_DDR5_SDRAM:
+            case SPDMemoryType.SPD_LPDDR5_SDRAM:
+                //Check if we are on correct page or if write protection is not enabled
+                if (accessor.PageData.HasFlag(PageData.ThermalData) || !accessor.HasSPDWriteProtection)
+                {
+                    _thermalSensor = new SpdThermalSensor($"DIMM #{accessor.Index}",
+                                                          accessor.Index,
+                                                          SensorType.Temperature,
+                                                          this,
+                                                          settings,
+                                                          accessor as IThermalSensor);
+                }
+
+                break;
+        }
+
+        //Add thermal sensor
+        if (_thermalSensor != null)
+            ActivateSensor(_thermalSensor);
+    }
+
+    public override HardwareType HardwareType => HardwareType.Memory;
+
+    public override void Update()
+    {
+        _thermalSensor?.UpdateSensor();
+    }
+}

LibreHardwareMonitorLib/Hardware/Memory/GenericLinuxMemory.cs

@@ -5,28 +5,137 @@
 // All Rights Reserved.
 
 using System.Collections.Generic;
+using System.Timers;
+using RAMSPDToolkit.I2CSMBus;
+using RAMSPDToolkit.SPD;
+using RAMSPDToolkit.SPD.Enums;
+using RAMSPDToolkit.SPD.Interfaces;
+using RAMSPDToolkit.SPD.Interop.Shared;
+using RAMSPDToolkit.Windows.Driver;
 
 namespace LibreHardwareMonitor.Hardware.Memory;
 
 internal class MemoryGroup : IGroup
 {
-    private readonly Hardware[] _hardware;
+    //Retry 12x
+    private const int RetryCount = 12;
+
+    //Retry every 2.5 seconds
+    private const double RetryTime = 2500;
+    private static readonly object _lock = new();
+
+    private readonly List<Hardware> _hardware = [];
+    private int _elapsedCounter;
+
+    private Timer _timer;
+
+    static MemoryGroup()
+    {
+        if (Ring0.IsOpen)
+        {
+            //Assign implementation of IDriver
+            DriverManager.Driver = new RAMSPDToolkitDriver(Ring0.KernelDriver);
+            SMBusManager.UseWMI = false;
+        }
+    }
 
     public MemoryGroup(ISettings settings)
     {
-        _hardware = new Hardware[] { Software.OperatingSystem.IsUnix ? new GenericLinuxMemory("Generic Memory", settings) : new GenericWindowsMemory("Generic Memory", settings) };
+        _hardware.Add(new VirtualMemory(settings));
+        _hardware.Add(new TotalMemory(settings));
+
+        //No RAM detected
+        if (!DetectThermalSensors(out List<SPDAccessor> accessors))
+        {
+            //Retry a couple of times
+            //SMBus might not be detected right after boot
+            _timer = new Timer(RetryTime);
+
+            _timer.Elapsed += (_, _) =>
+            {
+                if (_elapsedCounter++ >= RetryCount || DetectThermalSensors(out accessors))
+                {
+                    _timer.Stop();
+                    _timer = null;
+
+                    if (accessors != null)
+                        AddDimms(accessors, settings);
+                }
+            };
+
+            _timer.Start();
+        }
+        else
+        {
+            AddDimms(accessors, settings);
+        }
     }
 
+    public IReadOnlyList<IHardware> Hardware => _hardware;
+
     public string GetReport()
     {
         return null;
     }
 
-    public IReadOnlyList<IHardware> Hardware => _hardware;
-
     public void Close()
     {
         foreach (Hardware ram in _hardware)
             ram.Close();
     }
+
+    private static bool DetectThermalSensors(out List<SPDAccessor> accessors)
+    {
+        lock (_lock)
+        {
+            var list = new List<SPDAccessor>();
+
+            bool ramDetected = false;
+
+            SMBusManager.DetectSMBuses();
+
+            //Go through detected SMBuses
+            foreach (var 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
+                    var detector = new SPDDetector(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 })
+                            list.Add(detector.Accessor);
+
+                        ramDetected = true;
+                    }
+                }
+            }
+
+            accessors = list.Count > 0 ? list : [];
+            return ramDetected;
+        }
+    }
+
+    private void AddDimms(List<SPDAccessor> accessors, ISettings settings)
+    {
+        foreach (var 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);
+        }
+    }
 }