MercurialOpenHardwareMonitor / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
Hardware/LPC/LPCIO.cs
author moel.mich
Sun, 15 May 2011 17:21:27 +0000
changeset 286 48d7e8d6c0db
parent 265 961c07a3bd78
child 296 414783d1cda9
permissions -rw-r--r--
Fixed Issue 204. 
     1 /*

     2   

     3   Version: MPL 1.1/GPL 2.0/LGPL 2.1

     4 

     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

     8  

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

    10 

    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.

    14 

    15   The Original Code is the Open Hardware Monitor code.

    16 

    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.

    21 

    22   Contributor(s):

    23 

    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.

    35  

    36 */

    37 

    38 using System;

    39 using System.Collections.Generic;

    40 using System.Globalization;

    41 using System.Text;

    42 using System.Threading;

    43 

    44 namespace OpenHardwareMonitor.Hardware.LPC {

    45   internal class LPCIO {

    46 

    47     private readonly List<ISuperIO> superIOs = new List<ISuperIO>();

    48     private readonly StringBuilder report = new StringBuilder();

    49 

    50     // I/O Ports

    51     private readonly ushort[] REGISTER_PORTS = new ushort[] { 0x2E, 0x4E };

    52     private readonly ushort[] VALUE_PORTS = new ushort[] { 0x2F, 0x4F };

    53 

    54     private ushort registerPort;

    55     private ushort valuePort;

    56 

    57     // Registers

    58     private const byte CONFIGURATION_CONTROL_REGISTER = 0x02;

    59     private const byte DEVCIE_SELECT_REGISTER = 0x07;

    60     private const byte CHIP_ID_REGISTER = 0x20;

    61     private const byte CHIP_REVISION_REGISTER = 0x21;

    62     private const byte BASE_ADDRESS_REGISTER = 0x60;

    63 

    64     private byte ReadByte(byte register) {

    65       Ring0.WriteIoPort(registerPort, register);

    66       return Ring0.ReadIoPort(valuePort);

    67     }

    68 

    69     private ushort ReadWord(byte register) {

    70       return (ushort)((ReadByte(register) << 8) |

    71         ReadByte((byte)(register + 1)));

    72     }

    73 

    74     private void Select(byte logicalDeviceNumber) {

    75       Ring0.WriteIoPort(registerPort, DEVCIE_SELECT_REGISTER);

    76       Ring0.WriteIoPort(valuePort, logicalDeviceNumber);

    77     }

    78 

    79     private void ReportUnknownChip(string type, int chip) {

    80       report.Append("Chip ID: Unknown ");

    81       report.Append(type);

    82       report.Append(" with ID 0x");

    83       report.Append(chip.ToString("X", CultureInfo.InvariantCulture));

    84       report.Append(" at 0x");

    85       report.Append(registerPort.ToString("X", CultureInfo.InvariantCulture));

    86       report.Append("/0x");

    87       report.AppendLine(valuePort.ToString("X", CultureInfo.InvariantCulture));

    88       report.AppendLine();

    89     }

    90 

    91     #region Winbond, Nuvoton, Fintek

    92 

    93     private const byte FINTEK_VENDOR_ID_REGISTER = 0x23;

    94     private const ushort FINTEK_VENDOR_ID = 0x1934;

    95 

    96     private const byte WINBOND_NUVOTON_HARDWARE_MONITOR_LDN = 0x0B;

    97 

    98     private const byte F71858_HARDWARE_MONITOR_LDN = 0x02;

    99     private const byte FINTEK_HARDWARE_MONITOR_LDN = 0x04;

   100 

   101     private void WinbondNuvotonFintekEnter() {

   102       Ring0.WriteIoPort(registerPort, 0x87);

   103       Ring0.WriteIoPort(registerPort, 0x87);

   104     }

   105 

   106     private void WinbondNuvotonFintekExit() {

   107       Ring0.WriteIoPort(registerPort, 0xAA);

   108     }

   109 

   110     private bool DetectWinbondFintek() {

   111       WinbondNuvotonFintekEnter();

   112 

   113       byte logicalDeviceNumber = 0;

   114       byte id = ReadByte(CHIP_ID_REGISTER);

   115       byte revision = ReadByte(CHIP_REVISION_REGISTER);

   116       Chip chip = Chip.Unknown;

   117       switch (id) {

   118         case 0x05:

   119           switch (revision) {

   120             case 0x07:

   121               chip = Chip.F71858;

   122               logicalDeviceNumber = F71858_HARDWARE_MONITOR_LDN;

   123               break;

   124             case 0x41:

   125               chip = Chip.F71882;

   126               logicalDeviceNumber = FINTEK_HARDWARE_MONITOR_LDN;

   127               break;

   128           } break;

   129         case 0x06:

   130           switch (revision) {

   131             case 0x01:

   132               chip = Chip.F71862;

   133               logicalDeviceNumber = FINTEK_HARDWARE_MONITOR_LDN;

   134               break;

   135           } break;

   136         case 0x07:

   137           switch (revision) {

   138             case 0x23:

   139               chip = Chip.F71889F;

   140               logicalDeviceNumber = FINTEK_HARDWARE_MONITOR_LDN;

   141               break;

   142           } break;

   143         case 0x08:

   144           switch (revision) {

   145             case 0x14:

   146               chip = Chip.F71869;

   147               logicalDeviceNumber = FINTEK_HARDWARE_MONITOR_LDN;

   148               break;

   149           } break;

   150         case 0x09:

   151           switch (revision) {

   152             case 0x09:

   153               chip = Chip.F71889ED;

   154               logicalDeviceNumber = FINTEK_HARDWARE_MONITOR_LDN;

   155               break;

   156           } break;

   157         case 0x52:

   158           switch (revision) {

   159             case 0x17:

   160             case 0x3A:

   161             case 0x41:

   162               chip = Chip.W83627HF;

   163               logicalDeviceNumber = WINBOND_NUVOTON_HARDWARE_MONITOR_LDN;

   164               break;

   165           } break;

   166         case 0x82:

   167           switch (revision & 0xF0) {

   168             case 0x80:

   169               chip = Chip.W83627THF;

   170               logicalDeviceNumber = WINBOND_NUVOTON_HARDWARE_MONITOR_LDN;

   171               break;

   172           } break;

   173         case 0x85:

   174           switch (revision) {

   175             case 0x41:

   176               chip = Chip.W83687THF;

   177               logicalDeviceNumber = WINBOND_NUVOTON_HARDWARE_MONITOR_LDN;

   178               break;

   179           } break;

   180         case 0x88:

   181           switch (revision & 0xF0) {

   182             case 0x50:

   183             case 0x60:

   184               chip = Chip.W83627EHF;

   185               logicalDeviceNumber = WINBOND_NUVOTON_HARDWARE_MONITOR_LDN;

   186               break;

   187           } break;

   188         case 0xA0:

   189           switch (revision & 0xF0) {

   190             case 0x20:

   191               chip = Chip.W83627DHG;

   192               logicalDeviceNumber = WINBOND_NUVOTON_HARDWARE_MONITOR_LDN;

   193               break;

   194           } break;

   195         case 0xA5:

   196           switch (revision & 0xF0) {

   197             case 0x10:

   198               chip = Chip.W83667HG;

   199               logicalDeviceNumber = WINBOND_NUVOTON_HARDWARE_MONITOR_LDN;

   200               break;

   201           } break;

   202         case 0xB0:

   203           switch (revision & 0xF0) {

   204             case 0x70:

   205               chip = Chip.W83627DHGP;

   206               logicalDeviceNumber = WINBOND_NUVOTON_HARDWARE_MONITOR_LDN;

   207               break;

   208           } break;

   209         case 0xB3:

   210           switch (revision & 0xF0) {

   211             case 0x50:

   212               chip = Chip.W83667HGB;

   213               logicalDeviceNumber = WINBOND_NUVOTON_HARDWARE_MONITOR_LDN;

   214               break;

   215           } break;

   216         case 0xB4:

   217           switch (revision & 0xF0) {

   218             case 0x70:

   219               chip = Chip.NCT6771F;

   220               logicalDeviceNumber = WINBOND_NUVOTON_HARDWARE_MONITOR_LDN;

   221               break;

   222           } break;

   223         case 0xC3:

   224           switch (revision & 0xF0) {

   225             case 0x30:

   226               chip = Chip.NCT6776F;

   227               logicalDeviceNumber = WINBOND_NUVOTON_HARDWARE_MONITOR_LDN;

   228               break;

   229           } break;

   230       }

   231       if (chip == Chip.Unknown) {

   232         if (id != 0 && id != 0xff) {

   233           WinbondNuvotonFintekExit();

   234 

   235           ReportUnknownChip("Winbond / Nuvoton / Fintek", 

   236             ((id << 8) | revision));

   237         }

   238       } else {

   239 

   240         Select(logicalDeviceNumber);

   241         ushort address = ReadWord(BASE_ADDRESS_REGISTER);

   242         Thread.Sleep(1);

   243         ushort verify = ReadWord(BASE_ADDRESS_REGISTER);

   244 

   245         ushort vendorID = ReadWord(FINTEK_VENDOR_ID_REGISTER);

   246 

   247         WinbondNuvotonFintekExit();

   248 

   249         if (address != verify) {

   250           report.Append("Chip ID: 0x");

   251           report.AppendLine(chip.ToString("X"));

   252           report.Append("Chip revision: 0x");

   253           report.AppendLine(revision.ToString("X",

   254             CultureInfo.InvariantCulture));

   255           report.AppendLine("Error: Address verification failed");

   256           report.AppendLine();

   257           return false;

   258         }

   259 

   260         // some Fintek chips have address register offset 0x05 added already

   261         if ((address & 0x07) == 0x05)

   262           address &= 0xFFF8;

   263 

   264         if (address < 0x100 || (address & 0xF007) != 0) {

   265           report.Append("Chip ID: 0x");

   266           report.AppendLine(chip.ToString("X"));

   267           report.Append("Chip revision: 0x");

   268           report.AppendLine(revision.ToString("X",

   269             CultureInfo.InvariantCulture));

   270           report.Append("Error: Invalid address 0x");

   271           report.AppendLine(address.ToString("X",

   272             CultureInfo.InvariantCulture));

   273           report.AppendLine();

   274           return false;

   275         }

   276 

   277         switch (chip) {

   278           case Chip.W83627DHG:

   279           case Chip.W83627DHGP:

   280           case Chip.W83627EHF:

   281           case Chip.W83627HF:

   282           case Chip.W83627THF:

   283           case Chip.W83667HG:

   284           case Chip.W83667HGB:

   285           case Chip.W83687THF:

   286             superIOs.Add(new W836XX(chip, revision, address));

   287             break;

   288           case Chip.NCT6771F:

   289           case Chip.NCT6776F:

   290             superIOs.Add(new NCT677X(chip, revision, address));

   291             break;

   292           case Chip.F71858:

   293           case Chip.F71862:

   294           case Chip.F71869:

   295           case Chip.F71882:

   296           case Chip.F71889ED:

   297           case Chip.F71889F:

   298             if (vendorID != FINTEK_VENDOR_ID) {

   299               report.Append("Chip ID: 0x");

   300               report.AppendLine(chip.ToString("X"));

   301               report.Append("Chip revision: 0x");

   302               report.AppendLine(revision.ToString("X",

   303                 CultureInfo.InvariantCulture));

   304               report.Append("Error: Invalid vendor ID 0x");

   305               report.AppendLine(vendorID.ToString("X",

   306                 CultureInfo.InvariantCulture));

   307               report.AppendLine();

   308               return false;

   309             }

   310             superIOs.Add(new F718XX(chip, address));

   311             break;

   312           default: break;

   313         }

   314 

   315         return true;

   316       }

   317 

   318       return false;

   319     }

   320 

   321     #endregion

   322 

   323     #region ITE

   324 

   325     private const byte IT87_ENVIRONMENT_CONTROLLER_LDN = 0x04;

   326     private const byte IT87_GPIO_LDN = 0x07;

   327     private const byte IT87_CHIP_VERSION_REGISTER = 0x22;

   328 

   329     private void IT87Enter() {

   330       Ring0.WriteIoPort(registerPort, 0x87);

   331       Ring0.WriteIoPort(registerPort, 0x01);

   332       Ring0.WriteIoPort(registerPort, 0x55);

   333       Ring0.WriteIoPort(registerPort, 0x55);

   334     }

   335 

   336     private void IT87Exit() {

   337       Ring0.WriteIoPort(registerPort, CONFIGURATION_CONTROL_REGISTER);

   338       Ring0.WriteIoPort(valuePort, 0x02);

   339     }

   340 

   341     private bool DetectIT87() {

   342 

   343       // IT87XX can enter only on port 0x2E

   344       if (registerPort != 0x2E)

   345         return false;

   346 

   347       IT87Enter();

   348 

   349       ushort chipID = ReadWord(CHIP_ID_REGISTER);

   350       Chip chip;

   351       switch (chipID) {

   352         case 0x8712: chip = Chip.IT8712F; break;

   353         case 0x8716: chip = Chip.IT8716F; break;

   354         case 0x8718: chip = Chip.IT8718F; break;

   355         case 0x8720: chip = Chip.IT8720F; break;

   356         case 0x8721: chip = Chip.IT8721F; break;

   357         case 0x8726: chip = Chip.IT8726F; break;

   358         case 0x8728: chip = Chip.IT8728F; break;

   359         default: chip = Chip.Unknown; break;

   360       }

   361       if (chip == Chip.Unknown) {

   362         if (chipID != 0 && chipID != 0xffff) {

   363           IT87Exit();

   364 

   365           ReportUnknownChip("ITE", chipID);

   366         }

   367       } else {

   368         Select(IT87_ENVIRONMENT_CONTROLLER_LDN);

   369         ushort address = ReadWord(BASE_ADDRESS_REGISTER);

   370         Thread.Sleep(1);

   371         ushort verify = ReadWord(BASE_ADDRESS_REGISTER);

   372 

   373         byte version = (byte)(ReadByte(IT87_CHIP_VERSION_REGISTER) & 0x0F);

   374 

   375         Select(IT87_GPIO_LDN);

   376         ushort gpioAddress = ReadWord(BASE_ADDRESS_REGISTER + 2);

   377         Thread.Sleep(1);

   378         ushort gpioVerify = ReadWord(BASE_ADDRESS_REGISTER + 2);

   379 

   380         IT87Exit();

   381 

   382         if (address != verify || address < 0x100 || (address & 0xF007) != 0) {

   383           report.Append("Chip ID: 0x");

   384           report.AppendLine(chip.ToString("X"));

   385           report.Append("Error: Invalid address 0x");

   386           report.AppendLine(address.ToString("X",

   387             CultureInfo.InvariantCulture));

   388           report.AppendLine();

   389           return false;

   390         }

   391 

   392         if (gpioAddress != gpioVerify || gpioAddress < 0x100 ||

   393           (gpioAddress & 0xF007) != 0) {

   394           report.Append("Chip ID: 0x");

   395           report.AppendLine(chip.ToString("X"));

   396           report.Append("Error: Invalid GPIO address 0x");

   397           report.AppendLine(gpioAddress.ToString("X",

   398             CultureInfo.InvariantCulture));

   399           report.AppendLine();

   400           return false;

   401         }

   402 

   403         superIOs.Add(new IT87XX(chip, address, gpioAddress, version));

   404         return true;

   405       }

   406 

   407       return false;

   408     }

   409 

   410     #endregion

   411 

   412     #region SMSC

   413 

   414     private void SMSCEnter() {

   415       Ring0.WriteIoPort(registerPort, 0x55);

   416     }

   417 

   418     private void SMSCExit() {

   419       Ring0.WriteIoPort(registerPort, 0xAA);

   420     }

   421 

   422     private bool DetectSMSC() {

   423       SMSCEnter();

   424 

   425       ushort chipID = ReadWord(CHIP_ID_REGISTER);

   426       Chip chip;

   427       switch (chipID) {

   428         default: chip = Chip.Unknown; break;

   429       }

   430       if (chip == Chip.Unknown) {

   431         if (chipID != 0 && chipID != 0xffff) {

   432           SMSCExit();

   433 

   434           ReportUnknownChip("SMSC", chipID);

   435         }

   436       } else {

   437         SMSCExit();

   438         return true;

   439       }

   440 

   441       return false;

   442     }

   443 

   444     #endregion

   445 

   446     private void Detect() {

   447 

   448       for (int i = 0; i < REGISTER_PORTS.Length; i++) {

   449         registerPort = REGISTER_PORTS[i];

   450         valuePort = VALUE_PORTS[i];

   451 

   452         if (DetectWinbondFintek()) continue;

   453 

   454         if (DetectIT87()) continue;

   455 

   456         if (DetectSMSC()) continue;

   457       }

   458     }

   459 

   460     public LPCIO() {

   461       if (!Ring0.IsOpen)

   462         return;

   463 

   464       if (!Ring0.WaitIsaBusMutex(100))

   465         return;

   466 

   467       Detect();

   468 

   469       Ring0.ReleaseIsaBusMutex();

   470     }

   471 

   472     public ISuperIO[] SuperIO {

   473       get {

   474         return superIOs.ToArray();

   475       }

   476     }

   477 

   478     public string GetReport() {

   479       if (report.Length > 0) {

   480         return "LPCIO" + Environment.NewLine + Environment.NewLine + report;

   481       } else

   482         return null;

   483     }

   484   }

   485 }
OpenHardwareMonitor