aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Documentation/hwmon/abituguru59
-rw-r--r--Documentation/hwmon/abituguru-datasheet312
-rw-r--r--MAINTAINERS6
-rw-r--r--drivers/hwmon/Kconfig12
-rw-r--r--drivers/hwmon/Makefile1
-rw-r--r--drivers/hwmon/abituguru.c1391
6 files changed, 1781 insertions, 0 deletions
diff --git a/Documentation/hwmon/abituguru b/Documentation/hwmon/abituguru
new file mode 100644
index 000000000000..69cdb527d58f
--- /dev/null
+++ b/Documentation/hwmon/abituguru
@@ -0,0 +1,59 @@
1Kernel driver abituguru
2=======================
3
4Supported chips:
5 * Abit uGuru (Hardware Monitor part only)
6 Prefix: 'abituguru'
7 Addresses scanned: ISA 0x0E0
8 Datasheet: Not available, this driver is based on reverse engineering.
9 A "Datasheet" has been written based on the reverse engineering it
10 should be available in the same dir as this file under the name
11 abituguru-datasheet.
12
13Authors:
14 Hans de Goede <j.w.r.degoede@hhs.nl>,
15 (Initial reverse engineering done by Olle Sandberg
16 <ollebull@gmail.com>)
17
18
19Module Parameters
20-----------------
21
22* force: bool Force detection. Note this parameter only causes the
23 detection to be skipped, if the uGuru can't be read
24 the module initialization (insmod) will still fail.
25* fan_sensors: int Tell the driver how many fan speed sensors there are
26 on your motherboard. Default: 0 (autodetect).
27* pwms: int Tell the driver how many fan speed controls (fan
28 pwms) your motherboard has. Default: 0 (autodetect).
29* verbose: int How verbose should the driver be? (0-3):
30 0 normal output
31 1 + verbose error reporting
32 2 + sensors type probing info\n"
33 3 + retryable error reporting
34 Default: 2 (the driver is still in the testing phase)
35
36Notice if you need any of the first three options above please insmod the
37driver with verbose set to 3 and mail me <j.w.r.degoede@hhs.nl> the output of:
38dmesg | grep abituguru
39
40
41Description
42-----------
43
44This driver supports the hardware monitoring features of the Abit uGuru chip
45found on Abit uGuru featuring motherboards (most modern Abit motherboards).
46
47The uGuru chip in reality is a Winbond W83L950D in disguise (despite Abit
48claiming it is "a new microprocessor designed by the ABIT Engineers").
49Unfortunatly this doesn't help since the W83L950D is a generic
50microcontroller with a custom Abit application running on it.
51
52Despite Abit not releasing any information regarding the uGuru, Olle
53Sandberg <ollebull@gmail.com> has managed to reverse engineer the sensor part
54of the uGuru. Without his work this driver would not have been possible.
55
56Known Issues
57------------
58
59The voltage and frequency control parts of the Abit uGuru are not supported.
diff --git a/Documentation/hwmon/abituguru-datasheet b/Documentation/hwmon/abituguru-datasheet
new file mode 100644
index 000000000000..aef5a9b36846
--- /dev/null
+++ b/Documentation/hwmon/abituguru-datasheet
@@ -0,0 +1,312 @@
1uGuru datasheet
2===============
3
4First of all, what I know about uGuru is no fact based on any help, hints or
5datasheet from Abit. The data I have got on uGuru have I assembled through
6my weak knowledge in "backwards engineering".
7And just for the record, you may have noticed uGuru isn't a chip developed by
8Abit, as they claim it to be. It's realy just an microprocessor (uC) created by
9Winbond (W83L950D). And no, reading the manual for this specific uC or
10mailing Windbond for help won't give any usefull data about uGuru, as it is
11the program inside the uC that is responding to calls.
12
13Olle Sandberg <ollebull@gmail.com>, 2005-05-25
14
15
16Original version by Olle Sandberg who did the heavy lifting of the initial
17reverse engineering. This version has been almost fully rewritten for clarity
18and extended with write support and info on more databanks, the write support
19is once again reverse engineered by Olle the additional databanks have been
20reverse engineered by me. I would like to express my thanks to Olle, this
21document and the Linux driver could not have been written without his efforts.
22
23Note: because of the lack of specs only the sensors part of the uGuru is
24described here and not the CPU / RAM / etc voltage & frequency control.
25
26Hans de Goede <j.w.r.degoede@hhs.nl>, 28-01-2006
27
28
29Detection
30=========
31
32As far as known the uGuru is always placed at and using the (ISA) I/O-ports
330xE0 and 0xE4, so we don't have to scan any port-range, just check what the two
34ports are holding for detection. We will refer to 0xE0 as CMD (command-port)
35and 0xE4 as DATA because Abit refers to them with these names.
36
37If DATA holds 0x00 or 0x08 and CMD holds 0x00 or 0xAC an uGuru could be
38present. We have to check for two different values at data-port, because
39after a reboot uGuru will hold 0x00 here, but if the driver is removed and
40later on attached again data-port will hold 0x08, more about this later.
41
42After wider testing of the Linux kernel driver some variants of the uGuru have
43turned up which will hold 0x00 instead of 0xAC at the CMD port, thus we also
44have to test CMD for two different values. On these uGuru's DATA will initally
45hold 0x09 and will only hold 0x08 after reading CMD first, so CMD must be read
46first!
47
48To be really sure an uGuru is present a test read of one or more register
49sets should be done.
50
51
52Reading / Writing
53=================
54
55Addressing
56----------
57
58The uGuru has a number of different addressing levels. The first addressing
59level we will call banks. A bank holds data for one or more sensors. The data
60in a bank for a sensor is one or more bytes large.
61
62The number of bytes is fixed for a given bank, you should always read or write
63that many bytes, reading / writing more will fail, the results when writing
64less then the number of bytes for a given bank are undetermined.
65
66See below for all known bank addresses, numbers of sensors in that bank,
67number of bytes data per sensor and contents/meaning of those bytes.
68
69Although both this document and the kernel driver have kept the sensor
70terminoligy for the addressing within a bank this is not 100% correct, in
71bank 0x24 for example the addressing within the bank selects a PWM output not
72a sensor.
73
74Notice that some banks have both a read and a write address this is how the
75uGuru determines if a read from or a write to the bank is taking place, thus
76when reading you should always use the read address and when writing the
77write address. The write address is always one (1) more then the read address.
78
79
80uGuru ready
81-----------
82
83Before you can read from or write to the uGuru you must first put the uGuru
84in "ready" mode.
85
86To put the uGuru in ready mode first write 0x00 to DATA and then wait for DATA
87to hold 0x09, DATA should read 0x09 within 250 read cycles.
88
89Next CMD _must_ be read and should hold 0xAC, usually CMD will hold 0xAC the
90first read but sometimes it takes a while before CMD holds 0xAC and thus it
91has to be read a number of times (max 50).
92
93After reading CMD, DATA should hold 0x08 which means that the uGuru is ready
94for input. As above DATA will usually hold 0x08 the first read but not always.
95This step can be skipped, but it is undetermined what happens if the uGuru has
96not yet reported 0x08 at DATA and you proceed with writing a bank address.
97
98
99Sending bank and sensor addresses to the uGuru
100----------------------------------------------
101
102First the uGuru must be in "ready" mode as described above, DATA should hold
1030x08 indicating that the uGuru wants input, in this case the bank address.
104
105Next write the bank address to DATA. After the bank address has been written
106wait for to DATA to hold 0x08 again indicating that it wants / is ready for
107more input (max 250 reads).
108
109Once DATA holds 0x08 again write the sensor address to CMD.
110
111
112Reading
113-------
114
115First send the bank and sensor addresses as described above.
116Then for each byte of data you want to read wait for DATA to hold 0x01
117which indicates that the uGuru is ready to be read (max 250 reads) and once
118DATA holds 0x01 read the byte from CMD.
119
120Once all bytes have been read data will hold 0x09, but there is no reason to
121test for this. Notice that the number of bytes is bank address dependent see
122above and below.
123
124After completing a successfull read it is advised to put the uGuru back in
125ready mode, so that it is ready for the next read / write cycle. This way
126if your program / driver is unloaded and later loaded again the detection
127algorithm described above will still work.
128
129
130
131Writing
132-------
133
134First send the bank and sensor addresses as described above.
135Then for each byte of data you want to write wait for DATA to hold 0x00
136which indicates that the uGuru is ready to be written (max 250 reads) and
137once DATA holds 0x00 write the byte to CMD.
138
139Once all bytes have been written wait for DATA to hold 0x01 (max 250 reads)
140don't ask why this is the way it is.
141
142Once DATA holds 0x01 read CMD it should hold 0xAC now.
143
144After completing a successfull write it is advised to put the uGuru back in
145ready mode, so that it is ready for the next read / write cycle. This way
146if your program / driver is unloaded and later loaded again the detection
147algorithm described above will still work.
148
149
150Gotchas
151-------
152
153After wider testing of the Linux kernel driver some variants of the uGuru have
154turned up which do not hold 0x08 at DATA within 250 reads after writing the
155bank address. With these versions this happens quite frequent, using larger
156timeouts doesn't help, they just go offline for a second or 2, doing some
157internal callibration or whatever. Your code should be prepared to handle
158this and in case of no response in this specific case just goto sleep for a
159while and then retry.
160
161
162Address Map
163===========
164
165Bank 0x20 Alarms (R)
166--------------------
167This bank contains 0 sensors, iow the sensor address is ignored (but must be
168written) just use 0. Bank 0x20 contains 3 bytes:
169
170Byte 0:
171This byte holds the alarm flags for sensor 0-7 of Sensor Bank1, with bit 0
172corresponding to sensor 0, 1 to 1, etc.
173
174Byte 1:
175This byte holds the alarm flags for sensor 8-15 of Sensor Bank1, with bit 0
176corresponding to sensor 8, 1 to 9, etc.
177
178Byte 2:
179This byte holds the alarm flags for sensor 0-5 of Sensor Bank2, with bit 0
180corresponding to sensor 0, 1 to 1, etc.
181
182
183Bank 0x21 Sensor Bank1 Values / Readings (R)
184--------------------------------------------
185This bank contains 16 sensors, for each sensor it contains 1 byte.
186So far the following sensors are known to be available on all motherboards:
187Sensor 0 CPU temp
188Sensor 1 SYS temp
189Sensor 3 CPU core volt
190Sensor 4 DDR volt
191Sensor 10 DDR Vtt volt
192Sensor 15 PWM temp
193
194Byte 0:
195This byte holds the reading from the sensor. Sensors in Bank1 can be both
196volt and temp sensors, this is motherboard specific. The uGuru however does
197seem to know (be programmed with) what kindoff sensor is attached see Sensor
198Bank1 Settings description.
199
200Volt sensors use a linear scale, a reading 0 corresponds with 0 volt and a
201reading of 255 with 3494 mV. The sensors for higher voltages however are
202connected through a division circuit. The currently known division circuits
203in use result in ranges of: 0-4361mV, 0-6248mV or 0-14510mV. 3.3 volt sources
204use the 0-4361mV range, 5 volt the 0-6248mV and 12 volt the 0-14510mV .
205
206Temp sensors also use a linear scale, a reading of 0 corresponds with 0 degree
207Celsius and a reading of 255 with a reading of 255 degrees Celsius.
208
209
210Bank 0x22 Sensor Bank1 Settings (R)
211Bank 0x23 Sensor Bank1 Settings (W)
212-----------------------------------
213
214This bank contains 16 sensors, for each sensor it contains 3 bytes. Each
215set of 3 bytes contains the settings for the sensor with the same sensor
216address in Bank 0x21 .
217
218Byte 0:
219Alarm behaviour for the selected sensor. A 1 enables the described behaviour.
220Bit 0: Give an alarm if measured temp is over the warning threshold (RW) *
221Bit 1: Give an alarm if measured volt is over the max threshold (RW) **
222Bit 2: Give an alarm if measured volt is under the min threshold (RW) **
223Bit 3: Beep if alarm (RW)
224Bit 4: 1 if alarm cause measured temp is over the warning threshold (R)
225Bit 5: 1 if alarm cause measured volt is over the max threshold (R)
226Bit 6: 1 if alarm cause measured volt is under the min threshold (R)
227Bit 7: Volt sensor: Shutdown if alarm persist for more then 4 seconds (RW)
228 Temp sensor: Shutdown if temp is over the shutdown threshold (RW)
229
230* This bit is only honored/used by the uGuru if a temp sensor is connected
231** This bit is only honored/used by the uGuru if a volt sensor is connected
232Note with some trickery this can be used to find out what kinda sensor is
233detected see the Linux kernel driver for an example with many comments on
234how todo this.
235
236Byte 1:
237Temp sensor: warning threshold (scale as bank 0x21)
238Volt sensor: min threshold (scale as bank 0x21)
239
240Byte 2:
241Temp sensor: shutdown threshold (scale as bank 0x21)
242Volt sensor: max threshold (scale as bank 0x21)
243
244
245Bank 0x24 PWM outputs for FAN's (R)
246Bank 0x25 PWM outputs for FAN's (W)
247-----------------------------------
248
249This bank contains 3 "sensors", for each sensor it contains 5 bytes.
250Sensor 0 usually controls the CPU fan
251Sensor 1 usually controls the NB (or chipset for single chip) fan
252Sensor 2 usually controls the System fan
253
254Byte 0:
255Flag 0x80 to enable control, Fan runs at 100% when disabled.
256low nibble (temp)sensor address at bank 0x21 used for control.
257
258Byte 1:
2590-255 = 0-12v (linear), specify voltage at which fan will rotate when under
260low threshold temp (specified in byte 3)
261
262Byte 2:
2630-255 = 0-12v (linear), specify voltage at which fan will rotate when above
264high threshold temp (specified in byte 4)
265
266Byte 3:
267Low threshold temp (scale as bank 0x21)
268
269byte 4:
270High threshold temp (scale as bank 0x21)
271
272
273Bank 0x26 Sensors Bank2 Values / Readings (R)
274---------------------------------------------
275
276This bank contains 6 sensors (AFAIK), for each sensor it contains 1 byte.
277So far the following sensors are known to be available on all motherboards:
278Sensor 0: CPU fan speed
279Sensor 1: NB (or chipset for single chip) fan speed
280Sensor 2: SYS fan speed
281
282Byte 0:
283This byte holds the reading from the sensor. 0-255 = 0-15300 (linear)
284
285
286Bank 0x27 Sensors Bank2 Settings (R)
287Bank 0x28 Sensors Bank2 Settings (W)
288------------------------------------
289
290This bank contains 6 sensors (AFAIK), for each sensor it contains 2 bytes.
291
292Byte 0:
293Alarm behaviour for the selected sensor. A 1 enables the described behaviour.
294Bit 0: Give an alarm if measured rpm is under the min threshold (RW)
295Bit 3: Beep if alarm (RW)
296Bit 7: Shutdown if alarm persist for more then 4 seconds (RW)
297
298Byte 1:
299min threshold (scale as bank 0x26)
300
301
302Warning for the adventerous
303===========================
304
305A word of caution to those who want to experiment and see if they can figure
306the voltage / clock programming out, I tried reading and only reading banks
3070-0x30 with the reading code used for the sensor banks (0x20-0x28) and this
308resulted in a _permanent_ reprogramming of the voltages, luckily I had the
309sensors part configured so that it would shutdown my system on any out of spec
310voltages which proprably safed my computer (after a reboot I managed to
311immediatly enter the bios and reload the defaults). This probably means that
312the read/write cycle for the non sensor part is different from the sensor part.
diff --git a/MAINTAINERS b/MAINTAINERS
index 58d181d050c4..7e3a38eeccbf 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -181,6 +181,12 @@ M: bcrl@kvack.org
181L: linux-aio@kvack.org 181L: linux-aio@kvack.org
182S: Supported 182S: Supported
183 183
184ABIT UGURU HARDWARE MONITOR DRIVER
185P: Hans de Goede
186M: j.w.r.degoede@hhs.nl
187L: lm-sensors@lm-sensors.org
188S: Maintained
189
184ACENIC DRIVER 190ACENIC DRIVER
185P: Jes Sorensen 191P: Jes Sorensen
186M: jes@trained-monkey.org 192M: jes@trained-monkey.org
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 164760df1233..6fb93d63bd8c 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -27,6 +27,18 @@ config HWMON_VID
27 tristate 27 tristate
28 default n 28 default n
29 29
30config SENSORS_ABITUGURU
31 tristate "Abit uGuru"
32 depends on HWMON && EXPERIMENTAL
33 help
34 If you say yes here you get support for the Abit uGuru chips
35 sensor part. The voltage and frequency control parts of the Abit
36 uGuru are not supported. The Abit uGuru chip can be found on Abit
37 uGuru featuring motherboards (most modern Abit motherboards).
38
39 This driver can also be built as a module. If so, the module
40 will be called abituguru.
41
30config SENSORS_ADM1021 42config SENSORS_ADM1021
31 tristate "Analog Devices ADM1021 and compatibles" 43 tristate "Analog Devices ADM1021 and compatibles"
32 depends on HWMON && I2C 44 depends on HWMON && I2C
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index db72b1415e7f..5092999deb7b 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -12,6 +12,7 @@ obj-$(CONFIG_SENSORS_W83792D) += w83792d.o
12obj-$(CONFIG_SENSORS_W83781D) += w83781d.o 12obj-$(CONFIG_SENSORS_W83781D) += w83781d.o
13obj-$(CONFIG_SENSORS_W83791D) += w83791d.o 13obj-$(CONFIG_SENSORS_W83791D) += w83791d.o
14 14
15obj-$(CONFIG_SENSORS_ABITUGURU) += abituguru.o
15obj-$(CONFIG_SENSORS_ADM1021) += adm1021.o 16obj-$(CONFIG_SENSORS_ADM1021) += adm1021.o
16obj-$(CONFIG_SENSORS_ADM1025) += adm1025.o 17obj-$(CONFIG_SENSORS_ADM1025) += adm1025.o
17obj-$(CONFIG_SENSORS_ADM1026) += adm1026.o 18obj-$(CONFIG_SENSORS_ADM1026) += adm1026.o
diff --git a/drivers/hwmon/abituguru.c b/drivers/hwmon/abituguru.c
new file mode 100644
index 000000000000..bf2cb0aa69b4
--- /dev/null
+++ b/drivers/hwmon/abituguru.c
@@ -0,0 +1,1391 @@
1/*
2 abituguru.c Copyright (c) 2005-2006 Hans de Goede <j.w.r.degoede@hhs.nl>
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17*/
18/*
19 This driver supports the sensor part of the custom Abit uGuru chip found
20 on Abit uGuru motherboards. Note: because of lack of specs the CPU / RAM /
21 etc voltage & frequency control is not supported!
22*/
23#include <linux/module.h>
24#include <linux/init.h>
25#include <linux/slab.h>
26#include <linux/jiffies.h>
27#include <linux/mutex.h>
28#include <linux/err.h>
29#include <linux/platform_device.h>
30#include <linux/hwmon.h>
31#include <linux/hwmon-sysfs.h>
32#include <asm/io.h>
33
34/* Banks */
35#define ABIT_UGURU_ALARM_BANK 0x20 /* 1x 3 bytes */
36#define ABIT_UGURU_SENSOR_BANK1 0x21 /* 16x volt and temp */
37#define ABIT_UGURU_FAN_PWM 0x24 /* 3x 5 bytes */
38#define ABIT_UGURU_SENSOR_BANK2 0x26 /* fans */
39/* max nr of sensors in bank2, currently mb's with max 6 fans are known */
40#define ABIT_UGURU_MAX_BANK2_SENSORS 6
41/* max nr of pwm outputs, currently mb's with max 5 pwm outputs are known */
42#define ABIT_UGURU_MAX_PWMS 5
43/* uGuru sensor bank 1 flags */ /* Alarm if: */
44#define ABIT_UGURU_TEMP_HIGH_ALARM_ENABLE 0x01 /* temp over warn */
45#define ABIT_UGURU_VOLT_HIGH_ALARM_ENABLE 0x02 /* volt over max */
46#define ABIT_UGURU_VOLT_LOW_ALARM_ENABLE 0x04 /* volt under min */
47#define ABIT_UGURU_TEMP_HIGH_ALARM_FLAG 0x10 /* temp is over warn */
48#define ABIT_UGURU_VOLT_HIGH_ALARM_FLAG 0x20 /* volt is over max */
49#define ABIT_UGURU_VOLT_LOW_ALARM_FLAG 0x40 /* volt is under min */
50/* uGuru sensor bank 2 flags */ /* Alarm if: */
51#define ABIT_UGURU_FAN_LOW_ALARM_ENABLE 0x01 /* fan under min */
52/* uGuru sensor bank common flags */
53#define ABIT_UGURU_BEEP_ENABLE 0x08 /* beep if alarm */
54#define ABIT_UGURU_SHUTDOWN_ENABLE 0x80 /* shutdown if alarm */
55/* uGuru fan PWM (speed control) flags */
56#define ABIT_UGURU_FAN_PWM_ENABLE 0x80 /* enable speed control */
57/* Values used for conversion */
58#define ABIT_UGURU_FAN_MAX 15300 /* RPM */
59/* Bank1 sensor types */
60#define ABIT_UGURU_IN_SENSOR 0
61#define ABIT_UGURU_TEMP_SENSOR 1
62#define ABIT_UGURU_NC 2
63/* Timeouts / Retries, if these turn out to need a lot of fiddling we could
64 convert them to params. */
65/* 250 was determined by trial and error, 200 works most of the time, but not
66 always. I assume this is cpu-speed independent, since the ISA-bus and not
67 the CPU should be the bottleneck. Note that 250 sometimes is still not
68 enough (only reported on AN7 mb) this is handled by a higher layer. */
69#define ABIT_UGURU_WAIT_TIMEOUT 250
70/* Normally all expected status in abituguru_ready, are reported after the
71 first read, but sometimes not and we need to poll, 5 polls was not enough
72 50 sofar is. */
73#define ABIT_UGURU_READY_TIMEOUT 50
74/* Maximum 3 retries on timedout reads/writes, delay 200 ms before retrying */
75#define ABIT_UGURU_MAX_RETRIES 3
76#define ABIT_UGURU_RETRY_DELAY (HZ/5)
77/* Maximum 2 timeouts in abituguru_update_device, iow 3 in a row is a error */
78#define ABIT_UGURU_MAX_TIMEOUTS 2
79
80/* All the variables below are named identical to the oguru and oguru2 programs
81 reverse engineered by Olle Sandberg, hence the names might not be 100%
82 logical. I could come up with better names, but I prefer keeping the names
83 identical so that this driver can be compared with his work more easily. */
84/* Two i/o-ports are used by uGuru */
85#define ABIT_UGURU_BASE 0x00E0
86/* Used to tell uGuru what to read and to read the actual data */
87#define ABIT_UGURU_CMD 0x00
88/* Mostly used to check if uGuru is busy */
89#define ABIT_UGURU_DATA 0x04
90#define ABIT_UGURU_REGION_LENGTH 5
91/* uGuru status' */
92#define ABIT_UGURU_STATUS_WRITE 0x00 /* Ready to be written */
93#define ABIT_UGURU_STATUS_READ 0x01 /* Ready to be read */
94#define ABIT_UGURU_STATUS_INPUT 0x08 /* More input */
95#define ABIT_UGURU_STATUS_READY 0x09 /* Ready to be written */
96/* utility macros */
97#define ABIT_UGURU_NAME "abituguru"
98#define ABIT_UGURU_DEBUG(level, format, arg...) \
99 if (level <= verbose) \
100 printk(KERN_DEBUG ABIT_UGURU_NAME ": " format , ## arg)
101
102/* Constants */
103/* in (Volt) sensors go up to 3494 mV, temp to 255000 millidegrees Celsius */
104static const int abituguru_bank1_max_value[2] = { 3494, 255000 };
105/* Min / Max allowed values for sensor2 (fan) alarm threshold, these values
106 correspond to 300-3000 RPM */
107static const u8 abituguru_bank2_min_threshold = 5;
108static const u8 abituguru_bank2_max_threshold = 50;
109/* Register 0 is a bitfield, 1 and 2 are pwm settings (255 = 100%), 3 and 4
110 are temperature trip points. */
111static const int abituguru_pwm_settings_multiplier[5] = { 0, 1, 1, 1000, 1000 };
112/* Min / Max allowed values for pwm_settings. Note: pwm1 (CPU fan) is a
113 special case the minium allowed pwm% setting for this is 30% (77) on
114 some MB's this special case is handled in the code! */
115static const u8 abituguru_pwm_min[5] = { 0, 170, 170, 25, 25 };
116static const u8 abituguru_pwm_max[5] = { 0, 255, 255, 75, 75 };
117
118
119/* Insmod parameters */
120static int force;
121module_param(force, bool, 0);
122MODULE_PARM_DESC(force, "Set to one to force detection.");
123static int fan_sensors;
124module_param(fan_sensors, int, 0);
125MODULE_PARM_DESC(fan_sensors, "Number of fan sensors on the uGuru "
126 "(0 = autodetect)");
127static int pwms;
128module_param(pwms, int, 0);
129MODULE_PARM_DESC(pwms, "Number of PWMs on the uGuru "
130 "(0 = autodetect)");
131
132/* Default verbose is 2, since this driver is still in the testing phase */
133static int verbose = 2;
134module_param(verbose, int, 0644);
135MODULE_PARM_DESC(verbose, "How verbose should the driver be? (0-3):\n"
136 " 0 normal output\n"
137 " 1 + verbose error reporting\n"
138 " 2 + sensors type probing info\n"
139 " 3 + retryable error reporting");
140
141
142/* For the Abit uGuru, we need to keep some data in memory.
143 The structure is dynamically allocated, at the same time when a new
144 abituguru device is allocated. */
145struct abituguru_data {
146 struct class_device *class_dev; /* hwmon registered device */
147 struct mutex update_lock; /* protect access to data and uGuru */
148 unsigned long last_updated; /* In jiffies */
149 unsigned short addr; /* uguru base address */
150 char uguru_ready; /* is the uguru in ready state? */
151 unsigned char update_timeouts; /* number of update timeouts since last
152 successful update */
153
154 /* The sysfs attr and their names are generated automatically, for bank1
155 we cannot use a predefined array because we don't know beforehand
156 of a sensor is a volt or a temp sensor, for bank2 and the pwms its
157 easier todo things the same way. For in sensors we have 9 (temp 7)
158 sysfs entries per sensor, for bank2 and pwms 6. */
159 struct sensor_device_attribute_2 sysfs_attr[16 * 9 +
160 ABIT_UGURU_MAX_BANK2_SENSORS * 6 + ABIT_UGURU_MAX_PWMS * 6];
161 /* Buffer to store the dynamically generated sysfs names, we need 2120
162 bytes for bank1 (worst case scenario of 16 in sensors), 444 bytes
163 for fan1-6 and 738 bytes for pwm1-6 + some room to spare in case I
164 miscounted :) */
165 char bank1_names[3400];
166
167 /* Bank 1 data */
168 u8 bank1_sensors[2]; /* number of [0] in, [1] temp sensors */
169 u8 bank1_address[2][16];/* addresses of [0] in, [1] temp sensors */
170 u8 bank1_value[16];
171 /* This array holds 16 x 3 entries for all the bank 1 sensor settings
172 (flags, min, max for voltage / flags, warn, shutdown for temp). */
173 u8 bank1_settings[16][3];
174 /* Maximum value for each sensor used for scaling in mV/millidegrees
175 Celsius. */
176 int bank1_max_value[16];
177
178 /* Bank 2 data, ABIT_UGURU_MAX_BANK2_SENSORS entries for bank2 */
179 u8 bank2_sensors; /* actual number of bank2 sensors found */
180 u8 bank2_value[ABIT_UGURU_MAX_BANK2_SENSORS];
181 u8 bank2_settings[ABIT_UGURU_MAX_BANK2_SENSORS][2]; /* flags, min */
182
183 /* Alarms 2 bytes for bank1, 1 byte for bank2 */
184 u8 alarms[3];
185
186 /* Fan PWM (speed control) 5 bytes per PWM */
187 u8 pwms; /* actual number of pwms found */
188 u8 pwm_settings[ABIT_UGURU_MAX_PWMS][5];
189};
190
191/* wait till the uguru is in the specified state */
192static int abituguru_wait(struct abituguru_data *data, u8 state)
193{
194 int timeout = ABIT_UGURU_WAIT_TIMEOUT;
195
196 while (inb_p(data->addr + ABIT_UGURU_DATA) != state) {
197 timeout--;
198 if (timeout == 0)
199 return -EBUSY;
200 }
201 return 0;
202}
203
204/* Put the uguru in ready for input state */
205static int abituguru_ready(struct abituguru_data *data)
206{
207 int timeout = ABIT_UGURU_READY_TIMEOUT;
208
209 if (data->uguru_ready)
210 return 0;
211
212 /* Reset? / Prepare for next read/write cycle */
213 outb(0x00, data->addr + ABIT_UGURU_DATA);
214
215 /* Wait till the uguru is ready */
216 if (abituguru_wait(data, ABIT_UGURU_STATUS_READY)) {
217 ABIT_UGURU_DEBUG(1,
218 "timeout exceeded waiting for ready state\n");
219 return -EIO;
220 }
221
222 /* Cmd port MUST be read now and should contain 0xAC */
223 while (inb_p(data->addr + ABIT_UGURU_CMD) != 0xAC) {
224 timeout--;
225 if (timeout == 0) {
226 ABIT_UGURU_DEBUG(1,
227 "CMD reg does not hold 0xAC after ready command\n");
228 return -EIO;
229 }
230 }
231
232 /* After this the ABIT_UGURU_DATA port should contain
233 ABIT_UGURU_STATUS_INPUT */
234 timeout = ABIT_UGURU_READY_TIMEOUT;
235 while (inb_p(data->addr + ABIT_UGURU_DATA) != ABIT_UGURU_STATUS_INPUT) {
236 timeout--;
237 if (timeout == 0) {
238 ABIT_UGURU_DEBUG(1,
239 "state != more input after ready command\n");
240 return -EIO;
241 }
242 }
243
244 data->uguru_ready = 1;
245 return 0;
246}
247
248/* Send the bank and then sensor address to the uGuru for the next read/write
249 cycle. This function gets called as the first part of a read/write by
250 abituguru_read and abituguru_write. This function should never be
251 called by any other function. */
252static int abituguru_send_address(struct abituguru_data *data,
253 u8 bank_addr, u8 sensor_addr, int retries)
254{
255 /* assume the caller does error handling itself if it has not requested
256 any retries, and thus be quiet. */
257 int report_errors = retries;
258
259 for (;;) {
260 /* Make sure the uguru is ready and then send the bank address,
261 after this the uguru is no longer "ready". */
262 if (abituguru_ready(data) != 0)
263 return -EIO;
264 outb(bank_addr, data->addr + ABIT_UGURU_DATA);
265 data->uguru_ready = 0;
266
267 /* Wait till the uguru is ABIT_UGURU_STATUS_INPUT state again
268 and send the sensor addr */
269 if (abituguru_wait(data, ABIT_UGURU_STATUS_INPUT)) {
270 if (retries) {
271 ABIT_UGURU_DEBUG(3, "timeout exceeded "
272 "waiting for more input state, %d "
273 "tries remaining\n", retries);
274 set_current_state(TASK_UNINTERRUPTIBLE);
275 schedule_timeout(ABIT_UGURU_RETRY_DELAY);
276 retries--;
277 continue;
278 }
279 if (report_errors)
280 ABIT_UGURU_DEBUG(1, "timeout exceeded "
281 "waiting for more input state "
282 "(bank: %d)\n", (int)bank_addr);
283 return -EBUSY;
284 }
285 outb(sensor_addr, data->addr + ABIT_UGURU_CMD);
286 return 0;
287 }
288}
289
290/* Read count bytes from sensor sensor_addr in bank bank_addr and store the
291 result in buf, retry the send address part of the read retries times. */
292static int abituguru_read(struct abituguru_data *data,
293 u8 bank_addr, u8 sensor_addr, u8 *buf, int count, int retries)
294{
295 int i;
296
297 /* Send the address */
298 i = abituguru_send_address(data, bank_addr, sensor_addr, retries);
299 if (i)
300 return i;
301
302 /* And read the data */
303 for (i = 0; i < count; i++) {
304 if (abituguru_wait(data, ABIT_UGURU_STATUS_READ)) {
305 ABIT_UGURU_DEBUG(1, "timeout exceeded waiting for "
306 "read state (bank: %d, sensor: %d)\n",
307 (int)bank_addr, (int)sensor_addr);
308 break;
309 }
310 buf[i] = inb(data->addr + ABIT_UGURU_CMD);
311 }
312
313 /* Last put the chip back in ready state */
314 abituguru_ready(data);
315
316 return i;
317}
318
319/* Write count bytes from buf to sensor sensor_addr in bank bank_addr, the send
320 address part of the write is always retried ABIT_UGURU_MAX_RETRIES times. */
321static int abituguru_write(struct abituguru_data *data,
322 u8 bank_addr, u8 sensor_addr, u8 *buf, int count)
323{
324 int i;
325
326 /* Send the address */
327 i = abituguru_send_address(data, bank_addr, sensor_addr,
328 ABIT_UGURU_MAX_RETRIES);
329 if (i)
330 return i;
331
332 /* And write the data */
333 for (i = 0; i < count; i++) {
334 if (abituguru_wait(data, ABIT_UGURU_STATUS_WRITE)) {
335 ABIT_UGURU_DEBUG(1, "timeout exceeded waiting for "
336 "write state (bank: %d, sensor: %d)\n",
337 (int)bank_addr, (int)sensor_addr);
338 break;
339 }
340 outb(buf[i], data->addr + ABIT_UGURU_CMD);
341 }
342
343 /* Now we need to wait till the chip is ready to be read again,
344 don't ask why */
345 if (abituguru_wait(data, ABIT_UGURU_STATUS_READ)) {
346 ABIT_UGURU_DEBUG(1, "timeout exceeded waiting for read state "
347 "after write (bank: %d, sensor: %d)\n", (int)bank_addr,
348 (int)sensor_addr);
349 return -EIO;
350 }
351
352 /* Cmd port MUST be read now and should contain 0xAC */
353 if (inb_p(data->addr + ABIT_UGURU_CMD) != 0xAC) {
354 ABIT_UGURU_DEBUG(1, "CMD reg does not hold 0xAC after write "
355 "(bank: %d, sensor: %d)\n", (int)bank_addr,
356 (int)sensor_addr);
357 return -EIO;
358 }
359
360 /* Last put the chip back in ready state */
361 abituguru_ready(data);
362
363 return i;
364}
365
366/* Detect sensor type. Temp and Volt sensors are enabled with
367 different masks and will ignore enable masks not meant for them.
368 This enables us to test what kind of sensor we're dealing with.
369 By setting the alarm thresholds so that we will always get an
370 alarm for sensor type X and then enabling the sensor as sensor type
371 X, if we then get an alarm it is a sensor of type X. */
372static int __devinit
373abituguru_detect_bank1_sensor_type(struct abituguru_data *data,
374 u8 sensor_addr)
375{
376 u8 val, buf[3];
377 int ret = ABIT_UGURU_NC;
378
379 /* First read the sensor and the current settings */
380 if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK1, sensor_addr, &val,
381 1, ABIT_UGURU_MAX_RETRIES) != 1)
382 return -EIO;
383
384 /* Test val is sane / usable for sensor type detection. */
385 if ((val < 10u) || (val > 240u)) {
386 printk(KERN_WARNING ABIT_UGURU_NAME
387 ": bank1-sensor: %d reading (%d) too close to limits, "
388 "unable to determine sensor type, skipping sensor\n",
389 (int)sensor_addr, (int)val);
390 /* assume no sensor is there for sensors for which we can't
391 determine the sensor type because their reading is too close
392 to their limits, this usually means no sensor is there. */
393 return ABIT_UGURU_NC;
394 }
395
396 ABIT_UGURU_DEBUG(2, "testing bank1 sensor %d\n", (int)sensor_addr);
397 /* Volt sensor test, enable volt low alarm, set min value ridicously
398 high. If its a volt sensor this should always give us an alarm. */
399 buf[0] = ABIT_UGURU_VOLT_LOW_ALARM_ENABLE;
400 buf[1] = 245;
401 buf[2] = 250;
402 if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2, sensor_addr,
403 buf, 3) != 3)
404 return -EIO;
405 /* Now we need 20 ms to give the uguru time to read the sensors
406 and raise a voltage alarm */
407 set_current_state(TASK_UNINTERRUPTIBLE);
408 schedule_timeout(HZ/50);
409 /* Check for alarm and check the alarm is a volt low alarm. */
410 if (abituguru_read(data, ABIT_UGURU_ALARM_BANK, 0, buf, 3,
411 ABIT_UGURU_MAX_RETRIES) != 3)
412 return -EIO;
413 if (buf[sensor_addr/8] & (0x01 << (sensor_addr % 8))) {
414 if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK1 + 1,
415 sensor_addr, buf, 3,
416 ABIT_UGURU_MAX_RETRIES) != 3)
417 return -EIO;
418 if (buf[0] & ABIT_UGURU_VOLT_LOW_ALARM_FLAG) {
419 /* Restore original settings */
420 if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2,
421 sensor_addr,
422 data->bank1_settings[sensor_addr],
423 3) != 3)
424 return -EIO;
425 ABIT_UGURU_DEBUG(2, " found volt sensor\n");
426 return ABIT_UGURU_IN_SENSOR;
427 } else
428 ABIT_UGURU_DEBUG(2, " alarm raised during volt "
429 "sensor test, but volt low flag not set\n");
430 } else
431 ABIT_UGURU_DEBUG(2, " alarm not raised during volt sensor "
432 "test\n");
433
434 /* Temp sensor test, enable sensor as a temp sensor, set beep value
435 ridicously low (but not too low, otherwise uguru ignores it).
436 If its a temp sensor this should always give us an alarm. */
437 buf[0] = ABIT_UGURU_TEMP_HIGH_ALARM_ENABLE;
438 buf[1] = 5;
439 buf[2] = 10;
440 if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2, sensor_addr,
441 buf, 3) != 3)
442 return -EIO;
443 /* Now we need 50 ms to give the uguru time to read the sensors
444 and raise a temp alarm */
445 set_current_state(TASK_UNINTERRUPTIBLE);
446 schedule_timeout(HZ/20);
447 /* Check for alarm and check the alarm is a temp high alarm. */
448 if (abituguru_read(data, ABIT_UGURU_ALARM_BANK, 0, buf, 3,
449 ABIT_UGURU_MAX_RETRIES) != 3)
450 return -EIO;
451 if (buf[sensor_addr/8] & (0x01 << (sensor_addr % 8))) {
452 if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK1 + 1,
453 sensor_addr, buf, 3,
454 ABIT_UGURU_MAX_RETRIES) != 3)
455 return -EIO;
456 if (buf[0] & ABIT_UGURU_TEMP_HIGH_ALARM_FLAG) {
457 ret = ABIT_UGURU_TEMP_SENSOR;
458 ABIT_UGURU_DEBUG(2, " found temp sensor\n");
459 } else
460 ABIT_UGURU_DEBUG(2, " alarm raised during temp "
461 "sensor test, but temp high flag not set\n");
462 } else
463 ABIT_UGURU_DEBUG(2, " alarm not raised during temp sensor "
464 "test\n");
465
466 /* Restore original settings */
467 if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2, sensor_addr,
468 data->bank1_settings[sensor_addr], 3) != 3)
469 return -EIO;
470
471 return ret;
472}
473
474/* These functions try to find out how many sensors there are in bank2 and how
475 many pwms there are. The purpose of this is to make sure that we don't give
476 the user the possibility to change settings for non-existent sensors / pwm.
477 The uGuru will happily read / write whatever memory happens to be after the
478 memory storing the PWM settings when reading/writing to a PWM which is not
479 there. Notice even if we detect a PWM which doesn't exist we normally won't
480 write to it, unless the user tries to change the settings.
481
482 Although the uGuru allows reading (settings) from non existing bank2
483 sensors, my version of the uGuru does seem to stop writing to them, the
484 write function above aborts in this case with:
485 "CMD reg does not hold 0xAC after write"
486
487 Notice these 2 tests are non destructive iow read-only tests, otherwise
488 they would defeat their purpose. Although for the bank2_sensors detection a
489 read/write test would be feasible because of the reaction above, I've
490 however opted to stay on the safe side. */
491static void __devinit
492abituguru_detect_no_bank2_sensors(struct abituguru_data *data)
493{
494 int i;
495
496 if (fan_sensors) {
497 data->bank2_sensors = fan_sensors;
498 ABIT_UGURU_DEBUG(2, "assuming %d fan sensors because of "
499 "\"fan_sensors\" module param\n",
500 (int)data->bank2_sensors);
501 return;
502 }
503
504 ABIT_UGURU_DEBUG(2, "detecting number of fan sensors\n");
505 for (i = 0; i < ABIT_UGURU_MAX_BANK2_SENSORS; i++) {
506 /* 0x89 are the known used bits:
507 -0x80 enable shutdown
508 -0x08 enable beep
509 -0x01 enable alarm
510 All other bits should be 0, but on some motherboards
511 0x40 (bit 6) is also high, at least for fan1 */
512 if ((!i && (data->bank2_settings[i][0] & ~0xC9)) ||
513 (i && (data->bank2_settings[i][0] & ~0x89))) {
514 ABIT_UGURU_DEBUG(2, " bank2 sensor %d does not seem "
515 "to be a fan sensor: settings[0] = %02X\n",
516 i, (unsigned int)data->bank2_settings[i][0]);
517 break;
518 }
519
520 /* check if the threshold is within the allowed range */
521 if (data->bank2_settings[i][1] <
522 abituguru_bank2_min_threshold) {
523 ABIT_UGURU_DEBUG(2, " bank2 sensor %d does not seem "
524 "to be a fan sensor: the threshold (%d) is "
525 "below the minimum (%d)\n", i,
526 (int)data->bank2_settings[i][1],
527 (int)abituguru_bank2_min_threshold);
528 break;
529 }
530 if (data->bank2_settings[i][1] >
531 abituguru_bank2_max_threshold) {
532 ABIT_UGURU_DEBUG(2, " bank2 sensor %d does not seem "
533 "to be a fan sensor: the threshold (%d) is "
534 "above the maximum (%d)\n", i,
535 (int)data->bank2_settings[i][1],
536 (int)abituguru_bank2_max_threshold);
537 break;
538 }
539 }
540
541 data->bank2_sensors = i;
542 ABIT_UGURU_DEBUG(2, " found: %d fan sensors\n",
543 (int)data->bank2_sensors);
544}
545
546static void __devinit
547abituguru_detect_no_pwms(struct abituguru_data *data)
548{
549 int i, j;
550
551 if (pwms) {
552 data->pwms = pwms;
553 ABIT_UGURU_DEBUG(2, "assuming %d PWM outputs because of "
554 "\"pwms\" module param\n", (int)data->pwms);
555 return;
556 }
557
558 ABIT_UGURU_DEBUG(2, "detecting number of PWM outputs\n");
559 for (i = 0; i < ABIT_UGURU_MAX_PWMS; i++) {
560 /* 0x80 is the enable bit and the low
561 nibble is which temp sensor to use,
562 the other bits should be 0 */
563 if (data->pwm_settings[i][0] & ~0x8F) {
564 ABIT_UGURU_DEBUG(2, " pwm channel %d does not seem "
565 "to be a pwm channel: settings[0] = %02X\n",
566 i, (unsigned int)data->pwm_settings[i][0]);
567 break;
568 }
569
570 /* the low nibble must correspond to one of the temp sensors
571 we've found */
572 for (j = 0; j < data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR];
573 j++) {
574 if (data->bank1_address[ABIT_UGURU_TEMP_SENSOR][j] ==
575 (data->pwm_settings[i][0] & 0x0F))
576 break;
577 }
578 if (j == data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR]) {
579 ABIT_UGURU_DEBUG(2, " pwm channel %d does not seem "
580 "to be a pwm channel: %d is not a valid temp "
581 "sensor address\n", i,
582 data->pwm_settings[i][0] & 0x0F);
583 break;
584 }
585
586 /* check if all other settings are within the allowed range */
587 for (j = 1; j < 5; j++) {
588 u8 min;
589 /* special case pwm1 min pwm% */
590 if ((i == 0) && ((j == 1) || (j == 2)))
591 min = 77;
592 else
593 min = abituguru_pwm_min[j];
594 if (data->pwm_settings[i][j] < min) {
595 ABIT_UGURU_DEBUG(2, " pwm channel %d does "
596 "not seem to be a pwm channel: "
597 "setting %d (%d) is below the minimum "
598 "value (%d)\n", i, j,
599 (int)data->pwm_settings[i][j],
600 (int)min);
601 goto abituguru_detect_no_pwms_exit;
602 }
603 if (data->pwm_settings[i][j] > abituguru_pwm_max[j]) {
604 ABIT_UGURU_DEBUG(2, " pwm channel %d does "
605 "not seem to be a pwm channel: "
606 "setting %d (%d) is above the maximum "
607 "value (%d)\n", i, j,
608 (int)data->pwm_settings[i][j],
609 (int)abituguru_pwm_max[j]);
610 goto abituguru_detect_no_pwms_exit;
611 }
612 }
613
614 /* check that min temp < max temp and min pwm < max pwm */
615 if (data->pwm_settings[i][1] >= data->pwm_settings[i][2]) {
616 ABIT_UGURU_DEBUG(2, " pwm channel %d does not seem "
617 "to be a pwm channel: min pwm (%d) >= "
618 "max pwm (%d)\n", i,
619 (int)data->pwm_settings[i][1],
620 (int)data->pwm_settings[i][2]);
621 break;
622 }
623 if (data->pwm_settings[i][3] >= data->pwm_settings[i][4]) {
624 ABIT_UGURU_DEBUG(2, " pwm channel %d does not seem "
625 "to be a pwm channel: min temp (%d) >= "
626 "max temp (%d)\n", i,
627 (int)data->pwm_settings[i][3],
628 (int)data->pwm_settings[i][4]);
629 break;
630 }
631 }
632
633abituguru_detect_no_pwms_exit:
634 data->pwms = i;
635 ABIT_UGURU_DEBUG(2, " found: %d PWM outputs\n", (int)data->pwms);
636}
637
638/* Following are the sysfs callback functions. These functions expect:
639 sensor_device_attribute_2->index: sensor address/offset in the bank
640 sensor_device_attribute_2->nr: register offset, bitmask or NA. */
641static struct abituguru_data *abituguru_update_device(struct device *dev);
642
643static ssize_t show_bank1_value(struct device *dev,
644 struct device_attribute *devattr, char *buf)
645{
646 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
647 struct abituguru_data *data = abituguru_update_device(dev);
648 if (!data)
649 return -EIO;
650 return sprintf(buf, "%d\n", (data->bank1_value[attr->index] *
651 data->bank1_max_value[attr->index] + 128) / 255);
652}
653
654static ssize_t show_bank1_setting(struct device *dev,
655 struct device_attribute *devattr, char *buf)
656{
657 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
658 struct abituguru_data *data = dev_get_drvdata(dev);
659 return sprintf(buf, "%d\n",
660 (data->bank1_settings[attr->index][attr->nr] *
661 data->bank1_max_value[attr->index] + 128) / 255);
662}
663
664static ssize_t show_bank2_value(struct device *dev,
665 struct device_attribute *devattr, char *buf)
666{
667 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
668 struct abituguru_data *data = abituguru_update_device(dev);
669 if (!data)
670 return -EIO;
671 return sprintf(buf, "%d\n", (data->bank2_value[attr->index] *
672 ABIT_UGURU_FAN_MAX + 128) / 255);
673}
674
675static ssize_t show_bank2_setting(struct device *dev,
676 struct device_attribute *devattr, char *buf)
677{
678 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
679 struct abituguru_data *data = dev_get_drvdata(dev);
680 return sprintf(buf, "%d\n",
681 (data->bank2_settings[attr->index][attr->nr] *
682 ABIT_UGURU_FAN_MAX + 128) / 255);
683}
684
685static ssize_t store_bank1_setting(struct device *dev, struct device_attribute
686 *devattr, const char *buf, size_t count)
687{
688 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
689 struct abituguru_data *data = dev_get_drvdata(dev);
690 u8 val = (simple_strtoul(buf, NULL, 10) * 255 +
691 data->bank1_max_value[attr->index]/2) /
692 data->bank1_max_value[attr->index];
693 ssize_t ret = count;
694
695 mutex_lock(&data->update_lock);
696 if (data->bank1_settings[attr->index][attr->nr] != val) {
697 u8 orig_val = data->bank1_settings[attr->index][attr->nr];
698 data->bank1_settings[attr->index][attr->nr] = val;
699 if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2,
700 attr->index, data->bank1_settings[attr->index],
701 3) <= attr->nr) {
702 data->bank1_settings[attr->index][attr->nr] = orig_val;
703 ret = -EIO;
704 }
705 }
706 mutex_unlock(&data->update_lock);
707 return ret;
708}
709
710static ssize_t store_bank2_setting(struct device *dev, struct device_attribute
711 *devattr, const char *buf, size_t count)
712{
713 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
714 struct abituguru_data *data = dev_get_drvdata(dev);
715 u8 val = (simple_strtoul(buf, NULL, 10)*255 + ABIT_UGURU_FAN_MAX/2) /
716 ABIT_UGURU_FAN_MAX;
717 ssize_t ret = count;
718
719 /* this check can be done before taking the lock */
720 if ((val < abituguru_bank2_min_threshold) ||
721 (val > abituguru_bank2_max_threshold))
722 return -EINVAL;
723
724 mutex_lock(&data->update_lock);
725 if (data->bank2_settings[attr->index][attr->nr] != val) {
726 u8 orig_val = data->bank2_settings[attr->index][attr->nr];
727 data->bank2_settings[attr->index][attr->nr] = val;
728 if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK2 + 2,
729 attr->index, data->bank2_settings[attr->index],
730 2) <= attr->nr) {
731 data->bank2_settings[attr->index][attr->nr] = orig_val;
732 ret = -EIO;
733 }
734 }
735 mutex_unlock(&data->update_lock);
736 return ret;
737}
738
739static ssize_t show_bank1_alarm(struct device *dev,
740 struct device_attribute *devattr, char *buf)
741{
742 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
743 struct abituguru_data *data = abituguru_update_device(dev);
744 if (!data)
745 return -EIO;
746 /* See if the alarm bit for this sensor is set, and if the
747 alarm matches the type of alarm we're looking for (for volt
748 it can be either low or high). The type is stored in a few
749 readonly bits in the settings part of the relevant sensor.
750 The bitmask of the type is passed to us in attr->nr. */
751 if ((data->alarms[attr->index / 8] & (0x01 << (attr->index % 8))) &&
752 (data->bank1_settings[attr->index][0] & attr->nr))
753 return sprintf(buf, "1\n");
754 else
755 return sprintf(buf, "0\n");
756}
757
758static ssize_t show_bank2_alarm(struct device *dev,
759 struct device_attribute *devattr, char *buf)
760{
761 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
762 struct abituguru_data *data = abituguru_update_device(dev);
763 if (!data)
764 return -EIO;
765 if (data->alarms[2] & (0x01 << attr->index))
766 return sprintf(buf, "1\n");
767 else
768 return sprintf(buf, "0\n");
769}
770
771static ssize_t show_bank1_mask(struct device *dev,
772 struct device_attribute *devattr, char *buf)
773{
774 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
775 struct abituguru_data *data = dev_get_drvdata(dev);
776 if (data->bank1_settings[attr->index][0] & attr->nr)
777 return sprintf(buf, "1\n");
778 else
779 return sprintf(buf, "0\n");
780}
781
782static ssize_t show_bank2_mask(struct device *dev,
783 struct device_attribute *devattr, char *buf)
784{
785 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
786 struct abituguru_data *data = dev_get_drvdata(dev);
787 if (data->bank2_settings[attr->index][0] & attr->nr)
788 return sprintf(buf, "1\n");
789 else
790 return sprintf(buf, "0\n");
791}
792
793static ssize_t store_bank1_mask(struct device *dev,
794 struct device_attribute *devattr, const char *buf, size_t count)
795{
796 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
797 struct abituguru_data *data = dev_get_drvdata(dev);
798 int mask = simple_strtoul(buf, NULL, 10);
799 ssize_t ret = count;
800 u8 orig_val;
801
802 mutex_lock(&data->update_lock);
803 orig_val = data->bank1_settings[attr->index][0];
804
805 if (mask)
806 data->bank1_settings[attr->index][0] |= attr->nr;
807 else
808 data->bank1_settings[attr->index][0] &= ~attr->nr;
809
810 if ((data->bank1_settings[attr->index][0] != orig_val) &&
811 (abituguru_write(data,
812 ABIT_UGURU_SENSOR_BANK1 + 2, attr->index,
813 data->bank1_settings[attr->index], 3) < 1)) {
814 data->bank1_settings[attr->index][0] = orig_val;
815 ret = -EIO;
816 }
817 mutex_unlock(&data->update_lock);
818 return ret;
819}
820
821static ssize_t store_bank2_mask(struct device *dev,
822 struct device_attribute *devattr, const char *buf, size_t count)
823{
824 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
825 struct abituguru_data *data = dev_get_drvdata(dev);
826 int mask = simple_strtoul(buf, NULL, 10);
827 ssize_t ret = count;
828 u8 orig_val;
829
830 mutex_lock(&data->update_lock);
831 orig_val = data->bank2_settings[attr->index][0];
832
833 if (mask)
834 data->bank2_settings[attr->index][0] |= attr->nr;
835 else
836 data->bank2_settings[attr->index][0] &= ~attr->nr;
837
838 if ((data->bank2_settings[attr->index][0] != orig_val) &&
839 (abituguru_write(data,
840 ABIT_UGURU_SENSOR_BANK2 + 2, attr->index,
841 data->bank2_settings[attr->index], 2) < 1)) {
842 data->bank2_settings[attr->index][0] = orig_val;
843 ret = -EIO;
844 }
845 mutex_unlock(&data->update_lock);
846 return ret;
847}
848
849/* Fan PWM (speed control) */
850static ssize_t show_pwm_setting(struct device *dev,
851 struct device_attribute *devattr, char *buf)
852{
853 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
854 struct abituguru_data *data = dev_get_drvdata(dev);
855 return sprintf(buf, "%d\n", data->pwm_settings[attr->index][attr->nr] *
856 abituguru_pwm_settings_multiplier[attr->nr]);
857}
858
859static ssize_t store_pwm_setting(struct device *dev, struct device_attribute
860 *devattr, const char *buf, size_t count)
861{
862 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
863 struct abituguru_data *data = dev_get_drvdata(dev);
864 u8 min, val = (simple_strtoul(buf, NULL, 10) +
865 abituguru_pwm_settings_multiplier[attr->nr]/2) /
866 abituguru_pwm_settings_multiplier[attr->nr];
867 ssize_t ret = count;
868
869 /* special case pwm1 min pwm% */
870 if ((attr->index == 0) && ((attr->nr == 1) || (attr->nr == 2)))
871 min = 77;
872 else
873 min = abituguru_pwm_min[attr->nr];
874
875 /* this check can be done before taking the lock */
876 if ((val < min) || (val > abituguru_pwm_max[attr->nr]))
877 return -EINVAL;
878
879 mutex_lock(&data->update_lock);
880 /* this check needs to be done after taking the lock */
881 if ((attr->nr & 1) &&
882 (val >= data->pwm_settings[attr->index][attr->nr + 1]))
883 ret = -EINVAL;
884 else if (!(attr->nr & 1) &&
885 (val <= data->pwm_settings[attr->index][attr->nr - 1]))
886 ret = -EINVAL;
887 else if (data->pwm_settings[attr->index][attr->nr] != val) {
888 u8 orig_val = data->pwm_settings[attr->index][attr->nr];
889 data->pwm_settings[attr->index][attr->nr] = val;
890 if (abituguru_write(data, ABIT_UGURU_FAN_PWM + 1,
891 attr->index, data->pwm_settings[attr->index],
892 5) <= attr->nr) {
893 data->pwm_settings[attr->index][attr->nr] =
894 orig_val;
895 ret = -EIO;
896 }
897 }
898 mutex_unlock(&data->update_lock);
899 return ret;
900}
901
902static ssize_t show_pwm_sensor(struct device *dev,
903 struct device_attribute *devattr, char *buf)
904{
905 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
906 struct abituguru_data *data = dev_get_drvdata(dev);
907 int i;
908 /* We need to walk to the temp sensor addresses to find what
909 the userspace id of the configured temp sensor is. */
910 for (i = 0; i < data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR]; i++)
911 if (data->bank1_address[ABIT_UGURU_TEMP_SENSOR][i] ==
912 (data->pwm_settings[attr->index][0] & 0x0F))
913 return sprintf(buf, "%d\n", i+1);
914
915 return -ENXIO;
916}
917
918static ssize_t store_pwm_sensor(struct device *dev, struct device_attribute
919 *devattr, const char *buf, size_t count)
920{
921 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
922 struct abituguru_data *data = dev_get_drvdata(dev);
923 unsigned long val = simple_strtoul(buf, NULL, 10) - 1;
924 ssize_t ret = count;
925
926 mutex_lock(&data->update_lock);
927 if (val < data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR]) {
928 u8 orig_val = data->pwm_settings[attr->index][0];
929 u8 address = data->bank1_address[ABIT_UGURU_TEMP_SENSOR][val];
930 data->pwm_settings[attr->index][0] &= 0xF0;
931 data->pwm_settings[attr->index][0] |= address;
932 if (data->pwm_settings[attr->index][0] != orig_val) {
933 if (abituguru_write(data, ABIT_UGURU_FAN_PWM + 1,
934 attr->index,
935 data->pwm_settings[attr->index],
936 5) < 1) {
937 data->pwm_settings[attr->index][0] = orig_val;
938 ret = -EIO;
939 }
940 }
941 }
942 else
943 ret = -EINVAL;
944 mutex_unlock(&data->update_lock);
945 return ret;
946}
947
948static ssize_t show_pwm_enable(struct device *dev,
949 struct device_attribute *devattr, char *buf)
950{
951 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
952 struct abituguru_data *data = dev_get_drvdata(dev);
953 int res = 0;
954 if (data->pwm_settings[attr->index][0] & ABIT_UGURU_FAN_PWM_ENABLE)
955 res = 2;
956 return sprintf(buf, "%d\n", res);
957}
958
959static ssize_t store_pwm_enable(struct device *dev, struct device_attribute
960 *devattr, const char *buf, size_t count)
961{
962 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
963 struct abituguru_data *data = dev_get_drvdata(dev);
964 u8 orig_val, user_val = simple_strtoul(buf, NULL, 10);
965 ssize_t ret = count;
966
967 mutex_lock(&data->update_lock);
968 orig_val = data->pwm_settings[attr->index][0];
969 switch (user_val) {
970 case 0:
971 data->pwm_settings[attr->index][0] &=
972 ~ABIT_UGURU_FAN_PWM_ENABLE;
973 break;
974 case 2:
975 data->pwm_settings[attr->index][0] |=
976 ABIT_UGURU_FAN_PWM_ENABLE;
977 break;
978 default:
979 ret = -EINVAL;
980 }
981 if ((data->pwm_settings[attr->index][0] != orig_val) &&
982 (abituguru_write(data, ABIT_UGURU_FAN_PWM + 1,
983 attr->index, data->pwm_settings[attr->index],
984 5) < 1)) {
985 data->pwm_settings[attr->index][0] = orig_val;
986 ret = -EIO;
987 }
988 mutex_unlock(&data->update_lock);
989 return ret;
990}
991
992static ssize_t show_name(struct device *dev,
993 struct device_attribute *devattr, char *buf)
994{
995 return sprintf(buf, "%s\n", ABIT_UGURU_NAME);
996}
997
998/* Sysfs attr templates, the real entries are generated automatically. */
999static const
1000struct sensor_device_attribute_2 abituguru_sysfs_bank1_templ[2][9] = {
1001 {
1002 SENSOR_ATTR_2(in%d_input, 0444, show_bank1_value, NULL, 0, 0),
1003 SENSOR_ATTR_2(in%d_min, 0644, show_bank1_setting,
1004 store_bank1_setting, 1, 0),
1005 SENSOR_ATTR_2(in%d_min_alarm, 0444, show_bank1_alarm, NULL,
1006 ABIT_UGURU_VOLT_LOW_ALARM_FLAG, 0),
1007 SENSOR_ATTR_2(in%d_max, 0644, show_bank1_setting,
1008 store_bank1_setting, 2, 0),
1009 SENSOR_ATTR_2(in%d_max_alarm, 0444, show_bank1_alarm, NULL,
1010 ABIT_UGURU_VOLT_HIGH_ALARM_FLAG, 0),
1011 SENSOR_ATTR_2(in%d_beep, 0644, show_bank1_mask,
1012 store_bank1_mask, ABIT_UGURU_BEEP_ENABLE, 0),
1013 SENSOR_ATTR_2(in%d_shutdown, 0644, show_bank1_mask,
1014 store_bank1_mask, ABIT_UGURU_SHUTDOWN_ENABLE, 0),
1015 SENSOR_ATTR_2(in%d_min_alarm_enable, 0644, show_bank1_mask,
1016 store_bank1_mask, ABIT_UGURU_VOLT_LOW_ALARM_ENABLE, 0),
1017 SENSOR_ATTR_2(in%d_max_alarm_enable, 0644, show_bank1_mask,
1018 store_bank1_mask, ABIT_UGURU_VOLT_HIGH_ALARM_ENABLE, 0),
1019 }, {
1020 SENSOR_ATTR_2(temp%d_input, 0444, show_bank1_value, NULL, 0, 0),
1021 SENSOR_ATTR_2(temp%d_alarm, 0444, show_bank1_alarm, NULL,
1022 ABIT_UGURU_TEMP_HIGH_ALARM_FLAG, 0),
1023 SENSOR_ATTR_2(temp%d_max, 0644, show_bank1_setting,
1024 store_bank1_setting, 1, 0),
1025 SENSOR_ATTR_2(temp%d_crit, 0644, show_bank1_setting,
1026 store_bank1_setting, 2, 0),
1027 SENSOR_ATTR_2(temp%d_beep, 0644, show_bank1_mask,
1028 store_bank1_mask, ABIT_UGURU_BEEP_ENABLE, 0),
1029 SENSOR_ATTR_2(temp%d_shutdown, 0644, show_bank1_mask,
1030 store_bank1_mask, ABIT_UGURU_SHUTDOWN_ENABLE, 0),
1031 SENSOR_ATTR_2(temp%d_alarm_enable, 0644, show_bank1_mask,
1032 store_bank1_mask, ABIT_UGURU_TEMP_HIGH_ALARM_ENABLE, 0),
1033 }
1034};
1035
1036static const struct sensor_device_attribute_2 abituguru_sysfs_fan_templ[6] = {
1037 SENSOR_ATTR_2(fan%d_input, 0444, show_bank2_value, NULL, 0, 0),
1038 SENSOR_ATTR_2(fan%d_alarm, 0444, show_bank2_alarm, NULL, 0, 0),
1039 SENSOR_ATTR_2(fan%d_min, 0644, show_bank2_setting,
1040 store_bank2_setting, 1, 0),
1041 SENSOR_ATTR_2(fan%d_beep, 0644, show_bank2_mask,
1042 store_bank2_mask, ABIT_UGURU_BEEP_ENABLE, 0),
1043 SENSOR_ATTR_2(fan%d_shutdown, 0644, show_bank2_mask,
1044 store_bank2_mask, ABIT_UGURU_SHUTDOWN_ENABLE, 0),
1045 SENSOR_ATTR_2(fan%d_alarm_enable, 0644, show_bank2_mask,
1046 store_bank2_mask, ABIT_UGURU_FAN_LOW_ALARM_ENABLE, 0),
1047};
1048
1049static const struct sensor_device_attribute_2 abituguru_sysfs_pwm_templ[6] = {
1050 SENSOR_ATTR_2(pwm%d_enable, 0644, show_pwm_enable,
1051 store_pwm_enable, 0, 0),
1052 SENSOR_ATTR_2(pwm%d_auto_channels_temp, 0644, show_pwm_sensor,
1053 store_pwm_sensor, 0, 0),
1054 SENSOR_ATTR_2(pwm%d_auto_point1_pwm, 0644, show_pwm_setting,
1055 store_pwm_setting, 1, 0),
1056 SENSOR_ATTR_2(pwm%d_auto_point2_pwm, 0644, show_pwm_setting,
1057 store_pwm_setting, 2, 0),
1058 SENSOR_ATTR_2(pwm%d_auto_point1_temp, 0644, show_pwm_setting,
1059 store_pwm_setting, 3, 0),
1060 SENSOR_ATTR_2(pwm%d_auto_point2_temp, 0644, show_pwm_setting,
1061 store_pwm_setting, 4, 0),
1062};
1063
1064static const struct sensor_device_attribute_2 abituguru_sysfs_attr[] = {
1065 SENSOR_ATTR_2(name, 0444, show_name, NULL, 0, 0),
1066};
1067
1068static int __devinit abituguru_probe(struct platform_device *pdev)
1069{
1070 struct abituguru_data *data;
1071 int i, j, res;
1072 char *sysfs_filename;
1073 int sysfs_attr_i = 0;
1074
1075 /* El weirdo probe order, to keep the sysfs order identical to the
1076 BIOS and window-appliction listing order. */
1077 const u8 probe_order[16] = { 0x00, 0x01, 0x03, 0x04, 0x0A, 0x08, 0x0E,
1078 0x02, 0x09, 0x06, 0x05, 0x0B, 0x0F, 0x0D, 0x07, 0x0C };
1079
1080 if (!(data = kzalloc(sizeof(struct abituguru_data), GFP_KERNEL)))
1081 return -ENOMEM;
1082
1083 data->addr = platform_get_resource(pdev, IORESOURCE_IO, 0)->start;
1084 mutex_init(&data->update_lock);
1085 platform_set_drvdata(pdev, data);
1086
1087 /* See if the uGuru is ready */
1088 if (inb_p(data->addr + ABIT_UGURU_DATA) == ABIT_UGURU_STATUS_INPUT)
1089 data->uguru_ready = 1;
1090
1091 /* Completely read the uGuru this has 2 purposes:
1092 - testread / see if one really is there.
1093 - make an in memory copy of all the uguru settings for future use. */
1094 if (abituguru_read(data, ABIT_UGURU_ALARM_BANK, 0,
1095 data->alarms, 3, ABIT_UGURU_MAX_RETRIES) != 3) {
1096 kfree(data);
1097 return -ENODEV;
1098 }
1099
1100 for (i = 0; i < 16; i++) {
1101 if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK1, i,
1102 &data->bank1_value[i], 1,
1103 ABIT_UGURU_MAX_RETRIES) != 1) {
1104 kfree(data);
1105 return -ENODEV;
1106 }
1107 if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK1+1, i,
1108 data->bank1_settings[i], 3,
1109 ABIT_UGURU_MAX_RETRIES) != 3) {
1110 kfree(data);
1111 return -ENODEV;
1112 }
1113 }
1114 /* Note: We don't know how many bank2 sensors / pwms there really are,
1115 but in order to "detect" this we need to read the maximum amount
1116 anyways. If we read sensors/pwms not there we'll just read crap
1117 this can't hurt. We need the detection because we don't want
1118 unwanted writes, which will hurt! */
1119 for (i = 0; i < ABIT_UGURU_MAX_BANK2_SENSORS; i++) {
1120 if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK2, i,
1121 &data->bank2_value[i], 1,
1122 ABIT_UGURU_MAX_RETRIES) != 1) {
1123 kfree(data);
1124 return -ENODEV;
1125 }
1126 if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK2+1, i,
1127 data->bank2_settings[i], 2,
1128 ABIT_UGURU_MAX_RETRIES) != 2) {
1129 kfree(data);
1130 return -ENODEV;
1131 }
1132 }
1133 for (i = 0; i < ABIT_UGURU_MAX_PWMS; i++) {
1134 if (abituguru_read(data, ABIT_UGURU_FAN_PWM, i,
1135 data->pwm_settings[i], 5,
1136 ABIT_UGURU_MAX_RETRIES) != 5) {
1137 kfree(data);
1138 return -ENODEV;
1139 }
1140 }
1141 data->last_updated = jiffies;
1142
1143 /* Detect sensor types and fill the sysfs attr for bank1 */
1144 sysfs_filename = data->bank1_names;
1145 for (i = 0; i < 16; i++) {
1146 res = abituguru_detect_bank1_sensor_type(data, probe_order[i]);
1147 if (res < 0) {
1148 kfree(data);
1149 return -ENODEV;
1150 }
1151 if (res == ABIT_UGURU_NC)
1152 continue;
1153
1154 for (j = 0; j < (res ? 7 : 9); j++) {
1155 const char *name_templ = abituguru_sysfs_bank1_templ[
1156 res][j].dev_attr.attr.name;
1157 data->sysfs_attr[sysfs_attr_i] =
1158 abituguru_sysfs_bank1_templ[res][j];
1159 data->sysfs_attr[sysfs_attr_i].dev_attr.attr.name =
1160 sysfs_filename;
1161 sysfs_filename += sprintf(sysfs_filename, name_templ,
1162 data->bank1_sensors[res] + res) + 1;
1163 data->sysfs_attr[sysfs_attr_i].index = probe_order[i];
1164 sysfs_attr_i++;
1165 }
1166 data->bank1_max_value[probe_order[i]] =
1167 abituguru_bank1_max_value[res];
1168 data->bank1_address[res][data->bank1_sensors[res]] =
1169 probe_order[i];
1170 data->bank1_sensors[res]++;
1171 }
1172 /* Detect number of sensors and fill the sysfs attr for bank2 (fans) */
1173 abituguru_detect_no_bank2_sensors(data);
1174 for (i = 0; i < data->bank2_sensors; i++) {
1175 for (j = 0; j < 6; j++) {
1176 const char *name_templ = abituguru_sysfs_fan_templ[j].
1177 dev_attr.attr.name;
1178 data->sysfs_attr[sysfs_attr_i] =
1179 abituguru_sysfs_fan_templ[j];
1180 data->sysfs_attr[sysfs_attr_i].dev_attr.attr.name =
1181 sysfs_filename;
1182 sysfs_filename += sprintf(sysfs_filename, name_templ,
1183 i + 1) + 1;
1184 data->sysfs_attr[sysfs_attr_i].index = i;
1185 sysfs_attr_i++;
1186 }
1187 }
1188 /* Detect number of sensors and fill the sysfs attr for pwms */
1189 abituguru_detect_no_pwms(data);
1190 for (i = 0; i < data->pwms; i++) {
1191 for (j = 0; j < 6; j++) {
1192 const char *name_templ = abituguru_sysfs_pwm_templ[j].
1193 dev_attr.attr.name;
1194 data->sysfs_attr[sysfs_attr_i] =
1195 abituguru_sysfs_pwm_templ[j];
1196 data->sysfs_attr[sysfs_attr_i].dev_attr.attr.name =
1197 sysfs_filename;
1198 sysfs_filename += sprintf(sysfs_filename, name_templ,
1199 i + 1) + 1;
1200 data->sysfs_attr[sysfs_attr_i].index = i;
1201 sysfs_attr_i++;
1202 }
1203 }
1204 /* Last add any "generic" entries to sysfs */
1205 for (i = 0; i < ARRAY_SIZE(abituguru_sysfs_attr); i++) {
1206 data->sysfs_attr[sysfs_attr_i] = abituguru_sysfs_attr[i];
1207 sysfs_attr_i++;
1208 }
1209 printk(KERN_INFO ABIT_UGURU_NAME ": found Abit uGuru\n");
1210
1211 /* Register sysfs hooks */
1212 data->class_dev = hwmon_device_register(&pdev->dev);
1213 if (IS_ERR(data->class_dev)) {
1214 kfree(data);
1215 return PTR_ERR(data->class_dev);
1216 }
1217 for (i = 0; i < sysfs_attr_i; i++)
1218 device_create_file(&pdev->dev, &data->sysfs_attr[i].dev_attr);
1219
1220 return 0;
1221}
1222
1223static int __devexit abituguru_remove(struct platform_device *pdev)
1224{
1225 struct abituguru_data *data = platform_get_drvdata(pdev);
1226
1227 platform_set_drvdata(pdev, NULL);
1228 hwmon_device_unregister(data->class_dev);
1229 kfree(data);
1230
1231 return 0;
1232}
1233
1234static struct abituguru_data *abituguru_update_device(struct device *dev)
1235{
1236 int i, err;
1237 struct abituguru_data *data = dev_get_drvdata(dev);
1238 /* fake a complete successful read if no update necessary. */
1239 char success = 1;
1240
1241 mutex_lock(&data->update_lock);
1242 if (time_after(jiffies, data->last_updated + HZ)) {
1243 success = 0;
1244 if ((err = abituguru_read(data, ABIT_UGURU_ALARM_BANK, 0,
1245 data->alarms, 3, 0)) != 3)
1246 goto LEAVE_UPDATE;
1247 for (i = 0; i < 16; i++) {
1248 if ((err = abituguru_read(data,
1249 ABIT_UGURU_SENSOR_BANK1, i,
1250 &data->bank1_value[i], 1, 0)) != 1)
1251 goto LEAVE_UPDATE;
1252 if ((err = abituguru_read(data,
1253 ABIT_UGURU_SENSOR_BANK1 + 1, i,
1254 data->bank1_settings[i], 3, 0)) != 3)
1255 goto LEAVE_UPDATE;
1256 }
1257 for (i = 0; i < data->bank2_sensors; i++)
1258 if ((err = abituguru_read(data,
1259 ABIT_UGURU_SENSOR_BANK2, i,
1260 &data->bank2_value[i], 1, 0)) != 1)
1261 goto LEAVE_UPDATE;
1262 /* success! */
1263 success = 1;
1264 data->update_timeouts = 0;
1265LEAVE_UPDATE:
1266 /* handle timeout condition */
1267 if (err == -EBUSY) {
1268 /* No overflow please */
1269 if (data->update_timeouts < 255u)
1270 data->update_timeouts++;
1271 if (data->update_timeouts <= ABIT_UGURU_MAX_TIMEOUTS) {
1272 ABIT_UGURU_DEBUG(3, "timeout exceeded, will "
1273 "try again next update\n");
1274 /* Just a timeout, fake a successful read */
1275 success = 1;
1276 } else
1277 ABIT_UGURU_DEBUG(1, "timeout exceeded %d "
1278 "times waiting for more input state\n",
1279 (int)data->update_timeouts);
1280 }
1281 /* On success set last_updated */
1282 if (success)
1283 data->last_updated = jiffies;
1284 }
1285 mutex_unlock(&data->update_lock);
1286
1287 if (success)
1288 return data;
1289 else
1290 return NULL;
1291}
1292
1293static struct platform_driver abituguru_driver = {
1294 .driver = {
1295 .owner = THIS_MODULE,
1296 .name = ABIT_UGURU_NAME,
1297 },
1298 .probe = abituguru_probe,
1299 .remove = __devexit_p(abituguru_remove),
1300};
1301
1302static int __init abituguru_detect(void)
1303{
1304 /* See if there is an uguru there. After a reboot uGuru will hold 0x00
1305 at DATA and 0xAC, when this driver has already been loaded once
1306 DATA will hold 0x08. For most uGuru's CMD will hold 0xAC in either
1307 scenario but some will hold 0x00.
1308 Some uGuru's initally hold 0x09 at DATA and will only hold 0x08
1309 after reading CMD first, so CMD must be read first! */
1310 u8 cmd_val = inb_p(ABIT_UGURU_BASE + ABIT_UGURU_CMD);
1311 u8 data_val = inb_p(ABIT_UGURU_BASE + ABIT_UGURU_DATA);
1312 if (((data_val == 0x00) || (data_val == 0x08)) &&
1313 ((cmd_val == 0x00) || (cmd_val == 0xAC)))
1314 return ABIT_UGURU_BASE;
1315
1316 ABIT_UGURU_DEBUG(2, "no Abit uGuru found, data = 0x%02X, cmd = "
1317 "0x%02X\n", (unsigned int)data_val, (unsigned int)cmd_val);
1318
1319 if (force) {
1320 printk(KERN_INFO ABIT_UGURU_NAME ": Assuming Abit uGuru is "
1321 "present because of \"force\" parameter\n");
1322 return ABIT_UGURU_BASE;
1323 }
1324
1325 /* No uGuru found */
1326 return -ENODEV;
1327}
1328
1329static struct platform_device *abituguru_pdev;
1330
1331static int __init abituguru_init(void)
1332{
1333 int address, err;
1334 struct resource res = { .flags = IORESOURCE_IO };
1335
1336 address = abituguru_detect();
1337 if (address < 0)
1338 return address;
1339
1340 err = platform_driver_register(&abituguru_driver);
1341 if (err)
1342 goto exit;
1343
1344 abituguru_pdev = platform_device_alloc(ABIT_UGURU_NAME, address);
1345 if (!abituguru_pdev) {
1346 printk(KERN_ERR ABIT_UGURU_NAME
1347 ": Device allocation failed\n");
1348 err = -ENOMEM;
1349 goto exit_driver_unregister;
1350 }
1351
1352 res.start = address;
1353 res.end = address + ABIT_UGURU_REGION_LENGTH - 1;
1354 res.name = ABIT_UGURU_NAME;
1355
1356 err = platform_device_add_resources(abituguru_pdev, &res, 1);
1357 if (err) {
1358 printk(KERN_ERR ABIT_UGURU_NAME
1359 ": Device resource addition failed (%d)\n", err);
1360 goto exit_device_put;
1361 }
1362
1363 err = platform_device_add(abituguru_pdev);
1364 if (err) {
1365 printk(KERN_ERR ABIT_UGURU_NAME
1366 ": Device addition failed (%d)\n", err);
1367 goto exit_device_put;
1368 }
1369
1370 return 0;
1371
1372exit_device_put:
1373 platform_device_put(abituguru_pdev);
1374exit_driver_unregister:
1375 platform_driver_unregister(&abituguru_driver);
1376exit:
1377 return err;
1378}
1379
1380static void __exit abituguru_exit(void)
1381{
1382 platform_device_unregister(abituguru_pdev);
1383 platform_driver_unregister(&abituguru_driver);
1384}
1385
1386MODULE_AUTHOR("Hans de Goede <j.w.r.degoede@hhs.nl>");
1387MODULE_DESCRIPTION("Abit uGuru Sensor device");
1388MODULE_LICENSE("GPL");
1389
1390module_init(abituguru_init);
1391module_exit(abituguru_exit);
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-12 19:18:00 -0500