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