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