w83793.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * w83793.c - Linux kernel driver for hardware monitoring
   4 * Copyright (C) 2006 Winbond Electronics Corp.
   5 *	      Yuan Mu
   6 *	      Rudolf Marek <r.marek@assembler.cz>
   7 * Copyright (C) 2009-2010 Sven Anders <anders@anduras.de>, ANDURAS AG.
   8 *		Watchdog driver part
   9 *		(Based partially on fschmd driver,
  10 *		 Copyright 2007-2008 by Hans de Goede)
  11 */
  12
  13/*
  14 * Supports following chips:
  15 *
  16 * Chip	#vin	#fanin	#pwm	#temp	wchipid	vendid	i2c	ISA
  17 * w83793	10	12	8	6	0x7b	0x5ca3	yes	no
  18 */
  19
  20#include <linux/module.h>
  21#include <linux/init.h>
  22#include <linux/slab.h>
  23#include <linux/i2c.h>
  24#include <linux/hwmon.h>
  25#include <linux/hwmon-vid.h>
  26#include <linux/hwmon-sysfs.h>
  27#include <linux/err.h>
  28#include <linux/mutex.h>
  29#include <linux/fs.h>
  30#include <linux/watchdog.h>
  31#include <linux/miscdevice.h>
  32#include <linux/uaccess.h>
  33#include <linux/kref.h>
  34#include <linux/notifier.h>
  35#include <linux/reboot.h>
  36#include <linux/jiffies.h>
  37
  38/* Default values */
  39#define WATCHDOG_TIMEOUT 2	/* 2 minute default timeout */
  40
  41/* Addresses to scan */
  42static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f,
  43						I2C_CLIENT_END };
  44
  45/* Insmod parameters */
  46
  47static unsigned short force_subclients[4];
  48module_param_array(force_subclients, short, NULL, 0);
  49MODULE_PARM_DESC(force_subclients,
  50		 "List of subclient addresses: {bus, clientaddr, subclientaddr1, subclientaddr2}");
  51
  52static bool reset;
  53module_param(reset, bool, 0);
  54MODULE_PARM_DESC(reset, "Set to 1 to reset chip, not recommended");
  55
  56static int timeout = WATCHDOG_TIMEOUT;	/* default timeout in minutes */
  57module_param(timeout, int, 0);
  58MODULE_PARM_DESC(timeout,
  59	"Watchdog timeout in minutes. 2<= timeout <=255 (default="
  60				__MODULE_STRING(WATCHDOG_TIMEOUT) ")");
  61
  62static bool nowayout = WATCHDOG_NOWAYOUT;
  63module_param(nowayout, bool, 0);
  64MODULE_PARM_DESC(nowayout,
  65	"Watchdog cannot be stopped once started (default="
  66				__MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
  67
  68/*
  69 * Address 0x00, 0x0d, 0x0e, 0x0f in all three banks are reserved
  70 * as ID, Bank Select registers
  71 */
  72#define W83793_REG_BANKSEL		0x00
  73#define W83793_REG_VENDORID		0x0d
  74#define W83793_REG_CHIPID		0x0e
  75#define W83793_REG_DEVICEID		0x0f
  76
  77#define W83793_REG_CONFIG		0x40
  78#define W83793_REG_MFC			0x58
  79#define W83793_REG_FANIN_CTRL		0x5c
  80#define W83793_REG_FANIN_SEL		0x5d
  81#define W83793_REG_I2C_ADDR		0x0b
  82#define W83793_REG_I2C_SUBADDR		0x0c
  83#define W83793_REG_VID_INA		0x05
  84#define W83793_REG_VID_INB		0x06
  85#define W83793_REG_VID_LATCHA		0x07
  86#define W83793_REG_VID_LATCHB		0x08
  87#define W83793_REG_VID_CTRL		0x59
  88
  89#define W83793_REG_WDT_LOCK		0x01
  90#define W83793_REG_WDT_ENABLE		0x02
  91#define W83793_REG_WDT_STATUS		0x03
  92#define W83793_REG_WDT_TIMEOUT		0x04
  93
  94static u16 W83793_REG_TEMP_MODE[2] = { 0x5e, 0x5f };
  95
  96#define TEMP_READ	0
  97#define TEMP_CRIT	1
  98#define TEMP_CRIT_HYST	2
  99#define TEMP_WARN	3
 100#define TEMP_WARN_HYST	4
 101/*
 102 * only crit and crit_hyst affect real-time alarm status
 103 * current crit crit_hyst warn warn_hyst
 104 */
 105static u16 W83793_REG_TEMP[][5] = {
 106	{0x1c, 0x78, 0x79, 0x7a, 0x7b},
 107	{0x1d, 0x7c, 0x7d, 0x7e, 0x7f},
 108	{0x1e, 0x80, 0x81, 0x82, 0x83},
 109	{0x1f, 0x84, 0x85, 0x86, 0x87},
 110	{0x20, 0x88, 0x89, 0x8a, 0x8b},
 111	{0x21, 0x8c, 0x8d, 0x8e, 0x8f},
 112};
 113
 114#define W83793_REG_TEMP_LOW_BITS	0x22
 115
 116#define W83793_REG_BEEP(index)		(0x53 + (index))
 117#define W83793_REG_ALARM(index)		(0x4b + (index))
 118
 119#define W83793_REG_CLR_CHASSIS		0x4a	/* SMI MASK4 */
 120#define W83793_REG_IRQ_CTRL		0x50
 121#define W83793_REG_OVT_CTRL		0x51
 122#define W83793_REG_OVT_BEEP		0x52
 123
 124#define IN_READ				0
 125#define IN_MAX				1
 126#define IN_LOW				2
 127static const u16 W83793_REG_IN[][3] = {
 128	/* Current, High, Low */
 129	{0x10, 0x60, 0x61},	/* Vcore A	*/
 130	{0x11, 0x62, 0x63},	/* Vcore B	*/
 131	{0x12, 0x64, 0x65},	/* Vtt		*/
 132	{0x14, 0x6a, 0x6b},	/* VSEN1	*/
 133	{0x15, 0x6c, 0x6d},	/* VSEN2	*/
 134	{0x16, 0x6e, 0x6f},	/* +3VSEN	*/
 135	{0x17, 0x70, 0x71},	/* +12VSEN	*/
 136	{0x18, 0x72, 0x73},	/* 5VDD		*/
 137	{0x19, 0x74, 0x75},	/* 5VSB		*/
 138	{0x1a, 0x76, 0x77},	/* VBAT		*/
 139};
 140
 141/* Low Bits of Vcore A/B Vtt Read/High/Low */
 142static const u16 W83793_REG_IN_LOW_BITS[] = { 0x1b, 0x68, 0x69 };
 143static u8 scale_in[] = { 2, 2, 2, 16, 16, 16, 8, 24, 24, 16 };
 144static u8 scale_in_add[] = { 0, 0, 0, 0, 0, 0, 0, 150, 150, 0 };
 145
 146#define W83793_REG_FAN(index)		(0x23 + 2 * (index))	/* High byte */
 147#define W83793_REG_FAN_MIN(index)	(0x90 + 2 * (index))	/* High byte */
 148
 149#define W83793_REG_PWM_DEFAULT		0xb2
 150#define W83793_REG_PWM_ENABLE		0x207
 151#define W83793_REG_PWM_UPTIME		0xc3	/* Unit in 0.1 second */
 152#define W83793_REG_PWM_DOWNTIME		0xc4	/* Unit in 0.1 second */
 153#define W83793_REG_TEMP_CRITICAL	0xc5
 154
 155#define PWM_DUTY			0
 156#define PWM_START			1
 157#define PWM_NONSTOP			2
 158#define PWM_STOP_TIME			3
 159#define W83793_REG_PWM(index, nr)	(((nr) == 0 ? 0xb3 : \
 160					 (nr) == 1 ? 0x220 : 0x218) + (index))
 161
 162/* bit field, fan1 is bit0, fan2 is bit1 ... */
 163#define W83793_REG_TEMP_FAN_MAP(index)	(0x201 + (index))
 164#define W83793_REG_TEMP_TOL(index)	(0x208 + (index))
 165#define W83793_REG_TEMP_CRUISE(index)	(0x210 + (index))
 166#define W83793_REG_PWM_STOP_TIME(index)	(0x228 + (index))
 167#define W83793_REG_SF2_TEMP(index, nr)	(0x230 + ((index) << 4) + (nr))
 168#define W83793_REG_SF2_PWM(index, nr)	(0x238 + ((index) << 4) + (nr))
 169
 170static inline unsigned long FAN_FROM_REG(u16 val)
 171{
 172	if ((val >= 0xfff) || (val == 0))
 173		return	0;
 174	return 1350000UL / val;
 175}
 176
 177static inline u16 FAN_TO_REG(long rpm)
 178{
 179	if (rpm <= 0)
 180		return 0x0fff;
 181	return clamp_val((1350000 + (rpm >> 1)) / rpm, 1, 0xffe);
 182}
 183
 184static inline unsigned long TIME_FROM_REG(u8 reg)
 185{
 186	return reg * 100;
 187}
 188
 189static inline u8 TIME_TO_REG(unsigned long val)
 190{
 191	return clamp_val((val + 50) / 100, 0, 0xff);
 192}
 193
 194static inline long TEMP_FROM_REG(s8 reg)
 195{
 196	return reg * 1000;
 197}
 198
 199static inline s8 TEMP_TO_REG(long val, s8 min, s8 max)
 200{
 201	return clamp_val((val + (val < 0 ? -500 : 500)) / 1000, min, max);
 202}
 203
 204struct w83793_data {
 205	struct device *hwmon_dev;
 206	struct mutex update_lock;
 207	bool valid;			/* true if following fields are valid */
 208	unsigned long last_updated;	/* In jiffies */
 209	unsigned long last_nonvolatile;	/* In jiffies, last time we update the
 210					 * nonvolatile registers
 211					 */
 212
 213	u8 bank;
 214	u8 vrm;
 215	u8 vid[2];
 216	u8 in[10][3];		/* Register value, read/high/low */
 217	u8 in_low_bits[3];	/* Additional resolution for VCore A/B Vtt */
 218
 219	u16 has_fan;		/* Only fan1- fan5 has own pins */
 220	u16 fan[12];		/* Register value combine */
 221	u16 fan_min[12];	/* Register value combine */
 222
 223	s8 temp[6][5];		/* current, crit, crit_hyst,warn, warn_hyst */
 224	u8 temp_low_bits;	/* Additional resolution TD1-TD4 */
 225	u8 temp_mode[2];	/* byte 0: Temp D1-D4 mode each has 2 bits
 226				 * byte 1: Temp R1,R2 mode, each has 1 bit
 227				 */
 228	u8 temp_critical;	/* If reached all fan will be at full speed */
 229	u8 temp_fan_map[6];	/* Temp controls which pwm fan, bit field */
 230
 231	u8 has_pwm;
 232	u8 has_temp;
 233	u8 has_vid;
 234	u8 pwm_enable;		/* Register value, each Temp has 1 bit */
 235	u8 pwm_uptime;		/* Register value */
 236	u8 pwm_downtime;	/* Register value */
 237	u8 pwm_default;		/* All fan default pwm, next poweron valid */
 238	u8 pwm[8][3];		/* Register value */
 239	u8 pwm_stop_time[8];
 240	u8 temp_cruise[6];
 241
 242	u8 alarms[5];		/* realtime status registers */
 243	u8 beeps[5];
 244	u8 beep_enable;
 245	u8 tolerance[3];	/* Temp tolerance(Smart Fan I/II) */
 246	u8 sf2_pwm[6][7];	/* Smart FanII: Fan duty cycle */
 247	u8 sf2_temp[6][7];	/* Smart FanII: Temp level point */
 248
 249	/* watchdog */
 250	struct i2c_client *client;
 251	struct mutex watchdog_lock;
 252	struct list_head list; /* member of the watchdog_data_list */
 253	struct kref kref;
 254	struct miscdevice watchdog_miscdev;
 255	unsigned long watchdog_is_open;
 256	char watchdog_expect_close;
 257	char watchdog_name[10]; /* must be unique to avoid sysfs conflict */
 258	unsigned int watchdog_caused_reboot;
 259	int watchdog_timeout; /* watchdog timeout in minutes */
 260};
 261
 262/*
 263 * Somewhat ugly :( global data pointer list with all devices, so that
 264 * we can find our device data as when using misc_register. There is no
 265 * other method to get to one's device data from the open file-op and
 266 * for usage in the reboot notifier callback.
 267 */
 268static LIST_HEAD(watchdog_data_list);
 269
 270/* Note this lock not only protect list access, but also data.kref access */
 271static DEFINE_MUTEX(watchdog_data_mutex);
 272
 273/*
 274 * Release our data struct when we're detached from the i2c client *and* all
 275 * references to our watchdog device are released
 276 */
 277static void w83793_release_resources(struct kref *ref)
 278{
 279	struct w83793_data *data = container_of(ref, struct w83793_data, kref);
 280	kfree(data);
 281}
 282
 283static u8 w83793_read_value(struct i2c_client *client, u16 reg);
 284static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value);
 285static int w83793_probe(struct i2c_client *client);
 286static int w83793_detect(struct i2c_client *client,
 287			 struct i2c_board_info *info);
 288static void w83793_remove(struct i2c_client *client);
 289static void w83793_init_client(struct i2c_client *client);
 290static void w83793_update_nonvolatile(struct device *dev);
 291static struct w83793_data *w83793_update_device(struct device *dev);
 292
 293static const struct i2c_device_id w83793_id[] = {
 294	{ "w83793" },
 295	{ }
 296};
 297MODULE_DEVICE_TABLE(i2c, w83793_id);
 298
 299static struct i2c_driver w83793_driver = {
 300	.class		= I2C_CLASS_HWMON,
 301	.driver = {
 302		   .name = "w83793",
 303	},
 304	.probe		= w83793_probe,
 305	.remove		= w83793_remove,
 306	.id_table	= w83793_id,
 307	.detect		= w83793_detect,
 308	.address_list	= normal_i2c,
 309};
 310
 311static ssize_t
 312vrm_show(struct device *dev, struct device_attribute *attr, char *buf)
 313{
 314	struct w83793_data *data = dev_get_drvdata(dev);
 315	return sprintf(buf, "%d\n", data->vrm);
 316}
 317
 318static ssize_t
 319show_vid(struct device *dev, struct device_attribute *attr, char *buf)
 320{
 321	struct w83793_data *data = w83793_update_device(dev);
 322	struct sensor_device_attribute_2 *sensor_attr =
 323	    to_sensor_dev_attr_2(attr);
 324	int index = sensor_attr->index;
 325
 326	return sprintf(buf, "%d\n", vid_from_reg(data->vid[index], data->vrm));
 327}
 328
 329static ssize_t
 330vrm_store(struct device *dev, struct device_attribute *attr,
 331	  const char *buf, size_t count)
 332{
 333	struct w83793_data *data = dev_get_drvdata(dev);
 334	unsigned long val;
 335	int err;
 336
 337	err = kstrtoul(buf, 10, &val);
 338	if (err)
 339		return err;
 340
 341	if (val > 255)
 342		return -EINVAL;
 343
 344	data->vrm = val;
 345	return count;
 346}
 347
 348#define ALARM_STATUS			0
 349#define BEEP_ENABLE			1
 350static ssize_t
 351show_alarm_beep(struct device *dev, struct device_attribute *attr, char *buf)
 352{
 353	struct w83793_data *data = w83793_update_device(dev);
 354	struct sensor_device_attribute_2 *sensor_attr =
 355	    to_sensor_dev_attr_2(attr);
 356	int nr = sensor_attr->nr;
 357	int index = sensor_attr->index >> 3;
 358	int bit = sensor_attr->index & 0x07;
 359	u8 val;
 360
 361	if (nr == ALARM_STATUS) {
 362		val = (data->alarms[index] >> (bit)) & 1;
 363	} else {		/* BEEP_ENABLE */
 364		val = (data->beeps[index] >> (bit)) & 1;
 365	}
 366
 367	return sprintf(buf, "%u\n", val);
 368}
 369
 370static ssize_t
 371store_beep(struct device *dev, struct device_attribute *attr,
 372	   const char *buf, size_t count)
 373{
 374	struct i2c_client *client = to_i2c_client(dev);
 375	struct w83793_data *data = i2c_get_clientdata(client);
 376	struct sensor_device_attribute_2 *sensor_attr =
 377	    to_sensor_dev_attr_2(attr);
 378	int index = sensor_attr->index >> 3;
 379	int shift = sensor_attr->index & 0x07;
 380	u8 beep_bit = 1 << shift;
 381	unsigned long val;
 382	int err;
 383
 384	err = kstrtoul(buf, 10, &val);
 385	if (err)
 386		return err;
 387
 388	if (val > 1)
 389		return -EINVAL;
 390
 391	mutex_lock(&data->update_lock);
 392	data->beeps[index] = w83793_read_value(client, W83793_REG_BEEP(index));
 393	data->beeps[index] &= ~beep_bit;
 394	data->beeps[index] |= val << shift;
 395	w83793_write_value(client, W83793_REG_BEEP(index), data->beeps[index]);
 396	mutex_unlock(&data->update_lock);
 397
 398	return count;
 399}
 400
 401static ssize_t
 402show_beep_enable(struct device *dev, struct device_attribute *attr, char *buf)
 403{
 404	struct w83793_data *data = w83793_update_device(dev);
 405	return sprintf(buf, "%u\n", (data->beep_enable >> 1) & 0x01);
 406}
 407
 408static ssize_t
 409store_beep_enable(struct device *dev, struct device_attribute *attr,
 410		  const char *buf, size_t count)
 411{
 412	struct i2c_client *client = to_i2c_client(dev);
 413	struct w83793_data *data = i2c_get_clientdata(client);
 414	unsigned long val;
 415	int err;
 416
 417	err = kstrtoul(buf, 10, &val);
 418	if (err)
 419		return err;
 420
 421	if (val > 1)
 422		return -EINVAL;
 423
 424	mutex_lock(&data->update_lock);
 425	data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP)
 426			    & 0xfd;
 427	data->beep_enable |= val << 1;
 428	w83793_write_value(client, W83793_REG_OVT_BEEP, data->beep_enable);
 429	mutex_unlock(&data->update_lock);
 430
 431	return count;
 432}
 433
 434/* Write 0 to clear chassis alarm */
 435static ssize_t
 436store_chassis_clear(struct device *dev,
 437		    struct device_attribute *attr, const char *buf,
 438		    size_t count)
 439{
 440	struct i2c_client *client = to_i2c_client(dev);
 441	struct w83793_data *data = i2c_get_clientdata(client);
 442	unsigned long val;
 443	u8 reg;
 444	int err;
 445
 446	err = kstrtoul(buf, 10, &val);
 447	if (err)
 448		return err;
 449	if (val)
 450		return -EINVAL;
 451
 452	mutex_lock(&data->update_lock);
 453	reg = w83793_read_value(client, W83793_REG_CLR_CHASSIS);
 454	w83793_write_value(client, W83793_REG_CLR_CHASSIS, reg | 0x80);
 455	data->valid = false;		/* Force cache refresh */
 456	mutex_unlock(&data->update_lock);
 457	return count;
 458}
 459
 460#define FAN_INPUT			0
 461#define FAN_MIN				1
 462static ssize_t
 463show_fan(struct device *dev, struct device_attribute *attr, char *buf)
 464{
 465	struct sensor_device_attribute_2 *sensor_attr =
 466	    to_sensor_dev_attr_2(attr);
 467	int nr = sensor_attr->nr;
 468	int index = sensor_attr->index;
 469	struct w83793_data *data = w83793_update_device(dev);
 470	u16 val;
 471
 472	if (nr == FAN_INPUT)
 473		val = data->fan[index] & 0x0fff;
 474	else
 475		val = data->fan_min[index] & 0x0fff;
 476
 477	return sprintf(buf, "%lu\n", FAN_FROM_REG(val));
 478}
 479
 480static ssize_t
 481store_fan_min(struct device *dev, struct device_attribute *attr,
 482	      const char *buf, size_t count)
 483{
 484	struct sensor_device_attribute_2 *sensor_attr =
 485	    to_sensor_dev_attr_2(attr);
 486	int index = sensor_attr->index;
 487	struct i2c_client *client = to_i2c_client(dev);
 488	struct w83793_data *data = i2c_get_clientdata(client);
 489	unsigned long val;
 490	int err;
 491
 492	err = kstrtoul(buf, 10, &val);
 493	if (err)
 494		return err;
 495	val = FAN_TO_REG(val);
 496
 497	mutex_lock(&data->update_lock);
 498	data->fan_min[index] = val;
 499	w83793_write_value(client, W83793_REG_FAN_MIN(index),
 500			   (val >> 8) & 0xff);
 501	w83793_write_value(client, W83793_REG_FAN_MIN(index) + 1, val & 0xff);
 502	mutex_unlock(&data->update_lock);
 503
 504	return count;
 505}
 506
 507static ssize_t
 508show_pwm(struct device *dev, struct device_attribute *attr, char *buf)
 509{
 510	struct sensor_device_attribute_2 *sensor_attr =
 511	    to_sensor_dev_attr_2(attr);
 512	struct w83793_data *data = w83793_update_device(dev);
 513	u16 val;
 514	int nr = sensor_attr->nr;
 515	int index = sensor_attr->index;
 516
 517	if (nr == PWM_STOP_TIME)
 518		val = TIME_FROM_REG(data->pwm_stop_time[index]);
 519	else
 520		val = (data->pwm[index][nr] & 0x3f) << 2;
 521
 522	return sprintf(buf, "%d\n", val);
 523}
 524
 525static ssize_t
 526store_pwm(struct device *dev, struct device_attribute *attr,
 527	  const char *buf, size_t count)
 528{
 529	struct i2c_client *client = to_i2c_client(dev);
 530	struct w83793_data *data = i2c_get_clientdata(client);
 531	struct sensor_device_attribute_2 *sensor_attr =
 532	    to_sensor_dev_attr_2(attr);
 533	int nr = sensor_attr->nr;
 534	int index = sensor_attr->index;
 535	unsigned long val;
 536	int err;
 537
 538	err = kstrtoul(buf, 10, &val);
 539	if (err)
 540		return err;
 541
 542	mutex_lock(&data->update_lock);
 543	if (nr == PWM_STOP_TIME) {
 544		val = TIME_TO_REG(val);
 545		data->pwm_stop_time[index] = val;
 546		w83793_write_value(client, W83793_REG_PWM_STOP_TIME(index),
 547				   val);
 548	} else {
 549		val = clamp_val(val, 0, 0xff) >> 2;
 550		data->pwm[index][nr] =
 551		    w83793_read_value(client, W83793_REG_PWM(index, nr)) & 0xc0;
 552		data->pwm[index][nr] |= val;
 553		w83793_write_value(client, W83793_REG_PWM(index, nr),
 554							data->pwm[index][nr]);
 555	}
 556
 557	mutex_unlock(&data->update_lock);
 558	return count;
 559}
 560
 561static ssize_t
 562show_temp(struct device *dev, struct device_attribute *attr, char *buf)
 563{
 564	struct sensor_device_attribute_2 *sensor_attr =
 565	    to_sensor_dev_attr_2(attr);
 566	int nr = sensor_attr->nr;
 567	int index = sensor_attr->index;
 568	struct w83793_data *data = w83793_update_device(dev);
 569	long temp = TEMP_FROM_REG(data->temp[index][nr]);
 570
 571	if (nr == TEMP_READ && index < 4) {	/* Only TD1-TD4 have low bits */
 572		int low = ((data->temp_low_bits >> (index * 2)) & 0x03) * 250;
 573		temp += temp > 0 ? low : -low;
 574	}
 575	return sprintf(buf, "%ld\n", temp);
 576}
 577
 578static ssize_t
 579store_temp(struct device *dev, struct device_attribute *attr,
 580	   const char *buf, size_t count)
 581{
 582	struct sensor_device_attribute_2 *sensor_attr =
 583	    to_sensor_dev_attr_2(attr);
 584	int nr = sensor_attr->nr;
 585	int index = sensor_attr->index;
 586	struct i2c_client *client = to_i2c_client(dev);
 587	struct w83793_data *data = i2c_get_clientdata(client);
 588	long tmp;
 589	int err;
 590
 591	err = kstrtol(buf, 10, &tmp);
 592	if (err)
 593		return err;
 594
 595	mutex_lock(&data->update_lock);
 596	data->temp[index][nr] = TEMP_TO_REG(tmp, -128, 127);
 597	w83793_write_value(client, W83793_REG_TEMP[index][nr],
 598			   data->temp[index][nr]);
 599	mutex_unlock(&data->update_lock);
 600	return count;
 601}
 602
 603/*
 604 * TD1-TD4
 605 * each has 4 mode:(2 bits)
 606 * 0:	Stop monitor
 607 * 1:	Use internal temp sensor(default)
 608 * 2:	Reserved
 609 * 3:	Use sensor in Intel CPU and get result by PECI
 610 *
 611 * TR1-TR2
 612 * each has 2 mode:(1 bit)
 613 * 0:	Disable temp sensor monitor
 614 * 1:	To enable temp sensors monitor
 615 */
 616
 617/* 0 disable, 6 PECI */
 618static u8 TO_TEMP_MODE[] = { 0, 0, 0, 6 };
 619
 620static ssize_t
 621show_temp_mode(struct device *dev, struct device_attribute *attr, char *buf)
 622{
 623	struct w83793_data *data = w83793_update_device(dev);
 624	struct sensor_device_attribute_2 *sensor_attr =
 625	    to_sensor_dev_attr_2(attr);
 626	int index = sensor_attr->index;
 627	u8 mask = (index < 4) ? 0x03 : 0x01;
 628	u8 shift = (index < 4) ? (2 * index) : (index - 4);
 629	u8 tmp;
 630	index = (index < 4) ? 0 : 1;
 631
 632	tmp = (data->temp_mode[index] >> shift) & mask;
 633
 634	/* for the internal sensor, found out if diode or thermistor */
 635	if (tmp == 1)
 636		tmp = index == 0 ? 3 : 4;
 637	else
 638		tmp = TO_TEMP_MODE[tmp];
 639
 640	return sprintf(buf, "%d\n", tmp);
 641}
 642
 643static ssize_t
 644store_temp_mode(struct device *dev, struct device_attribute *attr,
 645		const char *buf, size_t count)
 646{
 647	struct i2c_client *client = to_i2c_client(dev);
 648	struct w83793_data *data = i2c_get_clientdata(client);
 649	struct sensor_device_attribute_2 *sensor_attr =
 650	    to_sensor_dev_attr_2(attr);
 651	int index = sensor_attr->index;
 652	u8 mask = (index < 4) ? 0x03 : 0x01;
 653	u8 shift = (index < 4) ? (2 * index) : (index - 4);
 654	unsigned long val;
 655	int err;
 656
 657	err = kstrtoul(buf, 10, &val);
 658	if (err)
 659		return err;
 660
 661	/* transform the sysfs interface values into table above */
 662	if ((val == 6) && (index < 4)) {
 663		val -= 3;
 664	} else if ((val == 3 && index < 4)
 665		|| (val == 4 && index >= 4)) {
 666		/* transform diode or thermistor into internal enable */
 667		val = !!val;
 668	} else {
 669		return -EINVAL;
 670	}
 671
 672	index = (index < 4) ? 0 : 1;
 673	mutex_lock(&data->update_lock);
 674	data->temp_mode[index] =
 675	    w83793_read_value(client, W83793_REG_TEMP_MODE[index]);
 676	data->temp_mode[index] &= ~(mask << shift);
 677	data->temp_mode[index] |= val << shift;
 678	w83793_write_value(client, W83793_REG_TEMP_MODE[index],
 679							data->temp_mode[index]);
 680	mutex_unlock(&data->update_lock);
 681
 682	return count;
 683}
 684
 685#define SETUP_PWM_DEFAULT		0
 686#define SETUP_PWM_UPTIME		1	/* Unit in 0.1s */
 687#define SETUP_PWM_DOWNTIME		2	/* Unit in 0.1s */
 688#define SETUP_TEMP_CRITICAL		3
 689static ssize_t
 690show_sf_setup(struct device *dev, struct device_attribute *attr, char *buf)
 691{
 692	struct sensor_device_attribute_2 *sensor_attr =
 693	    to_sensor_dev_attr_2(attr);
 694	int nr = sensor_attr->nr;
 695	struct w83793_data *data = w83793_update_device(dev);
 696	u32 val = 0;
 697
 698	if (nr == SETUP_PWM_DEFAULT)
 699		val = (data->pwm_default & 0x3f) << 2;
 700	else if (nr == SETUP_PWM_UPTIME)
 701		val = TIME_FROM_REG(data->pwm_uptime);
 702	else if (nr == SETUP_PWM_DOWNTIME)
 703		val = TIME_FROM_REG(data->pwm_downtime);
 704	else if (nr == SETUP_TEMP_CRITICAL)
 705		val = TEMP_FROM_REG(data->temp_critical & 0x7f);
 706
 707	return sprintf(buf, "%d\n", val);
 708}
 709
 710static ssize_t
 711store_sf_setup(struct device *dev, struct device_attribute *attr,
 712	       const char *buf, size_t count)
 713{
 714	struct sensor_device_attribute_2 *sensor_attr =
 715	    to_sensor_dev_attr_2(attr);
 716	int nr = sensor_attr->nr;
 717	struct i2c_client *client = to_i2c_client(dev);
 718	struct w83793_data *data = i2c_get_clientdata(client);
 719	long val;
 720	int err;
 721
 722	err = kstrtol(buf, 10, &val);
 723	if (err)
 724		return err;
 725
 726	mutex_lock(&data->update_lock);
 727	if (nr == SETUP_PWM_DEFAULT) {
 728		data->pwm_default =
 729		    w83793_read_value(client, W83793_REG_PWM_DEFAULT) & 0xc0;
 730		data->pwm_default |= clamp_val(val, 0, 0xff) >> 2;
 731		w83793_write_value(client, W83793_REG_PWM_DEFAULT,
 732							data->pwm_default);
 733	} else if (nr == SETUP_PWM_UPTIME) {
 734		data->pwm_uptime = TIME_TO_REG(val);
 735		data->pwm_uptime += data->pwm_uptime == 0 ? 1 : 0;
 736		w83793_write_value(client, W83793_REG_PWM_UPTIME,
 737							data->pwm_uptime);
 738	} else if (nr == SETUP_PWM_DOWNTIME) {
 739		data->pwm_downtime = TIME_TO_REG(val);
 740		data->pwm_downtime += data->pwm_downtime == 0 ? 1 : 0;
 741		w83793_write_value(client, W83793_REG_PWM_DOWNTIME,
 742							data->pwm_downtime);
 743	} else {		/* SETUP_TEMP_CRITICAL */
 744		data->temp_critical =
 745		    w83793_read_value(client, W83793_REG_TEMP_CRITICAL) & 0x80;
 746		data->temp_critical |= TEMP_TO_REG(val, 0, 0x7f);
 747		w83793_write_value(client, W83793_REG_TEMP_CRITICAL,
 748							data->temp_critical);
 749	}
 750
 751	mutex_unlock(&data->update_lock);
 752	return count;
 753}
 754
 755/*
 756 * Temp SmartFan control
 757 * TEMP_FAN_MAP
 758 * Temp channel control which pwm fan, bitfield, bit 0 indicate pwm1...
 759 * It's possible two or more temp channels control the same fan, w83793
 760 * always prefers to pick the most critical request and applies it to
 761 * the related Fan.
 762 * It's possible one fan is not in any mapping of 6 temp channels, this
 763 * means the fan is manual mode
 764 *
 765 * TEMP_PWM_ENABLE
 766 * Each temp channel has its own SmartFan mode, and temp channel
 767 * control fans that are set by TEMP_FAN_MAP
 768 * 0:	SmartFanII mode
 769 * 1:	Thermal Cruise Mode
 770 *
 771 * TEMP_CRUISE
 772 * Target temperature in thermal cruise mode, w83793 will try to turn
 773 * fan speed to keep the temperature of target device around this
 774 * temperature.
 775 *
 776 * TEMP_TOLERANCE
 777 * If Temp higher or lower than target with this tolerance, w83793
 778 * will take actions to speed up or slow down the fan to keep the
 779 * temperature within the tolerance range.
 780 */
 781
 782#define TEMP_FAN_MAP			0
 783#define TEMP_PWM_ENABLE			1
 784#define TEMP_CRUISE			2
 785#define TEMP_TOLERANCE			3
 786static ssize_t
 787show_sf_ctrl(struct device *dev, struct device_attribute *attr, char *buf)
 788{
 789	struct sensor_device_attribute_2 *sensor_attr =
 790	    to_sensor_dev_attr_2(attr);
 791	int nr = sensor_attr->nr;
 792	int index = sensor_attr->index;
 793	struct w83793_data *data = w83793_update_device(dev);
 794	u32 val;
 795
 796	if (nr == TEMP_FAN_MAP) {
 797		val = data->temp_fan_map[index];
 798	} else if (nr == TEMP_PWM_ENABLE) {
 799		/* +2 to transform into 2 and 3 to conform with sysfs intf */
 800		val = ((data->pwm_enable >> index) & 0x01) + 2;
 801	} else if (nr == TEMP_CRUISE) {
 802		val = TEMP_FROM_REG(data->temp_cruise[index] & 0x7f);
 803	} else {		/* TEMP_TOLERANCE */
 804		val = data->tolerance[index >> 1] >> ((index & 0x01) ? 4 : 0);
 805		val = TEMP_FROM_REG(val & 0x0f);
 806	}
 807	return sprintf(buf, "%d\n", val);
 808}
 809
 810static ssize_t
 811store_sf_ctrl(struct device *dev, struct device_attribute *attr,
 812	      const char *buf, size_t count)
 813{
 814	struct sensor_device_attribute_2 *sensor_attr =
 815	    to_sensor_dev_attr_2(attr);
 816	int nr = sensor_attr->nr;
 817	int index = sensor_attr->index;
 818	struct i2c_client *client = to_i2c_client(dev);
 819	struct w83793_data *data = i2c_get_clientdata(client);
 820	long val;
 821	int err;
 822
 823	err = kstrtol(buf, 10, &val);
 824	if (err)
 825		return err;
 826
 827	mutex_lock(&data->update_lock);
 828	if (nr == TEMP_FAN_MAP) {
 829		val = clamp_val(val, 0, 255);
 830		w83793_write_value(client, W83793_REG_TEMP_FAN_MAP(index), val);
 831		data->temp_fan_map[index] = val;
 832	} else if (nr == TEMP_PWM_ENABLE) {
 833		if (val == 2 || val == 3) {
 834			data->pwm_enable =
 835			    w83793_read_value(client, W83793_REG_PWM_ENABLE);
 836			if (val - 2)
 837				data->pwm_enable |= 1 << index;
 838			else
 839				data->pwm_enable &= ~(1 << index);
 840			w83793_write_value(client, W83793_REG_PWM_ENABLE,
 841							data->pwm_enable);
 842		} else {
 843			mutex_unlock(&data->update_lock);
 844			return -EINVAL;
 845		}
 846	} else if (nr == TEMP_CRUISE) {
 847		data->temp_cruise[index] =
 848		    w83793_read_value(client, W83793_REG_TEMP_CRUISE(index));
 849		data->temp_cruise[index] &= 0x80;
 850		data->temp_cruise[index] |= TEMP_TO_REG(val, 0, 0x7f);
 851
 852		w83793_write_value(client, W83793_REG_TEMP_CRUISE(index),
 853						data->temp_cruise[index]);
 854	} else {		/* TEMP_TOLERANCE */
 855		int i = index >> 1;
 856		u8 shift = (index & 0x01) ? 4 : 0;
 857		data->tolerance[i] =
 858		    w83793_read_value(client, W83793_REG_TEMP_TOL(i));
 859
 860		data->tolerance[i] &= ~(0x0f << shift);
 861		data->tolerance[i] |= TEMP_TO_REG(val, 0, 0x0f) << shift;
 862		w83793_write_value(client, W83793_REG_TEMP_TOL(i),
 863							data->tolerance[i]);
 864	}
 865
 866	mutex_unlock(&data->update_lock);
 867	return count;
 868}
 869
 870static ssize_t
 871show_sf2_pwm(struct device *dev, struct device_attribute *attr, char *buf)
 872{
 873	struct sensor_device_attribute_2 *sensor_attr =
 874	    to_sensor_dev_attr_2(attr);
 875	int nr = sensor_attr->nr;
 876	int index = sensor_attr->index;
 877	struct w83793_data *data = w83793_update_device(dev);
 878
 879	return sprintf(buf, "%d\n", (data->sf2_pwm[index][nr] & 0x3f) << 2);
 880}
 881
 882static ssize_t
 883store_sf2_pwm(struct device *dev, struct device_attribute *attr,
 884	      const char *buf, size_t count)
 885{
 886	struct i2c_client *client = to_i2c_client(dev);
 887	struct w83793_data *data = i2c_get_clientdata(client);
 888	struct sensor_device_attribute_2 *sensor_attr =
 889	    to_sensor_dev_attr_2(attr);
 890	int nr = sensor_attr->nr;
 891	int index = sensor_attr->index;
 892	unsigned long val;
 893	int err;
 894
 895	err = kstrtoul(buf, 10, &val);
 896	if (err)
 897		return err;
 898	val = clamp_val(val, 0, 0xff) >> 2;
 899
 900	mutex_lock(&data->update_lock);
 901	data->sf2_pwm[index][nr] =
 902	    w83793_read_value(client, W83793_REG_SF2_PWM(index, nr)) & 0xc0;
 903	data->sf2_pwm[index][nr] |= val;
 904	w83793_write_value(client, W83793_REG_SF2_PWM(index, nr),
 905						data->sf2_pwm[index][nr]);
 906	mutex_unlock(&data->update_lock);
 907	return count;
 908}
 909
 910static ssize_t
 911show_sf2_temp(struct device *dev, struct device_attribute *attr, char *buf)
 912{
 913	struct sensor_device_attribute_2 *sensor_attr =
 914	    to_sensor_dev_attr_2(attr);
 915	int nr = sensor_attr->nr;
 916	int index = sensor_attr->index;
 917	struct w83793_data *data = w83793_update_device(dev);
 918
 919	return sprintf(buf, "%ld\n",
 920		       TEMP_FROM_REG(data->sf2_temp[index][nr] & 0x7f));
 921}
 922
 923static ssize_t
 924store_sf2_temp(struct device *dev, struct device_attribute *attr,
 925	       const char *buf, size_t count)
 926{
 927	struct i2c_client *client = to_i2c_client(dev);
 928	struct w83793_data *data = i2c_get_clientdata(client);
 929	struct sensor_device_attribute_2 *sensor_attr =
 930	    to_sensor_dev_attr_2(attr);
 931	int nr = sensor_attr->nr;
 932	int index = sensor_attr->index;
 933	long val;
 934	int err;
 935
 936	err = kstrtol(buf, 10, &val);
 937	if (err)
 938		return err;
 939	val = TEMP_TO_REG(val, 0, 0x7f);
 940
 941	mutex_lock(&data->update_lock);
 942	data->sf2_temp[index][nr] =
 943	    w83793_read_value(client, W83793_REG_SF2_TEMP(index, nr)) & 0x80;
 944	data->sf2_temp[index][nr] |= val;
 945	w83793_write_value(client, W83793_REG_SF2_TEMP(index, nr),
 946					     data->sf2_temp[index][nr]);
 947	mutex_unlock(&data->update_lock);
 948	return count;
 949}
 950
 951/* only Vcore A/B and Vtt have additional 2 bits precision */
 952static ssize_t
 953show_in(struct device *dev, struct device_attribute *attr, char *buf)
 954{
 955	struct sensor_device_attribute_2 *sensor_attr =
 956	    to_sensor_dev_attr_2(attr);
 957	int nr = sensor_attr->nr;
 958	int index = sensor_attr->index;
 959	struct w83793_data *data = w83793_update_device(dev);
 960	u16 val = data->in[index][nr];
 961
 962	if (index < 3) {
 963		val <<= 2;
 964		val += (data->in_low_bits[nr] >> (index * 2)) & 0x3;
 965	}
 966	/* voltage inputs 5VDD and 5VSB needs 150mV offset */
 967	val = val * scale_in[index] + scale_in_add[index];
 968	return sprintf(buf, "%d\n", val);
 969}
 970
 971static ssize_t
 972store_in(struct device *dev, struct device_attribute *attr,
 973	 const char *buf, size_t count)
 974{
 975	struct sensor_device_attribute_2 *sensor_attr =
 976	    to_sensor_dev_attr_2(attr);
 977	int nr = sensor_attr->nr;
 978	int index = sensor_attr->index;
 979	struct i2c_client *client = to_i2c_client(dev);
 980	struct w83793_data *data = i2c_get_clientdata(client);
 981	unsigned long val;
 982	int err;
 983
 984	err = kstrtoul(buf, 10, &val);
 985	if (err)
 986		return err;
 987	val = (val + scale_in[index] / 2) / scale_in[index];
 988
 989	mutex_lock(&data->update_lock);
 990	if (index > 2) {
 991		/* fix the limit values of 5VDD and 5VSB to ALARM mechanism */
 992		if (nr == 1 || nr == 2)
 993			val -= scale_in_add[index] / scale_in[index];
 994		val = clamp_val(val, 0, 255);
 995	} else {
 996		val = clamp_val(val, 0, 0x3FF);
 997		data->in_low_bits[nr] =
 998		    w83793_read_value(client, W83793_REG_IN_LOW_BITS[nr]);
 999		data->in_low_bits[nr] &= ~(0x03 << (2 * index));
1000		data->in_low_bits[nr] |= (val & 0x03) << (2 * index);
1001		w83793_write_value(client, W83793_REG_IN_LOW_BITS[nr],
1002						     data->in_low_bits[nr]);
1003		val >>= 2;
1004	}
1005	data->in[index][nr] = val;
1006	w83793_write_value(client, W83793_REG_IN[index][nr],
1007							data->in[index][nr]);
1008	mutex_unlock(&data->update_lock);
1009	return count;
1010}
1011
1012#define NOT_USED			-1
1013
1014#define SENSOR_ATTR_IN(index)						\
1015	SENSOR_ATTR_2(in##index##_input, S_IRUGO, show_in, NULL,	\
1016		IN_READ, index),					\
1017	SENSOR_ATTR_2(in##index##_max, S_IRUGO | S_IWUSR, show_in,	\
1018		store_in, IN_MAX, index),				\
1019	SENSOR_ATTR_2(in##index##_min, S_IRUGO | S_IWUSR, show_in,	\
1020		store_in, IN_LOW, index),				\
1021	SENSOR_ATTR_2(in##index##_alarm, S_IRUGO, show_alarm_beep,	\
1022		NULL, ALARM_STATUS, index + ((index > 2) ? 1 : 0)),	\
1023	SENSOR_ATTR_2(in##index##_beep, S_IWUSR | S_IRUGO,		\
1024		show_alarm_beep, store_beep, BEEP_ENABLE,		\
1025		index + ((index > 2) ? 1 : 0))
1026
1027#define SENSOR_ATTR_FAN(index)						\
1028	SENSOR_ATTR_2(fan##index##_alarm, S_IRUGO, show_alarm_beep,	\
1029		NULL, ALARM_STATUS, index + 17),			\
1030	SENSOR_ATTR_2(fan##index##_beep, S_IWUSR | S_IRUGO,		\
1031		show_alarm_beep, store_beep, BEEP_ENABLE, index + 17),	\
1032	SENSOR_ATTR_2(fan##index##_input, S_IRUGO, show_fan,		\
1033		NULL, FAN_INPUT, index - 1),				\
1034	SENSOR_ATTR_2(fan##index##_min, S_IWUSR | S_IRUGO,		\
1035		show_fan, store_fan_min, FAN_MIN, index - 1)
1036
1037#define SENSOR_ATTR_PWM(index)						\
1038	SENSOR_ATTR_2(pwm##index, S_IWUSR | S_IRUGO, show_pwm,		\
1039		store_pwm, PWM_DUTY, index - 1),			\
1040	SENSOR_ATTR_2(pwm##index##_nonstop, S_IWUSR | S_IRUGO,		\
1041		show_pwm, store_pwm, PWM_NONSTOP, index - 1),		\
1042	SENSOR_ATTR_2(pwm##index##_start, S_IWUSR | S_IRUGO,		\
1043		show_pwm, store_pwm, PWM_START, index - 1),		\
1044	SENSOR_ATTR_2(pwm##index##_stop_time, S_IWUSR | S_IRUGO,	\
1045		show_pwm, store_pwm, PWM_STOP_TIME, index - 1)
1046
1047#define SENSOR_ATTR_TEMP(index)						\
1048	SENSOR_ATTR_2(temp##index##_type, S_IRUGO | S_IWUSR,		\
1049		show_temp_mode, store_temp_mode, NOT_USED, index - 1),	\
1050	SENSOR_ATTR_2(temp##index##_input, S_IRUGO, show_temp,		\
1051		NULL, TEMP_READ, index - 1),				\
1052	SENSOR_ATTR_2(temp##index##_max, S_IRUGO | S_IWUSR, show_temp,	\
1053		store_temp, TEMP_CRIT, index - 1),			\
1054	SENSOR_ATTR_2(temp##index##_max_hyst, S_IRUGO | S_IWUSR,	\
1055		show_temp, store_temp, TEMP_CRIT_HYST, index - 1),	\
1056	SENSOR_ATTR_2(temp##index##_warn, S_IRUGO | S_IWUSR, show_temp,	\
1057		store_temp, TEMP_WARN, index - 1),			\
1058	SENSOR_ATTR_2(temp##index##_warn_hyst, S_IRUGO | S_IWUSR,	\
1059		show_temp, store_temp, TEMP_WARN_HYST, index - 1),	\
1060	SENSOR_ATTR_2(temp##index##_alarm, S_IRUGO,			\
1061		show_alarm_beep, NULL, ALARM_STATUS, index + 11),	\
1062	SENSOR_ATTR_2(temp##index##_beep, S_IWUSR | S_IRUGO,		\
1063		show_alarm_beep, store_beep, BEEP_ENABLE, index + 11),	\
1064	SENSOR_ATTR_2(temp##index##_auto_channels_pwm,			\
1065		S_IRUGO | S_IWUSR, show_sf_ctrl, store_sf_ctrl,		\
1066		TEMP_FAN_MAP, index - 1),				\
1067	SENSOR_ATTR_2(temp##index##_pwm_enable, S_IWUSR | S_IRUGO,	\
1068		show_sf_ctrl, store_sf_ctrl, TEMP_PWM_ENABLE,		\
1069		index - 1),						\
1070	SENSOR_ATTR_2(thermal_cruise##index, S_IRUGO | S_IWUSR,		\
1071		show_sf_ctrl, store_sf_ctrl, TEMP_CRUISE, index - 1),	\
1072	SENSOR_ATTR_2(tolerance##index, S_IRUGO | S_IWUSR, show_sf_ctrl,\
1073		store_sf_ctrl, TEMP_TOLERANCE, index - 1),		\
1074	SENSOR_ATTR_2(temp##index##_auto_point1_pwm, S_IRUGO | S_IWUSR, \
1075		show_sf2_pwm, store_sf2_pwm, 0, index - 1),		\
1076	SENSOR_ATTR_2(temp##index##_auto_point2_pwm, S_IRUGO | S_IWUSR, \
1077		show_sf2_pwm, store_sf2_pwm, 1, index - 1),		\
1078	SENSOR_ATTR_2(temp##index##_auto_point3_pwm, S_IRUGO | S_IWUSR, \
1079		show_sf2_pwm, store_sf2_pwm, 2, index - 1),		\
1080	SENSOR_ATTR_2(temp##index##_auto_point4_pwm, S_IRUGO | S_IWUSR, \
1081		show_sf2_pwm, store_sf2_pwm, 3, index - 1),		\
1082	SENSOR_ATTR_2(temp##index##_auto_point5_pwm, S_IRUGO | S_IWUSR, \
1083		show_sf2_pwm, store_sf2_pwm, 4, index - 1),		\
1084	SENSOR_ATTR_2(temp##index##_auto_point6_pwm, S_IRUGO | S_IWUSR, \
1085		show_sf2_pwm, store_sf2_pwm, 5, index - 1),		\
1086	SENSOR_ATTR_2(temp##index##_auto_point7_pwm, S_IRUGO | S_IWUSR, \
1087		show_sf2_pwm, store_sf2_pwm, 6, index - 1),		\
1088	SENSOR_ATTR_2(temp##index##_auto_point1_temp, S_IRUGO | S_IWUSR,\
1089		show_sf2_temp, store_sf2_temp, 0, index - 1),		\
1090	SENSOR_ATTR_2(temp##index##_auto_point2_temp, S_IRUGO | S_IWUSR,\
1091		show_sf2_temp, store_sf2_temp, 1, index - 1),		\
1092	SENSOR_ATTR_2(temp##index##_auto_point3_temp, S_IRUGO | S_IWUSR,\
1093		show_sf2_temp, store_sf2_temp, 2, index - 1),		\
1094	SENSOR_ATTR_2(temp##index##_auto_point4_temp, S_IRUGO | S_IWUSR,\
1095		show_sf2_temp, store_sf2_temp, 3, index - 1),		\
1096	SENSOR_ATTR_2(temp##index##_auto_point5_temp, S_IRUGO | S_IWUSR,\
1097		show_sf2_temp, store_sf2_temp, 4, index - 1),		\
1098	SENSOR_ATTR_2(temp##index##_auto_point6_temp, S_IRUGO | S_IWUSR,\
1099		show_sf2_temp, store_sf2_temp, 5, index - 1),		\
1100	SENSOR_ATTR_2(temp##index##_auto_point7_temp, S_IRUGO | S_IWUSR,\
1101		show_sf2_temp, store_sf2_temp, 6, index - 1)
1102
1103static struct sensor_device_attribute_2 w83793_sensor_attr_2[] = {
1104	SENSOR_ATTR_IN(0),
1105	SENSOR_ATTR_IN(1),
1106	SENSOR_ATTR_IN(2),
1107	SENSOR_ATTR_IN(3),
1108	SENSOR_ATTR_IN(4),
1109	SENSOR_ATTR_IN(5),
1110	SENSOR_ATTR_IN(6),
1111	SENSOR_ATTR_IN(7),
1112	SENSOR_ATTR_IN(8),
1113	SENSOR_ATTR_IN(9),
1114	SENSOR_ATTR_FAN(1),
1115	SENSOR_ATTR_FAN(2),
1116	SENSOR_ATTR_FAN(3),
1117	SENSOR_ATTR_FAN(4),
1118	SENSOR_ATTR_FAN(5),
1119	SENSOR_ATTR_PWM(1),
1120	SENSOR_ATTR_PWM(2),
1121	SENSOR_ATTR_PWM(3),
1122};
1123
1124static struct sensor_device_attribute_2 w83793_temp[] = {
1125	SENSOR_ATTR_TEMP(1),
1126	SENSOR_ATTR_TEMP(2),
1127	SENSOR_ATTR_TEMP(3),
1128	SENSOR_ATTR_TEMP(4),
1129	SENSOR_ATTR_TEMP(5),
1130	SENSOR_ATTR_TEMP(6),
1131};
1132
1133/* Fan6-Fan12 */
1134static struct sensor_device_attribute_2 w83793_left_fan[] = {
1135	SENSOR_ATTR_FAN(6),
1136	SENSOR_ATTR_FAN(7),
1137	SENSOR_ATTR_FAN(8),
1138	SENSOR_ATTR_FAN(9),
1139	SENSOR_ATTR_FAN(10),
1140	SENSOR_ATTR_FAN(11),
1141	SENSOR_ATTR_FAN(12),
1142};
1143
1144/* Pwm4-Pwm8 */
1145static struct sensor_device_attribute_2 w83793_left_pwm[] = {
1146	SENSOR_ATTR_PWM(4),
1147	SENSOR_ATTR_PWM(5),
1148	SENSOR_ATTR_PWM(6),
1149	SENSOR_ATTR_PWM(7),
1150	SENSOR_ATTR_PWM(8),
1151};
1152
1153static struct sensor_device_attribute_2 w83793_vid[] = {
1154	SENSOR_ATTR_2(cpu0_vid, S_IRUGO, show_vid, NULL, NOT_USED, 0),
1155	SENSOR_ATTR_2(cpu1_vid, S_IRUGO, show_vid, NULL, NOT_USED, 1),
1156};
1157static DEVICE_ATTR_RW(vrm);
1158
1159static struct sensor_device_attribute_2 sda_single_files[] = {
1160	SENSOR_ATTR_2(intrusion0_alarm, S_IWUSR | S_IRUGO, show_alarm_beep,
1161		      store_chassis_clear, ALARM_STATUS, 30),
1162	SENSOR_ATTR_2(beep_enable, S_IWUSR | S_IRUGO, show_beep_enable,
1163		      store_beep_enable, NOT_USED, NOT_USED),
1164	SENSOR_ATTR_2(pwm_default, S_IWUSR | S_IRUGO, show_sf_setup,
1165		      store_sf_setup, SETUP_PWM_DEFAULT, NOT_USED),
1166	SENSOR_ATTR_2(pwm_uptime, S_IWUSR | S_IRUGO, show_sf_setup,
1167		      store_sf_setup, SETUP_PWM_UPTIME, NOT_USED),
1168	SENSOR_ATTR_2(pwm_downtime, S_IWUSR | S_IRUGO, show_sf_setup,
1169		      store_sf_setup, SETUP_PWM_DOWNTIME, NOT_USED),
1170	SENSOR_ATTR_2(temp_critical, S_IWUSR | S_IRUGO, show_sf_setup,
1171		      store_sf_setup, SETUP_TEMP_CRITICAL, NOT_USED),
1172};
1173
1174static void w83793_init_client(struct i2c_client *client)
1175{
1176	if (reset)
1177		w83793_write_value(client, W83793_REG_CONFIG, 0x80);
1178
1179	/* Start monitoring */
1180	w83793_write_value(client, W83793_REG_CONFIG,
1181			   w83793_read_value(client, W83793_REG_CONFIG) | 0x01);
1182}
1183
1184/*
1185 * Watchdog routines
1186 */
1187
1188static int watchdog_set_timeout(struct w83793_data *data, int timeout)
1189{
1190	unsigned int mtimeout;
1191	int ret;
1192
1193	mtimeout = DIV_ROUND_UP(timeout, 60);
1194
1195	if (mtimeout > 255)
1196		return -EINVAL;
1197
1198	mutex_lock(&data->watchdog_lock);
1199	if (!data->client) {
1200		ret = -ENODEV;
1201		goto leave;
1202	}
1203
1204	data->watchdog_timeout = mtimeout;
1205
1206	/* Set Timeout value (in Minutes) */
1207	w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT,
1208			   data->watchdog_timeout);
1209
1210	ret = mtimeout * 60;
1211
1212leave:
1213	mutex_unlock(&data->watchdog_lock);
1214	return ret;
1215}
1216
1217static int watchdog_get_timeout(struct w83793_data *data)
1218{
1219	int timeout;
1220
1221	mutex_lock(&data->watchdog_lock);
1222	timeout = data->watchdog_timeout * 60;
1223	mutex_unlock(&data->watchdog_lock);
1224
1225	return timeout;
1226}
1227
1228static int watchdog_trigger(struct w83793_data *data)
1229{
1230	int ret = 0;
1231
1232	mutex_lock(&data->watchdog_lock);
1233	if (!data->client) {
1234		ret = -ENODEV;
1235		goto leave;
1236	}
1237
1238	/* Set Timeout value (in Minutes) */
1239	w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT,
1240			   data->watchdog_timeout);
1241
1242leave:
1243	mutex_unlock(&data->watchdog_lock);
1244	return ret;
1245}
1246
1247static int watchdog_enable(struct w83793_data *data)
1248{
1249	int ret = 0;
1250
1251	mutex_lock(&data->watchdog_lock);
1252	if (!data->client) {
1253		ret = -ENODEV;
1254		goto leave;
1255	}
1256
1257	/* Set initial timeout */
1258	w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT,
1259			   data->watchdog_timeout);
1260
1261	/* Enable Soft Watchdog */
1262	w83793_write_value(data->client, W83793_REG_WDT_LOCK, 0x55);
1263
1264leave:
1265	mutex_unlock(&data->watchdog_lock);
1266	return ret;
1267}
1268
1269static int watchdog_disable(struct w83793_data *data)
1270{
1271	int ret = 0;
1272
1273	mutex_lock(&data->watchdog_lock);
1274	if (!data->client) {
1275		ret = -ENODEV;
1276		goto leave;
1277	}
1278
1279	/* Disable Soft Watchdog */
1280	w83793_write_value(data->client, W83793_REG_WDT_LOCK, 0xAA);
1281
1282leave:
1283	mutex_unlock(&data->watchdog_lock);
1284	return ret;
1285}
1286
1287static int watchdog_open(struct inode *inode, struct file *filp)
1288{
1289	struct w83793_data *pos, *data = NULL;
1290	int watchdog_is_open;
1291
1292	/*
1293	 * We get called from drivers/char/misc.c with misc_mtx hold, and we
1294	 * call misc_register() from  w83793_probe() with watchdog_data_mutex
1295	 * hold, as misc_register() takes the misc_mtx lock, this is a possible
1296	 * deadlock, so we use mutex_trylock here.
1297	 */
1298	if (!mutex_trylock(&watchdog_data_mutex))
1299		return -ERESTARTSYS;
1300	list_for_each_entry(pos, &watchdog_data_list, list) {
1301		if (pos->watchdog_miscdev.minor == iminor(inode)) {
1302			data = pos;
1303			break;
1304		}
1305	}
1306
1307	/* Check, if device is already open */
1308	watchdog_is_open = test_and_set_bit(0, &data->watchdog_is_open);
1309
1310	/*
1311	 * Increase data reference counter (if not already done).
1312	 * Note we can never not have found data, so we don't check for this
1313	 */
1314	if (!watchdog_is_open)
1315		kref_get(&data->kref);
1316
1317	mutex_unlock(&watchdog_data_mutex);
1318
1319	/* Check, if device is already open and possibly issue error */
1320	if (watchdog_is_open)
1321		return -EBUSY;
1322
1323	/* Enable Soft Watchdog */
1324	watchdog_enable(data);
1325
1326	/* Store pointer to data into filp's private data */
1327	filp->private_data = data;
1328
1329	return stream_open(inode, filp);
1330}
1331
1332static int watchdog_close(struct inode *inode, struct file *filp)
1333{
1334	struct w83793_data *data = filp->private_data;
1335
1336	if (data->watchdog_expect_close) {
1337		watchdog_disable(data);
1338		data->watchdog_expect_close = 0;
1339	} else {
1340		watchdog_trigger(data);
1341		dev_crit(&data->client->dev,
1342			"unexpected close, not stopping watchdog!\n");
1343	}
1344
1345	clear_bit(0, &data->watchdog_is_open);
1346
1347	/* Decrease data reference counter */
1348	mutex_lock(&watchdog_data_mutex);
1349	kref_put(&data->kref, w83793_release_resources);
1350	mutex_unlock(&watchdog_data_mutex);
1351
1352	return 0;
1353}
1354
1355static ssize_t watchdog_write(struct file *filp, const char __user *buf,
1356	size_t count, loff_t *offset)
1357{
1358	ssize_t ret;
1359	struct w83793_data *data = filp->private_data;
1360
1361	if (count) {
1362		if (!nowayout) {
1363			size_t i;
1364
1365			/* Clear it in case it was set with a previous write */
1366			data->watchdog_expect_close = 0;
1367
1368			for (i = 0; i != count; i++) {
1369				char c;
1370				if (get_user(c, buf + i))
1371					return -EFAULT;
1372				if (c == 'V')
1373					data->watchdog_expect_close = 1;
1374			}
1375		}
1376		ret = watchdog_trigger(data);
1377		if (ret < 0)
1378			return ret;
1379	}
1380	return count;
1381}
1382
1383static long watchdog_ioctl(struct file *filp, unsigned int cmd,
1384			   unsigned long arg)
1385{
1386	struct watchdog_info ident = {
1387		.options = WDIOF_KEEPALIVEPING |
1388			   WDIOF_SETTIMEOUT |
1389			   WDIOF_CARDRESET,
1390		.identity = "w83793 watchdog"
1391	};
1392
1393	int val, ret = 0;
1394	struct w83793_data *data = filp->private_data;
1395
1396	switch (cmd) {
1397	case WDIOC_GETSUPPORT:
1398		if (!nowayout)
1399			ident.options |= WDIOF_MAGICCLOSE;
1400		if (copy_to_user((void __user *)arg, &ident, sizeof(ident)))
1401			ret = -EFAULT;
1402		break;
1403
1404	case WDIOC_GETSTATUS:
1405		val = data->watchdog_caused_reboot ? WDIOF_CARDRESET : 0;
1406		ret = put_user(val, (int __user *)arg);
1407		break;
1408
1409	case WDIOC_GETBOOTSTATUS:
1410		ret = put_user(0, (int __user *)arg);
1411		break;
1412
1413	case WDIOC_KEEPALIVE:
1414		ret = watchdog_trigger(data);
1415		break;
1416
1417	case WDIOC_GETTIMEOUT:
1418		val = watchdog_get_timeout(data);
1419		ret = put_user(val, (int __user *)arg);
1420		break;
1421
1422	case WDIOC_SETTIMEOUT:
1423		if (get_user(val, (int __user *)arg)) {
1424			ret = -EFAULT;
1425			break;
1426		}
1427		ret = watchdog_set_timeout(data, val);
1428		if (ret > 0)
1429			ret = put_user(ret, (int __user *)arg);
1430		break;
1431
1432	case WDIOC_SETOPTIONS:
1433		if (get_user(val, (int __user *)arg)) {
1434			ret = -EFAULT;
1435			break;
1436		}
1437
1438		if (val & WDIOS_DISABLECARD)
1439			ret = watchdog_disable(data);
1440		else if (val & WDIOS_ENABLECARD)
1441			ret = watchdog_enable(data);
1442		else
1443			ret = -EINVAL;
1444
1445		break;
1446	default:
1447		ret = -ENOTTY;
1448	}
1449	return ret;
1450}
1451
1452static const struct file_operations watchdog_fops = {
1453	.owner = THIS_MODULE,
1454	.open = watchdog_open,
1455	.release = watchdog_close,
1456	.write = watchdog_write,
1457	.unlocked_ioctl = watchdog_ioctl,
1458	.compat_ioctl = compat_ptr_ioctl,
1459};
1460
1461/*
1462 *	Notifier for system down
1463 */
1464
1465static int watchdog_notify_sys(struct notifier_block *this, unsigned long code,
1466			       void *unused)
1467{
1468	struct w83793_data *data = NULL;
1469
1470	if (code == SYS_DOWN || code == SYS_HALT) {
1471
1472		/* Disable each registered watchdog */
1473		mutex_lock(&watchdog_data_mutex);
1474		list_for_each_entry(data, &watchdog_data_list, list) {
1475			if (data->watchdog_miscdev.minor)
1476				watchdog_disable(data);
1477		}
1478		mutex_unlock(&watchdog_data_mutex);
1479	}
1480
1481	return NOTIFY_DONE;
1482}
1483
1484/*
1485 *	The WDT needs to learn about soft shutdowns in order to
1486 *	turn the timebomb registers off.
1487 */
1488
1489static struct notifier_block watchdog_notifier = {
1490	.notifier_call = watchdog_notify_sys,
1491};
1492
1493/*
1494 * Init / remove routines
1495 */
1496
1497static void w83793_remove(struct i2c_client *client)
1498{
1499	struct w83793_data *data = i2c_get_clientdata(client);
1500	struct device *dev = &client->dev;
1501	int i, tmp;
1502
1503	/* Unregister the watchdog (if registered) */
1504	if (data->watchdog_miscdev.minor) {
1505		misc_deregister(&data->watchdog_miscdev);
1506
1507		if (data->watchdog_is_open) {
1508			dev_warn(&client->dev,
1509				"i2c client detached with watchdog open! "
1510				"Stopping watchdog.\n");
1511			watchdog_disable(data);
1512		}
1513
1514		mutex_lock(&watchdog_data_mutex);
1515		list_del(&data->list);
1516		mutex_unlock(&watchdog_data_mutex);
1517
1518		/* Tell the watchdog code the client is gone */
1519		mutex_lock(&data->watchdog_lock);
1520		data->client = NULL;
1521		mutex_unlock(&data->watchdog_lock);
1522	}
1523
1524	/* Reset Configuration Register to Disable Watch Dog Registers */
1525	tmp = w83793_read_value(client, W83793_REG_CONFIG);
1526	w83793_write_value(client, W83793_REG_CONFIG, tmp & ~0x04);
1527
1528	unregister_reboot_notifier(&watchdog_notifier);
1529
1530	hwmon_device_unregister(data->hwmon_dev);
1531
1532	for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++)
1533		device_remove_file(dev,
1534				   &w83793_sensor_attr_2[i].dev_attr);
1535
1536	for (i = 0; i < ARRAY_SIZE(sda_single_files); i++)
1537		device_remove_file(dev, &sda_single_files[i].dev_attr);
1538
1539	for (i = 0; i < ARRAY_SIZE(w83793_vid); i++)
1540		device_remove_file(dev, &w83793_vid[i].dev_attr);
1541	device_remove_file(dev, &dev_attr_vrm);
1542
1543	for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++)
1544		device_remove_file(dev, &w83793_left_fan[i].dev_attr);
1545
1546	for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++)
1547		device_remove_file(dev, &w83793_left_pwm[i].dev_attr);
1548
1549	for (i = 0; i < ARRAY_SIZE(w83793_temp); i++)
1550		device_remove_file(dev, &w83793_temp[i].dev_attr);
1551
1552	/* Decrease data reference counter */
1553	mutex_lock(&watchdog_data_mutex);
1554	kref_put(&data->kref, w83793_release_resources);
1555	mutex_unlock(&watchdog_data_mutex);
1556}
1557
1558static int
1559w83793_detect_subclients(struct i2c_client *client)
1560{
1561	int i, id;
1562	int address = client->addr;
1563	u8 tmp;
1564	struct i2c_adapter *adapter = client->adapter;
1565
1566	id = i2c_adapter_id(adapter);
1567	if (force_subclients[0] == id && force_subclients[1] == address) {
1568		for (i = 2; i <= 3; i++) {
1569			if (force_subclients[i] < 0x48
1570			    || force_subclients[i] > 0x4f) {
1571				dev_err(&client->dev,
1572					"invalid subclient "
1573					"address %d; must be 0x48-0x4f\n",
1574					force_subclients[i]);
1575				return -EINVAL;
1576			}
1577		}
1578		w83793_write_value(client, W83793_REG_I2C_SUBADDR,
1579				   (force_subclients[2] & 0x07) |
1580				   ((force_subclients[3] & 0x07) << 4));
1581	}
1582
1583	tmp = w83793_read_value(client, W83793_REG_I2C_SUBADDR);
1584
1585	if (!(tmp & 0x88) && (tmp & 0x7) == ((tmp >> 4) & 0x7)) {
1586		dev_err(&client->dev,
1587			"duplicate addresses 0x%x, use force_subclient\n", 0x48 + (tmp & 0x7));
1588		return -ENODEV;
1589	}
1590
1591	if (!(tmp & 0x08))
1592		devm_i2c_new_dummy_device(&client->dev, adapter, 0x48 + (tmp & 0x7));
1593
1594	if (!(tmp & 0x80))
1595		devm_i2c_new_dummy_device(&client->dev, adapter, 0x48 + ((tmp >> 4) & 0x7));
1596
1597	return 0;
1598}
1599
1600/* Return 0 if detection is successful, -ENODEV otherwise */
1601static int w83793_detect(struct i2c_client *client,
1602			 struct i2c_board_info *info)
1603{
1604	u8 tmp, bank, chip_id;
1605	struct i2c_adapter *adapter = client->adapter;
1606	unsigned short address = client->addr;
1607
1608	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1609		return -ENODEV;
1610
1611	bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL);
1612
1613	tmp = bank & 0x80 ? 0x5c : 0xa3;
1614	/* Check Winbond vendor ID */
1615	if (tmp != i2c_smbus_read_byte_data(client, W83793_REG_VENDORID)) {
1616		pr_debug("w83793: Detection failed at check vendor id\n");
1617		return -ENODEV;
1618	}
1619
1620	/*
1621	 * If Winbond chip, address of chip and W83793_REG_I2C_ADDR
1622	 * should match
1623	 */
1624	if ((bank & 0x07) == 0
1625	 && i2c_smbus_read_byte_data(client, W83793_REG_I2C_ADDR) !=
1626	    (address << 1)) {
1627		pr_debug("w83793: Detection failed at check i2c addr\n");
1628		return -ENODEV;
1629	}
1630
1631	/* Determine the chip type now */
1632	chip_id = i2c_smbus_read_byte_data(client, W83793_REG_CHIPID);
1633	if (chip_id != 0x7b)
1634		return -ENODEV;
1635
1636	strscpy(info->type, "w83793", I2C_NAME_SIZE);
1637
1638	return 0;
1639}
1640
1641static int w83793_probe(struct i2c_client *client)
1642{
1643	struct device *dev = &client->dev;
1644	static const int watchdog_minors[] = {
1645		WATCHDOG_MINOR, 212, 213, 214, 215
1646	};
1647	struct w83793_data *data;
1648	int i, tmp, val, err;
1649	int files_fan = ARRAY_SIZE(w83793_left_fan) / 7;
1650	int files_pwm = ARRAY_SIZE(w83793_left_pwm) / 5;
1651	int files_temp = ARRAY_SIZE(w83793_temp) / 6;
1652
1653	data = kzalloc(sizeof(struct w83793_data), GFP_KERNEL);
1654	if (!data) {
1655		err = -ENOMEM;
1656		goto exit;
1657	}
1658
1659	i2c_set_clientdata(client, data);
1660	data->bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL);
1661	mutex_init(&data->update_lock);
1662	mutex_init(&data->watchdog_lock);
1663	INIT_LIST_HEAD(&data->list);
1664	kref_init(&data->kref);
1665
1666	/*
1667	 * Store client pointer in our data struct for watchdog usage
1668	 * (where the client is found through a data ptr instead of the
1669	 * otherway around)
1670	 */
1671	data->client = client;
1672
1673	err = w83793_detect_subclients(client);
1674	if (err)
1675		goto free_mem;
1676
1677	/* Initialize the chip */
1678	w83793_init_client(client);
1679
1680	/*
1681	 * Only fan 1-5 has their own input pins,
1682	 * Pwm 1-3 has their own pins
1683	 */
1684	data->has_fan = 0x1f;
1685	data->has_pwm = 0x07;
1686	tmp = w83793_read_value(client, W83793_REG_MFC);
1687	val = w83793_read_value(client, W83793_REG_FANIN_CTRL);
1688
1689	/* check the function of pins 49-56 */
1690	if (tmp & 0x80) {
1691		data->has_vid |= 0x2;	/* has VIDB */
1692	} else {
1693		data->has_pwm |= 0x18;	/* pwm 4,5 */
1694		if (val & 0x01) {	/* fan 6 */
1695			data->has_fan |= 0x20;
1696			data->has_pwm |= 0x20;
1697		}
1698		if (val & 0x02) {	/* fan 7 */
1699			data->has_fan |= 0x40;
1700			data->has_pwm |= 0x40;
1701		}
1702		if (!(tmp & 0x40) && (val & 0x04)) {	/* fan 8 */
1703			data->has_fan |= 0x80;
1704			data->has_pwm |= 0x80;
1705		}
1706	}
1707
1708	/* check the function of pins 37-40 */
1709	if (!(tmp & 0x29))
1710		data->has_vid |= 0x1;	/* has VIDA */
1711	if (0x08 == (tmp & 0x0c)) {
1712		if (val & 0x08)	/* fan 9 */
1713			data->has_fan |= 0x100;
1714		if (val & 0x10)	/* fan 10 */
1715			data->has_fan |= 0x200;
1716	}
1717	if (0x20 == (tmp & 0x30)) {
1718		if (val & 0x20)	/* fan 11 */
1719			data->has_fan |= 0x400;
1720		if (val & 0x40)	/* fan 12 */
1721			data->has_fan |= 0x800;
1722	}
1723
1724	if ((tmp & 0x01) && (val & 0x04)) {	/* fan 8, second location */
1725		data->has_fan |= 0x80;
1726		data->has_pwm |= 0x80;
1727	}
1728
1729	tmp = w83793_read_value(client, W83793_REG_FANIN_SEL);
1730	if ((tmp & 0x01) && (val & 0x08)) {	/* fan 9, second location */
1731		data->has_fan |= 0x100;
1732	}
1733	if ((tmp & 0x02) && (val & 0x10)) {	/* fan 10, second location */
1734		data->has_fan |= 0x200;
1735	}
1736	if ((tmp & 0x04) && (val & 0x20)) {	/* fan 11, second location */
1737		data->has_fan |= 0x400;
1738	}
1739	if ((tmp & 0x08) && (val & 0x40)) {	/* fan 12, second location */
1740		data->has_fan |= 0x800;
1741	}
1742
1743	/* check the temp1-6 mode, ignore former AMDSI selected inputs */
1744	tmp = w83793_read_value(client, W83793_REG_TEMP_MODE[0]);
1745	if (tmp & 0x01)
1746		data->has_temp |= 0x01;
1747	if (tmp & 0x04)
1748		data->has_temp |= 0x02;
1749	if (tmp & 0x10)
1750		data->has_temp |= 0x04;
1751	if (tmp & 0x40)
1752		data->has_temp |= 0x08;
1753
1754	tmp = w83793_read_value(client, W83793_REG_TEMP_MODE[1]);
1755	if (tmp & 0x01)
1756		data->has_temp |= 0x10;
1757	if (tmp & 0x02)
1758		data->has_temp |= 0x20;
1759
1760	/* Register sysfs hooks */
1761	for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++) {
1762		err = device_create_file(dev,
1763					 &w83793_sensor_attr_2[i].dev_attr);
1764		if (err)
1765			goto exit_remove;
1766	}
1767
1768	for (i = 0; i < ARRAY_SIZE(w83793_vid); i++) {
1769		if (!(data->has_vid & (1 << i)))
1770			continue;
1771		err = device_create_file(dev, &w83793_vid[i].dev_attr);
1772		if (err)
1773			goto exit_remove;
1774	}
1775	if (data->has_vid) {
1776		data->vrm = vid_which_vrm();
1777		err = device_create_file(dev, &dev_attr_vrm);
1778		if (err)
1779			goto exit_remove;
1780	}
1781
1782	for (i = 0; i < ARRAY_SIZE(sda_single_files); i++) {
1783		err = device_create_file(dev, &sda_single_files[i].dev_attr);
1784		if (err)
1785			goto exit_remove;
1786
1787	}
1788
1789	for (i = 0; i < 6; i++) {
1790		int j;
1791		if (!(data->has_temp & (1 << i)))
1792			continue;
1793		for (j = 0; j < files_temp; j++) {
1794			err = device_create_file(dev,
1795						&w83793_temp[(i) * files_temp
1796								+ j].dev_attr);
1797			if (err)
1798				goto exit_remove;
1799		}
1800	}
1801
1802	for (i = 5; i < 12; i++) {
1803		int j;
1804		if (!(data->has_fan & (1 << i)))
1805			continue;
1806		for (j = 0; j < files_fan; j++) {
1807			err = device_create_file(dev,
1808					   &w83793_left_fan[(i - 5) * files_fan
1809								+ j].dev_attr);
1810			if (err)
1811				goto exit_remove;
1812		}
1813	}
1814
1815	for (i = 3; i < 8; i++) {
1816		int j;
1817		if (!(data->has_pwm & (1 << i)))
1818			continue;
1819		for (j = 0; j < files_pwm; j++) {
1820			err = device_create_file(dev,
1821					   &w83793_left_pwm[(i - 3) * files_pwm
1822								+ j].dev_attr);
1823			if (err)
1824				goto exit_remove;
1825		}
1826	}
1827
1828	data->hwmon_dev = hwmon_device_register(dev);
1829	if (IS_ERR(data->hwmon_dev)) {
1830		err = PTR_ERR(data->hwmon_dev);
1831		goto exit_remove;
1832	}
1833
1834	/* Watchdog initialization */
1835
1836	/* Register boot notifier */
1837	err = register_reboot_notifier(&watchdog_notifier);
1838	if (err != 0) {
1839		dev_err(&client->dev,
1840			"cannot register reboot notifier (err=%d)\n", err);
1841		goto exit_devunreg;
1842	}
1843
1844	/*
1845	 * Enable Watchdog registers.
1846	 * Set Configuration Register to Enable Watch Dog Registers
1847	 * (Bit 2) = XXXX, X1XX.
1848	 */
1849	tmp = w83793_read_value(client, W83793_REG_CONFIG);
1850	w83793_write_value(client, W83793_REG_CONFIG, tmp | 0x04);
1851
1852	/* Set the default watchdog timeout */
1853	data->watchdog_timeout = timeout;
1854
1855	/* Check, if last reboot was caused by watchdog */
1856	data->watchdog_caused_reboot =
1857	  w83793_read_value(data->client, W83793_REG_WDT_STATUS) & 0x01;
1858
1859	/* Disable Soft Watchdog during initialiation */
1860	watchdog_disable(data);
1861
1862	/*
1863	 * We take the data_mutex lock early so that watchdog_open() cannot
1864	 * run when misc_register() has completed, but we've not yet added
1865	 * our data to the watchdog_data_list (and set the default timeout)
1866	 */
1867	mutex_lock(&watchdog_data_mutex);
1868	for (i = 0; i < ARRAY_SIZE(watchdog_minors); i++) {
1869		/* Register our watchdog part */
1870		snprintf(data->watchdog_name, sizeof(data->watchdog_name),
1871			"watchdog%c", (i == 0) ? '\0' : ('0' + i));
1872		data->watchdog_miscdev.name = data->watchdog_name;
1873		data->watchdog_miscdev.fops = &watchdog_fops;
1874		data->watchdog_miscdev.minor = watchdog_minors[i];
1875
1876		err = misc_register(&data->watchdog_miscdev);
1877		if (err == -EBUSY)
1878			continue;
1879		if (err) {
1880			data->watchdog_miscdev.minor = 0;
1881			dev_err(&client->dev,
1882				"Registering watchdog chardev: %d\n", err);
1883			break;
1884		}
1885
1886		list_add(&data->list, &watchdog_data_list);
1887
1888		dev_info(&client->dev,
1889			"Registered watchdog chardev major 10, minor: %d\n",
1890			watchdog_minors[i]);
1891		break;
1892	}
1893	if (i == ARRAY_SIZE(watchdog_minors)) {
1894		data->watchdog_miscdev.minor = 0;
1895		dev_warn(&client->dev,
1896			 "Couldn't register watchdog chardev (due to no free minor)\n");
1897	}
1898
1899	mutex_unlock(&watchdog_data_mutex);
1900
1901	return 0;
1902
1903	/* Unregister hwmon device */
1904
1905exit_devunreg:
1906
1907	hwmon_device_unregister(data->hwmon_dev);
1908
1909	/* Unregister sysfs hooks */
1910
1911exit_remove:
1912	for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++)
1913		device_remove_file(dev, &w83793_sensor_attr_2[i].dev_attr);
1914
1915	for (i = 0; i < ARRAY_SIZE(sda_single_files); i++)
1916		device_remove_file(dev, &sda_single_files[i].dev_attr);
1917
1918	for (i = 0; i < ARRAY_SIZE(w83793_vid); i++)
1919		device_remove_file(dev, &w83793_vid[i].dev_attr);
1920
1921	for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++)
1922		device_remove_file(dev, &w83793_left_fan[i].dev_attr);
1923
1924	for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++)
1925		device_remove_file(dev, &w83793_left_pwm[i].dev_attr);
1926
1927	for (i = 0; i < ARRAY_SIZE(w83793_temp); i++)
1928		device_remove_file(dev, &w83793_temp[i].dev_attr);
1929free_mem:
1930	kfree(data);
1931exit:
1932	return err;
1933}
1934
1935static void w83793_update_nonvolatile(struct device *dev)
1936{
1937	struct i2c_client *client = to_i2c_client(dev);
1938	struct w83793_data *data = i2c_get_clientdata(client);
1939	int i, j;
1940	/*
1941	 * They are somewhat "stable" registers, and to update them every time
1942	 * takes so much time, it's just not worthy. Update them in a long
1943	 * interval to avoid exception.
1944	 */
1945	if (!(time_after(jiffies, data->last_nonvolatile + HZ * 300)
1946	      || !data->valid))
1947		return;
1948	/* update voltage limits */
1949	for (i = 1; i < 3; i++) {
1950		for (j = 0; j < ARRAY_SIZE(data->in); j++) {
1951			data->in[j][i] =
1952			    w83793_read_value(client, W83793_REG_IN[j][i]);
1953		}
1954		data->in_low_bits[i] =
1955		    w83793_read_value(client, W83793_REG_IN_LOW_BITS[i]);
1956	}
1957
1958	for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) {
1959		/* Update the Fan measured value and limits */
1960		if (!(data->has_fan & (1 << i)))
1961			continue;
1962		data->fan_min[i] =
1963		    w83793_read_value(client, W83793_REG_FAN_MIN(i)) << 8;
1964		data->fan_min[i] |=
1965		    w83793_read_value(client, W83793_REG_FAN_MIN(i) + 1);
1966	}
1967
1968	for (i = 0; i < ARRAY_SIZE(data->temp_fan_map); i++) {
1969		if (!(data->has_temp & (1 << i)))
1970			continue;
1971		data->temp_fan_map[i] =
1972		    w83793_read_value(client, W83793_REG_TEMP_FAN_MAP(i));
1973		for (j = 1; j < 5; j++) {
1974			data->temp[i][j] =
1975			    w83793_read_value(client, W83793_REG_TEMP[i][j]);
1976		}
1977		data->temp_cruise[i] =
1978		    w83793_read_value(client, W83793_REG_TEMP_CRUISE(i));
1979		for (j = 0; j < 7; j++) {
1980			data->sf2_pwm[i][j] =
1981			    w83793_read_value(client, W83793_REG_SF2_PWM(i, j));
1982			data->sf2_temp[i][j] =
1983			    w83793_read_value(client,
1984					      W83793_REG_SF2_TEMP(i, j));
1985		}
1986	}
1987
1988	for (i = 0; i < ARRAY_SIZE(data->temp_mode); i++)
1989		data->temp_mode[i] =
1990		    w83793_read_value(client, W83793_REG_TEMP_MODE[i]);
1991
1992	for (i = 0; i < ARRAY_SIZE(data->tolerance); i++) {
1993		data->tolerance[i] =
1994		    w83793_read_value(client, W83793_REG_TEMP_TOL(i));
1995	}
1996
1997	for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
1998		if (!(data->has_pwm & (1 << i)))
1999			continue;
2000		data->pwm[i][PWM_NONSTOP] =
2001		    w83793_read_value(client, W83793_REG_PWM(i, PWM_NONSTOP));
2002		data->pwm[i][PWM_START] =
2003		    w83793_read_value(client, W83793_REG_PWM(i, PWM_START));
2004		data->pwm_stop_time[i] =
2005		    w83793_read_value(client, W83793_REG_PWM_STOP_TIME(i));
2006	}
2007
2008	data->pwm_default = w83793_read_value(client, W83793_REG_PWM_DEFAULT);
2009	data->pwm_enable = w83793_read_value(client, W83793_REG_PWM_ENABLE);
2010	data->pwm_uptime = w83793_read_value(client, W83793_REG_PWM_UPTIME);
2011	data->pwm_downtime = w83793_read_value(client, W83793_REG_PWM_DOWNTIME);
2012	data->temp_critical =
2013	    w83793_read_value(client, W83793_REG_TEMP_CRITICAL);
2014	data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP);
2015
2016	for (i = 0; i < ARRAY_SIZE(data->beeps); i++)
2017		data->beeps[i] = w83793_read_value(client, W83793_REG_BEEP(i));
2018
2019	data->last_nonvolatile = jiffies;
2020}
2021
2022static struct w83793_data *w83793_update_device(struct device *dev)
2023{
2024	struct i2c_client *client = to_i2c_client(dev);
2025	struct w83793_data *data = i2c_get_clientdata(client);
2026	int i;
2027
2028	mutex_lock(&data->update_lock);
2029
2030	if (!(time_after(jiffies, data->last_updated + HZ * 2)
2031	      || !data->valid))
2032		goto END;
2033
2034	/* Update the voltages measured value and limits */
2035	for (i = 0; i < ARRAY_SIZE(data->in); i++)
2036		data->in[i][IN_READ] =
2037		    w83793_read_value(client, W83793_REG_IN[i][IN_READ]);
2038
2039	data->in_low_bits[IN_READ] =
2040	    w83793_read_value(client, W83793_REG_IN_LOW_BITS[IN_READ]);
2041
2042	for (i = 0; i < ARRAY_SIZE(data->fan); i++) {
2043		if (!(data->has_fan & (1 << i)))
2044			continue;
2045		data->fan[i] =
2046		    w83793_read_value(client, W83793_REG_FAN(i)) << 8;
2047		data->fan[i] |=
2048		    w83793_read_value(client, W83793_REG_FAN(i) + 1);
2049	}
2050
2051	for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
2052		if (!(data->has_temp & (1 << i)))
2053			continue;
2054		data->temp[i][TEMP_READ] =
2055		    w83793_read_value(client, W83793_REG_TEMP[i][TEMP_READ]);
2056	}
2057
2058	data->temp_low_bits =
2059	    w83793_read_value(client, W83793_REG_TEMP_LOW_BITS);
2060
2061	for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
2062		if (data->has_pwm & (1 << i))
2063			data->pwm[i][PWM_DUTY] =
2064			    w83793_read_value(client,
2065					      W83793_REG_PWM(i, PWM_DUTY));
2066	}
2067
2068	for (i = 0; i < ARRAY_SIZE(data->alarms); i++)
2069		data->alarms[i] =
2070		    w83793_read_value(client, W83793_REG_ALARM(i));
2071	if (data->has_vid & 0x01)
2072		data->vid[0] = w83793_read_value(client, W83793_REG_VID_INA);
2073	if (data->has_vid & 0x02)
2074		data->vid[1] = w83793_read_value(client, W83793_REG_VID_INB);
2075	w83793_update_nonvolatile(dev);
2076	data->last_updated = jiffies;
2077	data->valid = true;
2078
2079END:
2080	mutex_unlock(&data->update_lock);
2081	return data;
2082}
2083
2084/*
2085 * Ignore the possibility that somebody change bank outside the driver
2086 * Must be called with data->update_lock held, except during initialization
2087 */
2088static u8 w83793_read_value(struct i2c_client *client, u16 reg)
2089{
2090	struct w83793_data *data = i2c_get_clientdata(client);
2091	u8 res;
2092	u8 new_bank = reg >> 8;
2093
2094	new_bank |= data->bank & 0xfc;
2095	if (data->bank != new_bank) {
2096		if (i2c_smbus_write_byte_data
2097		    (client, W83793_REG_BANKSEL, new_bank) >= 0)
2098			data->bank = new_bank;
2099		else {
2100			dev_err(&client->dev,
2101				"set bank to %d failed, fall back "
2102				"to bank %d, read reg 0x%x error\n",
2103				new_bank, data->bank, reg);
2104			res = 0x0;	/* read 0x0 from the chip */
2105			goto END;
2106		}
2107	}
2108	res = i2c_smbus_read_byte_data(client, reg & 0xff);
2109END:
2110	return res;
2111}
2112
2113/* Must be called with data->update_lock held, except during initialization */
2114static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value)
2115{
2116	struct w83793_data *data = i2c_get_clientdata(client);
2117	int res;
2118	u8 new_bank = reg >> 8;
2119
2120	new_bank |= data->bank & 0xfc;
2121	if (data->bank != new_bank) {
2122		res = i2c_smbus_write_byte_data(client, W83793_REG_BANKSEL,
2123						new_bank);
2124		if (res < 0) {
2125			dev_err(&client->dev,
2126				"set bank to %d failed, fall back "
2127				"to bank %d, write reg 0x%x error\n",
2128				new_bank, data->bank, reg);
2129			goto END;
2130		}
2131		data->bank = new_bank;
2132	}
2133
2134	res = i2c_smbus_write_byte_data(client, reg & 0xff, value);
2135END:
2136	return res;
2137}
2138
2139module_i2c_driver(w83793_driver);
2140
2141MODULE_AUTHOR("Yuan Mu, Sven Anders");
2142MODULE_DESCRIPTION("w83793 driver");
2143MODULE_LICENSE("GPL");