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