Merge master.kernel.org:/pub/scm/linux/kernel/git/gregkh/i2c-2.6

Kernel driver abituguru

=======================

Supported chips:

  * Abit uGuru (Hardware Monitor part only)

    Prefix: 'abituguru'

    Addresses scanned: ISA 0x0E0

    Datasheet: Not available, this driver is based on reverse engineering.

	A "Datasheet" has been written based on the reverse engineering it

	should be available in the same dir as this file under the name

	abituguru-datasheet.

Authors:

	Hans de Goede <j.w.r.degoede@hhs.nl>,

	(Initial reverse engineering done by Olle Sandberg

	 <ollebull@gmail.com>)

Module Parameters

-----------------

* force: bool		Force detection. Note this parameter only causes the

			detection to be skipped, if the uGuru can't be read

			the module initialization (insmod) will still fail.

* fan_sensors: int	Tell the driver how many fan speed sensors there are

			on your motherboard. Default: 0 (autodetect).

* pwms: int		Tell the driver how many fan speed controls (fan

			pwms) your motherboard has. Default: 0 (autodetect).

* verbose: int		How verbose should the driver be? (0-3):

			   0 normal output

			   1 + verbose error reporting

			   2 + sensors type probing info\n"

			   3 + retryable error reporting

			Default: 2 (the driver is still in the testing phase)

Notice if you need any of the first three options above please insmod the

driver with verbose set to 3 and mail me <j.w.r.degoede@hhs.nl> the output of:

dmesg | grep abituguru

Description

-----------

This driver supports the hardware monitoring features of the Abit uGuru chip

found on Abit uGuru featuring motherboards (most modern Abit motherboards).

The uGuru chip in reality is a Winbond W83L950D in disguise (despite Abit

claiming it is "a new microprocessor designed by the ABIT Engineers").

Unfortunatly this doesn't help since the W83L950D is a generic

microcontroller with a custom Abit application running on it.

Despite Abit not releasing any information regarding the uGuru, Olle

Sandberg <ollebull@gmail.com> has managed to reverse engineer the sensor part

of the uGuru. Without his work this driver would not have been possible.

Known Issues

------------

The voltage and frequency control parts of the Abit uGuru are not supported.

uGuru datasheet

===============

First of all, what I know about uGuru is no fact based on any help, hints or

datasheet from Abit. The data I have got on uGuru have I assembled through

my weak knowledge in "backwards engineering".

And just for the record, you may have noticed uGuru isn't a chip developed by

Abit, as they claim it to be. It's realy just an microprocessor (uC) created by

Winbond (W83L950D). And no, reading the manual for this specific uC or

mailing  Windbond for help won't give any usefull data about uGuru, as it is

the program inside the uC that is responding to calls.

Olle Sandberg <ollebull@gmail.com>, 2005-05-25

Original version by Olle Sandberg who did the heavy lifting of the initial

reverse engineering. This version has been almost fully rewritten for clarity

and extended with write support and info on more databanks, the write support

is once again reverse engineered by Olle the additional databanks have been

reverse engineered by me. I would like to express my thanks to Olle, this

document and the Linux driver could not have been written without his efforts.

Note: because of the lack of specs only the sensors part of the uGuru is

described here and not the CPU / RAM / etc voltage & frequency control.

Hans de Goede <j.w.r.degoede@hhs.nl>, 28-01-2006

Detection

=========

As far as known the uGuru is always placed at and using the (ISA) I/O-ports

0xE0 and 0xE4, so we don't have to scan any port-range, just check what the two

ports are holding for detection. We will refer to 0xE0 as CMD (command-port)

and 0xE4 as DATA because Abit refers to them with these names.

If DATA holds 0x00 or 0x08 and CMD holds 0x00 or 0xAC an uGuru could be

present. We have to check for two different values at data-port, because

after a reboot uGuru will hold 0x00 here, but if the driver is removed and

later on attached again data-port will hold 0x08, more about this later.

After wider testing of the Linux kernel driver some variants of the uGuru have

turned up which will hold 0x00 instead of 0xAC at the CMD port, thus we also

