2 lm78.c - Part of lm_sensors, Linux kernel modules for hardware
4 Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/jiffies.h>
25 #include <linux/i2c.h>
26 #include <linux/i2c-isa.h>
27 #include <linux/hwmon.h>
28 #include <linux/hwmon-vid.h>
29 #include <linux/err.h>
32 /* Addresses to scan */
33 static unsigned short normal_i2c
[] = { 0x20, 0x21, 0x22, 0x23, 0x24,
34 0x25, 0x26, 0x27, 0x28, 0x29,
35 0x2a, 0x2b, 0x2c, 0x2d, 0x2e,
36 0x2f, I2C_CLIENT_END
};
37 static unsigned short isa_address
= 0x290;
39 /* Insmod parameters */
40 I2C_CLIENT_INSMOD_2(lm78
, lm79
);
42 /* Many LM78 constants specified below */
44 /* Length of ISA address segment */
47 /* Where are the ISA address/data registers relative to the base address */
48 #define LM78_ADDR_REG_OFFSET 5
49 #define LM78_DATA_REG_OFFSET 6
51 /* The LM78 registers */
52 #define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)
53 #define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)
54 #define LM78_REG_IN(nr) (0x20 + (nr))
56 #define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
57 #define LM78_REG_FAN(nr) (0x28 + (nr))
59 #define LM78_REG_TEMP 0x27
60 #define LM78_REG_TEMP_OVER 0x39
61 #define LM78_REG_TEMP_HYST 0x3a
63 #define LM78_REG_ALARM1 0x41
64 #define LM78_REG_ALARM2 0x42
66 #define LM78_REG_VID_FANDIV 0x47
68 #define LM78_REG_CONFIG 0x40
69 #define LM78_REG_CHIPID 0x49
70 #define LM78_REG_I2C_ADDR 0x48
73 /* Conversions. Rounding and limit checking is only done on the TO_REG
76 /* IN: mV, (0V to 4.08V)
78 static inline u8
IN_TO_REG(unsigned long val
)
80 unsigned long nval
= SENSORS_LIMIT(val
, 0, 4080);
81 return (nval
+ 8) / 16;
83 #define IN_FROM_REG(val) ((val) * 16)
85 static inline u8
FAN_TO_REG(long rpm
, int div
)
89 return SENSORS_LIMIT((1350000 + rpm
* div
/ 2) / (rpm
* div
), 1, 254);
92 static inline int FAN_FROM_REG(u8 val
, int div
)
94 return val
==0 ? -1 : val
==255 ? 0 : 1350000/(val
*div
);
97 /* TEMP: mC (-128C to +127C)
98 REG: 1C/bit, two's complement */
99 static inline s8
TEMP_TO_REG(int val
)
101 int nval
= SENSORS_LIMIT(val
, -128000, 127000) ;
102 return nval
<0 ? (nval
-500)/1000 : (nval
+500)/1000;
105 static inline int TEMP_FROM_REG(s8 val
)
110 #define DIV_FROM_REG(val) (1 << (val))
112 /* There are some complications in a module like this. First off, LM78 chips
113 may be both present on the SMBus and the ISA bus, and we have to handle
114 those cases separately at some places. Second, there might be several
115 LM78 chips available (well, actually, that is probably never done; but
116 it is a clean illustration of how to handle a case like that). Finally,
117 a specific chip may be attached to *both* ISA and SMBus, and we would
118 not like to detect it double. Fortunately, in the case of the LM78 at
119 least, a register tells us what SMBus address we are on, so that helps
120 a bit - except if there could be more than one SMBus. Groan. No solution
123 /* This module may seem overly long and complicated. In fact, it is not so
124 bad. Quite a lot of bookkeeping is done. A real driver can often cut
127 /* For each registered LM78, we need to keep some data in memory. That
128 data is pointed to by lm78_list[NR]->data. The structure itself is
129 dynamically allocated, at the same time when a new lm78 client is
132 struct i2c_client client
;
133 struct class_device
*class_dev
;
134 struct semaphore lock
;
137 struct semaphore update_lock
;
138 char valid
; /* !=0 if following fields are valid */
139 unsigned long last_updated
; /* In jiffies */
141 u8 in
[7]; /* Register value */
142 u8 in_max
[7]; /* Register value */
143 u8 in_min
[7]; /* Register value */
144 u8 fan
[3]; /* Register value */
145 u8 fan_min
[3]; /* Register value */
146 s8 temp
; /* Register value */
147 s8 temp_over
; /* Register value */
148 s8 temp_hyst
; /* Register value */
149 u8 fan_div
[3]; /* Register encoding, shifted right */
150 u8 vid
; /* Register encoding, combined */
151 u16 alarms
; /* Register encoding, combined */
155 static int lm78_attach_adapter(struct i2c_adapter
*adapter
);
156 static int lm78_isa_attach_adapter(struct i2c_adapter
*adapter
);
157 static int lm78_detect(struct i2c_adapter
*adapter
, int address
, int kind
);
158 static int lm78_detach_client(struct i2c_client
*client
);
160 static int lm78_read_value(struct i2c_client
*client
, u8
register);
161 static int lm78_write_value(struct i2c_client
*client
, u8
register, u8 value
);
162 static struct lm78_data
*lm78_update_device(struct device
*dev
);
163 static void lm78_init_client(struct i2c_client
*client
);
166 static struct i2c_driver lm78_driver
= {
167 .owner
= THIS_MODULE
,
169 .id
= I2C_DRIVERID_LM78
,
170 .flags
= I2C_DF_NOTIFY
,
171 .attach_adapter
= lm78_attach_adapter
,
172 .detach_client
= lm78_detach_client
,
175 static struct i2c_driver lm78_isa_driver
= {
176 .owner
= THIS_MODULE
,
178 .attach_adapter
= lm78_isa_attach_adapter
,
179 .detach_client
= lm78_detach_client
,
184 static ssize_t
show_in(struct device
*dev
, char *buf
, int nr
)
186 struct lm78_data
*data
= lm78_update_device(dev
);
187 return sprintf(buf
, "%d\n", IN_FROM_REG(data
->in
[nr
]));
190 static ssize_t
show_in_min(struct device
*dev
, char *buf
, int nr
)
192 struct lm78_data
*data
= lm78_update_device(dev
);
193 return sprintf(buf
, "%d\n", IN_FROM_REG(data
->in_min
[nr
]));
196 static ssize_t
show_in_max(struct device
*dev
, char *buf
, int nr
)
198 struct lm78_data
*data
= lm78_update_device(dev
);
199 return sprintf(buf
, "%d\n", IN_FROM_REG(data
->in_max
[nr
]));
202 static ssize_t
set_in_min(struct device
*dev
, const char *buf
,
203 size_t count
, int nr
)
205 struct i2c_client
*client
= to_i2c_client(dev
);
206 struct lm78_data
*data
= i2c_get_clientdata(client
);
207 unsigned long val
= simple_strtoul(buf
, NULL
, 10);
209 down(&data
->update_lock
);
210 data
->in_min
[nr
] = IN_TO_REG(val
);
211 lm78_write_value(client
, LM78_REG_IN_MIN(nr
), data
->in_min
[nr
]);
212 up(&data
->update_lock
);
216 static ssize_t
set_in_max(struct device
*dev
, const char *buf
,
217 size_t count
, int nr
)
219 struct i2c_client
*client
= to_i2c_client(dev
);
220 struct lm78_data
*data
= i2c_get_clientdata(client
);
221 unsigned long val
= simple_strtoul(buf
, NULL
, 10);
223 down(&data
->update_lock
);
224 data
->in_max
[nr
] = IN_TO_REG(val
);
225 lm78_write_value(client
, LM78_REG_IN_MAX(nr
), data
->in_max
[nr
]);
226 up(&data
->update_lock
);
230 #define show_in_offset(offset) \
232 show_in##offset (struct device *dev, struct device_attribute *attr, char *buf) \
234 return show_in(dev, buf, offset); \
236 static DEVICE_ATTR(in##offset##_input, S_IRUGO, \
237 show_in##offset, NULL); \
239 show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \
241 return show_in_min(dev, buf, offset); \
244 show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf) \
246 return show_in_max(dev, buf, offset); \
248 static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr, \
249 const char *buf, size_t count) \
251 return set_in_min(dev, buf, count, offset); \
253 static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr, \
254 const char *buf, size_t count) \
256 return set_in_max(dev, buf, count, offset); \
258 static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
259 show_in##offset##_min, set_in##offset##_min); \
260 static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
261 show_in##offset##_max, set_in##offset##_max);
272 static ssize_t
show_temp(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
274 struct lm78_data
*data
= lm78_update_device(dev
);
275 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp
));
278 static ssize_t
show_temp_over(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
280 struct lm78_data
*data
= lm78_update_device(dev
);
281 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_over
));
284 static ssize_t
set_temp_over(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
286 struct i2c_client
*client
= to_i2c_client(dev
);
287 struct lm78_data
*data
= i2c_get_clientdata(client
);
288 long val
= simple_strtol(buf
, NULL
, 10);
290 down(&data
->update_lock
);
291 data
->temp_over
= TEMP_TO_REG(val
);
292 lm78_write_value(client
, LM78_REG_TEMP_OVER
, data
->temp_over
);
293 up(&data
->update_lock
);
297 static ssize_t
show_temp_hyst(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
299 struct lm78_data
*data
= lm78_update_device(dev
);
300 return sprintf(buf
, "%d\n", TEMP_FROM_REG(data
->temp_hyst
));
303 static ssize_t
set_temp_hyst(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
305 struct i2c_client
*client
= to_i2c_client(dev
);
306 struct lm78_data
*data
= i2c_get_clientdata(client
);
307 long val
= simple_strtol(buf
, NULL
, 10);
309 down(&data
->update_lock
);
310 data
->temp_hyst
= TEMP_TO_REG(val
);
311 lm78_write_value(client
, LM78_REG_TEMP_HYST
, data
->temp_hyst
);
312 up(&data
->update_lock
);
316 static DEVICE_ATTR(temp1_input
, S_IRUGO
, show_temp
, NULL
);
317 static DEVICE_ATTR(temp1_max
, S_IRUGO
| S_IWUSR
,
318 show_temp_over
, set_temp_over
);
319 static DEVICE_ATTR(temp1_max_hyst
, S_IRUGO
| S_IWUSR
,
320 show_temp_hyst
, set_temp_hyst
);
323 static ssize_t
show_fan(struct device
*dev
, char *buf
, int nr
)
325 struct lm78_data
*data
= lm78_update_device(dev
);
326 return sprintf(buf
, "%d\n", FAN_FROM_REG(data
->fan
[nr
],
327 DIV_FROM_REG(data
->fan_div
[nr
])) );
330 static ssize_t
show_fan_min(struct device
*dev
, char *buf
, int nr
)
332 struct lm78_data
*data
= lm78_update_device(dev
);
333 return sprintf(buf
,"%d\n", FAN_FROM_REG(data
->fan_min
[nr
],
334 DIV_FROM_REG(data
->fan_div
[nr
])) );
337 static ssize_t
set_fan_min(struct device
*dev
, const char *buf
,
338 size_t count
, int nr
)
340 struct i2c_client
*client
= to_i2c_client(dev
);
341 struct lm78_data
*data
= i2c_get_clientdata(client
);
342 unsigned long val
= simple_strtoul(buf
, NULL
, 10);
344 down(&data
->update_lock
);
345 data
->fan_min
[nr
] = FAN_TO_REG(val
, DIV_FROM_REG(data
->fan_div
[nr
]));
346 lm78_write_value(client
, LM78_REG_FAN_MIN(nr
), data
->fan_min
[nr
]);
347 up(&data
->update_lock
);
351 static ssize_t
show_fan_div(struct device
*dev
, char *buf
, int nr
)
353 struct lm78_data
*data
= lm78_update_device(dev
);
354 return sprintf(buf
, "%d\n", DIV_FROM_REG(data
->fan_div
[nr
]) );
357 /* Note: we save and restore the fan minimum here, because its value is
358 determined in part by the fan divisor. This follows the principle of
359 least suprise; the user doesn't expect the fan minimum to change just
360 because the divisor changed. */
361 static ssize_t
set_fan_div(struct device
*dev
, const char *buf
,
362 size_t count
, int nr
)
364 struct i2c_client
*client
= to_i2c_client(dev
);
365 struct lm78_data
*data
= i2c_get_clientdata(client
);
366 unsigned long val
= simple_strtoul(buf
, NULL
, 10);
370 down(&data
->update_lock
);
371 min
= FAN_FROM_REG(data
->fan_min
[nr
],
372 DIV_FROM_REG(data
->fan_div
[nr
]));
375 case 1: data
->fan_div
[nr
] = 0; break;
376 case 2: data
->fan_div
[nr
] = 1; break;
377 case 4: data
->fan_div
[nr
] = 2; break;
378 case 8: data
->fan_div
[nr
] = 3; break;
380 dev_err(&client
->dev
, "fan_div value %ld not "
381 "supported. Choose one of 1, 2, 4 or 8!\n", val
);
382 up(&data
->update_lock
);
386 reg
= lm78_read_value(client
, LM78_REG_VID_FANDIV
);
389 reg
= (reg
& 0xcf) | (data
->fan_div
[nr
] << 4);
392 reg
= (reg
& 0x3f) | (data
->fan_div
[nr
] << 6);
395 lm78_write_value(client
, LM78_REG_VID_FANDIV
, reg
);
398 FAN_TO_REG(min
, DIV_FROM_REG(data
->fan_div
[nr
]));
399 lm78_write_value(client
, LM78_REG_FAN_MIN(nr
), data
->fan_min
[nr
]);
400 up(&data
->update_lock
);
405 #define show_fan_offset(offset) \
406 static ssize_t show_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
408 return show_fan(dev, buf, offset - 1); \
410 static ssize_t show_fan_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \
412 return show_fan_min(dev, buf, offset - 1); \
414 static ssize_t show_fan_##offset##_div (struct device *dev, struct device_attribute *attr, char *buf) \
416 return show_fan_div(dev, buf, offset - 1); \
418 static ssize_t set_fan_##offset##_min (struct device *dev, struct device_attribute *attr, \
419 const char *buf, size_t count) \
421 return set_fan_min(dev, buf, count, offset - 1); \
423 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, NULL);\
424 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
425 show_fan_##offset##_min, set_fan_##offset##_min);
427 static ssize_t
set_fan_1_div(struct device
*dev
, struct device_attribute
*attr
, const char *buf
,
430 return set_fan_div(dev
, buf
, count
, 0) ;
433 static ssize_t
set_fan_2_div(struct device
*dev
, struct device_attribute
*attr
, const char *buf
,
436 return set_fan_div(dev
, buf
, count
, 1) ;
443 /* Fan 3 divisor is locked in H/W */
444 static DEVICE_ATTR(fan1_div
, S_IRUGO
| S_IWUSR
,
445 show_fan_1_div
, set_fan_1_div
);
446 static DEVICE_ATTR(fan2_div
, S_IRUGO
| S_IWUSR
,
447 show_fan_2_div
, set_fan_2_div
);
448 static DEVICE_ATTR(fan3_div
, S_IRUGO
, show_fan_3_div
, NULL
);
451 static ssize_t
show_vid(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
453 struct lm78_data
*data
= lm78_update_device(dev
);
454 return sprintf(buf
, "%d\n", vid_from_reg(82, data
->vid
));
456 static DEVICE_ATTR(cpu0_vid
, S_IRUGO
, show_vid
, NULL
);
459 static ssize_t
show_alarms(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
461 struct lm78_data
*data
= lm78_update_device(dev
);
462 return sprintf(buf
, "%u\n", data
->alarms
);
464 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
);
466 /* This function is called when:
467 * lm78_driver is inserted (when this module is loaded), for each
469 * when a new adapter is inserted (and lm78_driver is still present) */
470 static int lm78_attach_adapter(struct i2c_adapter
*adapter
)
472 if (!(adapter
->class & I2C_CLASS_HWMON
))
474 return i2c_probe(adapter
, &addr_data
, lm78_detect
);
477 static int lm78_isa_attach_adapter(struct i2c_adapter
*adapter
)
479 return lm78_detect(adapter
, isa_address
, -1);
482 /* This function is called by i2c_probe */
483 int lm78_detect(struct i2c_adapter
*adapter
, int address
, int kind
)
486 struct i2c_client
*new_client
;
487 struct lm78_data
*data
;
488 const char *client_name
= "";
489 int is_isa
= i2c_is_isa_adapter(adapter
);
492 !i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
)) {
497 /* Reserve the ISA region */
499 if (!request_region(address
, LM78_EXTENT
,
500 lm78_isa_driver
.name
)) {
505 /* Probe whether there is anything available on this address. Already
506 done for SMBus clients */
510 #define REALLY_SLOW_IO
511 /* We need the timeouts for at least some LM78-like
512 chips. But only if we read 'undefined' registers. */
513 i
= inb_p(address
+ 1);
514 if (inb_p(address
+ 2) != i
) {
518 if (inb_p(address
+ 3) != i
) {
522 if (inb_p(address
+ 7) != i
) {
526 #undef REALLY_SLOW_IO
528 /* Let's just hope nothing breaks here */
529 i
= inb_p(address
+ 5) & 0x7f;
530 outb_p(~i
& 0x7f, address
+ 5);
531 if ((inb_p(address
+ 5) & 0x7f) != (~i
& 0x7f)) {
532 outb_p(i
, address
+ 5);
539 /* OK. For now, we presume we have a valid client. We now create the
540 client structure, even though we cannot fill it completely yet.
541 But it allows us to access lm78_{read,write}_value. */
543 if (!(data
= kmalloc(sizeof(struct lm78_data
), GFP_KERNEL
))) {
547 memset(data
, 0, sizeof(struct lm78_data
));
549 new_client
= &data
->client
;
551 init_MUTEX(&data
->lock
);
552 i2c_set_clientdata(new_client
, data
);
553 new_client
->addr
= address
;
554 new_client
->adapter
= adapter
;
555 new_client
->driver
= is_isa
? &lm78_isa_driver
: &lm78_driver
;
556 new_client
->flags
= 0;
558 /* Now, we do the remaining detection. */
560 if (lm78_read_value(new_client
, LM78_REG_CONFIG
) & 0x80) {
564 if (!is_isa
&& (lm78_read_value(
565 new_client
, LM78_REG_I2C_ADDR
) != address
)) {
571 /* Determine the chip type. */
573 i
= lm78_read_value(new_client
, LM78_REG_CHIPID
);
574 if (i
== 0x00 || i
== 0x20 /* LM78 */
575 || i
== 0x40) /* LM78-J */
577 else if ((i
& 0xfe) == 0xc0)
581 dev_warn(&adapter
->dev
, "Ignoring 'force' "
582 "parameter for unknown chip at "
583 "adapter %d, address 0x%02x\n",
584 i2c_adapter_id(adapter
), address
);
591 client_name
= "lm78";
592 } else if (kind
== lm79
) {
593 client_name
= "lm79";
596 /* Fill in the remaining client fields and put into the global list */
597 strlcpy(new_client
->name
, client_name
, I2C_NAME_SIZE
);
601 init_MUTEX(&data
->update_lock
);
603 /* Tell the I2C layer a new client has arrived */
604 if ((err
= i2c_attach_client(new_client
)))
607 /* Initialize the LM78 chip */
608 lm78_init_client(new_client
);
610 /* A few vars need to be filled upon startup */
611 for (i
= 0; i
< 3; i
++) {
612 data
->fan_min
[i
] = lm78_read_value(new_client
,
613 LM78_REG_FAN_MIN(i
));
616 /* Register sysfs hooks */
617 data
->class_dev
= hwmon_device_register(&new_client
->dev
);
618 if (IS_ERR(data
->class_dev
)) {
619 err
= PTR_ERR(data
->class_dev
);
623 device_create_file(&new_client
->dev
, &dev_attr_in0_input
);
624 device_create_file(&new_client
->dev
, &dev_attr_in0_min
);
625 device_create_file(&new_client
->dev
, &dev_attr_in0_max
);
626 device_create_file(&new_client
->dev
, &dev_attr_in1_input
);
627 device_create_file(&new_client
->dev
, &dev_attr_in1_min
);
628 device_create_file(&new_client
->dev
, &dev_attr_in1_max
);
629 device_create_file(&new_client
->dev
, &dev_attr_in2_input
);
630 device_create_file(&new_client
->dev
, &dev_attr_in2_min
);
631 device_create_file(&new_client
->dev
, &dev_attr_in2_max
);
632 device_create_file(&new_client
->dev
, &dev_attr_in3_input
);
633 device_create_file(&new_client
->dev
, &dev_attr_in3_min
);
634 device_create_file(&new_client
->dev
, &dev_attr_in3_max
);
635 device_create_file(&new_client
->dev
, &dev_attr_in4_input
);
636 device_create_file(&new_client
->dev
, &dev_attr_in4_min
);
637 device_create_file(&new_client
->dev
, &dev_attr_in4_max
);
638 device_create_file(&new_client
->dev
, &dev_attr_in5_input
);
639 device_create_file(&new_client
->dev
, &dev_attr_in5_min
);
640 device_create_file(&new_client
->dev
, &dev_attr_in5_max
);
641 device_create_file(&new_client
->dev
, &dev_attr_in6_input
);
642 device_create_file(&new_client
->dev
, &dev_attr_in6_min
);
643 device_create_file(&new_client
->dev
, &dev_attr_in6_max
);
644 device_create_file(&new_client
->dev
, &dev_attr_temp1_input
);
645 device_create_file(&new_client
->dev
, &dev_attr_temp1_max
);
646 device_create_file(&new_client
->dev
, &dev_attr_temp1_max_hyst
);
647 device_create_file(&new_client
->dev
, &dev_attr_fan1_input
);
648 device_create_file(&new_client
->dev
, &dev_attr_fan1_min
);
649 device_create_file(&new_client
->dev
, &dev_attr_fan1_div
);
650 device_create_file(&new_client
->dev
, &dev_attr_fan2_input
);
651 device_create_file(&new_client
->dev
, &dev_attr_fan2_min
);
652 device_create_file(&new_client
->dev
, &dev_attr_fan2_div
);
653 device_create_file(&new_client
->dev
, &dev_attr_fan3_input
);
654 device_create_file(&new_client
->dev
, &dev_attr_fan3_min
);
655 device_create_file(&new_client
->dev
, &dev_attr_fan3_div
);
656 device_create_file(&new_client
->dev
, &dev_attr_alarms
);
657 device_create_file(&new_client
->dev
, &dev_attr_cpu0_vid
);
662 i2c_detach_client(new_client
);
667 release_region(address
, LM78_EXTENT
);
672 static int lm78_detach_client(struct i2c_client
*client
)
674 struct lm78_data
*data
= i2c_get_clientdata(client
);
677 hwmon_device_unregister(data
->class_dev
);
679 if ((err
= i2c_detach_client(client
)))
682 if(i2c_is_isa_client(client
))
683 release_region(client
->addr
, LM78_EXTENT
);
690 /* The SMBus locks itself, but ISA access must be locked explicitly!
691 We don't want to lock the whole ISA bus, so we lock each client
693 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
694 would slow down the LM78 access and should not be necessary. */
695 static int lm78_read_value(struct i2c_client
*client
, u8 reg
)
698 if (i2c_is_isa_client(client
)) {
699 struct lm78_data
*data
= i2c_get_clientdata(client
);
701 outb_p(reg
, client
->addr
+ LM78_ADDR_REG_OFFSET
);
702 res
= inb_p(client
->addr
+ LM78_DATA_REG_OFFSET
);
706 return i2c_smbus_read_byte_data(client
, reg
);
709 /* The SMBus locks itself, but ISA access muse be locked explicitly!
710 We don't want to lock the whole ISA bus, so we lock each client
712 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
713 would slow down the LM78 access and should not be necessary.
714 There are some ugly typecasts here, but the good new is - they should
715 nowhere else be necessary! */
716 static int lm78_write_value(struct i2c_client
*client
, u8 reg
, u8 value
)
718 if (i2c_is_isa_client(client
)) {
719 struct lm78_data
*data
= i2c_get_clientdata(client
);
721 outb_p(reg
, client
->addr
+ LM78_ADDR_REG_OFFSET
);
722 outb_p(value
, client
->addr
+ LM78_DATA_REG_OFFSET
);
726 return i2c_smbus_write_byte_data(client
, reg
, value
);
729 static void lm78_init_client(struct i2c_client
*client
)
731 u8 config
= lm78_read_value(client
, LM78_REG_CONFIG
);
733 /* Start monitoring */
734 if (!(config
& 0x01))
735 lm78_write_value(client
, LM78_REG_CONFIG
,
736 (config
& 0xf7) | 0x01);
739 static struct lm78_data
*lm78_update_device(struct device
*dev
)
741 struct i2c_client
*client
= to_i2c_client(dev
);
742 struct lm78_data
*data
= i2c_get_clientdata(client
);
745 down(&data
->update_lock
);
747 if (time_after(jiffies
, data
->last_updated
+ HZ
+ HZ
/ 2)
750 dev_dbg(&client
->dev
, "Starting lm78 update\n");
752 for (i
= 0; i
<= 6; i
++) {
754 lm78_read_value(client
, LM78_REG_IN(i
));
756 lm78_read_value(client
, LM78_REG_IN_MIN(i
));
758 lm78_read_value(client
, LM78_REG_IN_MAX(i
));
760 for (i
= 0; i
< 3; i
++) {
762 lm78_read_value(client
, LM78_REG_FAN(i
));
764 lm78_read_value(client
, LM78_REG_FAN_MIN(i
));
766 data
->temp
= lm78_read_value(client
, LM78_REG_TEMP
);
768 lm78_read_value(client
, LM78_REG_TEMP_OVER
);
770 lm78_read_value(client
, LM78_REG_TEMP_HYST
);
771 i
= lm78_read_value(client
, LM78_REG_VID_FANDIV
);
772 data
->vid
= i
& 0x0f;
773 if (data
->type
== lm79
)
775 (lm78_read_value(client
, LM78_REG_CHIPID
) &
779 data
->fan_div
[0] = (i
>> 4) & 0x03;
780 data
->fan_div
[1] = i
>> 6;
781 data
->alarms
= lm78_read_value(client
, LM78_REG_ALARM1
) +
782 (lm78_read_value(client
, LM78_REG_ALARM2
) << 8);
783 data
->last_updated
= jiffies
;
786 data
->fan_div
[2] = 1;
789 up(&data
->update_lock
);
794 static int __init
sm_lm78_init(void)
798 res
= i2c_add_driver(&lm78_driver
);
802 res
= i2c_isa_add_driver(&lm78_isa_driver
);
804 i2c_del_driver(&lm78_driver
);
811 static void __exit
sm_lm78_exit(void)
813 i2c_isa_del_driver(&lm78_isa_driver
);
814 i2c_del_driver(&lm78_driver
);
819 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
820 MODULE_DESCRIPTION("LM78/LM79 driver");
821 MODULE_LICENSE("GPL");
823 module_init(sm_lm78_init
);
824 module_exit(sm_lm78_exit
);