2 abituguru.c Copyright (c) 2005-2006 Hans de Goede <hdegoede@redhat.com>
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.
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.
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.
19 This driver supports the sensor part of the first and second revision of
20 the custom Abit uGuru chip found on Abit uGuru motherboards. Note: because
21 of lack of specs the CPU/RAM voltage & frequency control is not supported!
24 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26 #include <linux/module.h>
27 #include <linux/sched.h>
28 #include <linux/init.h>
29 #include <linux/slab.h>
30 #include <linux/jiffies.h>
31 #include <linux/mutex.h>
32 #include <linux/err.h>
33 #include <linux/delay.h>
34 #include <linux/platform_device.h>
35 #include <linux/hwmon.h>
36 #include <linux/hwmon-sysfs.h>
37 #include <linux/dmi.h>
41 #define ABIT_UGURU_ALARM_BANK 0x20 /* 1x 3 bytes */
42 #define ABIT_UGURU_SENSOR_BANK1 0x21 /* 16x volt and temp */
43 #define ABIT_UGURU_FAN_PWM 0x24 /* 3x 5 bytes */
44 #define ABIT_UGURU_SENSOR_BANK2 0x26 /* fans */
45 /* max nr of sensors in bank1, a bank1 sensor can be in, temp or nc */
46 #define ABIT_UGURU_MAX_BANK1_SENSORS 16
47 /* Warning if you increase one of the 2 MAX defines below to 10 or higher you
48 should adjust the belonging _NAMES_LENGTH macro for the 2 digit number! */
49 /* max nr of sensors in bank2, currently mb's with max 6 fans are known */
50 #define ABIT_UGURU_MAX_BANK2_SENSORS 6
51 /* max nr of pwm outputs, currently mb's with max 5 pwm outputs are known */
52 #define ABIT_UGURU_MAX_PWMS 5
53 /* uGuru sensor bank 1 flags */ /* Alarm if: */
54 #define ABIT_UGURU_TEMP_HIGH_ALARM_ENABLE 0x01 /* temp over warn */
55 #define ABIT_UGURU_VOLT_HIGH_ALARM_ENABLE 0x02 /* volt over max */
56 #define ABIT_UGURU_VOLT_LOW_ALARM_ENABLE 0x04 /* volt under min */
57 #define ABIT_UGURU_TEMP_HIGH_ALARM_FLAG 0x10 /* temp is over warn */
58 #define ABIT_UGURU_VOLT_HIGH_ALARM_FLAG 0x20 /* volt is over max */
59 #define ABIT_UGURU_VOLT_LOW_ALARM_FLAG 0x40 /* volt is under min */
60 /* uGuru sensor bank 2 flags */ /* Alarm if: */
61 #define ABIT_UGURU_FAN_LOW_ALARM_ENABLE 0x01 /* fan under min */
62 /* uGuru sensor bank common flags */
63 #define ABIT_UGURU_BEEP_ENABLE 0x08 /* beep if alarm */
64 #define ABIT_UGURU_SHUTDOWN_ENABLE 0x80 /* shutdown if alarm */
65 /* uGuru fan PWM (speed control) flags */
66 #define ABIT_UGURU_FAN_PWM_ENABLE 0x80 /* enable speed control */
67 /* Values used for conversion */
68 #define ABIT_UGURU_FAN_MAX 15300 /* RPM */
69 /* Bank1 sensor types */
70 #define ABIT_UGURU_IN_SENSOR 0
71 #define ABIT_UGURU_TEMP_SENSOR 1
72 #define ABIT_UGURU_NC 2
73 /* In many cases we need to wait for the uGuru to reach a certain status, most
74 of the time it will reach this status within 30 - 90 ISA reads, and thus we
75 can best busy wait. This define gives the total amount of reads to try. */
76 #define ABIT_UGURU_WAIT_TIMEOUT 125
77 /* However sometimes older versions of the uGuru seem to be distracted and they
78 do not respond for a long time. To handle this we sleep before each of the
79 last ABIT_UGURU_WAIT_TIMEOUT_SLEEP tries. */
80 #define ABIT_UGURU_WAIT_TIMEOUT_SLEEP 5
81 /* Normally all expected status in abituguru_ready, are reported after the
82 first read, but sometimes not and we need to poll. */
83 #define ABIT_UGURU_READY_TIMEOUT 5
84 /* Maximum 3 retries on timedout reads/writes, delay 200 ms before retrying */
85 #define ABIT_UGURU_MAX_RETRIES 3
86 #define ABIT_UGURU_RETRY_DELAY (HZ/5)
87 /* Maximum 2 timeouts in abituguru_update_device, iow 3 in a row is an error */
88 #define ABIT_UGURU_MAX_TIMEOUTS 2
90 #define ABIT_UGURU_NAME "abituguru"
91 #define ABIT_UGURU_DEBUG(level, format, arg...) \
92 if (level <= verbose) \
93 printk(KERN_DEBUG ABIT_UGURU_NAME ": " format , ## arg)
94 /* Macros to help calculate the sysfs_names array length */
95 /* sum of strlen of: in??_input\0, in??_{min,max}\0, in??_{min,max}_alarm\0,
96 in??_{min,max}_alarm_enable\0, in??_beep\0, in??_shutdown\0 */
97 #define ABITUGURU_IN_NAMES_LENGTH (11 + 2 * 9 + 2 * 15 + 2 * 22 + 10 + 14)
98 /* sum of strlen of: temp??_input\0, temp??_max\0, temp??_crit\0,
99 temp??_alarm\0, temp??_alarm_enable\0, temp??_beep\0, temp??_shutdown\0 */
100 #define ABITUGURU_TEMP_NAMES_LENGTH (13 + 11 + 12 + 13 + 20 + 12 + 16)
101 /* sum of strlen of: fan?_input\0, fan?_min\0, fan?_alarm\0,
102 fan?_alarm_enable\0, fan?_beep\0, fan?_shutdown\0 */
103 #define ABITUGURU_FAN_NAMES_LENGTH (11 + 9 + 11 + 18 + 10 + 14)
104 /* sum of strlen of: pwm?_enable\0, pwm?_auto_channels_temp\0,
105 pwm?_auto_point{1,2}_pwm\0, pwm?_auto_point{1,2}_temp\0 */
106 #define ABITUGURU_PWM_NAMES_LENGTH (12 + 24 + 2 * 21 + 2 * 22)
107 /* IN_NAMES_LENGTH > TEMP_NAMES_LENGTH so assume all bank1 sensors are in */
108 #define ABITUGURU_SYSFS_NAMES_LENGTH ( \
109 ABIT_UGURU_MAX_BANK1_SENSORS * ABITUGURU_IN_NAMES_LENGTH + \
110 ABIT_UGURU_MAX_BANK2_SENSORS * ABITUGURU_FAN_NAMES_LENGTH + \
111 ABIT_UGURU_MAX_PWMS * ABITUGURU_PWM_NAMES_LENGTH)
113 /* All the macros below are named identical to the oguru and oguru2 programs
114 reverse engineered by Olle Sandberg, hence the names might not be 100%
115 logical. I could come up with better names, but I prefer keeping the names
116 identical so that this driver can be compared with his work more easily. */
117 /* Two i/o-ports are used by uGuru */
118 #define ABIT_UGURU_BASE 0x00E0
119 /* Used to tell uGuru what to read and to read the actual data */
120 #define ABIT_UGURU_CMD 0x00
121 /* Mostly used to check if uGuru is busy */
122 #define ABIT_UGURU_DATA 0x04
123 #define ABIT_UGURU_REGION_LENGTH 5
125 #define ABIT_UGURU_STATUS_WRITE 0x00 /* Ready to be written */
126 #define ABIT_UGURU_STATUS_READ 0x01 /* Ready to be read */
127 #define ABIT_UGURU_STATUS_INPUT 0x08 /* More input */
128 #define ABIT_UGURU_STATUS_READY 0x09 /* Ready to be written */
131 /* in (Volt) sensors go up to 3494 mV, temp to 255000 millidegrees Celsius */
132 static const int abituguru_bank1_max_value
[2] = { 3494, 255000 };
133 /* Min / Max allowed values for sensor2 (fan) alarm threshold, these values
134 correspond to 300-3000 RPM */
135 static const u8 abituguru_bank2_min_threshold
= 5;
136 static const u8 abituguru_bank2_max_threshold
= 50;
137 /* Register 0 is a bitfield, 1 and 2 are pwm settings (255 = 100%), 3 and 4
138 are temperature trip points. */
139 static const int abituguru_pwm_settings_multiplier
[5] = { 0, 1, 1, 1000, 1000 };
140 /* Min / Max allowed values for pwm_settings. Note: pwm1 (CPU fan) is a
141 special case the minium allowed pwm% setting for this is 30% (77) on
142 some MB's this special case is handled in the code! */
143 static const u8 abituguru_pwm_min
[5] = { 0, 170, 170, 25, 25 };
144 static const u8 abituguru_pwm_max
[5] = { 0, 255, 255, 75, 75 };
147 /* Insmod parameters */
149 module_param(force
, bool, 0);
150 MODULE_PARM_DESC(force
, "Set to one to force detection.");
151 static int bank1_types
[ABIT_UGURU_MAX_BANK1_SENSORS
] = { -1, -1, -1, -1, -1,
152 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
153 module_param_array(bank1_types
, int, NULL
, 0);
154 MODULE_PARM_DESC(bank1_types
, "Bank1 sensortype autodetection override:\n"
159 static int fan_sensors
;
160 module_param(fan_sensors
, int, 0);
161 MODULE_PARM_DESC(fan_sensors
, "Number of fan sensors on the uGuru "
164 module_param(pwms
, int, 0);
165 MODULE_PARM_DESC(pwms
, "Number of PWMs on the uGuru "
168 /* Default verbose is 2, since this driver is still in the testing phase */
169 static int verbose
= 2;
170 module_param(verbose
, int, 0644);
171 MODULE_PARM_DESC(verbose
, "How verbose should the driver be? (0-3):\n"
173 " 1 + verbose error reporting\n"
174 " 2 + sensors type probing info\n"
175 " 3 + retryable error reporting");
178 /* For the Abit uGuru, we need to keep some data in memory.
179 The structure is dynamically allocated, at the same time when a new
180 abituguru device is allocated. */
181 struct abituguru_data
{
182 struct device
*hwmon_dev
; /* hwmon registered device */
183 struct mutex update_lock
; /* protect access to data and uGuru */
184 unsigned long last_updated
; /* In jiffies */
185 unsigned short addr
; /* uguru base address */
186 char uguru_ready
; /* is the uguru in ready state? */
187 unsigned char update_timeouts
; /* number of update timeouts since last
190 /* The sysfs attr and their names are generated automatically, for bank1
191 we cannot use a predefined array because we don't know beforehand
192 of a sensor is a volt or a temp sensor, for bank2 and the pwms its
193 easier todo things the same way. For in sensors we have 9 (temp 7)
194 sysfs entries per sensor, for bank2 and pwms 6. */
195 struct sensor_device_attribute_2 sysfs_attr
[
196 ABIT_UGURU_MAX_BANK1_SENSORS
* 9 +
197 ABIT_UGURU_MAX_BANK2_SENSORS
* 6 + ABIT_UGURU_MAX_PWMS
* 6];
198 /* Buffer to store the dynamically generated sysfs names */
199 char sysfs_names
[ABITUGURU_SYSFS_NAMES_LENGTH
];
202 /* number of and addresses of [0] in, [1] temp sensors */
204 u8 bank1_address
[2][ABIT_UGURU_MAX_BANK1_SENSORS
];
205 u8 bank1_value
[ABIT_UGURU_MAX_BANK1_SENSORS
];
206 /* This array holds 3 entries per sensor for the bank 1 sensor settings
207 (flags, min, max for voltage / flags, warn, shutdown for temp). */
208 u8 bank1_settings
[ABIT_UGURU_MAX_BANK1_SENSORS
][3];
209 /* Maximum value for each sensor used for scaling in mV/millidegrees
211 int bank1_max_value
[ABIT_UGURU_MAX_BANK1_SENSORS
];
213 /* Bank 2 data, ABIT_UGURU_MAX_BANK2_SENSORS entries for bank2 */
214 u8 bank2_sensors
; /* actual number of bank2 sensors found */
215 u8 bank2_value
[ABIT_UGURU_MAX_BANK2_SENSORS
];
216 u8 bank2_settings
[ABIT_UGURU_MAX_BANK2_SENSORS
][2]; /* flags, min */
218 /* Alarms 2 bytes for bank1, 1 byte for bank2 */
221 /* Fan PWM (speed control) 5 bytes per PWM */
222 u8 pwms
; /* actual number of pwms found */
223 u8 pwm_settings
[ABIT_UGURU_MAX_PWMS
][5];
226 static const char *never_happen
= "This should never happen.";
227 static const char *report_this
=
228 "Please report this to the abituguru maintainer (see MAINTAINERS)";
230 /* wait till the uguru is in the specified state */
231 static int abituguru_wait(struct abituguru_data
*data
, u8 state
)
233 int timeout
= ABIT_UGURU_WAIT_TIMEOUT
;
235 while (inb_p(data
->addr
+ ABIT_UGURU_DATA
) != state
) {
239 /* sleep a bit before our last few tries, see the comment on
240 this where ABIT_UGURU_WAIT_TIMEOUT_SLEEP is defined. */
241 if (timeout
<= ABIT_UGURU_WAIT_TIMEOUT_SLEEP
)
247 /* Put the uguru in ready for input state */
248 static int abituguru_ready(struct abituguru_data
*data
)
250 int timeout
= ABIT_UGURU_READY_TIMEOUT
;
252 if (data
->uguru_ready
)
255 /* Reset? / Prepare for next read/write cycle */
256 outb(0x00, data
->addr
+ ABIT_UGURU_DATA
);
258 /* Wait till the uguru is ready */
259 if (abituguru_wait(data
, ABIT_UGURU_STATUS_READY
)) {
261 "timeout exceeded waiting for ready state\n");
265 /* Cmd port MUST be read now and should contain 0xAC */
266 while (inb_p(data
->addr
+ ABIT_UGURU_CMD
) != 0xAC) {
270 "CMD reg does not hold 0xAC after ready command\n");
276 /* After this the ABIT_UGURU_DATA port should contain
277 ABIT_UGURU_STATUS_INPUT */
278 timeout
= ABIT_UGURU_READY_TIMEOUT
;
279 while (inb_p(data
->addr
+ ABIT_UGURU_DATA
) != ABIT_UGURU_STATUS_INPUT
) {
283 "state != more input after ready command\n");
289 data
->uguru_ready
= 1;
293 /* Send the bank and then sensor address to the uGuru for the next read/write
294 cycle. This function gets called as the first part of a read/write by
295 abituguru_read and abituguru_write. This function should never be
296 called by any other function. */
297 static int abituguru_send_address(struct abituguru_data
*data
,
298 u8 bank_addr
, u8 sensor_addr
, int retries
)
300 /* assume the caller does error handling itself if it has not requested
301 any retries, and thus be quiet. */
302 int report_errors
= retries
;
305 /* Make sure the uguru is ready and then send the bank address,
306 after this the uguru is no longer "ready". */
307 if (abituguru_ready(data
) != 0)
309 outb(bank_addr
, data
->addr
+ ABIT_UGURU_DATA
);
310 data
->uguru_ready
= 0;
312 /* Wait till the uguru is ABIT_UGURU_STATUS_INPUT state again
313 and send the sensor addr */
314 if (abituguru_wait(data
, ABIT_UGURU_STATUS_INPUT
)) {
316 ABIT_UGURU_DEBUG(3, "timeout exceeded "
317 "waiting for more input state, %d "
318 "tries remaining\n", retries
);
319 set_current_state(TASK_UNINTERRUPTIBLE
);
320 schedule_timeout(ABIT_UGURU_RETRY_DELAY
);
325 ABIT_UGURU_DEBUG(1, "timeout exceeded "
326 "waiting for more input state "
327 "(bank: %d)\n", (int)bank_addr
);
330 outb(sensor_addr
, data
->addr
+ ABIT_UGURU_CMD
);
335 /* Read count bytes from sensor sensor_addr in bank bank_addr and store the
336 result in buf, retry the send address part of the read retries times. */
337 static int abituguru_read(struct abituguru_data
*data
,
338 u8 bank_addr
, u8 sensor_addr
, u8
*buf
, int count
, int retries
)
342 /* Send the address */
343 i
= abituguru_send_address(data
, bank_addr
, sensor_addr
, retries
);
347 /* And read the data */
348 for (i
= 0; i
< count
; i
++) {
349 if (abituguru_wait(data
, ABIT_UGURU_STATUS_READ
)) {
350 ABIT_UGURU_DEBUG(retries
? 1 : 3,
351 "timeout exceeded waiting for "
352 "read state (bank: %d, sensor: %d)\n",
353 (int)bank_addr
, (int)sensor_addr
);
356 buf
[i
] = inb(data
->addr
+ ABIT_UGURU_CMD
);
359 /* Last put the chip back in ready state */
360 abituguru_ready(data
);
365 /* Write count bytes from buf to sensor sensor_addr in bank bank_addr, the send
366 address part of the write is always retried ABIT_UGURU_MAX_RETRIES times. */
367 static int abituguru_write(struct abituguru_data
*data
,
368 u8 bank_addr
, u8 sensor_addr
, u8
*buf
, int count
)
370 /* We use the ready timeout as we have to wait for 0xAC just like the
372 int i
, timeout
= ABIT_UGURU_READY_TIMEOUT
;
374 /* Send the address */
375 i
= abituguru_send_address(data
, bank_addr
, sensor_addr
,
376 ABIT_UGURU_MAX_RETRIES
);
380 /* And write the data */
381 for (i
= 0; i
< count
; i
++) {
382 if (abituguru_wait(data
, ABIT_UGURU_STATUS_WRITE
)) {
383 ABIT_UGURU_DEBUG(1, "timeout exceeded waiting for "
384 "write state (bank: %d, sensor: %d)\n",
385 (int)bank_addr
, (int)sensor_addr
);
388 outb(buf
[i
], data
->addr
+ ABIT_UGURU_CMD
);
391 /* Now we need to wait till the chip is ready to be read again,
392 so that we can read 0xAC as confirmation that our write has
394 if (abituguru_wait(data
, ABIT_UGURU_STATUS_READ
)) {
395 ABIT_UGURU_DEBUG(1, "timeout exceeded waiting for read state "
396 "after write (bank: %d, sensor: %d)\n", (int)bank_addr
,
401 /* Cmd port MUST be read now and should contain 0xAC */
402 while (inb_p(data
->addr
+ ABIT_UGURU_CMD
) != 0xAC) {
405 ABIT_UGURU_DEBUG(1, "CMD reg does not hold 0xAC after "
406 "write (bank: %d, sensor: %d)\n",
407 (int)bank_addr
, (int)sensor_addr
);
413 /* Last put the chip back in ready state */
414 abituguru_ready(data
);
419 /* Detect sensor type. Temp and Volt sensors are enabled with
420 different masks and will ignore enable masks not meant for them.
421 This enables us to test what kind of sensor we're dealing with.
422 By setting the alarm thresholds so that we will always get an
423 alarm for sensor type X and then enabling the sensor as sensor type
424 X, if we then get an alarm it is a sensor of type X. */
426 abituguru_detect_bank1_sensor_type(struct abituguru_data
*data
,
429 u8 val
, test_flag
, buf
[3];
430 int i
, ret
= -ENODEV
; /* error is the most common used retval :| */
432 /* If overriden by the user return the user selected type */
433 if (bank1_types
[sensor_addr
] >= ABIT_UGURU_IN_SENSOR
&&
434 bank1_types
[sensor_addr
] <= ABIT_UGURU_NC
) {
435 ABIT_UGURU_DEBUG(2, "assuming sensor type %d for bank1 sensor "
436 "%d because of \"bank1_types\" module param\n",
437 bank1_types
[sensor_addr
], (int)sensor_addr
);
438 return bank1_types
[sensor_addr
];
441 /* First read the sensor and the current settings */
442 if (abituguru_read(data
, ABIT_UGURU_SENSOR_BANK1
, sensor_addr
, &val
,
443 1, ABIT_UGURU_MAX_RETRIES
) != 1)
446 /* Test val is sane / usable for sensor type detection. */
447 if ((val
< 10u) || (val
> 250u)) {
448 pr_warn("bank1-sensor: %d reading (%d) too close to limits, "
449 "unable to determine sensor type, skipping sensor\n",
450 (int)sensor_addr
, (int)val
);
451 /* assume no sensor is there for sensors for which we can't
452 determine the sensor type because their reading is too close
453 to their limits, this usually means no sensor is there. */
454 return ABIT_UGURU_NC
;
457 ABIT_UGURU_DEBUG(2, "testing bank1 sensor %d\n", (int)sensor_addr
);
458 /* Volt sensor test, enable volt low alarm, set min value ridicously
459 high, or vica versa if the reading is very high. If its a volt
460 sensor this should always give us an alarm. */
462 buf
[0] = ABIT_UGURU_VOLT_LOW_ALARM_ENABLE
;
465 test_flag
= ABIT_UGURU_VOLT_LOW_ALARM_FLAG
;
467 buf
[0] = ABIT_UGURU_VOLT_HIGH_ALARM_ENABLE
;
470 test_flag
= ABIT_UGURU_VOLT_HIGH_ALARM_FLAG
;
473 if (abituguru_write(data
, ABIT_UGURU_SENSOR_BANK1
+ 2, sensor_addr
,
475 goto abituguru_detect_bank1_sensor_type_exit
;
476 /* Now we need 20 ms to give the uguru time to read the sensors
477 and raise a voltage alarm */
478 set_current_state(TASK_UNINTERRUPTIBLE
);
479 schedule_timeout(HZ
/50);
480 /* Check for alarm and check the alarm is a volt low alarm. */
481 if (abituguru_read(data
, ABIT_UGURU_ALARM_BANK
, 0, buf
, 3,
482 ABIT_UGURU_MAX_RETRIES
) != 3)
483 goto abituguru_detect_bank1_sensor_type_exit
;
484 if (buf
[sensor_addr
/8] & (0x01 << (sensor_addr
% 8))) {
485 if (abituguru_read(data
, ABIT_UGURU_SENSOR_BANK1
+ 1,
487 ABIT_UGURU_MAX_RETRIES
) != 3)
488 goto abituguru_detect_bank1_sensor_type_exit
;
489 if (buf
[0] & test_flag
) {
490 ABIT_UGURU_DEBUG(2, " found volt sensor\n");
491 ret
= ABIT_UGURU_IN_SENSOR
;
492 goto abituguru_detect_bank1_sensor_type_exit
;
494 ABIT_UGURU_DEBUG(2, " alarm raised during volt "
495 "sensor test, but volt range flag not set\n");
497 ABIT_UGURU_DEBUG(2, " alarm not raised during volt sensor "
500 /* Temp sensor test, enable sensor as a temp sensor, set beep value
501 ridicously low (but not too low, otherwise uguru ignores it).
502 If its a temp sensor this should always give us an alarm. */
503 buf
[0] = ABIT_UGURU_TEMP_HIGH_ALARM_ENABLE
;
506 if (abituguru_write(data
, ABIT_UGURU_SENSOR_BANK1
+ 2, sensor_addr
,
508 goto abituguru_detect_bank1_sensor_type_exit
;
509 /* Now we need 50 ms to give the uguru time to read the sensors
510 and raise a temp alarm */
511 set_current_state(TASK_UNINTERRUPTIBLE
);
512 schedule_timeout(HZ
/20);
513 /* Check for alarm and check the alarm is a temp high alarm. */
514 if (abituguru_read(data
, ABIT_UGURU_ALARM_BANK
, 0, buf
, 3,
515 ABIT_UGURU_MAX_RETRIES
) != 3)
516 goto abituguru_detect_bank1_sensor_type_exit
;
517 if (buf
[sensor_addr
/8] & (0x01 << (sensor_addr
% 8))) {
518 if (abituguru_read(data
, ABIT_UGURU_SENSOR_BANK1
+ 1,
520 ABIT_UGURU_MAX_RETRIES
) != 3)
521 goto abituguru_detect_bank1_sensor_type_exit
;
522 if (buf
[0] & ABIT_UGURU_TEMP_HIGH_ALARM_FLAG
) {
523 ABIT_UGURU_DEBUG(2, " found temp sensor\n");
524 ret
= ABIT_UGURU_TEMP_SENSOR
;
525 goto abituguru_detect_bank1_sensor_type_exit
;
527 ABIT_UGURU_DEBUG(2, " alarm raised during temp "
528 "sensor test, but temp high flag not set\n");
530 ABIT_UGURU_DEBUG(2, " alarm not raised during temp sensor "
534 abituguru_detect_bank1_sensor_type_exit
:
535 /* Restore original settings, failing here is really BAD, it has been
536 reported that some BIOS-es hang when entering the uGuru menu with
537 invalid settings present in the uGuru, so we try this 3 times. */
538 for (i
= 0; i
< 3; i
++)
539 if (abituguru_write(data
, ABIT_UGURU_SENSOR_BANK1
+ 2,
540 sensor_addr
, data
->bank1_settings
[sensor_addr
],
544 pr_err("Fatal error could not restore original settings. %s %s\n",
545 never_happen
, report_this
);
551 /* These functions try to find out how many sensors there are in bank2 and how
552 many pwms there are. The purpose of this is to make sure that we don't give
553 the user the possibility to change settings for non-existent sensors / pwm.
554 The uGuru will happily read / write whatever memory happens to be after the
555 memory storing the PWM settings when reading/writing to a PWM which is not
556 there. Notice even if we detect a PWM which doesn't exist we normally won't
557 write to it, unless the user tries to change the settings.
559 Although the uGuru allows reading (settings) from non existing bank2
560 sensors, my version of the uGuru does seem to stop writing to them, the
561 write function above aborts in this case with:
562 "CMD reg does not hold 0xAC after write"
564 Notice these 2 tests are non destructive iow read-only tests, otherwise
565 they would defeat their purpose. Although for the bank2_sensors detection a
566 read/write test would be feasible because of the reaction above, I've
567 however opted to stay on the safe side. */
568 static void __devinit
569 abituguru_detect_no_bank2_sensors(struct abituguru_data
*data
)
573 if (fan_sensors
> 0 && fan_sensors
<= ABIT_UGURU_MAX_BANK2_SENSORS
) {
574 data
->bank2_sensors
= fan_sensors
;
575 ABIT_UGURU_DEBUG(2, "assuming %d fan sensors because of "
576 "\"fan_sensors\" module param\n",
577 (int)data
->bank2_sensors
);
581 ABIT_UGURU_DEBUG(2, "detecting number of fan sensors\n");
582 for (i
= 0; i
< ABIT_UGURU_MAX_BANK2_SENSORS
; i
++) {
583 /* 0x89 are the known used bits:
584 -0x80 enable shutdown
587 All other bits should be 0, but on some motherboards
588 0x40 (bit 6) is also high for some of the fans?? */
589 if (data
->bank2_settings
[i
][0] & ~0xC9) {
590 ABIT_UGURU_DEBUG(2, " bank2 sensor %d does not seem "
591 "to be a fan sensor: settings[0] = %02X\n",
592 i
, (unsigned int)data
->bank2_settings
[i
][0]);
596 /* check if the threshold is within the allowed range */
597 if (data
->bank2_settings
[i
][1] <
598 abituguru_bank2_min_threshold
) {
599 ABIT_UGURU_DEBUG(2, " bank2 sensor %d does not seem "
600 "to be a fan sensor: the threshold (%d) is "
601 "below the minimum (%d)\n", i
,
602 (int)data
->bank2_settings
[i
][1],
603 (int)abituguru_bank2_min_threshold
);
606 if (data
->bank2_settings
[i
][1] >
607 abituguru_bank2_max_threshold
) {
608 ABIT_UGURU_DEBUG(2, " bank2 sensor %d does not seem "
609 "to be a fan sensor: the threshold (%d) is "
610 "above the maximum (%d)\n", i
,
611 (int)data
->bank2_settings
[i
][1],
612 (int)abituguru_bank2_max_threshold
);
617 data
->bank2_sensors
= i
;
618 ABIT_UGURU_DEBUG(2, " found: %d fan sensors\n",
619 (int)data
->bank2_sensors
);
622 static void __devinit
623 abituguru_detect_no_pwms(struct abituguru_data
*data
)
627 if (pwms
> 0 && pwms
<= ABIT_UGURU_MAX_PWMS
) {
629 ABIT_UGURU_DEBUG(2, "assuming %d PWM outputs because of "
630 "\"pwms\" module param\n", (int)data
->pwms
);
634 ABIT_UGURU_DEBUG(2, "detecting number of PWM outputs\n");
635 for (i
= 0; i
< ABIT_UGURU_MAX_PWMS
; i
++) {
636 /* 0x80 is the enable bit and the low
637 nibble is which temp sensor to use,
638 the other bits should be 0 */
639 if (data
->pwm_settings
[i
][0] & ~0x8F) {
640 ABIT_UGURU_DEBUG(2, " pwm channel %d does not seem "
641 "to be a pwm channel: settings[0] = %02X\n",
642 i
, (unsigned int)data
->pwm_settings
[i
][0]);
646 /* the low nibble must correspond to one of the temp sensors
648 for (j
= 0; j
< data
->bank1_sensors
[ABIT_UGURU_TEMP_SENSOR
];
650 if (data
->bank1_address
[ABIT_UGURU_TEMP_SENSOR
][j
] ==
651 (data
->pwm_settings
[i
][0] & 0x0F))
654 if (j
== data
->bank1_sensors
[ABIT_UGURU_TEMP_SENSOR
]) {
655 ABIT_UGURU_DEBUG(2, " pwm channel %d does not seem "
656 "to be a pwm channel: %d is not a valid temp "
657 "sensor address\n", i
,
658 data
->pwm_settings
[i
][0] & 0x0F);
662 /* check if all other settings are within the allowed range */
663 for (j
= 1; j
< 5; j
++) {
665 /* special case pwm1 min pwm% */
666 if ((i
== 0) && ((j
== 1) || (j
== 2)))
669 min
= abituguru_pwm_min
[j
];
670 if (data
->pwm_settings
[i
][j
] < min
) {
671 ABIT_UGURU_DEBUG(2, " pwm channel %d does "
672 "not seem to be a pwm channel: "
673 "setting %d (%d) is below the minimum "
674 "value (%d)\n", i
, j
,
675 (int)data
->pwm_settings
[i
][j
],
677 goto abituguru_detect_no_pwms_exit
;
679 if (data
->pwm_settings
[i
][j
] > abituguru_pwm_max
[j
]) {
680 ABIT_UGURU_DEBUG(2, " pwm channel %d does "
681 "not seem to be a pwm channel: "
682 "setting %d (%d) is above the maximum "
683 "value (%d)\n", i
, j
,
684 (int)data
->pwm_settings
[i
][j
],
685 (int)abituguru_pwm_max
[j
]);
686 goto abituguru_detect_no_pwms_exit
;
690 /* check that min temp < max temp and min pwm < max pwm */
691 if (data
->pwm_settings
[i
][1] >= data
->pwm_settings
[i
][2]) {
692 ABIT_UGURU_DEBUG(2, " pwm channel %d does not seem "
693 "to be a pwm channel: min pwm (%d) >= "
695 (int)data
->pwm_settings
[i
][1],
696 (int)data
->pwm_settings
[i
][2]);
699 if (data
->pwm_settings
[i
][3] >= data
->pwm_settings
[i
][4]) {
700 ABIT_UGURU_DEBUG(2, " pwm channel %d does not seem "
701 "to be a pwm channel: min temp (%d) >= "
702 "max temp (%d)\n", i
,
703 (int)data
->pwm_settings
[i
][3],
704 (int)data
->pwm_settings
[i
][4]);
709 abituguru_detect_no_pwms_exit
:
711 ABIT_UGURU_DEBUG(2, " found: %d PWM outputs\n", (int)data
->pwms
);
714 /* Following are the sysfs callback functions. These functions expect:
715 sensor_device_attribute_2->index: sensor address/offset in the bank
716 sensor_device_attribute_2->nr: register offset, bitmask or NA. */
717 static struct abituguru_data
*abituguru_update_device(struct device
*dev
);
719 static ssize_t
show_bank1_value(struct device
*dev
,
720 struct device_attribute
*devattr
, char *buf
)
722 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
723 struct abituguru_data
*data
= abituguru_update_device(dev
);
726 return sprintf(buf
, "%d\n", (data
->bank1_value
[attr
->index
] *
727 data
->bank1_max_value
[attr
->index
] + 128) / 255);
730 static ssize_t
show_bank1_setting(struct device
*dev
,
731 struct device_attribute
*devattr
, char *buf
)
733 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
734 struct abituguru_data
*data
= dev_get_drvdata(dev
);
735 return sprintf(buf
, "%d\n",
736 (data
->bank1_settings
[attr
->index
][attr
->nr
] *
737 data
->bank1_max_value
[attr
->index
] + 128) / 255);
740 static ssize_t
show_bank2_value(struct device
*dev
,
741 struct device_attribute
*devattr
, char *buf
)
743 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
744 struct abituguru_data
*data
= abituguru_update_device(dev
);
747 return sprintf(buf
, "%d\n", (data
->bank2_value
[attr
->index
] *
748 ABIT_UGURU_FAN_MAX
+ 128) / 255);
751 static ssize_t
show_bank2_setting(struct device
*dev
,
752 struct device_attribute
*devattr
, char *buf
)
754 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
755 struct abituguru_data
*data
= dev_get_drvdata(dev
);
756 return sprintf(buf
, "%d\n",
757 (data
->bank2_settings
[attr
->index
][attr
->nr
] *
758 ABIT_UGURU_FAN_MAX
+ 128) / 255);
761 static ssize_t
store_bank1_setting(struct device
*dev
, struct device_attribute
762 *devattr
, const char *buf
, size_t count
)
764 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
765 struct abituguru_data
*data
= dev_get_drvdata(dev
);
766 u8 val
= (simple_strtoul(buf
, NULL
, 10) * 255 +
767 data
->bank1_max_value
[attr
->index
]/2) /
768 data
->bank1_max_value
[attr
->index
];
771 mutex_lock(&data
->update_lock
);
772 if (data
->bank1_settings
[attr
->index
][attr
->nr
] != val
) {
773 u8 orig_val
= data
->bank1_settings
[attr
->index
][attr
->nr
];
774 data
->bank1_settings
[attr
->index
][attr
->nr
] = val
;
775 if (abituguru_write(data
, ABIT_UGURU_SENSOR_BANK1
+ 2,
776 attr
->index
, data
->bank1_settings
[attr
->index
],
778 data
->bank1_settings
[attr
->index
][attr
->nr
] = orig_val
;
782 mutex_unlock(&data
->update_lock
);
786 static ssize_t
store_bank2_setting(struct device
*dev
, struct device_attribute
787 *devattr
, const char *buf
, size_t count
)
789 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
790 struct abituguru_data
*data
= dev_get_drvdata(dev
);
791 u8 val
= (simple_strtoul(buf
, NULL
, 10)*255 + ABIT_UGURU_FAN_MAX
/2) /
795 /* this check can be done before taking the lock */
796 if ((val
< abituguru_bank2_min_threshold
) ||
797 (val
> abituguru_bank2_max_threshold
))
800 mutex_lock(&data
->update_lock
);
801 if (data
->bank2_settings
[attr
->index
][attr
->nr
] != val
) {
802 u8 orig_val
= data
->bank2_settings
[attr
->index
][attr
->nr
];
803 data
->bank2_settings
[attr
->index
][attr
->nr
] = val
;
804 if (abituguru_write(data
, ABIT_UGURU_SENSOR_BANK2
+ 2,
805 attr
->index
, data
->bank2_settings
[attr
->index
],
807 data
->bank2_settings
[attr
->index
][attr
->nr
] = orig_val
;
811 mutex_unlock(&data
->update_lock
);
815 static ssize_t
show_bank1_alarm(struct device
*dev
,
816 struct device_attribute
*devattr
, char *buf
)
818 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
819 struct abituguru_data
*data
= abituguru_update_device(dev
);
822 /* See if the alarm bit for this sensor is set, and if the
823 alarm matches the type of alarm we're looking for (for volt
824 it can be either low or high). The type is stored in a few
825 readonly bits in the settings part of the relevant sensor.
826 The bitmask of the type is passed to us in attr->nr. */
827 if ((data
->alarms
[attr
->index
/ 8] & (0x01 << (attr
->index
% 8))) &&
828 (data
->bank1_settings
[attr
->index
][0] & attr
->nr
))
829 return sprintf(buf
, "1\n");
831 return sprintf(buf
, "0\n");
834 static ssize_t
show_bank2_alarm(struct device
*dev
,
835 struct device_attribute
*devattr
, char *buf
)
837 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
838 struct abituguru_data
*data
= abituguru_update_device(dev
);
841 if (data
->alarms
[2] & (0x01 << attr
->index
))
842 return sprintf(buf
, "1\n");
844 return sprintf(buf
, "0\n");
847 static ssize_t
show_bank1_mask(struct device
*dev
,
848 struct device_attribute
*devattr
, char *buf
)
850 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
851 struct abituguru_data
*data
= dev_get_drvdata(dev
);
852 if (data
->bank1_settings
[attr
->index
][0] & attr
->nr
)
853 return sprintf(buf
, "1\n");
855 return sprintf(buf
, "0\n");
858 static ssize_t
show_bank2_mask(struct device
*dev
,
859 struct device_attribute
*devattr
, char *buf
)
861 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
862 struct abituguru_data
*data
= dev_get_drvdata(dev
);
863 if (data
->bank2_settings
[attr
->index
][0] & attr
->nr
)
864 return sprintf(buf
, "1\n");
866 return sprintf(buf
, "0\n");
869 static ssize_t
store_bank1_mask(struct device
*dev
,
870 struct device_attribute
*devattr
, const char *buf
, size_t count
)
872 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
873 struct abituguru_data
*data
= dev_get_drvdata(dev
);
874 int mask
= simple_strtoul(buf
, NULL
, 10);
878 mutex_lock(&data
->update_lock
);
879 orig_val
= data
->bank1_settings
[attr
->index
][0];
882 data
->bank1_settings
[attr
->index
][0] |= attr
->nr
;
884 data
->bank1_settings
[attr
->index
][0] &= ~attr
->nr
;
886 if ((data
->bank1_settings
[attr
->index
][0] != orig_val
) &&
887 (abituguru_write(data
,
888 ABIT_UGURU_SENSOR_BANK1
+ 2, attr
->index
,
889 data
->bank1_settings
[attr
->index
], 3) < 1)) {
890 data
->bank1_settings
[attr
->index
][0] = orig_val
;
893 mutex_unlock(&data
->update_lock
);
897 static ssize_t
store_bank2_mask(struct device
*dev
,
898 struct device_attribute
*devattr
, const char *buf
, size_t count
)
900 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
901 struct abituguru_data
*data
= dev_get_drvdata(dev
);
902 int mask
= simple_strtoul(buf
, NULL
, 10);
906 mutex_lock(&data
->update_lock
);
907 orig_val
= data
->bank2_settings
[attr
->index
][0];
910 data
->bank2_settings
[attr
->index
][0] |= attr
->nr
;
912 data
->bank2_settings
[attr
->index
][0] &= ~attr
->nr
;
914 if ((data
->bank2_settings
[attr
->index
][0] != orig_val
) &&
915 (abituguru_write(data
,
916 ABIT_UGURU_SENSOR_BANK2
+ 2, attr
->index
,
917 data
->bank2_settings
[attr
->index
], 2) < 1)) {
918 data
->bank2_settings
[attr
->index
][0] = orig_val
;
921 mutex_unlock(&data
->update_lock
);
925 /* Fan PWM (speed control) */
926 static ssize_t
show_pwm_setting(struct device
*dev
,
927 struct device_attribute
*devattr
, char *buf
)
929 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
930 struct abituguru_data
*data
= dev_get_drvdata(dev
);
931 return sprintf(buf
, "%d\n", data
->pwm_settings
[attr
->index
][attr
->nr
] *
932 abituguru_pwm_settings_multiplier
[attr
->nr
]);
935 static ssize_t
store_pwm_setting(struct device
*dev
, struct device_attribute
936 *devattr
, const char *buf
, size_t count
)
938 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
939 struct abituguru_data
*data
= dev_get_drvdata(dev
);
940 u8 min
, val
= (simple_strtoul(buf
, NULL
, 10) +
941 abituguru_pwm_settings_multiplier
[attr
->nr
]/2) /
942 abituguru_pwm_settings_multiplier
[attr
->nr
];
945 /* special case pwm1 min pwm% */
946 if ((attr
->index
== 0) && ((attr
->nr
== 1) || (attr
->nr
== 2)))
949 min
= abituguru_pwm_min
[attr
->nr
];
951 /* this check can be done before taking the lock */
952 if ((val
< min
) || (val
> abituguru_pwm_max
[attr
->nr
]))
955 mutex_lock(&data
->update_lock
);
956 /* this check needs to be done after taking the lock */
957 if ((attr
->nr
& 1) &&
958 (val
>= data
->pwm_settings
[attr
->index
][attr
->nr
+ 1]))
960 else if (!(attr
->nr
& 1) &&
961 (val
<= data
->pwm_settings
[attr
->index
][attr
->nr
- 1]))
963 else if (data
->pwm_settings
[attr
->index
][attr
->nr
] != val
) {
964 u8 orig_val
= data
->pwm_settings
[attr
->index
][attr
->nr
];
965 data
->pwm_settings
[attr
->index
][attr
->nr
] = val
;
966 if (abituguru_write(data
, ABIT_UGURU_FAN_PWM
+ 1,
967 attr
->index
, data
->pwm_settings
[attr
->index
],
969 data
->pwm_settings
[attr
->index
][attr
->nr
] =
974 mutex_unlock(&data
->update_lock
);
978 static ssize_t
show_pwm_sensor(struct device
*dev
,
979 struct device_attribute
*devattr
, char *buf
)
981 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
982 struct abituguru_data
*data
= dev_get_drvdata(dev
);
984 /* We need to walk to the temp sensor addresses to find what
985 the userspace id of the configured temp sensor is. */
986 for (i
= 0; i
< data
->bank1_sensors
[ABIT_UGURU_TEMP_SENSOR
]; i
++)
987 if (data
->bank1_address
[ABIT_UGURU_TEMP_SENSOR
][i
] ==
988 (data
->pwm_settings
[attr
->index
][0] & 0x0F))
989 return sprintf(buf
, "%d\n", i
+1);
994 static ssize_t
store_pwm_sensor(struct device
*dev
, struct device_attribute
995 *devattr
, const char *buf
, size_t count
)
997 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
998 struct abituguru_data
*data
= dev_get_drvdata(dev
);
999 unsigned long val
= simple_strtoul(buf
, NULL
, 10) - 1;
1000 ssize_t ret
= count
;
1002 mutex_lock(&data
->update_lock
);
1003 if (val
< data
->bank1_sensors
[ABIT_UGURU_TEMP_SENSOR
]) {
1004 u8 orig_val
= data
->pwm_settings
[attr
->index
][0];
1005 u8 address
= data
->bank1_address
[ABIT_UGURU_TEMP_SENSOR
][val
];
1006 data
->pwm_settings
[attr
->index
][0] &= 0xF0;
1007 data
->pwm_settings
[attr
->index
][0] |= address
;
1008 if (data
->pwm_settings
[attr
->index
][0] != orig_val
) {
1009 if (abituguru_write(data
, ABIT_UGURU_FAN_PWM
+ 1,
1011 data
->pwm_settings
[attr
->index
],
1013 data
->pwm_settings
[attr
->index
][0] = orig_val
;
1020 mutex_unlock(&data
->update_lock
);
1024 static ssize_t
show_pwm_enable(struct device
*dev
,
1025 struct device_attribute
*devattr
, char *buf
)
1027 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
1028 struct abituguru_data
*data
= dev_get_drvdata(dev
);
1030 if (data
->pwm_settings
[attr
->index
][0] & ABIT_UGURU_FAN_PWM_ENABLE
)
1032 return sprintf(buf
, "%d\n", res
);
1035 static ssize_t
store_pwm_enable(struct device
*dev
, struct device_attribute
1036 *devattr
, const char *buf
, size_t count
)
1038 struct sensor_device_attribute_2
*attr
= to_sensor_dev_attr_2(devattr
);
1039 struct abituguru_data
*data
= dev_get_drvdata(dev
);
1040 u8 orig_val
, user_val
= simple_strtoul(buf
, NULL
, 10);
1041 ssize_t ret
= count
;
1043 mutex_lock(&data
->update_lock
);
1044 orig_val
= data
->pwm_settings
[attr
->index
][0];
1047 data
->pwm_settings
[attr
->index
][0] &=
1048 ~ABIT_UGURU_FAN_PWM_ENABLE
;
1051 data
->pwm_settings
[attr
->index
][0] |=
1052 ABIT_UGURU_FAN_PWM_ENABLE
;
1057 if ((data
->pwm_settings
[attr
->index
][0] != orig_val
) &&
1058 (abituguru_write(data
, ABIT_UGURU_FAN_PWM
+ 1,
1059 attr
->index
, data
->pwm_settings
[attr
->index
],
1061 data
->pwm_settings
[attr
->index
][0] = orig_val
;
1064 mutex_unlock(&data
->update_lock
);
1068 static ssize_t
show_name(struct device
*dev
,
1069 struct device_attribute
*devattr
, char *buf
)
1071 return sprintf(buf
, "%s\n", ABIT_UGURU_NAME
);
1074 /* Sysfs attr templates, the real entries are generated automatically. */
1076 struct sensor_device_attribute_2 abituguru_sysfs_bank1_templ
[2][9] = {
1078 SENSOR_ATTR_2(in
%d_input
, 0444, show_bank1_value
, NULL
, 0, 0),
1079 SENSOR_ATTR_2(in
%d_min
, 0644, show_bank1_setting
,
1080 store_bank1_setting
, 1, 0),
1081 SENSOR_ATTR_2(in
%d_min_alarm
, 0444, show_bank1_alarm
, NULL
,
1082 ABIT_UGURU_VOLT_LOW_ALARM_FLAG
, 0),
1083 SENSOR_ATTR_2(in
%d_max
, 0644, show_bank1_setting
,
1084 store_bank1_setting
, 2, 0),
1085 SENSOR_ATTR_2(in
%d_max_alarm
, 0444, show_bank1_alarm
, NULL
,
1086 ABIT_UGURU_VOLT_HIGH_ALARM_FLAG
, 0),
1087 SENSOR_ATTR_2(in
%d_beep
, 0644, show_bank1_mask
,
1088 store_bank1_mask
, ABIT_UGURU_BEEP_ENABLE
, 0),
1089 SENSOR_ATTR_2(in
%d_shutdown
, 0644, show_bank1_mask
,
1090 store_bank1_mask
, ABIT_UGURU_SHUTDOWN_ENABLE
, 0),
1091 SENSOR_ATTR_2(in
%d_min_alarm_enable
, 0644, show_bank1_mask
,
1092 store_bank1_mask
, ABIT_UGURU_VOLT_LOW_ALARM_ENABLE
, 0),
1093 SENSOR_ATTR_2(in
%d_max_alarm_enable
, 0644, show_bank1_mask
,
1094 store_bank1_mask
, ABIT_UGURU_VOLT_HIGH_ALARM_ENABLE
, 0),
1096 SENSOR_ATTR_2(temp
%d_input
, 0444, show_bank1_value
, NULL
, 0, 0),
1097 SENSOR_ATTR_2(temp
%d_alarm
, 0444, show_bank1_alarm
, NULL
,
1098 ABIT_UGURU_TEMP_HIGH_ALARM_FLAG
, 0),
1099 SENSOR_ATTR_2(temp
%d_max
, 0644, show_bank1_setting
,
1100 store_bank1_setting
, 1, 0),
1101 SENSOR_ATTR_2(temp
%d_crit
, 0644, show_bank1_setting
,
1102 store_bank1_setting
, 2, 0),
1103 SENSOR_ATTR_2(temp
%d_beep
, 0644, show_bank1_mask
,
1104 store_bank1_mask
, ABIT_UGURU_BEEP_ENABLE
, 0),
1105 SENSOR_ATTR_2(temp
%d_shutdown
, 0644, show_bank1_mask
,
1106 store_bank1_mask
, ABIT_UGURU_SHUTDOWN_ENABLE
, 0),
1107 SENSOR_ATTR_2(temp
%d_alarm_enable
, 0644, show_bank1_mask
,
1108 store_bank1_mask
, ABIT_UGURU_TEMP_HIGH_ALARM_ENABLE
, 0),
1112 static const struct sensor_device_attribute_2 abituguru_sysfs_fan_templ
[6] = {
1113 SENSOR_ATTR_2(fan
%d_input
, 0444, show_bank2_value
, NULL
, 0, 0),
1114 SENSOR_ATTR_2(fan
%d_alarm
, 0444, show_bank2_alarm
, NULL
, 0, 0),
1115 SENSOR_ATTR_2(fan
%d_min
, 0644, show_bank2_setting
,
1116 store_bank2_setting
, 1, 0),
1117 SENSOR_ATTR_2(fan
%d_beep
, 0644, show_bank2_mask
,
1118 store_bank2_mask
, ABIT_UGURU_BEEP_ENABLE
, 0),
1119 SENSOR_ATTR_2(fan
%d_shutdown
, 0644, show_bank2_mask
,
1120 store_bank2_mask
, ABIT_UGURU_SHUTDOWN_ENABLE
, 0),
1121 SENSOR_ATTR_2(fan
%d_alarm_enable
, 0644, show_bank2_mask
,
1122 store_bank2_mask
, ABIT_UGURU_FAN_LOW_ALARM_ENABLE
, 0),
1125 static const struct sensor_device_attribute_2 abituguru_sysfs_pwm_templ
[6] = {
1126 SENSOR_ATTR_2(pwm
%d_enable
, 0644, show_pwm_enable
,
1127 store_pwm_enable
, 0, 0),
1128 SENSOR_ATTR_2(pwm
%d_auto_channels_temp
, 0644, show_pwm_sensor
,
1129 store_pwm_sensor
, 0, 0),
1130 SENSOR_ATTR_2(pwm
%d_auto_point1_pwm
, 0644, show_pwm_setting
,
1131 store_pwm_setting
, 1, 0),
1132 SENSOR_ATTR_2(pwm
%d_auto_point2_pwm
, 0644, show_pwm_setting
,
1133 store_pwm_setting
, 2, 0),
1134 SENSOR_ATTR_2(pwm
%d_auto_point1_temp
, 0644, show_pwm_setting
,
1135 store_pwm_setting
, 3, 0),
1136 SENSOR_ATTR_2(pwm
%d_auto_point2_temp
, 0644, show_pwm_setting
,
1137 store_pwm_setting
, 4, 0),
1140 static struct sensor_device_attribute_2 abituguru_sysfs_attr
[] = {
1141 SENSOR_ATTR_2(name
, 0444, show_name
, NULL
, 0, 0),
1144 static int __devinit
abituguru_probe(struct platform_device
*pdev
)
1146 struct abituguru_data
*data
;
1147 int i
, j
, used
, sysfs_names_free
, sysfs_attr_i
, res
= -ENODEV
;
1148 char *sysfs_filename
;
1150 /* El weirdo probe order, to keep the sysfs order identical to the
1151 BIOS and window-appliction listing order. */
1152 const u8 probe_order
[ABIT_UGURU_MAX_BANK1_SENSORS
] = {
1153 0x00, 0x01, 0x03, 0x04, 0x0A, 0x08, 0x0E, 0x02,
1154 0x09, 0x06, 0x05, 0x0B, 0x0F, 0x0D, 0x07, 0x0C };
1156 if (!(data
= kzalloc(sizeof(struct abituguru_data
), GFP_KERNEL
)))
1159 data
->addr
= platform_get_resource(pdev
, IORESOURCE_IO
, 0)->start
;
1160 mutex_init(&data
->update_lock
);
1161 platform_set_drvdata(pdev
, data
);
1163 /* See if the uGuru is ready */
1164 if (inb_p(data
->addr
+ ABIT_UGURU_DATA
) == ABIT_UGURU_STATUS_INPUT
)
1165 data
->uguru_ready
= 1;
1167 /* Completely read the uGuru this has 2 purposes:
1168 - testread / see if one really is there.
1169 - make an in memory copy of all the uguru settings for future use. */
1170 if (abituguru_read(data
, ABIT_UGURU_ALARM_BANK
, 0,
1171 data
->alarms
, 3, ABIT_UGURU_MAX_RETRIES
) != 3)
1172 goto abituguru_probe_error
;
1174 for (i
= 0; i
< ABIT_UGURU_MAX_BANK1_SENSORS
; i
++) {
1175 if (abituguru_read(data
, ABIT_UGURU_SENSOR_BANK1
, i
,
1176 &data
->bank1_value
[i
], 1,
1177 ABIT_UGURU_MAX_RETRIES
) != 1)
1178 goto abituguru_probe_error
;
1179 if (abituguru_read(data
, ABIT_UGURU_SENSOR_BANK1
+1, i
,
1180 data
->bank1_settings
[i
], 3,
1181 ABIT_UGURU_MAX_RETRIES
) != 3)
1182 goto abituguru_probe_error
;
1184 /* Note: We don't know how many bank2 sensors / pwms there really are,
1185 but in order to "detect" this we need to read the maximum amount
1186 anyways. If we read sensors/pwms not there we'll just read crap
1187 this can't hurt. We need the detection because we don't want
1188 unwanted writes, which will hurt! */
1189 for (i
= 0; i
< ABIT_UGURU_MAX_BANK2_SENSORS
; i
++) {
1190 if (abituguru_read(data
, ABIT_UGURU_SENSOR_BANK2
, i
,
1191 &data
->bank2_value
[i
], 1,
1192 ABIT_UGURU_MAX_RETRIES
) != 1)
1193 goto abituguru_probe_error
;
1194 if (abituguru_read(data
, ABIT_UGURU_SENSOR_BANK2
+1, i
,
1195 data
->bank2_settings
[i
], 2,
1196 ABIT_UGURU_MAX_RETRIES
) != 2)
1197 goto abituguru_probe_error
;
1199 for (i
= 0; i
< ABIT_UGURU_MAX_PWMS
; i
++) {
1200 if (abituguru_read(data
, ABIT_UGURU_FAN_PWM
, i
,
1201 data
->pwm_settings
[i
], 5,
1202 ABIT_UGURU_MAX_RETRIES
) != 5)
1203 goto abituguru_probe_error
;
1205 data
->last_updated
= jiffies
;
1207 /* Detect sensor types and fill the sysfs attr for bank1 */
1209 sysfs_filename
= data
->sysfs_names
;
1210 sysfs_names_free
= ABITUGURU_SYSFS_NAMES_LENGTH
;
1211 for (i
= 0; i
< ABIT_UGURU_MAX_BANK1_SENSORS
; i
++) {
1212 res
= abituguru_detect_bank1_sensor_type(data
, probe_order
[i
]);
1214 goto abituguru_probe_error
;
1215 if (res
== ABIT_UGURU_NC
)
1218 /* res 1 (temp) sensors have 7 sysfs entries, 0 (in) 9 */
1219 for (j
= 0; j
< (res
? 7 : 9); j
++) {
1220 used
= snprintf(sysfs_filename
, sysfs_names_free
,
1221 abituguru_sysfs_bank1_templ
[res
][j
].dev_attr
.
1222 attr
.name
, data
->bank1_sensors
[res
] + res
)
1224 data
->sysfs_attr
[sysfs_attr_i
] =
1225 abituguru_sysfs_bank1_templ
[res
][j
];
1226 data
->sysfs_attr
[sysfs_attr_i
].dev_attr
.attr
.name
=
1228 data
->sysfs_attr
[sysfs_attr_i
].index
= probe_order
[i
];
1229 sysfs_filename
+= used
;
1230 sysfs_names_free
-= used
;
1233 data
->bank1_max_value
[probe_order
[i
]] =
1234 abituguru_bank1_max_value
[res
];
1235 data
->bank1_address
[res
][data
->bank1_sensors
[res
]] =
1237 data
->bank1_sensors
[res
]++;
1239 /* Detect number of sensors and fill the sysfs attr for bank2 (fans) */
1240 abituguru_detect_no_bank2_sensors(data
);
1241 for (i
= 0; i
< data
->bank2_sensors
; i
++) {
1242 for (j
= 0; j
< ARRAY_SIZE(abituguru_sysfs_fan_templ
); j
++) {
1243 used
= snprintf(sysfs_filename
, sysfs_names_free
,
1244 abituguru_sysfs_fan_templ
[j
].dev_attr
.attr
.name
,
1246 data
->sysfs_attr
[sysfs_attr_i
] =
1247 abituguru_sysfs_fan_templ
[j
];
1248 data
->sysfs_attr
[sysfs_attr_i
].dev_attr
.attr
.name
=
1250 data
->sysfs_attr
[sysfs_attr_i
].index
= i
;
1251 sysfs_filename
+= used
;
1252 sysfs_names_free
-= used
;
1256 /* Detect number of sensors and fill the sysfs attr for pwms */
1257 abituguru_detect_no_pwms(data
);
1258 for (i
= 0; i
< data
->pwms
; i
++) {
1259 for (j
= 0; j
< ARRAY_SIZE(abituguru_sysfs_pwm_templ
); j
++) {
1260 used
= snprintf(sysfs_filename
, sysfs_names_free
,
1261 abituguru_sysfs_pwm_templ
[j
].dev_attr
.attr
.name
,
1263 data
->sysfs_attr
[sysfs_attr_i
] =
1264 abituguru_sysfs_pwm_templ
[j
];
1265 data
->sysfs_attr
[sysfs_attr_i
].dev_attr
.attr
.name
=
1267 data
->sysfs_attr
[sysfs_attr_i
].index
= i
;
1268 sysfs_filename
+= used
;
1269 sysfs_names_free
-= used
;
1273 /* Fail safe check, this should never happen! */
1274 if (sysfs_names_free
< 0) {
1275 pr_err("Fatal error ran out of space for sysfs attr names. %s %s",
1276 never_happen
, report_this
);
1277 res
= -ENAMETOOLONG
;
1278 goto abituguru_probe_error
;
1280 pr_info("found Abit uGuru\n");
1282 /* Register sysfs hooks */
1283 for (i
= 0; i
< sysfs_attr_i
; i
++)
1284 if (device_create_file(&pdev
->dev
,
1285 &data
->sysfs_attr
[i
].dev_attr
))
1286 goto abituguru_probe_error
;
1287 for (i
= 0; i
< ARRAY_SIZE(abituguru_sysfs_attr
); i
++)
1288 if (device_create_file(&pdev
->dev
,
1289 &abituguru_sysfs_attr
[i
].dev_attr
))
1290 goto abituguru_probe_error
;
1292 data
->hwmon_dev
= hwmon_device_register(&pdev
->dev
);
1293 if (!IS_ERR(data
->hwmon_dev
))
1294 return 0; /* success */
1296 res
= PTR_ERR(data
->hwmon_dev
);
1297 abituguru_probe_error
:
1298 for (i
= 0; data
->sysfs_attr
[i
].dev_attr
.attr
.name
; i
++)
1299 device_remove_file(&pdev
->dev
, &data
->sysfs_attr
[i
].dev_attr
);
1300 for (i
= 0; i
< ARRAY_SIZE(abituguru_sysfs_attr
); i
++)
1301 device_remove_file(&pdev
->dev
,
1302 &abituguru_sysfs_attr
[i
].dev_attr
);
1303 platform_set_drvdata(pdev
, NULL
);
1308 static int __devexit
abituguru_remove(struct platform_device
*pdev
)
1311 struct abituguru_data
*data
= platform_get_drvdata(pdev
);
1313 hwmon_device_unregister(data
->hwmon_dev
);
1314 for (i
= 0; data
->sysfs_attr
[i
].dev_attr
.attr
.name
; i
++)
1315 device_remove_file(&pdev
->dev
, &data
->sysfs_attr
[i
].dev_attr
);
1316 for (i
= 0; i
< ARRAY_SIZE(abituguru_sysfs_attr
); i
++)
1317 device_remove_file(&pdev
->dev
,
1318 &abituguru_sysfs_attr
[i
].dev_attr
);
1319 platform_set_drvdata(pdev
, NULL
);
1325 static struct abituguru_data
*abituguru_update_device(struct device
*dev
)
1328 struct abituguru_data
*data
= dev_get_drvdata(dev
);
1329 /* fake a complete successful read if no update necessary. */
1332 mutex_lock(&data
->update_lock
);
1333 if (time_after(jiffies
, data
->last_updated
+ HZ
)) {
1335 if ((err
= abituguru_read(data
, ABIT_UGURU_ALARM_BANK
, 0,
1336 data
->alarms
, 3, 0)) != 3)
1338 for (i
= 0; i
< ABIT_UGURU_MAX_BANK1_SENSORS
; i
++) {
1339 if ((err
= abituguru_read(data
,
1340 ABIT_UGURU_SENSOR_BANK1
, i
,
1341 &data
->bank1_value
[i
], 1, 0)) != 1)
1343 if ((err
= abituguru_read(data
,
1344 ABIT_UGURU_SENSOR_BANK1
+ 1, i
,
1345 data
->bank1_settings
[i
], 3, 0)) != 3)
1348 for (i
= 0; i
< data
->bank2_sensors
; i
++)
1349 if ((err
= abituguru_read(data
,
1350 ABIT_UGURU_SENSOR_BANK2
, i
,
1351 &data
->bank2_value
[i
], 1, 0)) != 1)
1355 data
->update_timeouts
= 0;
1357 /* handle timeout condition */
1358 if (!success
&& (err
== -EBUSY
|| err
>= 0)) {
1359 /* No overflow please */
1360 if (data
->update_timeouts
< 255u)
1361 data
->update_timeouts
++;
1362 if (data
->update_timeouts
<= ABIT_UGURU_MAX_TIMEOUTS
) {
1363 ABIT_UGURU_DEBUG(3, "timeout exceeded, will "
1364 "try again next update\n");
1365 /* Just a timeout, fake a successful read */
1368 ABIT_UGURU_DEBUG(1, "timeout exceeded %d "
1369 "times waiting for more input state\n",
1370 (int)data
->update_timeouts
);
1372 /* On success set last_updated */
1374 data
->last_updated
= jiffies
;
1376 mutex_unlock(&data
->update_lock
);
1385 static int abituguru_suspend(struct platform_device
*pdev
, pm_message_t state
)
1387 struct abituguru_data
*data
= platform_get_drvdata(pdev
);
1388 /* make sure all communications with the uguru are done and no new
1390 mutex_lock(&data
->update_lock
);
1394 static int abituguru_resume(struct platform_device
*pdev
)
1396 struct abituguru_data
*data
= platform_get_drvdata(pdev
);
1397 /* See if the uGuru is still ready */
1398 if (inb_p(data
->addr
+ ABIT_UGURU_DATA
) != ABIT_UGURU_STATUS_INPUT
)
1399 data
->uguru_ready
= 0;
1400 mutex_unlock(&data
->update_lock
);
1404 #define abituguru_suspend NULL
1405 #define abituguru_resume NULL
1406 #endif /* CONFIG_PM */
1408 static struct platform_driver abituguru_driver
= {
1410 .owner
= THIS_MODULE
,
1411 .name
= ABIT_UGURU_NAME
,
1413 .probe
= abituguru_probe
,
1414 .remove
= __devexit_p(abituguru_remove
),
1415 .suspend
= abituguru_suspend
,
1416 .resume
= abituguru_resume
,
1419 static int __init
abituguru_detect(void)
1421 /* See if there is an uguru there. After a reboot uGuru will hold 0x00
1422 at DATA and 0xAC, when this driver has already been loaded once
1423 DATA will hold 0x08. For most uGuru's CMD will hold 0xAC in either
1424 scenario but some will hold 0x00.
1425 Some uGuru's initially hold 0x09 at DATA and will only hold 0x08
1426 after reading CMD first, so CMD must be read first! */
1427 u8 cmd_val
= inb_p(ABIT_UGURU_BASE
+ ABIT_UGURU_CMD
);
1428 u8 data_val
= inb_p(ABIT_UGURU_BASE
+ ABIT_UGURU_DATA
);
1429 if (((data_val
== 0x00) || (data_val
== 0x08)) &&
1430 ((cmd_val
== 0x00) || (cmd_val
== 0xAC)))
1431 return ABIT_UGURU_BASE
;
1433 ABIT_UGURU_DEBUG(2, "no Abit uGuru found, data = 0x%02X, cmd = "
1434 "0x%02X\n", (unsigned int)data_val
, (unsigned int)cmd_val
);
1437 pr_info("Assuming Abit uGuru is present because of \"force\" parameter\n");
1438 return ABIT_UGURU_BASE
;
1441 /* No uGuru found */
1445 static struct platform_device
*abituguru_pdev
;
1447 static int __init
abituguru_init(void)
1450 struct resource res
= { .flags
= IORESOURCE_IO
};
1451 const char *board_vendor
= dmi_get_system_info(DMI_BOARD_VENDOR
);
1453 /* safety check, refuse to load on non Abit motherboards */
1454 if (!force
&& (!board_vendor
||
1455 strcmp(board_vendor
, "http://www.abit.com.tw/")))
1458 address
= abituguru_detect();
1462 err
= platform_driver_register(&abituguru_driver
);
1466 abituguru_pdev
= platform_device_alloc(ABIT_UGURU_NAME
, address
);
1467 if (!abituguru_pdev
) {
1468 pr_err("Device allocation failed\n");
1470 goto exit_driver_unregister
;
1473 res
.start
= address
;
1474 res
.end
= address
+ ABIT_UGURU_REGION_LENGTH
- 1;
1475 res
.name
= ABIT_UGURU_NAME
;
1477 err
= platform_device_add_resources(abituguru_pdev
, &res
, 1);
1479 pr_err("Device resource addition failed (%d)\n", err
);
1480 goto exit_device_put
;
1483 err
= platform_device_add(abituguru_pdev
);
1485 pr_err("Device addition failed (%d)\n", err
);
1486 goto exit_device_put
;
1492 platform_device_put(abituguru_pdev
);
1493 exit_driver_unregister
:
1494 platform_driver_unregister(&abituguru_driver
);
1499 static void __exit
abituguru_exit(void)
1501 platform_device_unregister(abituguru_pdev
);
1502 platform_driver_unregister(&abituguru_driver
);
1505 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
1506 MODULE_DESCRIPTION("Abit uGuru Sensor device");
1507 MODULE_LICENSE("GPL");
1509 module_init(abituguru_init
);
1510 module_exit(abituguru_exit
);