1 /* 2 * f71805f.c - driver for the Fintek F71805F/FG and F71872F/FG Super-I/O 3 * chips integrated hardware monitoring features 4 * Copyright (C) 2005-2006 Jean Delvare <khali@linux-fr.org> 5 * 6 * The F71805F/FG is a LPC Super-I/O chip made by Fintek. It integrates 7 * complete hardware monitoring features: voltage, fan and temperature 8 * sensors, and manual and automatic fan speed control. 9 * 10 * The F71872F/FG is almost the same, with two more voltages monitored, 11 * and 6 VID inputs. 12 * 13 * The F71806F/FG is essentially the same as the F71872F/FG. It even has 14 * the same chip ID, so the driver can't differentiate between. 15 * 16 * This program is free software; you can redistribute it and/or modify 17 * it under the terms of the GNU General Public License as published by 18 * the Free Software Foundation; either version 2 of the License, or 19 * (at your option) any later version. 20 * 21 * This program is distributed in the hope that it will be useful, 22 * but WITHOUT ANY WARRANTY; without even the implied warranty of 23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 24 * GNU General Public License for more details. 25 * 26 * You should have received a copy of the GNU General Public License 27 * along with this program; if not, write to the Free Software 28 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 29 */ 30 31 #include <linux/module.h> 32 #include <linux/init.h> 33 #include <linux/slab.h> 34 #include <linux/jiffies.h> 35 #include <linux/platform_device.h> 36 #include <linux/hwmon.h> 37 #include <linux/hwmon-sysfs.h> 38 #include <linux/err.h> 39 #include <linux/mutex.h> 40 #include <linux/sysfs.h> 41 #include <linux/ioport.h> 42 #include <asm/io.h> 43 44 static struct platform_device *pdev; 45 46 #define DRVNAME "f71805f" 47 enum kinds { f71805f, f71872f }; 48 49 /* 50 * Super-I/O constants and functions 51 */ 52 53 #define F71805F_LD_HWM 0x04 54 55 #define SIO_REG_LDSEL 0x07 /* Logical device select */ 56 #define SIO_REG_DEVID 0x20 /* Device ID (2 bytes) */ 57 #define SIO_REG_DEVREV 0x22 /* Device revision */ 58 #define SIO_REG_MANID 0x23 /* Fintek ID (2 bytes) */ 59 #define SIO_REG_FNSEL1 0x29 /* Multi Function Select 1 (F71872F) */ 60 #define SIO_REG_ENABLE 0x30 /* Logical device enable */ 61 #define SIO_REG_ADDR 0x60 /* Logical device address (2 bytes) */ 62 63 #define SIO_FINTEK_ID 0x1934 64 #define SIO_F71805F_ID 0x0406 65 #define SIO_F71872F_ID 0x0341 66 67 static inline int 68 superio_inb(int base, int reg) 69 { 70 outb(reg, base); 71 return inb(base + 1); 72 } 73 74 static int 75 superio_inw(int base, int reg) 76 { 77 int val; 78 outb(reg++, base); 79 val = inb(base + 1) << 8; 80 outb(reg, base); 81 val |= inb(base + 1); 82 return val; 83 } 84 85 static inline void 86 superio_select(int base, int ld) 87 { 88 outb(SIO_REG_LDSEL, base); 89 outb(ld, base + 1); 90 } 91 92 static inline void 93 superio_enter(int base) 94 { 95 outb(0x87, base); 96 outb(0x87, base); 97 } 98 99 static inline void 100 superio_exit(int base) 101 { 102 outb(0xaa, base); 103 } 104 105 /* 106 * ISA constants 107 */ 108 109 #define REGION_LENGTH 8 110 #define ADDR_REG_OFFSET 5 111 #define DATA_REG_OFFSET 6 112 113 /* 114 * Registers 115 */ 116 117 /* in nr from 0 to 10 (8-bit values) */ 118 #define F71805F_REG_IN(nr) (0x10 + (nr)) 119 #define F71805F_REG_IN_HIGH(nr) ((nr) < 10 ? 0x40 + 2 * (nr) : 0x2E) 120 #define F71805F_REG_IN_LOW(nr) ((nr) < 10 ? 0x41 + 2 * (nr) : 0x2F) 121 /* fan nr from 0 to 2 (12-bit values, two registers) */ 122 #define F71805F_REG_FAN(nr) (0x20 + 2 * (nr)) 123 #define F71805F_REG_FAN_LOW(nr) (0x28 + 2 * (nr)) 124 #define F71805F_REG_FAN_TARGET(nr) (0x69 + 16 * (nr)) 125 #define F71805F_REG_FAN_CTRL(nr) (0x60 + 16 * (nr)) 126 #define F71805F_REG_PWM_FREQ(nr) (0x63 + 16 * (nr)) 127 #define F71805F_REG_PWM_DUTY(nr) (0x6B + 16 * (nr)) 128 /* temp nr from 0 to 2 (8-bit values) */ 129 #define F71805F_REG_TEMP(nr) (0x1B + (nr)) 130 #define F71805F_REG_TEMP_HIGH(nr) (0x54 + 2 * (nr)) 131 #define F71805F_REG_TEMP_HYST(nr) (0x55 + 2 * (nr)) 132 #define F71805F_REG_TEMP_MODE 0x01 133 /* pwm/fan pwmnr from 0 to 2, auto point apnr from 0 to 2 */ 134 /* map Fintek numbers to our numbers as follows: 9->0, 5->1, 1->2 */ 135 #define F71805F_REG_PWM_AUTO_POINT_TEMP(pwmnr, apnr) \ 136 (0xA0 + 0x10 * (pwmnr) + (2 - (apnr))) 137 #define F71805F_REG_PWM_AUTO_POINT_FAN(pwmnr, apnr) \ 138 (0xA4 + 0x10 * (pwmnr) + \ 139 2 * (2 - (apnr))) 140 141 #define F71805F_REG_START 0x00 142 /* status nr from 0 to 2 */ 143 #define F71805F_REG_STATUS(nr) (0x36 + (nr)) 144 145 /* individual register bits */ 146 #define FAN_CTRL_DC_MODE 0x10 147 #define FAN_CTRL_LATCH_FULL 0x08 148 #define FAN_CTRL_MODE_MASK 0x03 149 #define FAN_CTRL_MODE_SPEED 0x00 150 #define FAN_CTRL_MODE_TEMPERATURE 0x01 151 #define FAN_CTRL_MODE_MANUAL 0x02 152 153 /* 154 * Data structures and manipulation thereof 155 */ 156 157 struct f71805f_auto_point { 158 u8 temp[3]; 159 u16 fan[3]; 160 }; 161 162 struct f71805f_data { 163 unsigned short addr; 164 const char *name; 165 struct device *hwmon_dev; 166 167 struct mutex update_lock; 168 char valid; /* !=0 if following fields are valid */ 169 unsigned long last_updated; /* In jiffies */ 170 unsigned long last_limits; /* In jiffies */ 171 172 /* Register values */ 173 u8 in[11]; 174 u8 in_high[11]; 175 u8 in_low[11]; 176 u16 has_in; 177 u16 fan[3]; 178 u16 fan_low[3]; 179 u16 fan_target[3]; 180 u8 fan_ctrl[3]; 181 u8 pwm[3]; 182 u8 pwm_freq[3]; 183 u8 temp[3]; 184 u8 temp_high[3]; 185 u8 temp_hyst[3]; 186 u8 temp_mode; 187 unsigned long alarms; 188 struct f71805f_auto_point auto_points[3]; 189 }; 190 191 struct f71805f_sio_data { 192 enum kinds kind; 193 u8 fnsel1; 194 }; 195 196 static inline long in_from_reg(u8 reg) 197 { 198 return (reg * 8); 199 } 200 201 /* The 2 least significant bits are not used */ 202 static inline u8 in_to_reg(long val) 203 { 204 if (val <= 0) 205 return 0; 206 if (val >= 2016) 207 return 0xfc; 208 return (((val + 16) / 32) << 2); 209 } 210 211 /* in0 is downscaled by a factor 2 internally */ 212 static inline long in0_from_reg(u8 reg) 213 { 214 return (reg * 16); 215 } 216 217 static inline u8 in0_to_reg(long val) 218 { 219 if (val <= 0) 220 return 0; 221 if (val >= 4032) 222 return 0xfc; 223 return (((val + 32) / 64) << 2); 224 } 225 226 /* The 4 most significant bits are not used */ 227 static inline long fan_from_reg(u16 reg) 228 { 229 reg &= 0xfff; 230 if (!reg || reg == 0xfff) 231 return 0; 232 return (1500000 / reg); 233 } 234 235 static inline u16 fan_to_reg(long rpm) 236 { 237 /* If the low limit is set below what the chip can measure, 238 store the largest possible 12-bit value in the registers, 239 so that no alarm will ever trigger. */ 240 if (rpm < 367) 241 return 0xfff; 242 return (1500000 / rpm); 243 } 244 245 static inline unsigned long pwm_freq_from_reg(u8 reg) 246 { 247 unsigned long clock = (reg & 0x80) ? 48000000UL : 1000000UL; 248 249 reg &= 0x7f; 250 if (reg == 0) 251 reg++; 252 return clock / (reg << 8); 253 } 254 255 static inline u8 pwm_freq_to_reg(unsigned long val) 256 { 257 if (val >= 187500) /* The highest we can do */ 258 return 0x80; 259 if (val >= 1475) /* Use 48 MHz clock */ 260 return 0x80 | (48000000UL / (val << 8)); 261 if (val < 31) /* The lowest we can do */ 262 return 0x7f; 263 else /* Use 1 MHz clock */ 264 return 1000000UL / (val << 8); 265 } 266 267 static inline int pwm_mode_from_reg(u8 reg) 268 { 269 return !(reg & FAN_CTRL_DC_MODE); 270 } 271 272 static inline long temp_from_reg(u8 reg) 273 { 274 return (reg * 1000); 275 } 276 277 static inline u8 temp_to_reg(long val) 278 { 279 if (val < 0) 280 val = 0; 281 else if (val > 1000 * 0xff) 282 val = 0xff; 283 return ((val + 500) / 1000); 284 } 285 286 /* 287 * Device I/O access 288 */ 289 290 /* Must be called with data->update_lock held, except during initialization */ 291 static u8 f71805f_read8(struct f71805f_data *data, u8 reg) 292 { 293 outb(reg, data->addr + ADDR_REG_OFFSET); 294 return inb(data->addr + DATA_REG_OFFSET); 295 } 296 297 /* Must be called with data->update_lock held, except during initialization */ 298 static void f71805f_write8(struct f71805f_data *data, u8 reg, u8 val) 299 { 300 outb(reg, data->addr + ADDR_REG_OFFSET); 301 outb(val, data->addr + DATA_REG_OFFSET); 302 } 303 304 /* It is important to read the MSB first, because doing so latches the 305 value of the LSB, so we are sure both bytes belong to the same value. 306 Must be called with data->update_lock held, except during initialization */ 307 static u16 f71805f_read16(struct f71805f_data *data, u8 reg) 308 { 309 u16 val; 310 311 outb(reg, data->addr + ADDR_REG_OFFSET); 312 val = inb(data->addr + DATA_REG_OFFSET) << 8; 313 outb(++reg, data->addr + ADDR_REG_OFFSET); 314 val |= inb(data->addr + DATA_REG_OFFSET); 315 316 return val; 317 } 318 319 /* Must be called with data->update_lock held, except during initialization */ 320 static void f71805f_write16(struct f71805f_data *data, u8 reg, u16 val) 321 { 322 outb(reg, data->addr + ADDR_REG_OFFSET); 323 outb(val >> 8, data->addr + DATA_REG_OFFSET); 324 outb(++reg, data->addr + ADDR_REG_OFFSET); 325 outb(val & 0xff, data->addr + DATA_REG_OFFSET); 326 } 327 328 static struct f71805f_data *f71805f_update_device(struct device *dev) 329 { 330 struct f71805f_data *data = dev_get_drvdata(dev); 331 int nr, apnr; 332 333 mutex_lock(&data->update_lock); 334 335 /* Limit registers cache is refreshed after 60 seconds */ 336 if (time_after(jiffies, data->last_updated + 60 * HZ) 337 || !data->valid) { 338 for (nr = 0; nr < 11; nr++) { 339 if (!(data->has_in & (1 << nr))) 340 continue; 341 data->in_high[nr] = f71805f_read8(data, 342 F71805F_REG_IN_HIGH(nr)); 343 data->in_low[nr] = f71805f_read8(data, 344 F71805F_REG_IN_LOW(nr)); 345 } 346 for (nr = 0; nr < 3; nr++) { 347 data->fan_low[nr] = f71805f_read16(data, 348 F71805F_REG_FAN_LOW(nr)); 349 data->fan_target[nr] = f71805f_read16(data, 350 F71805F_REG_FAN_TARGET(nr)); 351 data->pwm_freq[nr] = f71805f_read8(data, 352 F71805F_REG_PWM_FREQ(nr)); 353 } 354 for (nr = 0; nr < 3; nr++) { 355 data->temp_high[nr] = f71805f_read8(data, 356 F71805F_REG_TEMP_HIGH(nr)); 357 data->temp_hyst[nr] = f71805f_read8(data, 358 F71805F_REG_TEMP_HYST(nr)); 359 } 360 data->temp_mode = f71805f_read8(data, F71805F_REG_TEMP_MODE); 361 for (nr = 0; nr < 3; nr++) { 362 for (apnr = 0; apnr < 3; apnr++) { 363 data->auto_points[nr].temp[apnr] = 364 f71805f_read8(data, 365 F71805F_REG_PWM_AUTO_POINT_TEMP(nr, 366 apnr)); 367 data->auto_points[nr].fan[apnr] = 368 f71805f_read16(data, 369 F71805F_REG_PWM_AUTO_POINT_FAN(nr, 370 apnr)); 371 } 372 } 373 374 data->last_limits = jiffies; 375 } 376 377 /* Measurement registers cache is refreshed after 1 second */ 378 if (time_after(jiffies, data->last_updated + HZ) 379 || !data->valid) { 380 for (nr = 0; nr < 11; nr++) { 381 if (!(data->has_in & (1 << nr))) 382 continue; 383 data->in[nr] = f71805f_read8(data, 384 F71805F_REG_IN(nr)); 385 } 386 for (nr = 0; nr < 3; nr++) { 387 data->fan[nr] = f71805f_read16(data, 388 F71805F_REG_FAN(nr)); 389 data->fan_ctrl[nr] = f71805f_read8(data, 390 F71805F_REG_FAN_CTRL(nr)); 391 data->pwm[nr] = f71805f_read8(data, 392 F71805F_REG_PWM_DUTY(nr)); 393 } 394 for (nr = 0; nr < 3; nr++) { 395 data->temp[nr] = f71805f_read8(data, 396 F71805F_REG_TEMP(nr)); 397 } 398 data->alarms = f71805f_read8(data, F71805F_REG_STATUS(0)) 399 + (f71805f_read8(data, F71805F_REG_STATUS(1)) << 8) 400 + (f71805f_read8(data, F71805F_REG_STATUS(2)) << 16); 401 402 data->last_updated = jiffies; 403 data->valid = 1; 404 } 405 406 mutex_unlock(&data->update_lock); 407 408 return data; 409 } 410 411 /* 412 * Sysfs interface 413 */ 414 415 static ssize_t show_in0(struct device *dev, struct device_attribute *devattr, 416 char *buf) 417 { 418 struct f71805f_data *data = f71805f_update_device(dev); 419 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 420 int nr = attr->index; 421 422 return sprintf(buf, "%ld\n", in0_from_reg(data->in[nr])); 423 } 424 425 static ssize_t show_in0_max(struct device *dev, struct device_attribute 426 *devattr, char *buf) 427 { 428 struct f71805f_data *data = f71805f_update_device(dev); 429 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 430 int nr = attr->index; 431 432 return sprintf(buf, "%ld\n", in0_from_reg(data->in_high[nr])); 433 } 434 435 static ssize_t show_in0_min(struct device *dev, struct device_attribute 436 *devattr, char *buf) 437 { 438 struct f71805f_data *data = f71805f_update_device(dev); 439 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 440 int nr = attr->index; 441 442 return sprintf(buf, "%ld\n", in0_from_reg(data->in_low[nr])); 443 } 444 445 static ssize_t set_in0_max(struct device *dev, struct device_attribute 446 *devattr, const char *buf, size_t count) 447 { 448 struct f71805f_data *data = dev_get_drvdata(dev); 449 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 450 int nr = attr->index; 451 long val = simple_strtol(buf, NULL, 10); 452 453 mutex_lock(&data->update_lock); 454 data->in_high[nr] = in0_to_reg(val); 455 f71805f_write8(data, F71805F_REG_IN_HIGH(nr), data->in_high[nr]); 456 mutex_unlock(&data->update_lock); 457 458 return count; 459 } 460 461 static ssize_t set_in0_min(struct device *dev, struct device_attribute 462 *devattr, const char *buf, size_t count) 463 { 464 struct f71805f_data *data = dev_get_drvdata(dev); 465 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 466 int nr = attr->index; 467 long val = simple_strtol(buf, NULL, 10); 468 469 mutex_lock(&data->update_lock); 470 data->in_low[nr] = in0_to_reg(val); 471 f71805f_write8(data, F71805F_REG_IN_LOW(nr), data->in_low[nr]); 472 mutex_unlock(&data->update_lock); 473 474 return count; 475 } 476 477 static ssize_t show_in(struct device *dev, struct device_attribute *devattr, 478 char *buf) 479 { 480 struct f71805f_data *data = f71805f_update_device(dev); 481 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 482 int nr = attr->index; 483 484 return sprintf(buf, "%ld\n", in_from_reg(data->in[nr])); 485 } 486 487 static ssize_t show_in_max(struct device *dev, struct device_attribute 488 *devattr, char *buf) 489 { 490 struct f71805f_data *data = f71805f_update_device(dev); 491 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 492 int nr = attr->index; 493 494 return sprintf(buf, "%ld\n", in_from_reg(data->in_high[nr])); 495 } 496 497 static ssize_t show_in_min(struct device *dev, struct device_attribute 498 *devattr, char *buf) 499 { 500 struct f71805f_data *data = f71805f_update_device(dev); 501 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 502 int nr = attr->index; 503 504 return sprintf(buf, "%ld\n", in_from_reg(data->in_low[nr])); 505 } 506 507 static ssize_t set_in_max(struct device *dev, struct device_attribute 508 *devattr, const char *buf, size_t count) 509 { 510 struct f71805f_data *data = dev_get_drvdata(dev); 511 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 512 int nr = attr->index; 513 long val = simple_strtol(buf, NULL, 10); 514 515 mutex_lock(&data->update_lock); 516 data->in_high[nr] = in_to_reg(val); 517 f71805f_write8(data, F71805F_REG_IN_HIGH(nr), data->in_high[nr]); 518 mutex_unlock(&data->update_lock); 519 520 return count; 521 } 522 523 static ssize_t set_in_min(struct device *dev, struct device_attribute 524 *devattr, const char *buf, size_t count) 525 { 526 struct f71805f_data *data = dev_get_drvdata(dev); 527 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 528 int nr = attr->index; 529 long val = simple_strtol(buf, NULL, 10); 530 531 mutex_lock(&data->update_lock); 532 data->in_low[nr] = in_to_reg(val); 533 f71805f_write8(data, F71805F_REG_IN_LOW(nr), data->in_low[nr]); 534 mutex_unlock(&data->update_lock); 535 536 return count; 537 } 538 539 static ssize_t show_fan(struct device *dev, struct device_attribute *devattr, 540 char *buf) 541 { 542 struct f71805f_data *data = f71805f_update_device(dev); 543 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 544 int nr = attr->index; 545 546 return sprintf(buf, "%ld\n", fan_from_reg(data->fan[nr])); 547 } 548 549 static ssize_t show_fan_min(struct device *dev, struct device_attribute 550 *devattr, char *buf) 551 { 552 struct f71805f_data *data = f71805f_update_device(dev); 553 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 554 int nr = attr->index; 555 556 return sprintf(buf, "%ld\n", fan_from_reg(data->fan_low[nr])); 557 } 558 559 static ssize_t show_fan_target(struct device *dev, struct device_attribute 560 *devattr, char *buf) 561 { 562 struct f71805f_data *data = f71805f_update_device(dev); 563 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 564 int nr = attr->index; 565 566 return sprintf(buf, "%ld\n", fan_from_reg(data->fan_target[nr])); 567 } 568 569 static ssize_t set_fan_min(struct device *dev, struct device_attribute 570 *devattr, const char *buf, size_t count) 571 { 572 struct f71805f_data *data = dev_get_drvdata(dev); 573 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 574 int nr = attr->index; 575 long val = simple_strtol(buf, NULL, 10); 576 577 mutex_lock(&data->update_lock); 578 data->fan_low[nr] = fan_to_reg(val); 579 f71805f_write16(data, F71805F_REG_FAN_LOW(nr), data->fan_low[nr]); 580 mutex_unlock(&data->update_lock); 581 582 return count; 583 } 584 585 static ssize_t set_fan_target(struct device *dev, struct device_attribute 586 *devattr, const char *buf, size_t count) 587 { 588 struct f71805f_data *data = dev_get_drvdata(dev); 589 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 590 int nr = attr->index; 591 long val = simple_strtol(buf, NULL, 10); 592 593 mutex_lock(&data->update_lock); 594 data->fan_target[nr] = fan_to_reg(val); 595 f71805f_write16(data, F71805F_REG_FAN_TARGET(nr), 596 data->fan_target[nr]); 597 mutex_unlock(&data->update_lock); 598 599 return count; 600 } 601 602 static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr, 603 char *buf) 604 { 605 struct f71805f_data *data = f71805f_update_device(dev); 606 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 607 int nr = attr->index; 608 609 return sprintf(buf, "%d\n", (int)data->pwm[nr]); 610 } 611 612 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute 613 *devattr, char *buf) 614 { 615 struct f71805f_data *data = f71805f_update_device(dev); 616 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 617 int nr = attr->index; 618 int mode; 619 620 switch (data->fan_ctrl[nr] & FAN_CTRL_MODE_MASK) { 621 case FAN_CTRL_MODE_SPEED: 622 mode = 3; 623 break; 624 case FAN_CTRL_MODE_TEMPERATURE: 625 mode = 2; 626 break; 627 default: /* MANUAL */ 628 mode = 1; 629 } 630 631 return sprintf(buf, "%d\n", mode); 632 } 633 634 static ssize_t show_pwm_freq(struct device *dev, struct device_attribute 635 *devattr, char *buf) 636 { 637 struct f71805f_data *data = f71805f_update_device(dev); 638 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 639 int nr = attr->index; 640 641 return sprintf(buf, "%lu\n", pwm_freq_from_reg(data->pwm_freq[nr])); 642 } 643 644 static ssize_t show_pwm_mode(struct device *dev, struct device_attribute 645 *devattr, char *buf) 646 { 647 struct f71805f_data *data = f71805f_update_device(dev); 648 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 649 int nr = attr->index; 650 651 return sprintf(buf, "%d\n", pwm_mode_from_reg(data->fan_ctrl[nr])); 652 } 653 654 static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr, 655 const char *buf, size_t count) 656 { 657 struct f71805f_data *data = dev_get_drvdata(dev); 658 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 659 int nr = attr->index; 660 unsigned long val = simple_strtoul(buf, NULL, 10); 661 662 if (val > 255) 663 return -EINVAL; 664 665 mutex_lock(&data->update_lock); 666 data->pwm[nr] = val; 667 f71805f_write8(data, F71805F_REG_PWM_DUTY(nr), data->pwm[nr]); 668 mutex_unlock(&data->update_lock); 669 670 return count; 671 } 672 673 static struct attribute *f71805f_attr_pwm[]; 674 675 static ssize_t set_pwm_enable(struct device *dev, struct device_attribute 676 *devattr, const char *buf, size_t count) 677 { 678 struct f71805f_data *data = dev_get_drvdata(dev); 679 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 680 int nr = attr->index; 681 unsigned long val = simple_strtoul(buf, NULL, 10); 682 u8 reg; 683 684 if (val < 1 || val > 3) 685 return -EINVAL; 686 687 if (val > 1) { /* Automatic mode, user can't set PWM value */ 688 if (sysfs_chmod_file(&dev->kobj, f71805f_attr_pwm[nr], 689 S_IRUGO)) 690 dev_dbg(dev, "chmod -w pwm%d failed\n", nr + 1); 691 } 692 693 mutex_lock(&data->update_lock); 694 reg = f71805f_read8(data, F71805F_REG_FAN_CTRL(nr)) 695 & ~FAN_CTRL_MODE_MASK; 696 switch (val) { 697 case 1: 698 reg |= FAN_CTRL_MODE_MANUAL; 699 break; 700 case 2: 701 reg |= FAN_CTRL_MODE_TEMPERATURE; 702 break; 703 case 3: 704 reg |= FAN_CTRL_MODE_SPEED; 705 break; 706 } 707 data->fan_ctrl[nr] = reg; 708 f71805f_write8(data, F71805F_REG_FAN_CTRL(nr), reg); 709 mutex_unlock(&data->update_lock); 710 711 if (val == 1) { /* Manual mode, user can set PWM value */ 712 if (sysfs_chmod_file(&dev->kobj, f71805f_attr_pwm[nr], 713 S_IRUGO | S_IWUSR)) 714 dev_dbg(dev, "chmod +w pwm%d failed\n", nr + 1); 715 } 716 717 return count; 718 } 719 720 static ssize_t set_pwm_freq(struct device *dev, struct device_attribute 721 *devattr, const char *buf, size_t count) 722 { 723 struct f71805f_data *data = dev_get_drvdata(dev); 724 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 725 int nr = attr->index; 726 unsigned long val = simple_strtoul(buf, NULL, 10); 727 728 mutex_lock(&data->update_lock); 729 data->pwm_freq[nr] = pwm_freq_to_reg(val); 730 f71805f_write8(data, F71805F_REG_PWM_FREQ(nr), data->pwm_freq[nr]); 731 mutex_unlock(&data->update_lock); 732 733 return count; 734 } 735 736 static ssize_t show_pwm_auto_point_temp(struct device *dev, 737 struct device_attribute *devattr, 738 char* buf) 739 { 740 struct f71805f_data *data = dev_get_drvdata(dev); 741 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); 742 int pwmnr = attr->nr; 743 int apnr = attr->index; 744 745 return sprintf(buf, "%ld\n", 746 temp_from_reg(data->auto_points[pwmnr].temp[apnr])); 747 } 748 749 static ssize_t set_pwm_auto_point_temp(struct device *dev, 750 struct device_attribute *devattr, 751 const char* buf, size_t count) 752 { 753 struct f71805f_data *data = dev_get_drvdata(dev); 754 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); 755 int pwmnr = attr->nr; 756 int apnr = attr->index; 757 unsigned long val = simple_strtol(buf, NULL, 10); 758 759 mutex_lock(&data->update_lock); 760 data->auto_points[pwmnr].temp[apnr] = temp_to_reg(val); 761 f71805f_write8(data, F71805F_REG_PWM_AUTO_POINT_TEMP(pwmnr, apnr), 762 data->auto_points[pwmnr].temp[apnr]); 763 mutex_unlock(&data->update_lock); 764 765 return count; 766 } 767 768 static ssize_t show_pwm_auto_point_fan(struct device *dev, 769 struct device_attribute *devattr, 770 char* buf) 771 { 772 struct f71805f_data *data = dev_get_drvdata(dev); 773 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); 774 int pwmnr = attr->nr; 775 int apnr = attr->index; 776 777 return sprintf(buf, "%ld\n", 778 fan_from_reg(data->auto_points[pwmnr].fan[apnr])); 779 } 780 781 static ssize_t set_pwm_auto_point_fan(struct device *dev, 782 struct device_attribute *devattr, 783 const char* buf, size_t count) 784 { 785 struct f71805f_data *data = dev_get_drvdata(dev); 786 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); 787 int pwmnr = attr->nr; 788 int apnr = attr->index; 789 unsigned long val = simple_strtoul(buf, NULL, 10); 790 791 mutex_lock(&data->update_lock); 792 data->auto_points[pwmnr].fan[apnr] = fan_to_reg(val); 793 f71805f_write16(data, F71805F_REG_PWM_AUTO_POINT_FAN(pwmnr, apnr), 794 data->auto_points[pwmnr].fan[apnr]); 795 mutex_unlock(&data->update_lock); 796 797 return count; 798 } 799 800 static ssize_t show_temp(struct device *dev, struct device_attribute *devattr, 801 char *buf) 802 { 803 struct f71805f_data *data = f71805f_update_device(dev); 804 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 805 int nr = attr->index; 806 807 return sprintf(buf, "%ld\n", temp_from_reg(data->temp[nr])); 808 } 809 810 static ssize_t show_temp_max(struct device *dev, struct device_attribute 811 *devattr, char *buf) 812 { 813 struct f71805f_data *data = f71805f_update_device(dev); 814 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 815 int nr = attr->index; 816 817 return sprintf(buf, "%ld\n", temp_from_reg(data->temp_high[nr])); 818 } 819 820 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute 821 *devattr, char *buf) 822 { 823 struct f71805f_data *data = f71805f_update_device(dev); 824 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 825 int nr = attr->index; 826 827 return sprintf(buf, "%ld\n", temp_from_reg(data->temp_hyst[nr])); 828 } 829 830 static ssize_t show_temp_type(struct device *dev, struct device_attribute 831 *devattr, char *buf) 832 { 833 struct f71805f_data *data = f71805f_update_device(dev); 834 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 835 int nr = attr->index; 836 837 /* 3 is diode, 4 is thermistor */ 838 return sprintf(buf, "%u\n", (data->temp_mode & (1 << nr)) ? 3 : 4); 839 } 840 841 static ssize_t set_temp_max(struct device *dev, struct device_attribute 842 *devattr, const char *buf, size_t count) 843 { 844 struct f71805f_data *data = dev_get_drvdata(dev); 845 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 846 int nr = attr->index; 847 long val = simple_strtol(buf, NULL, 10); 848 849 mutex_lock(&data->update_lock); 850 data->temp_high[nr] = temp_to_reg(val); 851 f71805f_write8(data, F71805F_REG_TEMP_HIGH(nr), data->temp_high[nr]); 852 mutex_unlock(&data->update_lock); 853 854 return count; 855 } 856 857 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute 858 *devattr, const char *buf, size_t count) 859 { 860 struct f71805f_data *data = dev_get_drvdata(dev); 861 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 862 int nr = attr->index; 863 long val = simple_strtol(buf, NULL, 10); 864 865 mutex_lock(&data->update_lock); 866 data->temp_hyst[nr] = temp_to_reg(val); 867 f71805f_write8(data, F71805F_REG_TEMP_HYST(nr), data->temp_hyst[nr]); 868 mutex_unlock(&data->update_lock); 869 870 return count; 871 } 872 873 static ssize_t show_alarms_in(struct device *dev, struct device_attribute 874 *devattr, char *buf) 875 { 876 struct f71805f_data *data = f71805f_update_device(dev); 877 878 return sprintf(buf, "%lu\n", data->alarms & 0x7ff); 879 } 880 881 static ssize_t show_alarms_fan(struct device *dev, struct device_attribute 882 *devattr, char *buf) 883 { 884 struct f71805f_data *data = f71805f_update_device(dev); 885 886 return sprintf(buf, "%lu\n", (data->alarms >> 16) & 0x07); 887 } 888 889 static ssize_t show_alarms_temp(struct device *dev, struct device_attribute 890 *devattr, char *buf) 891 { 892 struct f71805f_data *data = f71805f_update_device(dev); 893 894 return sprintf(buf, "%lu\n", (data->alarms >> 11) & 0x07); 895 } 896 897 static ssize_t show_alarm(struct device *dev, struct device_attribute 898 *devattr, char *buf) 899 { 900 struct f71805f_data *data = f71805f_update_device(dev); 901 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 902 int bitnr = attr->index; 903 904 return sprintf(buf, "%lu\n", (data->alarms >> bitnr) & 1); 905 } 906 907 static ssize_t show_name(struct device *dev, struct device_attribute 908 *devattr, char *buf) 909 { 910 struct f71805f_data *data = dev_get_drvdata(dev); 911 912 return sprintf(buf, "%s\n", data->name); 913 } 914 915 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in0, NULL, 0); 916 static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO| S_IWUSR, 917 show_in0_max, set_in0_max, 0); 918 static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO| S_IWUSR, 919 show_in0_min, set_in0_min, 0); 920 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in, NULL, 1); 921 static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO | S_IWUSR, 922 show_in_max, set_in_max, 1); 923 static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO | S_IWUSR, 924 show_in_min, set_in_min, 1); 925 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in, NULL, 2); 926 static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO | S_IWUSR, 927 show_in_max, set_in_max, 2); 928 static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO | S_IWUSR, 929 show_in_min, set_in_min, 2); 930 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in, NULL, 3); 931 static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO | S_IWUSR, 932 show_in_max, set_in_max, 3); 933 static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO | S_IWUSR, 934 show_in_min, set_in_min, 3); 935 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in, NULL, 4); 936 static SENSOR_DEVICE_ATTR(in4_max, S_IRUGO | S_IWUSR, 937 show_in_max, set_in_max, 4); 938 static SENSOR_DEVICE_ATTR(in4_min, S_IRUGO | S_IWUSR, 939 show_in_min, set_in_min, 4); 940 static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_in, NULL, 5); 941 static SENSOR_DEVICE_ATTR(in5_max, S_IRUGO | S_IWUSR, 942 show_in_max, set_in_max, 5); 943 static SENSOR_DEVICE_ATTR(in5_min, S_IRUGO | S_IWUSR, 944 show_in_min, set_in_min, 5); 945 static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_in, NULL, 6); 946 static SENSOR_DEVICE_ATTR(in6_max, S_IRUGO | S_IWUSR, 947 show_in_max, set_in_max, 6); 948 static SENSOR_DEVICE_ATTR(in6_min, S_IRUGO | S_IWUSR, 949 show_in_min, set_in_min, 6); 950 static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, show_in, NULL, 7); 951 static SENSOR_DEVICE_ATTR(in7_max, S_IRUGO | S_IWUSR, 952 show_in_max, set_in_max, 7); 953 static SENSOR_DEVICE_ATTR(in7_min, S_IRUGO | S_IWUSR, 954 show_in_min, set_in_min, 7); 955 static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, show_in, NULL, 8); 956 static SENSOR_DEVICE_ATTR(in8_max, S_IRUGO | S_IWUSR, 957 show_in_max, set_in_max, 8); 958 static SENSOR_DEVICE_ATTR(in8_min, S_IRUGO | S_IWUSR, 959 show_in_min, set_in_min, 8); 960 static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, show_in0, NULL, 9); 961 static SENSOR_DEVICE_ATTR(in9_max, S_IRUGO | S_IWUSR, 962 show_in0_max, set_in0_max, 9); 963 static SENSOR_DEVICE_ATTR(in9_min, S_IRUGO | S_IWUSR, 964 show_in0_min, set_in0_min, 9); 965 static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, show_in0, NULL, 10); 966 static SENSOR_DEVICE_ATTR(in10_max, S_IRUGO | S_IWUSR, 967 show_in0_max, set_in0_max, 10); 968 static SENSOR_DEVICE_ATTR(in10_min, S_IRUGO | S_IWUSR, 969 show_in0_min, set_in0_min, 10); 970 971 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0); 972 static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR, 973 show_fan_min, set_fan_min, 0); 974 static SENSOR_DEVICE_ATTR(fan1_target, S_IRUGO | S_IWUSR, 975 show_fan_target, set_fan_target, 0); 976 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1); 977 static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO | S_IWUSR, 978 show_fan_min, set_fan_min, 1); 979 static SENSOR_DEVICE_ATTR(fan2_target, S_IRUGO | S_IWUSR, 980 show_fan_target, set_fan_target, 1); 981 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2); 982 static SENSOR_DEVICE_ATTR(fan3_min, S_IRUGO | S_IWUSR, 983 show_fan_min, set_fan_min, 2); 984 static SENSOR_DEVICE_ATTR(fan3_target, S_IRUGO | S_IWUSR, 985 show_fan_target, set_fan_target, 2); 986 987 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0); 988 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, 989 show_temp_max, set_temp_max, 0); 990 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, 991 show_temp_hyst, set_temp_hyst, 0); 992 static SENSOR_DEVICE_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0); 993 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1); 994 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR, 995 show_temp_max, set_temp_max, 1); 996 static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR, 997 show_temp_hyst, set_temp_hyst, 1); 998 static SENSOR_DEVICE_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1); 999 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2); 1000 static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO | S_IWUSR, 1001 show_temp_max, set_temp_max, 2); 1002 static SENSOR_DEVICE_ATTR(temp3_max_hyst, S_IRUGO | S_IWUSR, 1003 show_temp_hyst, set_temp_hyst, 2); 1004 static SENSOR_DEVICE_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2); 1005 1006 /* pwm (value) files are created read-only, write permission is 1007 then added or removed dynamically as needed */ 1008 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO, show_pwm, set_pwm, 0); 1009 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR, 1010 show_pwm_enable, set_pwm_enable, 0); 1011 static SENSOR_DEVICE_ATTR(pwm1_freq, S_IRUGO | S_IWUSR, 1012 show_pwm_freq, set_pwm_freq, 0); 1013 static SENSOR_DEVICE_ATTR(pwm1_mode, S_IRUGO, show_pwm_mode, NULL, 0); 1014 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO, show_pwm, set_pwm, 1); 1015 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IRUGO | S_IWUSR, 1016 show_pwm_enable, set_pwm_enable, 1); 1017 static SENSOR_DEVICE_ATTR(pwm2_freq, S_IRUGO | S_IWUSR, 1018 show_pwm_freq, set_pwm_freq, 1); 1019 static SENSOR_DEVICE_ATTR(pwm2_mode, S_IRUGO, show_pwm_mode, NULL, 1); 1020 static SENSOR_DEVICE_ATTR(pwm3, S_IRUGO, show_pwm, set_pwm, 2); 1021 static SENSOR_DEVICE_ATTR(pwm3_enable, S_IRUGO | S_IWUSR, 1022 show_pwm_enable, set_pwm_enable, 2); 1023 static SENSOR_DEVICE_ATTR(pwm3_freq, S_IRUGO | S_IWUSR, 1024 show_pwm_freq, set_pwm_freq, 2); 1025 static SENSOR_DEVICE_ATTR(pwm3_mode, S_IRUGO, show_pwm_mode, NULL, 2); 1026 1027 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point1_temp, S_IRUGO | S_IWUSR, 1028 show_pwm_auto_point_temp, set_pwm_auto_point_temp, 1029 0, 0); 1030 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point1_fan, S_IRUGO | S_IWUSR, 1031 show_pwm_auto_point_fan, set_pwm_auto_point_fan, 1032 0, 0); 1033 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point2_temp, S_IRUGO | S_IWUSR, 1034 show_pwm_auto_point_temp, set_pwm_auto_point_temp, 1035 0, 1); 1036 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point2_fan, S_IRUGO | S_IWUSR, 1037 show_pwm_auto_point_fan, set_pwm_auto_point_fan, 1038 0, 1); 1039 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point3_temp, S_IRUGO | S_IWUSR, 1040 show_pwm_auto_point_temp, set_pwm_auto_point_temp, 1041 0, 2); 1042 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point3_fan, S_IRUGO | S_IWUSR, 1043 show_pwm_auto_point_fan, set_pwm_auto_point_fan, 1044 0, 2); 1045 1046 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point1_temp, S_IRUGO | S_IWUSR, 1047 show_pwm_auto_point_temp, set_pwm_auto_point_temp, 1048 1, 0); 1049 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point1_fan, S_IRUGO | S_IWUSR, 1050 show_pwm_auto_point_fan, set_pwm_auto_point_fan, 1051 1, 0); 1052 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point2_temp, S_IRUGO | S_IWUSR, 1053 show_pwm_auto_point_temp, set_pwm_auto_point_temp, 1054 1, 1); 1055 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point2_fan, S_IRUGO | S_IWUSR, 1056 show_pwm_auto_point_fan, set_pwm_auto_point_fan, 1057 1, 1); 1058 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point3_temp, S_IRUGO | S_IWUSR, 1059 show_pwm_auto_point_temp, set_pwm_auto_point_temp, 1060 1, 2); 1061 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point3_fan, S_IRUGO | S_IWUSR, 1062 show_pwm_auto_point_fan, set_pwm_auto_point_fan, 1063 1, 2); 1064 1065 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point1_temp, S_IRUGO | S_IWUSR, 1066 show_pwm_auto_point_temp, set_pwm_auto_point_temp, 1067 2, 0); 1068 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point1_fan, S_IRUGO | S_IWUSR, 1069 show_pwm_auto_point_fan, set_pwm_auto_point_fan, 1070 2, 0); 1071 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point2_temp, S_IRUGO | S_IWUSR, 1072 show_pwm_auto_point_temp, set_pwm_auto_point_temp, 1073 2, 1); 1074 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point2_fan, S_IRUGO | S_IWUSR, 1075 show_pwm_auto_point_fan, set_pwm_auto_point_fan, 1076 2, 1); 1077 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point3_temp, S_IRUGO | S_IWUSR, 1078 show_pwm_auto_point_temp, set_pwm_auto_point_temp, 1079 2, 2); 1080 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point3_fan, S_IRUGO | S_IWUSR, 1081 show_pwm_auto_point_fan, set_pwm_auto_point_fan, 1082 2, 2); 1083 1084 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0); 1085 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1); 1086 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2); 1087 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3); 1088 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 4); 1089 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 5); 1090 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 6); 1091 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 7); 1092 static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 8); 1093 static SENSOR_DEVICE_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 9); 1094 static SENSOR_DEVICE_ATTR(in10_alarm, S_IRUGO, show_alarm, NULL, 10); 1095 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 11); 1096 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 12); 1097 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13); 1098 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 16); 1099 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 17); 1100 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 18); 1101 static DEVICE_ATTR(alarms_in, S_IRUGO, show_alarms_in, NULL); 1102 static DEVICE_ATTR(alarms_fan, S_IRUGO, show_alarms_fan, NULL); 1103 static DEVICE_ATTR(alarms_temp, S_IRUGO, show_alarms_temp, NULL); 1104 1105 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); 1106 1107 static struct attribute *f71805f_attributes[] = { 1108 &sensor_dev_attr_in0_input.dev_attr.attr, 1109 &sensor_dev_attr_in0_max.dev_attr.attr, 1110 &sensor_dev_attr_in0_min.dev_attr.attr, 1111 &sensor_dev_attr_in1_input.dev_attr.attr, 1112 &sensor_dev_attr_in1_max.dev_attr.attr, 1113 &sensor_dev_attr_in1_min.dev_attr.attr, 1114 &sensor_dev_attr_in2_input.dev_attr.attr, 1115 &sensor_dev_attr_in2_max.dev_attr.attr, 1116 &sensor_dev_attr_in2_min.dev_attr.attr, 1117 &sensor_dev_attr_in3_input.dev_attr.attr, 1118 &sensor_dev_attr_in3_max.dev_attr.attr, 1119 &sensor_dev_attr_in3_min.dev_attr.attr, 1120 &sensor_dev_attr_in5_input.dev_attr.attr, 1121 &sensor_dev_attr_in5_max.dev_attr.attr, 1122 &sensor_dev_attr_in5_min.dev_attr.attr, 1123 &sensor_dev_attr_in6_input.dev_attr.attr, 1124 &sensor_dev_attr_in6_max.dev_attr.attr, 1125 &sensor_dev_attr_in6_min.dev_attr.attr, 1126 &sensor_dev_attr_in7_input.dev_attr.attr, 1127 &sensor_dev_attr_in7_max.dev_attr.attr, 1128 &sensor_dev_attr_in7_min.dev_attr.attr, 1129 1130 &sensor_dev_attr_fan1_input.dev_attr.attr, 1131 &sensor_dev_attr_fan1_min.dev_attr.attr, 1132 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 1133 &sensor_dev_attr_fan1_target.dev_attr.attr, 1134 &sensor_dev_attr_fan2_input.dev_attr.attr, 1135 &sensor_dev_attr_fan2_min.dev_attr.attr, 1136 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 1137 &sensor_dev_attr_fan2_target.dev_attr.attr, 1138 &sensor_dev_attr_fan3_input.dev_attr.attr, 1139 &sensor_dev_attr_fan3_min.dev_attr.attr, 1140 &sensor_dev_attr_fan3_alarm.dev_attr.attr, 1141 &sensor_dev_attr_fan3_target.dev_attr.attr, 1142 1143 &sensor_dev_attr_pwm1.dev_attr.attr, 1144 &sensor_dev_attr_pwm1_enable.dev_attr.attr, 1145 &sensor_dev_attr_pwm1_mode.dev_attr.attr, 1146 &sensor_dev_attr_pwm2.dev_attr.attr, 1147 &sensor_dev_attr_pwm2_enable.dev_attr.attr, 1148 &sensor_dev_attr_pwm2_mode.dev_attr.attr, 1149 &sensor_dev_attr_pwm3.dev_attr.attr, 1150 &sensor_dev_attr_pwm3_enable.dev_attr.attr, 1151 &sensor_dev_attr_pwm3_mode.dev_attr.attr, 1152 1153 &sensor_dev_attr_temp1_input.dev_attr.attr, 1154 &sensor_dev_attr_temp1_max.dev_attr.attr, 1155 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr, 1156 &sensor_dev_attr_temp1_type.dev_attr.attr, 1157 &sensor_dev_attr_temp2_input.dev_attr.attr, 1158 &sensor_dev_attr_temp2_max.dev_attr.attr, 1159 &sensor_dev_attr_temp2_max_hyst.dev_attr.attr, 1160 &sensor_dev_attr_temp2_type.dev_attr.attr, 1161 &sensor_dev_attr_temp3_input.dev_attr.attr, 1162 &sensor_dev_attr_temp3_max.dev_attr.attr, 1163 &sensor_dev_attr_temp3_max_hyst.dev_attr.attr, 1164 &sensor_dev_attr_temp3_type.dev_attr.attr, 1165 1166 &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr, 1167 &sensor_dev_attr_pwm1_auto_point1_fan.dev_attr.attr, 1168 &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr, 1169 &sensor_dev_attr_pwm1_auto_point2_fan.dev_attr.attr, 1170 &sensor_dev_attr_pwm1_auto_point3_temp.dev_attr.attr, 1171 &sensor_dev_attr_pwm1_auto_point3_fan.dev_attr.attr, 1172 &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr, 1173 &sensor_dev_attr_pwm2_auto_point1_fan.dev_attr.attr, 1174 &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr, 1175 &sensor_dev_attr_pwm2_auto_point2_fan.dev_attr.attr, 1176 &sensor_dev_attr_pwm2_auto_point3_temp.dev_attr.attr, 1177 &sensor_dev_attr_pwm2_auto_point3_fan.dev_attr.attr, 1178 &sensor_dev_attr_pwm3_auto_point1_temp.dev_attr.attr, 1179 &sensor_dev_attr_pwm3_auto_point1_fan.dev_attr.attr, 1180 &sensor_dev_attr_pwm3_auto_point2_temp.dev_attr.attr, 1181 &sensor_dev_attr_pwm3_auto_point2_fan.dev_attr.attr, 1182 &sensor_dev_attr_pwm3_auto_point3_temp.dev_attr.attr, 1183 &sensor_dev_attr_pwm3_auto_point3_fan.dev_attr.attr, 1184 1185 &sensor_dev_attr_in0_alarm.dev_attr.attr, 1186 &sensor_dev_attr_in1_alarm.dev_attr.attr, 1187 &sensor_dev_attr_in2_alarm.dev_attr.attr, 1188 &sensor_dev_attr_in3_alarm.dev_attr.attr, 1189 &sensor_dev_attr_in5_alarm.dev_attr.attr, 1190 &sensor_dev_attr_in6_alarm.dev_attr.attr, 1191 &sensor_dev_attr_in7_alarm.dev_attr.attr, 1192 &dev_attr_alarms_in.attr, 1193 &sensor_dev_attr_temp1_alarm.dev_attr.attr, 1194 &sensor_dev_attr_temp2_alarm.dev_attr.attr, 1195 &sensor_dev_attr_temp3_alarm.dev_attr.attr, 1196 &dev_attr_alarms_temp.attr, 1197 &dev_attr_alarms_fan.attr, 1198 1199 &dev_attr_name.attr, 1200 NULL 1201 }; 1202 1203 static const struct attribute_group f71805f_group = { 1204 .attrs = f71805f_attributes, 1205 }; 1206 1207 static struct attribute *f71805f_attributes_optin[4][5] = { 1208 { 1209 &sensor_dev_attr_in4_input.dev_attr.attr, 1210 &sensor_dev_attr_in4_max.dev_attr.attr, 1211 &sensor_dev_attr_in4_min.dev_attr.attr, 1212 &sensor_dev_attr_in4_alarm.dev_attr.attr, 1213 NULL 1214 }, { 1215 &sensor_dev_attr_in8_input.dev_attr.attr, 1216 &sensor_dev_attr_in8_max.dev_attr.attr, 1217 &sensor_dev_attr_in8_min.dev_attr.attr, 1218 &sensor_dev_attr_in8_alarm.dev_attr.attr, 1219 NULL 1220 }, { 1221 &sensor_dev_attr_in9_input.dev_attr.attr, 1222 &sensor_dev_attr_in9_max.dev_attr.attr, 1223 &sensor_dev_attr_in9_min.dev_attr.attr, 1224 &sensor_dev_attr_in9_alarm.dev_attr.attr, 1225 NULL 1226 }, { 1227 &sensor_dev_attr_in10_input.dev_attr.attr, 1228 &sensor_dev_attr_in10_max.dev_attr.attr, 1229 &sensor_dev_attr_in10_min.dev_attr.attr, 1230 &sensor_dev_attr_in10_alarm.dev_attr.attr, 1231 NULL 1232 } 1233 }; 1234 1235 static const struct attribute_group f71805f_group_optin[4] = { 1236 { .attrs = f71805f_attributes_optin[0] }, 1237 { .attrs = f71805f_attributes_optin[1] }, 1238 { .attrs = f71805f_attributes_optin[2] }, 1239 { .attrs = f71805f_attributes_optin[3] }, 1240 }; 1241 1242 /* We don't include pwm_freq files in the arrays above, because they must be 1243 created conditionally (only if pwm_mode is 1 == PWM) */ 1244 static struct attribute *f71805f_attributes_pwm_freq[] = { 1245 &sensor_dev_attr_pwm1_freq.dev_attr.attr, 1246 &sensor_dev_attr_pwm2_freq.dev_attr.attr, 1247 &sensor_dev_attr_pwm3_freq.dev_attr.attr, 1248 NULL 1249 }; 1250 1251 static const struct attribute_group f71805f_group_pwm_freq = { 1252 .attrs = f71805f_attributes_pwm_freq, 1253 }; 1254 1255 /* We also need an indexed access to pwmN files to toggle writability */ 1256 static struct attribute *f71805f_attr_pwm[] = { 1257 &sensor_dev_attr_pwm1.dev_attr.attr, 1258 &sensor_dev_attr_pwm2.dev_attr.attr, 1259 &sensor_dev_attr_pwm3.dev_attr.attr, 1260 }; 1261 1262 /* 1263 * Device registration and initialization 1264 */ 1265 1266 static void __devinit f71805f_init_device(struct f71805f_data *data) 1267 { 1268 u8 reg; 1269 int i; 1270 1271 reg = f71805f_read8(data, F71805F_REG_START); 1272 if ((reg & 0x41) != 0x01) { 1273 printk(KERN_DEBUG DRVNAME ": Starting monitoring " 1274 "operations\n"); 1275 f71805f_write8(data, F71805F_REG_START, (reg | 0x01) & ~0x40); 1276 } 1277 1278 /* Fan monitoring can be disabled. If it is, we won't be polling 1279 the register values, and won't create the related sysfs files. */ 1280 for (i = 0; i < 3; i++) { 1281 data->fan_ctrl[i] = f71805f_read8(data, 1282 F71805F_REG_FAN_CTRL(i)); 1283 /* Clear latch full bit, else "speed mode" fan speed control 1284 doesn't work */ 1285 if (data->fan_ctrl[i] & FAN_CTRL_LATCH_FULL) { 1286 data->fan_ctrl[i] &= ~FAN_CTRL_LATCH_FULL; 1287 f71805f_write8(data, F71805F_REG_FAN_CTRL(i), 1288 data->fan_ctrl[i]); 1289 } 1290 } 1291 } 1292 1293 static int __devinit f71805f_probe(struct platform_device *pdev) 1294 { 1295 struct f71805f_sio_data *sio_data = pdev->dev.platform_data; 1296 struct f71805f_data *data; 1297 struct resource *res; 1298 int i, err; 1299 1300 static const char *names[] = { 1301 "f71805f", 1302 "f71872f", 1303 }; 1304 1305 if (!(data = kzalloc(sizeof(struct f71805f_data), GFP_KERNEL))) { 1306 err = -ENOMEM; 1307 printk(KERN_ERR DRVNAME ": Out of memory\n"); 1308 goto exit; 1309 } 1310 1311 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 1312 if (!request_region(res->start + ADDR_REG_OFFSET, 2, DRVNAME)) { 1313 err = -EBUSY; 1314 dev_err(&pdev->dev, "Failed to request region 0x%lx-0x%lx\n", 1315 (unsigned long)(res->start + ADDR_REG_OFFSET), 1316 (unsigned long)(res->start + ADDR_REG_OFFSET + 1)); 1317 goto exit_free; 1318 } 1319 data->addr = res->start; 1320 data->name = names[sio_data->kind]; 1321 mutex_init(&data->update_lock); 1322 1323 platform_set_drvdata(pdev, data); 1324 1325 /* Some voltage inputs depend on chip model and configuration */ 1326 switch (sio_data->kind) { 1327 case f71805f: 1328 data->has_in = 0x1ff; 1329 break; 1330 case f71872f: 1331 data->has_in = 0x6ef; 1332 if (sio_data->fnsel1 & 0x01) 1333 data->has_in |= (1 << 4); /* in4 */ 1334 if (sio_data->fnsel1 & 0x02) 1335 data->has_in |= (1 << 8); /* in8 */ 1336 break; 1337 } 1338 1339 /* Initialize the F71805F chip */ 1340 f71805f_init_device(data); 1341 1342 /* Register sysfs interface files */ 1343 if ((err = sysfs_create_group(&pdev->dev.kobj, &f71805f_group))) 1344 goto exit_release_region; 1345 if (data->has_in & (1 << 4)) { /* in4 */ 1346 if ((err = sysfs_create_group(&pdev->dev.kobj, 1347 &f71805f_group_optin[0]))) 1348 goto exit_remove_files; 1349 } 1350 if (data->has_in & (1 << 8)) { /* in8 */ 1351 if ((err = sysfs_create_group(&pdev->dev.kobj, 1352 &f71805f_group_optin[1]))) 1353 goto exit_remove_files; 1354 } 1355 if (data->has_in & (1 << 9)) { /* in9 (F71872F/FG only) */ 1356 if ((err = sysfs_create_group(&pdev->dev.kobj, 1357 &f71805f_group_optin[2]))) 1358 goto exit_remove_files; 1359 } 1360 if (data->has_in & (1 << 10)) { /* in9 (F71872F/FG only) */ 1361 if ((err = sysfs_create_group(&pdev->dev.kobj, 1362 &f71805f_group_optin[3]))) 1363 goto exit_remove_files; 1364 } 1365 for (i = 0; i < 3; i++) { 1366 /* If control mode is PWM, create pwm_freq file */ 1367 if (!(data->fan_ctrl[i] & FAN_CTRL_DC_MODE)) { 1368 if ((err = sysfs_create_file(&pdev->dev.kobj, 1369 f71805f_attributes_pwm_freq[i]))) 1370 goto exit_remove_files; 1371 } 1372 /* If PWM is in manual mode, add write permission */ 1373 if (data->fan_ctrl[i] & FAN_CTRL_MODE_MANUAL) { 1374 if ((err = sysfs_chmod_file(&pdev->dev.kobj, 1375 f71805f_attr_pwm[i], 1376 S_IRUGO | S_IWUSR))) { 1377 dev_err(&pdev->dev, "chmod +w pwm%d failed\n", 1378 i + 1); 1379 goto exit_remove_files; 1380 } 1381 } 1382 } 1383 1384 data->hwmon_dev = hwmon_device_register(&pdev->dev); 1385 if (IS_ERR(data->hwmon_dev)) { 1386 err = PTR_ERR(data->hwmon_dev); 1387 dev_err(&pdev->dev, "Class registration failed (%d)\n", err); 1388 goto exit_remove_files; 1389 } 1390 1391 return 0; 1392 1393 exit_remove_files: 1394 sysfs_remove_group(&pdev->dev.kobj, &f71805f_group); 1395 for (i = 0; i < 4; i++) 1396 sysfs_remove_group(&pdev->dev.kobj, &f71805f_group_optin[i]); 1397 sysfs_remove_group(&pdev->dev.kobj, &f71805f_group_pwm_freq); 1398 exit_release_region: 1399 release_region(res->start + ADDR_REG_OFFSET, 2); 1400 exit_free: 1401 platform_set_drvdata(pdev, NULL); 1402 kfree(data); 1403 exit: 1404 return err; 1405 } 1406 1407 static int __devexit f71805f_remove(struct platform_device *pdev) 1408 { 1409 struct f71805f_data *data = platform_get_drvdata(pdev); 1410 struct resource *res; 1411 int i; 1412 1413 hwmon_device_unregister(data->hwmon_dev); 1414 sysfs_remove_group(&pdev->dev.kobj, &f71805f_group); 1415 for (i = 0; i < 4; i++) 1416 sysfs_remove_group(&pdev->dev.kobj, &f71805f_group_optin[i]); 1417 sysfs_remove_group(&pdev->dev.kobj, &f71805f_group_pwm_freq); 1418 platform_set_drvdata(pdev, NULL); 1419 kfree(data); 1420 1421 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 1422 release_region(res->start + ADDR_REG_OFFSET, 2); 1423 1424 return 0; 1425 } 1426 1427 static struct platform_driver f71805f_driver = { 1428 .driver = { 1429 .owner = THIS_MODULE, 1430 .name = DRVNAME, 1431 }, 1432 .probe = f71805f_probe, 1433 .remove = __devexit_p(f71805f_remove), 1434 }; 1435 1436 static int __init f71805f_device_add(unsigned short address, 1437 const struct f71805f_sio_data *sio_data) 1438 { 1439 struct resource res = { 1440 .start = address, 1441 .end = address + REGION_LENGTH - 1, 1442 .flags = IORESOURCE_IO, 1443 }; 1444 int err; 1445 1446 pdev = platform_device_alloc(DRVNAME, address); 1447 if (!pdev) { 1448 err = -ENOMEM; 1449 printk(KERN_ERR DRVNAME ": Device allocation failed\n"); 1450 goto exit; 1451 } 1452 1453 res.name = pdev->name; 1454 err = platform_device_add_resources(pdev, &res, 1); 1455 if (err) { 1456 printk(KERN_ERR DRVNAME ": Device resource addition failed " 1457 "(%d)\n", err); 1458 goto exit_device_put; 1459 } 1460 1461 err = platform_device_add_data(pdev, sio_data, 1462 sizeof(struct f71805f_sio_data)); 1463 if (err) { 1464 printk(KERN_ERR DRVNAME ": Platform data allocation failed\n"); 1465 goto exit_device_put; 1466 } 1467 1468 err = platform_device_add(pdev); 1469 if (err) { 1470 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n", 1471 err); 1472 goto exit_device_put; 1473 } 1474 1475 return 0; 1476 1477 exit_device_put: 1478 platform_device_put(pdev); 1479 exit: 1480 return err; 1481 } 1482 1483 static int __init f71805f_find(int sioaddr, unsigned short *address, 1484 struct f71805f_sio_data *sio_data) 1485 { 1486 int err = -ENODEV; 1487 u16 devid; 1488 1489 static const char *names[] = { 1490 "F71805F/FG", 1491 "F71872F/FG or F71806F/FG", 1492 }; 1493 1494 superio_enter(sioaddr); 1495 1496 devid = superio_inw(sioaddr, SIO_REG_MANID); 1497 if (devid != SIO_FINTEK_ID) 1498 goto exit; 1499 1500 devid = superio_inw(sioaddr, SIO_REG_DEVID); 1501 switch (devid) { 1502 case SIO_F71805F_ID: 1503 sio_data->kind = f71805f; 1504 break; 1505 case SIO_F71872F_ID: 1506 sio_data->kind = f71872f; 1507 sio_data->fnsel1 = superio_inb(sioaddr, SIO_REG_FNSEL1); 1508 break; 1509 default: 1510 printk(KERN_INFO DRVNAME ": Unsupported Fintek device, " 1511 "skipping\n"); 1512 goto exit; 1513 } 1514 1515 superio_select(sioaddr, F71805F_LD_HWM); 1516 if (!(superio_inb(sioaddr, SIO_REG_ENABLE) & 0x01)) { 1517 printk(KERN_WARNING DRVNAME ": Device not activated, " 1518 "skipping\n"); 1519 goto exit; 1520 } 1521 1522 *address = superio_inw(sioaddr, SIO_REG_ADDR); 1523 if (*address == 0) { 1524 printk(KERN_WARNING DRVNAME ": Base address not set, " 1525 "skipping\n"); 1526 goto exit; 1527 } 1528 *address &= ~(REGION_LENGTH - 1); /* Ignore 3 LSB */ 1529 1530 err = 0; 1531 printk(KERN_INFO DRVNAME ": Found %s chip at %#x, revision %u\n", 1532 names[sio_data->kind], *address, 1533 superio_inb(sioaddr, SIO_REG_DEVREV)); 1534 1535 exit: 1536 superio_exit(sioaddr); 1537 return err; 1538 } 1539 1540 static int __init f71805f_init(void) 1541 { 1542 int err; 1543 unsigned short address; 1544 struct f71805f_sio_data sio_data; 1545 1546 if (f71805f_find(0x2e, &address, &sio_data) 1547 && f71805f_find(0x4e, &address, &sio_data)) 1548 return -ENODEV; 1549 1550 err = platform_driver_register(&f71805f_driver); 1551 if (err) 1552 goto exit; 1553 1554 /* Sets global pdev as a side effect */ 1555 err = f71805f_device_add(address, &sio_data); 1556 if (err) 1557 goto exit_driver; 1558 1559 return 0; 1560 1561 exit_driver: 1562 platform_driver_unregister(&f71805f_driver); 1563 exit: 1564 return err; 1565 } 1566 1567 static void __exit f71805f_exit(void) 1568 { 1569 platform_device_unregister(pdev); 1570 platform_driver_unregister(&f71805f_driver); 1571 } 1572 1573 MODULE_AUTHOR("Jean Delvare <khali@linux-fr>"); 1574 MODULE_LICENSE("GPL"); 1575 MODULE_DESCRIPTION("F71805F/F71872F hardware monitoring driver"); 1576 1577 module_init(f71805f_init); 1578 module_exit(f71805f_exit); 1579