drivers/hwmon/f71805f.c

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