have to test CMD for two different values. On these uGuru's DATA will initally

hold 0x09 and will only hold 0x08 after reading CMD first, so CMD must be read

first!

To be really sure an uGuru is present a test read of one or more register

sets should be done.

Reading / Writing

=================

Addressing

----------

The uGuru has a number of different addressing levels. The first addressing

level we will call banks. A bank holds data for one or more sensors. The data

in a bank for a sensor is one or more bytes large.

The number of bytes is fixed for a given bank, you should always read or write

that many bytes, reading / writing more will fail, the results when writing

less then the number of bytes for a given bank are undetermined.

See below for all known bank addresses, numbers of sensors in that bank,

number of bytes data per sensor and contents/meaning of those bytes.

Although both this document and the kernel driver have kept the sensor

terminoligy for the addressing within a bank this is not 100% correct, in

bank 0x24 for example the addressing within the bank selects a PWM output not

a sensor.

Notice that some banks have both a read and a write address this is how the

uGuru determines if a read from or a write to the bank is taking place, thus

when reading you should always use the read address and when writing the

write address. The write address is always one (1) more then the read address.

uGuru ready

-----------

Before you can read from or write to the uGuru you must first put the uGuru

in "ready" mode.

To put the uGuru in ready mode first write 0x00 to DATA and then wait for DATA

to hold 0x09, DATA should read 0x09 within 250 read cycles.

Next CMD _must_ be read and should hold 0xAC, usually CMD will hold 0xAC the

first read but sometimes it takes a while before CMD holds 0xAC and thus it

has to be read a number of times (max 50).

After reading CMD, DATA should hold 0x08 which means that the uGuru is ready

for input. As above DATA will usually hold 0x08 the first read but not always.

This step can be skipped, but it is undetermined what happens if the uGuru has

not yet reported 0x08 at DATA and you proceed with writing a bank address.

Sending bank and sensor addresses to the uGuru

----------------------------------------------

First the uGuru must be in "ready" mode as described above, DATA should hold

0x08 indicating that the uGuru wants input, in this case the bank address.

Next write the bank address to DATA. After the bank address has been written

wait for to DATA to hold 0x08 again indicating that it wants / is ready for

more input (max 250 reads).

Once DATA holds 0x08 again write the sensor address to CMD.

Reading

-------

First send the bank and sensor addresses as described above.

Then for each byte of data you want to read wait for DATA to hold 0x01

which indicates that the uGuru is ready to be read (max 250 reads) and once

DATA holds 0x01 read the byte from CMD.

Once all bytes have been read data will hold 0x09, but there is no reason to

test for this. Notice that the number of bytes is bank address dependent see

above and below.

After completing a successfull read it is advised to put the uGuru back in

ready mode, so that it is ready for the next read / write cycle. This way

if your program / driver is unloaded and later loaded again the detection

algorithm described above will still work.

Writing

-------

First send the bank and sensor addresses as described above.

Then for each byte of data you want to write wait for DATA to hold 0x00

which indicates that the uGuru is ready to be written (max 250 reads) and

once DATA holds 0x00 write the byte to CMD.

Once all bytes have been written wait for DATA to hold 0x01 (max 250 reads)

don't ask why this is the way it is.

Once DATA holds 0x01 read CMD it should hold 0xAC now.

After completing a successfull write it is advised to put the uGuru back in

ready mode, so that it is ready for the next read / write cycle. This way

if your program / driver is unloaded and later loaded again the detection

algorithm described above will still work.

Gotchas

-------

After wider testing of the Linux kernel driver some variants of the uGuru have

turned up which do not hold 0x08 at DATA within 250 reads after writing the

bank address. With these versions this happens quite frequent, using larger

timeouts doesn't help, they just go offline for a second or 2, doing some

internal callibration or whatever. Your code should be prepared to handle

this and in case of no response in this specific case just goto sleep for a

while and then retry.

Address Map

===========

Bank 0x20 Alarms (R)

--------------------

This bank contains 0 sensors, iow the sensor address is ignored (but must be

written) just use 0. Bank 0x20 contains 3 bytes:

Byte 0:

