projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] I2C: Separate non-i2c hwmon drivers from i2c-core (4/9)
[linux-2.6-block.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 };
51static unsigned int normal_isa[] = { 0x0290, I2C_CLIENT_ISA_END };
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);
225static int it87_find(int *address);
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",
249 .attach_adapter = it87_attach_adapter,
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
704/* SuperIO detection - will change normal_isa[0] if a chip is found */
705static int it87_find(int *address)
706{
707 int err = -ENODEV;
708
709 superio_enter();
710 chip_type = superio_inw(DEVID);
711 if (chip_type != IT8712F_DEVID
712 && chip_type != IT8705F_DEVID)
713 goto exit;
714
715 superio_select();
716 if (!(superio_inb(IT87_ACT_REG) & 0x01)) {
717 pr_info("it87: Device not activated, skipping\n");
718 goto exit;
719 }
720
721 *address = superio_inw(IT87_BASE_REG) & ~(IT87_EXTENT - 1);
722 if (*address == 0) {
723 pr_info("it87: Base address not set, skipping\n");
724 goto exit;
725 }
726
727 err = 0;
728 pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
729 chip_type, *address, superio_inb(DEVREV) & 0x0f);
730
731exit:
732 superio_exit();
733 return err;
734}
735
736/* This function is called by i2c_detect */
737int it87_detect(struct i2c_adapter *adapter, int address, int kind)
738{
739 int i;
740 struct i2c_client *new_client;
741 struct it87_data *data;
742 int err = 0;
743 const char *name = "";
744 int is_isa = i2c_is_isa_adapter(adapter);
745 int enable_pwm_interface;
746
747 if (!is_isa &&
748 !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
749 goto ERROR0;
750
751 /* Reserve the ISA region */
752 if (is_isa)
fde09509 753 if (!request_region(address, IT87_EXTENT, it87_isa_driver.name))
1da177e4
LT		 754 goto ERROR0;
755
756 /* Probe whether there is anything available on this address. Already
757 done for SMBus and Super-I/O clients */
758 if (kind < 0) {
759 if (is_isa && !chip_type) {
760#define REALLY_SLOW_IO
761 /* We need the timeouts for at least some IT87-like chips. But only
762 if we read 'undefined' registers. */
763 i = inb_p(address + 1);
764 if (inb_p(address + 2) != i
765 || inb_p(address + 3) != i
766 || inb_p(address + 7) != i) {
767 err = -ENODEV;
768 goto ERROR1;
769 }
770#undef REALLY_SLOW_IO
771
772 /* Let's just hope nothing breaks here */
773 i = inb_p(address + 5) & 0x7f;
774 outb_p(~i & 0x7f, address + 5);
775 if ((inb_p(address + 5) & 0x7f) != (~i & 0x7f)) {
776 outb_p(i, address + 5);
777 err = -ENODEV;
778 goto ERROR1;
779 }
780 }
781 }
782
783 /* OK. For now, we presume we have a valid client. We now create the
784 client structure, even though we cannot fill it completely yet.
785 But it allows us to access it87_{read,write}_value. */
786
787 if (!(data = kmalloc(sizeof(struct it87_data), GFP_KERNEL))) {
788 err = -ENOMEM;
789 goto ERROR1;
790 }
791 memset(data, 0, sizeof(struct it87_data));
792
793 new_client = &data->client;
794 if (is_isa)
795 init_MUTEX(&data->lock);
796 i2c_set_clientdata(new_client, data);
797 new_client->addr = address;
798 new_client->adapter = adapter;
fde09509 799 new_client->driver = is_isa ? &it87_isa_driver : &it87_driver;
1da177e4
LT		 800 new_client->flags = 0;
801
802 /* Now, we do the remaining detection. */
803
804 if (kind < 0) {
805 if ((it87_read_value(new_client, IT87_REG_CONFIG) & 0x80)
806 || (!is_isa
807 && it87_read_value(new_client, IT87_REG_I2C_ADDR) != address)) {
808 err = -ENODEV;
809 goto ERROR2;
810 }
811 }
812
813 /* Determine the chip type. */
814 if (kind <= 0) {
815 i = it87_read_value(new_client, IT87_REG_CHIPID);
816 if (i == 0x90) {
817 kind = it87;
818 if ((is_isa) && (chip_type == IT8712F_DEVID))
819 kind = it8712;
820 }
821 else {
822 if (kind == 0)
823 dev_info(&adapter->dev,
824 "Ignoring 'force' parameter for unknown chip at "
825 "adapter %d, address 0x%02x\n",
826 i2c_adapter_id(adapter), address);
827 err = -ENODEV;
828 goto ERROR2;
829 }
830 }
831
832 if (kind == it87) {
833 name = "it87";
834 } else if (kind == it8712) {
835 name = "it8712";
836 }
837
838 /* Fill in the remaining client fields and put it into the global list */
839 strlcpy(new_client->name, name, I2C_NAME_SIZE);
840 data->type = kind;
841 data->valid = 0;
842 init_MUTEX(&data->update_lock);
843
844 /* Tell the I2C layer a new client has arrived */
845 if ((err = i2c_attach_client(new_client)))
846 goto ERROR2;
847
848 /* Check PWM configuration */
849 enable_pwm_interface = it87_check_pwm(new_client);
850
851 /* Initialize the IT87 chip */
852 it87_init_client(new_client, data);
853
854 /* Register sysfs hooks */
943b0830
MH		 855 data->class_dev = hwmon_device_register(&new_client->dev);
856 if (IS_ERR(data->class_dev)) {
857 err = PTR_ERR(data->class_dev);
858 goto ERROR3;
859 }
860
20ad93d4
JD		 861 device_create_file(&new_client->dev, &sensor_dev_attr_in0_input.dev_attr);
862 device_create_file(&new_client->dev, &sensor_dev_attr_in1_input.dev_attr);
863 device_create_file(&new_client->dev, &sensor_dev_attr_in2_input.dev_attr);
864 device_create_file(&new_client->dev, &sensor_dev_attr_in3_input.dev_attr);
865 device_create_file(&new_client->dev, &sensor_dev_attr_in4_input.dev_attr);
866 device_create_file(&new_client->dev, &sensor_dev_attr_in5_input.dev_attr);
867 device_create_file(&new_client->dev, &sensor_dev_attr_in6_input.dev_attr);
868 device_create_file(&new_client->dev, &sensor_dev_attr_in7_input.dev_attr);
869 device_create_file(&new_client->dev, &sensor_dev_attr_in8_input.dev_attr);
870 device_create_file(&new_client->dev, &sensor_dev_attr_in0_min.dev_attr);
871 device_create_file(&new_client->dev, &sensor_dev_attr_in1_min.dev_attr);
872 device_create_file(&new_client->dev, &sensor_dev_attr_in2_min.dev_attr);
873 device_create_file(&new_client->dev, &sensor_dev_attr_in3_min.dev_attr);
874 device_create_file(&new_client->dev, &sensor_dev_attr_in4_min.dev_attr);
875 device_create_file(&new_client->dev, &sensor_dev_attr_in5_min.dev_attr);
876 device_create_file(&new_client->dev, &sensor_dev_attr_in6_min.dev_attr);
877 device_create_file(&new_client->dev, &sensor_dev_attr_in7_min.dev_attr);
878 device_create_file(&new_client->dev, &sensor_dev_attr_in0_max.dev_attr);
879 device_create_file(&new_client->dev, &sensor_dev_attr_in1_max.dev_attr);
880 device_create_file(&new_client->dev, &sensor_dev_attr_in2_max.dev_attr);
881 device_create_file(&new_client->dev, &sensor_dev_attr_in3_max.dev_attr);
882 device_create_file(&new_client->dev, &sensor_dev_attr_in4_max.dev_attr);
883 device_create_file(&new_client->dev, &sensor_dev_attr_in5_max.dev_attr);
884 device_create_file(&new_client->dev, &sensor_dev_attr_in6_max.dev_attr);
885 device_create_file(&new_client->dev, &sensor_dev_attr_in7_max.dev_attr);
886 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_input.dev_attr);
887 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_input.dev_attr);
888 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_input.dev_attr);
889 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_max.dev_attr);
890 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_max.dev_attr);
891 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_max.dev_attr);
892 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_min.dev_attr);
893 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_min.dev_attr);
894 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_min.dev_attr);
895 device_create_file(&new_client->dev, &sensor_dev_attr_temp1_type.dev_attr);
896 device_create_file(&new_client->dev, &sensor_dev_attr_temp2_type.dev_attr);
897 device_create_file(&new_client->dev, &sensor_dev_attr_temp3_type.dev_attr);
898 device_create_file(&new_client->dev, &sensor_dev_attr_fan1_input.dev_attr);
899 device_create_file(&new_client->dev, &sensor_dev_attr_fan2_input.dev_attr);
900 device_create_file(&new_client->dev, &sensor_dev_attr_fan3_input.dev_attr);
901 device_create_file(&new_client->dev, &sensor_dev_attr_fan1_min.dev_attr);
902 device_create_file(&new_client->dev, &sensor_dev_attr_fan2_min.dev_attr);
903 device_create_file(&new_client->dev, &sensor_dev_attr_fan3_min.dev_attr);
904 device_create_file(&new_client->dev, &sensor_dev_attr_fan1_div.dev_attr);
905 device_create_file(&new_client->dev, &sensor_dev_attr_fan2_div.dev_attr);
906 device_create_file(&new_client->dev, &sensor_dev_attr_fan3_div.dev_attr);
1da177e4
LT		 907 device_create_file(&new_client->dev, &dev_attr_alarms);
908 if (enable_pwm_interface) {
20ad93d4
JD		 909 device_create_file(&new_client->dev, &sensor_dev_attr_pwm1_enable.dev_attr);
910 device_create_file(&new_client->dev, &sensor_dev_attr_pwm2_enable.dev_attr);
911 device_create_file(&new_client->dev, &sensor_dev_attr_pwm3_enable.dev_attr);
912 device_create_file(&new_client->dev, &sensor_dev_attr_pwm1.dev_attr);
913 device_create_file(&new_client->dev, &sensor_dev_attr_pwm2.dev_attr);
914 device_create_file(&new_client->dev, &sensor_dev_attr_pwm3.dev_attr);
1da177e4
LT		 915 }
916
917 if (data->type == it8712) {
918 data->vrm = i2c_which_vrm();
919 device_create_file_vrm(new_client);
920 device_create_file_vid(new_client);
921 }
922
923 return 0;
924
943b0830
MH		 925ERROR3:
926 i2c_detach_client(new_client);
1da177e4
LT		 927ERROR2:
928 kfree(data);
929ERROR1:
930 if (is_isa)
931 release_region(address, IT87_EXTENT);
932ERROR0:
933 return err;
934}
935
936static int it87_detach_client(struct i2c_client *client)
937{
943b0830 938 struct it87_data *data = i2c_get_clientdata(client);
1da177e4
LT		 939 int err;
940
943b0830
MH		 941 hwmon_device_unregister(data->class_dev);
942
1da177e4
LT		 943 if ((err = i2c_detach_client(client))) {
944 dev_err(&client->dev,
945 "Client deregistration failed, client not detached.\n");
946 return err;
947 }
948
949 if(i2c_is_isa_client(client))
950 release_region(client->addr, IT87_EXTENT);
943b0830 951 kfree(data);
1da177e4
LT		 952
953 return 0;
954}
955
44bbe87e 956/* The SMBus locks itself, but ISA access must be locked explicitly!
1da177e4
LT		 957 We don't want to lock the whole ISA bus, so we lock each client
958 separately.
959 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
960 would slow down the IT87 access and should not be necessary. */
961static int it87_read_value(struct i2c_client *client, u8 reg)
962{
963 struct it87_data *data = i2c_get_clientdata(client);
964
965 int res;
966 if (i2c_is_isa_client(client)) {
967 down(&data->lock);
968 outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
969 res = inb_p(client->addr + IT87_DATA_REG_OFFSET);
970 up(&data->lock);
971 return res;
972 } else
973 return i2c_smbus_read_byte_data(client, reg);
974}
975
44bbe87e 976/* The SMBus locks itself, but ISA access muse be locked explicitly!
1da177e4
LT		 977 We don't want to lock the whole ISA bus, so we lock each client
978 separately.
979 We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
980 would slow down the IT87 access and should not be necessary. */
981static int it87_write_value(struct i2c_client *client, u8 reg, u8 value)
982{
983 struct it87_data *data = i2c_get_clientdata(client);
984
985 if (i2c_is_isa_client(client)) {
986 down(&data->lock);
987 outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
988 outb_p(value, client->addr + IT87_DATA_REG_OFFSET);
989 up(&data->lock);
990 return 0;
991 } else
992 return i2c_smbus_write_byte_data(client, reg, value);
993}
994
995/* Return 1 if and only if the PWM interface is safe to use */
996static int it87_check_pwm(struct i2c_client *client)
997{
998 /* Some BIOSes fail to correctly configure the IT87 fans. All fans off
999 * and polarity set to active low is sign that this is the case so we
1000 * disable pwm control to protect the user. */
1001 int tmp = it87_read_value(client, IT87_REG_FAN_CTL);
1002 if ((tmp & 0x87) == 0) {
1003 if (fix_pwm_polarity) {
1004 /* The user asks us to attempt a chip reconfiguration.
1005 * This means switching to active high polarity and
1006 * inverting all fan speed values. */
1007 int i;
1008 u8 pwm[3];
1009
1010 for (i = 0; i < 3; i++)
1011 pwm[i] = it87_read_value(client,
1012 IT87_REG_PWM(i));
1013
1014 /* If any fan is in automatic pwm mode, the polarity
1015 * might be correct, as suspicious as it seems, so we
1016 * better don't change anything (but still disable the
1017 * PWM interface). */
1018 if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) {
1019 dev_info(&client->dev, "Reconfiguring PWM to "
1020 "active high polarity\n");
1021 it87_write_value(client, IT87_REG_FAN_CTL,
1022 tmp | 0x87);
1023 for (i = 0; i < 3; i++)
1024 it87_write_value(client,
1025 IT87_REG_PWM(i),
1026 0x7f & ~pwm[i]);
1027 return 1;
1028 }
1029
1030 dev_info(&client->dev, "PWM configuration is "
1031 "too broken to be fixed\n");
1032 }
1033
1034 dev_info(&client->dev, "Detected broken BIOS "
1035 "defaults, disabling PWM interface\n");
1036 return 0;
1037 } else if (fix_pwm_polarity) {
1038 dev_info(&client->dev, "PWM configuration looks "
1039 "sane, won't touch\n");
1040 }
1041
1042 return 1;
1043}
1044
1045/* Called when we have found a new IT87. */
1046static void it87_init_client(struct i2c_client *client, struct it87_data *data)
1047{
1048 int tmp, i;
1049
1050 /* initialize to sane defaults:
1051 * - if the chip is in manual pwm mode, this will be overwritten with
1052 * the actual settings on the chip (so in this case, initialization
1053 * is not needed)
1054 * - if in automatic or on/off mode, we could switch to manual mode,
1055 * read the registers and set manual_pwm_ctl accordingly, but currently
1056 * this is not implemented, so we initialize to something sane */
1057 for (i = 0; i < 3; i++) {
1058 data->manual_pwm_ctl[i] = 0xff;
1059 }
1060
1061 /* Check if temperature channnels are reset manually or by some reason */
1062 tmp = it87_read_value(client, IT87_REG_TEMP_ENABLE);
1063 if ((tmp & 0x3f) == 0) {
1064 /* Temp1,Temp3=thermistor; Temp2=thermal diode */
1065 tmp = (tmp & 0xc0) | 0x2a;
1066 it87_write_value(client, IT87_REG_TEMP_ENABLE, tmp);
1067 }
1068 data->sensor = tmp;
1069
1070 /* Check if voltage monitors are reset manually or by some reason */
1071 tmp = it87_read_value(client, IT87_REG_VIN_ENABLE);
1072 if ((tmp & 0xff) == 0) {
1073 /* Enable all voltage monitors */
1074 it87_write_value(client, IT87_REG_VIN_ENABLE, 0xff);
1075 }
1076
1077 /* Check if tachometers are reset manually or by some reason */
1078 data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL);
1079 if ((data->fan_main_ctrl & 0x70) == 0) {
1080 /* Enable all fan tachometers */
1081 data->fan_main_ctrl |= 0x70;
1082 it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
1083 }
1084
1085 /* Set current fan mode registers and the default settings for the
1086 * other mode registers */
1087 for (i = 0; i < 3; i++) {
1088 if (data->fan_main_ctrl & (1 << i)) {
1089 /* pwm mode */
1090 tmp = it87_read_value(client, IT87_REG_PWM(i));
1091 if (tmp & 0x80) {
1092 /* automatic pwm - not yet implemented, but
1093 * leave the settings made by the BIOS alone
1094 * until a change is requested via the sysfs
1095 * interface */
1096 } else {
1097 /* manual pwm */
1098 data->manual_pwm_ctl[i] = PWM_FROM_REG(tmp);
1099 }
1100 }
1101 }
1102
1103 /* Start monitoring */
1104 it87_write_value(client, IT87_REG_CONFIG,
1105 (it87_read_value(client, IT87_REG_CONFIG) & 0x36)
1106 | (update_vbat ? 0x41 : 0x01));
1107}
1108
1109static struct it87_data *it87_update_device(struct device *dev)
1110{
1111 struct i2c_client *client = to_i2c_client(dev);
1112 struct it87_data *data = i2c_get_clientdata(client);
1113 int i;
1114
1115 down(&data->update_lock);
1116
1117 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1118 || !data->valid) {
1119
1120 if (update_vbat) {
1121 /* Cleared after each update, so reenable. Value
1122 returned by this read will be previous value */
1123 it87_write_value(client, IT87_REG_CONFIG,
1124 it87_read_value(client, IT87_REG_CONFIG) | 0x40);
1125 }
1126 for (i = 0; i <= 7; i++) {
1127 data->in[i] =
1128 it87_read_value(client, IT87_REG_VIN(i));
1129 data->in_min[i] =
1130 it87_read_value(client, IT87_REG_VIN_MIN(i));
1131 data->in_max[i] =
1132 it87_read_value(client, IT87_REG_VIN_MAX(i));
1133 }
1134 data->in[8] =
1135 it87_read_value(client, IT87_REG_VIN(8));
1136 /* Temperature sensor doesn't have limit registers, set
1137 to min and max value */
1138 data->in_min[8] = 0;
1139 data->in_max[8] = 255;
1140
1141 for (i = 0; i < 3; i++) {
1142 data->fan[i] =
1143 it87_read_value(client, IT87_REG_FAN(i));
1144 data->fan_min[i] =
1145 it87_read_value(client, IT87_REG_FAN_MIN(i));
1146 }
1147 for (i = 0; i < 3; i++) {
1148 data->temp[i] =
1149 it87_read_value(client, IT87_REG_TEMP(i));
1150 data->temp_high[i] =
1151 it87_read_value(client, IT87_REG_TEMP_HIGH(i));
1152 data->temp_low[i] =
1153 it87_read_value(client, IT87_REG_TEMP_LOW(i));
1154 }
1155
1156 i = it87_read_value(client, IT87_REG_FAN_DIV);
1157 data->fan_div[0] = i & 0x07;
1158 data->fan_div[1] = (i >> 3) & 0x07;
1159 data->fan_div[2] = (i & 0x40) ? 3 : 1;
1160
1161 data->alarms =
1162 it87_read_value(client, IT87_REG_ALARM1) |
1163 (it87_read_value(client, IT87_REG_ALARM2) << 8) |
1164 (it87_read_value(client, IT87_REG_ALARM3) << 16);
1165 data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL);
1166
1167 data->sensor = it87_read_value(client, IT87_REG_TEMP_ENABLE);
1168 /* The 8705 does not have VID capability */
1169 if (data->type == it8712) {
1170 data->vid = it87_read_value(client, IT87_REG_VID);
1171 data->vid &= 0x1f;
1172 }
1173 data->last_updated = jiffies;
1174 data->valid = 1;
1175 }
1176
1177 up(&data->update_lock);
1178
1179 return data;
1180}
1181
1182static int __init sm_it87_init(void)
1183{
fde09509 1184 int addr, res;
1da177e4
LT		 1185
1186 if (!it87_find(&addr)) {
1187 normal_isa[0] = addr;
1188 }
fde09509
JD		 1189
1190 res = i2c_add_driver(&it87_driver);
1191 if (res)
1192 return res;
1193
1194 res = i2c_isa_add_driver(&it87_isa_driver);
1195 if (res) {
1196 i2c_del_driver(&it87_driver);
1197 return res;
1198 }
1199
1200 return 0;
1da177e4
LT		 1201}
1202
1203static void __exit sm_it87_exit(void)
1204{
fde09509 1205 i2c_isa_del_driver(&it87_isa_driver);
1da177e4
LT		 1206 i2c_del_driver(&it87_driver);
1207}
1208
1209
1210MODULE_AUTHOR("Chris Gauthron <chrisg@0-in.com>");
1211MODULE_DESCRIPTION("IT8705F, IT8712F, Sis950 driver");
1212module_param(update_vbat, bool, 0);
1213MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value");
1214module_param(fix_pwm_polarity, bool, 0);
1215MODULE_PARM_DESC(fix_pwm_polarity, "Force PWM polarity to active high (DANGEROUS)");
1216MODULE_LICENSE("GPL");
1217
1218module_init(sm_it87_init);
1219module_exit(sm_it87_exit);
Linux 6.x block layer and io_uring tree(s)