projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'sched-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6-block.git] / drivers / hwmon / lm78.c
CommitLineData
1da177e4
LT		 1/*
2 lm78.c - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring
4 Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
c40769fe 5 Copyright (c) 2007 Jean Delvare <khali@linux-fr.org>
1da177e4
LT		 6
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.
11
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.
16
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.
20*/
21
1da177e4
LT		 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>
c40769fe
JD		 27#include <linux/platform_device.h>
28#include <linux/ioport.h>
943b0830 29#include <linux/hwmon.h>
19f673ed 30#include <linux/hwmon-vid.h>
247dde4c 31#include <linux/hwmon-sysfs.h>
943b0830 32#include <linux/err.h>
9a61bf63 33#include <linux/mutex.h>
1da177e4
LT		 34#include <asm/io.h>
35
c40769fe
JD		 36/* ISA device, if found */
37static struct platform_device *pdev;
38
1da177e4 39/* Addresses to scan */
25e9c86d
MH		 40static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
41 0x2e, 0x2f, I2C_CLIENT_END };
2d8672c5 42static unsigned short isa_address = 0x290;
1da177e4
LT		 43
44/* Insmod parameters */
f4b50261 45I2C_CLIENT_INSMOD_2(lm78, lm79);
1da177e4
LT		 46
47/* Many LM78 constants specified below */
48
49/* Length of ISA address segment */
50#define LM78_EXTENT 8
51
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
55
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))
60
61#define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
62#define LM78_REG_FAN(nr) (0x28 + (nr))
63
64#define LM78_REG_TEMP 0x27
65#define LM78_REG_TEMP_OVER 0x39
66#define LM78_REG_TEMP_HYST 0x3a
67
68#define LM78_REG_ALARM1 0x41
69#define LM78_REG_ALARM2 0x42
70
71#define LM78_REG_VID_FANDIV 0x47
72
73#define LM78_REG_CONFIG 0x40
74#define LM78_REG_CHIPID 0x49
75#define LM78_REG_I2C_ADDR 0x48
76
77
78/* Conversions. Rounding and limit checking is only done on the TO_REG
79 variants. */
80
81/* IN: mV, (0V to 4.08V)
82 REG: 16mV/bit */
83static inline u8 IN_TO_REG(unsigned long val)
84{
85 unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
86 return (nval + 8) / 16;
87}
88#define IN_FROM_REG(val) ((val) * 16)
89
90static inline u8 FAN_TO_REG(long rpm, int div)
91{
92 if (rpm <= 0)
93 return 255;
94 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
95}
96
97static inline int FAN_FROM_REG(u8 val, int div)
98{
99 return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div);
100}
101
102/* TEMP: mC (-128C to +127C)
103 REG: 1C/bit, two's complement */
104static inline s8 TEMP_TO_REG(int val)
105{
106 int nval = SENSORS_LIMIT(val, -128000, 127000) ;
107 return nval<0 ? (nval-500)/1000 : (nval+500)/1000;
108}
109
110static inline int TEMP_FROM_REG(s8 val)
111{
112 return val * 1000;
113}
114
1da177e4
LT		 115#define DIV_FROM_REG(val) (1 << (val))
116
1da177e4 117struct lm78_data {
0c6e9731 118 struct i2c_client *client;
1beeffe4 119 struct device *hwmon_dev;
9a61bf63 120 struct mutex lock;
1da177e4
LT		 121 enum chips type;
122
6e1b5029
JD		 123 /* For ISA device only */
124 const char *name;
125 int isa_addr;
126
9a61bf63 127 struct mutex update_lock;
1da177e4
LT		 128 char valid; /* !=0 if following fields are valid */
129 unsigned long last_updated; /* In jiffies */
130
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 */
142};
143
144
0c6e9731
JD		 145static int lm78_i2c_detect(struct i2c_client *client, int kind,
146 struct i2c_board_info *info);
147static int lm78_i2c_probe(struct i2c_client *client,
148 const struct i2c_device_id *id);
149static int lm78_i2c_remove(struct i2c_client *client);
1da177e4 150
c40769fe
JD		 151static int __devinit lm78_isa_probe(struct platform_device *pdev);
152static int __devexit lm78_isa_remove(struct platform_device *pdev);
153
c59cc301
JD		 154static int lm78_read_value(struct lm78_data *data, u8 reg);
155static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value);
1da177e4 156static struct lm78_data *lm78_update_device(struct device *dev);
c59cc301 157static void lm78_init_device(struct lm78_data *data);
1da177e4
LT		 158
159
0c6e9731
JD		 160static const struct i2c_device_id lm78_i2c_id[] = {
161 { "lm78", lm78 },
162 { "lm79", lm79 },
163 { }
164};
165MODULE_DEVICE_TABLE(i2c, lm78_i2c_id);
166
1da177e4 167static struct i2c_driver lm78_driver = {
0c6e9731 168 .class = I2C_CLASS_HWMON,
cdaf7934 169 .driver = {
cdaf7934
LR		 170 .name = "lm78",
171 },
0c6e9731
JD		 172 .probe = lm78_i2c_probe,
173 .remove = lm78_i2c_remove,
174 .id_table = lm78_i2c_id,
175 .detect = lm78_i2c_detect,
176 .address_data = &addr_data,
1da177e4
LT		 177};
178
c40769fe 179static struct platform_driver lm78_isa_driver = {
cdaf7934 180 .driver = {
87218842 181 .owner = THIS_MODULE,
c40769fe 182 .name = "lm78",
cdaf7934 183 },
c40769fe
JD		 184 .probe = lm78_isa_probe,
185 .remove = lm78_isa_remove,
fde09509
JD		 186};
187
188
1da177e4 189/* 7 Voltages */
247dde4c
JD		 190static ssize_t show_in(struct device *dev, struct device_attribute *da,
191 char *buf)
1da177e4 192{
247dde4c 193 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
1da177e4 194 struct lm78_data *data = lm78_update_device(dev);
247dde4c 195 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[attr->index]));
1da177e4
LT		 196}
197
247dde4c
JD		 198static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
199 char *buf)
1da177e4 200{
247dde4c 201 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
1da177e4 202 struct lm78_data *data = lm78_update_device(dev);
247dde4c 203 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[attr->index]));
1da177e4
LT		 204}
205
247dde4c
JD		 206static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
207 char *buf)
1da177e4 208{
247dde4c 209 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
1da177e4 210 struct lm78_data *data = lm78_update_device(dev);
247dde4c 211 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[attr->index]));
1da177e4
LT		 212}
213
247dde4c
JD		 214static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
215 const char *buf, size_t count)
1da177e4 216{
247dde4c 217 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
c40769fe 218 struct lm78_data *data = dev_get_drvdata(dev);
1da177e4 219 unsigned long val = simple_strtoul(buf, NULL, 10);
247dde4c 220 int nr = attr->index;
1da177e4 221
9a61bf63 222 mutex_lock(&data->update_lock);
1da177e4 223 data->in_min[nr] = IN_TO_REG(val);
c59cc301 224 lm78_write_value(data, LM78_REG_IN_MIN(nr), data->in_min[nr]);
9a61bf63 225 mutex_unlock(&data->update_lock);
1da177e4
LT		 226 return count;
227}
228
247dde4c
JD		 229static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
230 const char *buf, size_t count)
1da177e4 231{
247dde4c 232 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
c40769fe 233 struct lm78_data *data = dev_get_drvdata(dev);
1da177e4 234 unsigned long val = simple_strtoul(buf, NULL, 10);
247dde4c 235 int nr = attr->index;
1da177e4 236
9a61bf63 237 mutex_lock(&data->update_lock);
1da177e4 238 data->in_max[nr] = IN_TO_REG(val);
c59cc301 239 lm78_write_value(data, LM78_REG_IN_MAX(nr), data->in_max[nr]);
9a61bf63 240 mutex_unlock(&data->update_lock);
1da177e4
LT		 241 return count;
242}
243
244#define show_in_offset(offset) \
247dde4c
JD		 245static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
246 show_in, NULL, offset); \
247static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
248 show_in_min, set_in_min, offset); \
249static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
250 show_in_max, set_in_max, offset);
1da177e4
LT		 251
252show_in_offset(0);
253show_in_offset(1);
254show_in_offset(2);
255show_in_offset(3);
256show_in_offset(4);
257show_in_offset(5);
258show_in_offset(6);
259
260/* Temperature */
247dde4c
JD		 261static ssize_t show_temp(struct device *dev, struct device_attribute *da,
262 char *buf)
1da177e4
LT		 263{
264 struct lm78_data *data = lm78_update_device(dev);
265 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
266}
267
247dde4c
JD		 268static ssize_t show_temp_over(struct device *dev, struct device_attribute *da,
269 char *buf)
1da177e4
LT		 270{
271 struct lm78_data *data = lm78_update_device(dev);
272 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
273}
274
247dde4c
JD		 275static ssize_t set_temp_over(struct device *dev, struct device_attribute *da,
276 const char *buf, size_t count)
1da177e4 277{
c40769fe 278 struct lm78_data *data = dev_get_drvdata(dev);
1da177e4
LT		 279 long val = simple_strtol(buf, NULL, 10);
280
9a61bf63 281 mutex_lock(&data->update_lock);
1da177e4 282 data->temp_over = TEMP_TO_REG(val);
c59cc301 283 lm78_write_value(data, LM78_REG_TEMP_OVER, data->temp_over);
9a61bf63 284 mutex_unlock(&data->update_lock);
1da177e4
LT		 285 return count;
286}
287
247dde4c
JD		 288static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *da,
289 char *buf)
1da177e4
LT		 290{
291 struct lm78_data *data = lm78_update_device(dev);
292 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
293}
294
247dde4c
JD		 295static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *da,
296 const char *buf, size_t count)
1da177e4 297{
c40769fe 298 struct lm78_data *data = dev_get_drvdata(dev);
1da177e4
LT		 299 long val = simple_strtol(buf, NULL, 10);
300
9a61bf63 301 mutex_lock(&data->update_lock);
1da177e4 302 data->temp_hyst = TEMP_TO_REG(val);
c59cc301 303 lm78_write_value(data, LM78_REG_TEMP_HYST, data->temp_hyst);
9a61bf63 304 mutex_unlock(&data->update_lock);
1da177e4
LT		 305 return count;
306}
307
308static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
309static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
310 show_temp_over, set_temp_over);
311static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
312 show_temp_hyst, set_temp_hyst);
313
314/* 3 Fans */
247dde4c
JD		 315static ssize_t show_fan(struct device *dev, struct device_attribute *da,
316 char *buf)
1da177e4 317{
247dde4c 318 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
1da177e4 319 struct lm78_data *data = lm78_update_device(dev);
247dde4c 320 int nr = attr->index;
1da177e4
LT		 321 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
322 DIV_FROM_REG(data->fan_div[nr])) );
323}
324
247dde4c
JD		 325static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
326 char *buf)
1da177e4 327{
247dde4c 328 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
1da177e4 329 struct lm78_data *data = lm78_update_device(dev);
247dde4c 330 int nr = attr->index;
1da177e4
LT		 331 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr],
332 DIV_FROM_REG(data->fan_div[nr])) );
333}
334
247dde4c
JD		 335static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
336 const char *buf, size_t count)
1da177e4 337{
247dde4c 338 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
c40769fe 339 struct lm78_data *data = dev_get_drvdata(dev);
247dde4c 340 int nr = attr->index;
1da177e4
LT		 341 unsigned long val = simple_strtoul(buf, NULL, 10);
342
9a61bf63 343 mutex_lock(&data->update_lock);
1da177e4 344 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
c59cc301 345 lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
9a61bf63 346 mutex_unlock(&data->update_lock);
1da177e4
LT		 347 return count;
348}
349
247dde4c
JD		 350static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
351 char *buf)
1da177e4 352{
247dde4c 353 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
1da177e4 354 struct lm78_data *data = lm78_update_device(dev);
247dde4c 355 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));
1da177e4
LT		 356}
357
358/* Note: we save and restore the fan minimum here, because its value is
359 determined in part by the fan divisor. This follows the principle of
d6e05edc 360 least surprise; the user doesn't expect the fan minimum to change just
1da177e4 361 because the divisor changed. */
247dde4c
JD		 362static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
363 const char *buf, size_t count)
1da177e4 364{
247dde4c 365 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
c40769fe 366 struct lm78_data *data = dev_get_drvdata(dev);
247dde4c 367 int nr = attr->index;
1da177e4
LT		 368 unsigned long val = simple_strtoul(buf, NULL, 10);
369 unsigned long min;
370 u8 reg;
371
9a61bf63 372 mutex_lock(&data->update_lock);
1da177e4
LT		 373 min = FAN_FROM_REG(data->fan_min[nr],
374 DIV_FROM_REG(data->fan_div[nr]));
375
376 switch (val) {
377 case 1: data->fan_div[nr] = 0; break;
378 case 2: data->fan_div[nr] = 1; break;
379 case 4: data->fan_div[nr] = 2; break;
380 case 8: data->fan_div[nr] = 3; break;
381 default:
c40769fe 382 dev_err(dev, "fan_div value %ld not "
1da177e4 383 "supported. Choose one of 1, 2, 4 or 8!\n", val);
9a61bf63 384 mutex_unlock(&data->update_lock);
1da177e4
LT		 385 return -EINVAL;
386 }
387
c59cc301 388 reg = lm78_read_value(data, LM78_REG_VID_FANDIV);
1da177e4
LT		 389 switch (nr) {
390 case 0:
391 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
392 break;
393 case 1:
394 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
395 break;
396 }
c59cc301 397 lm78_write_value(data, LM78_REG_VID_FANDIV, reg);
1da177e4
LT		 398
399 data->fan_min[nr] =
400 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
c59cc301 401 lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
9a61bf63 402 mutex_unlock(&data->update_lock);
1da177e4
LT		 403
404 return count;
405}
406
247dde4c
JD		 407#define show_fan_offset(offset) \
408static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
409 show_fan, NULL, offset - 1); \
410static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
411 show_fan_min, set_fan_min, offset - 1);
1da177e4
LT		 412
413show_fan_offset(1);
414show_fan_offset(2);
415show_fan_offset(3);
416
417/* Fan 3 divisor is locked in H/W */
247dde4c
JD		 418static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
419 show_fan_div, set_fan_div, 0);
420static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
421 show_fan_div, set_fan_div, 1);
422static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2);
1da177e4
LT		 423
424/* VID */
247dde4c
JD		 425static ssize_t show_vid(struct device *dev, struct device_attribute *da,
426 char *buf)
1da177e4
LT		 427{
428 struct lm78_data *data = lm78_update_device(dev);
d0d3cd69 429 return sprintf(buf, "%d\n", vid_from_reg(data->vid, 82));
1da177e4
LT		 430}
431static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
432
433/* Alarms */
247dde4c
JD		 434static ssize_t show_alarms(struct device *dev, struct device_attribute *da,
435 char *buf)
1da177e4
LT		 436{
437 struct lm78_data *data = lm78_update_device(dev);
438 return sprintf(buf, "%u\n", data->alarms);
439}
440static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
441
428a7039
JD		 442static ssize_t show_alarm(struct device *dev, struct device_attribute *da,
443 char *buf)
444{
445 struct lm78_data *data = lm78_update_device(dev);
446 int nr = to_sensor_dev_attr(da)->index;
447 return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
448}
449static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
450static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
451static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
452static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
453static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
454static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
455static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10);
456static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
457static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
458static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
459static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
460
c1685f61 461static struct attribute *lm78_attributes[] = {
247dde4c
JD		 462 &sensor_dev_attr_in0_input.dev_attr.attr,
463 &sensor_dev_attr_in0_min.dev_attr.attr,
464 &sensor_dev_attr_in0_max.dev_attr.attr,
428a7039 465 &sensor_dev_attr_in0_alarm.dev_attr.attr,
247dde4c
JD		 466 &sensor_dev_attr_in1_input.dev_attr.attr,
467 &sensor_dev_attr_in1_min.dev_attr.attr,
468 &sensor_dev_attr_in1_max.dev_attr.attr,
428a7039 469 &sensor_dev_attr_in1_alarm.dev_attr.attr,
247dde4c
JD		 470 &sensor_dev_attr_in2_input.dev_attr.attr,
471 &sensor_dev_attr_in2_min.dev_attr.attr,
472 &sensor_dev_attr_in2_max.dev_attr.attr,
428a7039 473 &sensor_dev_attr_in2_alarm.dev_attr.attr,
247dde4c
JD		 474 &sensor_dev_attr_in3_input.dev_attr.attr,
475 &sensor_dev_attr_in3_min.dev_attr.attr,
476 &sensor_dev_attr_in3_max.dev_attr.attr,
428a7039 477 &sensor_dev_attr_in3_alarm.dev_attr.attr,
247dde4c
JD		 478 &sensor_dev_attr_in4_input.dev_attr.attr,
479 &sensor_dev_attr_in4_min.dev_attr.attr,
480 &sensor_dev_attr_in4_max.dev_attr.attr,
428a7039 481 &sensor_dev_attr_in4_alarm.dev_attr.attr,
247dde4c
JD		 482 &sensor_dev_attr_in5_input.dev_attr.attr,
483 &sensor_dev_attr_in5_min.dev_attr.attr,
484 &sensor_dev_attr_in5_max.dev_attr.attr,
428a7039 485 &sensor_dev_attr_in5_alarm.dev_attr.attr,
247dde4c
JD		 486 &sensor_dev_attr_in6_input.dev_attr.attr,
487 &sensor_dev_attr_in6_min.dev_attr.attr,
488 &sensor_dev_attr_in6_max.dev_attr.attr,
428a7039 489 &sensor_dev_attr_in6_alarm.dev_attr.attr,
c1685f61
MH		 490 &dev_attr_temp1_input.attr,
491 &dev_attr_temp1_max.attr,
492 &dev_attr_temp1_max_hyst.attr,
428a7039 493 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
247dde4c
JD		 494 &sensor_dev_attr_fan1_input.dev_attr.attr,
495 &sensor_dev_attr_fan1_min.dev_attr.attr,
496 &sensor_dev_attr_fan1_div.dev_attr.attr,
428a7039 497 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
247dde4c
JD		 498 &sensor_dev_attr_fan2_input.dev_attr.attr,
499 &sensor_dev_attr_fan2_min.dev_attr.attr,
500 &sensor_dev_attr_fan2_div.dev_attr.attr,
428a7039 501 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
247dde4c
JD		 502 &sensor_dev_attr_fan3_input.dev_attr.attr,
503 &sensor_dev_attr_fan3_min.dev_attr.attr,
504 &sensor_dev_attr_fan3_div.dev_attr.attr,
428a7039 505 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
c1685f61
MH		 506 &dev_attr_alarms.attr,
507 &dev_attr_cpu0_vid.attr,
508
509 NULL
510};
511
512static const struct attribute_group lm78_group = {
513 .attrs = lm78_attributes,
514};
515
c40769fe
JD		 516/* I2C devices get this name attribute automatically, but for ISA devices
517 we must create it by ourselves. */
518static ssize_t show_name(struct device *dev, struct device_attribute
519 *devattr, char *buf)
520{
521 struct lm78_data *data = dev_get_drvdata(dev);
522
6e1b5029 523 return sprintf(buf, "%s\n", data->name);
c40769fe
JD		 524}
525static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
526
18c73f90
JD		 527/* Returns 1 if the I2C chip appears to be an alias of the ISA chip */
528static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
529{
0c6e9731 530 struct lm78_data *isa;
18c73f90
JD		 531 int i;
532
533 if (!pdev) /* No ISA chip */
534 return 0;
18c73f90
JD		 535 isa = platform_get_drvdata(pdev);
536
537 if (lm78_read_value(isa, LM78_REG_I2C_ADDR) != client->addr)
538 return 0; /* Address doesn't match */
539 if ((lm78_read_value(isa, LM78_REG_CHIPID) & 0xfe) != (chipid & 0xfe))
540 return 0; /* Chip type doesn't match */
541
542 /* We compare all the limit registers, the config register and the
543 * interrupt mask registers */
544 for (i = 0x2b; i <= 0x3d; i++) {
0c6e9731
JD		 545 if (lm78_read_value(isa, i) !=
546 i2c_smbus_read_byte_data(client, i))
18c73f90
JD		 547 return 0;
548 }
549 if (lm78_read_value(isa, LM78_REG_CONFIG) !=
0c6e9731 550 i2c_smbus_read_byte_data(client, LM78_REG_CONFIG))
18c73f90
JD		 551 return 0;
552 for (i = 0x43; i <= 0x46; i++) {
0c6e9731
JD		 553 if (lm78_read_value(isa, i) !=
554 i2c_smbus_read_byte_data(client, i))
18c73f90
JD		 555 return 0;
556 }
557
558 return 1;
559}
560
0c6e9731
JD		 561static int lm78_i2c_detect(struct i2c_client *client, int kind,
562 struct i2c_board_info *info)
1da177e4 563{
0c6e9731
JD		 564 int i;
565 struct lm78_data *isa = pdev ? platform_get_drvdata(pdev) : NULL;
566 const char *client_name;
567 struct i2c_adapter *adapter = client->adapter;
568 int address = client->addr;
1da177e4 569
0c6e9731
JD		 570 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
571 return -ENODEV;
1da177e4 572
0c6e9731
JD		 573 /* We block updates of the ISA device to minimize the risk of
574 concurrent access to the same LM78 chip through different
575 interfaces. */
576 if (isa)
577 mutex_lock(&isa->update_lock);
1da177e4 578
1da177e4 579 if (kind < 0) {
0c6e9731
JD		 580 if ((i2c_smbus_read_byte_data(client, LM78_REG_CONFIG) & 0x80)
581 || i2c_smbus_read_byte_data(client, LM78_REG_I2C_ADDR)
582 != address)
583 goto err_nodev;
584
ad3273be 585 /* Explicitly prevent the misdetection of Winbond chips */
0c6e9731
JD		 586 i = i2c_smbus_read_byte_data(client, 0x4f);
587 if (i == 0xa3 || i == 0x5c)
588 goto err_nodev;
1da177e4
LT		 589 }
590
591 /* Determine the chip type. */
592 if (kind <= 0) {
0c6e9731 593 i = i2c_smbus_read_byte_data(client, LM78_REG_CHIPID);
27fe048e
JD		 594 if (i == 0x00 || i == 0x20 /* LM78 */
595 || i == 0x40) /* LM78-J */
1da177e4 596 kind = lm78;
1da177e4
LT		 597 else if ((i & 0xfe) == 0xc0)
598 kind = lm79;
599 else {
600 if (kind == 0)
601 dev_warn(&adapter->dev, "Ignoring 'force' "
602 "parameter for unknown chip at "
603 "adapter %d, address 0x%02x\n",
604 i2c_adapter_id(adapter), address);
0c6e9731 605 goto err_nodev;
1da177e4 606 }
18c73f90 607
0c6e9731 608 if (lm78_alias_detect(client, i)) {
18c73f90
JD		 609 dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
610 "be the same as ISA device\n", address);
0c6e9731 611 goto err_nodev;
18c73f90 612 }
1da177e4
LT		 613 }
614
0c6e9731
JD		 615 if (isa)
616 mutex_unlock(&isa->update_lock);
617
618 switch (kind) {
619 case lm79:
1da177e4 620 client_name = "lm79";
0c6e9731
JD		 621 break;
622 default:
623 client_name = "lm78";
1da177e4 624 }
0c6e9731 625 strlcpy(info->type, client_name, I2C_NAME_SIZE);
1da177e4 626
0c6e9731 627 return 0;
1da177e4 628
0c6e9731
JD		 629 err_nodev:
630 if (isa)
631 mutex_unlock(&isa->update_lock);
632 return -ENODEV;
633}
634
635static int lm78_i2c_probe(struct i2c_client *client,
636 const struct i2c_device_id *id)
637{
638 struct lm78_data *data;
639 int err;
640
641 data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL);
642 if (!data)
643 return -ENOMEM;
644
645 i2c_set_clientdata(client, data);
646 data->client = client;
647 data->type = id->driver_data;
1da177e4
LT		 648
649 /* Initialize the LM78 chip */
c59cc301 650 lm78_init_device(data);
1da177e4 651
1da177e4 652 /* Register sysfs hooks */
0c6e9731
JD		 653 err = sysfs_create_group(&client->dev.kobj, &lm78_group);
654 if (err)
c1685f61
MH		 655 goto ERROR3;
656
0c6e9731 657 data->hwmon_dev = hwmon_device_register(&client->dev);
1beeffe4
TJ		 658 if (IS_ERR(data->hwmon_dev)) {
659 err = PTR_ERR(data->hwmon_dev);
c1685f61 660 goto ERROR4;
943b0830
MH		 661 }
662
1da177e4
LT		 663 return 0;
664
c1685f61 665ERROR4:
0c6e9731 666 sysfs_remove_group(&client->dev.kobj, &lm78_group);
943b0830 667ERROR3:
1da177e4 668 kfree(data);
1da177e4
LT		 669 return err;
670}
671
0c6e9731 672static int lm78_i2c_remove(struct i2c_client *client)
1da177e4 673{
943b0830 674 struct lm78_data *data = i2c_get_clientdata(client);
1da177e4 675
1beeffe4 676 hwmon_device_unregister(data->hwmon_dev);
c1685f61 677 sysfs_remove_group(&client->dev.kobj, &lm78_group);
c40769fe
JD		 678 kfree(data);
679
680 return 0;
681}
682
683static int __devinit lm78_isa_probe(struct platform_device *pdev)
684{
685 int err;
686 struct lm78_data *data;
687 struct resource *res;
c40769fe
JD		 688
689 /* Reserve the ISA region */
690 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
47c15532 691 if (!request_region(res->start + LM78_ADDR_REG_OFFSET, 2, "lm78")) {
c40769fe
JD		 692 err = -EBUSY;
693 goto exit;
694 }
695
696 if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
697 err = -ENOMEM;
698 goto exit_release_region;
699 }
700 mutex_init(&data->lock);
6e1b5029 701 data->isa_addr = res->start;
c40769fe
JD		 702 platform_set_drvdata(pdev, data);
703
c59cc301 704 if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
c40769fe 705 data->type = lm79;
6e1b5029 706 data->name = "lm79";
c40769fe
JD		 707 } else {
708 data->type = lm78;
6e1b5029 709 data->name = "lm78";
c40769fe 710 }
c40769fe
JD		 711
712 /* Initialize the LM78 chip */
c59cc301 713 lm78_init_device(data);
c40769fe
JD		 714
715 /* Register sysfs hooks */
716 if ((err = sysfs_create_group(&pdev->dev.kobj, &lm78_group))
717 || (err = device_create_file(&pdev->dev, &dev_attr_name)))
718 goto exit_remove_files;
719
1beeffe4
TJ		 720 data->hwmon_dev = hwmon_device_register(&pdev->dev);
721 if (IS_ERR(data->hwmon_dev)) {
722 err = PTR_ERR(data->hwmon_dev);
c40769fe
JD		 723 goto exit_remove_files;
724 }
725
726 return 0;
727
728 exit_remove_files:
729 sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
730 device_remove_file(&pdev->dev, &dev_attr_name);
731 kfree(data);
732 exit_release_region:
47c15532 733 release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
c40769fe
JD		 734 exit:
735 return err;
736}
737
738static int __devexit lm78_isa_remove(struct platform_device *pdev)
739{
740 struct lm78_data *data = platform_get_drvdata(pdev);
6e1b5029 741 struct resource *res;
1da177e4 742
1beeffe4 743 hwmon_device_unregister(data->hwmon_dev);
c40769fe
JD		 744 sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
745 device_remove_file(&pdev->dev, &dev_attr_name);
943b0830 746 kfree(data);
1da177e4 747
6e1b5029
JD		 748 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
749 release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
750
1da177e4
LT		 751 return 0;
752}
753
44bbe87e 754/* The SMBus locks itself, but ISA access must be locked explicitly!
1da177e4
LT		 755 We don't want to lock the whole ISA bus, so we lock each client
756 separately.
757 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
758 would slow down the LM78 access and should not be necessary. */
c59cc301 759static int lm78_read_value(struct lm78_data *data, u8 reg)
1da177e4 760{
0c6e9731 761 struct i2c_client *client = data->client;
c59cc301 762
0c6e9731 763 if (!client) { /* ISA device */
c59cc301 764 int res;
9a61bf63 765 mutex_lock(&data->lock);
6e1b5029
JD		 766 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
767 res = inb_p(data->isa_addr + LM78_DATA_REG_OFFSET);
9a61bf63 768 mutex_unlock(&data->lock);
1da177e4
LT		 769 return res;
770 } else
771 return i2c_smbus_read_byte_data(client, reg);
772}
773
44bbe87e 774/* The SMBus locks itself, but ISA access muse be locked explicitly!
1da177e4
LT		 775 We don't want to lock the whole ISA bus, so we lock each client
776 separately.
777 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
778 would slow down the LM78 access and should not be necessary.
779 There are some ugly typecasts here, but the good new is - they should
780 nowhere else be necessary! */
c59cc301 781static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
1da177e4 782{
0c6e9731 783 struct i2c_client *client = data->client;
c59cc301 784
0c6e9731 785 if (!client) { /* ISA device */
9a61bf63 786 mutex_lock(&data->lock);
6e1b5029
JD		 787 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
788 outb_p(value, data->isa_addr + LM78_DATA_REG_OFFSET);
9a61bf63 789 mutex_unlock(&data->lock);
1da177e4
LT		 790 return 0;
791 } else
792 return i2c_smbus_write_byte_data(client, reg, value);
793}
794
c59cc301 795static void lm78_init_device(struct lm78_data *data)
1da177e4 796{
c40769fe
JD		 797 u8 config;
798 int i;
1da177e4
LT		 799
800 /* Start monitoring */
c59cc301 801 config = lm78_read_value(data, LM78_REG_CONFIG);
c40769fe 802 if ((config & 0x09) != 0x01)
c59cc301 803 lm78_write_value(data, LM78_REG_CONFIG,
1da177e4 804 (config & 0xf7) | 0x01);
c40769fe
JD		 805
806 /* A few vars need to be filled upon startup */
807 for (i = 0; i < 3; i++) {
c59cc301 808 data->fan_min[i] = lm78_read_value(data,
c40769fe
JD		 809 LM78_REG_FAN_MIN(i));
810 }
811
812 mutex_init(&data->update_lock);
1da177e4
LT		 813}
814
815static struct lm78_data *lm78_update_device(struct device *dev)
816{
c40769fe 817 struct lm78_data *data = dev_get_drvdata(dev);
1da177e4
LT		 818 int i;
819
9a61bf63 820 mutex_lock(&data->update_lock);
1da177e4
LT		 821
822 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
823 || !data->valid) {
824
c40769fe 825 dev_dbg(dev, "Starting lm78 update\n");
1da177e4
LT		 826
827 for (i = 0; i <= 6; i++) {
828 data->in[i] =
c59cc301 829 lm78_read_value(data, LM78_REG_IN(i));
1da177e4 830 data->in_min[i] =
c59cc301 831 lm78_read_value(data, LM78_REG_IN_MIN(i));
1da177e4 832 data->in_max[i] =
c59cc301 833 lm78_read_value(data, LM78_REG_IN_MAX(i));
1da177e4
LT		 834 }
835 for (i = 0; i < 3; i++) {
836 data->fan[i] =
c59cc301 837 lm78_read_value(data, LM78_REG_FAN(i));
1da177e4 838 data->fan_min[i] =
c59cc301 839 lm78_read_value(data, LM78_REG_FAN_MIN(i));
1da177e4 840 }
c59cc301 841 data->temp = lm78_read_value(data, LM78_REG_TEMP);
1da177e4 842 data->temp_over =
c59cc301 843 lm78_read_value(data, LM78_REG_TEMP_OVER);
1da177e4 844 data->temp_hyst =
c59cc301
JD		 845 lm78_read_value(data, LM78_REG_TEMP_HYST);
846 i = lm78_read_value(data, LM78_REG_VID_FANDIV);
1da177e4
LT		 847 data->vid = i & 0x0f;
848 if (data->type == lm79)
849 data->vid |=
c59cc301 850 (lm78_read_value(data, LM78_REG_CHIPID) &
1da177e4
LT		 851 0x01) << 4;
852 else
853 data->vid |= 0x10;
854 data->fan_div[0] = (i >> 4) & 0x03;
855 data->fan_div[1] = i >> 6;
c59cc301
JD		 856 data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +
857 (lm78_read_value(data, LM78_REG_ALARM2) << 8);
1da177e4
LT		 858 data->last_updated = jiffies;
859 data->valid = 1;
860
861 data->fan_div[2] = 1;
862 }
863
9a61bf63 864 mutex_unlock(&data->update_lock);
1da177e4
LT		 865
866 return data;
867}
868
c40769fe
JD		 869/* return 1 if a supported chip is found, 0 otherwise */
870static int __init lm78_isa_found(unsigned short address)
871{
872 int val, save, found = 0;
873
47c15532
JD		 874 /* We have to request the region in two parts because some
875 boards declare base+4 to base+7 as a PNP device */
876 if (!request_region(address, 4, "lm78")) {
877 pr_debug("lm78: Failed to request low part of region\n");
c40769fe 878 return 0;
47c15532
JD		 879 }
880 if (!request_region(address + 4, 4, "lm78")) {
881 pr_debug("lm78: Failed to request high part of region\n");
882 release_region(address, 4);
883 return 0;
884 }
c40769fe
JD		 885
886#define REALLY_SLOW_IO
887 /* We need the timeouts for at least some LM78-like
888 chips. But only if we read 'undefined' registers. */
889 val = inb_p(address + 1);
890 if (inb_p(address + 2) != val
891 || inb_p(address + 3) != val
892 || inb_p(address + 7) != val)
893 goto release;
894#undef REALLY_SLOW_IO
895
896 /* We should be able to change the 7 LSB of the address port. The
897 MSB (busy flag) should be clear initially, set after the write. */
898 save = inb_p(address + LM78_ADDR_REG_OFFSET);
899 if (save & 0x80)
900 goto release;
901 val = ~save & 0x7f;
902 outb_p(val, address + LM78_ADDR_REG_OFFSET);
903 if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
904 outb_p(save, address + LM78_ADDR_REG_OFFSET);
905 goto release;
906 }
907
908 /* We found a device, now see if it could be an LM78 */
909 outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET);
910 val = inb_p(address + LM78_DATA_REG_OFFSET);
911 if (val & 0x80)
912 goto release;
913 outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET);
914 val = inb_p(address + LM78_DATA_REG_OFFSET);
915 if (val < 0x03 || val > 0x77) /* Not a valid I2C address */
916 goto release;
917
918 /* The busy flag should be clear again */
919 if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)
920 goto release;
921
922 /* Explicitly prevent the misdetection of Winbond chips */
923 outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);
924 val = inb_p(address + LM78_DATA_REG_OFFSET);
925 if (val == 0xa3 || val == 0x5c)
926 goto release;
927
928 /* Explicitly prevent the misdetection of ITE chips */
929 outb_p(0x58, address + LM78_ADDR_REG_OFFSET);
930 val = inb_p(address + LM78_DATA_REG_OFFSET);
931 if (val == 0x90)
932 goto release;
933
934 /* Determine the chip type */
935 outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET);
936 val = inb_p(address + LM78_DATA_REG_OFFSET);
acf346a3 937 if (val == 0x00 || val == 0x20 /* LM78 */
c40769fe
JD		 938 || val == 0x40 /* LM78-J */
939 || (val & 0xfe) == 0xc0) /* LM79 */
940 found = 1;
941
942 if (found)
943 pr_info("lm78: Found an %s chip at %#x\n",
944 val & 0x80 ? "LM79" : "LM78", (int)address);
945
946 release:
47c15532
JD		 947 release_region(address + 4, 4);
948 release_region(address, 4);
c40769fe
JD		 949 return found;
950}
951
952static int __init lm78_isa_device_add(unsigned short address)
953{
954 struct resource res = {
955 .start = address,
15bde2f1 956 .end = address + LM78_EXTENT - 1,
c40769fe
JD		 957 .name = "lm78",
958 .flags = IORESOURCE_IO,
959 };
960 int err;
961
962 pdev = platform_device_alloc("lm78", address);
963 if (!pdev) {
964 err = -ENOMEM;
965 printk(KERN_ERR "lm78: Device allocation failed\n");
966 goto exit;
967 }
968
969 err = platform_device_add_resources(pdev, &res, 1);
970 if (err) {
971 printk(KERN_ERR "lm78: Device resource addition failed "
972 "(%d)\n", err);
973 goto exit_device_put;
974 }
975
976 err = platform_device_add(pdev);
977 if (err) {
978 printk(KERN_ERR "lm78: Device addition failed (%d)\n",
979 err);
980 goto exit_device_put;
981 }
982
983 return 0;
984
985 exit_device_put:
986 platform_device_put(pdev);
987 exit:
988 pdev = NULL;
989 return err;
990}
991
1da177e4
LT		 992static int __init sm_lm78_init(void)
993{
fde09509
JD		 994 int res;
995
18c73f90
JD		 996 /* We register the ISA device first, so that we can skip the
997 * registration of an I2C interface to the same device. */
c40769fe
JD		 998 if (lm78_isa_found(isa_address)) {
999 res = platform_driver_register(&lm78_isa_driver);
1000 if (res)
18c73f90 1001 goto exit;
fde09509 1002
c40769fe
JD		 1003 /* Sets global pdev as a side effect */
1004 res = lm78_isa_device_add(isa_address);
1005 if (res)
1006 goto exit_unreg_isa_driver;
1007 }
fde09509 1008
18c73f90
JD		 1009 res = i2c_add_driver(&lm78_driver);
1010 if (res)
1011 goto exit_unreg_isa_device;
1012
fde09509 1013 return 0;
c40769fe 1014
18c73f90
JD		 1015 exit_unreg_isa_device:
1016 platform_device_unregister(pdev);
c40769fe
JD		 1017 exit_unreg_isa_driver:
1018 platform_driver_unregister(&lm78_isa_driver);
c40769fe
JD		 1019 exit:
1020 return res;
1da177e4
LT		 1021}
1022
1023static void __exit sm_lm78_exit(void)
1024{
c40769fe
JD		 1025 if (pdev) {
1026 platform_device_unregister(pdev);
1027 platform_driver_unregister(&lm78_isa_driver);
1028 }
1da177e4
LT		 1029 i2c_del_driver(&lm78_driver);
1030}
1031
1032
1033
1034MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
27fe048e 1035MODULE_DESCRIPTION("LM78/LM79 driver");
1da177e4
LT		 1036MODULE_LICENSE("GPL");
1037
1038module_init(sm_lm78_init);
1039module_exit(sm_lm78_exit);
Linux 6.x block layer and io_uring tree(s)