OpenHardwareMonitor: Hardware/LPC/IT87XX.cs@04905193c432

     1 /*

     3   Version: MPL 1.1/GPL 2.0/LGPL 2.1

     5   The contents of this file are subject to the Mozilla Public License Version

     6   1.1 (the "License"); you may not use this file except in compliance with

     7   the License. You may obtain a copy of the License at

     9   http://www.mozilla.org/MPL/

    11   Software distributed under the License is distributed on an "AS IS" basis,

    12   WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

    13   for the specific language governing rights and limitations under the License.

    15   The Original Code is the Open Hardware Monitor code.

    17   The Initial Developer of the Original Code is

    18   Michael Möller <m.moeller@gmx.ch>.

    19   Portions created by the Initial Developer are Copyright (C) 2009-2010

    20   the Initial Developer. All Rights Reserved.

    22   Contributor(s):

    24   Alternatively, the contents of this file may be used under the terms of

    25   either the GNU General Public License Version 2 or later (the "GPL"), or

    26   the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

    27   in which case the provisions of the GPL or the LGPL are applicable instead

    28   of those above. If you wish to allow use of your version of this file only

    29   under the terms of either the GPL or the LGPL, and not to allow others to

    30   use your version of this file under the terms of the MPL, indicate your

    31   decision by deleting the provisions above and replace them with the notice

    32   and other provisions required by the GPL or the LGPL. If you do not delete

    33   the provisions above, a recipient may use your version of this file under

    34   the terms of any one of the MPL, the GPL or the LGPL.

    36 */

    38 using System.Globalization;

    39 using System.Text;

    41 namespace OpenHardwareMonitor.Hardware.LPC {

    42   internal class IT87XX : ISuperIO {

    44     private readonly ushort address;

    45     private readonly Chip chip;

    46     private readonly byte version;

    48     private readonly ushort gpioAddress;

    49     private readonly int gpioCount;

    51     private readonly ushort addressReg;

    52     private readonly ushort dataReg;

    54     private readonly float?[] voltages = new float?[0];

    55     private readonly float?[] temperatures = new float?[0];

    56     private readonly float?[] fans = new float?[0];

    58     private readonly float voltageGain;

    59     private readonly bool has16bitFanCounter;

    61     // Consts

    62     private const byte ITE_VENDOR_ID = 0x90;

    64     // Environment Controller

    65     private const byte ADDRESS_REGISTER_OFFSET = 0x05;

    66     private const byte DATA_REGISTER_OFFSET = 0x06;

    68     // Environment Controller Registers

    69     private const byte CONFIGURATION_REGISTER = 0x00;

    70     private const byte TEMPERATURE_BASE_REG = 0x29;

    71     private const byte VENDOR_ID_REGISTER = 0x58;

    72     private const byte FAN_TACHOMETER_DIVISOR_REGISTER = 0x0B;

    73     private readonly byte[] FAN_TACHOMETER_REG =

    74       new byte[] { 0x0d, 0x0e, 0x0f, 0x80, 0x82 };

    75     private readonly byte[] FAN_TACHOMETER_EXT_REG =

    76       new byte[] { 0x18, 0x19, 0x1a, 0x81, 0x83 };

    77     private const byte VOLTAGE_BASE_REG = 0x20;

    79     private byte ReadByte(byte register, out bool valid) {

    80       Ring0.WriteIoPort(addressReg, register);

    81       byte value = Ring0.ReadIoPort(dataReg);

    82       valid = register == Ring0.ReadIoPort(addressReg);

    83       return value;

    84     }

    86     private bool WriteByte(byte register, byte value) {

    87       Ring0.WriteIoPort(addressReg, register);

    88       Ring0.WriteIoPort(dataReg, value);

    89       return register == Ring0.ReadIoPort(addressReg);

    90     }

    92     public byte? ReadGPIO(int index) {

    93       if (index >= gpioCount)

    94         return null;

    96       return Ring0.ReadIoPort((ushort)(gpioAddress + index));

    97     }

    99     public void WriteGPIO(int index, byte value) {

   100       if (index >= gpioCount)

   101         return;

   103       Ring0.WriteIoPort((ushort)(gpioAddress + index), value);

   104     }

   106     public IT87XX(Chip chip, ushort address, ushort gpioAddress, byte version) {

   108       this.address = address;

   109       this.chip = chip;

   110       this.version = version;

   111       this.addressReg = (ushort)(address + ADDRESS_REGISTER_OFFSET);

   112       this.dataReg = (ushort)(address + DATA_REGISTER_OFFSET);

   113       this.gpioAddress = gpioAddress;

   115       // Check vendor id

   116       bool valid;

   117       byte vendorId = ReadByte(VENDOR_ID_REGISTER, out valid);

   118       if (!valid || vendorId != ITE_VENDOR_ID)

   119         return;

   121       // Bit 0x10 of the configuration register should always be 1

   122       if ((ReadByte(CONFIGURATION_REGISTER, out valid) & 0x10) == 0)

   123         return;

   124       if (!valid)

   125         return;

   127       voltages = new float?[9];

   128       temperatures = new float?[3];

   129       fans = new float?[5];

   131       // The IT8721F uses a 12mV resultion ADC, all others 16mV

   132       if (chip == Chip.IT8721F) {

   133         voltageGain = 0.012f;

   134       } else {

   135         voltageGain = 0.016f;

   136       }

   138       // older IT8721F revision do not have 16-bit fan counters

   139       if (chip == Chip.IT8712F && version < 8) {

   140         has16bitFanCounter = false;

   141       } else {

   142         has16bitFanCounter = true;

   143       }

   145       // Set the number of GPIO sets

   146       switch (chip) {

   147         case Chip.IT8712F:

   148         case Chip.IT8716F:

   149         case Chip.IT8718F:

   150         case Chip.IT8726F:

   151           gpioCount = 5;

   152           break;

   153         case Chip.IT8720F:

   154         case Chip.IT8721F:

   155           gpioCount = 8;

   156           break;

   157       }

   158     }

   160     public Chip Chip { get { return chip; } }

   161     public float?[] Voltages { get { return voltages; } }

   162     public float?[] Temperatures { get { return temperatures; } }

   163     public float?[] Fans { get { return fans; } }

   165     public string GetReport() {

   166       StringBuilder r = new StringBuilder();

   168       r.AppendLine("LPC " + this.GetType().Name);

   169       r.AppendLine();

   170       r.Append("Chip ID: 0x"); r.AppendLine(chip.ToString("X"));

   171       r.Append("Chip Version: 0x"); r.AppendLine(

   172         version.ToString("X", CultureInfo.InvariantCulture));

   173       r.Append("Base Address: 0x"); r.AppendLine(

   174         address.ToString("X4", CultureInfo.InvariantCulture));

   175       r.Append("GPIO Address: 0x"); r.AppendLine(

   176         gpioAddress.ToString("X4", CultureInfo.InvariantCulture));

   177       r.AppendLine();

   179       if (!Ring0.WaitIsaBusMutex(100))

   180         return r.ToString();

   182       r.AppendLine("Environment Controller Registers");

   183       r.AppendLine();

   184       r.AppendLine("      00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F");

   185       r.AppendLine();

   186       for (int i = 0; i <= 0xA; i++) {

   187         r.Append(" ");

   188         r.Append((i << 4).ToString("X2", CultureInfo.InvariantCulture));

   189         r.Append("  ");

   190         for (int j = 0; j <= 0xF; j++) {

   191           r.Append(" ");

   192           bool valid;

   193           byte value = ReadByte((byte)((i << 4) | j), out valid);

   194           r.Append(

   195             valid ? value.ToString("X2", CultureInfo.InvariantCulture) : "??");

   196         }

   197         r.AppendLine();

   198       }

   199       r.AppendLine();

   201       r.AppendLine("GPIO Registers");

   202       r.AppendLine();

   203       for (int i = 0; i < gpioCount; i++) {

   204         r.Append(" ");

   205         r.Append(ReadGPIO(i).Value.ToString("X2",

   206           CultureInfo.InvariantCulture));

   207       }

   208       r.AppendLine();

   209       r.AppendLine();

   211       Ring0.ReleaseIsaBusMutex();

   213       return r.ToString();

   214     }

   216     public void Update() {

   217       if (!Ring0.WaitIsaBusMutex(10))

   218         return;

   220       for (int i = 0; i < voltages.Length; i++) {

   221         bool valid;

   223         float value =

   224           voltageGain * ReadByte((byte)(VOLTAGE_BASE_REG + i), out valid);

   226         if (!valid)

   227           continue;

   228         if (value > 0)

   229           voltages[i] = value;

   230         else

   231           voltages[i] = null;

   232       }

   234       for (int i = 0; i < temperatures.Length; i++) {

   235         bool valid;

   236         sbyte value = (sbyte)ReadByte(

   237           (byte)(TEMPERATURE_BASE_REG + i), out valid);

   238         if (!valid)

   239           continue;

   241         if (value < sbyte.MaxValue && value > 0)

   242           temperatures[i] = value;

   243         else

   244           temperatures[i] = null;

   245       }

   247       if (has16bitFanCounter) {

   248         for (int i = 0; i < fans.Length; i++) {

   249           bool valid;

   250           int value = ReadByte(FAN_TACHOMETER_REG[i], out valid);

   251           if (!valid)

   252             continue;

   253           value |= ReadByte(FAN_TACHOMETER_EXT_REG[i], out valid) << 8;

   254           if (!valid)

   255             continue;

   257           if (value > 0x3f) {

   258             fans[i] = (value < 0xffff) ? 1.35e6f / (value * 2) : 0;

   259           } else {

   260             fans[i] = null;

   261           }

   262         }

   263       } else {

   264         for (int i = 0; i < fans.Length; i++) {

   265           bool valid;

   266           int value = ReadByte(FAN_TACHOMETER_REG[i], out valid);

   267           if (!valid)

   268             continue;

   270           int divisor = 2;

   271           if (i < 2) {

   272             int divisors = ReadByte(FAN_TACHOMETER_DIVISOR_REGISTER, out valid);

   273             if (!valid)

   274               continue;

   275             divisor = 1 << ((divisors >> (3 * i)) & 0x7);

   276           }

   278           if (value > 0) {

   279             fans[i] = (value < 0xff) ? 1.35e6f / (value * divisor) : 0;

   280           } else {

   281             fans[i] = null;

   282           }

   283         }

   284       }

   286       Ring0.ReleaseIsaBusMutex();

   287     }

   288   }

   289 }

author	moel.mich
	Sat, 30 Apr 2011 21:01:54 +0000
changeset 276	04905193c432
parent 247	6dc755f1970e
child 277	5c80f37c0330
permissions	-rw-r--r--