2144 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * w83793.c - Linux kernel driver for hardware monitoring4 * Copyright (C) 2006 Winbond Electronics Corp.5 * Yuan Mu6 * Rudolf Marek <r.marek@assembler.cz>7 * Copyright (C) 2009-2010 Sven Anders <anders@anduras.de>, ANDURAS AG.8 * Watchdog driver part9 * (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 ISA17 * w83793 10 12 8 6 0x7b 0x5ca3 yes no18 */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 reserved70 * as ID, Bank Select registers71 */72#define W83793_REG_BANKSEL 0x0073#define W83793_REG_VENDORID 0x0d74#define W83793_REG_CHIPID 0x0e75#define W83793_REG_DEVICEID 0x0f76 77#define W83793_REG_CONFIG 0x4078#define W83793_REG_MFC 0x5879#define W83793_REG_FANIN_CTRL 0x5c80#define W83793_REG_FANIN_SEL 0x5d81#define W83793_REG_I2C_ADDR 0x0b82#define W83793_REG_I2C_SUBADDR 0x0c83#define W83793_REG_VID_INA 0x0584#define W83793_REG_VID_INB 0x0685#define W83793_REG_VID_LATCHA 0x0786#define W83793_REG_VID_LATCHB 0x0887#define W83793_REG_VID_CTRL 0x5988 89#define W83793_REG_WDT_LOCK 0x0190#define W83793_REG_WDT_ENABLE 0x0291#define W83793_REG_WDT_STATUS 0x0392#define W83793_REG_WDT_TIMEOUT 0x0493 94static u16 W83793_REG_TEMP_MODE[2] = { 0x5e, 0x5f };95 96#define TEMP_READ 097#define TEMP_CRIT 198#define TEMP_CRIT_HYST 299#define TEMP_WARN 3100#define TEMP_WARN_HYST 4101/*102 * only crit and crit_hyst affect real-time alarm status103 * current crit crit_hyst warn warn_hyst104 */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 0x22115 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 0x50121#define W83793_REG_OVT_CTRL 0x51122#define W83793_REG_OVT_BEEP 0x52123 124#define IN_READ 0125#define IN_MAX 1126#define IN_LOW 2127static 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 0xb2150#define W83793_REG_PWM_ENABLE 0x207151#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 0xc5154 155#define PWM_DUTY 0156#define PWM_START 1157#define PWM_NONSTOP 2158#define PWM_STOP_TIME 3159#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 the210 * nonvolatile registers211 */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 bits226 * byte 1: Temp R1,R2 mode, each has 1 bit227 */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 that264 * we can find our device data as when using misc_register. There is no265 * other method to get to one's device data from the open file-op and266 * 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* all275 * references to our watchdog device are released276 */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_t312vrm_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_t319show_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_t330vrm_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 0349#define BEEP_ENABLE 1350static ssize_t351show_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_t371store_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_t402show_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_t409store_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_t436store_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 0461#define FAN_MIN 1462static ssize_t463show_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 else475 val = data->fan_min[index] & 0x0fff;476 477 return sprintf(buf, "%lu\n", FAN_FROM_REG(val));478}479 480static ssize_t481store_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_t508show_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 else520 val = (data->pwm[index][nr] & 0x3f) << 2;521 522 return sprintf(buf, "%d\n", val);523}524 525static ssize_t526store_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_t562show_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_t579store_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-TD4605 * each has 4 mode:(2 bits)606 * 0: Stop monitor607 * 1: Use internal temp sensor(default)608 * 2: Reserved609 * 3: Use sensor in Intel CPU and get result by PECI610 *611 * TR1-TR2612 * each has 2 mode:(1 bit)613 * 0: Disable temp sensor monitor614 * 1: To enable temp sensors monitor615 */616 617/* 0 disable, 6 PECI */618static u8 TO_TEMP_MODE[] = { 0, 0, 0, 6 };619 620static ssize_t621show_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 else638 tmp = TO_TEMP_MODE[tmp];639 640 return sprintf(buf, "%d\n", tmp);641}642 643static ssize_t644store_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 0686#define SETUP_PWM_UPTIME 1 /* Unit in 0.1s */687#define SETUP_PWM_DOWNTIME 2 /* Unit in 0.1s */688#define SETUP_TEMP_CRITICAL 3689static ssize_t690show_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_t711store_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 control757 * TEMP_FAN_MAP758 * Temp channel control which pwm fan, bitfield, bit 0 indicate pwm1...759 * It's possible two or more temp channels control the same fan, w83793760 * always prefers to pick the most critical request and applies it to761 * the related Fan.762 * It's possible one fan is not in any mapping of 6 temp channels, this763 * means the fan is manual mode764 *765 * TEMP_PWM_ENABLE766 * Each temp channel has its own SmartFan mode, and temp channel767 * control fans that are set by TEMP_FAN_MAP768 * 0: SmartFanII mode769 * 1: Thermal Cruise Mode770 *771 * TEMP_CRUISE772 * Target temperature in thermal cruise mode, w83793 will try to turn773 * fan speed to keep the temperature of target device around this774 * temperature.775 *776 * TEMP_TOLERANCE777 * If Temp higher or lower than target with this tolerance, w83793778 * will take actions to speed up or slow down the fan to keep the779 * temperature within the tolerance range.780 */781 782#define TEMP_FAN_MAP 0783#define TEMP_PWM_ENABLE 1784#define TEMP_CRUISE 2785#define TEMP_TOLERANCE 3786static ssize_t787show_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_t811store_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 else839 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_t871show_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_t883store_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_t911show_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_t924store_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_t953show_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_t972store_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 -11013 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 routines1186 */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 we1294 * call misc_register() from w83793_probe() with watchdog_data_mutex1295 * hold, as misc_register() takes the misc_mtx lock, this is a possible1296 * 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 this1313 */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 else1443 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 down1463 */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 to1486 * 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 routines1495 */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 int1559w83793_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] < 0x481570 || 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_ADDR1622 * should match1623 */1624 if ((bank & 0x07) == 01625 && 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, 2151646 };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 usage1668 * (where the client is found through a data ptr instead of the1669 * 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 pins1683 */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_temp1796 + 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_fan1809 + 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_pwm1822 + 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 Registers1847 * (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() cannot1864 * run when misc_register() has completed, but we've not yet added1865 * 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 time1942 * takes so much time, it's just not worthy. Update them in a long1943 * 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 driver2086 * Must be called with data->update_lock held, except during initialization2087 */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_data2097 (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");2144