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