1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * f71805f.c - driver for the Fintek F71805F/FG and F71872F/FG Super-I/O
   4 *             chips integrated hardware monitoring features
   5 * Copyright (C) 2005-2006  Jean Delvare <jdelvare@suse.de>
   6 *
   7 * The F71805F/FG is a LPC Super-I/O chip made by Fintek. It integrates
   8 * complete hardware monitoring features: voltage, fan and temperature
   9 * sensors, and manual and automatic fan speed control.
  10 *
  11 * The F71872F/FG is almost the same, with two more voltages monitored,
  12 * and 6 VID inputs.
  13 *
  14 * The F71806F/FG is essentially the same as the F71872F/FG. It even has
  15 * the same chip ID, so the driver can't differentiate between.
  16 */
  17
  18#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  19
  20#include <linux/module.h>
  21#include <linux/init.h>
  22#include <linux/slab.h>
  23#include <linux/jiffies.h>
  24#include <linux/platform_device.h>
  25#include <linux/hwmon.h>
  26#include <linux/hwmon-sysfs.h>
  27#include <linux/err.h>
  28#include <linux/mutex.h>
  29#include <linux/sysfs.h>
  30#include <linux/ioport.h>
  31#include <linux/acpi.h>
  32#include <linux/io.h>
  33
  34static unsigned short force_id;
  35module_param(force_id, ushort, 0);
  36MODULE_PARM_DESC(force_id, "Override the detected device ID");
  37
  38static struct platform_device *pdev;
  39
  40#define DRVNAME "f71805f"
  41enum kinds { f71805f, f71872f };
  42
  43/*
  44 * Super-I/O constants and functions
  45 */
  46
  47#define F71805F_LD_HWM		0x04
  48
  49#define SIO_REG_LDSEL		0x07	/* Logical device select */
  50#define SIO_REG_DEVID		0x20	/* Device ID (2 bytes) */
  51#define SIO_REG_DEVREV		0x22	/* Device revision */
  52#define SIO_REG_MANID		0x23	/* Fintek ID (2 bytes) */
  53#define SIO_REG_FNSEL1		0x29	/* Multi Function Select 1 (F71872F) */
  54#define SIO_REG_ENABLE		0x30	/* Logical device enable */
  55#define SIO_REG_ADDR		0x60	/* Logical device address (2 bytes) */
  56
  57#define SIO_FINTEK_ID		0x1934
  58#define SIO_F71805F_ID		0x0406
  59#define SIO_F71872F_ID		0x0341
  60
  61static inline int
  62superio_inb(int base, int reg)
  63{
  64	outb(reg, base);
  65	return inb(base + 1);
  66}
  67
  68static int
  69superio_inw(int base, int reg)
  70{
  71	int val;
  72	outb(reg++, base);
  73	val = inb(base + 1) << 8;
  74	outb(reg, base);
  75	val |= inb(base + 1);
  76	return val;
  77}
  78
  79static inline void
  80superio_select(int base, int ld)
  81{
  82	outb(SIO_REG_LDSEL, base);
  83	outb(ld, base + 1);
  84}
  85
  86static inline int
  87superio_enter(int base)
  88{
  89	if (!request_muxed_region(base, 2, DRVNAME))
  90		return -EBUSY;
  91
  92	outb(0x87, base);
  93	outb(0x87, base);
  94
  95	return 0;
  96}
  97
  98static inline void
  99superio_exit(int base)
 100{
 101	outb(0xaa, base);
 102	release_region(base, 2);
 103}
 104
 105/*
 106 * ISA constants
 107 */
 108
 109#define REGION_LENGTH		8
 110#define ADDR_REG_OFFSET		5
 111#define DATA_REG_OFFSET		6
 112
 113/*
 114 * Registers
 115 */
 116
 117/* in nr from 0 to 10 (8-bit values) */
 118#define F71805F_REG_IN(nr)		(0x10 + (nr))
 119#define F71805F_REG_IN_HIGH(nr)		((nr) < 10 ? 0x40 + 2 * (nr) : 0x2E)
 120#define F71805F_REG_IN_LOW(nr)		((nr) < 10 ? 0x41 + 2 * (nr) : 0x2F)
 121/* fan nr from 0 to 2 (12-bit values, two registers) */
 122#define F71805F_REG_FAN(nr)		(0x20 + 2 * (nr))
 123#define F71805F_REG_FAN_LOW(nr)		(0x28 + 2 * (nr))
 124#define F71805F_REG_FAN_TARGET(nr)	(0x69 + 16 * (nr))
 125#define F71805F_REG_FAN_CTRL(nr)	(0x60 + 16 * (nr))
 126#define F71805F_REG_PWM_FREQ(nr)	(0x63 + 16 * (nr))
 127#define F71805F_REG_PWM_DUTY(nr)	(0x6B + 16 * (nr))
 128/* temp nr from 0 to 2 (8-bit values) */
 129#define F71805F_REG_TEMP(nr)		(0x1B + (nr))
 130#define F71805F_REG_TEMP_HIGH(nr)	(0x54 + 2 * (nr))
 131#define F71805F_REG_TEMP_HYST(nr)	(0x55 + 2 * (nr))
 132#define F71805F_REG_TEMP_MODE		0x01
 133/* pwm/fan pwmnr from 0 to 2, auto point apnr from 0 to 2 */
 134/* map Fintek numbers to our numbers as follows: 9->0, 5->1, 1->2 */
 135#define F71805F_REG_PWM_AUTO_POINT_TEMP(pwmnr, apnr) \
 136					(0xA0 + 0x10 * (pwmnr) + (2 - (apnr)))
 137#define F71805F_REG_PWM_AUTO_POINT_FAN(pwmnr, apnr) \
 138					(0xA4 + 0x10 * (pwmnr) + \
 139						2 * (2 - (apnr)))
 140
 141#define F71805F_REG_START		0x00
 142/* status nr from 0 to 2 */
 143#define F71805F_REG_STATUS(nr)		(0x36 + (nr))
 144
 145/* individual register bits */
 146#define FAN_CTRL_DC_MODE		0x10
 147#define FAN_CTRL_LATCH_FULL		0x08
 148#define FAN_CTRL_MODE_MASK		0x03
 149#define FAN_CTRL_MODE_SPEED		0x00
 150#define FAN_CTRL_MODE_TEMPERATURE	0x01
 151#define FAN_CTRL_MODE_MANUAL		0x02
 152
 153/*
 154 * Data structures and manipulation thereof
 155 */
 156
 157struct f71805f_auto_point {
 158	u8 temp[3];
 159	u16 fan[3];
 160};
 161
 162struct f71805f_data {
 163	unsigned short addr;
 164	const char *name;
 165	struct device *hwmon_dev;
 166
 167	struct mutex update_lock;
 168	char valid;		/* !=0 if following fields are valid */
 169	unsigned long last_updated;	/* In jiffies */
 170	unsigned long last_limits;	/* In jiffies */
 171
 172	/* Register values */
 173	u8 in[11];
 174	u8 in_high[11];
 175	u8 in_low[11];
 176	u16 has_in;
 177	u16 fan[3];
 178	u16 fan_low[3];
 179	u16 fan_target[3];
 180	u8 fan_ctrl[3];
 181	u8 pwm[3];
 182	u8 pwm_freq[3];
 183	u8 temp[3];
 184	u8 temp_high[3];
 185	u8 temp_hyst[3];
 186	u8 temp_mode;
 187	unsigned long alarms;
 188	struct f71805f_auto_point auto_points[3];
 189};
 190
 191struct f71805f_sio_data {
 192	enum kinds kind;
 193	u8 fnsel1;
 194};
 195
 196static inline long in_from_reg(u8 reg)
 197{
 198	return reg * 8;
 199}
 200
 201/* The 2 least significant bits are not used */
 202static inline u8 in_to_reg(long val)
 203{
 204	if (val <= 0)
 205		return 0;
 206	if (val >= 2016)
 207		return 0xfc;
 208	return ((val + 16) / 32) << 2;
 209}
 210
 211/* in0 is downscaled by a factor 2 internally */
 212static inline long in0_from_reg(u8 reg)
 213{
 214	return reg * 16;
 215}
 216
 217static inline u8 in0_to_reg(long val)
 218{
 219	if (val <= 0)
 220		return 0;
 221	if (val >= 4032)
 222		return 0xfc;
 223	return ((val + 32) / 64) << 2;
 224}
 225
 226/* The 4 most significant bits are not used */
 227static inline long fan_from_reg(u16 reg)
 228{
 229	reg &= 0xfff;
 230	if (!reg || reg == 0xfff)
 231		return 0;
 232	return 1500000 / reg;
 233}
 234
 235static inline u16 fan_to_reg(long rpm)
 236{
 237	/*
 238	 * If the low limit is set below what the chip can measure,
 239	 * store the largest possible 12-bit value in the registers,
 240	 * so that no alarm will ever trigger.
 241	 */
 242	if (rpm < 367)
 243		return 0xfff;
 244	return 1500000 / rpm;
 245}
 246
 247static inline unsigned long pwm_freq_from_reg(u8 reg)
 248{
 249	unsigned long clock = (reg & 0x80) ? 48000000UL : 1000000UL;
 250
 251	reg &= 0x7f;
 252	if (reg == 0)
 253		reg++;
 254	return clock / (reg << 8);
 255}
 256
 257static inline u8 pwm_freq_to_reg(unsigned long val)
 258{
 259	if (val >= 187500)	/* The highest we can do */
 260		return 0x80;
 261	if (val >= 1475)	/* Use 48 MHz clock */
 262		return 0x80 | (48000000UL / (val << 8));
 263	if (val < 31)		/* The lowest we can do */
 264		return 0x7f;
 265	else			/* Use 1 MHz clock */
 266		return 1000000UL / (val << 8);
 267}
 268
 269static inline int pwm_mode_from_reg(u8 reg)
 270{
 271	return !(reg & FAN_CTRL_DC_MODE);
 272}
 273
 274static inline long temp_from_reg(u8 reg)
 275{
 276	return reg * 1000;
 277}
 278
 279static inline u8 temp_to_reg(long val)
 280{
 281	if (val <= 0)
 282		return 0;
 283	if (val >= 1000 * 0xff)
 284		return 0xff;
 285	return (val + 500) / 1000;
 286}
 287
 288/*
 289 * Device I/O access
 290 */
 291
 292/* Must be called with data->update_lock held, except during initialization */
 293static u8 f71805f_read8(struct f71805f_data *data, u8 reg)
 294{
 295	outb(reg, data->addr + ADDR_REG_OFFSET);
 296	return inb(data->addr + DATA_REG_OFFSET);
 297}
 298
 299/* Must be called with data->update_lock held, except during initialization */
 300static void f71805f_write8(struct f71805f_data *data, u8 reg, u8 val)
 301{
 302	outb(reg, data->addr + ADDR_REG_OFFSET);
 303	outb(val, data->addr + DATA_REG_OFFSET);
 304}
 305
 306/*
 307 * It is important to read the MSB first, because doing so latches the
 308 * value of the LSB, so we are sure both bytes belong to the same value.
 309 * Must be called with data->update_lock held, except during initialization
 310 */
 311static u16 f71805f_read16(struct f71805f_data *data, u8 reg)
 312{
 313	u16 val;
 314
 315	outb(reg, data->addr + ADDR_REG_OFFSET);
 316	val = inb(data->addr + DATA_REG_OFFSET) << 8;
 317	outb(++reg, data->addr + ADDR_REG_OFFSET);
 318	val |= inb(data->addr + DATA_REG_OFFSET);
 319
 320	return val;
 321}
 322
 323/* Must be called with data->update_lock held, except during initialization */
 324static void f71805f_write16(struct f71805f_data *data, u8 reg, u16 val)
 325{
 326	outb(reg, data->addr + ADDR_REG_OFFSET);
 327	outb(val >> 8, data->addr + DATA_REG_OFFSET);
 328	outb(++reg, data->addr + ADDR_REG_OFFSET);
 329	outb(val & 0xff, data->addr + DATA_REG_OFFSET);
 330}
 331
 332static struct f71805f_data *f71805f_update_device(struct device *dev)
 333{
 334	struct f71805f_data *data = dev_get_drvdata(dev);
 335	int nr, apnr;
 336
 337	mutex_lock(&data->update_lock);
 338
 339	/* Limit registers cache is refreshed after 60 seconds */
 340	if (time_after(jiffies, data->last_updated + 60 * HZ)
 341	 || !data->valid) {
 342		for (nr = 0; nr < 11; nr++) {
 343			if (!(data->has_in & (1 << nr)))
 344				continue;
 345			data->in_high[nr] = f71805f_read8(data,
 346					    F71805F_REG_IN_HIGH(nr));
 347			data->in_low[nr] = f71805f_read8(data,
 348					   F71805F_REG_IN_LOW(nr));
 349		}
 350		for (nr = 0; nr < 3; nr++) {
 351			data->fan_low[nr] = f71805f_read16(data,
 352					    F71805F_REG_FAN_LOW(nr));
 353			data->fan_target[nr] = f71805f_read16(data,
 354					       F71805F_REG_FAN_TARGET(nr));
 355			data->pwm_freq[nr] = f71805f_read8(data,
 356					     F71805F_REG_PWM_FREQ(nr));
 357		}
 358		for (nr = 0; nr < 3; nr++) {
 359			data->temp_high[nr] = f71805f_read8(data,
 360					      F71805F_REG_TEMP_HIGH(nr));
 361			data->temp_hyst[nr] = f71805f_read8(data,
 362					      F71805F_REG_TEMP_HYST(nr));
 363		}
 364		data->temp_mode = f71805f_read8(data, F71805F_REG_TEMP_MODE);
 365		for (nr = 0; nr < 3; nr++) {
 366			for (apnr = 0; apnr < 3; apnr++) {
 367				data->auto_points[nr].temp[apnr] =
 368					f71805f_read8(data,
 369					F71805F_REG_PWM_AUTO_POINT_TEMP(nr,
 370									apnr));
 371				data->auto_points[nr].fan[apnr] =
 372					f71805f_read16(data,
 373					F71805F_REG_PWM_AUTO_POINT_FAN(nr,
 374								       apnr));
 375			}
 376		}
 377
 378		data->last_limits = jiffies;
 379	}
 380
 381	/* Measurement registers cache is refreshed after 1 second */
 382	if (time_after(jiffies, data->last_updated + HZ)
 383	 || !data->valid) {
 384		for (nr = 0; nr < 11; nr++) {
 385			if (!(data->has_in & (1 << nr)))
 386				continue;
 387			data->in[nr] = f71805f_read8(data,
 388				       F71805F_REG_IN(nr));
 389		}
 390		for (nr = 0; nr < 3; nr++) {
 391			data->fan[nr] = f71805f_read16(data,
 392					F71805F_REG_FAN(nr));
 393			data->fan_ctrl[nr] = f71805f_read8(data,
 394					     F71805F_REG_FAN_CTRL(nr));
 395			data->pwm[nr] = f71805f_read8(data,
 396					F71805F_REG_PWM_DUTY(nr));
 397		}
 398		for (nr = 0; nr < 3; nr++) {
 399			data->temp[nr] = f71805f_read8(data,
 400					 F71805F_REG_TEMP(nr));
 401		}
 402		data->alarms = f71805f_read8(data, F71805F_REG_STATUS(0))
 403			+ (f71805f_read8(data, F71805F_REG_STATUS(1)) << 8)
 404			+ (f71805f_read8(data, F71805F_REG_STATUS(2)) << 16);
 405
 406		data->last_updated = jiffies;
 407		data->valid = 1;
 408	}
 409
 410	mutex_unlock(&data->update_lock);
 411
 412	return data;
 413}
 414
 415/*
 416 * Sysfs interface
 417 */
 418
 419static ssize_t show_in0(struct device *dev, struct device_attribute *devattr,
 420			char *buf)
 421{
 422	struct f71805f_data *data = f71805f_update_device(dev);
 423	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 424	int nr = attr->index;
 425
 426	return sprintf(buf, "%ld\n", in0_from_reg(data->in[nr]));
 427}
 428
 429static ssize_t show_in0_max(struct device *dev, struct device_attribute
 430			    *devattr, char *buf)
 431{
 432	struct f71805f_data *data = f71805f_update_device(dev);
 433	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 434	int nr = attr->index;
 435
 436	return sprintf(buf, "%ld\n", in0_from_reg(data->in_high[nr]));
 437}
 438
 439static ssize_t show_in0_min(struct device *dev, struct device_attribute
 440			    *devattr, char *buf)
 441{
 442	struct f71805f_data *data = f71805f_update_device(dev);
 443	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 444	int nr = attr->index;
 445
 446	return sprintf(buf, "%ld\n", in0_from_reg(data->in_low[nr]));
 447}
 448
 449static ssize_t set_in0_max(struct device *dev, struct device_attribute
 450			   *devattr, const char *buf, size_t count)
 451{
 452	struct f71805f_data *data = dev_get_drvdata(dev);
 453	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 454	int nr = attr->index;
 455	long val;
 456	int err;
 457
 458	err = kstrtol(buf, 10, &val);
 459	if (err)
 460		return err;
 461
 462	mutex_lock(&data->update_lock);
 463	data->in_high[nr] = in0_to_reg(val);
 464	f71805f_write8(data, F71805F_REG_IN_HIGH(nr), data->in_high[nr]);
 465	mutex_unlock(&data->update_lock);
 466
 467	return count;
 468}
 469
 470static ssize_t set_in0_min(struct device *dev, struct device_attribute
 471			   *devattr, const char *buf, size_t count)
 472{
 473	struct f71805f_data *data = dev_get_drvdata(dev);
 474	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 475	int nr = attr->index;
 476	long val;
 477	int err;
 478
 479	err = kstrtol(buf, 10, &val);
 480	if (err)
 481		return err;
 482
 483	mutex_lock(&data->update_lock);
 484	data->in_low[nr] = in0_to_reg(val);
 485	f71805f_write8(data, F71805F_REG_IN_LOW(nr), data->in_low[nr]);
 486	mutex_unlock(&data->update_lock);
 487
 488	return count;
 489}
 490
 491static ssize_t show_in(struct device *dev, struct device_attribute *devattr,
 492		       char *buf)
 493{
 494	struct f71805f_data *data = f71805f_update_device(dev);
 495	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 496	int nr = attr->index;
 497
 498	return sprintf(buf, "%ld\n", in_from_reg(data->in[nr]));
 499}
 500
 501static ssize_t show_in_max(struct device *dev, struct device_attribute
 502			   *devattr, char *buf)
 503{
 504	struct f71805f_data *data = f71805f_update_device(dev);
 505	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 506	int nr = attr->index;
 507
 508	return sprintf(buf, "%ld\n", in_from_reg(data->in_high[nr]));
 509}
 510
 511static ssize_t show_in_min(struct device *dev, struct device_attribute
 512			   *devattr, char *buf)
 513{
 514	struct f71805f_data *data = f71805f_update_device(dev);
 515	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 516	int nr = attr->index;
 517
 518	return sprintf(buf, "%ld\n", in_from_reg(data->in_low[nr]));
 519}
 520
 521static ssize_t set_in_max(struct device *dev, struct device_attribute
 522			  *devattr, const char *buf, size_t count)
 523{
 524	struct f71805f_data *data = dev_get_drvdata(dev);
 525	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 526	int nr = attr->index;
 527	long val;
 528	int err;
 529
 530	err = kstrtol(buf, 10, &val);
 531	if (err)
 532		return err;
 533
 534	mutex_lock(&data->update_lock);
 535	data->in_high[nr] = in_to_reg(val);
 536	f71805f_write8(data, F71805F_REG_IN_HIGH(nr), data->in_high[nr]);
 537	mutex_unlock(&data->update_lock);
 538
 539	return count;
 540}
 541
 542static ssize_t set_in_min(struct device *dev, struct device_attribute
 543			  *devattr, const char *buf, size_t count)
 544{
 545	struct f71805f_data *data = dev_get_drvdata(dev);
 546	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 547	int nr = attr->index;
 548	long val;
 549	int err;
 550
 551	err = kstrtol(buf, 10, &val);
 552	if (err)
 553		return err;
 554
 555	mutex_lock(&data->update_lock);
 556	data->in_low[nr] = in_to_reg(val);
 557	f71805f_write8(data, F71805F_REG_IN_LOW(nr), data->in_low[nr]);
 558	mutex_unlock(&data->update_lock);
 559
 560	return count;
 561}
 562
 563static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
 564			char *buf)
 565{
 566	struct f71805f_data *data = f71805f_update_device(dev);
 567	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 568	int nr = attr->index;
 569
 570	return sprintf(buf, "%ld\n", fan_from_reg(data->fan[nr]));
 571}
 572
 573static ssize_t show_fan_min(struct device *dev, struct device_attribute
 574			    *devattr, char *buf)
 575{
 576	struct f71805f_data *data = f71805f_update_device(dev);
 577	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 578	int nr = attr->index;
 579
 580	return sprintf(buf, "%ld\n", fan_from_reg(data->fan_low[nr]));
 581}
 582
 583static ssize_t show_fan_target(struct device *dev, struct device_attribute
 584			       *devattr, char *buf)
 585{
 586	struct f71805f_data *data = f71805f_update_device(dev);
 587	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 588	int nr = attr->index;
 589
 590	return sprintf(buf, "%ld\n", fan_from_reg(data->fan_target[nr]));
 591}
 592
 593static ssize_t set_fan_min(struct device *dev, struct device_attribute
 594			   *devattr, const char *buf, size_t count)
 595{
 596	struct f71805f_data *data = dev_get_drvdata(dev);
 597	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 598	int nr = attr->index;
 599	long val;
 600	int err;
 601
 602	err = kstrtol(buf, 10, &val);
 603	if (err)
 604		return err;
 605
 606	mutex_lock(&data->update_lock);
 607	data->fan_low[nr] = fan_to_reg(val);
 608	f71805f_write16(data, F71805F_REG_FAN_LOW(nr), data->fan_low[nr]);
 609	mutex_unlock(&data->update_lock);
 610
 611	return count;
 612}
 613
 614static ssize_t set_fan_target(struct device *dev, struct device_attribute
 615			      *devattr, const char *buf, size_t count)
 616{
 617	struct f71805f_data *data = dev_get_drvdata(dev);
 618	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 619	int nr = attr->index;
 620	long val;
 621	int err;
 622
 623	err = kstrtol(buf, 10, &val);
 624	if (err)
 625		return err;
 626
 627	mutex_lock(&data->update_lock);
 628	data->fan_target[nr] = fan_to_reg(val);
 629	f71805f_write16(data, F71805F_REG_FAN_TARGET(nr),
 630			data->fan_target[nr]);
 631	mutex_unlock(&data->update_lock);
 632
 633	return count;
 634}
 635
 636static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr,
 637			char *buf)
 638{
 639	struct f71805f_data *data = f71805f_update_device(dev);
 640	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 641	int nr = attr->index;
 642
 643	return sprintf(buf, "%d\n", (int)data->pwm[nr]);
 644}
 645
 646static ssize_t show_pwm_enable(struct device *dev, struct device_attribute
 647			       *devattr, char *buf)
 648{
 649	struct f71805f_data *data = f71805f_update_device(dev);
 650	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 651	int nr = attr->index;
 652	int mode;
 653
 654	switch (data->fan_ctrl[nr] & FAN_CTRL_MODE_MASK) {
 655	case FAN_CTRL_MODE_SPEED:
 656		mode = 3;
 657		break;
 658	case FAN_CTRL_MODE_TEMPERATURE:
 659		mode = 2;
 660		break;
 661	default: /* MANUAL */
 662		mode = 1;
 663	}
 664
 665	return sprintf(buf, "%d\n", mode);
 666}
 667
 668static ssize_t show_pwm_freq(struct device *dev, struct device_attribute
 669			     *devattr, char *buf)
 670{
 671	struct f71805f_data *data = f71805f_update_device(dev);
 672	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 673	int nr = attr->index;
 674
 675	return sprintf(buf, "%lu\n", pwm_freq_from_reg(data->pwm_freq[nr]));
 676}
 677
 678static ssize_t show_pwm_mode(struct device *dev, struct device_attribute
 679			     *devattr, char *buf)
 680{
 681	struct f71805f_data *data = f71805f_update_device(dev);
 682	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 683	int nr = attr->index;
 684
 685	return sprintf(buf, "%d\n", pwm_mode_from_reg(data->fan_ctrl[nr]));
 686}
 687
 688static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr,
 689		       const char *buf, size_t count)
 690{
 691	struct f71805f_data *data = dev_get_drvdata(dev);
 692	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 693	int nr = attr->index;
 694	unsigned long val;
 695	int err;
 696
 697	err = kstrtoul(buf, 10, &val);
 698	if (err)
 699		return err;
 700
 701	if (val > 255)
 702		return -EINVAL;
 703
 704	mutex_lock(&data->update_lock);
 705	data->pwm[nr] = val;
 706	f71805f_write8(data, F71805F_REG_PWM_DUTY(nr), data->pwm[nr]);
 707	mutex_unlock(&data->update_lock);
 708
 709	return count;
 710}
 711
 712static struct attribute *f71805f_attr_pwm[];
 713
 714static ssize_t set_pwm_enable(struct device *dev, struct device_attribute
 715			      *devattr, const char *buf, size_t count)
 716{
 717	struct f71805f_data *data = dev_get_drvdata(dev);
 718	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 719	int nr = attr->index;
 720	u8 reg;
 721	unsigned long val;
 722	int err;
 723
 724	err = kstrtoul(buf, 10, &val);
 725	if (err)
 726		return err;
 727
 728	if (val < 1 || val > 3)
 729		return -EINVAL;
 730
 731	if (val > 1) { /* Automatic mode, user can't set PWM value */
 732		if (sysfs_chmod_file(&dev->kobj, f71805f_attr_pwm[nr],
 733				     S_IRUGO))
 734			dev_dbg(dev, "chmod -w pwm%d failed\n", nr + 1);
 735	}
 736
 737	mutex_lock(&data->update_lock);
 738	reg = f71805f_read8(data, F71805F_REG_FAN_CTRL(nr))
 739	    & ~FAN_CTRL_MODE_MASK;
 740	switch (val) {
 741	case 1:
 742		reg |= FAN_CTRL_MODE_MANUAL;
 743		break;
 744	case 2:
 745		reg |= FAN_CTRL_MODE_TEMPERATURE;
 746		break;
 747	case 3:
 748		reg |= FAN_CTRL_MODE_SPEED;
 749		break;
 750	}
 751	data->fan_ctrl[nr] = reg;
 752	f71805f_write8(data, F71805F_REG_FAN_CTRL(nr), reg);
 753	mutex_unlock(&data->update_lock);
 754
 755	if (val == 1) { /* Manual mode, user can set PWM value */
 756		if (sysfs_chmod_file(&dev->kobj, f71805f_attr_pwm[nr],
 757				     S_IRUGO | S_IWUSR))
 758			dev_dbg(dev, "chmod +w pwm%d failed\n", nr + 1);
 759	}
 760
 761	return count;
 762}
 763
 764static ssize_t set_pwm_freq(struct device *dev, struct device_attribute
 765			    *devattr, const char *buf, size_t count)
 766{
 767	struct f71805f_data *data = dev_get_drvdata(dev);
 768	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 769	int nr = attr->index;
 770	unsigned long val;
 771	int err;
 772
 773	err = kstrtoul(buf, 10, &val);
 774	if (err)
 775		return err;
 776
 777	mutex_lock(&data->update_lock);
 778	data->pwm_freq[nr] = pwm_freq_to_reg(val);
 779	f71805f_write8(data, F71805F_REG_PWM_FREQ(nr), data->pwm_freq[nr]);
 780	mutex_unlock(&data->update_lock);
 781
 782	return count;
 783}
 784
 785static ssize_t show_pwm_auto_point_temp(struct device *dev,
 786					struct device_attribute *devattr,
 787					char *buf)
 788{
 789	struct f71805f_data *data = dev_get_drvdata(dev);
 790	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 791	int pwmnr = attr->nr;
 792	int apnr = attr->index;
 793
 794	return sprintf(buf, "%ld\n",
 795		       temp_from_reg(data->auto_points[pwmnr].temp[apnr]));
 796}
 797
 798static ssize_t set_pwm_auto_point_temp(struct device *dev,
 799				       struct device_attribute *devattr,
 800				       const char *buf, size_t count)
 801{
 802	struct f71805f_data *data = dev_get_drvdata(dev);
 803	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 804	int pwmnr = attr->nr;
 805	int apnr = attr->index;
 806	unsigned long val;
 807	int err;
 808
 809	err = kstrtoul(buf, 10, &val);
 810	if (err)
 811		return err;
 812
 813	mutex_lock(&data->update_lock);
 814	data->auto_points[pwmnr].temp[apnr] = temp_to_reg(val);
 815	f71805f_write8(data, F71805F_REG_PWM_AUTO_POINT_TEMP(pwmnr, apnr),
 816		       data->auto_points[pwmnr].temp[apnr]);
 817	mutex_unlock(&data->update_lock);
 818
 819	return count;
 820}
 821
 822static ssize_t show_pwm_auto_point_fan(struct device *dev,
 823				       struct device_attribute *devattr,
 824				       char *buf)
 825{
 826	struct f71805f_data *data = dev_get_drvdata(dev);
 827	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 828	int pwmnr = attr->nr;
 829	int apnr = attr->index;
 830
 831	return sprintf(buf, "%ld\n",
 832		       fan_from_reg(data->auto_points[pwmnr].fan[apnr]));
 833}
 834
 835static ssize_t set_pwm_auto_point_fan(struct device *dev,
 836				      struct device_attribute *devattr,
 837				      const char *buf, size_t count)
 838{
 839	struct f71805f_data *data = dev_get_drvdata(dev);
 840	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr);
 841	int pwmnr = attr->nr;
 842	int apnr = attr->index;
 843	unsigned long val;
 844	int err;
 845
 846	err = kstrtoul(buf, 10, &val);
 847	if (err)
 848		return err;
 849
 850	mutex_lock(&data->update_lock);
 851	data->auto_points[pwmnr].fan[apnr] = fan_to_reg(val);
 852	f71805f_write16(data, F71805F_REG_PWM_AUTO_POINT_FAN(pwmnr, apnr),
 853			data->auto_points[pwmnr].fan[apnr]);
 854	mutex_unlock(&data->update_lock);
 855
 856	return count;
 857}
 858
 859static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
 860			 char *buf)
 861{
 862	struct f71805f_data *data = f71805f_update_device(dev);
 863	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 864	int nr = attr->index;
 865
 866	return sprintf(buf, "%ld\n", temp_from_reg(data->temp[nr]));
 867}
 868
 869static ssize_t show_temp_max(struct device *dev, struct device_attribute
 870			     *devattr, char *buf)
 871{
 872	struct f71805f_data *data = f71805f_update_device(dev);
 873	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 874	int nr = attr->index;
 875
 876	return sprintf(buf, "%ld\n", temp_from_reg(data->temp_high[nr]));
 877}
 878
 879static ssize_t show_temp_hyst(struct device *dev, struct device_attribute
 880			      *devattr, char *buf)
 881{
 882	struct f71805f_data *data = f71805f_update_device(dev);
 883	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 884	int nr = attr->index;
 885
 886	return sprintf(buf, "%ld\n", temp_from_reg(data->temp_hyst[nr]));
 887}
 888
 889static ssize_t show_temp_type(struct device *dev, struct device_attribute
 890			      *devattr, char *buf)
 891{
 892	struct f71805f_data *data = f71805f_update_device(dev);
 893	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 894	int nr = attr->index;
 895
 896	/* 3 is diode, 4 is thermistor */
 897	return sprintf(buf, "%u\n", (data->temp_mode & (1 << nr)) ? 3 : 4);
 898}
 899
 900static ssize_t set_temp_max(struct device *dev, struct device_attribute
 901			    *devattr, const char *buf, size_t count)
 902{
 903	struct f71805f_data *data = dev_get_drvdata(dev);
 904	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 905	int nr = attr->index;
 906	long val;
 907	int err;
 908
 909	err = kstrtol(buf, 10, &val);
 910	if (err)
 911		return err;
 912
 913	mutex_lock(&data->update_lock);
 914	data->temp_high[nr] = temp_to_reg(val);
 915	f71805f_write8(data, F71805F_REG_TEMP_HIGH(nr), data->temp_high[nr]);
 916	mutex_unlock(&data->update_lock);
 917
 918	return count;
 919}
 920
 921static ssize_t set_temp_hyst(struct device *dev, struct device_attribute
 922			     *devattr, const char *buf, size_t count)
 923{
 924	struct f71805f_data *data = dev_get_drvdata(dev);
 925	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 926	int nr = attr->index;
 927	long val;
 928	int err;
 929
 930	err = kstrtol(buf, 10, &val);
 931	if (err)
 932		return err;
 933
 934	mutex_lock(&data->update_lock);
 935	data->temp_hyst[nr] = temp_to_reg(val);
 936	f71805f_write8(data, F71805F_REG_TEMP_HYST(nr), data->temp_hyst[nr]);
 937	mutex_unlock(&data->update_lock);
 938
 939	return count;
 940}
 941
 942static ssize_t alarms_in_show(struct device *dev, struct device_attribute
 943			      *devattr, char *buf)
 944{
 945	struct f71805f_data *data = f71805f_update_device(dev);
 946
 947	return sprintf(buf, "%lu\n", data->alarms & 0x7ff);
 948}
 949
 950static ssize_t alarms_fan_show(struct device *dev, struct device_attribute
 951			       *devattr, char *buf)
 952{
 953	struct f71805f_data *data = f71805f_update_device(dev);
 954
 955	return sprintf(buf, "%lu\n", (data->alarms >> 16) & 0x07);
 956}
 957
 958static ssize_t alarms_temp_show(struct device *dev, struct device_attribute
 959				*devattr, char *buf)
 960{
 961	struct f71805f_data *data = f71805f_update_device(dev);
 962
 963	return sprintf(buf, "%lu\n", (data->alarms >> 11) & 0x07);
 964}
 965
 966static ssize_t show_alarm(struct device *dev, struct device_attribute
 967			  *devattr, char *buf)
 968{
 969	struct f71805f_data *data = f71805f_update_device(dev);
 970	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 971	int bitnr = attr->index;
 972
 973	return sprintf(buf, "%lu\n", (data->alarms >> bitnr) & 1);
 974}
 975
 976static ssize_t name_show(struct device *dev, struct device_attribute
 977			 *devattr, char *buf)
 978{
 979	struct f71805f_data *data = dev_get_drvdata(dev);
 980
 981	return sprintf(buf, "%s\n", data->name);
 982}
 983
 984static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in0, NULL, 0);
 985static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO | S_IWUSR,
 986			  show_in0_max, set_in0_max, 0);
 987static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO | S_IWUSR,
 988			  show_in0_min, set_in0_min, 0);
 989static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in, NULL, 1);
 990static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO | S_IWUSR,
 991			  show_in_max, set_in_max, 1);
 992static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO | S_IWUSR,
 993			  show_in_min, set_in_min, 1);
 994static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in, NULL, 2);
 995static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO | S_IWUSR,
 996			  show_in_max, set_in_max, 2);
 997static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO | S_IWUSR,
 998			  show_in_min, set_in_min, 2);
 999static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in, NULL, 3);
