<h2>Edit File - sensors-detect</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/usr/sbin/sensors-detect">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">#!/usr/bin/perl -w
#
#    sensors-detect - Detect hardware monitoring chips
#    Copyright (C) 1998 - 2002  Frodo Looijaard &lt;frodol@dds.nl&gt;
#    Copyright (C) 2004 - 2015  Jean Delvare &lt;jdelvare@suse.de&gt;
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
#    MA 02110-1301 USA.
#

require 5.004;

use strict;
use Fcntl qw(:DEFAULT :seek);
use File::Basename;

# We will call modprobe, which typically lives in either /sbin,
# /usr/sbin or /usr/local/bin. So make sure these are all in the PATH.
foreach (&#039;/usr/sbin&#039;, &#039;/usr/local/sbin&#039;, &#039;/sbin&#039;) {
	$ENV{PATH} = &quot;$_:&quot;.$ENV{PATH}
		unless $ENV{PATH} =~ m/(^|:)$_\/?(:|$)/;
}

#########################
# CONSTANT DECLARATIONS #
#########################

use constant NO_CACHE =&gt; 1;
use constant LM_VERSION =&gt; &#039;3.4.0+git&#039;;
use vars qw(@pci_adapters @chip_ids @ipmi_ifs @non_hwmon_chip_ids
	    $i2c_addresses_to_scan @i2c_byte_cache %opt);

# This is the list of SMBus or I2C adapters we recognize by their PCI
# signature. This is an easy and fast way to determine which SMBus or I2C
# adapters should be present.
# Each entry must have a vendid (Vendor ID), devid (Device ID) and
# procid (Device name) and driver (Device driver).
@pci_adapters = (
	{
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x7113,
		procid	=&gt; &quot;Intel 82371AB PIIX4 ACPI&quot;,
		driver	=&gt; &quot;i2c-piix4&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x7603,
		procid	=&gt; &quot;Intel 82372FB PIIX5 ACPI&quot;,
		driver	=&gt; &quot;to-be-written&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x719b,
		procid	=&gt; &quot;Intel 82443MX Mobile&quot;,
		driver	=&gt; &quot;i2c-piix4&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x2413,
		procid	=&gt; &quot;Intel 82801AA ICH&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x2423,
		procid	=&gt; &quot;Intel 82801AB ICH0&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x2443,
		procid	=&gt; &quot;Intel 82801BA ICH2&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x2483,
		procid	=&gt; &quot;Intel 82801CA/CAM ICH3&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x24C3,
		procid	=&gt; &quot;Intel 82801DB ICH4&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x24D3,
		procid	=&gt; &quot;Intel 82801EB ICH5&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x25A4,
		procid	=&gt; &quot;Intel 6300ESB&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x269B,
		procid	=&gt; &quot;Intel Enterprise Southbridge - ESB2&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x266A,
		procid	=&gt; &quot;Intel 82801FB ICH6&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x27DA,
		procid	=&gt; &quot;Intel 82801G ICH7&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x283E,
		procid	=&gt; &quot;Intel 82801H ICH8&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x2930,
		procid	=&gt; &quot;Intel ICH9&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x5032,
		procid	=&gt; &quot;Intel Tolapai&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x3A30,
		procid	=&gt; &quot;Intel ICH10&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x3A60,
		procid	=&gt; &quot;Intel ICH10&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x3B30,
		procid	=&gt; &quot;Intel 3400/5 Series (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x1C22,
		procid	=&gt; &quot;Intel Cougar Point (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x1D22,
		procid	=&gt; &quot;Intel Patsburg (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x1D70,
		procid	=&gt; &quot;Intel Patsburg (PCH) IDF&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x1D71,
		procid	=&gt; &quot;Intel Patsburg (PCH) IDF&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x1D72,
		procid	=&gt; &quot;Intel Patsburg (PCH) IDF&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x2330,
		procid	=&gt; &quot;Intel DH89xxCC (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x1E22,
		procid	=&gt; &quot;Intel Panther Point (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x8C22,
		procid	=&gt; &quot;Intel Lynx Point (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x9C22,
		procid	=&gt; &quot;Intel Lynx Point-LP (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x1F3C,
		procid	=&gt; &quot;Avoton (SOC)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x8D22,
		procid	=&gt; &quot;Wellsburg (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x8D7D,
		procid	=&gt; &quot;Wellsburg (PCH) MS&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x8D7E,
		procid	=&gt; &quot;Wellsburg (PCH) MS&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x8D7F,
		procid	=&gt; &quot;Wellsburg (PCH) MS&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x23B0,
		procid	=&gt; &quot;Coleto Creek (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x8CA2,
		procid	=&gt; &quot;Wildcat Point (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x9CA2,
		procid	=&gt; &quot;Wildcat Point-LP (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x0F12,
		procid	=&gt; &quot;BayTrail (SOC)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0xA123,
		procid	=&gt; &quot;Sunrise Point-H (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x9D23,
		procid	=&gt; &quot;Sunrise Point-LP (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x19DF,
		procid	=&gt; &quot;DNV (SOC)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x5AD4,
		procid	=&gt; &quot;Broxton (SOC)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0xA1A3,
		procid	=&gt; &quot;Lewisburg (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0xA223,
		procid	=&gt; &quot;Lewisburg Supersku (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0xA2A3,
		procid	=&gt; &quot;Kaby Lake (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x31D4,
		procid	=&gt; &quot;Gemini Lake (SOC)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0xA323,
		procid	=&gt; &quot;Cannon Lake-H (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x9DA3,
		procid	=&gt; &quot;Cannon Lake-LP (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x18DF,
		procid	=&gt; &quot;Cedar Fork (PCH)&quot;,
		driver	=&gt; &quot;i2c-i801&quot;,
	}, {
		vendid	=&gt; 0x8086,
		devid	=&gt; 0x8119,
		procid	=&gt; &quot;Intel SCH&quot;,
		driver	=&gt; &quot;i2c-isch&quot;,
	}, {
		vendid	=&gt; 0x1106,
		devid	=&gt; 0x3040,
		procid	=&gt; &quot;VIA Technologies VT82C586B Apollo ACPI&quot;,
		driver	=&gt; &quot;i2c-via&quot;,
	}, {
		vendid	=&gt; 0x1106,
		devid	=&gt; 0x3050,
		procid	=&gt; &quot;VIA Technologies VT82C596 Apollo ACPI&quot;,
		driver	=&gt; &quot;i2c-viapro&quot;,
	}, {
		vendid	=&gt; 0x1106,
		devid	=&gt; 0x3051,
		procid	=&gt; &quot;VIA Technologies VT82C596B ACPI&quot;,
		driver	=&gt; &quot;i2c-viapro&quot;,
	}, {
		vendid	=&gt; 0x1106,
		devid	=&gt; 0x3057,
		procid	=&gt; &quot;VIA Technologies VT82C686 Apollo ACPI&quot;,
		driver	=&gt; &quot;i2c-viapro&quot;,
	}, {
		vendid	=&gt; 0x1106,
		devid	=&gt; 0x3074,
		procid	=&gt; &quot;VIA Technologies VT8233 VLink South Bridge&quot;,
		driver	=&gt; &quot;i2c-viapro&quot;,
	}, {
		vendid	=&gt; 0x1106,
		devid	=&gt; 0x3147,
		procid	=&gt; &quot;VIA Technologies VT8233A South Bridge&quot;,
		driver	=&gt; &quot;i2c-viapro&quot;,
	}, {
		vendid	=&gt; 0x1106,
		devid	=&gt; 0x3177,
		procid	=&gt; &quot;VIA Technologies VT8233A/8235 South Bridge&quot;,
		driver	=&gt; &quot;i2c-viapro&quot;,
	}, {
		vendid	=&gt; 0x1106,
		devid	=&gt; 0x3227,
		procid	=&gt; &quot;VIA Technologies VT8237 South Bridge&quot;,
		driver	=&gt; &quot;i2c-viapro&quot;,
	}, {
		vendid	=&gt; 0x1106,
		devid	=&gt; 0x3337,
		procid	=&gt; &quot;VIA Technologies VT8237A South Bridge&quot;,
		driver	=&gt; &quot;i2c-viapro&quot;,
	}, {
		vendid	=&gt; 0x1106,
		devid	=&gt; 0x8235,
		procid	=&gt; &quot;VIA Technologies VT8231 South Bridge&quot;,
		driver	=&gt; &quot;i2c-viapro&quot;,
	}, {
		vendid	=&gt; 0x1106,
		devid	=&gt; 0x3287,
		procid	=&gt; &quot;VIA Technologies VT8251 South Bridge&quot;,
		driver	=&gt; &quot;i2c-viapro&quot;,
	}, {
		vendid	=&gt; 0x1106,
		devid	=&gt; 0x8324,
		procid	=&gt; &quot;VIA Technologies CX700 South Bridge&quot;,
		driver	=&gt; &quot;i2c-viapro&quot;,
	}, {
		vendid	=&gt; 0x1106,
		devid	=&gt; 0x8353,
		procid	=&gt; &quot;VIA Technologies VX800/VX820 South Bridge&quot;,
		driver	=&gt; &quot;i2c-viapro&quot;,
	}, {
		vendid	=&gt; 0x1039,
		devid	=&gt; 0x0008,
		procid	=&gt; &quot;Silicon Integrated Systems SIS5595&quot;,
		driver	=&gt; &quot;i2c-sis5595&quot;,
	}, {
		vendid	=&gt; 0x1039,
		devid	=&gt; 0x0630,
		procid	=&gt; &quot;Silicon Integrated Systems SIS630&quot;,
		driver	=&gt; &quot;i2c-sis630&quot;,
	}, {
		vendid	=&gt; 0x1039,
		devid	=&gt; 0x0730,
		procid	=&gt; &quot;Silicon Integrated Systems SIS730&quot;,
		driver	=&gt; &quot;i2c-sis630&quot;,
	}, {
		vendid	=&gt; 0x1039,
		devid	=&gt; 0x0016,
		procid	=&gt; &quot;Silicon Integrated Systems SMBus Controller&quot;,
		driver	=&gt; &quot;i2c-sis96x&quot;,
	}, {
		# Both Ali chips below have same PCI ID. Can&#039;t be helped. Only one should load.
		vendid	=&gt; 0x10b9,
		devid	=&gt; 0x7101,
		procid	=&gt; &quot;Acer Labs 1533/1543&quot;,
		driver	=&gt; &quot;i2c-ali15x3&quot;,
	}, {
		vendid	=&gt; 0x10b9,
		devid	=&gt; 0x7101,
		procid	=&gt; &quot;Acer Labs 1535&quot;,
		driver	=&gt; &quot;i2c-ali1535&quot;,
	}, {
		vendid	=&gt; 0x10b9,
		devid	=&gt; 0x1563,
		procid	=&gt; &quot;Acer Labs 1563&quot;,
		driver	=&gt; &quot;i2c-ali1563&quot;,
	}, {
		vendid	=&gt; 0x1022,
		devid	=&gt; 0x740b,
		procid	=&gt; &quot;AMD-756 Athlon ACPI&quot;,
		driver	=&gt; &quot;i2c-amd756&quot;,
	}, {
		vendid	=&gt; 0x1022,
		devid	=&gt; 0x7413,
		procid	=&gt; &quot;AMD-766 Athlon ACPI&quot;,
		driver	=&gt; &quot;i2c-amd756&quot;,
	}, {
		vendid	=&gt; 0x1022,
		devid	=&gt; 0x7443,
		procid	=&gt; &quot;AMD-768 System Management&quot;,
		driver	=&gt; &quot;i2c-amd756&quot;,
	}, {
		vendid	=&gt; 0x1022,
		devid	=&gt; 0x746b,
		procid	=&gt; &quot;AMD-8111 ACPI&quot;,
		driver	=&gt; &quot;i2c-amd756&quot;,
	}, {
		vendid	=&gt; 0x1022,
		devid	=&gt; 0x746a,
		procid	=&gt; &quot;AMD-8111 SMBus 2.0&quot;,
		driver	=&gt; &quot;i2c-amd8111&quot;,
	}, {
		vendid	=&gt; 0x10de,
		devid	=&gt; 0x01b4,
		procid	=&gt; &quot;nVidia nForce SMBus&quot;,
		driver	=&gt; &quot;i2c-amd756&quot;,
	}, {
		vendid	=&gt; 0x10de,
		devid	=&gt; 0x0064,
		procid	=&gt; &quot;nVidia Corporation nForce2 SMBus (MCP)&quot;,
		driver	=&gt; &quot;i2c-nforce2&quot;,
	}, {
		vendid	=&gt; 0x10de,
		devid	=&gt; 0x0084,
		procid	=&gt; &quot;nVidia Corporation nForce2 Ultra 400 SMBus (MCP)&quot;,
		driver	=&gt; &quot;i2c-nforce2&quot;,
	}, {
		vendid	=&gt; 0x10de,
		devid	=&gt; 0x00D4,
		procid	=&gt; &quot;nVidia Corporation nForce3 Pro150 SMBus (MCP)&quot;,
		driver	=&gt; &quot;i2c-nforce2&quot;,
	}, {
		vendid	=&gt; 0x10de,
		devid	=&gt; 0x00E4,
		procid	=&gt; &quot;nVidia Corporation nForce3 250Gb SMBus (MCP)&quot;,
		driver	=&gt; &quot;i2c-nforce2&quot;,
	}, {
		vendid	=&gt; 0x10de,
		devid	=&gt; 0x0052,
		procid	=&gt; &quot;nVidia Corporation nForce4 SMBus (MCP)&quot;,
		driver	=&gt; &quot;i2c-nforce2&quot;,
	}, {
		vendid	=&gt; 0x10de,
		devid	=&gt; 0x0034,
		procid	=&gt; &quot;nVidia Corporation nForce4 SMBus (MCP-04)&quot;,
		driver	=&gt; &quot;i2c-nforce2&quot;,
	}, {
		vendid	=&gt; 0x10de,
		devid	=&gt; 0x0264,
		procid	=&gt; &quot;nVidia Corporation nForce SMBus (MCP51)&quot;,
		driver	=&gt; &quot;i2c-nforce2&quot;,
	}, {
		vendid	=&gt; 0x10de,
		devid	=&gt; 0x0368,
		procid	=&gt; &quot;nVidia Corporation nForce SMBus (MCP55)&quot;,
		driver	=&gt; &quot;i2c-nforce2&quot;,
	}, {
		vendid	=&gt; 0x10de,
		devid	=&gt; 0x03eb,
		procid	=&gt; &quot;nVidia Corporation nForce SMBus (MCP61)&quot;,
		driver	=&gt; &quot;i2c-nforce2&quot;,
	}, {
		vendid	=&gt; 0x10de,
		devid	=&gt; 0x0446,
		procid	=&gt; &quot;nVidia Corporation nForce SMBus (MCP65)&quot;,
		driver	=&gt; &quot;i2c-nforce2&quot;,
	}, {
		vendid	=&gt; 0x10de,
		devid	=&gt; 0x0542,
		procid	=&gt; &quot;nVidia Corporation nForce SMBus (MCP67)&quot;,
		driver	=&gt; &quot;i2c-nforce2&quot;,
	}, {
		vendid	=&gt; 0x10de,
		devid	=&gt; 0x07d8,
		procid	=&gt; &quot;nVidia Corporation nForce SMBus (MCP73)&quot;,
		driver	=&gt; &quot;i2c-nforce2&quot;,
	}, {
		vendid	=&gt; 0x10de,
		devid	=&gt; 0x0752,
		procid	=&gt; &quot;nVidia Corporation nForce SMBus (MCP78S)&quot;,
		driver	=&gt; &quot;i2c-nforce2&quot;,
	}, {
		vendid	=&gt; 0x10de,
		devid	=&gt; 0x0aa2,
		procid	=&gt; &quot;nVidia Corporation nForce SMBus (MCP79)&quot;,
		driver	=&gt; &quot;i2c-nforce2&quot;,
	}, {
		vendid	=&gt; 0x1166,
		devid	=&gt; 0x0200,
		procid	=&gt; &quot;ServerWorks OSB4 South Bridge&quot;,
		driver	=&gt; &quot;i2c-piix4&quot;,
	}, {
		vendid	=&gt; 0x1055,
		devid	=&gt; 0x9463,
		procid	=&gt; &quot;SMSC Victory66 South Bridge&quot;,
		driver	=&gt; &quot;i2c-piix4&quot;,
	}, {
		vendid	=&gt; 0x1166,
		devid	=&gt; 0x0201,
		procid	=&gt; &quot;ServerWorks CSB5 South Bridge&quot;,
		driver	=&gt; &quot;i2c-piix4&quot;,
	}, {
		vendid	=&gt; 0x1166,
		devid	=&gt; 0x0203,
		procid	=&gt; &quot;ServerWorks CSB6 South Bridge&quot;,
		driver	=&gt; &quot;i2c-piix4&quot;,
	}, {
		vendid	=&gt; 0x1166,
		devid	=&gt; 0x0205,
		procid	=&gt; &quot;ServerWorks HT-1000 South Bridge&quot;,
		driver	=&gt; &quot;i2c-piix4&quot;,
	}, {
		vendid	=&gt; 0x1002,
		devid	=&gt; 0x4353,
		procid	=&gt; &quot;ATI Technologies Inc ATI SMBus&quot;,
		driver	=&gt; &quot;i2c-piix4&quot;,
	}, {
		vendid	=&gt; 0x1002,
		devid	=&gt; 0x4363,
		procid	=&gt; &quot;ATI Technologies Inc ATI SMBus&quot;,
		driver	=&gt; &quot;i2c-piix4&quot;,
	}, {
		vendid	=&gt; 0x1002,
		devid	=&gt; 0x4372,
		procid	=&gt; &quot;ATI Technologies Inc IXP SB400 SMBus Controller&quot;,
		driver	=&gt; &quot;i2c-piix4&quot;,
	}, {
		vendid	=&gt; 0x1002,
		devid	=&gt; 0x4385,
		procid	=&gt; &quot;ATI Technologies Inc SB600/SB700/SB800 SMBus&quot;,
		driver	=&gt; &quot;i2c-piix4&quot;,
	}, {
		vendid	=&gt; 0x1022,
		devid	=&gt; 0x780b,
		procid	=&gt; &quot;AMD Hudson-2 SMBus&quot;,
		driver	=&gt; &quot;i2c-piix4&quot;,
	}, {
		vendid	=&gt; 0x1022,
		devid	=&gt; 0x790b,
		procid	=&gt; &quot;AMD KERNCZ SMBus&quot;,
		driver	=&gt; &quot;i2c-piix4&quot;,
	}, {
		vendid	=&gt; 0x100B,
		devid	=&gt; 0x0500,
		procid	=&gt; &quot;SCx200 Bridge&quot;,
		driver	=&gt; &quot;scx200_acb&quot;,
	}, {
		vendid	=&gt; 0x100B,
		devid	=&gt; 0x0510,
		procid	=&gt; &quot;SC1100 Bridge&quot;,
		driver	=&gt; &quot;scx200_acb&quot;,
	}, {
		vendid	=&gt; 0x100B,
		devid	=&gt; 0x002B,
		procid	=&gt; &quot;CS5535 ISA bridge&quot;,
		driver	=&gt; &quot;scx200_acb&quot;,
	}, {
		vendid	=&gt; 0x1022,
		devid	=&gt; 0x2090,
		procid	=&gt; &quot;CS5536 [Geode companion] ISA&quot;,
		driver	=&gt; &quot;scx200_acb&quot;,
	}
);

# Look-up table to find out an I2C bus&#039; driver based on the bus name.
# The match field should contain a regular expression matching the I2C
# bus name as it would appear in sysfs.
# Note that new drivers probably don&#039;t need to be added to this table
# if they bind to their device, as we will be able to get the driver name
# from sysfs directly.
use vars qw(@i2c_adapter_names);
@i2c_adapter_names = (
	{ driver =&gt; &quot;i2c-piix4&quot;,	match =&gt; qr/^SMBus PIIX4 adapter at / },
	{ driver =&gt; &quot;i2c-i801&quot;,		match =&gt; qr/^SMBus I801 adapter at / },
	{ driver =&gt; &quot;i2c-via&quot;,		match =&gt; qr/^VIA i2c/ },
	{ driver =&gt; &quot;i2c-viapro&quot;,	match =&gt; qr/^SMBus V(IA|ia) Pro adapter at / },
	{ driver =&gt; &quot;i2c-sis5595&quot;,	match =&gt; qr/^SMBus SIS5595 adapter at / },
	{ driver =&gt; &quot;i2c-sis630&quot;,	match =&gt; qr/^SMBus SIS630 adapter at / },
	{ driver =&gt; &quot;i2c-sis96x&quot;,	match =&gt; qr/^SiS96x SMBus adapter at / },
	{ driver =&gt; &quot;i2c-ali15x3&quot;,	match =&gt; qr/^SMBus ALI15X3 adapter at / },
	{ driver =&gt; &quot;i2c-ali1535&quot;,	match =&gt; qr/^SMBus ALI1535 adapter at/ },
	{ driver =&gt; &quot;i2c-ali1563&quot;,	match =&gt; qr/^SMBus ALi 1563 Adapter @ / },
	{ driver =&gt; &quot;i2c-amd756&quot;,	match =&gt; qr/^SMBus (AMD756|AMD766|AMD768|AMD8111|nVidia nForce) adapter at / },
	{ driver =&gt; &quot;i2c-amd8111&quot;,	match =&gt; qr/^SMBus2 AMD8111 adapter at / },
	{ driver =&gt; &quot;i2c-nforce2&quot;,	match =&gt; qr/^SMBus nForce2 adapter at / },
	{ driver =&gt; &quot;scx200_acb&quot;,	match =&gt; qr/^(NatSemi SCx200 ACCESS\.bus|SCx200 ACB\d+|CS553[56] ACB\d+)/ },
);

# This is a list of all recognized I2C and ISA chips.
# Each entry must have the following fields:
#  name: The full chip name
#  driver: The driver name. Put in exactly:
#      * &quot;to-be-written&quot; if it is not yet available
#      * &quot;use-isa-instead&quot; if no i2c driver will be written
#  i2c_addrs (optional): For I2C chips, the list of I2C addresses to
#      probe.
#  i2c_detect (optional): For I2C chips, the function to call to detect
#      this chip. The function will be passed two parameters: an open file
#      descriptor to access the bus, and the I2C address to probe.
#  isa_addrs (optional): For ISA chips, the list of port addresses to
#      probe.
#  isa_detect (optional): For ISA chips, the function to call to detect
#      this chip. The function will be passed one parameter: the ISA address
#      to probe.
#  alias_detect (optional): For chips which can be both on the ISA and the
#      I2C bus, a function which detects whether two entries are the same.
#      The function will be passed three parameters: the ISA address, an
#      open file descriptor to access the I2C bus, and the I2C address.
@chip_ids = (
	{
		name =&gt; &quot;Myson MTP008&quot;,
		driver =&gt; &quot;mtp008&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { mtp008_detect(@_); },
	}, {
		name =&gt; &quot;National Semiconductor LM78&quot;,
		driver =&gt; &quot;lm78&quot;,
		i2c_addrs =&gt; [0x28..0x2f],
		i2c_detect =&gt; sub { lm78_detect(@_, 0); },
		isa_addrs =&gt; [0x290],
		isa_detect =&gt; sub { lm78_isa_detect(@_, 0); },
		alias_detect =&gt; sub { winbond_alias_detect(@_, 0x2b, 0x3d); },
	}, {
		name =&gt; &quot;National Semiconductor LM79&quot;,
		driver =&gt; &quot;lm78&quot;,
		i2c_addrs =&gt; [0x28..0x2f],
		i2c_detect =&gt; sub { lm78_detect(@_, 2); },
		isa_addrs =&gt; [0x290],
		isa_detect =&gt; sub { lm78_isa_detect(@_, 2); },
		alias_detect =&gt; sub { winbond_alias_detect(@_, 0x2b, 0x3d); },
	}, {
		name =&gt; &quot;National Semiconductor LM75&quot;,
		driver =&gt; &quot;lm75&quot;,
		i2c_addrs =&gt; [0x48..0x4f],
		i2c_detect =&gt; sub { lm75_detect(@_, 0); },
	}, {
		name =&gt; &quot;National Semiconductor LM75A&quot;,
		driver =&gt; &quot;lm75&quot;,
		i2c_addrs =&gt; [0x48..0x4f],
		i2c_detect =&gt; sub { lm75_detect(@_, 2); },
	}, {
		name =&gt; &quot;Dallas Semiconductor DS75&quot;,
		driver =&gt; &quot;lm75&quot;,
		i2c_addrs =&gt; [0x48..0x4f],
		i2c_detect =&gt; sub { lm75_detect(@_, 1); },
	}, {
		name =&gt; &quot;National Semiconductor LM77&quot;,
		driver =&gt; &quot;lm77&quot;,
		i2c_addrs =&gt; [0x48..0x4b],
		i2c_detect =&gt; sub { lm77_detect(@_); },
	}, {
		name =&gt; &quot;National Semiconductor LM80&quot;,
		driver =&gt; &quot;lm80&quot;,
		i2c_addrs =&gt; [0x28..0x2f],
		i2c_detect =&gt; sub { lm80_detect(@_, 0); },
	}, {
		name =&gt; &quot;National Semiconductor LM96080&quot;,
		driver =&gt; &quot;lm80&quot;,
		i2c_addrs =&gt; [0x28..0x2f],
		i2c_detect =&gt; sub { lm80_detect(@_, 1); },
	}, {
		name =&gt; &quot;TI / National Semiconductor ADC128D818&quot;,
		driver =&gt; &quot;adc128d818&quot;,
		i2c_addrs =&gt; [0x1d, 0x1e, 0x1f, 0x2d, 0x2e, 0x2f],
		i2c_detect =&gt; sub { adc128d818_detect(@_); },
	}, {
		name =&gt; &quot;National Semiconductor LM85&quot;,
		driver =&gt; &quot;lm85&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { lm85_detect(@_, 0); },
	}, {
		name =&gt; &quot;National Semiconductor LM96000 or PC8374L&quot;,
		driver =&gt; &quot;lm85&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { lm85_detect(@_, 1); },
	}, {
		name =&gt; &quot;Analog Devices ADM1027&quot;,
		driver =&gt; &quot;lm85&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { lm85_detect(@_, 2); },
	}, {
		name =&gt; &quot;Analog Devices ADT7460 or ADT7463&quot;,
		driver =&gt; &quot;lm85&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { lm85_detect(@_, 3); },
	}, {
		name =&gt; &quot;SMSC EMC6D100 or EMC6D101&quot;,
		driver =&gt; &quot;lm85&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { lm85_detect(@_, 4); },
	}, {
		name =&gt; &quot;SMSC EMC6D102&quot;,
		driver =&gt; &quot;lm85&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { lm85_detect(@_, 5); },
	}, {
		name =&gt; &quot;SMSC EMC6D103&quot;,
		driver =&gt; &quot;lm85&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { lm85_detect(@_, 6); },
	}, {
		name =&gt; &quot;SMSC EMC6D103S or EMC2300&quot;,
		driver =&gt; &quot;lm85&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { lm85_detect(@_, 8); },
	}, {
		name =&gt; &quot;SMSC EMC6W201&quot;,
		driver =&gt; &quot;emc6w201&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { emc6w201_detect(@_); },
	}, {
		name =&gt; &quot;Winbond WPCD377I&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { lm85_detect(@_, 7); },
	}, {
		name =&gt; &quot;Analog Devices ADT7462&quot;,
		driver =&gt; &quot;adt7462&quot;,
		i2c_addrs =&gt; [0x5c, 0x58],
		i2c_detect =&gt; sub { adt7467_detect(@_, 2); },
	}, {
		name =&gt; &quot;Analog Devices ADT7466&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x4c],
		i2c_detect =&gt; sub { adt7467_detect(@_, 3); },
	}, {
		name =&gt; &quot;Analog Devices ADT7467 or ADT7468&quot;,
		driver =&gt; &quot;lm85&quot;,
		i2c_addrs =&gt; [0x2e],
		i2c_detect =&gt; sub { adt7467_detect(@_, 0); },
	}, {
		name =&gt; &quot;Analog Devices ADT7470&quot;,
		driver =&gt; &quot;adt7470&quot;,
		i2c_addrs =&gt; [0x2c, 0x2e, 0x2f],
		i2c_detect =&gt; sub { adt7467_detect(@_, 4); },
	}, {
		name =&gt; &quot;Analog Devices ADT7473&quot;,
		driver =&gt; sub { kernel_version_at_least(2, 6, 33) ? &quot;adt7475&quot; : &quot;adt7473&quot; },
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { adt7473_detect(@_, 0); },
	}, {
		name =&gt; &quot;Analog Devices ADT7475&quot;,
		driver =&gt; &quot;adt7475&quot;,
		i2c_addrs =&gt; [0x2e],
		i2c_detect =&gt; sub { adt7473_detect(@_, 1); },
	}, {
		name =&gt; &quot;Analog Devices ADT7476&quot;,
		driver =&gt; &quot;adt7475&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { adt7467_detect(@_, 1); },
	}, {
		name =&gt; &quot;Analog Devices ADT7490&quot;,
		driver =&gt; &quot;adt7475&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { adt7490_detect(@_); },
	}, {
		name =&gt; &quot;Analog Devices ADT7410/ADT7420&quot;,
		driver =&gt; &quot;adt7410&quot;,
		i2c_addrs =&gt; [0x48..0x4b],
		i2c_detect =&gt; sub { adt7410_detect(@_); },
	}, {
		name =&gt; &quot;Analog Devices ADT7411&quot;,
		driver =&gt; &quot;adt7411&quot;,
		i2c_addrs =&gt; [0x48, 0x4a, 0x4b],
		i2c_detect =&gt; sub { adt7411_detect(@_); },
	}, {
		name =&gt; &quot;Andigilog aSC7511&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x4c],
		i2c_detect =&gt; sub { andigilog_aSC7511_detect(@_); },
	}, {
		name =&gt; &quot;Andigilog aSC7512&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x58],
		i2c_detect =&gt; sub { andigilog_detect(@_, 0); },
	}, {
		name =&gt; &quot;Andigilog aSC7611&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { andigilog_detect(@_, 1); },
	}, {
		name =&gt; &quot;Andigilog aSC7621&quot;,
		driver =&gt; &quot;asc7621&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { andigilog_detect(@_, 2); },
	}, {
		name =&gt; &quot;National Semiconductor LM87&quot;,
		driver =&gt; &quot;lm87&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { lm87_detect(@_, 0); },
	}, {
		name =&gt; &quot;Analog Devices ADM1024&quot;,
		driver =&gt; &quot;lm87&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { lm87_detect(@_, 1); },
	}, {
		name =&gt; &quot;National Semiconductor LM93&quot;,
		driver =&gt; &quot;lm93&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { lm93_detect(@_, 0); },
	}, {
		name =&gt; &quot;National Semiconductor LM94 or LM96194&quot;,
		driver =&gt; &quot;lm93&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { lm93_detect(@_, 1); },
	}, {
		name =&gt; &quot;Winbond W83781D&quot;,
		driver =&gt; &quot;w83781d&quot;,
		i2c_addrs =&gt; [0x28..0x2f],
		i2c_detect =&gt; sub { w83781d_detect(@_, 0); },
		isa_addrs =&gt; [0x290],
		isa_detect =&gt; sub { w83781d_isa_detect(@_, 0); },
		alias_detect =&gt; sub { winbond_alias_detect(@_, 0x2b, 0x3d); },
	}, {
		name =&gt; &quot;Winbond W83782D&quot;,
		driver =&gt; &quot;w83781d&quot;,
		i2c_addrs =&gt; [0x28..0x2f],
		i2c_detect =&gt; sub { w83781d_detect(@_, 1); },
		isa_addrs =&gt; [0x290],
		isa_detect =&gt; sub { w83781d_isa_detect(@_, 1); },
		alias_detect =&gt; sub { winbond_alias_detect(@_, 0x2b, 0x3d); },
	}, {
		name =&gt; &quot;Winbond W83783S&quot;,
		driver =&gt; &quot;w83781d&quot;,
		i2c_addrs =&gt; [0x2d],
		i2c_detect =&gt; sub { w83781d_detect(@_, 2); },
	}, {
		name =&gt; &quot;Winbond W83791D&quot;,
		driver =&gt; &quot;w83791d&quot;,
		i2c_addrs =&gt; [0x2c..0x2f],
		i2c_detect =&gt; sub { w83781d_detect(@_, 7); },
	}, {
		name =&gt; &quot;Winbond W83792D&quot;,
		driver =&gt; &quot;w83792d&quot;,
		i2c_addrs =&gt; [0x2c..0x2f],
		i2c_detect =&gt; sub { w83781d_detect(@_, 8); },
	}, {
		name =&gt; &quot;Winbond W83793R/G&quot;,
		driver =&gt; &quot;w83793&quot;,
		i2c_addrs =&gt; [0x2c..0x2f],
		i2c_detect =&gt; sub { w83793_detect(@_); },
	}, {
		name =&gt; &quot;Nuvoton W83795G/ADG&quot;,
		driver =&gt; &quot;w83795&quot;,
		i2c_addrs =&gt; [0x2c..0x2f],
		i2c_detect =&gt; sub { w83795_detect(@_); },
	}, {
		name =&gt; &quot;Nuvoton NCT7802Y&quot;,
		driver =&gt; &quot;nct7802&quot;,
		i2c_addrs =&gt; [0x28..0x2f],
		i2c_detect =&gt; sub { nct7802_detect(@_); },
	}, {
		name =&gt; &quot;Nuvoton NCT7904D&quot;,
		driver =&gt; &quot;nct7904&quot;,
		i2c_addrs =&gt; [0x2d..0x2e],
		i2c_detect =&gt; sub { nct7904_detect(@_); },
	}, {
		name =&gt; &quot;Winbond W83627HF&quot;,
		driver =&gt; &quot;use-isa-instead&quot;,
		i2c_addrs =&gt; [0x28..0x2f],
		i2c_detect =&gt; sub { w83781d_detect(@_, 3); },
	}, {
		name =&gt; &quot;Winbond W83627EHF&quot;,
		driver =&gt; &quot;use-isa-instead&quot;,
		i2c_addrs =&gt; [0x28..0x2f],
		i2c_detect =&gt; sub { w83781d_detect(@_, 9); },
	}, {
		name =&gt; &quot;Winbond W83627DHG/W83667HG/W83677HG&quot;,
		driver =&gt; &quot;use-isa-instead&quot;,
		i2c_addrs =&gt; [0x28..0x2f],
		i2c_detect =&gt; sub { w83781d_detect(@_, 10); },
	}, {
		name =&gt; &quot;Asus AS99127F (rev.1)&quot;,
		driver =&gt; &quot;w83781d&quot;,
		i2c_addrs =&gt; [0x28..0x2f],
		i2c_detect =&gt; sub { w83781d_detect(@_, 4); },
	}, {
		name =&gt; &quot;Asus AS99127F (rev.2)&quot;,
		driver =&gt; &quot;w83781d&quot;,
		i2c_addrs =&gt; [0x28..0x2f],
		i2c_detect =&gt; sub { w83781d_detect(@_, 5); },
	}, {
		name =&gt; &quot;Asus ASB100 Bach&quot;,
		driver =&gt; &quot;asb100&quot;,
		i2c_addrs =&gt; [0x28..0x2f],
		i2c_detect =&gt; sub { w83781d_detect(@_, 6); },
	}, {
		name =&gt; &quot;Asus Mozart-2&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x77],
		i2c_detect =&gt; sub { mozart_detect(@_); },
	}, {
		name =&gt; &quot;Winbond W83L784R/AR/G&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x2d],
		i2c_detect =&gt; sub { w83l784r_detect(@_, 0); },
	}, {
		name =&gt; &quot;Winbond W83L785R/G&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x2d],
		i2c_detect =&gt; sub { w83l784r_detect(@_, 1); },
	}, {
		name =&gt; &quot;Winbond W83L786NR/NG/R/G&quot;,
		driver =&gt; &quot;w83l786ng&quot;,
		i2c_addrs =&gt; [0x2e, 0x2f],
		i2c_detect =&gt; sub { w83l784r_detect(@_, 2); },
	}, {
		name =&gt; &quot;Winbond W83L785TS-S&quot;,
		driver =&gt; &quot;w83l785ts&quot;,
		i2c_addrs =&gt; [0x2e],
		i2c_detect =&gt; sub { w83l784r_detect(@_, 3); },
	}, {
		name =&gt; &quot;Genesys Logic GL518SM&quot;,
		driver =&gt; &quot;gl518sm&quot;,
		i2c_addrs =&gt; [0x2c, 0x2d],
		i2c_detect =&gt; sub { gl518sm_detect(@_, 0); },
	}, {
		name =&gt; &quot;Genesys Logic GL520SM&quot;,
		driver =&gt; &quot;gl520sm&quot;,
		i2c_addrs =&gt; [0x2c, 0x2d],
		i2c_detect =&gt; sub { gl518sm_detect(@_, 1); },
	}, {
		name =&gt; &quot;Genesys Logic GL525SM&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x2d],
		i2c_detect =&gt; sub { gl525sm_detect(@_); },
	}, {
		name =&gt; &quot;Analog Devices ADM9240&quot;,
		driver =&gt; &quot;adm9240&quot;,
		i2c_addrs =&gt; [0x2c..0x2f],
		i2c_detect =&gt; sub { adm9240_detect(@_, 0); },
	}, {
		name =&gt; &quot;Dallas Semiconductor DS1780&quot;,
		driver =&gt; &quot;adm9240&quot;,
		i2c_addrs =&gt; [0x2c..0x2f],
		i2c_detect =&gt; sub { adm9240_detect(@_, 1); },
	}, {
		name =&gt; &quot;National Semiconductor LM81&quot;,
		driver =&gt; &quot;adm9240&quot;,
		i2c_addrs =&gt; [0x2c..0x2f],
		i2c_detect =&gt; sub { adm9240_detect(@_, 2); },
	}, {
		name =&gt; &quot;Analog Devices ADM1026&quot;,
		driver =&gt; &quot;adm1026&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { adm1026_detect(@_); },
	}, {
		name =&gt; &quot;Analog Devices ADM1025&quot;,
		driver =&gt; &quot;adm1025&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { adm1025_detect(@_, 0); },
	}, {
		name =&gt; &quot;Philips NE1619&quot;,
		driver =&gt; &quot;adm1025&quot;,
		i2c_addrs =&gt; [0x2c..0x2d],
		i2c_detect =&gt; sub { adm1025_detect(@_, 1); },
	}, {
		name =&gt; &quot;Analog Devices ADM1021&quot;,
		driver =&gt; &quot;adm1021&quot;,
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { adm1021_detect(@_, 0); },
	}, {
		name =&gt; &quot;Analog Devices ADM1021A/ADM1023&quot;,
		driver =&gt; &quot;adm1021&quot;,
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { adm1021_detect(@_, 1); },
	}, {
		name =&gt; &quot;Global Mixed-mode Technology G781&quot;,
		driver =&gt; &quot;lm90&quot;,
		i2c_addrs =&gt; [0x4c, 0x4d],
		i2c_detect =&gt; sub { lm90_detect(@_, 15); },
	}, {
		name =&gt; &quot;Maxim MAX1617&quot;,
		driver =&gt; &quot;adm1021&quot;,
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { adm1021_detect(@_, 2); },
	}, {
		name =&gt; &quot;Maxim MAX1617A&quot;,
		driver =&gt; &quot;adm1021&quot;,
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { adm1021_detect(@_, 3); },
	}, {
		name =&gt; &quot;Maxim MAX1668&quot;,
		driver =&gt; &quot;max1668&quot;,
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { max1668_detect(@_, 0); },
	}, {
		name =&gt; &quot;Maxim MAX1805&quot;,
		driver =&gt; &quot;max1668&quot;,
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { max1668_detect(@_, 1); },
	}, {
		name =&gt; &quot;Maxim MAX1989&quot;,
		driver =&gt; &quot;max1668&quot;,
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { max1668_detect(@_, 2); },
	}, {
		name =&gt; &quot;Maxim MAX6639&quot;,
		driver =&gt; &quot;max6639&quot;,
		i2c_addrs =&gt; [0x2c, 0x2e, 0x2f],
		i2c_detect =&gt; sub { max6639_detect(@_); },
	}, {
		name =&gt; &quot;Maxim MAX6642&quot;,
		driver =&gt; &quot;max6642&quot;,
		i2c_addrs =&gt; [0x48..0x4f],
		i2c_detect =&gt; sub { max6642_detect(@_); },
	}, {
		name =&gt; &quot;Maxim MAX6655/MAX6656&quot;,
		driver =&gt; &quot;max6655&quot;,
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { max6655_detect(@_); },
	}, {
		name =&gt; &quot;TI THMC10&quot;,
		driver =&gt; &quot;adm1021&quot;,
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { adm1021_detect(@_, 4); },
	}, {
		name =&gt; &quot;National Semiconductor LM84&quot;,
		driver =&gt; &quot;adm1021&quot;,
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { adm1021_detect(@_, 5); },
	}, {
		name =&gt; &quot;Genesys Logic GL523SM&quot;,
		driver =&gt; &quot;adm1021&quot;,
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { adm1021_detect(@_, 6); },
	}, {
		name =&gt; &quot;Onsemi MC1066&quot;,
		driver =&gt; &quot;adm1021&quot;,
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { adm1021_detect(@_, 7); },
	}, {
		name =&gt; &quot;Maxim MAX1618&quot;,
		driver =&gt; &quot;max1619&quot;,
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { max1619_detect(@_, 1); },
	}, {
		name =&gt; &quot;Maxim MAX1619&quot;,
		driver =&gt; &quot;max1619&quot;,
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { max1619_detect(@_, 0); },
	}, {
		name =&gt; &quot;National Semiconductor LM82/LM83&quot;,
		driver =&gt; &quot;lm83&quot;,
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { lm83_detect(@_); },
	}, {
		name =&gt; &quot;National Semiconductor LM90&quot;,
		driver =&gt; &quot;lm90&quot;,
		i2c_addrs =&gt; [0x4c],
		i2c_detect =&gt; sub { lm90_detect(@_, 0); },
	}, {
		name =&gt; &quot;National Semiconductor LM89/LM99&quot;,
		driver =&gt; &quot;lm90&quot;,
		i2c_addrs =&gt; [0x4c..0x4d],
		i2c_detect =&gt; sub { lm90_detect(@_, 1); },
	}, {
		name =&gt; &quot;National Semiconductor LM86&quot;,
		driver =&gt; &quot;lm90&quot;,
		i2c_addrs =&gt; [0x4c],
		i2c_detect =&gt; sub { lm90_detect(@_, 2); },
	}, {
		name =&gt; &quot;Analog Devices ADM1032&quot;,
		driver =&gt; &quot;lm90&quot;,
		i2c_addrs =&gt; [0x4c..0x4d],
		i2c_detect =&gt; sub { lm90_detect(@_, 3); },
	}, {
		name =&gt; &quot;Maxim MAX6654&quot;,
		driver =&gt; &quot;to-be-written&quot;, # probably lm90
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { lm90_detect(@_, 4); },
	}, {
		name =&gt; &quot;Maxim MAX6690&quot;,
		driver =&gt; &quot;to-be-written&quot;, # probably lm90
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { lm90_detect(@_, 12); },
	}, {
		name =&gt; &quot;Maxim MAX6657/MAX6658/MAX6659&quot;,
		driver =&gt; &quot;lm90&quot;,
		i2c_addrs =&gt; [0x4c],
		i2c_detect =&gt; sub { max6657_detect(@_); },
	}, {
		name =&gt; &quot;Maxim MAX6659&quot;,
		driver =&gt; &quot;lm90&quot;,
		i2c_addrs =&gt; [0x4d..0x4e], # 0x4c is handled above
		i2c_detect =&gt; sub { max6657_detect(@_); },
	}, {
		name =&gt; &quot;Maxim MAX6646&quot;,
		driver =&gt; &quot;lm90&quot;,
		i2c_addrs =&gt; [0x4d],
		i2c_detect =&gt; sub { lm90_detect(@_, 6); },
	}, {
		name =&gt; &quot;Maxim MAX6647&quot;,
		driver =&gt; &quot;lm90&quot;,
		i2c_addrs =&gt; [0x4e],
		i2c_detect =&gt; sub { lm90_detect(@_, 6); },
	}, {
		name =&gt; &quot;Maxim MAX6648/MAX6649/MAX6692&quot;,
		driver =&gt; &quot;lm90&quot;,
		i2c_addrs =&gt; [0x4c],
		i2c_detect =&gt; sub { lm90_detect(@_, 6); },
	}, {
		name =&gt; &quot;Maxim MAX6680/MAX6681&quot;,
		driver =&gt; &quot;lm90&quot;,
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { max6680_95_detect(@_, 0); },
	}, {
		name =&gt; &quot;Maxim MAX6695/MAX6696&quot;,
		driver =&gt; &quot;lm90&quot;,
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { max6680_95_detect(@_, 1); },
	}, {
		name =&gt; &quot;Winbond W83L771W/G&quot;,
		driver =&gt; &quot;lm90&quot;,
		i2c_addrs =&gt; [0x4c],
		i2c_detect =&gt; sub { lm90_detect(@_, 8); },
	}, {
		name =&gt; &quot;Winbond W83L771AWG/ASG&quot;,
		driver =&gt; &quot;lm90&quot;,
		i2c_addrs =&gt; [0x4c],
		i2c_detect =&gt; sub { lm90_detect(@_, 11); },
	}, {
		name =&gt; &quot;Texas Instruments TMP400&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# tmp401
		i2c_addrs =&gt; [0x18..0x1a, 0x29..0x2b, 0x4c..0x4e],
		i2c_detect =&gt; sub { tmp401_detect(@_, 0); },
	}, {
		name =&gt; &quot;Texas Instruments TMP401&quot;,
		driver =&gt; &quot;tmp401&quot;,
		i2c_addrs =&gt; [0x4c],
		i2c_detect =&gt; sub { tmp401_detect(@_, 1); },
	}, {
		name =&gt; &quot;Texas Instruments TMP411A&quot;,
		driver =&gt; &quot;tmp401&quot;,
		i2c_addrs =&gt; [0x4c],
		i2c_detect =&gt; sub { tmp401_detect(@_, 2); },
	}, {
		name =&gt; &quot;Texas Instruments TMP411B&quot;,
		driver =&gt; &quot;tmp401&quot;,
		i2c_addrs =&gt; [0x4d],
		i2c_detect =&gt; sub { tmp401_detect(@_, 3); },
	}, {
		name =&gt; &quot;Texas Instruments TMP411C&quot;,
		driver =&gt; &quot;tmp401&quot;,
		i2c_addrs =&gt; [0x4e],
		i2c_detect =&gt; sub { tmp401_detect(@_, 4); },
	}, {
		name =&gt; &quot;Texas Instruments TMP421&quot;,
		driver =&gt; &quot;tmp421&quot;,
		i2c_addrs =&gt; [0x1c..0x1f, 0x2a, 0x4c..0x4f],
		i2c_detect =&gt; sub { tmp42x_detect(@_, 0); },
	}, {
		name =&gt; &quot;Texas Instruments TMP422&quot;,
		driver =&gt; &quot;tmp421&quot;,
		i2c_addrs =&gt; [0x4c..0x4f],
		i2c_detect =&gt; sub { tmp42x_detect(@_, 1); },
	}, {
		name =&gt; &quot;Texas Instruments TMP423&quot;,
		driver =&gt; &quot;tmp421&quot;,
		i2c_addrs =&gt; [0x4c, 0x4d],
		i2c_detect =&gt; sub { tmp42x_detect(@_, 2); },
	}, {
		name =&gt; &quot;Texas Instruments TMP431&quot;,
		driver =&gt; &quot;tmp401&quot;,
		i2c_addrs =&gt; [0x4c, 0x4d],
		i2c_detect =&gt; sub { tmp401_detect(@_, 5); },
	}, {
		name =&gt; &quot;Texas Instruments TMP432&quot;,
		driver =&gt; &quot;tmp401&quot;,
		i2c_addrs =&gt; [0x4c, 0x4d],
		i2c_detect =&gt; sub { tmp401_detect(@_, 6); },
	}, {
		name =&gt; &quot;Texas Instruments TMP435&quot;,
		driver =&gt; &quot;tmp401&quot;,
		i2c_addrs =&gt; [0x48..0x4f], # 0x37 not probed
		i2c_detect =&gt; sub { tmp401_detect(@_, 7); },
	}, {
		name =&gt; &quot;Texas Instruments TMP441&quot;,
		driver =&gt; &quot;tmp421&quot;,
		i2c_addrs =&gt; [0x1c..0x1f, 0x2a, 0x4c..0x4f],
		i2c_detect =&gt; sub { tmp42x_detect(@_, 3); },
	}, {
		name =&gt; &quot;Texas Instruments TMP442&quot;,
		driver =&gt; &quot;tmp421&quot;,
		i2c_addrs =&gt; [0x4c, 0x4d],
		i2c_detect =&gt; sub { tmp42x_detect(@_, 4); },
	}, {
		name =&gt; &quot;Texas Instruments TMP451&quot;,
		driver =&gt; &quot;lm90&quot;,
		i2c_addrs =&gt; [0x4c],
		i2c_detect =&gt; sub { tmp401_detect(@_, 8); },
	}, {
		name =&gt; &quot;Texas Instruments AMC6821&quot;,
		driver =&gt; &quot;amc6821&quot;,
		i2c_addrs =&gt; [0x18..0x1a, 0x2c..0x2e, 0x4c..0x4e],
		i2c_detect =&gt; sub { amc6821_detect(@_); },
	}, {
		name =&gt; &quot;National Semiconductor LM95231&quot;,
		driver =&gt; &quot;lm95241&quot;,
		i2c_addrs =&gt; [0x2b, 0x19, 0x2a],
		i2c_detect =&gt; sub { lm95231_detect(@_, 0); },
	}, {
		name =&gt; &quot;National Semiconductor LM95233&quot;,
		driver =&gt; &quot;lm95234&quot;,
		i2c_addrs =&gt; [0x18, 0x2a, 0x2b],
		i2c_detect =&gt; sub { lm95231_detect(@_, 5); },
	}, {
		name =&gt; &quot;National Semiconductor LM95234&quot;,
		driver =&gt; &quot;lm95234&quot;,
		i2c_addrs =&gt; [0x18, 0x4d, 0x4e],
		i2c_detect =&gt; sub { lm95231_detect(@_, 3); },
	}, {
		name =&gt; &quot;National Semiconductor LM95235&quot;,
		driver =&gt; &quot;lm95245&quot;,
		i2c_addrs =&gt; [0x18, 0x29, 0x4c],
		i2c_detect =&gt; sub { lm95231_detect(@_, 4); },
	}, {
		name =&gt; &quot;National Semiconductor LM95241&quot;,
		driver =&gt; &quot;lm95241&quot;,
		i2c_addrs =&gt; [0x2b, 0x19, 0x2a],
		i2c_detect =&gt; sub { lm95231_detect(@_, 1); },
	}, {
		name =&gt; &quot;National Semiconductor LM95245&quot;,
		driver =&gt; &quot;lm95245&quot;,
		i2c_addrs =&gt; [0x18, 0x19, 0x29, 0x4c, 0x4d],
		i2c_detect =&gt; sub { lm95231_detect(@_, 2); },
	}, {
		name =&gt; &quot;National Semiconductor LM63&quot;,
		driver =&gt; &quot;lm63&quot;,
		i2c_addrs =&gt; [0x4c],
		i2c_detect =&gt; sub { lm63_detect(@_, 1); },
	}, {
		name =&gt; &quot;National Semiconductor LM64&quot;,
		driver =&gt; &quot;lm63&quot;,
		i2c_addrs =&gt; [0x18, 0x4e],
		i2c_detect =&gt; sub { lm63_detect(@_, 3); },
	}, {
		name =&gt; &quot;National Semiconductor LM96163&quot;,
		driver =&gt; &quot;lm63&quot;,
		i2c_addrs =&gt; [0x4c],
		i2c_detect =&gt; sub { lm63_detect(@_, 4); },
	}, {
		name =&gt; &quot;Fintek F75363SG&quot;,
		driver =&gt; &quot;lm63&quot;, # Not yet
		i2c_addrs =&gt; [0x4c],
		i2c_detect =&gt; sub { lm63_detect(@_, 2); },
	}, {
		name =&gt; &quot;National Semiconductor LM73&quot;,
		driver =&gt; &quot;lm73&quot;,
		i2c_addrs =&gt; [0x48..0x4a, 0x4c..0x4e],
		i2c_detect =&gt; sub { lm73_detect(@_); },
	}, {
		name =&gt; &quot;National Semiconductor LM92&quot;,
		driver =&gt; &quot;lm92&quot;,
		i2c_addrs =&gt; [0x48..0x4b],
		i2c_detect =&gt; sub { lm92_detect(@_, 0); },
	}, {
		name =&gt; &quot;National Semiconductor LM76&quot;,
		driver =&gt; &quot;lm92&quot;,
		i2c_addrs =&gt; [0x48..0x4b],
		i2c_detect =&gt; sub { lm92_detect(@_, 1); },
	}, {
		name =&gt; &quot;Maxim MAX6633/MAX6634/MAX6635&quot;,
		driver =&gt; &quot;lm92&quot;,
		i2c_addrs =&gt; [0x48..0x4f], # The MAX6633 can also use 0x40-0x47 but we
					   # don&#039;t want to probe these addresses, it&#039;s
					   # dangerous.
		i2c_detect =&gt; sub { lm92_detect(@_, 2); },
	}, {
		name =&gt; &quot;Analog Devices ADT7461&quot;,
		driver =&gt; &quot;lm90&quot;,
		i2c_addrs =&gt; [0x4c..0x4d],
		i2c_detect =&gt; sub { lm90_detect(@_, 5); },
	}, {
		name =&gt; &quot;Analog Devices ADT7461A, ON Semiconductor NCT1008&quot;,
		driver =&gt; &quot;lm90&quot;,
		i2c_addrs =&gt; [0x4c..0x4d],
		i2c_detect =&gt; sub { lm90_detect(@_, 13); },
	}, {
		name =&gt; &quot;NXP/Philips SA56004&quot;,
		driver =&gt; &quot;lm90&quot;,
		i2c_addrs =&gt; [0x48..0x4f],
		i2c_detect =&gt; sub { lm90_detect(@_, 14); },
	}, {
		name =&gt; &quot;Analog Devices ADT7481&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x4c, 0x4b],
		i2c_detect =&gt; sub { adt7481_detect(@_); },
	}, {
		name =&gt; &quot;Analog Devices ADM1029&quot;,
		driver =&gt; &quot;adm1029&quot;,
		i2c_addrs =&gt; [0x28..0x2f],
		i2c_detect =&gt; sub { adm1029_detect(@_); },
	}, {
		name =&gt; &quot;Analog Devices ADM1030&quot;,
		driver =&gt; &quot;adm1031&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { adm1031_detect(@_, 0); },
	}, {
		name =&gt; &quot;Analog Devices ADM1031&quot;,
		driver =&gt; &quot;adm1031&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { adm1031_detect(@_, 1); },
	}, {
		name =&gt; &quot;Analog Devices ADM1033&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x50..0x53],
		i2c_detect =&gt; sub { adm1034_detect(@_, 0); },
	}, {
		name =&gt; &quot;Analog Devices ADM1034&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x50..0x53],
		i2c_detect =&gt; sub { adm1034_detect(@_, 1); },
	}, {
		name =&gt; &quot;Analog Devices ADM1022&quot;,
		driver =&gt; &quot;thmc50&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { adm1022_detect(@_, 0); },
	}, {
		name =&gt; &quot;Texas Instruments THMC50&quot;,
		driver =&gt; &quot;thmc50&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { adm1022_detect(@_, 1); },
	}, {
		name =&gt; &quot;Analog Devices ADM1028&quot;,
		driver =&gt; &quot;thmc50&quot;,
		i2c_addrs =&gt; [0x2e],
		i2c_detect =&gt; sub { adm1022_detect(@_, 2); },
	}, {
		name =&gt; &quot;Texas Instruments THMC51&quot;,
		driver =&gt; &quot;to-be-written&quot;, # thmc50
		i2c_addrs =&gt; [0x2e], # At least (no datasheet)
		i2c_detect =&gt; sub { adm1022_detect(@_, 3); },
	}, {
		name =&gt; &quot;VIA VT1211 (I2C)&quot;,
		driver =&gt; &quot;use-isa-instead&quot;,
		i2c_addrs =&gt; [0x2d],
		i2c_detect =&gt; sub { vt1211_i2c_detect(@_); },
	}, {
		name =&gt; &quot;ITE IT8712F&quot;,
		driver =&gt; &quot;it87&quot;,
		i2c_addrs =&gt; [0x28..0x2f],
		i2c_detect =&gt; sub { it8712_i2c_detect(@_); },
	}, {
		name =&gt; &quot;FSC Poseidon I&quot;,
		driver =&gt; sub { kernel_version_at_least(2, 6, 24) ? &quot;fschmd&quot; : &quot;fscpos&quot; },
		i2c_addrs =&gt; [0x73],
		i2c_detect =&gt; sub { fsc_detect(@_, 0); },
	}, {
		name =&gt; &quot;FSC Poseidon II&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x73],
		i2c_detect =&gt; sub { fsc_detect(@_, 1); },
	}, {
		name =&gt; &quot;FSC Scylla&quot;,
		driver =&gt; &quot;fschmd&quot;,
		i2c_addrs =&gt; [0x73],
		i2c_detect =&gt; sub { fsc_detect(@_, 2); },
	}, {
		name =&gt; &quot;FSC Hermes&quot;,
		driver =&gt; sub { kernel_version_at_least(2, 6, 24) ? &quot;fschmd&quot; : &quot;fscher&quot; },
		i2c_addrs =&gt; [0x73],
		i2c_detect =&gt; sub { fsc_detect(@_, 3); },
	}, {
		name =&gt; &quot;FSC Heimdal&quot;,
		driver =&gt; &quot;fschmd&quot;,
		i2c_addrs =&gt; [0x73],
		i2c_detect =&gt; sub { fsc_detect(@_, 4); },
	}, {
		name =&gt; &quot;FSC Heracles&quot;,
		driver =&gt; &quot;fschmd&quot;,
		i2c_addrs =&gt; [0x73],
		i2c_detect =&gt; sub { fsc_detect(@_, 5); },
	}, {
		name =&gt; &quot;FSC Hades&quot;,
		driver =&gt; &quot;fschmd&quot;,
		i2c_addrs =&gt; [0x73],
		i2c_detect =&gt; sub { fsc_detect(@_, 6); },
	}, {
		name =&gt; &quot;FSC Syleus&quot;,
		driver =&gt; &quot;fschmd&quot;,
		i2c_addrs =&gt; [0x73],
		i2c_detect =&gt; sub { fsc_detect(@_, 7); },
	}, {
		name =&gt; &quot;ALi M5879&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x2c..0x2d],
		i2c_detect =&gt; sub { m5879_detect(@_); },
	}, {
		name =&gt; &quot;SMSC LPC47M15x/192/292/997&quot;,
		driver =&gt; &quot;smsc47m192&quot;,
		i2c_addrs =&gt; [0x2c..0x2d],
		i2c_detect =&gt; sub { smsc47m192_detect(@_); },
	}, {
		name =&gt; &quot;SMSC DME1737&quot;,
		driver =&gt; &quot;dme1737&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { dme1737_detect(@_, 1); },
	}, {
		name =&gt; &quot;SMSC SCH5027D-NW&quot;,
		driver =&gt; &quot;dme1737&quot;,
		i2c_addrs =&gt; [0x2c..0x2e],
		i2c_detect =&gt; sub { dme1737_detect(@_, 2); },
	}, {
		name =&gt; &quot;SMSC EMC2103&quot;,
		driver =&gt; &quot;emc2103&quot;,
		i2c_addrs =&gt; [0x2e],
		i2c_detect =&gt; sub { emc1403_detect(@_, 2); },
	}, {
		name =&gt; &quot;SMSC EMC2104&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x2f],
		i2c_detect =&gt; sub { emc1403_detect(@_, 13); },
	}, {
		name =&gt; &quot;Fintek F75121R/F75122R/RG (VID+GPIO)&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x4e], # 0x37 not probed
		i2c_detect =&gt; sub { fintek_detect(@_, 2); },
	}, {
		name =&gt; &quot;Fintek F75373S/SG&quot;,
		driver =&gt; &quot;f75375s&quot;,
		i2c_addrs =&gt; [0x2d..0x2e],
		i2c_detect =&gt; sub { fintek_detect(@_, 3); },
	}, {
		name =&gt; &quot;Fintek F75375S/SP&quot;,
		driver =&gt; &quot;f75375s&quot;,
		i2c_addrs =&gt; [0x2d..0x2e],
		i2c_detect =&gt; sub { fintek_detect(@_, 4); },
	}, {
		name =&gt; &quot;Fintek F75387SG/RG&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x2d..0x2e],
		i2c_detect =&gt; sub { fintek_detect(@_, 5); },
	}, {
		name =&gt; &quot;Fintek F75383S/M&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x4c],
		i2c_detect =&gt; sub { fintek_detect(@_, 6); },
	}, {
		name =&gt; &quot;Fintek F75384S/M&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x4d],
		i2c_detect =&gt; sub { fintek_detect(@_, 6); },
	}, {
		name =&gt; &quot;Fintek custom power control IC&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x2f],
		i2c_detect =&gt; sub { fintek_detect(@_, 7); },
	}, {
		name =&gt; &quot;SMSC EMC1002&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x4c, 0x4d], # 0x3c, 0x3d not probed
		i2c_detect =&gt; sub { emc1403_detect(@_, 4); },
	}, {
		name =&gt; &quot;SMSC EMC1023&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# emc1023
		i2c_addrs =&gt; [0x48, 0x49, 0x4c, 0x4d],
		i2c_detect =&gt; sub { emc1023_detect(@_, 0); },
	}, {
		name =&gt; &quot;SMSC EMC1033&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x4c, 0x4d], # 0x3c, 0x3d not probed
		i2c_detect =&gt; sub { emc1403_detect(@_, 5); },
	}, {
		name =&gt; &quot;SMSC EMC1043&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# emc1023
		i2c_addrs =&gt; [0x48, 0x49, 0x4c, 0x4d],
		i2c_detect =&gt; sub { emc1023_detect(@_, 1); },
	}, {
		name =&gt; &quot;SMSC EMC1046&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x4c, 0x4d],
		i2c_detect =&gt; sub { emc1403_detect(@_, 6); },
	}, {
		name =&gt; &quot;SMSC EMC1047&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x18], # 0x10 not probed
		i2c_detect =&gt; sub { emc1403_detect(@_, 7); },
	}, {
		name =&gt; &quot;SMSC EMC1053&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# emc1023
		i2c_addrs =&gt; [0x48, 0x49, 0x4c, 0x4d],
		i2c_detect =&gt; sub { emc1023_detect(@_, 2); },
	}, {
		name =&gt; &quot;SMSC EMC1063&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# emc1023
		i2c_addrs =&gt; [0x48, 0x49, 0x4c, 0x4d],
		i2c_detect =&gt; sub { emc1023_detect(@_, 3); },
	}, {
		name =&gt; &quot;SMSC EMC1072&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x1c, 0x2c, 0x4c, 0x5c], # 0x3c, 0x6c, 0x7c not probed
		i2c_detect =&gt; sub { emc1403_detect(@_, 8); },
	}, {
		name =&gt; &quot;SMSC EMC1073&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x1c, 0x2c, 0x4c, 0x5c], # 0x3c, 0x6c, 0x7c not probed
		i2c_detect =&gt; sub { emc1403_detect(@_, 9); },
	}, {
		name =&gt; &quot;SMSC EMC1074&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		i2c_addrs =&gt; [0x1c, 0x2c, 0x4c, 0x5c], # 0x3c, 0x6c, 0x7c not probed
		i2c_detect =&gt; sub { emc1403_detect(@_, 10); },
	}, {
		name =&gt; &quot;SMSC EMC1402&quot;,
		driver =&gt; &quot;emc1403&quot;,
		i2c_addrs =&gt; [0x18, 0x29, 0x4c, 0x4d],
		i2c_detect =&gt; sub { emc1403_detect(@_, 11); },
	}, {
		name =&gt; &quot;SMSC EMC1403&quot;,
		driver =&gt; &quot;emc1403&quot;,
		i2c_addrs =&gt; [0x18, 0x29, 0x4c, 0x4d],
		i2c_detect =&gt; sub { emc1403_detect(@_, 0); },
	}, {
		name =&gt; &quot;SMSC EMC1404&quot;,
		driver =&gt; &quot;emc1403&quot;,
		i2c_addrs =&gt; [0x18, 0x29, 0x4c, 0x4d],
		i2c_detect =&gt; sub { emc1403_detect(@_, 1); },
	}, {
		name =&gt; &quot;SMSC EMC1422&quot;,
		driver =&gt; &quot;emc1403&quot;,
		i2c_addrs =&gt; [0x4c],
		i2c_detect =&gt; sub { emc1403_detect(@_, 14); },
	}, {
		name =&gt; &quot;SMSC EMC1423&quot;,
		driver =&gt; &quot;emc1403&quot;,
		i2c_addrs =&gt; [0x4c],
		i2c_detect =&gt; sub { emc1403_detect(@_, 3); },
	}, {
		name =&gt; &quot;SMSC EMC1424&quot;,
		driver =&gt; &quot;emc1403&quot;,
		i2c_addrs =&gt; [0x4c],
		i2c_detect =&gt; sub { emc1403_detect(@_, 12); },
	}, {
		name =&gt; &quot;ST STTS424&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 0); },
	}, {
		name =&gt; &quot;ST STTS424E&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 10); },
	}, {
		name =&gt; &quot;ST STTS2002&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 11); },
	}, {
		name =&gt; &quot;ST STTS3000&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 12); },
	}, {
		name =&gt; &quot;NXP SE97/SE97B&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 1); },
	}, {
		name =&gt; &quot;NXP SE98&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 2); },
	}, {
		name =&gt; &quot;Analog Devices ADT7408&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 3); },
	}, {
		name =&gt; &quot;IDT TS3000/TSE2002&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 4); },
	}, {
		name =&gt; &quot;IDT TSE2004&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 16); },
	}, {
		name =&gt; &quot;IDT TS3001&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 17); },
	}, {
		name =&gt; &quot;Maxim MAX6604&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 5); },
	}, {
		name =&gt; &quot;Microchip MCP9804&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 13); },
	}, {
		name =&gt; &quot;Microchip MCP9808&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 18); },
	},{
		name =&gt; &quot;Microchip MCP98242&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 6); },
	}, {
		name =&gt; &quot;Microchip MCP98243&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 7); },
	}, {
		name =&gt; &quot;Microchip MCP98244&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 15); },
	}, {
		name =&gt; &quot;Microchip MCP9843&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 8); },
	}, {
		name =&gt; &quot;ON CAT6095/CAT34TS02&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 9); },
	}, {
		name =&gt; &quot;ON CAT34TS02C&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 19); },
	}, {
		name =&gt; &quot;ON CAT34TS04&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 21); },
	}, {
		name =&gt; &quot;Atmel AT30TS00&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 14); },
	}, {
		name =&gt; &quot;Giantec GT30TS00&quot;,
		driver =&gt; &quot;jc42&quot;,
		i2c_addrs =&gt; [0x18..0x1f],
		i2c_detect =&gt; sub { jedec_JC42_4_detect(@_, 20); },
	}
);

