Hardware/LPC/LPCGroup.cs
author moel.mich
Sat, 24 Apr 2010 20:19:55 +0000
changeset 93 99fbbbf50357
parent 92 8a5ff8bdf3ca
child 103 0845adc5402e
permissions -rw-r--r--
Added basic support for ITE IT8712F super I/O chips.
     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.Text;
    41 using System.Threading;
    42 
    43 namespace OpenHardwareMonitor.Hardware.LPC {
    44   public class LPCGroup : IGroup {
    45 
    46     private List<IHardware> hardware = new List<IHardware>();
    47     private StringBuilder report = new StringBuilder();
    48 
    49     private Chip chip = Chip.Unknown;
    50 
    51     // I/O Ports
    52     private ushort[] REGISTER_PORTS = new ushort[] { 0x2e, 0x4e };
    53     private ushort[] VALUE_PORTS = new ushort[] { 0x2f, 0x4f };
    54 
    55     private ushort registerPort;
    56     private ushort valuePort;
    57 
    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;
    64 
    65     private byte ReadByte(byte register) {
    66       WinRing0.WriteIoPortByte(registerPort, register);
    67       return WinRing0.ReadIoPortByte(valuePort);
    68     } 
    69 
    70     private ushort ReadWord(byte register) {
    71       return (ushort)((ReadByte(register) << 8) | 
    72         ReadByte((byte)(register + 1)));
    73     }
    74 
    75     private void Select(byte logicalDeviceNumber) {
    76       WinRing0.WriteIoPortByte(registerPort, DEVCIE_SELECT_REGISTER);
    77       WinRing0.WriteIoPortByte(valuePort, logicalDeviceNumber);
    78     }
    79 
    80     // ITE
    81     private const byte IT87_ENVIRONMENT_CONTROLLER_LDN = 0x04;    
    82 
    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     }
    89 
    90     internal void IT87Exit() {
    91       WinRing0.WriteIoPortByte(registerPort, CONFIGURATION_CONTROL_REGISTER);
    92       WinRing0.WriteIoPortByte(valuePort, 0x02);
    93     }
    94 
    95     // Winbond, Fintek
    96     private const byte FINTEK_VENDOR_ID_REGISTER = 0x23;
    97     private const ushort FINTEK_VENDOR_ID = 0x1934;
    98 
    99     private const byte WINBOND_HARDWARE_MONITOR_LDN = 0x0B;
   100 
   101     private const byte F71858_HARDWARE_MONITOR_LDN = 0x02;
   102     private const byte FINTEK_HARDWARE_MONITOR_LDN = 0x04;
   103 
   104     private void WinbondFintekEnter() {
   105       WinRing0.WriteIoPortByte(registerPort, 0x87);
   106       WinRing0.WriteIoPortByte(registerPort, 0x87);
   107     }
   108 
   109     private void WinbondFintekExit() {
   110       WinRing0.WriteIoPortByte(registerPort, 0xAA);      
   111     }
   112 
   113     // SMSC
   114     private void SMSCEnter() {
   115       WinRing0.WriteIoPortByte(registerPort, 0x55);
   116     }
   117 
   118     private void SMSCExit() {
   119       WinRing0.WriteIoPortByte(registerPort, 0xAA);
   120     }
   121 
   122     public LPCGroup() {
   123       if (!WinRing0.IsAvailable)
   124         return;
   125 
   126       for (int i = 0; i < REGISTER_PORTS.Length; i++) {
   127         registerPort = REGISTER_PORTS[i];
   128         valuePort = VALUE_PORTS[i];
   129 
   130         WinbondFintekEnter();
   131 
   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.F71889;
   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 0x52:
   171             switch (revision) {
   172               case 0x17:
   173               case 0x3A:
   174               case 0x41:
   175                 chip = Chip.W83627HF;
   176                 logicalDeviceNumber = WINBOND_HARDWARE_MONITOR_LDN;
   177                 break;             
   178             } break;
   179           case 0x82:
   180             switch (revision) {
   181               case 0x83:
   182                 chip = Chip.W83627THF;
   183                 logicalDeviceNumber = WINBOND_HARDWARE_MONITOR_LDN;
   184                 break;
   185             } break;
   186           case 0x85:
   187             switch (revision) {
   188               case 0x41:
   189                 chip = Chip.W83687THF;
   190                 logicalDeviceNumber = WINBOND_HARDWARE_MONITOR_LDN;
   191                 break;
   192             } break;
   193           case 0x88:
   194             switch (revision & 0xF0) {
   195               case 0x60:
   196                 chip = Chip.W83627EHF;
   197                 logicalDeviceNumber = WINBOND_HARDWARE_MONITOR_LDN;
   198                 break;
   199             } break;
   200           case 0xA0:
   201             switch (revision & 0xF0) {
   202               case 0x20: 
   203                 chip = Chip.W83627DHG;
   204                 logicalDeviceNumber = WINBOND_HARDWARE_MONITOR_LDN;  
   205                 break;             
   206             } break;
   207           case 0xA5:
   208             switch (revision & 0xF0) {
   209               case 0x10:
   210                 chip = Chip.W83667HG;
   211                 logicalDeviceNumber = WINBOND_HARDWARE_MONITOR_LDN;
   212                 break;
   213             } break;
   214           case 0xB0:
   215             switch (revision & 0xF0) {
   216               case 0x70:
   217                 chip = Chip.W83627DHGP;
   218                 logicalDeviceNumber = WINBOND_HARDWARE_MONITOR_LDN;
   219                 break;             
   220             } break;
   221           case 0xB3:
   222             switch (revision & 0xF0) {
   223               case 0x50:
   224                 chip = Chip.W83667HGB;
   225                 logicalDeviceNumber = WINBOND_HARDWARE_MONITOR_LDN;
   226                 break;
   227             } break; 
   228         }
   229         if (chip == Chip.Unknown) {
   230           if (id != 0 && id != 0xff) {
   231             WinbondFintekExit();
   232 
   233             report.Append("Chip ID: Unknown Winbond / Fintek with ID 0x"); 
   234             report.AppendLine(((id << 8) | revision).ToString("X"));
   235             report.AppendLine();
   236           }
   237         } else {
   238 
   239           Select(logicalDeviceNumber);
   240           ushort address = ReadWord(BASE_ADDRESS_REGISTER);          
   241           Thread.Sleep(1);
   242           ushort verify = ReadWord(BASE_ADDRESS_REGISTER);
   243 
   244           ushort vendorID = FINTEK_VENDOR_ID;
   245           if (chip == Chip.F71858 || chip == Chip.F71862 || 
   246             chip == Chip.F71882 || chip == Chip.F71889)
   247             vendorID = ReadWord(FINTEK_VENDOR_ID_REGISTER);
   248 
   249           WinbondFintekExit();
   250 
   251           if (address != verify) {            
   252             report.Append("Chip ID: 0x"); 
   253             report.AppendLine(chip.ToString("X"));
   254             report.Append("Chip revision: 0x"); 
   255             report.AppendLine(revision.ToString("X"));
   256             report.AppendLine("Error: Address verification failed");
   257             report.AppendLine();
   258             return;
   259           }
   260 
   261           // some Fintek chips have address register offset 0x05 added already
   262           if ((address & 0x07) == 0x05)
   263             address &= 0xFFF8;
   264 
   265           if (address < 0x100 || (address & 0xF007) != 0) {            
   266             report.Append("Chip ID: 0x");
   267             report.AppendLine(chip.ToString("X"));
   268             report.Append("Chip revision: 0x");
   269             report.AppendLine(revision.ToString("X"));
   270             report.Append("Error: Invalid address 0x");
   271             report.AppendLine(address.ToString("X"));
   272             report.AppendLine();
   273             return;
   274           }
   275 
   276           switch (chip) {
   277             case Chip.W83627DHG:
   278             case Chip.W83627DHGP:
   279             case Chip.W83627EHF:
   280             case Chip.W83627HF:
   281             case Chip.W83627THF:
   282             case Chip.W83667HG:
   283             case Chip.W83667HGB:
   284             case Chip.W83687THF:
   285               W836XX w836XX = new W836XX(chip, revision, address);
   286               if (w836XX.IsAvailable)
   287                 hardware.Add(w836XX);
   288               break;
   289             case Chip.F71858:
   290             case Chip.F71862:
   291             case Chip.F71882:
   292             case Chip.F71889: 
   293             case Chip.F71869:
   294               hardware.Add(new F718XX(chip, address));
   295               break;
   296             default: break;
   297           }
   298           
   299           return;
   300         }
   301 
   302         IT87Enter();
   303 
   304         ushort chipID = ReadWord(CHIP_ID_REGISTER);
   305         switch (chipID) {
   306           case 0x8712: chip = Chip.IT8712F; break;
   307           case 0x8716: chip = Chip.IT8716F; break;
   308           case 0x8718: chip = Chip.IT8718F; break;
   309           case 0x8720: chip = Chip.IT8720F; break;
   310           case 0x8726: chip = Chip.IT8726F; break; 
   311           default: chip = Chip.Unknown; break;
   312         }
   313         if (chip == Chip.Unknown) {
   314           if (chipID != 0 && chipID != 0xffff) {
   315             IT87Exit();
   316 
   317             report.Append("Chip ID: Unknown ITE with ID 0x");
   318             report.AppendLine(chipID.ToString("X"));
   319             report.AppendLine();
   320           }
   321         } else {
   322           Select(IT87_ENVIRONMENT_CONTROLLER_LDN);
   323           ushort address = ReadWord(BASE_ADDRESS_REGISTER);
   324           Thread.Sleep(1);
   325           ushort verify = ReadWord(BASE_ADDRESS_REGISTER);
   326 
   327           IT87Exit();
   328 
   329           if (address != verify || address < 0x100 || (address & 0xF007) != 0) {
   330             report.Append("Chip ID: 0x");
   331             report.AppendLine(chip.ToString("X"));            
   332             report.Append("Error: Invalid address 0x");
   333             report.AppendLine(address.ToString("X"));
   334             report.AppendLine();
   335             return;
   336           }
   337 
   338           IT87XX it87 = new IT87XX(chip, address);
   339           if (it87.IsAvailable)
   340             hardware.Add(it87);
   341 
   342           return;
   343         }
   344 
   345         SMSCEnter();
   346 
   347         chipID = ReadWord(CHIP_ID_REGISTER);
   348         switch (chipID) {
   349           default: chip = Chip.Unknown; break;
   350         }
   351         if (chip == Chip.Unknown) {
   352           if (chipID != 0 && chipID != 0xffff) {
   353             SMSCExit();
   354 
   355             report.Append("Chip ID: Unknown SMSC with ID 0x");
   356             report.AppendLine(chipID.ToString("X"));
   357             report.AppendLine();
   358           }
   359         } else {
   360           SMSCExit();
   361 
   362           return;
   363         }
   364       }   
   365     }
   366 
   367     public IHardware[] Hardware {
   368       get {
   369         return hardware.ToArray();
   370       }
   371     }
   372 
   373     public string GetReport() {
   374       if (report.Length > 0) {
   375         report.Insert(0, "LPCIO" + Environment.NewLine +
   376           Environment.NewLine);        
   377         return report.ToString();
   378       } else
   379         return null;
   380     }
   381 
   382     public void Close() { }
   383   }
   384 }