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