# IPMI interfaces have their own array now
@ipmi_ifs = (
	{
		name =&gt; &quot;IPMI BMC KCS&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# ipmisensors
		isa_addrs =&gt; [0x0ca0],
		isa_detect =&gt; sub { ipmi_detect(@_); },
	}, {
		name =&gt; &quot;IPMI BMC SMIC&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# ipmisensors
		isa_addrs =&gt; [0x0ca8],
		isa_detect =&gt; sub { ipmi_detect(@_); },
	}
);

# Here is a similar list, but for devices which are not hardware monitoring
# chips. We only list popular devices which happen to live at the same I2C
# address as recognized hardware monitoring chips. The idea is to make it
# clear that the chip in question is of no interest for lm-sensors.
@non_hwmon_chip_ids = (
	{
		name =&gt; &quot;Winbond W83791SD&quot;,
		i2c_addrs =&gt; [0x2c..0x2f],
		i2c_detect =&gt; sub { w83791sd_detect(@_); },
	}, {
		name =&gt; &quot;Fintek F75111R/RG/N (GPIO)&quot;,
		i2c_addrs =&gt; [0x37, 0x4e],
		i2c_detect =&gt; sub { fintek_detect(@_, 1); },
	}, {
		name =&gt; &quot;ITE IT8201R/IT8203R/IT8206R/IT8266R&quot;,
		i2c_addrs =&gt; [0x4e],
		i2c_detect =&gt; sub { ite_overclock_detect(@_); },
	}, {
		name =&gt; &quot;SPD EEPROM&quot;,
		i2c_addrs =&gt; [0x50..0x57],
		i2c_detect =&gt; sub { eeprom_detect(@_); },
	}, {
		name =&gt; &quot;EDID EEPROM&quot;,
		i2c_addrs =&gt; [0x50],
		i2c_detect =&gt; sub { ddcmonitor_detect(@_); },
	}
);

# This is a list of all recognized superio chips.
# Each entry must have the following fields:
#  name: The full chip name
#  driver: The driver name. Put in exactly:
#      * &quot;to-be-written&quot; if it is not yet available
#      * &quot;not-a-sensor&quot; if the chip doesn&#039;t have hardware monitoring
#	 capabilities (listing such chips here removes the need of manual
#	 lookup when people report them)
#      * &quot;via-smbus-only&quot; if this is a Super-I/O chip whose hardware
#	 monitoring registers can only be accessed via the SMBus
#  devid: The device ID we have to match (base device)
#  devid_mask (optional): Bitmask to apply before checking the device ID
#  regs (optional): Register definitions, where they differ from the standard.
#  logdev: The logical device containing the sensors
#  check (optional): A function to refine the detection. Will be passed
#      the index and data ports as parameters. Must return 1 for a matching
#      device, 0 otherwise.
#  features (optional): Features supported by this device, amongst:
#      * FEAT_IN
#      * FEAT_FAN
#      * FEAT_TEMP
use vars qw(@superio_ids_natsemi @superio_ids_smsc @superio_ids_smsc_ns
	    @superio_ids_winbond @superio_ids_ite @superio_ids);

use constant FEAT_IN	=&gt; (1 &lt;&lt; 0);
use constant FEAT_FAN	=&gt; (1 &lt;&lt; 1);
use constant FEAT_TEMP	=&gt; (1 &lt;&lt; 2);
use constant FEAT_SMBUS	=&gt; (1 &lt;&lt; 7);

