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