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)
93
return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
96
static inline int FAN_FROM_REG(u8 val, int div)
98
return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div);
101
/* TEMP: mC (-128C to +127C)
102
REG: 1C/bit, two's complement */
103
static inline s8 TEMP_TO_REG(int val)
105
int nval = SENSORS_LIMIT(val, -128000, 127000) ;
106
return nval<0 ? (nval-500)/1000 : (nval+500)/1000;
109
static inline int TEMP_FROM_REG(s8 val)
114
#define DIV_FROM_REG(val) (1 << (val))
117
struct i2c_client *client;
118
struct device *hwmon_dev;
122
/* For ISA device only */
126
struct mutex update_lock;
127
char valid; /* !=0 if following fields are valid */
128
unsigned long last_updated; /* In jiffies */
130
u8 in[7]; /* Register value */
131
u8 in_max[7]; /* Register value */
132
u8 in_min[7]; /* Register value */
133
u8 fan[3]; /* Register value */
134
u8 fan_min[3]; /* Register value */
135
s8 temp; /* Register value */
136
s8 temp_over; /* Register value */
137
s8 temp_hyst; /* Register value */
138
u8 fan_div[3]; /* Register encoding, shifted right */
139
u8 vid; /* Register encoding, combined */
140
u16 alarms; /* Register encoding, combined */
144
static int lm78_read_value(struct lm78_data *data, u8 reg);
145
static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value);
146
static struct lm78_data *lm78_update_device(struct device *dev);
147
static void lm78_init_device(struct lm78_data *data);
151
static ssize_t show_in(struct device *dev, struct device_attribute *da,
154
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
155
struct lm78_data *data = lm78_update_device(dev);
156
return sprintf(buf, "%d\n", IN_FROM_REG(data->in[attr->index]));
159
static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
162
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
163
struct lm78_data *data = lm78_update_device(dev);
164
return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[attr->index]));
167
static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
170
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
171
struct lm78_data *data = lm78_update_device(dev);
172
return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[attr->index]));
175
static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
176
const char *buf, size_t count)
178
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
179
struct lm78_data *data = dev_get_drvdata(dev);
180
unsigned long val = simple_strtoul(buf, NULL, 10);
181
int nr = attr->index;
183
mutex_lock(&data->update_lock);
184
data->in_min[nr] = IN_TO_REG(val);
185
lm78_write_value(data, LM78_REG_IN_MIN(nr), data->in_min[nr]);
186
mutex_unlock(&data->update_lock);
190
static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
191
const char *buf, size_t count)
193
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
194
struct lm78_data *data = dev_get_drvdata(dev);
195
unsigned long val = simple_strtoul(buf, NULL, 10);
196
int nr = attr->index;
198
mutex_lock(&data->update_lock);
199
data->in_max[nr] = IN_TO_REG(val);
200
lm78_write_value(data, LM78_REG_IN_MAX(nr), data->in_max[nr]);
201
mutex_unlock(&data->update_lock);
205
#define show_in_offset(offset) \
206
static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
207
show_in, NULL, offset); \
208
static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
209
show_in_min, set_in_min, offset); \
210
static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
211
show_in_max, set_in_max, offset);
222
static ssize_t show_temp(struct device *dev, struct device_attribute *da,
225
struct lm78_data *data = lm78_update_device(dev);
226
return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
229
static ssize_t show_temp_over(struct device *dev, struct device_attribute *da,
232
struct lm78_data *data = lm78_update_device(dev);
233
return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
236
static ssize_t set_temp_over(struct device *dev, struct device_attribute *da,
237
const char *buf, size_t count)
239
struct lm78_data *data = dev_get_drvdata(dev);
240
long val = simple_strtol(buf, NULL, 10);
242
mutex_lock(&data->update_lock);
243
data->temp_over = TEMP_TO_REG(val);
244
lm78_write_value(data, LM78_REG_TEMP_OVER, data->temp_over);
245
mutex_unlock(&data->update_lock);
249
static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *da,
252
struct lm78_data *data = lm78_update_device(dev);
253
return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
256
static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *da,
257
const char *buf, size_t count)
259
struct lm78_data *data = dev_get_drvdata(dev);
260
long val = simple_strtol(buf, NULL, 10);
262
mutex_lock(&data->update_lock);
263
data->temp_hyst = TEMP_TO_REG(val);
264
lm78_write_value(data, LM78_REG_TEMP_HYST, data->temp_hyst);
265
mutex_unlock(&data->update_lock);
269
static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
270
static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
271
show_temp_over, set_temp_over);
272
static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
273
show_temp_hyst, set_temp_hyst);
276
static ssize_t show_fan(struct device *dev, struct device_attribute *da,
279
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
280
struct lm78_data *data = lm78_update_device(dev);
281
int nr = attr->index;
282
return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
283
DIV_FROM_REG(data->fan_div[nr])) );
286
static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
289
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
290
struct lm78_data *data = lm78_update_device(dev);
291
int nr = attr->index;
292
return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr],
293
DIV_FROM_REG(data->fan_div[nr])) );
296
static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
297
const char *buf, size_t count)
299
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
300
struct lm78_data *data = dev_get_drvdata(dev);
301
int nr = attr->index;
302
unsigned long val = simple_strtoul(buf, NULL, 10);
304
mutex_lock(&data->update_lock);
305
data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
306
lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
307
mutex_unlock(&data->update_lock);
311
static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
314
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
315
struct lm78_data *data = lm78_update_device(dev);
316
return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));
319
/* Note: we save and restore the fan minimum here, because its value is
320
determined in part by the fan divisor. This follows the principle of
321
least surprise; the user doesn't expect the fan minimum to change just
322
because the divisor changed. */
323
static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
324
const char *buf, size_t count)
326
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
327
struct lm78_data *data = dev_get_drvdata(dev);
328
int nr = attr->index;
329
unsigned long val = simple_strtoul(buf, NULL, 10);
333
mutex_lock(&data->update_lock);
334
min = FAN_FROM_REG(data->fan_min[nr],
335
DIV_FROM_REG(data->fan_div[nr]));
338
case 1: data->fan_div[nr] = 0; break;
339
case 2: data->fan_div[nr] = 1; break;
340
case 4: data->fan_div[nr] = 2; break;
341
case 8: data->fan_div[nr] = 3; break;
343
dev_err(dev, "fan_div value %ld not "
344
"supported. Choose one of 1, 2, 4 or 8!\n", val);
345
mutex_unlock(&data->update_lock);
349
reg = lm78_read_value(data, LM78_REG_VID_FANDIV);
352
reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
355
reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
358
lm78_write_value(data, LM78_REG_VID_FANDIV, reg);
361
FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
362
lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
363
mutex_unlock(&data->update_lock);
368
#define show_fan_offset(offset) \
369
static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
370
show_fan, NULL, offset - 1); \
371
static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
372
show_fan_min, set_fan_min, offset - 1);
378
/* Fan 3 divisor is locked in H/W */
379
static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
380
show_fan_div, set_fan_div, 0);
381
static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
382
show_fan_div, set_fan_div, 1);
383
static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2);
386
static ssize_t show_vid(struct device *dev, struct device_attribute *da,
389
struct lm78_data *data = lm78_update_device(dev);
390
return sprintf(buf, "%d\n", vid_from_reg(data->vid, 82));
392
static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
395
static ssize_t show_alarms(struct device *dev, struct device_attribute *da,
398
struct lm78_data *data = lm78_update_device(dev);
399
return sprintf(buf, "%u\n", data->alarms);
401
static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
403
static ssize_t show_alarm(struct device *dev, struct device_attribute *da,
406
struct lm78_data *data = lm78_update_device(dev);
407
int nr = to_sensor_dev_attr(da)->index;
408
return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
410
static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
411
static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
412
static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
413
static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
414
static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
415
static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
416
static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10);
417
static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
418
static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
419
static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
420
static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
422
static struct attribute *lm78_attributes[] = {
423
&sensor_dev_attr_in0_input.dev_attr.attr,
424
&sensor_dev_attr_in0_min.dev_attr.attr,
425
&sensor_dev_attr_in0_max.dev_attr.attr,
426
&sensor_dev_attr_in0_alarm.dev_attr.attr,
427
&sensor_dev_attr_in1_input.dev_attr.attr,
428
&sensor_dev_attr_in1_min.dev_attr.attr,
429
&sensor_dev_attr_in1_max.dev_attr.attr,
430
&sensor_dev_attr_in1_alarm.dev_attr.attr,
431
&sensor_dev_attr_in2_input.dev_attr.attr,
432
&sensor_dev_attr_in2_min.dev_attr.attr,
433
&sensor_dev_attr_in2_max.dev_attr.attr,
434
&sensor_dev_attr_in2_alarm.dev_attr.attr,
435
&sensor_dev_attr_in3_input.dev_attr.attr,
436
&sensor_dev_attr_in3_min.dev_attr.attr,
437
&sensor_dev_attr_in3_max.dev_attr.attr,
438
&sensor_dev_attr_in3_alarm.dev_attr.attr,
439
&sensor_dev_attr_in4_input.dev_attr.attr,
440
&sensor_dev_attr_in4_min.dev_attr.attr,
441
&sensor_dev_attr_in4_max.dev_attr.attr,
442
&sensor_dev_attr_in4_alarm.dev_attr.attr,
443
&sensor_dev_attr_in5_input.dev_attr.attr,
444
&sensor_dev_attr_in5_min.dev_attr.attr,
445
&sensor_dev_attr_in5_max.dev_attr.attr,
446
&sensor_dev_attr_in5_alarm.dev_attr.attr,
447
&sensor_dev_attr_in6_input.dev_attr.attr,
448
&sensor_dev_attr_in6_min.dev_attr.attr,
449
&sensor_dev_attr_in6_max.dev_attr.attr,
450
&sensor_dev_attr_in6_alarm.dev_attr.attr,
451
&dev_attr_temp1_input.attr,
452
&dev_attr_temp1_max.attr,
453
&dev_attr_temp1_max_hyst.attr,
454
&sensor_dev_attr_temp1_alarm.dev_attr.attr,
455
&sensor_dev_attr_fan1_input.dev_attr.attr,
456
&sensor_dev_attr_fan1_min.dev_attr.attr,
457
&sensor_dev_attr_fan1_div.dev_attr.attr,
458
&sensor_dev_attr_fan1_alarm.dev_attr.attr,
459
&sensor_dev_attr_fan2_input.dev_attr.attr,
460
&sensor_dev_attr_fan2_min.dev_attr.attr,
461
&sensor_dev_attr_fan2_div.dev_attr.attr,
462
&sensor_dev_attr_fan2_alarm.dev_attr.attr,
463
&sensor_dev_attr_fan3_input.dev_attr.attr,
464
&sensor_dev_attr_fan3_min.dev_attr.attr,
465
&sensor_dev_attr_fan3_div.dev_attr.attr,
466
&sensor_dev_attr_fan3_alarm.dev_attr.attr,
467
&dev_attr_alarms.attr,
468
&dev_attr_cpu0_vid.attr,
473
static const struct attribute_group lm78_group = {
474
.attrs = lm78_attributes,
482
/* ISA device, if found */
483
static struct platform_device *pdev;
485
static unsigned short isa_address = 0x290;
487
/* I2C devices get this name attribute automatically, but for ISA devices
488
we must create it by ourselves. */
489
static ssize_t show_name(struct device *dev, struct device_attribute
492
struct lm78_data *data = dev_get_drvdata(dev);
494
return sprintf(buf, "%s\n", data->name);
496
static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
498
static struct lm78_data *lm78_data_if_isa(void)
500
return pdev ? platform_get_drvdata(pdev) : NULL;
503
/* Returns 1 if the I2C chip appears to be an alias of the ISA chip */
504
static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
506
struct lm78_data *isa;
509
if (!pdev) /* No ISA chip */
511
isa = platform_get_drvdata(pdev);
513
if (lm78_read_value(isa, LM78_REG_I2C_ADDR) != client->addr)
514
return 0; /* Address doesn't match */
515
if ((lm78_read_value(isa, LM78_REG_CHIPID) & 0xfe) != (chipid & 0xfe))
516
return 0; /* Chip type doesn't match */
518
/* We compare all the limit registers, the config register and the
519
* interrupt mask registers */
520
for (i = 0x2b; i <= 0x3d; i++) {
521
if (lm78_read_value(isa, i) !=
522
i2c_smbus_read_byte_data(client, i))
525
if (lm78_read_value(isa, LM78_REG_CONFIG) !=
526
i2c_smbus_read_byte_data(client, LM78_REG_CONFIG))
528
for (i = 0x43; i <= 0x46; i++) {
529
if (lm78_read_value(isa, i) !=
530
i2c_smbus_read_byte_data(client, i))
536
#else /* !CONFIG_ISA */
538
static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
543
static struct lm78_data *lm78_data_if_isa(void)
547
#endif /* CONFIG_ISA */
549
static int lm78_i2c_detect(struct i2c_client *client,
550
struct i2c_board_info *info)
553
struct lm78_data *isa = lm78_data_if_isa();
554
const char *client_name;
555
struct i2c_adapter *adapter = client->adapter;
556
int address = client->addr;
558
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
561
/* We block updates of the ISA device to minimize the risk of
562
concurrent access to the same LM78 chip through different
565
mutex_lock(&isa->update_lock);
567
if ((i2c_smbus_read_byte_data(client, LM78_REG_CONFIG) & 0x80)
568
|| i2c_smbus_read_byte_data(client, LM78_REG_I2C_ADDR) != address)
571
/* Explicitly prevent the misdetection of Winbond chips */
572
i = i2c_smbus_read_byte_data(client, 0x4f);
573
if (i == 0xa3 || i == 0x5c)
576
/* Determine the chip type. */
577
i = i2c_smbus_read_byte_data(client, LM78_REG_CHIPID);
578
if (i == 0x00 || i == 0x20 /* LM78 */
579
|| i == 0x40) /* LM78-J */
580
client_name = "lm78";
581
else if ((i & 0xfe) == 0xc0)
582
client_name = "lm79";
586
if (lm78_alias_detect(client, i)) {
587
dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
588
"be the same as ISA device\n", address);
593
mutex_unlock(&isa->update_lock);
595
strlcpy(info->type, client_name, I2C_NAME_SIZE);
601
mutex_unlock(&isa->update_lock);
605
static int lm78_i2c_probe(struct i2c_client *client,
606
const struct i2c_device_id *id)
608
struct lm78_data *data;
611
data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL);
615
i2c_set_clientdata(client, data);
616
data->client = client;
617
data->type = id->driver_data;
619
/* Initialize the LM78 chip */
620
lm78_init_device(data);
622
/* Register sysfs hooks */
623
err = sysfs_create_group(&client->dev.kobj, &lm78_group);
627
data->hwmon_dev = hwmon_device_register(&client->dev);
628
if (IS_ERR(data->hwmon_dev)) {
629
err = PTR_ERR(data->hwmon_dev);
636
sysfs_remove_group(&client->dev.kobj, &lm78_group);
642
static int lm78_i2c_remove(struct i2c_client *client)
644
struct lm78_data *data = i2c_get_clientdata(client);
646
hwmon_device_unregister(data->hwmon_dev);
647
sysfs_remove_group(&client->dev.kobj, &lm78_group);
653
static const struct i2c_device_id lm78_i2c_id[] = {
658
MODULE_DEVICE_TABLE(i2c, lm78_i2c_id);
660
static struct i2c_driver lm78_driver = {
661
.class = I2C_CLASS_HWMON,
665
.probe = lm78_i2c_probe,
666
.remove = lm78_i2c_remove,
667
.id_table = lm78_i2c_id,
668
.detect = lm78_i2c_detect,
669
.address_list = normal_i2c,
672
/* The SMBus locks itself, but ISA access must be locked explicitly!
673
We don't want to lock the whole ISA bus, so we lock each client
675
We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
676
would slow down the LM78 access and should not be necessary. */
677
static int lm78_read_value(struct lm78_data *data, u8 reg)
679
struct i2c_client *client = data->client;
682
if (!client) { /* ISA device */
684
mutex_lock(&data->lock);
685
outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
686
res = inb_p(data->isa_addr + LM78_DATA_REG_OFFSET);
687
mutex_unlock(&data->lock);
691
return i2c_smbus_read_byte_data(client, reg);
694
/* The SMBus locks itself, but ISA access muse be locked explicitly!
695
We don't want to lock the whole ISA bus, so we lock each client
697
We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
698
would slow down the LM78 access and should not be necessary.
699
There are some ugly typecasts here, but the good new is - they should
700
nowhere else be necessary! */
701
static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
703
struct i2c_client *client = data->client;
706
if (!client) { /* ISA device */
707
mutex_lock(&data->lock);
708
outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
709
outb_p(value, data->isa_addr + LM78_DATA_REG_OFFSET);
710
mutex_unlock(&data->lock);
714
return i2c_smbus_write_byte_data(client, reg, value);
717
static void lm78_init_device(struct lm78_data *data)
722
/* Start monitoring */
723
config = lm78_read_value(data, LM78_REG_CONFIG);
724
if ((config & 0x09) != 0x01)
725
lm78_write_value(data, LM78_REG_CONFIG,
726
(config & 0xf7) | 0x01);
728
/* A few vars need to be filled upon startup */
729
for (i = 0; i < 3; i++) {
730
data->fan_min[i] = lm78_read_value(data,
731
LM78_REG_FAN_MIN(i));
734
mutex_init(&data->update_lock);
737
static struct lm78_data *lm78_update_device(struct device *dev)
739
struct lm78_data *data = dev_get_drvdata(dev);
742
mutex_lock(&data->update_lock);
744
if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
747
dev_dbg(dev, "Starting lm78 update\n");
749
for (i = 0; i <= 6; i++) {
751
lm78_read_value(data, LM78_REG_IN(i));
753
lm78_read_value(data, LM78_REG_IN_MIN(i));
755
lm78_read_value(data, LM78_REG_IN_MAX(i));
757
for (i = 0; i < 3; i++) {
759
lm78_read_value(data, LM78_REG_FAN(i));
761
lm78_read_value(data, LM78_REG_FAN_MIN(i));
763
data->temp = lm78_read_value(data, LM78_REG_TEMP);
765
lm78_read_value(data, LM78_REG_TEMP_OVER);
767
lm78_read_value(data, LM78_REG_TEMP_HYST);
768
i = lm78_read_value(data, LM78_REG_VID_FANDIV);
769
data->vid = i & 0x0f;
770
if (data->type == lm79)
772
(lm78_read_value(data, LM78_REG_CHIPID) &
776
data->fan_div[0] = (i >> 4) & 0x03;
777
data->fan_div[1] = i >> 6;
778
data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +
779
(lm78_read_value(data, LM78_REG_ALARM2) << 8);
780
data->last_updated = jiffies;
783
data->fan_div[2] = 1;
786
mutex_unlock(&data->update_lock);
792
static int __devinit lm78_isa_probe(struct platform_device *pdev)
795
struct lm78_data *data;
796
struct resource *res;
798
/* Reserve the ISA region */
799
res = platform_get_resource(pdev, IORESOURCE_IO, 0);
800
if (!request_region(res->start + LM78_ADDR_REG_OFFSET, 2, "lm78")) {
805
data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL);
808
goto exit_release_region;
810
mutex_init(&data->lock);
811
data->isa_addr = res->start;
812
platform_set_drvdata(pdev, data);
814
if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
822
/* Initialize the LM78 chip */
823
lm78_init_device(data);
825
/* Register sysfs hooks */
826
if ((err = sysfs_create_group(&pdev->dev.kobj, &lm78_group))
827
|| (err = device_create_file(&pdev->dev, &dev_attr_name)))
828
goto exit_remove_files;
830
data->hwmon_dev = hwmon_device_register(&pdev->dev);
831
if (IS_ERR(data->hwmon_dev)) {
832
err = PTR_ERR(data->hwmon_dev);
833
goto exit_remove_files;
839
sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
840
device_remove_file(&pdev->dev, &dev_attr_name);
843
release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
848
static int __devexit lm78_isa_remove(struct platform_device *pdev)
850
struct lm78_data *data = platform_get_drvdata(pdev);
851
struct resource *res;
853
hwmon_device_unregister(data->hwmon_dev);
854
sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
855
device_remove_file(&pdev->dev, &dev_attr_name);
858
res = platform_get_resource(pdev, IORESOURCE_IO, 0);
859
release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
864
static struct platform_driver lm78_isa_driver = {
866
.owner = THIS_MODULE,
869
.probe = lm78_isa_probe,
870
.remove = __devexit_p(lm78_isa_remove),
873
/* return 1 if a supported chip is found, 0 otherwise */
874
static int __init lm78_isa_found(unsigned short address)
876
int val, save, found = 0;
879
/* Some boards declare base+0 to base+7 as a PNP device, some base+4
880
* to base+7 and some base+5 to base+6. So we better request each port
881
* individually for the probing phase. */
882
for (port = address; port < address + LM78_EXTENT; port++) {
883
if (!request_region(port, 1, "lm78")) {
884
pr_debug("Failed to request port 0x%x\n", port);
889
#define REALLY_SLOW_IO
890
/* We need the timeouts for at least some LM78-like
891
chips. But only if we read 'undefined' registers. */
892
val = inb_p(address + 1);
893
if (inb_p(address + 2) != val
894
|| inb_p(address + 3) != val
895
|| inb_p(address + 7) != val)
897
#undef REALLY_SLOW_IO
899
/* We should be able to change the 7 LSB of the address port. The
900
MSB (busy flag) should be clear initially, set after the write. */
901
save = inb_p(address + LM78_ADDR_REG_OFFSET);
905
outb_p(val, address + LM78_ADDR_REG_OFFSET);
906
if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
907
outb_p(save, address + LM78_ADDR_REG_OFFSET);
911
/* We found a device, now see if it could be an LM78 */
912
outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET);
913
val = inb_p(address + LM78_DATA_REG_OFFSET);
916
outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET);
917
val = inb_p(address + LM78_DATA_REG_OFFSET);
918
if (val < 0x03 || val > 0x77) /* Not a valid I2C address */
921
/* The busy flag should be clear again */
922
if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)
925
/* Explicitly prevent the misdetection of Winbond chips */
926
outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);
927
val = inb_p(address + LM78_DATA_REG_OFFSET);
928
if (val == 0xa3 || val == 0x5c)
931
/* Explicitly prevent the misdetection of ITE chips */
932
outb_p(0x58, address + LM78_ADDR_REG_OFFSET);
933
val = inb_p(address + LM78_DATA_REG_OFFSET);
937
/* Determine the chip type */
938
outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET);
939
val = inb_p(address + LM78_DATA_REG_OFFSET);
940
if (val == 0x00 || val == 0x20 /* LM78 */
941
|| val == 0x40 /* LM78-J */
942
|| (val & 0xfe) == 0xc0) /* LM79 */
946
pr_info("Found an %s chip at %#x\n",
947
val & 0x80 ? "LM79" : "LM78", (int)address);
950
for (port--; port >= address; port--)
951
release_region(port, 1);
955
static int __init lm78_isa_device_add(unsigned short address)
957
struct resource res = {
959
.end = address + LM78_EXTENT - 1,
961
.flags = IORESOURCE_IO,
965
pdev = platform_device_alloc("lm78", address);
968
pr_err("Device allocation failed\n");
972
err = platform_device_add_resources(pdev, &res, 1);
974
pr_err("Device resource addition failed (%d)\n", err);
975
goto exit_device_put;
978
err = platform_device_add(pdev);
980
pr_err("Device addition failed (%d)\n", err);
981
goto exit_device_put;
987
platform_device_put(pdev);
993
static int __init lm78_isa_register(void)
997
if (lm78_isa_found(isa_address)) {
998
res = platform_driver_register(&lm78_isa_driver);
1002
/* Sets global pdev as a side effect */
1003
res = lm78_isa_device_add(isa_address);
1005
goto exit_unreg_isa_driver;
1010
exit_unreg_isa_driver:
1011
platform_driver_unregister(&lm78_isa_driver);
1016
static void lm78_isa_unregister(void)
1019
platform_device_unregister(pdev);
1020
platform_driver_unregister(&lm78_isa_driver);
1023
#else /* !CONFIG_ISA */
1025
static int __init lm78_isa_register(void)
1030
static void lm78_isa_unregister(void)
1033
#endif /* CONFIG_ISA */
1035
static int __init sm_lm78_init(void)
1039
/* We register the ISA device first, so that we can skip the
1040
* registration of an I2C interface to the same device. */
1041
res = lm78_isa_register();
1045
res = i2c_add_driver(&lm78_driver);
1047
goto exit_unreg_isa_device;
1051
exit_unreg_isa_device:
1052
lm78_isa_unregister();
1057
static void __exit sm_lm78_exit(void)
1059
lm78_isa_unregister();
1060
i2c_del_driver(&lm78_driver);
1063
MODULE_AUTHOR("Frodo Looijaard, Jean Delvare <khali@linux-fr.org>");
1064
MODULE_DESCRIPTION("LM78/LM79 driver");
1065
MODULE_LICENSE("GPL");
1067
module_init(sm_lm78_init);
1068
module_exit(sm_lm78_exit);