1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  pc87360.c - Part of lm_sensors, Linux kernel modules
   4 *              for hardware monitoring
   5 *  Copyright (C) 2004, 2007 Jean Delvare <jdelvare@suse.de>
   6 *
   7 *  Copied from smsc47m1.c:
   8 *  Copyright (C) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
   9 *
  10 *  Supports the following chips:
  11 *
  12 *  Chip        #vin    #fan    #pwm    #temp   devid
  13 *  PC87360     -       2       2       -       0xE1
  14 *  PC87363     -       2       2       -       0xE8
  15 *  PC87364     -       3       3       -       0xE4
  16 *  PC87365     11      3       3       2       0xE5
  17 *  PC87366     11      3       3       3-4     0xE9
  18 *
  19 *  This driver assumes that no more than one chip is present, and one of
  20 *  the standard Super-I/O addresses is used (0x2E/0x2F or 0x4E/0x4F).
  21 */
  22
  23#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  24
  25#include <linux/module.h>
  26#include <linux/init.h>
  27#include <linux/slab.h>
  28#include <linux/jiffies.h>
  29#include <linux/platform_device.h>
  30#include <linux/hwmon.h>
  31#include <linux/hwmon-sysfs.h>
  32#include <linux/hwmon-vid.h>
  33#include <linux/err.h>
  34#include <linux/mutex.h>
  35#include <linux/acpi.h>
  36#include <linux/io.h>
  37
  38#define DRIVER_NAME "pc87360"
  39
  40/* (temp & vin) channel conversion status register flags (pdf sec.11.5.12) */
  41#define CHAN_CNVRTD	0x80	/* new data ready */
  42#define CHAN_ENA	0x01	/* enabled channel (temp or vin) */
  43#define CHAN_ALM_ENA	0x10	/* propagate to alarms-reg ?? (chk val!) */
  44#define CHAN_READY	(CHAN_ENA|CHAN_CNVRTD) /* sample ready mask */
  45
  46#define TEMP_OTS_OE	0x20	/* OTS Output Enable */
  47#define VIN_RW1C_MASK	(CHAN_READY|CHAN_ALM_MAX|CHAN_ALM_MIN)   /* 0x87 */
  48#define TEMP_RW1C_MASK	(VIN_RW1C_MASK|TEMP_ALM_CRIT|TEMP_FAULT) /* 0xCF */
  49
  50static u8 devid;
  51static struct platform_device *pdev;
  52static unsigned short extra_isa[3];
  53static u8 confreg[4];
  54
  55static int init = 1;
  56module_param(init, int, 0);
  57MODULE_PARM_DESC(init,
  58"Chip initialization level:\n"
  59" 0: None\n"
  60"*1: Forcibly enable internal voltage and temperature channels, except in9\n"
  61" 2: Forcibly enable all voltage and temperature channels, except in9\n"
  62" 3: Forcibly enable all voltage and temperature channels, including in9");
  63
  64static unsigned short force_id;
  65module_param(force_id, ushort, 0);
  66MODULE_PARM_DESC(force_id, "Override the detected device ID");
  67
  68/*
  69 * Super-I/O registers and operations
  70 */
  71
  72#define DEV	0x07	/* Register: Logical device select */
  73#define DEVID	0x20	/* Register: Device ID */
  74#define ACT	0x30	/* Register: Device activation */
  75#define BASE	0x60	/* Register: Base address */
  76
  77#define FSCM	0x09	/* Logical device: fans */
  78#define VLM	0x0d	/* Logical device: voltages */
  79#define TMS	0x0e	/* Logical device: temperatures */
  80#define LDNI_MAX 3
  81static const u8 logdev[LDNI_MAX] = { FSCM, VLM, TMS };
  82
  83#define LD_FAN		0
  84#define LD_IN		1
  85#define LD_TEMP		2
  86
  87static inline void superio_outb(int sioaddr, int reg, int val)
  88{
  89	outb(reg, sioaddr);
  90	outb(val, sioaddr + 1);
  91}
  92
  93static inline int superio_inb(int sioaddr, int reg)
  94{
  95	outb(reg, sioaddr);
  96	return inb(sioaddr + 1);
  97}
  98
  99static inline void superio_exit(int sioaddr)
 100{
 101	outb(0x02, sioaddr);
 102	outb(0x02, sioaddr + 1);
 103}
 104
 105/*
 106 * Logical devices
 107 */
 108
 109#define PC87360_EXTENT		0x10
 110#define PC87365_REG_BANK	0x09
 111#define NO_BANK			0xff
 112
 113/*
 114 * Fan registers and conversions
 115 */
 116
 117/* nr has to be 0 or 1 (PC87360/87363) or 2 (PC87364/87365/87366) */
 118#define PC87360_REG_PRESCALE(nr)	(0x00 + 2 * (nr))
 119#define PC87360_REG_PWM(nr)		(0x01 + 2 * (nr))
 120#define PC87360_REG_FAN_MIN(nr)		(0x06 + 3 * (nr))
 121#define PC87360_REG_FAN(nr)		(0x07 + 3 * (nr))
 122#define PC87360_REG_FAN_STATUS(nr)	(0x08 + 3 * (nr))
 123
 124#define FAN_FROM_REG(val, div)		((val) == 0 ? 0 : \
 125					 480000 / ((val) * (div)))
 126#define FAN_TO_REG(val, div)		((val) <= 100 ? 0 : \
 127					 480000 / ((val) * (div)))
 128#define FAN_DIV_FROM_REG(val)		(1 << (((val) >> 5) & 0x03))
 129#define FAN_STATUS_FROM_REG(val)	((val) & 0x07)
 130
 131#define FAN_CONFIG_MONITOR(val, nr)	(((val) >> (2 + (nr) * 3)) & 1)
 132#define FAN_CONFIG_CONTROL(val, nr)	(((val) >> (3 + (nr) * 3)) & 1)
 133#define FAN_CONFIG_INVERT(val, nr)	(((val) >> (4 + (nr) * 3)) & 1)
 134
 135#define PWM_FROM_REG(val, inv)		((inv) ? 255 - (val) : (val))
 136static inline u8 PWM_TO_REG(int val, int inv)
 137{
 138	if (inv)
 139		val = 255 - val;
 140	if (val < 0)
 141		return 0;
 142	if (val > 255)
 143		return 255;
 144	return val;
 145}
 146
 147/*
 148 * Voltage registers and conversions
 149 */
 150
 151#define PC87365_REG_IN_CONVRATE		0x07
 152#define PC87365_REG_IN_CONFIG		0x08
 153#define PC87365_REG_IN			0x0B
 154#define PC87365_REG_IN_MIN		0x0D
 155#define PC87365_REG_IN_MAX		0x0C
 156#define PC87365_REG_IN_STATUS		0x0A
 157#define PC87365_REG_IN_ALARMS1		0x00
 158#define PC87365_REG_IN_ALARMS2		0x01
 159#define PC87365_REG_VID			0x06
 160
 161#define IN_FROM_REG(val, ref)		(((val) * (ref) + 128) / 256)
 162#define IN_TO_REG(val, ref)		((val) < 0 ? 0 : \
 163					 (val) * 256 >= (ref) * 255 ? 255 : \
 164					 ((val) * 256 + (ref) / 2) / (ref))
 165
 166/*
 167 * Temperature registers and conversions
 168 */
 169
 170#define PC87365_REG_TEMP_CONFIG		0x08
 171#define PC87365_REG_TEMP		0x0B
 172#define PC87365_REG_TEMP_MIN		0x0D
 173#define PC87365_REG_TEMP_MAX		0x0C
 174#define PC87365_REG_TEMP_CRIT		0x0E
 175#define PC87365_REG_TEMP_STATUS		0x0A
 176#define PC87365_REG_TEMP_ALARMS		0x00
 177
 178#define TEMP_FROM_REG(val)		((val) * 1000)
 179#define TEMP_TO_REG(val)		((val) < -55000 ? -55 : \
 180					 (val) > 127000 ? 127 : \
 181					 (val) < 0 ? ((val) - 500) / 1000 : \
 182					 ((val) + 500) / 1000)
 183
 184/*
 185 * Device data
 186 */
 187
 188struct pc87360_data {
 189	const char *name;
 190	struct device *hwmon_dev;
 191	struct mutex lock;
 192	struct mutex update_lock;
 193	bool valid;		/* true if following fields are valid */
 194	unsigned long last_updated;	/* In jiffies */
 195
 196	int address[3];
 197
 198	u8 fannr, innr, tempnr;
 199
 200	u8 fan[3];		/* Register value */
 201	u8 fan_min[3];		/* Register value */
 202	u8 fan_status[3];	/* Register value */
 203	u8 pwm[3];		/* Register value */
 204	u16 fan_conf;		/* Configuration register values, combined */
 205
 206	u16 in_vref;		/* 1 mV/bit */
 207	u8 in[14];		/* Register value */
 208	u8 in_min[14];		/* Register value */
 209	u8 in_max[14];		/* Register value */
 210	u8 in_crit[3];		/* Register value */
 211	u8 in_status[14];	/* Register value */
 212	u16 in_alarms;		/* Register values, combined, masked */
 213	u8 vid_conf;		/* Configuration register value */
 214	u8 vrm;
 215	u8 vid;			/* Register value */
 216
 217	s8 temp[3];		/* Register value */
 218	s8 temp_min[3];		/* Register value */
 219	s8 temp_max[3];		/* Register value */
 220	s8 temp_crit[3];	/* Register value */
 221	u8 temp_status[3];	/* Register value */
 222	u8 temp_alarms;		/* Register value, masked */
 223};
 224
 225/*
 226 * ldi is the logical device index
 227 * bank is for voltages and temperatures only
 228 */
 229static int pc87360_read_value(struct pc87360_data *data, u8 ldi, u8 bank,
 230			      u8 reg)
 231{
 232	int res;
 233
 234	mutex_lock(&(data->lock));
 235	if (bank != NO_BANK)
 236		outb_p(bank, data->address[ldi] + PC87365_REG_BANK);
 237	res = inb_p(data->address[ldi] + reg);
 238	mutex_unlock(&(data->lock));
 239
 240	return res;
 241}
 242
 243static void pc87360_write_value(struct pc87360_data *data, u8 ldi, u8 bank,
 244				u8 reg, u8 value)
 245{
 246	mutex_lock(&(data->lock));
 247	if (bank != NO_BANK)
 248		outb_p(bank, data->address[ldi] + PC87365_REG_BANK);
 249	outb_p(value, data->address[ldi] + reg);
 250	mutex_unlock(&(data->lock));
 251}
 252
 253static void pc87360_autodiv(struct device *dev, int nr)
 254{
 255	struct pc87360_data *data = dev_get_drvdata(dev);
 256	u8 old_min = data->fan_min[nr];
 257
 258	/* Increase clock divider if needed and possible */
 259	if ((data->fan_status[nr] & 0x04) /* overflow flag */
 260	 || (data->fan[nr] >= 224)) { /* next to overflow */
 261		if ((data->fan_status[nr] & 0x60) != 0x60) {
 262			data->fan_status[nr] += 0x20;
 263			data->fan_min[nr] >>= 1;
 264			data->fan[nr] >>= 1;
 265			dev_dbg(dev,
 266				"Increasing clock divider to %d for fan %d\n",
 267				FAN_DIV_FROM_REG(data->fan_status[nr]), nr + 1);
 268		}
 269	} else {
 270		/* Decrease clock divider if possible */
 271		while (!(data->fan_min[nr] & 0x80) /* min "nails" divider */
 272		 && data->fan[nr] < 85 /* bad accuracy */
 273		 && (data->fan_status[nr] & 0x60) != 0x00) {
 274			data->fan_status[nr] -= 0x20;
 275			data->fan_min[nr] <<= 1;
 276			data->fan[nr] <<= 1;
 277			dev_dbg(dev,
 278				"Decreasing clock divider to %d for fan %d\n",
 279				FAN_DIV_FROM_REG(data->fan_status[nr]),
 280				nr + 1);
 281		}
 282	}
 283
 284	/* Write new fan min if it changed */
 285	if (old_min != data->fan_min[nr]) {
 286		pc87360_write_value(data, LD_FAN, NO_BANK,
 287				    PC87360_REG_FAN_MIN(nr),
 288				    data->fan_min[nr]);
 289	}
 290}
 291
 292static struct pc87360_data *pc87360_update_device(struct device *dev)
 293{
 294	struct pc87360_data *data = dev_get_drvdata(dev);
 295	u8 i;
 296
 297	mutex_lock(&data->update_lock);
 298
 299	if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
 300		dev_dbg(dev, "Data update\n");
 301
 302		/* Fans */
 303		for (i = 0; i < data->fannr; i++) {
 304			if (FAN_CONFIG_MONITOR(data->fan_conf, i)) {
 305				data->fan_status[i] =
 306					pc87360_read_value(data, LD_FAN,
 307					NO_BANK, PC87360_REG_FAN_STATUS(i));
 308				data->fan[i] = pc87360_read_value(data, LD_FAN,
 309					       NO_BANK, PC87360_REG_FAN(i));
 310				data->fan_min[i] = pc87360_read_value(data,
 311						   LD_FAN, NO_BANK,
 312						   PC87360_REG_FAN_MIN(i));
 313				/* Change clock divider if needed */
 314				pc87360_autodiv(dev, i);
 315				/* Clear bits and write new divider */
 316				pc87360_write_value(data, LD_FAN, NO_BANK,
 317						    PC87360_REG_FAN_STATUS(i),
 318						    data->fan_status[i]);
 319			}
 320			if (FAN_CONFIG_CONTROL(data->fan_conf, i))
 321				data->pwm[i] = pc87360_read_value(data, LD_FAN,
 322					       NO_BANK, PC87360_REG_PWM(i));
 323		}
 324
 325		/* Voltages */
 326		/*
 327		 * The min() below does not have any practical meaning and is
 328		 * only needed to silence a warning observed with gcc 12+.
 329		 */
 330		for (i = 0; i < min(data->innr, ARRAY_SIZE(data->in)); i++) {
 331			data->in_status[i] = pc87360_read_value(data, LD_IN, i,
 332					     PC87365_REG_IN_STATUS);
 333			/* Clear bits */
 334			pc87360_write_value(data, LD_IN, i,
 335					    PC87365_REG_IN_STATUS,
 336					    data->in_status[i]);
 337			if ((data->in_status[i] & CHAN_READY) == CHAN_READY) {
 338				data->in[i] = pc87360_read_value(data, LD_IN,
 339					      i, PC87365_REG_IN);
 340			}
 341			if (data->in_status[i] & CHAN_ENA) {
 342				data->in_min[i] = pc87360_read_value(data,
 343						  LD_IN, i,
 344						  PC87365_REG_IN_MIN);
 345				data->in_max[i] = pc87360_read_value(data,
 346						  LD_IN, i,
 347						  PC87365_REG_IN_MAX);
 348				if (i >= 11)
 349					data->in_crit[i-11] =
 350						pc87360_read_value(data, LD_IN,
 351						i, PC87365_REG_TEMP_CRIT);
 352			}
 353		}
 354		if (data->innr) {
 355			data->in_alarms = pc87360_read_value(data, LD_IN,
 356					  NO_BANK, PC87365_REG_IN_ALARMS1)
 357					| ((pc87360_read_value(data, LD_IN,
 358					    NO_BANK, PC87365_REG_IN_ALARMS2)
 359					    & 0x07) << 8);
 360			data->vid = (data->vid_conf & 0xE0) ?
 361				    pc87360_read_value(data, LD_IN,
 362				    NO_BANK, PC87365_REG_VID) : 0x1F;
 363		}
 364
 365		/* Temperatures */
 366		for (i = 0; i < data->tempnr; i++) {
 367			data->temp_status[i] = pc87360_read_value(data,
 368					       LD_TEMP, i,
 369					       PC87365_REG_TEMP_STATUS);
 370			/* Clear bits */
 371			pc87360_write_value(data, LD_TEMP, i,
 372					    PC87365_REG_TEMP_STATUS,
 373					    data->temp_status[i]);
 374			if ((data->temp_status[i] & CHAN_READY) == CHAN_READY) {
 375				data->temp[i] = pc87360_read_value(data,
 376						LD_TEMP, i,
 377						PC87365_REG_TEMP);
 378			}
 379			if (data->temp_status[i] & CHAN_ENA) {
 380				data->temp_min[i] = pc87360_read_value(data,
 381						    LD_TEMP, i,
 382						    PC87365_REG_TEMP_MIN);
 383				data->temp_max[i] = pc87360_read_value(data,
 384						    LD_TEMP, i,
 385						    PC87365_REG_TEMP_MAX);
 386				data->temp_crit[i] = pc87360_read_value(data,
 387						     LD_TEMP, i,
 388						     PC87365_REG_TEMP_CRIT);
 389			}
 390		}
 391		if (data->tempnr) {
 392			data->temp_alarms = pc87360_read_value(data, LD_TEMP,
 393					    NO_BANK, PC87365_REG_TEMP_ALARMS)
 394					    & 0x3F;
 395		}
 396
 397		data->last_updated = jiffies;
 398		data->valid = true;
 399	}
 400
 401	mutex_unlock(&data->update_lock);
 402
 403	return data;
 404}
 405
 406static ssize_t in_input_show(struct device *dev,
 407			     struct device_attribute *devattr, char *buf)
 408{
 409	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 410	struct pc87360_data *data = pc87360_update_device(dev);
 411	return sprintf(buf, "%u\n", IN_FROM_REG(data->in[attr->index],
 412		       data->in_vref));
 413}
 414
 415static struct sensor_device_attribute in_input[] = {
 416	SENSOR_ATTR_RO(in0_input, in_input, 0),
 417	SENSOR_ATTR_RO(in1_input, in_input, 1),
 418	SENSOR_ATTR_RO(in2_input, in_input, 2),
 419	SENSOR_ATTR_RO(in3_input, in_input, 3),
 420	SENSOR_ATTR_RO(in4_input, in_input, 4),
 421	SENSOR_ATTR_RO(in5_input, in_input, 5),
 422	SENSOR_ATTR_RO(in6_input, in_input, 6),
 423	SENSOR_ATTR_RO(in7_input, in_input, 7),
 424	SENSOR_ATTR_RO(in8_input, in_input, 8),
 425	SENSOR_ATTR_RO(in9_input, in_input, 9),
 426	SENSOR_ATTR_RO(in10_input, in_input, 10),
 427};
 428
 429static ssize_t in_status_show(struct device *dev,
 430			      struct device_attribute *devattr, char *buf)
 431{
 432	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 433	struct pc87360_data *data = pc87360_update_device(dev);
 434	return sprintf(buf, "%u\n", data->in_status[attr->index]);
 435}
 436
 437static struct sensor_device_attribute in_status[] = {
 438	SENSOR_ATTR_RO(in0_status, in_status, 0),
 439	SENSOR_ATTR_RO(in1_status, in_status, 1),
 440	SENSOR_ATTR_RO(in2_status, in_status, 2),
 441	SENSOR_ATTR_RO(in3_status, in_status, 3),
 442	SENSOR_ATTR_RO(in4_status, in_status, 4),
 443	SENSOR_ATTR_RO(in5_status, in_status, 5),
 444	SENSOR_ATTR_RO(in6_status, in_status, 6),
 445	SENSOR_ATTR_RO(in7_status, in_status, 7),
 446	SENSOR_ATTR_RO(in8_status, in_status, 8),
 447	SENSOR_ATTR_RO(in9_status, in_status, 9),
 448	SENSOR_ATTR_RO(in10_status, in_status, 10),
 449};
 450
 451static ssize_t in_min_show(struct device *dev,
 452			   struct device_attribute *devattr, char *buf)
 453{
 454	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 455	struct pc87360_data *data = pc87360_update_device(dev);
 456	return sprintf(buf, "%u\n", IN_FROM_REG(data->in_min[attr->index],
 457		       data->in_vref));
 458}
 459
 460static ssize_t in_min_store(struct device *dev,
 461			    struct device_attribute *devattr, const char *buf,
 462			    size_t count)
 463{
 464	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 465	struct pc87360_data *data = dev_get_drvdata(dev);
 466	long val;
 467	int err;
 468
 469	err = kstrtol(buf, 10, &val);
 470	if (err)
 471		return err;
 472
 473	mutex_lock(&data->update_lock);
 474	data->in_min[attr->index] = IN_TO_REG(val, data->in_vref);
 475	pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_IN_MIN,
 476			    data->in_min[attr->index]);
 477	mutex_unlock(&data->update_lock);
 478	return count;
 479}
 480
 481static struct sensor_device_attribute in_min[] = {
 482	SENSOR_ATTR_RW(in0_min, in_min, 0),
 483	SENSOR_ATTR_RW(in1_min, in_min, 1),
 484	SENSOR_ATTR_RW(in2_min, in_min, 2),
 485	SENSOR_ATTR_RW(in3_min, in_min, 3),
 486	SENSOR_ATTR_RW(in4_min, in_min, 4),
 487	SENSOR_ATTR_RW(in5_min, in_min, 5),
 488	SENSOR_ATTR_RW(in6_min, in_min, 6),
 489	SENSOR_ATTR_RW(in7_min, in_min, 7),
 490	SENSOR_ATTR_RW(in8_min, in_min, 8),
 491	SENSOR_ATTR_RW(in9_min, in_min, 9),
 492	SENSOR_ATTR_RW(in10_min, in_min, 10),
 493};
 494
 495static ssize_t in_max_show(struct device *dev,
 496			   struct device_attribute *devattr, char *buf)
 497{
 498	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 499	struct pc87360_data *data = pc87360_update_device(dev);
 500	return sprintf(buf, "%u\n", IN_FROM_REG(data->in_max[attr->index],
 501		       data->in_vref));
 502}
 503
 504static ssize_t in_max_store(struct device *dev,
 505			    struct device_attribute *devattr, const char *buf,
 506			    size_t count)
 507{
 508	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 509	struct pc87360_data *data = dev_get_drvdata(dev);
 510	long val;
 511	int err;
 512
 513	err = kstrtol(buf, 10, &val);
 514	if (err)
 515		return err;
 516
 517	mutex_lock(&data->update_lock);
 518	data->in_max[attr->index] = IN_TO_REG(val,
 519			       data->in_vref);
 520	pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_IN_MAX,
 521			    data->in_max[attr->index]);
 522	mutex_unlock(&data->update_lock);
 523	return count;
 524}
 525
 526static struct sensor_device_attribute in_max[] = {
 527	SENSOR_ATTR_RW(in0_max, in_max, 0),
 528	SENSOR_ATTR_RW(in1_max, in_max, 1),
 529	SENSOR_ATTR_RW(in2_max, in_max, 2),
 530	SENSOR_ATTR_RW(in3_max, in_max, 3),
 531	SENSOR_ATTR_RW(in4_max, in_max, 4),
 532	SENSOR_ATTR_RW(in5_max, in_max, 5),
 533	SENSOR_ATTR_RW(in6_max, in_max, 6),
 534	SENSOR_ATTR_RW(in7_max, in_max, 7),
 535	SENSOR_ATTR_RW(in8_max, in_max, 8),
 536	SENSOR_ATTR_RW(in9_max, in_max, 9),
 537	SENSOR_ATTR_RW(in10_max, in_max, 10),
 538};
 539
 540/* (temp & vin) channel status register alarm bits (pdf sec.11.5.12) */
 541#define CHAN_ALM_MIN	0x02	/* min limit crossed */
 542#define CHAN_ALM_MAX	0x04	/* max limit exceeded */
 543#define TEMP_ALM_CRIT	0x08	/* temp crit exceeded (temp only) */
 544
 545/*
 546 * show_in_min/max_alarm() reads data from the per-channel status
 547 * register (sec 11.5.12), not the vin event status registers (sec
 548 * 11.5.2) that (legacy) show_in_alarm() resds (via data->in_alarms)
 549 */
 550
 551static ssize_t in_min_alarm_show(struct device *dev,
 552				 struct device_attribute *devattr, char *buf)
 553{
 554	struct pc87360_data *data = pc87360_update_device(dev);
 555	unsigned nr = to_sensor_dev_attr(devattr)->index;
 556
 557	return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MIN));
 558}
 559
 560static struct sensor_device_attribute in_min_alarm[] = {
 561	SENSOR_ATTR_RO(in0_min_alarm, in_min_alarm, 0),
 562	SENSOR_ATTR_RO(in1_min_alarm, in_min_alarm, 1),
 563	SENSOR_ATTR_RO(in2_min_alarm, in_min_alarm, 2),
 564	SENSOR_ATTR_RO(in3_min_alarm, in_min_alarm, 3),
 565	SENSOR_ATTR_RO(in4_min_alarm, in_min_alarm, 4),
 566	SENSOR_ATTR_RO(in5_min_alarm, in_min_alarm, 5),
 567	SENSOR_ATTR_RO(in6_min_alarm, in_min_alarm, 6),
 568	SENSOR_ATTR_RO(in7_min_alarm, in_min_alarm, 7),
 569	SENSOR_ATTR_RO(in8_min_alarm, in_min_alarm, 8),
 570	SENSOR_ATTR_RO(in9_min_alarm, in_min_alarm, 9),
 571	SENSOR_ATTR_RO(in10_min_alarm, in_min_alarm, 10),
 572};
 573
 574static ssize_t in_max_alarm_show(struct device *dev,
 575				 struct device_attribute *devattr, char *buf)
 576{
 577	struct pc87360_data *data = pc87360_update_device(dev);
 578	unsigned nr = to_sensor_dev_attr(devattr)->index;
 579
 580	return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MAX));
 581}
 582
 583static struct sensor_device_attribute in_max_alarm[] = {
 584	SENSOR_ATTR_RO(in0_max_alarm, in_max_alarm, 0),
 585	SENSOR_ATTR_RO(in1_max_alarm, in_max_alarm, 1),
 586	SENSOR_ATTR_RO(in2_max_alarm, in_max_alarm, 2),
 587	SENSOR_ATTR_RO(in3_max_alarm, in_max_alarm, 3),
 588	SENSOR_ATTR_RO(in4_max_alarm, in_max_alarm, 4),
 589	SENSOR_ATTR_RO(in5_max_alarm, in_max_alarm, 5),
 590	SENSOR_ATTR_RO(in6_max_alarm, in_max_alarm, 6),
 591	SENSOR_ATTR_RO(in7_max_alarm, in_max_alarm, 7),
 592	SENSOR_ATTR_RO(in8_max_alarm, in_max_alarm, 8),
 593	SENSOR_ATTR_RO(in9_max_alarm, in_max_alarm, 9),
 594	SENSOR_ATTR_RO(in10_max_alarm, in_max_alarm, 10),
 595};
 596
 597#define VIN_UNIT_ATTRS(X) \
 598	&in_input[X].dev_attr.attr,	\
 599	&in_status[X].dev_attr.attr,	\
 600	&in_min[X].dev_attr.attr,	\
 601	&in_max[X].dev_attr.attr,	\
 602	&in_min_alarm[X].dev_attr.attr,	\
 603	&in_max_alarm[X].dev_attr.attr
 604
 605static ssize_t cpu0_vid_show(struct device *dev,
 606			     struct device_attribute *attr, char *buf)
 607{
 608	struct pc87360_data *data = pc87360_update_device(dev);
 609	return sprintf(buf, "%u\n", vid_from_reg(data->vid, data->vrm));
 610}
 611static DEVICE_ATTR_RO(cpu0_vid);
 612
 613static ssize_t vrm_show(struct device *dev, struct device_attribute *attr,
 614			char *buf)
 615{
 616	struct pc87360_data *data = dev_get_drvdata(dev);
 617	return sprintf(buf, "%u\n", data->vrm);
 618}
 619
 620static ssize_t vrm_store(struct device *dev, struct device_attribute *attr,
 621			 const char *buf, size_t count)
 622{
 623	struct pc87360_data *data = dev_get_drvdata(dev);
 624	unsigned long val;
 625	int err;
 626
 627	err = kstrtoul(buf, 10, &val);
 628	if (err)
 629		return err;
 630
 631	if (val > 255)
 632		return -EINVAL;
 633
 634	data->vrm = val;
 635	return count;
 636}
 637static DEVICE_ATTR_RW(vrm);
 638
 639static ssize_t alarms_in_show(struct device *dev,
 640			      struct device_attribute *attr, char *buf)
 641{
 642	struct pc87360_data *data = pc87360_update_device(dev);
 643	return sprintf(buf, "%u\n", data->in_alarms);
 644}
 645static DEVICE_ATTR_RO(alarms_in);
 646
 647static struct attribute *pc8736x_vin_attr_array[] = {
 648	VIN_UNIT_ATTRS(0),
 649	VIN_UNIT_ATTRS(1),
 650	VIN_UNIT_ATTRS(2),
 651	VIN_UNIT_ATTRS(3),
 652	VIN_UNIT_ATTRS(4),
 653	VIN_UNIT_ATTRS(5),
 654	VIN_UNIT_ATTRS(6),
 655	VIN_UNIT_ATTRS(7),
 656	VIN_UNIT_ATTRS(8),
 657	VIN_UNIT_ATTRS(9),
 658	VIN_UNIT_ATTRS(10),
 659	&dev_attr_cpu0_vid.attr,
 660	&dev_attr_vrm.attr,
 661	&dev_attr_alarms_in.attr,
 662	NULL
 663};
 664static const struct attribute_group pc8736x_vin_group = {
 665	.attrs = pc8736x_vin_attr_array,
 666};
 667
 668static ssize_t therm_input_show(struct device *dev,
 669				struct device_attribute *devattr, char *buf)
 670{
 671	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 672	struct pc87360_data *data = pc87360_update_device(dev);
 673	return sprintf(buf, "%u\n", IN_FROM_REG(data->in[attr->index],
 674		       data->in_vref));
 675}
 676
 677/*
 678 * the +11 term below reflects the fact that VLM units 11,12,13 are
 679 * used in the chip to measure voltage across the thermistors
 680 */
 681static struct sensor_device_attribute therm_input[] = {
 682	SENSOR_ATTR_RO(temp4_input, therm_input, 0 + 11),
 683	SENSOR_ATTR_RO(temp5_input, therm_input, 1 + 11),
 684	SENSOR_ATTR_RO(temp6_input, therm_input, 2 + 11),
 685};
 686
 687static ssize_t therm_status_show(struct device *dev,
 688				 struct device_attribute *devattr, char *buf)
 689{
 690	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 691	struct pc87360_data *data = pc87360_update_device(dev);
 692	return sprintf(buf, "%u\n", data->in_status[attr->index]);
 693}
 694
 695static struct sensor_device_attribute therm_status[] = {
 696	SENSOR_ATTR_RO(temp4_status, therm_status, 0 + 11),
 697	SENSOR_ATTR_RO(temp5_status, therm_status, 1 + 11),
 698	SENSOR_ATTR_RO(temp6_status, therm_status, 2 + 11),
 699};
 700
 701static ssize_t therm_min_show(struct device *dev,
 702			      struct device_attribute *devattr, char *buf)
 703{
 704	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 705	struct pc87360_data *data = pc87360_update_device(dev);
 706	return sprintf(buf, "%u\n", IN_FROM_REG(data->in_min[attr->index],
 707		       data->in_vref));
 708}
 709
 710static ssize_t therm_min_store(struct device *dev,
 711			       struct device_attribute *devattr,
 712			       const char *buf, size_t count)
 713{
 714	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 715	struct pc87360_data *data = dev_get_drvdata(dev);
 716	long val;
 717	int err;
 718
 719	err = kstrtol(buf, 10, &val);
 720	if (err)
 721		return err;
 722
 723	mutex_lock(&data->update_lock);
 724	data->in_min[attr->index] = IN_TO_REG(val, data->in_vref);
 725	pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_TEMP_MIN,
 726			    data->in_min[attr->index]);
 727	mutex_unlock(&data->update_lock);
 728	return count;
 729}
 730
 731static struct sensor_device_attribute therm_min[] = {
 732	SENSOR_ATTR_RW(temp4_min, therm_min, 0 + 11),
 733	SENSOR_ATTR_RW(temp5_min, therm_min, 1 + 11),
 734	SENSOR_ATTR_RW(temp6_min, therm_min, 2 + 11),
 735};
 736
 737static ssize_t therm_max_show(struct device *dev,
 738			      struct device_attribute *devattr, char *buf)
 739{
 740	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 741	struct pc87360_data *data = pc87360_update_device(dev);
 742	return sprintf(buf, "%u\n", IN_FROM_REG(data->in_max[attr->index],
 743		       data->in_vref));
 744}
 745
 746static ssize_t therm_max_store(struct device *dev,
 747			       struct device_attribute *devattr,
 748			       const char *buf, size_t count)
 749{
 750	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 751	struct pc87360_data *data = dev_get_drvdata(dev);
 752	long val;
 753	int err;
 754
 755	err = kstrtol(buf, 10, &val);
 756	if (err)
 757		return err;
 758
 759	mutex_lock(&data->update_lock);
 760	data->in_max[attr->index] = IN_TO_REG(val, data->in_vref);
 761	pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_TEMP_MAX,
 762			    data->in_max[attr->index]);
 763	mutex_unlock(&data->update_lock);
 764	return count;
 765}
 766
 767static struct sensor_device_attribute therm_max[] = {
 768	SENSOR_ATTR_RW(temp4_max, therm_max, 0 + 11),
 769	SENSOR_ATTR_RW(temp5_max, therm_max, 1 + 11),
 770	SENSOR_ATTR_RW(temp6_max, therm_max, 2 + 11),
 771};
 772
 773static ssize_t therm_crit_show(struct device *dev,
 774			       struct device_attribute *devattr, char *buf)
 775{
 776	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 777	struct pc87360_data *data = pc87360_update_device(dev);
 778	return sprintf(buf, "%u\n", IN_FROM_REG(data->in_crit[attr->index-11],
 779		       data->in_vref));
 780}
 781
 782static ssize_t therm_crit_store(struct device *dev,
 783				struct device_attribute *devattr,
 784				const char *buf, size_t count)
 785{
 786	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 787	struct pc87360_data *data = dev_get_drvdata(dev);
 788	long val;
 789	int err;
 790
 791	err = kstrtol(buf, 10, &val);
 792	if (err)
 793		return err;
 794
 795	mutex_lock(&data->update_lock);
 796	data->in_crit[attr->index-11] = IN_TO_REG(val, data->in_vref);
 797	pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_TEMP_CRIT,
 798			    data->in_crit[attr->index-11]);
 799	mutex_unlock(&data->update_lock);
 800	return count;
 801}
 802
 803static struct sensor_device_attribute therm_crit[] = {
 804	SENSOR_ATTR_RW(temp4_crit, therm_crit, 0 + 11),
 805	SENSOR_ATTR_RW(temp5_crit, therm_crit, 1 + 11),
 806	SENSOR_ATTR_RW(temp6_crit, therm_crit, 2 + 11),
 807};
 808
 809/*
 810 * show_therm_min/max_alarm() reads data from the per-channel voltage
 811 * status register (sec 11.5.12)
 812 */
 813static ssize_t therm_min_alarm_show(struct device *dev,
 814				    struct device_attribute *devattr,
 815				    char *buf)
 816{
 817	struct pc87360_data *data = pc87360_update_device(dev);
 818	unsigned nr = to_sensor_dev_attr(devattr)->index;
 819
 820	return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MIN));
 821}
 822
 823static struct sensor_device_attribute therm_min_alarm[] = {
 824	SENSOR_ATTR_RO(temp4_min_alarm, therm_min_alarm, 0 + 11),
 825	SENSOR_ATTR_RO(temp5_min_alarm, therm_min_alarm, 1 + 11),
 826	SENSOR_ATTR_RO(temp6_min_alarm, therm_min_alarm, 2 + 11),
 827};
 828
 829static ssize_t therm_max_alarm_show(struct device *dev,
 830				    struct device_attribute *devattr,
 831				    char *buf)
 832{
 833	struct pc87360_data *data = pc87360_update_device(dev);
 834	unsigned nr = to_sensor_dev_attr(devattr)->index;
 835
 836	return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MAX));
 837}
 838
 839static struct sensor_device_attribute therm_max_alarm[] = {
 840	SENSOR_ATTR_RO(temp4_max_alarm, therm_max_alarm, 0 + 11),
 841	SENSOR_ATTR_RO(temp5_max_alarm, therm_max_alarm, 1 + 11),
 842	SENSOR_ATTR_RO(temp6_max_alarm, therm_max_alarm, 2 + 11),
 843};
 844
 845static ssize_t therm_crit_alarm_show(struct device *dev,
 846				     struct device_attribute *devattr,
 847				     char *buf)
 848{
 849	struct pc87360_data *data = pc87360_update_device(dev);
 850	unsigned nr = to_sensor_dev_attr(devattr)->index;
 851
 852	return sprintf(buf, "%u\n", !!(data->in_status[nr] & TEMP_ALM_CRIT));
 853}
 854
 855static struct sensor_device_attribute therm_crit_alarm[] = {
 856	SENSOR_ATTR_RO(temp4_crit_alarm, therm_crit_alarm, 0 + 11),
 857	SENSOR_ATTR_RO(temp5_crit_alarm, therm_crit_alarm, 1 + 11),
 858	SENSOR_ATTR_RO(temp6_crit_alarm, therm_crit_alarm, 2 + 11),
 859};
 860
 861#define THERM_UNIT_ATTRS(X) \
 862	&therm_input[X].dev_attr.attr,	\
 863	&therm_status[X].dev_attr.attr,	\
 864	&therm_min[X].dev_attr.attr,	\
 865	&therm_max[X].dev_attr.attr,	\
 866	&therm_crit[X].dev_attr.attr,	\
 867	&therm_min_alarm[X].dev_attr.attr, \
 868	&therm_max_alarm[X].dev_attr.attr, \
 869	&therm_crit_alarm[X].dev_attr.attr
 870
 871static struct attribute *pc8736x_therm_attr_array[] = {
 872	THERM_UNIT_ATTRS(0),
 873	THERM_UNIT_ATTRS(1),
 874	THERM_UNIT_ATTRS(2),
 875	NULL
 876};
 877static const struct attribute_group pc8736x_therm_group = {
 878	.attrs = pc8736x_therm_attr_array,
 879};
 880
 881static ssize_t temp_input_show(struct device *dev,
 882			       struct device_attribute *devattr, char *buf)
 883{
 884	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 885	struct pc87360_data *data = pc87360_update_device(dev);
 886	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[attr->index]));
 887}
 888
 889static struct sensor_device_attribute temp_input[] = {
 890	SENSOR_ATTR_RO(temp1_input, temp_input, 0),
 891	SENSOR_ATTR_RO(temp2_input, temp_input, 1),
 892	SENSOR_ATTR_RO(temp3_input, temp_input, 2),
 893};
 894
 895static ssize_t temp_status_show(struct device *dev,
 896				struct device_attribute *devattr, char *buf)
 897{
 898	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 899	struct pc87360_data *data = pc87360_update_device(dev);
 900	return sprintf(buf, "%d\n", data->temp_status[attr->index]);
 901}
 902
 903static struct sensor_device_attribute temp_status[] = {
 904	SENSOR_ATTR_RO(temp1_status, temp_status, 0),
 905	SENSOR_ATTR_RO(temp2_status, temp_status, 1),
 906	SENSOR_ATTR_RO(temp3_status, temp_status, 2),
 907};
 908
 909static ssize_t temp_min_show(struct device *dev,
 910			     struct device_attribute *devattr, char *buf)
 911{
 912	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 913	struct pc87360_data *data = pc87360_update_device(dev);
 914	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[attr->index]));
 915}
 916
 917static ssize_t temp_min_store(struct device *dev,
 918			      struct device_attribute *devattr,
 919			      const char *buf, size_t count)
 920{
 921	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 922	struct pc87360_data *data = dev_get_drvdata(dev);
 923	long val;
 924	int err;
 925
 926	err = kstrtol(buf, 10, &val);
 927	if (err)
 928		return err;
 929
 930	mutex_lock(&data->update_lock);
 931	data->temp_min[attr->index] = TEMP_TO_REG(val);
 932	pc87360_write_value(data, LD_TEMP, attr->index, PC87365_REG_TEMP_MIN,
 933			    data->temp_min[attr->index]);
 934	mutex_unlock(&data->update_lock);
 935	return count;
 936}
 937
 938static struct sensor_device_attribute temp_min[] = {
 939	SENSOR_ATTR_RW(temp1_min, temp_min, 0),
 940	SENSOR_ATTR_RW(temp2_min, temp_min, 1),
 941	SENSOR_ATTR_RW(temp3_min, temp_min, 2),
 942};
 943
 944static ssize_t temp_max_show(struct device *dev,
 945			     struct device_attribute *devattr, char *buf)
 946{
 947	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 948	struct pc87360_data *data = pc87360_update_device(dev);
 949	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[attr->index]));
 950}
 951
 952static ssize_t temp_max_store(struct device *dev,
 953			      struct device_attribute *devattr,
 954			      const char *buf, size_t count)
 955{
 956	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 957	struct pc87360_data *data = dev_get_drvdata(dev);
 958	long val;
 959	int err;
 960
 961	err = kstrtol(buf, 10, &val);
 962	if (err)
 963		return err;
 964
 965	mutex_lock(&data->update_lock);
 966	data->temp_max[attr->index] = TEMP_TO_REG(val);
 967	pc87360_write_value(data, LD_TEMP, attr->index, PC87365_REG_TEMP_MAX,
 968			    data->temp_max[attr->index]);
 969	mutex_unlock(&data->update_lock);
 970	return count;
 971}
 972
 973static struct sensor_device_attribute temp_max[] = {
 974	SENSOR_ATTR_RW(temp1_max, temp_max, 0),
 975	SENSOR_ATTR_RW(temp2_max, temp_max, 1),
 976	SENSOR_ATTR_RW(temp3_max, temp_max, 2),
 977};
 978
 979static ssize_t temp_crit_show(struct device *dev,
 980			      struct device_attribute *devattr, char *buf)
 981{
 982	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 983	struct pc87360_data *data = pc87360_update_device(dev);
 984	return sprintf(buf, "%d\n",
 985		       TEMP_FROM_REG(data->temp_crit[attr->index]));
 986}
 987
 988static ssize_t temp_crit_store(struct device *dev,
 989			       struct device_attribute *devattr,
 990			       const char *buf, size_t count)
 991{
 992	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 993	struct pc87360_data *data = dev_get_drvdata(dev);
 994	long val;
 995	int err;
 996
 997	err = kstrtol(buf, 10, &val);
 998	if (err)
 999		return err;
1000
1001	mutex_lock(&data->update_lock);
1002	data->temp_crit[attr->index] = TEMP_TO_REG(val);
1003	pc87360_write_value(data, LD_TEMP, attr->index, PC87365_REG_TEMP_CRIT,
1004			    data->temp_crit[attr->index]);
1005	mutex_unlock(&data->update_lock);
1006	return count;
1007}
1008
1009static struct sensor_device_attribute temp_crit[] = {
1010	SENSOR_ATTR_RW(temp1_crit, temp_crit, 0),
1011	SENSOR_ATTR_RW(temp2_crit, temp_crit, 1),
1012	SENSOR_ATTR_RW(temp3_crit, temp_crit, 2),
1013};
1014
1015/*
1016 * temp_min/max_alarm_show() reads data from the per-channel status
1017 * register (sec 12.3.7), not the temp event status registers (sec
1018 * 12.3.2) that show_temp_alarm() reads (via data->temp_alarms)
1019 */
1020static ssize_t temp_min_alarm_show(struct device *dev,
1021				   struct device_attribute *devattr,
1022				   char *buf)
1023{
1024	struct pc87360_data *data = pc87360_update_device(dev);
1025	unsigned nr = to_sensor_dev_attr(devattr)->index;
1026
1027	return sprintf(buf, "%u\n", !!(data->temp_status[nr] & CHAN_ALM_MIN));
1028}
1029
1030static struct sensor_device_attribute temp_min_alarm[] = {
1031	SENSOR_ATTR_RO(temp1_min_alarm, temp_min_alarm, 0),
1032	SENSOR_ATTR_RO(temp2_min_alarm, temp_min_alarm, 1),
1033	SENSOR_ATTR_RO(temp3_min_alarm, temp_min_alarm, 2),
1034};
1035
1036static ssize_t temp_max_alarm_show(struct device *dev,
1037				   struct device_attribute *devattr,
1038				   char *buf)
1039{
1040	struct pc87360_data *data = pc87360_update_device(dev);
1041	unsigned nr = to_sensor_dev_attr(devattr)->index;
1042
1043	return sprintf(buf, "%u\n", !!(data->temp_status[nr] & CHAN_ALM_MAX));
1044}
1045
1046static struct sensor_device_attribute temp_max_alarm[] = {
1047	SENSOR_ATTR_RO(temp1_max_alarm, temp_max_alarm, 0),
1048	SENSOR_ATTR_RO(temp2_max_alarm, temp_max_alarm, 1),
1049	SENSOR_ATTR_RO(temp3_max_alarm, temp_max_alarm, 2),
1050};
1051
1052static ssize_t temp_crit_alarm_show(struct device *dev,
1053				    struct device_attribute *devattr,
1054				    char *buf)
1055{
1056	struct pc87360_data *data = pc87360_update_device(dev);
1057	unsigned nr = to_sensor_dev_attr(devattr)->index;
1058
1059	return sprintf(buf, "%u\n", !!(data->temp_status[nr] & TEMP_ALM_CRIT));
1060}
1061
1062static struct sensor_device_attribute temp_crit_alarm[] = {
1063	SENSOR_ATTR_RO(temp1_crit_alarm, temp_crit_alarm, 0),
1064	SENSOR_ATTR_RO(temp2_crit_alarm, temp_crit_alarm, 1),
1065	SENSOR_ATTR_RO(temp3_crit_alarm, temp_crit_alarm, 2),
1066};
1067
1068#define TEMP_FAULT	0x40	/* open diode */
1069static ssize_t temp_fault_show(struct device *dev,
1070			       struct device_attribute *devattr, char *buf)
1071{
1072	struct pc87360_data *data = pc87360_update_device(dev);
1073	unsigned nr = to_sensor_dev_attr(devattr)->index;
1074
1075	return sprintf(buf, "%u\n", !!(data->temp_status[nr] & TEMP_FAULT));
1076}
1077
1078static struct sensor_device_attribute temp_fault[] = {
1079	SENSOR_ATTR_RO(temp1_fault, temp_fault, 0),
1080	SENSOR_ATTR_RO(temp2_fault, temp_fault, 1),
1081	SENSOR_ATTR_RO(temp3_fault, temp_fault, 2),
1082};
1083
1084#define TEMP_UNIT_ATTRS(X)			\
1085{	&temp_input[X].dev_attr.attr,		\
1086	&temp_status[X].dev_attr.attr,		\
1087	&temp_min[X].dev_attr.attr,		\
1088	&temp_max[X].dev_attr.attr,		\
1089	&temp_crit[X].dev_attr.attr,		\
1090	&temp_min_alarm[X].dev_attr.attr,	\
1091	&temp_max_alarm[X].dev_attr.attr,	\
1092	&temp_crit_alarm[X].dev_attr.attr,	\
1093	&temp_fault[X].dev_attr.attr,		\
1094	NULL					\
1095}
1096
1097static struct attribute *pc8736x_temp_attr[][10] = {
1098	TEMP_UNIT_ATTRS(0),
1099	TEMP_UNIT_ATTRS(1),
1100	TEMP_UNIT_ATTRS(2)
1101};
1102
1103static const struct attribute_group pc8736x_temp_attr_group[] = {
1104	{ .attrs = pc8736x_temp_attr[0] },
1105	{ .attrs = pc8736x_temp_attr[1] },
1106	{ .attrs = pc8736x_temp_attr[2] }
1107};
1108
1109static ssize_t alarms_temp_show(struct device *dev,
1110				struct device_attribute *attr, char *buf)
1111{
1112	struct pc87360_data *data = pc87360_update_device(dev);
1113	return sprintf(buf, "%u\n", data->temp_alarms);
1114}
1115
1116static DEVICE_ATTR_RO(alarms_temp);
1117
1118static ssize_t fan_input_show(struct device *dev,
1119			      struct device_attribute *devattr, char *buf)
1120{
1121	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1122	struct pc87360_data *data = pc87360_update_device(dev);
1123	return sprintf(buf, "%u\n", FAN_FROM_REG(data->fan[attr->index],
1124		       FAN_DIV_FROM_REG(data->fan_status[attr->index])));
1125}
1126
1127static struct sensor_device_attribute fan_input[] = {
1128	SENSOR_ATTR_RO(fan1_input, fan_input, 0),
1129	SENSOR_ATTR_RO(fan2_input, fan_input, 1),
1130	SENSOR_ATTR_RO(fan3_input, fan_input, 2),
1131};
1132
1133static ssize_t fan_status_show(struct device *dev,
1134			       struct device_attribute *devattr, char *buf)
1135{
1136	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1137	struct pc87360_data *data = pc87360_update_device(dev);
1138	return sprintf(buf, "%u\n",
1139		       FAN_STATUS_FROM_REG(data->fan_status[attr->index]));
1140}
1141
1142static struct sensor_device_attribute fan_status[] = {
1143	SENSOR_ATTR_RO(fan1_status, fan_status, 0),
1144	SENSOR_ATTR_RO(fan2_status, fan_status, 1),
1145	SENSOR_ATTR_RO(fan3_status, fan_status, 2),
1146};
1147
1148static ssize_t fan_div_show(struct device *dev,
1149			    struct device_attribute *devattr, char *buf)
1150{
1151	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1152	struct pc87360_data *data = pc87360_update_device(dev);
1153	return sprintf(buf, "%u\n",
1154		       FAN_DIV_FROM_REG(data->fan_status[attr->index]));
1155}
1156
1157static struct sensor_device_attribute fan_div[] = {
1158	SENSOR_ATTR_RO(fan1_div, fan_div, 0),
1159	SENSOR_ATTR_RO(fan2_div, fan_div, 1),
1160	SENSOR_ATTR_RO(fan3_div, fan_div, 2),
1161};
1162
1163static ssize_t fan_min_show(struct device *dev,
1164			    struct device_attribute *devattr, char *buf)
1165{
1166	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1167	struct pc87360_data *data = pc87360_update_device(dev);
1168	return sprintf(buf, "%u\n", FAN_FROM_REG(data->fan_min[attr->index],
1169		       FAN_DIV_FROM_REG(data->fan_status[attr->index])));
1170}
1171
1172static ssize_t fan_min_store(struct device *dev,
1173			     struct device_attribute *devattr,
1174			     const char *buf, size_t count)
1175{
1176	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1177	struct pc87360_data *data = dev_get_drvdata(dev);
1178	long fan_min;
1179	int err;
1180
1181	err = kstrtol(buf, 10, &fan_min);
1182	if (err)
1183		return err;
1184
1185	mutex_lock(&data->update_lock);
1186	fan_min = FAN_TO_REG(fan_min,
1187			     FAN_DIV_FROM_REG(data->fan_status[attr->index]));
1188
1189	/* If it wouldn't fit, change clock divisor */
1190	while (fan_min > 255
1191	    && (data->fan_status[attr->index] & 0x60) != 0x60) {
1192		fan_min >>= 1;
1193		data->fan[attr->index] >>= 1;
1194		data->fan_status[attr->index] += 0x20;
1195	}
1196	data->fan_min[attr->index] = fan_min > 255 ? 255 : fan_min;
1197	pc87360_write_value(data, LD_FAN, NO_BANK,
1198			    PC87360_REG_FAN_MIN(attr->index),
1199			    data->fan_min[attr->index]);
1200
1201	/* Write new divider, preserve alarm bits */
1202	pc87360_write_value(data, LD_FAN, NO_BANK,
1203			    PC87360_REG_FAN_STATUS(attr->index),
1204			    data->fan_status[attr->index] & 0xF9);
1205	mutex_unlock(&data->update_lock);
1206
1207	return count;
1208}
1209
1210static struct sensor_device_attribute fan_min[] = {
1211	SENSOR_ATTR_RW(fan1_min, fan_min, 0),
1212	SENSOR_ATTR_RW(fan2_min, fan_min, 1),
1213	SENSOR_ATTR_RW(fan3_min, fan_min, 2),
1214};
1215
1216#define FAN_UNIT_ATTRS(X)		\
1217{	&fan_input[X].dev_attr.attr,	\
1218	&fan_status[X].dev_attr.attr,	\
1219	&fan_div[X].dev_attr.attr,	\
1220	&fan_min[X].dev_attr.attr,	\
1221	NULL				\
1222}
1223
1224static struct attribute *pc8736x_fan_attr[][5] = {
1225	FAN_UNIT_ATTRS(0),
1226	FAN_UNIT_ATTRS(1),
1227	FAN_UNIT_ATTRS(2)
1228};
1229
1230static const struct attribute_group pc8736x_fan_attr_group[] = {
1231	{ .attrs = pc8736x_fan_attr[0], },
1232	{ .attrs = pc8736x_fan_attr[1], },
1233	{ .attrs = pc8736x_fan_attr[2], },
1234};
1235
1236static ssize_t pwm_show(struct device *dev, struct device_attribute *devattr,
1237			char *buf)
1238{
1239	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1240	struct pc87360_data *data = pc87360_update_device(dev);
1241	return sprintf(buf, "%u\n",
1242		       PWM_FROM_REG(data->pwm[attr->index],
1243				    FAN_CONFIG_INVERT(data->fan_conf,
1244						      attr->index)));
1245}
1246
1247static ssize_t pwm_store(struct device *dev, struct device_attribute *devattr,
1248			 const char *buf, size_t count)
1249{
1250	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
1251	struct pc87360_data *data = dev_get_drvdata(dev);
1252	long val;
1253	int err;
1254
1255	err = kstrtol(buf, 10, &val);
1256	if (err)
1257		return err;
1258
1259	mutex_lock(&data->update_lock);
1260	data->pwm[attr->index] = PWM_TO_REG(val,
1261			      FAN_CONFIG_INVERT(data->fan_conf, attr->index));
1262	pc87360_write_value(data, LD_FAN, NO_BANK, PC87360_REG_PWM(attr->index),
1263			    data->pwm[attr->index]);
1264	mutex_unlock(&data->update_lock);
1265	return count;
1266}
1267
1268static struct sensor_device_attribute pwm[] = {
1269	SENSOR_ATTR_RW(pwm1, pwm, 0),
1270	SENSOR_ATTR_RW(pwm2, pwm, 1),
1271	SENSOR_ATTR_RW(pwm3, pwm, 2),
1272};
1273
1274static ssize_t name_show(struct device *dev,
1275			struct device_attribute *devattr, char *buf)
1276{
1277	struct pc87360_data *data = dev_get_drvdata(dev);
1278	return sprintf(buf, "%s\n", data->name);
1279}
1280
1281static DEVICE_ATTR_RO(name);
1282
1283static void pc87360_remove_files(struct device *dev)
1284{
1285	int i;
1286
1287	device_remove_file(dev, &dev_attr_name);
1288	device_remove_file(dev, &dev_attr_alarms_temp);
1289	for (i = 0; i < ARRAY_SIZE(pc8736x_temp_attr_group); i++)
1290		sysfs_remove_group(&dev->kobj, &pc8736x_temp_attr_group[i]);
1291	for (i = 0; i < ARRAY_SIZE(pc8736x_fan_attr_group); i++) {
1292		sysfs_remove_group(&pdev->dev.kobj, &pc8736x_fan_attr_group[i]);
1293		device_remove_file(dev, &pwm[i].dev_attr);
1294	}
1295	sysfs_remove_group(&dev->kobj, &pc8736x_therm_group);
1296	sysfs_remove_group(&dev->kobj, &pc8736x_vin_group);
1297}
1298
1299static void pc87360_init_device(struct platform_device *pdev,
1300				int use_thermistors)
1301{
1302	struct pc87360_data *data = platform_get_drvdata(pdev);
1303	int i, nr;
1304	const u8 init_in[14] = { 2, 2, 2, 2, 2, 2, 2, 1, 1, 3, 1, 2, 2, 2 };
1305	const u8 init_temp[3] = { 2, 2, 1 };
1306	u8 reg;
1307
1308	if (init >= 2 && data->innr) {
1309		reg = pc87360_read_value(data, LD_IN, NO_BANK,
1310					 PC87365_REG_IN_CONVRATE);
1311		dev_info(&pdev->dev,
1312			 "VLM conversion set to 1s period, 160us delay\n");
1313		pc87360_write_value(data, LD_IN, NO_BANK,
1314				    PC87365_REG_IN_CONVRATE,
1315				    (reg & 0xC0) | 0x11);
1316	}
1317
1318	nr = min(data->innr, 11);
1319	for (i = 0; i < nr; i++) {
1320		reg = pc87360_read_value(data, LD_IN, i,
1321					 PC87365_REG_IN_STATUS);
1322		dev_dbg(&pdev->dev, "bios in%d status:0x%02x\n", i, reg);
1323		if (init >= init_in[i]) {
1324			/* Forcibly enable voltage channel */
1325			if (!(reg & CHAN_ENA)) {
1326				dev_dbg(&pdev->dev, "Forcibly enabling in%d\n",
1327					i);
1328				pc87360_write_value(data, LD_IN, i,
1329						    PC87365_REG_IN_STATUS,
1330						    (reg & 0x68) | 0x87);
1331			}
1332		}
1333	}
1334
1335	/*
1336	 * We can't blindly trust the Super-I/O space configuration bit,
1337	 * most BIOS won't set it properly
1338	 */
1339	dev_dbg(&pdev->dev, "bios thermistors:%d\n", use_thermistors);
1340	for (i = 11; i < data->innr; i++) {
1341		reg = pc87360_read_value(data, LD_IN, i,
1342					 PC87365_REG_TEMP_STATUS);
1343		use_thermistors = use_thermistors || (reg & CHAN_ENA);
1344		/* thermistors are temp[4-6], measured on vin[11-14] */
1345		dev_dbg(&pdev->dev, "bios temp%d_status:0x%02x\n", i-7, reg);
1346	}
1347	dev_dbg(&pdev->dev, "using thermistors:%d\n", use_thermistors);
1348
1349	i = use_thermistors ? 2 : 0;
1350	for (; i < data->tempnr; i++) {
1351		reg = pc87360_read_value(data, LD_TEMP, i,
1352					 PC87365_REG_TEMP_STATUS);
1353		dev_dbg(&pdev->dev, "bios temp%d_status:0x%02x\n", i + 1, reg);
1354		if (init >= init_temp[i]) {
1355			/* Forcibly enable temperature channel */
1356			if (!(reg & CHAN_ENA)) {
1357				dev_dbg(&pdev->dev,
1358					"Forcibly enabling temp%d\n", i + 1);
1359				pc87360_write_value(data, LD_TEMP, i,
1360						    PC87365_REG_TEMP_STATUS,
1361						    0xCF);
1362			}
1363		}
1364	}
1365
1366	if (use_thermistors) {
1367		for (i = 11; i < data->innr; i++) {
1368			if (init >= init_in[i]) {
1369				/*
1370				 * The pin may already be used by thermal
1371				 * diodes
1372				 */
1373				reg = pc87360_read_value(data, LD_TEMP,
1374				      (i - 11) / 2, PC87365_REG_TEMP_STATUS);
1375				if (reg & CHAN_ENA) {
1376					dev_dbg(&pdev->dev,
1377			"Skipping temp%d, pin already in use by temp%d\n",
1378						i - 7, (i - 11) / 2);
1379					continue;
1380				}
1381
1382				/* Forcibly enable thermistor channel */
1383				reg = pc87360_read_value(data, LD_IN, i,
1384							 PC87365_REG_IN_STATUS);
1385				if (!(reg & CHAN_ENA)) {
1386					dev_dbg(&pdev->dev,
1387						"Forcibly enabling temp%d\n",
1388						i - 7);
1389					pc87360_write_value(data, LD_IN, i,
1390						PC87365_REG_TEMP_STATUS,
1391						(reg & 0x60) | 0x8F);
1392				}
1393			}
1394		}
1395	}
1396
1397	if (data->innr) {
1398		reg = pc87360_read_value(data, LD_IN, NO_BANK,
1399					 PC87365_REG_IN_CONFIG);
1400		dev_dbg(&pdev->dev, "bios vin-cfg:0x%02x\n", reg);
1401		if (reg & CHAN_ENA) {
1402			dev_dbg(&pdev->dev,
1403				"Forcibly enabling monitoring (VLM)\n");
1404			pc87360_write_value(data, LD_IN, NO_BANK,
1405					    PC87365_REG_IN_CONFIG,
1406					    reg & 0xFE);
1407		}
1408	}
1409
1410	if (data->tempnr) {
1411		reg = pc87360_read_value(data, LD_TEMP, NO_BANK,
1412					 PC87365_REG_TEMP_CONFIG);
1413		dev_dbg(&pdev->dev, "bios temp-cfg:0x%02x\n", reg);
1414		if (reg & CHAN_ENA) {
1415			dev_dbg(&pdev->dev,
1416				"Forcibly enabling monitoring (TMS)\n");
1417			pc87360_write_value(data, LD_TEMP, NO_BANK,
1418					    PC87365_REG_TEMP_CONFIG,
1419					    reg & 0xFE);
1420		}
1421
1422		if (init >= 2) {
1423			/* Chip config as documented by National Semi. */
1424			pc87360_write_value(data, LD_TEMP, 0xF, 0xA, 0x08);
1425			/*
1426			 * We voluntarily omit the bank here, in case the
1427			 * sequence itself matters. It shouldn't be a problem,
1428			 * since nobody else is supposed to access the
1429			 * device at that point.
1430			 */
1431			pc87360_write_value(data, LD_TEMP, NO_BANK, 0xB, 0x04);
1432			pc87360_write_value(data, LD_TEMP, NO_BANK, 0xC, 0x35);
1433			pc87360_write_value(data, LD_TEMP, NO_BANK, 0xD, 0x05);
1434			pc87360_write_value(data, LD_TEMP, NO_BANK, 0xE, 0x05);
1435		}
1436	}
1437}
1438
1439static int pc87360_probe(struct platform_device *pdev)
1440{
1441	int i;
1442	struct pc87360_data *data;
1443	int err = 0;
1444	const char *name;
1445	int use_thermistors = 0;
1446	struct device *dev = &pdev->dev;
1447
1448	data = devm_kzalloc(dev, sizeof(struct pc87360_data), GFP_KERNEL);
1449	if (!data)
1450		return -ENOMEM;
1451
1452	switch (devid) {
1453	default:
1454		name = "pc87360";
1455		data->fannr = 2;
1456		break;
1457	case 0xe8:
1458		name = "pc87363";
1459		data->fannr = 2;
1460		break;
1461	case 0xe4:
1462		name = "pc87364";
1463		data->fannr = 3;
1464		break;
1465	case 0xe5:
1466		name = "pc87365";
1467		data->fannr = extra_isa[0] ? 3 : 0;
1468		data->innr = extra_isa[1] ? 11 : 0;
1469		data->tempnr = extra_isa[2] ? 2 : 0;
1470		break;
1471	case 0xe9:
1472		name = "pc87366";
1473		data->fannr = extra_isa[0] ? 3 : 0;
1474		data->innr = extra_isa[1] ? 14 : 0;
1475		data->tempnr = extra_isa[2] ? 3 : 0;
1476		break;
1477	}
1478
1479	data->name = name;
1480	mutex_init(&data->lock);
1481	mutex_init(&data->update_lock);
1482	platform_set_drvdata(pdev, data);
1483
1484	for (i = 0; i < LDNI_MAX; i++) {
1485		data->address[i] = extra_isa[i];
1486		if (data->address[i]
1487		 && !devm_request_region(dev, extra_isa[i], PC87360_EXTENT,
1488					 DRIVER_NAME)) {
1489			dev_err(dev,
1490				"Region 0x%x-0x%x already in use!\n",
1491				extra_isa[i], extra_isa[i]+PC87360_EXTENT-1);
1492			return -EBUSY;
1493		}
1494	}
1495
1496	/* Retrieve the fans configuration from Super-I/O space */
1497	if (data->fannr)
1498		data->fan_conf = confreg[0] | (confreg[1] << 8);
1499
1500	/*
1501	 * Use the correct reference voltage
1502	 * Unless both the VLM and the TMS logical devices agree to
1503	 * use an external Vref, the internal one is used.
1504	 */
1505	if (data->innr) {
1506		i = pc87360_read_value(data, LD_IN, NO_BANK,
1507				       PC87365_REG_IN_CONFIG);
1508		if (data->tempnr) {
1509			i &= pc87360_read_value(data, LD_TEMP, NO_BANK,
1510						PC87365_REG_TEMP_CONFIG);
1511		}
1512		data->in_vref = (i&0x02) ? 3025 : 2966;
1513		dev_dbg(dev, "Using %s reference voltage\n",
1514			(i&0x02) ? "external" : "internal");
1515
1516		data->vid_conf = confreg[3];
1517		data->vrm = vid_which_vrm();
1518	}
1519
1520	/* Fan clock dividers may be needed before any data is read */
1521	for (i = 0; i < data->fannr; i++) {
1522		if (FAN_CONFIG_MONITOR(data->fan_conf, i))
1523			data->fan_status[i] = pc87360_read_value(data,
1524					      LD_FAN, NO_BANK,
1525					      PC87360_REG_FAN_STATUS(i));
1526	}
1527
1528	if (init > 0) {
1529		if (devid == 0xe9 && data->address[1]) /* PC87366 */
1530			use_thermistors = confreg[2] & 0x40;
1531
1532		pc87360_init_device(pdev, use_thermistors);
1533	}
1534
1535	/* Register all-or-nothing sysfs groups */
1536
1537	if (data->innr) {
1538		err = sysfs_create_group(&dev->kobj, &pc8736x_vin_group);
1539		if (err)
1540			goto error;
1541	}
1542
1543	if (data->innr == 14) {
1544		err = sysfs_create_group(&dev->kobj, &pc8736x_therm_group);
1545		if (err)
1546			goto error;
1547	}
1548
1549	/* create device attr-files for varying sysfs groups */
1550
1551	if (data->tempnr) {
1552		for (i = 0; i < data->tempnr; i++) {
1553			err = sysfs_create_group(&dev->kobj,
1554						 &pc8736x_temp_attr_group[i]);
1555			if (err)
1556				goto error;
1557		}
1558		err = device_create_file(dev, &dev_attr_alarms_temp);
1559		if (err)
1560			goto error;
1561	}
1562
1563	for (i = 0; i < data->fannr; i++) {
1564		if (FAN_CONFIG_MONITOR(data->fan_conf, i)) {
1565			err = sysfs_create_group(&dev->kobj,
1566						 &pc8736x_fan_attr_group[i]);
1567			if (err)
1568				goto error;
1569		}
1570		if (FAN_CONFIG_CONTROL(data->fan_conf, i)) {
1571			err = device_create_file(dev, &pwm[i].dev_attr);
1572			if (err)
1573				goto error;
1574		}
1575	}
1576
1577	err = device_create_file(dev, &dev_attr_name);
1578	if (err)
1579		goto error;
1580
1581	data->hwmon_dev = hwmon_device_register(dev);
1582	if (IS_ERR(data->hwmon_dev)) {
1583		err = PTR_ERR(data->hwmon_dev);
1584		goto error;
1585	}
1586	return 0;
1587
1588error:
1589	pc87360_remove_files(dev);
1590	return err;
1591}
1592
1593static void pc87360_remove(struct platform_device *pdev)
1594{
1595	struct pc87360_data *data = platform_get_drvdata(pdev);
1596
1597	hwmon_device_unregister(data->hwmon_dev);
1598	pc87360_remove_files(&pdev->dev);
 
 
1599}
1600
1601/*
1602 * Driver data
1603 */
1604static struct platform_driver pc87360_driver = {
1605	.driver = {
1606		.name	= DRIVER_NAME,
1607	},
1608	.probe		= pc87360_probe,
1609	.remove		= pc87360_remove,
1610};
1611
1612/*
1613 * Device detection, registration and update
1614 */
1615
1616static int __init pc87360_find(int sioaddr, u8 *devid,
1617			       unsigned short *addresses)
1618{
1619	u16 val;
1620	int i;
1621	int nrdev; /* logical device count */
1622
1623	/* No superio_enter */
1624
1625	/* Identify device */
1626	val = force_id ? force_id : superio_inb(sioaddr, DEVID);
1627	switch (val) {
1628	case 0xE1: /* PC87360 */
1629	case 0xE8: /* PC87363 */
1630	case 0xE4: /* PC87364 */
1631		nrdev = 1;
1632		break;
1633	case 0xE5: /* PC87365 */
1634	case 0xE9: /* PC87366 */
1635		nrdev = 3;
1636		break;
1637	default:
1638		superio_exit(sioaddr);
1639		return -ENODEV;
1640	}
1641	/* Remember the device id */
1642	*devid = val;
1643
1644	for (i = 0; i < nrdev; i++) {
1645		/* select logical device */
1646		superio_outb(sioaddr, DEV, logdev[i]);
1647
1648		val = superio_inb(sioaddr, ACT);
1649		if (!(val & 0x01)) {
1650			pr_info("Device 0x%02x not activated\n", logdev[i]);
1651			continue;
1652		}
1653
1654		val = (superio_inb(sioaddr, BASE) << 8)
1655		    | superio_inb(sioaddr, BASE + 1);
1656		if (!val) {
1657			pr_info("Base address not set for device 0x%02x\n",
1658				logdev[i]);
1659			continue;
1660		}
1661
1662		addresses[i] = val;
1663
1664		if (i == 0) { /* Fans */
1665			confreg[0] = superio_inb(sioaddr, 0xF0);
1666			confreg[1] = superio_inb(sioaddr, 0xF1);
1667
1668			pr_debug("Fan %d: mon=%d ctrl=%d inv=%d\n", 1,
1669				 (confreg[0] >> 2) & 1, (confreg[0] >> 3) & 1,
1670				 (confreg[0] >> 4) & 1);
1671			pr_debug("Fan %d: mon=%d ctrl=%d inv=%d\n", 2,
1672				 (confreg[0] >> 5) & 1, (confreg[0] >> 6) & 1,
1673				 (confreg[0] >> 7) & 1);
1674			pr_debug("Fan %d: mon=%d ctrl=%d inv=%d\n", 3,
1675				 confreg[1] & 1, (confreg[1] >> 1) & 1,
1676				 (confreg[1] >> 2) & 1);
1677		} else if (i == 1) { /* Voltages */
1678			/* Are we using thermistors? */
1679			if (*devid == 0xE9) { /* PC87366 */
1680				/*
1681				 * These registers are not logical-device
1682				 * specific, just that we won't need them if
1683				 * we don't use the VLM device
1684				 */
1685				confreg[2] = superio_inb(sioaddr, 0x2B);
1686				confreg[3] = superio_inb(sioaddr, 0x25);
1687
1688				if (confreg[2] & 0x40) {
1689					pr_info("Using thermistors for temperature monitoring\n");
1690				}
1691				if (confreg[3] & 0xE0) {
1692					pr_info("VID inputs routed (mode %u)\n",
1693						confreg[3] >> 5);
1694				}
1695			}
1696		}
1697	}
1698
1699	superio_exit(sioaddr);
1700	return 0;
1701}
1702
1703static int __init pc87360_device_add(unsigned short address)
1704{
1705	struct resource res[3];
1706	int err, i, res_count;
1707
1708	pdev = platform_device_alloc("pc87360", address);
1709	if (!pdev) {
1710		err = -ENOMEM;
1711		pr_err("Device allocation failed\n");
1712		goto exit;
1713	}
1714
1715	memset(res, 0, 3 * sizeof(struct resource));
1716	res_count = 0;
1717	for (i = 0; i < 3; i++) {
1718		if (!extra_isa[i])
1719			continue;
1720		res[res_count].start = extra_isa[i];
1721		res[res_count].end = extra_isa[i] + PC87360_EXTENT - 1;
1722		res[res_count].name = "pc87360";
1723		res[res_count].flags = IORESOURCE_IO;
1724
1725		err = acpi_check_resource_conflict(&res[res_count]);
1726		if (err)
1727			goto exit_device_put;
1728
1729		res_count++;
1730	}
1731
1732	err = platform_device_add_resources(pdev, res, res_count);
1733	if (err) {
1734		pr_err("Device resources addition failed (%d)\n", err);
1735		goto exit_device_put;
1736	}
1737
1738	err = platform_device_add(pdev);
1739	if (err) {
1740		pr_err("Device addition failed (%d)\n", err);
1741		goto exit_device_put;
1742	}
1743
1744	return 0;
1745
1746exit_device_put:
1747	platform_device_put(pdev);
1748exit:
1749	return err;
1750}
1751
1752static int __init pc87360_init(void)
1753{
1754	int err, i;
1755	unsigned short address = 0;
1756
1757	if (pc87360_find(0x2e, &devid, extra_isa)
1758	 && pc87360_find(0x4e, &devid, extra_isa)) {
1759		pr_warn("PC8736x not detected, module not inserted\n");
1760		return -ENODEV;
1761	}
1762
1763	/* Arbitrarily pick one of the addresses */
1764	for (i = 0; i < 3; i++) {
1765		if (extra_isa[i] != 0x0000) {
1766			address = extra_isa[i];
1767			break;
1768		}
1769	}
1770
1771	if (address == 0x0000) {
1772		pr_warn("No active logical device, module not inserted\n");
1773		return -ENODEV;
1774	}
1775
1776	err = platform_driver_register(&pc87360_driver);
1777	if (err)
1778		goto exit;
1779
1780	/* Sets global pdev as a side effect */
1781	err = pc87360_device_add(address);
1782	if (err)
1783		goto exit_driver;
1784
1785	return 0;
1786
1787 exit_driver:
1788	platform_driver_unregister(&pc87360_driver);
1789 exit:
1790	return err;
1791}
1792
1793static void __exit pc87360_exit(void)
1794{
1795	platform_device_unregister(pdev);
1796	platform_driver_unregister(&pc87360_driver);
1797}
1798
1799MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
1800MODULE_DESCRIPTION("PC8736x hardware monitor");
1801MODULE_LICENSE("GPL");
1802MODULE_ALIAS("platform:" DRIVER_NAME);
1803
1804module_init(pc87360_init);
1805module_exit(pc87360_exit);