2 lm78.c - Part of lm_sensors, Linux kernel modules for hardware
4 Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
5 Copyright (c) 2007, 2011 Jean Delvare <khali@linux-fr.org>
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24 #include <linux/module.h>
25 #include <linux/init.h>
26 #include <linux/slab.h>
27 #include <linux/jiffies.h>
28 #include <linux/i2c.h>
29 #include <linux/hwmon.h>
30 #include <linux/hwmon-vid.h>
31 #include <linux/hwmon-sysfs.h>
32 #include <linux/err.h>
33 #include <linux/mutex.h>
36 #include <linux/platform_device.h>
37 #include <linux/ioport.h>
41 /* Addresses to scan */
42 static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
43 0x2e, 0x2f, I2C_CLIENT_END };
44 enum chips { lm78, lm79 };
46 /* Many LM78 constants specified below */
48 /* Length of ISA address segment */
51 /* Where are the ISA address/data registers relative to the base address */
52 #define LM78_ADDR_REG_OFFSET 5
53 #define LM78_DATA_REG_OFFSET 6
55 /* The LM78 registers */
56 #define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)
57 #define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)
58 #define LM78_REG_IN(nr) (0x20 + (nr))
60 #define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
61 #define LM78_REG_FAN(nr) (0x28 + (nr))
63 #define LM78_REG_TEMP 0x27
64 #define LM78_REG_TEMP_OVER 0x39
65 #define LM78_REG_TEMP_HYST 0x3a
67 #define LM78_REG_ALARM1 0x41
68 #define LM78_REG_ALARM2 0x42
70 #define LM78_REG_VID_FANDIV 0x47
72 #define LM78_REG_CONFIG 0x40
73 #define LM78_REG_CHIPID 0x49
74 #define LM78_REG_I2C_ADDR 0x48
77 /* Conversions. Rounding and limit checking is only done on the TO_REG
80 /* IN: mV, (0V to 4.08V)
82 static inline u8 IN_TO_REG(unsigned long val)
84 unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
85 return (nval + 8) / 16;
87 #define IN_FROM_REG(val) ((val) * 16)
89 static inline u8 FAN_TO_REG(long rpm, int div)
95 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
98 static inline int FAN_FROM_REG(u8 val, int div)
100 return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div);
103 /* TEMP: mC (-128C to +127C)
104 REG: 1C/bit, two's complement */
105 static inline s8 TEMP_TO_REG(long val)
107 int nval = SENSORS_LIMIT(val, -128000, 127000) ;
108 return nval<0 ? (nval-500)/1000 : (nval+500)/1000;
111 static inline int TEMP_FROM_REG(s8 val)
116 #define DIV_FROM_REG(val) (1 << (val))
119 struct i2c_client *client;
120 struct device *hwmon_dev;
124 /* For ISA device only */
128 struct mutex update_lock;
129 char valid; /* !=0 if following fields are valid */
130 unsigned long last_updated; /* In jiffies */
132 u8 in[7]; /* Register value */
133 u8 in_max[7]; /* Register value */
134 u8 in_min[7]; /* Register value */
135 u8 fan[3]; /* Register value */
136 u8 fan_min[3]; /* Register value */
137 s8 temp; /* Register value */
138 s8 temp_over; /* Register value */
139 s8 temp_hyst; /* Register value */
140 u8 fan_div[3]; /* Register encoding, shifted right */
141 u8 vid; /* Register encoding, combined */
142 u16 alarms; /* Register encoding, combined */
146 static int lm78_read_value(struct lm78_data *data, u8 reg);
147 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value);
148 static struct lm78_data *lm78_update_device(struct device *dev);
149 static void lm78_init_device(struct lm78_data *data);
153 static ssize_t show_in(struct device *dev, struct device_attribute *da,
156 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
157 struct lm78_data *data = lm78_update_device(dev);
158 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[attr->index]));
161 static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
164 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
165 struct lm78_data *data = lm78_update_device(dev);
166 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[attr->index]));
169 static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
172 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
173 struct lm78_data *data = lm78_update_device(dev);
174 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[attr->index]));
177 static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
178 const char *buf, size_t count)
180 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
181 struct lm78_data *data = dev_get_drvdata(dev);
182 unsigned long val = simple_strtoul(buf, NULL, 10);
183 int nr = attr->index;
185 mutex_lock(&data->update_lock);
186 data->in_min[nr] = IN_TO_REG(val);
187 lm78_write_value(data, LM78_REG_IN_MIN(nr), data->in_min[nr]);
188 mutex_unlock(&data->update_lock);
192 static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
193 const char *buf, size_t count)
195 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
196 struct lm78_data *data = dev_get_drvdata(dev);
197 unsigned long val = simple_strtoul(buf, NULL, 10);
198 int nr = attr->index;
200 mutex_lock(&data->update_lock);
201 data->in_max[nr] = IN_TO_REG(val);
202 lm78_write_value(data, LM78_REG_IN_MAX(nr), data->in_max[nr]);
203 mutex_unlock(&data->update_lock);
207 #define show_in_offset(offset) \
208 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
209 show_in, NULL, offset); \
210 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
211 show_in_min, set_in_min, offset); \
212 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
213 show_in_max, set_in_max, offset);
224 static ssize_t show_temp(struct device *dev, struct device_attribute *da,
227 struct lm78_data *data = lm78_update_device(dev);
228 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
231 static ssize_t show_temp_over(struct device *dev, struct device_attribute *da,
234 struct lm78_data *data = lm78_update_device(dev);
235 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
238 static ssize_t set_temp_over(struct device *dev, struct device_attribute *da,
239 const char *buf, size_t count)
241 struct lm78_data *data = dev_get_drvdata(dev);
242 long val = simple_strtol(buf, NULL, 10);
244 mutex_lock(&data->update_lock);
245 data->temp_over = TEMP_TO_REG(val);
246 lm78_write_value(data, LM78_REG_TEMP_OVER, data->temp_over);
247 mutex_unlock(&data->update_lock);
251 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *da,
254 struct lm78_data *data = lm78_update_device(dev);
255 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
258 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *da,
259 const char *buf, size_t count)
261 struct lm78_data *data = dev_get_drvdata(dev);
262 long val = simple_strtol(buf, NULL, 10);
264 mutex_lock(&data->update_lock);
265 data->temp_hyst = TEMP_TO_REG(val);
266 lm78_write_value(data, LM78_REG_TEMP_HYST, data->temp_hyst);
267 mutex_unlock(&data->update_lock);
271 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
272 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
273 show_temp_over, set_temp_over);
274 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
275 show_temp_hyst, set_temp_hyst);
278 static ssize_t show_fan(struct device *dev, struct device_attribute *da,
281 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
282 struct lm78_data *data = lm78_update_device(dev);
283 int nr = attr->index;
284 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
285 DIV_FROM_REG(data->fan_div[nr])) );
288 static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
291 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
292 struct lm78_data *data = lm78_update_device(dev);
293 int nr = attr->index;
294 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr],
295 DIV_FROM_REG(data->fan_div[nr])) );
298 static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
299 const char *buf, size_t count)
301 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
302 struct lm78_data *data = dev_get_drvdata(dev);
303 int nr = attr->index;
304 unsigned long val = simple_strtoul(buf, NULL, 10);
306 mutex_lock(&data->update_lock);
307 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
308 lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
309 mutex_unlock(&data->update_lock);
313 static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
316 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
317 struct lm78_data *data = lm78_update_device(dev);
318 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));
321 /* Note: we save and restore the fan minimum here, because its value is
322 determined in part by the fan divisor. This follows the principle of
323 least surprise; the user doesn't expect the fan minimum to change just
324 because the divisor changed. */
325 static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
326 const char *buf, size_t count)
328 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
329 struct lm78_data *data = dev_get_drvdata(dev);
330 int nr = attr->index;
331 unsigned long val = simple_strtoul(buf, NULL, 10);
335 mutex_lock(&data->update_lock);
336 min = FAN_FROM_REG(data->fan_min[nr],
337 DIV_FROM_REG(data->fan_div[nr]));
340 case 1: data->fan_div[nr] = 0; break;
341 case 2: data->fan_div[nr] = 1; break;
342 case 4: data->fan_div[nr] = 2; break;
343 case 8: data->fan_div[nr] = 3; break;
345 dev_err(dev, "fan_div value %ld not "
346 "supported. Choose one of 1, 2, 4 or 8!\n", val);
347 mutex_unlock(&data->update_lock);
351 reg = lm78_read_value(data, LM78_REG_VID_FANDIV);
354 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
357 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
360 lm78_write_value(data, LM78_REG_VID_FANDIV, reg);
363 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
364 lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
365 mutex_unlock(&data->update_lock);
370 #define show_fan_offset(offset) \
371 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
372 show_fan, NULL, offset - 1); \
373 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
374 show_fan_min, set_fan_min, offset - 1);
380 /* Fan 3 divisor is locked in H/W */
381 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
382 show_fan_div, set_fan_div, 0);
383 static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
384 show_fan_div, set_fan_div, 1);
385 static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2);
388 static ssize_t show_vid(struct device *dev, struct device_attribute *da,
391 struct lm78_data *data = lm78_update_device(dev);
392 return sprintf(buf, "%d\n", vid_from_reg(data->vid, 82));
394 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
397 static ssize_t show_alarms(struct device *dev, struct device_attribute *da,
400 struct lm78_data *data = lm78_update_device(dev);
401 return sprintf(buf, "%u\n", data->alarms);
403 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
405 static ssize_t show_alarm(struct device *dev, struct device_attribute *da,
408 struct lm78_data *data = lm78_update_device(dev);
409 int nr = to_sensor_dev_attr(da)->index;
410 return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
412 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
413 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
414 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
415 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
416 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
417 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
418 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10);
419 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
420 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
421 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
422 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
424 static struct attribute *lm78_attributes[] = {
425 &sensor_dev_attr_in0_input.dev_attr.attr,
426 &sensor_dev_attr_in0_min.dev_attr.attr,
427 &sensor_dev_attr_in0_max.dev_attr.attr,
428 &sensor_dev_attr_in0_alarm.dev_attr.attr,
429 &sensor_dev_attr_in1_input.dev_attr.attr,
430 &sensor_dev_attr_in1_min.dev_attr.attr,
431 &sensor_dev_attr_in1_max.dev_attr.attr,
432 &sensor_dev_attr_in1_alarm.dev_attr.attr,
433 &sensor_dev_attr_in2_input.dev_attr.attr,
434 &sensor_dev_attr_in2_min.dev_attr.attr,
435 &sensor_dev_attr_in2_max.dev_attr.attr,
436 &sensor_dev_attr_in2_alarm.dev_attr.attr,
437 &sensor_dev_attr_in3_input.dev_attr.attr,
438 &sensor_dev_attr_in3_min.dev_attr.attr,
439 &sensor_dev_attr_in3_max.dev_attr.attr,
440 &sensor_dev_attr_in3_alarm.dev_attr.attr,
441 &sensor_dev_attr_in4_input.dev_attr.attr,
442 &sensor_dev_attr_in4_min.dev_attr.attr,
443 &sensor_dev_attr_in4_max.dev_attr.attr,
444 &sensor_dev_attr_in4_alarm.dev_attr.attr,
445 &sensor_dev_attr_in5_input.dev_attr.attr,
446 &sensor_dev_attr_in5_min.dev_attr.attr,
447 &sensor_dev_attr_in5_max.dev_attr.attr,
448 &sensor_dev_attr_in5_alarm.dev_attr.attr,
449 &sensor_dev_attr_in6_input.dev_attr.attr,
450 &sensor_dev_attr_in6_min.dev_attr.attr,
451 &sensor_dev_attr_in6_max.dev_attr.attr,
452 &sensor_dev_attr_in6_alarm.dev_attr.attr,
453 &dev_attr_temp1_input.attr,
454 &dev_attr_temp1_max.attr,
455 &dev_attr_temp1_max_hyst.attr,
456 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
457 &sensor_dev_attr_fan1_input.dev_attr.attr,
458 &sensor_dev_attr_fan1_min.dev_attr.attr,
459 &sensor_dev_attr_fan1_div.dev_attr.attr,
460 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
461 &sensor_dev_attr_fan2_input.dev_attr.attr,
462 &sensor_dev_attr_fan2_min.dev_attr.attr,
463 &sensor_dev_attr_fan2_div.dev_attr.attr,
464 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
465 &sensor_dev_attr_fan3_input.dev_attr.attr,
466 &sensor_dev_attr_fan3_min.dev_attr.attr,
467 &sensor_dev_attr_fan3_div.dev_attr.attr,
468 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
469 &dev_attr_alarms.attr,
470 &dev_attr_cpu0_vid.attr,
475 static const struct attribute_group lm78_group = {
476 .attrs = lm78_attributes,
484 /* ISA device, if found */
485 static struct platform_device *pdev;
487 static unsigned short isa_address = 0x290;
489 /* I2C devices get this name attribute automatically, but for ISA devices
490 we must create it by ourselves. */
491 static ssize_t show_name(struct device *dev, struct device_attribute
494 struct lm78_data *data = dev_get_drvdata(dev);
496 return sprintf(buf, "%s\n", data->name);
498 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
500 static struct lm78_data *lm78_data_if_isa(void)
502 return pdev ? platform_get_drvdata(pdev) : NULL;
505 /* Returns 1 if the I2C chip appears to be an alias of the ISA chip */
506 static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
508 struct lm78_data *isa;
511 if (!pdev) /* No ISA chip */
513 isa = platform_get_drvdata(pdev);
515 if (lm78_read_value(isa, LM78_REG_I2C_ADDR) != client->addr)
516 return 0; /* Address doesn't match */
517 if ((lm78_read_value(isa, LM78_REG_CHIPID) & 0xfe) != (chipid & 0xfe))
518 return 0; /* Chip type doesn't match */
520 /* We compare all the limit registers, the config register and the
521 * interrupt mask registers */
522 for (i = 0x2b; i <= 0x3d; i++) {
523 if (lm78_read_value(isa, i) !=
524 i2c_smbus_read_byte_data(client, i))
527 if (lm78_read_value(isa, LM78_REG_CONFIG) !=
528 i2c_smbus_read_byte_data(client, LM78_REG_CONFIG))
530 for (i = 0x43; i <= 0x46; i++) {
531 if (lm78_read_value(isa, i) !=
532 i2c_smbus_read_byte_data(client, i))
538 #else /* !CONFIG_ISA */
540 static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
545 static struct lm78_data *lm78_data_if_isa(void)
549 #endif /* CONFIG_ISA */
551 static int lm78_i2c_detect(struct i2c_client *client,
552 struct i2c_board_info *info)
555 struct lm78_data *isa = lm78_data_if_isa();
556 const char *client_name;
557 struct i2c_adapter *adapter = client->adapter;
558 int address = client->addr;
560 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
563 /* We block updates of the ISA device to minimize the risk of
564 concurrent access to the same LM78 chip through different
567 mutex_lock(&isa->update_lock);
569 if ((i2c_smbus_read_byte_data(client, LM78_REG_CONFIG) & 0x80)
570 || i2c_smbus_read_byte_data(client, LM78_REG_I2C_ADDR) != address)
573 /* Explicitly prevent the misdetection of Winbond chips */
574 i = i2c_smbus_read_byte_data(client, 0x4f);
575 if (i == 0xa3 || i == 0x5c)
578 /* Determine the chip type. */
579 i = i2c_smbus_read_byte_data(client, LM78_REG_CHIPID);
580 if (i == 0x00 || i == 0x20 /* LM78 */
581 || i == 0x40) /* LM78-J */
582 client_name = "lm78";
583 else if ((i & 0xfe) == 0xc0)
584 client_name = "lm79";
588 if (lm78_alias_detect(client, i)) {
589 dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
590 "be the same as ISA device\n", address);
595 mutex_unlock(&isa->update_lock);
597 strlcpy(info->type, client_name, I2C_NAME_SIZE);
603 mutex_unlock(&isa->update_lock);
607 static int lm78_i2c_probe(struct i2c_client *client,
608 const struct i2c_device_id *id)
610 struct lm78_data *data;
613 data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL);
617 i2c_set_clientdata(client, data);
618 data->client = client;
619 data->type = id->driver_data;
621 /* Initialize the LM78 chip */
622 lm78_init_device(data);
624 /* Register sysfs hooks */
625 err = sysfs_create_group(&client->dev.kobj, &lm78_group);
629 data->hwmon_dev = hwmon_device_register(&client->dev);
630 if (IS_ERR(data->hwmon_dev)) {
631 err = PTR_ERR(data->hwmon_dev);
638 sysfs_remove_group(&client->dev.kobj, &lm78_group);
644 static int lm78_i2c_remove(struct i2c_client *client)
646 struct lm78_data *data = i2c_get_clientdata(client);
648 hwmon_device_unregister(data->hwmon_dev);
649 sysfs_remove_group(&client->dev.kobj, &lm78_group);
655 static const struct i2c_device_id lm78_i2c_id[] = {
660 MODULE_DEVICE_TABLE(i2c, lm78_i2c_id);
662 static struct i2c_driver lm78_driver = {
663 .class = I2C_CLASS_HWMON,
667 .probe = lm78_i2c_probe,
668 .remove = lm78_i2c_remove,
669 .id_table = lm78_i2c_id,
670 .detect = lm78_i2c_detect,
671 .address_list = normal_i2c,
674 /* The SMBus locks itself, but ISA access must be locked explicitly!
675 We don't want to lock the whole ISA bus, so we lock each client
677 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
678 would slow down the LM78 access and should not be necessary. */
679 static int lm78_read_value(struct lm78_data *data, u8 reg)
681 struct i2c_client *client = data->client;
684 if (!client) { /* ISA device */
686 mutex_lock(&data->lock);
687 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
688 res = inb_p(data->isa_addr + LM78_DATA_REG_OFFSET);
689 mutex_unlock(&data->lock);
693 return i2c_smbus_read_byte_data(client, reg);
696 /* The SMBus locks itself, but ISA access muse 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 There are some ugly typecasts here, but the good new is - they should
702 nowhere else be necessary! */
703 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
705 struct i2c_client *client = data->client;
708 if (!client) { /* ISA device */
709 mutex_lock(&data->lock);
710 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
711 outb_p(value, data->isa_addr + LM78_DATA_REG_OFFSET);
712 mutex_unlock(&data->lock);
716 return i2c_smbus_write_byte_data(client, reg, value);
719 static void lm78_init_device(struct lm78_data *data)
724 /* Start monitoring */
725 config = lm78_read_value(data, LM78_REG_CONFIG);
726 if ((config & 0x09) != 0x01)
727 lm78_write_value(data, LM78_REG_CONFIG,
728 (config & 0xf7) | 0x01);
730 /* A few vars need to be filled upon startup */
731 for (i = 0; i < 3; i++) {
732 data->fan_min[i] = lm78_read_value(data,
733 LM78_REG_FAN_MIN(i));
736 mutex_init(&data->update_lock);
739 static struct lm78_data *lm78_update_device(struct device *dev)
741 struct lm78_data *data = dev_get_drvdata(dev);
744 mutex_lock(&data->update_lock);
746 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
749 dev_dbg(dev, "Starting lm78 update\n");
751 for (i = 0; i <= 6; i++) {
753 lm78_read_value(data, LM78_REG_IN(i));
755 lm78_read_value(data, LM78_REG_IN_MIN(i));
757 lm78_read_value(data, LM78_REG_IN_MAX(i));
759 for (i = 0; i < 3; i++) {
761 lm78_read_value(data, LM78_REG_FAN(i));
763 lm78_read_value(data, LM78_REG_FAN_MIN(i));
765 data->temp = lm78_read_value(data, LM78_REG_TEMP);
767 lm78_read_value(data, LM78_REG_TEMP_OVER);
769 lm78_read_value(data, LM78_REG_TEMP_HYST);
770 i = lm78_read_value(data, LM78_REG_VID_FANDIV);
771 data->vid = i & 0x0f;
772 if (data->type == lm79)
774 (lm78_read_value(data, LM78_REG_CHIPID) &
778 data->fan_div[0] = (i >> 4) & 0x03;
779 data->fan_div[1] = i >> 6;
780 data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +
781 (lm78_read_value(data, LM78_REG_ALARM2) << 8);
782 data->last_updated = jiffies;
785 data->fan_div[2] = 1;
788 mutex_unlock(&data->update_lock);
794 static int __devinit lm78_isa_probe(struct platform_device *pdev)
797 struct lm78_data *data;
798 struct resource *res;
800 /* Reserve the ISA region */
801 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
802 if (!request_region(res->start + LM78_ADDR_REG_OFFSET, 2, "lm78")) {
807 data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL);
810 goto exit_release_region;
812 mutex_init(&data->lock);
813 data->isa_addr = res->start;
814 platform_set_drvdata(pdev, data);
816 if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
824 /* Initialize the LM78 chip */
825 lm78_init_device(data);
827 /* Register sysfs hooks */
828 if ((err = sysfs_create_group(&pdev->dev.kobj, &lm78_group))
829 || (err = device_create_file(&pdev->dev, &dev_attr_name)))
830 goto exit_remove_files;
832 data->hwmon_dev = hwmon_device_register(&pdev->dev);
833 if (IS_ERR(data->hwmon_dev)) {
834 err = PTR_ERR(data->hwmon_dev);
835 goto exit_remove_files;
841 sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
842 device_remove_file(&pdev->dev, &dev_attr_name);
845 release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
850 static int __devexit lm78_isa_remove(struct platform_device *pdev)
852 struct lm78_data *data = platform_get_drvdata(pdev);
853 struct resource *res;
855 hwmon_device_unregister(data->hwmon_dev);
856 sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
857 device_remove_file(&pdev->dev, &dev_attr_name);
860 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
861 release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
866 static struct platform_driver lm78_isa_driver = {
868 .owner = THIS_MODULE,
871 .probe = lm78_isa_probe,
872 .remove = __devexit_p(lm78_isa_remove),
875 /* return 1 if a supported chip is found, 0 otherwise */
876 static int __init lm78_isa_found(unsigned short address)
878 int val, save, found = 0;
881 /* Some boards declare base+0 to base+7 as a PNP device, some base+4
882 * to base+7 and some base+5 to base+6. So we better request each port
883 * individually for the probing phase. */
884 for (port = address; port < address + LM78_EXTENT; port++) {
885 if (!request_region(port, 1, "lm78")) {
886 pr_debug("Failed to request port 0x%x\n", port);
891 #define REALLY_SLOW_IO
892 /* We need the timeouts for at least some LM78-like
893 chips. But only if we read 'undefined' registers. */
894 val = inb_p(address + 1);
895 if (inb_p(address + 2) != val
896 || inb_p(address + 3) != val
897 || inb_p(address + 7) != val)
899 #undef REALLY_SLOW_IO
901 /* We should be able to change the 7 LSB of the address port. The
902 MSB (busy flag) should be clear initially, set after the write. */
903 save = inb_p(address + LM78_ADDR_REG_OFFSET);
907 outb_p(val, address + LM78_ADDR_REG_OFFSET);
908 if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
909 outb_p(save, address + LM78_ADDR_REG_OFFSET);
913 /* We found a device, now see if it could be an LM78 */
914 outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET);
915 val = inb_p(address + LM78_DATA_REG_OFFSET);
918 outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET);
919 val = inb_p(address + LM78_DATA_REG_OFFSET);
920 if (val < 0x03 || val > 0x77) /* Not a valid I2C address */
923 /* The busy flag should be clear again */
924 if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)
927 /* Explicitly prevent the misdetection of Winbond chips */
928 outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);
929 val = inb_p(address + LM78_DATA_REG_OFFSET);
930 if (val == 0xa3 || val == 0x5c)
933 /* Explicitly prevent the misdetection of ITE chips */
934 outb_p(0x58, address + LM78_ADDR_REG_OFFSET);
935 val = inb_p(address + LM78_DATA_REG_OFFSET);
939 /* Determine the chip type */
940 outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET);
941 val = inb_p(address + LM78_DATA_REG_OFFSET);
942 if (val == 0x00 || val == 0x20 /* LM78 */
943 || val == 0x40 /* LM78-J */
944 || (val & 0xfe) == 0xc0) /* LM79 */
948 pr_info("Found an %s chip at %#x\n",
949 val & 0x80 ? "LM79" : "LM78", (int)address);
952 for (port--; port >= address; port--)
953 release_region(port, 1);
957 static int __init lm78_isa_device_add(unsigned short address)
959 struct resource res = {
961 .end = address + LM78_EXTENT - 1,
963 .flags = IORESOURCE_IO,
967 pdev = platform_device_alloc("lm78", address);
970 pr_err("Device allocation failed\n");
974 err = platform_device_add_resources(pdev, &res, 1);
976 pr_err("Device resource addition failed (%d)\n", err);
977 goto exit_device_put;
980 err = platform_device_add(pdev);
982 pr_err("Device addition failed (%d)\n", err);
983 goto exit_device_put;
989 platform_device_put(pdev);
995 static int __init lm78_isa_register(void)
999 if (lm78_isa_found(isa_address)) {
1000 res = platform_driver_register(&lm78_isa_driver);
1004 /* Sets global pdev as a side effect */
1005 res = lm78_isa_device_add(isa_address);
1007 goto exit_unreg_isa_driver;
1012 exit_unreg_isa_driver:
1013 platform_driver_unregister(&lm78_isa_driver);
1018 static void lm78_isa_unregister(void)
1021 platform_device_unregister(pdev);
1022 platform_driver_unregister(&lm78_isa_driver);
1025 #else /* !CONFIG_ISA */
1027 static int __init lm78_isa_register(void)
1032 static void lm78_isa_unregister(void)
1035 #endif /* CONFIG_ISA */
1037 static int __init sm_lm78_init(void)
1041 /* We register the ISA device first, so that we can skip the
1042 * registration of an I2C interface to the same device. */
1043 res = lm78_isa_register();
1047 res = i2c_add_driver(&lm78_driver);
1049 goto exit_unreg_isa_device;
1053 exit_unreg_isa_device:
1054 lm78_isa_unregister();
1059 static void __exit sm_lm78_exit(void)
1061 lm78_isa_unregister();
1062 i2c_del_driver(&lm78_driver);
1065 MODULE_AUTHOR("Frodo Looijaard, Jean Delvare <khali@linux-fr.org>");
1066 MODULE_DESCRIPTION("LM78/LM79 driver");
1067 MODULE_LICENSE("GPL");
1069 module_init(sm_lm78_init);
1070 module_exit(sm_lm78_exit);