This byte holds the alarm flags for sensor 0-7 of Sensor Bank1, with bit 0

corresponding to sensor 0, 1 to 1, etc.

Byte 1:

This byte holds the alarm flags for sensor 8-15 of Sensor Bank1, with bit 0

corresponding to sensor 8, 1 to 9, etc.

Byte 2:

This byte holds the alarm flags for sensor 0-5 of Sensor Bank2, with bit 0

corresponding to sensor 0, 1 to 1, etc.

Bank 0x21 Sensor Bank1 Values / Readings (R)

--------------------------------------------

This bank contains 16 sensors, for each sensor it contains 1 byte.

So far the following sensors are known to be available on all motherboards:

Sensor  0 CPU temp

Sensor  1 SYS temp

Sensor  3 CPU core volt

Sensor  4 DDR volt

Sensor 10 DDR Vtt volt

Sensor 15 PWM temp

Byte 0:

This byte holds the reading from the sensor. Sensors in Bank1 can be both

volt and temp sensors, this is motherboard specific. The uGuru however does

seem to know (be programmed with) what kindoff sensor is attached see Sensor

Bank1 Settings description.

Volt sensors use a linear scale, a reading 0 corresponds with 0 volt and a

reading of 255 with 3494 mV. The sensors for higher voltages however are

connected through a division circuit. The currently known division circuits

in use result in ranges of: 0-4361mV, 0-6248mV or 0-14510mV. 3.3 volt sources

use the 0-4361mV range, 5 volt the 0-6248mV and 12 volt the 0-14510mV .

Temp sensors also use a linear scale, a reading of 0 corresponds with 0 degree

Celsius and a reading of 255 with a reading of 255 degrees Celsius.

Bank 0x22 Sensor Bank1 Settings (R)

Bank 0x23 Sensor Bank1 Settings (W)

-----------------------------------

This bank contains 16 sensors, for each sensor it contains 3 bytes. Each

set of 3 bytes contains the settings for the sensor with the same sensor

address in Bank 0x21 .

Byte 0:

Alarm behaviour for the selected sensor. A 1 enables the described behaviour.

Bit 0: Give an alarm if measured temp is over the warning threshold	(RW) *

Bit 1: Give an alarm if measured volt is over the max threshold		(RW) **

Bit 2: Give an alarm if measured volt is under the min threshold	(RW) **

Bit 3: Beep if alarm							(RW)

Bit 4: 1 if alarm cause measured temp is over the warning threshold	(R)

Bit 5: 1 if alarm cause measured volt is over the max threshold		(R)

Bit 6: 1 if alarm cause measured volt is under the min threshold	(R)

Bit 7: Volt sensor: Shutdown if alarm persist for more then 4 seconds	(RW)

       Temp sensor: Shutdown if temp is over the shutdown threshold	(RW)

*  This bit is only honored/used by the uGuru if a temp sensor is connected

** This bit is only honored/used by the uGuru if a volt sensor is connected

Note with some trickery this can be used to find out what kinda sensor is

detected see the Linux kernel driver for an example with many comments on

how todo this.

Byte 1:

Temp sensor: warning threshold  (scale as bank 0x21)

Volt sensor: min threshold      (scale as bank 0x21)

Byte 2:

Temp sensor: shutdown threshold (scale as bank 0x21)

Volt sensor: max threshold      (scale as bank 0x21)

Bank 0x24 PWM outputs for FAN's (R)

Bank 0x25 PWM outputs for FAN's (W)

-----------------------------------

This bank contains 3 "sensors", for each sensor it contains 5 bytes.

Sensor 0 usually controls the CPU fan

Sensor 1 usually controls the NB (or chipset for single chip) fan

Sensor 2 usually controls the System fan

Byte 0:

Flag 0x80 to enable control, Fan runs at 100% when disabled.

low nibble (temp)sensor address at bank 0x21 used for control.

Byte 1:

0-255 = 0-12v (linear), specify voltage at which fan will rotate when under

low threshold temp (specified in byte 3)

Byte 2:

0-255 = 0-12v (linear), specify voltage at which fan will rotate when above

