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