OpenHardwareMonitor: Hardware/LPC/IT87XX.cs@df3493f75225

     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-2011

    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       // IT8721F, IT8728F and IT8772E use a 12mV resultion ADC, all others 16mV

   132       if (chip == Chip.IT8721F || chip == Chip.IT8728F || chip == Chip.IT8772E)

   133       {

   134         voltageGain = 0.012f;

   135       } else {

   136         voltageGain = 0.016f;

   137       }

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

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

   141         has16bitFanCounter = false;

   142       } else {

   143         has16bitFanCounter = true;

   144       }

   146       // Set the number of GPIO sets

   147       switch (chip) {

   148         case Chip.IT8712F:

   149         case Chip.IT8716F:

   150         case Chip.IT8718F:

   151         case Chip.IT8726F:

   152           gpioCount = 5;

   153           break;

   154         case Chip.IT8720F:

   155         case Chip.IT8721F:

   156           gpioCount = 8;

   157           break;

   158         case Chip.IT8728F:

   159         case Chip.IT8772E:

   160           gpioCount = 0;

   161           break;

   162       }

   163     }

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

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

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

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

   170     public string GetReport() {

   171       StringBuilder r = new StringBuilder();

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

   174       r.AppendLine();

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

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

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

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

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

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

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

   182       r.AppendLine();

   184       if (!Ring0.WaitIsaBusMutex(100))

   185         return r.ToString();

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

   188       r.AppendLine();

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

   190       r.AppendLine();

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

   192         r.Append(" ");

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

   194         r.Append("  ");

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

   196           r.Append(" ");

   197           bool valid;

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

   199           r.Append(

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

   201         }

   202         r.AppendLine();

   203       }

   204       r.AppendLine();

   206       r.AppendLine("GPIO Registers");

   207       r.AppendLine();

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

   209         r.Append(" ");

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

   211           CultureInfo.InvariantCulture));

   212       }

   213       r.AppendLine();

   214       r.AppendLine();

   216       Ring0.ReleaseIsaBusMutex();

   218       return r.ToString();

   219     }

   221     public void Update() {

   222       if (!Ring0.WaitIsaBusMutex(10))

   223         return;

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

   226         bool valid;

   228         float value =

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

   231         if (!valid)

   232           continue;

   233         if (value > 0)

   234           voltages[i] = value;

   235         else

   236           voltages[i] = null;

   237       }

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

   240         bool valid;

   241         sbyte value = (sbyte)ReadByte(

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

   243         if (!valid)

   244           continue;

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

   247           temperatures[i] = value;

   248         else

   249           temperatures[i] = null;

   250       }

   252       if (has16bitFanCounter) {

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

   254           bool valid;

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

   256           if (!valid)

   257             continue;

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

   259           if (!valid)

   260             continue;

   262           if (value > 0x3f) {

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

   264           } else {

   265             fans[i] = null;

   266           }

   267         }

   268       } else {

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

   270           bool valid;

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

   272           if (!valid)

   273             continue;

   275           int divisor = 2;

   276           if (i < 2) {

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

   278             if (!valid)

   279               continue;

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

   281           }

   283           if (value > 0) {

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

   285           } else {

   286             fans[i] = null;

   287           }

   288         }

   289       }

   291       Ring0.ReleaseIsaBusMutex();

   292     }

   293   }

   294 }

author	moel.mich
	Sat, 06 Aug 2011 17:27:55 +0000
changeset 320	df3493f75225
parent 319	35cda448fc5f
child 323	3f2d9ebacf38
permissions	-rw-r--r--