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 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/platform_device.h>
30 #include <linux/ioport.h>
31 #include <linux/hwmon.h>
32 #include <linux/hwmon-vid.h>
33 #include <linux/hwmon-sysfs.h>
34 #include <linux/err.h>
35 #include <linux/mutex.h>
38 /* ISA device, if found */
39 static struct platform_device *pdev;
41 /* Addresses to scan */
42 static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
43 0x2e, 0x2f, I2C_CLIENT_END };
44 static unsigned short isa_address = 0x290;
46 enum chips { lm78, lm79 };
48 /* Many LM78 constants specified below */
50 /* Length of ISA address segment */
53 /* Where are the ISA address/data registers relative to the base address */
54 #define LM78_ADDR_REG_OFFSET 5
55 #define LM78_DATA_REG_OFFSET 6
57 /* The LM78 registers */
58 #define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)
59 #define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)
60 #define LM78_REG_IN(nr) (0x20 + (nr))
62 #define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
63 #define LM78_REG_FAN(nr) (0x28 + (nr))
65 #define LM78_REG_TEMP 0x27
66 #define LM78_REG_TEMP_OVER 0x39
67 #define LM78_REG_TEMP_HYST 0x3a
69 #define LM78_REG_ALARM1 0x41
70 #define LM78_REG_ALARM2 0x42
72 #define LM78_REG_VID_FANDIV 0x47
74 #define LM78_REG_CONFIG 0x40
75 #define LM78_REG_CHIPID 0x49
76 #define LM78_REG_I2C_ADDR 0x48
79 /* Conversions. Rounding and limit checking is only done on the TO_REG
82 /* IN: mV, (0V to 4.08V)
84 static inline u8 IN_TO_REG(unsigned long val)
86 unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
87 return (nval + 8) / 16;
89 #define IN_FROM_REG(val) ((val) * 16)
91 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(int 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,
479 /* I2C devices get this name attribute automatically, but for ISA devices
480 we must create it by ourselves. */
481 static ssize_t show_name(struct device *dev, struct device_attribute
484 struct lm78_data *data = dev_get_drvdata(dev);
486 return sprintf(buf, "%s\n", data->name);
488 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
490 /* Returns 1 if the I2C chip appears to be an alias of the ISA chip */
491 static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
493 struct lm78_data *isa;
496 if (!pdev) /* No ISA chip */
498 isa = platform_get_drvdata(pdev);
500 if (lm78_read_value(isa, LM78_REG_I2C_ADDR) != client->addr)
501 return 0; /* Address doesn't match */
502 if ((lm78_read_value(isa, LM78_REG_CHIPID) & 0xfe) != (chipid & 0xfe))
503 return 0; /* Chip type doesn't match */
505 /* We compare all the limit registers, the config register and the
506 * interrupt mask registers */
507 for (i = 0x2b; i <= 0x3d; i++) {
508 if (lm78_read_value(isa, i) !=
509 i2c_smbus_read_byte_data(client, i))
512 if (lm78_read_value(isa, LM78_REG_CONFIG) !=
513 i2c_smbus_read_byte_data(client, LM78_REG_CONFIG))
515 for (i = 0x43; i <= 0x46; i++) {
516 if (lm78_read_value(isa, i) !=
517 i2c_smbus_read_byte_data(client, i))
524 static int lm78_i2c_detect(struct i2c_client *client,
525 struct i2c_board_info *info)
528 struct lm78_data *isa = pdev ? platform_get_drvdata(pdev) : NULL;
529 const char *client_name;
530 struct i2c_adapter *adapter = client->adapter;
531 int address = client->addr;
533 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
536 /* We block updates of the ISA device to minimize the risk of
537 concurrent access to the same LM78 chip through different
540 mutex_lock(&isa->update_lock);
542 if ((i2c_smbus_read_byte_data(client, LM78_REG_CONFIG) & 0x80)
543 || i2c_smbus_read_byte_data(client, LM78_REG_I2C_ADDR) != address)
546 /* Explicitly prevent the misdetection of Winbond chips */
547 i = i2c_smbus_read_byte_data(client, 0x4f);
548 if (i == 0xa3 || i == 0x5c)
551 /* Determine the chip type. */
552 i = i2c_smbus_read_byte_data(client, LM78_REG_CHIPID);
553 if (i == 0x00 || i == 0x20 /* LM78 */
554 || i == 0x40) /* LM78-J */
555 client_name = "lm78";
556 else if ((i & 0xfe) == 0xc0)
557 client_name = "lm79";
561 if (lm78_alias_detect(client, i)) {
562 dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
563 "be the same as ISA device\n", address);
568 mutex_unlock(&isa->update_lock);
570 strlcpy(info->type, client_name, I2C_NAME_SIZE);
576 mutex_unlock(&isa->update_lock);
580 static int lm78_i2c_probe(struct i2c_client *client,
581 const struct i2c_device_id *id)
583 struct lm78_data *data;
586 data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL);
590 i2c_set_clientdata(client, data);
591 data->client = client;
592 data->type = id->driver_data;
594 /* Initialize the LM78 chip */
595 lm78_init_device(data);
597 /* Register sysfs hooks */
598 err = sysfs_create_group(&client->dev.kobj, &lm78_group);
602 data->hwmon_dev = hwmon_device_register(&client->dev);
603 if (IS_ERR(data->hwmon_dev)) {
604 err = PTR_ERR(data->hwmon_dev);
611 sysfs_remove_group(&client->dev.kobj, &lm78_group);
617 static int lm78_i2c_remove(struct i2c_client *client)
619 struct lm78_data *data = i2c_get_clientdata(client);
621 hwmon_device_unregister(data->hwmon_dev);
622 sysfs_remove_group(&client->dev.kobj, &lm78_group);
628 static const struct i2c_device_id lm78_i2c_id[] = {
633 MODULE_DEVICE_TABLE(i2c, lm78_i2c_id);
635 static struct i2c_driver lm78_driver = {
636 .class = I2C_CLASS_HWMON,
640 .probe = lm78_i2c_probe,
641 .remove = lm78_i2c_remove,
642 .id_table = lm78_i2c_id,
643 .detect = lm78_i2c_detect,
644 .address_list = normal_i2c,
647 /* The SMBus locks itself, but ISA access must be locked explicitly!
648 We don't want to lock the whole ISA bus, so we lock each client
650 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
651 would slow down the LM78 access and should not be necessary. */
652 static int lm78_read_value(struct lm78_data *data, u8 reg)
654 struct i2c_client *client = data->client;
656 if (!client) { /* ISA device */
658 mutex_lock(&data->lock);
659 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
660 res = inb_p(data->isa_addr + LM78_DATA_REG_OFFSET);
661 mutex_unlock(&data->lock);
664 return i2c_smbus_read_byte_data(client, reg);
667 /* The SMBus locks itself, but ISA access muse be locked explicitly!
668 We don't want to lock the whole ISA bus, so we lock each client
670 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
671 would slow down the LM78 access and should not be necessary.
672 There are some ugly typecasts here, but the good new is - they should
673 nowhere else be necessary! */
674 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
676 struct i2c_client *client = data->client;
678 if (!client) { /* ISA device */
679 mutex_lock(&data->lock);
680 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
681 outb_p(value, data->isa_addr + LM78_DATA_REG_OFFSET);
682 mutex_unlock(&data->lock);
685 return i2c_smbus_write_byte_data(client, reg, value);
688 static void lm78_init_device(struct lm78_data *data)
693 /* Start monitoring */
694 config = lm78_read_value(data, LM78_REG_CONFIG);
695 if ((config & 0x09) != 0x01)
696 lm78_write_value(data, LM78_REG_CONFIG,
697 (config & 0xf7) | 0x01);
699 /* A few vars need to be filled upon startup */
700 for (i = 0; i < 3; i++) {
701 data->fan_min[i] = lm78_read_value(data,
702 LM78_REG_FAN_MIN(i));
705 mutex_init(&data->update_lock);
708 static struct lm78_data *lm78_update_device(struct device *dev)
710 struct lm78_data *data = dev_get_drvdata(dev);
713 mutex_lock(&data->update_lock);
715 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
718 dev_dbg(dev, "Starting lm78 update\n");
720 for (i = 0; i <= 6; i++) {
722 lm78_read_value(data, LM78_REG_IN(i));
724 lm78_read_value(data, LM78_REG_IN_MIN(i));
726 lm78_read_value(data, LM78_REG_IN_MAX(i));
728 for (i = 0; i < 3; i++) {
730 lm78_read_value(data, LM78_REG_FAN(i));
732 lm78_read_value(data, LM78_REG_FAN_MIN(i));
734 data->temp = lm78_read_value(data, LM78_REG_TEMP);
736 lm78_read_value(data, LM78_REG_TEMP_OVER);
738 lm78_read_value(data, LM78_REG_TEMP_HYST);
739 i = lm78_read_value(data, LM78_REG_VID_FANDIV);
740 data->vid = i & 0x0f;
741 if (data->type == lm79)
743 (lm78_read_value(data, LM78_REG_CHIPID) &
747 data->fan_div[0] = (i >> 4) & 0x03;
748 data->fan_div[1] = i >> 6;
749 data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +
750 (lm78_read_value(data, LM78_REG_ALARM2) << 8);
751 data->last_updated = jiffies;
754 data->fan_div[2] = 1;
757 mutex_unlock(&data->update_lock);
762 static int __devinit lm78_isa_probe(struct platform_device *pdev)
765 struct lm78_data *data;
766 struct resource *res;
768 /* Reserve the ISA region */
769 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
770 if (!request_region(res->start + LM78_ADDR_REG_OFFSET, 2, "lm78")) {
775 data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL);
778 goto exit_release_region;
780 mutex_init(&data->lock);
781 data->isa_addr = res->start;
782 platform_set_drvdata(pdev, data);
784 if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
792 /* Initialize the LM78 chip */
793 lm78_init_device(data);
795 /* Register sysfs hooks */
796 if ((err = sysfs_create_group(&pdev->dev.kobj, &lm78_group))
797 || (err = device_create_file(&pdev->dev, &dev_attr_name)))
798 goto exit_remove_files;
800 data->hwmon_dev = hwmon_device_register(&pdev->dev);
801 if (IS_ERR(data->hwmon_dev)) {
802 err = PTR_ERR(data->hwmon_dev);
803 goto exit_remove_files;
809 sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
810 device_remove_file(&pdev->dev, &dev_attr_name);
813 release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
818 static int __devexit lm78_isa_remove(struct platform_device *pdev)
820 struct lm78_data *data = platform_get_drvdata(pdev);
821 struct resource *res;
823 hwmon_device_unregister(data->hwmon_dev);
824 sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
825 device_remove_file(&pdev->dev, &dev_attr_name);
828 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
829 release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
834 static struct platform_driver lm78_isa_driver = {
836 .owner = THIS_MODULE,
839 .probe = lm78_isa_probe,
840 .remove = __devexit_p(lm78_isa_remove),
843 /* return 1 if a supported chip is found, 0 otherwise */
844 static int __init lm78_isa_found(unsigned short address)
846 int val, save, found = 0;
849 /* Some boards declare base+0 to base+7 as a PNP device, some base+4
850 * to base+7 and some base+5 to base+6. So we better request each port
851 * individually for the probing phase. */
852 for (port = address; port < address + LM78_EXTENT; port++) {
853 if (!request_region(port, 1, "lm78")) {
854 pr_debug("Failed to request port 0x%x\n", port);
859 #define REALLY_SLOW_IO
860 /* We need the timeouts for at least some LM78-like
861 chips. But only if we read 'undefined' registers. */
862 val = inb_p(address + 1);
863 if (inb_p(address + 2) != val
864 || inb_p(address + 3) != val
865 || inb_p(address + 7) != val)
867 #undef REALLY_SLOW_IO
869 /* We should be able to change the 7 LSB of the address port. The
870 MSB (busy flag) should be clear initially, set after the write. */
871 save = inb_p(address + LM78_ADDR_REG_OFFSET);
875 outb_p(val, address + LM78_ADDR_REG_OFFSET);
876 if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
877 outb_p(save, address + LM78_ADDR_REG_OFFSET);
881 /* We found a device, now see if it could be an LM78 */
882 outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET);
883 val = inb_p(address + LM78_DATA_REG_OFFSET);
886 outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET);
887 val = inb_p(address + LM78_DATA_REG_OFFSET);
888 if (val < 0x03 || val > 0x77) /* Not a valid I2C address */
891 /* The busy flag should be clear again */
892 if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)
895 /* Explicitly prevent the misdetection of Winbond chips */
896 outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);
897 val = inb_p(address + LM78_DATA_REG_OFFSET);
898 if (val == 0xa3 || val == 0x5c)
901 /* Explicitly prevent the misdetection of ITE chips */
902 outb_p(0x58, address + LM78_ADDR_REG_OFFSET);
903 val = inb_p(address + LM78_DATA_REG_OFFSET);
907 /* Determine the chip type */
908 outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET);
909 val = inb_p(address + LM78_DATA_REG_OFFSET);
910 if (val == 0x00 || val == 0x20 /* LM78 */
911 || val == 0x40 /* LM78-J */
912 || (val & 0xfe) == 0xc0) /* LM79 */
916 pr_info("Found an %s chip at %#x\n",
917 val & 0x80 ? "LM79" : "LM78", (int)address);
920 for (port--; port >= address; port--)
921 release_region(port, 1);
925 static int __init lm78_isa_device_add(unsigned short address)
927 struct resource res = {
929 .end = address + LM78_EXTENT - 1,
931 .flags = IORESOURCE_IO,
935 pdev = platform_device_alloc("lm78", address);
938 pr_err("Device allocation failed\n");
942 err = platform_device_add_resources(pdev, &res, 1);
944 pr_err("Device resource addition failed (%d)\n", err);
945 goto exit_device_put;
948 err = platform_device_add(pdev);
950 pr_err("Device addition failed (%d)\n", err);
951 goto exit_device_put;
957 platform_device_put(pdev);
963 static int __init sm_lm78_init(void)
967 /* We register the ISA device first, so that we can skip the
968 * registration of an I2C interface to the same device. */
969 if (lm78_isa_found(isa_address)) {
970 res = platform_driver_register(&lm78_isa_driver);
974 /* Sets global pdev as a side effect */
975 res = lm78_isa_device_add(isa_address);
977 goto exit_unreg_isa_driver;
980 res = i2c_add_driver(&lm78_driver);
982 goto exit_unreg_isa_device;
986 exit_unreg_isa_device:
987 platform_device_unregister(pdev);
988 exit_unreg_isa_driver:
989 platform_driver_unregister(&lm78_isa_driver);
994 static void __exit sm_lm78_exit(void)
997 platform_device_unregister(pdev);
998 platform_driver_unregister(&lm78_isa_driver);
1000 i2c_del_driver(&lm78_driver);
1005 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
1006 MODULE_DESCRIPTION("LM78/LM79 driver");
1007 MODULE_LICENSE("GPL");
1009 module_init(sm_lm78_init);
1010 module_exit(sm_lm78_exit);