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 char valid; /* !=0 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 strlcpy(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 const struct i2c_device_id *id)
632{
633 struct device *dev = &client->dev;
634 struct device *hwmon_dev;
635 struct lm78_data *data;
636
637 data = devm_kzalloc(dev, sizeof(struct lm78_data), GFP_KERNEL);
638 if (!data)
639 return -ENOMEM;
640
641 data->client = client;
642 data->type = id->driver_data;
643
644 /* Initialize the LM78 chip */
645 lm78_init_device(data);
646
647 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
648 data, lm78_groups);
649 return PTR_ERR_OR_ZERO(hwmon_dev);
650}
651
652static const struct i2c_device_id lm78_i2c_id[] = {
653 { "lm78", lm78 },
654 { "lm79", lm79 },
655 { }
656};
657MODULE_DEVICE_TABLE(i2c, lm78_i2c_id);
658
659static struct i2c_driver lm78_driver = {
660 .class = I2C_CLASS_HWMON,
661 .driver = {
662 .name = "lm78",
663 },
664 .probe = lm78_i2c_probe,
665 .id_table = lm78_i2c_id,
666 .detect = lm78_i2c_detect,
667 .address_list = normal_i2c,
668};
669
670/*
671 * The SMBus locks itself, but ISA access must be locked explicitly!
672 * We don't want to lock the whole ISA bus, so we lock each client
673 * separately.
674 * We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
675 * would slow down the LM78 access and should not be necessary.
676 */
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
694static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
695{
696 struct i2c_client *client = data->client;
697
698#ifdef CONFIG_ISA
699 if (!client) { /* ISA device */
700 mutex_lock(&data->lock);
701 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
702 outb_p(value, data->isa_addr + LM78_DATA_REG_OFFSET);
703 mutex_unlock(&data->lock);
704 return 0;
705 } else
706#endif
707 return i2c_smbus_write_byte_data(client, reg, value);
708}
709
710static void lm78_init_device(struct lm78_data *data)
711{
712 u8 config;
713 int i;
714
715 /* Start monitoring */
716 config = lm78_read_value(data, LM78_REG_CONFIG);
717 if ((config & 0x09) != 0x01)
718 lm78_write_value(data, LM78_REG_CONFIG,
719 (config & 0xf7) | 0x01);
720
721 /* A few vars need to be filled upon startup */
722 for (i = 0; i < 3; i++) {
723 data->fan_min[i] = lm78_read_value(data,
724 LM78_REG_FAN_MIN(i));
725 }
726
727 mutex_init(&data->update_lock);
728}
729
730static struct lm78_data *lm78_update_device(struct device *dev)
731{
732 struct lm78_data *data = dev_get_drvdata(dev);
733 int i;
734
735 mutex_lock(&data->update_lock);
736
737 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
738 || !data->valid) {
739
740 dev_dbg(dev, "Starting lm78 update\n");
741
742 for (i = 0; i <= 6; i++) {
743 data->in[i] =
744 lm78_read_value(data, LM78_REG_IN(i));
745 data->in_min[i] =
746 lm78_read_value(data, LM78_REG_IN_MIN(i));
747 data->in_max[i] =
748 lm78_read_value(data, LM78_REG_IN_MAX(i));
749 }
750 for (i = 0; i < 3; i++) {
751 data->fan[i] =
752 lm78_read_value(data, LM78_REG_FAN(i));
753 data->fan_min[i] =
754 lm78_read_value(data, LM78_REG_FAN_MIN(i));
755 }
756 data->temp = lm78_read_value(data, LM78_REG_TEMP);
757 data->temp_over =
758 lm78_read_value(data, LM78_REG_TEMP_OVER);
759 data->temp_hyst =
760 lm78_read_value(data, LM78_REG_TEMP_HYST);
761 i = lm78_read_value(data, LM78_REG_VID_FANDIV);
762 data->vid = i & 0x0f;
763 if (data->type == lm79)
764 data->vid |=
765 (lm78_read_value(data, LM78_REG_CHIPID) &
766 0x01) << 4;
767 else
768 data->vid |= 0x10;
769 data->fan_div[0] = (i >> 4) & 0x03;
770 data->fan_div[1] = i >> 6;
771 data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +
772 (lm78_read_value(data, LM78_REG_ALARM2) << 8);
773 data->last_updated = jiffies;
774 data->valid = 1;
775
776 data->fan_div[2] = 1;
777 }
778
779 mutex_unlock(&data->update_lock);
780
781 return data;
782}
783
784#ifdef CONFIG_ISA
785static int lm78_isa_probe(struct platform_device *pdev)
786{
787 struct device *dev = &pdev->dev;
788 struct device *hwmon_dev;
789 struct lm78_data *data;
790 struct resource *res;
791
792 /* Reserve the ISA region */
793 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
794 if (!devm_request_region(dev, res->start + LM78_ADDR_REG_OFFSET,
795 2, "lm78"))
796 return -EBUSY;
797
798 data = devm_kzalloc(dev, sizeof(struct lm78_data), GFP_KERNEL);
799 if (!data)
800 return -ENOMEM;
801
802 mutex_init(&data->lock);
803 data->isa_addr = res->start;
804 platform_set_drvdata(pdev, data);
805
806 if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
807 data->type = lm79;
808 data->name = "lm79";
809 } else {
810 data->type = lm78;
811 data->name = "lm78";
812 }
813
814 /* Initialize the LM78 chip */
815 lm78_init_device(data);
816
817 hwmon_dev = devm_hwmon_device_register_with_groups(dev, data->name,
818 data, lm78_groups);
819 return PTR_ERR_OR_ZERO(hwmon_dev);
820}
821
822static struct platform_driver lm78_isa_driver = {
823 .driver = {
824 .name = "lm78",
825 },
826 .probe = lm78_isa_probe,
827};
828
829/* return 1 if a supported chip is found, 0 otherwise */
830static int __init lm78_isa_found(unsigned short address)
831{
832 int val, save, found = 0;
833 int port;
834
835 /*
836 * Some boards declare base+0 to base+7 as a PNP device, some base+4
837 * to base+7 and some base+5 to base+6. So we better request each port
838 * individually for the probing phase.
839 */
840 for (port = address; port < address + LM78_EXTENT; port++) {
841 if (!request_region(port, 1, "lm78")) {
842 pr_debug("Failed to request port 0x%x\n", port);
843 goto release;
844 }
845 }
846
847#define REALLY_SLOW_IO
848 /*
849 * We need the timeouts for at least some LM78-like
850 * chips. But only if we read 'undefined' registers.
851 */
852 val = inb_p(address + 1);
853 if (inb_p(address + 2) != val
854 || inb_p(address + 3) != val
855 || inb_p(address + 7) != val)
856 goto release;
857#undef REALLY_SLOW_IO
858
859 /*
860 * We should be able to change the 7 LSB of the address port. The
861 * MSB (busy flag) should be clear initially, set after the write.
862 */
863 save = inb_p(address + LM78_ADDR_REG_OFFSET);
864 if (save & 0x80)
865 goto release;
866 val = ~save & 0x7f;
867 outb_p(val, address + LM78_ADDR_REG_OFFSET);
868 if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
869 outb_p(save, address + LM78_ADDR_REG_OFFSET);
870 goto release;
871 }
872
873 /* We found a device, now see if it could be an LM78 */
874 outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET);
875 val = inb_p(address + LM78_DATA_REG_OFFSET);
876 if (val & 0x80)
877 goto release;
878 outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET);
879 val = inb_p(address + LM78_DATA_REG_OFFSET);
880 if (val < 0x03 || val > 0x77) /* Not a valid I2C address */
881 goto release;
882
883 /* The busy flag should be clear again */
884 if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)
885 goto release;
886
887 /* Explicitly prevent the misdetection of Winbond chips */
888 outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);
889 val = inb_p(address + LM78_DATA_REG_OFFSET);
890 if (val == 0xa3 || val == 0x5c)
891 goto release;
892
893 /* Explicitly prevent the misdetection of ITE chips */
894 outb_p(0x58, address + LM78_ADDR_REG_OFFSET);
895 val = inb_p(address + LM78_DATA_REG_OFFSET);
896 if (val == 0x90)
897 goto release;
898
899 /* Determine the chip type */
900 outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET);
901 val = inb_p(address + LM78_DATA_REG_OFFSET);
902 if (val == 0x00 || val == 0x20 /* LM78 */
903 || val == 0x40 /* LM78-J */
904 || (val & 0xfe) == 0xc0) /* LM79 */
905 found = 1;
906
907 if (found)
908 pr_info("Found an %s chip at %#x\n",
909 val & 0x80 ? "LM79" : "LM78", (int)address);
910
911 release:
912 for (port--; port >= address; port--)
913 release_region(port, 1);
914 return found;
915}
916
917static int __init lm78_isa_device_add(unsigned short address)
918{
919 struct resource res = {
920 .start = address,
921 .end = address + LM78_EXTENT - 1,
922 .name = "lm78",
923 .flags = IORESOURCE_IO,
924 };
925 int err;
926
927 pdev = platform_device_alloc("lm78", address);
928 if (!pdev) {
929 err = -ENOMEM;
930 pr_err("Device allocation failed\n");
931 goto exit;
932 }
933
934 err = platform_device_add_resources(pdev, &res, 1);
935 if (err) {
936 pr_err("Device resource addition failed (%d)\n", err);
937 goto exit_device_put;
938 }
939
940 err = platform_device_add(pdev);
941 if (err) {
942 pr_err("Device addition failed (%d)\n", err);
943 goto exit_device_put;
944 }
945
946 return 0;
947
948 exit_device_put:
949 platform_device_put(pdev);
950 exit:
951 pdev = NULL;
952 return err;
953}
954
955static int __init lm78_isa_register(void)
956{
957 int res;
958
959 if (lm78_isa_found(isa_address)) {
960 res = platform_driver_register(&lm78_isa_driver);
961 if (res)
962 goto exit;
963
964 /* Sets global pdev as a side effect */
965 res = lm78_isa_device_add(isa_address);
966 if (res)
967 goto exit_unreg_isa_driver;
968 }
969
970 return 0;
971
972 exit_unreg_isa_driver:
973 platform_driver_unregister(&lm78_isa_driver);
974 exit:
975 return res;
976}
977
978static void lm78_isa_unregister(void)
979{
980 if (pdev) {
981 platform_device_unregister(pdev);
982 platform_driver_unregister(&lm78_isa_driver);
983 }
984}
985#else /* !CONFIG_ISA */
986
987static int __init lm78_isa_register(void)
988{
989 return 0;
990}
991
992static void lm78_isa_unregister(void)
993{
994}
995#endif /* CONFIG_ISA */
996
997static int __init sm_lm78_init(void)
998{
999 int res;
1000
1001 /*
1002 * We register the ISA device first, so that we can skip the
1003 * registration of an I2C interface to the same device.
1004 */
1005 res = lm78_isa_register();
1006 if (res)
1007 goto exit;
1008
1009 res = i2c_add_driver(&lm78_driver);
1010 if (res)
1011 goto exit_unreg_isa_device;
1012
1013 return 0;
1014
1015 exit_unreg_isa_device:
1016 lm78_isa_unregister();
1017 exit:
1018 return res;
1019}
1020
1021static void __exit sm_lm78_exit(void)
1022{
1023 lm78_isa_unregister();
1024 i2c_del_driver(&lm78_driver);
1025}
1026
1027MODULE_AUTHOR("Frodo Looijaard, Jean Delvare <jdelvare@suse.de>");
1028MODULE_DESCRIPTION("LM78/LM79 driver");
1029MODULE_LICENSE("GPL");
1030
1031module_init(sm_lm78_init);
1032module_exit(sm_lm78_exit);