Linux Audio

Check our new training course

Loading...
v3.1
 
   1/*
   2    abituguru.c Copyright (c) 2005-2006 Hans de Goede <hdegoede@redhat.com>
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17*/
  18/*
  19    This driver supports the sensor part of the 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!
  22*/
  23
  24#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  25
  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>
  38#include <linux/io.h>
  39
  40/* Banks */
  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
  89/* utility macros */
  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)
 112
 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
 124/* uGuru status' */
 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 */
 129
 130/* Constants */
 131/* in (Volt) sensors go up to 3494 mV, temp to 255000 millidegrees Celsius */
 132static 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 */
 
 
 135static const u8 abituguru_bank2_min_threshold = 5;
 136static 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. */
 
 
 139static 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! */
 
 
 143static const u8 abituguru_pwm_min[5] = { 0, 170, 170, 25, 25 };
 144static const u8 abituguru_pwm_max[5] = { 0, 255, 255, 75, 75 };
 145
 146
 147/* Insmod parameters */
 148static int force;
 149module_param(force, bool, 0);
 150MODULE_PARM_DESC(force, "Set to one to force detection.");
 151static 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 };
 153module_param_array(bank1_types, int, NULL, 0);
 154MODULE_PARM_DESC(bank1_types, "Bank1 sensortype autodetection override:\n"
 155	"   -1 autodetect\n"
 156	"    0 volt sensor\n"
 157	"    1 temp sensor\n"
 158	"    2 not connected");
 159static int fan_sensors;
 160module_param(fan_sensors, int, 0);
 161MODULE_PARM_DESC(fan_sensors, "Number of fan sensors on the uGuru "
 162	"(0 = autodetect)");
 163static int pwms;
 164module_param(pwms, int, 0);
 165MODULE_PARM_DESC(pwms, "Number of PWMs on the uGuru "
 166	"(0 = autodetect)");
 167
 168/* Default verbose is 2, since this driver is still in the testing phase */
 169static int verbose = 2;
 170module_param(verbose, int, 0644);
 171MODULE_PARM_DESC(verbose, "How verbose should the driver be? (0-3):\n"
 172	"   0 normal output\n"
 173	"   1 + verbose error reporting\n"
 174	"   2 + sensors type probing info\n"
 175	"   3 + retryable error reporting");
 176
 177
 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. */
 
 
 181struct 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
 188					   successful update */
 189
 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];
 200
 201	/* Bank 1 data */
 202	/* number of and addresses of [0] in, [1] temp sensors */
 203	u8 bank1_sensors[2];
 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
 210	   Celsius. */
 
 
 211	int bank1_max_value[ABIT_UGURU_MAX_BANK1_SENSORS];
 212
 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 */
 217
 218	/* Alarms 2 bytes for bank1, 1 byte for bank2 */
 219	u8 alarms[3];
 220
 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];
 224};
 225
 226static const char *never_happen = "This should never happen.";
 227static const char *report_this =
 228	"Please report this to the abituguru maintainer (see MAINTAINERS)";
 229
 230/* wait till the uguru is in the specified state */
 231static int abituguru_wait(struct abituguru_data *data, u8 state)
 232{
 233	int timeout = ABIT_UGURU_WAIT_TIMEOUT;
 234
 235	while (inb_p(data->addr + ABIT_UGURU_DATA) != state) {
 236		timeout--;
 237		if (timeout == 0)
 238			return -EBUSY;
 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)
 242			msleep(0);
 243	}
 244	return 0;
 245}
 246
 247/* Put the uguru in ready for input state */
 248static int abituguru_ready(struct abituguru_data *data)
 249{
 250	int timeout = ABIT_UGURU_READY_TIMEOUT;
 251
 252	if (data->uguru_ready)
 253		return 0;
 254
 255	/* Reset? / Prepare for next read/write cycle */
 256	outb(0x00, data->addr + ABIT_UGURU_DATA);
 257
 258	/* Wait till the uguru is ready */
 259	if (abituguru_wait(data, ABIT_UGURU_STATUS_READY)) {
 260		ABIT_UGURU_DEBUG(1,
 261			"timeout exceeded waiting for ready state\n");
 262		return -EIO;
 263	}
 264
 265	/* Cmd port MUST be read now and should contain 0xAC */
 266	while (inb_p(data->addr + ABIT_UGURU_CMD) != 0xAC) {
 267		timeout--;
 268		if (timeout == 0) {
 269			ABIT_UGURU_DEBUG(1,
 270			   "CMD reg does not hold 0xAC after ready command\n");
 271			return -EIO;
 272		}
 273		msleep(0);
 274	}
 275
 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) {
 280		timeout--;
 281		if (timeout == 0) {
 282			ABIT_UGURU_DEBUG(1,
 283				"state != more input after ready command\n");
 284			return -EIO;
 285		}
 286		msleep(0);
 287	}
 288
 289	data->uguru_ready = 1;
 290	return 0;
 291}
 292
 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. */
 
 
 297static int abituguru_send_address(struct abituguru_data *data,
 298	u8 bank_addr, u8 sensor_addr, int retries)
 299{
 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;
 303
 304	for (;;) {
 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)
 308			return -EIO;
 309		outb(bank_addr, data->addr + ABIT_UGURU_DATA);
 310		data->uguru_ready = 0;
 311
 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)) {
 315			if (retries) {
 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);
 321				retries--;
 322				continue;
 323			}
 324			if (report_errors)
 325				ABIT_UGURU_DEBUG(1, "timeout exceeded "
 326					"waiting for more input state "
 327					"(bank: %d)\n", (int)bank_addr);
 328			return -EBUSY;
 329		}
 330		outb(sensor_addr, data->addr + ABIT_UGURU_CMD);
 331		return 0;
 332	}
 333}
 334
 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. */
 
 
 337static int abituguru_read(struct abituguru_data *data,
 338	u8 bank_addr, u8 sensor_addr, u8 *buf, int count, int retries)
 339{
 340	int i;
 341
 342	/* Send the address */
 343	i = abituguru_send_address(data, bank_addr, sensor_addr, retries);
 344	if (i)
 345		return i;
 346
 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);
 354			break;
 355		}
 356		buf[i] = inb(data->addr + ABIT_UGURU_CMD);
 357	}
 358
 359	/* Last put the chip back in ready state */
 360	abituguru_ready(data);
 361
 362	return i;
 363}
 364
 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. */
 
 
 367static int abituguru_write(struct abituguru_data *data,
 368	u8 bank_addr, u8 sensor_addr, u8 *buf, int count)
 369{
 370	/* We use the ready timeout as we have to wait for 0xAC just like the
 371	   ready function */
 
 
 372	int i, timeout = ABIT_UGURU_READY_TIMEOUT;
 373
 374	/* Send the address */
 375	i = abituguru_send_address(data, bank_addr, sensor_addr,
 376		ABIT_UGURU_MAX_RETRIES);
 377	if (i)
 378		return i;
 379
 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);
 386			break;
 387		}
 388		outb(buf[i], data->addr + ABIT_UGURU_CMD);
 389	}
 390
 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
 393	   succeeded. */
 
 
 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,
 397			(int)sensor_addr);
 398		return -EIO;
 399	}
 400
 401	/* Cmd port MUST be read now and should contain 0xAC */
 402	while (inb_p(data->addr + ABIT_UGURU_CMD) != 0xAC) {
 403		timeout--;
 404		if (timeout == 0) {
 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);
 408			return -EIO;
 409		}
 410		msleep(0);
 411	}
 412
 413	/* Last put the chip back in ready state */
 414	abituguru_ready(data);
 415
 416	return i;
 417}
 418
 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. */
 425static int __devinit
 
 
 426abituguru_detect_bank1_sensor_type(struct abituguru_data *data,
 427				   u8 sensor_addr)
 428{
 429	u8 val, test_flag, buf[3];
 430	int i, ret = -ENODEV; /* error is the most common used retval :| */
 431
 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];
 439	}
 440
 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)
 444		return -ENODEV;
 445
 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;
 455	}
 456
 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. */
 
 
 461	if (val <= 240u) {
 462		buf[0] = ABIT_UGURU_VOLT_LOW_ALARM_ENABLE;
 463		buf[1] = 245;
 464		buf[2] = 250;
 465		test_flag = ABIT_UGURU_VOLT_LOW_ALARM_FLAG;
 466	} else {
 467		buf[0] = ABIT_UGURU_VOLT_HIGH_ALARM_ENABLE;
 468		buf[1] = 5;
 469		buf[2] = 10;
 470		test_flag = ABIT_UGURU_VOLT_HIGH_ALARM_FLAG;
 471	}
 472
 473	if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2, sensor_addr,
 474			buf, 3) != 3)
 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,
 486				sensor_addr, buf, 3,
 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;
 493		} else
 494			ABIT_UGURU_DEBUG(2, "  alarm raised during volt "
 495				"sensor test, but volt range flag not set\n");
 496	} else
 497		ABIT_UGURU_DEBUG(2, "  alarm not raised during volt sensor "
 498			"test\n");
 499
 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;
 504	buf[1] = 5;
 505	buf[2] = 10;
 506	if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2, sensor_addr,
 507			buf, 3) != 3)
 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,
 519				sensor_addr, buf, 3,
 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;
 526		} else
 527			ABIT_UGURU_DEBUG(2, "  alarm raised during temp "
 528				"sensor test, but temp high flag not set\n");
 529	} else
 530		ABIT_UGURU_DEBUG(2, "  alarm not raised during temp sensor "
 531			"test\n");
 532
 533	ret = ABIT_UGURU_NC;
 534abituguru_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],
 541				3) == 3)
 542			break;
 543	if (i == 3) {
 544		pr_err("Fatal error could not restore original settings. %s %s\n",
 545		       never_happen, report_this);
 546		return -ENODEV;
 547	}
 548	return ret;
 549}
 550
 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.
 558
 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"
 563
 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. */
 568static void __devinit
 
 
 569abituguru_detect_no_bank2_sensors(struct abituguru_data *data)
 570{
 571	int i;
 572
 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);
 578		return;
 579	}
 580
 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
 585		   -0x08 enable beep
 586		   -0x01 enable alarm
 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]);
 593			break;
 594		}
 595
 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);
 604			break;
 605		}
 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);
 613			break;
 614		}
 615	}
 616
 617	data->bank2_sensors = i;
 618	ABIT_UGURU_DEBUG(2, " found: %d fan sensors\n",
 619		(int)data->bank2_sensors);
 620}
 621
 622static void __devinit
 623abituguru_detect_no_pwms(struct abituguru_data *data)
 624{
 625	int i, j;
 626
 627	if (pwms > 0 && pwms <= ABIT_UGURU_MAX_PWMS) {
 628		data->pwms = pwms;
 629		ABIT_UGURU_DEBUG(2, "assuming %d PWM outputs because of "
 630			"\"pwms\" module param\n", (int)data->pwms);
 631		return;
 632	}
 633
 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]);
 643			break;
 644		}
 645
 646		/* the low nibble must correspond to one of the temp sensors
 647		   we've found */
 
 
 648		for (j = 0; j < data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR];
 649				j++) {
 650			if (data->bank1_address[ABIT_UGURU_TEMP_SENSOR][j] ==
 651					(data->pwm_settings[i][0] & 0x0F))
 652				break;
 653		}
 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);
 659			break;
 660		}
 661
 662		/* check if all other settings are within the allowed range */
 663		for (j = 1; j < 5; j++) {
 664			u8 min;
 665			/* special case pwm1 min pwm% */
 666			if ((i == 0) && ((j == 1) || (j == 2)))
 667				min = 77;
 668			else
 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],
 676					(int)min);
 677				goto abituguru_detect_no_pwms_exit;
 678			}
 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;
 687			}
 688		}
 689
 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) >= "
 694				"max pwm (%d)\n", i,
 695				(int)data->pwm_settings[i][1],
 696				(int)data->pwm_settings[i][2]);
 697			break;
 698		}
 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]);
 705			break;
 706		}
 707	}
 708
 709abituguru_detect_no_pwms_exit:
 710	data->pwms = i;
 711	ABIT_UGURU_DEBUG(2, " found: %d PWM outputs\n", (int)data->pwms);
 712}
 713
 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. */
 
 
 717static struct abituguru_data *abituguru_update_device(struct device *dev);
 718
 719static ssize_t show_bank1_value(struct device *dev,
 720	struct device_attribute *devattr, char *buf)
 721{
 722	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 723	struct abituguru_data *data = abituguru_update_device(dev);
 724	if (!data)
 725		return -EIO;
 726	return sprintf(buf, "%d\n", (data->bank1_value[attr->index] *
 727		data->bank1_max_value[attr->index] + 128) / 255);
 728}
 729
 730static ssize_t show_bank1_setting(struct device *dev,
 731	struct device_attribute *devattr, char *buf)
 732{
 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);
 738}
 739
 740static ssize_t show_bank2_value(struct device *dev,
 741	struct device_attribute *devattr, char *buf)
 742{
 743	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 744	struct abituguru_data *data = abituguru_update_device(dev);
 745	if (!data)
 746		return -EIO;
 747	return sprintf(buf, "%d\n", (data->bank2_value[attr->index] *
 748		ABIT_UGURU_FAN_MAX + 128) / 255);
 749}
 750
 751static ssize_t show_bank2_setting(struct device *dev,
 752	struct device_attribute *devattr, char *buf)
 753{
 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);
 759}
 760
 761static ssize_t store_bank1_setting(struct device *dev, struct device_attribute
 762	*devattr, const char *buf, size_t count)
 763{
 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];
 769	ssize_t ret = count;
 
 770
 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],
 777				3) <= attr->nr) {
 778			data->bank1_settings[attr->index][attr->nr] = orig_val;
 779			ret = -EIO;
 780		}
 781	}
 782	mutex_unlock(&data->update_lock);
 783	return ret;
 784}
 785
 786static ssize_t store_bank2_setting(struct device *dev, struct device_attribute
 787	*devattr, const char *buf, size_t count)
 788{
 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) /
 792		ABIT_UGURU_FAN_MAX;
 793	ssize_t ret = count;
 
 
 
 
 
 
 794
 795	/* this check can be done before taking the lock */
 796	if ((val < abituguru_bank2_min_threshold) ||
 797			(val > abituguru_bank2_max_threshold))
 798		return -EINVAL;
 799
 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],
 806				2) <= attr->nr) {
 807			data->bank2_settings[attr->index][attr->nr] = orig_val;
 808			ret = -EIO;
 809		}
 810	}
 811	mutex_unlock(&data->update_lock);
 812	return ret;
 813}
 814
 815static ssize_t show_bank1_alarm(struct device *dev,
 816	struct device_attribute *devattr, char *buf)
 817{
 818	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 819	struct abituguru_data *data = abituguru_update_device(dev);
 820	if (!data)
 821		return -EIO;
 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");
 830	else
 831		return sprintf(buf, "0\n");
 832}
 833
 834static ssize_t show_bank2_alarm(struct device *dev,
 835	struct device_attribute *devattr, char *buf)
 836{
 837	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 838	struct abituguru_data *data = abituguru_update_device(dev);
 839	if (!data)
 840		return -EIO;
 841	if (data->alarms[2] & (0x01 << attr->index))
 842		return sprintf(buf, "1\n");
 843	else
 844		return sprintf(buf, "0\n");
 845}
 846
 847static ssize_t show_bank1_mask(struct device *dev,
 848	struct device_attribute *devattr, char *buf)
 849{
 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");
 854	else
 855		return sprintf(buf, "0\n");
 856}
 857
 858static ssize_t show_bank2_mask(struct device *dev,
 859	struct device_attribute *devattr, char *buf)
 860{
 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");
 865	else
 866		return sprintf(buf, "0\n");
 867}
 868
 869static ssize_t store_bank1_mask(struct device *dev,
 870	struct device_attribute *devattr, const char *buf, size_t count)
 871{
 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);
 875	ssize_t ret = count;
 876	u8 orig_val;
 
 
 
 
 
 877
 
 878	mutex_lock(&data->update_lock);
 879	orig_val = data->bank1_settings[attr->index][0];
 880
 881	if (mask)
 882		data->bank1_settings[attr->index][0] |= attr->nr;
 883	else
 884		data->bank1_settings[attr->index][0] &= ~attr->nr;
 885
 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;
 891		ret = -EIO;
 892	}
 893	mutex_unlock(&data->update_lock);
 894	return ret;
 895}
 896
 897static ssize_t store_bank2_mask(struct device *dev,
 898	struct device_attribute *devattr, const char *buf, size_t count)
 899{
 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);
 903	ssize_t ret = count;
 904	u8 orig_val;
 
 905
 
 
 
 
 
 906	mutex_lock(&data->update_lock);
 907	orig_val = data->bank2_settings[attr->index][0];
 908
 909	if (mask)
 910		data->bank2_settings[attr->index][0] |= attr->nr;
 911	else
 912		data->bank2_settings[attr->index][0] &= ~attr->nr;
 913
 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;
 919		ret = -EIO;
 920	}
 921	mutex_unlock(&data->update_lock);
 922	return ret;
 923}
 924
 925/* Fan PWM (speed control) */
 926static ssize_t show_pwm_setting(struct device *dev,
 927	struct device_attribute *devattr, char *buf)
 928{
 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]);
 933}
 934
 935static ssize_t store_pwm_setting(struct device *dev, struct device_attribute
 936	*devattr, const char *buf, size_t count)
 937{
 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];
 943	ssize_t ret = count;
 
 
 
 
 
 
 
 944
 945	/* special case pwm1 min pwm% */
 946	if ((attr->index == 0) && ((attr->nr == 1) || (attr->nr == 2)))
 947		min = 77;
 948	else
 949		min = abituguru_pwm_min[attr->nr];
 950
 951	/* this check can be done before taking the lock */
 952	if ((val < min) || (val > abituguru_pwm_max[attr->nr]))
 953		return -EINVAL;
 954
 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]))
 959		ret = -EINVAL;
 960	else if (!(attr->nr & 1) &&
 961			(val <= data->pwm_settings[attr->index][attr->nr - 1]))
 962		ret = -EINVAL;
 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],
 968				5) <= attr->nr) {
 969			data->pwm_settings[attr->index][attr->nr] =
 970				orig_val;
 971			ret = -EIO;
 972		}
 973	}
 974	mutex_unlock(&data->update_lock);
 975	return ret;
 976}
 977
 978static ssize_t show_pwm_sensor(struct device *dev,
 979	struct device_attribute *devattr, char *buf)
 980{
 981	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 982	struct abituguru_data *data = dev_get_drvdata(dev);
 983	int i;
 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);
 990
 991	return -ENXIO;
 992}
 993
 994static ssize_t store_pwm_sensor(struct device *dev, struct device_attribute
 995	*devattr, const char *buf, size_t count)
 996{
 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;
 
 
 
 
 
 
 
 
 
1001
 
 
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,
1010					attr->index,
1011					data->pwm_settings[attr->index],
1012					5) < 1) {
1013				data->pwm_settings[attr->index][0] = orig_val;
1014				ret = -EIO;
1015			}
1016		}
1017	}
1018	else
1019		ret = -EINVAL;
1020	mutex_unlock(&data->update_lock);
1021	return ret;
1022}
1023
1024static ssize_t show_pwm_enable(struct device *dev,
1025	struct device_attribute *devattr, char *buf)
1026{
1027	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
1028	struct abituguru_data *data = dev_get_drvdata(dev);
1029	int res = 0;
1030	if (data->pwm_settings[attr->index][0] & ABIT_UGURU_FAN_PWM_ENABLE)
1031		res = 2;
1032	return sprintf(buf, "%d\n", res);
1033}
1034
1035static ssize_t store_pwm_enable(struct device *dev, struct device_attribute
1036	*devattr, const char *buf, size_t count)
1037{
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;
 
 
 
 
 
1042
 
1043	mutex_lock(&data->update_lock);
1044	orig_val = data->pwm_settings[attr->index][0];
1045	switch (user_val) {
1046		case 0:
1047			data->pwm_settings[attr->index][0] &=
1048				~ABIT_UGURU_FAN_PWM_ENABLE;
1049			break;
1050		case 2:
1051			data->pwm_settings[attr->index][0] |=
1052				ABIT_UGURU_FAN_PWM_ENABLE;
1053			break;
1054		default:
1055			ret = -EINVAL;
1056	}
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],
1060			5) < 1)) {
1061		data->pwm_settings[attr->index][0] = orig_val;
1062		ret = -EIO;
1063	}
1064	mutex_unlock(&data->update_lock);
1065	return ret;
1066}
1067
1068static ssize_t show_name(struct device *dev,
1069	struct device_attribute *devattr, char *buf)
1070{
1071	return sprintf(buf, "%s\n", ABIT_UGURU_NAME);
1072}
1073
1074/* Sysfs attr templates, the real entries are generated automatically. */
1075static const
1076struct sensor_device_attribute_2 abituguru_sysfs_bank1_templ[2][9] = {
1077	{
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),
1095	}, {
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),
1109	}
1110};
1111
1112static 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),
1123};
1124
1125static 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),
1138};
1139
1140static struct sensor_device_attribute_2 abituguru_sysfs_attr[] = {
1141	SENSOR_ATTR_2(name, 0444, show_name, NULL, 0, 0),
1142};
1143
1144static int __devinit abituguru_probe(struct platform_device *pdev)
1145{
1146	struct abituguru_data *data;
1147	int i, j, used, sysfs_names_free, sysfs_attr_i, res = -ENODEV;
1148	char *sysfs_filename;
1149
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 };
1155
1156	if (!(data = kzalloc(sizeof(struct abituguru_data), GFP_KERNEL)))
 
 
1157		return -ENOMEM;
1158
1159	data->addr = platform_get_resource(pdev, IORESOURCE_IO, 0)->start;
1160	mutex_init(&data->update_lock);
1161	platform_set_drvdata(pdev, data);
1162
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;
1166
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;
1173
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;
1183	}
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;
1198	}
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;
1204	}
1205	data->last_updated = jiffies;
1206
1207	/* Detect sensor types and fill the sysfs attr for bank1 */
1208	sysfs_attr_i = 0;
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]);
1213		if (res < 0)
1214			goto abituguru_probe_error;
1215		if (res == ABIT_UGURU_NC)
1216			continue;
1217
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)
1223				+ 1;
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 =
1227				sysfs_filename;
1228			data->sysfs_attr[sysfs_attr_i].index = probe_order[i];
1229			sysfs_filename += used;
1230			sysfs_names_free -= used;
1231			sysfs_attr_i++;
1232		}
1233		data->bank1_max_value[probe_order[i]] =
1234			abituguru_bank1_max_value[res];
1235		data->bank1_address[res][data->bank1_sensors[res]] =
1236			probe_order[i];
1237		data->bank1_sensors[res]++;
1238	}
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,
1245				i + 1) + 1;
1246			data->sysfs_attr[sysfs_attr_i] =
1247				abituguru_sysfs_fan_templ[j];
1248			data->sysfs_attr[sysfs_attr_i].dev_attr.attr.name =
1249				sysfs_filename;
1250			data->sysfs_attr[sysfs_attr_i].index = i;
1251			sysfs_filename += used;
1252			sysfs_names_free -= used;
1253			sysfs_attr_i++;
1254		}
1255	}
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,
1262				i + 1) + 1;
1263			data->sysfs_attr[sysfs_attr_i] =
1264				abituguru_sysfs_pwm_templ[j];
1265			data->sysfs_attr[sysfs_attr_i].dev_attr.attr.name =
1266				sysfs_filename;
1267			data->sysfs_attr[sysfs_attr_i].index = i;
1268			sysfs_filename += used;
1269			sysfs_names_free -= used;
1270			sysfs_attr_i++;
1271		}
1272	}
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;
1279	}
1280	pr_info("found Abit uGuru\n");
1281
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;
 
