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