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 #include <linux/module.h>
23 #include <linux/init.h>
24 #include <linux/slab.h>
25 #include <linux/jiffies.h>
26 #include <linux/i2c.h>
27 #include <linux/platform_device.h>
28 #include <linux/ioport.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 /* ISA device, if found */
37 static struct platform_device *pdev;
39 /* Addresses to scan */
40 static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
41 0x2e, 0x2f, I2C_CLIENT_END };
42 static unsigned short isa_address = 0x290;
44 /* Insmod parameters */
45 I2C_CLIENT_INSMOD_2(lm78, lm79);
47 /* Many LM78 constants specified below */
49 /* Length of ISA address segment */
52 /* Where are the ISA address/data registers relative to the base address */
53 #define LM78_ADDR_REG_OFFSET 5
54 #define LM78_DATA_REG_OFFSET 6
56 /* The LM78 registers */
57 #define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)
58 #define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)
59 #define LM78_REG_IN(nr) (0x20 + (nr))
61 #define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
62 #define LM78_REG_FAN(nr) (0x28 + (nr))
64 #define LM78_REG_TEMP 0x27
65 #define LM78_REG_TEMP_OVER 0x39
66 #define LM78_REG_TEMP_HYST 0x3a
68 #define LM78_REG_ALARM1 0x41
69 #define LM78_REG_ALARM2 0x42
71 #define LM78_REG_VID_FANDIV 0x47
73 #define LM78_REG_CONFIG 0x40
74 #define LM78_REG_CHIPID 0x49
75 #define LM78_REG_I2C_ADDR 0x48
78 /* Conversions. Rounding and limit checking is only done on the TO_REG
81 /* IN: mV, (0V to 4.08V)
83 static inline u8 IN_TO_REG(unsigned long val)
85 unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
86 return (nval + 8) / 16;
88 #define IN_FROM_REG(val) ((val) * 16)
90 static inline u8 FAN_TO_REG(long rpm, int div)
94 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
97 static inline int FAN_FROM_REG(u8 val, int div)
99 return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div);
102 /* TEMP: mC (-128C to +127C)
103 REG: 1C/bit, two's complement */
104 static inline s8 TEMP_TO_REG(int val)
106 int nval = SENSORS_LIMIT(val, -128000, 127000) ;
107 return nval<0 ? (nval-500)/1000 : (nval+500)/1000;
110 static inline int TEMP_FROM_REG(s8 val)
115 #define DIV_FROM_REG(val) (1 << (val))
118 struct i2c_client client;
119 struct device *hwmon_dev;
123 /* For ISA device only */
127 struct mutex update_lock;
128 char valid; /* !=0 if following fields are valid */
129 unsigned long last_updated; /* In jiffies */
131 u8 in[7]; /* Register value */
132 u8 in_max[7]; /* Register value */
133 u8 in_min[7]; /* Register value */
134 u8 fan[3]; /* Register value */
135 u8 fan_min[3]; /* Register value */
136 s8 temp; /* Register value */
137 s8 temp_over; /* Register value */
138 s8 temp_hyst; /* Register value */
139 u8 fan_div[3]; /* Register encoding, shifted right */
140 u8 vid; /* Register encoding, combined */
141 u16 alarms; /* Register encoding, combined */
145 static int lm78_attach_adapter(struct i2c_adapter *adapter);
146 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind);
147 static int lm78_detach_client(struct i2c_client *client);
149 static int __devinit lm78_isa_probe(struct platform_device *pdev);
150 static int __devexit lm78_isa_remove(struct platform_device *pdev);
152 static int lm78_read_value(struct lm78_data *data, u8 reg);
153 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value);
154 static struct lm78_data *lm78_update_device(struct device *dev);
155 static void lm78_init_device(struct lm78_data *data);
158 static struct i2c_driver lm78_driver = {
162 .attach_adapter = lm78_attach_adapter,
163 .detach_client = lm78_detach_client,
166 static struct platform_driver lm78_isa_driver = {
168 .owner = THIS_MODULE,
171 .probe = lm78_isa_probe,
172 .remove = lm78_isa_remove,
177 static ssize_t show_in(struct device *dev, struct device_attribute *da,
180 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
181 struct lm78_data *data = lm78_update_device(dev);
182 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[attr->index]));
185 static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
188 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
189 struct lm78_data *data = lm78_update_device(dev);
190 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[attr->index]));
193 static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
196 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
197 struct lm78_data *data = lm78_update_device(dev);
198 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[attr->index]));
201 static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
202 const char *buf, size_t count)
204 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
205 struct lm78_data *data = dev_get_drvdata(dev);
206 unsigned long val = simple_strtoul(buf, NULL, 10);
207 int nr = attr->index;
209 mutex_lock(&data->update_lock);
210 data->in_min[nr] = IN_TO_REG(val);
211 lm78_write_value(data, LM78_REG_IN_MIN(nr), data->in_min[nr]);
212 mutex_unlock(&data->update_lock);
216 static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
217 const char *buf, size_t count)
219 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
220 struct lm78_data *data = dev_get_drvdata(dev);
221 unsigned long val = simple_strtoul(buf, NULL, 10);
222 int nr = attr->index;
224 mutex_lock(&data->update_lock);
225 data->in_max[nr] = IN_TO_REG(val);
226 lm78_write_value(data, LM78_REG_IN_MAX(nr), data->in_max[nr]);
227 mutex_unlock(&data->update_lock);
231 #define show_in_offset(offset) \
232 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
233 show_in, NULL, offset); \
234 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
235 show_in_min, set_in_min, offset); \
236 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
237 show_in_max, set_in_max, offset);
248 static ssize_t show_temp(struct device *dev, struct device_attribute *da,
251 struct lm78_data *data = lm78_update_device(dev);
252 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
255 static ssize_t show_temp_over(struct device *dev, struct device_attribute *da,
258 struct lm78_data *data = lm78_update_device(dev);
259 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
262 static ssize_t set_temp_over(struct device *dev, struct device_attribute *da,
263 const char *buf, size_t count)
265 struct lm78_data *data = dev_get_drvdata(dev);
266 long val = simple_strtol(buf, NULL, 10);
268 mutex_lock(&data->update_lock);
269 data->temp_over = TEMP_TO_REG(val);
270 lm78_write_value(data, LM78_REG_TEMP_OVER, data->temp_over);
271 mutex_unlock(&data->update_lock);
275 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *da,
278 struct lm78_data *data = lm78_update_device(dev);
279 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
282 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *da,
283 const char *buf, size_t count)
285 struct lm78_data *data = dev_get_drvdata(dev);
286 long val = simple_strtol(buf, NULL, 10);
288 mutex_lock(&data->update_lock);
289 data->temp_hyst = TEMP_TO_REG(val);
290 lm78_write_value(data, LM78_REG_TEMP_HYST, data->temp_hyst);
291 mutex_unlock(&data->update_lock);
295 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
296 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
297 show_temp_over, set_temp_over);
298 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
299 show_temp_hyst, set_temp_hyst);
302 static ssize_t show_fan(struct device *dev, struct device_attribute *da,
305 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
306 struct lm78_data *data = lm78_update_device(dev);
307 int nr = attr->index;
308 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
309 DIV_FROM_REG(data->fan_div[nr])) );
312 static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
315 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
316 struct lm78_data *data = lm78_update_device(dev);
317 int nr = attr->index;
318 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr],
319 DIV_FROM_REG(data->fan_div[nr])) );
322 static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
323 const char *buf, size_t count)
325 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
326 struct lm78_data *data = dev_get_drvdata(dev);
327 int nr = attr->index;
328 unsigned long val = simple_strtoul(buf, NULL, 10);
330 mutex_lock(&data->update_lock);
331 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
332 lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
333 mutex_unlock(&data->update_lock);
337 static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
340 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
341 struct lm78_data *data = lm78_update_device(dev);
342 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));
345 /* Note: we save and restore the fan minimum here, because its value is
346 determined in part by the fan divisor. This follows the principle of
347 least surprise; the user doesn't expect the fan minimum to change just
348 because the divisor changed. */
349 static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
350 const char *buf, size_t count)
352 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
353 struct lm78_data *data = dev_get_drvdata(dev);
354 int nr = attr->index;
355 unsigned long val = simple_strtoul(buf, NULL, 10);
359 mutex_lock(&data->update_lock);
360 min = FAN_FROM_REG(data->fan_min[nr],
361 DIV_FROM_REG(data->fan_div[nr]));
364 case 1: data->fan_div[nr] = 0; break;
365 case 2: data->fan_div[nr] = 1; break;
366 case 4: data->fan_div[nr] = 2; break;
367 case 8: data->fan_div[nr] = 3; break;
369 dev_err(dev, "fan_div value %ld not "
370 "supported. Choose one of 1, 2, 4 or 8!\n", val);
371 mutex_unlock(&data->update_lock);
375 reg = lm78_read_value(data, LM78_REG_VID_FANDIV);
378 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
381 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
384 lm78_write_value(data, LM78_REG_VID_FANDIV, reg);
387 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
388 lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
389 mutex_unlock(&data->update_lock);
394 #define show_fan_offset(offset) \
395 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
396 show_fan, NULL, offset - 1); \
397 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
398 show_fan_min, set_fan_min, offset - 1);
404 /* Fan 3 divisor is locked in H/W */
405 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
406 show_fan_div, set_fan_div, 0);
407 static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
408 show_fan_div, set_fan_div, 1);
409 static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2);
412 static ssize_t show_vid(struct device *dev, struct device_attribute *da,
415 struct lm78_data *data = lm78_update_device(dev);
416 return sprintf(buf, "%d\n", vid_from_reg(data->vid, 82));
418 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
421 static ssize_t show_alarms(struct device *dev, struct device_attribute *da,
424 struct lm78_data *data = lm78_update_device(dev);
425 return sprintf(buf, "%u\n", data->alarms);
427 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
429 static ssize_t show_alarm(struct device *dev, struct device_attribute *da,
432 struct lm78_data *data = lm78_update_device(dev);
433 int nr = to_sensor_dev_attr(da)->index;
434 return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
436 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
437 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
438 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
439 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
440 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
441 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
442 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10);
443 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
444 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
445 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
446 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
448 /* This function is called when:
449 * lm78_driver is inserted (when this module is loaded), for each
451 * when a new adapter is inserted (and lm78_driver is still present)
452 We block updates of the ISA device to minimize the risk of concurrent
453 access to the same LM78 chip through different interfaces. */
454 static int lm78_attach_adapter(struct i2c_adapter *adapter)
456 struct lm78_data *data;
459 if (!(adapter->class & I2C_CLASS_HWMON))
462 data = pdev ? platform_get_drvdata(pdev) : NULL;
464 mutex_lock(&data->update_lock);
465 err = i2c_probe(adapter, &addr_data, lm78_detect);
467 mutex_unlock(&data->update_lock);
471 static struct attribute *lm78_attributes[] = {
472 &sensor_dev_attr_in0_input.dev_attr.attr,
473 &sensor_dev_attr_in0_min.dev_attr.attr,
474 &sensor_dev_attr_in0_max.dev_attr.attr,
475 &sensor_dev_attr_in0_alarm.dev_attr.attr,
476 &sensor_dev_attr_in1_input.dev_attr.attr,
477 &sensor_dev_attr_in1_min.dev_attr.attr,
478 &sensor_dev_attr_in1_max.dev_attr.attr,
479 &sensor_dev_attr_in1_alarm.dev_attr.attr,
480 &sensor_dev_attr_in2_input.dev_attr.attr,
481 &sensor_dev_attr_in2_min.dev_attr.attr,
482 &sensor_dev_attr_in2_max.dev_attr.attr,
483 &sensor_dev_attr_in2_alarm.dev_attr.attr,
484 &sensor_dev_attr_in3_input.dev_attr.attr,
485 &sensor_dev_attr_in3_min.dev_attr.attr,
486 &sensor_dev_attr_in3_max.dev_attr.attr,
487 &sensor_dev_attr_in3_alarm.dev_attr.attr,
488 &sensor_dev_attr_in4_input.dev_attr.attr,
489 &sensor_dev_attr_in4_min.dev_attr.attr,
490 &sensor_dev_attr_in4_max.dev_attr.attr,
491 &sensor_dev_attr_in4_alarm.dev_attr.attr,
492 &sensor_dev_attr_in5_input.dev_attr.attr,
493 &sensor_dev_attr_in5_min.dev_attr.attr,
494 &sensor_dev_attr_in5_max.dev_attr.attr,
495 &sensor_dev_attr_in5_alarm.dev_attr.attr,
496 &sensor_dev_attr_in6_input.dev_attr.attr,
497 &sensor_dev_attr_in6_min.dev_attr.attr,
498 &sensor_dev_attr_in6_max.dev_attr.attr,
499 &sensor_dev_attr_in6_alarm.dev_attr.attr,
500 &dev_attr_temp1_input.attr,
501 &dev_attr_temp1_max.attr,
502 &dev_attr_temp1_max_hyst.attr,
503 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
504 &sensor_dev_attr_fan1_input.dev_attr.attr,
505 &sensor_dev_attr_fan1_min.dev_attr.attr,
506 &sensor_dev_attr_fan1_div.dev_attr.attr,
507 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
508 &sensor_dev_attr_fan2_input.dev_attr.attr,
509 &sensor_dev_attr_fan2_min.dev_attr.attr,
510 &sensor_dev_attr_fan2_div.dev_attr.attr,
511 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
512 &sensor_dev_attr_fan3_input.dev_attr.attr,
513 &sensor_dev_attr_fan3_min.dev_attr.attr,
514 &sensor_dev_attr_fan3_div.dev_attr.attr,
515 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
516 &dev_attr_alarms.attr,
517 &dev_attr_cpu0_vid.attr,
522 static const struct attribute_group lm78_group = {
523 .attrs = lm78_attributes,
526 /* I2C devices get this name attribute automatically, but for ISA devices
527 we must create it by ourselves. */
528 static ssize_t show_name(struct device *dev, struct device_attribute
531 struct lm78_data *data = dev_get_drvdata(dev);
533 return sprintf(buf, "%s\n", data->name);
535 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
537 /* Returns 1 if the I2C chip appears to be an alias of the ISA chip */
538 static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
540 struct lm78_data *i2c, *isa;
543 if (!pdev) /* No ISA chip */
546 i2c = i2c_get_clientdata(client);
547 isa = platform_get_drvdata(pdev);
549 if (lm78_read_value(isa, LM78_REG_I2C_ADDR) != client->addr)
550 return 0; /* Address doesn't match */
551 if ((lm78_read_value(isa, LM78_REG_CHIPID) & 0xfe) != (chipid & 0xfe))
552 return 0; /* Chip type doesn't match */
554 /* We compare all the limit registers, the config register and the
555 * interrupt mask registers */
556 for (i = 0x2b; i <= 0x3d; i++) {
557 if (lm78_read_value(isa, i) != lm78_read_value(i2c, i))
560 if (lm78_read_value(isa, LM78_REG_CONFIG) !=
561 lm78_read_value(i2c, LM78_REG_CONFIG))
563 for (i = 0x43; i <= 0x46; i++) {
564 if (lm78_read_value(isa, i) != lm78_read_value(i2c, i))
571 /* This function is called by i2c_probe */
572 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind)
575 struct i2c_client *new_client;
576 struct lm78_data *data;
577 const char *client_name = "";
579 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
584 /* OK. For now, we presume we have a valid client. We now create the
585 client structure, even though we cannot fill it completely yet.
586 But it allows us to access lm78_{read,write}_value. */
588 if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
593 new_client = &data->client;
594 i2c_set_clientdata(new_client, data);
595 new_client->addr = address;
596 new_client->adapter = adapter;
597 new_client->driver = &lm78_driver;
599 /* Now, we do the remaining detection. */
601 if (lm78_read_value(data, LM78_REG_CONFIG) & 0x80) {
605 if (lm78_read_value(data, LM78_REG_I2C_ADDR) !=
610 /* Explicitly prevent the misdetection of Winbond chips */
611 i = lm78_read_value(data, 0x4f);
612 if (i == 0xa3 || i == 0x5c) {
618 /* Determine the chip type. */
620 i = lm78_read_value(data, LM78_REG_CHIPID);
621 if (i == 0x00 || i == 0x20 /* LM78 */
622 || i == 0x40) /* LM78-J */
624 else if ((i & 0xfe) == 0xc0)
628 dev_warn(&adapter->dev, "Ignoring 'force' "
629 "parameter for unknown chip at "
630 "adapter %d, address 0x%02x\n",
631 i2c_adapter_id(adapter), address);
636 if (lm78_alias_detect(new_client, i)) {
637 dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
638 "be the same as ISA device\n", address);
645 client_name = "lm78";
646 } else if (kind == lm79) {
647 client_name = "lm79";
650 /* Fill in the remaining client fields and put into the global list */
651 strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
654 /* Tell the I2C layer a new client has arrived */
655 if ((err = i2c_attach_client(new_client)))
658 /* Initialize the LM78 chip */
659 lm78_init_device(data);
661 /* Register sysfs hooks */
662 if ((err = sysfs_create_group(&new_client->dev.kobj, &lm78_group)))
665 data->hwmon_dev = hwmon_device_register(&new_client->dev);
666 if (IS_ERR(data->hwmon_dev)) {
667 err = PTR_ERR(data->hwmon_dev);
674 sysfs_remove_group(&new_client->dev.kobj, &lm78_group);
676 i2c_detach_client(new_client);
683 static int lm78_detach_client(struct i2c_client *client)
685 struct lm78_data *data = i2c_get_clientdata(client);
688 hwmon_device_unregister(data->hwmon_dev);
689 sysfs_remove_group(&client->dev.kobj, &lm78_group);
691 if ((err = i2c_detach_client(client)))
699 static int __devinit lm78_isa_probe(struct platform_device *pdev)
702 struct lm78_data *data;
703 struct resource *res;
705 /* Reserve the ISA region */
706 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
707 if (!request_region(res->start + LM78_ADDR_REG_OFFSET, 2, "lm78")) {
712 if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
714 goto exit_release_region;
716 mutex_init(&data->lock);
717 data->isa_addr = res->start;
718 platform_set_drvdata(pdev, data);
720 if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
728 /* Initialize the LM78 chip */
729 lm78_init_device(data);
731 /* Register sysfs hooks */
732 if ((err = sysfs_create_group(&pdev->dev.kobj, &lm78_group))
733 || (err = device_create_file(&pdev->dev, &dev_attr_name)))
734 goto exit_remove_files;
736 data->hwmon_dev = hwmon_device_register(&pdev->dev);
737 if (IS_ERR(data->hwmon_dev)) {
738 err = PTR_ERR(data->hwmon_dev);
739 goto exit_remove_files;
745 sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
746 device_remove_file(&pdev->dev, &dev_attr_name);
749 release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
754 static int __devexit lm78_isa_remove(struct platform_device *pdev)
756 struct lm78_data *data = platform_get_drvdata(pdev);
757 struct resource *res;
759 hwmon_device_unregister(data->hwmon_dev);
760 sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
761 device_remove_file(&pdev->dev, &dev_attr_name);
764 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
765 release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
770 /* The SMBus locks itself, but ISA access must be locked explicitly!
771 We don't want to lock the whole ISA bus, so we lock each client
773 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
774 would slow down the LM78 access and should not be necessary. */
775 static int lm78_read_value(struct lm78_data *data, u8 reg)
777 struct i2c_client *client = &data->client;
779 if (!client->driver) { /* ISA device */
781 mutex_lock(&data->lock);
782 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
783 res = inb_p(data->isa_addr + LM78_DATA_REG_OFFSET);
784 mutex_unlock(&data->lock);
787 return i2c_smbus_read_byte_data(client, reg);
790 /* The SMBus locks itself, but ISA access muse be locked explicitly!
791 We don't want to lock the whole ISA bus, so we lock each client
793 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
794 would slow down the LM78 access and should not be necessary.
795 There are some ugly typecasts here, but the good new is - they should
796 nowhere else be necessary! */
797 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
799 struct i2c_client *client = &data->client;
801 if (!client->driver) { /* ISA device */
802 mutex_lock(&data->lock);
803 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
804 outb_p(value, data->isa_addr + LM78_DATA_REG_OFFSET);
805 mutex_unlock(&data->lock);
808 return i2c_smbus_write_byte_data(client, reg, value);
811 static void lm78_init_device(struct lm78_data *data)
816 /* Start monitoring */
817 config = lm78_read_value(data, LM78_REG_CONFIG);
818 if ((config & 0x09) != 0x01)
819 lm78_write_value(data, LM78_REG_CONFIG,
820 (config & 0xf7) | 0x01);
822 /* A few vars need to be filled upon startup */
823 for (i = 0; i < 3; i++) {
824 data->fan_min[i] = lm78_read_value(data,
825 LM78_REG_FAN_MIN(i));
828 mutex_init(&data->update_lock);
831 static struct lm78_data *lm78_update_device(struct device *dev)
833 struct lm78_data *data = dev_get_drvdata(dev);
836 mutex_lock(&data->update_lock);
838 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
841 dev_dbg(dev, "Starting lm78 update\n");
843 for (i = 0; i <= 6; i++) {
845 lm78_read_value(data, LM78_REG_IN(i));
847 lm78_read_value(data, LM78_REG_IN_MIN(i));
849 lm78_read_value(data, LM78_REG_IN_MAX(i));
851 for (i = 0; i < 3; i++) {
853 lm78_read_value(data, LM78_REG_FAN(i));
855 lm78_read_value(data, LM78_REG_FAN_MIN(i));
857 data->temp = lm78_read_value(data, LM78_REG_TEMP);
859 lm78_read_value(data, LM78_REG_TEMP_OVER);
861 lm78_read_value(data, LM78_REG_TEMP_HYST);
862 i = lm78_read_value(data, LM78_REG_VID_FANDIV);
863 data->vid = i & 0x0f;
864 if (data->type == lm79)
866 (lm78_read_value(data, LM78_REG_CHIPID) &
870 data->fan_div[0] = (i >> 4) & 0x03;
871 data->fan_div[1] = i >> 6;
872 data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +
873 (lm78_read_value(data, LM78_REG_ALARM2) << 8);
874 data->last_updated = jiffies;
877 data->fan_div[2] = 1;
880 mutex_unlock(&data->update_lock);
885 /* return 1 if a supported chip is found, 0 otherwise */
886 static int __init lm78_isa_found(unsigned short address)
888 int val, save, found = 0;
890 /* We have to request the region in two parts because some
891 boards declare base+4 to base+7 as a PNP device */
892 if (!request_region(address, 4, "lm78")) {
893 pr_debug("lm78: Failed to request low part of region\n");
896 if (!request_region(address + 4, 4, "lm78")) {
897 pr_debug("lm78: Failed to request high part of region\n");
898 release_region(address, 4);
902 #define REALLY_SLOW_IO
903 /* We need the timeouts for at least some LM78-like
904 chips. But only if we read 'undefined' registers. */
905 val = inb_p(address + 1);
906 if (inb_p(address + 2) != val
907 || inb_p(address + 3) != val
908 || inb_p(address + 7) != val)
910 #undef REALLY_SLOW_IO
912 /* We should be able to change the 7 LSB of the address port. The
913 MSB (busy flag) should be clear initially, set after the write. */
914 save = inb_p(address + LM78_ADDR_REG_OFFSET);
918 outb_p(val, address + LM78_ADDR_REG_OFFSET);
919 if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
920 outb_p(save, address + LM78_ADDR_REG_OFFSET);
924 /* We found a device, now see if it could be an LM78 */
925 outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET);
926 val = inb_p(address + LM78_DATA_REG_OFFSET);
929 outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET);
930 val = inb_p(address + LM78_DATA_REG_OFFSET);
931 if (val < 0x03 || val > 0x77) /* Not a valid I2C address */
934 /* The busy flag should be clear again */
935 if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)
938 /* Explicitly prevent the misdetection of Winbond chips */
939 outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);
940 val = inb_p(address + LM78_DATA_REG_OFFSET);
941 if (val == 0xa3 || val == 0x5c)
944 /* Explicitly prevent the misdetection of ITE chips */
945 outb_p(0x58, address + LM78_ADDR_REG_OFFSET);
946 val = inb_p(address + LM78_DATA_REG_OFFSET);
950 /* Determine the chip type */
951 outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET);
952 val = inb_p(address + LM78_DATA_REG_OFFSET);
953 if (val == 0x00 || val == 0x20 /* LM78 */
954 || val == 0x40 /* LM78-J */
955 || (val & 0xfe) == 0xc0) /* LM79 */
959 pr_info("lm78: Found an %s chip at %#x\n",
960 val & 0x80 ? "LM79" : "LM78", (int)address);
963 release_region(address + 4, 4);
964 release_region(address, 4);
968 static int __init lm78_isa_device_add(unsigned short address)
970 struct resource res = {
972 .end = address + LM78_EXTENT - 1,
974 .flags = IORESOURCE_IO,
978 pdev = platform_device_alloc("lm78", address);
981 printk(KERN_ERR "lm78: Device allocation failed\n");
985 err = platform_device_add_resources(pdev, &res, 1);
987 printk(KERN_ERR "lm78: Device resource addition failed "
989 goto exit_device_put;
992 err = platform_device_add(pdev);
994 printk(KERN_ERR "lm78: Device addition failed (%d)\n",
996 goto exit_device_put;
1002 platform_device_put(pdev);
1008 static int __init sm_lm78_init(void)
1012 /* We register the ISA device first, so that we can skip the
1013 * registration of an I2C interface to the same device. */
1014 if (lm78_isa_found(isa_address)) {
1015 res = platform_driver_register(&lm78_isa_driver);
1019 /* Sets global pdev as a side effect */
1020 res = lm78_isa_device_add(isa_address);
1022 goto exit_unreg_isa_driver;
1025 res = i2c_add_driver(&lm78_driver);
1027 goto exit_unreg_isa_device;
1031 exit_unreg_isa_device:
1032 platform_device_unregister(pdev);
1033 exit_unreg_isa_driver:
1034 platform_driver_unregister(&lm78_isa_driver);
1039 static void __exit sm_lm78_exit(void)
1042 platform_device_unregister(pdev);
1043 platform_driver_unregister(&lm78_isa_driver);
1045 i2c_del_driver(&lm78_driver);
1050 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
1051 MODULE_DESCRIPTION("LM78/LM79 driver");
1052 MODULE_LICENSE("GPL");
1054 module_init(sm_lm78_init);
1055 module_exit(sm_lm78_exit);