?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
BUG_ON() Conversion in kernel/printk.c
[linux-2.6/kvm.git] / drivers / hwmon / f71805f.c
blob885465df6e6a68db40f89c0d1b64c87efaf089c7
1 /*
2 * f71805f.c - driver for the Fintek F71805F/FG Super-I/O chip integrated
3 * hardware monitoring features
4 * Copyright (C) 2005 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 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25 #include <linux/module.h>
26 #include <linux/init.h>
27 #include <linux/slab.h>
28 #include <linux/jiffies.h>
29 #include <linux/platform_device.h>
30 #include <linux/hwmon.h>
31 #include <linux/hwmon-sysfs.h>
32 #include <linux/err.h>
33 #include <linux/mutex.h>
34 #include <asm/io.h>
35
36 static struct platform_device *pdev;
37
38 #define DRVNAME "f71805f"
39
40 /*
41 * Super-I/O constants and functions
42 */
43
44 #define F71805F_LD_HWM 0x04
45
46 #define SIO_REG_LDSEL 0x07 /* Logical device select */
47 #define SIO_REG_DEVID 0x20 /* Device ID (2 bytes) */
48 #define SIO_REG_DEVREV 0x22 /* Device revision */
49 #define SIO_REG_MANID 0x23 /* Fintek ID (2 bytes) */
50 #define SIO_REG_ENABLE 0x30 /* Logical device enable */
51 #define SIO_REG_ADDR 0x60 /* Logical device address (2 bytes) */
52
53 #define SIO_FINTEK_ID 0x1934
54 #define SIO_F71805F_ID 0x0406
55
56 static inline int
57 superio_inb(int base, int reg)
58 {
59 outb(reg, base);
60 return inb(base + 1);
61 }
62
63 static int
64 superio_inw(int base, int reg)
65 {
66 int val;
67 outb(reg++, base);
68 val = inb(base + 1) << 8;
69 outb(reg, base);
70 val |= inb(base + 1);
71 return val;
72 }
73
74 static inline void
75 superio_select(int base, int ld)
76 {
77 outb(SIO_REG_LDSEL, base);
78 outb(ld, base + 1);
79 }
80
81 static inline void
82 superio_enter(int base)
83 {
84 outb(0x87, base);
85 outb(0x87, base);
86 }
87
88 static inline void
89 superio_exit(int base)
90 {
91 outb(0xaa, base);
92 }
93
94 /*
95 * ISA constants
96 */
97
98 #define REGION_LENGTH 2
99 #define ADDR_REG_OFFSET 0
100 #define DATA_REG_OFFSET 1
101
102 static struct resource f71805f_resource __initdata = {
103 .flags = IORESOURCE_IO,
104 };
105
106 /*
107 * Registers
108 */
109
110 /* in nr from 0 to 8 (8-bit values) */
111 #define F71805F_REG_IN(nr) (0x10 + (nr))
112 #define F71805F_REG_IN_HIGH(nr) (0x40 + 2 * (nr))
113 #define F71805F_REG_IN_LOW(nr) (0x41 + 2 * (nr))
114 /* fan nr from 0 to 2 (12-bit values, two registers) */
115 #define F71805F_REG_FAN(nr) (0x20 + 2 * (nr))
116 #define F71805F_REG_FAN_LOW(nr) (0x28 + 2 * (nr))
117 #define F71805F_REG_FAN_CTRL(nr) (0x60 + 16 * (nr))
118 /* temp nr from 0 to 2 (8-bit values) */
119 #define F71805F_REG_TEMP(nr) (0x1B + (nr))
120 #define F71805F_REG_TEMP_HIGH(nr) (0x54 + 2 * (nr))
121 #define F71805F_REG_TEMP_HYST(nr) (0x55 + 2 * (nr))
122 #define F71805F_REG_TEMP_MODE 0x01
123
124 #define F71805F_REG_START 0x00
125 /* status nr from 0 to 2 */
126 #define F71805F_REG_STATUS(nr) (0x36 + (nr))
127
128 /*
129 * Data structures and manipulation thereof
130 */
131
132 struct f71805f_data {
133 unsigned short addr;
134 const char *name;
135 struct mutex lock;
136 struct class_device *class_dev;
137
138 struct mutex update_lock;
139 char valid; /* !=0 if following fields are valid */
140 unsigned long last_updated; /* In jiffies */
141 unsigned long last_limits; /* In jiffies */
142
143 /* Register values */
144 u8 in[9];
145 u8 in_high[9];
146 u8 in_low[9];
147 u16 fan[3];
148 u16 fan_low[3];
149 u8 fan_enabled; /* Read once at init time */
150 u8 temp[3];
151 u8 temp_high[3];
152 u8 temp_hyst[3];
153 u8 temp_mode;
154 u8 alarms[3];
155 };
156
157 static inline long in_from_reg(u8 reg)
158 {
159 return (reg * 8);
160 }
161
162 /* The 2 least significant bits are not used */
163 static inline u8 in_to_reg(long val)
164 {
165 if (val <= 0)
166 return 0;
167 if (val >= 2016)
168 return 0xfc;
169 return (((val + 16) / 32) << 2);
170 }
171
172 /* in0 is downscaled by a factor 2 internally */
173 static inline long in0_from_reg(u8 reg)
174 {
175 return (reg * 16);
176 }
177
178 static inline u8 in0_to_reg(long val)
179 {
180 if (val <= 0)
181 return 0;
182 if (val >= 4032)
183 return 0xfc;
184 return (((val + 32) / 64) << 2);
185 }
186
187 /* The 4 most significant bits are not used */
188 static inline long fan_from_reg(u16 reg)
189 {
190 reg &= 0xfff;
191 if (!reg || reg == 0xfff)
192 return 0;
193 return (1500000 / reg);
194 }
195
196 static inline u16 fan_to_reg(long rpm)
197 {
198 /* If the low limit is set below what the chip can measure,
199 store the largest possible 12-bit value in the registers,
200 so that no alarm will ever trigger. */
201 if (rpm < 367)
202 return 0xfff;
203 return (1500000 / rpm);
204 }
205
206 static inline long temp_from_reg(u8 reg)
207 {
208 return (reg * 1000);
209 }
210
211 static inline u8 temp_to_reg(long val)
212 {
213 if (val < 0)
214 val = 0;
215 else if (val > 1000 * 0xff)
216 val = 0xff;
217 return ((val + 500) / 1000);
218 }
219
220 /*
221 * Device I/O access
222 */
223
224 static u8 f71805f_read8(struct f71805f_data *data, u8 reg)
225 {
226 u8 val;
227
228 mutex_lock(&data->lock);
229 outb(reg, data->addr + ADDR_REG_OFFSET);
230 val = inb(data->addr + DATA_REG_OFFSET);
231 mutex_unlock(&data->lock);
232
233 return val;
234 }
235
236 static void f71805f_write8(struct f71805f_data *data, u8 reg, u8 val)
237 {
238 mutex_lock(&data->lock);
239 outb(reg, data->addr + ADDR_REG_OFFSET);
240 outb(val, data->addr + DATA_REG_OFFSET);
241 mutex_unlock(&data->lock);
242 }
243
244 /* It is important to read the MSB first, because doing so latches the
245 value of the LSB, so we are sure both bytes belong to the same value. */
246 static u16 f71805f_read16(struct f71805f_data *data, u8 reg)
247 {
248 u16 val;
249
250 mutex_lock(&data->lock);
251 outb(reg, data->addr + ADDR_REG_OFFSET);
252 val = inb(data->addr + DATA_REG_OFFSET) << 8;
253 outb(++reg, data->addr + ADDR_REG_OFFSET);
254 val |= inb(data->addr + DATA_REG_OFFSET);
255 mutex_unlock(&data->lock);
256
257 return val;
258 }
259
260 static void f71805f_write16(struct f71805f_data *data, u8 reg, u16 val)
261 {
262 mutex_lock(&data->lock);
263 outb(reg, data->addr + ADDR_REG_OFFSET);
264 outb(val >> 8, data->addr + DATA_REG_OFFSET);
265 outb(++reg, data->addr + ADDR_REG_OFFSET);
266 outb(val & 0xff, data->addr + DATA_REG_OFFSET);
267 mutex_unlock(&data->lock);
268 }
269
270 static struct f71805f_data *f71805f_update_device(struct device *dev)
271 {
272 struct f71805f_data *data = dev_get_drvdata(dev);
273 int nr;
274
275 mutex_lock(&data->update_lock);
276
277 /* Limit registers cache is refreshed after 60 seconds */
278 if (time_after(jiffies, data->last_updated + 60 * HZ)
279 || !data->valid) {
280 for (nr = 0; nr < 9; nr++) {
281 data->in_high[nr] = f71805f_read8(data,
282 F71805F_REG_IN_HIGH(nr));
283 data->in_low[nr] = f71805f_read8(data,
284 F71805F_REG_IN_LOW(nr));
285 }
286 for (nr = 0; nr < 3; nr++) {
287 if (data->fan_enabled & (1 << nr))
288 data->fan_low[nr] = f71805f_read16(data,
289 F71805F_REG_FAN_LOW(nr));
290 }
291 for (nr = 0; nr < 3; nr++) {
292 data->temp_high[nr] = f71805f_read8(data,
293 F71805F_REG_TEMP_HIGH(nr));
294 data->temp_hyst[nr] = f71805f_read8(data,
295 F71805F_REG_TEMP_HYST(nr));
296 }
297 data->temp_mode = f71805f_read8(data, F71805F_REG_TEMP_MODE);
298
299 data->last_limits = jiffies;
300 }
301
302 /* Measurement registers cache is refreshed after 1 second */
303 if (time_after(jiffies, data->last_updated + HZ)
304 || !data->valid) {
305 for (nr = 0; nr < 9; nr++) {
306 data->in[nr] = f71805f_read8(data,
307 F71805F_REG_IN(nr));
308 }
309 for (nr = 0; nr < 3; nr++) {
310 if (data->fan_enabled & (1 << nr))
311 data->fan[nr] = f71805f_read16(data,
312 F71805F_REG_FAN(nr));
313 }
314 for (nr = 0; nr < 3; nr++) {
315 data->temp[nr] = f71805f_read8(data,
316 F71805F_REG_TEMP(nr));
317 }
318 for (nr = 0; nr < 3; nr++) {
319 data->alarms[nr] = f71805f_read8(data,
320 F71805F_REG_STATUS(nr));
321 }
322
323 data->last_updated = jiffies;
324 data->valid = 1;
325 }
326
327 mutex_unlock(&data->update_lock);
328
329 return data;
330 }
331
332 /*
333 * Sysfs interface
334 */
335
336 static ssize_t show_in0(struct device *dev, struct device_attribute *devattr,
337 char *buf)
338 {
339 struct f71805f_data *data = f71805f_update_device(dev);
340
341 return sprintf(buf, "%ld\n", in0_from_reg(data->in[0]));
342 }
343
344 static ssize_t show_in0_max(struct device *dev, struct device_attribute
345 *devattr, char *buf)
346 {
347 struct f71805f_data *data = f71805f_update_device(dev);
348
349 return sprintf(buf, "%ld\n", in0_from_reg(data->in_high[0]));
350 }
351
352 static ssize_t show_in0_min(struct device *dev, struct device_attribute
353 *devattr, char *buf)
354 {
355 struct f71805f_data *data = f71805f_update_device(dev);
356
357 return sprintf(buf, "%ld\n", in0_from_reg(data->in_low[0]));
358 }
359
360 static ssize_t set_in0_max(struct device *dev, struct device_attribute
361 *devattr, const char *buf, size_t count)
362 {
363 struct f71805f_data *data = dev_get_drvdata(dev);
364 long val = simple_strtol(buf, NULL, 10);
365
366 mutex_lock(&data->update_lock);
367 data->in_high[0] = in0_to_reg(val);
368 f71805f_write8(data, F71805F_REG_IN_HIGH(0), data->in_high[0]);
369 mutex_unlock(&data->update_lock);
370
371 return count;
372 }
373
374 static ssize_t set_in0_min(struct device *dev, struct device_attribute
375 *devattr, const char *buf, size_t count)
376 {
377 struct f71805f_data *data = dev_get_drvdata(dev);
378 long val = simple_strtol(buf, NULL, 10);
379
380 mutex_lock(&data->update_lock);
381 data->in_low[0] = in0_to_reg(val);
382 f71805f_write8(data, F71805F_REG_IN_LOW(0), data->in_low[0]);
383 mutex_unlock(&data->update_lock);
384
385 return count;
386 }
387
388 static ssize_t show_in(struct device *dev, struct device_attribute *devattr,
389 char *buf)
390 {
391 struct f71805f_data *data = f71805f_update_device(dev);
392 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
393 int nr = attr->index;
394
395 return sprintf(buf, "%ld\n", in_from_reg(data->in[nr]));
396 }
397
398 static ssize_t show_in_max(struct device *dev, struct device_attribute
399 *devattr, char *buf)
400 {
401 struct f71805f_data *data = f71805f_update_device(dev);
402 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
403 int nr = attr->index;
404
405 return sprintf(buf, "%ld\n", in_from_reg(data->in_high[nr]));
406 }
407
408 static ssize_t show_in_min(struct device *dev, struct device_attribute
409 *devattr, char *buf)
410 {
411 struct f71805f_data *data = f71805f_update_device(dev);
412 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
413 int nr = attr->index;
414
415 return sprintf(buf, "%ld\n", in_from_reg(data->in_low[nr]));
416 }
417
418 static ssize_t set_in_max(struct device *dev, struct device_attribute
419 *devattr, const char *buf, size_t count)
420 {
421 struct f71805f_data *data = dev_get_drvdata(dev);
422 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
423 int nr = attr->index;
424 long val = simple_strtol(buf, NULL, 10);
425
426 mutex_lock(&data->update_lock);
427 data->in_high[nr] = in_to_reg(val);
428 f71805f_write8(data, F71805F_REG_IN_HIGH(nr), data->in_high[nr]);
429 mutex_unlock(&data->update_lock);
430
431 return count;
432 }
433
434 static ssize_t set_in_min(struct device *dev, struct device_attribute
435 *devattr, const char *buf, size_t count)
436 {
437 struct f71805f_data *data = dev_get_drvdata(dev);
438 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
439 int nr = attr->index;
440 long val = simple_strtol(buf, NULL, 10);
441
442 mutex_lock(&data->update_lock);
443 data->in_low[nr] = in_to_reg(val);
444 f71805f_write8(data, F71805F_REG_IN_LOW(nr), data->in_low[nr]);
445 mutex_unlock(&data->update_lock);
446
447 return count;
448 }
449
450 static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
451 char *buf)
452 {
453 struct f71805f_data *data = f71805f_update_device(dev);
454 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
455 int nr = attr->index;
456
457 return sprintf(buf, "%ld\n", fan_from_reg(data->fan[nr]));
458 }
459
460 static ssize_t show_fan_min(struct device *dev, struct device_attribute
461 *devattr, char *buf)
462 {
463 struct f71805f_data *data = f71805f_update_device(dev);
464 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
465 int nr = attr->index;
466
467 return sprintf(buf, "%ld\n", fan_from_reg(data->fan_low[nr]));
468 }
469
470 static ssize_t set_fan_min(struct device *dev, struct device_attribute
471 *devattr, const char *buf, size_t count)
472 {
473 struct f71805f_data *data = dev_get_drvdata(dev);
474 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
475 int nr = attr->index;
476 long val = simple_strtol(buf, NULL, 10);
477
478 mutex_lock(&data->update_lock);
479 data->fan_low[nr] = fan_to_reg(val);
480 f71805f_write16(data, F71805F_REG_FAN_LOW(nr), data->fan_low[nr]);
481 mutex_unlock(&data->update_lock);
482
483 return count;
484 }
485
486 static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
487 char *buf)
488 {
489 struct f71805f_data *data = f71805f_update_device(dev);
490 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
491 int nr = attr->index;
492
493 return sprintf(buf, "%ld\n", temp_from_reg(data->temp[nr]));
494 }
495
496 static ssize_t show_temp_max(struct device *dev, struct device_attribute
497 *devattr, char *buf)
498 {
499 struct f71805f_data *data = f71805f_update_device(dev);
500 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
501 int nr = attr->index;
502
503 return sprintf(buf, "%ld\n", temp_from_reg(data->temp_high[nr]));
504 }
505
506 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute
507 *devattr, char *buf)
508 {
509 struct f71805f_data *data = f71805f_update_device(dev);
510 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
511 int nr = attr->index;
512
513 return sprintf(buf, "%ld\n", temp_from_reg(data->temp_hyst[nr]));
514 }
515
516 static ssize_t show_temp_type(struct device *dev, struct device_attribute
517 *devattr, char *buf)
518 {
519 struct f71805f_data *data = f71805f_update_device(dev);
520 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
521 int nr = attr->index;
522
523 /* 3 is diode, 4 is thermistor */
524 return sprintf(buf, "%u\n", (data->temp_mode & (1 << nr)) ? 3 : 4);
525 }
526
527 static ssize_t set_temp_max(struct device *dev, struct device_attribute
528 *devattr, const char *buf, size_t count)
529 {
530 struct f71805f_data *data = dev_get_drvdata(dev);
531 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
532 int nr = attr->index;
533 long val = simple_strtol(buf, NULL, 10);
534
535 mutex_lock(&data->update_lock);
536 data->temp_high[nr] = temp_to_reg(val);
537 f71805f_write8(data, F71805F_REG_TEMP_HIGH(nr), data->temp_high[nr]);
538 mutex_unlock(&data->update_lock);
539
540 return count;
541 }
542
543 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute
544 *devattr, const char *buf, size_t count)
545 {
546 struct f71805f_data *data = dev_get_drvdata(dev);
547 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
548 int nr = attr->index;
549 long val = simple_strtol(buf, NULL, 10);
550
551 mutex_lock(&data->update_lock);
552 data->temp_hyst[nr] = temp_to_reg(val);
553 f71805f_write8(data, F71805F_REG_TEMP_HYST(nr), data->temp_hyst[nr]);
554 mutex_unlock(&data->update_lock);
555
556 return count;
557 }
558
559 static ssize_t show_alarms_in(struct device *dev, struct device_attribute
560 *devattr, char *buf)
561 {
562 struct f71805f_data *data = f71805f_update_device(dev);
563
564 return sprintf(buf, "%d\n", data->alarms[0] |
565 ((data->alarms[1] & 0x01) << 8));
566 }
567
568 static ssize_t show_alarms_fan(struct device *dev, struct device_attribute
569 *devattr, char *buf)
570 {
571 struct f71805f_data *data = f71805f_update_device(dev);
572
573 return sprintf(buf, "%d\n", data->alarms[2] & 0x07);
574 }
575
576 static ssize_t show_alarms_temp(struct device *dev, struct device_attribute
577 *devattr, char *buf)
578 {
579 struct f71805f_data *data = f71805f_update_device(dev);
580
581 return sprintf(buf, "%d\n", (data->alarms[1] >> 3) & 0x07);
582 }
583
584 static ssize_t show_name(struct device *dev, struct device_attribute
585 *devattr, char *buf)
586 {
587 struct f71805f_data *data = dev_get_drvdata(dev);
588
589 return sprintf(buf, "%s\n", data->name);
590 }
591
592 static struct device_attribute f71805f_dev_attr[] = {
593 __ATTR(in0_input, S_IRUGO, show_in0, NULL),
594 __ATTR(in0_max, S_IRUGO| S_IWUSR, show_in0_max, set_in0_max),
595 __ATTR(in0_min, S_IRUGO| S_IWUSR, show_in0_min, set_in0_min),
596 __ATTR(alarms_in, S_IRUGO, show_alarms_in, NULL),
597 __ATTR(alarms_fan, S_IRUGO, show_alarms_fan, NULL),
598 __ATTR(alarms_temp, S_IRUGO, show_alarms_temp, NULL),
599 __ATTR(name, S_IRUGO, show_name, NULL),
600 };
601
602 static struct sensor_device_attribute f71805f_sensor_attr[] = {
603 SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
604 SENSOR_ATTR(in1_max, S_IRUGO | S_IWUSR,
605 show_in_max, set_in_max, 1),
606 SENSOR_ATTR(in1_min, S_IRUGO | S_IWUSR,
607 show_in_min, set_in_min, 1),
608 SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
609 SENSOR_ATTR(in2_max, S_IRUGO | S_IWUSR,
610 show_in_max, set_in_max, 2),
611 SENSOR_ATTR(in2_min, S_IRUGO | S_IWUSR,
612 show_in_min, set_in_min, 2),
613 SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
614 SENSOR_ATTR(in3_max, S_IRUGO | S_IWUSR,
615 show_in_max, set_in_max, 3),
616 SENSOR_ATTR(in3_min, S_IRUGO | S_IWUSR,
617 show_in_min, set_in_min, 3),
618 SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
619 SENSOR_ATTR(in4_max, S_IRUGO | S_IWUSR,
620 show_in_max, set_in_max, 4),
621 SENSOR_ATTR(in4_min, S_IRUGO | S_IWUSR,
622 show_in_min, set_in_min, 4),
623 SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
624 SENSOR_ATTR(in5_max, S_IRUGO | S_IWUSR,
625 show_in_max, set_in_max, 5),
626 SENSOR_ATTR(in5_min, S_IRUGO | S_IWUSR,
627 show_in_min, set_in_min, 5),
628 SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
629 SENSOR_ATTR(in6_max, S_IRUGO | S_IWUSR,
630 show_in_max, set_in_max, 6),
631 SENSOR_ATTR(in6_min, S_IRUGO | S_IWUSR,
632 show_in_min, set_in_min, 6),
633 SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
634 SENSOR_ATTR(in7_max, S_IRUGO | S_IWUSR,
635 show_in_max, set_in_max, 7),
636 SENSOR_ATTR(in7_min, S_IRUGO | S_IWUSR,
637 show_in_min, set_in_min, 7),
638 SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
639 SENSOR_ATTR(in8_max, S_IRUGO | S_IWUSR,
640 show_in_max, set_in_max, 8),
641 SENSOR_ATTR(in8_min, S_IRUGO | S_IWUSR,
642 show_in_min, set_in_min, 8),
643
644 SENSOR_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0),
645 SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR,
646 show_temp_max, set_temp_max, 0),
647 SENSOR_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
648 show_temp_hyst, set_temp_hyst, 0),
649 SENSOR_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0),
650 SENSOR_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1),
651 SENSOR_ATTR(temp2_max, S_IRUGO | S_IWUSR,
652 show_temp_max, set_temp_max, 1),
653 SENSOR_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR,
654 show_temp_hyst, set_temp_hyst, 1),
655 SENSOR_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1),
656 SENSOR_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2),
657 SENSOR_ATTR(temp3_max, S_IRUGO | S_IWUSR,
658 show_temp_max, set_temp_max, 2),
659 SENSOR_ATTR(temp3_max_hyst, S_IRUGO | S_IWUSR,
660 show_temp_hyst, set_temp_hyst, 2),
661 SENSOR_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2),
662 };
663
664 static struct sensor_device_attribute f71805f_fan_attr[] = {
665 SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
666 SENSOR_ATTR(fan1_min, S_IRUGO | S_IWUSR,
667 show_fan_min, set_fan_min, 0),
668 SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
669 SENSOR_ATTR(fan2_min, S_IRUGO | S_IWUSR,
670 show_fan_min, set_fan_min, 1),
671 SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
672 SENSOR_ATTR(fan3_min, S_IRUGO | S_IWUSR,
673 show_fan_min, set_fan_min, 2),
674 };
675
676 /*
677 * Device registration and initialization
678 */
679
680 static void __devinit f71805f_init_device(struct f71805f_data *data)
681 {
682 u8 reg;
683 int i;
684
685 reg = f71805f_read8(data, F71805F_REG_START);
686 if ((reg & 0x41) != 0x01) {
687 printk(KERN_DEBUG DRVNAME ": Starting monitoring "
688 "operations\n");
689 f71805f_write8(data, F71805F_REG_START, (reg | 0x01) & ~0x40);
690 }
691
692 /* Fan monitoring can be disabled. If it is, we won't be polling
693 the register values, and won't create the related sysfs files. */
694 for (i = 0; i < 3; i++) {
695 reg = f71805f_read8(data, F71805F_REG_FAN_CTRL(i));
696 if (!(reg & 0x80))
697 data->fan_enabled |= (1 << i);
698 }
699 }
700
701 static int __devinit f71805f_probe(struct platform_device *pdev)
702 {
703 struct f71805f_data *data;
704 struct resource *res;
705 int i, err;
706
707 if (!(data = kzalloc(sizeof(struct f71805f_data), GFP_KERNEL))) {
708 err = -ENOMEM;
709 printk(KERN_ERR DRVNAME ": Out of memory\n");
710 goto exit;
711 }
712
713 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
714 data->addr = res->start;
715 mutex_init(&data->lock);
716 data->name = "f71805f";
717 mutex_init(&data->update_lock);
718
719 platform_set_drvdata(pdev, data);
720
721 data->class_dev = hwmon_device_register(&pdev->dev);
722 if (IS_ERR(data->class_dev)) {
723 err = PTR_ERR(data->class_dev);
724 dev_err(&pdev->dev, "Class registration failed (%d)\n", err);
725 goto exit_free;
726 }
727
728 /* Initialize the F71805F chip */
729 f71805f_init_device(data);
730
731 /* Register sysfs interface files */
732 for (i = 0; i < ARRAY_SIZE(f71805f_dev_attr); i++) {
733 err = device_create_file(&pdev->dev, &f71805f_dev_attr[i]);
734 if (err)
735 goto exit_class;
736 }
737 for (i = 0; i < ARRAY_SIZE(f71805f_sensor_attr); i++) {
738 err = device_create_file(&pdev->dev,
739 &f71805f_sensor_attr[i].dev_attr);
740 if (err)
741 goto exit_class;
742 }
743 for (i = 0; i < ARRAY_SIZE(f71805f_fan_attr); i++) {
744 if (!(data->fan_enabled & (1 << (i / 2))))
745 continue;
746 err = device_create_file(&pdev->dev,
747 &f71805f_fan_attr[i].dev_attr);
748 if (err)
749 goto exit_class;
750 }
751
752 return 0;
753
754 exit_class:
755 dev_err(&pdev->dev, "Sysfs interface creation failed\n");
756 hwmon_device_unregister(data->class_dev);
757 exit_free:
758 kfree(data);
759 exit:
760 return err;
761 }
762
763 static int __devexit f71805f_remove(struct platform_device *pdev)
764 {
765 struct f71805f_data *data = platform_get_drvdata(pdev);
766
767 platform_set_drvdata(pdev, NULL);
768 hwmon_device_unregister(data->class_dev);
769 kfree(data);
770
771 return 0;
772 }
773
774 static struct platform_driver f71805f_driver = {
775 .driver = {
776 .owner = THIS_MODULE,
777 .name = DRVNAME,
778 },
779 .probe = f71805f_probe,
780 .remove = __devexit_p(f71805f_remove),
781 };
782
783 static int __init f71805f_device_add(unsigned short address)
784 {
785 int err;
786
787 pdev = platform_device_alloc(DRVNAME, address);
788 if (!pdev) {
789 err = -ENOMEM;
790 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
791 goto exit;
792 }
793
794 f71805f_resource.start = address;
795 f71805f_resource.end = address + REGION_LENGTH - 1;
796 f71805f_resource.name = pdev->name;
797 err = platform_device_add_resources(pdev, &f71805f_resource, 1);
798 if (err) {
799 printk(KERN_ERR DRVNAME ": Device resource addition failed "
800 "(%d)\n", err);
801 goto exit_device_put;
802 }
803
804 err = platform_device_add(pdev);
805 if (err) {
806 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
807 err);
808 goto exit_device_put;
809 }
810
811 return 0;
812
813 exit_device_put:
814 platform_device_put(pdev);
815 exit:
816 return err;
817 }
818
819 static int __init f71805f_find(int sioaddr, unsigned short *address)
820 {
821 int err = -ENODEV;
822 u16 devid;
823
824 superio_enter(sioaddr);
825
826 devid = superio_inw(sioaddr, SIO_REG_MANID);
827 if (devid != SIO_FINTEK_ID)
828 goto exit;
829
830 devid = superio_inw(sioaddr, SIO_REG_DEVID);
831 if (devid != SIO_F71805F_ID) {
832 printk(KERN_INFO DRVNAME ": Unsupported Fintek device, "
833 "skipping\n");
834 goto exit;
835 }
836
837 superio_select(sioaddr, F71805F_LD_HWM);
838 if (!(superio_inb(sioaddr, SIO_REG_ENABLE) & 0x01)) {
839 printk(KERN_WARNING DRVNAME ": Device not activated, "
840 "skipping\n");
841 goto exit;
842 }
843
844 *address = superio_inw(sioaddr, SIO_REG_ADDR);
845 if (*address == 0) {
846 printk(KERN_WARNING DRVNAME ": Base address not set, "
847 "skipping\n");
848 goto exit;
849 }
850
851 err = 0;
852 printk(KERN_INFO DRVNAME ": Found F71805F chip at %#x, revision %u\n",
853 *address, superio_inb(sioaddr, SIO_REG_DEVREV));
854
855 exit:
856 superio_exit(sioaddr);
857 return err;
858 }
859
860 static int __init f71805f_init(void)
861 {
862 int err;
863 unsigned short address;
864
865 if (f71805f_find(0x2e, &address)
866 && f71805f_find(0x4e, &address))
867 return -ENODEV;
868
869 err = platform_driver_register(&f71805f_driver);
870 if (err)
871 goto exit;
872
873 /* Sets global pdev as a side effect */
874 err = f71805f_device_add(address);
875 if (err)
876 goto exit_driver;
877
878 return 0;
879
880 exit_driver:
881 platform_driver_unregister(&f71805f_driver);
882 exit:
883 return err;
884 }
885
886 static void __exit f71805f_exit(void)
887 {
888 platform_device_unregister(pdev);
889 platform_driver_unregister(&f71805f_driver);
890 }
891
892 MODULE_AUTHOR("Jean Delvare <khali@linux-fr>");
893 MODULE_LICENSE("GPL");
894 MODULE_DESCRIPTION("F71805F hardware monitoring driver");
895
896 module_init(f71805f_init);
897 module_exit(f71805f_exit);
kernel-based virtual machine