Hardware/LPC/LPCIO.cs
author moel.mich
Sun, 21 Nov 2010 17:31:25 +0000
changeset 245 f8e72b2efcc0
parent 236 763675f19ff4
child 265 961c07a3bd78
permissions -rw-r--r--
Added first experimental support for the Nuvoton NCT6771F super I/O chip.
     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-2010
    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       }
   224       if (chip == Chip.Unknown) {
   225         if (id != 0 && id != 0xff) {
   226           WinbondNuvotonFintekExit();
   227 
   228           ReportUnknownChip("Winbond / Nuvoton / Fintek", 
   229             ((id << 8) | revision));
   230         }
   231       } else {
   232 
   233         Select(logicalDeviceNumber);
   234         ushort address = ReadWord(BASE_ADDRESS_REGISTER);
   235         Thread.Sleep(1);
   236         ushort verify = ReadWord(BASE_ADDRESS_REGISTER);
   237 
   238         ushort vendorID = ReadWord(FINTEK_VENDOR_ID_REGISTER);
   239 
   240         WinbondNuvotonFintekExit();
   241 
   242         if (address != verify) {
   243           report.Append("Chip ID: 0x");
   244           report.AppendLine(chip.ToString("X"));
   245           report.Append("Chip revision: 0x");
   246           report.AppendLine(revision.ToString("X",
   247             CultureInfo.InvariantCulture));
   248           report.AppendLine("Error: Address verification failed");
   249           report.AppendLine();
   250           return false;
   251         }
   252 
   253         // some Fintek chips have address register offset 0x05 added already
   254         if ((address & 0x07) == 0x05)
   255           address &= 0xFFF8;
   256 
   257         if (address < 0x100 || (address & 0xF007) != 0) {
   258           report.Append("Chip ID: 0x");
   259           report.AppendLine(chip.ToString("X"));
   260           report.Append("Chip revision: 0x");
   261           report.AppendLine(revision.ToString("X",
   262             CultureInfo.InvariantCulture));
   263           report.Append("Error: Invalid address 0x");
   264           report.AppendLine(address.ToString("X",
   265             CultureInfo.InvariantCulture));
   266           report.AppendLine();
   267           return false;
   268         }
   269 
   270         switch (chip) {
   271           case Chip.W83627DHG:
   272           case Chip.W83627DHGP:
   273           case Chip.W83627EHF:
   274           case Chip.W83627HF:
   275           case Chip.W83627THF:
   276           case Chip.W83667HG:
   277           case Chip.W83667HGB:
   278           case Chip.W83687THF:
   279             superIOs.Add(new W836XX(chip, revision, address));
   280             break;
   281           case Chip.NCT6771F:
   282             superIOs.Add(new NCT677X(chip, revision, address));
   283             break;
   284           case Chip.F71858:
   285           case Chip.F71862:
   286           case Chip.F71869:
   287           case Chip.F71882:
   288           case Chip.F71889ED:
   289           case Chip.F71889F:
   290             if (vendorID != FINTEK_VENDOR_ID) {
   291               report.Append("Chip ID: 0x");
   292               report.AppendLine(chip.ToString("X"));
   293               report.Append("Chip revision: 0x");
   294               report.AppendLine(revision.ToString("X",
   295                 CultureInfo.InvariantCulture));
   296               report.Append("Error: Invalid vendor ID 0x");
   297               report.AppendLine(vendorID.ToString("X",
   298                 CultureInfo.InvariantCulture));
   299               report.AppendLine();
   300               return false;
   301             }
   302             superIOs.Add(new F718XX(chip, address));
   303             break;
   304           default: break;
   305         }
   306 
   307         return true;
   308       }
   309 
   310       return false;
   311     }
   312 
   313     #endregion
   314 
   315     #region ITE
   316 
   317     private const byte IT87_ENVIRONMENT_CONTROLLER_LDN = 0x04;
   318     private const byte IT87_GPIO_LDN = 0x07;
   319     private const byte IT87_CHIP_VERSION_REGISTER = 0x22;
   320 
   321     private void IT87Enter() {
   322       Ring0.WriteIoPort(registerPort, 0x87);
   323       Ring0.WriteIoPort(registerPort, 0x01);
   324       Ring0.WriteIoPort(registerPort, 0x55);
   325       Ring0.WriteIoPort(registerPort, 0x55);
   326     }
   327 
   328     private void IT87Exit() {
   329       Ring0.WriteIoPort(registerPort, CONFIGURATION_CONTROL_REGISTER);
   330       Ring0.WriteIoPort(valuePort, 0x02);
   331     }
   332 
   333     private bool DetectIT87() {
   334 
   335       // IT87XX can enter only on port 0x2E
   336       if (registerPort != 0x2E)
   337         return false;
   338 
   339       IT87Enter();
   340 
   341       ushort chipID = ReadWord(CHIP_ID_REGISTER);
   342       Chip chip;
   343       switch (chipID) {
   344         case 0x8712: chip = Chip.IT8712F; break;
   345         case 0x8716: chip = Chip.IT8716F; break;
   346         case 0x8718: chip = Chip.IT8718F; break;
   347         case 0x8720: chip = Chip.IT8720F; break;
   348         case 0x8721: chip = Chip.IT8721F; break;
   349         case 0x8726: chip = Chip.IT8726F; break;
   350         default: chip = Chip.Unknown; break;
   351       }
   352       if (chip == Chip.Unknown) {
   353         if (chipID != 0 && chipID != 0xffff) {
   354           IT87Exit();
   355 
   356           ReportUnknownChip("ITE", chipID);
   357         }
   358       } else {
   359         Select(IT87_ENVIRONMENT_CONTROLLER_LDN);
   360         ushort address = ReadWord(BASE_ADDRESS_REGISTER);
   361         Thread.Sleep(1);
   362         ushort verify = ReadWord(BASE_ADDRESS_REGISTER);
   363 
   364         byte version = (byte)(ReadByte(IT87_CHIP_VERSION_REGISTER) & 0x0F);
   365 
   366         Select(IT87_GPIO_LDN);
   367         ushort gpioAddress = ReadWord(BASE_ADDRESS_REGISTER + 2);
   368         Thread.Sleep(1);
   369         ushort gpioVerify = ReadWord(BASE_ADDRESS_REGISTER + 2);
   370 
   371         IT87Exit();
   372 
   373         if (address != verify || address < 0x100 || (address & 0xF007) != 0) {
   374           report.Append("Chip ID: 0x");
   375           report.AppendLine(chip.ToString("X"));
   376           report.Append("Error: Invalid address 0x");
   377           report.AppendLine(address.ToString("X",
   378             CultureInfo.InvariantCulture));
   379           report.AppendLine();
   380           return false;
   381         }
   382 
   383         if (gpioAddress != gpioVerify || gpioAddress < 0x100 ||
   384           (gpioAddress & 0xF007) != 0) {
   385           report.Append("Chip ID: 0x");
   386           report.AppendLine(chip.ToString("X"));
   387           report.Append("Error: Invalid GPIO address 0x");
   388           report.AppendLine(gpioAddress.ToString("X",
   389             CultureInfo.InvariantCulture));
   390           report.AppendLine();
   391           return false;
   392         }
   393 
   394         superIOs.Add(new IT87XX(chip, address, gpioAddress, version));
   395         return true;
   396       }
   397 
   398       return false;
   399     }
   400 
   401     #endregion
   402 
   403     #region SMSC
   404 
   405     private void SMSCEnter() {
   406       Ring0.WriteIoPort(registerPort, 0x55);
   407     }
   408 
   409     private void SMSCExit() {
   410       Ring0.WriteIoPort(registerPort, 0xAA);
   411     }
   412 
   413     private bool DetectSMSC() {
   414       SMSCEnter();
   415 
   416       ushort chipID = ReadWord(CHIP_ID_REGISTER);
   417       Chip chip;
   418       switch (chipID) {
   419         default: chip = Chip.Unknown; break;
   420       }
   421       if (chip == Chip.Unknown) {
   422         if (chipID != 0 && chipID != 0xffff) {
   423           SMSCExit();
   424 
   425           ReportUnknownChip("SMSC", chipID);
   426         }
   427       } else {
   428         SMSCExit();
   429         return true;
   430       }
   431 
   432       return false;
   433     }
   434 
   435     #endregion
   436 
   437     private void Detect() {
   438 
   439       for (int i = 0; i < REGISTER_PORTS.Length; i++) {
   440         registerPort = REGISTER_PORTS[i];
   441         valuePort = VALUE_PORTS[i];
   442 
   443         if (DetectWinbondFintek()) continue;
   444 
   445         if (DetectIT87()) continue;
   446 
   447         if (DetectSMSC()) continue;
   448       }
   449     }
   450 
   451     public LPCIO() {
   452       if (!Ring0.IsOpen)
   453         return;
   454 
   455       if (!Ring0.WaitIsaBusMutex(100))
   456         return;
   457 
   458       Detect();
   459 
   460       Ring0.ReleaseIsaBusMutex();
   461     }
   462 
   463     public ISuperIO[] SuperIO {
   464       get {
   465         return superIOs.ToArray();
   466       }
   467     }
   468 
   469     public string GetReport() {
   470       if (report.Length > 0) {
   471         return "LPCIO" + Environment.NewLine + Environment.NewLine + report;
   472       } else
   473         return null;
   474     }
   475   }
   476 }