OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [hwmon/] [f71805f.c] - Blame information for rev 78

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.