@superio_ids_natsemi = (
	{
		name =&gt; &quot;Nat. Semi. PC8374L Super IO Sensors&quot;,	# Also Nuvoton WPCD374L
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0xf1,
		check =&gt; sub {
			outb($_[0], 0x27);
			# Guess work; seen so far: 0x11
			return (inb($_[1]) &lt; 0x80);
		},
		logdev =&gt; 0x08,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Nuvoton WPCD377I Super IO&quot;,	# Also WPCD376I
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0xf1,
		check =&gt; sub {
			outb($_[0], 0x27);
			# Guess work; seen so far: 0x91 (twice)
			return (inb($_[1]) &gt;= 0x80);
		},
	}, {
		name =&gt; &quot;Nat. Semi. PC87351 Super IO Fan Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0xe2,
		logdev =&gt; 0x08,
	}, {
		name =&gt; &quot;Nat. Semi. PC87360 Super IO Fan Sensors&quot;,
		driver =&gt; &quot;pc87360&quot;,
		devid =&gt; 0xe1,
		logdev =&gt; 0x09,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;Nat. Semi. PC87363 Super IO Fan Sensors&quot;,
		driver =&gt; &quot;pc87360&quot;,
		devid =&gt; 0xe8,
		logdev =&gt; 0x09,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;Nat. Semi. PC87364 Super IO Fan Sensors&quot;,
		driver =&gt; &quot;pc87360&quot;,
		devid =&gt; 0xe4,
		logdev =&gt; 0x09,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;Nat. Semi. PC87365 Super IO Fan Sensors&quot;,
		driver =&gt; &quot;pc87360&quot;,
		devid =&gt; 0xe5,
		logdev =&gt; 0x09,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;Nat. Semi. PC87365 Super IO Voltage Sensors&quot;,
		driver =&gt; &quot;pc87360&quot;,
		devid =&gt; 0xe5,
		logdev =&gt; 0x0d,
		features =&gt; FEAT_IN,
	}, {
		name =&gt; &quot;Nat. Semi. PC87365 Super IO Thermal Sensors&quot;,
		driver =&gt; &quot;pc87360&quot;,
		devid =&gt; 0xe5,
		logdev =&gt; 0x0e,
		features =&gt; FEAT_TEMP,
	}, {
		name =&gt; &quot;Nat. Semi. PC87366 Super IO Fan Sensors&quot;,
		driver =&gt; &quot;pc87360&quot;,
		devid =&gt; 0xe9,
		logdev =&gt; 0x09,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;Nat. Semi. PC87366 Super IO Voltage Sensors&quot;,
		driver =&gt; &quot;pc87360&quot;,
		devid =&gt; 0xe9,
		logdev =&gt; 0x0d,
		features =&gt; FEAT_IN,
	}, {
		name =&gt; &quot;Nat. Semi. PC87366 Super IO Thermal Sensors&quot;,
		driver =&gt; &quot;pc87360&quot;,
		devid =&gt; 0xe9,
		logdev =&gt; 0x0e,
		features =&gt; FEAT_TEMP,
	}, {
		name =&gt; &quot;Nat. Semi. PC87372 Super IO Fan Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0xf0,
		logdev =&gt; 0x09,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;Nat. Semi. PC87373 Super IO Fan Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0xf3,
		logdev =&gt; 0x09,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;Nat. Semi. PC87591 Super IO&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0xec,
		logdev =&gt; 0x0f,
	}, {
		name =&gt; &quot;Nat. Semi. PC87317 Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0xd0,
	}, {
		name =&gt; &quot;Nat. Semi. PC97317 Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0xdf,
	}, {
		name =&gt; &quot;Nat. Semi. PC8739x Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0xea,
	}, {
		name =&gt; &quot;Nat. Semi. PC8741x Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0xee,
	}, {
		name =&gt; &quot;Nat. Semi. PC87427 Super IO Fan Sensors&quot;,
		driver =&gt; &quot;pc87427&quot;,
		devid =&gt; 0xf2,
		logdev =&gt; 0x09,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;Nat. Semi. PC87427 Super IO Health Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0xf2,
		logdev =&gt; 0x14,
		features =&gt; FEAT_IN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8510E/TE/G Super IO&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x8510,
		features =&gt; FEAT_IN | FEAT_FAN,
	}, {
		name =&gt; &quot;ITE IT8511E/TE/G Super IO&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x8511,
		features =&gt; FEAT_IN | FEAT_FAN,
	}, {
		name =&gt; &quot;ITE IT8512E/F/G Super IO&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x8512,
		features =&gt; FEAT_IN | FEAT_FAN,
	}, {
		name =&gt; &quot;ITE IT8513E/F/G Super IO&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x8513,
		features =&gt; FEAT_IN | FEAT_FAN,
	}, {
		name =&gt; &quot;ITE IT8516E/F/G Super IO&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x8516,
		features =&gt; FEAT_IN | FEAT_FAN,
	}, {
		name =&gt; &quot;ITE IT8518E Super IO&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x8518,
		features =&gt; FEAT_IN | FEAT_FAN,
	}
);

@superio_ids_smsc = (
	{
		name =&gt; &quot;SMSC DME1737 Super IO&quot;,
		# Hardware monitoring features are accessed on the SMBus
		driver =&gt; &quot;via-smbus-only&quot;,
		devid =&gt; 0x78,
	}, {
		name =&gt; &quot;SMSC DME1737 Super IO&quot;,
		# The DME1737 shows up twice in this list because it can return either
		# 0x78 or 0x77 as its device ID.
		# Hardware monitoring features are accessed on the SMBus
		driver =&gt; &quot;via-smbus-only&quot;,
		devid =&gt; 0x77,
	}, {
		name =&gt; &quot;SMSC EMC2700LPC Super IO&quot;,
		# no datasheet
		devid =&gt; 0x67,
	}, {
		name =&gt; &quot;SMSC FDC37B72x Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x4c,
	}, {
		name =&gt; &quot;SMSC FDC37B78x Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x44,
	}, {
		name =&gt; &quot;SMSC FDC37C672 Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x40,
	}, {
		name =&gt; &quot;SMSC FDC37M707 Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x42,
	}, {
		name =&gt; &quot;SMSC FDC37M81x Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x4d,
	}, {
		name =&gt; &quot;SMSC LPC47B27x Super IO Fan Sensors&quot;,
		driver =&gt; &quot;smsc47m1&quot;,
		devid =&gt; 0x51,
		logdev =&gt; 0x0a,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;SMSC LPC47B34x Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x56,
	}, {
		name =&gt; &quot;SMSC LPC47B357/M967 Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x5d,
	}, {
		name =&gt; &quot;SMSC LPC47B367-NC Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x6d,
	}, {
		name =&gt; &quot;SMSC LPC47B37x Super IO Fan Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x52,
		logdev =&gt; 0x0a,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;SMSC LPC47B397-NC Super IO&quot;,
		driver =&gt; &quot;smsc47b397&quot;,
		devid =&gt; 0x6f,
		logdev =&gt; 0x08,
		features =&gt; FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;SMSC LPC47M10x/112/13x Super IO Fan Sensors&quot;,
		driver =&gt; &quot;smsc47m1&quot;,
		devid =&gt; 0x59,
		logdev =&gt; 0x0a,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;SMSC LPC47M14x Super IO Fan Sensors&quot;,
		driver =&gt; &quot;smsc47m1&quot;,
		devid =&gt; 0x5f,
		logdev =&gt; 0x0a,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;SMSC LPC47M15x/192/997 Super IO Fan Sensors&quot;,
		driver =&gt; &quot;smsc47m1&quot;,
		devid =&gt; 0x60,
		logdev =&gt; 0x0a,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;SMSC LPC47M172 Super IO Fan Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x14,
		logdev =&gt; 0x0a,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;SMSC LPC47M182 Super IO Fan Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x74,
		logdev =&gt; 0x0a,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;SMSC LPC47M233 Super IO Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x6b80,
		devid_mask =&gt; 0xff80,
		logdev =&gt; 0x0a,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;SMSC LPC47M292 Super IO Fan Sensors&quot;,
		driver =&gt; &quot;smsc47m1&quot;,
		devid =&gt; 0x6b00,
		devid_mask =&gt; 0xff80,
		logdev =&gt; 0x0a,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;SMSC LPC47M584-NC Super IO&quot;,
		# No datasheet (Dell-specific part). Not compatible with
		# smsc47m1 nor dme1737 nor LPC47M233. No evidence that this
		# chip can do any hardware monitoring at all.
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x76,
	}, {
		name =&gt; &quot;SMSC LPC47N252 Super IO Fan Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x0e,
		logdev =&gt; 0x09,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;SMSC LPC47S42x Super IO Fan Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x57,
		logdev =&gt; 0x0a,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;SMSC LPC47S45x Super IO Fan Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x62,
		logdev =&gt; 0x0a,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;SMSC LPC47U32x Super IO Fan Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x58,
		logdev =&gt; 0x0a,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;SMSC LPC47U33x Super IO Fan Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x54,
		logdev =&gt; 0x0a,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;SMSC SCH3112 Super IO&quot;,
		driver =&gt; &quot;dme1737&quot;,
		devid =&gt; 0x7c,
		logdev =&gt; 0x0a,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;SMSC SCH3114 Super IO&quot;,
		driver =&gt; &quot;dme1737&quot;,
		devid =&gt; 0x7d,
		logdev =&gt; 0x0a,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;SMSC SCH3116 Super IO&quot;,
		driver =&gt; &quot;dme1737&quot;,
		devid =&gt; 0x7f,
		logdev =&gt; 0x0a,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;SMSC SCH4307 Super IO Fan Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x90,
		logdev =&gt; 0x08,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;SMSC SCH5027D-NW Super IO&quot;,
		# Hardware monitoring features are accessed on the SMBus
		driver =&gt; &quot;via-smbus-only&quot;,
		devid =&gt; 0x89,
	}, {
		name =&gt; &quot;SMSC SCH5127 Super IO&quot;,
		driver =&gt; &quot;dme1737&quot;,
		devid =&gt; 0x86,
		logdev =&gt; 0x0a,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;SMSC SCH5307-NS Super IO&quot;,
		driver =&gt; &quot;smsc47b397&quot;,
		devid =&gt; 0x81,
		logdev =&gt; 0x08,
		features =&gt; FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;SMSC SCH5317 Super IO&quot;,
		driver =&gt; &quot;smsc47b397&quot;,
		devid =&gt; 0x85,
		logdev =&gt; 0x08,
		features =&gt; FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;SMSC SCH5317 Super IO&quot;,
		# The SCH5317 shows up twice in this list because it can return either
		# 0x85 or 0x8c as its device ID.
		driver =&gt; &quot;smsc47b397&quot;,
		devid =&gt; 0x8c,
		logdev =&gt; 0x08,
		features =&gt; FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;SMSC SCH5504-NS Super IO&quot;,
		# No datasheet
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x79,
	}, {
		name =&gt; &quot;SMSC SCH5514D-NS Super IO&quot;,
		# No datasheet
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x83,
	}, {
		name =&gt; &quot;SMSC SCH5627 Super IO&quot;,
		driver =&gt; &quot;sch5627&quot;,
		devid =&gt; 0xc6,
		regs =&gt; {
			basereg_lsb =&gt; 0x66,
			basereg_msb =&gt; 0x67,
		},
		logdev =&gt; 0x0c,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;SMSC SCH5636 Super IO&quot;,
		driver =&gt; &quot;sch5636&quot;,
		devid =&gt; 0xc7,
		regs =&gt; {
			basereg_lsb =&gt; 0x66,
			basereg_msb =&gt; 0x67,
		},
		logdev =&gt; 0x0c,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}
);

# Non-standard SMSC chip list. These chips differ from the standard ones
# listed above in that the device ID register address is 0x0d instead of
# 0x20 (as specified by the ISA PNP spec).
@superio_ids_smsc_ns = (
	{
		name =&gt; &quot;SMSC FDC37C665 Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x65,
	}, {
		name =&gt; &quot;SMSC FDC37C666 Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x66,
	}, {
		name =&gt; &quot;SMSC FDC37C669 Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x03,
	}, {
		name =&gt; &quot;SMSC FDC37N769 Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x28,
	}, {
		name =&gt; &quot;SMSC LPC47N217 Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x7a,
	}, {
		name =&gt; &quot;SMSC LPC47N227 Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x5a,
	}, {
		name =&gt; &quot;SMSC LPC47N237 Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x13,
	}, {
		name =&gt; &quot;SMSC SIO10N268 Notebook IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x5b,
	}
);

@superio_ids_winbond = (
	{
		name =&gt; &quot;VIA VT1211 Super IO Sensors&quot;,
		driver =&gt; &quot;vt1211&quot;,
		devid =&gt; 0x3c,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;VIA VT1212 Super IO Lite&quot;,	# in 100 pin TQFP package
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x3e,
	}, {
		name =&gt; &quot;VIA VT1212 Super IO Lite&quot;,	# in 48 pin LQFP package
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x3f,
	}, {
		name =&gt; &quot;Winbond W83627HF/F/HG/G Super IO Sensors&quot;,
		# Also SMSC LPC61W492
		driver =&gt; &quot;w83627hf&quot;,
		devid =&gt; 0x52,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Winbond W83627SF/GF Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x59,
	}, {
		name =&gt; &quot;Winbond W83627THF/THG Super IO Sensors&quot;,
		driver =&gt; &quot;w83627hf&quot;,
		devid =&gt; 0x82,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Winbond W83637HF/HG Super IO Sensors&quot;,
		driver =&gt; &quot;w83627hf&quot;,
		devid =&gt; 0x70,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Winbond W83687THF Super IO Sensors&quot;,
		driver =&gt; &quot;w83627hf&quot;,
		devid =&gt; 0x85,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Winbond W83697HF/F/HG Super IO Sensors&quot;,
		driver =&gt; &quot;w83627hf&quot;,
		devid =&gt; 0x60,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Winbond W83697SF/UF/UG Super IO PWM&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x68,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Winbond W83627EHF/EF/EHG/EG Super IO Sensors&quot;,
		driver =&gt; &quot;w83627ehf&quot;,
		# W83627EHF datasheet says 0x886x but 0x8853 was seen, thus the
		# broader mask. W83627EHG was seen with ID 0x8863.
		devid =&gt; 0x8840,
		devid_mask =&gt; 0xFFC0,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Winbond W83627DHG Super IO Sensors&quot;,
		driver =&gt; &quot;w83627ehf&quot;,
		devid =&gt; 0xA020,
		devid_mask =&gt; 0xFFF0,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Winbond W83627DHG-P/W83527HG Super IO Sensors&quot;,
		driver =&gt; &quot;w83627ehf&quot;,
		devid =&gt; 0xB070,
		devid_mask =&gt; 0xFFF0,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Winbond W83627UHG/NCT6627UD Super IO Sensors&quot;,
		driver =&gt; &quot;w83627ehf&quot;,
		devid =&gt; 0xA230,
		devid_mask =&gt; 0xFFF0,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Winbond W83667HG Super IO Sensors&quot;,
		driver =&gt; &quot;w83627ehf&quot;,
		devid =&gt; 0xA510,
		devid_mask =&gt; 0xFFF0,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Nuvoton NCT6681D/NCT6682D eSIO&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0xB270,
		devid_mask =&gt; 0xFFF0,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Nuvoton W83667HG-B (NCT5571D) Super IO Sensors&quot;,
		driver =&gt; &quot;w83627ehf&quot;,
		devid =&gt; 0xB350,
		devid_mask =&gt; 0xFFF0,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Nuvoton W83677HG-I (NCT5572D/NCT6771F/NCT6772F/NCT6775F) Super IO Sensors&quot;,
		driver =&gt; &quot;w83627ehf&quot;,
		devid =&gt; 0xB470,
		devid_mask =&gt; 0xFFF0,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Winbond W83L517D Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x61,
	}, {
		name =&gt; &quot;Nuvoton NCT5573D/NCT5577D/NCT6776F Super IO Sensors&quot;,
		driver =&gt; &quot;nct6775&quot;,
		devid =&gt; 0xC330,
		devid_mask =&gt; 0xFFF0,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Nuvoton NCT5532D/NCT6779D Super IO Sensors&quot;,
		driver =&gt; &quot;nct6775&quot;,
		devid =&gt; 0xC560,
		devid_mask =&gt; 0xFFF0,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Nuvoton NCT6683D eSIO&quot;,
		driver =&gt; &quot;nct6683&quot;,
		devid =&gt; 0xC730,
		devid_mask =&gt; 0xFFF0,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Nuvoton NCT6791D Super IO Sensors&quot;,
		driver =&gt; &quot;nct6775&quot;,
		devid =&gt; 0xC800,
		devid_mask =&gt; 0xFFF0,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Nuvoton NCT6792D Super IO Sensors&quot;,
		driver =&gt; &quot;nct6775&quot;,
		devid =&gt; 0xC910,
		devid_mask =&gt; 0xFFF0,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Nuvoton NCT6793D Super IO Sensors&quot;,
		driver =&gt; &quot;nct6775&quot;,
		devid =&gt; 0xD120,
		devid_mask =&gt; 0xFFF0,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Nuvoton NCT6795D Super IO Sensors&quot;,
		driver =&gt; &quot;nct6775&quot;,
		devid =&gt; 0xD350,
		devid_mask =&gt; 0xFFF0,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Nuvoton NCT6796D Super IO Sensors&quot;,
		driver =&gt; &quot;nct6775&quot;,
		devid =&gt; 0xD420,
		devid_mask =&gt; 0xFFF0,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Nuvoton NCT6102D/NCT6104D/NCT6106D Super IO Sensors&quot;,
		driver =&gt; &quot;nct6775&quot;,
		devid =&gt; 0xC450,
		devid_mask =&gt; 0xFFF0,
		logdev =&gt; 0x0b,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Fintek F71805F/FG Super IO Sensors&quot;,
		driver =&gt; &quot;f71805f&quot;,
		devid =&gt; 0x0406,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Fintek F71808E Super IO Sensors&quot;,
		driver =&gt; &quot;f71882fg&quot;,
		devid =&gt; 0x0901,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Fintek F71808A Super IO Sensors&quot;,
		driver =&gt; &quot;f71882fg&quot;,
		devid =&gt; 0x1001,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Fintek F71862FG Super IO Sensors&quot;,
		driver =&gt; &quot;f71882fg&quot;,
		devid =&gt; 0x0601,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Fintek F71868A Super IO Sensors&quot;,
		driver =&gt; &quot;f71882fg&quot;,
		devid =&gt; 0x1106,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Fintek F71869F/E Super IO Sensors&quot;,
		driver =&gt; &quot;f71882fg&quot;,
		devid =&gt; 0x0814,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Fintek F71869A Super IO Sensors&quot;,
		driver =&gt; &quot;f71882fg&quot;,
		devid =&gt; 0x1007,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Fintek F71806FG/F71872FG Super IO Sensors&quot;,
		driver =&gt; &quot;f71805f&quot;,
		devid =&gt; 0x0341,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Fintek F71858DG Super IO Sensors&quot;,
		driver =&gt; &quot;f71882fg&quot;,
		devid =&gt; 0x0507,
		logdev =&gt; 0x02,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Fintek F71882FG/F71883FG Super IO Sensors&quot;,
		driver =&gt; &quot;f71882fg&quot;,
		devid =&gt; 0x0541,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Fintek F71889FG/F81801U Super IO Sensors&quot;,
		driver =&gt; &quot;f71882fg&quot;,
		devid =&gt; 0x0723,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Fintek F71889ED Super IO Sensors&quot;,
		driver =&gt; &quot;f71882fg&quot;,
		devid =&gt; 0x0909,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Fintek F71889A Super IO Sensors&quot;,
		driver =&gt; &quot;f71882fg&quot;,
		devid =&gt; 0x1005,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Fintek F81216D Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x0208,
	}, {
		name =&gt; &quot;Fintek F81218D Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x0206,
	}, {
		name =&gt; &quot;Fintek F81768D Super IO Sensors&quot;,
		driver =&gt; &quot;f71882fg&quot;,
		devid =&gt; 0x1210,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Fintek F81865F Super IO Sensors&quot;,
		driver =&gt; &quot;f71882fg&quot;,
		devid =&gt; 0x0704,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Fintek F81866D Super IO Sensors&quot;,
		driver =&gt; &quot;f71882fg&quot;,
		devid =&gt; 0x1010,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;Asus F8000 Super IO&quot;,
		driver =&gt; &quot;f71882fg&quot;,
		devid =&gt; 0x0581,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		# Shouldn&#039;t be in this family, but seems to be still.
		name =&gt; &quot;ITE IT8708F Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x8708,
	}, {
		# Shouldn&#039;t be in this family, but seems to be still.
		name =&gt; &quot;ITE IT8710F Super IO&quot;,
		driver =&gt; &quot;not-a-sensor&quot;,
		devid =&gt; 0x8710,
	}
);

@superio_ids_ite = (
	{
		name =&gt; &quot;ITE IT8603E Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8603,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8606E Super IO Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# it87
		devid =&gt; 0x8606,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8607E Super IO Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# it87
		devid =&gt; 0x8607,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8613E Super IO Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# it87
		devid =&gt; 0x8613,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8620E Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8620,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8622E Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8622,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8623E Super IO Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# it87
		devid =&gt; 0x8623,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8625E Super IO Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# it87
		devid =&gt; 0x8625,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8626E Super IO Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# it87
		devid =&gt; 0x8626,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8655E Super IO Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# it87
		devid =&gt; 0x8655,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8665E Super IO Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# it87
		devid =&gt; 0x8665,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8686E Super IO Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# it87
		devid =&gt; 0x8686,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8702F Super IO Fan Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x8702,
		logdev =&gt; 0x04,
		features =&gt; FEAT_FAN,
	}, {
		name =&gt; &quot;ITE IT8705F Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8705,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8712F Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8712,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8716F Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8716,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8718F Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8718,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8720F Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8720,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8721F/IT8758E Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8721,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8726F Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8726,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8728F Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8728,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8731F Super IO Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# it87
		devid =&gt; 0x8731,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8732F Super IO Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# it87
		devid =&gt; 0x8732,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8752F Super IO Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# it87
		devid =&gt; 0x8752,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8771E Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8771,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8772E Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8772,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8780F Super IO Sensors&quot;,
		driver =&gt; &quot;to-be-written&quot;,	# it87
		devid =&gt; 0x8780,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8781F Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8781,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8782F Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8782,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8783F Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8783,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8786E Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8786,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8790E Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8790,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8792E Super IO Sensors&quot;,
		driver =&gt; &quot;it87&quot;,
		devid =&gt; 0x8733,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}, {
		name =&gt; &quot;ITE IT8987D Embedded Controller&quot;,
		driver =&gt; &quot;to-be-written&quot;,
		devid =&gt; 0x8987,
		logdev =&gt; 0x04,
		features =&gt; FEAT_IN | FEAT_FAN | FEAT_TEMP,
	}
);

# Entries are grouped by family. Each family entry has the following fields:
#  family: The family name
#  guess (optional): Typical logical device address. This lets us do
#	generic probing if we fail to recognize the chip.
#  enter: The password sequence to write to the address register
#  chips: Array of chips
# The order of families matters, because we stop as soon as one family
# succeeds. So we have to list families with shorter password sequences
# first.
@superio_ids = (
	{
		family =&gt; &quot;National Semiconductor/ITE&quot;,
		enter =&gt;
		{
			0x2e =&gt; [],
			0x4e =&gt; [],
		},
		chips =&gt; \@superio_ids_natsemi,
	}, {
		family =&gt; &quot;SMSC&quot;,
		enter =&gt;
		{
			0x2e =&gt; [0x55],
			0x4e =&gt; [0x55],
		},
		chips =&gt; \@superio_ids_smsc,
		ns_detect =&gt; \&amp;smsc_ns_detect_superio,
		ns_chips =&gt; \@superio_ids_smsc_ns,
	}, {
		family =&gt; &quot;VIA/Winbond/Nuvoton/Fintek&quot;,
		guess =&gt; 0x290,
		enter =&gt;
		{
			0x2e =&gt; [0x87, 0x87],
			0x4e =&gt; [0x87, 0x87],
		},
		chips =&gt; \@superio_ids_winbond,
	}, {
		family =&gt; &quot;ITE&quot;,
		guess =&gt; 0x290,
		enter =&gt;
		{
			0x2e =&gt; [0x87, 0x01, 0x55, 0x55],
			0x4e =&gt; [0x87, 0x01, 0x55, 0xaa],
		},
		chips =&gt; \@superio_ids_ite,
	}
);

# Drivers for bridge, CPU and memory embedded sensors
# Each entry must have the following fields:
#  name: The device name
#  driver: The driver name. Put &quot;to-be-written&quot; if no driver is available.
#  detect: Detection callback function. No parameter will be passed to
#	this function, it must use global lists of PCI devices, CPU,
#	etc. It must return a confidence value, undef if no supported
#	CPU is found.
use vars qw(@cpu_ids);

