1/*
   2 * lm78.c - Part of lm_sensors, Linux kernel modules for hardware
   3 *	    monitoring
   4 * Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
   5 * Copyright (c) 2007, 2011  Jean Delvare <jdelvare@suse.de>
   6 *
   7 * This program is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 2 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * This program is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  23
  24#include <linux/module.h>
  25#include <linux/init.h>
  26#include <linux/slab.h>
  27#include <linux/jiffies.h>
  28#include <linux/i2c.h>
  29#include <linux/hwmon.h>
  30#include <linux/hwmon-vid.h>
  31#include <linux/hwmon-sysfs.h>
  32#include <linux/err.h>
  33#include <linux/mutex.h>
  34
  35#ifdef CONFIG_ISA
  36#include <linux/platform_device.h>
  37#include <linux/ioport.h>
  38#include <linux/io.h>
  39#endif
  40
  41/* Addresses to scan */
  42static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
  43						0x2e, 0x2f, I2C_CLIENT_END };
  44enum chips { lm78, lm79 };
  45
  46/* Many LM78 constants specified below */
  47
  48/* Length of ISA address segment */
  49#define LM78_EXTENT 8
  50
  51/* Where are the ISA address/data registers relative to the base address */
  52#define LM78_ADDR_REG_OFFSET 5
  53#define LM78_DATA_REG_OFFSET 6
  54
  55/* The LM78 registers */
  56#define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)
  57#define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)
  58#define LM78_REG_IN(nr) (0x20 + (nr))
  59
  60#define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
  61#define LM78_REG_FAN(nr) (0x28 + (nr))
  62
  63#define LM78_REG_TEMP 0x27
  64#define LM78_REG_TEMP_OVER 0x39
  65#define LM78_REG_TEMP_HYST 0x3a
  66
  67#define LM78_REG_ALARM1 0x41
  68#define LM78_REG_ALARM2 0x42
  69
  70#define LM78_REG_VID_FANDIV 0x47
  71
  72#define LM78_REG_CONFIG 0x40
  73#define LM78_REG_CHIPID 0x49
  74#define LM78_REG_I2C_ADDR 0x48
  75
  76
  77/*
  78 * Conversions. Rounding and limit checking is only done on the TO_REG
  79 * variants.
  80 */
  81
  82/*
  83 * IN: mV (0V to 4.08V)
  84 * REG: 16mV/bit
  85 */
  86static inline u8 IN_TO_REG(unsigned long val)
  87{
  88	unsigned long nval = clamp_val(val, 0, 4080);
  89	return (nval + 8) / 16;
  90}
  91#define IN_FROM_REG(val) ((val) *  16)
  92
  93static inline u8 FAN_TO_REG(long rpm, int div)
  94{
  95	if (rpm <= 0)
  96		return 255;
  97	if (rpm > 1350000)
  98		return 1;
  99	return clamp_val((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
 100}
 101
 102static inline int FAN_FROM_REG(u8 val, int div)
 103{
 104	return val == 0 ? -1 : val == 255 ? 0 : 1350000 / (val * div);
 105}
 106
 107/*
 108 * TEMP: mC (-128C to +127C)
 109 * REG: 1C/bit, two's complement
 110 */
 111static inline s8 TEMP_TO_REG(long val)
 112{
 113	int nval = clamp_val(val, -128000, 127000) ;
 114	return nval < 0 ? (nval - 500) / 1000 : (nval + 500) / 1000;
 115}
 116
 117static inline int TEMP_FROM_REG(s8 val)
 118{
 119	return val * 1000;
 120}
 121
 122#define DIV_FROM_REG(val) (1 << (val))
 123
 124struct lm78_data {
 125	struct i2c_client *client;
 126	struct mutex lock;
 127	enum chips type;
 128
 129	/* For ISA device only */
 130	const char *name;
 131	int isa_addr;
 132
 133	struct mutex update_lock;
 134	char valid;		/* !=0 if following fields are valid */
 135	unsigned long last_updated;	/* In jiffies */
 136
 137	u8 in[7];		/* Register value */
 138	u8 in_max[7];		/* Register value */
 139	u8 in_min[7];		/* Register value */
 140	u8 fan[3];		/* Register value */
 141	u8 fan_min[3];		/* Register value */
 142	s8 temp;		/* Register value */
 143	s8 temp_over;		/* Register value */
 144	s8 temp_hyst;		/* Register value */
 145	u8 fan_div[3];		/* Register encoding, shifted right */
 146	u8 vid;			/* Register encoding, combined */
 147	u16 alarms;		/* Register encoding, combined */
 148};
 149
 150
 151static int lm78_read_value(struct lm78_data *data, u8 reg);
 152static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value);
 153static struct lm78_data *lm78_update_device(struct device *dev);
 154static void lm78_init_device(struct lm78_data *data);
 155
 156
 157/* 7 Voltages */
 158static ssize_t show_in(struct device *dev, struct device_attribute *da,
 159		       char *buf)
 160{
 161	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 162	struct lm78_data *data = lm78_update_device(dev);
 163	return sprintf(buf, "%d\n", IN_FROM_REG(data->in[attr->index]));
 164}
 165
 166static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
 167			   char *buf)
 168{
 169	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 170	struct lm78_data *data = lm78_update_device(dev);
 171	return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[attr->index]));
 172}
 173
 174static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
 175			   char *buf)
 176{
 177	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 178	struct lm78_data *data = lm78_update_device(dev);
 179	return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[attr->index]));
 180}
 181
 182static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
 183			  const char *buf, size_t count)
 184{
 185	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 186	struct lm78_data *data = dev_get_drvdata(dev);
 187	int nr = attr->index;
 188	unsigned long val;
 189	int err;
 190
 191	err = kstrtoul(buf, 10, &val);
 192	if (err)
 193		return err;
 194
 195	mutex_lock(&data->update_lock);
 196	data->in_min[nr] = IN_TO_REG(val);
 197	lm78_write_value(data, LM78_REG_IN_MIN(nr), data->in_min[nr]);
 198	mutex_unlock(&data->update_lock);
 199	return count;
 200}
 201
 202static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
 203			  const char *buf, size_t count)
 204{
 205	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 206	struct lm78_data *data = dev_get_drvdata(dev);
 207	int nr = attr->index;
 208	unsigned long val;
 209	int err;
 210
 211	err = kstrtoul(buf, 10, &val);
 212	if (err)
 213		return err;
 214
 215	mutex_lock(&data->update_lock);
 216	data->in_max[nr] = IN_TO_REG(val);
 217	lm78_write_value(data, LM78_REG_IN_MAX(nr), data->in_max[nr]);
 218	mutex_unlock(&data->update_lock);
 219	return count;
 220}
 221
 222#define show_in_offset(offset)					\
 223static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO,		\
 224		show_in, NULL, offset);				\
 225static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,	\
 226		show_in_min, set_in_min, offset);		\
 227static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,	\
 228		show_in_max, set_in_max, offset);
 229
 230show_in_offset(0);
 231show_in_offset(1);
 232show_in_offset(2);
 233show_in_offset(3);
 234show_in_offset(4);
 235show_in_offset(5);
 236show_in_offset(6);
 237
 238/* Temperature */
 239static ssize_t show_temp(struct device *dev, struct device_attribute *da,
 240			 char *buf)
 241{
 242	struct lm78_data *data = lm78_update_device(dev);
 243	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
 244}
 245
 246static ssize_t show_temp_over(struct device *dev, struct device_attribute *da,
 247			      char *buf)
 248{
 249	struct lm78_data *data = lm78_update_device(dev);
 250	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
 251}
 252
 253static ssize_t set_temp_over(struct device *dev, struct device_attribute *da,
 254			     const char *buf, size_t count)
 255{
 256	struct lm78_data *data = dev_get_drvdata(dev);
 257	long val;
 258	int err;
 259
 260	err = kstrtol(buf, 10, &val);
 261	if (err)
 262		return err;
 263
 264	mutex_lock(&data->update_lock);
 265	data->temp_over = TEMP_TO_REG(val);
 266	lm78_write_value(data, LM78_REG_TEMP_OVER, data->temp_over);
 267	mutex_unlock(&data->update_lock);
 268	return count;
 269}
 270
 271static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *da,
 272			      char *buf)
 273{
 274	struct lm78_data *data = lm78_update_device(dev);
 275	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
 276}
 277
 278static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *da,
 279			     const char *buf, size_t count)
 280{
 281	struct lm78_data *data = dev_get_drvdata(dev);
 282	long val;
 283	int err;
 284
 285	err = kstrtol(buf, 10, &val);
 286	if (err)
 287		return err;
 288
 289	mutex_lock(&data->update_lock);
 290	data->temp_hyst = TEMP_TO_REG(val);
 291	lm78_write_value(data, LM78_REG_TEMP_HYST, data->temp_hyst);
 292	mutex_unlock(&data->update_lock);
 293	return count;
 294}
 295
 296static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
 297static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
 298		show_temp_over, set_temp_over);
 299static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
 300		show_temp_hyst, set_temp_hyst);
 301
 302/* 3 Fans */
 303static ssize_t show_fan(struct device *dev, struct device_attribute *da,
 304			char *buf)
 305{
 306	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 307	struct lm78_data *data = lm78_update_device(dev);
 308	int nr = attr->index;
 309	return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
 310		DIV_FROM_REG(data->fan_div[nr])));
 311}
 312
 313static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
 314			    char *buf)
 315{
 316	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 317	struct lm78_data *data = lm78_update_device(dev);
 318	int nr = attr->index;
 319	return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
 320		DIV_FROM_REG(data->fan_div[nr])));
 321}
 322
 323static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
 324			   const char *buf, size_t count)
 325{
 326	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 327	struct lm78_data *data = dev_get_drvdata(dev);
 328	int nr = attr->index;
 329	unsigned long val;
 330	int err;
 331
 332	err = kstrtoul(buf, 10, &val);
 333	if (err)
 334		return err;
 335
 336	mutex_lock(&data->update_lock);
 337	data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
 338	lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
 339	mutex_unlock(&data->update_lock);
 340	return count;
 341}
 342
 343static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
 344			    char *buf)
 345{
 346	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 347	struct lm78_data *data = lm78_update_device(dev);
 348	return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));
 349}
 350
 351/*
 352 * Note: we save and restore the fan minimum here, because its value is
 353 * determined in part by the fan divisor.  This follows the principle of
 354 * least surprise; the user doesn't expect the fan minimum to change just
 355 * because the divisor changed.
 356 */
 357static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
 358			   const char *buf, size_t count)
 359{
 360	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 361	struct lm78_data *data = dev_get_drvdata(dev);
 362	int nr = attr->index;
 363	unsigned long min;
 364	u8 reg;
 365	unsigned long val;
 366	int err;
 367
 368	err = kstrtoul(buf, 10, &val);
 369	if (err)
 370		return err;
 371
 372	mutex_lock(&data->update_lock);
 373	min = FAN_FROM_REG(data->fan_min[nr],
 374			   DIV_FROM_REG(data->fan_div[nr]));
 375
 376	switch (val) {
 377	case 1:
 378		data->fan_div[nr] = 0;
 379		break;
 380	case 2:
 381		data->fan_div[nr] = 1;
 382		break;
 383	case 4:
 384		data->fan_div[nr] = 2;
 385		break;
 386	case 8:
 387		data->fan_div[nr] = 3;
 388		break;
 389	default:
 390		dev_err(dev,
 391			"fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n",
 392			val);
 393		mutex_unlock(&data->update_lock);
 394		return -EINVAL;
 395	}
 396
 397	reg = lm78_read_value(data, LM78_REG_VID_FANDIV);
 398	switch (nr) {
 399	case 0:
 400		reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
 401		break;
 402	case 1:
 403		reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
 404		break;
 405	}
 406	lm78_write_value(data, LM78_REG_VID_FANDIV, reg);
 407
 408	data->fan_min[nr] =
 409		FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
 410	lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
 411	mutex_unlock(&data->update_lock);
 412
 413	return count;
 414}
 415
 416#define show_fan_offset(offset)				\
 417static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,		\
 418		show_fan, NULL, offset - 1);			\
 419static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,	\
 420		show_fan_min, set_fan_min, offset - 1);
 421
 422show_fan_offset(1);
 423show_fan_offset(2);
 424show_fan_offset(3);
 425
 426/* Fan 3 divisor is locked in H/W */
 427static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
 428		show_fan_div, set_fan_div, 0);
 429static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
 430		show_fan_div, set_fan_div, 1);
 431static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2);
 432
 433/* VID */
 434static ssize_t show_vid(struct device *dev, struct device_attribute *da,
 435			char *buf)
 436{
 437	struct lm78_data *data = lm78_update_device(dev);
 438	return sprintf(buf, "%d\n", vid_from_reg(data->vid, 82));
 439}
 440static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
 441
 442/* Alarms */
 443static ssize_t show_alarms(struct device *dev, struct device_attribute *da,
 444			   char *buf)
 445{
 446	struct lm78_data *data = lm78_update_device(dev);
 447	return sprintf(buf, "%u\n", data->alarms);
 448}
 449static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 450
 451static ssize_t show_alarm(struct device *dev, struct device_attribute *da,
 452			  char *buf)
 453{
 454	struct lm78_data *data = lm78_update_device(dev);
 455	int nr = to_sensor_dev_attr(da)->index;
 456	return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
 457}
 458static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
 459static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
 460static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
 461static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
 462static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
 463static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
 464static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10);
 465static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
 466static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
 467static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
 468static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
 469
 470static struct attribute *lm78_attrs[] = {
 471	&sensor_dev_attr_in0_input.dev_attr.attr,
 472	&sensor_dev_attr_in0_min.dev_attr.attr,
 473	&sensor_dev_attr_in0_max.dev_attr.attr,
 474	&sensor_dev_attr_in0_alarm.dev_attr.attr,
 475	&sensor_dev_attr_in1_input.dev_attr.attr,
 476	&sensor_dev_attr_in1_min.dev_attr.attr,
 477	&sensor_dev_attr_in1_max.dev_attr.attr,
 478	&sensor_dev_attr_in1_alarm.dev_attr.attr,
 479	&sensor_dev_attr_in2_input.dev_attr.attr,
 480	&sensor_dev_attr_in2_min.dev_attr.attr,
 481	&sensor_dev_attr_in2_max.dev_attr.attr,
 482	&sensor_dev_attr_in2_alarm.dev_attr.attr,
 483	&sensor_dev_attr_in3_input.dev_attr.attr,
 484	&sensor_dev_attr_in3_min.dev_attr.attr,
 485	&sensor_dev_attr_in3_max.dev_attr.attr,
 486	&sensor_dev_attr_in3_alarm.dev_attr.attr,
 487	&sensor_dev_attr_in4_input.dev_attr.attr,
 488	&sensor_dev_attr_in4_min.dev_attr.attr,
 489	&sensor_dev_attr_in4_max.dev_attr.attr,
 490	&sensor_dev_attr_in4_alarm.dev_attr.attr,
 491	&sensor_dev_attr_in5_input.dev_attr.attr,
 492	&sensor_dev_attr_in5_min.dev_attr.attr,
 493	&sensor_dev_attr_in5_max.dev_attr.attr,
 494	&sensor_dev_attr_in5_alarm.dev_attr.attr,
 495	&sensor_dev_attr_in6_input.dev_attr.attr,
 496	&sensor_dev_attr_in6_min.dev_attr.attr,
 497	&sensor_dev_attr_in6_max.dev_attr.attr,
 498	&sensor_dev_attr_in6_alarm.dev_attr.attr,
 499	&dev_attr_temp1_input.attr,
 500	&dev_attr_temp1_max.attr,
 501	&dev_attr_temp1_max_hyst.attr,
 502	&sensor_dev_attr_temp1_alarm.dev_attr.attr,
 503	&sensor_dev_attr_fan1_input.dev_attr.attr,
 504	&sensor_dev_attr_fan1_min.dev_attr.attr,
 505	&sensor_dev_attr_fan1_div.dev_attr.attr,
 506	&sensor_dev_attr_fan1_alarm.dev_attr.attr,
 507	&sensor_dev_attr_fan2_input.dev_attr.attr,
 508	&sensor_dev_attr_fan2_min.dev_attr.attr,
 509	&sensor_dev_attr_fan2_div.dev_attr.attr,
 510	&sensor_dev_attr_fan2_alarm.dev_attr.attr,
 511	&sensor_dev_attr_fan3_input.dev_attr.attr,
 512	&sensor_dev_attr_fan3_min.dev_attr.attr,
 513	&sensor_dev_attr_fan3_div.dev_attr.attr,
 514	&sensor_dev_attr_fan3_alarm.dev_attr.attr,
 515	&dev_attr_alarms.attr,
 516	&dev_attr_cpu0_vid.attr,
 517
 518	NULL
 519};
 520
 521ATTRIBUTE_GROUPS(lm78);
 522
 523/*
 524 * ISA related code
 525 */
 526#ifdef CONFIG_ISA
 527
 528/* ISA device, if found */
 529static struct platform_device *pdev;
 530
 531static unsigned short isa_address = 0x290;
 532
 533static struct lm78_data *lm78_data_if_isa(void)
 534{
 535	return pdev ? platform_get_drvdata(pdev) : NULL;
 536}
 537
 538/* Returns 1 if the I2C chip appears to be an alias of the ISA chip */
 539static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
 540{
 541	struct lm78_data *isa;
 542	int i;
 543
 544	if (!pdev)	/* No ISA chip */
 545		return 0;
 546	isa = platform_get_drvdata(pdev);
 547
 548	if (lm78_read_value(isa, LM78_REG_I2C_ADDR) != client->addr)
 549		return 0;	/* Address doesn't match */
 550	if ((lm78_read_value(isa, LM78_REG_CHIPID) & 0xfe) != (chipid & 0xfe))
 551		return 0;	/* Chip type doesn't match */
 552
 553	/*
 554	 * We compare all the limit registers, the config register and the
 555	 * interrupt mask registers
 556	 */
 557	for (i = 0x2b; i <= 0x3d; i++) {
 558		if (lm78_read_value(isa, i) !=
 559		    i2c_smbus_read_byte_data(client, i))
 560			return 0;
 561	}
 562	if (lm78_read_value(isa, LM78_REG_CONFIG) !=
 563	    i2c_smbus_read_byte_data(client, LM78_REG_CONFIG))
 564		return 0;
 565	for (i = 0x43; i <= 0x46; i++) {
 566		if (lm78_read_value(isa, i) !=
 567		    i2c_smbus_read_byte_data(client, i))
 568			return 0;
 569	}
 570
 571	return 1;
 572}
 573#else /* !CONFIG_ISA */
 574
 575static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
 576{
 577	return 0;
 578}
 579
 580static struct lm78_data *lm78_data_if_isa(void)
 581{
 582	return NULL;
 583}
 584#endif /* CONFIG_ISA */
 585
 586static int lm78_i2c_detect(struct i2c_client *client,
 587			   struct i2c_board_info *info)
 588{
 589	int i;
 590	struct lm78_data *isa = lm78_data_if_isa();
 591	const char *client_name;
 592	struct i2c_adapter *adapter = client->adapter;
 593	int address = client->addr;
 594
 595	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 596		return -ENODEV;
 597
 598	/*
 599	 * We block updates of the ISA device to minimize the risk of
 600	 * concurrent access to the same LM78 chip through different
 601	 * interfaces.
 602	 */
 603	if (isa)
 604		mutex_lock(&isa->update_lock);
 605
 606	if ((i2c_smbus_read_byte_data(client, LM78_REG_CONFIG) & 0x80)
 607	 || i2c_smbus_read_byte_data(client, LM78_REG_I2C_ADDR) != address)
 608		goto err_nodev;
 609
 610	/* Explicitly prevent the misdetection of Winbond chips */
 611	i = i2c_smbus_read_byte_data(client, 0x4f);
 612	if (i == 0xa3 || i == 0x5c)
 613		goto err_nodev;
 614
 615	/* Determine the chip type. */
 616	i = i2c_smbus_read_byte_data(client, LM78_REG_CHIPID);
 617	if (i == 0x00 || i == 0x20	/* LM78 */
 618	 || i == 0x40)			/* LM78-J */
 619		client_name = "lm78";
 620	else if ((i & 0xfe) == 0xc0)
 621		client_name = "lm79";
 622	else
 623		goto err_nodev;
 624
 625	if (lm78_alias_detect(client, i)) {
 626		dev_dbg(&adapter->dev,
 627			"Device at 0x%02x appears to be the same as ISA device\n",
 628			address);
 629		goto err_nodev;
 630	}
 631
 632	if (isa)
 633		mutex_unlock(&isa->update_lock);
 634
 635	strlcpy(info->type, client_name, I2C_NAME_SIZE);
 636
 637	return 0;
 638
 639 err_nodev:
 640	if (isa)
 641		mutex_unlock(&isa->update_lock);
 642	return -ENODEV;
 643}
 644
 645static int lm78_i2c_probe(struct i2c_client *client,
 646			  const struct i2c_device_id *id)
 647{
 648	struct device *dev = &client->dev;
 649	struct device *hwmon_dev;
 650	struct lm78_data *data;
 651
 652	data = devm_kzalloc(dev, sizeof(struct lm78_data), GFP_KERNEL);
 653	if (!data)
 654		return -ENOMEM;
 655
 656	data->client = client;
 657	data->type = id->driver_data;
 658
 659	/* Initialize the LM78 chip */
 660	lm78_init_device(data);
 661
 662	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
 663							   data, lm78_groups);
 664	return PTR_ERR_OR_ZERO(hwmon_dev);
 665}
 666
 667static const struct i2c_device_id lm78_i2c_id[] = {
 668	{ "lm78", lm78 },
 669	{ "lm79", lm79 },
 670	{ }
 671};
 672MODULE_DEVICE_TABLE(i2c, lm78_i2c_id);
 673
 674static struct i2c_driver lm78_driver = {
 675	.class		= I2C_CLASS_HWMON,
 676	.driver = {
 677		.name	= "lm78",
 678	},
 679	.probe		= lm78_i2c_probe,
 680	.id_table	= lm78_i2c_id,
 681	.detect		= lm78_i2c_detect,
 682	.address_list	= normal_i2c,
 683};
 684
 685/*
 686 * The SMBus locks itself, but ISA access must be locked explicitly!
 687 * We don't want to lock the whole ISA bus, so we lock each client
 688 * separately.
 689 * We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
 690 * would slow down the LM78 access and should not be necessary.
 691 */
 692static int lm78_read_value(struct lm78_data *data, u8 reg)
 693{
 694	struct i2c_client *client = data->client;
 695
 696#ifdef CONFIG_ISA
 697	if (!client) { /* ISA device */
 698		int res;
 699		mutex_lock(&data->lock);
 700		outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
 701		res = inb_p(data->isa_addr + LM78_DATA_REG_OFFSET);
 702		mutex_unlock(&data->lock);
 703		return res;
 704	} else
 705#endif
 706		return i2c_smbus_read_byte_data(client, reg);
 707}
 708
 709static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
 710{
 711	struct i2c_client *client = data->client;
 712
 713#ifdef CONFIG_ISA
 714	if (!client) { /* ISA device */
 715		mutex_lock(&data->lock);
 716		outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
 717		outb_p(value, data->isa_addr + LM78_DATA_REG_OFFSET);
 718		mutex_unlock(&data->lock);
 719		return 0;
 720	} else
 721#endif
 722		return i2c_smbus_write_byte_data(client, reg, value);
 723}
 724
 725static void lm78_init_device(struct lm78_data *data)
 726{
 727	u8 config;
 728	int i;
 729
 730	/* Start monitoring */
 731	config = lm78_read_value(data, LM78_REG_CONFIG);
 732	if ((config & 0x09) != 0x01)
 733		lm78_write_value(data, LM78_REG_CONFIG,
 734				 (config & 0xf7) | 0x01);
 735
 736	/* A few vars need to be filled upon startup */
 737	for (i = 0; i < 3; i++) {
 738		data->fan_min[i] = lm78_read_value(data,
 739					LM78_REG_FAN_MIN(i));
 740	}
 741
 742	mutex_init(&data->update_lock);
 743}
 744
 745static struct lm78_data *lm78_update_device(struct device *dev)
 746{
 747	struct lm78_data *data = dev_get_drvdata(dev);
 748	int i;
 749
 750	mutex_lock(&data->update_lock);
 751
 752	if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 753	    || !data->valid) {
 754
 755		dev_dbg(dev, "Starting lm78 update\n");
 756
 757		for (i = 0; i <= 6; i++) {
 758			data->in[i] =
 759			    lm78_read_value(data, LM78_REG_IN(i));
 760			data->in_min[i] =
 761			    lm78_read_value(data, LM78_REG_IN_MIN(i));
 762			data->in_max[i] =
 763			    lm78_read_value(data, LM78_REG_IN_MAX(i));
 764		}
 765		for (i = 0; i < 3; i++) {
 766			data->fan[i] =
 767			    lm78_read_value(data, LM78_REG_FAN(i));
 768			data->fan_min[i] =
 769			    lm78_read_value(data, LM78_REG_FAN_MIN(i));
 770		}
 771		data->temp = lm78_read_value(data, LM78_REG_TEMP);
 772		data->temp_over =
 773		    lm78_read_value(data, LM78_REG_TEMP_OVER);
 774		data->temp_hyst =
 775		    lm78_read_value(data, LM78_REG_TEMP_HYST);
 776		i = lm78_read_value(data, LM78_REG_VID_FANDIV);
 777		data->vid = i & 0x0f;
 778		if (data->type == lm79)
 779			data->vid |=
 780			    (lm78_read_value(data, LM78_REG_CHIPID) &
 781			     0x01) << 4;
 782		else
 783			data->vid |= 0x10;
 784		data->fan_div[0] = (i >> 4) & 0x03;
 785		data->fan_div[1] = i >> 6;
 786		data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +
 787		    (lm78_read_value(data, LM78_REG_ALARM2) << 8);
 788		data->last_updated = jiffies;
 789		data->valid = 1;
 790
 791		data->fan_div[2] = 1;
 792	}
 793
 794	mutex_unlock(&data->update_lock);
 795
 796	return data;
 797}
 798
 799#ifdef CONFIG_ISA
 800static int lm78_isa_probe(struct platform_device *pdev)
 801{
 802	struct device *dev = &pdev->dev;
 803	struct device *hwmon_dev;
 804	struct lm78_data *data;
 805	struct resource *res;
 806
 807	/* Reserve the ISA region */
 808	res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 809	if (!devm_request_region(dev, res->start + LM78_ADDR_REG_OFFSET,
 810				 2, "lm78"))
 811		return -EBUSY;
 812
 813	data = devm_kzalloc(dev, sizeof(struct lm78_data), GFP_KERNEL);
 814	if (!data)
 815		return -ENOMEM;
 816
 817	mutex_init(&data->lock);
 818	data->isa_addr = res->start;
 819	platform_set_drvdata(pdev, data);
 820
 821	if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
 822		data->type = lm79;
 823		data->name = "lm79";
 824	} else {
 825		data->type = lm78;
 826		data->name = "lm78";
 827	}
 828
 829	/* Initialize the LM78 chip */
 830	lm78_init_device(data);
 831
 832	hwmon_dev = devm_hwmon_device_register_with_groups(dev, data->name,
 833							   data, lm78_groups);
 834	return PTR_ERR_OR_ZERO(hwmon_dev);
 835}
 836
 837static struct platform_driver lm78_isa_driver = {
 838	.driver = {
 839		.name	= "lm78",
 840	},
 841	.probe		= lm78_isa_probe,
 842};
 843
 844/* return 1 if a supported chip is found, 0 otherwise */
 845static int __init lm78_isa_found(unsigned short address)
 846{
 847	int val, save, found = 0;
 848	int port;
 849
 850	/*
 851	 * Some boards declare base+0 to base+7 as a PNP device, some base+4
 852	 * to base+7 and some base+5 to base+6. So we better request each port
 853	 * individually for the probing phase.
 854	 */
 855	for (port = address; port < address + LM78_EXTENT; port++) {
 856		if (!request_region(port, 1, "lm78")) {
 857			pr_debug("Failed to request port 0x%x\n", port);
 858			goto release;
 859		}
 860	}
 861
 862#define REALLY_SLOW_IO
 863	/*
 864	 * We need the timeouts for at least some LM78-like
 865	 * chips. But only if we read 'undefined' registers.
 866	 */
 867	val = inb_p(address + 1);
 868	if (inb_p(address + 2) != val
 869	 || inb_p(address + 3) != val
 870	 || inb_p(address + 7) != val)
 871		goto release;
 872#undef REALLY_SLOW_IO
 873
 874	/*
 875	 * We should be able to change the 7 LSB of the address port. The
 876	 * MSB (busy flag) should be clear initially, set after the write.
 877	 */
 878	save = inb_p(address + LM78_ADDR_REG_OFFSET);
 879	if (save & 0x80)
 880		goto release;
 881	val = ~save & 0x7f;
 882	outb_p(val, address + LM78_ADDR_REG_OFFSET);
 883	if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
 884		outb_p(save, address + LM78_ADDR_REG_OFFSET);
 885		goto release;
 886	}
 887
 888	/* We found a device, now see if it could be an LM78 */
 889	outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET);
 890	val = inb_p(address + LM78_DATA_REG_OFFSET);
 891	if (val & 0x80)
 892		goto release;
 893	outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET);
 894	val = inb_p(address + LM78_DATA_REG_OFFSET);
 895	if (val < 0x03 || val > 0x77)	/* Not a valid I2C address */
 896		goto release;
 897
 898	/* The busy flag should be clear again */
 899	if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)
 900		goto release;
 901
 902	/* Explicitly prevent the misdetection of Winbond chips */
 903	outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);
 904	val = inb_p(address + LM78_DATA_REG_OFFSET);
 905	if (val == 0xa3 || val == 0x5c)
 906		goto release;
 907
 908	/* Explicitly prevent the misdetection of ITE chips */
 909	outb_p(0x58, address + LM78_ADDR_REG_OFFSET);
 910	val = inb_p(address + LM78_DATA_REG_OFFSET);
 911	if (val == 0x90)
 912		goto release;
 913
 914	/* Determine the chip type */
 915	outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET);
 916	val = inb_p(address + LM78_DATA_REG_OFFSET);
 917	if (val == 0x00 || val == 0x20	/* LM78 */
 918	 || val == 0x40			/* LM78-J */
 919	 || (val & 0xfe) == 0xc0)	/* LM79 */
 920		found = 1;
 921
 922	if (found)
 923		pr_info("Found an %s chip at %#x\n",
 924			val & 0x80 ? "LM79" : "LM78", (int)address);
 925
 926 release:
 927	for (port--; port >= address; port--)
 928		release_region(port, 1);
 929	return found;
 930}
 931
 932static int __init lm78_isa_device_add(unsigned short address)
 933{
 934	struct resource res = {
 935		.start	= address,
 936		.end	= address + LM78_EXTENT - 1,
 937		.name	= "lm78",
 938		.flags	= IORESOURCE_IO,
 939	};
 940	int err;
 941
 942	pdev = platform_device_alloc("lm78", address);
 943	if (!pdev) {
 944		err = -ENOMEM;
 945		pr_err("Device allocation failed\n");
 946		goto exit;
 947	}
 948
 949	err = platform_device_add_resources(pdev, &res, 1);
 950	if (err) {
 951		pr_err("Device resource addition failed (%d)\n", err);
 952		goto exit_device_put;
 953	}
 954
 955	err = platform_device_add(pdev);
 956	if (err) {
 957		pr_err("Device addition failed (%d)\n", err);
 958		goto exit_device_put;
 959	}
 960
 961	return 0;
 962
 963 exit_device_put:
 964	platform_device_put(pdev);
 965 exit:
 966	pdev = NULL;
 967	return err;
 968}
 969
 970static int __init lm78_isa_register(void)
 971{
 972	int res;
 973
 974	if (lm78_isa_found(isa_address)) {
 975		res = platform_driver_register(&lm78_isa_driver);
 976		if (res)
 977			goto exit;
 978
 979		/* Sets global pdev as a side effect */
 980		res = lm78_isa_device_add(isa_address);
 981		if (res)
 982			goto exit_unreg_isa_driver;
 983	}
 984
 985	return 0;
 986
 987 exit_unreg_isa_driver:
 988	platform_driver_unregister(&lm78_isa_driver);
 989 exit:
 990	return res;
 991}
 992
 993static void lm78_isa_unregister(void)
 994{
 995	if (pdev) {
 996		platform_device_unregister(pdev);
 997		platform_driver_unregister(&lm78_isa_driver);
 998	}
 999}
