xref: /openbmc/linux/drivers/hwmon/lm90.c (revision 87c2ce3b)
1 /*
2  * lm90.c - Part of lm_sensors, Linux kernel modules for hardware
3  *          monitoring
4  * Copyright (C) 2003-2005  Jean Delvare <khali@linux-fr.org>
5  *
6  * Based on the lm83 driver. The LM90 is a sensor chip made by National
7  * Semiconductor. It reports up to two temperatures (its own plus up to
8  * one external one) with a 0.125 deg resolution (1 deg for local
9  * temperature) and a 3-4 deg accuracy. Complete datasheet can be
10  * obtained from National's website at:
11  *   http://www.national.com/pf/LM/LM90.html
12  *
13  * This driver also supports the LM89 and LM99, two other sensor chips
14  * made by National Semiconductor. Both have an increased remote
15  * temperature measurement accuracy (1 degree), and the LM99
16  * additionally shifts remote temperatures (measured and limits) by 16
17  * degrees, which allows for higher temperatures measurement. The
18  * driver doesn't handle it since it can be done easily in user-space.
19  * Complete datasheets can be obtained from National's website at:
20  *   http://www.national.com/pf/LM/LM89.html
21  *   http://www.national.com/pf/LM/LM99.html
22  * Note that there is no way to differentiate between both chips.
23  *
24  * This driver also supports the LM86, another sensor chip made by
25  * National Semiconductor. It is exactly similar to the LM90 except it
26  * has a higher accuracy.
27  * Complete datasheet can be obtained from National's website at:
28  *   http://www.national.com/pf/LM/LM86.html
29  *
30  * This driver also supports the ADM1032, a sensor chip made by Analog
31  * Devices. That chip is similar to the LM90, with a few differences
32  * that are not handled by this driver. Complete datasheet can be
33  * obtained from Analog's website at:
34  *   http://www.analog.com/en/prod/0,2877,ADM1032,00.html
35  * Among others, it has a higher accuracy than the LM90, much like the
36  * LM86 does.
37  *
38  * This driver also supports the MAX6657, MAX6658 and MAX6659 sensor
39  * chips made by Maxim. These chips are similar to the LM86. Complete
40  * datasheet can be obtained at Maxim's website at:
41  *   http://www.maxim-ic.com/quick_view2.cfm/qv_pk/2578
42  * Note that there is no easy way to differentiate between the three
43  * variants. The extra address and features of the MAX6659 are not
44  * supported by this driver.
45  *
46  * This driver also supports the ADT7461 chip from Analog Devices but
47  * only in its "compatability mode". If an ADT7461 chip is found but
48  * is configured in non-compatible mode (where its temperature
49  * register values are decoded differently) it is ignored by this
50  * driver. Complete datasheet can be obtained from Analog's website
51  * at:
52  *   http://www.analog.com/en/prod/0,2877,ADT7461,00.html
53  *
54  * Since the LM90 was the first chipset supported by this driver, most
55  * comments will refer to this chipset, but are actually general and
56  * concern all supported chipsets, unless mentioned otherwise.
57  *
58  * This program is free software; you can redistribute it and/or modify
59  * it under the terms of the GNU General Public License as published by
60  * the Free Software Foundation; either version 2 of the License, or
61  * (at your option) any later version.
62  *
63  * This program is distributed in the hope that it will be useful,
64  * but WITHOUT ANY WARRANTY; without even the implied warranty of
65  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
66  * GNU General Public License for more details.
67  *
68  * You should have received a copy of the GNU General Public License
69  * along with this program; if not, write to the Free Software
70  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
71  */
72 
73 #include <linux/module.h>
74 #include <linux/init.h>
75 #include <linux/slab.h>
76 #include <linux/jiffies.h>
77 #include <linux/i2c.h>
78 #include <linux/hwmon-sysfs.h>
79 #include <linux/hwmon.h>
80 #include <linux/err.h>
81 
82 /*
83  * Addresses to scan
84  * Address is fully defined internally and cannot be changed except for
85  * MAX6659.
86  * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, MAX6657 and MAX6658
87  * have address 0x4c.
88  * ADM1032-2, ADT7461-2, LM89-1, and LM99-1 have address 0x4d.
89  * MAX6659 can have address 0x4c, 0x4d or 0x4e (unsupported).
90  */
91 
92 static unsigned short normal_i2c[] = { 0x4c, 0x4d, I2C_CLIENT_END };
93 
94 /*
95  * Insmod parameters
96  */
97 
98 I2C_CLIENT_INSMOD_6(lm90, adm1032, lm99, lm86, max6657, adt7461);
99 
100 /*
101  * The LM90 registers
102  */
103 
104 #define LM90_REG_R_MAN_ID		0xFE
105 #define LM90_REG_R_CHIP_ID		0xFF
106 #define LM90_REG_R_CONFIG1		0x03
107 #define LM90_REG_W_CONFIG1		0x09
108 #define LM90_REG_R_CONFIG2		0xBF
109 #define LM90_REG_W_CONFIG2		0xBF
110 #define LM90_REG_R_CONVRATE		0x04
111 #define LM90_REG_W_CONVRATE		0x0A
112 #define LM90_REG_R_STATUS		0x02
113 #define LM90_REG_R_LOCAL_TEMP		0x00
114 #define LM90_REG_R_LOCAL_HIGH		0x05
115 #define LM90_REG_W_LOCAL_HIGH		0x0B
116 #define LM90_REG_R_LOCAL_LOW		0x06
117 #define LM90_REG_W_LOCAL_LOW		0x0C
118 #define LM90_REG_R_LOCAL_CRIT		0x20
119 #define LM90_REG_W_LOCAL_CRIT		0x20
120 #define LM90_REG_R_REMOTE_TEMPH		0x01
121 #define LM90_REG_R_REMOTE_TEMPL		0x10
122 #define LM90_REG_R_REMOTE_OFFSH		0x11
123 #define LM90_REG_W_REMOTE_OFFSH		0x11
124 #define LM90_REG_R_REMOTE_OFFSL		0x12
125 #define LM90_REG_W_REMOTE_OFFSL		0x12
126 #define LM90_REG_R_REMOTE_HIGHH		0x07
127 #define LM90_REG_W_REMOTE_HIGHH		0x0D
128 #define LM90_REG_R_REMOTE_HIGHL		0x13
129 #define LM90_REG_W_REMOTE_HIGHL		0x13
130 #define LM90_REG_R_REMOTE_LOWH		0x08
131 #define LM90_REG_W_REMOTE_LOWH		0x0E
132 #define LM90_REG_R_REMOTE_LOWL		0x14
133 #define LM90_REG_W_REMOTE_LOWL		0x14
134 #define LM90_REG_R_REMOTE_CRIT		0x19
135 #define LM90_REG_W_REMOTE_CRIT		0x19
136 #define LM90_REG_R_TCRIT_HYST		0x21
137 #define LM90_REG_W_TCRIT_HYST		0x21
138 
139 /*
140  * Conversions and various macros
141  * For local temperatures and limits, critical limits and the hysteresis
142  * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
143  * For remote temperatures and limits, it uses signed 11-bit values with
144  * LSB = 0.125 degree Celsius, left-justified in 16-bit registers.
145  */
146 
147 #define TEMP1_FROM_REG(val)	((val) * 1000)
148 #define TEMP1_TO_REG(val)	((val) <= -128000 ? -128 : \
149 				 (val) >= 127000 ? 127 : \
150 				 (val) < 0 ? ((val) - 500) / 1000 : \
151 				 ((val) + 500) / 1000)
152 #define TEMP2_FROM_REG(val)	((val) / 32 * 125)
153 #define TEMP2_TO_REG(val)	((val) <= -128000 ? 0x8000 : \
154 				 (val) >= 127875 ? 0x7FE0 : \
155 				 (val) < 0 ? ((val) - 62) / 125 * 32 : \
156 				 ((val) + 62) / 125 * 32)
157 #define HYST_TO_REG(val)	((val) <= 0 ? 0 : (val) >= 30500 ? 31 : \
158 				 ((val) + 500) / 1000)
159 
160 /*
161  * ADT7461 is almost identical to LM90 except that attempts to write
162  * values that are outside the range 0 < temp < 127 are treated as
163  * the boundary value.
164  */
165 
166 #define TEMP1_TO_REG_ADT7461(val) ((val) <= 0 ? 0 : \
167 				 (val) >= 127000 ? 127 : \
168 				 ((val) + 500) / 1000)
169 #define TEMP2_TO_REG_ADT7461(val) ((val) <= 0 ? 0 : \
170 				 (val) >= 127750 ? 0x7FC0 : \
171 				 ((val) + 125) / 250 * 64)
172 
173 /*
174  * Functions declaration
175  */
176 
177 static int lm90_attach_adapter(struct i2c_adapter *adapter);
178 static int lm90_detect(struct i2c_adapter *adapter, int address,
179 	int kind);
180 static void lm90_init_client(struct i2c_client *client);
181 static int lm90_detach_client(struct i2c_client *client);
182 static struct lm90_data *lm90_update_device(struct device *dev);
183 
184 /*
185  * Driver data (common to all clients)
186  */
187 
188 static struct i2c_driver lm90_driver = {
189 	.driver = {
190 		.name	= "lm90",
191 	},
192 	.id		= I2C_DRIVERID_LM90,
193 	.attach_adapter	= lm90_attach_adapter,
194 	.detach_client	= lm90_detach_client,
195 };
196 
197 /*
198  * Client data (each client gets its own)
199  */
200 
201 struct lm90_data {
202 	struct i2c_client client;
203 	struct class_device *class_dev;
204 	struct semaphore update_lock;
205 	char valid; /* zero until following fields are valid */
206 	unsigned long last_updated; /* in jiffies */
207 	int kind;
208 
209 	/* registers values */
210 	s8 temp8[5];	/* 0: local input
211 			   1: local low limit
212 			   2: local high limit
213 			   3: local critical limit
214 			   4: remote critical limit */
215 	s16 temp11[3];	/* 0: remote input
216 			   1: remote low limit
217 			   2: remote high limit */
218 	u8 temp_hyst;
219 	u8 alarms; /* bitvector */
220 };
221 
222 /*
223  * Sysfs stuff
224  */
225 
226 static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr,
227 			  char *buf)
228 {
229 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
230 	struct lm90_data *data = lm90_update_device(dev);
231 	return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index]));
232 }
233 
234 static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
235 			 const char *buf, size_t count)
236 {
237 	static const u8 reg[4] = {
238 		LM90_REG_W_LOCAL_LOW,
239 		LM90_REG_W_LOCAL_HIGH,
240 		LM90_REG_W_LOCAL_CRIT,
241 		LM90_REG_W_REMOTE_CRIT,
242 	};
243 
244 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
245 	struct i2c_client *client = to_i2c_client(dev);
246 	struct lm90_data *data = i2c_get_clientdata(client);
247 	long val = simple_strtol(buf, NULL, 10);
248 	int nr = attr->index;
249 
250 	down(&data->update_lock);
251 	if (data->kind == adt7461)
252 		data->temp8[nr] = TEMP1_TO_REG_ADT7461(val);
253 	else
254 		data->temp8[nr] = TEMP1_TO_REG(val);
255 	i2c_smbus_write_byte_data(client, reg[nr - 1], data->temp8[nr]);
256 	up(&data->update_lock);
257 	return count;
258 }
259 
260 static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,
261 			   char *buf)
262 {
263 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
264 	struct lm90_data *data = lm90_update_device(dev);
265 	return sprintf(buf, "%d\n", TEMP2_FROM_REG(data->temp11[attr->index]));
266 }
267 
268 static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
269 			  const char *buf, size_t count)
270 {
271 	static const u8 reg[4] = {
272 		LM90_REG_W_REMOTE_LOWH,
273 		LM90_REG_W_REMOTE_LOWL,
274 		LM90_REG_W_REMOTE_HIGHH,
275 		LM90_REG_W_REMOTE_HIGHL,
276 	};
277 
278 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
279 	struct i2c_client *client = to_i2c_client(dev);
280 	struct lm90_data *data = i2c_get_clientdata(client);
281 	long val = simple_strtol(buf, NULL, 10);
282 	int nr = attr->index;
283 
284 	down(&data->update_lock);
285 	if (data->kind == adt7461)
286 		data->temp11[nr] = TEMP2_TO_REG_ADT7461(val);
287 	else
288 		data->temp11[nr] = TEMP2_TO_REG(val);
289 	i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
290 				  data->temp11[nr] >> 8);
291 	i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
292 				  data->temp11[nr] & 0xff);
293 	up(&data->update_lock);
294 	return count;
295 }
296 
297 static ssize_t show_temphyst(struct device *dev, struct device_attribute *devattr,
298 			     char *buf)
299 {
300 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
301 	struct lm90_data *data = lm90_update_device(dev);
302 	return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index])
303 		       - TEMP1_FROM_REG(data->temp_hyst));
304 }
305 
306 static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
307 			    const char *buf, size_t count)
308 {
309 	struct i2c_client *client = to_i2c_client(dev);
310 	struct lm90_data *data = i2c_get_clientdata(client);
311 	long val = simple_strtol(buf, NULL, 10);
312 	long hyst;
313 
314 	down(&data->update_lock);
315 	hyst = TEMP1_FROM_REG(data->temp8[3]) - val;
316 	i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
317 				  HYST_TO_REG(hyst));
318 	up(&data->update_lock);
319 	return count;
320 }
321 
322 static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
323 			   char *buf)
324 {
325 	struct lm90_data *data = lm90_update_device(dev);
326 	return sprintf(buf, "%d\n", data->alarms);
327 }
328 
329 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp8, NULL, 0);
330 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0);
331 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
332 	set_temp8, 1);
333 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
334 	set_temp11, 1);
335 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
336 	set_temp8, 2);
337 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
338 	set_temp11, 2);
339 static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
340 	set_temp8, 3);
341 static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
342 	set_temp8, 4);
343 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
344 	set_temphyst, 3);
345 static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 4);
346 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
347 
348 /* pec used for ADM1032 only */
349 static ssize_t show_pec(struct device *dev, struct device_attribute *dummy,
350 			char *buf)
351 {
352 	struct i2c_client *client = to_i2c_client(dev);
353 	return sprintf(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
354 }
355 
356 static ssize_t set_pec(struct device *dev, struct device_attribute *dummy,
357 		       const char *buf, size_t count)
358 {
359 	struct i2c_client *client = to_i2c_client(dev);
360 	long val = simple_strtol(buf, NULL, 10);
361 
362 	switch (val) {
363 	case 0:
364 		client->flags &= ~I2C_CLIENT_PEC;
365 		break;
366 	case 1:
367 		client->flags |= I2C_CLIENT_PEC;
368 		break;
369 	default:
370 		return -EINVAL;
371 	}
372 
373 	return count;
374 }
375 
376 static DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec);
377 
378 /*
379  * Real code
380  */
381 
382 /* The ADM1032 supports PEC but not on write byte transactions, so we need
383    to explicitely ask for a transaction without PEC. */
384 static inline s32 adm1032_write_byte(struct i2c_client *client, u8 value)
385 {
386 	return i2c_smbus_xfer(client->adapter, client->addr,
387 			      client->flags & ~I2C_CLIENT_PEC,
388 			      I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
389 }
390 
391 /* It is assumed that client->update_lock is held (unless we are in
392    detection or initialization steps). This matters when PEC is enabled,
393    because we don't want the address pointer to change between the write
394    byte and the read byte transactions. */
395 static int lm90_read_reg(struct i2c_client* client, u8 reg, u8 *value)
396 {
397 	int err;
398 
399  	if (client->flags & I2C_CLIENT_PEC) {
400  		err = adm1032_write_byte(client, reg);
401  		if (err >= 0)
402  			err = i2c_smbus_read_byte(client);
403  	} else
404  		err = i2c_smbus_read_byte_data(client, reg);
405 
406 	if (err < 0) {
407 		dev_warn(&client->dev, "Register %#02x read failed (%d)\n",
408 			 reg, err);
409 		return err;
410 	}
411 	*value = err;
412 
413 	return 0;
414 }
415 
416 static int lm90_attach_adapter(struct i2c_adapter *adapter)
417 {
418 	if (!(adapter->class & I2C_CLASS_HWMON))
419 		return 0;
420 	return i2c_probe(adapter, &addr_data, lm90_detect);
421 }
422 
423 /*
424  * The following function does more than just detection. If detection
425  * succeeds, it also registers the new chip.
426  */
427 static int lm90_detect(struct i2c_adapter *adapter, int address, int kind)
428 {
429 	struct i2c_client *new_client;
430 	struct lm90_data *data;
431 	int err = 0;
432 	const char *name = "";
433 
434 	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
435 		goto exit;
436 
437 	if (!(data = kzalloc(sizeof(struct lm90_data), GFP_KERNEL))) {
438 		err = -ENOMEM;
439 		goto exit;
440 	}
441 
442 	/* The common I2C client data is placed right before the
443 	   LM90-specific data. */
444 	new_client = &data->client;
445 	i2c_set_clientdata(new_client, data);
446 	new_client->addr = address;
447 	new_client->adapter = adapter;
448 	new_client->driver = &lm90_driver;
449 	new_client->flags = 0;
450 
451 	/*
452 	 * Now we do the remaining detection. A negative kind means that
453 	 * the driver was loaded with no force parameter (default), so we
454 	 * must both detect and identify the chip. A zero kind means that
455 	 * the driver was loaded with the force parameter, the detection
456 	 * step shall be skipped. A positive kind means that the driver
457 	 * was loaded with the force parameter and a given kind of chip is
458 	 * requested, so both the detection and the identification steps
459 	 * are skipped.
460 	 */
461 
462 	/* Default to an LM90 if forced */
463 	if (kind == 0)
464 		kind = lm90;
465 
466 	if (kind < 0) { /* detection and identification */
467 		u8 man_id, chip_id, reg_config1, reg_convrate;
468 
469 		if (lm90_read_reg(new_client, LM90_REG_R_MAN_ID,
470 				  &man_id) < 0
471 		 || lm90_read_reg(new_client, LM90_REG_R_CHIP_ID,
472 		 		  &chip_id) < 0
473 		 || lm90_read_reg(new_client, LM90_REG_R_CONFIG1,
474 		 		  &reg_config1) < 0
475 		 || lm90_read_reg(new_client, LM90_REG_R_CONVRATE,
476 		 		  &reg_convrate) < 0)
477 			goto exit_free;
478 
479 		if (man_id == 0x01) { /* National Semiconductor */
480 			u8 reg_config2;
481 
482 			if (lm90_read_reg(new_client, LM90_REG_R_CONFIG2,
483 					  &reg_config2) < 0)
484 				goto exit_free;
485 
486 			if ((reg_config1 & 0x2A) == 0x00
487 			 && (reg_config2 & 0xF8) == 0x00
488 			 && reg_convrate <= 0x09) {
489 				if (address == 0x4C
490 				 && (chip_id & 0xF0) == 0x20) { /* LM90 */
491 					kind = lm90;
492 				} else
493 				if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */
494 					kind = lm99;
495 				} else
496 				if (address == 0x4C
497 				 && (chip_id & 0xF0) == 0x10) { /* LM86 */
498 					kind = lm86;
499 				}
500 			}
501 		} else
502 		if (man_id == 0x41) { /* Analog Devices */
503 			if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
504 			 && (reg_config1 & 0x3F) == 0x00
505 			 && reg_convrate <= 0x0A) {
506 				kind = adm1032;
507 			} else
508 			if (chip_id == 0x51 /* ADT7461 */
509 			 && (reg_config1 & 0x1F) == 0x00 /* check compat mode */
510 			 && reg_convrate <= 0x0A) {
511 				kind = adt7461;
512 			}
513 		} else
514 		if (man_id == 0x4D) { /* Maxim */
515 			/*
516 			 * The Maxim variants do NOT have a chip_id register.
517 			 * Reading from that address will return the last read
518 			 * value, which in our case is those of the man_id
519 			 * register. Likewise, the config1 register seems to
520 			 * lack a low nibble, so the value will be those of the
521 			 * previous read, so in our case those of the man_id
522 			 * register.
523 			 */
524 			if (chip_id == man_id
525 			 && (reg_config1 & 0x1F) == (man_id & 0x0F)
526 			 && reg_convrate <= 0x09) {
527 			 	kind = max6657;
528 			}
529 		}
530 
531 		if (kind <= 0) { /* identification failed */
532 			dev_info(&adapter->dev,
533 			    "Unsupported chip (man_id=0x%02X, "
534 			    "chip_id=0x%02X).\n", man_id, chip_id);
535 			goto exit_free;
536 		}
537 	}
538 
539 	if (kind == lm90) {
540 		name = "lm90";
541 	} else if (kind == adm1032) {
542 		name = "adm1032";
543 		/* The ADM1032 supports PEC, but only if combined
544 		   transactions are not used. */
545 		if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
546 			new_client->flags |= I2C_CLIENT_PEC;
547 	} else if (kind == lm99) {
548 		name = "lm99";
549 	} else if (kind == lm86) {
550 		name = "lm86";
551 	} else if (kind == max6657) {
552 		name = "max6657";
553 	} else if (kind == adt7461) {
554 		name = "adt7461";
555 	}
556 
557 	/* We can fill in the remaining client fields */
558 	strlcpy(new_client->name, name, I2C_NAME_SIZE);
559 	data->valid = 0;
560 	data->kind = kind;
561 	init_MUTEX(&data->update_lock);
562 
563 	/* Tell the I2C layer a new client has arrived */
564 	if ((err = i2c_attach_client(new_client)))
565 		goto exit_free;
566 
567 	/* Initialize the LM90 chip */
568 	lm90_init_client(new_client);
569 
570 	/* Register sysfs hooks */
571 	data->class_dev = hwmon_device_register(&new_client->dev);
572 	if (IS_ERR(data->class_dev)) {
573 		err = PTR_ERR(data->class_dev);
574 		goto exit_detach;
575 	}
576 
577 	device_create_file(&new_client->dev,
578 			   &sensor_dev_attr_temp1_input.dev_attr);
579 	device_create_file(&new_client->dev,
580 			   &sensor_dev_attr_temp2_input.dev_attr);
581 	device_create_file(&new_client->dev,
582 			   &sensor_dev_attr_temp1_min.dev_attr);
583 	device_create_file(&new_client->dev,
584 			   &sensor_dev_attr_temp2_min.dev_attr);
585 	device_create_file(&new_client->dev,
586 			   &sensor_dev_attr_temp1_max.dev_attr);
587 	device_create_file(&new_client->dev,
588 			   &sensor_dev_attr_temp2_max.dev_attr);
589 	device_create_file(&new_client->dev,
590 			   &sensor_dev_attr_temp1_crit.dev_attr);
591 	device_create_file(&new_client->dev,
592 			   &sensor_dev_attr_temp2_crit.dev_attr);
593 	device_create_file(&new_client->dev,
594 			   &sensor_dev_attr_temp1_crit_hyst.dev_attr);
595 	device_create_file(&new_client->dev,
596 			   &sensor_dev_attr_temp2_crit_hyst.dev_attr);
597 	device_create_file(&new_client->dev, &dev_attr_alarms);
598 
599 	if (new_client->flags & I2C_CLIENT_PEC)
600 		device_create_file(&new_client->dev, &dev_attr_pec);
601 
602 	return 0;
603 
604 exit_detach:
605 	i2c_detach_client(new_client);
606 exit_free:
607 	kfree(data);
608 exit:
609 	return err;
610 }
611 
612 static void lm90_init_client(struct i2c_client *client)
613 {
614 	u8 config;
615 
616 	/*
617 	 * Start the conversions.
618 	 */
619 	i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
620 				  5); /* 2 Hz */
621 	if (lm90_read_reg(client, LM90_REG_R_CONFIG1, &config) < 0) {
622 		dev_warn(&client->dev, "Initialization failed!\n");
623 		return;
624 	}
625 	if (config & 0x40)
626 		i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
627 					  config & 0xBF); /* run */
628 }
629 
630 static int lm90_detach_client(struct i2c_client *client)
631 {
632 	struct lm90_data *data = i2c_get_clientdata(client);
633 	int err;
634 
635 	hwmon_device_unregister(data->class_dev);
636 
637 	if ((err = i2c_detach_client(client)))
638 		return err;
639 
640 	kfree(data);
641 	return 0;
642 }
643 
644 static struct lm90_data *lm90_update_device(struct device *dev)
645 {
646 	struct i2c_client *client = to_i2c_client(dev);
647 	struct lm90_data *data = i2c_get_clientdata(client);
648 
649 	down(&data->update_lock);
650 
651 	if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
652 		u8 oldh, newh, l;
653 
654 		dev_dbg(&client->dev, "Updating lm90 data.\n");
655 		lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP, &data->temp8[0]);
656 		lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[1]);
657 		lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[2]);
658 		lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[3]);
659 		lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[4]);
660 		lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
661 
662 		/*
663 		 * There is a trick here. We have to read two registers to
664 		 * have the remote sensor temperature, but we have to beware
665 		 * a conversion could occur inbetween the readings. The
666 		 * datasheet says we should either use the one-shot
667 		 * conversion register, which we don't want to do (disables
668 		 * hardware monitoring) or monitor the busy bit, which is
669 		 * impossible (we can't read the values and monitor that bit
670 		 * at the exact same time). So the solution used here is to
671 		 * read the high byte once, then the low byte, then the high
672 		 * byte again. If the new high byte matches the old one,
673 		 * then we have a valid reading. Else we have to read the low
674 		 * byte again, and now we believe we have a correct reading.
675 		 */
676 		if (lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPH, &oldh) == 0
677 		 && lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPL, &l) == 0
678 		 && lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPH, &newh) == 0
679 		 && (newh == oldh
680 		  || lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPL, &l) == 0))
681 			data->temp11[0] = (newh << 8) | l;
682 
683 		if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &newh) == 0
684 		 && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL, &l) == 0)
685 			data->temp11[1] = (newh << 8) | l;
686 		if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &newh) == 0
687 		 && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL, &l) == 0)
688 			data->temp11[2] = (newh << 8) | l;
689 		lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);
690 
691 		data->last_updated = jiffies;
692 		data->valid = 1;
693 	}
694 
695 	up(&data->update_lock);
696 
697 	return data;
698 }
699 
700 static int __init sensors_lm90_init(void)
701 {
702 	return i2c_add_driver(&lm90_driver);
703 }
704 
705 static void __exit sensors_lm90_exit(void)
706 {
707 	i2c_del_driver(&lm90_driver);
708 }
709 
710 MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
711 MODULE_DESCRIPTION("LM90/ADM1032 driver");
712 MODULE_LICENSE("GPL");
713 
714 module_init(sensors_lm90_init);
715 module_exit(sensors_lm90_exit);
716