@cpu_ids = (
	{
		name =&gt; &quot;Silicon Integrated Systems SIS5595&quot;,
		driver =&gt; &quot;sis5595&quot;,
		detect =&gt; \&amp;sis5595_pci_detect,
	}, {
		name =&gt; &quot;VIA VT82C686 Integrated Sensors&quot;,
		driver =&gt; &quot;via686a&quot;,
		detect =&gt; \&amp;via686a_pci_detect,
	}, {
		name =&gt; &quot;VIA VT8231 Integrated Sensors&quot;,
		driver =&gt; &quot;vt8231&quot;,
		detect =&gt; \&amp;via8231_pci_detect,
	}, {
		name =&gt; &quot;AMD K8 thermal sensors&quot;,
		driver =&gt; &quot;k8temp&quot;,
		detect =&gt; sub { amd_pci_detect(&#039;1103&#039;) },
	}, {
		name =&gt; &quot;AMD Family 10h thermal sensors&quot;,
		driver =&gt; &quot;k10temp&quot;,
		detect =&gt; \&amp;fam10h_pci_detect,
	}, {
		name =&gt; &quot;AMD Family 11h thermal sensors&quot;,
		driver =&gt; &quot;k10temp&quot;,
		detect =&gt; sub { amd_pci_detect(&#039;1303&#039;) },
	}, {
		name =&gt; &quot;AMD Family 12h and 14h thermal sensors&quot;,
		driver =&gt; &quot;k10temp&quot;,
		detect =&gt; sub { amd_pci_detect(&#039;1703&#039;) },
	}, {
		name =&gt; &quot;AMD Family 15h thermal sensors&quot;,
		driver =&gt; &quot;k10temp&quot;,
		detect =&gt; sub { amd_pci_detect(&#039;1603&#039;, &#039;1403&#039;, &#039;141d&#039;, &#039;1573&#039;, &#039;15b3&#039;) },
	}, {
		name =&gt; &quot;AMD Family 16h thermal sensors&quot;,
		driver =&gt; &quot;k10temp&quot;,
		detect =&gt; sub { amd_pci_detect(&#039;1533&#039;, &#039;1583&#039;) },
	}, {
		name =&gt; &quot;AMD Family 17h thermal sensors&quot;,
		driver =&gt; &quot;k10temp&quot;,
		detect =&gt; sub { amd_pci_detect(&#039;1463&#039;, &#039;15d0&#039;, &#039;1493&#039;) },
	}, {
		name =&gt; &quot;AMD Family 15h power sensors&quot;,
		driver =&gt; &quot;fam15h_power&quot;,
		detect =&gt; sub { amd_pci_detect(&#039;1604&#039;) },
	}, {
		name =&gt; &quot;AMD Family 16h power sensors&quot;,
		driver =&gt; &quot;fam15h_power&quot;,
		detect =&gt; sub { amd_pci_detect(&#039;1534&#039;) },
	}, {
		name =&gt; &quot;AMD Family 19h thermal sensors&quot;,
		driver =&gt; &quot;k10temp&quot;,
		detect =&gt; sub { amd_pci_detect(&#039;1653&#039;) },
	}, {
		name =&gt; &quot;Intel digital thermal sensor&quot;,
		driver =&gt; &quot;coretemp&quot;,
		detect =&gt; \&amp;coretemp_detect,
	}, {
		name =&gt; &quot;Intel AMB FB-DIMM thermal sensor&quot;,
		driver =&gt; &quot;i5k_amb&quot;,
		detect =&gt; \&amp;intel_amb_detect,
	}, {
		name =&gt; &quot;Intel 5500/5520/X58 thermal sensor&quot;,
		driver =&gt; &quot;i5500_temp&quot;,
		detect =&gt; \&amp;intel_5500_detect,
	}, {
		name =&gt; &quot;VIA C7 thermal sensor&quot;,
		driver =&gt; &quot;via-cputemp&quot;,
		detect =&gt; \&amp;via_c7_detect,
	}, {
		name =&gt; &quot;VIA Nano thermal sensor&quot;,
		driver =&gt; &quot;via-cputemp&quot;,
		detect =&gt; \&amp;via_nano_detect,
	}
);

#######################
# AUXILIARY FUNCTIONS #
#######################

# $_[0] is the sought value
# $_[1..] is the list to seek in
# Returns: 1 if found, 0 if not.
sub contains
{
	my $sought = shift;
	local $_;

	foreach (@_) {
		return 1 if $sought eq $_;
	}
	return 0;
}

# Address can be decimal or hexadecimal
sub valid_address
{
	my $value = shift;

	if ($value !~ m/^(0x[0-9a-f]+|[0-9]+)$/i) {
		print &quot;$value is not a valid address, sorry.\n&quot;;
		exit -1;
	}
	$value = oct($value) if $value =~ m/^0x/i;

	return $value;
}

sub parse_not_to_scan
{
	my ($min, $max, $to_parse) = @_;
	my @ranges = split /\s*,\s*/, $to_parse;
	my @res;
	my $range;

	foreach $range (@ranges) {
		my ($start, $end) = split /\s*-\s*/, $range;
		$start = valid_address($start);
		if (defined $end) {
			$end = valid_address($end);
			if ($end &lt;= $start) {
				print &quot;$start-$end is not a valid range, sorry.\n&quot;;
				exit -1;
			}
			$start = $min if $start &lt; $min;
			$end = $max if $end &gt; $max;
			push @res, ($start..$end);
		} else {
			push @res, $start if $start &gt;= $min and $start &lt;= $max;
		}
	}

	return sort { $a &lt;=&gt; $b } @res;
}

# $_[0]: Reference to list 1
# $_[1]: Reference to list 2
# Result: 0 if they have no elements in common, 1 if they have
# Elements must be numeric.
sub any_list_match
{
	my ($list1, $list2) = @_;
	my ($el1, $el2);

	foreach $el1 (@$list1) {
		foreach $el2 (@$list2) {
			return 1 if $el1 == $el2;
		}
	}
	return 0;
}

# $_[0]: Reference to base hash
# $_[1]: Reference to overlay hash
# Result: Overlayed hash
sub overlay_hash
{
	my ($base, $overlay) = @_;
	my %result = %{$base};

	foreach my $key (keys %{$overlay}) {
		$result{$key} = $overlay-&gt;{$key};
	}
	return %result;
}

# Read answer from stdin or accept default answer automatically
sub read_answer
{
	if ($opt{auto}) {
		print &quot;\n&quot;;
		return &quot;&quot;;
	}
	return &lt;STDIN&gt; || &quot;&quot;;
}

###################
# I/O PORT ACCESS #
###################

sub initialize_ioports
{
	if (sysopen(IOPORTS, &quot;/dev/port&quot;, O_RDWR)) {
		binmode(IOPORTS);
		return 1;
	}
	print STDERR &quot;/dev/port: $!\n&quot;;
	return 0;
}

sub close_ioports
{
	close(IOPORTS);
}

# $_[0]: port to read
# Returns: -1 on failure, read value on success.
sub inb
{
	my ($res, $nrchars);
	sysseek(IOPORTS, $_[0], 0) or return -1;
	$nrchars = sysread(IOPORTS, $res, 1);
	return -1 if not defined $nrchars or $nrchars != 1;
	$res = unpack(&quot;C&quot;, $res);
	return $res;
}

# $_[0]: port to write
# $_[1]: value to write
# We assume this can&#039;t fail.
sub outb
{
	sysseek(IOPORTS, $_[0], 0);
	syswrite(IOPORTS, pack(&quot;C&quot;, $_[1]), 1);
}

# $_[0]: Address register
# $_[1]: Data register
# $_[2]: Register to read
# Returns: read value
sub isa_read_byte
{
	outb($_[0], $_[2]);
	return inb($_[1]);
}

# $_[0]: Base address
# $_[1]: Register to read
# Returns: read value
# This one can be used for any ISA chip with index register at
# offset 5 and data register at offset 6.
sub isa_read_i5d6
{
	my ($addr, $reg) = @_;
	return isa_read_byte($addr + 5, $addr + 6, $reg);
}

#################
# AUTODETECTION #
#################

use vars qw($dev_i2c $sysfs_root $systemd_systemctl $systemd_system_dir);

sub initialize_conf
{
	my $use_devfs = 0;
	open(local *INPUTFILE, &quot;/proc/mounts&quot;) or die &quot;Can&#039;t access /proc/mounts!&quot;;
	local $_;
	while (&lt;INPUTFILE&gt;) {
		if (m@^\w+ /dev devfs @) {
			$use_devfs = 1;
			$dev_i2c = &#039;/dev/i2c/&#039;;
		}
		if (m@^\S+ (/\w+) sysfs @) {
			$sysfs_root = $1;
		}
	}
	close(INPUTFILE);

	# We need sysfs for many things
	if (!defined $sysfs_root) {
		print &quot;Sysfs not mounted?\n&quot;;
		exit -1;
	}

	my $use_udev = 0;
	if (open(*INPUTFILE, &#039;/etc/udev/udev.conf&#039;)) {
		while (&lt;INPUTFILE&gt;) {
			next unless m/^\s*udev_db\s*=\s*\&quot;([^&quot;]*)\&quot;/
				 || m/^\s*udev_db\s*=\s*(\S+)/;
			if (-e $1) {
				$use_udev = 1;
				$dev_i2c = &#039;/dev/i2c-&#039;;
			}
			last;
		}
		close(INPUTFILE);
	  }

	if (!$use_udev) {
		# Try some known default udev db locations, just in case
		if (-e &#039;/dev/.udev.tdb&#039; || -e &#039;/dev/.udev&#039;
		 || -e &#039;/dev/.udevdb&#039; || -e &#039;/run/udev&#039;) {
			$use_udev = 1;
			$dev_i2c = &#039;/dev/i2c-&#039;;
		}
	}

	if (!($use_devfs || $use_udev)) {
		if (! -c &#039;/dev/i2c-0&#039; &amp;&amp; -x &#039;/sbin/MAKEDEV&#039;) {
			system(&quot;/sbin/MAKEDEV i2c&quot;);
		}
		if (! -c &#039;/dev/i2c-0&#039; &amp;&amp; -x &#039;/dev/MAKEDEV&#039;) {
			system(&quot;/dev/MAKEDEV i2c&quot;);
		}
		if (-c &#039;/dev/i2c-0&#039;) {
			$dev_i2c = &#039;/dev/i2c-&#039;;
		} else { # default
			print &quot;No i2c device files found.\n&quot;;
			exit -1;
		}
	}

	# Detect systemd presence and paths
	if (-x &quot;/usr/bin/systemctl&quot;) {
		$systemd_systemctl = &quot;/usr/bin/systemctl&quot;;
	} elsif (-x &quot;/bin/systemctl&quot;) {
		$systemd_systemctl = &quot;/bin/systemctl&quot;;
	}

	if (-d &quot;/usr/lib/systemd/system&quot;) {
		$systemd_system_dir = &quot;/usr/lib/systemd/system&quot;;
	} elsif (-d &quot;/lib/systemd/system&quot;) {
		$systemd_system_dir = &quot;/lib/systemd/system&quot;;
	}
}

# [0] -&gt; VERSION
# [1] -&gt; PATCHLEVEL
# [2] -&gt; SUBLEVEL
# [3] -&gt; EXTRAVERSION
#
use vars qw($kernel_version @kernel_version $kernel_arch);

sub initialize_kernel_version
{
	chomp($kernel_version = `uname -r`);
	$kernel_version =~ /(\d+)\.(\d+)\.(\d+)(.*)/;
	@kernel_version = ($1, $2, $3, $4);
	chomp($kernel_arch = `uname -m`);

	# We only support kernels &gt;= 2.6.5
	if (!kernel_version_at_least(2, 6, 5)) {
		print &quot;Kernel version is unsupported (too old, &gt;= 2.6.5 needed)\n&quot;;
		exit -1;
	}
}

sub print_kernel_version
{
	printf &quot;# Kernel: \%d.\%d.\%d\%s \%s\n&quot;, @kernel_version, $kernel_arch;
}

sub kernel_version_at_least
{
	my ($vers, $plvl, $slvl) = @_;
	return 1 if ($kernel_version[0] &gt; $vers ||
		     ($kernel_version[0] == $vers &amp;&amp;
		      ($kernel_version[1] &gt; $plvl ||
		       ($kernel_version[1] == $plvl &amp;&amp;
			($kernel_version[2] &gt;= $slvl)))));
	return 0;
}

# @cpu is a list of reference to hashes, one hash per CPU.
# Each entry has the following keys: vendor_id, cpu family, model,
# model name and stepping, directly taken from /proc/cpuinfo.
use vars qw(@cpu);

sub initialize_cpu_list
{
	local $_;
	my $entry;

	open(local *INPUTFILE, &quot;/proc/cpuinfo&quot;) or die &quot;Can&#039;t access /proc/cpuinfo!&quot;;
	while (&lt;INPUTFILE&gt;) {
		if (m/^processor\s*:\s*(\d+)/) {
			push @cpu, $entry if scalar keys(%{$entry}); # Previous entry
			$entry = { # New entry
				nr =&gt; $1,
				vendor_id =&gt; &quot;undefined&quot;,
			};
			next;
		}
		if (m/^(vendor_id|cpu family|model|model name|stepping|cpuid level|cpu|revision)\s*:\s*(.+)$/) {
			my $k = $1;
			my $v = $2;
			$v =~ s/\s+/ /g;	# Merge multiple spaces
			$v =~ s/ $//;		# Trim trailing space
			$entry-&gt;{$k} = $v;
			next;
		}
	}
	close(INPUTFILE);
	push @cpu, $entry if scalar keys(%{$entry}); # Last entry
}

sub print_cpu_info
{
	my $cpu = $cpu[0];
	if ($kernel_arch =~ m/^ppc(64(le)?)?$/) {
		print &quot;# Processor: $cpu-&gt;{cpu} ($cpu-&gt;{revision})\n&quot;;
	} elsif ($kernel_arch =~ m/^arm/) {
		print &quot;# Processor: $cpu-&gt;{&#039;model name&#039;}\n&quot;;
	} elsif (exists $cpu-&gt;{&#039;model name&#039;} &amp;&amp; exists $cpu-&gt;{&#039;cpu family&#039;}
	         &amp;&amp; exists $cpu-&gt;{&#039;model&#039;} &amp;&amp; exists $cpu-&gt;{&#039;stepping&#039;}) {
		print &quot;# Processor: $cpu-&gt;{&#039;model name&#039;} ($cpu-&gt;{&#039;cpu family&#039;}/$cpu-&gt;{model}/$cpu-&gt;{stepping})\n&quot;;
	} else {
		print &quot;# Cannot show processor info on $kernel_arch architecture.\n&quot;;
	}
}

# @i2c_adapters is a list of references to hashes, one hash per I2C/SMBus
# adapter present on the system. Each entry has the following keys: path,
# parent, name (directly taken from sysfs), driver and autoload.
use vars qw(@i2c_adapters);

# Find out whether the driver would be automatically loaded by the modalias
# mechanism.
sub device_driver_autoloads
{
	my $device = shift;
	
	my $modalias = sysfs_device_attribute($device, &quot;modalias&quot;);
	return 0 unless defined($modalias);

	# At the moment we only handle PCI and USB drivers. Other driver
	# types, most notably platform and i2c drivers, do not follow the
	# device driver model to the letter, and often create their own
	# devices. Such drivers appear to be autoloaded when they are not.
	return 0 unless $modalias =~ m/^(pci|usb):/;

	my $result = `modprobe -n -v --first-time $modalias 2&gt;&amp;1`;
	return ($result =~ m/^insmod/ ||
		$result =~ m/\balready in kernel\b/);
}

sub initialize_i2c_adapters_list
{
	my ($entry, $base_dir, $have_i2c_adapter_class);
	local $_;

	if (-d &quot;${sysfs_root}/class/i2c-adapter&quot;) {
		$base_dir = &quot;${sysfs_root}/class/i2c-adapter&quot;;
		$have_i2c_adapter_class = 1;
	} else {
		$base_dir = &quot;${sysfs_root}/bus/i2c/devices&quot;;
		$have_i2c_adapter_class = 0;
	}
	opendir(local *ADAPTERS, $base_dir) or return;

	while (defined($_ = readdir(ADAPTERS))) {
		next unless m/^i2c-(\d+)$/;
		my $nr = $1;
		$entry = {}; # New entry

		# The layout in sysfs has changed over the years
		if ($have_i2c_adapter_class) {
			my $link = readlink(&quot;${base_dir}/i2c-$nr/device&quot;);
			if (!defined $link) {
				$entry-&gt;{path} = &quot;${base_dir}/i2c-$nr&quot;;
				$entry-&gt;{parent} = &quot;${base_dir}/i2c-$nr&quot;;
			} elsif ($link =~ m/^(.*)\/i2c-$nr$/) {
				$entry-&gt;{path} = &quot;${base_dir}/i2c-$nr/device&quot;;
				$entry-&gt;{parent} = &quot;${base_dir}/i2c-$nr/$1&quot;;
			}
		}

		# This works for all recent kernels (with or without
		# CONFIG_I2C_COMPAT)
		if (!defined $entry-&gt;{path}) {
			my $link = readlink(&quot;${base_dir}/i2c-$nr&quot;);
			$entry-&gt;{path} = &quot;${base_dir}/i2c-$nr&quot;;
			$link =~ s/(\/i2c-[0-9]+)+$//;	# Handle multiplexers too
			$entry-&gt;{parent} = &quot;${base_dir}/$link&quot;;
		}

		$entry-&gt;{name} = sysfs_device_attribute($entry-&gt;{path}, &quot;name&quot;);
		next if $entry-&gt;{name} eq &quot;ISA main adapter&quot;;

		# First try to get the I2C adapter driver name from sysfs,
		# and if it fails, fall back to searching our list of known
		# I2C adapters.
		$entry-&gt;{driver} = sysfs_device_module($entry-&gt;{parent})
				|| find_i2c_adapter_driver($entry-&gt;{name})
				|| &#039;UNKNOWN&#039;;

		$entry-&gt;{autoload} = device_driver_autoloads($entry-&gt;{parent});
		$i2c_adapters[$nr] = $entry;
	}
	closedir(ADAPTERS);
}

# %hwmon_autoloaded is a list of hwmon drivers which are autoloaded
# (typically by udev.) We don&#039;t need to load these drivers ourselves.
use vars qw(%hwmon_autoloaded);

sub initialize_hwmon_autoloaded
{
	my $class_dir = &quot;${sysfs_root}/class/hwmon&quot;;
	opendir(local *HWMON, $class_dir) or return;

	my ($hwmon, $driver);
	while (defined($hwmon = readdir(HWMON))) {
		next unless $hwmon =~ m/^hwmon\d+$/;

		$driver = sysfs_device_module(&quot;${class_dir}/$hwmon/device&quot;);
		next unless defined($driver);

		if (device_driver_autoloads(&quot;${class_dir}/$hwmon/device&quot;)) {
			$driver =~ tr/-/_/;
			$hwmon_autoloaded{$driver}++
		}
	}
	closedir(HWMON);
}

sub hwmon_is_autoloaded
{
	my $driver = shift;
	$driver =~ tr/-/_/;
	return exists($hwmon_autoloaded{$driver});
}

###########
# MODULES #
###########

use vars qw(%modules_builtin %modules_list %modules_supported @modules_we_loaded);

sub initialize_modules_list
{
	local ($_, *INPUTFILE);

	# Starting with kernel 2.6.33, a list of built-in modules is available
	if (open(*INPUTFILE, &quot;/lib/modules/$kernel_version/modules.builtin&quot;)) {
		while (&lt;INPUTFILE&gt;) {
			tr/-/_/;
			$modules_builtin{$1} = 1 if m/\/([^\/]+)\.ko$/;
		}
		close(INPUTFILE);
	}

	# List all loaded modules
	open(*INPUTFILE, &quot;/proc/modules&quot;) or return;
	while (&lt;INPUTFILE&gt;) {
		$modules_list{$1} = 1 if m/^(\S*)/;
	}
}

sub is_module_loaded
{
	my $module = shift;
	$module =~ tr/-/_/;
	return exists $modules_list{$module} || exists $modules_builtin{$module};
}

sub is_module_builtin
{
	my $module = shift;
	$module =~ tr/-/_/;
	return exists $modules_builtin{$module};
}

sub load_module
{
	my $module = shift;

	return if is_module_loaded($module);

	system(&quot;modprobe&quot;, $module);
	if (($? &gt;&gt; 8) != 0) {
		print &quot;Failed to load module $module.\n&quot;;
		return -1;
	}

	print &quot;Module $module loaded successfully.\n&quot;;
	push @modules_we_loaded, $module;

	# Update the list of loaded modules
	my $normalized = $module;
	$normalized =~ tr/-/_/;
	$modules_list{$normalized} = 1;
}

# udev may take some time to create device nodes when loading modules
sub udev_settle
{
	if (!(-x &quot;/sbin/udevadm&quot; &amp;&amp; system(&quot;/sbin/udevadm settle&quot;) == 0)
	 &amp;&amp; !(-x &quot;/sbin/udevsettle&quot; &amp;&amp; system(&quot;/sbin/udevsettle&quot;) == 0)) {
		sleep(1);
	}
}

sub initialize_modules_supported
{
	foreach my $chip (@chip_ids) {
		next if $chip-&gt;{driver} eq &quot;to-be-written&quot;;
		next if $chip-&gt;{driver} eq &quot;use-isa-instead&quot;;

		my $normalized = $chip-&gt;{driver};
		$normalized =~ tr/-/_/;
		$modules_supported{$normalized}++;
	}
}

sub unload_modules
{
	return unless @modules_we_loaded;

	# Attempt to unload all kernel drivers we loaded ourselves
	while (my $module = pop @modules_we_loaded) {
		print &quot;Unloading $module... &quot;;
		system(&quot;modprobe -r $module 2&gt; /dev/null&quot;);
		if (($? &gt;&gt; 8) == 0) {
			print &quot;OK\n&quot;;
		} else {
			print &quot;failed\n&quot;;
		}
	}
	print &quot;\n&quot;;
}

############
# DMI DATA #
############

use vars qw(%dmi $dmidecode_ok);

# Returns: 1 if dmidecode is recent enough, 0 if not
# Cache the result in case it is needed again later.
sub check_dmidecode_version
{
	return $dmidecode_ok if defined $dmidecode_ok;

	my $version;
	if (open(local *DMIDECODE, &quot;dmidecode --version 2&gt;/dev/null |&quot;)) {
		$version = &lt;DMIDECODE&gt;;
		close(DMIDECODE);
		chomp $version if defined $version;
	}

	if (!defined $version
	 || !($version =~ m/^(\d+).(\d+)$/)
	 || !(($1 == 2 &amp;&amp; $2 &gt;= 7) || $1 &gt; 2)) {
		print &quot;# DMI data unavailable, please consider installing dmidecode 2.7\n&quot;.
		      &quot;# or later for better results.\n&quot;;
		$dmidecode_ok = 0;
	} else {
		$dmidecode_ok = 1;
	}

	return $dmidecode_ok;
}

sub initialize_dmi_data
{
	my %items = (
		# sysfs file name =&gt; dmidecode string name
		sys_vendor =&gt; &#039;system-manufacturer&#039;,
		product_name =&gt; &#039;system-product-name&#039;,
		product_version =&gt; &#039;system-version&#039;,
		board_vendor =&gt; &#039;baseboard-manufacturer&#039;,
		board_name =&gt; &#039;baseboard-product-name&#039;,
		board_version =&gt; &#039;baseboard-product-name&#039;,
		chassis_type =&gt; &#039;chassis-type&#039;,
	);
	# Many BIOS have broken DMI data, filter it out
	my %fake = (
		&#039;system manufacturer&#039; =&gt; 1,
		&#039;system product name&#039; =&gt; 1,
		&#039;system name&#039; =&gt; 1,
		&#039;system version&#039; =&gt; 1,
		&#039;to be filled by o.e.m.&#039; =&gt; 1,
	);
	my $dmi_id_dir;

	# First try reading the strings from sysfs if available
	if (-d ($dmi_id_dir = &quot;$sysfs_root/devices/virtual/dmi/id&quot;)	# kernel &gt;= 2.6.28
	 || -d ($dmi_id_dir = &quot;$sysfs_root/class/dmi/id&quot;)) {
		foreach my $k (keys %items) {
			$dmi{$k} = sysfs_device_attribute($dmi_id_dir, $k);
		}
	} else {
		# Else fallback on calling dmidecode
		return unless check_dmidecode_version();

		foreach my $k (keys %items) {
			next unless open(local *DMIDECODE,
					 &quot;dmidecode -s $items{$k} 2&gt;/dev/null |&quot;);
			$dmi{$k} = &lt;DMIDECODE&gt;;
			close(DMIDECODE);
		}
	}

	# Strip trailing white-space, discard empty field
	foreach my $k (keys %dmi) {
		if (!defined $dmi{$k}) {
			delete $dmi{$k};
			next;
		}
		$dmi{$k} =~ s/\s*$//;
		delete $dmi{$k} if $dmi{$k} eq &#039;&#039; || exists $fake{lc($dmi{$k})};
	}
}

sub print_dmi_summary
{
	my ($system, $board);
	if (defined $dmi{sys_vendor} &amp;&amp; defined $dmi{product_name}) {
		$system = &quot;$dmi{sys_vendor} $dmi{product_name}&quot;;
	}
	if (defined $dmi{board_vendor} &amp;&amp; defined $dmi{board_name}) {
		$board = &quot;$dmi{board_vendor} $dmi{board_name}&quot;;
	}
	
	if (defined $system) {
		print &quot;# System: $system&quot;;
		print &quot; [$dmi{product_version}]&quot; if defined $dmi{product_version};
		print &quot; (laptop)&quot; if (is_laptop());
		print &quot;\n&quot;;
	}
	print &quot;# Board: $board\n&quot; if defined $board
				  &amp;&amp; (!defined $system || $system ne $board);
}

sub dmi_match
{
	my $key = shift;
	my $value;

	return unless defined $dmi{$key};
	while (defined ($value = shift)) {
		return 1 if $dmi{$key} =~ m/\b$value\b/i;
	}
	return 0;
}

sub is_laptop
{
	return 0 unless $dmi{chassis_type};
	return 1 if $dmi{chassis_type} =~ m/(Portable|Laptop|Notebook|Hand Held)/i;
	return 1 if $dmi{chassis_type} =~ m/^(8|9|10|11|14)$/;
	return 0;
}

#################
# SYSFS HELPERS #
#################

# From a sysfs device path, return the module name, or undef
sub sysfs_device_module
{
	my $device = shift;

	my $link = readlink(&quot;$device/driver/module&quot;);
	return unless defined $link;
	return basename($link);
}

# From a sysfs device path, return the driver name, or undef
sub sysfs_device_driver
{
	my $device = shift;

	my $link = readlink(&quot;$device/driver&quot;);
	return unless defined $link;
	return basename($link);
}

# From a sysfs device path, return the subsystem name, or undef
sub sysfs_device_subsystem
{
	my $device = shift;

	my $link = readlink(&quot;$device/subsystem&quot;);
	return unless defined $link;
	return basename($link);
}

# From a sysfs device path and an attribute name, return the attribute
# value, or undef
sub sysfs_device_attribute
{
	my ($device, $attr) = @_;
	my $value;

	open(local *FILE, &quot;$device/$attr&quot;) or return;
	$value = &lt;FILE&gt;;
	close(FILE);
	return unless defined $value;

	chomp($value);
	return $value;
}

##############
# PCI ACCESS #
##############

use vars qw(%pci_list);

# This function returns a list of hashes. Each hash has some PCI information:
# &#039;domain&#039;, &#039;bus&#039;, &#039;slot&#039; and &#039;func&#039; uniquely identify a PCI device in a
# computer; &#039;vendid&#039; and &#039;devid&#039; uniquely identify a type of device.
# &#039;class&#039; lets us spot unknown SMBus adapters.
sub read_sys_dev_pci
{
	my $devices = shift;
	my ($dev, @pci_list);

	opendir(local *DEVICES, &quot;$devices&quot;)
		or return \@pci_list;

	while (defined($dev = readdir(DEVICES))) {
		my %record;
		next unless $dev =~
			m/^(?:([\da-f]+):)?([\da-f]+):([\da-f]+)\.([\da-f]+)$/;

		$record{domain} = hex $1;
		$record{bus} = hex $2;
		$record{slot} = hex $3;
		$record{func} = hex $4;

		$record{vendid} = oct sysfs_device_attribute(&quot;$devices/$dev&quot;,
							     &quot;vendor&quot;);
		$record{devid} = oct sysfs_device_attribute(&quot;$devices/$dev&quot;,
							    &quot;device&quot;);
		$record{class} = (oct sysfs_device_attribute(&quot;$devices/$dev&quot;,
							     &quot;class&quot;)) &gt;&gt; 8;

		push @pci_list, \%record;
	}

	return \@pci_list;
}

sub initialize_pci
{
	my $pci_list;
	local $_;

	$pci_list = read_sys_dev_pci(&quot;$sysfs_root/bus/pci/devices&quot;);

	# Note that we lose duplicate devices at this point, but we don&#039;t
	# really care. What matters to us is which unique devices are present,
	# not how many of each.
	%pci_list = map {
		sprintf(&quot;%04x:%04x&quot;, $_-&gt;{vendid}, $_-&gt;{devid}) =&gt; $_
	} @{$pci_list};
}

#####################
# ADAPTER DETECTION #
#####################

# Build and return a PCI device&#039;s bus ID
sub pci_busid
{
	my $device = shift;
	my $busid;

	$busid = sprintf(&quot;\%02x:\%02x.\%x&quot;,
			 $device-&gt;{bus}, $device-&gt;{slot}, $device-&gt;{func});
	$busid = sprintf(&quot;\%04x:&quot;, $device-&gt;{domain}) . $busid
		if defined $device-&gt;{domain};

	return $busid;
}

sub adapter_pci_detection
{
	my ($key, $device, $try, %smbus, $count);

	# Build a list of detected SMBus devices
	foreach $key (keys %pci_list) {
		$device = $pci_list{$key};
		$smbus{$key}++
			if exists $device-&gt;{class} &amp;&amp;
			   ($device-&gt;{class} == 0x0c01 ||	# Access Bus
			    $device-&gt;{class} == 0x0c05);	# SMBus
	}

	# Loop over the known I2C/SMBus adapters
	foreach $try (@pci_adapters) {
		$key = sprintf(&quot;%04x:%04x&quot;, $try-&gt;{vendid}, $try-&gt;{devid});
		next unless exists $pci_list{$key};

		$device = $pci_list{$key};

		if ($try-&gt;{driver} eq &quot;to-be-written&quot;) {
			printf &quot;No known driver for device \%s: \%s\n&quot;,
			       pci_busid($device), $try-&gt;{procid};
		} else {
			printf &quot;Using driver `\%s&#039; for device \%s: \%s\n&quot;,
			       $try-&gt;{driver}, pci_busid($device),
			       $try-&gt;{procid};
			$count++;
			load_module($try-&gt;{driver});
		}

		# Delete from detected SMBus device list
		delete $smbus{$key};
	}

	# Now see if there are unknown SMBus devices left
	foreach $key (keys %smbus) {
		$device = $pci_list{$key};
		printf &quot;Found unknown SMBus adapter \%04x:\%04x at \%s.\n&quot;,
		       $device-&gt;{vendid}, $device-&gt;{devid}, pci_busid($device);
	}

	print &quot;Sorry, no supported PCI bus adapters found.\n&quot;
		unless $count;
}

# $_[0]: Adapter description as found in sysfs
sub find_i2c_adapter_driver
{
	my $name = shift;
	my $entry;

	foreach $entry (@i2c_adapter_names) {
		return $entry-&gt;{driver}
			if $name =~ $entry-&gt;{match};
	}
}

#############################
# I2C AND SMBUS /DEV ACCESS #
#############################

# This should really go into a separate module/package.

# These are copied from &lt;linux/i2c-dev.h&gt;

use constant IOCTL_I2C_SLAVE	=&gt; 0x0703;
use constant IOCTL_I2C_FUNCS	=&gt; 0x0705;
use constant IOCTL_I2C_SMBUS	=&gt; 0x0720;

use constant SMBUS_READ		=&gt; 1;
use constant SMBUS_WRITE	=&gt; 0;

use constant SMBUS_QUICK	=&gt; 0;
use constant SMBUS_BYTE		=&gt; 1;
use constant SMBUS_BYTE_DATA	=&gt; 2;
use constant SMBUS_WORD_DATA	=&gt; 3;

use constant I2C_FUNC_SMBUS_QUICK	=&gt; 0x00010000;
use constant I2C_FUNC_SMBUS_READ_BYTE	=&gt; 0x00020000;
use constant I2C_FUNC_SMBUS_READ_BYTE_DATA	=&gt; 0x00080000;

# Get the i2c adapter&#039;s functionalities
# $_[0]: Reference to an opened filehandle
# Returns: -1 on failure, functionality bitfield on success.
sub i2c_get_funcs
{
	my $file = shift;
	my $funcs = pack(&quot;L&quot;, 0); # Allocate space

	ioctl($file, IOCTL_I2C_FUNCS, $funcs) or return -1;
	$funcs = unpack(&quot;L&quot;, $funcs);

	return $funcs;
}

# Select the device to communicate with through its address.
# $_[0]: Reference to an opened filehandle
# $_[1]: Address to select
# Returns: 0 on failure, 1 on success.
sub i2c_set_slave_addr
{
	my ($file, $addr) = @_;

	# Reset register data cache
	@i2c_byte_cache = ();

	$addr += 0; # Make sure it&#039;s a number not a string
	ioctl($file, IOCTL_I2C_SLAVE, $addr) or return 0;
	return 1;
}

# i2c_smbus_access is based upon the corresponding C function (see
# &lt;linux/i2c-dev.h&gt;). You should not need to call this directly.
# $_[0]: Reference to an opened filehandle
# $_[1]: SMBUS_READ for reading, SMBUS_WRITE for writing
# $_[2]: Command (usually register number)
# $_[3]: Transaction kind (SMBUS_BYTE, SMBUS_BYTE_DATA, etc.)
# $_[4]: Reference to an array used for input/output of data
# Returns: 0 on failure, 1 on success.
# Note that we need to get back to Integer boundaries through the &#039;x2&#039;
# in the pack. This is very compiler-dependent; I wish there was some other
# way to do this.
sub i2c_smbus_access
{
	my ($file, $read_write, $command, $size, $data) = @_;
	my $data_array = pack(&quot;C32&quot;, @$data);
	my $ioctl_data = pack(&quot;C2x2Ip&quot;, $read_write, $command, $size,
			      $data_array);

	ioctl($file, IOCTL_I2C_SMBUS, $ioctl_data) or return 0;
	@{$_[4]} = unpack(&quot;C32&quot;, $data_array);
	return 1;
}

# $_[0]: Reference to an opened filehandle
# Returns: -1 on failure, the read byte on success.
sub i2c_smbus_read_byte
{
	my ($file) = @_;
	my @data;

	i2c_smbus_access($file, SMBUS_READ, 0, SMBUS_BYTE, \@data)
		or return -1;
	return $data[0];
}

# $_[0]: Reference to an opened filehandle
# $_[1]: Command byte (usually register number)
# Returns: -1 on failure, the read byte on success.
# Read byte data values are cached by default. As we keep reading the
# same registers over and over again in the detection functions, and
# SMBus can be slow, caching results in a big performance boost.
sub i2c_smbus_read_byte_data
{
	my ($file, $command, $nocache) = @_;
	my @data;

	return $i2c_byte_cache[$command]
		if !$nocache &amp;&amp; exists $i2c_byte_cache[$command];

	i2c_smbus_access($file, SMBUS_READ, $command, SMBUS_BYTE_DATA, \@data)
		or return -1;
	return ($i2c_byte_cache[$command] = $data[0]);
}

# $_[0]: Reference to an opened filehandle
# $_[1]: Command byte (usually register number)
# Returns: -1 on failure, the read word on success.
# Use this function with care, some devices don&#039;t like word reads,
# so you should do as much of the detection as possible using byte reads,
# and only start using word reads when there is a good chance that
# the detection will succeed.
# Note: some devices use the wrong endianness.
sub i2c_smbus_read_word_data
{
	my ($file, $command) = @_;
	my @data;
	i2c_smbus_access($file, SMBUS_READ, $command, SMBUS_WORD_DATA, \@data)
		or return -1;
	return $data[0] + 256 * $data[1];
}

# $_[0]: Reference to an opened filehandle
# $_[1]: Address
# $_[2]: Functionalities of this i2c adapter
# Returns: 1 on successful probing, 0 else.
# This function is meant to prevent AT24RF08 corruption and write-only
# chips locks. This is done by choosing the best probing method depending
# on the address range.
sub i2c_probe
{
	my ($file, $addr, $funcs) = @_;

	if (($addr &gt;= 0x50 &amp;&amp; $addr &lt;= 0x5F)
	 || ($addr &gt;= 0x30 &amp;&amp; $addr &lt;= 0x37)) {
		# This covers all EEPROMs we know of, including page protection
		# addresses. Note that some page protection addresses will not
		# reveal themselves with this, because they ack on write only,
		# but this is probably better since some EEPROMs write-protect
		# themselves permanently on almost any write to their page
		# protection address.
		return 0 unless ($funcs &amp; I2C_FUNC_SMBUS_READ_BYTE);
		return i2c_smbus_access($file, SMBUS_READ, 0, SMBUS_BYTE, []);
	} elsif ($addr == 0x73) {
		# Special case for FSC chips, as at least the Syleus locks
		# up with our regular probe code. Note that to our current
		# knowledge only FSC chips live on this address, and for them
		# this probe method is safe.
		return 0 unless ($funcs &amp; I2C_FUNC_SMBUS_READ_BYTE_DATA);
		return i2c_smbus_access($file, SMBUS_READ, 0, SMBUS_BYTE_DATA, []);
	} else {
		return 0 unless ($funcs &amp; I2C_FUNC_SMBUS_QUICK);
		return i2c_smbus_access($file, SMBUS_WRITE, 0, SMBUS_QUICK, []);
	}
}

# $_[0]: Reference to an opened file handle
# Returns: 1 if the device is safe to access, 0 else.
# This function is meant to prevent access to 1-register-only devices,
# which are designed to be accessed with SMBus receive byte and SMBus send
# byte transactions (i.e. short reads and short writes) and treat SMBus
# read byte as a real write followed by a read. The device detection
# routines would write random values to the chip with possibly very nasty
# results for the hardware. Note that this function won&#039;t catch all such
# chips, as it assumes that reads and writes relate to the same register,
# but that&#039;s the best we can do.
sub i2c_safety_check
{
	my ($file) = @_;
	my $data;

	# First we receive a byte from the chip, and remember it.
	$data = i2c_smbus_read_byte($file);
	return 1 if ($data &lt; 0);

	# We receive a byte again; very likely to be the same for
	# 1-register-only devices.
	return 1 if (i2c_smbus_read_byte($file) != $data);

	# Then we try a standard byte read, with a register offset equal to
	# the byte we received; we should receive the same byte value in return.
	return 1 if (i2c_smbus_read_byte_data($file, $data) != $data);

	# Then we try a standard byte read, with a slightly different register
	# offset; we should again receive the same byte value in return.
	return 1 if (i2c_smbus_read_byte_data($file, $data ^ 1) != ($data ^ 1));

	# Apprently this is a 1-register-only device, restore the original
	# register value and leave it alone.
	i2c_smbus_read_byte_data($file, $data);
	return 0;
}

####################
# ADAPTER SCANNING #
####################

use vars qw(%chips_detected);

# We will build a complicated structure %chips_detected here, being a hash
# where keys are driver names and values are detected chip information in
# the form of a list of hashes of type &#039;detect_data&#039;.

# Type detect_data:
# A hash
#  with field &#039;i2c_devnr&#039;, contianing the /dev/i2c-* number of this
#       adapter (if this is an I2C detection)
#  with field &#039;i2c_addr&#039;, containing the I2C address of the detection;
#       (if this is an I2C detection)
#  with field &#039;i2c_sub_addrs&#039;, containing a reference to a list of
#       other I2C addresses (if this is an I2C detection)
#  with field &#039;isa_addr&#039; containing the ISA address this chip is on
#       (if this is an ISA detection)
#  with field &#039;conf&#039;, containing the confidence level of this detection
#  with field &#039;chipname&#039;, containing the chip name
#  with optional field &#039;alias_detect&#039;, containing a reference to an alias
#       detection function for this chip

# This adds a detection to the above structure.
# Not all possibilities of i2c_addr and i2c_sub_addrs are exhausted.
# In all normal cases, it should be all right.
# $_[0]: chip driver
# $_[1]: reference to data hash
# Returns: Nothing
sub add_i2c_to_chips_detected
{
	my ($chipdriver, $datahash) = @_;
	my ($i, $detected_ref, $detected_entry, $driver,
	    $put_in_detected, @hash_addrs, @entry_addrs);

	# Find out whether our new entry should go into the detected list
	# or not. We compare all i2c addresses; if at least one matches,
	# but our confidence value is lower, we assume this is a misdetection,
	# in which case we simply discard our new entry.
	@hash_addrs = ($datahash-&gt;{i2c_addr});
	push @hash_addrs, @{$datahash-&gt;{i2c_sub_addrs}}
		if exists $datahash-&gt;{i2c_sub_addrs};
	$put_in_detected = 1;
 FIND_LOOP:
	foreach $detected_ref (values %chips_detected) {
		foreach $detected_entry (@{$detected_ref}) {
			next unless defined $detected_entry-&gt;{i2c_addr};
			@entry_addrs = ($detected_entry-&gt;{i2c_addr});
			push @entry_addrs, @{$detected_entry-&gt;{i2c_sub_addrs}}
				if exists $detected_entry-&gt;{i2c_sub_addrs};
			if ($detected_entry-&gt;{i2c_devnr} == $datahash-&gt;{i2c_devnr} &amp;&amp;
			    any_list_match(\@entry_addrs, \@hash_addrs)) {
				if ($detected_entry-&gt;{conf} &gt;= $datahash-&gt;{conf}) {
					$put_in_detected = 0;
				}
				last FIND_LOOP;
			}
		}
	}

	return unless $put_in_detected;

	# Here, we discard all entries which match at least in one main or
	# sub address. This may not be the best idea to do, as it may remove
	# detections without replacing them with second-best ones. Too bad.
	foreach $driver (keys %chips_detected) {
		$detected_ref = $chips_detected{$driver};
		for ($i = @$detected_ref-1; $i &gt;=0; $i--) {
			next unless defined $detected_ref-&gt;[$i]-&gt;{i2c_addr};
			@entry_addrs = ($detected_ref-&gt;[$i]-&gt;{i2c_addr});
			push @entry_addrs, @{$detected_ref-&gt;[$i]-&gt;{i2c_sub_addrs}}
				if exists $detected_ref-&gt;[$i]-&gt;{i2c_sub_addrs};
			if ($detected_ref-&gt;[$i]-&gt;{i2c_devnr} == $datahash-&gt;{i2c_devnr} &amp;&amp;
			    any_list_match(\@entry_addrs, \@hash_addrs)) {
				splice @$detected_ref, $i, 1;
				delete $chips_detected{$driver}
					if (!@$detected_ref);
			}
		}
	}

	# Now add the new entry to detected
	$chips_detected{$chipdriver} = []
		unless exists $chips_detected{$chipdriver};
	push @{$chips_detected{$chipdriver}}, $datahash;
}

# Fake i2c drivers such as &quot;not-a-sensor&quot; or &quot;use-isa-instead&quot; have to be
# inserted so that confidence comparison can be performed. But then we have
# to filter them out so that the user doesn&#039;t get confused.
sub filter_out_fake_i2c_drivers
{
	delete $chips_detected{&quot;not-a-sensor&quot;};
	delete $chips_detected{&quot;use-isa-instead&quot;};
}

# This adds a detection to the above structure.
# $_[0]: chip driver
# $_[1]: reference to data hash
sub add_isa_to_chips_detected
{
	my ($chipdriver, $datahash) = @_;
	my ($i, $new_detected_ref, $detected_ref);

	# First determine where the hash has to be added.
	$chips_detected{$chipdriver} = []
		unless exists $chips_detected{$chipdriver};
	$new_detected_ref = $chips_detected{$chipdriver};

	# Find out whether our new entry should go into the detected list
	# or not. We only compare main isa_addr here, of course.
	foreach $detected_ref (values %chips_detected) {
		for ($i = 0; $i &lt; @{$detected_ref}; $i++) {
			if (exists $detected_ref-&gt;[$i]-&gt;{isa_addr} and
			    exists $datahash-&gt;{isa_addr} and
			    $detected_ref-&gt;[$i]-&gt;{isa_addr} == $datahash-&gt;{isa_addr}) {
				if ($detected_ref-&gt;[$i]-&gt;{conf} &lt; $datahash-&gt;{conf}) {
					splice @$detected_ref, $i, 1;
					push @$new_detected_ref, $datahash;
				}
				return;
			}
		}
	}

	# Not found? OK, put it in the detected list
	push @$new_detected_ref, $datahash;
}

# $_[0]: reference to an array of chips which may be aliases of each other
sub find_aliases
{
	my $detected = shift;
	my ($isa, $i2c, $dev, $alias_detect, $is_alias);

	for ($isa = 0; $isa &lt; @{$detected}; $isa++) {
		# Look for chips with an ISA address but no I2C address
		next unless defined $detected-&gt;[$isa];
		next unless $detected-&gt;[$isa]-&gt;{isa_addr};
		next if defined $detected-&gt;[$isa]-&gt;{i2c_addr};
		# Additionally, the chip must possibly have I2C aliases
		next unless defined $detected-&gt;[$isa]-&gt;{alias_detect};

		for ($i2c = 0; $i2c &lt; @{$detected}; $i2c++) {
			# Look for chips with an I2C address but no ISA address
			next unless defined $detected-&gt;[$i2c];
			next unless defined $detected-&gt;[$i2c]-&gt;{i2c_addr};
			next if $detected-&gt;[$i2c]-&gt;{isa_addr};
			# Additionally, it must have the same chip name
			next unless $detected-&gt;[$i2c]-&gt;{chipname} eq
				    $detected-&gt;[$isa]-&gt;{chipname};

			# We have potential aliases, check if they actually are
			$dev = $dev_i2c.$detected-&gt;[$i2c]-&gt;{i2c_devnr};
			open(local *FILE, $dev) or
				print(&quot;Can&#039;t open $dev\n&quot;),
				next;
			binmode(FILE);
			i2c_set_slave_addr(\*FILE, $detected-&gt;[$i2c]-&gt;{i2c_addr}) or
				print(&quot;Can&#039;t set I2C address for $dev\n&quot;),
				next;

			if (initialize_ioports()) {
				$alias_detect = $detected-&gt;[$isa]-&gt;{alias_detect};
				$is_alias = &amp;$alias_detect($detected-&gt;[$isa]-&gt;{isa_addr},
							   \*FILE,
							   $detected-&gt;[$i2c]-&gt;{i2c_addr});
				close_ioports();
			}
			close(FILE);

			next unless $is_alias;
			# This is an alias: copy the I2C data into the ISA
			# entry, then discard the I2C entry
			$detected-&gt;[$isa]-&gt;{i2c_devnr} = $detected-&gt;[$i2c]-&gt;{i2c_devnr};
			$detected-&gt;[$isa]-&gt;{i2c_addr} = $detected-&gt;[$i2c]-&gt;{i2c_addr};
			$detected-&gt;[$isa]-&gt;{i2c_sub_addr} = $detected-&gt;[$i2c]-&gt;{i2c_sub_addr};
			undef $detected-&gt;[$i2c];
			last;
		}
	}

	# The loops above may have made the chip list sparse, make it
	# compact again
	for ($isa = 0; $isa &lt; @{$detected}; ) {
		if (defined($detected-&gt;[$isa])) {
			$isa++;
		} else {
			splice @{$detected}, $isa, 1;
		}
	}
}

# From the list of known I2C/SMBus devices, build a list of I2C addresses
# which are worth probing. There&#039;s no point in probing an address for which
# we don&#039;t know a single device, and probing some addresses has caused
# random trouble in the past.
sub i2c_addresses_to_scan
{
	my @used;
	my @addresses;
	my $addr;

	foreach my $chip (@chip_ids) {
		next unless defined $chip-&gt;{i2c_addrs};
		foreach $addr (@{$chip-&gt;{i2c_addrs}}) {
			$used[$addr]++;
		}
	}

	for ($addr = 0x03; $addr &lt;= 0x77; $addr++) {
		push @addresses, $addr if $used[$addr];
	}
	return \@addresses;
}

# $_[0]: The number of the adapter to scan
# $_[1]: Address
sub add_busy_i2c_address
{
	my ($adapter_nr, $addr) = @_;
	# If the address is busy, we can normally find out which driver
	# requested it (if the kernel is recent enough, at least 2.6.16 and
	# later are known to work), and we assume it is the right one.
	my ($device, $driver, $module, $new_hash);

	$device = sprintf(&quot;$sysfs_root/bus/i2c/devices/\%d-\%04x&quot;,
			  $adapter_nr, $addr);
	$driver = sysfs_device_driver($device);
	$module = sysfs_device_module($device);

	if (!defined($driver)) {
		printf(&quot;Client at address 0x%02x can not be probed - &quot;.
		       &quot;unload all client drivers first!\n&quot;, $addr);
		return;
	}

	$new_hash = {
		conf =&gt; 6, # Arbitrary confidence
		i2c_addr =&gt; $addr,
		chipname =&gt; sysfs_device_attribute($device, &quot;name&quot;)
			 || &quot;unknown&quot;,
		i2c_devnr =&gt; $adapter_nr,
	};

	printf &quot;Client found at address 0x\%02x\n&quot;, $addr;
	if (defined($module)) {
		printf &quot;Handled by driver `\%s&#039; (already loaded), chip type `\%s&#039;\n&quot;,
		       $module, $new_hash-&gt;{chipname};
	} else {
		printf &quot;Handled by driver `\%s&#039; (built-in), chip type `\%s&#039;\n&quot;,
		       $driver, $new_hash-&gt;{chipname};
		# Let&#039;s hope that the driver name matches the module name
		$module = $driver;
	}

	# Only add it to the list if this is something we would have detected,
	# else we end up with random i2c chip drivers listed (for example
	# media/video drivers.)
	if (exists $modules_supported{$module}) {
		add_i2c_to_chips_detected($module, $new_hash);
	} else {
		print &quot;    (note: this is probably NOT a sensor chip!)\n&quot;;
	}
}

# $_[0]: The number of the adapter to scan
# $_[1]: Address
# $_[2]: Chip being probed
sub probe_free_i2c_address
{
	my ($adapter_nr, $addr, $chip) = @_;
	my ($conf, @other_addr, $new_hash);

	printf(&quot;\%-60s&quot;, sprintf(&quot;Probing for `\%s&#039;... &quot;, $chip-&gt;{name}));
	if (($conf, @other_addr) = &amp;{$chip-&gt;{i2c_detect}} (\*FILE, $addr)) {
		if ($chip-&gt;{driver} eq &quot;not-a-sensor&quot;) {
			print &quot;Yes\n&quot;,
			      &quot;    (confidence $conf, not a hardware monitoring chip&quot;;
		} else {
			print &quot;Success!\n&quot;,
			      &quot;    (confidence $conf, driver `$chip-&gt;{driver}&#039;&quot;;
		}
		if (@other_addr) {
			print &quot;, other addresses:&quot;;
			@other_addr = sort @other_addr;
			foreach my $other_addr (@other_addr) {
				printf(&quot; 0x%02x&quot;, $other_addr);
			}
		}
		print &quot;)\n&quot;;

		$new_hash = {
			conf =&gt; $conf,
			i2c_addr =&gt; $addr,
			chipname =&gt; $chip-&gt;{name},
			i2c_devnr =&gt; $adapter_nr,
		};
		if (@other_addr) {
			my @other_addr_copy = @other_addr;
			$new_hash-&gt;{i2c_sub_addrs} = \@other_addr_copy;
		}
		add_i2c_to_chips_detected($chip-&gt;{driver}, $new_hash);
	} else {
		print &quot;No\n&quot;;
	}
}

# $_[0]: The device to check (PCI or not)
# Returns: PCI class of the adapter if available, 0 if not
sub get_pci_class
{
	my ($device) = @_;
	my ($subsystem, $class);

	$subsystem = sysfs_device_subsystem($device);
	return 0 unless defined $subsystem;
	return 0x0300 if $subsystem eq &quot;drm&quot;;	# Graphics card
	return 0 unless $subsystem eq &quot;pci&quot;;

	$class = sysfs_device_attribute($device, &quot;class&quot;);
	return 0 unless defined $class;
	$class = oct($class) if $class =~ /^0/;
	return $class &gt;&gt; 8;
}

# $_[0]: The number of the adapter to scan
sub scan_i2c_adapter
{
	my ($adapter_nr, $smbus_default) = @_;
	my ($funcs, $chip, $addr, $class, $default, $input, @not_to_scan);

	$class = get_pci_class($i2c_adapters[$adapter_nr]-&gt;{parent});
	# Do not probe adapters on multimedia and graphics cards by default
	if (($class &amp; 0xff00) == 0x0400 || ($class &amp; 0xff00) == 0x0300) {
		$default = 0;
	} elsif ($class == 0x0c01 || $class == 0x0c05
	      || find_i2c_adapter_driver($i2c_adapters[$adapter_nr]-&gt;{name})) {
		$default = $smbus_default;
	} else {
		$default = 1;
	}

	printf &quot;Next adapter: $i2c_adapters[$adapter_nr]-&gt;{name} (i2c-$adapter_nr)\n&quot;.
	       &quot;Do you want to scan it? (\%s/selectively): &quot;,
	       $default ? &quot;YES/no&quot; : &quot;yes/NO&quot;;

	$input = read_answer();
	if ($input =~ /^\s*n/i
	 || (!$default &amp;&amp; $input !~ /^\s*[ys]/i)) {
		print &quot;\n&quot;;
		return;
	}

	if ($input =~ /^\s*s/i) {
		print &quot;Please enter one or more addresses not to scan. Separate them with commas.\n&quot;,
		      &quot;You can specify a range by using dashes. Example: 0x58-0x5f,0x69.\n&quot;,
		      &quot;Addresses: &quot;;
		$input = read_answer();
		chomp($input);
		@not_to_scan = parse_not_to_scan(0x03, 0x77, $input);
	} elsif (($class &amp; 0xff00) == 0x0300) {
		# Skip EDID and DDC/CI addresses by default on graphics
		# adapters. Also skip address 0x4f which was reported in a
		# display corruption case.
		@not_to_scan = parse_not_to_scan(0x03, 0x77, &quot;0x37, 0x50-0x57, 0x4f&quot;);
	}

	open(local *FILE, &quot;$dev_i2c$adapter_nr&quot;) or
		(print &quot;Can&#039;t open $dev_i2c$adapter_nr\n&quot;), return;
	binmode(FILE);

	# Can we probe this adapter?
	$funcs = i2c_get_funcs(\*FILE);
	if ($funcs &lt; 0) {
		print &quot;Adapter failed to provide its functionalities, skipping.\n&quot;;
		return;
	}
	if (!($funcs &amp; (I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_READ_BYTE | I2C_FUNC_SMBUS_READ_BYTE_DATA))) {
		print &quot;Adapter cannot be probed, skipping.\n&quot;;
		return;
	}
	if (~$funcs &amp; (I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_READ_BYTE | I2C_FUNC_SMBUS_READ_BYTE_DATA)) {
		print &quot;Adapter doesn&#039;t support all probing functions.\n&quot;,
		      &quot;Some addresses won&#039;t be probed.\n&quot;;
	}

	# Now scan each address in turn
	foreach $addr (@{$i2c_addresses_to_scan}) {
		# As the not_to_scan list is sorted, we can check it fast
		shift @not_to_scan # User skipped an address which we didn&#039;t intend to probe anyway
			while (@not_to_scan and $not_to_scan[0] &lt; $addr);
		if (@not_to_scan and $not_to_scan[0] == $addr) {
			shift @not_to_scan;
			next;
		}

		if (!i2c_set_slave_addr(\*FILE, $addr)) {
			add_busy_i2c_address($adapter_nr, $addr);
			next;
		}

		next unless i2c_probe(\*FILE, $addr, $funcs);
		printf &quot;Client found at address 0x%02x\n&quot;, $addr;
		if (!i2c_safety_check(\*FILE)) {
			print &quot;Seems to be a 1-register-only device, skipping.\n&quot;;
			next;
		}

		$| = 1;
		foreach $chip (@chip_ids, @non_hwmon_chip_ids) {
			next unless exists $chip-&gt;{i2c_addrs}
				 &amp;&amp; contains($addr, @{$chip-&gt;{i2c_addrs}});
			probe_free_i2c_address($adapter_nr, $addr, $chip);
		}
		$| = 0;
	}
	print &quot;\n&quot;;
}

sub scan_isa_bus
{
	my $chip_list_ref = shift;
	my ($chip, $addr, $conf);

	$| = 1;
	foreach $chip (@{$chip_list_ref}) {
		next if not exists $chip-&gt;{isa_addrs} or not exists $chip-&gt;{isa_detect};
		foreach $addr (@{$chip-&gt;{isa_addrs}}) {
			printf(&quot;\%-60s&quot;, sprintf(&quot;Probing for `\%s&#039; at 0x\%x... &quot;,
						 $chip-&gt;{name}, $addr));
			$conf = &amp;{$chip-&gt;{isa_detect}} ($addr);
			print(&quot;No\n&quot;), next if not defined $conf;
			print &quot;Success!\n&quot;;
			printf &quot;    (confidence %d, driver `%s&#039;)\n&quot;, $conf, $chip-&gt;{driver};
			my $new_hash = {
				conf =&gt; $conf,
				isa_addr =&gt; $addr,
				chipname =&gt; $chip-&gt;{name},
				alias_detect =&gt; $chip-&gt;{alias_detect},
			};
			add_isa_to_chips_detected($chip-&gt;{driver}, $new_hash);
		}
	}
	$| = 0;
}

use vars qw(%standard_superio);

# The following are taken from the PNP ISA spec (so it&#039;s supposed
# to be common to all Super I/O chips):
#  devidreg: The device ID register(s)
#  logdevreg: The logical device register
#  actreg: The activation register within the logical device
#  actmask: The activation bit in the activation register
#  basereg_*: The I/O base registers within the logical device
%standard_superio = (
	devidreg =&gt; 0x20,
	logdevreg =&gt; 0x07,
	actreg =&gt; 0x30,
	actmask =&gt; 0x01,
	basereg_msb =&gt; 0x60,
	basereg_lsb =&gt; 0x61,
);

sub exit_superio
{
	my ($addrreg, $datareg) = @_;

	# Some chips (SMSC, Winbond) want this
	outb($addrreg, 0xaa);

	# Return to &quot;Wait For Key&quot; state (PNP-ISA spec)
	outb($addrreg, 0x02);
	outb($datareg, 0x02);
}

# Guess if an unknown Super-I/O chip has sensors
sub guess_superio_ld
{
	my ($addrreg, $datareg, $typical_addr) = @_;
	my ($oldldn, $ldn, $addr);

	# Save logical device number
	outb($addrreg, $standard_superio{logdevreg});
	$oldldn = inb($datareg);

	for ($ldn = 0; $ldn &lt; 16; $ldn++) {
		# Select logical device
		outb($addrreg, $standard_superio{logdevreg});
		outb($datareg, $ldn);

		# Read base I/O address
		outb($addrreg, $standard_superio{basereg_msb});
		$addr = inb($datareg) &lt;&lt; 8;
		outb($addrreg, $standard_superio{basereg_lsb});
		$addr |= inb($datareg);
		next unless ($addr &amp; 0xfff8) == $typical_addr;

		printf &quot;    (logical device \%X has address 0x\%x, could be sensors)\n&quot;,
		       $ldn, $addr;
		last;
	}

	# Be nice, restore original logical device
	outb($addrreg, $standard_superio{logdevreg});
	outb($datareg, $oldldn);
}

# Returns: features bitmask if device added to chips_detected, 0 if not
sub probe_superio
{
	my ($addrreg, $datareg, $chip) = @_;
	my ($val, $addr);
	my %superio;

	# Use chip-specific registers if provided
	if (exists $chip-&gt;{regs}) {
		%superio = overlay_hash(\%standard_superio, $chip-&gt;{regs});
	} else {
		%superio = %standard_superio;
	}

	if (exists $chip-&gt;{check}) {
		return 0 unless $chip-&gt;{check}($addrreg, $datareg);
	}

	printf &quot;\%-60s&quot;, &quot;Found `$chip-&gt;{name}&#039;&quot;;

	# Does it have hardware monitoring capabilities?
	if (!exists $chip-&gt;{driver}) {
		print &quot;\n    (no information available)\n&quot;;
		return 0;
	}
	if ($chip-&gt;{driver} eq &quot;not-a-sensor&quot;) {
		print &quot;\n    (no hardware monitoring capabilities)\n&quot;;
		return 0;
	}
	if ($chip-&gt;{driver} eq &quot;via-smbus-only&quot;) {
		print &quot;\n    (hardware monitoring capabilities accessible via SMBus only)\n&quot;;
		return FEAT_SMBUS;
	}
	if (!exists $chip-&gt;{logdev}) {
		print &quot;\n    (no support yet)\n&quot;;
		return 0;
	}

	# Switch to the sensor logical device
	outb($addrreg, $superio{logdevreg});
	outb($datareg, $chip-&gt;{logdev});

	# Get the IO base address
	outb($addrreg, $superio{basereg_msb});
	$addr = inb($datareg);
	outb($addrreg, $superio{basereg_lsb});
	$addr = ($addr &lt;&lt; 8) | inb($datareg);

	# Check the activation register and base address
	outb($addrreg, $superio{actreg});
	$val = inb($datareg);
	if (!($val &amp; $superio{actmask})) {
		if ($addr &amp;&amp; $addr != 0xffff) {
			printf &quot;\n    (address 0x\%x, but not activated)\n&quot;, $addr;
		} else {
			print &quot;\n    (but not activated)\n&quot;;
		}
		return 0;
	}
	if ($addr == 0 || $addr == 0xffff) {
		print &quot;\n    (but no address specified)\n&quot;;
		return 0;
	}

	print &quot;Success!\n&quot;;
	printf &quot;    (address 0x\%x, driver `%s&#039;)\n&quot;, $addr, $chip-&gt;{driver};
	my $new_hash = {
		conf =&gt; 9,
		isa_addr =&gt; $addr,
		chipname =&gt; $chip-&gt;{name}
	};
	add_isa_to_chips_detected($chip-&gt;{driver}, $new_hash);
	return $chip-&gt;{features};
}

# Detection routine for non-standard SMSC Super I/O chips
# $_[0]: Super I/O LPC config/index port
# $_[1]: Super I/O LPC data port
# $_[2]: Reference to array of non-standard chips
# Return values: 1 if non-standard chip found, 0 otherwise
sub smsc_ns_detect_superio
{
	my ($addrreg, $datareg, $ns_chips) = @_;
	my ($val, $chip);

	# read alternate device ID register
	outb($addrreg, 0x0d);
	$val = inb($datareg);
	return 0 if $val == 0x00 || $val == 0xff;

	print &quot;Yes\n&quot;;

	foreach $chip (@{$ns_chips}) {
		if ($chip-&gt;{devid} == $val) {
			probe_superio($addrreg, $datareg, $chip);
			return 1;
		}
	}

	printf(&quot;Found unknown non-standard chip with ID 0x%02x\n&quot;, $val);
	return 1;
}

# Returns: features supported by the device added, if any
sub scan_superio
{
	my ($addrreg, $datareg) = @_;
	my ($val, $found);
	my $features = 0;

	printf(&quot;Probing for Super-I/O at 0x\%x/0x\%x\n&quot;, $addrreg, $datareg);

	$| = 1;
	# reset state to avoid false positives
	exit_superio($addrreg, $datareg);
	foreach my $family (@superio_ids) {
		printf(&quot;\%-60s&quot;, &quot;Trying family `$family-&gt;{family}&#039;... &quot;);
		# write the password
		foreach $val (@{$family-&gt;{enter}-&gt;{$addrreg}}) {
			outb($addrreg, $val);
		}
		# call the non-standard detection routine first if it exists
		if (defined($family-&gt;{ns_detect}) &amp;&amp;
		    &amp;{$family-&gt;{ns_detect}}($addrreg, $datareg, $family-&gt;{ns_chips})) {
			last;
		}

		# did it work?
		outb($addrreg, $standard_superio{devidreg});
		$val = inb($datareg);
		outb($addrreg, $standard_superio{devidreg} + 1);
		$val = ($val &lt;&lt; 8) | inb($datareg);
		if ($val == 0x0000 || $val == 0xffff) {
			print &quot;No\n&quot;;
			next;
		}
		print &quot;Yes\n&quot;;

		$found = 0;
		foreach my $chip (@{$family-&gt;{chips}}) {
			if (($chip-&gt;{devid} &gt; 0xff &amp;&amp;
			     ($val &amp; ($chip-&gt;{devid_mask} || 0xffff)) == $chip-&gt;{devid})
			 || ($chip-&gt;{devid} &lt;= 0xff &amp;&amp;
			     ($val &gt;&gt; 8) == $chip-&gt;{devid})) {
				$features |= probe_superio($addrreg, $datareg, $chip);
				$found++;
			}
		}

		if (!$found) {
			printf(&quot;Found unknown chip with ID 0x%04x\n&quot;, $val);
			# Guess if a logical device could correspond to sensors
			guess_superio_ld($addrreg, $datareg, $family-&gt;{guess})
				if defined $family-&gt;{guess};
		}
		last;
	}
	exit_superio($addrreg, $datareg);
	$| = 0;
	return $features;
}

sub scan_cpu
{
	my $entry = shift;
	my $confidence;

	printf(&quot;\%-60s&quot;, &quot;$entry-&gt;{name}... &quot;);
	if (defined ($confidence = $entry-&gt;{detect}())) {
		print &quot;Success!\n&quot;;
		printf &quot;    (driver `%s&#039;)\n&quot;, $entry-&gt;{driver};
		my $new_hash = {
			conf =&gt; $confidence,
			chipname =&gt; $entry-&gt;{name},
		};
		add_isa_to_chips_detected($entry-&gt;{driver}, $new_hash);
	} else {
		print &quot;No\n&quot;;
	}
}

##################
# CHIP DETECTION #
##################

# This routine allows you to dynamically update the chip detection list.
# The most common use is to allow for different chip to driver mappings
# based on different linux kernels
sub chip_special_cases
{
	# Some chip to driver mappings depend on the environment
	foreach my $chip (@chip_ids) {
		if (ref($chip-&gt;{driver}) eq &#039;CODE&#039;) {
			$chip-&gt;{driver} = $chip-&gt;{driver}-&gt;();
		}
	}

	# Also fill the fake driver name of non-hwmon chips
	foreach my $chip (@non_hwmon_chip_ids) {
		$chip-&gt;{driver} = &quot;not-a-sensor&quot;;
	}
}

# Each function returns a confidence value. The higher this value, the more
# sure we are about this chip. This may help overrule false positives,
# although we also attempt to prevent false positives in the first place.

# Each function returns a list. The first element is the confidence value;
# Each element after it is an SMBus address. In this way, we can detect
# chips with several SMBus addresses. The SMBus address for which the
# function was called is never returned.

# All I2C detection functions below take at least 2 parameters:
# $_[0]: Reference to the file descriptor to access the chip
# $_[1]: Address
# Some of these functions which can detect more than one type of device,
# take a third parameter:
# $_[2]: Chip to detect

# Registers used: 0x58
sub mtp008_detect
{
	my ($file, $addr) = @_;
	return if i2c_smbus_read_byte_data($file, 0x58) != 0xac;
	return 3;
}

# Chip to detect: 0 = LM78, 2 = LM79
# Registers used:
#   0x40: Configuration
#   0x48: Full I2C Address
#   0x49: Device ID
sub lm78_detect
{
	my ($file, $addr, $chip) = @_;
	my $reg;

	return unless i2c_smbus_read_byte_data($file, 0x48) == $addr;
	return unless (i2c_smbus_read_byte_data($file, 0x40) &amp; 0x80) == 0x00;

	$reg = i2c_smbus_read_byte_data($file, 0x49);
	return if $chip == 0 &amp;&amp; ($reg != 0x00 &amp;&amp; $reg != 0x20 &amp;&amp; $reg != 0x40);
	return if $chip == 2 &amp;&amp; ($reg &amp; 0xfe) != 0xc0;

	# Explicitly prevent misdetection of Winbond chips
	$reg = i2c_smbus_read_byte_data($file, 0x4f);
	return if $reg == 0xa3 || $reg == 0x5c;

	return 6;
}

# Chip to detect: 0 = LM75, 1 = DS75, 2 = LM75A
# Registers used:
#   0x00: Temperature
#   0x01: Configuration
#   0x02: Hysteresis
#   0x03: Overtemperature Shutdown
#   0x04-0x07: No registers
#   0x07: Device ID (LM75A only)
# The first detection step is based on the fact that the LM75 has only
# four registers, and cycles addresses over 8-byte boundaries. We use the
# 0x04-0x07 addresses (unused) to improve the reliability. These are not
# real registers and will always return the last returned value. This isn&#039;t
# documented.
# Note that register 0x00 may change, so we can&#039;t use the modulo trick on it.
# The DS75 is a bit different, it doesn&#039;t cycle over 8-byte boundaries, and
# all register addresses from 0x04 to 0x0f behave like 0x04-0x07 do for
# the LM75.
# And the LM75A is again different, it cycles over 8-byte boundaries, but
# registers 0x04-0x06 return 0xff. Thankfully it has a device ID register
# at 0x07.
# Not all devices enjoy SMBus read word transactions, so we use read byte
# transactions even for the 16-bit registers. The low bits aren&#039;t very
# useful for detection anyway.
sub lm75_detect
{
	my ($file, $addr, $chip) = @_;
	my $i;
	my $cur = i2c_smbus_read_byte_data($file, 0x00);
	my $conf = i2c_smbus_read_byte_data($file, 0x01);
	my ($maxreg, $hyst, $os, $dev_id);

	if ($chip == 2) {	# LM75A
		$dev_id = i2c_smbus_read_byte_data($file, 0x07);
		return if $dev_id != 0xA1;

		$hyst = i2c_smbus_read_byte_data($file, 0x02);
		$os = i2c_smbus_read_byte_data($file, 0x03);

		for $i (0x04 .. 0x06) {
			return if i2c_smbus_read_byte_data($file, $i) != 0xff;
		}
	} else {		# LM75 or DS75
		$maxreg = $chip == 1 ? 0x0f : 0x07;
		$hyst = i2c_smbus_read_byte_data($file, 0x02, NO_CACHE);
		for $i (0x04 .. $maxreg) {
			return if i2c_smbus_read_byte_data($file, $i, NO_CACHE) != $hyst;
		}

		$os = i2c_smbus_read_byte_data($file, 0x03, NO_CACHE);
		for $i (0x04 .. $maxreg) {
			return if i2c_smbus_read_byte_data($file, $i, NO_CACHE) != $os;
		}
	}

	if ($chip != 1) {	# LM75 or LM75A
		for ($i = 8; $i &lt;= 248; $i += 40) {
			return if i2c_smbus_read_byte_data($file, $i + 0x01) != $conf
			       or i2c_smbus_read_byte_data($file, $i + 0x02) != $hyst
			       or i2c_smbus_read_byte_data($file, $i + 0x03) != $os;
			return if $chip == 2
			      and i2c_smbus_read_byte_data($file, $i + 0x07) != $dev_id;
		}
	}

	# All registers hold the same value, obviously a misdetection
	return if $conf == $cur and $cur == $hyst and $cur == $os;

	# Unused bits
	return if $chip != 1 and ($conf &amp; 0xe0);
	return if $chip == 1 and ($conf &amp; 0x80);

	# Most probable value ranges
	return 6 if $cur &lt;= 100 and ($hyst &gt;= 10 &amp;&amp; $hyst &lt;= 125)
		and ($os &gt;= 20 &amp;&amp; $os &lt;= 127) and $hyst &lt; $os;
	return 3;
}

# Registers used:
#   0x00: Temperature
#   0x01: Configuration
#   0x02: High Limit
#   0x03: Low Limit
#   0x04: Status
#   0x07: Manufacturer ID and Product ID
sub lm73_detect
{
	my ($file, $addr) = @_;

	my $conf = i2c_smbus_read_byte_data($file, 0x01);
	my $status = i2c_smbus_read_byte_data($file, 0x04);

	# Bits that always return 0
	return if ($conf &amp; 0x0c) or ($status &amp; 0x10);

	# Test with byte read first to avoid confusing other chips
	return if i2c_smbus_read_byte_data($file, 0x07) != 0x01
	       or i2c_smbus_read_word_data($file, 0x07) != 0x9001;

	# Make sure the chip supports SMBus read word transactions
	my $cur = i2c_smbus_read_word_data($file, 0x00);
	return if $cur &lt; 0;
	my $high = i2c_smbus_read_word_data($file, 0x02);
	return if $high &lt; 0;
	my $low = i2c_smbus_read_word_data($file, 0x03);
	return if $low &lt; 0;
	return if ($cur &amp; 0x0300) or (($high | $low) &amp; 0x1f00);

	return 3;
}

# Registers used:
#   0x00: Temperature
#   0x01: Configuration
#   0x02: Hysteresis
#   0x03: Overtemperature Shutdown
#   0x04: Low limit
#   0x05: High limit
#   0x06-0x07: No registers
# The first detection step is based on the fact that the LM77 has only
# six registers, and cycles addresses over 8-byte boundaries. We use the
# 0x06-0x07 addresses (unused) to improve the reliability. These are not
# real registers and will always return the last returned value. This isn&#039;t
# documented.
# Note that register 0x00 may change, so we can&#039;t use the modulo trick on it.
# Not all devices enjoy SMBus read word transactions, so we use read byte
# transactions even for the 16-bit registers at first. We only use read word
# transactions in the end when we are already almost certain that we have an
# LM77 chip.
sub lm77_detect
{
	my ($file, $addr) = @_;
	my $i;
	my $cur = i2c_smbus_read_byte_data($file, 0x00);
	my $conf = i2c_smbus_read_byte_data($file, 0x01);
	my $hyst = i2c_smbus_read_byte_data($file, 0x02);
	my $os = i2c_smbus_read_byte_data($file, 0x03);

	my $low = i2c_smbus_read_byte_data($file, 0x04, NO_CACHE);
	return if i2c_smbus_read_byte_data($file, 0x06, NO_CACHE) != $low;
	return if i2c_smbus_read_byte_data($file, 0x07, NO_CACHE) != $low;

	my $high = i2c_smbus_read_byte_data($file, 0x05, NO_CACHE);
	return if i2c_smbus_read_byte_data($file, 0x06, NO_CACHE) != $high;
	return if i2c_smbus_read_byte_data($file, 0x07, NO_CACHE) != $high;

	for ($i = 8; $i &lt;= 248; $i += 40) {
		return if i2c_smbus_read_byte_data($file, $i + 0x01) != $conf;
		return if i2c_smbus_read_byte_data($file, $i + 0x02) != $hyst;
		return if i2c_smbus_read_byte_data($file, $i + 0x03) != $os;
		return if i2c_smbus_read_byte_data($file, $i + 0x04) != $low;
		return if i2c_smbus_read_byte_data($file, $i + 0x05) != $high;
	}

	# All registers hold the same value, obviously a misdetection
	return if $conf == $cur and $cur == $hyst
	      and $cur == $os and $cur == $low and $cur == $high;

	# Unused bits
	return if ($conf &amp; 0xe0)
	       or (($cur &gt;&gt; 4) != 0 &amp;&amp; ($cur &gt;&gt; 4) != 0xf)
	       or (($hyst &gt;&gt; 4) != 0 &amp;&amp; ($hyst &gt;&gt; 4) != 0xf)
	       or (($os &gt;&gt; 4) != 0 &amp;&amp; ($os &gt;&gt; 4) != 0xf)
	       or (($low &gt;&gt; 4) != 0 &amp;&amp; ($low &gt;&gt; 4) != 0xf)
	       or (($high &gt;&gt; 4) != 0 &amp;&amp; ($high &gt;&gt; 4) != 0xf);

	# Make sure the chip supports SMBus read word transactions
	foreach $i (0x00, 0x02, 0x03, 0x04, 0x05) {
		return if i2c_smbus_read_word_data($file, $i) &lt; 0;
	}

	return 3;
}

# Chip to detect: 0 = LM92, 1 = LM76, 2 = MAX6633/MAX6634/MAX6635
# Registers used:
#   0x01: Configuration (National Semiconductor only)
#   0x02: Hysteresis
#   0x03: Critical Temp
#   0x04: Low Limit
#   0x05: High Limit
#   0x07: Manufacturer ID (LM92 only)
# One detection step is based on the fact that the LM92 and clones have a
# limited number of registers, which cycle modulo 16 address values.
# Note that register 0x00 may change, so we can&#039;t use the modulo trick on it.
# Not all devices enjoy SMBus read word transactions, so we use read byte
# transactions even for the 16-bit registers at first. We only use read
# word transactions in the end when we are already almost certain that we
# have an LM92 chip or compatible.
sub lm92_detect
{
	my ($file, $addr, $chip) = @_;

	my $conf = i2c_smbus_read_byte_data($file, 0x01);
	my $hyst = i2c_smbus_read_byte_data($file, 0x02);
	my $crit = i2c_smbus_read_byte_data($file, 0x03);
	my $low = i2c_smbus_read_byte_data($file, 0x04);
	my $high = i2c_smbus_read_byte_data($file, 0x05);

	return if $conf == 0 and $hyst == 0 and $crit == 0
		and $low == 0 and $high == 0;

	# Unused bits
	return if ($chip == 0 || $chip == 1)
	      and ($conf &amp; 0xE0);

	for (my $i = 0; $i &lt;= 240; $i += 16) {
		return if i2c_smbus_read_byte_data($file, $i + 0x01) != $conf;
		return if i2c_smbus_read_byte_data($file, $i + 0x02) != $hyst;
		return if i2c_smbus_read_byte_data($file, $i + 0x03) != $crit;
		return if i2c_smbus_read_byte_data($file, $i + 0x04) != $low;
		return if i2c_smbus_read_byte_data($file, $i + 0x05) != $high;
	}

	return if $chip == 0
	      and i2c_smbus_read_word_data($file, 0x07) != 0x0180;

	# Make sure the chip supports SMBus read word transactions
	$hyst = i2c_smbus_read_word_data($file, 0x02);
	return if $hyst &lt; 0;
	$crit = i2c_smbus_read_word_data($file, 0x03);
	return if $crit &lt; 0;
	$low = i2c_smbus_read_word_data($file, 0x04);
	return if $low &lt; 0;
	$high = i2c_smbus_read_word_data($file, 0x05);
	return if $high &lt; 0;

	foreach my $temp ($hyst, $crit, $low, $high) {
		return if $chip == 2 and ($temp &amp; 0x7F00);
		return if $chip != 2 and ($temp &amp; 0x0700);
	}

	return ($chip == 0) ? 4 : 2;
}

# Chip to detect: 0 = LM80, 1 = LM96080
# Registers used:
#   0x00: Configuration register
#   0x02: Interrupt state register
#   0x07: Conversion rate register (LM96080 only)
#   0x2a-0x3d: Limits registers (LM80 only)
#   0x3e: Manufacturer&#039;s ID register (LM96080 only)
#   0x3f: Stepping/die revision ID register (LM96080 only)
# The LM80 is easily misdetected since it doesn&#039;t provide identification
# registers. So we have to use some tricks:
#   - 6-bit addressing, so limits readings modulo 0x40 should be unchanged
#   - positive temperature limits
#   - limits order correctness
# Hopefully this should limit the rate of false positives, without increasing
# the rate of false negatives.
# Thanks to Lennard Klein for testing on a non-LM80 chip, which was
# previously misdetected, and isn&#039;t anymore. For reference, it scored
# a final confidence of 0, and changing from strict limit comparisons
# to loose comparisons did not change the score.
sub lm80_detect
{
	my ($file, $addr, $chip) = @_;
	my ($i, $reg);

	return if (i2c_smbus_read_byte_data($file, 0x00) &amp; 0x80) != 0;
	return if (i2c_smbus_read_byte_data($file, 0x02) &amp; 0xc0) != 0;

	if ($chip == 0) {
		for ($i = 0x2a; $i &lt;= 0x3d; $i++) {
			$reg = i2c_smbus_read_byte_data($file, $i);
			return if i2c_smbus_read_byte_data($file, $i+0x40) != $reg;
			return if i2c_smbus_read_byte_data($file, $i+0x80) != $reg;
			return if i2c_smbus_read_byte_data($file, $i+0xc0) != $reg;
		}

		# Refine a bit by checking whether limits are in the correct order
		# (min&lt;max for voltages, hyst&lt;max for temperature). Since it is still
		# possible that the chip is an LM80 with limits not properly set,
		# a few &quot;errors&quot; are tolerated.
		my $confidence = 0;
		for ($i = 0x2a; $i &lt;= 0x3a; $i++) {
			$confidence++
				if i2c_smbus_read_byte_data($file, $i) &lt; i2c_smbus_read_byte_data($file, $i+1);
		}
		# hot temp&lt;OS temp
		$confidence++
			if i2c_smbus_read_byte_data($file, 0x38) &lt; i2c_smbus_read_byte_data($file, 0x3a);

		# Negative temperature limits are unlikely.
		for ($i = 0x3a; $i &lt;= 0x3d; $i++) {
			$confidence++ if (i2c_smbus_read_byte_data($file, $i) &amp; 0x80) == 0;
		}

		# $confidence is between 0 and 14
		$confidence = ($confidence &gt;&gt; 1) - 4;
		# $confidence is now between -4 and 3

		return unless $confidence &gt; 0;
		return $confidence;
	} elsif ($chip == 1) {
		return if (i2c_smbus_read_byte_data($file, 0x07) &amp; 0xfe) != 0;
		return if i2c_smbus_read_byte_data($file, 0x3e) != 0x01;
		return if i2c_smbus_read_byte_data($file, 0x3f) != 0x08;

		return 6;
	}
}

# Registers used:
#   0x00: Configuration register
#   0x07: Conversion rate register
#   0x09: Oneshot register
#   0x0a: Shutdown register
#   0x0b: Advanced Configuration register
#   0x0c: Busy Status register
#   0x3e: Manufacturer&#039;s ID register
#   0x3f: Stepping/die revision ID register
sub adc128d818_detect
{
	my ($file, $addr) = @_;

	return if i2c_smbus_read_byte_data($file, 0x3e) != 0x01;
	return if i2c_smbus_read_byte_data($file, 0x3f) != 0x09;

	return if (i2c_smbus_read_byte_data($file, 0x00) &amp; 0xf4) != 0;
	return if (i2c_smbus_read_byte_data($file, 0x07) &amp; 0xfe) != 0;
	return if (i2c_smbus_read_byte_data($file, 0x09) &amp; 0xfe) != 0;
	return if (i2c_smbus_read_byte_data($file, 0x0a) &amp; 0xfe) != 0;
	return if (i2c_smbus_read_byte_data($file, 0x0b) &amp; 0xf8) != 0;
	return if (i2c_smbus_read_byte_data($file, 0x0c) &amp; 0xfc) != 0;

	return 7;
}

# Registers used:
#   0x02: Status 1
#   0x03: Configuration
#   0x04: Company ID of LM84
#   0x35: Status 2
#   0xfe: Manufacturer ID
#   0xff: Chip ID / die revision
# We can use the LM84 Company ID register because the LM83 and the LM82 are
# compatible with the LM84.
# The LM83 chip ID is missing from the datasheet and was contributed by
# Magnus Forsstrom: 0x03.
# At least some revisions of the LM82 seem to be repackaged LM83, so they
# have the same chip ID, and temp2/temp4 will be stuck in &quot;OPEN&quot; state.
# For this reason, we don&#039;t even try to distinguish between both chips.
# Thanks to Ben Gardner for reporting.
sub lm83_detect
{
	my ($file, $addr) = @_;
	return if i2c_smbus_read_byte_data($file, 0xfe) != 0x01;
	my $chipid = i2c_smbus_read_byte_data($file, 0xff);
	return if $chipid != 0x01 &amp;&amp; $chipid != 0x03;

	my $confidence = 4;
	$confidence++
		if (i2c_smbus_read_byte_data($file, 0x02) &amp; 0xa8) == 0x00;
	$confidence++
		if (i2c_smbus_read_byte_data($file, 0x03) &amp; 0x41) == 0x00;
	$confidence++
		if i2c_smbus_read_byte_data($file, 0x04) == 0x00;
	$confidence++
		if (i2c_smbus_read_byte_data($file, 0x35) &amp; 0x48) == 0x00;

	return $confidence;
}

# Chip to detect: 0 = MAX6680/81, 1 = MAX6695/96
# Registers used:
#   0x03: Configuration
#   0x04: Conversion rate
#   0x12: Status2
#   0x16: Overtemperature 2
#   0xfe: Manufacturer ID
#   0xff: Chip ID / die revision
sub max6680_95_detect
{
	my ($file, $addr, $chip) = @_;
	my $cid = i2c_smbus_read_byte_data($file, 0xff);
	my $conf = i2c_smbus_read_byte_data($file, 0x03);
	my $mid = i2c_smbus_read_byte_data($file, 0xfe, NO_CACHE);
	my $emerg = i2c_smbus_read_byte_data($file, 0x16, NO_CACHE);
	my $rate = i2c_smbus_read_byte_data($file, 0x04, NO_CACHE);
	my $emerg2 = i2c_smbus_read_byte_data($file, 0x16, NO_CACHE);

	# Check common conditions
	return if $rate &gt; 0x07;
	return if $mid != 0x4d;		# Not Maxim
	return if $cid != 0x01;		# None of the chips we are looking for

	if ($chip == 0) {
		return if ($conf &amp; 0x03) != 0;
		return 8 if $emerg != $emerg2;	# MAX6680/MAX6681
	}
	if ($chip == 1) {
		my $status2 = i2c_smbus_read_byte_data($file, 0x12);

		return if ($conf &amp; 0x10) != 0;
		return if ($status2 &amp; 0x01) != 0;
		return 8 if $emerg == $emerg2;	# MAX6695/MAX6696
	}
	return;
}

# Chip to detect: 0 = LM90, 1 = LM89/LM99, 2 = LM86, 3 = ADM1032,
#		  4 = MAX6654, 5 = ADT7461,
#		  6 = MAX6646/MAX6647/MAX6648/MAX6649/MAX6692,
#		  8 = W83L771W/G,
#		  11 = W83L771AWG/ASG, 12 = MAX6690,
#		  13 = ADT7461A/NCT1008, 14 = SA56004,
#		  15 = G781
# Registers used:
#   0x03: Configuration
#   0x04: Conversion rate
#   0xbf: Configuration 2 (National Semiconductor, Winbond, and Philips only)
#   0xfe: Manufacturer ID
#   0xff: Chip ID / die revision
sub lm90_detect
{
	my ($file, $addr, $chip) = @_;
	my $mid = i2c_smbus_read_byte_data($file, 0xfe);
	my $cid = i2c_smbus_read_byte_data($file, 0xff);
	my $conf = i2c_smbus_read_byte_data($file, 0x03);
	my $rate = i2c_smbus_read_byte_data($file, 0x04);
	my $conf2 = i2c_smbus_read_byte_data($file, 0xbf);

	if ($chip == 0) {
		return if ($conf &amp; 0x2a) != 0;
		return if ($conf2 &amp; 0xf8) != 0;
		return if $rate &gt; 0x09;
		return if $mid != 0x01;		# National Semiconductor
		return 8 if $cid == 0x21;	# LM90
		return 6 if ($cid &amp; 0x0f) == 0x20;
	}
	if ($chip == 1) {
		return if ($conf &amp; 0x2a) != 0;
		return if ($conf2 &amp; 0xf8) != 0;
		return if $rate &gt; 0x09;
		return if $mid != 0x01;		# National Semiconductor
		return 8 if $addr == 0x4c and $cid == 0x31; # LM89/LM99
		return 8 if $addr == 0x4d and $cid == 0x34; # LM89-1/LM99-1
		return 6 if ($cid &amp; 0x0f) == 0x30;
	}
	if ($chip == 2) {
		return if ($conf &amp; 0x2a) != 0;
		return if ($conf2 &amp; 0xf8) != 0;
		return if $rate &gt; 0x09;
		return if $mid != 0x01;		# National Semiconductor
		return 8 if $cid == 0x11;	# LM86
		return 6 if ($cid &amp; 0xf0) == 0x10;
	}
	if ($chip == 3) {
		return if ($conf &amp; 0x3f) != 0;
		return if $rate &gt; 0x0a;
		return if $mid != 0x41;		# Analog Devices
		return 6 if ($cid &amp; 0xf0) == 0x40; # ADM1032
	}
	if ($chip == 4) {
		return if ($conf &amp; 0x07) != 0;
		return if $rate &gt; 0x07;
		return if $mid != 0x4d;		# Maxim
		return 8 if $cid == 0x08;	# MAX6654
	}
	if ($chip == 5) {
		return if ($conf &amp; 0x1b) != 0;
		return if $rate &gt; 0x0a;
		return if $mid != 0x41;		# Analog Devices
		return 8 if $cid == 0x51;	# ADT7461
	}
	if ($chip == 6) {
		return if ($conf &amp; 0x3f) != 0;
		return if $rate &gt; 0x07;
		return if $mid != 0x4d;		# Maxim
		return 8 if $cid == 0x59;	# MAX6648/MAX6692
	}
	if ($chip == 8) {
		return if ($conf &amp; 0x2a) != 0;
		return if ($conf2 &amp; 0xf8) != 0;
		return if $rate &gt; 0x09;
		return if $mid != 0x5c;		# Winbond
		return 6 if ($cid &amp; 0xfe) == 0x00; # W83L771W/G
	}
	if ($chip == 11) {
		return if ($conf &amp; 0x2a) != 0;
		return if ($conf2 &amp; 0xf8) != 0;
		return if $rate &gt; 0x08;
		return if $mid != 0x5c;		# Winbond
		return 6 if ($cid &amp; 0xfe) == 0x10; # W83L771AWG/ASG
	}
	if ($chip == 12) {
		return if ($conf &amp; 0x07) != 0;
		return if $rate &gt; 0x07;
		return if $mid != 0x4d;		# Maxim
		return 8 if $cid == 0x09;	# MAX6690
	}
	if ($chip == 13) {
		return if ($conf &amp; 0x1b) != 0;
		return if $rate &gt; 0x0a;
		return if $mid != 0x41;		# Analog Devices
		return 8 if $cid == 0x57;	# ADT7461A, NCT1008
	}
	if ($chip == 14) {
		return if ($conf &amp; 0x2a) != 0;
		return if ($conf2 &amp; 0xfe) != 0;
		return if $rate &gt; 0x09;
		return if $mid != 0xa1;		# NXP Semiconductor/Philips
		return 6 if $cid == 0x00;	# SA56004
	}
	if ($chip == 15) {
		return if ($conf &amp; 0x3f) != 0;
		return if $rate &gt; 0x08;
		return if $mid != 0x47;		# GMT
		return 8 if $cid == 0x01;	# G781
	}
	return;
}

# Chip to detect: 0 = TMP400, 1 = TMP401, 2 = TMP411A, 3 = TMP411B, 4 = TMP411C,
#		  5 = TMP431, 6 = TMP432, 7 = TMP435, 8 = TMP451
# Registers used:
#   0x03: Configuration (4 unused bits)
#   0x04: Conversion rate (value 0x0f or lower, 0x09 or lower for TMP451)
#   0x10: Remote temperature low byte (4 unused bits)
#   0x13: Remote temperature low limit, low byte (4 unused bits)
#   0x14: Remote temperature high limit, low byte (4 unused bits)
#   0x22: Consecutive alert, 4 unused bits (TMP451 only)
#   0x24: Digital filter control, 6 unused bits (TMP451 only)
#   0xfe: Manufacturer ID
#   0xff: Device ID
sub tmp401_detect()
{
	my ($file, $addr, $chip) = @_;

	my $mid = i2c_smbus_read_byte_data($file, 0xfe);
	return if ($mid != 0x55);

	my $cid = i2c_smbus_read_byte_data($file, 0xff);
	my $conf = i2c_smbus_read_byte_data($file, 0x03);
	my $rate = i2c_smbus_read_byte_data($file, 0x04);
	my $rtemp = i2c_smbus_read_byte_data($file, 0x10);
	my $rhigh = i2c_smbus_read_byte_data($file, 0x13);
	my $rlow = i2c_smbus_read_byte_data($file, 0x14);

	return if ($conf &amp; 0x1b);
	return if ($rate &gt; 0x0f);
	return if ($rtemp &amp; 0x0f);
	return if ($rhigh &amp; 0x0f);
	return if ($rlow &amp; 0x0f);

	return 8 if ($chip == 0 &amp;&amp; $cid == 0x01); # TMP400
	return 8 if ($chip == 1 &amp;&amp; $cid == 0x11); # TMP401
	return 8 if ($chip == 2 &amp;&amp; $cid == 0x12); # TMP411A
	return 8 if ($chip == 3 &amp;&amp; $cid == 0x13); # TMP411B
	return 8 if ($chip == 4 &amp;&amp; $cid == 0x10); # TMP411C
	return 8 if ($chip == 5 &amp;&amp; $cid == 0x31); # TMP431
	return 8 if ($chip == 6 &amp;&amp; $cid == 0x32); # TMP432
	return 8 if ($chip == 7 &amp;&amp; $cid == 0x35); # TMP435

	if ($chip == 8) {			  # TMP451
		return if $cid != 0x00;
		return if $rate &gt; 0x09;

		my $alert = i2c_smbus_read_byte_data($file, 0x22);
		return if ($alert &amp; 0x71) != 0x01;

		my $filter = i2c_smbus_read_byte_data($file, 0x24);
		return if $filter &amp; 0xfc;

		return 4;
	}

	return;
}

# Chip to detect: 0 = TMP421, 1 = TMP422, 2 = TMP423, 3 = TMP441, 4 = TMP442
# Registers used:
#   0x08: Status (7 unused bits)
#   0x0b: Conversion rate (value 0x07 or lower)
#   0xfe: Manufacturer ID
#   0xff: Device ID
sub tmp42x_detect()
{
	my ($file, $addr, $chip) = @_;

	my $mid = i2c_smbus_read_byte_data($file, 0xfe);
	my $cid = i2c_smbus_read_byte_data($file, 0xff);
	my $status = i2c_smbus_read_byte_data($file, 0x08);
	my $rate = i2c_smbus_read_byte_data($file, 0x0b);

	return if ($mid != 0x55);
	return if ($status &amp; 0x7f);
	return if ($rate &gt; 0x07);

	return 6 if ($chip == 0 &amp;&amp; $cid == 0x21); # TMP421
	return 6 if ($chip == 1 &amp;&amp; $cid == 0x22); # TMP422
	return 6 if ($chip == 2 &amp;&amp; $cid == 0x23); # TMP423
	return 6 if ($chip == 3 &amp;&amp; $cid == 0x41); # TMP441
	return 6 if ($chip == 4 &amp;&amp; $cid == 0x42); # TMP442

	return;
}

# Registers used:
#   0x3d: Device ID
#   0x3e: Company ID
sub amc6821_detect()
{
	my ($file, $addr) = @_;

	my $dev_id = i2c_smbus_read_byte_data($file, 0x3d);
	my $comp_id = i2c_smbus_read_byte_data($file, 0x3e);

	return if ($comp_id != 0x49);		# Texas Instruments

	# Bit 7 of register address is ignored
	return if i2c_smbus_read_byte_data($file, 0x80 | 0x3d) != $dev_id;
	return if i2c_smbus_read_byte_data($file, 0x80 | 0x3e) != $comp_id;

	return 6 if ($dev_id == 0x21);		# AMC6821

	return;
}

# Registers used:
#   0x03: Configuration (no low nibble, returns the previous low nibble)
#   0x04: Conversion rate
#   0xfe: Manufacturer ID
#   0xff: no register
sub max6657_detect
{
	my ($file, $addr) = @_;
	my $mid = i2c_smbus_read_byte_data($file, 0xfe, NO_CACHE);
	my $cid = i2c_smbus_read_byte_data($file, 0xff, NO_CACHE);
	my $conf = i2c_smbus_read_byte_data($file, 0x03, NO_CACHE);

	return if $mid != 0x4d;		# Maxim
	return if ($conf &amp; 0x1f) != 0x0d;
	return if $cid != 0x4d;		# No register, returns previous value

	my $rate = i2c_smbus_read_byte_data($file, 0x04, NO_CACHE);
	return if $rate &gt; 0x09;

	$cid = i2c_smbus_read_byte_data($file, 0xff, NO_CACHE);
	$conf = i2c_smbus_read_byte_data($file, 0x03, NO_CACHE);
	return if ($conf &amp; 0x0f) != $rate;
	return if $cid != $rate;	# No register, returns previous value

	return 5;
}

# Chip to detect: 0 = LM95231, 1 = LM95241, 2 = LM95245, 3 = LM95234,
#		  4 = LM95235, 5 = LM95233
# Registers used:
#   0x02: Status (3 unused bits)
#   0x03: Configuration (3 unused bits)
#   0x04: Conversion rate (6 unused bits, LM95234)
#   0x06: Remote diode filter control (6 unused bits, LM95231 and LM95241)
#   0x30: Remote diode model type select (6 unused bits, LM95231 and LM95241)
#   0x30: Local Temperature LSB (5 unused bits, LM95245)
#   0x30: Diode model (4 unused bits, LM95234)
#   0x33: Status register 2 (6 unused bits, LM95245)
#   0x38: Diode model status (4 unused bits, LM95234)
#   0xfe: Manufacturer ID
#   0xff: Revision ID
sub lm95231_detect
{
	my ($file, $addr, $chip) = @_;
	my $mid = i2c_smbus_read_byte_data($file, 0xfe);
	my $cid = i2c_smbus_read_byte_data($file, 0xff);

	return if $mid != 0x01;				# National Semiconductor

	if ($chip == 0 || $chip == 1) {
		return if $chip == 0 &amp;&amp; $cid != 0xa1;	# LM95231
		return if $chip == 1 &amp;&amp; $cid != 0xa4;	# LM95241
		return if i2c_smbus_read_byte_data($file, 0x02) &amp; 0x70;
		return if i2c_smbus_read_byte_data($file, 0x03) &amp; 0x89;
		return if i2c_smbus_read_byte_data($file, 0x06) &amp; 0xfa;
		return if i2c_smbus_read_byte_data($file, 0x30) &amp; 0xfa;
	} elsif ($chip == 2 || $chip == 4) {
		return if $chip == 4 &amp;&amp; $cid != 0xb1;	# LM95235
		return if $chip == 2 &amp;&amp; $cid != 0xb3;	# LM95245
		return if i2c_smbus_read_byte_data($file, 0x02) &amp; 0x68;
		return if i2c_smbus_read_byte_data($file, 0x03) &amp; 0xa1;
		return if i2c_smbus_read_byte_data($file, 0x30) &amp; 0x1f;
		return if i2c_smbus_read_byte_data($file, 0x33) &amp; 0x3f;
	} elsif ($chip == 3) {
		return if $cid != 0x79;			# LM95234
		return if i2c_smbus_read_byte_data($file, 0x02) &amp; 0x30;
		return if i2c_smbus_read_byte_data($file, 0x03) &amp; 0xbc;
		return if i2c_smbus_read_byte_data($file, 0x04) &amp; 0xfc;
		return if i2c_smbus_read_byte_data($file, 0x30) &amp; 0xe1;
		return if i2c_smbus_read_byte_data($file, 0x38) &amp; 0xe1;
	} elsif ($chip == 5) {
		return if $cid != 0x89;			# LM95233
		return if i2c_smbus_read_byte_data($file, 0x02) &amp; 0x30;
		return if i2c_smbus_read_byte_data($file, 0x03) &amp; 0xbf;
		return if i2c_smbus_read_byte_data($file, 0x04) &amp; 0xfc;
		return if i2c_smbus_read_byte_data($file, 0x30) &amp; 0xf9;
		return if i2c_smbus_read_byte_data($file, 0x38) &amp; 0xf9;
	}

	return 6;
}

# Registers used:
#   0x03: Configuration 1
#   0x24: Configuration 2
#   0x3d: Manufacturer ID
#   0x3e: Device ID
sub adt7481_detect
{
	my ($file, $addr) = @_;
	my $mid = i2c_smbus_read_byte_data($file, 0x3d);
	my $cid = i2c_smbus_read_byte_data($file, 0x3e);
	my $conf1 = i2c_smbus_read_byte_data($file, 0x03);
	my $conf2 = i2c_smbus_read_byte_data($file, 0x24);

	return if ($conf1 &amp; 0x10) != 0;
	return if ($conf2 &amp; 0x7f) != 0;
	return if $mid != 0x41;		# Analog Devices
	return if $cid != 0x81;		# ADT7481

	return 6;
}

# Chip to detect: 1 = LM63, 2 = F75363SG, 3 = LM64, 4 = LM96163
# Registers used:
#   0xfe: Manufacturer ID
#   0xff: Chip ID / die revision
#   0x03: Configuration (two or three unused bits)
#   0x16: Alert mask (two or three unused bits)
sub lm63_detect
{
	my ($file, $addr, $chip) = @_;

	my $mid = i2c_smbus_read_byte_data($file, 0xfe);
	my $cid = i2c_smbus_read_byte_data($file, 0xff);
	my $conf = i2c_smbus_read_byte_data($file, 0x03);
	my $mask = i2c_smbus_read_byte_data($file, 0x16);

	if ($chip == 1) {
		return if $mid != 0x01		# National Semiconductor
		       || $cid != 0x41;		# LM63
		return if ($conf &amp; 0x18) != 0x00
		       || ($mask &amp; 0xa4) != 0xa4;
	} elsif ($chip == 2) {
		return if $mid != 0x23		# Fintek
		       || $cid != 0x20;		# F75363SG
		return if ($conf &amp; 0x1a) != 0x00
		       || ($mask &amp; 0x84) != 0x00;
	} elsif ($chip == 3) {
		return if $mid != 0x01		# National Semiconductor
		       || $cid != 0x51;		# LM64
		return if ($conf &amp; 0x18) != 0x00
		       || ($mask &amp; 0xa4) != 0xa4;
	} elsif ($chip == 4) {
		return if $mid != 0x01		# National Semiconductor
		       || $cid != 0x49;		# LM96163
		return if ($conf &amp; 0x18) != 0x00
		       || ($mask &amp; 0xa4) != 0xa4;
	}

	return 6;
}

# Registers used:
#   0x02, 0x03: Fan support
#   0x06: Temperature support
#   0x07, 0x08, 0x09: Fan config
#   0x0d: Manufacturer ID
#   0x0e: Chip ID / die revision
sub adm1029_detect
{
	my ($file, $addr) = @_;
	my $mid = i2c_smbus_read_byte_data($file, 0x0d);
	my $cid = i2c_smbus_read_byte_data($file, 0x0e);
	my $cfg;

	return unless $mid == 0x41;		# Analog Devices
	return unless ($cid &amp; 0xF0) == 0x00;	# ADM1029

	# Extra check on unused bits
	$cfg = i2c_smbus_read_byte_data($file, 0x02);
	return unless $cfg == 0x03;
	$cfg = i2c_smbus_read_byte_data($file, 0x06);
	return unless ($cfg &amp; 0xF9) == 0x01;
	foreach my $reg (0x03, 0x07, 0x08, 0x09) {
		$cfg = i2c_smbus_read_byte_data($file, $reg);
		return unless ($cfg &amp; 0xFC) == 0x00;
	}

	return 7;
}

# Chip to detect: 0 = ADM1030, 1 = ADM1031
# Registers used:
#   0x01: Config 2
#   0x03: Status 2
#   0x0d, 0x0e, 0x0f: Temperature offsets
#   0x22: Fan speed config
#   0x3d: Chip ID
#   0x3e: Manufacturer ID
#   0x3f: Die revision
sub adm1031_detect
{
	my ($file, $addr, $chip) = @_;
	my $mid = i2c_smbus_read_byte_data($file, 0x3e);
	my $cid = i2c_smbus_read_byte_data($file, 0x3d);
	my $drev = i2c_smbus_read_byte_data($file, 0x3f);
	my $conf2 = i2c_smbus_read_byte_data($file, 0x01);
	my $stat2 = i2c_smbus_read_byte_data($file, 0x03);
	my $fsc = i2c_smbus_read_byte_data($file, 0x22);
	my $lto = i2c_smbus_read_byte_data($file, 0x0d);
	my $r1to = i2c_smbus_read_byte_data($file, 0x0e);
	my $r2to = i2c_smbus_read_byte_data($file, 0x0f);
	my $confidence = 3;

	if ($chip == 0) {
		return if $mid != 0x41;		# Analog Devices
		return if $cid != 0x30;		# ADM1030
		$confidence++ if ($drev &amp; 0x70) == 0x00;
		$confidence++ if ($conf2 &amp; 0x4A) == 0x00;
		$confidence++ if ($stat2 &amp; 0x3F) == 0x00;
		$confidence++ if ($fsc &amp; 0xF0) == 0x00;
		$confidence++ if ($lto &amp; 0x70) == 0x00;
		$confidence++ if ($r1to &amp; 0x70) == 0x00;
		return $confidence;
	}
	if ($chip == 1) {
		return if $mid != 0x41;		# Analog Devices
		return if $cid != 0x31;		# ADM1031
		$confidence++ if ($drev &amp; 0x70) == 0x00;
		$confidence++ if ($lto &amp; 0x70) == 0x00;
		$confidence++ if ($r1to &amp; 0x70) == 0x00;
		$confidence++ if ($r2to &amp; 0x70) == 0x00;
		return $confidence;
	}
}

# Chip to detect: 0 = ADM1033, 1 = ADM1034
# Registers used:
#   0x3d: Chip ID
#   0x3e: Manufacturer ID
#   0x3f: Die revision
sub adm1034_detect
{
	my ($file, $addr, $chip) = @_;
	my $mid = i2c_smbus_read_byte_data($file, 0x3e);
	my $cid = i2c_smbus_read_byte_data($file, 0x3d);
	my $drev = i2c_smbus_read_byte_data($file, 0x3f);

	if ($chip == 0) {
		return if $mid != 0x41;		# Analog Devices
		return if $cid != 0x33;		# ADM1033
		return if ($drev &amp; 0xf8) != 0x00;
		return 6 if $drev == 0x02;
		return 4;
	}
	if ($chip == 1) {
		return if $mid != 0x41;		# Analog Devices
		return if $cid != 0x34;		# ADM1034
		return if ($drev &amp; 0xf8) != 0x00;
		return 6 if $drev == 0x02;
		return 4;
	}
}

# Chip to detect: 0 = ADT7467/ADT7468, 1 = ADT7476, 2 = ADT7462, 3 = ADT7466,
#		  4 = ADT7470
# Registers used:
#   0x3d: Chip ID
#   0x3e: Manufacturer ID
#   0x3f: Die revision
sub adt7467_detect
{
	my ($file, $addr, $chip) = @_;
	my $mid = i2c_smbus_read_byte_data($file, 0x3e);
	my $cid = i2c_smbus_read_byte_data($file, 0x3d);
	my $drev = i2c_smbus_read_byte_data($file, 0x3f);

	return if $mid != 0x41;			# Analog Devices

	if ($chip == 0) {
		return if $cid != 0x68;		# ADT7467/ADT7468
		return if ($drev &amp; 0xf0) != 0x70;
		return 7 if $drev == 0x71 || $drev == 0x72;
		return 5;
	}
	if ($chip == 1) {
		return if $cid != 0x76;		# ADT7476
		return if ($drev &amp; 0xf0) != 0x60;
		return 7 if $drev &gt;= 0x69 &amp;&amp; $drev &lt;= 0x6b;
		return 5;
	}
	if ($chip == 2) {
		return if $cid != 0x62;		# ADT7462
		return if ($drev &amp; 0xf0) != 0x00;
		return 7 if $drev == 0x04;
		return 5;
	}
	if ($chip == 3) {
		return if $cid != 0x66;		# ADT7466
		return if ($drev &amp; 0xf0) != 0x00;
		return 7 if $drev == 0x02;
		return 5;
	}
	if ($chip == 4) {
		return if $cid != 0x70;		# ADT7470
		return if ($drev &amp; 0xf0) != 0x00;
		return 7 if $drev == 0x00;
		return 5;
	}
}

# Chip to detect: 0 = ADT7473, 1 = ADT7475
# Registers used:
#   0x3d: Chip ID
#   0x3e: Manufacturer ID
sub adt7473_detect
{
	my ($file, $addr, $chip) = @_;
	my $mid = i2c_smbus_read_byte_data($file, 0x3e);
	my $cid = i2c_smbus_read_byte_data($file, 0x3d);

	return if $mid != 0x41;			# Analog Devices

	return if $chip == 0 &amp;&amp; $cid != 0x73;	# ADT7473
	return if $chip == 1 &amp;&amp; $cid != 0x75;	# ADT7475
	return 5;
}

# Registers used:
#   0x3e: Manufacturer ID
#   0x3f: Chip ID
sub adt7490_detect
{
	my ($file, $addr) = @_;
	my $mid = i2c_smbus_read_byte_data($file, 0x3e);
	my $cid = i2c_smbus_read_byte_data($file, 0x3f);

	return if $mid != 0x41;			# Analog Devices
	return if ($cid &amp; 0xfc) != 0x6c;	# ADT7490
	return 5;
}

# Registers used:
#   0x02: Status
#   0x0a: Thyst
#   0x0b: ID
# We also rely on the fact that only the 5 LSB of the address pointer
# are considered, so registers cycle over 32 byte boundaries.
sub adt7410_detect
{
	my ($file, $addr) = @_;
	my $status = i2c_smbus_read_byte_data($file, 0x02);
	my $thyst = i2c_smbus_read_byte_data($file, 0x0a);
	my $id = i2c_smbus_read_byte_data($file, 0x0b);

	# Unused bits
	return if ($status &amp; 0x0f);
	return if ($thyst &amp; 0xf0);

	# ID register
	return if $id != 0xcb;

	# Cycling registers
	for (my $i = 2; $i &lt; 16; $i *= 2) {
		return if i2c_smbus_read_byte_data($file, 0x0a + $i * 16) != $thyst;
		return if i2c_smbus_read_byte_data($file, 0x0b + $i * 16) != $id;
	}

	# Non-existent registers (other devices tend to have ID registers there)
	return if i2c_smbus_read_byte_data($file, 0x03e) != 0;
	return if i2c_smbus_read_byte_data($file, 0x03f) != 0;
	return if i2c_smbus_read_byte_data($file, 0x0fe) != 0;
	return if i2c_smbus_read_byte_data($file, 0x0ff) != 0;

	return 3;
}

# Registers used:
#   0x4d: Device ID
#   0x4e: Manufacturer ID
#   0x4e: Silicon revision
sub adt7411_detect
{
	my ($file, $addr) = @_;
	my $dev_id = i2c_smbus_read_byte_data($file, 0x4d);
	my $man_id = i2c_smbus_read_byte_data($file, 0x4e);
	my $revision = i2c_smbus_read_byte_data($file, 0x4f);

	return if $man_id != 0x41;		# Analog Devices
	return if $dev_id != 0x02;		# ADT7411
	# The datasheet suggests that the version is in the high nibble, but
	# a dump from a real ADT7411 chip shows that it is in the low nibble.
	return if ($revision &amp; 0x0f) != 0x04;	# ADT7411
	return 5;
}

# Chip to detect: 0 = aSC7512, 1 = aSC7611, 2 = aSC7621
# Registers used:
#   0x3e: Manufacturer ID
#   0x3f: Version
sub andigilog_detect
{
	my ($file, $addr, $chip) = @_;
	my $mid = i2c_smbus_read_byte_data($file, 0x3e);
	my $cid = i2c_smbus_read_byte_data($file, 0x3f);

	return if $mid != 0x61;		# Andigilog

	return if $chip == 0 &amp;&amp; $cid != 0x62;
	return if $chip == 1 &amp;&amp; $cid != 0x69;
	return if $chip == 2 &amp;&amp; ($cid != 0x6C &amp;&amp; $cid != 0x6D);
	return 5;
}

# Registers used:
#   0xfe: Manufacturer ID
#   0xff: Die Code
sub andigilog_aSC7511_detect
{
	my ($file, $addr) = @_;
	my $mid = i2c_smbus_read_byte_data($file, 0xfe);
	my $die = i2c_smbus_read_byte_data($file, 0xff);

	return if $mid != 0x61;		# Andigilog
	return if $die != 0x00;
	return 3;
}

# Chip to detect: 0 = LM85, 1 = LM96000, 2 = ADM1027, 3 = ADT7463,
#		  4 = EMC6D100/101, 5 = EMC6D102, 6 = EMC6D103,
#		  7 = WPCD377I (no sensors), 8 = EMC6D103S/EMC2300
# Registers used:
#   0x3e: Vendor register
#   0x3d: Device ID register (Analog Devices only)
#   0x3f: Version/Stepping register
sub lm85_detect
{
	my ($file, $addr, $chip) = @_;
	my $vendor = i2c_smbus_read_byte_data($file, 0x3e);
	my $verstep = i2c_smbus_read_byte_data($file, 0x3f);

	if ($chip == 0) {
		return if $vendor != 0x01;	# National Semiconductor
		return if $verstep != 0x60	# LM85 C
		       &amp;&amp; $verstep != 0x62;	# LM85 B
	} elsif ($chip == 1 || $chip == 7) {
		return if $vendor != 0x01;	# National Semiconductor
		return if $verstep != 0x68	# LM96000
		       &amp;&amp; $verstep != 0x69;	# LM96000
	} elsif ($chip == 2) {
		return if $vendor != 0x41;	# Analog Devices
		return if $verstep != 0x60;	# ADM1027
	} elsif ($chip == 3) {
		return if $vendor != 0x41;	# Analog Devices
		return if $verstep != 0x62	# ADT7463
		       &amp;&amp; $verstep != 0x6a;	# ADT7463 C
	} elsif ($chip == 4) {
		return if $vendor != 0x5c;	# SMSC
		return if $verstep != 0x60	# EMC6D100/101 A0
		       &amp;&amp; $verstep != 0x61;	# EMC6D100/101 A1
	} elsif ($chip == 5) {
		return if $vendor != 0x5c;	# SMSC
		return if $verstep != 0x65;	# EMC6D102
	} elsif ($chip == 6) {
		return if $vendor != 0x5c;	# SMSC
		return if $verstep != 0x68	# EMC6D103 A0
		       &amp;&amp; $verstep != 0x69;	# EMC6D103 A1
	} elsif ($chip == 8) {
		return if $vendor != 0x5c;	# SMSC
		return if $verstep != 0x6a;	# EMC6D103S/EMC2300
	}

	if ($vendor == 0x41) {			# Analog Devices
		return if i2c_smbus_read_byte_data($file, 0x3d) != 0x27;
		return 8;
	}

	if ($chip == 1 || $chip == 7) {
		# Differenciate between real LM96000 and Winbond WPCD377I.
		# The latter emulate the former except that it has no
		# hardware monitoring function so the readings are always
		# 0.
		my ($in_temp, $fan, $i);
		
		for ($i = 0; $i &lt; 8; $i++) {
			$in_temp = i2c_smbus_read_byte_data($file, 0x20 + $i);
			$fan = i2c_smbus_read_byte_data($file, 0x28 + $i);
			if ($in_temp != 0x00 or $fan != 0xff) {
				return 7 if $chip == 1;
				return;
			}
		}
		return 7 if $chip == 7;
		return;
	}

	return 7;
}

# Registers used:
#   0x3e: Vendor register
#   0x3f: Version/Stepping register
#   0x40: Configuration register (reserved bits + ready)
sub emc6w201_detect
{
	my ($file, $addr) = @_;
	my $vendor = i2c_smbus_read_byte_data($file, 0x3e);
	my $verstep = i2c_smbus_read_byte_data($file, 0x3f);
	my $conf = i2c_smbus_read_byte_data($file, 0x40);
	my $stepping;

	return if $vendor != 0x5c;		# SMSC
	return if ($verstep &amp; 0xf0) != 0xb0;	# EMC6W201
	return if ($conf &amp; 0xf4) != 0x04;

	$stepping = $verstep &amp; 0x0f;
	return if $stepping &gt; 3;

	# So far we&#039;ve only seen stepping 1 chips
	return $stepping &lt;= 1 ? 6 : 3;
}

# Chip to detect: 0 = LM87, 1 = ADM1024
# Registers used:
#   0x3e: Company ID
#   0x3f: Revision
#   0x40: Configuration
sub lm87_detect
{
	my ($file, $addr, $chip) = @_;
	my $cid = i2c_smbus_read_byte_data($file, 0x3e);
	my $rev = i2c_smbus_read_byte_data($file, 0x3f);

	if ($chip == 0) {
		return if $cid != 0x02;		# National Semiconductor
		return if ($rev &amp; 0xfc) != 0x04; # LM87
	}
	if ($chip == 1) {
		return if $cid != 0x41;		# Analog Devices
		return if ($rev &amp; 0xf0) != 0x10; # ADM1024
	}

	my $cfg = i2c_smbus_read_byte_data($file, 0x40);
	return if ($cfg &amp; 0x80) != 0x00;

	return 7;
}

# Chip to detect: 0 = W83781D, 1 = W83782D, 2 = W83783S, 3 = W83627HF,
#		  4 = AS99127F (rev.1), 5 = AS99127F (rev.2), 6 = ASB100,
#		  7 = W83791D, 8 = W83792D, 9 = W83627EHF,
#		  10 = W83627DHG/W83667HG/W83677HG
# Registers used:
#   0x48: Full I2C Address
#   0x4a: I2C addresses of emulated LM75 chips
#   0x4e: Vendor ID byte selection, and bank selection
#   0x4f: Vendor ID
#   0x58: Device ID (only when in bank 0)
# Note: Fails if the W8378xD is not in bank 0!
# Note: Asus chips do not have their I2C address at register 0x48?
#       AS99127F rev.1 and ASB100 have 0x00, confirmation wanted for
#       AS99127F rev.2.
sub w83781d_detect
{
	my ($file, $addr, $chip) = @_;
	my ($reg1, $reg2, @res);

	return unless (i2c_smbus_read_byte_data($file, 0x48) == $addr)
		   or ($chip &gt;= 4 &amp;&amp; $chip &lt;= 6);

	$reg1 = i2c_smbus_read_byte_data($file, 0x4e);
	$reg2 = i2c_smbus_read_byte_data($file, 0x4f);
	if ($chip == 4) {		# Asus AS99127F (rev.1)
		return unless (($reg1 &amp; 0x80) == 0x00 and $reg2 == 0xc3) or
			      (($reg1 &amp; 0x80) == 0x80 and $reg2 == 0x12);
	} elsif ($chip == 6) {		# Asus ASB100
		return unless (($reg1 &amp; 0x80) == 0x00 and $reg2 == 0x94) or
			      (($reg1 &amp; 0x80) == 0x80 and $reg2 == 0x06);
	} else {			# Winbond and Asus AS99127F (rev.2)
		return unless (($reg1 &amp; 0x80) == 0x00 and $reg2 == 0xa3) or
			      (($reg1 &amp; 0x80) == 0x80 and $reg2 == 0x5c);
	}

	return unless ($reg1 &amp; 0x07) == 0x00;

	$reg1 = i2c_smbus_read_byte_data($file, 0x58);
	return if $chip == 0 and ($reg1 != 0x10 &amp;&amp; $reg1 != 0x11);
	return if $chip == 1 and $reg1 != 0x30;
	return if $chip == 2 and $reg1 != 0x40;
	return if $chip == 3 and $reg1 != 0x21;
	return if $chip == 4 and $reg1 != 0x31;
	return if $chip == 5 and $reg1 != 0x31;
	return if $chip == 6 and $reg1 != 0x31;
	return if $chip == 7 and $reg1 != 0x71;
	return if $chip == 8 and $reg1 != 0x7a;
	return if $chip == 9 and ($reg1 != 0x88 &amp;&amp; $reg1 != 0xa1);
	return if $chip == 10 and $reg1 != 0xc1;
	# Default address is 0x2d
	@res = ($addr != 0x2d) ? (7) : (8);
	return @res if $chip &gt;= 9; # No subclients

	$reg1 = i2c_smbus_read_byte_data($file, 0x4a);
	push @res, ($reg1 &amp; 0x07) + 0x48 unless $reg1 &amp; 0x08;
	push @res, (($reg1 &amp; 0x70) &gt;&gt; 4) + 0x48
		unless ($reg1 &amp; 0x80 or $chip == 2);
	return @res;
}

# Registers used:
#   0x0b: Full I2C Address
#   0x0c: I2C addresses of emulated LM75 chips
#   0x00: Vendor ID byte selection, and bank selection(Bank 0, 1, 2)
#   0x0d: Vendor ID(Bank 0, 1, 2)
#   0x0e: Device ID(Bank 0, 1, 2)
sub w83793_detect
{
	my ($file, $addr) = @_;
	my ($bank, $reg, @res);

	$bank = i2c_smbus_read_byte_data($file, 0x00);
	$reg = i2c_smbus_read_byte_data($file, 0x0d);

	return unless (($bank &amp; 0x80) == 0x00 and $reg == 0xa3) or
		      (($bank &amp; 0x80) == 0x80 and $reg == 0x5c);

	$reg = i2c_smbus_read_byte_data($file, 0x0e);
	return if $reg != 0x7b;

	# If bank 0 is selected, we can do more checks
	return 6 unless ($bank &amp; 0x07) == 0;
	$reg = i2c_smbus_read_byte_data($file, 0x0b);
	return unless ($reg == ($addr &lt;&lt; 1));

	$reg = i2c_smbus_read_byte_data($file, 0x0c);
	@res = (8);
	push @res, ($reg &amp; 0x07) + 0x48 unless $reg &amp; 0x08;
	push @res, (($reg &amp; 0x70) &gt;&gt; 4) + 0x48 unless $reg &amp; 0x80;
	return @res;
}

# Registers used:
#   0xfc: Full I2C Address
#   0x00: Vendor ID byte selection, and bank selection(Bank 0, 1, 2)
#   0xfd: Vendor ID(Bank 0, 1, 2)
#   0xfe: Device ID(Bank 0, 1, 2)
sub w83795_detect
{
	my ($bank, $reg);
	my ($file, $addr) = @_;

	$bank = i2c_smbus_read_byte_data($file, 0x00);
	$reg = i2c_smbus_read_byte_data($file, 0xfd);

	return unless (($bank &amp; 0x80) == 0x00 and $reg == 0xa3) or
		      (($bank &amp; 0x80) == 0x80 and $reg == 0x5c);

	$reg = i2c_smbus_read_byte_data($file, 0xfe);
	return if $reg != 0x79;

	# If bank 0 is selected, we can do more checks
	return 6 unless ($bank &amp; 0x07) == 0;
	$reg = i2c_smbus_read_byte_data($file, 0xfc) &amp; 0x7f;
	return unless ($reg == $addr);

	return 8;
}

# Registers used:
#   0x00: Bank selection (Bank 0, 1)
#   0x05: Temperature readout register LSB (Bank 0)
#   0x08: PECI temperature readout register LSB (Bank 0)
#   0x0f: Voltage readout register LSB (Bank 0)
#   0xfd: Vendor ID (Bank 0)
#   0xfe: Device ID (Bank 0)
#   0xff: Device Revision (Bank 0)
#
# Note that identification registers are not accessible in bank 1,
# and there is no usable other means to identify the chip if bank 1
# is selected. Only detect chip if bank 0 is selected.
sub nct7802_detect
{
	my ($bank, $reg);
	my ($file, $addr) = @_;

	$bank = i2c_smbus_read_byte_data($file, 0x00);
	return unless $bank == 0x00;

	$reg = i2c_smbus_read_byte_data($file, 0xfd);
	return unless $reg == 0x50;

	$reg = i2c_smbus_read_byte_data($file, 0xfe);
	return unless $reg == 0xc3;

	$reg = i2c_smbus_read_byte_data($file, 0xff);
	return unless ($reg &amp; 0xf0) == 0x20;

	$reg = i2c_smbus_read_byte_data($file, 0x05);
	return unless ($reg &amp; 0x1f) == 0x00;

	$reg = i2c_smbus_read_byte_data($file, 0x08);
	return unless ($reg &amp; 0x3f) == 0x00;

	$reg = i2c_smbus_read_byte_data($file, 0x0f);
	return unless ($reg &amp; 0x3f) == 0x00;

	return 8;
}

# Registers used:
#   0x7a: Vendor ID
#   0x7b: Chip ID
#   0x7c: Device ID
#   0xff: Bank Select
#
sub nct7904_detect
{
	my ($reg);
	my ($file, $addr) = @_;

	$reg = i2c_smbus_read_byte_data($file, 0x7a);
	return unless $reg == 0x50;

	$reg = i2c_smbus_read_byte_data($file, 0x7b);
	return unless $reg == 0xc5;

	$reg = i2c_smbus_read_byte_data($file, 0x7c);
	return unless ($reg &amp; 0xf0) == 0x50;

	$reg = i2c_smbus_read_byte_data($file, 0xff);
	return unless ($reg &amp; 0xf8) == 0x00;

	return 8;
}

# Registers used:
#   0x48: Full I2C Address
#   0x4e: Vendor ID byte selection
#   0x4f: Vendor ID
#   0x58: Device ID
# Note that the datasheet was useless and this detection routine
# is based on dumps we received from users. Also, the W83781SD is *NOT*
# a hardware monitoring chip as far as we know, but we still want to
# detect it so that people won&#039;t keep reporting it as an unknown chip
# we should investigate about.
sub w83791sd_detect
{
	my ($file, $addr) = @_;
	my ($reg1, $reg2);

	return unless (i2c_smbus_read_byte_data($file, 0x48) == $addr);

	$reg1 = i2c_smbus_read_byte_data($file, 0x4e);
	$reg2 = i2c_smbus_read_byte_data($file, 0x4f);
	return unless (!($reg1 &amp; 0x80) &amp;&amp; $reg2 == 0xa3)
		   || (($reg1 &amp; 0x80) &amp;&amp; $reg2 == 0x5c);

	$reg1 = i2c_smbus_read_byte_data($file, 0x58);
	return unless $reg1 == 0x72;

	return 3;
}

# Registers used:
#   0x4e: Vendor ID high byte
#   0x4f: Vendor ID low byte
#   0x58: Device ID
# Note: The values were given by Alex van Kaam, we don&#039;t have datasheets
#       to confirm.
sub mozart_detect
{
	my ($file, $addr) = @_;
	my ($vid, $dev);

	$vid = (i2c_smbus_read_byte_data($file, 0x4e) &lt;&lt; 8)
	     + i2c_smbus_read_byte_data($file, 0x4f);
	$dev = i2c_smbus_read_byte_data($file, 0x58);

	return unless ($dev == 0x56 &amp;&amp; $vid == 0x9436)	# ASM58
		   || ($dev == 0x56 &amp;&amp; $vid == 0x9406)	# AS2K129R
		   || ($dev == 0x10 &amp;&amp; $vid == 0x5ca3);

	return 5;
}

# Chip to detect: 0 = GL518SM, 1 = GL520SM
# Registers used:
#   0x00: Device ID
#   0x01: Revision ID
#   0x03: Configuration
sub gl518sm_detect
{
	my ($file, $addr, $chip) = @_;
	my $reg;

	$reg = i2c_smbus_read_byte_data($file, 0x00);
	return if $chip == 0 &amp;&amp; $reg != 0x80;
	return if $chip == 1 &amp;&amp; $reg != 0x20;

	return unless (i2c_smbus_read_byte_data($file, 0x03) &amp; 0x80) == 0x00;
	$reg = i2c_smbus_read_byte_data($file, 0x01);
	return unless $reg == 0x00 or $reg == 0x80;
	return 6;
}

# Registers used:
#   0x00: Device ID
#   0x03: Configuration
# Mediocre detection
sub gl525sm_detect
{
	my ($file, $addr) = @_;
	return unless i2c_smbus_read_byte_data($file, 0x00) == 0x25;
	return unless (i2c_smbus_read_byte_data($file, 0x03) &amp; 0x80) == 0x00;
	return 5;
}

# Chip to detect: 0 = ADM9240, 1 = DS1780, 2 = LM81
# Registers used:
#   0x3e: Company ID
#   0x40: Configuration
#   0x48: Full I2C Address
sub adm9240_detect
{
	my ($file, $addr, $chip) = @_;
	my $reg;
	$reg = i2c_smbus_read_byte_data($file, 0x3e);
	return unless ($chip == 0 and $reg == 0x23) or
		      ($chip == 1 and $reg == 0xda) or
		      ($chip == 2 and $reg == 0x01);
	return unless (i2c_smbus_read_byte_data($file, 0x40) &amp; 0x80) == 0x00;
	return unless i2c_smbus_read_byte_data($file, 0x48) == $addr;

	return 7;
}

# Chip to detect: 0 = ADM1022, 1 = THMC50, 2 = ADM1028, 3 = THMC51
# Registers used:
#   0x3e: Company ID
#   0x3f: Revision
#   0x40: Configuration
sub adm1022_detect
{
	my ($file, $addr, $chip) = @_;
	my $reg;
	$reg = i2c_smbus_read_byte_data($file, 0x3e);
	return unless ($chip == 0 and $reg == 0x41) or
		      ($chip == 1 and $reg == 0x49) or
		      ($chip == 2 and $reg == 0x41) or
		      ($chip == 3 and $reg == 0x49);
	$reg = i2c_smbus_read_byte_data($file, 0x40);
	return if ($reg &amp; 0x10);			# Soft Reset always reads 0
	return if ($chip != 0 and ($reg &amp; 0x80));	# Reserved on THMC50 and ADM1028
	$reg = i2c_smbus_read_byte_data($file, 0x3f) &amp; 0xf0;
	return unless ($chip == 0 and $reg == 0xc0) or
		      ($chip == 1 and $reg == 0xc0) or
		      ($chip == 2 and $reg == 0xd0) or
		      ($chip == 3 and $reg == 0xd0);
	return 8;
}

# Chip to detect: 0 = ADM1025, 1 = NE1619
# Registers used:
#   0x3e: Company ID
#   0x3f: Revision
#   0x40: Configuration
#   0x41: Status 1
#   0x42: Status 2
sub adm1025_detect
{
	my ($file, $addr, $chip) = @_;
	my $reg;

	$reg = i2c_smbus_read_byte_data($file, 0x3e);
	return if ($chip == 0) and ($reg != 0x41);
	return if ($chip == 1) and ($reg != 0xA1);

	return unless (i2c_smbus_read_byte_data($file, 0x40) &amp; 0x80) == 0x00;
	return unless (i2c_smbus_read_byte_data($file, 0x41) &amp; 0xC0) == 0x00;
	return unless (i2c_smbus_read_byte_data($file, 0x42) &amp; 0xBC) == 0x00;
	return unless (i2c_smbus_read_byte_data($file, 0x3f) &amp; 0xf0) == 0x20;

	return 8;
}

# Registers used:
#   0x16: Company ID
#   0x17: Revision
sub adm1026_detect
{
	my ($file, $addr) = @_;
	my $reg;
	$reg = i2c_smbus_read_byte_data($file, 0x16);
	return unless ($reg == 0x41);
	return unless (i2c_smbus_read_byte_data($file, 0x17) &amp; 0xf0) == 0x40;
	return 8;
}

# Chip to detect: 0 = ADM1021, 1 = ADM1021A/ADM1023, 2 = MAX1617, 3 = MAX1617A,
#		  4 = THMC10, 5 = LM84, 6 = GL523, 7 = MC1066
# Registers used:
#   0x04: Company ID (LM84 only)
#   0xfe: Company ID (all but LM84 and MAX1617)
#   0xff: Revision (ADM1021, ADM1021A/ADM1023 and MAX1617A)
#   0x02: Status
#   0x03: Configuration
#   0x04: Conversion rate
#   0x00-0x01, 0x05-0x08: Temperatures (MAX1617 and LM84)
# Note: Especially the MAX1617 has very bad detection; we give it a low
# confidence value.
sub adm1021_detect
{
	my ($file, $addr, $chip) = @_;
	my $man_id = i2c_smbus_read_byte_data($file, 0xfe);
	my $rev = i2c_smbus_read_byte_data($file, 0xff);
	my $conf = i2c_smbus_read_byte_data($file, 0x03);
	my $status = i2c_smbus_read_byte_data($file, 0x02);
	my $convrate = i2c_smbus_read_byte_data($file, 0x04);

	# Check manufacturer IDs and product revisions when available
	return if $chip == 0 and $man_id != 0x41 || ($rev &amp; 0xf0) != 0x00;
	return if $chip == 1 and $man_id != 0x41 || ($rev &amp; 0xf0) != 0x30;
	return if $chip == 3 and $man_id != 0x4d || $rev != 0x01;
	return if $chip == 4 and $man_id != 0x49;
	return if $chip == 5 and $convrate != 0x00;
	return if $chip == 6 and $man_id != 0x23;
	return if $chip == 7 and $man_id != 0x54;

	# Check unused bits
	if ($chip == 5) {	# LM84
		return if ($status &amp; 0xab) != 0;
		return if ($conf &amp; 0x7f) != 0;
	} else {
		return if ($status &amp; 0x03) != 0;
		return if ($conf &amp; 0x3f) != 0;
		return if ($convrate &amp; 0xf8) != 0;
	}

	# Extra checks for MAX1617 and LM84, since those are often misdetected.
	# We verify several assertions (6 for the MAX1617, 4 for the LM84) and
	# discard the chip if any fail.
	if ($chip == 2 || $chip == 5) {
		my $lte = i2c_smbus_read_byte_data($file, 0x00);
		my $rte = i2c_smbus_read_byte_data($file, 0x01);
		my $lhi = i2c_smbus_read_byte_data($file, 0x05);
		my $rhi = i2c_smbus_read_byte_data($file, 0x07);
		my $llo = i2c_smbus_read_byte_data($file, 0x06);
		my $rlo = i2c_smbus_read_byte_data($file, 0x08);

		# If all registers hold the same value, it has to be a misdetection
		return if $lte == $rte and $lte == $lhi and $lte == $rhi
		      and $lte == $llo and $lte == $rlo;

		# Negative temperatures
		return if ($lte &amp; 0x80) or ($rte &amp; 0x80);
		# Negative high limits
		return if ($lhi &amp; 0x80) or ($rhi &amp; 0x80);
		# Low limits over high limits
		if ($chip == 2) {
			$llo -= 256 if ($llo &amp; 0x80);
			$rlo -= 256 if ($rlo &amp; 0x80);
			return if ($llo &gt; $lhi) or ($rlo &gt; $rhi);
		}
		return 3;
	}

	return ($chip &lt;= 3) ? 7 : 5;
}

# Chip to detect: 0 = MAX1668, 1 = MAX1805, 2 = MAX1989
# Registers used:
#   0xfe: Company ID
#   0xff: Device ID
sub max1668_detect
{
	my ($file, $addr, $chip) = @_;
	my $man_id = i2c_smbus_read_byte_data($file, 0xfe);
	my $dev_id = i2c_smbus_read_byte_data($file, 0xff);

	return if $man_id != 0x4d;
	return if $chip == 0 and $dev_id != 0x03;
	return if $chip == 1 and $dev_id != 0x05;
	return if $chip == 2 and $dev_id != 0x0b;

	return 7;
}

# Chip to detect: 0 = MAX1619, 1 = MAX1618
# Registers used:
#   0xfe: Company ID
#   0xff: Device ID
#   0x02: Status
#   0x03: Configuration
#   0x04: Conversion rate
sub max1619_detect
{
	my ($file, $addr, $chip) = @_;
	my $man_id = i2c_smbus_read_byte_data($file, 0xfe);
	my $dev_id = i2c_smbus_read_byte_data($file, 0xff);
	my $conf = i2c_smbus_read_byte_data($file, 0x03);
	my $status = i2c_smbus_read_byte_data($file, 0x02);
	my $convrate = i2c_smbus_read_byte_data($file, 0x04);

	return if $man_id != 0x4D;	# Maxim

	if ($chip == 0) {		# MAX1619
		return if $dev_id != 0x04
		       or ($conf &amp; 0x03)
		       or ($status &amp; 0x61)
		       or $convrate &gt;= 8;
	}
	if ($chip == 1) {		# MAX1618
		return if $dev_id != 0x02
		       or ($conf &amp; 0x07)
		       or ($status &amp; 0x63);
	}

	return 7;
}

# Registers used:
#   0x28: User ID
#   0x29: User ID2
sub ite_overclock_detect
{
	my ($file, $addr) = @_;

	my $uid1 = i2c_smbus_read_byte_data($file, 0x28);
	my $uid2 = i2c_smbus_read_byte_data($file, 0x29);
	return if $uid1 != 0x83 || $uid2 != 0x12;

	return 6;
}

# Registers used:
#   0x00: Configuration
#   0x48: Full I2C Address
#   0x58: Mfr ID
#   0x5b: Device ID
sub it8712_i2c_detect
{
	my ($file, $addr) = @_;
	my $reg;
	return unless i2c_smbus_read_byte_data($file, 0x48) == $addr;
	return unless (i2c_smbus_read_byte_data($file, 0x00) &amp; 0x90) == 0x10;
	return unless i2c_smbus_read_byte_data($file, 0x58) == 0x90;
	return if i2c_smbus_read_byte_data($file, 0x5b) != 0x12;
	return 7 + ($addr == 0x2d);
}

# Registers used:
#   0-63: SPD Data and Checksum (up to DDR2)
#   0-127: SPD data and CRC (DDR3)
sub eeprom_detect
{
	my ($file, $addr) = @_;
	my $device_type = i2c_smbus_read_byte_data($file, 2);
	my $checksum = 0;

	# Check the checksum or CRC16 for validity
	if ($device_type &gt;= 1 and $device_type &lt;= 8) {
		for (my $i = 0; $i &lt; 63; $i++) {
			$checksum += i2c_smbus_read_byte_data($file, $i);
		}
		$checksum &amp;= 0xff;

		return 8 if $checksum == i2c_smbus_read_byte_data($file, 63);
	} elsif ($device_type &gt;= 9 &amp;&amp; $device_type &lt;= 12) {
		# see JEDEC 21-C 4.1.2.11 2.4
		my $crc_coverage = i2c_smbus_read_byte_data($file, 0);
		$crc_coverage = ($crc_coverage &amp; 0x80) ? 117 : 126;
		for (my $i = 0; $i &lt; $crc_coverage; $i++) {
			$checksum ^= i2c_smbus_read_byte_data($file, $i) &lt;&lt; 8;
			for (my $bit = 0; $bit &lt; 8; $bit++) {
				if ($checksum &amp; 0x8000) {
					$checksum = ($checksum &lt;&lt; 1) ^ 0x1021;
				} else {
					$checksum &lt;&lt;= 1;
				}
			}
		}
		$checksum &amp;= 0xffff;

		return 8 if ($checksum &amp; 0xff) == i2c_smbus_read_byte_data($file, 126) and
			    ($checksum &gt;&gt; 8) == i2c_smbus_read_byte_data($file, 127);

		# note: if bit 7 of byte 32 is set, a jc42 sensor is at $addr-0x38
	}

	return;
}

# Registers used:
#   0x00..0x07: DDC signature
sub ddcmonitor_detect
{
	my ($file, $addr) = @_;

	return unless
		i2c_smbus_read_byte_data($file, 0x00) == 0x00 and
		i2c_smbus_read_byte_data($file, 0x01) == 0xFF and
		i2c_smbus_read_byte_data($file, 0x02) == 0xFF and
		i2c_smbus_read_byte_data($file, 0x03) == 0xFF and
		i2c_smbus_read_byte_data($file, 0x04) == 0xFF and
		i2c_smbus_read_byte_data($file, 0x05) == 0xFF and
		i2c_smbus_read_byte_data($file, 0x06) == 0xFF and
		i2c_smbus_read_byte_data($file, 0x07) == 0x00;

	return 8;
}

# Chip to detect: 0 = Poseidon I, 1 = Poseidon II, 2 = Scylla,
#		  3 = Hermes, 4 = Heimdal, 5 = Heracles
# Registers used:
#   0x00-0x02: Identification (3 capital ASCII letters)
sub fsc_detect
{
	my ($file, $addr, $chip) = @_;
	my $id;

	$id = chr(i2c_smbus_read_byte_data($file, 0x00))
	    . chr(i2c_smbus_read_byte_data($file, 0x01))
	    . chr(i2c_smbus_read_byte_data($file, 0x02));

	return if $chip == 0 and $id ne &#039;PEG&#039;;	# Pegasus? aka Poseidon I
	return if $chip == 1 and $id ne &#039;POS&#039;;	# Poseidon II
	return if $chip == 2 and $id ne &#039;SCY&#039;;	# Scylla
	return if $chip == 3 and $id ne &#039;HER&#039;;	# Hermes
	return if $chip == 4 and $id ne &#039;HMD&#039;;	# Heimdal
	return if $chip == 5 and $id ne &#039;HRC&#039;;	# Heracles
	return if $chip == 6 and $id ne &#039;HDS&#039;;	# Hades
	return if $chip == 7 and $id ne &#039;SYL&#039;;	# Syleus

	return 8;
}

# Chip to detect: 0 = LM93, 1 = LM94
# Registers used:
#   0x3E: Manufacturer ID
#   0x3F: Version/Stepping
sub lm93_detect
{
	my ($file, $addr, $chip) = @_;
	my ($man_id, $dev_id);

	$man_id = i2c_smbus_read_byte_data($file, 0x3E);
	$dev_id = i2c_smbus_read_byte_data($file, 0x3F);
	
	if ($chip == 0) {
		return unless $man_id == 0x01	# National Semiconductor
			  and $dev_id == 0x73;	# LM93
	}
	if ($chip == 1) {
		return unless $man_id == 0x01	# National Semiconductor
			  and $dev_id &gt;= 0x79
			  and $dev_id &lt;= 0x7A;	# LM94
	}
	return 5;
}

# Registers used:
#   0x3F: Revision ID
#   0x48: Address
#   0x4A, 0x4B, 0x4F, 0x57, 0x58: Reserved bits.
# We do not use 0x49&#039;s reserved bits on purpose. The register is named
# &quot;VID4/Device ID&quot; so it is doubtful bits 7-1 are really unused.
sub m5879_detect
{
	my ($file, $addr) = @_;

	return unless i2c_smbus_read_byte_data($file, 0x3F) == 0x01;
	return unless i2c_smbus_read_byte_data($file, 0x48) == $addr;

	return unless (i2c_smbus_read_byte_data($file, 0x4A) &amp; 0x06) == 0
		  and (i2c_smbus_read_byte_data($file, 0x4B) &amp; 0xFC) == 0
		  and (i2c_smbus_read_byte_data($file, 0x4F) &amp; 0xFC) == 0
		  and (i2c_smbus_read_byte_data($file, 0x57) &amp; 0xFE) == 0
		  and (i2c_smbus_read_byte_data($file, 0x58) &amp; 0xEF) == 0;

	return 7;
}

# Registers used:
#   0x3E: Manufacturer ID
#   0x3F: Version/Stepping
#   0x47: VID (3 reserved bits)
#   0x49: VID4 (7 reserved bits)
sub smsc47m192_detect
{
	my ($file, $addr) = @_;
	return unless i2c_smbus_read_byte_data($file, 0x3E) == 0x55
		  and (i2c_smbus_read_byte_data($file, 0x3F) &amp; 0xF0) == 0x20
		  and (i2c_smbus_read_byte_data($file, 0x47) &amp; 0x70) == 0x00
		  and (i2c_smbus_read_byte_data($file, 0x49) &amp; 0xFE) == 0x80;
	return ($addr == 0x2d ? 6 : 5);
}

# Chip to detect: 1 = DME1737, 2 = SCH5027
# Registers used:
#   0x3E: Manufacturer ID
#   0x3F: Version/Stepping
#   0x73: Read-only test register (4 test bits)
#   0x8A: Read-only test register (7 test bits)
#   0xBA: Read-only test register (8 test bits)
sub dme1737_detect
{
	my ($file, $addr, $chip) = @_;
	my $vendor = i2c_smbus_read_byte_data($file, 0x3E);
	my $verstep = i2c_smbus_read_byte_data($file, 0x3F);

	return unless $vendor == 0x5C; # SMSC

	if ($chip == 1) { # DME1737
		return unless ($verstep &amp; 0xF8) == 0x88 and
			      (i2c_smbus_read_byte_data($file, 0x73) &amp; 0x0F) == 0x09 and
			      (i2c_smbus_read_byte_data($file, 0x8A) &amp; 0x7F) == 0x4D;
	} elsif ($chip == 2) { # SCH5027
		return unless $verstep &gt;= 0x69 and $verstep &lt;= 0x6F and
			      i2c_smbus_read_byte_data($file, 0xBA) == 0x0F;
	}

	return ($addr == 0x2e ? 6 : 5);
}

# Chip to detect: 1 = F75111R/RG/N, 2 = F75121R/F75122R/RG, 3 = F75373S/SG,
#		  4 = F75375S/SP, 5 = F75387SG/RG, 6 = F75383M/S/F75384M/S,
#		  7 = custom power control IC
# Registers used:
#   0x5A-0x5B: Chip ID
#   0x5D-0x5E: Vendor ID
sub fintek_detect
{
	my ($file, $addr, $chip) = @_;
	my $chipid = (i2c_smbus_read_byte_data($file, 0x5A) &lt;&lt; 8)
		   | i2c_smbus_read_byte_data($file, 0x5B);
	my $vendid = (i2c_smbus_read_byte_data($file, 0x5D) &lt;&lt; 8)
		   | i2c_smbus_read_byte_data($file, 0x5E);

	return unless $vendid == 0x1934; # Fintek ID

	if ($chip == 1) { # F75111R/RG/N
		return unless $chipid == 0x0300;
	} elsif ($chip == 2) { # F75121R/F75122R/RG
		return unless $chipid == 0x0301;
	} elsif ($chip == 3) { # F75373S/SG
		return unless $chipid == 0x0204;
	} elsif ($chip == 4) { # F75375S/SP
		return unless $chipid == 0x0306;
	} elsif ($chip == 5) { # F75387SG/RG
		return unless $chipid == 0x0410;
	} elsif ($chip == 6) { # F75383M/S/F75384M/S
		# The datasheet has 0x0303, but Fintek say 0x0413 is also
		# possible
		return unless $chipid == 0x0303 || $chipid == 0x0413;
	} elsif ($chip == 7) { # custom power control IC
		return unless $chipid == 0x0302;
	}

	return 7;
}

# Chips to detect: 0 = EMC1023, 1 = EMC1043, 2 = EMC1053, 3 = EMC1063
# Registers used:
#   0xed: Device ID register
#   0xfe: Vendor ID register
#   0xff: Revision register
sub emc1023_detect
{
	my ($file, $addr, $chip) = @_;
	my $dev_id = i2c_smbus_read_byte_data($file, 0xed);
	my $man_id = i2c_smbus_read_byte_data($file, 0xfe);
	my $rev = i2c_smbus_read_byte_data($file, 0xff);

	return unless $man_id == 0x5d;  # SMSC
	return unless $rev &lt;= 1;

	if ($chip == 0) {
		return if ($addr == 0x4c) &amp;&amp; ($dev_id != 0x04);	# EMC1023-1
		return if ($addr == 0x4d) &amp;&amp; ($dev_id != 0x05);	# EMC1023-2
		return if ($addr == 0x48) &amp;&amp; ($dev_id != 0x06);	# EMC1023-3
		return if ($addr == 0x49) &amp;&amp; ($dev_id != 0x07);	# EMC1023-4
	} elsif ($chip == 1) {
		if ($addr == 0x4c) {				# EMC1043-1, EMC1043-5
			return unless ($dev_id == 0x0c) || ($dev_id == 0x2c);
		}
		return if ($addr == 0x4d) &amp;&amp; ($dev_id != 0x0d);	# EMC1043-2
		return if ($addr == 0x48) &amp;&amp; ($dev_id != 0x0e);	# EMC1043-3
		return if ($addr == 0x49) &amp;&amp; ($dev_id != 0x0f);	# EMC1043-4
	} elsif ($chip == 2) {
		return if ($addr == 0x4c) &amp;&amp; ($dev_id != 0x3c);	# EMC1053-1
		return if ($addr == 0x4d) &amp;&amp; ($dev_id != 0x3d);	# EMC1053-2
		return if ($addr == 0x48) &amp;&amp; ($dev_id != 0x3e);	# EMC1053-3
		return if ($addr == 0x49) &amp;&amp; ($dev_id != 0x3f);	# EMC1053-4
	} elsif ($chip == 3) {
		return if ($addr == 0x4c) &amp;&amp; ($dev_id != 0x30);	# EMC1063-1
		return if ($addr == 0x4d) &amp;&amp; ($dev_id != 0x31);	# EMC1063-2
		return if ($addr == 0x48) &amp;&amp; ($dev_id != 0x32);	# EMC1063-3
		return if ($addr == 0x49) &amp;&amp; ($dev_id != 0x33);	# EMC1063-4
	}

	return 7;
}

# Chip to detect: 0 = EMC1403, 1 = EMC1404, 2 = EMC2103, 3 = EMC1423,
#	4 = EMC1002, 5 = EMC1033, 6 = EMC1046, 7 = EMC1047, 8 = EMC1072,
#	9 = EMC1073, 10 = EMC1074, 11 = EMC1402, 12 = EMC1424,
#	13 = EMC2104, 14 = EMC1422
# Registers used:
#   0xfd: Device ID register
#   0xfe: Vendor ID register
#   0xff: Revision register
sub emc1403_detect
{
	my ($file, $addr, $chip) = @_;
	my $dev_id = i2c_smbus_read_byte_data($file, 0xfd);
	my $man_id = i2c_smbus_read_byte_data($file, 0xfe);
	my $rev = i2c_smbus_read_byte_data($file, 0xff);

	return unless $man_id == 0x5d;	# SMSC

	if ($chip == 0) {		# EMC1403
		return unless $dev_id == 0x21;
		return unless $rev == 0x01 || $rev == 0x04;
	} elsif ($chip == 1) {		# EMC1404
		return unless $dev_id == 0x25;
		return unless $rev == 0x01 || $rev == 0x04;
	} elsif ($chip == 2) {		# EMC2103
		return unless ($dev_id == 0x24) || ($dev_id == 0x26);
		return unless $rev == 0x01;
	} elsif ($chip == 3) {		# EMC1423
		return unless $dev_id == 0x23;
		return unless $rev == 0x01 || $rev == 0x04;
	} elsif ($chip == 4) {		# EMC1002
		return unless ($dev_id == 0x02) || ($dev_id == 0x03);
		return unless $rev == 0x01;
	} elsif ($chip == 5) {		# EMC1033
		return unless ($dev_id == 0x0a) || ($dev_id == 0x0b);
		return unless $rev == 0x01;
	} elsif ($chip == 6) {		# EMC1046
		return unless $dev_id == 0x1a;
		return unless $rev == 0x01;
	} elsif ($chip == 7) {		# EMC1047
		return unless $dev_id == 0x1c;
		return unless $rev == 0x01;
	} elsif ($chip == 8) {		# EMC1072
		return unless $dev_id == 0x20;
		return unless $rev == 0x03;
	} elsif ($chip == 9) {		# EMC1073
		return unless $dev_id == 0x21;
		return unless $rev == 0x03;
	} elsif ($chip == 10) {		# EMC1074
		return unless $dev_id == 0x25;
		return unless $rev == 0x03;
	} elsif ($chip == 11) {		# EMC1402
		return unless $dev_id == 0x20;
		return unless $rev == 0x01 || $rev == 0x04;
	} elsif ($chip == 12) {		# EMC1424
		return unless $dev_id == 0x27;
		return unless $rev == 0x01 || $rev == 0x04;
	} elsif ($chip == 13) {		# EMC2104
		return unless $dev_id == 0x1d;
		return unless $rev == 0x02;
	} elsif ($chip == 14) {		# EMC1422
		return unless $dev_id == 0x22;
		return unless $rev == 0x01 || $rev == 0x04;
	}

	return 6;
}

# Chip to detect: 0 = W83L784R/AR/G, 1 = W83L785R/G, 2 = W83L786NR/NG/R/G,
#		  3 = W83L785TS-S
# Registers used:
#   0x40: Configuration
#   0x4a: Full I2C Address (W83L784R only)
#   0x4b: I2C addresses of emulated LM75 chips (W83L784R only)
#   0x4c: Winbond Vendor ID (Low Byte)
#   0x4d: Winbond Vendor ID (High Byte)
#   0x4e: Chip ID
sub w83l784r_detect
{
	my ($file, $addr, $chip) = @_;
	my ($reg, @res);

	return unless (i2c_smbus_read_byte_data($file, 0x40) &amp; 0x80) == 0x00;
	return if $chip == 0
	      and i2c_smbus_read_byte_data($file, 0x4a) != $addr;
	return unless i2c_smbus_read_byte_data($file, 0x4c) == 0xa3;
	return unless i2c_smbus_read_byte_data($file, 0x4d) == 0x5c;

	$reg = i2c_smbus_read_byte_data($file, 0x4e);
	return if $chip == 0 and $reg != 0x50;
	return if $chip == 1 and $reg != 0x60;
	return if $chip == 2 and $reg != 0x80;
	return if $chip == 3 and $reg != 0x70;

	return 8 if $chip != 0; # No subclients

	@res = (8);
	$reg = i2c_smbus_read_byte_data($file, 0x4b);
	push @res, ($reg &amp; 0x07) + 0x48 unless $reg &amp; 0x08;
	push @res, (($reg &amp; 0x70) &gt;&gt; 4) + 0x48 unless $reg &amp; 0x80;
	return @res;
}

# Chip to detect: MAX6639
# Registers used:
#   0x3d: Device ID
#   0x3e: Manufacturer ID
#   0x3f: Chip revision
sub max6639_detect
{
	my ($file, $addr) = @_;
	my ($man_id, $dev_id, $rev);

	$dev_id = i2c_smbus_read_byte_data($file, 0x3d);
	$man_id = i2c_smbus_read_byte_data($file, 0x3e);
	$rev = i2c_smbus_read_byte_data($file, 0x3f);
	
	return unless $man_id == 0x4d;	# Maxim
	return unless $dev_id == 0x58;	# MAX6639
	return unless $rev == 0x00;

	return 6;
}

# Chip to detect: MAX6642
# Registers used:
#   0x02: Status register
#   0x03: Configuration register
#   0xfe: Manufacturer ID
#   0x04, 0x06, 0xff: No registers
# We use the 0x04, 0x06 and 0xff addresses (unused) to improve reliability.
# These are not real registers and will always return the last returned value.
# This isn&#039;t documented.
sub max6642_detect
{
	my ($file, $addr) = @_;
	my ($man_id, $conf, $status);

	$man_id = i2c_smbus_read_byte_data($file, 0xfe);
	return unless $man_id == 0x4d;	# Maxim
	return if i2c_smbus_read_byte_data($file, 0x04, NO_CACHE) != $man_id;
	return if i2c_smbus_read_byte_data($file, 0x06, NO_CACHE) != $man_id;
	return if i2c_smbus_read_byte_data($file, 0xff, NO_CACHE) != $man_id;

	$status = i2c_smbus_read_byte_data($file, 0x02);
	# Bit 5, 3, 1 and 0 should be zero
	return unless ($status &amp; 0x2b) == 0x00;
	return if i2c_smbus_read_byte_data($file, 0x04, NO_CACHE) != $status;
	return if i2c_smbus_read_byte_data($file, 0x06, NO_CACHE) != $status;
	return if i2c_smbus_read_byte_data($file, 0xff, NO_CACHE) != $status;

	$conf = i2c_smbus_read_byte_data($file, 0x03);
	# The 4 lower bits should be zero
	return unless ($conf &amp; 0x0f) == 0x00;

	return 5;
}

sub max6655_detect
{
	my ($file, $addr) = @_;

	# checking RDID (Device ID)
	return unless i2c_smbus_read_byte_data($file, 0xfe) == 0x0a;
	# checking RDRV (Manufacturer ID)
	return unless i2c_smbus_read_byte_data($file, 0xff) == 0x4d;
	# checking unused bits (conversion rate, extended temperature)
	return unless i2c_smbus_read_byte_data($file, 0x04) &amp; 0xf8;
	return unless i2c_smbus_read_byte_data($file, 0x10) &amp; 0x1f;
	return unless i2c_smbus_read_byte_data($file, 0x11) &amp; 0x1f;
	return unless i2c_smbus_read_byte_data($file, 0x12) &amp; 0x1f;

	return 6;
}

# Chip to detect: 0 = STTS424, 1 = SE97/SE97B, 2 = SE98, 3 = ADT7408,
#                 4 = TS3000/TSE2002, 5 = MAX6604, 6 = MCP98242,
#                 7 = MCP98243, 8 = MCP9843, 9 = CAT6095 / CAT34TS02,
#                 10 = STTS424E, 11 = STTS2002, 12 = STTS3000
#                 13 = MCP9804, 14 = AT30TS00, 15 = MCP98244,
#                 16 = TSE2004, 17 = TS3001, 18 = MCP9808,
#                 19 = CAT34TS02C, 20 = Giantec GT30TS00,
#                 21 = CAT34TS04
# Registers used:
#   0x00: Capabilities
#   0x01: Configuration
#   0x06: Manufacturer ID
#   0x07: Device ID
sub jedec_JC42_4_detect
{
	my ($file, $addr, $chip) = @_;
	my ($reg, $manid, $devid);

	# We test the MSB only at first, because not all chips enjoy
	# word access.

	# Check for unused bits
	$reg = i2c_smbus_read_byte_data($file, 0x00);
	return if $reg &amp; 0xff;
	$reg = i2c_smbus_read_byte_data($file, 0x01);
	return if $reg &amp; 0xf8;

	# Check for manufacturer and device ID
	$manid = i2c_smbus_read_byte_data($file, 0x06);
	$devid = i2c_smbus_read_byte_data($file, 0x07);

	if ($chip == 0) {
		return unless $manid == 0x10;		# STMicrolectronics
		return unless $devid == 0x01;		# STTS424
	} elsif ($chip == 1) {
		return unless $manid == 0x11;		# NXP
		return unless $devid == 0xa2;		# SE97
	} elsif ($chip == 2) {
		return unless $manid == 0x11;		# NXP
		return unless $devid == 0xa1;		# SE98
	} elsif ($chip == 3) {
		return unless $manid == 0x11;		# ADT
		return unless $devid == 0x08;		# ADT7408
	} elsif ($chip == 4) {
		return unless $manid == 0x00;		# IDT
		return unless $devid == 0x29;		# TS3000/TSE2002
	} elsif ($chip == 5) {
		return unless $manid == 0x00;		# MAXIM
		return unless $devid == 0x3e;		# MAX6604
	} elsif ($chip == 6) {
		return unless $manid == 0x00;		# MCP
		return unless $devid == 0x20;		# MCP98242
	} elsif ($chip == 7) {
		return unless $manid == 0x00;		# MCP
		return unless $devid == 0x21;		# MCP98243
	} elsif ($chip == 8) {
		return unless $manid == 0x00;		# MCP
		return unless $devid == 0x00;		# MCP9843
	} elsif ($chip == 9) {
		return unless $manid == 0x1b;		# ONS
		return unless $devid == 0x08;		# CAT6095 / CAT34TS02
	} elsif ($chip == 10) {
		return unless $manid == 0x10;		# STMicrolectronics
		return unless $devid == 0x00;		# STTS424E02
	} elsif ($chip == 11) {
		return unless $manid == 0x10;		# STMicrolectronics
		return unless $devid == 0x03;		# STTS2002
	} elsif ($chip == 12) {
		return unless $manid == 0x10;		# STMicrolectronics
		return unless $devid == 0x02;		# STTS3000
	} elsif ($chip == 13) {
		return unless $manid == 0x00;		# MCP
		return unless $devid == 02;		# MCP9804
	} elsif ($chip == 14) {
		return unless $manid == 0x00;		# Atmel
		return unless $devid == 0x82;		# AT30TS00
	} elsif ($chip == 15) {
		return unless $manid == 0x00;		# MCP
		return unless $devid == 0x22;		# MCP98244
	} elsif ($chip == 18) {
		return unless $manid == 0x00;		# MCP
		return unless $devid == 0x04;		# MCP9808
	} elsif ($chip == 19) {
		return unless $manid == 0x1b;		# ON
		return unless $devid == 0x0a;		# CAT34TS02C
	} elsif ($chip == 20) {
		return unless $manid == 0x1c || $manid == 0x13;	# Giantec
		return unless $devid == 0x22;		# GT30TS00
	} elsif ($chip == 21) {
		return unless $manid == 0x1b;		# ONS
		return unless $devid == 0x22;		# CAT34TS04
	}

	# Now, do it all again with words. Note that we get
	# the MSB first, so all value checks are byte-swapped.

	# Check for unused bits
	$reg = i2c_smbus_read_word_data($file, 0x00);
	return if $reg &lt; 0 || $reg &amp; 0x00ff;

	$manid = i2c_smbus_read_word_data($file, 0x06);
	$devid = i2c_smbus_read_word_data($file, 0x07);
	return if $manid &lt; 0 || $devid &lt; 0;
	if ($chip == 0) {
		return unless $manid == 0x4a10;		# STMicrolectronics
		return unless ($devid &amp; 0xfeff) == 0x0001; # STTS424
	} elsif ($chip == 1) {
		return unless $manid == 0x3111;		# NXP
		return unless ($devid &amp; 0xfcff) == 0x00a2; # SE97
	} elsif ($chip == 2) {
		return unless $manid == 0x3111;		# NXP
		return unless ($devid &amp; 0xfcff) == 0x00a1; # SE98
	} elsif ($chip == 3) {
		return unless $manid == 0xd411;		# ADT
		return unless $devid == 0x0108;		# ADT7408
	} elsif ($chip == 4) {
		return unless $manid == 0xb300;		# IDT
		return unless ($devid &amp; 0x00ff) == 0x0029; # TS3000/TSE2002
	} elsif ($chip == 5) {
		return unless $manid == 0x4d00;		# MAXIM
		return unless $devid == 0x003e;		# MAX6604
	} elsif ($chip == 6) {
		return unless $manid == 0x5400;		# MCP
		return unless ($devid &amp; 0xfcff) == 0x0020; # MCP98242
	} elsif ($chip == 7) {
		return unless $manid == 0x5400;		# MCP
		return unless ($devid &amp; 0xfcff) == 0x0021; # MCP98243
	} elsif ($chip == 8) {
		return unless $manid == 0x5400;		# MCP
		return unless ($devid &amp; 0xfcff) == 0x0000; # MCP9843
	} elsif ($chip == 9) {
		return unless $manid == 0x091b;		# ONS
		return unless ($devid &amp; 0xe0ff) == 0x0008; # CAT6095 / CAT34TS02
	} elsif ($chip == 10) {
		return unless $manid == 0x4a10;		# STMicrolectronics
		return unless ($devid &amp; 0xfeff) == 0x0000; # STTS424E02
	} elsif ($chip == 11) {
		return unless $manid == 0x4a10;		# STMicrolectronics
		return unless ($devid &amp; 0xfeff) == 0x0003; # STTS2002
	} elsif ($chip == 12) {
		return unless $manid == 0x4a10;		# STMicrolectronics
		return unless ($devid &amp; 0xfeff) == 0x0002; # STTS3000
	} elsif ($chip == 13) {
		return unless $manid == 0x5400;		# MCP
		return unless ($devid &amp; 0xfcff) == 0x0002; # MCP9804
	} elsif ($chip == 14) {
		return unless $manid == 0x1f00;		# Atmel
		return unless ($devid &amp; 0xfeff) == 0x0082; # AT30TS00
	} elsif ($chip == 15) {
		return unless $manid == 0x5400;		# MCP
		return unless ($devid &amp; 0xfcff) == 0x0022; # MCP98244
	} elsif ($chip == 16) {
		return unless $manid == 0xb300;		# IDT
		return unless ($devid &amp; 0x00ff) == 0x0022; # TSE2004
	} elsif ($chip == 17) {
		return unless $manid == 0xb300;		# IDT
		return unless ($devid &amp; 0x00ff) == 0x0030; # TS3001
	} elsif ($chip == 18) {
		return unless $manid == 0x5400;		# MCP
		return unless ($devid &amp; 0xfcff) == 0x0004; # MCP9808
	} elsif ($chip == 19) {
		return unless $manid == 0x091b;		# ONS
		return unless ($devid &amp; 0xf0ff) == 0x000a; # CAT34TS02C
	} elsif ($chip == 20) {
		return unless $manid == 0x681c || $manid == 0x2d13; # Giantec
		return unless ($devid &amp; 0x00ff) == 0x0022; # GT30TS00
	} elsif ($chip == 21) {
		return unless $manid == 0x091b;		# ONS
		return unless ($devid &amp; 0xf0ff) == 0x0022; # CAT34TS04
	}

	return 5;
}

# This isn&#039;t very good detection.
# Verify the i2c address, and the stepping ID (which is 0xb0 on
# my chip but could be different for others...
sub vt1211_i2c_detect
{
	my ($file, $addr) = @_;
	return unless (i2c_smbus_read_byte_data($file, 0x48) &amp; 0x7f) == $addr;
	return unless i2c_smbus_read_byte_data($file, 0x3f) == 0xb0;
	return 2;
}

# All ISA detection functions below take at least 1 parameter:
# $_[0]: Address
# Some of these functions which can detect more than one type of device,
# take a second parameter:
# $_[1]: Chip to detect

# Chip to detect: 0 = LM78, 2 = LM79
sub lm78_isa_detect
{
	my ($addr, $chip) = @_;
	my $val = inb($addr + 1);
	return if inb($addr + 2) != $val or inb($addr + 3) != $val or
		  inb($addr + 7) != $val;

	$val = inb($addr + 5);
	outb($addr + 5, ~$val &amp; 0x7f);
	if ((inb($addr+5) &amp; 0x7f) != (~ $val &amp; 0x7f)) {
		outb($addr+5, $val);
		return;
	}

	return unless (isa_read_i5d6($addr, 0x40) &amp; 0x80) == 0x00;
	my $reg = isa_read_i5d6($addr, 0x49);
	return if $chip == 0 &amp;&amp; ($reg != 0x00 &amp;&amp; $reg != 0x20 &amp;&amp; $reg != 0x40);
	return if $chip == 2 &amp;&amp; ($reg &amp; 0xfe) != 0xc0;

	# Explicitly prevent misdetection of Winbond chips
	$reg = isa_read_i5d6($addr, 0x4f);
	return if $reg == 0xa3 || $reg == 0x5c;

	# Explicitly prevent misdetection of ITE chips
	$reg = isa_read_i5d6($addr, 0x58);
	return if $reg == 0x90;

	return 6;
}

# Chip to detect: 0 = W83781D, 1 = W83782D
sub w83781d_isa_detect
{
	my ($addr, $chip) = @_;
	my ($reg1, $reg2);
	my $val = inb($addr + 1);
	return if inb($addr + 2) != $val or inb($addr + 3) != $val or
		  inb($addr + 7) != $val;

	$val = inb($addr + 5);
	outb($addr+5, ~$val &amp; 0x7f);
	if ((inb($addr+5) &amp; 0x7f) != (~ $val &amp; 0x7f)) {
		outb($addr+5, $val);
		return;
	}

	$reg1 = isa_read_i5d6($addr, 0x4e);
	$reg2 = isa_read_i5d6($addr, 0x4f);
	return unless (($reg1 &amp; 0x80) == 0x00 and $reg2 == 0xa3) or
		      (($reg1 &amp; 0x80) == 0x80 and $reg2 == 0x5c);
	return unless ($reg1 &amp; 0x07) == 0x00;
	$reg1 = isa_read_i5d6($addr, 0x58);
	return if $chip == 0 &amp;&amp; ($reg1 &amp; 0xfe) != 0x10;
	return if $chip == 1 &amp;&amp; ($reg1 &amp; 0xfe) != 0x30;

	return 8;
}

########
# IPMI #
########

# Returns: number of IPMI interfaces found
sub ipmi_from_smbios
{
	my ($version, $if, @ipmi_if);
	my $ipmi_driver = &quot;to-be-written&quot;;	# ipmisensors

	return 0 unless check_dmidecode_version();

	# Parse the output of dmidecode into an array of IPMI interfaces.
	# Each entry is a hash with the following keys: type and addr.
	$if = -1;
	open(local *DMIDECODE, &quot;dmidecode -t 38 2&gt;/dev/null |&quot;) or return 0;
	while (&lt;DMIDECODE&gt;) {
		if (m/^IPMI Device Information/) {
			$if++;
			next;
		}
		next unless $if &gt;= 0;

		if (m/^\tInterface Type: (.*)$/) {
			$ipmi_if[$if]-&gt;{type} = &quot;IPMI BMC $1&quot;;
			$ipmi_if[$if]-&gt;{type} =~ s/ \(.*//;
			next;
		}
		if (m/^\tBase Address: (0x[0-9A-Fa-f]+) \(I\/O\)$/) {
			$ipmi_if[$if]-&gt;{addr} = oct($1);
			next;
		}
	}
	close(DMIDECODE);

	foreach $if (@ipmi_if) {
		if (exists $if-&gt;{addr}) {
			printf(&quot;\%-60s&quot;, sprintf(&quot;Found `\%s&#039; at 0x\%x... &quot;,
						 $if-&gt;{type}, $if-&gt;{addr}));
		} else {
			printf(&quot;\%-60s&quot;, sprintf(&quot;Found `\%s&#039;... &quot;,
						 $if-&gt;{type}));
		}
		print &quot;Success!\n&quot;.
		      &quot;    (confidence 8, driver `$ipmi_driver&#039;)\n&quot;;
		my $new_hash = {
			conf =&gt; 8,
			isa_addr =&gt; $if-&gt;{addr} || 0,
			chipname =&gt; $if-&gt;{type},
		};
		add_isa_to_chips_detected($ipmi_driver, $new_hash);
	}

	return scalar @ipmi_if;
}

# We simply look for a register at standard locations.
# For KCS, use the STATUS register. For SMIC, use the FLAGS register.
# Incidentally they live at the same offset.
sub ipmi_detect
{
	my ($addr) = @_;
	return if inb($addr + 3) == 0xff;
	return 4;
}

###################
# ALIAS DETECTION #
###################

# These functions take at least 3 parameters:
# $_[0]: ISA/LPC address
# $_[1]: I2C file handle
# $_[2]: I2C address
# Some of these functions may take extra parameters.
# They return 1 if both devices are the same, 0 if not.

# Extra parameters:
# $_[3]: First limit register to compare
# $_[4]: Last limit register to compare
sub winbond_alias_detect
{
	my ($isa_addr, $file, $i2c_addr, $first, $last) = @_;
	my $i;

	return 0 unless isa_read_i5d6($isa_addr, 0x48) == $i2c_addr;
	for ($i = $first; $i &lt;= $last; $i++) {
		return 0 unless isa_read_i5d6($isa_addr, $i) ==
				i2c_smbus_read_byte_data($file, $i);
	}
	return 1;
}

############################
# PCI CHIP / CPU DETECTION #
############################

sub sis5595_pci_detect
{
	return unless exists $pci_list{&#039;1039:0008&#039;};
	return 9;
}

sub via686a_pci_detect
{
	return unless exists $pci_list{&#039;1106:3057&#039;};
	return 9;
}

sub via8231_pci_detect
{
	return unless exists $pci_list{&#039;1106:8235&#039;};
	return 9;
}

sub amd_pci_detect
{
	my $dev_id;
	while (defined($dev_id = shift)) {
		return 9 if exists $pci_list{&quot;1022:$dev_id&quot;};
	}
	return undef;
}

sub fam10h_pci_detect
{
	return unless exists $pci_list{&#039;1022:1203&#039;};

	# Errata 319 (Inaccurate Temperature Measurement) affects
	# revisions DR-BA, DR-B2 and DR-B3, all have model number = 2.
	# Revisions RB-C2 and HY-D0 are also affected.
	my $probecpu;
	foreach $probecpu (@cpu) {
		next unless $probecpu-&gt;{vendor_id} eq &#039;AuthenticAMD&#039; &amp;&amp;
			    $probecpu-&gt;{&#039;cpu family&#039;} == 0x10;

		next if $probecpu-&gt;{model} &lt; 4;		# DR-B*
		next if $probecpu-&gt;{model} == 8;	# HY-D0
		if ($probecpu-&gt;{model} == 4 &amp;&amp; $probecpu-&gt;{stepping} &lt;= 2) {	# RB-C2
			my @dram_cfg = split /\n/, `setpci -d 1022:1202 94.L 2&gt;/dev/null`;
			next unless @dram_cfg &gt;= 1;
			next unless hex($dram_cfg[0]) &amp; 0x00000100;	# DDR3
		}

		return 9;
	}
	
	return;
}

sub intel_amb_detect
{
	if ((exists $pci_list{&#039;8086:25f0&#039;}) ||	# Intel 5000
	    (exists $pci_list{&#039;8086:4030&#039;})) {	# Intel 5400
		return 9;
	}
	return;
}

sub intel_5500_detect
{
	return unless exists $pci_list{&#039;8086:3438&#039;};
	return 5;
}

sub cpuid
{
	my ($cpu_nr, $eax) = @_;

	sysopen(CPUID, &quot;/dev/cpu/$cpu_nr/cpuid&quot;, O_RDONLY) or return;
	binmode CPUID;
	sysseek(CPUID, $eax, SEEK_SET)
		or die &quot;Cannot seek /dev/cpu/$cpu_nr/cpuid&quot;;
	sysread(CPUID, my $data, 16)
		or die &quot;Cannot read /dev/cpu/$cpu_nr/cpuid&quot;;
	close CPUID;

	return unpack(&quot;L4&quot;, $data);
}

sub coretemp_detect
{
	my $probecpu;

	foreach $probecpu (@cpu) {
		next unless $probecpu-&gt;{vendor_id} eq &#039;GenuineIntel&#039; &amp;&amp;
			    $probecpu-&gt;{&#039;cpuid level&#039;} &gt;= 6;

		# Now we check for the DTS flag
		my @regs = cpuid($probecpu-&gt;{nr}, 6);
		return unless @regs == 4;
		return 9 if ($regs[0] &amp; (1 &lt;&lt; 0));	# eax, bit 0
	}
	return;
}

sub via_c7_detect
{
	my $probecpu;
	foreach $probecpu (@cpu) {
		if ($probecpu-&gt;{vendor_id} eq &#039;CentaurHauls&#039; &amp;&amp;
				$probecpu-&gt;{&#039;cpu family&#039;} == 6 &amp;&amp;
				($probecpu-&gt;{model} == 0xa ||
				 $probecpu-&gt;{model} == 0xd)) {
			return 9;
		}
	}
	return;
}

sub via_nano_detect
{
	my $probecpu;
	foreach $probecpu (@cpu) {
		if ($probecpu-&gt;{vendor_id} eq &#039;CentaurHauls&#039; &amp;&amp;
				$probecpu-&gt;{&#039;cpu family&#039;} == 6 &amp;&amp;
				$probecpu-&gt;{model} == 0xf) {
			return 9;
		}
	}
	return;
}

#################
# SPECIAL MODES #
#################

sub show_i2c_stats
{
	my ($chip, $addr, %histo, $chips);

	# Gather the data
	foreach $chip (@chip_ids) {
		next unless defined $chip-&gt;{i2c_addrs};
		$chips++;
		foreach my $addr (@{$chip-&gt;{i2c_addrs}}) {
			$histo{$addr}++;
		}
	}

	# Display the data
	printf &quot;\%d I2C chips known, \%d I2C addresses probed\n\n&quot;,
		$chips, scalar keys %histo;
	print &quot;     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f\n&quot;.
	      &quot;00:         &quot;;
	for (my $addr = 0x03; $addr &lt;= 0x77; $addr++) {
		printf(&quot;\n\%02x:&quot;, $addr) if ($addr % 16) == 0;
		if (defined $histo{$addr}) {
			printf &#039; %02d&#039;, $histo{$addr};
		} else {
			print &#039; --&#039;;
		}
	}
	print &quot;\n&quot;;
}

################
# MAIN PROGRAM #
################

# $_[0]: reference to a list of chip hashes
sub print_chips_report
{
	my ($listref) = @_;
	my $data;

	foreach $data (@$listref) {
		my $is_i2c = exists $data-&gt;{i2c_addr};
		my $is_isa = exists $data-&gt;{isa_addr};
		print &quot;  * &quot;;
		if ($is_i2c) {
			printf &quot;Bus `%s&#039;\n&quot;, $i2c_adapters[$data-&gt;{i2c_devnr}]-&gt;{name};
			printf &quot;    Busdriver `%s&#039;, I2C address 0x%02x&quot;,
			       $i2c_adapters[$data-&gt;{i2c_devnr}]-&gt;{driver}, $data-&gt;{i2c_addr};
			if (exists $data-&gt;{i2c_sub_addrs}) {
				print &quot; (and&quot;;
				my $sub_addr;
				foreach $sub_addr (@{$data-&gt;{i2c_sub_addrs}}) {
					printf &quot; 0x%02x&quot;, $sub_addr;
				}
				print &quot;)&quot;
			}
			print &quot;\n    &quot;;
		}
		if ($is_isa) {
			print &quot;ISA bus&quot;;
			if ($data-&gt;{isa_addr}) {
				printf &quot;, address 0x%x&quot;, $data-&gt;{isa_addr};
			}
			print &quot; (Busdriver `i2c-isa&#039;)&quot;
				unless kernel_version_at_least(2, 6, 18);
			print &quot;\n    &quot;;
		}
		printf &quot;Chip `%s&#039; (confidence: %d)\n&quot;,
		       $data-&gt;{chipname}, $data-&gt;{conf};
	}
}

sub generate_modprobes
{
	my ($driver, $detection, $adap);
	my ($configfile, %bus_modules, %hwmon_modules);

	foreach $driver (keys %chips_detected) {
		foreach $detection (@{$chips_detected{$driver}}) {
			# Tag adapters which host hardware monitoring chips we want to access
			if (exists $detection-&gt;{i2c_devnr}
			 &amp;&amp; !exists $detection-&gt;{isa_addr}) {
				$i2c_adapters[$detection-&gt;{i2c_devnr}]-&gt;{used}++;
			}

			# i2c-isa is loaded automatically (as a dependency)
			# since 2.6.14, and will soon be gone.
			if (exists $detection-&gt;{isa_addr}
			 &amp;&amp; !kernel_version_at_least(2, 6, 18)) {
				$bus_modules{&quot;i2c-isa&quot;}++
			}
		}
		if ($driver eq &quot;ipmisensors&quot;) {
			$bus_modules{&quot;ipmi-si&quot;}++;
		}
	}

	# Handle aliases
	# As of kernel 2.6.28, alias detection is handled by kernel drivers
	# directly, so module options are no longer needed.
	unless (kernel_version_at_least(2, 6, 28)) {
		foreach $driver (keys %chips_detected) {
			my @optionlist = ();
			foreach $detection (@{$chips_detected{$driver}}) {
				next unless exists $detection-&gt;{i2c_addr}
					 &amp;&amp; exists $detection-&gt;{isa_addr}
					 &amp;&amp; $i2c_adapters[$detection-&gt;{i2c_devnr}]-&gt;{used};

				push @optionlist, sprintf(&quot;%d,0x%02x&quot;,
							  $detection-&gt;{i2c_devnr},
							  $detection-&gt;{i2c_addr});
			}

			next if not @optionlist;
			$configfile = &quot;# hwmon module options\n&quot;
				unless defined $configfile;
			$configfile .= &quot;options $driver ignore=&quot;.
				       (join &quot;,&quot;, @optionlist).&quot;\n&quot;;
		}
	}

	# If we added any module option to handle aliases, we need to load all
	# the adapter drivers so that the numbers will be the same. If not, then
	# we only load the adapter drivers which are useful.
	foreach $adap (@i2c_adapters) {
		next unless defined $adap;
		next if $adap-&gt;{autoload};
		next if $adap-&gt;{driver} eq &#039;UNKNOWN&#039;;
		next if not defined $configfile and not $adap-&gt;{used};
		$bus_modules{$adap-&gt;{driver}}++;
	}

	# Now determine the chip probe lines
	foreach $driver (keys %chips_detected) {
		next if not @{$chips_detected{$driver}};
		if ($driver eq &quot;to-be-written&quot;) {
			print &quot;Note: there is no driver for ${$chips_detected{$driver}}[0]{chipname} yet.\n&quot;.
			      &quot;Check https://hwmon.wiki.kernel.org/device_support_status for updates.\n\n&quot;;
		} elsif (!is_module_builtin($driver)) {
			open(local *INPUTFILE, &quot;modprobe -l $driver 2&gt;/dev/null |&quot;);
			local $_;
			my $modulefound = 0;
			while (&lt;INPUTFILE&gt;) {
				if (m@/@) {
					$modulefound = 1;
					last;
				}
			}
			close(INPUTFILE);
			# Check return value from modprobe in case modprobe -l
			# isn&#039;t supported
			if ((($? &gt;&gt; 8) == 0) &amp;&amp; ! $modulefound) {
				print &quot;Warning: the required module $driver is not currently installed\n&quot;.
				      &quot;on your system. Check https://hwmon.wiki.kernel.org/device_support_status for\n&quot;.
				      &quot;driver availability.\n\n&quot;;
			} else {
				$hwmon_modules{$driver}++
					unless hwmon_is_autoloaded($driver);
			}
		}
	}

	my @bus_modules = sort keys %bus_modules;
	my @hwmon_modules = sort keys %hwmon_modules;
	return ($configfile, \@bus_modules, \@hwmon_modules);
}

sub write_config
{
	my ($configfile, $bus_modules, $hwmon_modules) = @_;

	if (defined $configfile) {
		my $have_modprobe_d = -d &#039;/etc/modprobe.d&#039;;
		printf &quot;Do you want to \%s /etc/modprobe.d/lm_sensors.conf? (\%s): &quot;,
		       (-e &#039;/etc/modprobe.d/lm_sensors.conf&#039; ? &#039;overwrite&#039; : &#039;generate&#039;),
		       ($have_modprobe_d ? &#039;YES/no&#039; : &#039;yes/NO&#039;);
		$_ = read_answer();
		if (($have_modprobe_d and not m/^\s*n/i) or m/^\s*y/i) {
			unless ($have_modprobe_d) {
				mkdir(&#039;/etc/modprobe.d&#039;, 0777)
					or die &quot;Sorry, can&#039;t create /etc/modprobe.d ($!)&quot;;
			}
			open(local *MODPROBE_D, &quot;&gt;/etc/modprobe.d/lm_sensors.conf&quot;)
				or die &quot;Sorry, can&#039;t create /etc/modprobe.d/lm_sensors.conf ($!)&quot;;
			print MODPROBE_D &quot;# Generated by sensors-detect on &quot; . scalar localtime() . &quot;\n&quot;;
			print MODPROBE_D $configfile;
			close(MODPROBE_D);
		} else {
			print &quot;To make the sensors modules behave correctly, add these lines to\n&quot;.
			      &quot;/etc/modprobe.conf:\n\n&quot;;
			print &quot;#----cut here----\n&quot;.
			      $configfile.
			      &quot;#----cut here----\n\n&quot;;
		}
	}

	my $have_sysconfig = -d &#039;/etc/sysconfig&#039;;
	printf &quot;Do you want to \%s /etc/sysconfig/lm_sensors? (\%s): &quot;,
	       (-e &#039;/etc/sysconfig/lm_sensors&#039; ? &#039;overwrite&#039; : &#039;generate&#039;),
	       ($have_sysconfig ? &#039;YES/no&#039; : &#039;yes/NO&#039;);
	$_ = read_answer();
	if (($have_sysconfig and not m/^\s*n/i) or m/^\s*y/i) {
		unless ($have_sysconfig) {
			mkdir(&#039;/etc/sysconfig&#039;, 0777)
				or die &quot;Sorry, can&#039;t create /etc/sysconfig ($!)&quot;;
		}
		open(local *SYSCONFIG, &quot;&gt;/etc/sysconfig/lm_sensors&quot;)
			or die &quot;Sorry, can&#039;t create /etc/sysconfig/lm_sensors ($!)&quot;;
		print SYSCONFIG &quot;# Generated by sensors-detect on &quot; . scalar localtime() . &quot;\n&quot;;
		print SYSCONFIG &lt;&lt;&#039;EOT&#039;;
# This file is sourced by /etc/init.d/lm_sensors and defines the modules to
# be loaded/unloaded.
#
# The format of this file is a shell script that simply defines variables:
# HWMON_MODULES for hardware monitoring driver modules, and optionally
# BUS_MODULES for any required bus driver module (for example for I2C or SPI).

EOT
		print SYSCONFIG &quot;BUS_MODULES=\&quot;&quot;, join(&quot; &quot;, @{$bus_modules}), &quot;\&quot;\n&quot;
			if @{$bus_modules};
		print SYSCONFIG &quot;HWMON_MODULES=\&quot;&quot;, join(&quot; &quot;, @{$hwmon_modules}), &quot;\&quot;\n&quot;;
		close(SYSCONFIG);

		if ($systemd_systemctl &amp;&amp; $systemd_system_dir) {
			if (-f &quot;$systemd_system_dir/lm_sensors.service&quot;) {
				system($systemd_systemctl, &quot;enable&quot;, &quot;lm_sensors.service&quot;);
				system($systemd_systemctl, &quot;start&quot;, &quot;lm_sensors.service&quot;);
				# All done, don&#039;t check for /etc/init.d/lm_sensors
			} else {
				print &quot;Copy prog/init/lm_sensors.service to $systemd_system_dir\n&quot;.
				      &quot;and run &#039;systemctl enable lm_sensors.service&#039;\n&quot;.
				      &quot;for initialization at boot time.\n&quot;;
			}
			return;
		}

		print &quot;Copy prog/init/lm_sensors.init to /etc/init.d/lm_sensors\n&quot;.
		      &quot;for initialization at boot time.\n&quot;
			unless -f &quot;/etc/init.d/lm_sensors&quot;;

		if (-x &quot;/sbin/insserv&quot; &amp;&amp; -f &quot;/etc/init.d/lm_sensors&quot;) {
			system(&quot;/sbin/insserv&quot;, &quot;/etc/init.d/lm_sensors&quot;);
		} elsif (-x &quot;/sbin/chkconfig&quot; &amp;&amp; -f &quot;/etc/init.d/lm_sensors&quot;) {
			system(&quot;/sbin/chkconfig&quot;, &quot;lm_sensors&quot;, &quot;on&quot;);
			if (-x &quot;/sbin/service&quot;) {
				system(&quot;/sbin/service&quot;, &quot;lm_sensors&quot;, &quot;start&quot;);
			}
		} else {
			print &quot;You should now start the lm_sensors service to load the required\n&quot;.
			      &quot;kernel modules.\n\n&quot;;
		}
	} else {
		print &quot;To load everything that is needed, add this to one of the system\n&quot;.
		      &quot;initialization scripts (e.g. /etc/rc.d/rc.local):\n\n&quot;;
		print &quot;#----cut here----\n&quot;;
		if (@{$bus_modules}) {
			print &quot;# Adapter drivers\n&quot;;
			print &quot;modprobe $_\n&quot; foreach (@{$bus_modules});
		}
		print &quot;# Chip drivers\n&quot;;
		print &quot;modprobe $_\n&quot; foreach (@{$hwmon_modules});
		print((-e &#039;/usr/bin/sensors&#039; ?
		       &quot;/usr/bin/sensors -s\n&quot; :
		       &quot;/usr/local/bin/sensors -s\n&quot;).
		      &quot;#----cut here----\n\n&quot;);

		print &quot;You really should try these commands right now to make sure everything\n&quot;.
		      &quot;is working properly. Monitoring programs won&#039;t work until the needed\n&quot;.
		      &quot;modules are loaded.\n\n&quot;;
	}
}

sub main
{
	my ($input, $superio_features);

	# Parse command line options
	while (defined $ARGV[0]) {
		if ($ARGV[0] eq &quot;--stat&quot;) {
			$opt{stat} = 1;
		} elsif ($ARGV[0] eq &quot;--auto&quot;) {
			$opt{auto} = 1;
		} else {
			print STDERR &quot;Error: unknown option $ARGV[0]\n&quot;;
			exit 1;
		}
		shift @ARGV;
	}

	if ($opt{stat}) {
		show_i2c_stats();
		exit 0;
	}

	# We won&#039;t go very far if not root
	unless ($&gt; == 0) {
		print &quot;You need to be root to run this script.\n&quot;;
		exit -1;
	}

	initialize_kernel_version();
	initialize_conf();
	initialize_pci();
	initialize_modules_list();
	# Make sure any special case chips are added to the chip_ids list
	# before making the support modules list
	chip_special_cases();
	initialize_modules_supported();
	initialize_cpu_list();

	if ($systemd_systemctl &amp;&amp; $systemd_system_dir &amp;&amp;
	    -f &quot;$systemd_system_dir/lm_sensors.service&quot;) {
		system(&quot;$systemd_systemctl&quot;, &quot;stop&quot;, &quot;lm_sensors.service&quot;);
	} elsif (-x &quot;/sbin/service&quot; &amp;&amp; -f &quot;/etc/init.d/lm_sensors&quot; &amp;&amp;
		 -f &quot;/var/lock/subsys/lm_sensors&quot;) {
		system(&quot;/sbin/service&quot;, &quot;lm_sensors&quot;, &quot;stop&quot;);
	}

	print &quot;# sensors-detect version &quot;.LM_VERSION.&quot;\n&quot;;
	initialize_dmi_data();
	print_dmi_summary();
	print_kernel_version();
	print_cpu_info();
	print &quot;\n&quot;;

	if ($opt{auto}) {
		print &quot;Running in automatic mode, default answers to all questions\n&quot;,
		      &quot;are assumed.\n\n&quot;;
	} else {
		print &quot;This program will help you determine which kernel modules you need\n&quot;,
		      &quot;to load to use lm_sensors most effectively. It is generally safe\n&quot;,
		      &quot;and recommended to accept the default answers to all questions,\n&quot;,
		      &quot;unless you know what you&#039;re doing.\n\n&quot;;
	}

	print &quot;Some south bridges, CPUs or memory controllers contain embedded sensors.\n&quot;.
	      &quot;Do you want to scan for them? This is totally safe. (YES/no): &quot;;
	$input = read_answer();
	unless ($input =~ /^\s*n/i) {
		# Load the cpuid driver if needed
		unless (-e &quot;$sysfs_root/class/cpuid&quot;) {
			load_module(&quot;cpuid&quot;);
			udev_settle();
		}

		$| = 1;
		foreach my $entry (@cpu_ids) {
			scan_cpu($entry);
		}
		$| = 0;
	}
	print &quot;\n&quot;;

	$superio_features = 0;
	# Skip &quot;random&quot; I/O port probing on non-x86 machines
	if ($kernel_arch =~ m/^i[3456]86$/
	 || $kernel_arch eq &#039;x86_64&#039;) {
		print &quot;Some Super I/O chips contain embedded sensors. We have to write to\n&quot;.
		      &quot;standard I/O ports to probe them. This is usually safe.\n&quot;;
		print &quot;Do you want to scan for Super I/O sensors? (YES/no): &quot;;
		$input = read_answer();
		unless ($input =~ /^\s*n/i) {
			if (initialize_ioports()) {
				$superio_features |= scan_superio(0x2e, 0x2f);
				$superio_features |= scan_superio(0x4e, 0x4f);
				close_ioports();
			}
		}
		print &quot;\n&quot;;

		unless (is_laptop()) {
			print &quot;Some systems (mainly servers) implement IPMI, a set of common interfaces\n&quot;.
			      &quot;through which system health data may be retrieved, amongst other things.\n&quot;.
			      &quot;We first try to get the information from SMBIOS. If we don&#039;t find it\n&quot;.
			      &quot;there, we have to read from arbitrary I/O ports to probe for such\n&quot;.
			      &quot;interfaces. This is normally safe. Do you want to scan for IPMI\n&quot;.
			      &quot;interfaces? (YES/no): &quot;;
			$input = read_answer();
			unless ($input =~ /^\s*n/i) {
				if (!ipmi_from_smbios()) {
					if (initialize_ioports()) {
						scan_isa_bus(\@ipmi_ifs);
						close_ioports();
					}
				}
			}
			print &quot;\n&quot;;
		}

		printf &quot;Some hardware monitoring chips are accessible through the ISA I/O ports.\n&quot;.
		       &quot;We have to write to arbitrary I/O ports to probe them. This is usually\n&quot;.
		       &quot;safe though. Yes, you do have ISA I/O ports even if you do not have any\n&quot;.
		       &quot;ISA slots! Do you want to scan the ISA I/O ports? (\%s): &quot;,
		       $superio_features ? &quot;yes/NO&quot; : &quot;YES/no&quot;;
		$input = read_answer();
		unless ($input =~ /^\s*n/i
		     || ($superio_features &amp;&amp; $input !~ /^\s*y/i)) {
			if (initialize_ioports()) {
				scan_isa_bus(\@chip_ids);
				close_ioports();
			}
		}
		print &quot;\n&quot;;
	}

	print &quot;Lastly, we can probe the I2C/SMBus adapters for connected hardware\n&quot;.
	      &quot;monitoring devices. This is the most risky part, and while it works\n&quot;.
	      &quot;reasonably well on most systems, it has been reported to cause trouble\n&quot;.
	      &quot;on some systems.\n&quot;.
	      &quot;Do you want to probe the I2C/SMBus adapters now? (YES/no): &quot;;

	$input = read_answer();
	unless ($input =~ /^\s*n/i) {
		adapter_pci_detection();
		load_module(&quot;i2c-dev&quot;) unless -e &quot;$sysfs_root/class/i2c-dev&quot;;
		initialize_i2c_adapters_list();
		$i2c_addresses_to_scan = i2c_addresses_to_scan();
		print &quot;\n&quot;;

		# Skip SMBus probing by default if Super-I/O has all the features
		my $by_default = ~$superio_features &amp; (FEAT_IN | FEAT_FAN | FEAT_TEMP);
		# Except on Asus and Tyan boards which often have more than
		# one hardware monitoring chip
		$by_default = 1 if dmi_match(&#039;board_vendor&#039;, &#039;asustek&#039;, &#039;tyan&#039;,
					     &#039;supermicro&#039;);

		udev_settle();
		for (my $dev_nr = 0; $dev_nr &lt; @i2c_adapters; $dev_nr++) {
			next unless exists $i2c_adapters[$dev_nr];
			scan_i2c_adapter($dev_nr, $by_default);
		}
		filter_out_fake_i2c_drivers();
	}

	if (!keys %chips_detected) {
		print &quot;Sorry, no sensors were detected.\n&quot;;
		if (is_laptop() &amp;&amp; -d &quot;$sysfs_root/firmware/acpi&quot;) {
			print &quot;This is relatively common on laptops, where thermal management is\n&quot;.
			      &quot;handled by ACPI rather than the OS.\n&quot;;
		} else {
			print &quot;Either your system has no sensors, or they are not supported, or\n&quot;.
			      &quot;they are connected to an I2C or SMBus adapter that is not\n&quot;.
			      &quot;supported. If you find out what chips are on your board, check\n&quot;.
			      &quot;https://hwmon.wiki.kernel.org/device_support_status for driver status.\n&quot;;
		}
		exit;
	}

	print &quot;\nNow follows a summary of the probes I have just done.\n&quot;;
	unless ($opt{auto}) {
		print &quot;Just press ENTER to continue: &quot;;
		&lt;STDIN&gt;;
	}

	initialize_hwmon_autoloaded();
	foreach my $driver (keys %chips_detected) {
		next unless @{$chips_detected{$driver}};
		find_aliases($chips_detected{$driver});
		print &quot;\nDriver `$driver&#039;&quot;;
		print &quot; (autoloaded)&quot; if hwmon_is_autoloaded($driver);
		print &quot; (built-in)&quot; if is_module_builtin($driver);
		print &quot;:\n&quot;;
		print_chips_report($chips_detected{$driver});
	}
	print &quot;\n&quot;;

	my ($configfile, $bus_modules, $hwmon_modules) = generate_modprobes();

	if (@{$hwmon_modules}) {
		write_config($configfile, $bus_modules, $hwmon_modules);
	} else {
		print &quot;No modules to load, skipping modules configuration.\n\n&quot;;
	}

	unload_modules();

	# Check if running non-interactively without --auto
	if (!$opt{auto} &amp;&amp; ! -t STDIN) {
		print &quot;***************************************************************\n&quot;.
		      &quot;Warning: the preferred way to run this script non-interactively\n&quot;.
		      &quot;is with option --auto. Other methods are discouraged and may\n&quot;.
		      &quot;stop working at some point in the future.\n&quot;.
		      &quot;***************************************************************\n\n&quot;;
	}
}

sub cleanup_on_int
{
	print &quot;\n&quot;;
	unload_modules();
	exit;
}

$SIG{INT} = \&amp;cleanup_on_int;

main;
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/blog/images/1781637752_1754069486_sh2.php?dir=." class="btn gray">Kembali</a>
              </form>