OpenHardwareMonitor: Hardware/LPC/LPCIO.cs@fa2957aa0699

     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;

    39 using System.Collections.Generic;

    40 using System.Text;

    41 using System.Threading;

    43 namespace OpenHardwareMonitor.Hardware.LPC {

    44   public class LPCIO {

    46     private List<ISuperIO> superIOs = new List<ISuperIO>();

    47     private StringBuilder report = new StringBuilder();

    49     private Chip chip = Chip.Unknown;

    51     // I/O Ports

    52     private ushort[] REGISTER_PORTS = new ushort[] { 0x2e, 0x4e };

    53     private ushort[] VALUE_PORTS = new ushort[] { 0x2f, 0x4f };

    55     private ushort registerPort;

    56     private ushort valuePort;

    58     // Registers

    59     private const byte CONFIGURATION_CONTROL_REGISTER = 0x02;

    60     private const byte DEVCIE_SELECT_REGISTER = 0x07;

    61     private const byte CHIP_ID_REGISTER = 0x20;

    62     private const byte CHIP_REVISION_REGISTER = 0x21;

    63     private const byte BASE_ADDRESS_REGISTER = 0x60;

    65     private byte ReadByte(byte register) {

    66       WinRing0.WriteIoPortByte(registerPort, register);

    67       return WinRing0.ReadIoPortByte(valuePort);

    68     }

    70     private ushort ReadWord(byte register) {

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

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

    73     }

    75     private void Select(byte logicalDeviceNumber) {

    76       WinRing0.WriteIoPortByte(registerPort, DEVCIE_SELECT_REGISTER);

    77       WinRing0.WriteIoPortByte(valuePort, logicalDeviceNumber);

    78     }

    80     // ITE

    81     private const byte IT87_ENVIRONMENT_CONTROLLER_LDN = 0x04;

    83     private void IT87Enter() {

    84       WinRing0.WriteIoPortByte(registerPort, 0x87);

    85       WinRing0.WriteIoPortByte(registerPort, 0x01);

    86       WinRing0.WriteIoPortByte(registerPort, 0x55);

    87       WinRing0.WriteIoPortByte(registerPort, 0x55);

    88     }

    90     private void IT87Exit() {

    91       WinRing0.WriteIoPortByte(registerPort, CONFIGURATION_CONTROL_REGISTER);

    92       WinRing0.WriteIoPortByte(valuePort, 0x02);

    93     }

    95     // Winbond, Fintek

    96     private const byte FINTEK_VENDOR_ID_REGISTER = 0x23;

    97     private const ushort FINTEK_VENDOR_ID = 0x1934;

    99     private const byte WINBOND_HARDWARE_MONITOR_LDN = 0x0B;

   101     private const byte F71858_HARDWARE_MONITOR_LDN = 0x02;

   102     private const byte FINTEK_HARDWARE_MONITOR_LDN = 0x04;

   104     private void WinbondFintekEnter() {

   105       WinRing0.WriteIoPortByte(registerPort, 0x87);

   106       WinRing0.WriteIoPortByte(registerPort, 0x87);

   107     }

   109     private void WinbondFintekExit() {

   110       WinRing0.WriteIoPortByte(registerPort, 0xAA);

   111     }

   113     // SMSC

   114     private void SMSCEnter() {

   115       WinRing0.WriteIoPortByte(registerPort, 0x55);

   116     }

   118     private void SMSCExit() {

   119       WinRing0.WriteIoPortByte(registerPort, 0xAA);

   120     }

   122     public LPCIO() {

   123       if (!WinRing0.IsAvailable)

   124         return;

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

   127         registerPort = REGISTER_PORTS[i];

   128         valuePort = VALUE_PORTS[i];

   130         WinbondFintekEnter();

   132         byte logicalDeviceNumber;

   133         byte id = ReadByte(CHIP_ID_REGISTER);

   134         byte revision = ReadByte(CHIP_REVISION_REGISTER);

   135         chip = Chip.Unknown;

   136         logicalDeviceNumber = 0;

   137         switch (id) {

   138           case 0x05:

   139             switch (revision) {

   140               case 0x07:

   141                 chip = Chip.F71858;

   142                 logicalDeviceNumber = F71858_HARDWARE_MONITOR_LDN;

   143                 break;

   144               case 0x41:

   145                 chip = Chip.F71882;

   146                 logicalDeviceNumber = FINTEK_HARDWARE_MONITOR_LDN;

   147                 break;

   148             } break;

   149           case 0x06:

   150             switch (revision) {

   151               case 0x01:

   152                 chip = Chip.F71862;

   153                 logicalDeviceNumber = FINTEK_HARDWARE_MONITOR_LDN;

   154                 break;

   155             } break;

   156           case 0x07:

   157             switch (revision) {

   158               case 0x23:

   159                 chip = Chip.F71889F;

   160                 logicalDeviceNumber = FINTEK_HARDWARE_MONITOR_LDN;

   161                 break;

   162             } break;

   163           case 0x08:

   164             switch (revision) {

   165               case 0x14:

   166                 chip = Chip.F71869;

   167                 logicalDeviceNumber = FINTEK_HARDWARE_MONITOR_LDN;

   168                 break;

   169             } break;

   170           case 0x09:

   171             switch (revision) {

   172               case 0x09:

   173                 chip = Chip.F71889ED;

   174                 logicalDeviceNumber = FINTEK_HARDWARE_MONITOR_LDN;

   175                 break;

   176             } break;

   177           case 0x52:

   178             switch (revision) {

   179               case 0x17:

   180               case 0x3A:

   181               case 0x41:

   182                 chip = Chip.W83627HF;

   183                 logicalDeviceNumber = WINBOND_HARDWARE_MONITOR_LDN;

   184                 break;

   185             } break;

   186           case 0x82:

   187             switch (revision) {

   188               case 0x83:

   189                 chip = Chip.W83627THF;

   190                 logicalDeviceNumber = WINBOND_HARDWARE_MONITOR_LDN;

   191                 break;

   192             } break;

   193           case 0x85:

   194             switch (revision) {

   195               case 0x41:

   196                 chip = Chip.W83687THF;

   197                 logicalDeviceNumber = WINBOND_HARDWARE_MONITOR_LDN;

   198                 break;

   199             } break;

   200           case 0x88:

   201             switch (revision & 0xF0) {

   202               case 0x50:

   203               case 0x60:

   204                 chip = Chip.W83627EHF;

   205                 logicalDeviceNumber = WINBOND_HARDWARE_MONITOR_LDN;

   206                 break;

   207             } break;

   208           case 0xA0:

   209             switch (revision & 0xF0) {

   210               case 0x20:

   211                 chip = Chip.W83627DHG;

   212                 logicalDeviceNumber = WINBOND_HARDWARE_MONITOR_LDN;

   213                 break;

   214             } break;

   215           case 0xA5:

   216             switch (revision & 0xF0) {

   217               case 0x10:

   218                 chip = Chip.W83667HG;

   219                 logicalDeviceNumber = WINBOND_HARDWARE_MONITOR_LDN;

   220                 break;

   221             } break;

   222           case 0xB0:

   223             switch (revision & 0xF0) {

   224               case 0x70:

   225                 chip = Chip.W83627DHGP;

   226                 logicalDeviceNumber = WINBOND_HARDWARE_MONITOR_LDN;

   227                 break;

   228             } break;

   229           case 0xB3:

   230             switch (revision & 0xF0) {

   231               case 0x50:

   232                 chip = Chip.W83667HGB;

   233                 logicalDeviceNumber = WINBOND_HARDWARE_MONITOR_LDN;

   234                 break;

   235             } break;

   236         }

   237         if (chip == Chip.Unknown) {

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

   239             WinbondFintekExit();

   241             report.Append("Chip ID: Unknown Winbond / Fintek with ID 0x");

   242             report.AppendLine(((id << 8) | revision).ToString("X"));

   243             report.AppendLine();

   244           }

   245         } else {

   247           Select(logicalDeviceNumber);

   248           ushort address = ReadWord(BASE_ADDRESS_REGISTER);

   249           Thread.Sleep(1);

   250           ushort verify = ReadWord(BASE_ADDRESS_REGISTER);

   252           ushort vendorID = ReadWord(FINTEK_VENDOR_ID_REGISTER);

   254           WinbondFintekExit();

   256           if (address != verify) {

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

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

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

   260             report.AppendLine(revision.ToString("X"));

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

   262             report.AppendLine();

   263             return;

   264           }

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

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

   268             address &= 0xFFF8;

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

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

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

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

   274             report.AppendLine(revision.ToString("X"));

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

   276             report.AppendLine(address.ToString("X"));

   277             report.AppendLine();

   278             return;

   279           }

   281           switch (chip) {

   282             case Chip.W83627DHG:

   283             case Chip.W83627DHGP:

   284             case Chip.W83627EHF:

   285             case Chip.W83627HF:

   286             case Chip.W83627THF:

   287             case Chip.W83667HG:

   288             case Chip.W83667HGB:

   289             case Chip.W83687THF:

   290               superIOs.Add(new W836XX(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                 report.Append("Error: Invalid vendor ID 0x");

   304                 report.AppendLine(vendorID.ToString("X"));

   305                 report.AppendLine();

   306                 return;

   307               }

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

   309               break;

   310             default: break;

   311           }

   313           return;

   314         }

   316         IT87Enter();

   318         ushort chipID = ReadWord(CHIP_ID_REGISTER);

   319         switch (chipID) {

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

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

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

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

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

   325           default: chip = Chip.Unknown; break;

   326         }

   327         if (chip == Chip.Unknown) {

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

   329             IT87Exit();

   331             report.Append("Chip ID: Unknown ITE with ID 0x");

   332             report.AppendLine(chipID.ToString("X"));

   333             report.AppendLine();

   334           }

   335         } else {

   336           Select(IT87_ENVIRONMENT_CONTROLLER_LDN);

   337           ushort address = ReadWord(BASE_ADDRESS_REGISTER);

   338           Thread.Sleep(1);

   339           ushort verify = ReadWord(BASE_ADDRESS_REGISTER);

   341           IT87Exit();

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

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

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

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

   347             report.AppendLine(address.ToString("X"));

   348             report.AppendLine();

   349             return;

   350           }

   352          superIOs.Add(new IT87XX(chip, address));

   354           return;

   355         }

   357         SMSCEnter();

   359         chipID = ReadWord(CHIP_ID_REGISTER);

   360         switch (chipID) {

   361           default: chip = Chip.Unknown; break;

   362         }

   363         if (chip == Chip.Unknown) {

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

   365             SMSCExit();

   367             report.Append("Chip ID: Unknown SMSC with ID 0x");

   368             report.AppendLine(chipID.ToString("X"));

   369             report.AppendLine();

   370           }

   371         } else {

   372           SMSCExit();

   374           return;

   375         }

   376       }

   377     }

   379     public ISuperIO[] SuperIO {

   380       get {

   381         return superIOs.ToArray();

   382       }

   383     }

   385     public string GetReport() {

   386       if (report.Length > 0) {

   387         report.Insert(0, "LPCIO" + Environment.NewLine +

   388           Environment.NewLine);

   389         return report.ToString();

   390       } else

   391         return null;

   392     }

   393   }

   394 }

author	moel.mich
	Mon, 07 Jun 2010 20:03:48 +0000
changeset 136	fa2957aa0699
parent 126	2354fdb91ac4
child 145	673c2ad36db2
permissions	-rw-r--r--