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