331 lines
10 KiB
C#
331 lines
10 KiB
C#
/*
|
|
|
|
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) 2009-2012 Michael Möller <mmoeller@openhardwaremonitor.org>
|
|
|
|
*/
|
|
|
|
using System.Globalization;
|
|
using System.Text;
|
|
using System;
|
|
|
|
namespace OpenHardwareMonitor.Hardware.LPC {
|
|
internal class IT87XX : ISuperIO {
|
|
|
|
private readonly ushort address;
|
|
private readonly Chip chip;
|
|
private readonly byte version;
|
|
|
|
private readonly ushort gpioAddress;
|
|
private readonly int gpioCount;
|
|
|
|
private readonly ushort addressReg;
|
|
private readonly ushort dataReg;
|
|
|
|
private readonly float?[] voltages = new float?[0];
|
|
private readonly float?[] temperatures = new float?[0];
|
|
private readonly float?[] fans = new float?[0];
|
|
private readonly float?[] controls = new float?[0];
|
|
|
|
private readonly float voltageGain;
|
|
private readonly bool has16bitFanCounter;
|
|
|
|
// Consts
|
|
private const byte ITE_VENDOR_ID = 0x90;
|
|
|
|
// Environment Controller
|
|
private const byte ADDRESS_REGISTER_OFFSET = 0x05;
|
|
private const byte DATA_REGISTER_OFFSET = 0x06;
|
|
|
|
// Environment Controller Registers
|
|
private const byte CONFIGURATION_REGISTER = 0x00;
|
|
private const byte TEMPERATURE_BASE_REG = 0x29;
|
|
private const byte VENDOR_ID_REGISTER = 0x58;
|
|
private const byte FAN_TACHOMETER_DIVISOR_REGISTER = 0x0B;
|
|
private readonly byte[] FAN_TACHOMETER_REG =
|
|
{ 0x0d, 0x0e, 0x0f, 0x80, 0x82 };
|
|
private readonly byte[] FAN_TACHOMETER_EXT_REG =
|
|
{ 0x18, 0x19, 0x1a, 0x81, 0x83 };
|
|
private const byte VOLTAGE_BASE_REG = 0x20;
|
|
private readonly byte[] FAN_PWM_CTRL_REG = { 0x15, 0x16, 0x17 };
|
|
|
|
private bool[] restoreDefaultFanPwmControlRequired = new bool[3];
|
|
private byte[] initialFanPwmControl = new byte[3];
|
|
|
|
private byte ReadByte(byte register, out bool valid) {
|
|
Ring0.WriteIoPort(addressReg, register);
|
|
byte value = Ring0.ReadIoPort(dataReg);
|
|
valid = register == Ring0.ReadIoPort(addressReg);
|
|
return value;
|
|
}
|
|
|
|
private bool WriteByte(byte register, byte value) {
|
|
Ring0.WriteIoPort(addressReg, register);
|
|
Ring0.WriteIoPort(dataReg, value);
|
|
return register == Ring0.ReadIoPort(addressReg);
|
|
}
|
|
|
|
public byte? ReadGPIO(int index) {
|
|
if (index >= gpioCount)
|
|
return null;
|
|
|
|
return Ring0.ReadIoPort((ushort)(gpioAddress + index));
|
|
}
|
|
|
|
public void WriteGPIO(int index, byte value) {
|
|
if (index >= gpioCount)
|
|
return;
|
|
|
|
Ring0.WriteIoPort((ushort)(gpioAddress + index), value);
|
|
}
|
|
|
|
private void SaveDefaultFanPwmControl(int index) {
|
|
bool valid;
|
|
if (!restoreDefaultFanPwmControlRequired[index]) {
|
|
initialFanPwmControl[index] =
|
|
ReadByte(FAN_PWM_CTRL_REG[index], out valid);
|
|
restoreDefaultFanPwmControlRequired[index] = true;
|
|
}
|
|
}
|
|
|
|
private void RestoreDefaultFanPwmControl(int index) {
|
|
if (restoreDefaultFanPwmControlRequired[index]) {
|
|
WriteByte(FAN_PWM_CTRL_REG[index], initialFanPwmControl[index]);
|
|
restoreDefaultFanPwmControlRequired[index] = false;
|
|
}
|
|
}
|
|
|
|
public void SetControl(int index, byte? value) {
|
|
if (index < 0 || index >= controls.Length)
|
|
throw new ArgumentOutOfRangeException("index");
|
|
|
|
if (!Ring0.WaitIsaBusMutex(10))
|
|
return;
|
|
|
|
if (value.HasValue) {
|
|
SaveDefaultFanPwmControl(index);
|
|
|
|
// set output value
|
|
WriteByte(FAN_PWM_CTRL_REG[index], (byte)(value.Value >> 1));
|
|
} else {
|
|
RestoreDefaultFanPwmControl(index);
|
|
}
|
|
|
|
Ring0.ReleaseIsaBusMutex();
|
|
}
|
|
|
|
public IT87XX(Chip chip, ushort address, ushort gpioAddress, byte version) {
|
|
|
|
this.address = address;
|
|
this.chip = chip;
|
|
this.version = version;
|
|
this.addressReg = (ushort)(address + ADDRESS_REGISTER_OFFSET);
|
|
this.dataReg = (ushort)(address + DATA_REGISTER_OFFSET);
|
|
this.gpioAddress = gpioAddress;
|
|
|
|
// Check vendor id
|
|
bool valid;
|
|
byte vendorId = ReadByte(VENDOR_ID_REGISTER, out valid);
|
|
if (!valid || vendorId != ITE_VENDOR_ID)
|
|
return;
|
|
|
|
// Bit 0x10 of the configuration register should always be 1
|
|
if ((ReadByte(CONFIGURATION_REGISTER, out valid) & 0x10) == 0)
|
|
return;
|
|
if (!valid)
|
|
return;
|
|
|
|
voltages = new float?[9];
|
|
temperatures = new float?[3];
|
|
fans = new float?[chip == Chip.IT8705F ? 3 : 5];
|
|
controls = new float?[3];
|
|
|
|
// IT8721F, IT8728F and IT8772E use a 12mV resultion ADC, all others 16mV
|
|
if (chip == Chip.IT8721F || chip == Chip.IT8728F || chip == Chip.IT8771E
|
|
|| chip == Chip.IT8772E)
|
|
{
|
|
voltageGain = 0.012f;
|
|
} else {
|
|
voltageGain = 0.016f;
|
|
}
|
|
|
|
// older IT8705F and IT8721F revisions do not have 16-bit fan counters
|
|
if ((chip == Chip.IT8705F && version < 3) ||
|
|
(chip == Chip.IT8712F && version < 8))
|
|
{
|
|
has16bitFanCounter = false;
|
|
} else {
|
|
has16bitFanCounter = true;
|
|
}
|
|
|
|
// Set the number of GPIO sets
|
|
switch (chip) {
|
|
case Chip.IT8712F:
|
|
case Chip.IT8716F:
|
|
case Chip.IT8718F:
|
|
case Chip.IT8726F:
|
|
gpioCount = 5;
|
|
break;
|
|
case Chip.IT8720F:
|
|
case Chip.IT8721F:
|
|
gpioCount = 8;
|
|
break;
|
|
case Chip.IT8705F:
|
|
case Chip.IT8728F:
|
|
case Chip.IT8771E:
|
|
case Chip.IT8772E:
|
|
gpioCount = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
public Chip Chip { get { return chip; } }
|
|
public float?[] Voltages { get { return voltages; } }
|
|
public float?[] Temperatures { get { return temperatures; } }
|
|
public float?[] Fans { get { return fans; } }
|
|
public float?[] Controls { get { return controls; } }
|
|
|
|
public string GetReport() {
|
|
StringBuilder r = new StringBuilder();
|
|
|
|
r.AppendLine("LPC " + this.GetType().Name);
|
|
r.AppendLine();
|
|
r.Append("Chip ID: 0x"); r.AppendLine(chip.ToString("X"));
|
|
r.Append("Chip Version: 0x"); r.AppendLine(
|
|
version.ToString("X", CultureInfo.InvariantCulture));
|
|
r.Append("Base Address: 0x"); r.AppendLine(
|
|
address.ToString("X4", CultureInfo.InvariantCulture));
|
|
r.Append("GPIO Address: 0x"); r.AppendLine(
|
|
gpioAddress.ToString("X4", CultureInfo.InvariantCulture));
|
|
r.AppendLine();
|
|
|
|
if (!Ring0.WaitIsaBusMutex(100))
|
|
return r.ToString();
|
|
|
|
r.AppendLine("Environment Controller Registers");
|
|
r.AppendLine();
|
|
r.AppendLine(" 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F");
|
|
r.AppendLine();
|
|
for (int i = 0; i <= 0xA; i++) {
|
|
r.Append(" ");
|
|
r.Append((i << 4).ToString("X2", CultureInfo.InvariantCulture));
|
|
r.Append(" ");
|
|
for (int j = 0; j <= 0xF; j++) {
|
|
r.Append(" ");
|
|
bool valid;
|
|
byte value = ReadByte((byte)((i << 4) | j), out valid);
|
|
r.Append(
|
|
valid ? value.ToString("X2", CultureInfo.InvariantCulture) : "??");
|
|
}
|
|
r.AppendLine();
|
|
}
|
|
r.AppendLine();
|
|
|
|
r.AppendLine("GPIO Registers");
|
|
r.AppendLine();
|
|
for (int i = 0; i < gpioCount; i++) {
|
|
r.Append(" ");
|
|
r.Append(ReadGPIO(i).Value.ToString("X2",
|
|
CultureInfo.InvariantCulture));
|
|
}
|
|
r.AppendLine();
|
|
r.AppendLine();
|
|
|
|
Ring0.ReleaseIsaBusMutex();
|
|
|
|
return r.ToString();
|
|
}
|
|
|
|
public void Update() {
|
|
if (!Ring0.WaitIsaBusMutex(10))
|
|
return;
|
|
|
|
for (int i = 0; i < voltages.Length; i++) {
|
|
bool valid;
|
|
|
|
float value =
|
|
voltageGain * ReadByte((byte)(VOLTAGE_BASE_REG + i), out valid);
|
|
|
|
if (!valid)
|
|
continue;
|
|
if (value > 0)
|
|
voltages[i] = value;
|
|
else
|
|
voltages[i] = null;
|
|
}
|
|
|
|
for (int i = 0; i < temperatures.Length; i++) {
|
|
bool valid;
|
|
sbyte value = (sbyte)ReadByte(
|
|
(byte)(TEMPERATURE_BASE_REG + i), out valid);
|
|
if (!valid)
|
|
continue;
|
|
|
|
if (value < sbyte.MaxValue && value > 0)
|
|
temperatures[i] = value;
|
|
else
|
|
temperatures[i] = null;
|
|
}
|
|
|
|
if (has16bitFanCounter) {
|
|
for (int i = 0; i < fans.Length; i++) {
|
|
bool valid;
|
|
int value = ReadByte(FAN_TACHOMETER_REG[i], out valid);
|
|
if (!valid)
|
|
continue;
|
|
value |= ReadByte(FAN_TACHOMETER_EXT_REG[i], out valid) << 8;
|
|
if (!valid)
|
|
continue;
|
|
|
|
if (value > 0x3f) {
|
|
fans[i] = (value < 0xffff) ? 1.35e6f / (value * 2) : 0;
|
|
} else {
|
|
fans[i] = null;
|
|
}
|
|
}
|
|
} else {
|
|
for (int i = 0; i < fans.Length; i++) {
|
|
bool valid;
|
|
int value = ReadByte(FAN_TACHOMETER_REG[i], out valid);
|
|
if (!valid)
|
|
continue;
|
|
|
|
int divisor = 2;
|
|
if (i < 2) {
|
|
int divisors = ReadByte(FAN_TACHOMETER_DIVISOR_REGISTER, out valid);
|
|
if (!valid)
|
|
continue;
|
|
divisor = 1 << ((divisors >> (3 * i)) & 0x7);
|
|
}
|
|
|
|
if (value > 0) {
|
|
fans[i] = (value < 0xff) ? 1.35e6f / (value * divisor) : 0;
|
|
} else {
|
|
fans[i] = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < controls.Length; i++) {
|
|
bool valid;
|
|
byte value = ReadByte(FAN_PWM_CTRL_REG[i], out valid);
|
|
if (!valid)
|
|
continue;
|
|
|
|
if ((value & 0x80) > 0) {
|
|
// automatic operation (value can't be read)
|
|
controls[i] = null;
|
|
} else {
|
|
// software operation
|
|
controls[i] = (float)Math.Round((value & 0x7F) * 100.0f / 0x7F);
|
|
}
|
|
}
|
|
|
|
Ring0.ReleaseIsaBusMutex();
|
|
}
|
|
}
|
|
}
|