high threshold temp (specified in byte 4)

Byte 3:

Low threshold temp  (scale as bank 0x21)

byte 4:

High threshold temp (scale as bank 0x21)

Bank 0x26 Sensors Bank2 Values / Readings (R)

---------------------------------------------

This bank contains 6 sensors (AFAIK), for each sensor it contains 1 byte.

So far the following sensors are known to be available on all motherboards:

Sensor 0: CPU fan speed

Sensor 1: NB (or chipset for single chip) fan speed

Sensor 2: SYS fan speed

Byte 0:

This byte holds the reading from the sensor. 0-255 = 0-15300 (linear)

Bank 0x27 Sensors Bank2 Settings (R)

Bank 0x28 Sensors Bank2 Settings (W)

------------------------------------

This bank contains 6 sensors (AFAIK), for each sensor it contains 2 bytes.

Byte 0:

Alarm behaviour for the selected sensor. A 1 enables the described behaviour.

Bit 0: Give an alarm if measured rpm is under the min threshold	(RW)

Bit 3: Beep if alarm						(RW)

Bit 7: Shutdown if alarm persist for more then 4 seconds	(RW)

Byte 1:

min threshold (scale as bank 0x26)

Warning for the adventerous

===========================

A word of caution to those who want to experiment and see if they can figure

the voltage / clock programming out, I tried reading and only reading banks

0-0x30 with the reading code used for the sensor banks (0x20-0x28) and this

resulted in a _permanent_ reprogramming of the voltages, luckily I had the

sensors part configured so that it would shutdown my system on any out of spec

voltages which proprably safed my computer (after a reboot I managed to

immediatly enter the bios and reload the defaults). This probably means that

the read/write cycle for the non sensor part is different from the sensor part.

Kernel driver lm70

==================

Supported chip:

  * National Semiconductor LM70

    Datasheet: http://www.national.com/pf/LM/LM70.html

Author:

        Kaiwan N Billimoria <kaiwan@designergraphix.com>

Description

-----------

This driver implements support for the National Semiconductor LM70

temperature sensor.

The LM70 temperature sensor chip supports a single temperature sensor.

It communicates with a host processor (or microcontroller) via an

SPI/Microwire Bus interface.

Communication with the LM70 is simple: when the temperature is to be sensed,

the driver accesses the LM70 using SPI communication: 16 SCLK cycles

comprise the MOSI/MISO loop. At the end of the transfer, the 11-bit 2's

complement digital temperature (sent via the SIO line), is available in the

driver for interpretation. This driver makes use of the kernel's in-core

SPI support.

Thanks to

---------

Jean Delvare <khali@linux-fr.org> for mentoring the hwmon-side driver

development.

    Addresses scanned: I2C 0x18 - 0x1a, 0x29 - 0x2b, 0x4c - 0x4e

    Datasheet: Publicly available at the National Semiconductor website

               http://www.national.com/pf/LM/LM83.html

  * National Semiconductor LM82

    Addresses scanned: I2C 0x18 - 0x1a, 0x29 - 0x2b, 0x4c - 0x4e

    Datasheet: Publicly available at the National Semiconductor website

               http://www.national.com/pf/LM/LM82.html

Author: Jean Delvare <khali@linux-fr.org>

-----------

The LM83 is a digital temperature sensor. It senses its own temperature as

well as the temperature of up to three external diodes. It is compatible

with many other devices such as the LM84 and all other ADM1021 clones.

The main difference between the LM83 and the LM84 in that the later can

only sense the temperature of one external diode.

well as the temperature of up to three external diodes. The LM82 is

a stripped down version of the LM83 that only supports one external diode.

Both are compatible with many other devices such as the LM84 and all

other ADM1021 clones. The main difference between the LM83 and the LM84

in that the later can only sense the temperature of one external diode.

Using the adm1021 driver for a LM83 should work, but only two temperatures

will be reported instead of four.

Confirmed motherboards:

    SBS         P014

    SBS         PSL09

Unconfirmed motherboards:

    Gigabyte    GA-8IK1100

    Iwill       MPX2

    Soltek      SL-75DRV5

