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 .attach_adapter = lm78_attach_adapter,
171 .detach_client = lm78_detach_client,
174 static struct i2c_driver lm78_isa_driver = {
175 .owner = THIS_MODULE,
177 .attach_adapter = lm78_isa_attach_adapter,
178 .detach_client = lm78_detach_client,
183 static ssize_t show_in(struct device *dev, char *buf, int nr)
185 struct lm78_data *data = lm78_update_device(dev);
186 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
189 static ssize_t show_in_min(struct device *dev, char *buf, int nr)
191 struct lm78_data *data = lm78_update_device(dev);
192 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
195 static ssize_t show_in_max(struct device *dev, char *buf, int nr)
197 struct lm78_data *data = lm78_update_device(dev);
198 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
201 static ssize_t set_in_min(struct device *dev, const char *buf,
202 size_t count, int nr)
204 struct i2c_client *client = to_i2c_client(dev);
205 struct lm78_data *data = i2c_get_clientdata(client);
206 unsigned long val = simple_strtoul(buf, NULL, 10);
208 down(&data->update_lock);
209 data->in_min[nr] = IN_TO_REG(val);
210 lm78_write_value(client, LM78_REG_IN_MIN(nr), data->in_min[nr]);
211 up(&data->update_lock);
215 static ssize_t set_in_max(struct device *dev, const char *buf,
216 size_t count, int nr)
218 struct i2c_client *client = to_i2c_client(dev);
219 struct lm78_data *data = i2c_get_clientdata(client);
220 unsigned long val = simple_strtoul(buf, NULL, 10);
222 down(&data->update_lock);
223 data->in_max[nr] = IN_TO_REG(val);
224 lm78_write_value(client, LM78_REG_IN_MAX(nr), data->in_max[nr]);
225 up(&data->update_lock);
229 #define show_in_offset(offset) \
231 show_in##offset (struct device *dev, struct device_attribute *attr, char *buf) \
233 return show_in(dev, buf, offset); \
235 static DEVICE_ATTR(in##offset##_input, S_IRUGO, \
236 show_in##offset, NULL); \
238 show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \
240 return show_in_min(dev, buf, offset); \
243 show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf) \
245 return show_in_max(dev, buf, offset); \
247 static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr, \
248 const char *buf, size_t count) \
250 return set_in_min(dev, buf, count, offset); \
252 static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr, \
253 const char *buf, size_t count) \
255 return set_in_max(dev, buf, count, offset); \
257 static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
258 show_in##offset##_min, set_in##offset##_min); \
259 static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
260 show_in##offset##_max, set_in##offset##_max);
271 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf)
273 struct lm78_data *data = lm78_update_device(dev);
274 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
277 static ssize_t show_temp_over(struct device *dev, struct device_attribute *attr, char *buf)
279 struct lm78_data *data = lm78_update_device(dev);
280 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
283 static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
285 struct i2c_client *client = to_i2c_client(dev);
286 struct lm78_data *data = i2c_get_clientdata(client);
287 long val = simple_strtol(buf, NULL, 10);
289 down(&data->update_lock);
290 data->temp_over = TEMP_TO_REG(val);
291 lm78_write_value(client, LM78_REG_TEMP_OVER, data->temp_over);
292 up(&data->update_lock);
296 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf)
298 struct lm78_data *data = lm78_update_device(dev);
299 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
302 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
304 struct i2c_client *client = to_i2c_client(dev);
305 struct lm78_data *data = i2c_get_clientdata(client);
306 long val = simple_strtol(buf, NULL, 10);
308 down(&data->update_lock);
309 data->temp_hyst = TEMP_TO_REG(val);
310 lm78_write_value(client, LM78_REG_TEMP_HYST, data->temp_hyst);
311 up(&data->update_lock);
315 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
316 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
317 show_temp_over, set_temp_over);
318 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
319 show_temp_hyst, set_temp_hyst);
322 static ssize_t show_fan(struct device *dev, char *buf, int nr)
324 struct lm78_data *data = lm78_update_device(dev);
325 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
326 DIV_FROM_REG(data->fan_div[nr])) );
329 static ssize_t show_fan_min(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_min[nr],
333 DIV_FROM_REG(data->fan_div[nr])) );
336 static ssize_t set_fan_min(struct device *dev, const char *buf,
337 size_t count, int nr)
339 struct i2c_client *client = to_i2c_client(dev);
340 struct lm78_data *data = i2c_get_clientdata(client);
341 unsigned long val = simple_strtoul(buf, NULL, 10);
343 down(&data->update_lock);
344 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
345 lm78_write_value(client, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
346 up(&data->update_lock);
350 static ssize_t show_fan_div(struct device *dev, char *buf, int nr)
352 struct lm78_data *data = lm78_update_device(dev);
353 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) );
356 /* Note: we save and restore the fan minimum here, because its value is
357 determined in part by the fan divisor. This follows the principle of
358 least suprise; the user doesn't expect the fan minimum to change just
359 because the divisor changed. */
360 static ssize_t set_fan_div(struct device *dev, const char *buf,
361 size_t count, int nr)
363 struct i2c_client *client = to_i2c_client(dev);
364 struct lm78_data *data = i2c_get_clientdata(client);
365 unsigned long val = simple_strtoul(buf, NULL, 10);
369 down(&data->update_lock);
370 min = FAN_FROM_REG(data->fan_min[nr],
371 DIV_FROM_REG(data->fan_div[nr]));
374 case 1: data->fan_div[nr] = 0; break;
375 case 2: data->fan_div[nr] = 1; break;
376 case 4: data->fan_div[nr] = 2; break;
377 case 8: data->fan_div[nr] = 3; break;
379 dev_err(&client->dev, "fan_div value %ld not "
380 "supported. Choose one of 1, 2, 4 or 8!\n", val);
381 up(&data->update_lock);
385 reg = lm78_read_value(client, LM78_REG_VID_FANDIV);
388 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
391 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
394 lm78_write_value(client, LM78_REG_VID_FANDIV, reg);
397 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
398 lm78_write_value(client, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
399 up(&data->update_lock);
404 #define show_fan_offset(offset) \
405 static ssize_t show_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf) \
407 return show_fan(dev, buf, offset - 1); \
409 static ssize_t show_fan_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \
411 return show_fan_min(dev, buf, offset - 1); \
413 static ssize_t show_fan_##offset##_div (struct device *dev, struct device_attribute *attr, char *buf) \
415 return show_fan_div(dev, buf, offset - 1); \
417 static ssize_t set_fan_##offset##_min (struct device *dev, struct device_attribute *attr, \
418 const char *buf, size_t count) \
420 return set_fan_min(dev, buf, count, offset - 1); \
422 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, NULL);\
423 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
424 show_fan_##offset##_min, set_fan_##offset##_min);
426 static ssize_t set_fan_1_div(struct device *dev, struct device_attribute *attr, const char *buf,
429 return set_fan_div(dev, buf, count, 0) ;
432 static ssize_t set_fan_2_div(struct device *dev, struct device_attribute *attr, const char *buf,
435 return set_fan_div(dev, buf, count, 1) ;
442 /* Fan 3 divisor is locked in H/W */
443 static DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
444 show_fan_1_div, set_fan_1_div);
445 static DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
446 show_fan_2_div, set_fan_2_div);
447 static DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_3_div, NULL);
450 static ssize_t show_vid(struct device *dev, struct device_attribute *attr, char *buf)
452 struct lm78_data *data = lm78_update_device(dev);
453 return sprintf(buf, "%d\n", vid_from_reg(data->vid, 82));
455 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
458 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
460 struct lm78_data *data = lm78_update_device(dev);
461 return sprintf(buf, "%u\n", data->alarms);
463 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
465 /* This function is called when:
466 * lm78_driver is inserted (when this module is loaded), for each
468 * when a new adapter is inserted (and lm78_driver is still present) */
469 static int lm78_attach_adapter(struct i2c_adapter *adapter)
471 if (!(adapter->class & I2C_CLASS_HWMON))
473 return i2c_probe(adapter, &addr_data, lm78_detect);
476 static int lm78_isa_attach_adapter(struct i2c_adapter *adapter)
478 return lm78_detect(adapter, isa_address, -1);
481 /* This function is called by i2c_probe */
482 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind)
485 struct i2c_client *new_client;
486 struct lm78_data *data;
487 const char *client_name = "";
488 int is_isa = i2c_is_isa_adapter(adapter);
491 !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
496 /* Reserve the ISA region */
498 if (!request_region(address, LM78_EXTENT,
499 lm78_isa_driver.name)) {
504 /* Probe whether there is anything available on this address. Already
505 done for SMBus clients */
509 #define REALLY_SLOW_IO
510 /* We need the timeouts for at least some LM78-like
511 chips. But only if we read 'undefined' registers. */
512 i = inb_p(address + 1);
513 if (inb_p(address + 2) != i) {
517 if (inb_p(address + 3) != i) {
521 if (inb_p(address + 7) != i) {
525 #undef REALLY_SLOW_IO
527 /* Let's just hope nothing breaks here */
528 i = inb_p(address + 5) & 0x7f;
529 outb_p(~i & 0x7f, address + 5);
530 if ((inb_p(address + 5) & 0x7f) != (~i & 0x7f)) {
531 outb_p(i, address + 5);
538 /* OK. For now, we presume we have a valid client. We now create the
539 client structure, even though we cannot fill it completely yet.
540 But it allows us to access lm78_{read,write}_value. */
542 if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
547 new_client = &data->client;
549 init_MUTEX(&data->lock);
550 i2c_set_clientdata(new_client, data);
551 new_client->addr = address;
552 new_client->adapter = adapter;
553 new_client->driver = is_isa ? &lm78_isa_driver : &lm78_driver;
554 new_client->flags = 0;
556 /* Now, we do the remaining detection. */
558 if (lm78_read_value(new_client, LM78_REG_CONFIG) & 0x80) {
562 if (!is_isa && (lm78_read_value(
563 new_client, LM78_REG_I2C_ADDR) != address)) {
569 /* Determine the chip type. */
571 i = lm78_read_value(new_client, LM78_REG_CHIPID);
572 if (i == 0x00 || i == 0x20 /* LM78 */
573 || i == 0x40) /* LM78-J */
575 else if ((i & 0xfe) == 0xc0)
579 dev_warn(&adapter->dev, "Ignoring 'force' "
580 "parameter for unknown chip at "
581 "adapter %d, address 0x%02x\n",
582 i2c_adapter_id(adapter), address);
589 client_name = "lm78";
590 } else if (kind == lm79) {
591 client_name = "lm79";
594 /* Fill in the remaining client fields and put into the global list */
595 strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
599 init_MUTEX(&data->update_lock);
601 /* Tell the I2C layer a new client has arrived */
602 if ((err = i2c_attach_client(new_client)))
605 /* Initialize the LM78 chip */
606 lm78_init_client(new_client);
608 /* A few vars need to be filled upon startup */
609 for (i = 0; i < 3; i++) {
610 data->fan_min[i] = lm78_read_value(new_client,
611 LM78_REG_FAN_MIN(i));
614 /* Register sysfs hooks */
615 data->class_dev = hwmon_device_register(&new_client->dev);
616 if (IS_ERR(data->class_dev)) {
617 err = PTR_ERR(data->class_dev);
621 device_create_file(&new_client->dev, &dev_attr_in0_input);
622 device_create_file(&new_client->dev, &dev_attr_in0_min);
623 device_create_file(&new_client->dev, &dev_attr_in0_max);
624 device_create_file(&new_client->dev, &dev_attr_in1_input);
625 device_create_file(&new_client->dev, &dev_attr_in1_min);
626 device_create_file(&new_client->dev, &dev_attr_in1_max);
627 device_create_file(&new_client->dev, &dev_attr_in2_input);
628 device_create_file(&new_client->dev, &dev_attr_in2_min);
629 device_create_file(&new_client->dev, &dev_attr_in2_max);
630 device_create_file(&new_client->dev, &dev_attr_in3_input);
631 device_create_file(&new_client->dev, &dev_attr_in3_min);
632 device_create_file(&new_client->dev, &dev_attr_in3_max);
633 device_create_file(&new_client->dev, &dev_attr_in4_input);
634 device_create_file(&new_client->dev, &dev_attr_in4_min);
635 device_create_file(&new_client->dev, &dev_attr_in4_max);
636 device_create_file(&new_client->dev, &dev_attr_in5_input);
637 device_create_file(&new_client->dev, &dev_attr_in5_min);
638 device_create_file(&new_client->dev, &dev_attr_in5_max);
639 device_create_file(&new_client->dev, &dev_attr_in6_input);
640 device_create_file(&new_client->dev, &dev_attr_in6_min);
641 device_create_file(&new_client->dev, &dev_attr_in6_max);
642 device_create_file(&new_client->dev, &dev_attr_temp1_input);
643 device_create_file(&new_client->dev, &dev_attr_temp1_max);
644 device_create_file(&new_client->dev, &dev_attr_temp1_max_hyst);
645 device_create_file(&new_client->dev, &dev_attr_fan1_input);
646 device_create_file(&new_client->dev, &dev_attr_fan1_min);
647 device_create_file(&new_client->dev, &dev_attr_fan1_div);
648 device_create_file(&new_client->dev, &dev_attr_fan2_input);
649 device_create_file(&new_client->dev, &dev_attr_fan2_min);
650 device_create_file(&new_client->dev, &dev_attr_fan2_div);
651 device_create_file(&new_client->dev, &dev_attr_fan3_input);
652 device_create_file(&new_client->dev, &dev_attr_fan3_min);
653 device_create_file(&new_client->dev, &dev_attr_fan3_div);
654 device_create_file(&new_client->dev, &dev_attr_alarms);
655 device_create_file(&new_client->dev, &dev_attr_cpu0_vid);
660 i2c_detach_client(new_client);
665 release_region(address, LM78_EXTENT);
670 static int lm78_detach_client(struct i2c_client *client)
672 struct lm78_data *data = i2c_get_clientdata(client);
675 hwmon_device_unregister(data->class_dev);
677 if ((err = i2c_detach_client(client)))
680 if(i2c_is_isa_client(client))
681 release_region(client->addr, LM78_EXTENT);
688 /* The SMBus locks itself, but ISA access must be locked explicitly!
689 We don't want to lock the whole ISA bus, so we lock each client
691 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
692 would slow down the LM78 access and should not be necessary. */
693 static int lm78_read_value(struct i2c_client *client, u8 reg)
696 if (i2c_is_isa_client(client)) {
697 struct lm78_data *data = i2c_get_clientdata(client);
699 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
700 res = inb_p(client->addr + LM78_DATA_REG_OFFSET);
704 return i2c_smbus_read_byte_data(client, reg);
707 /* The SMBus locks itself, but ISA access muse be locked explicitly!
708 We don't want to lock the whole ISA bus, so we lock each client
710 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
711 would slow down the LM78 access and should not be necessary.
712 There are some ugly typecasts here, but the good new is - they should
713 nowhere else be necessary! */
714 static int lm78_write_value(struct i2c_client *client, u8 reg, u8 value)
716 if (i2c_is_isa_client(client)) {
717 struct lm78_data *data = i2c_get_clientdata(client);
719 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
720 outb_p(value, client->addr + LM78_DATA_REG_OFFSET);
724 return i2c_smbus_write_byte_data(client, reg, value);
727 static void lm78_init_client(struct i2c_client *client)
729 u8 config = lm78_read_value(client, LM78_REG_CONFIG);
731 /* Start monitoring */
732 if (!(config & 0x01))
733 lm78_write_value(client, LM78_REG_CONFIG,
734 (config & 0xf7) | 0x01);
737 static struct lm78_data *lm78_update_device(struct device *dev)
739 struct i2c_client *client = to_i2c_client(dev);
740 struct lm78_data *data = i2c_get_clientdata(client);
743 down(&data->update_lock);
745 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
748 dev_dbg(&client->dev, "Starting lm78 update\n");
750 for (i = 0; i <= 6; i++) {
752 lm78_read_value(client, LM78_REG_IN(i));
754 lm78_read_value(client, LM78_REG_IN_MIN(i));
756 lm78_read_value(client, LM78_REG_IN_MAX(i));
758 for (i = 0; i < 3; i++) {
760 lm78_read_value(client, LM78_REG_FAN(i));
762 lm78_read_value(client, LM78_REG_FAN_MIN(i));
764 data->temp = lm78_read_value(client, LM78_REG_TEMP);
766 lm78_read_value(client, LM78_REG_TEMP_OVER);
768 lm78_read_value(client, LM78_REG_TEMP_HYST);
769 i = lm78_read_value(client, LM78_REG_VID_FANDIV);
770 data->vid = i & 0x0f;
771 if (data->type == lm79)
773 (lm78_read_value(client, LM78_REG_CHIPID) &
777 data->fan_div[0] = (i >> 4) & 0x03;
778 data->fan_div[1] = i >> 6;
779 data->alarms = lm78_read_value(client, LM78_REG_ALARM1) +
780 (lm78_read_value(client, LM78_REG_ALARM2) << 8);
781 data->last_updated = jiffies;
784 data->fan_div[2] = 1;
787 up(&data->update_lock);
792 static int __init sm_lm78_init(void)
796 res = i2c_add_driver(&lm78_driver);
800 res = i2c_isa_add_driver(&lm78_isa_driver);
802 i2c_del_driver(&lm78_driver);
809 static void __exit sm_lm78_exit(void)
811 i2c_isa_del_driver(&lm78_isa_driver);
812 i2c_del_driver(&lm78_driver);
817 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
818 MODULE_DESCRIPTION("LM78/LM79 driver");
819 MODULE_LICENSE("GPL");
821 module_init(sm_lm78_init);
822 module_exit(sm_lm78_exit);