1291
1292	data->hwmon_dev = hwmon_device_register(&pdev->dev);
1293	if (!IS_ERR(data->hwmon_dev))
1294		return 0; /* success */
1295
1296	res = PTR_ERR(data->hwmon_dev);
1297abituguru_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);
1304	kfree(data);
1305	return res;
1306}
1307
1308static int __devexit abituguru_remove(struct platform_device *pdev)
1309{
1310	int i;
1311	struct abituguru_data *data = platform_get_drvdata(pdev);
1312
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);
1320	kfree(data);
1321
1322	return 0;
1323}
1324
1325static struct abituguru_data *abituguru_update_device(struct device *dev)
1326{
1327	int i, err;
1328	struct abituguru_data *data = dev_get_drvdata(dev);
1329	/* fake a complete successful read if no update necessary. */
1330	char success = 1;
1331
1332	mutex_lock(&data->update_lock);
1333	if (time_after(jiffies, data->last_updated + HZ)) {
1334		success = 0;
1335		if ((err = abituguru_read(data, ABIT_UGURU_ALARM_BANK, 0,
1336				data->alarms, 3, 0)) != 3)
 
1337			goto LEAVE_UPDATE;
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)
1342				goto LEAVE_UPDATE;
1343			if ((err = abituguru_read(data,
1344					ABIT_UGURU_SENSOR_BANK1 + 1, i,
1345					data->bank1_settings[i], 3, 0)) != 3)
1346				goto LEAVE_UPDATE;
1347		}
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)
1352				goto LEAVE_UPDATE;
 