1000static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO | S_IWUSR,
1001			  show_in_max, set_in_max, 3);
1002static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO | S_IWUSR,
1003			  show_in_min, set_in_min, 3);
1004static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in, NULL, 4);
1005static SENSOR_DEVICE_ATTR(in4_max, S_IRUGO | S_IWUSR,
1006			  show_in_max, set_in_max, 4);
1007static SENSOR_DEVICE_ATTR(in4_min, S_IRUGO | S_IWUSR,
1008			  show_in_min, set_in_min, 4);
1009static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_in, NULL, 5);
1010static SENSOR_DEVICE_ATTR(in5_max, S_IRUGO | S_IWUSR,
1011			  show_in_max, set_in_max, 5);
1012static SENSOR_DEVICE_ATTR(in5_min, S_IRUGO | S_IWUSR,
1013			  show_in_min, set_in_min, 5);
1014static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_in, NULL, 6);
1015static SENSOR_DEVICE_ATTR(in6_max, S_IRUGO | S_IWUSR,
1016			  show_in_max, set_in_max, 6);
1017static SENSOR_DEVICE_ATTR(in6_min, S_IRUGO | S_IWUSR,
1018			  show_in_min, set_in_min, 6);
1019static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, show_in, NULL, 7);
1020static SENSOR_DEVICE_ATTR(in7_max, S_IRUGO | S_IWUSR,
1021			  show_in_max, set_in_max, 7);
1022static SENSOR_DEVICE_ATTR(in7_min, S_IRUGO | S_IWUSR,
1023			  show_in_min, set_in_min, 7);
1024static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, show_in, NULL, 8);
1025static SENSOR_DEVICE_ATTR(in8_max, S_IRUGO | S_IWUSR,
1026			  show_in_max, set_in_max, 8);
1027static SENSOR_DEVICE_ATTR(in8_min, S_IRUGO | S_IWUSR,
1028			  show_in_min, set_in_min, 8);
1029static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, show_in0, NULL, 9);
1030static SENSOR_DEVICE_ATTR(in9_max, S_IRUGO | S_IWUSR,
1031			  show_in0_max, set_in0_max, 9);
1032static SENSOR_DEVICE_ATTR(in9_min, S_IRUGO | S_IWUSR,
1033			  show_in0_min, set_in0_min, 9);
1034static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, show_in0, NULL, 10);
1035static SENSOR_DEVICE_ATTR(in10_max, S_IRUGO | S_IWUSR,
1036			  show_in0_max, set_in0_max, 10);
1037static SENSOR_DEVICE_ATTR(in10_min, S_IRUGO | S_IWUSR,
1038			  show_in0_min, set_in0_min, 10);
1039
1040static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
1041static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR,
1042			  show_fan_min, set_fan_min, 0);
1043static SENSOR_DEVICE_ATTR(fan1_target, S_IRUGO | S_IWUSR,
1044			  show_fan_target, set_fan_target, 0);
1045static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
1046static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO | S_IWUSR,
1047			  show_fan_min, set_fan_min, 1);
1048static SENSOR_DEVICE_ATTR(fan2_target, S_IRUGO | S_IWUSR,
1049			  show_fan_target, set_fan_target, 1);
1050static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2);
1051static SENSOR_DEVICE_ATTR(fan3_min, S_IRUGO | S_IWUSR,
1052			  show_fan_min, set_fan_min, 2);
1053static SENSOR_DEVICE_ATTR(fan3_target, S_IRUGO | S_IWUSR,
1054			  show_fan_target, set_fan_target, 2);
1055
1056static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
1057static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
1058		    show_temp_max, set_temp_max, 0);
1059static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
1060		    show_temp_hyst, set_temp_hyst, 0);
1061static SENSOR_DEVICE_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0);
1062static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
1063static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR,
1064		    show_temp_max, set_temp_max, 1);
1065static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR,
1066		    show_temp_hyst, set_temp_hyst, 1);
1067static SENSOR_DEVICE_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1);
1068static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
1069static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO | S_IWUSR,
1070		    show_temp_max, set_temp_max, 2);
1071static SENSOR_DEVICE_ATTR(temp3_max_hyst, S_IRUGO | S_IWUSR,
1072		    show_temp_hyst, set_temp_hyst, 2);
1073static SENSOR_DEVICE_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2);
1074
1075/*
1076 * pwm (value) files are created read-only, write permission is
1077 * then added or removed dynamically as needed
1078 */
1079static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO, show_pwm, set_pwm, 0);
1080static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR,
1081			  show_pwm_enable, set_pwm_enable, 0);
1082static SENSOR_DEVICE_ATTR(pwm1_freq, S_IRUGO | S_IWUSR,
1083			  show_pwm_freq, set_pwm_freq, 0);
1084static SENSOR_DEVICE_ATTR(pwm1_mode, S_IRUGO, show_pwm_mode, NULL, 0);
1085static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO, show_pwm, set_pwm, 1);
1086static SENSOR_DEVICE_ATTR(pwm2_enable, S_IRUGO | S_IWUSR,
1087			  show_pwm_enable, set_pwm_enable, 1);
1088static SENSOR_DEVICE_ATTR(pwm2_freq, S_IRUGO | S_IWUSR,
1089			  show_pwm_freq, set_pwm_freq, 1);
1090static SENSOR_DEVICE_ATTR(pwm2_mode, S_IRUGO, show_pwm_mode, NULL, 1);
1091static SENSOR_DEVICE_ATTR(pwm3, S_IRUGO, show_pwm, set_pwm, 2);
1092static SENSOR_DEVICE_ATTR(pwm3_enable, S_IRUGO | S_IWUSR,
1093			  show_pwm_enable, set_pwm_enable, 2);
1094static SENSOR_DEVICE_ATTR(pwm3_freq, S_IRUGO | S_IWUSR,
1095			  show_pwm_freq, set_pwm_freq, 2);
1096static SENSOR_DEVICE_ATTR(pwm3_mode, S_IRUGO, show_pwm_mode, NULL, 2);
1097
1098static SENSOR_DEVICE_ATTR_2(pwm1_auto_point1_temp, S_IRUGO | S_IWUSR,
1099			    show_pwm_auto_point_temp, set_pwm_auto_point_temp,
1100			    0, 0);
1101static SENSOR_DEVICE_ATTR_2(pwm1_auto_point1_fan, S_IRUGO | S_IWUSR,
1102			    show_pwm_auto_point_fan, set_pwm_auto_point_fan,
1103			    0, 0);
1104static SENSOR_DEVICE_ATTR_2(pwm1_auto_point2_temp, S_IRUGO | S_IWUSR,
1105			    show_pwm_auto_point_temp, set_pwm_auto_point_temp,
1106			    0, 1);
1107static SENSOR_DEVICE_ATTR_2(pwm1_auto_point2_fan, S_IRUGO | S_IWUSR,
1108			    show_pwm_auto_point_fan, set_pwm_auto_point_fan,
1109			    0, 1);
1110static SENSOR_DEVICE_ATTR_2(pwm1_auto_point3_temp, S_IRUGO | S_IWUSR,
1111			    show_pwm_auto_point_temp, set_pwm_auto_point_temp,
1112			    0, 2);
1113static SENSOR_DEVICE_ATTR_2(pwm1_auto_point3_fan, S_IRUGO | S_IWUSR,
1114			    show_pwm_auto_point_fan, set_pwm_auto_point_fan,
1115			    0, 2);
1116
1117static SENSOR_DEVICE_ATTR_2(pwm2_auto_point1_temp, S_IRUGO | S_IWUSR,
1118			    show_pwm_auto_point_temp, set_pwm_auto_point_temp,
1119			    1, 0);
1120static SENSOR_DEVICE_ATTR_2(pwm2_auto_point1_fan, S_IRUGO | S_IWUSR,
1121			    show_pwm_auto_point_fan, set_pwm_auto_point_fan,
1122			    1, 0);
1123static SENSOR_DEVICE_ATTR_2(pwm2_auto_point2_temp, S_IRUGO | S_IWUSR,
1124			    show_pwm_auto_point_temp, set_pwm_auto_point_temp,
1125			    1, 1);
1126static SENSOR_DEVICE_ATTR_2(pwm2_auto_point2_fan, S_IRUGO | S_IWUSR,
1127			    show_pwm_auto_point_fan, set_pwm_auto_point_fan,
1128			    1, 1);
1129static SENSOR_DEVICE_ATTR_2(pwm2_auto_point3_temp, S_IRUGO | S_IWUSR,
1130			    show_pwm_auto_point_temp, set_pwm_auto_point_temp,
1131			    1, 2);
1132static SENSOR_DEVICE_ATTR_2(pwm2_auto_point3_fan, S_IRUGO | S_IWUSR,
1133			    show_pwm_auto_point_fan, set_pwm_auto_point_fan,
1134			    1, 2);
1135
1136static SENSOR_DEVICE_ATTR_2(pwm3_auto_point1_temp, S_IRUGO | S_IWUSR,
1137			    show_pwm_auto_point_temp, set_pwm_auto_point_temp,
1138			    2, 0);
1139static SENSOR_DEVICE_ATTR_2(pwm3_auto_point1_fan, S_IRUGO | S_IWUSR,
1140			    show_pwm_auto_point_fan, set_pwm_auto_point_fan,
1141			    2, 0);
1142static SENSOR_DEVICE_ATTR_2(pwm3_auto_point2_temp, S_IRUGO | S_IWUSR,
1143			    show_pwm_auto_point_temp, set_pwm_auto_point_temp,
1144			    2, 1);
1145static SENSOR_DEVICE_ATTR_2(pwm3_auto_point2_fan, S_IRUGO | S_IWUSR,
1146			    show_pwm_auto_point_fan, set_pwm_auto_point_fan,
1147			    2, 1);
1148static SENSOR_DEVICE_ATTR_2(pwm3_auto_point3_temp, S_IRUGO | S_IWUSR,
1149			    show_pwm_auto_point_temp, set_pwm_auto_point_temp,
1150			    2, 2);
1151static SENSOR_DEVICE_ATTR_2(pwm3_auto_point3_fan, S_IRUGO | S_IWUSR,
1152			    show_pwm_auto_point_fan, set_pwm_auto_point_fan,
1153			    2, 2);
1154
1155static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
1156static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
1157static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
1158static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
1159static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 4);
1160static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 5);
1161static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 6);
1162static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 7);
1163static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 8);
1164static SENSOR_DEVICE_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 9);
1165static SENSOR_DEVICE_ATTR(in10_alarm, S_IRUGO, show_alarm, NULL, 10);
1166static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 11);
1167static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 12);
1168static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13);
1169static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 16);
1170static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 17);
1171static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 18);
1172static DEVICE_ATTR_RO(alarms_in);
1173static DEVICE_ATTR_RO(alarms_fan);
1174static DEVICE_ATTR_RO(alarms_temp);
1175
1176static DEVICE_ATTR_RO(name);
1177
1178static struct attribute *f71805f_attributes[] = {
1179	&sensor_dev_attr_in0_input.dev_attr.attr,
1180	&sensor_dev_attr_in0_max.dev_attr.attr,
1181	&sensor_dev_attr_in0_min.dev_attr.attr,
1182	&sensor_dev_attr_in1_input.dev_attr.attr,
1183	&sensor_dev_attr_in1_max.dev_attr.attr,
1184	&sensor_dev_attr_in1_min.dev_attr.attr,
1185	&sensor_dev_attr_in2_input.dev_attr.attr,
1186	&sensor_dev_attr_in2_max.dev_attr.attr,
1187	&sensor_dev_attr_in2_min.dev_attr.attr,
1188	&sensor_dev_attr_in3_input.dev_attr.attr,
1189	&sensor_dev_attr_in3_max.dev_attr.attr,
1190	&sensor_dev_attr_in3_min.dev_attr.attr,
1191	&sensor_dev_attr_in5_input.dev_attr.attr,
1192	&sensor_dev_attr_in5_max.dev_attr.attr,
1193	&sensor_dev_attr_in5_min.dev_attr.attr,
1194	&sensor_dev_attr_in6_input.dev_attr.attr,
1195	&sensor_dev_attr_in6_max.dev_attr.attr,
1196	&sensor_dev_attr_in6_min.dev_attr.attr,
1197	&sensor_dev_attr_in7_input.dev_attr.attr,
1198	&sensor_dev_attr_in7_max.dev_attr.attr,
1199	&sensor_dev_attr_in7_min.dev_attr.attr,
1200
1201	&sensor_dev_attr_fan1_input.dev_attr.attr,
1202	&sensor_dev_attr_fan1_min.dev_attr.attr,
1203	&sensor_dev_attr_fan1_alarm.dev_attr.attr,
1204	&sensor_dev_attr_fan1_target.dev_attr.attr,
1205	&sensor_dev_attr_fan2_input.dev_attr.attr,
1206	&sensor_dev_attr_fan2_min.dev_attr.attr,
1207	&sensor_dev_attr_fan2_alarm.dev_attr.attr,
1208	&sensor_dev_attr_fan2_target.dev_attr.attr,
1209	&sensor_dev_attr_fan3_input.dev_attr.attr,
1210	&sensor_dev_attr_fan3_min.dev_attr.attr,
1211	&sensor_dev_attr_fan3_alarm.dev_attr.attr,
1212	&sensor_dev_attr_fan3_target.dev_attr.attr,
1213
1214	&sensor_dev_attr_pwm1.dev_attr.attr,
1215	&sensor_dev_attr_pwm1_enable.dev_attr.attr,
1216	&sensor_dev_attr_pwm1_mode.dev_attr.attr,
1217	&sensor_dev_attr_pwm2.dev_attr.attr,
1218	&sensor_dev_attr_pwm2_enable.dev_attr.attr,
1219	&sensor_dev_attr_pwm2_mode.dev_attr.attr,
1220	&sensor_dev_attr_pwm3.dev_attr.attr,
1221	&sensor_dev_attr_pwm3_enable.dev_attr.attr,
1222	&sensor_dev_attr_pwm3_mode.dev_attr.attr,
1223
1224	&sensor_dev_attr_temp1_input.dev_attr.attr,
1225	&sensor_dev_attr_temp1_max.dev_attr.attr,
1226	&sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
1227	&sensor_dev_attr_temp1_type.dev_attr.attr,
1228	&sensor_dev_attr_temp2_input.dev_attr.attr,
1229	&sensor_dev_attr_temp2_max.dev_attr.attr,
1230	&sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
1231	&sensor_dev_attr_temp2_type.dev_attr.attr,
1232	&sensor_dev_attr_temp3_input.dev_attr.attr,
1233	&sensor_dev_attr_temp3_max.dev_attr.attr,
1234	&sensor_dev_attr_temp3_max_hyst.dev_attr.attr,
1235	&sensor_dev_attr_temp3_type.dev_attr.attr,
1236
1237	&sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr,
1238	&sensor_dev_attr_pwm1_auto_point1_fan.dev_attr.attr,
1239	&sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr,
1240	&sensor_dev_attr_pwm1_auto_point2_fan.dev_attr.attr,
1241	&sensor_dev_attr_pwm1_auto_point3_temp.dev_attr.attr,
1242	&sensor_dev_attr_pwm1_auto_point3_fan.dev_attr.attr,
1243	&sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr,
1244	&sensor_dev_attr_pwm2_auto_point1_fan.dev_attr.attr,
1245	&sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr,
1246	&sensor_dev_attr_pwm2_auto_point2_fan.dev_attr.attr,
1247	&sensor_dev_attr_pwm2_auto_point3_temp.dev_attr.attr,
1248	&sensor_dev_attr_pwm2_auto_point3_fan.dev_attr.attr,
1249	&sensor_dev_attr_pwm3_auto_point1_temp.dev_attr.attr,
1250	&sensor_dev_attr_pwm3_auto_point1_fan.dev_attr.attr,
1251	&sensor_dev_attr_pwm3_auto_point2_temp.dev_attr.attr,
1252	&sensor_dev_attr_pwm3_auto_point2_fan.dev_attr.attr,
1253	&sensor_dev_attr_pwm3_auto_point3_temp.dev_attr.attr,
1254	&sensor_dev_attr_pwm3_auto_point3_fan.dev_attr.attr,
1255
1256	&sensor_dev_attr_in0_alarm.dev_attr.attr,
1257	&sensor_dev_attr_in1_alarm.dev_attr.attr,
1258	&sensor_dev_attr_in2_alarm.dev_attr.attr,
1259	&sensor_dev_attr_in3_alarm.dev_attr.attr,
1260	&sensor_dev_attr_in5_alarm.dev_attr.attr,
1261	&sensor_dev_attr_in6_alarm.dev_attr.attr,
1262	&sensor_dev_attr_in7_alarm.dev_attr.attr,
1263	&dev_attr_alarms_in.attr,
1264	&sensor_dev_attr_temp1_alarm.dev_attr.attr,
1265	&sensor_dev_attr_temp2_alarm.dev_attr.attr,
1266	&sensor_dev_attr_temp3_alarm.dev_attr.attr,
1267	&dev_attr_alarms_temp.attr,
1268	&dev_attr_alarms_fan.attr,
1269
1270	&dev_attr_name.attr,
1271	NULL
1272};
1273
1274static const struct attribute_group f71805f_group = {
1275	.attrs = f71805f_attributes,
1276};
1277
1278static struct attribute *f71805f_attributes_optin[4][5] = {
1279	{
1280		&sensor_dev_attr_in4_input.dev_attr.attr,
1281		&sensor_dev_attr_in4_max.dev_attr.attr,
1282		&sensor_dev_attr_in4_min.dev_attr.attr,
1283		&sensor_dev_attr_in4_alarm.dev_attr.attr,
1284		NULL
1285	}, {
1286		&sensor_dev_attr_in8_input.dev_attr.attr,
1287		&sensor_dev_attr_in8_max.dev_attr.attr,
1288		&sensor_dev_attr_in8_min.dev_attr.attr,
1289		&sensor_dev_attr_in8_alarm.dev_attr.attr,
1290		NULL
1291	}, {
1292		&sensor_dev_attr_in9_input.dev_attr.attr,
1293		&sensor_dev_attr_in9_max.dev_attr.attr,
1294		&sensor_dev_attr_in9_min.dev_attr.attr,
1295		&sensor_dev_attr_in9_alarm.dev_attr.attr,
1296		NULL
1297	}, {
1298		&sensor_dev_attr_in10_input.dev_attr.attr,
1299		&sensor_dev_attr_in10_max.dev_attr.attr,
1300		&sensor_dev_attr_in10_min.dev_attr.attr,
1301		&sensor_dev_attr_in10_alarm.dev_attr.attr,
1302		NULL
1303	}
1304};
1305
1306static const struct attribute_group f71805f_group_optin[4] = {
1307	{ .attrs = f71805f_attributes_optin[0] },
1308	{ .attrs = f71805f_attributes_optin[1] },
1309	{ .attrs = f71805f_attributes_optin[2] },
1310	{ .attrs = f71805f_attributes_optin[3] },
1311};
1312
1313/*
1314 * We don't include pwm_freq files in the arrays above, because they must be
1315 * created conditionally (only if pwm_mode is 1 == PWM)
1316 */
1317static struct attribute *f71805f_attributes_pwm_freq[] = {
1318	&sensor_dev_attr_pwm1_freq.dev_attr.attr,
1319	&sensor_dev_attr_pwm2_freq.dev_attr.attr,
1320	&sensor_dev_attr_pwm3_freq.dev_attr.attr,
1321	NULL
1322};
1323
1324static const struct attribute_group f71805f_group_pwm_freq = {
1325	.attrs = f71805f_attributes_pwm_freq,
1326};
1327
1328/* We also need an indexed access to pwmN files to toggle writability */
1329static struct attribute *f71805f_attr_pwm[] = {
1330	&sensor_dev_attr_pwm1.dev_attr.attr,
1331	&sensor_dev_attr_pwm2.dev_attr.attr,
1332	&sensor_dev_attr_pwm3.dev_attr.attr,
1333};
1334
1335/*
1336 * Device registration and initialization
1337 */
1338
1339static void f71805f_init_device(struct f71805f_data *data)
1340{
1341	u8 reg;
1342	int i;
1343
1344	reg = f71805f_read8(data, F71805F_REG_START);
1345	if ((reg & 0x41) != 0x01) {
1346		pr_debug("Starting monitoring operations\n");
1347		f71805f_write8(data, F71805F_REG_START, (reg | 0x01) & ~0x40);
1348	}
1349
1350	/*
1351	 * Fan monitoring can be disabled. If it is, we won't be polling
1352	 * the register values, and won't create the related sysfs files.
1353	 */
1354	for (i = 0; i < 3; i++) {
1355		data->fan_ctrl[i] = f71805f_read8(data,
1356						  F71805F_REG_FAN_CTRL(i));
1357		/*
1358		 * Clear latch full bit, else "speed mode" fan speed control
1359		 * doesn't work
1360		 */
1361		if (data->fan_ctrl[i] & FAN_CTRL_LATCH_FULL) {
1362			data->fan_ctrl[i] &= ~FAN_CTRL_LATCH_FULL;
1363			f71805f_write8(data, F71805F_REG_FAN_CTRL(i),
1364				       data->fan_ctrl[i]);
1365		}
1366	}
1367}
1368
1369static int f71805f_probe(struct platform_device *pdev)
1370{
1371	struct f71805f_sio_data *sio_data = dev_get_platdata(&pdev->dev);
1372	struct f71805f_data *data;
1373	struct resource *res;
1374	int i, err;
1375
1376	static const char * const names[] = {
1377		"f71805f",
1378		"f71872f",
1379	};
1380
1381	data = devm_kzalloc(&pdev->dev, sizeof(struct f71805f_data),
1382			    GFP_KERNEL);
1383	if (!data)
1384		return -ENOMEM;
1385
1386	res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1387	if (!devm_request_region(&pdev->dev, res->start + ADDR_REG_OFFSET, 2,
1388				 DRVNAME)) {
1389		dev_err(&pdev->dev, "Failed to request region 0x%lx-0x%lx\n",
1390			(unsigned long)(res->start + ADDR_REG_OFFSET),
1391			(unsigned long)(res->start + ADDR_REG_OFFSET + 1));
1392		return -EBUSY;
1393	}
1394	data->addr = res->start;
1395	data->name = names[sio_data->kind];
1396	mutex_init(&data->update_lock);
1397
1398	platform_set_drvdata(pdev, data);
1399
1400	/* Some voltage inputs depend on chip model and configuration */
1401	switch (sio_data->kind) {
1402	case f71805f:
1403		data->has_in = 0x1ff;
1404		break;
1405	case f71872f:
1406		data->has_in = 0x6ef;
1407		if (sio_data->fnsel1 & 0x01)
1408			data->has_in |= (1 << 4); /* in4 */
1409		if (sio_data->fnsel1 & 0x02)
1410			data->has_in |= (1 << 8); /* in8 */
1411		break;
1412	}
1413
1414	/* Initialize the F71805F chip */
1415	f71805f_init_device(data);
1416
1417	/* Register sysfs interface files */
1418	err = sysfs_create_group(&pdev->dev.kobj, &f71805f_group);
1419	if (err)
1420		return err;
1421	if (data->has_in & (1 << 4)) { /* in4 */
1422		err = sysfs_create_group(&pdev->dev.kobj,
1423					 &f71805f_group_optin[0]);
1424		if (err)
1425			goto exit_remove_files;
1426	}
1427	if (data->has_in & (1 << 8)) { /* in8 */
1428		err = sysfs_create_group(&pdev->dev.kobj,
1429					 &f71805f_group_optin[1]);
1430		if (err)
1431			goto exit_remove_files;
1432	}
1433	if (data->has_in & (1 << 9)) { /* in9 (F71872F/FG only) */
1434		err = sysfs_create_group(&pdev->dev.kobj,
1435					 &f71805f_group_optin[2]);
1436		if (err)
1437			goto exit_remove_files;
1438	}
1439	if (data->has_in & (1 << 10)) { /* in9 (F71872F/FG only) */
1440		err = sysfs_create_group(&pdev->dev.kobj,
1441					 &f71805f_group_optin[3]);
1442		if (err)
1443			goto exit_remove_files;
1444	}
1445	for (i = 0; i < 3; i++) {
1446		/* If control mode is PWM, create pwm_freq file */
1447		if (!(data->fan_ctrl[i] & FAN_CTRL_DC_MODE)) {
1448			err = sysfs_create_file(&pdev->dev.kobj,
1449						f71805f_attributes_pwm_freq[i]);
1450			if (err)
1451				goto exit_remove_files;
1452		}
1453		/* If PWM is in manual mode, add write permission */
1454		if (data->fan_ctrl[i] & FAN_CTRL_MODE_MANUAL) {
1455			err = sysfs_chmod_file(&pdev->dev.kobj,
1456					       f71805f_attr_pwm[i],
1457					       S_IRUGO | S_IWUSR);
1458			if (err) {
1459				dev_err(&pdev->dev, "chmod +w pwm%d failed\n",
1460					i + 1);
1461				goto exit_remove_files;
1462			}
1463		}
1464	}
1465
1466	data->hwmon_dev = hwmon_device_register(&pdev->dev);
1467	if (IS_ERR(data->hwmon_dev)) {
1468		err = PTR_ERR(data->hwmon_dev);
1469		dev_err(&pdev->dev, "Class registration failed (%d)\n", err);
1470		goto exit_remove_files;
1471	}
1472
1473	return 0;
1474
1475exit_remove_files:
1476	sysfs_remove_group(&pdev->dev.kobj, &f71805f_group);
1477	for (i = 0; i < 4; i++)
1478		sysfs_remove_group(&pdev->dev.kobj, &f71805f_group_optin[i]);
1479	sysfs_remove_group(&pdev->dev.kobj, &f71805f_group_pwm_freq);
1480	return err;
1481}
1482
1483static int f71805f_remove(struct platform_device *pdev)
1484{
1485	struct f71805f_data *data = platform_get_drvdata(pdev);
1486	int i;
1487
1488	hwmon_device_unregister(data->hwmon_dev);
1489	sysfs_remove_group(&pdev->dev.kobj, &f71805f_group);
1490	for (i = 0; i < 4; i++)
1491		sysfs_remove_group(&pdev->dev.kobj, &f71805f_group_optin[i]);
1492	sysfs_remove_group(&pdev->dev.kobj, &f71805f_group_pwm_freq);
1493
1494	return 0;
1495}
1496
1497static struct platform_driver f71805f_driver = {
1498	.driver = {
1499		.name	= DRVNAME,
1500	},
1501	.probe		= f71805f_probe,
1502	.remove		= f71805f_remove,
1503};
1504
1505static int __init f71805f_device_add(unsigned short address,
1506				     const struct f71805f_sio_data *sio_data)
1507{
1508	struct resource res = {
1509		.start	= address,
1510		.end	= address + REGION_LENGTH - 1,
1511		.flags	= IORESOURCE_IO,
1512	};
1513	int err;
1514
1515	pdev = platform_device_alloc(DRVNAME, address);
1516	if (!pdev) {
1517		err = -ENOMEM;
1518		pr_err("Device allocation failed\n");
1519		goto exit;
1520	}
1521
1522	res.name = pdev->name;
1523	err = acpi_check_resource_conflict(&res);
1524	if (err)
1525		goto exit_device_put;
1526
1527	err = platform_device_add_resources(pdev, &res, 1);
1528	if (err) {
1529		pr_err("Device resource addition failed (%d)\n", err);
1530		goto exit_device_put;
1531	}
1532
1533	err = platform_device_add_data(pdev, sio_data,
1534				       sizeof(struct f71805f_sio_data));
1535	if (err) {
1536		pr_err("Platform data allocation failed\n");
1537		goto exit_device_put;
1538	}
1539
1540	err = platform_device_add(pdev);
1541	if (err) {
1542		pr_err("Device addition failed (%d)\n", err);
1543		goto exit_device_put;
1544	}
1545
1546	return 0;
1547
1548exit_device_put:
1549	platform_device_put(pdev);
1550exit:
1551	return err;
1552}
1553
1554static int __init f71805f_find(int sioaddr, unsigned short *address,
1555			       struct f71805f_sio_data *sio_data)
1556{
1557	int err;
1558	u16 devid;
1559
1560	static const char * const names[] = {
1561		"F71805F/FG",
1562		"F71872F/FG or F71806F/FG",
1563	};
1564
1565	err = superio_enter(sioaddr);
1566	if (err)
1567		return err;
1568
1569	err = -ENODEV;
1570	devid = superio_inw(sioaddr, SIO_REG_MANID);
1571	if (devid != SIO_FINTEK_ID)
1572		goto exit;
1573
1574	devid = force_id ? force_id : superio_inw(sioaddr, SIO_REG_DEVID);
1575	switch (devid) {
1576	case SIO_F71805F_ID:
1577		sio_data->kind = f71805f;
1578		break;
1579	case SIO_F71872F_ID:
1580		sio_data->kind = f71872f;
1581		sio_data->fnsel1 = superio_inb(sioaddr, SIO_REG_FNSEL1);
1582		break;
1583	default:
1584		pr_info("Unsupported Fintek device, skipping\n");
1585		goto exit;
1586	}
1587
1588	superio_select(sioaddr, F71805F_LD_HWM);
1589	if (!(superio_inb(sioaddr, SIO_REG_ENABLE) & 0x01)) {
1590		pr_warn("Device not activated, skipping\n");
1591		goto exit;
1592	}
1593
1594	*address = superio_inw(sioaddr, SIO_REG_ADDR);
1595	if (*address == 0) {
1596		pr_warn("Base address not set, skipping\n");
1597		goto exit;
1598	}
1599	*address &= ~(REGION_LENGTH - 1);	/* Ignore 3 LSB */
1600
1601	err = 0;
1602	pr_info("Found %s chip at %#x, revision %u\n",
1603		names[sio_data->kind], *address,
1604		superio_inb(sioaddr, SIO_REG_DEVREV));
1605
1606exit:
1607	superio_exit(sioaddr);
1608	return err;
1609}
1610
1611static int __init f71805f_init(void)
1612{
1613	int err;
1614	unsigned short address;
1615	struct f71805f_sio_data sio_data;
1616
1617	if (f71805f_find(0x2e, &address, &sio_data)
1618	 && f71805f_find(0x4e, &address, &sio_data))
1619		return -ENODEV;
1620
1621	err = platform_driver_register(&f71805f_driver);
1622	if (err)
1623		goto exit;
1624
1625	/* Sets global pdev as a side effect */
1626	err = f71805f_device_add(address, &sio_data);
1627	if (err)
1628		goto exit_driver;
1629
1630	return 0;
1631
1632exit_driver:
1633	platform_driver_unregister(&f71805f_driver);
1634exit:
1635	return err;
1636}
1637
1638static void __exit f71805f_exit(void)
1639{
1640	platform_device_unregister(pdev);
1641	platform_driver_unregister(&f71805f_driver);
1642}
1643
1644MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
1645MODULE_LICENSE("GPL");
1646MODULE_DESCRIPTION("F71805F/F71872F hardware monitoring driver");
1647
1648module_init(f71805f_init);
1649module_exit(f71805f_exit);