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" }, 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 = 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 .open = watchdog_open, 1455 .release = watchdog_close, 1456 .write = watchdog_write, 1457 .unlocked_ioctl = watchdog_ioctl, 1458 .compat_ioctl = compat_ptr_ioctl, 1459 }; 1460 1461 /* 1462 * Notifier for system down 1463 */ 1464 1465 static int watchdog_notify_sys(struct notifier_block *this, unsigned long code, 1466 void *unused) 1467 { 1468 struct w83793_data *data = NULL; 1469 1470 if (code == SYS_DOWN || code == SYS_HALT) { 1471 1472 /* Disable each registered watchdog */ 1473 mutex_lock(&watchdog_data_mutex); 1474 list_for_each_entry(data, &watchdog_data_list, list) { 1475 if (data->watchdog_miscdev.minor) 1476 watchdog_disable(data); 1477 } 1478 mutex_unlock(&watchdog_data_mutex); 1479 } 1480 1481 return NOTIFY_DONE; 1482 } 1483 1484 /* 1485 * The WDT needs to learn about soft shutdowns in order to 1486 * turn the timebomb registers off. 1487 */ 1488 1489 static struct notifier_block watchdog_notifier = { 1490 .notifier_call = watchdog_notify_sys, 1491 }; 1492 1493 /* 1494 * Init / remove routines 1495 */ 1496 1497 static void w83793_remove(struct i2c_client *client) 1498 { 1499 struct w83793_data *data = i2c_get_clientdata(client); 1500 struct device *dev = &client->dev; 1501 int i, tmp; 1502 1503 /* Unregister the watchdog (if registered) */ 1504 if (data->watchdog_miscdev.minor) { 1505 misc_deregister(&data->watchdog_miscdev); 1506 1507 if (data->watchdog_is_open) { 1508 dev_warn(&client->dev, 1509 "i2c client detached with watchdog open! " 1510 "Stopping watchdog.\n"); 1511 watchdog_disable(data); 1512 } 1513 1514 mutex_lock(&watchdog_data_mutex); 1515 list_del(&data->list); 1516 mutex_unlock(&watchdog_data_mutex); 1517 1518 /* Tell the watchdog code the client is gone */ 1519 mutex_lock(&data->watchdog_lock); 1520 data->client = NULL; 1521 mutex_unlock(&data->watchdog_lock); 1522 } 1523 1524 /* Reset Configuration Register to Disable Watch Dog Registers */ 1525 tmp = w83793_read_value(client, W83793_REG_CONFIG); 1526 w83793_write_value(client, W83793_REG_CONFIG, tmp & ~0x04); 1527 1528 unregister_reboot_notifier(&watchdog_notifier); 1529 1530 hwmon_device_unregister(data->hwmon_dev); 1531 1532 for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++) 1533 device_remove_file(dev, 1534 &w83793_sensor_attr_2[i].dev_attr); 1535 1536 for (i = 0; i < ARRAY_SIZE(sda_single_files); i++) 1537 device_remove_file(dev, &sda_single_files[i].dev_attr); 1538 1539 for (i = 0; i < ARRAY_SIZE(w83793_vid); i++) 1540 device_remove_file(dev, &w83793_vid[i].dev_attr); 1541 device_remove_file(dev, &dev_attr_vrm); 1542 1543 for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++) 1544 device_remove_file(dev, &w83793_left_fan[i].dev_attr); 1545 1546 for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++) 1547 device_remove_file(dev, &w83793_left_pwm[i].dev_attr); 1548 1549 for (i = 0; i < ARRAY_SIZE(w83793_temp); i++) 1550 device_remove_file(dev, &w83793_temp[i].dev_attr); 1551 1552 /* Decrease data reference counter */ 1553 mutex_lock(&watchdog_data_mutex); 1554 kref_put(&data->kref, w83793_release_resources); 1555 mutex_unlock(&watchdog_data_mutex); 1556 } 1557 1558 static int 1559 w83793_detect_subclients(struct i2c_client *client) 1560 { 1561 int i, id; 1562 int address = client->addr; 1563 u8 tmp; 1564 struct i2c_adapter *adapter = client->adapter; 1565 1566 id = i2c_adapter_id(adapter); 1567 if (force_subclients[0] == id && force_subclients[1] == address) { 1568 for (i = 2; i <= 3; i++) { 1569 if (force_subclients[i] < 0x48 1570 || force_subclients[i] > 0x4f) { 1571 dev_err(&client->dev, 1572 "invalid subclient " 1573 "address %d; must be 0x48-0x4f\n", 1574 force_subclients[i]); 1575 return -EINVAL; 1576 } 1577 } 1578 w83793_write_value(client, W83793_REG_I2C_SUBADDR, 1579 (force_subclients[2] & 0x07) | 1580 ((force_subclients[3] & 0x07) << 4)); 1581 } 1582 1583 tmp = w83793_read_value(client, W83793_REG_I2C_SUBADDR); 1584 1585 if (!(tmp & 0x88) && (tmp & 0x7) == ((tmp >> 4) & 0x7)) { 1586 dev_err(&client->dev, 1587 "duplicate addresses 0x%x, use force_subclient\n", 0x48 + (tmp & 0x7)); 1588 return -ENODEV; 1589 } 1590 1591 if (!(tmp & 0x08)) 1592 devm_i2c_new_dummy_device(&client->dev, adapter, 0x48 + (tmp & 0x7)); 1593 1594 if (!(tmp & 0x80)) 1595 devm_i2c_new_dummy_device(&client->dev, adapter, 0x48 + ((tmp >> 4) & 0x7)); 1596 1597 return 0; 1598 } 1599 1600 /* Return 0 if detection is successful, -ENODEV otherwise */ 1601 static int w83793_detect(struct i2c_client *client, 1602 struct i2c_board_info *info) 1603 { 1604 u8 tmp, bank, chip_id; 1605 struct i2c_adapter *adapter = client->adapter; 1606 unsigned short address = client->addr; 1607 1608 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 1609 return -ENODEV; 1610 1611 bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL); 1612 1613 tmp = bank & 0x80 ? 0x5c : 0xa3; 1614 /* Check Winbond vendor ID */ 1615 if (tmp != i2c_smbus_read_byte_data(client, W83793_REG_VENDORID)) { 1616 pr_debug("w83793: Detection failed at check vendor id\n"); 1617 return -ENODEV; 1618 } 1619 1620 /* 1621 * If Winbond chip, address of chip and W83793_REG_I2C_ADDR 1622 * should match 1623 */ 1624 if ((bank & 0x07) == 0 1625 && i2c_smbus_read_byte_data(client, W83793_REG_I2C_ADDR) != 1626 (address << 1)) { 1627 pr_debug("w83793: Detection failed at check i2c addr\n"); 1628 return -ENODEV; 1629 } 1630 1631 /* Determine the chip type now */ 1632 chip_id = i2c_smbus_read_byte_data(client, W83793_REG_CHIPID); 1633 if (chip_id != 0x7b) 1634 return -ENODEV; 1635 1636 strscpy(info->type, "w83793", I2C_NAME_SIZE); 1637 1638 return 0; 1639 } 1640 1641 static int w83793_probe(struct i2c_client *client) 1642 { 1643 struct device *dev = &client->dev; 1644 static const int watchdog_minors[] = { 1645 WATCHDOG_MINOR, 212, 213, 214, 215 1646 }; 1647 struct w83793_data *data; 1648 int i, tmp, val, err; 1649 int files_fan = ARRAY_SIZE(w83793_left_fan) / 7; 1650 int files_pwm = ARRAY_SIZE(w83793_left_pwm) / 5; 1651 int files_temp = ARRAY_SIZE(w83793_temp) / 6; 1652 1653 data = kzalloc(sizeof(struct w83793_data), GFP_KERNEL); 1654 if (!data) { 1655 err = -ENOMEM; 1656 goto exit; 1657 } 1658 1659 i2c_set_clientdata(client, data); 1660 data->bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL); 1661 mutex_init(&data->update_lock); 1662 mutex_init(&data->watchdog_lock); 1663 INIT_LIST_HEAD(&data->list); 1664 kref_init(&data->kref); 1665 1666 /* 1667 * Store client pointer in our data struct for watchdog usage 1668 * (where the client is found through a data ptr instead of the 1669 * otherway around) 1670 */ 1671 data->client = client; 1672 1673 err = w83793_detect_subclients(client); 1674 if (err) 1675 goto free_mem; 1676 1677 /* Initialize the chip */ 1678 w83793_init_client(client); 1679 1680 /* 1681 * Only fan 1-5 has their own input pins, 1682 * Pwm 1-3 has their own pins 1683 */ 1684 data->has_fan = 0x1f; 1685 data->has_pwm = 0x07; 1686 tmp = w83793_read_value(client, W83793_REG_MFC); 1687 val = w83793_read_value(client, W83793_REG_FANIN_CTRL); 1688 1689 /* check the function of pins 49-56 */ 1690 if (tmp & 0x80) { 1691 data->has_vid |= 0x2; /* has VIDB */ 1692 } else { 1693 data->has_pwm |= 0x18; /* pwm 4,5 */ 1694 if (val & 0x01) { /* fan 6 */ 1695 data->has_fan |= 0x20; 1696 data->has_pwm |= 0x20; 1697 } 1698 if (val & 0x02) { /* fan 7 */ 1699 data->has_fan |= 0x40; 1700 data->has_pwm |= 0x40; 1701 } 1702 if (!(tmp & 0x40) && (val & 0x04)) { /* fan 8 */ 1703 data->has_fan |= 0x80; 1704 data->has_pwm |= 0x80; 1705 } 1706 } 1707 1708 /* check the function of pins 37-40 */ 1709 if (!(tmp & 0x29)) 1710 data->has_vid |= 0x1; /* has VIDA */ 1711 if (0x08 == (tmp & 0x0c)) { 1712 if (val & 0x08) /* fan 9 */ 1713 data->has_fan |= 0x100; 1714 if (val & 0x10) /* fan 10 */ 1715 data->has_fan |= 0x200; 1716 } 1717 if (0x20 == (tmp & 0x30)) { 1718 if (val & 0x20) /* fan 11 */ 1719 data->has_fan |= 0x400; 1720 if (val & 0x40) /* fan 12 */ 1721 data->has_fan |= 0x800; 1722 } 1723 1724 if ((tmp & 0x01) && (val & 0x04)) { /* fan 8, second location */ 1725 data->has_fan |= 0x80; 1726 data->has_pwm |= 0x80; 1727 } 1728 1729 tmp = w83793_read_value(client, W83793_REG_FANIN_SEL); 1730 if ((tmp & 0x01) && (val & 0x08)) { /* fan 9, second location */ 1731 data->has_fan |= 0x100; 1732 } 1733 if ((tmp & 0x02) && (val & 0x10)) { /* fan 10, second location */ 1734 data->has_fan |= 0x200; 1735 } 1736 if ((tmp & 0x04) && (val & 0x20)) { /* fan 11, second location */ 1737 data->has_fan |= 0x400; 1738 } 1739 if ((tmp & 0x08) && (val & 0x40)) { /* fan 12, second location */ 1740 data->has_fan |= 0x800; 1741 } 1742 1743 /* check the temp1-6 mode, ignore former AMDSI selected inputs */ 1744 tmp = w83793_read_value(client, W83793_REG_TEMP_MODE[0]); 1745 if (tmp & 0x01) 1746 data->has_temp |= 0x01; 1747 if (tmp & 0x04) 1748 data->has_temp |= 0x02; 1749 if (tmp & 0x10) 1750 data->has_temp |= 0x04; 1751 if (tmp & 0x40) 1752 data->has_temp |= 0x08; 1753 1754 tmp = w83793_read_value(client, W83793_REG_TEMP_MODE[1]); 1755 if (tmp & 0x01) 1756 data->has_temp |= 0x10; 1757 if (tmp & 0x02) 1758 data->has_temp |= 0x20; 1759 1760 /* Register sysfs hooks */ 1761 for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++) { 1762 err = device_create_file(dev, 1763 &w83793_sensor_attr_2[i].dev_attr); 1764 if (err) 1765 goto exit_remove; 1766 } 1767 1768 for (i = 0; i < ARRAY_SIZE(w83793_vid); i++) { 1769 if (!(data->has_vid & (1 << i))) 1770 continue; 1771 err = device_create_file(dev, &w83793_vid[i].dev_attr); 1772 if (err) 1773 goto exit_remove; 1774 } 1775 if (data->has_vid) { 1776 data->vrm = vid_which_vrm(); 1777 err = device_create_file(dev, &dev_attr_vrm); 1778 if (err) 1779 goto exit_remove; 1780 } 1781 1782 for (i = 0; i < ARRAY_SIZE(sda_single_files); i++) { 1783 err = device_create_file(dev, &sda_single_files[i].dev_attr); 1784 if (err) 1785 goto exit_remove; 1786 1787 } 1788 1789 for (i = 0; i < 6; i++) { 1790 int j; 1791 if (!(data->has_temp & (1 << i))) 1792 continue; 1793 for (j = 0; j < files_temp; j++) { 1794 err = device_create_file(dev, 1795 &w83793_temp[(i) * files_temp 1796 + j].dev_attr); 1797 if (err) 1798 goto exit_remove; 1799 } 1800 } 1801 1802 for (i = 5; i < 12; i++) { 1803 int j; 1804 if (!(data->has_fan & (1 << i))) 1805 continue; 1806 for (j = 0; j < files_fan; j++) { 1807 err = device_create_file(dev, 1808 &w83793_left_fan[(i - 5) * files_fan 1809 + j].dev_attr); 1810 if (err) 1811 goto exit_remove; 1812 } 1813 } 1814 1815 for (i = 3; i < 8; i++) { 1816 int j; 1817 if (!(data->has_pwm & (1 << i))) 1818 continue; 1819 for (j = 0; j < files_pwm; j++) { 1820 err = device_create_file(dev, 1821 &w83793_left_pwm[(i - 3) * files_pwm 1822 + j].dev_attr); 1823 if (err) 1824 goto exit_remove; 1825 } 1826 } 1827 1828 data->hwmon_dev = hwmon_device_register(dev); 1829 if (IS_ERR(data->hwmon_dev)) { 1830 err = PTR_ERR(data->hwmon_dev); 1831 goto exit_remove; 1832 } 1833 1834 /* Watchdog initialization */ 1835 1836 /* Register boot notifier */ 1837 err = register_reboot_notifier(&watchdog_notifier); 1838 if (err != 0) { 1839 dev_err(&client->dev, 1840 "cannot register reboot notifier (err=%d)\n", err); 1841 goto exit_devunreg; 1842 } 1843 1844 /* 1845 * Enable Watchdog registers. 1846 * Set Configuration Register to Enable Watch Dog Registers 1847 * (Bit 2) = XXXX, X1XX. 1848 */ 1849 tmp = w83793_read_value(client, W83793_REG_CONFIG); 1850 w83793_write_value(client, W83793_REG_CONFIG, tmp | 0x04); 1851 1852 /* Set the default watchdog timeout */ 1853 data->watchdog_timeout = timeout; 1854 1855 /* Check, if last reboot was caused by watchdog */ 1856 data->watchdog_caused_reboot = 1857 w83793_read_value(data->client, W83793_REG_WDT_STATUS) & 0x01; 1858 1859 /* Disable Soft Watchdog during initialiation */ 1860 watchdog_disable(data); 1861 1862 /* 1863 * We take the data_mutex lock early so that watchdog_open() cannot 1864 * run when misc_register() has completed, but we've not yet added 1865 * our data to the watchdog_data_list (and set the default timeout) 1866 */ 1867 mutex_lock(&watchdog_data_mutex); 1868 for (i = 0; i < ARRAY_SIZE(watchdog_minors); i++) { 1869 /* Register our watchdog part */ 1870 snprintf(data->watchdog_name, sizeof(data->watchdog_name), 1871 "watchdog%c", (i == 0) ? '\0' : ('0' + i)); 1872 data->watchdog_miscdev.name = data->watchdog_name; 1873 data->watchdog_miscdev.fops = &watchdog_fops; 1874 data->watchdog_miscdev.minor = watchdog_minors[i]; 1875 1876 err = misc_register(&data->watchdog_miscdev); 1877 if (err == -EBUSY) 1878 continue; 1879 if (err) { 1880 data->watchdog_miscdev.minor = 0; 1881 dev_err(&client->dev, 1882 "Registering watchdog chardev: %d\n", err); 1883 break; 1884 } 1885 1886 list_add(&data->list, &watchdog_data_list); 1887 1888 dev_info(&client->dev, 1889 "Registered watchdog chardev major 10, minor: %d\n", 1890 watchdog_minors[i]); 1891 break; 1892 } 1893 if (i == ARRAY_SIZE(watchdog_minors)) { 1894 data->watchdog_miscdev.minor = 0; 1895 dev_warn(&client->dev, 1896 "Couldn't register watchdog chardev (due to no free minor)\n"); 1897 } 1898 1899 mutex_unlock(&watchdog_data_mutex); 1900 1901 return 0; 1902 1903 /* Unregister hwmon device */ 1904 1905 exit_devunreg: 1906 1907 hwmon_device_unregister(data->hwmon_dev); 1908 1909 /* Unregister sysfs hooks */ 1910 1911 exit_remove: 1912 for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++) 1913 device_remove_file(dev, &w83793_sensor_attr_2[i].dev_attr); 1914 1915 for (i = 0; i < ARRAY_SIZE(sda_single_files); i++) 1916 device_remove_file(dev, &sda_single_files[i].dev_attr); 1917 1918 for (i = 0; i < ARRAY_SIZE(w83793_vid); i++) 1919 device_remove_file(dev, &w83793_vid[i].dev_attr); 1920 1921 for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++) 1922 device_remove_file(dev, &w83793_left_fan[i].dev_attr); 1923 1924 for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++) 1925 device_remove_file(dev, &w83793_left_pwm[i].dev_attr); 1926 1927 for (i = 0; i < ARRAY_SIZE(w83793_temp); i++) 1928 device_remove_file(dev, &w83793_temp[i].dev_attr); 1929 free_mem: 1930 kfree(data); 1931 exit: 1932 return err; 1933 } 1934 1935 static void w83793_update_nonvolatile(struct device *dev) 1936 { 1937 struct i2c_client *client = to_i2c_client(dev); 1938 struct w83793_data *data = i2c_get_clientdata(client); 1939 int i, j; 1940 /* 1941 * They are somewhat "stable" registers, and to update them every time 1942 * takes so much time, it's just not worthy. Update them in a long 1943 * interval to avoid exception. 1944 */ 1945 if (!(time_after(jiffies, data->last_nonvolatile + HZ * 300) 1946 || !data->valid)) 1947 return; 1948 /* update voltage limits */ 1949 for (i = 1; i < 3; i++) { 1950 for (j = 0; j < ARRAY_SIZE(data->in); j++) { 1951 data->in[j][i] = 1952 w83793_read_value(client, W83793_REG_IN[j][i]); 1953 } 1954 data->in_low_bits[i] = 1955 w83793_read_value(client, W83793_REG_IN_LOW_BITS[i]); 1956 } 1957 1958 for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) { 1959 /* Update the Fan measured value and limits */ 1960 if (!(data->has_fan & (1 << i))) 1961 continue; 1962 data->fan_min[i] = 1963 w83793_read_value(client, W83793_REG_FAN_MIN(i)) << 8; 1964 data->fan_min[i] |= 1965 w83793_read_value(client, W83793_REG_FAN_MIN(i) + 1); 1966 } 1967 1968 for (i = 0; i < ARRAY_SIZE(data->temp_fan_map); i++) { 1969 if (!(data->has_temp & (1 << i))) 1970 continue; 1971 data->temp_fan_map[i] = 1972 w83793_read_value(client, W83793_REG_TEMP_FAN_MAP(i)); 1973 for (j = 1; j < 5; j++) { 1974 data->temp[i][j] = 1975 w83793_read_value(client, W83793_REG_TEMP[i][j]); 1976 } 1977 data->temp_cruise[i] = 1978 w83793_read_value(client, W83793_REG_TEMP_CRUISE(i)); 1979 for (j = 0; j < 7; j++) { 1980 data->sf2_pwm[i][j] = 1981 w83793_read_value(client, W83793_REG_SF2_PWM(i, j)); 1982 data->sf2_temp[i][j] = 1983 w83793_read_value(client, 1984 W83793_REG_SF2_TEMP(i, j)); 1985 } 1986 } 1987 1988 for (i = 0; i < ARRAY_SIZE(data->temp_mode); i++) 1989 data->temp_mode[i] = 1990 w83793_read_value(client, W83793_REG_TEMP_MODE[i]); 1991 1992 for (i = 0; i < ARRAY_SIZE(data->tolerance); i++) { 1993 data->tolerance[i] = 1994 w83793_read_value(client, W83793_REG_TEMP_TOL(i)); 1995 } 1996 1997 for (i = 0; i < ARRAY_SIZE(data->pwm); i++) { 1998 if (!(data->has_pwm & (1 << i))) 1999 continue; 2000 data->pwm[i][PWM_NONSTOP] = 2001 w83793_read_value(client, W83793_REG_PWM(i, PWM_NONSTOP)); 2002 data->pwm[i][PWM_START] = 2003 w83793_read_value(client, W83793_REG_PWM(i, PWM_START)); 2004 data->pwm_stop_time[i] = 2005 w83793_read_value(client, W83793_REG_PWM_STOP_TIME(i)); 2006 } 2007 2008 data->pwm_default = w83793_read_value(client, W83793_REG_PWM_DEFAULT); 2009 data->pwm_enable = w83793_read_value(client, W83793_REG_PWM_ENABLE); 2010 data->pwm_uptime = w83793_read_value(client, W83793_REG_PWM_UPTIME); 2011 data->pwm_downtime = w83793_read_value(client, W83793_REG_PWM_DOWNTIME); 2012 data->temp_critical = 2013 w83793_read_value(client, W83793_REG_TEMP_CRITICAL); 2014 data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP); 2015 2016 for (i = 0; i < ARRAY_SIZE(data->beeps); i++) 2017 data->beeps[i] = w83793_read_value(client, W83793_REG_BEEP(i)); 2018 2019 data->last_nonvolatile = jiffies; 2020 } 2021 2022 static struct w83793_data *w83793_update_device(struct device *dev) 2023 { 2024 struct i2c_client *client = to_i2c_client(dev); 2025 struct w83793_data *data = i2c_get_clientdata(client); 2026 int i; 2027 2028 mutex_lock(&data->update_lock); 2029 2030 if (!(time_after(jiffies, data->last_updated + HZ * 2) 2031 || !data->valid)) 2032 goto END; 2033 2034 /* Update the voltages measured value and limits */ 2035 for (i = 0; i < ARRAY_SIZE(data->in); i++) 2036 data->in[i][IN_READ] = 2037 w83793_read_value(client, W83793_REG_IN[i][IN_READ]); 2038 2039 data->in_low_bits[IN_READ] = 2040 w83793_read_value(client, W83793_REG_IN_LOW_BITS[IN_READ]); 2041 2042 for (i = 0; i < ARRAY_SIZE(data->fan); i++) { 2043 if (!(data->has_fan & (1 << i))) 2044 continue; 2045 data->fan[i] = 2046 w83793_read_value(client, W83793_REG_FAN(i)) << 8; 2047 data->fan[i] |= 2048 w83793_read_value(client, W83793_REG_FAN(i) + 1); 2049 } 2050 2051 for (i = 0; i < ARRAY_SIZE(data->temp); i++) { 2052 if (!(data->has_temp & (1 << i))) 2053 continue; 2054 data->temp[i][TEMP_READ] = 2055 w83793_read_value(client, W83793_REG_TEMP[i][TEMP_READ]); 2056 } 2057 2058 data->temp_low_bits = 2059 w83793_read_value(client, W83793_REG_TEMP_LOW_BITS); 2060 2061 for (i = 0; i < ARRAY_SIZE(data->pwm); i++) { 2062 if (data->has_pwm & (1 << i)) 2063 data->pwm[i][PWM_DUTY] = 2064 w83793_read_value(client, 2065 W83793_REG_PWM(i, PWM_DUTY)); 2066 } 2067 2068 for (i = 0; i < ARRAY_SIZE(data->alarms); i++) 2069 data->alarms[i] = 2070 w83793_read_value(client, W83793_REG_ALARM(i)); 2071 if (data->has_vid & 0x01) 2072 data->vid[0] = w83793_read_value(client, W83793_REG_VID_INA); 2073 if (data->has_vid & 0x02) 2074 data->vid[1] = w83793_read_value(client, W83793_REG_VID_INB); 2075 w83793_update_nonvolatile(dev); 2076 data->last_updated = jiffies; 2077 data->valid = true; 2078 2079 END: 2080 mutex_unlock(&data->update_lock); 2081 return data; 2082 } 2083 2084 /* 2085 * Ignore the possibility that somebody change bank outside the driver 2086 * Must be called with data->update_lock held, except during initialization 2087 */ 2088 static u8 w83793_read_value(struct i2c_client *client, u16 reg) 2089 { 2090 struct w83793_data *data = i2c_get_clientdata(client); 2091 u8 res; 2092 u8 new_bank = reg >> 8; 2093 2094 new_bank |= data->bank & 0xfc; 2095 if (data->bank != new_bank) { 2096 if (i2c_smbus_write_byte_data 2097 (client, W83793_REG_BANKSEL, new_bank) >= 0) 2098 data->bank = new_bank; 2099 else { 2100 dev_err(&client->dev, 2101 "set bank to %d failed, fall back " 2102 "to bank %d, read reg 0x%x error\n", 2103 new_bank, data->bank, reg); 2104 res = 0x0; /* read 0x0 from the chip */ 2105 goto END; 2106 } 2107 } 2108 res = i2c_smbus_read_byte_data(client, reg & 0xff); 2109 END: 2110 return res; 2111 } 2112 2113 /* Must be called with data->update_lock held, except during initialization */ 2114 static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value) 2115 { 2116 struct w83793_data *data = i2c_get_clientdata(client); 2117 int res; 2118 u8 new_bank = reg >> 8; 2119 2120 new_bank |= data->bank & 0xfc; 2121 if (data->bank != new_bank) { 2122 res = i2c_smbus_write_byte_data(client, W83793_REG_BANKSEL, 2123 new_bank); 2124 if (res < 0) { 2125 dev_err(&client->dev, 2126 "set bank to %d failed, fall back " 2127 "to bank %d, write reg 0x%x error\n", 2128 new_bank, data->bank, reg); 2129 goto END; 2130 } 2131 data->bank = new_bank; 2132 } 2133 2134 res = i2c_smbus_write_byte_data(client, reg & 0xff, value); 2135 END: 2136 return res; 2137 } 2138 2139 module_i2c_driver(w83793_driver); 2140 2141 MODULE_AUTHOR("Yuan Mu, Sven Anders"); 2142 MODULE_DESCRIPTION("w83793 driver"); 2143 MODULE_LICENSE("GPL"); 2144