]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - drivers/hwmon/it87.c
[PATCH] hwmon: tag super-i/o find functions __init
[mirror_ubuntu-zesty-kernel.git] / drivers / hwmon / it87.c
CommitLineData
1da177e4
LT
1/*
2 it87.c - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring.
4
5 Supports: IT8705F Super I/O chip w/LPC interface & SMBus
6 IT8712F Super I/O chip w/LPC interface & SMBus
7 Sis950 A clone of the IT8705F
8
9 Copyright (C) 2001 Chris Gauthron <chrisg@0-in.com>
10 Largely inspired by lm78.c of the same package
11
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25*/
26
27/*
28 djg@pdp8.net David Gesswein 7/18/01
29 Modified to fix bug with not all alarms enabled.
30 Added ability to read battery voltage and select temperature sensor
31 type at module load time.
32*/
33
1da177e4
LT
34#include <linux/module.h>
35#include <linux/init.h>
36#include <linux/slab.h>
37#include <linux/jiffies.h>
38#include <linux/i2c.h>
fde09509 39#include <linux/i2c-isa.h>
1da177e4
LT
40#include <linux/i2c-sensor.h>
41#include <linux/i2c-vid.h>
10c08f81 42#include <linux/hwmon-sysfs.h>
943b0830
MH
43#include <linux/hwmon.h>
44#include <linux/err.h>
1da177e4
LT
45#include <asm/io.h>
46
47
48/* Addresses to scan */
49static unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
50 0x2e, 0x2f, I2C_CLIENT_END };
2d8672c5 51static unsigned short isa_address = 0x290;
1da177e4
LT
52
53/* Insmod parameters */
54SENSORS_INSMOD_2(it87, it8712);
55
56#define REG 0x2e /* The register to read/write */
57#define DEV 0x07 /* Register: Logical device select */
58#define VAL 0x2f /* The value to read/write */
59#define PME 0x04 /* The device with the fan registers in it */
60#define DEVID 0x20 /* Register: Device ID */
61#define DEVREV 0x22 /* Register: Device Revision */
62
63static inline int
64superio_inb(int reg)
65{
66 outb(reg, REG);
67 return inb(VAL);
68}
69
70static int superio_inw(int reg)
71{
72 int val;
73 outb(reg++, REG);
74 val = inb(VAL) << 8;
75 outb(reg, REG);
76 val |= inb(VAL);
77 return val;
78}
79
80static inline void
81superio_select(void)
82{
83 outb(DEV, REG);
84 outb(PME, VAL);
85}
86
87static inline void
88superio_enter(void)
89{
90 outb(0x87, REG);
91 outb(0x01, REG);
92 outb(0x55, REG);
93 outb(0x55, REG);
94}
95
96static inline void
97superio_exit(void)
98{
99 outb(0x02, REG);
100 outb(0x02, VAL);
101}
102
103#define IT8712F_DEVID 0x8712
104#define IT8705F_DEVID 0x8705
105#define IT87_ACT_REG 0x30
106#define IT87_BASE_REG 0x60
107
108/* Update battery voltage after every reading if true */
109static int update_vbat;
110
111/* Not all BIOSes properly configure the PWM registers */
112static int fix_pwm_polarity;
113
114/* Chip Type */
115
116static u16 chip_type;
117
118/* Many IT87 constants specified below */
119
120/* Length of ISA address segment */
121#define IT87_EXTENT 8
122
123/* Where are the ISA address/data registers relative to the base address */
124#define IT87_ADDR_REG_OFFSET 5
125#define IT87_DATA_REG_OFFSET 6
126
127/*----- The IT87 registers -----*/
128
129#define IT87_REG_CONFIG 0x00
130
131#define IT87_REG_ALARM1 0x01
132#define IT87_REG_ALARM2 0x02
133#define IT87_REG_ALARM3 0x03
134
135#define IT87_REG_VID 0x0a
136#define IT87_REG_FAN_DIV 0x0b
137
138/* Monitors: 9 voltage (0 to 7, battery), 3 temp (1 to 3), 3 fan (1 to 3) */
139
140#define IT87_REG_FAN(nr) (0x0d + (nr))
141#define IT87_REG_FAN_MIN(nr) (0x10 + (nr))
142#define IT87_REG_FAN_MAIN_CTRL 0x13
143#define IT87_REG_FAN_CTL 0x14
144#define IT87_REG_PWM(nr) (0x15 + (nr))
145
146#define IT87_REG_VIN(nr) (0x20 + (nr))
147#define IT87_REG_TEMP(nr) (0x29 + (nr))
148
149#define IT87_REG_VIN_MAX(nr) (0x30 + (nr) * 2)
150#define IT87_REG_VIN_MIN(nr) (0x31 + (nr) * 2)
151#define IT87_REG_TEMP_HIGH(nr) (0x40 + (nr) * 2)
152#define IT87_REG_TEMP_LOW(nr) (0x41 + (nr) * 2)
153
154#define IT87_REG_I2C_ADDR 0x48
155
156#define IT87_REG_VIN_ENABLE 0x50
157#define IT87_REG_TEMP_ENABLE 0x51
158
159#define IT87_REG_CHIPID 0x58
160
161#define IN_TO_REG(val) (SENSORS_LIMIT((((val) + 8)/16),0,255))
162#define IN_FROM_REG(val) ((val) * 16)
163
164static inline u8 FAN_TO_REG(long rpm, int div)
165{
166 if (rpm == 0)
167 return 255;
168 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
169 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
170 254);
171}
172
173#define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
174
175#define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-500)/1000):\
176 ((val)+500)/1000),-128,127))
177#define TEMP_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*1000)
178
1da177e4
LT
179#define PWM_TO_REG(val) ((val) >> 1)
180#define PWM_FROM_REG(val) (((val)&0x7f) << 1)
181
182static int DIV_TO_REG(int val)
183{
184 int answer = 0;
185 while ((val >>= 1) != 0)
186 answer++;
187 return answer;
188}
189#define DIV_FROM_REG(val) (1 << (val))
190
191
192/* For each registered IT87, we need to keep some data in memory. That
193 data is pointed to by it87_list[NR]->data. The structure itself is
194 dynamically allocated, at the same time when a new it87 client is
195 allocated. */
196struct it87_data {
197 struct i2c_client client;
943b0830 198 struct class_device *class_dev;
1da177e4
LT
199 struct semaphore lock;
200 enum chips type;
201
202 struct semaphore update_lock;
203 char valid; /* !=0 if following fields are valid */
204 unsigned long last_updated; /* In jiffies */
205
206 u8 in[9]; /* Register value */
207 u8 in_max[9]; /* Register value */
208 u8 in_min[9]; /* Register value */
209 u8 fan[3]; /* Register value */
210 u8 fan_min[3]; /* Register value */
211 u8 temp[3]; /* Register value */
212 u8 temp_high[3]; /* Register value */
213 u8 temp_low[3]; /* Register value */
214 u8 sensor; /* Register value */
215 u8 fan_div[3]; /* Register encoding, shifted right */
216 u8 vid; /* Register encoding, combined */
217 int vrm;
218 u32 alarms; /* Register encoding, combined */
219 u8 fan_main_ctrl; /* Register value */
220 u8 manual_pwm_ctl[3]; /* manual PWM value set by user */
221};
222
223
224static int it87_attach_adapter(struct i2c_adapter *adapter);
2d8672c5 225static int it87_isa_attach_adapter(struct i2c_adapter *adapter);
1da177e4
LT
226static int it87_detect(struct i2c_adapter *adapter, int address, int kind);
227static int it87_detach_client(struct i2c_client *client);
228
229static int it87_read_value(struct i2c_client *client, u8 register);
230static int it87_write_value(struct i2c_client *client, u8 register,
231 u8 value);
232static struct it87_data *it87_update_device(struct device *dev);
233static int it87_check_pwm(struct i2c_client *client);
234static void it87_init_client(struct i2c_client *client, struct it87_data *data);
235
236
237static struct i2c_driver it87_driver = {
238 .owner = THIS_MODULE,
239 .name = "it87",
240 .id = I2C_DRIVERID_IT87,
241 .flags = I2C_DF_NOTIFY,
242 .attach_adapter = it87_attach_adapter,
243 .detach_client = it87_detach_client,
244};
245
fde09509
JD
246static struct i2c_driver it87_isa_driver = {
247 .owner = THIS_MODULE,
248 .name = "it87-isa",
2d8672c5 249 .attach_adapter = it87_isa_attach_adapter,
fde09509
JD
250 .detach_client = it87_detach_client,
251};
252
253
20ad93d4
JD
254static ssize_t show_in(struct device *dev, struct device_attribute *attr,
255 char *buf)
1da177e4 256{
20ad93d4
JD
257 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
258 int nr = sensor_attr->index;
259
1da177e4
LT
260 struct it87_data *data = it87_update_device(dev);
261 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
262}
263
20ad93d4
JD
264static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
265 char *buf)
1da177e4 266{
20ad93d4
JD
267 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
268 int nr = sensor_attr->index;
269
1da177e4
LT
270 struct it87_data *data = it87_update_device(dev);
271 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
272}
273
20ad93d4
JD
274static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
275 char *buf)
1da177e4 276{
20ad93d4
JD
277 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
278 int nr = sensor_attr->index;
279
1da177e4
LT
280 struct it87_data *data = it87_update_device(dev);
281 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
282}
283
20ad93d4
JD
284static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
285 const char *buf, size_t count)
1da177e4 286{
20ad93d4
JD
287 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
288 int nr = sensor_attr->index;
289
1da177e4
LT
290 struct i2c_client *client = to_i2c_client(dev);
291 struct it87_data *data = i2c_get_clientdata(client);
292 unsigned long val = simple_strtoul(buf, NULL, 10);
293
294 down(&data->update_lock);
295 data->in_min[nr] = IN_TO_REG(val);
296 it87_write_value(client, IT87_REG_VIN_MIN(nr),
297 data->in_min[nr]);
298 up(&data->update_lock);
299 return count;
300}
20ad93d4
JD
301static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
302 const char *buf, size_t count)
1da177e4 303{
20ad93d4
JD
304 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
305 int nr = sensor_attr->index;
306
1da177e4
LT
307 struct i2c_client *client = to_i2c_client(dev);
308 struct it87_data *data = i2c_get_clientdata(client);
309 unsigned long val = simple_strtoul(buf, NULL, 10);
310
311 down(&data->update_lock);
312 data->in_max[nr] = IN_TO_REG(val);
313 it87_write_value(client, IT87_REG_VIN_MAX(nr),
314 data->in_max[nr]);
315 up(&data->update_lock);
316 return count;
317}
318
319#define show_in_offset(offset) \
20ad93d4
JD
320static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
321 show_in, NULL, offset);
1da177e4
LT
322
323#define limit_in_offset(offset) \
20ad93d4
JD
324static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
325 show_in_min, set_in_min, offset); \
326static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
327 show_in_max, set_in_max, offset);
1da177e4
LT
328
329show_in_offset(0);
330limit_in_offset(0);
331show_in_offset(1);
332limit_in_offset(1);
333show_in_offset(2);
334limit_in_offset(2);
335show_in_offset(3);
336limit_in_offset(3);
337show_in_offset(4);
338limit_in_offset(4);
339show_in_offset(5);
340limit_in_offset(5);
341show_in_offset(6);
342limit_in_offset(6);
343show_in_offset(7);
344limit_in_offset(7);
345show_in_offset(8);
346
347/* 3 temperatures */
20ad93d4
JD
348static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
349 char *buf)
1da177e4 350{
20ad93d4
JD
351 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
352 int nr = sensor_attr->index;
353
1da177e4
LT
354 struct it87_data *data = it87_update_device(dev);
355 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
356}
20ad93d4
JD
357static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
358 char *buf)
1da177e4 359{
20ad93d4
JD
360 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
361 int nr = sensor_attr->index;
362
1da177e4
LT
363 struct it87_data *data = it87_update_device(dev);
364 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_high[nr]));
365}
20ad93d4
JD
366static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
367 char *buf)
1da177e4 368{
20ad93d4
JD
369 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
370 int nr = sensor_attr->index;
371
1da177e4
LT
372 struct it87_data *data = it87_update_device(dev);
373 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_low[nr]));
374}
20ad93d4
JD
375static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
376 const char *buf, size_t count)
1da177e4 377{
20ad93d4
JD
378 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
379 int nr = sensor_attr->index;
380
1da177e4
LT
381 struct i2c_client *client = to_i2c_client(dev);
382 struct it87_data *data = i2c_get_clientdata(client);
383 int val = simple_strtol(buf, NULL, 10);
384
385 down(&data->update_lock);
386 data->temp_high[nr] = TEMP_TO_REG(val);
387 it87_write_value(client, IT87_REG_TEMP_HIGH(nr), data->temp_high[nr]);
388 up(&data->update_lock);
389 return count;
390}
20ad93d4
JD
391static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
392 const char *buf, size_t count)
1da177e4 393{
20ad93d4
JD
394 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
395 int nr = sensor_attr->index;
396
1da177e4
LT
397 struct i2c_client *client = to_i2c_client(dev);
398 struct it87_data *data = i2c_get_clientdata(client);
399 int val = simple_strtol(buf, NULL, 10);
400
401 down(&data->update_lock);
402 data->temp_low[nr] = TEMP_TO_REG(val);
403 it87_write_value(client, IT87_REG_TEMP_LOW(nr), data->temp_low[nr]);
404 up(&data->update_lock);
405 return count;
406}
407#define show_temp_offset(offset) \
20ad93d4
JD
408static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
409 show_temp, NULL, offset - 1); \
410static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
411 show_temp_max, set_temp_max, offset - 1); \
412static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
413 show_temp_min, set_temp_min, offset - 1);
1da177e4
LT
414
415show_temp_offset(1);
416show_temp_offset(2);
417show_temp_offset(3);
418
20ad93d4
JD
419static ssize_t show_sensor(struct device *dev, struct device_attribute *attr,
420 char *buf)
1da177e4 421{
20ad93d4
JD
422 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
423 int nr = sensor_attr->index;
424
1da177e4
LT
425 struct it87_data *data = it87_update_device(dev);
426 u8 reg = data->sensor; /* In case the value is updated while we use it */
427
428 if (reg & (1 << nr))
429 return sprintf(buf, "3\n"); /* thermal diode */
430 if (reg & (8 << nr))
431 return sprintf(buf, "2\n"); /* thermistor */
432 return sprintf(buf, "0\n"); /* disabled */
433}
20ad93d4
JD
434static ssize_t set_sensor(struct device *dev, struct device_attribute *attr,
435 const char *buf, size_t count)
1da177e4 436{
20ad93d4
JD
437 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
438 int nr = sensor_attr->index;
439
1da177e4
LT
440 struct i2c_client *client = to_i2c_client(dev);
441 struct it87_data *data = i2c_get_clientdata(client);
442 int val = simple_strtol(buf, NULL, 10);
443
444 down(&data->update_lock);
445
446 data->sensor &= ~(1 << nr);
447 data->sensor &= ~(8 << nr);
448 /* 3 = thermal diode; 2 = thermistor; 0 = disabled */
449 if (val == 3)
450 data->sensor |= 1 << nr;
451 else if (val == 2)
452 data->sensor |= 8 << nr;
453 else if (val != 0) {
454 up(&data->update_lock);
455 return -EINVAL;
456 }
457 it87_write_value(client, IT87_REG_TEMP_ENABLE, data->sensor);
458 up(&data->update_lock);
459 return count;
460}
461#define show_sensor_offset(offset) \
20ad93d4
JD
462static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO | S_IWUSR, \
463 show_sensor, set_sensor, offset - 1);
1da177e4
LT
464
465show_sensor_offset(1);
466show_sensor_offset(2);
467show_sensor_offset(3);
468
469/* 3 Fans */
20ad93d4
JD
470static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
471 char *buf)
1da177e4 472{
20ad93d4
JD
473 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
474 int nr = sensor_attr->index;
475
1da177e4
LT
476 struct it87_data *data = it87_update_device(dev);
477 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan[nr],
478 DIV_FROM_REG(data->fan_div[nr])));
479}
20ad93d4
JD
480static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
481 char *buf)
1da177e4 482{
20ad93d4
JD
483 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
484 int nr = sensor_attr->index;
485
1da177e4
LT
486 struct it87_data *data = it87_update_device(dev);
487 return sprintf(buf,"%d\n",
488 FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])));
489}
20ad93d4
JD
490static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
491 char *buf)
1da177e4 492{
20ad93d4
JD
493 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
494 int nr = sensor_attr->index;
495
1da177e4
LT
496 struct it87_data *data = it87_update_device(dev);
497 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
498}
20ad93d4
JD
499static ssize_t show_pwm_enable(struct device *dev, struct device_attribute *attr,
500 char *buf)
1da177e4 501{
20ad93d4
JD
502 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
503 int nr = sensor_attr->index;
504
1da177e4
LT
505 struct it87_data *data = it87_update_device(dev);
506 return sprintf(buf,"%d\n", (data->fan_main_ctrl & (1 << nr)) ? 1 : 0);
507}
20ad93d4
JD
508static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
509 char *buf)
1da177e4 510{
20ad93d4
JD
511 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
512 int nr = sensor_attr->index;
513
1da177e4
LT
514 struct it87_data *data = it87_update_device(dev);
515 return sprintf(buf,"%d\n", data->manual_pwm_ctl[nr]);
516}
20ad93d4
JD
517static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
518 const char *buf, size_t count)
1da177e4 519{
20ad93d4
JD
520 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
521 int nr = sensor_attr->index;
522
1da177e4
LT
523 struct i2c_client *client = to_i2c_client(dev);
524 struct it87_data *data = i2c_get_clientdata(client);
525 int val = simple_strtol(buf, NULL, 10);
526
527 down(&data->update_lock);
528 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
529 it87_write_value(client, IT87_REG_FAN_MIN(nr), data->fan_min[nr]);
530 up(&data->update_lock);
531 return count;
532}
20ad93d4
JD
533static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
534 const char *buf, size_t count)
1da177e4 535{
20ad93d4
JD
536 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
537 int nr = sensor_attr->index;
538
1da177e4
LT
539 struct i2c_client *client = to_i2c_client(dev);
540 struct it87_data *data = i2c_get_clientdata(client);
541 int val = simple_strtol(buf, NULL, 10);
542 int i, min[3];
543 u8 old;
544
545 down(&data->update_lock);
546 old = it87_read_value(client, IT87_REG_FAN_DIV);
547
548 for (i = 0; i < 3; i++)
549 min[i] = FAN_FROM_REG(data->fan_min[i], DIV_FROM_REG(data->fan_div[i]));
550
551 switch (nr) {
552 case 0:
553 case 1:
554 data->fan_div[nr] = DIV_TO_REG(val);
555 break;
556 case 2:
557 if (val < 8)
558 data->fan_div[nr] = 1;
559 else
560 data->fan_div[nr] = 3;
561 }
562 val = old & 0x80;
563 val |= (data->fan_div[0] & 0x07);
564 val |= (data->fan_div[1] & 0x07) << 3;
565 if (data->fan_div[2] == 3)
566 val |= 0x1 << 6;
567 it87_write_value(client, IT87_REG_FAN_DIV, val);
568
569 for (i = 0; i < 3; i++) {
570 data->fan_min[i]=FAN_TO_REG(min[i], DIV_FROM_REG(data->fan_div[i]));
571 it87_write_value(client, IT87_REG_FAN_MIN(i), data->fan_min[i]);
572 }
573 up(&data->update_lock);
574 return count;
575}
20ad93d4
JD
576static ssize_t set_pwm_enable(struct device *dev,
577 struct device_attribute *attr, const char *buf, size_t count)
1da177e4 578{
20ad93d4
JD
579 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
580 int nr = sensor_attr->index;
581
1da177e4
LT
582 struct i2c_client *client = to_i2c_client(dev);
583 struct it87_data *data = i2c_get_clientdata(client);
584 int val = simple_strtol(buf, NULL, 10);
585
586 down(&data->update_lock);
587
588 if (val == 0) {
589 int tmp;
590 /* make sure the fan is on when in on/off mode */
591 tmp = it87_read_value(client, IT87_REG_FAN_CTL);
592 it87_write_value(client, IT87_REG_FAN_CTL, tmp | (1 << nr));
593 /* set on/off mode */
594 data->fan_main_ctrl &= ~(1 << nr);
595 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
596 } else if (val == 1) {
597 /* set SmartGuardian mode */
598 data->fan_main_ctrl |= (1 << nr);
599 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
600 /* set saved pwm value, clear FAN_CTLX PWM mode bit */
601 it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
602 } else {
603 up(&data->update_lock);
604 return -EINVAL;
605 }
606
607 up(&data->update_lock);
608 return count;
609}
20ad93d4
JD
610static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
611 const char *buf, size_t count)
1da177e4 612{
20ad93d4
JD
613 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
614 int nr = sensor_attr->index;
615
1da177e4
LT
616 struct i2c_client *client = to_i2c_client(dev);
617 struct it87_data *data = i2c_get_clientdata(client);
618 int val = simple_strtol(buf, NULL, 10);
619
620 if (val < 0 || val > 255)
621 return -EINVAL;
622
623 down(&data->update_lock);
624 data->manual_pwm_ctl[nr] = val;
625 if (data->fan_main_ctrl & (1 << nr))
626 it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
627 up(&data->update_lock);
628 return count;
629}
630
20ad93d4
JD
631#define show_fan_offset(offset) \
632static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
633 show_fan, NULL, offset - 1); \
634static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
635 show_fan_min, set_fan_min, offset - 1); \
636static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
637 show_fan_div, set_fan_div, offset - 1);
1da177e4
LT
638
639show_fan_offset(1);
640show_fan_offset(2);
641show_fan_offset(3);
642
643#define show_pwm_offset(offset) \
20ad93d4
JD
644static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
645 show_pwm_enable, set_pwm_enable, offset - 1); \
646static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
647 show_pwm, set_pwm, offset - 1);
1da177e4
LT
648
649show_pwm_offset(1);
650show_pwm_offset(2);
651show_pwm_offset(3);
652
653/* Alarms */
30f74292 654static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT
655{
656 struct it87_data *data = it87_update_device(dev);
68188ba7 657 return sprintf(buf, "%u\n", data->alarms);
1da177e4 658}
1d66c64c 659static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
1da177e4
LT
660
661static ssize_t
30f74292 662show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT
663{
664 struct it87_data *data = it87_update_device(dev);
665 return sprintf(buf, "%ld\n", (long) data->vrm);
666}
667static ssize_t
30f74292 668store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1da177e4
LT
669{
670 struct i2c_client *client = to_i2c_client(dev);
671 struct it87_data *data = i2c_get_clientdata(client);
672 u32 val;
673
674 val = simple_strtoul(buf, NULL, 10);
675 data->vrm = val;
676
677 return count;
678}
679static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
680#define device_create_file_vrm(client) \
681device_create_file(&client->dev, &dev_attr_vrm)
682
683static ssize_t
30f74292 684show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT
685{
686 struct it87_data *data = it87_update_device(dev);
687 return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
688}
689static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
690#define device_create_file_vid(client) \
691device_create_file(&client->dev, &dev_attr_cpu0_vid)
692
693/* This function is called when:
694 * it87_driver is inserted (when this module is loaded), for each
695 available adapter
696 * when a new adapter is inserted (and it87_driver is still present) */
697static int it87_attach_adapter(struct i2c_adapter *adapter)
698{
699 if (!(adapter->class & I2C_CLASS_HWMON))
700 return 0;
701 return i2c_detect(adapter, &addr_data, it87_detect);
702}
703
2d8672c5
JD
704static int it87_isa_attach_adapter(struct i2c_adapter *adapter)
705{
706 return it87_detect(adapter, isa_address, -1);
707}
708
709/* SuperIO detection - will change isa_address if a chip is found */
e6cfb3ad 710static int __init it87_find(int *address)
1da177e4
LT
711{
712 int err = -ENODEV;
713
714 superio_enter();
715 chip_type = superio_inw(DEVID);
716 if (chip_type != IT8712F_DEVID
717 && chip_type != IT8705F_DEVID)
718 goto exit;
719
720 superio_select();
721 if (!(superio_inb(IT87_ACT_REG) & 0x01)) {
722 pr_info("it87: Device not activated, skipping\n");
723 goto exit;
724 }
725
726 *address = superio_inw(IT87_BASE_REG) & ~(IT87_EXTENT - 1);
727 if (*address == 0) {
728 pr_info("it87: Base address not set, skipping\n");
729 goto exit;
730 }
731
732 err = 0;
733 pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
734 chip_type, *address, superio_inb(DEVREV) & 0x0f);
735
736exit:
737 superio_exit();
738 return err;
739}
740
741/* This function is called by i2c_detect */
742int it87_detect(struct i2c_adapter *adapter, int address, int kind)
743{
744 int i;
745 struct i2c_client *new_client;
746 struct it87_data *data;
747 int err = 0;
748 const char *name = "";
749 int is_isa = i2c_is_isa_adapter(adapter);
750 int enable_pwm_interface;
751
752 if (!is_isa &&
753 !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
754 goto ERROR0;
755
756 /* Reserve the ISA region */
757 if (is_isa)
fde09509 758 if (!request_region(address, IT87_EXTENT, it87_isa_driver.name))
1da177e4
LT
759 goto ERROR0;
760
761 /* Probe whether there is anything available on this address. Already
762 done for SMBus and Super-I/O clients */
763 if (kind < 0) {
764 if (is_isa && !chip_type) {
765#define REALLY_SLOW_IO
766 /* We need the timeouts for at least some IT87-like chips. But only
767 if we read 'undefined' registers. */
768 i = inb_p(address + 1);
769 if (inb_p(address + 2) != i
770 || inb_p(address + 3) != i
771 || inb_p(address + 7) != i) {
772 err = -ENODEV;
773 goto ERROR1;
774 }
775#undef REALLY_SLOW_IO
776
777 /* Let's just hope nothing breaks here */
778 i = inb_p(address + 5) & 0x7f;
779 outb_p(~i & 0x7f, address + 5);
780 if ((inb_p(address + 5) & 0x7f) != (~i & 0x7f)) {
781 outb_p(i, address + 5);
782 err = -ENODEV;
783 goto ERROR1;
784 }
785 }
786 }
787
788 /* OK. For now, we presume we have a valid client. We now create the
789 client structure, even though we cannot fill it completely yet.
790 But it allows us to access it87_{read,write}_value. */
791
792 if (!(data = kmalloc(sizeof(struct it87_data), GFP_KERNEL))) {
793 err = -ENOMEM;
794 goto ERROR1;
795 }
796 memset(data, 0, sizeof(struct it87_data));
797
798 new_client = &data->client;
799 if (is_isa)
800 init_MUTEX(&data->lock);
801 i2c_set_clientdata(new_client, data);
802 new_client->addr = address;
803 new_client->adapter = adapter;
fde09509 804 new_client->driver = is_isa ? &it87_isa_driver : &it87_driver;
1da177e4
LT
805 new_client->flags = 0;
806
807 /* Now, we do the remaining detection. */
808
809 if (kind < 0) {
810 if ((it87_read_value(new_client, IT87_REG_CONFIG) & 0x80)
811 || (!is_isa
812 && it87_read_value(new_client, IT87_REG_I2C_ADDR) != address)) {
813 err = -ENODEV;
814 goto ERROR2;
815 }
816 }
817
818 /* Determine the chip type. */
819 if (kind <= 0) {
820 i = it87_read_value(new_client, IT87_REG_CHIPID);
821 if (i == 0x90) {
822 kind = it87;
823 if ((is_isa) && (chip_type == IT8712F_DEVID))
824 kind = it8712;
825 }
826 else {
827 if (kind == 0)
828 dev_info(&adapter->dev,
829 "Ignoring 'force' parameter for unknown chip at "
830 "adapter %d, address 0x%02x\n",
831 i2c_adapter_id(adapter), address);
832 err = -ENODEV;
833 goto ERROR2;
834 }
835 }
836
837 if (kind == it87) {
838 name = "it87";
839 } else if (kind == it8712) {
840 name = "it8712";
841 }
842
843 /* Fill in the remaining client fields and put it into the global list */
844 strlcpy(new_client->name, name, I2C_NAME_SIZE);
845 data->type = kind;
846 data->valid = 0;
847 init_MUTEX(&data->update_lock);
848
849 /* Tell the I2C layer a new client has arrived */
850 if ((err = i2c_attach_client(new_client)))
851 goto ERROR2;
852
853 /* Check PWM configuration */
854 enable_pwm_interface = it87_check_pwm(new_client);
855
856 /* Initialize the IT87 chip */
857 it87_init_client(new_client, data);
858
859 /* Register sysfs hooks */
943b0830
MH
860 data->class_dev = hwmon_device_register(&new_client->dev);
861 if (IS_ERR(data->class_dev)) {
862 err = PTR_ERR(data->class_dev);
863 goto ERROR3;
864 }
865
20ad93d4
JD
866 device_create_file(&new_client->dev, &sensor_dev_attr_in0_input.dev_attr);
867 device_create_file(&new_client->dev, &sensor_dev_attr_in1_input.dev_attr);
868 device_create_file(&new_client->dev, &sensor_dev_attr_in2_input.dev_attr);
869 device_create_file(&new_client->dev, &sensor_dev_attr_in3_input.dev_attr);
870 device_create_file(&new_client->dev, &sensor_dev_attr_in4_input.dev_attr);
871 device_create_file(&new_client->dev, &sensor_dev_attr_in5_input.dev_attr);
872 device_create_file(&new_client->dev, &sensor_dev_attr_in6_input.dev_attr);
873 device_create_file(&new_client->dev, &sensor_dev_attr_in7_input.dev_attr);
874 device_create_file(&new_client->dev, &sensor_dev_attr_in8_input.dev_attr);
875 device_create_file(&new_client->dev, &sensor_dev_attr_in0_min.dev_attr);
876 device_create_file(&new_client->dev, &sensor_dev_attr_in1_min.dev_attr);
877 device_create_file(&new_client->dev, &sensor_dev_attr_in2_min.dev_attr);
878 device_create_file(&new_client->dev, &sensor_dev_attr_in3_min.dev_attr);
879 device_create_file(&new_client->dev, &sensor_dev_attr_in4_min.dev_attr);
880 device_create_file(&new_client->dev, &sensor_dev_attr_in5_min.dev_attr);
881 device_create_file(&new_client->dev, &sensor_dev_attr_in6_min.dev_attr);
882 device_create_file(&new_client->dev, &sensor_dev_attr_in7_min.dev_attr);
883 device_create_file(&new_client->dev, &sensor_dev_attr_in0_max.dev_attr);
884 device_create_file(&new_client->dev, &sensor_dev_attr_in1_max.dev_attr);
885 device_create_file(&new_client->dev, &sensor_dev_attr_in2_max.dev_attr);
886 device_create_file(&new_client->dev, &sensor_dev_attr_in3_max.dev_attr);
887 device_create_file(&new_client->dev, &sensor_dev_attr_in4_max.dev_attr);
888 device_create_file(&new_client->dev, &sensor_dev_attr_in5_max.dev_attr);
889 device_create_file(&new_client->dev, &sensor_dev_attr_in6_max.dev_attr);
890 device_create_file(&new_client->dev, &sensor_dev_attr_in7_max.dev_attr);
891 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_input.dev_attr);
892 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_input.dev_attr);
893 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_input.dev_attr);
894 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_max.dev_attr);
895 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_max.dev_attr);
896 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_max.dev_attr);
897 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_min.dev_attr);
898 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_min.dev_attr);
899 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_min.dev_attr);
900 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_type.dev_attr);
901 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_type.dev_attr);
902 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_type.dev_attr);
903 device_create_file(&new_client->dev, &sensor_dev_attr_fan1_input.dev_attr);
904 device_create_file(&new_client->dev, &sensor_dev_attr_fan2_input.dev_attr);
905 device_create_file(&new_client->dev, &sensor_dev_attr_fan3_input.dev_attr);
906 device_create_file(&new_client->dev, &sensor_dev_attr_fan1_min.dev_attr);
907 device_create_file(&new_client->dev, &sensor_dev_attr_fan2_min.dev_attr);
908 device_create_file(&new_client->dev, &sensor_dev_attr_fan3_min.dev_attr);
909 device_create_file(&new_client->dev, &sensor_dev_attr_fan1_div.dev_attr);
910 device_create_file(&new_client->dev, &sensor_dev_attr_fan2_div.dev_attr);
911 device_create_file(&new_client->dev, &sensor_dev_attr_fan3_div.dev_attr);
1da177e4
LT
912 device_create_file(&new_client->dev, &dev_attr_alarms);
913 if (enable_pwm_interface) {
20ad93d4
JD
914 device_create_file(&new_client->dev, &sensor_dev_attr_pwm1_enable.dev_attr);
915 device_create_file(&new_client->dev, &sensor_dev_attr_pwm2_enable.dev_attr);
916 device_create_file(&new_client->dev, &sensor_dev_attr_pwm3_enable.dev_attr);
917 device_create_file(&new_client->dev, &sensor_dev_attr_pwm1.dev_attr);
918 device_create_file(&new_client->dev, &sensor_dev_attr_pwm2.dev_attr);
919 device_create_file(&new_client->dev, &sensor_dev_attr_pwm3.dev_attr);
1da177e4
LT
920 }
921
922 if (data->type == it8712) {
923 data->vrm = i2c_which_vrm();
924 device_create_file_vrm(new_client);
925 device_create_file_vid(new_client);
926 }
927
928 return 0;
929
943b0830
MH
930ERROR3:
931 i2c_detach_client(new_client);
1da177e4
LT
932ERROR2:
933 kfree(data);
934ERROR1:
935 if (is_isa)
936 release_region(address, IT87_EXTENT);
937ERROR0:
938 return err;
939}
940
941static int it87_detach_client(struct i2c_client *client)
942{
943b0830 943 struct it87_data *data = i2c_get_clientdata(client);
1da177e4
LT
944 int err;
945
943b0830
MH
946 hwmon_device_unregister(data->class_dev);
947
7bef5594 948 if ((err = i2c_detach_client(client)))
1da177e4 949 return err;
1da177e4
LT
950
951 if(i2c_is_isa_client(client))
952 release_region(client->addr, IT87_EXTENT);
943b0830 953 kfree(data);
1da177e4
LT
954
955 return 0;
956}
957
44bbe87e 958/* The SMBus locks itself, but ISA access must be locked explicitly!
1da177e4
LT
959 We don't want to lock the whole ISA bus, so we lock each client
960 separately.
961 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
962 would slow down the IT87 access and should not be necessary. */
963static int it87_read_value(struct i2c_client *client, u8 reg)
964{
965 struct it87_data *data = i2c_get_clientdata(client);
966
967 int res;
968 if (i2c_is_isa_client(client)) {
969 down(&data->lock);
970 outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
971 res = inb_p(client->addr + IT87_DATA_REG_OFFSET);
972 up(&data->lock);
973 return res;
974 } else
975 return i2c_smbus_read_byte_data(client, reg);
976}
977
44bbe87e 978/* The SMBus locks itself, but ISA access muse be locked explicitly!
1da177e4
LT
979 We don't want to lock the whole ISA bus, so we lock each client
980 separately.
981 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
982 would slow down the IT87 access and should not be necessary. */
983static int it87_write_value(struct i2c_client *client, u8 reg, u8 value)
984{
985 struct it87_data *data = i2c_get_clientdata(client);
986
987 if (i2c_is_isa_client(client)) {
988 down(&data->lock);
989 outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
990 outb_p(value, client->addr + IT87_DATA_REG_OFFSET);
991 up(&data->lock);
992 return 0;
993 } else
994 return i2c_smbus_write_byte_data(client, reg, value);
995}
996
997/* Return 1 if and only if the PWM interface is safe to use */
998static int it87_check_pwm(struct i2c_client *client)
999{
1000 /* Some BIOSes fail to correctly configure the IT87 fans. All fans off
1001 * and polarity set to active low is sign that this is the case so we
1002 * disable pwm control to protect the user. */
1003 int tmp = it87_read_value(client, IT87_REG_FAN_CTL);
1004 if ((tmp & 0x87) == 0) {
1005 if (fix_pwm_polarity) {
1006 /* The user asks us to attempt a chip reconfiguration.
1007 * This means switching to active high polarity and
1008 * inverting all fan speed values. */
1009 int i;
1010 u8 pwm[3];
1011
1012 for (i = 0; i < 3; i++)
1013 pwm[i] = it87_read_value(client,
1014 IT87_REG_PWM(i));
1015
1016 /* If any fan is in automatic pwm mode, the polarity
1017 * might be correct, as suspicious as it seems, so we
1018 * better don't change anything (but still disable the
1019 * PWM interface). */
1020 if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) {
1021 dev_info(&client->dev, "Reconfiguring PWM to "
1022 "active high polarity\n");
1023 it87_write_value(client, IT87_REG_FAN_CTL,
1024 tmp | 0x87);
1025 for (i = 0; i < 3; i++)
1026 it87_write_value(client,
1027 IT87_REG_PWM(i),
1028 0x7f & ~pwm[i]);
1029 return 1;
1030 }
1031
1032 dev_info(&client->dev, "PWM configuration is "
1033 "too broken to be fixed\n");
1034 }
1035
1036 dev_info(&client->dev, "Detected broken BIOS "
1037 "defaults, disabling PWM interface\n");
1038 return 0;
1039 } else if (fix_pwm_polarity) {
1040 dev_info(&client->dev, "PWM configuration looks "
1041 "sane, won't touch\n");
1042 }
1043
1044 return 1;
1045}
1046
1047/* Called when we have found a new IT87. */
1048static void it87_init_client(struct i2c_client *client, struct it87_data *data)
1049{
1050 int tmp, i;
1051
1052 /* initialize to sane defaults:
1053 * - if the chip is in manual pwm mode, this will be overwritten with
1054 * the actual settings on the chip (so in this case, initialization
1055 * is not needed)
1056 * - if in automatic or on/off mode, we could switch to manual mode,
1057 * read the registers and set manual_pwm_ctl accordingly, but currently
1058 * this is not implemented, so we initialize to something sane */
1059 for (i = 0; i < 3; i++) {
1060 data->manual_pwm_ctl[i] = 0xff;
1061 }
1062
1063 /* Check if temperature channnels are reset manually or by some reason */
1064 tmp = it87_read_value(client, IT87_REG_TEMP_ENABLE);
1065 if ((tmp & 0x3f) == 0) {
1066 /* Temp1,Temp3=thermistor; Temp2=thermal diode */
1067 tmp = (tmp & 0xc0) | 0x2a;
1068 it87_write_value(client, IT87_REG_TEMP_ENABLE, tmp);
1069 }
1070 data->sensor = tmp;
1071
1072 /* Check if voltage monitors are reset manually or by some reason */
1073 tmp = it87_read_value(client, IT87_REG_VIN_ENABLE);
1074 if ((tmp & 0xff) == 0) {
1075 /* Enable all voltage monitors */
1076 it87_write_value(client, IT87_REG_VIN_ENABLE, 0xff);
1077 }
1078
1079 /* Check if tachometers are reset manually or by some reason */
1080 data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL);
1081 if ((data->fan_main_ctrl & 0x70) == 0) {
1082 /* Enable all fan tachometers */
1083 data->fan_main_ctrl |= 0x70;
1084 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
1085 }
1086
1087 /* Set current fan mode registers and the default settings for the
1088 * other mode registers */
1089 for (i = 0; i < 3; i++) {
1090 if (data->fan_main_ctrl & (1 << i)) {
1091 /* pwm mode */
1092 tmp = it87_read_value(client, IT87_REG_PWM(i));
1093 if (tmp & 0x80) {
1094 /* automatic pwm - not yet implemented, but
1095 * leave the settings made by the BIOS alone
1096 * until a change is requested via the sysfs
1097 * interface */
1098 } else {
1099 /* manual pwm */
1100 data->manual_pwm_ctl[i] = PWM_FROM_REG(tmp);
1101 }
1102 }
1103 }
1104
1105 /* Start monitoring */
1106 it87_write_value(client, IT87_REG_CONFIG,
1107 (it87_read_value(client, IT87_REG_CONFIG) & 0x36)
1108 | (update_vbat ? 0x41 : 0x01));
1109}
1110
1111static struct it87_data *it87_update_device(struct device *dev)
1112{
1113 struct i2c_client *client = to_i2c_client(dev);
1114 struct it87_data *data = i2c_get_clientdata(client);
1115 int i;
1116
1117 down(&data->update_lock);
1118
1119 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1120 || !data->valid) {
1121
1122 if (update_vbat) {
1123 /* Cleared after each update, so reenable. Value
1124 returned by this read will be previous value */
1125 it87_write_value(client, IT87_REG_CONFIG,
1126 it87_read_value(client, IT87_REG_CONFIG) | 0x40);
1127 }
1128 for (i = 0; i <= 7; i++) {
1129 data->in[i] =
1130 it87_read_value(client, IT87_REG_VIN(i));
1131 data->in_min[i] =
1132 it87_read_value(client, IT87_REG_VIN_MIN(i));
1133 data->in_max[i] =
1134 it87_read_value(client, IT87_REG_VIN_MAX(i));
1135 }
1136 data->in[8] =
1137 it87_read_value(client, IT87_REG_VIN(8));
1138 /* Temperature sensor doesn't have limit registers, set
1139 to min and max value */
1140 data->in_min[8] = 0;
1141 data->in_max[8] = 255;
1142
1143 for (i = 0; i < 3; i++) {
1144 data->fan[i] =
1145 it87_read_value(client, IT87_REG_FAN(i));
1146 data->fan_min[i] =
1147 it87_read_value(client, IT87_REG_FAN_MIN(i));
1148 }
1149 for (i = 0; i < 3; i++) {
1150 data->temp[i] =
1151 it87_read_value(client, IT87_REG_TEMP(i));
1152 data->temp_high[i] =
1153 it87_read_value(client, IT87_REG_TEMP_HIGH(i));
1154 data->temp_low[i] =
1155 it87_read_value(client, IT87_REG_TEMP_LOW(i));
1156 }
1157
1158 i = it87_read_value(client, IT87_REG_FAN_DIV);
1159 data->fan_div[0] = i & 0x07;
1160 data->fan_div[1] = (i >> 3) & 0x07;
1161 data->fan_div[2] = (i & 0x40) ? 3 : 1;
1162
1163 data->alarms =
1164 it87_read_value(client, IT87_REG_ALARM1) |
1165 (it87_read_value(client, IT87_REG_ALARM2) << 8) |
1166 (it87_read_value(client, IT87_REG_ALARM3) << 16);
1167 data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL);
1168
1169 data->sensor = it87_read_value(client, IT87_REG_TEMP_ENABLE);
1170 /* The 8705 does not have VID capability */
1171 if (data->type == it8712) {
1172 data->vid = it87_read_value(client, IT87_REG_VID);
1173 data->vid &= 0x1f;
1174 }
1175 data->last_updated = jiffies;
1176 data->valid = 1;
1177 }
1178
1179 up(&data->update_lock);
1180
1181 return data;
1182}
1183
1184static int __init sm_it87_init(void)
1185{
fde09509 1186 int addr, res;
1da177e4
LT
1187
1188 if (!it87_find(&addr)) {
2d8672c5 1189 isa_address = addr;
1da177e4 1190 }
fde09509
JD
1191
1192 res = i2c_add_driver(&it87_driver);
1193 if (res)
1194 return res;
1195
1196 res = i2c_isa_add_driver(&it87_isa_driver);
1197 if (res) {
1198 i2c_del_driver(&it87_driver);
1199 return res;
1200 }
1201
1202 return 0;
1da177e4
LT
1203}
1204
1205static void __exit sm_it87_exit(void)
1206{
fde09509 1207 i2c_isa_del_driver(&it87_isa_driver);
1da177e4
LT
1208 i2c_del_driver(&it87_driver);
1209}
1210
1211
1212MODULE_AUTHOR("Chris Gauthron <chrisg@0-in.com>");
1213MODULE_DESCRIPTION("IT8705F, IT8712F, Sis950 driver");
1214module_param(update_vbat, bool, 0);
1215MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value");
1216module_param(fix_pwm_polarity, bool, 0);
1217MODULE_PARM_DESC(fix_pwm_polarity, "Force PWM polarity to active high (DANGEROUS)");
1218MODULE_LICENSE("GPL");
1219
1220module_init(sm_it87_init);
1221module_exit(sm_it87_exit);