1353		/* success! */
1354		success = 1;
1355		data->update_timeouts = 0;
1356LEAVE_UPDATE:
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 */
1366				success = 1;
1367			} else
1368				ABIT_UGURU_DEBUG(1, "timeout exceeded %d "
1369					"times waiting for more input state\n",
1370					(int)data->update_timeouts);
1371		}
1372		/* On success set last_updated */
1373		if (success)
1374			data->last_updated = jiffies;
1375	}
1376	mutex_unlock(&data->update_lock);
1377
1378	if (success)
1379		return data;
1380	else
1381		return NULL;
1382}
1383
1384#ifdef CONFIG_PM
1385static int abituguru_suspend(struct platform_device *pdev, pm_message_t state)
1386{
1387	struct abituguru_data *data = platform_get_drvdata(pdev);
1388	/* make sure all communications with the uguru are done and no new
1389	   ones are started */
 
 
1390	mutex_lock(&data->update_lock);
1391	return 0;
1392}
1393
1394static int abituguru_resume(struct platform_device *pdev)
1395{
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);
1401	return 0;
1402}
1403#else
1404#define abituguru_suspend	NULL
1405#define abituguru_resume	NULL
1406#endif /* CONFIG_PM */
1407
1408static struct platform_driver abituguru_driver = {
1409	.driver = {
1410		.owner	= THIS_MODULE,
1411		.name	= ABIT_UGURU_NAME,
 
1412	},
1413	.probe		= abituguru_probe,
1414	.remove		= __devexit_p(abituguru_remove),
1415	.suspend	= abituguru_suspend,
1416	.resume		= abituguru_resume,
1417};
1418
1419static int __init abituguru_detect(void)
1420{
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;
1432
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);
1435
1436	if (force) {
1437		pr_info("Assuming Abit uGuru is present because of \"force\" parameter\n");
1438		return ABIT_UGURU_BASE;
1439	}
1440
1441	/* No uGuru found */
1442	return -ENODEV;
1443}
1444
1445static struct platform_device *abituguru_pdev;
1446
1447static int __init abituguru_init(void)
1448{
1449	int address, err;
1450	struct resource res = { .flags = IORESOURCE_IO };
1451	const char *board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
1452
1453	/* safety check, refuse to load on non Abit motherboards */
1454	if (!force && (!board_vendor ||
1455			strcmp(board_vendor, "http://www.abit.com.tw/")))
1456		return -ENODEV;
1457
1458	address = abituguru_detect();
1459	if (address < 0)
1460		return address;
1461
1462	err = platform_driver_register(&abituguru_driver);
1463	if (err)
1464		goto exit;
1465
1466	abituguru_pdev = platform_device_alloc(ABIT_UGURU_NAME, address);
1467	if (!abituguru_pdev) {
1468		pr_err("Device allocation failed\n");
1469		err = -ENOMEM;
1470		goto exit_driver_unregister;
1471	}
1472
1473	res.start = address;
1474	res.end = address + ABIT_UGURU_REGION_LENGTH - 1;
1475	res.name = ABIT_UGURU_NAME;
1476
1477	err = platform_device_add_resources(abituguru_pdev, &res, 1);
1478	if (err) {
1479		pr_err("Device resource addition failed (%d)\n", err);
1480		goto exit_device_put;
1481	}
1482
1483	err = platform_device_add(abituguru_pdev);
1484	if (err) {
1485		pr_err("Device addition failed (%d)\n", err);
1486		goto exit_device_put;
1487	}
1488
1489	return 0;
1490
1491exit_device_put:
1492	platform_device_put(abituguru_pdev);
1493exit_driver_unregister:
1494	platform_driver_unregister(&abituguru_driver);
1495exit:
1496	return err;
1497}
1498
1499static void __exit abituguru_exit(void)
1500{
1501	platform_device_unregister(abituguru_pdev);
1502	platform_driver_unregister(&abituguru_driver);
1503}
1504
1505MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
1506MODULE_DESCRIPTION("Abit uGuru Sensor device");
1507MODULE_LICENSE("GPL");
1508
1509module_init(abituguru_init);
1510module_exit(abituguru_exit);
v6.2
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * abituguru.c Copyright (c) 2005-2006 Hans de Goede <hdegoede@redhat.com>
   4 */
   5/*
   6 * This driver supports the sensor part of the first and second revision of
   7 * the custom Abit uGuru chip found on Abit uGuru motherboards. Note: because
   8 * of lack of specs the CPU/RAM voltage & frequency control is not supported!
   9 */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  10
  11#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13#include <linux/module.h>
  14#include <linux/sched.h>
  15#include <linux/init.h>
  16#include <linux/slab.h>
  17#include <linux/jiffies.h>
  18#include <linux/mutex.h>
  19#include <linux/err.h>
  20#include <linux/delay.h>
  21#include <linux/platform_device.h>
  22#include <linux/hwmon.h>
  23#include <linux/hwmon-sysfs.h>
  24#include <linux/dmi.h>
  25#include <linux/io.h>
  26
  27/* Banks */
  28#define ABIT_UGURU_ALARM_BANK			0x20 /* 1x 3 bytes */
  29#define ABIT_UGURU_SENSOR_BANK1			0x21 /* 16x volt and temp */
  30#define ABIT_UGURU_FAN_PWM			0x24 /* 3x 5 bytes */
  31#define ABIT_UGURU_SENSOR_BANK2			0x26 /* fans */
  32/* max nr of sensors in bank1, a bank1 sensor can be in, temp or nc */
  33#define ABIT_UGURU_MAX_BANK1_SENSORS		16
  34/*
  35 * Warning if you increase one of the 2 MAX defines below to 10 or higher you
  36 * should adjust the belonging _NAMES_LENGTH macro for the 2 digit number!
  37 */
  38/* max nr of sensors in bank2, currently mb's with max 6 fans are known */
  39#define ABIT_UGURU_MAX_BANK2_SENSORS		6
  40/* max nr of pwm outputs, currently mb's with max 5 pwm outputs are known */
  41#define ABIT_UGURU_MAX_PWMS			5
  42/* uGuru sensor bank 1 flags */			     /* Alarm if: */
  43#define ABIT_UGURU_TEMP_HIGH_ALARM_ENABLE	0x01 /*  temp over warn */
  44#define ABIT_UGURU_VOLT_HIGH_ALARM_ENABLE	0x02 /*  volt over max */
  45#define ABIT_UGURU_VOLT_LOW_ALARM_ENABLE	0x04 /*  volt under min */
  46#define ABIT_UGURU_TEMP_HIGH_ALARM_FLAG		0x10 /* temp is over warn */
  47#define ABIT_UGURU_VOLT_HIGH_ALARM_FLAG		0x20 /* volt is over max */
  48#define ABIT_UGURU_VOLT_LOW_ALARM_FLAG		0x40 /* volt is under min */
  49/* uGuru sensor bank 2 flags */			     /* Alarm if: */
  50#define ABIT_UGURU_FAN_LOW_ALARM_ENABLE		0x01 /*   fan under min */
  51/* uGuru sensor bank common flags */
  52#define ABIT_UGURU_BEEP_ENABLE			0x08 /* beep if alarm */
  53#define ABIT_UGURU_SHUTDOWN_ENABLE		0x80 /* shutdown if alarm */
  54/* uGuru fan PWM (speed control) flags */
  55#define ABIT_UGURU_FAN_PWM_ENABLE		0x80 /* enable speed control */
  56/* Values used for conversion */
  57#define ABIT_UGURU_FAN_MAX			15300 /* RPM */
  58/* Bank1 sensor types */
  59#define ABIT_UGURU_IN_SENSOR			0
  60#define ABIT_UGURU_TEMP_SENSOR			1
  61#define ABIT_UGURU_NC				2
  62/*
  63 * In many cases we need to wait for the uGuru to reach a certain status, most
  64 * of the time it will reach this status within 30 - 90 ISA reads, and thus we
  65 * can best busy wait. This define gives the total amount of reads to try.
  66 */
  67#define ABIT_UGURU_WAIT_TIMEOUT			125
  68/*
  69 * However sometimes older versions of the uGuru seem to be distracted and they
  70 * do not respond for a long time. To handle this we sleep before each of the
  71 * last ABIT_UGURU_WAIT_TIMEOUT_SLEEP tries.
  72 */
  73#define ABIT_UGURU_WAIT_TIMEOUT_SLEEP		5
  74/*
  75 * Normally all expected status in abituguru_ready, are reported after the
  76 * first read, but sometimes not and we need to poll.
  77 */
  78#define ABIT_UGURU_READY_TIMEOUT		5
  79/* Maximum 3 retries on timedout reads/writes, delay 200 ms before retrying */
  80#define ABIT_UGURU_MAX_RETRIES			3
  81#define ABIT_UGURU_RETRY_DELAY			(HZ/5)
  82/* Maximum 2 timeouts in abituguru_update_device, iow 3 in a row is an error */
  83#define ABIT_UGURU_MAX_TIMEOUTS			2
  84/* utility macros */
  85#define ABIT_UGURU_NAME				"abituguru"
  86#define ABIT_UGURU_DEBUG(level, format, arg...)		\
  87	do {						\
  88		if (level <= verbose)			\
  89			pr_debug(format , ## arg);	\
  90	} while (0)
  91
  92/* Macros to help calculate the sysfs_names array length */
  93/*
  94 * sum of strlen of: in??_input\0, in??_{min,max}\0, in??_{min,max}_alarm\0,
  95 * in??_{min,max}_alarm_enable\0, in??_beep\0, in??_shutdown\0
  96 */
  97#define ABITUGURU_IN_NAMES_LENGTH	(11 + 2 * 9 + 2 * 15 + 2 * 22 + 10 + 14)
  98/*
  99 * sum of strlen of: temp??_input\0, temp??_max\0, temp??_crit\0,
 100 * temp??_alarm\0, temp??_alarm_enable\0, temp??_beep\0, temp??_shutdown\0
 101 */
 102#define ABITUGURU_TEMP_NAMES_LENGTH	(13 + 11 + 12 + 13 + 20 + 12 + 16)
 103/*
 104 * sum of strlen of: fan?_input\0, fan?_min\0, fan?_alarm\0,
 105 * fan?_alarm_enable\0, fan?_beep\0, fan?_shutdown\0
 106 */
 107#define ABITUGURU_FAN_NAMES_LENGTH	(11 + 9 + 11 + 18 + 10 + 14)
 108/*
 109 * sum of strlen of: pwm?_enable\0, pwm?_auto_channels_temp\0,
 110 * pwm?_auto_point{1,2}_pwm\0, pwm?_auto_point{1,2}_temp\0
 111 */
 112#define ABITUGURU_PWM_NAMES_LENGTH	(12 + 24 + 2 * 21 + 2 * 22)
 113/* IN_NAMES_LENGTH > TEMP_NAMES_LENGTH so assume all bank1 sensors are in */
 114#define ABITUGURU_SYSFS_NAMES_LENGTH	( \
 115	ABIT_UGURU_MAX_BANK1_SENSORS * ABITUGURU_IN_NAMES_LENGTH + \
 116	ABIT_UGURU_MAX_BANK2_SENSORS * ABITUGURU_FAN_NAMES_LENGTH + \
 117	ABIT_UGURU_MAX_PWMS * ABITUGURU_PWM_NAMES_LENGTH)
 118
 119/*
 120 * All the macros below are named identical to the oguru and oguru2 programs
 121 * reverse engineered by Olle Sandberg, hence the names might not be 100%
 122 * logical. I could come up with better names, but I prefer keeping the names
 123 * identical so that this driver can be compared with his work more easily.
 124 */
 125/* Two i/o-ports are used by uGuru */
 126#define ABIT_UGURU_BASE				0x00E0
 127/* Used to tell uGuru what to read and to read the actual data */
 128#define ABIT_UGURU_CMD				0x00
 129/* Mostly used to check if uGuru is busy */
 130#define ABIT_UGURU_DATA				0x04
 131#define ABIT_UGURU_REGION_LENGTH		5
 132/* uGuru status' */
 133#define ABIT_UGURU_STATUS_WRITE			0x00 /* Ready to be written */
 134#define ABIT_UGURU_STATUS_READ			0x01 /* Ready to be read */
 135#define ABIT_UGURU_STATUS_INPUT			0x08 /* More input */
 136#define ABIT_UGURU_STATUS_READY			0x09 /* Ready to be written */
 137
 138/* Constants */
 139/* in (Volt) sensors go up to 3494 mV, temp to 255000 millidegrees Celsius */
 140static const int abituguru_bank1_max_value[2] = { 3494, 255000 };
 141/*
 142 * Min / Max allowed values for sensor2 (fan) alarm threshold, these values
 143 * correspond to 300-3000 RPM
 144 */
 145static const u8 abituguru_bank2_min_threshold = 5;
 146static const u8 abituguru_bank2_max_threshold = 50;
 147/*
 148 * Register 0 is a bitfield, 1 and 2 are pwm settings (255 = 100%), 3 and 4
 149 * are temperature trip points.
 150 */
 151static const int abituguru_pwm_settings_multiplier[5] = { 0, 1, 1, 1000, 1000 };
 152/*
 153 * Min / Max allowed values for pwm_settings. Note: pwm1 (CPU fan) is a
 154 * special case the minimum allowed pwm% setting for this is 30% (77) on
 155 * some MB's this special case is handled in the code!
 156 */
 157static const u8 abituguru_pwm_min[5] = { 0, 170, 170, 25, 25 };
 158static const u8 abituguru_pwm_max[5] = { 0, 255, 255, 75, 75 };
 159
 160
 161/* Insmod parameters */
 162static bool force;
 163module_param(force, bool, 0);
 164MODULE_PARM_DESC(force, "Set to one to force detection.");
 165static int bank1_types[ABIT_UGURU_MAX_BANK1_SENSORS] = { -1, -1, -1, -1, -1,
 166	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
 167module_param_array(bank1_types, int, NULL, 0);
 168MODULE_PARM_DESC(bank1_types, "Bank1 sensortype autodetection override:\n"
 169	"   -1 autodetect\n"
 170	"    0 volt sensor\n"
 171	"    1 temp sensor\n"
 172	"    2 not connected");
 173static int fan_sensors;
 174module_param(fan_sensors, int, 0);
 175MODULE_PARM_DESC(fan_sensors, "Number of fan sensors on the uGuru "
 176	"(0 = autodetect)");
 177static int pwms;
 178module_param(pwms, int, 0);
 179MODULE_PARM_DESC(pwms, "Number of PWMs on the uGuru "
 180	"(0 = autodetect)");
 181
 182/* Default verbose is 2, since this driver is still in the testing phase */
 183static int verbose = 2;
 184module_param(verbose, int, 0644);
 185MODULE_PARM_DESC(verbose, "How verbose should the driver be? (0-3):\n"
 186	"   0 normal output\n"
 187	"   1 + verbose error reporting\n"
 188	"   2 + sensors type probing info\n"
 189	"   3 + retryable error reporting");
 190
 191
 192/*
 193 * For the Abit uGuru, we need to keep some data in memory.
 194 * The structure is dynamically allocated, at the same time when a new
 195 * abituguru device is allocated.
 196 */
 197struct abituguru_data {
 198	struct device *hwmon_dev;	/* hwmon registered device */
 199	struct mutex update_lock;	/* protect access to data and uGuru */
 200	unsigned long last_updated;	/* In jiffies */
 201	unsigned short addr;		/* uguru base address */
 202	char uguru_ready;		/* is the uguru in ready state? */
 203	unsigned char update_timeouts;	/*
 204					 * number of update timeouts since last
 205					 * successful update
 206					 */
 207
 208	/*
 209	 * The sysfs attr and their names are generated automatically, for bank1
 210	 * we cannot use a predefined array because we don't know beforehand
 211	 * of a sensor is a volt or a temp sensor, for bank2 and the pwms its
 212	 * easier todo things the same way.  For in sensors we have 9 (temp 7)
 213	 * sysfs entries per sensor, for bank2 and pwms 6.
 214	 */
 215	struct sensor_device_attribute_2 sysfs_attr[
 216		ABIT_UGURU_MAX_BANK1_SENSORS * 9 +
 217		ABIT_UGURU_MAX_BANK2_SENSORS * 6 + ABIT_UGURU_MAX_PWMS * 6];
 218	/* Buffer to store the dynamically generated sysfs names */
 219	char sysfs_names[ABITUGURU_SYSFS_NAMES_LENGTH];
 220
 221	/* Bank 1 data */
 222	/* number of and addresses of [0] in, [1] temp sensors */
 223	u8 bank1_sensors[2];
 224	u8 bank1_address[2][ABIT_UGURU_MAX_BANK1_SENSORS];
 225	u8 bank1_value[ABIT_UGURU_MAX_BANK1_SENSORS];
 226	/*
 227	 * This array holds 3 entries per sensor for the bank 1 sensor settings
 228	 * (flags, min, max for voltage / flags, warn, shutdown for temp).
 229	 */
 230	u8 bank1_settings[ABIT_UGURU_MAX_BANK1_SENSORS][3];
 231	/*
 232	 * Maximum value for each sensor used for scaling in mV/millidegrees
 233	 * Celsius.
 234	 */
 235	int bank1_max_value[ABIT_UGURU_MAX_BANK1_SENSORS];
 236
 237	/* Bank 2 data, ABIT_UGURU_MAX_BANK2_SENSORS entries for bank2 */
 238	u8 bank2_sensors; /* actual number of bank2 sensors found */
 239	u8 bank2_value[ABIT_UGURU_MAX_BANK2_SENSORS];
 240	u8 bank2_settings[ABIT_UGURU_MAX_BANK2_SENSORS][2]; /* flags, min */
 241
 242	/* Alarms 2 bytes for bank1, 1 byte for bank2 */
 243	u8 alarms[3];
 244
 245	/* Fan PWM (speed control) 5 bytes per PWM */
 246	u8 pwms; /* actual number of pwms found */
 247	u8 pwm_settings[ABIT_UGURU_MAX_PWMS][5];
 248};
 249
 250static const char *never_happen = "This should never happen.";
 251static const char *report_this =
 252	"Please report this to the abituguru maintainer (see MAINTAINERS)";
 253
 254/* wait till the uguru is in the specified state */
 255static int abituguru_wait(struct abituguru_data *data, u8 state)
 256{
 257	int timeout = ABIT_UGURU_WAIT_TIMEOUT;
 258
 259	while (inb_p(data->addr + ABIT_UGURU_DATA) != state) {
 260		timeout--;
 261		if (timeout == 0)
 262			return -EBUSY;
 263		/*
 264		 * sleep a bit before our last few tries, see the comment on
 265		 * this where ABIT_UGURU_WAIT_TIMEOUT_SLEEP is defined.
 266		 */
 267		if (timeout <= ABIT_UGURU_WAIT_TIMEOUT_SLEEP)
 268			msleep(0);
 269	}
 270	return 0;
 271}
 272
 273/* Put the uguru in ready for input state */
 274static int abituguru_ready(struct abituguru_data *data)
 275{
 276	int timeout = ABIT_UGURU_READY_TIMEOUT;
 277
 278	if (data->uguru_ready)
 279		return 0;
 280
 281	/* Reset? / Prepare for next read/write cycle */
 282	outb(0x00, data->addr + ABIT_UGURU_DATA);
 283
 284	/* Wait till the uguru is ready */
 285	if (abituguru_wait(data, ABIT_UGURU_STATUS_READY)) {
 286		ABIT_UGURU_DEBUG(1,
 287			"timeout exceeded waiting for ready state\n");
 288		return -EIO;
 289	}
 290
 291	/* Cmd port MUST be read now and should contain 0xAC */
 292	while (inb_p(data->addr + ABIT_UGURU_CMD) != 0xAC) {
 293		timeout--;
 294		if (timeout == 0) {
 295			ABIT_UGURU_DEBUG(1,
 296			   "CMD reg does not hold 0xAC after ready command\n");
 297			return -EIO;
 298		}
 299		msleep(0);
 300	}
 301
 302	/*
 303	 * After this the ABIT_UGURU_DATA port should contain
 304	 * ABIT_UGURU_STATUS_INPUT
 305	 */
 306	timeout = ABIT_UGURU_READY_TIMEOUT;
 307	while (inb_p(data->addr + ABIT_UGURU_DATA) != ABIT_UGURU_STATUS_INPUT) {
 308		timeout--;
 309		if (timeout == 0) {
 310			ABIT_UGURU_DEBUG(1,
 311				"state != more input after ready command\n");
 312			return -EIO;
 313		}
 314		msleep(0);
 315	}
 316
 317	data->uguru_ready = 1;
 318	return 0;
 319}
 320
 321/*
 322 * Send the bank and then sensor address to the uGuru for the next read/write
 323 * cycle. This function gets called as the first part of a read/write by
 324 * abituguru_read and abituguru_write. This function should never be
 325 * called by any other function.
 326 */
 327static int abituguru_send_address(struct abituguru_data *data,
 328	u8 bank_addr, u8 sensor_addr, int retries)
 329{
 330	/*
 331	 * assume the caller does error handling itself if it has not requested
 332	 * any retries, and thus be quiet.
 333	 */
 334	int report_errors = retries;
 335
 336	for (;;) {
 337		/*
 338		 * Make sure the uguru is ready and then send the bank address,
 339		 * after this the uguru is no longer "ready".
 340		 */
 341		if (abituguru_ready(data) != 0)
 342			return -EIO;
 343		outb(bank_addr, data->addr + ABIT_UGURU_DATA);
 344		data->uguru_ready = 0;
 345
 346		/*
 347		 * Wait till the uguru is ABIT_UGURU_STATUS_INPUT state again
 348		 * and send the sensor addr
 349		 */
 350		if (abituguru_wait(data, ABIT_UGURU_STATUS_INPUT)) {
 351			if (retries) {
 352				ABIT_UGURU_DEBUG(3, "timeout exceeded "
 353					"waiting for more input state, %d "
 354					"tries remaining\n", retries);
 355				set_current_state(TASK_UNINTERRUPTIBLE);
 356				schedule_timeout(ABIT_UGURU_RETRY_DELAY);
 357				retries--;
 358				continue;
 359			}
 360			if (report_errors)
 361				ABIT_UGURU_DEBUG(1, "timeout exceeded "
 362					"waiting for more input state "
 363					"(bank: %d)\n", (int)bank_addr);
 364			return -EBUSY;
 365		}
 366		outb(sensor_addr, data->addr + ABIT_UGURU_CMD);
 367		return 0;
 368	}
 369}
 370
 371/*
 372 * Read count bytes from sensor sensor_addr in bank bank_addr and store the
 373 * result in buf, retry the send address part of the read retries times.
 374 */
 375static int abituguru_read(struct abituguru_data *data,
 376	u8 bank_addr, u8 sensor_addr, u8 *buf, int count, int retries)
 377{
 378	int i;
 379
 380	/* Send the address */
 381	i = abituguru_send_address(data, bank_addr, sensor_addr, retries);
 382	if (i)
 383		return i;
 384
 385	/* And read the data */
 386	for (i = 0; i < count; i++) {
 387		if (abituguru_wait(data, ABIT_UGURU_STATUS_READ)) {
 388			ABIT_UGURU_DEBUG(retries ? 1 : 3,
 389				"timeout exceeded waiting for "
 390				"read state (bank: %d, sensor: %d)\n",
 391				(int)bank_addr, (int)sensor_addr);
 392			break;
 393		}
 394		buf[i] = inb(data->addr + ABIT_UGURU_CMD);
 395	}
 396
 397	/* Last put the chip back in ready state */
 398	abituguru_ready(data);
 399
 400	return i;
 401}
 402
 403/*
 404 * Write count bytes from buf to sensor sensor_addr in bank bank_addr, the send
 405 * address part of the write is always retried ABIT_UGURU_MAX_RETRIES times.
 406 */
 407static int abituguru_write(struct abituguru_data *data,
 408	u8 bank_addr, u8 sensor_addr, u8 *buf, int count)
 409{
 410	/*
 411	 * We use the ready timeout as we have to wait for 0xAC just like the
 412	 * ready function
 413	 */
 414	int i, timeout = ABIT_UGURU_READY_TIMEOUT;
 415
 416	/* Send the address */
 417	i = abituguru_send_address(data, bank_addr, sensor_addr,
 418		ABIT_UGURU_MAX_RETRIES);
 419	if (i)
 420		return i;
 421
 422	/* And write the data */
 423	for (i = 0; i < count; i++) {
 424		if (abituguru_wait(data, ABIT_UGURU_STATUS_WRITE)) {
 425			ABIT_UGURU_DEBUG(1, "timeout exceeded waiting for "
 426				"write state (bank: %d, sensor: %d)\n",
 427				(int)bank_addr, (int)sensor_addr);
 428			break;
 429		}
 430		outb(buf[i], data->addr + ABIT_UGURU_CMD);
 431	}
 432
 433	/*
 434	 * Now we need to wait till the chip is ready to be read again,
 435	 * so that we can read 0xAC as confirmation that our write has
 436	 * succeeded.
 437	 */
 438	if (abituguru_wait(data, ABIT_UGURU_STATUS_READ)) {
 439		ABIT_UGURU_DEBUG(1, "timeout exceeded waiting for read state "
 440			"after write (bank: %d, sensor: %d)\n", (int)bank_addr,
 441			(int)sensor_addr);
 442		return -EIO;
 443	}
 444
 445	/* Cmd port MUST be read now and should contain 0xAC */
 446	while (inb_p(data->addr + ABIT_UGURU_CMD) != 0xAC) {
 447		timeout--;
 448		if (timeout == 0) {
 449			ABIT_UGURU_DEBUG(1, "CMD reg does not hold 0xAC after "
 450				"write (bank: %d, sensor: %d)\n",
 451				(int)bank_addr, (int)sensor_addr);
 452			return -EIO;
 453		}
 454		msleep(0);
 455	}
 456
 457	/* Last put the chip back in ready state */
 458	abituguru_ready(data);
 459
 460	return i;
 461}
 462
 463/*
 464 * Detect sensor type. Temp and Volt sensors are enabled with
 465 * different masks and will ignore enable masks not meant for them.
 466 * This enables us to test what kind of sensor we're dealing with.
 467 * By setting the alarm thresholds so that we will always get an
 468 * alarm for sensor type X and then enabling the sensor as sensor type
 469 * X, if we then get an alarm it is a sensor of type X.
 470 */
 471static int
 472abituguru_detect_bank1_sensor_type(struct abituguru_data *data,
 473				   u8 sensor_addr)
 474{
 475	u8 val, test_flag, buf[3];
 476	int i, ret = -ENODEV; /* error is the most common used retval :| */
 477
 478	/* If overriden by the user return the user selected type */
 479	if (bank1_types[sensor_addr] >= ABIT_UGURU_IN_SENSOR &&
 480			bank1_types[sensor_addr] <= ABIT_UGURU_NC) {
 481		ABIT_UGURU_DEBUG(2, "assuming sensor type %d for bank1 sensor "
 482			"%d because of \"bank1_types\" module param\n",
 483			bank1_types[sensor_addr], (int)sensor_addr);
 484		return bank1_types[sensor_addr];
 485	}
 486
 487	/* First read the sensor and the current settings */
 488	if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK1, sensor_addr, &val,
 489			1, ABIT_UGURU_MAX_RETRIES) != 1)
 490		return -ENODEV;
 491
 492	/* Test val is sane / usable for sensor type detection. */
 493	if ((val < 10u) || (val > 250u)) {
 494		pr_warn("bank1-sensor: %d reading (%d) too close to limits, "
 495			"unable to determine sensor type, skipping sensor\n",
 496			(int)sensor_addr, (int)val);
 497		/*
 498		 * assume no sensor is there for sensors for which we can't
 499		 * determine the sensor type because their reading is too close
 500		 * to their limits, this usually means no sensor is there.
 501		 */
 502		return ABIT_UGURU_NC;
 503	}
 504
 505	ABIT_UGURU_DEBUG(2, "testing bank1 sensor %d\n", (int)sensor_addr);
 506	/*
 507	 * Volt sensor test, enable volt low alarm, set min value ridiculously
 508	 * high, or vica versa if the reading is very high. If its a volt
 509	 * sensor this should always give us an alarm.
 510	 */
 511	if (val <= 240u) {
 512		buf[0] = ABIT_UGURU_VOLT_LOW_ALARM_ENABLE;
 513		buf[1] = 245;
 514		buf[2] = 250;
 515		test_flag = ABIT_UGURU_VOLT_LOW_ALARM_FLAG;
 516	} else {
 517		buf[0] = ABIT_UGURU_VOLT_HIGH_ALARM_ENABLE;
 518		buf[1] = 5;
 519		buf[2] = 10;
 520		test_flag = ABIT_UGURU_VOLT_HIGH_ALARM_FLAG;
 521	}
 522
 523	if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2, sensor_addr,
 524			buf, 3) != 3)
 525		goto abituguru_detect_bank1_sensor_type_exit;
 526	/*
 527	 * Now we need 20 ms to give the uguru time to read the sensors
 528	 * and raise a voltage alarm
 529	 */
 530	set_current_state(TASK_UNINTERRUPTIBLE);
 531	schedule_timeout(HZ/50);
 532	/* Check for alarm and check the alarm is a volt low alarm. */
 533	if (abituguru_read(data, ABIT_UGURU_ALARM_BANK, 0, buf, 3,
 534			ABIT_UGURU_MAX_RETRIES) != 3)
 535		goto abituguru_detect_bank1_sensor_type_exit;
 536	if (buf[sensor_addr/8] & (0x01 << (sensor_addr % 8))) {
 537		if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK1 + 1,
 538				sensor_addr, buf, 3,
 539				ABIT_UGURU_MAX_RETRIES) != 3)
 540			goto abituguru_detect_bank1_sensor_type_exit;
 541		if (buf[0] & test_flag) {
 542			ABIT_UGURU_DEBUG(2, "  found volt sensor\n");
 543			ret = ABIT_UGURU_IN_SENSOR;
 544			goto abituguru_detect_bank1_sensor_type_exit;
 545		} else
 546			ABIT_UGURU_DEBUG(2, "  alarm raised during volt "
 547				"sensor test, but volt range flag not set\n");
 548	} else
 549		ABIT_UGURU_DEBUG(2, "  alarm not raised during volt sensor "
 550			"test\n");
 551
 552	/*
 553	 * Temp sensor test, enable sensor as a temp sensor, set beep value
 554	 * ridiculously low (but not too low, otherwise uguru ignores it).
 555	 * If its a temp sensor this should always give us an alarm.
 556	 */
 557	buf[0] = ABIT_UGURU_TEMP_HIGH_ALARM_ENABLE;
 558	buf[1] = 5;
 559	buf[2] = 10;
 560	if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2, sensor_addr,
 561			buf, 3) != 3)
 562		goto abituguru_detect_bank1_sensor_type_exit;
 563	/*
 564	 * Now we need 50 ms to give the uguru time to read the sensors
 565	 * and raise a temp alarm
 566	 */
 567	set_current_state(TASK_UNINTERRUPTIBLE);
 568	schedule_timeout(HZ/20);
 569	/* Check for alarm and check the alarm is a temp high alarm. */
 570	if (abituguru_read(data, ABIT_UGURU_ALARM_BANK, 0, buf, 3,
 571			ABIT_UGURU_MAX_RETRIES) != 3)
 572		goto abituguru_detect_bank1_sensor_type_exit;
 573	if (buf[sensor_addr/8] & (0x01 << (sensor_addr % 8))) {
 574		if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK1 + 1,
 575				sensor_addr, buf, 3,
 576				ABIT_UGURU_MAX_RETRIES) != 3)
 577			goto abituguru_detect_bank1_sensor_type_exit;
 578		if (buf[0] & ABIT_UGURU_TEMP_HIGH_ALARM_FLAG) {
 579			ABIT_UGURU_DEBUG(2, "  found temp sensor\n");
 580			ret = ABIT_UGURU_TEMP_SENSOR;
 581			goto abituguru_detect_bank1_sensor_type_exit;
 582		} else
 583			ABIT_UGURU_DEBUG(2, "  alarm raised during temp "
 584				"sensor test, but temp high flag not set\n");
 585	} else
 586		ABIT_UGURU_DEBUG(2, "  alarm not raised during temp sensor "
 587			"test\n");
 588
 589	ret = ABIT_UGURU_NC;
 590abituguru_detect_bank1_sensor_type_exit:
 591	/*
 592	 * Restore original settings, failing here is really BAD, it has been
 593	 * reported that some BIOS-es hang when entering the uGuru menu with
 594	 * invalid settings present in the uGuru, so we try this 3 times.
 595	 */
 596	for (i = 0; i < 3; i++)
 597		if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2,
 598				sensor_addr, data->bank1_settings[sensor_addr],
 599				3) == 3)
 600			break;
 601	if (i == 3) {
 602		pr_err("Fatal error could not restore original settings. %s %s\n",
 603		       never_happen, report_this);
 604		return -ENODEV;
 605	}
 606	return ret;
 607}
 608
 609/*
 610 * These functions try to find out how many sensors there are in bank2 and how
 611 * many pwms there are. The purpose of this is to make sure that we don't give
 612 * the user the possibility to change settings for non-existent sensors / pwm.
 613 * The uGuru will happily read / write whatever memory happens to be after the
 614 * memory storing the PWM settings when reading/writing to a PWM which is not
 615 * there. Notice even if we detect a PWM which doesn't exist we normally won't
 616 * write to it, unless the user tries to change the settings.
 617 *
 618 * Although the uGuru allows reading (settings) from non existing bank2
 619 * sensors, my version of the uGuru does seem to stop writing to them, the
 620 * write function above aborts in this case with:
 621 * "CMD reg does not hold 0xAC after write"
 622 *
 623 * Notice these 2 tests are non destructive iow read-only tests, otherwise
 624 * they would defeat their purpose. Although for the bank2_sensors detection a
 625 * read/write test would be feasible because of the reaction above, I've
 626 * however opted to stay on the safe side.
 627 */
 628static void
 629abituguru_detect_no_bank2_sensors(struct abituguru_data *data)
 630{
 631	int i;
 632
 633	if (fan_sensors > 0 && fan_sensors <= ABIT_UGURU_MAX_BANK2_SENSORS) {
 634		data->bank2_sensors = fan_sensors;
 635		ABIT_UGURU_DEBUG(2, "assuming %d fan sensors because of "
 636			"\"fan_sensors\" module param\n",
 637			(int)data->bank2_sensors);
 638		return;
 639	}
 640
 641	ABIT_UGURU_DEBUG(2, "detecting number of fan sensors\n");
 642	for (i = 0; i < ABIT_UGURU_MAX_BANK2_SENSORS; i++) {
 643		/*
 644		 * 0x89 are the known used bits:
 645		 * -0x80 enable shutdown
 646		 * -0x08 enable beep
 647		 * -0x01 enable alarm
 648		 * All other bits should be 0, but on some motherboards
 649		 * 0x40 (bit 6) is also high for some of the fans??
 650		 */
 651		if (data->bank2_settings[i][0] & ~0xC9) {
 652			ABIT_UGURU_DEBUG(2, "  bank2 sensor %d does not seem "
 653				"to be a fan sensor: settings[0] = %02X\n",
 654				i, (unsigned int)data->bank2_settings[i][0]);
 655			break;
 656		}
 657
 658		/* check if the threshold is within the allowed range */
 659		if (data->bank2_settings[i][1] <
 660				abituguru_bank2_min_threshold) {
 661			ABIT_UGURU_DEBUG(2, "  bank2 sensor %d does not seem "
 662				"to be a fan sensor: the threshold (%d) is "
 663				"below the minimum (%d)\n", i,
 664				(int)data->bank2_settings[i][1],
 665				(int)abituguru_bank2_min_threshold);
 666			break;
 667		}
 668		if (data->bank2_settings[i][1] >
 669				abituguru_bank2_max_threshold) {
 670			ABIT_UGURU_DEBUG(2, "  bank2 sensor %d does not seem "
 671				"to be a fan sensor: the threshold (%d) is "
 672				"above the maximum (%d)\n", i,
 673				(int)data->bank2_settings[i][1],
 674				(int)abituguru_bank2_max_threshold);
 675			break;
 676		}
 677	}
 678
 679	data->bank2_sensors = i;
 680	ABIT_UGURU_DEBUG(2, " found: %d fan sensors\n",
 681		(int)data->bank2_sensors);
 682}
 683
 684static void
 685abituguru_detect_no_pwms(struct abituguru_data *data)
 686{
 687	int i, j;
 688
 689	if (pwms > 0 && pwms <= ABIT_UGURU_MAX_PWMS) {
 690		data->pwms = pwms;
 691		ABIT_UGURU_DEBUG(2, "assuming %d PWM outputs because of "
 692			"\"pwms\" module param\n", (int)data->pwms);
 693		return;
 694	}
 695
 696	ABIT_UGURU_DEBUG(2, "detecting number of PWM outputs\n");
 697	for (i = 0; i < ABIT_UGURU_MAX_PWMS; i++) {
 698		/*
 699		 * 0x80 is the enable bit and the low
 700		 * nibble is which temp sensor to use,
 701		 * the other bits should be 0
 702		 */
 703		if (data->pwm_settings[i][0] & ~0x8F) {
 704			ABIT_UGURU_DEBUG(2, "  pwm channel %d does not seem "
 705				"to be a pwm channel: settings[0] = %02X\n",
 706				i, (unsigned int)data->pwm_settings[i][0]);
 707			break;
 708		}
 709
 710		/*
 711		 * the low nibble must correspond to one of the temp sensors
 712		 * we've found
 713		 */
 714		for (j = 0; j < data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR];
 715				j++) {
 716			if (data->bank1_address[ABIT_UGURU_TEMP_SENSOR][j] ==
 717					(data->pwm_settings[i][0] & 0x0F))
 718				break;
 719		}
 720		if (j == data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR]) {
 721			ABIT_UGURU_DEBUG(2, "  pwm channel %d does not seem "
 722				"to be a pwm channel: %d is not a valid temp "
 723				"sensor address\n", i,
 724				data->pwm_settings[i][0] & 0x0F);
 725			break;
 726		}
 727
 728		/* check if all other settings are within the allowed range */
 729		for (j = 1; j < 5; j++) {
 730			u8 min;
 731			/* special case pwm1 min pwm% */
 732			if ((i == 0) && ((j == 1) || (j == 2)))
 733				min = 77;
 734			else
 735				min = abituguru_pwm_min[j];
 736			if (data->pwm_settings[i][j] < min) {
 737				ABIT_UGURU_DEBUG(2, "  pwm channel %d does "
 738					"not seem to be a pwm channel: "
 739					"setting %d (%d) is below the minimum "
 740					"value (%d)\n", i, j,
 741					(int)data->pwm_settings[i][j],
 742					(int)min);
 743				goto abituguru_detect_no_pwms_exit;
 744			}
 745			if (data->pwm_settings[i][j] > abituguru_pwm_max[j]) {
 746				ABIT_UGURU_DEBUG(2, "  pwm channel %d does "
 747					"not seem to be a pwm channel: "
 748					"setting %d (%d) is above the maximum "
 749					"value (%d)\n", i, j,
 750					(int)data->pwm_settings[i][j],
 751					(int)abituguru_pwm_max[j]);
 752				goto abituguru_detect_no_pwms_exit;
 753			}
 754		}
 755
 756		/* check that min temp < max temp and min pwm < max pwm */
 757		if (data->pwm_settings[i][1] >= data->pwm_settings[i][2]) {
 758			ABIT_UGURU_DEBUG(2, "  pwm channel %d does not seem "
 759				"to be a pwm channel: min pwm (%d) >= "
 760				"max pwm (%d)\n", i,
 761				(int)data->pwm_settings[i][1],
 762				(int)data->pwm_settings[i][2]);
 763			break;
 764		}
 765		if (data->pwm_settings[i][3] >= data->pwm_settings[i][4]) {
 766			ABIT_UGURU_DEBUG(2, "  pwm channel %d does not seem "
 767				"to be a pwm channel: min temp (%d) >= "
 768				"max temp (%d)\n", i,
 769				(int)data->pwm_settings[i][3],
 770				(int)data->pwm_settings[i][4]);
 771			break;
 772		}
 773	}
 774
 775abituguru_detect_no_pwms_exit:
 776	data->pwms = i;
 777	ABIT_UGURU_DEBUG(2, " found: %d PWM outputs\n", (int)data->pwms);
 778}
 779
 780/*
 781 * Following are the sysfs callback functions. These functions expect:
 782 * sensor_device_attribute_2->index:   sensor address/offset in the bank
 783 * sensor_device_attribute_2->nr:      register offset, bitmask or NA.
 784 */
 785static struct abituguru_data *abituguru_update_device(struct device *dev);
 786
 787static ssize_t show_bank1_value(struct device *dev,
 788	struct device_attribute *devattr, char *buf)
 789{
 790	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 791	struct abituguru_data *data = abituguru_update_device(dev);
 792	if (!data)
 793		return -EIO;
 794	return sprintf(buf, "%d\n", (data->bank1_value[attr->index] *
 795		data->bank1_max_value[attr->index] + 128) / 255);
 796}
 797
 798static ssize_t show_bank1_setting(struct device *dev,
 799	struct device_attribute *devattr, char *buf)
 800{
 801	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 802	struct abituguru_data *data = dev_get_drvdata(dev);
 803	return sprintf(buf, "%d\n",
 804		(data->bank1_settings[attr->index][attr->nr] *
 805		data->bank1_max_value[attr->index] + 128) / 255);
 806}
 807
 808static ssize_t show_bank2_value(struct device *dev,
 809	struct device_attribute *devattr, char *buf)
 810{
 811	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 812	struct abituguru_data *data = abituguru_update_device(dev);
 813	if (!data)
 814		return -EIO;
 815	return sprintf(buf, "%d\n", (data->bank2_value[attr->index] *
 816		ABIT_UGURU_FAN_MAX + 128) / 255);
 817}
 818
 819static ssize_t show_bank2_setting(struct device *dev,
 820	struct device_attribute *devattr, char *buf)
 821{
 822	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 823	struct abituguru_data *data = dev_get_drvdata(dev);
 824	return sprintf(buf, "%d\n",
 825		(data->bank2_settings[attr->index][attr->nr] *
 826		ABIT_UGURU_FAN_MAX + 128) / 255);
 827}
 828
 829static ssize_t store_bank1_setting(struct device *dev, struct device_attribute
 830	*devattr, const char *buf, size_t count)
 831{
 832	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 833	struct abituguru_data *data = dev_get_drvdata(dev);
 834	unsigned long val;
 835	ssize_t ret;
 836
 837	ret = kstrtoul(buf, 10, &val);
 838	if (ret)
 839		return ret;
 840
 841	ret = count;
 842	val = (val * 255 + data->bank1_max_value[attr->index] / 2) /
 843		data->bank1_max_value[attr->index];
 844	if (val > 255)
 845		return -EINVAL;
 846
 847	mutex_lock(&data->update_lock);
 848	if (data->bank1_settings[attr->index][attr->nr] != val) {
 849		u8 orig_val = data->bank1_settings[attr->index][attr->nr];
 850		data->bank1_settings[attr->index][attr->nr] = val;
 851		if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK1 + 2,
 852				attr->index, data->bank1_settings[attr->index],
 853				3) <= attr->nr) {
 854			data->bank1_settings[attr->index][attr->nr] = orig_val;
 855			ret = -EIO;
 856		}
 857	}
 858	mutex_unlock(&data->update_lock);
 859	return ret;
 860}
 861
 862static ssize_t store_bank2_setting(struct device *dev, struct device_attribute
 863	*devattr, const char *buf, size_t count)
 864{
 865	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 866	struct abituguru_data *data = dev_get_drvdata(dev);
 867	unsigned long val;
 868	ssize_t ret;
 869
 870	ret = kstrtoul(buf, 10, &val);
 871	if (ret)
 872		return ret;
 873
 874	ret = count;
 875	val = (val * 255 + ABIT_UGURU_FAN_MAX / 2) / ABIT_UGURU_FAN_MAX;
 876
 877	/* this check can be done before taking the lock */
 878	if (val < abituguru_bank2_min_threshold ||
 879			val > abituguru_bank2_max_threshold)
 880		return -EINVAL;
 881
 882	mutex_lock(&data->update_lock);
 883	if (data->bank2_settings[attr->index][attr->nr] != val) {
 884		u8 orig_val = data->bank2_settings[attr->index][attr->nr];
 885		data->bank2_settings[attr->index][attr->nr] = val;
 886		if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK2 + 2,
 887				attr->index, data->bank2_settings[attr->index],
 888				2) <= attr->nr) {
 889			data->bank2_settings[attr->index][attr->nr] = orig_val;
 890			ret = -EIO;
 891		}
 892	}
 893	mutex_unlock(&data->update_lock);
 894	return ret;
 895}
 896
 897static ssize_t show_bank1_alarm(struct device *dev,
 898	struct device_attribute *devattr, char *buf)
 899{
 900	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 901	struct abituguru_data *data = abituguru_update_device(dev);
 902	if (!data)
 903		return -EIO;
 904	/*
 905	 * See if the alarm bit for this sensor is set, and if the
 906	 * alarm matches the type of alarm we're looking for (for volt
 907	 * it can be either low or high). The type is stored in a few
 908	 * readonly bits in the settings part of the relevant sensor.
 909	 * The bitmask of the type is passed to us in attr->nr.
 910	 */
 911	if ((data->alarms[attr->index / 8] & (0x01 << (attr->index % 8))) &&
 912			(data->bank1_settings[attr->index][0] & attr->nr))
 913		return sprintf(buf, "1\n");
 914	else
 915		return sprintf(buf, "0\n");
 916}
 917
 918static ssize_t show_bank2_alarm(struct device *dev,
 919	struct device_attribute *devattr, char *buf)
 920{
 921	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 922	struct abituguru_data *data = abituguru_update_device(dev);
 923	if (!data)
 924		return -EIO;
 925	if (data->alarms[2] & (0x01 << attr->index))
 926		return sprintf(buf, "1\n");
 927	else
 928		return sprintf(buf, "0\n");
 929}
 930
 931static ssize_t show_bank1_mask(struct device *dev,
 932	struct device_attribute *devattr, char *buf)
 933{
 934	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 935	struct abituguru_data *data = dev_get_drvdata(dev);
 936	if (data->bank1_settings[attr->index][0] & attr->nr)
 937		return sprintf(buf, "1\n");
 938	else
 939		return sprintf(buf, "0\n");
 940}
 941
 942static ssize_t show_bank2_mask(struct device *dev,
 943	struct device_attribute *devattr, char *buf)
 944{
 945	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 946	struct abituguru_data *data = dev_get_drvdata(dev);
 947	if (data->bank2_settings[attr->index][0] & attr->nr)
 948		return sprintf(buf, "1\n");
 949	else
 950		return sprintf(buf, "0\n");
 951}
 952
 953static ssize_t store_bank1_mask(struct device *dev,
 954	struct device_attribute *devattr, const char *buf, size_t count)
 955{
 956	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 957	struct abituguru_data *data = dev_get_drvdata(dev);
 958	ssize_t ret;
 
 959	u8 orig_val;
 960	unsigned long mask;
 961
 962	ret = kstrtoul(buf, 10, &mask);
 963	if (ret)
 964		return ret;
 965
 966	ret = count;
 967	mutex_lock(&data->update_lock);
 968	orig_val = data->bank1_settings[attr->index][0];
 969
 970	if (mask)
 971		data->bank1_settings[attr->index][0] |= attr->nr;
 972	else
 973		data->bank1_settings[attr->index][0] &= ~attr->nr;
 974
 975	if ((data->bank1_settings[attr->index][0] != orig_val) &&
 976			(abituguru_write(data,
 977			ABIT_UGURU_SENSOR_BANK1 + 2, attr->index,
 978			data->bank1_settings[attr->index], 3) < 1)) {
 979		data->bank1_settings[attr->index][0] = orig_val;
 980		ret = -EIO;
 981	}
 982	mutex_unlock(&data->update_lock);
 983	return ret;
 984}
 985
 986static ssize_t store_bank2_mask(struct device *dev,
 987	struct device_attribute *devattr, const char *buf, size_t count)
 988{
 989	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 990	struct abituguru_data *data = dev_get_drvdata(dev);
 991	ssize_t ret;
 
 992	u8 orig_val;
 993	unsigned long mask;
 994
 995	ret = kstrtoul(buf, 10, &mask);
 996	if (ret)
 997		return ret;
 998
 999	ret = count;
1000	mutex_lock(&data->update_lock);
1001	orig_val = data->bank2_settings[attr->index][0];
1002
1003	if (mask)
1004		data->bank2_settings[attr->index][0] |= attr->nr;
1005	else
1006		data->bank2_settings[attr->index][0] &= ~attr->nr;
1007
1008	if ((data->bank2_settings[attr->index][0] != orig_val) &&
1009			(abituguru_write(data,
1010			ABIT_UGURU_SENSOR_BANK2 + 2, attr->index,
1011			data->bank2_settings[attr->index], 2) < 1)) {
1012		data->bank2_settings[attr->index][0] = orig_val;
1013		ret = -EIO;
1014	}
1015	mutex_unlock(&data->update_lock);
1016	return ret;
1017}
1018
1019/* Fan PWM (speed control) */
1020static ssize_t show_pwm_setting(struct device *dev,
1021	struct device_attribute *devattr, char *buf)
1022{
1023	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
1024	struct abituguru_data *data = dev_get_drvdata(dev);
1025	return sprintf(buf, "%d\n", data->pwm_settings[attr->index][attr->nr] *
1026		abituguru_pwm_settings_multiplier[attr->nr]);
1027}
1028
1029static ssize_t store_pwm_setting(struct device *dev, struct device_attribute
1030	*devattr, const char *buf, size_t count)
1031{
1032	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
1033	struct abituguru_data *data = dev_get_drvdata(dev);
1034	u8 min;
1035	unsigned long val;
1036	ssize_t ret;
1037
1038	ret = kstrtoul(buf, 10, &val);
1039	if (ret)
1040		return ret;
1041
1042	ret = count;
1043	val = (val + abituguru_pwm_settings_multiplier[attr->nr] / 2) /
1044				abituguru_pwm_settings_multiplier[attr->nr];
1045
1046	/* special case pwm1 min pwm% */
1047	if ((attr->index == 0) && ((attr->nr == 1) || (attr->nr == 2)))
1048		min = 77;
1049	else
1050		min = abituguru_pwm_min[attr->nr];
1051
1052	/* this check can be done before taking the lock */
1053	if (val < min || val > abituguru_pwm_max[attr->nr])
1054		return -EINVAL;
1055
1056	mutex_lock(&data->update_lock);
1057	/* this check needs to be done after taking the lock */
1058	if ((attr->nr & 1) &&
1059			(val >= data->pwm_settings[attr->index][attr->nr + 1]))
1060		ret = -EINVAL;
1061	else if (!(attr->nr & 1) &&
1062			(val <= data->pwm_settings[attr->index][attr->nr - 1]))
1063		ret = -EINVAL;
1064	else if (data->pwm_settings[attr->index][attr->nr] != val) {
1065		u8 orig_val = data->pwm_settings[attr->index][attr->nr];
1066		data->pwm_settings[attr->index][attr->nr] = val;
1067		if (abituguru_write(data, ABIT_UGURU_FAN_PWM + 1,
1068				attr->index, data->pwm_settings[attr->index],
1069				5) <= attr->nr) {
1070			data->pwm_settings[attr->index][attr->nr] =
1071				orig_val;
1072			ret = -EIO;
1073		}
1074	}
1075	mutex_unlock(&data->update_lock);
1076	return ret;
1077}
1078
1079static ssize_t show_pwm_sensor(struct device *dev,
1080	struct device_attribute *devattr, char *buf)
1081{
1082	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
1083	struct abituguru_data *data = dev_get_drvdata(dev);
1084	int i;
1085	/*
1086	 * We need to walk to the temp sensor addresses to find what
1087	 * the userspace id of the configured temp sensor is.
1088	 */
1089	for (i = 0; i < data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR]; i++)
1090		if (data->bank1_address[ABIT_UGURU_TEMP_SENSOR][i] ==
1091				(data->pwm_settings[attr->index][0] & 0x0F))
1092			return sprintf(buf, "%d\n", i+1);
1093
1094	return -ENXIO;
1095}
1096
1097static ssize_t store_pwm_sensor(struct device *dev, struct device_attribute
1098	*devattr, const char *buf, size_t count)
1099{
1100	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
1101	struct abituguru_data *data = dev_get_drvdata(dev);
1102	ssize_t ret;
1103	unsigned long val;
1104	u8 orig_val;
1105	u8 address;
1106
1107	ret = kstrtoul(buf, 10, &val);
1108	if (ret)
1109		return ret;
1110
1111	if (val == 0 || val > data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR])
1112		return -EINVAL;
1113
1114	val -= 1;
1115	ret = count;
1116	mutex_lock(&data->update_lock);
1117	orig_val = data->pwm_settings[attr->index][0];
1118	address = data->bank1_address[ABIT_UGURU_TEMP_SENSOR][val];
1119	data->pwm_settings[attr->index][0] &= 0xF0;
1120	data->pwm_settings[attr->index][0] |= address;
1121	if (data->pwm_settings[attr->index][0] != orig_val) {
1122		if (abituguru_write(data, ABIT_UGURU_FAN_PWM + 1, attr->index,
1123				    data->pwm_settings[attr->index], 5) < 1) {
1124			data->pwm_settings[attr->index][0] = orig_val;
1125			ret = -EIO;
 
 
 
 
1126		}
1127	}
 
 
1128	mutex_unlock(&data->update_lock);
1129	return ret;
1130}
1131
1132static ssize_t show_pwm_enable(struct device *dev,
1133	struct device_attribute *devattr, char *buf)
1134{
1135	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
1136	struct abituguru_data *data = dev_get_drvdata(dev);
1137	int res = 0;
1138	if (data->pwm_settings[attr->index][0] & ABIT_UGURU_FAN_PWM_ENABLE)
1139		res = 2;
1140	return sprintf(buf, "%d\n", res);
1141}
1142
1143static ssize_t store_pwm_enable(struct device *dev, struct device_attribute
1144	*devattr, const char *buf, size_t count)
1145{
1146	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
1147	struct abituguru_data *data = dev_get_drvdata(dev);
1148	u8 orig_val;
1149	ssize_t ret;
1150	unsigned long user_val;
1151
1152	ret = kstrtoul(buf, 10, &user_val);
1153	if (ret)
1154		return ret;
1155
1156	ret = count;
1157	mutex_lock(&data->update_lock);
1158	orig_val = data->pwm_settings[attr->index][0];
1159	switch (user_val) {
1160	case 0:
1161		data->pwm_settings[attr->index][0] &=
1162			~ABIT_UGURU_FAN_PWM_ENABLE;
1163		break;
1164	case 2:
1165		data->pwm_settings[attr->index][0] |= ABIT_UGURU_FAN_PWM_ENABLE;
1166		break;
1167	default:
1168		ret = -EINVAL;
 
1169	}
1170	if ((data->pwm_settings[attr->index][0] != orig_val) &&
1171			(abituguru_write(data, ABIT_UGURU_FAN_PWM + 1,
1172			attr->index, data->pwm_settings[attr->index],
1173			5) < 1)) {
1174		data->pwm_settings[attr->index][0] = orig_val;
1175		ret = -EIO;
1176	}
1177	mutex_unlock(&data->update_lock);
1178	return ret;
1179}
1180
1181static ssize_t show_name(struct device *dev,
1182	struct device_attribute *devattr, char *buf)
1183{
1184	return sprintf(buf, "%s\n", ABIT_UGURU_NAME);
1185}
1186
1187/* Sysfs attr templates, the real entries are generated automatically. */
1188static const
1189struct sensor_device_attribute_2 abituguru_sysfs_bank1_templ[2][9] = {
1190	{
1191	SENSOR_ATTR_2(in%d_input, 0444, show_bank1_value, NULL, 0, 0),
1192	SENSOR_ATTR_2(in%d_min, 0644, show_bank1_setting,
1193		store_bank1_setting, 1, 0),
1194	SENSOR_ATTR_2(in%d_min_alarm, 0444, show_bank1_alarm, NULL,
1195		ABIT_UGURU_VOLT_LOW_ALARM_FLAG, 0),
1196	SENSOR_ATTR_2(in%d_max, 0644, show_bank1_setting,
1197		store_bank1_setting, 2, 0),
1198	SENSOR_ATTR_2(in%d_max_alarm, 0444, show_bank1_alarm, NULL,
1199		ABIT_UGURU_VOLT_HIGH_ALARM_FLAG, 0),
1200	SENSOR_ATTR_2(in%d_beep, 0644, show_bank1_mask,
1201		store_bank1_mask, ABIT_UGURU_BEEP_ENABLE, 0),
1202	SENSOR_ATTR_2(in%d_shutdown, 0644, show_bank1_mask,
1203		store_bank1_mask, ABIT_UGURU_SHUTDOWN_ENABLE, 0),
1204	SENSOR_ATTR_2(in%d_min_alarm_enable, 0644, show_bank1_mask,
1205		store_bank1_mask, ABIT_UGURU_VOLT_LOW_ALARM_ENABLE, 0),
1206	SENSOR_ATTR_2(in%d_max_alarm_enable, 0644, show_bank1_mask,
1207		store_bank1_mask, ABIT_UGURU_VOLT_HIGH_ALARM_ENABLE, 0),
1208	}, {
1209	SENSOR_ATTR_2(temp%d_input, 0444, show_bank1_value, NULL, 0, 0),
1210	SENSOR_ATTR_2(temp%d_alarm, 0444, show_bank1_alarm, NULL,
1211		ABIT_UGURU_TEMP_HIGH_ALARM_FLAG, 0),
1212	SENSOR_ATTR_2(temp%d_max, 0644, show_bank1_setting,
1213		store_bank1_setting, 1, 0),
1214	SENSOR_ATTR_2(temp%d_crit, 0644, show_bank1_setting,
1215		store_bank1_setting, 2, 0),
1216	SENSOR_ATTR_2(temp%d_beep, 0644, show_bank1_mask,
1217		store_bank1_mask, ABIT_UGURU_BEEP_ENABLE, 0),
1218	SENSOR_ATTR_2(temp%d_shutdown, 0644, show_bank1_mask,
1219		store_bank1_mask, ABIT_UGURU_SHUTDOWN_ENABLE, 0),
1220	SENSOR_ATTR_2(temp%d_alarm_enable, 0644, show_bank1_mask,
1221		store_bank1_mask, ABIT_UGURU_TEMP_HIGH_ALARM_ENABLE, 0),
1222	}
1223};
1224
1225static const struct sensor_device_attribute_2 abituguru_sysfs_fan_templ[6] = {
1226	SENSOR_ATTR_2(fan%d_input, 0444, show_bank2_value, NULL, 0, 0),
1227	SENSOR_ATTR_2(fan%d_alarm, 0444, show_bank2_alarm, NULL, 0, 0),
1228	SENSOR_ATTR_2(fan%d_min, 0644, show_bank2_setting,
1229		store_bank2_setting, 1, 0),
1230	SENSOR_ATTR_2(fan%d_beep, 0644, show_bank2_mask,
1231		store_bank2_mask, ABIT_UGURU_BEEP_ENABLE, 0),
1232	SENSOR_ATTR_2(fan%d_shutdown, 0644, show_bank2_mask,
1233		store_bank2_mask, ABIT_UGURU_SHUTDOWN_ENABLE, 0),
1234	SENSOR_ATTR_2(fan%d_alarm_enable, 0644, show_bank2_mask,
1235		store_bank2_mask, ABIT_UGURU_FAN_LOW_ALARM_ENABLE, 0),
1236};
1237
1238static const struct sensor_device_attribute_2 abituguru_sysfs_pwm_templ[6] = {
1239	SENSOR_ATTR_2(pwm%d_enable, 0644, show_pwm_enable,
1240		store_pwm_enable, 0, 0),
1241	SENSOR_ATTR_2(pwm%d_auto_channels_temp, 0644, show_pwm_sensor,
1242		store_pwm_sensor, 0, 0),
1243	SENSOR_ATTR_2(pwm%d_auto_point1_pwm, 0644, show_pwm_setting,
1244		store_pwm_setting, 1, 0),
1245	SENSOR_ATTR_2(pwm%d_auto_point2_pwm, 0644, show_pwm_setting,
1246		store_pwm_setting, 2, 0),
1247	SENSOR_ATTR_2(pwm%d_auto_point1_temp, 0644, show_pwm_setting,
1248		store_pwm_setting, 3, 0),
1249	SENSOR_ATTR_2(pwm%d_auto_point2_temp, 0644, show_pwm_setting,
1250		store_pwm_setting, 4, 0),
1251};
1252
1253static struct sensor_device_attribute_2 abituguru_sysfs_attr[] = {
1254	SENSOR_ATTR_2(name, 0444, show_name, NULL, 0, 0),
1255};
1256
1257static int abituguru_probe(struct platform_device *pdev)
1258{
1259	struct abituguru_data *data;
1260	int i, j, used, sysfs_names_free, sysfs_attr_i, res = -ENODEV;
1261	char *sysfs_filename;
1262
1263	/*
1264	 * El weirdo probe order, to keep the sysfs order identical to the
1265	 * BIOS and window-appliction listing order.
1266	 */
1267	static const u8 probe_order[ABIT_UGURU_MAX_BANK1_SENSORS] = {
1268		0x00, 0x01, 0x03, 0x04, 0x0A, 0x08, 0x0E, 0x02,
1269		0x09, 0x06, 0x05, 0x0B, 0x0F, 0x0D, 0x07, 0x0C };
1270
1271	data = devm_kzalloc(&pdev->dev, sizeof(struct abituguru_data),
1272			    GFP_KERNEL);
1273	if (!data)
1274		return -ENOMEM;
1275
1276	data->addr = platform_get_resource(pdev, IORESOURCE_IO, 0)->start;
1277	mutex_init(&data->update_lock);
1278	platform_set_drvdata(pdev, data);
1279
1280	/* See if the uGuru is ready */
1281	if (inb_p(data->addr + ABIT_UGURU_DATA) == ABIT_UGURU_STATUS_INPUT)
1282		data->uguru_ready = 1;
1283
1284	/*
1285	 * Completely read the uGuru this has 2 purposes:
1286	 * - testread / see if one really is there.
1287	 * - make an in memory copy of all the uguru settings for future use.
1288	 */
1289	if (abituguru_read(data, ABIT_UGURU_ALARM_BANK, 0,
1290			data->alarms, 3, ABIT_UGURU_MAX_RETRIES) != 3)
1291		goto abituguru_probe_error;
1292
1293	for (i = 0; i < ABIT_UGURU_MAX_BANK1_SENSORS; i++) {
1294		if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK1, i,
1295				&data->bank1_value[i], 1,
1296				ABIT_UGURU_MAX_RETRIES) != 1)
1297			goto abituguru_probe_error;
1298		if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK1+1, i,
1299				data->bank1_settings[i], 3,
1300				ABIT_UGURU_MAX_RETRIES) != 3)
1301			goto abituguru_probe_error;
1302	}
1303	/*
1304	 * Note: We don't know how many bank2 sensors / pwms there really are,
1305	 * but in order to "detect" this we need to read the maximum amount
1306	 * anyways. If we read sensors/pwms not there we'll just read crap
1307	 * this can't hurt. We need the detection because we don't want
1308	 * unwanted writes, which will hurt!
1309	 */
1310	for (i = 0; i < ABIT_UGURU_MAX_BANK2_SENSORS; i++) {
1311		if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK2, i,
1312				&data->bank2_value[i], 1,
1313				ABIT_UGURU_MAX_RETRIES) != 1)
1314			goto abituguru_probe_error;
1315		if (abituguru_read(data, ABIT_UGURU_SENSOR_BANK2+1, i,
1316				data->bank2_settings[i], 2,
1317				ABIT_UGURU_MAX_RETRIES) != 2)
1318			goto abituguru_probe_error;
1319	}
1320	for (i = 0; i < ABIT_UGURU_MAX_PWMS; i++) {
1321		if (abituguru_read(data, ABIT_UGURU_FAN_PWM, i,
1322				data->pwm_settings[i], 5,
1323				ABIT_UGURU_MAX_RETRIES) != 5)
1324			goto abituguru_probe_error;
1325	}
1326	data->last_updated = jiffies;
1327
1328	/* Detect sensor types and fill the sysfs attr for bank1 */
1329	sysfs_attr_i = 0;
1330	sysfs_filename = data->sysfs_names;
1331	sysfs_names_free = ABITUGURU_SYSFS_NAMES_LENGTH;
1332	for (i = 0; i < ABIT_UGURU_MAX_BANK1_SENSORS; i++) {
1333		res = abituguru_detect_bank1_sensor_type(data, probe_order[i]);
1334		if (res < 0)
1335			goto abituguru_probe_error;
1336		if (res == ABIT_UGURU_NC)
1337			continue;
1338
1339		/* res 1 (temp) sensors have 7 sysfs entries, 0 (in) 9 */
1340		for (j = 0; j < (res ? 7 : 9); j++) {
1341			used = snprintf(sysfs_filename, sysfs_names_free,
1342				abituguru_sysfs_bank1_templ[res][j].dev_attr.
1343				attr.name, data->bank1_sensors[res] + res)
1344				+ 1;
1345			data->sysfs_attr[sysfs_attr_i] =
1346				abituguru_sysfs_bank1_templ[res][j];
1347			data->sysfs_attr[sysfs_attr_i].dev_attr.attr.name =
1348				sysfs_filename;
1349			data->sysfs_attr[sysfs_attr_i].index = probe_order[i];
1350			sysfs_filename += used;
1351			sysfs_names_free -= used;
1352			sysfs_attr_i++;
1353		}
1354		data->bank1_max_value[probe_order[i]] =
1355			abituguru_bank1_max_value[res];
1356		data->bank1_address[res][data->bank1_sensors[res]] =
1357			probe_order[i];
1358		data->bank1_sensors[res]++;
1359	}
1360	/* Detect number of sensors and fill the sysfs attr for bank2 (fans) */
1361	abituguru_detect_no_bank2_sensors(data);
1362	for (i = 0; i < data->bank2_sensors; i++) {
1363		for (j = 0; j < ARRAY_SIZE(abituguru_sysfs_fan_templ); j++) {
1364			used = snprintf(sysfs_filename, sysfs_names_free,
1365				abituguru_sysfs_fan_templ[j].dev_attr.attr.name,
1366				i + 1) + 1;
1367			data->sysfs_attr[sysfs_attr_i] =
1368				abituguru_sysfs_fan_templ[j];
1369			data->sysfs_attr[sysfs_attr_i].dev_attr.attr.name =
1370				sysfs_filename;
1371			data->sysfs_attr[sysfs_attr_i].index = i;
1372			sysfs_filename += used;
1373			sysfs_names_free -= used;
1374			sysfs_attr_i++;
1375		}
1376	}
1377	/* Detect number of sensors and fill the sysfs attr for pwms */
1378	abituguru_detect_no_pwms(data);
1379	for (i = 0; i < data->pwms; i++) {
1380		for (j = 0; j < ARRAY_SIZE(abituguru_sysfs_pwm_templ); j++) {
1381			used = snprintf(sysfs_filename, sysfs_names_free,
1382				abituguru_sysfs_pwm_templ[j].dev_attr.attr.name,
1383				i + 1) + 1;
1384			data->sysfs_attr[sysfs_attr_i] =
1385				abituguru_sysfs_pwm_templ[j];
1386			data->sysfs_attr[sysfs_attr_i].dev_attr.attr.name =
1387				sysfs_filename;
1388			data->sysfs_attr[sysfs_attr_i].index = i;
1389			sysfs_filename += used;
1390			sysfs_names_free -= used;
1391			sysfs_attr_i++;
1392		}
1393	}
1394	/* Fail safe check, this should never happen! */
1395	if (sysfs_names_free < 0) {
1396		pr_err("Fatal error ran out of space for sysfs attr names. %s %s",
1397		       never_happen, report_this);
1398		res = -ENAMETOOLONG;
1399		goto abituguru_probe_error;
1400	}
1401	pr_info("found Abit uGuru\n");
1402
1403	/* Register sysfs hooks */
1404	for (i = 0; i < sysfs_attr_i; i++) {
1405		res = device_create_file(&pdev->dev,
1406					 &data->sysfs_attr[i].dev_attr);
1407		if (res)
1408			goto abituguru_probe_error;
1409	}
1410	for (i = 0; i < ARRAY_SIZE(abituguru_sysfs_attr); i++) {
1411		res = device_create_file(&pdev->dev,
1412					 &abituguru_sysfs_attr[i].dev_attr);
1413		if (res)
1414			goto abituguru_probe_error;
1415	}
1416
1417	data->hwmon_dev = hwmon_device_register(&pdev->dev);
1418	if (!IS_ERR(data->hwmon_dev))
1419		return 0; /* success */
1420
1421	res = PTR_ERR(data->hwmon_dev);
1422abituguru_probe_error:
1423	for (i = 0; data->sysfs_attr[i].dev_attr.attr.name; i++)
1424		device_remove_file(&pdev->dev, &data->sysfs_attr[i].dev_attr);
1425	for (i = 0; i < ARRAY_SIZE(abituguru_sysfs_attr); i++)
1426		device_remove_file(&pdev->dev,
1427			&abituguru_sysfs_attr[i].dev_attr);
 
 
1428	return res;
1429}
1430
1431static int abituguru_remove(struct platform_device *pdev)
1432{
1433	int i;
1434	struct abituguru_data *data = platform_get_drvdata(pdev);
1435
1436	hwmon_device_unregister(data->hwmon_dev);
1437	for (i = 0; data->sysfs_attr[i].dev_attr.attr.name; i++)
1438		device_remove_file(&pdev->dev, &data->sysfs_attr[i].dev_attr);
1439	for (i = 0; i < ARRAY_SIZE(abituguru_sysfs_attr); i++)
1440		device_remove_file(&pdev->dev,
1441			&abituguru_sysfs_attr[i].dev_attr);
 
 
1442
1443	return 0;
1444}
1445
1446static struct abituguru_data *abituguru_update_device(struct device *dev)
1447{
1448	int i, err;
1449	struct abituguru_data *data = dev_get_drvdata(dev);
1450	/* fake a complete successful read if no update necessary. */
1451	char success = 1;
1452
1453	mutex_lock(&data->update_lock);
1454	if (time_after(jiffies, data->last_updated + HZ)) {
1455		success = 0;
1456		err = abituguru_read(data, ABIT_UGURU_ALARM_BANK, 0,
1457				     data->alarms, 3, 0);
1458		if (err != 3)
1459			goto LEAVE_UPDATE;
1460		for (i = 0; i < ABIT_UGURU_MAX_BANK1_SENSORS; i++) {
1461			err = abituguru_read(data, ABIT_UGURU_SENSOR_BANK1,
1462					     i, &data->bank1_value[i], 1, 0);
1463			if (err != 1)
1464				goto LEAVE_UPDATE;
1465			err = abituguru_read(data, ABIT_UGURU_SENSOR_BANK1 + 1,
1466					     i, data->bank1_settings[i], 3, 0);
1467			if (err != 3)
1468				goto LEAVE_UPDATE;
1469		}
1470		for (i = 0; i < data->bank2_sensors; i++) {
1471			err = abituguru_read(data, ABIT_UGURU_SENSOR_BANK2, i,
1472					     &data->bank2_value[i], 1, 0);
1473			if (err != 1)
1474				goto LEAVE_UPDATE;
1475		}
1476		/* success! */
1477		success = 1;
1478		data->update_timeouts = 0;
1479LEAVE_UPDATE:
1480		/* handle timeout condition */
1481		if (!success && (err == -EBUSY || err >= 0)) {
1482			/* No overflow please */
1483			if (data->update_timeouts < 255u)
1484				data->update_timeouts++;
1485			if (data->update_timeouts <= ABIT_UGURU_MAX_TIMEOUTS) {
1486				ABIT_UGURU_DEBUG(3, "timeout exceeded, will "
1487					"try again next update\n");
1488				/* Just a timeout, fake a successful read */
1489				success = 1;
1490			} else
1491				ABIT_UGURU_DEBUG(1, "timeout exceeded %d "
1492					"times waiting for more input state\n",
1493					(int)data->update_timeouts);
1494		}
1495		/* On success set last_updated */
1496		if (success)
1497			data->last_updated = jiffies;
1498	}
1499	mutex_unlock(&data->update_lock);
1500
1501	if (success)
1502		return data;
1503	else
1504		return NULL;
1505}
1506
1507static int abituguru_suspend(struct device *dev)
 
