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