blob: 866b401ab6e86937f5880d9b7571df72081e9665 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 lm77.c - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring
4
5 Copyright (c) 2004 Andras BALI <drewie@freemail.hu>
6
7 Heavily based on lm75.c by Frodo Looijaard <frodol@dds.nl>. The LM77
8 is a temperature sensor and thermal window comparator with 0.5 deg
9 resolution made by National Semiconductor. Complete datasheet can be
10 obtained at their site:
11 http://www.national.com/pf/LM/LM77.html
12
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
17
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26*/
27
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/module.h>
29#include <linux/init.h>
30#include <linux/slab.h>
31#include <linux/jiffies.h>
32#include <linux/i2c.h>
Mark M. Hoffman943b0832005-07-15 21:39:18 -040033#include <linux/hwmon.h>
Jean Delvare1f52af02008-01-03 23:35:33 +010034#include <linux/hwmon-sysfs.h>
Mark M. Hoffman943b0832005-07-15 21:39:18 -040035#include <linux/err.h>
Ingo Molnar9a61bf62006-01-18 23:19:26 +010036#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
38/* Addresses to scan */
Mark M. Hoffman25e9c862008-02-17 22:28:03 -050039static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b,
40 I2C_CLIENT_END };
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
42/* Insmod parameters */
Jean Delvaref4b50262005-07-31 21:49:03 +020043I2C_CLIENT_INSMOD_1(lm77);
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45/* The LM77 registers */
46#define LM77_REG_TEMP 0x00
47#define LM77_REG_CONF 0x01
48#define LM77_REG_TEMP_HYST 0x02
49#define LM77_REG_TEMP_CRIT 0x03
50#define LM77_REG_TEMP_MIN 0x04
51#define LM77_REG_TEMP_MAX 0x05
52
53/* Each client has this additional data */
54struct lm77_data {
Tony Jones1beeffe2007-08-20 13:46:20 -070055 struct device *hwmon_dev;
Ingo Molnar9a61bf62006-01-18 23:19:26 +010056 struct mutex update_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 char valid;
58 unsigned long last_updated; /* In jiffies */
59 int temp_input; /* Temperatures */
60 int temp_crit;
61 int temp_min;
62 int temp_max;
63 int temp_hyst;
64 u8 alarms;
65};
66
Jean Delvarea189dd62008-07-16 19:30:13 +020067static int lm77_probe(struct i2c_client *client,
68 const struct i2c_device_id *id);
69static int lm77_detect(struct i2c_client *client, int kind,
70 struct i2c_board_info *info);
Linus Torvalds1da177e2005-04-16 15:20:36 -070071static void lm77_init_client(struct i2c_client *client);
Jean Delvarea189dd62008-07-16 19:30:13 +020072static int lm77_remove(struct i2c_client *client);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073static u16 lm77_read_value(struct i2c_client *client, u8 reg);
74static int lm77_write_value(struct i2c_client *client, u8 reg, u16 value);
75
76static struct lm77_data *lm77_update_device(struct device *dev);
77
78
Jean Delvarea189dd62008-07-16 19:30:13 +020079static const struct i2c_device_id lm77_id[] = {
80 { "lm77", lm77 },
81 { }
82};
83MODULE_DEVICE_TABLE(i2c, lm77_id);
84
Linus Torvalds1da177e2005-04-16 15:20:36 -070085/* This is the driver that will be inserted */
86static struct i2c_driver lm77_driver = {
Jean Delvarea189dd62008-07-16 19:30:13 +020087 .class = I2C_CLASS_HWMON,
Laurent Riffardcdaf7932005-11-26 20:37:41 +010088 .driver = {
Laurent Riffardcdaf7932005-11-26 20:37:41 +010089 .name = "lm77",
90 },
Jean Delvarea189dd62008-07-16 19:30:13 +020091 .probe = lm77_probe,
92 .remove = lm77_remove,
93 .id_table = lm77_id,
94 .detect = lm77_detect,
95 .address_data = &addr_data,
Linus Torvalds1da177e2005-04-16 15:20:36 -070096};
97
98/* straight from the datasheet */
99#define LM77_TEMP_MIN (-55000)
100#define LM77_TEMP_MAX 125000
101
102/* In the temperature registers, the low 3 bits are not part of the
103 temperature values; they are the status bits. */
Jean Delvare413b6452006-01-09 22:43:08 +0100104static inline s16 LM77_TEMP_TO_REG(int temp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105{
106 int ntemp = SENSORS_LIMIT(temp, LM77_TEMP_MIN, LM77_TEMP_MAX);
Jean Delvare413b6452006-01-09 22:43:08 +0100107 return (ntemp / 500) * 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108}
109
Jean Delvare413b6452006-01-09 22:43:08 +0100110static inline int LM77_TEMP_FROM_REG(s16 reg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111{
Jean Delvare413b6452006-01-09 22:43:08 +0100112 return (reg / 8) * 500;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113}
114
115/* sysfs stuff */
116
117/* read routines for temperature limits */
118#define show(value) \
Yani Ioannou8627f9b2005-05-17 06:42:03 -0400119static ssize_t show_##value(struct device *dev, struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120{ \
121 struct lm77_data *data = lm77_update_device(dev); \
122 return sprintf(buf, "%d\n", data->value); \
123}
124
125show(temp_input);
126show(temp_crit);
127show(temp_min);
128show(temp_max);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129
130/* read routines for hysteresis values */
Yani Ioannou8627f9b2005-05-17 06:42:03 -0400131static ssize_t show_temp_crit_hyst(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132{
133 struct lm77_data *data = lm77_update_device(dev);
134 return sprintf(buf, "%d\n", data->temp_crit - data->temp_hyst);
135}
Yani Ioannou8627f9b2005-05-17 06:42:03 -0400136static ssize_t show_temp_min_hyst(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137{
138 struct lm77_data *data = lm77_update_device(dev);
139 return sprintf(buf, "%d\n", data->temp_min + data->temp_hyst);
140}
Yani Ioannou8627f9b2005-05-17 06:42:03 -0400141static ssize_t show_temp_max_hyst(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142{
143 struct lm77_data *data = lm77_update_device(dev);
144 return sprintf(buf, "%d\n", data->temp_max - data->temp_hyst);
145}
146
147/* write routines */
148#define set(value, reg) \
Yani Ioannou8627f9b2005-05-17 06:42:03 -0400149static ssize_t set_##value(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150{ \
151 struct i2c_client *client = to_i2c_client(dev); \
152 struct lm77_data *data = i2c_get_clientdata(client); \
Christian Hohnstaedt5bfedac2007-08-16 11:40:10 +0200153 long val = simple_strtol(buf, NULL, 10); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 \
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100155 mutex_lock(&data->update_lock); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 data->value = val; \
157 lm77_write_value(client, reg, LM77_TEMP_TO_REG(data->value)); \
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100158 mutex_unlock(&data->update_lock); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 return count; \
160}
161
162set(temp_min, LM77_REG_TEMP_MIN);
163set(temp_max, LM77_REG_TEMP_MAX);
164
165/* hysteresis is stored as a relative value on the chip, so it has to be
166 converted first */
Yani Ioannou8627f9b2005-05-17 06:42:03 -0400167static ssize_t set_temp_crit_hyst(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168{
169 struct i2c_client *client = to_i2c_client(dev);
170 struct lm77_data *data = i2c_get_clientdata(client);
171 unsigned long val = simple_strtoul(buf, NULL, 10);
172
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100173 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 data->temp_hyst = data->temp_crit - val;
175 lm77_write_value(client, LM77_REG_TEMP_HYST,
176 LM77_TEMP_TO_REG(data->temp_hyst));
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100177 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 return count;
179}
180
181/* preserve hysteresis when setting T_crit */
Yani Ioannou8627f9b2005-05-17 06:42:03 -0400182static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183{
184 struct i2c_client *client = to_i2c_client(dev);
185 struct lm77_data *data = i2c_get_clientdata(client);
186 long val = simple_strtoul(buf, NULL, 10);
187 int oldcrithyst;
188
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100189 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 oldcrithyst = data->temp_crit - data->temp_hyst;
191 data->temp_crit = val;
192 data->temp_hyst = data->temp_crit - oldcrithyst;
193 lm77_write_value(client, LM77_REG_TEMP_CRIT,
194 LM77_TEMP_TO_REG(data->temp_crit));
195 lm77_write_value(client, LM77_REG_TEMP_HYST,
196 LM77_TEMP_TO_REG(data->temp_hyst));
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100197 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 return count;
199}
200
Jean Delvare1f52af02008-01-03 23:35:33 +0100201static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
202 char *buf)
203{
204 int bitnr = to_sensor_dev_attr(attr)->index;
205 struct lm77_data *data = lm77_update_device(dev);
206 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
207}
208
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209static DEVICE_ATTR(temp1_input, S_IRUGO,
210 show_temp_input, NULL);
211static DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO,
212 show_temp_crit, set_temp_crit);
213static DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO,
214 show_temp_min, set_temp_min);
215static DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
216 show_temp_max, set_temp_max);
217
218static DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO,
219 show_temp_crit_hyst, set_temp_crit_hyst);
220static DEVICE_ATTR(temp1_min_hyst, S_IRUGO,
221 show_temp_min_hyst, NULL);
222static DEVICE_ATTR(temp1_max_hyst, S_IRUGO,
223 show_temp_max_hyst, NULL);
224
Jean Delvare1f52af02008-01-03 23:35:33 +0100225static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 2);
226static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 0);
227static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
Mark M. Hoffman0501a3812006-09-24 21:14:35 +0200229static struct attribute *lm77_attributes[] = {
230 &dev_attr_temp1_input.attr,
231 &dev_attr_temp1_crit.attr,
232 &dev_attr_temp1_min.attr,
233 &dev_attr_temp1_max.attr,
234 &dev_attr_temp1_crit_hyst.attr,
235 &dev_attr_temp1_min_hyst.attr,
236 &dev_attr_temp1_max_hyst.attr,
Jean Delvare1f52af02008-01-03 23:35:33 +0100237 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
238 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
239 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
Mark M. Hoffman0501a3812006-09-24 21:14:35 +0200240 NULL
241};
242
243static const struct attribute_group lm77_group = {
244 .attrs = lm77_attributes,
245};
246
Jean Delvarea189dd62008-07-16 19:30:13 +0200247/* Return 0 if detection is successful, -ENODEV otherwise */
248static int lm77_detect(struct i2c_client *new_client, int kind,
249 struct i2c_board_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250{
Jean Delvarea189dd62008-07-16 19:30:13 +0200251 struct i2c_adapter *adapter = new_client->adapter;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
253 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
254 I2C_FUNC_SMBUS_WORD_DATA))
Jean Delvarea189dd62008-07-16 19:30:13 +0200255 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
257 /* Here comes the remaining detection. Since the LM77 has no
258 register dedicated to identification, we have to rely on the
259 following tricks:
260
261 1. the high 4 bits represent the sign and thus they should
262 always be the same
263 2. the high 3 bits are unused in the configuration register
264 3. addresses 0x06 and 0x07 return the last read value
265 4. registers cycling over 8-address boundaries
266
267 Word-sized registers are high-byte first. */
268 if (kind < 0) {
269 int i, cur, conf, hyst, crit, min, max;
270
271 /* addresses cycling */
272 cur = i2c_smbus_read_word_data(new_client, 0);
273 conf = i2c_smbus_read_byte_data(new_client, 1);
274 hyst = i2c_smbus_read_word_data(new_client, 2);
275 crit = i2c_smbus_read_word_data(new_client, 3);
276 min = i2c_smbus_read_word_data(new_client, 4);
277 max = i2c_smbus_read_word_data(new_client, 5);
278 for (i = 8; i <= 0xff; i += 8)
279 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
280 || i2c_smbus_read_word_data(new_client, i + 2) != hyst
281 || i2c_smbus_read_word_data(new_client, i + 3) != crit
282 || i2c_smbus_read_word_data(new_client, i + 4) != min
283 || i2c_smbus_read_word_data(new_client, i + 5) != max)
Jean Delvarea189dd62008-07-16 19:30:13 +0200284 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285
286 /* sign bits */
287 if (((cur & 0x00f0) != 0xf0 && (cur & 0x00f0) != 0x0)
288 || ((hyst & 0x00f0) != 0xf0 && (hyst & 0x00f0) != 0x0)
289 || ((crit & 0x00f0) != 0xf0 && (crit & 0x00f0) != 0x0)
290 || ((min & 0x00f0) != 0xf0 && (min & 0x00f0) != 0x0)
291 || ((max & 0x00f0) != 0xf0 && (max & 0x00f0) != 0x0))
Jean Delvarea189dd62008-07-16 19:30:13 +0200292 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293
294 /* unused bits */
295 if (conf & 0xe0)
Jean Delvarea189dd62008-07-16 19:30:13 +0200296 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297
298 /* 0x06 and 0x07 return the last read value */
299 cur = i2c_smbus_read_word_data(new_client, 0);
300 if (i2c_smbus_read_word_data(new_client, 6) != cur
301 || i2c_smbus_read_word_data(new_client, 7) != cur)
Jean Delvarea189dd62008-07-16 19:30:13 +0200302 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 hyst = i2c_smbus_read_word_data(new_client, 2);
304 if (i2c_smbus_read_word_data(new_client, 6) != hyst
305 || i2c_smbus_read_word_data(new_client, 7) != hyst)
Jean Delvarea189dd62008-07-16 19:30:13 +0200306 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 min = i2c_smbus_read_word_data(new_client, 4);
308 if (i2c_smbus_read_word_data(new_client, 6) != min
309 || i2c_smbus_read_word_data(new_client, 7) != min)
Jean Delvarea189dd62008-07-16 19:30:13 +0200310 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311
312 }
313
Jean Delvarea189dd62008-07-16 19:30:13 +0200314 strlcpy(info->type, "lm77", I2C_NAME_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315
Jean Delvarea189dd62008-07-16 19:30:13 +0200316 return 0;
317}
318
319static int lm77_probe(struct i2c_client *new_client,
320 const struct i2c_device_id *id)
321{
322 struct lm77_data *data;
323 int err;
324
325 data = kzalloc(sizeof(struct lm77_data), GFP_KERNEL);
326 if (!data) {
327 err = -ENOMEM;
328 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 }
330
Jean Delvarea189dd62008-07-16 19:30:13 +0200331 i2c_set_clientdata(new_client, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 data->valid = 0;
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100333 mutex_init(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 /* Initialize the LM77 chip */
336 lm77_init_client(new_client);
337
338 /* Register sysfs hooks */
Mark M. Hoffman0501a3812006-09-24 21:14:35 +0200339 if ((err = sysfs_create_group(&new_client->dev.kobj, &lm77_group)))
Jean Delvarea189dd62008-07-16 19:30:13 +0200340 goto exit_free;
Mark M. Hoffman0501a3812006-09-24 21:14:35 +0200341
Tony Jones1beeffe2007-08-20 13:46:20 -0700342 data->hwmon_dev = hwmon_device_register(&new_client->dev);
343 if (IS_ERR(data->hwmon_dev)) {
344 err = PTR_ERR(data->hwmon_dev);
Mark M. Hoffman0501a3812006-09-24 21:14:35 +0200345 goto exit_remove;
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400346 }
347
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 return 0;
349
Mark M. Hoffman0501a3812006-09-24 21:14:35 +0200350exit_remove:
351 sysfs_remove_group(&new_client->dev.kobj, &lm77_group);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352exit_free:
353 kfree(data);
354exit:
355 return err;
356}
357
Jean Delvarea189dd62008-07-16 19:30:13 +0200358static int lm77_remove(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359{
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400360 struct lm77_data *data = i2c_get_clientdata(client);
Tony Jones1beeffe2007-08-20 13:46:20 -0700361 hwmon_device_unregister(data->hwmon_dev);
Mark M. Hoffman0501a3812006-09-24 21:14:35 +0200362 sysfs_remove_group(&client->dev.kobj, &lm77_group);
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400363 kfree(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 return 0;
365}
366
367/* All registers are word-sized, except for the configuration register.
368 The LM77 uses the high-byte first convention. */
369static u16 lm77_read_value(struct i2c_client *client, u8 reg)
370{
371 if (reg == LM77_REG_CONF)
372 return i2c_smbus_read_byte_data(client, reg);
373 else
374 return swab16(i2c_smbus_read_word_data(client, reg));
375}
376
377static int lm77_write_value(struct i2c_client *client, u8 reg, u16 value)
378{
379 if (reg == LM77_REG_CONF)
380 return i2c_smbus_write_byte_data(client, reg, value);
381 else
382 return i2c_smbus_write_word_data(client, reg, swab16(value));
383}
384
385static void lm77_init_client(struct i2c_client *client)
386{
387 /* Initialize the LM77 chip - turn off shutdown mode */
388 int conf = lm77_read_value(client, LM77_REG_CONF);
389 if (conf & 1)
390 lm77_write_value(client, LM77_REG_CONF, conf & 0xfe);
391}
392
393static struct lm77_data *lm77_update_device(struct device *dev)
394{
395 struct i2c_client *client = to_i2c_client(dev);
396 struct lm77_data *data = i2c_get_clientdata(client);
397
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100398 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399
400 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
401 || !data->valid) {
402 dev_dbg(&client->dev, "Starting lm77 update\n");
403 data->temp_input =
404 LM77_TEMP_FROM_REG(lm77_read_value(client,
405 LM77_REG_TEMP));
406 data->temp_hyst =
407 LM77_TEMP_FROM_REG(lm77_read_value(client,
408 LM77_REG_TEMP_HYST));
409 data->temp_crit =
410 LM77_TEMP_FROM_REG(lm77_read_value(client,
411 LM77_REG_TEMP_CRIT));
412 data->temp_min =
413 LM77_TEMP_FROM_REG(lm77_read_value(client,
414 LM77_REG_TEMP_MIN));
415 data->temp_max =
416 LM77_TEMP_FROM_REG(lm77_read_value(client,
417 LM77_REG_TEMP_MAX));
418 data->alarms =
419 lm77_read_value(client, LM77_REG_TEMP) & 0x0007;
420 data->last_updated = jiffies;
421 data->valid = 1;
422 }
423
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100424 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
426 return data;
427}
428
429static int __init sensors_lm77_init(void)
430{
431 return i2c_add_driver(&lm77_driver);
432}
433
434static void __exit sensors_lm77_exit(void)
435{
436 i2c_del_driver(&lm77_driver);
437}
438
439MODULE_AUTHOR("Andras BALI <drewie@freemail.hu>");
440MODULE_DESCRIPTION("LM77 driver");
441MODULE_LICENSE("GPL");
442
443module_init(sensors_lm77_init);
444module_exit(sensors_lm77_exit);