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