1508{
1509	struct abituguru_data *data = dev_get_drvdata(dev);
1510	/*
1511	 * make sure all communications with the uguru are done and no new
1512	 * ones are started
1513	 */
1514	mutex_lock(&data->update_lock);
1515	return 0;
1516}
1517
1518static int abituguru_resume(struct device *dev)
1519{
1520	struct abituguru_data *data = dev_get_drvdata(dev);
1521	/* See if the uGuru is still ready */
1522	if (inb_p(data->addr + ABIT_UGURU_DATA) != ABIT_UGURU_STATUS_INPUT)
1523		data->uguru_ready = 0;
1524	mutex_unlock(&data->update_lock);
1525	return 0;
1526}
1527
1528static DEFINE_SIMPLE_DEV_PM_OPS(abituguru_pm, abituguru_suspend, abituguru_resume);
 
 
1529
1530static struct platform_driver abituguru_driver = {
1531	.driver = {
 
1532		.name	= ABIT_UGURU_NAME,
1533		.pm	= pm_sleep_ptr(&abituguru_pm),
1534	},
1535	.probe		= abituguru_probe,
1536	.remove		= abituguru_remove,
 
 
1537};
1538
1539static int __init abituguru_detect(void)
1540{
1541	/*
1542	 * See if there is an uguru there. After a reboot uGuru will hold 0x00
1543	 * at DATA and 0xAC, when this driver has already been loaded once
1544	 * DATA will hold 0x08. For most uGuru's CMD will hold 0xAC in either
1545	 * scenario but some will hold 0x00.
1546	 * Some uGuru's initially hold 0x09 at DATA and will only hold 0x08
1547	 * after reading CMD first, so CMD must be read first!
1548	 */
1549	u8 cmd_val = inb_p(ABIT_UGURU_BASE + ABIT_UGURU_CMD);
1550	u8 data_val = inb_p(ABIT_UGURU_BASE + ABIT_UGURU_DATA);
1551	if (((data_val == 0x00) || (data_val == 0x08)) &&
1552	    ((cmd_val == 0x00) || (cmd_val == 0xAC)))
1553		return ABIT_UGURU_BASE;
1554
1555	ABIT_UGURU_DEBUG(2, "no Abit uGuru found, data = 0x%02X, cmd = "
1556		"0x%02X\n", (unsigned int)data_val, (unsigned int)cmd_val);
1557
1558	if (force) {
1559		pr_info("Assuming Abit uGuru is present because of \"force\" parameter\n");
1560		return ABIT_UGURU_BASE;
1561	}
1562
1563	/* No uGuru found */
1564	return -ENODEV;
1565}
1566
1567static struct platform_device *abituguru_pdev;
1568
1569static int __init abituguru_init(void)
1570{
1571	int address, err;
1572	struct resource res = { .flags = IORESOURCE_IO };
1573	const char *board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
1574
1575	/* safety check, refuse to load on non Abit motherboards */
1576	if (!force && (!board_vendor ||
1577			strcmp(board_vendor, "http://www.abit.com.tw/")))
1578		return -ENODEV;
1579
1580	address = abituguru_detect();
1581	if (address < 0)
1582		return address;
1583
1584	err = platform_driver_register(&abituguru_driver);
1585	if (err)
1586		goto exit;
1587
1588	abituguru_pdev = platform_device_alloc(ABIT_UGURU_NAME, address);
1589	if (!abituguru_pdev) {
1590		pr_err("Device allocation failed\n");
1591		err = -ENOMEM;
1592		goto exit_driver_unregister;
1593	}
1594
1595	res.start = address;
1596	res.end = address + ABIT_UGURU_REGION_LENGTH - 1;
1597	res.name = ABIT_UGURU_NAME;
1598
1599	err = platform_device_add_resources(abituguru_pdev, &res, 1);
1600	if (err) {
1601		pr_err("Device resource addition failed (%d)\n", err);
1602		goto exit_device_put;
1603	}
1604
1605	err = platform_device_add(abituguru_pdev);
1606	if (err) {
1607		pr_err("Device addition failed (%d)\n", err);
1608		goto exit_device_put;
1609	}
1610
1611	return 0;
1612
1613exit_device_put:
1614	platform_device_put(abituguru_pdev);
1615exit_driver_unregister:
1616	platform_driver_unregister(&abituguru_driver);
1617exit:
1618	return err;
1619}
1620
1621static void __exit abituguru_exit(void)
1622{
1623	platform_device_unregister(abituguru_pdev);
1624	platform_driver_unregister(&abituguru_driver);
1625}
1626
1627MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
1628MODULE_DESCRIPTION("Abit uGuru Sensor device");
1629MODULE_LICENSE("GPL");
1630
1631module_init(abituguru_init);
1632module_exit(abituguru_exit);