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