xref: /linux/drivers/hwmon/lm78.c (revision 14b42963f64b98ab61fa9723c03d71aa5ef4f862)
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 
6     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10 
11     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15 
16     You should have received a copy of the GNU General Public License
17     along with this program; if not, write to the Free Software
18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20 
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/jiffies.h>
25 #include <linux/i2c.h>
26 #include <linux/i2c-isa.h>
27 #include <linux/hwmon.h>
28 #include <linux/hwmon-vid.h>
29 #include <linux/err.h>
30 #include <linux/mutex.h>
31 #include <asm/io.h>
32 
33 /* Addresses to scan */
34 static unsigned short normal_i2c[] = { 0x20, 0x21, 0x22, 0x23, 0x24,
35 					0x25, 0x26, 0x27, 0x28, 0x29,
36 					0x2a, 0x2b, 0x2c, 0x2d, 0x2e,
37 					0x2f, I2C_CLIENT_END };
38 static unsigned short isa_address = 0x290;
39 
40 /* Insmod parameters */
41 I2C_CLIENT_INSMOD_2(lm78, lm79);
42 
43 /* Many LM78 constants specified below */
44 
45 /* Length of ISA address segment */
46 #define LM78_EXTENT 8
47 
48 /* Where are the ISA address/data registers relative to the base address */
49 #define LM78_ADDR_REG_OFFSET 5
50 #define LM78_DATA_REG_OFFSET 6
51 
52 /* The LM78 registers */
53 #define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)
54 #define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)
55 #define LM78_REG_IN(nr) (0x20 + (nr))
56 
57 #define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
58 #define LM78_REG_FAN(nr) (0x28 + (nr))
59 
60 #define LM78_REG_TEMP 0x27
61 #define LM78_REG_TEMP_OVER 0x39
62 #define LM78_REG_TEMP_HYST 0x3a
63 
64 #define LM78_REG_ALARM1 0x41
65 #define LM78_REG_ALARM2 0x42
66 
67 #define LM78_REG_VID_FANDIV 0x47
68 
69 #define LM78_REG_CONFIG 0x40
70 #define LM78_REG_CHIPID 0x49
71 #define LM78_REG_I2C_ADDR 0x48
72 
73 
74 /* Conversions. Rounding and limit checking is only done on the TO_REG
75    variants. */
76 
77 /* IN: mV, (0V to 4.08V)
78    REG: 16mV/bit */
79 static inline u8 IN_TO_REG(unsigned long val)
80 {
81 	unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
82 	return (nval + 8) / 16;
83 }
84 #define IN_FROM_REG(val) ((val) *  16)
85 
86 static inline u8 FAN_TO_REG(long rpm, int div)
87 {
88 	if (rpm <= 0)
89 		return 255;
90 	return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
91 }
92 
93 static inline int FAN_FROM_REG(u8 val, int div)
94 {
95 	return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div);
96 }
97 
98 /* TEMP: mC (-128C to +127C)
99    REG: 1C/bit, two's complement */
100 static inline s8 TEMP_TO_REG(int val)
101 {
102 	int nval = SENSORS_LIMIT(val, -128000, 127000) ;
103 	return nval<0 ? (nval-500)/1000 : (nval+500)/1000;
104 }
105 
106 static inline int TEMP_FROM_REG(s8 val)
107 {
108 	return val * 1000;
109 }
110 
111 #define DIV_FROM_REG(val) (1 << (val))
112 
113 /* There are some complications in a module like this. First off, LM78 chips
114    may be both present on the SMBus and the ISA bus, and we have to handle
115    those cases separately at some places. Second, there might be several
116    LM78 chips available (well, actually, that is probably never done; but
117    it is a clean illustration of how to handle a case like that). Finally,
118    a specific chip may be attached to *both* ISA and SMBus, and we would
119    not like to detect it double. Fortunately, in the case of the LM78 at
120    least, a register tells us what SMBus address we are on, so that helps
121    a bit - except if there could be more than one SMBus. Groan. No solution
122    for this yet. */
123 
124 /* This module may seem overly long and complicated. In fact, it is not so
125    bad. Quite a lot of bookkeeping is done. A real driver can often cut
126    some corners. */
127 
128 /* For each registered LM78, we need to keep some data in memory. That
129    data is pointed to by lm78_list[NR]->data. The structure itself is
130    dynamically allocated, at the same time when a new lm78 client is
131    allocated. */
132 struct lm78_data {
133 	struct i2c_client client;
134 	struct class_device *class_dev;
135 	struct mutex lock;
136 	enum chips type;
137 
138 	struct mutex update_lock;
139 	char valid;		/* !=0 if following fields are valid */
140 	unsigned long last_updated;	/* In jiffies */
141 
142 	u8 in[7];		/* Register value */
143 	u8 in_max[7];		/* Register value */
144 	u8 in_min[7];		/* Register value */
145 	u8 fan[3];		/* Register value */
146 	u8 fan_min[3];		/* Register value */
147 	s8 temp;		/* Register value */
148 	s8 temp_over;		/* Register value */
149 	s8 temp_hyst;		/* Register value */
150 	u8 fan_div[3];		/* Register encoding, shifted right */
151 	u8 vid;			/* Register encoding, combined */
152 	u16 alarms;		/* Register encoding, combined */
153 };
154 
155 
156 static int lm78_attach_adapter(struct i2c_adapter *adapter);
157 static int lm78_isa_attach_adapter(struct i2c_adapter *adapter);
158 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind);
159 static int lm78_detach_client(struct i2c_client *client);
160 
161 static int lm78_read_value(struct i2c_client *client, u8 reg);
162 static int lm78_write_value(struct i2c_client *client, u8 reg, u8 value);
163 static struct lm78_data *lm78_update_device(struct device *dev);
164 static void lm78_init_client(struct i2c_client *client);
165 
166 
167 static struct i2c_driver lm78_driver = {
168 	.driver = {
169 		.name	= "lm78",
170 	},
171 	.id		= I2C_DRIVERID_LM78,
172 	.attach_adapter	= lm78_attach_adapter,
173 	.detach_client	= lm78_detach_client,
174 };
175 
176 static struct i2c_driver lm78_isa_driver = {
177 	.driver = {
178 		.name	= "lm78-isa",
179 	},
180 	.attach_adapter	= lm78_isa_attach_adapter,
181 	.detach_client	= lm78_detach_client,
182 };
183 
184 
185 /* 7 Voltages */
186 static ssize_t show_in(struct device *dev, char *buf, int nr)
187 {
188 	struct lm78_data *data = lm78_update_device(dev);
189 	return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
190 }
191 
192 static ssize_t show_in_min(struct device *dev, char *buf, int nr)
193 {
194 	struct lm78_data *data = lm78_update_device(dev);
195 	return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
196 }
197 
198 static ssize_t show_in_max(struct device *dev, char *buf, int nr)
199 {
200 	struct lm78_data *data = lm78_update_device(dev);
201 	return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
202 }
203 
204 static ssize_t set_in_min(struct device *dev, const char *buf,
205 		size_t count, int nr)
206 {
207 	struct i2c_client *client = to_i2c_client(dev);
208 	struct lm78_data *data = i2c_get_clientdata(client);
209 	unsigned long val = simple_strtoul(buf, NULL, 10);
210 
211 	mutex_lock(&data->update_lock);
212 	data->in_min[nr] = IN_TO_REG(val);
213 	lm78_write_value(client, LM78_REG_IN_MIN(nr), data->in_min[nr]);
214 	mutex_unlock(&data->update_lock);
215 	return count;
216 }
217 
218 static ssize_t set_in_max(struct device *dev, const char *buf,
219 		size_t count, int nr)
220 {
221 	struct i2c_client *client = to_i2c_client(dev);
222 	struct lm78_data *data = i2c_get_clientdata(client);
223 	unsigned long val = simple_strtoul(buf, NULL, 10);
224 
225 	mutex_lock(&data->update_lock);
226 	data->in_max[nr] = IN_TO_REG(val);
227 	lm78_write_value(client, LM78_REG_IN_MAX(nr), data->in_max[nr]);
228 	mutex_unlock(&data->update_lock);
229 	return count;
230 }
231 
232 #define show_in_offset(offset)					\
233 static ssize_t							\
234 	show_in##offset (struct device *dev, struct device_attribute *attr, char *buf)		\
235 {								\
236 	return show_in(dev, buf, offset);			\
237 }								\
238 static DEVICE_ATTR(in##offset##_input, S_IRUGO, 		\
239 		show_in##offset, NULL);				\
240 static ssize_t							\
241 	show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)   \
242 {								\
243 	return show_in_min(dev, buf, offset);			\
244 }								\
245 static ssize_t							\
246 	show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf)   \
247 {								\
248 	return show_in_max(dev, buf, offset);			\
249 }								\
250 static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr,	\
251 		const char *buf, size_t count)			\
252 {								\
253 	return set_in_min(dev, buf, count, offset);		\
254 }								\
255 static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr,	\
256 		const char *buf, size_t count)			\
257 {								\
258 	return set_in_max(dev, buf, count, offset);		\
259 }								\
260 static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,		\
261 		show_in##offset##_min, set_in##offset##_min);	\
262 static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,		\
263 		show_in##offset##_max, set_in##offset##_max);
264 
265 show_in_offset(0);
266 show_in_offset(1);
267 show_in_offset(2);
268 show_in_offset(3);
269 show_in_offset(4);
270 show_in_offset(5);
271 show_in_offset(6);
272 
273 /* Temperature */
274 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf)
275 {
276 	struct lm78_data *data = lm78_update_device(dev);
277 	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
278 }
279 
280 static ssize_t show_temp_over(struct device *dev, struct device_attribute *attr, char *buf)
281 {
282 	struct lm78_data *data = lm78_update_device(dev);
283 	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
284 }
285 
286 static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
287 {
288 	struct i2c_client *client = to_i2c_client(dev);
289 	struct lm78_data *data = i2c_get_clientdata(client);
290 	long val = simple_strtol(buf, NULL, 10);
291 
292 	mutex_lock(&data->update_lock);
293 	data->temp_over = TEMP_TO_REG(val);
294 	lm78_write_value(client, LM78_REG_TEMP_OVER, data->temp_over);
295 	mutex_unlock(&data->update_lock);
296 	return count;
297 }
298 
299 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *attr, char *buf)
300 {
301 	struct lm78_data *data = lm78_update_device(dev);
302 	return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
303 }
304 
305 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
306 {
307 	struct i2c_client *client = to_i2c_client(dev);
308 	struct lm78_data *data = i2c_get_clientdata(client);
309 	long val = simple_strtol(buf, NULL, 10);
310 
311 	mutex_lock(&data->update_lock);
312 	data->temp_hyst = TEMP_TO_REG(val);
313 	lm78_write_value(client, LM78_REG_TEMP_HYST, data->temp_hyst);
314 	mutex_unlock(&data->update_lock);
315 	return count;
316 }
317 
318 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
319 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
320 		show_temp_over, set_temp_over);
321 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
322 		show_temp_hyst, set_temp_hyst);
323 
324 /* 3 Fans */
325 static ssize_t show_fan(struct device *dev, char *buf, int nr)
326 {
327 	struct lm78_data *data = lm78_update_device(dev);
328 	return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
329 		DIV_FROM_REG(data->fan_div[nr])) );
330 }
331 
332 static ssize_t show_fan_min(struct device *dev, char *buf, int nr)
333 {
334 	struct lm78_data *data = lm78_update_device(dev);
335 	return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr],
336 		DIV_FROM_REG(data->fan_div[nr])) );
337 }
338 
339 static ssize_t set_fan_min(struct device *dev, const char *buf,
340 		size_t count, int nr)
341 {
342 	struct i2c_client *client = to_i2c_client(dev);
343 	struct lm78_data *data = i2c_get_clientdata(client);
344 	unsigned long val = simple_strtoul(buf, NULL, 10);
345 
346 	mutex_lock(&data->update_lock);
347 	data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
348 	lm78_write_value(client, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
349 	mutex_unlock(&data->update_lock);
350 	return count;
351 }
352 
353 static ssize_t show_fan_div(struct device *dev, char *buf, int nr)
354 {
355 	struct lm78_data *data = lm78_update_device(dev);
356 	return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]) );
357 }
358 
359 /* Note: we save and restore the fan minimum here, because its value is
360    determined in part by the fan divisor.  This follows the principle of
361    least surprise; the user doesn't expect the fan minimum to change just
362    because the divisor changed. */
363 static ssize_t set_fan_div(struct device *dev, const char *buf,
364 	size_t count, int nr)
365 {
366 	struct i2c_client *client = to_i2c_client(dev);
367 	struct lm78_data *data = i2c_get_clientdata(client);
368 	unsigned long val = simple_strtoul(buf, NULL, 10);
369 	unsigned long min;
370 	u8 reg;
371 
372 	mutex_lock(&data->update_lock);
373 	min = FAN_FROM_REG(data->fan_min[nr],
374 			   DIV_FROM_REG(data->fan_div[nr]));
375 
376 	switch (val) {
377 	case 1: data->fan_div[nr] = 0; break;
378 	case 2: data->fan_div[nr] = 1; break;
379 	case 4: data->fan_div[nr] = 2; break;
380 	case 8: data->fan_div[nr] = 3; break;
381 	default:
382 		dev_err(&client->dev, "fan_div value %ld not "
383 			"supported. Choose one of 1, 2, 4 or 8!\n", val);
384 		mutex_unlock(&data->update_lock);
385 		return -EINVAL;
386 	}
387 
388 	reg = lm78_read_value(client, LM78_REG_VID_FANDIV);
389 	switch (nr) {
390 	case 0:
391 		reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
392 		break;
393 	case 1:
394 		reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
395 		break;
396 	}
397 	lm78_write_value(client, LM78_REG_VID_FANDIV, reg);
398 
399 	data->fan_min[nr] =
400 		FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
401 	lm78_write_value(client, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
402 	mutex_unlock(&data->update_lock);
403 
404 	return count;
405 }
406 
407 #define show_fan_offset(offset)						\
408 static ssize_t show_fan_##offset (struct device *dev, struct device_attribute *attr, char *buf)	\
409 {									\
410 	return show_fan(dev, buf, offset - 1);				\
411 }									\
412 static ssize_t show_fan_##offset##_min (struct device *dev, struct device_attribute *attr, char *buf)  \
413 {									\
414 	return show_fan_min(dev, buf, offset - 1);			\
415 }									\
416 static ssize_t show_fan_##offset##_div (struct device *dev, struct device_attribute *attr, char *buf)  \
417 {									\
418 	return show_fan_div(dev, buf, offset - 1);			\
419 }									\
420 static ssize_t set_fan_##offset##_min (struct device *dev, struct device_attribute *attr,		\
421 		const char *buf, size_t count)				\
422 {									\
423 	return set_fan_min(dev, buf, count, offset - 1);		\
424 }									\
425 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan_##offset, NULL);\
426 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,		\
427 		show_fan_##offset##_min, set_fan_##offset##_min);
428 
429 static ssize_t set_fan_1_div(struct device *dev, struct device_attribute *attr, const char *buf,
430 		size_t count)
431 {
432 	return set_fan_div(dev, buf, count, 0) ;
433 }
434 
435 static ssize_t set_fan_2_div(struct device *dev, struct device_attribute *attr, const char *buf,
436 		size_t count)
437 {
438 	return set_fan_div(dev, buf, count, 1) ;
439 }
440 
441 show_fan_offset(1);
442 show_fan_offset(2);
443 show_fan_offset(3);
444 
445 /* Fan 3 divisor is locked in H/W */
446 static DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
447 		show_fan_1_div, set_fan_1_div);
448 static DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
449 		show_fan_2_div, set_fan_2_div);
450 static DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_3_div, NULL);
451 
452 /* VID */
453 static ssize_t show_vid(struct device *dev, struct device_attribute *attr, char *buf)
454 {
455 	struct lm78_data *data = lm78_update_device(dev);
456 	return sprintf(buf, "%d\n", vid_from_reg(data->vid, 82));
457 }
458 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
459 
460 /* Alarms */
461 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
462 {
463 	struct lm78_data *data = lm78_update_device(dev);
464 	return sprintf(buf, "%u\n", data->alarms);
465 }
466 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
467 
468 /* This function is called when:
469      * lm78_driver is inserted (when this module is loaded), for each
470        available adapter
471      * when a new adapter is inserted (and lm78_driver is still present) */
472 static int lm78_attach_adapter(struct i2c_adapter *adapter)
473 {
474 	if (!(adapter->class & I2C_CLASS_HWMON))
475 		return 0;
476 	return i2c_probe(adapter, &addr_data, lm78_detect);
477 }
478 
479 static int lm78_isa_attach_adapter(struct i2c_adapter *adapter)
480 {
481 	return lm78_detect(adapter, isa_address, -1);
482 }
483 
484 /* This function is called by i2c_probe */
485 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind)
486 {
487 	int i, err;
488 	struct i2c_client *new_client;
489 	struct lm78_data *data;
490 	const char *client_name = "";
491 	int is_isa = i2c_is_isa_adapter(adapter);
492 
493 	if (!is_isa &&
494 	    !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
495 		err = -ENODEV;
496 		goto ERROR0;
497 	}
498 
499 	/* Reserve the ISA region */
500 	if (is_isa)
501 		if (!request_region(address, LM78_EXTENT,
502 				    lm78_isa_driver.driver.name)) {
503 			err = -EBUSY;
504 			goto ERROR0;
505 		}
506 
507 	/* Probe whether there is anything available on this address. Already
508 	   done for SMBus clients */
509 	if (kind < 0) {
510 		if (is_isa) {
511 
512 #define REALLY_SLOW_IO
513 			/* We need the timeouts for at least some LM78-like
514 			   chips. But only if we read 'undefined' registers. */
515 			i = inb_p(address + 1);
516 			if (inb_p(address + 2) != i) {
517 				err = -ENODEV;
518 				goto ERROR1;
519 			}
520 			if (inb_p(address + 3) != i) {
521 				err = -ENODEV;
522 				goto ERROR1;
523 			}
524 			if (inb_p(address + 7) != i) {
525 				err = -ENODEV;
526 				goto ERROR1;
527 			}
528 #undef REALLY_SLOW_IO
529 
530 			/* Let's just hope nothing breaks here */
531 			i = inb_p(address + 5) & 0x7f;
532 			outb_p(~i & 0x7f, address + 5);
533 			if ((inb_p(address + 5) & 0x7f) != (~i & 0x7f)) {
534 				outb_p(i, address + 5);
535 				err = -ENODEV;
536 				goto ERROR1;
537 			}
538 		}
539 	}
540 
541 	/* OK. For now, we presume we have a valid client. We now create the
542 	   client structure, even though we cannot fill it completely yet.
543 	   But it allows us to access lm78_{read,write}_value. */
544 
545 	if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
546 		err = -ENOMEM;
547 		goto ERROR1;
548 	}
549 
550 	new_client = &data->client;
551 	if (is_isa)
552 		mutex_init(&data->lock);
553 	i2c_set_clientdata(new_client, data);
554 	new_client->addr = address;
555 	new_client->adapter = adapter;
556 	new_client->driver = is_isa ? &lm78_isa_driver : &lm78_driver;
557 	new_client->flags = 0;
558 
559 	/* Now, we do the remaining detection. */
560 	if (kind < 0) {
561 		if (lm78_read_value(new_client, LM78_REG_CONFIG) & 0x80) {
562 			err = -ENODEV;
563 			goto ERROR2;
564 		}
565 		if (!is_isa && (lm78_read_value(
566 				new_client, LM78_REG_I2C_ADDR) != address)) {
567 			err = -ENODEV;
568 			goto ERROR2;
569 		}
570 	}
571 
572 	/* Determine the chip type. */
573 	if (kind <= 0) {
574 		i = lm78_read_value(new_client, LM78_REG_CHIPID);
575 		if (i == 0x00 || i == 0x20	/* LM78 */
576 		 || i == 0x40)			/* LM78-J */
577 			kind = lm78;
578 		else if ((i & 0xfe) == 0xc0)
579 			kind = lm79;
580 		else {
581 			if (kind == 0)
582 				dev_warn(&adapter->dev, "Ignoring 'force' "
583 					"parameter for unknown chip at "
584 					"adapter %d, address 0x%02x\n",
585 					i2c_adapter_id(adapter), address);
586 			err = -ENODEV;
587 			goto ERROR2;
588 		}
589 	}
590 
591 	if (kind == lm78) {
592 		client_name = "lm78";
593 	} else if (kind == lm79) {
594 		client_name = "lm79";
595 	}
596 
597 	/* Fill in the remaining client fields and put into the global list */
598 	strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
599 	data->type = kind;
600 
601 	data->valid = 0;
602 	mutex_init(&data->update_lock);
603 
604 	/* Tell the I2C layer a new client has arrived */
605 	if ((err = i2c_attach_client(new_client)))
606 		goto ERROR2;
607 
608 	/* Initialize the LM78 chip */
609 	lm78_init_client(new_client);
610 
611 	/* A few vars need to be filled upon startup */
612 	for (i = 0; i < 3; i++) {
613 		data->fan_min[i] = lm78_read_value(new_client,
614 					LM78_REG_FAN_MIN(i));
615 	}
616 
617 	/* Register sysfs hooks */
618 	data->class_dev = hwmon_device_register(&new_client->dev);
619 	if (IS_ERR(data->class_dev)) {
620 		err = PTR_ERR(data->class_dev);
621 		goto ERROR3;
622 	}
623 
624 	device_create_file(&new_client->dev, &dev_attr_in0_input);
625 	device_create_file(&new_client->dev, &dev_attr_in0_min);
626 	device_create_file(&new_client->dev, &dev_attr_in0_max);
627 	device_create_file(&new_client->dev, &dev_attr_in1_input);
628 	device_create_file(&new_client->dev, &dev_attr_in1_min);
629 	device_create_file(&new_client->dev, &dev_attr_in1_max);
630 	device_create_file(&new_client->dev, &dev_attr_in2_input);
631 	device_create_file(&new_client->dev, &dev_attr_in2_min);
632 	device_create_file(&new_client->dev, &dev_attr_in2_max);
633 	device_create_file(&new_client->dev, &dev_attr_in3_input);
634 	device_create_file(&new_client->dev, &dev_attr_in3_min);
635 	device_create_file(&new_client->dev, &dev_attr_in3_max);
636 	device_create_file(&new_client->dev, &dev_attr_in4_input);
637 	device_create_file(&new_client->dev, &dev_attr_in4_min);
638 	device_create_file(&new_client->dev, &dev_attr_in4_max);
639 	device_create_file(&new_client->dev, &dev_attr_in5_input);
640 	device_create_file(&new_client->dev, &dev_attr_in5_min);
641 	device_create_file(&new_client->dev, &dev_attr_in5_max);
642 	device_create_file(&new_client->dev, &dev_attr_in6_input);
643 	device_create_file(&new_client->dev, &dev_attr_in6_min);
644 	device_create_file(&new_client->dev, &dev_attr_in6_max);
645 	device_create_file(&new_client->dev, &dev_attr_temp1_input);
646 	device_create_file(&new_client->dev, &dev_attr_temp1_max);
647 	device_create_file(&new_client->dev, &dev_attr_temp1_max_hyst);
648 	device_create_file(&new_client->dev, &dev_attr_fan1_input);
649 	device_create_file(&new_client->dev, &dev_attr_fan1_min);
650 	device_create_file(&new_client->dev, &dev_attr_fan1_div);
651 	device_create_file(&new_client->dev, &dev_attr_fan2_input);
652 	device_create_file(&new_client->dev, &dev_attr_fan2_min);
653 	device_create_file(&new_client->dev, &dev_attr_fan2_div);
654 	device_create_file(&new_client->dev, &dev_attr_fan3_input);
655 	device_create_file(&new_client->dev, &dev_attr_fan3_min);
656 	device_create_file(&new_client->dev, &dev_attr_fan3_div);
657 	device_create_file(&new_client->dev, &dev_attr_alarms);
658 	device_create_file(&new_client->dev, &dev_attr_cpu0_vid);
659 
660 	return 0;
661 
662 ERROR3:
663 	i2c_detach_client(new_client);
664 ERROR2:
665 	kfree(data);
666 ERROR1:
667 	if (is_isa)
668 		release_region(address, LM78_EXTENT);
669 ERROR0:
670 	return err;
671 }
672 
673 static int lm78_detach_client(struct i2c_client *client)
674 {
675 	struct lm78_data *data = i2c_get_clientdata(client);
676 	int err;
677 
678 	hwmon_device_unregister(data->class_dev);
679 
680 	if ((err = i2c_detach_client(client)))
681 		return err;
682 
683 	if(i2c_is_isa_client(client))
684 		release_region(client->addr, LM78_EXTENT);
685 
686 	kfree(data);
687 
688 	return 0;
689 }
690 
691 /* The SMBus locks itself, but ISA access must be locked explicitly!
692    We don't want to lock the whole ISA bus, so we lock each client
693    separately.
694    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
695    would slow down the LM78 access and should not be necessary.  */
696 static int lm78_read_value(struct i2c_client *client, u8 reg)
697 {
698 	int res;
699 	if (i2c_is_isa_client(client)) {
700 		struct lm78_data *data = i2c_get_clientdata(client);
701 		mutex_lock(&data->lock);
702 		outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
703 		res = inb_p(client->addr + LM78_DATA_REG_OFFSET);
704 		mutex_unlock(&data->lock);
705 		return res;
706 	} else
707 		return i2c_smbus_read_byte_data(client, reg);
708 }
709 
710 /* The SMBus locks itself, but ISA access muse be locked explicitly!
711    We don't want to lock the whole ISA bus, so we lock each client
712    separately.
713    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
714    would slow down the LM78 access and should not be necessary.
715    There are some ugly typecasts here, but the good new is - they should
716    nowhere else be necessary! */
717 static int lm78_write_value(struct i2c_client *client, u8 reg, u8 value)
718 {
719 	if (i2c_is_isa_client(client)) {
720 		struct lm78_data *data = i2c_get_clientdata(client);
721 		mutex_lock(&data->lock);
722 		outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
723 		outb_p(value, client->addr + LM78_DATA_REG_OFFSET);
724 		mutex_unlock(&data->lock);
725 		return 0;
726 	} else
727 		return i2c_smbus_write_byte_data(client, reg, value);
728 }
729 
730 static void lm78_init_client(struct i2c_client *client)
731 {
732 	u8 config = lm78_read_value(client, LM78_REG_CONFIG);
733 
734 	/* Start monitoring */
735 	if (!(config & 0x01))
736 		lm78_write_value(client, LM78_REG_CONFIG,
737 				 (config & 0xf7) | 0x01);
738 }
739 
740 static struct lm78_data *lm78_update_device(struct device *dev)
741 {
742 	struct i2c_client *client = to_i2c_client(dev);
743 	struct lm78_data *data = i2c_get_clientdata(client);
744 	int i;
745 
746 	mutex_lock(&data->update_lock);
747 
748 	if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
749 	    || !data->valid) {
750 
751 		dev_dbg(&client->dev, "Starting lm78 update\n");
752 
753 		for (i = 0; i <= 6; i++) {
754 			data->in[i] =
755 			    lm78_read_value(client, LM78_REG_IN(i));
756 			data->in_min[i] =
757 			    lm78_read_value(client, LM78_REG_IN_MIN(i));
758 			data->in_max[i] =
759 			    lm78_read_value(client, LM78_REG_IN_MAX(i));
760 		}
761 		for (i = 0; i < 3; i++) {
762 			data->fan[i] =
763 			    lm78_read_value(client, LM78_REG_FAN(i));
764 			data->fan_min[i] =
765 			    lm78_read_value(client, LM78_REG_FAN_MIN(i));
766 		}
767 		data->temp = lm78_read_value(client, LM78_REG_TEMP);
768 		data->temp_over =
769 		    lm78_read_value(client, LM78_REG_TEMP_OVER);
770 		data->temp_hyst =
771 		    lm78_read_value(client, LM78_REG_TEMP_HYST);
772 		i = lm78_read_value(client, LM78_REG_VID_FANDIV);
773 		data->vid = i & 0x0f;
774 		if (data->type == lm79)
775 			data->vid |=
776 			    (lm78_read_value(client, LM78_REG_CHIPID) &
777 			     0x01) << 4;
778 		else
779 			data->vid |= 0x10;
780 		data->fan_div[0] = (i >> 4) & 0x03;
781 		data->fan_div[1] = i >> 6;
782 		data->alarms = lm78_read_value(client, LM78_REG_ALARM1) +
783 		    (lm78_read_value(client, LM78_REG_ALARM2) << 8);
784 		data->last_updated = jiffies;
785 		data->valid = 1;
786 
787 		data->fan_div[2] = 1;
788 	}
789 
790 	mutex_unlock(&data->update_lock);
791 
792 	return data;
793 }
794 
795 static int __init sm_lm78_init(void)
796 {
797 	int res;
798 
799 	res = i2c_add_driver(&lm78_driver);
800 	if (res)
801 		return res;
802 
803 	res = i2c_isa_add_driver(&lm78_isa_driver);
804 	if (res) {
805 		i2c_del_driver(&lm78_driver);
806 		return res;
807 	}
808 
809 	return 0;
810 }
811 
812 static void __exit sm_lm78_exit(void)
813 {
814 	i2c_isa_del_driver(&lm78_isa_driver);
815 	i2c_del_driver(&lm78_driver);
816 }
817 
818 
819 
820 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
821 MODULE_DESCRIPTION("LM78/LM79 driver");
822 MODULE_LICENSE("GPL");
823 
824 module_init(sm_lm78_init);
825 module_exit(sm_lm78_exit);
826