1000#else /* !CONFIG_ISA */
1001
1002static int __init lm78_isa_register(void)
1003{
1004	return 0;
1005}
1006
1007static void lm78_isa_unregister(void)
1008{
1009}
1010#endif /* CONFIG_ISA */
1011
1012static int __init sm_lm78_init(void)
1013{
1014	int res;
1015
1016	/*
1017	 * We register the ISA device first, so that we can skip the
1018	 * registration of an I2C interface to the same device.
1019	 */
1020	res = lm78_isa_register();
1021	if (res)
1022		goto exit;
1023
1024	res = i2c_add_driver(&lm78_driver);
1025	if (res)
1026		goto exit_unreg_isa_device;
1027
1028	return 0;
1029
1030 exit_unreg_isa_device:
1031	lm78_isa_unregister();
1032 exit:
1033	return res;
1034}
1035
1036static void __exit sm_lm78_exit(void)
1037{
1038	lm78_isa_unregister();
1039	i2c_del_driver(&lm78_driver);
1040}
1041
1042MODULE_AUTHOR("Frodo Looijaard, Jean Delvare <jdelvare@suse.de>");
1043MODULE_DESCRIPTION("LM78/LM79 driver");
1044MODULE_LICENSE("GPL");
1045
1046module_init(sm_lm78_init);
1047module_exit(sm_lm78_exit);