1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * vt8231.c - Part of lm_sensors, Linux kernel modules 4 * for hardware monitoring 5 * 6 * Copyright (c) 2005 Roger Lucas <vt8231@hiddenengine.co.uk> 7 * Copyright (c) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com> 8 * Aaron M. Marsh <amarsh@sdf.lonestar.org> 9 */ 10 11 /* 12 * Supports VIA VT8231 South Bridge embedded sensors 13 */ 14 15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 16 17 #include <linux/module.h> 18 #include <linux/init.h> 19 #include <linux/slab.h> 20 #include <linux/pci.h> 21 #include <linux/jiffies.h> 22 #include <linux/platform_device.h> 23 #include <linux/hwmon.h> 24 #include <linux/hwmon-sysfs.h> 25 #include <linux/hwmon-vid.h> 26 #include <linux/err.h> 27 #include <linux/mutex.h> 28 #include <linux/acpi.h> 29 #include <linux/io.h> 30 31 static int force_addr; 32 module_param(force_addr, int, 0); 33 MODULE_PARM_DESC(force_addr, "Initialize the base address of the sensors"); 34 35 static struct platform_device *pdev; 36 37 #define VT8231_EXTENT 0x80 38 #define VT8231_BASE_REG 0x70 39 #define VT8231_ENABLE_REG 0x74 40 41 #define DRIVER_NAME "vt8231" 42 43 /* 44 * The VT8231 registers 45 * 46 * The reset value for the input channel configuration is used (Reg 0x4A=0x07) 47 * which sets the selected inputs marked with '*' below if multiple options are 48 * possible: 49 * 50 * Voltage Mode Temperature Mode 51 * Sensor Linux Id Linux Id VIA Id 52 * -------- -------- -------- ------ 53 * CPU Diode N/A temp1 0 54 * UIC1 in0 temp2 * 1 55 * UIC2 in1 * temp3 2 56 * UIC3 in2 * temp4 3 57 * UIC4 in3 * temp5 4 58 * UIC5 in4 * temp6 5 59 * 3.3V in5 N/A 60 * 61 * Note that the BIOS may set the configuration register to a different value 62 * to match the motherboard configuration. 63 */ 64 65 /* fans numbered 0-1 */ 66 #define VT8231_REG_FAN_MIN(nr) (0x3b + (nr)) 67 #define VT8231_REG_FAN(nr) (0x29 + (nr)) 68 69 /* Voltage inputs numbered 0-5 */ 70 71 static const u8 regvolt[] = { 0x21, 0x22, 0x23, 0x24, 0x25, 0x26 }; 72 static const u8 regvoltmax[] = { 0x3d, 0x2b, 0x2d, 0x2f, 0x31, 0x33 }; 73 static const u8 regvoltmin[] = { 0x3e, 0x2c, 0x2e, 0x30, 0x32, 0x34 }; 74 75 /* 76 * Temperatures are numbered 1-6 according to the Linux kernel specification. 77 * 78 * In the VIA datasheet, however, the temperatures are numbered from zero. 79 * Since it is important that this driver can easily be compared to the VIA 80 * datasheet, we will use the VIA numbering within this driver and map the 81 * kernel sysfs device name to the VIA number in the sysfs callback. 82 */ 83 84 #define VT8231_REG_TEMP_LOW01 0x49 85 #define VT8231_REG_TEMP_LOW25 0x4d 86 87 static const u8 regtemp[] = { 0x1f, 0x21, 0x22, 0x23, 0x24, 0x25 }; 88 static const u8 regtempmax[] = { 0x39, 0x3d, 0x2b, 0x2d, 0x2f, 0x31 }; 89 static const u8 regtempmin[] = { 0x3a, 0x3e, 0x2c, 0x2e, 0x30, 0x32 }; 90 91 #define TEMP_FROM_REG(reg) (((253 * 4 - (reg)) * 550 + 105) / 210) 92 #define TEMP_MAXMIN_FROM_REG(reg) (((253 - (reg)) * 2200 + 105) / 210) 93 #define TEMP_MAXMIN_TO_REG(val) (253 - ((val) * 210 + 1100) / 2200) 94 95 #define VT8231_REG_CONFIG 0x40 96 #define VT8231_REG_ALARM1 0x41 97 #define VT8231_REG_ALARM2 0x42 98 #define VT8231_REG_FANDIV 0x47 99 #define VT8231_REG_UCH_CONFIG 0x4a 100 #define VT8231_REG_TEMP1_CONFIG 0x4b 101 #define VT8231_REG_TEMP2_CONFIG 0x4c 102 103 /* 104 * temps 0-5 as numbered in VIA datasheet - see later for mapping to Linux 105 * numbering 106 */ 107 #define ISTEMP(i, ch_config) ((i) == 0 ? 1 : \ 108 ((ch_config) >> ((i)+1)) & 0x01) 109 /* voltages 0-5 */ 110 #define ISVOLT(i, ch_config) ((i) == 5 ? 1 : \ 111 !(((ch_config) >> ((i)+2)) & 0x01)) 112 113 #define DIV_FROM_REG(val) (1 << (val)) 114 115 /* 116 * NB The values returned here are NOT temperatures. The calibration curves 117 * for the thermistor curves are board-specific and must go in the 118 * sensors.conf file. Temperature sensors are actually ten bits, but the 119 * VIA datasheet only considers the 8 MSBs obtained from the regtemp[] 120 * register. The temperature value returned should have a magnitude of 3, 121 * so we use the VIA scaling as the "true" scaling and use the remaining 2 122 * LSBs as fractional precision. 123 * 124 * All the on-chip hardware temperature comparisons for the alarms are only 125 * 8-bits wide, and compare against the 8 MSBs of the temperature. The bits 126 * in the registers VT8231_REG_TEMP_LOW01 and VT8231_REG_TEMP_LOW25 are 127 * ignored. 128 */ 129 130 /* 131 ****** FAN RPM CONVERSIONS ******** 132 * This chip saturates back at 0, not at 255 like many the other chips. 133 * So, 0 means 0 RPM 134 */ 135 static inline u8 FAN_TO_REG(long rpm, int div) 136 { 137 if (rpm <= 0 || rpm > 1310720) 138 return 0; 139 return clamp_val(1310720 / (rpm * div), 1, 255); 140 } 141 142 #define FAN_FROM_REG(val, div) ((val) == 0 ? 0 : 1310720 / ((val) * (div))) 143 144 struct vt8231_data { 145 unsigned short addr; 146 const char *name; 147 148 struct mutex update_lock; 149 struct device *hwmon_dev; 150 bool valid; /* true if following fields are valid */ 151 unsigned long last_updated; /* In jiffies */ 152 153 u8 in[6]; /* Register value */ 154 u8 in_max[6]; /* Register value */ 155 u8 in_min[6]; /* Register value */ 156 u16 temp[6]; /* Register value 10 bit, right aligned */ 157 u8 temp_max[6]; /* Register value */ 158 u8 temp_min[6]; /* Register value */ 159 u8 fan[2]; /* Register value */ 160 u8 fan_min[2]; /* Register value */ 161 u8 fan_div[2]; /* Register encoding, shifted right */ 162 u16 alarms; /* Register encoding */ 163 u8 uch_config; 164 }; 165 166 static struct pci_dev *s_bridge; 167 168 static inline int vt8231_read_value(struct vt8231_data *data, u8 reg) 169 { 170 return inb_p(data->addr + reg); 171 } 172 173 static inline void vt8231_write_value(struct vt8231_data *data, u8 reg, 174 u8 value) 175 { 176 outb_p(value, data->addr + reg); 177 } 178 179 static struct vt8231_data *vt8231_update_device(struct device *dev) 180 { 181 struct vt8231_data *data = dev_get_drvdata(dev); 182 int i; 183 u16 low; 184 185 mutex_lock(&data->update_lock); 186 187 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) 188 || !data->valid) { 189 for (i = 0; i < 6; i++) { 190 if (ISVOLT(i, data->uch_config)) { 191 data->in[i] = vt8231_read_value(data, 192 regvolt[i]); 193 data->in_min[i] = vt8231_read_value(data, 194 regvoltmin[i]); 195 data->in_max[i] = vt8231_read_value(data, 196 regvoltmax[i]); 197 } 198 } 199 for (i = 0; i < 2; i++) { 200 data->fan[i] = vt8231_read_value(data, 201 VT8231_REG_FAN(i)); 202 data->fan_min[i] = vt8231_read_value(data, 203 VT8231_REG_FAN_MIN(i)); 204 } 205 206 low = vt8231_read_value(data, VT8231_REG_TEMP_LOW01); 207 low = (low >> 6) | ((low & 0x30) >> 2) 208 | (vt8231_read_value(data, VT8231_REG_TEMP_LOW25) << 4); 209 for (i = 0; i < 6; i++) { 210 if (ISTEMP(i, data->uch_config)) { 211 data->temp[i] = (vt8231_read_value(data, 212 regtemp[i]) << 2) 213 | ((low >> (2 * i)) & 0x03); 214 data->temp_max[i] = vt8231_read_value(data, 215 regtempmax[i]); 216 data->temp_min[i] = vt8231_read_value(data, 217 regtempmin[i]); 218 } 219 } 220 221 i = vt8231_read_value(data, VT8231_REG_FANDIV); 222 data->fan_div[0] = (i >> 4) & 0x03; 223 data->fan_div[1] = i >> 6; 224 data->alarms = vt8231_read_value(data, VT8231_REG_ALARM1) | 225 (vt8231_read_value(data, VT8231_REG_ALARM2) << 8); 226 227 /* Set alarm flags correctly */ 228 if (!data->fan[0] && data->fan_min[0]) 229 data->alarms |= 0x40; 230 else if (data->fan[0] && !data->fan_min[0]) 231 data->alarms &= ~0x40; 232 233 if (!data->fan[1] && data->fan_min[1]) 234 data->alarms |= 0x80; 235 else if (data->fan[1] && !data->fan_min[1]) 236 data->alarms &= ~0x80; 237 238 data->last_updated = jiffies; 239 data->valid = true; 240 } 241 242 mutex_unlock(&data->update_lock); 243 244 return data; 245 } 246 247 /* following are the sysfs callback functions */ 248 static ssize_t in_show(struct device *dev, struct device_attribute *attr, 249 char *buf) 250 { 251 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 252 int nr = sensor_attr->index; 253 struct vt8231_data *data = vt8231_update_device(dev); 254 255 return sprintf(buf, "%d\n", ((data->in[nr] - 3) * 10000) / 958); 256 } 257 258 static ssize_t in_min_show(struct device *dev, struct device_attribute *attr, 259 char *buf) 260 { 261 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 262 int nr = sensor_attr->index; 263 struct vt8231_data *data = vt8231_update_device(dev); 264 265 return sprintf(buf, "%d\n", ((data->in_min[nr] - 3) * 10000) / 958); 266 } 267 268 static ssize_t in_max_show(struct device *dev, struct device_attribute *attr, 269 char *buf) 270 { 271 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 272 int nr = sensor_attr->index; 273 struct vt8231_data *data = vt8231_update_device(dev); 274 275 return sprintf(buf, "%d\n", (((data->in_max[nr] - 3) * 10000) / 958)); 276 } 277 278 static ssize_t in_min_store(struct device *dev, struct device_attribute *attr, 279 const char *buf, size_t count) 280 { 281 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 282 int nr = sensor_attr->index; 283 struct vt8231_data *data = dev_get_drvdata(dev); 284 unsigned long val; 285 int err; 286 287 err = kstrtoul(buf, 10, &val); 288 if (err) 289 return err; 290 291 mutex_lock(&data->update_lock); 292 data->in_min[nr] = clamp_val(((val * 958) / 10000) + 3, 0, 255); 293 vt8231_write_value(data, regvoltmin[nr], data->in_min[nr]); 294 mutex_unlock(&data->update_lock); 295 return count; 296 } 297 298 static ssize_t in_max_store(struct device *dev, struct device_attribute *attr, 299 const char *buf, size_t count) 300 { 301 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 302 int nr = sensor_attr->index; 303 struct vt8231_data *data = dev_get_drvdata(dev); 304 unsigned long val; 305 int err; 306 307 err = kstrtoul(buf, 10, &val); 308 if (err) 309 return err; 310 311 mutex_lock(&data->update_lock); 312 data->in_max[nr] = clamp_val(((val * 958) / 10000) + 3, 0, 255); 313 vt8231_write_value(data, regvoltmax[nr], data->in_max[nr]); 314 mutex_unlock(&data->update_lock); 315 return count; 316 } 317 318 /* Special case for input 5 as this has 3.3V scaling built into the chip */ 319 static ssize_t in5_input_show(struct device *dev, 320 struct device_attribute *attr, char *buf) 321 { 322 struct vt8231_data *data = vt8231_update_device(dev); 323 324 return sprintf(buf, "%d\n", 325 (((data->in[5] - 3) * 10000 * 54) / (958 * 34))); 326 } 327 328 static ssize_t in5_min_show(struct device *dev, struct device_attribute *attr, 329 char *buf) 330 { 331 struct vt8231_data *data = vt8231_update_device(dev); 332 333 return sprintf(buf, "%d\n", 334 (((data->in_min[5] - 3) * 10000 * 54) / (958 * 34))); 335 } 336 337 static ssize_t in5_max_show(struct device *dev, struct device_attribute *attr, 338 char *buf) 339 { 340 struct vt8231_data *data = vt8231_update_device(dev); 341 342 return sprintf(buf, "%d\n", 343 (((data->in_max[5] - 3) * 10000 * 54) / (958 * 34))); 344 } 345 346 static ssize_t in5_min_store(struct device *dev, 347 struct device_attribute *attr, const char *buf, 348 size_t count) 349 { 350 struct vt8231_data *data = dev_get_drvdata(dev); 351 unsigned long val; 352 int err; 353 354 err = kstrtoul(buf, 10, &val); 355 if (err) 356 return err; 357 358 mutex_lock(&data->update_lock); 359 data->in_min[5] = clamp_val(((val * 958 * 34) / (10000 * 54)) + 3, 360 0, 255); 361 vt8231_write_value(data, regvoltmin[5], data->in_min[5]); 362 mutex_unlock(&data->update_lock); 363 return count; 364 } 365 366 static ssize_t in5_max_store(struct device *dev, 367 struct device_attribute *attr, const char *buf, 368 size_t count) 369 { 370 struct vt8231_data *data = dev_get_drvdata(dev); 371 unsigned long val; 372 int err; 373 374 err = kstrtoul(buf, 10, &val); 375 if (err) 376 return err; 377 378 mutex_lock(&data->update_lock); 379 data->in_max[5] = clamp_val(((val * 958 * 34) / (10000 * 54)) + 3, 380 0, 255); 381 vt8231_write_value(data, regvoltmax[5], data->in_max[5]); 382 mutex_unlock(&data->update_lock); 383 return count; 384 } 385 386 static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0); 387 static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0); 388 static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0); 389 static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1); 390 static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1); 391 static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1); 392 static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2); 393 static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2); 394 static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2); 395 static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3); 396 static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3); 397 static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3); 398 static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4); 399 static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4); 400 static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4); 401 402 static DEVICE_ATTR_RO(in5_input); 403 static DEVICE_ATTR_RW(in5_min); 404 static DEVICE_ATTR_RW(in5_max); 405 406 /* Temperatures */ 407 static ssize_t temp1_input_show(struct device *dev, 408 struct device_attribute *attr, char *buf) 409 { 410 struct vt8231_data *data = vt8231_update_device(dev); 411 return sprintf(buf, "%d\n", data->temp[0] * 250); 412 } 413 414 static ssize_t temp1_max_show(struct device *dev, struct device_attribute *attr, 415 char *buf) 416 { 417 struct vt8231_data *data = vt8231_update_device(dev); 418 return sprintf(buf, "%d\n", data->temp_max[0] * 1000); 419 } 420 421 static ssize_t temp1_max_hyst_show(struct device *dev, 422 struct device_attribute *attr, char *buf) 423 { 424 struct vt8231_data *data = vt8231_update_device(dev); 425 return sprintf(buf, "%d\n", data->temp_min[0] * 1000); 426 } 427 428 static ssize_t temp1_max_store(struct device *dev, 429 struct device_attribute *attr, const char *buf, 430 size_t count) 431 { 432 struct vt8231_data *data = dev_get_drvdata(dev); 433 long val; 434 int err; 435 436 err = kstrtol(buf, 10, &val); 437 if (err) 438 return err; 439 440 mutex_lock(&data->update_lock); 441 data->temp_max[0] = clamp_val((val + 500) / 1000, 0, 255); 442 vt8231_write_value(data, regtempmax[0], data->temp_max[0]); 443 mutex_unlock(&data->update_lock); 444 return count; 445 } 446 static ssize_t temp1_max_hyst_store(struct device *dev, 447 struct device_attribute *attr, 448 const char *buf, size_t count) 449 { 450 struct vt8231_data *data = dev_get_drvdata(dev); 451 long val; 452 int err; 453 454 err = kstrtol(buf, 10, &val); 455 if (err) 456 return err; 457 458 mutex_lock(&data->update_lock); 459 data->temp_min[0] = clamp_val((val + 500) / 1000, 0, 255); 460 vt8231_write_value(data, regtempmin[0], data->temp_min[0]); 461 mutex_unlock(&data->update_lock); 462 return count; 463 } 464 465 static ssize_t temp_show(struct device *dev, struct device_attribute *attr, 466 char *buf) 467 { 468 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 469 int nr = sensor_attr->index; 470 struct vt8231_data *data = vt8231_update_device(dev); 471 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr])); 472 } 473 474 static ssize_t temp_max_show(struct device *dev, 475 struct device_attribute *attr, char *buf) 476 { 477 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 478 int nr = sensor_attr->index; 479 struct vt8231_data *data = vt8231_update_device(dev); 480 return sprintf(buf, "%d\n", TEMP_MAXMIN_FROM_REG(data->temp_max[nr])); 481 } 482 483 static ssize_t temp_min_show(struct device *dev, 484 struct device_attribute *attr, char *buf) 485 { 486 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 487 int nr = sensor_attr->index; 488 struct vt8231_data *data = vt8231_update_device(dev); 489 return sprintf(buf, "%d\n", TEMP_MAXMIN_FROM_REG(data->temp_min[nr])); 490 } 491 492 static ssize_t temp_max_store(struct device *dev, 493 struct device_attribute *attr, const char *buf, 494 size_t count) 495 { 496 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 497 int nr = sensor_attr->index; 498 struct vt8231_data *data = dev_get_drvdata(dev); 499 long val; 500 int err; 501 502 err = kstrtol(buf, 10, &val); 503 if (err) 504 return err; 505 506 mutex_lock(&data->update_lock); 507 data->temp_max[nr] = clamp_val(TEMP_MAXMIN_TO_REG(val), 0, 255); 508 vt8231_write_value(data, regtempmax[nr], data->temp_max[nr]); 509 mutex_unlock(&data->update_lock); 510 return count; 511 } 512 static ssize_t temp_min_store(struct device *dev, 513 struct device_attribute *attr, const char *buf, 514 size_t count) 515 { 516 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 517 int nr = sensor_attr->index; 518 struct vt8231_data *data = dev_get_drvdata(dev); 519 long val; 520 int err; 521 522 err = kstrtol(buf, 10, &val); 523 if (err) 524 return err; 525 526 mutex_lock(&data->update_lock); 527 data->temp_min[nr] = clamp_val(TEMP_MAXMIN_TO_REG(val), 0, 255); 528 vt8231_write_value(data, regtempmin[nr], data->temp_min[nr]); 529 mutex_unlock(&data->update_lock); 530 return count; 531 } 532 533 /* 534 * Note that these map the Linux temperature sensor numbering (1-6) to the VIA 535 * temperature sensor numbering (0-5) 536 */ 537 538 static DEVICE_ATTR_RO(temp1_input); 539 static DEVICE_ATTR_RW(temp1_max); 540 static DEVICE_ATTR_RW(temp1_max_hyst); 541 542 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1); 543 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1); 544 static SENSOR_DEVICE_ATTR_RW(temp2_max_hyst, temp_min, 1); 545 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2); 546 static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2); 547 static SENSOR_DEVICE_ATTR_RW(temp3_max_hyst, temp_min, 2); 548 static SENSOR_DEVICE_ATTR_RO(temp4_input, temp, 3); 549 static SENSOR_DEVICE_ATTR_RW(temp4_max, temp_max, 3); 550 static SENSOR_DEVICE_ATTR_RW(temp4_max_hyst, temp_min, 3); 551 static SENSOR_DEVICE_ATTR_RO(temp5_input, temp, 4); 552 static SENSOR_DEVICE_ATTR_RW(temp5_max, temp_max, 4); 553 static SENSOR_DEVICE_ATTR_RW(temp5_max_hyst, temp_min, 4); 554 static SENSOR_DEVICE_ATTR_RO(temp6_input, temp, 5); 555 static SENSOR_DEVICE_ATTR_RW(temp6_max, temp_max, 5); 556 static SENSOR_DEVICE_ATTR_RW(temp6_max_hyst, temp_min, 5); 557 558 /* Fans */ 559 static ssize_t fan_show(struct device *dev, struct device_attribute *attr, 560 char *buf) 561 { 562 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 563 int nr = sensor_attr->index; 564 struct vt8231_data *data = vt8231_update_device(dev); 565 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr], 566 DIV_FROM_REG(data->fan_div[nr]))); 567 } 568 569 static ssize_t fan_min_show(struct device *dev, struct device_attribute *attr, 570 char *buf) 571 { 572 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 573 int nr = sensor_attr->index; 574 struct vt8231_data *data = vt8231_update_device(dev); 575 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr], 576 DIV_FROM_REG(data->fan_div[nr]))); 577 } 578 579 static ssize_t fan_div_show(struct device *dev, struct device_attribute *attr, 580 char *buf) 581 { 582 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 583 int nr = sensor_attr->index; 584 struct vt8231_data *data = vt8231_update_device(dev); 585 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr])); 586 } 587 588 static ssize_t fan_min_store(struct device *dev, 589 struct device_attribute *attr, const char *buf, 590 size_t count) 591 { 592 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 593 int nr = sensor_attr->index; 594 struct vt8231_data *data = dev_get_drvdata(dev); 595 unsigned long val; 596 int err; 597 598 err = kstrtoul(buf, 10, &val); 599 if (err) 600 return err; 601 602 mutex_lock(&data->update_lock); 603 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr])); 604 vt8231_write_value(data, VT8231_REG_FAN_MIN(nr), data->fan_min[nr]); 605 mutex_unlock(&data->update_lock); 606 return count; 607 } 608 609 static ssize_t fan_div_store(struct device *dev, 610 struct device_attribute *attr, const char *buf, 611 size_t count) 612 { 613 struct vt8231_data *data = dev_get_drvdata(dev); 614 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 615 unsigned long val; 616 int nr = sensor_attr->index; 617 int old = vt8231_read_value(data, VT8231_REG_FANDIV); 618 long min = FAN_FROM_REG(data->fan_min[nr], 619 DIV_FROM_REG(data->fan_div[nr])); 620 int err; 621 622 err = kstrtoul(buf, 10, &val); 623 if (err) 624 return err; 625 626 mutex_lock(&data->update_lock); 627 switch (val) { 628 case 1: 629 data->fan_div[nr] = 0; 630 break; 631 case 2: 632 data->fan_div[nr] = 1; 633 break; 634 case 4: 635 data->fan_div[nr] = 2; 636 break; 637 case 8: 638 data->fan_div[nr] = 3; 639 break; 640 default: 641 dev_err(dev, 642 "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n", 643 val); 644 mutex_unlock(&data->update_lock); 645 return -EINVAL; 646 } 647 648 /* Correct the fan minimum speed */ 649 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr])); 650 vt8231_write_value(data, VT8231_REG_FAN_MIN(nr), data->fan_min[nr]); 651 652 old = (old & 0x0f) | (data->fan_div[1] << 6) | (data->fan_div[0] << 4); 653 vt8231_write_value(data, VT8231_REG_FANDIV, old); 654 mutex_unlock(&data->update_lock); 655 return count; 656 } 657 658 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0); 659 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0); 660 static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0); 661 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1); 662 static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1); 663 static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1); 664 665 /* Alarms */ 666 static ssize_t alarms_show(struct device *dev, struct device_attribute *attr, 667 char *buf) 668 { 669 struct vt8231_data *data = vt8231_update_device(dev); 670 return sprintf(buf, "%d\n", data->alarms); 671 } 672 static DEVICE_ATTR_RO(alarms); 673 674 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr, 675 char *buf) 676 { 677 int bitnr = to_sensor_dev_attr(attr)->index; 678 struct vt8231_data *data = vt8231_update_device(dev); 679 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1); 680 } 681 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 4); 682 static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 11); 683 static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 0); 684 static SENSOR_DEVICE_ATTR_RO(temp4_alarm, alarm, 1); 685 static SENSOR_DEVICE_ATTR_RO(temp5_alarm, alarm, 3); 686 static SENSOR_DEVICE_ATTR_RO(temp6_alarm, alarm, 8); 687 static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 11); 688 static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 0); 689 static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 1); 690 static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3); 691 static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 8); 692 static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 2); 693 static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 6); 694 static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 7); 695 696 static ssize_t name_show(struct device *dev, struct device_attribute 697 *devattr, char *buf) 698 { 699 struct vt8231_data *data = dev_get_drvdata(dev); 700 return sprintf(buf, "%s\n", data->name); 701 } 702 static DEVICE_ATTR_RO(name); 703 704 static struct attribute *vt8231_attributes_temps[6][5] = { 705 { 706 &dev_attr_temp1_input.attr, 707 &dev_attr_temp1_max_hyst.attr, 708 &dev_attr_temp1_max.attr, 709 &sensor_dev_attr_temp1_alarm.dev_attr.attr, 710 NULL 711 }, { 712 &sensor_dev_attr_temp2_input.dev_attr.attr, 713 &sensor_dev_attr_temp2_max_hyst.dev_attr.attr, 714 &sensor_dev_attr_temp2_max.dev_attr.attr, 715 &sensor_dev_attr_temp2_alarm.dev_attr.attr, 716 NULL 717 }, { 718 &sensor_dev_attr_temp3_input.dev_attr.attr, 719 &sensor_dev_attr_temp3_max_hyst.dev_attr.attr, 720 &sensor_dev_attr_temp3_max.dev_attr.attr, 721 &sensor_dev_attr_temp3_alarm.dev_attr.attr, 722 NULL 723 }, { 724 &sensor_dev_attr_temp4_input.dev_attr.attr, 725 &sensor_dev_attr_temp4_max_hyst.dev_attr.attr, 726 &sensor_dev_attr_temp4_max.dev_attr.attr, 727 &sensor_dev_attr_temp4_alarm.dev_attr.attr, 728 NULL 729 }, { 730 &sensor_dev_attr_temp5_input.dev_attr.attr, 731 &sensor_dev_attr_temp5_max_hyst.dev_attr.attr, 732 &sensor_dev_attr_temp5_max.dev_attr.attr, 733 &sensor_dev_attr_temp5_alarm.dev_attr.attr, 734 NULL 735 }, { 736 &sensor_dev_attr_temp6_input.dev_attr.attr, 737 &sensor_dev_attr_temp6_max_hyst.dev_attr.attr, 738 &sensor_dev_attr_temp6_max.dev_attr.attr, 739 &sensor_dev_attr_temp6_alarm.dev_attr.attr, 740 NULL 741 } 742 }; 743 744 static const struct attribute_group vt8231_group_temps[6] = { 745 { .attrs = vt8231_attributes_temps[0] }, 746 { .attrs = vt8231_attributes_temps[1] }, 747 { .attrs = vt8231_attributes_temps[2] }, 748 { .attrs = vt8231_attributes_temps[3] }, 749 { .attrs = vt8231_attributes_temps[4] }, 750 { .attrs = vt8231_attributes_temps[5] }, 751 }; 752 753 static struct attribute *vt8231_attributes_volts[6][5] = { 754 { 755 &sensor_dev_attr_in0_input.dev_attr.attr, 756 &sensor_dev_attr_in0_min.dev_attr.attr, 757 &sensor_dev_attr_in0_max.dev_attr.attr, 758 &sensor_dev_attr_in0_alarm.dev_attr.attr, 759 NULL 760 }, { 761 &sensor_dev_attr_in1_input.dev_attr.attr, 762 &sensor_dev_attr_in1_min.dev_attr.attr, 763 &sensor_dev_attr_in1_max.dev_attr.attr, 764 &sensor_dev_attr_in1_alarm.dev_attr.attr, 765 NULL 766 }, { 767 &sensor_dev_attr_in2_input.dev_attr.attr, 768 &sensor_dev_attr_in2_min.dev_attr.attr, 769 &sensor_dev_attr_in2_max.dev_attr.attr, 770 &sensor_dev_attr_in2_alarm.dev_attr.attr, 771 NULL 772 }, { 773 &sensor_dev_attr_in3_input.dev_attr.attr, 774 &sensor_dev_attr_in3_min.dev_attr.attr, 775 &sensor_dev_attr_in3_max.dev_attr.attr, 776 &sensor_dev_attr_in3_alarm.dev_attr.attr, 777 NULL 778 }, { 779 &sensor_dev_attr_in4_input.dev_attr.attr, 780 &sensor_dev_attr_in4_min.dev_attr.attr, 781 &sensor_dev_attr_in4_max.dev_attr.attr, 782 &sensor_dev_attr_in4_alarm.dev_attr.attr, 783 NULL 784 }, { 785 &dev_attr_in5_input.attr, 786 &dev_attr_in5_min.attr, 787 &dev_attr_in5_max.attr, 788 &sensor_dev_attr_in5_alarm.dev_attr.attr, 789 NULL 790 } 791 }; 792 793 static const struct attribute_group vt8231_group_volts[6] = { 794 { .attrs = vt8231_attributes_volts[0] }, 795 { .attrs = vt8231_attributes_volts[1] }, 796 { .attrs = vt8231_attributes_volts[2] }, 797 { .attrs = vt8231_attributes_volts[3] }, 798 { .attrs = vt8231_attributes_volts[4] }, 799 { .attrs = vt8231_attributes_volts[5] }, 800 }; 801 802 static struct attribute *vt8231_attributes[] = { 803 &sensor_dev_attr_fan1_input.dev_attr.attr, 804 &sensor_dev_attr_fan2_input.dev_attr.attr, 805 &sensor_dev_attr_fan1_min.dev_attr.attr, 806 &sensor_dev_attr_fan2_min.dev_attr.attr, 807 &sensor_dev_attr_fan1_div.dev_attr.attr, 808 &sensor_dev_attr_fan2_div.dev_attr.attr, 809 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 810 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 811 &dev_attr_alarms.attr, 812 &dev_attr_name.attr, 813 NULL 814 }; 815 816 static const struct attribute_group vt8231_group = { 817 .attrs = vt8231_attributes, 818 }; 819 820 static void vt8231_init_device(struct vt8231_data *data) 821 { 822 vt8231_write_value(data, VT8231_REG_TEMP1_CONFIG, 0); 823 vt8231_write_value(data, VT8231_REG_TEMP2_CONFIG, 0); 824 } 825 826 static int vt8231_probe(struct platform_device *pdev) 827 { 828 struct resource *res; 829 struct vt8231_data *data; 830 int err = 0, i; 831 832 /* Reserve the ISA region */ 833 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 834 if (!devm_request_region(&pdev->dev, res->start, VT8231_EXTENT, 835 DRIVER_NAME)) { 836 dev_err(&pdev->dev, "Region 0x%lx-0x%lx already in use!\n", 837 (unsigned long)res->start, (unsigned long)res->end); 838 return -ENODEV; 839 } 840 841 data = devm_kzalloc(&pdev->dev, sizeof(struct vt8231_data), GFP_KERNEL); 842 if (!data) 843 return -ENOMEM; 844 845 platform_set_drvdata(pdev, data); 846 data->addr = res->start; 847 data->name = DRIVER_NAME; 848 849 mutex_init(&data->update_lock); 850 vt8231_init_device(data); 851 852 /* Register sysfs hooks */ 853 err = sysfs_create_group(&pdev->dev.kobj, &vt8231_group); 854 if (err) 855 return err; 856 857 /* Must update device information to find out the config field */ 858 data->uch_config = vt8231_read_value(data, VT8231_REG_UCH_CONFIG); 859 860 for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++) { 861 if (ISTEMP(i, data->uch_config)) { 862 err = sysfs_create_group(&pdev->dev.kobj, 863 &vt8231_group_temps[i]); 864 if (err) 865 goto exit_remove_files; 866 } 867 } 868 869 for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++) { 870 if (ISVOLT(i, data->uch_config)) { 871 err = sysfs_create_group(&pdev->dev.kobj, 872 &vt8231_group_volts[i]); 873 if (err) 874 goto exit_remove_files; 875 } 876 } 877 878 data->hwmon_dev = hwmon_device_register(&pdev->dev); 879 if (IS_ERR(data->hwmon_dev)) { 880 err = PTR_ERR(data->hwmon_dev); 881 goto exit_remove_files; 882 } 883 return 0; 884 885 exit_remove_files: 886 for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++) 887 sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_volts[i]); 888 889 for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++) 890 sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_temps[i]); 891 892 sysfs_remove_group(&pdev->dev.kobj, &vt8231_group); 893 return err; 894 } 895 896 static int vt8231_remove(struct platform_device *pdev) 897 { 898 struct vt8231_data *data = platform_get_drvdata(pdev); 899 int i; 900 901 hwmon_device_unregister(data->hwmon_dev); 902 903 for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++) 904 sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_volts[i]); 905 906 for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++) 907 sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_temps[i]); 908 909 sysfs_remove_group(&pdev->dev.kobj, &vt8231_group); 910 911 return 0; 912 } 913 914 915 static struct platform_driver vt8231_driver = { 916 .driver = { 917 .name = DRIVER_NAME, 918 }, 919 .probe = vt8231_probe, 920 .remove = vt8231_remove, 921 }; 922 923 static const struct pci_device_id vt8231_pci_ids[] = { 924 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8231_4) }, 925 { 0, } 926 }; 927 928 MODULE_DEVICE_TABLE(pci, vt8231_pci_ids); 929 930 static int vt8231_device_add(unsigned short address) 931 { 932 struct resource res = { 933 .start = address, 934 .end = address + VT8231_EXTENT - 1, 935 .name = DRIVER_NAME, 936 .flags = IORESOURCE_IO, 937 }; 938 int err; 939 940 err = acpi_check_resource_conflict(&res); 941 if (err) 942 goto exit; 943 944 pdev = platform_device_alloc(DRIVER_NAME, address); 945 if (!pdev) { 946 err = -ENOMEM; 947 pr_err("Device allocation failed\n"); 948 goto exit; 949 } 950 951 err = platform_device_add_resources(pdev, &res, 1); 952 if (err) { 953 pr_err("Device resource addition failed (%d)\n", err); 954 goto exit_device_put; 955 } 956 957 err = platform_device_add(pdev); 958 if (err) { 959 pr_err("Device addition failed (%d)\n", err); 960 goto exit_device_put; 961 } 962 963 return 0; 964 965 exit_device_put: 966 platform_device_put(pdev); 967 exit: 968 return err; 969 } 970 971 static int vt8231_pci_probe(struct pci_dev *dev, 972 const struct pci_device_id *id) 973 { 974 u16 address, val; 975 if (force_addr) { 976 address = force_addr & 0xff00; 977 dev_warn(&dev->dev, "Forcing ISA address 0x%x\n", 978 address); 979 980 if (PCIBIOS_SUCCESSFUL != 981 pci_write_config_word(dev, VT8231_BASE_REG, address | 1)) 982 return -ENODEV; 983 } 984 985 pci_read_config_word(dev, VT8231_BASE_REG, &val); 986 if (val == (u16)~0) 987 return -ENODEV; 988 989 address = val & ~(VT8231_EXTENT - 1); 990 if (address == 0) { 991 dev_err(&dev->dev, "base address not set - upgrade BIOS or use force_addr=0xaddr\n"); 992 return -ENODEV; 993 } 994 995 pci_read_config_word(dev, VT8231_ENABLE_REG, &val); 996 if (val == (u16)~0) 997 return -ENODEV; 998 999 if (!(val & 0x0001)) { 1000 dev_warn(&dev->dev, "enabling sensors\n"); 1001 if (PCIBIOS_SUCCESSFUL != 1002 pci_write_config_word(dev, VT8231_ENABLE_REG, 1003 val | 0x0001)) 1004 return -ENODEV; 1005 } 1006 1007 if (platform_driver_register(&vt8231_driver)) 1008 goto exit; 1009 1010 /* Sets global pdev as a side effect */ 1011 if (vt8231_device_add(address)) 1012 goto exit_unregister; 1013 1014 /* 1015 * Always return failure here. This is to allow other drivers to bind 1016 * to this pci device. We don't really want to have control over the 1017 * pci device, we only wanted to read as few register values from it. 1018 */ 1019 1020 /* 1021 * We do, however, mark ourselves as using the PCI device to stop it 1022 * getting unloaded. 1023 */ 1024 s_bridge = pci_dev_get(dev); 1025 return -ENODEV; 1026 1027 exit_unregister: 1028 platform_driver_unregister(&vt8231_driver); 1029 exit: 1030 return -ENODEV; 1031 } 1032 1033 static struct pci_driver vt8231_pci_driver = { 1034 .name = DRIVER_NAME, 1035 .id_table = vt8231_pci_ids, 1036 .probe = vt8231_pci_probe, 1037 }; 1038 1039 static int __init sm_vt8231_init(void) 1040 { 1041 return pci_register_driver(&vt8231_pci_driver); 1042 } 1043 1044 static void __exit sm_vt8231_exit(void) 1045 { 1046 pci_unregister_driver(&vt8231_pci_driver); 1047 if (s_bridge != NULL) { 1048 platform_device_unregister(pdev); 1049 platform_driver_unregister(&vt8231_driver); 1050 pci_dev_put(s_bridge); 1051 s_bridge = NULL; 1052 } 1053 } 1054 1055 MODULE_AUTHOR("Roger Lucas <vt8231@hiddenengine.co.uk>"); 1056 MODULE_DESCRIPTION("VT8231 sensors"); 1057 MODULE_LICENSE("GPL"); 1058 1059 module_init(sm_vt8231_init); 1060 module_exit(sm_vt8231_exit); 1061