Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
lm80.c
Go to the documentation of this file.
1 /*
2  * lm80.c - From lm_sensors, Linux kernel modules for hardware
3  * monitoring
4  * Copyright (C) 1998, 1999 Frodo Looijaard <[email protected]>
5  * and Philip Edelbrock <[email protected]>
6  *
7  * Ported to Linux 2.6 by Tiago Sousa <[email protected]>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22  */
23 
24 #include <linux/module.h>
25 #include <linux/init.h>
26 #include <linux/slab.h>
27 #include <linux/jiffies.h>
28 #include <linux/i2c.h>
29 #include <linux/hwmon.h>
30 #include <linux/hwmon-sysfs.h>
31 #include <linux/err.h>
32 #include <linux/mutex.h>
33 
34 /* Addresses to scan */
35 static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
36  0x2e, 0x2f, I2C_CLIENT_END };
37 
38 /* Many LM80 constants specified below */
39 
40 /* The LM80 registers */
41 #define LM80_REG_IN_MAX(nr) (0x2a + (nr) * 2)
42 #define LM80_REG_IN_MIN(nr) (0x2b + (nr) * 2)
43 #define LM80_REG_IN(nr) (0x20 + (nr))
44 
45 #define LM80_REG_FAN1 0x28
46 #define LM80_REG_FAN2 0x29
47 #define LM80_REG_FAN_MIN(nr) (0x3b + (nr))
48 
49 #define LM80_REG_TEMP 0x27
50 #define LM80_REG_TEMP_HOT_MAX 0x38
51 #define LM80_REG_TEMP_HOT_HYST 0x39
52 #define LM80_REG_TEMP_OS_MAX 0x3a
53 #define LM80_REG_TEMP_OS_HYST 0x3b
54 
55 #define LM80_REG_CONFIG 0x00
56 #define LM80_REG_ALARM1 0x01
57 #define LM80_REG_ALARM2 0x02
58 #define LM80_REG_MASK1 0x03
59 #define LM80_REG_MASK2 0x04
60 #define LM80_REG_FANDIV 0x05
61 #define LM80_REG_RES 0x06
62 
63 #define LM96080_REG_CONV_RATE 0x07
64 #define LM96080_REG_MAN_ID 0x3e
65 #define LM96080_REG_DEV_ID 0x3f
66 
67 
68 /*
69  * Conversions. Rounding and limit checking is only done on the TO_REG
70  * variants. Note that you should be a bit careful with which arguments
71  * these macros are called: arguments may be evaluated more than once.
72  * Fixing this is just not worth it.
73  */
74 
75 #define IN_TO_REG(val) (SENSORS_LIMIT(((val) + 5) / 10, 0, 255))
76 #define IN_FROM_REG(val) ((val) * 10)
77 
78 static inline unsigned char FAN_TO_REG(unsigned rpm, unsigned div)
79 {
80  if (rpm == 0)
81  return 255;
82  rpm = SENSORS_LIMIT(rpm, 1, 1000000);
83  return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
84 }
85 
86 #define FAN_FROM_REG(val, div) ((val) == 0 ? -1 : \
87  (val) == 255 ? 0 : 1350000/((div) * (val)))
88 
89 static inline long TEMP_FROM_REG(u16 temp)
90 {
91  long res;
92 
93  temp >>= 4;
94  if (temp < 0x0800)
95  res = 625 * (long) temp;
96  else
97  res = ((long) temp - 0x01000) * 625;
98 
99  return res / 10;
100 }
101 
102 #define TEMP_LIMIT_FROM_REG(val) (((val) > 0x80 ? \
103  (val) - 0x100 : (val)) * 1000)
104 
105 #define TEMP_LIMIT_TO_REG(val) SENSORS_LIMIT((val) < 0 ? \
106  ((val) - 500) / 1000 : ((val) + 500) / 1000, 0, 255)
107 
108 #define DIV_FROM_REG(val) (1 << (val))
109 
110 /*
111  * Client data (each client gets its own)
112  */
113 
114 struct lm80_data {
115  struct device *hwmon_dev;
116  struct mutex update_lock;
117  char error; /* !=0 if error occurred during last update */
118  char valid; /* !=0 if following fields are valid */
119  unsigned long last_updated; /* In jiffies */
120 
121  u8 in[7]; /* Register value */
122  u8 in_max[7]; /* Register value */
123  u8 in_min[7]; /* Register value */
124  u8 fan[2]; /* Register value */
125  u8 fan_min[2]; /* Register value */
126  u8 fan_div[2]; /* Register encoding, shifted right */
127  u16 temp; /* Register values, shifted right */
128  u8 temp_hot_max; /* Register value */
129  u8 temp_hot_hyst; /* Register value */
130  u8 temp_os_max; /* Register value */
131  u8 temp_os_hyst; /* Register value */
132  u16 alarms; /* Register encoding, combined */
133 };
134 
135 /*
136  * Functions declaration
137  */
138 
139 static int lm80_probe(struct i2c_client *client,
140  const struct i2c_device_id *id);
141 static int lm80_detect(struct i2c_client *client, struct i2c_board_info *info);
142 static void lm80_init_client(struct i2c_client *client);
143 static int lm80_remove(struct i2c_client *client);
144 static struct lm80_data *lm80_update_device(struct device *dev);
145 static int lm80_read_value(struct i2c_client *client, u8 reg);
146 static int lm80_write_value(struct i2c_client *client, u8 reg, u8 value);
147 
148 /*
149  * Driver data (common to all clients)
150  */
151 
152 static const struct i2c_device_id lm80_id[] = {
153  { "lm80", 0 },
154  { "lm96080", 1 },
155  { }
156 };
157 MODULE_DEVICE_TABLE(i2c, lm80_id);
158 
159 static struct i2c_driver lm80_driver = {
160  .class = I2C_CLASS_HWMON,
161  .driver = {
162  .name = "lm80",
163  },
164  .probe = lm80_probe,
165  .remove = lm80_remove,
166  .id_table = lm80_id,
167  .detect = lm80_detect,
168  .address_list = normal_i2c,
169 };
170 
171 /*
172  * Sysfs stuff
173  */
174 
175 #define show_in(suffix, value) \
176 static ssize_t show_in_##suffix(struct device *dev, \
177  struct device_attribute *attr, char *buf) \
178 { \
179  int nr = to_sensor_dev_attr(attr)->index; \
180  struct lm80_data *data = lm80_update_device(dev); \
181  if (IS_ERR(data)) \
182  return PTR_ERR(data); \
183  return sprintf(buf, "%d\n", IN_FROM_REG(data->value[nr])); \
184 }
185 show_in(min, in_min)
186 show_in(max, in_max)
187 show_in(input, in)
188 
189 #define set_in(suffix, value, reg) \
190 static ssize_t set_in_##suffix(struct device *dev, \
191  struct device_attribute *attr, const char *buf, size_t count) \
192 { \
193  int nr = to_sensor_dev_attr(attr)->index; \
194  struct i2c_client *client = to_i2c_client(dev); \
195  struct lm80_data *data = i2c_get_clientdata(client); \
196  long val; \
197  int err = kstrtol(buf, 10, &val); \
198  if (err < 0) \
199  return err; \
200 \
201  mutex_lock(&data->update_lock);\
202  data->value[nr] = IN_TO_REG(val); \
203  lm80_write_value(client, reg(nr), data->value[nr]); \
204  mutex_unlock(&data->update_lock);\
205  return count; \
206 }
207 set_in(min, in_min, LM80_REG_IN_MIN)
208 set_in(max, in_max, LM80_REG_IN_MAX)
209 
210 #define show_fan(suffix, value) \
211 static ssize_t show_fan_##suffix(struct device *dev, \
212  struct device_attribute *attr, char *buf) \
213 { \
214  int nr = to_sensor_dev_attr(attr)->index; \
215  struct lm80_data *data = lm80_update_device(dev); \
216  if (IS_ERR(data)) \
217  return PTR_ERR(data); \
218  return sprintf(buf, "%d\n", FAN_FROM_REG(data->value[nr], \
219  DIV_FROM_REG(data->fan_div[nr]))); \
220 }
221 show_fan(min, fan_min)
222 show_fan(input, fan)
223 
224 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
225  char *buf)
226 {
227  int nr = to_sensor_dev_attr(attr)->index;
228  struct lm80_data *data = lm80_update_device(dev);
229  if (IS_ERR(data))
230  return PTR_ERR(data);
231  return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
232 }
233 
234 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
235  const char *buf, size_t count)
236 {
237  int nr = to_sensor_dev_attr(attr)->index;
238  struct i2c_client *client = to_i2c_client(dev);
239  struct lm80_data *data = i2c_get_clientdata(client);
240  unsigned long val;
241  int err = kstrtoul(buf, 10, &val);
242  if (err < 0)
243  return err;
244 
245  mutex_lock(&data->update_lock);
246  data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
247  lm80_write_value(client, LM80_REG_FAN_MIN(nr + 1), data->fan_min[nr]);
248  mutex_unlock(&data->update_lock);
249  return count;
250 }
251 
252 /*
253  * Note: we save and restore the fan minimum here, because its value is
254  * determined in part by the fan divisor. This follows the principle of
255  * least surprise; the user doesn't expect the fan minimum to change just
256  * because the divisor changed.
257  */
258 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
259  const char *buf, size_t count)
260 {
261  int nr = to_sensor_dev_attr(attr)->index;
262  struct i2c_client *client = to_i2c_client(dev);
263  struct lm80_data *data = i2c_get_clientdata(client);
264  unsigned long min, val;
265  u8 reg;
266  int err = kstrtoul(buf, 10, &val);
267  if (err < 0)
268  return err;
269 
270  /* Save fan_min */
271  mutex_lock(&data->update_lock);
272  min = FAN_FROM_REG(data->fan_min[nr],
273  DIV_FROM_REG(data->fan_div[nr]));
274 
275  switch (val) {
276  case 1:
277  data->fan_div[nr] = 0;
278  break;
279  case 2:
280  data->fan_div[nr] = 1;
281  break;
282  case 4:
283  data->fan_div[nr] = 2;
284  break;
285  case 8:
286  data->fan_div[nr] = 3;
287  break;
288  default:
289  dev_err(&client->dev, "fan_div value %ld not "
290  "supported. Choose one of 1, 2, 4 or 8!\n", val);
291  mutex_unlock(&data->update_lock);
292  return -EINVAL;
293  }
294 
295  reg = (lm80_read_value(client, LM80_REG_FANDIV) & ~(3 << (2 * (nr + 1))))
296  | (data->fan_div[nr] << (2 * (nr + 1)));
297  lm80_write_value(client, LM80_REG_FANDIV, reg);
298 
299  /* Restore fan_min */
300  data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
301  lm80_write_value(client, LM80_REG_FAN_MIN(nr + 1), data->fan_min[nr]);
302  mutex_unlock(&data->update_lock);
303 
304  return count;
305 }
306 
307 static ssize_t show_temp_input1(struct device *dev,
308  struct device_attribute *attr, char *buf)
309 {
310  struct lm80_data *data = lm80_update_device(dev);
311  if (IS_ERR(data))
312  return PTR_ERR(data);
313  return sprintf(buf, "%ld\n", TEMP_FROM_REG(data->temp));
314 }
315 
316 #define show_temp(suffix, value) \
317 static ssize_t show_temp_##suffix(struct device *dev, \
318  struct device_attribute *attr, char *buf) \
319 { \
320  struct lm80_data *data = lm80_update_device(dev); \
321  if (IS_ERR(data)) \
322  return PTR_ERR(data); \
323  return sprintf(buf, "%d\n", TEMP_LIMIT_FROM_REG(data->value)); \
324 }
325 show_temp(hot_max, temp_hot_max);
326 show_temp(hot_hyst, temp_hot_hyst);
327 show_temp(os_max, temp_os_max);
328 show_temp(os_hyst, temp_os_hyst);
329 
330 #define set_temp(suffix, value, reg) \
331 static ssize_t set_temp_##suffix(struct device *dev, \
332  struct device_attribute *attr, const char *buf, size_t count) \
333 { \
334  struct i2c_client *client = to_i2c_client(dev); \
335  struct lm80_data *data = i2c_get_clientdata(client); \
336  long val; \
337  int err = kstrtol(buf, 10, &val); \
338  if (err < 0) \
339  return err; \
340 \
341  mutex_lock(&data->update_lock); \
342  data->value = TEMP_LIMIT_TO_REG(val); \
343  lm80_write_value(client, reg, data->value); \
344  mutex_unlock(&data->update_lock); \
345  return count; \
346 }
347 set_temp(hot_max, temp_hot_max, LM80_REG_TEMP_HOT_MAX);
348 set_temp(hot_hyst, temp_hot_hyst, LM80_REG_TEMP_HOT_HYST);
349 set_temp(os_max, temp_os_max, LM80_REG_TEMP_OS_MAX);
350 set_temp(os_hyst, temp_os_hyst, LM80_REG_TEMP_OS_HYST);
351 
352 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr,
353  char *buf)
354 {
355  struct lm80_data *data = lm80_update_device(dev);
356  if (IS_ERR(data))
357  return PTR_ERR(data);
358  return sprintf(buf, "%u\n", data->alarms);
359 }
360 
361 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
362  char *buf)
363 {
364  int bitnr = to_sensor_dev_attr(attr)->index;
365  struct lm80_data *data = lm80_update_device(dev);
366  if (IS_ERR(data))
367  return PTR_ERR(data);
368  return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
369 }
370 
371 static SENSOR_DEVICE_ATTR(in0_min, S_IWUSR | S_IRUGO,
372  show_in_min, set_in_min, 0);
373 static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO,
374  show_in_min, set_in_min, 1);
375 static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO,
376  show_in_min, set_in_min, 2);
377 static SENSOR_DEVICE_ATTR(in3_min, S_IWUSR | S_IRUGO,
378  show_in_min, set_in_min, 3);
379 static SENSOR_DEVICE_ATTR(in4_min, S_IWUSR | S_IRUGO,
380  show_in_min, set_in_min, 4);
381 static SENSOR_DEVICE_ATTR(in5_min, S_IWUSR | S_IRUGO,
382  show_in_min, set_in_min, 5);
383 static SENSOR_DEVICE_ATTR(in6_min, S_IWUSR | S_IRUGO,
384  show_in_min, set_in_min, 6);
385 static SENSOR_DEVICE_ATTR(in0_max, S_IWUSR | S_IRUGO,
386  show_in_max, set_in_max, 0);
387 static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO,
388  show_in_max, set_in_max, 1);
389 static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO,
390  show_in_max, set_in_max, 2);
391 static SENSOR_DEVICE_ATTR(in3_max, S_IWUSR | S_IRUGO,
392  show_in_max, set_in_max, 3);
393 static SENSOR_DEVICE_ATTR(in4_max, S_IWUSR | S_IRUGO,
394  show_in_max, set_in_max, 4);
395 static SENSOR_DEVICE_ATTR(in5_max, S_IWUSR | S_IRUGO,
396  show_in_max, set_in_max, 5);
397 static SENSOR_DEVICE_ATTR(in6_max, S_IWUSR | S_IRUGO,
398  show_in_max, set_in_max, 6);
399 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in_input, NULL, 0);
400 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in_input, NULL, 1);
401 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in_input, NULL, 2);
402 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in_input, NULL, 3);
403 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in_input, NULL, 4);
404 static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_in_input, NULL, 5);
405 static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_in_input, NULL, 6);
406 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO,
407  show_fan_min, set_fan_min, 0);
408 static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO,
409  show_fan_min, set_fan_min, 1);
410 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0);
411 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1);
412 static SENSOR_DEVICE_ATTR(fan1_div, S_IWUSR | S_IRUGO,
413  show_fan_div, set_fan_div, 0);
414 static SENSOR_DEVICE_ATTR(fan2_div, S_IWUSR | S_IRUGO,
415  show_fan_div, set_fan_div, 1);
416 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input1, NULL);
417 static DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_hot_max,
418  set_temp_hot_max);
419 static DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, show_temp_hot_hyst,
420  set_temp_hot_hyst);
421 static DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp_os_max,
422  set_temp_os_max);
423 static DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temp_os_hyst,
424  set_temp_os_hyst);
425 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
426 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
427 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
428 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
429 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
430 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 4);
431 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 5);
432 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 6);
433 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 10);
434 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 11);
435 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 8);
436 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 13);
437 
438 /*
439  * Real code
440  */
441 
442 static struct attribute *lm80_attributes[] = {
443  &sensor_dev_attr_in0_min.dev_attr.attr,
444  &sensor_dev_attr_in1_min.dev_attr.attr,
445  &sensor_dev_attr_in2_min.dev_attr.attr,
446  &sensor_dev_attr_in3_min.dev_attr.attr,
447  &sensor_dev_attr_in4_min.dev_attr.attr,
448  &sensor_dev_attr_in5_min.dev_attr.attr,
449  &sensor_dev_attr_in6_min.dev_attr.attr,
450  &sensor_dev_attr_in0_max.dev_attr.attr,
451  &sensor_dev_attr_in1_max.dev_attr.attr,
452  &sensor_dev_attr_in2_max.dev_attr.attr,
453  &sensor_dev_attr_in3_max.dev_attr.attr,
454  &sensor_dev_attr_in4_max.dev_attr.attr,
455  &sensor_dev_attr_in5_max.dev_attr.attr,
456  &sensor_dev_attr_in6_max.dev_attr.attr,
457  &sensor_dev_attr_in0_input.dev_attr.attr,
458  &sensor_dev_attr_in1_input.dev_attr.attr,
459  &sensor_dev_attr_in2_input.dev_attr.attr,
460  &sensor_dev_attr_in3_input.dev_attr.attr,
461  &sensor_dev_attr_in4_input.dev_attr.attr,
462  &sensor_dev_attr_in5_input.dev_attr.attr,
463  &sensor_dev_attr_in6_input.dev_attr.attr,
464  &sensor_dev_attr_fan1_min.dev_attr.attr,
465  &sensor_dev_attr_fan2_min.dev_attr.attr,
466  &sensor_dev_attr_fan1_input.dev_attr.attr,
467  &sensor_dev_attr_fan2_input.dev_attr.attr,
468  &sensor_dev_attr_fan1_div.dev_attr.attr,
469  &sensor_dev_attr_fan2_div.dev_attr.attr,
470  &dev_attr_temp1_input.attr,
471  &dev_attr_temp1_max.attr,
472  &dev_attr_temp1_max_hyst.attr,
473  &dev_attr_temp1_crit.attr,
474  &dev_attr_temp1_crit_hyst.attr,
475  &dev_attr_alarms.attr,
476  &sensor_dev_attr_in0_alarm.dev_attr.attr,
477  &sensor_dev_attr_in1_alarm.dev_attr.attr,
478  &sensor_dev_attr_in2_alarm.dev_attr.attr,
479  &sensor_dev_attr_in3_alarm.dev_attr.attr,
480  &sensor_dev_attr_in4_alarm.dev_attr.attr,
481  &sensor_dev_attr_in5_alarm.dev_attr.attr,
482  &sensor_dev_attr_in6_alarm.dev_attr.attr,
483  &sensor_dev_attr_fan1_alarm.dev_attr.attr,
484  &sensor_dev_attr_fan2_alarm.dev_attr.attr,
485  &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
486  &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
487  NULL
488 };
489 
490 static const struct attribute_group lm80_group = {
491  .attrs = lm80_attributes,
492 };
493 
494 /* Return 0 if detection is successful, -ENODEV otherwise */
495 static int lm80_detect(struct i2c_client *client, struct i2c_board_info *info)
496 {
497  struct i2c_adapter *adapter = client->adapter;
498  int i, cur, man_id, dev_id;
499  const char *name = NULL;
500 
501  if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
502  return -ENODEV;
503 
504  /* First check for unused bits, common to both chip types */
505  if ((lm80_read_value(client, LM80_REG_ALARM2) & 0xc0)
506  || (lm80_read_value(client, LM80_REG_CONFIG) & 0x80))
507  return -ENODEV;
508 
509  /*
510  * The LM96080 has manufacturer and stepping/die rev registers so we
511  * can just check that. The LM80 does not have such registers so we
512  * have to use a more expensive trick.
513  */
514  man_id = lm80_read_value(client, LM96080_REG_MAN_ID);
515  dev_id = lm80_read_value(client, LM96080_REG_DEV_ID);
516  if (man_id == 0x01 && dev_id == 0x08) {
517  /* Check more unused bits for confirmation */
518  if (lm80_read_value(client, LM96080_REG_CONV_RATE) & 0xfe)
519  return -ENODEV;
520 
521  name = "lm96080";
522  } else {
523  /* Check 6-bit addressing */
524  for (i = 0x2a; i <= 0x3d; i++) {
525  cur = i2c_smbus_read_byte_data(client, i);
526  if ((i2c_smbus_read_byte_data(client, i + 0x40) != cur)
527  || (i2c_smbus_read_byte_data(client, i + 0x80) != cur)
528  || (i2c_smbus_read_byte_data(client, i + 0xc0) != cur))
529  return -ENODEV;
530  }
531 
532  name = "lm80";
533  }
534 
535  strlcpy(info->type, name, I2C_NAME_SIZE);
536 
537  return 0;
538 }
539 
540 static int lm80_probe(struct i2c_client *client,
541  const struct i2c_device_id *id)
542 {
543  struct lm80_data *data;
544  int err;
545 
546  data = devm_kzalloc(&client->dev, sizeof(struct lm80_data), GFP_KERNEL);
547  if (!data)
548  return -ENOMEM;
549 
550  i2c_set_clientdata(client, data);
551  mutex_init(&data->update_lock);
552 
553  /* Initialize the LM80 chip */
554  lm80_init_client(client);
555 
556  /* A few vars need to be filled upon startup */
557  data->fan_min[0] = lm80_read_value(client, LM80_REG_FAN_MIN(1));
558  data->fan_min[1] = lm80_read_value(client, LM80_REG_FAN_MIN(2));
559 
560  /* Register sysfs hooks */
561  err = sysfs_create_group(&client->dev.kobj, &lm80_group);
562  if (err)
563  return err;
564 
565  data->hwmon_dev = hwmon_device_register(&client->dev);
566  if (IS_ERR(data->hwmon_dev)) {
567  err = PTR_ERR(data->hwmon_dev);
568  goto error_remove;
569  }
570 
571  return 0;
572 
573 error_remove:
574  sysfs_remove_group(&client->dev.kobj, &lm80_group);
575  return err;
576 }
577 
578 static int lm80_remove(struct i2c_client *client)
579 {
580  struct lm80_data *data = i2c_get_clientdata(client);
581 
582  hwmon_device_unregister(data->hwmon_dev);
583  sysfs_remove_group(&client->dev.kobj, &lm80_group);
584 
585  return 0;
586 }
587 
588 static int lm80_read_value(struct i2c_client *client, u8 reg)
589 {
590  return i2c_smbus_read_byte_data(client, reg);
591 }
592 
593 static int lm80_write_value(struct i2c_client *client, u8 reg, u8 value)
594 {
595  return i2c_smbus_write_byte_data(client, reg, value);
596 }
597 
598 /* Called when we have found a new LM80. */
599 static void lm80_init_client(struct i2c_client *client)
600 {
601  /*
602  * Reset all except Watchdog values and last conversion values
603  * This sets fan-divs to 2, among others. This makes most other
604  * initializations unnecessary
605  */
606  lm80_write_value(client, LM80_REG_CONFIG, 0x80);
607  /* Set 11-bit temperature resolution */
608  lm80_write_value(client, LM80_REG_RES, 0x08);
609 
610  /* Start monitoring */
611  lm80_write_value(client, LM80_REG_CONFIG, 0x01);
612 }
613 
614 static struct lm80_data *lm80_update_device(struct device *dev)
615 {
616  struct i2c_client *client = to_i2c_client(dev);
617  struct lm80_data *data = i2c_get_clientdata(client);
618  int i;
619  int rv;
620  int prev_rv;
621  struct lm80_data *ret = data;
622 
623  mutex_lock(&data->update_lock);
624 
625  if (data->error)
626  lm80_init_client(client);
627 
628  if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
629  dev_dbg(&client->dev, "Starting lm80 update\n");
630  for (i = 0; i <= 6; i++) {
631  rv = lm80_read_value(client, LM80_REG_IN(i));
632  if (rv < 0)
633  goto abort;
634  data->in[i] = rv;
635 
636  rv = lm80_read_value(client, LM80_REG_IN_MIN(i));
637  if (rv < 0)
638  goto abort;
639  data->in_min[i] = rv;
640 
641  rv = lm80_read_value(client, LM80_REG_IN_MAX(i));
642  if (rv < 0)
643  goto abort;
644  data->in_max[i] = rv;
645  }
646 
647  rv = lm80_read_value(client, LM80_REG_FAN1);
648  if (rv < 0)
649  goto abort;
650  data->fan[0] = rv;
651 
652  rv = lm80_read_value(client, LM80_REG_FAN_MIN(1));
653  if (rv < 0)
654  goto abort;
655  data->fan_min[0] = rv;
656 
657  rv = lm80_read_value(client, LM80_REG_FAN2);
658  if (rv < 0)
659  goto abort;
660  data->fan[1] = rv;
661 
662  rv = lm80_read_value(client, LM80_REG_FAN_MIN(2));
663  if (rv < 0)
664  goto abort;
665  data->fan_min[1] = rv;
666 
667  prev_rv = rv = lm80_read_value(client, LM80_REG_TEMP);
668  if (rv < 0)
669  goto abort;
670  rv = lm80_read_value(client, LM80_REG_RES);
671  if (rv < 0)
672  goto abort;
673  data->temp = (prev_rv << 8) | (rv & 0xf0);
674 
675  rv = lm80_read_value(client, LM80_REG_TEMP_OS_MAX);
676  if (rv < 0)
677  goto abort;
678  data->temp_os_max = rv;
679 
680  rv = lm80_read_value(client, LM80_REG_TEMP_OS_HYST);
681  if (rv < 0)
682  goto abort;
683  data->temp_os_hyst = rv;
684 
685  rv = lm80_read_value(client, LM80_REG_TEMP_HOT_MAX);
686  if (rv < 0)
687  goto abort;
688  data->temp_hot_max = rv;
689 
690  rv = lm80_read_value(client, LM80_REG_TEMP_HOT_HYST);
691  if (rv < 0)
692  goto abort;
693  data->temp_hot_hyst = rv;
694 
695  rv = lm80_read_value(client, LM80_REG_FANDIV);
696  if (rv < 0)
697  goto abort;
698  data->fan_div[0] = (rv >> 2) & 0x03;
699  data->fan_div[1] = (rv >> 4) & 0x03;
700 
701  prev_rv = rv = lm80_read_value(client, LM80_REG_ALARM1);
702  if (rv < 0)
703  goto abort;
704  rv = lm80_read_value(client, LM80_REG_ALARM2);
705  if (rv < 0)
706  goto abort;
707  data->alarms = prev_rv + (rv << 8);
708 
709  data->last_updated = jiffies;
710  data->valid = 1;
711  data->error = 0;
712  }
713  goto done;
714 
715 abort:
716  ret = ERR_PTR(rv);
717  data->valid = 0;
718  data->error = 1;
719 
720 done:
721  mutex_unlock(&data->update_lock);
722 
723  return ret;
724 }
725 
726 module_i2c_driver(lm80_driver);
727 
728 MODULE_AUTHOR("Frodo Looijaard <[email protected]> and "
729  "Philip Edelbrock <[email protected]>");
730 MODULE_DESCRIPTION("LM80 driver");
731 MODULE_LICENSE("GPL");
Generated on Thu Jan 10 2013 13:34:59 for Linux Kernel by   doxygen 1.8.2