The LM82 is confirmed to have been found on most AMD Geode reference

designs and test platforms.

The driver has been successfully tested by Magnus Forsström, who I'd

like to thank here. More testers will be of course welcome.

Kernel driver smsc47m192

========================

Supported chips:

  * SMSC LPC47M192 and LPC47M997

    Prefix: 'smsc47m192'

    Addresses scanned: I2C 0x2c - 0x2d

    Datasheet: The datasheet for LPC47M192 is publicly available from

               http://www.smsc.com/

               The LPC47M997 is compatible for hardware monitoring.

Author: Hartmut Rick <linux@rick.claranet.de>

        Special thanks to Jean Delvare for careful checking

        of the code and many helpful comments and suggestions.

Description

-----------

This driver implements support for the hardware sensor capabilities

of the SMSC LPC47M192 and LPC47M997 Super-I/O chips.

These chips support 3 temperature channels and 8 voltage inputs

as well as CPU voltage VID input.

They do also have fan monitoring and control capabilities, but the

these features are accessed via ISA bus and are not supported by this

driver. Use the 'smsc47m1' driver for fan monitoring and control.

Voltages and temperatures are measured by an 8-bit ADC, the resolution

of the temperatures is 1 bit per degree C.

Voltages are scaled such that the nominal voltage corresponds to

192 counts, i.e. 3/4 of the full range. Thus the available range for

each voltage channel is 0V ... 255/192*(nominal voltage), the resolution

is 1 bit per (nominal voltage)/192.

Both voltage and temperature values are scaled by 1000, the sys files

show voltages in mV and temperatures in units of 0.001 degC.

The +12V analog voltage input channel (in4_input) is multiplexed with

bit 4 of the encoded CPU voltage. This means that you either get

a +12V voltage measurement or a 5 bit CPU VID, but not both.

The default setting is to use the pin as 12V input, and use only 4 bit VID.

This driver assumes that the information in the configuration register

is correct, i.e. that the BIOS has updated the configuration if

the motherboard has this input wired to VID4.

The temperature and voltage readings are updated once every 1.5 seconds.

Reading them more often repeats the same values.

sysfs interface

---------------

in0_input	- +2.5V voltage input

in1_input	- CPU voltage input (nominal 2.25V)

in2_input	- +3.3V voltage input

in3_input	- +5V voltage input

in4_input	- +12V voltage input (may be missing if used as VID4)

in5_input	- Vcc voltage input (nominal 3.3V)

		  This is the supply voltage of the sensor chip itself.

in6_input	- +1.5V voltage input

in7_input	- +1.8V voltage input

in[0-7]_min,

in[0-7]_max	- lower and upper alarm thresholds for in[0-7]_input reading

		  All voltages are read and written in mV.

in[0-7]_alarm	- alarm flags for voltage inputs

		  These files read '1' in case of alarm, '0' otherwise.

temp1_input	- chip temperature measured by on-chip diode

temp[2-3]_input	- temperature measured by external diodes (one of these would

		  typically be wired to the diode inside the CPU)

temp[1-3]_min,

temp[1-3]_max	- lower and upper alarm thresholds for temperatures

temp[1-3]_offset - temperature offset registers

		  The chip adds the offsets stored in these registers to

		  the corresponding temperature readings.

		  Note that temp1 and temp2 offsets share the same register,

		  they cannot both be different from zero at the same time.

		  Writing a non-zero number to one of them will reset the other

		  offset to zero.

		  All temperatures and offsets are read and written in

		  units of 0.001 degC.

temp[1-3]_alarm - alarm flags for temperature inputs, '1' in case of alarm,

		  '0' otherwise.

temp[2-3]_input_fault - diode fault flags for temperature inputs 2 and 3.

		  A fault is detected if the two pins for the corresponding

		  sensor are open or shorted, or any of the two is shorted

		  to ground or Vcc. '1' indicates a diode fault.

cpu0_vid	- CPU voltage as received from the CPU

vrm		- CPU VID standard used for decoding CPU voltage

		  The *_min, *_max, *_offset and vrm files can be read and

		  written, all others are read-only.