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/err.h>
31 /* Addresses to scan */
32 static unsigned short normal_i2c[] = { 0x20, 0x21, 0x22, 0x23, 0x24,
33 0x25, 0x26, 0x27, 0x28, 0x29,
34 0x2a, 0x2b, 0x2c, 0x2d, 0x2e,
35 0x2f, I2C_CLIENT_END };
36 static unsigned short isa_address = 0x290;
38 /* Insmod parameters */
39 I2C_CLIENT_INSMOD_2(lm78, lm79);
41 /* Many LM78 constants specified below */
43 /* Length of ISA address segment */
46 /* Where are the ISA address/data registers relative to the base address */
47 #define LM78_ADDR_REG_OFFSET 5
48 #define LM78_DATA_REG_OFFSET 6
50 /* The LM78 registers */
51 #define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)
52 #define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)
53 #define LM78_REG_IN(nr) (0x20 + (nr))
55 #define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
56 #define LM78_REG_FAN(nr) (0x28 + (nr))
58 #define LM78_REG_TEMP 0x27
59 #define LM78_REG_TEMP_OVER 0x39
60 #define LM78_REG_TEMP_HYST 0x3a
62 #define LM78_REG_ALARM1 0x41
63 #define LM78_REG_ALARM2 0x42
65 #define LM78_REG_VID_FANDIV 0x47
67 #define LM78_REG_CONFIG 0x40
68 #define LM78_REG_CHIPID 0x49
69 #define LM78_REG_I2C_ADDR 0x48
72 /* Conversions. Rounding and limit checking is only done on the TO_REG
75 /* IN: mV, (0V to 4.08V)
77 static inline u8 IN_TO_REG(unsigned long val)
79 unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
80 return (nval + 8) / 16;
82 #define IN_FROM_REG(val) ((val) * 16)
84 static inline u8 FAN_TO_REG(long rpm, int div)
88 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
91 static inline int FAN_FROM_REG(u8 val, int div)
93 return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div);
96 /* TEMP: mC (-128C to +127C)
97 REG: 1C/bit, two's complement */
98 static inline s8 TEMP_TO_REG(int val)
100 int nval = SENSORS_LIMIT(val, -128000, 127000) ;
101 return nval<0 ? (nval-500)/1000 : (nval+500)/1000;
104 static inline int TEMP_FROM_REG(s8 val)
110 REG: (see doc/vid) */
111 static inline int VID_FROM_REG(u8 val)
113 return val==0x1f ? 0 : val>=0x10 ? 5100-val*100 : 2050-val*50;
116 #define DIV_FROM_REG(val) (1 << (val))
118 /* There are some complications in a module like this. First off, LM78 chips
119 may be both present on the SMBus and the ISA bus, and we have to handle
120 those cases separately at some places. Second, there might be several
121 LM78 chips available (well, actually, that is probably never done; but
122 it is a clean illustration of how to handle a case like that). Finally,
123 a specific chip may be attached to *both* ISA and SMBus, and we would
124 not like to detect it double. Fortunately, in the case of the LM78 at
125 least, a register tells us what SMBus address we are on, so that helps
126 a bit - except if there could be more than one SMBus. Groan. No solution
129 /* This module may seem overly long and complicated. In fact, it is not so
130 bad. Quite a lot of bookkeeping is done. A real driver can often cut
133 /* For each registered LM78, we need to keep some data in memory. That
134 data is pointed to by lm78_list[NR]->data. The structure itself is
135 dynamically allocated, at the same time when a new lm78 client is
138 struct i2c_client client;
139 struct class_device *class_dev;
140 struct semaphore lock;
143 struct semaphore update_lock;
144 char valid; /* !=0 if following fields are valid */
145 unsigned long last_updated; /* In jiffies */
147 u8 in[7]; /* Register value */
148 u8 in_max[7]; /* Register value */
149 u8 in_min[7]; /* Register value */
150 u8 fan[3]; /* Register value */
151 u8 fan_min[3]; /* Register value */
152 s8 temp; /* Register value */
153 s8 temp_over; /* Register value */
154 s8 temp_hyst; /* Register value */
155 u8 fan_div[3]; /* Register encoding, shifted right */
156 u8 vid; /* Register encoding, combined */
157 u16 alarms; /* Register encoding, combined */
161 static int lm78_attach_adapter(struct i2c_adapter *adapter);
162 static int lm78_isa_attach_adapter(struct i2c_adapter *adapter);
163 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind);
164 static int lm78_detach_client(struct i2c_client *client);
166 static int lm78_read_value(struct i2c_client *client, u8 register);
167 static int lm78_write_value(struct i2c_client *client, u8 register, u8 value);
168 static struct lm78_data *lm78_update_device(struct device *dev);
169 static void lm78_init_client(struct i2c_client *client);
172 static struct i2c_driver lm78_driver = {
173 .owner = THIS_MODULE,
175 .id = I2C_DRIVERID_LM78,
176 .flags = I2C_DF_NOTIFY,
177 .attach_adapter = lm78_attach_adapter,
178 .detach_client = lm78_detach_client,
181 static struct i2c_driver lm78_isa_driver = {
182 .owner = THIS_MODULE,
184 .attach_adapter = lm78_isa_attach_adapter,
185 .detach_client = lm78_detach_client,
190 static ssize_t show_in(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[nr]));
196 static ssize_t show_in_min(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_min[nr]));
202 static ssize_t show_in_max(struct device *dev, char *buf, int nr)
204 struct lm78_data *data = lm78_update_device(dev);
205 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
208 static ssize_t set_in_min(struct device *dev, const char *buf,
209 size_t count, int nr)
211 struct i2c_client *client = to_i2c_client(dev);
212 struct lm78_data *data = i2c_get_clientdata(client);
213 unsigned long val = simple_strtoul(buf, NULL, 10);
215 down(&data->update_lock);
216 data->in_min[nr] = IN_TO_REG(val);
217 lm78_write_value(client, LM78_REG_IN_MIN(nr), data->in_min[nr]);
218 up(&data->update_lock);
222 static ssize_t set_in_max(struct device *dev, const char *buf,
223 size_t count, int nr)
225 struct i2c_client *client = to_i2c_client(dev);
226 struct lm78_data *data = i2c_get_clientdata(client);
227 unsigned long val = simple_strtoul(buf, NULL, 10);
229 down(&data->update_lock);
230 data->in_max[nr] = IN_TO_REG(val);
231 lm78_write_value(client, LM78_REG_IN_MAX(nr), data->in_max[nr]);
232 up(&data->update_lock);
236 #define show_in_offset(offset) \
238 show_in##offset (struct device *dev, struct device_attribute *attr, char *buf) \
240 return show_in(dev, buf, offset); \
242 static DEVICE_ATTR(in##offset##_input, S_IRUGO, \
243 show_in##offset, NULL); \
245 show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \
247 return show_in_min(dev, buf, offset); \
250 show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf) \
252 return show_in_max(dev, buf, offset); \
254 static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr, \
255 const char *buf, size_t count) \
257 return set_in_min(dev, buf, count, offset); \
259 static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr, \
260 const char *buf, size_t count) \
262 return set_in_max(dev, buf, count, offset); \
264 static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
265 show_in##offset##_min, set_in##offset##_min); \
266 static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
267 show_in##offset##_max, set_in##offset##_max);
278 static ssize_t show_temp(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));
284 static ssize_t show_temp_over(struct device *dev, struct device_attribute *attr, char *buf)
286 struct lm78_data *data = lm78_update_device(dev);
287 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
290 static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
292 struct i2c_client *client = to_i2c_client(dev);
293 struct lm78_data *data = i2c_get_clientdata(client);
294 long val = simple_strtol(buf, NULL, 10);
296 down(&data->update_lock);
297 data->temp_over = TEMP_TO_REG(val);
298 lm78_write_value(client, LM78_REG_TEMP_OVER, data->temp_over);
299 up(&data->update_lock);
303 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf)
305 struct lm78_data *data = lm78_update_device(dev);
306 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
309 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
311 struct i2c_client *client = to_i2c_client(dev);
312 struct lm78_data *data = i2c_get_clientdata(client);
313 long val = simple_strtol(buf, NULL, 10);
315 down(&data->update_lock);
316 data->temp_hyst = TEMP_TO_REG(val);
317 lm78_write_value(client, LM78_REG_TEMP_HYST, data->temp_hyst);
318 up(&data->update_lock);
322 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
323 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
324 show_temp_over, set_temp_over);
325 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
326 show_temp_hyst, set_temp_hyst);
329 static ssize_t show_fan(struct device *dev, char *buf, int nr)
331 struct lm78_data *data = lm78_update_device(dev);
332 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
333 DIV_FROM_REG(data->fan_div[nr])) );
336 static ssize_t show_fan_min(struct device *dev, char *buf, int nr)
338 struct lm78_data *data = lm78_update_device(dev);
339 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr],
340 DIV_FROM_REG(data->fan_div[nr])) );
343 static ssize_t set_fan_min(struct device *dev, const char *buf,
344 size_t count, int nr)
346 struct i2c_client *client = to_i2c_client(dev);
347 struct lm78_data *data = i2c_get_clientdata(client);
348 unsigned long val = simple_strtoul(buf, NULL, 10);
350 down(&data->update_lock);
351 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
352 lm78_write_value(client, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
353 up(&data->update_lock);
357 static ssize_t show_fan_div(struct device *dev, char *buf, int nr)
359 struct lm78_data *data = lm78_update_device(dev);
360 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) );
363 /* Note: we save and restore the fan minimum here, because its value is
364 determined in part by the fan divisor. This follows the principle of
365 least suprise; the user doesn't expect the fan minimum to change just
366 because the divisor changed. */
367 static ssize_t set_fan_div(struct device *dev, const char *buf,
368 size_t count, int nr)
370 struct i2c_client *client = to_i2c_client(dev);
371 struct lm78_data *data = i2c_get_clientdata(client);
372 unsigned long val = simple_strtoul(buf, NULL, 10);
376 down(&data->update_lock);
377 min = FAN_FROM_REG(data->fan_min[nr],
378 DIV_FROM_REG(data->fan_div[nr]));
381 case 1: data->fan_div[nr] = 0; break;
382 case 2: data->fan_div[nr] = 1; break;
383 case 4: data->fan_div[nr] = 2; break;
384 case 8: data->fan_div[nr] = 3; break;
386 dev_err(&client->dev, "fan_div value %ld not "
387 "supported. Choose one of 1, 2, 4 or 8!\n", val);
388 up(&data->update_lock);
392 reg = lm78_read_value(client, LM78_REG_VID_FANDIV);
395 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
398 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
401 lm78_write_value(client, LM78_REG_VID_FANDIV, reg);
404 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
405 lm78_write_value(client, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
406 up(&data->update_lock);
411 #define show_fan_offset(offset) \
412 static ssize_t show_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
414 return show_fan(dev, buf, offset - 1); \
416 static ssize_t show_fan_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \
418 return show_fan_min(dev, buf, offset - 1); \
420 static ssize_t show_fan_##offset##_div (struct device *dev, struct device_attribute *attr, char *buf) \
422 return show_fan_div(dev, buf, offset - 1); \
424 static ssize_t set_fan_##offset##_min (struct device *dev, struct device_attribute *attr, \
425 const char *buf, size_t count) \
427 return set_fan_min(dev, buf, count, offset - 1); \
429 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, NULL);\
430 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
431 show_fan_##offset##_min, set_fan_##offset##_min);
433 static ssize_t set_fan_1_div(struct device *dev, struct device_attribute *attr, const char *buf,
436 return set_fan_div(dev, buf, count, 0) ;
439 static ssize_t set_fan_2_div(struct device *dev, struct device_attribute *attr, const char *buf,
442 return set_fan_div(dev, buf, count, 1) ;
449 /* Fan 3 divisor is locked in H/W */
450 static DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
451 show_fan_1_div, set_fan_1_div);
452 static DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
453 show_fan_2_div, set_fan_2_div);
454 static DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_3_div, NULL);
457 static ssize_t show_vid(struct device *dev, struct device_attribute *attr, char *buf)
459 struct lm78_data *data = lm78_update_device(dev);
460 return sprintf(buf, "%d\n", VID_FROM_REG(data->vid));
462 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
465 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
467 struct lm78_data *data = lm78_update_device(dev);
468 return sprintf(buf, "%u\n", data->alarms);
470 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
472 /* This function is called when:
473 * lm78_driver is inserted (when this module is loaded), for each
475 * when a new adapter is inserted (and lm78_driver is still present) */
476 static int lm78_attach_adapter(struct i2c_adapter *adapter)
478 if (!(adapter->class & I2C_CLASS_HWMON))
480 return i2c_probe(adapter, &addr_data, lm78_detect);
483 static int lm78_isa_attach_adapter(struct i2c_adapter *adapter)
485 return lm78_detect(adapter, isa_address, -1);
488 /* This function is called by i2c_probe */
489 int lm78_detect(struct i2c_adapter *adapter, int address, int kind)
492 struct i2c_client *new_client;
493 struct lm78_data *data;
494 const char *client_name = "";
495 int is_isa = i2c_is_isa_adapter(adapter);
498 !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
503 /* Reserve the ISA region */
505 if (!request_region(address, LM78_EXTENT,
506 lm78_isa_driver.name)) {
511 /* Probe whether there is anything available on this address. Already
512 done for SMBus clients */
516 #define REALLY_SLOW_IO
517 /* We need the timeouts for at least some LM78-like
518 chips. But only if we read 'undefined' registers. */
519 i = inb_p(address + 1);
520 if (inb_p(address + 2) != i) {
524 if (inb_p(address + 3) != i) {
528 if (inb_p(address + 7) != i) {
532 #undef REALLY_SLOW_IO
534 /* Let's just hope nothing breaks here */
535 i = inb_p(address + 5) & 0x7f;
536 outb_p(~i & 0x7f, address + 5);
537 if ((inb_p(address + 5) & 0x7f) != (~i & 0x7f)) {
538 outb_p(i, address + 5);
545 /* OK. For now, we presume we have a valid client. We now create the
546 client structure, even though we cannot fill it completely yet.
547 But it allows us to access lm78_{read,write}_value. */
549 if (!(data = kmalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
553 memset(data, 0, sizeof(struct lm78_data));
555 new_client = &data->client;
557 init_MUTEX(&data->lock);
558 i2c_set_clientdata(new_client, data);
559 new_client->addr = address;
560 new_client->adapter = adapter;
561 new_client->driver = is_isa ? &lm78_isa_driver : &lm78_driver;
562 new_client->flags = 0;
564 /* Now, we do the remaining detection. */
566 if (lm78_read_value(new_client, LM78_REG_CONFIG) & 0x80) {
570 if (!is_isa && (lm78_read_value(
571 new_client, LM78_REG_I2C_ADDR) != address)) {
577 /* Determine the chip type. */
579 i = lm78_read_value(new_client, LM78_REG_CHIPID);
580 if (i == 0x00 || i == 0x20 /* LM78 */
581 || i == 0x40) /* LM78-J */
583 else if ((i & 0xfe) == 0xc0)
587 dev_warn(&adapter->dev, "Ignoring 'force' "
588 "parameter for unknown chip at "
589 "adapter %d, address 0x%02x\n",
590 i2c_adapter_id(adapter), address);
597 client_name = "lm78";
598 } else if (kind == lm79) {
599 client_name = "lm79";
602 /* Fill in the remaining client fields and put into the global list */
603 strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
607 init_MUTEX(&data->update_lock);
609 /* Tell the I2C layer a new client has arrived */
610 if ((err = i2c_attach_client(new_client)))
613 /* Initialize the LM78 chip */
614 lm78_init_client(new_client);
616 /* A few vars need to be filled upon startup */
617 for (i = 0; i < 3; i++) {
618 data->fan_min[i] = lm78_read_value(new_client,
619 LM78_REG_FAN_MIN(i));
622 /* Register sysfs hooks */
623 data->class_dev = hwmon_device_register(&new_client->dev);
624 if (IS_ERR(data->class_dev)) {
625 err = PTR_ERR(data->class_dev);
629 device_create_file(&new_client->dev, &dev_attr_in0_input);
630 device_create_file(&new_client->dev, &dev_attr_in0_min);
631 device_create_file(&new_client->dev, &dev_attr_in0_max);
632 device_create_file(&new_client->dev, &dev_attr_in1_input);
633 device_create_file(&new_client->dev, &dev_attr_in1_min);
634 device_create_file(&new_client->dev, &dev_attr_in1_max);
635 device_create_file(&new_client->dev, &dev_attr_in2_input);
636 device_create_file(&new_client->dev, &dev_attr_in2_min);
637 device_create_file(&new_client->dev, &dev_attr_in2_max);
638 device_create_file(&new_client->dev, &dev_attr_in3_input);
639 device_create_file(&new_client->dev, &dev_attr_in3_min);
640 device_create_file(&new_client->dev, &dev_attr_in3_max);
641 device_create_file(&new_client->dev, &dev_attr_in4_input);
642 device_create_file(&new_client->dev, &dev_attr_in4_min);
643 device_create_file(&new_client->dev, &dev_attr_in4_max);
644 device_create_file(&new_client->dev, &dev_attr_in5_input);
645 device_create_file(&new_client->dev, &dev_attr_in5_min);
646 device_create_file(&new_client->dev, &dev_attr_in5_max);
647 device_create_file(&new_client->dev, &dev_attr_in6_input);
648 device_create_file(&new_client->dev, &dev_attr_in6_min);
649 device_create_file(&new_client->dev, &dev_attr_in6_max);
650 device_create_file(&new_client->dev, &dev_attr_temp1_input);
651 device_create_file(&new_client->dev, &dev_attr_temp1_max);
652 device_create_file(&new_client->dev, &dev_attr_temp1_max_hyst);
653 device_create_file(&new_client->dev, &dev_attr_fan1_input);
654 device_create_file(&new_client->dev, &dev_attr_fan1_min);
655 device_create_file(&new_client->dev, &dev_attr_fan1_div);
656 device_create_file(&new_client->dev, &dev_attr_fan2_input);
657 device_create_file(&new_client->dev, &dev_attr_fan2_min);
658 device_create_file(&new_client->dev, &dev_attr_fan2_div);
659 device_create_file(&new_client->dev, &dev_attr_fan3_input);
660 device_create_file(&new_client->dev, &dev_attr_fan3_min);
661 device_create_file(&new_client->dev, &dev_attr_fan3_div);
662 device_create_file(&new_client->dev, &dev_attr_alarms);
663 device_create_file(&new_client->dev, &dev_attr_cpu0_vid);
668 i2c_detach_client(new_client);
673 release_region(address, LM78_EXTENT);
678 static int lm78_detach_client(struct i2c_client *client)
680 struct lm78_data *data = i2c_get_clientdata(client);
683 hwmon_device_unregister(data->class_dev);
685 if ((err = i2c_detach_client(client)))
688 if(i2c_is_isa_client(client))
689 release_region(client->addr, LM78_EXTENT);
696 /* The SMBus locks itself, but ISA access must be locked explicitly!
697 We don't want to lock the whole ISA bus, so we lock each client
699 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
700 would slow down the LM78 access and should not be necessary. */
701 static int lm78_read_value(struct i2c_client *client, u8 reg)
704 if (i2c_is_isa_client(client)) {
705 struct lm78_data *data = i2c_get_clientdata(client);
707 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
708 res = inb_p(client->addr + LM78_DATA_REG_OFFSET);
712 return i2c_smbus_read_byte_data(client, reg);
715 /* The SMBus locks itself, but ISA access muse be locked explicitly!
716 We don't want to lock the whole ISA bus, so we lock each client
718 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
719 would slow down the LM78 access and should not be necessary.
720 There are some ugly typecasts here, but the good new is - they should
721 nowhere else be necessary! */
722 static int lm78_write_value(struct i2c_client *client, u8 reg, u8 value)
724 if (i2c_is_isa_client(client)) {
725 struct lm78_data *data = i2c_get_clientdata(client);
727 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
728 outb_p(value, client->addr + LM78_DATA_REG_OFFSET);
732 return i2c_smbus_write_byte_data(client, reg, value);
735 /* Called when we have found a new LM78. It should set limits, etc. */
736 static void lm78_init_client(struct i2c_client *client)
738 u8 config = lm78_read_value(client, LM78_REG_CONFIG);
740 /* Start monitoring */
741 if (!(config & 0x01))
742 lm78_write_value(client, LM78_REG_CONFIG,
743 (config & 0xf7) | 0x01);
746 static struct lm78_data *lm78_update_device(struct device *dev)
748 struct i2c_client *client = to_i2c_client(dev);
749 struct lm78_data *data = i2c_get_clientdata(client);
752 down(&data->update_lock);
754 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
757 dev_dbg(&client->dev, "Starting lm78 update\n");
759 for (i = 0; i <= 6; i++) {
761 lm78_read_value(client, LM78_REG_IN(i));
763 lm78_read_value(client, LM78_REG_IN_MIN(i));
765 lm78_read_value(client, LM78_REG_IN_MAX(i));
767 for (i = 0; i < 3; i++) {
769 lm78_read_value(client, LM78_REG_FAN(i));
771 lm78_read_value(client, LM78_REG_FAN_MIN(i));
773 data->temp = lm78_read_value(client, LM78_REG_TEMP);
775 lm78_read_value(client, LM78_REG_TEMP_OVER);
777 lm78_read_value(client, LM78_REG_TEMP_HYST);
778 i = lm78_read_value(client, LM78_REG_VID_FANDIV);
779 data->vid = i & 0x0f;
780 if (data->type == lm79)
782 (lm78_read_value(client, LM78_REG_CHIPID) &
786 data->fan_div[0] = (i >> 4) & 0x03;
787 data->fan_div[1] = i >> 6;
788 data->alarms = lm78_read_value(client, LM78_REG_ALARM1) +
789 (lm78_read_value(client, LM78_REG_ALARM2) << 8);
790 data->last_updated = jiffies;
793 data->fan_div[2] = 1;
796 up(&data->update_lock);
801 static int __init sm_lm78_init(void)
805 res = i2c_add_driver(&lm78_driver);
809 res = i2c_isa_add_driver(&lm78_isa_driver);
811 i2c_del_driver(&lm78_driver);
818 static void __exit sm_lm78_exit(void)
820 i2c_isa_del_driver(&lm78_isa_driver);
821 i2c_del_driver(&lm78_driver);
826 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
827 MODULE_DESCRIPTION("LM78/LM79 driver");
828 MODULE_LICENSE("GPL");
830 module_init(sm_lm78_init);
831 module_exit(sm_lm78_exit);