Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
adm1031.c
Go to the documentation of this file.
1 /*
2  * adm1031.c - Part of lm_sensors, Linux kernel modules for hardware
3  * monitoring
4  * Based on lm75.c and lm85.c
5  * Supports adm1030 / adm1031
6  * Copyright (C) 2004 Alexandre d'Alton <[email protected]>
7  * Reworked by Jean Delvare <[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 /* Following macros takes channel parameter starting from 0 to 2 */
35 #define ADM1031_REG_FAN_SPEED(nr) (0x08 + (nr))
36 #define ADM1031_REG_FAN_DIV(nr) (0x20 + (nr))
37 #define ADM1031_REG_PWM (0x22)
38 #define ADM1031_REG_FAN_MIN(nr) (0x10 + (nr))
39 #define ADM1031_REG_FAN_FILTER (0x23)
40 
41 #define ADM1031_REG_TEMP_OFFSET(nr) (0x0d + (nr))
42 #define ADM1031_REG_TEMP_MAX(nr) (0x14 + 4 * (nr))
43 #define ADM1031_REG_TEMP_MIN(nr) (0x15 + 4 * (nr))
44 #define ADM1031_REG_TEMP_CRIT(nr) (0x16 + 4 * (nr))
45 
46 #define ADM1031_REG_TEMP(nr) (0x0a + (nr))
47 #define ADM1031_REG_AUTO_TEMP(nr) (0x24 + (nr))
48 
49 #define ADM1031_REG_STATUS(nr) (0x2 + (nr))
50 
51 #define ADM1031_REG_CONF1 0x00
52 #define ADM1031_REG_CONF2 0x01
53 #define ADM1031_REG_EXT_TEMP 0x06
54 
55 #define ADM1031_CONF1_MONITOR_ENABLE 0x01 /* Monitoring enable */
56 #define ADM1031_CONF1_PWM_INVERT 0x08 /* PWM Invert */
57 #define ADM1031_CONF1_AUTO_MODE 0x80 /* Auto FAN */
58 
59 #define ADM1031_CONF2_PWM1_ENABLE 0x01
60 #define ADM1031_CONF2_PWM2_ENABLE 0x02
61 #define ADM1031_CONF2_TACH1_ENABLE 0x04
62 #define ADM1031_CONF2_TACH2_ENABLE 0x08
63 #define ADM1031_CONF2_TEMP_ENABLE(chan) (0x10 << (chan))
64 
65 #define ADM1031_UPDATE_RATE_MASK 0x1c
66 #define ADM1031_UPDATE_RATE_SHIFT 2
67 
68 /* Addresses to scan */
69 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
70 
71 enum chips { adm1030, adm1031 };
72 
73 typedef u8 auto_chan_table_t[8][2];
74 
75 /* Each client has this additional data */
76 struct adm1031_data {
77  struct device *hwmon_dev;
78  struct mutex update_lock;
79  int chip_type;
80  char valid; /* !=0 if following fields are valid */
81  unsigned long last_updated; /* In jiffies */
82  unsigned int update_interval; /* In milliseconds */
83  /*
84  * The chan_select_table contains the possible configurations for
85  * auto fan control.
86  */
87  const auto_chan_table_t *chan_select_table;
88  u16 alarm;
89  u8 conf1;
90  u8 conf2;
91  u8 fan[2];
92  u8 fan_div[2];
93  u8 fan_min[2];
94  u8 pwm[2];
95  u8 old_pwm[2];
96  s8 temp[3];
97  u8 ext_temp[3];
98  u8 auto_temp[3];
99  u8 auto_temp_min[3];
100  u8 auto_temp_off[3];
101  u8 auto_temp_max[3];
102  s8 temp_offset[3];
103  s8 temp_min[3];
104  s8 temp_max[3];
105  s8 temp_crit[3];
106 };
107 
108 static int adm1031_probe(struct i2c_client *client,
109  const struct i2c_device_id *id);
110 static int adm1031_detect(struct i2c_client *client,
111  struct i2c_board_info *info);
112 static void adm1031_init_client(struct i2c_client *client);
113 static int adm1031_remove(struct i2c_client *client);
114 static struct adm1031_data *adm1031_update_device(struct device *dev);
115 
116 static const struct i2c_device_id adm1031_id[] = {
117  { "adm1030", adm1030 },
118  { "adm1031", adm1031 },
119  { }
120 };
121 MODULE_DEVICE_TABLE(i2c, adm1031_id);
122 
123 /* This is the driver that will be inserted */
124 static struct i2c_driver adm1031_driver = {
125  .class = I2C_CLASS_HWMON,
126  .driver = {
127  .name = "adm1031",
128  },
129  .probe = adm1031_probe,
130  .remove = adm1031_remove,
131  .id_table = adm1031_id,
132  .detect = adm1031_detect,
133  .address_list = normal_i2c,
134 };
135 
136 static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg)
137 {
138  return i2c_smbus_read_byte_data(client, reg);
139 }
140 
141 static inline int
142 adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value)
143 {
144  return i2c_smbus_write_byte_data(client, reg, value);
145 }
146 
147 
148 #define TEMP_TO_REG(val) (((val) < 0 ? ((val - 500) / 1000) : \
149  ((val + 500) / 1000)))
150 
151 #define TEMP_FROM_REG(val) ((val) * 1000)
152 
153 #define TEMP_FROM_REG_EXT(val, ext) (TEMP_FROM_REG(val) + (ext) * 125)
154 
155 #define TEMP_OFFSET_TO_REG(val) (TEMP_TO_REG(val) & 0x8f)
156 #define TEMP_OFFSET_FROM_REG(val) TEMP_FROM_REG((val) < 0 ? \
157  (val) | 0x70 : (val))
158 
159 #define FAN_FROM_REG(reg, div) ((reg) ? \
160  (11250 * 60) / ((reg) * (div)) : 0)
161 
162 static int FAN_TO_REG(int reg, int div)
163 {
164  int tmp;
165  tmp = FAN_FROM_REG(SENSORS_LIMIT(reg, 0, 65535), div);
166  return tmp > 255 ? 255 : tmp;
167 }
168 
169 #define FAN_DIV_FROM_REG(reg) (1<<(((reg)&0xc0)>>6))
170 
171 #define PWM_TO_REG(val) (SENSORS_LIMIT((val), 0, 255) >> 4)
172 #define PWM_FROM_REG(val) ((val) << 4)
173 
174 #define FAN_CHAN_FROM_REG(reg) (((reg) >> 5) & 7)
175 #define FAN_CHAN_TO_REG(val, reg) \
176  (((reg) & 0x1F) | (((val) << 5) & 0xe0))
177 
178 #define AUTO_TEMP_MIN_TO_REG(val, reg) \
179  ((((val) / 500) & 0xf8) | ((reg) & 0x7))
180 #define AUTO_TEMP_RANGE_FROM_REG(reg) (5000 * (1 << ((reg) & 0x7)))
181 #define AUTO_TEMP_MIN_FROM_REG(reg) (1000 * ((((reg) >> 3) & 0x1f) << 2))
182 
183 #define AUTO_TEMP_MIN_FROM_REG_DEG(reg) ((((reg) >> 3) & 0x1f) << 2)
184 
185 #define AUTO_TEMP_OFF_FROM_REG(reg) \
186  (AUTO_TEMP_MIN_FROM_REG(reg) - 5000)
187 
188 #define AUTO_TEMP_MAX_FROM_REG(reg) \
189  (AUTO_TEMP_RANGE_FROM_REG(reg) + \
190  AUTO_TEMP_MIN_FROM_REG(reg))
191 
192 static int AUTO_TEMP_MAX_TO_REG(int val, int reg, int pwm)
193 {
194  int ret;
195  int range = val - AUTO_TEMP_MIN_FROM_REG(reg);
196 
197  range = ((val - AUTO_TEMP_MIN_FROM_REG(reg))*10)/(16 - pwm);
198  ret = ((reg & 0xf8) |
199  (range < 10000 ? 0 :
200  range < 20000 ? 1 :
201  range < 40000 ? 2 : range < 80000 ? 3 : 4));
202  return ret;
203 }
204 
205 /* FAN auto control */
206 #define GET_FAN_AUTO_BITFIELD(data, idx) \
207  (*(data)->chan_select_table)[FAN_CHAN_FROM_REG((data)->conf1)][idx % 2]
208 
209 /*
210  * The tables below contains the possible values for the auto fan
211  * control bitfields. the index in the table is the register value.
212  * MSb is the auto fan control enable bit, so the four first entries
213  * in the table disables auto fan control when both bitfields are zero.
214  */
215 static const auto_chan_table_t auto_channel_select_table_adm1031 = {
216  { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
217  { 2 /* 0b010 */ , 4 /* 0b100 */ },
218  { 2 /* 0b010 */ , 2 /* 0b010 */ },
219  { 4 /* 0b100 */ , 4 /* 0b100 */ },
220  { 7 /* 0b111 */ , 7 /* 0b111 */ },
221 };
222 
223 static const auto_chan_table_t auto_channel_select_table_adm1030 = {
224  { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
225  { 2 /* 0b10 */ , 0 },
226  { 0xff /* invalid */ , 0 },
227  { 0xff /* invalid */ , 0 },
228  { 3 /* 0b11 */ , 0 },
229 };
230 
231 /*
232  * That function checks if a bitfield is valid and returns the other bitfield
233  * nearest match if no exact match where found.
234  */
235 static int
236 get_fan_auto_nearest(struct adm1031_data *data, int chan, u8 val, u8 reg)
237 {
238  int i;
239  int first_match = -1, exact_match = -1;
240  u8 other_reg_val =
241  (*data->chan_select_table)[FAN_CHAN_FROM_REG(reg)][chan ? 0 : 1];
242 
243  if (val == 0)
244  return 0;
245 
246  for (i = 0; i < 8; i++) {
247  if ((val == (*data->chan_select_table)[i][chan]) &&
248  ((*data->chan_select_table)[i][chan ? 0 : 1] ==
249  other_reg_val)) {
250  /* We found an exact match */
251  exact_match = i;
252  break;
253  } else if (val == (*data->chan_select_table)[i][chan] &&
254  first_match == -1) {
255  /*
256  * Save the first match in case of an exact match has
257  * not been found
258  */
259  first_match = i;
260  }
261  }
262 
263  if (exact_match >= 0)
264  return exact_match;
265  else if (first_match >= 0)
266  return first_match;
267 
268  return -EINVAL;
269 }
270 
271 static ssize_t show_fan_auto_channel(struct device *dev,
272  struct device_attribute *attr, char *buf)
273 {
274  int nr = to_sensor_dev_attr(attr)->index;
275  struct adm1031_data *data = adm1031_update_device(dev);
276  return sprintf(buf, "%d\n", GET_FAN_AUTO_BITFIELD(data, nr));
277 }
278 
279 static ssize_t
280 set_fan_auto_channel(struct device *dev, struct device_attribute *attr,
281  const char *buf, size_t count)
282 {
283  struct i2c_client *client = to_i2c_client(dev);
284  struct adm1031_data *data = i2c_get_clientdata(client);
285  int nr = to_sensor_dev_attr(attr)->index;
286  long val;
287  u8 reg;
288  int ret;
289  u8 old_fan_mode;
290 
291  ret = kstrtol(buf, 10, &val);
292  if (ret)
293  return ret;
294 
295  old_fan_mode = data->conf1;
296 
297  mutex_lock(&data->update_lock);
298 
299  ret = get_fan_auto_nearest(data, nr, val, data->conf1);
300  if (ret < 0) {
301  mutex_unlock(&data->update_lock);
302  return ret;
303  }
304  reg = ret;
305  data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
306  if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) ^
307  (old_fan_mode & ADM1031_CONF1_AUTO_MODE)) {
308  if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
309  /*
310  * Switch to Auto Fan Mode
311  * Save PWM registers
312  * Set PWM registers to 33% Both
313  */
314  data->old_pwm[0] = data->pwm[0];
315  data->old_pwm[1] = data->pwm[1];
316  adm1031_write_value(client, ADM1031_REG_PWM, 0x55);
317  } else {
318  /* Switch to Manual Mode */
319  data->pwm[0] = data->old_pwm[0];
320  data->pwm[1] = data->old_pwm[1];
321  /* Restore PWM registers */
322  adm1031_write_value(client, ADM1031_REG_PWM,
323  data->pwm[0] | (data->pwm[1] << 4));
324  }
325  }
326  data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
327  adm1031_write_value(client, ADM1031_REG_CONF1, data->conf1);
328  mutex_unlock(&data->update_lock);
329  return count;
330 }
331 
332 static SENSOR_DEVICE_ATTR(auto_fan1_channel, S_IRUGO | S_IWUSR,
333  show_fan_auto_channel, set_fan_auto_channel, 0);
334 static SENSOR_DEVICE_ATTR(auto_fan2_channel, S_IRUGO | S_IWUSR,
335  show_fan_auto_channel, set_fan_auto_channel, 1);
336 
337 /* Auto Temps */
338 static ssize_t show_auto_temp_off(struct device *dev,
339  struct device_attribute *attr, char *buf)
340 {
341  int nr = to_sensor_dev_attr(attr)->index;
342  struct adm1031_data *data = adm1031_update_device(dev);
343  return sprintf(buf, "%d\n",
344  AUTO_TEMP_OFF_FROM_REG(data->auto_temp[nr]));
345 }
346 static ssize_t show_auto_temp_min(struct device *dev,
347  struct device_attribute *attr, char *buf)
348 {
349  int nr = to_sensor_dev_attr(attr)->index;
350  struct adm1031_data *data = adm1031_update_device(dev);
351  return sprintf(buf, "%d\n",
352  AUTO_TEMP_MIN_FROM_REG(data->auto_temp[nr]));
353 }
354 static ssize_t
355 set_auto_temp_min(struct device *dev, struct device_attribute *attr,
356  const char *buf, size_t count)
357 {
358  struct i2c_client *client = to_i2c_client(dev);
359  struct adm1031_data *data = i2c_get_clientdata(client);
360  int nr = to_sensor_dev_attr(attr)->index;
361  long val;
362  int ret;
363 
364  ret = kstrtol(buf, 10, &val);
365  if (ret)
366  return ret;
367 
368  mutex_lock(&data->update_lock);
369  data->auto_temp[nr] = AUTO_TEMP_MIN_TO_REG(val, data->auto_temp[nr]);
370  adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
371  data->auto_temp[nr]);
372  mutex_unlock(&data->update_lock);
373  return count;
374 }
375 static ssize_t show_auto_temp_max(struct device *dev,
376  struct device_attribute *attr, char *buf)
377 {
378  int nr = to_sensor_dev_attr(attr)->index;
379  struct adm1031_data *data = adm1031_update_device(dev);
380  return sprintf(buf, "%d\n",
381  AUTO_TEMP_MAX_FROM_REG(data->auto_temp[nr]));
382 }
383 static ssize_t
384 set_auto_temp_max(struct device *dev, struct device_attribute *attr,
385  const char *buf, size_t count)
386 {
387  struct i2c_client *client = to_i2c_client(dev);
388  struct adm1031_data *data = i2c_get_clientdata(client);
389  int nr = to_sensor_dev_attr(attr)->index;
390  long val;
391  int ret;
392 
393  ret = kstrtol(buf, 10, &val);
394  if (ret)
395  return ret;
396 
397  mutex_lock(&data->update_lock);
398  data->temp_max[nr] = AUTO_TEMP_MAX_TO_REG(val, data->auto_temp[nr],
399  data->pwm[nr]);
400  adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
401  data->temp_max[nr]);
402  mutex_unlock(&data->update_lock);
403  return count;
404 }
405 
406 #define auto_temp_reg(offset) \
407 static SENSOR_DEVICE_ATTR(auto_temp##offset##_off, S_IRUGO, \
408  show_auto_temp_off, NULL, offset - 1); \
409 static SENSOR_DEVICE_ATTR(auto_temp##offset##_min, S_IRUGO | S_IWUSR, \
410  show_auto_temp_min, set_auto_temp_min, offset - 1); \
411 static SENSOR_DEVICE_ATTR(auto_temp##offset##_max, S_IRUGO | S_IWUSR, \
412  show_auto_temp_max, set_auto_temp_max, offset - 1)
413 
414 auto_temp_reg(1);
415 auto_temp_reg(2);
416 auto_temp_reg(3);
417 
418 /* pwm */
419 static ssize_t show_pwm(struct device *dev,
420  struct device_attribute *attr, char *buf)
421 {
422  int nr = to_sensor_dev_attr(attr)->index;
423  struct adm1031_data *data = adm1031_update_device(dev);
424  return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
425 }
426 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
427  const char *buf, size_t count)
428 {
429  struct i2c_client *client = to_i2c_client(dev);
430  struct adm1031_data *data = i2c_get_clientdata(client);
431  int nr = to_sensor_dev_attr(attr)->index;
432  long val;
433  int ret, reg;
434 
435  ret = kstrtol(buf, 10, &val);
436  if (ret)
437  return ret;
438 
439  mutex_lock(&data->update_lock);
440  if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) &&
441  (((val>>4) & 0xf) != 5)) {
442  /* In automatic mode, the only PWM accepted is 33% */
443  mutex_unlock(&data->update_lock);
444  return -EINVAL;
445  }
446  data->pwm[nr] = PWM_TO_REG(val);
447  reg = adm1031_read_value(client, ADM1031_REG_PWM);
448  adm1031_write_value(client, ADM1031_REG_PWM,
449  nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf)
450  : (data->pwm[nr] & 0xf) | (reg & 0xf0));
451  mutex_unlock(&data->update_lock);
452  return count;
453 }
454 
455 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 0);
456 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 1);
457 static SENSOR_DEVICE_ATTR(auto_fan1_min_pwm, S_IRUGO | S_IWUSR,
458  show_pwm, set_pwm, 0);
459 static SENSOR_DEVICE_ATTR(auto_fan2_min_pwm, S_IRUGO | S_IWUSR,
460  show_pwm, set_pwm, 1);
461 
462 /* Fans */
463 
464 /*
465  * That function checks the cases where the fan reading is not
466  * relevant. It is used to provide 0 as fan reading when the fan is
467  * not supposed to run
468  */
469 static int trust_fan_readings(struct adm1031_data *data, int chan)
470 {
471  int res = 0;
472 
473  if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
474  switch (data->conf1 & 0x60) {
475  case 0x00:
476  /*
477  * remote temp1 controls fan1,
478  * remote temp2 controls fan2
479  */
480  res = data->temp[chan+1] >=
481  AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[chan+1]);
482  break;
483  case 0x20: /* remote temp1 controls both fans */
484  res =
485  data->temp[1] >=
486  AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]);
487  break;
488  case 0x40: /* remote temp2 controls both fans */
489  res =
490  data->temp[2] >=
491  AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]);
492  break;
493  case 0x60: /* max controls both fans */
494  res =
495  data->temp[0] >=
496  AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[0])
497  || data->temp[1] >=
498  AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1])
499  || (data->chip_type == adm1031
500  && data->temp[2] >=
501  AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]));
502  break;
503  }
504  } else {
505  res = data->pwm[chan] > 0;
506  }
507  return res;
508 }
509 
510 
511 static ssize_t show_fan(struct device *dev,
512  struct device_attribute *attr, char *buf)
513 {
514  int nr = to_sensor_dev_attr(attr)->index;
515  struct adm1031_data *data = adm1031_update_device(dev);
516  int value;
517 
518  value = trust_fan_readings(data, nr) ? FAN_FROM_REG(data->fan[nr],
519  FAN_DIV_FROM_REG(data->fan_div[nr])) : 0;
520  return sprintf(buf, "%d\n", value);
521 }
522 
523 static ssize_t show_fan_div(struct device *dev,
524  struct device_attribute *attr, char *buf)
525 {
526  int nr = to_sensor_dev_attr(attr)->index;
527  struct adm1031_data *data = adm1031_update_device(dev);
528  return sprintf(buf, "%d\n", FAN_DIV_FROM_REG(data->fan_div[nr]));
529 }
530 static ssize_t show_fan_min(struct device *dev,
531  struct device_attribute *attr, char *buf)
532 {
533  int nr = to_sensor_dev_attr(attr)->index;
534  struct adm1031_data *data = adm1031_update_device(dev);
535  return sprintf(buf, "%d\n",
536  FAN_FROM_REG(data->fan_min[nr],
537  FAN_DIV_FROM_REG(data->fan_div[nr])));
538 }
539 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
540  const char *buf, size_t count)
541 {
542  struct i2c_client *client = to_i2c_client(dev);
543  struct adm1031_data *data = i2c_get_clientdata(client);
544  int nr = to_sensor_dev_attr(attr)->index;
545  long val;
546  int ret;
547 
548  ret = kstrtol(buf, 10, &val);
549  if (ret)
550  return ret;
551 
552  mutex_lock(&data->update_lock);
553  if (val) {
554  data->fan_min[nr] =
555  FAN_TO_REG(val, FAN_DIV_FROM_REG(data->fan_div[nr]));
556  } else {
557  data->fan_min[nr] = 0xff;
558  }
559  adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), data->fan_min[nr]);
560  mutex_unlock(&data->update_lock);
561  return count;
562 }
563 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
564  const char *buf, size_t count)
565 {
566  struct i2c_client *client = to_i2c_client(dev);
567  struct adm1031_data *data = i2c_get_clientdata(client);
568  int nr = to_sensor_dev_attr(attr)->index;
569  long val;
570  u8 tmp;
571  int old_div;
572  int new_min;
573  int ret;
574 
575  ret = kstrtol(buf, 10, &val);
576  if (ret)
577  return ret;
578 
579  tmp = val == 8 ? 0xc0 :
580  val == 4 ? 0x80 :
581  val == 2 ? 0x40 :
582  val == 1 ? 0x00 :
583  0xff;
584  if (tmp == 0xff)
585  return -EINVAL;
586 
587  mutex_lock(&data->update_lock);
588  /* Get fresh readings */
589  data->fan_div[nr] = adm1031_read_value(client,
590  ADM1031_REG_FAN_DIV(nr));
591  data->fan_min[nr] = adm1031_read_value(client,
592  ADM1031_REG_FAN_MIN(nr));
593 
594  /* Write the new clock divider and fan min */
595  old_div = FAN_DIV_FROM_REG(data->fan_div[nr]);
596  data->fan_div[nr] = tmp | (0x3f & data->fan_div[nr]);
597  new_min = data->fan_min[nr] * old_div / val;
598  data->fan_min[nr] = new_min > 0xff ? 0xff : new_min;
599 
600  adm1031_write_value(client, ADM1031_REG_FAN_DIV(nr),
601  data->fan_div[nr]);
602  adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr),
603  data->fan_min[nr]);
604 
605  /* Invalidate the cache: fan speed is no longer valid */
606  data->valid = 0;
607  mutex_unlock(&data->update_lock);
608  return count;
609 }
610 
611 #define fan_offset(offset) \
612 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
613  show_fan, NULL, offset - 1); \
614 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
615  show_fan_min, set_fan_min, offset - 1); \
616 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
617  show_fan_div, set_fan_div, offset - 1)
618 
619 fan_offset(1);
620 fan_offset(2);
621 
622 
623 /* Temps */
624 static ssize_t show_temp(struct device *dev,
625  struct device_attribute *attr, char *buf)
626 {
627  int nr = to_sensor_dev_attr(attr)->index;
628  struct adm1031_data *data = adm1031_update_device(dev);
629  int ext;
630  ext = nr == 0 ?
631  ((data->ext_temp[nr] >> 6) & 0x3) * 2 :
632  (((data->ext_temp[nr] >> ((nr - 1) * 3)) & 7));
633  return sprintf(buf, "%d\n", TEMP_FROM_REG_EXT(data->temp[nr], ext));
634 }
635 static ssize_t show_temp_offset(struct device *dev,
636  struct device_attribute *attr, char *buf)
637 {
638  int nr = to_sensor_dev_attr(attr)->index;
639  struct adm1031_data *data = adm1031_update_device(dev);
640  return sprintf(buf, "%d\n",
641  TEMP_OFFSET_FROM_REG(data->temp_offset[nr]));
642 }
643 static ssize_t show_temp_min(struct device *dev,
644  struct device_attribute *attr, char *buf)
645 {
646  int nr = to_sensor_dev_attr(attr)->index;
647  struct adm1031_data *data = adm1031_update_device(dev);
648  return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
649 }
650 static ssize_t show_temp_max(struct device *dev,
651  struct device_attribute *attr, char *buf)
652 {
653  int nr = to_sensor_dev_attr(attr)->index;
654  struct adm1031_data *data = adm1031_update_device(dev);
655  return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
656 }
657 static ssize_t show_temp_crit(struct device *dev,
658  struct device_attribute *attr, char *buf)
659 {
660  int nr = to_sensor_dev_attr(attr)->index;
661  struct adm1031_data *data = adm1031_update_device(dev);
662  return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr]));
663 }
664 static ssize_t set_temp_offset(struct device *dev,
665  struct device_attribute *attr, const char *buf,
666  size_t count)
667 {
668  struct i2c_client *client = to_i2c_client(dev);
669  struct adm1031_data *data = i2c_get_clientdata(client);
670  int nr = to_sensor_dev_attr(attr)->index;
671  long val;
672  int ret;
673 
674  ret = kstrtol(buf, 10, &val);
675  if (ret)
676  return ret;
677 
678  val = SENSORS_LIMIT(val, -15000, 15000);
679  mutex_lock(&data->update_lock);
680  data->temp_offset[nr] = TEMP_OFFSET_TO_REG(val);
681  adm1031_write_value(client, ADM1031_REG_TEMP_OFFSET(nr),
682  data->temp_offset[nr]);
683  mutex_unlock(&data->update_lock);
684  return count;
685 }
686 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
687  const char *buf, size_t count)
688 {
689  struct i2c_client *client = to_i2c_client(dev);
690  struct adm1031_data *data = i2c_get_clientdata(client);
691  int nr = to_sensor_dev_attr(attr)->index;
692  long val;
693  int ret;
694 
695  ret = kstrtol(buf, 10, &val);
696  if (ret)
697  return ret;
698 
699  val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
700  mutex_lock(&data->update_lock);
701  data->temp_min[nr] = TEMP_TO_REG(val);
702  adm1031_write_value(client, ADM1031_REG_TEMP_MIN(nr),
703  data->temp_min[nr]);
704  mutex_unlock(&data->update_lock);
705  return count;
706 }
707 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
708  const char *buf, size_t count)
709 {
710  struct i2c_client *client = to_i2c_client(dev);
711  struct adm1031_data *data = i2c_get_clientdata(client);
712  int nr = to_sensor_dev_attr(attr)->index;
713  long val;
714  int ret;
715 
716  ret = kstrtol(buf, 10, &val);
717  if (ret)
718  return ret;
719 
720  val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
721  mutex_lock(&data->update_lock);
722  data->temp_max[nr] = TEMP_TO_REG(val);
723  adm1031_write_value(client, ADM1031_REG_TEMP_MAX(nr),
724  data->temp_max[nr]);
725  mutex_unlock(&data->update_lock);
726  return count;
727 }
728 static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr,
729  const char *buf, size_t count)
730 {
731  struct i2c_client *client = to_i2c_client(dev);
732  struct adm1031_data *data = i2c_get_clientdata(client);
733  int nr = to_sensor_dev_attr(attr)->index;
734  long val;
735  int ret;
736 
737  ret = kstrtol(buf, 10, &val);
738  if (ret)
739  return ret;
740 
741  val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
742  mutex_lock(&data->update_lock);
743  data->temp_crit[nr] = TEMP_TO_REG(val);
744  adm1031_write_value(client, ADM1031_REG_TEMP_CRIT(nr),
745  data->temp_crit[nr]);
746  mutex_unlock(&data->update_lock);
747  return count;
748 }
749 
750 #define temp_reg(offset) \
751 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
752  show_temp, NULL, offset - 1); \
753 static SENSOR_DEVICE_ATTR(temp##offset##_offset, S_IRUGO | S_IWUSR, \
754  show_temp_offset, set_temp_offset, offset - 1); \
755 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \
756  show_temp_min, set_temp_min, offset - 1); \
757 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \
758  show_temp_max, set_temp_max, offset - 1); \
759 static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO | S_IWUSR, \
760  show_temp_crit, set_temp_crit, offset - 1)
761 
762 temp_reg(1);
763 temp_reg(2);
764 temp_reg(3);
765 
766 /* Alarms */
767 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr,
768  char *buf)
769 {
770  struct adm1031_data *data = adm1031_update_device(dev);
771  return sprintf(buf, "%d\n", data->alarm);
772 }
773 
774 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
775 
776 static ssize_t show_alarm(struct device *dev,
777  struct device_attribute *attr, char *buf)
778 {
779  int bitnr = to_sensor_dev_attr(attr)->index;
780  struct adm1031_data *data = adm1031_update_device(dev);
781  return sprintf(buf, "%d\n", (data->alarm >> bitnr) & 1);
782 }
783 
784 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0);
785 static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_alarm, NULL, 1);
786 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 2);
787 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
788 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 4);
789 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 5);
790 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
791 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 7);
792 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 8);
793 static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_alarm, NULL, 9);
794 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 10);
795 static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 11);
796 static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 12);
797 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 13);
798 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 14);
799 
800 /* Update Interval */
801 static const unsigned int update_intervals[] = {
802  16000, 8000, 4000, 2000, 1000, 500, 250, 125,
803 };
804 
805 static ssize_t show_update_interval(struct device *dev,
806  struct device_attribute *attr, char *buf)
807 {
808  struct i2c_client *client = to_i2c_client(dev);
809  struct adm1031_data *data = i2c_get_clientdata(client);
810 
811  return sprintf(buf, "%u\n", data->update_interval);
812 }
813 
814 static ssize_t set_update_interval(struct device *dev,
815  struct device_attribute *attr,
816  const char *buf, size_t count)
817 {
818  struct i2c_client *client = to_i2c_client(dev);
819  struct adm1031_data *data = i2c_get_clientdata(client);
820  unsigned long val;
821  int i, err;
822  u8 reg;
823 
824  err = kstrtoul(buf, 10, &val);
825  if (err)
826  return err;
827 
828  /*
829  * Find the nearest update interval from the table.
830  * Use it to determine the matching update rate.
831  */
832  for (i = 0; i < ARRAY_SIZE(update_intervals) - 1; i++) {
833  if (val >= update_intervals[i])
834  break;
835  }
836  /* if not found, we point to the last entry (lowest update interval) */
837 
838  /* set the new update rate while preserving other settings */
839  reg = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
840  reg &= ~ADM1031_UPDATE_RATE_MASK;
841  reg |= i << ADM1031_UPDATE_RATE_SHIFT;
842  adm1031_write_value(client, ADM1031_REG_FAN_FILTER, reg);
843 
844  mutex_lock(&data->update_lock);
845  data->update_interval = update_intervals[i];
846  mutex_unlock(&data->update_lock);
847 
848  return count;
849 }
850 
851 static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval,
852  set_update_interval);
853 
854 static struct attribute *adm1031_attributes[] = {
855  &sensor_dev_attr_fan1_input.dev_attr.attr,
856  &sensor_dev_attr_fan1_div.dev_attr.attr,
857  &sensor_dev_attr_fan1_min.dev_attr.attr,
858  &sensor_dev_attr_fan1_alarm.dev_attr.attr,
859  &sensor_dev_attr_fan1_fault.dev_attr.attr,
860  &sensor_dev_attr_pwm1.dev_attr.attr,
861  &sensor_dev_attr_auto_fan1_channel.dev_attr.attr,
862  &sensor_dev_attr_temp1_input.dev_attr.attr,
863  &sensor_dev_attr_temp1_offset.dev_attr.attr,
864  &sensor_dev_attr_temp1_min.dev_attr.attr,
865  &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
866  &sensor_dev_attr_temp1_max.dev_attr.attr,
867  &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
868  &sensor_dev_attr_temp1_crit.dev_attr.attr,
869  &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
870  &sensor_dev_attr_temp2_input.dev_attr.attr,
871  &sensor_dev_attr_temp2_offset.dev_attr.attr,
872  &sensor_dev_attr_temp2_min.dev_attr.attr,
873  &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
874  &sensor_dev_attr_temp2_max.dev_attr.attr,
875  &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
876  &sensor_dev_attr_temp2_crit.dev_attr.attr,
877  &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
878  &sensor_dev_attr_temp2_fault.dev_attr.attr,
879 
880  &sensor_dev_attr_auto_temp1_off.dev_attr.attr,
881  &sensor_dev_attr_auto_temp1_min.dev_attr.attr,
882  &sensor_dev_attr_auto_temp1_max.dev_attr.attr,
883 
884  &sensor_dev_attr_auto_temp2_off.dev_attr.attr,
885  &sensor_dev_attr_auto_temp2_min.dev_attr.attr,
886  &sensor_dev_attr_auto_temp2_max.dev_attr.attr,
887 
888  &sensor_dev_attr_auto_fan1_min_pwm.dev_attr.attr,
889 
890  &dev_attr_update_interval.attr,
891  &dev_attr_alarms.attr,
892 
893  NULL
894 };
895 
896 static const struct attribute_group adm1031_group = {
897  .attrs = adm1031_attributes,
898 };
899 
900 static struct attribute *adm1031_attributes_opt[] = {
901  &sensor_dev_attr_fan2_input.dev_attr.attr,
902  &sensor_dev_attr_fan2_div.dev_attr.attr,
903  &sensor_dev_attr_fan2_min.dev_attr.attr,
904  &sensor_dev_attr_fan2_alarm.dev_attr.attr,
905  &sensor_dev_attr_fan2_fault.dev_attr.attr,
906  &sensor_dev_attr_pwm2.dev_attr.attr,
907  &sensor_dev_attr_auto_fan2_channel.dev_attr.attr,
908  &sensor_dev_attr_temp3_input.dev_attr.attr,
909  &sensor_dev_attr_temp3_offset.dev_attr.attr,
910  &sensor_dev_attr_temp3_min.dev_attr.attr,
911  &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
912  &sensor_dev_attr_temp3_max.dev_attr.attr,
913  &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
914  &sensor_dev_attr_temp3_crit.dev_attr.attr,
915  &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
916  &sensor_dev_attr_temp3_fault.dev_attr.attr,
917  &sensor_dev_attr_auto_temp3_off.dev_attr.attr,
918  &sensor_dev_attr_auto_temp3_min.dev_attr.attr,
919  &sensor_dev_attr_auto_temp3_max.dev_attr.attr,
920  &sensor_dev_attr_auto_fan2_min_pwm.dev_attr.attr,
921  NULL
922 };
923 
924 static const struct attribute_group adm1031_group_opt = {
925  .attrs = adm1031_attributes_opt,
926 };
927 
928 /* Return 0 if detection is successful, -ENODEV otherwise */
929 static int adm1031_detect(struct i2c_client *client,
930  struct i2c_board_info *info)
931 {
932  struct i2c_adapter *adapter = client->adapter;
933  const char *name;
934  int id, co;
935 
936  if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
937  return -ENODEV;
938 
939  id = i2c_smbus_read_byte_data(client, 0x3d);
940  co = i2c_smbus_read_byte_data(client, 0x3e);
941 
942  if (!((id == 0x31 || id == 0x30) && co == 0x41))
943  return -ENODEV;
944  name = (id == 0x30) ? "adm1030" : "adm1031";
945 
946  strlcpy(info->type, name, I2C_NAME_SIZE);
947 
948  return 0;
949 }
950 
951 static int adm1031_probe(struct i2c_client *client,
952  const struct i2c_device_id *id)
953 {
954  struct adm1031_data *data;
955  int err;
956 
957  data = devm_kzalloc(&client->dev, sizeof(struct adm1031_data),
958  GFP_KERNEL);
959  if (!data)
960  return -ENOMEM;
961 
962  i2c_set_clientdata(client, data);
963  data->chip_type = id->driver_data;
964  mutex_init(&data->update_lock);
965 
966  if (data->chip_type == adm1030)
967  data->chan_select_table = &auto_channel_select_table_adm1030;
968  else
969  data->chan_select_table = &auto_channel_select_table_adm1031;
970 
971  /* Initialize the ADM1031 chip */
972  adm1031_init_client(client);
973 
974  /* Register sysfs hooks */
975  err = sysfs_create_group(&client->dev.kobj, &adm1031_group);
976  if (err)
977  return err;
978 
979  if (data->chip_type == adm1031) {
980  err = sysfs_create_group(&client->dev.kobj, &adm1031_group_opt);
981  if (err)
982  goto exit_remove;
983  }
984 
985  data->hwmon_dev = hwmon_device_register(&client->dev);
986  if (IS_ERR(data->hwmon_dev)) {
987  err = PTR_ERR(data->hwmon_dev);
988  goto exit_remove;
989  }
990 
991  return 0;
992 
993 exit_remove:
994  sysfs_remove_group(&client->dev.kobj, &adm1031_group);
995  sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
996  return err;
997 }
998 
999 static int adm1031_remove(struct i2c_client *client)
1000 {
1001  struct adm1031_data *data = i2c_get_clientdata(client);
1002 
1003  hwmon_device_unregister(data->hwmon_dev);
1004  sysfs_remove_group(&client->dev.kobj, &adm1031_group);
1005  sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
1006  return 0;
1007 }
1008 
1009 static void adm1031_init_client(struct i2c_client *client)
1010 {
1011  unsigned int read_val;
1012  unsigned int mask;
1013  int i;
1014  struct adm1031_data *data = i2c_get_clientdata(client);
1015 
1016  mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE);
1017  if (data->chip_type == adm1031) {
1018  mask |= (ADM1031_CONF2_PWM2_ENABLE |
1019  ADM1031_CONF2_TACH2_ENABLE);
1020  }
1021  /* Initialize the ADM1031 chip (enables fan speed reading ) */
1022  read_val = adm1031_read_value(client, ADM1031_REG_CONF2);
1023  if ((read_val | mask) != read_val)
1024  adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask);
1025 
1026  read_val = adm1031_read_value(client, ADM1031_REG_CONF1);
1027  if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) {
1028  adm1031_write_value(client, ADM1031_REG_CONF1,
1029  read_val | ADM1031_CONF1_MONITOR_ENABLE);
1030  }
1031 
1032  /* Read the chip's update rate */
1033  mask = ADM1031_UPDATE_RATE_MASK;
1034  read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
1035  i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT;
1036  /* Save it as update interval */
1037  data->update_interval = update_intervals[i];
1038 }
1039 
1040 static struct adm1031_data *adm1031_update_device(struct device *dev)
1041 {
1042  struct i2c_client *client = to_i2c_client(dev);
1043  struct adm1031_data *data = i2c_get_clientdata(client);
1044  unsigned long next_update;
1045  int chan;
1046 
1047  mutex_lock(&data->update_lock);
1048 
1049  next_update = data->last_updated
1050  + msecs_to_jiffies(data->update_interval);
1051  if (time_after(jiffies, next_update) || !data->valid) {
1052 
1053  dev_dbg(&client->dev, "Starting adm1031 update\n");
1054  for (chan = 0;
1055  chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) {
1056  u8 oldh, newh;
1057 
1058  oldh =
1059  adm1031_read_value(client, ADM1031_REG_TEMP(chan));
1060  data->ext_temp[chan] =
1061  adm1031_read_value(client, ADM1031_REG_EXT_TEMP);
1062  newh =
1063  adm1031_read_value(client, ADM1031_REG_TEMP(chan));
1064  if (newh != oldh) {
1065  data->ext_temp[chan] =
1066  adm1031_read_value(client,
1067  ADM1031_REG_EXT_TEMP);
1068 #ifdef DEBUG
1069  oldh =
1070  adm1031_read_value(client,
1071  ADM1031_REG_TEMP(chan));
1072 
1073  /* oldh is actually newer */
1074  if (newh != oldh)
1075  dev_warn(&client->dev,
1076  "Remote temperature may be wrong.\n");
1077 #endif
1078  }
1079  data->temp[chan] = newh;
1080 
1081  data->temp_offset[chan] =
1082  adm1031_read_value(client,
1083  ADM1031_REG_TEMP_OFFSET(chan));
1084  data->temp_min[chan] =
1085  adm1031_read_value(client,
1086  ADM1031_REG_TEMP_MIN(chan));
1087  data->temp_max[chan] =
1088  adm1031_read_value(client,
1089  ADM1031_REG_TEMP_MAX(chan));
1090  data->temp_crit[chan] =
1091  adm1031_read_value(client,
1092  ADM1031_REG_TEMP_CRIT(chan));
1093  data->auto_temp[chan] =
1094  adm1031_read_value(client,
1095  ADM1031_REG_AUTO_TEMP(chan));
1096 
1097  }
1098 
1099  data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1);
1100  data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2);
1101 
1102  data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0))
1103  | (adm1031_read_value(client, ADM1031_REG_STATUS(1)) << 8);
1104  if (data->chip_type == adm1030)
1105  data->alarm &= 0xc0ff;
1106 
1107  for (chan = 0; chan < (data->chip_type == adm1030 ? 1 : 2);
1108  chan++) {
1109  data->fan_div[chan] =
1110  adm1031_read_value(client,
1111  ADM1031_REG_FAN_DIV(chan));
1112  data->fan_min[chan] =
1113  adm1031_read_value(client,
1114  ADM1031_REG_FAN_MIN(chan));
1115  data->fan[chan] =
1116  adm1031_read_value(client,
1117  ADM1031_REG_FAN_SPEED(chan));
1118  data->pwm[chan] =
1119  (adm1031_read_value(client,
1120  ADM1031_REG_PWM) >> (4 * chan)) & 0x0f;
1121  }
1122  data->last_updated = jiffies;
1123  data->valid = 1;
1124  }
1125 
1126  mutex_unlock(&data->update_lock);
1127 
1128  return data;
1129 }
1130 
1131 module_i2c_driver(adm1031_driver);
1132 
1133 MODULE_AUTHOR("Alexandre d'Alton <[email protected]>");
1134 MODULE_DESCRIPTION("ADM1031/ADM1030 driver");
1135 MODULE_LICENSE("GPL");
Generated on Thu Jan 10 2013 13:34:34 for Linux Kernel by   doxygen 1.8.2