OpenHardwareMonitor: Hardware/LPC/IT87XX.cs@d882720734bf

     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 || chip == Chip.IT8728F) {

   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         case Chip.IT8728F:

   158           gpioCount = 0;

   159           break;

   160       }

   161     }

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

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

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

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

   168     public string GetReport() {

   169       StringBuilder r = new StringBuilder();

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

   172       r.AppendLine();

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

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

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

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

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

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

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

   180       r.AppendLine();

   182       if (!Ring0.WaitIsaBusMutex(100))

   183         return r.ToString();

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

   186       r.AppendLine();

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

   188       r.AppendLine();

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

   190         r.Append(" ");

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

   192         r.Append("  ");

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

   194           r.Append(" ");

   195           bool valid;

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

   197           r.Append(

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

   199         }

   200         r.AppendLine();

   201       }

   202       r.AppendLine();

   204       r.AppendLine("GPIO Registers");

   205       r.AppendLine();

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

   207         r.Append(" ");

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

   209           CultureInfo.InvariantCulture));

   210       }

   211       r.AppendLine();

   212       r.AppendLine();

   214       Ring0.ReleaseIsaBusMutex();

   216       return r.ToString();

   217     }

   219     public void Update() {

   220       if (!Ring0.WaitIsaBusMutex(10))

   221         return;

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

   224         bool valid;

   226         float value =

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

   229         if (!valid)

   230           continue;

   231         if (value > 0)

   232           voltages[i] = value;

   233         else

   234           voltages[i] = null;

   235       }

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

   238         bool valid;

   239         sbyte value = (sbyte)ReadByte(

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

   241         if (!valid)

   242           continue;

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

   245           temperatures[i] = value;

   246         else

   247           temperatures[i] = null;

   248       }

   250       if (has16bitFanCounter) {

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

   252           bool valid;

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

   254           if (!valid)

   255             continue;

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

   257           if (!valid)

   258             continue;

   260           if (value > 0x3f) {

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

   262           } else {

   263             fans[i] = null;

   264           }

   265         }

   266       } else {

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

   268           bool valid;

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

   270           if (!valid)

   271             continue;

   273           int divisor = 2;

   274           if (i < 2) {

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

   276             if (!valid)

   277               continue;

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

   279           }

   281           if (value > 0) {

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

   283           } else {

   284             fans[i] = null;

   285           }

   286         }

   287       }

   289       Ring0.ReleaseIsaBusMutex();

   290     }

   291   }

   292 }

author	moel.mich
	Thu, 07 Jul 2011 20:41:09 +0000
changeset 308	d882720734bf
parent 272	037a2d66082f
child 319	35cda448fc5f
permissions	-rw-r--r--