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