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