AuxXxilium/linux_dsm_epyc7002
1
0
Fork 0
mirror of https://github.com/AuxXxilium/linux_dsm_epyc7002.git synced 2024-11-24 12:40:53 +07:00
Code Issues Actions Packages Projects Releases Wiki Activity

hwmon: (abituguru) Fix checkpatch issues

Browse Source 
Fixed:
ERROR: do not use assignment in if condition
ERROR: else should follow close brace '}'
ERROR: switch and case should be at the same indent
WARNING: simple_strtoul is obsolete, use kstrtoul instead

Modify multi-line comments to follow Documentation/CodingStyle.

Not fixed:
WARNING: msleep < 20ms can sleep for up to 20ms

Cc: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Guenter Roeck <linux@roeck-us.net>
This commit is contained in:
Guenter Roeck 2012-01-14 12:30:52 -08:00 committed by Guenter Roeck
parent 8969e84d95
commit 1bd385d679
1 changed files with 359 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

582
drivers/hwmon/abituguru.c
View File

@ -1,25 +1,25 @@
/* /*
abituguru.c Copyright (c) 2005-2006 Hans de Goede <hdegoede@redhat.com> * abituguru.c Copyright (c) 2005-2006 Hans de Goede <hdegoede@redhat.com>
*
This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
(at your option) any later version. * (at your option) any later version.
*
This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. * GNU General Public License for more details.
*
You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
/* /*
This driver supports the sensor part of the first and second revision of * This driver supports the sensor part of the first and second revision of
the custom Abit uGuru chip found on Abit uGuru motherboards. Note: because * the custom Abit uGuru chip found on Abit uGuru motherboards. Note: because
of lack of specs the CPU/RAM voltage & frequency control is not supported! * of lack of specs the CPU/RAM voltage & frequency control is not supported!
*/ */
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
@ -44,8 +44,10 @@
#define ABIT_UGURU_SENSOR_BANK2 0x26 /* fans */ #define ABIT_UGURU_SENSOR_BANK2 0x26 /* fans */
/* max nr of sensors in bank1, a bank1 sensor can be in, temp or nc */ /* max nr of sensors in bank1, a bank1 sensor can be in, temp or nc */
#define ABIT_UGURU_MAX_BANK1_SENSORS 16 #define ABIT_UGURU_MAX_BANK1_SENSORS 16
/* Warning if you increase one of the 2 MAX defines below to 10 or higher you /*
should adjust the belonging _NAMES_LENGTH macro for the 2 digit number! */ * Warning if you increase one of the 2 MAX defines below to 10 or higher you
* should adjust the belonging _NAMES_LENGTH macro for the 2 digit number!
*/
/* max nr of sensors in bank2, currently mb's with max 6 fans are known */ /* max nr of sensors in bank2, currently mb's with max 6 fans are known */
#define ABIT_UGURU_MAX_BANK2_SENSORS 6 #define ABIT_UGURU_MAX_BANK2_SENSORS 6
/* max nr of pwm outputs, currently mb's with max 5 pwm outputs are known */ /* max nr of pwm outputs, currently mb's with max 5 pwm outputs are known */
@ -70,16 +72,22 @@
#define ABIT_UGURU_IN_SENSOR 0 #define ABIT_UGURU_IN_SENSOR 0
#define ABIT_UGURU_TEMP_SENSOR 1 #define ABIT_UGURU_TEMP_SENSOR 1
#define ABIT_UGURU_NC 2 #define ABIT_UGURU_NC 2
/* In many cases we need to wait for the uGuru to reach a certain status, most /*
of the time it will reach this status within 30 - 90 ISA reads, and thus we * In many cases we need to wait for the uGuru to reach a certain status, most
can best busy wait. This define gives the total amount of reads to try. */ * of the time it will reach this status within 30 - 90 ISA reads, and thus we
* can best busy wait. This define gives the total amount of reads to try.
*/
#define ABIT_UGURU_WAIT_TIMEOUT 125 #define ABIT_UGURU_WAIT_TIMEOUT 125
/* However sometimes older versions of the uGuru seem to be distracted and they /*
do not respond for a long time. To handle this we sleep before each of the * However sometimes older versions of the uGuru seem to be distracted and they
last ABIT_UGURU_WAIT_TIMEOUT_SLEEP tries. */ * do not respond for a long time. To handle this we sleep before each of the
* last ABIT_UGURU_WAIT_TIMEOUT_SLEEP tries.
*/
#define ABIT_UGURU_WAIT_TIMEOUT_SLEEP 5 #define ABIT_UGURU_WAIT_TIMEOUT_SLEEP 5
/* Normally all expected status in abituguru_ready, are reported after the /*
first read, but sometimes not and we need to poll. */ * Normally all expected status in abituguru_ready, are reported after the
* first read, but sometimes not and we need to poll.
*/
#define ABIT_UGURU_READY_TIMEOUT 5 #define ABIT_UGURU_READY_TIMEOUT 5
/* Maximum 3 retries on timedout reads/writes, delay 200 ms before retrying */ /* Maximum 3 retries on timedout reads/writes, delay 200 ms before retrying */
#define ABIT_UGURU_MAX_RETRIES 3 #define ABIT_UGURU_MAX_RETRIES 3
@ -92,17 +100,25 @@
if (level <= verbose) \ if (level <= verbose) \
printk(KERN_DEBUG ABIT_UGURU_NAME ": " format , ## arg) printk(KERN_DEBUG ABIT_UGURU_NAME ": " format , ## arg)
/* Macros to help calculate the sysfs_names array length */ /* Macros to help calculate the sysfs_names array length */
/* sum of strlen of: in??_input\0, in??_{min,max}\0, in??_{min,max}_alarm\0, /*
in??_{min,max}_alarm_enable\0, in??_beep\0, in??_shutdown\0 */ * sum of strlen of: in??_input\0, in??_{min,max}\0, in??_{min,max}_alarm\0,
* in??_{min,max}_alarm_enable\0, in??_beep\0, in??_shutdown\0
*/
#define ABITUGURU_IN_NAMES_LENGTH (11 + 2 * 9 + 2 * 15 + 2 * 22 + 10 + 14) #define ABITUGURU_IN_NAMES_LENGTH (11 + 2 * 9 + 2 * 15 + 2 * 22 + 10 + 14)
/* sum of strlen of: temp??_input\0, temp??_max\0, temp??_crit\0, /*
temp??_alarm\0, temp??_alarm_enable\0, temp??_beep\0, temp??_shutdown\0 */ * sum of strlen of: temp??_input\0, temp??_max\0, temp??_crit\0,
* temp??_alarm\0, temp??_alarm_enable\0, temp??_beep\0, temp??_shutdown\0
*/
#define ABITUGURU_TEMP_NAMES_LENGTH (13 + 11 + 12 + 13 + 20 + 12 + 16) #define ABITUGURU_TEMP_NAMES_LENGTH (13 + 11 + 12 + 13 + 20 + 12 + 16)
/* sum of strlen of: fan?_input\0, fan?_min\0, fan?_alarm\0, /*
fan?_alarm_enable\0, fan?_beep\0, fan?_shutdown\0 */ * sum of strlen of: fan?_input\0, fan?_min\0, fan?_alarm\0,
* fan?_alarm_enable\0, fan?_beep\0, fan?_shutdown\0
*/
#define ABITUGURU_FAN_NAMES_LENGTH (11 + 9 + 11 + 18 + 10 + 14) #define ABITUGURU_FAN_NAMES_LENGTH (11 + 9 + 11 + 18 + 10 + 14)
/* sum of strlen of: pwm?_enable\0, pwm?_auto_channels_temp\0, /*
pwm?_auto_point{1,2}_pwm\0, pwm?_auto_point{1,2}_temp\0 */ * sum of strlen of: pwm?_enable\0, pwm?_auto_channels_temp\0,
* pwm?_auto_point{1,2}_pwm\0, pwm?_auto_point{1,2}_temp\0
*/
#define ABITUGURU_PWM_NAMES_LENGTH (12 + 24 + 2 * 21 + 2 * 22) #define ABITUGURU_PWM_NAMES_LENGTH (12 + 24 + 2 * 21 + 2 * 22)
/* IN_NAMES_LENGTH > TEMP_NAMES_LENGTH so assume all bank1 sensors are in */ /* IN_NAMES_LENGTH > TEMP_NAMES_LENGTH so assume all bank1 sensors are in */
#define ABITUGURU_SYSFS_NAMES_LENGTH ( \ #define ABITUGURU_SYSFS_NAMES_LENGTH ( \
@ -110,10 +126,12 @@
ABIT_UGURU_MAX_BANK2_SENSORS * ABITUGURU_FAN_NAMES_LENGTH + \ ABIT_UGURU_MAX_BANK2_SENSORS * ABITUGURU_FAN_NAMES_LENGTH + \
ABIT_UGURU_MAX_PWMS * ABITUGURU_PWM_NAMES_LENGTH) ABIT_UGURU_MAX_PWMS * ABITUGURU_PWM_NAMES_LENGTH)
/* All the macros below are named identical to the oguru and oguru2 programs /*
reverse engineered by Olle Sandberg, hence the names might not be 100% * All the macros below are named identical to the oguru and oguru2 programs
logical. I could come up with better names, but I prefer keeping the names * reverse engineered by Olle Sandberg, hence the names might not be 100%
identical so that this driver can be compared with his work more easily. */ * logical. I could come up with better names, but I prefer keeping the names
* identical so that this driver can be compared with his work more easily.
*/
/* Two i/o-ports are used by uGuru */ /* Two i/o-ports are used by uGuru */
#define ABIT_UGURU_BASE 0x00E0 #define ABIT_UGURU_BASE 0x00E0
/* Used to tell uGuru what to read and to read the actual data */ /* Used to tell uGuru what to read and to read the actual data */
@ -130,16 +148,22 @@
/* Constants */ /* Constants */
/* in (Volt) sensors go up to 3494 mV, temp to 255000 millidegrees Celsius */ /* in (Volt) sensors go up to 3494 mV, temp to 255000 millidegrees Celsius */
static const int abituguru_bank1_max_value[2] = { 3494, 255000 }; static const int abituguru_bank1_max_value[2] = { 3494, 255000 };
/* Min / Max allowed values for sensor2 (fan) alarm threshold, these values /*
correspond to 300-3000 RPM */ * Min / Max allowed values for sensor2 (fan) alarm threshold, these values
* correspond to 300-3000 RPM
*/
static const u8 abituguru_bank2_min_threshold = 5; static const u8 abituguru_bank2_min_threshold = 5;
static const u8 abituguru_bank2_max_threshold = 50; static const u8 abituguru_bank2_max_threshold = 50;
/* Register 0 is a bitfield, 1 and 2 are pwm settings (255 = 100%), 3 and 4 /*
are temperature trip points. */ * Register 0 is a bitfield, 1 and 2 are pwm settings (255 = 100%), 3 and 4
* are temperature trip points.
*/
static const int abituguru_pwm_settings_multiplier[5] = { 0, 1, 1, 1000, 1000 }; static const int abituguru_pwm_settings_multiplier[5] = { 0, 1, 1, 1000, 1000 };
/* Min / Max allowed values for pwm_settings. Note: pwm1 (CPU fan) is a /*
special case the minium allowed pwm% setting for this is 30% (77) on * Min / Max allowed values for pwm_settings. Note: pwm1 (CPU fan) is a
some MB's this special case is handled in the code! */ * special case the minium allowed pwm% setting for this is 30% (77) on
* some MB's this special case is handled in the code!
*/
static const u8 abituguru_pwm_min[5] = { 0, 170, 170, 25, 25 }; static const u8 abituguru_pwm_min[5] = { 0, 170, 170, 25, 25 };
static const u8 abituguru_pwm_max[5] = { 0, 255, 255, 75, 75 }; static const u8 abituguru_pwm_max[5] = { 0, 255, 255, 75, 75 };
@ -175,23 +199,29 @@ MODULE_PARM_DESC(verbose, "How verbose should the driver be? (0-3):\n"
" 3 + retryable error reporting"); " 3 + retryable error reporting");
/* For the Abit uGuru, we need to keep some data in memory. /*
The structure is dynamically allocated, at the same time when a new * For the Abit uGuru, we need to keep some data in memory.
abituguru device is allocated. */ * The structure is dynamically allocated, at the same time when a new
* abituguru device is allocated.
*/
struct abituguru_data { struct abituguru_data {
struct device *hwmon_dev; /* hwmon registered device */ struct device *hwmon_dev; /* hwmon registered device */
struct mutex update_lock; /* protect access to data and uGuru */ struct mutex update_lock; /* protect access to data and uGuru */
unsigned long last_updated; /* In jiffies */ unsigned long last_updated; /* In jiffies */
unsigned short addr; /* uguru base address */ unsigned short addr; /* uguru base address */
char uguru_ready; /* is the uguru in ready state? */ char uguru_ready; /* is the uguru in ready state? */
unsigned char update_timeouts; /* number of update timeouts since last unsigned char update_timeouts; /*
successful update */ * number of update timeouts since last
* successful update
*/
/* The sysfs attr and their names are generated automatically, for bank1 /*
we cannot use a predefined array because we don't know beforehand * The sysfs attr and their names are generated automatically, for bank1
of a sensor is a volt or a temp sensor, for bank2 and the pwms its * we cannot use a predefined array because we don't know beforehand
easier todo things the same way. For in sensors we have 9 (temp 7) * of a sensor is a volt or a temp sensor, for bank2 and the pwms its
sysfs entries per sensor, for bank2 and pwms 6. */ * easier todo things the same way. For in sensors we have 9 (temp 7)
* sysfs entries per sensor, for bank2 and pwms 6.
*/
struct sensor_device_attribute_2 sysfs_attr[ struct sensor_device_attribute_2 sysfs_attr[
ABIT_UGURU_MAX_BANK1_SENSORS * 9 + ABIT_UGURU_MAX_BANK1_SENSORS * 9 +
ABIT_UGURU_MAX_BANK2_SENSORS * 6 + ABIT_UGURU_MAX_PWMS * 6]; ABIT_UGURU_MAX_BANK2_SENSORS * 6 + ABIT_UGURU_MAX_PWMS * 6];
@ -203,11 +233,15 @@ struct abituguru_data {
u8 bank1_sensors[2]; u8 bank1_sensors[2];
u8 bank1_address[2][ABIT_UGURU_MAX_BANK1_SENSORS]; u8 bank1_address[2][ABIT_UGURU_MAX_BANK1_SENSORS];
u8 bank1_value[ABIT_UGURU_MAX_BANK1_SENSORS]; u8 bank1_value[ABIT_UGURU_MAX_BANK1_SENSORS];
/* This array holds 3 entries per sensor for the bank 1 sensor settings /*
(flags, min, max for voltage / flags, warn, shutdown for temp). */ * This array holds 3 entries per sensor for the bank 1 sensor settings
* (flags, min, max for voltage / flags, warn, shutdown for temp).
*/
u8 bank1_settings[ABIT_UGURU_MAX_BANK1_SENSORS][3]; u8 bank1_settings[ABIT_UGURU_MAX_BANK1_SENSORS][3];
/* Maximum value for each sensor used for scaling in mV/millidegrees /*
Celsius. */ * Maximum value for each sensor used for scaling in mV/millidegrees
* Celsius.
*/
int bank1_max_value[ABIT_UGURU_MAX_BANK1_SENSORS]; int bank1_max_value[ABIT_UGURU_MAX_BANK1_SENSORS];
/* Bank 2 data, ABIT_UGURU_MAX_BANK2_SENSORS entries for bank2 */ /* Bank 2 data, ABIT_UGURU_MAX_BANK2_SENSORS entries for bank2 */
@ -236,8 +270,10 @@ static int abituguru_wait(struct abituguru_data *data, u8 state)
timeout--; timeout--;
if (timeout == 0) if (timeout == 0)
return -EBUSY; return -EBUSY;
/* sleep a bit before our last few tries, see the comment on /*
this where ABIT_UGURU_WAIT_TIMEOUT_SLEEP is defined. */ * sleep a bit before our last few tries, see the comment on
* this where ABIT_UGURU_WAIT_TIMEOUT_SLEEP is defined.
*/
if (timeout <= ABIT_UGURU_WAIT_TIMEOUT_SLEEP) if (timeout <= ABIT_UGURU_WAIT_TIMEOUT_SLEEP)
msleep(0); msleep(0);
} }
@ -273,8 +309,10 @@ static int abituguru_ready(struct abituguru_data *data)
msleep(0); msleep(0);
} }
/* After this the ABIT_UGURU_DATA port should contain /*
ABIT_UGURU_STATUS_INPUT */ * After this the ABIT_UGURU_DATA port should contain
* ABIT_UGURU_STATUS_INPUT
*/
timeout = ABIT_UGURU_READY_TIMEOUT; timeout = ABIT_UGURU_READY_TIMEOUT;
while (inb_p(data->addr + ABIT_UGURU_DATA) != ABIT_UGURU_STATUS_INPUT) { while (inb_p(data->addr + ABIT_UGURU_DATA) != ABIT_UGURU_STATUS_INPUT) {
timeout--; timeout--;
@ -290,27 +328,35 @@ static int abituguru_ready(struct abituguru_data *data)
return 0; return 0;
} }
/* Send the bank and then sensor address to the uGuru for the next read/write /*
cycle. This function gets called as the first part of a read/write by * Send the bank and then sensor address to the uGuru for the next read/write
abituguru_read and abituguru_write. This function should never be * cycle. This function gets called as the first part of a read/write by
called by any other function. */ * abituguru_read and abituguru_write. This function should never be
* called by any other function.
*/
static int abituguru_send_address(struct abituguru_data *data, static int abituguru_send_address(struct abituguru_data *data,
u8 bank_addr, u8 sensor_addr, int retries) u8 bank_addr, u8 sensor_addr, int retries)
{ {
/* assume the caller does error handling itself if it has not requested /*
any retries, and thus be quiet. */ * assume the caller does error handling itself if it has not requested
* any retries, and thus be quiet.
*/
int report_errors = retries; int report_errors = retries;
for (;;) { for (;;) {
/* Make sure the uguru is ready and then send the bank address, /*
after this the uguru is no longer "ready". */ * Make sure the uguru is ready and then send the bank address,
* after this the uguru is no longer "ready".
*/
if (abituguru_ready(data) != 0) if (abituguru_ready(data) != 0)
return -EIO; return -EIO;
outb(bank_addr, data->addr + ABIT_UGURU_DATA); outb(bank_addr, data->addr + ABIT_UGURU_DATA);
data->uguru_ready = 0; data->uguru_ready = 0;
/* Wait till the uguru is ABIT_UGURU_STATUS_INPUT state again /*
and send the sensor addr */ * Wait till the uguru is ABIT_UGURU_STATUS_INPUT state again
* and send the sensor addr
*/
if (abituguru_wait(data, ABIT_UGURU_STATUS_INPUT)) { if (abituguru_wait(data, ABIT_UGURU_STATUS_INPUT)) {
if (retries) { if (retries) {
ABIT_UGURU_DEBUG(3, "timeout exceeded " ABIT_UGURU_DEBUG(3, "timeout exceeded "
@ -332,8 +378,10 @@ static int abituguru_send_address(struct abituguru_data *data,
} }
} }
/* Read count bytes from sensor sensor_addr in bank bank_addr and store the /*
result in buf, retry the send address part of the read retries times. */ * Read count bytes from sensor sensor_addr in bank bank_addr and store the
* result in buf, retry the send address part of the read retries times.
*/
static int abituguru_read(struct abituguru_data *data, static int abituguru_read(struct abituguru_data *data,
u8 bank_addr, u8 sensor_addr, u8 *buf, int count, int retries) u8 bank_addr, u8 sensor_addr, u8 *buf, int count, int retries)
{ {
@ -362,13 +410,17 @@ static int abituguru_read(struct abituguru_data *data,
return i; return i;
} }
/* Write count bytes from buf to sensor sensor_addr in bank bank_addr, the send /*
address part of the write is always retried ABIT_UGURU_MAX_RETRIES times. */ * Write count bytes from buf to sensor sensor_addr in bank bank_addr, the send
* address part of the write is always retried ABIT_UGURU_MAX_RETRIES times.
*/
static int abituguru_write(struct abituguru_data *data, static int abituguru_write(struct abituguru_data *data,
u8 bank_addr, u8 sensor_addr, u8 *buf, int count) u8 bank_addr, u8 sensor_addr, u8 *buf, int count)
{ {
/* We use the ready timeout as we have to wait for 0xAC just like the /*
ready function */ * We use the ready timeout as we have to wait for 0xAC just like the
* ready function
*/
int i, timeout = ABIT_UGURU_READY_TIMEOUT; int i, timeout = ABIT_UGURU_READY_TIMEOUT;
/* Send the address */ /* Send the address */
@ -388,9 +440,11 @@ static int abituguru_write(struct abituguru_data *data,
outb(buf[i], data->addr + ABIT_UGURU_CMD); outb(buf[i], data->addr + ABIT_UGURU_CMD);
} }
/* Now we need to wait till the chip is ready to be read again, /*
so that we can read 0xAC as confirmation that our write has * Now we need to wait till the chip is ready to be read again,
succeeded. */ * so that we can read 0xAC as confirmation that our write has
* succeeded.
*/
if (abituguru_wait(data, ABIT_UGURU_STATUS_READ)) { if (abituguru_wait(data, ABIT_UGURU_STATUS_READ)) {
ABIT_UGURU_DEBUG(1, "timeout exceeded waiting for read state " ABIT_UGURU_DEBUG(1, "timeout exceeded waiting for read state "
"after write (bank: %d, sensor: %d)\n", (int)bank_addr, "after write (bank: %d, sensor: %d)\n", (int)bank_addr,
@ -416,12 +470,14 @@ static int abituguru_write(struct abituguru_data *data,
return i; return i;
} }
/* Detect sensor type. Temp and Volt sensors are enabled with /*
different masks and will ignore enable masks not meant for them. * Detect sensor type. Temp and Volt sensors are enabled with
This enables us to test what kind of sensor we're dealing with. * different masks and will ignore enable masks not meant for them.
By setting the alarm thresholds so that we will always get an * This enables us to test what kind of sensor we're dealing with.
alarm for sensor type X and then enabling the sensor as sensor type * By setting the alarm thresholds so that we will always get an
X, if we then get an alarm it is a sensor of type X. */ * alarm for sensor type X and then enabling the sensor as sensor type
* X, if we then get an alarm it is a sensor of type X.
*/
static int __devinit static int __devinit
abituguru_detect_bank1_sensor_type(struct abituguru_data *data, abituguru_detect_bank1_sensor_type(struct abituguru_data *data,
u8 sensor_addr) u8 sensor_addr)
@ -448,16 +504,20 @@ abituguru_detect_bank1_sensor_type(struct abituguru_data *data,
pr_warn("bank1-sensor: %d reading (%d) too close to limits, " pr_warn("bank1-sensor: %d reading (%d) too close to limits, "
"unable to determine sensor type, skipping sensor\n", "unable to determine sensor type, skipping sensor\n",
(int)sensor_addr, (int)val); (int)sensor_addr, (int)val);
/* assume no sensor is there for sensors for which we can't /*
determine the sensor type because their reading is too close * assume no sensor is there for sensors for which we can't
to their limits, this usually means no sensor is there. */ * determine the sensor type because their reading is too close
* to their limits, this usually means no sensor is there.
*/
return ABIT_UGURU_NC; return ABIT_UGURU_NC;
} }
ABIT_UGURU_DEBUG(2, "testing bank1 sensor %d\n", (int)sensor_addr); ABIT_UGURU_DEBUG(2, "testing bank1 sensor %d\n", (int)sensor_addr);
/* Volt sensor test, enable volt low alarm, set min value ridicously /*
high, or vica versa if the reading is very high. If its a volt * Volt sensor test, enable volt low alarm, set min value ridicously
sensor this should always give us an alarm. */ * high, or vica versa if the reading is very high. If its a volt
* sensor this should always give us an alarm.
*/
if (val <= 240u) { if (val <= 240u) {
buf[0] = ABIT_UGURU_VOLT_LOW_ALARM_ENABLE; buf[0] = ABIT_UGURU_VOLT_LOW_ALARM_ENABLE;
buf[1] = 245; buf[1] = 245;
@ -473,8 +533,10 @@ abituguru_detect_bank1_sensor_type(struct abituguru_data *data,
if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2, sensor_addr, if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2, sensor_addr,
buf, 3) != 3) buf, 3) != 3)
goto abituguru_detect_bank1_sensor_type_exit; goto abituguru_detect_bank1_sensor_type_exit;
/* Now we need 20 ms to give the uguru time to read the sensors /*
and raise a voltage alarm */ * Now we need 20 ms to give the uguru time to read the sensors
* and raise a voltage alarm
*/
set_current_state(TASK_UNINTERRUPTIBLE); set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout(HZ/50); schedule_timeout(HZ/50);
/* Check for alarm and check the alarm is a volt low alarm. */ /* Check for alarm and check the alarm is a volt low alarm. */
@ -497,17 +559,21 @@ abituguru_detect_bank1_sensor_type(struct abituguru_data *data,
ABIT_UGURU_DEBUG(2, " alarm not raised during volt sensor " ABIT_UGURU_DEBUG(2, " alarm not raised during volt sensor "
"test\n"); "test\n");
/* Temp sensor test, enable sensor as a temp sensor, set beep value /*
ridicously low (but not too low, otherwise uguru ignores it). * Temp sensor test, enable sensor as a temp sensor, set beep value
If its a temp sensor this should always give us an alarm. */ * ridicously low (but not too low, otherwise uguru ignores it).
* If its a temp sensor this should always give us an alarm.
*/
buf[0] = ABIT_UGURU_TEMP_HIGH_ALARM_ENABLE; buf[0] = ABIT_UGURU_TEMP_HIGH_ALARM_ENABLE;
buf[1] = 5; buf[1] = 5;
buf[2] = 10; buf[2] = 10;
if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2, sensor_addr, if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2, sensor_addr,
buf, 3) != 3) buf, 3) != 3)
goto abituguru_detect_bank1_sensor_type_exit; goto abituguru_detect_bank1_sensor_type_exit;
/* Now we need 50 ms to give the uguru time to read the sensors /*
and raise a temp alarm */ * Now we need 50 ms to give the uguru time to read the sensors
* and raise a temp alarm
*/
set_current_state(TASK_UNINTERRUPTIBLE); set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout(HZ/20); schedule_timeout(HZ/20);
/* Check for alarm and check the alarm is a temp high alarm. */ /* Check for alarm and check the alarm is a temp high alarm. */
@ -532,9 +598,11 @@ abituguru_detect_bank1_sensor_type(struct abituguru_data *data,
ret = ABIT_UGURU_NC; ret = ABIT_UGURU_NC;
abituguru_detect_bank1_sensor_type_exit: abituguru_detect_bank1_sensor_type_exit:
/* Restore original settings, failing here is really BAD, it has been /*
reported that some BIOS-es hang when entering the uGuru menu with * Restore original settings, failing here is really BAD, it has been
invalid settings present in the uGuru, so we try this 3 times. */ * reported that some BIOS-es hang when entering the uGuru menu with
* invalid settings present in the uGuru, so we try this 3 times.
*/
for (i = 0; i < 3; i++) for (i = 0; i < 3; i++)
if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2, if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2,
sensor_addr, data->bank1_settings[sensor_addr], sensor_addr, data->bank1_settings[sensor_addr],
@ -548,23 +616,25 @@ abituguru_detect_bank1_sensor_type(struct abituguru_data *data,
return ret; return ret;
} }
/* These functions try to find out how many sensors there are in bank2 and how /*
many pwms there are. The purpose of this is to make sure that we don't give * These functions try to find out how many sensors there are in bank2 and how
the user the possibility to change settings for non-existent sensors / pwm. * many pwms there are. The purpose of this is to make sure that we don't give
The uGuru will happily read / write whatever memory happens to be after the * the user the possibility to change settings for non-existent sensors / pwm.
memory storing the PWM settings when reading/writing to a PWM which is not * The uGuru will happily read / write whatever memory happens to be after the
there. Notice even if we detect a PWM which doesn't exist we normally won't * memory storing the PWM settings when reading/writing to a PWM which is not
write to it, unless the user tries to change the settings. * there. Notice even if we detect a PWM which doesn't exist we normally won't
* write to it, unless the user tries to change the settings.
Although the uGuru allows reading (settings) from non existing bank2 *
sensors, my version of the uGuru does seem to stop writing to them, the * Although the uGuru allows reading (settings) from non existing bank2
write function above aborts in this case with: * sensors, my version of the uGuru does seem to stop writing to them, the
"CMD reg does not hold 0xAC after write" * write function above aborts in this case with:
* "CMD reg does not hold 0xAC after write"
Notice these 2 tests are non destructive iow read-only tests, otherwise *
they would defeat their purpose. Although for the bank2_sensors detection a * Notice these 2 tests are non destructive iow read-only tests, otherwise
read/write test would be feasible because of the reaction above, I've * they would defeat their purpose. Although for the bank2_sensors detection a
however opted to stay on the safe side. */ * read/write test would be feasible because of the reaction above, I've
* however opted to stay on the safe side.
*/
static void __devinit static void __devinit
abituguru_detect_no_bank2_sensors(struct abituguru_data *data) abituguru_detect_no_bank2_sensors(struct abituguru_data *data)
{ {
@ -580,12 +650,14 @@ abituguru_detect_no_bank2_sensors(struct abituguru_data *data)
ABIT_UGURU_DEBUG(2, "detecting number of fan sensors\n"); ABIT_UGURU_DEBUG(2, "detecting number of fan sensors\n");
for (i = 0; i < ABIT_UGURU_MAX_BANK2_SENSORS; i++) { for (i = 0; i < ABIT_UGURU_MAX_BANK2_SENSORS; i++) {
/* 0x89 are the known used bits: /*
-0x80 enable shutdown * 0x89 are the known used bits:
-0x08 enable beep * -0x80 enable shutdown
-0x01 enable alarm * -0x08 enable beep
All other bits should be 0, but on some motherboards * -0x01 enable alarm
0x40 (bit 6) is also high for some of the fans?? */ * All other bits should be 0, but on some motherboards
* 0x40 (bit 6) is also high for some of the fans??
*/
if (data->bank2_settings[i][0] & ~0xC9) { if (data->bank2_settings[i][0] & ~0xC9) {
ABIT_UGURU_DEBUG(2, " bank2 sensor %d does not seem " ABIT_UGURU_DEBUG(2, " bank2 sensor %d does not seem "
"to be a fan sensor: settings[0] = %02X\n", "to be a fan sensor: settings[0] = %02X\n",
@ -633,9 +705,11 @@ abituguru_detect_no_pwms(struct abituguru_data *data)
ABIT_UGURU_DEBUG(2, "detecting number of PWM outputs\n"); ABIT_UGURU_DEBUG(2, "detecting number of PWM outputs\n");
for (i = 0; i < ABIT_UGURU_MAX_PWMS; i++) { for (i = 0; i < ABIT_UGURU_MAX_PWMS; i++) {
/* 0x80 is the enable bit and the low /*
nibble is which temp sensor to use, * 0x80 is the enable bit and the low
the other bits should be 0 */ * nibble is which temp sensor to use,
* the other bits should be 0
*/
if (data->pwm_settings[i][0] & ~0x8F) { if (data->pwm_settings[i][0] & ~0x8F) {
ABIT_UGURU_DEBUG(2, " pwm channel %d does not seem " ABIT_UGURU_DEBUG(2, " pwm channel %d does not seem "
"to be a pwm channel: settings[0] = %02X\n", "to be a pwm channel: settings[0] = %02X\n",
@ -643,8 +717,10 @@ abituguru_detect_no_pwms(struct abituguru_data *data)
break; break;
} }
/* the low nibble must correspond to one of the temp sensors /*
we've found */ * the low nibble must correspond to one of the temp sensors
* we've found
*/
for (j = 0; j < data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR]; for (j = 0; j < data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR];
j++) { j++) {
if (data->bank1_address[ABIT_UGURU_TEMP_SENSOR][j] == if (data->bank1_address[ABIT_UGURU_TEMP_SENSOR][j] ==
@ -711,9 +787,11 @@ abituguru_detect_no_pwms(struct abituguru_data *data)
ABIT_UGURU_DEBUG(2, " found: %d PWM outputs\n", (int)data->pwms); ABIT_UGURU_DEBUG(2, " found: %d PWM outputs\n", (int)data->pwms);
} }
/* Following are the sysfs callback functions. These functions expect: /*
sensor_device_attribute_2->index: sensor address/offset in the bank * Following are the sysfs callback functions. These functions expect:
sensor_device_attribute_2->nr: register offset, bitmask or NA. */ * sensor_device_attribute_2->index: sensor address/offset in the bank
* sensor_device_attribute_2->nr: register offset, bitmask or NA.
*/
static struct abituguru_data *abituguru_update_device(struct device *dev); static struct abituguru_data *abituguru_update_device(struct device *dev);
static ssize_t show_bank1_value(struct device *dev, static ssize_t show_bank1_value(struct device *dev,
@ -763,10 +841,18 @@ static ssize_t store_bank1_setting(struct device *dev, struct device_attribute
{ {
struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
struct abituguru_data *data = dev_get_drvdata(dev); struct abituguru_data *data = dev_get_drvdata(dev);
u8 val = (simple_strtoul(buf, NULL, 10) * 255 + unsigned long val;
data->bank1_max_value[attr->index]/2) / ssize_t ret;
ret = kstrtoul(buf, 10, &val);
if (ret)
return ret;
ret = count;
val = (val * 255 + data->bank1_max_value[attr->index] / 2) /
data->bank1_max_value[attr->index]; data->bank1_max_value[attr->index];
ssize_t ret = count; if (val > 255)
return -EINVAL;
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
if (data->bank1_settings[attr->index][attr->nr] != val) { if (data->bank1_settings[attr->index][attr->nr] != val) {
@ -788,13 +874,19 @@ static ssize_t store_bank2_setting(struct device *dev, struct device_attribute
{ {
struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
struct abituguru_data *data = dev_get_drvdata(dev); struct abituguru_data *data = dev_get_drvdata(dev);
u8 val = (simple_strtoul(buf, NULL, 10)*255 + ABIT_UGURU_FAN_MAX/2) / unsigned long val;
ABIT_UGURU_FAN_MAX; ssize_t ret;
ssize_t ret = count;
ret = kstrtoul(buf, 10, &val);
if (ret)
return ret;
ret = count;
val = (val * 255 + ABIT_UGURU_FAN_MAX / 2) / ABIT_UGURU_FAN_MAX;
/* this check can be done before taking the lock */ /* this check can be done before taking the lock */
if ((val < abituguru_bank2_min_threshold) || if (val < abituguru_bank2_min_threshold ||
(val > abituguru_bank2_max_threshold)) val > abituguru_bank2_max_threshold)
return -EINVAL; return -EINVAL;
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
@ -819,11 +911,13 @@ static ssize_t show_bank1_alarm(struct device *dev,
struct abituguru_data *data = abituguru_update_device(dev); struct abituguru_data *data = abituguru_update_device(dev);
if (!data) if (!data)
return -EIO; return -EIO;
/* See if the alarm bit for this sensor is set, and if the /*
alarm matches the type of alarm we're looking for (for volt * See if the alarm bit for this sensor is set, and if the
it can be either low or high). The type is stored in a few * alarm matches the type of alarm we're looking for (for volt
readonly bits in the settings part of the relevant sensor. * it can be either low or high). The type is stored in a few
The bitmask of the type is passed to us in attr->nr. */ * readonly bits in the settings part of the relevant sensor.
* The bitmask of the type is passed to us in attr->nr.
*/
if ((data->alarms[attr->index / 8] & (0x01 << (attr->index % 8))) && if ((data->alarms[attr->index / 8] & (0x01 << (attr->index % 8))) &&
(data->bank1_settings[attr->index][0] & attr->nr)) (data->bank1_settings[attr->index][0] & attr->nr))
return sprintf(buf, "1\n"); return sprintf(buf, "1\n");
@ -871,10 +965,15 @@ static ssize_t store_bank1_mask(struct device *dev,
{ {
struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
struct abituguru_data *data = dev_get_drvdata(dev); struct abituguru_data *data = dev_get_drvdata(dev);
int mask = simple_strtoul(buf, NULL, 10); ssize_t ret;
ssize_t ret = count;
u8 orig_val; u8 orig_val;
unsigned long mask;
ret = kstrtoul(buf, 10, &mask);
if (ret)
return ret;
ret = count;
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
orig_val = data->bank1_settings[attr->index][0]; orig_val = data->bank1_settings[attr->index][0];
@ -899,10 +998,15 @@ static ssize_t store_bank2_mask(struct device *dev,
{ {
struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
struct abituguru_data *data = dev_get_drvdata(dev); struct abituguru_data *data = dev_get_drvdata(dev);
int mask = simple_strtoul(buf, NULL, 10); ssize_t ret;
ssize_t ret = count;
u8 orig_val; u8 orig_val;
unsigned long mask;
ret = kstrtoul(buf, 10, &mask);
if (ret)
return ret;
ret = count;
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
orig_val = data->bank2_settings[attr->index][0]; orig_val = data->bank2_settings[attr->index][0];
@ -937,10 +1041,17 @@ static ssize_t store_pwm_setting(struct device *dev, struct device_attribute
{ {
struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
struct abituguru_data *data = dev_get_drvdata(dev); struct abituguru_data *data = dev_get_drvdata(dev);
u8 min, val = (simple_strtoul(buf, NULL, 10) + u8 min;
abituguru_pwm_settings_multiplier[attr->nr]/2) / unsigned long val;
abituguru_pwm_settings_multiplier[attr->nr]; ssize_t ret;
ssize_t ret = count;
ret = kstrtoul(buf, 10, &val);
if (ret)
return ret;
ret = count;
val = (val + abituguru_pwm_settings_multiplier[attr->nr] / 2) /
abituguru_pwm_settings_multiplier[attr->nr];
/* special case pwm1 min pwm% */ /* special case pwm1 min pwm% */
if ((attr->index == 0) && ((attr->nr == 1) || (attr->nr == 2))) if ((attr->index == 0) && ((attr->nr == 1) || (attr->nr == 2)))
@ -949,7 +1060,7 @@ static ssize_t store_pwm_setting(struct device *dev, struct device_attribute
min = abituguru_pwm_min[attr->nr]; min = abituguru_pwm_min[attr->nr];
/* this check can be done before taking the lock */ /* this check can be done before taking the lock */
if ((val < min) || (val > abituguru_pwm_max[attr->nr])) if (val < min || val > abituguru_pwm_max[attr->nr])
return -EINVAL; return -EINVAL;
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
@ -981,8 +1092,10 @@ static ssize_t show_pwm_sensor(struct device *dev,
struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
struct abituguru_data *data = dev_get_drvdata(dev); struct abituguru_data *data = dev_get_drvdata(dev);
int i; int i;
/* We need to walk to the temp sensor addresses to find what /*
the userspace id of the configured temp sensor is. */ * We need to walk to the temp sensor addresses to find what
* the userspace id of the configured temp sensor is.
*/
for (i = 0; i < data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR]; i++) for (i = 0; i < data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR]; i++)
if (data->bank1_address[ABIT_UGURU_TEMP_SENSOR][i] == if (data->bank1_address[ABIT_UGURU_TEMP_SENSOR][i] ==
(data->pwm_settings[attr->index][0] & 0x0F)) (data->pwm_settings[attr->index][0] & 0x0F))
@ -996,27 +1109,32 @@ static ssize_t store_pwm_sensor(struct device *dev, struct device_attribute
{ {
struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
struct abituguru_data *data = dev_get_drvdata(dev); struct abituguru_data *data = dev_get_drvdata(dev);
unsigned long val = simple_strtoul(buf, NULL, 10) - 1; ssize_t ret;
ssize_t ret = count; unsigned long val;
u8 orig_val;
u8 address;
ret = kstrtoul(buf, 10, &val);
if (ret)
return ret;
if (val == 0 || val > data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR])
return -EINVAL;
val -= 1;
ret = count;
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
if (val < data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR]) { orig_val = data->pwm_settings[attr->index][0];
u8 orig_val = data->pwm_settings[attr->index][0]; address = data->bank1_address[ABIT_UGURU_TEMP_SENSOR][val];
u8 address = data->bank1_address[ABIT_UGURU_TEMP_SENSOR][val]; data->pwm_settings[attr->index][0] &= 0xF0;
data->pwm_settings[attr->index][0] &= 0xF0; data->pwm_settings[attr->index][0] |= address;
data->pwm_settings[attr->index][0] |= address; if (data->pwm_settings[attr->index][0] != orig_val) {
if (data->pwm_settings[attr->index][0] != orig_val) { if (abituguru_write(data, ABIT_UGURU_FAN_PWM + 1, attr->index,
if (abituguru_write(data, ABIT_UGURU_FAN_PWM + 1, data->pwm_settings[attr->index], 5) < 1) {
attr->index, data->pwm_settings[attr->index][0] = orig_val;
data->pwm_settings[attr->index], ret = -EIO;
5) < 1) {
data->pwm_settings[attr->index][0] = orig_val;
ret = -EIO;
}
} }
} }
else
ret = -EINVAL;
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return ret; return ret;
} }
@ -1037,22 +1155,27 @@ static ssize_t store_pwm_enable(struct device *dev, struct device_attribute
{ {
struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
struct abituguru_data *data = dev_get_drvdata(dev); struct abituguru_data *data = dev_get_drvdata(dev);
u8 orig_val, user_val = simple_strtoul(buf, NULL, 10); u8 orig_val;
ssize_t ret = count; ssize_t ret;
unsigned long user_val;
ret = kstrtoul(buf, 10, &user_val);
if (ret)
return ret;
ret = count;
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
orig_val = data->pwm_settings[attr->index][0]; orig_val = data->pwm_settings[attr->index][0];
switch (user_val) { switch (user_val) {
case 0: case 0:
data->pwm_settings[attr->index][0] &= data->pwm_settings[attr->index][0] &=
~ABIT_UGURU_FAN_PWM_ENABLE; ~ABIT_UGURU_FAN_PWM_ENABLE;
break; break;
case 2: case 2:
data->pwm_settings[attr->index][0] |= data->pwm_settings[attr->index][0] |= ABIT_UGURU_FAN_PWM_ENABLE;
ABIT_UGURU_FAN_PWM_ENABLE; break;
break; default:
default: ret = -EINVAL;
ret = -EINVAL;
} }
if ((data->pwm_settings[attr->index][0] != orig_val) && if ((data->pwm_settings[attr->index][0] != orig_val) &&
(abituguru_write(data, ABIT_UGURU_FAN_PWM + 1, (abituguru_write(data, ABIT_UGURU_FAN_PWM + 1,
@ -1147,13 +1270,16 @@ static int __devinit abituguru_probe(struct platform_device *pdev)
int i, j, used, sysfs_names_free, sysfs_attr_i, res = -ENODEV; int i, j, used, sysfs_names_free, sysfs_attr_i, res = -ENODEV;
char *sysfs_filename; char *sysfs_filename;
/* El weirdo probe order, to keep the sysfs order identical to the /*
BIOS and window-appliction listing order. */ * El weirdo probe order, to keep the sysfs order identical to the
* BIOS and window-appliction listing order.
*/
const u8 probe_order[ABIT_UGURU_MAX_BANK1_SENSORS] = { const u8 probe_order[ABIT_UGURU_MAX_BANK1_SENSORS] = {
0x00, 0x01, 0x03, 0x04, 0x0A, 0x08, 0x0E, 0x02, 0x00, 0x01, 0x03, 0x04, 0x0A, 0x08, 0x0E, 0x02,
0x09, 0x06, 0x05, 0x0B, 0x0F, 0x0D, 0x07, 0x0C }; 0x09, 0x06, 0x05, 0x0B, 0x0F, 0x0D, 0x07, 0x0C };
if (!(data = kzalloc(sizeof(struct abituguru_data), GFP_KERNEL))) data = kzalloc(sizeof(struct abituguru_data), GFP_KERNEL);
if (!data)
return -ENOMEM; return -ENOMEM;
data->addr = platform_get_resource(pdev, IORESOURCE_IO, 0)->start; data->addr = platform_get_resource(pdev, IORESOURCE_IO, 0)->start;
@ -1164,9 +1290,11 @@ static int __devinit abituguru_probe(struct platform_device *pdev)
if (inb_p(data->addr + ABIT_UGURU_DATA) == ABIT_UGURU_STATUS_INPUT) if (inb_p(data->addr + ABIT_UGURU_DATA) == ABIT_UGURU_STATUS_INPUT)
data->uguru_ready = 1; data->uguru_ready = 1;
/* Completely read the uGuru this has 2 purposes: /*
- testread / see if one really is there. * Completely read the uGuru this has 2 purposes:
- make an in memory copy of all the uguru settings for future use. */ * - testread / see if one really is there.
* - make an in memory copy of all the uguru settings for future use.
*/
if (abituguru_read(data, ABIT_UGURU_ALARM_BANK, 0, if (abituguru_read(data, ABIT_UGURU_ALARM_BANK, 0,
data->alarms, 3, ABIT_UGURU_MAX_RETRIES) != 3) data->alarms, 3, ABIT_UGURU_MAX_RETRIES) != 3)
goto abituguru_probe_error; goto abituguru_probe_error;
@ -1181,11 +1309,13 @@ static int __devinit abituguru_probe(struct platform_device *pdev)
ABIT_UGURU_MAX_RETRIES) != 3) ABIT_UGURU_MAX_RETRIES) != 3)
goto abituguru_probe_error; goto abituguru_probe_error;
} }
/* Note: We don't know how many bank2 sensors / pwms there really are, /*
but in order to "detect" this we need to read the maximum amount * Note: We don't know how many bank2 sensors / pwms there really are,
anyways. If we read sensors/pwms not there we'll just read crap * but in order to "detect" this we need to read the maximum amount
this can't hurt. We need the detection because we don't want * anyways. If we read sensors/pwms not there we'll just read crap
unwanted writes, which will hurt! */ * this can't hurt. We need the detection because we don't want
* unwanted writes, which will hurt!
*/
for (i = 0; i < ABIT_UGURU_MAX_BANK2_SENSORS; i++) { for (i = 0; i < ABIT_UGURU_MAX_BANK2_SENSORS; i++) {
if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK2, i, if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK2, i,
&data->bank2_value[i], 1, &data->bank2_value[i], 1,
@ -1332,24 +1462,26 @@ static struct abituguru_data *abituguru_update_device(struct device *dev)
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
if (time_after(jiffies, data->last_updated + HZ)) { if (time_after(jiffies, data->last_updated + HZ)) {
success = 0; success = 0;
if ((err = abituguru_read(data, ABIT_UGURU_ALARM_BANK, 0, err = abituguru_read(data, ABIT_UGURU_ALARM_BANK, 0,
data->alarms, 3, 0)) != 3) data->alarms, 3, 0);
if (err != 3)
goto LEAVE_UPDATE; goto LEAVE_UPDATE;
for (i = 0; i < ABIT_UGURU_MAX_BANK1_SENSORS; i++) { for (i = 0; i < ABIT_UGURU_MAX_BANK1_SENSORS; i++) {
if ((err = abituguru_read(data, err = abituguru_read(data, ABIT_UGURU_SENSOR_BANK1,
ABIT_UGURU_SENSOR_BANK1, i, i, &data->bank1_value[i], 1, 0);
&data->bank1_value[i], 1, 0)) != 1) if (err != 1)
goto LEAVE_UPDATE; goto LEAVE_UPDATE;
if ((err = abituguru_read(data, err = abituguru_read(data, ABIT_UGURU_SENSOR_BANK1 + 1,
ABIT_UGURU_SENSOR_BANK1 + 1, i, i, data->bank1_settings[i], 3, 0);
data->bank1_settings[i], 3, 0)) != 3) if (err != 3)
goto LEAVE_UPDATE; goto LEAVE_UPDATE;
} }
for (i = 0; i < data->bank2_sensors; i++) for (i = 0; i < data->bank2_sensors; i++) {
if ((err = abituguru_read(data, err = abituguru_read(data, ABIT_UGURU_SENSOR_BANK2, i,
ABIT_UGURU_SENSOR_BANK2, i, &data->bank2_value[i], 1, 0);
&data->bank2_value[i], 1, 0)) != 1) if (err != 1)
goto LEAVE_UPDATE; goto LEAVE_UPDATE;
}
/* success! */ /* success! */
success = 1; success = 1;
data->update_timeouts = 0; data->update_timeouts = 0;
@ -1385,8 +1517,10 @@ static struct abituguru_data *abituguru_update_device(struct device *dev)
static int abituguru_suspend(struct platform_device *pdev, pm_message_t state) static int abituguru_suspend(struct platform_device *pdev, pm_message_t state)
{ {
struct abituguru_data *data = platform_get_drvdata(pdev); struct abituguru_data *data = platform_get_drvdata(pdev);
/* make sure all communications with the uguru are done and no new /*
ones are started */ * make sure all communications with the uguru are done and no new
* ones are started
*/
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
return 0; return 0;
} }
@ -1418,12 +1552,14 @@ static struct platform_driver abituguru_driver = {
static int __init abituguru_detect(void) static int __init abituguru_detect(void)
{ {
/* See if there is an uguru there. After a reboot uGuru will hold 0x00 /*
at DATA and 0xAC, when this driver has already been loaded once * See if there is an uguru there. After a reboot uGuru will hold 0x00
DATA will hold 0x08. For most uGuru's CMD will hold 0xAC in either * at DATA and 0xAC, when this driver has already been loaded once
scenario but some will hold 0x00. * DATA will hold 0x08. For most uGuru's CMD will hold 0xAC in either
Some uGuru's initially hold 0x09 at DATA and will only hold 0x08 * scenario but some will hold 0x00.
after reading CMD first, so CMD must be read first! */ * Some uGuru's initially hold 0x09 at DATA and will only hold 0x08
* after reading CMD first, so CMD must be read first!
*/
u8 cmd_val = inb_p(ABIT_UGURU_BASE + ABIT_UGURU_CMD); u8 cmd_val = inb_p(ABIT_UGURU_BASE + ABIT_UGURU_CMD);
u8 data_val = inb_p(ABIT_UGURU_BASE + ABIT_UGURU_DATA); u8 data_val = inb_p(ABIT_UGURU_BASE + ABIT_UGURU_DATA);
if (((data_val == 0x00) || (data_val == 0x08)) && if (((data_val == 0x00) || (data_val == 0x08)) &&